Internet-Draft                                                Ryan Moats
draft-moats-dmtf-network-ldap-00.txt
draft-moats-dmtf-network-ldap-01.txt                    Gerald Maziarski
Expires in six months                                               AT&T
                                                          John Strassner
                                                           cisco Systems
                                                            October
                                                           December 1999

            LDAP Schema for the DMTF Network CIM v2.2 Model
             Filename: draft-moats-dmtf-network-ldap-00.txt draft-moats-dmtf-network-ldap-01.txt

Status of this Memo

   This document is an Internet-Draft and is in full conformance with
   all provisions of Section 10 of RFC2026.  Internet-Drafts are working
   documents of the Internet Engineering Task Force (IETF), its areas,
   and its working groups.  Note that other groups may also distribute
   working documents as Internet-Drafts.

   Internet-Drafts are draft documents valid for a maximum of six months
   and may be updated, replaced, or obsoleted by other documents at any
   time.  It is inappropriate to use Internet- Drafts as reference
   material or to cite them other than as "work in progress."

   The list of current Internet-Drafts can be accessed at
   http://www.ietf.org/ietf/1id-abstracts.txt

   The list of Internet-Draft Shadow Directories can be accessed at
   http://www.ietf.org/shadow.html.

Abstract

   This draft presents a LDAP schema for the DMTF CIM Network model
   version 2.2 [4].

1. Introduction

   This draft presents a LDAPv3 [1,2] schema for the DMTF CIM Network
   model.  Associations are mapped using a combination of auxiliary
   classes and DIT structure rules.  Where auxiliary classes are used,
   name form and DIT content rules are specified.

   This document is not a product of the DMTF, and represents the view
   of the authors.

2. LDAP Mapping Considerations

2.1 Differences Between this Mapping and the CIM Device Model

   There are some differences between the classes and associations
   specified in the CIM model and the schema here.  First, because the
   core model requires services to be contained by systems the
   NetworkServicesInAdminDomain association doesn't add any new
   information.  Second, there are a couple of classes that don't have
   structural rules specified for them as they don't specify any new
   RDNs.  There are a couple of namespace collisions between this model
   and and other models, a couple of attributes in this model have been
   renamed.  Finaly, the classes TransparentBridgingStatistics,
   SpanningTreeStatistics, SwitchPortStatistics,
   SwitchPortTransparentBridingStatistics,
   SwitchPortSpanningTreeStatistics, SwitchPortSourceRoutingStatisitcs,
   BGPStatistics, and BGPServiceStatistics aren't included as they
   contain counter information that is considered too dynamic for
   directory storage.

2.2 Changes to cimAssociationInstance

   The core mapping [3] defined cimAssociationInstance as a helper
   class.  To support the auxiliary classes, the following classes
   should be added to cimAssociationInstance's content rule:

   Also, the following structure rules defined here need to be added to
   the structure rule for cimAssociationInstance:

3. Class Definitions

   For efficiency in the LDAP representation, associations are specified
   as a combination of auxiliary classes and DIT structure rules.
   Attribute definitions for each class are presented with the object
   class.  Other definitions are also provided when necessary.

   This approach minimizes the number of DN pointers stored in the
   schema, but some pointer dereferencing is necessary.  While not
   explicitly stated in the definitions below, we assume that all
   attributes with DN support the matching rule defined in [3].
   Attribute names for DN pointers also follow the convention that a
   single pointer's name ends in "Ref", while an array of pointers' name
   ends in "Refs".

   Note: all attribute, object class, and name form OIDs are place
   holders, and syntax OIDs in definitions have been replaced by names
   for clarity.

   There are some differences between the classes and associations
   specified in the CIM model and the schema here.  First, because the
   core model requires services to be contained by systems the
   NetworkServicesInAdminDomain association doesn't add any new
   information.  Second, there are a couple of classes that don't have
   structural rules specified for them as they don't specify any new
   RDNs.  There are a couple of namespace collisions between this model
   and and other models, a couple of attributes in this model have been
   renamed.  Finaly, the classes TransparentBridgingStatistics,
   SpanningTreeStatistics, SwitchPortStatistics,
   SwitchPortTransparentBridingStatistics,
   SwitchPortSpanningTreeStatistics, SwitchPortSourceRoutingStatisitcs,
   BGPStatistics, and BGPServiceStatistics aren't included as they
   contain counter information that is considered too dynamic for
   directory storage.

2.1 dmtfAdminDomain

3.1 cim22AdminDomain

   This is a special grouping of dmtfManagedSystemElement cim22ManagedSystemElement objects that
   are all administered by the same user or group of users. It serves as
   an aggregation point to associate one or more of the following
   elements: network devices, such as routers and switches, servers, and
   other resources that can be accessed by end systems. This grouping of
   devices plays an essential role in ensuring that the same
   administrative POLICY is applied to all the devices in the grouping.

      ( <oid-oc266> <oid-oc269> NAME 'dmtfAdminDomain' 'cim22AdminDomain'
        DESC 'special 'This is a special grouping of ManagedSystemElements that
              are all administered by the same user or group of users.' users. It
              serves as an aggregation point to associate one or more of
              the following elements: network devices, such as routers
              and switches, servers, and other resources that can be
              accessed by end systems. This grouping of devices plays an
              essential role in ensuring that the same administrative
              POLICY is applied to all of the devices in the grouping.'
        SUP dmtfSystem ABSTRACT cim22System
      )

      ( <oid-nf63> NAME 'cim22AdminDomainNameForm'
        OC cim22AdminDomain
        MUST (nameFormat) (orderedCimModelPath)
      )

2.2 dmtfNetworkService

      ( <sr63> NAME 'cim22AdminDomainStructureRule'
        FORM cim22AdminDomainNameForm
      )

3.2 cim22NetworkService

   This abstract base class is derived from the dmtfService cim22Service class. It serves as
   the root of the network service hierarchy. Network services represent
   generic functions that are available from the network that configure
   and/or change the traffic being sent. For example, FTP is not a
   network service, as it simply passes data unchanged from source to
   destination. On the other hand, services that provide quality of
   service (e.g., DiffServ) and security (e.g., IPSec) do affect the
   traffic stream. Quality of service, IPSec, and other services are
   subclasses of this class. This class hierarchy enables developers to
   match services to users, groups, and other objects in the network.

      ( <oid-at611> <oid-at607> NAME 'keywords' 'cimKeywords'
        DESC 'a 'This is a free-form array of strings that provide
              descriptive words and phrases that can be used in queries
              to help locate and identify instances of this service.'

        SYNTAX string
      )

      ( <oid-at612> <oid-at608> NAME 'startupConditions' 'cimServiceURL'
        DESC 'a 'This is a URL that provides the protocol, network location,
              and other service-specific information required in order to
              access the service. This should be implemented as a
              LabeledURI, with syntax DirectoryString and a matching rule
              of CaseExactMatch, for directory implementors.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at609> NAME 'cimStartupConditions'
        DESC 'This is a free-form array of strings that specify any
              specific pre-conditions that must be met in order for this
              service to start correctly.'
        SYNTAX string
      )

      ( <oid-at613> <oid-at610> NAME 'startupParameters' 'cimStartupParameters'
        DESC 'a 'This is a free-form array of strings that specify any
              specific parameters that must be supplied to the
              StartService() method in order for this service to start
              correctly.'
        SYNTAX string
      )

      ( <oid-at614> <oid-oc270> NAME 'serviceURL' 'cim22NetworkService'
        DESC 'This is a URL the root of the network service hierarchy. Network
              services represent generic functions that provides are available
              from the protocol, network location, that configure and/or modify the traffic
              being sent. For example, FTP is not a network service, as
              it simply passes data unchanged from source to
              destination. On the other hand, services that provide
              quality of service (e.g., DiffServ) and security (e.g.,
              IPSec) do affect the traffic stream. Quality of service,
              IPSec, and other service-specific information required services are subclasses of this
              class. This class hierarchy enables developers to
           access match
              services to users, groups, and other objects in the service.'
        SYNTAX DirectoryString EQUALITY CaseExactMatch
        SINGLE-VALUE
              network.'
        SUP cim22Service
        MAY (cimKeywords $ cimServiceURL $ cimStartupConditions $
             cimStartupParameters)
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22NetworkService.

      ( <oid-oc267> <oid-oc270> NAME 'dmtfNetworkService' 'cim22NetworkServiceContentRule'
        DESC 'an abstract base class derived from the dmtfService class.'
        SUP dmtfService ABSTRACT
        MUST (serviceURL $ keywords $ startupConditions 'The auxiliary classes that may be attached to
              cim22NetworkService'
        AUX (cim22LogicalNetworkServiceAuxClass $
           startupParameters)
             cim22ProvidesEndpointAuxClass)
      )

2.3 dmtfForwardingService

3.3 cim22ForwardingService

   This class represents the forwarding of network traffic by receiving
   data from one or more protocol endpoints and sending that data via
   other protocol endpoints. This class is different from the
   dmtfRouteCalculationService
   cim22RouteCalculationService class in that it represents a way to
   forward traffic independent of calculating routing information (e.g.,
   using static routing). Generally, the endpoints a forwarding service
   routes data among are at the same protocol layer and are usually of
   similar types or of the same type. Examples of this service include
   routing, bridging, and repeating services.

      ( <oid-at615> <oid-at611> NAME 'protocolType' 'cimProtocolType'
        DESC 'This defines the type of protocol that is being
              forwarded.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at616> <oid-at612> NAME 'otherProtocolType' 'cimOtherProtocolType'
        DESC 'This defines the type of protocol that is being forwarded
              when the value of the ProtocolType attribute is 1 (e.g.,
              "Other"). This provides for future extensibility.'
        SYNTAX string{32} SINGLE-VALUE
      )

      ( <oid-oc268> <oid-oc271> NAME 'dmtfForwardingService' 'cim22ForwardingService'
        DESC 'represents 'This class represents the forwarding of network traffic by
              receiving data from one or more ProtocolEndpoints and
              sending that data via other ProtocolEndpoints.' ProtocolEndpoints. This class
              is different than the RouteCalculationService class in that
              it represents a way to forward traffic independent of
              calculating routing information (e.g., using static
              routing). Generally, the endpoints among which a
              ForwardingService routes data are at the same protocol
              layer and are usually of similar types or of the same
              type. Examples of this kind of service include routing,
              bridging, and repeating services. Instances of this class
              will have ForwardsAmong associations to the
              ProtocolEndpoint instances among which forwarding is
              occurring.'
        SUP dmtfNetworkService
        MUST (protocolType cim22NetworkService
        MAY (cimProtocolType $ otherProtocolType) cimOtherProtocolType)
      )

2.4 dmtfAutonomousSystem

      ( <oid-nf55> NAME 'cim22ForwardingServiceNameForm'
        OC cim22ForwardingService
        MUST (orderedCimModelPath)
      )

      ( <sr55> NAME 'cim22ForwardingServiceStructureRule'
        FORM cim22ForwardingServiceNameForm
        SUP <sr2>
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22ForwardingService.

      ( <oid-oc271> NAME 'cim22ForwardingServiceContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22ForwardingService'
        AUX (cim22ForwardsAmongAuxClass)
      )

3.4 cim22AutonomousSystem

   This class provides a structured view of routing by segregating the
   system that is using routing (e.g., the Internet, or an extranet)
   into a set of separately administered domains that each have their
   own independent routing policies. These domains are called autonomous
   systems.  The classic definition of an AS, from RFC1771, is

       ...a set of routers under a single technical administration,
      using an interior gateway protocol and common metrics to route
      packets within the AS, and using an exterior gateway protocol to
      route packets to other ASs

   The RFC continues

      Since this classic definition was developed, it has become common
      for a single AS to use several interior gateway protocols and
      sometimes several sets of metrics within an AS. The use of the
      term Autonomous System here stresses that, even when multiple IGPs
      and metrics are used, the administration of an AS appears to other
      ASs to have a single coherent interior routing plan and presents a
      consistent picture of what destinations are reachable through it.

         ( <oid-at617> <oid-at613> NAME 'aSNumber' 'cimASNumber'
           DESC 'an 'An ASNumber is an integer between 1 and 65535, with the
                 range 64512 through 65535 reserved for private use. Every
                 AS has a unique AS number, which is assigned to it by an
                 Internet Registry or a provider. IANA assigns and
                 administers AS numbers.'
           SYNTAX integer SINGLE-VALUE
         )

         ( <oid-at618> <oid-at614> NAME 'isSingleHomed' 'cimIsSingleHomed'
           DESC 'a 'IsSingleHomed is a boolean that, when its value is TRUE, shows
                 indicates that this AS reaches networks outside of its
                 domain through a single exit point. Whether a given AS is
                 single-homed or not has important ramifications for BGP
                 configuration.'
           SYNTAX boolean SINGLE-VALUE
         )

         ( <oid-at619> <oid-at615> NAME 'isTransit' 'cimIsTransit'
           DESC 'a 'IsTransit is a boolean that, when its value is TRUE, shows
                 indicates that this AS will advertise routes that it learns
                 from other ASs. A
              non-transit non- transit AS will only advertise its
                 own routes.'
           SYNTAX boolean SINGLE-VALUE
         )

         ( <oid-at620> <oid-at616> NAME 'requireIGPSync' 'cimRequireIGPSync'
           DESC 'a 'RequireIGPSync is a boolean that, when its value is TRUE, shows
                 indicates that this AS must obey the following BGP rule: a
                 BGP router should not advertise destinations learned from
                 internal BGP neighbors to external BGP destinations unless
                 those destinations are also known via some internal gateway
                 protocol. Otherwise, a BGP router may receive traffic that
                 cannot yet be routed. However, since this is a costly
                 choice, it is common practice to allow this rule to be
                 broken under certain carefully controlled circumstances.'
           SYNTAX boolean SINGLE-VALUE
         )

         ( <oid-at621> <oid-at617> NAME 'routingUpdateSource' 'cimRoutingUpdateSource'
           DESC 'defines 'RoutingUpdateSource defines how routing information is to
                 be injected into BGP. Statically injected routes are
                 maintained by the routing table and are independent of the
                 status of the networks that they refer to. This is done by
                 defining static routes in the BGP routing
                 table. Dynamically injected routes are of two
                 types. Dynamic routes refer to distributing all of the IGP
                 routes into BGP. Semi-dynamic routes define a set of
                 specific IGP routes that will be injected into BGP.'
           SYNTAX integer SINGLE-VALUE
         )
         ( <oid-at622> <oid-at618> NAME 'aggregationType' 'cimAggregationType'
           DESC 'refers 'Route aggregation refers to summarizing ranges of routes
                 into one or more aggregate routes.' routes. This is done to minimize
                 the number of routes in the global routing table. A
                 potential drawback is that specific path information (e.g.,
                 AS_Path attribute value) is lost, which may lead to
                 potential routing loops. There are a variety of ways to
                 ensure that this does not happen. Note, however, that BGP4
                 is required to do this. There are many ways to form
                 aggregate routes. The following are the most popular:
                 "Aggregate only", where only the aggregate is advertised,
                 and all of its more specific routes are suppressed;
                 "Aggregate Plus Specific Routes", where both the aggregate
                 as well as its more specific routes are advertised (e.g.,
                 send the aggregate to the NAP, but send the more specific
                 routes to providers); "Aggregate Based on a Subset of
                 Specific Routes", where the aggregate route is formed by
                 looking at certain more specific routes and forming an
                 aggregate on them, suppressing all others.'
           SYNTAX integer SINGLE-VALUE
         )

         ( <oid-oc269> <oid-oc272> NAME 'dmtfAutonomousSystem' 'cim22AutonomousSystem'
           DESC 'provides 'An Autonomous System (AS) is a fundamental concept in
                 networking. An AS provides a structured view of routing by
                 segregating the system that is using routing (e.g., the
                 Internet, or an extranet) into a set of separately
                 administered domains that each have their own independent
                 routing policies.' policies. These domains are called autonomous
                 systems.'
           SUP dmtfAdminDomain
           MUST (aSNumber cim22AdminDomain
           MAY (cimASNumber $ isSingleHomed cimIsSingleHomed $ isTransit cimIsTransit $ requireIGPSync
                cimRequireIGPSync $
              routingUpdateSource cimRoutingUpdateSource $ suppressed
                cimAggregationType)
         )

      The following content rule specifies the auxiliary classes that
      may be attached to cim22AutonomosSystem.

         ( <oid-oc272> NAME 'cim22AutonomousSystemContentRule'
           DESC 'The auxiliary classes that may be attached to
                 cim22AutonomousSystem'
           AUX (cim22BGPClustersInASAuxClass $ cim22RoutersInASAuxClass $ providers)
                cim22ASBGPEndpointsAuxClass $
              aggregationType) cim22ConfederationAuxClass)
         )

2.5 dmtfLogicalNetwork

3.5 cim22LogicalNetwork

   The dmtfLogicalNetwork cim22LogicalNetwork object groups together a set of
   dmtfProtocolEndpoint
   cim22ProtocolEndpoint objects of a given type that are able to
   communicate with each other directly. It is used for describing the
   characteristics of the grouping and/or its associated medium. This
   class represents the ability to send and/or receive data over a
   network.

      ( <oid-at623> <oid-at619> NAME 'type' 'cimType'
        DESC 'an 'Type is an enumeration that provides additional information
              that can be used to help categorize and classify different
              instances of this class . Subclasses should ensure that
              they are of the appropriate type defined in the Type
              enumeration. That is, the IPSubnet subclass should define
              its property as either IPv4 or IPv6, as opposed to, for
              example, ATM.'
        SYNTAX string{64} SINGLE-VALUE
      )

      ( <oid-oc270> <oid-oc273> NAME 'dmtfLogicalNetwork' 'cim22LogicalNetwork'
        DESC 'groups 'A LogicalNetwork groups together a set of ProtocolEndpoints
              of a given type which are able to communicate with each
              other directly.' directly. It is used for describing the
              characteristics of the grouping and/or its associated
              medium. A LogicalNetwork represents the ability to send
              and/or receive data over a network.'
        SUP dmtfCollectionOfMSEs cim22CollectionOfMSEs
        MUST (systemCreationClassName (cimSystemCreationClassName $ systemName cimSystemName $ creationClassName
              cimCreationClassName $
           name cimName $ type orderedCimModelPath)
        MAY (cimType $ otherTypeDescription) cimOtherTypeDescription)
      )

   While a variety of attributes may be used as RDNs, the following
   structural rules are recommended:

      ( 40 <oid-nf56> NAME 'dmtfLogicalNetworkStructureRule1' 'cim22LogicalNetworkNameForm'
        OC cim22LogicalNetwork
        MUST (orderedCimModelPath)
      )

      ( <sr56> NAME 'cim22LogicalNetworkStructureRule'
        FORM dmtfLogicalNetworkNameForm1 cim22LogicalNetworkNameForm
        SUP 3 4 <sr11>
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22LogicalNetwork

      ( <oid-nf40> <oid-oc273> NAME 'dmtfLogicalNetworkNameForm1'
        OC dmtfLogicalNetwork
        MUST (name) 'cim22LogicalNetworkContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22LogicalNetwork'
        AUX (cim22LogicalNetworkServiceAuxClass $
             cim22InLogicalNetworkAuxClass $ cim22CollectedMSEsAuxClass $
             cim22CollectedCollectionsAuxClass $
             cim22CollectionConfigurationAuxClass $
             cim22CollectionSettingAuxClass)
      )

2.6 dmtfLogicalNetworkServiceAuxClass

3.6 cim22LogicalNetworkServiceAuxClass

   This auxiliary class represents network services that either
   originate and/or terminate in a logical network. This enables
   management applications to more easily identify services that are
   provided by particular network devices.

      ( <oid-at624> <oid-at620> NAME 'dmtfLogicalNetworkRefs' 'cimNetworkRef'
        DESC 'The LogicalNetwork that contains the network service.'
        SYNTAX DN
      )

      ( <oid-at625> <oid-at621> NAME 'dmtfNetworkServiceRefs' 'cimNetworkServiceRef'
        DESC 'The NetworkService that is running in the LogicalNetwork.' LogicalNetwork. '
        SYNTAX DN
      )

      ( <oid-at626> <oid-at622> NAME 'containmentType' 'cimContainmentType'
        DESC 'An enumeration that explicitly defines this network service
              as originating, terminating, or residing in this
              LogicalNetwork.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc271> <oid-oc274> NAME 'dmtfLogicalNetworkServiceAuxClass' 'cim22LogicalNetworkServiceAuxClass'
        DESC 'represents 'A LogicalNetworkService represents network services that
              either originate and/or terminate in a LogicalNetwork.' LogicalNetwork. This
              enables management applications to more easily identify
              services that are provided by particular network
              devices. Attribute cimNetworkRef points to
              cim22LogicalNetwork. Attribute cimNetworkServiceRef points to
              cim22NetworkService.'
        SUP top AUXILIARY
        MUST (dmtfLogicalNetworkRefs
        MAY (cimNetworkRef $ dmtfNetworkServiceRefs cimNetworkServiceRef $
           containmentType) cimContainmentType)
      )

2.7 dmtfIPSubnet

3.7 cim22IPSubnet

   This class represents a group of related dmtfIPProtocolEndpoint cim22IPProtocolEndpoint
   objects that can communicate with each other directly using IP. It is
   used for describing the characteristics of the grouping.

      ( <oid-at627> <oid-at623> NAME 'subnetNumber' 'cimSubnetNumber'
        DESC 'The IP address of the entire subnet, formatted according to
              the appropriate convention as defined in the AddressType
              property of this class. Note that CIDR format is not
              supported for this release. This is because, without more
              formal methods like constraints, it is possible to create
              different instances of the same object that have different
              naming formats.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at628> NAME 'subnetMask'
        DESC 'The mask for the starting IP address formats.  IPv4-compatible addresses should be used
              instead of the IPSubnet,
           formatted according IPv6 addresses (see RFC 2373, section 2.5.4). In
              order to the appropriate convention as
           defined in the AddressType property of this class (e.g.,
           "255.255.252.0").'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at629> NAME 'addressType'
        DESC 'An enumeration that describes the have a consistent format of the address
           property. Addresses that can be formatted for IPv4 addresses in a
              mixed IPv4/v6 environment, all IPv4 format,
           must addresses and both
              IPv4-compatible IPv6 addresses and IPv4-mapped IPv6
              addresses, per RFC 2373, section 2.5.4, should be formatted that way to ensure mixed IPv4/IPv6
           support.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc272> NAME 'dmtfIPSubnet'
        DESC 'a group of related IPProtocolEndpoints that can communicate
           with each other directly using IP.'
        SUP dmtfLogicalNetwork
        MUST (subnetNumber $ subnetMask $ addressType)
      )

2.8 dmtfProtocolEndpoint

   This class represents a group of related dmtfIPProtocolEndpoint
   objects that can communicate with each other directly using IP. It is
   used for describing the characteristics of the grouping.

      ( <oid-at630> NAME 'subnetNumber'
        DESC 'The IP address of the entire subnet, formatted according to
           the appropriate convention as defined
              in the AddressType
           property of standard IPv4 format. However, this class. Note that CIDR format is (the 2.2) version of
              the Network Common Model will not
           supported for this release. explicitly support mixed
              IPv4/IPv6 environments. This is because, without more
           formal methods like constraints, it is possible to create
           different instances of will be added in the same object that have different
           naming formats.' 2.3
              release.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at631> <oid-at624> NAME 'subnetMask' 'cimSubnetMask'
        DESC 'The mask for the starting IP address of the IPSubnet,
              formatted according to the appropriate convention as
              defined in the AddressType property of this class (e.g.,
              "255.255.252.0").'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at632> <oid-at625> NAME 'addressType' 'cimAddressType'
        DESC 'An enumeration that describes the format of the address
              property. Addresses that can be formatted in IPv4 format,
              must be formatted that way to ensure mixed IPv4/IPv6
              support.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc273> <oid-oc275> NAME 'dmtfIPSubnet' 'cim22IPSubnet'
        DESC 'a 'An IPSubnet represents a group of related
              IPProtocolEndpoints that can communicate with each other
              directly using IP.' IP. It is used for describing the
              characteristics of the grouping.'
        SUP dmtfLogicalNetwork
        MUST (subnetNumber cimLogicalNetwork
        MAY (cimSubnetNumber $ subnetMask cimSubnetMask $ addressType) cimAddressType)
      )

2.8 dmtfProtocolEndpoint

3.8 cim22ProtocolEndpoint

   This class represents a communication point from which data may be
   sent or received. Objects of this class link router interfaces and switch
   ports to logical networks.

      ( <oid-oc274> <oid-oc276> NAME 'dmtfProtocolEndpoint' 'cim22ProtocolEndpoint'
        DESC 'a 'A communication point from which data may be sent or
          received.'
              received. ProtocolEndpoints link router interfaces and
              switch ports to LogicalNetworks.'
        SUP dmtfServiceAccessPoint
       MUST (name cim22ServiceAccessPoint
        MAY (cimNameFormat $ nameFormat cimType $ type cimOtherTypeDescription $
             cimSpeed $ cimMaxSpeed)
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22ProtocolEndpoint.

      ( <oid-oc276> NAME 'cim22ProtocolEndpointContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22ProtocolEndpoint'
        AUX (cim22ForwardsAmongAuxClass $ cim22InLogicalNetworkAuxClass $
             cim22ActiveConnectionAuxClass $ cim22BindsToAuxClass $ otherTypeDescription
             cim22ProvidesEndpointAuxClass $ speed cim22CalculatesAmongAuxClass $
          maxSpeed)
             cim22EndpointIdentityAuxClass)
      )

2.9 dmtfForwardsAmongAuxClass

3.9 cim22ForwardsAmongAuxClass

   This auxiliary class represents the dependency that exists between
   protocol endpoints that are used to forward data and the forwarding
   service that is performing the forwarding of data.  In it,
   antecedentRefs point to dmtfProtocolEndpoint objects and
   dependentRefs point to dmtfForwardingService objects.

      ( <oid-oc275> <oid-oc277> NAME 'dmtfForwardsAmongAuxClass' 'cim22ForwardsAmongAuxClass'
        DESC 'represents 'This association represents the dependency that exists
              between the ProtocolEndpoints that are used to forward data
              and the ForwardingService that is performing the forwarding
              of
           data.' data. Attribute cimAntecedentRef points to
              cim22ProtocolEndpoint and attribute cimDependentRef points to
              cim22ForwardingService.'
        SUP dmtfServiceSAPDependencyAuxClass cim22ServiceSAPDependencyAuxClass AUXILIARY
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.10 dmtfLANEndpoint

3.10 cim22LANEndpoint

   This object represents a communication endpoint that, when its
   associated interface device is connected to a LAN, may send and
   receive data frames.  They link switch ports and host interfaces to
   LANs.

      ( <oid-at633> <oid-at626> NAME 'lANID' 'cimLANID'
        DESC 'A label or identifier for the LAN Segment.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at634> <oid-at627> NAME 'lANType' 'cimLANType'
        DESC 'the 'An indication of the kind of technology used on the LAN.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at635> <oid-at628> NAME 'otherLANType' 'cimOtherLANType'
        DESC 'A free-form string that describes the type of technology
              used on the LAN when the value of the LANType property is
              equal to 1 (e.g., "Other"). This provides built-in
              extensibility.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at636> <oid-at629> NAME 'mACAddress' 'cimMACAddress'
        DESC 'The principal unicast address used in communication with
              the LANEndpoint. The MAC address is formatted as twelve
              hexadecimal digits (e.g., "010203040506"with "010203040506"), with each pair
              representing one of the six octets of the MAC address in
           "canonical"according
              "canonical" bit order according to RFC 2469.'
        SYNTAX string{12} SINGLE-VALUE
      )

      ( <oid-at637> <oid-at630> NAME 'aliasLANAddresses' 'cimAliasAddressesstring'
        DESC 'Other unicast addresses that may be used to communicate
              with the LANEndpoint.'
        SYNTAX string
      )

      ( <oid-at638> <oid-at631> NAME 'groupAddresses' 'cimGroupAddresses'
        DESC 'Multicast addresses to which the LANEndpoint listens.'
        SYNTAX string
      )

      ( <oid-oc276> <oid-oc278> NAME 'dmtfLANEndpoint' 'cim22LANEndpoint'
        DESC 'A communication endpoint that, which, when its associated
              interface device is connected to a LAN, may send and
              receive data frames.' frames. LANEndpoints link switch ports and
              host interfaces to LANs. '
        SUP dmtfProtocolEndpoint
        MUST (lANID cim22ProtocolEndpoint
        MAY (cimLANID $ cimLANType $ cimOtherLANType $ lANType cimMACAddress $ otherLANType
             cimAliasAddressesstring $ mACAddress cimGroupAddresses $
           aliasLANAddresses
             cimMaxDataSize)
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22LANEndpoint.

      ( <oid-oc278> NAME 'cim22LANEndpointContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22LANEndpoint'
        AUX (cim22InSegmentAuxClass $ groupAddresses cim22BindsToLANEndpointAuxClass $ maxDataSize)
             cim22SwitchableAuxClass)
      )

2.11 dmtfLANSegment

3.11 cim22LANSegment

   This class represents a collection of LAN Endpoints of a particular
   type that are able to intercommunicate directly without the help of
   bridging or routing services.

      ( <oid-oc277> <oid-oc279> NAME 'dmtfLANSegment' 'cim22LANSegment'
        DESC 'A collection of LAN Endpoints of a particular type that are
              able to intercommunicate directly without the help assistance of
              bridging or routing services.'
        SUP dmtfLogicalNetwork
        MUST (lANID cim22LogicalNetwork
        MAY (cimLANID $ lANType cimLANType $ otherLANType) cimOtherLANType)
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22LANSegment.

      ( <oid-oc279> NAME 'cim22LANSegmentContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22LANSegment'
        AUX (cim22InSegmentAuxClass)
      )

2.12 dmtfInLogicalNetworkAuxClass

3.12 cim22InLogicalNetworkAuxClass

   This auxiliary class defines a protocol endpoint as a member of a
   specific logical network. In it, collectionRef points to a single
   dmtfLogicalNetwork objects and memberRefs point to
   dmtfProtocolEndpoint objects.

      ( <oid-oc278> <oid-oc280> NAME 'dmtfInLogicalNetworkAuxClass' 'cim22InLogicalNetworkAuxClass'
        DESC 'defines 'This association defines a ProtocolEndpoint as a member of
              a specific
           LogicalNetwork.' LogicalNetwork. Attribute cimCollectionRef
              points to cim22LogicalNetwork and attribute cimMemberRef
              points to cim22ProtocolEndpoint.'
        SUP dmtfCollectedMSEsAuxClass cim22CollectedMSEsAuxClass AUXILIARY
        MAY (cimCollectionRef $ cimMemberRef)
      )

2.13 dmtfInSegmentAuxClass

3.13 cim22InSegmentAuxClass

   This auxiliary class defines a LAN endpoint as a member of a specific
   LAN segment.  In it, collectionRef points to a single dmtfLANSegment
   object and memberRefs point to dmtfLANEndpoint objects.

      ( <oid-oc279> <oid-oc281> NAME 'dmtfInSegmentAuxClass' 'cim22InSegmentAuxClass'
        DESC 'Defines a LANEndpoint as a member of a specific
           LANSegment.'
              LANSegment. Attribute cimCollectionRef points to
              cim22LANSegment and attribute cimMemberRef points to
              cim22LANEndpoint.'
        SUP dmtfInLogicalNetworkAuxClass cim22InLogicalNetworkAuxClass AUXILIARY
        MAY (cimCollectionRef $ cimMemberRef)
      )

2.14 dmtfActiveConnectionAuxClass

3.14 cim22ActiveConnectionAuxClass

   This auxiliary class defines a connection that is currently carrying
   traffic between two protocol endpoints.  In it, both antecedentRefs
   and dependentRefs point to dmtfProtocolEndpoint objects.

      ( <oid-at639> <oid-at632> NAME 'trafficType' 'cimTrafficType'
        DESC 'The type of traffic that is carried over this connection.' connection'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at640> <oid-at633> NAME 'otherTrafficDescription' 'cimOtherTrafficDescription'
        DESC 'A string describing the type of traffic that is being
              carried over this instance when its Type property is set to
              1 (e.g., "Other"). The format of the string inserted in
              this property should be similar in format to the values
              defined for the Type property. This property should be set
              to NULL when the Type property is any value other than 1.'
        SYNTAX string{64} SINGLE-VALUE
      )

      ( <oid-at641> <oid-at634> NAME 'isUnidirectional' 'cimIsUnidirectional'
        DESC 'TRUE means that this connection is uni-directional; FALSE
              means that this connection is bi-directional.'
        SYNTAX boolean SINGLE-VALUE
      )

      ( <oid-oc280> <oid-oc282> NAME 'dmtfActiveConnectionAuxClass' 'cim22ActiveConnectionAuxClass'
        DESC 'defines 'This association defines a connection that is currently
              carrying traffic between two ProtocolEndpoints.' ProtocolEndpoints. Both
              reference attributes point to cim22ProtocolEndpoint objects.'
        SUP dmtfSAPSAPDependencyAuxClass cim22SAPSAPDependencyAuxClass AUXILIARY
        MUST (trafficType
        MAY (cimAntecedentRef $ cimDependentRef $ otherTrafficDescription cimTrafficType $ uni-directional
             cimOtherTrafficDescription $
           isUnidirectional) cimIsUnidirectional)
      )

2.15 dmtfIPAddressRange

3.15 cim22IPAddressRange

   This class represents a grouping of specific addresses, and provides
   additional semantics for this group if appropriate.

      ( <oid-at642> <oid-at635> NAME 'startAddress' 'cimStartAddress'
        DESC 'The starting IP address of the AddressRange, formatted
              according to the appropriate convention as defined in the
              AddressType property of this class' class (e.g., "171.79.6.40").'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at643> <oid-at636> NAME 'endAddress' 'cimEndAddress'
        DESC 'The ending IP address of the AddressRange, formatted
              according to the appropriate convention as defined in the
              AddressType property of this class' class (e.g., "171.79.6.40").'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at644> <oid-at637> NAME 'typeOfAddress' 'cimTypeOfAddress'
        DESC 'An enumeration that defines how to format the address and
           maskof
              mask of the address range that defines this IPSubnet).
           Whenever
              IPSubnet).Whenever possible, IPv4-compatible addresses
              should be used instead of IPv6 addresses (see RFC 2373,
              section 2.5.4). In order to have a consistent format for
              IPv4 addresses in a mixed IPv4/v6 environment, all IPv4
              addresses and both IPv4-compatible IPv6 addresses and
              IPv4-mapped IPv6 addresses, per RFC 2373, section 2.5.4,
              should be formatted in standard IPv4 format. However, this
              (the 2.2) version of the Network Common Model will not
              explicitly support mixed IPv4/IPv6 environments. This will
              be added in the 2.3 release.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at645> <oid-at638> NAME 'allocationRegion' 'cimAllocationRegion'
        DESC 'This attribute defines the region that addresses can be
              allocated to.'
        SYNTAX integer SINGLE-VALUE
      )
      ( <oid-oc281> <oid-oc283> NAME 'dmtfIPAddressRange' 'cim22IPAddressRange'
        DESC 'represents 'This represents a grouping of specific addresses, and
              provides additional semantics for this group if appropriate.'
        SUP dmtfCollectionOfMSEs cim22CollectionOfMSEs ABSTRACT
        MUST (startAddress
        MAY (cimStartAddress $ endAddress cimEndAddress $ typeOfAddress cimTypeOfAddress $
           allocationRegion)
             cimAllocationRegion)
      )

2.16 dmtfIPProtocolEndpoint

3.16 cim22IPProtocolEndpoint

   This class represents a protocol endpoint that is dedicated to
   running IP.

      ( <oid-at646> <oid-at639> NAME 'iPVersionSupport' 'cimIPVersionSupport'
        DESC 'It is not possible to tell from the address alone if a
              given IPProtocolEndpoint can support IPv4 and IPv6, or just
              one of these. This property explicitly defines the support
              for different versions of IP that this IPProtocolEndpoint
              has. More implementation experience is needed in order to
              correctly model mixed IPv4/IPv6 networks; therefore, this
              version (2.2) of the Network Common Model will not support
              mixed IPv4/IPv6 environments. This will be looked at more
              in the 2.3 version.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc282> <oid-oc284> NAME 'dmtfIPProtocolEndpoint' 'cim22IPProtocolEndpoint'
        DESC 'A ProtocolEndpoint that is dedicated to running IP.'
        SUP dmtfProtocolEndpoint
        MUST (address cim22ProtocolEndpoint
        MAY (cimAddress $ subnetMask cimSubnetMask $ addressType cimAddressType $ networks $
           iPVersionSupport)
             cimIPVersionSupport)
      )

2.17 dmtfBGPProtocolEndpoint

3.17 cim22BGPProtocolEndpoint

   This class represents a protocol endpoint that is dedicated to
   running BGP.

      ( <oid-at647> <oid-at640> NAME 'isEBGP' 'cimIsEBGP'
        DESC 'A boolean that, when TRUE, signifies that this is an
              instance of the external version of BGP (FALSE is the
              internal version).'
        SYNTAX boolean SINGLE-VALUE
      )

      ( <oid-at648> <oid-at641> NAME 'isEBGPMultihop' 'cimIsEBGPMultihop'
        DESC 'Normally, two routers running EBGP must be physically
              connected. This boolean, when TRUE, denotes a LOGICAL
              connection between two routers that are running EBGP (e.g.,
              there is an intermediate router or interface between them.'
        SYNTAX boolean SINGLE-VALUE
      )

      ( <oid-at649> <oid-at642> NAME 'localIdentifier' 'cimLocalIdentifier'
        DESC 'This is the unique identifier of the local BGP router. This
              is often the router ID (e.g., an IP address).'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at650> <oid-at643> NAME 'peerIdentifier' 'cimPeerIdentifier'
        DESC 'This is the unique identifier of the peer BGP router. This
              is often the router ID (e.g., an IP address).'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at651> <oid-at644> NAME 'state' 'cimState'
        DESC 'This defines the current connection state of the BGP Peer.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at652> <oid-at645> NAME 'adminStatus' 'cimAdminStatus'
        DESC 'This defines the desired state of the BGP connection.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at653> <oid-at646> NAME 'negotiatedVersion' 'cimNegotiatedVersion'
        DESC 'This defines the negotiated version of BGP that is running
              between the two peers.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at654> <oid-at647> NAME 'localAddress' 'cimLocalAddress'
        DESC 'This is the local IP address of this router's BGP
              connection.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at655> <oid-at648> NAME 'localPort' 'cimLocalPort'
        DESC 'This is the local port number for the TCP connection of
              this router's BGP connection.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at656> <oid-at649> NAME 'remoteAddress' 'cimRemoteAddress'
        DESC 'This is the remote IP address of this router's BGP
              connection.'

        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at657> <oid-at650> NAME 'remotePort' 'cimRemotePort'
        DESC 'This is the remote port number for the TCP connection of
              this router's BGP connection.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at658> <oid-at651> NAME 'remoteAS' 'cimRemoteAS'
        DESC 'This is the remote AS number for this router's BGP
              connection.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at659> <oid-at652> NAME 'holdTime' 'cimHoldTime'
        DESC 'This defines the maximum amount of time in seconds that may
              elapse between the receipt of successive KEEPALIVE or
              UPDATE messages. This is instrumented as a counter that
              increments from zero to the value specified in this
              property. The value of this property is calculated by this
              BGP speaker by using the smaller of the values of
              bgpPeerHoldTimeConfigured and the Hold Time received in the
              OPEN message. This value, if not zero seconds, must be at
              least three seconds, up to a maximum of 65535
              seconds. Receipt of either a KEEPALIVE or an UPDATE message
              resets this value.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at660> <oid-at667> NAME 'keepAlive' 'cimKeepAlive'
        DESC 'This defines the time interval in seconds for the KeepAlive
              timer established with the peer. The value of this property
              is calculated by this speaker such that, when compared with
              the HoldTime property, it has the same proportion as the
              KeepAliveConfigured property has with the
              HoldTimeConfigured property. A value of 0 shows indicates that
              the KeepAlive timer has not yet been established. The
              maximum value of this property is 21845 seconds.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc283> <oid-oc285> NAME 'dmtfBGPProtocolEndpoint' 'cim22BGPProtocolEndpoint'
        DESC 'A ProtocolEndpoint that is dedicated to running BGP.'
        SUP dmtfProtocolEndpoint
        MUST (isEBGP cim22ProtocolEndpoint
        MAY (cimIsEBGP $ isEBGPMultihop cimIsEBGPMultihop $ localIdentifier cimLocalIdentifier $
           peerIdentifier
             cimPeerIdentifier $ state cimState $ adminStatus cimAdminStatus $ negotiatedVersion
             cimNegotiatedVersion $
           localAddress cimLocalAddress $ localPort cimLocalPort $ remoteAddress
             cimRemoteAddress $ remotePort cimRemotePort $
           remoteAS cimRemoteAS $ holdTime
             cimHoldTime $ cimKeepAlive)
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22BGPProtocolEndpoint.

      ( <oid-oc284> NAME 'cim22BGPProtocolEndpointContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22BGPProtocolEndpoint'
        AUX (cim22RoutesBGPAuxClass $ keepAlive) cim22ASBGPEndpointsAuxClass)
      )

2.18 dmtfIPXProtocolEndpoint

3.18 cim22IPXProtocolEndpoint

   This class represents an IPX communication point from which data may
   be sent or received.

      ( <oid-oc284> <oid-oc286> NAME 'dmtfIPXProtocolEndpoint' 'cim22IPXProtocolEndpoint'
        DESC 'An IPX communication point from which data may be sent or
              received.'
        SUP dmtfProtocolEndpoint
        MUST (address) cim22ProtocolEndpoint
        MAY (cimAddress)
      )

2.19 dmtfIPXNetwork

3.19 cim22IPXNetwork

   This class represents a network or subnet that uses the IPX protocol'

      ( <oid-at661> <oid-at654> NAME 'networkNumber' 'cimNetworkNumber'
        DESC 'An IPX network number formatted as eight hexadecimal digits
              (e.g., "00112233".' "00112233").'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-oc285> <oid-oc287> NAME 'dmtfIPXNetwork' 'cim22IPXNetwork'
        DESC 'A network or subnet that uses the IPX protocol'
        SUP dmtfLogicalNetwork
        MUST (networkNumber) cim22LogicalNetwork
        MAY (cimNetworkNumber)
      )

2.20 dmtfIPRoute

3.20 cim22IPRoute

   This class relates a remote IP address (destination) to a local IP
   address (source) through which the remote address may be reached. The
   local and remote addresses may be either specific IP endpoints or IP
   subnets. This class may used to represent a generic routing table
   entry.

      ( <oid-at662> <oid-at655> NAME 'cimServiceCreationClassName'
        DESC 'The scoping Service's CreationClassName.'
        SYNTAX string{256} SINGLE-VALUE
      )

      ( <oid-at656> NAME 'iPDestinationAddress' 'cimServiceName'
        DESC 'The scoping Service's Name.'
        SYNTAX string{256} SINGLE-VALUE
      )

      ( <oid-at657> NAME 'cimIPDestinationAddress'
        DESC 'The IP address that which serves as the destination of the
              traffic, formatted according to the appropriate convention
              as defined in the AddressType property of this class.  May
           be used as an RDN.' class.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at663> <oid-at658> NAME 'iPDestinationMask' 'cimIPDestinationMask'
        DESC 'The mask for the destination IP address, formatted
              according to the appropriate convention as defined in the
              AddressType property of this class.  May be used as an RDN.' class.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at664> <oid-at659> NAME 'nextHop' 'cimNextHop'
        DESC 'This contains either the address of the directly connected
              interface of the next-hop router or the address of the
              interface to which the destination is connected to.  May be
           used as an RDN.' to.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at665> <oid-at660> NAME 'isStatic' 'cimIsStatic'
        DESC 'TRUE shows indicates that this ProtocolEndpoint represents a
              static route, and FALSE means that it represents a
              dynamically-learned route.'
        SYNTAX boolean SINGLE-VALUE
      )

      ( <oid-at666> NAME 'adminDistance'
        DESC 'This property contains the current administrative distance
           of this route. Note that the AdministrativeDistance class
           contains the default values, not the current values, of
           administrative distances that are to be used with routes.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at667> NAME 'pathMetric'
        DESC 'This contains an integer that provides an indication to
           the preference of this route compared to other routes that
           reach the same destination.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc286> <oid-oc288> NAME 'dmtfIPRoute' 'cim22IPRoute'
        DESC 'relates 'An IPRoute relates a remote IP address (destination) to a
              local IP address (source) through which the remote address
              may be
           reached.' reached. The local and remote addresses may be
              either specific IP endpoints or IP subnets. This class may
              used to represent a generic routing table entry.'
        SUP dmtfLogicalElement ABSTRACT cim22LogicalElement
        MUST (systemCreationClassName (cimSystemCreationClassName $ systemName cimSystemName $
           serviceCreationClassName
              cimServiceCreationClassName $ serviceName cimServiceName $ creationClassName
              cimCreationClassName $
           iPDestinationAddress cimIPDestinationAddress $ iPDestinationMask
              cimIPDestinationMask $ nextHop cimNextHop $
           addressType $ isStatic $ adminDistance $ pathMetric) cimAddressType)
        MAY (cimIsStatic)
      )

   Although there are a variety of attributes that may be used as RDNs
   for this class, the following structural rules are recommended:

      ( 38 <oid-nf57> NAME 'dmtfIPRouteStructureRule1'
        FORM dmtfIPRouteNameForm1
        SUP 5 6
      )

      ( <oid-nf38>  NAME 'dmtfIPRouteNameForm1' 'cim22IPRouteNameForm'
        OC dmtfIPRoute cim22IPRoute
        MUST (name) (orderedCimModelPath)
      )

      ( 39 <sr57> NAME 'dmtfIPRouteStructureRule2' 'cim22IPRouteStructureRule'
        FORM dmtfIPRouteNameForm2 cim22IPRouteNameForm
        SUP 5 6 <sr55>
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22IPRoute.

      ( <oid-nf39> <oid-oc288> NAME 'dmtfIPRouteNameForm2'
        OC dmtfIPRoute
        MUST (ipDestinationAddress) 'cim22IPRouteContentRule'
        DESC 'The auxiliary classes that may be attached to cim22IPRoute'
        AUX (cim22CalculatedRoutesAuxClass $
             cim22LogicalIdentityAuxClass $ cim22CollectedMSEsAuxClass $
             cim22ElementConfigurationAuxClass $
             cim22ElementSettingAuxClass $ cim22DependencyAuxClass $
             cim22ProvidesServiceToElementAuxClass $
             cim22ComponentAuxClass $ cim22SystemComponentAuxClass $
             cim22ActsAsSpareAuxClass)
   )
      )

2.21 dmtfBindsToAuxClass

3.21 cim22BindsToAuxClass

   This auxiliary class establishes a protocol endpoint on one system as
   a requestor of protocol services from another protocol endpoint on
   the same system. This binding establishes a layering of two
   protocols, the upper layer represented by dependentRefs (pointing to
   dmtfProtocolEndpoint objects) and the lower layer represented by
   antecedentRef (pointing to dmtfServiceAccessPoint objects).

      ( <oid-oc287> <oid-oc289> NAME 'dmtfBindsToAuxClass' 'cim22BindsToAuxClass'
        DESC 'establishes 'This association establishes a ProtocolEndpoint on one
              system as a requestor of protocol services from another
              ProtocolEndpoint on the same system.' system. This binding
              establishes a layering of two protocols, the upper layer
              represented by the Dependent (a cim22ProtocolEndpoint)  and
              the lower layer represented by the Antecedent (a
              cim22ServiceAccessPoint).'
        SUP dmtfSAPSAPDependencyAuxClass cim22SAPSAPDependencyAuxClass AUXILIARY
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.22 dmtfBindsToLANEdpointAuxClass

3.22 cim22BindsToLANEdpointAuxClass

   This auxiliary class makes explicit the dependency of a protocol
   endpoint on some lower layer protocol endpoint on the same system. In
   it, antecedentRefs point to dmtfLANEndpoint objects.

      ( <oid-at668> <oid-at661> NAME 'frameType' 'cimFrameType'
        DESC 'This describes the framing method for the upper layer
              protocol endpoint that is bound to a LANEndpoint. Note:
           "Raw802.3"only
              "Raw802.3" is only known to be used with the IPX protocol.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc288> <oid-oc290> NAME 'dmtfBindsToLANEndpointAuxClass' 'cim22BindsToLANEndpointAuxClass'
        DESC 'makes 'This association makes explicit the dependency of a
              ProtocolEndpoint on some lower layer ProtocolEndpoint on
              the same system.' system. Attribute cimAntecedentRef points to
              cim22LANEndpoint and cimDependentRef points to
              cim22ProtocolEndpoint.'
        SUP dmtfBindsToAuxClass cim22BindsToAuxClass AUXILIARY
        MUST (frameType)
        MAY (cimAntecedentRef $ cimDependentRef $ cimFrameType)
      )

2.23 dmtfBGPIPRoute

3.23 cim22BGPIPRoute

   This class describes a BGP routing entry that connects two peer
   routers that are running BGP. The source and destination addresses may
   be either specific IP endpoints or IP subnets.

      ( <oid-at669> <oid-at662> NAME 'isBackDoorRoute' 'cimIsBackDoorRoute'
        DESC 'Usually, the administrative distance determines is used to determine
              which route gets installed in the routing table. Using this
              scheme, routes learned via EBGP will win over routes
              learned via an IGP. If this is not desired, then this
              assigns the administrative distance of this route to be
              equal to that of a local route, which means that the same
              route learned by an IGP will have a lower administrative
              distance and be installed instead.'
        SYNTAX boolean SINGLE-VALUE
      )

      ( <oid-at670> <oid-at663> NAME 'usesLoopbackPeering' 'cimUsesLoopbackPeering'
        DESC 'Loopback interfaces are often used by IBGP peers, because
              they eliminate a dependency that would otherwise occur if
              the actual IP address of a physical interface was used to
              configure BGP. The loopback interface instead instructs the
              router to use any available interface.'
        SYNTAX boolean SINGLE-VALUE
      )
      ( <oid-oc289> <oid-oc291> NAME 'dmtfBGPIPRoute' 'cim22BGPIPRoute'
        DESC 'describes 'BGPIPRoute describes a BGP routing entry that connects two
              peer routers that are running BGP.' BGP. The source and
              destination addresses may be either specific IP endpoints
              or IP subnets.'
        SUP dmtfIPRoute
        MUST (isBackDoorRoute cim22IPRoute
        MAY (cimIsBackDoorRoute $ usesLoopbackPeering) cimUsesLoopbackPeering)
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22BGPIPRoute.

      ( <oid-oc291> NAME 'cim22BGPIPRouteContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22BGPIPRoute'
        AUX (cim22RoutesBGPAuxClass)
      )

2.24 dmtfRoutesBGPAuxClass

3.24 cim22RoutesBGPAuxClass

   This auxiliary class defines a BGP route, and makes explicit the
   dependency between a BGPIPRoute and a BGPProtocolEndpoint.  In it,
   antecedentRefs point to at most two dmtfBGPProtocolEndpoint objects
   and dependentRef must point to a dmtfBGPIPRoute object.

      ( <oid-oc290> <oid-oc292> NAME 'dmtfRoutesBGPAuxClass' 'cim22RoutesBGPAuxClass'
        DESC 'This association defines a BGP route, and makes explicit
              the dependency between a BGPIPRoute and a
           BGPProtocolEndpoint.'
              BGPProtocolEndpoint. Attribute cimAntecedentRef points to
              cim22BGPProtocolEndpoint and attribute cimDependentRef points
              to cim22BGPIPRoute.'
        SUP dmtfDependencyAuxClass cim22DependencyAuxClass AUXILIARY
        MUST (dependentRef)
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.25 dmtfBGPCluster

3.25 cim22BGPCluster

   BGP speakers in an AS are required to be fully meshed. This can lead
   to a huge number of TCP connections per router. One way to reduce the
   peering requirements is to use a route reflector. This is based on
   specifying one or more routers to act as focal points for IBGP
   sessions. The route reflector as a whole is called a cluster. It is
   logically divided into three types of routers: reflectors, clients of
   the route reflector(s), and non-clients of the route reflector. An AS
   can have more than one route reflector. There can be more than one
   route reflector in a cluster, and there can be more than one cluster
   in an AS.

      ( <oid-at671> <oid-at664> NAME 'clusterID' 'cimClusterID'
        DESC 'If a cluster has more than one route reflector, all of the
              route reflectors in the cluster need to be configured with
              a 4-byte cluster ID. This allows route reflectors to
              recognize updates from other route reflectors in the same
           cluster.  May be used as an RDN.'
              cluster.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc291> <oid-oc293> NAME 'dmtfBGPCluster' 'cim22BGPCluster'
        DESC 'a 'The BGP speakers in an AS are required to be fully
              meshed. This can lead to a huge number of TCP connections
              per router. One way to reduce the peering requirements is
              to use a route reflector. This is based on specifying one
              or more routers to act as focal points for IBGP
              sessions. The route reflector as a whole is called a cluster and
              cluster. It is logically divided into three types of routers'
              routers: reflectors, clients of the route reflector(s), and
              non-clients of the route reflector. An AS can have more
              than one route reflector. There can be more than one route
              reflector in a cluster, and there can be more than one
              cluster in an AS.'
        SUP dmtfCollectionOfMSEs cim22CollectionOfMSEs
        MUST (clusterID) (cimClusterID $ orderedCimModelPath)
      )

2.26 dmtfRoutersInBGPClusterAuxClass

      ( <oid-nf58> NAME 'cim22BGPClusterNameForm'
        OC cim22BGPCluster
        MUST (orderedCimModelPath)
      )

      ( <sr58> NAME 'cim22BGPClusterStructureRule'
        FORM cim22BGPClusterNameForm
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22BGPCluster.

      ( <oid-oc293> NAME 'cim22BGPClusterContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22BGPCluster'
        AUX (cim22RoutersInBGPClusterAuxClass $
             cim22BGPClustersInASAuxClass $
             cim22ReflectorServiceAuxClass $
cim22ReflectorClientServiceAuxClass $
             cim22ReflectorNonClientServiceAuxClass $
             cim22CollectedMSEsAuxClass $
             cim22CollectedCollectionsAuxClass $
             cim22CollectionConfigurationAuxClass $
             cim22CollectionSettingAuxClass)
      )

3.26 cim22RoutersInBGPClusterAuxClass

   This auxiliary class establishes 'whole-part' relationships between a
   BGP cluster and the computer systems (e.g., the routers) that it
   contains. At least three routers are required to form a cluster - a
   reflector and two clients. In addition, the routers that form a
   cluster share common configuration information, and are commonly
   administered.  In this class, collectionRef points to a
   dmtfBGPCluster object and memberRefs to at least three
   dmtfComputerSystem objects.

      ( <oid-oc292> <oid-oc294> NAME 'dmtfRoutersInBGPClusterAuxClass' 'cim22RoutersInBGPClusterAuxClass'
        DESC 'establishes whole-part 'This aggregation establishes "whole-part" relationships
              between a BGPCluster and the ComputerSystems (e.g., the
              routers) that it
           contains.' contains. At least three routers are
              required to form a cluster - a reflector and two
              clients. In addition, the routers that form a cluster share
              common configuration information, and are commonly
              administered. Attribute cimCollectionRef points to
              cim22BGPCluster and attribute cimMemberRef points to
              cim22ComputerSystem.'
        SUP dmtfCollectedMSEsAuxClass cim22CollectedMSEsAuxClass AUXILIARY
        MAY (cimCollectionRef $ cimMemberRef)
      )

2.27 dmtfBGPClustersInASAuxClass

3.27 cim22BGPClustersInASAuxClass

   This auxiliary class 'whole-part' relationships between an autonomous
   system and the BGP clusters that it contains. In addition, the
   routers that form a cluster share common configuration information,
   and are commonly administered.

      ( <oid-at672> <oid-at665> NAME 'groupASRef' 'cimGroupASRef'
        DESC 'The AutonomousSystem that aggregates the Clusters belonging
              to it and administers them.'
        SYNTAX DN SINGLE-VALUE
      )

      ( <oid-at673> <oid-at666> NAME 'partASRefs' 'cimPartASRef'
        DESC 'The Clusters that are contained in the AS.'
        SYNTAX DN
      )

      ( <oid-oc293> <oid-oc295> NAME 'dmtfBGPClustersInASAuxClass' 'cim22BGPClustersInASAuxClass'
        DESC 'establishes whole-part 'This aggregation establishes "whole-part" relationships
              between an AutonomousSystem and the BGPClusters that it contains' In
              addition, the routers that form a cluster share common
              configuration information, and are commonly
              administered. Attribute cimGroupASRef points to
              cim22AutonomousSystem and attribute cimPartASRef points to
              cim22BGPCluster.'
        SUP top AUXILIARY
        MUST (groupASRef
        MAY (cimGroupASRef $ partASRefs) cimPartASRef)
      )

2.28 dmtfRoutersInASAuxClass

3.28 cim22RoutersInASAuxClass

   This auxiliary class establishes 'whole-part' relationships between
   an AutonomousSystem and the routers that it contains. In addition,
   the routers in the AS share common configuration information, and are
   commonly administered.  In it, groupComponentRef points to a
   dmtfAutonomousSystem object and partComponentRefs point to
   dmtfComputerSystem objects.

      ( <oid-at674> 'bGPSupportedAttributes' <oid-at667> NAME 'cimBGPSupportedAttributes'
        DESC 'an 'This is an array of strings that contain the BGP attributes
              supported by this router.'
        SYNTAX string
      )

      ( <oid-at675> <oid-at668> NAME 'addCommunityValue' 'cimAddCommunityValue'
        DESC 'TRUE means that the community value of this router is added
              to the existing community value, and FALSE means that the
              community value of this router replaces the existing
              community value.'
        SYNTAX boolean SINGLE-VALUE
      )

      ( <oid-at676> <oid-at669> NAME 'role' 'cimRoleInteger'
        DESC 'This is an enumeration that defines the function, from the
              point of view of BGP, of this router.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at677> <oid-at670> NAME 'otherRoleDescription' 'cimOtherRoleDescription'
        DESC 'A string describing the type of function that this router
              has in its AS when the value of the Role property of this
              class is set to 1 (e.g., "Other"). The format of the string
              inserted in this property should be similar in format to
              the values defined for the Role property. This property
              should be set to NULL when the Role property is any value
              other than 1.'
        SYNTAX string{64} SINGLE-VALUE
      )

      ( <oid-oc294> <oid-oc296> NAME 'dmtfRoutersInASAuxClass' 'cim22RoutersInASAuxClass'
        DESC 'establishes whole-part 'This aggregation establishes "whole-part" relationships
              between an AutonomousSystem and the routers that it contains.'
              contains. In addition, the routers in the AS share common
              configuration information, and are commonly
              administered. Attribute cimGroupComponentRef points to
              cim22AutonomousSystem and attribute cimPartComponentRef
              points to cim22ComputerSystem.'
        SUP dmtfSystemComponentAuxClass cim22SystemComponentAuxClass AUXILIARY
        MUST (bGPSupportedAttributes
        MAY (cimGroupComponentRef $ addCommunityValue cimPartComponentRef $ role
             cimBGPSupportedAttributes $ cimAddCommunityValue $
           otherRoleDescription)
             cimRoleInteger $ cimOtherRoleDescription)
      )

2.29 dmtfProvidesEndpointAuxClass

3.29 cim22ProvidesEndpointAuxClass

   This auxiliary class shows that a protocol service provides endpoints
   to give access its services.  In it, antecedentRef points to a single
   dmtfNetworkService object and dependentRefs to dmtfProtocolEndpoint
   objects.

      ( <oid-oc295> <oid-oc297> NAME 'dmtfProvidesEndpointAuxClass' 'cim22ProvidesEndpointAuxClass'
        DESC 'a 'A protocol service provides endpoints to give access its
           services.'
              services. Attribute cimAntecedentRef points to
              cim22NetworkService and attribute cimDependentRef points to
              cim22ProtocolEndpoint.'
        SUP dmtfServiceAccessBySAPAuxClass cim22ServiceAccessBySAPAuxClass AUXILIARY
        MUST (antecedentRef)
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.30 dmtfASBGPEndpointsAuxClass

3.30 cim22ASBGPEndpointsAuxClass

   This auxiliary class defines the different router interfaces that are
   running BGP in the autonomous system.  In it, groupComponentRef
   points to a dmtfAutonomousSystem object and partComponentRefs point
   to dmtfBGPProtocolEndpoint objects.

      ( <oid-oc296> <oid-oc298> NAME 'dmtfASBGPEndpointsAuxClass' 'cim22ASBGPEndpointsAuxClass'
        DESC 'defines 'This aggregation defines the different router interfaces
              that are running BGP in the AutonomousSystem.' AutonomousSystem. Attribute
              cimGroupComponentRef points to
              cim22AutonomousSystem and attribute cimPartComponentRef
              points to cim22BGPProtocolEndpoint.'
        SUP dmtfSystemComponentAuxClass cim22SystemComponentAuxClass AUXILIARY
        MAY (cimGroupComponentRef $ cimPartComponentRef)
      )

2.31 dmtfConfederationAuxClass

3.31 cim22ConfederationAuxClass

   The BGP speakers in an AS are required to be fully meshed. This can
   lead to a huge number of TCP connections per router. One way to
   reduce the peering requirements is to use a confederation. A
   confederation effectively partitions one AS into a group of 'sub-
   ASs'. This enables all the benefits of IBGP to be applied inside the
   confederation, while enabling EBGP to be run between each
   confederation. This enables certain BGP attribute values to be
   preserved between confederations. However, to the outside world, the
   AS with its confederations appear to be a single AS.

   In this class, groupComponentRef points to a dmtfAutonomousSystem
   object and partComponentRefs to mulitple dmtfAutonomousSystem
   objects.

      ( <oid-at678> <oid-at671> NAME 'parentASNumber' 'cimParentASNumber'
        DESC 'A unique identifier of the AutonomousSystem that contains
              the confederations.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at679> <oid-at672> NAME 'childASNumber' 'cimChildASNumber'
        DESC 'A unique identifier of the Confederation within the
              AutonomousSystem.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc297> <oid-oc299> NAME 'dmtfConfederationAuxClass' 'cim22ConfederationAuxClass'
        DESC 'a 'The BGP speakers in an AS are required to be fully
              meshed. This can lead to a huge number of TCP connections
              per router. One way to reduce the peering requirements' requirements is
              to use a confederation. A confederation effectively
              partitions one AS into a group of "sub-ASs". This enables
              all of the benefits of IBGP to be applied inside the
              confederation, while enabling EBGP to be run between each
              confederation. This enables certain BGP attribute values to
              be preserved between confederations. However, to the
              outside world, the AS with its confederations appear to be
              a single AS. Both reference attributes point to
              cim22AutonomousSystem objects.'
        SUP dmtfSystemComponentAuxClass cim22SystemComponentAuxClass AUXILIARY
        MUST (parentASNumber
        MAY (cimGroupComponentRef $ cimPartComponentRef $
             cimParentASNumber $ childASNumber) cimChildASNumber)
      )

2.32 dmtfRouteCalculationService

3.32 cim22RouteCalculationService

   This is a base class, derived from dmtfNetworkService, cim22NetworkService, that
   represents the route calculation aspects performed by a router. This
   also include functions performed by the router when it exchanges
   routing information. There are a large variety of additional routing
   protocols that are not listed below that will use this service. These
   will be added when they are modeled.

      ( <oid-at680> <oid-at673> NAME 'routerID' 'cimRouterID'
        DESC 'uniquely 'The RouterID uniquely identifies the router that is
              performing the route calculation. It is the highest IP
              address on the router (or the highest loopback interface,
              if there is one).'
        SYNTAX string SINGLE-VALUE
      )
      ( <oid-at681> <oid-at674> NAME 'typeOfRoutingAlgorithm' 'cimTypeinteger'
        DESC 'This is an enumerated value that defines the routing
              algorithm used that this route calculation is being
              performed for.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc298> <oid-oc300> NAME 'dmtfRouteCalculationService' 'cim22RouteCalculationService'
        DESC 'a 'This is a concrete base class class, derived from
              cim22NetworkService, that represents the route calculation
              aspects performed by a router.' router. This also include functions
              performed by the router when it exchanges routing
              information. There are a large variety of additional
              routing protocols that are not listed below that will use
              this service. These will be added when they are modeled.'
        SUP dmtfNetworkService ABSTRACT
        MUST (routerID cim22NetworkService
        MAY (cimRouterID $ typeOfRoutingAlgorithm) cimTypeinteger)
      )

2.33 dmtfCalculatedRoutesAuxClass

   The following content rule specifies the auxiliary classes that may
   be attached to cim22RouteCalculationService.

      ( <oid-oc300> NAME 'cim22RouteCalculationServiceContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22RouteCalculationService'
        AUX (cim22CalculatedRoutesAuxClass $
             cim22EGPRouteCalcDependencyAuxClass $
             cim22CalculatesAmongAuxClass)
      )

3.33 cim22CalculatedRoutesAuxClass

   This auxiliary class makes explicit the routes that are calculated by
   a specific route calculation service. Thus, every route calculation
   service can have its own unique set of calculated routes.  In it,
   antecedentRef points to a dmtfRouteCalculationService object and
   dependentRefs to dmtfIPRoute objects.

      ( <oid-oc299> <oid-oc301> NAME 'dmtfCalculatedRoutesAuxClass' 'cim22CalculatedRoutesAuxClass'
        DESC 'makes 'This assocation makes explicit the routes that are
              calculated by a specific
           RouteCalculationService.' RouteCalculationService. Thus,
              every RouteCalculationService can have its own unique set
              of calculated routes. Attribute cimAntecedentRef points to
              cim22RouteCalculationService and attribute cimDependentRef
              points to cim22IPRoute.'
        SUP dmtfDependencyAuxClass cim22DependencyAuxClass AUXILIARY
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.34 dmtfEGPRouteCalcDependencyAuxClass

3.34 cim22EGPRouteCalcDependencyAuxClass

   This is a specialization of dmtfServiceServiceDependencyAuxClass, cim22ServiceServiceDependencyAuxClass,
   and captures the dependency that external gateway protocols (such as
   BGP) have on interior gateway protocols (such as OSPF).  In it,
   antecedentRef points to a dmtfRouteCalculationService object and
   dependentRefs to multiple dmtfRouteCalculationService objects.

      ( <oid-at682> <oid-at675> NAME 'iGPInjection' 'cimIGPInjection'
        DESC 'Sometimes it is necessary to inject EGP information, such
              as that from BGP, into IGPs. This attribute defines whether
              this should be done for the two routing protocols that are
           associated
              defined by this class. association. The values below mean that no,
              partial, and full EGP information is injected into the IGP,
              respectively.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc300> <oid-oc302> NAME 'dmtfEGPRouteCalcDependencyAuxClass' 'cim22EGPRouteCalcDependencyAuxClass'
        DESC 'captures 'This is a specialization of cim22ServiceServiceDependency,
              and captures the dependency that external gateway protocols
              (such as BGP) have on interior gateway protocols (such as
           OSPF).'
              OSPF). Both reference attributes point to
              cim22RouteCalculationService objects.'
        SUP dmtfServiceServiceDependencyAuxClass cim22ServiceServiceDependencyAuxClass AUXILIARY
        MUST (iGPInjection)
        MAY (cimAntecedentRef $ cimDependentRef $ cimIGPInjection)
      )

2.35

3.35 cim22BGPService

   This class represents the basic operation of BGP. It is derived from
   dmtfRouteCalculationService,
   cim22RouteCalculationService, the superclass of all routing
   protocols.

      ( <oid-at683> <oid-at676> NAME 'bGPVersion' 'cimBGPVersion'
        DESC 'defines 'The BGPVersion property defines the version of BGP that
              this router is using. This is part of the BGP peer
              negotiation process).'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at684> <oid-at677> NAME 'lastMessageErrorSubCode' 'cimLastMessageErrorSubCode'
        DESC 'This defines the BGP error subcode for message header
              errors. If the ErrorCode property is any other value, then
              this property should be set to NULL.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at685> <oid-at678> NAME 'lastOpenErrorSubCode' 'cimLastOpenErrorSubCode'
        DESC 'This defines the BGP error subcode for OPEN message
              errors. If the ErrorCode property is any other value, then
              this property should be set to NULL.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at686> <oid-at679> NAME 'lastUpdateErrorSubCode' 'cimLastUpdateErrorSubCode'
        DESC 'This defines the BGP error subcode for UPDATE message
              errors. If the ErrorCode property is any other value, then
              this property should be set to NULL.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc301> <oid-oc303> NAME 'dmtfBGPService' 'cim22BGPService'
        DESC 'represents 'This class is used to represent the basic operation of BGP.'
              BGP. It is derived from RouteCalculationService, the
              superclass of all routing protocols.'
        SUP dmtfRouteCalculationService
        MUST (bGPVersion cim22RouteCalculationService
        MAY (cimBGPVersion $ cimLastErrorCode $
             cimLastMessageErrorSubCode $ cimLastOpenErrorSubCode $
             cimLastUpdateErrorSubCode)
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22BGPService.

      ( <oid-oc303> NAME 'cim22BGPServiceContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22BGPService'
        AUX (cim22ReflectorServiceAuxClass $
             cim22ReflectorClientServiceAuxClass $ lastErrorCode
             cim22ReflectorNonClientServiceAuxClass $ lastMessageErrorSubCode
             cim22BGPRoutingPolicyAuxClass $
           lastOpenErrorSubCode
             cim22BGPPeerGroupServiceAuxClass $ lastUpdateErrorSubCode)
cim22BGPAdminDistanceAuxClass)
      )

2.36 dmtfBGPPeerGroup

3.36 cim22BGPPeerGroup

   A BGP Peer Group is a set of BGP neighbors that share the same update
   policies. This enables an administrator to assign policies to the
   peer group, instead of individually. This enables the routers in the
   Peer Group to optimize UPDATE messages. Consequently, Peer Groups
   have a set of restrictions that must be followed to work correctly
   with external BGP peers. Otherwise, loss of routing information could
   occur.

      ( <oid-at687> <oid-at680> NAME 'connectRetryInterval' 'cimConnectRetryInterval'
        DESC 'This defines the time interval, in seconds, for the
              ConnectRetry timer. The suggested value is 120 seconds.'

        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at688> <oid-at681> NAME 'holdTimeConfigured' 'cimHoldTimeConfigured'
        DESC 'This defines the time interval in seconds for the Hold Time
              configured for this BGP speaker with a peer. This value is
              placed in an OPEN message sent to a peer by this BGP
              speaker, and is compared with the Hold Time field in the
              OPEN message received from the peer. This enables this
              speaker to establish a mutually agreeable Hold Time with
              the peer. This value must not be less than three
              seconds. If it is zero, then the Hold Time is NOT to be
              established with the peer. The suggested value for this
              timer is 90 seconds.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at689> <oid-at682> NAME 'keepAliveConfigured' 'cimKeepAliveConfigured'
        DESC 'This defines the time interval in seconds for the KeepAlive
              timer configured for this BGP speaker with a peer. This
              value will determine the frequency of the KEEPALIVE
              messages relative to the value of the HoldTimeConfigured
              property; the actual frequency is specified by the value of
              the KeepAlive property. A reasonable value is one third of
              that of the value of the HoldTimeConfigured property. If it
              is zero, then NO periodic KEEPALIVE messages are sent to
              the peer. The suggested value for this property is 30
              seconds. The maximum value of this property is 21845 seconds.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at690> <oid-at683> NAME 'minASOriginationInterval' 'cimMinASOriginationInterval'
        DESC 'This defines the time interval in seconds for the
              MinASOriginationInterval timer. The suggested value for
              this property is 15 seconds.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at691> <oid-at684> NAME 'minRouteAdvertisementInterval' 'cimMinRouteAdvertisementInterval'
        DESC 'This defines the time interval in seconds for the
              MinRouteAdvertisementInterval timer. The suggested value
              for this property is 30 seconds.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc302> <oid-oc304> NAME 'dmtfBGPPeerGroup' 'cim22BGPPeerGroup'
        DESC 'a 'A BGP Peer Group is a set of BGP neighbors that share the
              same update policies.' policies. This enables an administrator to
              assign policies to the peer group, instead of
              individually. This enables the routers in the Peer Group to
              optimize UPDATE messages. Consequently, Peer Groups have a
              set of restrictions that must be followed in order to work
              correctly with external BGP peers. Otherwise, loss of
              routing information could occur.  A BGPPeerGroup is weak to
              the AutonomousSystem that contains it. Therefore, the keys
              from System must be propagated to it.'
        SUP dmtfCollectionOfMSEs cim22CollectionOfMSEs
        MUST (systemCreationClassName $ systemName (cimSystemCreationClassName $ creationClassName cimSystemName $
           name
              cimCreationClassName $ connectRetryInterval cimName $ holdTimeConfigured orderedCimModelPath)
        MAY (cimConnectRetryInterval $ property cimHoldTimeConfigured $
           keepAliveConfigured
             cimKeepAliveConfigured $ minASOriginationInterval cimMinASOriginationInterval $
           minRouteAdvertisementInterval)
             cimMinRouteAdvertisementInterval)
      )

      ( <oid-nf59> NAME 'cim22BGPPeerGroupNameForm'
        OC cim22BGPPeerGroup
        MUST (orderedCimModelPath)
      )

   The following structural rules are recommended:

      ( 41 <sr59> NAME 'dmtfBGPPeerGroupStructureRule1' 'cim22BGPPeerGroupStructureRule'
        FORM dmtfBGPPeerGroupNameForm1
        SUP 3 4 cim22BGPPeerGroupNameForm
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22BGPPeerGroup.

      ( <oid-nf41> <oid-oc304> NAME 'dmtfBGPPeerGroupNameForm1'
        OC dmtfBGPPeerGroup
        MUST (name) 'cim22BGPPeerGroupContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22BGPPeerGroup'
        AUX (cim22BGPPeerGroupServiceAuxClass $
             cim22BGPPeerUsesRouteMapAuxClass $
             cim22InBGPPeerGroupAuxClass $ cim22CollectedMSEsAuxClass $
             cim22CollectedCollectionsAuxClass $
             cim22CollectionConfigurationAuxClass $
             cim22CollectionSettingAuxClass)
      )

2.37 dmtfReflectorServiceAuxClass

3.37 cim22ReflectorServiceAuxClass

   This auxiliary class acts as the base for defining BGP routing
   policies for the reflector of this Cluster.  In it, antecedentRef
   points to a dmtfBGPCluster object and dependentRefs point to
   dmtfBGPService objects.

      ( <oid-oc303> <oid-oc305> NAME 'dmtfReflectorServiceAuxClass' 'cim22ReflectorServiceAuxClass'
        DESC 'the 'This association will serve as the base class for defining
              BGP routing policies for the reflector of this Cluster.'
              Cluster. Attribute cimAntecedentRef points to cim22BGPCluster
              and attribute cimDependentRef points to cim22BGPService.'
        SUP top AUXILIARY
        MUST (antecedentRef
        MAY (cimAntecedentRef $ dependentRefs) cimDependentRef)
      )

2.38 dmtfReflectorClientServiceAuxClass

3.38 cim22ReflectorClientServiceAuxClass

   This auxiliary class acts as the base for defining BGP routing
   policies for clients of the reflector of this Cluster.  In it,
   antecedentRef points to a dmtfBGPCluster object and dependentRefs
   point to dmtfBGPService objects.

      ( <oid-oc304> <oid-oc306> NAME 'dmtfReflectorClientServiceAuxClass' 'cim22ReflectorClientServiceAuxClass'
        DESC 'the 'This association will serve as the base class for defining
              BGP routing policies for clients of the reflector of this Cluster.'
              Cluster. Attribute cimAntecedentRef points to
              cim22BGPCluster and attribute cimDependentRef points to
              cim22BGPService.'
        SUP top AUXILIARY
        MUST (antecedentRef
        MAY (cimAntecedentRef $ dependentRefs) cimDependentRef)
      )

2.39 dmtfReflectorNonClientServiceAuxClass

3.39 cim22ReflectorNonClientServiceAuxClass

   This auxiliary class acts as the base for defining BGP routing
   policies for non-clients of the reflector of this Cluster.  In it,
   antecedentRef points to a dmtfBGPCluster object and dependentRefs
   point to dmtfBGPService objects.

      ( <oid-oc305> <oid-oc307> NAME 'dmtfReflectorNonClientServiceAuxClass' 'cim22ReflectorNonClientServiceAuxClass'
        DESC 'the 'This association will serve as the base class for defining
              BGP routing policies for the non-clients of the reflector
              of this Cluster.' Cluster. Attribute cimAntecedentRef points to
              cim22BGPCluster attribute cimDependentRef points to
              cim22BGPService.'
        SUP top AUXILIARY
        MUST (antecedentRef
        MAY (cimAntecedentRef $ dependentRefs) cimDependentRef)
      )

2.40 dmtfFilterEntry

3.40 cim22FilterEntry

   This class is used by network devices to identify traffic and either
   forward them (with possibly further processing) to their destination,
   or to deny their forwarding. They are the building block of
   FilterLists. Since a FilterEntry is weak to the network device (e.g.,
   the ComputerSystem) that contains it, DIT structuratl rules are also
   specified.

      ( <oid-at692> <oid-at685> NAME 'matchConditionType' 'cimMatchConditionType'
        DESC 'This specifies one of a set of ways to identify traffic. if
              the value is 1 (e.g., 'Other'), "Other"), then the specific type of
              filtering is specified in the OtherMatchConditionType
              property of this class.'
        SYNTAX integer SINGLE-VALUE

      )

      ( <oid-at693> <oid-at686> NAME 'otherMatchConditionType' 'cimOtherMatchConditionType'
        DESC 'If the value of the MatchConditionType property in this
              class is 1 (e.g., "Other"), then the specific type of
              filtering is specified in this property.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at694> <oid-at687> NAME 'matchConditionValue' 'cimMatchConditionValue'
        DESC 'This is the value of the condition that filters the
              traffic. It corresponds to the condition specified in the
              MatchConditionType property. If, however, the value of the
              MatchConditionProperty is 1, then it corresponds to the
              condition specified in the OtherMatchConditionType
              property.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at695> <oid-at688> NAME 'action' 'cimAction'
        DESC 'This defines whether the action should be to forward or
              deny traffic meeting the match condition specified in this
              filter.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc306> <oid-oc308> NAME 'dmtfFilterEntry' 'cim22FilterEntry'
        DESC 'identify 'A FilterEntry is used by network devices to identify
              traffic and either forward them (with possibly further
              processing) to their destination, or to deny their
           forwarding.'
              forwarding. They are the building block of FilterLists.A
              FilterEntry is weak to the network device (e.g., the
              ComputerSystem) that contains it. Hence, the ComputerSystem
              keys are propagated to this class.'
        SUP dmtfLogicalElement cim22LogicalElement
        MUST (systemCreationClassName $ systemName (cimSystemCreationClassName $ creationClassName cimSystemName $
           name
              cimCreationClassName $ trafficType cimName)
        MAY (cimTrafficType $ matchConditionType cimMatchConditionType $
           otherMatchConditionType
             cimOtherMatchConditionType $ matchConditionValue cimMatchConditionValue $ action)
cimAction)
      )

   The following DIT structural rule is recommended:

      ( 42 <oid-nf60> NAME 'dmtfFilterEntryStructureRule1' 'cim22FilterEntryNameForm'
        OC cim22FilterEntry
        MUST (orderedCimModelPath)
      )

      ( <sr60> NAME 'cim22FilterEntryStructureRule'
        FORM dmtfFilterEntryNameForm1 cim22FilterEntryNameForm
        SUP 24 25 <sr11>
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22FilterEntry.

      ( <oid-nf42> <oid-oc308> NAME 'dmtfFilterEntryNameForm1'
        OC dmtfFilterEntry
        MUST (name) 'cim22FilterEntryContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22FilterEntry'
        AUX (cim22EntriesInFilterListAuxClass $
             cim22LogicalIdentityAuxClass $ cim22CollectedMSEsAuxClass $
             cim22ElementConfigurationAuxClass $
             cim22ElementSettingAuxClass $ cim22DependencyAuxClass $
             cim22ProvidesServiceToElementAuxClass $
             cim22ComponentAuxClass $ cim22SystemComponentAuxClass $
             cim22ActsAsSpareAuxClass)
      )

2.41 dmtfFilterList

3.41 cim22FilterList

   This class is used by network devices to identify routes by
   aggregating a set of FilterEntries into a unit, called a FilterList.
   FilterLists can also be used to accept or deny routing updates. Since
   a FilterList is weak to the network device (e.g., the ComputerSystem)
   that contains it, DIT structural rules are also specified.'

      ( <oid-oc307> <oid-oc309> NAME 'dmtfFilterList' 'cim22FilterList'
        DESC 'A FilterList is used by network devices to identify routes
              by aggregating a set of FilterEntries into a unit, called a
           FilterList.'
              FilterList. FilterLists can also be used to accept or deny
              routing updates.  A FilterList is weak to the network device
              (e.g., the ComputerSystem) that contains it. Hence, the
              ComputerSystem keys are propagated to this class.'
        SUP dmtfLogicalElement cim22LogicalElement
        MUST (systemCreationClassName (cimSystemCreationClassName $ systemName cimSystemName $ creationClassName
              cimCreationClassName $
           name $ direction) cimName)
        MAY (cimDirection)
      )

   The following structural rule is recommended:

      ( 43 <oid-nf61> NAME 'dmtfFilterListStructureRule1' 'cim22FilterListNameForm'
        OC cim22FilterList
        MUST (orderedCimModelPath)
      )

      ( <sr61> NAME 'cim22FilterListStructureRule'
        FORM dmtfFilterListNameForm1 cim22FilterListNameForm
        SUP 24 25 <sr11>
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22FilterList.

      ( <oid-nf43> <oid-oc309> NAME 'dmtfFilterListNameForm1'
        OC dmtfFilterList
        MUST (name) 'cim22FilterListContentRule'
        DESC 'The auxiliary classes that may be attached to cim22FilterList'
        AUX (cim22EntriesInFilterListAuxClass $
             cim22ListsInRoutingPolicyAuxClass $
             cim22FilterListsInBGPRouteMapAuxClass $
             cim22LogicalIdentityAuxClass $ cim22CollectedMSEsAuxClass $
             cim22ElementConfigurationAuxClass $
             cim22ElementSettingAuxClass $ cim22DependencyAuxClass $
             cim22ProvidesServiceToElementAuxClass $
             cim22ComponentAuxClass $ cim22SystemComponentAuxClass $
             cim22ActsAsSpareAuxClass)
      )

2.42 dmtfRoutingPolicy

3.42 cim22RoutingPolicy

   This class implements routing policies. It aggregates a set of
   FilterLists, along with other appropriate constructs, into a unit. A
   most important use of this class is to change the routing policy by
   changing values of various BGP attributes in a consistent manner.
   Since a RoutingPolicy is weak to the network device (e.g., the
   ComputerSystem) that contains it, DIT structural rules are also
   specified.

      ( <oid-at696> <oid-at689> NAME 'bGPAction' 'cimBGPAction'
        DESC 'This defines one or more BGP attributes that should beused be used
              to change modify this routing update.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at697> <oid-at690> NAME 'bGPValue' 'cimBGPValue'
        DESC 'The value for the corresponding BGPAction.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at698> <oid-at691> NAME 'remarkAction' 'cimRemarkAction'
        DESC 'This defines a remarking action for this traffic.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at699> <oid-at692> NAME 'remarkValue' 'cimRemarkValue'
        DESC 'The value for the corresponding RemarkAction.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at700> <oid-at693> NAME 'conditioningAction' 'cimConditioningAction'
        DESC 'This defines other actions to be taken for this traffic.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at701> <oid-at694> NAME 'otherConditioningAction' 'cimOtherConditioningAction'
        DESC 'If the value of the ConditioningAction property of this
              class is 1, this contains an application-specific type of
              conditioning that is to be performed. Otherwise, if the
              ConditioningAction property is any other value, the value
              of this property should be NULL.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at702> <oid-at695> NAME 'conditioningValue' 'cimConditioningValue'
        DESC 'The value for the corresponding ConditioningAction.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at703> <oid-at696> NAME 'attributeAction' 'cimAttributeAction'
        DESC 'This controls whether BGP attribute values replace, get
              prepended, or get appended to their existing values.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc308> <oid-oc310> NAME 'dmtfRoutingPolicy' 'cim22RoutingPolicy'
        DESC 'used 'This class is used to implement routing policies.' policies. It
              aggregates a set of FilterLists, along with other
              appropriate constructs, into a unit. One of the most
              important uses of this class is to change the routing
              policy by changing values of various BGP attributes in a
              consistent manner.  A RoutingPolicy is weak to the network
              device (e.g., the ComputerSystem) that contains it. Hence,
              the ComputerSystem keys are propagated to this class.'
        SUP dmtfLogicalElement cim22LogicalElement
        MUST (systemCreationClassName (cimSystemCreationClassName $ systemName cimSystemName $ creationClassName
              cimCreationClassName $
           name cimName)
        MAY (cimDescription $ description cimAction $ action cimBGPAction $ bGPAction cimBGPValue $ bGPValue
             cimRemarkAction $
           remarkAction cimRemarkValue $ remarkValue cimConditioningAction $ conditioningAction
             cimOtherConditioningAction $
           otherConditioningAction cimConditioningValue $ conditioningValue $
           attributeAction)
             cimAttributeAction)
      )

   The following structural rule is recommended:

      ( 44 <oid-nf62> NAME 'dmtfRoutingPolicyStructureRule1' 'cim22RoutingPolicyNameForm'
        OC cim22RoutingPolicy
        MUST (orderedCimModelPath)
      )

      ( <sr62> NAME 'cim22RoutingPolicyStructureRule'
        FORM dmtfRoutingPolicyNameForm1 cim22RoutingPolicyNameForm
        SUP 24 25 <sr11>
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22RoutingPolicy.

      ( <oid-nf44> <oid-oc310> NAME 'dmtfRoutingPolicyNameForm1'
        OC dmtfRoutingPolicy
        MUST (name) 'cim22RoutingPolicyContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22RoutingPolicy'
        AUX (cim22ListsInRoutingPolicyAuxClass $
             cim22BGPRoutingPolicyAuxClass $
             cim22BGPRouteMapsInRoutingPolicyAuxClass $
             cim22FilteredBGPAttributesAuxClass $
             cim22LogicalIdentityAuxClass $ cim22CollectedMSEsAuxClass $
             cim22ElementConfigurationAuxClass $
             cim22ElementSettingAuxClass $ cim22DependencyAuxClass $
             cim22ProvidesServiceToElementAuxClass $
             cim22ComponentAuxClass $ cim22SystemComponentAuxClass $
             cim22ActsAsSpareAuxClass)
      )

2.43 dmtfEntriesInFilterListAuxClass

3.43 cim22EntriesInFilterListAuxClass

   This is a specialization of dmtfComponentAuxClass cim22ComponentAuxClass that defines a set
   of filter entries that are aggregated by a particular filter list.
   In it, groupComponentRef points to a dmtfFilterList object and
   partComponentRefs point to dmtfFilterEntry objects.

      ( <oid-at704> <oid-at697> NAME 'sequence' 'cimSequence'
        DESC 'the position of the FilterEntry relative to all other
              entries in the FilterList.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc309> <oid-oc311> NAME 'dmtfEntriesInFilterListAuxClass' 'cim22EntriesInFilterListAuxClass'
        DESC 'a 'This is a specialization of the dmtfComponentAuxClass that cim22Component aggregation
              which is used to define a set of FilterEntries that are
              aggregated by a particular FilterList.' FilterList. Attribute
              cimGroupComponentRef points to cim22FilterList and attribute
              cimPartComponentRef points to cim22FilterEntry.'
        SUP dmtfComponentAuxClass cim22ComponentAuxClass AUXILIARY
        MUST (sequence)
        MAY (cimGroupComponentRef $ cimPartComponentRef $ cimSequence)
      )

2.44 dmtfListsInRoutingPolicyAuxClass

3.44 cim22ListsInRoutingPolicyAuxClass

   This is a specialization of the dmtfComponentAuxClass cim22ComponentAuxClass that defines a
   set of filter lists that are aggregated by a particular routing
   policy.  In it, groupComponentRef point to a dmtfRoutingPolicy object
   and filterComponentRefs point to dmtfFilterList objects

      ( <oid-oc310> <oid-oc312> NAME 'dmtfListsInRoutingPolicyAuxClass' 'cim22ListsInRoutingPolicyAuxClass'
        DESC 'This is a specialization of the dmtfComponentAuxClass cim22Component aggregation that defines
              which is used to define a set of filter lists FilterLists that are
              aggregated by a particular routing policy.' RoutingPolicy. Attribute
              cimGroupComponentRef points to cim22RoutingPolicy and
              attribute cimPartComponentRef points to cim22FilterList.'
        SUP dmtfComponentAuxClass cim22ComponentAuxClass AUXILIARY
        MAY (cimGroupComponentRef $ cimPartComponentRef $ cimSequence)
      )

2.45 dmtfBGPRoutingPolicyAuxClass

3.45 cim22BGPRoutingPolicyAuxClass

   This is a specialization of the dmtfDependencyAuxClass, cim22DependencyAuxClass, and defines
   the relationship between a BGP service and the routing policy that
   control it.  In it, antecedentRefs points to dmtfRoutingPolicy
   objects and dependentRefs, to dmtfBGPService objects.

      ( <oid-oc311> <oid-oc313> NAME 'dmtfBGPRoutingPolicyAuxClass' 'cim22BGPRoutingPolicyAuxClass'
        DESC 'a 'This is a specialization of the dmtfDependencyAuxClass, Dependency association, and
              defines the relationship between a BGP service BGPService and the routing policy
              RoutingPolicy that control it.' it. Attribute cimAntecedentRef
              points to cim22RoutingPolicy and attribute cimDependentRef
              points to cim22BGPService.'
        SUP dmtfDependencyAuxClass cim22DependencyAuxClass AUXILIARY
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.46 dmtfBGPPeerGroupServiceAuxClass

3.46 cim22BGPPeerGroupServiceAuxClass

   This auxiliary class defines the relationship between a BGPService
   and the BGP Peer Group that hosts it.

      ( <oid-oc312> <oid-oc314> NAME 'dmtfBGPPeerGroupServiceAuxClass' 'cim22BGPPeerGroupServiceAuxClass'
        DESC 'defines 'This defines the relationship between a BGPService and the
              BGP Peer Group that hosts it.' it. Attribute cimAntecedentRef
              points to cim22BGPPeerGroup and attribute cimDependentRef
              points to cim22BGPService.'
        SUP top AUXILIARY
        MUST (antecedentRef
        MAY (cimAntecedentRef $ dependentRefs) cimDependentRef)
      )

2.47 dmtfAdministrativeDistance

3.47 cim22AdministrativeDistance

   This class controls the choosing of which protocol to give preference
   over when two protocols learn the same route. This preference
   parameter is called the distance of the protocol. The lower the
   distance, the higher the preference for that protocol. This table
   affects ALL routes. Because this object weak to the AdminDomain that
   contains it, DIT structural rules are included.

      ( <oid-at705> <oid-at698> NAME 'directConnect' 'cimDirectConnect'
        DESC 'The distance for directly connected peers. It has a default
              value of 0.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at706> <oid-at699> NAME 'static' 'cimStatic'
        DESC 'The distance for staticly connected peers. It has a default
              value of 1.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at707> <oid-at700> NAME 'eBGP' 'cimEBGP'
        DESC 'The distance for peers using EBGP. It has a default value
              of 20.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at708> <oid-at701> NAME 'eIGRPInternal' 'cimEIGRPInternal'
        DESC 'The distance for peers using internal EIGRP. It has a
              default value of 90.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at709> <oid-at702> NAME 'iGRP' 'cimIGRP'
        DESC 'The distance for peers using IGRP. It has a default value
              of 100.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at710> <oid-at703> NAME 'oSPF' 'cimOSPF'
        DESC 'The distance for peers using OSPF. It has a default value
              of 110.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at711> <oid-at704> NAME 'iSIS' 'cimISIS'
        DESC 'The distance for peers using ISIS. It has a default value
              of 115.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at712> <oid-at705> NAME 'rIP' 'cimRIP'
        DESC 'The distance for peers using RIP. It has a default value of
              120.'
        SYNTAX integer SINGLE-VALUE
      )
      ( <oid-at713> <oid-at706> NAME 'eGP' 'cimEGP'
        DESC 'The distance for peers using EGP. It has a default value of
              140.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at714> <oid-at707> NAME 'eIGRPExternal' 'cimEIGRPExternal'
        DESC 'The distance for peers using external EIGRP. It has a
              default value of 170.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at715> <oid-at708> NAME 'iBGP' 'cimIBGP'
        DESC 'The distance for peers using IBGP. It has a default value
              of 200.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at716> <oid-at709> NAME 'bGPLocal' 'cimBGPLocal'
        DESC 'The distance for peers using BGP locally. It has a default
              value of 200.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at717> <oid-at710> NAME 'unknown' 'cimUnknown'
        DESC 'The distance for peers using an unknown protocol. It has a
              default value of 255.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc313> <oid-oc315> NAME 'dmtfAdministrativeDistance' 'cim22AdministrativeDistance'
        DESC 'used 'This class is used to control the choosing of which
              protocol to give preference over when two protocols learn
              the same route.' route. This preference parameter is called the
              distance of the protocol. The lower the distance, the
              higher the preference for that protocol. This table affects
              ALL routes. AdministrativeDistance, being a global object,
              is weak to the AdminDomain that contains it. Hence, the
              AdminDomain keys are propagated to this class.'
        SUP dmtfLogicalElement cim22LogicalElement
        MUST (systemCreationClassName (cimSystemCreationClassName $ systemName cimSystemName $ creationClassName
              cimCreationClassName $
           name cimName)
        MAY (cimDirectConnect $ directConnect cimStatic $ static $ eBGP cimEBGP $ eIGRPInternal cimEIGRPInternal $
           iGRP
             cimIGRP $ oSPF cimOSPF $ iSIS cimISIS $ rIP cimRIP $ eGP cimEGP $ eIGRPExternal
             cimEIGRPExternal $ iBGP cimIBGP $
           bGPLocal cimBGPLocal $ unknown) cimUnknown)
      )

      ( <oid-nf64> NAME 'cim22AdministrativeDistanceNameForm'
        OC cim22AdministrativeDistance
        MUST (orderedCimModelPath)
      )

   The following structural rules are recommended:

      ( 45 <sr64> NAME 'dmtfAdministrativeDistanceStructureRule1' 'cim22AdministrativeDistanceStructureRule'
        FORM dmtfAdministrativeDistanceNameForm1 cim22AdministrativeDistanceNameForm
        SUP 3 4 <sr63>
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22AdministrativeDistance.

      ( <oid-nf45> <oid-oc315> NAME 'dmtfAdministrativeDistanceNameForm1'
        OC dmtfAdministrativeDistance
        MUST (name) 'cim22AdministrativeDistanceContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22AdministrativeDistance'
        AUX (cim22BGPAdminDistanceAuxClass $
             cim22LogicalIdentityAuxClass $ cim22CollectedMSEsAuxClass $
             cim22ElementConfigurationAuxClass $
             cim22ElementSettingAuxClass $ cim22DependencyAuxClass $
             cim22ProvidesServiceToElementAuxClass $
             cim22ComponentAuxClass $ cim22SystemComponentAuxClass $
             cim22ActsAsSpareAuxClass)
      )

2.48 dmtfBGPAdminDistanceAuxClass

3.48 cim22BGPAdminDistanceAuxClass

   This is a specialization of dmtfDependencyAuxClass cim22DependencyAuxClass and defines the
   relationship between a BGPService and the Administrative Distances
   that it uses to control the (BGP) routing decisions that it makes.
   In it, antecedentRef points to a dmtfAdministrativeDistance object
   and dependentRefs to dmtfBGPService objects.

      ( <oid-oc314> <oid-oc316> NAME 'dmtfBGPAdminDistanceAuxClass' 'cim22BGPAdminDistanceAuxClass'
        DESC 'defines 'This is a specialization of the Dependency association, and
              defines the relationship between a BGPService and the
              Administrative Distances that it uses to control the (BGP)
              routing decisions that it makes.' makes. Attribute cimAntecedentRef
              points to cim22AdministrativeDistance and attribute
              cimDependentRef points to cim22BGPService.'
        SUP dmtfDependencyAuxClass cim22DependencyAuxClass AUXILIARY
        MUST (antecedentRef)
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.49 dmtfBGPRouteMap

3.49 cim22BGPRouteMap

   A route map controls and changes routing information as well as to
   define when a route is redistributed between routing domains. Route
   maps are placed in router configuration files, and several instances
   of the same route map may be used to implement different actions (see
   accompanying white paper). Route maps may use FilterLists to identify
   the route (again, see the accompanying white paper). This object is
   specific to a given AutonomousSystem that contains it. Hence, DIT
   structural rules are included.

      ( <oid-at718> <oid-at711> NAME 'setMetricType' 'cimSetMetricType'
        DESC 'This defines an additional action to take if the
              MatchCondition is satisfied. This definition is
              specifically limited to BGP filtering for now (e.g., its
              use is limited to setting a BGP attribute to a specific
              value), and will be upgraded in a subsequent release. The
              actual value of the metric is specified in the
              SetMetricValue property.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at719> <oid-at712> NAME 'setMetricValue' 'cimSetMetricValue'
        DESC 'This is the value of the metric that is being set for the
              BGP attribute defined in the SetMetricType property.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-oc315> <oid-oc317> NAME 'dmtfBGPRouteMap' 'cim22BGPRouteMap'
        DESC 'used 'A route map is used to control and change modify routing
              information as well as to define when a route is
              redistributed between routing
           domains.' domains. Route maps are
              placed in router configuration files, and several instances
              of the same route map may be used to implement different
              actions (see accompanying white paper). Route maps may use
              FilterLists to identify the route (again, see the
              accompanying white paper). A BGPRouteMap is specific to a
              given AutonomousSystem that contains it. Hence, the keys of
              the AutonomousSystem are propagated to this class.'
        SUP dmtfLogicalElement cim22LogicalElement
        MUST (systemCreationClassName (cimSystemCreationClassName $ systemName cimSystemName $ creationClassName
              cimCreationClassName $
           name cimName)
        MAY (cimDirection $ direction cimAction $ action $ matchConditionType cimMatchConditionType $
           otherMatchConditionType
             cimOtherMatchConditionType $ setMetricType cimSetMetricType $ setMetricValue)
             cimSetMetricValue)
      )

      ( <oid-nf65> NAME 'cim22BGPRouteMapNameForm'
        OC cim22BGPRouteMap
        MUST (orderedCimModelPath)
      )

   The following structural rule is recommended:

      ( 46 <sr65> NAME 'dmtfBGPRouteMapStructureRule1' 'cim22BGPRouteMapStructureRule'
        FORM dmtfBGPRouteMapNameForm1 cim22BGPRouteMapNameForm
        SUP 3 4 <sr56>

      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22BGPRouteMap.

      ( <oid-nf46> <oid-oc317> NAME 'dmtfBGPRouteMapNameForm1'
        OC dmtfBGPRouteMap
        MUST (name) 'cim22BGPRouteMapContentRule'
        DESC 'The auxiliary classes that may be attached to
cim22BGPRouteMap'
        AUX (cim22BGPRouteMapsInRoutingPolicyAuxClass $
             cim22BGPPeerUsesRouteMapAuxClass $
             cim22FilterListsInBGPRouteMapAuxClass $
             cim22LogicalIdentityAuxClass $ cim22CollectedMSEsAuxClass $
             cim22ElementConfigurationAuxClass $
             cim22ElementSettingAuxClass $ cim22DependencyAuxClass $
             cim22ProvidesServiceToElementAuxClass $
             cim22ComponentAuxClass $ cim22SystemComponentAuxClass $
             cim22ActsAsSpareAuxClass)
      )

2.50 dmtfBGPRouteMapsInRoutingPolicy

3.50 cim22BGPRouteMapsInRoutingPolicyAuxClass

   This auxiliary class defines the RouteMaps that are used by a
   particular RoutingPolicy object. Multiple instances of the same
   RouteMap may be used in the same RoutingPolicy instance; if this is
   desired, then the Sequence attribute of this aggregation can be used
   to disambiguate them.  In it, groupComponentRefs point to
   dmtfRoutingPolicy objects and partComponentRefs point to
   dmtfBGPRouteMap objects.

      ( <oid-oc316> <oid-oc318> NAME 'dmtfBGPRouteMapsInRoutingPolicyAuxClass' 'cim22BGPRouteMapsInRoutingPolicyAuxClass'
        DESC 'defines 'This aggregation defines the RouteMaps that are used by a
              particular RoutingPolicy object.' object. Multiple instances of the
              same RouteMap may be used in the same RoutingPolicy
              instance; if this is desired, then the Sequence attribute
              of this aggregation can be used to disambiguate
              them. Attribute cimGroupComponentRef points to
              cim22RoutingPolicy and attribute cimPartComponentRef points
              to cim22BGPRouteMap.'
        SUP dmtfComponentAuxClass cim22ComponentAuxClass AUXILIARY
        MUST (groupComponentRefs)
        MAY (cimGroupComponentRef $ cimPartComponentRef $ cimSequence)
      )

2.51 dmtfBGPPeerUsesRouteMapAuxClass

3.51 cim22BGPPeerUsesRouteMapAuxClass

   This auxiliary class defines the RouteMaps that are used by a
   particular BGPPeerGroup object. Multiple instances of the same
   RouteMap may be used in the same BGPPeerGroup instance; if this is
   desired, then the Sequence attribute of this association can be used
   to disambiguate them.  In it antecedentRefs point to dmtfBGPPeerGroup
   objects and dependentRefs to dmtfBGPRouteMap objects.

      ( <oid-oc317> <oid-oc319> NAME 'dmtfBGPPeerUsesRouteMapAuxClass' 'cim22BGPPeerUsesRouteMapAuxClass'
        DESC 'defines 'This association defines the RouteMaps that are used by a
              particular BGPPeerGroup object.' object. Multiple instances of the
              same RouteMap may be used in the same BGPPeerGroup
              instance; if this is desired, then the Sequence attribute
              of this association can be used to disambiguate
              them. Attribute cimAntecedentRef points to
              cim22BGPPeerGroup and attribute cimDependentRef points to
              cim22BGPRouteMap.'
        SUP top AUXILIARY
        MUST (antecedentRefs
        MAY (cimAntecedentRef $ dependentRefs cimDependentRef $ sequence) cimSequence)
      )

2.52 dmtfFilterListInBGPRouteMapAuxClass

3.52 cim22FilterListInBGPRouteMapAuxClass

   While route maps do not have to use filter lists, this auxiliary
   class defines that filter list that is used by a particular route
   map.  In it, antecedentRef points to a dmtfFilterList object and
   dependentRef to a dmtfBGPRouteMap object.

      ( <oid-oc318> <oid-oc320> NAME 'dmtfFilterListsInBGPRouteMapAuxClass' 'cim22FilterListsInBGPRouteMapAuxClass'
        DESC 'RouteMaps do not have to use FilterLists, but if they do,
              this association defines the which FilterList that is used by a
              particular RouteMap.' RouteMap. Attribute cimAntecedentRef points to
              cim22FilterList and attribute cimDependentRef points to
              cim22BGPRouteMap.'
        SUP dmtfDependencyAuxClass cim22DependencyAuxClass AUXILIARY
        MUST (antecedentRef
        MAY (cimAntecedentRef $ dependentRef) cimDependentRef)
      )

2.53 dmtfInBGPPeerGroupAuxClass

3.53 cim22InBGPPeerGroupAuxClass

   This auxiliary class defines the specific routers (e.g.,
   ComputerSystems) that participate in a PeerGroup.  In it,
   collectionRef points to a dmtfBGPPeerGroup object and memberRefs to
   at least two dmtfComputerSystem objects.

      ( <oid-oc319> <oid-oc321> NAME 'dmtfInBGPPeerGroupAuxClass' 'cim22InBGPPeerGroupAuxClass'
        DESC 'defines 'This aggregation defines the specific routers (e.g.,
              ComputerSystems) that participate in a PeerGroup.' PeerGroup. Attribute
              cimCollectionRef points to cim22BGPPeerGroup and attribute
              cimMemberRef points to cim22ComputerSystem.'
        SUP dmtfCollectedMSEsAuxClass cim22CollectedMSEsAuxClass AUXILIARY
        MAY (cimCollectionRef $ cimMemberRef)
      )

2.54 dmtfCalculatesAmongAuxClass

3.54 cim22CalculatesAmongAuxClass

   This is a specialization of dmtfServiceSAPDependencyAuxClass, cim22ServiceSAPDependencyAuxClass,
   indicating that the referenced ProtocolEndpoint is utilized by the
   RouteCalculationService to provide its functionality.  In this class
   antecedentRefs point to dmtfProtocolEndpoint objects and
   dependentRefs point to dmtfRouteCalculationService objects.

      ( <oid-oc320> <oid-oc322> NAME 'dmtfCalculatesAmongAuxClass' 'cim22CalculatesAmongAuxClass'
        DESC 'shows 'This is a specialization of the ServiceSAPDependency
              association, indicating that the referenced
              ProtocolEndpoint is utilized by the RouteCalculationService
              to provide its
           functionality.' functionality. Attribute cimAntecedentRef
              points to cim22ProtocolEndpoint and attribute cimDependentRef
              points to cim22RouteCalculationService.'
        SUP dmtfServiceSAPDependencyAuxClass cim22ServiceSAPDependencyAuxClass AUXILIARY
        MUST (antecedentRefs
        MAY (cimAntecedentRef $ cimDependentRef $ isStatic) cimIsStatic)
      )

2.55 dmtfBGPAttributes

3.55 cim22BGPAttributes

   This class defines all the BGP Attributes, for a given version of the
   BGP protocol, that can be used to affect routing decisions.
   BGPAttributes are specific to a given AutonomousSystem that contains
   it. Hence, DIT structural rules are recommended.

      ( <oid-at720> <oid-at713> NAME 'localPreference' 'cimLocalPreference'
        DESC 'This defines the priority, or preference, of a route, in
              order to better compare it with other routes for the same
              destination. Higher values indicate a higher preference for
              a route.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at721> <oid-at714> NAME 'aSPath' 'cimASPath'
        DESC 'This attribute is a sequences of the AS numbers through
              which routing information carried in this UPDATE message
              has passed. The components of this list can be AS_SETs or
              AS_SEQUENCEs.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at722> <oid-at715> NAME 'aS_Set' 'cimASSet'
        DESC 'This is the set of all elements contained in all specific
              paths that are being summarized, so that those attributes
              will remain available to the routing decision process.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at723> <oid-at716> NAME 'nextHopSelf' 'cimNextHopSelf'
        DESC 'This defines the next hop to be the IP address of the
              border IBGP neighbor.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at724> <oid-at717> NAME 'mED' 'cimMED'
        DESC 'This is used on external (e.g., inter-AS) links to indicate
              which is the preferred entry point into an AS, when that AS
              has multiple entry points. Lower MED values have preference.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at725> <oid-at718> NAME 'bGPCommunityValue' 'cimBGPCommunityValue'
        DESC 'This defines a group of destinations that share a similar
              property. Communities are not restricted to a single AS,
              and can span multiple ASs. This attribute simplifies is used to
              simplify routing policies by basing policies on a logical
              value, as opposed to an IP address or an AS number.' number. '
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at726> <oid-at719> NAME 'atomicAggregate' 'cimAtomicAggregate'
        DESC 'This attribute gets set if there are overlapping routes,
              and a less-specific route is selected instead of a more
              specific one (e.g., a system propagates an aggregate that
              causes loss of information.'
        SYNTAX boolean SINGLE-VALUE
      )

      ( <oid-at727> <oid-at720> NAME 'aggregator' 'cimAggregator'
        DESC 'This specifies the AS and IP address of the router that has
              generated an aggregate.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at728> <oid-at721> NAME 'origin' 'cimOrigin'
        DESC 'This is generated by the AS that originates the routing
              information. There are three types of origins - IGP, EGP,
              and INCOMPLETE. These correspond to whether the information
              was learned internally in the AS, externally via an EGP, or
              by some other means.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at729> <oid-at722> NAME 'originatorID' 'cimOriginatorID'
        DESC 'This is the router ID for the ORIGIN attribute.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-oc321> <oid-oc323> NAME 'dmtfBGPAttributes' 'cim22BGPAttributes'
        DESC 'defines 'This class defines all of the BGP Attributes, for a given
              version of the BGP protocol, that can be used to affect
              routing
           decisions.' decisions. BGPAttributes are specific to a given
              AutonomousSystem that contains it. Hence, the keys of the
              AutonomousSystem are propagated to this class.'
        SUP dmtfLogicalElement cim22LogicalElement
        MUST (systemCreationClassName (cimSystemCreationClassName $ systemName cimSystemName $ version $
           localPreference cimVersion)
        MAY (cimLocalPreference $ aSPath cimASPath $ aS_Set cimASSet $ nextHop cimNextHop $ nextHopSelf
             cimNextHopSelf $
           mED cimMED $ bGPCommunityValue cimBGPCommunityValue $ atomicAggregate
             cimAtomicAggregate $ aggregator cimAggregator $
           origin cimOrigin $ originatorID)
      )

   The following structural rule is recommended:

      ( 47 NAME 'dmtfBGPAttributesStructureRule1'
        FORM dmtfBGPAttributesNameForm1
        SUP 3 4
             cimOriginatorID)
      )

      ( <oid-nf47> <oid-nf66> NAME 'dmtfBGPAttributesNameForm1' 'cim22BGPAttributesNameForm'
        OC dmtfBGPAttributes cim22BGPAttributes
        MUST (name) (orderedCimModelPath)
      )

2.56 dmtfFilteredBGPAttributesAuxClass

   This is a specialization of dmtfComponentAuxClass, which defines the
   set of BGP Attributes that are used by a particular Routing Policy.
   In it, groupRefs points to dmtfRoutingPolicy objects and partRefs
   point to dmtfBGPAttributes objects.

      ( <oid-oc322> <sr66> NAME 'dmtfFilteredBGPAttributesAuxClass'
        DESC 'defines the set of BGP Attributes that are used by a
           particular Routing Policy.' 'cim22BGPAttributesStructureRule'
        FORM cim22BGPAttributesNameForm
        SUP dmtfComponentAuxClass AUXILIARY <sr56>
      )

2.57 dmtfBGPPathAttributes

   This class defines the per-path information used to process specific
   BGP attribute information, as defined in the bgp4PathAttrTable of RFC
   1657.

      ( <oid-at730> NAME 'pathAttrASPathSegment'
        DESC 'represents a sequence of AS path segments. May be used as
           an RDN.'
        SYNTAX integer
      )

      ( <oid-at731> NAME 'pathAttrNextHop'
        DESC 'This is the address of the border router that should be
           used for the destination network.  May be used as an RDN.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at732> NAME 'pathAttrOrigin'
        DESC 'This is an enumeration that defines the ultimate origin of
           the path information.

   The value "IGP" means that the origin
           is interior; the value "EGP" means that it was learned via
           an EGP; the value "INCOMPLETE" means that the origin is
           undetermined.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at733> NAME 'pathAttrMultiExitDisc'
        DESC 'This metric discriminates between multiple
           adjacent autonomous systems. A value of -1 shows the
           absence of this attribute. The range of this attribute is
           defined to be -1 to 2147483647.'
        SYNTAX binary SINGLE-VALUE
      )

      ( <oid-at734> NAME 'pathAttrLocalPref'
        DESC 'This is the originating BGP4 speaker's degree of preference
           for an advertised route. A value of -1 shows the
           absence of this attribute. The range of this attribute is
           defined to be -1 to 2147483647.'
        SYNTAX binary SINGLE-VALUE
      )

      ( <oid-at735> NAME 'pathAttrAtomicAggregate'
        DESC 'This is an enumeration that defines whether the
           local system has selected a less specific route without
           selecting a more specific route. There are two values, 1
           and 2, indicating that a less specific route has not and
           has been selected, respectively. This is a 32-bit integer
           to correspond to the IETF MIB.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at736> NAME 'pathAttrAggregatorAS'
        DESC 'This is the AS number of following content rule specifies the last BGP4 speaker auxiliary classes that
           performed route aggregation. A value of 0 shows the
           absence of this attribute. The range of this attribute is
           defined to may
   be 0 attached to 65535.'
        SYNTAX integer SINGLE-VALUE
      ) cim22BGPAttributes.

      ( <oid-at737> <oid-oc323> NAME 'pathAttrAggregatorAddr' 'cim22BGPAttributesContentRule'
        DESC 'This is the IP address of the last BGP4 speaker 'The auxiliary classes that
           performed route aggregation. A value of 0.0.0.0 shows
           the absence of this attribute.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at738> NAME 'pathAttrCalcLocalPref'
        DESC 'This is the degree of preference calculated by the
           receiving BGP4 speaker for an advertised route. A value of
           -1 shows the absence of this attribute. The range of
           this attribute is defined to may be -1 to 2147483647.'
        SYNTAX binary SINGLE-VALUE
      )

      ( <oid-at739> NAME 'pathAttrBest'
        DESC 'This shows whether or not this route was
           chosen as the best BGP4 route. There are two possible
           values, 1 (FALSE) and 2 (TRUE).'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at740> NAME 'pathAttrUnknown'
        DESC 'This contains one or more path atributes not understood by
           this BGP4 speaker. The MIB variable is an OctetString, and
           contains a 1-octet length field and up to 254 additional
           octets of data. The length is placed in a separate
           attribute of this class, pathAttrUnknownNumber.'
        SYNTAX string
      )
      ( <oid-at741> NAME 'pathAttrUnknownNumber'
        DESC 'The MIB variable is an OctetString, and contains a 1-octet
           length field and up attached to 255 additional octets of data. The
           length is placed in this attribute.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc323> NAME 'dmtfBGPPathAttributes'
        DESC 'This class defines the per-path information used to process
           specific BGP attribute information, as defined in the
           bgp4PathAttrTable of RFC 1657.'
        SUP dmtfLogicalElement
        MUST (pathAttrNextHop $ pathAttrOrigin
              cim22BGPAttributes'
        AUX (cim22FilteredBGPAttributesAuxClass $ pathAttrMultiExitDisc
             cim22LogicalIdentityAuxClass $
           pathAttrLocalPref cim22CollectedMSEsAuxClass $ pathAttrAtomicAggregate
             cim22ElementConfigurationAuxClass $
           pathAttrAggregatorAS
             cim22ElementSettingAuxClass $ pathAttrAggregatorAddr cim22DependencyAuxClass $
           pathAttrCalcLocalPref
             cim22ProvidesServiceToElementAuxClass $ pathAttrBest
             cim22ComponentAuxClass $ pathAttrUnknown cim22SystemComponentAuxClass $
           pathAttrUnknownNumber)
             cim22ActsAsSpareAuxClass)
      )

2.58 dmtfBGPAttribtuesForRouteAuxClass

3.56 cim22FilteredBGPAttributesAuxClass

   This defines the attributes that are transmitted between BGP peers on
   a per-route basis. In it, antecedentRef points to a dmtfBGPIPRoute
   object and dependentRef points to is a dmtfBGPPathAttributes object.

      ( <oid-at742> NAME 'pathAttrPeer'
        DESC 'This defines the IP address specialization of the peer where the path
           information was learned.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at743> NAME 'pathAttrIPAddrPrefixLen'
        DESC 'This cim22ComponentAuxClass, which defines the length in bits of the IP address prefix in
           the Network Layer Reachability information field. The range
   set of this attribute is defined to be 0 to 32.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at744> NAME 'pathAttrIPAddrPrefix'
        DESC 'An IP address prefix in the Network Layer Reachability
           Information field. This object is an IP address containing
           the prefix with length specified by the
           PathAttrIpAddrPrefixLen attribute.  May be BGP Attributes that are used as an RDN.'
        SYNTAX string SINGLE-VALUE
      ) by a particular Routing Policy.

      ( <oid-oc324> NAME 'dmtfBGPAttributesForRouteAuxClass' 'cim22FilteredBGPAttributesAuxClass'
        DESC 'This defines the attributes that are transmitted between
           BGP peers on a per-route basis.'
        SUP dmtfDependencyAuxClass AUXILIARY
        MUST (antecedentRef $ dependentRef $ pathAttrPeer $
           pathAttrIPAddrPrefixLen $ pathAttrIPAddrPrefix)
      )

2.59 dmtfBGPServiceAttributesAuxClass

   This is a specialization of dmtfComponentAuxClass and defines the Component aggregation,
              which is used to define the set of BGP Attributes that are transmitted in per-path UPDATE messages.
   In it groupComponentRef
              used by a particular Routing Policy. Attribute
              cimGroupComponentRef points to a dmtfBGPService object cim22RoutingPolicy and
   partComponentRef
              attribute cimPartComponentRef points to a dmtfBGPPathAttributes object.

      ( <oid-at745> NAME 'partComponentRef'
        DESC 'The part component'
        SYNTAX DN SINGLE-VALUE
      )

      ( <oid-oc325> NAME 'dmtfBGPServiceAttributesAuxClass'
        DESC 'defines the set of BGP Attributes that are transmitted in
           per-path UPDATE messages.' cim22BGPAttributes.'
        SUP dmtfComponentAuxClass cim22ComponentAuxClass AUXILIARY
        MUST (partComponentRef)
        MAY (cimGroupComponentRef $ cimPartComponentRef)
      )

2.60 dmtfSwitchService

3.57 cim22SwitchService

   Generic switch (bridging) service class. Additional switching
   functions are incorporated as subordinate services related to this
   class via ServiceComponent associations.

      ( <oid-at746> NAME 'bridgeAddress'
        DESC 'MAC address used by this switch service when it must be
              uniquely identified. When concatenated with a
           SpanningTreeService Priority, a unique bridge identifier
           results. The MAC address is formatted as twelve hexadecimal
           digits (e.g., "010203040506"), with each pair representing
           one of the six octets of the MAC address in "canonical" bit
           order according to RFC 2469.'
        SYNTAX string{12} SINGLE-VALUE
      )

      ( <oid-at747> NAME 'numPorts'
        DESC 'The number of switch ports controlled by this switching
           service.'
        SYNTAX integer SINGLE-VALUE
      )
      ( <oid-oc326> <oid-oc325> NAME 'dmtfSwitchService' 'cim22SwitchService'
        DESC 'Generic switch (bridging) service class. Additional
              switching functions are incorporated as subordinate
              services related to this class via ServiceComponent
              associations.'
        SUP dmtfForwardingService
        MUST (bridgeAddress cim22ForwardingService
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22SwitchService.

      ( <oid-oc325> NAME 'cim22SwitchServiceContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22SwitchService'
        AUX (cim22SwitchesAmongAuxClass $
             cim22SwitchServiceTransparentBridgingAuxClass $ numPorts
             cim22SwitchServiceSpanningTreeAuxClass $ bridgeType)
             cim22SwitchServiceSourceRoutingAuxClass $
             cim22SwitchServiceVLANAuxClass)
      )

2.61 dmtfSwitchPort

3.58 cim22SwitchPort

   A switch port from which frames are received and out they are
   transmitted.

      ( <oid-at748> <oid-at723> NAME 'portNumber' 'cimPortNumber'
        DESC 'Numeric identifier for a switch port.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc327> <oid-oc326> NAME 'dmtfSwitchPort' 'cim22SwitchPort'
        DESC 'Switch Port from which frames are received and out which
              they are transmitted.'
        SUP dmtfProtocolEndpoint
        MUST (portNumber) cim22ProtocolEndpoint
        MAY (cimPortNumber)
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22SwitchPort.

      ( <oid-oc326> NAME 'cim22SwitchPortContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22SwitchPort'
        AUX (cim22SwitchesAmongAuxClass $ cim22SwitchableAuxClass $
             cim22SwitchPortSpanningTreeAuxClass $
             cim22SwitchPortDynamicForwardingAuxClass $
             cim22SwitchPortStaticForwardingAuxClass $
             cim22SwitchPortPairAuxClass $
             cim22SwitchPortSourceRoutingAuxClass $ cim22InboundVLANAuxClass
$
             cim22OutboundVLANAuxClass)
      )

2.62 dmtfSwitchesAmongAuxClass

3.59 cim22SwitchesAmongAuxClass

   A SwitchService switches frames between SwitchPorts. This auxiliary
   class makes that relationship explicit.  In it, antecedentRefs point
   to dmtfSwitchPort objects and dependentRef to a dmtfSwitchService
   object.

      ( <oid-oc328> <oid-oc327> NAME 'dmtfSwitchesAmongAuxClass' 'cim22SwitchesAmongAuxClass'
        DESC 'makes the relationship between 'A SwitchService that switches frames between SwitchPorts explicit' SwitchPorts. This
              association makes that relationship explicit. Attribute
              cimAntecedentRef points to cim22SwitchPort and attribute
              cimDependentRef points to cim22SwitchService.'
        SUP dmtfForwardsAmongAuxClass cim22ForwardsAmongAuxClass AUXILIARY
        MUST (dependentRef)
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.63 dmtfSwitchableAuxClass

3.60 cim22SwitchableAuxClass

   A switch port has a LANEndpoint that is exposed via this auxiliary
   class.  In it antecedentRef points to a dmtfSwitchPort object and
   dependentRef points to a dmtfLANEndpoint object.

      ( <oid-oc329> <oid-oc328> NAME 'dmtfSwitchableAuxClass' 'cim22SwitchableAuxClass'
        DESC 'A switch port has a LANEndpoint that is exposed via this
           relationship.'
              relationship. Attribute cimAntecedentRef points to
              cim22SwitchPort and attribute cimDependentRef points to
              cim22LANEndpoint.'
        SUP dmtfBindsToAuxClass cim22BindsToAuxClass AUXILIARY
        MUST (antecedentRef
        MAY (cimAntecedentRef $ dependentRef) cimDependentRef)
      )

2.64 dmtfTransparentBridgingService

3.61 cim22TransparentBridgingService

   This service class represents the learning/transparent bridging
   aspect of switch service.

      ( <oid-at749> <oid-at724> NAME 'agingTime' 'cimAgingTime'
        DESC 'The timeout period in seconds for aging out dynamically
              learned forwarding information. 802.1D-1990 recommends a
              default of 300 seconds.'

        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at750> <oid-at725> NAME 'fID' 'cimFID'
        DESC 'Filtering Database Identifier. Used by VLAN-aware switch
              having more than one filtering database.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc330> <oid-oc329> NAME 'dmtfTransparentBridgingService' 'cim22TransparentBridgingService'
        DESC 'represents 'This service class represents the learning/transparent
              bridging aspect of switch service.'
        SUP dmtfService cim22Service
        MAY (cimAgingTime $ cimFID)
      )

      ( <oid-nf67> NAME 'cim22TransparentBridigingServiceNameForm'
        OC cim22TransparentBridigingService
        MUST (agingTime (orderedCimModelPath)
      )

      ( <sr67> NAME 'cim22TransparentBridigingServiceStructureRule'
        FORM cim22TransparentBridigingServiceNameForm
        SUP <sr2>
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22TransparentBridgingService.

      ( <oid-oc329> NAME 'cim22TransparentBridgingServiceContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22TransparentBridgingService'
        AUX (cim22SwitchServiceTransparentBridgingAuxClass $ fID)
             cim22RelatedTransparentBridgingServiceAuxClass $
             cim22RelatedSpanningTreeAuxClass)
      )

2.65 dmtfSpanningTreeService

3.62 cim22SpanningTreeService

   This service class represents the capability of a switch to participate in
   the distributed construction of a spanning tree.

      ( <oid-at751> <oid-at726> NAME 'protocolSpec' 'cimProtocolSpec'
        DESC 'The version of the spanning tree protocol used by the
              switch.'
        SYNTAX integer SINGLE-VALUE
      )
      ( <oid-at752> <oid-at727> NAME 'priority' 'cimPriority'
        DESC 'The format of 'Priority indicates the priority bits are the first two octets of
           the 8-octet long Bridge ID. The other (last) 6 octets urgency or importance of
           the Bridge ID are given by the value execution
              of the Bridge
           Address. A priority that can be assigned to the switch for
           use in constructing the spanning tree. The unique
           identifier for a switch Process. If a priority is constructed by concatenating the
           MAC address associated with the switch not defined for spanning tree
           operations to the two-byte priority. Choice of the priority a Process, a
              value influences election of the root bridge.' 0 should be used.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at753> <oid-at728> NAME 'designatedRoot' 'cimDesignatedRoot'
        DESC 'The Bridge ID (Priority + MAC Address) of the root
           bridge.The
              bridge. The format of the priority bits are the first two
              octets of the 8-octet long Bridge ID. The other (last) 6
              octets of the Bridge ID are given by the value of the
              Bridge Address. Note that the MAC address is formatted as
              twelve hexadecimal digits (e.g., "010203040506")' "010203040506"), with each
              pair representing one of the six octets of the MAC address
              in "canonical" bit order according to RFC 2469.'
        SYNTAX string{16} SINGLE-VALUE
      )

      ( <oid-at754> <oid-at729> NAME 'rootCost' 'cimRootCost'
        DESC 'The cost of the path from the switch to the root.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at755> <oid-at730> NAME 'rootPort' 'cimRootPort'
        DESC 'The port number of the port having the lowest cost path to
              the root bridge.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at756> <oid-at731> NAME 'maxAge' 'cimMaxAge'
        DESC 'The current value for the maximum age of Spanning Tree
              information before discard, as learned from the network.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at757> <oid-at732> NAME 'helloTime' 'cimHelloTime'
        DESC 'The current value of the interval between transmission of
              bridge PDUs by the switch on any port for which it is the
              spanning tree root or trying to become so, as learned from
              the network.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at758> <oid-at733> NAME 'forwardDelay' 'cimForwardDelay'
        DESC 'The time spent by a port in the listening state before
              transitioning to the learning state and in the learning
              state before transitioning to the forwarding state, as
              learned from the network. This value is also used during
              the period of a topology change as the maximum age of
              Spanning Tree information before discard.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at759> <oid-at734> NAME 'bridgeMaxAge' 'cimBridgeMaxAge'
        DESC 'The MaxAge parameter to be used by all switches in the
              network if this switch becomes the root.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at760> <oid-at735> NAME 'bridgeHelloTime' 'cimBridgeHelloTime'
        DESC 'The HelloTime parameter to be used by all switches in the
              network if this switch becomes the root.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at761> <oid-at736> NAME 'bridgeForwardDelay' 'cimBridgeForwardDelay'
        DESC 'The ForwardDelay parameter to be used by all switches in
              the network if this switch becomes the root.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at762> <oid-at737> NAME 'spanningTreeBridgeAddress' 'cimSpanningTreeBridgeAddress'
        DESC 'MAC address used by the spanning tree service when it must
              be uniquely identified. When concatenated with a
              SpanningTreeService Priority, a unique bridge identifier
              results. This property is defined for use of switches
              supporting multiple spanning tree services. Note that the
              MAC address is formatted as twelve hexadecimal digits
              (e.g., "010203040506")' "010203040506"), with each pair representing one of
              the six octets of the MAC address in "canonical" bit order
              according to RFC 2469.'
        SYNTAX string{12} string SINGLE-VALUE
      )

      ( <oid-oc331> <oid-oc330> NAME 'dmtfSpanningTreeService' 'cim22SpanningTreeService'
        DESC 'This service class represents the capability of a switch to
              participate in the distributed construction of a spanning
tree.'
        SUP dmtfService
        MUST (protocolSpec cim22Service
        MAY (cimProtocolSpec $ priority cimPriority $ designatedRoot cimDesignatedRoot $ rootCost
             cimRootCost $
           rootPort cimRootPort $ maxAge cimMaxAge $ helloTime cimHelloTime $ holdTime
             cimHoldTime $ forwardDelay cimForwardDelay $
           bridgeMaxAge cimBridgeMaxAge $ bridgeHelloTime
             cimBridgeHelloTime $ bridgeForwardDelay cimBridgeForwardDelay $
           spanningTreeBridgeAddress)
             cimSpanningTreeBridgeAddress)
      )

2.66 dmtfSwitchPortSpanningTreeAuxClass

   The following content rule specifies the auxiliary classes that may
   be attached to cim22SpanningTreeService.

      ( <oid-oc330> NAME 'cim22SpanningTreeServiceContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22SpanningTreeService'
        AUX (cim22SwitchPortSpanningTreeAuxClass $
             cim22SwitchServiceSpanningTreeAuxClass $
             cim22RelatedSpanningTreeAuxClass)
      )

3.63 cim22SwitchPortSpanningTreeAuxClass

   A switch participating in the spanning tree maintains spanning-tree
   specific information about each port whose forwarding is determined
   by the spanning tree. This auxiliary class represents that
   information and in it antecedentRefs point to dmtfSwitchPort objects
   and dependentRefs point to dmtfSpanningTreeService objects.
   information.

      ( <oid-at763> <oid-at738> NAME 'enable' 'cimEnable'
        DESC 'The enabled/disabled status of the port.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at764> <oid-at739> NAME 'pathCost' 'cimPathCost'
        DESC 'The contribution of this port to the path cost of paths
              towards the spanning tree root that includes which include this port.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at765> <oid-at740> NAME 'designatedCost' 'cimDesignatedCost'
        DESC 'The cost of the path to the root offered by the designated
              bridge for the segment.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at766> <oid-at741> NAME 'designatedBridge' 'cimDesignatedBridge'
        DESC 'The bridge identifier of the designated bridge for the
              segment to which the port is attached.'
        SYNTAX string SINGLE-VALUE
      )

      ( <oid-at767> <oid-at742> NAME 'designatedPort' 'cimDesignatedPort'
        DESC 'The port identifier of the port on the designated bridge
              serving the segment to which the port is attached.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc332> <oid-oc331> NAME 'dmtfSwitchPortSpanningTreeAuxClass' 'cim22SwitchPortSpanningTreeAuxClass'
        DESC 'A switch participating in the spanning tree maintains
              spanning-tree specific information about each port whose
              forwarding is determined by the spanning tree. This
              association represents that information.' information. Attribute
              cimAntecedentRef points to cim22SwitchPort and attribute
              cimDependentRef points to cim22SpanningTreeService.'
        SUP dmtfServiceSAPDependencyAuxClass cim22ServiceSAPDependencyAuxClass AUXILIARY
        MUST (dmtfSwitchPortRefs
        MAY (cimAntecedentRef $ dmtfSpanningTreeServiceRefs cimDependentRef $ iD cimPriority $
           priority
             cimState $ state cimEnable $ enable cimPathCost $ pathCost cimDesignatedRoot $ designatedRoot
             cimDesignatedCost $
           designatedCost cimDesignatedBridge $ designatedBridge $ designatedPort) cimDesignatedPort)
      )

2.67 dmtfDynamicForwardingEntry

3.64 cim22DynamicForwardingEntry

   This class represents an entry in the forwarding (filtering) database
   associated with the transparent bridging service.

      ( <oid-at768> <oid-at743> NAME 'dynamicStatus' 'cimDynamicStatus'
        DESC 'The status of the entry.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc333> <oid-oc332> NAME 'dmtfDynamicForwardingEntry' 'cim22DynamicForwardingEntry'
        DESC 'represents 'A DynamicForwardingEntry represents an entry in the
              forwarding (filtering) database associated with the
              transparent bridging service.'
        SUP dmtfLogicalElement cim22LogicalElement
        MUST (systemCreationClassName (cimSystemCreationClassName $ systemName cimSystemName $
           serviceCreationClassName
              cimServiceCreationClassName $ serviceName cimServiceName $
           creationClassName
              cimCreationClassName $ mACAddress $ dynamicStatus) cimMACAddress)
        MAY (cimDynamicStatus)
      )

   The following DIT structural rule is recommended:

      ( 48 <oid-nf68> NAME 'dmtfDynamicForwardEntryStrutureRule1'
        FORM dmtfDynamicForwardEntryNameForm1
        SUP 50
      )

      ( <oid-nf48> NAME 'dmtfDynamicForwardEntryNameForm1' 'cim22DynamicForwardingEntryNameForm'
        OC dmtfDynamicForwardEntry cim22DynamicForwardingEntry
        MUST (name) (orderedCimModelPath)
      )

      ( 49 <sr68> NAME 'dmtfDynamicForwardEntryStrutureRule2' 'cim22DynamicForwardingEntryStructureRule'
        FORM dmtfDynamicForwardEntryNameForm2 cim22DynamicForwardingEntryNameForm
        SUP 50
      )

      ( <oid-nf49> NAME 'dmtfDynamicForwardEntryNameForm2'
        OC dmtfDynamicForwardEntry
        MUST (mACAddress)
      )

      ( 50 NAME 'dmtfTransparentBridgingServiceStructureRule'
           FORM dmtfTransparentBridgingServiceNameForm <sr67>
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22DynamicForwardingEntry.

      ( <oid-nf50> <oid-oc332> NAME 'dmtfTransparentBridgingServiceNameForm'
        OC dmtfTransparentBridgingService
        MUST (name) 'cim22DynamicForwardingEntryContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22DynamicForwardingEntry'
        AUX (cim22SwitchPortDynamicForwardingAuxClass $
             cim22LogicalIdentityAuxClass $ cim22CollectedMSEsAuxClass $
             cim22ElementConfigurationAuxClass $
             cim22ElementSettingAuxClass $ cim22DependencyAuxClass $
             cim22ProvidesServiceToElementAuxClass $
             cim22ComponentAuxClass $ cim22SystemComponentAuxClass $
             cim22ActsAsSpareAuxClass)
      )

2.68 dmtfSwitchPortDynamicForwardingAuxClass

3.65 cim22SwitchPortDynamicForwardingAuxClass

   This auxiliary class links a dynamic forwarding entry and the switch
   port to which the entry applies.  In it, antecedentRef points to a
   dmtfSwitchPort object and dependentRefs point to
   dmtfDynamicForwardingEntry objects.

      ( <oid-oc334> <oid-oc333> NAME 'dmtfSwitchPortDynamicForwardingAuxClass' 'cim22SwitchPortDynamicForwardingAuxClass'
        DESC 'links 'This association links a dynamic forwarding entry and the
              switch port to which the entry applies.' applies. Attribute
              cimAntecedentRef points to cim22SwitchPort and attribute
              cimDependentRef points to cim22DynamicForwardingEntry.'
        SUP dmtfDependencyAuxClass cim22DependencyAuxClass AUXILIARY
        MUST (antecedentRef)
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.69 dmtfStaticForwardingEntry

3.66 cim22StaticForwardingEntry

      ( <oid-at769> <oid-at744> NAME 'staticStatus' 'cimStaticStatus'
        DESC 'The status of the entry.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at770> <oid-at745> NAME 'allowedToGo' 'cimAllowedToGo'
        DESC 'The ports to which frames with the destination MAC address
              arriving on the port represented by the
              SwitchPortStaticForwarding association are allowed to be
              forwarded.'
        SYNTAX integer
      )

      ( <oid-oc335> <oid-oc334> NAME 'dmtfStaticForwardingEntry' 'cim22StaticForwardingEntry'
        DESC 'A StaticForwardingEntry represents an entry in the static
              (destination-address filtering) database associated with
              the switch service.'
        SUP dmtfLogicalElement cim22LogicalElement
        MUST (systemCreationClassName (cimSystemCreationClassName $ systemName cimSystemName $
           serviceCreationClassName
              cimServiceCreationClassName $ serviceName cimServiceName $
           creationClassName
              cimCreationClassName $ mACAddress cimMACAddress)

        MAY (cimStaticStatus $ staticStatus $
           allowedToGo) cimAllowedToGo)
      )

   The following DIT structure rule is recommended:

      ( 51 <oid-nf69> NAME 'dmtfStaticForwardEntryStrutureRule1'
        FORM dmtfStaticForwardEntryNameForm1
        SUP 50
      )
      ( <oid-nf51> NAME 'dmtfStaticForwardEntryNameForm1' 'cim22StaticForwardingEntryNameForm'
        OC dmtfStaticForwardEntry cim22StaticForwardingEntry
        MUST (name) (orderedCimModelPath)
      )

      ( 52 <sr69> NAME 'dmtfStaticForwardEntryStrutureRule2' 'cim22StaticForwardingEntryStructureRule'
        FORM dmtfStaticForwardEntryNameForm2 cim22StaticForwardingEntryNameForm
        SUP 50 <sr67>
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22StaticForwardingEntry.

      ( <oid-nf52> <oid-oc334> NAME 'dmtfStaticForwardEntryNameForm2'
        OC dmtfStaticForwardEntry
        MUST (mACAddress) 'cim22StaticForwardingEntryContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22StaticForwardingEntry'
        AUX (cim22SwitchPortStaticForwardingAuxClass $
             cim22LogicalIdentityAuxClass $ cim22CollectedMSEsAuxClass $
             cim22ElementConfigurationAuxClass $
             cim22ElementSettingAuxClass $ cim22DependencyAuxClass $
             cim22ProvidesServiceToElementAuxClass $
             cim22ComponentAuxClass $ cim22SystemComponentAuxClass $
             cim22ActsAsSpareAuxClass)
      )

2.70 dmtfSwitchPortStaticForwardingAuxClass

3.67 cim22SwitchPortStaticForwardingAuxClass

   This auxiliary class links a static database entry and the switch
   port to which the entry applies. In it, antecedentRef points to a
   dmtfSwitchPort object and dependentRefs point to
   dmtfStaticForwardingEntry objects.

      ( <oid-oc336> <oid-oc335> NAME 'dmtfSwitchPortStaticForwardingAuxClass' 'cim22SwitchPortStaticForwardingAuxClass'
        DESC 'links 'This association links a static forwarding database entry and the
              switch port to which the entry applies.' applies. Attribute
              cimAntecedentRef points to cim22SwitchPort and attribute
              cimDependentRef points to cim22StaticForwardingEntry.'
        SUP dmtfDependencyAuxClass cim22DependencyAuxClass AUXILIARY
        MUST (antecedentRef)
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.71 dmtfServiceComponentAuxClass

3.68 cim22ServiceComponentAuxClass

   This auxiliary class models a set of subordinate Services that are
   aggregated together to form a higher-level service.  In it,
   groupComponentRef points to dmtfService object and partComponentRefs
   point to dmtfService objects.

      ( <oid-oc337> <oid-oc336> NAME 'dmtfServiceComponentAuxClass' 'cim22ServiceComponentAuxClass'
        DESC 'models 'The ServiceComponent aggregation models a set of
              subordinate Services that are aggregated together to form a
              higher-level service.' service. Both reference attributes point to
              cim22Service objects.'
        SUP dmtfComponentAuxClass cim22ComponentAuxClass AUXILIARY
        MAY (cimGroupComponentRef $ cimPartComponentRef)
      )

2.72 dmtfSwitchServiceTransparentBridgingAuxClass

3.69 cim22SwitchServiceTransparentBridgingAuxClass

   This auxiliary class links SwitchService to a component
   TransparentBridgingService. The cardinality of the
   TransparentBridgingService is 0.1 for a VLAN-unaware switch.  In this
   class, groupComponentRef points to a dmtfSwitchService object and
   partComponentRefs point to dmtfTransparentBridgingService objects.

      ( <oid-oc338> <oid-oc337> NAME 'dmtfSwitchServiceTransparentBridgingAuxClass' 'cim22SwitchServiceTransparentBridgingAuxClass'
        DESC 'links 'An association linking SwitchService to a component
           TransparentBridgingService.'
              TransparentBridgingService. The cardinality of the
              TransparentBridgingService is 0..1 for a VLAN-unaware
              switch. Attribute cimGroupComponentRef points to
              cim22SwitchService and attribute cimPartComponentRef points
              to cim22TransparentBridgingService.'
        SUP dmtfServiceComponentAuxClass cim22ServiceComponentAuxClass AUXILIARY
        MAY (cimGroupComponentRef $ cimPartComponentRef)
      )

2.73 dmtfSwitchServiceSpanningTreeAuxClass

3.70 cim22SwitchServiceSpanningTreeAuxClass

   An auxiliary class that links SwitchService to a component
   SpanningTreeService. The cardinality of the SpanningTreeService is
   0.1 for a VLAN-unaware switch.  In it, groupComponentRef points to a
   dmtfSwitchService object and partComponentRefs point to
   dmtfSpanningTreeService objects.

      ( <oid-oc339> <oid-oc338> NAME 'dmtfSwitchServiceSpanningTreeAuxClass' 'cim22SwitchServiceSpanningTreeAuxClass'
        DESC 'linking 'An association linking SwitchService to a component SpanningTreeService.'
              SpanningTreeService. The cardinality of the
              SpanningTreeService is 0..1 for a VLAN-unaware
              switch. Attribute cimGroupComponentRef points to
              cim22SwitchService and attribute cimPartComponentRef points
              to cim22SpanningTreeService.'
        SUP dmtfServiceComponentAuxClass cim22ServiceComponentAuxClass AUXILIARY
        MAY (cimGroupComponentRef $ cimPartComponentRef)
      )

2.74 dmtfSourceRoutingService

3.71 cim22SourceRoutingService

   This service class represents the capability of a switch to
   participate in the source routing of frames received at its ports.

      ( <oid-at771> <oid-at746> NAME 'bridgeLfMode' 'cimBridgeLfMode'
        DESC 'Indicates whether the bridge operates using older 3 bit
              length negotiation fields or the newer 6 bit length field
              in its RIF.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc340> <oid-oc339> NAME 'dmtfSourceRoutingService' 'cim22SourceRoutingService'
        DESC 'represents 'This service class represents the capability of a switch to
              participate in the source routing of frames received at its
              ports.'
        SUP dmtfService
        MUST (bridgeLfMode) cim22Service
        MAY (cimBridgeLfMode)
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22SourceRoutingService.

      ( <oid-oc339> NAME 'cim22SourceRoutingServiceContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22SourceRoutingService'
        AUX (cim22SwitchServiceSourceRoutingAuxClass $
             cim22SwitchPortSourceRoutingAuxClass)
      )

2.75 dmtfSwitchServiceSourceRoutingAuxClass

3.72 cim22SwitchServiceSourceRoutingAuxClass

   This auxiliary class that links SwitchService to a component
   SourceRoutingService. The cardinality of the SourceRoutingService is
   0.1 for a VLAN-unaware switch.  In this class, groupComponentRef
   points to a dmtfSwitchService object and partComponentRefs point to
   dmtfSourceRoutingService objects.

      ( <oid-oc341> <oid-oc340> NAME 'dmtfSwitchServiceSourceRoutingAuxClass' 'cim22SwitchServiceSourceRoutingAuxClass'
        DESC 'links 'An association linking SwitchService to a component
              SourceRoutingService. The cardinality of the
              SourceRoutingService is 0.1 0..1 for a VLAN-unaware switch.'
              switch. Attribute cimGroupComponentRef points to
              cim22SwitchService and attribute cimPartComponentRef points
              to cim22SourceRoutingService.'
        SUP dmtfServiceComponentAuxClass cim22ServiceComponentAuxClass AUXILIARY
        MAY (cimGroupComponentRef $ cimPartComponentRef)
      )

2.76 dmtfSwitchPortPairAuxClass

3.73 cim22SwitchPortPairAuxClass

   This auxiliary class represents information regarding port pairings
   that is used by the SourceRoutingService of a switch.  In this class,
   antecedentRefs and dependentRefs point to dmtfSwitchPort objects.

      ( <oid-at772> <oid-at747> NAME 'bridgeNum' 'cimBridgeNum'
        DESC 'A bridge number that uniquely identifies the path provided
              by this source routing bridge between the segments
              connected to high and low ports. The purpose of bridge
              number is to disambiguate between multiple paths connecting
              the same two LANs.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at773> <oid-at748> NAME 'bridgeState' 'cimBridgeState'
        DESC 'The state of dot1dPortPairBridgeNum. Writing "invalid(3)"
              to this property removes the instance' association instance.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc342> <oid-oc341> NAME 'dmtfSwitchPortPairAuxClass' 'cim22SwitchPortPairAuxClass'
        DESC 'represents 'This association represents information regarding port
              pairings that is used by the SourceRoutingService of a switch.'
              switch. Both reference attributes point to cim22SwitchPort
              objects.'
        SUP dmtfSAPSAPDependency cim22SAPSAPDependencyAuxClass AUXILIARY
        MUST (bridgeNum
        MAY (cimAntecedentRef $ bridgeState) cimDependentRef $ cimBridgeNum $
             cimBridgeState)
      )

2.77 dmtfSwitchPortSourceRoutingAuxClass

3.74 cim22SwitchPortSourceRoutingAuxClass

   A switch capable of source routing maintains source-routing specific
   information about each port. This auxiliary class represents that
   information. In it, antecedentRefs point to dmtfSwitchPort objects
   and dependentRef points to a dmtfSourceRoutingService object.

      ( <oid-at774> <oid-at749> NAME 'hopCount' 'cimHopCount'
        DESC 'The maximum number of routing descriptors allowed in an All
              Paths or Spanning Tree Explorer frames.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at775> <oid-at750> NAME 'localSegment' 'cimLocalSegment'
        DESC 'The segment number that uniquely identifies the segment to
              which this port is connected. Current source routing
              protocols limit this value to the range: 0 through
              4095. (The value 0 is used by some management applications
              for special test cases.) A value of 65535 signifies that no
              segment number is assigned to this port.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at776> <oid-at751> NAME 'targetSegment' 'cimTargetSegment'
        DESC 'The segment number that corresponds to the target segment
              this port is considered to be connected to by the
              switch. Current source routing protocols limit this value
              to the range: 0 through 4095. (The value 0 is used by some
              management applications for special test cases.) A value of
              65535 signifies that no target segment is assigned to this
              port.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-at777> <oid-at752> NAME 'sTESpanMode' 'cimSTESpanMode'
        DESC 'Determines how the port behaves when pres`ented presented with a
              Spanning Tree Explorer frame. The value "disabled(2)"
           shows
              indicates that the port will not accept or send Spanning
              Tree Explorer packets; any STE packets received will be
              silently discarded. The value "forced(3)" shows indicates the
              port will always accept and propagate Spanning Tree
              Explorer frames. This allows a manually configured Spanning
              Tree for this class of packet to be configured. Note that
              unlike transparent bridging, this is not catastrophic to
              the network if there are loops. The value "auto-span(1)"
              can only be returned by a bridge that both implements the
              Spanning Tree Protocol and has use of the protocol enabled
              on this port. The behavior of the port for Spanning Tree
              Explorer frames is determined by the value of the State
              property of the SwitchPortSpanningTree association for the
              port. If the port is in the "forwarding" state, the frame
              will be accepted or propagated. Otherwise, it will be
              silently discarded.'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc343> <oid-oc342> NAME 'dmtfSwitchPortSourceRoutingAuxClass' 'cim22SwitchPortSourceRoutingAuxClass'
        DESC 'represents 'A switch capable of source routing maintains source-routing
              specific information about each
           port.' port. This association
              represents that information. Attribute cimAntecedentRef
              points to cim22SwitchPort and attribute cimDependentRef
              points to cim22SourceRoutingService.'
        SUP dmtfServiceSAPDependencyAuxClass cim22ServiceSAPDependencyAuxClass AUXILIARY
        MUST (dependentRef
        MAY (cimAntecedentRef $ hopCount cimDependentRef $ localSegment cimHopCount $ bridgeNum
             cimLocalSegment $
           targetSegment cimBridgeNum $ packets cimTargetSegment $ sTESpanMode)
             cimSTESpanMode)
      )

2.78 dmtfVLAN

3.75 cim22VLAN

   This class_VLAN class VLAN represents a VLAN within a switch.  In a particular
   switch, there should be an instance of this object for every VLAN
   available in the switch. For example, in a switchwith switch with port-based
   VLANs, if there are 16 VLANs to which ports canbe can be assigned (VLAN 1
   through VLAN 16), there should be aninstance of CIM_VLAN cim22VLAN for each of
   VLAN 1 through VLAN 16.

   This class inherits Name from ServiceAccessPoint.

   Use this cimName for the textual name of the VLAN, if there is one.
   Otherwise, synthesize a textual name, e.g., VLAN 0003. (Consider
   leading zero fill, as shown, to ensure that if the textual VLAN names
   are extracted and presented by management applictions, the VLAN names
   will sort in the expected order.

   It is intended that dmtfVLAN cim22VLAN be subclassed only if necessary to add
   attributes. The type of the VLAN can be inferred from the
   VLANService(s) with which the dmtfVLAN cim22VLAN is associated via the
   dmtfVLANForAuxClass
   cim22VLANForAuxClass object.

      ( <oid-at778> <oid-at753> NAME 'vLANNumber'
        DESC 'The number of the VLAN.' 'cimVLANNumber'
        SYNTAX integer SINGLE-VALUE
      )

      ( <oid-oc344> <oid-oc343> NAME 'dmtfVLAN' 'cim22VLAN'
        DESC 'represents 'An instance of cim22VLAN represents a VLAN within a switch.'
        SUP dmtfServiceAccessPoint
        MUST (vLANNumber) cim22ServiceAccessPoint
        MAY (cimVLANNumber)
      )

   The following content rule specifies the auxiliary classes that may
   be attached to cim22VLAN.

      ( <oid-oc343> NAME 'cim22VLANContentRule'
        DESC 'The auxiliary classes that may be attached to cim22VLAN'
        AUX (cim22RelatedTransparentBridgingServiceAuxClass $
             cim22InboundVLANAuxClass $ cim22OutboundVLANAuxClass)
      )

2.79 dmtfRelatedTransparentBridgingServiceAuxClass

3.76 cim22RelatedTransparentBridgingServiceAuxClass

   This auxiliary class maps between a VLAN and the forwarding database
   (some use the term filtering database) used to determine the port a
   packet should be transmitted on, given that it is assigned to the
   VLAN and that it has a particular destination MAC address. The
   TransparentBridgingServicerepresents a forwarding database.  In this
   class, antecedentRefs point to dmtfVLAN objects and dependentRef
   points to a dmtfTransparentBridgingService object.

      ( <oid-oc345> <oid-oc344> NAME 'dmtfRelatedTransparentBridgingServiceAuxClass' 'cim22RelatedTransparentBridgingServiceAuxClass'
        DESC 'relationship 'The association between a VLAN and the forwarding database'
              database(some use the term filtering database) used to
              determine which port a packet should be transmitted on,
              given that it is assigned to the VLAN and that it has a
              particular destination MAC address. The
              TransparentBridgingService represents a forwarding
              database. Attribute cimAntecedentRef points to cim22VLAN and
              attribute cimDependentRef points to
              cim22TransparentBridgingService.'
        SUP dmtfServiceSAPDependencyAuxClass cim22ServiceSAPDependencyAuxClass AUXILIARY
        MUST (dependentRef)
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.80 dmtfRelatedSpanningTreeAuxClass

3.77 cim22RelatedSpanningTreeAuxClass

   This auxiliary class identifies the spanning tree in which a
   forwarding database (TransparentBridgingService) is nested.  In it,
   antecedentRefs point to dmtfTransparentBridgingService objects and
   dependentRef points to a dmtfSpanningTreeService object.

      ( <oid-oc346> <oid-oc345> NAME 'dmtfRelatedSpanningTreeAuxClass' 'cim22RelatedSpanningTreeAuxClass'
        DESC 'identifies 'This association identifies the spanning tree in which a
              forwarding database (TransparentBridgingService) is nested.'
              nested. Attribute cimAntecedentRef points to
              cim22TransparentBridgingService and attribute cimDependentRef
              points to cim22SpanningTreeService.'
        SUP dmtfServiceServiceDependencyAuxClass cim22ServiceServiceDependencyAuxClass AUXILIARY
        MUST (dependentRef)
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.81 dmtfInboundVLANAuxClass

3.78 cim22InboundVLANAuxClass

   If there is an association between a particular SwitchPort and a
   particular CIM_VLAN, cim22VLAN, then there is the possibility that a packet
   received by the port will be assigned to the VLAN (or if the packet
   already has a VLAN tag, that the packet will not be dropped). If
   there is no such association, then there is no possibility that a
   packet received by the port will progress through the switch having
   been assigned to the VLAN in question.  In it, antecedentRefs point
   to dmtfVLAN objects and dependentRefs point to dmtfSwitchPort
   objects.

      ( <oid-at779> <oid-at754> NAME 'tagged' 'cimTagged'
        DESC 'If true, packets already tagged with this VLAN number will
              be accepted when arriving at this port. For example, if
              there is an InboundVLAN association between port 12 and
           VLAN 7 for which Tagged is true, then if a packet tagged
              with VLAN 7 arrives at port 12, the packet will be accepted
           into the switch for further processing. If there is no such
           association, then the packet will be dropped.  If false, it
           means that any untagged packets arriving at this port MIGHT
           be classified into the associated VLAN.' port.'
        SYNTAX boolean SINGLE-VALUE
      )

      ( <oid-at780> <oid-at755> NAME 'default' 'cimDefault'
        DESC 'Default should be true if untagged packets received by the
              Antecedent SwitchPort are assigned to the Dependent VLAN by
              default.'
        SYNTAX boolean SINGLE-VALUE
      )

      ( <oid-oc347> <oid-oc346> NAME 'dmtfInboundVLANAuxClass' 'cim22InboundVLANAuxClass'
        DESC 'relation 'If there is an association between a VLAN particular SwitchPort
              and switch ports where inbound
           traffic arrives.' a particular cimVLAN, then there is the possibility
              that a packet received by the port will be assigned to the
VLAN.
              Attribute cimAntecedentRef points to cim22VLAN and attribute
              cimDependentRef points to cim22SwitchPort.'
        SUP dmtfSAPSAPDependencyAuxClass cim22SAPSAPDependencyAuxClass AUXILIARY
        MUST (tagged
        MAY (cimAntecedentRef $ cimDependentRef $ cimTagged $ default) cimDefault)
      )

2.82 dmtfOutboundVLANAuxClass

   If

3.79 cim22OutboundVLANAuxClass

   This class controls whether packets assigned to a particular VLAN may
   be transmitted over a given switch port.
      ( <oid-oc347> NAME 'cim22OutboundVLANAuxClass'
        DESC 'If there is no instance of OutboundVLAN between a given
              SwitchPort and
   VLAN, cim22VLAN, then any packet that has been
              assigned to the VLAN and whose destination address is
              associated with the port will be dropped by the switch
              without being transmitted. Otherwise, the packet will be
              transmitted.
   In this class, antecedentRefs point Attribute cimAntecedentRef points to dmtfVLAN objects cim22VLAN
              and dependentRefs
   point attribute cimDependentRef points to dmtfSwitchPort objects.

      ( <oid-oc348> NAME 'dmtfOutboundVLANAuxClass'
        DESC 'relation between a VLAN and outbound switch ports' cim22SwitchPort.'
        SUP dmtfSAPSAPDependencyAuxClass cim22SAPSAPDependencyAuxClass AUXILIARY
        MUST (tagged)
        MAY (cimAntecedentRef $ cimDependentRef $ cimTagged)
      )

2.83 dmtfVLANService

3.80 cim22VLANService

   This class represents the VLAN aspects of the function performed by a
   switch. Some VLAN-aware devices participate in protocols where VLAN
   information is propagated among switches, e.g., GVRP in 802.1Q
   switches and VTP in Cisco Catalyst switches. VLANService also
   represents the function performed by the switch as a participant in
   such a protocol.  VLANService must be subclassed so that instances
   can be distinguished by their class. If there is a name assigned to a
   set of VLAN-aware switches, e.g., the VTP domain name in Cisco
   Catalyst switches, use the Name attribute inherited from dmtfService cim22Service
   to store the name. A VLANService should be instantiated in a VLAN-
   aware switch even if there is no GVRP-like protocol.

      ( <oid-oc349> <oid-oc348> NAME 'dmtfVLANService' 'cim22VLANService'
        DESC 'represents 'VLANService represents the VLAN aspects of the
              function performed by a
           switch.' switch. Some VLAN-aware devices
              participate in protocols where VLAN information is
              propagated among switches, e.g., GVRP in 802.1Q switches
              and VTP in Cisco Catalyst switches. VLANService also
              represents the function performed by the switch as a
              participant in such a protocol.VLANService must be
              subclassed so that instances can be distinguished by their
              class. If there is a name assigned to a set of VLAN-aware
              switches, e.g., the VTP domain name in Cisco Catalyst
              switches, use the Name attribute inherited from cim22Service
              to store the name.  A VLANService should be instantiated in a
              VLAN-aware switch even if there is no GVRP-like protocol.'
        SUP dmtfService ABSTRACT cim22Service
      )

2.84 dmtf802dot1QVLANService

   The following content rule specifies the auxiliary classes that may
   be attached to cim22VLANService.

      ( <oid-oc348> NAME 'cim22VLANServiceContentRule'
        DESC 'The auxiliary classes that may be attached to
              cim22VLANService'
        AUX (cim22SwitchServiceVLANAuxClass)
      )

3.81 cim22802dot1QVLANService

   If a switch supports 802.1Q, an instance of this class should be
   instantiated in the switch. If the switch supports GVRP, this class
   represents the function that the switch performs with respect to GVRP.

      ( <oid-oc350> <oid-oc349> NAME 'dmtf802dot1QVLANService' 'cim22802dot1QVLANService'
        DESC 'If a switch supports 802.1Q, an instance of this class
              should be instantiated' instantiated in the switch. If the switch
              supports GVRP, this class represents the function that the
              switch performs with respect to GVRP.'
        SUP dmtfVLANService cim22VLANService
      )

2.85 dmtfSwitchServiceVLANAuxClass

3.82 cim22SwitchServiceVLANAuxClass

   This auxiliary class links SwitchService to a component VLANService.
   In it, groupComponentRef points to a dmtfSwitchService object and
   partComponentRefs point to dmtfVLANService objects.

      ( <oid-oc351> <oid-oc350> NAME 'dmtfSwitchServiceVLANAuxClass' 'cim22SwitchServiceVLANAuxClass'
        DESC 'links 'An association linking SwitchService to a component VLANService.'
              VLANService. Attribute cimGroupComponentRef points to
              cim22SwitchService and attribute cimPartComponentRef points
              to cim22VLANService.'
        SUP dmtfServiceComponentAuxClass cim22ServiceComponentAuxClass AUXILIARY
        MAY (cimGroupComponentRef $ cimPartComponentRef)
      )

2.86 dmtfVLANForAuxClass

3.83 cim22VLANForAuxClass

   An auxiliary class linking SwitchService to a component VLANService.
   In this class, antecedentRefs point to dmtfVLAN objects and
   dependentRefs point to dmtfVLANService objects.

      ( <oid-oc352> <oid-oc351> NAME 'dmtfVLANForAuxClass'
        DESC 'links SwitchService to a component VLANService.' 'cim22VLANForAuxClass'
        SUP dmtfServiceSAPDependencyAuxClass AUXILIARY cim22ServiceSAPDependencyAuxClass
        MAY (cimAntecedentRef $ cimDependentRef)
      )

2.87 dmtfAdapterActiveConnectionAuxClass

3.84 cim22AdapterActiveConnectionAuxClass

   This auxiliary class shows that a NetworkAdapter is using the
   referenced PhysicalConnector to output to the network. This
   relationship is important when the Adapter can choose to output from
   one of several Connectors. The Connectors may be associated with the
   NetworkAdapter in a Realizes relationship - but this is not required.
   This association provides additional information (i.e., 'in use for
   communication') that makes it different from the information provided
   by the Realizes association.  In this class, antecedentRefs point to
   dmtfPhysicalConnector objects and dependentRefs point to
   dmtfNetworkAdapter objects.

      ( <oid-at781> NAME 'active'
        DESC 'TRUE shows that this connection is active.'
        SYNTAX boolean SINGLE-VALUE
      )

      ( <oid-oc353> <oid-oc352> NAME 'dmtfAdapterActiveConnectionAuxClass' 'cim22AdapterActiveConnectionAuxClass'
        DESC 'shows 'The AdapterActiveConnection relationship indicates that a
              NetworkAdapter is using the referenced PhysicalConnector to
              output to the network.' network. This relationship is important when
              the Adapter can choose to output from one of several
              Connectors. The Connectors may be associated with the
              NetworkAdapter in a Realizes relationship - but this is not
              required. This association provides additional information
              (i.e., "in use for communication") that makes it different
              than the information provided by the Realizes association.
              Attribute cimAntecedentRef points to cim22PhysicalConnector
              and attribute cimDependentRef points to cim22NetworkAdapter.'
        SUP dmtfDependencyAuxClass cim22DependencyAuxClass AUXILIARY
        MUST (active)
        MAY (cimAntecedentRef $ cimDependentRef $ cimActive)
      )

2.88 dmtfEndpointIdentityAuxClass

3.85 cim22EndpointIdentityAuxClass

   This auxiliary class shows that two ProtocolEndpoints represent
   different aspects of the same underlying address or protocol-specific
   ID. This association refines dmtfLogicalIdentityAuxClass cim22LogicalIdentityAuxClass by
   restricting it to the Endpoint level and defining its use in well
   understood scenarios. One of these scenarios is to represent that an
   Endpoint has both 'LAN' and protocol-specific aspects. For example,
   an Endpoint could be both a LANEndpoint as well as a DHCPEndpoint.
   In this class, both systemElementRefs and sameElementRefs point to
   dmtfProtocolEndpoint objects.

      ( <oid-oc354> <oid-oc353> NAME 'dmtfEndpointIdentityAuxClass' 'cim22EndpointIdentityAuxClass'
        DESC 'shows 'EndpointIdentity indicates that two ProtocolEndpoints
              represent different aspects of the same underlying address
              or protocol-specific
          ID.'
       SUP dmtfLogicalIdentityAuxClass AUXILIARY
    MUST (systemElement $ sameElement)
   )

3. DIT Content Rules

   The following DIT Content Rules apply to objects in this schema.
   These content rules reference not only auxiliary classes in this
   draft but auxiliary classes from other DMTF CIM models [5, 6, 7, 8, 9].

      ( <oid-oc267> NAME 'dmtfNetworkServiceContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfNetworkService class'
        AUX (dmtfLogicalNetworkServiceAuxClass $
          dmtfProvidesEndpointAuxClass)
      )

      ( <oid-oc268> NAME 'dmtfForwardingServiceContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfForwardingService class'
        AUX (dmtfForwardsAmongAuxClass)
      )

      ( <oid-oc269> NAME 'dmtfAutonomousSystemContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfAutonomousSystem class'

        AUX (dmtfBGPClustersInASAuxClass $ dmtfRoutersInASAuxClass $
          dmtfASBGPEndpointsAuxClass $ dmtfConfederationAuxClass $
          dmtfConfederationAuxClass)
      )

      ( <oid-oc270> NAME 'dmtfLogicalNetworkContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfLogicalNetwork class'
        AUX (dmtfLogicalNetworkServiceAuxClass $
          dmtfInLogicalNetworkAuxClass)
      )

      ( <oid-oc274> NAME 'dmtfProtocolEndpointContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfProtocolEndpoint class'
        AUX (dmtfForwardsAmongAuxClass $ dmtfInLogicalNetworkAuxClass $
          dmtfActiveConnectionAuxClass $ dmtfActiveConnectionAuxClass $
          dmtfBindsToAuxClass $ dmtfProvidesEndpointAuxClass $
          dmtfCalculatesAmongAuxClass $
          dmtfEndpointIdentityAuxClass)
      )

      ( <oid-oc276> NAME 'dmtfLANEndpointContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfLANEndpoint class'
        AUX (dmtfInSegmentAuxClass $ dmtfBindsToLANEndpointAuxClass $
          dmtfSwitchableAuxClass)
      )

      ( <oid-oc277> NAME 'dmtfLANSegmentContentRule'
        DESC 'shows what auxiliary classes may go with the dmtfLANSegment
           class'
        AUX (dmtfInSegmentAuxClass)
      )

      ( <oid-oc283> NAME 'dmtfBGPProtocolEndpointContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfBGPProtocolEndpoint class'
        AUX (dmtfRoutesBGPAuxClass $ dmtfASBGPEndpointsAuxClass)
      )

      ( <oid-oc286> NAME 'dmtfIPRouteContentRule'
        DESC 'shows what auxiliary classes may go with the dmtfIPRoute
           class'
        AUX (dmtfCalculatedRoutesAuxClass)
      )

      ( <oid-oc289> NAME 'dmtfBGPIPRouteContentRule'
        DESC 'shows what auxiliary classes may go with the dmtfBGPIPRoute
           class'
        AUX (dmtfRoutesBGPAuxClass $ dmtfBGPAttributesForRouteAuxClass)
      )

      ( <oid-oc291> NAME 'dmtfBGPClusterContentRule'
        DESC 'shows what auxiliary classes may go with the dmtfBGPCluster
           class'
        AUX (dmtfRoutersInBGPClusterAuxClass $
          dmtfBGPClustersInASAuxClass $ dmtfReflectorServiceAuxClass $
          dmtfReflectorClientServiceAuxClass $
          dmtfReflectorNonClientServiceAuxClass)
      )

      ( <oid-oc298> NAME 'dmtfRouteCalculationServiceContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfRouteCalculationService class'
        AUX (dmtfCalculatedRoutesAuxClass $
          dmtfEGPRouteCalcDependencyAuxClass $
          dmtfEGPRouteCalcDependencyAuxClass $
          dmtfCalculatesAmongAuxClass)
      )

      ( <oid-oc301> NAME 'dmtfBGPServiceContentRule'
        DESC 'shows what auxiliary classes may go with the dmtfBGPService
           class'
        AUX (dmtfReflectorServiceAuxClass $
          dmtfReflectorClientServiceAuxClass $
          dmtfReflectorNonClientServiceAuxClass $
          dmtfBGPRoutingPolicyAuxClass $
             dmtfBGPPeerGroupServiceAuxClass $
          dmtfBGPAdminDistanceAuxClass $
          dmtfBGPServiceAttributesAuxClass)
      )

      ( <oid-oc302> NAME 'dmtfBGPPeerGroupContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfBGPPeerGroup class'
        AUX (dmtfBGPPeerGroupServiceAuxClass $
          dmtfBGPPeerUsesRouteMapAuxClass $
          dmtfInBGPPeerGroupAuxClass)
      )

      ( <oid-oc306> NAME 'dmtfFilterEntryContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfFilterEntry class'
        AUX (dmtfEntriesInFilterListAuxClass)
      )
      ( <oid-oc307> NAME 'dmtfFilterListContentRule'
        DESC 'shows what auxiliary classes may go with the dmtfFilterList
           class'
        AUX (dmtfEntriesInFilterListAuxClass $
          dmtfListsInRoutingPolicyAuxClass $
          dmtfFilterListsInBGPRouteMapAuxClass)
      )

      ( <oid-oc308> NAME 'dmtfRoutingPolicyContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfRoutingPolicy class'
        AUX (dmtfListsInRoutingPolicyAuxClass $
          dmtfBGPRoutingPolicyAuxClass $
          dmtfBGPRouteMapsInRoutingPolicyAuxClass $
          dmtfFilteredBGPAttributesAuxClass)
      )

      ( <oid-oc313> NAME 'dmtfAdministrativeDistanceContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfAdministrativeDistance class'
        AUX (dmtfBGPAdminDistanceAuxClass)
      )

      ( <oid-oc315> NAME 'dmtfBGPRouteMapContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfBGPRouteMap class'
        AUX (dmtfBGPRouteMapsInRoutingPolicyAuxClass $
          dmtfBGPPeerUsesRouteMapAuxClass $
          dmtfFilterListsInBGPRouteMapAuxClass)
      )

      ( <oid-oc321> NAME 'dmtfBGPAttributesContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfBGPAttributes class'
        AUX (dmtfFilteredBGPAttributesAuxClass)
      )

      ( <oid-oc323> NAME 'dmtfBGPPathAttributesContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfBGPPathAttributes class'
        AUX (dmtfBGPAttributesForRouteAuxClass $
          dmtfBGPServiceAttributesAuxClass)
      )

      ( <oid-oc326> NAME 'dmtfSwitchServiceContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfSwitchService class'
        AUX (dmtfSwitchesAmongAuxClass $
          dmtfSwitchServiceTransparentBridgingAuxClass $
          dmtfSwitchServiceSpanningTreeAuxClass $
          dmtfSwitchServiceSourceRoutingAuxClass $
          dmtfSwitchServiceVLANAuxClass)
      )

      ( <oid-oc327> NAME 'dmtfSwitchPortContentRule'
        DESC 'shows what auxiliary classes may go with the dmtfSwitchPort
           class'
        AUX (dmtfSwitchesAmongAuxClass $ dmtfSwitchableAuxClass $
          dmtfSwitchPortSpanningTreeAuxClass $
          dmtfSwitchPortDynamicForwardingAuxClass $
          dmtfSwitchPortStaticForwardingAuxClass $
          dmtfSwitchPortPairAuxClass $ dmtfSwitchPortPairAuxClass $
          dmtfSwitchPortSourceRoutingAuxClass $
          dmtfInboundVLANAuxClass $ dmtfOutboundVLANAuxClass)
      )

      ( <oid-oc330> NAME 'dmtfTransparentBridgingServiceContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfTransparentBridgingService class'
        AUX (dmtfSwitchServiceTransparentBridgingAuxClass $
          dmtfRelatedTransparentBridgingServiceAuxClass $
          dmtfRelatedSpanningTreeAuxClass)
      )

      ( <oid-oc331> NAME 'dmtfSpanningTreeServiceContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfSpanningTreeService class'
        AUX (dmtfSwitchPortSpanningTreeAuxClass $
          dmtfSwitchServiceSpanningTreeAuxClass $
          dmtfRelatedSpanningTreeAuxClass)
      )

      ( <oid-oc333> NAME 'dmtfDynamicForwardingEntryContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfDynamicForwardingEntry class'
        AUX (dmtfSwitchPortDynamicForwardingAuxClass)
      )

      ( <oid-oc335> NAME 'dmtfStaticForwardingEntryContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfStaticForwardingEntry class'
        AUX (dmtfSwitchPortStaticForwardingAuxClass)
      )

      ( <oid-oc340> NAME 'dmtfSourceRoutingServiceContentRule'
        DESC 'shows what auxiliary classes may go with the
           dmtfSourceRoutingService class'
        AUX (dmtfSwitchServiceSourceRoutingAuxClass $
          dmtfSwitchPortSourceRoutingAuxClass)
      )

      ( <oid-oc344> NAME 'dmtfVLANContentRule'
        DESC 'shows what auxiliary classes may go with ID. This association refines the dmtfVLAN
           class'
        AUX (dmtfRelatedTransparentBridgingServiceAuxClass $
          dmtfVLANForAuxClass $ dmtfInboundVLANAuxClass $
          dmtfOutboundVLANAuxClass)
      )

      ( <oid-oc349> NAME 'dmtfVLANServiceContentRule'
        DESC 'shows what auxiliary classes may go with
              LogicalIdentity superclass by restricting it to the
           dmtfVLANService class'
        AUX (dmtfSwitchServiceVLANAuxClass
              Endpoint level and defining its use in well understood
              scenarios. One of these scenarios is to represent that an
              Endpoint has both "LAN" and protocol-specific aspects. For
              example, an Endpoint could be both a LANEndpoint as well as
              a DHCPEndpoint. Both attributes point to
              cim22ProtocolEndpoint objects.'
        SUP cim22LogicalIdentityAuxClass AUXILIARY
        MAY (cimSystemElementRef $ dmtfVLANForAuxClass) cimSameElementRef)
      )

4. References

   Request For Comments (RFC) and Internet Draft documents are available
   from numerous mirror sites.

         [1]         M. Wahl, T. Howes, S. Kille, "Lightweight Directory
                     Access Protocol (v3)," RFC 2251, Decemeber 1997.

         [2]         M. Wahl, A. Coulbeck, T. Howes, S. Kille, "Lightweight "Light-
                     weight Directory Access Protocol (v3): Attribute
                     Synatx Defini-
            tions," Definitions," RFC 2252, December 1997.

         [3]         Ryan Moats, Gerald Maziarski, John Strassner,
                     "Extensible Match Rule to Dereference Pointers",
                     Internet Draft (work in progress), June 1999.

         [4]         DMTF, "CIM Network Model, v2.2".

         [5]         Ryan Moats, Gerald Maziarski, John Strassner, "LDAP
                     Schema for the DMTF Core CIM v2.2 Model", September Internet
                     Draft (work in progress), December 1999.

         [6]         Ryan Moats, Gerald Maziarski, John Strassner, "LDAP
                     Schema for the DMTF Device CIM v2.2 Model", September Inter-
                     net Draft (work in progress), December 1999.

         [7]         Ryan Moats, Gerald Maziarski, Ma<ziarski, John Strassner,
                     "LDAP Schema for the DMTF Application CIM v2.1
                     Model", October Internet Draft (work in progress), December
                     1999.

         [8]         Ryan Moats, Gerald Maziarski, John Strassner, "LDAP
                     Schema for the DMTF System CIM v2.2 Model", October Inter-
                     net Draft (work in progress), December 1999.

         [9]         Ryan Moats, Gerald Maziarski, John Strassner, "LDAP
                     Schema for the DMTF Physical CIM v2.2 Model", October
                     Internet Draft (work in progress), December 1999.

5. Author's Addresses

   Ryan Moats               Jerry Maziarski           John Strassner
   15621 Drexel Circle      Room C3-3Z01              Cisco Systems, Bldg 1
   Omaha, NE 68135          200 S. Laurel Ave.        170 West Tasman Drive
   USA                      Middletown, NJ 07748      San Jose, CA 95134
   E-mail: jayhawk@att.com  USA                       E-mail:
johns@cisco.com
                            E-mail: gfm@qsun.att.com