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_scopes_mask(
 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         uint64_t mask;
 121
 122         assert(reply);
 123         assert(l);
 124
 125         mask =  (l->unicast_scope ? SD_RESOLVED_DNS : 0) |
 126                 (l->llmnr_ipv4_scope ? SD_RESOLVED_LLMNR_IPV4 : 0) |
 127                 (l->llmnr_ipv6_scope ? SD_RESOLVED_LLMNR_IPV6 : 0) |
 128                 (l->mdns_ipv4_scope ? SD_RESOLVED_MDNS_IPV4 : 0) |
 129                 (l->mdns_ipv6_scope ? SD_RESOLVED_MDNS_IPV6 : 0);
 130
 131         return sd_bus_message_append(reply, "t", mask);
 132 }
 133
 134 static int property_get_ntas(
 135                 sd_bus *bus,
 136                 const char *path,
 137                 const char *interface,
 138                 const char *property,
 139                 sd_bus_message *reply,
 140                 void *userdata,
 141                 sd_bus_error *error) {
 142
 143         Link *l = userdata;
 144         const char *name;
 145         Iterator i;
 146         int r;
 147
 148         assert(reply);
 149         assert(l);
 150
 151         r = sd_bus_message_open_container(reply, 'a', "s");
 152         if (r < 0)
 153                 return r;
 154
 155         SET_FOREACH(name, l->dnssec_negative_trust_anchors, i) {
 156                 r = sd_bus_message_append(reply, "s", name);
 157                 if (r < 0)
 158                         return r;
 159         }
 160
 161         return sd_bus_message_close_container(reply);
 162 }
 163
 164 static int verify_unmanaged_link(Link *l, sd_bus_error *error) {
 165         assert(l);
 166
 167         if (l->flags & IFF_LOOPBACK)
 168                 return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is loopback device.", l->name);
 169         if (l->is_managed)
 170                 return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is managed.", l->name);
 171
 172         return 0;
 173 }
 174
 175 int bus_link_method_set_dns_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 176         _cleanup_free_ struct in_addr_data *dns = NULL;
 177         size_t allocated = 0, n = 0;
 178         Link *l = userdata;
 179         unsigned i;
 180         int r;
 181
 182         assert(message);
 183         assert(l);
 184
 185         r = verify_unmanaged_link(l, error);
 186         if (r < 0)
 187                 return r;
 188
 189         r = sd_bus_message_enter_container(message, 'a', "(iay)");
 190         if (r < 0)
 191                 return r;
 192
 193         for (;;) {
 194                 int family;
 195                 size_t sz;
 196                 const void *d;
 197
 198                 assert_cc(sizeof(int) == sizeof(int32_t));
 199
 200                 r = sd_bus_message_enter_container(message, 'r', "iay");
 201                 if (r < 0)
 202                         return r;
 203                 if (r == 0)
 204                         break;
 205
 206                 r = sd_bus_message_read(message, "i", &family);
 207                 if (r < 0)
 208                         return r;
 209
 210                 if (!IN_SET(family, AF_INET, AF_INET6))
 211                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);
 212
 213                 r = sd_bus_message_read_array(message, 'y', &d, &sz);
 214                 if (r < 0)
 215                         return r;
 216                 if (sz != FAMILY_ADDRESS_SIZE(family))
 217                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address size");
 218
 219                 if (!dns_server_address_valid(family, d))
 220                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNS server address");
 221
 222                 r = sd_bus_message_exit_container(message);
 223                 if (r < 0)
 224                         return r;
 225
 226                 if (!GREEDY_REALLOC(dns, allocated, n+1))
 227                         return -ENOMEM;
 228
 229                 dns[n].family = family;
 230                 memcpy(&dns[n].address, d, sz);
 231                 n++;
 232         }
 233
 234         r = sd_bus_message_exit_container(message);
 235         if (r < 0)
 236                 return r;
 237
 238         dns_server_mark_all(l->dns_servers);
 239
 240         for (i = 0; i < n; i++) {
 241                 DnsServer *s;
 242
 243                 s = dns_server_find(l->dns_servers, dns[i].family, &dns[i].address, 0);
 244                 if (s)
 245                         dns_server_move_back_and_unmark(s);
 246                 else {
 247                         r = dns_server_new(l->manager, NULL, DNS_SERVER_LINK, l, dns[i].family, &dns[i].address, 0);
 248                         if (r < 0)
 249                                 goto clear;
 250                 }
 251
 252         }
 253
 254         dns_server_unlink_marked(l->dns_servers);
 255         link_allocate_scopes(l);
 256
 257         (void) link_save_user(l);
 258         (void) manager_write_resolv_conf(l->manager);
 259
 260         return sd_bus_reply_method_return(message, NULL);
 261
 262 clear:
 263         dns_server_unlink_all(l->dns_servers);
 264         return r;
 265 }
 266
 267 int bus_link_method_set_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 268         Link *l = userdata;
 269         int r;
 270
 271         assert(message);
 272         assert(l);
 273
 274         r = verify_unmanaged_link(l, error);
 275         if (r < 0)
 276                 return r;
 277
 278         r = sd_bus_message_enter_container(message, 'a', "(sb)");
 279         if (r < 0)
 280                 return r;
 281
 282         for (;;) {
 283                 const char *name;
 284                 int route_only;
 285
 286                 r = sd_bus_message_read(message, "(sb)", &name, &route_only);
 287                 if (r < 0)
 288                         return r;
 289                 if (r == 0)
 290                         break;
 291
 292                 r = dns_name_is_valid(name);
 293                 if (r < 0)
 294                         return r;
 295                 if (r == 0)
 296                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid search domain %s", name);
 297                 if (!route_only && dns_name_is_root(name))
 298                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Root domain is not suitable as search domain");
 299         }
 300
 301         dns_search_domain_mark_all(l->search_domains);
 302
 303         r = sd_bus_message_rewind(message, false);
 304         if (r < 0)
 305                 return r;
 306
 307         for (;;) {
 308                 DnsSearchDomain *d;
 309                 const char *name;
 310                 int route_only;
 311
 312                 r = sd_bus_message_read(message, "(sb)", &name, &route_only);
 313                 if (r < 0)
 314                         goto clear;
 315                 if (r == 0)
 316                         break;
 317
 318                 r = dns_search_domain_find(l->search_domains, name, &d);
 319                 if (r < 0)
 320                         goto clear;
 321
 322                 if (r > 0)
 323                         dns_search_domain_move_back_and_unmark(d);
 324                 else {
 325                         r = dns_search_domain_new(l->manager, &d, DNS_SEARCH_DOMAIN_LINK, l, name);
 326                         if (r < 0)
 327                                 goto clear;
 328                 }
 329
 330                 d->route_only = route_only;
 331         }
 332
 333         r = sd_bus_message_exit_container(message);
 334         if (r < 0)
 335                 goto clear;
 336
 337         dns_search_domain_unlink_marked(l->search_domains);
 338
 339         (void) link_save_user(l);
 340         (void) manager_write_resolv_conf(l->manager);
 341
 342         return sd_bus_reply_method_return(message, NULL);
 343
 344 clear:
 345         dns_search_domain_unlink_all(l->search_domains);
 346         return r;
 347 }
 348
 349 int bus_link_method_set_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 350         Link *l = userdata;
 351         ResolveSupport mode;
 352         const char *llmnr;
 353         int r;
 354
 355         assert(message);
 356         assert(l);
 357
 358         r = verify_unmanaged_link(l, error);
 359         if (r < 0)
 360                 return r;
 361
 362         r = sd_bus_message_read(message, "s", &llmnr);
 363         if (r < 0)
 364                 return r;
 365
 366         if (isempty(llmnr))
 367                 mode = RESOLVE_SUPPORT_YES;
 368         else {
 369                 mode = resolve_support_from_string(llmnr);
 370                 if (mode < 0)
 371                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid LLMNR setting: %s", llmnr);
 372         }
 373
 374         l->llmnr_support = mode;
 375         link_allocate_scopes(l);
 376         link_add_rrs(l, false);
 377
 378         (void) link_save_user(l);
 379
 380         return sd_bus_reply_method_return(message, NULL);
 381 }
 382
 383 int bus_link_method_set_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 384         Link *l = userdata;
 385         ResolveSupport mode;
 386         const char *mdns;
 387         int r;
 388
 389         assert(message);
 390         assert(l);
 391
 392         r = verify_unmanaged_link(l, error);
 393         if (r < 0)
 394                 return r;
 395
 396         r = sd_bus_message_read(message, "s", &mdns);
 397         if (r < 0)
 398                 return r;
 399
 400         if (isempty(mdns))
 401                 mode = RESOLVE_SUPPORT_NO;
 402         else {
 403                 mode = resolve_support_from_string(mdns);
 404                 if (mode < 0)
 405                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid MulticastDNS setting: %s", mdns);
 406         }
 407
 408         l->mdns_support = mode;
 409         link_allocate_scopes(l);
 410         link_add_rrs(l, false);
 411
 412         (void) link_save_user(l);
 413
 414         return sd_bus_reply_method_return(message, NULL);
 415 }
 416
 417 int bus_link_method_set_dns_over_tls(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 418         Link *l = userdata;
 419         const char *dns_over_tls;
 420         DnsOverTlsMode mode;
 421         int r;
 422
 423         assert(message);
 424         assert(l);
 425
 426         r = verify_unmanaged_link(l, error);
 427         if (r < 0)
 428                 return r;
 429
 430         r = sd_bus_message_read(message, "s", &dns_over_tls);
 431         if (r < 0)
 432                 return r;
 433
 434         if (isempty(dns_over_tls))
 435                 mode = _DNS_OVER_TLS_MODE_INVALID;
 436         else {
 437                 mode = dns_over_tls_mode_from_string(dns_over_tls);
 438                 if (mode < 0)
 439                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSOverTLS setting: %s", dns_over_tls);
 440         }
 441
 442         link_set_dns_over_tls_mode(l, mode);
 443
 444         (void) link_save_user(l);
 445
 446         return sd_bus_reply_method_return(message, NULL);
 447 }
 448
 449 int bus_link_method_set_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 450         Link *l = userdata;
 451         const char *dnssec;
 452         DnssecMode mode;
 453         int r;
 454
 455         assert(message);
 456         assert(l);
 457
 458         r = verify_unmanaged_link(l, error);
 459         if (r < 0)
 460                 return r;
 461
 462         r = sd_bus_message_read(message, "s", &dnssec);
 463         if (r < 0)
 464                 return r;
 465
 466         if (isempty(dnssec))
 467                 mode = _DNSSEC_MODE_INVALID;
 468         else {
 469                 mode = dnssec_mode_from_string(dnssec);
 470                 if (mode < 0)
 471                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSSEC setting: %s", dnssec);
 472         }
 473
 474         link_set_dnssec_mode(l, mode);
 475
 476         (void) link_save_user(l);
 477
 478         return sd_bus_reply_method_return(message, NULL);
 479 }
 480
 481 int bus_link_method_set_dnssec_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 482         _cleanup_set_free_free_ Set *ns = NULL;
 483         _cleanup_strv_free_ char **ntas = NULL;
 484         Link *l = userdata;
 485         int r;
 486         char **i;
 487
 488         assert(message);
 489         assert(l);
 490
 491         r = verify_unmanaged_link(l, error);
 492         if (r < 0)
 493                 return r;
 494
 495         r = sd_bus_message_read_strv(message, &ntas);
 496         if (r < 0)
 497                 return r;
 498
 499         STRV_FOREACH(i, ntas) {
 500                 r = dns_name_is_valid(*i);
 501                 if (r < 0)
 502                         return r;
 503                 if (r == 0)
 504                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid negative trust anchor domain: %s", *i);
 505         }
 506
 507         ns = set_new(&dns_name_hash_ops);
 508         if (!ns)
 509                 return -ENOMEM;
 510
 511         STRV_FOREACH(i, ntas) {
 512                 r = set_put_strdup(ns, *i);
 513                 if (r < 0)
 514                         return r;
 515         }
 516
 517         set_free_free(l->dnssec_negative_trust_anchors);
 518         l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
 519
 520         (void) link_save_user(l);
 521
 522         return sd_bus_reply_method_return(message, NULL);
 523 }
 524
 525 int bus_link_method_revert(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 526         Link *l = userdata;
 527         int r;
 528
 529         assert(message);
 530         assert(l);
 531
 532         r = verify_unmanaged_link(l, error);
 533         if (r < 0)
 534                 return r;
 535
 536         link_flush_settings(l);
 537         link_allocate_scopes(l);
 538         link_add_rrs(l, false);
 539
 540         (void) link_save_user(l);
 541         (void) manager_write_resolv_conf(l->manager);
 542
 543         return sd_bus_reply_method_return(message, NULL);
 544 }
 545
 546 const sd_bus_vtable link_vtable[] = {
 547         SD_BUS_VTABLE_START(0),
 548
 549         SD_BUS_PROPERTY("ScopesMask", "t", property_get_scopes_mask, 0, 0),
 550         SD_BUS_PROPERTY("DNS", "a(iay)", property_get_dns, 0, 0),
 551         SD_BUS_PROPERTY("CurrentDNSServer", "(iay)", property_get_current_dns_server, offsetof(Link, current_dns_server), 0),
 552         SD_BUS_PROPERTY("Domains", "a(sb)", property_get_domains, 0, 0),
 553         SD_BUS_PROPERTY("LLMNR", "s", bus_property_get_resolve_support, offsetof(Link, llmnr_support), 0),
 554         SD_BUS_PROPERTY("MulticastDNS", "s", bus_property_get_resolve_support, offsetof(Link, mdns_support), 0),
 555         SD_BUS_PROPERTY("DNSOverTLS", "s", property_get_dns_over_tls_mode, 0, 0),
 556         SD_BUS_PROPERTY("DNSSEC", "s", property_get_dnssec_mode, 0, 0),
 557         SD_BUS_PROPERTY("DNSSECNegativeTrustAnchors", "as", property_get_ntas, 0, 0),
 558         SD_BUS_PROPERTY("DNSSECSupported", "b", property_get_dnssec_supported, 0, 0),
 559
 560         SD_BUS_METHOD("SetDNS", "a(iay)", NULL, bus_link_method_set_dns_servers, 0),
 561         SD_BUS_METHOD("SetDomains", "a(sb)", NULL, bus_link_method_set_domains, 0),
 562         SD_BUS_METHOD("SetLLMNR", "s", NULL, bus_link_method_set_llmnr, 0),
 563         SD_BUS_METHOD("SetMulticastDNS", "s", NULL, bus_link_method_set_mdns, 0),
 564         SD_BUS_METHOD("SetDNSOverTLS", "s", NULL, bus_link_method_set_dns_over_tls, 0),
 565         SD_BUS_METHOD("SetDNSSEC", "s", NULL, bus_link_method_set_dnssec, 0),
 566         SD_BUS_METHOD("SetDNSSECNegativeTrustAnchors", "as", NULL, bus_link_method_set_dnssec_negative_trust_anchors, 0),
 567         SD_BUS_METHOD("Revert", NULL, NULL, bus_link_method_revert, 0),
 568
 569         SD_BUS_VTABLE_END
 570 };
 571
 572 int link_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 573         _cleanup_free_ char *e = NULL;
 574         Manager *m = userdata;
 575         int ifindex;
 576         Link *link;
 577         int r;
 578
 579         assert(bus);
 580         assert(path);
 581         assert(interface);
 582         assert(found);
 583         assert(m);
 584
 585         r = sd_bus_path_decode(path, "/org/freedesktop/resolve1/link", &e);
 586         if (r <= 0)
 587                 return 0;
 588
 589         r = parse_ifindex(e, &ifindex);
 590         if (r < 0)
 591                 return 0;
 592
 593         link = hashmap_get(m->links, INT_TO_PTR(ifindex));
 594         if (!link)
 595                 return 0;
 596
 597         *found = link;
 598         return 1;
 599 }
 600
 601 char *link_bus_path(Link *link) {
 602         _cleanup_free_ char *ifindex = NULL;
 603         char *p;
 604         int r;
 605
 606         assert(link);
 607
 608         if (asprintf(&ifindex, "%i", link->ifindex) < 0)
 609                 return NULL;
 610
 611         r = sd_bus_path_encode("/org/freedesktop/resolve1/link", ifindex, &p);
 612         if (r < 0)
 613                 return NULL;
 614
 615         return p;
 616 }
 617
 618 int link_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 619         _cleanup_strv_free_ char **l = NULL;
 620         Manager *m = userdata;
 621         Link *link;
 622         Iterator i;
 623         unsigned c = 0;
 624
 625         assert(bus);
 626         assert(path);
 627         assert(m);
 628         assert(nodes);
 629
 630         l = new0(char*, hashmap_size(m->links) + 1);
 631         if (!l)
 632                 return -ENOMEM;
 633
 634         HASHMAP_FOREACH(link, m->links, i) {
 635                 char *p;
 636
 637                 p = link_bus_path(link);
 638                 if (!p)
 639                         return -ENOMEM;
 640
 641                 l[c++] = p;
 642         }
 643
 644         l[c] = NULL;
 645         *nodes = TAKE_PTR(l);
 646
 647         return 1;
 648 }