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