src/network/networkd-radv.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright (C) 2017 Intel Corporation. All rights reserved.
   6 ***/
   7
   8 #include <netinet/icmp6.h>
   9 #include <arpa/inet.h>
  10
  11 #include "networkd-address.h"
  12 #include "networkd-manager.h"
  13 #include "networkd-radv.h"
  14 #include "parse-util.h"
  15 #include "sd-radv.h"
  16 #include "string-util.h"
  17
  18 int config_parse_router_prefix_delegation(
  19                 const char *unit,
  20                 const char *filename,
  21                 unsigned line,
  22                 const char *section,
  23                 unsigned section_line,
  24                 const char *lvalue,
  25                 int ltype,
  26                 const char *rvalue,
  27                 void *data,
  28                 void *userdata) {
  29
  30         Network *network = userdata;
  31         int d;
  32
  33         assert(filename);
  34         assert(section);
  35         assert(lvalue);
  36         assert(rvalue);
  37         assert(data);
  38
  39         if (streq(rvalue, "static"))
  40                 network->router_prefix_delegation = RADV_PREFIX_DELEGATION_STATIC;
  41         else if (streq(rvalue, "dhcpv6"))
  42                 network->router_prefix_delegation = RADV_PREFIX_DELEGATION_DHCP6;
  43         else {
  44                 d = parse_boolean(rvalue);
  45                 if (d > 0)
  46                         network->router_prefix_delegation = RADV_PREFIX_DELEGATION_BOTH;
  47                 else
  48                         network->router_prefix_delegation = RADV_PREFIX_DELEGATION_NONE;
  49
  50                 if (d < 0)
  51                         log_syntax(unit, LOG_ERR, filename, line, -EINVAL, "Router prefix delegation '%s' is invalid, ignoring assignment: %m", rvalue);
  52         }
  53
  54         return 0;
  55 }
  56
  57 int config_parse_router_preference(const char *unit,
  58                                    const char *filename,
  59                                    unsigned line,
  60                                    const char *section,
  61                                    unsigned section_line,
  62                                    const char *lvalue,
  63                                    int ltype,
  64                                    const char *rvalue,
  65                                    void *data,
  66                                    void *userdata) {
  67         Network *network = userdata;
  68
  69         assert(filename);
  70         assert(section);
  71         assert(lvalue);
  72         assert(rvalue);
  73         assert(data);
  74
  75         if (streq(rvalue, "high"))
  76                 network->router_preference = SD_NDISC_PREFERENCE_HIGH;
  77         else if (STR_IN_SET(rvalue, "medium", "normal", "default"))
  78                 network->router_preference = SD_NDISC_PREFERENCE_MEDIUM;
  79         else if (streq(rvalue, "low"))
  80                 network->router_preference = SD_NDISC_PREFERENCE_LOW;
  81         else
  82                 log_syntax(unit, LOG_ERR, filename, line, -EINVAL, "Router preference '%s' is invalid, ignoring assignment: %m", rvalue);
  83
  84         return 0;
  85 }
  86
  87 void prefix_free(Prefix *prefix) {
  88         if (!prefix)
  89                 return;
  90
  91         if (prefix->network) {
  92                 LIST_REMOVE(prefixes, prefix->network->static_prefixes, prefix);
  93                 assert(prefix->network->n_static_prefixes > 0);
  94                 prefix->network->n_static_prefixes--;
  95
  96                 if (prefix->section)
  97                         hashmap_remove(prefix->network->prefixes_by_section,
  98                                        prefix->section);
  99         }
 100
 101         prefix->radv_prefix = sd_radv_prefix_unref(prefix->radv_prefix);
 102
 103         free(prefix);
 104 }
 105
 106 int prefix_new(Prefix **ret) {
 107         Prefix *prefix = NULL;
 108
 109         prefix = new0(Prefix, 1);
 110         if (!prefix)
 111                 return -ENOMEM;
 112
 113         if (sd_radv_prefix_new(&prefix->radv_prefix) < 0)
 114                 return -ENOMEM;
 115
 116         *ret = TAKE_PTR(prefix);
 117
 118         return 0;
 119 }
 120
 121 int prefix_new_static(Network *network, const char *filename,
 122                       unsigned section_line, Prefix **ret) {
 123         _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
 124         _cleanup_(prefix_freep) Prefix *prefix = NULL;
 125         int r;
 126
 127         assert(network);
 128         assert(ret);
 129         assert(!!filename == (section_line > 0));
 130
 131         if (filename) {
 132                 r = network_config_section_new(filename, section_line, &n);
 133                 if (r < 0)
 134                         return r;
 135
 136                 if (section_line) {
 137                         prefix = hashmap_get(network->prefixes_by_section, n);
 138                         if (prefix) {
 139                                 *ret = TAKE_PTR(prefix);
 140
 141                                 return 0;
 142                         }
 143                 }
 144         }
 145
 146         r = prefix_new(&prefix);
 147         if (r < 0)
 148                 return r;
 149
 150         if (filename) {
 151                 prefix->section = TAKE_PTR(n);
 152
 153                 r = hashmap_put(network->prefixes_by_section, prefix->section,
 154                                 prefix);
 155                 if (r < 0)
 156                         return r;
 157         }
 158
 159         prefix->network = network;
 160         LIST_APPEND(prefixes, network->static_prefixes, prefix);
 161         network->n_static_prefixes++;
 162
 163         *ret = TAKE_PTR(prefix);
 164
 165         return 0;
 166 }
 167
 168 int config_parse_prefix(const char *unit,
 169                 const char *filename,
 170                 unsigned line,
 171                 const char *section,
 172                 unsigned section_line,
 173                 const char *lvalue,
 174                 int ltype,
 175                 const char *rvalue,
 176                 void *data,
 177                 void *userdata) {
 178
 179         Network *network = userdata;
 180         _cleanup_(prefix_freep) Prefix *p = NULL;
 181         uint8_t prefixlen = 64;
 182         union in_addr_union in6addr;
 183         int r;
 184
 185         assert(filename);
 186         assert(section);
 187         assert(lvalue);
 188         assert(rvalue);
 189         assert(data);
 190
 191         r = prefix_new_static(network, filename, section_line, &p);
 192         if (r < 0)
 193                 return r;
 194
 195         r = in_addr_prefix_from_string(rvalue, AF_INET6, &in6addr, &prefixlen);
 196         if (r < 0) {
 197                 log_syntax(unit, LOG_ERR, filename, line, r, "Prefix is invalid, ignoring assignment: %s", rvalue);
 198                 return 0;
 199         }
 200
 201         if (sd_radv_prefix_set_prefix(p->radv_prefix, &in6addr.in6, prefixlen) < 0)
 202                 return -EADDRNOTAVAIL;
 203
 204         log_syntax(unit, LOG_INFO, filename, line, r, "Found prefix %s", rvalue);
 205
 206         p = NULL;
 207
 208         return 0;
 209 }
 210
 211 int config_parse_prefix_flags(const char *unit,
 212                               const char *filename,
 213                               unsigned line,
 214                               const char *section,
 215                               unsigned section_line,
 216                               const char *lvalue,
 217                               int ltype,
 218                               const char *rvalue,
 219                               void *data,
 220                               void *userdata) {
 221         Network *network = userdata;
 222         _cleanup_(prefix_freep) Prefix *p = NULL;
 223         int r, val;
 224
 225         assert(filename);
 226         assert(section);
 227         assert(lvalue);
 228         assert(rvalue);
 229         assert(data);
 230
 231         r = prefix_new_static(network, filename, section_line, &p);
 232         if (r < 0)
 233                 return r;
 234
 235         r = parse_boolean(rvalue);
 236         if (r < 0) {
 237                 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse address flag, ignoring: %s", rvalue);
 238                 return 0;
 239         }
 240
 241         val = r;
 242
 243         if (streq(lvalue, "OnLink"))
 244                 r = sd_radv_prefix_set_onlink(p->radv_prefix, val);
 245         else if (streq(lvalue, "AddressAutoconfiguration"))
 246                 r = sd_radv_prefix_set_address_autoconfiguration(p->radv_prefix, val);
 247         if (r < 0)
 248                 return r;
 249
 250         p = NULL;
 251
 252         return 0;
 253 }
 254
 255 int config_parse_prefix_lifetime(const char *unit,
 256                                  const char *filename,
 257                                  unsigned line,
 258                                  const char *section,
 259                                  unsigned section_line,
 260                                  const char *lvalue,
 261                                  int ltype,
 262                                  const char *rvalue,
 263                                  void *data,
 264                                  void *userdata) {
 265         Network *network = userdata;
 266         _cleanup_(prefix_freep) Prefix *p = NULL;
 267         usec_t usec;
 268         int r;
 269
 270         assert(filename);
 271         assert(section);
 272         assert(lvalue);
 273         assert(rvalue);
 274         assert(data);
 275
 276         r = prefix_new_static(network, filename, section_line, &p);
 277         if (r < 0)
 278                 return r;
 279
 280         r = parse_sec(rvalue, &usec);
 281         if (r < 0) {
 282                 log_syntax(unit, LOG_ERR, filename, line, r, "Lifetime is invalid, ignoring assignment: %s", rvalue);
 283                 return 0;
 284         }
 285
 286         /* a value of 0xffffffff represents infinity */
 287         if (streq(lvalue, "PreferredLifetimeSec"))
 288                 r = sd_radv_prefix_set_preferred_lifetime(p->radv_prefix,
 289                                                           DIV_ROUND_UP(usec, USEC_PER_SEC));
 290         else if (streq(lvalue, "ValidLifetimeSec"))
 291                 r = sd_radv_prefix_set_valid_lifetime(p->radv_prefix,
 292                                                       DIV_ROUND_UP(usec, USEC_PER_SEC));
 293         if (r < 0)
 294                 return r;
 295
 296         p = NULL;
 297
 298         return 0;
 299 }
 300
 301 static int radv_get_ip6dns(Network *network, struct in6_addr **dns,
 302                            size_t *n_dns) {
 303         _cleanup_free_ struct in6_addr *addresses = NULL;
 304         size_t i, n_addresses = 0, n_allocated = 0;
 305
 306         assert(network);
 307         assert(dns);
 308         assert(n_dns);
 309
 310         for (i = 0; i < network->n_dns; i++) {
 311                 union in_addr_union *addr;
 312
 313                 if (network->dns[i].family != AF_INET6)
 314                         continue;
 315
 316                 addr = &network->dns[i].address;
 317
 318                 if (in_addr_is_null(AF_INET6, addr) ||
 319                     in_addr_is_link_local(AF_INET6, addr) ||
 320                     in_addr_is_localhost(AF_INET6, addr))
 321                         continue;
 322
 323                 if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + 1))
 324                         return -ENOMEM;
 325
 326                 addresses[n_addresses++] = addr->in6;
 327         }
 328
 329         if (addresses) {
 330                 *dns = TAKE_PTR(addresses);
 331
 332                 *n_dns = n_addresses;
 333         }
 334
 335         return n_addresses;
 336 }
 337
 338 static int radv_set_dns(Link *link, Link *uplink) {
 339         _cleanup_free_ struct in6_addr *dns = NULL;
 340         size_t n_dns;
 341         usec_t lifetime_usec;
 342         int r;
 343
 344         if (!link->network->router_emit_dns)
 345                 return 0;
 346
 347         if (link->network->router_dns) {
 348                 dns = newdup(struct in6_addr, link->network->router_dns,
 349                              link->network->n_router_dns);
 350                 if (dns == NULL)
 351                         return -ENOMEM;
 352
 353                 n_dns = link->network->n_router_dns;
 354                 lifetime_usec = link->network->router_dns_lifetime_usec;
 355
 356                 goto set_dns;
 357         }
 358
 359         lifetime_usec = SD_RADV_DEFAULT_DNS_LIFETIME_USEC;
 360
 361         r = radv_get_ip6dns(link->network, &dns, &n_dns);
 362         if (r > 0)
 363                 goto set_dns;
 364
 365         if (uplink) {
 366                 if (uplink->network == NULL) {
 367                         log_link_debug(uplink, "Cannot fetch DNS servers as uplink interface is not managed by us");
 368                         return 0;
 369                 }
 370
 371                 r = radv_get_ip6dns(uplink->network, &dns, &n_dns);
 372                 if (r > 0)
 373                         goto set_dns;
 374         }
 375
 376         return 0;
 377
 378  set_dns:
 379         return sd_radv_set_rdnss(link->radv,
 380                                  DIV_ROUND_UP(lifetime_usec, USEC_PER_SEC),
 381                                  dns, n_dns);
 382 }
 383
 384 static int radv_set_domains(Link *link, Link *uplink) {
 385         char **search_domains;
 386         usec_t lifetime_usec;
 387
 388         if (!link->network->router_emit_domains)
 389                 return 0;
 390
 391         search_domains = link->network->router_search_domains;
 392         lifetime_usec = link->network->router_dns_lifetime_usec;
 393
 394         if (search_domains)
 395                 goto set_domains;
 396
 397         lifetime_usec = SD_RADV_DEFAULT_DNS_LIFETIME_USEC;
 398
 399         search_domains = link->network->search_domains;
 400         if (search_domains)
 401                 goto set_domains;
 402
 403         if (uplink) {
 404                 if (uplink->network == NULL) {
 405                         log_link_debug(uplink, "Cannot fetch DNS search domains as uplink interface is not managed by us");
 406                         return 0;
 407                 }
 408
 409                 search_domains = uplink->network->search_domains;
 410                 if (search_domains)
 411                         goto set_domains;
 412         }
 413
 414         return 0;
 415
 416  set_domains:
 417         return sd_radv_set_dnssl(link->radv,
 418                                  DIV_ROUND_UP(lifetime_usec, USEC_PER_SEC),
 419                                  search_domains);
 420
 421 }
 422
 423 int radv_emit_dns(Link *link) {
 424         Link *uplink;
 425         int r;
 426
 427         uplink = manager_find_uplink(link->manager, link);
 428
 429         r = radv_set_dns(link, uplink);
 430         if (r < 0)
 431                 log_link_warning_errno(link, r, "Could not set RA DNS: %m");
 432
 433         r = radv_set_domains(link, uplink);
 434         if (r < 0)
 435                 log_link_warning_errno(link, r, "Could not set RA Domains: %m");
 436
 437         return 0;
 438 }
 439
 440 int radv_configure(Link *link) {
 441         int r;
 442         Prefix *p;
 443
 444         assert(link);
 445         assert(link->network);
 446
 447         r = sd_radv_new(&link->radv);
 448         if (r < 0)
 449                 return r;
 450
 451         r = sd_radv_attach_event(link->radv, NULL, 0);
 452         if (r < 0)
 453                 return r;
 454
 455         r = sd_radv_set_mac(link->radv, &link->mac);
 456         if (r < 0)
 457                 return r;
 458
 459         r = sd_radv_set_ifindex(link->radv, link->ifindex);
 460         if (r < 0)
 461                 return r;
 462
 463         r = sd_radv_set_managed_information(link->radv, link->network->router_managed);
 464         if (r < 0)
 465                 return r;
 466
 467         r = sd_radv_set_other_information(link->radv, link->network->router_other_information);
 468         if (r < 0)
 469                 return r;
 470
 471         /* a value of 0xffffffff represents infinity, 0x0 means this host is
 472            not a router */
 473         r = sd_radv_set_router_lifetime(link->radv,
 474                                         DIV_ROUND_UP(link->network->router_lifetime_usec, USEC_PER_SEC));
 475         if (r < 0)
 476                 return r;
 477
 478         if (link->network->router_lifetime_usec > 0) {
 479                 r = sd_radv_set_preference(link->radv,
 480                                            link->network->router_preference);
 481                 if (r < 0)
 482                         return r;
 483         }
 484
 485         if (IN_SET(link->network->router_prefix_delegation,
 486                    RADV_PREFIX_DELEGATION_STATIC,
 487                    RADV_PREFIX_DELEGATION_BOTH)) {
 488                 LIST_FOREACH(prefixes, p, link->network->static_prefixes) {
 489                         r = sd_radv_add_prefix(link->radv, p->radv_prefix, false);
 490                         if (r != -EEXIST && r < 0)
 491                                 return r;
 492                 }
 493         }
 494
 495         return radv_emit_dns(link);
 496 }