zebra/ipforward_solaris.c

   1 /*
   2  * ipforward value get function for solaris.
   3  * Copyright (C) 1997 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 #include "log.h"
  24 #include "prefix.h"
  25
  26 #include "privs.h"
  27 #include "zebra/ipforward.h"
  28
  29 /*
  30 ** Solaris should define IP_DEV_NAME in <inet/ip.h>, but we'll save
  31 ** configure.in changes for another day.  We can use the same device
  32 ** for both IPv4 and IPv6.
  33 */
  34 /* #include <inet/ip.h> */
  35 #ifndef IP_DEV_NAME
  36 #define IP_DEV_NAME "/dev/ip"
  37 #endif
  38
  39
  40 extern struct zebra_privs_t zserv_privs;
  41
  42 /* This is a limited ndd style function that operates one integer
  43 ** value only.  Errors return -1. ND_SET commands return 0 on
  44 ** success. ND_GET commands return the value on success (which could
  45 ** be -1 and be confused for an error).  The parameter is the string
  46 ** name of the parameter being referenced.
  47 */
  48
  49 static int
  50 solaris_nd(const int cmd, const char* parameter, const int value)
  51 {
  52 #define ND_BUFFER_SIZE 1024
  53   int fd;
  54   char nd_buf[ND_BUFFER_SIZE];
  55   struct strioctl strioctl;
  56   const char* device = IP_DEV_NAME;
  57   int retval;
  58   memset(nd_buf, '\0', ND_BUFFER_SIZE);
  59   /*
  60   ** ND_SET takes a NULL delimited list of strings further terminated
  61   ** buy a NULL.  ND_GET returns a list in a similar layout, although
  62   ** here we only use the first result.
  63   */
  64   if (cmd == ND_SET)
  65     snprintf(nd_buf, ND_BUFFER_SIZE, "%s%c%d%c", parameter, '\0', value,'\0');
  66   else if (cmd == ND_GET)
  67     snprintf(nd_buf, ND_BUFFER_SIZE, "%s", parameter);
  68   else {
  69     zlog_err("internal error - inappropriate command given to "
  70              "solaris_nd()%s:%d", __FILE__, __LINE__);
  71     return -1;
  72   }
  73
  74   strioctl.ic_cmd = cmd;
  75   strioctl.ic_timout = 0;
  76   strioctl.ic_len = ND_BUFFER_SIZE;
  77   strioctl.ic_dp = nd_buf;
  78
  79   if ( zserv_privs.change (ZPRIVS_RAISE) )
  80        zlog_err ("solaris_nd: Can't raise privileges");
  81   if ((fd = open (device, O_RDWR)) < 0)
  82     {
  83       zlog_warn("failed to open device %s - %s", device, safe_strerror(errno));
  84       if ( zserv_privs.change (ZPRIVS_LOWER) )
  85         zlog_err ("solaris_nd: Can't lower privileges");
  86       return -1;
  87     }
  88   if (ioctl (fd, I_STR, &strioctl) < 0)
  89     {
  90       int save_errno = errno;
  91       if ( zserv_privs.change (ZPRIVS_LOWER) )
  92         zlog_err ("solaris_nd: Can't lower privileges");
  93       close (fd);
  94       zlog_warn("ioctl I_STR failed on device %s - %s",
  95                 device, safe_strerror(save_errno));
  96       return -1;
  97     }
  98   close(fd);
  99   if ( zserv_privs.change (ZPRIVS_LOWER) )
 100          zlog_err ("solaris_nd: Can't lower privileges");
 101
 102   if (cmd == ND_GET)
 103     {
 104       errno = 0;
 105       retval = atoi(nd_buf);
 106       if (errno)
 107         {
 108           zlog_warn("failed to convert returned value to integer - %s",
 109                     safe_strerror(errno));
 110           retval = -1;
 111         }
 112     }
 113   else
 114     {
 115       retval = 0;
 116     }
 117   return retval;
 118 }
 119
 120 static int
 121 solaris_nd_set(const char* parameter, const int value) {
 122   return solaris_nd(ND_SET, parameter, value);
 123 }
 124 static int
 125 solaris_nd_get(const char* parameter) {
 126   return solaris_nd(ND_GET, parameter, 0);
 127 }
 128 int
 129 ipforward(void)
 130 {
 131   return solaris_nd_get("ip_forwarding");
 132 }
 133
 134 int
 135 ipforward_on (void)
 136 {
 137   (void) solaris_nd_set("ip_forwarding", 1);
 138   return ipforward();
 139 }
 140
 141 int
 142 ipforward_off (void)
 143 {
 144   (void) solaris_nd_set("ip_forwarding", 0);
 145   return ipforward();
 146 }
 147 int ipforward_ipv6(void)
 148 {
 149   return solaris_nd_get("ip6_forwarding");
 150 }
 151 int
 152 ipforward_ipv6_on (void)
 153 {
 154   (void) solaris_nd_set("ip6_forwarding", 1);
 155   return ipforward_ipv6();
 156 }
 157 int
 158 ipforward_ipv6_off (void)
 159 {
 160   (void) solaris_nd_set("ip6_forwarding", 0);
 161   return ipforward_ipv6();
 162 }