/** 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);
}
