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