/** Initializes the expValueTable module */
void
init_expValueTable(void)
{
static oid expValueTable_oid[] = { 1, 3, 6, 1, 2, 1, 90, 1, 3, 1 };
size_t expValueTable_oid_len = OID_LENGTH(expValueTable_oid);
netsnmp_handler_registration *reg;
netsnmp_table_registration_info *table_info;
reg =
netsnmp_create_handler_registration("expValueTable",
expValueTable_handler,
expValueTable_oid,
expValueTable_oid_len,
HANDLER_CAN_RONLY);
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
netsnmp_table_helper_add_indexes(table_info,
ASN_OCTET_STR, /* expExpressionOwner */
ASN_OCTET_STR, /* expExpressionName */
/* expValueInstance */
ASN_PRIV_IMPLIED_OBJECT_ID,
0);
table_info->min_column = COLUMN_EXPVALUECOUNTER32VAL;
table_info->max_column = COLUMN_EXPVALUECOUNTER64VAL;
netsnmp_register_table(reg, table_info);
DEBUGMSGTL(("disman:expr:init", "Expression Value Table\n"));
}
/** registers a handler as a data table.
* If table_info != NULL, it registers it as a normal table too. */
int
netsnmp_register_table_data(netsnmp_handler_registration *reginfo,
netsnmp_table_data *table,
netsnmp_table_registration_info *table_info)
{
netsnmp_inject_handler(reginfo, netsnmp_get_table_data_handler(table));
return netsnmp_register_table(reginfo, table_info);
}
/**
* Creates and registers a table iterator helper handler calling
* netsnmp_create_handler with a handler name set to TABLE_ITERATOR_NAME
* and access method, netsnmp_table_iterator_helper_handler.
*
* If NOT_SERIALIZED is not defined the function injects the serialize
* handler into the calling chain prior to calling netsnmp_register_table.
*
* @param reginfo is a pointer to a netsnmp_handler_registration struct
*
* @param iinfo A pointer to a netsnmp_iterator_info struct. If the flag
* NETSNMP_HANDLER_OWNS_IINFO is not set in iinfo->flags, the caller remains
* the owner of this structure. And if the flag NETSNMP_HANDLER_OWNS_IINFO is
* set in iinfo->flags, ownership of this data structure is passed to the
* handler.
*
* @return MIB_REGISTERED_OK is returned if the registration was a success.
* Failures are MIB_REGISTRATION_FAILED, MIB_DUPLICATE_REGISTRATION.
* If iinfo is NULL, SNMPERR_GENERR is returned.
*
*/
int netsnmp_register_table_iterator (netsnmp_handler_registration * reginfo, netsnmp_iterator_info * iinfo)
{
#ifndef NETSNMP_FEATURE_REMOVE_STASH_CACHE
reginfo->modes |= HANDLER_CAN_STASH;
#endif /* NETSNMP_FEATURE_REMOVE_STASH_CACHE */
netsnmp_inject_handler (reginfo, netsnmp_get_table_iterator_handler (iinfo));
if (!iinfo)
return SNMPERR_GENERR;
if (!iinfo->indexes && iinfo->table_reginfo && iinfo->table_reginfo->indexes)
iinfo->indexes = snmp_clone_varbind (iinfo->table_reginfo->indexes);
return netsnmp_register_table (reginfo, iinfo->table_reginfo);
}
/** registers a table after attaching it to a table_iterator helper */
int
netsnmp_register_table_iterator(netsnmp_handler_registration *reginfo,
netsnmp_iterator_info *iinfo)
{
netsnmp_inject_handler(reginfo,
netsnmp_get_table_iterator_handler(iinfo));
if (!iinfo)
return SNMPERR_GENERR;
#ifndef NOT_SERIALIZED
netsnmp_inject_handler(reginfo, netsnmp_get_serialize_handler());
#endif
return netsnmp_register_table(reginfo, iinfo->table_reginfo);
}
/**
* Creates and registers a table iterator helper handler calling
* netsnmp_create_handler with a handler name set to TABLE_ITERATOR_NAME
* and access method, netsnmp_table_iterator_helper_handler.
*
* If NOT_SERIALIZED is not defined the function injects the serialize
* handler into the calling chain prior to calling netsnmp_register_table.
*
* @param reginfo is a pointer to a netsnmp_handler_registration struct
*
* @param iinfo is a pointer to a netsnmp_iterator_info struct
*
* @return MIB_REGISTERED_OK is returned if the registration was a success.
* Failures are MIB_REGISTRATION_FAILED, MIB_DUPLICATE_REGISTRATION.
* If iinfo is NULL, SNMPERR_GENERR is returned.
*
*/
int
netsnmp_register_table_iterator(netsnmp_handler_registration *reginfo,
netsnmp_iterator_info *iinfo)
{
reginfo->modes |= HANDLER_CAN_STASH;
netsnmp_inject_handler(reginfo,
netsnmp_get_table_iterator_handler(iinfo));
if (!iinfo)
return SNMPERR_GENERR;
if (!iinfo->indexes && iinfo->table_reginfo &&
iinfo->table_reginfo->indexes )
iinfo->indexes = snmp_clone_varbind( iinfo->table_reginfo->indexes );
return netsnmp_register_table(reginfo, iinfo->table_reginfo);
}
/** register specified callbacks for the specified table/oid. If the
group_rows parameter is set, the row related callbacks will be
called once for each unique row index. Otherwise, each callback
will be called only once, for all objects.
*/
int
netsnmp_table_container_register (netsnmp_handler_registration * reginfo,
netsnmp_table_registration_info * tabreg,
netsnmp_table_array_callbacks * cb, netsnmp_container * container, int group_rows)
{
table_container_data *tad = SNMP_MALLOC_TYPEDEF (table_container_data);
if (!tad)
return SNMPERR_GENERR;
tad->tblreg_info = tabreg; /* we need it too, but it really is not ours */
if (!cb)
{
snmp_log (LOG_ERR, "table_array registration with no callbacks\n");
free (tad); /* SNMP_FREE is overkill for local var */
return SNMPERR_GENERR;
}
/*
* check for required callbacks
*/
if ((cb->can_set && ((NULL == cb->duplicate_row) || (NULL == cb->delete_row) || (NULL == cb->row_copy))))
{
snmp_log (LOG_ERR, "table_array registration with incomplete " "callback structure.\n");
free (tad); /* SNMP_FREE is overkill for local var */
return SNMPERR_GENERR;
}
if (NULL == container)
{
tad->table = netsnmp_container_find ("table_array");
snmp_log (LOG_ERR, "table_array couldn't allocate container\n");
free (tad); /* SNMP_FREE is overkill for local var */
return SNMPERR_GENERR;
}
else
tad->table = container;
if (NULL == tad->table->compare)
tad->table->compare = netsnmp_compare_netsnmp_index;
if (NULL == tad->table->ncompare)
tad->table->ncompare = netsnmp_ncompare_netsnmp_index;
tad->cb = cb;
reginfo->handler->myvoid = tad;
return netsnmp_register_table (reginfo, tabreg);
}
/**
* @internal
* Initialize the table dot11ConfTotalTrapGroupTable
* (Define its contents and how it's structured)
*/
void
_dot11ConfTotalTrapGroupTable_initialize_interface(dot11ConfTotalTrapGroupTable_registration_ptr reg_ptr, u_long flags)
{
netsnmp_baby_steps_access_methods *access_multiplexer =
&dot11ConfTotalTrapGroupTable_if_ctx.access_multiplexer;
netsnmp_table_registration_info *tbl_info = &dot11ConfTotalTrapGroupTable_if_ctx.tbl_info;
netsnmp_handler_registration *reginfo;
netsnmp_mib_handler *handler;
int mfd_modes = 0;
DEBUGMSGTL(("internal:dot11ConfTotalTrapGroupTable:_dot11ConfTotalTrapGroupTable_initialize_interface","called\n"));
/*************************************************
*
* save interface context for dot11ConfTotalTrapGroupTable
*/
/*
* Setting up the table's definition
*/
netsnmp_table_helper_add_indexes(tbl_info,
ASN_INTEGER, /** index: NewTrapIndex */
0);
/* Define the minimum and maximum accessible columns. This
optimizes retrival. */
tbl_info->min_column = DOT11CONFTOTALTRAPGROUPTABLE_MIN_COL;
tbl_info->max_column = DOT11CONFTOTALTRAPGROUPTABLE_MAX_COL;
/*
* save users context
*/
dot11ConfTotalTrapGroupTable_if_ctx.user_ctx = reg_ptr;
/*
* call data access initialization code
*/
dot11ConfTotalTrapGroupTable_init_data(reg_ptr);
/*
* set up the container
*/
_dot11ConfTotalTrapGroupTable_container_init(&dot11ConfTotalTrapGroupTable_if_ctx);
if (NULL == dot11ConfTotalTrapGroupTable_if_ctx.container) {
snmp_log(LOG_ERR,"could not initialize container for dot11ConfTotalTrapGroupTable\n");
return;
}
/*
* access_multiplexer: REQUIRED wrapper for get request handling
*/
access_multiplexer->object_lookup = _mfd_dot11ConfTotalTrapGroupTable_object_lookup;
access_multiplexer->get_values = _mfd_dot11ConfTotalTrapGroupTable_get_values;
/*
* no wrappers yet
*/
access_multiplexer->pre_request = _mfd_dot11ConfTotalTrapGroupTable_pre_request;
access_multiplexer->post_request = _mfd_dot11ConfTotalTrapGroupTable_post_request;
/*
* REQUIRED wrappers for set request handling
*/
access_multiplexer->object_syntax_checks = _mfd_dot11ConfTotalTrapGroupTable_check_objects;
access_multiplexer->undo_setup = _mfd_dot11ConfTotalTrapGroupTable_undo_setup;
access_multiplexer->undo_cleanup = _mfd_dot11ConfTotalTrapGroupTable_undo_cleanup;
access_multiplexer->set_values = _mfd_dot11ConfTotalTrapGroupTable_set_values;
access_multiplexer->undo_sets = _mfd_dot11ConfTotalTrapGroupTable_undo_values;
/*
* no wrappers yet
*/
access_multiplexer->commit = _mfd_dot11ConfTotalTrapGroupTable_commit;
access_multiplexer->undo_commit = _mfd_dot11ConfTotalTrapGroupTable_undo_commit;
/*
* REQUIRED for tables with dependencies
*/
access_multiplexer->consistency_checks = _mfd_dot11ConfTotalTrapGroupTable_check_dependencies;
/*************************************************
*
* Create a registration, save our reg data, register table.
*/
DEBUGMSGTL(("dot11ConfTotalTrapGroupTable:init_dot11ConfTotalTrapGroupTable",
"Registering dot11ConfTotalTrapGroupTable as a mibs-for-dummies table.\n"));
handler = netsnmp_baby_steps_access_multiplexer_get(access_multiplexer);
reginfo = netsnmp_handler_registration_create("dot11ConfTotalTrapGroupTable", handler,
dot11ConfTotalTrapGroupTable_oid,
dot11ConfTotalTrapGroupTable_oid_size,
HANDLER_CAN_BABY_STEP |
HANDLER_CAN_RWRITE
);
if(NULL == reginfo) {
snmp_log(LOG_ERR,"error registering table dot11ConfTotalTrapGroupTable\n");
return;
}
reginfo->my_reg_void = &dot11ConfTotalTrapGroupTable_if_ctx;
/*************************************************
*
* set up baby steps handler, create it and inject it
*/
if( access_multiplexer->object_lookup )
mfd_modes |= BABY_STEP_OBJECT_LOOKUP;
if( access_multiplexer->set_values )
mfd_modes |= BABY_STEP_SET_VALUES;
if( access_multiplexer->irreversible_commit )
mfd_modes |= BABY_STEP_IRREVERSIBLE_COMMIT;
if( access_multiplexer->object_syntax_checks )
mfd_modes |= BABY_STEP_CHECK_OBJECT;
if( access_multiplexer->pre_request )
mfd_modes |= BABY_STEP_PRE_REQUEST;
if( access_multiplexer->post_request )
mfd_modes |= BABY_STEP_POST_REQUEST;
if( access_multiplexer->undo_setup )
mfd_modes |= BABY_STEP_UNDO_SETUP;
if( access_multiplexer->undo_cleanup )
mfd_modes |= BABY_STEP_UNDO_CLEANUP;
if( access_multiplexer->undo_sets )
mfd_modes |= BABY_STEP_UNDO_SETS;
if( access_multiplexer->row_creation )
mfd_modes |= BABY_STEP_ROW_CREATE;
if( access_multiplexer->consistency_checks )
mfd_modes |= BABY_STEP_CHECK_CONSISTENCY;
if( access_multiplexer->commit )
mfd_modes |= BABY_STEP_COMMIT;
if( access_multiplexer->undo_commit )
mfd_modes |= BABY_STEP_UNDO_COMMIT;
handler = netsnmp_baby_steps_handler_get(mfd_modes);
netsnmp_inject_handler(reginfo, handler);
/*************************************************
*
* inject row_merge helper with prefix rootoid_len + 2 (entry.col)
*/
handler = netsnmp_get_row_merge_handler(reginfo->rootoid_len + 2);
netsnmp_inject_handler(reginfo, handler);
/*************************************************
*
* inject container_table helper
*/
handler =
netsnmp_container_table_handler_get(tbl_info,
dot11ConfTotalTrapGroupTable_if_ctx.container,
TABLE_CONTAINER_KEY_NETSNMP_INDEX);
netsnmp_inject_handler( reginfo, handler );
/*************************************************
*
* inject cache helper
*/
if(NULL != dot11ConfTotalTrapGroupTable_if_ctx.cache) {
handler = netsnmp_cache_handler_get(dot11ConfTotalTrapGroupTable_if_ctx.cache);
netsnmp_inject_handler( reginfo, handler );
}
/*
* register table
*/
netsnmp_register_table(reginfo, tbl_info);
} /* _dot11ConfTotalTrapGroupTable_initialize_interface */
/**
* @internal
* Initialize the table ipDefaultRouterTable
* (Define its contents and how it's structured)
*/
void
_ipDefaultRouterTable_initialize_interface
(ipDefaultRouterTable_registration * reg_ptr, u_long flags)
{
netsnmp_baby_steps_access_methods *access_multiplexer =
&ipDefaultRouterTable_if_ctx.access_multiplexer;
netsnmp_table_registration_info *tbl_info =
&ipDefaultRouterTable_if_ctx.tbl_info;
netsnmp_handler_registration *reginfo;
netsnmp_mib_handler *handler;
int mfd_modes = 0;
DEBUGMSGTL(("internal:ipDefaultRouterTable:_ipDefaultRouterTable_initialize_interface", "called\n"));
/*************************************************
*
* save interface context for ipDefaultRouterTable
*/
/*
* Setting up the table's definition
*/
netsnmp_table_helper_add_indexes(tbl_info, ASN_INTEGER,
/** index: ipDefaultRouterAddressType */
ASN_OCTET_STR,
/** index: ipDefaultRouterAddress */
ASN_INTEGER,
/** index: ipDefaultRouterIfIndex */
0);
/*
* Define the minimum and maximum accessible columns. This
* optimizes retrieval.
*/
tbl_info->min_column = IPDEFAULTROUTERTABLE_MIN_COL;
tbl_info->max_column = IPDEFAULTROUTERTABLE_MAX_COL;
/*
* save users context
*/
ipDefaultRouterTable_if_ctx.user_ctx = reg_ptr;
/*
* call data access initialization code
*/
ipDefaultRouterTable_init_data(reg_ptr);
/*
* set up the container
*/
_ipDefaultRouterTable_container_init(&ipDefaultRouterTable_if_ctx);
if (NULL == ipDefaultRouterTable_if_ctx.container) {
snmp_log(LOG_ERR,
"could not initialize container for ipDefaultRouterTable\n");
return;
}
/*
* access_multiplexer: REQUIRED wrapper for get request handling
*/
access_multiplexer->object_lookup =
_mfd_ipDefaultRouterTable_object_lookup;
access_multiplexer->get_values = _mfd_ipDefaultRouterTable_get_values;
/*
* no wrappers yet
*/
access_multiplexer->pre_request =
_mfd_ipDefaultRouterTable_pre_request;
access_multiplexer->post_request =
_mfd_ipDefaultRouterTable_post_request;
/*************************************************
*
* Create a registration, save our reg data, register table.
*/
DEBUGMSGTL(("ipDefaultRouterTable:init_ipDefaultRouterTable",
"Registering ipDefaultRouterTable as a mibs-for-dummies table.\n"));
handler =
netsnmp_baby_steps_access_multiplexer_get(access_multiplexer);
reginfo =
netsnmp_handler_registration_create("ipDefaultRouterTable",
handler,
ipDefaultRouterTable_oid,
ipDefaultRouterTable_oid_size,
HANDLER_CAN_BABY_STEP |
HANDLER_CAN_RONLY);
if (NULL == reginfo) {
snmp_log(LOG_ERR,
"error registering table ipDefaultRouterTable\n");
return;
}
reginfo->my_reg_void = &ipDefaultRouterTable_if_ctx;
/*************************************************
*
* set up baby steps handler, create it and inject it
*/
if (access_multiplexer->object_lookup)
mfd_modes |= BABY_STEP_OBJECT_LOOKUP;
if (access_multiplexer->pre_request)
mfd_modes |= BABY_STEP_PRE_REQUEST;
if (access_multiplexer->post_request)
mfd_modes |= BABY_STEP_POST_REQUEST;
#ifndef NETSNMP_DISABLE_SET_SUPPORT
/* XXX - are these actually necessary? */
if (access_multiplexer->set_values)
mfd_modes |= BABY_STEP_SET_VALUES;
if (access_multiplexer->irreversible_commit)
mfd_modes |= BABY_STEP_IRREVERSIBLE_COMMIT;
if (access_multiplexer->object_syntax_checks)
mfd_modes |= BABY_STEP_CHECK_OBJECT;
if (access_multiplexer->undo_setup)
mfd_modes |= BABY_STEP_UNDO_SETUP;
if (access_multiplexer->undo_cleanup)
mfd_modes |= BABY_STEP_UNDO_CLEANUP;
if (access_multiplexer->undo_sets)
mfd_modes |= BABY_STEP_UNDO_SETS;
if (access_multiplexer->row_creation)
mfd_modes |= BABY_STEP_ROW_CREATE;
if (access_multiplexer->consistency_checks)
mfd_modes |= BABY_STEP_CHECK_CONSISTENCY;
if (access_multiplexer->commit)
mfd_modes |= BABY_STEP_COMMIT;
if (access_multiplexer->undo_commit)
mfd_modes |= BABY_STEP_UNDO_COMMIT;
#endif
handler = netsnmp_baby_steps_handler_get(mfd_modes);
netsnmp_inject_handler(reginfo, handler);
/*************************************************
*
* inject row_merge helper with prefix rootoid_len + 2 (entry.col)
*/
handler = netsnmp_get_row_merge_handler(reginfo->rootoid_len + 2);
netsnmp_inject_handler(reginfo, handler);
/*************************************************
*
* inject container_table helper
*/
handler =
netsnmp_container_table_handler_get(tbl_info,
ipDefaultRouterTable_if_ctx.
container,
TABLE_CONTAINER_KEY_NETSNMP_INDEX);
netsnmp_inject_handler(reginfo, handler);
/*************************************************
*
* inject cache helper
*/
if (NULL != ipDefaultRouterTable_if_ctx.cache) {
handler =
netsnmp_cache_handler_get(ipDefaultRouterTable_if_ctx.cache);
netsnmp_inject_handler(reginfo, handler);
}
/*
* register table
*/
netsnmp_register_table(reginfo, tbl_info);
} /* _ipDefaultRouterTable_initialize_interface */
/** 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 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);
}
void
init_testhandler(void)
{
/*
* we're registering at .1.2.3.4
*/
netsnmp_handler_registration *my_test;
netsnmp_table_registration_info *table_info;
u_long ind1;
netsnmp_table_data *table;
netsnmp_table_data_set *table_set;
netsnmp_table_row *row;
DEBUGMSGTL(("testhandler", "initializing\n"));
/*
* basic handler test
*/
netsnmp_register_handler(netsnmp_create_handler_registration
("myTest", my_test_handler, my_test_oid, 4,
HANDLER_CAN_RONLY));
/*
* instance handler test
*/
netsnmp_register_instance(netsnmp_create_handler_registration
("myInstance", my_test_instance_handler,
my_instance_oid, 5, HANDLER_CAN_RWRITE));
netsnmp_register_ulong_instance("myulong",
my_data_ulong_instance, 4,
&my_ulong, NULL);
/*
* table helper test
*/
my_test = netsnmp_create_handler_registration("myTable",
my_test_table_handler,
my_table_oid, 4,
HANDLER_CAN_RONLY);
if (!my_test)
return;
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (table_info == NULL)
return;
netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, ASN_INTEGER,
0);
table_info->min_column = 3;
table_info->max_column = 3;
netsnmp_register_table(my_test, table_info);
/*
* data table helper test
*/
/*
* we'll construct a simple table here with two indexes: an
* integer and a string (why not). It'll contain only one
* column so the data pointer is merely the data in that
* column.
*/
table = netsnmp_create_table_data("data_table_test");
netsnmp_table_data_add_index(table, ASN_INTEGER);
netsnmp_table_data_add_index(table, ASN_OCTET_STR);
/*
* 1 partridge in a pear tree
*/
row = netsnmp_create_table_data_row();
ind1 = 1;
netsnmp_table_row_add_index(row, ASN_INTEGER, &ind1, sizeof(ind1));
netsnmp_table_row_add_index(row, ASN_OCTET_STR, "partridge",
strlen("partridge"));
row->data = (void *) "pear tree";
netsnmp_table_data_add_row(table, row);
/*
* 2 turtle doves
*/
row = netsnmp_create_table_data_row();
ind1 = 2;
netsnmp_table_row_add_index(row, ASN_INTEGER, &ind1, sizeof(ind1));
netsnmp_table_row_add_index(row, ASN_OCTET_STR, "turtle",
strlen("turtle"));
row->data = (void *) "doves";
netsnmp_table_data_add_row(table, row);
/*
* we're going to register it as a normal table too, so we get the
* automatically parsed column and index information
*/
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (table_info == NULL)
return;
netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER,
ASN_OCTET_STR, 0);
table_info->min_column = 3;
table_info->max_column = 3;
netsnmp_register_read_only_table_data
(netsnmp_create_handler_registration
("12days", my_data_table_handler, my_data_table_oid, 4,
HANDLER_CAN_RONLY), table, table_info);
}
/** 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);
}
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");
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);
memdup((u_char **) & reginfo->rootoid, (const u_char *) row_oid,
row_oid_len * sizeof(oid));
reginfo->rootoid_len = row_oid_len;
/*
* ... insert a minimal handler ...
*/
handler = netsnmp_table_row_handler_get(row);
netsnmp_inject_handler(reginfo, handler );
/*
* ... and register the row
*/
return netsnmp_register_handler(reginfo);
}
/** 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);
}
/** 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);
}
/** 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);
}
/**
* @internal
* Initialize the table ipv4InterfaceTable
* (Define its contents and how it's structured)
*/
void
_ipv4InterfaceTable_initialize_interface(ipv4InterfaceTable_registration *
reg_ptr, u_long flags)
{
netsnmp_baby_steps_access_methods *access_multiplexer =
&ipv4InterfaceTable_if_ctx.access_multiplexer;
netsnmp_table_registration_info *tbl_info =
&ipv4InterfaceTable_if_ctx.tbl_info;
netsnmp_handler_registration *reginfo;
netsnmp_mib_handler *handler;
int mfd_modes = 0;
DEBUGMSGTL(("internal:ipv4InterfaceTable:_ipv4InterfaceTable_initialize_interface", "called\n"));
/*************************************************
*
* save interface context for ipv4InterfaceTable
*/
/*
* Setting up the table's definition
*/
netsnmp_table_helper_add_indexes(tbl_info, ASN_INTEGER,
/** index: ipv4InterfaceIfIndex */
0);
/*
* Define the minimum and maximum accessible columns. This
* optimizes retrival.
*/
tbl_info->min_column = IPV4INTERFACETABLE_MIN_COL;
tbl_info->max_column = IPV4INTERFACETABLE_MAX_COL;
/*
* save users context
*/
ipv4InterfaceTable_if_ctx.user_ctx = reg_ptr;
/*
* call data access initialization code
*/
ipv4InterfaceTable_init_data(reg_ptr);
/*
* set up the container
*/
_ipv4InterfaceTable_container_init(&ipv4InterfaceTable_if_ctx);
if (NULL == ipv4InterfaceTable_if_ctx.container) {
snmp_log(LOG_ERR,
"could not initialize container for ipv4InterfaceTable\n");
return;
}
/*
* access_multiplexer: REQUIRED wrapper for get request handling
*/
access_multiplexer->object_lookup =
_mfd_ipv4InterfaceTable_object_lookup;
access_multiplexer->get_values = _mfd_ipv4InterfaceTable_get_values;
/*
* no wrappers yet
*/
access_multiplexer->pre_request = _mfd_ipv4InterfaceTable_pre_request;
access_multiplexer->post_request =
_mfd_ipv4InterfaceTable_post_request;
/*
* REQUIRED wrappers for set request handling
*/
access_multiplexer->object_syntax_checks =
_mfd_ipv4InterfaceTable_check_objects;
access_multiplexer->undo_setup = _mfd_ipv4InterfaceTable_undo_setup;
access_multiplexer->undo_cleanup =
_mfd_ipv4InterfaceTable_undo_cleanup;
access_multiplexer->set_values = _mfd_ipv4InterfaceTable_set_values;
access_multiplexer->undo_sets = _mfd_ipv4InterfaceTable_undo_values;
/*
* no wrappers yet
*/
access_multiplexer->commit = _mfd_ipv4InterfaceTable_commit;
access_multiplexer->undo_commit = _mfd_ipv4InterfaceTable_undo_commit;
access_multiplexer->irreversible_commit =
_mfd_ipv4InterfaceTable_irreversible_commit;
/*************************************************
*
* Create a registration, save our reg data, register table.
*/
DEBUGMSGTL(("ipv4InterfaceTable:init_ipv4InterfaceTable",
"Registering ipv4InterfaceTable as a mibs-for-dummies table.\n"));
handler =
netsnmp_baby_steps_access_multiplexer_get(access_multiplexer);
reginfo =
netsnmp_handler_registration_create("ipv4InterfaceTable", handler,
ipv4InterfaceTable_oid,
ipv4InterfaceTable_oid_size,
HANDLER_CAN_BABY_STEP |
HANDLER_CAN_RWRITE);
if (NULL == reginfo) {
snmp_log(LOG_ERR, "error registering table ipv4InterfaceTable\n");
return;
}
reginfo->my_reg_void = &ipv4InterfaceTable_if_ctx;
/*************************************************
*
* set up baby steps handler, create it and inject it
*/
if (access_multiplexer->object_lookup)
mfd_modes |= BABY_STEP_OBJECT_LOOKUP;
if (access_multiplexer->set_values)
mfd_modes |= BABY_STEP_SET_VALUES;
if (access_multiplexer->irreversible_commit)
mfd_modes |= BABY_STEP_IRREVERSIBLE_COMMIT;
if (access_multiplexer->object_syntax_checks)
mfd_modes |= BABY_STEP_CHECK_OBJECT;
if (access_multiplexer->pre_request)
mfd_modes |= BABY_STEP_PRE_REQUEST;
if (access_multiplexer->post_request)
mfd_modes |= BABY_STEP_POST_REQUEST;
if (access_multiplexer->undo_setup)
mfd_modes |= BABY_STEP_UNDO_SETUP;
if (access_multiplexer->undo_cleanup)
mfd_modes |= BABY_STEP_UNDO_CLEANUP;
if (access_multiplexer->undo_sets)
mfd_modes |= BABY_STEP_UNDO_SETS;
if (access_multiplexer->row_creation)
mfd_modes |= BABY_STEP_ROW_CREATE;
if (access_multiplexer->consistency_checks)
mfd_modes |= BABY_STEP_CHECK_CONSISTENCY;
if (access_multiplexer->commit)
mfd_modes |= BABY_STEP_COMMIT;
if (access_multiplexer->undo_commit)
mfd_modes |= BABY_STEP_UNDO_COMMIT;
handler = netsnmp_baby_steps_handler_get(mfd_modes);
netsnmp_inject_handler(reginfo, handler);
/*************************************************
*
* inject row_merge helper with prefix rootoid_len + 2 (entry.col)
*/
handler = netsnmp_get_row_merge_handler(reginfo->rootoid_len + 2);
netsnmp_inject_handler(reginfo, handler);
/*************************************************
*
* inject container_table helper
*/
handler =
netsnmp_container_table_handler_get(tbl_info,
ipv4InterfaceTable_if_ctx.
container,
TABLE_CONTAINER_KEY_NETSNMP_INDEX);
netsnmp_inject_handler(reginfo, handler);
/*
* register table
*/
netsnmp_register_table(reginfo, tbl_info);
/*
* register LastChanged
*/
{
oid lc_oid[] = { IPV4INTERFACETABLELASTCHANGE_OID };
netsnmp_register_watched_scalar(netsnmp_create_handler_registration
("ipv4TableLastChanged", NULL,
lc_oid, OID_LENGTH(lc_oid),
HANDLER_CAN_RONLY),
netsnmp_create_watcher_info((void
*)
&ipv4InterfaceTable_if_ctx.
last_changed,
sizeof
(u_long),
ASN_TIMETICKS,
WATCHER_FIXED_SIZE));
}
} /* _ipv4InterfaceTable_initialize_interface */
/** 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);
}
