/** 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;
}
/** 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;
}
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;
}
/**
* This function injects a "read only" handler into the handler chain
* prior to serializing/registering the handler.
*
* The only purpose of this "read only" handler is to return an
* appropriate error for any requests passed to it in a SET mode.
* Inserting it into your handler chain will ensure you're never
* asked to perform a SET request so you can ignore those error
* conditions.
*
* @param reginfo a handler registration structure which could get created
* using netsnmp_create_handler_registration. Used to register
* a read only instance helper handler.
*
* @return
* MIB_REGISTERED_OK is returned if the registration was a success.
* Failures are MIB_REGISTRATION_FAILED and MIB_DUPLICATE_REGISTRATION.
*/
int
netsnmp_register_read_only_instance(netsnmp_handler_registration *reginfo)
{
netsnmp_mib_handler *h1, *h2;
if (!reginfo)
return MIB_REGISTRATION_FAILED;
h1 = netsnmp_get_instance_handler();
h2 = netsnmp_get_read_only_handler();
if (h1 && h2 && netsnmp_inject_handler(reginfo, h1) == SNMPERR_SUCCESS) {
h1 = NULL;
if (netsnmp_inject_handler(reginfo, h2) == SNMPERR_SUCCESS)
return netsnmp_register_serialize(reginfo);
}
snmp_log(LOG_ERR, "failed to register read only instance\n");
netsnmp_handler_free(h1);
netsnmp_handler_free(h2);
netsnmp_handler_registration_free(reginfo);
return MIB_REGISTRATION_FAILED;
}
/**
* This function registers an instance helper handler, which is a way of
* registering an exact OID such that GENEXT requests are handled entirely
* by the helper. First need to inject it into the calling chain of the
* handler defined by the netsnmp_handler_registration struct, reginfo.
* The new handler is injected at the top of the list and will be the new
* handler to be called first. This function also injects a serialize
* handler before actually calling netsnmp_register_handle, registering
* reginfo.
*
* @param reginfo a handler registration structure which could get created
* using netsnmp_create_handler_registration. Used to register
* an instance helper handler.
*
* @return
* MIB_REGISTERED_OK is returned if the registration was a success.
* Failures are MIB_REGISTRATION_FAILED and MIB_DUPLICATE_REGISTRATION.
*/
int
netsnmp_register_instance(netsnmp_handler_registration *reginfo)
{
netsnmp_mib_handler *handler = netsnmp_get_instance_handler();
if (handler) {
handler->flags |= MIB_HANDLER_INSTANCE;
if (netsnmp_inject_handler(reginfo, handler) == SNMPERR_SUCCESS)
return netsnmp_register_serialize(reginfo);
}
snmp_log(LOG_ERR, "failed to register instance\n");
netsnmp_handler_free(handler);
netsnmp_handler_registration_free(reginfo);
return MIB_REGISTRATION_FAILED;
}
/** registers a tdata-based MIB table */
int
netsnmp_tdata_register(netsnmp_handler_registration *reginfo,
netsnmp_tdata *table,
netsnmp_table_registration_info *table_info)
{
netsnmp_mib_handler *handler = netsnmp_get_tdata_handler(table);
if (!reginfo || !table || !table_info || !handler ||
(netsnmp_inject_handler(reginfo, handler) != SNMPERR_SUCCESS)) {
snmp_log(LOG_ERR, "could not create tdata handler\n");
netsnmp_handler_free(handler);
netsnmp_handler_registration_free(reginfo);
return SNMP_ERR_GENERR;
}
return netsnmp_container_table_register(reginfo, table_info,
table->container, TABLE_CONTAINER_KEY_NETSNMP_INDEX);
}
static int
_cache_handler_register(netsnmp_handler_registration * reginfo,
netsnmp_mib_handler *handler)
{
/** success path */
if (reginfo && handler &&
(netsnmp_inject_handler(reginfo, handler) == SNMPERR_SUCCESS))
return netsnmp_register_handler(reginfo);
/** error path */
snmp_log(LOG_ERR, "could not register cache handler\n");
if (handler)
netsnmp_handler_free(handler);
netsnmp_handler_registration_free(reginfo);
return MIB_REGISTRATION_FAILED;
}
/** @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;
}
/** Initialize the sctpLookupRemPortTable table by defining its contents and how it's structured */
void
initialize_table_sctpLookupRemPortTable(void)
{
static oid sctpLookupRemPortTable_oid[] =
{ 1, 3, 6, 1, 2, 1, 104, 1, 7 };
size_t sctpLookupRemPortTable_oid_len =
OID_LENGTH(sctpLookupRemPortTable_oid);
netsnmp_handler_registration *reg = NULL;
netsnmp_mib_handler *handler = NULL;
netsnmp_container *container = NULL;
reg =
netsnmp_create_handler_registration("sctpLookupRemPortTable",
sctpLookupRemPortTable_handler,
sctpLookupRemPortTable_oid,
sctpLookupRemPortTable_oid_len,
HANDLER_CAN_RONLY);
if (NULL == reg) {
snmp_log(LOG_ERR,
"error creating handler registration for sctpLookupRemPortTable\n");
goto bail;
}
container =
netsnmp_container_find("sctpLookupRemPortTable:table_container");
if (NULL == container) {
snmp_log(LOG_ERR,
"error creating container for sctpLookupRemPortTable\n");
goto bail;
}
sctpLookupRemPortTable_container = container;
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (NULL == table_info) {
snmp_log(LOG_ERR,
"error allocating table registration for sctpLookupRemPortTable\n");
goto bail;
}
netsnmp_table_helper_add_indexes(table_info, ASN_UNSIGNED, /* index: sctpAssocRemPort */
ASN_UNSIGNED, /* index: sctpAssocId */
0);
table_info->min_column = COLUMN_SCTPLOOKUPREMPORTSTARTTIME;
table_info->max_column = COLUMN_SCTPLOOKUPREMPORTSTARTTIME;
/*************************************************
*
* inject container_table helper
*/
handler = netsnmp_container_table_handler_get(table_info, container,
TABLE_CONTAINER_KEY_NETSNMP_INDEX);
if (NULL == handler) {
snmp_log(LOG_ERR,
"error allocating table registration for sctpLookupRemPortTable\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,
"error injecting container_table handler for sctpLookupRemPortTable\n");
goto bail;
}
handler = NULL; /* reg has it, will reuse below */
/*
* register the table
*/
if (SNMPERR_SUCCESS != netsnmp_register_table(reg, table_info)) {
snmp_log(LOG_ERR,
"error registering table handler for sctpLookupRemPortTable\n");
reg = NULL; /* it was freed inside netsnmp_register_table */
goto bail;
}
return; /* ok */
/*
* Some error occurred during registration. Clean up and bail.
*/
bail: /* not ok */
if (handler)
netsnmp_handler_free(handler);
if (table_info)
netsnmp_table_registration_info_free(table_info);
if (container)
CONTAINER_FREE(container);
if (reg)
netsnmp_handler_registration_free(reg);
}
/** Initialize the cpqSasPhyDrvTable table by defining its contents and how it's structured */
void
initialize_table_cpqSasPhyDrvTable(void)
{
netsnmp_handler_registration *reg = NULL;
netsnmp_mib_handler *handler = NULL;
netsnmp_container *container = NULL;
netsnmp_table_registration_info *table_info = NULL;
netsnmp_cache *cache = NULL;
int reg_tbl_ret = SNMPERR_SUCCESS;
DEBUGMSGTL(("cpqSasPhyDrvTable:init",
"initializing table cpqSasPhyDrvTable\n"));
reg =
netsnmp_create_handler_registration("cpqSasPhyDrvTable",
cpqSasPhyDrvTable_handler,
cpqSasPhyDrvTable_oid,
cpqSasPhyDrvTable_oid_len,
HANDLER_CAN_RONLY);
if (NULL == reg) {
snmp_log(LOG_ERR,
"error creating handler registration for cpqSasPhyDrvTable\n");
goto bail;
}
container =
netsnmp_container_find("cpqSasPhyDrvTable:table_container");
if (NULL == container) {
snmp_log(LOG_ERR,
"error creating container for cpqSasPhyDrvTable\n");
goto bail;
}
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (NULL == table_info) {
snmp_log(LOG_ERR,
"error allocating table registration for cpqSasPhyDrvTable\n");
goto bail;
}
netsnmp_table_helper_add_indexes(table_info,
ASN_INTEGER, /* index: cpqSasPhyDrvHbaIndex */
ASN_INTEGER, /* index: cpqSasPhyDrvIndex */
0);
table_info->min_column = COLUMN_CPQSASPHYDRVHBAINDEX;
table_info->max_column = COLUMN_CPQSASPHYDRVTEMPERATURETHRESHOLD;
/*************************************************
*
* inject container_table helper
*/
handler = netsnmp_container_table_handler_get(table_info, container,
TABLE_CONTAINER_KEY_NETSNMP_INDEX);
if (NULL == handler) {
snmp_log(LOG_ERR,
"error allocating table registration for cpqSasPhyDrvTable\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,
"error injecting container_table handler for cpqSasPhyDrvTable\n");
goto bail;
}
handler = NULL; /* reg has it, will reuse below */
/*************************************************
*
* inject cache helper
*/
cache = netsnmp_cache_create(300, /* timeout in seconds */
_cache_load, _cache_free,
cpqSasPhyDrvTable_oid,
cpqSasPhyDrvTable_oid_len);
if (NULL == cache) {
snmp_log(LOG_ERR, "error creating cache for cpqSasPhyDrvTable\n");
goto bail;
}
cache->flags = NETSNMP_CACHE_PRELOAD |
NETSNMP_CACHE_DONT_FREE_BEFORE_LOAD |
NETSNMP_CACHE_DONT_FREE_EXPIRED |
NETSNMP_CACHE_DONT_AUTO_RELEASE |
NETSNMP_CACHE_DONT_INVALIDATE_ON_SET;
cache->magic = container;
handler = netsnmp_cache_handler_get(cache);
if (NULL == handler) {
snmp_log(LOG_ERR,
"error creating cache handler for cpqSasPhyDrvTable\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,
"error injecting cache handler for cpqSasPhyDrvTable\n");
goto bail;
}
handler = NULL; /* reg has it */
/*
* register the table
*/
reg_tbl_ret = netsnmp_register_table(reg, table_info);
if (reg_tbl_ret != SNMPERR_SUCCESS) {
snmp_log(LOG_ERR,
"error registering table handler for cpqSasPhyDrvTable\n");
goto bail;
}
/*
* Initialise the contents of the table here
*/
return; /* ok */
/*
* Some error occurred during registration. Clean up and bail.
*/
bail: /* not ok */
if (handler)
netsnmp_handler_free(handler);
if (cache)
netsnmp_cache_free(cache);
if (table_info)
netsnmp_table_registration_info_free(table_info);
if (container)
CONTAINER_FREE(container);
if (reg_tbl_ret == SNMPERR_SUCCESS)
if (reg)
netsnmp_handler_registration_free(reg);
}
/** Initialize the hrSWInstalledTable table by defining its contents and how it's structured */
void
initialize_table_hrSWInstalledTable(void)
{
static oid hrSWInstalledTable_oid[] =
{ 1, 3, 6, 1, 2, 1, 25, 6, 3 };
size_t hrSWInstalledTable_oid_len =
OID_LENGTH(hrSWInstalledTable_oid);
netsnmp_handler_registration *reg;
netsnmp_mib_handler *handler = NULL;
netsnmp_container *container = NULL;
netsnmp_cache *cache = NULL;
DEBUGMSGTL(("hrSWInstalled", "initialize\n"));
reg =
netsnmp_create_handler_registration("hrSWInstalledTable",
hrSWInstalledTable_handler,
hrSWInstalledTable_oid,
hrSWInstalledTable_oid_len,
HANDLER_CAN_RONLY);
if (NULL == reg) {
snmp_log(LOG_ERR,"error creating handler registration for "
MYTABLE "\n");
goto bail;
}
container = netsnmp_container_find("hrSWInstalledTable:table_container");
if (NULL == container) {
snmp_log(LOG_ERR,"error creating container for "
MYTABLE "\n");
goto bail;
}
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (NULL == table_info) {
snmp_log(LOG_ERR,"error allocating table registration for "
MYTABLE "\n");
goto bail;
}
netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, /* index: hrSWInstalledIndex */
0);
table_info->min_column = COLUMN_HRSWINSTALLEDINDEX;
table_info->max_column = COLUMN_HRSWINSTALLEDDATE;
/*************************************************
*
* inject container_table helper
*/
handler = netsnmp_container_table_handler_get(table_info, container,
TABLE_CONTAINER_KEY_NETSNMP_INDEX);
if (NULL == handler) {
snmp_log(LOG_ERR,"error allocating table registration for "
MYTABLE "\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,"error injecting container_table handler for "
MYTABLE "\n");
goto bail;
}
handler = NULL; /* reg has it, will reuse below */
/*************************************************
*
* inject cache helper
*/
cache = netsnmp_cache_create(30, /* timeout in seconds */
_cache_load, _cache_free,
hrSWInstalledTable_oid,
hrSWInstalledTable_oid_len);
if (NULL == cache) {
snmp_log(LOG_ERR, "error creating cache for "
MYTABLE "\n");
goto bail;
}
cache->magic = container;
handler = netsnmp_cache_handler_get(cache);
if (NULL == handler) {
snmp_log(LOG_ERR, "error creating cache handler for "
MYTABLE "\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,"error injecting cache handler for "
MYTABLE "\n");
goto bail;
}
handler = NULL; /* reg has it*/
if (SNMPERR_SUCCESS != netsnmp_register_table(reg, table_info)) {
snmp_log(LOG_ERR,"error registering table handler for "
MYTABLE "\n");
reg = NULL; /* it was freed inside netsnmp_register_table */
goto bail;
}
return; /* ok */
bail: /* not ok */
if (handler)
netsnmp_handler_free(handler);
if (cache)
netsnmp_cache_free(cache);
if (table_info)
netsnmp_table_registration_info_free(table_info);
if (container)
CONTAINER_FREE(container);
if (reg)
netsnmp_handler_registration_free(reg);
}
/** Initialize the cpqLinOsProcessorTable table by defining its contents
* and how it's structured
*/
void
initialize_table_cpqLinOsProcessorTable(void)
{
netsnmp_handler_registration *reg = NULL;
netsnmp_mib_handler *handler = NULL;
netsnmp_container *container = NULL;
netsnmp_table_registration_info *table_info = NULL;
netsnmp_cache *cache = NULL;
DEBUGMSGTL(("cpqLinOsProcessorTable:init",
"initializing table cpqLinOsProcessorTable\n"));
reg =
netsnmp_create_handler_registration("cpqLinOsProcessorTable",
cpqLinOsProcessorTable_handler,
cpqLinOsProcessorTable_oid,
cpqLinOsProcessorTable_oid_len,
HANDLER_CAN_RONLY);
if (NULL == reg) {
snmp_log(LOG_ERR,
"error creating handler registration for cpqLinOsProcessorTable\n");
goto bail;
}
container = netsnmp_container_find("cpqLinOsProcessorTable:table_container");
if (NULL == container) {
snmp_log(LOG_ERR, "error creating container for cpqLinOsProcessorTable\n");
goto bail;
}
container->container_name = strdup("cpqLinOsProcessorTable container");
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (NULL == table_info) {
snmp_log(LOG_ERR,
"error allocating table registration for cpqLinOsProcessorTable\n");
goto bail;
}
netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, /* index: cpqLinOsCpuIndex */
0);
table_info->min_column = COLUMN_CPQLINOSCPUINDEX;
table_info->max_column = COLUMN_CPQLINOSCPUPRIVILEGEDTIMEPERCENT;
/*************************************************
*
* inject container_table helper
*/
handler = netsnmp_container_table_handler_get(table_info, container,
TABLE_CONTAINER_KEY_NETSNMP_INDEX);
if (NULL == handler) {
snmp_log(LOG_ERR,
"error allocating table registration for cpqLinOsProcessorTable\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,
"error injecting container_table handler for cpqLinOsProcessorTable\n");
goto bail;
}
handler = NULL; /* reg has it, will reuse below */
/*************************************************
*
* inject cache helper
*/
cache = netsnmp_cache_create(5, /* timeout in seconds */
_cache_load, _cache_free,
cpqLinOsProcessorTable_oid,
cpqLinOsProcessorTable_oid_len);
if (NULL == cache) {
snmp_log(LOG_ERR,
"error creating cache for cpqLinOsProcessorTable\n");
goto bail;
}
cache->flags = NETSNMP_CACHE_PRELOAD |
NETSNMP_CACHE_DONT_FREE_EXPIRED |
NETSNMP_CACHE_DONT_AUTO_RELEASE |
NETSNMP_CACHE_DONT_FREE_BEFORE_LOAD |
NETSNMP_CACHE_DONT_INVALIDATE_ON_SET;
cache->magic = container;
handler = netsnmp_cache_handler_get(cache);
if (NULL == handler) {
snmp_log(LOG_ERR,
"error creating cache handler for cpqLinOsProcessorTable\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,
"error injecting cache handler for cpqLinOsProcessorTable\n");
goto bail;
}
handler = NULL; /* reg has it */
/*
* register the table
*/
if (SNMPERR_SUCCESS != netsnmp_register_table(reg, table_info)) {
snmp_log(LOG_ERR,
"error registering table handler for cpqLinOsProcessorTable\n");
reg = NULL; /* it was freed inside netsnmp_register_table */
goto bail;
}
return; /* ok */
/*
* Some error occurred during registration. Clean up and bail.
*/
bail: /* not ok */
if (handler)
netsnmp_handler_free(handler);
if (cache)
netsnmp_cache_free(cache);
if (table_info)
netsnmp_table_registration_info_free(table_info);
if (container)
CONTAINER_FREE(container);
if (reg)
netsnmp_handler_registration_free(reg);
}
/** Initialize the hrSWRunTable table by defining its contents and how it's structured */
void
initialize_table_hrSWRunTable(void)
{
netsnmp_handler_registration *reg;
netsnmp_mib_handler *handler = NULL;
#ifndef NETSNMP_NO_WRITE_SUPPORT
#ifdef NETSNMP_INCLUDE_HRSWRUN_WRITE_SUPPORT
# define SWRUN_ACCESS_LEVEL HANDLER_CAN_RWRITE
#else
# define SWRUN_ACCESS_LEVEL HANDLER_CAN_RONLY
#endif
#else /* !NETSNMP_NO_WRITE_SUPPORT */
# define SWRUN_ACCESS_LEVEL HANDLER_CAN_RONLY
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
reg =
netsnmp_create_handler_registration(MYTABLE,
hrSWRunTable_handler,
hrSWRunTable_oid,
hrSWRunTable_oid_len,
SWRUN_ACCESS_LEVEL);
if (NULL == reg) {
snmp_log(LOG_ERR,"error creating handler registration for "
MYTABLE "\n");
goto bail;
}
reg->modes |= HANDLER_CAN_NOT_CREATE;
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (NULL == table_info) {
snmp_log(LOG_ERR,"error allocating table registration for "
MYTABLE "\n");
goto bail;
}
netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, /* index: hrSWRunIndex */
0);
table_info->min_column = COLUMN_HRSWRUNINDEX;
table_info->max_column = COLUMN_HRSWRUNSTATUS;
/*************************************************
*
* inject container_table helper
*/
handler = netsnmp_container_table_handler_get(table_info, netsnmp_swrun_container(),
TABLE_CONTAINER_KEY_NETSNMP_INDEX);
if (NULL == handler) {
snmp_log(LOG_ERR,"error allocating table registration for "
MYTABLE "\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,"error injecting container_table handler for "
MYTABLE "\n");
goto bail;
}
handler = NULL; /* reg has it, will reuse below */
/*************************************************
*
* inject cache helper
*/
handler = netsnmp_cache_handler_get(netsnmp_swrun_cache());
if (NULL == handler) {
snmp_log(LOG_ERR, "error creating cache handler for " MYTABLE "\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,"error injecting cache handler for "
MYTABLE "\n");
goto bail;
}
handler = NULL; /* reg has it*/
if (SNMPERR_SUCCESS != netsnmp_register_table(reg, table_info)) {
snmp_log(LOG_ERR,"error registering table handler for "
MYTABLE "\n");
reg = NULL; /* it was freed inside netsnmp_register_table */
goto bail;
}
return; /* ok */
bail: /* not ok */
if (handler)
netsnmp_handler_free(handler);
if (table_info)
netsnmp_table_registration_info_free(table_info);
if (reg)
netsnmp_handler_registration_free(reg);
}
/** Initialize the sctpAssocTable table by defining its contents and how it's structured */
void
initialize_table_sctpAssocTable(void)
{
static oid sctpAssocTable_oid[] = { 1, 3, 6, 1, 2, 1, 104, 1, 3 };
size_t sctpAssocTable_oid_len =
OID_LENGTH(sctpAssocTable_oid);
netsnmp_handler_registration *reg = NULL;
netsnmp_mib_handler *handler = NULL;
netsnmp_container *container = NULL;
netsnmp_table_registration_info *table_info = NULL;
netsnmp_cache *cache = NULL;
reg =
netsnmp_create_handler_registration("sctpAssocTable",
sctpAssocTable_handler,
sctpAssocTable_oid,
sctpAssocTable_oid_len,
HANDLER_CAN_RWRITE);
if (NULL == reg) {
snmp_log(LOG_ERR,
"error creating handler registration for sctpAssocTable\n");
goto bail;
}
/** should a set on a non-existent row create a new one? */
/** reg->modes |= HANDLER_CAN_NOT_CREATE; */
container = netsnmp_container_find("sctpAssocTable:table_container");
if (NULL == container) {
snmp_log(LOG_ERR, "error creating container for sctpAssocTable\n");
goto bail;
}
sctpAssocTable_container = container;
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (NULL == table_info) {
snmp_log(LOG_ERR,
"error allocating table registration for sctpAssocTable\n");
goto bail;
}
netsnmp_table_helper_add_indexes(table_info, ASN_UNSIGNED, /* index: sctpAssocId */
0);
table_info->min_column = COLUMN_SCTPASSOCREMHOSTNAME;
table_info->max_column = COLUMN_SCTPASSOCDISCONTINUITYTIME;
/*************************************************
*
* inject container_table helper
*/
handler = netsnmp_container_table_handler_get(table_info, container,
TABLE_CONTAINER_KEY_NETSNMP_INDEX);
if (NULL == handler) {
snmp_log(LOG_ERR,
"error allocating table registration for sctpAssocTable\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,
"error injecting container_table handler for sctpAssocTable\n");
goto bail;
}
handler = NULL; /* reg has it, will reuse below */
/*************************************************
*
* inject cache helper
*/
cache = netsnmp_cache_create(SCTP_TABLES_CACHE_TIMEOUT, /* timeout in seconds */
_cache_load, _cache_free,
sctpAssocTable_oid,
sctpAssocTable_oid_len);
if (NULL == cache) {
snmp_log(LOG_ERR, "error creating cache for sctpAssocTable\n");
goto bail;
}
cache->flags = NETSNMP_CACHE_DONT_INVALIDATE_ON_SET
| NETSNMP_CACHE_AUTO_RELOAD | NETSNMP_CACHE_PRELOAD;
cache->magic = container;
handler = netsnmp_cache_handler_get(cache);
if (NULL == handler) {
snmp_log(LOG_ERR,
"error creating cache handler for sctpAssocTable\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,
"error injecting cache handler for sctpAssocTable\n");
goto bail;
}
handler = NULL; /* reg has it */
/*
* register the table
*/
if (SNMPERR_SUCCESS != netsnmp_register_table(reg, table_info)) {
snmp_log(LOG_ERR,
"error registering table handler for sctpAssocTable\n");
goto bail;
}
/*
* Initialise the contents of the table here
*/
return; /* ok */
/*
* Some error occurred during registration. Clean up and bail.
*/
bail: /* not ok */
if (handler)
netsnmp_handler_free(handler);
if (container)
CONTAINER_FREE(container);
if (reg)
netsnmp_handler_registration_free(reg);
}
int
netsnmp_table_row_register(netsnmp_handler_registration *reginfo,
netsnmp_table_registration_info *tabreg,
void *row, netsnmp_variable_list *index)
{
netsnmp_handler_registration *reg2;
netsnmp_mib_handler *handler;
oid row_oid[MAX_OID_LEN];
size_t row_oid_len, len;
char tmp[SNMP_MAXBUF_MEDIUM];
if ((NULL == reginfo) || (NULL == reginfo->handler) || (NULL == tabreg)) {
snmp_log(LOG_ERR, "bad param in netsnmp_table_row_register\n");
netsnmp_handler_registration_free(reginfo);
return SNMPERR_GENERR;
}
/*
* The first table_row invoked for a particular table should
* register the full table as well, with a default handler to
* process requests for non-existent (or incomplete) rows.
*
* Subsequent table_row registrations attempting to set up
* this default handler would fail - preferably silently!
*/
snprintf(tmp, sizeof(tmp), "%s_table", reginfo->handlerName);
reg2 = netsnmp_create_handler_registration(
tmp, _table_row_default_handler,
reginfo->rootoid, reginfo->rootoid_len,
reginfo->modes);
netsnmp_register_table(reg2, tabreg); /* Ignore return value */
/*
* Adjust the OID being registered, to take account
* of the indexes and column range provided....
*/
row_oid_len = reginfo->rootoid_len;
memcpy( row_oid, (u_char *) reginfo->rootoid, row_oid_len * sizeof(oid));
row_oid[row_oid_len++] = 1; /* tableEntry */
row_oid[row_oid_len++] = tabreg->min_column;
reginfo->range_ubound = tabreg->max_column;
reginfo->range_subid = row_oid_len-1;
build_oid_noalloc(&row_oid[row_oid_len],
MAX_OID_LEN-row_oid_len, &len, NULL, 0, index);
row_oid_len += len;
free(reginfo->rootoid);
reginfo->rootoid = snmp_duplicate_objid(row_oid, row_oid_len);
reginfo->rootoid_len = row_oid_len;
/*
* ... insert a minimal handler ...
*/
handler = netsnmp_table_row_handler_get(row);
if (!handler ||
(netsnmp_inject_handler(reginfo, handler) != SNMPERR_SUCCESS)) {
snmp_log(LOG_ERR, "could not create table row handler\n");
netsnmp_handler_free(handler);
netsnmp_handler_registration_free(reginfo);
return SNMP_ERR_GENERR;
}
/*
* ... and register the row
*/
return netsnmp_register_handler(reginfo);
}
/** Initialize the cpqNicIfLogMapTable table by defining its contents and how it's structured */
void
initialize_table_cpqNicIfLogMapTable(void)
{
const oid cpqNicIfLogMapTable_oid[] =
{ 1, 3, 6, 1, 4, 1, 232, 18, 2, 2, 1 };
const size_t cpqNicIfLogMapTable_oid_len =
OID_LENGTH(cpqNicIfLogMapTable_oid);
netsnmp_handler_registration *reg = NULL;
netsnmp_mib_handler *handler = NULL;
netsnmp_container *container = NULL;
netsnmp_table_registration_info *table_info = NULL;
netsnmp_cache *cache = NULL;
int reg_tbl_ret = SNMPERR_SUCCESS;
DEBUGMSGTL(("cpqNicIfLogMapTable:init",
"initializing table cpqNicIfLogMapTable\n"));
reg =
netsnmp_create_handler_registration("cpqNicIfLogMapTable",
cpqNicIfLogMapTable_handler,
cpqNicIfLogMapTable_oid,
cpqNicIfLogMapTable_oid_len,
HANDLER_CAN_RONLY);
if (NULL == reg) {
snmp_log(LOG_ERR,
"error creating handler registration for cpqNicIfLogMapTable\n");
goto bail;
}
container =
netsnmp_container_find("cpqNicIfLogMapTable:table_container");
if (NULL == container) {
snmp_log(LOG_ERR,
"error creating container for cpqNicIfLogMapTable\n");
goto bail;
}
container->container_name = strdup("cpqNicIfLogMapTable container");
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (NULL == table_info) {
snmp_log(LOG_ERR,
"error allocating table registration for cpqNicIfLogMapTable\n");
goto bail;
}
netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, /* index: cpqNicIfLogMapIndex */
0);
table_info->min_column = COLUMN_CPQNICIFLOGMAPINDEX;
table_info->max_column = COLUMN_CPQNICIFLOGMAPPCILOCATION;
/*************************************************
*
* inject container_table helper
*/
handler = netsnmp_container_table_handler_get(table_info, container,
TABLE_CONTAINER_KEY_NETSNMP_INDEX);
if (NULL == handler) {
snmp_log(LOG_ERR,
"error allocating table registration for cpqNicIfLogMapTable\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,
"error injecting container_table handler for cpqNicIfLogMapTable\n");
goto bail;
}
handler = NULL; /* reg has it, will reuse below */
/*************************************************
*
* inject cache helper
*/
cache = netsnmp_cache_create(30, /* timeout in seconds */
_cache_load, _cache_free,
cpqNicIfLogMapTable_oid,
cpqNicIfLogMapTable_oid_len);
if (NULL == cache) {
snmp_log(LOG_ERR,
"error creating cache for cpqNicIfLogMapTable\n");
goto bail;
}
cache->flags = NETSNMP_CACHE_PRELOAD |
NETSNMP_CACHE_DONT_FREE_EXPIRED |
NETSNMP_CACHE_DONT_AUTO_RELEASE |
NETSNMP_CACHE_DONT_FREE_BEFORE_LOAD |
NETSNMP_CACHE_DONT_INVALIDATE_ON_SET;
cache->magic = container;
handler = netsnmp_cache_handler_get(cache);
if (NULL == handler) {
snmp_log(LOG_ERR,
"error creating cache handler for cpqNicIfLogMapTable\n");
goto bail;
}
if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) {
snmp_log(LOG_ERR,
"error injecting cache handler for cpqNicIfLogMapTable\n");
goto bail;
}
handler = NULL; /* reg has it */
/*
* register the table
*/
reg_tbl_ret = netsnmp_register_table(reg, table_info);
if (reg_tbl_ret != SNMPERR_SUCCESS) {
snmp_log(LOG_ERR,
"error registering table handler for cpqNicIfLogMapTable\n");
goto bail;
}
return; /* ok */
/*
* Some error occurred during registration. Clean up and bail.
*/
bail: /* not ok */
if (handler)
netsnmp_handler_free(handler);
if (cache)
netsnmp_cache_free(cache);
if (table_info)
netsnmp_table_registration_info_free(table_info);
if (container)
CONTAINER_FREE(container);
if (reg_tbl_ret == SNMPERR_SUCCESS)
if (reg)
netsnmp_handler_registration_free(reg);
}