void
netsnmp_access_udp_endpoint_container_free(netsnmp_container *container,
u_int free_flags)
{
DEBUGMSGTL(("access:udp_endpoint:container", "free\n"));
if (NULL == container) {
snmp_log(LOG_ERR,
"invalid container for netsnmp_access_udp_endpoint_free\n");
return;
}
if(! (free_flags & NETSNMP_ACCESS_UDP_ENDPOINT_FREE_DONT_CLEAR)) {
/*
* free all items.
*/
CONTAINER_CLEAR(container,
(netsnmp_container_obj_func*)
netsnmp_access_udp_endpoint_entry_free,
NULL);
}
if(! (free_flags & NETSNMP_ACCESS_UDP_ENDPOINT_FREE_KEEP_CONTAINER))
CONTAINER_FREE(container);
}
/*
* free a buffer
* dontcare param is there so this function can be passed directly
* to CONTAINER_FOR_EACH.
*/
static void
_sql_buf_free(sql_buf *sqlb, void* dontcare)
{
if (NULL == sqlb)
return;
/** do varbinds first */
if (sqlb->varbinds) {
CONTAINER_CLEAR(sqlb->varbinds,
(netsnmp_container_obj_func*)_sql_vb_buf_free, NULL);
CONTAINER_FREE(sqlb->varbinds);
}
SNMP_FREE(sqlb->host);
SNMP_FREE(sqlb->oid);
SNMP_FREE(sqlb->user);
SNMP_FREE(sqlb->context);
SNMP_FREE(sqlb->security_name);
SNMP_FREE(sqlb->context_engine);
SNMP_FREE(sqlb->security_engine);
SNMP_FREE(sqlb->transport);
free(sqlb);
}
netsnmp_container *
netsnmp_access_ipaddress_container_init(u_int flags)
{
netsnmp_container *container1;
DEBUGMSGTL(("access:ipaddress:container", "init\n"));
/*
* create the containers. one indexed by ifIndex, the other
* indexed by ifName.
*/
container1 = netsnmp_container_find("access_ipaddress:table_container");
if (NULL == container1) {
snmp_log(LOG_ERR, "ipaddress primary container not found\n");
return NULL;
}
container1->container_name = strdup("ia_index");
if (flags & NETSNMP_ACCESS_IPADDRESS_INIT_ADDL_IDX_BY_ADDR) {
netsnmp_container *container2 =
netsnmp_container_find("ipaddress_addr:access_ipaddress:table_container");
if (NULL == container2) {
snmp_log(LOG_ERR, "ipaddress secondary container not found\n");
CONTAINER_FREE(container1);
return NULL;
}
container2->compare = _access_ipaddress_entry_compare_addr;
container2->container_name = strdup("ia_addr");
netsnmp_container_add_index(container1, container2);
}
return container1;
}
static void release_netsnmp_request_groups (void *vp)
{
netsnmp_container *c = (netsnmp_container *) vp;
CONTAINER_FOR_EACH (c, (netsnmp_container_obj_func *) release_netsnmp_request_group, NULL);
CONTAINER_FREE (c);
}
/*
* sql cleanup function, called at exit
*/
static void
netsnmp_mysql_cleanup(void)
{
DEBUGMSGTL(("sql:cleanup"," called\n"));
/** unregister alarm */
if (_sql.alarm_id)
snmp_alarm_unregister(_sql.alarm_id);
/** save any queued traps */
if (CONTAINER_SIZE(_sql.queue))
_sql_process_queue(0,NULL);
CONTAINER_FREE(_sql.queue);
_sql.queue = NULL;
if (_sql.trap_stmt) {
mysql_stmt_close(_sql.trap_stmt);
_sql.trap_stmt = NULL;
}
if (_sql.vb_stmt) {
mysql_stmt_close(_sql.vb_stmt);
_sql.vb_stmt = NULL;
}
/** disconnect from server */
netsnmp_sql_disconnected();
if (_sql.conn) {
mysql_close(_sql.conn);
_sql.conn = NULL;
}
mysql_library_end();
}
netsnmp_container *
netsnmp_text_token_container_from_file(const char *file, u_int flags,
netsnmp_container *cin, void *context)
{
netsnmp_line_process_info lpi;
netsnmp_container *c = cin, *c_rc;
netsnmp_file *fp;
if (NULL == file)
return NULL;
/*
* allocate file resources
*/
fp = netsnmp_file_fill(NULL, file, O_RDONLY, 0, 0);
if (NULL == fp) /** msg already logged */
return NULL;
memset(&lpi, 0x0, sizeof(lpi));
lpi.mem_size = sizeof(netsnmp_token_value_index);
lpi.process = _process_line_tvi;
lpi.user_context = context;
if (NULL == c) {
c = netsnmp_container_find("string:binary_array");
if (NULL == c) {
snmp_log(LOG_ERR,"malloc failed\n");
netsnmp_file_release(fp);
return NULL;
}
}
c_rc = netsnmp_file_text_parse(fp, c, PM_USER_FUNCTION, 0, &lpi);
/*
* if we got a bad return and the user didn't pass us a container,
* we need to release the container we allocated.
*/
if ((NULL == c_rc) && (NULL == cin)) {
CONTAINER_FREE(c);
c = NULL;
}
else
c = c_rc;
/*
* release file resources
*/
netsnmp_file_release(fp);
return c;
}
/** creates and returns a 'tdata' table data structure */
void netsnmp_tdata_delete_table (netsnmp_tdata * table)
{
if (!table)
return;
if (table->name)
free (table->name);
if (table->container)
CONTAINER_FREE (table->container);
SNMP_FREE (table);
return;
}
void
netsnmp_swrun_container_free(netsnmp_container *container, u_int free_flags)
{
DEBUGMSGTL(("swrun:container", "free\n"));
if (NULL == container) {
snmp_log(LOG_ERR, "invalid container for netsnmp_swrun_container_free\n");
return;
}
if(! (free_flags & NETSNMP_SWRUN_DONT_FREE_ITEMS))
netsnmp_swrun_container_free_items(container);
CONTAINER_FREE(container);
}
/*
* Remove all entries from sctpAssocRemAddrTable, which are not marked as valid.
* All valid entries are then marked as invalid (to delete them in next cache
* load, if the entry is not updated).
*/
void
sctpAssocRemAddrTable_delete_invalid(netsnmp_container *remAddrTable)
{
netsnmp_container *to_delete = netsnmp_container_find("lifo");
CONTAINER_FOR_EACH(remAddrTable, sctpAssocRemAddrTable_collect_invalid,
to_delete);
while (CONTAINER_SIZE(to_delete)) {
sctpAssocRemAddrTable_entry *entry = CONTAINER_FIRST(to_delete);
CONTAINER_REMOVE(remAddrTable, entry);
sctpAssocRemAddrTable_entry_free(entry);
CONTAINER_REMOVE(to_delete, NULL);
}
CONTAINER_FREE(to_delete);
}
void
shutdown_snmpNotifyFilterTable_data_storage(void)
{
if (NULL == _container)
return;
CONTAINER_FREE_ALL(_container, NULL);
CONTAINER_FREE(_container);
_container = NULL;
DEBUGMSGTL(("trap:notifyFilter:storage:shutdown",
"active count %d\n", _active));
if (_active != 0) {
DEBUGMSGTL(("trap:notifyFilter:storage:shutdown",
"unexpected count %d after cleanup!\n",_active));
snmp_log(LOG_WARNING,
"notifyFilter count %d, not 0, after shutdown.\n", _active);
}
}
void
netsnmp_access_systemstats_container_free(netsnmp_container *container, u_int free_flags)
{
DEBUGMSGTL(("access:systemstats:container", "free\n"));
if (NULL == container) {
snmp_log(LOG_ERR, "invalid container for netsnmp_access_systemstats_free\n");
return;
}
if(! (free_flags & NETSNMP_ACCESS_SYSTEMSTATS_FREE_DONT_CLEAR)) {
/*
* free all items.
*/
CONTAINER_CLEAR(container,
(netsnmp_container_obj_func*)_entry_release,
NULL);
}
CONTAINER_FREE(container);
}
void
netsnmp_access_tcpconn_container_free(netsnmp_container *container, u_int free_flags)
{
DEBUGMSGTL(("access:tcpconn:container", "free\n"));
if (NULL == container) {
snmp_log(LOG_ERR, "invalid container for netsnmp_access_tcpconn_free\n");
return;
}
if(! (free_flags & NETSNMP_ACCESS_TCPCONN_FREE_DONT_CLEAR)) {
/*
* free all items.
*/
CONTAINER_CLEAR(container,
(netsnmp_container_obj_func*)_access_tcpconn_entry_release,
NULL);
}
if(! (free_flags & NETSNMP_ACCESS_TCPCONN_FREE_KEEP_CONTAINER))
CONTAINER_FREE(container);
}
/** 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 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);
}
void
netsnmp_directory_container_free(netsnmp_container *container)
{
CONTAINER_FREE_ALL(container, NULL);
CONTAINER_FREE(container);
}
/** 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);
}
/** Initializes the sysORTable module */
void
init_sysORTable(void)
{
const oid sysORLastChange_oid[] = { 1, 3, 6, 1, 2, 1, 1, 8 };
const oid sysORTable_oid[] = { 1, 3, 6, 1, 2, 1, 1, 9 };
sysORTable_table_info =
SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
table = netsnmp_container_find("sysORTable:table_container");
if (sysORTable_table_info == NULL || table == NULL) {
SNMP_FREE(sysORTable_table_info);
CONTAINER_FREE(table);
return;
}
table->container_name = strdup("sysORTable");
netsnmp_table_helper_add_indexes(sysORTable_table_info,
ASN_INTEGER, /** index: sysORIndex */
0);
sysORTable_table_info->min_column = COLUMN_SYSORID;
sysORTable_table_info->max_column = COLUMN_SYSORUPTIME;
sysORLastChange_reg =
netsnmp_create_handler_registration(
"mibII/sysORLastChange", NULL,
sysORLastChange_oid, OID_LENGTH(sysORLastChange_oid),
HANDLER_CAN_RONLY);
netsnmp_init_watcher_info(
&sysORLastChange_winfo,
&sysORLastChange, sizeof(u_long),
ASN_TIMETICKS, WATCHER_FIXED_SIZE);
netsnmp_register_watched_scalar(sysORLastChange_reg,
&sysORLastChange_winfo);
sysORTable_reg =
netsnmp_create_handler_registration(
"mibII/sysORTable", sysORTable_handler,
sysORTable_oid, OID_LENGTH(sysORTable_oid), HANDLER_CAN_RONLY);
netsnmp_container_table_register(sysORTable_reg, sysORTable_table_info,
table, TABLE_CONTAINER_KEY_NETSNMP_INDEX);
sysORLastChange = netsnmp_get_agent_uptime();
/*
* Initialise the contents of the table here
*/
netsnmp_sysORTable_foreach(®ister_foreach, NULL);
/*
* Register callbacks
*/
snmp_register_callback(SNMP_CALLBACK_APPLICATION,
SNMPD_CALLBACK_REG_SYSOR, register_cb, NULL);
snmp_register_callback(SNMP_CALLBACK_APPLICATION,
SNMPD_CALLBACK_UNREG_SYSOR, unregister_cb, NULL);
#ifdef USING_MIBII_SYSTEM_MIB_MODULE
if (++system_module_count == 3)
REGISTER_SYSOR_TABLE(system_module_oid, system_module_oid_len,
"The MIB module for SNMPv2 entities");
#endif
}
/**
* process text file, reading into extras
*/
netsnmp_container *
netsnmp_file_text_parse(netsnmp_file *f, netsnmp_container *cin,
int parse_mode, u_int flags, void *context)
{
netsnmp_container *c = cin;
FILE *fin;
int rc;
if (NULL == f)
return NULL;
if ((NULL == c) && (!(flags & PM_FLAG_NO_CONTAINER))) {
c = netsnmp_container_find("text_parse:binary_array");
if (NULL == c)
return NULL;
}
rc = netsnmp_file_open(f);
if (rc < 0) { /** error already logged */
if ((NULL !=c) && (c != cin))
CONTAINER_FREE(c);
return NULL;
}
/*
* get a stream from the file descriptor. This DOES NOT rewind the
* file (if fd was previously opened).
*/
fin = fdopen(f->fd, "r");
if (NULL == fin) {
if (NS_FI_AUTOCLOSE(f->ns_flags))
close(f->fd);
if ((NULL !=c) && (c != cin))
CONTAINER_FREE(c);
return NULL;
}
switch (parse_mode) {
case PM_SAVE_EVERYTHING:
_pm_save_everything(fin, c, flags);
break;
case PM_INDEX_STRING_STRING:
_pm_save_index_string_string(fin, c, flags);
break;
case PM_USER_FUNCTION:
if (NULL != context)
_pm_user_function(fin, c, (netsnmp_line_process_info*)context,
flags);
break;
default:
snmp_log(LOG_ERR, "unknown parse mode %d\n", parse_mode);
break;
}
/*
* close the stream, which will have the side effect of also closing
* the file descriptor, so we need to reset it.
*/
fclose(fin);
f->fd = -1;
return c;
}
/** 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 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);
}