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_domains(
  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         Link *l = userdata;
  74         DnsSearchDomain *d;
  75         int r;
  76
  77         assert(reply);
  78         assert(l);
  79
  80         r = sd_bus_message_open_container(reply, 'a', "(sb)");
  81         if (r < 0)
  82                 return r;
  83
  84         LIST_FOREACH(domains, d, l->search_domains) {
  85                 r = sd_bus_message_append(reply, "(sb)", d->name, d->route_only);
  86                 if (r < 0)
  87                         return r;
  88         }
  89
  90         return sd_bus_message_close_container(reply);
  91 }
  92
  93 static int property_get_scopes_mask(
  94                 sd_bus *bus,
  95                 const char *path,
  96                 const char *interface,
  97                 const char *property,
  98                 sd_bus_message *reply,
  99                 void *userdata,
 100                 sd_bus_error *error) {
 101
 102         Link *l = userdata;
 103         uint64_t mask;
 104
 105         assert(reply);
 106         assert(l);
 107
 108         mask =  (l->unicast_scope ? SD_RESOLVED_DNS : 0) |
 109                 (l->llmnr_ipv4_scope ? SD_RESOLVED_LLMNR_IPV4 : 0) |
 110                 (l->llmnr_ipv6_scope ? SD_RESOLVED_LLMNR_IPV6 : 0) |
 111                 (l->mdns_ipv4_scope ? SD_RESOLVED_MDNS_IPV4 : 0) |
 112                 (l->mdns_ipv6_scope ? SD_RESOLVED_MDNS_IPV6 : 0);
 113
 114         return sd_bus_message_append(reply, "t", mask);
 115 }
 116
 117 static int property_get_ntas(
 118                 sd_bus *bus,
 119                 const char *path,
 120                 const char *interface,
 121                 const char *property,
 122                 sd_bus_message *reply,
 123                 void *userdata,
 124                 sd_bus_error *error) {
 125
 126         Link *l = userdata;
 127         const char *name;
 128         Iterator i;
 129         int r;
 130
 131         assert(reply);
 132         assert(l);
 133
 134         r = sd_bus_message_open_container(reply, 'a', "s");
 135         if (r < 0)
 136                 return r;
 137
 138         SET_FOREACH(name, l->dnssec_negative_trust_anchors, i) {
 139                 r = sd_bus_message_append(reply, "s", name);
 140                 if (r < 0)
 141                         return r;
 142         }
 143
 144         return sd_bus_message_close_container(reply);
 145 }
 146
 147 static int property_get_dnssec_supported(
 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 = userdata;
 157
 158         assert(reply);
 159         assert(l);
 160
 161         return sd_bus_message_append(reply, "b", link_dnssec_supported(l));
 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_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 418         Link *l = userdata;
 419         const char *dnssec;
 420         DnssecMode 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", &dnssec);
 431         if (r < 0)
 432                 return r;
 433
 434         if (isempty(dnssec))
 435                 mode = _DNSSEC_MODE_INVALID;
 436         else {
 437                 mode = dnssec_mode_from_string(dnssec);
 438                 if (mode < 0)
 439                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSSEC setting: %s", dnssec);
 440         }
 441
 442         link_set_dnssec_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_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 450         _cleanup_set_free_free_ Set *ns = NULL;
 451         _cleanup_strv_free_ char **ntas = NULL;
 452         Link *l = userdata;
 453         int r;
 454         char **i;
 455
 456         assert(message);
 457         assert(l);
 458
 459         r = verify_unmanaged_link(l, error);
 460         if (r < 0)
 461                 return r;
 462
 463         r = sd_bus_message_read_strv(message, &ntas);
 464         if (r < 0)
 465                 return r;
 466
 467         STRV_FOREACH(i, ntas) {
 468                 r = dns_name_is_valid(*i);
 469                 if (r < 0)
 470                         return r;
 471                 if (r == 0)
 472                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid negative trust anchor domain: %s", *i);
 473         }
 474
 475         ns = set_new(&dns_name_hash_ops);
 476         if (!ns)
 477                 return -ENOMEM;
 478
 479         STRV_FOREACH(i, ntas) {
 480                 r = set_put_strdup(ns, *i);
 481                 if (r < 0)
 482                         return r;
 483         }
 484
 485         set_free_free(l->dnssec_negative_trust_anchors);
 486         l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
 487
 488         (void) link_save_user(l);
 489
 490         return sd_bus_reply_method_return(message, NULL);
 491 }
 492
 493 int bus_link_method_revert(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 494         Link *l = userdata;
 495         int r;
 496
 497         assert(message);
 498         assert(l);
 499
 500         r = verify_unmanaged_link(l, error);
 501         if (r < 0)
 502                 return r;
 503
 504         link_flush_settings(l);
 505         link_allocate_scopes(l);
 506         link_add_rrs(l, false);
 507
 508         (void) link_save_user(l);
 509         (void) manager_write_resolv_conf(l->manager);
 510
 511         return sd_bus_reply_method_return(message, NULL);
 512 }
 513
 514 const sd_bus_vtable link_vtable[] = {
 515         SD_BUS_VTABLE_START(0),
 516
 517         SD_BUS_PROPERTY("ScopesMask", "t", property_get_scopes_mask, 0, 0),
 518         SD_BUS_PROPERTY("DNS", "a(iay)", property_get_dns, 0, 0),
 519         SD_BUS_PROPERTY("Domains", "a(sb)", property_get_domains, 0, 0),
 520         SD_BUS_PROPERTY("LLMNR", "s", bus_property_get_resolve_support, offsetof(Link, llmnr_support), 0),
 521         SD_BUS_PROPERTY("MulticastDNS", "s", bus_property_get_resolve_support, offsetof(Link, mdns_support), 0),
 522         SD_BUS_PROPERTY("DNSSEC", "s", property_get_dnssec_mode, 0, 0),
 523         SD_BUS_PROPERTY("DNSSECNegativeTrustAnchors", "as", property_get_ntas, 0, 0),
 524         SD_BUS_PROPERTY("DNSSECSupported", "b", property_get_dnssec_supported, 0, 0),
 525
 526         SD_BUS_METHOD("SetDNS", "a(iay)", NULL, bus_link_method_set_dns_servers, 0),
 527         SD_BUS_METHOD("SetDomains", "a(sb)", NULL, bus_link_method_set_domains, 0),
 528         SD_BUS_METHOD("SetLLMNR", "s", NULL, bus_link_method_set_llmnr, 0),
 529         SD_BUS_METHOD("SetMulticastDNS", "s", NULL, bus_link_method_set_mdns, 0),
 530         SD_BUS_METHOD("SetDNSSEC", "s", NULL, bus_link_method_set_dnssec, 0),
 531         SD_BUS_METHOD("SetDNSSECNegativeTrustAnchors", "as", NULL, bus_link_method_set_dnssec_negative_trust_anchors, 0),
 532         SD_BUS_METHOD("Revert", NULL, NULL, bus_link_method_revert, 0),
 533
 534         SD_BUS_VTABLE_END
 535 };
 536
 537 int link_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 538         _cleanup_free_ char *e = NULL;
 539         Manager *m = userdata;
 540         int ifindex;
 541         Link *link;
 542         int r;
 543
 544         assert(bus);
 545         assert(path);
 546         assert(interface);
 547         assert(found);
 548         assert(m);
 549
 550         r = sd_bus_path_decode(path, "/org/freedesktop/resolve1/link", &e);
 551         if (r <= 0)
 552                 return 0;
 553
 554         r = parse_ifindex(e, &ifindex);
 555         if (r < 0)
 556                 return 0;
 557
 558         link = hashmap_get(m->links, INT_TO_PTR(ifindex));
 559         if (!link)
 560                 return 0;
 561
 562         *found = link;
 563         return 1;
 564 }
 565
 566 char *link_bus_path(Link *link) {
 567         _cleanup_free_ char *ifindex = NULL;
 568         char *p;
 569         int r;
 570
 571         assert(link);
 572
 573         if (asprintf(&ifindex, "%i", link->ifindex) < 0)
 574                 return NULL;
 575
 576         r = sd_bus_path_encode("/org/freedesktop/resolve1/link", ifindex, &p);
 577         if (r < 0)
 578                 return NULL;
 579
 580         return p;
 581 }
 582
 583 int link_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 584         _cleanup_strv_free_ char **l = NULL;
 585         Manager *m = userdata;
 586         Link *link;
 587         Iterator i;
 588         unsigned c = 0;
 589
 590         assert(bus);
 591         assert(path);
 592         assert(m);
 593         assert(nodes);
 594
 595         l = new0(char*, hashmap_size(m->links) + 1);
 596         if (!l)
 597                 return -ENOMEM;
 598
 599         HASHMAP_FOREACH(link, m->links, i) {
 600                 char *p;
 601
 602                 p = link_bus_path(link);
 603                 if (!p)
 604                         return -ENOMEM;
 605
 606                 l[c++] = p;
 607         }
 608
 609         l[c] = NULL;
 610         *nodes = TAKE_PTR(l);
 611
 612         return 1;
 613 }