RFC 2863
The Interfaces Group MIB
RFC 2863: The Interfaces Group MIB 🎀
okay bestie, this one is the Interfaces Group MIB and it's giving standards-track royalty 👑. It's from the Network Working Group and it's a Standards Track doc, dated June 2000. The authors are K. McCloghrie (Cisco Systems) and F. Kastenholz (Argon Networks) 🧚. The big tea: it obsoletes RFC 2233, the previous version of the Interfaces Group MIB 💅.
Status of this Memo ✨
This document is an Internet standards track protocol for the Internet community, and it's asking for discussion and suggestions for improvements 🫶. For the standardization state and status of this protocol, check the current edition of the "Internet Official Protocol Standards" (STD 1). Distribution of this memo is unlimited 🌈.
Copyright Notice 💜
Copyright (C) The Internet Society (2000). All Rights Reserved.
Table of Contents 🍓
1 Introduction ................................................. 2
2 The SNMP Network Management Framework ........................ 2
3 Experience with the Interfaces Group ......................... 3
3.1 Clarifications/Revisions ................................... 4
3.1.1 Interface Sub-Layers ..................................... 4
3.1.2 Guidance on Defining Sub-layers .......................... 7
3.1.3 Virtual Circuits ......................................... 8
3.1.4 Bit, Character, and Fixed-Length Interfaces .............. 8
3.1.5 Interface Numbering ...................................... 10
3.1.6 Counter Size ............................................. 14
3.1.7 Interface Speed .......................................... 16
3.1.8 Multicast/Broadcast Counters ............................. 17
3.1.9 Trap Enable .............................................. 17
3.1.10 Addition of New ifType values ........................... 18
3.1.11 InterfaceIndex Textual Convention ....................... 18
3.1.12 New states for IfOperStatus ............................. 18
3.1.13 IfAdminStatus and IfOperStatus .......................... 19
3.1.14 IfOperStatus in an Interface Stack ...................... 21
3.1.15 Traps ................................................... 21
3.1.16 ifSpecific .............................................. 23
3.1.17 Creation/Deletion of Interfaces ......................... 23
3.1.18 All Values Must be Known ................................ 24
4 Media-Specific MIB Applicability ............................. 24
5 Overview ..................................................... 25
6 Interfaces Group Definitions ................................. 26
7 Acknowledgements ............................................. 64
8 References ................................................... 64
9 Security Considerations ...................................... 66
10 Authors' Addresses .......................................... 67
11 Changes from RFC 2233 ....................................... 67
12 Notice on Intellectual Property ............................. 68
13 Full Copyright Statement .................................... 691. Introduction 🦋
okay so this memo defines a chunk of the Management Information Base (MIB) for network management protocols in the Internet community 💖. It's all about managed objects for Network Interfaces 🔥. It looks at the 'interfaces' group of MIB-II [17], especially what got learned from defining a bunch of media-specific MIB modules that work with the 'interfaces' group to manage the various sub-layers beneath the internetwork-layer 🫶. It also spells out clarifications to, and extensions of, the architectural issues in the MIB-II model of the 'interfaces' group ✨. And yes, this memo obsoletes RFC 2233, the previous version of the Interfaces Group MIB 💅.
The key words "MUST" and "MUST NOT" in this document are to be interpreted as described in RFC 2119 [16] 🎀. Those are the no-cap rules, so read them closely 💀.
2. The SNMP Network Management Framework 🌸
The SNMP Management Framework currently has five major components 👑:
- An overall architecture, described in RFC 2571 [1].
- Mechanisms for describing and naming objects and events for the purpose of management. The first version of this Structure of Management Information (SMI) is called SMIv1 and is described in STD 16, RFC 1155 [2], STD 16, RFC 1212 [3] and RFC 1215 [4]. The second version, called SMIv2, is described in STD 58, which consists of RFC 2578 [5], RFC 2579 [6] and RFC 2580 [7].
- Message protocols for transferring management information. The first version of the SNMP message protocol is called SNMPv1 and is described in STD 15, RFC 1157 [8]. A second version of the SNMP message protocol, which is not an Internet standards track protocol, is called SNMPv2c and is described in RFC 1901 [9] and RFC 1906 [10]. The third version of the message protocol is called SNMPv3 and is described in RFC 1906 [10], RFC 2572 [11] and RFC 2574 [12].
- Protocol operations for accessing management information. The first set of protocol operations and associated PDU formats is described in STD 15, RFC 1157 [8]. A second set of protocol operations and associated PDU formats is described in RFC 1905 [13].
- A set of fundamental applications described in RFC 2573 [14] and the view-based access control mechanism described in RFC 2575 [15].
If you want a more detailed intro to the current SNMP Management Framework, check out RFC 2570 [22] 🧚.
Managed objects are accessed via a virtual information store, called the Management Information Base or MIB 🍓. Objects in the MIB are defined using the mechanisms defined in the SMI 💜.
This memo specifies a MIB module that is compliant to the SMIv2 ✨. A MIB conforming to the SMIv1 can be produced through the appropriate translations. The resulting translated MIB must be semantically equivalent, except where objects or events are omitted because no translation is possible (e.g., use of Counter64). Some machine readable information in SMIv2 will be converted into textual descriptions in SMIv1 during the translation process. However, this loss of machine readable information is not considered to change the semantics of the MIB 🙈.
3. Experience with the Interfaces Group 🌈
Here's the big strength of internetwork-layer protocols like IP [18]: they're designed to run over any network interface 🔥. To make that work, IP treats every protocol it runs over as one single "network interface" layer 💅. Other internetwork-layer protocols do the same thing 🫶.
MIB-II handles this with the 'interfaces' group, which is a generic set of managed objects so that any network interface can be managed in an interface-independent way ✨. The 'interfaces' group also gives you a way to define extra managed objects for specific types of network interface (like a particular medium such as Ethernet) as extensions for media-specific management 🦋. Since MIB-II got standardized, a lot of these media-specific MIB modules have been defined 💖.
Here's the tea ☕: experience with those media-specific modules showed that the MIB-II model is too simplistic and/or static for some kinds of media-specific management 💀. So some of those modules assume the model has evolved or loosened up 🙈. This memo documents and standardizes that evolution and fills in the gaps it left behind 🫶. It also folds in the interfaces group extensions documented in RFC 1229 [19] 🎀.
3.1. Clarifications/Revisions 💖
Several areas have shown that clarification, revision, or extension of the model would help a lot 🔥. The following sections talk about the changes to the interfaces group that this memo adopts in each of those areas 🌸.
Some sections have one or more paragraphs about rejected alternatives to the model adopted in this memo 🙈. If you're not familiar with the MIB-II model and you don't care about the reasoning behind the new model, you can skip those paragraphs 🫶.
3.1.1. Interface Sub-Layers 🧁
Okay so, experience with defining media-specific management info showed we need to tell apart the multiple sub-layers beneath the internetwork-layer 🍓. And there's a catch: we also need to manage these sub-layers on devices (like MAC-layer bridges) that have no idea which internetwork protocols, if any, run over them 💀. So the old idea of one ifTable row representing a whole interface underneath the internetwork-layer, plus one media-specific MIB module referenced through the ifType object, is just too simplistic 🙅♀️. And the enumerated values of ifType have their own problem too.
Picture this: PPP running over an HDLC link that uses an RS232-like connector 🔌. Each of those sub-layers has its own media-specific MIB module. If you squish all of it into one ifTable row, you'd need an ifType value for that exact combo that maps to that exact combo of MIBs. And even then, the model still has no way to describe how all the sub-layers relate to each other 😩.
There's also upward and downward multiplexing to deal with 🌀. Upward is something like MLP (Multi-Link-Procedure), which does load-sharing over several serial lines but looks like a single point-to-point link to the sub-layer(s) above it 🔗. Downward is when you've got several instances of PPP, each framed inside its own X.25 virtual circuit, all running over one fractional T1 channel while the rest of the T1 link is doing its own thing at the same time 🤯. The MIB structure has to be able to describe these sorts of relationships, period.
Several solutions got rejected, and the tea is good 🍵. One idea kept one conceptual row for all the sub-layers of an interface and had each media-specific MIB module name its "superior" and "subordinate" sub-layers with OBJECT IDENTIFIER "pointers". That had a bunch of drawbacks. The pointers would live inside the media-specific MIB modules, so a manager couldn't learn an interface's structure without poking through multiple pointers across different MIB modules. That would be overly complex, and it would only work if the manager knew about every relevant media-specific MIB module. Every MIB module would also need retrofitting with these new "pointers". It wouldn't properly handle upward and downward multiplexing, and it would still need enumerated values of ifType for each combination of sub-layers 🥴.
Another rejected idea also kept one conceptual row for all the sub-layers, but added a new separate MIB table to hold the "superior" and "subordinate" sub-layers, plus OBJECT IDENTIFIER "pointers" to the media-specific MIB module for each sub-layer. Effectively, one ifTable row would represent each combination of sub-layers between the internetwork-layer and the wire. This one had fewer drawbacks, but it still couldn't support downward multiplexing, like PPP over MLP 🙃. Think about it: MLP makes two (or more) serial lines look like a single physical interface to the layers above, so PPP over MLP should show up to the internetwork-layer as a single interface. This scheme would instead create two (or more) conceptual rows in the ifTable, and the internetwork-layer would run over both of them. It would also still need enumerated values of ifType for each combination of sub-layers.
The solution this memo actually adopts is giving each sub-layer its own conceptual row in the ifTable 🎀. Then there's a brand-new MIB table, the ifStackTable (see section 6 below), that identifies the "superior" and "subordinate" sub-layers through INTEGER "pointers" to the right conceptual rows in the ifTable. This solution supports both upward and downward multiplexing ✨. It lets the IANAifType to Media-Specific MIB mapping identify the media-specific MIB module for each sub-layer, so the new table only needs to be checked for layering info. And it only needs enumerated values of ifType for each sub-layer, not for combinations of them 💅.
There's a tradeoff, though. The descriptions of some ifTable objects need to be generalized so they apply to any sub-layer, not just a sub-layer sitting right beneath the network layer like before. Those objects are ifType, ifPhysAddress, ifInUcastPkts, and ifOutUcastPkts. On top of that, ifSpeed needs appropriate values identified for the cases where a generalized definition doesn't fit a particular sub-layer 🫠.
Also, this adopted solution doesn't require a device, where a sub-layer is instrumented by a row of the ifTable, to know whether an internetwork protocol runs on top of that sub-layer. The packet counters on an interface count packets "delivered to a higher-layer protocol" 📦. For the input side, "higher-layer" includes:
- Delivery to a forwarding module that accepts packets/frames/octets and forwards them on at the same protocol layer. For this definition, the forwarding module of a MAC-layer bridge counts as a "higher-layer" to the MAC-layer of each port on the bridge.
- Delivery to a higher sub-layer within an interface stack. For example, if a PPP module ran directly over a serial interface, the PPP module would count as the higher sub-layer to the serial interface.
- Delivery to a higher protocol layer that doesn't do packet forwarding, for sub-layers that are "at the top of" the interface stack. For example, the local IP module would count as the higher layer to a SLIP serial interface.
Output counters work the same way, but they count packets that "higher-level protocols requested to be transmitted" 🚀. For this output side, "higher-layer" includes:
- A forwarding module, at the same protocol layer, that transmits packets/frames/octets which were received on a different interface. For this definition, the forwarding module of a MAC-layer bridge counts as a "higher-layer" to the MAC-layer of each port on the bridge.
- The next higher sub-layer within an interface stack. For example, if a PPP module ran directly over a serial interface, the PPP module would be a "higher layer" to the serial interface.
- For sub-layers that are "at the top of" the interface stack, a higher element in the network protocol stack. For example, the local IP module would count as the higher layer to an Ethernet interface.
3.1.2. Guidance on Defining Sub-layers 🗺️
The designer of a media-specific MIB has to decide whether to divide an interface into sub-layers, and if so, how to make those divisions 🤔. The guidance below is here to help the media-specific MIB designer make those calls.
In general, the number of entries in the ifTable should be kept to the minimum required for network management 🧹. Specifically, a group of related interfaces should be treated as a single interface with one entry in the ifTable, as long as:
- None of the group of interfaces performs multiplexing for any other interface in the agent.
- There's a meaningful and useful way for all of the ifTable's information (for example, the counters and the status variables) and all of the ifTable's capabilities (for example, write access to ifAdminStatus) to apply to the group of interfaces as a whole.
When those conditions hold, there should be one ifTable entry for that group of interfaces. Any internal structure that network management needs to see should be captured in a MIB module specific to that type of interface 📚.
Bullet 2 also applies to the ifTable's ifType object, which means there has to be a meaningful media-specific MIB and a meaningful ifType value that apply to the group of interfaces as a whole. For example, it's not okay to treat an HDLC sub-layer and an RS-232 sub-layer as a single ifTable entry when their media-specific MIBs and ifType values are separate (rather than combined) 🙅♀️.
With that in mind, it's appropriate to assign an ifIndex value to any interface that can show up in an interface stack (in the ifStackTable) where the bottom of the stack is a physical interface (ifConnectorPresent has the value 'true'), and where there's a layer-3 or other application that "points down" to the top of that stack 🧱. One example of an application that points down to the top of the stack is the Character MIB [21].
Heads up: the sub-layers of an interface on one device can be different from the sub-layers of the interface it's connected to on another device 👀. For example, a frame-relay DTE interface connected to a frameRelayService interface has inter-connected DTE and DCE interfaces with different ifType values and media-specific MIBs.
These are just guidelines, though 🫶. The designer of a media-specific MIB is free to lay out the MIB in whatever SMI conformant manner they want. That said, the media-specific MIB MUST completely specify the sub-layering model used for the MIB, and it must provide the assumptions, reasoning, and rationale used to develop that model 📝.
3.1.3. Virtual Circuits 🦋
A bunch of the sub-layers that have media-specific MIB modules are connection oriented, like Frame Relay and X.25 💜. Every time someone tries to define one of these MIB modules, they end up asking again whether each virtual circuit needs its own conceptual row in the ifTable. Most, if not all, of those efforts so far have decided that all virtual circuits should reference a single conceptual row in the ifTable 🌸.
This memo strongly recommends that connection-oriented sub-layers don't get a conceptual row in the ifTable for each virtual circuit ✨. That keeps conceptual rows from multiplying, especially the ones packed with lots of redundant info 🙈. (As a comparison, connection-less sub-layers don't get conceptual rows for each remote address.) There may be situations where a virtual circuit of a connection-oriented sub-layer deserves its own conceptual row in the ifTable, though. One example might be PPP over an X.25 virtual circuit. The MIB in section 6 of this memo supports those situations 💖.
If a media-specific MIB wants to assign an ifTable entry to each virtual circuit, the MIB designer must present the rationale for that decision in the media-specific MIB's specification 🧾.
3.1.4. Bit, Character, and Fixed-Length Interfaces 🎀
Okay so RS-232 is a character-oriented sub-layer, and you can totally send IP datagrams over it (through PPP, for example) 🔌. But a lot of the objects in the ifTable are built around packets, so experience has shown that giving a character-oriented sub-layer a whole conceptual row in the ifTable is not the move 🙅♀️. Learned that one the hard way, bestie 💀.
Bit-oriented interfaces have a similar problem 🧩. Sometimes you still want management info for them, but they're hard to squeeze into a whole row too. Picture managing the channels of a DS1 circuit where only some of the channels are carrying packet-based data. Very main character problem 💅.
Then there's the fixed-length situation. Some subnetwork technologies send data in fixed-length transmission units 📦. Cell relay, and especially Asynchronous Transfer Mode (ATM), sends its data in fixed-length cells. If you model that as a packet-based interface, you end up with redundant objects whenever the relationship between packets and octets in either direction is fixed by the size of the transmission unit (like the size of a cell) 🙃.
Here's the vibe check: about half the objects in the ifTable apply to every type of interface (packet-oriented, character-oriented, and bit-oriented) 🙌. Of the other half, two apply to both character-oriented and packet-oriented interfaces, and the rest only apply to packet-oriented ones 😩. So even though it would be nice for consistency to represent any and every type of interface in the ifTable, it just isn't possible to implement the full ifTable for bit- and character-oriented sub-layers 🥲.
A rejected solution was to split the ifTable into two (or more) new MIB tables: one for objects that only matter to packet-oriented interfaces (like PPP), and another that any interface could use. Highly undesirable 🚫. It would mean changes in every agent implementing the ifTable, which is just about every existing SNMP agent out there 😭.
The solution this memo actually goes with 💜 is built on a neat fact: compliance statements in SMIv2 (unlike SMIv1) refer to object groups, and object groups are explicitly defined by listing the objects they contain 🧠. So with SMIv2, you can have multiple compliance statements, one for all interfaces and extra ones for specific types of interfaces. The object group for all interfaces only contains the objects from the ifTable that are appropriate for every type of interface. Result? Every sub-layer gets its own conceptual row in the ifTable 🎉✨.
So, Section 6 of this memo defines the objects in the existing 'interfaces' group of MIB-II. These definitions are SNMPv2-compliant and semantically equivalent to the existing MIB-II definitions 🧚. The BER ("on the wire") encodings stay unchanged, and the definitions keep the same OBJECT IDENTIFIER values MIB-II assigned. Which means, in general, existing agents that conform to MIB-II and the ifExtensions MIB don't need a rewrite 🙌🌸.
This memo also defines several object groups that say which objects apply to which types of interface 🗂️:
- The
ifGeneralInformationGroup. This one holds the objects that apply to all types of network interfaces, including bit-oriented ones 🌈. - The
ifPacketGroup. This one holds the objects that apply to packet-oriented network interfaces 📬. - The
ifFixedLengthGroup. This one holds the objects that apply to character-oriented interfaces (like RS-232) and to subnetwork technologies that send data in fixed-length transmission units (like cell-relay/ATM) 🔥. Besides the octet counters, there are a few other counters (like the error counters) that are useful for this kind of interface but are currently defined as packet-oriented. To make them work here, their definitions are generalized so they also apply to character-oriented and fixed-length-transmission interfaces 🫶.
Heads up, bestie: the octet counters in the ifTable add up octet counts for unicast and non-unicast packets into a single octet counter per direction (received/transmitted) 👀. So with the fixed-length-transmission definition above, interfaces that support non-unicast packets can only keep separate counts of unicast and multicast/broadcast transmissions in a media-specific MIB module. Iconic? Not really, but that's how it be 💀.
3.1.5. Interface Numbering ✨
okay bestie, so MIB-II has this object called ifNumber, and its whole job is to tell you how many network interfaces are on the system (no matter what state they're in) 🧚
"The number of network interfaces (regardless of their current state) present on this system."
every interface gets its own unique ifIndex value, and the description of ifIndex puts a little boundary on it:
"Its value ranges between 1 and the value of ifNumber. The value for each interface must remain constant at least from one re-initialization of the entity's network management system to the next re-initialization."
the constancy part is super important for efficient management 💅 but here's the drama: more and more devices let you add and remove interfaces on the fly 🙈 like being able to set up SLIP/PPP over a character-oriented port. so when you combine "ifIndex must stay constant" with "ifIndex must be less than ifNumber," things get messy fr fr 💀
so people looked at redefining ifNumber as the largest ifIndex value, and that got rejected because it wouldn't actually help 🙅♀️ it would mean deprecating ifNumber, and the redefined object would be kinda questionable anyway. they also considered deprecating ifNumber and not replacing it, but that would still need ifIndex's definition to change (since that definition points at ifNumber). so since ifIndex has to change anyway, touching ifNumber doesn't really help the solution 🤷♀️
the fix in this memo is just to delete the rule that ifIndex must be less than ifNumber, and keep ifNumber exactly as it is ✨ it's a minor semantic change to ifIndex, but all the existing agent implementations already match the new definition. so to avoid making everyone rewrite agents and all those media-specific MIBs, this memo assumes the change doesn't require deprecating ifIndex 🎀 honestly, experience shows it does "break" a few management apps, but that's considered way better than breaking every agent implementation 😭
this also means the ifTable can have "holes" 🕳️ the ifIndex values of its conceptual rows don't have to be contiguous, but SNMP's GetNext (and GetBulk) operations handle holes easily 💖 and ifNumber still counts the conceptual rows, going up and down as interfaces get dynamically added and removed 📈📉
now for the constancy rule across re-initializations: after an interface is dynamically removed, its ifIndex value can't be re-used by a different dynamically added interface until after the next re-initialization of the network management system 🔒 this way you don't have to pre-assign ifIndex values for every interface that could ever be added, which is so much easier 🦋
the catch is that "different" is hard to define, and there will be gray areas 🌫️ any firm definition in this document would probably turn out inadequate, so instead implementors choose what it means in their own situation, following these rules:
(1) a previously-unused value of ifIndex must be assigned to a dynamically added interface if the agent has no knowledge of whether the interface is the "same" or "different" to a previously incarnated interface. 🫶
(2) a management station that hasn't noticed an interface went away and another one showed up must not get confused when calculating the difference between counter values retrieved on successive polls for a particular ifIndex value. 👑
now, when the new interface is the same as an old one but a counter discontinuity can't be avoided, the ifTable has (until now) required a brand new ifIndex for the returning interface 😤 so either the agent kept all the counter values while the interface was gone (so the same ifIndex works on return), or the returning interface got a new ifIndex. both options have been burdensome for some implementations:
(1) keeping the counter values may not be possible (for example, if they live on removable hardware) 🔌
(2) using a new ifIndex value creates extra work for management applications. that extra work can't be avoided on agent re-initializations, but it's really desirable to avoid it between re-initializations 🙏
to fix this, there's a new object called ifCounterDiscontinuityTime 🕰️ it records when an interface's counters last had a discontinuity. by watching it, a management application can spot counter discontinuities without the interface's ifIndex changing ✨ so an agent that implements this new object should, when a new interface is the same as an old one, keep that interface's ifIndex value and update ifCounterDiscontinuityTime if necessary 💜
with this new object, a management application has to throw out any calculated difference between counter values from successive polls where ifCounterDiscontinuityTime is different between the two polls 🗑️ (and this check happens in addition to the normal sysUpTime check for agent re-initializations, so don't skip it 🙈) since throwing those differences away wastes management processing and bandwidth, an agent should not update ifCounterDiscontinuityTime unless it's absolutely necessary 🚫
defining this new object does change the semantics of the ifTable counter objects, but it's totally impractical to deprecate and redefine all of those counters because they're so widely deployed and important 📚 plus, a survey found that many agents and management apps don't implement this aspect of the current semantics correctly (because of those burdensome issues), so the practical impact of the change is small 🌸 so this breach of the SMI's rules is considered acceptable 💅
Note, however, that addingifCounterDiscontinuityTimedoes not change the fact that: it is necessary at certain times for the assignment ofifIndexvalues to change on a re-initialization of the agent (such as a reboot).
so a management application must accommodate ifIndex value re-assignment whenever sysUpTime is reset to zero 🔄⏰
also, some agents support multiple "naming scopes" 🗂️ for example, an SNMPv1 agent with multiple values of the SNMPv1 community string. for an agent like that (say, a CNM agent that supports a different subset of interfaces for different customers), there's no required relationship between the ifIndex values identifying interfaces in one naming scope and those in another 🌈 it's up to the agent whether the same or different ifIndex values identify the same or different interfaces across scopes.
because ifIndex used to have to be less than ifNumber, interfaces got small integer numbers, and humans could use them as somewhat user-friendly names, like "interface number 3" 🍓 but now that the restriction is relaxed, ifIndex values could be assigned as really big numbers (like memory addresses) 😬 which are way less friendly. so this memo recommends that ifIndex values still be assigned as (relatively) small integers starting at 1, even though the values in use at any one time aren't necessarily contiguous 💖 (and this makes it easy for agents that dynamically add new interfaces to remember which values have been assigned 🧠)
a new problem shows up when each sub-layer is represented as its own ifTable entry 😵💫 before, there was usually a simple, direct mapping from interfaces to the physical ports on systems, based on ifIndex. but with an ifTable entry for each interface sub-layer, mapping interfaces to physical ports gets more and more problematic 🌀
to deal with this, a new object called ifName is added to the MIB 🏷️ it holds the device's local name (like the name used at the device's local console) for the interface that the relevant ifTable entry is a component of. for example, say a router has an interface made of PPP running over an RS-232 port. if the router calls the combined interface "wan1", then the ifName objects for the PPP and RS-232 entries in the ifTable would both be "wan1" 👯♀️ but if the router calls the PPP interface "wan1.1" and the RS-232 port "wan1.2", then the ifName objects would be "wan1.1" and "wan1.2" respectively 🎀 and for another example: say an agent answers SNMP queries about an interface on some other (proxied) device 🛸 if that proxied device gives the interface an identifier, it's totally appropriate to use that identifier as the interface's ifName, since the "local console" in this case belongs to the proxied device 💫
meanwhile, the existing ifDescr object is meant to hold a description of an interface ✍️ and another new object, ifAlias, gives a network management application a place to store a non-volatile interface-naming value of its own choosing 🫧 ifAlias lets a network manager give one or more interfaces their own unique names, no matter what the interface-stack relationship is 👑 and since the ifAlias name is non-volatile, an interface must keep its assigned ifAlias value across reboots, even if the agent picks a new ifIndex for it 🔥
3.1.6. Counter Size ✨
okay bestie, so here's the thing 🧚 as network media gets faster, the minimum time before a 32 bit counter wraps around gets shorter, and it gets shorter FAST 😭 For example, a 10Mbs stream of back-to-back, full-size packets makes ifInOctets wrap in just over 57 minutes 💀 At 100Mbs, the minimum wrap time is 5.7 minutes, and at 1Gbs it's a mere 34 seconds 🔥 Making sure every interface gets polled often enough to never miss a wrap is becoming seriously problematic 🙈
A rejected solution was to scale the counters. For example, ifInOctets could count received octets in, say, 1024 byte blocks. That works great at high rates ✨ but at low rates it's giving buggy. If there's barely any traffic on an interface, it could take forever before enough events happen to bump the scaled counter. Traffic would then look super bursty, and you'd draw the wrong conclusions about how the network is actually performing 🙃 So scaling was out.
Instead, this memo adopts expanded, 64 bit, counters 💜 They live in new "high capacity" groups. The old, 32-bit, counters have not been deprecated, and the 64-bit counters are only meant to be used when the 32-bit counters don't have enough capacity. In other words, when the 32 bit counters could wrap too fast.
Here are the speed rules, bestie 👑
For interfaces that operate at 20,000,000 (20 million) bits per second or less, 32-bit byte and packet counters MUST be supported. For interfaces that operate faster than 20,000,000 bits/second, and slower than 650,000,000 bits/second, 32-bit packet counters MUST be supported and 64-bit octet counters MUST be supported. For interfaces that operate at 650,000,000 bits/second or faster, 64-bit packet counters AND 64-bit octet counters MUST be supported.
These speed thresholds were picked as reasonable compromises, and here's why 🌸
- The cost of maintaining 64-bit counters is relatively high, so minimizing the number of agents that have to support them is desirable. Common interfaces (such as 10Mbs Ethernet) should not require them.
- 64-bit counters are a new feature, introduced in the SMIv2. It's reasonable to expect that support for them will be spotty for the immediate future. So we want to limit them to as few systems as possible. This, in effect, means that 64-bit counters should be limited to higher speed interfaces. Ethernet (10,000,000 bps) and Token Ring (16,000,000 bps) are fairly wide-spread, so it seems reasonable to not require 64-bit counters for these interfaces. 🫶
- The 32-bit octet counters will wrap in the following times, for the following interfaces (when transmitting maximum-sized packets back-to-back):
- 10Mbs Ethernet: 57 minutes,
- 16Mbs Token Ring: 36 minutes,
- a US T3 line (45 megabits): 12 minutes,
- FDDI: 5.7 minutes
- The 32-bit packet counters wrap in about 57 minutes when 64-byte packets are transmitted back-to-back on a 650,000,000 bit/second link.
As an aside (iykyk 😏), a 1-terabit/second (1,000 Gbs) link will cause a 64 bit octet counter to wrap in just under 5 years. Conversely, you'd need an 81,000,000 terabit/second link to make a 64-bit counter wrap in 30 minutes 🤯 The authors believe that, while technology marches forward super fast, that link speed won't be achieved for at least several years. That leaves plenty of time to evaluate introducing 96 bit counters 🦋
When 64-bit counters are in use, the 32-bit counters MUST still be available. They report the low 32-bits of the associated 64-bit count (for example, ifInOctets reports the least significant 32 bits of ifHCInOctets). This keeps things inter-operable with existing implementations at a very minimal cost to agents. Iconic behaviour, honestly 💅
The new "high capacity" groups are:
- the ifHCFixedLengthGroup for character-oriented/fixed-length interfaces, and the ifHCPacketGroup for packet-based interfaces. Both of these groups include 64 bit counters for octets, and
- the ifVHCPacketGroup for packet-based interfaces. This group includes 64 bit counters for octets and packets.
3.1.7. Interface Speed 🚀
Network speeds keep going up, and ifSpeed is struggling to keep up 😭 Its range is limited to reporting a maximum speed of (2**31)-1 bits/second, or approximately 2.2Gbs. SONET defines an OC-48 interface, which is defined as operating at 48 times 51 Mbs, which is a speed in excess of 2.4Gbs. So ifSpeed is insufficient for the future, and this memo defines an additional object: ifHighSpeed ✨
The ifHighSpeed object reports the speed of the interface in 1,000,000 (1 million) bits/second units. So the true speed of the interface is the value reported by this object, plus or minus 500,000 bits/second.
Other alternatives were considered (but rejected), and the drama is real 🎭
- Making the interface speed a 64-bit gauge. This was rejected since the current SMI doesn't allow that syntax. Furthermore, even if 64-bit gauges were available, using them would add complexity to agents because of the increased requirement for 64-bit operations.
- We also considered making "high-32 bit" and "low-32-bit" objects which, when combined, would form a 64-bit value. This seemed overly complex for what we're trying to do. Furthermore, a full 64-bits of precision doesn't seem necessary. The value of ifHighSpeed will be the only report of interface speed for interfaces faster than 4,294,967,295 bits per second. At that speed, the granularity of ifHighSpeed is 1,000,000 bits per second, so the error is 1/4294, or about 0.02%. That seems reasonable 👌
- Adding a "scale" object, which would define the units that ifSpeed's value is in. This would require two additional objects: one for the scaling object, and one to replace the current ifSpeed. This later object is required since the semantics of ifSpeed would be significantly altered, and manager stations that don't understand the new semantics would get confused 🙈
3.1.8. Multicast/Broadcast Counters 📦
In MIB-II, the ifTable counters for multicast and broadcast packets are combined as counters of non-unicast packets. In contrast, the ifExtensions MIB [19] defined one set of counters for multicast, and a separate set for broadcast packets. With the separate counters, the original combined counters become redundant. To avoid that redundancy, the non-unicast counters are deprecated 🫠
For the output broadcast and multicast counters defined in RFC 1229, their definitions varied slightly from the packet counters in the ifTable. They didn't count errors/discarded packets. So this memo defines new objects with better aligned definitions 💖 Counters with 64 bits of range are also needed, as explained above.
3.1.9. Trap Enable 🔔
In the multi-layer interface model, each sub-layer that has an entry in the ifTable can generate linkUp/linkDown Traps. Since interface state changes tend to propagate through the interface (from top to bottom, or bottom to top), it's likely that several traps would be generated for each linkUp/linkDown occurrence. Chaotic energy, honestly 😭
It's desirable to give manager stations a way to control the generation of these traps. That's why the ifLinkUpDownTrapEnable object was added. It lets managers limit trap generation to just the sub-layers they care about 🎀
The default setting should limit the number of traps generated to one per interface per linkUp/linkDown event. Also, the state changes that matter most to network managers tend to occur at the lowest level of an interface stack. So we specify that by default, only the lowest sub-layer of the interface generates traps 🧠
3.1.10. Addition of New ifType values 🆕
Over time, new ifType enumerated values are needed for new interface types. If the syntax of ifType were defined in the MIB in section 6, then a new version of this MIB would have to be re-issued in order to define new values. In the past, re-issuing a MIB has only happened after several years 💀
So the syntax of ifType is changed to be a textual convention, which means the enumerated integer values are now defined in the textual convention IANAifType, defined in a different document. This allows additional values to be documented without having to re-issue a new version of this document 🌈 The Internet Assigned Number Authority (IANA) is responsible for assigning all Internet numbers, including various SNMP-related numbers, and specifically new ifType values.
3.1.11. InterfaceIndex Textual Convention 🧩
A new textual convention, InterfaceIndex, has been defined. This textual convention "contains" all of the semantics of the ifIndex object. That lets other MIB modules easily import the semantics of ifIndex, which is so clean ✨
3.1.12. New states for IfOperStatus 🚦
Three new states have been added to ifOperStatus: 'dormant', 'notPresent', and 'lowerLayerDown'. Bestie, these are a whole mood 🫶
The dormant state means the interface isn't actually in a condition to pass packets (so it isn't 'up'), but it's in a "pending" state, waiting for some external event. For "on-demand" interfaces, this new state covers the situation where the interface is waiting for events to bring it up. Examples of such events might be:
- having packets to transmit before establishing a connection to a remote system;
- having a remote system establish a connection to the interface (e.g. dialing up to a slip-server).
The notPresent state is a refinement of the down state. It means the interface is down specifically because some component (typically a hardware component) isn't present in the managed system. Examples of using the notPresent state are:
- to allow an interface's conceptual row, including its counter values, to be retained across a "hot swap" of a card/module, and/or
- to allow an interface's conceptual row to be created, which enables interfaces to be pre-configured before the hardware needed to make the interface operational gets installed 🛠️
Agents are not required to support interfaces in the notPresent state. However, from a conceptual viewpoint, when a row in the ifTable is created, it first enters the notPresent state and then transitions into the down state. Similarly, when a row in the ifTable is deleted, it first enters the notPresent state and then the object instances are deleted. For an agent with no support for notPresent, both of these transitions (from the notPresent state to the down state, and from the notPresent state to the instances being removed) are immediate. That means the transition doesn't last long enough to be recorded by ifOperStatus. Even for agents that do support interfaces in the notPresent state, how long an interface stays in that state, and under what conditions, is implementation-specific 🌙
The lowerLayerDown state is also a refinement of the down state. This new state means the interface runs "on top of" one or more other interfaces (see ifStackTable), and that this interface is down specifically because one or more of those lower-layer interfaces are down 💜
3.1.13. IfAdminStatus and IfOperStatus ✨
okay so ifOperStatus has a double life 💅 its down state means something different depending on what ifAdminStatus is set to:
- if
ifAdminStatusis notdownandifOperStatusisdown, then a fault condition is presumed to exist on the interface 🚨 - if
ifAdminStatusisdown, thenifOperStatuswill normally also bedown(ornotPresent), i.e., there is not (necessarily) a fault condition on the interface 🫶
note the vibe check here 🙈 when ifAdminStatus goes to down, ifOperStatus will normally go to down too. it's not always instant tho! it might take a small time lag to finish up stuff first, like wrapping up sending a packet before it goes "down" 📦
if a manager station sees that ifAdminStatus is down but ifOperStatus is not down for a particular interface, the manager station should wait a short while and check again. if the condition still exists, only then should it raise an error indication. 😤 and it should also make sure ifLastChange hasn't changed during that interval. patience is a whole skill, bestie 🧚
whenever an interface table entry gets created (usually because the system is starting up), the relevant instance of ifAdminStatus is set to down, and ifOperStatus will be down or notPresent 🌱
an interface can get enabled in two ways: either through explicit management action (like setting ifAdminStatus to up) or as part of the managed system's initialization process ⭐ when ifAdminStatus changes to up, the related ifOperStatus should do one of the following:
- Change to the
upstate if and only if the interface is able to send and receive packets. 💖 - Change to the
lowerLayerDownstate if and only if the interface is prevented from entering theupstate because of the state of one or more of the interfaces beneath it in the interface stack. 🧱 - Change to the
dormantstate if and only if the interface is found to be operable, but the interface is waiting for other, external, events to occur before it can transmit or receive packets. presumably, when those events happen, the interface will then change to theupstate 🌙 - Remain in the
downstate if an error or other fault condition is detected on the interface. 💀 - Change to the
unknownstate if, for some reason, the state of the interface cannot be ascertained. 🌫️ - Change to the
testingstate if some test(s) must be performed on the interface. presumably, after the test is done, the interface's state will change toup,dormant, ordown, as appropriate. 🧪 - Remain in the
notPresentstate if interface components are missing. 🔍
3.1.14. IfOperStatus in an Interface Stack 🥞
when an interface is part of an interface-stack, but it is not the lowest interface in the stack, then:
ifOperStatushas the valueupif it is able to pass packets because one or more interfaces below it in the stack areup, no matter what the other interfaces below it are doing (down,dormant,notPresent,lowerLayerDown,unknown, ortesting) 👑ifOperStatusmay have the valueupordormantif one or more interfaces below it in the stack aredormant, and all others below it are eitherdown,dormant,notPresent,lowerLayerDown,unknown, ortesting🦋ifOperStatushas the valuelowerLayerDownwhile all interfaces below it in the stack are eitherdown,notPresent,lowerLayerDown, ortesting🍓
3.1.15. Traps 🔔
the exact definition of when linkUp and linkDown traps get generated has been changed to match the changes to ifAdminStatus and ifOperStatus. operational experience shows that management stations care most about an interface being in the down state, and the fact that this state may signal a failure. so it's most useful to track transitions into or out of the up state or the down state 🌸
tracking transitions into or out of the up state got rejected 🙅♀️ because a demand interface might bounce between up and dormant a bunch of times, leading to tons of linkUp traps and zero linkDown traps. even worse, if a node's only interface is the demand interface, then a move to dormant would mean generating a linkDown trap, which would force the link back up to the up state (and another linkUp trap)!! the loop is literally unhinged 💀
on the other hand, tracking transitions into or out of the down state (to or from all other states except notPresent) has these advantages:
- A transition into the
downstate (from a state other thannotPresent) happens when an error is detected on an interface. error conditions are presumably of great interest to network managers 🚨 - leaving the
downstate (to a state other thannotPresent) generally means the interface is heading to eitherupordormant, and both of those count as "healthy" states 💚
also, it is believed that generating traps on transitions into or out of the down state (except to or from the notPresent state) is generally consistent with current usage and how manager stations interpret these traps 🧠
transitions to or from the notPresent state are about inserting and removing hardware, so they're outside the scope of these traps 🔌
so this memo defines that linkUp and linkDown traps are generated just after ifOperStatus leaves the down state, or just before it enters the down state, respectively. the exception: linkUp and linkDown traps are never generated on transitions to or from the notPresent state ❌ for deciding when these traps happen, the lowerLayerDown state and the down state are treated as equivalent. that means there is no trap on a transition from lowerLayerDown into down, and there is a trap on a transition from any other state (except down and notPresent) into lowerLayerDown 🎀
note that this definition allows a node with only one interface to transmit a linkDown trap before that interface goes down. (of course, when the interface is going down because of a failure condition, the linkDown trap probably can't be successfully transmitted anyway 😭)
some interfaces do a link "training" function when they try to bring the interface up. if such an interface were defective, the training function would fail and the interface would stay down, and the training function might get repeated at appropriate intervals. if the interface were considered to be in the testing state while doing this training, then linkUp and linkDown traps would be generated for each start and end of the training function. that's not the point of linkUp and linkDown traps, so while the interface is doing a training function like this, its state should be represented as down 🏋️♀️
⚠️ there's an exception to the trap generation above. when an interface is "flapping" (that is, rapidly oscillating between theupanddownstates), generating a trap for each oscillation would flood the network and the network management system with unnecessary traps 🌊 in that situation, the agent should limit the rate at which it generates traps.
3.1.16. ifSpecific 🧩
the original definition of the OBJECT IDENTIFIER value of ifSpecific wasn't clear enough, so different implementors used it differently, and things got confusing 😵💫 some implementations set ifSpecific to the OBJECT IDENTIFIER that defines the media-specific MIB, i.e., the "foo" of:
foo OBJECT IDENTIFIER ::= { transmission xxx }others set it to the OBJECT IDENTIFIER of the specific table or entry in the appropriate media-specific MIB (i.e., fooTable or fooEntry), and still others set it to the OBJECT IDENTIFIER of the index object of the table's row, including the instance identifier (i.e., fooIfIndex.ifIndex). a definition based on that last one wouldn't be enough unless it also allowed for media-specific MIBs that include several tables, where each table has its own (different) indexing 🗂️
the only definition that can be made explicit and cover all the useful situations is to have ifSpecific be the most general value for the media-specific MIB module (the first example above) 💅 this effectively makes it redundant, because it contains no more information than ifType already provides. so ifSpecific has been deprecated 🪦
3.1.17. Creation/Deletion of Interfaces 🛠️
some interfaces, like most physical ones, can't be created via network management, but other interfaces, like logical ones, sometimes can be ✨ the ifTable only holds generic info about an interface. almost all "create-able" interfaces have other, media-specific info where configuration parameters can be supplied before the interface is created 📝 so the ifTable doesn't support creating or deleting an interface itself (specifically, it has no RowStatus [6] column) 🙅♀️
instead, if a particular interface type supports dynamic creation and/or deletion of an interface of that type, then that media-specific MIB should include an appropriate RowStatus object (see the ATM LAN-Emulation Client MIB [20] for an example of a MIB that does this) 🧚 typically, when that RowStatus object gets created or deleted, the conceptual row in the ifTable appears or disappears as a by-product, and an ifIndex value (chosen by the agent) gets stored in an appropriate object in the media-specific MIB 🎀
3.1.18. All Values Must be Known 🔐
there are a bunch of situations where an agent doesn't know the value of one or more objects for a particular interface 🫠 in all of those circumstances, an agent MUST NOT instantiate an object with an incorrect value. instead, it MUST respond with the appropriate error/exception condition (e.g., noSuchInstance or noSuchName) 🙅♀️
one example: an agent can't count the occurrences defined by one (or more) of the ifTable counters. in that case, the agent MUST NOT instantiate the counter with a value of, say, zero 😤 that would be giving a network management app misinformation, and it would read the zero and assume nothing has happened (e.g., no input errors, because ifInErrors is always zero). yikes, no thanks 💀
sometimes not knowing an object's value is only temporary 🕰️ for example, when the MTU of an interface is a configured value, and a device only learns that configured value after exchanging messages over the interface (e.g., ATM LAN-Emulation [20]). in that case, the value isn't known until after the ifTable entry has already been created. so the ifTable entry should be created without an instance of the object whose value is unknown, and later, when the value becomes known, the missing object can be instantiated (e.g., the instance of ifMtu only gets instantiated once the interface's MTU becomes known) 🌈
because of this "known values" rule, management applications MUST be able to cope with responses to retrieving the object instances within a conceptual row of the ifTable showing that some of the row's columnar objects are missing or not available 🫶 so apps have to be ready for gaps. no drama, just grace 💖
4. Media-Specific MIB Applicability ✨
okay so, this MIB is super generic, which is kinda the whole point 💅 but it also means a lot of the objects can be read in more than one way. It's not always possible to write text that's totally specific and unambiguous for every case while keeping that generic vibe 🌸
So the job falls to whoever writes a media-specific MIB (like one for Ethernet or whatever). They have to clarify how this MIB gets used for their medium, wherever it's needed 🫶 Here are the main areas they need to clear up:
- Layering Model: The media-specific MIB designer MUST completely and unambiguously specify the layering model used. Each individual sub-layer must be identified, as must the ifStackTable's portrayal of the relationship(s) between the sub-layers.
- Virtual Circuits: The media-specific MIB designer MUST specify whether virtual circuits are assigned entries in the ifTable or not. If they are, compelling rationale must be presented.
- ifRcvAddressTable: The media-specific MIB designer MUST specify the applicability of the ifRcvAddressTable.
- ifType: For each of the ifType values to which the media-specific MIB applies, it must specify the mapping of ifType values to media-specific MIB module(s) and instances of MIB objects within those modules.
- ifXxxOctets: The definitions of ifInOctets and ifOutOctets (and similarly, ifHCInOctets and ifHCOutOctets) specify that their values include framing characters. The media-specific MIB designer MUST specify any special conditions of the media concerning the inclusion of framing characters, especially with respect to frames with errors.
BUT, and this is a big one 🚨, wherever this interface MIB is specific about the semantics, DESCRIPTION, or applicability of objects, the media-specific MIB designer MUST NOT change said semantics, DESCRIPTION, or applicability. No rewriting the rules just because it's convenient 🙅♀️
5. Overview 🌈
so this MIB has 4 tables. Here's the lineup:
ifTable: This is the ifTable from MIB-II, just the classic one, no notes 💖
ifXTable: This one holds the objects that got added to the Interface MIB during the Interface Evolution effort. It also holds replacements for objects from the original (MIB-II) ifTable that got deprecated, because what they mean changed a lot. And it picks up the objects that used to live in the ifExtnsTable 🦋
ifStackTable: This one is all about how the sub-layers of an interface relate to each other. Think of it as the family tree of an interface 🌳
ifRcvAddressTable: This one holds the media-level addresses that an interface will receive. It's a generic table, so the people designing media-specific MIBs have to spell out exactly how it works for their particular MIB 🧚
6. Interfaces Group Definitions 🎀
okay this is the actual MIB code, so every single character matters 💅 Here it is, exactly as written:
IF-MIB DEFINITIONS ::= BEGIN
IMPORTS
MODULE-IDENTITY, OBJECT-TYPE, Counter32, Gauge32, Counter64,
Integer32, TimeTicks, mib-2,
NOTIFICATION-TYPE FROM SNMPv2-SMI
TEXTUAL-CONVENTION, DisplayString,
PhysAddress, TruthValue, RowStatus,
TimeStamp, AutonomousType, TestAndIncr FROM SNMPv2-TC
MODULE-COMPLIANCE, OBJECT-GROUP,
NOTIFICATION-GROUP FROM SNMPv2-CONF
snmpTraps FROM SNMPv2-MIB
IANAifType FROM IANAifType-MIB;
ifMIB MODULE-IDENTITY
LAST-UPDATED "200006140000Z"
ORGANIZATION "IETF Interfaces MIB Working Group"
CONTACT-INFO
" Keith McCloghrie
Cisco Systems, Inc.
170 West Tasman Drive
San Jose, CA 95134-1706
US
408-526-5260
kzm@cisco.com"
DESCRIPTION
"The MIB module to describe generic objects for network
interface sub-layers. This MIB is an updated version of
MIB-II's ifTable, and incorporates the extensions defined in
RFC 1229."
REVISION "200006140000Z"
DESCRIPTION
"Clarifications agreed upon by the Interfaces MIB WG, and
published as RFC 2863."
REVISION "199602282155Z"
DESCRIPTION
"Revisions made by the Interfaces MIB WG, and published in
RFC 2233."
REVISION "199311082155Z"
DESCRIPTION
"Initial revision, published as part of RFC 1573."
::= { mib-2 31 }
ifMIBObjects OBJECT IDENTIFIER ::= { ifMIB 1 }
interfaces OBJECT IDENTIFIER ::= { mib-2 2 }
--
-- Textual Conventions
--
-- OwnerString has the same semantics as used in RFC 1271
OwnerString ::= TEXTUAL-CONVENTION
DISPLAY-HINT "255a"
STATUS deprecated
DESCRIPTION
"This data type is used to model an administratively
assigned name of the owner of a resource. This information
is taken from the NVT ASCII character set. It is suggested
that this name contain one or more of the following: ASCII
form of the manager station's transport address, management
station name (e.g., domain name), network management
personnel's name, location, or phone number. In some cases
the agent itself will be the owner of an entry. In these
cases, this string shall be set to a string starting with
'agent'."
SYNTAX OCTET STRING (SIZE(0..255))
-- InterfaceIndex contains the semantics of ifIndex and should be used
-- for any objects defined in other MIB modules that need these semantics.
InterfaceIndex ::= TEXTUAL-CONVENTION
DISPLAY-HINT "d"
STATUS current
DESCRIPTION
"A unique value, greater than zero, for each interface or
interface sub-layer in the managed system. It is
recommended that values are assigned contiguously starting
from 1. The value for each interface sub-layer must remain
constant at least from one re-initialization of the entity's
network management system to the next re-initialization."
SYNTAX Integer32 (1..2147483647)
InterfaceIndexOrZero ::= TEXTUAL-CONVENTION
DISPLAY-HINT "d"
STATUS current
DESCRIPTION
"This textual convention is an extension of the
InterfaceIndex convention. The latter defines a greater
than zero value used to identify an interface or interface
sub-layer in the managed system. This extension permits the
additional value of zero. the value zero is object-specific
and must therefore be defined as part of the description of
any object which uses this syntax. Examples of the usage of
zero might include situations where interface was unknown,
or when none or all interfaces need to be referenced."
SYNTAX Integer32 (0..2147483647)
ifNumber OBJECT-TYPE
SYNTAX Integer32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The number of network interfaces (regardless of their
current state) present on this system."
::= { interfaces 1 }
ifTableLastChange OBJECT-TYPE
SYNTAX TimeTicks
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value of sysUpTime at the time of the last creation or
deletion of an entry in the ifTable. If the number of
entries has been unchanged since the last re-initialization
of the local network management subsystem, then this object
contains a zero value."
::= { ifMIBObjects 5 }
-- the Interfaces table
-- The Interfaces table contains information on the entity's
-- interfaces. Each sub-layer below the internetwork-layer
-- of a network interface is considered to be an interface.
ifTable OBJECT-TYPE
SYNTAX SEQUENCE OF IfEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A list of interface entries. The number of entries is
given by the value of ifNumber."
::= { interfaces 2 }
ifEntry OBJECT-TYPE
SYNTAX IfEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"An entry containing management information applicable to a
particular interface."
INDEX { ifIndex }
::= { ifTable 1 }
IfEntry ::=
SEQUENCE {
ifIndex InterfaceIndex,
ifDescr DisplayString,
ifType IANAifType,
ifMtu Integer32,
ifSpeed Gauge32,
ifPhysAddress PhysAddress,
ifAdminStatus INTEGER,
ifOperStatus INTEGER,
ifLastChange TimeTicks,
ifInOctets Counter32,
ifInUcastPkts Counter32,
ifInNUcastPkts Counter32, -- deprecated
ifInDiscards Counter32,
ifInErrors Counter32,
ifInUnknownProtos Counter32,
ifOutOctets Counter32,
ifOutUcastPkts Counter32,
ifOutNUcastPkts Counter32, -- deprecated
ifOutDiscards Counter32,
ifOutErrors Counter32,
ifOutQLen Gauge32, -- deprecated
ifSpecific OBJECT IDENTIFIER -- deprecated
}
ifIndex OBJECT-TYPE
SYNTAX InterfaceIndex
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"A unique value, greater than zero, for each interface. It
is recommended that values are assigned contiguously
starting from 1. The value for each interface sub-layer
must remain constant at least from one re-initialization of
the entity's network management system to the next re-
initialization."
::= { ifEntry 1 }
ifDescr OBJECT-TYPE
SYNTAX DisplayString (SIZE (0..255))
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"A textual string containing information about the
interface. This string should include the name of the
manufacturer, the product name and the version of the
interface hardware/software."
::= { ifEntry 2 }
ifType OBJECT-TYPE
SYNTAX IANAifType
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The type of interface. Additional values for ifType are
assigned by the Internet Assigned Numbers Authority (IANA),
through updating the syntax of the IANAifType textual
convention."
::= { ifEntry 3 }
ifMtu OBJECT-TYPE
SYNTAX Integer32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The size of the largest packet which can be sent/received
on the interface, specified in octets. For interfaces that
are used for transmitting network datagrams, this is the
size of the largest network datagram that can be sent on the
interface."
::= { ifEntry 4 }Okay bestie, we're picking up right where the speed stuff left off 🫶
ifSpeed OBJECT-TYPE
SYNTAX Gauge32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"An estimate of the interface's current bandwidth in bits
per second. For interfaces which do not vary in bandwidth
or for those where no accurate estimation can be made, this
object should contain the nominal bandwidth. If the
bandwidth of the interface is greater than the maximum value
reportable by this object then this object should report its
maximum value (4,294,967,295) and ifHighSpeed must be used
to report the interace's speed. For a sub-layer which has
no concept of bandwidth, this object should be zero."
::= { ifEntry 5 }So ifSpeed 🚀 is basically the interface's bandwidth in bits per second, but it's an estimate, ngl. If the speed never changes (or you can't measure it accurately), you just report the nominal bandwidth. And if the real speed is bigger than what this 32-bit field can hold, you cap it at 4,294,967,295 and point people to ifHighSpeed for the real number 💅. A sub-layer with no concept of bandwidth at all just reports zero. Not everything has a speed, and that's fine 🌸
ifPhysAddress OBJECT-TYPE
SYNTAX PhysAddress
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The interface's address at its protocol sub-layer. For
example, for an 802.x interface, this object normally
contains a MAC address. The interface's media-specific MIB
must define the bit and byte ordering and the format of the
value of this object. For interfaces which do not have such
an address (e.g., a serial line), this object should contain
an octet string of zero length."
::= { ifEntry 6 }ifPhysAddress 🪪 is the interface's address at its own protocol sub-layer. For an 802.x interface, that's usually a MAC address, obviously. The bit order, byte order, and format are up to the media-specific MIB for that medium, so go check there 🧚 And if the interface doesn't have an address at all, like a serial line, it should hold an octet string of zero length. Empty but valid, iconic 🎀
ifAdminStatus OBJECT-TYPE
SYNTAX INTEGER {
up(1), -- ready to pass packets
down(2),
testing(3) -- in some test mode
}
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"The desired state of the interface. The testing(3) state
indicates that no operational packets can be passed. When a
managed system initializes, all interfaces start with
ifAdminStatus in the down(2) state. As a result of either
explicit management action or per configuration information
retained by the managed system, ifAdminStatus is then
changed to either the up(1) or testing(3) states (or remains
in the down(2) state)."
::= { ifEntry 7 }ifAdminStatus 🔐 is the state you want the interface to be in. It's the admin's wish list, basically. When a managed system boots up, every interface starts out as down(2). After that, either someone takes explicit management action or the saved configuration says so, and it moves to up(1) or testing(3). Or, if nobody touches it, it just stays down(2) 💀 And testing(3) is the one that's giving "no operational packets allowed here," so don't expect traffic in that mode 🙈
ifOperStatus OBJECT-TYPE
SYNTAX INTEGER {
up(1), -- ready to pass packets
down(2),
testing(3), -- in some test mode
unknown(4), -- status can not be determined
-- for some reason.
dormant(5),
notPresent(6), -- some component is missing
lowerLayerDown(7) -- down due to state of
-- lower-layer interface(s)
}
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The current operational state of the interface. The
testing(3) state indicates that no operational packets can
be passed. If ifAdminStatus is down(2) then ifOperStatus
should be down(2). If ifAdminStatus is changed to up(1)
then ifOperStatus should change to up(1) if the interface is
ready to transmit and receive network traffic; it should
change to dormant(5) if the interface is waiting for
external actions (such as a serial line waiting for an
incoming connection); it should remain in the down(2) state
if and only if there is a fault that prevents it from going
to the up(1) state; it should remain in the notPresent(6)
state if the interface has missing (typically, hardware)
components."
::= { ifEntry 8 }ifOperStatus 🌈 is the real current state, which is the big-brain counterpart to ifAdminStatus. Testing(3) still means no operational packets 🫠 If admin says down(2), operational has to be down(2) too, no debate. If admin says up(1), operational should follow to up(1) once the interface is actually ready to send and receive traffic. If it's sitting around waiting for something outside, like a serial line waiting for someone to connect, it goes dormant(5) instead ✨ It only stays down(2) when a fault is actually stopping it from coming up, and it stays notPresent(6) when hardware parts are missing. That's the whole vibe, and it's lowkey very precise 🔥
ifLastChange OBJECT-TYPE
SYNTAX TimeTicks
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value of sysUpTime at the time the interface entered
its current operational state. If the current state was
entered prior to the last re-initialization of the local
network management subsystem, then this object contains a
zero value."
::= { ifEntry 9 }ifLastChange ⏰ tells you the sysUpTime at the moment the interface entered its current operational state. Think of it as the timestamp of its latest glow-up. But if that state started before the local network management subsystem last re-initialized, the timestamp got wiped, so you'll see zero 🥲
ifInOctets OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The total number of octets received on the interface,
including framing characters.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifEntry 10 }ifInOctets 📥 is the running total of every octet that came in on the interface, framing characters included. Counters can skip or reset at management re-initialization, and at other moments that ifCounterDiscontinuityTime will tell you about 🦋
ifInUcastPkts OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The number of packets, delivered by this sub-layer to a
higher (sub-)layer, which were not addressed to a multicast
or broadcast address at this sub-layer.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifEntry 11 }ifInUcastPkts 🎯 counts packets this sub-layer handed up to a higher layer, as long as they weren't addressed to a multicast or broadcast address at this sub-layer. The same discontinuity rules apply, so keep ifCounterDiscontinuityTime in your back pocket 💜
ifInNUcastPkts OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS deprecated
DESCRIPTION
"The number of packets, delivered by this sub-layer to a
higher (sub-)layer, which were addressed to a multicast or
broadcast address at this sub-layer.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime.
This object is deprecated in favour of ifInMulticastPkts and
ifInBroadcastPkts."
::= { ifEntry 12 }ifInNUcastPkts 👋 is the packets-delivered-up counter for multicast and broadcast traffic, but it's been deprecated 😭 The replacements are ifInMulticastPkts and ifInBroadcastPkts, so that's where the new drama lives now. Same discontinuity warning as always 🥀
ifInDiscards OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The number of inbound packets which were chosen to be
discarded even though no errors had been detected to prevent
their being deliverable to a higher-layer protocol. One
possible reason for discarding such a packet could be to
free up buffer space.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifEntry 13 }ifInDiscards 🗑️ counts inbound packets that got tossed even though nothing was wrong with them. Nothing was broken, they just weren't delivered upward. One possible reason is freeing up buffer space, which is honestly a relatable energy 😂 Discontinuities apply here too 🌸
ifInErrors OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"For packet-oriented interfaces, the number of inbound
packets that contained errors preventing them from being
deliverable to a higher-layer protocol. For character-
oriented or fixed-length interfaces, the number of inbound
transmission units that contained errors preventing them
from being deliverable to a higher-layer protocol.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifEntry 14 }ifInErrors 🚨 is the "something was actually broken" counter. For packet-oriented interfaces it counts inbound packets with errors that stopped them from reaching a higher-layer protocol. For character-oriented or fixed-length interfaces, it counts transmission units instead 🧩 Same discontinuity rules, same vibes 💅
ifInUnknownProtos OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"For packet-oriented interfaces, the number of packets
received via the interface which were discarded because of
an unknown or unsupported protocol. For character-oriented
or fixed-length interfaces that support protocol
multiplexing the number of transmission units received via
the interface which were discarded because of an unknown or
unsupported protocol. For any interface that does not
support protocol multiplexing, this counter will always be
0.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifEntry 15 }ifInUnknownProtos 🤷♀️ counts packets (or transmission units, for character-oriented or fixed-length interfaces that do protocol multiplexing) that got discarded because the protocol was unknown or unsupported. And here's the twist: if an interface doesn't support protocol multiplexing at all, this counter is always 0. Not sometimes, always 🌈 Discontinuities still apply, obviously 🫶
ifOutOctets OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The total number of octets transmitted out of the
interface, including framing characters.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifEntry 16 }ifOutOctets 📤 is the outbound mirror of ifInOctets: every octet sent out the interface, framing characters included, with the same discontinuity caveats 🎀
ifOutUcastPkts OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The total number of packets that higher-level protocols
requested be transmitted, and which were not addressed to a
multicast or broadcast address at this sub-layer, including
those that were discarded or not sent.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifEntry 17 }ifOutUcastPkts 🍓 counts the packets that higher-level protocols asked to send, as long as they weren't going to a multicast or broadcast address at this sub-layer. The fun part: this includes the ones that got discarded or never sent at all. The request counts even if the packet didn't leave 😤 Discontinuities, you know the drill 💖
ifOutNUcastPkts OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS deprecated
DESCRIPTION
"The total number of packets that higher-level protocols
requested be transmitted, and which were addressed to a
multicast or broadcast address at this sub-layer, including
those that were discarded or not sent.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime.
This object is deprecated in favour of ifOutMulticastPkts
and ifOutBroadcastPkts."
::= { ifEntry 18 }ifOutNUcastPkts 📣 is the multicast-and-broadcast version of the outbound request counter, and yep, it's deprecated too 😩 Use ifOutMulticastPkts and ifOutBroadcastPkts instead. Bestie, the deprecation train keeps going 🚂
ifOutDiscards OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The number of outbound packets which were chosen to be
discarded even though no errors had been detected to prevent
their being transmitted. One possible reason for discarding
such a packet could be to free up buffer space.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifEntry 19 }ifOutDiscards 🧹 is the outbound version of the inbound discard counter: packets dropped on purpose with no errors detected to block their transmission. Freeing up buffer space is again the example given, so it's a whole vibe of "making room" 🛏️
ifOutErrors OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"For packet-oriented interfaces, the number of outbound
packets that could not be transmitted because of errors.
For character-oriented or fixed-length interfaces, the
number of outbound transmission units that could not be
transmitted because of errors.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifEntry 20 }ifOutErrors 💥 is the outbound "couldn't send because something broke" counter. Packet-oriented interfaces count packets, and character-oriented or fixed-length ones count transmission units instead 🙃 Discontinuities apply, as always 💜
ifOutQLen OBJECT-TYPE
SYNTAX Gauge32
MAX-ACCESS read-only
STATUS deprecated
DESCRIPTION
"The length of the output packet queue (in packets)."
::= { ifEntry 21 }And last but not least, ifOutQLen 📦 tells you how long the output packet queue is, measured in packets. It's a Gauge, so it's a snapshot, not a running total. Sadly it's deprecated too, so it's a bit of a sunset moment 🌅 ✨
Okay bestie, the ifSpecific object is the one that points at the media-specific stuff, and then we get to the ifX extension table. Let's gooo 💅✨
ifSpecific OBJECT-TYPE
SYNTAX OBJECT IDENTIFIER
MAX-ACCESS read-only
STATUS deprecated
DESCRIPTION
"A reference to MIB definitions specific to the particular
media being used to realize the interface. It is
recommended that this value point to an instance of a MIB
object in the media-specific MIB, i.e., that this object
have the semantics associated with the InstancePointer
textual convention defined in RFC 2579. In fact, it is
recommended that the media-specific MIB specify what value
ifSpecific should/can take for values of ifType. If no MIB
definitions specific to the particular media are available,
the value should be set to the OBJECT IDENTIFIER { 0 0 }."
::= { ifEntry 22 }
--
-- Extension to the interface table
--
-- This table replaces the ifExtnsTable table.
--
ifXTable OBJECT-TYPE
SYNTAX SEQUENCE OF IfXEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A list of interface entries. The number of entries is
given by the value of ifNumber. This table contains
additional objects for the interface table."
::= { ifMIBObjects 1 }
ifXEntry OBJECT-TYPE
SYNTAX IfXEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"An entry containing additional management information
applicable to a particular interface."
AUGMENTS { ifEntry }
::= { ifXTable 1 }
IfXEntry ::=
SEQUENCE {
ifName DisplayString,
ifInMulticastPkts Counter32,
ifInBroadcastPkts Counter32,
ifOutMulticastPkts Counter32,
ifOutBroadcastPkts Counter32,
ifHCInOctets Counter64,
ifHCInUcastPkts Counter64,
ifHCInMulticastPkts Counter64,
ifHCInBroadcastPkts Counter64,
ifHCOutOctets Counter64,
ifHCOutUcastPkts Counter64,
ifHCOutMulticastPkts Counter64,
ifHCOutBroadcastPkts Counter64,
ifLinkUpDownTrapEnable INTEGER,
ifHighSpeed Gauge32,
ifPromiscuousMode TruthValue,
ifConnectorPresent TruthValue,
ifAlias DisplayString,
ifCounterDiscontinuityTime TimeStamp
}
ifName OBJECT-TYPE
SYNTAX DisplayString
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The textual name of the interface. The value of this
object should be the name of the interface as assigned by
the local device and should be suitable for use in commands
entered at the device's `console'. This might be a text
name, such as `le0' or a simple port number, such as `1',
depending on the interface naming syntax of the device. If
several entries in the ifTable together represent a single
interface as named by the device, then each will have the
same value of ifName. Note that for an agent which responds
to SNMP queries concerning an interface on some other
(proxied) device, then the value of ifName for such an
interface is the proxied device's local name for it.
If there is no local name, or this object is otherwise not
applicable, then this object contains a zero-length string."
::= { ifXEntry 1 }
ifInMulticastPkts OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The number of packets, delivered by this sub-layer to a
higher (sub-)layer, which were addressed to a multicast
address at this sub-layer. For a MAC layer protocol, this
includes both Group and Functional addresses.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 2 }
ifInBroadcastPkts OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The number of packets, delivered by this sub-layer to a
higher (sub-)layer, which were addressed to a broadcast
address at this sub-layer.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 3 }
ifOutMulticastPkts OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The total number of packets that higher-level protocols
requested be transmitted, and which were addressed to a
multicast address at this sub-layer, including those that
were discarded or not sent. For a MAC layer protocol, this
includes both Group and Functional addresses.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 4 }
ifOutBroadcastPkts OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The total number of packets that higher-level protocols
requested be transmitted, and which were addressed to a
broadcast address at this sub-layer, including those that
were discarded or not sent.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 5 }
--
-- High Capacity Counter objects. These objects are all
-- 64 bit versions of the "basic" ifTable counters. These
-- objects all have the same basic semantics as their 32-bit
-- counterparts, however, their syntax has been extended
-- to 64 bits.
--
ifHCInOctets OBJECT-TYPE
SYNTAX Counter64
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The total number of octets received on the interface,
including framing characters. This object is a 64-bit
version of ifInOctets.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 6 }
ifHCInUcastPkts OBJECT-TYPE
SYNTAX Counter64
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The number of packets, delivered by this sub-layer to a
higher (sub-)layer, which were not addressed to a multicast
or broadcast address at this sub-layer. This object is a
64-bit version of ifInUcastPkts.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 7 }
ifHCInMulticastPkts OBJECT-TYPE
SYNTAX Counter64
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The number of packets, delivered by this sub-layer to a
higher (sub-)layer, which were addressed to a multicast
address at this sub-layer. For a MAC layer protocol, this
includes both Group and Functional addresses. This object
is a 64-bit version of ifInMulticastPkts.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 8 }
ifHCInBroadcastPkts OBJECT-TYPE
SYNTAX Counter64
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The number of packets, delivered by this sub-layer to a
higher (sub-)layer, which were addressed to a broadcast
address at this sub-layer. This object is a 64-bit version
of ifInBroadcastPkts.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 9 }
ifHCOutOctets OBJECT-TYPE
SYNTAX Counter64
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The total number of octets transmitted out of the
interface, including framing characters. This object is a
64-bit version of ifOutOctets.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 10 }
ifHCOutUcastPkts OBJECT-TYPE
SYNTAX Counter64
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The total number of packets that higher-level protocols
requested be transmitted, and which were not addressed to a
multicast or broadcast address at this sub-layer, including
those that were discarded or not sent. This object is a
64-bit version of ifOutUcastPkts.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 11 }
ifHCOutMulticastPkts OBJECT-TYPE
SYNTAX Counter64
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The total number of packets that higher-level protocols
requested be transmitted, and which were addressed to a
multicast address at this sub-layer, including those that
were discarded or not sent. For a MAC layer protocol, this
includes both Group and Functional addresses. This object
is a 64-bit version of ifOutMulticastPkts.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 12 }
ifHCOutBroadcastPkts OBJECT-TYPE
SYNTAX Counter64
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The total number of packets that higher-level protocols
requested be transmitted, and which were addressed to a
broadcast address at this sub-layer, including those that
were discarded or not sent. This object is a 64-bit version
of ifOutBroadcastPkts.
Discontinuities in the value of this counter can occur at
re-initialization of the management system, and at other
times as indicated by the value of
ifCounterDiscontinuityTime."
::= { ifXEntry 13 }okay so the next bit is all about the little knobs and dials every interface has 💅
First up is ifLinkUpDownTrapEnable 🎀, a read-write setting that controls whether linkUp/linkDown traps get generated for an interface. By default it's enabled(1) for interfaces that don't sit "on top" of any other interface (the ifStackTable stuff), and disabled(2) for the ones that do. 🦋
ifLinkUpDownTrapEnable OBJECT-TYPE
SYNTAX INTEGER { enabled(1), disabled(2) }
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"Indicates whether linkUp/linkDown traps should be generated
for this interface.
By default, this object should have the value enabled(1) for
interfaces which do not operate on 'top' of any other
interface (as defined in the ifStackTable), and disabled(2)
otherwise."
::= { ifXEntry 14 }Next is ifHighSpeed 🚀, a read-only Gauge32 that's basically an estimate of the interface's current bandwidth, measured in units of 1,000,000 bits per second. The vibe is "close enough, not exact": if it reads n, the real speed is somewhere between n-500,000 and n+499,999. 🌸 Interfaces whose bandwidth never changes (or where nobody can estimate it accurately) just carry their nominal bandwidth. And a sub-layer with no concept of bandwidth at all reports zero. 🙈
ifHighSpeed OBJECT-TYPE
SYNTAX Gauge32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"An estimate of the interface's current bandwidth in units
of 1,000,000 bits per second. If this object reports a
value of `n' then the speed of the interface is somewhere in
the range of `n-500,000' to `n+499,999'. For interfaces
which do not vary in bandwidth or for those where no
accurate estimation can be made, this object should contain
the nominal bandwidth. For a sub-layer which has no concept
of bandwidth, this object should be zero."
::= { ifXEntry 15 }Now ifPromiscuousMode 👀, a read-write TruthValue. false(2) means the interface only takes in packets/frames addressed to this station. true(1) means the station grabs everything it sees on the media. 💅 Only certain types of media can do true(1) at all, and if your media is one of them, flipping it on might need an interface reset before it actually kicks in. Also, this setting has zero effect on broadcast and multicast traffic. Periodt. ✨
ifPromiscuousMode OBJECT-TYPE
SYNTAX TruthValue
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"This object has a value of false(2) if this interface only
accepts packets/frames that are addressed to this station.
This object has a value of true(1) when the station accepts
all packets/frames transmitted on the media. The value
true(1) is only legal on certain types of media. If legal,
setting this object to a value of true(1) may require the
interface to be reset before becoming effective.
The value of ifPromiscuousMode does not affect the reception
of broadcast and multicast packets/frames by the interface."
::= { ifXEntry 16 }ifConnectorPresent 🔌 is a read-only TruthValue that's simply true(1) if the interface sublayer has a physical connector, and false(2) if it doesn't. Very straightforward, very iconic. 💖
ifConnectorPresent OBJECT-TYPE
SYNTAX TruthValue
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"This object has the value 'true(1)' if the interface
sublayer has a physical connector and the value 'false(2)'
otherwise."
::= { ifXEntry 17 }Okay, ifAlias 🏷️ is my favourite. It's a read-write DisplayString of up to 64 characters that a network manager sets as a nickname for the interface, basically a non-volatile "handle" for it. 🧚 Fresh interfaces start with the zero-length string. Once someone writes a value in, the agent has to hang onto it for as long as that interface exists, and that includes reboots of the management system and even when the interface's ifIndex changes. 😭 Like, the name survives everything. The example given is a WAN interface storing the Telco's circuit number. Some agents only let you write this for certain ifTypes. And any agent that does allow writes has to keep the value in non-volatile storage, though it can cap how long new values are based on how much storage the other interfaces are already using. 🍓
ifAlias OBJECT-TYPE
SYNTAX DisplayString (SIZE(0..64))
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"This object is an 'alias' name for the interface as
specified by a network manager, and provides a non-volatile
'handle' for the interface.
On the first instantiation of an interface, the value of
ifAlias associated with that interface is the zero-length
string. As and when a value is written into an instance of
ifAlias through a network management set operation, then the
agent must retain the supplied value in the ifAlias instance
associated with the same interface for as long as that
interface remains instantiated, including across all re-
initializations/reboots of the network management system,
including those which result in a change of the interface's
ifIndex value.
An example of the value which a network manager might store
in this object for a WAN interface is the (Telco's) circuit
number/identifier of the interface.
Some agents may support write-access only for interfaces
having particular values of ifType. An agent which supports
write access to this object is required to keep the value in
non-volatile storage, but it may limit the length of new
values depending on how much storage is already occupied by
the current values for other interfaces."
::= { ifXEntry 18 }Last one in this bunch is ifCounterDiscontinuityTime ⏰. It's a TimeStamp, read-only, and it tells you the sysUpTime from the most recent moment any of this interface's counters had a discontinuity. We're talking the Counter32 or Counter64 objects in the ifTable or ifXTable, specifically the ones for this interface. 🦋 If nothing has glitched since the local management subsystem last re-initialized, the value is zero. Clean record, bestie. 💜
ifCounterDiscontinuityTime OBJECT-TYPE
SYNTAX TimeStamp
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value of sysUpTime on the most recent occasion at which
any one or more of this interface's counters suffered a
discontinuity. The relevant counters are the specific
instances associated with this interface of any Counter32 or
Counter64 object contained in the ifTable or ifXTable. If
no such discontinuities have occurred since the last re-
initialization of the local management subsystem, then this
object contains a zero value."
::= { ifXEntry 19 }Now we're entering the Interface Stack Group 🥞, which is the family of objects that describes how interfaces are layered on top of each other. The group is optional, but it's strongly recommended for all systems. Honestly, you'd want it. ✨
-- The Interface Stack Group
--
-- Implementation of this group is optional, but strongly recommended
-- for all systems
--ifStackTable 🧱 is the star of the stack group. It's a SEQUENCE OF IfStackEntry that holds the relationships between sublayers, meaning which sublayer runs on top of which other one. Each sublayer maps to a row in the ifTable. So if sublayer x runs over sublayer y, you'd see ifStackStatus.x.y=active in here. 💖 For every active ifIndex value I, there are always at least two live rows tied to it: one where I is the ifStackHigherLayer, and one where I is the ifStackLowerLayer. If I isn't involved in any multiplexing, those two are the only rows for it. 🍰 Even an interface with nothing stacked above or below it still has both rows, shown here with a 0 on the other side.
ifStackTable OBJECT-TYPE
SYNTAX SEQUENCE OF IfStackEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The table containing information on the relationships
between the multiple sub-layers of network interfaces. In
particular, it contains information on which sub-layers run
'on top of' which other sub-layers, where each sub-layer
corresponds to a conceptual row in the ifTable. For
example, when the sub-layer with ifIndex value x runs over
the sub-layer with ifIndex value y, then this table
contains:
ifStackStatus.x.y=active
For each ifIndex value, I, which identifies an active
interface, there are always at least two instantiated rows
in this table associated with I. For one of these rows, I
is the value of ifStackHigherLayer; for the other, I is the
value of ifStackLowerLayer. (If I is not involved in
multiplexing, then these are the only two rows associated
with I.)
For example, two rows exist even for an interface which has
no others stacked on top or below it:
ifStackStatus.0.x=active
ifStackStatus.x.0=active "
::= { ifMIBObjects 2 }ifStackEntry 📋 is the row for one relationship between two sublayers. It says one sublayer runs on 'top' of the other. Each sublayer is still a conceptual row in the ifTable. It's indexed by ifStackHigherLayer and ifStackLowerLayer, and it's not accessible directly. 🙈
ifStackEntry OBJECT-TYPE
SYNTAX IfStackEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Information on a particular relationship between two sub-
layers, specifying that one sub-layer runs on 'top' of the
other sub-layer. Each sub-layer corresponds to a conceptual
row in the ifTable."
INDEX { ifStackHigherLayer, ifStackLowerLayer }
::= { ifStackTable 1 }Here's the SEQUENCE that defines the columns for each stack entry, which is just the two layer indices plus the status. 🧁
IfStackEntry ::=
SEQUENCE {
ifStackHigherLayer InterfaceIndexOrZero,
ifStackLowerLayer InterfaceIndexOrZero,
ifStackStatus RowStatus
}ifStackHigherLayer ⬆️ is the ifIndex of the higher sublayer in the relationship, the one running on top of the lower sublayer. If there's no higher sublayer (below the internetwork layer), this is 0. ✨
ifStackHigherLayer OBJECT-TYPE
SYNTAX InterfaceIndexOrZero
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The value of ifIndex corresponding to the higher sub-layer
of the relationship, i.e., the sub-layer which runs 'on top'
of the sub-layer identified by the corresponding instance of
ifStackLowerLayer. If there is no higher sub-layer (below
the internetwork layer), then this object has the value 0."
::= { ifStackEntry 1 }ifStackLowerLayer ⬇️ is the mirror image: the ifIndex of the lower sublayer, the one running below. If there's no lower sublayer, it's 0. 🫶
ifStackLowerLayer OBJECT-TYPE
SYNTAX InterfaceIndexOrZero
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The value of ifIndex corresponding to the lower sub-layer
of the relationship, i.e., the sub-layer which runs 'below'
the sub-layer identified by the corresponding instance of
ifStackHigherLayer. If there is no lower sub-layer, then
this object has the value 0."
::= { ifStackEntry 2 }ifStackStatus 🚦 is a read-create RowStatus that shows the state of the relationship between two sublayers. ngl, this one is a little dangerous. Flipping it from 'active' to 'notInService' or 'destroy' is likely to ripple up and down the whole interface stack. 😭 That's why write access is probably a bad idea for a lot of interface types, and plenty of implementations just don't let you write it at all. Be careful with this one, bestie. 💀
ifStackStatus OBJECT-TYPE
SYNTAX RowStatus
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The status of the relationship between two sub-layers.
Changing the value of this object from 'active' to
'notInService' or 'destroy' will likely have consequences up
and down the interface stack. Thus, write access to this
object is likely to be inappropriate for some types of
interfaces, and many implementations will choose not to
support write-access for any type of interface."
::= { ifStackEntry 3 }ifStackLastChange 🕰️ is a read-only TimeTicks showing the sysUpTime of the last change to the whole interface stack. A "change" here means any creation, deletion, or value change of any ifStackStatus instance. If nothing has changed since the local network management subsystem last re-initialized, the value is zero. 🌈
ifStackLastChange OBJECT-TYPE
SYNTAX TimeTicks
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value of sysUpTime at the time of the last change of
the (whole) interface stack. A change of the interface
stack is defined to be any creation, deletion, or change in
value of any instance of ifStackStatus. If the interface
stack has been unchanged since the last re-initialization of
the local network management subsystem, then this object
contains a zero value."
::= { ifMIBObjects 6 }Next up is the Generic Receive Address Table 📬. The group is mandatory for any interface that can receive packets/frames addressed to more than one address. It also replaces the ifExtnsRcvAddr table. The big difference is that this one uses the RowStatus textual convention, which the old one didn't. ✨
-- Generic Receive Address Table
--
-- This group of objects is mandatory for all types of
-- interfaces which can receive packets/frames addressed to
-- more than one address.
--
-- This table replaces the ifExtnsRcvAddr table. The main
-- difference is that this table makes use of the RowStatus
-- textual convention, while ifExtnsRcvAddr did not.ifRcvAddressTable 📖 has an entry for each address (broadcast, multicast, or unicast) the system will receive packets/frames on for a particular interface. There are two exceptions, and they're kind of cute:
- Promiscuous mode 👁️: you only need entries for the addresses the system would have received without promiscuous mode on.
- 802.5 functional addresses 🎯: just one entry is needed, for the address you get by ANDing the functional address bit with the bit mask of every functional address the interface will accept frames for.
And a bonus: a system can normally use any unicast address listed in this table as a source address. 💜
ifRcvAddressTable OBJECT-TYPE
SYNTAX SEQUENCE OF IfRcvAddressEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"This table contains an entry for each address (broadcast,
multicast, or uni-cast) for which the system will receive
packets/frames on a particular interface, except as follows:
- for an interface operating in promiscuous mode, entries
are only required for those addresses for which the system
would receive frames were it not operating in promiscuous
mode.
- for 802.5 functional addresses, only one entry is
required, for the address which has the functional address
bit ANDed with the bit mask of all functional addresses for
which the interface will accept frames.
A system is normally able to use any unicast address which
corresponds to an entry in this table as a source address."
::= { ifMIBObjects 4 }ifRcvAddressEntry 🪪 is the row itself, a little list of objects identifying an address the system will accept packets/frames for on the interface with that ifIndex. It's indexed by ifIndex and ifRcvAddressAddress. 🧚
ifRcvAddressEntry OBJECT-TYPE
SYNTAX IfRcvAddressEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A list of objects identifying an address for which the
system will accept packets/frames on the particular
interface identified by the index value ifIndex."
INDEX { ifIndex, ifRcvAddressAddress }
::= { ifRcvAddressTable 1 }And here's the column layout, with the address, the status, and the type. 🍬
IfRcvAddressEntry ::=
SEQUENCE {
ifRcvAddressAddress PhysAddress,
ifRcvAddressStatus RowStatus,
ifRcvAddressType INTEGER
}ifRcvAddressAddress 🏠 is the PhysAddress itself, an address the system will accept packets/frames on for this entry's interface. It's not accessible directly, since it's the index. 💅
ifRcvAddressAddress OBJECT-TYPE
SYNTAX PhysAddress
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"An address for which the system will accept packets/frames
on this entry's interface."
::= { ifRcvAddressEntry 1 }Last one for this part is ifRcvAddressStatus ✅, a read-create RowStatus used to create and delete rows in the ifRcvAddressTable. That's how you add or remove a receive address. 🌸
ifRcvAddressStatus OBJECT-TYPE
SYNTAX RowStatus
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"This object is used to create and delete rows in the
ifRcvAddressTable."
::= { ifRcvAddressEntry 2 }Okay bestie, so this is where ifRcvAddressType gets its whole personality 💅. It's an enum with three vibes: nonVolatile(3) means the entry is valid and survives a restart 💾, volatile(2) means it exists but was never saved so it's gone after a restart 🫠, and other(1) means it's valid but nobody's classified whether it sticks around 🤷♀️. The default is volatile, so if nothing else gets set, it's volatile ✨.
ifRcvAddressType OBJECT-TYPE
SYNTAX INTEGER {
other(1),
volatile(2),
nonVolatile(3)
}
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"This object has the value nonVolatile(3) for those entries
in the table which are valid and will not be deleted by the
next restart of the managed system. Entries having the
value volatile(2) are valid and exist, but have not been
saved, so that will not exist after the next restart of the
managed system. Entries having the value other(1) are valid
and exist but are not classified as to whether they will
continue to exist after the next restart."
DEFVAL { volatile }
::= { ifRcvAddressEntry 3 }
-- definition of interface-related traps.
linkDown NOTIFICATION-TYPE
OBJECTS { ifIndex, ifAdminStatus, ifOperStatus }
STATUS current
DESCRIPTION
"A linkDown trap signifies that the SNMP entity, acting in
an agent role, has detected that the ifOperStatus object for
one of its communication links is about to enter the down
state from some other state (but not from the notPresent
state). This other state is indicated by the included value
of ifOperStatus."
::= { snmpTraps 3 }
linkUp NOTIFICATION-TYPE
OBJECTS { ifIndex, ifAdminStatus, ifOperStatus }
STATUS current
DESCRIPTION
"A linkUp trap signifies that the SNMP entity, acting in an
agent role, has detected that the ifOperStatus object for
one of its communication links left the down state and
transitioned into some other state (but not into the
notPresent state). This other state is indicated by the
included value of ifOperStatus."
::= { snmpTraps 4 }Now the traps 🚨. linkDown fires when an agent notices that an interface's ifOperStatus is about to drop into down from some other state, and it's not coming from notPresent 📉. linkUp is the glow-up version 📈: it fires when ifOperStatus climbs out of down into some other state, again not into notPresent. Both carry ifIndex, ifAdminStatus and ifOperStatus along for the ride 🧚.
-- conformance information
ifConformance OBJECT IDENTIFIER ::= { ifMIB 2 }
ifGroups OBJECT IDENTIFIER ::= { ifConformance 1 }
ifCompliances OBJECT IDENTIFIER ::= { ifConformance 2 }
-- compliance statements
ifCompliance3 MODULE-COMPLIANCE
STATUS current
DESCRIPTION
"The compliance statement for SNMP entities which have
network interfaces."
MODULE -- this module
MANDATORY-GROUPS { ifGeneralInformationGroup,
linkUpDownNotificationsGroup }
-- The groups:
-- ifFixedLengthGroup
-- ifHCFixedLengthGroup
-- ifPacketGroup
-- ifHCPacketGroup
-- ifVHCPacketGroup
-- are mutually exclusive; at most one of these groups is implemented
-- for a particular interface. When any of these groups is implemented
-- for a particular interface, then ifCounterDiscontinuityGroup must
-- also be implemented for that interface.
GROUP ifFixedLengthGroup
DESCRIPTION
"This group is mandatory for those network interfaces which
are character-oriented or transmit data in fixed-length
transmission units, and for which the value of the
corresponding instance of ifSpeed is less than or equal to
20,000,000 bits/second."
GROUP ifHCFixedLengthGroup
DESCRIPTION
"This group is mandatory for those network interfaces which
are character-oriented or transmit data in fixed-length
transmission units, and for which the value of the
corresponding instance of ifSpeed is greater than 20,000,000
bits/second."
GROUP ifPacketGroup
DESCRIPTION
"This group is mandatory for those network interfaces which
are packet-oriented, and for which the value of the
corresponding instance of ifSpeed is less than or equal to
20,000,000 bits/second."
GROUP ifHCPacketGroup
DESCRIPTION
"This group is mandatory only for those network interfaces
which are packet-oriented and for which the value of the
corresponding instance of ifSpeed is greater than 20,000,000
bits/second but less than or equal to 650,000,000
bits/second."
GROUP ifVHCPacketGroup
DESCRIPTION
"This group is mandatory only for those network interfaces
which are packet-oriented and for which the value of the
corresponding instance of ifSpeed is greater than
650,000,000 bits/second."
GROUP ifCounterDiscontinuityGroup
DESCRIPTION
"This group is mandatory for those network interfaces that
are required to maintain counters (i.e., those for which one
of the ifFixedLengthGroup, ifHCFixedLengthGroup,
ifPacketGroup, ifHCPacketGroup, or ifVHCPacketGroup is
mandatory)."
GROUP ifRcvAddressGroup
DESCRIPTION
"The applicability of this group MUST be defined by the
media-specific MIBs. Media-specific MIBs must define the
exact meaning, use, and semantics of the addresses in this
group."
OBJECT ifLinkUpDownTrapEnable
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT ifPromiscuousMode
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT ifAdminStatus
SYNTAX INTEGER { up(1), down(2) }
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required, nor is support for the value
testing(3)."
OBJECT ifAlias
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
::= { ifCompliances 3 }Here's the compliance section 🎀. ifCompliance3 is the statement for SNMP entities that have network interfaces, and it makes two groups mandatory no matter what: ifGeneralInformationGroup and linkUpDownNotificationsGroup 💖. The five counter groups (fixed-length, HC fixed-length, packet, HC packet and VHC packet) are mutually exclusive, so only one of them per interface, and whenever one of them is in play, ifCounterDiscontinuityGroup has to come along too 👑. Which one applies depends on whether the interface is packet- or character-oriented and on its ifSpeed, with the cutoffs at 20,000,000 and 650,000,000 bits/second 🔥. The ifRcvAddressGroup is the one that gets a real MUST in it: the media-specific MIBs have to define how it applies 🦋. Then a few objects get relaxed to read-only, so write access isn't required for ifLinkUpDownTrapEnable, ifPromiscuousMode, ifAdminStatus or ifAlias 🌸. For ifAdminStatus specifically, you only need up(1) and down(2), and you don't have to support testing(3) either 🙈.
-- units of conformance
ifGeneralInformationGroup OBJECT-GROUP
OBJECTS { ifIndex, ifDescr, ifType, ifSpeed, ifPhysAddress,
ifAdminStatus, ifOperStatus, ifLastChange,
ifLinkUpDownTrapEnable, ifConnectorPresent,
ifHighSpeed, ifName, ifNumber, ifAlias,
ifTableLastChange }
STATUS current
DESCRIPTION
"A collection of objects providing information applicable to
all network interfaces."
::= { ifGroups 10 }
-- the following five groups are mutually exclusive; at most
-- one of these groups is implemented for any interface
ifFixedLengthGroup OBJECT-GROUP
OBJECTS { ifInOctets, ifOutOctets, ifInUnknownProtos,
ifInErrors, ifOutErrors }
STATUS current
DESCRIPTION
"A collection of objects providing information specific to
non-high speed (non-high speed interfaces transmit and
receive at speeds less than or equal to 20,000,000
bits/second) character-oriented or fixed-length-transmission
network interfaces."
::= { ifGroups 2 }
ifHCFixedLengthGroup OBJECT-GROUP
OBJECTS { ifHCInOctets, ifHCOutOctets,
ifInOctets, ifOutOctets, ifInUnknownProtos,
ifInErrors, ifOutErrors }
STATUS current
DESCRIPTION
"A collection of objects providing information specific to
high speed (greater than 20,000,000 bits/second) character-
oriented or fixed-length-transmission network interfaces."
::= { ifGroups 3 }
ifPacketGroup OBJECT-GROUP
OBJECTS { ifInOctets, ifOutOctets, ifInUnknownProtos,
ifInErrors, ifOutErrors,
ifMtu, ifInUcastPkts, ifInMulticastPkts,
ifInBroadcastPkts, ifInDiscards,
ifOutUcastPkts, ifOutMulticastPkts,
ifOutBroadcastPkts, ifOutDiscards,
ifPromiscuousMode }
STATUS current
DESCRIPTION
"A collection of objects providing information specific to
non-high speed (non-high speed interfaces transmit and
receive at speeds less than or equal to 20,000,000
bits/second) packet-oriented network interfaces."
::= { ifGroups 4 }
ifHCPacketGroup OBJECT-GROUP
OBJECTS { ifHCInOctets, ifHCOutOctets,
ifInOctets, ifOutOctets, ifInUnknownProtos,
ifInErrors, ifOutErrors,
ifMtu, ifInUcastPkts, ifInMulticastPkts,
ifInBroadcastPkts, ifInDiscards,
ifOutUcastPkts, ifOutMulticastPkts,
ifOutBroadcastPkts, ifOutDiscards,
ifPromiscuousMode }
STATUS current
DESCRIPTION
"A collection of objects providing information specific to
high speed (greater than 20,000,000 bits/second but less
than or equal to 650,000,000 bits/second) packet-oriented
network interfaces."
::= { ifGroups 5 }
ifVHCPacketGroup OBJECT-GROUP
OBJECTS { ifHCInUcastPkts, ifHCInMulticastPkts,
ifHCInBroadcastPkts, ifHCOutUcastPkts,
ifHCOutMulticastPkts, ifHCOutBroadcastPkts,
ifHCInOctets, ifHCOutOctets,
ifInOctets, ifOutOctets, ifInUnknownProtos,
ifInErrors, ifOutErrors,
ifMtu, ifInUcastPkts, ifInMulticastPkts,
ifInBroadcastPkts, ifInDiscards,
ifOutUcastPkts, ifOutMulticastPkts,
ifOutBroadcastPkts, ifOutDiscards,
ifPromiscuousMode }
STATUS current
DESCRIPTION
"A collection of objects providing information specific to
higher speed (greater than 650,000,000 bits/second) packet-
oriented network interfaces."
::= { ifGroups 6 }
ifRcvAddressGroup OBJECT-GROUP
OBJECTS { ifRcvAddressStatus, ifRcvAddressType }
STATUS current
DESCRIPTION
"A collection of objects providing information on the
multiple addresses which an interface receives."
::= { ifGroups 7 }
ifStackGroup2 OBJECT-GROUP
OBJECTS { ifStackStatus, ifStackLastChange }
STATUS current
DESCRIPTION
"A collection of objects providing information on the
layering of MIB-II interfaces."
::= { ifGroups 11 }
ifCounterDiscontinuityGroup OBJECT-GROUP
OBJECTS { ifCounterDiscontinuityTime }
STATUS current
DESCRIPTION
"A collection of objects providing information specific to
interface counter discontinuities."
::= { ifGroups 13 }
linkUpDownNotificationsGroup NOTIFICATION-GROUP
NOTIFICATIONS { linkUp, linkDown }
STATUS current
DESCRIPTION
"The notifications which indicate specific changes in the
value of ifOperStatus."
::= { ifGroups 14 }Time for the groups 🧁. Each one is a bundle of objects with its own number under ifGroups. ifGeneralInformationGroup is the everyday basics for every interface 💅. The counter groups are the ones with the speed-based splits: the fixed-length pair covers character-oriented or fixed-length transmission, the packet trio covers packet-oriented, and each one is tied to its speed range ⚡. ifRcvAddressGroup is the multiple-receive-address bundle 📬, ifStackGroup2 is for the layering of MIB-II interfaces 🥞, ifCounterDiscontinuityGroup is the counter-reset tracker ⏰, and linkUpDownNotificationsGroup bundles the linkUp and linkDown traps 🔔.
-- Deprecated Definitions - Objects
--
-- The Interface Test Table
--
-- This group of objects is optional. However, a media-specific
-- MIB may make implementation of this group mandatory.
--
-- This table replaces the ifExtnsTestTableAnd the last bit is the start of the deprecated section 🕰️. The Interface Test Table is optional, unless a media-specific MIB makes it mandatory, and this table is the replacement for ifExtnsTestTable ✨.
Okay so this part is all about ifTestTable, and it's giving "deprecated but still iconic" 💀🎀 It has one entry per interface, and the entries are how a manager asks an agent to test an interface. Here's the whole thing, verbatim, because MIB definitions are code and we don't touch the code 🫶
--
ifTestTable OBJECT-TYPE
SYNTAX SEQUENCE OF IfTestEntry
MAX-ACCESS not-accessible
STATUS deprecated
DESCRIPTION
"This table contains one entry per interface. It defines
objects which allow a network manager to instruct an agent
to test an interface for various faults. Tests for an
interface are defined in the media-specific MIB for that
interface. After invoking a test, the object ifTestResult
can be read to determine the outcome. If an agent can not
perform the test, ifTestResult is set to so indicate. The
object ifTestCode can be used to provide further test-
specific or interface-specific (or even enterprise-specific)
information concerning the outcome of the test. Only one
test can be in progress on each interface at any one time.
If one test is in progress when another test is invoked, the
second test is rejected. Some agents may reject a test when
a prior test is active on another interface.
Before starting a test, a manager-station must first obtain
'ownership' of the entry in the ifTestTable for the
interface to be tested. This is accomplished with the
ifTestId and ifTestStatus objects as follows:
try_again:
get (ifTestId, ifTestStatus)
while (ifTestStatus != notInUse)
/*
* Loop while a test is running or some other
* manager is configuring a test.
*/
short delay
get (ifTestId, ifTestStatus)
}
/*
* Is not being used right now -- let's compete
* to see who gets it.
*/
lock_value = ifTestId
if ( set(ifTestId = lock_value, ifTestStatus = inUse,
ifTestOwner = 'my-IP-address') == FAILURE)
/*
* Another manager got the ifTestEntry -- go
* try again
*/
goto try_again;
/*
* I have the lock
*/
set up any test parameters.
/*
* This starts the test
*/
set(ifTestType = test_to_run);
wait for test completion by polling ifTestResult
when test completes, agent sets ifTestResult
agent also sets ifTestStatus = 'notInUse'
retrieve any additional test results, and ifTestId
if (ifTestId == lock_value+1) results are valid
A manager station first retrieves the value of the
appropriate ifTestId and ifTestStatus objects, periodically
repeating the retrieval if necessary, until the value of
ifTestStatus is 'notInUse'. The manager station then tries
to set the same ifTestId object to the value it just
retrieved, the same ifTestStatus object to 'inUse', and the
corresponding ifTestOwner object to a value indicating
itself. If the set operation succeeds then the manager has
obtained ownership of the ifTestEntry, and the value of the
ifTestId object is incremented by the agent (per the
semantics of TestAndIncr). Failure of the set operation
indicates that some other manager has obtained ownership of
the ifTestEntry.
Once ownership is obtained, any test parameters can be
setup, and then the test is initiated by setting ifTestType.
On completion of the test, the agent sets ifTestStatus to
'notInUse'. Once this occurs, the manager can retrieve the
results. In the (rare) event that the invocation of tests
by two network managers were to overlap, then there would be
a possibility that the first test's results might be
overwritten by the second test's results prior to the first
results being read. This unlikely circumstance can be
detected by a network manager retrieving ifTestId at the
same time as retrieving the test results, and ensuring that
the results are for the desired request.
If ifTestType is not set within an abnormally long period of
time after ownership is obtained, the agent should time-out
the manager, and reset the value of the ifTestStatus object
back to 'notInUse'. It is suggested that this time-out
period be 5 minutes.
In general, a management station must not retransmit a
request to invoke a test for which it does not receive a
response; instead, it properly inspects an agent's MIB to
determine if the invocation was successful. Only if the
invocation was unsuccessful, is the invocation request
retransmitted.
Some tests may require the interface to be taken off-line in
order to execute them, or may even require the agent to
reboot after completion of the test. In these
circumstances, communication with the management station
invoking the test may be lost until after completion of the
test. An agent is not required to support such tests.
However, if such tests are supported, then the agent should
make every effort to transmit a response to the request
which invoked the test prior to losing communication. When
the agent is restored to normal service, the results of the
test are properly made available in the appropriate objects.
Note that this requires that the ifIndex value assigned to
an interface must be unchanged even if the test causes a
reboot. An agent must reject any test for which it cannot,
perhaps due to resource constraints, make available at least
the minimum amount of information after that test
completes."
::= { ifMIBObjects 3 }
ifTestEntry OBJECT-TYPE
SYNTAX IfTestEntry
MAX-ACCESS not-accessible
STATUS deprecated
DESCRIPTION
"An entry containing objects for invoking tests on an
interface."
AUGMENTS { ifEntry }
::= { ifTestTable 1 }
IfTestEntry ::=
SEQUENCE {
ifTestId TestAndIncr,
ifTestStatus INTEGER,
ifTestType AutonomousType,
ifTestResult INTEGER,
ifTestCode OBJECT IDENTIFIER,
ifTestOwner OwnerString
}
ifTestId OBJECT-TYPE
SYNTAX TestAndIncr
MAX-ACCESS read-write
STATUS deprecated
DESCRIPTION
"This object identifies the current invocation of the
interface's test."
::= { ifTestEntry 1 }
ifTestStatus OBJECT-TYPE
SYNTAX INTEGER { notInUse(1), inUse(2) }
MAX-ACCESS read-write
STATUS deprecated
DESCRIPTION
"This object indicates whether or not some manager currently
has the necessary 'ownership' required to invoke a test on
this interface. A write to this object is only successful
when it changes its value from 'notInUse(1)' to 'inUse(2)'.
After completion of a test, the agent resets the value back
to 'notInUse(1)'."
::= { ifTestEntry 2 }
ifTestType OBJECT-TYPE
SYNTAX AutonomousType
MAX-ACCESS read-write
STATUS deprecated
DESCRIPTION
"A control variable used to start and stop operator-
initiated interface tests. Most OBJECT IDENTIFIER values
assigned to tests are defined elsewhere, in association with
specific types of interface. However, this document assigns
a value for a full-duplex loopback test, and defines the
special meanings of the subject identifier:
noTest OBJECT IDENTIFIER ::= { 0 0 }
When the value noTest is written to this object, no action
is taken unless a test is in progress, in which case the
test is aborted. Writing any other value to this object is
only valid when no test is currently in progress, in which
case the indicated test is initiated.
When read, this object always returns the most recent value
that ifTestType was set to. If it has not been set since
the last initialization of the network management subsystem
on the agent, a value of noTest is returned."
::= { ifTestEntry 3 }
ifTestResult OBJECT-TYPE
SYNTAX INTEGER {
none(1), -- no test yet requested
success(2),
inProgress(3),
notSupported(4),
unAbleToRun(5), -- due to state of system
aborted(6),
failed(7)
}
MAX-ACCESS read-only
STATUS deprecated
DESCRIPTION
"This object contains the result of the most recently
requested test, or the value none(1) if no tests have been
requested since the last reset. Note that this facility
provides no provision for saving the results of one test
when starting another, as could be required if used by
multiple managers concurrently."
::= { ifTestEntry 4 }
ifTestCode OBJECT-TYPE
SYNTAX OBJECT IDENTIFIER
MAX-ACCESS read-only
STATUS deprecated
DESCRIPTION
"This object contains a code which contains more specific
information on the test result, for example an error-code
after a failed test. Error codes and other values this
object may take are specific to the type of interface and/or
test. The value may have the semantics of either the
AutonomousType or InstancePointer textual conventions as
defined in RFC 2579. The identifier:
testCodeUnknown OBJECT IDENTIFIER ::= { 0 0 }
is defined for use if no additional result code is
available."
::= { ifTestEntry 5 }
ifTestOwner OBJECT-TYPE
SYNTAX OwnerString
MAX-ACCESS read-write
STATUS deprecated
DESCRIPTION
"The entity which currently has the 'ownership' required to
invoke a test on this interface."
::= { ifTestEntry 6 }Quick vibe check on the table: ifTestTable is deprecated 🥀 and it's indexed through ifTestEntry, which AUGMENTS ifEntry, so each interface gets its own little test row 🧚 The main drama is the ownership dance with ifTestId and ifTestStatus: a manager has to snag the lock before it can start a test 🔒✨ Every object here is marked deprecated too, so it's basically a retired icon who still shows up to the party 💅
7. Acknowledgements 🌸
This memo was cooked up by the IETF's Interfaces MIB working-group, and it's giving real teamwork energy 🫶
The original proposal grew out of conversations and discussions with a bunch of amazing people, including at least Fred Baker, Ted Brunner, Chuck Davin, Jeremy Greene, Marshall Rose, Kaj Tesink, and Dean Throop. Iconic squad 👑
-- Deprecated Definitions - Groups
ifGeneralGroup OBJECT-GROUP
OBJECTS { ifDescr, ifType, ifSpeed, ifPhysAddress,
ifAdminStatus, ifOperStatus, ifLastChange,
ifLinkUpDownTrapEnable, ifConnectorPresent,
ifHighSpeed, ifName }
STATUS deprecated
DESCRIPTION
"A collection of objects deprecated in favour of
ifGeneralInformationGroup."
::= { ifGroups 1 }
ifTestGroup OBJECT-GROUP
OBJECTS { ifTestId, ifTestStatus, ifTestType,
ifTestResult, ifTestCode, ifTestOwner }
STATUS deprecated
DESCRIPTION
"A collection of objects providing the ability to invoke
tests on an interface."
::= { ifGroups 8 }
ifStackGroup OBJECT-GROUP
OBJECTS { ifStackStatus }
STATUS deprecated
DESCRIPTION
"The previous collection of objects providing information on
the layering of MIB-II interfaces."
::= { ifGroups 9 }
ifOldObjectsGroup OBJECT-GROUP
OBJECTS { ifInNUcastPkts, ifOutNUcastPkts,
ifOutQLen, ifSpecific }
STATUS deprecated
DESCRIPTION
"The collection of objects deprecated from the original MIB-
II interfaces group."
::= { ifGroups 12 }
-- Deprecated Definitions - Compliance
ifCompliance MODULE-COMPLIANCE
STATUS deprecated
DESCRIPTION
"A compliance statement defined in a previous version of
this MIB module, for SNMP entities which have network
interfaces."
MODULE -- this module
MANDATORY-GROUPS { ifGeneralGroup, ifStackGroup }
GROUP ifFixedLengthGroup
DESCRIPTION
"This group is mandatory for all network interfaces which
are character-oriented or transmit data in fixed-length
transmission units."
GROUP ifHCFixedLengthGroup
DESCRIPTION
"This group is mandatory only for those network interfaces
which are character-oriented or transmit data in fixed-
length transmission units, and for which the value of the
corresponding instance of ifSpeed is greater than 20,000,000
bits/second."
GROUP ifPacketGroup
DESCRIPTION
"This group is mandatory for all network interfaces which
are packet-oriented."
GROUP ifHCPacketGroup
DESCRIPTION
"This group is mandatory only for those network interfaces
which are packet-oriented and for which the value of the
corresponding instance of ifSpeed is greater than
650,000,000 bits/second."
GROUP ifTestGroup
DESCRIPTION
"This group is optional. Media-specific MIBs which require
interface tests are strongly encouraged to use this group
for invoking tests and reporting results. A medium specific
MIB which has mandatory tests may make implementation of
this group mandatory."
GROUP ifRcvAddressGroup
DESCRIPTION
"The applicability of this group MUST be defined by the
media-specific MIBs. Media-specific MIBs must define the
exact meaning, use, and semantics of the addresses in this
group."
OBJECT ifLinkUpDownTrapEnable
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT ifPromiscuousMode
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT ifStackStatus
SYNTAX INTEGER { active(1) } -- subset of RowStatus
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required, and only one of the six
enumerated values for the RowStatus textual convention need
be supported, specifically: active(1)."
OBJECT ifAdminStatus
SYNTAX INTEGER { up(1), down(2) }
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required, nor is support for the value
testing(3)."
::= { ifCompliances 1 }
ifCompliance2 MODULE-COMPLIANCE
STATUS deprecated
DESCRIPTION
"A compliance statement defined in a previous version of
this MIB module, for SNMP entities which have network
interfaces."
MODULE -- this module
MANDATORY-GROUPS { ifGeneralInformationGroup, ifStackGroup2,
ifCounterDiscontinuityGroup }
GROUP ifFixedLengthGroup
DESCRIPTION
"This group is mandatory for all network interfaces which
are character-oriented or transmit data in fixed-length
transmission units."
GROUP ifHCFixedLengthGroup
DESCRIPTION
"This group is mandatory only for those network interfaces
which are character-oriented or transmit data in fixed-
length transmission units, and for which the value of the
corresponding instance of ifSpeed is greater than 20,000,000
bits/second."
GROUP ifPacketGroup
DESCRIPTION
"This group is mandatory for all network interfaces which
are packet-oriented."
GROUP ifHCPacketGroup
DESCRIPTION
"This group is mandatory only for those network interfaces
which are packet-oriented and for which the value of the
corresponding instance of ifSpeed is greater than
650,000,000 bits/second."
GROUP ifRcvAddressGroup
DESCRIPTION
"The applicability of this group MUST be defined by the
media-specific MIBs. Media-specific MIBs must define the
exact meaning, use, and semantics of the addresses in this
group."
OBJECT ifLinkUpDownTrapEnable
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT ifPromiscuousMode
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT ifStackStatus
SYNTAX INTEGER { active(1) } -- subset of RowStatus
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required, and only one of the six
enumerated values for the RowStatus textual convention need
be supported, specifically: active(1)."
OBJECT ifAdminStatus
SYNTAX INTEGER { up(1), down(2) }
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required, nor is support for the value
testing(3)."
OBJECT ifAlias
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
::= { ifCompliances 2 }
END8. References 📚
Here's the reading list, bestie. Every citation is here, all the details included, so you can go look up whatever you need 🧚
[1] Harrington, D., Presuhn, R. and B. Wijnen, "An Architecture for Describing SNMP Management Frameworks", RFC 2571, April 1999.
[2] Rose, M. and K. McCloghrie, "Structure and Identification of Management Information for TCP/IP-based Internets", STD 16, RFC 1155, May 1990.
[3] Rose, M. and K. McCloghrie, "Concise MIB Definitions", STD 16, RFC 1212, March 1991.
[4] Rose, M., "A Convention for Defining Traps for use with the SNMP", RFC 1215, March 1991.
[5] McCloghrie, K., Perkins, D., Schoenwaelder, J., Case, J., Rose, M. and S. Waldbusser, "Structure of Management Information Version 2 (SMIv2)", STD 58, RFC 2578, April 1999.
[6] McCloghrie, K., Perkins, D., Schoenwaelder, J., Case, J., Rose, M. and S. Waldbusser, "Textual Conventions for SMIv2", STD 58, RFC 2579, April 1999.
[7] McCloghrie, K., Perkins, D., Schoenwaelder, J., Case, J., Rose, M. and S. Waldbusser, "Conformance Statements for SMIv2", STD 58, RFC 2580, April 1999.
[8] Case, J., Fedor, M., Schoffstall, M. and J. Davin, "Simple Network Management Protocol", STD 15, RFC 1157, May 1990.
[9] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Introduction to Community-based SNMPv2", RFC 1901, January 1996.
[10] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Transport Mappings for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1906, January 1996.
[11] Case, J., Harrington D., Presuhn R. and B. Wijnen, "Message Processing and Dispatching for the Simple Network Management Protocol (SNMP)", RFC 2572, January 1998.
[12] Blumenthal, U. and B. Wijnen, "User-based Security Model (USM) for version 3 of the Simple Network Management Protocol (SNMPv3)", RFC 2574, January 1998.
[13] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Protocol Operations for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1905, January 1996.
[14] Levi, D., Meyer, P. and B. Stewart, "SMPv3 Applications", RFC 2573, January 1998.
[15] Wijnen, B., Presuhn, R. and K. McCloghrie, "View-based Access Control Model (VACM) for the Simple Network Management Protocol (SNMP)", RFC 2575, January 1998.
[16] Bradner, S., "Key words for use in RFCs to Indicate Requirements Levels", BCP 14, RFC 2119, March 1997.
[17] McCloghrie, K. and M. Rose, "Management Information Base for Network Management of TCP/IP-based internets - MIB-II", STD 17. RFC 1213, March 1991.
[18] Postel, J., "Internet Protocol", STD 5, RFC 791, September 1981.
[19] McCloghrie, K., "Extensions to the Generic-Interface MIB", RFC 1229, May 1991.
[20] ATM Forum Technical Committee, "LAN Emulation Client Management: Version 1.0 Specification", af-lane-0044.000, ATM Forum, September 1995.
[21] Stewart, B., "Definitions of Managed Objects for Character Stream Devices using SMIv2", RFC 1658, July 1994.
[22] Case, J., Mundy, R., Partain, D. and B. Stewart, "Introduction to Version 3 of the Internet-standard Network Management Framework", RFC 2570, April 1999.
[23] McCloghrie, K. and F. Kastenholz, "Evolution of the Interfaces Group of MIB-II", RFC 1573, January 1994.
[24] McCloghrie, K. and F. Kastenholz, "The Interfaces Group MIB using SMIv2", RFC 2233, November 1997.
9. Security Considerations 🔐
bestie, this part is serious, so let's go 🫶
There are a bunch of management objects in this MIB with a MAX-ACCESS clause of read-write and/or read-create. 🙈 These objects may be considered sensitive or vulnerable in some network environments. Supporting SET operations in an insecure environment, without proper protection, can have a negative effect on network operations. 😭
Writable objects let an admin control the interfaces and run tests on them. If someone unauthorized gets access, that could cause a denial of service. Combined with other security breaches, like physical ones, it could even give unauthorized connectivity to a device. 💀
SNMPv1 by itself is not a secure environment. 🚨
Even if the network itself is secure (for example, by using IPSec), there's still no control over who on that secure network can access and GET/SET (read/change/create/delete) the objects in this MIB. So the network being locked down isn't enough on its own 😤
Implementers are encouraged to consider the security features provided by the SNMPv3 framework. Specifically, the User-based Security Model RFC 2574 [12] and the View-based Access Control Model RFC 2575 [15] are recommended. 🔥
Then it's a customer or user responsibility to make sure that the SNMP entity giving access to an instance of this MIB is properly configured. Access should only be given to the objects for those principals (users) who have legitimate rights to actually GET or SET (change/create/delete) them. 👑
10. Authors' Addresses 💌
Here are the authors and their contact info:
Keith McCloghrie
Cisco Systems, Inc.
170 West Tasman Drive
San Jose, CA 95134-1706
Phone: 408-526-5260
EMail: kzm@cisco.comFrank Kastenholz
Argon Networks
25 Porter Rd
Littleton Ma 01460
Phone: (508)685-4000
EMail: kasten@argon.com11. Changes from RFC 2233 📝
Here's what changed since RFC 2233, bestie 🦋
Added linkUpDownNotificationsGroup. ✨
The status of the OwnerString definition in this MIB is now deprecated. 🥀 That's because it's only used by ifTestOwner, which is now deprecated too. Also, other MIBs should import OwnerString from RFC 1757 or its successors instead.
Added ifCompliance3 as a replacement for ifCompliance2. It leaves out the ifStackGroup2 group and adds linkUpDownNotificationsGroup. 🎀 It also fixes the omission of ifVHCPacketGroup, plus some typos in the DESCRIPTIONs of ifHCPacketGroup and ifFixedLengthGroup. ifCompliance2 is now obsoleted. 💅
Changed the syntax of ifStackHigherLayer and ifStackLowerLayer to be InterfaceIndexOrZero. 🌸
Added a requirement that media-specific MIB designers specify any special conditions about counting framing characters in ifInOctets and ifOutOctets. 🧚
Fixed a typo in the DESCRIPTION of the linkUp notification. 🍓
Updated the introductory SNMP Network Management Framework boilerplate text. 💜
12. Notice on Intellectual Property ⚖️
The IETF takes no position regarding the validity or scope of any intellectual property or other rights that might be claimed to pertain to the implementation or use of the technology described in this document or the extent to which any license under such rights might or might not be available; neither does it represent that it has made any effort to identify any such rights. Information on the IETF's procedures with respect to rights in standards-track and standards-related documentation can be found in BCP-11. Copies of claims of rights made available for publication and any assurances of licenses to be made available, or the result of an attempt made to obtain a general license or permission for the use of such proprietary rights by implementors or users of this specification can be obtained from the IETF Secretariat.
The IETF invites any interested party to bring to its attention any copyrights, patents or patent applications, or other proprietary rights which may cover technology that may be required to practice this standard. Please address the information to the IETF Executive Director.
13. Full Copyright Statement 🌈
Copyright (C) The Internet Society (2000). All Rights Reserved.
This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations, except as needed for the purpose of developing Internet standards in which case the procedures for copyrights defined in the Internet Standards process must be followed, or as required to translate it into languages other than English.
The limited permissions granted above are perpetual and will not be revoked by the Internet Society or its successors or assigns.
This document and the information contained herein is provided on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
Acknowledgement 💖
Funding for the RFC Editor function is currently provided by the Internet Society. 🫶✨
📦 where this page comes from
- ietf: rfc2863 2000-06
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms