zebra/ioctl.c

   1 /*
   2  * Common ioctl functions.
   3  * Copyright (C) 1997, 98 Kunihiro Ishiguro
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * GNU Zebra is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; see the file COPYING; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include "linklist.h"
  25 #include "if.h"
  26 #include "prefix.h"
  27 #include "ioctl.h"
  28 #include "log.h"
  29 #include "privs.h"
  30 #include "lib_errors.h"
  31
  32 #include "vty.h"
  33 #include "zebra/rib.h"
  34 #include "zebra/rt.h"
  35 #include "zebra/interface.h"
  36 #include "zebra/zebra_errors.h"
  37 #include "zebra/debug.h"
  38
  39 #ifndef SUNOS_5
  40
  41 #ifdef HAVE_BSD_LINK_DETECT
  42 #include <net/if_media.h>
  43 #endif /* HAVE_BSD_LINK_DETECT*/
  44
  45 extern struct zebra_privs_t zserv_privs;
  46
  47 /* clear and set interface name string */
  48 void ifreq_set_name(struct ifreq *ifreq, struct interface *ifp)
  49 {
  50         strlcpy(ifreq->ifr_name, ifp->name, sizeof(ifreq->ifr_name));
  51 }
  52
  53 /* call ioctl system call */
  54 int if_ioctl(unsigned long request, caddr_t buffer)
  55 {
  56         int sock;
  57         int ret;
  58         int err = 0;
  59
  60         frr_with_privs(&zserv_privs) {
  61                 sock = socket(AF_INET, SOCK_DGRAM, 0);
  62                 if (sock < 0) {
  63                         zlog_err("Cannot create UDP socket: %s",
  64                                  safe_strerror(errno));
  65                         exit(1);
  66                 }
  67                 if ((ret = ioctl(sock, request, buffer)) < 0)
  68                         err = errno;
  69         }
  70         close(sock);
  71
  72         if (ret < 0) {
  73                 errno = err;
  74                 return ret;
  75         }
  76         return 0;
  77 }
  78
  79 /* call ioctl system call */
  80 int vrf_if_ioctl(unsigned long request, caddr_t buffer, vrf_id_t vrf_id)
  81 {
  82         int sock;
  83         int ret;
  84         int err = 0;
  85
  86         frr_with_privs(&zserv_privs) {
  87                 sock = vrf_socket(AF_INET, SOCK_DGRAM, 0, vrf_id, NULL);
  88                 if (sock < 0) {
  89                         zlog_err("Cannot create UDP socket: %s",
  90                                  safe_strerror(errno));
  91                         exit(1);
  92                 }
  93                 ret = vrf_ioctl(vrf_id, sock, request, buffer);
  94                 if (ret < 0)
  95                         err = errno;
  96         }
  97         close(sock);
  98
  99         if (ret < 0) {
 100                 errno = err;
 101                 return ret;
 102         }
 103         return 0;
 104 }
 105
 106 #ifndef HAVE_NETLINK
 107 static int if_ioctl_ipv6(unsigned long request, caddr_t buffer)
 108 {
 109         int sock;
 110         int ret;
 111         int err = 0;
 112
 113         frr_with_privs(&zserv_privs) {
 114                 sock = socket(AF_INET6, SOCK_DGRAM, 0);
 115                 if (sock < 0) {
 116                         zlog_err("Cannot create IPv6 datagram socket: %s",
 117                                  safe_strerror(errno));
 118                         exit(1);
 119                 }
 120
 121                 if ((ret = ioctl(sock, request, buffer)) < 0)
 122                         err = errno;
 123         }
 124         close(sock);
 125
 126         if (ret < 0) {
 127                 errno = err;
 128                 return ret;
 129         }
 130         return 0;
 131 }
 132 #endif /* ! HAVE_NETLINK */
 133
 134 /*
 135  * get interface metric
 136  *   -- if value is not avaliable set -1
 137  */
 138 void if_get_metric(struct interface *ifp)
 139 {
 140 #ifdef SIOCGIFMETRIC
 141         struct ifreq ifreq;
 142
 143         ifreq_set_name(&ifreq, ifp);
 144
 145         if (vrf_if_ioctl(SIOCGIFMETRIC, (caddr_t)&ifreq, ifp->vrf_id) < 0)
 146                 return;
 147         ifp->metric = ifreq.ifr_metric;
 148         if (ifp->metric == 0)
 149                 ifp->metric = 1;
 150 #else  /* SIOCGIFMETRIC */
 151         ifp->metric = -1;
 152 #endif /* SIOCGIFMETRIC */
 153 }
 154
 155 /* get interface MTU */
 156 void if_get_mtu(struct interface *ifp)
 157 {
 158         struct ifreq ifreq;
 159
 160         ifreq_set_name(&ifreq, ifp);
 161
 162 #if defined(SIOCGIFMTU)
 163         if (vrf_if_ioctl(SIOCGIFMTU, (caddr_t)&ifreq, ifp->vrf_id) < 0) {
 164                 zlog_info("Can't lookup mtu by ioctl(SIOCGIFMTU)");
 165                 ifp->mtu6 = ifp->mtu = -1;
 166                 return;
 167         }
 168
 169 #ifdef SUNOS_5
 170         ifp->mtu6 = ifp->mtu = ifreq.ifr_metric;
 171 #else
 172         ifp->mtu6 = ifp->mtu = ifreq.ifr_mtu;
 173 #endif /* SUNOS_5 */
 174
 175         /* propogate */
 176         zebra_interface_up_update(ifp);
 177
 178 #else
 179         zlog_info("Can't lookup mtu on this system");
 180         ifp->mtu6 = ifp->mtu = -1;
 181 #endif
 182 }
 183
 184 /*
 185  * Handler for interface address programming via the zebra dplane,
 186  * for non-netlink platforms. This handler dispatches to per-platform
 187  * helpers, based on the operation requested.
 188  */
 189 #ifndef HAVE_NETLINK
 190
 191 /* Prototypes: these are placed in this block so that they're only seen
 192  * on non-netlink platforms.
 193  */
 194 static int if_set_prefix_ctx(const struct zebra_dplane_ctx *ctx);
 195 static int if_unset_prefix_ctx(const struct zebra_dplane_ctx *ctx);
 196 static int if_set_prefix6_ctx(const struct zebra_dplane_ctx *ctx);
 197 static int if_unset_prefix6_ctx(const struct zebra_dplane_ctx *ctx);
 198
 199 enum zebra_dplane_result kernel_address_update_ctx(
 200         struct zebra_dplane_ctx *ctx)
 201 {
 202         int ret = -1;
 203         const struct prefix *p;
 204
 205         p = dplane_ctx_get_intf_addr(ctx);
 206
 207         if (dplane_ctx_get_op(ctx) == DPLANE_OP_ADDR_INSTALL) {
 208                 if (p->family == AF_INET)
 209                         ret = if_set_prefix_ctx(ctx);
 210                 else
 211                         ret = if_set_prefix6_ctx(ctx);
 212         } else if (dplane_ctx_get_op(ctx) == DPLANE_OP_ADDR_UNINSTALL) {
 213                 if (p->family == AF_INET)
 214                         ret = if_unset_prefix_ctx(ctx);
 215                 else
 216                         ret = if_unset_prefix6_ctx(ctx);
 217         } else {
 218                 if (IS_ZEBRA_DEBUG_DPLANE)
 219                         zlog_debug("Invalid op in interface-addr install");
 220         }
 221
 222         return (ret == 0 ?
 223                 ZEBRA_DPLANE_REQUEST_SUCCESS : ZEBRA_DPLANE_REQUEST_FAILURE);
 224 }
 225
 226 #endif  /* !HAVE_NETLINK */
 227
 228 #ifdef HAVE_NETLINK
 229
 230 /* TODO -- remove; no use of these apis with netlink any longer */
 231
 232 #else /* ! HAVE_NETLINK */
 233 #ifdef HAVE_STRUCT_IFALIASREQ
 234
 235 /*
 236  * Helper for interface-addr install, non-netlink
 237  */
 238 static int if_set_prefix_ctx(const struct zebra_dplane_ctx *ctx)
 239 {
 240         int ret;
 241         struct ifaliasreq addreq;
 242         struct sockaddr_in addr, mask, peer;
 243         struct prefix_ipv4 *p;
 244
 245         p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);
 246
 247         memset(&addreq, 0, sizeof(addreq));
 248         strlcpy((char *)&addreq.ifra_name, dplane_ctx_get_ifname(ctx),
 249                 sizeof(addreq.ifra_name));
 250
 251         memset(&addr, 0, sizeof(struct sockaddr_in));
 252         addr.sin_addr = p->prefix;
 253         addr.sin_family = p->family;
 254 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 255         addr.sin_len = sizeof(struct sockaddr_in);
 256 #endif
 257         memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in));
 258
 259         if (dplane_ctx_intf_is_connected(ctx)) {
 260                 p = (struct prefix_ipv4 *)dplane_ctx_get_intf_dest(ctx);
 261                 memset(&mask, 0, sizeof(struct sockaddr_in));
 262                 peer.sin_addr = p->prefix;
 263                 peer.sin_family = p->family;
 264 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 265                 peer.sin_len = sizeof(struct sockaddr_in);
 266 #endif
 267                 memcpy(&addreq.ifra_broadaddr, &peer,
 268                        sizeof(struct sockaddr_in));
 269         }
 270
 271         memset(&mask, 0, sizeof(struct sockaddr_in));
 272         masklen2ip(p->prefixlen, &mask.sin_addr);
 273         mask.sin_family = p->family;
 274 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 275         mask.sin_len = sizeof(struct sockaddr_in);
 276 #endif
 277         memcpy(&addreq.ifra_mask, &mask, sizeof(struct sockaddr_in));
 278
 279         ret = if_ioctl(SIOCAIFADDR, (caddr_t)&addreq);
 280         if (ret < 0)
 281                 return ret;
 282         return 0;
 283
 284 }
 285
 286 /*
 287  * Helper for interface-addr un-install, non-netlink
 288  */
 289 static int if_unset_prefix_ctx(const struct zebra_dplane_ctx *ctx)
 290 {
 291         int ret;
 292         struct ifaliasreq addreq;
 293         struct sockaddr_in addr, mask, peer;
 294         struct prefix_ipv4 *p;
 295
 296         p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);
 297
 298         memset(&addreq, 0, sizeof(addreq));
 299         strlcpy((char *)&addreq.ifra_name, dplane_ctx_get_ifname(ctx),
 300                 sizeof(addreq.ifra_name));
 301
 302         memset(&addr, 0, sizeof(struct sockaddr_in));
 303         addr.sin_addr = p->prefix;
 304         addr.sin_family = p->family;
 305 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 306         addr.sin_len = sizeof(struct sockaddr_in);
 307 #endif
 308         memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in));
 309
 310         if (dplane_ctx_intf_is_connected(ctx)) {
 311                 p = (struct prefix_ipv4 *)dplane_ctx_get_intf_dest(ctx);
 312                 memset(&mask, 0, sizeof(struct sockaddr_in));
 313                 peer.sin_addr = p->prefix;
 314                 peer.sin_family = p->family;
 315 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 316                 peer.sin_len = sizeof(struct sockaddr_in);
 317 #endif
 318                 memcpy(&addreq.ifra_broadaddr, &peer,
 319                        sizeof(struct sockaddr_in));
 320         }
 321
 322         memset(&mask, 0, sizeof(struct sockaddr_in));
 323         masklen2ip(p->prefixlen, &mask.sin_addr);
 324         mask.sin_family = p->family;
 325 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 326         mask.sin_len = sizeof(struct sockaddr_in);
 327 #endif
 328         memcpy(&addreq.ifra_mask, &mask, sizeof(struct sockaddr_in));
 329
 330         ret = if_ioctl(SIOCDIFADDR, (caddr_t)&addreq);
 331         if (ret < 0)
 332                 return ret;
 333         return 0;
 334 }
 335 #else
 336 /* Set up interface's address, netmask (and broadcas? ).  Linux or
 337    Solaris uses ifname:number semantics to set IP address aliases. */
 338 int if_set_prefix_ctx(const struct zebra_dplane_ctx *ctx)
 339 {
 340         int ret;
 341         struct ifreq ifreq;
 342         struct sockaddr_in addr;
 343         struct sockaddr_in broad;
 344         struct sockaddr_in mask;
 345         struct prefix_ipv4 ifaddr;
 346         struct prefix_ipv4 *p;
 347
 348         p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);
 349
 350         ifaddr = *p;
 351
 352         strlcpy(ifreq.ifr_name, dplane_ctx_get_ifname(ctx),
 353                 sizeof(ifreq.ifr_name));
 354
 355         addr.sin_addr = p->prefix;
 356         addr.sin_family = p->family;
 357         memcpy(&ifreq.ifr_addr, &addr, sizeof(struct sockaddr_in));
 358         ret = if_ioctl(SIOCSIFADDR, (caddr_t)&ifreq);
 359         if (ret < 0)
 360                 return ret;
 361
 362         /* We need mask for make broadcast addr. */
 363         masklen2ip(p->prefixlen, &mask.sin_addr);
 364
 365         if (dplane_ctx_intf_is_broadcast(ctx)) {
 366                 apply_mask_ipv4(&ifaddr);
 367                 addr.sin_addr = ifaddr.prefix;
 368
 369                 broad.sin_addr.s_addr =
 370                         (addr.sin_addr.s_addr | ~mask.sin_addr.s_addr);
 371                 broad.sin_family = p->family;
 372
 373                 memcpy(&ifreq.ifr_broadaddr, &broad,
 374                        sizeof(struct sockaddr_in));
 375                 ret = if_ioctl(SIOCSIFBRDADDR, (caddr_t)&ifreq);
 376                 if (ret < 0)
 377                         return ret;
 378         }
 379
 380         mask.sin_family = p->family;
 381 #ifdef SUNOS_5
 382         memcpy(&mask, &ifreq.ifr_addr, sizeof(mask));
 383 #else
 384         memcpy(&ifreq.ifr_addr, &mask, sizeof(struct sockaddr_in));
 385 #endif /* SUNOS5 */
 386         ret = if_ioctl(SIOCSIFNETMASK, (caddr_t)&ifreq);
 387         if (ret < 0)
 388                 return ret;
 389
 390         return 0;
 391 }
 392
 393 /* Set up interface's address, netmask (and broadcas? ).  Linux or
 394    Solaris uses ifname:number semantics to set IP address aliases. */
 395 int if_unset_prefix_ctx(const struct zebra_dplane_ctx *ctx)
 396 {
 397         int ret;
 398         struct ifreq ifreq;
 399         struct sockaddr_in addr;
 400         struct prefix_ipv4 *p;
 401
 402         p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);
 403
 404         strlcpy(ifreq.ifr_name, dplane_ctx_get_ifname(ctx),
 405                 sizeof(ifreq.ifr_name));
 406
 407         memset(&addr, 0, sizeof(struct sockaddr_in));
 408         addr.sin_family = p->family;
 409         memcpy(&ifreq.ifr_addr, &addr, sizeof(struct sockaddr_in));
 410         ret = if_ioctl(SIOCSIFADDR, (caddr_t)&ifreq);
 411         if (ret < 0)
 412                 return ret;
 413
 414         return 0;
 415 }
 416 #endif /* HAVE_STRUCT_IFALIASREQ */
 417 #endif /* HAVE_NETLINK */
 418
 419 /* get interface flags */
 420 void if_get_flags(struct interface *ifp)
 421 {
 422         int ret;
 423         struct ifreq ifreq;
 424 #ifdef HAVE_BSD_LINK_DETECT
 425         struct ifmediareq ifmr;
 426 #endif /* HAVE_BSD_LINK_DETECT */
 427
 428         ifreq_set_name(&ifreq, ifp);
 429
 430         ret = vrf_if_ioctl(SIOCGIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
 431         if (ret < 0) {
 432                 flog_err_sys(EC_LIB_SYSTEM_CALL,
 433                              "vrf_if_ioctl(SIOCGIFFLAGS) failed: %s",
 434                              safe_strerror(errno));
 435                 return;
 436         }
 437 #ifdef HAVE_BSD_LINK_DETECT /* Detect BSD link-state at start-up */
 438
 439         /* Per-default, IFF_RUNNING is held high, unless link-detect says
 440          * otherwise - we abuse IFF_RUNNING inside zebra as a link-state flag,
 441          * following practice on Linux and Solaris kernels
 442          */
 443         SET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
 444
 445         if (CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION)) {
 446                 (void)memset(&ifmr, 0, sizeof(ifmr));
 447                 strlcpy(ifmr.ifm_name, ifp->name, sizeof(ifmr.ifm_name));
 448
 449                 /* Seems not all interfaces implement this ioctl */
 450                 if (if_ioctl(SIOCGIFMEDIA, (caddr_t)&ifmr) == -1 &&
 451                     errno != EINVAL)
 452                         flog_err_sys(EC_LIB_SYSTEM_CALL,
 453                                      "if_ioctl(SIOCGIFMEDIA) failed: %s",
 454                                      safe_strerror(errno));
 455                 else if (ifmr.ifm_status & IFM_AVALID) /* Link state is valid */
 456                 {
 457                         if (ifmr.ifm_status & IFM_ACTIVE)
 458                                 SET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
 459                         else
 460                                 UNSET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
 461                 }
 462         }
 463 #endif /* HAVE_BSD_LINK_DETECT */
 464
 465         if_flags_update(ifp, (ifreq.ifr_flags & 0x0000ffff));
 466 }
 467
 468 /* Set interface flags */
 469 int if_set_flags(struct interface *ifp, uint64_t flags)
 470 {
 471         int ret;
 472         struct ifreq ifreq;
 473
 474         memset(&ifreq, 0, sizeof(struct ifreq));
 475         ifreq_set_name(&ifreq, ifp);
 476
 477         ifreq.ifr_flags = ifp->flags;
 478         ifreq.ifr_flags |= flags;
 479
 480         ret = vrf_if_ioctl(SIOCSIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
 481
 482         if (ret < 0) {
 483                 zlog_info("can't set interface flags");
 484                 return ret;
 485         }
 486         return 0;
 487 }
 488
 489 /* Unset interface's flag. */
 490 int if_unset_flags(struct interface *ifp, uint64_t flags)
 491 {
 492         int ret;
 493         struct ifreq ifreq;
 494
 495         memset(&ifreq, 0, sizeof(struct ifreq));
 496         ifreq_set_name(&ifreq, ifp);
 497
 498         ifreq.ifr_flags = ifp->flags;
 499         ifreq.ifr_flags &= ~flags;
 500
 501         ret = vrf_if_ioctl(SIOCSIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
 502
 503         if (ret < 0) {
 504                 zlog_info("can't unset interface flags");
 505                 return ret;
 506         }
 507         return 0;
 508 }
 509
 510 #ifndef LINUX_IPV6 /* Netlink has its own code */
 511
 512 #ifdef HAVE_STRUCT_IN6_ALIASREQ
 513 #ifndef ND6_INFINITE_LIFETIME
 514 #define ND6_INFINITE_LIFETIME 0xffffffffL
 515 #endif /* ND6_INFINITE_LIFETIME */
 516
 517 /*
 518  * Helper for interface-addr install, non-netlink
 519  */
 520 static int if_set_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
 521 {
 522         int ret;
 523         struct in6_aliasreq addreq;
 524         struct sockaddr_in6 addr;
 525         struct sockaddr_in6 mask;
 526         struct prefix_ipv6 *p;
 527
 528         p = (struct prefix_ipv6 *)dplane_ctx_get_intf_addr(ctx);
 529
 530         memset(&addreq, 0, sizeof(addreq));
 531         strlcpy((char *)&addreq.ifra_name,
 532                 dplane_ctx_get_ifname(ctx), sizeof(addreq.ifra_name));
 533
 534         memset(&addr, 0, sizeof(struct sockaddr_in6));
 535         addr.sin6_addr = p->prefix;
 536         addr.sin6_family = p->family;
 537 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 538         addr.sin6_len = sizeof(struct sockaddr_in6);
 539 #endif
 540         memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in6));
 541
 542         memset(&mask, 0, sizeof(struct sockaddr_in6));
 543         masklen2ip6(p->prefixlen, &mask.sin6_addr);
 544         mask.sin6_family = p->family;
 545 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 546         mask.sin6_len = sizeof(struct sockaddr_in6);
 547 #endif
 548         memcpy(&addreq.ifra_prefixmask, &mask, sizeof(struct sockaddr_in6));
 549
 550         addreq.ifra_lifetime.ia6t_vltime = 0xffffffff;
 551         addreq.ifra_lifetime.ia6t_pltime = 0xffffffff;
 552
 553 #ifdef HAVE_STRUCT_IF6_ALIASREQ_IFRA_LIFETIME
 554         addreq.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
 555         addreq.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
 556 #endif
 557
 558         ret = if_ioctl_ipv6(SIOCAIFADDR_IN6, (caddr_t)&addreq);
 559         if (ret < 0)
 560                 return ret;
 561         return 0;
 562 }
 563
 564 /*
 565  * Helper for interface-addr un-install, non-netlink
 566  */
 567 static int if_unset_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
 568 {
 569         int ret;
 570         struct in6_aliasreq addreq;
 571         struct sockaddr_in6 addr;
 572         struct sockaddr_in6 mask;
 573         struct prefix_ipv6 *p;
 574
 575         p = (struct prefix_ipv6 *)dplane_ctx_get_intf_addr(ctx);
 576
 577         memset(&addreq, 0, sizeof(addreq));
 578         strlcpy((char *)&addreq.ifra_name,
 579                 dplane_ctx_get_ifname(ctx), sizeof(addreq.ifra_name));
 580
 581         memset(&addr, 0, sizeof(struct sockaddr_in6));
 582         addr.sin6_addr = p->prefix;
 583         addr.sin6_family = p->family;
 584 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 585         addr.sin6_len = sizeof(struct sockaddr_in6);
 586 #endif
 587         memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in6));
 588
 589         memset(&mask, 0, sizeof(struct sockaddr_in6));
 590         masklen2ip6(p->prefixlen, &mask.sin6_addr);
 591         mask.sin6_family = p->family;
 592 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 593         mask.sin6_len = sizeof(struct sockaddr_in6);
 594 #endif
 595         memcpy(&addreq.ifra_prefixmask, &mask, sizeof(struct sockaddr_in6));
 596
 597 #ifdef HAVE_STRUCT_IF6_ALIASREQ_IFRA_LIFETIME
 598         addreq.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
 599         addreq.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
 600 #endif
 601
 602         ret = if_ioctl_ipv6(SIOCDIFADDR_IN6, (caddr_t)&addreq);
 603         if (ret < 0)
 604                 return ret;
 605         return 0;
 606 }
 607 #else
 608 /* The old, pre-dataplane code here just returned, so we're retaining that
 609  * choice.
 610  */
 611 static int if_set_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
 612 {
 613         return 0;
 614 }
 615
 616 static int if_unset_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
 617 {
 618         return 0;
 619 }
 620 #endif /* HAVE_STRUCT_IN6_ALIASREQ */
 621
 622 #endif /* LINUX_IPV6 */
 623
 624 #endif /* !SUNOS_5 */