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