usr/src/lib/libipadm/common/ipadm_ndpd.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  23  * Copyright (c) 2016, Chris Fraire <cfraire@me.com>.
  24  */
  25
  26 /*
  27  * This file contains the functions that are required for communicating
  28  * with in.ndpd while creating autoconfigured addresses.
  29  */
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <strings.h>
  35 #include <errno.h>
  36 #include <fcntl.h>
  37 #include <unistd.h>
  38 #include <sys/sockio.h>
  39 #include <sys/types.h>
  40 #include <sys/stat.h>
  41 #include <sys/socket.h>
  42 #include <netinet/in.h>
  43 #include <inet/ip.h>
  44 #include <arpa/inet.h>
  45 #include <assert.h>
  46 #include <poll.h>
  47 #include <ipadm_ndpd.h>
  48 #include "libipadm_impl.h"
  49
  50 #define NDPDTIMEOUT             5000
  51 #define PREFIXLEN_LINKLOCAL     10
  52
  53 static ipadm_status_t   i_ipadm_create_linklocal(ipadm_handle_t,
  54                             ipadm_addrobj_t);
  55 static void             i_ipadm_make_linklocal(struct sockaddr_in6 *,
  56                             const struct in6_addr *);
  57 static ipadm_status_t   i_ipadm_send_ndpd_cmd(const char *,
  58                             const struct ipadm_addrobj_s *, int);
  59
  60 /*
  61  * Sends message to in.ndpd asking not to do autoconf for the given interface,
  62  * until IPADM_CREATE_ADDRS or IPADM_ENABLE_AUTOCONF is sent.
  63  */
  64 ipadm_status_t
  65 i_ipadm_disable_autoconf(const char *ifname)
  66 {
  67         return (i_ipadm_send_ndpd_cmd(ifname, NULL, IPADM_DISABLE_AUTOCONF));
  68 }
  69
  70 /*
  71  * Sends message to in.ndpd to enable autoconf for the given interface,
  72  * until another IPADM_DISABLE_AUTOCONF is sent.
  73  */
  74 ipadm_status_t
  75 i_ipadm_enable_autoconf(const char *ifname)
  76 {
  77         return (i_ipadm_send_ndpd_cmd(ifname, NULL, IPADM_ENABLE_AUTOCONF));
  78 }
  79
  80 ipadm_status_t
  81 i_ipadm_create_ipv6addrs(ipadm_handle_t iph, ipadm_addrobj_t addr,
  82     uint32_t i_flags)
  83 {
  84         ipadm_status_t status;
  85
  86         /*
  87          * Create the link local based on the given token. If the same intfid
  88          * was already used with a different address object, this step will
  89          * fail.
  90          */
  91         status = i_ipadm_create_linklocal(iph, addr);
  92         if (status != IPADM_SUCCESS)
  93                 return (status);
  94
  95         /*
  96          * Request in.ndpd to start the autoconfiguration.
  97          * If autoconfiguration was already started by another means (e.g.
  98          * "ifconfig" ), in.ndpd will return EEXIST.
  99          */
 100         if (addr->ipadm_stateless || addr->ipadm_stateful) {
 101                 status = i_ipadm_send_ndpd_cmd(addr->ipadm_ifname, addr,
 102                     IPADM_CREATE_ADDRS);
 103                 if (status != IPADM_SUCCESS &&
 104                     status != IPADM_NDPD_NOT_RUNNING) {
 105                         (void) i_ipadm_delete_addr(iph, addr);
 106                         return (status);
 107                 }
 108         }
 109
 110         /* Persist the intfid. */
 111         status = i_ipadm_addr_persist(iph, addr, B_FALSE, i_flags, NULL);
 112         if (status != IPADM_SUCCESS) {
 113                 (void) i_ipadm_delete_addr(iph, addr);
 114                 (void) i_ipadm_send_ndpd_cmd(addr->ipadm_ifname, addr,
 115                     IPADM_DELETE_ADDRS);
 116         }
 117
 118         return (status);
 119 }
 120
 121 ipadm_status_t
 122 i_ipadm_delete_ipv6addrs(ipadm_handle_t iph, ipadm_addrobj_t ipaddr)
 123 {
 124         ipadm_status_t status;
 125
 126         /*
 127          * Send a msg to in.ndpd to remove the autoconfigured addresses,
 128          * and delete the link local that was created.
 129          */
 130         status = i_ipadm_send_ndpd_cmd(ipaddr->ipadm_ifname, ipaddr,
 131             IPADM_DELETE_ADDRS);
 132         if (status == IPADM_NDPD_NOT_RUNNING)
 133                 status = IPADM_SUCCESS;
 134         if (status == IPADM_SUCCESS)
 135                 status = i_ipadm_delete_addr(iph, ipaddr);
 136
 137         return (status);
 138 }
 139
 140 static ipadm_status_t
 141 i_ipadm_create_linklocal(ipadm_handle_t iph, ipadm_addrobj_t addr)
 142 {
 143         boolean_t addif = B_FALSE;
 144         struct sockaddr_in6 *sin6;
 145         struct lifreq lifr;
 146         int err;
 147         ipadm_status_t status;
 148         in6_addr_t ll_template = { { { 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
 149             0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } } };
 150
 151         /*
 152          * Create a logical interface if needed.
 153          */
 154 retry:
 155         status = i_ipadm_do_addif(iph, addr);
 156         if (status != IPADM_SUCCESS)
 157                 return (status);
 158         if (!(iph->iph_flags & IPH_INIT)) {
 159                 status = i_ipadm_setlifnum_addrobj(iph, addr);
 160                 if (status == IPADM_ADDROBJ_EXISTS)
 161                         goto retry;
 162                 if (status != IPADM_SUCCESS)
 163                         return (status);
 164         }
 165
 166         bzero(&lifr, sizeof (lifr));
 167         (void) strlcpy(lifr.lifr_name, addr->ipadm_ifname, LIFNAMSIZ);
 168         i_ipadm_addrobj2lifname(addr, lifr.lifr_name, sizeof (lifr.lifr_name));
 169         sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
 170
 171         /* Create the link-local address */
 172         bzero(&lifr.lifr_addr, sizeof (lifr.lifr_addr));
 173         (void) plen2mask(PREFIXLEN_LINKLOCAL, AF_INET6,
 174             (struct sockaddr *)&lifr.lifr_addr);
 175         if ((err = ioctl(iph->iph_sock6, SIOCSLIFNETMASK, (caddr_t)&lifr)) < 0)
 176                 goto fail;
 177         if (addr->ipadm_intfidlen == 0) {
 178                 /*
 179                  * If we have to use the default interface id,
 180                  * we just need to set the prefix to the link-local prefix.
 181                  * SIOCSLIFPREFIX sets the address with the given prefix
 182                  * and the default interface id.
 183                  */
 184                 sin6->sin6_addr = ll_template;
 185                 err = ioctl(iph->iph_sock6, SIOCSLIFPREFIX, (caddr_t)&lifr);
 186                 if (err < 0)
 187                         goto fail;
 188         } else {
 189                 /* Make a linklocal address in sin6 and set it */
 190                 i_ipadm_make_linklocal(sin6, &addr->ipadm_intfid.sin6_addr);
 191                 err = ioctl(iph->iph_sock6, SIOCSLIFADDR, (caddr_t)&lifr);
 192                 if (err < 0)
 193                         goto fail;
 194         }
 195         if ((err = ioctl(iph->iph_sock6, SIOCGLIFFLAGS, (char *)&lifr)) < 0)
 196                 goto fail;
 197         lifr.lifr_flags |= IFF_UP;
 198         if ((err = ioctl(iph->iph_sock6, SIOCSLIFFLAGS, (char *)&lifr)) < 0)
 199                 goto fail;
 200         return (IPADM_SUCCESS);
 201
 202 fail:
 203         if (errno == EEXIST)
 204                 status = IPADM_ADDRCONF_EXISTS;
 205         else
 206                 status = ipadm_errno2status(errno);
 207         /* Remove the linklocal that was created. */
 208         if (addif) {
 209                 (void) ioctl(iph->iph_sock6, SIOCLIFREMOVEIF, (caddr_t)&lifr);
 210         } else {
 211                 struct sockaddr_in6 *sin6;
 212
 213                 sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
 214                 lifr.lifr_flags &= ~IFF_UP;
 215                 (void) ioctl(iph->iph_sock6, SIOCSLIFFLAGS, (caddr_t)&lifr);
 216                 sin6->sin6_family = AF_INET6;
 217                 sin6->sin6_addr = in6addr_any;
 218                 (void) ioctl(iph->iph_sock6, SIOCSLIFADDR, (caddr_t)&lifr);
 219         }
 220         return (status);
 221 }
 222
 223 /*
 224  * Make a linklocal address based on the given intfid and copy it into
 225  * the output parameter `sin6'.
 226  */
 227 static void
 228 i_ipadm_make_linklocal(struct sockaddr_in6 *sin6, const struct in6_addr *intfid)
 229 {
 230         int i;
 231         in6_addr_t ll_template = { { { 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
 232             0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } } };
 233
 234         sin6->sin6_family = AF_INET6;
 235         sin6->sin6_addr = *intfid;
 236         for (i = 0; i < 4; i++) {
 237                 sin6->sin6_addr.s6_addr[i] =
 238                     sin6->sin6_addr.s6_addr[i] | ll_template.s6_addr[i];
 239         }
 240 }
 241
 242 /*
 243  * Function that forms an ndpd msg and sends it to the in.ndpd daemon's loopback
 244  * listener socket.
 245  */
 246 static ipadm_status_t
 247 i_ipadm_send_ndpd_cmd(const char *ifname, const struct ipadm_addrobj_s *addr,
 248     int cmd)
 249 {
 250         int fd;
 251         struct sockaddr_un servaddr;
 252         int flags;
 253         ipadm_ndpd_msg_t msg;
 254         int retval;
 255
 256         if (addr == NULL &&
 257             (cmd == IPADM_CREATE_ADDRS || cmd == IPADM_DELETE_ADDRS)) {
 258                 return (IPADM_INVALID_ARG);
 259         }
 260
 261         fd = socket(AF_UNIX, SOCK_STREAM, 0);
 262         if (fd == -1)
 263                 return (IPADM_FAILURE);
 264
 265         /* Put the socket in non-blocking mode */
 266         flags = fcntl(fd, F_GETFL, 0);
 267         if (flags != -1)
 268                 (void) fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 269
 270         /* Connect to in.ndpd */
 271         bzero(&servaddr, sizeof (servaddr));
 272         servaddr.sun_family = AF_UNIX;
 273         (void) strlcpy(servaddr.sun_path, IPADM_UDS_PATH,
 274             sizeof (servaddr.sun_path));
 275         if (connect(fd, (struct sockaddr *)&servaddr, sizeof (servaddr)) == -1)
 276                 goto fail;
 277
 278         bzero(&msg, sizeof (msg));
 279         msg.inm_cmd = cmd;
 280         (void) strlcpy(msg.inm_ifname, ifname, sizeof (msg.inm_ifname));
 281         if (addr != NULL) {
 282                 msg.inm_intfid = addr->ipadm_intfid;
 283                 msg.inm_intfidlen = addr->ipadm_intfidlen;
 284                 msg.inm_stateless = addr->ipadm_stateless;
 285                 msg.inm_stateful = addr->ipadm_stateful;
 286                 if (cmd == IPADM_CREATE_ADDRS) {
 287                         (void) strlcpy(msg.inm_aobjname, addr->ipadm_aobjname,
 288                             sizeof (msg.inm_aobjname));
 289                 }
 290         }
 291         if (ipadm_ndpd_write(fd, &msg, sizeof (msg)) < 0)
 292                 goto fail;
 293         if (ipadm_ndpd_read(fd, &retval, sizeof (retval)) < 0)
 294                 goto fail;
 295         (void) close(fd);
 296         if (cmd == IPADM_CREATE_ADDRS && retval == EEXIST)
 297                 return (IPADM_ADDRCONF_EXISTS);
 298         return (ipadm_errno2status(retval));
 299 fail:
 300         (void) close(fd);
 301         return (IPADM_NDPD_NOT_RUNNING);
 302 }
 303
 304 /*
 305  * Attempt to read `buflen' worth of bytes from `fd' into the buffer pointed
 306  * to by `buf'.
 307  */
 308 int
 309 ipadm_ndpd_read(int fd, void *buffer, size_t buflen)
 310 {
 311         int             retval;
 312         ssize_t         nbytes = 0;     /* total bytes processed */
 313         ssize_t         prbytes;        /* per-round bytes processed */
 314         struct pollfd   pfd;
 315
 316         while (nbytes < buflen) {
 317
 318                 pfd.fd = fd;
 319                 pfd.events = POLLIN;
 320
 321                 /*
 322                  * Wait for data to come in or for the timeout to fire.
 323                  */
 324                 retval = poll(&pfd, 1, NDPDTIMEOUT);
 325                 if (retval <= 0) {
 326                         if (retval == 0)
 327                                 errno = ETIME;
 328                         break;
 329                 }
 330
 331                 /*
 332                  * Descriptor is ready; have at it.
 333                  */
 334                 prbytes = read(fd, (caddr_t)buffer + nbytes, buflen - nbytes);
 335                 if (prbytes <= 0) {
 336                         if (prbytes == -1 && errno == EINTR)
 337                                 continue;
 338                         break;
 339                 }
 340                 nbytes += prbytes;
 341         }
 342
 343         return (nbytes == buflen ? 0 : -1);
 344 }
 345
 346 /*
 347  * Write `buflen' bytes from `buffer' to open file `fd'.  Returns 0
 348  * if all requested bytes were written, or an error code if not.
 349  */
 350 int
 351 ipadm_ndpd_write(int fd, const void *buffer, size_t buflen)
 352 {
 353         size_t          nwritten;
 354         ssize_t         nbytes;
 355         const char      *buf = buffer;
 356
 357         for (nwritten = 0; nwritten < buflen; nwritten += nbytes) {
 358                 nbytes = write(fd, &buf[nwritten], buflen - nwritten);
 359                 if (nbytes == -1)
 360                         return (-1);
 361                 if (nbytes == 0) {
 362                         errno = EIO;
 363                         return (-1);
 364                 }
 365         }
 366
 367         assert(nwritten == buflen);
 368         return (0);
 369 }