/** returns a cache handler that can be injected into a given handler chain. */ netsnmp_mib_handler * netsnmp_cache_handler_get(netsnmp_cache* cache) { netsnmp_mib_handler *ret = NULL; ret = netsnmp_create_handler("cache_handler", netsnmp_cache_helper_handler); if (ret) { ret->flags |= MIB_HANDLER_AUTO_NEXT; ret->myvoid = (void *) cache; if(NULL != cache) { if ((cache->flags & NETSNMP_CACHE_PRELOAD) && ! cache->valid) { /* * load cache, ignore rc * (failed load doesn't affect registration) */ (void)_cache_load(cache); } if (cache->flags & NETSNMP_CACHE_AUTO_RELOAD) netsnmp_cache_timer_start(cache); } } return ret; }
/** returns a baby_steps handler that can be injected into a given * handler chain. */ netsnmp_mib_handler * netsnmp_baby_steps_handler_get(u_long modes) { netsnmp_mib_handler *mh; netsnmp_baby_steps_modes *md; mh = netsnmp_create_handler("baby_steps", _baby_steps_helper); if(!mh) return NULL; md = SNMP_MALLOC_TYPEDEF(netsnmp_baby_steps_modes); if (NULL == md) { snmp_log(LOG_ERR,"malloc failed in netsnmp_baby_steps_handler_get\n"); netsnmp_handler_free(mh); mh = NULL; } else { mh->myvoid = md; if (0 == modes) modes = BABY_STEP_ALL; md->registered = modes; } /* * don't set MIB_HANDLER_AUTO_NEXT, since we need to call lower * handlers with a munged mode. */ return mh; }
/** returns a stash_cache handler that can be injected into a given * handler chain (with the specified timeout and root OID values), * but *only* if that handler chain explicitly supports stash cache processing. */ netsnmp_mib_handler * netsnmp_get_timed_bare_stash_cache_handler(int timeout, oid *rootoid, size_t rootoid_len) { netsnmp_mib_handler *handler; netsnmp_cache *cinfo; cinfo = netsnmp_cache_create( timeout, _netsnmp_stash_cache_load, _netsnmp_stash_cache_free, rootoid, rootoid_len ); if (!cinfo) return NULL; handler = netsnmp_cache_handler_get( cinfo ); if (!handler) { free(cinfo); return NULL; } handler->next = netsnmp_create_handler("stash_cache", netsnmp_stash_cache_helper); if (!handler->next) { netsnmp_handler_free(handler); free(cinfo); return NULL; } handler->myvoid = cinfo; netsnmp_cache_handler_owns_cache(handler); return handler; }
static netsnmp_handler_registration * get_reg(const char *name, const char *ourname, const oid * reg_oid, size_t reg_oid_len, void *it, int modes, Netsnmp_Node_Handler * scalarh, Netsnmp_Node_Handler * subhandler, const char *contextName) { netsnmp_handler_registration *myreg; netsnmp_mib_handler *myhandler; if (subhandler) { myreg = netsnmp_create_handler_registration(name, subhandler, reg_oid, reg_oid_len, modes); myhandler = netsnmp_create_handler(ourname, scalarh); myhandler->myvoid = (void *) it; netsnmp_inject_handler(myreg, myhandler); } else { myreg = netsnmp_create_handler_registration(name, scalarh, reg_oid, reg_oid_len, modes); myreg->handler->myvoid = (void *) it; } if (contextName) myreg->contextName = strdup(contextName); return myreg; }
int netsnmp_table_array_register (netsnmp_handler_registration * reginfo, netsnmp_table_registration_info * tabreg, netsnmp_table_array_callbacks * cb, netsnmp_container * container, int group_rows) { netsnmp_inject_handler (reginfo, netsnmp_create_handler (reginfo->handlerName, netsnmp_table_array_helper_handler)); return netsnmp_table_container_register (reginfo, tabreg, cb, container, group_rows); }
static netsnmp_mib_handler* netsnmp_get_truthvalue(void) { netsnmp_mib_handler* hnd = netsnmp_create_handler("truthvalue", handle_truthvalue); if (hnd) hnd->flags |= MIB_HANDLER_AUTO_NEXT; return hnd; }
netsnmp_mib_handler * netsnmp_get_watched_spinlock_handler(void) { netsnmp_mib_handler *ret = NULL; ret = netsnmp_create_handler("watcher-spinlock", netsnmp_watched_spinlock_handler); if (ret) { ret->flags |= MIB_HANDLER_AUTO_NEXT; } return ret; }
/** returns a stash_to_next handler that can be injected into a given * handler chain. */ netsnmp_mib_handler * netsnmp_get_stash_to_next_handler(void) { netsnmp_mib_handler *handler = netsnmp_create_handler("stash_to_next", netsnmp_stash_to_next_helper); if (NULL != handler) handler->flags |= MIB_HANDLER_AUTO_NEXT; return handler; }
/** returns a read_only handler that can be injected into a given * handler chain. */ netsnmp_mib_handler * netsnmp_get_read_only_handler(void) { netsnmp_mib_handler *ret = NULL; ret = netsnmp_create_handler("read_only", netsnmp_read_only_helper); if (ret) { ret->flags |= MIB_HANDLER_AUTO_NEXT; } return ret; }
static netsnmp_handler_registration * get_reg(const char *name, const char *ourname, const oid * reg_oid, size_t reg_oid_len, netsnmp_num_file_instance *it, int modes, Netsnmp_Node_Handler * scalarh, Netsnmp_Node_Handler * subhandler, const char *contextName) { netsnmp_handler_registration *myreg; netsnmp_mib_handler *myhandler; if (subhandler) { myreg = netsnmp_create_handler_registration(name, subhandler, reg_oid, reg_oid_len, modes); if (!myreg) return NULL; myhandler = netsnmp_create_handler(ourname, scalarh); if (!myhandler) { netsnmp_handler_registration_free(myreg); return NULL; } myhandler->myvoid = it; myhandler->data_clone = (void*(*)(void*))netsnmp_num_file_instance_ref; myhandler->data_free = (void(*)(void*))netsnmp_num_file_instance_deref; if (netsnmp_inject_handler(myreg, myhandler) != SNMPERR_SUCCESS) { netsnmp_handler_free(myhandler); netsnmp_handler_registration_free(myreg); return NULL; } } else { myreg = netsnmp_create_handler_registration(name, scalarh, reg_oid, reg_oid_len, modes); if (!myreg) return NULL; myreg->handler->myvoid = it; myreg->handler->data_clone = (void *(*)(void *))netsnmp_num_file_instance_ref; myreg->handler->data_free = (void (*)(void *))netsnmp_num_file_instance_deref; } if (contextName) { myreg->contextName = strdup(contextName); if (!myreg->contextName) { netsnmp_handler_registration_free(myreg); return NULL; } } return myreg; }
static netsnmp_mib_handler * netsnmp_get_statistic_handler(int offset) { netsnmp_mib_handler *ret = netsnmp_create_handler("get_statistic", netsnmp_get_statistic_helper_handler); if (ret) { ret->flags |= MIB_HANDLER_AUTO_NEXT; ret->myvoid = (void*)(uintptr_t)offset; } return ret; }
/** returns a mode_end_call handler that can be injected into a given * handler chain. * @param endlist The callback list for the handler to make use of. * @return An injectable Net-SNMP handler. */ netsnmp_mib_handler * netsnmp_get_mode_end_call_handler(netsnmp_mode_handler_list *endlist) { netsnmp_mib_handler *me = netsnmp_create_handler("mode_end_call", netsnmp_mode_end_call_helper); if (!me) return NULL; me->myvoid = endlist; return me; }
/** returns a netsnmp_mib_handler object for the table_iterator helper */ netsnmp_mib_handler * netsnmp_get_table_iterator_handler(netsnmp_iterator_info *iinfo) { netsnmp_mib_handler *me = netsnmp_create_handler(TABLE_ITERATOR_NAME, netsnmp_table_iterator_helper_handler); if (!me || !iinfo) return NULL; me->myvoid = iinfo; return me; }
netsnmp_handler_registration *netsnmp_create_update_handler_registration (const char *name, const oid * id, size_t idlen, int mode, int *set) { netsnmp_handler_registration *res = NULL; netsnmp_mib_handler *hnd = netsnmp_create_handler ("update", handle_updates); if (hnd) { hnd->myvoid = set; res = netsnmp_handler_registration_create (name, hnd, id, idlen, mode); } return res; }
/** returns a baby_steps handler that can be injected into a given * handler chain. */ netsnmp_mib_handler * netsnmp_baby_steps_access_multiplexer_get(netsnmp_baby_steps_access_methods *am) { netsnmp_mib_handler *mh; mh = netsnmp_create_handler("baby_steps_mux", _baby_steps_access_multiplexer); if(!mh) return NULL; mh->myvoid = am; mh->flags |= MIB_HANDLER_AUTO_NEXT; return mh; }
int netsnmp_register_null_context(oid * loc, size_t loc_len, const char *contextName) { netsnmp_handler_registration *reginfo; reginfo = SNMP_MALLOC_TYPEDEF(netsnmp_handler_registration); reginfo->handlerName = strdup(""); reginfo->rootoid = loc; reginfo->rootoid_len = loc_len; reginfo->handler = netsnmp_create_handler("null", netsnmp_null_handler); if (contextName) reginfo->contextName = strdup(contextName); reginfo->modes = HANDLER_CAN_DEFAULT; return netsnmp_register_handler(reginfo); }
/** * Returns a netsnmp_mib_handler object for the table_iterator helper. * * The caller remains the owner of the iterator information object if * the flag NETSNMP_HANDLER_OWNS_IINFO has not been set, and the created * handler becomes the owner of the iterator information if the flag * NETSNMP_HANDLER_OWNS_IINFO has been set. */ netsnmp_mib_handler *netsnmp_get_table_iterator_handler (netsnmp_iterator_info * iinfo) { netsnmp_mib_handler *me; if (!iinfo) return NULL; me = netsnmp_create_handler (TABLE_ITERATOR_NAME, netsnmp_table_iterator_helper_handler); if (!me) return NULL; me->myvoid = iinfo; if (iinfo->flags & NETSNMP_HANDLER_OWNS_IINFO) netsnmp_handler_owns_iterator_info (me); return me; }
/** @defgroup scalar_group_group scalar_group * Process groups of scalars. * @ingroup leaf * @{ */ netsnmp_mib_handler * netsnmp_get_scalar_group_handler(oid first, oid last) { netsnmp_mib_handler *ret = NULL; netsnmp_scalar_group *sgroup = NULL; ret = netsnmp_create_handler("scalar_group", netsnmp_scalar_group_helper_handler); if (ret) { sgroup = SNMP_MALLOC_TYPEDEF(netsnmp_scalar_group); if (sgroup) { sgroup->lbound = first; sgroup->ubound = last; } ret->myvoid = (void *)sgroup; } return ret; }
/** Creates a tdata handler and returns it */ netsnmp_mib_handler *netsnmp_get_tdata_handler (netsnmp_tdata * table) { netsnmp_mib_handler *ret = NULL; if (!table) { snmp_log (LOG_INFO, "netsnmp_get_tdata_handler(NULL) called\n"); return NULL; } ret = netsnmp_create_handler (TABLE_TDATA_NAME, _netsnmp_tdata_helper_handler); if (ret) { ret->flags |= MIB_HANDLER_AUTO_NEXT; ret->myvoid = (void *) table; } return ret; }
/** Creates a table_data handler and returns it */ netsnmp_mib_handler * netsnmp_get_table_data_handler(netsnmp_table_data *table) { netsnmp_mib_handler *ret = NULL; if (!table) { snmp_log(LOG_INFO, "netsnmp_get_table_data_handler(NULL) called\n"); return NULL; } ret = netsnmp_create_handler(TABLE_DATA_NAME, netsnmp_table_data_helper_handler); if (ret) { ret->myvoid = (void *) table; } return ret; }
/** returns a netsnmp_mib_handler object for the table_container helper */ netsnmp_mib_handler * netsnmp_table_row_handler_get(void *row) { netsnmp_mib_handler *handler; handler = netsnmp_create_handler("table_row", _table_row_handler); if(NULL == handler) { snmp_log(LOG_ERR, "malloc failure in netsnmp_table_row_register\n"); return NULL; } handler->myvoid = (void*)row; handler->flags |= MIB_HANDLER_INSTANCE; /* handler->flags |= MIB_HANDLER_AUTO_NEXT; ??? */ return handler; }
/** Given a netsnmp_table_data_set definition, create a handler for it */ netsnmp_mib_handler * netsnmp_get_table_data_set_handler(netsnmp_table_data_set *data_set) { netsnmp_mib_handler *ret = NULL; if (!data_set) { snmp_log(LOG_INFO, "netsnmp_get_table_data_set_handler(NULL) called\n"); return NULL; } ret = netsnmp_create_handler(TABLE_DATA_SET_NAME, netsnmp_table_data_set_helper_handler); if (ret) { ret->flags |= MIB_HANDLER_AUTO_NEXT; ret->myvoid = (void *) data_set; } return ret; }
/** @defgroup scalar_group_group scalar_group * Process groups of scalars. * @ingroup leaf * @{ */ netsnmp_mib_handler * netsnmp_get_scalar_group_handler(oid first, oid last) { netsnmp_mib_handler *ret = NULL; netsnmp_scalar_group *sgroup = NULL; ret = netsnmp_create_handler("scalar_group", netsnmp_scalar_group_helper_handler); if (ret) { sgroup = SNMP_MALLOC_TYPEDEF(netsnmp_scalar_group); if (NULL == sgroup) { netsnmp_handler_free(ret); ret = NULL; } else { sgroup->lbound = first; sgroup->ubound = last; ret->myvoid = (void *)sgroup; ret->data_free = free; ret->data_clone = (void *(*)(void *))clone_scalar_group; } } return ret; }
/** * Creates a scalar handler calling netsnmp_create_handler with a * handler name defaulted to "scalar" and access method, * netsnmp_scalar_helper_handler. * * @param void * * @return Returns a pointer to a netsnmp_mib_handler struct which contains * the handler's name and the access method * * @see netsnmp_get_scalar_handler * @see netsnmp_register_scalar */ netsnmp_mib_handler * netsnmp_get_scalar_handler(void) { return netsnmp_create_handler("scalar", netsnmp_scalar_helper_handler); }
/** returns a serialize handler that can be injected into a given * handler chain. */ netsnmp_mib_handler * netsnmp_get_serialize_handler(void) { return netsnmp_create_handler("serialize", netsnmp_serialize_helper_handler); }
/** returns a old_api handler that should be the final calling * handler. Don't use this function. Use the netsnmp_register_old_api() * function instead. */ netsnmp_mib_handler * get_old_api_handler(void) { return netsnmp_create_handler("old_api", netsnmp_old_api_helper); }
static netsnmp_mib_handler* netsnmp_get_truthvalue(void) { return netsnmp_create_handler("truthvalue", handle_truthvalue); }
/** Initializes the safAmf module */ void clSnmpsafAmfScalarsInit(void) { netsnmp_mib_handler *callback_handler; netsnmp_handler_registration *reg = NULL; DEBUGMSGTL(("safAmfScalars", "Initializing\n")); reg = netsnmp_create_handler_registration("saAmfAgentSpecVersion", clSnmpsaAmfAgentSpecVersionHandler, saAmfAgentSpecVersionOid, OID_LENGTH(saAmfAgentSpecVersionOid), HANDLER_CAN_RONLY ); netsnmp_register_scalar (reg); callback_handler = netsnmp_get_mode_end_call_handler( netsnmp_mode_end_call_add_mode_callback(NULL, NETSNMP_MODE_END_ALL_MODES, netsnmp_create_handler("my_end_callback_handler", clSnmpModeEndCallback) )); netsnmp_inject_handler (reg, callback_handler); reg = netsnmp_create_handler_registration("saAmfAgentVendor", clSnmpsaAmfAgentVendorHandler, saAmfAgentVendorOid, OID_LENGTH(saAmfAgentVendorOid), HANDLER_CAN_RONLY ); netsnmp_register_scalar (reg); callback_handler = netsnmp_get_mode_end_call_handler( netsnmp_mode_end_call_add_mode_callback(NULL, NETSNMP_MODE_END_ALL_MODES, netsnmp_create_handler("my_end_callback_handler", clSnmpModeEndCallback) )); netsnmp_inject_handler (reg, callback_handler); reg = netsnmp_create_handler_registration("saAmfAgentVendorProductRev", clSnmpsaAmfAgentVendorProductRevHandler, saAmfAgentVendorProductRevOid, OID_LENGTH(saAmfAgentVendorProductRevOid), HANDLER_CAN_RONLY ); netsnmp_register_scalar (reg); callback_handler = netsnmp_get_mode_end_call_handler( netsnmp_mode_end_call_add_mode_callback(NULL, NETSNMP_MODE_END_ALL_MODES, netsnmp_create_handler("my_end_callback_handler", clSnmpModeEndCallback) )); netsnmp_inject_handler (reg, callback_handler); reg = netsnmp_create_handler_registration("saAmfServiceStartEnabled", clSnmpsaAmfServiceStartEnabledHandler, saAmfServiceStartEnabledOid, OID_LENGTH(saAmfServiceStartEnabledOid), HANDLER_CAN_RONLY ); netsnmp_register_scalar (reg); callback_handler = netsnmp_get_mode_end_call_handler( netsnmp_mode_end_call_add_mode_callback(NULL, NETSNMP_MODE_END_ALL_MODES, netsnmp_create_handler("my_end_callback_handler", clSnmpModeEndCallback) )); netsnmp_inject_handler (reg, callback_handler); reg = netsnmp_create_handler_registration("saAmfServiceState", clSnmpsaAmfServiceStateHandler, saAmfServiceStateOid, OID_LENGTH(saAmfServiceStateOid), HANDLER_CAN_RWRITE ); netsnmp_register_scalar (reg); callback_handler = netsnmp_get_mode_end_call_handler( netsnmp_mode_end_call_add_mode_callback(NULL, NETSNMP_MODE_END_ALL_MODES, netsnmp_create_handler("my_end_callback_handler", clSnmpModeEndCallback) )); netsnmp_inject_handler (reg, callback_handler); reg = netsnmp_create_handler_registration("saAmfClusterStartupTimeout", clSnmpsaAmfClusterStartupTimeoutHandler, saAmfClusterStartupTimeoutOid, OID_LENGTH(saAmfClusterStartupTimeoutOid), HANDLER_CAN_RWRITE ); netsnmp_register_scalar (reg); callback_handler = netsnmp_get_mode_end_call_handler( netsnmp_mode_end_call_add_mode_callback(NULL, NETSNMP_MODE_END_ALL_MODES, netsnmp_create_handler("my_end_callback_handler", clSnmpModeEndCallback) )); netsnmp_inject_handler (reg, callback_handler); reg = netsnmp_create_handler_registration("saAmfClusterAdminState", clSnmpsaAmfClusterAdminStateHandler, saAmfClusterAdminStateOid, OID_LENGTH(saAmfClusterAdminStateOid), HANDLER_CAN_RONLY ); netsnmp_register_scalar (reg); callback_handler = netsnmp_get_mode_end_call_handler( netsnmp_mode_end_call_add_mode_callback(NULL, NETSNMP_MODE_END_ALL_MODES, netsnmp_create_handler("my_end_callback_handler", clSnmpModeEndCallback) )); netsnmp_inject_handler (reg, callback_handler); reg = netsnmp_create_handler_registration("saAmfClusterAdminStateTrigger", clSnmpsaAmfClusterAdminStateTriggerHandler, saAmfClusterAdminStateTriggerOid, OID_LENGTH(saAmfClusterAdminStateTriggerOid), HANDLER_CAN_RWRITE ); netsnmp_register_scalar (reg); callback_handler = netsnmp_get_mode_end_call_handler( netsnmp_mode_end_call_add_mode_callback(NULL, NETSNMP_MODE_END_ALL_MODES, netsnmp_create_handler("my_end_callback_handler", clSnmpModeEndCallback) )); netsnmp_inject_handler (reg, callback_handler); reg = netsnmp_create_handler_registration("saAmfSvcUserName", clSnmpsaAmfSvcUserNameHandler, saAmfSvcUserNameOid, OID_LENGTH(saAmfSvcUserNameOid), HANDLER_CAN_RONLY ); netsnmp_register_scalar (reg); callback_handler = netsnmp_get_mode_end_call_handler( netsnmp_mode_end_call_add_mode_callback(NULL, NETSNMP_MODE_END_ALL_MODES, netsnmp_create_handler("my_end_callback_handler", clSnmpModeEndCallback) )); netsnmp_inject_handler (reg, callback_handler); reg = netsnmp_create_handler_registration("saAmfProbableCause", clSnmpsaAmfProbableCauseHandler, saAmfProbableCauseOid, OID_LENGTH(saAmfProbableCauseOid), HANDLER_CAN_RONLY ); netsnmp_register_scalar (reg); callback_handler = netsnmp_get_mode_end_call_handler( netsnmp_mode_end_call_add_mode_callback(NULL, NETSNMP_MODE_END_ALL_MODES, netsnmp_create_handler("my_end_callback_handler", clSnmpModeEndCallback) )); netsnmp_inject_handler (reg, callback_handler); }
void netsnmp_parse_override(const char *token, char *line) { char *cp; char buf[SNMP_MAXBUF], namebuf[SNMP_MAXBUF]; int readwrite = 0; oid oidbuf[MAX_OID_LEN]; size_t oidbuf_len = MAX_OID_LEN; int type; override_data *thedata; netsnmp_handler_registration *the_reg; cp = copy_nword(line, namebuf, sizeof(namebuf) - 1); if (strcmp(namebuf, "-rw") == 0) { readwrite = 1; cp = copy_nword(cp, namebuf, sizeof(namebuf) - 1); } if (!cp) { config_perror("no oid specified"); return; } if (!snmp_parse_oid(namebuf, oidbuf, &oidbuf_len)) { config_perror("illegal oid"); return; } cp = copy_nword(cp, buf, sizeof(buf) - 1); if (!cp && strcmp(buf, "null") != 0) { config_perror("no variable value specified"); return; } { struct { const char* key; int value; } const strings[] = { { "counter", ASN_COUNTER }, { "counter64", ASN_COUNTER64 }, { "integer", ASN_INTEGER }, { "ipaddress", ASN_IPADDRESS }, { "nsap", ASN_NSAP }, { "null", ASN_NULL }, { "object_id", ASN_OBJECT_ID }, { "octet_str", ASN_OCTET_STR }, { "opaque", ASN_OPAQUE }, #ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES { "opaque_counter64", ASN_OPAQUE_COUNTER64 }, { "opaque_double", ASN_OPAQUE_DOUBLE }, { "opaque_float", ASN_OPAQUE_FLOAT }, { "opaque_i64", ASN_OPAQUE_I64 }, { "opaque_u64", ASN_OPAQUE_U64 }, #endif { "timeticks", ASN_TIMETICKS }, { "uinteger", ASN_GAUGE }, { "unsigned", ASN_UNSIGNED }, { NULL, 0 } }, * run; for(run = strings; run->key && strcasecmp(run->key, buf) < 0; ++run); if(run->key && strcasecmp(run->key, buf) == 0) type = run->value; else { config_perror("unknown type specified"); return; } } if (cp) copy_nword(cp, buf, sizeof(buf) - 1); else buf[0] = 0; thedata = SNMP_MALLOC_TYPEDEF(override_data); if (!thedata) { config_perror("memory allocation failure"); return; } thedata->type = type; switch (type) { case ASN_INTEGER: MALLOC_OR_DIE(sizeof(long)); *((long *) thedata->value) = strtol(buf, NULL, 0); break; case ASN_COUNTER: case ASN_TIMETICKS: case ASN_UNSIGNED: MALLOC_OR_DIE(sizeof(u_long)); *((u_long *) thedata->value) = strtoul(buf, NULL, 0); break; case ASN_OCTET_STR: case ASN_BIT_STR: if (buf[0] == '0' && buf[1] == 'x') { /* * hex */ thedata->value_len = hex_to_binary2((u_char *)(buf + 2), strlen(buf) - 2, (char **) &thedata->value); } else { thedata->value = strdup(buf); thedata->value_len = strlen(buf); } break; case ASN_OBJECT_ID: read_config_read_objid(buf, (oid **) & thedata->value, &thedata->value_len); break; case ASN_NULL: thedata->value_len = 0; break; default: SNMP_FREE(thedata); config_perror("illegal/unsupported type specified"); return; } if (!thedata->value && thedata->type != ASN_NULL) { config_perror("memory allocation failure"); free(thedata); return; } the_reg = SNMP_MALLOC_TYPEDEF(netsnmp_handler_registration); if (!the_reg) { config_perror("memory allocation failure"); free(thedata); return; } the_reg->handlerName = strdup(namebuf); the_reg->priority = 255; the_reg->modes = (readwrite) ? HANDLER_CAN_RWRITE : HANDLER_CAN_RONLY; the_reg->handler = netsnmp_create_handler("override", override_handler); the_reg->rootoid = snmp_duplicate_objid(oidbuf, oidbuf_len); the_reg->rootoid_len = oidbuf_len; if (!the_reg->rootoid || !the_reg->handler || !the_reg->handlerName) { if (the_reg->handler) SNMP_FREE(the_reg->handler->handler_name); SNMP_FREE(the_reg->handler); SNMP_FREE(the_reg->handlerName); SNMP_FREE(the_reg); config_perror("memory allocation failure"); free(thedata); return; } the_reg->handler->myvoid = thedata; if (netsnmp_register_instance(the_reg)) { config_perror("oid registration failed within the agent"); SNMP_FREE(thedata->value); free(thedata); return; } }
/** * Creates an instance helper handler, calls netsnmp_create_handler, which * then could be registered, using netsnmp_register_handler(). * * @return Returns a pointer to a netsnmp_mib_handler struct which contains * the handler's name and the access method */ netsnmp_mib_handler * netsnmp_get_instance_handler(void) { return netsnmp_create_handler("instance", netsnmp_instance_helper_handler); }