Policy Framework Working Group B. Moore
INTERNET-DRAFT E. Ellesson
Category: Standards Track IBM
J. Strassner
Cisco Systems
June 1999
Policy Framework Core Information Model
<draft-ietf-policy-core-info-model-00.txt>
Friday, June 25, 1999, 1:27 PM
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
Copyright Notice
Copyright (C) The Internet Society (1999). All Rights Reserved.
Abstract
This document presents the object-oriented information model for
representing policy information currently under development as part of
the Common Information Model (CIM) activity in the Distributed
Management Task Force (DMTF). This CIM model defines two hierarchies
of object classes: structural classes representing policy information
and control of policies, and relationship classes that indicate how
instances of the structural classes are related to each other. A
companion document "Policy Framework Core LDAP Schema" [9] defines the
mapping of this information model to a directory that uses LDAPv3 as
its access protocol.
Moore, et al. Expires: Jun 1999 + 6 months [Page 1]
Internet Draft Policy Core Information Model June 1999
Table of Contents
1. Introduction......................................................3
2. Modeling Policies.................................................4
2.1. Policy Scope.................................................7
2.2. Declarative versus Procedural Model..........................7
3. Overview of the Policy Core Information Model.....................7
4. Inheritance Hierarchies for the Core Policy Classes and
Relationships........................................................9
5. Naming in the Policy Core Information ModelError! Bookmark not defined.
6. Class Definitions................................................11
6.1. The Abstract Class "Policy".................................12
6.1.1. The Key Property "CreationClassName"......................12
6.1.2. The Property "CommonName (CN)"............................12
6.1.3. The Property "Caption"....................................13
6.1.4. The Property "Description"................................13
6.1.5. The Multi-valued Property "PolicyKeywords"................13
6.2. The Class "PolicyGroup".....................................14
6.2.1. The Key Property "PolicyGroupName"........................15
6.3. The Class "PolicyRule"......................................15
6.3.1. The Key Property "PolicyRuleName".........................17
6.3.2. The Property "Enabled"....................................17
6.3.3. The Property "ConditionListType"..........................17
6.3.4. The Property "RuleUsage"..................................18
6.3.5. The Property "Priority"...................................18
6.3.6. The Property "Mandatory"..................................18
6.3.7. The Property "SequencedActions"...........................19
6.4. The Class "PolicyCondition".................................19
6.4.1. The Key Property "PolicyConditionName"....................21
6.5. The Class "PolicyTimePeriodCondition".......................21
6.5.1. The Property "TimePeriod".................................22
6.5.2. The Property "MonthOfYearMask"............................23
6.5.3. The Property "DayOfMonthMask".............................24
6.5.4. The Property "DayOfWeekMask"..............................24
6.5.5. The Property "TimeOfDayMask"..............................25
6.5.6. The Property "ApplicableTimeZone".........................25
6.6. The Class "VendorPolicyCondition"...........................26
6.6.1. The Multi-valued Property "Constraint"....................26
6.6.2. The Property "ConstraintEncoding".........................27
6.7. The Class "PolicyAction"....................................27
6.7.1. The Key Property "PolicyActionName".......................28
6.8. The Class "VendorPolicyAction"..............................28
6.8.1. The Multi-valued Property "ActionData"....................28
6.8.2. The Property "ActionEncoding".............................29
7. Association and Aggregation Definitions..........................29
7.1. Relationships...............................................29
7.2. Associations................................................30
7.3. Aggregations................................................30
7.4. The Aggregation "ContainedPolicyGroup"......................30
7.4.1. The Reference "ContainingGroup"...........................30
7.4.2. The Reference "ContainedGroup"............................31
7.5. The Aggregation "ContainedPolicyRule".......................31
Moore, et al. Expires: Jun 1999 + 6 months [Page 2]
Internet Draft Policy Core Information Model June 1999
7.5.1. The Reference "ContainingGroup"...........................31
7.5.2. The Reference "ContainedRule".............................31
7.6. The Aggregation "ContainedPolicyCondition"..................31
7.6.1. The Reference "ContainingRule"............................32
7.6.2. The Reference "ContainedCondition"........................32
7.6.3. The Property "GroupNumber"................................33
7.6.4. The Property "ConditionNegated"...........................33
7.7. The Aggregation "PolicyRuleValidityPeriod"..................33
7.7.1. The Reference "ContainingRule"............................34
7.7.2. The Reference "ContainedPtp"..............................34
7.8. The Aggregation "ContainedPolicyAction".....................34
7.8.1. The Reference "ContainingRule"............................35
7.8.2. The Reference "ContainedAction"...........................35
7.8.3. The Property "ActionOrder"................................35
7.9. The Policy Group Jurisdiction Associations..................36
7.9.1. The Reference "GroupScope"................................36
7.9.2. The Reference "ApplicableGroup"...........................37
7.10. The Policy Rule Jurisdiction Associations..................37
7.10.1. The Reference "RuleScope"................................38
7.10.2. The Reference "ApplicableRule"...........................38
8. Intellectual Property............................................38
9. Acknowledgements.................................................38
10. Security Considerations.........................................39
11. References......................................................41
12. Authors' Addresses..............................................41
13. Full Copyright Statement........................................42
1. Introduction
This document presents the object-oriented information model for
representing policy information currently under development as part of
the Common Information Model (CIM) activity in the Distributed
Management Task Force (DMTF). This CIM model defines two hierarchies
of object classes: structural classes representing policy information
and control of policies, and relationship classes that indicate how
instances of the structural classes are related to each other. A
companion document "Policy Framework Core LDAP Schema" [9] defines the
mapping of this information model to a directory that uses LDAPv3 as
its access protocol.
The policy classes and relationships defined in the CIM model are
sufficiently generic to allow them to represent policies related to
anything. However, it is expected that their initial application in
the IETF will be for representing policies related to QoS (DiffServ
and IntServ) and to IPSec. Policy models for application-specific
areas such as these may extend the Core Model in several ways. The
preferred way is to use the PolicyGroup, PolicyRule, and
PolicyTimePeriodCondition classes directly, as a foundation for
representing and communicating policy information. Then, specific
subclasses derived from PolicyCondition and PolicyAction can capture
Moore, et al. Expires: Jun 1999 + 6 months [Page 3]
Internet Draft Policy Core Information Model June 1999
application-specific definitions of conditions and actions of
policies.
Two subclasses, VendorPolicyCondition and VendorPolicyAction, are also
included in this document, to provide a standard escape mechanism for
vendor-specific extensions to the Policy Core Information Model.
This document fits into the overall framework for representing,
deploying, and managing policies being developed by the Policy
Framework Working Group. The initial work to define this framework is
in reference [1]. More specifically, this document builds on the core
policy classes first introduced in references [2] and [3]. It also
draws on the work done for the Directory-enabled Networks (DEN)
specification, reference [4]. Work on the DEN specification by the
DEN Ad-Hoc Working Group itself has been completed. Further work to
standardize the models contained in it will be the responsibility of
selected working groups of the CIM effort in the Distributed
Management Task Force (DMTF). Standardization of the core policy
model is the responsibility of the SLA Policy working group.
This document is organized in the following manner:
o Section 2 provides a general overview of policies and how they are
modeled.
o Section 3 presents a high-level overview of the classes and
relationships comprising the Policy Core Information Model.
o The remainder of the document presents the detailed specifications
for each of the classes and relationships.
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 RFC 2119, reference
[5].
2. Modeling Policies
The classes comprising the Policy Core Information Model are intended
to serve as an extensible class hierarchy (through specialization) for
defining policy objects that enable application developers, network
administrators, and policy administrators to represent policies of
different types.
One way to think of a policy-controlled network is to first model the
network as a state machine and then use policy to control which state
a policy-controlled device should be in or is allowed to be in at any
given time. Given this approach, policy is applied using a set of
policy rules. Each policy rule consists of a set of conditions and a
set of actions. Policy rules may be aggregated into policy groups.
These groups may be nested, to represent a hierarchy of policies.
Moore, et al. Expires: Jun 1999 + 6 months [Page 4]
Internet Draft Policy Core Information Model June 1999
The set of conditions associated with a policy rule specifies when the
policy rule is applicable. The set of conditions can be expressed as
either an ORed set of ANDed sets of condition statements or an ANDed
set of ORed sets of statements. Individual condition statements can
also be negated. These combinations are termed, respectively,
Disjunctive Normal Form (DNF) and Conjunctive Normal Form (CNF) for
the conditions.
If the set of conditions associated with a policy rule evaluates to
TRUE, then a set of actions that either maintain the current state of
the object or transition the object to a new state may be executed.
For the set of actions associated with a policy rule, it is possible
to specify an order of execution, as well as an indication of whether
the order is required or merely recommended. It is also possible to
indicate that the order in which the actions are executed does not
matter.
Policy rules themselves can be prioritized. One common reason for
doing this is to express an overall policy that has a general case
with a few specific exceptions.
For example, a general QoS policy rule might specify that traffic
originating from members of the engineering group is to get Bronze
Service. A second policy rule might express an exception: traffic
originating from John, a specific member of the engineering group, is
to get Gold Service. Since traffic originating from John satisfies
the conditions of both policy rules, and since the actions associated
with the two rules are incompatible, a priority needs to be
established. By giving the second rule (the exception) a higher
priority than the first rule (the general case), a policy
administrator can get the desired effect: traffic originating from
John gets Gold Service, and traffic originating from all the other
members of the engineering group gets Bronze Service.
Policies can either be used in a stand-alone fashion or aggregated
into policy groups to perform more elaborate functions. Stand-alone
policies are called policy rules. Policy groups are aggregations of
policy rules, or aggregations of policy groups, but not both. Policy
groups can model intricate interactions between objects that have
complex interdependencies. Examples of this include a sophisticated
user logon policy that sets up application access, security, and
reconfigures network connections based on a combination of user
identity, network location, logon method and time of day. A policy
group represents a unit of reusability and manageability in that its
management is handled by an identifiable group of administrators and
its policy rules apply equally to the scope of the policy group.
Stand-alone policies are those that can be expressed in a simple
statement. They can be represented effectively in schemata or MIBs.
Examples of this are VLAN assignments, simple YES/NO QoS requests, and
IP address allocations. A specific design goal of this model is to
support both stand-alone and aggregated policies.
Moore, et al. Expires: Jun 1999 + 6 months [Page 5]
Internet Draft Policy Core Information Model June 1999
Policy groups and rules can be classified by their purpose and intent.
This classification is useful in querying or grouping policy rules.
It indicates whether the policy is used to motivate when or how an
action occurs, or to characterize services (that can then be used, for
example, to bind clients to network services). Describing each of
these concepts in more detail,
o Motivational Policies are solely targeted at whether or how a
policy's goal is accomplished. Configuration and Usage Policies
are specific kinds of Motivational Policies. Another example is
the scheduling of file backup based on disk write activity from 8am
to 3pm, M-F.
o Configuration Policies define the default (or generic) setup of a
managed entity (for example, a network service). Examples of
Configuration Policies are the setup of a network forwarding
service or a network-hosted print queue.
o Installation Policies define what can and cannot be put on a system
or component, as well as the configuration of the mechanisms that
perform the install. Installation policies typically represent
specific administrative permissions, and can also represent
dependencies between different components (e.g., to complete the
installation of component A, components B and C must be previously
successfully installed or uninstalled).
o Error and Event Policies. For example, if a device fails between
8am and 9pm, call the system administrator, otherwise call the Help
Desk.
o Usage Policies control the selection and configuration of entities
based on specific "usage" data. Configuration Policies can be
modified or simply re-applied by Usage Policies. Examples of Usage
Policies include upgrading network forwarding services after a user
is verified to be a member of a "gold" service group, or
reconfiguring a printer to be able to handle the next job in its
queue.
o Security Policies deal with verifying that the client is actually
who the client purports to be, permitting or denying access to
resources, selecting and applying appropriate authentication
mechanisms, and performing accounting and auditing of resources.
o Service Policies characterize network and other services (not use
them). For example, all wide-area backbone interfaces shall use a
specific type of queuing.
Service policies describe services available in the network. Usage
policies describe the particular binding of a client of the network
to services available in the network.
Moore, et al. Expires: Jun 1999 + 6 months [Page 6]
Internet Draft Policy Core Information Model June 1999
These categories are represented in the Policy Core Information Model
by special values defined for the PolicyKeywords property of the
abstract class Policy.
2.1. Policy Scope
Policies represent business goals and objectives. A translation must
be made between these goals and objectives and their realization in
the network. An example of this could be a Service Level Agreement
(SLA), and its objectives and metrics (Service Level Objectives, or
SLOs), that are used to specify services that the network will provide
for a given client [8]. The SLA will usually be written in high-level
business terminology. SLOs address more specific metrics in support of
the SLA. These high-level descriptions of network services and metrics
must be translated into lower-level, but also vendor- and device-
independent specifications. The Policy Core Information Model classes
are intended to serve as the foundation for these vendor- and device-
independent specifications.
It is envisioned that the definition of policy in this draft is
generic in nature and is applicable to Quality of Service (QoS), to
non-QoS networking applications (e.g., DHCP and IPSEC), and to non-
networking applications (e.g., backup policies, auditing access,
etc.).
2.2. Declarative versus Procedural Model
The Policy Core Information Model is declarative, not procedural.
<<Raju to add details.>>
3. Overview of the Policy Core Information Model
The following diagram provides an overview of the five central classes
comprising the Policy Core Information Model, and their relationships
to each other. Note that the abstract class Policy and the two
extension classes VendorPolicyCondition and VendorPolicyAction are not
shown.
Moore, et al. Expires: Jun 1999 + 6 months [Page 7]
Internet Draft Policy Core Information Model June 1999
(various other CIM classes)
^ 0..n ^ 0..n
* *
* RuleJurisdiction * GroupJurisdiction
* *
* ********************
* *
* * **************
* * * *
* * 0..n * * ContainedPolicyGroup
* * +------v------+ *
* ****> PolicyGroup <******
* 0..n| | 0..n
* +------^------+
* 0..n *
* * ContainedPolicyRule
* 0..n *
* +------v------+
* | |
* | PolicyRule |
* | | ContainedPolicyCondition
*******> <****************************
0..n | | 0..n *
| | * 0..n
| | +---------v------------+
| | | PolicyCondition |
| | +----------------------+
| | PolicyRuleValidityPeriod ^
| <****************** I
| | 0..n * I
| | * 0..n ^
| | +----v----------------------+
| | | PolicyTimePeriodCondition |
| | +---------------------------+
| |
| | ContainedPolicyAction
| <*****************************
| | 0..n *
| | * 0..n
| | +----------v-----------+
| | | PolicyAction |
+-------------+ +----------------------+
Figure 1. Overview of the Core Policy Classes and Relationships
In this figure the boxes represent the classes, and the starred arrows
represent the relationships. A relationship always connects two
classes. The "two" classes may, however, be the same class, as is the
case with the ContainedPolicyGroup relationship, which represents the
recursive containment of PolicyGroups in other PolicyGroups.
Moore, et al. Expires: Jun 1999 + 6 months [Page 8]
Internet Draft Policy Core Information Model June 1999
A relationship has associated with it cardinalities for each of the
related classes. These cardinalities indicate how many instances of
each class may be related to an instance of the other class. For
example, the ContainedPolicyRule relationship has the cardinality
ranges "0..n" for both the PolicyGroup and PolicyRule classes. These
ranges are interpreted as follows:
o The "0..n" written next to PolicyGroup indicates that a PolicyRule
may be related to no PolicyGroups, to one PolicyGroup, or to more
than one PolicyGroup via the ContainedPolicyGroup relationship. In
other words, a PolicyRule may be contained in no PolicyGroups, in
one PolicyGroups, or in more than one PolicyGroup.
o The "0..n" written next to PolicyRule indicates that a PolicyGroup
may be related to no PolicyRules, to one PolicyRule, or to more
than one PolicyRule via the ContainedPolicyGroup relationship. In
other words, a PolicyGroup may contain no PolicyRules, one
PolicyRule, or more than one PolicyRule.
The relationships shown in Figure 1 are discussed in more detail in
Section 7.
4. Inheritance Hierarchies for the Core Policy Classes and Relationships
The following diagram illustrates the inheritance hierarchy for the
core policy classes:
Top
|
+--Policy (abstract)
|
+---PolicyGroup
|
+---PolicyRule
|
+---PolicyCondition
| |
| +---PolicyTimePeriodCondition
| |
| +---VendorPolicyCondition
|
+---PolicyAction
|
+---VendorPolicyAction
Figure 2. Inheritance Hierarchy for the Core Policy Classes
In CIM, relationships are also modeled as classes. For the Policy
Core Information Model, the inheritance hierarchy for the
relationships has only a single level:
Moore, et al. Expires: Jun 1999 + 6 months [Page 9]
Internet Draft Policy Core Information Model June 1999
Top
|
+---ContainedPolicyGroup
|
+---ContainedPolicyRule
|
+---ContainedPolicyCondition
|
+---PolicyRuleValidityPeriod
|
+---ContainedPolicyAction
|
+---VendorPolicyAction
|
+---GroupWithSettingJurisdiction
|
+---GroupWithMseJurisdiction
|
+---GroupWithPartyJurisdiction
|
+---GroupWithCollectionJurisdiction
|
+---RuleWithSettingJurisdiction
|
+---RuleWithMseJurisdiction
|
+---RuleWithPartyJurisdiction
|
+---RuleWithCollectionJurisdiction
Figure 3. Inheritance Hierarchy for the Core Policy Relationships
Near the bottom of Figure 3 there are two groups of four
relationships, representing jurisdictions. These relationships are
the vehicle for tying instances of the policy classes to instances of
other classes that represent the elements to which the policies are to
be applied. There are two relationships with each of four high-level
CIM classes: Setting, ManagedSystemElement (MSE), Party, and
Collection. These relationships indicate that a PolicyGroup or a
PolicyRule applies to a Setting, an MSE, a Party, or a Collection.
5. Details of the Model
5.1. Naming in the Policy Core Information Model
The Policy Core Information Model follows a common, but not universal,
CIM practice for naming instances of the its classes. Instances are
named by a combination of two key properties: CreationClassName,
which is inherited from the abstract class Policy, and a class-
specific key property such as PolicyGroupName or PolicyRuleName. By
including CreationClassName as a key property, the model insures that
Moore, et al. Expires: Jun 1999 + 6 months [Page 10]
Internet Draft Policy Core Information Model June 1999
the only possible name collisions within a naming context are ones
between instances of the same class.
5.2. CIM Data Types
The following CIM data types are used in the class definitions that
follow in Sections 6 and 7:
o uint8 unsigned 8-bit integer
o uint16 unsigned 16-bit integer
o boolean Boolean
o string UCS-2 string.
In addition, the association classes in Section 7 use the following
type:
o <classname> ref strongly typed reference.
6. Class Definitions
There are a significant number of differences between CIM and LDAP
class specifications. The ones that are relevant to the abbreviated
class specifications in this document are the following:
o Instead of LDAP's three class types (abstract, auxiliary,
structural), CIM has only two: abstract and instantiable. The
type of a CIM class is indicated by the Boolean qualifier ABSTRACT.
o CIM uses the term "property" for what LDAP terms an "attribute".
o CIM uses the array notation "[ ]" to indicate that a property is
multi-valued. As is the case with LDAP, multi-valued properties in
CIM are unordered.
o There is no distinction in a CIM class between mandatory and
optional properties. Aside from the key properties (designated for
naming instances of the class), all properties are optional.
o CIM classes and properties are identified by name, not by OID.
o In LDAP, attribute definitions are global, and the same attribute
may appear in multiple classes. In CIM, a property is defined
within the scope of a single class definition. The property may be
inherited into subclasses of the class in which it is defined, but
otherwise it cannot appear in other classes. One side effect of
this difference is that CIM property names tend to be much shorter
than LDAP attribute names, since they are implicitly scoped by the
name of the class in which they are defined.
Moore, et al. Expires: Jun 1999 + 6 months [Page 11]
Internet Draft Policy Core Information Model June 1999
For the complete definition of the CIM specification language, see
reference [7].
6.1. The Abstract Class "Policy"
The abstract class Policy collects five properties that may be
included in instances of any of the Core Policy classes (or their
subclasses).
The class definition is as follows:
NAME Policy
DESCRIPTION An abstract class with five properties for
describing a policy-related instance.
DERIVED FROM Top
ABSTRACT TRUE
PROPERTIES CreationClassName[key]
CommonName (CN)
Caption
Description
PolicyKeywords[ ]
6.1.1. The Key Property "CreationClassName"
As discussed above in Section 5, this property is used to scope
instance names to the classes of the instances being named. Its value
is the name of the class which its instance instantiates. Since the
class Policy is abstract, CreationClassName is not used to name
instances of Policy itself. It is used, however, to name instances of
all subclasses of Policy.
NAME CreationClassName
DESCRIPTION The name of the class that a policy-related object
instantiates.
SYNTAX string
QUALIFIER key
6.1.2. The Property "CommonName (CN)"
The CN, or CommonName, property corresponds to the X.500 attribute
commonName (cn). In X.500 this property specifies one or more user-
friendly names (typically only one name) by which an object is
commonly known, names that conform to the naming conventions of the
country or culture with which the object is associated. In the CIM
model, however, the CommonName property is single-valued.
NAME CN
DESCRIPTION A user-friendly name of a policy-related object.
SYNTAX string
Moore, et al. Expires: Jun 1999 + 6 months [Page 12]
Internet Draft Policy Core Information Model June 1999
6.1.3. The Property "Caption"
This property provides a one-line description of a policy-related CIM
object.
NAME Caption
DESCRIPTION A one-line description of this policy-related
object.
SYNTAX string
6.1.4. The Property "Description"
This property provides a longer description than that provided by the
caption property.
NAME Description
DESCRIPTION A long description of this policy-related object.
SYNTAX string
6.1.5. The Multi-valued Property "PolicyKeywords"
This property provides a set of one or more keywords that a policy
administrator may use to assist in characterizing or categorizing a
policy object. Keywords are of one of two types:
o Keywords defined in this document, or in documents that define
subclasses of the classes defined in this document. These keywords
provide a vendor-independent, installation-independent way of
characterizing policy objects.
o Installation-dependent keywords for characterizing policy objects.
Examples include "Engineering", "Billing", and "Review in December
1999".
This document defines the following keywords: "UNKNOWN",
"CONFIGURATION", "USAGE", "SECURITY", "SERVICE", "MOTIVATIONAL",
"INSTALLATION", and "EVENT". These concepts were defined earlier in
Section 2.
One additional keyword is defined: "POLICY". The role of this
keyword is to identify policy-related instances that would not
otherwise be identifiable as being related to policy.
Documents that define subclasses of the Policy Core Information Model
classes SHOULD define additional keywords to characterize instances of
these subclasses. By convention, keywords defined in conjunction with
class definitions are in uppercase. Installation-defined keywords can
be in any case.
The property definition is as follows:
NAME PolicyKeywords
Moore, et al. Expires: Jun 1999 + 6 months [Page 13]
Internet Draft Policy Core Information Model June 1999
DESCRIPTION A set of keywords for characterizing /categorizing
policy objects.
SYNTAX string
6.2. The Class "PolicyGroup"
This class is a generalized aggregation container. It enables either
PolicyRules or PolicyGroups, but not both, to be aggregated in a
single container. Loops, including the degenerate case of a
PolicyGroup that contains itself, are not allowed when PolicyGroups
contain other PolicyGroups.
PolicyGroups and their nesting capabilities are shown in Figure 4
below. Note that a PolicyGroup can nest other PolicyGroups, and there
is no restriction on the depth of the nesting in sibling PolicyGroups.
+---------------------------------------------------+
| PolicyGroup |
| |
| +--------------------+ +-----------------+ |
| | PolicyGroup A | | PolicyGroup X | |
| | | | | |
| | +----------------+ | ooo | | |
| | | PolicyGroup A1 | | | | |
| | +----------------+ | | | |
| +--------------------+ +-----------------+ |
+---------------------------------------------------+
Figure 4. Overview of the PolicyGroup class
As a simple example, think of the highest level PolicyGroup shown in
Figure 4 above as a logon policy for US employees of a company. This
PolicyGroup may be called USEmployeeLogonPolicy, and may aggregate
several PolicyGroups that provide specialized rules per location.
Hence, PolicyGroup A in Figure 4 above may define logon rules for
employees on the West Coast, while another PolicyGroup might define
logon rules for the Midwest (e.g., PolicyGroup X), and so forth.
Note also that the depth of each PolicyGroup does not need to be the
same. Thus, the WestCoast PolicyGroup might have several additional
layers of PolicyGroups defined for any of several reasons (different
locales, number of subnets, etc.). The PolicyRules are therefore
contained at n levels from the USEmployeeLogonPolicyGroup. Compare
this to the Midwest PolicyGroup (PolicyGroup X), which might directly
contain PolicyRules.
The class definition for PolicyGroup is as follows:
NAME PolicyGroup
DESCRIPTION A container for either a set of related PolicyRules
or a set of related PolicyGroups.
DERIVED FROM Policy
Moore, et al. Expires: Jun 1999 + 6 months [Page 14]
Internet Draft Policy Core Information Model June 1999
ABSTRACT FALSE
PROPERTIES PolicyGroupName[key]
6.2.1. The Key Property "PolicyGroupName"
This property provides a user-friendly name for a policy group, and is
normally what will be displayed to the end-user as the instance name.
It is defined as follows:
NAME PolicyGroupName
DESCRIPTION The user-friendly name of this policy group.
SYNTAX string
QUALIFIER key
6.3. The Class "PolicyRule"
This class represents the "If Condition then Action" semantics
associated with a policy. A PolicyRule condition, in the most general
sense, is represented as either an ORed set of ANDed conditions
(Disjunctive Normal Form, or DNF) or an ANDed set of ORed conditions
(Conjunctive Normal Form, or CNF). Individual conditions may either be
negated (NOT C) or unnegated (C). The actions specified by a
PolicyRule are to be performed if and only if the PolicyRule condition
(whether it is represented in DNF or CNF) evaluates to TRUE.
The conditions and actions associated with a policy rule are modeled,
respectively, with subclasses of the classes PolicyCondition and
PolicyAction. These condition and action objects are tied to
instances of PolicyRule by the ContainedPolicyCondition and
ContainedPolicyAction aggregations.
As illustrated above in Section 3, a policy rule may also be
associated with one or more policy time periods, indicating the
schedule according to which the policy rule is active and inactive.
In this case it is the PolicyRuleValidityPeriod aggregation that
provides the linkage.
A policy rule is illustrated conceptually in Figure 5. below.
+------------------------------------------------+
| PolicyRule |
| |
| +--------------------+ +-----------------+ |
| | PolicyCondition(s) | | PolicyAction(s) | |
| +--------------------+ +-----------------+ |
| |
| +------------------------------+ |
| | PolicyTimePeriodCondition(s) | |
| +------------------------------+ |
+------------------------------------------------+
Figure 5. Overview of the PolicyRule Class
Moore, et al. Expires: Jun 1999 + 6 months [Page 15]
Internet Draft Policy Core Information Model June 1999
The PolicyRule class uses the property ConditionListType, to indicate
whether the conditions for the rule are in DNF or CNF. The
ContainedPolicyCondition aggregation contains two additional
properties to complete the representation of the rule's conditional
expression. The first of these properties is an integer to partition
the referenced conditions into one or more sets, and the second is a
Boolean to indicate whether a referenced condition is negated. An
example shows how ConditionListType and these two additional
properties provide a unique representation of a set of conditions in
either DNF or CNF.
Suppose we have a PolicyRule that aggregates five PolicyConditions C1
through C5, with the following values in the properties of the five
ContainedPolicyCondition relationships:
C1: GroupNumber = 1, ConditionNegated = FALSE
C2: GroupNumber = 1, ConditionNegated = TRUE
C3: GroupNumber = 1, ConditionNegated = FALSE
C4: GroupNumber = 2, ConditionNegated = FALSE
C5: GroupNumber = 2, ConditionNegated = FALSE
If ConditionListType = DNF, then the overall condition for the
PolicyRule is:
(C1 AND (NOT C2) AND C3) OR (C4 AND C5)
On the other hand, if ConditionListType = CNF, then the overall
condition for the PolicyRule is:
(C1 OR (NOT C2) OR C3) AND (C4 OR C5)
In both cases, there is an unambiguous specification of the overall
condition that is tested to determine whether to perform the actions
associated with the PolicyRule.
The class definition is as follows:
NAME PolicyRule
DESCRIPTION The central class for representing the "If
Condition then Action" semantics associated with a
policy rule.
DERIVED FROM Policy
ABSTRACT FALSE
PROPERTIES PolicyRuleName[key]
Enabled
ConditionListType
RuleUsage
Priority
Mandatory
SequencedActions
Moore, et al. Expires: Jun 1999 + 6 months [Page 16]
Internet Draft Policy Core Information Model June 1999
6.3.1. The Key Property "PolicyRuleName"
This property provides a user-friendly name for a policy rule, and is
normally what will be displayed to the end-user as the instance name.
It is defined as follows:
NAME PolicyRuleName
DESCRIPTION The user-friendly name of this policy rule.
SYNTAX string
QUALIFIER key
6.3.2. The Property "Enabled"
This property indicates whether a policy rule is currently enabled,
from an ADMINISTRATIVE point of view. Its purpose is to allow a
policy administrator to enable or disable a policy rule without having
to add it to, or remove it from, the policy repository.
The property also supports the value 'enabledForDebug'. When the
property has this value, the Policy Decision Point is being told to
evaluate the conditions for the policy rule, but not to perform the
actions if the conditions evaluate to TRUE. This value serves as a
debug vehicle when attempting to determine what policies would execute
in a particular scenario, without taking any actions to change state
during the debugging.
The property definition is as follows:
NAME Enabled
DESCRIPTION An enumeration indicating whether a policy rule is
administratively enabled, administratively
disabled, or enabled for debug mode.
SYNTAX uint16
VALUES enabled(1), disabled(2), enabledForDebug(3)
DEFAULT VALUE enabled(1)
6.3.3. The Property "ConditionListType"
This property is used to specify whether the list of policy conditions
associated with this policy rule is in disjunctive normal form (DNF)
or conjunctive normal form (CNF). If this property is not present,
the list type defaults to DNF. The property definition is as follows:
NAME ConditionListType
DESCRIPTION Indicates whether the list of policy conditions
associated with this policy rule is in disjunctive
normal form (DNF) or conjunctive normal form (CNF).
SYNTAX uint16
VALUES DNF(1), CNF(2)
DEFAULT VALUE DNF(1)
Moore, et al. Expires: Jun 1999 + 6 months [Page 17]
Internet Draft Policy Core Information Model June 1999
6.3.4. The Property "RuleUsage"
This property is a free-form string that recommends how this policy
should be used. The property definition is as follows:
NAME PolicyRuleUsage
DESCRIPTION This property is used to provide guidelines on how
this policy should be used.
SYNTAX string
6.3.5. The Property "Priority"
This property provides a non-negative integer for prioritizing policy
rules relative to each other. For policy rules that have this
property, larger integer values indicate higher priority. Since one
purpose of this property is to allow specific, ad hoc policy rules to
temporarily override established policy rules, an instance that has
this property set has a higher priority than all instances that lack
it.
Prioritization among policy rules provides a simple and efficient
mechanism for resolving policy conflicts.
The property definition is as follows:
NAME Priority
DESCRIPTION A non-negative integer for prioritizing this
PolicyRule relative to other PolicyRules. A larger
value indicates a higher priority.
SYNTAX uint16
DEFAULT VALUE 0
6.3.6. The Property "Mandatory"
This property indicates whether evaluation (and possibly action
execution) of a PolicyRule is mandatory or not. Its concept is
similar to the ability to mark packets for delivery or possible
discard, based on network traffic and device load.
The evaluation of a PolicyRule MUST be attempted if the
PolicyRuleMandatory property value is TRUE. If the
PolicyRuleMandatory property value of a PolicyRule is FALSE, then the
evaluation of the rule is "best effort" and MAY be ignored.
The property definition is as follows:
NAME PolicyRuleMandatory
DESCRIPTION A flag indicating that the evaluation of the
PolicyConditions and execution of PolicyActions (if
the condition list evaluates to TRUE) is required.
SYNTAX boolean
DEFAULT VALUE TRUE
Moore, et al. Expires: Jun 1999 + 6 months [Page 18]
Internet Draft Policy Core Information Model June 1999
6.3.7. The Property "SequencedActions"
This property gives a policy administrator a way of specifying how the
ordering of the policy actions associated with this PolicyRule is to
be interpreted. Three values are supported:
o mandatory(1): Do the actions in the indicated order, or don't do
them at all.
o recommended(2): Do the actions in the indicated order if you can,
but if you can't do them in this order, do them in another order if
you can.
o dontCare(3): Do them -- I don't care about the order.
When error / event reporting is addressed for the Policy Framework,
suitable codes will be defined for reporting that a set of actions
could not be performed in an order specified as mandatory (and thus
were not performed at all), that a set of actions could not be
performed in a recommended order (and moreover could not be performed
in any order), or that a set of actions could not be performed in a
recommended order (but were performed in a different order). The
property definition is as follows:
NAME SequencedActions
DESCRIPTION An enumeration indicating how to interpret the
action ordering indicated via the
ContainedPolicyAction aggregation.
SYNTAX uint16
VALUES mandatory(1), recommended(2), dontCare(3)
DEFAULT VALUE dontCare(3)
6.4. The Class "PolicyCondition"
The purpose of a policy condition is to determine whether or not the
set of actions (aggregated in the PolicyRule that the condition
applies to) should be executed or not. For the purposes of the Policy
Core Information Model, all that matters about an individual
PolicyCondition is that it evaluates to TRUE or FALSE. (The
individual PolicyConditions associated with a PolicyRule are combined
to form a compound expression in either DNF or CNF, but this is
accomplished via the ConditionListType property, discussed above, and
by the properties of the ContainedPolicyCondition aggregation,
introduced above and discussed further in Section 7.6 below.) A
logical structure WITHIN an individual PolicyCondition may also be
introduced, but this would have to be done in a subclass of
PolicyCondition.
Moore, et al. Expires: Jun 1999 + 6 months [Page 19]
Internet Draft Policy Core Information Model June 1999
+---------------------------------------------------------------+
| Policy Conditions in DNF |
| +-------------------------+ +-----------------------+ |
| | AND list | | AND list | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | ... | | PolicyCondition | | |
| | +-------------------+ | ORed | +-----------------+ | |
| | ... | | ... | |
| | ANDed | | ANDed | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| +-------------------------+ +-----------------------+ |
+---------------------------------------------------------------+
Figure 6. Overview of Policy Conditions in DNF
This figure illustrates that when policy conditions are in DNF, there
are one or more sets of conditions that are ANDed together to form AND
lists. An AND list evaluates to TRUE if and only if all of its
constituent conditions evaluate to TRUE. The overall condition then
evaluates to TRUE if and only if at least one of its constituent AND
lists evaluates to TRUE.
+---------------------------------------------------------------+
| Policy Conditions in CNF |
| +-------------------------+ +-----------------------+ |
| | OR list | | OR list | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | ... | | PolicyCondition | | |
| | +-------------------+ | ANDed | +-----------------+ | |
| | ... | | ... | |
| | ORed | | ORed | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| +-------------------------+ +-----------------------+ |
+---------------------------------------------------------------+
Figure 7. Overview of Policy Conditions in CNF
In this figure, the policy conditions are in CNF. Consequently, there
are one or more OR lists, each of which evaluates to TRUE if and only
if at least one of its constituent conditions evaluates to TRUE. The
Moore, et al. Expires: Jun 1999 + 6 months [Page 20]
Internet Draft Policy Core Information Model June 1999
overall condition then evaluates to TRUE if and only if ALL of its
constituent OR lists evaluate to TRUE. The class definition is as
follows:
NAME PolicyCondition
DESCRIPTION A class representing a condition to be evaluated in
conjunction with a policy rule.
DERIVED FROM Policy
ABSTRACT FALSE
PROPERTIES PolicyConditionName[key]
6.4.1. The Key Property "PolicyConditionName"
This property provides a user-friendly name for a policy condition,
and is normally what will be displayed to the end-user as the instance
name. It is defined as follows:
NAME PolicyConditionName
DESCRIPTION The user-friendly name of this policy condition.
SYNTAX string
QUALIFIER key
6.5. The Class "PolicyTimePeriodCondition"
This class provides a means of representing the time periods during
which a policy rule is valid, i.e., active. At all times that fall
outside these time periods, the policy rule has no effect. A policy
rule is treated as valid at all times if it does not specify a
PolicyTimePeriodCondition.
In some cases a PDP may need to perform certain setup / cleanup
actions when a policy rule becomes active / inactive. For example,
sessions that were established while a policy rule was active might
need to be taken down when the rule becomes inactive. In other cases,
however, such sessions might be left up: in this case, the effect of
deactivating the policy rule would just be to prevent the
establishment of new sessions. Any such setup / cleanup behaviors on
validity period transitions must be specified in a subclass of
PolicyRule. If such behaviors need to be under the control of the
policy administrator, then a mechanism to allow this control must also
be specified in the subclass.
PolicyTimePeriodCondition is defined as a subclass of PolicyCondition.
This is to allow the inclusion of time-based criteria in the AND/OR
condition definitions for a PolicyRule.
Instances of this class may have up to five properties identifying
time periods at different levels. The values of all the properties
present in an instance are ANDed together to determine the validity
period(s) for the instance. For example, an instance with an overall
validity range of January 1, 1999 through December 31, 1999; a month
mask of "001100000000" (March and April); a day-of-the-week mask of
Moore, et al. Expires: Jun 1999 + 6 months [Page 21]
Internet Draft Policy Core Information Model June 1999
"0000100" (Fridays); and a time of day range of 0800 through 1600
would represent the following time periods:
Friday, March 5, 1999, from 0800 through 1600;
Friday, March 12, 1999, from 0800 through 1600;
Friday, March 19, 1999, from 0800 through 1600;
Friday, March 26, 1999, from 0800 through 1600;
Friday, April 2, 1999, from 0800 through 1600;
Friday, April 9, 1999, from 0800 through 1600;
Friday, April 16, 1999, from 0800 through 1600;
Friday, April 23, 1999, from 0800 through 1600;
Friday, April 30, 1999, from 0800 through 1600.
Attributes not present in an instance of PolicyTimePeriodCondition are
implicitly treated as having their value "always enabled". Thus, in
the example above, the day-of-the-month mask is not present, and so
the validity period for the instance implicitly includes a day-of-the-
month mask containing 31 1's. If we apply this "missing property"
rule to its fullest, we see that there is a second way to indicate
that a policy rule is always enabled: have it point to an instance of
PolicyTimePeriodCondition whose only properties are its naming
properties.
The class definition is as follows. Note that instances of this class
are named with the inherited key properties CreationClassName and
PolicyRuleName.
NAME PolicyTimePeriodCondition
DESCRIPTION A class that provides the capability of enabling /
disabling a policy rule according to a pre-
determined schedule.
DERIVED FROM PolicyCondition
ABSTRACT FALSE
PROPERTIES TimePeriod
MonthOfYearMask
DayOfMonthMask
DayOfWeekMask
TimeOfDayMask
ApplicableTimeZone
6.5.1. The Property "TimePeriod"
This property identifies an overall range of calendar dates and times
over which a policy rule is valid. It is formatted as a string
consisting of a start date and time, then a colon (':'), and followed
by an end date and time. The first date indicates the beginning of
the range, while the second date indicates the end. Thus, the second
date and time must be later than the first. Dates are expressed as
substrings of the form "yyyymmddhhmmss". For example:
Moore, et al. Expires: Jun 1999 + 6 months [Page 22]
Internet Draft Policy Core Information Model June 1999
19990101080000:19990131120000
January 1, 1999, 0800 through January 31, 1999, noon
There are three special cases that can also be represented with this
format:
o If the date before the ':' is omitted, then the property indicates
that a policy rule is valid [from now] until the date that appears
after the ':'.
o If the date after the ':' is omitted, then the property indicates
that a policy rule becomes valid on the date that appears before
the ':', and remains valid from that point on.
o If both dates are omitted (i.e., if the string contains only the
':' character), then the property indicates that a policy rule is
valid now, and remains valid from now on.
The property definition is as follows:
NAME TimePeriod
DESCRIPTION The range of calendar dates on which a policy rule
is valid.
SYNTAX string
FORMAT [yyyymmddhhmmss]:[yyyymmddhhmmss]
6.5.2. The Property "MonthOfYearMask"
The purpose of this property is to refine the definition of the valid
time period that is defined by the TimePeriod property, by explicitly
specifying which months the policy is valid for. These properties
work together, with the TimePeriod used to specify the overall time
period that the policy is valid for, and the MonthOfYearMask used to
pick out which months of that time period the policy is valid for.
This property is formatted as a string containing 12 ASCII '0's and
'1's, where the '1's identify the months (beginning with January) in
which the policy rule is valid. The value "000010010000", for
example, indicates that a policy rule is valid only in the months May
and August.
If this property is omitted, then the policy rule is treated as valid
for all twelve months. The property definition is as follows:
NAME MonthOfYearMask
DESCRIPTION A mask identifying the months of the year in which
a policy rule is valid.
SYNTAX string
FORMAT A string of 12 ASCII '0's and '1's.
Moore, et al. Expires: Jun 1999 + 6 months [Page 23]
Internet Draft Policy Core Information Model June 1999
6.5.3. The Property "DayOfMonthMask"
The purpose of this property is to refine the definition of the valid
time period that is defined by the TimePeriod property, by explicitly
specifying which days of the month the policy is valid for. These
properties work together, with the TimePeriod used to specify the
overall time period that the policy is valid for, and the
DayOfMonthMask used to pick out which days of the month in that time
period the policy is valid for.
This property is formatted as a string containing 31 ASCII '0's and
'1's, where the '1's identify the days of the month (beginning with
day 1 and going up through day 31) on which the policy rule is valid.
The value "1110000000000000000000000000000", for example, indicates
that a policy rule is valid only on the first three days of each
month. For months with fewer than 31 days, the digits corresponding
to days that the months do not have are ignored. The property
definition is as follows:
NAME DayOfMonthMask
DESCRIPTION A mask identifying the days of the month on which a
policy rule is valid.
SYNTAX string
FORMAT A string of 31 ASCII '0's and '1's.
6.5.4. The Property "DayOfWeekMask"
The purpose of this property is to refine the definition of the valid
time period that is defined by the TimePeriod property by explicitly
specifying which days of the week the policy is valid for. These
properties work together, with the TimePeriod used to specify the
overall time period that the policy is valid for, and the
DayOfWeekMask used to pick out which days of the week in that time
period the policy is valid for.
This property is formatted as a string containing 7 ASCII '0's and
'1's, where the '1's identify the days of the week (beginning with
Monday and going up through Sunday) on which the policy rule is valid.
The value "1111100", for example, indicates that a policy rule is
valid Monday through Friday.
The property definition is as follows:
NAME DayOfWeekMask
DESCRIPTION A mask identifying the days of the week on which a
policy rule is valid.
SYNTAX string
FORMAT A string of 7 ASCII '0's and '1's.
Moore, et al. Expires: Jun 1999 + 6 months [Page 24]
Internet Draft Policy Core Information Model June 1999
6.5.5. The Property "TimeOfDayMask"
The purpose of this property is to refine the definition of the valid
time period that is defined by the TimePeriod property by explicitly
specifying a range of times in a day the policy is valid for. These
properties work together, with the TimePeriod used to specify the
overall time period that the policy is valid for, and the
TimeOfDayMask used to pick out which range of time periods in a given
day of that time period the policy is valid for.
This property is formatted as a string containing two times, separated
by a colon (':'). The first time indicates the beginning of the
range, while the second time indicates the end. Times are expressed
as substrings of the form "hhmmss".
The second substring always identifies a later time than the first
substring. To allow for ranges that span midnight, however, the value
of the second string may be smaller than the value of the first
substring. Thus, "080000:210000" identifies the range from 0800 until
2100, while "210000:080000" identifies the range from 2100 until 0800
of the following day.
When a range spans midnight, it by definition includes parts of two
successive days. When one of these days is also selected by either
the MonthOfYearMask, DayOfMonthMask, and/or DayOfWeekMask, but the
other day is not, then the policy is active only during the portion of
the range that falls on the selected day. For example, if the range
extends from 2100 until 0800, and the day of week mask selects Monday
and Tuesday, then the policy is active during the following three
intervals:
From midnight Sunday until 0800 Monday;
From 2100 Monday until 0800 Tuesday;
From 2100 Tuesday until 21:59:59 Tuesday.
The property definition is as follows:
NAME TimeOfDayMask
DESCRIPTION The range of times at which a policy rule is valid.
If the second time is earlier than the first, then
the interval spans midnight.
SYNTAX string
FORMAT hhmmss:hhmmss
6.5.6. The Property "ApplicableTimeZone"
This property is used to explicitly define a time zone for use by the
TimePeriod and the various Mask properties. If this property is not
present, then local time (at the location where the PolicyRule is
enforced -- in other words, at the Policy Enforcement Point) is
assumed.
Moore, et al. Expires: Jun 1999 + 6 months [Page 25]
Internet Draft Policy Core Information Model June 1999
This property specifies time in UTC, using an offset indicator. The
UTC offset indicator is either a 'Z', indicating UTC, or a substring
of the following form:
'+' or '-' direction from UTC: '+' = east, '-' = west
hh hours from UTC (00..13)
mm minutes from UTC (00..59)
For example, the string "+0200" indicates a time zone two hours east
of UTC, and the string "-0830" indicates a time zone 8.5 hours west of
UTC.
The property definition is as follows:
NAME ApplicableTimeZone
DESCRIPTION The time zone for the PolicyTimePeriodCondition.
SYNTAX string
FORMAT either 'Z' (UTC) or <'+'|'-'><hhmm>
6.6. The Class "VendorPolicyCondition"
The purpose of this class is to provide a general escape mechanism for
representing policy conditions that have not been modeled with
specific properties. Instead, the two properties Constraint and
ConstraintEncoding are used to define the content and format of the
condition, as explained below.
As its name suggests, this class is intended for vendor-specific
extensions to the Policy Core Information Model. Standardized
extensions are not expected to use this class.
The class definition is as follows:
NAME VendorPolicyCondition
DESCRIPTION A class that defines a registered means to describe
a policy condition.
DERIVED FROM PolicyCondition
ABSTRACT FALSE
PROPERTIES Constraint[ ]
ConstraintEncoding
6.6.1. The Multi-valued Property "Constraint"
This property provides a general escape mechanism for representing
policy conditions that have not been modeled with specific properties.
The format of the uint8 array is left unspecified in this definition.
It is determined by the OID value stored in the property
ConstraintEncoding. Since ConstraintEncoding is single-valued, all
the values of Constraint share the same format and semantics.
Moore, et al. Expires: Jun 1999 + 6 months [Page 26]
Internet Draft Policy Core Information Model June 1999
A policy decision point can readily determine whether it supports the
values stored in an instance of Constraint by checking the OID value
from ConstraintEncoding against the set of OIDs it recognizes. The
action for the policy decision point to take in case it does not
recognize the format of this data could itself be modeled as a policy
rule, governing the behavior of the policy decision point.
The property is defined as follows:
NAME Constraint
DESCRIPTION Escape mechanism for representing constraints that
have not been modeled as specific properties. The
format of the values is identified by the OID
stored in the property ConstraintEncoding.
SYNTAX uint8
6.6.2. The Property "ConstraintEncoding"
This property identifies the encoding and semantics of the Constraint
property values in this instance. The value of this property is a
single string, representing a single OID.
The property is defined as follows:
NAME ConstraintEncoding
DESCRIPTION An OID encoded as a string, identifying the format
and semantics for this instance's Constraint
property.
SYNTAX string
QUALIFIER OID
6.7. The Class "PolicyAction"
The purpose of a policy action is to execute one or more operations
that will affect network traffic and/or systems, devices, etc. in
order to achieve a desired policy state. This (new) policy state
provides one or more (new) behaviors. A policy action ordinarily
changes the configuration of one or more elements.
A PolicyRule contains one or more policy actions. A policy
administrator can assign an order to the actions associated with a
PolicyRule, complete with an indication of whether the indicated order
is mandatory, recommended, or of no significance. Ordering of the
actions associated with a PolicyRule is accomplished via a property in
the ContainedPolicyAction aggregation.
The actions associated with a PolicyRule are executed if and only if
the overall condition(s) of the PolicyRule evaluates to TRUE.
The class definition is as follows:
Moore, et al. Expires: Jun 1999 + 6 months [Page 27]
Internet Draft Policy Core Information Model June 1999
NAME PolicyAction
DESCRIPTION A class representing an action to be performed if
the condition for a policy rule evaluates to TRUE.
DERIVED FROM Policy
ABSTRACT FALSE
PROPERTIES PolicyActionName[key]
6.7.1. The Key Property "PolicyActionName"
This property provides a user-friendly name for a policy action, and
is normally what will be displayed to the end-user as the instance
name. It is defined as follows:
NAME PolicyActionName
DESCRIPTION The user-friendly name of this policy action.
SYNTAX string
QUALIFIER key
6.8. The Class "VendorPolicyAction"
The purpose of this class is to provide a general escape mechanism for
representing policy actions that have not been modeled with specific
properties. Instead, the two properties ActionData and ActionEncoding
are used to define the content and format of the action, as explained
below.
As its name suggests, this class is intended for vendor-specific
extensions to the Policy Core Information Model. Standardized
extensions are not expected to use this class.
The class definition is as follows:
NAME VendorPolicyAction
DESCRIPTION A class that defines a registered means to describe
a policy action.
DERIVED FROM PolicyAction
ABSTRACT FALSE
PROPERTIES ActionData[ ]
ActionEncoding
6.8.1. The Multi-valued Property "ActionData"
This property provides a general escape mechanism for representing
policy actions that have not been modeled with specific properties.
The format of the uint8 array is left unspecified in this definition.
It is determined by the OID value stored in the property
ActionEncoding. Since ActionEncoding is single-valued, all the values
of ActionData share the same format and semantics.
Moore, et al. Expires: Jun 1999 + 6 months [Page 28]
Internet Draft Policy Core Information Model June 1999
A policy decision point can readily determine whether it supports the
values stored in an instance of ActionData by checking the OID value
from ActionEncoding against the set of OIDs it recognizes. The action
for the policy decision point to take in case it does not recognize
the format of this data could itself be modeled as a policy rule,
governing the behavior of the policy decision point.
The property is defined as follows:
NAME ActionData
DESCRIPTION Escape mechanism for representing actions that have
not been modeled as specific properties. The format
of the values is identified by the OID stored in
the property ActionEncoding.
SYNTAX uint8
6.8.2. The Property "ActionEncoding"
This property identifies the encoding and semantics of the ActionData
property values in this instance. The value of this property is a
single string, representing a single OID.
The property is defined as follows:
NAME ActionEncoding
DESCRIPTION An OID encoded as a string, identifying the format
and semantics for this instance's ActionData
property.
SYNTAX string
QUALIFIER OID
7. Association and Aggregation Definitions
The first three subsections of this section introduce relationships,
associations, and aggregations as they are used in CIM. The remaining
subsections present the class definitions for the associations and
aggregations that are part of the Policy Core Information Model.
7.1. Relationships
Relationships are a central feature of information models. A
relationship represents a physical or conceptual connection between
objects. CIM and DEN define the general concept of an association
between two (or more) objects. Two types of relationships in CIM are
aggregations (which express whole-part relationships) and
associations, such as those that express dependency. Both are
represented as classes, and both are used in this model.
Moore, et al. Expires: Jun 1999 + 6 months [Page 29]
Internet Draft Policy Core Information Model June 1999
7.2. Associations
An association is a class that contains two or more references, where
each reference identifies another object. An association is defined
using a class. Associations can be defined between classes without
affecting any of the related classes. That is, addition of an
association does not affect the interface of the related classes.
7.3. Aggregations
An aggregation is a strong form of an association. An aggregation is
usually used to represent a "whole-part" relationship. This type of
relationship defines the containment relationship between a system and
the components that make up the system. Aggregation often implies,
but does not require, that the aggregated objects have mutual
dependencies.
7.4. The Aggregation "ContainedPolicyGroup"
The ContainedPolicyGroup aggregation enables policy groups to be
nested. This is critical for scalability and manageability, as it
enables complex policies to be constructed from multiple simpler
policies for administrative convenience. For example, a policy group
representing policies for the US might have nested within it policy
groups for the Eastern and Western US.
A PolicyGroup may aggregate other PolicyGroups via this aggregation,
or it may aggregate PolicyRules via the ContainedPolicyRule
aggregation. But a single PolicyGroup SHALL NOT do both.
The class definition for the aggregation is as follows:
NAME ContainedPolicyGroup
DESCRIPTION A class representing the aggregation of
PolicyGroups by a higher-level PolicyGroup.
DERIVED FROM Top
ABSTRACT FALSE
PROPERTIES ContainingGroup[ref PolicyGroup[0..n]]
ContainedGroup[ref PolicyGroup[0..n]]
7.4.1. The Reference "ContainingGroup"
This property contains the name of a PolicyGroup that contains one or
more other PolicyGroups. Note that for any single instance of the
association class ContainedPolicyGroup, this property (like all
Reference properties) is single-valued. The [0..n] cardinality
indicates that there may be 0, 1, or more than one PolicyGroups that
contain any given PolicyGroup.
Moore, et al. Expires: Jun 1999 + 6 months [Page 30]
Internet Draft Policy Core Information Model June 1999
7.4.2. The Reference "ContainedGroup"
This property contains the name of a PolicyGroup contained by one or
more other PolicyGroups. Note that for any single instance of the
association class ContainedPolicyGroup, this property (like all
Reference properties) is single-valued. The [0..n] cardinality
indicates that a given PolicyGroup may contain 0, 1, or more than one
other PolicyGroups.
7.5. The Aggregation "ContainedPolicyRule"
A policy group may aggregate one or more policy rules, via the
ContainedPolicyRule aggregation. Grouping of policy rules into a
policy group is again for administrative convenience; a policy rule
may also be used by itself, without belonging to a policy group.
A PolicyGroup may aggregate PolicyRules via this aggregation, or it
may aggregate other PolicyGroups via the ContainedPolicyGroup
aggregation. But a single PolicyGroup SHALL NOT do both.
The class definition for the aggregation is as follows:
NAME ContainedPolicyRule
DESCRIPTION A class representing the aggregation of PolicyRules
by a PolicyGroup.
DERIVED FROM Top
ABSTRACT FALSE
PROPERTIES ContainingGroup[ref PolicyGroup[0..n]]
ContainedRule[ref PolicyRule[0..n]]
7.5.1. The Reference "ContainingGroup"
This property contains the name of a PolicyGroup that contains one or
more PolicyRules. Note that for any single instance of the
association class ContainedPolicyRule, this property (like all
Reference properties) is single-valued. The [0..n] cardinality
indicates that there may be 0, 1, or more than one PolicyGroups that
contain any given PolicyRule.
7.5.2. The Reference "ContainedRule"
This property contains the name of a PolicyRule contained by one or
more PolicyGroups. Note that for any single instance of the
association class ContainedPolicyRule, this property (like all
Reference properties) is single-valued. The [0..n] cardinality
indicates that a given PolicyGroup may contain 0, 1, or more than one
PolicyRules.
7.6. The Aggregation "ContainedPolicyCondition"
A policy rule aggregates zero or more instances of the PolicyCondition
class, via the ContainedPolicyCondition association. A policy rule
Moore, et al. Expires: Jun 1999 + 6 months [Page 31]
Internet Draft Policy Core Information Model June 1999
that aggregates zero policy conditions is not a valid rule -- it may,
for example, be in the process of being entered into the policy
repository. A policy rule has no effect until it is valid. The
conditions aggregated by a policy rule are grouped into two levels of
lists: either an ORed set of ANDed sets of conditions (DNF, the
default) or an ANDed set of ORed sets of conditions (CNF). Individual
conditions in these lists may be negated. The property
ConditionListType specifies which of these two grouping schemes
applies to a particular PolicyRule.
Since conditions may be defined explicitly in a subclass of
PolicyRule, the AND/OR mechanism to combine these conditions with
other (associated) PolicyConditions MUST be specified by the
PolicyRule's subclass.
In either case, the conditions are used to determine whether to
perform the actions associated with the PolicyRule.
One or more policy time periods may be among the conditions associated
with a policy rule via the ContainedPolicyCondition association. In
this case, the time periods are simply additional conditions to be
evaluated along with any other conditions specified for the rule.
The class definition for the aggregation is as follows:
NAME ContainedPolicyCondition
DESCRIPTION A class representing the aggregation of
PolicyConditions by a PolicyRule.
DERIVED FROM Top
ABSTRACT FALSE
PROPERTIES ContainingRule[ref PolicyRule[0..n]]
ContainedCondition[ref PolicyCondition[0..n]]
GroupNumber
ConditionNegated
7.6.1. The Reference "ContainingRule"
This property contains the name of a PolicyRule that contains one or
more PolicyConditions. Note that for any single instance of the
association class ContainedPolicyCondition, this property (like all
Reference properties) is single-valued. The [0..n] cardinality
indicates that there may be 0, 1, or more than one PolicyRules that
contain any given PolicyCondition.
7.6.2. The Reference "ContainedCondition"
This property contains the name of a PolicyCondition contained by one
or more PolicyRules. Note that for any single instance of the
association class ContainedPolicyCondition, this property (like all
Reference properties) is single-valued. The [0..n] cardinality
indicates that a given PolicyRule may contain 0, 1, or more than one
PolicyConditions.
Moore, et al. Expires: Jun 1999 + 6 months [Page 32]
Internet Draft Policy Core Information Model June 1999
7.6.3. The Property "GroupNumber"
This property contains an integer identifying the group to which the
condition referenced by the ContainedCondition property is assigned in
forming the overall conditional expression for the policy rule
identified by the ContainingRule reference.
The property is defined as follows:
NAME GroupNumber
DESCRIPTION Unsigned integer indicating the group to which the
condition identified by the ContainedCondition
property is to be assigned.
SYNTAX uint16
7.6.4. The Property "ConditionNegated"
This property is a boolean, indicating whether the condition
referenced by the ContainedCondition property is negated in forming
the overall conditional expression for the policy rule identified by
the ContainingRule reference.
The property is defined as follows:
NAME ConditionNegated
DESCRIPTION Indication of whether the condition identified by
the ContainedCondition property is negated. (TRUE
indicates that the condition IS negated, FALSE
indicates that it IS NOT negated.)
SYNTAX boolean
7.7. The Aggregation "PolicyRuleValidityPeriod"
A different relationship between a policy rule and a policy time
period is represented by the PolicyRuleValidityPeriod association:
scheduled activation and deactivation of the policy rule. If a policy
rule is associated with multiple policy time periods via this
association, then the rule is active if at least one of the time
periods indicates that it is active. (In other words, the time
periods are ORed to determine whether the rule is active.) A policy
time period may be aggregated by multiple policy rules. A rule that
does not point to a policy time period via this association is, from
the point of view of scheduling, always active. It may, however, be
inactive for other reasons.
Time periods are a general concept that can be used in other
applications. However, they are mentioned explicitly here in this
specification since they are frequently used in policy applications.
Moore, et al. Expires: Jun 1999 + 6 months [Page 33]
Internet Draft Policy Core Information Model June 1999
The class definition for the aggregation is as follows:
NAME PolicyRuleValidityPeriod
DESCRIPTION A class representing the aggregation of
PolicyTimePeriodConditions by a PolicyRule.
DERIVED FROM Top
ABSTRACT FALSE
PROPERTIES ContainingRule[ref PolicyRule[0..n]]
ContainedPtp[ref PolicyTimePeriodCondition[0..n]]
7.7.1. The Reference "ContainingRule"
This property contains the name of a PolicyRule that contains one or
more PolicyTimePeriodConditions. Note that for any single instance of
the association class PolicyRuleValidityPeriod, this property (like
all Reference properties) is single-valued. The [0..n] cardinality
indicates that there may be 0, 1, or more than one PolicyRules that
contain any given PolicyTimePeriodCondition.
7.7.2. The Reference "ContainedPtp"
This property contains the name of a PolicyTimePeriodCondition
contained by one or more PolicyRules. Note that for any single
instance of the association class PolicyRuleValidityPeriod, this
property (like all Reference properties) is single-valued. The [0..n]
cardinality indicates that a given PolicyRule may contain 0, 1, or
more than one PolicyTimePeriodConditions.
7.8. The Aggregation "ContainedPolicyAction"
A policy rule may aggregate zero or more policy actions. A policy
rule that aggregates zero policy actions is not a valid rule -- it
may, for example, be in the process of being entered into the policy
repository. A policy rule has no effect until it is valid. The
actions associated with a PolicyRule may be given a required order, a
recommended order, or no order at all. For actions represented as
separate objects, the ContainedPolicyAction aggregation can be used to
express an order. For actions defined explicitly in a subclass of
PolicyRule, the ordering mechanism must be specified in the subclass
definition.
This aggregation does not indicate whether a specified action order is
required, recommended, or of no significance; the property
SequencedActions in the aggregating instance of PolicyRule provides
this indication.
The class definition for the aggregation is as follows:
NAME ContainedPolicyAction
DESCRIPTION A class representing the aggregation of
PolicyActions by a PolicyCondition.
Moore, et al. Expires: Jun 1999 + 6 months [Page 34]
Internet Draft Policy Core Information Model June 1999
DERIVED FROM Top
ABSTRACT FALSE
PROPERTIES ContainingRule[ref PolicyRule[0..n]]
ContainedAction[ref PolicyAction[0..n]]
ActionOrder
7.8.1. The Reference "ContainingRule"
This property contains the name of a PolicyRule that contains one or
more PolicyActions. Note that for any single instance of the
association class ContainedPolicyAction, this property (like all
Reference properties) is single-valued. The [0..n] cardinality
indicates that there may be 0, 1, or more than one PolicyRules that
contain any given PolicyAction.
7.8.2. The Reference "ContainedAction"
This property contains the name of a PolicyAction contained by one or
more PolicyRules. Note that for any single instance of the
association class ContainedPolicyAction, this property (like all
Reference properties) is single-valued. The [0..n] cardinality
indicates that a given PolicyRule may contain 0, 1, or more than one
PolicyActions.
7.8.3. The Property "ActionOrder"
This property provides an unsigned integer 'n' that indicates the
relative position of an action in the sequence of actions associated
with a policy rule. When 'n' is a positive integer, it indicates a
place in the sequence of actions to be performed, with smaller
integers indicating earlier positions in the sequence. The special
value '0' indicates "don't care". If two or more actions have the
same non-zero sequence number, they may be performed in any order, but
they must all be performed at the appropriate place in the overall
action sequence.
A series of examples will make ordering of actions clearer:
o If all actions have the same sequence number, regardless of whether
it is '0' or non-zero, any order is acceptable.
o The values
1:ACTION A
2:ACTION B
1:ACTION C
3:ACTION D
indicate two acceptable orders: A,C,B,D or C,A,B,D, since A and C
can be performed in either order, but only at the '1' position.
Moore, et al. Expires: Jun 1999 + 6 months [Page 35]
Internet Draft Policy Core Information Model June 1999
o The values
0:ACTION A
2:ACTION B
3:ACTION C
3:ACTION D
require that B,C, and D occur either as B,C,D or as B,D,C. Action
A may appear at any point relative to B,C, and D. Thus the
complete set of acceptable orders is: A,B,C,D; B,A,C,D; B,C,A,D;
B,C,D,A; A,B,D,C; B,A,D,C; B,D,A,C; B,D,C,A.
Note that the non-zero sequence numbers need not start with '1', and
they need not be consecutive. All that matters is their relative
magnitude.
The property is defined as follows:
NAME ActionOrder
DESCRIPTION Unsigned integer indicating the relative position
of an action in the sequence of actions aggregated
by a policy rule.
SYNTAX uint16
7.9. The Policy Group Jurisdiction Associations
There are four CIM associations that link objects representing
resources to which policies apply with the PolicyGroup objects that
represent these policies. The fact that there are four associations
rather than one reflects how CIM has modeled the resources, not how it
has modeled policies. Since all four associations work in exactly the
same way, this section will focus on only one of them:
GroupWithSettingJurisdiction. The remaining three associations,
GroupWithMseJurisdiction, GroupWithPartyJurisdiction, and
GroupWithCollectionJurisdiction are equivalent to this one.
The class definition for the GroupWithSettingJurisdiction association
is as follows:
NAME GroupWithSettingJurisdiction
DESCRIPTION A class representing the fact that a PolicyGroup is
applicable to a resource represented by a Setting
object.
DERIVED FROM Top
ABSTRACT FALSE
PROPERTIES GroupScope[ref Setting[0..n]]
ApplicableGroup[ref PolicyGroup[0..n]]
7.9.1. The Reference "GroupScope"
This property contains the name of a Setting object to which the
policies represented by one or more PolicyRules apply. Note that for
Moore, et al. Expires: Jun 1999 + 6 months [Page 36]
Internet Draft Policy Core Information Model June 1999
any single instance of the association class
GroupWithSettingJurisdiction, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that
there may be 0, 1, or more than one Settings to which the policies
belonging to a single PolicyGroup apply.
7.9.2. The Reference "ApplicableGroup"
This property contains the name of a PolicyGroup whose policies apply
to the resources represented by one or more Setting objects. Note
that for any single instance of the association class
GroupWithSettingJurisdiction, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that a
given Setting may be governed by policies belonging to 0, 1, or more
than one PolicyGroup.
7.10. The Policy Rule Jurisdiction Associations
There are also four CIM associations that link objects representing
resources to which policies apply directly with the PolicyRule objects
that represent these policies, without going by way of a PolicyGroup.
The fact that there are four associations rather than one reflects how
CIM has modeled the resources, not how it has modeled policies. Since
all four associations work in exactly the same way, this section will
focus on only one of them: RuleWithSettingJurisdiction. The
remaining three associations, RuleWithMseJurisdiction,
RuleWithPartyJurisdiction, and RuleWithCollectionJurisdiction are
equivalent to this one.
The class definition for the RuleWithSettingJurisdiction association
is as follows:
NAME RuleWithSettingJurisdiction
DESCRIPTION A class representing the fact that a PolicyRule is
applicable to a resource represented by a Setting
object.
DERIVED FROM Top
ABSTRACT FALSE
PROPERTIES RuleScope[ref Setting[0..n]]
ApplicableRule[ref PolicyRule[0..n]]
Note: In the DMTF's CIM model, there are two additional properties
defined for this association class: LastExecutionTime and
LastExecutionSuccessful. Since these properties appear to have no
relationship to the (currently chartered) work of the Policy Framework
WG, they have been omitted from this document.
Moore, et al. Expires: Jun 1999 + 6 months [Page 37]
Internet Draft Policy Core Information Model June 1999
7.10.1. The Reference "RuleScope"
This property contains the name of a Setting object to which the
policies represented by one or more PolicyRules apply. Note that for
any single instance of the association class
RuleWithSettingJurisdiction, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that
there may be 0, 1, or more than one Settings to which the policies
belonging to a single PolicyRule apply.
7.10.2. The Reference "ApplicableRule"
This property contains the name of a PolicyRule whose policies apply
to the resources represented by one or more Setting objects. Note
that for any single instance of the association class
RuleWithSettingJurisdiction, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that a
given Setting may be governed by policies belonging to 0, 1, or more
than one PolicyRule.
8. Intellectual Property
The IETF takes no position regarding the validity or scope of any
intellectual property or other rights that might be claimed to pertain
to the implementation or use of the technology described in this
document or the extent to which any license under such rights might or
might not be available; neither does it represent that it has made any
effort to identify any such rights. Information on the IETF's
procedures with respect to rights in standards-track and standards-
related documentation can be found in BCP-11.
Copies of claims of rights made available for publication and any
assurances of licenses to be made available, or the result of an
attempt made to obtain a general license or permission for the use of
such proprietary rights by implementers or users of this specification
can be obtained from the IETF Secretariat.
The IETF invites any interested party to bring to its attention any
copyrights, patents or patent applications, or other proprietary
rights which may cover technology that may be required to practice
this standard. Please address the information to the IETF Executive
Director.
9. Acknowledgements
The Policy Core Information Model in this document is closely based on
the work of the DMTF's Service Level Agreements working group, so
thanks are due to the members of that working group.
Moore, et al. Expires: Jun 1999 + 6 months [Page 38]
Internet Draft Policy Core Information Model June 1999
10. Security Considerations
o General: The IETF is concerned with standardizing what happens on
the wire. However, many of the security concerns in a policy
system have to do with things that have nothing to do with what
happens on the wire, like logging, how data is stored on the
repository server, etc. These are out-of-scope for IETF
standardization. However, it is necessary to document the
requirements for a secure policy system, in order to show that the
overall policy framework is viable. Our model for documenting
these requirements is based on prior work in the IETF on DNSSEC and
SNMPv3. One of our objectives in the policy work in the IETF is to
not break the known existing security mechanisms, or to make them
less effective, regardless of whether or not these security
mechanisms affect what flows on the wire.
o Users: The first step in identifying security requirements for
policy, is to identify the users of policy. The users fall into
three categories:
o Administrators of Schema: This group requires the most stringent
authorization and associated security controls. An improper or
mal-formed change in the design of the policy schema carries with
it the danger of rendering the repository inoperable while the
repository is being repaired or re-built. During this time, the
policy enforcement entities would need to continue to enforce
policies according to their prior configuration. The good news is
that it is expected that large network operators will change schema
design infrequently, and, when they do, the schema creation changes
will be tested on an off-line copy of the directory before the
operational directory is updated. Typically, a small group of
schema administrators will be authorized to make these changes in a
service provider or enterprise environment. The ability to
maintain an audit trails is also required here.
o Administrators of Schema Content: This group requires authorization
to load values (entries) into a policy repository) schema
(read/write access). An audit trail mechanism is also required
here. The effect of entering improperly formatted or maliciously-
intended data into a policy repository, could potentially result in
re-configuring mass numbers of network elements in a way that
renders them to be inoperable, or of rendering network resources
inaccessible for an extended period of time,
o Applications and PDPs: These entities must be authorized for read-
only access to the policy repository, so that they may acquire
policy for the purposes of passing it to their respective
enforcement entities.
o Security Disciplines:
Moore, et al. Expires: Jun 1999 + 6 months [Page 39]
Internet Draft Policy Core Information Model June 1999
o Audit Trail (Non-repudiation): In general, standardizing
mechanisms for non-repudiation is outside the scope of the
IETF; however, we can certainly document the need for this
function in systems which maintain and distribute policy. The
dependency for support of this function is on the implementers
of these systems, and not on any specific standards for
implementation. The requirement for a policy system is that a
minimum level of auditing via an auditing facility must be
provided. Logging should be enabled. This working group will
not specify what this minimal auditing function consists of.
o Access Control/Authorization: Access Control List (ACL)
functionality must be provided. The two administrative sets of
users documented above will form the basis for two
administrative use cases which require support.
o Authentication: Authentication support on the order of that
available with TLS and Kerboros are acceptable for
authentication. We advise against using weaker mechanisms,
such as clear text and HTTP Digest. Mutual authentication is
recommended.
o Integrity/Privacy: Integrity/privacy support on the order of
TLS or IPSEC is acceptable for encryption and data integrity
on the wire. If physical or virtual access to the policy
repository is in question, it may also be necessary to encrypt
the policy data as it is stored on the file system; however,
specification of mechanisms for this purpose are outside the
scope of this working group. In any case, we recommend that
the physical server be located in a physically secure
environment.
In the case of PDP-to-PEP communications, the use of IPSEC is
recommended for providing confidentiality, data origin
authentication, integrity and replay prevention. See reference
[10].
o Denial of Service: We recommend the use of multiple policy
repositories, such that a denial of service attack on any one
repository will not make all policy data inaccessible to legitimate
users. However, this still leaves a denial of service attack
exposure. Our belief is that the use of a policy schema, in a
centrally administered but physically distributed policy
repository, does not increase the risk of denial of service
attacks; however, such attacks are still possible. If executed
successfully, such an attack could prevent PDPs from accessing a
policy repository, and thus prevent them from acquiring new policy.
In such a case, the PDPs, and associated PEPs would continue
operating under the policies in force before the denial of service
attack was launched. Note that exposure of policy systems to
denial of service attacks is not any greater than the exposure of
DNS with DNSSEC in place.
Moore, et al. Expires: Jun 1999 + 6 months [Page 40]
Internet Draft Policy Core Information Model June 1999
11. References
[1] J. Strassner and E. Ellesson, "Terminology for describing network
policy and services", draft-strassner-policy-terms-02.txt, June
1999.
[2] Bhattacharya, P., and R. Adams, W. Dixon, R. Pereira, R. Rajan, "An
LDAP Schema for Configuration and Administration of IPSec based
Virtual Private Networks (VPNs)", Internet-Draft work in progress,
October 1998
[3] Rajan, R., and J. C. Martin, S. Kamat, M. See, R. Chaudhury, D.
Verma, G. Powers, R. Yavatkar, "Schema for Differentiated Services
and Integrated Services in Networks", Internet-Draft work in
progress, October 1998
[4] J. Strassner and S. Judd, "Directory-Enabled Networks", version
3.0c5 (August 1998).
[5] Bradner, S., "Key words for use in RFCs to Indicate Requirement
Levels", BCP 14, RFC 2119, March 1997.
[6] Hovey, R., and S. Bradner, "The Organizations Involved in the IETF
Standards Process", BCP 11, RFC 2028, October 1996.
[7] Distributed Management Task Force, Inc., "Common Information Model
(CIM) Specification, version 2.2, June 14, 1999.
[8] J. Strassner, policy architecture BOF presentation, 42nd IETF
Meeting, Chicago, Illinois, October, 1998
[9] J. Strassner and E. Ellesson, B. Moore "Policy Framework LDAP Core
Schema," draft-ietf-policy-core-schema-04.txt, June 1999.
[10] R. Yavatkar and D. Pendarakis, R. Guerin, "A Framework for Policy-
based Admission Control", draft-ietf-rap-framework-03.txt, April
1999.
12. Authors' Addresses
John Strassner
Cisco Systems, Bldg 1
170 West Tasman Drive
San Jose, CA 95134
Phone: +1 408-527-1069
Fax: +1 408-527-1722
E-mail: johns@cisco.com
Ed Ellesson
IBM Corporation, JDGA/501
4205 S. Miami Blvd.
Moore, et al. Expires: Jun 1999 + 6 months [Page 41]
Internet Draft Policy Core Information Model June 1999
Research Triangle Park, NC 27709
Phone: +1 919-254-4115
Fax: +1 919-254-6243
E-mail: ellesson@raleigh.ibm.com
Bob Moore
IBM Corporation, JDGA/501
4205 S. Miami Blvd.
Research Triangle Park, NC 27709
Phone: +1 919-254-4436
Fax: +1 919-254-6243
E-mail: remoore@us.ibm.com
13. Full Copyright Statement
Copyright (C) The Internet Society (1999). All Rights Reserved.
This document and translations of it may be copied and furnished to
others, and derivative works that comment on or otherwise explain it
or assist in its implementation may be prepared, copied, published and
distributed, in whole or in part, without restriction of any kind,
provided that the above copyright notice and this paragraph are
included on all such copies and derivative works. However, this
document itself may not be modified in any way, such as by removing
the copyright notice or references to the Internet Society or other
Internet organizations, except as needed for the purpose of developing
Internet standards in which case the procedures for copyrights defined
in the Internet Standards process must be followed, or as required to
translate it into languages other than English.
The limited permissions granted above are perpetual and will not be
revoked by the Internet Society or its successors or assigns.
This document and the information contained herein is provided on an
"AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING
TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT
NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN
WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
Moore, et al. Expires: Jun 1999 + 6 months [Page 42]
