void
shutdown_mteTriggerThresholdTable(void)
{
if (table_info) {
netsnmp_table_registration_info_free(table_info);
table_info = NULL;
}
}
void
shutdown_hrSWInstalledTable(void)
{
if (table_info) {
netsnmp_table_registration_info_free(table_info);
table_info = NULL;
}
}
void
shutdown_mteEventTable(void)
{
if (table_info) {
netsnmp_table_registration_info_free(table_info);
table_info = NULL;
}
}
void
shutdown_table_sctpLookupRemPortTable(void)
{
if (table_info) {
netsnmp_table_registration_info_free(table_info);
table_info = NULL;
}
sctpLookupRemPortTable_container_clear
(sctpLookupRemPortTable_container);
}
void
shutdown_table_sctpAssocTable(void)
{
if (table_info) {
netsnmp_table_registration_info_free(table_info);
table_info = NULL;
}
if (sctpAssocTable_container)
sctpAssocTable_container_clear(sctpAssocTable_container);
}
/** Free the memory that was allocated for a table iterator. */
void netsnmp_iterator_delete_table (netsnmp_iterator_info * iinfo)
{
if (!iinfo)
return;
if (iinfo->indexes)
{
snmp_free_varbind (iinfo->indexes);
iinfo->indexes = NULL;
}
netsnmp_table_registration_info_free (iinfo->table_reginfo);
SNMP_FREE (iinfo);
}
void
shutdown_sysORTable(void)
{
#ifdef USING_MIBII_SYSTEM_MIB_MODULE
if (system_module_count-- == 3)
UNREGISTER_SYSOR_TABLE(system_module_oid, system_module_oid_len);
#endif
snmp_unregister_callback(SNMP_CALLBACK_APPLICATION,
SNMPD_CALLBACK_UNREG_SYSOR, unregister_cb, NULL,
1);
snmp_unregister_callback(SNMP_CALLBACK_APPLICATION,
SNMPD_CALLBACK_REG_SYSOR, register_cb, NULL, 1);
if (table)
CONTAINER_CLEAR(table, netsnmp_container_simple_free, NULL);
netsnmp_container_table_unregister(sysORTable_reg);
sysORTable_reg = NULL;
table = NULL;
netsnmp_table_registration_info_free(sysORTable_table_info);
sysORTable_table_info = NULL;
netsnmp_unregister_handler(sysORLastChange_reg);
sysORLastChange_reg = NULL;
}
/** 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 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 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_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;
}
netsnmp_cache_handler_owns_cache(handler);
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");
reg = NULL; /* it was freed inside netsnmp_register_table */
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)
netsnmp_handler_registration_free(reg);
}