/* Portions of this file are subject to the following copyright(s). See
* the Net-SNMP's COPYING file for more details and other copyrights
* that may apply:
*/
/*
* Portions of this file are copyrighted by:
* Copyright © 2003 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms specified in the COPYING file
* distributed with the Net-SNMP package.
*/
/*- This is a -*- C -*- compatible code file
*
* Code for SUNOS5_INSTRUMENTATION
*
* This file contains includes of standard and local system header files,
* includes of other application header files, global variable definitions,
* static variable definitions, static function prototypes, and function
* definitions.
*
* This file contains function to obtain statistics from SunOS 5.x kernel
*
*/
#include <net-snmp/net-snmp-config.h>
#ifdef solaris2
/*-
* Includes of standard ANSI C header files
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
/*-
* Includes of system header files (wrapped in duplicate include prevention)
*/
#include <fcntl.h>
#include <stropts.h>
#include <sys/types.h>
#include <kvm.h>
#include <sys/fcntl.h>
#include <kstat.h>
#include <errno.h>
#include <time.h>
#include <ctype.h>
#include <sys/sockio.h>
#include <sys/socket.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/tihdr.h>
#include <sys/tiuser.h>
#include <sys/dlpi.h>
#include <inet/common.h>
#include <inet/mib2.h>
#include <inet/ip.h>
#include <net/if.h>
#include <netinet/in.h>
/*-
* Includes of local application header files
*/
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include "kernel_sunos5.h"
kstat_ctl_t *kstat_fd = 0;
/*-
* Global variable definitions (with initialization)
*/
/*-
* Static variable definitions (with initialization)
*/
static
mibcache Mibcache[MIBCACHE_SIZE+1] = {
{MIB_SYSTEM, 0, (void *) -1, 0, 0, 0, 0},
{MIB_INTERFACES, 50 * sizeof(mib2_ifEntry_t), (void *) -1, 0, 3, 0,
0},
{MIB_AT, 0, (void *) -1, 0, 0, 0, 0},
{MIB_IP, sizeof(mib2_ip_t), (void *) -1, 0, 60, 0, 0},
{MIB_IP_ADDR, 20 * sizeof(mib2_ipAddrEntry_t), (void *) -1, 0, 60, 0,
0},
{MIB_IP_ROUTE, 200 * sizeof(mib2_ipRouteEntry_t), (void *) -1, 0, 30,
0, 0},
{MIB_IP_NET, 100 * sizeof(mib2_ipNetToMediaEntry_t), (void *) -1, 0,
300, 0, 0},
{MIB_ICMP, sizeof(mib2_icmp_t), (void *) -1, 0, 60, 0, 0},
{MIB_TCP, sizeof(mib2_tcp_t), (void *) -1, 0, 60, 0, 0},
{MIB_TCP_CONN, 1000 * sizeof(mib2_tcpConnEntry_t), (void *) -1, 0, 30,
0, 0},
{MIB_UDP, sizeof(mib2_udp_t), (void *) -1, 0, 30, 0, 0},
{MIB_UDP_LISTEN, 1000 * sizeof(mib2_udpEntry_t), (void *) -1, 0, 30, 0,
0},
{MIB_EGP, 0, (void *) -1, 0, 0, 0, 0},
{MIB_CMOT, 0, (void *) -1, 0, 0, 0, 0},
{MIB_TRANSMISSION, 0, (void *) -1, 0, 0, 0, 0},
{MIB_SNMP, 0, (void *) -1, 0, 0, 0, 0},
#ifdef SOLARIS_HAVE_IPV6_MIB_SUPPORT
#ifdef SOLARIS_HAVE_RFC4293_SUPPORT
{MIB_IP_TRAFFIC_STATS, 20 * sizeof(mib2_ipIfStatsEntry_t), (void *)-1, 0,
30, 0, 0},
{MIB_IP6, 20 * sizeof(mib2_ipIfStatsEntry_t), (void *)-1, 0, 30, 0, 0},
#else
{MIB_IP6, 20 * sizeof(mib2_ipv6IfStatsEntry_t), (void *)-1, 0, 30, 0, 0},
#endif
{MIB_IP6_ADDR, 20 * sizeof(mib2_ipv6AddrEntry_t), (void *)-1, 0, 30, 0, 0},
{MIB_IP6_ROUTE, 200 * sizeof(mib2_ipv6AddrEntry_t), (void *)-1, 0, 30, 0, 0},
{MIB_ICMP6, 20 * sizeof(mib2_ipv6IfIcmpEntry_t), (void *)-1, 0, 30, 0, 0},
{MIB_TCP6_CONN, 1000 * sizeof(mib2_tcp6ConnEntry_t), (void *) -1, 0, 30,
0, 0},
{MIB_UDP6_ENDPOINT, 1000 * sizeof(mib2_udp6Entry_t), (void *) -1, 0, 30,
0, 0},
#endif
#ifdef MIB2_SCTP
{MIB_SCTP, sizeof(mib2_sctp_t), (void *)-1, 0, 60, 0, 0},
{MIB_SCTP_CONN, sizeof(mib2_sctpConnEntry_t), (void *)-1, 0, 60, 0, 0},
{MIB_SCTP_CONN_LOCAL, sizeof(mib2_sctpConnLocalEntry_t), (void *)-1, 0,
60, 0, 0},
{MIB_SCTP_CONN_REMOTE, sizeof(mib2_sctpConnRemoteEntry_t), (void *)-1, 0,
60, 0, 0},
#endif
{0},
};
static
mibmap Mibmap[MIBCACHE_SIZE+1] = {
{MIB2_SYSTEM, 0,},
{MIB2_INTERFACES, 0,},
{MIB2_AT, 0,},
{MIB2_IP, 0,},
{MIB2_IP, MIB2_IP_20,},
{MIB2_IP, MIB2_IP_21,},
{MIB2_IP, MIB2_IP_22,},
{MIB2_ICMP, 0,},
{MIB2_TCP, 0,},
{MIB2_TCP, MIB2_TCP_13,},
{MIB2_UDP, 0,},
{MIB2_UDP, MIB2_UDP_5},
{MIB2_EGP, 0,},
{MIB2_CMOT, 0,},
{MIB2_TRANSMISSION, 0,},
{MIB2_SNMP, 0,},
#ifdef SOLARIS_HAVE_IPV6_MIB_SUPPORT
#ifdef SOLARIS_HAVE_RFC4293_SUPPORT
{MIB2_IP, MIB2_IP_TRAFFIC_STATS},
#endif
{MIB2_IP6, 0},
{MIB2_IP6, MIB2_IP6_ADDR},
{MIB2_IP6, MIB2_IP6_ROUTE},
{MIB2_ICMP6, 0},
{MIB2_TCP6, MIB2_TCP6_CONN},
{MIB2_UDP6, MIB2_UDP6_ENTRY},
#endif
#ifdef MIB2_SCTP
{MIB2_SCTP, 0},
{MIB2_SCTP, MIB2_SCTP_CONN},
{MIB2_SCTP, MIB2_SCTP_CONN_LOCAL},
{MIB2_SCTP, MIB2_SCTP_CONN_REMOTE},
#endif
{0},
};
static int sd = -2; /* /dev/arp stream descriptor. */
/*-
* Static function prototypes (use void as argument type if there are none)
*/
static found_e
getentry(req_e req_type, void *bufaddr, size_t len, size_t entrysize,
void *resp, int (*comp)(void *, void *), void *arg);
static int
getmib(int groupname, int subgroupname, void **statbuf, size_t *size,
size_t entrysize, req_e req_type, void *resp, size_t *length,
int (*comp)(void *, void *), void *arg);
static int
getif(mib2_ifEntry_t *ifbuf, size_t size, req_e req_type, mib2_ifEntry_t *resp,
size_t *length, int (*comp)(void *, void *), void *arg);
static void
set_if_info(mib2_ifEntry_t *ifp, unsigned index, char *name, uint64_t flags,
int mtu);
static int get_if_stats(mib2_ifEntry_t *ifp);
#if defined(HAVE_IF_NAMEINDEX) && defined(NETSNMP_INCLUDE_IFTABLE_REWRITES)
static int _dlpi_open(const char *devname);
static int _dlpi_get_phys_address(int fd, char *paddr, int maxlen,
int *paddrlen);
static int _dlpi_get_iftype(int fd, unsigned int *iftype);
static int _dlpi_attach(int fd, int ppa);
static int _dlpi_parse_devname(char *devname, int *ppap);
#endif
static int
Name_cmp(void *, void *);
static void
init_mibcache_element(mibcache * cp);
#define STREAM_DEV "/dev/arp"
#define BUFSIZE 40960 /* Buffer for messages (should be modulo(pagesize) */
/*-
* Function definitions
*/
#ifdef _STDC_COMPAT
#ifdef __cplusplus
extern "C" {
#endif
#endif
/*
* I profiled snmpd using Quantify on a Solaris 7 box, and it turned out that
* the calls to time() in getMibstat() were taking 18% of the total execution
* time of snmpd when doing simple walks over the whole tree. I guess it must
* be difficult for Sun hardware to tell the time or something ;-). Anyway,
* this seemed like it was negating the point of having the cache, so I have
* changed the code so that it runs a periodic alarm to age the cache entries
* instead. The meaning of the cache_ttl and cache_time members has changed to
* support this. cache_ttl is now the value that cache_time gets reset to when
* we fetch a value from the kernel; cache_time then ticks down to zero in
* steps of period (see below). When it reaches zero, the cache entry is no
* longer valid and we fetch a new one. The effect of this is the same as the
* previous code, but more efficient (because it's not calling time() for every
* variable fetched) when you are walking the tables. jbpn, 20020226.
*/
static void
kernel_sunos5_cache_age(unsigned int regnumber, void *data)
{
int i = 0, period = (int)data;
for (i = 0; i < MIBCACHE_SIZE; i++) {
DEBUGMSGTL(("kernel_sunos5", "cache[%d] time %ld ttl %d\n", i,
Mibcache[i].cache_time, (int)Mibcache[i].cache_ttl));
if (Mibcache[i].cache_time < period) {
Mibcache[i].cache_time = 0;
} else {
Mibcache[i].cache_time -= period;
}
}
}
void
init_kernel_sunos5(void)
{
static int creg = 0;
const int period = 3;
int alarm_id = 0;
if (creg == 0) {
alarm_id = snmp_alarm_register(period, SA_REPEAT,
kernel_sunos5_cache_age,
(void *)period);
DEBUGMSGTL(("kernel_sunos5", "registered alarm %d with period %ds\n",
alarm_id, period));
++creg;
}
}
/*
* Get various kernel statistics using undocumented Solaris kstat interface.
* We need it mainly for getting network interface statistics, although it is
* generic enough to be used for any purpose. It knows about kstat_headers
* module names and by the name of the statistics it tries to figure out the
* rest of necessary information. Returns 0 in case of success and < 0 if
* there were any errors.
*
* NOTE: To use this function correctly you have to know the actual type of the
* value to be returned, so you may build the test program, figure out the type
* and use it. Exposing kstat data types to upper layers doesn't seem to be
* reasonable. In any case I'd expect more reasonable kstat interface. :-(
*/
int
getKstatInt(const char *classname, const char *statname,
const char *varname, int *value)
{
kstat_ctl_t *ksc;
kstat_t *ks;
kid_t kid;
kstat_named_t *named;
int ret = -1; /* fail unless ... */
if (kstat_fd == 0) {
kstat_fd = kstat_open();
if (kstat_fd == 0) {
snmp_log_perror("kstat_open");
}
}
if ((ksc = kstat_fd) == NULL) {
goto Return;
}
ks = kstat_lookup(ksc, classname, -1, statname);
if (ks == NULL) {
DEBUGMSGTL(("kernel_sunos5", "class %s, stat %s not found\n",
classname ? classname : "NULL",
statname ? statname : "NULL"));
goto Return;
}
kid = kstat_read(ksc, ks, NULL);
if (kid == -1) {
DEBUGMSGTL(("kernel_sunos5", "cannot read class %s stats %s\n",
classname ? classname : "NULL", statname ? statname : "NULL"));
goto Return;
}
named = kstat_data_lookup(ks, varname);
if (named == NULL) {
DEBUGMSGTL(("kernel_sunos5", "no var %s for class %s stat %s\n",
varname, classname ? classname : "NULL",
statname ? statname : "NULL"));
goto Return;
}
ret = 0; /* maybe successful */
switch (named->data_type) {
#ifdef KSTAT_DATA_INT32 /* Solaris 2.6 and up */
case KSTAT_DATA_INT32:
*value = named->value.i32;
break;
case KSTAT_DATA_UINT32:
*value = named->value.ui32;
break;
case KSTAT_DATA_INT64:
*value = named->value.i64;
break;
case KSTAT_DATA_UINT64:
*value = named->value.ui64;
break;
#else
case KSTAT_DATA_LONG:
*value = named->value.l;
break;
case KSTAT_DATA_ULONG:
*value = named->value.ul;
break;
case KSTAT_DATA_LONGLONG:
*value = named->value.ll;
break;
case KSTAT_DATA_ULONGLONG:
*value = named->value.ull;
break;
#endif
default:
snmp_log(LOG_ERR,
"non-int type in kstat data: \"%s\" \"%s\" \"%s\" %d\n",
classname ? classname : "NULL",
statname ? statname : "NULL",
varname ? varname : "NULL", named->data_type);
ret = -1; /* fail */
break;
}
Return:
return ret;
}
int
getKstat(const char *statname, const char *varname, void *value)
{
kstat_ctl_t *ksc;
kstat_t *ks, *kstat_data;
kstat_named_t *d;
uint_t i;
int instance = 0;
char module_name[64];
int ret;
u_longlong_t val; /* The largest value */
void *v;
static char buf[128];
if (value == NULL) { /* Pretty useless but ... */
v = (void *) &val;
} else {
v = value;
}
if (kstat_fd == 0) {
kstat_fd = kstat_open();
if (kstat_fd == 0) {
snmp_log_perror("kstat_open");
}
}
if ((ksc = kstat_fd) == NULL) {
ret = -10;
goto Return; /* kstat errors */
}
if (statname == NULL || varname == NULL) {
ret = -20;
goto Return;
}
/*
* First, get "kstat_headers" statistics. It should
* contain all available modules.
*/
if ((ks = kstat_lookup(ksc, "unix", 0, "kstat_headers")) == NULL) {
ret = -10;
goto Return; /* kstat errors */
}
if (kstat_read(ksc, ks, NULL) <= 0) {
ret = -10;
goto Return; /* kstat errors */
}
kstat_data = ks->ks_data;
/*
* Now, look for the name of our stat in the headers buf
*/
for (i = 0; i < ks->ks_ndata; i++) {
DEBUGMSGTL(("kernel_sunos5",
"module: %s instance: %d name: %s class: %s type: %d flags: %x\n",
kstat_data[i].ks_module, kstat_data[i].ks_instance,
kstat_data[i].ks_name, kstat_data[i].ks_class,
kstat_data[i].ks_type, kstat_data[i].ks_flags));
if (strcmp(statname, kstat_data[i].ks_name) == 0) {
strcpy(module_name, kstat_data[i].ks_module);
instance = kstat_data[i].ks_instance;
break;
}
}
if (i == ks->ks_ndata) {
ret = -1;
goto Return; /* Not found */
}
/*
* Get the named statistics
*/
if ((ks = kstat_lookup(ksc, module_name, instance, statname)) == NULL) {
ret = -10;
goto Return; /* kstat errors */
}
if (kstat_read(ksc, ks, NULL) <= 0) {
ret = -10;
goto Return; /* kstat errors */
}
/*
* This function expects only name/value type of statistics, so if it is
* not the case return an error
*/
if (ks->ks_type != KSTAT_TYPE_NAMED) {
ret = -2;
goto Return; /* Invalid stat type */
}
for (i = 0, d = KSTAT_NAMED_PTR(ks); i < ks->ks_ndata; i++, d++) {
DEBUGMSGTL(("kernel_sunos5", "variable: \"%s\" (type %d)\n",
d->name, d->data_type));
if (strcmp(d->name, varname) == 0) {
switch (d->data_type) {
case KSTAT_DATA_CHAR:
DEBUGMSGTL(("kernel_sunos5", "value: %s\n", d->value.c));
*(char **)v = buf;
strlcpy(buf, d->value.c, sizeof(buf));
break;
#ifdef KSTAT_DATA_INT32 /* Solaris 2.6 and up */
case KSTAT_DATA_INT32:
*(Counter *)v = d->value.i32;
DEBUGMSGTL(("kernel_sunos5", "value: %d\n", d->value.i32));
break;
case KSTAT_DATA_UINT32:
*(Counter *)v = d->value.ui32;
DEBUGMSGTL(("kernel_sunos5", "value: %u\n", d->value.ui32));
break;
case KSTAT_DATA_INT64:
*(int64_t *)v = d->value.i64;
DEBUGMSGTL(("kernel_sunos5", "value: %ld\n", (long)d->value.i64));
break;
case KSTAT_DATA_UINT64:
*(uint64_t *)v = d->value.ui64;
DEBUGMSGTL(("kernel_sunos5", "value: %lu\n", (unsigned long)d->value.ui64));
break;
#else
case KSTAT_DATA_LONG:
*(Counter *)v = d->value.l;
DEBUGMSGTL(("kernel_sunos5", "value: %ld\n", d->value.l));
break;
case KSTAT_DATA_ULONG:
*(Counter *)v = d->value.ul;
DEBUGMSGTL(("kernel_sunos5", "value: %lu\n", d->value.ul));
break;
case KSTAT_DATA_LONGLONG:
*(Counter *)v = d->value.ll;
DEBUGMSGTL(("kernel_sunos5", "value: %lld\n",
(long)d->value.ll));
break;
case KSTAT_DATA_ULONGLONG:
*(Counter *)v = d->value.ull;
DEBUGMSGTL(("kernel_sunos5", "value: %llu\n",
(unsigned long)d->value.ull));
break;
#endif
case KSTAT_DATA_FLOAT:
*(float *)v = d->value.f;
DEBUGMSGTL(("kernel_sunos5", "value: %f\n", d->value.f));
break;
case KSTAT_DATA_DOUBLE:
*(double *)v = d->value.d;
DEBUGMSGTL(("kernel_sunos5", "value: %f\n", d->value.d));
break;
default:
DEBUGMSGTL(("kernel_sunos5",
"UNKNOWN TYPE %d (stat \"%s\" var \"%s\")\n",
d->data_type, statname, varname));
ret = -3;
goto Return; /* Invalid data type */
}
ret = 0; /* Success */
goto Return;
}
}
ret = -4; /* Name not found */
Return:
return ret;
}
int
getKstatString(const char *statname, const char *varname,
char *value, size_t value_len)
{
kstat_ctl_t *ksc;
kstat_t *ks, *kstat_data;
kstat_named_t *d;
size_t i, instance = 0;
char module_name[64];
int ret;
if (kstat_fd == 0) {
kstat_fd = kstat_open();
if (kstat_fd == 0) {
snmp_log_perror("kstat_open");
}
}
if ((ksc = kstat_fd) == NULL) {
ret = -10;
goto Return; /* kstat errors */
}
if (statname == NULL || varname == NULL) {
ret = -20;
goto Return;
}
/*
* First, get "kstat_headers" statistics. It should
* contain all available modules.
*/
if ((ks = kstat_lookup(ksc, "unix", 0, "kstat_headers")) == NULL) {
ret = -10;
goto Return; /* kstat errors */
}
if (kstat_read(ksc, ks, NULL) <= 0) {
ret = -10;
goto Return; /* kstat errors */
}
kstat_data = ks->ks_data;
/*
* Now, look for the name of our stat in the headers buf
*/
for (i = 0; i < ks->ks_ndata; i++) {
DEBUGMSGTL(("kernel_sunos5",
"module: %s instance: %d name: %s class: %s type: %d flags: %x\n",
kstat_data[i].ks_module, kstat_data[i].ks_instance,
kstat_data[i].ks_name, kstat_data[i].ks_class,
kstat_data[i].ks_type, kstat_data[i].ks_flags));
if (strcmp(statname, kstat_data[i].ks_name) == 0) {
strcpy(module_name, kstat_data[i].ks_module);
instance = kstat_data[i].ks_instance;
break;
}
}
if (i == ks->ks_ndata) {
ret = -1;
goto Return; /* Not found */
}
/*
* Get the named statistics
*/
if ((ks = kstat_lookup(ksc, module_name, instance, statname)) == NULL) {
ret = -10;
goto Return; /* kstat errors */
}
if (kstat_read(ksc, ks, NULL) <= 0) {
ret = -10;
goto Return; /* kstat errors */
}
/*
* This function expects only name/value type of statistics, so if it is
* not the case return an error
*/
if (ks->ks_type != KSTAT_TYPE_NAMED) {
ret = -2;
goto Return; /* Invalid stat type */
}
for (i = 0, d = KSTAT_NAMED_PTR(ks); i < ks->ks_ndata; i++, d++) {
DEBUGMSGTL(("kernel_sunos5", "variable: \"%s\" (type %d)\n",
d->name, d->data_type));
if (strcmp(d->name, varname) == 0) {
switch (d->data_type) {
case KSTAT_DATA_CHAR:
strlcpy(value, d->value.c, value_len);
DEBUGMSGTL(("kernel_sunos5", "value: %s\n", d->value.c));
break;
default:
DEBUGMSGTL(("kernel_sunos5",
"NONSTRING TYPE %d (stat \"%s\" var \"%s\")\n",
d->data_type, statname, varname));
ret = -3;
goto Return; /* Invalid data type */
}
ret = 0; /* Success */
goto Return;
}
}
ret = -4; /* Name not found */
Return:
return ret;
}
/*
* get MIB-II statistics. It maintaines a simple cache which buffers the last
* read block of MIB statistics (which may contain the whole table). It calls
* *comp to compare every entry with an entry pointed by arg. *comp should
* return 0 if comparison is successful. Req_type may be GET_FIRST, GET_EXACT,
* GET_NEXT. If search is successful getMibstat returns 0, otherwise 1.
*/
int
getMibstat(mibgroup_e grid, void *resp, size_t entrysize,
req_e req_type, int (*comp) (void *, void *), void *arg)
{
int ret, rc = -1, mibgr, mibtb, cache_valid;
size_t length;
mibcache *cachep;
found_e result = NOT_FOUND;
void *ep;
/*
* We assume that Mibcache is initialized in mibgroup_e enum order so we
* don't check the validity of index here.
*/
DEBUGMSGTL(("kernel_sunos5", "getMibstat (%d, *, %d, %d, *, *)\n",
grid, (int)entrysize, req_type));
cachep = &Mibcache[grid];
mibgr = Mibmap[grid].group;
mibtb = Mibmap[grid].table;
if (cachep->cache_addr == (void *) -1) /* Hasn't been initialized yet */
init_mibcache_element(cachep);
if (cachep->cache_size == 0) { /* Memory allocation problems */
cachep->cache_addr = resp; /* So use caller supplied address instead of cache */
cachep->cache_size = entrysize;
cachep->cache_last_found = 0;
}
if (req_type != GET_NEXT)
cachep->cache_last_found = 0;
cache_valid = (cachep->cache_time > 0);
DEBUGMSGTL(("kernel_sunos5","... cache_valid %d time %ld ttl %d now %ld\n",
cache_valid, cachep->cache_time, (int)cachep->cache_ttl,
time(NULL)));
if (cache_valid) {
/*
* Is it really?
*/
if (cachep->cache_comp != (void *)comp || cachep->cache_arg != arg) {
cache_valid = 0; /* Nope. */
}
}
if (cache_valid) {
/*
* Entry is valid, let's try to find a match
*/
if (req_type == GET_NEXT) {
result = getentry(req_type,
(void *)((char *)cachep->cache_addr +
(cachep->cache_last_found * entrysize)),
cachep->cache_length -
(cachep->cache_last_found * entrysize),
entrysize, &ep, comp, arg);
} else {
result = getentry(req_type, cachep->cache_addr,
cachep->cache_length, entrysize, &ep, comp,
arg);
}
}
if ((cache_valid == 0) || (result == NOT_FOUND) ||
(result == NEED_NEXT && cachep->cache_flags & CACHE_MOREDATA)) {
/*
* Either the cache is old, or we haven't found anything, or need the
* next item which hasn't been read yet. In any case, fill the cache
* up and try to find our entry.
*/
if (grid == MIB_INTERFACES) {
rc = getif((mib2_ifEntry_t *) cachep->cache_addr,
cachep->cache_size, req_type,
(mib2_ifEntry_t *) & ep, &length, comp, arg);
} else {
rc = getmib(mibgr, mibtb, &(cachep->cache_addr),
&(cachep->cache_size), entrysize, req_type, &ep,
&length, comp, arg);
}
if (rc >= 0) { /* Cache has been filled up */
cachep->cache_time = cachep->cache_ttl;
cachep->cache_length = length;
if (rc == 1) /* Found but there are more unread data */
cachep->cache_flags |= CACHE_MOREDATA;
else {
cachep->cache_flags &= ~CACHE_MOREDATA;
if (rc > 1) {
cachep->cache_time = 0;
}
}
cachep->cache_comp = (void *) comp;
cachep->cache_arg = arg;
} else {
cachep->cache_comp = NULL;
cachep->cache_arg = NULL;
}
}
DEBUGMSGTL(("kernel_sunos5", "... result %d rc %d\n", result, rc));
if (result == FOUND || rc == 0 || rc == 1) {
/*
* Entry has been found, deliver it
*/
if (resp != NULL) {
memcpy(resp, ep, entrysize);
}
ret = 0;
cachep->cache_last_found =
((char *)ep - (char *)cachep->cache_addr) / entrysize;
} else {
ret = 1; /* Not found */
}
DEBUGMSGTL(("kernel_sunos5", "... getMibstat returns %d\n", ret));
return ret;
}
/*
* Get a MIB-II entry from the buffer buffaddr, which satisfies the criterion,
* computed by (*comp), which gets arg as the first argument and pointer to the
* current position in the buffer as the second. If found entry is pointed by
* resp.
*/
static found_e
getentry(req_e req_type, void *bufaddr, size_t len,
size_t entrysize, void *resp, int (*comp)(void *, void *),
void *arg)
{
void *bp = bufaddr, **rp = resp;
int previous_found = 0;
if ((len > 0) && (len % entrysize != 0)) {
/*
* The data in the cache does not make sense, the size must be a
* multiple of the entry. Could be caused by alignment issues etc.
*/
DEBUGMSGTL(("kernel_sunos5",
"bad cache length %d - not multiple of entry size %d\n",
(int)len, (int)entrysize));
return NOT_FOUND;
}
/*
* Here we have to perform address arithmetic with pointer to void. Ugly...
*/
for (; len > 0; len -= entrysize, bp = (char *) bp + entrysize) {
if (rp != (void *) NULL) {
*rp = bp;
}
if (req_type == GET_FIRST || (req_type == GET_NEXT && previous_found)){
return FOUND;
}
if ((*comp)(arg, bp) == 0) {
if (req_type == GET_EXACT) {
return FOUND;
} else { /* GET_NEXT */
previous_found++;
continue;
}
}
}
if (previous_found) {
return NEED_NEXT;
} else {
return NOT_FOUND;
}
}
/*
* Initialize a cache element. It allocates the memory and sets the time stamp
* to invalidate the element.
*/
static void
init_mibcache_element(mibcache * cp)
{
if (cp == (mibcache *)NULL) {
return;
}
if (cp->cache_size) {
cp->cache_addr = malloc(cp->cache_size);
}
cp->cache_time = 0;
cp->cache_comp = NULL;
cp->cache_arg = NULL;
}
/*
* Get MIB-II statistics from the Solaris kernel. It uses undocumented
* interface to TCP/IP streams modules, which provides extended MIB-II for the
* following groups: ip, icmp, tcp, udp, egp.
*
* Usage: groupname, subgroupname are from <inet/mib2.h>,
* size%sizeof(statbuf) == 0,
* entrysize should be exact size of MIB-II entry,
* req_type:
* GET_FIRST - get the first entry in the buffer
* GET_EXACT - get exact match
* GET_NEXT - get next entry after the exact match
*
* (*comp) is a compare function, provided by the caller, which gets arg as the
* first argument and pointer to the current entry as th second. If compared,
* should return 0 and found entry will be pointed by resp.
*
* If search is successful and no more data to read, it returns 0,
* if successful and there is more data -- 1,
* if not found and end of data -- 2, any other errors -- < 0
* (negative error numbers are pretty random).
*
* NOTE: needs to be protected by a mutex in reentrant environment
*/
static int
getmib(int groupname, int subgroupname, void **statbuf, size_t *size,
size_t entrysize, req_e req_type, void *resp,
size_t *length, int (*comp)(void *, void *), void *arg)
{
int rc, ret = 0, flags;
char buf[BUFSIZE];
struct strbuf strbuf;
struct T_optmgmt_req *tor = (struct T_optmgmt_req *) buf;
struct T_optmgmt_ack *toa = (struct T_optmgmt_ack *) buf;
struct T_error_ack *tea = (struct T_error_ack *) buf;
struct opthdr *req;
found_e result = FOUND;
size_t oldsize;
DEBUGMSGTL(("kernel_sunos5", "...... getmib (%d, %d, ...)\n",
groupname, subgroupname));
/*
* Open the stream driver and push all MIB-related modules
*/
if (sd == -2) { /* First time */
if ((sd = open(STREAM_DEV, O_RDWR)) == -1) {
snmp_log_perror(STREAM_DEV);
ret = -1;
goto Return;
}
if (ioctl(sd, I_PUSH, "tcp") == -1) {
snmp_log_perror("I_PUSH tcp");
ret = -1;
goto Return;
}
if (ioctl(sd, I_PUSH, "udp") == -1) {
snmp_log_perror("I_PUSH udp");
ret = -1;
goto Return;
}
DEBUGMSGTL(("kernel_sunos5", "...... modules pushed OK\n"));
}
if (sd == -1) {
ret = -1;
goto Return;
}
/*
* First, use bigger buffer, to accelerate skipping unwanted messages
*/
strbuf.buf = buf;
strbuf.maxlen = BUFSIZE;
tor->PRIM_type = T_OPTMGMT_REQ;
tor->OPT_offset = sizeof(struct T_optmgmt_req);
tor->OPT_length = sizeof(struct opthdr);
#ifdef MI_T_CURRENT
tor->MGMT_flags = MI_T_CURRENT; /* Solaris < 2.6 */
#else
tor->MGMT_flags = T_CURRENT; /* Solaris 2.6 */
#endif
req = (struct opthdr *)(tor + 1);
req->level = groupname;
req->name = subgroupname;
/*
* non-zero len field is used to request extended MIB statistics
* on Solaris 10 Update 4 and later. The LEGACY_MIB_SIZE macro is only
* available for S10U4+, so we use that to see what action to take.
*/
#ifdef LEGACY_MIB_SIZE
req->len = 1; /* ask for extended MIBs */
#else
req->len = 0;
#endif
strbuf.len = tor->OPT_length + tor->OPT_offset;
flags = 0;
if ((rc = putmsg(sd, &strbuf, NULL, flags))) {
ret = -2;
goto Return;
}
req = (struct opthdr *) (toa + 1);
for (;;) {
flags = 0;
if ((rc = getmsg(sd, &strbuf, NULL, &flags)) == -1) {
ret = -EIO;
break;
}
if (rc == 0 && strbuf.len >= sizeof(struct T_optmgmt_ack) &&
toa->PRIM_type == T_OPTMGMT_ACK &&
toa->MGMT_flags == T_SUCCESS && req->len == 0) {
ret = 2;
break;
}
if (strbuf.len >= sizeof(struct T_error_ack) &&
tea->PRIM_type == T_ERROR_ACK) {
/* Protocol error */
ret = -((tea->TLI_error == TSYSERR) ? tea->UNIX_error : EPROTO);
break;
}
if (rc != MOREDATA || strbuf.len < sizeof(struct T_optmgmt_ack) ||
toa->PRIM_type != T_OPTMGMT_ACK ||
toa->MGMT_flags != T_SUCCESS) {
ret = -ENOMSG; /* No more messages */
break;
}
/*
* The order in which we get the statistics is determined by the kernel
* and not by the group name, so we have to loop until we get the
* required statistics.
*/
if (req->level != groupname || req->name != subgroupname) {
strbuf.maxlen = BUFSIZE;
strbuf.buf = buf;
do {
rc = getmsg(sd, NULL, &strbuf, &flags);
} while (rc == MOREDATA);
continue;
}
/*
* Now when we found our stat, switch buffer to a caller-provided
* one. Manipulating the size of it one can control performance,
* reducing the number of getmsg calls
*/
strbuf.buf = *statbuf;
strbuf.maxlen = *size;
strbuf.len = 0;
flags = 0;
do {
rc = getmsg(sd, NULL, &strbuf, &flags);
switch (rc) {
case -1:
ret = -ENOSR;
snmp_perror("getmsg");
goto Return;
default:
snmp_log(LOG_ERR, "kernel_sunos5/getmib: getmsg returned %d\n", rc);
ret = -ENODATA;
goto Return;
case MOREDATA:
DEBUGMSGTL(("kernel_sunos5", "...... getmib increased buffer size\n"));
oldsize = ( strbuf.buf - (char *)*statbuf) + strbuf.len;
strbuf.buf = (char *)realloc(*statbuf, oldsize+4096);
if(strbuf.buf != NULL) {
*statbuf = strbuf.buf;
*size = oldsize + 4096;
strbuf.buf = (char *)*statbuf + oldsize;
strbuf.maxlen = 4096;
result = NOT_FOUND;
break;
}
strbuf.buf = (char *)*statbuf + (oldsize - strbuf.len);
case 0:
/* fix buffer to real size & position */
strbuf.len += strbuf.buf - (char*)*statbuf;
strbuf.buf = *statbuf;
strbuf.maxlen = *size;
if (req_type == GET_NEXT && result == NEED_NEXT)
/*
* End of buffer, so "next" is the first item in the next
* buffer
*/
req_type = GET_FIRST;
result = getentry(req_type, (void *) strbuf.buf, strbuf.len,
entrysize, resp, comp, arg);
*length = strbuf.len; /* To use in caller for cacheing */
break;
}
} while (rc == MOREDATA && result != FOUND);
DEBUGMSGTL(("kernel_sunos5", "...... getmib buffer size is %d\n", (int)*size));
if (result == FOUND) { /* Search is successful */
if (rc != MOREDATA) {
ret = 0; /* Found and no more data */
} else {
ret = 1; /* Found and there is another unread data block */
}
break;
} else { /* Restore buffers, continue search */
strbuf.buf = buf;
strbuf.maxlen = BUFSIZE;
}
}
Return:
if (sd >= 0) ioctl(sd, I_FLUSH, FLUSHRW);
DEBUGMSGTL(("kernel_sunos5", "...... getmib returns %d\n", ret));
return ret;
}
/*
* Get info for interfaces group. Mimics getmib interface as much as possible
* to be substituted later if SunSoft decides to extend its mib2 interface.
*/
#if defined(HAVE_IF_NAMEINDEX) && defined(NETSNMP_INCLUDE_IFTABLE_REWRITES)
/*
* If IFTABLE_REWRITES is enabled, then we will also rely on DLPI to obtain
* information from the NIC.
*/
/*
* Open a DLPI device.
*
* On success the file descriptor is returned.
* On error -1 is returned.
*/
static int
_dlpi_open(const char *devname)
{
char *devstr;
int fd = -1;
int ppa = -1;
DEBUGMSGTL(("kernel_sunos5", "_dlpi_open called\n"));
if (devname == NULL)
return (-1);
if ((devstr = malloc(5 + strlen(devname) + 1)) == NULL)
return (-1);
(void) sprintf(devstr, "/dev/%s", devname);
DEBUGMSGTL(("kernel_sunos5:dlpi", "devstr(%s)\n", devstr));
/*
* First try opening the device using style 1, if the device does not
* exist we try style 2. Modules will not be pushed, so something like
* ip tunnels will not work.
*/
DEBUGMSGTL(("kernel_sunos5:dlpi", "style1 open(%s)\n", devstr));
if ((fd = open(devstr, O_RDWR | O_NONBLOCK)) < 0) {
DEBUGMSGTL(("kernel_sunos5:dlpi", "style1 open failed\n"));
if (_dlpi_parse_devname(devstr, &ppa) == 0) {
DEBUGMSGTL(("kernel_sunos5:dlpi", "style2 parse: %s, %d\n",
devstr, ppa));
/* try style 2 */
DEBUGMSGTL(("kernel_sunos5:dlpi", "style2 open(%s)\n", devstr));
if ((fd = open(devstr, O_RDWR | O_NONBLOCK)) != -1) {
if (_dlpi_attach(fd, ppa) == 0) {
DEBUGMSGTL(("kernel_sunos5:dlpi", "attached\n"));
} else {
DEBUGMSGTL(("kernel_sunos5:dlpi", "attached failed\n"));
close(fd);
fd = -1;
}
} else {
DEBUGMSGTL(("kernel_sunos5:dlpi", "style2 open failed\n"));
}
}
} else {
DEBUGMSGTL(("kernel_sunos5:dlpi", "style1 open succeeded\n"));
}
/* clean up */
free(devstr);
return (fd);
}
/*
* Obtain the physical address of the interface using DLPI
*/
static int
_dlpi_get_phys_address(int fd, char *addr, int maxlen, int *addrlen)
{
dl_phys_addr_req_t paddr_req;
union DL_primitives *dlp;
struct strbuf ctlbuf;
char buf[MAX(DL_PHYS_ADDR_ACK_SIZE+64, DL_ERROR_ACK_SIZE)];
int flag = 0;
DEBUGMSGTL(("kernel_sunos5:dlpi", "_dlpi_get_phys_address\n"));
paddr_req.dl_primitive = DL_PHYS_ADDR_REQ;
paddr_req.dl_addr_type = DL_CURR_PHYS_ADDR;
ctlbuf.buf = (char *)&paddr_req;
ctlbuf.len = DL_PHYS_ADDR_REQ_SIZE;
if (putmsg(fd, &ctlbuf, NULL, 0) < 0)
return (-1);
ctlbuf.maxlen = sizeof(buf);
ctlbuf.len = 0;
ctlbuf.buf = buf;
if (getmsg(fd, &ctlbuf, NULL, &flag) < 0)
return (-1);
if (ctlbuf.len < sizeof(uint32_t))
return (-1);
dlp = (union DL_primitives *)buf;
switch (dlp->dl_primitive) {
case DL_PHYS_ADDR_ACK: {
dl_phys_addr_ack_t *phyp = (dl_phys_addr_ack_t *)buf;
DEBUGMSGTL(("kernel_sunos5:dlpi", "got ACK\n"));
if (ctlbuf.len < DL_PHYS_ADDR_ACK_SIZE || phyp->dl_addr_length > maxlen)
return (-1);
(void) memcpy(addr, buf+phyp->dl_addr_offset, phyp->dl_addr_length);
*addrlen = phyp->dl_addr_length;
return (0);
}
case DL_ERROR_ACK: {
dl_error_ack_t *errp = (dl_error_ack_t *)buf;
DEBUGMSGTL(("kernel_sunos5:dlpi", "got ERROR ACK\n"));
if (ctlbuf.len < DL_ERROR_ACK_SIZE)
return (-1);
return (errp->dl_errno);
}
default:
DEBUGMSGTL(("kernel_sunos5:dlpi", "got type: %x\n", (unsigned)dlp->dl_primitive));
return (-1);
}
}
/*
* Query the interface about it's type.
*/
static int
_dlpi_get_iftype(int fd, unsigned int *iftype)
{
dl_info_req_t info_req;
union DL_primitives *dlp;
struct strbuf ctlbuf;
char buf[MAX(DL_INFO_ACK_SIZE, DL_ERROR_ACK_SIZE)];
int flag = 0;
DEBUGMSGTL(("kernel_sunos5:dlpi", "_dlpi_get_iftype\n"));
info_req.dl_primitive = DL_INFO_REQ;
ctlbuf.buf = (char *)&info_req;
ctlbuf.len = DL_INFO_REQ_SIZE;
if (putmsg(fd, &ctlbuf, NULL, 0) < 0) {
DEBUGMSGTL(("kernel_sunos5:dlpi", "putmsg failed: %d\nn", errno));
return (-1);
}
ctlbuf.maxlen = sizeof(buf);
ctlbuf.len = 0;
ctlbuf.buf = buf;
if (getmsg(fd, &ctlbuf, NULL, &flag) < 0) {
DEBUGMSGTL(("kernel_sunos5:dlpi", "getmsg failed: %d\n", errno));
return (-1);
}
if (ctlbuf.len < sizeof(uint32_t))
return (-1);
dlp = (union DL_primitives *)buf;
switch (dlp->dl_primitive) {
case DL_INFO_ACK: {
dl_info_ack_t *info = (dl_info_ack_t *)buf;
if (ctlbuf.len < DL_INFO_ACK_SIZE)
return (-1);
DEBUGMSGTL(("kernel_sunos5:dlpi", "dl_mac_type: %x\n",
(unsigned)info->dl_mac_type));
switch (info->dl_mac_type) {
case DL_CSMACD:
case DL_ETHER:
case DL_ETH_CSMA:
*iftype = 6;
break;
case DL_TPB: /* Token Passing Bus */
*iftype = 8;
break;
case DL_TPR: /* Token Passing Ring */
*iftype = 9;
break;
case DL_HDLC:
*iftype = 118;
break;
case DL_FDDI:
*iftype = 15;
break;
case DL_FC: /* Fibre channel */
*iftype = 56;
break;
case DL_ATM:
*iftype = 37;
break;
case DL_X25:
case DL_ISDN:
*iftype = 63;
break;
case DL_HIPPI:
*iftype = 47;
break;
#ifdef DL_IB
case DL_IB:
*iftype = 199;
break;
#endif
case DL_FRAME: /* Frame Relay */
*iftype = 32;
break;
case DL_LOOP:
*iftype = 24;
break;
#ifdef DL_WIFI
case DL_WIFI:
*iftype = 71;
break;
#endif
#ifdef DL_IPV4 /* then IPv6 is also defined */
case DL_IPV4: /* IPv4 Tunnel */
case DL_IPV6: /* IPv6 Tunnel */
*iftype = 131;
break;
#endif
default:
*iftype = 1; /* Other */
break;
}
return (0);
}
case DL_ERROR_ACK: {
dl_error_ack_t *errp = (dl_error_ack_t *)buf;
DEBUGMSGTL(("kernel_sunos5:dlpi",
"got DL_ERROR_ACK: dlpi %ld, error %ld\n",
(long)errp->dl_errno, (long)errp->dl_unix_errno));
if (ctlbuf.len < DL_ERROR_ACK_SIZE)
return (-1);
return (errp->dl_errno);
}
default:
DEBUGMSGTL(("kernel_sunos5:dlpi", "got type %x\n", (unsigned)dlp->dl_primitive));
return (-1);
}
}
static int
_dlpi_attach(int fd, int ppa)
{
dl_attach_req_t attach_req;
struct strbuf ctlbuf;
union DL_primitives *dlp;
char buf[MAX(DL_OK_ACK_SIZE, DL_ERROR_ACK_SIZE)];
int flag = 0;
attach_req.dl_primitive = DL_ATTACH_REQ;
attach_req.dl_ppa = ppa;
ctlbuf.buf = (char *)&attach_req;
ctlbuf.len = DL_ATTACH_REQ_SIZE;
if (putmsg(fd, &ctlbuf, NULL, 0) != 0)
return (-1);
ctlbuf.buf = buf;
ctlbuf.len = 0;
ctlbuf.maxlen = sizeof(buf);
if (getmsg(fd, &ctlbuf, NULL, &flag) != 0)
return (-1);
if (ctlbuf.len < sizeof(uint32_t))
return (-1);
dlp = (union DL_primitives *)buf;
if (dlp->dl_primitive == DL_OK_ACK && ctlbuf.len >= DL_OK_ACK_SIZE)
return (0);
return (-1);
}
static int
_dlpi_parse_devname(char *devname, int *ppap)
{
int ppa = 0;
int m = 1;
int i = strlen(devname) - 1;
while (i >= 0 && isdigit(devname[i] & 0xFF)) {
ppa += m * (devname[i] - '0');
m *= 10;
i--;
}
if (m == 1) {
return (-1);
}
*ppap = ppa;
devname[i + 1] = '\0';
return (0);
}
static int
getif(mib2_ifEntry_t *ifbuf, size_t size, req_e req_type,
mib2_ifEntry_t *resp, size_t *length, int (*comp)(void *, void *),
void *arg)
{
int fd, i, ret;
int ifsd, ifsd6 = -1;
struct lifreq lifreq, *lifrp;
mib2_ifEntry_t *ifp;
int nentries = size / sizeof(mib2_ifEntry_t);
found_e result = NOT_FOUND;
boolean_t if_isv6;
uint64_t if_flags;
struct if_nameindex *ifname, *ifnp;
lifrp = &lifreq;
if ((ifsd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
return -1;
}
DEBUGMSGTL(("kernel_sunos5", "...... using if_nameindex\n"));
if ((ifname = if_nameindex()) == NULL) {
ret = -1;
goto Return;
}
/*
* Gather information about each interface found. We try to handle errors
* gracefully: if an error occurs while processing an interface we simply
* move along to the next one. Previously, the function returned with an
* error right away.
*
* if_nameindex() already eliminates duplicate interfaces, so no extra
* checks are needed for interfaces that have both IPv4 and IPv6 plumbed
*/
Again:
for (i = 0, ifnp = ifname, ifp = (mib2_ifEntry_t *) ifbuf;
ifnp->if_index != 0 && (i < nentries); ifnp++) {
DEBUGMSGTL(("kernel_sunos5", "...... getif %s\n", ifnp->if_name));
strlcpy(lifrp->lifr_name, ifnp->if_name, LIFNAMSIZ);
if_isv6 = B_FALSE;
if (ioctl(ifsd, SIOCGLIFFLAGS, lifrp) < 0) {
if (ifsd6 == -1) {
if ((ifsd6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
ret = -1;
goto Return;
}
}
if (ioctl(ifsd6, SIOCGLIFFLAGS, lifrp) < 0) {
snmp_log(LOG_ERR, "SIOCGLIFFLAGS %s: %s\n",
lifrp->lifr_name, strerror(errno));
continue;
}
if_isv6 = B_TRUE;
}
if_flags = lifrp->lifr_flags;
if (ioctl(if_isv6?ifsd6:ifsd, SIOCGLIFMTU, lifrp) < 0) {
DEBUGMSGTL(("kernel_sunos5", "...... SIOCGLIFMTU failed\n"));
continue;
}
memset(ifp, 0, sizeof(mib2_ifEntry_t));
if ((fd = _dlpi_open(ifnp->if_name)) != -1) {
/* Could open DLPI... now try to grab some info */
(void) _dlpi_get_phys_address(fd, ifp->ifPhysAddress.o_bytes,
sizeof(ifp->ifPhysAddress.o_bytes),
&ifp->ifPhysAddress.o_length);
(void) _dlpi_get_iftype(fd, &ifp->ifType);
close(fd);
}
set_if_info(ifp, ifnp->if_index, ifnp->if_name, if_flags,
lifrp->lifr_metric);
if (get_if_stats(ifp) < 0) {
DEBUGMSGTL(("kernel_sunos5", "...... get_if_stats failed\n"));
continue;
}
/*
* Once we reach here we know that all went well, so move to
* the next ifEntry.
*/
i++;
ifp++;
}
if ((req_type == GET_NEXT) && (result == NEED_NEXT)) {
/*
* End of buffer, so "next" is the first item in the next buffer
*/
req_type = GET_FIRST;
}
result = getentry(req_type, (void *) ifbuf, size, sizeof(mib2_ifEntry_t),
(void *)resp, comp, arg);
if ((result != FOUND) && (i == nentries) && ifnp->if_index != 0) {
/*
* We reached the end of supplied buffer, but there is
* some more stuff to read, so continue.
*/
goto Again;
}
if (result != FOUND) {
ret = 2;
} else {
if (ifnp->if_index != 0) {
ret = 1; /* Found and more data to fetch */
} else {
ret = 0; /* Found and no more data */
}
*length = i * sizeof(mib2_ifEntry_t); /* Actual cache length */
}
Return:
if (ifname)
if_freenameindex(ifname);
close(ifsd);
if (ifsd6 != -1)
close(ifsd6);
return ret;
}
#else /* only rely on SIOCGIFCONF to get interface information */
static int
getif(mib2_ifEntry_t *ifbuf, size_t size, req_e req_type,
mib2_ifEntry_t *resp, size_t *length, int (*comp)(void *, void *),
void *arg)
{
int i, ret, idx = 1;
int ifsd;
static char *buf = NULL;
static int bufsize = 0;
struct ifconf ifconf;
struct ifreq *ifrp;
mib2_ifEntry_t *ifp;
mib2_ipNetToMediaEntry_t Media;
int nentries = size / sizeof(mib2_ifEntry_t);
int if_flags = 0;
found_e result = NOT_FOUND;
if ((ifsd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
return -1;
}
if (!buf) {
bufsize = 10240;
buf = malloc(bufsize);
if (!buf) {
ret = -1;
goto Return;
}
}
ifconf.ifc_buf = buf;
ifconf.ifc_len = bufsize;
while (ioctl(ifsd, SIOCGIFCONF, &ifconf) == -1) {
bufsize += 10240;
free(buf);
buf = malloc(bufsize);
if (!buf) {
ret = -1;
goto Return;
}
ifconf.ifc_buf = buf;
ifconf.ifc_len = bufsize;
}
Again:
for (i = 0, ifp = (mib2_ifEntry_t *) ifbuf, ifrp = ifconf.ifc_req;
((char *) ifrp < ((char *) ifconf.ifc_buf + ifconf.ifc_len))
&& (i < nentries); i++, ifp++, ifrp++, idx++) {
DEBUGMSGTL(("kernel_sunos5", "...... getif %s\n", ifrp->ifr_name));
if (ioctl(ifsd, SIOCGIFFLAGS, ifrp) < 0) {
ret = -1;
snmp_log(LOG_ERR, "SIOCGIFFLAGS %s: %s\n", ifrp->ifr_name,
strerror(errno));
goto Return;
}
if_flags = ifrp->ifr_flags;
if (ioctl(ifsd, SIOCGIFMTU, ifrp) < 0) {
ret = -1;
DEBUGMSGTL(("kernel_sunos5", "...... SIOCGIFMTU failed\n"));
goto Return;
}
memset(ifp, 0, sizeof(mib2_ifEntry_t));
set_if_info(ifp, idx, ifrp->ifr_name, if_flags, ifrp->ifr_metric);
if (get_if_stats(ifp) < 0) {
ret = -1;
goto Return;
}
/*
* An attempt to determine the physical address of the interface.
* There should be a more elegant solution using DLPI, but "the margin
* is too small to put it here ..."
*/
if (ioctl(ifsd, SIOCGIFADDR, ifrp) < 0) {
ret = -1;
goto Return;
}
if (getMibstat(MIB_IP_NET, &Media, sizeof(mib2_ipNetToMediaEntry_t),
GET_EXACT, &Name_cmp, ifrp) == 0) {
ifp->ifPhysAddress = Media.ipNetToMediaPhysAddress;
}
}
if ((req_type == GET_NEXT) && (result == NEED_NEXT)) {
/*
* End of buffer, so "next" is the first item in the next buffer
*/
req_type = GET_FIRST;
}
result = getentry(req_type, (void *) ifbuf, size, sizeof(mib2_ifEntry_t),
(void *)resp, comp, arg);
if ((result != FOUND) && (i == nentries) &&
((char *)ifrp < (char *)ifconf.ifc_buf + ifconf.ifc_len)) {
/*
* We reached the end of supplied buffer, but there is
* some more stuff to read, so continue.
*/
ifconf.ifc_len -= i * sizeof(struct ifreq);
ifconf.ifc_req = ifrp;
goto Again;
}
if (result != FOUND) {
ret = 2;
} else {
if ((char *)ifrp < (char *)ifconf.ifc_buf + ifconf.ifc_len) {
ret = 1; /* Found and more data to fetch */
} else {
ret = 0; /* Found and no more data */
}
*length = i * sizeof(mib2_ifEntry_t); /* Actual cache length */
}
Return:
close(ifsd);
return ret;
}
#endif /*defined(HAVE_IF_NAMEINDEX)&&defined(NETSNMP_INCLUDE_IFTABLE_REWRITES)*/
static void
set_if_info(mib2_ifEntry_t *ifp, unsigned index, char *name, uint64_t flags,
int mtu)
{
boolean_t havespeed = B_FALSE;
/*
* Set basic information
*/
ifp->ifIndex = index;
ifp->ifDescr.o_length = strlen(name);
strcpy(ifp->ifDescr.o_bytes, name);
ifp->ifAdminStatus = (flags & IFF_UP) ? 1 : 2;
ifp->ifOperStatus = ((flags & IFF_UP) && (flags & IFF_RUNNING)) ? 1 : 2;
ifp->ifLastChange = 0; /* Who knows ... */
ifp->flags = flags;
ifp->ifMtu = mtu;
ifp->ifSpeed = 0;
/*
* Get link speed
*/
if ((getKstatInt(NULL, name, "ifspeed", &ifp->ifSpeed) == 0)) {
/*
* check for SunOS patch with half implemented ifSpeed
*/
if (ifp->ifSpeed > 0 && ifp->ifSpeed < 10000) {
ifp->ifSpeed *= 1000000;
}
havespeed = B_TRUE;
} else if (getKstatInt(NULL, name, "ifSpeed", &ifp->ifSpeed) == 0) {
/*
* this is good
*/
havespeed = B_TRUE;
} else if (getKstatInt("link", name, "ifspeed", &ifp->ifSpeed) == 0) {
havespeed = B_TRUE;
}
/* make ifOperStatus depend on link status if available */
if (ifp->ifAdminStatus == 1) {
int i_tmp;
/* only UPed interfaces get correct link status - if any */
if (getKstatInt(NULL, name,"link_up",&i_tmp) == 0) {
ifp->ifOperStatus = i_tmp ? 1 : 2;
#ifdef IFF_FAILED
} else if (flags & IFF_FAILED) {
/*
* If IPMP is used, and if the daemon marks the interface
* as 'failed', then we know for sure something is amiss.
*/
ifp->ifOperStatus = 2;
#endif
} else if (havespeed == B_TRUE && ifp->ifSpeed == 0) {
/* Heuristic */
ifp->ifOperStatus = 2;
}
}
/*
* Set link Type and Speed (if it could not be determined from kstat)
*/
if (ifp->ifType == 24) {
ifp->ifSpeed = 127000000;
} else if (ifp->ifType == 1 || ifp->ifType == 0) {
/*
* Could not get the type from DLPI, so lets fall back to the hardcoded
* values.
*/
switch (name[0]) {
case 'a': /* ath (802.11) */
if (name[1] == 't' && name[2] == 'h')
ifp->ifType = 71;
break;
case 'l': /* le / lo / lane (ATM LAN Emulation) */
if (name[1] == 'o') {
if (!ifp->ifSpeed)
ifp->ifSpeed = 127000000;
ifp->ifType = 24;
} else if (name[1] == 'e') {
if (!ifp->ifSpeed)
ifp->ifSpeed = 10000000;
ifp->ifType = 6;
} else if (name[1] == 'a') {
if (!ifp->ifSpeed)
ifp->ifSpeed = 155000000;
ifp->ifType = 37;
}
break;
case 'g': /* ge (gigabit ethernet card) */
case 'c': /* ce (Cassini Gigabit-Ethernet (PCI) */
if (!ifp->ifSpeed)
ifp->ifSpeed = 1000000000;
ifp->ifType = 6;
break;
case 'h': /* hme (SBus card) */
case 'e': /* eri (PCI card) */
case 'b': /* be */
case 'd': /* dmfe -- found on netra X1 */
if (!ifp->ifSpeed)
ifp->ifSpeed = 100000000;
ifp->ifType = 6;
break;
case 'f': /* fa (Fore ATM) */
if (!ifp->ifSpeed)
ifp->ifSpeed = 155000000;
ifp->ifType = 37;
break;
case 'q': /* qe (QuadEther)/qa (Fore ATM)/qfe (QuadFastEther) */
if (name[1] == 'a') {
if (!ifp->ifSpeed)
ifp->ifSpeed = 155000000;
ifp->ifType = 37;
} else if (name[1] == 'e') {
if (!ifp->ifSpeed)
ifp->ifSpeed = 10000000;
ifp->ifType = 6;
} else if (name[1] == 'f') {
if (!ifp->ifSpeed)
ifp->ifSpeed = 100000000;
ifp->ifType = 6;
}
break;
case 'i': /* ibd (Infiniband)/ip.tun (IP tunnel) */
if (name[1] == 'b')
ifp->ifType = 199;
else if (name[1] == 'p')
ifp->ifType = 131;
break;
}
}
}
static int
get_if_stats(mib2_ifEntry_t *ifp)
{
Counter l_tmp;
char *name = ifp->ifDescr.o_bytes;
if (strchr(name, ':'))
return (0);
/*
* First try to grab 64-bit counters; if they are not available,
* fall back to 32-bit.
*/
if (getKstat(name, "ipackets64", &ifp->ifHCInUcastPkts) != 0) {
if (getKstatInt(NULL, name, "ipackets", &ifp->ifInUcastPkts) != 0) {
return (-1);
}
} else {
ifp->ifInUcastPkts = (uint32_t)(ifp->ifHCInUcastPkts & 0xffffffff);
}
if (getKstat(name, "rbytes64", &ifp->ifHCInOctets) != 0) {
if (getKstatInt(NULL, name, "rbytes", &ifp->ifInOctets) != 0) {
ifp->ifInOctets = ifp->ifInUcastPkts * 308;
}
} else {
ifp->ifInOctets = (uint32_t)(ifp->ifHCInOctets & 0xffffffff);
}
if (getKstat(name, "opackets64", &ifp->ifHCOutUcastPkts) != 0) {
if (getKstatInt(NULL, name, "opackets", &ifp->ifOutUcastPkts) != 0) {
return (-1);
}
} else {
ifp->ifOutUcastPkts = (uint32_t)(ifp->ifHCOutUcastPkts & 0xffffffff);
}
if (getKstat(name, "obytes64", &ifp->ifHCOutOctets) != 0) {
if (getKstatInt(NULL, name, "obytes", &ifp->ifOutOctets) != 0) {
ifp->ifOutOctets = ifp->ifOutUcastPkts * 308; /* XXX */
}
} else {
ifp->ifOutOctets = (uint32_t)(ifp->ifHCOutOctets & 0xffffffff);
}
if (ifp->ifType == 24) /* Loopback */
return (0);
/* some? VLAN interfaces don't have error counters, so ignore failure */
getKstatInt(NULL, name, "ierrors", &ifp->ifInErrors);
getKstatInt(NULL, name, "oerrors", &ifp->ifOutErrors);
/* Try to grab some additional information */
getKstatInt(NULL, name, "collisions", &ifp->ifCollisions);
getKstatInt(NULL, name, "unknowns", &ifp->ifInUnknownProtos);
/*
* TODO some NICs maintain 64-bit counters for multi/broadcast
* packets; should try to get that information.
*/
if (getKstatInt(NULL, name, "brdcstrcv", &l_tmp) == 0)
ifp->ifHCInBroadcastPkts = l_tmp;
if (getKstatInt(NULL, name, "multircv", &l_tmp) == 0)
ifp->ifHCInMulticastPkts = l_tmp;
ifp->ifInNUcastPkts = (uint32_t)(ifp->ifHCInBroadcastPkts +
ifp->ifHCInMulticastPkts);
if (getKstatInt(NULL, name, "brdcstxmt", &l_tmp) == 0)
ifp->ifHCOutBroadcastPkts = l_tmp;
if (getKstatInt(NULL, name, "multixmt", &l_tmp) == 0)
ifp->ifHCOutMulticastPkts = l_tmp;
ifp->ifOutNUcastPkts = (uint32_t)(ifp->ifHCOutBroadcastPkts +
ifp->ifHCOutMulticastPkts);
return(0);
}
/*
* Always TRUE. May be used as a comparison function in getMibstat
* to obtain the whole table (GET_FIRST should be used)
*/
int
Get_everything(void *x, void *y)
{
return 0; /* Always TRUE */
}
/*
* Compare name and IP address of the interface to ARP table entry.
* Needed to obtain the physical address of the interface in getif.
*/
static int
Name_cmp(void *ifrp, void *ep)
{
struct sockaddr_in *s = (struct sockaddr_in *)
&(((struct ifreq *)ifrp)->ifr_addr);
mib2_ipNetToMediaEntry_t *Ep = (mib2_ipNetToMediaEntry_t *)ep;
if ((strncmp(Ep->ipNetToMediaIfIndex.o_bytes,
((struct ifreq *)ifrp)->ifr_name,
Ep->ipNetToMediaIfIndex.o_length) == 0) &&
(s->sin_addr.s_addr == Ep->ipNetToMediaNetAddress)) {
return 0;
} else {
return 1;
}
}
/*
* Try to determine the index of a particular interface. If mfd-rewrites is
* specified, then this function would only be used when the system does not
* have if_nametoindex(3SOCKET).
*/
int
solaris2_if_nametoindex(const char *Name, int Len)
{
int i, sd, lastlen = 0, interfaces = 0;
struct ifconf ifc;
struct ifreq *ifrp = NULL;
char *buf = NULL;
if (Name == 0) {
return 0;
}
if ((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
return 0;
}
/*
* Cope with lots of interfaces and brokenness of ioctl SIOCGIFCONF
* on some platforms; see W. R. Stevens, ``Unix Network Programming
* Volume I'', p.435.
*/
for (i = 8;; i += 8) {
buf = calloc(i, sizeof(struct ifreq));
if (buf == NULL) {
close(sd);
return 0;
}
ifc.ifc_len = i * sizeof(struct ifreq);
ifc.ifc_buf = (caddr_t) buf;
if (ioctl(sd, SIOCGIFCONF, (char *) &ifc) < 0) {
if (errno != EINVAL || lastlen != 0) {
/*
* Something has gone genuinely wrong.
*/
free(buf);
close(sd);
return 0;
}
/*
* Otherwise, it could just be that the buffer is too small.
*/
} else {
if (ifc.ifc_len == lastlen) {
/*
* The length is the same as the last time; we're done.
*/
break;
}
lastlen = ifc.ifc_len;
}
free(buf);
}
ifrp = ifc.ifc_req;
interfaces = (ifc.ifc_len / sizeof(struct ifreq)) + 1;
for (i = 1; i < interfaces; i++, ifrp++) {
if (strncmp(ifrp->ifr_name, Name, Len) == 0) {
free(buf);
close(sd);
return i;
}
}
free(buf);
close(sd);
return 0;
}
#ifdef _STDC_COMPAT
#ifdef __cplusplus
}
#endif
#endif
#ifdef _GETKSTAT_TEST
int
main(int argc, char **argv)
{
int rc = 0;
u_long val = 0;
if (argc != 3) {
snmp_log(LOG_ERR, "Usage: %s stat_name var_name\n", argv[0]);
exit(1);
}
snmp_set_do_debugging(1);
rc = getKstat(argv[1], argv[2], &val);
if (rc == 0)
snmp_log(LOG_ERR, "%s = %lu\n", argv[2], val);
else
snmp_log(LOG_ERR, "rc =%d\n", rc);
return 0;
}
#endif /*_GETKSTAT_TEST */
#ifdef _GETMIBSTAT_TEST
int
ip20comp(void *ifname, void *ipp)
{
return (strncmp((char *) ifname,
((mib2_ipAddrEntry_t *) ipp)->ipAdEntIfIndex.o_bytes,
((mib2_ipAddrEntry_t *) ipp)->ipAdEntIfIndex.
o_length));
}
int
ARP_Cmp_Addr(void *addr, void *ep)
{
DEBUGMSGTL(("kernel_sunos5", "ARP: %lx <> %lx\n",
((mib2_ipNetToMediaEntry_t *) ep)->ipNetToMediaNetAddress,
*(IpAddress *) addr));
if (((mib2_ipNetToMediaEntry_t *) ep)->ipNetToMediaNetAddress ==
*(IpAddress *)addr) {
return 0;
} else {
return 1;
}
}
int
IF_cmp(void *addr, void *ep)
{
if (((mib2_ifEntry_t *)ep)->ifIndex ==((mib2_ifEntry_t *)addr)->ifIndex) {
return 0;
} else {
return 1;
}
}
int
main(int argc, char **argv)
{
int rc = 0, i, idx;
mib2_ipAddrEntry_t ipbuf, *ipp = &ipbuf;
mib2_ipNetToMediaEntry_t entry, *ep = &entry;
mib2_ifEntry_t ifstat;
req_e req_type;
IpAddress LastAddr = 0;
if (argc != 3) {
snmp_log(LOG_ERR,
"Usage: %s if_name req_type (0 first, 1 exact, 2 next) \n",
argv[0]);
exit(1);
}
switch (atoi(argv[2])) {
case 0:
req_type = GET_FIRST;
break;
case 1:
req_type = GET_EXACT;
break;
case 2:
req_type = GET_NEXT;
break;
};
snmp_set_do_debugging(0);
while ((rc =
getMibstat(MIB_INTERFACES, &ifstat, sizeof(mib2_ifEntry_t),
req_type, &IF_cmp, &idx)) == 0) {
idx = ifstat.ifIndex;
DEBUGMSGTL(("kernel_sunos5", "Ifname = %s\n",
ifstat.ifDescr.o_bytes));
req_type = GET_NEXT;
}
rc = getMibstat(MIB_IP_ADDR, &ipbuf, sizeof(mib2_ipAddrEntry_t),
req_type, ip20comp, argv[1]);
if (rc == 0)
DEBUGMSGTL(("kernel_sunos5", "mtu = %ld\n",
ipp->ipAdEntInfo.ae_mtu));
else
DEBUGMSGTL(("kernel_sunos5", "rc =%d\n", rc));
while ((rc =
getMibstat(MIB_IP_NET, &entry,
sizeof(mib2_ipNetToMediaEntry_t), req_type,
&ARP_Cmp_Addr, &LastAddr)) == 0) {
LastAddr = ep->ipNetToMediaNetAddress;
DEBUGMSGTL(("kernel_sunos5", "Ipaddr = %lX\n", (u_long) LastAddr));
req_type = GET_NEXT;
}
return 0;
}
#endif /*_GETMIBSTAT_TEST */
#endif /* SUNOS5 */