Return to ipforward_solaris.c CVS log

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

Annotation of embedaddon/quagga/zebra/ipforward_solaris.c, revision 1.1.1.1

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