Return to ipforward_solaris.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / zebra

quagga

    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 */