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