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 "socket-util.h"
  32 #include "string-util.h"
  33 #include "util.h"
  34
  35 #define NDISC_ROUTER_SOLICITATION_INTERVAL (4U * USEC_PER_SEC)
  36 #define NDISC_MAX_ROUTER_SOLICITATIONS 3U
  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->recv_event_source = sd_event_source_unref(nd->recv_event_source);
 133         nd->fd = safe_close(nd->fd);
 134         nd->nd_sent = 0;
 135
 136         return 0;
 137 }
 138
 139 _public_ sd_ndisc *sd_ndisc_unref(sd_ndisc *nd) {
 140
 141         if (!nd)
 142                 return NULL;
 143
 144         assert(nd->n_ref > 0);
 145         nd->n_ref--;
 146
 147         if (nd->n_ref > 0)
 148                 return NULL;
 149
 150         ndisc_reset(nd);
 151         sd_ndisc_detach_event(nd);
 152         return mfree(nd);
 153 }
 154
 155 _public_ int sd_ndisc_new(sd_ndisc **ret) {
 156         _cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
 157
 158         assert_return(ret, -EINVAL);
 159
 160         nd = new0(sd_ndisc, 1);
 161         if (!nd)
 162                 return -ENOMEM;
 163
 164         nd->n_ref = 1;
 165         nd->fd = -1;
 166
 167         *ret = nd;
 168         nd = NULL;
 169
 170         return 0;
 171 }
 172
 173 _public_ int sd_ndisc_get_mtu(sd_ndisc *nd, uint32_t *mtu) {
 174         assert_return(nd, -EINVAL);
 175         assert_return(mtu, -EINVAL);
 176
 177         if (nd->mtu == 0)
 178                 return -ENODATA;
 179
 180         *mtu = nd->mtu;
 181         return 0;
 182 }
 183
 184 _public_ int sd_ndisc_get_hop_limit(sd_ndisc *nd, uint8_t *ret) {
 185         assert_return(nd, -EINVAL);
 186         assert_return(ret, -EINVAL);
 187
 188         if (nd->hop_limit == 0)
 189                 return -ENODATA;
 190
 191         *ret = nd->hop_limit;
 192         return 0;
 193 }
 194
 195 static int ndisc_handle_datagram(sd_ndisc *nd, sd_ndisc_router *rt) {
 196         int r;
 197
 198         assert(nd);
 199         assert(rt);
 200
 201         r = ndisc_router_parse(rt);
 202         if (r == -EBADMSG) /* Bad packet */
 203                 return 0;
 204         if (r < 0)
 205                 return 0;
 206
 207         /* Update global variables we keep */
 208         if (rt->mtu > 0)
 209                 nd->mtu = rt->mtu;
 210         if (rt->hop_limit > 0)
 211                 nd->hop_limit = rt->hop_limit;
 212
 213         log_ndisc("Received Router Advertisement: flags %s preference %s lifetime %" PRIu16 " sec",
 214                   rt->flags & ND_RA_FLAG_MANAGED ? "MANAGED" : rt->flags & ND_RA_FLAG_OTHER ? "OTHER" : "none",
 215                   rt->preference == SD_NDISC_PREFERENCE_HIGH ? "high" : rt->preference == SD_NDISC_PREFERENCE_LOW ? "low" : "medium",
 216                   rt->lifetime);
 217
 218         ndisc_callback(nd, SD_NDISC_EVENT_ROUTER, rt);
 219         return 0;
 220 }
 221
 222 static int ndisc_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 223         _cleanup_(sd_ndisc_router_unrefp) sd_ndisc_router *rt = NULL;
 224         sd_ndisc *nd = userdata;
 225         union {
 226                 struct cmsghdr cmsghdr;
 227                 uint8_t buf[CMSG_SPACE(sizeof(int)) + /* ttl */
 228                             CMSG_SPACE(sizeof(struct timeval))];
 229         } control = {};
 230         struct iovec iov = {};
 231         union sockaddr_union sa = {};
 232         struct msghdr msg = {
 233                 .msg_name = &sa.sa,
 234                 .msg_namelen = sizeof(sa),
 235                 .msg_iov = &iov,
 236                 .msg_iovlen = 1,
 237                 .msg_control = &control,
 238                 .msg_controllen = sizeof(control),
 239         };
 240         struct cmsghdr *cmsg;
 241         ssize_t len, buflen;
 242
 243         assert(s);
 244         assert(nd);
 245         assert(nd->event);
 246
 247         buflen = next_datagram_size_fd(fd);
 248         if (buflen < 0)
 249                 return log_ndisc_errno(buflen, "Failed to determine datagram size to read: %m");
 250
 251         rt = ndisc_router_new(buflen);
 252         if (!rt)
 253                 return -ENOMEM;
 254
 255         iov.iov_base = NDISC_ROUTER_RAW(rt);
 256         iov.iov_len = rt->raw_size;
 257
 258         len = recvmsg(fd, &msg, MSG_DONTWAIT);
 259         if (len < 0) {
 260                 if (errno == EAGAIN || errno == EINTR)
 261                         return 0;
 262
 263                 return log_ndisc_errno(errno, "Could not receive message from ICMPv6 socket: %m");
 264         }
 265
 266         if ((size_t) len != rt->raw_size) {
 267                 log_ndisc("Packet size mismatch.");
 268                 return -EINVAL;
 269         }
 270
 271         if (msg.msg_namelen == sizeof(struct sockaddr_in6) &&
 272             sa.in6.sin6_family == AF_INET6)  {
 273
 274                 if (in_addr_is_link_local(AF_INET6, (union in_addr_union*) &sa.in6.sin6_addr) <= 0) {
 275                         _cleanup_free_ char *addr = NULL;
 276
 277                         (void) in_addr_to_string(AF_INET6, (union in_addr_union*) &sa.in6.sin6_addr, &addr);
 278                         log_ndisc("Received RA from non-link-local address %s. Ignoring.", strna(addr));
 279                         return 0;
 280                 }
 281
 282                 rt->address = sa.in6.sin6_addr;
 283
 284         } else if (msg.msg_namelen > 0) {
 285                 log_ndisc("Received invalid source address size from ICMPv6 socket: %zu bytes", (size_t) msg.msg_namelen);
 286                 return -EINVAL;
 287         }
 288
 289         /* namelen == 0 only happens when running the test-suite over a socketpair */
 290
 291         assert(!(msg.msg_flags & MSG_CTRUNC));
 292         assert(!(msg.msg_flags & MSG_TRUNC));
 293
 294         CMSG_FOREACH(cmsg, &msg) {
 295                 if (cmsg->cmsg_level == SOL_IPV6 &&
 296                     cmsg->cmsg_type == IPV6_HOPLIMIT &&
 297                     cmsg->cmsg_len == CMSG_LEN(sizeof(int))) {
 298                         int hops = *(int*) CMSG_DATA(cmsg);
 299
 300                         if (hops != 255) {
 301                                 log_ndisc("Received RA with invalid hop limit %d. Ignoring.", hops);
 302                                 return 0;
 303                         }
 304                 }
 305
 306                 if (cmsg->cmsg_level == SOL_SOCKET &&
 307                     cmsg->cmsg_type == SO_TIMESTAMP &&
 308                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
 309                         triple_timestamp_from_realtime(&rt->timestamp, timeval_load((struct timeval*) CMSG_DATA(cmsg)));
 310         }
 311
 312         if (!triple_timestamp_is_set(&rt->timestamp))
 313                 triple_timestamp_get(&rt->timestamp);
 314
 315         nd->timeout_event_source = sd_event_source_unref(nd->timeout_event_source);
 316
 317         return ndisc_handle_datagram(nd, rt);
 318 }
 319
 320 static int ndisc_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
 321         sd_ndisc *nd = userdata;
 322         usec_t time_now, next_timeout;
 323         int r;
 324
 325         assert(s);
 326         assert(nd);
 327         assert(nd->event);
 328
 329         if (nd->nd_sent >= NDISC_MAX_ROUTER_SOLICITATIONS) {
 330                 nd->timeout_event_source = sd_event_source_unref(nd->timeout_event_source);
 331                 ndisc_callback(nd, SD_NDISC_EVENT_TIMEOUT, NULL);
 332                 return 0;
 333         }
 334
 335         r = icmp6_send_router_solicitation(nd->fd, &nd->mac_addr);
 336         if (r < 0) {
 337                 log_ndisc_errno(r, "Error sending Router Solicitation: %m");
 338                 goto fail;
 339         }
 340
 341         log_ndisc("Sent Router Solicitation");
 342         nd->nd_sent++;
 343
 344         assert_se(sd_event_now(nd->event, clock_boottime_or_monotonic(), &time_now) >= 0);
 345         next_timeout = time_now + NDISC_ROUTER_SOLICITATION_INTERVAL;
 346
 347         r = sd_event_source_set_time(nd->timeout_event_source, next_timeout);
 348         if (r < 0) {
 349                 log_ndisc_errno(r, "Error updating timer: %m");
 350                 goto fail;
 351         }
 352
 353         r = sd_event_source_set_enabled(nd->timeout_event_source, SD_EVENT_ONESHOT);
 354         if (r < 0) {
 355                 log_ndisc_errno(r, "Error reenabling timer: %m");
 356                 goto fail;
 357         }
 358
 359         return 0;
 360
 361 fail:
 362         sd_ndisc_stop(nd);
 363         return 0;
 364 }
 365
 366 _public_ int sd_ndisc_stop(sd_ndisc *nd) {
 367         assert_return(nd, -EINVAL);
 368
 369         if (nd->fd < 0)
 370                 return 0;
 371
 372         log_ndisc("Stopping IPv6 Router Solicitation client");
 373
 374         ndisc_reset(nd);
 375         return 1;
 376 }
 377
 378 _public_ int sd_ndisc_start(sd_ndisc *nd) {
 379         int r;
 380
 381         assert_return(nd, -EINVAL);
 382         assert_return(nd->event, -EINVAL);
 383         assert_return(nd->ifindex > 0, -EINVAL);
 384
 385         if (nd->fd >= 0)
 386                 return 0;
 387
 388         assert(!nd->recv_event_source);
 389         assert(!nd->timeout_event_source);
 390
 391         nd->fd = icmp6_bind_router_solicitation(nd->ifindex);
 392         if (nd->fd < 0)
 393                 return nd->fd;
 394
 395         r = sd_event_add_io(nd->event, &nd->recv_event_source, nd->fd, EPOLLIN, ndisc_recv, nd);
 396         if (r < 0)
 397                 goto fail;
 398
 399         r = sd_event_source_set_priority(nd->recv_event_source, nd->event_priority);
 400         if (r < 0)
 401                 goto fail;
 402
 403         (void) sd_event_source_set_description(nd->recv_event_source, "ndisc-receive-message");
 404
 405         r = sd_event_add_time(nd->event, &nd->timeout_event_source, clock_boottime_or_monotonic(), 0, 0, ndisc_timeout, nd);
 406         if (r < 0)
 407                 goto fail;
 408
 409         r = sd_event_source_set_priority(nd->timeout_event_source, nd->event_priority);
 410         if (r < 0)
 411                 goto fail;
 412
 413         (void) sd_event_source_set_description(nd->timeout_event_source, "ndisc-timeout");
 414
 415         log_ndisc("Started IPv6 Router Solicitation client");
 416         return 1;
 417
 418 fail:
 419         ndisc_reset(nd);
 420         return r;
 421 }