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

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

SNMP编程

开发平台：

Unix_Linux

nsCache.c：源码内容
  1. #include <net-snmp/net-snmp-config.h>
  2. #include <net-snmp/net-snmp-includes.h>
  3. #include <net-snmp/agent/net-snmp-agent-includes.h>
  4. #include <net-snmp/agent/scalar.h>
  6. #ifdef HAVE_STRING_H
  7. #include <string.h>
  8. #else
  9. #include <strings.h>
  10. #endif
  12. #include <net-snmp/agent/cache_handler.h>
  13. #include "agent/nsCache.h"
  14. #include "util_funcs.h"
  17. /*
  18.  * use unadvertised function to get cache head. You really should not
  19.  * do this, since the internal storage mechanism might change.
  20.  */
  21. extern netsnmp_cache *netsnmp_cache_get_head(void);
  24. /*
  25.  * OIDs for the cacheging control scalar objects
  26.  *
  27.  * Note that these we're registering the full object rather
  28.  *  than the (sole) valid instance in each case, in order
  29.  *  to handle requests for invalid instances properly.
  30.  */
  31. oid nsCacheTimeout_oid[]    = { 1, 3, 6, 1, 4, 1, 8072, 1, 5, 1};
  32. oid nsCacheEnabled_oid[]    = { 1, 3, 6, 1, 4, 1, 8072, 1, 5, 2};
  34. /*
  35.  * ... and for the cache table.
  36.  */
  38. #define  NSCACHE_TIMEOUT 2
  39. #define  NSCACHE_STATUS 3
  41. #define NSCACHE_STATUS_ENABLED  1
  42. #define NSCACHE_STATUS_DISABLED 2
  43. #define NSCACHE_STATUS_EMPTY    3
  44. #define NSCACHE_STATUS_ACTIVE   4
  45. #define NSCACHE_STATUS_EXPIRED  5
  47. oid nsCacheTable_oid[]      = { 1, 3, 6, 1, 4, 1, 8072, 1, 5, 3};
  50. void
  51. init_nsCache(void)
  52. {
  53.     netsnmp_table_registration_info *table_info;
  54.     netsnmp_iterator_info           *iinfo;
  56.     /*
  57.      * Register the scalar objects...
  58.      */
  59.     DEBUGMSGTL(("nsCacheScalars", "Initializingn"));
  60.     netsnmp_register_scalar(
  61.         netsnmp_create_handler_registration(
  62.             "nsCacheTimeout", handle_nsCacheTimeout,
  63.             nsCacheTimeout_oid, OID_LENGTH(nsCacheTimeout_oid),
  64.             HANDLER_CAN_RWRITE)
  65.         );
  66.     netsnmp_register_scalar(
  67.         netsnmp_create_handler_registration(
  68.             "nsCacheEnabled", handle_nsCacheEnabled,
  69.             nsCacheEnabled_oid, OID_LENGTH(nsCacheEnabled_oid),
  70.             HANDLER_CAN_RWRITE)
  71.         );
  73.     /*
  74.      * ... and the table.
  75.      * We need to define the column structure and indexing....
  76.      */
  78.     table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
  79.     if (!table_info) {
  80.         return;
  81.     }
  82.     netsnmp_table_helper_add_indexes(table_info, ASN_PRIV_IMPLIED_OBJECT_ID, 0);
  83.     table_info->min_column = NSCACHE_TIMEOUT;
  84.     table_info->max_column = NSCACHE_STATUS;
  87.     /*
  88.      * .... and the iteration information ....
  89.      */
  90.     iinfo      = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info);
  91.     if (!iinfo) {
  92.         return;
  93.     }
  94.     iinfo->get_first_data_point = get_first_cache_entry;
  95.     iinfo->get_next_data_point  = get_next_cache_entry;
  96.     iinfo->table_reginfo        = table_info;
  99.     /*
  100.      * .... and register the table with the agent.
  101.      */
  102.     netsnmp_register_table_iterator(
  103.         netsnmp_create_handler_registration(
  104.             "tzCacheTable", handle_nsCacheTable,
  105.             nsCacheTable_oid, OID_LENGTH(nsCacheTable_oid),
  106.             HANDLER_CAN_RWRITE),
  107.         iinfo);
  108. }
  111. /*
  112.  * nsCache scalar handling
  113.  */
  115. int
  116. handle_nsCacheTimeout(netsnmp_mib_handler *handler,
  117.                 netsnmp_handler_registration *reginfo,
  118.                 netsnmp_agent_request_info *reqinfo,
  119.                 netsnmp_request_info *requests)
  120. {
  121.     long cache_default_timeout =
  122.         netsnmp_ds_get_int(NETSNMP_DS_APPLICATION_ID,
  123.                                NETSNMP_DS_AGENT_CACHE_TIMEOUT);
  124.     netsnmp_request_info *request=NULL;
  126.     switch (reqinfo->mode) {
  128.     case MODE_GET:
  129. for (request = requests; request; request=request->next) {
  130.     snmp_set_var_typed_value(request->requestvb, ASN_INTEGER,
  131.                                      (u_char*)&cache_default_timeout,
  132.                                         sizeof(cache_default_timeout));
  133. }
  134. break;
  137.     case MODE_SET_RESERVE1:
  138. for (request = requests; request; request=request->next) {
  139.             if ( request->status != 0 ) {
  140.                 return SNMP_ERR_NOERROR; /* Already got an error */
  141.             }
  142.             if ( request->requestvb->type != ASN_INTEGER ) {
  143.                 netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGTYPE);
  144.                 return SNMP_ERR_WRONGTYPE;
  145.             }
  146.             if ( *request->requestvb->val.integer < 0 ) {
  147.                 netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGVALUE);
  148.                 return SNMP_ERR_WRONGVALUE;
  149.             }
  150.         }
  151.         break;
  153.     case MODE_SET_COMMIT:
  154.         netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID,
  155.                            NETSNMP_DS_AGENT_CACHE_TIMEOUT,
  156.                            *requests->requestvb->val.integer);
  157.         break;
  158.     }
  160.     return SNMP_ERR_NOERROR;
  161. }
  164. int
  165. handle_nsCacheEnabled(netsnmp_mib_handler *handler,
  166.                 netsnmp_handler_registration *reginfo,
  167.                 netsnmp_agent_request_info *reqinfo,
  168.                 netsnmp_request_info *requests)
  169. {
  170.     long enabled;
  171.     netsnmp_request_info *request=NULL;
  173.     switch (reqinfo->mode) {
  175.     case MODE_GET:
  176. enabled =  (netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID,
  177.                                            NETSNMP_DS_AGENT_NO_CACHING)
  178.                        ? NSCACHE_STATUS_ENABLED    /* Actually True/False */
  179.                        : NSCACHE_STATUS_DISABLED );
  180. for (request = requests; request; request=request->next) {
  181.     snmp_set_var_typed_value(request->requestvb, ASN_INTEGER,
  182.                                      (u_char*)&enabled, sizeof(enabled));
  183. }
  184. break;
  187.     case MODE_SET_RESERVE1:
  188. for (request = requests; request; request=request->next) {
  189.             if ( request->status != 0 ) {
  190.                 return SNMP_ERR_NOERROR; /* Already got an error */
  191.             }
  192.             if ( request->requestvb->type != ASN_INTEGER ) {
  193.                 netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGTYPE);
  194.                 return SNMP_ERR_WRONGTYPE;
  195.             }
  196.             if ((*request->requestvb->val.integer != NSCACHE_STATUS_ENABLED) &&
  197.                 (*request->requestvb->val.integer != NSCACHE_STATUS_DISABLED)) {
  198.                 netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGVALUE);
  199.                 return SNMP_ERR_WRONGVALUE;
  200.             }
  201.         }
  202.         break;
  204.     case MODE_SET_COMMIT:
  205.         enabled = *requests->requestvb->val.integer;
  206. if (enabled == NSCACHE_STATUS_DISABLED)
  207.     enabled = 0;
  208. netsnmp_ds_set_boolean(NETSNMP_DS_APPLICATION_ID,
  209.                                NETSNMP_DS_AGENT_NO_CACHING, enabled);
  210.         break;
  211.     }
  213.     return SNMP_ERR_NOERROR;
  214. }
  217. /*
  218.  * nsCacheTable handling
  219.  */
  221. netsnmp_variable_list *
  222. get_first_cache_entry(void **loop_context, void **data_context,
  223.                       netsnmp_variable_list *index,
  224.                       netsnmp_iterator_info *data)
  225. {
  226.     netsnmp_cache  *cache_head = netsnmp_cache_get_head();
  228.     if ( !cache_head )
  229.         return NULL;
  231.     snmp_set_var_value(index, (u_char*)cache_head->rootoid,
  232.          sizeof(oid) * cache_head->rootoid_len);
  233.     *loop_context = (void*)cache_head;
  234.     *data_context = (void*)cache_head;
  235.     return index;
  236. }
  238. netsnmp_variable_list *
  239. get_next_cache_entry(void **loop_context, void **data_context,
  240.                       netsnmp_variable_list *index,
  241.                       netsnmp_iterator_info *data)
  242. {
  243.     netsnmp_cache *cache = (netsnmp_cache *)*loop_context;
  244.     cache = cache->next;
  246.     if ( !cache )
  247.         return NULL;
  249.     snmp_set_var_value(index, (u_char*)cache->rootoid,
  250.          sizeof(oid) * cache->rootoid_len);
  251.     *loop_context = (void*)cache;
  252.     *data_context = (void*)cache;
  253.     return index;
  254. }
  257. int
  258. handle_nsCacheTable(netsnmp_mib_handler *handler,
  259.                 netsnmp_handler_registration *reginfo,
  260.                 netsnmp_agent_request_info *reqinfo,
  261.                 netsnmp_request_info *requests)
  262. {
  263.     long status;
  264.     netsnmp_request_info       *request     = NULL;
  265.     netsnmp_table_request_info *table_info  = NULL;
  266.     netsnmp_cache              *cache_entry = NULL;
  268.     switch (reqinfo->mode) {
  270.     case MODE_GET:
  271.         for (request=requests; request; request=request->next) {
  272.             if (requests->processed != 0)
  273.                 continue;
  275.             cache_entry = (netsnmp_cache*)netsnmp_extract_iterator_context(request);
  276.             table_info  =                 netsnmp_extract_table_info(request);
  278.             switch (table_info->colnum) {
  279.             case NSCACHE_TIMEOUT:
  280.                 if (!cache_entry) {
  281.                     netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHINSTANCE);
  282.                     continue;
  283. }
  284. status = cache_entry->timeout;
  285.         snmp_set_var_typed_value(request->requestvb, ASN_INTEGER,
  286.                                          (u_char*)&status, sizeof(status));
  287.         break;
  289.             case NSCACHE_STATUS:
  290.                 if (!cache_entry) {
  291.                     netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHINSTANCE);
  292.                     continue;
  293. }
  294. status = (cache_entry->enabled ?
  295.                    (cache_entry->timestamp ?
  296.                              (!atime_ready(cache_entry->timestamp,
  297.                                           1000*cache_entry->timeout) ?
  298.                         NSCACHE_STATUS_ACTIVE:
  299.                         NSCACHE_STATUS_EXPIRED) :
  300.                       NSCACHE_STATUS_EMPTY) :
  301.                     NSCACHE_STATUS_DISABLED);
  302.         snmp_set_var_typed_value(request->requestvb, ASN_INTEGER,
  303.                                          (u_char*)&status, sizeof(status));
  304.         break;
  306.             default:
  307.                 netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
  308.                 continue;
  309.     }
  310. }
  311. break;
  314.     case MODE_SET_RESERVE1:
  315.         for (request=requests; request; request=request->next) {
  316.             if (requests->processed != 0)
  317.                 continue;
  318.             if ( request->status != 0 ) {
  319.                 return SNMP_ERR_NOERROR; /* Already got an error */
  320.             }
  321.             cache_entry = (netsnmp_cache*)netsnmp_extract_iterator_context(request);
  322.             table_info  =                 netsnmp_extract_table_info(request);
  324.             switch (table_info->colnum) {
  325.             case NSCACHE_TIMEOUT:
  326.                 if (!cache_entry) {
  327.                     netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION);
  328.                     return SNMP_ERR_NOCREATION;
  329. }
  330.                 if ( request->requestvb->type != ASN_INTEGER ) {
  331.                     netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGTYPE);
  332.                     return SNMP_ERR_WRONGTYPE;
  333.                 }
  334.                 if (*request->requestvb->val.integer < 0 ) {
  335.                     netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGVALUE);
  336.                     return SNMP_ERR_WRONGVALUE;
  337.                 }
  338.         break;
  340.             case NSCACHE_STATUS:
  341.                 if (!cache_entry) {
  342.                     netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION);
  343.                     return SNMP_ERR_NOCREATION;
  344. }
  345.                 if ( request->requestvb->type != ASN_INTEGER ) {
  346.                     netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGTYPE);
  347.                     return SNMP_ERR_WRONGTYPE;
  348.                 }
  349.                 status = *request->requestvb->val.integer;
  350.                 if (!((status == NSCACHE_STATUS_ENABLED  ) ||
  351.                       (status == NSCACHE_STATUS_DISABLED ) ||
  352.                       (status == NSCACHE_STATUS_EMPTY  ))) {
  353.                     netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGVALUE);
  354.                     return SNMP_ERR_WRONGVALUE;
  355.                 }
  356.         break;
  358.             default:
  359.                 netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION);
  360.                 return SNMP_ERR_NOCREATION; /* XXX - is this right ? */
  361.                 continue;
  362.     }
  363. }
  364. break;
  367.     case MODE_SET_COMMIT:
  368.         for (request=requests; request; request=request->next) {
  369.             if (requests->processed != 0)
  370.                 continue;
  371.             if ( request->status != 0 ) {
  372.                 return SNMP_ERR_NOERROR; /* Already got an error */
  373.             }
  374.             cache_entry = (netsnmp_cache*)netsnmp_extract_iterator_context(request);
  375.             if (!cache_entry) {
  376.                 netsnmp_set_request_error(reqinfo, request, SNMP_ERR_COMMITFAILED);
  377.                 return SNMP_ERR_COMMITFAILED; /* Shouldn't happen! */
  378.             }
  379.             table_info  =                 netsnmp_extract_table_info(request);
  381.             switch (table_info->colnum) {
  382.             case NSCACHE_TIMEOUT:
  383.                 cache_entry->timeout = *request->requestvb->val.integer;
  384.         break;
  386.             case NSCACHE_STATUS:
  387.                 switch (*request->requestvb->val.integer) {
  388.                     case NSCACHE_STATUS_ENABLED:
  389.                         cache_entry->enabled = 1;
  390.                         break;
  391.     case NSCACHE_STATUS_DISABLED:
  392.                         cache_entry->enabled = 0;
  393.                         break;
  394.     case NSCACHE_STATUS_EMPTY:
  395.                         cache_entry->free_cache(cache_entry, cache_entry->magic);
  396.                         free(cache_entry->timestamp);
  397.                         cache_entry->timestamp = NULL;
  398.                         break;
  399. }
  400.         break;
  401.     }
  402. }
  403. break;
  404.     }
  406.     return SNMP_ERR_NOERROR;
  407. }