src/network/networkd-link-bus.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <net/if.h>
   4 #include <netinet/in.h>
   5 #include <sys/capability.h>
   6
   7 #include "alloc-util.h"
   8 #include "bus-common-errors.h"
   9 #include "bus-get-properties.h"
  10 #include "bus-message-util.h"
  11 #include "bus-polkit.h"
  12 #include "dns-domain.h"
  13 #include "networkd-json.h"
  14 #include "networkd-link-bus.h"
  15 #include "networkd-link.h"
  16 #include "networkd-manager.h"
  17 #include "networkd-state-file.h"
  18 #include "parse-util.h"
  19 #include "resolve-util.h"
  20 #include "socket-netlink.h"
  21 #include "strv.h"
  22 #include "user-util.h"
  23
  24 BUS_DEFINE_PROPERTY_GET_ENUM(property_get_operational_state, link_operstate, LinkOperationalState);
  25 BUS_DEFINE_PROPERTY_GET_ENUM(property_get_carrier_state, link_carrier_state, LinkCarrierState);
  26 BUS_DEFINE_PROPERTY_GET_ENUM(property_get_address_state, link_address_state, LinkAddressState);
  27 BUS_DEFINE_PROPERTY_GET_ENUM(property_get_online_state, link_online_state, LinkOnlineState);
  28 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_administrative_state, link_state, LinkState);
  29
  30 static int property_get_bit_rates(
  31                 sd_bus *bus,
  32                 const char *path,
  33                 const char *interface,
  34                 const char *property,
  35                 sd_bus_message *reply,
  36                 void *userdata,
  37                 sd_bus_error *error) {
  38
  39         Link *link = ASSERT_PTR(userdata);
  40         Manager *manager;
  41         double interval_sec;
  42         uint64_t tx, rx;
  43
  44         assert(bus);
  45         assert(reply);
  46
  47         manager = link->manager;
  48
  49         if (!manager->use_speed_meter ||
  50             manager->speed_meter_usec_old == 0 ||
  51             !link->stats_updated)
  52                 return sd_bus_message_append(reply, "(tt)", UINT64_MAX, UINT64_MAX);
  53
  54         assert(manager->speed_meter_usec_new > manager->speed_meter_usec_old);
  55         interval_sec = (manager->speed_meter_usec_new - manager->speed_meter_usec_old) / USEC_PER_SEC;
  56
  57         if (link->stats_new.tx_bytes > link->stats_old.tx_bytes)
  58                 tx = (uint64_t) ((link->stats_new.tx_bytes - link->stats_old.tx_bytes) / interval_sec);
  59         else
  60                 tx = (uint64_t) ((UINT64_MAX - (link->stats_old.tx_bytes - link->stats_new.tx_bytes)) / interval_sec);
  61
  62         if (link->stats_new.rx_bytes > link->stats_old.rx_bytes)
  63                 rx = (uint64_t) ((link->stats_new.rx_bytes - link->stats_old.rx_bytes) / interval_sec);
  64         else
  65                 rx = (uint64_t) ((UINT64_MAX - (link->stats_old.rx_bytes - link->stats_new.rx_bytes)) / interval_sec);
  66
  67         return sd_bus_message_append(reply, "(tt)", tx, rx);
  68 }
  69
  70 static int verify_managed_link(Link *l, sd_bus_error *error) {
  71         assert(l);
  72
  73         if (l->flags & IFF_LOOPBACK)
  74                 return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is loopback device.", l->ifname);
  75
  76         return 0;
  77 }
  78
  79 int bus_link_method_set_ntp_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
  80         _cleanup_strv_free_ char **ntp = NULL;
  81         Link *l = ASSERT_PTR(userdata);
  82         int r;
  83
  84         assert(message);
  85
  86         r = verify_managed_link(l, error);
  87         if (r < 0)
  88                 return r;
  89
  90         r = sd_bus_message_read_strv(message, &ntp);
  91         if (r < 0)
  92                 return r;
  93
  94         STRV_FOREACH(i, ntp) {
  95                 r = dns_name_is_valid_or_address(*i);
  96                 if (r < 0)
  97                         return r;
  98                 if (r == 0)
  99                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid NTP server: %s", *i);
 100         }
 101
 102         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 103                                     "org.freedesktop.network1.set-ntp-servers",
 104                                     NULL, true, UID_INVALID,
 105                                     &l->manager->polkit_registry, error);
 106         if (r < 0)
 107                 return r;
 108         if (r == 0)
 109                 return 1; /* Polkit will call us back */
 110
 111         strv_free_and_replace(l->ntp, ntp);
 112
 113         link_dirty(l);
 114         r = link_save_and_clean(l);
 115         if (r < 0)
 116                 return r;
 117
 118         return sd_bus_reply_method_return(message, NULL);
 119 }
 120
 121 static int bus_link_method_set_dns_servers_internal(sd_bus_message *message, void *userdata, sd_bus_error *error, bool extended) {
 122         struct in_addr_full **dns;
 123         Link *l = ASSERT_PTR(userdata);
 124         size_t n;
 125         int r;
 126
 127         assert(message);
 128
 129         r = verify_managed_link(l, error);
 130         if (r < 0)
 131                 return r;
 132
 133         r = bus_message_read_dns_servers(message, error, extended, &dns, &n);
 134         if (r < 0)
 135                 return r;
 136
 137         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 138                                     "org.freedesktop.network1.set-dns-servers",
 139                                     NULL, true, UID_INVALID,
 140                                     &l->manager->polkit_registry, error);
 141         if (r < 0)
 142                 goto finalize;
 143         if (r == 0) {
 144                 r = 1; /* Polkit will call us back */
 145                 goto finalize;
 146         }
 147
 148         if (l->n_dns != UINT_MAX)
 149                 for (unsigned i = 0; i < l->n_dns; i++)
 150                         in_addr_full_free(l->dns[i]);
 151
 152         free_and_replace(l->dns, dns);
 153         l->n_dns = n;
 154
 155         link_dirty(l);
 156         r = link_save_and_clean(l);
 157         if (r < 0)
 158                 return r;
 159
 160         return sd_bus_reply_method_return(message, NULL);
 161
 162 finalize:
 163         for (size_t i = 0; i < n; i++)
 164                 in_addr_full_free(dns[i]);
 165         free(dns);
 166
 167         return r;
 168 }
 169
 170 int bus_link_method_set_dns_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 171         return bus_link_method_set_dns_servers_internal(message, userdata, error, false);
 172 }
 173
 174 int bus_link_method_set_dns_servers_ex(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 175         return bus_link_method_set_dns_servers_internal(message, userdata, error, true);
 176 }
 177
 178 int bus_link_method_set_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 179         _cleanup_ordered_set_free_ OrderedSet *search_domains = NULL, *route_domains = NULL;
 180         Link *l = ASSERT_PTR(userdata);
 181         int r;
 182
 183         assert(message);
 184
 185         r = verify_managed_link(l, error);
 186         if (r < 0)
 187                 return r;
 188
 189         r = sd_bus_message_enter_container(message, 'a', "(sb)");
 190         if (r < 0)
 191                 return r;
 192
 193         search_domains = ordered_set_new(&string_hash_ops_free);
 194         if (!search_domains)
 195                 return -ENOMEM;
 196
 197         route_domains = ordered_set_new(&string_hash_ops_free);
 198         if (!route_domains)
 199                 return -ENOMEM;
 200
 201         for (;;) {
 202                 _cleanup_free_ char *str = NULL;
 203                 const char *name;
 204                 int route_only;
 205
 206                 r = sd_bus_message_read(message, "(sb)", &name, &route_only);
 207                 if (r < 0)
 208                         return r;
 209                 if (r == 0)
 210                         break;
 211
 212                 r = dns_name_is_valid(name);
 213                 if (r < 0)
 214                         return r;
 215                 if (r == 0)
 216                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid search domain %s", name);
 217                 if (!route_only && dns_name_is_root(name))
 218                         return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Root domain is not suitable as search domain");
 219
 220                 r = dns_name_normalize(name, 0, &str);
 221                 if (r < 0)
 222                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid search domain %s", name);
 223
 224                 r = ordered_set_consume(route_only ? route_domains : search_domains, TAKE_PTR(str));
 225                 if (r == -EEXIST)
 226                         continue;
 227                 if (r < 0)
 228                         return r;
 229         }
 230
 231         r = sd_bus_message_exit_container(message);
 232         if (r < 0)
 233                 return r;
 234
 235         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 236                                     "org.freedesktop.network1.set-domains",
 237                                     NULL, true, UID_INVALID,
 238                                     &l->manager->polkit_registry, error);
 239         if (r < 0)
 240                 return r;
 241         if (r == 0)
 242                 return 1; /* Polkit will call us back */
 243
 244         ordered_set_free(l->search_domains);
 245         ordered_set_free(l->route_domains);
 246         l->search_domains = TAKE_PTR(search_domains);
 247         l->route_domains = TAKE_PTR(route_domains);
 248
 249         link_dirty(l);
 250         r = link_save_and_clean(l);
 251         if (r < 0)
 252                 return r;
 253
 254         return sd_bus_reply_method_return(message, NULL);
 255 }
 256
 257 int bus_link_method_set_default_route(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 258         Link *l = ASSERT_PTR(userdata);
 259         int r, b;
 260
 261         assert(message);
 262
 263         r = verify_managed_link(l, error);
 264         if (r < 0)
 265                 return r;
 266
 267         r = sd_bus_message_read(message, "b", &b);
 268         if (r < 0)
 269                 return r;
 270
 271         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 272                                     "org.freedesktop.network1.set-default-route",
 273                                     NULL, true, UID_INVALID,
 274                                     &l->manager->polkit_registry, error);
 275         if (r < 0)
 276                 return r;
 277         if (r == 0)
 278                 return 1; /* Polkit will call us back */
 279
 280         if (l->dns_default_route != b) {
 281                 l->dns_default_route = b;
 282
 283                 link_dirty(l);
 284                 r = link_save_and_clean(l);
 285                 if (r < 0)
 286                         return r;
 287         }
 288
 289         return sd_bus_reply_method_return(message, NULL);
 290 }
 291
 292 int bus_link_method_set_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 293         Link *l = ASSERT_PTR(userdata);
 294         ResolveSupport mode;
 295         const char *llmnr;
 296         int r;
 297
 298         assert(message);
 299
 300         r = verify_managed_link(l, error);
 301         if (r < 0)
 302                 return r;
 303
 304         r = sd_bus_message_read(message, "s", &llmnr);
 305         if (r < 0)
 306                 return r;
 307
 308         if (isempty(llmnr))
 309                 mode = RESOLVE_SUPPORT_YES;
 310         else {
 311                 mode = resolve_support_from_string(llmnr);
 312                 if (mode < 0)
 313                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid LLMNR setting: %s", llmnr);
 314         }
 315
 316         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 317                                     "org.freedesktop.network1.set-llmnr",
 318                                     NULL, true, UID_INVALID,
 319                                     &l->manager->polkit_registry, error);
 320         if (r < 0)
 321                 return r;
 322         if (r == 0)
 323                 return 1; /* Polkit will call us back */
 324
 325         if (l->llmnr != mode) {
 326                 l->llmnr = mode;
 327
 328                 link_dirty(l);
 329                 r = link_save_and_clean(l);
 330                 if (r < 0)
 331                         return r;
 332         }
 333
 334         return sd_bus_reply_method_return(message, NULL);
 335 }
 336
 337 int bus_link_method_set_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 338         Link *l = ASSERT_PTR(userdata);
 339         ResolveSupport mode;
 340         const char *mdns;
 341         int r;
 342
 343         assert(message);
 344
 345         r = verify_managed_link(l, error);
 346         if (r < 0)
 347                 return r;
 348
 349         r = sd_bus_message_read(message, "s", &mdns);
 350         if (r < 0)
 351                 return r;
 352
 353         if (isempty(mdns))
 354                 mode = RESOLVE_SUPPORT_NO;
 355         else {
 356                 mode = resolve_support_from_string(mdns);
 357                 if (mode < 0)
 358                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid MulticastDNS setting: %s", mdns);
 359         }
 360
 361         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 362                                     "org.freedesktop.network1.set-mdns",
 363                                     NULL, true, UID_INVALID,
 364                                     &l->manager->polkit_registry, error);
 365         if (r < 0)
 366                 return r;
 367         if (r == 0)
 368                 return 1; /* Polkit will call us back */
 369
 370         if (l->mdns != mode) {
 371                 l->mdns = mode;
 372
 373                 link_dirty(l);
 374                 r = link_save_and_clean(l);
 375                 if (r < 0)
 376                         return r;
 377         }
 378
 379         return sd_bus_reply_method_return(message, NULL);
 380 }
 381
 382 int bus_link_method_set_dns_over_tls(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 383         Link *l = ASSERT_PTR(userdata);
 384         const char *dns_over_tls;
 385         DnsOverTlsMode mode;
 386         int r;
 387
 388         assert(message);
 389
 390         r = verify_managed_link(l, error);
 391         if (r < 0)
 392                 return r;
 393
 394         r = sd_bus_message_read(message, "s", &dns_over_tls);
 395         if (r < 0)
 396                 return r;
 397
 398         if (isempty(dns_over_tls))
 399                 mode = _DNS_OVER_TLS_MODE_INVALID;
 400         else {
 401                 mode = dns_over_tls_mode_from_string(dns_over_tls);
 402                 if (mode < 0)
 403                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSOverTLS setting: %s", dns_over_tls);
 404         }
 405
 406         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 407                                     "org.freedesktop.network1.set-dns-over-tls",
 408                                     NULL, true, UID_INVALID,
 409                                     &l->manager->polkit_registry, error);
 410         if (r < 0)
 411                 return r;
 412         if (r == 0)
 413                 return 1; /* Polkit will call us back */
 414
 415         if (l->dns_over_tls_mode != mode) {
 416                 l->dns_over_tls_mode = mode;
 417
 418                 link_dirty(l);
 419                 r = link_save_and_clean(l);
 420                 if (r < 0)
 421                         return r;
 422         }
 423
 424         return sd_bus_reply_method_return(message, NULL);
 425 }
 426
 427 int bus_link_method_set_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 428         Link *l = ASSERT_PTR(userdata);
 429         const char *dnssec;
 430         DnssecMode mode;
 431         int r;
 432
 433         assert(message);
 434
 435         r = verify_managed_link(l, error);
 436         if (r < 0)
 437                 return r;
 438
 439         r = sd_bus_message_read(message, "s", &dnssec);
 440         if (r < 0)
 441                 return r;
 442
 443         if (isempty(dnssec))
 444                 mode = _DNSSEC_MODE_INVALID;
 445         else {
 446                 mode = dnssec_mode_from_string(dnssec);
 447                 if (mode < 0)
 448                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSSEC setting: %s", dnssec);
 449         }
 450
 451         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 452                                     "org.freedesktop.network1.set-dnssec",
 453                                     NULL, true, UID_INVALID,
 454                                     &l->manager->polkit_registry, error);
 455         if (r < 0)
 456                 return r;
 457         if (r == 0)
 458                 return 1; /* Polkit will call us back */
 459
 460         if (l->dnssec_mode != mode) {
 461                 l->dnssec_mode = mode;
 462
 463                 link_dirty(l);
 464                 r = link_save_and_clean(l);
 465                 if (r < 0)
 466                         return r;
 467         }
 468
 469         return sd_bus_reply_method_return(message, NULL);
 470 }
 471
 472 int bus_link_method_set_dnssec_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 473         _cleanup_set_free_free_ Set *ns = NULL;
 474         _cleanup_strv_free_ char **ntas = NULL;
 475         Link *l = ASSERT_PTR(userdata);
 476         int r;
 477
 478         assert(message);
 479
 480         r = verify_managed_link(l, error);
 481         if (r < 0)
 482                 return r;
 483
 484         r = sd_bus_message_read_strv(message, &ntas);
 485         if (r < 0)
 486                 return r;
 487
 488         STRV_FOREACH(i, ntas) {
 489                 r = dns_name_is_valid(*i);
 490                 if (r < 0)
 491                         return r;
 492                 if (r == 0)
 493                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid negative trust anchor domain: %s", *i);
 494         }
 495
 496         ns = set_new(&dns_name_hash_ops);
 497         if (!ns)
 498                 return -ENOMEM;
 499
 500         STRV_FOREACH(i, ntas) {
 501                 r = set_put_strdup(&ns, *i);
 502                 if (r < 0)
 503                         return r;
 504         }
 505
 506         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 507                                     "org.freedesktop.network1.set-dnssec-negative-trust-anchors",
 508                                     NULL, true, UID_INVALID,
 509                                     &l->manager->polkit_registry, error);
 510         if (r < 0)
 511                 return r;
 512         if (r == 0)
 513                 return 1; /* Polkit will call us back */
 514
 515         set_free_free(l->dnssec_negative_trust_anchors);
 516         l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
 517
 518         link_dirty(l);
 519         r = link_save_and_clean(l);
 520         if (r < 0)
 521                 return r;
 522
 523         return sd_bus_reply_method_return(message, NULL);
 524 }
 525
 526 int bus_link_method_revert_ntp(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 527         Link *l = ASSERT_PTR(userdata);
 528         int r;
 529
 530         assert(message);
 531
 532         r = verify_managed_link(l, error);
 533         if (r < 0)
 534                 return r;
 535
 536         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 537                                     "org.freedesktop.network1.revert-ntp",
 538                                     NULL, true, UID_INVALID,
 539                                     &l->manager->polkit_registry, error);
 540         if (r < 0)
 541                 return r;
 542         if (r == 0)
 543                 return 1; /* Polkit will call us back */
 544
 545         link_ntp_settings_clear(l);
 546
 547         link_dirty(l);
 548         r = link_save_and_clean(l);
 549         if (r < 0)
 550                 return r;
 551
 552         return sd_bus_reply_method_return(message, NULL);
 553 }
 554
 555 int bus_link_method_revert_dns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 556         Link *l = ASSERT_PTR(userdata);
 557         int r;
 558
 559         assert(message);
 560
 561         r = verify_managed_link(l, error);
 562         if (r < 0)
 563                 return r;
 564
 565         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 566                                     "org.freedesktop.network1.revert-dns",
 567                                     NULL, true, UID_INVALID,
 568                                     &l->manager->polkit_registry, error);
 569         if (r < 0)
 570                 return r;
 571         if (r == 0)
 572                 return 1; /* Polkit will call us back */
 573
 574         link_dns_settings_clear(l);
 575
 576         link_dirty(l);
 577         r = link_save_and_clean(l);
 578         if (r < 0)
 579                 return r;
 580
 581         return sd_bus_reply_method_return(message, NULL);
 582 }
 583
 584 int bus_link_method_force_renew(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 585         Link *l = ASSERT_PTR(userdata);
 586         int r;
 587
 588         if (!l->network)
 589                 return sd_bus_error_setf(error, BUS_ERROR_UNMANAGED_INTERFACE,
 590                                          "Interface %s is not managed by systemd-networkd",
 591                                          l->ifname);
 592
 593         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 594                                     "org.freedesktop.network1.forcerenew",
 595                                     NULL, true, UID_INVALID,
 596                                     &l->manager->polkit_registry, error);
 597         if (r < 0)
 598                 return r;
 599         if (r == 0)
 600                 return 1; /* Polkit will call us back */
 601
 602         if (l->dhcp_server) {
 603                 r = sd_dhcp_server_forcerenew(l->dhcp_server);
 604                 if (r < 0)
 605                         return r;
 606         }
 607
 608         return sd_bus_reply_method_return(message, NULL);
 609 }
 610
 611 int bus_link_method_renew(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 612         Link *l = ASSERT_PTR(userdata);
 613         int r;
 614
 615         if (!l->network)
 616                 return sd_bus_error_setf(error, BUS_ERROR_UNMANAGED_INTERFACE,
 617                                          "Interface %s is not managed by systemd-networkd",
 618                                          l->ifname);
 619
 620         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 621                                     "org.freedesktop.network1.renew",
 622                                     NULL, true, UID_INVALID,
 623                                     &l->manager->polkit_registry, error);
 624         if (r < 0)
 625                 return r;
 626         if (r == 0)
 627                 return 1; /* Polkit will call us back */
 628
 629         if (l->dhcp_client) {
 630                 r = sd_dhcp_client_send_renew(l->dhcp_client);
 631                 if (r < 0)
 632                         return r;
 633         }
 634
 635         return sd_bus_reply_method_return(message, NULL);
 636 }
 637
 638 int bus_link_method_reconfigure(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 639         Link *l = ASSERT_PTR(userdata);
 640         int r;
 641
 642         assert(message);
 643
 644         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 645                                     "org.freedesktop.network1.reconfigure",
 646                                     NULL, true, UID_INVALID,
 647                                     &l->manager->polkit_registry, error);
 648         if (r < 0)
 649                 return r;
 650         if (r == 0)
 651                 return 1; /* Polkit will call us back */
 652
 653         r = link_reconfigure(l, /* force = */ true);
 654         if (r < 0)
 655                 return r;
 656         if (r > 0) {
 657                 link_set_state(l, LINK_STATE_INITIALIZED);
 658                 r = link_save_and_clean(l);
 659                 if (r < 0)
 660                         return r;
 661         }
 662
 663         return sd_bus_reply_method_return(message, NULL);
 664 }
 665
 666 int bus_link_method_describe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 667         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 668         _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
 669         _cleanup_free_ char *text = NULL;
 670         Link *link = ASSERT_PTR(userdata);
 671         int r;
 672
 673         assert(message);
 674
 675         r = link_build_json(link, &v);
 676         if (r < 0)
 677                 return log_link_error_errno(link, r, "Failed to build JSON data: %m");
 678
 679         r = json_variant_format(v, 0, &text);
 680         if (r < 0)
 681                 return log_link_error_errno(link, r, "Failed to format JSON data: %m");
 682
 683         r = sd_bus_message_new_method_return(message, &reply);
 684         if (r < 0)
 685                 return r;
 686
 687         r = sd_bus_message_append(reply, "s", text);
 688         if (r < 0)
 689                 return r;
 690
 691         return sd_bus_send(NULL, reply, NULL);
 692 }
 693
 694 static const sd_bus_vtable link_vtable[] = {
 695         SD_BUS_VTABLE_START(0),
 696
 697         SD_BUS_PROPERTY("OperationalState", "s", property_get_operational_state, offsetof(Link, operstate), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 698         SD_BUS_PROPERTY("CarrierState", "s", property_get_carrier_state, offsetof(Link, carrier_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 699         SD_BUS_PROPERTY("AddressState", "s", property_get_address_state, offsetof(Link, address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 700         SD_BUS_PROPERTY("IPv4AddressState", "s", property_get_address_state, offsetof(Link, ipv4_address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 701         SD_BUS_PROPERTY("IPv6AddressState", "s", property_get_address_state, offsetof(Link, ipv6_address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 702         SD_BUS_PROPERTY("OnlineState", "s", property_get_online_state, offsetof(Link, online_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 703         SD_BUS_PROPERTY("AdministrativeState", "s", property_get_administrative_state, offsetof(Link, state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 704         SD_BUS_PROPERTY("BitRates", "(tt)", property_get_bit_rates, 0, 0),
 705
 706         SD_BUS_METHOD_WITH_ARGS("SetNTP",
 707                                 SD_BUS_ARGS("as", servers),
 708                                 SD_BUS_NO_RESULT,
 709                                 bus_link_method_set_ntp_servers,
 710                                 SD_BUS_VTABLE_UNPRIVILEGED),
 711         SD_BUS_METHOD_WITH_ARGS("SetDNS",
 712                                 SD_BUS_ARGS("a(iay)", addresses),
 713                                 SD_BUS_NO_RESULT,
 714                                 bus_link_method_set_dns_servers,
 715                                 SD_BUS_VTABLE_UNPRIVILEGED),
 716         SD_BUS_METHOD_WITH_ARGS("SetDNSEx",
 717                                 SD_BUS_ARGS("a(iayqs)", addresses),
 718                                 SD_BUS_NO_RESULT,
 719                                 bus_link_method_set_dns_servers_ex,
 720                                 SD_BUS_VTABLE_UNPRIVILEGED),
 721         SD_BUS_METHOD_WITH_ARGS("SetDomains",
 722                                 SD_BUS_ARGS("a(sb)", domains),
 723                                 SD_BUS_NO_RESULT,
 724                                 bus_link_method_set_domains,
 725                                 SD_BUS_VTABLE_UNPRIVILEGED),
 726         SD_BUS_METHOD_WITH_ARGS("SetDefaultRoute",
 727                                 SD_BUS_ARGS("b", enable),
 728                                 SD_BUS_NO_RESULT,
 729                                 bus_link_method_set_default_route,
 730                                 SD_BUS_VTABLE_UNPRIVILEGED),
 731         SD_BUS_METHOD_WITH_ARGS("SetLLMNR",
 732                                 SD_BUS_ARGS("s", mode),
 733                                 SD_BUS_NO_RESULT,
 734                                 bus_link_method_set_llmnr,
 735                                 SD_BUS_VTABLE_UNPRIVILEGED),
 736         SD_BUS_METHOD_WITH_ARGS("SetMulticastDNS",
 737                                 SD_BUS_ARGS("s", mode),
 738                                 SD_BUS_NO_RESULT,
 739                                 bus_link_method_set_mdns,
 740                                 SD_BUS_VTABLE_UNPRIVILEGED),
 741         SD_BUS_METHOD_WITH_ARGS("SetDNSOverTLS",
 742                                 SD_BUS_ARGS("s", mode),
 743                                 SD_BUS_NO_RESULT,
 744                                 bus_link_method_set_dns_over_tls,
 745                                 SD_BUS_VTABLE_UNPRIVILEGED),
 746         SD_BUS_METHOD_WITH_ARGS("SetDNSSEC",
 747                                 SD_BUS_ARGS("s", mode),
 748                                 SD_BUS_NO_RESULT,
 749                                 bus_link_method_set_dnssec,
 750                                 SD_BUS_VTABLE_UNPRIVILEGED),
 751         SD_BUS_METHOD_WITH_ARGS("SetDNSSECNegativeTrustAnchors",
 752                                 SD_BUS_ARGS("as", names),
 753                                 SD_BUS_NO_RESULT,
 754                                 bus_link_method_set_dnssec_negative_trust_anchors,
 755                                 SD_BUS_VTABLE_UNPRIVILEGED),
 756         SD_BUS_METHOD_WITH_ARGS("RevertNTP",
 757                                 SD_BUS_NO_ARGS,
 758                                 SD_BUS_NO_RESULT,
 759                                 bus_link_method_revert_ntp,
 760                                 SD_BUS_VTABLE_UNPRIVILEGED),
 761         SD_BUS_METHOD_WITH_ARGS("RevertDNS",
 762                                 SD_BUS_NO_ARGS,
 763                                 SD_BUS_NO_RESULT,
 764                                 bus_link_method_revert_dns,
 765                                 SD_BUS_VTABLE_UNPRIVILEGED),
 766         SD_BUS_METHOD_WITH_ARGS("Renew",
 767                                 SD_BUS_NO_ARGS,
 768                                 SD_BUS_NO_RESULT,
 769                                 bus_link_method_renew,
 770                                 SD_BUS_VTABLE_UNPRIVILEGED),
 771         SD_BUS_METHOD_WITH_ARGS("ForceRenew",
 772                                 SD_BUS_NO_ARGS,
 773                                 SD_BUS_NO_RESULT,
 774                                 bus_link_method_force_renew,
 775                                 SD_BUS_VTABLE_UNPRIVILEGED),
 776         SD_BUS_METHOD_WITH_ARGS("Reconfigure",
 777                                 SD_BUS_NO_ARGS,
 778                                 SD_BUS_NO_RESULT,
 779                                 bus_link_method_reconfigure,
 780                                 SD_BUS_VTABLE_UNPRIVILEGED),
 781         SD_BUS_METHOD_WITH_ARGS("Describe",
 782                                 SD_BUS_NO_ARGS,
 783                                 SD_BUS_RESULT("s", json),
 784                                 bus_link_method_describe,
 785                                 SD_BUS_VTABLE_UNPRIVILEGED),
 786
 787         SD_BUS_VTABLE_END
 788 };
 789
 790 char *link_bus_path(Link *link) {
 791         _cleanup_free_ char *ifindex = NULL;
 792         char *p;
 793         int r;
 794
 795         assert(link);
 796         assert(link->ifindex > 0);
 797
 798         if (asprintf(&ifindex, "%d", link->ifindex) < 0)
 799                 return NULL;
 800
 801         r = sd_bus_path_encode("/org/freedesktop/network1/link", ifindex, &p);
 802         if (r < 0)
 803                 return NULL;
 804
 805         return p;
 806 }
 807
 808 int link_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 809         _cleanup_strv_free_ char **l = NULL;
 810         Manager *m = ASSERT_PTR(userdata);
 811         unsigned c = 0;
 812         Link *link;
 813
 814         assert(bus);
 815         assert(path);
 816         assert(nodes);
 817
 818         l = new0(char*, hashmap_size(m->links_by_index) + 1);
 819         if (!l)
 820                 return -ENOMEM;
 821
 822         HASHMAP_FOREACH(link, m->links_by_index) {
 823                 char *p;
 824
 825                 p = link_bus_path(link);
 826                 if (!p)
 827                         return -ENOMEM;
 828
 829                 l[c++] = p;
 830         }
 831
 832         l[c] = NULL;
 833         *nodes = TAKE_PTR(l);
 834
 835         return 1;
 836 }
 837
 838 int link_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 839         _cleanup_free_ char *identifier = NULL;
 840         Manager *m = ASSERT_PTR(userdata);
 841         Link *link;
 842         int ifindex, r;
 843
 844         assert(bus);
 845         assert(path);
 846         assert(interface);
 847         assert(found);
 848
 849         r = sd_bus_path_decode(path, "/org/freedesktop/network1/link", &identifier);
 850         if (r <= 0)
 851                 return 0;
 852
 853         ifindex = parse_ifindex(identifier);
 854         if (ifindex < 0)
 855                 return 0;
 856
 857         r = link_get_by_index(m, ifindex, &link);
 858         if (r < 0)
 859                 return 0;
 860
 861         if (streq(interface, "org.freedesktop.network1.DHCPServer") &&
 862             (!link->dhcp_server || sd_dhcp_server_is_in_relay_mode(link->dhcp_server)))
 863                 return 0;
 864
 865         *found = link;
 866
 867         return 1;
 868 }
 869
 870 int link_send_changed_strv(Link *link, char **properties) {
 871         _cleanup_free_ char *p = NULL;
 872
 873         assert(link);
 874         assert(link->manager);
 875         assert(properties);
 876
 877         if (sd_bus_is_ready(link->manager->bus) <= 0)
 878                 return 0;
 879
 880         p = link_bus_path(link);
 881         if (!p)
 882                 return -ENOMEM;
 883
 884         return sd_bus_emit_properties_changed_strv(
 885                         link->manager->bus,
 886                         p,
 887                         "org.freedesktop.network1.Link",
 888                         properties);
 889 }
 890
 891 int link_send_changed(Link *link, const char *property, ...) {
 892         char **properties;
 893
 894         properties = strv_from_stdarg_alloca(property);
 895
 896         return link_send_changed_strv(link, properties);
 897 }
 898
 899 const BusObjectImplementation link_object = {
 900         "/org/freedesktop/network1/link",
 901         "org.freedesktop.network1.Link",
 902         .fallback_vtables = BUS_FALLBACK_VTABLES({link_vtable, link_object_find}),
 903         .node_enumerator = link_node_enumerator,
 904 };