src/network/networkd-dhcp6.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright (C) 2014 Intel Corporation. All rights reserved.
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <netinet/ether.h>
  23 #include <linux/if.h>
  24
  25 #include "networkd-link.h"
  26 #include "network-internal.h"
  27
  28 #include "sd-icmp6-nd.h"
  29 #include "sd-dhcp6-client.h"
  30
  31 static int dhcp6_lease_information_acquired(sd_dhcp6_client *client,
  32                                         Link *link) {
  33         return 0;
  34 }
  35
  36 static int dhcp6_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
  37                                  void *userdata) {
  38         _cleanup_link_unref_ Link *link = userdata;
  39         int r;
  40
  41         assert(link);
  42
  43         r = sd_rtnl_message_get_errno(m);
  44         if (r < 0 && r != -EEXIST) {
  45                 log_link_error(link, "Could not set DHCPv6 address: %s",
  46                                strerror(-r));
  47
  48                 link_enter_failed(link);
  49
  50         } else if (r >= 0)
  51                 link_rtnl_process_address(rtnl, m, link->manager);
  52
  53         return 1;
  54 }
  55
  56 static int dhcp6_address_update(Link *link, struct in6_addr *ip6_addr,
  57                                 uint8_t prefixlen, uint32_t lifetime_preferred,
  58                                 uint32_t lifetime_valid) {
  59         int r;
  60         _cleanup_address_free_ Address *addr = NULL;
  61
  62         r = address_new_dynamic(&addr);
  63         if (r < 0)
  64                 return r;
  65
  66         addr->family = AF_INET6;
  67         memcpy(&addr->in_addr.in6, ip6_addr, sizeof(*ip6_addr));
  68
  69         addr->flags = IFA_F_NOPREFIXROUTE;
  70         addr->prefixlen = 64;
  71
  72         addr->cinfo.ifa_prefered = lifetime_preferred;
  73         addr->cinfo.ifa_valid = lifetime_valid;
  74
  75         log_link_struct(link, LOG_INFO, "MESSAGE=%-*s: DHCPv6 address "SD_ICMP6_ADDRESS_FORMAT_STR"/%d timeout preferred %d valid %d",
  76                         IFNAMSIZ,
  77                         link->ifname, SD_ICMP6_ADDRESS_FORMAT_VAL(addr->in_addr.in6),
  78                         addr->prefixlen, lifetime_preferred, lifetime_valid,
  79                         NULL);
  80
  81         r = address_update(addr, link, dhcp6_address_handler);
  82         if (r < 0)
  83                 log_link_warning(link, "Could not assign DHCPv6 address: %s",
  84                                 strerror(-r));
  85
  86         return r;
  87 }
  88
  89 static int dhcp6_lease_address_acquired(sd_dhcp6_client *client, Link *link) {
  90         int r;
  91         sd_dhcp6_lease *lease;
  92         struct in6_addr ip6_addr;
  93         uint32_t lifetime_preferred, lifetime_valid;
  94         uint8_t prefixlen;
  95
  96         r = sd_dhcp6_client_get_lease(client, &lease);
  97         if (r < 0)
  98                 return r;
  99
 100         sd_dhcp6_lease_reset_address_iter(lease);
 101
 102         while (sd_dhcp6_lease_get_address(lease, &ip6_addr,
 103                                                 &lifetime_preferred,
 104                                                 &lifetime_valid) >= 0) {
 105
 106                 r = sd_icmp6_ra_get_prefixlen(link->icmp6_router_discovery,
 107                                         &ip6_addr, &prefixlen);
 108                 if (r < 0 && r != -EADDRNOTAVAIL) {
 109                         log_link_warning(link, "Could not get prefix information: %s",
 110                                         strerror(-r));
 111                         return r;
 112                 }
 113
 114                 if (r == -EADDRNOTAVAIL)
 115                         prefixlen = 128;
 116
 117                 r = dhcp6_address_update(link, &ip6_addr, prefixlen,
 118                                         lifetime_preferred, lifetime_valid);
 119                 if (r < 0)
 120                         return r;
 121         }
 122
 123         return 0;
 124 }
 125
 126 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
 127         int r;
 128         Link *link = userdata;
 129
 130         assert(link);
 131         assert(link->network);
 132         assert(link->manager);
 133
 134         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 135                 return;
 136
 137         switch(event) {
 138         case DHCP6_EVENT_STOP:
 139         case DHCP6_EVENT_RESEND_EXPIRE:
 140         case DHCP6_EVENT_RETRANS_MAX:
 141                 log_link_debug(link, "DHCPv6 event %d", event);
 142                 break;
 143
 144         case DHCP6_EVENT_IP_ACQUIRE:
 145                 r = dhcp6_lease_address_acquired(client, link);
 146                 if (r < 0) {
 147                         link_enter_failed(link);
 148                         return;
 149                 }
 150
 151                 /* fall through */
 152         case DHCP6_EVENT_INFORMATION_REQUEST:
 153                 r = dhcp6_lease_information_acquired(client, link);
 154                 if (r < 0) {
 155                         link_enter_failed(link);
 156                         return;
 157                 }
 158
 159                 break;
 160
 161         default:
 162                 if (event < 0)
 163                         log_link_warning(link, "DHCPv6 error: %s",
 164                                          strerror(-event));
 165                 else
 166                         log_link_warning(link, "DHCPv6 unknown event: %d",
 167                                          event);
 168                 return;
 169         }
 170 }
 171
 172 static int dhcp6_configure(Link *link, int event) {
 173         int r;
 174         bool information_request;
 175
 176         assert_return(link, -EINVAL);
 177
 178         if (link->dhcp6_client) {
 179                 if (event != ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED)
 180                         return 0;
 181
 182                 r = sd_dhcp6_client_get_information_request(link->dhcp6_client,
 183                                                         &information_request);
 184                 if (r < 0) {
 185                         log_link_warning(link, "Could not get DHCPv6 Information request setting: %s",
 186                                         strerror(-r));
 187                         link->dhcp6_client =
 188                                 sd_dhcp6_client_unref(link->dhcp6_client);
 189                         return r;
 190                 }
 191
 192                 if (!information_request)
 193                         return r;
 194
 195                 r = sd_dhcp6_client_set_information_request(link->dhcp6_client,
 196                                                         false);
 197                 if (r < 0) {
 198                         log_link_warning(link, "Could not unset DHCPv6 Information request: %s",
 199                                         strerror(-r));
 200                         link->dhcp6_client =
 201                                 sd_dhcp6_client_unref(link->dhcp6_client);
 202                         return r;
 203                 }
 204
 205                 r = sd_dhcp6_client_start(link->dhcp6_client);
 206                 if (r < 0) {
 207                         log_link_warning(link, "Could not restart DHCPv6 after enabling Information request: %s",
 208                                         strerror(-r));
 209                         link->dhcp6_client =
 210                                 sd_dhcp6_client_unref(link->dhcp6_client);
 211                         return r;
 212                 }
 213
 214                 return r;
 215         }
 216
 217         r = sd_dhcp6_client_new(&link->dhcp6_client);
 218         if (r < 0)
 219                 return r;
 220
 221         r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
 222         if (r < 0) {
 223                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
 224                 return r;
 225         }
 226
 227         r = sd_dhcp6_client_set_mac(link->dhcp6_client,
 228                                     (const uint8_t *) &link->mac,
 229                                     sizeof (link->mac), ARPHRD_ETHER);
 230         if (r < 0) {
 231                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
 232                 return r;
 233         }
 234
 235         r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
 236         if (r < 0) {
 237                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
 238                 return r;
 239         }
 240
 241         r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
 242                                          link);
 243         if (r < 0) {
 244                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
 245                 return r;
 246         }
 247
 248         if (event == ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER) {
 249                 r = sd_dhcp6_client_set_information_request(link->dhcp6_client,
 250                                                         true);
 251                 if (r < 0) {
 252                         link->dhcp6_client =
 253                                 sd_dhcp6_client_unref(link->dhcp6_client);
 254                         return r;
 255                 }
 256         }
 257
 258         r = sd_dhcp6_client_start(link->dhcp6_client);
 259         if (r < 0)
 260                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
 261
 262         return r;
 263 }
 264
 265 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
 266         Link *link = userdata;
 267
 268         assert(link);
 269         assert(link->network);
 270         assert(link->manager);
 271
 272         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 273                 return;
 274
 275         switch(event) {
 276         case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
 277         case ICMP6_EVENT_ROUTER_ADVERTISMENT_PREFIX_EXPIRED:
 278                 return;
 279
 280         case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
 281         case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
 282         case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
 283                 dhcp6_configure(link, event);
 284
 285                 break;
 286
 287         default:
 288                 if (event < 0)
 289                         log_link_warning(link, "ICMPv6 error: %s",
 290                                          strerror(-event));
 291                 else
 292                         log_link_warning(link, "ICMPv6 unknown event: %d",
 293                                          event);
 294
 295                 break;
 296         }
 297
 298 }
 299
 300 int icmp6_configure(Link *link) {
 301         int r;
 302
 303         assert_return(link, -EINVAL);
 304
 305         r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
 306         if (r < 0)
 307                 return r;
 308
 309         r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery, NULL, 0);
 310         if (r < 0)
 311                 return r;
 312
 313         r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery, &link->mac);
 314         if (r < 0)
 315                 return r;
 316
 317         r = sd_icmp6_nd_set_index(link->icmp6_router_discovery, link->ifindex);
 318         if (r < 0)
 319                 return r;
 320
 321         r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
 322                                 icmp6_router_handler, link);
 323
 324         return r;
 325 }