src/resolve/resolved-link-bus.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2016 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include "alloc-util.h"
  21 #include "bus-util.h"
  22 #include "parse-util.h"
  23 #include "resolve-util.h"
  24 #include "resolved-bus.h"
  25 #include "resolved-link-bus.h"
  26 #include "resolved-resolv-conf.h"
  27 #include "strv.h"
  28
  29 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_resolve_support, resolve_support, ResolveSupport);
  30 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_dnssec_mode, dnssec_mode, DnssecMode);
  31
  32 static int property_get_dns(
  33                 sd_bus *bus,
  34                 const char *path,
  35                 const char *interface,
  36                 const char *property,
  37                 sd_bus_message *reply,
  38                 void *userdata,
  39                 sd_bus_error *error) {
  40
  41         Link *l = userdata;
  42         DnsServer *s;
  43         int r;
  44
  45         assert(reply);
  46         assert(l);
  47
  48         r = sd_bus_message_open_container(reply, 'a', "(iay)");
  49         if (r < 0)
  50                 return r;
  51
  52         LIST_FOREACH(servers, s, l->dns_servers) {
  53                 r = bus_dns_server_append(reply, s, false);
  54                 if (r < 0)
  55                         return r;
  56         }
  57
  58         return sd_bus_message_close_container(reply);
  59 }
  60
  61 static int property_get_domains(
  62                 sd_bus *bus,
  63                 const char *path,
  64                 const char *interface,
  65                 const char *property,
  66                 sd_bus_message *reply,
  67                 void *userdata,
  68                 sd_bus_error *error) {
  69
  70         Link *l = userdata;
  71         DnsSearchDomain *d;
  72         int r;
  73
  74         assert(reply);
  75         assert(l);
  76
  77         r = sd_bus_message_open_container(reply, 'a', "(sb)");
  78         if (r < 0)
  79                 return r;
  80
  81         LIST_FOREACH(domains, d, l->search_domains) {
  82                 r = sd_bus_message_append(reply, "(sb)", d->name, d->route_only);
  83                 if (r < 0)
  84                         return r;
  85         }
  86
  87         return sd_bus_message_close_container(reply);
  88 }
  89
  90 static int property_get_scopes_mask(
  91                 sd_bus *bus,
  92                 const char *path,
  93                 const char *interface,
  94                 const char *property,
  95                 sd_bus_message *reply,
  96                 void *userdata,
  97                 sd_bus_error *error) {
  98
  99         Link *l = userdata;
 100         uint64_t mask;
 101
 102         assert(reply);
 103         assert(l);
 104
 105         mask =  (l->unicast_scope ? SD_RESOLVED_DNS : 0) |
 106                 (l->llmnr_ipv4_scope ? SD_RESOLVED_LLMNR_IPV4 : 0) |
 107                 (l->llmnr_ipv6_scope ? SD_RESOLVED_LLMNR_IPV6 : 0) |
 108                 (l->mdns_ipv4_scope ? SD_RESOLVED_MDNS_IPV4 : 0) |
 109                 (l->mdns_ipv6_scope ? SD_RESOLVED_MDNS_IPV6 : 0);
 110
 111         return sd_bus_message_append(reply, "t", mask);
 112 }
 113
 114 static int property_get_ntas(
 115                 sd_bus *bus,
 116                 const char *path,
 117                 const char *interface,
 118                 const char *property,
 119                 sd_bus_message *reply,
 120                 void *userdata,
 121                 sd_bus_error *error) {
 122
 123         Link *l = userdata;
 124         const char *name;
 125         Iterator i;
 126         int r;
 127
 128         assert(reply);
 129         assert(l);
 130
 131         r = sd_bus_message_open_container(reply, 'a', "s");
 132         if (r < 0)
 133                 return r;
 134
 135         SET_FOREACH(name, l->dnssec_negative_trust_anchors, i) {
 136                 r = sd_bus_message_append(reply, "s", name);
 137                 if (r < 0)
 138                         return r;
 139         }
 140
 141         return sd_bus_message_close_container(reply);
 142 }
 143
 144 static int property_get_dnssec_supported(
 145                 sd_bus *bus,
 146                 const char *path,
 147                 const char *interface,
 148                 const char *property,
 149                 sd_bus_message *reply,
 150                 void *userdata,
 151                 sd_bus_error *error) {
 152
 153         Link *l = userdata;
 154
 155         assert(reply);
 156         assert(l);
 157
 158         return sd_bus_message_append(reply, "b", link_dnssec_supported(l));
 159 }
 160
 161 int bus_link_method_set_dns_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 162         _cleanup_free_ struct in_addr_data *dns = NULL;
 163         size_t allocated = 0, n = 0;
 164         Link *l = userdata;
 165         unsigned i;
 166         int r;
 167
 168         assert(message);
 169         assert(l);
 170
 171         r = sd_bus_message_enter_container(message, 'a', "(iay)");
 172         if (r < 0)
 173                 return r;
 174
 175         for (;;) {
 176                 int family;
 177                 size_t sz;
 178                 const void *d;
 179
 180                 assert_cc(sizeof(int) == sizeof(int32_t));
 181
 182                 r = sd_bus_message_enter_container(message, 'r', "iay");
 183                 if (r < 0)
 184                         return r;
 185                 if (r == 0)
 186                         break;
 187
 188                 r = sd_bus_message_read(message, "i", &family);
 189                 if (r < 0)
 190                         return r;
 191
 192                 if (!IN_SET(family, AF_INET, AF_INET6))
 193                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);
 194
 195                 r = sd_bus_message_read_array(message, 'y', &d, &sz);
 196                 if (r < 0)
 197                         return r;
 198                 if (sz != FAMILY_ADDRESS_SIZE(family))
 199                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address size");
 200
 201                 r = sd_bus_message_exit_container(message);
 202                 if (r < 0)
 203                         return r;
 204
 205                 if (!GREEDY_REALLOC(dns, allocated, n+1))
 206                         return -ENOMEM;
 207
 208                 dns[n].family = family;
 209                 memcpy(&dns[n].address, d, sz);
 210                 n++;
 211         }
 212
 213         r = sd_bus_message_exit_container(message);
 214         if (r < 0)
 215                 return r;
 216
 217         dns_server_mark_all(l->dns_servers);
 218
 219         for (i = 0; i < n; i++) {
 220                 DnsServer *s;
 221
 222                 s = dns_server_find(l->dns_servers, dns[i].family, &dns[i].address, 0);
 223                 if (s)
 224                         dns_server_move_back_and_unmark(s);
 225                 else {
 226                         r = dns_server_new(l->manager, NULL, DNS_SERVER_LINK, l, dns[i].family, &dns[i].address, 0);
 227                         if (r < 0)
 228                                 goto clear;
 229                 }
 230
 231         }
 232
 233         dns_server_unlink_marked(l->dns_servers);
 234         link_allocate_scopes(l);
 235
 236         (void) manager_write_resolv_conf(l->manager);
 237
 238         return sd_bus_reply_method_return(message, NULL);
 239
 240 clear:
 241         dns_server_unlink_all(l->dns_servers);
 242         return r;
 243 }
 244
 245 int bus_link_method_set_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 246         Link *l = userdata;
 247         int r;
 248
 249         assert(message);
 250         assert(l);
 251
 252         r = sd_bus_message_enter_container(message, 'a', "(sb)");
 253         if (r < 0)
 254                 return r;
 255
 256         for (;;) {
 257                 const char *name;
 258                 int route_only;
 259
 260                 r = sd_bus_message_read(message, "(sb)", &name, &route_only);
 261                 if (r < 0)
 262                         return r;
 263                 if (r == 0)
 264                         break;
 265
 266                 r = dns_name_is_valid(name);
 267                 if (r < 0)
 268                         return r;
 269                 if (r == 0)
 270                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid search domain %s", name);
 271                 if (!route_only && dns_name_is_root(name))
 272                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Root domain is not suitable as search domain");
 273         }
 274
 275         dns_search_domain_mark_all(l->search_domains);
 276
 277         r = sd_bus_message_rewind(message, false);
 278         if (r < 0)
 279                 return r;
 280
 281         for (;;) {
 282                 DnsSearchDomain *d;
 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                         goto clear;
 289                 if (r == 0)
 290                         break;
 291
 292                 r = dns_search_domain_find(l->search_domains, name, &d);
 293                 if (r < 0)
 294                         goto clear;
 295
 296                 if (r > 0)
 297                         dns_search_domain_move_back_and_unmark(d);
 298                 else {
 299                         r = dns_search_domain_new(l->manager, &d, DNS_SEARCH_DOMAIN_LINK, l, name);
 300                         if (r < 0)
 301                                 goto clear;
 302                 }
 303
 304                 d->route_only = route_only;
 305         }
 306
 307         r = sd_bus_message_exit_container(message);
 308         if (r < 0)
 309                 goto clear;
 310
 311         dns_search_domain_unlink_marked(l->search_domains);
 312
 313         (void) manager_write_resolv_conf(l->manager);
 314
 315         return sd_bus_reply_method_return(message, NULL);
 316
 317 clear:
 318         dns_search_domain_unlink_all(l->search_domains);
 319         return r;
 320 }
 321
 322 int bus_link_method_set_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 323         Link *l = userdata;
 324         ResolveSupport mode;
 325         const char *llmnr;
 326         int r;
 327
 328         assert(message);
 329         assert(l);
 330
 331         r = sd_bus_message_read(message, "s", &llmnr);
 332         if (r < 0)
 333                 return r;
 334
 335         if (isempty(llmnr))
 336                 mode = RESOLVE_SUPPORT_YES;
 337         else {
 338                 mode = resolve_support_from_string(llmnr);
 339                 if (mode < 0)
 340                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid LLMNR setting: %s", llmnr);
 341         }
 342
 343         l->llmnr_support = mode;
 344         link_allocate_scopes(l);
 345         link_add_rrs(l, false);
 346
 347         return sd_bus_reply_method_return(message, NULL);
 348 }
 349
 350 int bus_link_method_set_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 351         Link *l = userdata;
 352         ResolveSupport mode;
 353         const char *mdns;
 354         int r;
 355
 356         assert(message);
 357         assert(l);
 358
 359         r = sd_bus_message_read(message, "s", &mdns);
 360         if (r < 0)
 361                 return r;
 362
 363         if (isempty(mdns))
 364                 mode = RESOLVE_SUPPORT_NO;
 365         else {
 366                 mode = resolve_support_from_string(mdns);
 367                 if (mode < 0)
 368                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid MulticastDNS setting: %s", mdns);
 369         }
 370
 371         l->mdns_support = mode;
 372         link_allocate_scopes(l);
 373         link_add_rrs(l, false);
 374
 375         return sd_bus_reply_method_return(message, NULL);
 376 }
 377
 378 int bus_link_method_set_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 379         Link *l = userdata;
 380         const char *dnssec;
 381         DnssecMode mode;
 382         int r;
 383
 384         assert(message);
 385         assert(l);
 386
 387         r = sd_bus_message_read(message, "s", &dnssec);
 388         if (r < 0)
 389                 return r;
 390
 391         if (isempty(dnssec))
 392                 mode = _DNSSEC_MODE_INVALID;
 393         else {
 394                 mode = dnssec_mode_from_string(dnssec);
 395                 if (mode < 0)
 396                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSSEC setting: %s", dnssec);
 397         }
 398
 399         link_set_dnssec_mode(l, mode);
 400
 401         return sd_bus_reply_method_return(message, NULL);
 402 }
 403
 404 int bus_link_method_set_dnssec_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 405         _cleanup_set_free_free_ Set *ns = NULL;
 406         _cleanup_free_ char **ntas = NULL;
 407         Link *l = userdata;
 408         int r;
 409         char **i;
 410
 411         assert(message);
 412         assert(l);
 413
 414         r = sd_bus_message_read_strv(message, &ntas);
 415         if (r < 0)
 416                 return r;
 417
 418         STRV_FOREACH(i, ntas) {
 419                 r = dns_name_is_valid(*i);
 420                 if (r < 0)
 421                         return r;
 422                 if (r == 0)
 423                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid negative trust anchor domain: %s", *i);
 424         }
 425
 426         ns = set_new(&dns_name_hash_ops);
 427         if (!ns)
 428                 return -ENOMEM;
 429
 430         STRV_FOREACH(i, ntas) {
 431                 r = set_put_strdup(ns, *i);
 432                 if (r < 0)
 433                         return r;
 434         }
 435
 436         set_free_free(l->dnssec_negative_trust_anchors);
 437         l->dnssec_negative_trust_anchors = ns;
 438         ns = NULL;
 439
 440         return sd_bus_reply_method_return(message, NULL);
 441 }
 442
 443 int bus_link_method_revert(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 444         Link *l = userdata;
 445
 446         assert(message);
 447         assert(l);
 448
 449         link_flush_settings(l);
 450         link_allocate_scopes(l);
 451         link_add_rrs(l, false);
 452
 453         (void) manager_write_resolv_conf(l->manager);
 454
 455         return sd_bus_reply_method_return(message, NULL);
 456 }
 457
 458 const sd_bus_vtable link_vtable[] = {
 459         SD_BUS_VTABLE_START(0),
 460
 461         SD_BUS_PROPERTY("ScopesMask", "t", property_get_scopes_mask, 0, 0),
 462         SD_BUS_PROPERTY("DNS", "a(iay)", property_get_dns, 0, 0),
 463         SD_BUS_PROPERTY("Domains", "a(sb)", property_get_domains, 0, 0),
 464         SD_BUS_PROPERTY("LLMNR", "s", property_get_resolve_support, offsetof(Link, llmnr_support), 0),
 465         SD_BUS_PROPERTY("MulticastDNS", "s", property_get_resolve_support, offsetof(Link, mdns_support), 0),
 466         SD_BUS_PROPERTY("DNSSEC", "s", property_get_dnssec_mode, offsetof(Link, dnssec_mode), 0),
 467         SD_BUS_PROPERTY("DNSSECNegativeTrustAnchors", "as", property_get_ntas, 0, 0),
 468         SD_BUS_PROPERTY("DNSSECSupported", "b", property_get_dnssec_supported, 0, 0),
 469
 470         SD_BUS_METHOD("SetDNS", "a(iay)", NULL, bus_link_method_set_dns_servers, 0),
 471         SD_BUS_METHOD("SetDomains", "a(sb)", NULL, bus_link_method_set_domains, 0),
 472         SD_BUS_METHOD("SetLLMNR", "s", NULL, bus_link_method_set_llmnr, 0),
 473         SD_BUS_METHOD("SetMulticastDNS", "s", NULL, bus_link_method_set_mdns, 0),
 474         SD_BUS_METHOD("SetDNSSEC", "s", NULL, bus_link_method_set_dnssec, 0),
 475         SD_BUS_METHOD("SetDNSSECNegativeTrustAnchors", "as", NULL, bus_link_method_set_dnssec_negative_trust_anchors, 0),
 476         SD_BUS_METHOD("Revert", NULL, NULL, bus_link_method_revert, 0),
 477
 478         SD_BUS_VTABLE_END
 479 };
 480
 481 int link_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 482         _cleanup_free_ char *e = NULL;
 483         Manager *m = userdata;
 484         int ifindex;
 485         Link *link;
 486         int r;
 487
 488         assert(bus);
 489         assert(path);
 490         assert(interface);
 491         assert(found);
 492         assert(m);
 493
 494         r = sd_bus_path_decode(path, "/org/freedesktop/resolve1/link", &e);
 495         if (r <= 0)
 496                 return 0;
 497
 498         r = parse_ifindex(e, &ifindex);
 499         if (r < 0)
 500                 return 0;
 501
 502         link = hashmap_get(m->links, INT_TO_PTR(ifindex));
 503         if (!link)
 504                 return 0;
 505
 506         *found = link;
 507         return 1;
 508 }
 509
 510 char *link_bus_path(Link *link) {
 511         _cleanup_free_ char *ifindex = NULL;
 512         char *p;
 513         int r;
 514
 515         assert(link);
 516
 517         if (asprintf(&ifindex, "%i", link->ifindex) < 0)
 518                 return NULL;
 519
 520         r = sd_bus_path_encode("/org/freedesktop/resolve1/link", ifindex, &p);
 521         if (r < 0)
 522                 return NULL;
 523
 524         return p;
 525 }
 526
 527 int link_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 528         _cleanup_strv_free_ char **l = NULL;
 529         Manager *m = userdata;
 530         Link *link;
 531         Iterator i;
 532         unsigned c = 0;
 533
 534         assert(bus);
 535         assert(path);
 536         assert(m);
 537         assert(nodes);
 538
 539         l = new0(char*, hashmap_size(m->links) + 1);
 540         if (!l)
 541                 return -ENOMEM;
 542
 543         HASHMAP_FOREACH(link, m->links, i) {
 544                 char *p;
 545
 546                 p = link_bus_path(link);
 547                 if (!p)
 548                         return -ENOMEM;
 549
 550                 l[c++] = p;
 551         }
 552
 553         l[c] = NULL;
 554         *nodes = l;
 555         l = NULL;
 556
 557         return 1;
 558 }