src/network/networkd-ndisc.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright (C) 2014 Intel Corporation. All rights reserved.
   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 <netinet/ether.h>
  21 #include <netinet/icmp6.h>
  22 #include <netinet/in.h>
  23 #include <linux/if.h>
  24
  25 #include "sd-ndisc.h"
  26
  27 #include "networkd.h"
  28
  29 static int ndisc_netlink_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
  30         _cleanup_link_unref_ Link *link = userdata;
  31         int r;
  32
  33         assert(link);
  34         assert(link->ndisc_messages > 0);
  35
  36         link->ndisc_messages--;
  37
  38         r = sd_netlink_message_get_errno(m);
  39         if (r < 0 && r != -EEXIST) {
  40                 log_link_error_errno(link, r, "Could not set NDisc route or address: %m");
  41                 link_enter_failed(link);
  42         }
  43
  44         if (link->ndisc_messages == 0) {
  45                 link->ndisc_configured = true;
  46                 link_check_ready(link);
  47         }
  48
  49         return 1;
  50 }
  51
  52 static void ndisc_prefix_autonomous_handler(sd_ndisc *nd, const struct in6_addr *prefix, unsigned prefixlen,
  53                                             unsigned lifetime_preferred, unsigned lifetime_valid, void *userdata) {
  54         _cleanup_address_free_ Address *address = NULL;
  55         Link *link = userdata;
  56         usec_t time_now;
  57         int r;
  58
  59         assert(nd);
  60         assert(link);
  61         assert(link->network);
  62
  63         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
  64                 return;
  65
  66         r = address_new(&address);
  67         if (r < 0) {
  68                 log_link_error_errno(link, r, "Could not allocate address: %m");
  69                 return;
  70         }
  71
  72         assert_se(sd_event_now(link->manager->event, clock_boottime_or_monotonic(), &time_now) >= 0);
  73
  74         address->family = AF_INET6;
  75         address->in_addr.in6 = *prefix;
  76         if (in_addr_is_null(AF_INET6, (const union in_addr_union *) &link->network->ipv6_token) == 0)
  77                 memcpy(((char *)&address->in_addr.in6) + 8, ((char *)&link->network->ipv6_token) + 8, 8);
  78         else {
  79                 /* see RFC4291 section 2.5.1 */
  80                 address->in_addr.in6.s6_addr[8]  = link->mac.ether_addr_octet[0];
  81                 address->in_addr.in6.s6_addr[8] ^= 1 << 1;
  82                 address->in_addr.in6.s6_addr[9]  = link->mac.ether_addr_octet[1];
  83                 address->in_addr.in6.s6_addr[10] = link->mac.ether_addr_octet[2];
  84                 address->in_addr.in6.s6_addr[11] = 0xff;
  85                 address->in_addr.in6.s6_addr[12] = 0xfe;
  86                 address->in_addr.in6.s6_addr[13] = link->mac.ether_addr_octet[3];
  87                 address->in_addr.in6.s6_addr[14] = link->mac.ether_addr_octet[4];
  88                 address->in_addr.in6.s6_addr[15] = link->mac.ether_addr_octet[5];
  89         }
  90         address->prefixlen = prefixlen;
  91         address->flags = IFA_F_NOPREFIXROUTE|IFA_F_MANAGETEMPADDR;
  92         address->cinfo.ifa_prefered = lifetime_preferred;
  93         address->cinfo.ifa_valid = lifetime_valid;
  94
  95         r = address_configure(address, link, ndisc_netlink_handler, true);
  96         if (r < 0) {
  97                 log_link_warning_errno(link, r, "Could not set SLAAC address: %m");
  98                 link_enter_failed(link);
  99                 return;
 100         }
 101
 102         link->ndisc_messages++;
 103 }
 104
 105 static void ndisc_prefix_onlink_handler(sd_ndisc *nd, const struct in6_addr *prefix, unsigned prefixlen, unsigned lifetime, void *userdata) {
 106         _cleanup_route_free_ Route *route = NULL;
 107         Link *link = userdata;
 108         usec_t time_now;
 109         int r;
 110
 111         assert(nd);
 112         assert(link);
 113
 114         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 115                 return;
 116
 117         r = route_new(&route);
 118         if (r < 0) {
 119                 log_link_error_errno(link, r, "Could not allocate route: %m");
 120                 return;
 121         }
 122
 123         assert_se(sd_event_now(link->manager->event, clock_boottime_or_monotonic(), &time_now) >= 0);
 124
 125         route->family = AF_INET6;
 126         route->table = RT_TABLE_MAIN;
 127         route->protocol = RTPROT_RA;
 128         route->flags = RTM_F_PREFIX;
 129         route->dst.in6 = *prefix;
 130         route->dst_prefixlen = prefixlen;
 131         route->lifetime = time_now + lifetime * USEC_PER_SEC;
 132
 133         r = route_configure(route, link, ndisc_netlink_handler);
 134         if (r < 0) {
 135                 log_link_warning_errno(link, r, "Could not set prefix route: %m");
 136                 link_enter_failed(link);
 137                 return;
 138         }
 139
 140         link->ndisc_messages++;
 141 }
 142
 143 static void ndisc_router_handler(sd_ndisc *nd, uint8_t flags, const struct in6_addr *gateway, unsigned lifetime, int pref, void *userdata) {
 144         _cleanup_route_free_ Route *route = NULL;
 145         Link *link = userdata;
 146         usec_t time_now;
 147         int r;
 148
 149         assert(link);
 150         assert(link->network);
 151         assert(link->manager);
 152
 153         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 154                 return;
 155
 156         if (flags & (ND_RA_FLAG_MANAGED | ND_RA_FLAG_OTHER)) {
 157                 if (flags & ND_RA_FLAG_MANAGED)
 158                         dhcp6_request_address(link);
 159
 160                 r = sd_dhcp6_client_set_local_address(link->dhcp6_client, &link->ipv6ll_address);
 161                 if (r < 0 && r != -EBUSY)
 162                         log_link_warning_errno(link, r, "Could not set IPv6LL address in DHCP client: %m");
 163
 164                 r = sd_dhcp6_client_start(link->dhcp6_client);
 165                 if (r < 0 && r != -EBUSY)
 166                         log_link_warning_errno(link, r, "Starting DHCPv6 client on NDisc request failed: %m");
 167         }
 168
 169         if (!gateway)
 170                 return;
 171
 172         r = route_new(&route);
 173         if (r < 0) {
 174                 log_link_error_errno(link, r, "Could not allocate route: %m");
 175                 return;
 176         }
 177
 178         assert_se(sd_event_now(link->manager->event, clock_boottime_or_monotonic(), &time_now) >= 0);
 179
 180         route->family = AF_INET6;
 181         route->table = RT_TABLE_MAIN;
 182         route->protocol = RTPROT_RA;
 183         route->pref = pref;
 184         route->gw.in6 = *gateway;
 185         route->lifetime = time_now + lifetime * USEC_PER_SEC;
 186
 187         r = route_configure(route, link, ndisc_netlink_handler);
 188         if (r < 0) {
 189                 log_link_warning_errno(link, r, "Could not set default route: %m");
 190                 link_enter_failed(link);
 191                 return;
 192         }
 193
 194         link->ndisc_messages++;
 195 }
 196
 197 static void ndisc_handler(sd_ndisc *nd, int event, void *userdata) {
 198         Link *link = userdata;
 199         int r;
 200
 201         assert(link);
 202
 203         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 204                 return;
 205
 206         switch (event) {
 207         case SD_NDISC_EVENT_TIMEOUT:
 208                 dhcp6_request_address(link);
 209
 210                 r = sd_dhcp6_client_set_local_address(link->dhcp6_client, &link->ipv6ll_address);
 211                 if (r < 0 && r != -EBUSY)
 212                         log_link_warning_errno(link, r, "Could not set IPv6LL address in DHCP client: %m");
 213
 214                 r = sd_dhcp6_client_start(link->dhcp6_client);
 215                 if (r < 0 && r != -EBUSY)
 216                         log_link_warning_errno(link, r, "Starting DHCPv6 client after NDisc timeout failed: %m");
 217
 218                 link->ndisc_configured = true;
 219                 link_check_ready(link);
 220
 221                 break;
 222         case SD_NDISC_EVENT_STOP:
 223                 break;
 224         default:
 225                 log_link_warning(link, "IPv6 Neighbor Discovery unknown event: %d", event);
 226         }
 227 }
 228
 229 int ndisc_configure(Link *link) {
 230         int r;
 231
 232         assert_return(link, -EINVAL);
 233
 234         r = sd_ndisc_new(&link->ndisc_router_discovery);
 235         if (r < 0)
 236                 return r;
 237
 238         r = sd_ndisc_attach_event(link->ndisc_router_discovery, NULL, 0);
 239         if (r < 0)
 240                 return r;
 241
 242         r = sd_ndisc_set_mac(link->ndisc_router_discovery, &link->mac);
 243         if (r < 0)
 244                 return r;
 245
 246         r = sd_ndisc_set_ifindex(link->ndisc_router_discovery, link->ifindex);
 247         if (r < 0)
 248                 return r;
 249
 250         r = sd_ndisc_set_callback(link->ndisc_router_discovery,
 251                                   ndisc_router_handler,
 252                                   ndisc_prefix_onlink_handler,
 253                                   ndisc_prefix_autonomous_handler,
 254                                   ndisc_handler,
 255                                   link);
 256
 257         return r;
 258 }