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

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

SNMP编程

开发平台：

Unix_Linux

pingResultsTable.c：源码内容
  1. /*
  2.  *Copyright(c)2004,Cisco URP imburses and Network Information Center in Beijing University of Posts and Telecommunications researches.
  3.  *
  4.  *All right reserved
  5.  *
  6.  *File Name:pingResultsTable.c
  7.  *File Description:Rows of lookupResultsTable MIB add and delete.
  8.  *
  9.  *Current Version:1.0
  10.  *Author:ChenJing
  11.  *Date:2004.8.20
  12.  */
  15. /*
  16.  * This should always be included first before anything else 
  17.  */
  19. #if HAVE_STDLIB_H
  20. #include <stdlib.h>
  21. #endif
  22. #if HAVE_STRING_H
  23. #include <string.h>
  24. #else
  25. #include <strings.h>
  26. #endif
  27. #ifdef HAVE_LIMITS_H
  28. #include <limits.h>
  29. #endif
  34. #include <net-snmp/net-snmp-config.h>
  35. #include <net-snmp/net-snmp-includes.h>
  36. #include <net-snmp/agent/net-snmp-agent-includes.h>
  38. #include "pingCtlTable.h"
  39. #include "pingResultsTable.h"
  40. #include "pingProbeHistoryTable.h"
  41. #include "header_complex.h"
  44. /*
  45.  *pingResultsTable_variables_oid:
  46.  *
  47.  */
  48. oid             pingResultsTable_variables_oid[] =
  49.     { 1, 3, 6, 1, 2, 1, 80, 1, 3 };
  51. struct variable2 pingResultsTable_variables[] = {
  52.     {COLUMN_PINGRESULTSOPERSTATUS,       ASN_INTEGER, RONLY, var_pingResultsTable, 2, {1, 1}},
  53.     {COLUMN_PINGRESULTSIPTARGETADDRESSTYPE, ASN_INTEGER, RONLY, var_pingResultsTable, 2, {1, 2}},
  54.     {COLUMN_PINGRESULTSIPTARGETADDRESS, ASN_OCTET_STR, RONLY, var_pingResultsTable, 2, {1, 3}},
  55.     {COLUMN_PINGRESULTSMINRTT,          ASN_UNSIGNED, RONLY, var_pingResultsTable, 2, {1, 4}},
  56.     {COLUMN_PINGRESULTSMAXRTT,          ASN_UNSIGNED, RONLY, var_pingResultsTable, 2, {1, 5}},
  57.     {COLUMN_PINGRESULTSAVERAGERTT,      ASN_UNSIGNED, RONLY, var_pingResultsTable, 2, {1, 6}},
  58.     {COLUMN_PINGRESULTSPROBERESPONSES,  ASN_UNSIGNED, RONLY, var_pingResultsTable, 2, {1, 7}},
  59.     {COLUMN_PINGRESULTSSENTPROBES,      ASN_UNSIGNED, RONLY, var_pingResultsTable, 2, {1, 8}},
  60.     {COLUMN_PINGRESULTSRTTSUMOFSQUARES, ASN_UNSIGNED, RONLY, var_pingResultsTable, 2, {1, 9}},
  61.     {COLUMN_PINGRESULTSLASTGOODPROBE,  ASN_OCTET_STR, RONLY, var_pingResultsTable, 2, {1, 10}}
  62. };
  67. /*
  68.  * global storage of our data, saved in and configured by header_complex() 
  69.  */
  71. extern struct header_complex_index *pingCtlTableStorage;
  72. extern struct header_complex_index *pingResultsTableStorage;
  74. void
  75. pingResultsTable_cleaner(struct header_complex_index *thestuff)
  76. {
  77.     struct header_complex_index *hciptr = NULL;
  78.     struct pingResultsTable_data *StorageDel = NULL;
  79.     DEBUGMSGTL(("pingResultsTable", "cleanerout  "));
  80.     for (hciptr = thestuff; hciptr != NULL; hciptr = hciptr->next) {
  81.         StorageDel =
  82.             header_complex_extract_entry(&pingResultsTableStorage, hciptr);
  83.         DEBUGMSGTL(("pingResultsTable", "cleaner  "));
  84.     }
  86. }
  87. void
  88. init_pingResultsTable(void)
  89. {
  91.     DEBUGMSGTL(("pingResultsTable", "initializing...  "));
  94.     /*
  95.      * register ourselves with the agent to handle our mib tree 
  96.      */
  97.     REGISTER_MIB("pingResultsTable", pingResultsTable_variables, variable2,
  98.                  pingResultsTable_variables_oid);
  101.     /*
  102.      * register our config handler(s) to deal with registrations 
  103.      */
  104.     snmpd_register_config_handler("pingResultsTable",
  105.                                   parse_pingResultsTable, NULL, NULL);
  107.     /*
  108.      * we need to be called back later to store our data 
  109.      */
  110.     snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
  111.                            store_pingResultsTable, NULL);
  113.     DEBUGMSGTL(("pingResultsTable", "done.n"));
  114. }
  116. /*
  117.  * parse_mteObjectsTable():
  118.  *   parses .conf file entries needed to configure the mib.
  119.  */
  121. void
  122. parse_pingResultsTable(const char *token, char *line)
  123. {
  124.     size_t          tmpint;
  125.     struct pingResultsTable_data *StorageTmp =
  126.         SNMP_MALLOC_STRUCT(pingResultsTable_data);
  128.     DEBUGMSGTL(("pingResultsTable", "parsing config...  "));
  131.     if (StorageTmp == NULL) {
  132.         config_perror("malloc failure");
  133.         return;
  134.     }
  136.     line =
  137.         read_config_read_data(ASN_OCTET_STR, line,
  138.                               &StorageTmp->pingCtlOwnerIndex,
  139.                               &StorageTmp->pingCtlOwnerIndexLen);
  140.     if (StorageTmp->pingCtlOwnerIndex == NULL) {
  141.         config_perror("invalid specification for pingCtlOwnerIndex");
  142.         return;
  143.     }
  145.     line =
  146.         read_config_read_data(ASN_OCTET_STR, line,
  147.                               &StorageTmp->pingCtlTestName,
  148.                               &StorageTmp->pingCtlTestNameLen);
  149.     if (StorageTmp->pingCtlTestName == NULL) {
  150.         config_perror("invalid specification for pingCtlTestName");
  151.         return;
  152.     }
  154.     line =
  155.         read_config_read_data(ASN_INTEGER, line,
  156.                               &StorageTmp->pingResultsOperStatus, &tmpint);
  157.     line =
  158.         read_config_read_data(ASN_INTEGER, line,
  159.                               &StorageTmp->pingResultsIpTargetAddressType,
  160.                               &tmpint);
  161.     line =
  162.         read_config_read_data(ASN_OCTET_STR, line,
  163.                               &StorageTmp->pingResultsIpTargetAddress,
  164.                               &StorageTmp->pingResultsIpTargetAddressLen);
  165.     if (StorageTmp->pingResultsIpTargetAddress == NULL) {
  166.         config_perror
  167.             ("invalid specification for pingResultsIpTargetAddress");
  168.         return;
  169.     }
  171.     line =
  172.         read_config_read_data(ASN_UNSIGNED, line,
  173.                               &StorageTmp->pingResultsMinRtt, &tmpint);
  174.     line =
  175.         read_config_read_data(ASN_UNSIGNED, line,
  176.                               &StorageTmp->pingResultsMaxRtt, &tmpint);
  177.     line =
  178.         read_config_read_data(ASN_UNSIGNED, line,
  179.                               &StorageTmp->pingResultsAverageRtt, &tmpint);
  180.     line =
  181.         read_config_read_data(ASN_UNSIGNED, line,
  182.                               &StorageTmp->pingResultsProbeResponses,
  183.                               &tmpint);
  184.     line =
  185.         read_config_read_data(ASN_UNSIGNED, line,
  186.                               &StorageTmp->pingResultsSendProbes, &tmpint);
  187.     line =
  188.         read_config_read_data(ASN_UNSIGNED, line,
  189.                               &StorageTmp->pingResultsRttSumOfSquares,
  190.                               &tmpint);
  191.     line =
  192.         read_config_read_data(ASN_OCTET_STR, line,
  193.                               &StorageTmp->pingResultsLastGoodProbe,
  194.                               &StorageTmp->pingResultsLastGoodProbeLen);
  195.     if (StorageTmp->pingResultsLastGoodProbe == NULL) {
  196.         config_perror
  197.             ("invalid specification for pingResultsLastGoodProbe!");
  198.         return;
  199.     }
  201.     pingResultsTable_inadd(StorageTmp);
  203.     /* pingResultsTable_cleaner(pingResultsTableStorage); */
  205.     DEBUGMSGTL(("pingResultsTable", "done.n"));
  206. }
  212. /*
  213.  * store_pingResultsTable():
  214.  *   stores .conf file entries needed to configure the mib.
  215.  */
  217. int
  218. store_pingResultsTable(int majorID, int minorID, void *serverarg,
  219.                        void *clientarg)
  220. {
  221.     char            line[SNMP_MAXBUF];
  222.     char           *cptr;
  223.     size_t          tmpint;
  224.     struct pingResultsTable_data *StorageTmp;
  225.     struct header_complex_index *hcindex;
  228.     DEBUGMSGTL(("pingResultsTable", "storing data...  "));
  231.     for (hcindex = pingResultsTableStorage; hcindex != NULL;
  232.          hcindex = hcindex->next) {
  233.         StorageTmp = (struct pingResultsTable_data *) hcindex->data;
  235.         if (StorageTmp->storageType != ST_READONLY) {
  236.             memset(line, 0, sizeof(line));
  237.             strcat(line, "pingResultsTable ");
  238.             cptr = line + strlen(line);
  241.             cptr =
  242.                 read_config_store_data(ASN_OCTET_STR, cptr,
  243.                                        &StorageTmp->pingCtlOwnerIndex,
  244.                                        &StorageTmp->pingCtlOwnerIndexLen);
  246.             cptr =
  247.                 read_config_store_data(ASN_OCTET_STR, cptr,
  248.                                        &StorageTmp->pingCtlTestName,
  249.                                        &StorageTmp->pingCtlTestNameLen);
  250.             cptr =
  251.                 read_config_store_data(ASN_INTEGER, cptr,
  252.                                        &StorageTmp->pingResultsOperStatus,
  253.                                        &tmpint);
  254.             cptr =
  255.                 read_config_store_data(ASN_INTEGER, cptr,
  256.                                        &StorageTmp->
  257.                                        pingResultsIpTargetAddressType,
  258.                                        &tmpint);
  259.             cptr =
  260.                 read_config_store_data(ASN_OCTET_STR, cptr,
  261.                                        &StorageTmp->
  262.                                        pingResultsIpTargetAddress,
  263.                                        &StorageTmp->
  264.                                        pingResultsIpTargetAddressLen);
  266.             cptr =
  267.                 read_config_store_data(ASN_UNSIGNED, cptr,
  268.                                        &StorageTmp->pingResultsMinRtt,
  269.                                        &tmpint);
  270.             cptr =
  271.                 read_config_store_data(ASN_UNSIGNED, cptr,
  272.                                        &StorageTmp->pingResultsMaxRtt,
  273.                                        &tmpint);
  274.             cptr =
  275.                 read_config_store_data(ASN_UNSIGNED, cptr,
  276.                                        &StorageTmp->pingResultsAverageRtt,
  277.                                        &tmpint);
  278.             cptr =
  279.                 read_config_store_data(ASN_UNSIGNED, cptr,
  280.                                        &StorageTmp->
  281.                                        pingResultsProbeResponses, &tmpint);
  282.             cptr =
  283.                 read_config_store_data(ASN_UNSIGNED, cptr,
  284.                                        &StorageTmp->pingResultsSendProbes,
  285.                                        &tmpint);
  286.             cptr =
  287.                 read_config_store_data(ASN_UNSIGNED, cptr,
  288.                                        &StorageTmp->
  289.                                        pingResultsRttSumOfSquares,
  290.                                        &tmpint);
  291.             cptr =
  292.                 read_config_store_data(ASN_OCTET_STR, cptr,
  293.                                        &StorageTmp->
  294.                                        pingResultsLastGoodProbe,
  295.                                        &StorageTmp->
  296.                                        pingResultsLastGoodProbeLen);
  298.             snmpd_store_config(line);
  299.         }
  300.     }
  301.     DEBUGMSGTL(("pingResultsTable", "done.n"));
  302.     return SNMPERR_SUCCESS;
  303. }
  305. int
  306. pingResultsTable_inadd(struct pingResultsTable_data *thedata)
  307. {
  308.     netsnmp_variable_list *vars_list;
  309.     vars_list = NULL;
  312.     snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) thedata->pingCtlOwnerIndex, thedata->pingCtlOwnerIndexLen);  /* pingCtlOwnerIndex */
  313.     snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) thedata->pingCtlTestName, thedata->pingCtlTestNameLen);      /* pingCtlTestName */
  315.     /*
  316.      * XXX: fill in default row values here into StorageNew 
  317.      * 
  318.      */
  321.     DEBUGMSGTL(("pingResultsTable", "adding data...  "));
  322.     /*
  323.      * add the index variables to the varbind list, which is 
  324.      * used by header_complex to index the data 
  325.      */
  327.     header_complex_add_data(&pingResultsTableStorage, vars_list, thedata);
  328.     DEBUGMSGTL(("pingResultsTable", "registered an entryn"));
  331.     DEBUGMSGTL(("pingResultsTable", "done.n"));
  332.     return SNMPERR_SUCCESS;
  333. }
  336. /*
  337.  * var_pingResultsTable():
  338.  *   Handle this table separately from the scalar value case.
  339.  *   The workings of this are basically the same as for var_pingResultsTable above.
  340.  */
  341. unsigned char  *
  342. var_pingResultsTable(struct variable *vp,
  343.                      oid * name,
  344.                      size_t *length,
  345.                      int exact,
  346.                      size_t *var_len, WriteMethod ** write_method)
  347. {
  350.     struct pingResultsTable_data *StorageTmp = NULL;
  352.     *write_method = NULL;
  353.     /*
  354.      * this assumes you have registered all your data properly
  355.      */
  356.     if ((StorageTmp =
  357.          header_complex(pingResultsTableStorage, vp, name, length, exact,
  358.                         var_len, write_method)) == NULL) {
  360.         return NULL;
  361.     }
  363.     /*
  364.      * this is where we do the value assignments for the mib results.
  365.      */
  367.     switch (vp->magic) {
  369.     case COLUMN_PINGRESULTSOPERSTATUS:
  370.         *var_len = sizeof(StorageTmp->pingResultsOperStatus);
  371.         return (u_char *) & StorageTmp->pingResultsOperStatus;
  373.     case COLUMN_PINGRESULTSIPTARGETADDRESSTYPE:
  374.         *var_len = sizeof(StorageTmp->pingResultsIpTargetAddressType);
  375.         return (u_char *) & StorageTmp->pingResultsIpTargetAddressType;
  377.     case COLUMN_PINGRESULTSIPTARGETADDRESS:
  378.         *var_len = (StorageTmp->pingResultsIpTargetAddressLen);
  379.         return (u_char *) StorageTmp->pingResultsIpTargetAddress;
  381.     case COLUMN_PINGRESULTSMINRTT:
  382.         *var_len = sizeof(StorageTmp->pingResultsMinRtt);
  383.         return (u_char *) & StorageTmp->pingResultsMinRtt;
  385.     case COLUMN_PINGRESULTSMAXRTT:
  386.         *var_len = sizeof(StorageTmp->pingResultsMaxRtt);
  387.         return (u_char *) & StorageTmp->pingResultsMaxRtt;
  389.     case COLUMN_PINGRESULTSAVERAGERTT:
  390.         *var_len = sizeof(StorageTmp->pingResultsAverageRtt);
  391.         return (u_char *) & StorageTmp->pingResultsAverageRtt;
  393.     case COLUMN_PINGRESULTSPROBERESPONSES:
  394.         *var_len = sizeof(StorageTmp->pingResultsProbeResponses);
  395.         return (u_char *) & StorageTmp->pingResultsProbeResponses;
  397.     case COLUMN_PINGRESULTSSENTPROBES:
  398.         *var_len = sizeof(StorageTmp->pingResultsSendProbes);
  399.         return (u_char *) & StorageTmp->pingResultsSendProbes;
  401.     case COLUMN_PINGRESULTSRTTSUMOFSQUARES:
  402.         *var_len = sizeof(StorageTmp->pingResultsRttSumOfSquares);
  403.         return (u_char *) & StorageTmp->pingResultsRttSumOfSquares;
  405.     case COLUMN_PINGRESULTSLASTGOODPROBE:
  406.         *var_len = (StorageTmp->pingResultsLastGoodProbeLen);
  407.         return (u_char *) StorageTmp->pingResultsLastGoodProbe;
  409.     default:
  410.         ERROR_MSG("");
  411.     }
  413.     return NULL;
  414. }