/** Initialize the nsTransactionTable table by defining it's contents and how it's structured */ void initialize_table_nsTransactionTable(void) { const oid nsTransactionTable_oid[] = { 1, 3, 6, 1, 4, 1, 8072, 1, 8, 1 }; netsnmp_table_registration_info *table_info; netsnmp_handler_registration *my_handler; netsnmp_iterator_info *iinfo; /* * create the table structure itself */ table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info); /* * if your table is read only, it's easiest to change the * HANDLER_CAN_RWRITE definition below to HANDLER_CAN_RONLY */ my_handler = netsnmp_create_handler_registration( "nsTransactionTable", nsTransactionTable_handler, nsTransactionTable_oid, OID_LENGTH(nsTransactionTable_oid), HANDLER_CAN_RONLY); if (!my_handler || !table_info || !iinfo) { if (my_handler) netsnmp_handler_registration_free(my_handler); SNMP_FREE(table_info); SNMP_FREE(iinfo); return; /* mallocs failed */ } /*************************************************** * Setting up the table's definition */ netsnmp_table_helper_add_index(table_info, ASN_INTEGER); /* index: * * nsTransactionID */ table_info->min_column = 2; table_info->max_column = 2; iinfo->get_first_data_point = nsTransactionTable_get_first_data_point; iinfo->get_next_data_point = nsTransactionTable_get_next_data_point; iinfo->table_reginfo = table_info; /*************************************************** * registering the table with the master agent */ DEBUGMSGTL(("initialize_table_nsTransactionTable", "Registering table nsTransactionTable as a table iterator\n")); netsnmp_register_table_iterator(my_handler, iinfo); }
/* Initialize the kamailioSIPMethodSupportedTable by defining its structure and * callback mechanisms */ void initialize_table_kamailioSIPMethodSupportedTable(void) { netsnmp_table_registration_info *table_info; if(my_handler) { snmp_log(LOG_ERR, "initialize_table_kamailioSIPMethodSupported" "Table_handler called again\n"); return; } memset(&cb, 0x00, sizeof(cb)); /** create the table structure itself */ table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); my_handler = netsnmp_create_handler_registration( "kamailioSIPMethodSupportedTable", netsnmp_table_array_helper_handler, kamailioSIPMethodSupportedTable_oid, kamailioSIPMethodSupportedTable_oid_len, HANDLER_CAN_RONLY); if (!my_handler || !table_info) { snmp_log(LOG_ERR, "malloc failed in initialize_table_kamailio" "SIPMethodSupportedTable_handler\n"); return; } netsnmp_table_helper_add_index(table_info, ASN_UNSIGNED); table_info->min_column = kamailioSIPMethodSupportedTable_COL_MIN; table_info->max_column = kamailioSIPMethodSupportedTable_COL_MAX; /*************************************************** * registering the table with the master agent */ cb.get_value = kamailioSIPMethodSupportedTable_get_value; cb.container = netsnmp_container_find("kamailioSIPMethodSupportedTable_primary:" "kamailioSIPMethodSupportedTable:" "table_container"); DEBUGMSGTL(("initialize_table_kamailioSIPMethodSupportedTable", "Registering table kamailioSIPMethodSupportedTable" "as a table array\n")); netsnmp_table_container_register(my_handler, table_info, &cb, cb.container, 1); }
/* Initialize the openserSIPPortTable table by defining how it is structured */ void initialize_table_openserSIPPortTable(void) { netsnmp_table_registration_info *table_info; if(my_handler) { snmp_log(LOG_ERR, "initialize_table_openserSIPPortTable_handler" "called again\n"); return; } memset(&cb, 0x00, sizeof(cb)); /* create the table structure itself */ table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); my_handler = netsnmp_create_handler_registration("openserSIPPortTable", netsnmp_table_array_helper_handler, openserSIPPortTable_oid, openserSIPPortTable_oid_len, HANDLER_CAN_RONLY); if (!my_handler || !table_info) { snmp_log(LOG_ERR, "malloc failed in " "initialize_table_openserSIPPortTable_handler\n"); return; /** mallocs failed */ } /* Set up the table's structural definition */ /* index: openserSIPPortIndex */ netsnmp_table_helper_add_index(table_info, ASN_OCTET_STR); table_info->min_column = openserSIPPortTable_COL_MIN; table_info->max_column = openserSIPPortTable_COL_MAX; /* register the table with the master agent */ cb.get_value = openserSIPPortTable_get_value; cb.container = netsnmp_container_find("openserSIPPortTable_primary:" "openserSIPPortTable:" "table_container"); DEBUGMSGTL(("initialize_table_openserSIPPortTable", "Registering table openserSIPPortTable " "as a table array\n")); netsnmp_table_container_register(my_handler, table_info, &cb, cb.container, 1); }
void init_vacm_context(void) { /* * table vacm_context */ netsnmp_handler_registration *my_handler; netsnmp_table_registration_info *table_info; netsnmp_iterator_info *iinfo; my_handler = netsnmp_create_handler_registration("vacm_context", vacm_context_handler, vacm_context_oid, sizeof (vacm_context_oid) / sizeof(oid), HANDLER_CAN_RONLY); if (!my_handler) return; table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info); if (!table_info || !iinfo) { SNMP_FREE(table_info); SNMP_FREE(iinfo); return; } netsnmp_table_helper_add_index(table_info, ASN_OCTET_STR) table_info->min_column = 1; table_info->max_column = 1; iinfo->get_first_data_point = get_first_context; iinfo->get_next_data_point = get_next_context; iinfo->table_reginfo = table_info; netsnmp_register_table_iterator(my_handler, iinfo); }
/************************************************************ * * Initialize the saHpiDomainEventTable table by defining its contents and how it's structured */ void initialize_table_saHpiDomainEventTable(void) { netsnmp_table_registration_info *table_info; if(my_handler) { snmp_log(LOG_ERR, "initialize_table_saHpiDomainEventTable_handler called again\n"); return; } memset(&cb, 0x00, sizeof(cb)); /** create the table structure itself */ table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); /* if your table is read only, it's easiest to change the HANDLER_CAN_RWRITE definition below to HANDLER_CAN_RONLY */ my_handler = netsnmp_create_handler_registration("saHpiDomainEventTable", netsnmp_table_array_helper_handler, saHpiDomainEventTable_oid, saHpiDomainEventTable_oid_len, HANDLER_CAN_RWRITE); if (!my_handler || !table_info) { snmp_log(LOG_ERR, "malloc failed in " "initialize_table_saHpiDomainEventTable_handler\n"); return; /** mallocs failed */ } /*************************************************** * Setting up the table's definition */ /* * TODO: add any external indexes here. */ /** TODO: add code for external index(s)! */ /* * internal indexes */ /** index: saHpiDomainId */ netsnmp_table_helper_add_index(table_info, ASN_UNSIGNED); /** index: saHpiDomainEventEntryId */ netsnmp_table_helper_add_index(table_info, ASN_UNSIGNED); /** index: saHpiEventSeverity */ netsnmp_table_helper_add_index(table_info, ASN_INTEGER); table_info->min_column = saHpiDomainEventTable_COL_MIN; table_info->max_column = saHpiDomainEventTable_COL_MAX; /*************************************************** * registering the table with the master agent */ cb.get_value = saHpiDomainEventTable_get_value; cb.container = netsnmp_container_find("saHpiDomainEventTable_primary:" "saHpiDomainEventTable:" "table_container"); netsnmp_container_add_index(cb.container, netsnmp_container_find("saHpiDomainEventTable_secondary:" "saHpiDomainEventTable:" "table_container")); cb.container->next->compare = saHpiDomainEventTable_cmp; cb.can_set = 1; cb.create_row = (UserRowMethod*)saHpiDomainEventTable_create_row; cb.duplicate_row = (UserRowMethod*)saHpiDomainEventTable_duplicate_row; cb.delete_row = (UserRowMethod*)saHpiDomainEventTable_delete_row; cb.row_copy = (Netsnmp_User_Row_Operation *)saHpiDomainEventTable_row_copy; cb.can_activate = (Netsnmp_User_Row_Action *)saHpiDomainEventTable_can_activate; cb.can_deactivate = (Netsnmp_User_Row_Action *)saHpiDomainEventTable_can_deactivate; cb.can_delete = (Netsnmp_User_Row_Action *)saHpiDomainEventTable_can_delete; cb.set_reserve1 = saHpiDomainEventTable_set_reserve1; cb.set_reserve2 = saHpiDomainEventTable_set_reserve2; cb.set_action = saHpiDomainEventTable_set_action; cb.set_commit = saHpiDomainEventTable_set_commit; cb.set_free = saHpiDomainEventTable_set_free; cb.set_undo = saHpiDomainEventTable_set_undo; DEBUGMSGTL(("initialize_table_saHpiDomainEventTable", "Registering table saHpiDomainEventTable " "as a table array\n")); netsnmp_table_container_register(my_handler, table_info, &cb, cb.container, 1); }
/* * Initialize the openserSIPStatusCodesTable table by defining how it is * structured. * * This function is mostly auto-generated. */ void initialize_table_openserSIPStatusCodesTable(void) { netsnmp_table_registration_info *table_info; if(my_handler) { snmp_log(LOG_ERR, "initialize_table_openserSIPStatusCodes" "Table_handler called again\n"); return; } memset(&cb, 0x00, sizeof(cb)); /** create the table structure itself */ table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); my_handler = netsnmp_create_handler_registration( "openserSIPStatusCodesTable", netsnmp_table_array_helper_handler, openserSIPStatusCodesTable_oid, openserSIPStatusCodesTable_oid_len, HANDLER_CAN_RWRITE); if (!my_handler || !table_info) { snmp_log(LOG_ERR, "malloc failed in initialize_table_openserSIP" "StatusCodesTable_handler\n"); return; /** mallocs failed */ } /** index: openserSIPStatusCodeMethod */ netsnmp_table_helper_add_index(table_info, ASN_UNSIGNED); /** index: openserSIPStatusCodeValue */ netsnmp_table_helper_add_index(table_info, ASN_UNSIGNED); table_info->min_column = openserSIPStatusCodesTable_COL_MIN; table_info->max_column = openserSIPStatusCodesTable_COL_MAX; /*************************************************** * registering the table with the master agent */ cb.get_value = openserSIPStatusCodesTable_get_value; cb.container = netsnmp_container_find("openserSIPStatusCodesTable_primary:" "openserSIPStatusCodesTable:" "table_container"); #ifdef openserSIPStatusCodesTable_CUSTOM_SORT netsnmp_container_add_index(cb.container, netsnmp_container_find( "openserSIPStatusCodesTable_custom:" "openserSIPStatusCodesTable:" "table_container")); cb.container->next->compare = openserSIPStatusCodesTable_cmp; #endif cb.can_set = 1; cb.create_row = (UserRowMethod*)openserSIPStatusCodesTable_create_row; cb.duplicate_row = (UserRowMethod*)openserSIPStatusCodesTable_duplicate_row; cb.delete_row = (UserRowMethod*)openserSIPStatusCodesTable_delete_row; cb.row_copy = (Netsnmp_User_Row_Operation *) openserSIPStatusCodesTable_row_copy; cb.can_activate = (Netsnmp_User_Row_Action *) openserSIPStatusCodesTable_can_activate; cb.can_deactivate = (Netsnmp_User_Row_Action *) openserSIPStatusCodesTable_can_deactivate; cb.can_delete = (Netsnmp_User_Row_Action *)openserSIPStatusCodesTable_can_delete; cb.set_reserve1 = openserSIPStatusCodesTable_set_reserve1; cb.set_reserve2 = openserSIPStatusCodesTable_set_reserve2; cb.set_action = openserSIPStatusCodesTable_set_action; cb.set_commit = openserSIPStatusCodesTable_set_commit; cb.set_free = openserSIPStatusCodesTable_set_free; cb.set_undo = openserSIPStatusCodesTable_set_undo; DEBUGMSGTL(("initialize_table_openserSIPStatusCodesTable", "Registering table openserSIPStatusCodesTable " "as a table array\n")); netsnmp_table_container_register(my_handler, table_info, &cb, cb.container, 1); }
/* General initialization */ void init_custom_queries(void) { netsnmp_table_registration_info *table_info; pgsnmpd_query *curquery; int i; PGresult *res; if (custom_query_config_file == NULL) return; /* ASN_INTEGER = 0 ASN_FLOAT = 1 ASN_BOOLEAN = 2 ASN_OCTET_STR = 3 */ res = PQprepare(dbconn, "TYPEQUERY", "SELECT CASE " "WHEN typname LIKE 'int%' OR typname = 'xid' OR typname = 'oid'" "THEN 0 " "WHEN typname LIKE 'float%' THEN 1 " "WHEN typname = 'bool' THEN 2 " "ELSE 3 " "END " "FROM pg_catalog.pg_type WHERE oid = $1", 1, NULL); if (PQresultStatus(res) != PGRES_COMMAND_OK) { snmp_log(LOG_ERR, "Failed to prepare statement (error: %s)\n", PQresStatus(PQresultStatus(res))); return; } PQclear(res); head = parse_config(custom_query_config_file); if (head == NULL) { snmp_log(LOG_INFO, "No custom queries initialized\n"); return; } for (curquery = head; curquery != NULL; curquery = curquery->next) { run_query(curquery); if (curquery->typeslen < curquery->colcount) curquery->types = realloc(curquery->types, sizeof(u_char) * curquery->colcount); if (curquery->types == NULL) { snmp_log(LOG_ERR, "Memory allocation problem"); return; } init_types_array(curquery->types, curquery->typeslen, curquery->colcount); fill_query_column_types(curquery); if (curquery->my_handler) { snmp_log(LOG_ERR, "init_custom_queries called again for query %s\n", curquery->table_name); return; } memset(&(curquery->cb), 0x00, sizeof(curquery->cb)); /** create the table structure itself */ snmp_log(LOG_INFO, "Initializing table name %s\n", curquery->table_name); table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); curquery->my_handler = netsnmp_create_handler_registration( curquery->table_name, netsnmp_table_array_helper_handler, curquery->table_oid, curquery->oid_len, HANDLER_CAN_RONLY ); if (!curquery->my_handler || !table_info) { snmp_log(LOG_ERR, "malloc failed in init_custom_queries\n"); return; /** mallocs failed */ } netsnmp_table_helper_add_index(table_info, ASN_INTEGER); /* pgsnmpdConnID */ netsnmp_table_helper_add_index(table_info, ASN_INTEGER); /* rdbmsDbIndex */ for (i = 0; i < curquery->num_indexes; i++) netsnmp_table_helper_add_index(table_info, curquery->types[i]); table_info->min_column = curquery->min_colnum; table_info->max_column = curquery->colcount; curquery->cb.get_value = custom_query_get_value; curquery->cb.container = netsnmp_container_find("table_container"); DEBUGMSGTL(("init_custom_queries", "Registering table for query " "as a table array\n")); switch (netsnmp_table_container_register(curquery->my_handler, table_info, &curquery->cb, curquery->cb.container, 1)) { case MIB_REGISTRATION_FAILED: snmp_log(LOG_INFO, "Failed to register table %s\n", curquery->table_name); break; case MIB_DUPLICATE_REGISTRATION: snmp_log(LOG_INFO, "Duplicate registration for table %s\n", curquery->table_name); break; case MIB_REGISTERED_OK: DEBUGMSGTL(("init_custom_queries", "Successfully registered table %s\n", curquery->table_name)); break; default: snmp_log(LOG_INFO, "Unknown registration result for table %s\n", curquery->table_name); } /* Having set everything up, fill the table's container with data */ fill_query_container(curquery); } snmp_log(LOG_DEBUG, "Finished intializing queries\n"); }
/************************************************************ * * Initialize the memTable table by defining its contents and how it's structured */ void initialize_table_memTable(void) { netsnmp_table_registration_info *table_info; if (my_handler) { log_print(LOGN_CRI, "initialize_table_memTable_handler called again\n"); return; } memset(&cb, 0x00, sizeof(cb)); /** create the table structure itself */ table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); /* * if your table is read only, it's easiest to change the * HANDLER_CAN_RWRITE definition below to HANDLER_CAN_RONLY */ my_handler = netsnmp_create_handler_registration("memTable", netsnmp_table_array_helper_handler, memTable_oid, memTable_oid_len, HANDLER_CAN_RWRITE); if (!my_handler || !table_info) { log_print(LOGN_CRI, "malloc failed in " "initialize_table_memTable_handler\n"); return; /** mallocs failed */ } /*************************************************** * Setting up the table's definition */ /* * TODO: add any external indexes here. */ /* * internal indexes */ /** index: memIndex */ netsnmp_table_helper_add_index(table_info, ASN_INTEGER); table_info->min_column = memTable_COL_MIN; table_info->max_column = memTable_COL_MAX; /*************************************************** * registering the table with the master agent */ cb.get_value = memTable_get_value; cb.container = netsnmp_container_find("memTable_primary:" "memTable:" "table_container"); #ifdef memTable_IDX2 netsnmp_container_add_index(cb.container, netsnmp_container_find ("memTable_secondary:" "memTable:" "table_container")); cb.container->next->compare = memTable_cmp; #endif #ifdef memTable_SET_HANDLING cb.can_set = 1; #ifdef memTable_ROW_CREATION cb.create_row = (UserRowMethod *) memTable_create_row; #endif cb.duplicate_row = (UserRowMethod *) memTable_duplicate_row; cb.delete_row = (UserRowMethod *) memTable_delete_row; cb.row_copy = (Netsnmp_User_Row_Operation *) memTable_row_copy; cb.can_delete = (Netsnmp_User_Row_Action *) memTable_can_delete; cb.set_reserve1 = memTable_set_reserve1; cb.set_reserve2 = memTable_set_reserve2; cb.set_action = memTable_set_action; cb.set_commit = memTable_set_commit; cb.set_free = memTable_set_free; cb.set_undo = memTable_set_undo; #endif DEBUGMSGTL(("initialize_table_memTable", "Registering table memTable " "as a table array\n")); netsnmp_table_container_register(my_handler, table_info, &cb, cb.container, 1); }
/************************************************************ * * Initialize the saHpiRdrTable table by defining its contents and how it's structured */ void initialize_table_saHpiRdrTable (void) { netsnmp_table_registration_info *table_info; if (my_handler) { snmp_log (LOG_ERR, "initialize_table_saHpiRdrTable_handler called again\n"); return; } memset (&cb, 0x00, sizeof (cb)); /** create the table structure itself */ table_info = SNMP_MALLOC_TYPEDEF (netsnmp_table_registration_info); /* * if your table is read only, it's easiest to change the * HANDLER_CAN_RWRITE definition below to HANDLER_CAN_RONLY */ my_handler = netsnmp_create_handler_registration ("saHpiRdrTable", netsnmp_table_array_helper_handler, saHpiRdrTable_oid, saHpiRdrTable_oid_len, HANDLER_CAN_RONLY); if (!my_handler || !table_info) { snmp_log (LOG_ERR, "malloc failed in " "initialize_table_saHpiRdrTable_handler\n"); return; /** mallocs failed */ } /** index: saHpiRdrRecordId */ netsnmp_table_helper_add_index (table_info, ASN_UNSIGNED); netsnmp_table_helper_add_index (table_info, ASN_UNSIGNED); netsnmp_table_helper_add_index (table_info, ASN_UNSIGNED); /** index: saHpiRdrType */ netsnmp_table_helper_add_index (table_info, ASN_INTEGER); table_info->min_column = saHpiRdrTable_COL_MIN; table_info->max_column = saHpiRdrTable_COL_MAX; /*************************************************** * registering the table with the master agent */ cb.get_value = saHpiRdrTable_get_value; cb.container = netsnmp_container_find ("saHpiRdrTable_primary:" "saHpiRdrTable:" "table_container"); cb.create_row = (UserRowMethod *) saHpiRdrTable_create_row; DEBUGMSGTL (("initialize_table_saHpiRdrTable", "Registering table saHpiRdrTable " "as a table array\n")); netsnmp_table_container_register (my_handler, table_info, &cb, cb.container, 1); netsnmp_register_read_only_counter32_instance ("rdr_count", saHpiRdrCount_oid, OID_LENGTH (saHpiRdrCount_oid), &rdr_count, NULL); }
/* * Initialize the kamailioSIPRegUserLookupTable table by defining how it is * structured. * * This function is mostly auto-generated. */ void initialize_table_kamailioSIPRegUserLookupTable(void) { netsnmp_table_registration_info *table_info; if(my_handler) { snmp_log(LOG_ERR, "initialize_table_kamailioSIPRegUserLookup" "Table_handler called again\n"); return; } memset(&cb, 0x00, sizeof(cb)); /** create the table structure itself */ table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); my_handler = netsnmp_create_handler_registration( "kamailioSIPRegUserLookupTable", netsnmp_table_array_helper_handler, kamailioSIPRegUserLookupTable_oid, kamailioSIPRegUserLookupTable_oid_len, HANDLER_CAN_RWRITE); if (!my_handler || !table_info) { snmp_log(LOG_ERR, "malloc failed in " "initialize_table_kamailioSIPRegUserLookup" "Table_handler\n"); return; /** mallocs failed */ } /* * Setting up the table's definition */ netsnmp_table_helper_add_index(table_info, ASN_UNSIGNED); table_info->min_column = kamailioSIPRegUserLookupTable_COL_MIN; table_info->max_column = kamailioSIPRegUserLookupTable_COL_MAX; /* * registering the table with the master agent */ cb.get_value = kamailioSIPRegUserLookupTable_get_value; cb.container = netsnmp_container_find( "kamailioSIPRegUserLookupTable_primary:" "kamailioSIPRegUserLookupTable:" "table_container"); cb.can_set = 1; cb.create_row = (UserRowMethod*)kamailioSIPRegUserLookupTable_create_row; cb.duplicate_row = (UserRowMethod*)kamailioSIPRegUserLookupTable_duplicate_row; cb.delete_row = (UserRowMethod*)kamailioSIPRegUserLookupTable_delete_row; cb.row_copy = (Netsnmp_User_Row_Operation *) kamailioSIPRegUserLookupTable_row_copy; cb.can_activate = (Netsnmp_User_Row_Action *) kamailioSIPRegUserLookupTable_can_activate; cb.can_deactivate = (Netsnmp_User_Row_Action *) kamailioSIPRegUserLookupTable_can_deactivate; cb.can_delete = (Netsnmp_User_Row_Action *) kamailioSIPRegUserLookupTable_can_delete; cb.set_reserve1 = kamailioSIPRegUserLookupTable_set_reserve1; cb.set_reserve2 = kamailioSIPRegUserLookupTable_set_reserve2; cb.set_action = kamailioSIPRegUserLookupTable_set_action; cb.set_commit = kamailioSIPRegUserLookupTable_set_commit; cb.set_free = kamailioSIPRegUserLookupTable_set_free; cb.set_undo = kamailioSIPRegUserLookupTable_set_undo; DEBUGMSGTL(("initialize_table_kamailioSIPRegUserLookupTable", "Registering table kamailioSIPRegUserLookupTable " "as a table array\n")); netsnmp_table_container_register(my_handler, table_info, &cb, cb.container, 1); }
/************************************************************ * * Initialize the saHpiSensorTable table by defining its contents and how it's structured */ void initialize_table_saHpiSensorTable (void) { netsnmp_table_registration_info *table_info; if (my_handler) { snmp_log (LOG_ERR, "initialize_table_saHpiSensorTable_handler called again\n"); return; } memset (&cb, 0x00, sizeof (cb)); /** create the table structure itself */ table_info = SNMP_MALLOC_TYPEDEF (netsnmp_table_registration_info); /* * if your table is read only, it's easiest to change the * HANDLER_CAN_RWRITE definition below to HANDLER_CAN_RONLY */ my_handler = netsnmp_create_handler_registration ("saHpiSensorTable", netsnmp_table_array_helper_handler, saHpiSensorTable_oid, saHpiSensorTable_oid_len, HANDLER_CAN_RWRITE); if (!my_handler || !table_info) { snmp_log (LOG_ERR, "malloc failed in " "initialize_table_saHpiSensorTable_handler\n"); return; /** mallocs failed */ } /*************************************************** * Setting up the table's definition */ /* * internal indexes */ /** index: saHpiSensorIndex */ netsnmp_table_helper_add_index (table_info, ASN_UNSIGNED); netsnmp_table_helper_add_index (table_info, ASN_UNSIGNED); netsnmp_table_helper_add_index (table_info, ASN_UNSIGNED); table_info->min_column = saHpiSensorTable_COL_MIN; table_info->max_column = saHpiSensorTable_COL_MAX; /*************************************************** * registering the table with the master agent */ cb.get_value = saHpiSensorTable_get_value; cb.container = netsnmp_container_find ("saHpiSensorTable_primary:" "saHpiSensorTable:" "table_container"); // cb.can_set = 1; cb.create_row = (UserRowMethod *) saHpiSensorTable_create_row; cb.duplicate_row = (UserRowMethod *) saHpiSensorTable_duplicate_row; cb.delete_row = (UserRowMethod *) saHpiSensorTable_delete_row; cb.row_copy = (Netsnmp_User_Row_Operation *) saHpiSensorTable_row_copy; cb.can_delete = (Netsnmp_User_Row_Action *) saHpiSensorTable_can_delete; cb.set_reserve1 = saHpiSensorTable_set_reserve1; cb.set_reserve2 = saHpiSensorTable_set_reserve2; cb.set_action = saHpiSensorTable_set_action; cb.set_commit = saHpiSensorTable_set_commit; cb.set_free = saHpiSensorTable_set_free; cb.set_undo = saHpiSensorTable_set_undo; DEBUGMSGTL (("initialize_table_saHpiSensorTable", "Registering table saHpiSensorTable " "as a table array\n")); netsnmp_table_container_register (my_handler, table_info, &cb, cb.container, 1); netsnmp_register_read_only_counter32_instance ("sensor_count", saHpiSensorCount_oid, OID_LENGTH (saHpiSensorCount_oid), &sensor_count, NULL); }