开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
tunnel.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：26k
源码类别：

SNMP编程

开发平台：

Unix_Linux

tunnel.c：源码内容
  1. /*
  2.  * tunnel.c --
  3.  * 
  4.  *      An implementation of the TUNNEL-MIB for the UCD-SNMP 4.2
  5.  *      agent running on Linux 2.2.x.
  6.  *      
  7.  * Copyright (c) 2000 Frank Strauss <strauss@ibr.cs.tu-bs.de>
  8.  *
  9.  *                          All Rights Reserved
  10.  * 
  11.  * Permission to use, copy, modify and distribute this software and its
  12.  * documentation for any purpose and without fee is hereby granted,
  13.  * provided that the above copyright notice appears in all copies and
  14.  * that both that copyright notice and this permission notice appear in
  15.  * supporting documentation, and that the name of the author and CMU and
  16.  * The Regents of the University of California not be used in advertising
  17.  * or publicity pertaining to distribution of the software without
  18.  * specific written permission.
  19.  * 
  20.  * THE AUTHOR AND CMU AND THE REGENTS OF THE UNIVERSITY OF CALIFORNIA
  21.  * DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  22.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL
  23.  * THE AUTHOR OR CMU OR THE REGENTS OF THE UNIVERSITY OF CALIFORNIA BE
  24.  * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
  25.  * DAMAGES WHATSOEVER RESULTING FROM THE LOSS OF USE, DATA OR PROFITS,
  26.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  27.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  28.  * SOFTWARE.
  29.  *
  30.  */
  32. /*
  33.  * NOTE: This TUNNEL-MIB implementation
  34.  *
  35.  *       (a) DOES NOT implement write access on the tunnelConfigTable,
  36.  *           i.e. no new tunnels can be created and no existing tunnels
  37.  *           can be removed through SET operations.
  38.  *
  39.  *       (b) DOES implement write access on some tunnelIfTable objects
  40.  *           to allow reconfiguring established tunnels. This violates
  41.  *           RFC 2667! However, the author thinks it makes sense. ;-)
  42.  */
  44. #include <string.h>
  45. #include <stdio.h>
  46. #include <stdlib.h>
  47. #include <unistd.h>
  48. #include <sys/types.h>
  49. #include <sys/socket.h>
  50. #include <sys/time.h>
  51. #include <sys/ioctl.h>
  52. #include <signal.h>
  53. #include <netinet/in.h>
  54. #include <arpa/inet.h>
  56. #include <linux/if.h>
  57. #include <linux/ip.h>
  58. #include <linux/sockios.h>
  59. #include <linux/if_tunnel.h>
  60. #include <linux/if_arp.h>
  62. #include <net-snmp/net-snmp-config.h>
  63. #include <net-snmp/net-snmp-includes.h>
  64. #include <net-snmp/agent/net-snmp-agent-includes.h>
  66. #include "util_funcs.h"
  67. #include "tunnel.h"
  69. #ifndef MIN
  70. #define MIN(a, b) (((a) < (b)) ? (a) : (b))
  71. #endif
  72. #ifndef MAX
  73. #define MAX(a, b) (((a) > (b)) ? (a) : (b))
  74. #endif
  78. /*
  79.  * This is used, because the TUNNEL-MIB augments ifTable. 
  80.  */
  81. extern unsigned char *var_ifEntry(struct variable *,
  82.                                   oid *, size_t *,
  83.                                   int, size_t *, WriteMethod **);
  86. /*
  87.  * tunnel_variables_oid:
  88.  *   this is the top level oid that we want to register under.  This
  89.  *   is essentially a prefix, with the suffix appearing in the
  90.  *   variable below.
  91.  */
  92. oid             tunnel_variables_oid[] =
  93.     { 1, 3, 6, 1, 2, 1, 10, 131, 1, 1 };
  94. const int       tunnel_len = 10;
  96. oid             tunnel_ifEntry_oid[] =
  97.     { 1, 3, 6, 1, 2, 1, 10, 131, 1, 1, 1, 1 };
  98. const int       tunnel_ifEntry_len = 12;
  100. oid             tunnel_configEntry_oid[] =
  101.     { 1, 3, 6, 1, 2, 1, 10, 131, 1, 1, 2, 1 };
  102. const int       tunnel_configEntry_len = 12;
  106. struct tunnel {
  107.     oid             ifindex;
  108.     int             id;
  109.     char           *ifname;
  110.     int             active;
  111.     unsigned long   local;
  112.     unsigned long   remote;
  113.     int             encaps;
  114.     int             hoplimit;
  115.     int             security;
  116.     int             tos;
  117.     oid             config_name[MAX_OID_LEN];
  118.     size_t          config_length;
  119.     struct tunnel  *next;
  120. };
  124. /*
  125.  * variable4 tunnel_variables:
  126.  *   this variable defines function callbacks and type return information 
  127.  *   for the tunnel mib section 
  128.  */
  130. struct variable4 tunnel_variables[] = {
  131.     /*
  132.      * magic number        , variable type , ro/rw , callback fn  , L, oidsuffix 
  133.      */
  134. #define   LOCALADDRESS          1
  135.     {LOCALADDRESS, ASN_IPADDRESS, RWRITE, var_tunnelIfEntry, 3, {1, 1, 1}},
  136. #define   REMOTEADDRESS         2
  137.     {REMOTEADDRESS, ASN_IPADDRESS, RWRITE, var_tunnelIfEntry, 3,
  138.      {1, 1, 2}},
  139. #define   ENCAPSMETHOD          3
  140.     {ENCAPSMETHOD, ASN_INTEGER, RONLY, var_tunnelIfEntry, 3, {1, 1, 3}},
  141. #define   HOPLIMIT              4
  142.     {HOPLIMIT, ASN_INTEGER, RWRITE, var_tunnelIfEntry, 3, {1, 1, 4}},
  143. #define   SECURITY              5
  144.     {SECURITY, ASN_INTEGER, RONLY, var_tunnelIfEntry, 3, {1, 1, 5}},
  145. #define   TOS                   6
  146.     {TOS, ASN_INTEGER, RWRITE, var_tunnelIfEntry, 3, {1, 1, 6}},
  148. #define   IFINDEX               7
  149.     {IFINDEX, ASN_INTEGER, RONLY, var_tunnelConfigEntry, 3, {2, 1, 5}},
  150. #define   ROWSTATUS             8
  151.     {ROWSTATUS, ASN_INTEGER, RWRITE, var_tunnelConfigEntry, 3, {2, 1, 6}},
  152. };
  156. extern int      register_sysORTable(oid *, size_t, const char *);
  157. extern int      unregister_sysORTable(oid *, size_t);
  159. static oid      sysORTable_reg[] = { 1, 3, 6, 1, 2, 1, 10, 131 };
  160. static size_t   sysORTable_reglen = 8;
  162. static struct tunnel *tunnels;
  166. void
  167. deinit_tunnel(void)
  168. {
  169.     unregister_sysORTable(sysORTable_reg, sysORTable_reglen);
  170. }
  174. int
  175. term_tunnel(int majorID, int minorID, void *serverarg, void *clientarg)
  176. {
  177.     deinit_tunnel();
  178.     return 0;
  179. }
  183. void
  184. init_tunnel(void)
  185. {
  186.     register_sysORTable(sysORTable_reg, sysORTable_reglen,
  187.                         "RFC 2667 TUNNEL-MIB implementation for "
  188.                         "Linux 2.2.x kernels.");
  190.     /*
  191.      * register ourselves with the agent to handle our mib tree 
  192.      */
  193.     REGISTER_MIB("tunnel", tunnel_variables, variable4,
  194.                  tunnel_variables_oid);
  196.     snmp_register_callback(SNMP_CALLBACK_LIBRARY,
  197.                            SNMP_CALLBACK_SHUTDOWN, term_tunnel, NULL);
  199.     tunnels = NULL;
  200. }
  204. static int
  205. getType(int index)
  206. {
  207.     oid             name[MAX_OID_LEN] = { 1, 3, 6, 1, 2, 1, 2, 2, 1, 3 };
  208.     size_t          length = 10;
  209.     struct variable ifType_variable =
  210.         { 3, ASN_INTEGER, RONLY, var_ifEntry, 10,
  211.         {1, 3, 6, 1, 2, 1, 2, 2, 1, 3}
  212.     };
  213.     unsigned char  *p;
  214.     size_t          var_len;
  215.     WriteMethod    *write_method;
  217.     name[length] = index;
  218.     length++;
  220.     p = var_ifEntry(&ifType_variable,
  221.                     name, &length,
  222.                     1 /* exact */ , &var_len, &write_method);
  223.     if (!p)
  224.         return 0;
  226.     return *(int *) p;
  227. }
  231. static char    *
  232. getName(int index)
  233. {
  234.     oid             name[MAX_OID_LEN] = { 1, 3, 6, 1, 2, 1, 2, 2, 1, 2 };
  235.     size_t          length = 10;
  236.     struct variable ifName_variable =
  237.         { 2, ASN_INTEGER, RONLY, var_ifEntry, 10,
  238.         {1, 3, 6, 1, 2, 1, 2, 2, 1, 2}
  239.     };
  240.     unsigned char  *p;
  241.     size_t          var_len;
  242.     WriteMethod    *write_method;
  244.     name[length] = index;
  245.     length++;
  247.     p = var_ifEntry(&ifName_variable,
  248.                     name, &length,
  249.                     1 /* exact */ , &var_len, &write_method);
  250.     if (!p)
  251.         return NULL;
  253.     return p;
  254. }
  258. static struct ip_tunnel_parm *
  259. getTunnelParm(char *ifname)
  260. {
  261.     struct ifreq    ifrq;
  262.     int             fd;
  263.     static struct ip_tunnel_parm parm;
  265.     if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  266.         return NULL;
  267.     }
  269.     memset(&parm, 0, sizeof(struct ip_tunnel_parm));
  270.     strcpy(ifrq.ifr_name, ifname);
  271.     ifrq.ifr_ifru.ifru_data = (void *) &parm;
  272.     if (ioctl(fd, SIOCGETTUNNEL, &ifrq) < 0) {
  273.         /*
  274.          * try again with the last char of the device name cut off.
  275.          * it might have been a zero digit appended by the agent.
  276.          */
  277.         ifrq.ifr_name[strlen(ifrq.ifr_name) - 1] = 0;
  278.         if (ioctl(fd, SIOCGETTUNNEL, &ifrq) < 0) {
  279.             close(fd);
  280.             return NULL;
  281.         }
  282.         ifname[strlen(ifname) - 1] = 0;
  283.     }
  285.     close(fd);
  287.     return &parm;
  288. }
  292. int
  293. setTunnelParm(char *ifname, struct ip_tunnel_parm *parm)
  294. {
  295.     struct ifreq    ifrq;
  296.     int             fd;
  297.     int             err;
  299.     if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  300.         return -1;
  301.     }
  303.     strcpy(ifrq.ifr_name, ifname);
  304.     ifrq.ifr_ifru.ifru_data = (void *) parm;
  305.     err = ioctl(fd, SIOCCHGTUNNEL, &ifrq);
  306.     close(fd);
  308.     return err;
  309. }
  313. /*
  314.  * update a struct tunnel. its index and ifname elements have to be set.
  315.  */
  316. static struct tunnel *
  317. updateTunnel(struct tunnel *tunnel)
  318. {
  319.     struct ip_tunnel_parm *parm;
  320.     int             fd;
  321.     struct ifreq    ifrq;
  323.     /*
  324.      * NOTE: getTunnelParm() may adjust the passed ifname. 
  325.      */
  326.     parm = getTunnelParm(tunnel->ifname);
  327.     if (!parm) {
  328. DEBUGMSGTL(("tunnel",
  329.     "updateTunnel(): getTunnelParm("%s") returned NULLn",
  330.     tunnel->ifname));
  331.         tunnel->active = 0;
  332.         return NULL;
  333.     }
  335.     tunnel->active = 1;
  337.     tunnel->local = parm->iph.saddr;
  338.     tunnel->remote = parm->iph.daddr;
  340.     if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  341.         DEBUGMSGTL(("snmpd", "socket open failure in updateTunnels()n"));
  342.         return NULL;
  343.     } else {
  344.         /*
  345.          * NOTE: this ioctl does not guarantee 6 bytes of a physaddr.
  346.          * In particular, a 'sit0' interface only appears to get back
  347.          * 4 bytes of sa_data. We don't use sa_data here, or we'd
  348.          * need to memset it to 0 before the ioct.
  349.          */
  350.         strcpy(ifrq.ifr_name, tunnel->ifname);
  351.         if (ioctl(fd, SIOCGIFHWADDR, &ifrq) == 0)
  352.             switch (ifrq.ifr_hwaddr.sa_family) {
  353.             case ARPHRD_TUNNEL:
  354.                 tunnel->encaps = 2;
  355.                 break;;         /* direct */
  356.             case ARPHRD_TUNNEL6:
  357.                 tunnel->encaps = 2;
  358.                 break;;         /* direct */
  359.             case ARPHRD_IPGRE:
  360.                 tunnel->encaps = 3;
  361.                 break;;         /* gre */
  362.             case ARPHRD_SIT:
  363.                 tunnel->encaps = 2;
  364.                 break;;         /* direct */
  365.             default:
  366.                 tunnel->encaps = 1;     /* other */
  367.             }
  368.         close(fd);
  369.     }
  371.     tunnel->hoplimit = parm->iph.ttl;
  372.     tunnel->security = 1;
  373.     tunnel->tos = (parm->iph.tos & 1) ? -1 : parm->iph.tos;
  374.     /*
  375.      * XXX: adjust tos mapping (kernel <-> TUNNEL-MIB::tunnelIfTOS) 
  376.      */
  378.     return tunnel;
  379. }
  383. static void
  384. updateTunnels(void)
  385. {
  386.     static int      max_index = 1;
  387.     static struct tunnel *last_tunnel = NULL;
  388.     struct tunnel  *tunnel;
  389.     char           *ifname;
  390.     int             type;
  392.     /*
  393.      * uptime the tunnels we have so far 
  394.      */
  395.     for (tunnel = tunnels; tunnel; tunnel = tunnel->next) {
  396.         DEBUGMSG(("tunnel",
  397.                   "updateTunnels(): updating %s (index=%d)n",
  398.                   tunnel->ifname, tunnel->ifindex));
  399.         updateTunnel(tunnel);
  400.     }
  402.     /*
  403.      * look for new tunnels 
  404.      */
  405.     for (; max_index < 256; max_index++) {
  406.         DEBUGMSG(("tunnel",
  407.                   "updateTunnels(): looking for new index=%dn",
  408.                   max_index));
  409.         type = getType(max_index);
  410.         if (type == 131) {
  411.             tunnel = (struct tunnel *) malloc(sizeof(struct tunnel));
  412.             if (!tunnel)
  413.                 continue;
  415.             tunnel->ifindex = max_index;
  416.             tunnel->id = 1;
  418.             ifname = getName(max_index);
  419.             if (!ifname) {
  420.                 free(tunnel);
  421.                 continue;
  422.             }
  424.             tunnel->ifname = strdup(ifname);
  425.             if (!tunnel->ifname) {
  426.                 free(tunnel);
  427.                 continue;
  428.             }
  430.             if (!updateTunnel(tunnel)) {
  431.                 free(tunnel);
  432.                 continue;
  433.             }
  435.             if (last_tunnel)
  436.                 last_tunnel->next = tunnel;
  437.             if (!tunnels)
  438.                 tunnels = last_tunnel = tunnel;
  439.             tunnel->next = NULL;
  440.             last_tunnel = tunnel;
  442.             DEBUGMSG(("tunnel",
  443.                       "updateTunnels(): added %s (index=%d state=%d)n",
  444.                       tunnel->ifname, tunnel->ifindex, tunnel->active));
  445.         }
  446.         if (type == 0)
  447.             break;
  448.     }
  449. }
  453. static struct tunnel *
  454. getTunnelByIfIndex(int index)
  455. {
  456.     struct tunnel  *tunnel;
  458.     DEBUGMSG(("tunnel", "getTunnelByIfIndex(%d): ", index));
  460.     for (tunnel = tunnels; tunnel; tunnel = tunnel->next) {
  461.         if (tunnel->ifindex == index) {
  462.             if (!tunnel->active)
  463.                 break;
  464.             DEBUGMSG(("tunnel",
  465.                       "%s (index=%d)n", tunnel->ifname, tunnel->ifindex));
  466.             return tunnel;
  467.         }
  468.     }
  469.     DEBUGMSG(("tunnel", "NONEn"));
  470.     return NULL;
  471. }
  475. static struct tunnel *
  476. getNextTunnelByIfIndex(int index)
  477. {
  478.     struct tunnel  *tunnel;
  480.     DEBUGMSG(("tunnel", "getNextTunnelByIfIndex(%d): ", index));
  482.     for (tunnel = tunnels; tunnel; tunnel = tunnel->next) {
  483.         if (tunnel->ifindex > index) {
  484.             if (!tunnel->active)
  485.                 continue;
  486.             DEBUGMSG(("tunnel",
  487.                       "%s (index=%d)n", tunnel->ifname, tunnel->ifindex));
  488.             return tunnel;
  489.         }
  490.     }
  491.     DEBUGMSG(("tunnel", "NONEn"));
  492.     return NULL;
  493. }
  497. static void
  498. fillConfigOid(oid * name, struct tunnel *tunnel)
  499. {
  500.     name[0] = ((unsigned char *) &tunnel->local)[0];
  501.     name[1] = ((unsigned char *) &tunnel->local)[1];
  502.     name[2] = ((unsigned char *) &tunnel->local)[2];
  503.     name[3] = ((unsigned char *) &tunnel->local)[3];
  504.     name[4] = ((unsigned char *) &tunnel->remote)[0];
  505.     name[5] = ((unsigned char *) &tunnel->remote)[1];
  506.     name[6] = ((unsigned char *) &tunnel->remote)[2];
  507.     name[7] = ((unsigned char *) &tunnel->remote)[3];
  508.     name[8] = tunnel->encaps;
  509.     name[9] = tunnel->id;
  510.     DEBUGMSGOID(("tunnel", name, 10));
  511. }
  515. static struct tunnel *
  516. getTunnelByConfigOid(oid * name, size_t * length)
  517. {
  518.     struct tunnel  *tunnel;
  519.     oid             tname[4 + 4 + 1 + 1];
  521.     DEBUGMSG(("tunnel", "getTunnelByConfigOid(): "));
  523.     for (tunnel = tunnels; tunnel; tunnel = tunnel->next) {
  524.         fillConfigOid(tname, tunnel);
  525.         if (!snmp_oid_compare(tname, 4 + 4 + 1 + 1,
  526.                               &name[tunnel_len + 3],
  527.                               (*length) - tunnel_len - 3)) {
  528.             if (!tunnel->active)
  529.                 break;
  530.             DEBUGMSG(("tunnel",
  531.                       "%s (index=%d)n", tunnel->ifname, tunnel->ifindex));
  532.             return tunnel;
  533.         }
  534.     }
  535.     DEBUGMSG(("tunnel", "NONEn"));
  536.     return NULL;
  537. }
  541. static struct tunnel *
  542. getNextTunnelByConfigOid(oid * name, size_t * length)
  543. {
  544.     struct tunnel  *tunnel, *last_tunnel;
  545.     oid             tname[10], last_tname[10];
  547.     DEBUGMSG(("tunnel", "getNextTunnelByConfigOid("));
  548.     DEBUGMSGOID(("tunnel", name, *length));
  549.     DEBUGMSG(("tunnel", "): "));
  551.     last_tunnel = NULL;
  552.     for (tunnel = tunnels; tunnel; tunnel = tunnel->next) {
  553.         if (!tunnel->active)
  554.             continue;
  555.         fillConfigOid(tname, tunnel);
  556.         if (snmp_oid_compare(tname, 10,
  557.                              &name[tunnel_len + 3],
  558.                              (*length) - tunnel_len - 3) > 0) {
  559.             if (!last_tunnel) {
  560.                 last_tunnel = tunnel;
  561.                 memcpy((char *) last_tname, (char *) tname,
  562.                        10 * sizeof(oid));
  563.             } else {
  564.                 if (snmp_oid_compare(tname, 10, last_tname, 10) < 0) {
  565.                     last_tunnel = tunnel;
  566.                     memcpy((char *) last_tname, (char *) tname,
  567.                            10 * sizeof(oid));
  568.                 }
  569.             }
  570.         }
  571.     }
  573.     if (last_tunnel) {
  574.         DEBUGMSG(("tunnel",
  575.                   "%s (index=%d)n",
  576.                   last_tunnel->ifname, last_tunnel->ifindex));
  577.     } else {
  578.         DEBUGMSG(("tunnel", "NONEn"));
  579.     }
  581.     return last_tunnel;
  582. }
  586. static int
  587. writeLocalAddress(int action, unsigned char *var_val,
  588.                   unsigned char var_val_type, size_t var_val_len,
  589.                   unsigned char *statP, oid * name, size_t name_len)
  590. {
  591.     static struct tunnel *tunnel;
  592.     struct ip_tunnel_parm *parm;
  594.     switch (action) {
  595.     case RESERVE1:
  596.         if (var_val_type != ASN_IPADDRESS) {
  597.             return SNMP_ERR_WRONGTYPE;
  598.         }
  599.         if (var_val_len != 4) {
  600.             return SNMP_ERR_WRONGLENGTH;
  601.         }
  602.     case RESERVE2:
  603.         tunnel = getTunnelByIfIndex((int) name[name_len - 1]);
  604.         if (!tunnel) {
  605.             return SNMP_ERR_NOSUCHNAME;
  606.         }
  607.     case FREE:
  608.         break;
  609.     case ACTION:
  610.         break;
  611.     case UNDO:
  612.         break;
  613.     case COMMIT:
  614.         if (!tunnel) {
  615.             return SNMP_ERR_NOSUCHNAME;
  616.         }
  617.         parm = getTunnelParm(tunnel->ifname);
  618.         if (!parm) {
  619.             return SNMP_ERR_NOSUCHNAME;
  620.         }
  621.         parm->iph.saddr = *(unsigned long *) var_val;
  622.         setTunnelParm(tunnel->ifname, parm);
  623.         break;
  624.     }
  626.     return SNMP_ERR_NOERROR;
  627. }
  631. static int
  632. writeRemoteAddress(int action, unsigned char *var_val,
  633.                    unsigned char var_val_type, size_t var_val_len,
  634.                    unsigned char *statP, oid * name, size_t name_len)
  635. {
  636.     static struct tunnel *tunnel;
  637.     struct ip_tunnel_parm *parm;
  639.     switch (action) {
  640.     case RESERVE1:
  641.         if (var_val_type != ASN_IPADDRESS) {
  642.             return SNMP_ERR_WRONGTYPE;
  643.         }
  644.         if (var_val_len != 4) {
  645.             return SNMP_ERR_WRONGLENGTH;
  646.         }
  647.     case RESERVE2:
  648.         tunnel = getTunnelByIfIndex((int) name[name_len - 1]);
  649.         if (!tunnel) {
  650.             return SNMP_ERR_NOSUCHNAME;
  651.         }
  652.     case FREE:
  653.         break;
  654.     case ACTION:
  655.         break;
  656.     case UNDO:
  657.         break;
  658.     case COMMIT:
  659.         if (!tunnel) {
  660.             return SNMP_ERR_NOSUCHNAME;
  661.         }
  662.         parm = getTunnelParm(tunnel->ifname);
  663.         if (!parm) {
  664.             return SNMP_ERR_NOSUCHNAME;
  665.         }
  666.         parm->iph.daddr = *(unsigned long *) var_val;
  667.         setTunnelParm(tunnel->ifname, parm);
  668.         break;
  669.     }
  671.     return SNMP_ERR_NOERROR;
  672. }
  676. static int
  677. writeHopLimit(int action, unsigned char *var_val,
  678.               unsigned char var_val_type, size_t var_val_len,
  679.               unsigned char *statP, oid * name, size_t name_len)
  680. {
  681.     static struct tunnel *tunnel;
  682.     struct ip_tunnel_parm *parm;
  684.     switch (action) {
  685.     case RESERVE1:
  686.         if (var_val_type != ASN_INTEGER) {
  687.             return SNMP_ERR_WRONGTYPE;
  688.         }
  689.         if (var_val_len > sizeof(long)) {
  690.             return SNMP_ERR_WRONGLENGTH;
  691.         }
  692.     case RESERVE2:
  693.         tunnel = getTunnelByIfIndex((int) name[name_len - 1]);
  694.         if (!tunnel) {
  695.             return SNMP_ERR_NOSUCHNAME;
  696.         }
  697.     case FREE:
  698.         break;
  699.     case ACTION:
  700.         break;
  701.     case UNDO:
  702.         break;
  703.     case COMMIT:
  704.         if (!tunnel) {
  705.             return SNMP_ERR_NOSUCHNAME;
  706.         }
  707.         parm = getTunnelParm(tunnel->ifname);
  708.         if (!parm) {
  709.             return SNMP_ERR_NOSUCHNAME;
  710.         }
  711.         parm->iph.ttl = *(long *) var_val;
  712.         setTunnelParm(tunnel->ifname, parm);
  713.         break;
  714.     }
  716.     return SNMP_ERR_NOERROR;
  717. }
  721. static int
  722. writeTOS(int action, unsigned char *var_val,
  723.          unsigned char var_val_type, size_t var_val_len,
  724.          unsigned char *statP, oid * name, size_t name_len)
  725. {
  726.     static struct tunnel *tunnel;
  727.     struct ip_tunnel_parm *parm;
  729.     switch (action) {
  730.     case RESERVE1:
  731.         if (var_val_type != ASN_INTEGER) {
  732.             return SNMP_ERR_WRONGTYPE;
  733.         }
  734.         if (var_val_len > sizeof(long)) {
  735.             return SNMP_ERR_WRONGLENGTH;
  736.         }
  737.     case RESERVE2:
  738.         tunnel = getTunnelByIfIndex((int) name[name_len - 1]);
  739.         if (!tunnel) {
  740.             return SNMP_ERR_NOSUCHNAME;
  741.         }
  742.     case FREE:
  743.         break;
  744.     case ACTION:
  745.         break;
  746.     case UNDO:
  747.         break;
  748.     case COMMIT:
  749.         if (!tunnel) {
  750.             return SNMP_ERR_NOSUCHNAME;
  751.         }
  752.         parm = getTunnelParm(tunnel->ifname);
  753.         if (!parm) {
  754.             return SNMP_ERR_NOSUCHNAME;
  755.         }
  756.         /*
  757.          * this does not cover all meaningful values: 
  758.          */
  759.         parm->iph.tos = (*(long *) var_val == -1) ? 1 : *(long *) var_val;
  760.         setTunnelParm(tunnel->ifname, parm);
  761.         break;
  762.     }
  764.     return SNMP_ERR_NOERROR;
  765. }
  769. unsigned char  *
  770. var_tunnelIfEntry(struct variable *vp,
  771.                   oid * name, size_t * length,
  772.                   int exact, size_t * var_len, WriteMethod ** write_method)
  773. {
  774.     static unsigned long ret_addr;
  775.     static long     ret_int;
  776.     struct tunnel  *tunnel;
  778.     DEBUGMSGTL(("tunnel", "var_tunnelIfEntry: "));
  779.     DEBUGMSGOID(("tunnel", name, *length));
  780.     DEBUGMSG(("tunnel", " %dn", exact));
  782.     updateTunnels();
  784.     if (exact) {
  785.         if (*length != tunnel_len + 3 + 1) {
  786.             return NULL;
  787.         }
  788.         tunnel = getTunnelByIfIndex((int) name[*length - 1]);
  789.     } else {
  790.         if ((*length) < tunnel_len) {
  791.             memcpy((char *) name, (char *) tunnel_variables_oid,
  792.                    tunnel_len * sizeof(oid));
  793.         }
  794.         if ((*length) < tunnel_len + 1) {
  795.             name[tunnel_len] = 1;
  796.         }
  797.         if ((*length) < tunnel_len + 2) {
  798.             name[tunnel_len + 1] = 1;
  799.         }
  800.         if ((*length) < tunnel_len + 3) {
  801.             name[tunnel_len + 2] = 1;
  802.         }
  803.         if ((*length) < tunnel_len + 4) {
  804.             name[tunnel_len + 3] = 0;
  805.         }
  806.         *length = tunnel_len + 4;
  808.         tunnel = getNextTunnelByIfIndex(name[*length - 1]);
  809.         if (!tunnel) {
  810.             /*
  811.              * end of column, continue with first row of next column 
  812.              */
  813.             tunnel = tunnels;
  814.             name[tunnel_len + 2]++;
  815.             if (name[tunnel_len + 2] > 6) {
  816.                 /*
  817.                  * there is no next column 
  818.                  */
  819.                 return NULL;
  820.             }
  821.             if (!tunnel) {
  822.                 /*
  823.                  * there is no (next) row 
  824.                  */
  825.                 return NULL;
  826.             }
  827.         }
  828.     }
  830.     if (!tunnel) {
  831.         return NULL;
  832.     }
  834.     name[*length - 1] = tunnel->ifindex;
  836.     DEBUGMSGTL(("tunnel", "var_tunnelIfEntry: using"));
  837.     DEBUGMSGOID(("tunnel", name, *length));
  838.     DEBUGMSG(("tunnel", "n"));
  840.     switch (name[tunnel_len + 2]) {
  841.     case 1:                    /* tunnelIfLocalAddress */
  842.         ret_addr = tunnel->local;
  843.         *var_len = 4;
  844.         vp->type = ASN_IPADDRESS;
  845.         *write_method = writeLocalAddress;
  846.         return (u_char *) & ret_addr;
  847.     case 2:                    /* tunnelIfRemoteAddress */
  848.         ret_addr = tunnel->remote;
  849.         *var_len = 4;
  850.         vp->type = ASN_IPADDRESS;
  851.         *write_method = writeRemoteAddress;
  852.         return (u_char *) & ret_addr;
  853.     case 3:                    /* tunnelIfEncapsMethod */
  854.         ret_int = tunnel->encaps;
  855.         *var_len = sizeof(ret_int);
  856.         vp->type = ASN_INTEGER;
  857.         return (u_char *) & ret_int;
  858.     case 4:                    /* tunnelIfHopLimit */
  859.         ret_int = tunnel->hoplimit;
  860.         *var_len = sizeof(ret_int);
  861.         vp->type = ASN_INTEGER;
  862.         *write_method = writeHopLimit;
  863.         return (u_char *) & ret_int;
  864.     case 5:                    /* tunnelIfSecurity */
  865.         ret_int = tunnel->security;
  866.         *var_len = sizeof(ret_int);
  867.         vp->type = ASN_INTEGER;
  868.         return (u_char *) & ret_int;
  869.     case 6:                    /* tunnelIfTOS */
  870.         ret_int = tunnel->tos;
  871.         *var_len = sizeof(ret_int);
  872.         vp->type = ASN_INTEGER;
  873.         *write_method = writeTOS;
  874.         return (u_char *) & ret_int;
  875.     default:
  876.         return 0;
  877.     }
  879.     return NULL;
  880. }
  884. unsigned char  *
  885. var_tunnelConfigEntry(struct variable *vp,
  886.                       oid * name, size_t * length,
  887.                       int exact, size_t * var_len,
  888.                       WriteMethod ** write_method)
  889. {
  890.     static long     ret_int;
  891.     struct tunnel  *tunnel;
  892.     int             i;
  894.     DEBUGMSGTL(("tunnel", "var_tunnelConfigEntry: "));
  895.     DEBUGMSGOID(("tunnel", name, *length));
  896.     DEBUGMSG(("tunnel", " %dn", exact));
  898.     updateTunnels();
  900.     if (exact) {
  901.         if (*length != tunnel_len + 3 + 4 + 4 + 1 + 1) {
  902.             return NULL;
  903.         }
  904.         tunnel = getTunnelByConfigOid(name, length);
  905.     } else {
  906.         if (snmp_oid_compare(name, *length,
  907.                              tunnel_configEntry_oid,
  908.                              tunnel_configEntry_len) < 0) {
  909.             *length = 0;
  910.         }
  911.         if ((*length) < tunnel_len) {
  912.             memcpy((char *) name, (char *) tunnel_variables_oid,
  913.                    tunnel_len * sizeof(oid));
  914.         }
  915.         if ((*length) < tunnel_len + 1) {
  916.             name[tunnel_len] = 2;
  917.         }
  918.         if ((*length) < tunnel_len + 2) {
  919.             name[tunnel_len + 1] = 1;
  920.         }
  921.         if ((*length) < tunnel_len + 3) {
  922.             name[tunnel_len + 2] = 5;
  923.         }
  924.         for (i = MAX(*length, tunnel_len + 3);
  925.              i < tunnel_len + 3 + 4 + 4 + 1 + 1; i++) {
  926.             name[i] = 0;
  927.         }
  928.         *length = tunnel_len + 3 + 4 + 4 + 1 + 1;
  929.         tunnel = getNextTunnelByConfigOid(name, length);
  930.         if (!tunnel) {
  931.             /*
  932.              * end of column, continue with first row of next column 
  933.              */
  934.             tunnel = tunnels;
  935.             name[tunnel_len + 2]++;
  936.             if (name[tunnel_len + 2] > 6) {
  937.                 /*
  938.                  * there is no next column 
  939.                  */
  940.                 return NULL;
  941.             }
  942.             if (!tunnel) {
  943.                 /*
  944.                  * there is no (next) row 
  945.                  */
  946.                 return NULL;
  947.             }
  948.         }
  949.     }
  951.     if (!tunnel) {
  952.         return NULL;
  953.     }
  955.     fillConfigOid(&name[tunnel_len + 3], tunnel);
  957.     DEBUGMSGTL(("tunnel", "var_tunnelConfigEntry: using "));
  958.     DEBUGMSGOID(("tunnel", name, *length));
  959.     DEBUGMSG(("tunnel", "n"));
  961.     switch (name[tunnel_len + 2]) {
  962.     case 5:                    /* tunnelConfigIfIndex */
  963.         ret_int = tunnel->ifindex;
  964.         *var_len = sizeof(ret_int);
  965.         vp->type = ASN_INTEGER;
  966.         return (u_char *) & ret_int;
  967.     case 6:                    /* tunnelConfigStatus */
  968.         ret_int = 1;            /* active */
  969.         *var_len = sizeof(ret_int);
  970.         vp->type = ASN_INTEGER;
  971.         return (u_char *) & ret_int;
  972.     default:
  973.         return 0;
  974.     }
  976.     return NULL;
  977. }