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

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

SNMP编程

开发平台：

Unix_Linux

ipCidrRouteTable.c：源码内容
  1. /*
  2.  * Note: this file originally auto-generated by mib2c using
  3.  *        : mib2c.iterate_access.conf$
  4.  */
  6. #include <net-snmp/net-snmp-config.h>
  7. #include "route_headers.h"
  8. #include <net-snmp/net-snmp-includes.h>
  9. #include <net-snmp/agent/net-snmp-agent-includes.h>
  10. #include "ipCidrRouteTable.h"
  11. #include "ipCidrRouteTable_checkfns.h"
  12. #include "ipCidrRouteTable_access.h"
  14. #include "var_route.h"
  16. static netsnmp_oid_stash_node *undoStorage;
  18. struct undoInfo {
  19.     void           *ptr;
  20.     size_t          len;
  21. };
  23. void
  24. free_undoInfo(void *vp)
  25. {
  26.     struct undoInfo *ui = (struct undoInfo *) vp;
  27.     if (!ui)
  28.         return;
  29.     SNMP_FREE(ui->ptr);
  30.     SNMP_FREE(ui);
  31. }
  33. /** Initialize the ipCidrRouteTable table by defining its contents and how it's structured */
  34. void
  35. initialize_table_ipCidrRouteTable(void)
  36. {
  37.     static oid      ipCidrRouteTable_oid[] =
  38.         { 1, 3, 6, 1, 2, 1, 4, 24, 4 };
  39.     netsnmp_table_registration_info *table_info;
  40.     netsnmp_handler_registration *my_handler;
  41.     netsnmp_iterator_info *iinfo;
  43.     /** create the table registration information structures */
  44.     table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
  45.     iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info);
  47.     /** if your table is read only, it's easiest to change the
  48.         HANDLER_CAN_RWRITE definition below to HANDLER_CAN_RONLY */
  49.     my_handler = netsnmp_create_handler_registration("ipCidrRouteTable",
  50.                                                      ipCidrRouteTable_handler,
  51.                                                      ipCidrRouteTable_oid,
  52.                                                      OID_LENGTH
  53.                                                      (ipCidrRouteTable_oid),
  54.                                                      HANDLER_CAN_RWRITE);
  56.     if (!my_handler || !table_info || !iinfo) {
  57.         snmp_log(LOG_ERR,
  58.                  "malloc failed in initialize_table_ipCidrRouteTable");
  59.         return; /** Serious error. */
  60.     }
  62.     /***************************************************
  63.      * Setting up the table's definition
  64.      */
  65.     netsnmp_table_helper_add_indexes(table_info, ASN_IPADDRESS,
  66.                                                  /** index: ipCidrRouteDest */
  67.                                      ASN_IPADDRESS,
  68.                                                  /** index: ipCidrRouteMask */
  69.                                      ASN_INTEGER,
  70.                                                /** index: ipCidrRouteTos */
  71.                                      ASN_IPADDRESS,
  72.                                                  /** index: ipCidrRouteNextHop */
  73.                                      0);
  75.     /** Define the minimum and maximum accessible columns.  This
  76.         optimizes retrival. */
  77.     table_info->min_column = 1;
  78.     table_info->max_column = 16;
  80.     /** iterator access routines */
  81.     iinfo->get_first_data_point = ipCidrRouteTable_get_first_data_point;
  82.     iinfo->get_next_data_point = ipCidrRouteTable_get_next_data_point;
  84.     /** you may wish to set these as well */
  85. #ifdef MAYBE_USE_THESE
  86.     iinfo->make_data_context = ipCidrRouteTable_context_convert_function;
  87.     iinfo->free_data_context = ipCidrRouteTable_data_free;
  89.     /** pick *only* one of these if you use them */
  90.     iinfo->free_loop_context = ipCidrRouteTable_loop_free;
  91.     iinfo->free_loop_context_at_end = ipCidrRouteTable_loop_free;
  92. #endif
  94.     /** tie the two structures together */
  95.     iinfo->table_reginfo = table_info;
  97.     /***************************************************
  98.      * registering the table with the master agent
  99.      */
  100.     DEBUGMSGTL(("initialize_table_ipCidrRouteTable",
  101.                 "Registering table ipCidrRouteTable as a table iteratorn"));
  102.     netsnmp_register_table_iterator(my_handler, iinfo);
  103. }
  105. /** Initializes the ipCidrRouteTable module */
  106. void
  107. init_ipCidrRouteTable(void)
  108. {
  110.   /** here we initialize all the tables we're planning on supporting */
  111.     initialize_table_ipCidrRouteTable();
  112. }
  115. /* globals */
  116. static size_t rtsize;
  117. static RTENTRY **rthead;
  119. netsnmp_variable_list *
  120. ipCidrRouteTable_set_indexes(RTENTRY *ourroute,
  121.                              netsnmp_variable_list *put_index_data) {
  122.     netsnmp_variable_list *vptr;
  124.     /** ipCidrRouteDest */
  125.     vptr = put_index_data;
  126.     snmp_set_var_value(vptr, (u_char *) &((struct sockaddr_in *) (&ourroute->rt_dst))->sin_addr.s_addr,
  127.                        sizeof(((struct sockaddr_in *) (&ourroute->rt_dst))->sin_addr));
  129.     /** ipCidrRouteMask */
  130.     vptr = vptr->next_variable;
  131.     snmp_set_var_value(vptr, (u_char *) &((struct sockaddr_in *) (&ourroute->rt_genmask))->sin_addr.s_addr,
  132.                        sizeof(((struct sockaddr_in *) (&ourroute->rt_genmask))->sin_addr));
  134.     /** ipCidrRouteTos */
  135.     vptr = vptr->next_variable;
  136.     snmp_set_var_value(vptr, (u_char *) &ourroute->rt_tos,
  137.                        sizeof(ourroute->rt_tos));
  138.     vptr = vptr->next_variable;
  140.     /** ipCidrRouteNextHop */
  141.     snmp_set_var_value(vptr,
  142.                        (u_char *) &((struct sockaddr_in *) (&ourroute->rt_gateway))->sin_addr.s_addr,
  143.                        sizeof(((struct sockaddr_in *) (&ourroute->rt_gateway))->sin_addr));
  145.     return put_index_data;
  146. }
  148. /** returns the first data point within the ipCidrRouteTable table data.
  150.     Set the my_loop_context variable to the first data point structure
  151.     of your choice (from which you can find the next one).  This could
  152.     be anything from the first node in a linked list, to an integer
  153.     pointer containing the beginning of an array variable.
  155.     Set the my_data_context variable to something to be returned to
  156.     you later that will provide you with the data to return in a given
  157.     row.  This could be the same pointer as what my_loop_context is
  158.     set to, or something different.
  160.     The put_index_data variable contains a list of snmp variable
  161.     bindings, one for each index in your table.  Set the values of
  162.     each appropriately according to the data matching the first row
  163.     and return the put_index_data variable at the end of the function.
  164. */
  165. netsnmp_variable_list *
  166. ipCidrRouteTable_get_first_data_point(void **my_loop_context,
  167.                                       void **my_data_context,
  168.                                       netsnmp_variable_list *
  169.                                       put_index_data,
  170.                                       netsnmp_iterator_info *mydata)
  171. {
  172.     int *position;
  174.     /* we could do this with a file-static variable, but for learning
  175.        purposes we'll use memory allocation to demonstrate simplistic
  176.        freeing of a loop_context */
  177.     position = malloc(sizeof(position));
  178.     if (!position)
  179.         return NULL;
  181.     /* read the routing table into the route array. This function is
  182.        defined in var_route.c, but is sorted incorrectly for this
  183.        table. By using a table_iterator we don't do any sorting
  184.        ourselves and the table_iterator handles it all for us, so we
  185.        don't resort with different criteria. */
  186.     rthead = netsnmp_get_routes(&rtsize);
  188.     if (!rthead) {
  189.         snmp_log(LOG_ERR,"ipCidrRouteTable: failed to get routesn");
  190.         free(position);
  191.         return NULL;
  192.     }
  194.     /* We use the positinonal count as our loop context */
  195.     *position = 0;
  196.     *my_loop_context = position;
  198.     /* our data context is the individual array element, in this case
  199.        it's the first. */
  200.     *my_data_context = rthead[*position];
  202.     /* now, save the index data into the passed in (linked list) pointer */
  203.     return ipCidrRouteTable_set_indexes(rthead[*position], put_index_data);
  204. }
  206. /** functionally the same as ipCidrRouteTable_get_first_data_point, but
  207.    my_loop_context has already been set to a previous value and should
  208.    be updated to the next in the list.  For example, if it was a
  209.    linked list, you might want to cast it and the return
  210.    my_loop_context->next.  The my_data_context pointer should be set
  211.    to something you need later and the indexes in put_index_data
  212.    updated again. */
  214. netsnmp_variable_list *
  215. ipCidrRouteTable_get_next_data_point(void **my_loop_context,
  216.                                      void **my_data_context,
  217.                                      netsnmp_variable_list *
  218.                                      put_index_data,
  219.                                      netsnmp_iterator_info *mydata)
  220. {
  222.     int *position = (int *) *my_loop_context;
  224.     /* make sure we were called correctly */
  225.     if (!position)
  226.         return NULL;
  227.     
  228.     /* go to the next route in the list */
  229.     (*position)++;
  231.     /* Are we beyond the end? */
  232.     if (*position >= rtsize) {
  233.         /* End of routes.  stop here by returning NULL */
  234.         SNMP_FREE(position);
  235.         *my_loop_context = NULL;
  236.         *my_data_context = NULL;
  237.         return NULL;
  238.     }
  240.     /* our data context is the individual array element, in this case
  241.        it's the first. */
  242.     *my_data_context = rthead[*position];
  244.     /* now, save the index data into the passed in (linked list) pointer */
  245.     return ipCidrRouteTable_set_indexes(rthead[*position], put_index_data);
  246. }
  248. /** handles requests for the ipCidrRouteTable table, if anything else
  249.    needs to be done */
  250. int
  251. ipCidrRouteTable_handler(netsnmp_mib_handler *handler,
  252.                          netsnmp_handler_registration *reginfo,
  253.                          netsnmp_agent_request_info *reqinfo,
  254.                          netsnmp_request_info *requests)
  255. {
  257.     netsnmp_request_info *request;
  258.     netsnmp_table_request_info *table_info;
  259.     netsnmp_variable_list *var;
  261.     void           *data_context;
  263.     oid            *suffix;
  264.     size_t          suffix_len;
  266.     /** column and row index encoded portion */
  267.     suffix = requests->requestvb->name + reginfo->rootoid_len + 1;
  268.     suffix_len = requests->requestvb->name_length -
  269.         (reginfo->rootoid_len + 1);
  271.     for (request = requests; request; request = request->next) {
  272.         var = request->requestvb;
  273.         if (request->processed != 0)
  274.             continue;
  276.         data_context = netsnmp_extract_iterator_context(request);
  277.         if (data_context == NULL) {
  278.             if (reqinfo->mode == MODE_GET) {
  279.                 netsnmp_set_request_error(reqinfo, request,
  280.                                           SNMP_NOSUCHINSTANCE);
  281.                 continue;
  282.             }
  283.             /** XXX: no row existed, if you support creation and this is a
  284.                set, start dealing with it here, else continue */
  285.         }
  287.         /** extracts the information about the table from the request */
  288.         table_info = netsnmp_extract_table_info(request);
  289.         /** table_info->colnum contains the column number requested */
  290.         /** table_info->indexes contains a linked list of snmp variable
  291.            bindings for the indexes of the table.  Values in the list
  292.            have been set corresponding to the indexes of the
  293.            request */
  294.         if (table_info == NULL) {
  295.             continue;
  296.         }
  298.         switch (reqinfo->mode) {
  299.         case MODE_GET:
  300.             switch (table_info->colnum) {
  301.             case COLUMN_IPCIDRROUTEDEST:
  302.                 {
  303.                     u_long         *retval;
  304.                     size_t          retval_len = 0;
  305.                     retval =
  306.                         get_ipCidrRouteDest(data_context, &retval_len);
  307.                     snmp_set_var_typed_value(var, ASN_IPADDRESS,
  308.                                              (const u_char *) retval,
  309.                                              retval_len);
  310.                 }
  311.                 break;
  313.             case COLUMN_IPCIDRROUTEMASK:
  314.                 {
  315.                     u_long         *retval;
  316.                     size_t          retval_len = 0;
  317.                     retval =
  318.                         get_ipCidrRouteMask(data_context, &retval_len);
  319.                     snmp_set_var_typed_value(var, ASN_IPADDRESS,
  320.                                              (const u_char *) retval,
  321.                                              retval_len);
  322.                 }
  323.                 break;
  325.             case COLUMN_IPCIDRROUTETOS:
  326.                 {
  327.                     long           *retval;
  328.                     size_t          retval_len = 0;
  329.                     retval = get_ipCidrRouteTos(data_context, &retval_len);
  330.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  331.                                              (const u_char *) retval,
  332.                                              retval_len);
  333.                 }
  334.                 break;
  336.             case COLUMN_IPCIDRROUTENEXTHOP:
  337.                 {
  338.                     u_long         *retval;
  339.                     size_t          retval_len = 0;
  340.                     retval =
  341.                         get_ipCidrRouteNextHop(data_context, &retval_len);
  342.                     snmp_set_var_typed_value(var, ASN_IPADDRESS,
  343.                                              (const u_char *) retval,
  344.                                              retval_len);
  345.                 }
  346.                 break;
  348.             case COLUMN_IPCIDRROUTEIFINDEX:
  349.                 {
  350.                     long           *retval;
  351.                     size_t          retval_len = 0;
  352.                     retval =
  353.                         get_ipCidrRouteIfIndex(data_context, &retval_len);
  354.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  355.                                              (const u_char *) retval,
  356.                                              retval_len);
  357.                 }
  358.                 break;
  360.             case COLUMN_IPCIDRROUTETYPE:
  361.                 {
  362.                     long           *retval;
  363.                     size_t          retval_len = 0;
  364.                     retval =
  365.                         get_ipCidrRouteType(data_context, &retval_len);
  366.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  367.                                              (const u_char *) retval,
  368.                                              retval_len);
  369.                 }
  370.                 break;
  372.             case COLUMN_IPCIDRROUTEPROTO:
  373.                 {
  374.                     long           *retval;
  375.                     size_t          retval_len = 0;
  376.                     retval =
  377.                         get_ipCidrRouteProto(data_context, &retval_len);
  378.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  379.                                              (const u_char *) retval,
  380.                                              retval_len);
  381.                 }
  382.                 break;
  384.             case COLUMN_IPCIDRROUTEAGE:
  385.                 {
  386.                     long           *retval;
  387.                     size_t          retval_len = 0;
  388.                     retval = get_ipCidrRouteAge(data_context, &retval_len);
  389.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  390.                                              (const u_char *) retval,
  391.                                              retval_len);
  392.                 }
  393.                 break;
  395.             case COLUMN_IPCIDRROUTEINFO:
  396.                 {
  397.                     oid            *retval;
  398.                     size_t          retval_len = 0;
  399.                     retval =
  400.                         get_ipCidrRouteInfo(data_context, &retval_len);
  401.                     snmp_set_var_typed_value(var, ASN_OBJECT_ID,
  402.                                              (const u_char *) retval,
  403.                                              retval_len);
  404.                 }
  405.                 break;
  407.             case COLUMN_IPCIDRROUTENEXTHOPAS:
  408.                 {
  409.                     long           *retval;
  410.                     size_t          retval_len = 0;
  411.                     retval =
  412.                         get_ipCidrRouteNextHopAS(data_context,
  413.                                                  &retval_len);
  414.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  415.                                              (const u_char *) retval,
  416.                                              retval_len);
  417.                 }
  418.                 break;
  420.             case COLUMN_IPCIDRROUTEMETRIC1:
  421.                 {
  422.                     long           *retval;
  423.                     size_t          retval_len = 0;
  424.                     retval =
  425.                         get_ipCidrRouteMetric1(data_context, &retval_len);
  426.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  427.                                              (const u_char *) retval,
  428.                                              retval_len);
  429.                 }
  430.                 break;
  432.             case COLUMN_IPCIDRROUTEMETRIC2:
  433.                 {
  434.                     long           *retval;
  435.                     size_t          retval_len = 0;
  436.                     retval =
  437.                         get_ipCidrRouteMetric2(data_context, &retval_len);
  438.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  439.                                              (const u_char *) retval,
  440.                                              retval_len);
  441.                 }
  442.                 break;
  444.             case COLUMN_IPCIDRROUTEMETRIC3:
  445.                 {
  446.                     long           *retval;
  447.                     size_t          retval_len = 0;
  448.                     retval =
  449.                         get_ipCidrRouteMetric3(data_context, &retval_len);
  450.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  451.                                              (const u_char *) retval,
  452.                                              retval_len);
  453.                 }
  454.                 break;
  456.             case COLUMN_IPCIDRROUTEMETRIC4:
  457.                 {
  458.                     long           *retval;
  459.                     size_t          retval_len = 0;
  460.                     retval =
  461.                         get_ipCidrRouteMetric4(data_context, &retval_len);
  462.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  463.                                              (const u_char *) retval,
  464.                                              retval_len);
  465.                 }
  466.                 break;
  468.             case COLUMN_IPCIDRROUTEMETRIC5:
  469.                 {
  470.                     long           *retval;
  471.                     size_t          retval_len = 0;
  472.                     retval =
  473.                         get_ipCidrRouteMetric5(data_context, &retval_len);
  474.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  475.                                              (const u_char *) retval,
  476.                                              retval_len);
  477.                 }
  478.                 break;
  480.             case COLUMN_IPCIDRROUTESTATUS:
  481.                 {
  482.                     long           *retval;
  483.                     size_t          retval_len = 0;
  484.                     retval =
  485.                         get_ipCidrRouteStatus(data_context, &retval_len);
  486.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  487.                                              (const u_char *) retval,
  488.                                              retval_len);
  489.                 }
  490.                 break;
  492.             default:
  493.                         /** We shouldn't get here */
  494.                 snmp_log(LOG_ERR,
  495.                          "problem encountered in ipCidrRouteTable_handler: unknown columnn");
  496.             }
  497.             break;
  499.         case MODE_SET_RESERVE1:
  500.                 /** mib2cXXX: clear out old undo info if we have any.  Remove if
  501.                    table_iterator becomes un-serialized */
  502.             netsnmp_oid_stash_free(&undoStorage, free_undoInfo);
  504.             switch (table_info->colnum) {
  505.             case COLUMN_IPCIDRROUTEIFINDEX:
  506.                 {
  507.                     int             ret =
  508.                         check_ipCidrRouteIfIndex(request->requestvb->type,
  509.                                                  (long *) request->
  510.                                                  requestvb->val.string,
  511.                                                  request->requestvb->
  512.                                                  val_len);
  513.                     if (ret != 0) {
  514.                         netsnmp_set_request_error(reqinfo, requests, ret);
  515.                     }
  516.                 }
  517.                 break;
  518.             case COLUMN_IPCIDRROUTETYPE:
  519.                 {
  520.                     int             ret =
  521.                         check_ipCidrRouteType(request->requestvb->type,
  522.                                               (long *) request->requestvb->
  523.                                               val.string,
  524.                                               request->requestvb->val_len);
  525.                     if (ret != 0) {
  526.                         netsnmp_set_request_error(reqinfo, requests, ret);
  527.                     }
  528.                 }
  529.                 break;
  530.             case COLUMN_IPCIDRROUTEINFO:
  531.                 {
  532.                     int             ret =
  533.                         check_ipCidrRouteInfo(request->requestvb->type,
  534.                                               (oid *) request->requestvb->
  535.                                               val.string,
  536.                                               request->requestvb->val_len);
  537.                     if (ret != 0) {
  538.                         netsnmp_set_request_error(reqinfo, requests, ret);
  539.                     }
  540.                 }
  541.                 break;
  542.             case COLUMN_IPCIDRROUTENEXTHOPAS:
  543.                 {
  544.                     int             ret =
  545.                         check_ipCidrRouteNextHopAS(request->requestvb->
  546.                                                    type,
  547.                                                    (long *) request->
  548.                                                    requestvb->val.string,
  549.                                                    request->requestvb->
  550.                                                    val_len);
  551.                     if (ret != 0) {
  552.                         netsnmp_set_request_error(reqinfo, requests, ret);
  553.                     }
  554.                 }
  555.                 break;
  556.             case COLUMN_IPCIDRROUTEMETRIC1:
  557.                 {
  558.                     int             ret =
  559.                         check_ipCidrRouteMetric1(request->requestvb->type,
  560.                                                  (long *) request->
  561.                                                  requestvb->val.string,
  562.                                                  request->requestvb->
  563.                                                  val_len);
  564.                     if (ret != 0) {
  565.                         netsnmp_set_request_error(reqinfo, requests, ret);
  566.                     }
  567.                 }
  568.                 break;
  569.             case COLUMN_IPCIDRROUTEMETRIC2:
  570.                 {
  571.                     int             ret =
  572.                         check_ipCidrRouteMetric2(request->requestvb->type,
  573.                                                  (long *) request->
  574.                                                  requestvb->val.string,
  575.                                                  request->requestvb->
  576.                                                  val_len);
  577.                     if (ret != 0) {
  578.                         netsnmp_set_request_error(reqinfo, requests, ret);
  579.                     }
  580.                 }
  581.                 break;
  582.             case COLUMN_IPCIDRROUTEMETRIC3:
  583.                 {
  584.                     int             ret =
  585.                         check_ipCidrRouteMetric3(request->requestvb->type,
  586.                                                  (long *) request->
  587.                                                  requestvb->val.string,
  588.                                                  request->requestvb->
  589.                                                  val_len);
  590.                     if (ret != 0) {
  591.                         netsnmp_set_request_error(reqinfo, requests, ret);
  592.                     }
  593.                 }
  594.                 break;
  595.             case COLUMN_IPCIDRROUTEMETRIC4:
  596.                 {
  597.                     int             ret =
  598.                         check_ipCidrRouteMetric4(request->requestvb->type,
  599.                                                  (long *) request->
  600.                                                  requestvb->val.string,
  601.                                                  request->requestvb->
  602.                                                  val_len);
  603.                     if (ret != 0) {
  604.                         netsnmp_set_request_error(reqinfo, requests, ret);
  605.                     }
  606.                 }
  607.                 break;
  608.             case COLUMN_IPCIDRROUTEMETRIC5:
  609.                 {
  610.                     int             ret =
  611.                         check_ipCidrRouteMetric5(request->requestvb->type,
  612.                                                  (long *) request->
  613.                                                  requestvb->val.string,
  614.                                                  request->requestvb->
  615.                                                  val_len);
  616.                     if (ret != 0) {
  617.                         netsnmp_set_request_error(reqinfo, requests, ret);
  618.                     }
  619.                 }
  620.                 break;
  621.             case COLUMN_IPCIDRROUTESTATUS:
  622.                 {
  623.                     int             ret =
  624.                         check_ipCidrRouteStatus(request->requestvb->type,
  625.                                                 (long *) request->
  626.                                                 requestvb->val.string,
  627.                                                 request->requestvb->
  628.                                                 val_len);
  629.                     if (ret != 0) {
  630.                         netsnmp_set_request_error(reqinfo, requests, ret);
  631.                     }
  632.                 }
  633.                 break;
  634.             default:
  635.                 netsnmp_set_request_error(reqinfo, requests,
  636.                                           SNMP_ERR_NOTWRITABLE);
  637.                 break;
  638.             }
  639.             break;
  641.         case MODE_SET_RESERVE2:
  642.                 /** save a variable copy */
  643.             switch (table_info->colnum) {
  644.             case COLUMN_IPCIDRROUTEIFINDEX:
  645.                 {
  646.                     long           *retval;
  647.                     size_t          retval_len = 0;
  648.                     struct undoInfo *ui;
  649.                     retval =
  650.                         get_ipCidrRouteIfIndex(data_context, &retval_len);
  651.                     if (retval) {
  652.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  653.                         ui->len = retval_len;
  654.                         memdup((u_char **) & ui->ptr,
  655.                                (u_char *) retval, ui->len);
  656.                         netsnmp_oid_stash_add_data(&undoStorage,
  657.                                                    suffix, suffix_len, ui);
  658.                     }
  659.                 }
  660.                 break;
  661.             case COLUMN_IPCIDRROUTETYPE:
  662.                 {
  663.                     long           *retval;
  664.                     size_t          retval_len = 0;
  665.                     struct undoInfo *ui;
  666.                     retval =
  667.                         get_ipCidrRouteType(data_context, &retval_len);
  668.                     if (retval) {
  669.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  670.                         ui->len = retval_len;
  671.                         memdup((u_char **) & ui->ptr,
  672.                                (u_char *) retval, ui->len);
  673.                         netsnmp_oid_stash_add_data(&undoStorage,
  674.                                                    suffix, suffix_len, ui);
  675.                     }
  676.                 }
  677.                 break;
  678.             case COLUMN_IPCIDRROUTEINFO:
  679.                 {
  680.                     oid            *retval;
  681.                     size_t          retval_len = 0;
  682.                     struct undoInfo *ui;
  683.                     retval =
  684.                         get_ipCidrRouteInfo(data_context, &retval_len);
  685.                     if (retval) {
  686.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  687.                         ui->len = retval_len;
  688.                         memdup((u_char **) & ui->ptr,
  689.                                (u_char *) retval, ui->len);
  690.                         netsnmp_oid_stash_add_data(&undoStorage,
  691.                                                    suffix, suffix_len, ui);
  692.                     }
  693.                 }
  694.                 break;
  695.             case COLUMN_IPCIDRROUTENEXTHOPAS:
  696.                 {
  697.                     long           *retval;
  698.                     size_t          retval_len = 0;
  699.                     struct undoInfo *ui;
  700.                     retval =
  701.                         get_ipCidrRouteNextHopAS(data_context,
  702.                                                  &retval_len);
  703.                     if (retval) {
  704.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  705.                         ui->len = retval_len;
  706.                         memdup((u_char **) & ui->ptr,
  707.                                (u_char *) retval, ui->len);
  708.                         netsnmp_oid_stash_add_data(&undoStorage,
  709.                                                    suffix, suffix_len, ui);
  710.                     }
  711.                 }
  712.                 break;
  713.             case COLUMN_IPCIDRROUTEMETRIC1:
  714.                 {
  715.                     long           *retval;
  716.                     size_t          retval_len = 0;
  717.                     struct undoInfo *ui;
  718.                     retval =
  719.                         get_ipCidrRouteMetric1(data_context, &retval_len);
  720.                     if (retval) {
  721.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  722.                         ui->len = retval_len;
  723.                         memdup((u_char **) & ui->ptr,
  724.                                (u_char *) retval, ui->len);
  725.                         netsnmp_oid_stash_add_data(&undoStorage,
  726.                                                    suffix, suffix_len, ui);
  727.                     }
  728.                 }
  729.                 break;
  730.             case COLUMN_IPCIDRROUTEMETRIC2:
  731.                 {
  732.                     long           *retval;
  733.                     size_t          retval_len = 0;
  734.                     struct undoInfo *ui;
  735.                     retval =
  736.                         get_ipCidrRouteMetric2(data_context, &retval_len);
  737.                     if (retval) {
  738.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  739.                         ui->len = retval_len;
  740.                         memdup((u_char **) & ui->ptr,
  741.                                (u_char *) retval, ui->len);
  742.                         netsnmp_oid_stash_add_data(&undoStorage,
  743.                                                    suffix, suffix_len, ui);
  744.                     }
  745.                 }
  746.                 break;
  747.             case COLUMN_IPCIDRROUTEMETRIC3:
  748.                 {
  749.                     long           *retval;
  750.                     size_t          retval_len = 0;
  751.                     struct undoInfo *ui;
  752.                     retval =
  753.                         get_ipCidrRouteMetric3(data_context, &retval_len);
  754.                     if (retval) {
  755.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  756.                         ui->len = retval_len;
  757.                         memdup((u_char **) & ui->ptr,
  758.                                (u_char *) retval, ui->len);
  759.                         netsnmp_oid_stash_add_data(&undoStorage,
  760.                                                    suffix, suffix_len, ui);
  761.                     }
  762.                 }
  763.                 break;
  764.             case COLUMN_IPCIDRROUTEMETRIC4:
  765.                 {
  766.                     long           *retval;
  767.                     size_t          retval_len = 0;
  768.                     struct undoInfo *ui;
  769.                     retval =
  770.                         get_ipCidrRouteMetric4(data_context, &retval_len);
  771.                     if (retval) {
  772.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  773.                         ui->len = retval_len;
  774.                         memdup((u_char **) & ui->ptr,
  775.                                (u_char *) retval, ui->len);
  776.                         netsnmp_oid_stash_add_data(&undoStorage,
  777.                                                    suffix, suffix_len, ui);
  778.                     }
  779.                 }
  780.                 break;
  781.             case COLUMN_IPCIDRROUTEMETRIC5:
  782.                 {
  783.                     long           *retval;
  784.                     size_t          retval_len = 0;
  785.                     struct undoInfo *ui;
  786.                     retval =
  787.                         get_ipCidrRouteMetric5(data_context, &retval_len);
  788.                     if (retval) {
  789.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  790.                         ui->len = retval_len;
  791.                         memdup((u_char **) & ui->ptr,
  792.                                (u_char *) retval, ui->len);
  793.                         netsnmp_oid_stash_add_data(&undoStorage,
  794.                                                    suffix, suffix_len, ui);
  795.                     }
  796.                 }
  797.                 break;
  798.             case COLUMN_IPCIDRROUTESTATUS:
  799.                 {
  800.                     long           *retval;
  801.                     size_t          retval_len = 0;
  802.                     struct undoInfo *ui;
  803.                     retval =
  804.                         get_ipCidrRouteStatus(data_context, &retval_len);
  805.                     if (retval) {
  806.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  807.                         ui->len = retval_len;
  808.                         memdup((u_char **) & ui->ptr,
  809.                                (u_char *) retval, ui->len);
  810.                         netsnmp_oid_stash_add_data(&undoStorage,
  811.                                                    suffix, suffix_len, ui);
  812.                     }
  813.                 }
  814.                 break;
  815.             }
  816.             break;
  818.         case MODE_SET_FREE:
  819.                 /** Forget undo data, if exists */
  820.             netsnmp_oid_stash_free(&undoStorage, free_undoInfo);
  821.             break;
  823.         case MODE_SET_ACTION:
  824.                 /** save a variable copy */
  825.             switch (table_info->colnum) {
  826.             case COLUMN_IPCIDRROUTEIFINDEX:
  827.                 {
  828.                     int             ret =
  829.                         set_ipCidrRouteIfIndex(data_context,
  830.                                                (long *) request->
  831.                                                requestvb->val.string,
  832.                                                request->requestvb->
  833.                                                val_len);
  834.                     if (ret) {
  835.                         netsnmp_set_request_error(reqinfo, requests, ret);
  836.                     }
  837.                 }
  838.                 break;
  839.             case COLUMN_IPCIDRROUTETYPE:
  840.                 {
  841.                     int             ret = set_ipCidrRouteType(data_context,
  842.                                                               (long *)
  843.                                                               request->
  844.                                                               requestvb->
  845.                                                               val.string,
  846.                                                               request->
  847.                                                               requestvb->
  848.                                                               val_len);
  849.                     if (ret) {
  850.                         netsnmp_set_request_error(reqinfo, requests, ret);
  851.                     }
  852.                 }
  853.                 break;
  854.             case COLUMN_IPCIDRROUTEINFO:
  855.                 {
  856.                     int             ret = set_ipCidrRouteInfo(data_context,
  857.                                                               (oid *)
  858.                                                               request->
  859.                                                               requestvb->
  860.                                                               val.string,
  861.                                                               request->
  862.                                                               requestvb->
  863.                                                               val_len);
  864.                     if (ret) {
  865.                         netsnmp_set_request_error(reqinfo, requests, ret);
  866.                     }
  867.                 }
  868.                 break;
  869.             case COLUMN_IPCIDRROUTENEXTHOPAS:
  870.                 {
  871.                     int             ret =
  872.                         set_ipCidrRouteNextHopAS(data_context,
  873.                                                  (long *) request->
  874.                                                  requestvb->val.string,
  875.                                                  request->requestvb->
  876.                                                  val_len);
  877.                     if (ret) {
  878.                         netsnmp_set_request_error(reqinfo, requests, ret);
  879.                     }
  880.                 }
  881.                 break;
  882.             case COLUMN_IPCIDRROUTEMETRIC1:
  883.                 {
  884.                     int             ret =
  885.                         set_ipCidrRouteMetric1(data_context,
  886.                                                (long *) request->
  887.                                                requestvb->val.string,
  888.                                                request->requestvb->
  889.                                                val_len);
  890.                     if (ret) {
  891.                         netsnmp_set_request_error(reqinfo, requests, ret);
  892.                     }
  893.                 }
  894.                 break;
  895.             case COLUMN_IPCIDRROUTEMETRIC2:
  896.                 {
  897.                     int             ret =
  898.                         set_ipCidrRouteMetric2(data_context,
  899.                                                (long *) request->
  900.                                                requestvb->val.string,
  901.                                                request->requestvb->
  902.                                                val_len);
  903.                     if (ret) {
  904.                         netsnmp_set_request_error(reqinfo, requests, ret);
  905.                     }
  906.                 }
  907.                 break;
  908.             case COLUMN_IPCIDRROUTEMETRIC3:
  909.                 {
  910.                     int             ret =
  911.                         set_ipCidrRouteMetric3(data_context,
  912.                                                (long *) request->
  913.                                                requestvb->val.string,
  914.                                                request->requestvb->
  915.                                                val_len);
  916.                     if (ret) {
  917.                         netsnmp_set_request_error(reqinfo, requests, ret);
  918.                     }
  919.                 }
  920.                 break;
  921.             case COLUMN_IPCIDRROUTEMETRIC4:
  922.                 {
  923.                     int             ret =
  924.                         set_ipCidrRouteMetric4(data_context,
  925.                                                (long *) request->
  926.                                                requestvb->val.string,
  927.                                                request->requestvb->
  928.                                                val_len);
  929.                     if (ret) {
  930.                         netsnmp_set_request_error(reqinfo, requests, ret);
  931.                     }
  932.                 }
  933.                 break;
  934.             case COLUMN_IPCIDRROUTEMETRIC5:
  935.                 {
  936.                     int             ret =
  937.                         set_ipCidrRouteMetric5(data_context,
  938.                                                (long *) request->
  939.                                                requestvb->val.string,
  940.                                                request->requestvb->
  941.                                                val_len);
  942.                     if (ret) {
  943.                         netsnmp_set_request_error(reqinfo, requests, ret);
  944.                     }
  945.                 }
  946.                 break;
  947.             case COLUMN_IPCIDRROUTESTATUS:
  948.                 {
  949.                     int             ret =
  950.                         set_ipCidrRouteStatus(data_context,
  951.                                               (long *) request->requestvb->
  952.                                               val.string,
  953.                                               request->requestvb->val_len);
  954.                     if (ret) {
  955.                         netsnmp_set_request_error(reqinfo, requests, ret);
  956.                     }
  957.                 }
  958.                 break;
  959.             }
  960.             break;
  962.         case MODE_SET_COMMIT:
  963.                 /** answers were all good.  Forget undo data */
  964.             netsnmp_oid_stash_free(&undoStorage, free_undoInfo);
  965.                 /** mib2cXXX: call commit hook */
  966.             break;
  968.         case MODE_SET_UNDO:
  969.                 /** save a variable copy */
  970.             switch (table_info->colnum) {
  971.             case COLUMN_IPCIDRROUTEIFINDEX:
  972.                 {
  973.                     int             retval;
  974.                     struct undoInfo *ui;
  975.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  976.                                                     suffix, suffix_len);
  977.                     retval =
  978.                         set_ipCidrRouteIfIndex(data_context, ui->ptr,
  979.                                                ui->len);
  980.                     if (retval) {
  981.                         netsnmp_set_request_error(reqinfo, requests,
  982.                                                   SNMP_ERR_UNDOFAILED);
  983.                     }
  984.                 }
  985.                 break;
  986.             case COLUMN_IPCIDRROUTETYPE:
  987.                 {
  988.                     int             retval;
  989.                     struct undoInfo *ui;
  990.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  991.                                                     suffix, suffix_len);
  992.                     retval =
  993.                         set_ipCidrRouteType(data_context, ui->ptr,
  994.                                             ui->len);
  995.                     if (retval) {
  996.                         netsnmp_set_request_error(reqinfo, requests,
  997.                                                   SNMP_ERR_UNDOFAILED);
  998.                     }
  999.                 }
  1000.                 break;
  1001.             case COLUMN_IPCIDRROUTEINFO:
  1002.                 {
  1003.                     int             retval;
  1004.                     struct undoInfo *ui;
  1005.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  1006.                                                     suffix, suffix_len);
  1007.                     retval =
  1008.                         set_ipCidrRouteInfo(data_context, ui->ptr,
  1009.                                             ui->len);
  1010.                     if (retval) {
  1011.                         netsnmp_set_request_error(reqinfo, requests,
  1012.                                                   SNMP_ERR_UNDOFAILED);
  1013.                     }
  1014.                 }
  1015.                 break;
  1016.             case COLUMN_IPCIDRROUTENEXTHOPAS:
  1017.                 {
  1018.                     int             retval;
  1019.                     struct undoInfo *ui;
  1020.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  1021.                                                     suffix, suffix_len);
  1022.                     retval =
  1023.                         set_ipCidrRouteNextHopAS(data_context, ui->ptr,
  1024.                                                  ui->len);
  1025.                     if (retval) {
  1026.                         netsnmp_set_request_error(reqinfo, requests,
  1027.                                                   SNMP_ERR_UNDOFAILED);
  1028.                     }
  1029.                 }
  1030.                 break;
  1031.             case COLUMN_IPCIDRROUTEMETRIC1:
  1032.                 {
  1033.                     int             retval;
  1034.                     struct undoInfo *ui;
  1035.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  1036.                                                     suffix, suffix_len);
  1037.                     retval =
  1038.                         set_ipCidrRouteMetric1(data_context, ui->ptr,
  1039.                                                ui->len);
  1040.                     if (retval) {
  1041.                         netsnmp_set_request_error(reqinfo, requests,
  1042.                                                   SNMP_ERR_UNDOFAILED);
  1043.                     }
  1044.                 }
  1045.                 break;
  1046.             case COLUMN_IPCIDRROUTEMETRIC2:
  1047.                 {
  1048.                     int             retval;
  1049.                     struct undoInfo *ui;
  1050.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  1051.                                                     suffix, suffix_len);
  1052.                     retval =
  1053.                         set_ipCidrRouteMetric2(data_context, ui->ptr,
  1054.                                                ui->len);
  1055.                     if (retval) {
  1056.                         netsnmp_set_request_error(reqinfo, requests,
  1057.                                                   SNMP_ERR_UNDOFAILED);
  1058.                     }
  1059.                 }
  1060.                 break;
  1061.             case COLUMN_IPCIDRROUTEMETRIC3:
  1062.                 {
  1063.                     int             retval;
  1064.                     struct undoInfo *ui;
  1065.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  1066.                                                     suffix, suffix_len);
  1067.                     retval =
  1068.                         set_ipCidrRouteMetric3(data_context, ui->ptr,
  1069.                                                ui->len);
  1070.                     if (retval) {
  1071.                         netsnmp_set_request_error(reqinfo, requests,
  1072.                                                   SNMP_ERR_UNDOFAILED);
  1073.                     }
  1074.                 }
  1075.                 break;
  1076.             case COLUMN_IPCIDRROUTEMETRIC4:
  1077.                 {
  1078.                     int             retval;
  1079.                     struct undoInfo *ui;
  1080.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  1081.                                                     suffix, suffix_len);
  1082.                     retval =
  1083.                         set_ipCidrRouteMetric4(data_context, ui->ptr,
  1084.                                                ui->len);
  1085.                     if (retval) {
  1086.                         netsnmp_set_request_error(reqinfo, requests,
  1087.                                                   SNMP_ERR_UNDOFAILED);
  1088.                     }
  1089.                 }
  1090.                 break;
  1091.             case COLUMN_IPCIDRROUTEMETRIC5:
  1092.                 {
  1093.                     int             retval;
  1094.                     struct undoInfo *ui;
  1095.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  1096.                                                     suffix, suffix_len);
  1097.                     retval =
  1098.                         set_ipCidrRouteMetric5(data_context, ui->ptr,
  1099.                                                ui->len);
  1100.                     if (retval) {
  1101.                         netsnmp_set_request_error(reqinfo, requests,
  1102.                                                   SNMP_ERR_UNDOFAILED);
  1103.                     }
  1104.                 }
  1105.                 break;
  1106.             case COLUMN_IPCIDRROUTESTATUS:
  1107.                 {
  1108.                     int             retval;
  1109.                     struct undoInfo *ui;
  1110.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  1111.                                                     suffix, suffix_len);
  1112.                     retval =
  1113.                         set_ipCidrRouteStatus(data_context, ui->ptr,
  1114.                                               ui->len);
  1115.                     if (retval) {
  1116.                         netsnmp_set_request_error(reqinfo, requests,
  1117.                                                   SNMP_ERR_UNDOFAILED);
  1118.                     }
  1119.                 }
  1120.                 break;
  1121.             }
  1122.                 /** mib2cXXX: remove cache!  hard to do when serialized, however */
  1123.             break;
  1125.         default:
  1126.             snmp_log(LOG_ERR,
  1127.                      "problem encountered in ipCidrRouteTable_handler: unsupported moden");
  1128.         }
  1129.     }
  1130.     return SNMP_ERR_NOERROR;
  1131. }