stash_cache.c

00001 #include <net-snmp/net-snmp-config.h>
00002 
00003 #include <net-snmp/net-snmp-includes.h>
00004 #include <net-snmp/agent/net-snmp-agent-includes.h>
00005 
00006 #include <net-snmp/agent/stash_cache.h>
00007 
00008 #include <net-snmp/agent/stash_to_next.h>
00009 
00010 extern NetsnmpCacheLoad _netsnmp_stash_cache_load;
00011 extern NetsnmpCacheFree _netsnmp_stash_cache_free;
00012  
00024 netsnmp_stash_cache_info *
00025 netsnmp_get_new_stash_cache(void)
00026 {
00027     netsnmp_stash_cache_info *cinfo;
00028 
00029     cinfo = SNMP_MALLOC_TYPEDEF(netsnmp_stash_cache_info);
00030     if (cinfo != NULL)
00031         cinfo->cache_length = 30;
00032     return cinfo;
00033 }
00034 
00039 netsnmp_mib_handler *
00040 netsnmp_get_timed_bare_stash_cache_handler(int timeout, oid *rootoid, size_t rootoid_len)
00041 {
00042     netsnmp_mib_handler *handler;
00043     netsnmp_cache       *cinfo;
00044 
00045     cinfo = netsnmp_cache_create( timeout, _netsnmp_stash_cache_load,
00046                                  _netsnmp_stash_cache_free, rootoid, rootoid_len );
00047 
00048     if (!cinfo)
00049         return NULL;
00050 
00051     handler = netsnmp_cache_handler_get( cinfo );
00052     if (!handler) {
00053         free(cinfo);
00054         return NULL;
00055     }
00056 
00057     handler->next = netsnmp_create_handler("stash_cache", netsnmp_stash_cache_helper);
00058     if (!handler->next) {
00059         netsnmp_handler_free(handler);
00060         free(cinfo);
00061         return NULL;
00062     }
00063 
00064     handler->myvoid = cinfo;
00065     handler->data_free = free;
00066 
00067     return handler;
00068 }
00069 
00074 netsnmp_mib_handler *
00075 netsnmp_get_bare_stash_cache_handler(void)
00076 {
00077     return netsnmp_get_timed_bare_stash_cache_handler( 30, NULL, 0 );
00078 }
00079 
00083 netsnmp_mib_handler *
00084 netsnmp_get_stash_cache_handler(void)
00085 {
00086     netsnmp_mib_handler *handler = netsnmp_get_bare_stash_cache_handler();
00087     if (handler && handler->next) {
00088         handler->next->next = netsnmp_get_stash_to_next_handler();
00089     }
00090     return handler;
00091 }
00092 
00096 netsnmp_mib_handler *
00097 netsnmp_get_timed_stash_cache_handler(int timeout, oid *rootoid, size_t rootoid_len)
00098 {
00099     netsnmp_mib_handler *handler = 
00100        netsnmp_get_timed_bare_stash_cache_handler(timeout, rootoid, rootoid_len);
00101     if (handler && handler->next) {
00102         handler->next->next = netsnmp_get_stash_to_next_handler();
00103     }
00104     return handler;
00105 }
00106 
00108 netsnmp_oid_stash_node  **
00109 netsnmp_extract_stash_cache(netsnmp_agent_request_info *reqinfo)
00110 {
00111     return netsnmp_agent_get_list_data(reqinfo, STASH_CACHE_NAME);
00112 }
00113 
00114 
00116 int
00117 netsnmp_stash_cache_helper(netsnmp_mib_handler *handler,
00118                            netsnmp_handler_registration *reginfo,
00119                            netsnmp_agent_request_info *reqinfo,
00120                            netsnmp_request_info *requests)
00121 {
00122     netsnmp_cache            *cache;
00123     netsnmp_stash_cache_info *cinfo;
00124     netsnmp_oid_stash_node   *cnode;
00125     netsnmp_variable_list    *cdata;
00126     netsnmp_request_info     *request;
00127 
00128     DEBUGMSGTL(("helper:stash_cache", "Got request\n"));
00129 
00130     cache = netsnmp_cache_reqinfo_extract( reqinfo, reginfo->handlerName );
00131     if (!cache) {
00132         DEBUGMSGTL(("helper:stash_cache", "No cache structure\n"));
00133         return SNMP_ERR_GENERR;
00134     }
00135     cinfo = (netsnmp_stash_cache_info *) cache->magic;
00136 
00137     switch (reqinfo->mode) {
00138 
00139     case MODE_GET:
00140         DEBUGMSGTL(("helper:stash_cache", "Processing GET request\n"));
00141         for(request = requests; request; request = request->next) {
00142             cdata =
00143                 netsnmp_oid_stash_get_data(cinfo->cache,
00144                                            requests->requestvb->name,
00145                                            requests->requestvb->name_length);
00146             if (cdata && cdata->val.string && cdata->val_len) {
00147                 DEBUGMSGTL(("helper:stash_cache", "Found cached GET varbind\n"));
00148                 DEBUGMSGOID(("helper:stash_cache", cdata->name, cdata->name_length));
00149                 DEBUGMSG(("helper:stash_cache", "\n"));
00150                 snmp_set_var_typed_value(request->requestvb, cdata->type,
00151                                          cdata->val.string, cdata->val_len);
00152             }
00153         }
00154         break;
00155 
00156     case MODE_GETNEXT:
00157         DEBUGMSGTL(("helper:stash_cache", "Processing GETNEXT request\n"));
00158         for(request = requests; request; request = request->next) {
00159             cnode =
00160                 netsnmp_oid_stash_getnext_node(cinfo->cache,
00161                                                requests->requestvb->name,
00162                                                requests->requestvb->name_length);
00163             if (cnode && cnode->thedata) {
00164                 cdata = cnode->thedata;
00165                 if (cdata->val.string && cdata->name && cdata->name_length) {
00166                     DEBUGMSGTL(("helper:stash_cache", "Found cached GETNEXT varbind\n"));
00167                     DEBUGMSGOID(("helper:stash_cache", cdata->name, cdata->name_length));
00168                     DEBUGMSG(("helper:stash_cache", "\n"));
00169                     snmp_set_var_typed_value(request->requestvb, cdata->type,
00170                                              cdata->val.string, cdata->val_len);
00171                     snmp_set_var_objid(request->requestvb, cdata->name,
00172                                        cdata->name_length);
00173                 }
00174             }
00175         }
00176         break;
00177 
00178     default:
00179         cinfo->cache_valid = 0;
00180         return netsnmp_call_next_handler(handler, reginfo, reqinfo,
00181                                          requests);
00182     }
00183 
00184     return SNMP_ERR_NOERROR;
00185 }
00186 
00189 int
00190 _netsnmp_stash_cache_load( netsnmp_cache *cache, void *magic )
00191 {
00192     netsnmp_mib_handler          *handler  = cache->cache_hint->handler;
00193     netsnmp_handler_registration *reginfo  = cache->cache_hint->reginfo;
00194     netsnmp_agent_request_info   *reqinfo  = cache->cache_hint->reqinfo;
00195     netsnmp_request_info         *requests = cache->cache_hint->requests;
00196     netsnmp_stash_cache_info     *cinfo    = (netsnmp_stash_cache_info*) magic;
00197     int old_mode;
00198     int ret;
00199 
00200     if (!cinfo) {
00201         cinfo = netsnmp_get_new_stash_cache();
00202         cache->magic = cinfo;
00203     }
00204 
00205     /* change modes to the GET_STASH mode */
00206     old_mode = reqinfo->mode;
00207     reqinfo->mode = MODE_GET_STASH;
00208     netsnmp_agent_add_list_data(reqinfo,
00209                                 netsnmp_create_data_list(STASH_CACHE_NAME,
00210                                                          &cinfo->cache, NULL));
00211 
00212     /* have the next handler fill stuff in and switch modes back */
00213     ret = netsnmp_call_next_handler(handler->next, reginfo, reqinfo, requests);
00214     reqinfo->mode = old_mode;
00215 
00216     return ret;
00217 }
00218 
00219 void
00220 _netsnmp_stash_cache_free( netsnmp_cache *cache, void *magic )
00221 {
00222     netsnmp_stash_cache_info *cinfo = (netsnmp_stash_cache_info*) magic;
00223     netsnmp_oid_stash_free(&cinfo->cache,
00224                           (NetSNMPStashFreeNode *) snmp_free_var);
00225     return;
00226 }
00227 
00232 void
00233 netsnmp_init_stash_cache_helper(void)
00234 {
00235     netsnmp_register_handler_by_name("stash_cache",
00236                                      netsnmp_get_stash_cache_handler());
00237 }