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
  37 #ifndef SUNOS_5
  38
  39 #ifdef HAVE_BSD_LINK_DETECT
  40 #include <net/if_media.h>
  41 #endif /* HAVE_BSD_LINK_DETECT*/
  42
  43 extern struct zebra_privs_t zserv_privs;
  44
  45 /* clear and set interface name string */
  46 void ifreq_set_name(struct ifreq *ifreq, struct interface *ifp)
  47 {
  48         strlcpy(ifreq->ifr_name, ifp->name, sizeof(ifreq->ifr_name));
  49 }
  50
  51 /* call ioctl system call */
  52 int if_ioctl(unsigned long request, caddr_t buffer)
  53 {
  54         int sock;
  55         int ret;
  56         int err = 0;
  57
  58         frr_elevate_privs(&zserv_privs) {
  59                 sock = socket(AF_INET, SOCK_DGRAM, 0);
  60                 if (sock < 0) {
  61                         zlog_err("Cannot create UDP socket: %s",
  62                                  safe_strerror(errno));
  63                         exit(1);
  64                 }
  65                 if ((ret = ioctl(sock, request, buffer)) < 0)
  66                         err = errno;
  67         }
  68         close(sock);
  69
  70         if (ret < 0) {
  71                 errno = err;
  72                 return ret;
  73         }
  74         return 0;
  75 }
  76
  77 /* call ioctl system call */
  78 int vrf_if_ioctl(unsigned long request, caddr_t buffer, vrf_id_t vrf_id)
  79 {
  80         int sock;
  81         int ret;
  82         int err = 0;
  83
  84         frr_elevate_privs(&zserv_privs) {
  85                 sock = vrf_socket(AF_INET, SOCK_DGRAM, 0, vrf_id, NULL);
  86                 if (sock < 0) {
  87                         zlog_err("Cannot create UDP socket: %s",
  88                                  safe_strerror(errno));
  89                         exit(1);
  90                 }
  91                 ret = vrf_ioctl(vrf_id, sock, request, buffer);
  92                 if (ret < 0)
  93                         err = errno;
  94         }
  95         close(sock);
  96
  97         if (ret < 0) {
  98                 errno = err;
  99                 return ret;
 100         }
 101         return 0;
 102 }
 103
 104 #ifndef HAVE_NETLINK
 105 static int if_ioctl_ipv6(unsigned long request, caddr_t buffer)
 106 {
 107         int sock;
 108         int ret;
 109         int err = 0;
 110
 111         frr_elevate_privs(&zserv_privs) {
 112                 sock = socket(AF_INET6, SOCK_DGRAM, 0);
 113                 if (sock < 0) {
 114                         zlog_err("Cannot create IPv6 datagram socket: %s",
 115                                  safe_strerror(errno));
 116                         exit(1);
 117                 }
 118
 119                 if ((ret = ioctl(sock, request, buffer)) < 0)
 120                         err = errno;
 121         }
 122         close(sock);
 123
 124         if (ret < 0) {
 125                 errno = err;
 126                 return ret;
 127         }
 128         return 0;
 129 }
 130 #endif /* ! HAVE_NETLINK */
 131
 132 /*
 133  * get interface metric
 134  *   -- if value is not avaliable set -1
 135  */
 136 void if_get_metric(struct interface *ifp)
 137 {
 138 #ifdef SIOCGIFMETRIC
 139         struct ifreq ifreq;
 140
 141         ifreq_set_name(&ifreq, ifp);
 142
 143         if (vrf_if_ioctl(SIOCGIFMETRIC, (caddr_t)&ifreq, ifp->vrf_id) < 0)
 144                 return;
 145         ifp->metric = ifreq.ifr_metric;
 146         if (ifp->metric == 0)
 147                 ifp->metric = 1;
 148 #else  /* SIOCGIFMETRIC */
 149         ifp->metric = -1;
 150 #endif /* SIOCGIFMETRIC */
 151 }
 152
 153 /* get interface MTU */
 154 void if_get_mtu(struct interface *ifp)
 155 {
 156         struct ifreq ifreq;
 157
 158         ifreq_set_name(&ifreq, ifp);
 159
 160 #if defined(SIOCGIFMTU)
 161         if (vrf_if_ioctl(SIOCGIFMTU, (caddr_t)&ifreq, ifp->vrf_id) < 0) {
 162                 zlog_info("Can't lookup mtu by ioctl(SIOCGIFMTU)");
 163                 ifp->mtu6 = ifp->mtu = -1;
 164                 return;
 165         }
 166
 167 #ifdef SUNOS_5
 168         ifp->mtu6 = ifp->mtu = ifreq.ifr_metric;
 169 #else
 170         ifp->mtu6 = ifp->mtu = ifreq.ifr_mtu;
 171 #endif /* SUNOS_5 */
 172
 173         /* propogate */
 174         zebra_interface_up_update(ifp);
 175
 176 #else
 177         zlog_info("Can't lookup mtu on this system");
 178         ifp->mtu6 = ifp->mtu = -1;
 179 #endif
 180 }
 181
 182 #ifdef HAVE_NETLINK
 183 /* Interface address setting via netlink interface. */
 184 int if_set_prefix(struct interface *ifp, struct connected *ifc)
 185 {
 186         return kernel_address_add_ipv4(ifp, ifc);
 187 }
 188
 189 /* Interface address is removed using netlink interface. */
 190 int if_unset_prefix(struct interface *ifp, struct connected *ifc)
 191 {
 192         return kernel_address_delete_ipv4(ifp, ifc);
 193 }
 194 #else /* ! HAVE_NETLINK */
 195 #ifdef HAVE_STRUCT_IFALIASREQ
 196 /* Set up interface's IP address, netmask (and broadcas? ).  *BSD may
 197    has ifaliasreq structure.  */
 198 int if_set_prefix(struct interface *ifp, struct connected *ifc)
 199 {
 200         int ret;
 201         struct ifaliasreq addreq;
 202         struct sockaddr_in addr, mask, peer;
 203         struct prefix_ipv4 *p;
 204
 205         /* don't configure PtP addresses on broadcast ifs or reverse */
 206         if (!(ifp->flags & IFF_POINTOPOINT) != !CONNECTED_PEER(ifc)) {
 207                 errno = EINVAL;
 208                 return -1;
 209         }
 210
 211         p = (struct prefix_ipv4 *)ifc->address;
 212         rib_lookup_and_pushup(p, ifp->vrf_id);
 213
 214         memset(&addreq, 0, sizeof addreq);
 215         strncpy((char *)&addreq.ifra_name, ifp->name, sizeof addreq.ifra_name);
 216
 217         memset(&addr, 0, sizeof(struct sockaddr_in));
 218         addr.sin_addr = p->prefix;
 219         addr.sin_family = p->family;
 220 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 221         addr.sin_len = sizeof(struct sockaddr_in);
 222 #endif
 223         memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in));
 224
 225         if (CONNECTED_PEER(ifc)) {
 226                 p = (struct prefix_ipv4 *)ifc->destination;
 227                 memset(&mask, 0, sizeof(struct sockaddr_in));
 228                 peer.sin_addr = p->prefix;
 229                 peer.sin_family = p->family;
 230 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 231                 peer.sin_len = sizeof(struct sockaddr_in);
 232 #endif
 233                 memcpy(&addreq.ifra_broadaddr, &peer,
 234                        sizeof(struct sockaddr_in));
 235         }
 236
 237         memset(&mask, 0, sizeof(struct sockaddr_in));
 238         masklen2ip(p->prefixlen, &mask.sin_addr);
 239         mask.sin_family = p->family;
 240 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 241         mask.sin_len = sizeof(struct sockaddr_in);
 242 #endif
 243         memcpy(&addreq.ifra_mask, &mask, sizeof(struct sockaddr_in));
 244
 245         ret = if_ioctl(SIOCAIFADDR, (caddr_t)&addreq);
 246         if (ret < 0)
 247                 return ret;
 248         return 0;
 249 }
 250
 251 /* Set up interface's IP address, netmask (and broadcas? ).  *BSD may
 252    has ifaliasreq structure.  */
 253 int if_unset_prefix(struct interface *ifp, struct connected *ifc)
 254 {
 255         int ret;
 256         struct ifaliasreq addreq;
 257         struct sockaddr_in addr, mask, peer;
 258         struct prefix_ipv4 *p;
 259
 260         /* this would probably wreak havoc */
 261         if (!(ifp->flags & IFF_POINTOPOINT) != !CONNECTED_PEER(ifc)) {
 262                 errno = EINVAL;
 263                 return -1;
 264         }
 265
 266         p = (struct prefix_ipv4 *)ifc->address;
 267
 268         memset(&addreq, 0, sizeof addreq);
 269         strncpy((char *)&addreq.ifra_name, ifp->name, sizeof addreq.ifra_name);
 270
 271         memset(&addr, 0, sizeof(struct sockaddr_in));
 272         addr.sin_addr = p->prefix;
 273         addr.sin_family = p->family;
 274 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 275         addr.sin_len = sizeof(struct sockaddr_in);
 276 #endif
 277         memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in));
 278
 279         if (CONNECTED_PEER(ifc)) {
 280                 p = (struct prefix_ipv4 *)ifc->destination;
 281                 memset(&mask, 0, sizeof(struct sockaddr_in));
 282                 peer.sin_addr = p->prefix;
 283                 peer.sin_family = p->family;
 284 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 285                 peer.sin_len = sizeof(struct sockaddr_in);
 286 #endif
 287                 memcpy(&addreq.ifra_broadaddr, &peer,
 288                        sizeof(struct sockaddr_in));
 289         }
 290
 291         memset(&mask, 0, sizeof(struct sockaddr_in));
 292         masklen2ip(p->prefixlen, &mask.sin_addr);
 293         mask.sin_family = p->family;
 294 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 295         mask.sin_len = sizeof(struct sockaddr_in);
 296 #endif
 297         memcpy(&addreq.ifra_mask, &mask, sizeof(struct sockaddr_in));
 298
 299         ret = if_ioctl(SIOCDIFADDR, (caddr_t)&addreq);
 300         if (ret < 0)
 301                 return ret;
 302         return 0;
 303 }
 304 #else
 305 /* Set up interface's address, netmask (and broadcas? ).  Linux or
 306    Solaris uses ifname:number semantics to set IP address aliases. */
 307 int if_set_prefix(struct interface *ifp, struct connected *ifc)
 308 {
 309         int ret;
 310         struct ifreq ifreq;
 311         struct sockaddr_in addr;
 312         struct sockaddr_in broad;
 313         struct sockaddr_in mask;
 314         struct prefix_ipv4 ifaddr;
 315         struct prefix_ipv4 *p;
 316
 317         p = (struct prefix_ipv4 *)ifc->address;
 318
 319         ifaddr = *p;
 320
 321         ifreq_set_name(&ifreq, ifp);
 322
 323         addr.sin_addr = p->prefix;
 324         addr.sin_family = p->family;
 325         memcpy(&ifreq.ifr_addr, &addr, sizeof(struct sockaddr_in));
 326         ret = if_ioctl(SIOCSIFADDR, (caddr_t)&ifreq);
 327         if (ret < 0)
 328                 return ret;
 329
 330         /* We need mask for make broadcast addr. */
 331         masklen2ip(p->prefixlen, &mask.sin_addr);
 332
 333         if (if_is_broadcast(ifp)) {
 334                 apply_mask_ipv4(&ifaddr);
 335                 addr.sin_addr = ifaddr.prefix;
 336
 337                 broad.sin_addr.s_addr =
 338                         (addr.sin_addr.s_addr | ~mask.sin_addr.s_addr);
 339                 broad.sin_family = p->family;
 340
 341                 memcpy(&ifreq.ifr_broadaddr, &broad,
 342                        sizeof(struct sockaddr_in));
 343                 ret = if_ioctl(SIOCSIFBRDADDR, (caddr_t)&ifreq);
 344                 if (ret < 0)
 345                         return ret;
 346         }
 347
 348         mask.sin_family = p->family;
 349 #ifdef SUNOS_5
 350         memcpy(&mask, &ifreq.ifr_addr, sizeof(mask));
 351 #else
 352         memcpy(&ifreq.ifr_netmask, &mask, sizeof(struct sockaddr_in));
 353 #endif /* SUNOS5 */
 354         ret = if_ioctl(SIOCSIFNETMASK, (caddr_t)&ifreq);
 355         if (ret < 0)
 356                 return ret;
 357
 358         return 0;
 359 }
 360
 361 /* Set up interface's address, netmask (and broadcas? ).  Linux or
 362    Solaris uses ifname:number semantics to set IP address aliases. */
 363 int if_unset_prefix(struct interface *ifp, struct connected *ifc)
 364 {
 365         int ret;
 366         struct ifreq ifreq;
 367         struct sockaddr_in addr;
 368         struct prefix_ipv4 *p;
 369
 370         p = (struct prefix_ipv4 *)ifc->address;
 371
 372         ifreq_set_name(&ifreq, ifp);
 373
 374         memset(&addr, 0, sizeof(struct sockaddr_in));
 375         addr.sin_family = p->family;
 376         memcpy(&ifreq.ifr_addr, &addr, sizeof(struct sockaddr_in));
 377         ret = if_ioctl(SIOCSIFADDR, (caddr_t)&ifreq);
 378         if (ret < 0)
 379                 return ret;
 380
 381         return 0;
 382 }
 383 #endif /* HAVE_STRUCT_IFALIASREQ */
 384 #endif /* HAVE_NETLINK */
 385
 386 /* get interface flags */
 387 void if_get_flags(struct interface *ifp)
 388 {
 389         int ret;
 390         struct ifreq ifreq;
 391 #ifdef HAVE_BSD_LINK_DETECT
 392         struct ifmediareq ifmr;
 393 #endif /* HAVE_BSD_LINK_DETECT */
 394
 395         ifreq_set_name(&ifreq, ifp);
 396
 397         ret = vrf_if_ioctl(SIOCGIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
 398         if (ret < 0) {
 399                 flog_err_sys(LIB_ERR_SYSTEM_CALL,
 400                              "vrf_if_ioctl(SIOCGIFFLAGS) failed: %s",
 401                              safe_strerror(errno));
 402                 return;
 403         }
 404 #ifdef HAVE_BSD_LINK_DETECT /* Detect BSD link-state at start-up */
 405
 406         /* Per-default, IFF_RUNNING is held high, unless link-detect says
 407          * otherwise - we abuse IFF_RUNNING inside zebra as a link-state flag,
 408          * following practice on Linux and Solaris kernels
 409          */
 410         SET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
 411
 412         if (CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION)) {
 413                 (void)memset(&ifmr, 0, sizeof(ifmr));
 414                 strncpy(ifmr.ifm_name, ifp->name, IFNAMSIZ);
 415
 416                 /* Seems not all interfaces implement this ioctl */
 417                 if (if_ioctl(SIOCGIFMEDIA, (caddr_t)&ifmr) < 0)
 418                         flog_err_sys(LIB_ERR_SYSTEM_CALL,
 419                                      "if_ioctl(SIOCGIFMEDIA) failed: %s",
 420                                      safe_strerror(errno));
 421                 else if (ifmr.ifm_status & IFM_AVALID) /* Link state is valid */
 422                 {
 423                         if (ifmr.ifm_status & IFM_ACTIVE)
 424                                 SET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
 425                         else
 426                                 UNSET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
 427                 }
 428         }
 429 #endif /* HAVE_BSD_LINK_DETECT */
 430
 431         if_flags_update(ifp, (ifreq.ifr_flags & 0x0000ffff));
 432 }
 433
 434 /* Set interface flags */
 435 int if_set_flags(struct interface *ifp, uint64_t flags)
 436 {
 437         int ret;
 438         struct ifreq ifreq;
 439
 440         memset(&ifreq, 0, sizeof(struct ifreq));
 441         ifreq_set_name(&ifreq, ifp);
 442
 443         ifreq.ifr_flags = ifp->flags;
 444         ifreq.ifr_flags |= flags;
 445
 446         ret = vrf_if_ioctl(SIOCSIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
 447
 448         if (ret < 0) {
 449                 zlog_info("can't set interface flags");
 450                 return ret;
 451         }
 452         return 0;
 453 }
 454
 455 /* Unset interface's flag. */
 456 int if_unset_flags(struct interface *ifp, uint64_t flags)
 457 {
 458         int ret;
 459         struct ifreq ifreq;
 460
 461         memset(&ifreq, 0, sizeof(struct ifreq));
 462         ifreq_set_name(&ifreq, ifp);
 463
 464         ifreq.ifr_flags = ifp->flags;
 465         ifreq.ifr_flags &= ~flags;
 466
 467         ret = vrf_if_ioctl(SIOCSIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
 468
 469         if (ret < 0) {
 470                 zlog_info("can't unset interface flags");
 471                 return ret;
 472         }
 473         return 0;
 474 }
 475
 476 #ifdef LINUX_IPV6
 477 #ifndef _LINUX_IN6_H
 478 /* linux/include/net/ipv6.h */
 479 struct in6_ifreq {
 480         struct in6_addr ifr6_addr;
 481         uint32_t ifr6_prefixlen;
 482         int ifr6_ifindex;
 483 };
 484 #endif /* _LINUX_IN6_H */
 485 /* Interface's address add/delete functions. */
 486 int if_prefix_add_ipv6(struct interface *ifp, struct connected *ifc)
 487 {
 488 #ifdef HAVE_NETLINK
 489         return kernel_address_add_ipv6(ifp, ifc);
 490 #endif /* HAVE_NETLINK */
 491 }
 492
 493 int if_prefix_delete_ipv6(struct interface *ifp, struct connected *ifc)
 494 {
 495 #ifdef HAVE_NETLINK
 496         return kernel_address_delete_ipv6(ifp, ifc);
 497 #endif /* HAVE_NETLINK */
 498 }
 499 #else /* LINUX_IPV6 */
 500 #ifdef HAVE_STRUCT_IN6_ALIASREQ
 501 #ifndef ND6_INFINITE_LIFETIME
 502 #define ND6_INFINITE_LIFETIME 0xffffffffL
 503 #endif /* ND6_INFINITE_LIFETIME */
 504 int if_prefix_add_ipv6(struct interface *ifp, struct connected *ifc)
 505 {
 506         int ret;
 507         struct in6_aliasreq addreq;
 508         struct sockaddr_in6 addr;
 509         struct sockaddr_in6 mask;
 510         struct prefix_ipv6 *p;
 511
 512         p = (struct prefix_ipv6 *)ifc->address;
 513
 514         memset(&addreq, 0, sizeof addreq);
 515         strncpy((char *)&addreq.ifra_name, ifp->name, sizeof addreq.ifra_name);
 516
 517         memset(&addr, 0, sizeof(struct sockaddr_in6));
 518         addr.sin6_addr = p->prefix;
 519         addr.sin6_family = p->family;
 520 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 521         addr.sin6_len = sizeof(struct sockaddr_in6);
 522 #endif
 523         memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in6));
 524
 525         memset(&mask, 0, sizeof(struct sockaddr_in6));
 526         masklen2ip6(p->prefixlen, &mask.sin6_addr);
 527         mask.sin6_family = p->family;
 528 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 529         mask.sin6_len = sizeof(struct sockaddr_in6);
 530 #endif
 531         memcpy(&addreq.ifra_prefixmask, &mask, sizeof(struct sockaddr_in6));
 532
 533         addreq.ifra_lifetime.ia6t_vltime = 0xffffffff;
 534         addreq.ifra_lifetime.ia6t_pltime = 0xffffffff;
 535
 536 #ifdef HAVE_STRUCT_IF6_ALIASREQ_IFRA_LIFETIME
 537         addreq.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
 538         addreq.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
 539 #endif
 540
 541         ret = if_ioctl_ipv6(SIOCAIFADDR_IN6, (caddr_t)&addreq);
 542         if (ret < 0)
 543                 return ret;
 544         return 0;
 545 }
 546
 547 int if_prefix_delete_ipv6(struct interface *ifp, struct connected *ifc)
 548 {
 549         int ret;
 550         struct in6_aliasreq addreq;
 551         struct sockaddr_in6 addr;
 552         struct sockaddr_in6 mask;
 553         struct prefix_ipv6 *p;
 554
 555         p = (struct prefix_ipv6 *)ifc->address;
 556
 557         memset(&addreq, 0, sizeof addreq);
 558         strncpy((char *)&addreq.ifra_name, ifp->name, sizeof addreq.ifra_name);
 559
 560         memset(&addr, 0, sizeof(struct sockaddr_in6));
 561         addr.sin6_addr = p->prefix;
 562         addr.sin6_family = p->family;
 563 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 564         addr.sin6_len = sizeof(struct sockaddr_in6);
 565 #endif
 566         memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in6));
 567
 568         memset(&mask, 0, sizeof(struct sockaddr_in6));
 569         masklen2ip6(p->prefixlen, &mask.sin6_addr);
 570         mask.sin6_family = p->family;
 571 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 572         mask.sin6_len = sizeof(struct sockaddr_in6);
 573 #endif
 574         memcpy(&addreq.ifra_prefixmask, &mask, sizeof(struct sockaddr_in6));
 575
 576 #ifdef HAVE_STRUCT_IF6_ALIASREQ_IFRA_LIFETIME
 577         addreq.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
 578         addreq.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
 579 #endif
 580
 581         ret = if_ioctl_ipv6(SIOCDIFADDR_IN6, (caddr_t)&addreq);
 582         if (ret < 0)
 583                 return ret;
 584         return 0;
 585 }
 586 #else
 587 int if_prefix_add_ipv6(struct interface *ifp, struct connected *ifc)
 588 {
 589         return 0;
 590 }
 591
 592 int if_prefix_delete_ipv6(struct interface *ifp, struct connected *ifc)
 593 {
 594         return 0;
 595 }
 596 #endif /* HAVE_STRUCT_IN6_ALIASREQ */
 597
 598 #endif /* LINUX_IPV6 */
 599
 600 #endif /* !SUNOS_5 */