开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
tcp.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：19k
源码类别：

SNMP编程

开发平台：

Unix_Linux

tcp.c：源码内容
  2. /*
  3.  *  TCP MIB group implementation - tcp.c
  4.  *
  5.  */
  7. #include <net-snmp/net-snmp-config.h>
  8. #include "mibII_common.h"
  10. #if HAVE_STDLIB_H
  11. #include <stdlib.h>
  12. #endif
  13. #if HAVE_UNISTD_H
  14. #include <unistd.h>
  15. #endif
  17. #if HAVE_SYS_PROTOSW_H
  18. #include <sys/protosw.h>
  19. #endif
  20. #if HAVE_ARPA_INET_H
  21. #include <arpa/inet.h>
  22. #endif
  24. #if defined(osf4) || defined(osf5) || defined(aix4) || defined(hpux10)
  25. /*
  26.  * these are undefed to remove a stupid warning on osf compilers
  27.  * because they get redefined with a slightly different notation of the
  28.  * same value.  -- Wes 
  29.  */
  30. #undef TCP_NODELAY
  31. #undef TCP_MAXSEG
  32. #endif
  33. #if HAVE_NETINET_TCP_H
  34. #include <netinet/tcp.h>
  35. #endif
  36. #if HAVE_NETINET_TCPIP_H
  37. #include <netinet/tcpip.h>
  38. #endif
  39. #if HAVE_NETINET_TCP_TIMER_H
  40. #include <netinet/tcp_timer.h>
  41. #endif
  42. #if HAVE_SYS_SOCKETVAR_H
  43. #include <sys/socketvar.h>
  44. #endif
  45. #if HAVE_NETINET_TCP_VAR_H
  46. #include <netinet/tcp_var.h>
  47. #endif
  48. #if HAVE_NETINET_TCP_FSM_H
  49. #include <netinet/tcp_fsm.h>
  50. #endif
  52. #include <net-snmp/net-snmp-includes.h>
  53. #include <net-snmp/agent/net-snmp-agent-includes.h>
  54. #include <net-snmp/agent/auto_nlist.h>
  56. #include "util_funcs.h"
  57. #include "tcp.h"
  58. #include "tcpTable.h"
  59. #include "sysORTable.h"
  61. #ifndef MIB_STATS_CACHE_TIMEOUT
  62. #define MIB_STATS_CACHE_TIMEOUT 5
  63. #endif
  64. #ifndef TCP_STATS_CACHE_TIMEOUT
  65. #define TCP_STATS_CACHE_TIMEOUT MIB_STATS_CACHE_TIMEOUT
  66. #endif
  68.         /*********************
  69.  *
  70.  *  Kernel & interface information,
  71.  *   and internal forward declarations
  72.  *
  73.  *********************/
  75.                 /*
  76.                  * FreeBSD4 *does* need an explicit variable 'hz'
  77.                  *   since this appears in a system header file.
  78.                  * But only define it under FreeBSD, since it
  79.                  *   breaks other systems (notable AIX)
  80.                  */
  81. #if defined (freebsd4)
  82. int  hz = 1000;
  83. #endif
  85. extern int TCP_Count_Connections( void );
  86.         /*********************
  87.  *
  88.  *  Initialisation & common implementation functions
  89.  *
  90.  *********************/
  93. /*
  94.  * Define the OID pointer to the top of the mib tree that we're
  95.  * registering underneath, and the OID for the MIB module 
  96.  */
  97. oid             tcp_oid[]               = { SNMP_OID_MIB2, 6 };
  98. oid             tcp_module_oid[]        = { SNMP_OID_MIB2, 49 };
  100. void
  101. init_tcp(void)
  102. {
  103.     netsnmp_handler_registration *reginfo;
  105.     /*
  106.      * register ourselves with the agent as a group of scalars...
  107.      */
  108.     DEBUGMSGTL(("mibII/tcpScalar", "Initialising TCP scalar groupn"));
  109.     reginfo = netsnmp_create_handler_registration("tcp", tcp_handler,
  110.     tcp_oid, OID_LENGTH(tcp_oid), HANDLER_CAN_RONLY);
  111.     netsnmp_register_scalar_group(reginfo, TCPRTOALGORITHM, TCPOUTRSTS);
  113.     /*
  114.      * .... with a local cache
  115.      *    (except for HP-UX 11, which extracts objects individually)
  116.      */
  117. #ifndef hpux11
  118.     netsnmp_inject_handler( reginfo,
  119.     netsnmp_get_cache_handler(TCP_STATS_CACHE_TIMEOUT,
  120.     tcp_load, tcp_free,
  121. tcp_oid, OID_LENGTH(tcp_oid)));
  122. #endif
  124.     REGISTER_SYSOR_ENTRY(tcp_module_oid,
  125.                          "The MIB module for managing TCP implementations");
  127. #ifdef TCPSTAT_SYMBOL
  128.     auto_nlist(TCPSTAT_SYMBOL, 0, 0);
  129. #endif
  130. #ifdef TCP_SYMBOL
  131.     auto_nlist(TCP_SYMBOL, 0, 0);
  132. #endif
  133. #if freebsd4
  134.     hz = sysconf(_SC_CLK_TCK);  /* get ticks/s from system */
  135. #endif
  136. #ifdef solaris2
  137.     init_kernel_sunos5();
  138. #endif
  139. }
  141.         /*********************
  142.  *
  143.  *  System specific implementation functions
  144.  *
  145.  *********************/
  147. #ifdef hpux11
  148. #define TCP_STAT_STRUCTURE int
  149. #endif
  151. #ifdef linux
  152. #define TCP_STAT_STRUCTURE struct tcp_mib
  153. #define USES_SNMP_DESIGNED_TCPSTAT
  154. #undef TCPSTAT_SYMBOL
  155. #endif
  157. #ifdef solaris2
  158. #define TCP_STAT_STRUCTURE mib2_tcp_t
  159. #define USES_SNMP_DESIGNED_TCPSTAT
  160. #endif
  162. #if defined (WIN32) || defined (cygwin)
  163. #include <iphlpapi.h>
  164. #define TCP_STAT_STRUCTURE     MIB_TCPSTATS
  165. #endif
  167. #ifdef HAVE_SYS_TCPIPSTATS_H
  168. #define TCP_STAT_STRUCTURE struct kna
  169. #define USES_TRADITIONAL_TCPSTAT
  170. #endif
  172. #if !defined(TCP_STAT_STRUCTURE)
  173. #define TCP_STAT_STRUCTURE struct tcpstat
  174. #define USES_TRADITIONAL_TCPSTAT
  175. #endif
  177. TCP_STAT_STRUCTURE tcpstat;
  181.         /*********************
  182.  *
  183.  *  System independent handler (mostly)
  184.  *
  185.  *********************/
  189. int
  190. tcp_handler(netsnmp_mib_handler          *handler,
  191.             netsnmp_handler_registration *reginfo,
  192.             netsnmp_agent_request_info   *reqinfo,
  193.             netsnmp_request_info         *requests)
  194. {
  195.     netsnmp_request_info  *request;
  196.     netsnmp_variable_list *requestvb;
  197.     long     ret_value = -1;
  198.     oid      subid;
  199.     int      type = ASN_COUNTER;
  201.     /*
  202.      * The cached data should already have been loaded by the
  203.      *    cache handler, higher up the handler chain.
  204.      * But just to be safe, check this and load it manually if necessary
  205.      */
  206. #ifndef hpux11
  207.     if (!netsnmp_cache_is_valid(reqinfo, reginfo->handlerName)) {
  208.         netsnmp_assert("cache" == "valid"); /* always false */
  209.         tcp_load( NULL, NULL ); /* XXX - check for failure */
  210.     }
  211. #endif
  214.     /*
  215.      * 
  216.      *
  217.      */
  218.     DEBUGMSGTL(("mibII/tcpScalar", "Handler - mode %sn",
  219.                     se_find_label_in_slist("agent_mode", reqinfo->mode)));
  220.     switch (reqinfo->mode) {
  221.     case MODE_GET:
  222.         for (request=requests; request; request=request->next) {
  223.             requestvb = request->requestvb;
  224.             subid = requestvb->name[OID_LENGTH(tcp_oid)];  /* XXX */
  226.             DEBUGMSGTL(( "mibII/tcpScalar", "oid: "));
  227.             DEBUGMSGOID(("mibII/tcpScalar", requestvb->name,
  228.                                             requestvb->name_length));
  229.             DEBUGMSG((   "mibII/tcpScalar", "n"));
  230.             switch (subid) {
  231. #ifdef USES_SNMP_DESIGNED_TCPSTAT
  232.     case TCPRTOALGORITHM:
  233.         ret_value = tcpstat.tcpRtoAlgorithm;
  234.         type = ASN_INTEGER;
  235.         break;
  236.     case TCPRTOMIN:
  237.         ret_value = tcpstat.tcpRtoMin;
  238.         type = ASN_INTEGER;
  239.         break;
  240.     case TCPRTOMAX:
  241.         ret_value = tcpstat.tcpRtoMax;
  242.         type = ASN_INTEGER;
  243.         break;
  244.     case TCPMAXCONN:
  245.         ret_value = tcpstat.tcpMaxConn;
  246.         type = ASN_INTEGER;
  247.         break;
  248.     case TCPACTIVEOPENS:
  249.         ret_value = tcpstat.tcpActiveOpens;
  250.         break;
  251.     case TCPPASSIVEOPENS:
  252.         ret_value = tcpstat.tcpPassiveOpens;
  253.         break;
  254.     case TCPATTEMPTFAILS:
  255.         ret_value = tcpstat.tcpAttemptFails;
  256.         break;
  257.     case TCPESTABRESETS:
  258.         ret_value = tcpstat.tcpEstabResets;
  259.         break;
  260.     case TCPCURRESTAB:
  261.         ret_value = tcpstat.tcpCurrEstab;
  262.         type = ASN_GAUGE;
  263.         break;
  264.     case TCPINSEGS:
  265.         ret_value = tcpstat.tcpInSegs;
  266.         break;
  267.     case TCPOUTSEGS:
  268.         ret_value = tcpstat.tcpOutSegs;
  269.         break;
  270.     case TCPRETRANSSEGS:
  271.         ret_value = tcpstat.tcpRetransSegs;
  272.         break;
  273.     case TCPINERRS:
  274. #ifdef solaris2
  275.         ret_value = tcp_load(NULL, (void *)TCPINERRS);
  276. if (ret_value == -1) {
  277.             netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
  278.             continue;
  279. }
  280.         break;
  281. #else /* solaris2 */
  282. #ifdef linux
  283.         if (tcpstat.tcpInErrsValid) {
  284.             ret_value = tcpstat.tcpInErrs;
  285.             break;
  286. } else {
  287.             netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
  288.             continue;
  289. }
  290. #else /* linux */
  291.         netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
  292.         continue;
  293. #endif /* linux */
  294. #endif /* solaris2 */
  295.     case TCPOUTRSTS:
  296. #ifdef linux
  297.         if (tcpstat.tcpOutRstsValid) {
  298.             ret_value = tcpstat.tcpOutRsts;
  299.             break;
  300. }
  301. #endif /* linux */
  302.         netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
  303.         continue;
  304. #else /* USES_SNMP_DESIGNED_TCPSTAT */
  306. #ifdef USES_TRADITIONAL_TCPSTAT
  307. #ifdef HAVE_SYS_TCPIPSTATS_H
  308.     /*
  309.      * This actually reads statistics for *all* the groups together,
  310.      * so we need to isolate the TCP-specific bits.  
  311.      */
  312. #define tcpstat          tcpstat.tcpstat
  313. #endif
  314.     case TCPRTOALGORITHM:      /* Assume Van Jacobsen's algorithm */
  315.         ret_value = 4;
  316.         type = ASN_INTEGER;
  317.         break;
  318.     case TCPRTOMIN:
  319. #ifdef TCPTV_NEEDS_HZ
  320.         ret_value = TCPTV_MIN;
  321. #else
  322.         ret_value = TCPTV_MIN / PR_SLOWHZ * 1000;
  323. #endif
  324.         type = ASN_INTEGER;
  325.         break;
  326.     case TCPRTOMAX:
  327. #ifdef TCPTV_NEEDS_HZ
  328.         ret_value = TCPTV_REXMTMAX;
  329. #else
  330.         ret_value = TCPTV_REXMTMAX / PR_SLOWHZ * 1000;
  331. #endif
  332.         type = ASN_INTEGER;
  333.         break;
  334.     case TCPMAXCONN:
  335.         ret_value = -1; /* Dynamic maximum */
  336.         type = ASN_INTEGER;
  337.         break;
  338.     case TCPACTIVEOPENS:
  339.         ret_value = tcpstat.tcps_connattempt;
  340.         break;
  341.     case TCPPASSIVEOPENS:
  342.         ret_value = tcpstat.tcps_accepts;
  343.         break;
  344.         /*
  345.          * NB:  tcps_drops is actually the sum of the two MIB
  346.          *      counters tcpAttemptFails and tcpEstabResets.
  347.          */
  348.     case TCPATTEMPTFAILS:
  349.         ret_value = tcpstat.tcps_conndrops;
  350.         break;
  351.     case TCPESTABRESETS:
  352.         ret_value = tcpstat.tcps_drops;
  353.         break;
  354.     case TCPCURRESTAB:
  355. #ifdef USING_MIBII_TCPTABLE_MODULE
  356.         ret_value = TCP_Count_Connections();
  357. #else
  358.         ret_value = 0;
  359. #endif
  360.         type = ASN_GAUGE;
  361.         break;
  362.     case TCPINSEGS:
  363.         ret_value = tcpstat.tcps_rcvtotal;
  364.         break;
  365.     case TCPOUTSEGS:
  366.         /*
  367.          * RFC 1213 defines this as the number of segments sent
  368.          * "excluding those containing only retransmitted octets"
  369.          */
  370.         ret_value = tcpstat.tcps_sndtotal - tcpstat.tcps_sndrexmitpack;
  371.         break;
  372.     case TCPRETRANSSEGS:
  373.         ret_value = tcpstat.tcps_sndrexmitpack;
  374.         break;
  375.     case TCPINERRS:
  376.         ret_value = tcpstat.tcps_rcvbadsum + tcpstat.tcps_rcvbadoff
  377. #ifdef STRUCT_TCPSTAT_HAS_TCPS_RCVMEMDROP
  378.             + tcpstat.tcps_rcvmemdrop
  379. #endif
  380.             + tcpstat.tcps_rcvshort;
  381.         break;
  382.     case TCPOUTRSTS:
  383.         ret_value = tcpstat.tcps_sndctrl - tcpstat.tcps_closed;
  384.         break;
  385. #ifdef HAVE_SYS_TCPIPSTATS_H
  386. #undef tcpstat
  387. #endif
  388. #else /* USES_TRADITIONAL_TCPSTAT */
  390. #ifdef hpux11
  391.     case TCPRTOALGORITHM:
  392.     case TCPRTOMIN:
  393.     case TCPRTOMAX:
  394.     case TCPMAXCONN:
  395.     case TCPCURRESTAB:
  396.         if (subid == TCPCURRESTAB)
  397.            type = ASN_GAUGE;
  398. else
  399.            type = ASN_INTEGER;
  400.     case TCPACTIVEOPENS:
  401.     case TCPPASSIVEOPENS:
  402.     case TCPATTEMPTFAILS:
  403.     case TCPESTABRESETS:
  404.     case TCPINSEGS:
  405.     case TCPOUTSEGS:
  406.     case TCPRETRANSSEGS:
  407.     case TCPINERRS:
  408.     case TCPOUTRSTS:
  409. /*
  410.  * This is a bit of a hack, to shoehorn the HP-UX 11
  411.  * single-object retrieval approach into the caching
  412.  * architecture.
  413.  */
  414. if (tcp_load(NULL, (void*)subid) == -1 ) {
  415.             netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
  416.             continue;
  417. }
  418.         ret_value = tcpstat;
  419.         break;
  420. #else /* hpux11 */
  422. #if defined (WIN32) || defined (cygwin)
  423.     case TCPRTOALGORITHM:
  424.         ret_value = tcpstat.dwRtoAlgorithm;
  425.         type = ASN_INTEGER;
  426.         break;
  427.     case TCPRTOMIN:
  428.         ret_value = tcpstat.dwRtoMin;
  429.         type = ASN_INTEGER;
  430.         break;
  431.     case TCPRTOMAX:
  432.         ret_value = tcpstat.dwRtoMax;
  433.         type = ASN_INTEGER;
  434.         break;
  435.     case TCPMAXCONN:
  436.         ret_value = tcpstat.dwMaxConn;
  437.         type = ASN_INTEGER;
  438.         break;
  439.     case TCPACTIVEOPENS:
  440.         ret_value = tcpstat.dwActiveOpens;
  441.         break;
  442.     case TCPPASSIVEOPENS:
  443.         ret_value = tcpstat.dwPassiveOpens;
  444.         break;
  445.     case TCPATTEMPTFAILS:
  446.         ret_value = tcpstat.dwAttemptFails;
  447.         break;
  448.     case TCPESTABRESETS:
  449.         ret_value = tcpstat.dwEstabResets;
  450.         break;
  451.     case TCPCURRESTAB:
  452.         ret_value = tcpstat.dwCurrEstab;
  453.         type = ASN_GAUGE;
  454.         break;
  455.     case TCPINSEGS:
  456.         ret_value = tcpstat.dwInSegs;
  457.         break;
  458.     case TCPOUTSEGS:
  459.         ret_value = tcpstat.dwOutSegs;
  460.         break;
  461.     case TCPRETRANSSEGS:
  462.         ret_value = tcpstat.dwRetransSegs;
  463.         break;
  464.     case TCPINERRS:
  465.         ret_value = tcpstat.dwInErrs;
  466.         break;
  467.     case TCPOUTRSTS:
  468.         ret_value = tcpstat.dwOutRsts;
  469.         break;
  470. #endif /* WIN32 cygwin */
  471. #endif /* hpux11 */
  472. #endif /* USES_TRADITIONAL_TCPSTAT */
  473. #endif /* USES_SNMP_DESIGNED_TCPSTAT */
  475.     case TCPCONNTABLE:
  476.         /*
  477.  * This is not actually a valid scalar object.
  478.  * The table registration should take precedence,
  479.  *   so skip this subtree, regardless of architecture.
  480.  */
  481.         netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
  482.         continue;
  484.     }
  485.     snmp_set_var_typed_value(request->requestvb, (u_char)type,
  486.              (u_char *)&ret_value, sizeof(ret_value));
  487. }
  488.         break;
  490.     case MODE_GETNEXT:
  491.     case MODE_GETBULK:
  492.     case MODE_SET_RESERVE1:
  493.     case MODE_SET_RESERVE2:
  494.     case MODE_SET_ACTION:
  495.     case MODE_SET_COMMIT:
  496.     case MODE_SET_FREE:
  497.     case MODE_SET_UNDO:
  498.         snmp_log(LOG_WARNING, "mibII/tcp: Unsupported mode (%d)n",
  499.                                reqinfo->mode);
  500.         break;
  501.     default:
  502.         snmp_log(LOG_WARNING, "mibII/tcp: Unrecognised mode (%d)n",
  503.                                reqinfo->mode);
  504.         break;
  505.     }
  507.     return SNMP_ERR_NOERROR;
  508. }
  512.         /*********************
  513.  *
  514.  *  Internal implementation functions
  515.  *
  516.  *********************/
  518. #ifdef hpux11
  519. int
  520. tcp_load(netsnmp_cache *cache, void *vmagic)
  521. {
  522.     int             fd;
  523.     struct nmparms  p;
  524.     unsigned int    ulen;
  525.     int             ret;
  526.     int             magic = (int) vmagic;
  527.     
  528.     if ((fd = open_mib("/dev/ip", O_RDONLY, 0, NM_ASYNC_OFF)) < 0) {
  529.         DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP object %d (hpux11)n", magic));
  530.         return (-1);            /* error */
  531.     }
  533.     switch (magic) {
  534.     case TCPRTOALGORITHM:
  535.         p.objid = ID_tcpRtoAlgorithm;
  536.         break;
  537.     case TCPRTOMIN:
  538.         p.objid = ID_tcpRtoMin;
  539.         break;
  540.     case TCPRTOMAX:
  541.         p.objid = ID_tcpRtoMax;
  542.         break;
  543.     case TCPMAXCONN:
  544.         p.objid = ID_tcpMaxConn;
  545.         break;
  546.     case TCPACTIVEOPENS:
  547.         p.objid = ID_tcpActiveOpens;
  548.         break;
  549.     case TCPPASSIVEOPENS:
  550.         p.objid = ID_tcpPassiveOpens;
  551.         break;
  552.     case TCPATTEMPTFAILS:
  553.         p.objid = ID_tcpAttemptFails;
  554.         break;
  555.     case TCPESTABRESETS:
  556.         p.objid = ID_tcpEstabResets;
  557.         break;
  558.     case TCPCURRESTAB:
  559.         p.objid = ID_tcpCurrEstab;
  560.         break;
  561.     case TCPINSEGS:
  562.         p.objid = ID_tcpInSegs;
  563.         break;
  564.     case TCPOUTSEGS:
  565.         p.objid = ID_tcpOutSegs;
  566.         break;
  567.     case TCPRETRANSSEGS:
  568.         p.objid = ID_tcpRetransSegs;
  569.         break;
  570.     case TCPINERRS:
  571.         p.objid = ID_tcpInErrs;
  572.         break;
  573.     case TCPOUTRSTS:
  574.         p.objid = ID_tcpOutRsts;
  575.         break;
  576.     default:
  577.         tcpstat = 0;
  578.         close_mib(fd);
  579.         return -1;
  580.     }
  582.     p.buffer = (void *)&tcpstat;
  583.     ulen = sizeof(TCP_STAT_STRUCTURE);
  584.     p.len = &ulen;
  585.     ret = get_mib_info(fd, &p);
  586.     close_mib(fd);
  588.     DEBUGMSGTL(("mibII/tcpScalar", "%s TCP object %d (hpux11)n",
  589.                (ret < 0 ? "Failed to load" : "Loaded"),  magic));
  590.     return (ret);         /* 0: ok, < 0: error */
  591. }
  592. #else                           /* hpux11 */
  593. #ifdef linux
  594. int
  595. tcp_load(netsnmp_cache *cache, void *vmagic)
  596. {
  597.     long ret_value = -1;
  599.     ret_value = linux_read_tcp_stat(&tcpstat);
  601.     if ( ret_value < 0 ) {
  602.         DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (linux)n"));
  603.     } else {
  604.         DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (linux)n"));
  605.     }
  606.     return ret_value;
  607. }
  608. #else                           /* linux */
  609. #ifdef solaris2
  610. int
  611. tcp_load(netsnmp_cache *cache, void *vmagic)
  612. {
  613.     long ret_value = -1;
  614.     int  magic = (int)vmagic;
  615.     mib2_ip_t ipstat;
  617.     /*
  618.      * tcpInErrs is actually implemented as part of the MIB_IP group
  619.      * so we need to retrieve this independently
  620.      */
  621.     if (magic == TCPINERRS) {
  622.         if (getMibstat
  623.             (MIB_IP, &ipstat, sizeof(mib2_ip_t), GET_FIRST,
  624.              &Get_everything, NULL) < 0) {
  625.             DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP object %d (solaris)n", magic));
  626.             return -1;
  627.         } else {
  628.             DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP object %d (solaris)n", magic));
  629.             return ipstat.tcpInErrs;
  630.         }
  631.     }
  633.     /*
  634.      * Otherwise, retrieve the whole of the MIB_TCP group (and cache it)
  635.      */
  636.     ret_value = getMibstat(MIB_TCP, &tcpstat, sizeof(mib2_tcp_t),
  637.                            GET_FIRST, &Get_everything, NULL);
  639.     if ( ret_value < 0 ) {
  640.         DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (solaris)n"));
  641.     } else {
  642.         DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (solaris)n"));
  643.     }
  644.     return ret_value;
  645. }
  646. #else                           /* solaris2 */
  647. #if defined (WIN32) || defined (cygwin)
  648. int
  649. tcp_load(netsnmp_cache *cache, void *vmagic)
  650. {
  651.     long ret_value = -1;
  653.     ret_value = GetTcpStatistics(&tcpstat);
  655.     if ( ret_value < 0 ) {
  656.         DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (win32)n"));
  657.     } else {
  658.         DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (win32)n"));
  659.     }
  660.     return ret_value;
  661. }
  662. #else                           /* WIN32 cygwin */
  663. #if (defined(CAN_USE_SYSCTL) && defined(TCPCTL_STATS))
  664. int
  665. tcp_load(netsnmp_cache *cache, void *vmagic)
  666. {
  667.     int     sname[4]  = { CTL_NET, PF_INET, IPPROTO_TCP, TCPCTL_STATS };
  668.     size_t  len       = sizeof(tcpstat);
  669.     long    ret_value = -1;
  671.     ret_value = sysctl(sname, 4, &tcpstat, &len, 0, 0);
  673.     if ( ret_value < 0 ) {
  674.         DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (sysctl)n"));
  675.     } else {
  676.         DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (sysctl)n"));
  677.     }
  678.     return ret_value;
  679. }
  680. #else /* (defined(CAN_USE_SYSCTL) && defined(TCPCTL_STATS)) */
  681. #ifdef HAVE_SYS_TCPIPSTATS_H
  682. int
  683. tcp_load(netsnmp_cache *cache, void *vmagic)
  684. {
  685.     long ret_value = -1;
  687.     ret_value = sysmp(MP_SAGET, MPSA_TCPIPSTATS, &tcpstat, sizeof(tcpstat));
  689.     if ( ret_value < 0 ) {
  690.         DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (tcpipstats)n"));
  691.     } else {
  692.         DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (tcpipstats)n"));
  693.     }
  694.     return ret_value;
  695. }
  696. #else /* HAVE_SYS_TCPIPSTATS_H */
  697. #ifdef TCPSTAT_SYMBOL
  698. int
  699. tcp_load(netsnmp_cache *cache, void *vmagic)
  700. {
  701.     long ret_value = -1;
  703.     if (auto_nlist(TCPSTAT_SYMBOL, (char *)&tcpstat, sizeof(tcpstat)))
  704.         ret_value = 0;
  706.     if ( ret_value < 0 ) {
  707.         DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (tcpstat)n"));
  708.     } else {
  709.         DEBUGMSGTL(("mibII/tcpScalar", "Loaded TCP scalar Group (tcpstat)n"));
  710.     }
  711.     return ret_value;
  712. }
  713. #else /* TCPSTAT_SYMBOL */
  714. int
  715. tcp_load(netsnmp_cache *cache, void *vmagic)
  716. {
  717.     long ret_value = -1;
  719.     DEBUGMSGTL(("mibII/tcpScalar", "Failed to load TCP scalar Group (null)n"));
  720.     return ret_value;
  721. }
  722. #endif /* TCPSTAT_SYMBOL */
  723. #endif /* HAVE_SYS_TCPIPSTATS_H */
  724. #endif /* (defined(CAN_USE_SYSCTL) && defined(TCPCTL_STATS)) */
  725. #endif                          /* hpux11 */
  726. #endif                          /* linux */
  727. #endif                          /* solaris2 */
  728. #endif                          /* WIN32 cygwin */
  731. void
  732. tcp_free(netsnmp_cache *cache, void *magic)
  733. {
  734.     memset(&tcpstat, 0, sizeof(tcpstat));
  735. }