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);
}
