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

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

SNMP编程

开发平台：

Unix_Linux

netSnmpHostsTable.c：源码内容
  1. /*
  2.  * Note: this file originally auto-generated by mib2c using
  3.  *        : mib2c.iterate_access.conf,v 1.4 2003/07/01 00:15:11 hardaker Exp $
  4.  */
  6. #include <net-snmp/net-snmp-config.h>
  7. #include <net-snmp/net-snmp-includes.h>
  8. #include <net-snmp/agent/net-snmp-agent-includes.h>
  9. #include "netSnmpHostsTable.h"
  10. #include "netSnmpHostsTable_checkfns.h"
  11. #include "netSnmpHostsTable_access.h"
  13. static netsnmp_oid_stash_node *undoStorage = NULL;
  14. static netsnmp_oid_stash_node *commitStorage = NULL;
  16. struct undoInfo {
  17.     void           *ptr;
  18.     size_t          len;
  19. };
  21. struct commitInfo {
  22.     void           *data_context;
  23.     int             have_committed;
  24.     int             new_row;
  25. };
  27. void
  28. netSnmpHostsTable_free_undoInfo(void *vptr)
  29. {
  30.     struct undoInfo *ui = vptr;
  31.     if (!ui)
  32.         return;
  33.     SNMP_FREE(ui->ptr);
  34.     SNMP_FREE(ui);
  35. }
  37. /** Initialize the netSnmpHostsTable table by defining its contents and how it's structured */
  38. void
  39. initialize_table_netSnmpHostsTable(void)
  40. {
  41.     static oid      netSnmpHostsTable_oid[] =
  42.         { 1, 3, 6, 1, 4, 1, 8072, 2, 2, 2 };
  43.     netsnmp_table_registration_info *table_info;
  44.     netsnmp_handler_registration *my_handler;
  45.     netsnmp_iterator_info *iinfo;
  47.     /** create the table registration information structures */
  48.     table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
  49.     iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info);
  51.     /** if your table is read only, it's easiest to change the
  52.         HANDLER_CAN_RWRITE definition below to HANDLER_CAN_RONLY */
  53.     my_handler = netsnmp_create_handler_registration("netSnmpHostsTable",
  54.                                                      netSnmpHostsTable_handler,
  55.                                                      netSnmpHostsTable_oid,
  56.                                                      OID_LENGTH
  57.                                                      (netSnmpHostsTable_oid),
  58.                                                      HANDLER_CAN_RWRITE);
  60.     if (!my_handler || !table_info || !iinfo) {
  61.         snmp_log(LOG_ERR,
  62.                  "malloc failed in initialize_table_netSnmpHostsTable");
  63.         return; /** Serious error. */
  64.     }
  66.     /***************************************************
  67.      * Setting up the table's definition
  68.      */
  69.     netsnmp_table_helper_add_indexes(table_info, ASN_OCTET_STR,
  70.                                                  /** index: netSnmpHostName */
  71.                                      0);
  73.     /** Define the minimum and maximum accessible columns.  This
  74.         optimizes retrival. */
  75.     table_info->min_column = 2;
  76.     table_info->max_column = 5;
  78.     /** iterator access routines */
  79.     iinfo->get_first_data_point = netSnmpHostsTable_get_first_data_point;
  80.     iinfo->get_next_data_point = netSnmpHostsTable_get_next_data_point;
  82.     /** you may wish to set these as well */
  83.     iinfo->make_data_context = netSnmpHostsTable_context_convert_function;
  84.     iinfo->free_data_context = netSnmpHostsTable_data_free;
  85.     iinfo->free_loop_context_at_end = netSnmpHostsTable_loop_free;
  87.     /** tie the two structures together */
  88.     iinfo->table_reginfo = table_info;
  90.     /***************************************************
  91.      * registering the table with the master agent
  92.      */
  93.     DEBUGMSGTL(("initialize_table_netSnmpHostsTable",
  94.                 "Registering table netSnmpHostsTable as a table iteratorn"));
  95.     netsnmp_register_table_iterator(my_handler, iinfo);
  96. }
  98. /** Initializes the netSnmpHostsTable module */
  99. void
  100. init_netSnmpHostsTable(void)
  101. {
  103.   /** here we initialize all the tables we're planning on supporting */
  104.     initialize_table_netSnmpHostsTable();
  105. }
  107. /** handles requests for the netSnmpHostsTable table, if anything else needs to be done */
  108. int
  109. netSnmpHostsTable_handler(netsnmp_mib_handler *handler,
  110.                           netsnmp_handler_registration *reginfo,
  111.                           netsnmp_agent_request_info *reqinfo,
  112.                           netsnmp_request_info *requests)
  113. {
  115.     netsnmp_request_info *request;
  116.     netsnmp_table_request_info *table_info;
  117.     netsnmp_variable_list *var;
  118.     struct commitInfo *ci = NULL;
  120.     void           *data_context = NULL;
  122.     oid            *suffix;
  123.     size_t          suffix_len;
  125.     for (request = requests; request; request = request->next) {
  126.         /* column and row index encoded portion */
  127.         var = request->requestvb;
  128.         suffix     = var->name + reginfo->rootoid_len + 1;
  129.         suffix_len = var->name_length - (reginfo->rootoid_len + 1);
  131.         if (request->processed != 0)
  132.             continue;
  134.         switch (reqinfo->mode) {
  135.         case MODE_GET:
  136.         case MODE_SET_RESERVE1:
  137.             data_context = netsnmp_extract_iterator_context(request);
  138.             if (data_context == NULL) {
  139.                 if (reqinfo->mode == MODE_GET) {
  140.                     netsnmp_set_request_error(reqinfo, request,
  141.                                               SNMP_NOSUCHINSTANCE);
  142.                     continue;
  143.                 }
  144.             }
  145.             break;
  147.         default:               /* == the other SET modes */
  148.             ci = netsnmp_oid_stash_get_data(commitStorage,
  149.                                             suffix + 1, suffix_len - 1);
  150.             break;
  152.         }
  154.         /** extracts the information about the table from the request */
  155.         table_info = netsnmp_extract_table_info(request);
  156.         /** table_info->colnum contains the column number requested */
  157.         /** table_info->indexes contains a linked list of snmp variable
  158.            bindings for the indexes of the table.  Values in the list
  159.            have been set corresponding to the indexes of the
  160.            request */
  161.         if (table_info == NULL) {
  162.             continue;
  163.         }
  165.         switch (reqinfo->mode) {
  166.         case MODE_GET:
  167.             switch (table_info->colnum) {
  168.             case COLUMN_NETSNMPHOSTADDRESSTYPE:
  169.                 {
  170.                     long           *retval;
  171.                     size_t          retval_len = 0;
  172.                     retval =
  173.                         get_netSnmpHostAddressType(data_context,
  174.                                                    &retval_len);
  175.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  176.                                              (const u_char *) retval,
  177.                                              retval_len);
  178.                 }
  179.                 break;
  181.             case COLUMN_NETSNMPHOSTADDRESS:
  182.                 {
  183.                     char           *retval;
  184.                     size_t          retval_len = 0;
  185.                     retval =
  186.                         get_netSnmpHostAddress(data_context, &retval_len);
  187.                     snmp_set_var_typed_value(var, ASN_OCTET_STR,
  188.                                              (const u_char *) retval,
  189.                                              retval_len);
  190.                 }
  191.                 break;
  193.             case COLUMN_NETSNMPHOSTSTORAGE:
  194.                 {
  195.                     long           *retval;
  196.                     size_t          retval_len = 0;
  197.                     retval =
  198.                         get_netSnmpHostStorage(data_context, &retval_len);
  199.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  200.                                              (const u_char *) retval,
  201.                                              retval_len);
  202.                 }
  203.                 break;
  205.             case COLUMN_NETSNMPHOSTROWSTATUS:
  206.                 {
  207.                     long           *retval;
  208.                     size_t          retval_len = 0;
  209.                     retval =
  210.                         get_netSnmpHostRowStatus(data_context,
  211.                                                  &retval_len);
  212.                     snmp_set_var_typed_value(var, ASN_INTEGER,
  213.                                              (const u_char *) retval,
  214.                                              retval_len);
  215.                 }
  216.                 break;
  218.             default:
  219.                 /** We shouldn't get here */
  220.                 snmp_log(LOG_ERR,
  221.                          "problem encountered in netSnmpHostsTable_handler: unknown columnn");
  222.             }
  223.             break;
  225.         case MODE_SET_RESERVE1:
  226.             ci = netsnmp_oid_stash_get_data(commitStorage,
  227.                                             suffix + 1, suffix_len - 1);
  229.             if (!ci) {
  230.                     /** create the commit storage info */
  231.                 ci = SNMP_MALLOC_STRUCT(commitInfo);
  232.                 if (!data_context) {
  233.                     ci->data_context =
  234.                         netSnmpHostsTable_create_data_context(table_info->
  235.                                                               indexes);
  236.                     ci->new_row = 1;
  237.                 } else {
  238.                     ci->data_context = data_context;
  239.                 }
  240.                 netsnmp_oid_stash_add_data(&commitStorage,
  241.                                            suffix + 1, suffix_len - 1, ci);
  242.             }
  243.             break;
  245.         case MODE_SET_RESERVE2:
  246.             switch (table_info->colnum) {
  247.             case COLUMN_NETSNMPHOSTADDRESSTYPE:
  248.                 {
  249.                     long           *retval;
  250.                     size_t          retval_len = 0;
  251.                     struct undoInfo *ui = NULL;
  252.                     int             ret;
  254.                     /** first, get the old value */
  255.                     retval =
  256.                         get_netSnmpHostAddressType(ci->data_context,
  257.                                                    &retval_len);
  258.                     if (retval) {
  259.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  260.                         ui->len = retval_len;
  261.                         memdup((u_char **) & ui->ptr,
  262.                                (u_char *) retval, ui->len);
  263.                     }
  265.                     /** check the new value, possibly against the
  266.                         older value for a valid state transition */
  267.                     ret =
  268.                         check_netSnmpHostAddressType(request->requestvb->
  269.                                                      type,
  270.                                                      (long *) request->
  271.                                                      requestvb->val.string,
  272.                                                      request->requestvb->
  273.                                                      val_len, retval,
  274.                                                      retval_len);
  275.                     if (ret != 0) {
  276.                         netsnmp_set_request_error(reqinfo, request, ret);
  277.                         netSnmpHostsTable_free_undoInfo(ui);
  278.                     } else if (ui) {
  279.                         /** remember information for undo purposes later */
  280.                         netsnmp_oid_stash_add_data(&undoStorage,
  281.                                                    suffix, suffix_len, ui);
  282.                     }
  284.                 }
  285.                 break;
  286.             case COLUMN_NETSNMPHOSTADDRESS:
  287.                 {
  288.                     char           *retval;
  289.                     size_t          retval_len = 0;
  290.                     struct undoInfo *ui = NULL;
  291.                     int             ret;
  293.                     /** first, get the old value */
  294.                     retval =
  295.                         get_netSnmpHostAddress(ci->data_context,
  296.                                                &retval_len);
  297.                     if (retval) {
  298.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  299.                         ui->len = retval_len;
  300.                         memdup((u_char **) & ui->ptr,
  301.                                (u_char *) retval, ui->len);
  302.                     }
  304.                     /** check the new value, possibly against the
  305.                         older value for a valid state transition */
  306.                     ret =
  307.                         check_netSnmpHostAddress(request->requestvb->type,
  308.                                                  (char *) request->
  309.                                                  requestvb->val.string,
  310.                                                  request->requestvb->
  311.                                                  val_len, retval,
  312.                                                  retval_len);
  313.                     if (ret != 0) {
  314.                         netsnmp_set_request_error(reqinfo, request, ret);
  315.                         netSnmpHostsTable_free_undoInfo(ui);
  316.                     } else if (ui) {
  317.                         /** remember information for undo purposes later */
  318.                         netsnmp_oid_stash_add_data(&undoStorage,
  319.                                                    suffix, suffix_len, ui);
  320.                     }
  322.                 }
  323.                 break;
  324.             case COLUMN_NETSNMPHOSTSTORAGE:
  325.                 {
  326.                     long           *retval;
  327.                     size_t          retval_len = 0;
  328.                     struct undoInfo *ui = NULL;
  329.                     int             ret;
  331.                     /** first, get the old value */
  332.                     retval =
  333.                         get_netSnmpHostStorage(ci->data_context,
  334.                                                &retval_len);
  335.                     if (retval) {
  336.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  337.                         ui->len = retval_len;
  338.                         memdup((u_char **) & ui->ptr,
  339.                                (u_char *) retval, ui->len);
  340.                     }
  342.                     /** check the new value, possibly against the
  343.                         older value for a valid state transition */
  344.                     ret =
  345.                         check_netSnmpHostStorage(request->requestvb->type,
  346.                                                  (long *) request->
  347.                                                  requestvb->val.string,
  348.                                                  request->requestvb->
  349.                                                  val_len, retval,
  350.                                                  retval_len);
  351.                     if (ret != 0) {
  352.                         netsnmp_set_request_error(reqinfo, request, ret);
  353.                         netSnmpHostsTable_free_undoInfo(ui);
  354.                     } else if (ui) {
  355.                         /** remember information for undo purposes later */
  356.                         netsnmp_oid_stash_add_data(&undoStorage,
  357.                                                    suffix, suffix_len, ui);
  358.                     }
  360.                 }
  361.                 break;
  362.             case COLUMN_NETSNMPHOSTROWSTATUS:
  363.                 {
  364.                     long           *retval;
  365.                     size_t          retval_len = 0;
  366.                     struct undoInfo *ui = NULL;
  367.                     int             ret;
  369.                     /** first, get the old value */
  370.                     retval =
  371.                         get_netSnmpHostRowStatus(ci->data_context,
  372.                                                  &retval_len);
  373.                     if (retval) {
  374.                         ui = SNMP_MALLOC_STRUCT(undoInfo);
  375.                         ui->len = retval_len;
  376.                         memdup((u_char **) & ui->ptr,
  377.                                (u_char *) retval, ui->len);
  378.                     }
  380.                     /** check the new value, possibly against the
  381.                         older value for a valid state transition */
  382.                     ret =
  383.                         check_netSnmpHostRowStatus(request->requestvb->
  384.                                                    type,
  385.                                                    (long *) request->
  386.                                                    requestvb->val.string,
  387.                                                    request->requestvb->
  388.                                                    val_len, retval,
  389.                                                    retval_len);
  390.                     if (ret != 0) {
  391.                         netsnmp_set_request_error(reqinfo, request, ret);
  392.                         netSnmpHostsTable_free_undoInfo(ui);
  393.                     } else if (ui) {
  394.                         /** remember information for undo purposes later */
  395.                         netsnmp_oid_stash_add_data(&undoStorage,
  396.                                                    suffix, suffix_len, ui);
  397.                     }
  399.                 }
  400.                 break;
  401.             default:
  402.                 netsnmp_set_request_error(reqinfo, request,
  403.                                           SNMP_ERR_NOTWRITABLE);
  404.                 break;
  405.             }
  406.             break;
  408.         case MODE_SET_ACTION:
  409.             /** save a variable copy */
  410.             switch (table_info->colnum) {
  411.             case COLUMN_NETSNMPHOSTADDRESSTYPE:
  412.                 {
  413.                     int             ret;
  414.                     ret = set_netSnmpHostAddressType(ci->data_context,
  415.                                                      (long *) request->
  416.                                                      requestvb->val.string,
  417.                                                      request->requestvb->
  418.                                                      val_len);
  419.                     if (ret) {
  420.                         netsnmp_set_request_error(reqinfo, request, ret);
  421.                     }
  422.                 }
  423.                 break;
  424.             case COLUMN_NETSNMPHOSTADDRESS:
  425.                 {
  426.                     int             ret;
  427.                     ret = set_netSnmpHostAddress(ci->data_context,
  428.                                                  (char *) request->
  429.                                                  requestvb->val.string,
  430.                                                  request->requestvb->
  431.                                                  val_len);
  432.                     if (ret) {
  433.                         netsnmp_set_request_error(reqinfo, request, ret);
  434.                     }
  435.                 }
  436.                 break;
  437.             case COLUMN_NETSNMPHOSTSTORAGE:
  438.                 {
  439.                     int             ret;
  440.                     ret = set_netSnmpHostStorage(ci->data_context,
  441.                                                  (long *) request->
  442.                                                  requestvb->val.string,
  443.                                                  request->requestvb->
  444.                                                  val_len);
  445.                     if (ret) {
  446.                         netsnmp_set_request_error(reqinfo, request, ret);
  447.                     }
  448.                 }
  449.                 break;
  450.             case COLUMN_NETSNMPHOSTROWSTATUS:
  451.                 {
  452.                     int             ret;
  453.                     ret = set_netSnmpHostRowStatus(ci->data_context,
  454.                                                    (long *) request->
  455.                                                    requestvb->val.string,
  456.                                                    request->requestvb->
  457.                                                    val_len);
  458.                     if (ret) {
  459.                         netsnmp_set_request_error(reqinfo, request, ret);
  460.                     }
  461.                     if (*request->requestvb->val.integer == RS_DESTROY) {
  462.                         ci->new_row = -1;
  463.                     }
  464.                 }
  465.                 break;
  466.             }
  467.             break;
  469.         case MODE_SET_COMMIT:
  470.             if (!ci->have_committed) {
  471.                     /** do this once per row only */
  472.                 netSnmpHostsTable_commit_row(&ci->data_context,
  473.                                              ci->new_row);
  474.                 ci->have_committed = 1;
  475.             }
  476.             break;
  478.         case MODE_SET_UNDO:
  479.              /** save a variable copy */
  480.             switch (table_info->colnum) {
  481.             case COLUMN_NETSNMPHOSTADDRESSTYPE:
  482.                 {
  483.                     int             retval;
  484.                     struct undoInfo *ui;
  485.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  486.                                                     suffix, suffix_len);
  487.                     retval =
  488.                         set_netSnmpHostAddressType(ci->data_context,
  489.                                                    ui->ptr, ui->len);
  490.                     if (retval) {
  491.                         netsnmp_set_request_error(reqinfo, request,
  492.                                                   SNMP_ERR_UNDOFAILED);
  493.                     }
  494.                 }
  495.                 break;
  496.             case COLUMN_NETSNMPHOSTADDRESS:
  497.                 {
  498.                     int             retval;
  499.                     struct undoInfo *ui;
  500.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  501.                                                     suffix, suffix_len);
  502.                     retval =
  503.                         set_netSnmpHostAddress(ci->data_context, ui->ptr,
  504.                                                ui->len);
  505.                     if (retval) {
  506.                         netsnmp_set_request_error(reqinfo, request,
  507.                                                   SNMP_ERR_UNDOFAILED);
  508.                     }
  509.                 }
  510.                 break;
  511.             case COLUMN_NETSNMPHOSTSTORAGE:
  512.                 {
  513.                     int             retval;
  514.                     struct undoInfo *ui;
  515.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  516.                                                     suffix, suffix_len);
  517.                     retval =
  518.                         set_netSnmpHostStorage(ci->data_context, ui->ptr,
  519.                                                ui->len);
  520.                     if (retval) {
  521.                         netsnmp_set_request_error(reqinfo, request,
  522.                                                   SNMP_ERR_UNDOFAILED);
  523.                     }
  524.                 }
  525.                 break;
  526.             case COLUMN_NETSNMPHOSTROWSTATUS:
  527.                 {
  528.                     int             retval;
  529.                     struct undoInfo *ui;
  530.                     ui = netsnmp_oid_stash_get_data(undoStorage,
  531.                                                     suffix, suffix_len);
  532.                     retval =
  533.                         set_netSnmpHostRowStatus(ci->data_context, ui->ptr,
  534.                                                  ui->len);
  535.                     if (retval) {
  536.                         netsnmp_set_request_error(reqinfo, request,
  537.                                                   SNMP_ERR_UNDOFAILED);
  538.                     }
  539.                 }
  540.                 break;
  541.             }
  542.             break;
  544.         case MODE_SET_FREE:
  545.             break;
  547.         default:
  548.             snmp_log(LOG_ERR,
  549.                      "problem encountered in netSnmpHostsTable_handler: unsupported moden");
  550.         }
  551.     }
  553.     /** clean up after all requset processing has ended */
  554.     switch (reqinfo->mode) {
  555.     case MODE_SET_UNDO:
  556.     case MODE_SET_FREE:
  557.     case MODE_SET_COMMIT:
  558.         /** clear out the undo cache */
  559.         netsnmp_oid_stash_free(&undoStorage,
  560.                                netSnmpHostsTable_free_undoInfo);
  561.         netsnmp_oid_stash_free(&commitStorage, netsnmp_oid_stash_no_free);
  562.     }
  565.     return SNMP_ERR_NOERROR;
  566. }