/** Initializes the snmp module */
void
init_snmp_mib_5_5(void)
{
DEBUGMSGTL(("snmp", "Initializing\n"));
NETSNMP_REGISTER_STATISTIC_HANDLER(
netsnmp_create_handler_registration(
"mibII/snmp", handle_snmp, snmp_oid, OID_LENGTH(snmp_oid),
HANDLER_CAN_RONLY),
1, SNMP);
{
oid snmpEnableAuthenTraps_oid[] = { SNMP_OID, 30, 0 };
static netsnmp_watcher_info enableauthen_info;
netsnmp_handler_registration *reg =
netsnmp_create_update_handler_registration(
"mibII/snmpEnableAuthenTraps",
snmpEnableAuthenTraps_oid,
OID_LENGTH(snmpEnableAuthenTraps_oid),
HANDLER_CAN_RWRITE, &snmp_enableauthentrapsset);
netsnmp_inject_handler(reg, netsnmp_get_truthvalue());
netsnmp_register_watched_instance(
reg,
netsnmp_init_watcher_info(
&enableauthen_info,
&snmp_enableauthentraps, sizeof(snmp_enableauthentraps),
ASN_INTEGER, WATCHER_FIXED_SIZE));
}
#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
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
snmp_enableauthentraps_store, NULL);
}
/*
* init_expExpressionTable():
* Initialization routine. This is called when the agent starts up.
* At a minimum, registration of your variables should take place here.
*/
void
init_expExpressionTable(void)
{
/*
* register ourselves with the agent to handle our mib tree
*/
REGISTER_MIB("expExpressionTable", expExpressionTable_variables,
variable2, expExpressionTable_variables_oid);
/*
* register our config handler(s) to deal with registrations
*/
snmpd_register_config_handler("expExpressionTable",
parse_expExpressionTable, NULL, NULL);
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
store_expExpressionTable, NULL);
DEBUGMSGTL(("expExpressionTable", "done.\n"));
}
void init_pingResultsTable (void)
{
DEBUGMSGTL (("pingResultsTable", "initializing... "));
/*
* register ourselves with the agent to handle our mib tree
*/
REGISTER_MIB ("pingResultsTable", pingResultsTable_variables, variable2, pingResultsTable_variables_oid);
/*
* register our config handler(s) to deal with registrations
*/
snmpd_register_config_handler ("pingResultsTable", parse_pingResultsTable, NULL, NULL);
/*
* we need to be called back later to store our data
*/
snmp_register_callback (SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA, store_pingResultsTable, NULL);
DEBUGMSGTL (("pingResultsTable", "done.\n"));
}
static void init_asterisk_mib(void)
{
static struct variable4 asterisk_vars[] = {
{ASTVERSTRING, ASN_OCTET_STR, RONLY, ast_var_Version, 2, {ASTVERSION, ASTVERSTRING}},
{ASTVERTAG, ASN_UNSIGNED, RONLY, ast_var_Version, 2, {ASTVERSION, ASTVERTAG}},
{ASTCONFUPTIME, ASN_TIMETICKS, RONLY, ast_var_Config, 2, {ASTCONFIGURATION, ASTCONFUPTIME}},
{ASTCONFRELOADTIME, ASN_TIMETICKS, RONLY, ast_var_Config, 2, {ASTCONFIGURATION, ASTCONFRELOADTIME}},
{ASTCONFPID, ASN_INTEGER, RONLY, ast_var_Config, 2, {ASTCONFIGURATION, ASTCONFPID}},
{ASTCONFSOCKET, ASN_OCTET_STR, RONLY, ast_var_Config, 2, {ASTCONFIGURATION, ASTCONFSOCKET}},
{ASTCONFACTIVECALLS, ASN_GAUGE, RONLY, ast_var_Config, 2, {ASTCONFIGURATION, ASTCONFACTIVECALLS}},
{ASTCONFPROCESSEDCALLS, ASN_COUNTER, RONLY, ast_var_Config, 2, {ASTCONFIGURATION, ASTCONFPROCESSEDCALLS}},
{ASTMODCOUNT, ASN_INTEGER, RONLY, ast_var_Modules , 2, {ASTMODULES, ASTMODCOUNT}},
{ASTINDCOUNT, ASN_INTEGER, RONLY, ast_var_indications, 2, {ASTINDICATIONS, ASTINDCOUNT}},
{ASTINDCURRENT, ASN_OCTET_STR, RONLY, ast_var_indications, 2, {ASTINDICATIONS, ASTINDCURRENT}},
{ASTINDINDEX, ASN_INTEGER, RONLY, ast_var_indications_table, 4, {ASTINDICATIONS, ASTINDTABLE, 1, ASTINDINDEX}},
{ASTINDCOUNTRY, ASN_OCTET_STR, RONLY, ast_var_indications_table, 4, {ASTINDICATIONS, ASTINDTABLE, 1, ASTINDCOUNTRY}},
{ASTINDALIAS, ASN_OCTET_STR, RONLY, ast_var_indications_table, 4, {ASTINDICATIONS, ASTINDTABLE, 1, ASTINDALIAS}},
{ASTINDDESCRIPTION, ASN_OCTET_STR, RONLY, ast_var_indications_table, 4, {ASTINDICATIONS, ASTINDTABLE, 1, ASTINDDESCRIPTION}},
{ASTCHANCOUNT, ASN_GAUGE, RONLY, ast_var_channels, 2, {ASTCHANNELS, ASTCHANCOUNT}},
{ASTCHANINDEX, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANINDEX}},
{ASTCHANNAME, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANNAME}},
{ASTCHANLANGUAGE, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANLANGUAGE}},
{ASTCHANTYPE, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANTYPE}},
{ASTCHANMUSICCLASS, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMUSICCLASS}},
{ASTCHANBRIDGE, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANBRIDGE}},
{ASTCHANMASQ, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMASQ}},
{ASTCHANMASQR, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMASQR}},
{ASTCHANWHENHANGUP, ASN_TIMETICKS, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANWHENHANGUP}},
{ASTCHANAPP, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANAPP}},
{ASTCHANDATA, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANDATA}},
{ASTCHANCONTEXT, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCONTEXT}},
{ASTCHANMACROCONTEXT, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMACROCONTEXT}},
{ASTCHANMACROEXTEN, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMACROEXTEN}},
{ASTCHANMACROPRI, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMACROPRI}},
{ASTCHANEXTEN, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANEXTEN}},
{ASTCHANPRI, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANPRI}},
{ASTCHANACCOUNTCODE, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANACCOUNTCODE}},
{ASTCHANFORWARDTO, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANFORWARDTO}},
{ASTCHANUNIQUEID, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANUNIQUEID}},
{ASTCHANCALLGROUP, ASN_UNSIGNED, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCALLGROUP}},
{ASTCHANPICKUPGROUP, ASN_UNSIGNED, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANPICKUPGROUP}},
{ASTCHANSTATE, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANSTATE}},
{ASTCHANMUTED, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMUTED}},
{ASTCHANRINGS, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANRINGS}},
{ASTCHANCIDDNID, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDDNID}},
{ASTCHANCIDNUM, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDNUM}},
{ASTCHANCIDNAME, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDNAME}},
{ASTCHANCIDANI, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDANI}},
{ASTCHANCIDRDNIS, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDRDNIS}},
{ASTCHANCIDPRES, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDPRES}},
{ASTCHANCIDANI2, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDANI2}},
{ASTCHANCIDTON, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDTON}},
{ASTCHANCIDTNS, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDTNS}},
{ASTCHANAMAFLAGS, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANAMAFLAGS}},
{ASTCHANADSI, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANADSI}},
{ASTCHANTONEZONE, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANTONEZONE}},
{ASTCHANHANGUPCAUSE, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANHANGUPCAUSE}},
{ASTCHANVARIABLES, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANVARIABLES}},
{ASTCHANFLAGS, ASN_OCTET_STR, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANFLAGS}},
{ASTCHANTRANSFERCAP, ASN_INTEGER, RONLY, ast_var_channels_table, 4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANTRANSFERCAP}},
{ASTCHANTYPECOUNT, ASN_INTEGER, RONLY, ast_var_channel_types, 2, {ASTCHANNELS, ASTCHANTYPECOUNT}},
{ASTCHANTYPEINDEX, ASN_INTEGER, RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPEINDEX}},
{ASTCHANTYPENAME, ASN_OCTET_STR, RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPENAME}},
{ASTCHANTYPEDESC, ASN_OCTET_STR, RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPEDESC}},
{ASTCHANTYPEDEVSTATE, ASN_INTEGER, RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPEDEVSTATE}},
{ASTCHANTYPEINDICATIONS, ASN_INTEGER, RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPEINDICATIONS}},
{ASTCHANTYPETRANSFER, ASN_INTEGER, RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPETRANSFER}},
{ASTCHANTYPECHANNELS, ASN_GAUGE, RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPECHANNELS}},
{ASTCHANBRIDGECOUNT, ASN_GAUGE, RONLY, ast_var_channel_bridge, 3, {ASTCHANNELS, ASTCHANSCALARS, ASTCHANBRIDGECOUNT}},
};
register_sysORTable(asterisk_oid, OID_LENGTH(asterisk_oid),
"ASTERISK-MIB implementation for Asterisk.");
REGISTER_MIB("res_snmp", asterisk_vars, variable4, asterisk_oid);
snmp_register_callback(SNMP_CALLBACK_LIBRARY,
SNMP_CALLBACK_SHUTDOWN,
term_asterisk_mib, NULL);
}
static void
initialize_internal(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
void *logger_client_arg = NULL;
char *master_agentx_socket = NULL;
char *ping_interval_string = NULL;
uint16_t ping_interval = 0;
state = SNMPMGR_NONE;
/* `is_thread` is able to be changed only once here */
is_thread = is_thread_dummy;
if (is_thread == false && thdptr_dummy != NULL) {
*thdptr_dummy = NULL;
} else if (thdptr_dummy != NULL) {
*thdptr_dummy = &snmpmgr;
} else {
/* never reached! */
return;
}
if (lagopus_mutex_create(&snmp_lock) != LAGOPUS_RESULT_OK) {
return;
}
if (lagopus_mutex_create(&snmp_state_lock) != LAGOPUS_RESULT_OK) {
return;
}
snmp_set_do_debugging(false);
/* setup Net-SNMP logger to use the lagopus logging function */
if (snmp_register_callback(SNMP_CALLBACK_LIBRARY,
SNMP_CALLBACK_LOGGING,
snmp_log_callback_wrapper,
logger_client_arg) != SNMPERR_SUCCESS) {
return;
}
snmp_enable_calllog();
/* setup the SNMP module to be Agentx subagent */
netsnmp_enable_subagent();
#ifdef THE_CONFSYS_ERA
master_agentx_socket = config_get("snmp master-agentx-socket WORD");
if (master_agentx_socket == NULL) {
config_set_default("snmp master-agentx-socket WORD",
(char *)DEFAULT_SNMPMGR_AGENTX_SOCKET);
master_agentx_socket = config_get("snmp master-agentx-socket WORD");
}
#else
/*
* FIXME:
* Fetch it from the datastore.
*/
master_agentx_socket = (char *)DEFAULT_SNMPMGR_AGENTX_SOCKET;
#endif /* THE_CONFSYS_ERA */
lagopus_msg_debug(25, "master agentx socket is %s\n", master_agentx_socket);
if (netsnmp_ds_set_string(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_X_SOCKET,
master_agentx_socket)
!= SNMPERR_SUCCESS) {
initialize_ret = LAGOPUS_RESULT_SNMP_API_ERROR;
return;
}
/* don't read/write configuration files */
if (netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_DONT_PERSIST_STATE,
true) != SNMPERR_SUCCESS) {
initialize_ret = LAGOPUS_RESULT_SNMP_API_ERROR;
return;
}
if (netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_DISABLE_PERSISTENT_LOAD,
true) != SNMPERR_SUCCESS) {
initialize_ret = LAGOPUS_RESULT_SNMP_API_ERROR;
return;
}
/* the interval [sec] to send ping to AgentX master agent */
#ifdef THE_CONFSYS_ERA
ping_interval_string = config_get("snmp ping-interval-second 1-255");
if (ping_interval_string != NULL &&
(ret = check_ping_interval(ping_interval_string, &ping_interval))
!= LAGOPUS_RESULT_OK) {
config_set_default("snmp ping-interval-second 1-255",
(char *) __STR__(DEFAULT_SNMPMGR_AGENTX_PING_INTERVAL_SEC));
ping_interval_string = config_get("snmp ping-interval-second 1-255");
ping_interval = DEFAULT_SNMPMGR_AGENTX_PING_INTERVAL_SEC; /* default value */
}
#else
/*
* FIXME:
* Fetch it from the datastore.
*/
ping_interval = DEFAULT_SNMPMGR_AGENTX_PING_INTERVAL_SEC;
#endif /* THE_CONFSYS_ERA */
if (netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_AGENTX_PING_INTERVAL,
(int)ping_interval)
!= SNMPERR_SUCCESS) {
initialize_ret = LAGOPUS_RESULT_SNMP_API_ERROR;
return;
}
if (init_agent(SNMP_TYPE) != SNMPERR_SUCCESS) {
initialize_ret = LAGOPUS_RESULT_SNMP_API_ERROR;
return;
}
if ((ret = lagopus_hashmap_create(&iftable_entry_hash,
LAGOPUS_HASHMAP_TYPE_STRING,
delete_entry)) != LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
exit(1);
}
init_ifTable();
init_ifNumber();
init_dot1dBaseBridgeAddress();
init_dot1dBaseNumPorts();
init_dot1dBasePortTable();
init_dot1dBaseType();
if (is_thread == false) {
initialize_ret = LAGOPUS_RESULT_OK;
} else {
keep_running = true;
initialize_ret = lagopus_thread_create(&snmpmgr,
snmpmgr_thread_loop,
snmpmgr_thread_finally_called,
NULL,
"snmpmgr",
NULL);
}
lagopus_msg_info("SNMP manager initialized.\n");
}
void
init_snmpTlstmCertToTSNTable_context(const char *contextName)
{
oid reg_oid[] = { SNMP_TLS_TM_CERT_TABLE };
const size_t reg_oid_len = OID_LENGTH(reg_oid);
netsnmp_handler_registration *reg;
netsnmp_table_registration_info *info;
netsnmp_cache *cache;
netsnmp_watcher_info *watcher;
const char *mib_map_help =
MAP_MIB_CONFIG_TOKEN " table persistence (internal use)";
DEBUGMSGTL(("tlstmCertToSN:init",
"initializing table tlstmCertToTSNTable\n"));
reg = netsnmp_create_handler_registration
("tlstmCertToTSNTable", tlstmCertToTSNTable_handler,
reg_oid, reg_oid_len,
HANDLER_CAN_RWRITE);
if (NULL == reg) {
snmp_log(LOG_ERR,
"error creating handler registration for tlstmCertToSN\n");
return;
}
if (NULL != contextName)
reg->contextName = strdup(contextName);
_table = netsnmp_tdata_create_table("tlstmCertToTSNTable", 0);
if (NULL == _table) {
snmp_log(LOG_ERR,
"error creating tdata table for tlstmCertToTSNTable\n");
return;
}
info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (NULL == info) {
snmp_log(LOG_ERR,
"error creating table info for tlstmCertToTSNTable\n");
netsnmp_tdata_delete_table(_table);
_table = NULL;
return;
}
netsnmp_table_helper_add_indexes(info,
/* index: tlstmCertToTSNID */
ASN_UNSIGNED, 0);
info->min_column = SNMPTLSTMCERTTOTSN_TABLE_MIN_COL;
info->max_column = SNMPTLSTMCERTTOTSN_TABLE_MAX_COL;
/*
* cache init
*/
cache = netsnmp_cache_create(30, (NetsnmpCacheLoad*)_cache_load,
(NetsnmpCacheFree*)_cache_free,
reg_oid,
reg_oid_len);
if (NULL == cache) {
snmp_log(LOG_ERR,"error creating cache for tlstmCertToTSNTable\n");
netsnmp_tdata_delete_table(_table);
_table = NULL;
return;
}
cache->magic = (void *)_table;
cache->flags = NETSNMP_CACHE_DONT_INVALIDATE_ON_SET;
netsnmp_tdata_register(reg, _table, info);
if (cache)
netsnmp_inject_handler_before( reg, netsnmp_cache_handler_get(cache),
"table_container");
/*
* register scalars
*/
reg_oid[10] = 1;
reg = netsnmp_create_handler_registration("snmpTlstmCertToTSNCount",
_count_handler, reg_oid,
OID_LENGTH(reg_oid),
HANDLER_CAN_RONLY);
if (NULL == reg)
snmp_log(LOG_ERR,
"could not create handler for snmpTlstmCertToTSNCount\n");
else {
if (NULL != contextName)
reg->contextName = strdup(contextName);
netsnmp_register_scalar(reg);
if (cache)
netsnmp_inject_handler_before(reg, netsnmp_cache_handler_get(cache),
"table_container");
}
reg_oid[10] = 2;
reg = netsnmp_create_handler_registration(
"snmpTlstmCertToTSNTableLastChanged", NULL, reg_oid,
OID_LENGTH(reg_oid), HANDLER_CAN_RONLY);
watcher = netsnmp_create_watcher_info((void*)&_last_changed,
sizeof(_last_changed),
ASN_TIMETICKS,
WATCHER_FIXED_SIZE);
if ((NULL == reg) || (NULL == watcher))
snmp_log(LOG_ERR,
"could not create handler for snmpTlstmCertToTSNCount\n");
else {
if (NULL != contextName)
reg->contextName = strdup(contextName);
netsnmp_register_watched_scalar(reg, watcher);
}
/*
* persistence
*/
register_config_handler(NULL, MAP_MIB_CONFIG_TOKEN, _parse_mib_maps, NULL,
mib_map_help);
if (snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
_save_maps, NULL) != SNMP_ERR_NOERROR)
snmp_log(LOG_ERR, "error registering for STORE_DATA callback "
"for certToTSN\n");
}
/*******************************************************************-o-******
* init_snmpv3
*
* Parameters:
* *type Label for the config file "type" used by calling entity.
*
* Set time and engineID.
* Set parsing functions for config file tokens.
* Initialize SNMP Crypto API (SCAPI).
*/
void
init_snmpv3(const char *type)
{
#if SNMP_USE_TIMES
struct tms dummy;
/* fixme: -1 is fault code... */
snmpv3startClock = times(&dummy);
/* remember how many ticks per second there are, since times() returns this */
clockticks = sysconf(_SC_CLK_TCK);
#endif /* SNMP_USE_TIMES */
gettimeofday(&snmpv3starttime, NULL);
if (!type)
type = "__snmpapp__";
/*
* we need to be called back later
*/
snmp_register_callback(SNMP_CALLBACK_LIBRARY,
SNMP_CALLBACK_POST_READ_CONFIG,
init_snmpv3_post_config, NULL);
snmp_register_callback(SNMP_CALLBACK_LIBRARY,
SNMP_CALLBACK_POST_PREMIB_READ_CONFIG,
init_snmpv3_post_premib_config, NULL);
/*
* we need to be called back later
*/
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
snmpv3_store, (void *) strdup(type));
/*
* Free stuff at shutdown time
*/
snmp_register_callback(SNMP_CALLBACK_LIBRARY,
SNMP_CALLBACK_SHUTDOWN,
free_enginetime_on_shutdown, NULL);
/*
* initialize submodules
*/
/*
* NOTE: this must be after the callbacks are registered above,
* since they need to be called before the USM callbacks.
*/
init_secmod();
/*
* register all our configuration handlers (ack, there's a lot)
*/
/*
* handle engineID setup before everything else which may depend on it
*/
register_prenetsnmp_mib_handler(type, "engineID", engineID_conf, NULL,
"string");
register_prenetsnmp_mib_handler(type, "oldEngineID", oldengineID_conf,
NULL, NULL);
register_prenetsnmp_mib_handler(type, "engineIDType",
engineIDType_conf, NULL, "num");
register_prenetsnmp_mib_handler(type, "engineIDNic", engineIDNic_conf,
NULL, "string");
register_config_handler(type, "engineBoots", engineBoots_conf, NULL,
NULL);
/*
* default store config entries
*/
netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defSecurityName",
NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SECNAME);
netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defContext",
NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_CONTEXT);
netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defPassphrase",
NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_PASSPHRASE);
netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defAuthPassphrase",
NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_AUTHPASSPHRASE);
netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defPrivPassphrase",
NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_PRIVPASSPHRASE);
netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defAuthMasterKey",
NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_AUTHMASTERKEY);
netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defPrivMasterKey",
NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_PRIVMASTERKEY);
netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defAuthLocalizedKey",
NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_AUTHLOCALIZEDKEY);
netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defPrivLocalizedKey",
NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_PRIVLOCALIZEDKEY);
register_config_handler("snmp", "defVersion", version_conf, NULL,
"1|2c|3");
register_config_handler("snmp", "defAuthType", snmpv3_authtype_conf,
NULL, "MD5|SHA");
register_config_handler("snmp", "defPrivType", snmpv3_privtype_conf,
NULL,
#ifdef HAVE_AES
"DES|AES");
#else
"DES (AES support not available)");
#endif
register_config_handler("snmp", "defSecurityLevel",
snmpv3_secLevel_conf, NULL,
"noAuthNoPriv|authNoPriv|authPriv");
register_config_handler(type, "userSetAuthPass", usm_set_password,
NULL, NULL);
register_config_handler(type, "userSetPrivPass", usm_set_password,
NULL, NULL);
register_config_handler(type, "userSetAuthKey", usm_set_password, NULL,
NULL);
register_config_handler(type, "userSetPrivKey", usm_set_password, NULL,
NULL);
register_config_handler(type, "userSetAuthLocalKey", usm_set_password,
NULL, NULL);
register_config_handler(type, "userSetPrivLocalKey", usm_set_password,
NULL, NULL);
}
void
init_diskio(void)
{
/*
* Define a 'variable' structure that is a representation of our mib.
*/
/*
* first, we have to pick the variable type. They are all defined in
* the var_struct.h file in the agent subdirectory. I'm picking the
* variable2 structure since the longest sub-component of the oid I
* want to load is .2.1 and .2.2 so I need at most 2 spaces in the
* last entry.
*/
struct variable2 diskio_variables[] = {
{DISKIO_INDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_diskio, 1, {1}},
{DISKIO_DEVICE, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
var_diskio, 1, {2}},
{DISKIO_NREAD, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_diskio, 1, {3}},
{DISKIO_NWRITTEN, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_diskio, 1, {4}},
{DISKIO_READS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_diskio, 1, {5}},
{DISKIO_WRITES, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_diskio, 1, {6}},
#if defined(HAVE_GETDEVS) || defined(HAVE_DEVSTAT_GETDEVS) || defined(linux)
{DISKIO_LA1, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_diskio, 1, {9}},
{DISKIO_LA5, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_diskio, 1, {10}},
{DISKIO_LA15, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_diskio, 1, {11}},
#endif
{DISKIO_NREADX, ASN_COUNTER64, NETSNMP_OLDAPI_RONLY,
var_diskio, 1, {12}},
{DISKIO_NWRITTENX, ASN_COUNTER64, NETSNMP_OLDAPI_RONLY,
var_diskio, 1, {13}},
};
/*
* Define the OID pointer to the top of the mib tree that we're
* registering underneath.
*/
oid diskio_variables_oid[] =
{ 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1 };
/*
* register ourselves with the agent to handle our mib tree
*
* This is a macro defined in ../../snmp_vars.h. The arguments are:
*
* descr: A short description of the mib group being loaded.
* var: The variable structure to load.
* vartype: The variable structure used to define it (variable2, variable4, ...)
* theoid: A *initialized* *exact length* oid pointer.
* (sizeof(theoid) *must* return the number of elements!)
*/
REGISTER_MIB("diskio", diskio_variables, variable2,
diskio_variables_oid);
#ifdef solaris2
kc = kstat_open();
if (kc == NULL)
snmp_log(LOG_ERR, "diskio: Couldn't open kstat\n");
#endif
#ifdef darwin
/*
* Get the I/O Kit communication handle.
*/
IOMasterPort(bootstrap_port, &masterPort);
#endif
#if defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7)
/*
* initialize values to gather information on first request
*/
ps_numdisks = 0;
ps_disk = NULL;
#endif
#if defined (HAVE_GETDEVS) || defined(HAVE_DEVSTAT_GETDEVS) || defined(linux)
devla_getstats(0, NULL);
/* collect LA data regularly */
snmp_alarm_register(DISKIO_SAMPLE_INTERVAL, SA_REPEAT, devla_getstats, NULL);
#endif
#ifdef linux
char *app = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_APPTYPE);
netsnmp_ds_register_config(ASN_BOOLEAN, app, "diskio_exclude_fd",
NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_DISKIO_NO_FD);
netsnmp_ds_register_config(ASN_BOOLEAN, app, "diskio_exclude_loop",
NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_DISKIO_NO_LOOP);
netsnmp_ds_register_config(ASN_BOOLEAN, app, "diskio_exclude_ram",
NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_DISKIO_NO_RAM);
/* or possible an exclusion pattern? */
snmp_register_callback(SNMP_CALLBACK_APPLICATION,
SNMPD_CALLBACK_PRE_UPDATE_CONFIG,
diskio_free_config, NULL);
#endif
}
void
init_system_mib(void)
{
char tmpbuf[1024];
#ifdef HAVE_UNAME
struct utsname utsName;
uname(&utsName);
snprintf(version_descr, sizeof(version_descr),
"%s %s %s %s %s", utsName.sysname,
utsName.nodename, utsName.release, utsName.version,
utsName.machine);
version_descr[ sizeof(version_descr)-1 ] = 0;
#else
#if HAVE_EXECV
struct extensible extmp;
/*
* set default values of system stuff
*/
sprintf(extmp.command, "%s -a", UNAMEPROG);
/*
* setup defaults
*/
extmp.type = EXECPROC;
extmp.next = NULL;
exec_command(&extmp);
strncpy(version_descr, extmp.output, sizeof(version_descr));
version_descr[sizeof(version_descr) - 1] = 0;
version_descr[strlen(version_descr) - 1] = 0; /* chomp new line */
#else
#if (defined (WIN32) && defined (HAVE_WIN32_PLATFORM_SDK)) || defined (mingw32)
windowsOSVersionString(version_descr, sizeof(version_descr));
#else
strcpy(version_descr, "unknown");
#endif
#endif
#endif
#ifdef HAVE_GETHOSTNAME
gethostname(sysName, sizeof(sysName));
#else
#ifdef HAVE_UNAME
strncpy(sysName, utsName.nodename, sizeof(sysName));
#else
#if defined (HAVE_EXECV) && !defined (mingw32)
sprintf(extmp.command, "%s -n", UNAMEPROG);
/*
* setup defaults
*/
extmp.type = EXECPROC;
extmp.next = NULL;
exec_command(&extmp);
strncpy(sysName, extmp.output, sizeof(sysName));
sysName[strlen(sysName) - 1] = 0; /* chomp new line */
#else
strcpy(sysName, "unknown");
#endif /* HAVE_EXECV */
#endif /* HAVE_UNAME */
#endif /* HAVE_GETHOSTNAME */
#if (defined (WIN32) && defined (HAVE_WIN32_PLATFORM_SDK)) || defined (mingw32)
{
HKEY hKey;
/* Default sysContact is the registered windows user */
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS) {
char registeredOwner[256] = "";
DWORD registeredOwnerSz = 256;
if (RegQueryValueEx(hKey, "RegisteredOwner", NULL, NULL, (LPBYTE)registeredOwner, ®isteredOwnerSz) == ERROR_SUCCESS) {
strcpy(sysContact, registeredOwner);
}
RegCloseKey(hKey);
}
}
#endif
/* default sysObjectID */
// Modified by Gavin Lin, 2008/10/30
// memcpy(sysObjectID, version_sysoid, version_sysoid_len * sizeof(oid));
// sysObjectIDLength = version_sysoid_len;
#ifdef CONFIG_MODEL_LRTXXX
/* purpose : 0012697 author : Gavin.Lin date : 2010-06-22 */
/* description : Customer requirements */
kd_doCommand("VERSION MODEL", CMD_PRINT, ASH_DO_NOTHING, tmpbuf);
if (!strcmp("LRT214", tmpbuf))
{
memcpy(sysObjectID, nk_sysobjectid_214, nk_sysobjectid_len * sizeof(oid));
}
if (!strcmp("LRT224", tmpbuf))
{
memcpy(sysObjectID, nk_sysobjectid_224, nk_sysobjectid_len * sizeof(oid));
}
#else
memcpy(sysObjectID, nk_sysobjectid, nk_sysobjectid_len * sizeof(oid));
#endif
sysObjectIDLength = nk_sysobjectid_len;
/*
* register ourselves with the agent to handle our mib tree
*/
REGISTER_MIB("mibII/system", system_variables, variable1,
system_variables_oid);
if (++system_module_count == 3)
REGISTER_SYSOR_ENTRY(system_module_oid,
"The MIB module for SNMPv2 entities");
sysContactSet = sysLocationSet = sysNameSet = 0;
/*
* register our config handlers
*/
snmpd_register_config_handler("sysdescr",
system_parse_config_sysdescr, NULL,
"description");
snmpd_register_config_handler("syslocation",
system_parse_config_sysloc, NULL,
"location");
snmpd_register_config_handler("syscontact", system_parse_config_syscon,
NULL, "contact-name");
snmpd_register_config_handler("sysname", system_parse_config_sysname,
NULL, "node-name");
snmpd_register_config_handler("psyslocation",
system_parse_config_sysloc, NULL, NULL);
snmpd_register_config_handler("psyscontact",
system_parse_config_syscon, NULL, NULL);
snmpd_register_config_handler("psysname", system_parse_config_sysname,
NULL, NULL);
snmpd_register_config_handler("sysservices",
system_parse_config_sysServices, NULL,
"NUMBER");
snmpd_register_config_handler("sysobjectid",
system_parse_config_sysObjectID, NULL,
"OID");
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
system_store, NULL);
}
void
init_snmp_alarm(void) {
start_alarms = 0;
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_POST_READ_CONFIG,
init_alarm_post_config, NULL);
}
/*******************************************************************-o-******
* init_snmpv3
*
* Parameters:
* *type Label for the config file "type" used by calling entity.
*
* Set time and engineID.
* Set parsing functions for config file tokens.
* Initialize SNMP Crypto API (SCAPI).
*/
void
init_snmpv3(const char *type) {
gettimeofday(&snmpv3starttime, NULL);
if (type == NULL)
type = "snmpapp";
if (type && !strcmp(type,"snmpapp")) {
setup_engineID(NULL,"__snmpapp__");
} else {
setup_engineID(NULL, NULL);
}
/* initialize submodules */
init_usm();
/* we need to be called back later */
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_POST_READ_CONFIG,
init_snmpv3_post_config, NULL);
/* we need to be called back later */
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
snmpv3_store, (void *) type);
#if !defined(USE_INTERNAL_MD5)
/* doesn't belong here at all */
sc_init();
#endif /* !USE_INTERNAL_MD5 */
/* register all our configuration handlers (ack, there's a lot) */
/* handle engineID setup before everything else which may depend on it */
register_premib_handler(type,"engineID", engineID_conf, NULL, "string");
register_premib_handler(type,"oldEngineID", oldengineID_conf, NULL, NULL);
register_config_handler(type,"engineBoots", engineBoots_conf, NULL, NULL);
/* default store config entries */
ds_register_config(ASN_OCTET_STR, "snmp", "defSecurityName", DS_LIBRARY_ID,
DS_LIB_SECNAME);
ds_register_config(ASN_OCTET_STR, "snmp", "defContext", DS_LIBRARY_ID,
DS_LIB_CONTEXT);
ds_register_config(ASN_OCTET_STR, "snmp", "defPassphrase", DS_LIBRARY_ID,
DS_LIB_PASSPHRASE);
ds_register_config(ASN_OCTET_STR, "snmp", "defAuthPassphrase", DS_LIBRARY_ID,
DS_LIB_AUTHPASSPHRASE);
ds_register_config(ASN_OCTET_STR, "snmp", "defPrivPassphrase", DS_LIBRARY_ID,
DS_LIB_PRIVPASSPHRASE);
register_config_handler("snmp","defVersion", version_conf, NULL, "1|2c|3");
register_config_handler("snmp","defAuthType", snmpv3_authtype_conf, NULL,
"MD5|SHA");
register_config_handler("snmp","defPrivType", snmpv3_privtype_conf, NULL,
"DES (currently the only possible value)");
register_config_handler("snmp","defSecurityLevel", snmpv3_secLevel_conf,
NULL, "noAuthNoPriv|authNoPriv|authPriv");
register_config_handler(type,"userSetAuthPass", usm_set_password, NULL,
"secname engineIDLen engineID pass");
register_config_handler(type,"userSetPrivPass", usm_set_password, NULL,
"secname engineIDLen engineID pass");
register_config_handler(type,"userSetAuthKey", usm_set_password, NULL,
"secname engineIDLen engineID KuLen Ku");
register_config_handler(type,"userSetPrivKey", usm_set_password, NULL,
"secname engineIDLen engineID KuLen Ku");
register_config_handler(type,"userSetAuthLocalKey", usm_set_password, NULL,
"secname engineIDLen engineID KulLen Kul");
register_config_handler(type,"userSetPrivLocalKey", usm_set_password, NULL,
"secname engineIDLen engineID KulLen Kul");
}
/** 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
}
void
init_system_mib(void)
{
#ifdef HAVE_UNAME
struct utsname utsName;
uname(&utsName);
snprintf(version_descr, sizeof(version_descr),
"%s %s %s %s %s", utsName.sysname,
utsName.nodename, utsName.release, utsName.version,
utsName.machine);
version_descr[ sizeof(version_descr)-1 ] = 0;
#else
#if HAVE_EXECV
struct extensible extmp;
/*
* set default values of system stuff
*/
if (asprintf(&extmp.command, "%s -a", UNAMEPROG) < 0)
extmp.command = NULL;
/*
* setup defaults
*/
extmp.type = EXECPROC;
extmp.next = NULL;
exec_command(&extmp);
strlcpy(version_descr, extmp.output, sizeof(version_descr));
if (strlen(version_descr) >= 1)
version_descr[strlen(version_descr) - 1] = 0; /* chomp new line */
#else
#if (defined (WIN32) && defined (HAVE_WIN32_PLATFORM_SDK)) || defined (mingw32)
windowsOSVersionString(version_descr, sizeof(version_descr));
#else
strcpy(version_descr, "unknown");
#endif
#endif
#endif
#ifdef HAVE_GETHOSTNAME
gethostname(sysName, sizeof(sysName));
#else
#ifdef HAVE_UNAME
strlcpy(sysName, utsName.nodename, sizeof(sysName));
#else
#if defined (HAVE_EXECV) && !defined (mingw32)
if (asprintf(&extmp.command, "%s -n", UNAMEPROG) < 0)
extmp.command = NULL;
/*
* setup defaults
*/
extmp.type = EXECPROC;
extmp.next = NULL;
exec_command(&extmp);
strlcpy(sysName, extmp.output, sizeof(sysName));
if (strlen(sysName) >= 1)
sysName[strlen(sysName) - 1] = 0; /* chomp new line */
#else
strcpy(sysName, "unknown");
#endif /* HAVE_EXECV */
#endif /* HAVE_UNAME */
#endif /* HAVE_GETHOSTNAME */
#if (defined (WIN32) && defined (HAVE_WIN32_PLATFORM_SDK)) || defined (mingw32)
{
HKEY hKey;
/* Default sysContact is the registered windows user */
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", 0,
KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS) {
char registeredOwner[256] = "";
DWORD registeredOwnerSz = 256;
if (RegQueryValueEx(hKey, "RegisteredOwner", NULL, NULL,
(LPBYTE)registeredOwner,
®isteredOwnerSz) == ERROR_SUCCESS) {
strlcpy(sysContact, registeredOwner, sizeof(sysContact));
}
RegCloseKey(hKey);
}
}
#endif
/* default sysObjectID */
memcpy(sysObjectID, version_sysoid, version_sysoid_len * sizeof(oid));
sysObjectIDByteLength = version_sysoid_len * sizeof(oid);
{
const oid sysDescr_oid[] = { 1, 3, 6, 1, 2, 1, 1, 1 };
static netsnmp_watcher_info sysDescr_winfo;
netsnmp_register_watched_scalar(
netsnmp_create_handler_registration(
"mibII/sysDescr", NULL, sysDescr_oid, OID_LENGTH(sysDescr_oid),
HANDLER_CAN_RONLY),
netsnmp_init_watcher_info(&sysDescr_winfo, version_descr, 0,
ASN_OCTET_STR, WATCHER_SIZE_STRLEN));
}
{
const oid sysObjectID_oid[] = { 1, 3, 6, 1, 2, 1, 1, 2 };
static netsnmp_watcher_info sysObjectID_winfo;
netsnmp_register_watched_scalar(
netsnmp_create_handler_registration(
"mibII/sysObjectID", NULL,
sysObjectID_oid, OID_LENGTH(sysObjectID_oid),
HANDLER_CAN_RONLY),
netsnmp_init_watcher_info6(
&sysObjectID_winfo, sysObjectID, 0, ASN_OBJECT_ID,
WATCHER_MAX_SIZE | WATCHER_SIZE_IS_PTR,
MAX_OID_LEN, &sysObjectIDByteLength));
}
{
const oid sysUpTime_oid[] = { 1, 3, 6, 1, 2, 1, 1, 3 };
netsnmp_register_scalar(
netsnmp_create_handler_registration(
"mibII/sysUpTime", handle_sysUpTime,
sysUpTime_oid, OID_LENGTH(sysUpTime_oid),
HANDLER_CAN_RONLY));
}
{
const oid sysContact_oid[] = { 1, 3, 6, 1, 2, 1, 1, 4 };
static netsnmp_watcher_info sysContact_winfo;
#ifndef NETSNMP_NO_WRITE_SUPPORT
netsnmp_register_watched_scalar(
netsnmp_create_update_handler_registration(
"mibII/sysContact", sysContact_oid, OID_LENGTH(sysContact_oid),
HANDLER_CAN_RWRITE, &sysContactSet),
netsnmp_init_watcher_info(
&sysContact_winfo, sysContact, SYS_STRING_LEN - 1,
ASN_OCTET_STR, WATCHER_MAX_SIZE | WATCHER_SIZE_STRLEN));
#else /* !NETSNMP_NO_WRITE_SUPPORT */
netsnmp_register_watched_scalar(
netsnmp_create_update_handler_registration(
"mibII/sysContact", sysContact_oid, OID_LENGTH(sysContact_oid),
HANDLER_CAN_RONLY, &sysContactSet),
netsnmp_init_watcher_info(
&sysContact_winfo, sysContact, SYS_STRING_LEN - 1,
ASN_OCTET_STR, WATCHER_MAX_SIZE | WATCHER_SIZE_STRLEN));
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
}
{
const oid sysName_oid[] = { 1, 3, 6, 1, 2, 1, 1, 5 };
static netsnmp_watcher_info sysName_winfo;
#ifndef NETSNMP_NO_WRITE_SUPPORT
netsnmp_register_watched_scalar(
netsnmp_create_update_handler_registration(
"mibII/sysName", sysName_oid, OID_LENGTH(sysName_oid),
HANDLER_CAN_RWRITE, &sysNameSet),
netsnmp_init_watcher_info(
&sysName_winfo, sysName, SYS_STRING_LEN - 1, ASN_OCTET_STR,
WATCHER_MAX_SIZE | WATCHER_SIZE_STRLEN));
#else /* !NETSNMP_NO_WRITE_SUPPORT */
netsnmp_register_watched_scalar(
netsnmp_create_update_handler_registration(
"mibII/sysName", sysName_oid, OID_LENGTH(sysName_oid),
HANDLER_CAN_RONLY, &sysNameSet),
netsnmp_init_watcher_info(
&sysName_winfo, sysName, SYS_STRING_LEN - 1, ASN_OCTET_STR,
WATCHER_MAX_SIZE | WATCHER_SIZE_STRLEN));
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
}
{
const oid sysLocation_oid[] = { 1, 3, 6, 1, 2, 1, 1, 6 };
static netsnmp_watcher_info sysLocation_winfo;
#ifndef NETSNMP_NO_WRITE_SUPPORT
netsnmp_register_watched_scalar(
netsnmp_create_update_handler_registration(
"mibII/sysLocation", sysLocation_oid,
OID_LENGTH(sysLocation_oid),
HANDLER_CAN_RWRITE, &sysLocationSet),
netsnmp_init_watcher_info(
&sysLocation_winfo, sysLocation, SYS_STRING_LEN - 1,
ASN_OCTET_STR, WATCHER_MAX_SIZE | WATCHER_SIZE_STRLEN));
#else /* !NETSNMP_NO_WRITE_SUPPORT */
netsnmp_register_watched_scalar(
netsnmp_create_update_handler_registration(
"mibII/sysLocation", sysLocation_oid,
OID_LENGTH(sysLocation_oid),
HANDLER_CAN_RONLY, &sysLocationSet),
netsnmp_init_watcher_info(
&sysLocation_winfo, sysLocation, SYS_STRING_LEN - 1,
ASN_OCTET_STR, WATCHER_MAX_SIZE | WATCHER_SIZE_STRLEN));
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
}
{
const oid sysServices_oid[] = { 1, 3, 6, 1, 2, 1, 1, 7 };
netsnmp_register_read_only_int_scalar(
"mibII/sysServices", sysServices_oid, OID_LENGTH(sysServices_oid),
&sysServices, handle_sysServices);
}
if (++system_module_count == 3)
REGISTER_SYSOR_ENTRY(system_module_oid,
"The MIB module for SNMPv2 entities");
sysContactSet = sysLocationSet = sysNameSet = 0;
/*
* register our config handlers
*/
snmpd_register_config_handler("sysdescr",
system_parse_config_sysdescr, NULL,
"description");
snmpd_register_config_handler("syslocation",
system_parse_config_sysloc, NULL,
"location");
snmpd_register_config_handler("syscontact", system_parse_config_syscon,
NULL, "contact-name");
snmpd_register_config_handler("sysname", system_parse_config_sysname,
NULL, "node-name");
snmpd_register_config_handler("psyslocation",
system_parse_config_sysloc, NULL, NULL);
snmpd_register_config_handler("psyscontact",
system_parse_config_syscon, NULL, NULL);
snmpd_register_config_handler("psysname", system_parse_config_sysname,
NULL, NULL);
snmpd_register_config_handler("sysservices",
system_parse_config_sysServices, NULL,
"NUMBER");
snmpd_register_config_handler("sysobjectid",
system_parse_config_sysObjectID, NULL,
"OID");
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
system_store, NULL);
}
static void dumpAgtImpl(SmiModule *smiModule, char *baseName)
{
char *stubModuleName, *cModuleName;
FILE *f;
stubModuleName = xmalloc(strlen(baseName) + 10);
strcpy(stubModuleName, baseName);
strcat(stubModuleName, "-agt");
f = createFile(stubModuleName, ".c");
if (! f) {
xfree(stubModuleName);
return;
}
cModuleName = translateLower(smiModule->name);
fprintf(f,
"/*\n"
" * This C file has been generated by smidump "
SMI_VERSION_STRING ".\n"
" * It is intended to be used with the NET-SNMP agent library.\n"
" *\n"
" * This C file is derived from the %s module.\n"
" *\n * $I" "d$\n"
" */\n\n", smiModule->name );
fprintf(f,
"#include <stdio.h>\n"
"#include <string.h>\n"
"#include <malloc.h>\n"
"\n"
"#include \"%s.h\"\n"
"\n"
"#include <ucd-snmp/asn1.h>\n"
"#include <ucd-snmp/snmp.h>\n"
"#include <ucd-snmp/snmp_api.h>\n"
"#include <ucd-snmp/snmp_impl.h>\n"
"#include <ucd-snmp/snmp_vars.h>\n"
"\n",
baseName);
fprintf(f,
"static oid %s_caps[] = {0,0};\n"
"\n",
cModuleName);
fprintf(f,
"void init_%s(void)\n"
"{\n"
#if 0
/* create an entry in the sysORTable */
register_sysORTable(if_mib_caps, sizeof(if_mib_caps),
"IF-MIB implementation version 0.0.");
/* register the various parts of the MIB */
register_interfaces();
register_ifEntry();
/* register essential callbacks */
snmp_register_callback(SNMP_CALLBACK_LIBRARY,
SNMP_CALLBACK_SHUTDOWN,
term_if_mib, NULL);
#endif
"}\n"
"\n",
cModuleName);
fprintf(f,
"void deinit_%s()\n"
"{\n"
" unregister_sysORTable(%s_caps, sizeof(%s_caps));\n"
"}\n"
"\n",
cModuleName, cModuleName, cModuleName);
fprintf(f,
"int term_%s()\n"
"{\n"
" deinit_%s();\n"
" return 0;\n"
"}\n"
"\n",
cModuleName, cModuleName);
xfree(cModuleName);
if (fflush(f) || ferror(f)) {
perror("smidump: write error");
exit(1);
}
fclose(f);
xfree(stubModuleName);
}
