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