zebra/ioctl_solaris.c

   1 /*
   2  * Common ioctl functions for Solaris.
   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 #ifdef SUNOS_5
  25
  26 #include "linklist.h"
  27 #include "if.h"
  28 #include "prefix.h"
  29 #include "ioctl.h"
  30 #include "log.h"
  31 #include "privs.h"
  32 #include "vty.h"
  33 #include "vrf.h"
  34 #include "lib_errors.h"
  35
  36 #include "zebra/rib.h"
  37 #include "zebra/rt.h"
  38 #include "zebra/interface.h"
  39 #include "zebra/ioctl_solaris.h"
  40
  41 extern struct zebra_privs_t zserv_privs;
  42
  43 /* clear and set interface name string */
  44 void lifreq_set_name(struct lifreq *lifreq, const char *ifname)
  45 {
  46         strncpy(lifreq->lifr_name, ifname, IFNAMSIZ);
  47 }
  48
  49 int vrf_if_ioctl(unsigned long request, caddr_t buffer, vrf_id_t vrf_id)
  50 {
  51         return if_ioctl(request, buffer);
  52 }
  53
  54 /* call ioctl system call */
  55 int if_ioctl(unsigned long request, caddr_t buffer)
  56 {
  57         int sock;
  58         int ret;
  59         int err;
  60
  61         if (zserv_privs.change(ZPRIVS_RAISE))
  62                 zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
  63
  64         sock = socket(AF_INET, SOCK_DGRAM, 0);
  65         if (sock < 0) {
  66                 int save_errno = errno;
  67                 if (zserv_privs.change(ZPRIVS_LOWER))
  68                         zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
  69                 zlog_ferr(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
  70                           safe_strerror(save_errno));
  71                 exit(1);
  72         }
  73
  74         if ((ret = ioctl(sock, request, buffer)) < 0)
  75                 err = errno;
  76
  77         if (zserv_privs.change(ZPRIVS_LOWER))
  78                 zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
  79
  80         close(sock);
  81
  82         if (ret < 0) {
  83                 errno = err;
  84                 return ret;
  85         }
  86         return 0;
  87 }
  88
  89
  90 int if_ioctl_ipv6(unsigned long request, caddr_t buffer)
  91 {
  92         int sock;
  93         int ret;
  94         int err;
  95
  96         if (zserv_privs.change(ZPRIVS_RAISE))
  97                 zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
  98
  99         sock = socket(AF_INET6, SOCK_DGRAM, 0);
 100         if (sock < 0) {
 101                 int save_errno = errno;
 102                 if (zserv_privs.change(ZPRIVS_LOWER))
 103                         zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 104                 zlog_ferr(LIB_ERR_SOCKET,
 105                           "Cannot create IPv6 datagram socket: %s",
 106                           safe_strerror(save_errno));
 107                 exit(1);
 108         }
 109
 110         if ((ret = ioctl(sock, request, buffer)) < 0)
 111                 err = errno;
 112
 113         if (zserv_privs.change(ZPRIVS_LOWER))
 114                 zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 115
 116         close(sock);
 117
 118         if (ret < 0) {
 119                 errno = err;
 120                 return ret;
 121         }
 122
 123         return 0;
 124 }
 125
 126 /*
 127  * get interface metric
 128  *   -- if value is not avaliable set -1
 129  */
 130 void if_get_metric(struct interface *ifp)
 131 {
 132         struct lifreq lifreq;
 133         int ret;
 134
 135         lifreq_set_name(&lifreq, ifp->name);
 136
 137         if (ifp->flags & IFF_IPV4)
 138                 ret = AF_IOCTL(AF_INET, SIOCGLIFMETRIC, (caddr_t)&lifreq);
 139 #ifdef SOLARIS_IPV6
 140         else if (ifp->flags & IFF_IPV6)
 141                 ret = AF_IOCTL(AF_INET6, SIOCGLIFMETRIC, (caddr_t)&lifreq);
 142 #endif /* SOLARIS_IPV6 */
 143         else
 144                 ret = -1;
 145
 146         if (ret < 0)
 147                 return;
 148
 149         ifp->metric = lifreq.lifr_metric;
 150
 151         if (ifp->metric == 0)
 152                 ifp->metric = 1;
 153 }
 154
 155 /* get interface MTU */
 156 void if_get_mtu(struct interface *ifp)
 157 {
 158         struct lifreq lifreq;
 159         int ret;
 160         uint8_t changed = 0;
 161
 162         if (ifp->flags & IFF_IPV4) {
 163                 lifreq_set_name(&lifreq, ifp->name);
 164                 ret = AF_IOCTL(AF_INET, SIOCGLIFMTU, (caddr_t)&lifreq);
 165                 if (ret < 0) {
 166                         zlog_info(
 167                                 "Can't lookup mtu on %s by ioctl(SIOCGLIFMTU)",
 168                                 ifp->name);
 169                         ifp->mtu = -1;
 170                 } else {
 171                         ifp->mtu = lifreq.lifr_metric;
 172                         changed = 1;
 173                 }
 174         }
 175
 176         if (ifp->flags & IFF_IPV6) {
 177                 memset(&lifreq, 0, sizeof(lifreq));
 178                 lifreq_set_name(&lifreq, ifp->name);
 179
 180                 ret = AF_IOCTL(AF_INET6, SIOCGLIFMTU, (caddr_t)&lifreq);
 181                 if (ret < 0) {
 182                         zlog_info(
 183                                 "Can't lookup mtu6 on %s by ioctl(SIOCGIFMTU)",
 184                                 ifp->name);
 185                         ifp->mtu6 = -1;
 186                 } else {
 187                         ifp->mtu6 = lifreq.lifr_metric;
 188                         changed = 1;
 189                 }
 190         }
 191
 192         if (changed)
 193                 zebra_interface_up_update(ifp);
 194 }
 195
 196 /* Set up interface's address, netmask (and broadcast? ).
 197    Solaris uses ifname:number semantics to set IP address aliases. */
 198 int if_set_prefix(struct interface *ifp, struct connected *ifc)
 199 {
 200         int ret;
 201         struct ifreq ifreq;
 202         struct sockaddr_in addr;
 203         struct sockaddr_in broad;
 204         struct sockaddr_in mask;
 205         struct prefix_ipv4 ifaddr;
 206         struct prefix_ipv4 *p;
 207
 208         p = (struct prefix_ipv4 *)ifc->address;
 209
 210         ifaddr = *p;
 211
 212         strncpy(ifreq.ifr_name, ifp->name, IFNAMSIZ);
 213
 214         addr.sin_addr = p->prefix;
 215         addr.sin_family = p->family;
 216         memcpy(&ifreq.ifr_addr, &addr, sizeof(struct sockaddr_in));
 217
 218         ret = if_ioctl(SIOCSIFADDR, (caddr_t)&ifreq);
 219
 220         if (ret < 0)
 221                 return ret;
 222
 223         /* We need mask for make broadcast addr. */
 224         masklen2ip(p->prefixlen, &mask.sin_addr);
 225
 226         if (if_is_broadcast(ifp)) {
 227                 apply_mask_ipv4(&ifaddr);
 228                 addr.sin_addr = ifaddr.prefix;
 229
 230                 broad.sin_addr.s_addr =
 231                         (addr.sin_addr.s_addr | ~mask.sin_addr.s_addr);
 232                 broad.sin_family = p->family;
 233
 234                 memcpy(&ifreq.ifr_broadaddr, &broad,
 235                        sizeof(struct sockaddr_in));
 236                 ret = if_ioctl(SIOCSIFBRDADDR, (caddr_t)&ifreq);
 237                 if (ret < 0)
 238                         return ret;
 239         }
 240
 241         mask.sin_family = p->family;
 242 #ifdef SUNOS_5
 243         memcpy(&mask, &ifreq.ifr_addr, sizeof(mask));
 244 #else
 245         memcpy(&ifreq.ifr_netmask, &mask, sizeof(struct sockaddr_in));
 246 #endif /* SUNOS_5 */
 247         ret = if_ioctl(SIOCSIFNETMASK, (caddr_t)&ifreq);
 248
 249         return ((ret < 0) ? ret : 0);
 250 }
 251
 252 /* Set up interface's address, netmask (and broadcast).
 253    Solaris uses ifname:number semantics to set IP address aliases. */
 254 int if_unset_prefix(struct interface *ifp, struct connected *ifc)
 255 {
 256         int ret;
 257         struct ifreq ifreq;
 258         struct sockaddr_in addr;
 259         struct prefix_ipv4 *p;
 260
 261         p = (struct prefix_ipv4 *)ifc->address;
 262
 263         strncpy(ifreq.ifr_name, ifp->name, IFNAMSIZ);
 264
 265         memset(&addr, 0, sizeof(struct sockaddr_in));
 266         addr.sin_family = p->family;
 267         memcpy(&ifreq.ifr_addr, &addr, sizeof(struct sockaddr_in));
 268
 269         ret = if_ioctl(SIOCSIFADDR, (caddr_t)&ifreq);
 270
 271         if (ret < 0)
 272                 return ret;
 273
 274         return 0;
 275 }
 276
 277 /* Get just the flags for the given name.
 278  * Used by the normal 'if_get_flags' function, as well
 279  * as the bootup interface-list code, which has to peek at per-address
 280  * flags in order to figure out which ones should be ignored..
 281  */
 282 int if_get_flags_direct(const char *ifname, uint64_t *flags, unsigned int af)
 283 {
 284         struct lifreq lifreq;
 285         int ret;
 286
 287         lifreq_set_name(&lifreq, ifname);
 288
 289         ret = AF_IOCTL(af, SIOCGLIFFLAGS, (caddr_t)&lifreq);
 290
 291         if (ret)
 292                 zlog_debug("%s: ifname %s, error %s (%d)", __func__, ifname,
 293                            safe_strerror(errno), errno);
 294
 295         *flags = lifreq.lifr_flags;
 296
 297         return ret;
 298 }
 299
 300 /* get interface flags */
 301 void if_get_flags(struct interface *ifp)
 302 {
 303         int ret4 = 0, ret6 = 0;
 304         uint64_t newflags = 0;
 305         uint64_t tmpflags;
 306
 307         if (ifp->flags & IFF_IPV4) {
 308                 ret4 = if_get_flags_direct(ifp->name, &tmpflags, AF_INET);
 309
 310                 if (!ret4)
 311                         newflags |= tmpflags;
 312                 else if (errno == ENXIO) {
 313                         /* it's gone */
 314                         UNSET_FLAG(ifp->flags, IFF_UP);
 315                         if_flags_update(ifp, ifp->flags);
 316                 }
 317         }
 318
 319         if (ifp->flags & IFF_IPV6) {
 320                 ret6 = if_get_flags_direct(ifp->name, &tmpflags, AF_INET6);
 321
 322                 if (!ret6)
 323                         newflags |= tmpflags;
 324                 else if (errno == ENXIO) {
 325                         /* it's gone */
 326                         UNSET_FLAG(ifp->flags, IFF_UP);
 327                         if_flags_update(ifp, ifp->flags);
 328                 }
 329         }
 330
 331         /* only update flags if one of above succeeded */
 332         if (!(ret4 && ret6))
 333                 if_flags_update(ifp, newflags);
 334 }
 335
 336 /* Set interface flags */
 337 int if_set_flags(struct interface *ifp, uint64_t flags)
 338 {
 339         int ret;
 340         struct lifreq lifreq;
 341
 342         lifreq_set_name(&lifreq, ifp->name);
 343
 344         lifreq.lifr_flags = ifp->flags;
 345         lifreq.lifr_flags |= flags;
 346
 347         if (ifp->flags & IFF_IPV4)
 348                 ret = AF_IOCTL(AF_INET, SIOCSLIFFLAGS, (caddr_t)&lifreq);
 349         else if (ifp->flags & IFF_IPV6)
 350                 ret = AF_IOCTL(AF_INET6, SIOCSLIFFLAGS, (caddr_t)&lifreq);
 351         else
 352                 ret = -1;
 353
 354         if (ret < 0)
 355                 zlog_info("can't set interface flags on %s: %s", ifp->name,
 356                           safe_strerror(errno));
 357         else
 358                 ret = 0;
 359
 360         return ret;
 361 }
 362
 363 /* Unset interface's flag. */
 364 int if_unset_flags(struct interface *ifp, uint64_t flags)
 365 {
 366         int ret;
 367         struct lifreq lifreq;
 368
 369         lifreq_set_name(&lifreq, ifp->name);
 370
 371         lifreq.lifr_flags = ifp->flags;
 372         lifreq.lifr_flags &= ~flags;
 373
 374         if (ifp->flags & IFF_IPV4)
 375                 ret = AF_IOCTL(AF_INET, SIOCSLIFFLAGS, (caddr_t)&lifreq);
 376         else if (ifp->flags & IFF_IPV6)
 377                 ret = AF_IOCTL(AF_INET6, SIOCSLIFFLAGS, (caddr_t)&lifreq);
 378         else
 379                 ret = -1;
 380
 381         if (ret < 0)
 382                 zlog_info("can't unset interface flags");
 383         else
 384                 ret = 0;
 385
 386         return ret;
 387 }
 388
 389 /* Interface's address add/delete functions. */
 390 int if_prefix_add_ipv6(struct interface *ifp, struct connected *ifc)
 391 {
 392         char addrbuf[PREFIX_STRLEN];
 393
 394         zlog_warn("Can't set %s on interface %s",
 395                   prefix2str(ifc->address, addrbuf, sizeof(addrbuf)),
 396                   ifp->name);
 397
 398         return 0;
 399 }
 400
 401 int if_prefix_delete_ipv6(struct interface *ifp, struct connected *ifc)
 402 {
 403         char addrbuf[PREFIX_STRLEN];
 404
 405         zlog_warn("Can't delete %s on interface %s",
 406                   prefix2str(ifc->address, addrbuf, sizeof(addrbuf)),
 407                   ifp->name);
 408
 409         return 0;
 410 }
 411
 412 #endif /* SUNOS_5 */