GENWiki

Premier IT Outsourcing and Support Services within the UK

User Tools

Site Tools


rfc:rfc4498

Network Working Group G. Keeni Request for Comments: 4498 Cyber Solutions Inc. Category: Experimental May 2006

                 The Managed Object Aggregation MIB

Status of This Memo

 This memo defines an Experimental Protocol for the Internet
 community.  It does not specify an Internet standard of any kind.
 Discussion and suggestions for improvement are requested.
 Distribution of this memo is unlimited.

Copyright Notice

 Copyright (C) The Internet Society (2006).

IESG Note

 The content of this RFC was at one time considered by the IETF, and
 therefore it may resemble a current IETF work in progress or a
 published IETF work.  This RFC is not a candidate for any level of
 Internet Standard.  The IETF disclaims any knowledge of the fitness
 of this RFC for any purpose and in particular notes that the decision
 to publish is not based on IETF review for such things as security,
 congestion control, or inappropriate interaction with deployed
 protocols.  The RFC Editor has chosen to publish this document at its
 discretion.  Readers of this RFC should exercise caution in
 evaluating its value for implementation and deployment.  See RFC 3932
 for more information.

Abstract

 This memo defines a portion of the Management Information Base (MIB),
 the Aggregation MIB modules, for use with network management
 protocols in the Internet community.  In particular, the Aggregation
 MIB modules will be used to configure a network management agent to
 aggregate the values of a user-specified set of Managed Object
 instances and to service queries related to the aggregated Managed
 Object instances.

Keeni Experimental [Page 1] RFC 4498 The Managed Object Aggregation MIB May 2006

Table of Contents

 1. The Internet-Standard Management Framework ......................2
 2. Background ......................................................2
 3. MO Aggregation: The Concept .....................................3
 4. The Requirements for Managed Object Aggregation .................6
 5. MIB Design ......................................................6
 6. The Aggregation MIB Modules .....................................7
 7. Security Considerations ........................................25
 8. IANA Considerations ............................................27
 9. References .....................................................27
    9.1. Normative References ......................................27
    9.2. Informative References ....................................27
 10. Acknowledgements ..............................................28

1. The Internet-Standard Management Framework

 For a detailed overview of the documents that describe the current
 Internet-Standard Management Framework, please refer to section 7 of
 RFC 3410 [RFC3410].
 Managed objects are accessed via a virtual information store, termed
 the Management Information Base or MIB.  MIB objects are generally
 accessed through the Simple Network Management Protocol (SNMP).
 Objects in the MIB are defined using the mechanisms defined in the
 Structure of Management Information (SMI).  This memo specifies a MIB
 module that is compliant to the SMIv2, which is described in STD 58,
 RFC 2578 [RFC2578], STD 58, RFC 2579 [RFC2579] and STD 58, RFC 2580
 [RFC2580].
 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
 "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
 document are to be interpreted as described in BCP 14, RFC 2119
 [RFC2119].

2. Background

 For the purpose of management, it is necessary to access Managed
 Objects (MOs).  The SNMP framework provides a mechanism for naming
 and describing managed objects.  These objects are accessed via a
 virtual information store termed a Management Information Base (MIB).
 MIBs have been defined by equipment, protocol, and application
 developers to provide management access to the managed entities.  We
 will call the MOs defined in these MIBs simple MOs (SMO).  Management
 applications will access one or more instances of these SMOs, one or
 more times, to monitor the target entity.

Keeni Experimental [Page 2] RFC 4498 The Managed Object Aggregation MIB May 2006

 There is a cost associated with accessing MOs.  The cost is the
 network bandwidth and the packet header processing overhead at the
 command generator (manager) and the command responder (agent).  This
 cost constrains the number of MO instances that can be polled and the
 interval at which polling can be carried out.
 The overhead reduction can be carried out by reducing the number of
 query-response packets.  This will reduce the packet processing
 overhead, and to some extent, the bandwidth.
 The payloads in a typical SNMP "get" packet and the corresponding
 response are as shown in Figure 1.  In this example, polling is
 carried out for 'n' Managed Object instances OID1, OID2, ..., OIDn.
 It is obvious that a substantial amount of the payload in an SNMP
 packet consists of the OIDs.

3. MO Aggregation: The Concept

 In this document, a mechanism of MO aggregation for payload
 compression is defined.  The idea is simple: we introduce the concept
 of an Aggregate MO (AgMO).  An AgMO is just another MO as far as the
 SNMP protocol is concerned.  No new protocol operations will be
 required to handle these MOs.  As in the case of any other MO, it
 requires additional instrumentation at the command responder (agent)
 and at the (command generator) manager.  In this mechanism, the user
 defines an Aggregate MO (AgMO) corresponding to one or more
 (predefined) MO instances.  Semantically, the value of an AgMO
 instance will be equivalent to the concatenation of the values of the
 corresponding MO instances.  The order of the concatenation will be
 determined by the order in which the MO instances are specified in
 the AgMO definition.  With the definitions done, the user can, as and
 when the necessity arises, do an SNMP 'get' on instances of the AgMO
 to fetch the value of the constituent MO instances.  There is
 substantial savings on bandwidth, as only one instance object
 identifier is carried in the request and the response.  In the normal
 case, instance object identifiers for each of the constituent MO
 instances would be carried in the requests and the responses.  This
 is the basic concept of Aggregate Managed Objects.  For every AgMO,
 an ErrorStatus Managed Object is defined.  This MO indicates errors,
 if any, that have been encountered while fetching the values of the
 constituent MO instances.  The error indication is comprised of the
 index of the MO instance and the corresponding error.  If there are
 no errors, the ErrorStatus Managed Object instance will have a null
 value.  This is the basic concept of Aggregate Managed Objects.

Keeni Experimental [Page 3] RFC 4498 The Managed Object Aggregation MIB May 2006

 The concepts are explained in Figure 2.  An aggregate managed object,
 AgMOx, has been defined for the MO instances MOI1, ... MOIn.  The
 value of an instance of AgMOx will be a concatenation of the values
 of MOI1, ... MOIn, in that order.
    Polling for MO Instances [MOI1, MOI2, ... MOIn]:
              +--------+------+-------+... -+------+------+
       Query: |Get req | MOI1 | NULL  |     | MOIn | NULL |
              +--------+------+-------+... -+------+------+
              +--------+------+-------+... -+------+------+
    Response: |Get resp| MOI1 | Val1  |     | MOIn | Valn |
              +--------+------+-------+... -+------+------+
                   Figure 1.  Polling for MO instances
    Polling for an instance (AgMOIx) of an aggregate MO (AgMOx):
    AgMOx = aggr{AgMOI1, AgMOI2, ......AgMOIn}
              +--------+--------+-------+
       Query: |Get req | AgMOIx | NULL  |
              +--------+--------+-------+
              +--------+--------+------------------------+
    Response: |Get resp| AgMOIx |    Val1,Val2,...,Valn  |
              +--------+--------+------------------------+
                   Figure 2.  MO aggregation
 As a further refinement of the AgMO, we introduce the Time-Based
 Aggregated Managed Object (TAgMO).  The TAgMO is an MO that
 represents the values of a user-specified MO instance sampled at
 user-specified intervals for a user-specified number of times.  In
 this case, the user defines a TAgMO by specifying the MO instance
 that needs to be sampled, the sampling interval, and the desired
 number of samples that will be included in one TAgMO.  The value of a
 TAgMO instance will include the timestamp (sysUpTime) at which the
 first sample was taken.  The start time is not specified when the
 TAgMO is defined.  Implementations may choose to align the start time
 with the appropriate time boundaries (e.g., seconds, minutes, hours).
 With the definitions, the user can do an SNMP "get" on an instance of
 the TAgMO to fetch the values of the constituent MO instance sampled
 at the specified intervals.  This is the concept of Time-Based
 aggregation.

Keeni Experimental [Page 4] RFC 4498 The Managed Object Aggregation MIB May 2006

 Polling for 'n' samples of an MO Instance [MOI] at an interval 'i':
              Query               Time         Response
              =====               ====         ========
    +--------+-----+-----------+
    |Get req | MOI |    NULL   |  t
    +--------+-----+-----------+  :    +--------+-----+--------------+
                                  :    |Get resp| MOI |    Val(t)    |
                                  :    +--------+-----+--------------+
    +--------+-----+-----------+  t+i
    |Get req | MOI |    NULL   |  :
    +--------+-----+-----------+  :    +--------+-----+--------------+
                                  :    |Get resp| MOI |    Val(t+i)  |
                                  X    +--------+-----+--------------+
                                  X
                                  :
    +--------+-----+-----------+  t+(n-1)i
    |Get req | MOI |    NULL   |  :
    +--------+-----+-----------+  :    +--------+-----+--------------+
                                  :    |Get resp| MOI | Val(t+(n-1)i)|
                                       +--------+-----+--------------+
       Figure 3.  Periodic polling for samples of an MO instance
 Polling for an instance (TAgMOIx) of a Time-Based aggregate MO
 (TAgMOx):
 TAgMOx = aggr{'n' polled samples of an instance (MOI) of MO
                at intervals       = 'i' microseconds}
           +--------+---------+-------+
    Query: |Get req | TAgMOIx | NULL  |
           +--------+---------+-------+
           +--------+---------+--------------------------------------+
 Response: |Get resp| TAgMOIx | t,Val(t),Val(t+i),.,Val(t + (n-1)*i) |
           +--------+---------+--------------------------------------+
                 Figure 4.  Time-Based aggregation
 The TAgMO instance is a "bucket" of data representing the value of
 the corresponding MO instance sampled at 'i' microsecond intervals,
 'n' times (i.e., over a 'n' X 'i' microsecond window).  The TAgMO
 instance value gets updated at 'n' X 'i' microsecond intervals.

Keeni Experimental [Page 5] RFC 4498 The Managed Object Aggregation MIB May 2006

4. The Requirements for Managed Object Aggregation

 The general requirements of managed object aggregation are as
 follows:
    o It should lead to fewer packets.
    o It should lead to less bandwidth consumption.
    o It should not lead to loss of information.
 In the case of Time-Based aggregation, there will be a delay involved
 in getting the actual data.  The minimum delay in this case will be
 the duration of the aggregation.
 The manager application is expected to configure AgMOs (Aggregate
 MOs) and TAgMOs (Time-Based Aggregate MOs) with care so that the
 response size is not too large.  In case the resultant response size
 is larger than the maximum acceptable message size of the originator
 or larger than the local maximum message size, then the error-status
 field will be set to "tooBig".
 Note that an aggregate MO can be defined only when all the
 constituent MO instances of interest are known.  This scheme cannot
 be employed if a manager/application does not know the specific MO
 instances (of interest) that are serviced by the management target.
 In such cases, the application may "discover" the MO instances of
 interest by some means, e.g., by "walking" through the MIB tree on
 the agent.  According to the results of the "walk", the application
 can define an appropriate aggregate MO that will serve the purpose.
 Considering the cost involved in this exercise, this method is
 recommended only if the aggregate MO will be used repeatedly, so that
 the benefits of aggregation outweigh the costs of configuration.

5. MIB Design

 The basic principle has been to keep the MIB as simple as possible
 and at the same time to make it flexible enough that a large number
 of users and applications can use the MIB to configure aggregate MOs
 conveniently.
 Two separate MIB modules have been defined.  The AggrMIB supports the
 aggregation of independent MO instances, while TAggrMIB supports the
 aggregation of several samples of the same MO instance.  Both of
 these MIB modules use the textual conventions defined in RMON-MIB
 [RFC2819] and SNMP-FRAMEWORK-MIB [RFC3411].

Keeni Experimental [Page 6] RFC 4498 The Managed Object Aggregation MIB May 2006

 The AggrMIB is comprised of three tables, described below.
  1. The aggrCtlTable controls the aggregation process. Each row in

this table defines the attributes of the aggregate object defined

    in the aggrMOTable.
  1. The aggrMOTable defines the primary MO-based aggregation, i.e.,

the MOs that will be aggregated.

  1. The aggrDataTable contains the details of the aggregated object.
 The TAggrMIB is comprised of two tables described below.
  1. The tAggrCtlTable controls the aggregation process. Each row in

this table defines the attributes of the aggregate object defined

    in the aggrMOTable.
  1. The tAggrDataTable contains the details of the aggregated object.

6. The Aggregation MIB Modules

    AGGREGATE-MIB DEFINITIONS ::= BEGIN
     IMPORTS
       MODULE-IDENTITY,  experimental, Unsigned32,
       OBJECT-TYPE, Opaque
                  FROM SNMPv2-SMI
       OwnerString
                  FROM RMON-MIB
       RowStatus, StorageType, TEXTUAL-CONVENTION
                  FROM SNMPv2-TC
       MODULE-COMPLIANCE, OBJECT-GROUP
                  FROM SNMPv2-CONF
       SnmpAdminString
                  FROM SNMP-FRAMEWORK-MIB;
   aggrMIB MODULE-IDENTITY
        LAST-UPDATED "200604270000Z"        --  27th April, 2006
        ORGANIZATION "Cyber Solutions Inc. NetMan Working Group"
        CONTACT-INFO
       "                      Glenn Mansfield Keeni
                      Postal: Cyber Solutions Inc.
                              6-6-3, Minami Yoshinari
                              Aoba-ku, Sendai, Japan 989-3204.
                         Tel: +81-22-303-4012
                         Fax: +81-22-303-4015
                      E-mail: glenn@cysols.com
           Support Group E-mail: mibsupport@cysols.com"

Keeni Experimental [Page 7] RFC 4498 The Managed Object Aggregation MIB May 2006

           DESCRIPTION
                   "The MIB for servicing aggregate objects.
                    Copyright (C) The Internet Society (2006).  This
                    version of this MIB module is part of RFC 4498;
                    see the RFC itself for full legal notices.
                   "
           REVISION    "200604270000Z"      -- 27th April, 2006
           DESCRIPTION "Initial version, published as RFC 4498."
                ::= { experimental 123 }
    AggrMOErrorStatus ::= TEXTUAL-CONVENTION
      STATUS       current
      DESCRIPTION
        "This data type is used to model the error status of the
         constituent MO instances.  The error status for a
         constituent MO instance is given in terms of two elements:
           o The moIndex, which indicates the position of the MO
             instance (starting at 1) in the value of the aggregated
             MO instance.
           o The moError, which indicates the error that was
             encountered in fetching that MO instance.
         The syntax in ASN.1 Notation will be
         ErrorStatus :: = SEQUENCE {
            moIndex  Integer32,
            moError  SnmpPduErrorStatus
         }
         AggrMOErrorStatus ::= SEQUENCE OF {
            ErrorStatus
         }
         Note1: The command responder will supply values for all
                constituent MO instances, in the same order in
                which the MO instances are specified for the AgMO.
                If an error is encountered for an MO instance, then
                the corresponding value will have an ASN.1 value NULL,
                and an error will be flagged in the corresponding
                AggrMOErrorStatus object.
                Only MOs for which errors have been encountered will
                have their corresponding moIndex and moError values
                set.
         Note2: The error code for the component MO instances will be
                in accordance with the SnmpPduErrorStatus TC defined
                in the DISMAN-SCHEDULE-MIB [RFC3231].
         Note3: The command generator will need to know
                constituent MO instances and their order to correctly
                interpret AggrMOErrorStatus.
        "
      SYNTAX      Opaque (SIZE (0..1024))

Keeni Experimental [Page 8] RFC 4498 The Managed Object Aggregation MIB May 2006

    AggrMOValue ::= TEXTUAL-CONVENTION
      STATUS       current
      DESCRIPTION
        "This data type is used to model the aggregate
         MOs.  It will have a format dependent on the constituent
         MOs, a sequence of values.  The syntax in ASN.1 Notation will
         be
         MOValue :: = SEQUENCE {
              value ObjectSyntax
         }
         where 'value' is the value of a constituent MO instance.
         AggrMOValue :: = SEQUENCE OF {
             MOValue
         }
         Note: The command generator will need to know the
         constituent MO instances and their order to
         correctly interpret AggrMOValue."
      SYNTAX      Opaque (SIZE (0..1024))
    AggrMOCompressedValue ::= TEXTUAL-CONVENTION
      STATUS       current
      DESCRIPTION
        "This data type is used to model the compressed
         aggregate MOs."
      SYNTAX      OCTET STRING (SIZE (0..1024))
  1. -
  2. - The aggregation control table
  3. - There will be a row for each aggregate MO
  4. -

aggrCtlTable OBJECT-TYPE

         SYNTAX  SEQUENCE OF AggrCtlEntry
         MAX-ACCESS  not-accessible
         STATUS current
         DESCRIPTION
           "A table that controls the aggregation of the MOs."
         ::= {aggrMIB 1}
     aggrCtlEntry OBJECT-TYPE
         SYNTAX  AggrCtlEntry
         MAX-ACCESS  not-accessible
         STATUS  current
         DESCRIPTION
           "A row of the control table that defines one aggregated
            MO.

Keeni Experimental [Page 9] RFC 4498 The Managed Object Aggregation MIB May 2006

            Entries in this table are required to survive a reboot
            of the managed entity depending on the value of the
            corresponding aggrCtlEntryStorageType instance.
           "
         INDEX {aggrCtlEntryID }
         ::= {aggrCtlTable 1 }
     AggrCtlEntry ::= SEQUENCE {
        aggrCtlEntryID
                      SnmpAdminString,
        aggrCtlMOIndex
                      Unsigned32,
        aggrCtlMODescr
                      SnmpAdminString,
        aggrCtlCompressionAlgorithm
                      INTEGER,
        aggrCtlEntryOwner
                      OwnerString,
        aggrCtlEntryStorageType
                      StorageType,
        aggrCtlEntryStatus
                      RowStatus
     }
    aggrCtlEntryID OBJECT-TYPE
         SYNTAX SnmpAdminString (SIZE(1..32))
         MAX-ACCESS not-accessible
         STATUS current
         DESCRIPTION
           "A locally unique, administratively assigned name
            for this aggregated MO.  It is used as an index to
            uniquely identify this row in the table."
         ::= { aggrCtlEntry 1 }
    aggrCtlMOIndex OBJECT-TYPE
         SYNTAX Unsigned32 (1..2147483647)
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
           "A pointer to a group of MOs identified by aggrMOEntryID
            in the aggrMOTable.  This is the group of MOs that will
            be aggregated."
         ::= { aggrCtlEntry 2 }
    aggrCtlMODescr OBJECT-TYPE
         SYNTAX SnmpAdminString (SIZE(0..64))
         MAX-ACCESS read-create
         STATUS current

Keeni Experimental [Page 10] RFC 4498 The Managed Object Aggregation MIB May 2006

         DESCRIPTION
           "A textual description of the object that is
            being aggregated."
         ::= {aggrCtlEntry 3}
  1. - only one compression algorithm is defined as of now.

aggrCtlCompressionAlgorithm OBJECT-TYPE

         SYNTAX INTEGER {
                none      (1),
                deflate   (2)
         }
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
           "The compression algorithm that will be used by
            the agent to compress the value of the aggregated
            object.
            The deflate algorithm and corresponding data format
            specification is described in RFC 1951.  It is
            compatible with the widely used gzip utility.
           "
         REFERENCE
           "RFC1951 : DEFLATE Compressed Data Format Specification
            version 1.3
           "
         DEFVAL { none }
         ::= {aggrCtlEntry 4}
    aggrCtlEntryOwner OBJECT-TYPE
         SYNTAX OwnerString
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
           "The entity that created this entry."
         ::= {aggrCtlEntry 5}
    aggrCtlEntryStorageType OBJECT-TYPE
         SYNTAX StorageType
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "This object defines whether the parameters defined in
             this row are kept in volatile storage and lost upon
             reboot or backed up by non-volatile (permanent)
             storage.
             Conceptual rows having the value 'permanent' need not
             allow write-access to any columnar objects in the row.

Keeni Experimental [Page 11] RFC 4498 The Managed Object Aggregation MIB May 2006

            "
         ::= {aggrCtlEntry 6}
    aggrCtlEntryStatus OBJECT-TYPE
         SYNTAX RowStatus
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "The row status variable, used according to row
             installation and removal conventions.
             Objects in a row can be modified only when the value of
             this object in the corresponding conceptual row is not
             'active'.
             Thus, to modify one or more of the objects in this
             conceptual row,
               a. change the row status to 'notInService',
               b. change the values of the row, and
               c. change the row status to 'active'.
             The aggrCtlEntryStatus may be changed to 'active' if
             all the MOs in the conceptual row have been assigned
             valid values.
            "
         ::= {aggrCtlEntry 7}
  1. -
  2. - The Table of primary(simple) MOs
  3. -

aggrMOTable OBJECT-TYPE

         SYNTAX  SEQUENCE OF AggrMOEntry
         MAX-ACCESS  not-accessible
         STATUS current
         DESCRIPTION
            "The table of primary(simple) MOs that will be aggregated.
             Each row in this table represents a MO that will be
             aggregated.  The aggrMOEntryID index is used to identify
             the group of MOs that will be aggregated.  The
             aggrMOIndex instance in the corresponding row of the
             aggrCtlTable will have a value equal to the value of
             aggrMOEntryID.  The aggrMOEntryMOID index is used to
             identify an MO in the group.
            "
         ::= {aggrMIB 2}
     aggrMOEntry OBJECT-TYPE
         SYNTAX  AggrMOEntry
         MAX-ACCESS  not-accessible
         STATUS  current
         DESCRIPTION

Keeni Experimental [Page 12] RFC 4498 The Managed Object Aggregation MIB May 2006

            "A row of the table that specifies one MO.
             Entries in this table are required to survive a reboot
             of the managed entity depending on the value of the
             corresponding aggrMOEntryStorageType instance.
            "
         INDEX { aggrMOEntryID, aggrMOEntryMOID }
         ::= {aggrMOTable 1 }
     AggrMOEntry ::= SEQUENCE {
        aggrMOEntryID
                      Unsigned32,
        aggrMOEntryMOID
                      Unsigned32,
        aggrMOInstance
                      OBJECT IDENTIFIER,
        aggrMODescr
                      SnmpAdminString,
        aggrMOEntryStorageType
                      StorageType,
        aggrMOEntryStatus
                      RowStatus
     }
    aggrMOEntryID OBJECT-TYPE
         SYNTAX Unsigned32 (1..2147483647)
         MAX-ACCESS not-accessible
         STATUS current
         DESCRIPTION
           "An index uniquely identifying a group of MOs
            that will be aggregated."
         ::= { aggrMOEntry 1 }
    aggrMOEntryMOID OBJECT-TYPE
         SYNTAX Unsigned32 (1..65535)
         MAX-ACCESS not-accessible
         STATUS current
         DESCRIPTION
           "An index to uniquely identify an MO instance in the
            group of MO instances that will be aggregated."
         ::= { aggrMOEntry 2 }
    aggrMOInstance OBJECT-TYPE
         SYNTAX OBJECT IDENTIFIER
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
           "The OID of the MO instance, the value of which will
            be sampled by the agent."

Keeni Experimental [Page 13] RFC 4498 The Managed Object Aggregation MIB May 2006

         ::= { aggrMOEntry 3 }
    aggrMODescr OBJECT-TYPE
         SYNTAX SnmpAdminString (SIZE(0..64))
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "A textual description of the object that will
             be aggregated."
         ::= {aggrMOEntry 4}
    aggrMOEntryStorageType OBJECT-TYPE
         SYNTAX StorageType
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "This object defines whether the parameters defined in
             this row are kept in volatile storage and lost upon
             reboot or backed up by non-volatile (permanent)
             storage.
             Conceptual rows having the value 'permanent' need not
             allow write-access to any columnar objects in the row.
            "
         ::= {aggrMOEntry 5}
    aggrMOEntryStatus OBJECT-TYPE
         SYNTAX RowStatus
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "The row status variable, used according to row
             installation and removal conventions.
             Objects in a row can be modified only when the value of
             this object in the corresponding conceptual row is not
             'active'.
             Thus, to modify one or more of the objects in this
             conceptual row,
               a. change the row status to 'notInService',
               b. change the values of the row, and
               c. change the row status to 'active'.
             The aggrMOEntryStatus may be changed to 'active' iff
             all the MOs in the conceptual row have been assigned
             valid values.
            "
         ::= {aggrMOEntry 6}
  1. -
  2. - aggrDataTable: The Table of Data. Each row represents a Data

Keeni Experimental [Page 14] RFC 4498 The Managed Object Aggregation MIB May 2006

  1. - set. aggrCtlEntryID is the key to the table.
  2. - It is used to identify instances of the
  3. - aggregated MO that are present in the table.
  4. -

aggrDataTable OBJECT-TYPE

         SYNTAX  SEQUENCE OF AggrDataEntry
         MAX-ACCESS  not-accessible
         STATUS  current
         DESCRIPTION
            "Each row of this table contains information
             about an aggregateMO indexed by aggrCtlEntryID."
         ::= {aggrMIB 3}
    aggrDataEntry OBJECT-TYPE
         SYNTAX  AggrDataEntry
         MAX-ACCESS  not-accessible
         STATUS  current
         DESCRIPTION
            "Entry containing information pertaining to
             an aggregate MO."
         INDEX {aggrCtlEntryID}
         ::= {aggrDataTable 1 }
    AggrDataEntry ::= SEQUENCE {
       aggrDataRecord
                  AggrMOValue,
       aggrDataRecordCompressed
                  AggrMOCompressedValue,
       aggrDataErrorRecord
                  AggrMOErrorStatus
       }
    aggrDataRecord OBJECT-TYPE
         SYNTAX AggrMOValue
         MAX-ACCESS read-only
         STATUS current
         DESCRIPTION
           "The snapshot value of the aggregated MO.
            Note that the access privileges to this object will be
            governed by the access privileges of the component
            objects.  Thus, an entity attempting to access an
            instance of this MO MUST have access rights to all the
            component instance objects and this MO instance.
           "
         ::= { aggrDataEntry 1}
    aggrDataRecordCompressed OBJECT-TYPE
         SYNTAX AggrMOCompressedValue

Keeni Experimental [Page 15] RFC 4498 The Managed Object Aggregation MIB May 2006

         MAX-ACCESS read-only
         STATUS current
         DESCRIPTION
           "The compressed value of the aggregated MO.
            The compression algorithm will depend on the
            aggrCtlCompressionAlgorithm given in the corresponding
            aggrCtlEntry.  If the value of the corresponding
            aggrCtlCompressionAlgorithm is (1) 'none', then the value
            of all instances of this object will be a string of zero
            length.
            Note that the access privileges to this object will be
            governed by the access privileges of the component
            objects.  Thus, an entity attempting to access an instance
            of this MO MUST have access rights to all the component
            instance objects and this MO instance.
           "
         ::= { aggrDataEntry 2}
    aggrDataErrorRecord OBJECT-TYPE
         SYNTAX AggrMOErrorStatus
         MAX-ACCESS read-only
         STATUS current
         DESCRIPTION
            "The error status corresponding to the MO instances
             aggregated in aggrDataRecord (and
             aggrDataRecordCompressed)."
         ::= { aggrDataEntry 3}
  1. - Conformance information

aggrConformance OBJECT IDENTIFIER ::= { aggrMIB 4 }

    aggrGroups      OBJECT IDENTIFIER ::= { aggrConformance 1 }
    aggrCompliances OBJECT IDENTIFIER ::= { aggrConformance 2 }
  1. - Compliance statements

aggrMibCompliance MODULE-COMPLIANCE

         STATUS  current
         DESCRIPTION
                 "The compliance statement for SNMP entities
                  that implement the AGGREGATE-MIB."
         MODULE  -- this module
             MANDATORY-GROUPS { aggrMibBasicGroup }
         ::= { aggrCompliances 1 }
  1. - Units of conformance

aggrMibBasicGroup OBJECT-GROUP

         OBJECTS {
                    aggrCtlMOIndex,
                    aggrCtlMODescr,

Keeni Experimental [Page 16] RFC 4498 The Managed Object Aggregation MIB May 2006

                    aggrCtlCompressionAlgorithm,
                    aggrCtlEntryOwner,
                    aggrCtlEntryStorageType,
                    aggrCtlEntryStatus,
                    aggrMOInstance,
                    aggrMODescr,
                    aggrMOEntryStorageType,
                    aggrMOEntryStatus,
                    aggrDataRecord,
                    aggrDataRecordCompressed,
                    aggrDataErrorRecord
        }
         STATUS  current
         DESCRIPTION
                 "A collection of objects for aggregation of MOs."
         ::= { aggrGroups 1 }
    END
    TIME-AGGREGATE-MIB DEFINITIONS ::= BEGIN
     IMPORTS
       MODULE-IDENTITY,  experimental,
       OBJECT-TYPE,      Opaque, Integer32
                  FROM SNMPv2-SMI
       OwnerString
                  FROM RMON-MIB
       RowStatus, StorageType, TEXTUAL-CONVENTION
                  FROM SNMPv2-TC
       MODULE-COMPLIANCE, OBJECT-GROUP
                  FROM SNMPv2-CONF
       SnmpAdminString
                  FROM SNMP-FRAMEWORK-MIB;
   tAggrMIB MODULE-IDENTITY
        LAST-UPDATED "200604270000Z"        --  27 April 2006
        ORGANIZATION "Cyber Solutions Inc. NetMan Working Group"
        CONTACT-INFO
       "                      Glenn Mansfield Keeni
                      Postal: Cyber Solutions Inc.
                              6-6-3, Minami Yoshinari
                              Aoba-ku, Sendai, Japan 989-3204.
                         Tel: +81-22-303-4012
                         Fax: +81-22-303-4015
                      E-mail: glenn@cysols.com
           Support Group E-mail: mibsupport@cysols.com"
           DESCRIPTION

Keeni Experimental [Page 17] RFC 4498 The Managed Object Aggregation MIB May 2006

                   "The MIB for servicing Time-Based aggregate
                     objects.
                     Copyright (C) The Internet Society (2006).  This
                     version of this MIB module is part of RFC 4498;
                     see the RFC itself for full legal notices.
                   "
           REVISION    "200604270000Z"      -- 27th April, 2006
           DESCRIPTION "Initial version, published as RFC 4498."
                ::= { experimental 124 }
    TAggrMOErrorStatus ::= TEXTUAL-CONVENTION
      STATUS       current
      DESCRIPTION
        "This data type is used to model the error status of the
         sampled MO instance.  The error status for a sampled MO
         instance is given in terms of two elements:
           o The moIndex, which indicates the sample number of the MO
             instance (starting at 1) in the value of the time-
             aggregated MO instance.
           o The moError, which indicates the error that was
             encountered in sampling that MO instance.
         The syntax in ASN.1 Notation will be
         ErrorStatus :: = SEQUENCE {
            moIndex  Integer32,
            moError  SnmpPduErrorStatus
         }
         TAggrMOErrorStatus ::= SEQUENCE OF {
            ErrorStatus
         }
         Note1: The command responder will supply values for all
                the samples of the MO instance.  If an error is
                encountered for a sample, then the corresponding
                value will have an ASN.1 value NULL, and an error
                will be flagged in the corresponding
                TAggrMOErrorStatus object.
                Only MOs for which errors have been encountered will
                the corresponding moIndex and moError values be set.
         Note2: The error code for the component MO instances will be
                in accordance with the SnmpPduErrorStatus TC defined
                in the DISMAN-SCHEDULE-MIB[RFC3231].
        "
      SYNTAX      Opaque (SIZE (0..1024))
    TimeAggrMOValue ::= TEXTUAL-CONVENTION
      STATUS       current
      DESCRIPTION
        "This data type is used to model the time-aggregated MOs.  It

Keeni Experimental [Page 18] RFC 4498 The Managed Object Aggregation MIB May 2006

         will be a sequence of values.  The syntax in ASN.1 Notation
         will be
         MOSampleValue :: = SEQUENCE {
              value ObjectSyntax
         }
         TimeAggrMOValue ::= SEQUENCE OF {
              MOSampleValue
         }
         where the first MOSampleValue, if any, will always be the
         timestamp of the first sample in the aggregated object.  The
         subsequent values are the values of the MO instance sampled
         at the specified intervals for the specified number of times.
         Note: The command generator will need to know the
               constituent MO instance and the sampling interval to
               correctly interpret TimeAggrMOValue.
        "
      SYNTAX      Opaque (SIZE (0..1024))
    CompressedTimeAggrMOValue ::= TEXTUAL-CONVENTION
      STATUS       current
      DESCRIPTION
        "This data type is used to model the compressed
         TAgMOs."
      SYNTAX      Opaque (SIZE (0..1024))
  1. -
  2. - The Time-Based aggregation control table
  3. -

tAggrCtlTable OBJECT-TYPE

         SYNTAX  SEQUENCE OF TAggrCtlEntry
         MAX-ACCESS  not-accessible
         STATUS current
         DESCRIPTION
            "The Time-Based aggregation control table.  It controls
             the aggregation of the samples of MO instances.  There
             will be a row for each TAgMO.
            "
         ::= {tAggrMIB 1}
     tAggrCtlEntry OBJECT-TYPE
         SYNTAX  TAggrCtlEntry
         MAX-ACCESS  not-accessible
         STATUS  current
         DESCRIPTION
           "A row of the control table that defines one Time-Based
            aggregate MO (TAgMO)."
         INDEX {tAggrCtlEntryID }
         ::= {tAggrCtlTable 1 }

Keeni Experimental [Page 19] RFC 4498 The Managed Object Aggregation MIB May 2006

     TAggrCtlEntry ::= SEQUENCE {
        tAggrCtlEntryID
                      SnmpAdminString,
        tAggrCtlMOInstance
                      OBJECT IDENTIFIER,
        tAggrCtlAgMODescr
                      SnmpAdminString,
        tAggrCtlInterval
                      Integer32,
        tAggrCtlSamples
                      Integer32,
        tAggrCtlCompressionAlgorithm
                      INTEGER,
        tAggrCtlEntryOwner
                      OwnerString,
        tAggrCtlEntryStorageType
                      StorageType,
        tAggrCtlEntryStatus
                      RowStatus
     }
    tAggrCtlEntryID OBJECT-TYPE
         SYNTAX SnmpAdminString (SIZE(1..32))
         MAX-ACCESS not-accessible
         STATUS current
         DESCRIPTION
           "A locally unique, administratively assigned name
             for this aggregated MO.  It is used as an index to
             uniquely identify this row in the table."
         ::= { tAggrCtlEntry 1 }
    tAggrCtlMOInstance OBJECT-TYPE
         SYNTAX OBJECT IDENTIFIER
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "The sampled values of this MO instance will be
             aggregated by the TAgMO.
             "
         ::= { tAggrCtlEntry 2 }
    tAggrCtlAgMODescr OBJECT-TYPE
         SYNTAX SnmpAdminString (SIZE(0..64))
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "A textual description of the aggregate object."
         ::= {tAggrCtlEntry 3}

Keeni Experimental [Page 20] RFC 4498 The Managed Object Aggregation MIB May 2006

    tAggrCtlInterval OBJECT-TYPE
         SYNTAX Integer32
         UNITS  "micro seconds"
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "The interval, in microseconds, at which the MO instance
             pointed at by tAggrInstance will be sampled for
             Time-Based aggregation.
           "
         ::= {tAggrCtlEntry 4}
    tAggrCtlSamples OBJECT-TYPE
         SYNTAX Integer32
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "The number of times at which the MO instance referred
             to by tAggrInstance will be sampled for Time-Based
             aggregation."
         ::= {tAggrCtlEntry 5}
  1. - only one compression algorithm is defined as of now.

tAggrCtlCompressionAlgorithm OBJECT-TYPE

         SYNTAX INTEGER {
                none      (1),
                deflate   (2)
         }
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "The compression algorithm that will be used by
             the agent to compress the value of the TAgMO.
             The deflate algorithm and corresponding data format
             specification is described in RFC 1951.  It is
             compatible with the widely used gzip utility.
           "
         REFERENCE
           "RFC1951 : DEFLATE Compressed Data Format Specification
            version 1.3
           "
         DEFVAL { none }
         ::= {tAggrCtlEntry 6}
    tAggrCtlEntryOwner OBJECT-TYPE
         SYNTAX OwnerString
         MAX-ACCESS read-create
         STATUS current

Keeni Experimental [Page 21] RFC 4498 The Managed Object Aggregation MIB May 2006

         DESCRIPTION
            "A textual description of the entity that created
             this entry.
           "
         ::= {tAggrCtlEntry 7}
    tAggrCtlEntryStorageType OBJECT-TYPE
         SYNTAX StorageType
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "This object defines whether the parameters defined in
             this row are kept in volatile storage and lost upon
             reboot or backed up by non-volatile (permanent)
             storage.
             Conceptual rows having the value 'permanent' need not
             allow write-access to any columnar objects in the row.
            "
         ::= {tAggrCtlEntry 8}
    tAggrCtlEntryStatus OBJECT-TYPE
         SYNTAX RowStatus
         MAX-ACCESS read-create
         STATUS current
         DESCRIPTION
            "The row status variable, used according to row
             installation and removal conventions.
             Objects in a row can be modified only when the value of
             this object in the corresponding conceptual row is not
             'active'.
             Thus, to modify one or more of the objects in this
             conceptual row,
               a. change the row status to 'notInService',
               b. change the values of the row, and
               c. change the row status to 'active'.
             The tAggrCtlEntryStatus may be changed to 'active' iff
             all the MOs in the conceptual row have been assigned
             valid values.
            "
         ::= {tAggrCtlEntry 9}
  1. -
  2. - tAggrDataTable: The data table.
  3. -

tAggrDataTable OBJECT-TYPE

         SYNTAX  SEQUENCE OF TAggrDataEntry

Keeni Experimental [Page 22] RFC 4498 The Managed Object Aggregation MIB May 2006

         MAX-ACCESS  not-accessible
         STATUS  current
         DESCRIPTION
            "This is the data table.  Each row of this table contains
             information about a TAgMO indexed by tAggrCtlEntryID.
             tAggrCtlEntryID is the key to the table.  It is used to
             identify instances of the TAgMO that are present in the
             table.
           "
         ::= {tAggrMIB 2}
    tAggrDataEntry OBJECT-TYPE
         SYNTAX  TAggrDataEntry
         MAX-ACCESS  not-accessible
         STATUS  current
         DESCRIPTION
           "Entry containing information pertaining
             to a TAgMO."
         INDEX {tAggrCtlEntryID}
         ::= {tAggrDataTable 1 }
    TAggrDataEntry ::= SEQUENCE {
       tAggrDataRecord
                  TimeAggrMOValue,
       tAggrDataRecordCompressed
                  CompressedTimeAggrMOValue,
       tAggrDataErrorRecord
                  TAggrMOErrorStatus
       }
    tAggrDataRecord OBJECT-TYPE
         SYNTAX TimeAggrMOValue
         MAX-ACCESS read-only
         STATUS current
         DESCRIPTION
           "The snapshot value of the TAgMO."
         ::= { tAggrDataEntry 1}
    tAggrDataRecordCompressed OBJECT-TYPE
         SYNTAX CompressedTimeAggrMOValue
         MAX-ACCESS read-only
         STATUS current
         DESCRIPTION
           "The compressed value of the TAgMO.
            The compression algorithm will depend on the
            tAggrCtlCompressionAlgorithm given in the corresponding
            tAggrCtlEntry.  If the value of the corresponding
            tAggrCtlCompressionAlgorithm is (1) 'none', then the

Keeni Experimental [Page 23] RFC 4498 The Managed Object Aggregation MIB May 2006

            value of all instances of this object will be a string
            of zero length.
            Note that the access privileges to this object will be
            governed by the access privileges of the corresponding MO
            instance.  Thus, an entity attempting to access an
            instance of this MO MUST have access rights to the
            instance object pointed at by tAggrCtlMOInstance and this
            MO instance.
           "
         ::= { tAggrDataEntry 2}
    tAggrDataErrorRecord OBJECT-TYPE
         SYNTAX TAggrMOErrorStatus
         MAX-ACCESS read-only
         STATUS current
         DESCRIPTION
            "The error status corresponding to the MO instance
             samples aggregated in tAggrDataRecord (and
             tAggrDataRecordCompressed)."
         ::= { tAggrDataEntry 3}
  1. - Conformance information

tAggrConformance OBJECT IDENTIFIER ::= { tAggrMIB 3 }

    tAggrGroups      OBJECT IDENTIFIER ::= { tAggrConformance 1 }
    tAggrCompliances OBJECT IDENTIFIER ::= { tAggrConformance 2 }
  1. - Compliance statements

tAggrMibCompliance MODULE-COMPLIANCE

         STATUS  current
         DESCRIPTION
                 "The compliance statement for SNMP entities
                  that implement the TIME-AGGREGATE-MIB."
         MODULE  -- this module
             MANDATORY-GROUPS { tAggrMibBasicGroup }
         ::= { tAggrCompliances 1 }
  1. - Units of conformance

tAggrMibBasicGroup OBJECT-GROUP

         OBJECTS {
                    tAggrCtlMOInstance,
                    tAggrCtlAgMODescr,
                    tAggrCtlInterval,
                    tAggrCtlSamples,
                    tAggrCtlCompressionAlgorithm,
                    tAggrCtlEntryOwner,
                    tAggrCtlEntryStorageType,
                    tAggrCtlEntryStatus,

Keeni Experimental [Page 24] RFC 4498 The Managed Object Aggregation MIB May 2006

                    tAggrDataRecord,
                    tAggrDataRecordCompressed,
                    tAggrDataErrorRecord
        }
         STATUS  current
         DESCRIPTION
                  "A collection of objects for Time-Based aggregation
                   of MOs."
         ::= { tAggrGroups 1 }
    END

7. Security Considerations

 There are management objects in the MIB modules defined in this
 document that have a MAX-ACCESS clause of read-create.  Such objects
 may be considered sensitive or vulnerable in some network
 environments.  The support for SET operations in a non-secure
 environment without proper protection can have a negative effect on
 network operations.  The objects and corresponding vulnerabilities
 are discussed below.
 The following MOs are used to configure an agent that implements the
 aggregate MIB modules.
       aggrCtlMOIndex,
       aggrCtlMODescr,
       aggrCtlCompressionAlgorithm,
       aggrCtlEntryOwner,
       aggrCtlEntryStorageType,
       aggrCtlEntryStatus,
       aggrMOInstance,
       aggrMODescr,
       aggrMOEntryStorageType,
       aggrMOEntryStatus,
       tAggrCtlMOInstance,
       tAggrCtlAgMODescr,
       tAggrCtlInterval,
       tAggrCtlSamples,
       tAggrCtlCompressionAlgorithm,
       tAggrCtlEntryOwner,
       tAggrCtlEntryStorageType,
       tAggrCtlEntryStatus,

Keeni Experimental [Page 25] RFC 4498 The Managed Object Aggregation MIB May 2006

 Access to these objects may be abused to affect the operation of the
 data collection system.  In particular,
  1. by changing the value of an instance of aggrCtlEntryStatus,

tAggrCtlEntryStatus, aggrMOEntryStatus, or tAggrMOEntryStatus

       to 'notInService' or 'destroy', the data aggregation operation
       for the corresponding entry will become unavailable to the
       management system.
  1. by changing the value of an instance of aggrMOInstance or

tAggrCtlMOInstance, the data aggregation operation may be

       subverted.  This may result in wrong information being fed to
       the management system.
  1. by adding several rows in the aggrMOTable corresponding to an

aggregate MO, it is possible to make the value of the aggregate

       MOs very large.  A similar effect may be achieved by
       manipulating the value of the tAggrCtlSamples instance
       corresponding to a Time-Based aggregate MO.  This could result
       in very heavy management traffic and/or fragmentation of
       response packets.  In some cases the responder may refuse to
       send the data and will simply respond with an error message
       indicating that the response packet size is too big.
 An entity attempting to access an instance of an aggregated MO MUST
 have access rights to all the component instance objects and the
 aggregate MO instance.  An implementation MUST follow this
 requirement.  Lax adherence to this requirement will breach the
 security model and make the system vulnerable to illegal accesses.
 SNMP versions prior to SNMPv3 did not include adequate security.
 Even if the network itself is secure (for example by using IPSec),
 there is no control as to who on the secure network is allowed to
 access and GET/SET (read/change/create/delete) the objects in this
 MIB module.
 It is RECOMMENDED that implementers consider the security features as
 provided by the SNMPv3 framework (see [RFC3410], section 8),
 including full support for the SNMPv3 cryptographic mechanisms (for
 authentication and privacy).
 Further, deployment of SNMP versions prior to SNMPv3 is NOT
 RECOMMENDED.  Instead, it is RECOMMENDED to deploy SNMPv3 and to
 enable cryptographic security.  It is then a customer/operator
 responsibility to ensure that the SNMP entity giving access to an
 instance of this MIB module is properly configured to give access to
 the objects only to those principals (users) that have legitimate
 rights to indeed GET or SET (change/create/delete) them.

Keeni Experimental [Page 26] RFC 4498 The Managed Object Aggregation MIB May 2006

8. IANA Considerations

 The MIB modules in this document use the following IANA-assigned
 OBJECT IDENTIFIER values, recorded in the SMI Numbers registry:
 Descriptor        OBJECT IDENTIFIER value
 ----------        -----------------------
 aggrMIB           { experimental 123 }
 tAggrMIB          { experimental 124 }

9. References

9.1. Normative References

 [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
           Requirement Levels", BCP 14, RFC 2119, March 1997.
 [RFC2578] McCloghrie, K., Perkins, D., and J. Schoenwaelder,
           "Structure of Management Information Version 2 (SMIv2)",
           STD 58, RFC 2578, April 1999.
 [RFC2579] McCloghrie, K., Perkins, D., and J. Schoenwaelder, "Textual
           Conventions for SMIv2", STD 58, RFC 2579, April 1999.
 [RFC2580] McCloghrie, K., Perkins, D., and J. Schoenwaelder,
           "Conformance Statements for SMIv2", STD 58, RFC 2580, April
           1999.
 [RFC2819] Waldbusser, S., "Remote Network Monitoring Management
           Information Base", STD 59, RFC 2819, May 2000.
 [RFC3411] Harrington, D., Presuhn, R., and B. Wijnen, "An
           Architecture for Describing Simple Network Management
           Protocol (SNMP) Management Frameworks", STD 62, RFC 3411,
           December 2002.
 [RFC3231] Levi, D. and J. Schoenwaelder, "Definitions of Managed
           Objects for Scheduling Management Operations", RFC 3231,
           January 2002.
 [RFC1951] Deutsch, P., "DEFLATE Compressed Data Format Specification
           version 1.3", RFC 1951, May 1996.

9.2. Informative References

 [RFC3410] Case, J., Mundy, R., Partain, D., and B. Stewart,
           "Introduction and Applicability Statements for Internet-
           Standard Management Framework", RFC 3410, December 2002.

Keeni Experimental [Page 27] RFC 4498 The Managed Object Aggregation MIB May 2006

10. Acknowledgements

 This document is the product of discussions and deliberations carried
 out in the WIDE-netman group.  Bert Wijnen and Glenn Waters reviewed
 the document and provided valuable comments.

Authors' Addresses

 Glenn Mansfield Keeni
 Cyber Solutions Inc.
 6-6-3 Minami Yoshinari
 Aoba-ku, Sendai 989-3204
 Japan
 Phone: +81-22-303-4012
 EMail: glenn@cysols.com

Keeni Experimental [Page 28] RFC 4498 The Managed Object Aggregation MIB May 2006

Full Copyright Statement

 Copyright (C) The Internet Society (2006).
 This document is subject to the rights, licenses and restrictions
 contained in BCP 78 and at www.rfc-editor.org/copyright.html, and
 except as set forth therein, the authors retain all their rights.
 This document and the information contained herein are provided on an
 "AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS
 OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY AND THE INTERNET
 ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED,
 INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE
 INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED
 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

Intellectual Property

 The IETF takes no position regarding the validity or scope of any
 Intellectual Property Rights or other rights that might be claimed to
 pertain to the implementation or use of the technology described in
 this document or the extent to which any license under such rights
 might or might not be available; nor does it represent that it has
 made any independent effort to identify any such rights.  Information
 on the procedures with respect to rights in RFC documents can be
 found in BCP 78 and BCP 79.
 Copies of IPR disclosures made to the IETF Secretariat and any
 assurances of licenses to be made available, or the result of an
 attempt made to obtain a general license or permission for the use of
 such proprietary rights by implementers or users of this
 specification can be obtained from the IETF on-line IPR repository at
 http://www.ietf.org/ipr.
 The IETF invites any interested party to bring to its attention any
 copyrights, patents or patent applications, or other proprietary
 rights that may cover technology that may be required to implement
 this standard.  Please address the information to the IETF at
 ietf-ipr@ietf.org.

Acknowledgement

 Funding for the RFC Editor function is provided by the IETF
 Administrative Support Activity (IASA).

Keeni Experimental [Page 29]

/data/webs/external/dokuwiki/data/pages/rfc/rfc4498.txt · Last modified: 2006/05/22 21:46 by 127.0.0.1

Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki