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); }
/** handles requests for the expValueTable table */ int expValueTable_handler(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { netsnmp_request_info *request; netsnmp_table_request_info *tinfo; netsnmp_variable_list *value; oid expValueOID[] = { 1, 3, 6, 1, 2, 1, 90, 1, 3, 1, 1, 99 }; size_t expValueOID_len = OID_LENGTH(expValueOID); oid name_buf[ MAX_OID_LEN ]; oid *name_ptr = name_buf; size_t name_buf_len = MAX_OID_LEN; DEBUGMSGTL(("disman:expr:mib", "Expression Value Table handler (%d)\n", reqinfo->mode)); switch (reqinfo->mode) { case MODE_GET: case MODE_GETNEXT: for (request = requests; request; request = request->next) { tinfo = netsnmp_extract_table_info(request); value = expValueTable_getEntry(tinfo->indexes, reqinfo->mode, tinfo->colnum); if (!value || !value->val.integer) { netsnmp_set_request_error(reqinfo, request, (reqinfo->mode == MODE_GET) ? SNMP_NOSUCHINSTANCE : SNMP_ENDOFMIBVIEW); continue; } if ( reqinfo->mode == MODE_GETNEXT ) { /* * Need to update the request varbind OID * to match the instance just evaluated. * (XXX - Is this the appropriate mechanism?) */ build_oid_noalloc( name_buf, MAX_OID_LEN, &name_buf_len, expValueOID, expValueOID_len, tinfo->indexes ); name_buf[ expValueOID_len -1 ] = tinfo->colnum; snmp_set_var_objid(request->requestvb, name_buf, name_buf_len); } switch (tinfo->colnum) { case COLUMN_EXPVALUECOUNTER32VAL: snmp_set_var_typed_integer(request->requestvb, ASN_COUNTER, *value->val.integer); break; case COLUMN_EXPVALUEUNSIGNED32VAL: snmp_set_var_typed_integer(request->requestvb, ASN_UNSIGNED, *value->val.integer); break; case COLUMN_EXPVALUETIMETICKSVAL: snmp_set_var_typed_integer(request->requestvb, ASN_TIMETICKS, *value->val.integer); break; case COLUMN_EXPVALUEINTEGER32VAL: snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, *value->val.integer); break; case COLUMN_EXPVALUEIPADDRESSVAL: snmp_set_var_typed_integer(request->requestvb, ASN_IPADDRESS, *value->val.integer); break; case COLUMN_EXPVALUEOCTETSTRINGVAL: snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR, value->val.string, value->val_len); break; case COLUMN_EXPVALUEOIDVAL: snmp_set_var_typed_value( request->requestvb, ASN_OBJECT_ID, (u_char *)value->val.objid, value->val_len); break; case COLUMN_EXPVALUECOUNTER64VAL: snmp_set_var_typed_value( request->requestvb, ASN_COUNTER64, (u_char *)value->val.counter64, value->val_len); break; } } break; } DEBUGMSGTL(("disman:expr:mib", "Expression Value handler - done \n")); return SNMP_ERR_NOERROR; }
int ip_handler(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { netsnmp_request_info *request; netsnmp_variable_list *requestvb; long ret_value; oid subid; int type = ASN_COUNTER; /* * The cached data should already have been loaded by the * cache handler, higher up the handler chain. * But just to be safe, check this and load it manually if necessary */ #ifndef hpux11 if (!netsnmp_is_cache_valid(reqinfo)) { ip_load( NULL, NULL ); /* XXX - check for failure */ } #endif /* * * */ DEBUGMSGTL(("mibII/ip", "Handler - mode %s\n", se_find_label_in_slist("agent_mode", reqinfo->mode))); switch (reqinfo->mode) { case MODE_GET: for (request=requests; request; request=request->next) { requestvb = request->requestvb; subid = requestvb->name[OID_LENGTH(ip_oid)]; /* XXX */ DEBUGMSGTL(( "mibII/ip", "oid: ")); DEBUGMSGOID(("mibII/ip", requestvb->name, requestvb->name_length)); DEBUGMSG(( "mibII/ip", "\n")); switch (subid) { #ifdef USES_SNMP_DESIGNED_IPSTAT case IPFORWARDING: ret_value = ipstat.ipForwarding; type = ASN_INTEGER; break; case IPDEFAULTTTL: ret_value = ipstat.ipDefaultTTL; type = ASN_INTEGER; break; case IPINRECEIVES: ret_value = ipstat.ipInReceives; break; case IPINHDRERRORS: ret_value = ipstat.ipInHdrErrors; break; case IPINADDRERRORS: ret_value = ipstat.ipInAddrErrors; break; case IPFORWDATAGRAMS: ret_value = ipstat.ipForwDatagrams; break; case IPINUNKNOWNPROTOS: ret_value = ipstat.ipInUnknownProtos; break; case IPINDISCARDS: ret_value = ipstat.ipInDiscards; break; case IPINDELIVERS: ret_value = ipstat.ipInDelivers; break; case IPOUTREQUESTS: ret_value = ipstat.ipOutRequests; break; case IPOUTDISCARDS: ret_value = ipstat.ipOutDiscards; break; case IPOUTNOROUTES: ret_value = ipstat.ipOutNoRoutes; break; case IPREASMTIMEOUT: ret_value = ipstat.ipReasmTimeout; type = ASN_INTEGER; break; case IPREASMREQDS: ret_value = ipstat.ipReasmReqds; break; case IPREASMOKS: ret_value = ipstat.ipReasmOKs; break; case IPREASMFAILS: ret_value = ipstat.ipReasmFails; break; case IPFRAGOKS: ret_value = ipstat.ipFragOKs; break; case IPFRAGFAILS: ret_value = ipstat.ipFragFails; break; case IPFRAGCREATES: ret_value = ipstat.ipFragCreates; break; case IPROUTEDISCARDS: ret_value = ipstat.ipRoutingDiscards; break; #else /* USES_SNMP_DESIGNED_IPSTAT */ #ifdef USES_TRADITIONAL_IPSTAT #ifdef HAVE_SYS_TCPIPSTATS_H /* * This actually reads statistics for *all* the groups together, * so we need to isolate the IP-specific bits. */ #define ipstat ipstat.ipstat #endif case IPFORWARDING: case IPDEFAULTTTL: /* * Query these two individually */ ret_value = ip_load(NULL, (void *)subid); if (ret_value == -1 ) { netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; } type = ASN_INTEGER; break; case IPINRECEIVES: ret_value = ipstat.ips_total; break; case IPINHDRERRORS: ret_value = ipstat.ips_badsum + ipstat.ips_tooshort + ipstat.ips_toosmall + ipstat.ips_badhlen + ipstat.ips_badlen; break; case IPINADDRERRORS: ret_value = ipstat.ips_cantforward; break; case IPFORWDATAGRAMS: ret_value = ipstat.ips_forward; break; case IPINUNKNOWNPROTOS: #if STRUCT_IPSTAT_HAS_IPS_NOPROTO ret_value = ipstat.ips_noproto; break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif case IPINDISCARDS: #if STRUCT_IPSTAT_HAS_IPS_FRAGDROPPED ret_value = ipstat.ips_fragdropped; /* ?? */ break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif case IPINDELIVERS: #if STRUCT_IPSTAT_HAS_IPS_DELIVERED ret_value = ipstat.ips_delivered; break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif case IPOUTREQUESTS: #if STRUCT_IPSTAT_HAS_IPS_LOCALOUT ret_value = ipstat.ips_localout; break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif case IPOUTDISCARDS: #if STRUCT_IPSTAT_HAS_IPS_ODROPPED ret_value = ipstat.ips_odropped; break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif case IPOUTNOROUTES: /* * XXX: how to calculate this (counts dropped routes, not packets)? * ipstat.ips_cantforward isn't right, as it counts packets. * ipstat.ips_noroute is also incorrect. */ netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; case IPREASMTIMEOUT: ret_value = IPFRAGTTL; type = ASN_INTEGER; break; case IPREASMREQDS: ret_value = ipstat.ips_fragments; break; case IPREASMOKS: #if STRUCT_IPSTAT_HAS_IPS_REASSEMBLED ret_value = ipstat.ips_reassembled; break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif case IPREASMFAILS: ret_value = ipstat.ips_fragdropped + ipstat.ips_fragtimeout; break; case IPFRAGOKS: /* XXX */ ret_value = ipstat.ips_fragments - (ipstat.ips_fragdropped + ipstat.ips_fragtimeout); break; case IPFRAGFAILS: #if STRUCT_IPSTAT_HAS_IPS_CANTFRAG ret_value = ipstat.ips_cantfrag; break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif case IPFRAGCREATES: #if STRUCT_IPSTAT_HAS_IPS_OFRAGMENTS ret_value = ipstat.ips_ofragments; break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif case IPROUTEDISCARDS: #if STRUCT_IPSTAT_HAS_IPS_NOROUTE ret_value = ipstat.ips_noroute; break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif #ifdef HAVE_SYS_TCPIPSTATS_H #undef ipstat #endif #else /* USE_TRADITIONAL_IPSTAT */ #ifdef hpux11 case IPFORWARDING: case IPDEFAULTTTL: case IPREASMTIMEOUT: type = ASN_INTEGER; case IPINRECEIVES: case IPINHDRERRORS: case IPINADDRERRORS: case IPFORWDATAGRAMS: case IPINUNKNOWNPROTOS: case IPINDISCARDS: case IPINDELIVERS: case IPOUTREQUESTS: case IPOUTDISCARDS: case IPOUTNOROUTES: case IPREASMREQDS: case IPREASMOKS: case IPREASMFAILS: case IPFRAGOKS: case IPFRAGFAILS: case IPFRAGCREATES: case IPROUTEDISCARDS: /* * This is a bit of a hack, to shoehorn the HP-UX 11 * single-object retrieval approach into the caching * architecture. */ if (ip_load(NULL, (void*)subid) == -1 ) { netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; } ret_value = ipstat; break; #else /* hpux11 */ #ifdef WIN32 case IPFORWARDING: ipForwarding = ipstat.dwForwarding; ret_value = ipstat.dwForwarding; type = ASN_INTEGER; break; case IPDEFAULTTTL: ipTTL = ipstat.dwDefaultTTL; ret_value = ipstat.dwDefaultTTL; type = ASN_INTEGER; break; case IPINRECEIVES: ret_value = ipstat.dwInReceives; break; case IPINHDRERRORS: ret_value = ipstat.dwInHdrErrors; break; case IPINADDRERRORS: ret_value = ipstat.dwInAddrErrors; break; case IPFORWDATAGRAMS: ret_value = ipstat.dwForwDatagrams; break; case IPINUNKNOWNPROTOS: ret_value = ipstat.dwInUnknownProtos; break; case IPINDISCARDS: ret_value = ipstat.dwInDiscards; break; case IPINDELIVERS: ret_value = ipstat.dwInDelivers; break; case IPOUTREQUESTS: ret_value = ipstat.dwOutRequests; break; case IPOUTDISCARDS: ret_value = ipstat.dwOutDiscards; break; case IPOUTNOROUTES: ret_value = ipstat.dwOutNoRoutes; break; case IPREASMTIMEOUT: ret_value = ipstat.dwReasmTimeout; type = ASN_INTEGER; break; case IPREASMREQDS: ret_value = ipstat.dwReasmReqds; break; case IPREASMOKS: ret_value = ipstat.dwReasmOks; break; case IPREASMFAILS: ret_value = ipstat.dwReasmFails; break; case IPFRAGOKS: ret_value = ipstat.dwFragOks; break; case IPFRAGFAILS: ret_value = ipstat.dwFragFails; break; case IPFRAGCREATES: ret_value = ipstat.dwFragCreates; break; case IPROUTEDISCARDS: ret_value = ipstat.dwRoutingDiscards; break; #endif /* WIN32 */ #endif /* hpux11 */ #endif /* USE_TRADITIONAL_IPSTAT */ #endif /* USES_SNMP_DESIGNED_IPSTAT */ case IPADDRTABLE: case IPROUTETABLE: case IPMEDIATABLE: /* * These are not actually valid scalar objects. * The relevant table registrations should take precedence, * so skip these three subtrees, regardless of architecture. */ netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; } snmp_set_var_typed_value(request->requestvb, (u_char)type, (u_char *)&ret_value, sizeof(ret_value)); } break; case MODE_GETNEXT: case MODE_GETBULK: case MODE_SET_RESERVE1: /* XXX - Windows currently supports setting this */ case MODE_SET_RESERVE2: case MODE_SET_ACTION: case MODE_SET_COMMIT: case MODE_SET_FREE: case MODE_SET_UNDO: snmp_log(LOG_WARNING, "mibII/ip: Unsupported mode (%d)\n", reqinfo->mode); break; default: snmp_log(LOG_WARNING, "mibII/ip: Unrecognised mode (%d)\n", reqinfo->mode); break; } return SNMP_ERR_NOERROR; }
int udp_handler(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { netsnmp_request_info *request; netsnmp_variable_list *requestvb; long ret_value = -1; oid subid; int type = ASN_COUNTER; /* * The cached data should already have been loaded by the * cache handler, higher up the handler chain. * But just to be safe, check this and load it manually if necessary */ #if defined(_USE_PERFSTAT_PROTOCOL) udp_load(NULL, NULL); #endif /* * * */ DEBUGMSGTL(("mibII/udpScalar", "Handler - mode %s\n", se_find_label_in_slist("agent_mode", reqinfo->mode))); switch (reqinfo->mode) { case MODE_GET: for (request=requests; request; request=request->next) { requestvb = request->requestvb; subid = requestvb->name[OID_LENGTH(udp_oid)]; /* XXX */ DEBUGMSGTL(( "mibII/udpScalar", "oid: ")); DEBUGMSGOID(("mibII/udpScalar", requestvb->name, requestvb->name_length)); DEBUGMSG(( "mibII/udpScalar", "\n")); switch (subid) { #ifdef USES_SNMP_DESIGNED_UDPSTAT case UDPINDATAGRAMS: ret_value = udpstat.udpInDatagrams; break; case UDPNOPORTS: #ifdef solaris2 ret_value = udp_load(NULL, (void *)UDPNOPORTS); if (ret_value == -1) { netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; } break; #else ret_value = udpstat.udpNoPorts; break; #endif case UDPOUTDATAGRAMS: ret_value = udpstat.udpOutDatagrams; break; case UDPINERRORS: ret_value = udpstat.udpInErrors; break; #elif defined(USES_TRADITIONAL_UDPSTAT) && !defined(_USE_PERFSTAT_PROTOCOL) #ifdef HAVE_SYS_TCPIPSTATS_H /* * This actually reads statistics for *all* the groups together, * so we need to isolate the UDP-specific bits. */ #define udpstat udpstat.udpstat #endif case UDPINDATAGRAMS: #if HAVE_STRUCT_UDPSTAT_UDPS_IPACKETS ret_value = udpstat.udps_ipackets; break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif case UDPNOPORTS: #if HAVE_STRUCT_UDPSTAT_UDPS_NOPORT ret_value = udpstat.udps_noport; break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif case UDPOUTDATAGRAMS: #if HAVE_STRUCT_UDPSTAT_UDPS_OPACKETS ret_value = udpstat.udps_opackets; break; #else netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; #endif case UDPINERRORS: ret_value = udpstat.udps_hdrops + udpstat.udps_badsum + #ifdef HAVE_STRUCT_UDPSTAT_UDPS_DISCARD udpstat.udps_discard + #endif #ifdef HAVE_STRUCT_UDPSTAT_UDPS_FULLSOCK udpstat.udps_fullsock + #endif udpstat.udps_badlen; break; #ifdef HAVE_SYS_TCPIPSTATS_H #undef udpstat #endif #elif defined(hpux11) case UDPINDATAGRAMS: case UDPNOPORTS: case UDPOUTDATAGRAMS: case UDPINERRORS: /* * This is a bit of a hack, to shoehorn the HP-UX 11 * single-object retrieval approach into the caching * architecture. */ if (udp_load(NULL, (void*)subid) == -1 ) { netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; } ret_value = udpstat; break; #elif defined(WIN32) case UDPINDATAGRAMS: ret_value = udpstat.dwInDatagrams; break; case UDPNOPORTS: ret_value = udpstat.dwNoPorts; break; case UDPOUTDATAGRAMS: ret_value = udpstat.dwOutDatagrams; break; case UDPINERRORS: ret_value = udpstat.dwInErrors; break; #elif defined(_USE_PERFSTAT_PROTOCOL) case UDPINDATAGRAMS: ret_value = ps_proto.u.udp.ipackets; break; case UDPNOPORTS: ret_value = ps_proto.u.udp.no_socket; break; case UDPOUTDATAGRAMS: ret_value = ps_proto.u.udp.opackets; break; case UDPINERRORS: ret_value = ps_proto.u.udp.ierrors; break; #endif /* USES_SNMP_DESIGNED_UDPSTAT */ } snmp_set_var_typed_value(request->requestvb, (u_char)type, (u_char *)&ret_value, sizeof(ret_value)); } break; case MODE_GETNEXT: case MODE_GETBULK: case MODE_SET_RESERVE1: case MODE_SET_RESERVE2: case MODE_SET_ACTION: case MODE_SET_COMMIT: case MODE_SET_FREE: case MODE_SET_UNDO: snmp_log(LOG_WARNING, "mibII/udp: Unsupported mode (%d)\n", reqinfo->mode); break; default: snmp_log(LOG_WARNING, "mibII/udp: Unrecognised mode (%d)\n", reqinfo->mode); break; } return SNMP_ERR_NOERROR; }
int icmp_handler(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { netsnmp_request_info *request; netsnmp_variable_list *requestvb; long ret_value; oid subid; #ifdef USES_TRADITIONAL_ICMPSTAT int i; #endif /* * The cached data should already have been loaded by the * cache handler, higher up the handler chain. * But just to be safe, check this and load it manually if necessary */ #if defined(_USE_PERFSTAT_PROTOCOL) icmp_load(NULL, NULL); #elif !defined(hpux11) if (!netsnmp_cache_is_valid(reqinfo, reginfo->handlerName)) { netsnmp_assert(!"cache == valid"); /* always false */ icmp_load( NULL, NULL ); /* XXX - check for failure */ } #endif /* * * */ DEBUGMSGTL(("mibII/icmp", "Handler - mode %s\n", se_find_label_in_slist("agent_mode", reqinfo->mode))); switch (reqinfo->mode) { case MODE_GET: for (request=requests; request; request=request->next) { requestvb = request->requestvb; subid = requestvb->name[OID_LENGTH(icmp_oid)]; /* XXX */ DEBUGMSGTL(( "mibII/icmp", "oid: ")); DEBUGMSGOID(("mibII/icmp", requestvb->name, requestvb->name_length)); DEBUGMSG(( "mibII/icmp", "\n")); switch (subid) { #ifdef USES_SNMP_DESIGNED_ICMPSTAT case ICMPINMSGS: ret_value = icmpstat.icmpInMsgs; break; case ICMPINERRORS: ret_value = icmpstat.icmpInErrors; break; case ICMPINDESTUNREACHS: ret_value = icmpstat.icmpInDestUnreachs; break; case ICMPINTIMEEXCDS: ret_value = icmpstat.icmpInTimeExcds; break; case ICMPINPARMPROBS: ret_value = icmpstat.icmpInParmProbs; break; case ICMPINSRCQUENCHS: ret_value = icmpstat.icmpInSrcQuenchs; break; case ICMPINREDIRECTS: ret_value = icmpstat.icmpInRedirects; break; case ICMPINECHOS: ret_value = icmpstat.icmpInEchos; break; case ICMPINECHOREPS: ret_value = icmpstat.icmpInEchoReps; break; case ICMPINTIMESTAMPS: ret_value = icmpstat.icmpInTimestamps; break; case ICMPINTIMESTAMPREPS: ret_value = icmpstat.icmpInTimestampReps; break; case ICMPINADDRMASKS: ret_value = icmpstat.icmpInAddrMasks; break; case ICMPINADDRMASKREPS: ret_value = icmpstat.icmpInAddrMaskReps; break; case ICMPOUTMSGS: ret_value = icmpstat.icmpOutMsgs; break; case ICMPOUTERRORS: ret_value = icmpstat.icmpOutErrors; break; case ICMPOUTDESTUNREACHS: ret_value = icmpstat.icmpOutDestUnreachs; break; case ICMPOUTTIMEEXCDS: ret_value = icmpstat.icmpOutTimeExcds; break; case ICMPOUTPARMPROBS: ret_value = icmpstat.icmpOutParmProbs; break; case ICMPOUTSRCQUENCHS: ret_value = icmpstat.icmpOutSrcQuenchs; break; case ICMPOUTREDIRECTS: ret_value = icmpstat.icmpOutRedirects; break; case ICMPOUTECHOS: ret_value = icmpstat.icmpOutEchos; break; case ICMPOUTECHOREPS: ret_value = icmpstat.icmpOutEchoReps; break; case ICMPOUTTIMESTAMPS: ret_value = icmpstat.icmpOutTimestamps; break; case ICMPOUTTIMESTAMPREPS: ret_value = icmpstat.icmpOutTimestampReps; break; case ICMPOUTADDRMASKS: ret_value = icmpstat.icmpOutAddrMasks; break; case ICMPOUTADDRMASKREPS: ret_value = icmpstat.icmpOutAddrMaskReps; break; #elif defined(USES_TRADITIONAL_ICMPSTAT) && !defined(_USE_PERFSTAT_PROTOCOL) case ICMPINMSGS: ret_value = icmpstat.icps_badcode + icmpstat.icps_tooshort + icmpstat.icps_checksum + icmpstat.icps_badlen; for (i = 0; i <= ICMP_MAXTYPE; i++) ret_value += icmpstat.icps_inhist[i]; break; case ICMPINERRORS: ret_value = icmpstat.icps_badcode + icmpstat.icps_tooshort + icmpstat.icps_checksum + icmpstat.icps_badlen; break; case ICMPINDESTUNREACHS: ret_value = icmpstat.icps_inhist[ICMP_UNREACH]; break; case ICMPINTIMEEXCDS: ret_value = icmpstat.icps_inhist[ICMP_TIMXCEED]; break; case ICMPINPARMPROBS: ret_value = icmpstat.icps_inhist[ICMP_PARAMPROB]; break; case ICMPINSRCQUENCHS: ret_value = icmpstat.icps_inhist[ICMP_SOURCEQUENCH]; break; case ICMPINREDIRECTS: ret_value = icmpstat.icps_inhist[ICMP_REDIRECT]; break; case ICMPINECHOS: ret_value = icmpstat.icps_inhist[ICMP_ECHO]; break; case ICMPINECHOREPS: ret_value = icmpstat.icps_inhist[ICMP_ECHOREPLY]; break; case ICMPINTIMESTAMPS: ret_value = icmpstat.icps_inhist[ICMP_TSTAMP]; break; case ICMPINTIMESTAMPREPS: ret_value = icmpstat.icps_inhist[ICMP_TSTAMPREPLY]; break; case ICMPINADDRMASKS: ret_value = icmpstat.icps_inhist[ICMP_MASKREQ]; break; case ICMPINADDRMASKREPS: ret_value = icmpstat.icps_inhist[ICMP_MASKREPLY]; break; case ICMPOUTMSGS: ret_value = icmpstat.icps_oldshort + icmpstat.icps_oldicmp; for (i = 0; i <= ICMP_MAXTYPE; i++) ret_value += icmpstat.icps_outhist[i]; break; case ICMPOUTERRORS: ret_value = icmpstat.icps_oldshort + icmpstat.icps_oldicmp; break; case ICMPOUTDESTUNREACHS: ret_value = icmpstat.icps_outhist[ICMP_UNREACH]; break; case ICMPOUTTIMEEXCDS: ret_value = icmpstat.icps_outhist[ICMP_TIMXCEED]; break; case ICMPOUTPARMPROBS: ret_value = icmpstat.icps_outhist[ICMP_PARAMPROB]; break; case ICMPOUTSRCQUENCHS: ret_value = icmpstat.icps_outhist[ICMP_SOURCEQUENCH]; break; case ICMPOUTREDIRECTS: ret_value = icmpstat.icps_outhist[ICMP_REDIRECT]; break; case ICMPOUTECHOS: ret_value = icmpstat.icps_outhist[ICMP_ECHO]; break; case ICMPOUTECHOREPS: ret_value = icmpstat.icps_outhist[ICMP_ECHOREPLY]; break; case ICMPOUTTIMESTAMPS: ret_value = icmpstat.icps_outhist[ICMP_TSTAMP]; break; case ICMPOUTTIMESTAMPREPS: ret_value = icmpstat.icps_outhist[ICMP_TSTAMPREPLY]; break; case ICMPOUTADDRMASKS: ret_value = icmpstat.icps_outhist[ICMP_MASKREQ]; break; case ICMPOUTADDRMASKREPS: ret_value = icmpstat.icps_outhist[ICMP_MASKREPLY]; break; #elif defined(hpux11) case ICMPINMSGS: case ICMPINERRORS: case ICMPINDESTUNREACHS: case ICMPINTIMEEXCDS: case ICMPINPARMPROBS: case ICMPINSRCQUENCHS: case ICMPINREDIRECTS: case ICMPINECHOS: case ICMPINECHOREPS: case ICMPINTIMESTAMPS: case ICMPINTIMESTAMPREPS: case ICMPINADDRMASKS: case ICMPINADDRMASKREPS: case ICMPOUTMSGS: case ICMPOUTERRORS: case ICMPOUTDESTUNREACHS: case ICMPOUTTIMEEXCDS: case ICMPOUTPARMPROBS: case ICMPOUTSRCQUENCHS: case ICMPOUTREDIRECTS: case ICMPOUTECHOS: case ICMPOUTECHOREPS: case ICMPOUTTIMESTAMPS: case ICMPOUTTIMESTAMPREPS: case ICMPOUTADDRMASKS: case ICMPOUTADDRMASKREPS: /* * This is a bit of a hack, to shoehorn the HP-UX 11 * single-object retrieval approach into the caching * architecture. */ if (icmp_load(NULL, (void*)subid) == -1 ) { netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT); continue; } ret_value = icmpstat; break; #elif defined (WIN32) || defined (cygwin) case ICMPINMSGS: ret_value = icmpstat.stats.icmpInStats.dwMsgs; break; case ICMPINERRORS: ret_value = icmpstat.stats.icmpInStats.dwErrors; break; case ICMPINDESTUNREACHS: ret_value = icmpstat.stats.icmpInStats.dwDestUnreachs; break; case ICMPINTIMEEXCDS: ret_value = icmpstat.stats.icmpInStats.dwTimeExcds; break; case ICMPINPARMPROBS: ret_value = icmpstat.stats.icmpInStats.dwParmProbs; break; case ICMPINSRCQUENCHS: ret_value = icmpstat.stats.icmpInStats.dwSrcQuenchs; break; case ICMPINREDIRECTS: ret_value = icmpstat.stats.icmpInStats.dwRedirects; break; case ICMPINECHOS: ret_value = icmpstat.stats.icmpInStats.dwEchos; break; case ICMPINECHOREPS: ret_value = icmpstat.stats.icmpInStats.dwEchoReps; break; case ICMPINTIMESTAMPS: ret_value = icmpstat.stats.icmpInStats.dwTimestamps; break; case ICMPINTIMESTAMPREPS: ret_value = icmpstat.stats.icmpInStats.dwTimestampReps; break; case ICMPINADDRMASKS: ret_value = icmpstat.stats.icmpInStats.dwAddrMasks; break; case ICMPINADDRMASKREPS: ret_value = icmpstat.stats.icmpInStats.dwAddrMaskReps; break; case ICMPOUTMSGS: ret_value = icmpstat.stats.icmpOutStats.dwMsgs; break; case ICMPOUTERRORS: ret_value = icmpstat.stats.icmpOutStats.dwErrors; break; case ICMPOUTDESTUNREACHS: ret_value = icmpstat.stats.icmpOutStats.dwDestUnreachs; break; case ICMPOUTTIMEEXCDS: ret_value = icmpstat.stats.icmpOutStats.dwTimeExcds; break; case ICMPOUTPARMPROBS: ret_value = icmpstat.stats.icmpOutStats.dwParmProbs; break; case ICMPOUTSRCQUENCHS: ret_value = icmpstat.stats.icmpOutStats.dwSrcQuenchs; break; case ICMPOUTREDIRECTS: ret_value = icmpstat.stats.icmpOutStats.dwRedirects; break; case ICMPOUTECHOS: ret_value = icmpstat.stats.icmpOutStats.dwEchos; break; case ICMPOUTECHOREPS: ret_value = icmpstat.stats.icmpOutStats.dwEchoReps; break; case ICMPOUTTIMESTAMPS: ret_value = icmpstat.stats.icmpOutStats.dwTimestamps; break; case ICMPOUTTIMESTAMPREPS: ret_value = icmpstat.stats.icmpOutStats.dwTimestampReps; break; case ICMPOUTADDRMASKS: ret_value = icmpstat.stats.icmpOutStats.dwAddrMasks; break; case ICMPOUTADDRMASKREPS: ret_value = icmpstat.stats.icmpOutStats.dwAddrMaskReps; break; #elif defined(_USE_PERFSTAT_PROTOCOL) case ICMPINMSGS: ret_value = ps_proto.u.icmp.received; break; case ICMPINERRORS: ret_value = ps_proto.u.icmp.errors; break; case ICMPINDESTUNREACHS: case ICMPINTIMEEXCDS: case ICMPINPARMPROBS: case ICMPINSRCQUENCHS: case ICMPINREDIRECTS: case ICMPINECHOS: case ICMPINECHOREPS: case ICMPINTIMESTAMPS: case ICMPINTIMESTAMPREPS: case ICMPINADDRMASKS: case ICMPINADDRMASKREPS: ret_value = 0; break; case ICMPOUTMSGS: ret_value = ps_proto.u.icmp.sent; break; case ICMPOUTERRORS: ret_value = ps_proto.u.icmp.errors; break; case ICMPOUTDESTUNREACHS: case ICMPOUTTIMEEXCDS: case ICMPOUTPARMPROBS: case ICMPOUTSRCQUENCHS: case ICMPOUTREDIRECTS: case ICMPOUTECHOS: case ICMPOUTECHOREPS: case ICMPOUTTIMESTAMPS: case ICMPOUTTIMESTAMPREPS: case ICMPOUTADDRMASKS: case ICMPOUTADDRMASKREPS: ret_value = 0; break; #endif /* USES_SNMP_DESIGNED_ICMPSTAT */ } snmp_set_var_typed_value(request->requestvb, ASN_COUNTER, (u_char *)&ret_value, sizeof(ret_value)); } break; case MODE_GETNEXT: case MODE_GETBULK: case MODE_SET_RESERVE1: case MODE_SET_RESERVE2: case MODE_SET_ACTION: case MODE_SET_COMMIT: case MODE_SET_FREE: case MODE_SET_UNDO: snmp_log(LOG_WARNING, "mibII/icmp: Unsupported mode (%d)\n", reqinfo->mode); break; default: snmp_log(LOG_WARNING, "mibII/icmp: Unrecognised mode (%d)\n", reqinfo->mode); break; } return SNMP_ERR_NOERROR; }
/** Initialize the sctpAssocTable table by defining its contents and how it's structured */ void initialize_table_sctpAssocTable(void) { static oid sctpAssocTable_oid[] = { 1, 3, 6, 1, 2, 1, 104, 1, 3 }; size_t sctpAssocTable_oid_len = OID_LENGTH(sctpAssocTable_oid); netsnmp_handler_registration *reg = NULL; netsnmp_mib_handler *handler = NULL; netsnmp_container *container = NULL; netsnmp_cache *cache = NULL; reg = netsnmp_create_handler_registration("sctpAssocTable", sctpAssocTable_handler, sctpAssocTable_oid, sctpAssocTable_oid_len, HANDLER_CAN_RWRITE); if (NULL == reg) { snmp_log(LOG_ERR, "error creating handler registration for sctpAssocTable\n"); goto bail; } /** should a set on a non-existent row create a new one? */ /** reg->modes |= HANDLER_CAN_NOT_CREATE; */ container = netsnmp_container_find("sctpAssocTable:table_container"); if (NULL == container) { snmp_log(LOG_ERR, "error creating container for sctpAssocTable\n"); goto bail; } sctpAssocTable_container = container; table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); if (NULL == table_info) { snmp_log(LOG_ERR, "error allocating table registration for sctpAssocTable\n"); goto bail; } netsnmp_table_helper_add_indexes(table_info, ASN_UNSIGNED, /* index: sctpAssocId */ 0); table_info->min_column = COLUMN_SCTPASSOCREMHOSTNAME; table_info->max_column = COLUMN_SCTPASSOCDISCONTINUITYTIME; /************************************************* * * inject container_table helper */ handler = netsnmp_container_table_handler_get(table_info, container, TABLE_CONTAINER_KEY_NETSNMP_INDEX); if (NULL == handler) { snmp_log(LOG_ERR, "error allocating table registration for sctpAssocTable\n"); goto bail; } if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) { snmp_log(LOG_ERR, "error injecting container_table handler for sctpAssocTable\n"); goto bail; } handler = NULL; /* reg has it, will reuse below */ /************************************************* * * inject cache helper */ cache = netsnmp_cache_create(SCTP_TABLES_CACHE_TIMEOUT, /* timeout in seconds */ _cache_load, _cache_free, sctpAssocTable_oid, sctpAssocTable_oid_len); if (NULL == cache) { snmp_log(LOG_ERR, "error creating cache for sctpAssocTable\n"); goto bail; } cache->flags = NETSNMP_CACHE_DONT_INVALIDATE_ON_SET | NETSNMP_CACHE_AUTO_RELOAD | NETSNMP_CACHE_PRELOAD; cache->magic = container; handler = netsnmp_cache_handler_get(cache); if (NULL == handler) { snmp_log(LOG_ERR, "error creating cache handler for sctpAssocTable\n"); goto bail; } netsnmp_cache_handler_owns_cache(handler); if (SNMPERR_SUCCESS != netsnmp_inject_handler(reg, handler)) { snmp_log(LOG_ERR, "error injecting cache handler for sctpAssocTable\n"); goto bail; } handler = NULL; /* reg has it */ /* * register the table */ if (SNMPERR_SUCCESS != netsnmp_register_table(reg, table_info)) { snmp_log(LOG_ERR, "error registering table handler for sctpAssocTable\n"); reg = NULL; /* it was freed inside netsnmp_register_table */ goto bail; } /* * Initialise the contents of the table here */ return; /* ok */ /* * Some error occurred during registration. Clean up and bail. */ bail: /* not ok */ if (handler) netsnmp_handler_free(handler); if (cache) netsnmp_cache_free(cache); if (table_info) netsnmp_table_registration_info_free(table_info); if (container) CONTAINER_FREE(container); if (reg) netsnmp_handler_registration_free(reg); }
#include <net-snmp/net-snmp-includes.h> #include <net-snmp/agent/net-snmp-agent-includes.h> /* * include our parent header */ #include "dessertSysifTable.h" #include <net-snmp/agent/mib_modules.h> #include "dessertSysifTable_interface.h" oid dessertSysifTable_oid[] = { DESSERTSYSIFTABLE_OID }; int dessertSysifTable_oid_size = OID_LENGTH(dessertSysifTable_oid); dessertSysifTable_registration dessertSysifTable_user_context; void initialize_table_dessertSysifTable(void); void shutdown_table_dessertSysifTable(void); /** * Initializes the dessertSysifTable module */ void init_dessertSysifTable(void) { DEBUGMSGTL(("verbose:dessertSysifTable:init_dessertSysifTable", "called\n"));
#include <net-snmp/net-snmp-config.h> #include <net-snmp/net-snmp-includes.h> #include <net-snmp/agent/net-snmp-agent-includes.h> /* * include our parent header */ #include "tcpConnectionTable.h" #include <net-snmp/agent/mib_modules.h> #include "tcpConnectionTable_interface.h" const oid tcpConnectionTable_oid[] = { TCPCONNECTIONTABLE_OID }; const int tcpConnectionTable_oid_size = OID_LENGTH (tcpConnectionTable_oid); tcpConnectionTable_registration tcpConnectionTable_user_context; void initialize_table_tcpConnectionTable (void); void shutdown_table_tcpConnectionTable (void); /** * Initializes the tcpConnectionTable module */ void init_tcpConnectionTable (void) { DEBUGMSGTL (("verbose:tcpConnectionTable:init_tcpConnectionTable", "called\n"));
#include <net-snmp/net-snmp-includes.h> #include <net-snmp/agent/net-snmp-agent-includes.h> /* * include our parent header */ #include "ExchangeTable.h" #include <net-snmp/agent/mib_modules.h> #include "ExchangeTable_interface.h" const oid brokerExchangeTable_oid[] = { brokerEXCHANGETABLE_OID }; const int brokerExchangeTable_oid_size = OID_LENGTH(brokerExchangeTable_oid); brokerExchangeTable_registration brokerExchangeTable_user_context; void initialize_table_brokerExchangeTable(void); void shutdown_table_brokerExchangeTable(void); /** * Initializes the brokerExchangeTable module */ void init_ExchangeTable(void) { DEBUGMSGTL(("verbose:brokerExchangeTable:init_ExchangeTable", "called\n"));
/************************************************************ * * Initialize the saHpiWatchdogTable table by defining its contents and how it's structured */ void initialize_table_saHpiWatchdogTable (void) { netsnmp_table_registration_info *table_info; if (my_handler) { snmp_log (LOG_ERR, "initialize_table_saHpiWatchdogTable_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 ("saHpiWatchdogTable", netsnmp_table_array_helper_handler, saHpiWatchdogTable_oid, saHpiWatchdogTable_oid_len, HANDLER_CAN_RWRITE); if (!my_handler || !table_info) { snmp_log (LOG_ERR, "malloc failed in " "initialize_table_saHpiWatchdogTable_handler\n"); return; /** mallocs failed */ } /*************************************************** * Setting up the table's definition */ /* * internal indexes */ /** index: saHpiWatchdogNum */ 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 = saHpiWatchdogTable_COL_MIN; table_info->max_column = saHpiWatchdogTable_COL_MAX; /*************************************************** * registering the table with the master agent */ cb.get_value = saHpiWatchdogTable_get_value; cb.container = netsnmp_container_find ("saHpiWatchdogTable_primary:" "saHpiWatchdogTable:" "table_container"); cb.can_set = 1; cb.create_row = (UserRowMethod *) saHpiWatchdogTable_create_row; cb.duplicate_row = (UserRowMethod *) saHpiWatchdogTable_duplicate_row; cb.delete_row = (UserRowMethod *) saHpiWatchdogTable_delete_row; cb.row_copy = (Netsnmp_User_Row_Operation *) saHpiWatchdogTable_row_copy; cb.can_delete = (Netsnmp_User_Row_Action *) saHpiWatchdogTable_can_delete; cb.set_reserve1 = saHpiWatchdogTable_set_reserve1; cb.set_reserve2 = saHpiWatchdogTable_set_reserve2; cb.set_action = saHpiWatchdogTable_set_action; cb.set_commit = saHpiWatchdogTable_set_commit; cb.set_free = saHpiWatchdogTable_set_free; cb.set_undo = saHpiWatchdogTable_set_undo; DEBUGMSGTL (("initialize_table_saHpiWatchdogTable", "Registering table saHpiWatchdogTable " "as a table array\n")); netsnmp_table_container_register (my_handler, table_info, &cb, cb.container, 1); netsnmp_register_read_only_counter32_instance ("watchdog_count", saHpiWatchdogCount_oid, OID_LENGTH (saHpiWatchdogCount_oid), &watchdog_count, NULL); }
#include <saHpiOEMEventTable.h> #include <saHpiHotSwapEventTable.h> #include <saHpiWatchdogEventTable.h> #include <saHpiSoftwareEventTable.h> #include <saHpiSensorEnableChangeEventTable.h> #include <saHpiUserEventTable.h> #include <saHpiSensorEventTable.h> #include <session_info.h> #include <oh_utils.h> static netsnmp_handler_registration *my_handler = NULL; static netsnmp_table_array_callbacks cb; oid saHpiEventTable_oid[] = { saHpiEventTable_TABLE_OID }; size_t saHpiEventTable_oid_len = OID_LENGTH(saHpiEventTable_oid); /************************************************************/ /************************************************************/ /************************************************************/ /************************************************************/ static u_long event_entry_count_total = 0; static u_long event_entry_count = 0; static oid saHpiEventEntryCountTotal_oid[] = { 1,3,6,1,4,1,18568,2,1,1,3,1,1 }; static oid saHpiEventEntryCount_oid[] = { 1,3,6,1,4,1,18568,2,1,1,3,1,2 }; int handle_saHpiEventEntryCountTotal(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests); int handle_saHpiEventEntryCount(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo,
#include <net-snmp/net-snmp-config.h> #include <net-snmp/net-snmp-includes.h> #include <net-snmp/agent/net-snmp-agent-includes.h> #include <net-snmp/library/snmp_assert.h> #include <saHpiWatchdogTable.h> #include <SaHpi.h> #include <hpiSubagent.h> static netsnmp_handler_registration *my_handler = NULL; static netsnmp_table_array_callbacks cb; static oid saHpiWatchdogTable_oid[] = { saHpiWatchdogTable_TABLE_OID }; static size_t saHpiWatchdogTable_oid_len = OID_LENGTH (saHpiWatchdogTable_oid); //{ 1, 3, 6, 1, 3, 90, 3, 9, 0 }; static oid saHpiWatchdogCount_oid[] = { hpiResources_OID, 9, 0 }; static u_long watchdog_count; static int saHpiWatchdogTable_modify_context (SaHpiWatchdogRecT * entry, SaHpiRptEntryT * rpt_entry, SaHpiWatchdogT * wdog, oid *, size_t, saHpiWatchdogTable_context * ctx);
/* * Initializes the kamailioObjects module. This involves: * * - Registering all OID's * - Setting up handlers for all OID's * * This function is mostly auto-generated. */ void init_kamailioObjects(void) { static oid kamailioMsgQueueDepth_oid[] = { KAMAILIO_OID,3,1,3,1,2,3,1 }; static oid kamailioMsgQueueMinorThreshold_oid[] = { KAMAILIO_OID,3,1,3,1,2,3,2 }; static oid kamailioMsgQueueMajorThreshold_oid[] = { KAMAILIO_OID,3,1,3,1,2,3,3 }; static oid kamailioMsgQueueDepthAlarmStatus_oid[] = { KAMAILIO_OID,3,1,3,1,2,4,1 }; static oid kamailioMsgQueueDepthMinorAlarm_oid[] = { KAMAILIO_OID,3,1,3,1,2,4,2 }; static oid kamailioMsgQueueDepthMajorAlarm_oid[] = { KAMAILIO_OID,3,1,3,1,2,4,3 }; static oid kamailioCurNumDialogs_oid[] = { KAMAILIO_OID,3,1,3,1,3,2,1 }; static oid kamailioCurNumDialogsInProgress_oid[] = { KAMAILIO_OID,3,1,3,1,3,2,2 }; static oid kamailioCurNumDialogsInSetup_oid[] = { KAMAILIO_OID,3,1,3,1,3,2,3 }; static oid kamailioTotalNumFailedDialogSetups_oid[] = { KAMAILIO_OID,3,1,3,1,3,2,4 }; static oid kamailioDialogLimitMinorThreshold_oid[] = { KAMAILIO_OID,3,1,3,1,3,2,5 }; static oid kamailioDialogLimitMajorThreshold_oid[] = { KAMAILIO_OID,3,1,3,1,3,2,6 }; static oid kamailioTotalNumDialogSetups_oid[] = { KAMAILIO_OID,3,1,3,1,3,2,7 }; static oid kamailioDialogUsageState_oid[] = { KAMAILIO_OID,3,1,3,1,3,3,1 }; static oid kamailioDialogLimitAlarmStatus_oid[] = { KAMAILIO_OID,3,1,3,1,3,4,1 }; static oid kamailioDialogLimitMinorAlarm_oid[] = { KAMAILIO_OID,3,1,3,1,3,4,2 }; static oid kamailioDialogLimitMajorAlarm_oid[] = { KAMAILIO_OID,3,1,3,1,3,4,3 }; DEBUGMSGTL(("kamailioObjects", "Initializing\n")); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioMsgQueueDepth", handle_kamailioMsgQueueDepth, kamailioMsgQueueDepth_oid, OID_LENGTH(kamailioMsgQueueDepth_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioMsgQueueMinorThreshold", handle_kamailioMsgQueueMinorThreshold, kamailioMsgQueueMinorThreshold_oid, OID_LENGTH(kamailioMsgQueueMinorThreshold_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioMsgQueueMajorThreshold", handle_kamailioMsgQueueMajorThreshold, kamailioMsgQueueMajorThreshold_oid, OID_LENGTH(kamailioMsgQueueMajorThreshold_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioMsgQueueDepthAlarmStatus", handle_kamailioMsgQueueDepthAlarmStatus, kamailioMsgQueueDepthAlarmStatus_oid, OID_LENGTH(kamailioMsgQueueDepthAlarmStatus_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioMsgQueueDepthMinorAlarm", handle_kamailioMsgQueueDepthMinorAlarm, kamailioMsgQueueDepthMinorAlarm_oid, OID_LENGTH(kamailioMsgQueueDepthMinorAlarm_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioMsgQueueDepthMajorAlarm", handle_kamailioMsgQueueDepthMajorAlarm, kamailioMsgQueueDepthMajorAlarm_oid, OID_LENGTH(kamailioMsgQueueDepthMajorAlarm_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioCurNumDialogs", handle_kamailioCurNumDialogs, kamailioCurNumDialogs_oid, OID_LENGTH(kamailioCurNumDialogs_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioCurNumDialogsInProgress", handle_kamailioCurNumDialogsInProgress, kamailioCurNumDialogsInProgress_oid, OID_LENGTH(kamailioCurNumDialogsInProgress_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioCurNumDialogsInSetup", handle_kamailioCurNumDialogsInSetup, kamailioCurNumDialogsInSetup_oid, OID_LENGTH(kamailioCurNumDialogsInSetup_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioTotalNumFailedDialogSetups", handle_kamailioTotalNumFailedDialogSetups, kamailioTotalNumFailedDialogSetups_oid, OID_LENGTH(kamailioTotalNumFailedDialogSetups_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioDialogLimitMinorThreshold", handle_kamailioDialogLimitMinorThreshold, kamailioDialogLimitMinorThreshold_oid, OID_LENGTH(kamailioDialogLimitMinorThreshold_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioDialogLimitMajorThreshold", handle_kamailioDialogLimitMajorThreshold, kamailioDialogLimitMajorThreshold_oid, OID_LENGTH(kamailioDialogLimitMajorThreshold_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioTotalNumDialogSetups", handle_kamailioTotalNumDialogSetups, kamailioTotalNumDialogSetups_oid, OID_LENGTH(kamailioTotalNumDialogSetups_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioDialogUsageState", handle_kamailioDialogUsageState, kamailioDialogUsageState_oid, OID_LENGTH(kamailioDialogUsageState_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioDialogLimitAlarmStatus", handle_kamailioDialogLimitAlarmStatus, kamailioDialogLimitAlarmStatus_oid, OID_LENGTH(kamailioDialogLimitAlarmStatus_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioDialogLimitMinorAlarm", handle_kamailioDialogLimitMinorAlarm, kamailioDialogLimitMinorAlarm_oid, OID_LENGTH(kamailioDialogLimitMinorAlarm_oid), HANDLER_CAN_RONLY) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "kamailioDialogLimitMajorAlarm", handle_kamailioDialogLimitMajorAlarm, kamailioDialogLimitMajorAlarm_oid, OID_LENGTH(kamailioDialogLimitMajorAlarm_oid), HANDLER_CAN_RONLY) ); }
void send_enterprise_trap_vars(int trap, int specific, oid * enterprise, int enterprise_length, netsnmp_variable_list * vars) { netsnmp_variable_list uptime_var, snmptrap_var, enterprise_var; netsnmp_variable_list *v2_vars, *last_var = NULL; netsnmp_pdu *template_pdu; u_long uptime; in_addr_t *pdu_in_addr_t; struct trap_sink *sink; #ifdef BRCM_SNMP_MIB_SUPPORT oid temp_oid[MAX_OID_LEN]; #endif /* * Initialise SNMPv2 required variables */ uptime = netsnmp_get_agent_uptime(); memset(&uptime_var, 0, sizeof(netsnmp_variable_list)); snmp_set_var_objid(&uptime_var, sysuptime_oid, OID_LENGTH(sysuptime_oid)); snmp_set_var_value(&uptime_var, (u_char *) & uptime, sizeof(uptime)); uptime_var.type = ASN_TIMETICKS; uptime_var.next_variable = &snmptrap_var; memset(&snmptrap_var, 0, sizeof(netsnmp_variable_list)); snmp_set_var_objid(&snmptrap_var, snmptrap_oid, OID_LENGTH(snmptrap_oid)); /* * value set later .... */ snmptrap_var.type = ASN_OBJECT_ID; if (vars) snmptrap_var.next_variable = vars; else snmptrap_var.next_variable = &enterprise_var; /* * find end of provided varbind list, * ready to append the enterprise info if necessary */ last_var = vars; while (last_var && last_var->next_variable) last_var = last_var->next_variable; memset(&enterprise_var, 0, sizeof(netsnmp_variable_list)); snmp_set_var_objid(&enterprise_var, snmptrapenterprise_oid, OID_LENGTH(snmptrapenterprise_oid)); snmp_set_var_value(&enterprise_var, (u_char *) enterprise, enterprise_length * sizeof(oid)); enterprise_var.type = ASN_OBJECT_ID; enterprise_var.next_variable = NULL; v2_vars = &uptime_var; /* * Create a template PDU, ready for sending */ template_pdu = snmp_pdu_create(SNMP_MSG_TRAP); if (template_pdu == NULL) { /* * Free memory if value stored dynamically */ snmp_set_var_value(&enterprise_var, NULL, 0); return; } template_pdu->trap_type = trap; template_pdu->specific_type = specific; if (snmp_clone_mem((void **) &template_pdu->enterprise, enterprise, enterprise_length * sizeof(oid))) { snmp_free_pdu(template_pdu); snmp_set_var_value(&enterprise_var, NULL, 0); return; } template_pdu->enterprise_length = enterprise_length; template_pdu->flags |= UCD_MSG_FLAG_FORCE_PDU_COPY; pdu_in_addr_t = (in_addr_t *) template_pdu->agent_addr; *pdu_in_addr_t = get_myaddr(); template_pdu->time = uptime; /* * Now use the parameters to determine * which v2 variables are needed, * and what values they should take. */ switch (trap) { case -1: /* * SNMPv2 only * Check to see whether the variables provided * are sufficient for SNMPv2 notifications */ if (vars && netsnmp_oid_equals(vars->name, vars->name_length, sysuptime_oid, OID_LENGTH(sysuptime_oid)) == 0) v2_vars = vars; else if (vars && netsnmp_oid_equals(vars->name, vars->name_length, snmptrap_oid, OID_LENGTH(snmptrap_oid)) == 0) uptime_var.next_variable = vars; else { /* * Hmmm... we don't seem to have a value - oops! */ snmptrap_var.next_variable = vars; } last_var = NULL; /* Don't need enterprise info */ convert_v2_to_v1(vars, template_pdu); break; /* * "Standard" SNMPv1 traps */ case SNMP_TRAP_COLDSTART: snmp_set_var_value(&snmptrap_var, (u_char *) cold_start_oid, sizeof(cold_start_oid)); break; case SNMP_TRAP_WARMSTART: snmp_set_var_value(&snmptrap_var, (u_char *) warm_start_oid, sizeof(warm_start_oid)); break; case SNMP_TRAP_LINKDOWN: snmp_set_var_value(&snmptrap_var, (u_char *) link_down_oid, sizeof(link_down_oid)); break; case SNMP_TRAP_LINKUP: snmp_set_var_value(&snmptrap_var, (u_char *) link_up_oid, sizeof(link_up_oid)); break; case SNMP_TRAP_AUTHFAIL: if (snmp_enableauthentraps == SNMP_AUTHENTICATED_TRAPS_DISABLED) { snmp_free_pdu(template_pdu); snmp_set_var_value(&enterprise_var, NULL, 0); return; } snmp_set_var_value(&snmptrap_var, (u_char *) auth_fail_oid, sizeof(auth_fail_oid)); break; case SNMP_TRAP_EGPNEIGHBORLOSS: snmp_set_var_value(&snmptrap_var, (u_char *) egp_xxx_oid, sizeof(egp_xxx_oid)); break; #ifdef BRCM_SNMP_MIB_SUPPORT case SNMP_TRAP_ENTERPRISESPECIFIC: memcpy(temp_oid, (char *) enterprise, (enterprise_length) * sizeof(oid)); temp_oid[enterprise_length] = 0; temp_oid[enterprise_length + 1] = specific; snmp_set_var_value(&snmptrap_var, (u_char *) temp_oid, (enterprise_length + 2) * sizeof(oid)); snmptrap_var.next_variable = vars; last_var = NULL; /* Don't need version info */ break; #endif /* BRCM_SNMP_MIB_SUPPORT */ } /* * Now loop through the list of trap sinks, * sending an appropriately formatted PDU to each */ for (sink = sinks; sink; sink = sink->next) { if (sink->version == SNMP_VERSION_1 && trap == -1) continue; /* Skip v1 sinks for v2 only traps */ template_pdu->command = sink->pdutype; if (sink->version != SNMP_VERSION_1) { template_pdu->variables = v2_vars; if (last_var) last_var->next_variable = &enterprise_var; } else template_pdu->variables = vars; send_trap_to_sess(sink->sesp, template_pdu); if (sink->version != SNMP_VERSION_1 && last_var) last_var->next_variable = NULL; } /* * send stuff to registered callbacks */ /* * v2 traps/informs */ template_pdu->variables = v2_vars; if (last_var) last_var->next_variable = &enterprise_var; snmp_call_callbacks(SNMP_CALLBACK_APPLICATION, SNMPD_CALLBACK_SEND_TRAP2, template_pdu); if (last_var) last_var->next_variable = NULL; /* * v1 traps */ template_pdu->command = SNMP_MSG_TRAP; template_pdu->variables = vars; snmp_call_callbacks(SNMP_CALLBACK_APPLICATION, SNMPD_CALLBACK_SEND_TRAP1, template_pdu); /* * Free memory if values stored dynamically */ snmp_set_var_value(&enterprise_var, NULL, 0); snmp_set_var_value(&snmptrap_var, NULL, 0); /* * Ensure we don't free anything we shouldn't */ if (last_var) last_var->next_variable = NULL; template_pdu->variables = NULL; snmp_free_pdu(template_pdu); }
*/ /* * Note: this file originally auto-generated by mib2c using * : mib2c.array-user.conf 15997 2007-03-25 22:28:35Z dts12 $ * * $Id:$ */ #include "itu_alarm_table.hpp" static netsnmp_handler_registration* my_handler = NULL; static netsnmp_table_array_callbacks cb; oid ituAlarmTable_oid[] = { ituAlarmTable_TABLE_OID }; size_t ituAlarmTable_oid_len = OID_LENGTH(ituAlarmTable_oid); static oid alarm_model_table_row_oid[] = { ALARM_MODEL_TABLE_ROW_OID }; /************************************************************ * * Initializes the ituAlarmTable module */ void init_ituAlarmTable(void) { AlarmTableDefs& defs = AlarmTableDefs::get_instance(); if (initialize_table_ituAlarmTable() == SNMP_ERR_NOERROR) { for (AlarmTableDefsIterator it = defs.begin(); it != defs.end(); it++) {
#include <net-snmp/library/snmp_assert.h> #include <SaHpi.h> #include "saHpiSensorReadingMaxTable.h" #include <hpiSubagent.h> #include <hpiCheckIndice.h> #include <session_info.h> #include <oh_utils.h> static netsnmp_handler_registration *my_handler = NULL; static netsnmp_table_array_callbacks cb; oid saHpiSensorReadingMaxTable_oid[] = { saHpiSensorReadingMaxTable_TABLE_OID}; size_t saHpiSensorReadingMaxTable_oid_len = OID_LENGTH(saHpiSensorReadingMaxTable_oid); /************************************************************/ /************************************************************/ /************************************************************/ /************************************************************/ /* * SaErrorT populate_sensor_max() */ SaErrorT populate_sensor_max(SaHpiSessionIdT sessionid, SaHpiRdrT *rdr_entry, SaHpiRptEntryT *rpt_entry) { DEBUGMSGTL ((AGENT, "populate_sensor_max, called\n"));
/** here we send a SNMP v2 trap (which can be sent through snmpv3 and * snmpv1 as well) and send it out. */ void send_example_notification(unsigned int clientreg, void *clientarg) { /* * define the OID for the notification we're going to send * NET-SNMP-EXAMPLES-MIB::netSnmpExampleNotification */ oid notification_oid[] = { 1, 3, 6, 1, 4, 1, 8072, 2, 3, 1 }; size_t notification_oid_len = OID_LENGTH(notification_oid); /* * In the notification, we have to assign our notification OID to * the snmpTrapOID.0 object. Here is it's definition. */ oid objid_snmptrap[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 }; size_t objid_snmptrap_len = OID_LENGTH(objid_snmptrap); /* * here is where we store the variables to be sent in the trap */ netsnmp_variable_list *notification_vars = NULL; DEBUGMSGTL(("example_notification", "defining the trap\n")); /* * add in the trap definition object */ snmp_varlist_add_variable(¬ification_vars, /* * the snmpTrapOID.0 variable */ objid_snmptrap, objid_snmptrap_len, /* * value type is an OID */ ASN_OBJECT_ID, /* * value contents is our notification OID */ (u_char *) notification_oid, /* * size in bytes = oid length * sizeof(oid) */ notification_oid_len * sizeof(oid)); /* * if we wanted to insert additional objects, we'd do it here */ /* * send the trap out. This will send it to all registered * receivers (see the "SETTING UP TRAP AND/OR INFORM DESTINATIONS" * section of the snmpd.conf manual page. */ DEBUGMSGTL(("example_notification", "sending the trap\n")); send_v2trap(notification_vars); /* * free the created notification variable list */ DEBUGMSGTL(("example_notification", "cleaning up\n")); snmp_free_varbind(notification_vars); }
#include <net-snmp/net-snmp-includes.h> #include <net-snmp/agent/net-snmp-agent-includes.h> /* * include our parent header */ #include "SessionTable.h" #include <net-snmp/agent/mib_modules.h> #include "SessionTable_interface.h" const oid brokerSessionTable_oid[] = { brokerSESSIONTABLE_OID }; const int brokerSessionTable_oid_size = OID_LENGTH(brokerSessionTable_oid); brokerSessionTable_registration brokerSessionTable_user_context; void initialize_table_brokerSessionTable(void); void shutdown_table_brokerSessionTable(void); /** * Initializes the brokerSessionTable module */ void init_SessionTable(void) { DEBUGMSGTL(("verbose:brokerSessionTable:init_SessionTable", "called\n"));
* Yes, there is lots of code here that you might not use. But it is much * easier to remove code than to add it! */ #include <net-snmp/net-snmp-config.h> #include <net-snmp/net-snmp-includes.h> #include <net-snmp/agent/net-snmp-agent-includes.h> #include <net-snmp/library/snmp_assert.h> #include "saHpiHotSwapEventLogTable.h" static netsnmp_handler_registration *my_handler = NULL; static netsnmp_table_array_callbacks cb; oid saHpiHotSwapEventLogTable_oid[] = { saHpiHotSwapEventLogTable_TABLE_OID }; size_t saHpiHotSwapEventLogTable_oid_len = OID_LENGTH(saHpiHotSwapEventLogTable_oid); #ifdef saHpiHotSwapEventLogTable_IDX2 /************************************************************ * keep binary tree to find context by name */ static int saHpiHotSwapEventLogTable_cmp( const void *lhs, const void *rhs ); /************************************************************ * compare two context pointers here. Return -1 if lhs < rhs, * 0 if lhs == rhs, and 1 if lhs > rhs. */ static int saHpiHotSwapEventLogTable_cmp( const void *lhs, const void *rhs ) {
void init_nsCache(void) { const oid nsCacheTimeout_oid[] = { nsCache, 1 }; const oid nsCacheEnabled_oid[] = { nsCache, 2 }; const oid nsCacheTable_oid[] = { nsCache, 3 }; netsnmp_table_registration_info *table_info; netsnmp_iterator_info *iinfo; /* * Register the scalar objects... */ DEBUGMSGTL(("nsCacheScalars", "Initializing\n")); netsnmp_register_scalar( netsnmp_create_handler_registration( "nsCacheTimeout", handle_nsCacheTimeout, nsCacheTimeout_oid, OID_LENGTH(nsCacheTimeout_oid), HANDLER_CAN_RWRITE) ); netsnmp_register_scalar( netsnmp_create_handler_registration( "nsCacheEnabled", handle_nsCacheEnabled, nsCacheEnabled_oid, OID_LENGTH(nsCacheEnabled_oid), HANDLER_CAN_RWRITE) ); /* * ... and the table. * We need to define the column structure and indexing.... */ table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); if (!table_info) { return; } netsnmp_table_helper_add_indexes(table_info, ASN_PRIV_IMPLIED_OBJECT_ID, 0); table_info->min_column = NSCACHE_TIMEOUT; table_info->max_column = NSCACHE_STATUS; /* * .... and the iteration information .... */ iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info); if (!iinfo) { return; } iinfo->get_first_data_point = get_first_cache_entry; iinfo->get_next_data_point = get_next_cache_entry; iinfo->table_reginfo = table_info; /* * .... and register the table with the agent. */ netsnmp_register_table_iterator2( netsnmp_create_handler_registration( "tzCacheTable", handle_nsCacheTable, nsCacheTable_oid, OID_LENGTH(nsCacheTable_oid), HANDLER_CAN_RWRITE), iinfo); }
/* * Our list of supported transport domains. */ static netsnmp_tdomain *domain_list = NULL; /* * The standard SNMP domains. */ oid netsnmpUDPDomain[] = { 1, 3, 6, 1, 6, 1, 1 }; size_t netsnmpUDPDomain_len = OID_LENGTH(netsnmpUDPDomain); oid netsnmpCLNSDomain[] = { 1, 3, 6, 1, 6, 1, 2 }; size_t netsnmpCLNSDomain_len = OID_LENGTH(netsnmpCLNSDomain); oid netsnmpCONSDomain[] = { 1, 3, 6, 1, 6, 1, 3 }; size_t netsnmpCONSDomain_len = OID_LENGTH(netsnmpCONSDomain); oid netsnmpDDPDomain[] = { 1, 3, 6, 1, 6, 1, 4 }; size_t netsnmpDDPDomain_len = OID_LENGTH(netsnmpDDPDomain); oid netsnmpIPXDomain[] = { 1, 3, 6, 1, 6, 1, 5 }; size_t netsnmpIPXDomain_len = OID_LENGTH(netsnmpIPXDomain); static void netsnmp_tdomain_dump(void); /*
#include <net-snmp/net-snmp-includes.h> #include <net-snmp/agent/net-snmp-agent-includes.h> /* * include our parent header */ #include "wmanIfBsServiceClassTable.h" #include <net-snmp/agent/mib_modules.h> #include "wmanIfBsServiceClassTable_interface.h" oid wmanIfBsServiceClassTable_oid[] = { WMANIFBSSERVICECLASSTABLE_OID }; int wmanIfBsServiceClassTable_oid_size = OID_LENGTH(wmanIfBsServiceClassTable_oid); wmanIfBsServiceClassTable_registration wmanIfBsServiceClassTable_user_context; void initialize_table_wmanIfBsServiceClassTable(void); void shutdown_table_wmanIfBsServiceClassTable(void); /** * Initializes the wmanIfBsServiceClassTable module */ void init_wmanIfBsServiceClassTable(void) { DEBUGMSGTL(("verbose:wmanIfBsServiceClassTable:init_wmanIfBsServiceClassTable", "called\n"));
void init_icmp(void) { netsnmp_handler_registration *reginfo; netsnmp_handler_registration *msg_stats_reginfo; netsnmp_iterator_info *iinfo; netsnmp_iterator_info *msg_stats_iinfo; netsnmp_table_registration_info *table_info; netsnmp_table_registration_info *msg_stats_table_info; /* * register ourselves with the agent as a group of scalars... */ DEBUGMSGTL(("mibII/icmp", "Initialising ICMP group\n")); reginfo = netsnmp_create_handler_registration("icmp", icmp_handler, icmp_oid, OID_LENGTH(icmp_oid), HANDLER_CAN_RONLY); netsnmp_register_scalar_group(reginfo, ICMPINMSGS, ICMPOUTADDRMASKREPS); /* * .... with a local cache * (except for HP-UX 11, which extracts objects individually) */ #ifndef hpux11 netsnmp_inject_handler( reginfo, netsnmp_get_cache_handler(ICMP_STATS_CACHE_TIMEOUT, icmp_load, icmp_free, icmp_oid, OID_LENGTH(icmp_oid))); #endif #ifdef linux /* register icmpStatsTable */ reginfo = netsnmp_create_handler_registration("icmpStatsTable", icmp_stats_table_handler, icmp_stats_tbl_oid, OID_LENGTH(icmp_stats_tbl_oid), HANDLER_CAN_RONLY); table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); if (!table_info) { return; } netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, 0); table_info->min_column = ICMP_STAT_INMSG; table_info->max_column = ICMP_STAT_OUTERR; iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info); if (!iinfo) { return; } iinfo->get_first_data_point = icmp_stats_first_entry; iinfo->get_next_data_point = icmp_stats_next_entry; iinfo->table_reginfo = table_info; netsnmp_register_table_iterator(reginfo, iinfo); /* register icmpMsgStatsTable */ msg_stats_reginfo = netsnmp_create_handler_registration("icmpMsgStatsTable", icmp_msg_stats_table_handler, icmp_msg_stats_tbl_oid, OID_LENGTH(icmp_msg_stats_tbl_oid), HANDLER_CAN_RONLY); msg_stats_table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); if (!msg_stats_table_info) { return; } netsnmp_table_helper_add_indexes(msg_stats_table_info, ASN_INTEGER, ASN_INTEGER, 0); msg_stats_table_info->min_column = ICMP_MSG_STAT_IN_PKTS; msg_stats_table_info->max_column = ICMP_MSG_STAT_OUT_PKTS; msg_stats_iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info); if (!msg_stats_iinfo) { return; } msg_stats_iinfo->get_first_data_point = icmp_msg_stats_first_entry; msg_stats_iinfo->get_next_data_point = icmp_msg_stats_next_entry; msg_stats_iinfo->table_reginfo = msg_stats_table_info; netsnmp_register_table_iterator(msg_stats_reginfo, msg_stats_iinfo); netsnmp_inject_handler( msg_stats_reginfo, netsnmp_get_cache_handler(ICMP_STATS_CACHE_TIMEOUT, icmp_load, icmp_free, icmp_msg_stats_tbl_oid, OID_LENGTH(icmp_msg_stats_tbl_oid))); #ifndef hpux11 netsnmp_inject_handler( reginfo, netsnmp_get_cache_handler(ICMP_STATS_CACHE_TIMEOUT, icmp_load, icmp_free, icmp_stats_tbl_oid, OID_LENGTH(icmp_stats_tbl_oid))); #endif /* ! hpux11 */ #endif /* linux */ #ifdef USING_MIBII_IP_MODULE if (++ip_module_count == 2) REGISTER_SYSOR_TABLE(ip_module_oid, ip_module_oid_len, "The MIB module for managing IP and ICMP implementations"); #endif #if !defined(_USE_PERFSTAT_PROTOCOL) #ifdef ICMPSTAT_SYMBOL auto_nlist(ICMPSTAT_SYMBOL, 0, 0); #endif #ifdef solaris2 init_kernel_sunos5(); #endif #endif }
void init_tcpTable(void) { const oid tcpTable_oid[] = { SNMP_OID_MIB2, 6, 13 }; netsnmp_table_registration_info *table_info; netsnmp_iterator_info *iinfo; netsnmp_handler_registration *reginfo; int rc; DEBUGMSGTL(("mibII/tcpTable", "Initialising TCP Table\n")); /* * Create the table data structure, and define the indexing.... */ table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); if (!table_info) { return; } netsnmp_table_helper_add_indexes(table_info, ASN_IPADDRESS, ASN_INTEGER, ASN_IPADDRESS, ASN_INTEGER, 0); table_info->min_column = TCPCONNSTATE; table_info->max_column = TCPCONNREMOTEPORT; /* * .... and iteration information .... */ iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info); if (!iinfo) { return; } iinfo->get_first_data_point = tcpTable_first_entry; iinfo->get_next_data_point = tcpTable_next_entry; iinfo->table_reginfo = table_info; #if defined (WIN32) || defined (cygwin) iinfo->flags |= NETSNMP_ITERATOR_FLAG_SORTED; #endif /* WIN32 || cygwin */ /* * .... and register the table with the agent. */ reginfo = netsnmp_create_handler_registration("tcpTable", tcpTable_handler, tcpTable_oid, OID_LENGTH(tcpTable_oid), HANDLER_CAN_RONLY), rc = netsnmp_register_table_iterator2(reginfo, iinfo); if (rc != SNMPERR_SUCCESS) return; /* * .... with a local cache * (except for Solaris, which uses a different approach) */ netsnmp_inject_handler( reginfo, netsnmp_get_cache_handler(TCP_STATS_CACHE_TIMEOUT, tcpTable_load, tcpTable_free, tcpTable_oid, OID_LENGTH(tcpTable_oid))); }
#include <net-snmp/library/snmp_assert.h> #include <saHpiSensorThdNegHysteresisTable.h> #include <hpiSubagent.h> static netsnmp_handler_registration *my_handler = NULL; static netsnmp_table_array_callbacks cb; oid saHpiSensorThdNegHysteresisTable_oid[] = { saHpiSensorThdNegHysteresisTable_TABLE_OID }; size_t saHpiSensorThdNegHysteresisTable_oid_len = OID_LENGTH (saHpiSensorThdNegHysteresisTable_oid); static int modify_saHpiSensorThdNegHysteresisTable_row (SaHpiDomainIdT domain_id, SaHpiResourceIdT resource_id, SaHpiSensorNumT sensor_num, SaHpiSensorThdDefnT * threshold_def, SaHpiSensorReadingT * reading, saHpiSensorThdNegHysteresisTable_context * ctx); int delete_ThdNegHysteresis_row (SaHpiDomainIdT domain_id, SaHpiResourceIdT resource_id, SaHpiSensorNumT sensor_num)
#include <net-snmp/agent/net-snmp-agent-includes.h> #include <net-snmp/library/snmp_assert.h> #include <SaHpi.h> #include "saHpiWatchdogEventLogTable.h" #include <hpiSubagent.h> #include <hpiCheckIndice.h> #include <session_info.h> #include <oh_utils.h> static netsnmp_handler_registration *my_handler = NULL; static netsnmp_table_array_callbacks cb; oid saHpiWatchdogEventLogTable_oid[] = { saHpiWatchdogEventLogTable_TABLE_OID }; size_t saHpiWatchdogEventLogTable_oid_len = OID_LENGTH(saHpiWatchdogEventLogTable_oid); /************************************************************/ /************************************************************/ /************************************************************/ /************************************************************/ /************************************************************* * objects for hash table */ static int initialized = FALSE; static GHashTable *dr_table; /************************************************************* * oid and fucntion declarations scalars */
/* * Initializes the openserSIPCommonObjects MIB elements. This involves: * * - Registering all OID's * - Setting up handlers for all OID's * * This function is mostly auto-generated. */ void init_openserSIPCommonObjects(void) { static oid openserSIPProtocolVersion_oid[] = { OPENSER_OID,3,1,1,1,1,1 }; static oid openserSIPServiceStartTime_oid[] = { OPENSER_OID,3,1,1,1,1,2 }; static oid openserSIPEntityType_oid[] = { OPENSER_OID,3,1,1,1,1,4 }; static oid openserSIPSummaryInRequests_oid[] = { OPENSER_OID,3,1,1,1,3,1 }; static oid openserSIPSummaryOutRequests_oid[] = { OPENSER_OID,3,1,1,1,3,2 }; static oid openserSIPSummaryInResponses_oid[] = { OPENSER_OID,3,1,1,1,3,3 }; static oid openserSIPSummaryOutResponses_oid[] = { OPENSER_OID,3,1,1,1,3,4 }; static oid openserSIPSummaryTotalTransactions_oid[] = { OPENSER_OID,3,1,1,1,3,5 }; static oid openserSIPCurrentTransactions_oid[] = { OPENSER_OID,3,1,1,1,6,1 }; static oid openserSIPNumUnsupportedUris_oid[] = { OPENSER_OID,3,1,1,1,8,1 }; static oid openserSIPNumUnsupportedMethods_oid[] = { OPENSER_OID,3,1,1,1,8,2 }; static oid openserSIPOtherwiseDiscardedMsgs_oid[] = { OPENSER_OID,3,1,1,1,8,3 }; DEBUGMSGTL(("openserSIPCommonObjects", "Initializing\n")); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPProtocolVersion", handle_openserSIPProtocolVersion, openserSIPProtocolVersion_oid, OID_LENGTH(openserSIPProtocolVersion_oid), HANDLER_CAN_RONLY)); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPServiceStartTime", handle_openserSIPServiceStartTime, openserSIPServiceStartTime_oid, OID_LENGTH(openserSIPServiceStartTime_oid), HANDLER_CAN_RONLY)); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPEntityType", handle_openserSIPEntityType, openserSIPEntityType_oid, OID_LENGTH(openserSIPEntityType_oid), HANDLER_CAN_RONLY)); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPSummaryInRequests", handle_openserSIPSummaryInRequests, openserSIPSummaryInRequests_oid, OID_LENGTH(openserSIPSummaryInRequests_oid), HANDLER_CAN_RONLY)); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPSummaryOutRequests", handle_openserSIPSummaryOutRequests, openserSIPSummaryOutRequests_oid, OID_LENGTH(openserSIPSummaryOutRequests_oid), HANDLER_CAN_RONLY)); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPSummaryInResponses", handle_openserSIPSummaryInResponses, openserSIPSummaryInResponses_oid, OID_LENGTH(openserSIPSummaryInResponses_oid), HANDLER_CAN_RONLY)); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPSummaryOutResponses", handle_openserSIPSummaryOutResponses, openserSIPSummaryOutResponses_oid, OID_LENGTH(openserSIPSummaryOutResponses_oid), HANDLER_CAN_RONLY)); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPSummaryTotalTransactions", handle_openserSIPSummaryTotalTransactions, openserSIPSummaryTotalTransactions_oid, OID_LENGTH(openserSIPSummaryTotalTransactions_oid), HANDLER_CAN_RONLY)); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPCurrentTransactions", handle_openserSIPCurrentTransactions, openserSIPCurrentTransactions_oid, OID_LENGTH(openserSIPCurrentTransactions_oid), HANDLER_CAN_RONLY)); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPNumUnsupportedUris", handle_openserSIPNumUnsupportedUris, openserSIPNumUnsupportedUris_oid, OID_LENGTH(openserSIPNumUnsupportedUris_oid), HANDLER_CAN_RONLY)); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPNumUnsupportedMethods", handle_openserSIPNumUnsupportedMethods, openserSIPNumUnsupportedMethods_oid, OID_LENGTH(openserSIPNumUnsupportedMethods_oid), HANDLER_CAN_RONLY)); netsnmp_register_scalar( netsnmp_create_handler_registration( "openserSIPOtherwiseDiscardedMsgs", handle_openserSIPOtherwiseDiscardedMsgs, openserSIPOtherwiseDiscardedMsgs_oid, OID_LENGTH(openserSIPOtherwiseDiscardedMsgs_oid), HANDLER_CAN_RONLY)); }
authKeyOid[MAX_OID_LEN] = { 1, 3, 6, 1, 6, 3, 15, 1, 2, 2, 1, 6 }, ownAuthKeyOid[MAX_OID_LEN] = {1, 3, 6, 1, 6, 3, 15, 1, 2, 2, 1, 7}, privKeyOid[MAX_OID_LEN] = {1, 3, 6, 1, 6, 3, 15, 1, 2, 2, 1, 9}, ownPrivKeyOid[MAX_OID_LEN] = {1, 3, 6, 1, 6, 3, 15, 1, 2, 2, 1, 10}, usmUserCloneFrom[MAX_OID_LEN] = {1, 3, 6, 1, 6, 3, 15, 1, 2, 2, 1, 4}, usmUserSecurityName[MAX_OID_LEN] = {1, 3, 6, 1, 6, 3, 15, 1, 2, 2, 1, 3}, usmUserPublic[MAX_OID_LEN] = {1, 3, 6, 1, 6, 3, 15, 1, 2, 2, 1, 11}, usmUserStatus[MAX_OID_LEN] = {1, 3, 6, 1, 6, 3, 15, 1, 2, 2, 1, 13}, /* diffie helman change key objects */ usmDHUserAuthKeyChange[MAX_OID_LEN] = {1, 3, 6, 1, 3, 101, 1, 1, 2, 1, 1 }, usmDHUserOwnAuthKeyChange[MAX_OID_LEN] = {1, 3, 6, 1, 3, 101, 1, 1, 2, 1, 2 }, usmDHUserPrivKeyChange[MAX_OID_LEN] = {1, 3, 6, 1, 3, 101, 1, 1, 2, 1, 3 }, usmDHUserOwnPrivKeyChange[MAX_OID_LEN] = {1, 3, 6, 1, 3, 101, 1, 1, 2, 1, 4 }, usmDHParameters[] = { 1,3,6,1,3,101,1,1,1,0 } ; size_t usmDHParameters_len = OID_LENGTH(usmDHParameters); static oid *authKeyChange = authKeyOid, *privKeyChange = privKeyOid; oid *dhauthKeyChange = usmDHUserAuthKeyChange, *dhprivKeyChange = usmDHUserPrivKeyChange; int doauthkey = 0, doprivkey = 0, uselocalizedkey = 0; size_t usmUserEngineIDLen = 0; u_char *usmUserEngineID = NULL; char *usmUserPublic_val = NULL; void usage(void) { fprintf(stderr, "Usage: snmpusm ");
#include <net-snmp/library/snmp_assert.h> #include <SaHpi.h> #include "saHpiDomainEventLogTable.h" #include <hpiSubagent.h> #include <hpiCheckIndice.h> #include <session_info.h> #include <oh_utils.h> #include <hpiLock.h> static netsnmp_handler_registration *my_handler = NULL; static netsnmp_table_array_callbacks cb; oid saHpiDomainEventLogTable_oid[] = { saHpiDomainEventLogTable_TABLE_OID }; size_t saHpiDomainEventLogTable_oid_len = OID_LENGTH(saHpiDomainEventLogTable_oid); /************************************************************/ /************************************************************/ /************************************************************/ /************************************************************/ /************************************************************* * objects for hash table */ static int initialized = FALSE; static GHashTable *dr_table; /************************************************************* * oid and fucntion declarations scalars
sysObjectIDByteLength = version_sysoid_len * sizeof(oid); memcpy(sysObjectID, version_sysoid, sysObjectIDByteLength); } else sysObjectIDByteLength = sysObjectIDLength * sizeof(oid); } /********************* * * Initialisation & common implementation functions * *********************/ oid system_module_oid[] = { SNMP_OID_SNMPMODULES, 1 }; int system_module_oid_len = OID_LENGTH(system_module_oid); int system_module_count = 0; static int system_store(int a, int b, void *c, void *d) { char line[SNMP_MAXBUF_SMALL]; if (sysLocationSet > 0) { snprintf(line, SNMP_MAXBUF_SMALL, "psyslocation %s", sysLocation); snmpd_store_config(line); } if (sysContactSet > 0) { snprintf(line, SNMP_MAXBUF_SMALL, "psyscontact %s", sysContact); snmpd_store_config(line); }