include/inet/mib2.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  *
  21  * Copyright (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
  22  */
  23 /* Copyright (c) 1990 Mentat Inc. */
  24
  25 #ifndef _INET_MIB2_H
  26 #define _INET_MIB2_H
  27
  28 #include <netinet/in.h> /* For in6_addr_t */
  29
  30 #ifdef  __cplusplus
  31 extern "C" {
  32 #endif
  33
  34 /*
  35  * The IPv6 parts of this are derived from:
  36  *      RFC 2465
  37  *      RFC 2466
  38  *      RFC 2452
  39  *      RFC 2454
  40  */
  41
  42 /*
  43  * SNMP set/get via M_PROTO T_OPTMGMT_REQ.  Structure is that used
  44  * for [gs]etsockopt() calls.  get uses T_CURRENT, set uses T_NEOGTIATE
  45  * MGMT_flags value.  The following definition of opthdr is taken from
  46  * socket.h:
  47  *
  48  * An option specification consists of an opthdr, followed by the value of
  49  * the option.  An options buffer contains one or more options.  The len
  50  * field of opthdr specifies the length of the option value in bytes.  This
  51  * length must be a multiple of sizeof(long) (use OPTLEN macro).
  52  *
  53  * struct opthdr {
  54  *      long    level;  protocol level affected
  55  *      long    name;   option to modify
  56  *      long    len;    length of option value
  57  * };
  58  *
  59  * #define OPTLEN(x) ((((x) + sizeof(long) - 1) / sizeof(long)) * sizeof(long))
  60  * #define OPTVAL(opt) ((char *)(opt + 1))
  61  *
  62  * For get requests (T_CURRENT), any MIB2_xxx value can be used (only
  63  * "get all" is supported, so all modules get a copy of the request to
  64  * return everything it knows.   In general, we use MIB2_IP.  There is
  65  * one exception: in general, IP will not report information related to
  66  * ire_testhidden and IRE_IF_CLONE routes (e.g., in the MIB2_IP_ROUTE
  67  * table). However, using the special value EXPER_IP_AND_ALL_IRES will cause
  68  * all information to be reported.  This special value should only be
  69  * used by IPMP-aware low-level utilities (e.g. in.mpathd).
  70  *
  71  * IMPORTANT:  some fields are grouped in a different structure than
  72  * suggested by MIB-II, e.g., checksum error counts.  The original MIB-2
  73  * field name has been retained.  Field names beginning with "mi" are not
  74  * defined in the MIB but contain important & useful information maintained
  75  * by the corresponding module.
  76  */
  77 #ifndef IPPROTO_MAX
  78 #define IPPROTO_MAX     256
  79 #endif
  80
  81 #define MIB2_SYSTEM             (IPPROTO_MAX+1)
  82 #define MIB2_INTERFACES         (IPPROTO_MAX+2)
  83 #define MIB2_AT                 (IPPROTO_MAX+3)
  84 #define MIB2_IP                 (IPPROTO_MAX+4)
  85 #define MIB2_ICMP               (IPPROTO_MAX+5)
  86 #define MIB2_TCP                (IPPROTO_MAX+6)
  87 #define MIB2_UDP                (IPPROTO_MAX+7)
  88 #define MIB2_EGP                (IPPROTO_MAX+8)
  89 #define MIB2_CMOT               (IPPROTO_MAX+9)
  90 #define MIB2_TRANSMISSION       (IPPROTO_MAX+10)
  91 #define MIB2_SNMP               (IPPROTO_MAX+11)
  92 #define MIB2_IP6                (IPPROTO_MAX+12)
  93 #define MIB2_ICMP6              (IPPROTO_MAX+13)
  94 #define MIB2_TCP6               (IPPROTO_MAX+14)
  95 #define MIB2_UDP6               (IPPROTO_MAX+15)
  96 #define MIB2_SCTP               (IPPROTO_MAX+16)
  97
  98 /*
  99  * Define range of levels for use with MIB2_*
 100  */
 101 #define MIB2_RANGE_START        (IPPROTO_MAX+1)
 102 #define MIB2_RANGE_END          (IPPROTO_MAX+16)
 103
 104
 105 #define EXPER                   1024    /* experimental - not part of mib */
 106 #define EXPER_IGMP              (EXPER+1)
 107 #define EXPER_DVMRP             (EXPER+2)
 108 #define EXPER_RAWIP             (EXPER+3)
 109 #define EXPER_IP_AND_ALL_IRES   (EXPER+4)
 110
 111 /*
 112  * Define range of levels for experimental use
 113  */
 114 #define EXPER_RANGE_START       (EXPER+1)
 115 #define EXPER_RANGE_END         (EXPER+4)
 116
 117 #define BUMP_MIB(s, x)          {                               \
 118         extern void __dtrace_probe___mib_##x(int, void *);      \
 119         void *stataddr = &((s)->x);                             \
 120         __dtrace_probe___mib_##x(1, stataddr);                  \
 121         (s)->x++;                                               \
 122 }
 123
 124 #define UPDATE_MIB(s, x, y)     {                               \
 125         extern void __dtrace_probe___mib_##x(int, void *);      \
 126         void *stataddr = &((s)->x);                             \
 127         __dtrace_probe___mib_##x(y, stataddr);                  \
 128         (s)->x += (y);                                          \
 129 }
 130
 131 #define SET_MIB(x, y)           x = y
 132 #define BUMP_LOCAL(x)           (x)++
 133 #define UPDATE_LOCAL(x, y)      (x) += (y)
 134 #define SYNC32_MIB(s, m32, m64) SET_MIB((s)->m32, (s)->m64 & 0xffffffff)
 135
 136 /*
 137  * Each struct that has been extended have a macro (MIB_FIRST_NEW_ELM_type)
 138  * that is set to the first new element of the extended struct.
 139  * The LEGACY_MIB_SIZE macro can be used to determine the size of MIB
 140  * objects that needs to be returned to older applications unaware of
 141  * these extensions.
 142  */
 143 #define MIB_PTRDIFF(s, e)       (caddr_t)e - (caddr_t)s
 144 #define LEGACY_MIB_SIZE(s, t)   MIB_PTRDIFF(s, &(s)->MIB_FIRST_NEW_ELM_##t)
 145
 146 #define OCTET_LENGTH    32      /* Must be at least LIFNAMSIZ */
 147 typedef struct Octet_s {
 148         int     o_length;
 149         char    o_bytes[OCTET_LENGTH];
 150 } Octet_t;
 151
 152 typedef uint32_t        Counter;
 153 typedef uint32_t        Counter32;
 154 typedef uint64_t        Counter64;
 155 typedef uint32_t        Gauge;
 156 typedef uint32_t        IpAddress;
 157 typedef struct in6_addr Ip6Address;
 158 typedef Octet_t         DeviceName;
 159 typedef Octet_t         PhysAddress;
 160 typedef uint32_t        DeviceIndex;    /* Interface index */
 161
 162 #define MIB2_UNKNOWN_INTERFACE  0
 163 #define MIB2_UNKNOWN_PROCESS    0
 164
 165 /*
 166  *  IP group
 167  */
 168 #define MIB2_IP_ADDR            20      /* ipAddrEntry */
 169 #define MIB2_IP_ROUTE           21      /* ipRouteEntry */
 170 #define MIB2_IP_MEDIA           22      /* ipNetToMediaEntry */
 171 #define MIB2_IP6_ROUTE          23      /* ipv6RouteEntry */
 172 #define MIB2_IP6_MEDIA          24      /* ipv6NetToMediaEntry */
 173 #define MIB2_IP6_ADDR           25      /* ipv6AddrEntry */
 174 #define MIB2_IP_TRAFFIC_STATS   31      /* ipIfStatsEntry (IPv4) */
 175 #define EXPER_IP_GROUP_MEMBERSHIP       100
 176 #define EXPER_IP6_GROUP_MEMBERSHIP      101
 177 #define EXPER_IP_GROUP_SOURCES          102
 178 #define EXPER_IP6_GROUP_SOURCES         103
 179 #define EXPER_IP_DCE                    105
 180
 181 /* Old names retained for compatibility */
 182 #define MIB2_IP_20      MIB2_IP_ADDR
 183 #define MIB2_IP_21      MIB2_IP_ROUTE
 184 #define MIB2_IP_22      MIB2_IP_MEDIA
 185
 186 typedef struct mib2_ip {
 187                 /* forwarder?  1 gateway, 2 NOT gateway {ip 1} RW */
 188         int     ipForwarding;
 189                 /* default Time-to-Live for iph         {ip 2} RW */
 190         int     ipDefaultTTL;
 191                 /* # of input datagrams                 {ip 3} */
 192         Counter ipInReceives;
 193                 /* # of dg discards for iph error       {ip 4} */
 194         Counter ipInHdrErrors;
 195                 /* # of dg discards for bad addr        {ip 5} */
 196         Counter ipInAddrErrors;
 197                 /* # of dg being forwarded              {ip 6} */
 198         Counter ipForwDatagrams;
 199                 /* # of dg discards for unk protocol    {ip 7} */
 200         Counter ipInUnknownProtos;
 201                 /* # of dg discards of good dg's        {ip 8} */
 202         Counter ipInDiscards;
 203                 /* # of dg sent upstream                {ip 9} */
 204         Counter ipInDelivers;
 205                 /* # of outdgs recv'd from upstream     {ip 10} */
 206         Counter ipOutRequests;
 207                 /* # of good outdgs discarded           {ip 11} */
 208         Counter ipOutDiscards;
 209                 /* # of outdg discards: no route found  {ip 12} */
 210         Counter ipOutNoRoutes;
 211                 /* sec's recv'd frags held for reass.   {ip 13} */
 212         int     ipReasmTimeout;
 213                 /* # of ip frags needing reassembly     {ip 14} */
 214         Counter ipReasmReqds;
 215                 /* # of dg's reassembled                {ip 15} */
 216         Counter ipReasmOKs;
 217                 /* # of reassembly failures (not dg cnt){ip 16} */
 218         Counter ipReasmFails;
 219                 /* # of dg's fragged                    {ip 17} */
 220         Counter ipFragOKs;
 221                 /* # of dg discards for no frag set     {ip 18} */
 222         Counter ipFragFails;
 223                 /* # of dg frags from fragmentation     {ip 19} */
 224         Counter ipFragCreates;
 225                 /* {ip 20} */
 226         int     ipAddrEntrySize;
 227                 /* {ip 21} */
 228         int     ipRouteEntrySize;
 229                 /* {ip 22} */
 230         int     ipNetToMediaEntrySize;
 231                 /* # of valid route entries discarded   {ip 23} */
 232         Counter ipRoutingDiscards;
 233 /*
 234  * following defined in MIB-II as part of TCP & UDP groups:
 235  */
 236                 /* total # of segments recv'd with error        { tcp 14 } */
 237         Counter tcpInErrs;
 238                 /* # of recv'd dg's not deliverable (no appl.)  { udp 2 } */
 239         Counter udpNoPorts;
 240 /*
 241  * In addition to MIB-II
 242  */
 243                 /* # of bad IP header checksums */
 244         Counter ipInCksumErrs;
 245                 /* # of complete duplicates in reassembly */
 246         Counter ipReasmDuplicates;
 247                 /* # of partial duplicates in reassembly */
 248         Counter ipReasmPartDups;
 249                 /* # of packets not forwarded due to adminstrative reasons */
 250         Counter ipForwProhibits;
 251                 /* # of UDP packets with bad UDP checksums */
 252         Counter udpInCksumErrs;
 253                 /* # of UDP packets droped due to queue overflow */
 254         Counter udpInOverflows;
 255                 /*
 256                  * # of RAW IP packets (all IP protocols except UDP, TCP
 257                  * and ICMP) droped due to queue overflow
 258                  */
 259         Counter rawipInOverflows;
 260
 261         /*
 262          * Folowing are private IPSEC MIB.
 263          */
 264         /* # of incoming packets that succeeded policy checks */
 265         Counter ipsecInSucceeded;
 266         /* # of incoming packets that failed policy checks */
 267         Counter ipsecInFailed;
 268 /* Compatible extensions added here */
 269         int     ipMemberEntrySize;      /* Size of ip_member_t */
 270         int     ipGroupSourceEntrySize; /* Size of ip_grpsrc_t */
 271
 272         Counter ipInIPv6; /* # of IPv6 packets received by IPv4 and dropped */
 273         Counter ipOutIPv6;              /* No longer used */
 274         Counter ipOutSwitchIPv6;        /* No longer used */
 275
 276         int     ipDestEntrySize;        /* Size of dest_cache_entry_t */
 277 } mib2_ip_t;
 278
 279 /*
 280  *      ipv6IfStatsEntry OBJECT-TYPE
 281  *              SYNTAX     Ipv6IfStatsEntry
 282  *              MAX-ACCESS not-accessible
 283  *              STATUS     current
 284  *              DESCRIPTION
 285  *                      "An interface statistics entry containing objects
 286  *                      at a particular IPv6 interface."
 287  *              AUGMENTS { ipv6IfEntry }
 288  *              ::= { ipv6IfStatsTable 1 }
 289  *
 290  * Per-interface IPv6 statistics table
 291  */
 292
 293 typedef struct mib2_ipv6IfStatsEntry {
 294         /* Local ifindex to identify the interface */
 295         DeviceIndex     ipv6IfIndex;
 296
 297                 /* forwarder?  1 gateway, 2 NOT gateway {ipv6MIBObjects 1} RW */
 298         int     ipv6Forwarding;
 299                 /* default Hoplimit for IPv6            {ipv6MIBObjects 2} RW */
 300         int     ipv6DefaultHopLimit;
 301
 302         int     ipv6IfStatsEntrySize;
 303         int     ipv6AddrEntrySize;
 304         int     ipv6RouteEntrySize;
 305         int     ipv6NetToMediaEntrySize;
 306         int     ipv6MemberEntrySize;            /* Size of ipv6_member_t */
 307         int     ipv6GroupSourceEntrySize;       /* Size of ipv6_grpsrc_t */
 308
 309         /* # input datagrams (incl errors)      { ipv6IfStatsEntry 1 } */
 310         Counter ipv6InReceives;
 311         /* # errors in IPv6 headers and options { ipv6IfStatsEntry 2 } */
 312         Counter ipv6InHdrErrors;
 313         /* # exceeds outgoing link MTU          { ipv6IfStatsEntry 3 } */
 314         Counter ipv6InTooBigErrors;
 315         /* # discarded due to no route to dest  { ipv6IfStatsEntry 4 } */
 316         Counter ipv6InNoRoutes;
 317         /* # invalid or unsupported addresses   { ipv6IfStatsEntry 5 } */
 318         Counter ipv6InAddrErrors;
 319         /* # unknown next header                { ipv6IfStatsEntry 6 } */
 320         Counter ipv6InUnknownProtos;
 321         /* # too short packets                  { ipv6IfStatsEntry 7 } */
 322         Counter ipv6InTruncatedPkts;
 323         /* # discarded e.g. due to no buffers   { ipv6IfStatsEntry 8 } */
 324         Counter ipv6InDiscards;
 325         /* # delivered to upper layer protocols { ipv6IfStatsEntry 9 } */
 326         Counter ipv6InDelivers;
 327         /* # forwarded out interface            { ipv6IfStatsEntry 10 } */
 328         Counter ipv6OutForwDatagrams;
 329         /* # originated out interface           { ipv6IfStatsEntry 11 } */
 330         Counter ipv6OutRequests;
 331         /* # discarded e.g. due to no buffers   { ipv6IfStatsEntry 12 } */
 332         Counter ipv6OutDiscards;
 333         /* # sucessfully fragmented packets     { ipv6IfStatsEntry 13 } */
 334         Counter ipv6OutFragOKs;
 335         /* # fragmentation failed               { ipv6IfStatsEntry 14 } */
 336         Counter ipv6OutFragFails;
 337         /* # fragments created                  { ipv6IfStatsEntry 15 } */
 338         Counter ipv6OutFragCreates;
 339         /* # fragments to reassemble            { ipv6IfStatsEntry 16 } */
 340         Counter ipv6ReasmReqds;
 341         /* # packets after reassembly           { ipv6IfStatsEntry 17 } */
 342         Counter ipv6ReasmOKs;
 343         /* # reassembly failed                  { ipv6IfStatsEntry 18 } */
 344         Counter ipv6ReasmFails;
 345         /* # received multicast packets         { ipv6IfStatsEntry 19 } */
 346         Counter ipv6InMcastPkts;
 347         /* # transmitted multicast packets      { ipv6IfStatsEntry 20 } */
 348         Counter ipv6OutMcastPkts;
 349 /*
 350  * In addition to defined MIBs
 351  */
 352                 /* # discarded due to no route to dest */
 353         Counter ipv6OutNoRoutes;
 354                 /* # of complete duplicates in reassembly */
 355         Counter ipv6ReasmDuplicates;
 356                 /* # of partial duplicates in reassembly */
 357         Counter ipv6ReasmPartDups;
 358                 /* # of packets not forwarded due to adminstrative reasons */
 359         Counter ipv6ForwProhibits;
 360                 /* # of UDP packets with bad UDP checksums */
 361         Counter udpInCksumErrs;
 362                 /* # of UDP packets droped due to queue overflow */
 363         Counter udpInOverflows;
 364                 /*
 365                  * # of RAW IPv6 packets (all IPv6 protocols except UDP, TCP
 366                  * and ICMPv6) droped due to queue overflow
 367                  */
 368         Counter rawipInOverflows;
 369
 370                 /* # of IPv4 packets received by IPv6 and dropped */
 371         Counter ipv6InIPv4;
 372                 /* # of IPv4 packets transmitted by ip_wput_wput */
 373         Counter ipv6OutIPv4;
 374                 /* # of times ip_wput_v6 has switched to become ip_wput */
 375         Counter ipv6OutSwitchIPv4;
 376 } mib2_ipv6IfStatsEntry_t;
 377
 378 /*
 379  * Per interface IP statistics, both v4 and v6.
 380  *
 381  * Some applications expect to get mib2_ipv6IfStatsEntry_t structs back when
 382  * making a request. To ensure backwards compatability, the first
 383  * sizeof(mib2_ipv6IfStatsEntry_t) bytes of the structure is identical to
 384  * mib2_ipv6IfStatsEntry_t. This should work as long the application is
 385  * written correctly (i.e., using ipv6IfStatsEntrySize to get the size of
 386  * the struct)
 387  *
 388  * RFC4293 introduces several new counters, as well as defining 64-bit
 389  * versions of existing counters. For a new counters, if they have both 32-
 390  * and 64-bit versions, then we only added the latter. However, for already
 391  * existing counters, we have added the 64-bit versions without removing the
 392  * old (32-bit) ones. The 64- and 32-bit counters will only be synchronized
 393  * when the structure contains IPv6 statistics, which is done to ensure
 394  * backwards compatibility.
 395  */
 396
 397 /* The following are defined in RFC 4001 and are used for ipIfStatsIPVersion */
 398 #define MIB2_INETADDRESSTYPE_unknown    0
 399 #define MIB2_INETADDRESSTYPE_ipv4       1
 400 #define MIB2_INETADDRESSTYPE_ipv6       2
 401
 402 /*
 403  * On amd64, the alignment requirements for long long's is different for
 404  * 32 and 64 bits. If we have a struct containing long long's that is being
 405  * passed between a 64-bit kernel to a 32-bit application, then it is very
 406  * likely that the size of the struct will differ due to padding. Therefore, we
 407  * pack the data to ensure that the struct size is the same for 32- and
 408  * 64-bits.
 409  */
 410 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
 411 #pragma pack(4)
 412 #endif
 413
 414 typedef struct mib2_ipIfStatsEntry {
 415
 416         /* Local ifindex to identify the interface */
 417         DeviceIndex     ipIfStatsIfIndex;
 418
 419         /* forwarder?  1 gateway, 2 NOT gateway { ipv6MIBObjects 1} RW */
 420         int     ipIfStatsForwarding;
 421         /* default Hoplimit for IPv6            { ipv6MIBObjects 2} RW */
 422         int     ipIfStatsDefaultHopLimit;
 423 #define ipIfStatsDefaultTTL     ipIfStatsDefaultHopLimit
 424
 425         int     ipIfStatsEntrySize;
 426         int     ipIfStatsAddrEntrySize;
 427         int     ipIfStatsRouteEntrySize;
 428         int     ipIfStatsNetToMediaEntrySize;
 429         int     ipIfStatsMemberEntrySize;
 430         int     ipIfStatsGroupSourceEntrySize;
 431
 432         /* # input datagrams (incl errors)      { ipIfStatsEntry 3 } */
 433         Counter ipIfStatsInReceives;
 434         /* # errors in IP headers and options   { ipIfStatsEntry 7 } */
 435         Counter ipIfStatsInHdrErrors;
 436         /* # exceeds outgoing link MTU(v6 only) { ipv6IfStatsEntry 3 } */
 437         Counter ipIfStatsInTooBigErrors;
 438         /* # discarded due to no route to dest  { ipIfStatsEntry 8 } */
 439         Counter ipIfStatsInNoRoutes;
 440         /* # invalid or unsupported addresses   { ipIfStatsEntry 9 } */
 441         Counter ipIfStatsInAddrErrors;
 442         /* # unknown next header                { ipIfStatsEntry 10 } */
 443         Counter ipIfStatsInUnknownProtos;
 444         /* # too short packets                  { ipIfStatsEntry 11 } */
 445         Counter ipIfStatsInTruncatedPkts;
 446         /* # discarded e.g. due to no buffers   { ipIfStatsEntry 17 } */
 447         Counter ipIfStatsInDiscards;
 448         /* # delivered to upper layer protocols { ipIfStatsEntry 18 } */
 449         Counter ipIfStatsInDelivers;
 450         /* # forwarded out interface            { ipIfStatsEntry 23 } */
 451         Counter ipIfStatsOutForwDatagrams;
 452         /* # originated out interface           { ipIfStatsEntry 20 } */
 453         Counter ipIfStatsOutRequests;
 454         /* # discarded e.g. due to no buffers   { ipIfStatsEntry 25 } */
 455         Counter ipIfStatsOutDiscards;
 456         /* # sucessfully fragmented packets     { ipIfStatsEntry 27 } */
 457         Counter ipIfStatsOutFragOKs;
 458         /* # fragmentation failed               { ipIfStatsEntry 28 } */
 459         Counter ipIfStatsOutFragFails;
 460         /* # fragments created                  { ipIfStatsEntry 29 } */
 461         Counter ipIfStatsOutFragCreates;
 462         /* # fragments to reassemble            { ipIfStatsEntry 14 } */
 463         Counter ipIfStatsReasmReqds;
 464         /* # packets after reassembly           { ipIfStatsEntry 15 } */
 465         Counter ipIfStatsReasmOKs;
 466         /* # reassembly failed                  { ipIfStatsEntry 16 } */
 467         Counter ipIfStatsReasmFails;
 468         /* # received multicast packets         { ipIfStatsEntry 34 } */
 469         Counter ipIfStatsInMcastPkts;
 470         /* # transmitted multicast packets      { ipIfStatsEntry 38 } */
 471         Counter ipIfStatsOutMcastPkts;
 472
 473         /*
 474          * In addition to defined MIBs
 475          */
 476
 477         /* # discarded due to no route to dest  { ipSystemStatsEntry 22 } */
 478         Counter ipIfStatsOutNoRoutes;
 479         /* # of complete duplicates in reassembly */
 480         Counter ipIfStatsReasmDuplicates;
 481         /* # of partial duplicates in reassembly */
 482         Counter ipIfStatsReasmPartDups;
 483         /* # of packets not forwarded due to adminstrative reasons */
 484         Counter ipIfStatsForwProhibits;
 485         /* # of UDP packets with bad UDP checksums */
 486         Counter udpInCksumErrs;
 487 #define udpIfStatsInCksumErrs   udpInCksumErrs
 488         /* # of UDP packets droped due to queue overflow */
 489         Counter udpInOverflows;
 490 #define udpIfStatsInOverflows   udpInOverflows
 491         /*
 492          * # of RAW IP packets (all IP protocols except UDP, TCP
 493          * and ICMP) droped due to queue overflow
 494          */
 495         Counter rawipInOverflows;
 496 #define rawipIfStatsInOverflows rawipInOverflows
 497
 498         /*
 499          * # of IP packets received with the wrong version (i.e., not equal
 500          * to ipIfStatsIPVersion) and that were dropped.
 501          */
 502         Counter ipIfStatsInWrongIPVersion;
 503         /*
 504          * This counter is no longer used
 505          */
 506         Counter ipIfStatsOutWrongIPVersion;
 507         /*
 508          * This counter is no longer used
 509          */
 510         Counter ipIfStatsOutSwitchIPVersion;
 511
 512         /*
 513          * Fields defined in RFC 4293
 514          */
 515
 516         /* ip version                           { ipIfStatsEntry 1 } */
 517         int             ipIfStatsIPVersion;
 518         /* # input datagrams (incl errors)      { ipIfStatsEntry 4 } */
 519         Counter64       ipIfStatsHCInReceives;
 520         /* # input octets (incl errors)         { ipIfStatsEntry 6 } */
 521         Counter64       ipIfStatsHCInOctets;
 522         /*
 523          *                                      { ipIfStatsEntry 13 }
 524          * # input datagrams for which a forwarding attempt was made
 525          */
 526         Counter64       ipIfStatsHCInForwDatagrams;
 527         /* # delivered to upper layer protocols { ipIfStatsEntry 19 } */
 528         Counter64       ipIfStatsHCInDelivers;
 529         /* # originated out interface           { ipIfStatsEntry 21 } */
 530         Counter64       ipIfStatsHCOutRequests;
 531         /* # forwarded out interface            { ipIfStatsEntry 23 } */
 532         Counter64       ipIfStatsHCOutForwDatagrams;
 533         /* # dg's requiring fragmentation       { ipIfStatsEntry 26 } */
 534         Counter         ipIfStatsOutFragReqds;
 535         /* # output datagrams                   { ipIfStatsEntry 31 } */
 536         Counter64       ipIfStatsHCOutTransmits;
 537         /* # output octets                      { ipIfStatsEntry 33 } */
 538         Counter64       ipIfStatsHCOutOctets;
 539         /* # received multicast datagrams       { ipIfStatsEntry 35 } */
 540         Counter64       ipIfStatsHCInMcastPkts;
 541         /* # received multicast octets          { ipIfStatsEntry 37 } */
 542         Counter64       ipIfStatsHCInMcastOctets;
 543         /* # transmitted multicast datagrams    { ipIfStatsEntry 39 } */
 544         Counter64       ipIfStatsHCOutMcastPkts;
 545         /* # transmitted multicast octets       { ipIfStatsEntry 41 } */
 546         Counter64       ipIfStatsHCOutMcastOctets;
 547         /* # received broadcast datagrams       { ipIfStatsEntry 43 } */
 548         Counter64       ipIfStatsHCInBcastPkts;
 549         /* # transmitted broadcast datagrams    { ipIfStatsEntry 45 } */
 550         Counter64       ipIfStatsHCOutBcastPkts;
 551
 552         /*
 553          * Fields defined in mib2_ip_t
 554          */
 555
 556         /* # of incoming packets that succeeded policy checks */
 557         Counter         ipsecInSucceeded;
 558 #define ipsecIfStatsInSucceeded ipsecInSucceeded
 559         /* # of incoming packets that failed policy checks */
 560         Counter         ipsecInFailed;
 561 #define ipsecIfStatsInFailed    ipsecInFailed
 562         /* # of bad IP header checksums */
 563         Counter         ipInCksumErrs;
 564 #define ipIfStatsInCksumErrs    ipInCksumErrs
 565         /* total # of segments recv'd with error        { tcp 14 } */
 566         Counter         tcpInErrs;
 567 #define tcpIfStatsInErrs        tcpInErrs
 568         /* # of recv'd dg's not deliverable (no appl.)  { udp 2 } */
 569         Counter         udpNoPorts;
 570 #define udpIfStatsNoPorts       udpNoPorts
 571 } mib2_ipIfStatsEntry_t;
 572 #define MIB_FIRST_NEW_ELM_mib2_ipIfStatsEntry_t ipIfStatsIPVersion
 573
 574 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
 575 #pragma pack()
 576 #endif
 577
 578 /*
 579  * The IP address table contains this entity's IP addressing information.
 580  *
 581  *      ipAddrTable OBJECT-TYPE
 582  *              SYNTAX  SEQUENCE OF IpAddrEntry
 583  *              ACCESS  not-accessible
 584  *              STATUS  mandatory
 585  *              DESCRIPTION
 586  *                      "The table of addressing information relevant to
 587  *                      this entity's IP addresses."
 588  *              ::= { ip 20 }
 589  */
 590
 591 typedef struct mib2_ipAddrEntry {
 592                         /* IP address of this entry     {ipAddrEntry 1} */
 593         IpAddress       ipAdEntAddr;
 594                         /* Unique interface index       {ipAddrEntry 2} */
 595         DeviceName      ipAdEntIfIndex;
 596                         /* Subnet mask for this IP addr {ipAddrEntry 3} */
 597         IpAddress       ipAdEntNetMask;
 598                         /* 2^lsb of IP broadcast addr   {ipAddrEntry 4} */
 599         int             ipAdEntBcastAddr;
 600                         /* max size for dg reassembly   {ipAddrEntry 5} */
 601         int             ipAdEntReasmMaxSize;
 602                         /* additional ipif_t fields */
 603         struct ipAdEntInfo_s {
 604                 Gauge           ae_mtu;
 605                                 /* BSD if metric */
 606                 int             ae_metric;
 607                                 /* ipif broadcast addr.  relation to above?? */
 608                 IpAddress       ae_broadcast_addr;
 609                                 /* point-point dest addr */
 610                 IpAddress       ae_pp_dst_addr;
 611                 int             ae_flags;       /* IFF_* flags in if.h */
 612                 Counter         ae_ibcnt;       /* Inbound packets */
 613                 Counter         ae_obcnt;       /* Outbound packets */
 614                 Counter         ae_focnt;       /* Forwarded packets */
 615                 IpAddress       ae_subnet;      /* Subnet prefix */
 616                 int             ae_subnet_len;  /* Subnet prefix length */
 617                 IpAddress       ae_src_addr;    /* Source address */
 618         }               ipAdEntInfo;
 619         uint32_t        ipAdEntRetransmitTime;  /* ipInterfaceRetransmitTime */
 620 } mib2_ipAddrEntry_t;
 621 #define MIB_FIRST_NEW_ELM_mib2_ipAddrEntry_t    ipAdEntRetransmitTime
 622
 623 /*
 624  *      ipv6AddrTable OBJECT-TYPE
 625  *              SYNTAX      SEQUENCE OF Ipv6AddrEntry
 626  *              MAX-ACCESS  not-accessible
 627  *              STATUS      current
 628  *              DESCRIPTION
 629  *                      "The table of addressing information relevant to
 630  *                      this node's interface addresses."
 631  *              ::= { ipv6MIBObjects 8 }
 632  */
 633
 634 typedef struct mib2_ipv6AddrEntry {
 635         /* Unique interface index                       { Part of INDEX } */
 636         DeviceName      ipv6AddrIfIndex;
 637
 638         /* IPv6 address of this entry                   { ipv6AddrEntry 1 } */
 639         Ip6Address      ipv6AddrAddress;
 640         /* Prefix length                                { ipv6AddrEntry 2 } */
 641         uint_t          ipv6AddrPfxLength;
 642         /* Type: stateless(1), stateful(2), unknown(3)  { ipv6AddrEntry 3 } */
 643         uint_t          ipv6AddrType;
 644         /* Anycast: true(1), false(2)                   { ipv6AddrEntry 4 } */
 645         uint_t          ipv6AddrAnycastFlag;
 646         /*
 647          * Address status: preferred(1), deprecated(2), invalid(3),
 648          * inaccessible(4), unknown(5)                  { ipv6AddrEntry 5 }
 649          */
 650         uint_t          ipv6AddrStatus;
 651         struct ipv6AddrInfo_s {
 652                 Gauge           ae_mtu;
 653                                 /* BSD if metric */
 654                 int             ae_metric;
 655                                 /* point-point dest addr */
 656                 Ip6Address      ae_pp_dst_addr;
 657                 int             ae_flags;       /* IFF_* flags in if.h */
 658                 Counter         ae_ibcnt;       /* Inbound packets */
 659                 Counter         ae_obcnt;       /* Outbound packets */
 660                 Counter         ae_focnt;       /* Forwarded packets */
 661                 Ip6Address      ae_subnet;      /* Subnet prefix */
 662                 int             ae_subnet_len;  /* Subnet prefix length */
 663                 Ip6Address      ae_src_addr;    /* Source address */
 664         }               ipv6AddrInfo;
 665         uint32_t        ipv6AddrReasmMaxSize;   /* InterfaceReasmMaxSize */
 666         Ip6Address      ipv6AddrIdentifier;     /* InterfaceIdentifier */
 667         uint32_t        ipv6AddrIdentifierLen;
 668         uint32_t        ipv6AddrReachableTime;  /* InterfaceReachableTime */
 669         uint32_t        ipv6AddrRetransmitTime; /* InterfaceRetransmitTime */
 670 } mib2_ipv6AddrEntry_t;
 671 #define MIB_FIRST_NEW_ELM_mib2_ipv6AddrEntry_t  ipv6AddrReasmMaxSize
 672
 673 /*
 674  * The IP routing table contains an entry for each route presently known to
 675  * this entity. (for IPv4 routes)
 676  *
 677  *      ipRouteTable OBJECT-TYPE
 678  *              SYNTAX  SEQUENCE OF IpRouteEntry
 679  *              ACCESS  not-accessible
 680  *              STATUS  mandatory
 681  *              DESCRIPTION
 682  *                      "This entity's IP Routing table."
 683  *              ::= { ip 21 }
 684  */
 685
 686 typedef struct mib2_ipRouteEntry {
 687                 /* dest ip addr for this route          {ipRouteEntry 1 } RW */
 688         IpAddress       ipRouteDest;
 689                 /* unique interface index for this hop  {ipRouteEntry 2 } RW */
 690         DeviceName      ipRouteIfIndex;
 691                 /* primary route metric                 {ipRouteEntry 3 } RW */
 692         int             ipRouteMetric1;
 693                 /* alternate route metric               {ipRouteEntry 4 } RW */
 694         int             ipRouteMetric2;
 695                 /* alternate route metric               {ipRouteEntry 5 } RW */
 696         int             ipRouteMetric3;
 697                 /* alternate route metric               {ipRouteEntry 6 } RW */
 698         int             ipRouteMetric4;
 699                 /* ip addr of next hop on this route    {ipRouteEntry 7 } RW */
 700         IpAddress       ipRouteNextHop;
 701                 /* other(1), inval(2), dir(3), indir(4) {ipRouteEntry 8 } RW */
 702         int             ipRouteType;
 703                 /* mechanism by which route was learned {ipRouteEntry 9 } */
 704         int             ipRouteProto;
 705                 /* sec's since last update of route     {ipRouteEntry 10} RW */
 706         int             ipRouteAge;
 707                 /*                                      {ipRouteEntry 11} RW */
 708         IpAddress       ipRouteMask;
 709                 /* alternate route metric               {ipRouteEntry 12} RW */
 710         int             ipRouteMetric5;
 711                 /* additional info from ire's           {ipRouteEntry 13 } */
 712         struct ipRouteInfo_s {
 713                 Gauge           re_max_frag;
 714                 Gauge           re_rtt;
 715                 Counter         re_ref;
 716                 int             re_frag_flag;
 717                 IpAddress       re_src_addr;
 718                 int             re_ire_type;
 719                 Counter         re_obpkt;
 720                 Counter         re_ibpkt;
 721                 int             re_flags;
 722                 /*
 723                  * The following two elements (re_in_ill and re_in_src_addr)
 724                  * are no longer used but are left here for the benefit of
 725                  * old Apps that won't be able to handle the change in the
 726                  * size of this struct. These elements will always be
 727                  * set to zeroes.
 728                  */
 729                 DeviceName      re_in_ill;      /* Input interface */
 730                 IpAddress       re_in_src_addr; /* Input source address */
 731         }               ipRouteInfo;
 732 } mib2_ipRouteEntry_t;
 733
 734 /*
 735  * The IPv6 routing table contains an entry for each route presently known to
 736  * this entity.
 737  *
 738  *      ipv6RouteTable OBJECT-TYPE
 739  *              SYNTAX  SEQUENCE OF IpRouteEntry
 740  *              ACCESS  not-accessible
 741  *              STATUS  current
 742  *              DESCRIPTION
 743  *                      "IPv6 Routing table. This table contains
 744  *                      an entry for each valid IPv6 unicast route
 745  *                      that can be used for packet forwarding
 746  *                      determination."
 747  *              ::= { ipv6MIBObjects 11 }
 748  */
 749
 750 typedef struct mib2_ipv6RouteEntry {
 751                 /* dest ip addr for this route          { ipv6RouteEntry 1 } */
 752         Ip6Address      ipv6RouteDest;
 753                 /* prefix length                        { ipv6RouteEntry 2 } */
 754         int             ipv6RoutePfxLength;
 755                 /* unique route index                   { ipv6RouteEntry 3 } */
 756         unsigned        ipv6RouteIndex;
 757                 /* unique interface index for this hop  { ipv6RouteEntry 4 } */
 758         DeviceName      ipv6RouteIfIndex;
 759                 /* IPv6 addr of next hop on this route  { ipv6RouteEntry 5 } */
 760         Ip6Address      ipv6RouteNextHop;
 761                 /* other(1), discard(2), local(3), remote(4) */
 762                 /*                                      { ipv6RouteEntry 6 } */
 763         int             ipv6RouteType;
 764                 /* mechanism by which route was learned { ipv6RouteEntry 7 } */
 765                 /*
 766                  * other(1), local(2), netmgmt(3), ndisc(4), rip(5), ospf(6),
 767                  * bgp(7), idrp(8), igrp(9)
 768                  */
 769         int             ipv6RouteProtocol;
 770                 /* policy hook or traffic class         { ipv6RouteEntry 8 } */
 771         unsigned        ipv6RoutePolicy;
 772                 /* sec's since last update of route     { ipv6RouteEntry 9} */
 773         int             ipv6RouteAge;
 774                 /* Routing domain ID of the next hop    { ipv6RouteEntry 10 } */
 775         unsigned        ipv6RouteNextHopRDI;
 776                 /* route metric                         { ipv6RouteEntry 11 } */
 777         unsigned        ipv6RouteMetric;
 778                 /* preference (impl specific)           { ipv6RouteEntry 12 } */
 779         unsigned        ipv6RouteWeight;
 780                 /* additional info from ire's           { } */
 781         struct ipv6RouteInfo_s {
 782                 Gauge           re_max_frag;
 783                 Gauge           re_rtt;
 784                 Counter         re_ref;
 785                 int             re_frag_flag;
 786                 Ip6Address      re_src_addr;
 787                 int             re_ire_type;
 788                 Counter         re_obpkt;
 789                 Counter         re_ibpkt;
 790                 int             re_flags;
 791         }               ipv6RouteInfo;
 792 } mib2_ipv6RouteEntry_t;
 793
 794 /*
 795  * The IP address translation table contain the IpAddress to
 796  * `physical' address equivalences.  Some interfaces do not
 797  * use translation tables for determining address
 798  * equivalences (e.g., DDN-X.25 has an algorithmic method);
 799  * if all interfaces are of this type, then the Address
 800  * Translation table is empty, i.e., has zero entries.
 801  *
 802  *      ipNetToMediaTable OBJECT-TYPE
 803  *              SYNTAX  SEQUENCE OF IpNetToMediaEntry
 804  *              ACCESS  not-accessible
 805  *              STATUS  mandatory
 806  *              DESCRIPTION
 807  *                      "The IP Address Translation table used for mapping
 808  *                      from IP addresses to physical addresses."
 809  *              ::= { ip 22 }
 810  */
 811
 812 typedef struct mib2_ipNetToMediaEntry {
 813         /* Unique interface index               { ipNetToMediaEntry 1 } RW */
 814         DeviceName      ipNetToMediaIfIndex;
 815         /* Media dependent physical addr        { ipNetToMediaEntry 2 } RW */
 816         PhysAddress     ipNetToMediaPhysAddress;
 817         /* ip addr for this physical addr       { ipNetToMediaEntry 3 } RW */
 818         IpAddress       ipNetToMediaNetAddress;
 819         /* other(1), inval(2), dyn(3), stat(4)  { ipNetToMediaEntry 4 } RW */
 820         int             ipNetToMediaType;
 821         struct ipNetToMediaInfo_s {
 822                 PhysAddress     ntm_mask;       /* subnet mask for entry */
 823                 int             ntm_flags;      /* ACE_F_* flags in arp.h */
 824         }               ipNetToMediaInfo;
 825 } mib2_ipNetToMediaEntry_t;
 826
 827 /*
 828  *      ipv6NetToMediaTable OBJECT-TYPE
 829  *               SYNTAX      SEQUENCE OF Ipv6NetToMediaEntry
 830  *               MAX-ACCESS  not-accessible
 831  *               STATUS      current
 832  *               DESCRIPTION
 833  *                      "The IPv6 Address Translation table used for
 834  *                      mapping from IPv6 addresses to physical addresses.
 835  *
 836  *                      The IPv6 address translation table contain the
 837  *                      Ipv6Address to `physical' address equivalencies.
 838  *                      Some interfaces do not use translation tables
 839  *                      for determining address equivalencies; if all
 840  *                      interfaces are of this type, then the Address
 841  *                      Translation table is empty, i.e., has zero
 842  *                      entries."
 843  *              ::= { ipv6MIBObjects 12 }
 844  */
 845
 846 typedef struct mib2_ipv6NetToMediaEntry {
 847         /* Unique interface index               { Part of INDEX } */
 848         DeviceIndex     ipv6NetToMediaIfIndex;
 849
 850         /* ip addr for this physical addr       { ipv6NetToMediaEntry 1 } */
 851         Ip6Address      ipv6NetToMediaNetAddress;
 852         /* Media dependent physical addr        { ipv6NetToMediaEntry 2 } */
 853         PhysAddress     ipv6NetToMediaPhysAddress;
 854         /*
 855          * Type of mapping
 856          * other(1), dynamic(2), static(3), local(4)
 857          *                                      { ipv6NetToMediaEntry 3 }
 858          */
 859         int             ipv6NetToMediaType;
 860         /*
 861          * NUD state
 862          * reachable(1), stale(2), delay(3), probe(4), invalid(5), unknown(6)
 863          * Note: The kernel returns ND_* states.
 864          *                                      { ipv6NetToMediaEntry 4 }
 865          */
 866         int             ipv6NetToMediaState;
 867         /* sysUpTime last time entry was updated { ipv6NetToMediaEntry 5 } */
 868         int             ipv6NetToMediaLastUpdated;
 869 } mib2_ipv6NetToMediaEntry_t;
 870
 871
 872 /*
 873  * List of group members per interface
 874  */
 875 typedef struct ip_member {
 876         /* Interface index */
 877         DeviceName      ipGroupMemberIfIndex;
 878         /* IP Multicast address */
 879         IpAddress       ipGroupMemberAddress;
 880         /* Number of member sockets */
 881         Counter         ipGroupMemberRefCnt;
 882         /* Filter mode: 1 => include, 2 => exclude */
 883         int             ipGroupMemberFilterMode;
 884 } ip_member_t;
 885
 886
 887 /*
 888  * List of IPv6 group members per interface
 889  */
 890 typedef struct ipv6_member {
 891         /* Interface index */
 892         DeviceIndex     ipv6GroupMemberIfIndex;
 893         /* IP Multicast address */
 894         Ip6Address      ipv6GroupMemberAddress;
 895         /* Number of member sockets */
 896         Counter         ipv6GroupMemberRefCnt;
 897         /* Filter mode: 1 => include, 2 => exclude */
 898         int             ipv6GroupMemberFilterMode;
 899 } ipv6_member_t;
 900
 901 /*
 902  * List of IPv4 source addresses being filtered per interface
 903  */
 904 typedef struct ip_grpsrc {
 905         /* Interface index */
 906         DeviceName      ipGroupSourceIfIndex;
 907         /* IP Multicast address */
 908         IpAddress       ipGroupSourceGroup;
 909         /* IP Source address */
 910         IpAddress       ipGroupSourceAddress;
 911 } ip_grpsrc_t;
 912
 913
 914 /*
 915  * List of IPv6 source addresses being filtered per interface
 916  */
 917 typedef struct ipv6_grpsrc {
 918         /* Interface index */
 919         DeviceIndex     ipv6GroupSourceIfIndex;
 920         /* IP Multicast address */
 921         Ip6Address      ipv6GroupSourceGroup;
 922         /* IP Source address */
 923         Ip6Address      ipv6GroupSourceAddress;
 924 } ipv6_grpsrc_t;
 925
 926
 927 /*
 928  * List of destination cache entries
 929  */
 930 typedef struct dest_cache_entry {
 931         /* IP Multicast address */
 932         IpAddress       DestIpv4Address;
 933         Ip6Address      DestIpv6Address;
 934         uint_t          DestFlags;      /* DCEF_* */
 935         uint32_t        DestPmtu;       /* Path MTU if DCEF_PMTU */
 936         uint32_t        DestIdent;      /* Per destination IP ident. */
 937         DeviceIndex     DestIfindex;    /* For IPv6 link-locals */
 938         uint32_t        DestAge;        /* Age of MTU info in seconds */
 939 } dest_cache_entry_t;
 940
 941
 942 /*
 943  * ICMP Group
 944  */
 945 typedef struct mib2_icmp {
 946         /* total # of recv'd ICMP msgs                  { icmp 1 } */
 947         Counter icmpInMsgs;
 948         /* recv'd ICMP msgs with errors                 { icmp 2 } */
 949         Counter icmpInErrors;
 950         /* recv'd "dest unreachable" msg's              { icmp 3 } */
 951         Counter icmpInDestUnreachs;
 952         /* recv'd "time exceeded" msg's                 { icmp 4 } */
 953         Counter icmpInTimeExcds;
 954         /* recv'd "parameter problem" msg's             { icmp 5 } */
 955         Counter icmpInParmProbs;
 956         /* recv'd "source quench" msg's                 { icmp 6 } */
 957         Counter icmpInSrcQuenchs;
 958         /* recv'd "ICMP redirect" msg's                 { icmp 7 } */
 959         Counter icmpInRedirects;
 960         /* recv'd "echo request" msg's                  { icmp 8 } */
 961         Counter icmpInEchos;
 962         /* recv'd "echo reply" msg's                    { icmp 9 } */
 963         Counter icmpInEchoReps;
 964         /* recv'd "timestamp" msg's                     { icmp 10 } */
 965         Counter icmpInTimestamps;
 966         /* recv'd "timestamp reply" msg's               { icmp 11 } */
 967         Counter icmpInTimestampReps;
 968         /* recv'd "address mask request" msg's          { icmp 12 } */
 969         Counter icmpInAddrMasks;
 970         /* recv'd "address mask reply" msg's            { icmp 13 } */
 971         Counter icmpInAddrMaskReps;
 972         /* total # of sent ICMP msg's                   { icmp 14 } */
 973         Counter icmpOutMsgs;
 974         /* # of msg's not sent for internal icmp errors { icmp 15 } */
 975         Counter icmpOutErrors;
 976         /* # of "dest unreachable" msg's sent           { icmp 16 } */
 977         Counter icmpOutDestUnreachs;
 978         /* # of "time exceeded" msg's sent              { icmp 17 } */
 979         Counter icmpOutTimeExcds;
 980         /* # of "parameter problme" msg's sent          { icmp 18 } */
 981         Counter icmpOutParmProbs;
 982         /* # of "source quench" msg's sent              { icmp 19 } */
 983         Counter icmpOutSrcQuenchs;
 984         /* # of "ICMP redirect" msg's sent              { icmp 20 } */
 985         Counter icmpOutRedirects;
 986         /* # of "Echo request" msg's sent               { icmp 21 } */
 987         Counter icmpOutEchos;
 988         /* # of "Echo reply" msg's sent                 { icmp 22 } */
 989         Counter icmpOutEchoReps;
 990         /* # of "timestamp request" msg's sent          { icmp 23 } */
 991         Counter icmpOutTimestamps;
 992         /* # of "timestamp reply" msg's sent            { icmp 24 } */
 993         Counter icmpOutTimestampReps;
 994         /* # of "address mask request" msg's sent       { icmp 25 } */
 995         Counter icmpOutAddrMasks;
 996         /* # of "address mask reply" msg's sent         { icmp 26 } */
 997         Counter icmpOutAddrMaskReps;
 998 /*
 999  * In addition to MIB-II
1000  */
1001         /* # of received packets with checksum errors */
1002         Counter icmpInCksumErrs;
1003         /* # of received packets with unknow codes */
1004         Counter icmpInUnknowns;
1005         /* # of received unreachables with "fragmentation needed" */
1006         Counter icmpInFragNeeded;
1007         /* # of sent unreachables with "fragmentation needed" */
1008         Counter icmpOutFragNeeded;
1009         /*
1010          * # of msg's not sent since original packet was broadcast/multicast
1011          * or an ICMP error packet
1012          */
1013         Counter icmpOutDrops;
1014         /* # of ICMP packets droped due to queue overflow */
1015         Counter icmpInOverflows;
1016         /* recv'd "ICMP redirect" msg's that are bad thus ignored */
1017         Counter icmpInBadRedirects;
1018 } mib2_icmp_t;
1019
1020
1021 /*
1022  *      ipv6IfIcmpEntry OBJECT-TYPE
1023  *              SYNTAX      Ipv6IfIcmpEntry
1024  *              MAX-ACCESS  not-accessible
1025  *              STATUS      current
1026  *              DESCRIPTION
1027  *                      "An ICMPv6 statistics entry containing
1028  *                      objects at a particular IPv6 interface.
1029  *
1030  *                      Note that a receiving interface is
1031  *                      the interface to which a given ICMPv6 message
1032  *                      is addressed which may not be necessarily
1033  *                      the input interface for the message.
1034  *
1035  *                      Similarly, the sending interface is
1036  *                      the interface that sources a given
1037  *                      ICMP message which is usually but not
1038  *                      necessarily the output interface for the message."
1039  *              AUGMENTS { ipv6IfEntry }
1040  *              ::= { ipv6IfIcmpTable 1 }
1041  *
1042  * Per-interface ICMPv6 statistics table
1043  */
1044
1045 typedef struct mib2_ipv6IfIcmpEntry {
1046         /* Local ifindex to identify the interface */
1047         DeviceIndex     ipv6IfIcmpIfIndex;
1048
1049         int             ipv6IfIcmpEntrySize;    /* Size of ipv6IfIcmpEntry */
1050
1051         /* The total # ICMP msgs rcvd includes ipv6IfIcmpInErrors */
1052         Counter32       ipv6IfIcmpInMsgs;
1053         /* # ICMP with ICMP-specific errors (bad checkum, length, etc) */
1054         Counter32       ipv6IfIcmpInErrors;
1055         /* # ICMP Destination Unreachable */
1056         Counter32       ipv6IfIcmpInDestUnreachs;
1057         /* # ICMP destination unreachable/communication admin prohibited */
1058         Counter32       ipv6IfIcmpInAdminProhibs;
1059         Counter32       ipv6IfIcmpInTimeExcds;
1060         Counter32       ipv6IfIcmpInParmProblems;
1061         Counter32       ipv6IfIcmpInPktTooBigs;
1062         Counter32       ipv6IfIcmpInEchos;
1063         Counter32       ipv6IfIcmpInEchoReplies;
1064         Counter32       ipv6IfIcmpInRouterSolicits;
1065         Counter32       ipv6IfIcmpInRouterAdvertisements;
1066         Counter32       ipv6IfIcmpInNeighborSolicits;
1067         Counter32       ipv6IfIcmpInNeighborAdvertisements;
1068         Counter32       ipv6IfIcmpInRedirects;
1069         Counter32       ipv6IfIcmpInGroupMembQueries;
1070         Counter32       ipv6IfIcmpInGroupMembResponses;
1071         Counter32       ipv6IfIcmpInGroupMembReductions;
1072         /* Total # ICMP messages attempted to send (includes OutErrors) */
1073         Counter32       ipv6IfIcmpOutMsgs;
1074         /* # ICMP messages not sent due to ICMP problems (e.g. no buffers) */
1075         Counter32       ipv6IfIcmpOutErrors;
1076         Counter32       ipv6IfIcmpOutDestUnreachs;
1077         Counter32       ipv6IfIcmpOutAdminProhibs;
1078         Counter32       ipv6IfIcmpOutTimeExcds;
1079         Counter32       ipv6IfIcmpOutParmProblems;
1080         Counter32       ipv6IfIcmpOutPktTooBigs;
1081         Counter32       ipv6IfIcmpOutEchos;
1082         Counter32       ipv6IfIcmpOutEchoReplies;
1083         Counter32       ipv6IfIcmpOutRouterSolicits;
1084         Counter32       ipv6IfIcmpOutRouterAdvertisements;
1085         Counter32       ipv6IfIcmpOutNeighborSolicits;
1086         Counter32       ipv6IfIcmpOutNeighborAdvertisements;
1087         Counter32       ipv6IfIcmpOutRedirects;
1088         Counter32       ipv6IfIcmpOutGroupMembQueries;
1089         Counter32       ipv6IfIcmpOutGroupMembResponses;
1090         Counter32       ipv6IfIcmpOutGroupMembReductions;
1091 /* Additions beyond the MIB */
1092         Counter32       ipv6IfIcmpInOverflows;
1093         /* recv'd "ICMPv6 redirect" msg's that are bad thus ignored */
1094         Counter32       ipv6IfIcmpBadHoplimit;
1095         Counter32       ipv6IfIcmpInBadNeighborAdvertisements;
1096         Counter32       ipv6IfIcmpInBadNeighborSolicitations;
1097         Counter32       ipv6IfIcmpInBadRedirects;
1098         Counter32       ipv6IfIcmpInGroupMembTotal;
1099         Counter32       ipv6IfIcmpInGroupMembBadQueries;
1100         Counter32       ipv6IfIcmpInGroupMembBadReports;
1101         Counter32       ipv6IfIcmpInGroupMembOurReports;
1102 } mib2_ipv6IfIcmpEntry_t;
1103
1104 /*
1105  * the TCP group
1106  *
1107  * Note that instances of object types that represent
1108  * information about a particular TCP connection are
1109  * transient; they persist only as long as the connection
1110  * in question.
1111  */
1112 #define MIB2_TCP_CONN   13      /* tcpConnEntry */
1113 #define MIB2_TCP6_CONN  14      /* tcp6ConnEntry */
1114
1115 /* Old name retained for compatibility */
1116 #define MIB2_TCP_13     MIB2_TCP_CONN
1117
1118 /* Pack data in mib2_tcp to make struct size the same for 32- and 64-bits */
1119 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1120 #pragma pack(4)
1121 #endif
1122 typedef struct mib2_tcp {
1123                 /* algorithm used for transmit timeout value    { tcp 1 } */
1124         int     tcpRtoAlgorithm;
1125                 /* minimum retransmit timeout (ms)              { tcp 2 } */
1126         int     tcpRtoMin;
1127                 /* maximum retransmit timeout (ms)              { tcp 3 } */
1128         int     tcpRtoMax;
1129                 /* maximum # of connections supported           { tcp 4 } */
1130         int     tcpMaxConn;
1131                 /* # of direct transitions CLOSED -> SYN-SENT   { tcp 5 } */
1132         Counter tcpActiveOpens;
1133                 /* # of direct transitions LISTEN -> SYN-RCVD   { tcp 6 } */
1134         Counter tcpPassiveOpens;
1135                 /* # of direct SIN-SENT/RCVD -> CLOSED/LISTEN   { tcp 7 } */
1136         Counter tcpAttemptFails;
1137                 /* # of direct ESTABLISHED/CLOSE-WAIT -> CLOSED { tcp 8 } */
1138         Counter tcpEstabResets;
1139                 /* # of connections ESTABLISHED or CLOSE-WAIT   { tcp 9 } */
1140         Gauge   tcpCurrEstab;
1141                 /* total # of segments recv'd                   { tcp 10 } */
1142         Counter tcpInSegs;
1143                 /* total # of segments sent                     { tcp 11 } */
1144         Counter tcpOutSegs;
1145                 /* total # of segments retransmitted            { tcp 12 } */
1146         Counter tcpRetransSegs;
1147                 /* {tcp 13} */
1148         int     tcpConnTableSize;       /* Size of tcpConnEntry_t */
1149         /* in ip                                {tcp 14} */
1150                 /* # of segments sent with RST flag             { tcp 15 } */
1151         Counter tcpOutRsts;
1152 /* In addition to MIB-II */
1153 /* Sender */
1154         /* total # of data segments sent */
1155         Counter tcpOutDataSegs;
1156         /* total # of bytes in data segments sent */
1157         Counter tcpOutDataBytes;
1158         /* total # of bytes in segments retransmitted */
1159         Counter tcpRetransBytes;
1160         /* total # of acks sent */
1161         Counter tcpOutAck;
1162         /* total # of delayed acks sent */
1163         Counter tcpOutAckDelayed;
1164         /* total # of segments sent with the urg flag on */
1165         Counter tcpOutUrg;
1166         /* total # of window updates sent */
1167         Counter tcpOutWinUpdate;
1168         /* total # of zero window probes sent */
1169         Counter tcpOutWinProbe;
1170         /* total # of control segments sent (syn, fin, rst) */
1171         Counter tcpOutControl;
1172         /* total # of segments sent due to "fast retransmit" */
1173         Counter tcpOutFastRetrans;
1174 /* Receiver */
1175         /* total # of ack segments received */
1176         Counter tcpInAckSegs;
1177         /* total # of bytes acked */
1178         Counter tcpInAckBytes;
1179         /* total # of duplicate acks */
1180         Counter tcpInDupAck;
1181         /* total # of acks acking unsent data */
1182         Counter tcpInAckUnsent;
1183         /* total # of data segments received in order */
1184         Counter tcpInDataInorderSegs;
1185         /* total # of data bytes received in order */
1186         Counter tcpInDataInorderBytes;
1187         /* total # of data segments received out of order */
1188         Counter tcpInDataUnorderSegs;
1189         /* total # of data bytes received out of order */
1190         Counter tcpInDataUnorderBytes;
1191         /* total # of complete duplicate data segments received */
1192         Counter tcpInDataDupSegs;
1193         /* total # of bytes in the complete duplicate data segments received */
1194         Counter tcpInDataDupBytes;
1195         /* total # of partial duplicate data segments received */
1196         Counter tcpInDataPartDupSegs;
1197         /* total # of bytes in the partial duplicate data segments received */
1198         Counter tcpInDataPartDupBytes;
1199         /* total # of data segments received past the window */
1200         Counter tcpInDataPastWinSegs;
1201         /* total # of data bytes received part the window */
1202         Counter tcpInDataPastWinBytes;
1203         /* total # of zero window probes received */
1204         Counter tcpInWinProbe;
1205         /* total # of window updates received */
1206         Counter tcpInWinUpdate;
1207         /* total # of data segments received after the connection has closed */
1208         Counter tcpInClosed;
1209 /* Others */
1210         /* total # of failed attempts to update the rtt estimate */
1211         Counter tcpRttNoUpdate;
1212         /* total # of successful attempts to update the rtt estimate */
1213         Counter tcpRttUpdate;
1214         /* total # of retransmit timeouts */
1215         Counter tcpTimRetrans;
1216         /* total # of retransmit timeouts dropping the connection */
1217         Counter tcpTimRetransDrop;
1218         /* total # of keepalive timeouts */
1219         Counter tcpTimKeepalive;
1220         /* total # of keepalive timeouts sending a probe */
1221         Counter tcpTimKeepaliveProbe;
1222         /* total # of keepalive timeouts dropping the connection */
1223         Counter tcpTimKeepaliveDrop;
1224         /* total # of connections refused due to backlog full on listen */
1225         Counter tcpListenDrop;
1226         /* total # of connections refused due to half-open queue (q0) full */
1227         Counter tcpListenDropQ0;
1228         /* total # of connections dropped from a full half-open queue (q0) */
1229         Counter tcpHalfOpenDrop;
1230         /* total # of retransmitted segments by SACK retransmission */
1231         Counter tcpOutSackRetransSegs;
1232
1233         int     tcp6ConnTableSize;      /* Size of tcp6ConnEntry_t */
1234
1235         /*
1236          * fields from RFC 4022
1237          */
1238
1239         /* total # of segments recv'd                           { tcp 17 } */
1240         Counter64       tcpHCInSegs;
1241         /* total # of segments sent                             { tcp 18 } */
1242         Counter64       tcpHCOutSegs;
1243 } mib2_tcp_t;
1244 #define MIB_FIRST_NEW_ELM_mib2_tcp_t    tcpHCInSegs
1245
1246 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1247 #pragma pack()
1248 #endif
1249
1250 /*
1251  * The TCP/IPv4 connection table {tcp 13} contains information about this
1252  * entity's existing TCP connections over IPv4.
1253  */
1254 /* For tcpConnState and tcp6ConnState */
1255 #define MIB2_TCP_closed         1
1256 #define MIB2_TCP_listen         2
1257 #define MIB2_TCP_synSent        3
1258 #define MIB2_TCP_synReceived    4
1259 #define MIB2_TCP_established    5
1260 #define MIB2_TCP_finWait1       6
1261 #define MIB2_TCP_finWait2       7
1262 #define MIB2_TCP_closeWait      8
1263 #define MIB2_TCP_lastAck        9
1264 #define MIB2_TCP_closing        10
1265 #define MIB2_TCP_timeWait       11
1266 #define MIB2_TCP_deleteTCB      12              /* only writeable value */
1267
1268 /* Pack data to make struct size the same for 32- and 64-bits */
1269 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1270 #pragma pack(4)
1271 #endif
1272 typedef struct mib2_tcpConnEntry {
1273                 /* state of tcp connection              { tcpConnEntry 1} RW */
1274         int             tcpConnState;
1275                 /* local ip addr for this connection    { tcpConnEntry 2 } */
1276         IpAddress       tcpConnLocalAddress;
1277                 /* local port for this connection       { tcpConnEntry 3 } */
1278         int             tcpConnLocalPort;       /* In host byte order */
1279                 /* remote ip addr for this connection   { tcpConnEntry 4 } */
1280         IpAddress       tcpConnRemAddress;
1281                 /* remote port for this connection      { tcpConnEntry 5 } */
1282         int             tcpConnRemPort;         /* In host byte order */
1283         struct tcpConnEntryInfo_s {
1284                         /* seq # of next segment to send */
1285                 Gauge           ce_snxt;
1286                                 /* seq # of of last segment unacknowledged */
1287                 Gauge           ce_suna;
1288                                 /* currect send window size */
1289                 Gauge           ce_swnd;
1290                                 /* seq # of next expected segment */
1291                 Gauge           ce_rnxt;
1292                                 /* seq # of last ack'd segment */
1293                 Gauge           ce_rack;
1294                                 /* currenct receive window size */
1295                 Gauge           ce_rwnd;
1296                                         /* current rto (retransmit timeout) */
1297                 Gauge           ce_rto;
1298                                         /* current max segment size */
1299                 Gauge           ce_mss;
1300                                 /* actual internal state */
1301                 int             ce_state;
1302         }               tcpConnEntryInfo;
1303
1304         /* pid of the processes that created this connection */
1305         uint32_t        tcpConnCreationProcess;
1306         /* system uptime when the connection was created */
1307         uint64_t        tcpConnCreationTime;
1308 } mib2_tcpConnEntry_t;
1309 #define MIB_FIRST_NEW_ELM_mib2_tcpConnEntry_t   tcpConnCreationProcess
1310
1311 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1312 #pragma pack()
1313 #endif
1314
1315
1316 /*
1317  * The TCP/IPv6 connection table {tcp 14} contains information about this
1318  * entity's existing TCP connections over IPv6.
1319  */
1320
1321 /* Pack data to make struct size the same for 32- and 64-bits */
1322 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1323 #pragma pack(4)
1324 #endif
1325 typedef struct mib2_tcp6ConnEntry {
1326         /* local ip addr for this connection    { ipv6TcpConnEntry 1 } */
1327         Ip6Address      tcp6ConnLocalAddress;
1328         /* local port for this connection       { ipv6TcpConnEntry 2 } */
1329         int             tcp6ConnLocalPort;
1330         /* remote ip addr for this connection   { ipv6TcpConnEntry 3 } */
1331         Ip6Address      tcp6ConnRemAddress;
1332         /* remote port for this connection      { ipv6TcpConnEntry 4 } */
1333         int             tcp6ConnRemPort;
1334         /* interface index or zero              { ipv6TcpConnEntry 5 } */
1335         DeviceIndex     tcp6ConnIfIndex;
1336         /* state of tcp6 connection             { ipv6TcpConnEntry 6 } RW */
1337         int             tcp6ConnState;
1338         struct tcp6ConnEntryInfo_s {
1339                         /* seq # of next segment to send */
1340                 Gauge           ce_snxt;
1341                                 /* seq # of of last segment unacknowledged */
1342                 Gauge           ce_suna;
1343                                 /* currect send window size */
1344                 Gauge           ce_swnd;
1345                                 /* seq # of next expected segment */
1346                 Gauge           ce_rnxt;
1347                                 /* seq # of last ack'd segment */
1348                 Gauge           ce_rack;
1349                                 /* currenct receive window size */
1350                 Gauge           ce_rwnd;
1351                                         /* current rto (retransmit timeout) */
1352                 Gauge           ce_rto;
1353                                         /* current max segment size */
1354                 Gauge           ce_mss;
1355                                 /* actual internal state */
1356                 int             ce_state;
1357         }               tcp6ConnEntryInfo;
1358
1359         /* pid of the processes that created this connection */
1360         uint32_t        tcp6ConnCreationProcess;
1361         /* system uptime when the connection was created */
1362         uint64_t        tcp6ConnCreationTime;
1363 } mib2_tcp6ConnEntry_t;
1364 #define MIB_FIRST_NEW_ELM_mib2_tcp6ConnEntry_t  tcp6ConnCreationProcess
1365
1366 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1367 #pragma pack()
1368 #endif
1369
1370 /*
1371  * the UDP group
1372  */
1373 #define MIB2_UDP_ENTRY  5       /* udpEntry */
1374 #define MIB2_UDP6_ENTRY 6       /* udp6Entry */
1375
1376 /* Old name retained for compatibility */
1377 #define MIB2_UDP_5      MIB2_UDP_ENTRY
1378
1379 /* Pack data to make struct size the same for 32- and 64-bits */
1380 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1381 #pragma pack(4)
1382 #endif
1383 typedef struct mib2_udp {
1384                 /* total # of UDP datagrams sent upstream       { udp 1 } */
1385         Counter udpInDatagrams;
1386         /* in ip                                { udp 2 } */
1387                 /* # of recv'd dg's not deliverable (other)     { udp 3 }  */
1388         Counter udpInErrors;
1389                 /* total # of dg's sent                         { udp 4 } */
1390         Counter udpOutDatagrams;
1391                 /* { udp 5 } */
1392         int     udpEntrySize;                   /* Size of udpEntry_t */
1393         int     udp6EntrySize;                  /* Size of udp6Entry_t */
1394         Counter udpOutErrors;
1395
1396         /*
1397          * fields from RFC 4113
1398          */
1399
1400         /* total # of UDP datagrams sent upstream               { udp 8 } */
1401         Counter64       udpHCInDatagrams;
1402         /* total # of dg's sent                                 { udp 9 } */
1403         Counter64       udpHCOutDatagrams;
1404 } mib2_udp_t;
1405 #define MIB_FIRST_NEW_ELM_mib2_udp_t    udpHCInDatagrams
1406
1407 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1408 #pragma pack()
1409 #endif
1410
1411 /*
1412  * The UDP listener table contains information about this entity's UDP
1413  * end-points on which a local application is currently accepting datagrams.
1414  */
1415
1416 /* For both IPv4 and IPv6 ue_state: */
1417 #define MIB2_UDP_unbound        1
1418 #define MIB2_UDP_idle           2
1419 #define MIB2_UDP_connected      3
1420 #define MIB2_UDP_unknown        4
1421
1422 /* Pack data to make struct size the same for 32- and 64-bits */
1423 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1424 #pragma pack(4)
1425 #endif
1426 typedef struct mib2_udpEntry {
1427                 /* local ip addr of listener            { udpEntry 1 } */
1428         IpAddress       udpLocalAddress;
1429                 /* local port of listener               { udpEntry 2 } */
1430         int             udpLocalPort;           /* In host byte order */
1431         struct udpEntryInfo_s {
1432                 int             ue_state;
1433                 IpAddress       ue_RemoteAddress;
1434                 int             ue_RemotePort;  /* In host byte order */
1435         }               udpEntryInfo;
1436
1437         /*
1438          * RFC 4113
1439          */
1440
1441         /* Unique id for this 4-tuple           { udpEndpointEntry 7 } */
1442         uint32_t        udpInstance;
1443         /* pid of the processes that created this endpoint */
1444         uint32_t        udpCreationProcess;
1445         /* system uptime when the endpoint was created */
1446         uint64_t        udpCreationTime;
1447 } mib2_udpEntry_t;
1448 #define MIB_FIRST_NEW_ELM_mib2_udpEntry_t       udpInstance
1449
1450 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1451 #pragma pack()
1452 #endif
1453
1454 /*
1455  * The UDP (for IPv6) listener table contains information about this
1456  * entity's UDP end-points on which a local application is
1457  * currently accepting datagrams.
1458  */
1459
1460 /* Pack data to make struct size the same for 32- and 64-bits */
1461 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1462 #pragma pack(4)
1463 #endif
1464 typedef struct mib2_udp6Entry {
1465                 /* local ip addr of listener            { ipv6UdpEntry 1 } */
1466         Ip6Address      udp6LocalAddress;
1467                 /* local port of listener               { ipv6UdpEntry 2 } */
1468         int             udp6LocalPort;          /* In host byte order */
1469                 /* interface index or zero              { ipv6UdpEntry 3 } */
1470         DeviceIndex     udp6IfIndex;
1471         struct udp6EntryInfo_s {
1472                 int     ue_state;
1473                 Ip6Address      ue_RemoteAddress;
1474                 int             ue_RemotePort;  /* In host byte order */
1475         }               udp6EntryInfo;
1476
1477         /*
1478          * RFC 4113
1479          */
1480
1481         /* Unique id for this 4-tuple           { udpEndpointEntry 7 } */
1482         uint32_t        udp6Instance;
1483         /* pid of the processes that created this endpoint */
1484         uint32_t        udp6CreationProcess;
1485         /* system uptime when the endpoint was created */
1486         uint64_t        udp6CreationTime;
1487 } mib2_udp6Entry_t;
1488 #define MIB_FIRST_NEW_ELM_mib2_udp6Entry_t      udp6Instance
1489
1490 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1491 #pragma pack()
1492 #endif
1493
1494 /*
1495  * the RAWIP group
1496  */
1497 typedef struct mib2_rawip {
1498                 /* total # of RAWIP datagrams sent upstream */
1499         Counter rawipInDatagrams;
1500                 /* # of RAWIP packets with bad IPV6_CHECKSUM checksums */
1501         Counter rawipInCksumErrs;
1502                 /* # of recv'd dg's not deliverable (other) */
1503         Counter rawipInErrors;
1504                 /* total # of dg's sent */
1505         Counter rawipOutDatagrams;
1506                 /* total # of dg's not sent (e.g. no memory) */
1507         Counter rawipOutErrors;
1508 } mib2_rawip_t;
1509
1510 /* DVMRP group */
1511 #define EXPER_DVMRP_VIF         1
1512 #define EXPER_DVMRP_MRT         2
1513
1514
1515 /*
1516  * The SCTP group
1517  */
1518 #define MIB2_SCTP_CONN                  15
1519 #define MIB2_SCTP_CONN_LOCAL            16
1520 #define MIB2_SCTP_CONN_REMOTE           17
1521
1522 #define MIB2_SCTP_closed                1
1523 #define MIB2_SCTP_cookieWait            2
1524 #define MIB2_SCTP_cookieEchoed          3
1525 #define MIB2_SCTP_established           4
1526 #define MIB2_SCTP_shutdownPending       5
1527 #define MIB2_SCTP_shutdownSent          6
1528 #define MIB2_SCTP_shutdownReceived      7
1529 #define MIB2_SCTP_shutdownAckSent       8
1530 #define MIB2_SCTP_deleteTCB             9
1531 #define MIB2_SCTP_listen                10      /* Not in the MIB */
1532
1533 #define MIB2_SCTP_ACTIVE                1
1534 #define MIB2_SCTP_INACTIVE              2
1535
1536 #define MIB2_SCTP_ADDR_V4               1
1537 #define MIB2_SCTP_ADDR_V6               2
1538
1539 #define MIB2_SCTP_RTOALGO_OTHER         1
1540 #define MIB2_SCTP_RTOALGO_VANJ          2
1541
1542 typedef struct mib2_sctpConnEntry {
1543                 /* connection identifier        { sctpAssocEntry 1 } */
1544         uint32_t        sctpAssocId;
1545                 /* remote hostname (not used)   { sctpAssocEntry 2 } */
1546         Octet_t         sctpAssocRemHostName;
1547                 /* local port number            { sctpAssocEntry 3 } */
1548         uint32_t        sctpAssocLocalPort;
1549                 /* remote port number           { sctpAssocEntry 4 } */
1550         uint32_t        sctpAssocRemPort;
1551                 /* type of primary remote addr  { sctpAssocEntry 5 } */
1552         int             sctpAssocRemPrimAddrType;
1553                 /* primary remote address       { sctpAssocEntry 6 } */
1554         Ip6Address      sctpAssocRemPrimAddr;
1555                 /* local address */
1556         Ip6Address      sctpAssocLocPrimAddr;
1557                 /* current heartbeat interval   { sctpAssocEntry 7 } */
1558         uint32_t        sctpAssocHeartBeatInterval;
1559                 /* state of this association    { sctpAssocEntry 8 } */
1560         int             sctpAssocState;
1561                 /* # of inbound streams         { sctpAssocEntry 9 } */
1562         uint32_t        sctpAssocInStreams;
1563                 /* # of outbound streams        { sctpAssocEntry 10 } */
1564         uint32_t        sctpAssocOutStreams;
1565                 /* max # of data retans         { sctpAssocEntry 11 } */
1566         uint32_t        sctpAssocMaxRetr;
1567                 /* sysId for assoc owner        { sctpAssocEntry 12 } */
1568         uint32_t        sctpAssocPrimProcess;
1569                 /* # of rxmit timeouts during hanshake */
1570         Counter32       sctpAssocT1expired;     /* { sctpAssocEntry 13 } */
1571                 /* # of rxmit timeouts during shutdown */
1572         Counter32       sctpAssocT2expired;     /* { sctpAssocEntry 14 } */
1573                 /* # of rxmit timeouts during data transfer */
1574         Counter32       sctpAssocRtxChunks;     /* { sctpAssocEntry 15 } */
1575                 /* assoc start-up time          { sctpAssocEntry 16 } */
1576         uint32_t        sctpAssocStartTime;
1577         struct sctpConnEntryInfo_s {
1578                                 /* amount of data in send Q */
1579                 Gauge           ce_sendq;
1580                                 /* amount of data in recv Q */
1581                 Gauge           ce_recvq;
1582                                 /* currect send window size */
1583                 Gauge           ce_swnd;
1584                                 /* currenct receive window size */
1585                 Gauge           ce_rwnd;
1586                                 /* current max segment size */
1587                 Gauge           ce_mss;
1588         } sctpConnEntryInfo;
1589 } mib2_sctpConnEntry_t;
1590
1591 typedef struct mib2_sctpConnLocalAddrEntry {
1592                 /* connection identifier */
1593         uint32_t        sctpAssocId;
1594                 /* type of local addr           { sctpAssocLocalEntry 1 } */
1595         int             sctpAssocLocalAddrType;
1596                 /* local address                { sctpAssocLocalEntry 2 } */
1597         Ip6Address      sctpAssocLocalAddr;
1598 } mib2_sctpConnLocalEntry_t;
1599
1600 typedef struct mib2_sctpConnRemoteAddrEntry {
1601                 /* connection identier */
1602         uint32_t        sctpAssocId;
1603                 /* remote addr type             { sctpAssocRemEntry 1 } */
1604         int             sctpAssocRemAddrType;
1605                 /* remote address               { sctpAssocRemEntry 2 } */
1606         Ip6Address      sctpAssocRemAddr;
1607                 /* is the address active        { sctpAssocRemEntry 3 } */
1608         int             sctpAssocRemAddrActive;
1609                 /* whether hearbeat is active   { sctpAssocRemEntry 4 } */
1610         int             sctpAssocRemAddrHBActive;
1611                 /* current RTO                  { sctpAssocRemEntry 5 } */
1612         uint32_t        sctpAssocRemAddrRTO;
1613                 /* max # of rexmits before becoming inactive */
1614         uint32_t        sctpAssocRemAddrMaxPathRtx; /* {sctpAssocRemEntry 6} */
1615                 /* # of rexmits to this dest    { sctpAssocRemEntry 7 } */
1616         uint32_t        sctpAssocRemAddrRtx;
1617 } mib2_sctpConnRemoteEntry_t;
1618
1619
1620
1621 /* Pack data in mib2_sctp to make struct size the same for 32- and 64-bits */
1622 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1623 #pragma pack(4)
1624 #endif
1625
1626 typedef struct mib2_sctp {
1627                 /* algorithm used to determine rto      { sctpParams 1 } */
1628         int             sctpRtoAlgorithm;
1629                 /* min RTO in msecs                     { sctpParams 2 } */
1630         uint32_t        sctpRtoMin;
1631                 /* max RTO in msecs                     { sctpParams 3 } */
1632         uint32_t        sctpRtoMax;
1633                 /* initial RTO in msecs                 { sctpParams 4 } */
1634         uint32_t        sctpRtoInitial;
1635                 /* max # of assocs                      { sctpParams 5 } */
1636         int32_t         sctpMaxAssocs;
1637                 /* cookie lifetime in msecs             { sctpParams 6 } */
1638         uint32_t        sctpValCookieLife;
1639                 /* max # of retrans in startup          { sctpParams 7 } */
1640         uint32_t        sctpMaxInitRetr;
1641         /* # of conns ESTABLISHED, SHUTDOWN-RECEIVED or SHUTDOWN-PENDING */
1642         Counter32       sctpCurrEstab;          /* { sctpStats 1 } */
1643                 /* # of active opens                    { sctpStats 2 } */
1644         Counter32       sctpActiveEstab;
1645                 /* # of passive opens                   { sctpStats 3 } */
1646         Counter32       sctpPassiveEstab;
1647                 /* # of aborted conns                   { sctpStats 4 } */
1648         Counter32       sctpAborted;
1649                 /* # of graceful shutdowns              { sctpStats 5 } */
1650         Counter32       sctpShutdowns;
1651                 /* # of OOB packets                     { sctpStats 6 } */
1652         Counter32       sctpOutOfBlue;
1653                 /* # of packets discarded due to cksum  { sctpStats 7 } */
1654         Counter32       sctpChecksumError;
1655                 /* # of control chunks sent             { sctpStats 8 } */
1656         Counter64       sctpOutCtrlChunks;
1657                 /* # of ordered data chunks sent        { sctpStats 9 } */
1658         Counter64       sctpOutOrderChunks;
1659                 /* # of unordered data chunks sent      { sctpStats 10 } */
1660         Counter64       sctpOutUnorderChunks;
1661                 /* # of retransmitted data chunks */
1662         Counter64       sctpRetransChunks;
1663                 /* # of SACK chunks sent */
1664         Counter         sctpOutAck;
1665                 /* # of delayed ACK timeouts */
1666         Counter         sctpOutAckDelayed;
1667                 /* # of SACK chunks sent to update window */
1668         Counter         sctpOutWinUpdate;
1669                 /* # of fast retransmits */
1670         Counter         sctpOutFastRetrans;
1671                 /* # of window probes sent */
1672         Counter         sctpOutWinProbe;
1673                 /* # of control chunks received         { sctpStats 11 } */
1674         Counter64       sctpInCtrlChunks;
1675                 /* # of ordered data chunks rcvd        { sctpStats 12 } */
1676         Counter64       sctpInOrderChunks;
1677                 /* # of unord data chunks rcvd          { sctpStats 13 } */
1678         Counter64       sctpInUnorderChunks;
1679                 /* # of received SACK chunks */
1680         Counter         sctpInAck;
1681                 /* # of received SACK chunks with duplicate TSN */
1682         Counter         sctpInDupAck;
1683                 /* # of SACK chunks acking unsent data */
1684         Counter         sctpInAckUnsent;
1685                 /* # of Fragmented User Messages        { sctpStats 14 } */
1686         Counter64       sctpFragUsrMsgs;
1687                 /* # of Reassembled User Messages       { sctpStats 15 } */
1688         Counter64       sctpReasmUsrMsgs;
1689                 /* # of Sent SCTP Packets               { sctpStats 16 } */
1690         Counter64       sctpOutSCTPPkts;
1691                 /* # of Received SCTP Packets           { sctpStats 17 } */
1692         Counter64       sctpInSCTPPkts;
1693                 /* # of invalid cookies received */
1694         Counter         sctpInInvalidCookie;
1695                 /* total # of retransmit timeouts */
1696         Counter         sctpTimRetrans;
1697                 /* total # of retransmit timeouts dropping the connection */
1698         Counter         sctpTimRetransDrop;
1699                 /* total # of heartbeat probes */
1700         Counter         sctpTimHeartBeatProbe;
1701                 /* total # of heartbeat timeouts dropping the connection */
1702         Counter         sctpTimHeartBeatDrop;
1703                 /* total # of conns refused due to backlog full on listen */
1704         Counter         sctpListenDrop;
1705                 /* total # of pkts received after the association has closed */
1706         Counter         sctpInClosed;
1707         int             sctpEntrySize;
1708         int             sctpLocalEntrySize;
1709         int             sctpRemoteEntrySize;
1710 } mib2_sctp_t;
1711
1712 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
1713 #pragma pack()
1714 #endif
1715
1716
1717 #ifdef  __cplusplus
1718 }
1719 #endif
1720
1721 #endif  /* _INET_MIB2_H */