src/resolve/resolved-link-bus.c

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