/*

 *  TCP MIB group implementation - tcp.c

 *

 */

#include <net-snmp/net-snmp-config.h>

#include <net-snmp/net-snmp-features.h>

#include "mibII_common.h"

#if HAVE_STDLIB_H

#include <stdlib.h>

#endif

#if HAVE_UNISTD_H

#include <unistd.h>

#endif

#if HAVE_SYS_PROTOSW_H

#include <sys/protosw.h>

#endif

#if HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

#if defined(osf4) || defined(osf5) || defined(aix4) || defined(hpux10)

/*

 * these are undefed to remove a stupid warning on osf compilers

 * because they get redefined with a slightly different notation of the

 * same value.  -- Wes 

 */

#undef TCP_NODELAY

#undef TCP_MAXSEG

#endif

#if HAVE_NETINET_TCP_H

#include <netinet/tcp.h>

#endif

#if HAVE_NETINET_TCPIP_H

#include <netinet/tcpip.h>

#endif

#if HAVE_NETINET_TCP_TIMER_H

#include <netinet/tcp_timer.h>

#endif

#if HAVE_NETINET_TCP_VAR_H

#include <netinet/tcp_var.h>

#endif

#if HAVE_NETINET_TCP_FSM_H

#include <netinet/tcp_fsm.h>

#endif

#include <net-snmp/net-snmp-includes.h>

#include <net-snmp/agent/net-snmp-agent-includes.h>

#include <net-snmp/agent/auto_nlist.h>

#include <net-snmp/agent/sysORTable.h>

#include "util_funcs/MIB_STATS_CACHE_TIMEOUT.h"

#include "tcp.h"

#include "tcpTable.h"

#ifndef MIB_STATS_CACHE_TIMEOUT

#define MIB_STATS_CACHE_TIMEOUT	5

#endif

#ifndef TCP_STATS_CACHE_TIMEOUT

#define TCP_STATS_CACHE_TIMEOUT	MIB_STATS_CACHE_TIMEOUT

#endif

#if defined(HAVE_LIBPERFSTAT_H) && (defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7)) && !defined(FIRST_PROTOCOL)

#ifdef HAVE_SYS_PROTOSW_H

#include <sys/protosw.h>

#endif

#include <libperfstat.h>

#ifdef FIRST_PROTOCOL

perfstat_protocol_t ps_proto;

perfstat_id_t ps_name;

#define _USE_FIRST_PROTOCOL 1

#endif

#endif

        /*********************

	 *

	 *  Kernel & interface information,

	 *   and internal forward declarations

	 *

	 *********************/

                /*

                 * FreeBSD4 *does* need an explicit variable 'hz'

                 *   since this appears in a system header file.

                 * But only define it under FreeBSD, since it

                 *   breaks other systems (notable AIX)

                 */

#ifdef freebsd4

int  hz = 1000;

#endif

        /*********************

	 *

	 *  Initialisation & common implementation functions

	 *

	 *********************/

/*

 * Define the OID pointer to the top of the mib tree that we're

 * registering underneath, and the OID for the MIB module 

 */

oid             tcp_oid[]               = { SNMP_OID_MIB2, 6 };

oid             tcp_module_oid[]        = { SNMP_OID_MIB2, 49 };

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

}

        /*********************

	 *

	 *  System specific implementation functions

	 *

	 *********************/

#ifdef hpux11

#define TCP_STAT_STRUCTURE	int

#endif

#ifdef linux

#define TCP_STAT_STRUCTURE	struct tcp_mib

#define USES_SNMP_DESIGNED_TCPSTAT

#undef TCPSTAT_SYMBOL

#endif

#ifdef solaris2

#define TCP_STAT_STRUCTURE	mib2_tcp_t

#define USES_SNMP_DESIGNED_TCPSTAT

#endif

#ifdef NETBSD_STATS_VIA_SYSCTL

#define TCP_STAT_STRUCTURE      struct tcp_mib

#define USES_SNMP_DESIGNED_TCPSTAT

#undef TCP_NSTATS

#endif

#ifdef HAVE_IPHLPAPI_H

#include <iphlpapi.h>

#define TCP_STAT_STRUCTURE     MIB_TCPSTATS

#endif

#ifdef HAVE_SYS_TCPIPSTATS_H

#define TCP_STAT_STRUCTURE	struct kna

#define USES_TRADITIONAL_TCPSTAT

#endif

#ifdef dragonfly

#define TCP_STAT_STRUCTURE	struct tcp_stats

#define USES_TRADITIONAL_TCPSTAT

#endif

#if !defined(TCP_STAT_STRUCTURE)

#define TCP_STAT_STRUCTURE	struct tcpstat

#define USES_TRADITIONAL_TCPSTAT

#endif

TCP_STAT_STRUCTURE tcpstat;

        /*********************

	 *

	 *  System independent handler (mostly)

	 *

	 *********************/

int

tcp_handler(netsnmp_mib_handler          *handler,

            netsnmp_handler_registration *reginfo,

            netsnmp_agent_request_info   *reqinfo,

            netsnmp_request_info         *requests)

{

    netsnmp_request_info  *request;

    netsnmp_variable_list *requestvb;

    long     ret_value = -1;

    oid      subid;

    int      type = ASN_COUNTER;

    /*

     * The cached data should already have been loaded by the

     *    cache handler, higher up the handler chain.

     * But just to be safe, check this and load it manually if necessary

     */

#if defined(_USE_FIRST_PROTOCOL)

    tcp_load(NULL, NULL);

#endif

    /*

     * 

     *

     */

    DEBUGMSGTL(("mibII/tcpScalar", "Handler - mode %s\n",

                    se_find_label_in_slist("agent_mode", reqinfo->mode)));

    switch (reqinfo->mode) {

    case MODE_GET:

        for (request=requests; request; request=request->next) {

            requestvb = request->requestvb;

            subid = requestvb->name[OID_LENGTH(tcp_oid)];  /* XXX */

            DEBUGMSGTL(( "mibII/tcpScalar", "oid: "));

            DEBUGMSGOID(("mibII/tcpScalar", requestvb->name,

                                            requestvb->name_length));

            DEBUGMSG((   "mibII/tcpScalar", "\n"));

            switch (subid) {

#ifdef USES_SNMP_DESIGNED_TCPSTAT

    case TCPRTOALGORITHM:

        ret_value = tcpstat.tcpRtoAlgorithm;

        type = ASN_INTEGER;

        break;

    case TCPRTOMIN:

        ret_value = tcpstat.tcpRtoMin;

        type = ASN_INTEGER;

        break;

    case TCPRTOMAX:

        ret_value = tcpstat.tcpRtoMax;

        type = ASN_INTEGER;

        break;

    case TCPMAXCONN:

        ret_value = tcpstat.tcpMaxConn;

        type = ASN_INTEGER;

        break;

    case TCPACTIVEOPENS:

        ret_value = tcpstat.tcpActiveOpens;

        break;

    case TCPPASSIVEOPENS:

        ret_value = tcpstat.tcpPassiveOpens;

        break;

    case TCPATTEMPTFAILS:

        ret_value = tcpstat.tcpAttemptFails;

        break;

    case TCPESTABRESETS:

        ret_value = tcpstat.tcpEstabResets;

        break;

    case TCPCURRESTAB:

        ret_value = tcpstat.tcpCurrEstab;

        type = ASN_GAUGE;

        break;

    case TCPINSEGS:

        ret_value = tcpstat.tcpInSegs & 0xffffffff;

        break;

    case TCPOUTSEGS:

        ret_value = tcpstat.tcpOutSegs & 0xffffffff;

        break;

    case TCPRETRANSSEGS:

        ret_value = tcpstat.tcpRetransSegs;

        break;

    case TCPINERRS:

#ifdef solaris2

        ret_value = tcp_load(NULL, (void *)TCPINERRS);

	if (ret_value == -1) {

            netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);

            continue;

	}

        break;

#elif defined(linux)

        if (tcpstat.tcpInErrsValid) {

            ret_value = tcpstat.tcpInErrs;

            break;

	} else {

            netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);

            continue;

	}

#else			/* linux */

        netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);

        continue;

#endif			/* solaris2 */

    case TCPOUTRSTS:

#ifdef linux

        if (tcpstat.tcpOutRstsValid) {

            ret_value = tcpstat.tcpOutRsts;

            break;

	}

#elif defined(solaris2)

        ret_value = tcpstat.tcpOutRsts;

        break;

#endif			/* linux */

        netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);

        continue;

#elif defined(USES_TRADITIONAL_TCPSTAT) && !defined(_USE_FIRST_PROTOCOL)

#ifdef HAVE_SYS_TCPIPSTATS_H

    /*

     * This actually reads statistics for *all* the groups together,

     * so we need to isolate the TCP-specific bits.  

     */

#define tcpstat          tcpstat.tcpstat

#endif

    case TCPRTOALGORITHM:      /* Assume Van Jacobsen's algorithm */

        ret_value = 4;

        type = ASN_INTEGER;

        break;

    case TCPRTOMIN:

#ifdef TCPTV_NEEDS_HZ

        ret_value = TCPTV_MIN;

#else

        ret_value = TCPTV_MIN / PR_SLOWHZ * 1000;

#endif

        type = ASN_INTEGER;

        break;

    case TCPRTOMAX:

#ifdef TCPTV_NEEDS_HZ

        ret_value = TCPTV_REXMTMAX;

#else

        ret_value = TCPTV_REXMTMAX / PR_SLOWHZ * 1000;

#endif

        type = ASN_INTEGER;

        break;

    case TCPMAXCONN:

        ret_value = -1;		/* Dynamic maximum */

        type = ASN_INTEGER;

        break;

    case TCPACTIVEOPENS:

        ret_value = tcpstat.tcps_connattempt;

        break;

    case TCPPASSIVEOPENS:

        ret_value = tcpstat.tcps_accepts;

        break;

        /*

         * NB:  tcps_drops is actually the sum of the two MIB

         *      counters tcpAttemptFails and tcpEstabResets.

         */

    case TCPATTEMPTFAILS:

        ret_value = tcpstat.tcps_conndrops;

        break;

    case TCPESTABRESETS:

        ret_value = tcpstat.tcps_drops;

        break;

    case TCPCURRESTAB:

#ifdef NETSNMP_FEATURE_CHECKING

        netsnmp_feature_want(tcp_count_connections)

#endif

#ifndef NETSNMP_FEATURE_REMOVE_TCP_COUNT_CONNECTIONS

        ret_value = TCP_Count_Connections();

#else

        ret_value = 0;

#endif /* NETSNMP_FEATURE_REMOVE_TCP_COUNT_CONNECTIONS */

        type = ASN_GAUGE;

        break;

    case TCPINSEGS:

        ret_value = tcpstat.tcps_rcvtotal & 0xffffffff;

        break;

    case TCPOUTSEGS:

        /*

         * RFC 1213 defines this as the number of segments sent

         * "excluding those containing only retransmitted octets"

         */

        ret_value = (tcpstat.tcps_sndtotal - tcpstat.tcps_sndrexmitpack) & 0xffffffff;

        break;

    case TCPRETRANSSEGS:

        ret_value = tcpstat.tcps_sndrexmitpack;

        break;

    case TCPINERRS:

        ret_value = tcpstat.tcps_rcvbadsum + tcpstat.tcps_rcvbadoff

#ifdef HAVE_STRUCT_TCPSTAT_TCPS_RCVMEMDROP

            + tcpstat.tcps_rcvmemdrop

#endif

            + tcpstat.tcps_rcvshort;

        break;

    case TCPOUTRSTS:

        ret_value = tcpstat.tcps_sndctrl - tcpstat.tcps_closed;

        break;

#ifdef HAVE_SYS_TCPIPSTATS_H

#undef tcpstat

#endif

#elif defined(hpux11)

    case TCPRTOALGORITHM:

    case TCPRTOMIN:

    case TCPRTOMAX:

    case TCPMAXCONN:

    case TCPCURRESTAB:

        if (subid == TCPCURRESTAB)

           type = ASN_GAUGE;

	else

           type = ASN_INTEGER;

    case TCPACTIVEOPENS:

    case TCPPASSIVEOPENS:

    case TCPATTEMPTFAILS:

    case TCPESTABRESETS:

    case TCPINSEGS:

    case TCPOUTSEGS:

    case TCPRETRANSSEGS:

    case TCPINERRS:

    case TCPOUTRSTS:

	/*

	 * This is a bit of a hack, to shoehorn the HP-UX 11

	 * single-object retrieval approach into the caching

	 * architecture.

	 */

	if (tcp_load(NULL, (void*)subid) == -1 ) {

            netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);

            continue;

	}

        ret_value = tcpstat;

        break;

#elif defined (WIN32) || defined (cygwin)

    case TCPRTOALGORITHM:

        ret_value = tcpstat.dwRtoAlgorithm;

        type = ASN_INTEGER;

        break;

    case TCPRTOMIN:

        ret_value = tcpstat.dwRtoMin;

        type = ASN_INTEGER;

        break;

    case TCPRTOMAX:

        ret_value = tcpstat.dwRtoMax;

        type = ASN_INTEGER;

        break;

    case TCPMAXCONN:

        ret_value = tcpstat.dwMaxConn;

        type = ASN_INTEGER;

        break;

    case TCPACTIVEOPENS:

        ret_value = tcpstat.dwActiveOpens;

        break;

    case TCPPASSIVEOPENS:

        ret_value = tcpstat.dwPassiveOpens;

        break;

    case TCPATTEMPTFAILS:

        ret_value = tcpstat.dwAttemptFails;

        break;

    case TCPESTABRESETS:

        ret_value = tcpstat.dwEstabResets;

        break;

    case TCPCURRESTAB:

        ret_value = tcpstat.dwCurrEstab;

        type = ASN_GAUGE;

        break;

    case TCPINSEGS:

        ret_value = tcpstat.dwInSegs;

        break;

    case TCPOUTSEGS:

        ret_value = tcpstat.dwOutSegs;

        break;

    case TCPRETRANSSEGS:

        ret_value = tcpstat.dwRetransSegs;

        break;

    case TCPINERRS:

        ret_value = tcpstat.dwInErrs;

        break;

    case TCPOUTRSTS:

        ret_value = tcpstat.dwOutRsts;

        break;

#elif defined(_USE_FIRST_PROTOCOL)

    case TCPRTOALGORITHM:

        ret_value = 4;

        type = ASN_INTEGER;

        break;

    case TCPRTOMIN:

        ret_value = 0;

        type = ASN_INTEGER;

        break;

    case TCPRTOMAX:

        ret_value = 0;

        type = ASN_INTEGER;

        break;

    case TCPMAXCONN:

        ret_value = -1;

        type = ASN_INTEGER;

        break;

    case TCPACTIVEOPENS:

        ret_value = ps_proto.u.tcp.initiated;

        break;

    case TCPPASSIVEOPENS:

        ret_value = ps_proto.u.tcp.accepted;

        break;

    case TCPATTEMPTFAILS:

        ret_value = ps_proto.u.tcp.dropped;

        break;

    case TCPESTABRESETS:

        ret_value = ps_proto.u.tcp.dropped;

        break;

    case TCPCURRESTAB:

        /* this value is currently missing */

        ret_value = 0; /*ps_proto.u.tcp.established;*/

        type = ASN_GAUGE;

        break;

    case TCPINSEGS:

        ret_value = ps_proto.u.tcp.ipackets;

        break;

    case TCPOUTSEGS:

        ret_value = ps_proto.u.tcp.opackets;

        break;

    case TCPRETRANSSEGS:

        ret_value = 0;

        break;

    case TCPINERRS:

        ret_value = ps_proto.u.tcp.ierrors;

        break;

    case TCPOUTRSTS:

        ret_value = 0;

        break;

#endif			/* USES_SNMP_DESIGNED_TCPSTAT */

    case TCPCONNTABLE:

        /*

	 * This is not actually a valid scalar object.

	 * The table registration should take precedence,

	 *   so skip this subtree, regardless of architecture.

	 */

        netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);

        continue;

	    }

	    snmp_set_var_typed_value(request->requestvb, (u_char)type,

			             (u_char *)&ret_value, sizeof(ret_value));

	}

        break;

    case MODE_GETNEXT:

    case MODE_GETBULK:

#ifndef NETSNMP_NO_WRITE_SUPPORT

    case MODE_SET_RESERVE1:

    case MODE_SET_RESERVE2:

    case MODE_SET_ACTION:

    case MODE_SET_COMMIT:

    case MODE_SET_FREE:

    case MODE_SET_UNDO:

        snmp_log(LOG_WARNING, "mibII/tcp: Unsupported mode (%d)\n",

                               reqinfo->mode);

        break;

#endif /* !NETSNMP_NO_WRITE_SUPPORT */

    default:

        snmp_log(LOG_WARNING, "mibII/tcp: Unrecognised mode (%d)\n",

                               reqinfo->mode);

        break;

    }

    return SNMP_ERR_NOERROR;

}

        /*********************

	 *

	 *  Internal implementation functions

	 *

	 *********************/

#ifdef hpux11

int

tcp_load(netsnmp_cache *cache, void *vmagic)

{

    int             fd;

    struct nmparms  p;

    unsigned int    ulen;

    int             ret;

    int             magic = (int) vmagic;

    if ((fd = open_mib("/dev/ip", O_RDONLY, 0, NM_ASYNC_OFF)) < 0) {

        DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP object %d (hpux11)\n", magic));

        return (-1);            /* error */

    }

    switch (magic) {

    case TCPRTOALGORITHM:

        p.objid = ID_tcpRtoAlgorithm;

        break;

    case TCPRTOMIN:

        p.objid = ID_tcpRtoMin;

        break;

    case TCPRTOMAX:

        p.objid = ID_tcpRtoMax;

        break;

    case TCPMAXCONN:

        p.objid = ID_tcpMaxConn;

        break;

    case TCPACTIVEOPENS:

        p.objid = ID_tcpActiveOpens;

        break;

    case TCPPASSIVEOPENS:

        p.objid = ID_tcpPassiveOpens;

        break;

    case TCPATTEMPTFAILS:

        p.objid = ID_tcpAttemptFails;

        break;

    case TCPESTABRESETS:

        p.objid = ID_tcpEstabResets;

        break;

    case TCPCURRESTAB:

        p.objid = ID_tcpCurrEstab;

        break;

    case TCPINSEGS:

        p.objid = ID_tcpInSegs;

        break;

    case TCPOUTSEGS:

        p.objid = ID_tcpOutSegs;

        break;

    case TCPRETRANSSEGS:

        p.objid = ID_tcpRetransSegs;

        break;

    case TCPINERRS:

        p.objid = ID_tcpInErrs;

        break;

    case TCPOUTRSTS:

        p.objid = ID_tcpOutRsts;

        break;

    default:

        tcpstat = 0;

        close_mib(fd);

        return -1;

    }

    p.buffer = (void *)&tcpstat;

    ulen = sizeof(TCP_STAT_STRUCTURE);

    p.len = &ule;;

    ret = get_mib_info(fd, &p);

    close_mib(fd);

    DEBUGMSGTL(("mibII/tcpScalar", "%s TCP object %d (hpux11)\n",

               (ret < 0 ? "Failed to load" : "Loaded"),  magic));

    return (ret);         /* 0: ok, < 0: error */

}

#elif defined(linux)

int

tcp_load(netsnmp_cache *cache, void *vmagic)

{

    long ret_value = -1;

    ret_value = linux_read_tcp_stat(&tcpstat);

    if ( ret_value < 0 ) {

        DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (linux)\n"));

    } else {

        DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (linux)\n"));

    }

    return ret_value;

}

#elif defined(solaris2)

int

tcp_load(netsnmp_cache *cache, void *vmagic)

{

    long ret_value = -1;

    int  magic = (int)vmagic;

    mib2_ip_t ipstat;

    /*

     * tcpInErrs is actually implemented as part of the MIB_IP group

     * so we need to retrieve this independently

     */

    if (magic == TCPINERRS) {

        if (getMibstat

            (MIB_IP, &ipstat, sizeof(mib2_ip_t), GET_FIRST,

             &Get_everything, NULL) < 0) {

            DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP object %d (solaris)\n", magic));

            return -1;

        } else {

            DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP object %d (solaris)\n", magic));

            return ipstat.tcpInErrs;

        }

    }

    /*

     * Otherwise, retrieve the whole of the MIB_TCP group (and cache it)

     */

    ret_value = getMibstat(MIB_TCP, &tcpstat, sizeof(mib2_tcp_t),

                           GET_FIRST, &Get_everything, NULL);

    if ( ret_value < 0 ) {

        DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (solaris)\n"));

    } else {

        DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (solaris)\n"));

    }

    return ret_value;

}

#elif defined(NETBSD_STATS_VIA_SYSCTL)

int

tcp_load(netsnmp_cache *cache, void *vmagic)

{

    long ret_value = -1;

    ret_value = netbsd_read_tcp_stat(&tcpstat);

    if ( ret_value < 0 ) {

       DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (netbsd)\n"));

    } else {

        DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (netbsd)\n"));

    }

    return ret_value;

}

#elif defined (WIN32) || defined (cygwin)

int

tcp_load(netsnmp_cache *cache, void *vmagic)

{

    long ret_value = -1;

    ret_value = GetTcpStatistics(&tcpstat);

    if ( ret_value < 0 ) {

        DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (win32)\n"));

    } else {

        DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (win32)\n"));

    }

    return ret_value;

}

#elif defined(_USE_FIRST_PROTOCOL)

int

tcp_load(netsnmp_cache *cache, void *vmagic)

{

    long ret_value = -1;

    strcpy(ps_name.name, "tcp");

    ret_value = perfstat_protocol(&ps_name, &ps_proto, sizeof(ps_proto), 1);

    if ( ret_value < 0 ) {

        DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (AIX)\n"));

    } else {

        ret_value = 0;

        DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (AIX)\n"));

    }

    return ret_value;

}

#elif (defined(NETSNMP_CAN_USE_SYSCTL) && defined(TCPCTL_STATS))

int

tcp_load(netsnmp_cache *cache, void *vmagic)

{

    int     sname[4]  = { CTL_NET, PF_INET, IPPROTO_TCP, TCPCTL_STATS };

    size_t  len       = sizeof(tcpstat);

    long    ret_value = -1;

    ret_value = sysctl(sname, 4, &tcpstat, &len, 0, 0);

    if ( ret_value < 0 ) {

        DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (sysctl)\n"));

    } else {

        DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (sysctl)\n"));

    }

    return ret_value;

}

#elif defined(HAVE_SYS_TCPIPSTATS_H)

int

tcp_load(netsnmp_cache *cache, void *vmagic)

{

    long ret_value = -1;

    ret_value = sysmp(MP_SAGET, MPSA_TCPIPSTATS, &tcpstat, sizeof(tcpstat));

    if ( ret_value < 0 ) {

        DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (tcpipstats)\n"));

    } else {

        DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (tcpipstats)\n"));

    }

    return ret_value;

}

#elif defined(TCPSTAT_SYMBOL)

int

tcp_load(netsnmp_cache *cache, void *vmagic)

{

    long ret_value = -1;

    if (auto_nlist(TCPSTAT_SYMBOL, (char *)&tcpstat, sizeof(tcpstat)))

        ret_value = 0;

    if ( ret_value < 0 ) {

        DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (tcpstat)\n"));

    } else {

        DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (tcpstat)\n"));

    }

    return ret_value;

}

#else				/* TCPSTAT_SYMBOL */

int

tcp_load(netsnmp_cache *cache, void *vmagic)

{

    long ret_value = -1;

    DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (null)\n"));

    return ret_value;

}

#endif                          /* WIN32 cygwin */

void

tcp_free(netsnmp_cache *cache, void *magic)

{

#if defined(_USE_FIRST_PROTOCOL)

    memset(&ps_proto, 0, sizeof(ps_proto));

#else

    memset(&tcpstat, 0, sizeof(tcpstat));

#endif

}