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_prefix_expired(Link *link) {
  90         int r;
  91         sd_dhcp6_lease *lease;
  92         struct in6_addr *expired_prefix, ip6_addr;
  93         uint8_t expired_prefixlen;
  94         uint32_t lifetime_preferred, lifetime_valid;
  95
  96         r = sd_icmp6_ra_get_expired_prefix(link->icmp6_router_discovery,
  97                                         &expired_prefix, &expired_prefixlen);
  98         if (r < 0)
  99                 return r;
 100
 101         r = sd_dhcp6_client_get_lease(link->dhcp6_client, &lease);
 102         if (r < 0)
 103                 return r;
 104
 105         sd_dhcp6_lease_reset_address_iter(lease);
 106
 107         while (sd_dhcp6_lease_get_address(lease, &ip6_addr,
 108                                                 &lifetime_preferred,
 109                                                 &lifetime_valid) >= 0) {
 110
 111                 r = sd_icmp6_prefix_match(expired_prefix, expired_prefixlen,
 112                                         &ip6_addr);
 113                 if (r >= 0) {
 114                         r = dhcp6_address_update(link, &ip6_addr, 128,
 115                                                 lifetime_preferred,
 116                                                 lifetime_valid);
 117
 118                         return r;
 119                 }
 120         }
 121
 122         return 0;
 123 }
 124
 125 static int dhcp6_lease_address_acquired(sd_dhcp6_client *client, Link *link) {
 126         int r;
 127         sd_dhcp6_lease *lease;
 128         struct in6_addr ip6_addr;
 129         uint32_t lifetime_preferred, lifetime_valid;
 130         uint8_t prefixlen;
 131
 132         r = sd_dhcp6_client_get_lease(client, &lease);
 133         if (r < 0)
 134                 return r;
 135
 136         sd_dhcp6_lease_reset_address_iter(lease);
 137
 138         while (sd_dhcp6_lease_get_address(lease, &ip6_addr,
 139                                                 &lifetime_preferred,
 140                                                 &lifetime_valid) >= 0) {
 141
 142                 r = sd_icmp6_ra_get_prefixlen(link->icmp6_router_discovery,
 143                                         &ip6_addr, &prefixlen);
 144                 if (r < 0 && r != -EADDRNOTAVAIL) {
 145                         log_link_warning(link, "Could not get prefix information: %s",
 146                                         strerror(-r));
 147                         return r;
 148                 }
 149
 150                 if (r == -EADDRNOTAVAIL)
 151                         prefixlen = 128;
 152
 153                 r = dhcp6_address_update(link, &ip6_addr, prefixlen,
 154                                         lifetime_preferred, lifetime_valid);
 155                 if (r < 0)
 156                         return r;
 157         }
 158
 159         return 0;
 160 }
 161
 162 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
 163         int r;
 164         Link *link = userdata;
 165
 166         assert(link);
 167         assert(link->network);
 168         assert(link->manager);
 169
 170         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 171                 return;
 172
 173         switch(event) {
 174         case DHCP6_EVENT_STOP:
 175         case DHCP6_EVENT_RESEND_EXPIRE:
 176         case DHCP6_EVENT_RETRANS_MAX:
 177                 log_link_debug(link, "DHCPv6 event %d", event);
 178                 break;
 179
 180         case DHCP6_EVENT_IP_ACQUIRE:
 181                 r = dhcp6_lease_address_acquired(client, link);
 182                 if (r < 0) {
 183                         link_enter_failed(link);
 184                         return;
 185                 }
 186
 187                 /* fall through */
 188         case DHCP6_EVENT_INFORMATION_REQUEST:
 189                 r = dhcp6_lease_information_acquired(client, link);
 190                 if (r < 0) {
 191                         link_enter_failed(link);
 192                         return;
 193                 }
 194
 195                 break;
 196
 197         default:
 198                 if (event < 0)
 199                         log_link_warning(link, "DHCPv6 error: %s",
 200                                          strerror(-event));
 201                 else
 202                         log_link_warning(link, "DHCPv6 unknown event: %d",
 203                                          event);
 204                 return;
 205         }
 206 }
 207
 208 static int dhcp6_configure(Link *link, int event) {
 209         int r;
 210         bool information_request;
 211
 212         assert_return(link, -EINVAL);
 213
 214         if (link->dhcp6_client) {
 215                 if (event != ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED)
 216                         return 0;
 217
 218                 r = sd_dhcp6_client_get_information_request(link->dhcp6_client,
 219                                                         &information_request);
 220                 if (r < 0) {
 221                         log_link_warning(link, "Could not get DHCPv6 Information request setting: %s",
 222                                         strerror(-r));
 223                         link->dhcp6_client =
 224                                 sd_dhcp6_client_unref(link->dhcp6_client);
 225                         return r;
 226                 }
 227
 228                 if (!information_request)
 229                         return r;
 230
 231                 r = sd_dhcp6_client_set_information_request(link->dhcp6_client,
 232                                                         false);
 233                 if (r < 0) {
 234                         log_link_warning(link, "Could not unset DHCPv6 Information request: %s",
 235                                         strerror(-r));
 236                         link->dhcp6_client =
 237                                 sd_dhcp6_client_unref(link->dhcp6_client);
 238                         return r;
 239                 }
 240
 241                 r = sd_dhcp6_client_start(link->dhcp6_client);
 242                 if (r < 0) {
 243                         log_link_warning(link, "Could not restart DHCPv6 after enabling Information request: %s",
 244                                         strerror(-r));
 245                         link->dhcp6_client =
 246                                 sd_dhcp6_client_unref(link->dhcp6_client);
 247                         return r;
 248                 }
 249
 250                 return r;
 251         }
 252
 253         r = sd_dhcp6_client_new(&link->dhcp6_client);
 254         if (r < 0)
 255                 return r;
 256
 257         r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
 258         if (r < 0) {
 259                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
 260                 return r;
 261         }
 262
 263         r = sd_dhcp6_client_set_mac(link->dhcp6_client,
 264                                     (const uint8_t *) &link->mac,
 265                                     sizeof (link->mac), ARPHRD_ETHER);
 266         if (r < 0) {
 267                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
 268                 return r;
 269         }
 270
 271         r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
 272         if (r < 0) {
 273                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
 274                 return r;
 275         }
 276
 277         r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
 278                                          link);
 279         if (r < 0) {
 280                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
 281                 return r;
 282         }
 283
 284         if (event == ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER) {
 285                 r = sd_dhcp6_client_set_information_request(link->dhcp6_client,
 286                                                         true);
 287                 if (r < 0) {
 288                         link->dhcp6_client =
 289                                 sd_dhcp6_client_unref(link->dhcp6_client);
 290                         return r;
 291                 }
 292         }
 293
 294         r = sd_dhcp6_client_start(link->dhcp6_client);
 295         if (r < 0)
 296                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
 297
 298         return r;
 299 }
 300
 301 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
 302         Link *link = userdata;
 303
 304         assert(link);
 305         assert(link->network);
 306         assert(link->manager);
 307
 308         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 309                 return;
 310
 311         switch(event) {
 312         case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
 313                 return;
 314
 315         case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
 316         case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
 317         case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
 318                 dhcp6_configure(link, event);
 319
 320                 break;
 321
 322         case ICMP6_EVENT_ROUTER_ADVERTISMENT_PREFIX_EXPIRED:
 323                 dhcp6_prefix_expired(link);
 324
 325                 break;
 326
 327         default:
 328                 if (event < 0)
 329                         log_link_warning(link, "ICMPv6 error: %s",
 330                                          strerror(-event));
 331                 else
 332                         log_link_warning(link, "ICMPv6 unknown event: %d",
 333                                          event);
 334
 335                 break;
 336         }
 337
 338 }
 339
 340 int icmp6_configure(Link *link) {
 341         int r;
 342
 343         assert_return(link, -EINVAL);
 344
 345         r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
 346         if (r < 0)
 347                 return r;
 348
 349         r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery, NULL, 0);
 350         if (r < 0)
 351                 return r;
 352
 353         r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery, &link->mac);
 354         if (r < 0)
 355                 return r;
 356
 357         r = sd_icmp6_nd_set_index(link->icmp6_router_discovery, link->ifindex);
 358         if (r < 0)
 359                 return r;
 360
 361         r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
 362                                 icmp6_router_handler, link);
 363
 364         return r;
 365 }