void init_hrh_storage(void) { char *appname; netsnmp_register_scalar( netsnmp_create_handler_registration("host/hrMemorySize", handle_memsize, hrMemorySize_oid, OID_LENGTH(hrMemorySize_oid), HANDLER_CAN_RONLY)); REGISTER_MIB("host/hr_storage", hrstore_variables, variable2, hrStorageTable_oid); appname = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_APPTYPE); netsnmp_ds_register_config(ASN_BOOLEAN, appname, "skipNFSInHostResources", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_SKIPNFSINHOSTRESOURCES); netsnmp_ds_register_config(ASN_BOOLEAN, appname, "realStorageUnits", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_REALSTORAGEUNITS); snmpd_register_config_handler("storageUseNFS", parse_storage_config, NULL, "1 | 2\t\t(1 = enable, 2 = disable)"); }
void netsnmp_ssh_ctor(void) { sshDomain.name = netsnmp_snmpSSHDomain; sshDomain.name_length = netsnmp_snmpSSHDomain_len; sshDomain.prefix = (const char **)calloc(2, sizeof(char *)); sshDomain.prefix[0] = "ssh"; sshDomain.f_create_from_tstring = NULL; sshDomain.f_create_from_tstring_new = netsnmp_ssh_create_tstring; sshDomain.f_create_from_ostring = netsnmp_ssh_create_ostring; register_config_handler("snmp", "sshtosnmpsocketperms", &sshdomain_parse_socket, NULL, "socketperms [username [groupname]]"); netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "sshtosnmpsocket", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SSHTOSNMP_SOCKET); netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "sshusername", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SSH_USERNAME); netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "sshpublickey", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SSH_PUBKEY); netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "sshprivatekey", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SSH_PRIVKEY); DEBUGMSGTL(("ssh", "registering the ssh domain\n")); netsnmp_tdomain_register(&sshDomain); }
void netsnmp_tlsbase_ctor(void) { /* bootstrap ssl since we'll need it */ netsnmp_init_openssl(); /* the private client cert to authenticate with */ netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "extraX509SubDir", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_CERT_EXTRA_SUBDIR); /* Do we have a CRL list? */ netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "x509CRLFile", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_X509_CRL_FILE); /* What TLS algorithms should be use */ netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "tlsAlgorithms", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_TLS_ALGORITMS); /* * for the client */ /* the public client cert to authenticate with */ register_config_handler("snmp", "clientCert", _parse_client_cert, NULL, NULL); /* * for the server */ /* The X509 server key to use */ register_config_handler("snmp", "serverCert", _parse_server_cert, NULL, NULL); /* * remove cert config ambiguity: localCert, peerCert */ netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "localCert", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_TLS_LOCAL_CERT); netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "peerCert", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_TLS_PEER_CERT); /* * register our boot-strapping needs */ snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_POST_PREMIB_READ_CONFIG, tls_bootstrap, NULL); }
/** Initialize the TSM security module */ void init_tsm(void) { struct snmp_secmod_def *def; int ret; def = SNMP_MALLOC_STRUCT(snmp_secmod_def); if (!def) { snmp_log(LOG_ERR, "Unable to malloc snmp_secmod struct, not registering TSM\n"); return; } def->encode_reverse = tsm_rgenerate_out_msg; def->decode = tsm_process_in_msg; def->session_open = tsm_session_init; def->pdu_free_state_ref = tsm_free_state_ref; def->pdu_clone = tsm_clone_pdu; def->pdu_free = tsm_free_pdu; def->probe_engineid = snmpv3_probe_contextEngineID_rfc5343; DEBUGMSGTL(("tsm","registering ourselves\n")); ret = register_sec_mod(NETSNMP_TSM_SECURITY_MODEL, "tsm", def); DEBUGMSGTL(("tsm"," returned %d\n", ret)); netsnmp_ds_register_config(ASN_BOOLEAN, "snmp", "tsmUseTransportPrefix", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_TSM_USE_PREFIX); }
/* * returns non-zero on error */ int subagent_pre_init(void) { DEBUGMSGTL(("agentx/subagent", "initializing....\n")); /* * set up callbacks to initiate master agent pings for this session */ netsnmp_ds_register_config(ASN_INTEGER, netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_APPTYPE), "agentxPingInterval", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_AGENTX_PING_INTERVAL); if (netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_ROLE) != SUB_AGENT) { return 0; } /* * if a valid ping interval has been defined, call agentx_reopen_session * * to try to connect to master or setup a ping alarm if it couldn't * * succeed */ if (netsnmp_ds_get_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_AGENTX_PING_INTERVAL) > 0) agentx_reopen_session(0, NULL); else /* if no ping interval was set up, just try to connect once */ subagent_open_master_session(); if (!main_session) return -1; DEBUGMSGTL(("agentx/subagent", "initializing.... DONE\n")); return 0; }
void init_ksm(void) { krb5_error_code retval; struct snmp_secmod_def *def; int i; netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defKSMKeytab", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_KSM_KEYTAB); netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defKSMServiceName", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_KSM_SERVICE_NAME); snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_POST_READ_CONFIG, init_snmpksm_post_config, NULL); if (kcontext == NULL) { retval = krb5_init_context(&kcontext); if (retval) { DEBUGMSGTL(("ksm", "krb5_init_context failed (%s), not " "registering KSM\n", error_message(retval))); return; } } for (i = 0; i < HASHSIZE; i++) ksm_hash_table[i] = NULL; def = SNMP_MALLOC_STRUCT(snmp_secmod_def); if (!def) { DEBUGMSGTL(("ksm", "Unable to malloc snmp_secmod struct, not " "registering KSM\n")); return; } def->encode_reverse = ksm_rgenerate_out_msg; def->decode = ksm_process_in_msg; def->session_open = ksm_session_init; def->pdu_free_state_ref = ksm_free_state_ref; def->pdu_free = ksm_free_pdu; def->pdu_clone = ksm_clone_pdu; register_sec_mod(2066432, "ksm", def); }
void agentx_config_init(void) { int agent_role = netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_ROLE); /* * Common tokens for master/subagent */ netsnmp_register_default_domain("agentx", "unix tcp"); netsnmp_register_default_target("agentx", "unix", NETSNMP_AGENTX_SOCKET); #define val(x) __STRING(x) netsnmp_register_default_target("agentx", "tcp", "localhost:" val(AGENTX_PORT)); #undef val agentx_register_config_handler("agentxsocket", agentx_parse_agentx_socket, NULL, "AgentX bind address"); #ifdef USING_AGENTX_MASTER_MODULE /* * tokens for master agent */ if (MASTER_AGENT == agent_role) { snmpd_register_config_handler("master", agentx_parse_master, NULL, "specify 'agentx' for AgentX support"); agentx_register_config_handler("agentxperms", agentx_parse_agentx_perms, NULL, "AgentX socket permissions: socket_perms [directory_perms [username|userid [groupname|groupid]]]"); agentx_register_config_handler("agentxRetries", agentx_parse_agentx_retries, NULL, "AgentX Retries"); agentx_register_config_handler("agentxTimeout", agentx_parse_agentx_timeout, NULL, "AgentX Timeout (seconds)"); } #endif /* USING_AGENTX_MASTER_MODULE */ #ifdef USING_AGENTX_SUBAGENT_MODULE /* * tokens for master agent */ if (SUB_AGENT == agent_role) { /* * set up callbacks to initiate master agent pings for this session */ netsnmp_ds_register_config(ASN_INTEGER, netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_APPTYPE), "agentxPingInterval", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_AGENTX_PING_INTERVAL); /* ping and/or reconnect by default every 15 seconds */ netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_AGENTX_PING_INTERVAL, 15); } #endif /* USING_AGENTX_SUBAGENT_MODULE */ }
void init_snmp_transport(void) { netsnmp_ds_register_config(ASN_BOOLEAN, "snmp", "dontLoadHostConfig", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_DONT_LOAD_HOST_FILES); }
void init_notification_log(void) { static oid my_nlmStatsGlobalNotificationsLogged_oid[] = { 1, 3, 6, 1, 2, 1, 92, 1, 2, 1, 0 }; static oid my_nlmStatsGlobalNotificationsBumped_oid[] = { 1, 3, 6, 1, 2, 1, 92, 1, 2, 2, 0 }; static oid my_nlmConfigGlobalEntryLimit_oid[] = { 1, 3, 6, 1, 2, 1, 92, 1, 1, 1, 0 }; static oid my_nlmConfigGlobalAgeOut_oid[] = { 1, 3, 6, 1, 2, 1, 92, 1, 1, 2, 0 }; /* * static variables */ netsnmp_register_read_only_counter32_instance ("nlmStatsGlobalNotificationsLogged", my_nlmStatsGlobalNotificationsLogged_oid, OID_LENGTH(my_nlmStatsGlobalNotificationsLogged_oid), &num_received, NULL); netsnmp_register_read_only_counter32_instance ("nlmStatsGlobalNotificationsBumped", my_nlmStatsGlobalNotificationsBumped_oid, OID_LENGTH(my_nlmStatsGlobalNotificationsBumped_oid), &num_deleted, NULL); netsnmp_register_ulong_instance("nlmConfigGlobalEntryLimit", my_nlmConfigGlobalEntryLimit_oid, OID_LENGTH (my_nlmConfigGlobalEntryLimit_oid), &max_logged, notification_log_config_handler); netsnmp_register_ulong_instance("nlmConfigGlobalAgeOut", my_nlmConfigGlobalAgeOut_oid, OID_LENGTH (my_nlmConfigGlobalAgeOut_oid), &max_age, notification_log_config_handler); /* * tables */ initialize_table_nlmLogTable(); initialize_table_nlmLogVariableTable(); /* * disable flag */ netsnmp_ds_register_config(ASN_BOOLEAN, "snmptrapd", "dontRetainLogs", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_APP_DONT_LOG); }
void init_secmod(void) { snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_SESSION_INIT, set_default_secmod, NULL); netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defSecurityModel", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SECMODEL); /* * this file is generated by configure for all the stuff we're using */ #include "snmpsm_init.h" }
/** * initializes the snmptrapd authorization code registering needed * handlers and config parsers. */ void init_netsnmp_trapd_auth(void) { /* register our function as a authorization handler */ netsnmp_trapd_handler *traph; traph = netsnmp_add_global_traphandler(NETSNMPTRAPD_AUTH_HANDLER, netsnmp_trapd_auth); traph->authtypes = TRAP_AUTH_NONE; #ifdef USING_MIBII_VACM_CONF_MODULE /* register our configuration tokens for VACM configs */ init_vacm_config_tokens(); #endif /* register a config token for turning off the authorization entirely */ netsnmp_ds_register_config(ASN_BOOLEAN, "snmptrapd", "disableAuthorization", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_APP_NO_AUTHORIZATION); }
/** Initializes the mteEventsConf module */ void init_mteEventConf(void) { init_event_table_data(); /* * Register config handlers for user-level (fixed) events.... */ snmpd_register_config_handler("notificationEvent", parse_notificationEvent, NULL, "eventname notifyOID [-m] [-i OID|-o OID]*"); snmpd_register_config_handler("setEvent", parse_setEvent, NULL, "eventname [-I] OID = value"); netsnmp_ds_register_config(ASN_BOOLEAN, netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_APPTYPE), "strictDisman", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_STRICT_DISMAN); /* * ... and for persistent storage of dynamic event table entries. * * (The previous implementation didn't store these entries, * so we don't need to worry about backwards compatability) */ snmpd_register_config_handler("_mteETable", parse_mteETable, NULL, NULL); snmpd_register_config_handler("_mteENotTable", parse_mteENotTable, NULL, NULL); snmpd_register_config_handler("_mteESetTable", parse_mteESetTable, NULL, NULL); /* * Register to save (non-fixed) entries when the agent shuts down */ snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA, store_mteETable, NULL); snmp_register_callback(SNMP_CALLBACK_APPLICATION, SNMPD_CALLBACK_PRE_UPDATE_CONFIG, clear_mteETable, NULL); }
void init_agent_read_config(const char *app) { if (app != NULL) { netsnmp_ds_set_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_APPTYPE, app); } else { app = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_APPTYPE); } register_app_config_handler("authtrapenable", snmpd_parse_config_authtrap, NULL, "1 | 2\t\t(1 = enable, 2 = disable)"); register_app_config_handler("pauthtrapenable",snmpd_parse_config_authtrap, NULL, NULL); if (netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_ROLE) == MASTER_AGENT) { #ifndef NETSNMP_DISABLE_SNMPV1 register_app_config_handler("trapsink", snmpd_parse_config_trapsink, snmpd_free_trapsinks, "host [community] [port]"); #endif #ifndef NETSNMP_DISABLE_SNMPV2C register_app_config_handler("trap2sink", snmpd_parse_config_trap2sink, snmpd_free_trapsinks, "host [community] [port]"); register_app_config_handler("informsink", snmpd_parse_config_informsink, snmpd_free_trapsinks, "host [community] [port]"); #endif register_app_config_handler("trapsess", snmpd_parse_config_trapsess, snmpd_free_trapsinks, "[snmpcmdargs] host"); } #if !defined(NETSNMP_DISABLE_SNMPV1) || !defined(NETSNMP_DISABLE_SNMPV2C) register_app_config_handler("trapcommunity", snmpd_parse_config_trapcommunity, snmpd_free_trapcommunity, "community-string"); #endif /* support for community based SNMP */ netsnmp_ds_register_config(ASN_OCTET_STR, app, "v1trapaddress", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_TRAP_ADDR); #ifdef HAVE_UNISTD_H register_app_config_handler("agentuser", snmpd_set_agent_user, NULL, "userid"); register_app_config_handler("agentgroup", snmpd_set_agent_group, NULL, "groupid"); #endif #ifndef NETSNMP_NO_LISTEN_SUPPORT register_app_config_handler("agentaddress", snmpd_set_agent_address, NULL, "SNMP bind address"); #endif /* NETSNMP_NO_LISTEN_SUPPORT */ netsnmp_ds_register_config(ASN_BOOLEAN, app, "quit", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_QUIT_IMMEDIATELY); netsnmp_ds_register_config(ASN_BOOLEAN, app, "leave_pidfile", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_LEAVE_PIDFILE); netsnmp_ds_register_config(ASN_BOOLEAN, app, "dontLogTCPWrappersConnects", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_DONT_LOG_TCPWRAPPERS_CONNECTS); netsnmp_ds_register_config(ASN_INTEGER, app, "maxGetbulkRepeats", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_MAX_GETBULKREPEATS); netsnmp_ds_register_config(ASN_INTEGER, app, "maxGetbulkResponses", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_MAX_GETBULKRESPONSES); netsnmp_init_handler_conf(); #include "agent_module_dot_conf.h" #include "mib_module_dot_conf.h" #ifdef TESTING print_config_handlers(); #endif }
/** * Bulk walk snmp value to the structure my_oid_result array. * Author : lining 15810423651 [email protected] * @param peername : the remote host ip address. * @param oid_argv : the char *oid pointer. * @param my_oid_result oid_results : the return values array. * @param my_oid_result oid_results_nums : the values array numbers. * @return 0 on success, or others on failure. * @return 1 on failure, the argument error. * @return 2 on failure, snmp_open return error. * @return 3 on failure, snmp_parse_oid return error. * @return 4 on failure, snmp_synch_response return status time out. * @return 5 on failure, snmp_synch_response return status others. * @return 6 on failure, response->errstat end of mib. * @return 7 on failure, response->errstat others. */ int my_snmp_bulkwalk(const char *peername, const char *community, const char *oid_argv, my_oid_result *oid_results, unsigned int *oid_results_nums) { if(peername == NULL) { printf("[ERROR] my_snmp_walk: the peername pointer is null\n"); return 1; } if(community == NULL) { printf("[ERROR] my_snmp_walk: the community pointer is null\n"); return 1; } if(oid_argv == NULL) { printf("[ERROR] my_snmp_walk: the oid_argv pointer is null\n"); return 1; } netsnmp_session session,*ss; netsnmp_pdu *pdu, *response; netsnmp_variable_list *vars; int arg; oid name[MAX_OID_LEN]; size_t name_length; oid root[MAX_OID_LEN]; size_t rootlen; int count; int running; int status; int check; int numprinted = 0; int reps = 10, non_reps = 0; netsnmp_ds_register_config(ASN_BOOLEAN, "snmpwalk", "includeRequested", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_WALK_INCLUDE_REQUESTED); netsnmp_ds_register_config(ASN_BOOLEAN, "snmpwalk", "printStatistics", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_WALK_PRINT_STATISTICS); netsnmp_ds_register_config(ASN_BOOLEAN, "snmpwalk", "dontCheckOrdering", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_WALK_DONT_CHECK_LEXICOGRAPHIC); init_snmp("snmpapp"); snmp_sess_init(&session); session.version = SNMP_VERSION_2c; session.community = (char*)community; session.community_len = strlen(session.community); session.peername = (char*)peername; session.timeout = 1000000; session.retries = 1; rootlen = MAX_OID_LEN; if(snmp_parse_oid(oid_argv, root, &rootlen) == NULL) { printf("[ERROR] my_snmp_bulkwalk: call snmp_parse_oid function failed\n"); snmp_close(ss); SOCK_CLEANUP; return 2; } SOCK_STARTUP; ss = snmp_open(&session); if(ss == NULL) { printf("[ERROR] my_snmp_bulkwalk: cakk snnp_open function failed\n"); snmp_close(ss); SOCK_CLEANUP; return 3; } memmove(name, root, rootlen * sizeof(oid)); name_length = rootlen; running = 1; check = !netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_WALK_DONT_CHECK_LEXICOGRAPHIC); while(running) { pdu = snmp_pdu_create(SNMP_MSG_GETBULK); pdu->non_repeaters = non_reps; pdu->max_repetitions = reps; snmp_add_null_var(pdu, name, name_length); status = snmp_synch_response(ss, pdu, &response); if(status == STAT_SUCCESS) { if(response->errstat == SNMP_ERR_NOERROR) { for(vars = response->variables; vars; vars = vars->next_variable) { if((vars->name_length < rootlen) || (memcmp(root, vars->name, rootlen * sizeof(oid)) != 0)) { running = 0; continue; } get_bulkwalk_oid_values(vars, &oid_results[numprinted]); numprinted++; if((vars->type != SNMP_ENDOFMIBVIEW) && (vars->type != SNMP_NOSUCHOBJECT) && (vars->type != SNMP_NOSUCHINSTANCE)) { if(check && snmp_oid_compare(name, name_length, vars->name, vars->name_length) >= 0) { running = 0; } if(vars->next_variable == NULL) { unsigned int count; for(count = 0; count < vars->name_length; count++) { oid_results[numprinted - 1].oid_name[count] = vars->name[count]; oid_results[numprinted - 1].oid_name_length = vars->name_length; } memmove(name, vars->name, vars->name_length * sizeof(oid)); name_length = vars->name_length; } } else { running = 0; } } } else { running = 0; if(response->errstat == SNMP_ERR_NOSUCHNAME) { printf("[ERROR] my_snmp_bulkwalk: have reached the end of MIB file\n"); *oid_results_nums = numprinted; snmp_close(ss); SOCK_CLEANUP; return 6; } else { printf("[ERROR] my_snmp_bulkwalk: return response->errstat others error\n"); *oid_results_nums = numprinted; snmp_close(ss); SOCK_CLEANUP; return 7; } } } else if(status == STAT_TIMEOUT) { printf("[ERROR] my_snmp_bulkwalk: return status is session time out\n"); running = 0; *oid_results_nums = numprinted; snmp_close(ss); SOCK_CLEANUP; return 4; } else { printf("[ERROR] my_snmp_bulkwalk: return session response error\n"); running = 0; *oid_results_nums = numprinted; snmp_close(ss); SOCK_CLEANUP; return 5; } if(response) { snmp_free_pdu(response); } } *oid_results_nums = numprinted; snmp_close(ss); SOCK_CLEANUP; return 0; }
/*******************************************************************-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_agent_read_config(const char *app) { if (app != NULL) { netsnmp_ds_set_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_APPTYPE, app); } else { app = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_APPTYPE); } register_app_config_handler("authtrapenable", snmpd_parse_config_authtrap, NULL, "1 | 2\t\t(1 = enable, 2 = disable)"); register_app_config_handler("pauthtrapenable", snmpd_parse_config_authtrap, NULL, NULL); if (netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_ROLE) == MASTER_AGENT) { #ifndef DISABLE_SNMPV1 register_app_config_handler("trapsink", snmpd_parse_config_trapsink, snmpd_free_trapsinks, "host [community] [port]"); #endif #ifndef DISABLE_SNMPV2C register_app_config_handler("trap2sink", snmpd_parse_config_trap2sink, NULL, "host [community] [port]"); register_app_config_handler("informsink", snmpd_parse_config_informsink, NULL, "host [community] [port]"); #endif register_app_config_handler("trapsess", snmpd_parse_config_trapsess, NULL, "[snmpcmdargs] host"); } #if !defined(DISABLE_SNMPV1) || !defined(DISABLE_SNMPV2C) register_app_config_handler("trapcommunity", snmpd_parse_config_trapcommunity, snmpd_free_trapcommunity, "community-string"); #endif /* support for community based SNMP */ #ifdef HAVE_UNISTD_H register_app_config_handler("agentuser", snmpd_set_agent_user, NULL, "userid"); register_app_config_handler("agentgroup", snmpd_set_agent_group, NULL, "groupid"); #endif register_app_config_handler("agentaddress", snmpd_set_agent_address, NULL, "SNMP bind address"); netsnmp_ds_register_config(ASN_BOOLEAN, app, "quit", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_QUIT_IMMEDIATELY); netsnmp_ds_register_config(ASN_BOOLEAN, app, "leave_pidfile", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_LEAVE_PIDFILE); netsnmp_init_handler_conf(); #include "agent_module_dot_conf.h" #include "mib_module_dot_conf.h" #ifdef TESTING print_config_handlers(); #endif }
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 }
int main(int argc, char *argv[]) { netsnmp_session session, *ss; netsnmp_pdu *pdu, *response; netsnmp_variable_list *vars; int arg; oid name[MAX_OID_LEN]; size_t name_length; oid root[MAX_OID_LEN]; size_t rootlen; int count; int running; int status; int check; int exitval = 0; netsnmp_ds_register_config(ASN_BOOLEAN, "snmpwalk", "includeRequested", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_WALK_INCLUDE_REQUESTED); netsnmp_ds_register_config(ASN_BOOLEAN, "snmpwalk", "printStatistics", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_WALK_PRINT_STATISTICS); netsnmp_ds_register_config(ASN_BOOLEAN, "snmpwalk", "dontCheckOrdering", NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_WALK_DONT_CHECK_LEXICOGRAPHIC); /* * get the common command line arguments */ switch (arg = snmp_parse_args(argc, argv, &session, "C:", optProc)) { case NETSNMP_PARSE_ARGS_ERROR: exit(1); case NETSNMP_PARSE_ARGS_SUCCESS_EXIT: exit(0); case NETSNMP_PARSE_ARGS_ERROR_USAGE: usage(); exit(1); default: break; } /* * get the initial object and subtree */ if (arg < argc) { /* * specified on the command line */ rootlen = MAX_OID_LEN; if (snmp_parse_oid(argv[arg], root, &rootlen) == NULL) { snmp_perror(argv[arg]); exit(1); } } else { /* * use default value */ memmove(root, objid_mib, sizeof(objid_mib)); rootlen = sizeof(objid_mib) / sizeof(oid); } SOCK_STARTUP; /* * open an SNMP session */ ss = snmp_open(&session); if (ss == NULL) { /* * diagnose snmp_open errors with the input netsnmp_session pointer */ snmp_sess_perror("snmpbulkwalk", &session); SOCK_CLEANUP; exit(1); } /* * setup initial object name */ memmove(name, root, rootlen * sizeof(oid)); name_length = rootlen; running = 1; check = !netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_WALK_DONT_CHECK_LEXICOGRAPHIC); if (netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_WALK_INCLUDE_REQUESTED)) { snmp_get_and_print(ss, root, rootlen); } while (running) { /* * create PDU for GETBULK request and add object name to request */ pdu = snmp_pdu_create(SNMP_MSG_GETBULK); pdu->non_repeaters = non_reps; pdu->max_repetitions = reps; /* fill the packet */ snmp_add_null_var(pdu, name, name_length); /* * do the request */ status = snmp_synch_response(ss, pdu, &response); if (status == STAT_SUCCESS) { if (response->errstat == SNMP_ERR_NOERROR) { /* * check resulting variables */ for (vars = response->variables; vars; vars = vars->next_variable) { if ((vars->name_length < rootlen) || (memcmp(root, vars->name, rootlen * sizeof(oid)) != 0)) { /* * not part of this subtree */ running = 0; continue; } numprinted++; print_variable(vars->name, vars->name_length, vars); if ((vars->type != SNMP_ENDOFMIBVIEW) && (vars->type != SNMP_NOSUCHOBJECT) && (vars->type != SNMP_NOSUCHINSTANCE)) { /* * not an exception value */ if (check && snmp_oid_compare(name, name_length, vars->name, vars->name_length) >= 0) { fprintf(stderr, "Error: OID not increasing: "); fprint_objid(stderr, name, name_length); fprintf(stderr, " >= "); fprint_objid(stderr, vars->name, vars->name_length); fprintf(stderr, "\n"); running = 0; exitval = 1; } /* * Check if last variable, and if so, save for next request. */ if (vars->next_variable == NULL) { memmove(name, vars->name, vars->name_length * sizeof(oid)); name_length = vars->name_length; } } else { /* * an exception value, so stop */ running = 0; } } } else { /* * error in response, print it */ running = 0; if (response->errstat == SNMP_ERR_NOSUCHNAME) { printf("End of MIB\n"); } else { fprintf(stderr, "Error in packet.\nReason: %s\n", snmp_errstring(response->errstat)); if (response->errindex != 0) { fprintf(stderr, "Failed object: "); for (count = 1, vars = response->variables; vars && count != response->errindex; vars = vars->next_variable, count++) /*EMPTY*/; if (vars) fprint_objid(stderr, vars->name, vars->name_length); fprintf(stderr, "\n"); } exitval = 2; } } } else if (status == STAT_TIMEOUT) { fprintf(stderr, "Timeout: No Response from %s\n", session.peername); running = 0; exitval = 1; } else { /* status == STAT_ERROR */ snmp_sess_perror("snmpbulkwalk", ss); running = 0; exitval = 1; } if (response) snmp_free_pdu(response); } if (numprinted == 0 && status == STAT_SUCCESS) { /* * no printed successful results, which may mean we were * pointed at an only existing instance. Attempt a GET, just * for get measure. */ snmp_get_and_print(ss, root, rootlen); } snmp_close(ss); if (netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_WALK_PRINT_STATISTICS)) { printf("Variables found: %d\n", numprinted); } SOCK_CLEANUP; return exitval; }
int ds_register_config (u_char type, const char *ftype, const char *token, int storeid, int which) { return netsnmp_ds_register_config (type, ftype, token, storeid, which); }
/* * Locate the appropriate transport domain and call the create function for * it. */ netsnmp_transport * netsnmp_tdomain_transport_full(const char *application, const char *str, int local, const char *default_domain, const char *default_target) { netsnmp_tdomain *match = NULL; const char *addr = NULL; const char * const *spec = NULL; int any_found = 0; char buf[SNMP_MAXPATH]; char **lspec = 0; DEBUGMSGTL(("tdomain", "tdomain_transport_full(\"%s\", \"%s\", %d, \"%s\", \"%s\")\n", application, str ? str : "[NIL]", local, default_domain ? default_domain : "[NIL]", default_target ? default_target : "[NIL]")); /* see if we can load a host-name specific set of conf files */ if (!netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_DONT_LOAD_HOST_FILES) && netsnmp_is_fqdn(str)) { static int have_added_handler = 0; char *newhost; struct config_line *config_handlers; struct config_files file_names; char *prev_hostname; /* register a "transport" specifier */ if (!have_added_handler) { have_added_handler = 1; netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "transport", NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_HOSTNAME); } /* we save on specific setting that we don't allow to change from one transport creation to the next; ie, we don't want the "transport" specifier to be a default. It should be a single invocation use only */ prev_hostname = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_HOSTNAME); if (prev_hostname) prev_hostname = strdup(prev_hostname); /* read in the hosts/STRING.conf files */ config_handlers = read_config_get_handlers("snmp"); snprintf(buf, sizeof(buf)-1, "hosts/%s", str); file_names.fileHeader = buf; file_names.start = config_handlers; file_names.next = NULL; DEBUGMSGTL(("tdomain", "checking for host specific config %s\n", buf)); read_config_files_of_type(EITHER_CONFIG, &file_names); if (NULL != (newhost = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_HOSTNAME))) { strlcpy(buf, newhost, sizeof(buf)); str = buf; } netsnmp_ds_set_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_HOSTNAME, prev_hostname); SNMP_FREE(prev_hostname); } /* First try - assume that there is a domain in str (domain:target) */ if (str != NULL) { const char *cp; if ((cp = strchr(str, ':')) != NULL) { char* mystring = (char*)malloc(cp + 1 - str); memcpy(mystring, str, cp - str); mystring[cp - str] = '\0'; addr = cp + 1; match = find_tdomain(mystring); free(mystring); } } /* * Second try, if there is no domain in str (target), then try the * default domain */ if (match == NULL) { addr = str; if (addr && *addr == '/') { DEBUGMSGTL(("tdomain", "Address starts with '/', so assume \"unix\" " "domain\n")); match = find_tdomain("unix"); } else if (default_domain) { DEBUGMSGTL(("tdomain", "Use user specified default domain \"%s\"\n", default_domain)); if (!strchr(default_domain, ',')) match = find_tdomain(default_domain); else { int commas = 0; const char *cp = default_domain; char *dup = strdup(default_domain); while (*++cp) if (*cp == ',') commas++; lspec = (char **) calloc(commas+2, sizeof(char *)); commas = 1; lspec[0] = strtok(dup, ","); while ((lspec[commas++] = strtok(NULL, ","))) ; spec = (const char * const *)lspec; } } else { spec = netsnmp_lookup_default_domains(application); if (spec == NULL) { DEBUGMSGTL(("tdomain", "No default domain found, assume \"udp\"\n")); match = find_tdomain("udp"); } else { const char * const * r = spec; DEBUGMSGTL(("tdomain", "Use application default domains")); while(*r) { DEBUGMSG(("tdomain", " \"%s\"", *r)); ++r; } DEBUGMSG(("tdomain", "\n")); } } } for(;;) { if (match) { netsnmp_transport *t = NULL; const char* addr2; any_found = 1; /* * Ok, we know what domain to try, lets see what default data * should be used with it */ if (default_target != NULL) addr2 = default_target; else addr2 = netsnmp_lookup_default_target(application, match->prefix[0]); DEBUGMSGTL(("tdomain", "trying domain \"%s\" address \"%s\" " "default address \"%s\"\n", match->prefix[0], addr ? addr : "[NIL]", addr2 ? addr2 : "[NIL]")); if (match->f_create_from_tstring) { NETSNMP_LOGONCE((LOG_WARNING, "transport domain %s uses deprecated f_create_from_tstring\n", match->prefix[0])); t = match->f_create_from_tstring(addr, local); } else t = match->f_create_from_tstring_new(addr, local, addr2); if (t) { if (lspec) { free(lspec[0]); free(lspec); } return t; } } addr = str; if (spec && *spec) match = find_tdomain(*spec++); else break; } if (!any_found) snmp_log(LOG_ERR, "No support for any checked transport domain\n"); if (lspec) { free(lspec[0]); free(lspec); } return NULL; }