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 "sd-dhcp6-client.h"
  26
  27 #include "network-internal.h"
  28 #include "networkd-link.h"
  29
  30 static int dhcp6_lease_address_acquired(sd_dhcp6_client *client, Link *link);
  31
  32 static int dhcp6_lease_information_acquired(sd_dhcp6_client *client,
  33                                         Link *link) {
  34         return 0;
  35 }
  36
  37 static int dhcp6_address_handler(sd_netlink *rtnl, sd_netlink_message *m,
  38                                  void *userdata) {
  39         _cleanup_link_unref_ Link *link = userdata;
  40         int r;
  41
  42         assert(link);
  43
  44         r = sd_netlink_message_get_errno(m);
  45         if (r < 0 && r != -EEXIST) {
  46                 if (link->rtnl_extended_attrs) {
  47                         log_link_warning(link, "Could not set extended netlink attributes, reverting to fallback mechanism");
  48
  49                         link->rtnl_extended_attrs = false;
  50                         dhcp6_lease_address_acquired(link->dhcp6_client, link);
  51
  52                         return 1;
  53                 }
  54
  55                 log_link_error_errno(link, r, "Could not set DHCPv6 address: %m");
  56
  57                 link_enter_failed(link);
  58
  59         } else if (r >= 0)
  60                 manager_rtnl_process_address(rtnl, m, link->manager);
  61
  62         return 1;
  63 }
  64
  65 static int dhcp6_address_change(Link *link, struct in6_addr *ip6_addr,
  66                                 uint32_t lifetime_preferred, uint32_t lifetime_valid) {
  67         int r;
  68         _cleanup_address_free_ Address *addr = NULL;
  69
  70         r = address_new(&addr);
  71         if (r < 0)
  72                 return r;
  73
  74         addr->family = AF_INET6;
  75         memcpy(&addr->in_addr.in6, ip6_addr, sizeof(*ip6_addr));
  76
  77         addr->flags = IFA_F_NOPREFIXROUTE;
  78         addr->prefixlen = 128;
  79
  80         addr->cinfo.ifa_prefered = lifetime_preferred;
  81         addr->cinfo.ifa_valid = lifetime_valid;
  82
  83         log_link_info(link,
  84                       "DHCPv6 address "SD_NDISC_ADDRESS_FORMAT_STR"/%d timeout preferred %d valid %d",
  85                       SD_NDISC_ADDRESS_FORMAT_VAL(addr->in_addr.in6),
  86                       addr->prefixlen, lifetime_preferred, lifetime_valid);
  87
  88         r = address_configure(addr, link, dhcp6_address_handler, true);
  89         if (r < 0)
  90                 log_link_warning_errno(link, r, "Could not assign DHCPv6 address: %m");
  91
  92         return r;
  93 }
  94
  95 static int dhcp6_lease_address_acquired(sd_dhcp6_client *client, Link *link) {
  96         int r;
  97         sd_dhcp6_lease *lease;
  98         struct in6_addr ip6_addr;
  99         uint32_t lifetime_preferred, lifetime_valid;
 100
 101         r = sd_dhcp6_client_get_lease(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 = dhcp6_address_change(link, &ip6_addr, lifetime_preferred, lifetime_valid);
 112                 if (r < 0)
 113                         return r;
 114         }
 115
 116         return 0;
 117 }
 118
 119 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
 120         int r;
 121         Link *link = userdata;
 122
 123         assert(link);
 124         assert(link->network);
 125         assert(link->manager);
 126
 127         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 128                 return;
 129
 130         switch(event) {
 131         case SD_DHCP6_CLIENT_EVENT_STOP:
 132         case SD_DHCP6_CLIENT_EVENT_RESEND_EXPIRE:
 133         case SD_DHCP6_CLIENT_EVENT_RETRANS_MAX:
 134                 if (sd_dhcp6_client_get_lease(client, NULL) >= 0)
 135                         log_link_warning(link, "DHCPv6 lease lost");
 136
 137                 link->dhcp6_configured = false;
 138                 break;
 139
 140         case SD_DHCP6_CLIENT_EVENT_IP_ACQUIRE:
 141                 r = dhcp6_lease_address_acquired(client, link);
 142                 if (r < 0) {
 143                         link_enter_failed(link);
 144                         return;
 145                 }
 146
 147                 /* fall through */
 148         case SD_DHCP6_CLIENT_EVENT_INFORMATION_REQUEST:
 149                 r = dhcp6_lease_information_acquired(client, link);
 150                 if (r < 0) {
 151                         link_enter_failed(link);
 152                         return;
 153                 }
 154
 155                 link->dhcp6_configured = true;
 156                 break;
 157
 158         default:
 159                 if (event < 0)
 160                         log_link_warning_errno(link, event, "DHCPv6 error: %m");
 161                 else
 162                         log_link_warning(link, "DHCPv6 unknown event: %d", event);
 163                 return;
 164         }
 165
 166         link_check_ready(link);
 167 }
 168
 169 int dhcp6_request_address(Link *link) {
 170         int r, inf_req;
 171         bool running;
 172
 173         assert(link);
 174         assert(link->dhcp6_client);
 175
 176         r = sd_dhcp6_client_get_information_request(link->dhcp6_client, &inf_req);
 177         if (r < 0)
 178                 return r;
 179
 180         if (!inf_req)
 181                 return 0;
 182
 183         r = sd_dhcp6_client_is_running(link->dhcp6_client);
 184         if (r < 0)
 185                 return r;
 186         else
 187                 running = !!r;
 188
 189         if (running) {
 190                 r = sd_dhcp6_client_stop(link->dhcp6_client);
 191                 if (r < 0)
 192                         return r;
 193         }
 194
 195         r = sd_dhcp6_client_set_information_request(link->dhcp6_client, false);
 196         if (r < 0)
 197                 return r;
 198
 199         if (running) {
 200                 r = sd_dhcp6_client_start(link->dhcp6_client);
 201                 if (r < 0)
 202                         return r;
 203         }
 204
 205         return 0;
 206 }
 207
 208 int dhcp6_configure(Link *link) {
 209         sd_dhcp6_client *client = NULL;
 210         int r;
 211
 212         assert(link);
 213
 214         if (link->dhcp6_client)
 215                 return 0;
 216
 217         r = sd_dhcp6_client_new(&client);
 218         if (r < 0)
 219                 return r;
 220
 221         r = sd_dhcp6_client_attach_event(client, NULL, 0);
 222         if (r < 0)
 223                 goto error;
 224
 225         r = sd_dhcp6_client_set_information_request(client, true);
 226         if (r < 0)
 227                 goto error;
 228
 229         r = sd_dhcp6_client_set_mac(client,
 230                                     (const uint8_t *) &link->mac,
 231                                     sizeof (link->mac), ARPHRD_ETHER);
 232         if (r < 0)
 233                 goto error;
 234
 235         r = sd_dhcp6_client_set_index(client, link->ifindex);
 236         if (r < 0)
 237                 goto error;
 238
 239         r = sd_dhcp6_client_set_callback(client, dhcp6_handler, link);
 240         if (r < 0)
 241                 goto error;
 242
 243         link->dhcp6_client = client;
 244
 245         return 0;
 246
 247 error:
 248         sd_dhcp6_client_unref(client);
 249         return r;
 250 }