src/resolve/resolved-link-bus.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "alloc-util.h"
   4 #include "bus-common-errors.h"
   5 #include "bus-util.h"
   6 #include "parse-util.h"
   7 #include "resolve-util.h"
   8 #include "resolved-bus.h"
   9 #include "resolved-link-bus.h"
  10 #include "resolved-resolv-conf.h"
  11 #include "strv.h"
  12
  13 static BUS_DEFINE_PROPERTY_GET(property_get_dnssec_supported, "b", Link, link_dnssec_supported);
  14 static BUS_DEFINE_PROPERTY_GET2(property_get_dnssec_mode, "s", Link, link_get_dnssec_mode, dnssec_mode_to_string);
  15
  16 static int property_get_dns_over_tls_mode(
  17                 sd_bus *bus,
  18                 const char *path,
  19                 const char *interface,
  20                 const char *property,
  21                 sd_bus_message *reply,
  22                 void *userdata,
  23                 sd_bus_error *error) {
  24
  25         Link *l = userdata;
  26
  27         assert(reply);
  28         assert(l);
  29
  30         return sd_bus_message_append(reply, "s", dns_over_tls_mode_to_string(link_get_dns_over_tls_mode(l)));
  31 }
  32
  33 static int property_get_dns(
  34                 sd_bus *bus,
  35                 const char *path,
  36                 const char *interface,
  37                 const char *property,
  38                 sd_bus_message *reply,
  39                 void *userdata,
  40                 sd_bus_error *error) {
  41
  42         Link *l = userdata;
  43         DnsServer *s;
  44         int r;
  45
  46         assert(reply);
  47         assert(l);
  48
  49         r = sd_bus_message_open_container(reply, 'a', "(iay)");
  50         if (r < 0)
  51                 return r;
  52
  53         LIST_FOREACH(servers, s, l->dns_servers) {
  54                 r = bus_dns_server_append(reply, s, false);
  55                 if (r < 0)
  56                         return r;
  57         }
  58
  59         return sd_bus_message_close_container(reply);
  60 }
  61
  62 static int property_get_current_dns_server(
  63                 sd_bus *bus,
  64                 const char *path,
  65                 const char *interface,
  66                 const char *property,
  67                 sd_bus_message *reply,
  68                 void *userdata,
  69                 sd_bus_error *error) {
  70
  71         DnsServer *s;
  72
  73         assert(reply);
  74         assert(userdata);
  75
  76         s = *(DnsServer **) userdata;
  77
  78         return bus_dns_server_append(reply, s, false);
  79 }
  80
  81 static int property_get_domains(
  82                 sd_bus *bus,
  83                 const char *path,
  84                 const char *interface,
  85                 const char *property,
  86                 sd_bus_message *reply,
  87                 void *userdata,
  88                 sd_bus_error *error) {
  89
  90         Link *l = userdata;
  91         DnsSearchDomain *d;
  92         int r;
  93
  94         assert(reply);
  95         assert(l);
  96
  97         r = sd_bus_message_open_container(reply, 'a', "(sb)");
  98         if (r < 0)
  99                 return r;
 100
 101         LIST_FOREACH(domains, d, l->search_domains) {
 102                 r = sd_bus_message_append(reply, "(sb)", d->name, d->route_only);
 103                 if (r < 0)
 104                         return r;
 105         }
 106
 107         return sd_bus_message_close_container(reply);
 108 }
 109
 110 static int property_get_default_route(
 111                 sd_bus *bus,
 112                 const char *path,
 113                 const char *interface,
 114                 const char *property,
 115                 sd_bus_message *reply,
 116                 void *userdata,
 117                 sd_bus_error *error) {
 118
 119         Link *l = userdata;
 120
 121         assert(reply);
 122         assert(l);
 123
 124         /* Return what is configured, if there's something configured */
 125         if (l->default_route >= 0)
 126                 return sd_bus_message_append(reply, "b", l->default_route);
 127
 128         /* Otherwise report what is in effect */
 129         if (l->unicast_scope)
 130                 return sd_bus_message_append(reply, "b", dns_scope_is_default_route(l->unicast_scope));
 131
 132         return sd_bus_message_append(reply, "b", false);
 133 }
 134
 135 static int property_get_scopes_mask(
 136                 sd_bus *bus,
 137                 const char *path,
 138                 const char *interface,
 139                 const char *property,
 140                 sd_bus_message *reply,
 141                 void *userdata,
 142                 sd_bus_error *error) {
 143
 144         Link *l = userdata;
 145         uint64_t mask;
 146
 147         assert(reply);
 148         assert(l);
 149
 150         mask =  (l->unicast_scope ? SD_RESOLVED_DNS : 0) |
 151                 (l->llmnr_ipv4_scope ? SD_RESOLVED_LLMNR_IPV4 : 0) |
 152                 (l->llmnr_ipv6_scope ? SD_RESOLVED_LLMNR_IPV6 : 0) |
 153                 (l->mdns_ipv4_scope ? SD_RESOLVED_MDNS_IPV4 : 0) |
 154                 (l->mdns_ipv6_scope ? SD_RESOLVED_MDNS_IPV6 : 0);
 155
 156         return sd_bus_message_append(reply, "t", mask);
 157 }
 158
 159 static int property_get_ntas(
 160                 sd_bus *bus,
 161                 const char *path,
 162                 const char *interface,
 163                 const char *property,
 164                 sd_bus_message *reply,
 165                 void *userdata,
 166                 sd_bus_error *error) {
 167
 168         Link *l = userdata;
 169         const char *name;
 170         Iterator i;
 171         int r;
 172
 173         assert(reply);
 174         assert(l);
 175
 176         r = sd_bus_message_open_container(reply, 'a', "s");
 177         if (r < 0)
 178                 return r;
 179
 180         SET_FOREACH(name, l->dnssec_negative_trust_anchors, i) {
 181                 r = sd_bus_message_append(reply, "s", name);
 182                 if (r < 0)
 183                         return r;
 184         }
 185
 186         return sd_bus_message_close_container(reply);
 187 }
 188
 189 static int verify_unmanaged_link(Link *l, sd_bus_error *error) {
 190         assert(l);
 191
 192         if (l->flags & IFF_LOOPBACK)
 193                 return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is loopback device.", l->name);
 194         if (l->is_managed)
 195                 return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is managed.", l->name);
 196
 197         return 0;
 198 }
 199
 200 int bus_link_method_set_dns_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 201         _cleanup_free_ struct in_addr_data *dns = NULL;
 202         size_t allocated = 0, n = 0;
 203         Link *l = userdata;
 204         unsigned i;
 205         int r;
 206
 207         assert(message);
 208         assert(l);
 209
 210         r = verify_unmanaged_link(l, error);
 211         if (r < 0)
 212                 return r;
 213
 214         r = sd_bus_message_enter_container(message, 'a', "(iay)");
 215         if (r < 0)
 216                 return r;
 217
 218         for (;;) {
 219                 int family;
 220                 size_t sz;
 221                 const void *d;
 222
 223                 assert_cc(sizeof(int) == sizeof(int32_t));
 224
 225                 r = sd_bus_message_enter_container(message, 'r', "iay");
 226                 if (r < 0)
 227                         return r;
 228                 if (r == 0)
 229                         break;
 230
 231                 r = sd_bus_message_read(message, "i", &family);
 232                 if (r < 0)
 233                         return r;
 234
 235                 if (!IN_SET(family, AF_INET, AF_INET6))
 236                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);
 237
 238                 r = sd_bus_message_read_array(message, 'y', &d, &sz);
 239                 if (r < 0)
 240                         return r;
 241                 if (sz != FAMILY_ADDRESS_SIZE(family))
 242                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address size");
 243
 244                 if (!dns_server_address_valid(family, d))
 245                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNS server address");
 246
 247                 r = sd_bus_message_exit_container(message);
 248                 if (r < 0)
 249                         return r;
 250
 251                 if (!GREEDY_REALLOC(dns, allocated, n+1))
 252                         return -ENOMEM;
 253
 254                 dns[n].family = family;
 255                 memcpy(&dns[n].address, d, sz);
 256                 n++;
 257         }
 258
 259         r = sd_bus_message_exit_container(message);
 260         if (r < 0)
 261                 return r;
 262
 263         dns_server_mark_all(l->dns_servers);
 264
 265         for (i = 0; i < n; i++) {
 266                 DnsServer *s;
 267
 268                 s = dns_server_find(l->dns_servers, dns[i].family, &dns[i].address, 0);
 269                 if (s)
 270                         dns_server_move_back_and_unmark(s);
 271                 else {
 272                         r = dns_server_new(l->manager, NULL, DNS_SERVER_LINK, l, dns[i].family, &dns[i].address, 0);
 273                         if (r < 0)
 274                                 goto clear;
 275                 }
 276
 277         }
 278
 279         dns_server_unlink_marked(l->dns_servers);
 280         link_allocate_scopes(l);
 281
 282         (void) link_save_user(l);
 283         (void) manager_write_resolv_conf(l->manager);
 284
 285         return sd_bus_reply_method_return(message, NULL);
 286
 287 clear:
 288         dns_server_unlink_all(l->dns_servers);
 289         return r;
 290 }
 291
 292 int bus_link_method_set_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 293         Link *l = userdata;
 294         int r;
 295
 296         assert(message);
 297         assert(l);
 298
 299         r = verify_unmanaged_link(l, error);
 300         if (r < 0)
 301                 return r;
 302
 303         r = sd_bus_message_enter_container(message, 'a', "(sb)");
 304         if (r < 0)
 305                 return r;
 306
 307         for (;;) {
 308                 const char *name;
 309                 int route_only;
 310
 311                 r = sd_bus_message_read(message, "(sb)", &name, &route_only);
 312                 if (r < 0)
 313                         return r;
 314                 if (r == 0)
 315                         break;
 316
 317                 r = dns_name_is_valid(name);
 318                 if (r < 0)
 319                         return r;
 320                 if (r == 0)
 321                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid search domain %s", name);
 322                 if (!route_only && dns_name_is_root(name))
 323                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Root domain is not suitable as search domain");
 324         }
 325
 326         dns_search_domain_mark_all(l->search_domains);
 327
 328         r = sd_bus_message_rewind(message, false);
 329         if (r < 0)
 330                 return r;
 331
 332         for (;;) {
 333                 DnsSearchDomain *d;
 334                 const char *name;
 335                 int route_only;
 336
 337                 r = sd_bus_message_read(message, "(sb)", &name, &route_only);
 338                 if (r < 0)
 339                         goto clear;
 340                 if (r == 0)
 341                         break;
 342
 343                 r = dns_search_domain_find(l->search_domains, name, &d);
 344                 if (r < 0)
 345                         goto clear;
 346
 347                 if (r > 0)
 348                         dns_search_domain_move_back_and_unmark(d);
 349                 else {
 350                         r = dns_search_domain_new(l->manager, &d, DNS_SEARCH_DOMAIN_LINK, l, name);
 351                         if (r < 0)
 352                                 goto clear;
 353                 }
 354
 355                 d->route_only = route_only;
 356         }
 357
 358         r = sd_bus_message_exit_container(message);
 359         if (r < 0)
 360                 goto clear;
 361
 362         dns_search_domain_unlink_marked(l->search_domains);
 363
 364         (void) link_save_user(l);
 365         (void) manager_write_resolv_conf(l->manager);
 366
 367         return sd_bus_reply_method_return(message, NULL);
 368
 369 clear:
 370         dns_search_domain_unlink_all(l->search_domains);
 371         return r;
 372 }
 373
 374 int bus_link_method_set_default_route(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 375         Link *l = userdata;
 376         int r, b;
 377
 378         assert(message);
 379         assert(l);
 380
 381         r = verify_unmanaged_link(l, error);
 382         if (r < 0)
 383                 return r;
 384
 385         r = sd_bus_message_read(message, "b", &b);
 386         if (r < 0)
 387                 return r;
 388
 389         if (l->default_route != b) {
 390                 l->default_route = b;
 391
 392                 (void) link_save_user(l);
 393                 (void) manager_write_resolv_conf(l->manager);
 394         }
 395
 396         return sd_bus_reply_method_return(message, NULL);
 397 }
 398
 399 int bus_link_method_set_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 400         Link *l = userdata;
 401         ResolveSupport mode;
 402         const char *llmnr;
 403         int r;
 404
 405         assert(message);
 406         assert(l);
 407
 408         r = verify_unmanaged_link(l, error);
 409         if (r < 0)
 410                 return r;
 411
 412         r = sd_bus_message_read(message, "s", &llmnr);
 413         if (r < 0)
 414                 return r;
 415
 416         if (isempty(llmnr))
 417                 mode = RESOLVE_SUPPORT_YES;
 418         else {
 419                 mode = resolve_support_from_string(llmnr);
 420                 if (mode < 0)
 421                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid LLMNR setting: %s", llmnr);
 422         }
 423
 424         l->llmnr_support = mode;
 425         link_allocate_scopes(l);
 426         link_add_rrs(l, false);
 427
 428         (void) link_save_user(l);
 429
 430         return sd_bus_reply_method_return(message, NULL);
 431 }
 432
 433 int bus_link_method_set_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 434         Link *l = userdata;
 435         ResolveSupport mode;
 436         const char *mdns;
 437         int r;
 438
 439         assert(message);
 440         assert(l);
 441
 442         r = verify_unmanaged_link(l, error);
 443         if (r < 0)
 444                 return r;
 445
 446         r = sd_bus_message_read(message, "s", &mdns);
 447         if (r < 0)
 448                 return r;
 449
 450         if (isempty(mdns))
 451                 mode = RESOLVE_SUPPORT_NO;
 452         else {
 453                 mode = resolve_support_from_string(mdns);
 454                 if (mode < 0)
 455                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid MulticastDNS setting: %s", mdns);
 456         }
 457
 458         l->mdns_support = mode;
 459         link_allocate_scopes(l);
 460         link_add_rrs(l, false);
 461
 462         (void) link_save_user(l);
 463
 464         return sd_bus_reply_method_return(message, NULL);
 465 }
 466
 467 int bus_link_method_set_dns_over_tls(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 468         Link *l = userdata;
 469         const char *dns_over_tls;
 470         DnsOverTlsMode mode;
 471         int r;
 472
 473         assert(message);
 474         assert(l);
 475
 476         r = verify_unmanaged_link(l, error);
 477         if (r < 0)
 478                 return r;
 479
 480         r = sd_bus_message_read(message, "s", &dns_over_tls);
 481         if (r < 0)
 482                 return r;
 483
 484         if (isempty(dns_over_tls))
 485                 mode = _DNS_OVER_TLS_MODE_INVALID;
 486         else {
 487                 mode = dns_over_tls_mode_from_string(dns_over_tls);
 488                 if (mode < 0)
 489                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSOverTLS setting: %s", dns_over_tls);
 490         }
 491
 492         link_set_dns_over_tls_mode(l, mode);
 493
 494         (void) link_save_user(l);
 495
 496         return sd_bus_reply_method_return(message, NULL);
 497 }
 498
 499 int bus_link_method_set_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 500         Link *l = userdata;
 501         const char *dnssec;
 502         DnssecMode mode;
 503         int r;
 504
 505         assert(message);
 506         assert(l);
 507
 508         r = verify_unmanaged_link(l, error);
 509         if (r < 0)
 510                 return r;
 511
 512         r = sd_bus_message_read(message, "s", &dnssec);
 513         if (r < 0)
 514                 return r;
 515
 516         if (isempty(dnssec))
 517                 mode = _DNSSEC_MODE_INVALID;
 518         else {
 519                 mode = dnssec_mode_from_string(dnssec);
 520                 if (mode < 0)
 521                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSSEC setting: %s", dnssec);
 522         }
 523
 524         link_set_dnssec_mode(l, mode);
 525
 526         (void) link_save_user(l);
 527
 528         return sd_bus_reply_method_return(message, NULL);
 529 }
 530
 531 int bus_link_method_set_dnssec_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 532         _cleanup_set_free_free_ Set *ns = NULL;
 533         _cleanup_strv_free_ char **ntas = NULL;
 534         Link *l = userdata;
 535         int r;
 536         char **i;
 537
 538         assert(message);
 539         assert(l);
 540
 541         r = verify_unmanaged_link(l, error);
 542         if (r < 0)
 543                 return r;
 544
 545         r = sd_bus_message_read_strv(message, &ntas);
 546         if (r < 0)
 547                 return r;
 548
 549         STRV_FOREACH(i, ntas) {
 550                 r = dns_name_is_valid(*i);
 551                 if (r < 0)
 552                         return r;
 553                 if (r == 0)
 554                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid negative trust anchor domain: %s", *i);
 555         }
 556
 557         ns = set_new(&dns_name_hash_ops);
 558         if (!ns)
 559                 return -ENOMEM;
 560
 561         STRV_FOREACH(i, ntas) {
 562                 r = set_put_strdup(ns, *i);
 563                 if (r < 0)
 564                         return r;
 565         }
 566
 567         set_free_free(l->dnssec_negative_trust_anchors);
 568         l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
 569
 570         (void) link_save_user(l);
 571
 572         return sd_bus_reply_method_return(message, NULL);
 573 }
 574
 575 int bus_link_method_revert(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 576         Link *l = userdata;
 577         int r;
 578
 579         assert(message);
 580         assert(l);
 581
 582         r = verify_unmanaged_link(l, error);
 583         if (r < 0)
 584                 return r;
 585
 586         link_flush_settings(l);
 587         link_allocate_scopes(l);
 588         link_add_rrs(l, false);
 589
 590         (void) link_save_user(l);
 591         (void) manager_write_resolv_conf(l->manager);
 592
 593         return sd_bus_reply_method_return(message, NULL);
 594 }
 595
 596 const sd_bus_vtable link_vtable[] = {
 597         SD_BUS_VTABLE_START(0),
 598
 599         SD_BUS_PROPERTY("ScopesMask", "t", property_get_scopes_mask, 0, 0),
 600         SD_BUS_PROPERTY("DNS", "a(iay)", property_get_dns, 0, 0),
 601         SD_BUS_PROPERTY("CurrentDNSServer", "(iay)", property_get_current_dns_server, offsetof(Link, current_dns_server), 0),
 602         SD_BUS_PROPERTY("Domains", "a(sb)", property_get_domains, 0, 0),
 603         SD_BUS_PROPERTY("DefaultRoute", "b", property_get_default_route, 0, 0),
 604         SD_BUS_PROPERTY("LLMNR", "s", bus_property_get_resolve_support, offsetof(Link, llmnr_support), 0),
 605         SD_BUS_PROPERTY("MulticastDNS", "s", bus_property_get_resolve_support, offsetof(Link, mdns_support), 0),
 606         SD_BUS_PROPERTY("DNSOverTLS", "s", property_get_dns_over_tls_mode, 0, 0),
 607         SD_BUS_PROPERTY("DNSSEC", "s", property_get_dnssec_mode, 0, 0),
 608         SD_BUS_PROPERTY("DNSSECNegativeTrustAnchors", "as", property_get_ntas, 0, 0),
 609         SD_BUS_PROPERTY("DNSSECSupported", "b", property_get_dnssec_supported, 0, 0),
 610
 611         SD_BUS_METHOD("SetDNS", "a(iay)", NULL, bus_link_method_set_dns_servers, 0),
 612         SD_BUS_METHOD("SetDomains", "a(sb)", NULL, bus_link_method_set_domains, 0),
 613         SD_BUS_METHOD("SetDefaultRoute", "b", NULL, bus_link_method_set_default_route, 0),
 614         SD_BUS_METHOD("SetLLMNR", "s", NULL, bus_link_method_set_llmnr, 0),
 615         SD_BUS_METHOD("SetMulticastDNS", "s", NULL, bus_link_method_set_mdns, 0),
 616         SD_BUS_METHOD("SetDNSOverTLS", "s", NULL, bus_link_method_set_dns_over_tls, 0),
 617         SD_BUS_METHOD("SetDNSSEC", "s", NULL, bus_link_method_set_dnssec, 0),
 618         SD_BUS_METHOD("SetDNSSECNegativeTrustAnchors", "as", NULL, bus_link_method_set_dnssec_negative_trust_anchors, 0),
 619         SD_BUS_METHOD("Revert", NULL, NULL, bus_link_method_revert, 0),
 620
 621         SD_BUS_VTABLE_END
 622 };
 623
 624 int link_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 625         _cleanup_free_ char *e = NULL;
 626         Manager *m = userdata;
 627         int ifindex;
 628         Link *link;
 629         int r;
 630
 631         assert(bus);
 632         assert(path);
 633         assert(interface);
 634         assert(found);
 635         assert(m);
 636
 637         r = sd_bus_path_decode(path, "/org/freedesktop/resolve1/link", &e);
 638         if (r <= 0)
 639                 return 0;
 640
 641         r = parse_ifindex(e, &ifindex);
 642         if (r < 0)
 643                 return 0;
 644
 645         link = hashmap_get(m->links, INT_TO_PTR(ifindex));
 646         if (!link)
 647                 return 0;
 648
 649         *found = link;
 650         return 1;
 651 }
 652
 653 char *link_bus_path(Link *link) {
 654         _cleanup_free_ char *ifindex = NULL;
 655         char *p;
 656         int r;
 657
 658         assert(link);
 659
 660         if (asprintf(&ifindex, "%i", link->ifindex) < 0)
 661                 return NULL;
 662
 663         r = sd_bus_path_encode("/org/freedesktop/resolve1/link", ifindex, &p);
 664         if (r < 0)
 665                 return NULL;
 666
 667         return p;
 668 }
 669
 670 int link_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 671         _cleanup_strv_free_ char **l = NULL;
 672         Manager *m = userdata;
 673         Link *link;
 674         Iterator i;
 675         unsigned c = 0;
 676
 677         assert(bus);
 678         assert(path);
 679         assert(m);
 680         assert(nodes);
 681
 682         l = new0(char*, hashmap_size(m->links) + 1);
 683         if (!l)
 684                 return -ENOMEM;
 685
 686         HASHMAP_FOREACH(link, m->links, i) {
 687                 char *p;
 688
 689                 p = link_bus_path(link);
 690                 if (!p)
 691                         return -ENOMEM;
 692
 693                 l[c++] = p;
 694         }
 695
 696         l[c] = NULL;
 697         *nodes = TAKE_PTR(l);
 698
 699         return 1;
 700 }