void
init_ip(void)
{
/*
* register ourselves with the agent to handle our mib tree
*/
REGISTER_MIB("mibII/ip", ip_variables, variable3, ip_variables_oid);
if (++ip_module_count == 2)
REGISTER_SYSOR_ENTRY(ip_module_oid,
"The MIB module for managing IP and ICMP implementations");
/*
* for speed optimization, we call this now to do the lookup
*/
#ifdef IPSTAT_SYMBOL
auto_nlist(IPSTAT_SYMBOL, 0, 0);
#endif
#ifdef IP_FORWARDING_SYMBOL
auto_nlist(IP_FORWARDING_SYMBOL, 0, 0);
#endif
#ifdef TCP_TTL_SYMBOL
auto_nlist(TCP_TTL_SYMBOL, 0, 0);
#endif
#ifdef MIB_IPCOUNTER_SYMBOL
auto_nlist(MIB_IPCOUNTER_SYMBOL, 0, 0);
#endif
#ifdef solaris2
init_kernel_sunos5();
#endif
}
int
ip_load(netsnmp_cache *cache, void *vmagic)
{
long ret_value = -1;
int magic = (int) vmagic;
switch (magic) {
case IPFORWARDING:
if (!auto_nlist
(IP_FORWARDING_SYMBOL, (char *) &ret_value, sizeof(ret_value)))
return -1;
else
return (ret_value ? 1 /* GATEWAY */
: 2 /* HOST */ );
case IPDEFAULTTTL:
if (!auto_nlist
(TCP_TTL_SYMBOL, (char *) &ret_value, sizeof(ret_value)))
return -1;
else
return ret_value;
default:
if (auto_nlist(IPSTAT_SYMBOL, (char *)&ipstat, sizeof(ipstat)))
ret_value = 0;
if ( ret_value < 0 ) {
DEBUGMSGTL(("mibII/ip", "Failed to load IP Group (ipstat)\n"));
} else {
DEBUGMSGTL(("mibII/ip", "Loaded IP Group (ipstat)\n"));
}
return ret_value;
}
}
/* ---------------------------------------------------------------------
*/
void
netsnmp_arch_swrun_init(void)
{
extern int _swrun_max;
auto_nlist( PROC_SYMBOL, 0, 0);
auto_nlist( NPROC_SYMBOL, (char *)&_swrun_max, sizeof(int));
return;
}
void
init_ip(void)
{
netsnmp_handler_registration *reginfo;
/*
* register ourselves with the agent as a group of scalars...
*/
DEBUGMSGTL(("mibII/ip", "Initialising IP group\n"));
reginfo = netsnmp_create_handler_registration("ip", ip_handler,
ip_oid, OID_LENGTH(ip_oid), HANDLER_CAN_RONLY);
netsnmp_register_scalar_group(reginfo, IPFORWARDING, IPROUTEDISCARDS);
/*
* .... with a local cache
* (except for HP-UX 11, which extracts objects individually)
*/
#ifndef hpux11
netsnmp_inject_handler( reginfo,
netsnmp_get_cache_handler(IP_STATS_CACHE_TIMEOUT,
ip_load, ip_free,
ip_oid, OID_LENGTH(ip_oid)));
#endif
/*
* register (using the old-style API) to handle the IP tables
*/
REGISTER_MIB("mibII/ipaddr", ipaddr_variables,
variable1, ipaddr_variables_oid);
REGISTER_MIB("mibII/iproute", iproute_variables,
variable1, iproute_variables_oid);
REGISTER_MIB("mibII/ipmedia", ipmedia_variables,
variable1, ipmedia_variables_oid);
if (++ip_module_count == 2)
REGISTER_SYSOR_ENTRY(ip_module_oid,
"The MIB module for managing IP and ICMP implementations");
/*
* for speed optimization, we call this now to do the lookup
*/
#ifdef IPSTAT_SYMBOL
auto_nlist(IPSTAT_SYMBOL, 0, 0);
#endif
#ifdef IP_FORWARDING_SYMBOL
auto_nlist(IP_FORWARDING_SYMBOL, 0, 0);
#endif
#ifdef TCP_TTL_SYMBOL
auto_nlist(TCP_TTL_SYMBOL, 0, 0);
#endif
#ifdef MIB_IPCOUNTER_SYMBOL
auto_nlist(MIB_IPCOUNTER_SYMBOL, 0, 0);
#endif
#ifdef solaris2
init_kernel_sunos5();
#endif
}
static void
Address_Scan_Init(void)
{
int rc = auto_nlist(IFADDR_SYMBOL, (char *) &in_ifaddraddr,
sizeof(in_ifaddraddr));
if (0 == rc)
in_ifaddraddr = NULL;
}
void
init_tcp(void)
{
netsnmp_handler_registration *reginfo;
int rc;
/*
* register ourselves with the agent as a group of scalars...
*/
DEBUGMSGTL(("mibII/tcpScalar", "Initialising TCP scalar group\n"));
reginfo = netsnmp_create_handler_registration("tcp", tcp_handler,
tcp_oid, OID_LENGTH(tcp_oid), HANDLER_CAN_RONLY);
rc = netsnmp_register_scalar_group(reginfo, TCPRTOALGORITHM, TCPOUTRSTS);
if (rc != SNMPERR_SUCCESS)
return;
/*
* .... with a local cache
* (except for HP-UX 11, which extracts objects individually)
*/
#ifndef hpux11
netsnmp_inject_handler( reginfo,
netsnmp_get_cache_handler(TCP_STATS_CACHE_TIMEOUT,
tcp_load, tcp_free,
tcp_oid, OID_LENGTH(tcp_oid)));
#endif
REGISTER_SYSOR_ENTRY(tcp_module_oid,
"The MIB module for managing TCP implementations");
#if !defined(_USE_FIRST_PROTOCOL)
#ifdef TCPSTAT_SYMBOL
auto_nlist(TCPSTAT_SYMBOL, 0, 0);
#endif
#ifdef TCP_SYMBOL
auto_nlist(TCP_SYMBOL, 0, 0);
#endif
#ifdef freebsd4
hz = sysconf(_SC_CLK_TCK); /* get ticks/s from system */
#endif
#ifdef solaris2
init_kernel_sunos5();
#endif
#endif
}
int
tcpTable_load(netsnmp_cache *cache, void *vmagic)
{
struct inpcb tcp_inpcb;
struct tcpcb tcpcb;
netsnmp_inpcb *nnew;
struct inpcb *entry;
#ifdef hpux
int StateMap[] = { 1, 2, 3, -1, 4, 5, 8, 6, 10, 9, 7, 11 };
#else
int StateMap[] = { 1, 2, 3, 4, 5, 8, 6, 10, 9, 7, 11 };
#endif
tcpTable_free(NULL, NULL);
if (!auto_nlist(TCP_SYMBOL, (char *) &tcp_inpcb, sizeof(tcp_inpcb))) {
DEBUGMSGTL(("mibII/tcpTable", "Failed to read tcp_symbol\n"));
return -1;
}
/*
* Set up a linked list
*/
entry = tcp_inpcb.INP_NEXT_SYMBOL;
while (entry) {
nnew = SNMP_MALLOC_TYPEDEF(netsnmp_inpcb);
if (!nnew)
break;
if (!NETSNMP_KLOOKUP(entry, (char *)&(nnew->pcb), sizeof(struct inpcb))) {
DEBUGMSGTL(("mibII/tcpTable:tcpTable_load", "klookup failed\n"));
break;
}
if (!NETSNMP_KLOOKUP(nnew->pcb.inp_ppcb, (char *)&tcpcb, sizeof(struct tcpcb))) {
DEBUGMSGTL(("mibII/tcpTable:tcpTable_load", "klookup failed\n"));
break;
}
nnew->state = StateMap[tcpcb.t_state];
if (nnew->state == 5 /* established */ ||
nnew->state == 8 /* closeWait */ )
tcp_estab++;
entry = nnew->pcb.INP_NEXT_SYMBOL; /* Next kernel entry */
nnew->inp_next = tcp_head;
tcp_head = nnew;
if (entry == tcp_inpcb.INP_NEXT_SYMBOL)
break;
}
if (tcp_head) {
DEBUGMSGTL(("mibII/tcpTable", "Loaded TCP Table (tcp_symbol)\n"));
return 0;
}
DEBUGMSGTL(("mibII/tcpTable", "Failed to load TCP Table (tcp_symbol)\n"));
return -1;
}
void init_ip(void)
{
/* register ourselves with the agent to handle our mib tree */
REGISTER_MIB("mibII/ip", ip_variables, variable4, ip_variables_oid);
/* for speed optimization, we call this now to do the lookup */
#ifdef IPSTAT_SYMBOL
auto_nlist(IPSTAT_SYMBOL,0,0);
#endif
#ifdef IP_FORWARDING_SYMBOL
auto_nlist(IP_FORWARDING_SYMBOL,0,0);
#endif
#ifdef TCP_TTL_SYMBOL
auto_nlist(TCP_TTL_SYMBOL,0,0);
#endif
#ifdef MIB_IPCOUNTER_SYMBOL
auto_nlist(MIB_IPCOUNTER_SYMBOL,0,0);
#endif
}
void
init_hr_system(void)
{
#ifdef NPROC_SYMBOL
auto_nlist(NPROC_SYMBOL, 0, 0);
#endif
REGISTER_MIB("host/hr_system", hrsystem_variables, variable2,
hrsystem_variables_oid);
} /* end init_hr_system */
/*
* Load the latest CPU usage statistics
*/
int netsnmp_cpu_arch_load( netsnmp_cache *cache, void *magic ) {
long cpu_stats[CPUSTATES];
struct vmmeter mem_stats;
netsnmp_cpu_info *cpu = netsnmp_cpu_get_byIdx( -1, 0 );
auto_nlist( CPU_SYMBOL, (char *) cpu_stats, sizeof(cpu_stats));
auto_nlist( MEM_SYMBOL, (char *)&mem_stats, sizeof(mem_stats));
cpu->user_ticks = (unsigned long long)cpu_stats[CP_USER];
cpu->nice_ticks = (unsigned long long)cpu_stats[CP_NICE];
cpu->sys2_ticks = (unsigned long long)cpu_stats[CP_SYS]+cpu_stats[CP_INTR];
cpu->idle_ticks = (unsigned long long)cpu_stats[CP_IDLE];
cpu->kern_ticks = (unsigned long long)cpu_stats[CP_SYS];
cpu->intrpt_ticks = (unsigned long long)cpu_stats[CP_INTR];
/* wait_ticks, sirq_ticks unused */
/*
* Interrupt/Context Switch statistics
* XXX - Do these really belong here ?
*/
#if defined(openbsd2) || defined(darwin)
cpu->swapIn = (unsigned long long)mem_stats.v_swpin;
cpu->swapOut = (unsigned long long)mem_stats.v_swpout;
#else
cpu->swapIn = (unsigned long long)mem_stats.v_swappgsin+mem_stats.v_vnodepgsin;
cpu->swapOut = (unsigned long long)mem_stats.v_swappgsout+mem_stats.v_vnodepgsout;
#endif
cpu->nInterrupts = (unsigned long long)mem_stats.v_intr;
cpu->nCtxSwitches = (unsigned long long)mem_stats.v_swtch;
#ifdef PER_CPU_INFO
for ( i = 0; i < n; i++ ) {
cpu = netsnmp_cpu_get_byIdx( i, 0 );
/* XXX - per-CPU statistics */
}
#else
/* Copy "overall" figures to cpu0 entry */
_cpu_copy_stats( cpu );
#endif
return 0;
}
void
init_udp(void)
{
netsnmp_handler_registration *reginfo;
int rc;
/*
* register ourselves with the agent as a group of scalars...
*/
DEBUGMSGTL(("mibII/udpScalar", "Initialising UDP scalar group\n"));
reginfo = netsnmp_create_handler_registration("udp", udp_handler,
udp_oid, OID_LENGTH(udp_oid), HANDLER_CAN_RONLY);
rc = netsnmp_register_scalar_group(reginfo, UDPINDATAGRAMS, UDPOUTDATAGRAMS);
if (rc != SNMPERR_SUCCESS)
return;
/*
* .... with a local cache
* (except for HP-UX 11, which extracts objects individually)
*/
#ifndef hpux11
netsnmp_inject_handler( reginfo,
netsnmp_get_cache_handler(UDP_STATS_CACHE_TIMEOUT,
udp_load, udp_free,
udp_oid, OID_LENGTH(udp_oid)));
#endif
REGISTER_SYSOR_ENTRY(udp_module_oid,
"The MIB module for managing UDP implementations");
#if !defined(_USE_PERFSTAT_PROTOCOL)
#ifdef UDPSTAT_SYMBOL
auto_nlist(UDPSTAT_SYMBOL, 0, 0);
#endif
#ifdef UDB_SYMBOL
auto_nlist(UDB_SYMBOL, 0, 0);
#endif
#ifdef solaris2
init_kernel_sunos5();
#endif
#endif
}
void
init_udp(void)
{
/*
* register ourselves with the agent to handle our mib tree
*/
REGISTER_MIB("mibII/udp", udp_variables, variable3, udp_variables_oid);
#ifdef BUILD_SNMP_SYSOR_MIB
REGISTER_SYSOR_ENTRY(udp_module_oid,
"The MIB module for managing UDP implementations");
#endif /* BUILD_SNMP_SYSOR_MIB */
#ifdef UDPSTAT_SYMBOL
auto_nlist(UDPSTAT_SYMBOL, 0, 0);
#endif
#ifdef UDB_SYMBOL
auto_nlist(UDB_SYMBOL, 0, 0);
#endif
#ifdef solaris2
init_kernel_sunos5();
#endif
}
long
getuptime(void)
{
static time_t now, boottime;
time_t uptime;
if (boottime == 0)
auto_nlist(BOOTTIME_SYMBOL, (char *) &boottime, sizeof(boottime));
time(&now);
uptime = now - boottime;
return (uptime);
}
int
udp_load(netsnmp_cache *cache, void *vmagic)
{
long ret_value = -1;
if (auto_nlist(UDPSTAT_SYMBOL, (char *)&udpstat, sizeof(udpstat)))
ret_value = 0;
if ( ret_value < 0 ) {
DEBUGMSGTL(("mibII/udpScalar", "Failed to load UDP scalar Group (udpstat)\n"));
} else {
DEBUGMSGTL(("mibII/udpScalar", "Loaded UDP scalar Group (udpstat)\n"));
}
return ret_value;
}
int
icmp_load(netsnmp_cache *cache, void *vmagic)
{
long ret_value = -1;
if (auto_nlist(ICMPSTAT_SYMBOL, (char *)&icmpstat, sizeof(icmpstat)))
ret_value = 0;
if ( ret_value < 0 ) {
DEBUGMSGTL(("mibII/icmp", "Failed to load ICMP Group (icmpstat)\n"));
} else {
DEBUGMSGTL(("mibII/icmp", "Loaded ICMP Group (icmpstat)\n"));
}
return ret_value;
}
int
tcpTable_load(netsnmp_cache *cache, void *vmagic)
{
struct inpcbtable table;
struct inpcb *entry;
struct tcpcb tcpcb;
netsnmp_inpcb *nnew;
int StateMap[] = { 1, 2, 3, 4, 5, 8, 6, 10, 9, 7, 11 };
tcpTable_free(NULL, NULL);
if (!auto_nlist(TCP_SYMBOL, (char *) &table, sizeof(table))) {
DEBUGMSGTL(("mibII/tcpTable", "Failed to read inpcbtable\n"));
return -1;
}
/*
* Set up a linked list
*/
entry = table.inpt_queue.cqh_first;
while (entry) {
nnew = SNMP_MALLOC_TYPEDEF(netsnmp_inpcb);
if (!nnew)
break;
klookup((unsigned long) entry, (char *)&(nnew->pcb), sizeof(struct inpcb));
klookup((int) nnew->pcb.inp_ppcb, (char *)&tcpcb, sizeof(struct tcpcb));
nnew->state = StateMap[tcpcb.t_state];
if (nnew->state == 5 /* established */ ||
nnew->state == 8 /* closeWait */ )
tcp_estab++;
entry = nnew->inp_queue.cqe_next; /* Next kernel entry */
nnew->inp_next = tcp_head;
tcp_head = nnew;
if (entry == table.inpt_queue.cqh_first)
break;
}
if (tcp_head) {
DEBUGMSGTL(("mibII/tcpTable", "Loaded TCP Table\n"));
return 0;
}
DEBUGMSGTL(("mibII/tcpTable", "Failed to load TCP Table (pcb_table)\n"));
return -1;
}
int
udpTable_load(netsnmp_cache *cache, void *vmagic)
{
struct inpcbtable table;
struct inpcb *nnew, *entry;
udpTable_free(NULL, NULL);
if (!auto_nlist(UDB_SYMBOL, (char *) &table, sizeof(table))) {
DEBUGMSGTL(("mibII/udpTable", "Failed to read inpcbtable\n"));
return -1;
}
/*
* Set up a linked list
*/
entry = table.inpt_queue.cqh_first;
while (entry) {
nnew = SNMP_MALLOC_TYPEDEF(struct inpcb);
if (!nnew)
break;
if (!NETSNMP_KLOOKUP(entry, (char *) nnew, sizeof(struct inpcb))) {
DEBUGMSGTL(("mibII/udpTable:udpTable_load", "klookup failed\n"));
break;
}
entry = nnew->inp_queue.cqe_next; /* Next kernel entry */
nnew->inp_queue.cqe_next = udp_head;
udp_head = nnew;
if (entry == table.inpt_queue.cqh_first)
break;
}
if (udp_head) {
DEBUGMSGTL(("mibII/udpTable", "Loaded UDP Table\n"));
return 0;
}
DEBUGMSGTL(("mibII/udpTable", "Failed to load UDP Table (pcb_table)\n"));
return -1;
}
int
udpTable_load(netsnmp_cache *cache, void *vmagic)
{
struct inpcb udp_inpcb;
struct inpcb *nnew, *entry;
udpTable_free(NULL, NULL);
if (!auto_nlist(UDB_SYMBOL, (char *) &udp_inpcb, sizeof(udp_inpcb))) {
DEBUGMSGTL(("mibII/udpTable", "Failed to read udb_symbol\n"));
return -1;
}
/*
* Set up a linked list
*/
entry = udp_inpcb.INP_NEXT_SYMBOL;
while (entry) {
nnew = SNMP_MALLOC_TYPEDEF(struct inpcb);
if (!nnew)
break;
if (!NETSNMP_KLOOKUP(entry, (char *) nnew, sizeof(struct inpcb))) {
DEBUGMSGTL(("mibII/udpTable:udpTable_load", "klookup failed\n"));
break;
}
entry = nnew->INP_NEXT_SYMBOL; /* Next kernel entry */
nnew->INP_NEXT_SYMBOL = udp_head;
udp_head = nnew;
if (entry == udp_inpcb.INP_NEXT_SYMBOL)
break;
}
if (udp_head) {
DEBUGMSGTL(("mibII/udpTable", "Loaded UDP Table\n"));
return 0;
}
DEBUGMSGTL(("mibII/udpTable", "Failed to load UDP Table (udb_symbol)\n"));
return -1;
}
void
init_icmp(void)
{
netsnmp_handler_registration *reginfo;
/*
* 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 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
#ifdef ICMPSTAT_SYMBOL
auto_nlist(ICMPSTAT_SYMBOL, 0, 0);
#endif
#ifdef solaris2
init_kernel_sunos5();
#endif
}
static void
ARP_Scan_Init(void)
{
#ifndef NETSNMP_CAN_USE_SYSCTL
#ifndef linux
#ifdef hpux11
int fd;
struct nmparms p;
int val;
unsigned int ulen;
int ret;
if (at)
free(at);
at = (mib_ipNetToMediaEnt *) 0;
arptab_size = 0;
if ((fd = open_mib("/dev/ip", O_RDONLY, 0, NM_ASYNC_OFF)) >= 0) {
p.objid = ID_ipNetToMediaTableNum;
p.buffer = (void *) &val;
ulen = sizeof(int);
p.len = &ulen;
if ((ret = get_mib_info(fd, &p)) == 0)
arptab_size = val;
if (arptab_size > 0) {
ulen = (unsigned) arptab_size *sizeof(mib_ipNetToMediaEnt);
at = (mib_ipNetToMediaEnt *) malloc(ulen);
p.objid = ID_ipNetToMediaTable;
p.buffer = (void *) at;
p.len = &ulen;
if ((ret = get_mib_info(fd, &p)) < 0)
arptab_size = 0;
}
close_mib(fd);
}
arptab_current = 0;
#else /* hpux11 */
if (!at) {
#ifdef ARPTAB_SIZE_SYMBOL
auto_nlist(ARPTAB_SIZE_SYMBOL, (char *) &arptab_size,
sizeof arptab_size);
#ifdef STRUCT_ARPHD_HAS_AT_NEXT
at = (struct arphd *) malloc(arptab_size * sizeof(struct arphd));
#else
at = (struct arptab *) malloc(arptab_size * sizeof(struct arptab));
#endif
#else
return;
#endif
}
#ifdef STRUCT_ARPHD_HAS_AT_NEXT
auto_nlist(ARPTAB_SYMBOL, (char *) at,
arptab_size * sizeof(struct arphd));
at_ptr = at[0].at_next;
#else
auto_nlist(ARPTAB_SYMBOL, (char *) at,
arptab_size * sizeof(struct arptab));
#endif
arptab_current = 0;
#endif /* hpux11 */
#else /* linux */
static time_t tm = 0; /* Time of last scan */
FILE *in;
int i, j;
char line[128];
int za, zb, zc, zd;
char ifname[21];
char mac[3*MAX_MAC_ADDR_LEN+1];
char *tok;
arptab_current = 0; /* Anytime this is called we need to reset 'current' */
if (time(NULL) < tm + 1) { /*Our cool one second cache implementation :-) */
return;
}
in = fopen("/proc/net/arp", "r");
if (!in) {
snmp_log(LOG_ERR, "snmpd: Cannot open /proc/net/arp\n");
arptab_size = 0;
return;
}
/*
* Get rid of the header line
*/
fgets(line, sizeof(line), in);
i = 0;
while (fgets(line, sizeof(line), in)) {
u_long tmp_a;
int tmp_flags;
if (i >= arptab_curr_max_size) {
struct arptab *newtab = (struct arptab *)
realloc(at, (sizeof(struct arptab) *
(arptab_curr_max_size + ARP_CACHE_INCR)));
if (newtab == at) {
snmp_log(LOG_ERR,
"Error allocating more space for arpcache. "
"Cache will continue to be limited to %d entries",
arptab_curr_max_size);
break;
} else {
arptab_curr_max_size += ARP_CACHE_INCR;
at = newtab;
}
}
if (7 !=
sscanf(line,
"%d.%d.%d.%d 0x%*x 0x%x %s %*[^ ] %20s\n",
&za, &zb, &zc, &zd, &tmp_flags, mac, ifname)) {
snmp_log(LOG_ERR, "Bad line in /proc/net/arp: %s", line);
continue;
}
/*
* Invalidated entries have their flag set to 0.
* * We want to ignore them
*/
if (tmp_flags == 0) {
continue;
}
ifname[sizeof(ifname)-1] = 0; /* make sure name is null terminated */
at[i].at_flags = tmp_flags;
tmp_a = ((u_long) za << 24) |
((u_long) zb << 16) | ((u_long) zc << 8) | ((u_long) zd);
at[i].at_iaddr.s_addr = htonl(tmp_a);
at[i].if_index = netsnmp_access_interface_index_find(ifname);
for (j=0,tok=strtok(mac, ":"); tok != NULL; tok=strtok(NULL, ":"),j++) {
at[i].at_enaddr[j] = strtol(tok, NULL, 16);
}
at[i].at_enaddr_len = j;
i++;
}
arptab_size = i;
fclose(in);
time(&tm);
#endif /* linux */
#else /* NETSNMP_CAN_USE_SYSCTL */
int mib[6];
size_t needed;
mib[0] = CTL_NET;
mib[1] = PF_ROUTE;
mib[2] = 0;
mib[3] = AF_INET;
mib[4] = NET_RT_FLAGS;
mib[5] = RTF_LLINFO;
if (at)
free(at);
rtnext = lim = at = 0;
if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
snmp_log_perror("route-sysctl-estimate");
else {
if ((at = malloc(needed ? needed : 1)) == NULL)
snmp_log_perror("malloc");
else {
if (sysctl(mib, 6, at, &needed, NULL, 0) < 0)
snmp_log_perror("actual retrieval of routing table");
else {
lim = at + needed;
rtnext = at;
}
}
}
#endif /* NETSNMP_CAN_USE_SYSCTL */
}
u_char *
var_hrstore(struct variable *vp,
oid * name,
size_t * length,
int exact, size_t * var_len, WriteMethod ** write_method)
{
int store_idx = 0;
#if !defined(linux)
#if defined(solaris2)
int freemem;
int swap_total, swap_used;
#elif defined(hpux10) || defined(hpux11)
struct pst_dynamic pst_buf;
#elif defined(darwin8)
vm_statistics_data_t vm_stat;
int count = HOST_VM_INFO_COUNT;
#elif defined(TOTAL_MEMORY_SYMBOL) || defined(USE_SYSCTL_VM)
#ifdef VM_UVMEXP
struct uvmexp uvmexp_totals;
#endif
struct vmtotal memory_totals;
#endif
#if HAVE_KVM_GETSWAPINFO
struct kvm_swap swapinfo;
static kvm_t *kd = NULL;
#endif
#if HAVE_SYS_POOL_H
struct pool mbpool, mclpool;
int i;
#endif
#ifdef MBSTAT_SYMBOL
struct mbstat mbstat;
#endif
#endif /* !linux */
static char string[1024];
struct HRFS_statfs stat_buf;
if (vp->magic == HRSTORE_MEMSIZE) {
if (header_hrstore(vp, name, length, exact, var_len, write_method)
== MATCH_FAILED)
return NULL;
} else {
really_try_next:
store_idx = header_hrstoreEntry(vp, name, length, exact, var_len,
write_method);
if (store_idx == MATCH_FAILED)
return NULL;
if (store_idx > HRS_TYPE_FIXED_MAX) {
if (HRFS_statfs(HRFS_entry->HRFS_mount, &stat_buf) < 0) {
snmp_log_perror(HRFS_entry->HRFS_mount);
goto try_next;
}
}
#if !defined(linux) && !defined(solaris2)
else
switch (store_idx) {
case HRS_TYPE_MEM:
case HRS_TYPE_SWAP:
#ifdef USE_SYSCTL_VM
{
int mib[2];
size_t len = sizeof(memory_totals);
mib[0] = CTL_VM;
mib[1] = VM_METER;
sysctl(mib, 2, &memory_totals, &len, NULL, 0);
#ifdef VM_UVMEXP
mib[1] = VM_UVMEXP;
len = sizeof(uvmexp_totals);
sysctl(mib, 2, &uvmexp_totals, &len, NULL, 0);
#endif
}
#elif defined(darwin8)
host_statistics(myHost,HOST_VM_INFO,&vm_stat,&count);
#elif defined(hpux10) || defined(hpux11)
pstat_getdynamic(&pst_buf, sizeof(struct pst_dynamic), 1, 0);
#elif defined(TOTAL_MEMORY_SYMBOL)
auto_nlist(TOTAL_MEMORY_SYMBOL, (char *) &memory_totals,
sizeof(struct vmtotal));
#endif
#if HAVE_KVM_GETSWAPINFO
if (kd == NULL)
kd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, NULL);
if (!kd) {
snmp_log_perror("kvm_openfiles");
goto try_next;
}
if (kvm_getswapinfo(kd, &swapinfo, 1, 0) < 0) {
snmp_log_perror("kvm_getswapinfo");
goto try_next;
}
#endif
break;
#if !defined(hpux10) && !defined(hpux11)
case HRS_TYPE_MBUF:
#if HAVE_SYS_POOL_H
auto_nlist(MBPOOL_SYMBOL, (char *) &mbpool,
sizeof(mbpool));
auto_nlist(MCLPOOL_SYMBOL, (char *) &mclpool,
sizeof(mclpool));
#endif
#ifdef MBSTAT_SYMBOL
auto_nlist(MBSTAT_SYMBOL, (char *) &mbstat,
sizeof(mbstat));
#endif
break;
#endif /* !hpux10 && !hpux11 */
default:
break;
}
#endif /* !linux && !solaris2 */
}
switch (vp->magic) {
case HRSTORE_MEMSIZE:
long_return = physmem * (pagesize / 1024);
return (u_char *) & long_return;
case HRSTORE_INDEX:
long_return = store_idx;
return (u_char *) & long_return;
case HRSTORE_TYPE:
if (store_idx > HRS_TYPE_FIXED_MAX)
if (storageUseNFS && Check_HR_FileSys_NFS())
storage_type_id[storage_type_len - 1] = 10; /* Network Disk */
else
storage_type_id[storage_type_len - 1] = 4; /* Assume fixed */
else
switch (store_idx) {
case HRS_TYPE_MEM:
storage_type_id[storage_type_len - 1] = 2; /* RAM */
break;
case HRS_TYPE_SWAP:
storage_type_id[storage_type_len - 1] = 3; /* Virtual Mem */
break;
case HRS_TYPE_MBUF:
storage_type_id[storage_type_len - 1] = 1; /* Other */
break;
default:
storage_type_id[storage_type_len - 1] = 1; /* Other */
break;
}
*var_len = sizeof(storage_type_id);
return (u_char *) storage_type_id;
case HRSTORE_DESCR:
if (store_idx > HRS_TYPE_FIXED_MAX) {
strncpy(string, HRFS_entry->HRFS_mount, sizeof(string)-1);
string[ sizeof(string)-1 ] = 0;
*var_len = strlen(string);
return (u_char *) string;
} else {
/* store_idx = store_idx - 1; */
*var_len = strlen(hrs_descr[store_idx]);
return (u_char *) hrs_descr[store_idx];
}
case HRSTORE_UNITS:
if (store_idx > HRS_TYPE_FIXED_MAX)
#if HRFS_HAS_FRSIZE
long_return = stat_buf.f_frsize;
#else
long_return = stat_buf.f_bsize;
#endif
else
switch (store_idx) {
case HRS_TYPE_MEM:
case HRS_TYPE_SWAP:
#if defined(USE_SYSCTL) || defined(solaris2)
long_return = pagesize;
#elif defined(NBPG)
long_return = NBPG;
#else
long_return = 1024; /* Report in Kb */
#endif
break;
case HRS_TYPE_MBUF:
#ifdef MSIZE
long_return = MSIZE;
#elif defined(linux)
long_return = 1024;
#else
long_return = 256;
#endif
break;
default:
#if NO_DUMMY_VALUES
goto try_next;
#endif
long_return = 1024; /* As likely as any! */
break;
}
return (u_char *) & long_return;
case HRSTORE_SIZE:
if (store_idx > HRS_TYPE_FIXED_MAX)
long_return = stat_buf.f_blocks;
else
switch (store_idx) {
#if defined(linux)
case HRS_TYPE_MEM:
case HRS_TYPE_SWAP:
long_return = linux_mem(store_idx, HRSTORE_SIZE);
break;
#elif defined(solaris2)
case HRS_TYPE_MEM:
long_return = physmem;
break;
case HRS_TYPE_SWAP:
sol_get_swapinfo(&swap_total, &swap_used);
long_return = swap_total;
break;
#elif defined(hpux10) || defined(hpux11)
case HRS_TYPE_MEM:
long_return = pst_buf.psd_rm;
break;
case HRS_TYPE_SWAP:
long_return = pst_buf.psd_vm;
break;
#elif defined(darwin8)
case HRS_TYPE_MEM:
long_return = physmem;
break;
case HRS_TYPE_SWAP:
long_return = -1;
break;
#if defined(MBSTAT_SYMBOL)
case HRS_TYPE_MBUF:
long_return = mbstat.m_mbufs;
break;
#endif
#elif defined(TOTAL_MEMORY_SYMBOL) || defined(USE_SYSCTL_VM)
case HRS_TYPE_MEM:
long_return = memory_totals.t_rm;
break;
case HRS_TYPE_SWAP:
#if HAVE_KVM_GETSWAPINFO
long_return = swapinfo.ksw_total;
#elif defined(VM_UVMEXP)
long_return = uvmexp_totals.swpages;
#else
long_return = memory_totals.t_vm;
#endif
break;
#else /* !linux && !solaris2 && !hpux10 && !hpux11 && ... */
case HRS_TYPE_MEM:
long_return = physmem;
break;
case HRS_TYPE_SWAP:
#if NO_DUMMY_VALUES
goto try_next;
#endif
long_return = 0;
break;
#endif /* !linux && !solaris2 && !hpux10 && !hpux11 && ... */
case HRS_TYPE_MBUF:
#ifdef linux
long_return = linux_mem(store_idx, HRSTORE_SIZE);
#elif HAVE_SYS_POOL_H
long_return = 0;
for (i = 0;
i <
sizeof(mbstat.m_mtypes) / sizeof(mbstat.m_mtypes[0]);
i++)
long_return += mbstat.m_mtypes[i];
#elif defined(MBSTAT_SYMBOL) && defined(STRUCT_MBSTAT_HAS_M_MBUFS)
long_return = mbstat.m_mbufs;
#elif defined(NO_DUMMY_VALUES)
goto try_next;
#else
long_return = 0;
#endif
break;
default:
#if NO_DUMMY_VALUES
goto try_next;
#endif
long_return = 1024;
break;
}
return (u_char *) & long_return;
case HRSTORE_USED:
if (store_idx > HRS_TYPE_FIXED_MAX)
long_return = (stat_buf.f_blocks - stat_buf.f_bfree);
else
switch (store_idx) {
#if defined(linux)
case HRS_TYPE_MBUF:
case HRS_TYPE_MEM:
case HRS_TYPE_SWAP:
long_return = linux_mem(store_idx, HRSTORE_USED);
break;
#elif defined(solaris2)
case HRS_TYPE_MEM:
getKstatInt("unix", "system_pages", "freemem", &freemem);
long_return = physmem - freemem;
break;
case HRS_TYPE_SWAP:
sol_get_swapinfo(&swap_total, &swap_used);
long_return = swap_used;
break;
#elif defined(hpux10) || defined(hpux11)
case HRS_TYPE_MEM:
long_return = pst_buf.psd_arm;
break;
case HRS_TYPE_SWAP:
long_return = pst_buf.psd_avm;
break;
#elif defined(darwin8)
case HRS_TYPE_MEM:
long_return = vm_stat.active_count + vm_stat.inactive_count + vm_stat.wire_count;
break;
case HRS_TYPE_SWAP:
long_return = -1;
break;
#if defined(MBSTAT_SYMBOL)
case HRS_TYPE_MBUF:
long_return = mbstat.m_mbufs;
break;
#endif
#elif defined(TOTAL_MEMORY_SYMBOL) || defined(USE_SYSCTL_VM)
case HRS_TYPE_MEM:
long_return = memory_totals.t_arm;
break;
case HRS_TYPE_SWAP:
#if HAVE_KVM_GETSWAPINFO
long_return = swapinfo.ksw_used;
#elif defined(VM_UVMEXP)
long_return = uvmexp_totals.swpginuse;
#else
long_return = memory_totals.t_avm;
#endif
break;
#endif /* linux || solaris2 || hpux10 || hpux11 || ... */
#if !defined(linux) && !defined(solaris2) && !defined(hpux10) && !defined(hpux11)
case HRS_TYPE_MBUF:
#if HAVE_SYS_POOL_H
long_return =
(mbpool.pr_nget - mbpool.pr_nput) * mbpool.pr_size +
(mclpool.pr_nget - mclpool.pr_nput) * mclpool.pr_size;
#ifdef MSIZE
long_return /= MSIZE;
#else
long_return /= 256;
#endif
#elif defined(MBSTAT_SYMBOL) && defined(STRUCT_MBSTAT_HAS_M_CLUSTERS)
long_return = mbstat.m_clusters - mbstat.m_clfree; /* unlikely, but... */
#elif defined(NO_DUMMY_VALUES)
goto try_next;
#else
long_return = 0;
#endif
break;
#endif /* !linux && !solaris2 && !hpux10 && !hpux11 && ... */
default:
#if NO_DUMMY_VALUES
goto try_next;
#endif
long_return = 1024;
break;
}
return (u_char *) & long_return;
case HRSTORE_FAILS:
if (store_idx > HRS_TYPE_FIXED_MAX)
#if NO_DUMMY_VALUES
goto try_next;
#else
long_return = 0;
#endif
else
switch (store_idx) {
u_char *
var_hrsys(struct variable * vp,
oid * name,
size_t * length,
int exact, size_t * var_len, WriteMethod ** write_method)
{
static char string[1024];
#if defined(solaris2)
/* max size of nvram property */
char bootparam[8192];
#endif
time_t now;
#ifndef NR_TASKS
int nproc = 0;
#endif
#ifdef linux
FILE *fp;
#endif
#if CAN_USE_SYSCTL && defined(CTL_KERN) && defined(KERN_MAXPROC)
static int maxproc_mib[] = { CTL_KERN, KERN_MAXPROC };
int buf_size;
#endif
#if defined(hpux10) || defined(hpux11)
struct pst_static pst_buf;
#endif
if (header_hrsys(vp, name, length, exact, var_len, write_method) ==
MATCH_FAILED)
return NULL;
switch (vp->magic) {
case HRSYS_UPTIME:
long_return = get_uptime();
return (u_char *) & long_return;
case HRSYS_DATE:
#if defined(HAVE_MKTIME) && defined(HAVE_STIME)
*write_method=ns_set_time;
#endif
(void *) time(&now);
return (u_char *) date_n_time(&now, var_len);
case HRSYS_LOAD_DEV:
long_return = get_load_dev();
return (u_char *) & long_return;
case HRSYS_LOAD_PARAM:
#ifdef linux
if((fp = fopen("/proc/cmdline", "r")) != NULL) {
fgets(string, sizeof(string), fp);
fclose(fp);
} else {
return NULL;
}
#elif defined(solaris2)
*write_method=set_solaris_bootcommand_parameter;
if ( get_solaris_eeprom_parameter("boot-command",bootparam) ) {
snmp_log(LOG_ERR,"unable to lookup boot-command from eeprom\n");
return NULL;
}
strlcpy(string,bootparam,sizeof(string));
#else
#if NO_DUMMY_VALUES
return NULL;
#endif
sprintf(string, "ask Dave"); /* XXX */
#endif
*var_len = strlen(string);
return (u_char *) string;
case HRSYS_USERS:
long_return = count_users();
return (u_char *) & long_return;
case HRSYS_PROCS:
#if USING_HOST_HR_SWRUN_MODULE
long_return = count_processes();
#else
#if NO_DUMMY_VALUES
return NULL;
#endif
long_return = 0;
#endif
return (u_char *) & long_return;
case HRSYS_MAXPROCS:
#if defined(NR_TASKS)
long_return = NR_TASKS; /* <linux/tasks.h> */
#elif CAN_USE_SYSCTL && defined(CTL_KERN) && defined(KERN_MAXPROC)
buf_size = sizeof(nproc);
if (sysctl(maxproc_mib, 2, &nproc, &buf_size, NULL, 0) < 0)
return NULL;
long_return = nproc;
#elif defined(hpux10) || defined(hpux11)
pstat_getstatic(&pst_buf, sizeof(struct pst_static), 1, 0);
long_return = pst_buf.max_proc;
#elif defined(solaris2)
long_return=get_max_solaris_processes();
if(long_return == -1) return NULL;
#elif defined(NPROC_SYMBOL)
auto_nlist(NPROC_SYMBOL, (char *) &nproc, sizeof(int));
long_return = nproc;
#else
#if NO_DUMMY_VALUES
return NULL;
#endif
long_return = 0;
#endif
return (u_char *) & long_return;
default:
DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrsys\n",
vp->magic));
}
return NULL;
} /* end var_hrsys */
/*
* Load the latest memory usage statistics
*/
int netsnmp_mem_arch_load( netsnmp_cache *cache, void *magic ) {
netsnmp_memory_info *mem;
long pagesize;
int nswap;
struct vmmeter vmem;
struct vmtotal total;
size_t total_size = sizeof(total);
int total_mib[] = { CTL_VM, VM_METER };
u_long phys_mem;
u_long user_mem;
unsigned int bufspace;
unsigned int maxbufspace;
size_t mem_size = sizeof(phys_mem);
size_t buf_size = sizeof(bufspace);
int phys_mem_mib[] = { CTL_HW, HW_PHYSMEM };
int user_mem_mib[] = { CTL_HW, HW_USERMEM };
/*
* Retrieve the memory information from the underlying O/S...
*/
sysctl(total_mib, 2, &total, &total_size, NULL, 0);
sysctl(phys_mem_mib, 2, &phys_mem, &mem_size, NULL, 0);
sysctl(user_mem_mib, 2, &user_mem, &mem_size, NULL, 0);
sysctlbyname("vfs.bufspace", &bufspace, &buf_size, NULL, 0);
sysctlbyname("vfs.maxbufspace", &maxbufspace, &buf_size, NULL, 0);
auto_nlist(SUM_SYMBOL, (char *) &vmem, sizeof(vmem));
#ifndef freebsd4
pagesize = 1024;
#else
pagesize = getpagesize();
#endif
/*
* ... and save this in a standard form.
*/
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_PHYSMEM, 1 );
if (!mem) {
snmp_log_perror("No Physical Memory info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Physical memory");
mem->units = pagesize;
mem->size = user_mem/pagesize;
mem->free = total.t_free;
}
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_USERMEM, 1 );
if (!mem) {
snmp_log_perror("No (user) Memory info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Real memory");
mem->units = pagesize;
mem->size = total.t_rm;
mem->free = total.t_arm;
}
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_VIRTMEM, 1 );
if (!mem) {
snmp_log_perror("No Virtual Memory info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Virtual memory");
mem->units = pagesize;
mem->size = total.t_vm;
mem->free = total.t_avm;
}
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SHARED, 1 );
if (!mem) {
snmp_log_perror("No Shared Memory info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Shared virtual memory");
mem->units = pagesize;
mem->size = total.t_vmshr;
mem->free = total.t_avmshr;
}
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SHARED2, 1 );
if (!mem) {
snmp_log_perror("No Shared2 Memory info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Shared real memory");
mem->units = pagesize;
mem->size = total.t_rmshr;
mem->free = total.t_armshr;
}
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_CACHED, 1 );
if (!mem) {
snmp_log_perror("No Cached Memory info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Cached memory");
mem->units = vmem.v_page_size;
mem->size = vmem.v_cache_max;
mem->free = vmem.v_cache_max - vmem.v_cache_count;
}
nswap = swapmode(pagesize);
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SWAP, 1 );
if (!mem) {
snmp_log_perror("No Swap info entry");
} else {
if (!mem->descr)
mem->descr = strdup( (nswap>1) ? "Swap space (total)"
: "Swap space");
mem->units = pagesize;
mem->size = swapTotal;
mem->free = swapFree;
}
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_MBUF, 1 );
if (!mem) {
snmp_log_perror("No Buffer, etc info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Memory buffers");
mem->units = 1024;
mem->size = maxbufspace / 1024;
mem->free = (maxbufspace - bufspace)/1024;
}
return 0;
}
long
read_udp_stat(UDP_STAT_STRUCTURE * udpstat, int magic)
{
long ret_value = -1;
#if (defined(CAN_USE_SYSCTL) && defined(UDPCTL_STATS))
static int sname[4] =
{ CTL_NET, PF_INET, IPPROTO_UDP, UDPCTL_STATS };
size_t len = sizeof(*udpstat);
#endif
#ifdef solaris2
static mib2_ip_t ipstat;
#endif
#ifdef hpux11
int fd;
struct nmparms p;
unsigned int ulen;
if ((fd = open_mib("/dev/ip", O_RDONLY, 0, NM_ASYNC_OFF)) < 0)
return (-1); /* error */
switch (magic) {
case UDPINDATAGRAMS:
p.objid = ID_udpInDatagrams;
break;
case UDPNOPORTS:
p.objid = ID_udpNoPorts;
break;
case UDPOUTDATAGRAMS:
p.objid = ID_udpOutDatagrams;
break;
case UDPINERRORS:
p.objid = ID_udpInErrors;
break;
default:
*udpstat = 0;
close_mib(fd);
return (0);
}
p.buffer = (void *) udpstat;
ulen = sizeof(UDP_STAT_STRUCTURE);
p.len = &ulen;
ret_value = get_mib_info(fd, &p);
close_mib(fd);
return (ret_value); /* 0: ok, < 0: error */
#else /* hpux11 */
if (udp_stats_cache_marker &&
(!atime_ready
(udp_stats_cache_marker, UDP_STATS_CACHE_TIMEOUT * 1000)))
#ifdef solaris2
return (magic == UDPNOPORTS ? ipstat.udpNoPorts : 0);
#else
return 0;
#endif
if (udp_stats_cache_marker)
atime_setMarker(udp_stats_cache_marker);
else
udp_stats_cache_marker = atime_newMarker();
#ifdef linux
ret_value = linux_read_udp_stat(udpstat);
#endif
#ifdef WIN32
ret_value = GetUdpStatistics(udpstat);
#endif
#ifdef solaris2
if (magic == UDPNOPORTS) {
if (getMibstat
(MIB_IP, &ipstat, sizeof(mib2_ip_t), GET_FIRST,
&Get_everything, NULL) < 0)
ret_value = -1;
else
ret_value = ipstat.udpNoPorts;
} else
ret_value = getMibstat(MIB_UDP, udpstat, sizeof(mib2_udp_t),
GET_FIRST, &Get_everything, NULL);
#endif
#ifdef HAVE_SYS_TCPIPSTATS_H
ret_value = sysmp(MP_SAGET, MPSA_TCPIPSTATS, udpstat, sizeof *udpstat);
#endif
#if defined(CAN_USE_SYSCTL) && defined(UDPCTL_STATS)
ret_value = sysctl(sname, 4, udpstat, &len, 0, 0);
#endif
#ifdef UDPSTAT_SYMBOL
if (auto_nlist(UDPSTAT_SYMBOL, (char *) udpstat, sizeof(*udpstat)))
ret_value = 0;
#endif
if (ret_value == -1) {
free(udp_stats_cache_marker);
udp_stats_cache_marker = NULL;
}
return ret_value;
#endif /* hpux11 */
}
/* ---------------------------------------------------------------------
*/
int
netsnmp_arch_swrun_container_load( netsnmp_container *container, u_int flags)
{
struct proc *proc_table;
int proc_type_base;
int nproc, i, rc;
netsnmp_swrun_entry *entry;
auto_nlist( NPROC_SYMBOL, (char *)&nproc, sizeof(int));
proc_table = (struct proc *) malloc(nproc*(sizeof(struct proc)));
auto_nlist( PROC_SYMBOL, (char *)&proc_table_base, sizeof(int));
NETSNMP_KLOOKUP(proc_table_base, (char *)proc_table,
nproc*(sizeof(struct proc)));
for ( i=0 ; i<nproc; i++ ) {
if (0 == proc_table[i].p_stat)
continue; /* Skip unused entries */
entry = netsnmp_swrun_entry_create(proc_table[i].p_pid);
if (NULL == entry)
continue; /* error already logged by function */
rc = CONTAINER_INSERT(container, entry);
/*
* XXX - What information does 'struct proc' contain?
*/
/*
Apparently no process name/argument information
entry->hrSWRunName_len = snprintf(entry->hrSWRunName,
sizeof(entry->hrSWRunName)-1,
"%s", proc_table[i].???);
entry->hrSWRunPath_len = snprintf(entry->hrSWRunPath,
sizeof(entry->hrSWRunPath)-1,
"%s", proc_table[i].???);
entry->hrSWRunParameters_len = snprintf(entry->hrSWRunParameters,
sizeof(entry->hrSWRunParameters)-1,
"%s", ???);
*/
switch (proc_table[i].p_stat) {
/* XXX - which names to use ?? */
case SACTIVE:
case SRUN:
case SONPROC: entry->hrSWRunStatus = HRSWRUNSTATUS_RUNNING;
break;
case SSWAP:
case SSLEEP:
case SWAIT: entry->hrSWRunStatus = HRSWRUNSTATUS_RUNNABLE;
break;
case SSTOP: entry->hrSWRunStatus = HRSWRUNSTATUS_NOTRUNNABLE;
break;
case SIDL:
case SZOMB:
default: entry->hrSWRunStatus = HRSWRUNSTATUS_INVALID;
break;
}
entry->hrSWRunPerfCPU = (proc_table[i].p_utime.tv_sec * 100);
entry->hrSWRunPerfCPU += (proc_table[i].p_utime.tv_usec / 10000);
entry->hrSWRunPerfCPU += (proc_table[i].p_stime.tv_sec * 100);
entry->hrSWRunPerfCPU += (proc_table[i].p_stime.tv_usec / 10000);
/*
or entry->hrSWRunPerfCPU = proc_table[i].p_time;
*/
}
free(proc_table);
DEBUGMSGTL(("swrun:load:arch"," loaded %d entries\n",
CONTAINER_SIZE(container)));
return 0;
}
unsigned char *
var_extensible_vmstat(struct variable *vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
int loop;
time_t time_new = getuptime();
static time_t time_old;
static time_t time_diff;
#if defined(KERN_CP_TIME)
static uint64_t cpu_old[CPUSTATES];
static uint64_t cpu_new[CPUSTATES];
static uint64_t cpu_diff[CPUSTATES];
static uint64_t cpu_total;
#elif defined(KERN_CPTIME)
static long cpu_old[CPUSTATES];
static long cpu_new[CPUSTATES];
static long cpu_diff[CPUSTATES];
static long cpu_total;
#else
static long cpu_old[CPUSTATES];
static long cpu_new[CPUSTATES];
static long cpu_diff[CPUSTATES];
static long cpu_total;
#endif
long cpu_sum;
double cpu_prc;
static struct uvmexp mem_old, mem_new;
int mem_mib[] = { CTL_VM, VM_UVMEXP };
int mem_size = sizeof(struct uvmexp);
static long long_ret;
static char errmsg[300];
long_ret = 0; /* set to 0 as default */
if (header_generic(vp, name, length, exact, var_len, write_method))
return (NULL);
/*
* Update structures (only if time has passed)
*/
if (time_new != time_old) {
#ifdef KERN_CP_TIME
int mib[2] = { CTL_KERN, KERN_CP_TIME };
int ssize = sizeof(cpu_new);
if (sysctl(mib, 2, cpu_new, &ssize, NULL, 0) < 0)
memset(cpu_new, 0, sizeof(cpu_new));
#elif defined(KERN_CPTIME)
int mib[2] = { CTL_KERN, KERN_CPTIME };
int ssize = sizeof(cpu_new);
if (sysctl(mib, 2, cpu_new, &ssize, NULL, 0) < 0)
memset(cpu_new, 0, sizeof(cpu_new));
#else
/*
* CPU usage
*/
auto_nlist(CPTIME_SYMBOL, (char *) cpu_new, sizeof(cpu_new));
#endif
time_diff = time_new - time_old;
time_old = time_new;
cpu_total = 0;
for (loop = 0; loop < CPUSTATES; loop++) {
cpu_diff[loop] = cpu_new[loop] - cpu_old[loop];
cpu_old[loop] = cpu_new[loop];
cpu_total += cpu_diff[loop];
}
if (cpu_total == 0)
cpu_total = 1;
/*
* Memory info
*/
mem_old = mem_new;
sysctl(mem_mib, 2, &mem_new, &mem_size, NULL, 0);
}
/*
* Rate macro
*/
#define rate(x) (((x)+ time_diff/2) / time_diff)
/*
* Page-to-kb macro
*/
#define ptok(p) ((p) * (mem_new.pagesize >> 10))
switch (vp->magic) {
case MIBINDEX:
long_ret = 1;
return ((u_char *) (&long_ret));
case ERRORNAME: /* dummy name */
sprintf(errmsg, "systemStats");
*var_len = strlen(errmsg);
return ((u_char *) (errmsg));
case SWAPIN:
long_ret = ptok(mem_new.swapins - mem_old.swapins);
long_ret = rate(long_ret);
return ((u_char *) (&long_ret));
case SWAPOUT:
long_ret = ptok(mem_new.swapouts - mem_old.swapouts);
long_ret = rate(long_ret);
return ((u_char *) (&long_ret));
case IOSENT:
#if NETSNMP_NO_DUMMY_VALUES
return NULL;
#endif
long_ret = -1;
return ((u_char *) (&long_ret));
case IORECEIVE:
#if NETSNMP_NO_DUMMY_VALUES
return NULL;
#endif
long_ret = -1;
return ((u_char *) (&long_ret));
case SYSINTERRUPTS:
long_ret = rate(mem_new.intrs - mem_old.intrs);
return ((u_char *) (&long_ret));
case SYSCONTEXT:
long_ret = rate(mem_new.swtch - mem_old.swtch);
return ((u_char *) (&long_ret));
case CPUUSER:
cpu_sum = cpu_diff[CP_USER] + cpu_diff[CP_NICE];
cpu_prc = (float) cpu_sum / (float) cpu_total;
long_ret = cpu_prc * CPU_PRC;
return ((u_char *) (&long_ret));
case CPUSYSTEM:
cpu_sum = cpu_diff[CP_SYS] + cpu_diff[CP_INTR];
cpu_prc = (float) cpu_sum / (float) cpu_total;
long_ret = cpu_prc * CPU_PRC;
return ((u_char *) (&long_ret));
case CPUIDLE:
cpu_sum = cpu_diff[CP_IDLE];
cpu_prc = (float) cpu_sum / (float) cpu_total;
long_ret = cpu_prc * CPU_PRC;
return ((u_char *) (&long_ret));
case CPURAWUSER:
long_ret = cpu_new[CP_USER];
return ((u_char *) (&long_ret));
case CPURAWNICE:
long_ret = cpu_new[CP_NICE];
return ((u_char *) (&long_ret));
case CPURAWSYSTEM:
long_ret = cpu_new[CP_SYS] + cpu_new[CP_INTR];
return ((u_char *) (&long_ret));
case CPURAWIDLE:
long_ret = cpu_new[CP_IDLE];
return ((u_char *) (&long_ret));
case CPURAWKERNEL:
long_ret = cpu_new[CP_SYS];
return ((u_char *) (&long_ret));
case CPURAWINTR:
long_ret = cpu_new[CP_INTR];
return ((u_char *) (&long_ret));
/*
* reserved for future use
*/
/*
* case ERRORFLAG:
* return((u_char *) (&long_ret));
* case ERRORMSG:
* return((u_char *) (&long_ret));
*/
}
return NULL;
}
unsigned char *
var_extensible_vmstat(struct variable *vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
int loop;
time_t time_new = getuptime();
static time_t time_old;
static time_t time_diff;
/* static long cpu_old[CPUSTATES];
static long cpu_new[CPUSTATES];
static long cpu_diff[CPUSTATES]; */
static long cpu_total;
long cpu_sum;
double cpu_prc;
static struct vmmeter mem_old, mem_new;
static long long_ret;
static char errmsg[300];
long_ret = 0; /* set to 0 as default */
if (header_generic(vp, name, length, exact, var_len, write_method))
return (NULL);
/*
* Update structures (only if time has passed)
* we only update every 30 seconds so that we don't
* get strange results, especially with cpu information
*/
if (time_new > time_old + 30) {
time_diff = time_new - time_old;
time_old = time_new;
/*
* CPU usage
*/
/* auto_nlist(CPTIME_SYMBOL, (char *) cpu_new, sizeof(cpu_new)); */
cpu_total = 0;
/* for (loop = 0; loop < CPUSTATES; loop++) {
cpu_diff[loop] = cpu_new[loop] - cpu_old[loop];
cpu_old[loop] = cpu_new[loop];
cpu_total += cpu_diff[loop];
}
*/
if (cpu_total == 0)
cpu_total = 1;
/*
* Memory info
*/
mem_old = mem_new;
auto_nlist(SUM_SYMBOL, (char *) &mem_new, sizeof(mem_new));
}
/*
* Rate macro
*/
#define rate(x) (((x)+ time_diff/2) / time_diff)
/*
* Page-to-kb macro
*/
#define ptok(p) ((p) * (mem_new.v_page_size >> 10))
switch (vp->magic) {
case MIBINDEX:
long_ret = 1;
return ((u_char *) (&long_ret));
case ERRORNAME: /* dummy name */
sprintf(errmsg, "systemStats");
*var_len = strlen(errmsg);
return ((u_char *) (errmsg));
case SWAPIN:
#if defined(openbsd2) || defined(darwin)
long_ret = ptok(mem_new.v_swpin - mem_old.v_swpin);
#else
long_ret = ptok(mem_new.v_swappgsin - mem_old.v_swappgsin +
mem_new.v_vnodepgsin - mem_old.v_vnodepgsin);
#endif
long_ret = rate(long_ret);
return ((u_char *) (&long_ret));
case SWAPOUT:
#if defined(openbsd2) || defined(darwin)
long_ret = ptok(mem_new.v_swpout - mem_old.v_swpout);
#else
long_ret = ptok(mem_new.v_swappgsout - mem_old.v_swappgsout +
mem_new.v_vnodepgsout - mem_old.v_vnodepgsout);
#endif
long_ret = rate(long_ret);
return ((u_char *) (&long_ret));
case IOSENT:
#if NO_DUMMY_VALUES
return NULL;
#endif
long_ret = -1;
return ((u_char *) (&long_ret));
case IORECEIVE:
#if NO_DUMMY_VALUES
return NULL;
#endif
long_ret = -1;
return ((u_char *) (&long_ret));
case SYSINTERRUPTS:
long_ret = rate(mem_new.v_intr - mem_old.v_intr);
return ((u_char *) (&long_ret));
case SYSCONTEXT:
long_ret = rate(mem_new.v_swtch - mem_old.v_swtch);
return ((u_char *) (&long_ret));
case CPUUSER:
/* cpu_sum = cpu_diff[CP_USER] + cpu_diff[CP_NICE];
cpu_prc = (float) cpu_sum / (float) cpu_total;
long_ret = cpu_prc * CPU_PRC; */
return ((u_char *) (&long_ret));
case CPUSYSTEM:
/* cpu_sum = cpu_diff[CP_SYS] + cpu_diff[CP_INTR];
cpu_prc = (float) cpu_sum / (float) cpu_total;
long_ret = cpu_prc * CPU_PRC; */
return ((u_char *) (&long_ret));
case CPUIDLE:
/* cpu_sum = cpu_diff[CP_IDLE];
cpu_prc = (float) cpu_sum / (float) cpu_total;
long_ret = cpu_prc * CPU_PRC; */
return ((u_char *) (&long_ret));
case CPURAWUSER:
/* long_ret = cpu_new[CP_USER]; */
return ((u_char *) (&long_ret));
case CPURAWNICE:
/* long_ret = cpu_new[CP_NICE]; */
return ((u_char *) (&long_ret));
case CPURAWSYSTEM:
/* long_ret = cpu_new[CP_SYS] + cpu_new[CP_INTR]; */
return ((u_char *) (&long_ret));
case CPURAWIDLE:
/* long_ret = cpu_new[CP_IDLE]; */
return ((u_char *) (&long_ret));
case CPURAWKERNEL:
/* long_ret = cpu_new[CP_SYS]; */
return ((u_char *) (&long_ret));
case CPURAWINTR:
/* long_ret = cpu_new[CP_INTR]; */
return ((u_char *) (&long_ret));
case SYSRAWINTERRUPTS:
long_ret = mem_new.v_intr;
return ((u_char *) (&long_ret));
case SYSRAWCONTEXT:
long_ret = mem_new.v_swtch;
return ((u_char *) (&long_ret));
/*
* reserved for future use
*/
/*
* case ERRORFLAG:
* return((u_char *) (&long_ret));
* case ERRORMSG:
* return((u_char *) (&long_ret));
*/
}
return NULL;
}
/*
* try to get load average
* Inputs: pointer to array of doubles, number of elements in array
* Returns: 0=array has values, -1=error occurred.
*/
int
try_getloadavg(double *r_ave, size_t s_ave)
{
#ifndef HAVE_GETLOADAVG
#ifdef HAVE_SYS_FIXPOINT_H
fix favenrun[3];
#endif
#if (defined(ultrix) || defined(sun) || defined(__alpha) || defined(dynix))
int i;
#if (defined(sun) || defined(__alpha) || defined(dynix))
long favenrun[3];
if (s_ave > 3) /* bounds check */
return (-1);
#define FIX_TO_DBL(_IN) (((double) _IN)/((double) FSCALE))
#endif
#endif
#if defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7)
perfstat_cpu_total_t cs;
#endif
#if defined(hpux10) || defined(hpux11)
struct pst_dynamic pst_buf;
#endif
#ifdef irix6
int i, favenrun[3];
sgt_cookie_t cookie;
#endif
#endif /* !HAVE_GETLOADAVG */
#ifdef HAVE_GETLOADAVG
if (getloadavg(r_ave, s_ave) == -1)
return (-1);
#elif defined(linux)
{
FILE *in = fopen("/proc/loadavg", "r");
if (!in) {
NETSNMP_LOGONCE((LOG_ERR, "snmpd: cannot open /proc/loadavg\n"));
return (-1);
}
fscanf(in, "%lf %lf %lf", r_ave, (r_ave + 1), (r_ave + 2));
fclose(in);
}
#elif (defined(ultrix) || defined(sun) || defined(__alpha) || defined(dynix))
if (auto_nlist(LOADAVE_SYMBOL, (char *) favenrun, sizeof(favenrun)) ==
0)
return (-1);
for (i = 0; i < s_ave; i++)
*(r_ave + i) = FIX_TO_DBL(favenrun[i]);
#elif defined(hpux10) || defined(hpux11)
if (pstat_getdynamic(&pst_buf, sizeof(struct pst_dynamic), 1, 0) < 0)
return(-1);
r_ave[0] = pst_buf.psd_avg_1_min;
r_ave[1] = pst_buf.psd_avg_5_min;
r_ave[2] = pst_buf.psd_avg_15_min;
#elif defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7)
if(perfstat_cpu_total((perfstat_id_t *)NULL, &cs, sizeof(perfstat_cpu_total_t), 1) > 0) {
r_ave[0] = cs.loadavg[0] / 65536.0;
r_ave[1] = cs.loadavg[1] / 65536.0;
r_ave[2] = cs.loadavg[2] / 65536.0;
}
#elif defined(irix6)
SGT_COOKIE_INIT(&cookie);
SGT_COOKIE_SET_KSYM(&cookie, "avenrun");
sysget(SGT_KSYM, (char*)favenrun, sizeof(favenrun), SGT_READ, &cookie);
for (i = 0; i < s_ave; i++)
r_ave[i] = favenrun[i] / 1000.0;
DEBUGMSGTL(("ucd-snmp/loadave", "irix6: %d %d %d\n", favenrun[0], favenrun[1], favenrun[2]));
#elif !defined(cygwin)
#if defined(NETSNMP_CAN_USE_NLIST) && defined(LOADAVE_SYMBOL)
if (auto_nlist(LOADAVE_SYMBOL, (char *) r_ave, sizeof(double) * s_ave)
== 0)
#endif
return (-1);
#endif
/*
* XXX
* To calculate this, we need to compare
* successive values of the kernel array
* '_cp_times', and calculate the resulting
* percentage changes.
* This calculation needs to be performed
* regularly - perhaps as a background process.
*
* See the source to 'top' for full details.
*
* The linux SNMP HostRes implementation
* uses 'avenrun[0]*100' as an approximation.
* This is less than accurate, but has the
* advantage of being simple to implement!
*
* I'm also assuming a single processor
*/
return 0;
}
static unsigned char *
var_extensible_mem(struct variable *vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
static long long_ret;
static char errmsg[1024];
#ifdef dragonfly
static struct vmstats mem;
size_t vmstats_size = sizeof(mem);
#endif
static struct vmmeter mem;
#endif
static struct vmtotal total;
size_t total_size = sizeof(total);
int total_mib[] = { CTL_VM, VM_METER };
u_long phys_mem;
size_t phys_mem_size = sizeof(phys_mem);
int phys_mem_mib[] = { CTL_HW, HW_PHYSMEM };
#ifdef BUFSPACE_SYMBOL
long bufspace;
#endif
if (header_generic(vp, name, length, exact, var_len, write_method))
return (NULL);
/*
* Memory info
*/
#ifdef dragonfly
sysctlbyname("vm.vmstats", &vmstats, &vmstats_size, NULL, 0);
#else
auto_nlist(SUM_SYMBOL, (char *) &mem, sizeof(mem));
#endif
sysctl(total_mib, 2, &total, &total_size, NULL, 0);
/*
* Swap info
*/
swapmode();
/*
* getSwap();
*/
/*
* Physical memory
*/
sysctl(phys_mem_mib, 2, &phys_mem, &phys_mem_size, NULL, 0);
#ifdef BUFSPACE_SYMBOL
/*
* Buffer space
*/
auto_nlist(BUFSPACE_SYMBOL, (char *) &bufspace, sizeof(bufspace));
#endif
long_ret = 0; /* set to 0 as default */
/*
* Page-to-kb macro
*/
#define ptok(p) ((p) * (mem.v_page_size >> 10))
switch (vp->magic) {
case MIBINDEX:
long_ret = 0;
return ((u_char *) (&long_ret));
case ERRORNAME: /* dummy name */
sprintf(errmsg, "swap");
*var_len = strlen(errmsg);
return ((u_char *) (errmsg));
case MEMTOTALSWAP:
long_ret = swapTotal;
return ((u_char *) (&long_ret));
case MEMAVAILSWAP: /* FREE swap memory */
long_ret = swapFree;
return ((u_char *) (&long_ret));
case MEMTOTALREAL:
long_ret = phys_mem >> 10;
return ((u_char *) (&long_ret));
case MEMAVAILREAL: /* FREE real memory */
long_ret = ptok(mem.v_free_count);
return ((u_char *) (&long_ret));
/*
* these are not implemented
*/
case MEMTOTALSWAPTXT:
case MEMUSEDSWAPTXT:
case MEMTOTALREALTXT:
case MEMUSEDREALTXT:
#if NETSNMP_NO_DUMMY_VALUES
return NULL;
#endif
long_ret = -1;
return ((u_char *) (&long_ret));
case MEMTOTALFREE:
long_ret = ptok((int) total.t_free);
return ((u_char *) (&long_ret));
case MEMSWAPMINIMUM:
long_ret = minimumswap;
return ((u_char *) (&long_ret));
case MEMSHARED:
long_ret = ptok(total.t_vmshr +
total.t_avmshr + total.t_rmshr + total.t_armshr);
return ((u_char *) (&long_ret));
#ifdef BUFSPACE_SYMBOL
case MEMBUFFER:
long_ret = bufspace >> 10;
return ((u_char *) (&long_ret));
#endif
#ifndef openbsd2
case MEMCACHED:
#ifdef darwin
long_ret = ptok(mem.v_lookups);
#elif defined(dragonfly)
long_ret = ptok(mem.v_cache_count);
#else
long_ret = ptok(mem.v_cache_count) + ptok(mem.v_inactive_count);
#endif
return ((u_char *) (&long_ret));
#endif
case ERRORFLAG:
long_ret = (swapFree > minimumswap) ? 0 : 1;
return ((u_char *) (&long_ret));
case ERRORMSG:
if (swapFree < minimumswap)
sprintf(errmsg, "Running out of swap space (%qd)", swapFree);
else
errmsg[0] = 0;
*var_len = strlen(errmsg);
return ((u_char *) (errmsg));
}
return NULL;
}
/**
*
* @retval 0 no errors
* @retval !0 errors
*/
static int
_load(netsnmp_container *container, u_int load_flags)
{
struct inpcbtable table;
struct inpcb *head, *next, *prev;
struct inpcb inpcb;
struct tcpcb tcpcb;
int StateMap[] = { 1, 2, 3, 4, 5, 8, 6, 10, 9, 7, 11 };
netsnmp_tcpconn_entry *entry;
int state;
int rc = 0;
/*
* Read in the buffer containing the TCP table data
*/
if (!auto_nlist(TCP_SYMBOL, (char *)&table, sizeof(table))) {
DEBUGMSGTL(("tcp-mib/tcpConn_openbsd", "Failed to read tcp_symbol\n"));
return -1;
}
prev = (struct inpcb *)&CIRCLEQ_FIRST(&table.inpt_queue);
prev = NULL;
head = next = CIRCLEQ_FIRST(&table.inpt_queue);
while (next) {
if (!NETSNMP_KLOOKUP(next, (char *)&inpcb, sizeof(inpcb))) {
DEBUGMSGTL(("tcp-mib/data_access/tcpConn", "klookup inpcb failed\n"));
break;
}
if (prev && CIRCLEQ_PREV(&inpcb, inp_queue) != prev) {
snmp_log(LOG_ERR,"tcbtable link error\n");
break;
}
prev = next;
next = CIRCLEQ_NEXT(&inpcb, inp_queue);
if (!NETSNMP_KLOOKUP(inpcb.inp_ppcb, (char *)&tcpcb, sizeof(tcpcb))) {
DEBUGMSGTL(("tcp-mib/data_access/tcpConn", "klookup tcpcb failed\n"));
break;
}
state = StateMap[tcpcb.t_state];
if (load_flags) {
if (state == TCPCONNECTIONSTATE_LISTEN) {
if (load_flags & NETSNMP_ACCESS_TCPCONN_LOAD_NOLISTEN) {
DEBUGMSGT(("verbose:access:tcpconn:container",
" skipping listen\n"));
goto skip;
}
}
else if (load_flags & NETSNMP_ACCESS_TCPCONN_LOAD_ONLYLISTEN) {
DEBUGMSGT(("verbose:access:tcpconn:container",
" skipping non-listen\n"));
goto skip;
}
}
#if !defined(NETSNMP_ENABLE_IPV6)
if (inpcb.inp_flags & INP_IPV6)
goto skip;
#endif
entry = netsnmp_access_tcpconn_entry_create();
if(NULL == entry) {
rc = -3;
break;
}
/** oddly enough, these appear to already be in network order */
entry->loc_port = ntohs(inpcb.inp_lport);
entry->rmt_port = ntohs(inpcb.inp_fport);
entry->tcpConnState = state;
entry->pid = 0;
/** the addr string may need work */
if (inpcb.inp_flags & INP_IPV6) {
entry->loc_addr_len = entry->rmt_addr_len = 16;
memcpy(entry->loc_addr, &inpcb.inp_laddr6, 16);
memcpy(entry->rmt_addr, &inpcb.inp_faddr6, 16);
}
else {
entry->loc_addr_len = entry->rmt_addr_len = 4;
memcpy(entry->loc_addr, &inpcb.inp_laddr, 4);
memcpy(entry->rmt_addr, &inpcb.inp_faddr, 4);
}
DEBUGMSGTL(("tcp-mib/data_access", "tcp %d %d %d\n",
entry->loc_addr_len, entry->loc_port, entry->rmt_port));
/*
* add entry to container
*/
entry->arbitrary_index = CONTAINER_SIZE(container) + 1;
CONTAINER_INSERT(container, entry);
skip:
if (head == next)
break;
}
if(rc<0)
return rc;
return 0;
}
