src/resolve/resolved-link-bus.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   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 "parse-util.h"
  13 #include "resolve-util.h"
  14 #include "resolved-bus.h"
  15 #include "resolved-link-bus.h"
  16 #include "resolved-resolv-conf.h"
  17 #include "socket-netlink.h"
  18 #include "stdio-util.h"
  19 #include "strv.h"
  20 #include "user-util.h"
  21
  22 static BUS_DEFINE_PROPERTY_GET(property_get_dnssec_supported, "b", Link, link_dnssec_supported);
  23 static BUS_DEFINE_PROPERTY_GET2(property_get_dnssec_mode, "s", Link, link_get_dnssec_mode, dnssec_mode_to_string);
  24
  25 static int property_get_dns_over_tls_mode(
  26                 sd_bus *bus,
  27                 const char *path,
  28                 const char *interface,
  29                 const char *property,
  30                 sd_bus_message *reply,
  31                 void *userdata,
  32                 sd_bus_error *error) {
  33
  34         Link *l = userdata;
  35
  36         assert(reply);
  37         assert(l);
  38
  39         return sd_bus_message_append(reply, "s", dns_over_tls_mode_to_string(link_get_dns_over_tls_mode(l)));
  40 }
  41
  42 static int property_get_dns_internal(
  43                 sd_bus *bus,
  44                 const char *path,
  45                 const char *interface,
  46                 const char *property,
  47                 sd_bus_message *reply,
  48                 void *userdata,
  49                 sd_bus_error *error,
  50                 bool extended) {
  51
  52         Link *l = userdata;
  53         DnsServer *s;
  54         int r;
  55
  56         assert(reply);
  57         assert(l);
  58
  59         r = sd_bus_message_open_container(reply, 'a', extended ? "(iayqs)" : "(iay)");
  60         if (r < 0)
  61                 return r;
  62
  63         LIST_FOREACH(servers, s, l->dns_servers) {
  64                 r = bus_dns_server_append(reply, s, false, extended);
  65                 if (r < 0)
  66                         return r;
  67         }
  68
  69         return sd_bus_message_close_container(reply);
  70 }
  71
  72 static int property_get_dns(
  73                 sd_bus *bus,
  74                 const char *path,
  75                 const char *interface,
  76                 const char *property,
  77                 sd_bus_message *reply,
  78                 void *userdata,
  79                 sd_bus_error *error) {
  80         return property_get_dns_internal(bus, path, interface, property, reply, userdata, error, false);
  81 }
  82
  83 static int property_get_dns_ex(
  84                 sd_bus *bus,
  85                 const char *path,
  86                 const char *interface,
  87                 const char *property,
  88                 sd_bus_message *reply,
  89                 void *userdata,
  90                 sd_bus_error *error) {
  91         return property_get_dns_internal(bus, path, interface, property, reply, userdata, error, true);
  92 }
  93
  94 static int property_get_current_dns_server_internal(
  95                 sd_bus *bus,
  96                 const char *path,
  97                 const char *interface,
  98                 const char *property,
  99                 sd_bus_message *reply,
 100                 void *userdata,
 101                 sd_bus_error *error,
 102                 bool extended) {
 103
 104         DnsServer *s;
 105
 106         assert(reply);
 107         assert(userdata);
 108
 109         s = *(DnsServer **) userdata;
 110
 111         return bus_dns_server_append(reply, s, false, extended);
 112 }
 113
 114 static int property_get_current_dns_server(
 115                 sd_bus *bus,
 116                 const char *path,
 117                 const char *interface,
 118                 const char *property,
 119                 sd_bus_message *reply,
 120                 void *userdata,
 121                 sd_bus_error *error) {
 122         return property_get_current_dns_server_internal(bus, path, interface, property, reply, userdata, error, false);
 123 }
 124
 125 static int property_get_current_dns_server_ex(
 126                 sd_bus *bus,
 127                 const char *path,
 128                 const char *interface,
 129                 const char *property,
 130                 sd_bus_message *reply,
 131                 void *userdata,
 132                 sd_bus_error *error) {
 133         return property_get_current_dns_server_internal(bus, path, interface, property, reply, userdata, error, true);
 134 }
 135
 136 static int property_get_domains(
 137                 sd_bus *bus,
 138                 const char *path,
 139                 const char *interface,
 140                 const char *property,
 141                 sd_bus_message *reply,
 142                 void *userdata,
 143                 sd_bus_error *error) {
 144
 145         Link *l = userdata;
 146         DnsSearchDomain *d;
 147         int r;
 148
 149         assert(reply);
 150         assert(l);
 151
 152         r = sd_bus_message_open_container(reply, 'a', "(sb)");
 153         if (r < 0)
 154                 return r;
 155
 156         LIST_FOREACH(domains, d, l->search_domains) {
 157                 r = sd_bus_message_append(reply, "(sb)", d->name, d->route_only);
 158                 if (r < 0)
 159                         return r;
 160         }
 161
 162         return sd_bus_message_close_container(reply);
 163 }
 164
 165 static int property_get_default_route(
 166                 sd_bus *bus,
 167                 const char *path,
 168                 const char *interface,
 169                 const char *property,
 170                 sd_bus_message *reply,
 171                 void *userdata,
 172                 sd_bus_error *error) {
 173
 174         Link *l = userdata;
 175
 176         assert(reply);
 177         assert(l);
 178
 179         /* Return what is configured, if there's something configured */
 180         if (l->default_route >= 0)
 181                 return sd_bus_message_append(reply, "b", l->default_route);
 182
 183         /* Otherwise report what is in effect */
 184         if (l->unicast_scope)
 185                 return sd_bus_message_append(reply, "b", dns_scope_is_default_route(l->unicast_scope));
 186
 187         return sd_bus_message_append(reply, "b", false);
 188 }
 189
 190 static int property_get_scopes_mask(
 191                 sd_bus *bus,
 192                 const char *path,
 193                 const char *interface,
 194                 const char *property,
 195                 sd_bus_message *reply,
 196                 void *userdata,
 197                 sd_bus_error *error) {
 198
 199         Link *l = userdata;
 200         uint64_t mask;
 201
 202         assert(reply);
 203         assert(l);
 204
 205         mask =  (l->unicast_scope ? SD_RESOLVED_DNS : 0) |
 206                 (l->llmnr_ipv4_scope ? SD_RESOLVED_LLMNR_IPV4 : 0) |
 207                 (l->llmnr_ipv6_scope ? SD_RESOLVED_LLMNR_IPV6 : 0) |
 208                 (l->mdns_ipv4_scope ? SD_RESOLVED_MDNS_IPV4 : 0) |
 209                 (l->mdns_ipv6_scope ? SD_RESOLVED_MDNS_IPV6 : 0);
 210
 211         return sd_bus_message_append(reply, "t", mask);
 212 }
 213
 214 static int property_get_ntas(
 215                 sd_bus *bus,
 216                 const char *path,
 217                 const char *interface,
 218                 const char *property,
 219                 sd_bus_message *reply,
 220                 void *userdata,
 221                 sd_bus_error *error) {
 222
 223         Link *l = userdata;
 224         const char *name;
 225         Iterator i;
 226         int r;
 227
 228         assert(reply);
 229         assert(l);
 230
 231         r = sd_bus_message_open_container(reply, 'a', "s");
 232         if (r < 0)
 233                 return r;
 234
 235         SET_FOREACH(name, l->dnssec_negative_trust_anchors, i) {
 236                 r = sd_bus_message_append(reply, "s", name);
 237                 if (r < 0)
 238                         return r;
 239         }
 240
 241         return sd_bus_message_close_container(reply);
 242 }
 243
 244 static int verify_unmanaged_link(Link *l, sd_bus_error *error) {
 245         assert(l);
 246
 247         if (l->flags & IFF_LOOPBACK)
 248                 return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is loopback device.", l->ifname);
 249         if (l->is_managed)
 250                 return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is managed.", l->ifname);
 251
 252         return 0;
 253 }
 254
 255 static int bus_link_method_set_dns_servers_internal(sd_bus_message *message, void *userdata, sd_bus_error *error, bool extended) {
 256         struct in_addr_full **dns;
 257         Link *l = userdata;
 258         size_t n;
 259         int r;
 260
 261         assert(message);
 262         assert(l);
 263
 264         r = verify_unmanaged_link(l, error);
 265         if (r < 0)
 266                 return r;
 267
 268         r = bus_message_read_dns_servers(message, error, extended, &dns, &n);
 269         if (r < 0)
 270                 return r;
 271
 272         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 273                                     "org.freedesktop.resolve1.set-dns-servers",
 274                                     NULL, true, UID_INVALID,
 275                                     &l->manager->polkit_registry, error);
 276         if (r < 0)
 277                 goto finalize;
 278         if (r == 0) {
 279                 r = 1; /* Polkit will call us back */
 280                 goto finalize;
 281         }
 282
 283         dns_server_mark_all(l->dns_servers);
 284
 285         for (size_t i = 0; i < n; i++) {
 286                 DnsServer *s;
 287
 288                 s = dns_server_find(l->dns_servers, dns[i]->family, &dns[i]->address, dns[i]->port, 0, dns[i]->server_name);
 289                 if (s)
 290                         dns_server_move_back_and_unmark(s);
 291                 else {
 292                         r = dns_server_new(l->manager, NULL, DNS_SERVER_LINK, l, dns[i]->family, &dns[i]->address, dns[i]->port, 0, dns[i]->server_name);
 293                         if (r < 0) {
 294                                 dns_server_unlink_all(l->dns_servers);
 295                                 goto finalize;
 296                         }
 297                 }
 298
 299         }
 300
 301         dns_server_unlink_marked(l->dns_servers);
 302         link_allocate_scopes(l);
 303
 304         (void) link_save_user(l);
 305         (void) manager_write_resolv_conf(l->manager);
 306         (void) manager_send_changed(l->manager, "DNS");
 307
 308         r = sd_bus_reply_method_return(message, NULL);
 309
 310 finalize:
 311         for (size_t i = 0; i < n; i++)
 312                 in_addr_full_free(dns[i]);
 313         free(dns);
 314
 315         return r;
 316 }
 317
 318 int bus_link_method_set_dns_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 319         return bus_link_method_set_dns_servers_internal(message, userdata, error, false);
 320 }
 321
 322 int bus_link_method_set_dns_servers_ex(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 323         return bus_link_method_set_dns_servers_internal(message, userdata, error, true);
 324 }
 325
 326 int bus_link_method_set_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 327         Link *l = userdata;
 328         int r;
 329
 330         assert(message);
 331         assert(l);
 332
 333         r = verify_unmanaged_link(l, error);
 334         if (r < 0)
 335                 return r;
 336
 337         r = sd_bus_message_enter_container(message, 'a', "(sb)");
 338         if (r < 0)
 339                 return r;
 340
 341         for (;;) {
 342                 const char *name;
 343                 int route_only;
 344
 345                 r = sd_bus_message_read(message, "(sb)", &name, &route_only);
 346                 if (r < 0)
 347                         return r;
 348                 if (r == 0)
 349                         break;
 350
 351                 r = dns_name_is_valid(name);
 352                 if (r < 0)
 353                         return r;
 354                 if (r == 0)
 355                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid search domain %s", name);
 356                 if (!route_only && dns_name_is_root(name))
 357                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Root domain is not suitable as search domain");
 358         }
 359
 360         r = sd_bus_message_rewind(message, false);
 361         if (r < 0)
 362                 return r;
 363
 364         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 365                                     "org.freedesktop.resolve1.set-domains",
 366                                     NULL, true, UID_INVALID,
 367                                     &l->manager->polkit_registry, error);
 368         if (r < 0)
 369                 return r;
 370         if (r == 0)
 371                 return 1; /* Polkit will call us back */
 372
 373         dns_search_domain_mark_all(l->search_domains);
 374
 375         for (;;) {
 376                 DnsSearchDomain *d;
 377                 const char *name;
 378                 int route_only;
 379
 380                 r = sd_bus_message_read(message, "(sb)", &name, &route_only);
 381                 if (r < 0)
 382                         goto clear;
 383                 if (r == 0)
 384                         break;
 385
 386                 r = dns_search_domain_find(l->search_domains, name, &d);
 387                 if (r < 0)
 388                         goto clear;
 389
 390                 if (r > 0)
 391                         dns_search_domain_move_back_and_unmark(d);
 392                 else {
 393                         r = dns_search_domain_new(l->manager, &d, DNS_SEARCH_DOMAIN_LINK, l, name);
 394                         if (r < 0)
 395                                 goto clear;
 396                 }
 397
 398                 d->route_only = route_only;
 399         }
 400
 401         r = sd_bus_message_exit_container(message);
 402         if (r < 0)
 403                 goto clear;
 404
 405         dns_search_domain_unlink_marked(l->search_domains);
 406
 407         (void) link_save_user(l);
 408         (void) manager_write_resolv_conf(l->manager);
 409
 410         return sd_bus_reply_method_return(message, NULL);
 411
 412 clear:
 413         dns_search_domain_unlink_all(l->search_domains);
 414         return r;
 415 }
 416
 417 int bus_link_method_set_default_route(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 418         Link *l = userdata;
 419         int r, b;
 420
 421         assert(message);
 422         assert(l);
 423
 424         r = verify_unmanaged_link(l, error);
 425         if (r < 0)
 426                 return r;
 427
 428         r = sd_bus_message_read(message, "b", &b);
 429         if (r < 0)
 430                 return r;
 431
 432         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 433                                     "org.freedesktop.resolve1.set-default-route",
 434                                     NULL, true, UID_INVALID,
 435                                     &l->manager->polkit_registry, error);
 436         if (r < 0)
 437                 return r;
 438         if (r == 0)
 439                 return 1; /* Polkit will call us back */
 440
 441         if (l->default_route != b) {
 442                 l->default_route = b;
 443
 444                 (void) link_save_user(l);
 445                 (void) manager_write_resolv_conf(l->manager);
 446         }
 447
 448         return sd_bus_reply_method_return(message, NULL);
 449 }
 450
 451 int bus_link_method_set_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 452         Link *l = userdata;
 453         ResolveSupport mode;
 454         const char *llmnr;
 455         int r;
 456
 457         assert(message);
 458         assert(l);
 459
 460         r = verify_unmanaged_link(l, error);
 461         if (r < 0)
 462                 return r;
 463
 464         r = sd_bus_message_read(message, "s", &llmnr);
 465         if (r < 0)
 466                 return r;
 467
 468         if (isempty(llmnr))
 469                 mode = RESOLVE_SUPPORT_YES;
 470         else {
 471                 mode = resolve_support_from_string(llmnr);
 472                 if (mode < 0)
 473                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid LLMNR setting: %s", llmnr);
 474         }
 475
 476         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 477                                     "org.freedesktop.resolve1.set-llmnr",
 478                                     NULL, true, UID_INVALID,
 479                                     &l->manager->polkit_registry, error);
 480         if (r < 0)
 481                 return r;
 482         if (r == 0)
 483                 return 1; /* Polkit will call us back */
 484
 485         l->llmnr_support = mode;
 486         link_allocate_scopes(l);
 487         link_add_rrs(l, false);
 488
 489         (void) link_save_user(l);
 490
 491         return sd_bus_reply_method_return(message, NULL);
 492 }
 493
 494 int bus_link_method_set_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 495         Link *l = userdata;
 496         ResolveSupport mode;
 497         const char *mdns;
 498         int r;
 499
 500         assert(message);
 501         assert(l);
 502
 503         r = verify_unmanaged_link(l, error);
 504         if (r < 0)
 505                 return r;
 506
 507         r = sd_bus_message_read(message, "s", &mdns);
 508         if (r < 0)
 509                 return r;
 510
 511         if (isempty(mdns))
 512                 mode = RESOLVE_SUPPORT_NO;
 513         else {
 514                 mode = resolve_support_from_string(mdns);
 515                 if (mode < 0)
 516                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid MulticastDNS setting: %s", mdns);
 517         }
 518
 519         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 520                                     "org.freedesktop.resolve1.set-mdns",
 521                                     NULL, true, UID_INVALID,
 522                                     &l->manager->polkit_registry, error);
 523         if (r < 0)
 524                 return r;
 525         if (r == 0)
 526                 return 1; /* Polkit will call us back */
 527
 528         l->mdns_support = mode;
 529         link_allocate_scopes(l);
 530         link_add_rrs(l, false);
 531
 532         (void) link_save_user(l);
 533
 534         return sd_bus_reply_method_return(message, NULL);
 535 }
 536
 537 int bus_link_method_set_dns_over_tls(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 538         Link *l = userdata;
 539         const char *dns_over_tls;
 540         DnsOverTlsMode mode;
 541         int r;
 542
 543         assert(message);
 544         assert(l);
 545
 546         r = verify_unmanaged_link(l, error);
 547         if (r < 0)
 548                 return r;
 549
 550         r = sd_bus_message_read(message, "s", &dns_over_tls);
 551         if (r < 0)
 552                 return r;
 553
 554         if (isempty(dns_over_tls))
 555                 mode = _DNS_OVER_TLS_MODE_INVALID;
 556         else {
 557                 mode = dns_over_tls_mode_from_string(dns_over_tls);
 558                 if (mode < 0)
 559                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSOverTLS setting: %s", dns_over_tls);
 560         }
 561
 562         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 563                                     "org.freedesktop.resolve1.set-dns-over-tls",
 564                                     NULL, true, UID_INVALID,
 565                                     &l->manager->polkit_registry, error);
 566         if (r < 0)
 567                 return r;
 568         if (r == 0)
 569                 return 1; /* Polkit will call us back */
 570
 571         link_set_dns_over_tls_mode(l, mode);
 572
 573         (void) link_save_user(l);
 574
 575         return sd_bus_reply_method_return(message, NULL);
 576 }
 577
 578 int bus_link_method_set_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 579         Link *l = userdata;
 580         const char *dnssec;
 581         DnssecMode mode;
 582         int r;
 583
 584         assert(message);
 585         assert(l);
 586
 587         r = verify_unmanaged_link(l, error);
 588         if (r < 0)
 589                 return r;
 590
 591         r = sd_bus_message_read(message, "s", &dnssec);
 592         if (r < 0)
 593                 return r;
 594
 595         if (isempty(dnssec))
 596                 mode = _DNSSEC_MODE_INVALID;
 597         else {
 598                 mode = dnssec_mode_from_string(dnssec);
 599                 if (mode < 0)
 600                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSSEC setting: %s", dnssec);
 601         }
 602
 603         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 604                                     "org.freedesktop.resolve1.set-dnssec",
 605                                     NULL, true, UID_INVALID,
 606                                     &l->manager->polkit_registry, error);
 607         if (r < 0)
 608                 return r;
 609         if (r == 0)
 610                 return 1; /* Polkit will call us back */
 611
 612         link_set_dnssec_mode(l, mode);
 613
 614         (void) link_save_user(l);
 615
 616         return sd_bus_reply_method_return(message, NULL);
 617 }
 618
 619 int bus_link_method_set_dnssec_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 620         _cleanup_set_free_free_ Set *ns = NULL;
 621         _cleanup_strv_free_ char **ntas = NULL;
 622         Link *l = userdata;
 623         int r;
 624         char **i;
 625
 626         assert(message);
 627         assert(l);
 628
 629         r = verify_unmanaged_link(l, error);
 630         if (r < 0)
 631                 return r;
 632
 633         ns = set_new(&dns_name_hash_ops);
 634         if (!ns)
 635                 return -ENOMEM;
 636
 637         r = sd_bus_message_read_strv(message, &ntas);
 638         if (r < 0)
 639                 return r;
 640
 641         STRV_FOREACH(i, ntas) {
 642                 r = dns_name_is_valid(*i);
 643                 if (r < 0)
 644                         return r;
 645                 if (r == 0)
 646                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
 647                                                  "Invalid negative trust anchor domain: %s", *i);
 648
 649                 r = set_put_strdup(&ns, *i);
 650                 if (r < 0)
 651                         return r;
 652         }
 653
 654         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 655                                     "org.freedesktop.resolve1.set-dnssec-negative-trust-anchors",
 656                                     NULL, true, UID_INVALID,
 657                                     &l->manager->polkit_registry, error);
 658         if (r < 0)
 659                 return r;
 660         if (r == 0)
 661                 return 1; /* Polkit will call us back */
 662
 663         set_free_free(l->dnssec_negative_trust_anchors);
 664         l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
 665
 666         (void) link_save_user(l);
 667
 668         return sd_bus_reply_method_return(message, NULL);
 669 }
 670
 671 int bus_link_method_revert(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 672         Link *l = userdata;
 673         int r;
 674
 675         assert(message);
 676         assert(l);
 677
 678         r = verify_unmanaged_link(l, error);
 679         if (r < 0)
 680                 return r;
 681
 682         r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
 683                                     "org.freedesktop.resolve1.revert",
 684                                     NULL, true, UID_INVALID,
 685                                     &l->manager->polkit_registry, error);
 686         if (r < 0)
 687                 return r;
 688         if (r == 0)
 689                 return 1; /* Polkit will call us back */
 690
 691         link_flush_settings(l);
 692         link_allocate_scopes(l);
 693         link_add_rrs(l, false);
 694
 695         (void) link_save_user(l);
 696         (void) manager_write_resolv_conf(l->manager);
 697         (void) manager_send_changed(l->manager, "DNS");
 698
 699         return sd_bus_reply_method_return(message, NULL);
 700 }
 701
 702 static int link_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 703         _cleanup_free_ char *e = NULL;
 704         Manager *m = userdata;
 705         Link *link;
 706         int ifindex, r;
 707
 708         assert(bus);
 709         assert(path);
 710         assert(interface);
 711         assert(found);
 712         assert(m);
 713
 714         r = sd_bus_path_decode(path, "/org/freedesktop/resolve1/link", &e);
 715         if (r <= 0)
 716                 return 0;
 717
 718         ifindex = parse_ifindex(e);
 719         if (ifindex < 0)
 720                 return 0;
 721
 722         link = hashmap_get(m->links, INT_TO_PTR(ifindex));
 723         if (!link)
 724                 return 0;
 725
 726         *found = link;
 727         return 1;
 728 }
 729
 730 char *link_bus_path(const Link *link) {
 731         char *p, ifindex[DECIMAL_STR_MAX(link->ifindex)];
 732         int r;
 733
 734         assert(link);
 735
 736         xsprintf(ifindex, "%i", link->ifindex);
 737
 738         r = sd_bus_path_encode("/org/freedesktop/resolve1/link", ifindex, &p);
 739         if (r < 0)
 740                 return NULL;
 741
 742         return p;
 743 }
 744
 745 static int link_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 746         _cleanup_strv_free_ char **l = NULL;
 747         Manager *m = userdata;
 748         Link *link;
 749         Iterator i;
 750         unsigned c = 0;
 751
 752         assert(bus);
 753         assert(path);
 754         assert(m);
 755         assert(nodes);
 756
 757         l = new0(char*, hashmap_size(m->links) + 1);
 758         if (!l)
 759                 return -ENOMEM;
 760
 761         HASHMAP_FOREACH(link, m->links, i) {
 762                 char *p;
 763
 764                 p = link_bus_path(link);
 765                 if (!p)
 766                         return -ENOMEM;
 767
 768                 l[c++] = p;
 769         }
 770
 771         l[c] = NULL;
 772         *nodes = TAKE_PTR(l);
 773
 774         return 1;
 775 }
 776
 777 static const sd_bus_vtable link_vtable[] = {
 778         SD_BUS_VTABLE_START(0),
 779
 780         SD_BUS_PROPERTY("ScopesMask", "t", property_get_scopes_mask, 0, 0),
 781         SD_BUS_PROPERTY("DNS", "a(iay)", property_get_dns, 0, 0),
 782         SD_BUS_PROPERTY("DNSEx", "a(iayqs)", property_get_dns_ex, 0, 0),
 783         SD_BUS_PROPERTY("CurrentDNSServer", "(iay)", property_get_current_dns_server, offsetof(Link, current_dns_server), 0),
 784         SD_BUS_PROPERTY("CurrentDNSServerEx", "(iayqs)", property_get_current_dns_server_ex, offsetof(Link, current_dns_server), 0),
 785         SD_BUS_PROPERTY("Domains", "a(sb)", property_get_domains, 0, 0),
 786         SD_BUS_PROPERTY("DefaultRoute", "b", property_get_default_route, 0, 0),
 787         SD_BUS_PROPERTY("LLMNR", "s", bus_property_get_resolve_support, offsetof(Link, llmnr_support), 0),
 788         SD_BUS_PROPERTY("MulticastDNS", "s", bus_property_get_resolve_support, offsetof(Link, mdns_support), 0),
 789         SD_BUS_PROPERTY("DNSOverTLS", "s", property_get_dns_over_tls_mode, 0, 0),
 790         SD_BUS_PROPERTY("DNSSEC", "s", property_get_dnssec_mode, 0, 0),
 791         SD_BUS_PROPERTY("DNSSECNegativeTrustAnchors", "as", property_get_ntas, 0, 0),
 792         SD_BUS_PROPERTY("DNSSECSupported", "b", property_get_dnssec_supported, 0, 0),
 793
 794         SD_BUS_METHOD_WITH_ARGS("SetDNS",
 795                                 SD_BUS_ARGS("a(iay)", addresses),
 796                                 SD_BUS_NO_RESULT,
 797                                 bus_link_method_set_dns_servers,
 798                                 SD_BUS_VTABLE_UNPRIVILEGED),
 799         SD_BUS_METHOD_WITH_ARGS("SetDNSEx",
 800                                 SD_BUS_ARGS("a(iayqs)", addresses),
 801                                 SD_BUS_NO_RESULT,
 802                                 bus_link_method_set_dns_servers_ex,
 803                                 SD_BUS_VTABLE_UNPRIVILEGED),
 804         SD_BUS_METHOD_WITH_ARGS("SetDomains",
 805                                 SD_BUS_ARGS("a(sb)", domains),
 806                                 SD_BUS_NO_RESULT,
 807                                 bus_link_method_set_domains,
 808                                 SD_BUS_VTABLE_UNPRIVILEGED),
 809         SD_BUS_METHOD_WITH_ARGS("SetDefaultRoute",
 810                                 SD_BUS_ARGS("b", enable),
 811                                 SD_BUS_NO_RESULT,
 812                                 bus_link_method_set_default_route,
 813                                 SD_BUS_VTABLE_UNPRIVILEGED),
 814         SD_BUS_METHOD_WITH_ARGS("SetLLMNR",
 815                                 SD_BUS_ARGS("s", mode),
 816                                 SD_BUS_NO_RESULT,
 817                                 bus_link_method_set_llmnr,
 818                                 SD_BUS_VTABLE_UNPRIVILEGED),
 819         SD_BUS_METHOD_WITH_ARGS("SetMulticastDNS",
 820                                 SD_BUS_ARGS("s", mode),
 821                                 SD_BUS_NO_RESULT,
 822                                 bus_link_method_set_mdns,
 823                                 SD_BUS_VTABLE_UNPRIVILEGED),
 824         SD_BUS_METHOD_WITH_ARGS("SetDNSOverTLS",
 825                                 SD_BUS_ARGS("s", mode),
 826                                 SD_BUS_NO_RESULT,
 827                                 bus_link_method_set_dns_over_tls,
 828                                 SD_BUS_VTABLE_UNPRIVILEGED),
 829         SD_BUS_METHOD_WITH_ARGS("SetDNSSEC",
 830                                 SD_BUS_ARGS("s", mode),
 831                                 SD_BUS_NO_RESULT,
 832                                 bus_link_method_set_dnssec,
 833                                 SD_BUS_VTABLE_UNPRIVILEGED),
 834         SD_BUS_METHOD_WITH_ARGS("SetDNSSECNegativeTrustAnchors",
 835                                 SD_BUS_ARGS("as", names),
 836                                 SD_BUS_NO_RESULT,
 837                                 bus_link_method_set_dnssec_negative_trust_anchors,
 838                                 SD_BUS_VTABLE_UNPRIVILEGED),
 839         SD_BUS_METHOD_WITH_ARGS("Revert",
 840                                 SD_BUS_NO_ARGS,
 841                                 SD_BUS_NO_RESULT,
 842                                 bus_link_method_revert,
 843                                 SD_BUS_VTABLE_UNPRIVILEGED),
 844
 845         SD_BUS_VTABLE_END
 846 };
 847
 848 const BusObjectImplementation link_object = {
 849         "/org/freedesktop/resolve1/link",
 850         "org.freedesktop.resolve1.Link",
 851         .fallback_vtables = BUS_FALLBACK_VTABLES({link_vtable, link_object_find}),
 852         .node_enumerator = link_node_enumerator,
 853 };