src/libsystemd-network/sd-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/icmp6.h>
  21 #include <netinet/in.h>
  22
  23 #include "sd-ndisc.h"
  24
  25 #include "alloc-util.h"
  26 #include "fd-util.h"
  27 #include "icmp6-util.h"
  28 #include "in-addr-util.h"
  29 #include "ndisc-internal.h"
  30 #include "ndisc-router.h"
  31 #include "random-util.h"
  32 #include "socket-util.h"
  33 #include "string-util.h"
  34 #include "util.h"
  35
  36 #define NDISC_TIMEOUT_NO_RA_USEC (NDISC_ROUTER_SOLICITATION_INTERVAL * NDISC_MAX_ROUTER_SOLICITATIONS)
  37
  38 static void ndisc_callback(sd_ndisc *ndisc, sd_ndisc_event event, sd_ndisc_router *rt) {
  39         assert(ndisc);
  40
  41         log_ndisc("Invoking callback for '%c'.", event);
  42
  43         if (!ndisc->callback)
  44                 return;
  45
  46         ndisc->callback(ndisc, event, rt, ndisc->userdata);
  47 }
  48
  49 _public_ int sd_ndisc_set_callback(
  50                 sd_ndisc *nd,
  51                 sd_ndisc_callback_t callback,
  52                 void *userdata) {
  53
  54         assert_return(nd, -EINVAL);
  55
  56         nd->callback = callback;
  57         nd->userdata = userdata;
  58
  59         return 0;
  60 }
  61
  62 _public_ int sd_ndisc_set_ifindex(sd_ndisc *nd, int ifindex) {
  63         assert_return(nd, -EINVAL);
  64         assert_return(ifindex > 0, -EINVAL);
  65         assert_return(nd->fd < 0, -EBUSY);
  66
  67         nd->ifindex = ifindex;
  68         return 0;
  69 }
  70
  71 _public_ int sd_ndisc_set_mac(sd_ndisc *nd, const struct ether_addr *mac_addr) {
  72         assert_return(nd, -EINVAL);
  73
  74         if (mac_addr)
  75                 nd->mac_addr = *mac_addr;
  76         else
  77                 zero(nd->mac_addr);
  78
  79         return 0;
  80 }
  81
  82 _public_ int sd_ndisc_attach_event(sd_ndisc *nd, sd_event *event, int64_t priority) {
  83         int r;
  84
  85         assert_return(nd, -EINVAL);
  86         assert_return(nd->fd < 0, -EBUSY);
  87         assert_return(!nd->event, -EBUSY);
  88
  89         if (event)
  90                 nd->event = sd_event_ref(event);
  91         else {
  92                 r = sd_event_default(&nd->event);
  93                 if (r < 0)
  94                         return 0;
  95         }
  96
  97         nd->event_priority = priority;
  98
  99         return 0;
 100 }
 101
 102 _public_ int sd_ndisc_detach_event(sd_ndisc *nd) {
 103
 104         assert_return(nd, -EINVAL);
 105         assert_return(nd->fd < 0, -EBUSY);
 106
 107         nd->event = sd_event_unref(nd->event);
 108         return 0;
 109 }
 110
 111 _public_ sd_event *sd_ndisc_get_event(sd_ndisc *nd) {
 112         assert_return(nd, NULL);
 113
 114         return nd->event;
 115 }
 116
 117 _public_ sd_ndisc *sd_ndisc_ref(sd_ndisc *nd) {
 118
 119         if (!nd)
 120                 return NULL;
 121
 122         assert(nd->n_ref > 0);
 123         nd->n_ref++;
 124
 125         return nd;
 126 }
 127
 128 static int ndisc_reset(sd_ndisc *nd) {
 129         assert(nd);
 130
 131         nd->timeout_event_source = sd_event_source_unref(nd->timeout_event_source);
 132         nd->timeout_no_ra = sd_event_source_unref(nd->timeout_no_ra);
 133         nd->retransmit_time = 0;
 134         nd->recv_event_source = sd_event_source_unref(nd->recv_event_source);
 135         nd->fd = safe_close(nd->fd);
 136
 137         return 0;
 138 }
 139
 140 _public_ sd_ndisc *sd_ndisc_unref(sd_ndisc *nd) {
 141
 142         if (!nd)
 143                 return NULL;
 144
 145         assert(nd->n_ref > 0);
 146         nd->n_ref--;
 147
 148         if (nd->n_ref > 0)
 149                 return NULL;
 150
 151         ndisc_reset(nd);
 152         sd_ndisc_detach_event(nd);
 153         return mfree(nd);
 154 }
 155
 156 _public_ int sd_ndisc_new(sd_ndisc **ret) {
 157         _cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
 158
 159         assert_return(ret, -EINVAL);
 160
 161         nd = new0(sd_ndisc, 1);
 162         if (!nd)
 163                 return -ENOMEM;
 164
 165         nd->n_ref = 1;
 166         nd->fd = -1;
 167
 168         *ret = nd;
 169         nd = NULL;
 170
 171         return 0;
 172 }
 173
 174 _public_ int sd_ndisc_get_mtu(sd_ndisc *nd, uint32_t *mtu) {
 175         assert_return(nd, -EINVAL);
 176         assert_return(mtu, -EINVAL);
 177
 178         if (nd->mtu == 0)
 179                 return -ENODATA;
 180
 181         *mtu = nd->mtu;
 182         return 0;
 183 }
 184
 185 _public_ int sd_ndisc_get_hop_limit(sd_ndisc *nd, uint8_t *ret) {
 186         assert_return(nd, -EINVAL);
 187         assert_return(ret, -EINVAL);
 188
 189         if (nd->hop_limit == 0)
 190                 return -ENODATA;
 191
 192         *ret = nd->hop_limit;
 193         return 0;
 194 }
 195
 196 static int ndisc_handle_datagram(sd_ndisc *nd, sd_ndisc_router *rt) {
 197         int r;
 198
 199         assert(nd);
 200         assert(rt);
 201
 202         r = ndisc_router_parse(rt);
 203         if (r == -EBADMSG) /* Bad packet */
 204                 return 0;
 205         if (r < 0)
 206                 return 0;
 207
 208         /* Update global variables we keep */
 209         if (rt->mtu > 0)
 210                 nd->mtu = rt->mtu;
 211         if (rt->hop_limit > 0)
 212                 nd->hop_limit = rt->hop_limit;
 213
 214         log_ndisc("Received Router Advertisement: flags %s preference %s lifetime %" PRIu16 " sec",
 215                   rt->flags & ND_RA_FLAG_MANAGED ? "MANAGED" : rt->flags & ND_RA_FLAG_OTHER ? "OTHER" : "none",
 216                   rt->preference == SD_NDISC_PREFERENCE_HIGH ? "high" : rt->preference == SD_NDISC_PREFERENCE_LOW ? "low" : "medium",
 217                   rt->lifetime);
 218
 219         ndisc_callback(nd, SD_NDISC_EVENT_ROUTER, rt);
 220         return 0;
 221 }
 222
 223 static int ndisc_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 224         _cleanup_(sd_ndisc_router_unrefp) sd_ndisc_router *rt = NULL;
 225         sd_ndisc *nd = userdata;
 226         ssize_t buflen;
 227         int r;
 228         _cleanup_free_ char *addr = NULL;
 229
 230         assert(s);
 231         assert(nd);
 232         assert(nd->event);
 233
 234         buflen = next_datagram_size_fd(fd);
 235         if (buflen < 0)
 236                 return log_ndisc_errno(buflen, "Failed to determine datagram size to read: %m");
 237
 238         rt = ndisc_router_new(buflen);
 239         if (!rt)
 240                 return -ENOMEM;
 241
 242         r = icmp6_receive(fd, NDISC_ROUTER_RAW(rt), rt->raw_size, &rt->address,
 243                      &rt->timestamp);
 244         if (r < 0) {
 245                 switch (r) {
 246                 case -EADDRNOTAVAIL:
 247                         (void) in_addr_to_string(AF_INET6, (union in_addr_union*) &rt->address, &addr);
 248                         log_ndisc("Received RA from non-link-local address %s. Ignoring", addr);
 249                         break;
 250
 251                 case -EMULTIHOP:
 252                         log_ndisc("Received RA with invalid hop limit. Ignoring.");
 253                         break;
 254
 255                 case -EPFNOSUPPORT:
 256                         log_ndisc("Received invalid source address from ICMPv6 socket.");
 257                         break;
 258                 }
 259
 260                 return 0;
 261         }
 262
 263         nd->timeout_event_source = sd_event_source_unref(nd->timeout_event_source);
 264
 265         return ndisc_handle_datagram(nd, rt);
 266 }
 267
 268 static usec_t ndisc_timeout_compute_random(usec_t val) {
 269         /* compute a time that is random within ±10% of the given value */
 270         return val - val / 10 +
 271                 (random_u64() % (2 * USEC_PER_SEC)) * val / 10 / USEC_PER_SEC;
 272 }
 273
 274 static int ndisc_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
 275         sd_ndisc *nd = userdata;
 276         usec_t time_now;
 277         int r;
 278         char time_string[FORMAT_TIMESPAN_MAX];
 279
 280         assert(s);
 281         assert(nd);
 282         assert(nd->event);
 283
 284         assert_se(sd_event_now(nd->event, clock_boottime_or_monotonic(), &time_now) >= 0);
 285
 286         nd->timeout_event_source = sd_event_source_unref(nd->timeout_event_source);
 287
 288         if (!nd->retransmit_time)
 289                 nd->retransmit_time = ndisc_timeout_compute_random(NDISC_ROUTER_SOLICITATION_INTERVAL);
 290         else {
 291                 if (nd->retransmit_time > NDISC_MAX_ROUTER_SOLICITATION_INTERVAL / 2)
 292                         nd->retransmit_time = ndisc_timeout_compute_random(NDISC_MAX_ROUTER_SOLICITATION_INTERVAL);
 293                 else
 294                         nd->retransmit_time += ndisc_timeout_compute_random(nd->retransmit_time);
 295         }
 296
 297         r = sd_event_add_time(nd->event, &nd->timeout_event_source,
 298                               clock_boottime_or_monotonic(),
 299                               time_now + nd->retransmit_time,
 300                               10 * USEC_PER_MSEC, ndisc_timeout, nd);
 301         if (r < 0)
 302                 goto fail;
 303
 304         r = sd_event_source_set_priority(nd->timeout_event_source, nd->event_priority);
 305         if (r < 0)
 306                 goto fail;
 307
 308         (void) sd_event_source_set_description(nd->timeout_event_source, "ndisc-timeout-no-ra");
 309
 310         r = sd_event_source_set_enabled(nd->timeout_event_source, SD_EVENT_ONESHOT);
 311         if (r < 0) {
 312                 log_ndisc_errno(r, "Error reenabling timer: %m");
 313                 goto fail;
 314         }
 315
 316         r = icmp6_send_router_solicitation(nd->fd, &nd->mac_addr);
 317         if (r < 0) {
 318                 log_ndisc_errno(r, "Error sending Router Solicitation: %m");
 319                 goto fail;
 320         }
 321
 322         log_ndisc("Sent Router Solicitation, next solicitation in %s",
 323                   format_timespan(time_string, FORMAT_TIMESPAN_MAX,
 324                                   nd->retransmit_time, USEC_PER_SEC));
 325
 326         return 0;
 327
 328 fail:
 329         sd_ndisc_stop(nd);
 330         return 0;
 331 }
 332
 333 static int ndisc_timeout_no_ra(sd_event_source *s, uint64_t usec, void *userdata) {
 334         sd_ndisc *nd = userdata;
 335
 336         assert(s);
 337         assert(nd);
 338
 339         log_ndisc("No RA received before link confirmation timeout");
 340
 341         nd->timeout_no_ra = sd_event_source_unref(nd->timeout_no_ra);
 342         ndisc_callback(nd, SD_NDISC_EVENT_TIMEOUT, NULL);
 343
 344         return 0;
 345 }
 346
 347 _public_ int sd_ndisc_stop(sd_ndisc *nd) {
 348         assert_return(nd, -EINVAL);
 349
 350         if (nd->fd < 0)
 351                 return 0;
 352
 353         log_ndisc("Stopping IPv6 Router Solicitation client");
 354
 355         ndisc_reset(nd);
 356         return 1;
 357 }
 358
 359 _public_ int sd_ndisc_start(sd_ndisc *nd) {
 360         int r;
 361         usec_t time_now;
 362
 363         assert_return(nd, -EINVAL);
 364         assert_return(nd->event, -EINVAL);
 365         assert_return(nd->ifindex > 0, -EINVAL);
 366
 367         if (nd->fd >= 0)
 368                 return 0;
 369
 370         assert(!nd->recv_event_source);
 371         assert(!nd->timeout_event_source);
 372
 373         r = sd_event_now(nd->event, clock_boottime_or_monotonic(), &time_now);
 374         if (r < 0)
 375                 goto fail;
 376
 377         nd->fd = icmp6_bind_router_solicitation(nd->ifindex);
 378         if (nd->fd < 0)
 379                 return nd->fd;
 380
 381         r = sd_event_add_io(nd->event, &nd->recv_event_source, nd->fd, EPOLLIN, ndisc_recv, nd);
 382         if (r < 0)
 383                 goto fail;
 384
 385         r = sd_event_source_set_priority(nd->recv_event_source, nd->event_priority);
 386         if (r < 0)
 387                 goto fail;
 388
 389         (void) sd_event_source_set_description(nd->recv_event_source, "ndisc-receive-message");
 390
 391         r = sd_event_add_time(nd->event, &nd->timeout_event_source, clock_boottime_or_monotonic(), 0, 0, ndisc_timeout, nd);
 392         if (r < 0)
 393                 goto fail;
 394
 395         r = sd_event_source_set_priority(nd->timeout_event_source, nd->event_priority);
 396         if (r < 0)
 397                 goto fail;
 398
 399         (void) sd_event_source_set_description(nd->timeout_event_source, "ndisc-timeout");
 400
 401         r = sd_event_add_time(nd->event, &nd->timeout_no_ra,
 402                               clock_boottime_or_monotonic(),
 403                               time_now + NDISC_TIMEOUT_NO_RA_USEC,
 404                               10 * USEC_PER_MSEC, ndisc_timeout_no_ra, nd);
 405         if (r < 0)
 406                 goto fail;
 407
 408         r = sd_event_source_set_priority(nd->timeout_no_ra, nd->event_priority);
 409         if (r < 0)
 410                 goto fail;
 411
 412         (void) sd_event_source_set_description(nd->timeout_no_ra, "ndisc-timeout-no-ra");
 413
 414         log_ndisc("Started IPv6 Router Solicitation client");
 415         return 1;
 416
 417 fail:
 418         ndisc_reset(nd);
 419         return r;
 420 }