/* 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;