META-POLICY-PIB PIB-DEFINITIONS ::= BEGIN 
 
IMPORTS 
     ibrpib
          FROM TUBS-SMI
     Unsigned32, TimeTicks, 
     MODULE-IDENTITY, OBJECT-TYPE, 
     TEXTUAL-CONVENTION
          FROM COPS-PR-SPPI 
     InstanceId, ReferenceId, TagId, TagReferenceId, Prid
          FROM COPS-PR-SPPI-TC
     SnmpAdminString
          FROM SNMP-FRAMEWORK-MIB
     TruthValue
          FROM SNMPv2-TC;
 
metaPolicyPib  MODULE-IDENTITY 
     SUBJECT-CATEGORIES { all } 
     LAST-UPDATED "200104010000Z" 
     ORGANIZATION "IETF" 
     CONTACT-INFO " Andreas Polyrakis 
                    Dept. of Computer Science, 
                    University of Toronto, 
                    10 King's College Road, 
                    Toronto, Ontario,M5S 3G4, Canada. 
                    e-mail: apolyr@cs.toronto.edu 
                    Phone: ++1 (416) 978-4837 
                    Fax: ++1 (416) 978 1931 
 
                    Raouf Boutaba 
                    Dept. of Computer Science, 
                    University of Waterloo, 
                    200 University Avenue West, 
                    Waterloo, Ontario N2L 3G1, Canada 
                    e-mail: rboutaba@bbcr.uwaterloo.ca 
                    Phone: ++1 (519) 888 4567 ext.4820 
                    Fax: ++1 (519) 885 1208" 
     DESCRIPTION 
          "The meta-policy PIB module. It contains the classes 
          that are necessary for the provisioning of meta-policy 
          related information. This module is applicable, 
          but not current, to all subject-categories" 
 
     ::= { ibrpib 21 } 
-- The root OID for PRCs in the Meta-Policy PIB 
 
 
--- 
--- Textual Conventions 
--- 
BERValue ::= TEXTUAL-CONVENTION 
     STATUS       current 
     DESCRIPTION 
          "A sequence of octets that encodes a value using BER. 
          The suppoted BER types are (borrowed by SNMPv2): 
          Type                | BER identifier 
          --------------------|---------------- 
 
          INTEGER             | 02 
          BIT STRING          | 03 
          OCTET STRING        | 04 
          NULL                | 05 
          OBJECT IDENTIFIER   | 06 
          IP ADDRESS          | 40 
          COUNTER32           | 41 
          GAUGE32             | 42 
          TIMETICKS           | 43 
          OPAQUE              | 44 
  
 
          By using this type, the PEP can store values for different  
          types of parameters in the same class (PRC)." 
 
     SYNTAX OCTET STRING (SIZE (0..16)) 
 
XMLString ::= TEXTUAL-CONVENTION 
       STATUS       current 
       DESCRIPTION 
          "A string that contains a logical expression encoded using  
          XML. The semantics of the XML tags are defined in special  
          DTDs, which the PEP declares that supports." 
       SYNTAX OCTET STRING (SIZE (0..1024)) 
--- 
--- End of Textual Conventions 
--- 
 
----------------------------------------------- 
----------------------------------------------- 
 
 
-- Meta-Policy Capabilities Group 
metaPolicyCapabilitiesClasses 
     OBJECT IDENTIFIER ::= { metaPolicyPib 1 } 
 
 
--- 
--- Meta-Policy Capabilities Table 
--- 
xmlDTDTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF XmlDTDEntry 
     PIB-ACCESS notify 
     STATUS current 
     DESCRIPTION 
          "Each instance of this class specifies a PRC that 
          identifies an XML DTD supported by the PEP for encoding 
          logical expressions. If this class has no instances, 
          then the PEP supports only expressions that are formed 
          with boolean predicates and operators, and in this case 
          the PDP MUST not attempt to install any XML-encoded 
          expressions in the generalConditionTable." 
     ::= { metaPolicyCapabilitiesClasses 1 } 
 
xmlDTDEntry OBJECT-TYPE 
     SYNTAX XmlDTDEntry
     STATUS current 
     DESCRIPTION 
          "An instance of the xmlDTDTable class that determines an 
          XML DTD that can be used to encode a logical expression" 
     PIB-INDEX { xmlDTDPrid } 
     ::= { xmlDTDTable 1 } 
 
XmlDTDEntry ::= 
     SEQUENCE { 
  
          xmlDTDPrid           InstanceId, 
          xmlDTDURL            SnmpAdminString 
     } 
 
xmlDTDPrid OBJECT-TYPE 
     SYNTAX InstanceId 
     STATUS current 
     DESCRIPTION 
          "An arbitrary integer that uniquely identifies an 
          instance of the xmlDTD class." 
     ::= { xmlDTDEntry 1 } 
 
xmlDTDURL OBJECT-TYPE 
     SYNTAX SnmpAdminString 
     STATUS current 
     DESCRIPTION 
          "The XML DTD URL. A string that indicates the URL of an 
          XML DTD that can be used for encoding expressions. 
          These DTDs can be defined either by standardization 
          organizations, such as IETF, or be vendor specific. 
 
          When the PDP receives a URL that uniquely identifies 
          such a DTD, it knows that it may encode expressions 
          according to this DTD that the PEP will be able to 
          evaluate." 
     ::= { xmlDTDEntry 2 } 
 
--End of xmlDTDTable 
 
----------------------------------------------- 
----------------------------------------------- 
 
-- Base Meta-Policy Group 
metaPolicyClasses 
     OBJECT IDENTIFIER ::= { metaPolicyPib 2 } 
 
 
--- 
--- Meta-Policy Table 
--- 
metaPolicyTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF MetaPolicyEntry 
     PIB-ACCESS install
     STATUS current 
     DESCRIPTION 
          "Each instance of this class specifies a PRC that 
          represents a meta-policy. Each meta-policy, apart 
          from a unique identifier and an optional name, it 
          constists of a condition and a group of actions." 
     ::= { metaPolicyClasses 1 } 
 
metaPolicyEntry OBJECT-TYPE 
     SYNTAX MetaPolicyEntry 
     STATUS current 
  
     DESCRIPTION 
          "An instance of the metaPolicy Class that represents 
          a meta-policy." 
     PIB-INDEX { metaPolicyPrid } 
     ::= { metaPolicyTable 1 } 
 
MetaPolicyEntry ::= 
     SEQUENCE { 
          metaPolicyPrid            InstanceId, 
          metaPolicyName            SnmpAdminString, 
          metaPolicyCondition       ReferenceId, 
          metaPolicyActions         TagId 
     } 
 
metaPolicyPrid OBJECT-TYPE 
     SYNTAX InstanceId 
     STATUS current 
     DESCRIPTION 
          "An arbitrary integer that uniquely identifies an 
          instance of the metaPolicy class." 
     ::= { metaPolicyEntry 1 } 
 
metaPolicyName OBJECT-TYPE 
     SYNTAX SnmpAdminString 
     STATUS current 
     DESCRIPTION 
          "A display string that represents the name of the 
          meta-policy. It is reccomented that different 
          meta-policies have different names. However, similar 
          meta-policies may have the same name. 
          Also, an empty string can be used as a name." 
     ::= { metaPolicyEntry 2 } 
 
metaPolicyCondition OBJECT-TYPE 
     SYNTAX ReferenceId 
     PIB-REFERENCES { conditionEntry }
     STATUS current 
     DESCRIPTION 
          "This attribute associates the specific meta-policy with 
          a condition in the condition Class. The condition MUST 
 
          exist when the meta-policy is installed. The meta-policy 
          MUST always be assosiated with one condition (which means 
          that the attribute can never be null/invalid." 
     ::= { metaPolicyEntry 3 } 
 
metaPolicyActions OBJECT-TYPE 
     SYNTAX TagId 
--     PIB-REFERENCES { actionEntry }
     STATUS current 
     DESCRIPTION 
          "A tag that maps this instance (meta-policy) to a group 
          of actions in the actions Class. Although the tag should 
          map to at least one action, there might be cases where a 
  
          meta-policy is associated to no actions. However such 
          cases should be avoided and only be temporal." 
     ::= { metaPolicyEntry 4 } 
--End of metaPolicyTable 
 
-- 
-- Meta-Policy Status Table 
-- 
metaPolicyStatusTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF MetaPolicyStatusEntry 
     PIB-ACCESS report-only
     STATUS current 
     DESCRIPTION 
          "This class augments the metaPolicy class. 
          Each instance of this class defines a PRC that is used 
          in order to report to the PDP the status of the 
          meta-policies. 
 
          Also, information form this table can be used as a 
          parameter to another meta-policy, as an alternative 
          way to ensure that two priorities cannot be 
          activated at the same time." 
     ::= { metaPolicyClasses 2 } 
 
metaPolicyStatusEntry OBJECT-TYPE 
     SYNTAX MetaPolicyStatusEntry 
     STATUS current 
     DESCRIPTION 
          "An instance of the metaPolicyStatus class that reports 
          the status of the corresponding meta-policy in the 
          metaPolicy class." 
     AUGMENTS { metaPolicyEntry } 
     ::= { metaPolicyStatusTable 1 } 
 
MetaPolicyStatusEntry ::= 
     SEQUENCE { 
          metaPolicyActive     TruthValue, 
          metaPolicySuppressed TruthValue 
     } 
 
metaPolicyActive OBJECT-TYPE 
     SYNTAX TruthValue 
     STATUS current 
     DESCRIPTION 
          "True while the meta-policy is active" 
     ::= { metaPolicyStatusEntry 1 } 
 
metaPolicySuppressed OBJECT-TYPE 
     SYNTAX TruthValue 
     STATUS current 
     DESCRIPTION 
          "If this meta-policy is prevented from being active by 
          an other meta-policy (but its conditions are met), this 
          attribute is set to true. 
  
 
          If this meta-policy prevents another meta-policy from 
          being active, then this attribute is true. 
 
          In other words: 
          Active | Suppr.| 
          -------------------------------- 
           true  | true  | meta-policy active, 
                         | it suppresses another one 
           true  | false | meta-policy active, 
                         | does not suppress another one 
           false | true  | meta-policy inactive 
                         | because it is suppressed by another one 
           false | false | meta-policy inactive because 
                         | the conditions are not met 
          " 
     ::= { metaPolicyStatusEntry 2 } 
--End of metaPolicyStatusTable 
 
 
--- 
--- Meta-Policy Priority Table 
--- 
metaPolicyPriorityTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF MetaPolicyPriorityEntry 
     PIB-ACCESS install 
     STATUS current 
     DESCRIPTION 
          "This table reports conflicting meta-policies. 
          When a meta-policy needs to be activated, the PEP 
          MUST check if it is conflicting with another meta-policy, 
          which is already active or needs to be activated at the 
          same time. If so, the one that is referenced in the 
          higherPriority attribute is activated and the other one 
          is deactivated or remains deactivated. Similarly, when a 
          meta-policy is deactivated, the PEP must check if a 
          lower-priority meta-policy must now be activated." 
     ::= { metaPolicyClasses 3 } 
 
metaPolicyPriorityEntry OBJECT-TYPE 
     SYNTAX MetaPolicyPriorityEntry 
     STATUS current 
     DESCRIPTION 
          "An instance of the metaPolicyPriority Class that 
          identifies the relative priority between two 
          meta-policies." 
     PIB-INDEX { metaPolicyPriorityPrid } 
     ::= { metaPolicyPriorityTable 1 } 
 
MetaPolicyPriorityEntry ::= 
     SEQUENCE { 
          metaPolicyPriorityPrid   InstanceId, 
          higherPriority           ReferenceId, 
          lowerPriority            ReferenceId
  
     } 
 
metaPolicyPriorityPrid OBJECT-TYPE 
     SYNTAX InstanceId 
     STATUS current 
     DESCRIPTION 
          "An arbitrary integer  that uniquely identifies an 
          instance of the metaPolicyPriority class." 
     ::= { metaPolicyPriorityEntry 1 } 
 
higherPriority OBJECT-TYPE 
     SYNTAX ReferenceId 
     PIB-REFERENCES { metaPolicyEntry }
     STATUS current 
     DESCRIPTION 
          "This attribute references to the meta-policy that 
          has higher priority than the one referenced by the 
          lowerPriority attribute" 
     ::= { metaPolicyPriorityEntry 2 } 
 
lowerPriority OBJECT-TYPE 
     SYNTAX ReferenceId 
     PIB-REFERENCES { metaPolicyEntry }
     STATUS current 
     DESCRIPTION 
 
          "This attribute references to the meta-policy that 
          has lower priority than the one referenced by the 
          higherPriority attribute" 
     ::= { metaPolicyPriorityEntry 3 } 
 
--End of metaPolicyPriorityTable 
----------------------------------------------- 
---------------------------------------------- 
 
 
-- Condition Group 
conditionClasses 
     OBJECT IDENTIFIER ::= { metaPolicyPib 3 } 
 
 
-- 
-- Condition Table 
-- 
conditionTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF ConditionEntry 
     PIB-ACCESS install
     STATUS current 
     DESCRIPTION 
          "Each instance of this PRC represents a boolean 
          expression. The conditionss of the meta-policies are 
          instances of this class. However, if the condition of 
          a meta-policy contains more than one predicate, the 
          predicates are also instances of this PRC. 
  
 
          For instance, Suppose that we want to encode a condition 
          A, which is evaluated as ( B OR C ), where B and C some 
          other boolean expressions. 
          In this case, A, B and C are instances of this PRC. 
 
          All instances of this PRC MUST be extended by an instance 
          of one of the rest PRCs of this group, in order to denote 
          if this condition should be evaluated based on simpler 
          conditions, if it is a boolean operand or an other 
          logical expression." 
     ::= { conditionClasses 1 } 
 
conditionEntry OBJECT-TYPE 
     SYNTAX ConditionEntry 
     STATUS current 
     DESCRIPTION 
          "An instance of the condition Class that defines a 
          boolean condition" 
     PIB-INDEX { conditionPrid } 
     ::= { conditionTable 1 } 
 
ConditionEntry ::= 
     SEQUENCE { 
          conditionPrid       InstanceId, 
          conditionReverse    TruthValue 
     } 
 
conditionPrid OBJECT-TYPE 
     SYNTAX InstanceId 
     STATUS current 
     DESCRIPTION 
          "An arbitrary integer that uniquely identifies an 
          instance of the condition class." 
     ::= { conditionEntry 1 } 
 
conditionReverse OBJECT-TYPE 
     SYNTAX TruthValue 
     STATUS current 
     DESCRIPTION 
          "if true, the negation of the logical expression 
           is evaluated, instead." 
     ::= { conditionEntry 2 } 
-- END OF conditionTable 
 
-- 
-- Complex Condition Table 
-- 
complexConditionTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF ComplexConditionEntry 
     PIB-ACCESS install
     STATUS current 
     DESCRIPTION 
          "Each instance of this PRC represents a complex 
  
          condition. It consists of two simplier conditions, 
          and a logical operator that determines how the two 
          terms are assosiated to compose the more 
          complicated condition" 
     ::= { conditionClasses 2 } 
 
complexConditionEntry OBJECT-TYPE 
     SYNTAX ComplexConditionEntry 
     STATUS current 
     DESCRIPTION 
          "An instance of the complexCondition class that breaks a 
          complex condition into two simpler ones." 
     EXTENDS { conditionEntry } 
 
     ::= { complexConditionTable 1 } 
 
ComplexConditionEntry ::= 
     SEQUENCE { 
          operator       INTEGER, 
          leftTerm       ReferenceId, 
          rightTerm      ReferenceId 
     } 
 
operator OBJECT-TYPE 
     SYNTAX INTEGER { 
          and (0), 
          or (1) 
          } 
     STATUS current 
     DESCRIPTION 
          "The logical operator in the complex condition" 
     ::= { complexConditionEntry 1 } 
 
leftTerm OBJECT-TYPE 
     SYNTAX ReferenceId 
     PIB-REFERENCES { conditionEntry }
     STATUS current 
     DESCRIPTION 
          "A reference to the first simpler condition." 
     ::= { complexConditionEntry 2 } 
 
rightTerm OBJECT-TYPE 
     SYNTAX ReferenceId 
     PIB-REFERENCES { conditionEntry }
     STATUS current 
 
     DESCRIPTION 
          "A reference to the second simpler condition." 
     ::= { complexConditionEntry 3 } 
-- END OF complexConditionTable 
 
-- 
-- Boolean Condition Expression Table 
-- 
  
booleanConditionTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF BooleanConditionEntry 
     PIB-ACCESS install
     STATUS current
     DESCRIPTION 
          "Each instance of this class extends the condition class 
          and represents a boolean parameter from which the 
          condition is evaluated." 
     ::= { metaPolicyCapabilitiesClasses 2 } 
 
booleanConditionEntry OBJECT-TYPE 
     SYNTAX BooleanConditionEntry 
     STATUS current
     DESCRIPTION 
          "An instance of the booleanCondition class that defines 
          the boolean parameter that gives values to the 
          corresponding condition." 
     EXTENDS { conditionEntry } 
     ::= { booleanConditionTable 1 } 
 
BooleanConditionEntry ::= 
     SEQUENCE { 
          parameterReference  ReferenceId 
     } 
 
parameterReference OBJECT-TYPE 
     SYNTAX ReferenceId 
     PIB-REFERENCES { parameterEntry }
     STATUS current 
     DESCRIPTION 
          "A reference to a parameter from where the condition is 
          evaluated. This condition MUST be of type boolean 
          (TruthValue)." 
     ::= { booleanConditionEntry 1 } 
-- End of booleanConditionTable 
 
-- 
-- Generic Condition Table 
-- 
genericConditionTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF GenericConditionEntry 
     PIB-ACCESS install
     STATUS current 
     DESCRIPTION 
          "Each instance of this class extends the condition class 
          and assosiates the corresponding condition with a complex 
          logical expression, from where the condition is 
          evaluated." 
     ::= { conditionClasses 3 } 
 
genericConditionEntry OBJECT-TYPE 
     SYNTAX GenericConditionEntry 
     STATUS current 
     DESCRIPTION 
  
          "An instance of the generalCondition class that defines 
          the logical expression for the corresponding condition 
          of the condition class." 
     PIB-INDEX { xmlDTDID }
     ::= { genericConditionTable 1 } 
 
GenericConditionEntry ::= 
     SEQUENCE { 
        xmlDTDID       InstanceId,
        xmlDTDRef      ReferenceId,
        xmlCondition   XMLString 
     } 
 
xmlDTDID OBJECT-TYPE 
     SYNTAX InstanceId 
     STATUS current 
     DESCRIPTION 
          "unique ID" 
     ::= { genericConditionEntry 1 } 
 
xmlDTDRef OBJECT-TYPE 
     SYNTAX ReferenceId 
     PIB-REFERENCES { xmlDTDEntry }
     STATUS current 
     DESCRIPTION 
          "A reference to the xmlDTD class that deternies which 
          of the XML DTDs that this PEP supports is used in 
          order to encode the expression." 
     ::= { genericConditionEntry 2 } 
 
xmlCondition OBJECT-TYPE 
     SYNTAX XMLString 
     STATUS current 
     DESCRIPTION 
          "The XML-encoded expression." 
     ::={ genericConditionEntry 3 } 
-- End of genericConditionTable 
 
----------------------------------------------- 
----------------------------------------------- 
 
 
-- Actions Group 
actionClasses 
     OBJECT IDENTIFIER ::= { metaPolicyPib 4 } 
 
 
-- 
-- Actions Table 
-- 
actionTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF ActionEntry 
     PIB-ACCESS install 
     STATUS current 
     DESCRIPTION 
          "Each instance of this class stores an action of 
          a meta-policy." 
     ::= { actionClasses 1 } 
 
actionEntry OBJECT-TYPE 
     SYNTAX ActionEntry 
     STATUS current 
  
     DESCRIPTION 
          "An instance of the action class that stores an action 
          of a meta-policy." 
     PIB-INDEX { actionPrid } 
     ::= { actionTable 1 } 
 
ActionEntry ::= 
     SEQUENCE { 
          actionPrid        InstanceId, 
          actionRefTag      TagReferenceId, 
          actionTargetPrid  Prid 
     } 
 
actionPrid OBJECT-TYPE 
     SYNTAX InstanceId 
     STATUS current 
     DESCRIPTION 
          "An arbitrary integer that uniquely identifies an 
          instance of the action class." 
     ::= { actionEntry 1 } 
 
actionRefTag OBJECT-TYPE 
     SYNTAX TagReferenceId 
     PIB-TAG { metaPolicyActions }
     STATUS current 
     DESCRIPTION 
          "An attribute that defines a Tag Group of actions. 
          All actions with the same tag are grouped as the actions 
          of a single meta-policy." 
     ::={ actionEntry 2 } 
 
actionTargetPrid OBJECT-TYPE 
     SYNTAX Prid 
     STATUS current 
     DESCRIPTION 
          "The PRID of the PRI to be installed/updated. 
          The PRID must point to a single PRI." 
     ::={ actionEntry 3 } 
-- END OF actionTable 
 
-- 
-- Action Value table 
-- 
actionValueTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF ActionValueEntry 
     PIB-ACCESS install 
     STATUS current 
     DESCRIPTION 
          "Each instance of this class extends the corresponding 
          instance of the action class. It provides the BER-encoded 
value  
          that will be installed at the corresponding PRI." 
     ::= { actionClasses 2 } 

  
 
 
actionValueEntry OBJECT-TYPE 
     SYNTAX ActionValueEntry 
     STATUS current 
     DESCRIPTION 
          "An insance of the actionValue class. It provides 
          the value (encoded with BER) that will be installed at 
          the PRI denoted by the corresponding instance of the 
          action class." 
     EXTENDS { actionEntry } 
     ::= { actionValueTable 1 } 
 
ActionValueEntry ::= 
     SEQUENCE { 
          actionValueEpd      BERValue 
     } 
 
actionValueEpd OBJECT-TYPE 
     SYNTAX BERValue 
     STATUS current 
     DESCRIPTION 
          "This attribute contains the BER-encoded value of the 
          PRI to be installed/updated." 
     ::={ actionValueEntry 1 } 
-- END OF actionValueTable 
 
-- 
-- Action Parametric Value Table 
-- 
actionParametricValueTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF ActionParametricValueEntry 
     PIB-ACCESS install 
     STATUS current 
     DESCRIPTION 
          "Each instance of this class that extends the 
           corresponding instance of the action class. It provides 
with the 
           parametric value that will be installed at the 
corresponding PRI." 
     ::= { actionClasses 3 } 
 
actionParametricValueEntry OBJECT-TYPE 
     SYNTAX ActionParametricValueEntry 
     STATUS current 
     DESCRIPTION 
          "An insance of the actionValue class. It provides with 
          the parametric value that will be installed at the PRI 
           denoted by the corresponding instance of the action 
           class." 
     EXTENDS { actionEntry } 
 
     ::= { actionParametricValueTable 1 } 
 
  
ActionParametricValueEntry ::= 
     SEQUENCE { 
          parameterRef        ReferenceId 
     } 
 
parameterRef OBJECT-TYPE 
     SYNTAX ReferenceId 
     PIB-REFERENCES { parameterEntry }
     STATUS current 
     DESCRIPTION 
          "A reference to a the parameter, from where the value 
          of the installed PRI should be obtained. Whenever the 
          value of the parameter changes, the installed PRI 
          MUST be updated." 
     ::={ actionParametricValueEntry 1 } 
-- END OF actionParametricValueTable 
 
----------------------------------------------- 
----------------------------------------------- 
 
 
-- Parameter Group 
parameterClasses 
     OBJECT IDENTIFIER ::= { metaPolicyPib 5 } 
 
 
-- 
-- Parameter Table 
-- 
parameterTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF ParameterEntry 
     PIB-ACCESS install 
     STATUS current 
     DESCRIPTION 
          "Each instance of this class defines a parameter 
          that has been installed on the PEP. This class 
          MUST be extended by a class that defines how 
          the value of the parameter will be evaluated." 
     ::= { parameterClasses 1} 
 
parameterEntry OBJECT-TYPE 
     SYNTAX ParameterEntry 
     STATUS current 
     DESCRIPTION 
          "An instance of the parameter class that installs 
          a parameter into the PEP." 
     PIB-INDEX { parameterPrid } 
     ::= { parameterTable 1 } 
 
ParameterEntry ::= 
     SEQUENCE { 
          parameterPrid       InstanceId, 
          parameterName       SnmpAdminString, 
          parameterType       INTEGER
  
     } 
 
parameterPrid OBJECT-TYPE 
     SYNTAX InstanceId 
     STATUS current 
     DESCRIPTION 
          "An arbitrary integer that uniquely identifies an 
          instance of the parameter class." 
     ::= { parameterEntry 1 } 
 
parameterName OBJECT-TYPE 
     SYNTAX SnmpAdminString 
     STATUS current 
     DESCRIPTION 
          "A string that represents the name of the parameter. 
          It is reccomented that different parameter have different 
          names. However, similar parameter may have the same name. 
          Also, an empty string can be used as a name." 
     ::= { parameterEntry 2 } 
 
parameterType OBJECT-TYPE
     SYNTAX INTEGER { 
          integer(2),
          bitstring (3),
          octetstring (4),
          null (5),
          objectidentifier (6),
          ipaddress (40) 
          } 
     STATUS current 
     DESCRIPTION 
          "The BER type of the parameter. 
          The suppoted BER types are: 
          Type                | BER identifier 
          --------------------|---------------- 
          INTEGER             | 02 
          BIT STRING          | 03 
          OCTET STRING        | 04 
          NULL                | 05 
          OBJECT IDENTIFIER   | 06 
          IP ADDRESS          | 40" 
     ::= { parameterEntry 3 } 
-- END OF parameterTable 
 
-- 
-- MIBPIB Parameter Table 
-- 
mibPibParameterTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF MibPibParameterEntry 
     PIB-ACCESS install 
     STATUS current 
     DESCRIPTION 
          "This class extends the parameter class. 
          Each instance of this class assosiates to the 
  
          corresponding parameter a MIB or PIB variable, from 
          where the parameter is evaluated" 
     ::= { parameterClasses 2 } 
 
mibPibParameterEntry OBJECT-TYPE 
     SYNTAX MibPibParameterEntry 
     STATUS current 
     DESCRIPTION 
          "An instance of the mibPibParameter class that provides 
          the identifier of the MIB/PIB variable from where the 
          corresponding parameter is evaluated." 
     EXTENDS { parameterEntry } 
     ::= { mibPibParameterTable 1 } 
 
MibPibParameterEntry ::= 
     SEQUENCE { 
          targetOID        OBJECT IDENTIFIER, 
          evaluationFrequency TimeTicks 
          } 
 
targetOID OBJECT-TYPE 
     SYNTAX OBJECT IDENTIFIER 
     PIB-ACCESS install 
     STATUS current 
     DESCRIPTION 
          "The object identifier of the MIB/PIB variable. 
          The MIB/PIB variable MUST exist in the MIB/PIB of the 
          device. Also, the type of the target variable MUST be 
          compatible with the type of the corresponding PRI of the 
          parameter Class." 
     ::={ mibPibParameterEntry 1 } 
 
evaluationFrequency OBJECT-TYPE 
     SYNTAX TimeTicks 
     STATUS current 
     DESCRIPTION 
          "The frequency of updating the parameter in milliseconds" 
     ::={ mibPibParameterEntry 2 } 
-- END of mibPibParameterTable 
 
-- 
-- PDP Parameter Table 
-- 
pdpParameterTable OBJECT-TYPE 
     SYNTAX SEQUENCE OF PdpParameterEntry 
     PIB-ACCESS install 
     STATUS current 
     DESCRIPTION 
          "This class extends the parameter class. Each instance 
          of this class contains the value of the corresponding 
          paramter. This value is send by the PDP and updated 
          whenever necessary." 
     ::= { parameterClasses 3 } 
 
  
pdpParameterEntry OBJECT-TYPE 
     SYNTAX PdpParameterEntry 
     STATUS current 
     DESCRIPTION 
          "An instance of the pdpParameter class that stores the 
          value, sent by the PDP, for the corresponding parameter." 
     PIB-INDEX { pdpParameterPrid } 
     ::= { pdpParameterTable 1 } 
 
PdpParameterEntry ::= 
     SEQUENCE { 
          pdpParameterPrid  InstanceId,
          lastValue         BERValue 
     } 
 
lastValue OBJECT-TYPE 
     SYNTAX BERValue 
     STATUS current 
     DESCRIPTION 
          "The latest value of the parameter, encoded with BER. 
          The BER-encoded value must be of the same type as the 
          corresponding PRI of the parameter class." 
     ::={ pdpParameterEntry 1 } 

pdpParameterPrid OBJECT-TYPE   
    SYNTAX         InstanceId   
    STATUS         current   
    DESCRIPTION   
        "An index to uniquely identify this parameter."   

    ::= { pdpParameterEntry 2 }   
     
-- END OF pdpParameterTable 
 
 
END 
