src/resolve/resolved-link-bus.c

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