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