cisco_cef_mib

package
v0.0.0-...-fac1166 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 17, 2019 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Overview

Cisco Express Forwarding (CEF) describes a high speed switching mechanism that a router uses to forward packets from the inbound to the outbound interface.

CEF uses two sets of data structures or tables, which it stores in router memory:

Forwarding information base (FIB) - Describes a database of information used to make forwarding decisions. It is conceptually similar to a routing table or route-cache, although its implementation is different.

Adjacency - Two nodes in the network are said to be adjacent if they can reach each other via a single hop across a link layer.

CEF path is a valid route to reach to a destination IP prefix. Multiple paths may exist out of a router to the same destination prefix. CEF Load balancing capability share the traffic to the destination IP prefix over all the active paths.

After obtaining the prefix in the CEF table with the longest match, output forwarding follows the chain of forwarding elements.

Forwarding element (FE) may process the packet, forward the packet, drop or punt the packet or it may also pass the packet to the next forwarding element in the chain for further processing.

Forwarding Elements are of various types but this MIB only represents the forwarding elements of adjacency and label types. Hence a forwarding element chain will be represented as a list of labels and adjacency. The adjacency may point to a forwarding element list again, if it is not the last forwarding element in this chain.

For the simplest IP forwarding case, the prefix entry will point at an adjacency forwarding element. The IP adjacency processing function will apply the output features, add the encapsulation (performing any required fixups), and may send the packet out.

If loadbalancing is configured, the prefix entry will point to lists of forwarding elements. One of these lists will be selected to forward the packet.

Each forwarding element list dictates which of a set of possible packet transformations to apply on the way to the same neighbour.

The following diagram represents relationship between three of the core tables in this MIB module. 

cefPrefixTable             cefFESelectionTable

+---------------+  points           +--------------+
|   |     |     |  a set     +----> |   |   |   |  |
|---------------|  of FE     |      |--------------|
|   |     |     |  Selection |      |   |   |   |  |
|---------------|  Entries   |      |--------------|
|   |     |     |------------+      |              |<----+
|---------------|                   |--------------|     |
|               |    +--------------|   |   |   |  |     |
+---------------+    |              +--------------+     |
                     |                                   |
               points to an                              |
               adjacency entry                           |
                     |                                   |
                     |   cefAdjTable                     |
                     |  +---------------+  may point     |
                     +->|   |     |     |  to a set      |
                        |---------------|  of FE         |
                        |   |     |     |  Selection     |
                        |---------------|  Entries       |
                        |   |     |     |----------------+
                        |---------------|
                        |               |
                        +---------------+

Some of the Cisco series routers (e.g. 7500 & 12000) support distributed CEF (dCEF), in which the line cards (LCs) make the packet forwarding decisions using locally stored copies of the same Forwarding information base (FIB) and adjacency tables as the Routing Processor (RP).

Inter-Process Communication (IPC) is the protocol used by routers that support distributed packet forwarding. CEF updates are encoded as external Data Representation (XDR) information elements inside IPC messages.

This MIB reflects the distributed nature of CEF, e.g. CEF has different instances running on the RP and the line cards.

There may be instances of inconsistency between the CEF forwarding databases(i.e between CEF forwarding database on line cards and the CEF forwarding database on the RP). CEF consistency checkers (CC) detects this inconsistency.

When two databases are compared by a consistency checker, a set of records from the first (master) database is looked up in the second (slave).

There are two types of consistency checkers, active and passive. Active consistency checkers are invoked in response to some stimulus, i.e. when a packet cannot be forwarded because the prefix is not in the forwarding table or in response to a Management Station request.

Passive consistency checkers operate in the background, scanning portions of the databases on a periodic basis.

The full-scan checkers are active consistency checkers which are invoked in response to a Management Station Request.

If 64-bit counter objects in this MIB are supported, then their associated 32-bit counter objects must also be supported. The 32-bit counters will report the low 32-bits of the associated 64-bit counter count (e.g., cefPrefixPkts will report the least significant 32 bits of cefPrefixHCPkts). The same rule should be applied for the 64-bit gauge objects and their assocaited 32-bit gauge objects.

If 64-bit counters in this MIB are not supported, then an agent MUST NOT instantiate the corresponding objects with an incorrect value; rather, it MUST respond with the appropriate error/exception condition (e.g., noSuchInstance or noSuchName).

Counters related to CEF accounting (e.g., cefPrefixPkts) MUST NOT be instantiated if the corresponding accounting method has been disabled.

This MIB allows configuration and monitoring of CEF related objects.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CISCOCEFMIB 

type CISCOCEFMIB struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	CefFIB CISCOCEFMIB_CefFIB

	CefCC CISCOCEFMIB_CefCC

	CefNotifCntl CISCOCEFMIB_CefNotifCntl

	// This table contains the summary information for the cefPrefixTable.
	CefFIBSummaryTable CISCOCEFMIB_CefFIBSummaryTable

	// A list of CEF forwarding prefixes.
	CefPrefixTable CISCOCEFMIB_CefPrefixTable

	// A table of Longest Match Prefix Query requests.  Generator application
	// should utilize the cefLMPrefixSpinLock to try to avoid collisions. See
	// DESCRIPTION clause of cefLMPrefixSpinLock.
	CefLMPrefixTable CISCOCEFMIB_CefLMPrefixTable

	// CEF prefix path is a valid route to reach to a  destination IP prefix.
	// Multiple paths may exist  out of a router to the same destination prefix.
	// This table specify lists of CEF paths.
	CefPathTable CISCOCEFMIB_CefPathTable

	// This table contains the summary information for the cefAdjTable.
	CefAdjSummaryTable CISCOCEFMIB_CefAdjSummaryTable

	// A list of CEF adjacencies.
	CefAdjTable CISCOCEFMIB_CefAdjTable

	// A list of forwarding element selection entries.
	CefFESelectionTable CISCOCEFMIB_CefFESelectionTable

	// This table contains global config parameter  of CEF on the Managed device.
	CefCfgTable CISCOCEFMIB_CefCfgTable

	// This table contains global resource  information of CEF on the Managed
	// device.
	CefResourceTable CISCOCEFMIB_CefResourceTable

	// This Table contains interface specific information of CEF on the Managed
	// device.
	CefIntTable CISCOCEFMIB_CefIntTable

	// Entity acting as RP (Routing Processor) keeps the CEF states for the line
	// card entities and communicates with the line card entities using XDR. This
	// Table contains the CEF information  related to peer entities on the managed
	// device.
	CefPeerTable CISCOCEFMIB_CefPeerTable

	// Entity acting as RP (Routing Processor) keep the CEF FIB states for the
	// line card entities and communicate with the line card entities using XDR.
	// This Table contains the CEF FIB State  related to peer entities on the
	// managed device.
	CefPeerFIBTable CISCOCEFMIB_CefPeerFIBTable

	// This table contains CEF consistency checker (CC) global parameters for the
	// managed device.
	CefCCGlobalTable CISCOCEFMIB_CefCCGlobalTable

	// This table contains CEF consistency checker types specific parameters on
	// the managed device.  All detected inconsistency are signaled to the
	// Management Station via cefInconsistencyDetection notification.
	CefCCTypeTable CISCOCEFMIB_CefCCTypeTable

	// This table contains CEF inconsistency records.
	CefInconsistencyRecordTable CISCOCEFMIB_CefInconsistencyRecordTable

	// This table specifies the CEF stats based on the Prefix Length.
	CefStatsPrefixLenTable CISCOCEFMIB_CefStatsPrefixLenTable

	// This table specifies the CEF switch stats.
	CefSwitchingStatsTable CISCOCEFMIB_CefSwitchingStatsTable
}

CISCOCEFMIB

func (*CISCOCEFMIB) GetEntityData 

func (cISCOCEFMIB *CISCOCEFMIB) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefAdjSummaryTable 

type CISCOCEFMIB_CefAdjSummaryTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the Managed device, each entry contains the CEF
	// Adjacency   summary related attributes for the Managed entity. A row exists
	// for each adjacency link type.  entPhysicalIndex is also an index for this
	// table which represents entities of 'module' entPhysicalClass which are
	// capable of running CEF. The type is slice of
	// CISCOCEFMIB_CefAdjSummaryTable_CefAdjSummaryEntry.
	CefAdjSummaryEntry []*CISCOCEFMIB_CefAdjSummaryTable_CefAdjSummaryEntry
}

CISCOCEFMIB_CefAdjSummaryTable This table contains the summary information for the cefAdjTable.

func (*CISCOCEFMIB_CefAdjSummaryTable) GetEntityData 

func (cefAdjSummaryTable *CISCOCEFMIB_CefAdjSummaryTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefAdjSummaryTable_CefAdjSummaryEntry 

type CISCOCEFMIB_CefAdjSummaryTable_CefAdjSummaryEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The link type of the adjacency. The type is
	// CefAdjLinkType.
	CefAdjSummaryLinkType interface{}

	// The total number of complete adjacencies.  The total number of adjacencies
	// which can be used  to switch traffic to a neighbour. The type is
	// interface{} with range: 0..4294967295.
	CefAdjSummaryComplete interface{}

	// The total number of incomplete adjacencies.  The total number of
	// adjacencies which cannot be  used to switch traffic in their current state.
	// The type is interface{} with range: 0..4294967295.
	CefAdjSummaryIncomplete interface{}

	// The total number of adjacencies for which the Layer 2 encapsulation string
	// (header) may be  updated (fixed up) at packet switch time. The type is
	// interface{} with range: 0..4294967295.
	CefAdjSummaryFixup interface{}

	// The total number of adjacencies for which  ip redirect (or icmp
	// redirection) is enabled. The value of this object is only relevant for ipv4
	// and ipv6 link type (when the index object  cefAdjSummaryLinkType value is
	// ipv4(1) or ipv6(2)) and will be set to zero for other link types. The type
	// is interface{} with range: 0..4294967295.
	CefAdjSummaryRedirect interface{}
}

CISCOCEFMIB_CefAdjSummaryTable_CefAdjSummaryEntry If CEF is enabled on the Managed device, each entry contains the CEF Adjacency summary related attributes for the Managed entity. A row exists for each adjacency link type.

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefAdjSummaryTable_CefAdjSummaryEntry) GetEntityData 

func (cefAdjSummaryEntry *CISCOCEFMIB_CefAdjSummaryTable_CefAdjSummaryEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefAdjTable 

type CISCOCEFMIB_CefAdjTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the Managed device, each entry contains the adjacency
	// attributes. Adjacency entries may exist for all the interfaces on which
	// packets can be switched out of the device. The interface is instantiated by
	// ifIndex.   Therefore, the interface index must have been assigned,
	// according to the applicable procedures, before it can be meaningfully used.
	// Generally, this means that the interface must exist.  entPhysicalIndex is
	// also an index for this table which represents entities of 'module'
	// entPhysicalClass which are capable of running CEF. The type is slice of
	// CISCOCEFMIB_CefAdjTable_CefAdjEntry.
	CefAdjEntry []*CISCOCEFMIB_CefAdjTable_CefAdjEntry
}

CISCOCEFMIB_CefAdjTable A list of CEF adjacencies.

func (*CISCOCEFMIB_CefAdjTable) GetEntityData 

func (cefAdjTable *CISCOCEFMIB_CefAdjTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefAdjTable_CefAdjEntry 

type CISCOCEFMIB_CefAdjTable_CefAdjEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to if_mib.IFMIB_IfTable_IfEntry_IfIndex
	IfIndex interface{}

	// This attribute is a key. Address type for the cefAdjNextHopAddr. This
	// object specifies the address type used for cefAdjNextHopAddr.   Adjacency
	// entries are only valid for the  address type of ipv4(1) and ipv6(2). The
	// type is InetAddressType.
	CefAdjNextHopAddrType interface{}

	// This attribute is a key. The next Hop address for this adjacency. The type
	// of this address is determined by the value of the cefAdjNextHopAddrType
	// object. The type is string with length: 0..255.
	CefAdjNextHopAddr interface{}

	// This attribute is a key. In cases where cefLinkType, interface and the next
	// hop address are not able to uniquely define an adjacency entry (e.g. ATM
	// and Frame Relay Bundles), this object is a unique identifier to
	// differentiate between these adjacency entries.   In all the other cases the
	// value of this  index object will be 0. The type is interface{} with range:
	// 0..4294967295.
	CefAdjConnId interface{}

	// This attribute is a key. The type is CefAdjLinkType. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefAdjSummaryTable_CefAdjSummaryEntry_CefAdjSummaryLinkType
	CefAdjSummaryLinkType interface{}

	// If the adjacency is created because some neighbour discovery mechanism has
	// discovered a neighbour and all the information required to build a frame
	// header to encapsulate traffic to the neighbour is available then the source
	// of adjacency is set to the mechanism by which the adjacency is learned. The
	// type is map[string]bool.
	CefAdjSource interface{}

	// The layer 2 encapsulation string to be used for sending the packet out
	// using this adjacency. The type is string.
	CefAdjEncap interface{}

	// For the cases, where the encapsulation string is decided at packet switch
	// time, the adjacency  encapsulation string specified by object cefAdjEncap
	// require a fixup. I.e. for the adjacencies out of IP  Tunnels, the string
	// prepended is an IP header which has  fields which can only be setup at
	// packet switch time.  The value of this object represent the kind of fixup
	// applied to the packet.  If the encapsulation string doesn't require any
	// fixup, then the value of this object will be of zero length. The type is
	// string.
	CefAdjFixup interface{}

	// The Layer 3 MTU which can be transmitted using  this adjacency. The type is
	// interface{} with range: 0..65535. Units are bytes.
	CefAdjMTU interface{}

	// This object selects a forwarding info entry  defined in the
	// cefFESelectionTable. The  selected target is defined by an entry in the
	// cefFESelectionTable whose index value (cefFESelectionName)  is equal to
	// this object.  The value of this object will be of zero length if this
	// adjacency entry is the last forwarding  element in the forwarding path. The
	// type is string.
	CefAdjForwardingInfo interface{}

	// Number of pkts transmitted using this adjacency. The type is interface{}
	// with range: 0..4294967295. Units are packets.
	CefAdjPkts interface{}

	// Number of pkts transmitted using this adjacency. This object is a 64-bit
	// version of cefAdjPkts. The type is interface{} with range:
	// 0..18446744073709551615. Units are packets.
	CefAdjHCPkts interface{}

	// Number of bytes transmitted using this adjacency. The type is interface{}
	// with range: 0..4294967295. Units are bytes.
	CefAdjBytes interface{}

	// Number of bytes transmitted using this adjacency. This object is a 64-bit
	// version of cefAdjBytes. The type is interface{} with range:
	// 0..18446744073709551615. Units are bytes.
	CefAdjHCBytes interface{}
}

CISCOCEFMIB_CefAdjTable_CefAdjEntry If CEF is enabled on the Managed device, each entry contains the adjacency attributes. Adjacency entries may exist for all the interfaces on which packets can be switched out of the device. The interface is instantiated by ifIndex. Therefore, the interface index must have been assigned, according to the applicable procedures, before it can be meaningfully used. Generally, this means that the interface must exist.

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefAdjTable_CefAdjEntry) GetEntityData 

func (cefAdjEntry *CISCOCEFMIB_CefAdjTable_CefAdjEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefCC 

type CISCOCEFMIB_CefCC struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The value of sysUpTime at the time an inconsistency is detecetd. The type
	// is interface{} with range: 0..4294967295.
	EntLastInconsistencyDetectTime interface{}

	// Setting the value of this object to ccActionStart(1) will reset all the
	// active consistency checkers.  The Management station should poll the
	// cefInconsistencyResetStatus object to get the  state of inconsistency reset
	// operation.  This operation once started, cannot be aborted. Hence, the
	// value of this object cannot be set to ccActionAbort(2).  The value of this
	// object can't be set to ccActionStart(1),  if the value of object
	// cefInconsistencyResetStatus is ccStatusRunning(2). The type is CefCCAction.
	CefInconsistencyReset interface{}

	// Indicates the status of the consistency reset request. The type is
	// CefCCStatus.
	CefInconsistencyResetStatus interface{}
}

CISCOCEFMIB_CefCC

func (*CISCOCEFMIB_CefCC) GetEntityData 

func (cefCC *CISCOCEFMIB_CefCC) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefCCGlobalTable 

type CISCOCEFMIB_CefCCGlobalTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If the managed device supports CEF, each entry contains the global
	// consistency  checker parameter for the managed device. A row may exist for
	// each IP version type (v4 and v6) depending upon the IP version supported on
	// the device. The type is slice of
	// CISCOCEFMIB_CefCCGlobalTable_CefCCGlobalEntry.
	CefCCGlobalEntry []*CISCOCEFMIB_CefCCGlobalTable_CefCCGlobalEntry
}

CISCOCEFMIB_CefCCGlobalTable This table contains CEF consistency checker (CC) global parameters for the managed device.

func (*CISCOCEFMIB_CefCCGlobalTable) GetEntityData 

func (cefCCGlobalTable *CISCOCEFMIB_CefCCGlobalTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefCCGlobalTable_CefCCGlobalEntry 

type CISCOCEFMIB_CefCCGlobalTable_CefCCGlobalEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is CefIpVersion. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry_CefFIBIpVersion
	CefFIBIpVersion interface{}

	// Once an inconsistency has been detected,  CEF has the ability to repair the
	// problem.  This object indicates the status of auto-repair  function for the
	// consistency checkers. The type is bool.
	CefCCGlobalAutoRepairEnabled interface{}

	// Indiactes how long the consistency checker  waits to fix an inconsistency.
	// The value of this object has no effect when the value of object
	// cefCCGlobalAutoRepairEnabled is 'false'. The type is interface{} with
	// range: 0..4294967295. Units are seconds.
	CefCCGlobalAutoRepairDelay interface{}

	// Indicates how long the consistency checker waits to re-enable auto-repair
	// after  auto-repair runs.  The value of this object has no effect when the
	// value of object cefCCGlobalAutoRepairEnabled is 'false'. The type is
	// interface{} with range: 0..4294967295. Units are seconds.
	CefCCGlobalAutoRepairHoldDown interface{}

	// Enables the consistency checker to generate  an error message when it
	// detects an inconsistency. The type is bool.
	CefCCGlobalErrorMsgEnabled interface{}

	// Setting the value of this object to ccActionStart(1) will start the full
	// scan consistency checkers.  The Management station should poll the
	// cefCCGlobalFullScanStatus object to get the  state of full-scan operation.
	// Once the full-scan operation completes (value of cefCCGlobalFullScanStatus
	// object is ccStatusDone(3)),  the Management station should retrieve the
	// values of the related stats object from the cefCCTypeTable.  Setting the
	// value of this object to ccActionAbort(2) will  abort the full-scan
	// operation.  The value of this object can't be set to ccActionStart(1),  if
	// the value of object cefCCGlobalFullScanStatus is ccStatusRunning(2).  The
	// value of this object will be set to cefActionNone(1) when the full scan
	// consistency checkers have never been activated.  A Management Station
	// cannot set the value of this object to cefActionNone(1). The type is
	// CefCCAction.
	CefCCGlobalFullScanAction interface{}

	// Indicates the status of the full scan consistency checker request. The type
	// is CefCCStatus.
	CefCCGlobalFullScanStatus interface{}
}

CISCOCEFMIB_CefCCGlobalTable_CefCCGlobalEntry If the managed device supports CEF, each entry contains the global consistency checker parameter for the managed device. A row may exist for each IP version type (v4 and v6) depending upon the IP version supported on the device.

func (*CISCOCEFMIB_CefCCGlobalTable_CefCCGlobalEntry) GetEntityData 

func (cefCCGlobalEntry *CISCOCEFMIB_CefCCGlobalTable_CefCCGlobalEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefCCTypeTable 

type CISCOCEFMIB_CefCCTypeTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If the managed device supports CEF, each entry contains the consistency
	// checker statistics for a consistency  checker type. A row may exist for
	// each IP version type (v4 and v6) depending upon the IP version supported on
	// the device. The type is slice of CISCOCEFMIB_CefCCTypeTable_CefCCTypeEntry.
	CefCCTypeEntry []*CISCOCEFMIB_CefCCTypeTable_CefCCTypeEntry
}

CISCOCEFMIB_CefCCTypeTable This table contains CEF consistency checker types specific parameters on the managed device.

All detected inconsistency are signaled to the Management Station via cefInconsistencyDetection notification.

func (*CISCOCEFMIB_CefCCTypeTable) GetEntityData 

func (cefCCTypeTable *CISCOCEFMIB_CefCCTypeTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefCCTypeTable_CefCCTypeEntry 

type CISCOCEFMIB_CefCCTypeTable_CefCCTypeEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is CefIpVersion. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry_CefFIBIpVersion
	CefFIBIpVersion interface{}

	// This attribute is a key. Type of the consistency checker. The type is
	// CefCCType.
	CefCCType interface{}

	// Enables the passive consistency checker. Passive consistency checkers are
	// disabled by default.  Full-scan consistency checkers are always enabled. An
	// attempt to set this object to 'false' for an active consistency checker
	// will result in 'wrongValue' error. The type is bool.
	CefCCEnabled interface{}

	// The maximum number of prefixes to check per scan.  The default value for
	// this object  depends upon the consistency checker type.  The value of this
	// object will be irrelevant  for some of the consistency checkers and will be
	// set to 0.  A Management Station cannot set the value of this object to 0.
	// The type is interface{} with range: 0..4294967295.
	CefCCCount interface{}

	// The period between scans for the consistency checker. The type is
	// interface{} with range: 0..4294967295. Units are seconds.
	CefCCPeriod interface{}

	// Number of prefix consistency queries sent to CEF forwarding databases by
	// this consistency checker. The type is interface{} with range:
	// 0..4294967295.
	CefCCQueriesSent interface{}

	// Number of prefix consistency queries for which the consistency checks were
	// not performed by this  consistency checker. This may be because of some
	// internal error or resource failure. The type is interface{} with range:
	// 0..4294967295.
	CefCCQueriesIgnored interface{}

	// Number of prefix consistency queries processed by this  consistency
	// checker. The type is interface{} with range: 0..4294967295.
	CefCCQueriesChecked interface{}

	// Number of prefix consistency queries iterated back to the master database
	// by this consistency checker. The type is interface{} with range:
	// 0..4294967295.
	CefCCQueriesIterated interface{}
}

CISCOCEFMIB_CefCCTypeTable_CefCCTypeEntry If the managed device supports CEF, each entry contains the consistency checker statistics for a consistency checker type. A row may exist for each IP version type (v4 and v6) depending upon the IP version supported on the device.

func (*CISCOCEFMIB_CefCCTypeTable_CefCCTypeEntry) GetEntityData 

func (cefCCTypeEntry *CISCOCEFMIB_CefCCTypeTable_CefCCTypeEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefCfgTable 

type CISCOCEFMIB_CefCfgTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If the Managed device supports CEF,  each entry contains the CEF config
	// parameter for the managed entity. A row may exist for each IP version type
	// (v4 and v6) depending upon the IP version supported on the device.
	// entPhysicalIndex is also an index for this table which represents entities
	// of 'module' entPhysicalClass which are capable of running CEF. The type is
	// slice of CISCOCEFMIB_CefCfgTable_CefCfgEntry.
	CefCfgEntry []*CISCOCEFMIB_CefCfgTable_CefCfgEntry
}

CISCOCEFMIB_CefCfgTable This table contains global config parameter of CEF on the Managed device.

func (*CISCOCEFMIB_CefCfgTable) GetEntityData 

func (cefCfgTable *CISCOCEFMIB_CefCfgTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefCfgTable_CefCfgEntry 

type CISCOCEFMIB_CefCfgTable_CefCfgEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The type is CefIpVersion. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry_CefFIBIpVersion
	CefFIBIpVersion interface{}

	// The desired state of CEF. The type is CefAdminStatus.
	CefCfgAdminState interface{}

	// The current operational state of CEF.  If the cefCfgAdminState is
	// disabled(2), then cefOperState will eventually go to the down(2) state
	// unless some error has occurred.   If cefCfgAdminState is changed to
	// enabled(1) then  cefCfgOperState should change to up(1) only if the  CEF
	// entity is ready to forward the packets using  Cisco Express Forwarding
	// (CEF) else it should remain  in the down(2) state. The up(1) state for this
	// object  indicates that CEF entity is forwarding the packet using Cisco
	// Express Forwarding. The type is CefOperStatus.
	CefCfgOperState interface{}

	// The desired state of CEF distribution. The type is CefAdminStatus.
	CefCfgDistributionAdminState interface{}

	// The current operational state of CEF distribution.  If the
	// cefCfgDistributionAdminState is disabled(2), then cefDistributionOperState
	// will eventually go to the down(2) state unless some error has occurred.
	// If cefCfgDistributionAdminState is changed to enabled(1)  then
	// cefCfgDistributionOperState should change to up(1)  only if the CEF entity
	// is ready to forward the packets  using Distributed Cisco Express Forwarding
	// (dCEF) else  it should remain in the down(2) state. The up(1) state  for
	// this object indicates that CEF entity is forwarding the packet using
	// Distributed Cisco Express Forwarding. The type is CefOperStatus.
	CefCfgDistributionOperState interface{}

	// This object represents a bitmap of network accounting options.  CEF network
	// accounting is disabled by default.  CEF network accounting can be enabled
	// by selecting one or more of the following CEF accounting option for the
	// value of this object.    nonRecursive(0):  enables accounting through
	// nonrecursive prefixes.   perPrefix(1):     enables the collection of the
	// numbers                     of pkts and bytes express forwarded
	// to a destination (prefix)   prefixLength(2):  enables accounting through
	// prefixlength.           Once the accounting is enabled, the corresponding
	// stats  can be retrieved from the cefPrefixTable and
	// cefStatsPrefixLenTable.  . The type is map[string]bool.
	CefCfgAccountingMap interface{}

	// Indicates the CEF Load balancing algorithm.  Setting this object to none(1)
	// will disable the Load sharing for the specified entry.  CEF load balancing
	// can be enabled by setting  this object to one of following Algorithms:
	// original(2)  : This algorithm is based on a                  source and
	// destination hash    tunnel(3)    : This algorithm is used in
	// tunnels environments or in                 environments where there are
	// only a few source                      universal(4)  : This algorithm uses
	// a source and                   destination and ID hash  If the value of
	// this object is set to 'tunnel' or 'universal', then the FIXED ID for these
	// algorithms may be specified by the managed  object cefLoadSharingID. . The
	// type is CefCfgLoadSharingAlgorithm.
	CefCfgLoadSharingAlgorithm interface{}

	// The Fixed ID associated with the managed object cefCfgLoadSharingAlgorithm.
	// The hash of this object value may be used by the Load Sharing Algorithm.
	// The value of this object is not relevant and will be set to zero if the
	// value of managed object  cefCfgLoadSharingAlgorithm is set to none(1) or
	// original(2). The default value of this object is calculated by the device
	// at the time of initialization. The type is interface{} with range:
	// 0..4294967295.
	CefCfgLoadSharingID interface{}

	// The interval time over which the CEF traffic statistics are collected. The
	// type is interface{} with range: 0..4294967295. Units are seconds.
	CefCfgTrafficStatsLoadInterval interface{}

	// The frequency with which the line card sends the traffic load statistics to
	// the Router Processor.  Setting the value of this object to 0 will disable
	// the CEF traffic statistics collection. The type is interface{} with range:
	// 0..65535. Units are seconds.
	CefCfgTrafficStatsUpdateRate interface{}
}

CISCOCEFMIB_CefCfgTable_CefCfgEntry If the Managed device supports CEF, each entry contains the CEF config parameter for the managed entity. A row may exist for each IP version type (v4 and v6) depending upon the IP version supported on the device.

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefCfgTable_CefCfgEntry) GetEntityData 

func (cefCfgEntry *CISCOCEFMIB_CefCfgTable_CefCfgEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefCfgTable_CefCfgEntry_CefCfgLoadSharingAlgorithm 

type CISCOCEFMIB_CefCfgTable_CefCfgEntry_CefCfgLoadSharingAlgorithm string

CISCOCEFMIB_CefCfgTable_CefCfgEntry_CefCfgLoadSharingAlgorithm represents object cefLoadSharingID. 

const (
	CISCOCEFMIB_CefCfgTable_CefCfgEntry_CefCfgLoadSharingAlgorithm_none CISCOCEFMIB_CefCfgTable_CefCfgEntry_CefCfgLoadSharingAlgorithm = "none"

	CISCOCEFMIB_CefCfgTable_CefCfgEntry_CefCfgLoadSharingAlgorithm_original CISCOCEFMIB_CefCfgTable_CefCfgEntry_CefCfgLoadSharingAlgorithm = "original"

	CISCOCEFMIB_CefCfgTable_CefCfgEntry_CefCfgLoadSharingAlgorithm_tunnel CISCOCEFMIB_CefCfgTable_CefCfgEntry_CefCfgLoadSharingAlgorithm = "tunnel"

	CISCOCEFMIB_CefCfgTable_CefCfgEntry_CefCfgLoadSharingAlgorithm_universal CISCOCEFMIB_CefCfgTable_CefCfgEntry_CefCfgLoadSharingAlgorithm = "universal"
)

type CISCOCEFMIB_CefFESelectionTable 

type CISCOCEFMIB_CefFESelectionTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the Managed device, each entry contain a CEF
	// forwarding element selection list.  entPhysicalIndex is also an index for
	// this table which represents entities of 'module' entPhysicalClass which are
	// capable of running CEF. The type is slice of
	// CISCOCEFMIB_CefFESelectionTable_CefFESelectionEntry.
	CefFESelectionEntry []*CISCOCEFMIB_CefFESelectionTable_CefFESelectionEntry
}

CISCOCEFMIB_CefFESelectionTable A list of forwarding element selection entries.

func (*CISCOCEFMIB_CefFESelectionTable) GetEntityData 

func (cefFESelectionTable *CISCOCEFMIB_CefFESelectionTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefFESelectionTable_CefFESelectionEntry 

type CISCOCEFMIB_CefFESelectionTable_CefFESelectionEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The locally arbitrary, but unique identifier used
	// to select a set of forwarding element lists. The type is string with
	// length: 1..32.
	CefFESelectionName interface{}

	// This attribute is a key. Secondary index to identify a forwarding elements
	// List  in this Table. The type is interface{} with range: 1..2147483647.
	CefFESelectionId interface{}

	// Special processing for a destination is indicated through the use of
	// special  forwarding element.   If the forwarding element list contains the
	// special forwarding element, then this object  represents the type of
	// special forwarding element. The type is CefForwardingElementSpecialType.
	CefFESelectionSpecial interface{}

	// This object represent the MPLS Labels  associated with this forwarding
	// Element List.  The value of this object will be irrelevant and will be set
	// to zero length if the forwarding element list  doesn't contain a label
	// forwarding element. A zero  length label list will indicate that there is
	// no label forwarding element associated with this selection entry. The type
	// is string with length: 0..255.
	CefFESelectionLabels interface{}

	// This object represent the link type for the adjacency associated with this
	// forwarding  Element List.  The value of this object will be irrelevant and
	// will be set to unknown(5) if the forwarding element list  doesn't contain
	// an adjacency forwarding element. The type is CefAdjLinkType.
	CefFESelectionAdjLinkType interface{}

	// This object represent the interface for the adjacency associated with this
	// forwarding  Element List.  The value of this object will be irrelevant and
	// will be set to zero if the forwarding element list doesn't  contain an
	// adjacency forwarding element. The type is interface{} with range:
	// 0..2147483647.
	CefFESelectionAdjInterface interface{}

	// This object represent the next hop address type for the adjacency
	// associated with this forwarding  Element List.  The value of this object
	// will be irrelevant and will be set to unknown(0) if the forwarding element
	// list  doesn't contain an adjacency forwarding element. The type is
	// InetAddressType.
	CefFESelectionAdjNextHopAddrType interface{}

	// This object represent the next hop address for the adjacency associated
	// with this forwarding  Element List.  The value of this object will be
	// irrelevant and will be set to zero if the forwarding element list doesn't
	// contain an adjacency forwarding element. The type is string with length:
	// 0..255.
	CefFESelectionAdjNextHopAddr interface{}

	// This object represent the connection id for the adjacency associated with
	// this forwarding  Element List.  The value of this object will be irrelevant
	// and will be set to zero if the forwarding element list doesn't  contain an
	// adjacency forwarding element.   In cases where cefFESelectionAdjLinkType,
	// interface  and the next hop address are not able to uniquely  define an
	// adjacency entry (e.g. ATM and Frame Relay Bundles), this object is a unique
	// identifier to differentiate between these adjacency entries. The type is
	// interface{} with range: 0..4294967295.
	CefFESelectionAdjConnId interface{}

	// This object represent the Vrf name for the lookup associated with this
	// forwarding  Element List.  The value of this object will be irrelevant and
	// will be set to a string containing the single octet 0x00 if the forwarding
	// element list  doesn't contain a lookup forwarding element. The type is
	// string with length: 0..31.
	CefFESelectionVrfName interface{}

	// This object represent the weighting for  load balancing between multiple
	// Forwarding Element Lists. The value of this object will be zero if load
	// balancing is associated with this selection entry. The type is interface{}
	// with range: 0..4294967295.
	CefFESelectionWeight interface{}
}

CISCOCEFMIB_CefFESelectionTable_CefFESelectionEntry If CEF is enabled on the Managed device, each entry contain a CEF forwarding element selection list.

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefFESelectionTable_CefFESelectionEntry) GetEntityData 

func (cefFESelectionEntry *CISCOCEFMIB_CefFESelectionTable_CefFESelectionEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefFIB 

type CISCOCEFMIB_CefFIB struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// An advisory lock used to allow cooperating SNMP Command Generator
	// applications to coordinate their use of the Set operation in creating
	// Longest Match Prefix Entries in cefLMPrefixTable.  When creating a new
	// longest prefix match entry, the value of cefLMPrefixSpinLock should be
	// retrieved.   The destination address should be determined to be unique by
	// the SNMP Command Generator application by consulting the cefLMPrefixTable.
	// Finally, the longest  prefix entry may be created (Set), including the
	// advisory lock.         If another SNMP Command Generator application has
	// altered the longest prefix entry in the meantime,  then the spin lock's
	// value will have changed,  and so this creation will fail because it will
	// specify the wrong value for the spin lock.  Since this is an advisory lock,
	// the use of this lock is not enforced, but not using this lock may lead to
	// conflict with the another SNMP command responder  application which may
	// also be acting on the cefLMPrefixTable. The type is interface{} with range:
	// 0..2147483647.
	CefLMPrefixSpinLock interface{}
}

CISCOCEFMIB_CefFIB

func (*CISCOCEFMIB_CefFIB) GetEntityData 

func (cefFIB *CISCOCEFMIB_CefFIB) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefFIBSummaryTable 

type CISCOCEFMIB_CefFIBSummaryTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the Managed device, each entry contains the FIB
	// summary related attributes for the managed entity.  A row may exist for
	// each IP version type (v4 and v6) depending upon the IP version supported on
	// the device.  entPhysicalIndex is also an index for this table which
	// represents entities of 'module' entPhysicalClass which are capable of
	// running CEF. The type is slice of
	// CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry.
	CefFIBSummaryEntry []*CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry
}

CISCOCEFMIB_CefFIBSummaryTable This table contains the summary information for the cefPrefixTable.

func (*CISCOCEFMIB_CefFIBSummaryTable) GetEntityData 

func (cefFIBSummaryTable *CISCOCEFMIB_CefFIBSummaryTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry 

type CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The version of IP forwarding. The type is
	// CefIpVersion.
	CefFIBIpVersion interface{}

	// Total number of forwarding Prefixes in FIB for the IP version specified by
	// cefFIBIpVersion object. The type is interface{} with range: 0..4294967295.
	CefFIBSummaryFwdPrefixes interface{}
}

CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry If CEF is enabled on the Managed device, each entry contains the FIB summary related attributes for the managed entity.

A row may exist for each IP version type (v4 and v6) depending upon the IP version supported on the device.

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry) GetEntityData 

func (cefFIBSummaryEntry *CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefInconsistencyRecordTable 

type CISCOCEFMIB_CefInconsistencyRecordTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If the managed device supports CEF, each entry contains the inconsistency
	// record. The type is slice of
	// CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry.
	CefInconsistencyRecordEntry []*CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry
}

CISCOCEFMIB_CefInconsistencyRecordTable This table contains CEF inconsistency records.

func (*CISCOCEFMIB_CefInconsistencyRecordTable) GetEntityData 

func (cefInconsistencyRecordTable *CISCOCEFMIB_CefInconsistencyRecordTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry 

type CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is CefIpVersion. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry_CefFIBIpVersion
	CefFIBIpVersion interface{}

	// This attribute is a key. The locally arbitrary, but unique identifier
	// associated with this inconsistency record entry. The type is interface{}
	// with range: 1..2147483647.
	CefInconsistencyRecId interface{}

	// The network prefix type associated with this inconsistency record. The type
	// is InetAddressType.
	CefInconsistencyPrefixType interface{}

	// The network prefix address associated with this  inconsistency record.  The
	// type of this address is determined by the value of the
	// cefInconsistencyPrefixType object. The type is string with length: 0..255.
	CefInconsistencyPrefixAddr interface{}

	// Length in bits of the inconsistency address prefix. The type is interface{}
	// with range: 0..2040.
	CefInconsistencyPrefixLen interface{}

	// Vrf name associated with this inconsistency record. The type is string with
	// length: 0..31.
	CefInconsistencyVrfName interface{}

	// The type of consistency checker who generated this inconsistency record.
	// The type is CefCCType.
	CefInconsistencyCCType interface{}

	// The entity for which this inconsistency record was  generated. The value of
	// this object will be  irrelevant and will be set to 0 when the inconsisency
	// record is applicable for all the entities. The type is interface{} with
	// range: 0..2147483647.
	CefInconsistencyEntity interface{}

	// The reason for generating this inconsistency record.   missing(1):
	// the prefix is missing  checksumErr(2):    checksum error was found
	// unknown(3):        reason is unknown. The type is CefInconsistencyReason.
	CefInconsistencyReason interface{}
}

CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry If the managed device supports CEF, each entry contains the inconsistency record.

func (*CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry) GetEntityData 

func (cefInconsistencyRecordEntry *CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry_CefInconsistencyReason 

type CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry_CefInconsistencyReason string

CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry_CefInconsistencyReason represents unknown(3): reason is unknown 

const (
	CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry_CefInconsistencyReason_missing CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry_CefInconsistencyReason = "missing"

	CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry_CefInconsistencyReason_checksumErr CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry_CefInconsistencyReason = "checksumErr"

	CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry_CefInconsistencyReason_unknown CISCOCEFMIB_CefInconsistencyRecordTable_CefInconsistencyRecordEntry_CefInconsistencyReason = "unknown"
)

type CISCOCEFMIB_CefIntTable 

type CISCOCEFMIB_CefIntTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the Managed device,  each entry contains the CEF
	// attributes  associated with an interface. The interface is instantiated by
	// ifIndex.   Therefore, the interface index must have been assigned,
	// according to the applicable procedures, before it can be meaningfully used.
	// Generally, this means that the interface must exist.  A row may exist for
	// each IP version type (v4 and v6) depending upon the IP version supported on
	// the device.  entPhysicalIndex is also an index for this table which
	// represents entities of 'module' entPhysicalClass which are capable of
	// running CEF. The type is slice of CISCOCEFMIB_CefIntTable_CefIntEntry.
	CefIntEntry []*CISCOCEFMIB_CefIntTable_CefIntEntry
}

CISCOCEFMIB_CefIntTable This Table contains interface specific information of CEF on the Managed device.

func (*CISCOCEFMIB_CefIntTable) GetEntityData 

func (cefIntTable *CISCOCEFMIB_CefIntTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefIntTable_CefIntEntry 

type CISCOCEFMIB_CefIntTable_CefIntEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The type is CefIpVersion. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry_CefFIBIpVersion
	CefFIBIpVersion interface{}

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to if_mib.IFMIB_IfTable_IfEntry_IfIndex
	IfIndex interface{}

	// The CEF switching State for the interface.  If CEF is enabled but
	// distributed CEF(dCEF) is disabled then CEF is in cefEnabled(1) state.  If
	// distributed CEF is enabled, then CEF is in  distCefEnabled(2) state. The
	// cefDisabled(3) state indicates that CEF is disabled.  The CEF switching
	// state is only applicable to the received packet on the interface. The type
	// is CefIntSwitchingState.
	CefIntSwitchingState interface{}

	// The status of load sharing on the interface.  perPacket(1) : Router to send
	// data packets                over successive equal-cost paths
	// without regard to individual hosts                or user sessions.
	// perDestination(2) : Router to use multiple, equal-cost
	// paths to achieve load sharing  Load sharing is enabled by default  for an
	// interface when CEF is enabled. The type is CefIntLoadSharing.
	CefIntLoadSharing interface{}

	// The CEF accounting mode for the interface. CEF prefix based non-recursive
	// accounting  on an interface can be configured to store  the stats for
	// non-recursive prefixes in a internal  or external bucket.  internal(1)  :
	// Count input traffic in the nonrecursive                 internal bucket
	// external(2)  :  Count input traffic in the nonrecursive
	// external bucket  The value of this object will only be effective if  value
	// of the object cefAccountingMap is set to enable nonRecursive(1) accounting.
	// The type is CefIntNonrecursiveAccouting.
	CefIntNonrecursiveAccouting interface{}
}

CISCOCEFMIB_CefIntTable_CefIntEntry If CEF is enabled on the Managed device, each entry contains the CEF attributes associated with an interface. The interface is instantiated by ifIndex. Therefore, the interface index must have been assigned, according to the applicable procedures, before it can be meaningfully used. Generally, this means that the interface must exist.

A row may exist for each IP version type (v4 and v6) depending upon the IP version supported on the device.

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefIntTable_CefIntEntry) GetEntityData 

func (cefIntEntry *CISCOCEFMIB_CefIntTable_CefIntEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntLoadSharing 

type CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntLoadSharing string

CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntLoadSharing represents for an interface when CEF is enabled. 

const (
	CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntLoadSharing_perPacket CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntLoadSharing = "perPacket"

	CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntLoadSharing_perDestination CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntLoadSharing = "perDestination"
)

type CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntNonrecursiveAccouting 

type CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntNonrecursiveAccouting string

CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntNonrecursiveAccouting represents nonRecursive(1) accounting. 

const (
	CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntNonrecursiveAccouting_internal CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntNonrecursiveAccouting = "internal"

	CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntNonrecursiveAccouting_external CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntNonrecursiveAccouting = "external"
)

type CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntSwitchingState 

type CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntSwitchingState string

CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntSwitchingState represents received packet on the interface. 

const (
	CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntSwitchingState_cefEnabled CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntSwitchingState = "cefEnabled"

	CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntSwitchingState_distCefEnabled CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntSwitchingState = "distCefEnabled"

	CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntSwitchingState_cefDisabled CISCOCEFMIB_CefIntTable_CefIntEntry_CefIntSwitchingState = "cefDisabled"
)

type CISCOCEFMIB_CefLMPrefixTable 

type CISCOCEFMIB_CefLMPrefixTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the managed device, then each entry represents a
	// longest Match Prefix request.  A management station wishing to get the
	// longest Match prefix for a given destination address should create the
	// associate instance of the row status. The row status should be set to
	// active(1) to initiate the request. Note that  this entire procedure may be
	// initiated via a  single set request which specifies a row status  of
	// createAndGo(4).  Once the request completes, the management station  should
	// retrieve the values of the objects of  interest, and should then delete the
	// entry.  In order  to prevent old entries from clogging the table,  entries
	// will be aged out, but an entry will never be  deleted within 5 minutes of
	// completion. Entries are lost after an agent restart.  I.e. to find out the
	// longest prefix match for  destination address of A.B.C.D on entity whose
	// entityPhysicalIndex is 1, the Management station will create an entry in
	// cefLMPrefixTable with
	// cefLMPrefixRowStatus.1(entPhysicalIndex).1(ipv4).A.B.C.D set to
	// createAndGo(4). Management Station may query the value of objects
	// cefLMPrefix and cefLMPrefixLen to find out the corresponding prefix entry
	// from the cefPrefixTable once the value of cefLMPrefixState is set to
	// matchFound(2).  entPhysicalIndex is also an index for this table which
	// represents entities of 'module' entPhysicalClass which are capable of
	// running CEF. The type is slice of
	// CISCOCEFMIB_CefLMPrefixTable_CefLMPrefixEntry.
	CefLMPrefixEntry []*CISCOCEFMIB_CefLMPrefixTable_CefLMPrefixEntry
}

CISCOCEFMIB_CefLMPrefixTable A table of Longest Match Prefix Query requests.

Generator application should utilize the cefLMPrefixSpinLock to try to avoid collisions. See DESCRIPTION clause of cefLMPrefixSpinLock.

func (*CISCOCEFMIB_CefLMPrefixTable) GetEntityData 

func (cefLMPrefixTable *CISCOCEFMIB_CefLMPrefixTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefLMPrefixTable_CefLMPrefixEntry 

type CISCOCEFMIB_CefLMPrefixTable_CefLMPrefixEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The Destination Address Type. This object
	// specifies the address type used for cefLMPrefixDestAddr.  Longest Match
	// Prefix entries are only valid  for the address type of ipv4(1) and ipv6(2).
	// The type is InetAddressType.
	CefLMPrefixDestAddrType interface{}

	// This attribute is a key. The Destination Address. The type of this address
	// is determined by the value of the cefLMPrefixDestAddrType object. The type
	// is string with length: 0..255.
	CefLMPrefixDestAddr interface{}

	// Indicates the state of this prefix search request. The type is
	// CefPrefixSearchState.
	CefLMPrefixState interface{}

	// The Network Prefix Address. Index to the cefPrefixTable. The type of this
	// address is determined by the value of the cefLMPrefixDestAddrType object.
	// The type is string with length: 0..255.
	CefLMPrefixAddr interface{}

	// The Network Prefix Length. Index to the cefPrefixTable. The type is
	// interface{} with range: 0..2040.
	CefLMPrefixLen interface{}

	// The status of this table entry.  Once the entry  status is set to
	// active(1), the associated entry  cannot be modified until the request
	// completes (cefLMPrefixState transitions to matchFound(2)  or
	// noMatchFound(3)).  Once the longest match request has been created (i.e.
	// the cefLMPrefixRowStatus has been made active), the entry cannot be
	// modified - the only operation possible after this is to delete the row. The
	// type is RowStatus.
	CefLMPrefixRowStatus interface{}
}

CISCOCEFMIB_CefLMPrefixTable_CefLMPrefixEntry If CEF is enabled on the managed device, then each entry represents a longest Match Prefix request.

A management station wishing to get the longest Match prefix for a given destination address should create the associate instance of the row status. The row status should be set to active(1) to initiate the request. Note that this entire procedure may be initiated via a single set request which specifies a row status of createAndGo(4).

Once the request completes, the management station should retrieve the values of the objects of interest, and should then delete the entry. In order to prevent old entries from clogging the table, entries will be aged out, but an entry will never be deleted within 5 minutes of completion. Entries are lost after an agent restart.

I.e. to find out the longest prefix match for destination address of A.B.C.D on entity whose entityPhysicalIndex is 1, the Management station will create an entry in cefLMPrefixTable with cefLMPrefixRowStatus.1(entPhysicalIndex).1(ipv4).A.B.C.D set to createAndGo(4). Management Station may query the value of objects cefLMPrefix and cefLMPrefixLen to find out the corresponding prefix entry from the cefPrefixTable once the value of cefLMPrefixState is set to matchFound(2).

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefLMPrefixTable_CefLMPrefixEntry) GetEntityData 

func (cefLMPrefixEntry *CISCOCEFMIB_CefLMPrefixTable_CefLMPrefixEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefNotifCntl 

type CISCOCEFMIB_CefNotifCntl struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Indicates whether or not a notification should be generated on the
	// detection of CEF resource Failure. The type is bool.
	CefResourceFailureNotifEnable interface{}

	// Indicates whether or not a notification should be generated on the
	// detection of CEF peer state change. The type is bool.
	CefPeerStateChangeNotifEnable interface{}

	// Indicates whether or not a notification should be generated on the
	// detection of CEF FIB peer state change. The type is bool.
	CefPeerFIBStateChangeNotifEnable interface{}

	// This object controls the generation of the cefInconsistencyDetection
	// notification.  If this object has a value of zero, then the throttle
	// control is disabled.  If this object has a non-zero value, then the agent
	// must not generate more than one  cefInconsistencyDetection
	// 'notification-event' in the  indicated period, where a 'notification-event'
	// is the transmission of a single trap or inform PDU to a list of
	// notification destinations.  If additional inconsistency is detected within
	// the  throttling period, then notification-events for these inconsistencies
	// should be suppressed by the agent until the current throttling period
	// expires.  At the end of a throttling period, one notification-event should
	// be generated if any inconsistency was detected since the start of the
	// throttling period. In such a case,  another throttling period is started
	// right away.  An NMS should periodically poll cefInconsistencyRecordTable to
	// detect any missed cefInconsistencyDetection notification-events, e.g., due
	// to throttling or transmission loss.   If cefNotifThrottlingInterval
	// notification generation is enabled, the suggested default throttling period
	// is 60 seconds, but generation of the cefInconsistencyDetection notification
	// should be disabled by default.  If the agent is capable of storing
	// non-volatile configuration, then the value of this object must be restored
	// after a re-initialization of the management system.  The actual
	// transmission of notifications is controlled via the MIB modules in RFC
	// 3413. The type is interface{} with range: 0..3600. Units are seconds.
	CefNotifThrottlingInterval interface{}

	// Indicates whether cefInconsistencyDetection notification should be
	// generated for this managed device. The type is bool.
	CefInconsistencyNotifEnable interface{}
}

CISCOCEFMIB_CefNotifCntl

func (*CISCOCEFMIB_CefNotifCntl) GetEntityData 

func (cefNotifCntl *CISCOCEFMIB_CefNotifCntl) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefPathTable 

type CISCOCEFMIB_CefPathTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the Managed device, each entry contain a CEF prefix
	// path.  entPhysicalIndex is also an index for this table which represents
	// entities of 'module' entPhysicalClass which are capable of running CEF. The
	// type is slice of CISCOCEFMIB_CefPathTable_CefPathEntry.
	CefPathEntry []*CISCOCEFMIB_CefPathTable_CefPathEntry
}

CISCOCEFMIB_CefPathTable CEF prefix path is a valid route to reach to a destination IP prefix. Multiple paths may exist out of a router to the same destination prefix. This table specify lists of CEF paths.

func (*CISCOCEFMIB_CefPathTable) GetEntityData 

func (cefPathTable *CISCOCEFMIB_CefPathTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefPathTable_CefPathEntry 

type CISCOCEFMIB_CefPathTable_CefPathEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The type is InetAddressType. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefPrefixTable_CefPrefixEntry_CefPrefixType
	CefPrefixType interface{}

	// This attribute is a key. The type is string with length: 0..255. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefPrefixTable_CefPrefixEntry_CefPrefixAddr
	CefPrefixAddr interface{}

	// This attribute is a key. The type is string with range: 0..2040. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefPrefixTable_CefPrefixEntry_CefPrefixLen
	CefPrefixLen interface{}

	// This attribute is a key. The locally arbitrary, but unique identifier
	// associated with this prefix path entry. The type is interface{} with range:
	// 1..2147483647.
	CefPathId interface{}

	// Type for this CEF Path. The type is CefPathType.
	CefPathType interface{}

	// Interface associated with this CEF path.  A value of zero for this object
	// will indicate that no interface is associated with this path  entry. The
	// type is interface{} with range: 0..2147483647.
	CefPathInterface interface{}

	// Next hop address associated with this CEF path.  The value of this object
	// is only relevant for attached next hop and recursive next hop   path types
	// (when the object cefPathType is set to attachedNexthop(4) or
	// recursiveNexthop(5)). and will be set to zero for other path types.  The
	// type of this address is determined by the value of the cefPrefixType
	// object. The type is string with length: 0..255.
	CefPathNextHopAddr interface{}

	// The recursive vrf name associated with this path.  The value of this object
	// is only relevant for recursive next hop path types (when the  object
	// cefPathType is set to recursiveNexthop(5)), and '0x00' will be returned for
	// other path types. The type is string with length: 0..31.
	CefPathRecurseVrfName interface{}
}

CISCOCEFMIB_CefPathTable_CefPathEntry If CEF is enabled on the Managed device, each entry contain a CEF prefix path.

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefPathTable_CefPathEntry) GetEntityData 

func (cefPathEntry *CISCOCEFMIB_CefPathTable_CefPathEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefPeerFIBTable 

type CISCOCEFMIB_CefPeerFIBTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the Managed device, each entry contains the CEF FIB
	// State  associated a CEF peer entity.  entPhysicalIndex and
	// entPeerPhysicalIndex are also indexes for this table which represents
	// entities of 'module' entPhysicalClass which are capable of running CEF. The
	// type is slice of CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry.
	CefPeerFIBEntry []*CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry
}

CISCOCEFMIB_CefPeerFIBTable Entity acting as RP (Routing Processor) keep the CEF FIB states for the line card entities and communicate with the line card entities using XDR. This Table contains the CEF FIB State related to peer entities on the managed device.

func (*CISCOCEFMIB_CefPeerFIBTable) GetEntityData 

func (cefPeerFIBTable *CISCOCEFMIB_CefPeerFIBTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry 

type CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefPeerTable_CefPeerEntry_EntPeerPhysicalIndex
	EntPeerPhysicalIndex interface{}

	// This attribute is a key. The type is CefIpVersion. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry_CefFIBIpVersion
	CefFIBIpVersion interface{}

	// The current CEF FIB Operational State for the  CEF peer entity. The type is
	// CefPeerFIBOperState.
	CefPeerFIBOperState interface{}
}

CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry If CEF is enabled on the Managed device, each entry contains the CEF FIB State associated a CEF peer entity.

entPhysicalIndex and entPeerPhysicalIndex are also indexes for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry) GetEntityData 

func (cefPeerFIBEntry *CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState 

type CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState string

CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState represents CEF peer entity. 

const (
	CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState_peerFIBDown CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState = "peerFIBDown"

	CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState_peerFIBUp CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState = "peerFIBUp"

	CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState_peerFIBReloadRequest CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState = "peerFIBReloadRequest"

	CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState_peerFIBReloading CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState = "peerFIBReloading"

	CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState_peerFIBSynced CISCOCEFMIB_CefPeerFIBTable_CefPeerFIBEntry_CefPeerFIBOperState = "peerFIBSynced"
)

type CISCOCEFMIB_CefPeerTable 

type CISCOCEFMIB_CefPeerTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the Managed device, each entry contains the CEF
	// related attributes  associated with a CEF peer entity.  entPhysicalIndex
	// and entPeerPhysicalIndex are also indexes for this table which represents
	// entities of 'module' entPhysicalClass which are capable of running CEF. The
	// type is slice of CISCOCEFMIB_CefPeerTable_CefPeerEntry.
	CefPeerEntry []*CISCOCEFMIB_CefPeerTable_CefPeerEntry
}

CISCOCEFMIB_CefPeerTable Entity acting as RP (Routing Processor) keeps the CEF states for the line card entities and communicates with the line card entities using XDR. This Table contains the CEF information related to peer entities on the managed device.

func (*CISCOCEFMIB_CefPeerTable) GetEntityData 

func (cefPeerTable *CISCOCEFMIB_CefPeerTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefPeerTable_CefPeerEntry 

type CISCOCEFMIB_CefPeerTable_CefPeerEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The entity index for the CEF peer entity. Only the
	// entities of 'module'  entPhysicalClass are included here. The type is
	// interface{} with range: 1..2147483647.
	EntPeerPhysicalIndex interface{}

	// The current CEF operational state of the CEF peer entity.  Cef peer entity
	// oper state will be peerDisabled(1) in  the following condition:     : Cef
	// Peer entity encounters fatal error i.e. resource      allocation failure,
	// ipc failure etc     : When a reload/delete request is received from the Cef
	// Peer Entity  Once the peer entity is up and no fatal error is encountered,
	// then the value of this object will transits to the peerUp(3)  state.  If
	// the Cef Peer entity is in held stage, then the value of this object will be
	// peerHold(3). Cef peer entity can only transit to peerDisabled(1) state from
	// the peerHold(3) state. The type is CefPeerOperState.
	CefPeerOperState interface{}

	// Number of times the session with CEF peer entity  has been reset. The type
	// is interface{} with range: 0..4294967295.
	CefPeerNumberOfResets interface{}
}

CISCOCEFMIB_CefPeerTable_CefPeerEntry If CEF is enabled on the Managed device, each entry contains the CEF related attributes associated with a CEF peer entity.

entPhysicalIndex and entPeerPhysicalIndex are also indexes for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefPeerTable_CefPeerEntry) GetEntityData 

func (cefPeerEntry *CISCOCEFMIB_CefPeerTable_CefPeerEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefPeerTable_CefPeerEntry_CefPeerOperState 

type CISCOCEFMIB_CefPeerTable_CefPeerEntry_CefPeerOperState string

CISCOCEFMIB_CefPeerTable_CefPeerEntry_CefPeerOperState represents transit to peerDisabled(1) state from the peerHold(3) state. 

const (
	CISCOCEFMIB_CefPeerTable_CefPeerEntry_CefPeerOperState_peerDisabled CISCOCEFMIB_CefPeerTable_CefPeerEntry_CefPeerOperState = "peerDisabled"

	CISCOCEFMIB_CefPeerTable_CefPeerEntry_CefPeerOperState_peerUp CISCOCEFMIB_CefPeerTable_CefPeerEntry_CefPeerOperState = "peerUp"

	CISCOCEFMIB_CefPeerTable_CefPeerEntry_CefPeerOperState_peerHold CISCOCEFMIB_CefPeerTable_CefPeerEntry_CefPeerOperState = "peerHold"
)

type CISCOCEFMIB_CefPrefixTable 

type CISCOCEFMIB_CefPrefixTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the Managed device, each entry contains the forwarding
	// prefix attributes.   CEF prefix based non-recursive stats are maintained in
	// internal and external buckets (depending upon the  value of
	// cefIntNonrecursiveAccouting object in the  CefIntEntry).  entPhysicalIndex
	// is also an index for this table which represents entities of 'module'
	// entPhysicalClass which are capable of running CEF. The type is slice of
	// CISCOCEFMIB_CefPrefixTable_CefPrefixEntry.
	CefPrefixEntry []*CISCOCEFMIB_CefPrefixTable_CefPrefixEntry
}

CISCOCEFMIB_CefPrefixTable A list of CEF forwarding prefixes.

func (*CISCOCEFMIB_CefPrefixTable) GetEntityData 

func (cefPrefixTable *CISCOCEFMIB_CefPrefixTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefPrefixTable_CefPrefixEntry 

type CISCOCEFMIB_CefPrefixTable_CefPrefixEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The Network Prefix Type. This object specifies the
	// address type used for cefPrefixAddr.  Prefix entries are only valid for the
	// address type of ipv4(1) and ipv6(2). The type is InetAddressType.
	CefPrefixType interface{}

	// This attribute is a key. The Network Prefix Address. The type of this
	// address is determined by the value of the cefPrefixType object. This object
	// is a Prefix Address containing the  prefix with length specified by
	// cefPrefixLen.  Any bits beyond the length specified by cefPrefixLen are
	// zeroed. The type is string with length: 0..255.
	CefPrefixAddr interface{}

	// This attribute is a key. Length in bits of the FIB Address prefix. The type
	// is interface{} with range: 0..2040.
	CefPrefixLen interface{}

	// This object indicates the associated forwarding element selection entries
	// in cefFESelectionTable. The value of this object is index value
	// (cefFESelectionName) of cefFESelectionTable. The type is string.
	CefPrefixForwardingInfo interface{}

	// If CEF accounting is set to enable per prefix accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable 'perPrefix'
	// accounting), then this object represents the  number of packets switched to
	// this prefix. The type is interface{} with range: 0..4294967295. Units are
	// packets.
	CefPrefixPkts interface{}

	// If CEF accounting is set to enable per prefix accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable 'perPrefix'
	// accounting), then this object represents the  number of packets switched to
	// this prefix.   This object is a 64-bit version of  cefPrefixPkts. The type
	// is interface{} with range: 0..18446744073709551615. Units are packets.
	CefPrefixHCPkts interface{}

	// If CEF accounting is set to enable per prefix accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable 'perPrefix'
	// accounting), then this object represents the  number of bytes switched to
	// this prefix. The type is interface{} with range: 0..4294967295. Units are
	// bytes.
	CefPrefixBytes interface{}

	// If CEF accounting is set to enable per prefix accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable 'perPrefix'
	// accounting), then this object represents the  number of bytes switched to
	// this prefix.  This object is a 64-bit version of  cefPrefixBytes. The type
	// is interface{} with range: 0..18446744073709551615. Units are bytes.
	CefPrefixHCBytes interface{}

	// If CEF accounting is set to enable non-recursive accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable
	// 'nonRecursive'  accounting), then this object represents the number of
	// non-recursive packets in the internal bucket switched using this prefix.
	// The type is interface{} with range: 0..4294967295. Units are packets.
	CefPrefixInternalNRPkts interface{}

	// If CEF accounting is set to enable non-recursive accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable
	// 'nonRecursive'  accounting), then this object represents the number of
	// non-recursive packets in the internal bucket switched using this prefix.
	// This object is a 64-bit version of  cefPrefixInternalNRPkts. The type is
	// interface{} with range: 0..18446744073709551615. Units are packets.
	CefPrefixInternalNRHCPkts interface{}

	// If CEF accounting is set to enable nonRecursive accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable
	// 'nonRecursive'  accounting), then this object represents  the number of
	// non-recursive bytes in the internal bucket switched using this prefix. The
	// type is interface{} with range: 0..4294967295. Units are bytes.
	CefPrefixInternalNRBytes interface{}

	// If CEF accounting is set to enable nonRecursive accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable
	// 'nonRecursive'  accounting), then this object represents  the number of
	// non-recursive bytes in the internal bucket switched using this prefix.
	// This object is a 64-bit version of  cefPrefixInternalNRBytes. The type is
	// interface{} with range: 0..18446744073709551615. Units are bytes.
	CefPrefixInternalNRHCBytes interface{}

	// If CEF accounting is set to enable non-recursive accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable
	// 'nonRecursive'  accounting), then this object represents the number of
	// non-recursive packets in the external bucket switched using this prefix.
	// The type is interface{} with range: 0..4294967295. Units are packets.
	CefPrefixExternalNRPkts interface{}

	// If CEF accounting is set to enable non-recursive accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable
	// 'nonRecursive'  accounting), then this object represents the number of
	// non-recursive packets in the external bucket switched using this prefix.
	// This object is a 64-bit version of  cefPrefixExternalNRPkts. The type is
	// interface{} with range: 0..18446744073709551615. Units are packets.
	CefPrefixExternalNRHCPkts interface{}

	// If CEF accounting is set to enable nonRecursive accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable
	// 'nonRecursive'  accounting), then this object represents  the number of
	// non-recursive bytes in the external bucket switched using this prefix. The
	// type is interface{} with range: 0..4294967295. Units are bytes.
	CefPrefixExternalNRBytes interface{}

	// If CEF accounting is set to enable nonRecursive accounting (value of
	// cefCfgAccountingMap object in  the cefCfgEntry is set to enable
	// 'nonRecursive'  accounting), then this object represents  the number of
	// non-recursive bytes in the external bucket switched using this prefix.
	// This object is a 64-bit version of  cefPrefixExternalNRBytes. The type is
	// interface{} with range: 0..18446744073709551615. Units are bytes.
	CefPrefixExternalNRHCBytes interface{}
}

CISCOCEFMIB_CefPrefixTable_CefPrefixEntry If CEF is enabled on the Managed device, each entry contains the forwarding prefix attributes.

CEF prefix based non-recursive stats are maintained in internal and external buckets (depending upon the value of cefIntNonrecursiveAccouting object in the CefIntEntry).

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefPrefixTable_CefPrefixEntry) GetEntityData 

func (cefPrefixEntry *CISCOCEFMIB_CefPrefixTable_CefPrefixEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefResourceTable 

type CISCOCEFMIB_CefResourceTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If the Managed device supports CEF, each entry contains the CEF Resource
	// parameters for the managed entity.  entPhysicalIndex is also an index for
	// this table which represents entities of 'module' entPhysicalClass which are
	// capable of running CEF. The type is slice of
	// CISCOCEFMIB_CefResourceTable_CefResourceEntry.
	CefResourceEntry []*CISCOCEFMIB_CefResourceTable_CefResourceEntry
}

CISCOCEFMIB_CefResourceTable This table contains global resource information of CEF on the Managed device.

func (*CISCOCEFMIB_CefResourceTable) GetEntityData 

func (cefResourceTable *CISCOCEFMIB_CefResourceTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefResourceTable_CefResourceEntry 

type CISCOCEFMIB_CefResourceTable_CefResourceEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// Indicates the number of bytes from the Processor Memory Pool that are
	// currently in use by CEF on the managed entity. The type is interface{} with
	// range: 0..4294967295. Units are bytes.
	CefResourceMemoryUsed interface{}

	// The CEF resource failure reason which may lead to CEF being disabled on the
	// managed entity. The type is CefFailureReason.
	CefResourceFailureReason interface{}
}

CISCOCEFMIB_CefResourceTable_CefResourceEntry If the Managed device supports CEF, each entry contains the CEF Resource parameters for the managed entity.

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefResourceTable_CefResourceEntry) GetEntityData 

func (cefResourceEntry *CISCOCEFMIB_CefResourceTable_CefResourceEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefStatsPrefixLenTable 

type CISCOCEFMIB_CefStatsPrefixLenTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the Managed device and if CEF accounting is set to
	// enable  prefix length based accounting (value of  cefCfgAccountingMap
	// object in the  cefCfgEntry is set to enable 'prefixLength'  accounting),
	// each entry contains the traffic  statistics for a prefix length. A row may
	// exist for each IP version type (v4 and v6) depending upon the IP version
	// supported on the device.  entPhysicalIndex is also an index for this table
	// which represents entities of 'module' entPhysicalClass which are capable of
	// running CEF. The type is slice of
	// CISCOCEFMIB_CefStatsPrefixLenTable_CefStatsPrefixLenEntry.
	CefStatsPrefixLenEntry []*CISCOCEFMIB_CefStatsPrefixLenTable_CefStatsPrefixLenEntry
}

CISCOCEFMIB_CefStatsPrefixLenTable This table specifies the CEF stats based on the Prefix Length.

func (*CISCOCEFMIB_CefStatsPrefixLenTable) GetEntityData 

func (cefStatsPrefixLenTable *CISCOCEFMIB_CefStatsPrefixLenTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefStatsPrefixLenTable_CefStatsPrefixLenEntry 

type CISCOCEFMIB_CefStatsPrefixLenTable_CefStatsPrefixLenEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The type is CefIpVersion. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry_CefFIBIpVersion
	CefFIBIpVersion interface{}

	// This attribute is a key. Length in bits of the Destination IP prefix. As
	// 0.0.0.0/0 is a valid prefix, hence  0 is a valid prefix length. The type is
	// interface{} with range: 0..2040.
	CefStatsPrefixLen interface{}

	// Number of queries received in the FIB database  for the specified IP prefix
	// length. The type is interface{} with range: 0..4294967295.
	CefStatsPrefixQueries interface{}

	// Number of queries received in the FIB database for the specified IP prefix
	// length. This object is a 64-bit version of  cefStatsPrefixQueries. The type
	// is interface{} with range: 0..18446744073709551615.
	CefStatsPrefixHCQueries interface{}

	// Number of insert operations performed to the FIB  database for the
	// specified IP prefix length. The type is interface{} with range:
	// 0..4294967295.
	CefStatsPrefixInserts interface{}

	// Number of insert operations performed to the FIB  database for the
	// specified IP prefix length. This object is a 64-bit version of
	// cefStatsPrefixInsert. The type is interface{} with range:
	// 0..18446744073709551615.
	CefStatsPrefixHCInserts interface{}

	// Number of delete operations performed to the FIB  database for the
	// specified IP prefix length. The type is interface{} with range:
	// 0..4294967295.
	CefStatsPrefixDeletes interface{}

	// Number of delete operations performed to the FIB  database for the
	// specified IP prefix length. This object is a 64-bit version of
	// cefStatsPrefixDelete. The type is interface{} with range:
	// 0..18446744073709551615.
	CefStatsPrefixHCDeletes interface{}

	// Total number of elements in the FIB database for the specified IP prefix
	// length. The type is interface{} with range: 0..4294967295.
	CefStatsPrefixElements interface{}

	// Total number of elements in the FIB database for the specified IP prefix
	// length. This object is a 64-bit version of  cefStatsPrefixElements. The
	// type is interface{} with range: 0..18446744073709551615.
	CefStatsPrefixHCElements interface{}
}

CISCOCEFMIB_CefStatsPrefixLenTable_CefStatsPrefixLenEntry If CEF is enabled on the Managed device and if CEF accounting is set to enable prefix length based accounting (value of cefCfgAccountingMap object in the cefCfgEntry is set to enable 'prefixLength' accounting), each entry contains the traffic statistics for a prefix length. A row may exist for each IP version type (v4 and v6) depending upon the IP version supported on the device.

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefStatsPrefixLenTable_CefStatsPrefixLenEntry) GetEntityData 

func (cefStatsPrefixLenEntry *CISCOCEFMIB_CefStatsPrefixLenTable_CefStatsPrefixLenEntry) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefSwitchingStatsTable 

type CISCOCEFMIB_CefSwitchingStatsTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// If CEF is enabled on the Managed device, each entry specifies the switching
	// stats. A row may exist for each IP version type (v4 and v6) depending upon
	// the IP version supported on the device.  entPhysicalIndex is also an index
	// for this table which represents entities of 'module' entPhysicalClass which
	// are capable of running CEF. The type is slice of
	// CISCOCEFMIB_CefSwitchingStatsTable_CefSwitchingStatsEntry.
	CefSwitchingStatsEntry []*CISCOCEFMIB_CefSwitchingStatsTable_CefSwitchingStatsEntry
}

CISCOCEFMIB_CefSwitchingStatsTable This table specifies the CEF switch stats.

func (*CISCOCEFMIB_CefSwitchingStatsTable) GetEntityData 

func (cefSwitchingStatsTable *CISCOCEFMIB_CefSwitchingStatsTable) GetEntityData() *types.CommonEntityData

type CISCOCEFMIB_CefSwitchingStatsTable_CefSwitchingStatsEntry 

type CISCOCEFMIB_CefSwitchingStatsTable_CefSwitchingStatsEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to
	// entity_mib.ENTITYMIB_EntPhysicalTable_EntPhysicalEntry_EntPhysicalIndex
	EntPhysicalIndex interface{}

	// This attribute is a key. The type is CefIpVersion. Refers to
	// cisco_cef_mib.CISCOCEFMIB_CefFIBSummaryTable_CefFIBSummaryEntry_CefFIBIpVersion
	CefFIBIpVersion interface{}

	// This attribute is a key. The locally arbitrary, but unique identifier
	// associated with this switching stats entry. The type is interface{} with
	// range: 1..2147483647.
	CefSwitchingIndex interface{}

	// Switch path where the feature was executed. Available switch paths are
	// platform-dependent. Following are the examples of switching paths:     RIB
	// : switching with CEF assistance     Low-end switching (LES) : CEF switch
	// path     PAS : CEF turbo switch path. The type is string with length:
	// 1..32.
	CefSwitchingPath interface{}

	// Number of packets dropped by CEF. The type is interface{} with range:
	// 0..4294967295. Units are packets.
	CefSwitchingDrop interface{}

	// Number of packets dropped by CEF. This object is a 64-bit version of
	// cefSwitchingDrop. The type is interface{} with range:
	// 0..18446744073709551615. Units are packets.
	CefSwitchingHCDrop interface{}

	// Number of packets that could not be switched in the normal path and were
	// punted to the next-fastest switching vector. The type is interface{} with
	// range: 0..4294967295. Units are packets.
	CefSwitchingPunt interface{}

	// Number of packets that could not be switched in the normal path and were
	// punted to the next-fastest switching vector. This object is a 64-bit
	// version of cefSwitchingPunt. The type is interface{} with range:
	// 0..18446744073709551615. Units are packets.
	CefSwitchingHCPunt interface{}

	// Number of packets that could not be switched in the normal path and were
	// punted to the host (process switching path).  For most of the switching
	// paths, the value of this object may be similar to cefSwitchingPunt. The
	// type is interface{} with range: 0..4294967295. Units are packets.
	CefSwitchingPunt2Host interface{}

	// Number of packets that could not be switched in the normal path and were
	// punted to the host (process switching path).  For most of the switching
	// paths, the value of this object may be similar to cefSwitchingPunt. This
	// object is a 64-bit version of cefSwitchingPunt2Host. The type is
	// interface{} with range: 0..18446744073709551615. Units are packets.
	CefSwitchingHCPunt2Host interface{}
}

CISCOCEFMIB_CefSwitchingStatsTable_CefSwitchingStatsEntry If CEF is enabled on the Managed device, each entry specifies the switching stats. A row may exist for each IP version type (v4 and v6) depending upon the IP version supported on the device.

entPhysicalIndex is also an index for this table which represents entities of 'module' entPhysicalClass which are capable of running CEF.

func (*CISCOCEFMIB_CefSwitchingStatsTable_CefSwitchingStatsEntry) GetEntityData 

func (cefSwitchingStatsEntry *CISCOCEFMIB_CefSwitchingStatsTable_CefSwitchingStatsEntry) GetEntityData() *types.CommonEntityData

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.