DMM Working Group                                          S. Matsushima
Internet-Draft                                                  SoftBank
Intended status: Standards Track                                L. Bertz
Expires: May 3, September 6, 2018                                        Sprint
                                                              M. Liebsch
                                                                     NEC
                                                           S. Gundavelli
                                                                   Cisco
                                                                D. Moses
                                                       Intel Corporation
                                                              C. Perkins
                                                               Futurewei
                                                        October 30, 2017
                                                           March 5, 2018

       Protocol for Forwarding Policy Configuration (FPC) in DMM
                       draft-ietf-dmm-fpc-cpdp-09
                       draft-ietf-dmm-fpc-cpdp-10

Abstract

   This document describes a way, called Forwarding Policy Configuration
   (FPC) to manage the separation of data-plane and control-plane.  FPC
   defines a flexible mobility management system using FPC agent and FPC
   client functions.  An FPC agent provides an abstract interface to the
   data-plane.  The FPC client configures data-plane nodes by using the
   functions and abstractions provided by the FPC agent for that the data-
   plane nodes.  The data-plane abstractions presented in this document
   is
   are extensible, in order to support many different types of mobility
   management systems and data-plane functions.

Status of This Memo

   This Internet-Draft is submitted in full conformance with the
   provisions of BCP 78 and BCP 79.

   Internet-Drafts are working documents of the Internet Engineering
   Task Force (IETF).  Note that other groups may also distribute
   working documents as Internet-Drafts.  The list of current Internet-
   Drafts is at https://datatracker.ietf.org/drafts/current/.

   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."

   This Internet-Draft will expire on May 3, September 6, 2018.

Copyright Notice

   Copyright (c) 2017 2018 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents
   (https://trustee.ietf.org/license-info) in effect on the date of
   publication of this document.  Please review these documents
   carefully, as they describe your rights and restrictions with respect
   to this document.  Code Components extracted from this document must
   include Simplified BSD License text as described in Section 4.e of
   the Trust Legal Provisions and are provided without warranty as
   described in the Simplified BSD License.

Table of Contents

   1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   3
   2.  Terminology . . . . . . . . . . . . . . . . . . . . . . . . .   4
   3.  FPC Design Objectives and Deployment  . . . . . . . . . . . .   5   6
   4.  FPC Mobility Information Model  . . . . . . . . . . . . . . .   8   9
     4.1.  Model Notation and Conventions  . . . . . . . . . . . . .   8   9
     4.2.  Core Structure - Information Model Components  Templates and Attributes  . . . . . .   9
     4.3.  Topology . . . . . . . . . .  12
     4.3.  Attribute-Expressions . . . . . . . . . . . . . .  10
       4.3.1.  DPN . . . .  13
     4.4.  Attribute Value Types . . . . . . . . . . . . . . . . . .  14
     4.5.  Namespace and Format  . . .  11
       4.3.2.  DPN-Type . . . . . . . . . . . . . . .  14
     4.6.  Configuring Attribute Values  . . . . . . .  12
       4.3.3.  DPN-Group . . . . . . .  14
     4.7.  Entity Configuration Blocks . . . . . . . . . . . . . . .  13
       4.3.4.  Domain  15
     4.8.  Infomation Model Checkpoint . . . . . . . . . . . . . . .  16
     4.9.  Information Model Components  . . . . . . . .  15
     4.4.  Policy . . . . . .  17
       4.9.1.  Service-Group . . . . . . . . . . . . . . . . . . .  15
     4.5.  Configurable Policy .  17
       4.9.2.  Service Endpoints . . . . . . . . . . . . . . . . . .  18
     4.6.  Mobility-Context  17
       4.9.3.  Topology Information Model  . . . . . . . . . . . . .  19
       4.9.4.  Domain Information Model  . . . . . . .  19
     4.7.  Monitors . . . . . . .  19
       4.9.5.  DPN Information Model . . . . . . . . . . . . . . . .  19
       4.9.6.  Policy Information Model  .  22
     4.8.  Namespace and Format . . . . . . . . . . . . .  21
       4.9.7.  Mobility-Context Information Model  . . . . .  23
     4.9.  Attribute Application . . . .  24
       4.9.8.  Monitor Information Model . . . . . . . . . . . . . .  24  26
   5.  Protocol  . . . . . . . . . . . . . . . . . . . . . . . . . .  24  27
     5.1.  Protocol Messages and Semantics . . . . . . . . . . . . .  24  27
       5.1.1.  CONFIG and CONF_BUNDLE Messages  Configure Message . . . . . . . . . . . . .  27
       5.1.2.  Monitors . . . . .  30
       5.1.2.  Monitor Messages  . . . . . . . . . . . . . . . . . .  29  36
     5.2.  Protocol Operation  . . . . . . . . . . . . . . . . . . .  30  38
       5.2.1.  Simple RPC Operation  . . . . . . . . . . . . . . . .  30  38
       5.2.2.  Policy And Mobility on the Agent  . . . . . . . . . .  36
       5.2.3.  Optimization for Current and Subsequent Messages  46
   6.  Templates And Command Sets  . .  38
   6.  Protocol Message Details . . . . . . . . . . . . . . .  48
     6.1.  Monitor Configuration Templates . . .  41
     6.1.  Data Structures And Type Assignment . . . . . . . . . .  49
     6.2.  Descriptor Templates  .  41
       6.1.1.  Policy Structures . . . . . . . . . . . . . . . . .  49
     6.3.  Tunnel Templates  .  41
       6.1.2.  Mobility Structures . . . . . . . . . . . . . . . . .  43
       6.1.3.  Message Attributes . .  52
     6.4.  Action Templates  . . . . . . . . . . . . . . . .  47
   7.  Derived and Subtyped Attributes . . . .  53
     6.5.  Quality of Service Action Templates . . . . . . . . . . .  51
     7.1.  3GPP Specific Extenstions  54
     6.6.  PMIP Command-Set  . . . . . . . . . . . . . . . .  56
   8. . . . .  55
     6.7.  3GPP Specific Templates and Command-Set . . . . . . . . .  55
   7.  Implementation Status . . . . . . . . . . . . . . . . . . . .  58
   9.  57
   8.  Security Considerations . . . . . . . . . . . . . . . . . . .  62
   10.  61
   9.  IANA Considerations . . . . . . . . . . . . . . . . . . . . .  63
   11.  62
   10. Work Team Participants  . . . . . . . . . . . . . . . . . . .  64
   12.
   11. References  . . . . . . . . . . . . . . . . . . . . . . . . .  64
     12.1.
     11.1.  Normative References . . . . . . . . . . . . . . . . . .  65
     12.2.  64
     11.2.  Informative References . . . . . . . . . . . . . . . . .  65
   Appendix A.  YANG Data Model for the FPC protocol . . . . . . . .  66
     A.1.  FPC YANG Model  . . . . . . . . . . . . . . . . . . . . .  67
     A.2.  YANG Models . . . . . . . . . . . . . . . . . . . . . . .  89
       A.2.1.  FPC YANG Settings and Extensions Model  . . . . . . .  89
       A.2.2.  PMIP QoS Model  . . . . . . . . . . . . . . . . . . . 105 101
       A.2.3.  Traffic Selectors YANG Model  . . . . . . . . . . . . 109
       A.2.4.  RFC 5777 Classifier YANG Model  . . . . . . . . . . . 117
     A.3.  FPC YANG Data Model Structure . . . . . . . . . . . . . . 125
   Appendix B.  Changes since Version 09 . . . . . . . . . . . . . . 133
   Authors' Addresses  . . . . . . . . . . . . . . . . . . . . . . . 128 134

1.  Introduction

   This document describes Forwarding Policy Configuration (FPC), a
   system for managing the separation of data-plane control-plane and control-plane. data-plane.
   FPC enables flexible mobility management using FPC agent client and FPC
   client
   agent functions.  An FPC agent exports an abstract interface to
   representing the data-plane.  To configure data-plane nodes and
   functions, the FPC client uses the interface to the data-plane
   offered by the FPC agent.

   Control planes of mobility management systems, or other related
   applications which require data-plane control, can utilize the FPC
   client at various granularities levels of operation.  The abstraction.  FPC operations are capable
   of directly configuring a single Data-Plane Node (DPN) directly, (DPN), as well as
   multiple DPNs DPNs, as determined by abstracted the data-plane models on exported by the
   FPC agent.

   A FPC agent provides data-plane abstraction in represents the following three
   areas:

   Topology:  DPNs are grouped and abstracted data-plane operation according to well-known
      concepts of mobility management such as access networks, anchors
      and domains.  A several
   basic information models.  An FPC agent also provides an interface to the abstract
      DPN-groups that enables definition of a topology for the
      forwarding plane.  For example, access nodes may be assigned to a
      DPN-group which peers to a DPN-group of anchor nodes.

   Policy:  A Policy embodies the mechanisms for processing specific
      traffic flows or packets.  This is needed for QoS, for packet
      processing to rewrite headers, etc.  A Policy consists of one or
      more rules.  Each rule is composed of Descriptors and Actions.
      Descriptors in a rule identify traffic flows, and Actions apply
      treatments to packets that match the Descriptors in the rule.  An
      arbitrary set of policies can applied to a particular collection
      of flows throgh the use of a Configurable-Policy.

   Mobility:  A mobility session
   Monitors, which is active on a mobile node is
      abstracted as a Mobility-Context with associated runtime concrete
      attributes, such as tunnel endpoints, tunnel identifiers,
      delegated prefix(es), routing information, etc.  Mobility-Contexts
      are attached to DPNs via DPN-References.  The References assign
      pre-defined Policies that were requested to be enforced as part of
      the mobility signaling request.  Policy may also be realized by
      Embedded-Rules in the DPN-Reference.  Such policies are typically
      highly specialized (e.g. negotiated as a part of signaling), were
      not pre-provisioned or designed as a template.  Hence, they are
      not reusable across Mobility-Contexts.

      Monitors provide a mechanism to produce reports when triggered by events regarding Configurable Policies,
   Mobility Contexts, DPNs or the
      Agent occur.

   The Agent Agent.

   To manage mobility sessions, the FPC client assembles applicable sets
   of forwarding policies for the
   mobility sessions from the data model, and configures them on
   the appropriate FPC Agent.  The Agent then renders those policies
   into specific configurations for each DPN to at which the
   sessions attached. mobile nodes are
   attached.  The specific protocols and configurations to configure a
   DPN from a FPC Agent are outside the scope of this document.

   The

   A DPN is a logical entity that performs data-plane abstractions operations (packet
   movement and management).  It may represent a physical DPN unit, a
   sub-function of a physical DPN or a collection of physical DPNs
   (i.e., a "virtual DPN").  A DPN may be extended virtual -- it may export the
   FPC DPN Agent interface, but be implemented as software that controls
   other data-plane hardware or modules that may or may not be FPC-
   compliant.  In this document, DPNs are specified without regard for
   whether the implementation is virtual or physical.  DPNs are
   connected to provide mobility management systems such as access
   networks, anchors and domains.  The FPC agent interface enables
   establishment of a topology for the forwarding plane.

   When a DPN is mapped to physical data-plane equipment, the FPC client
   can have complete knowledge of the DPN architecture, and use that
   information to perform DPN selection for specific sessions.  On the
   other hand, when a virtual DPN is mapped to a collection of physical
   DPNs, the FPC client cannot select a specific physical DPN because it
   is hidden by the abstraction; only the FPC Agent can address the
   specific associated physical DPNs.  Network architects have the
   flexibility to determine which DPN-selection capabilities are
   performed by the FPC Agent (distributed) and which by the FPC client
   (centralized).  In this way, overlay networks can be configured
   without disclosing detailed knowledge of the underlying hardware to
   the FPC client and applications.

   The abstractions in this document are designed to support many
   different mobility management systems and data-plane functions.  The
   architecture and protocol design of FPC is not tied to specific types
   of access technologies and mobility protocols.

2.  Terminology

   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 [RFC2119].

   DPN:                    A data-plane node (DPN) is capable of
                           deploying data-plane features.  DPNs may be
                           switches

   Domain:                 One or routers regardless more DPNs that form a logical
                           partition of their
                           realiziation, i.e. whether network resources (e.g., a data-
                           plane network under common network
                           administration).  An FPC client (e.g., a
                           mobility management system) may utilize a
                           single or multiple domains.

   DPN:                    A data-plane node (DPN) is capable of
                           performing data-plane features.  For example,
                           DPNs may be switches or routers, regardless
                           of whether they are realized as hardware or software based.
                           purely in software.

   DPN-Set:                the set of DPNs in a network configuration

   Service-Endpoint-Set:   a set of Service-Endpoint entities

   FPC Agent:              A functional entity in              An FPC that Agent manages DPNs
                           and provides DPNs, thereby providing
                           abstracted data-plane networks to mobility management systems and/or
                           applications through FPC
                           Clients.

   FPC Client:             A functional entity in             An FPC that Client is integrated with a mobility
                           management systems and/or
                           applications to system or related application,
                           enabling control over forwarding policy,
                           mobility sessions and DPNs.

   Tenant:                 An operational entity that manages mobility
                           management systems or applications which
                           require data-plane functions.

   Domain:                 One or more DPNs that form a data-plane
                           network.  A mobility management system or via an
                           application in a tenant may utilize FPC Agent.

   Service-Group-Set:      a single
                           or multiple domains.

   Configurable Policy:    A set of Rules (forwarding policies)
                           installed upon DPN interfaces that support a DPN.
                           specific data-plane purpose (inbound/
                           outbound, roaming, subnetwork with common
                           specific configuration, etc.)

   Mobility Context:       An abstracted endpoint of a mobility session
                           associated with runtime attributes.

3.  FPC Design Objectives       A Mobility Context contains the data-plane
                           information necessary to efficiently send and Deployment

   To fulfill
                           receive traffic from a mobile node.  This
                           includes policies that are created or
                           modified during the requirements described network's operation - in [RFC7333], FPC enables
   mobility control-planes and applications to configure DPNs with
   various roles of
                           most cases, on a per-flow or per session
                           basis.  A Mobility-Context represents the
                           mobility management as described in
   [I-D.ietf-dmm-deployment-models].

   FPC defines building blocks of FPC Agent and FPC Client, as well sessions (or flows) which are active
                           on a mobile node.  This includes associated
                           runtime attributes, such as
   data models for the necessary data-plane abstractions. tunnel endpoints,
                           tunnel identifiers, delegated prefix(es),
                           routing information, etc.  Mobility-Contexts
                           are associated to specific DPNs.  Some pre-
                           defined Policies may apply during mobility
                           signaling requests.  The
   attributes defining those data models serve as protocol elements for
   the interface between the FPC Agent and the FPC Client. Mobility control-planes and applications integrate Context
                           supplies information about the FPC Client
   function.  The FPC Client connects policy
                           settings specific to FPC Agent functions.  The
   Client a mobile node and the Agent communicate based on its
                           flows; this information models for the
   data-plane abstractions described in Section 4.  The data models
   allow the control-plane and the applications is often quite
                           dynamic.

   Mobility Session:       Traffic to/from a mobile node that is
                           expected to support forwarding
   policies on the Agent survive reconnection events.

   Monitor:                A reporting mechanism for their mobility sessions.

   The FPC Agent carries out the required configuration and management a list of the DPN(s).  The events
                           that trigger notification messages from an
                           FPC Agent determines DPN configurations according to
   the forwarding policies requested by the an FPC Client.  The DPN
   configurations could be specific to each DPN implementation such that
   how FPC Agent

   Policy:                 A Policy determines implementation the mechanisms for
                           managing specific configuration traffic flows or packets.
                           Policies specify QoS, rewriting rules for a
   DPN is outside
                           packet processing, etc.  A Policy consists of the scope
                           one or more rules.  Each rule is composed of this document.  Along with the models,
   the control-plane
                           a Descriptor and Actions.  The Descriptor in
                           a rule identifies packets (e.g., traffic
                           flows), and the applications put Policies Actions apply treatments to
                           packets that match the Agent
   prior to creating their mobility sessions.

   Once Descriptor in the Topology of DPN(s) and domains are defined for a data plane
                           rule.  Policies can apply to Domains, DPNs,
                           Mobile Nodes, Service Groups, or particular
                           Flows on a Mobile Node.

   Property:               An attribute-value pair for an Agent, the data-plane nodes (DPNs) are available instance of an
                           FPC entity

   Template:               A recipe for further
   configuration.  The instantiating FPC Agent connects those DPNs to manage their
   configurations.

   This architecture is illustrated entities.
                           Template definitions are accessible (by name
                           or by a key) in Figure 1. an indexed set.  A template
                           is used to create specific instances (e.g.,
                           specific policies) by assigning appropriate
                           values into the template definition.

   Tenant:                 An FPC Agent may be
   implemented in a network controller operational entity that handles multiple DPNs, manages mobility
                           management systems or
   there is a simple case where another FPC Agent applications which
                           require data-plane functions.

   Topology:               The DPNs and the links between them.  For
                           example, access nodes may itself be
   integrated into assigned to a DPN.
                           Service Group which peers to a Service Group
                           of anchor nodes.

3.  FPC Design Objectives and Deployment

   Using FPC, mobility control-planes and applications can configure
   DPNs to perform various mobility management roles as described in
   [I-D.ietf-dmm-deployment-models].  This fulfills the requirements
   described in [RFC7333].

   This document does not adopt a specific defines FPC Agent and FPC Client, as well as the
   information models that they use.  The attributes defining those
   models serve as the protocol elements for the FPC interface protocol and it is out of scope.  However it must be
   capable of supporting between the
   FPC protocol messages Agent and transactions
   described in Section 5.

                           +-------------------------+
                           | the FPC Client.

   Mobility Control-Plane  |
                           |          and            |
                           |      Applications       |
                           |+-----------------------+|
                           || control-plane applications integrate features offered by the
   FPC Client.  The FPC Client       ||
                           |+----------^------------+|
                           +-----------|-------------+ connects to FPC interface protocol  |
                       +---------------+-----------------+
                       |                                 |
         Network       |                                 | Agent functions.  The
   Client and the Agent communicate based on information models
   described in Section 4.  The models allow the control-plane to
   configure forwarding policies on the Agent for data-plane
   communications with mobile nodes.

   Once the Topology of DPN(s) and domains are defined on an Agent for a
   data plane, the DPNs in the topology are available for further
   configuration.  The FPC Agent connects those DPNs to manage their
   configurations.

   An FPC Agent configures and manages its DPN(s) according to
   forwarding policies requested by the FPC Client.  Configuration
   commands used by the FPC agent to configure its DPN node(s) may be
   specific to the DPN implementation; consequently the method by which
   the FPC Agent carries out the specific configuration for its DPN(s)
   is out of scope for this document.  Along with the data models, the
   FPC Client (on behalf of control-plane and applications) requests
   that the Agent configures Policies prior to the time when the DPNs
   start forwarding data for their mobility sessions.

   This architecture is illustrated in Figure 1.  An FPC Agent may be
   implemented in a network controller that handles multiple DPNs, or
   (more simply) an FPC Agent may itself be integrated into a DPN.

   This document does not specify a protocol for the FPC interface; it
   is out of scope.  However, an implementation must support the FPC
   transactions described in Section 5.

                           +-------------------------+
                           | Mobility Control-Plane  |
                           |          and            |
                           |      Applications       |
                           |+-----------------------+|
                           ||      FPC Client       ||
                           |+----------^------------+|
                           +-----------|-------------+
               FPC interface protocol  |
                       +---------------+-----------------+
                       |                                 |
         Network       |                                 |
         Controller    |                      DPN        |
           +-----------|-------------+        +----------|---------+
           |+----------v------------+|        |+---------v--------+|
           ||   [Data-plane model]  ||        ||[Data-plane model]||
           ||       FPC Agent       ||        ||    FPC Agent     ||
           |+-----------------------+|        |+------------------+|
           |+------------+----------+|        |                    |
           ||SB Protocols|FPC Protocol |FPC Client||        |  DPN Configuration |
           ||   Modules  |  Module  ||        +--------------------+
           |+------^-----+----^-----+|
           +-------|----------|------+
                   |          |
         Other     |          | FPC interface
         Southband
         southband |          | Protocol
         Protocols protocol
         protocols |          |
                   |          +-----------------+
                   |                            |
       DPN         |                 DPN        |
        +----------|---------+       +----------|---------+
        |+---------v--------+|       |+---------v--------+|
        ||  Configuration   ||       ||[Data-plane model]||
        || Protocol module  ||       ||     FPC Agent    ||
        |+------------------+|       |+------------------+|
        |                    |       |                    |
        | DPN Configuration  |       |  DPN Configuration |
        +--------------------+       +--------------------+

         Figure 1: Reference Forwarding Policy Configuration (FPC)
                               Architecture

   The FPC architecture supports multi-tenancy; an FPC enabled data-
   plane supports tenants of multiple mobile operator networks and/or
   applications.  It means that the FPC Client of each tenant connects
   to the FPC Agent and it MUST partition namespace and data for their
   data-planes.  DPNs on the data-plane may fulfill multiple data-plane
   roles which are defined per session, domain and tenant.

   Note that all

   FPC information models SHOULD be configurable.  The FPC interface
   protocol in Figure often configuration to fit the specific needs
   for DPN management of a mobile node's traffic.  The FPC interfaces in
   Figure 1 is are the only interfaces required to handle runtime data in the a
   Mobility model. Context.  The rest of the FPC models, namely Topology and
   Policy, some Policy FPC models may be pre-configured, and
   pre-configured; in that case real-time protocol exchanges would are not be
   required for them.  Operators that are tenants
   in the

4.  FPC data-plane could configure Mobility Information Model

   The FPC information model includes the following components:

      DPN Information Model,
      Topology and Information Model,
      Policy on the
   Agent through other means, such Information Model,
      Mobility-Context, and
      Monitor, as Restconf
   [I-D.ietf-netconf-restconf] or Netconf [RFC6241].

4.  FPC illustrated in Figure 2.

                   :
                   |
                   +-[FPC Mobility Information Model]
                   |          |
                   |          +-[DPN Information Model]
                   |          |
                   |          +-[Topology Information Model]
                   |          |
                   |          +-[Policy Information Model]
                   |          |
                   |          +-[Mobility-Context]
                   |          |
                   |          +-[Monitor]
                   |

                 Figure 2: FPC Information Model structure

4.1.  Model Notation and Conventions

   In order

   The following conventions are used to clarify the description of the information model, this
   draft uses the convention describe in the below. FPC information
   models.

   Information model entities, e.g. entities (e.g.  DPNs, Rules, etc., etc.) are listed defined in a
   hierarchical notation where all entities with at the same hierarchical
   level are located on the same left-justified vertical position one after the
   other.
   sequentially.  When entities are composed of sub-entities, they will the sub-
   entities appear shifted to the right. right, as shown in Figure 3.

                              |
                              +-[entity2]
                              |         +-[entity2.1]
                              |         +-[entity2.2]

                   Figure 2: 3: Model Notation - An Example

   Some entities MAY have one or more sub-types qualifiers placed on the right hand
   side of the element definition in pointing brackets. angle-brackets.  Common types
   include:

   List:  A  a collection of entities (some could be of the same kind) duplicated)

   Set:  A  a nonempty collection of entities without duplications

   Name:  a human-readable string

   Key:  a unique value.  There are  We distinguish 3 types of keys:

      U-Key:  a universally unique key unique across all tenants.  U-Key spaces
         are typically
         involve the use of registries or language specific mechanisms
         that guarantee universal uniqueness of values.

      G-Key:  a globally unique key - unique within a tenant

      L-Key:  a unique key unique within the set of values in a local namespace.  For example, there
         may exist interfaces with teh the same name, e.g.
         "interface0", "if0", in two
         different DPNs within the same tenant but there can only be one "interface0" "if0" within each DPN, i.e. DPN
         (i.e. its local Interface-Id Interface-Key L-Key space.

   The Settings pattern, i.e. attributes whose names contain the word
   'Settings', is a genera set that holds unique properties.  If
   multiple values of a property are present they are held in a List for
   the property within the settings container.  The container acts as an
   extensible placeholder for properties (attribute/value pairs). space).

   Each entity or its subtype attribute may be optional (O) or mandatory (M).
   Entities that are not marked as optional are mandatory.

             Example:

       The following example shows 3 entities:
                      -
           -- Entity1 is a globally unique key key, and has optionally can have
                      an
                              optional, associated Name
                      -
           -- Entity2 is a list
                      -
           -- Entity3 is a set and is optional
                      +
                      |
                      +-[entity1] <G-Key> (M), <Name> (O)
                      +-[entity2] <List>
                      +-[entity3] <Set> (O)
                      |
                      +

                                 Figure 3 4

   When expanding entity1 into an information model a modeling language such as YANG it would
   result in two values: entity1-GKey and entity1-Name.

4.2.  Core Structure - Information Model Components

   The substructures that comprise the information model are:

   Topology:

   To encourage re-use, FPC defines the different DPNs and links between them.

   Policy-Definitions:   describes how to handle flows: how to identify
      traffic and what actions are performed on data packets

   Configurable-Policy:   policies indexed sets of various entity
   templates.  Other model elements that are relatively static.  These
      policies are usually pre-provisioned and are modified only need access to an indexed model
   entity contain an attribute which is always denoted as "entity-Key".
   When a Key attribute is encountered, the referencing model element
   may supply attribute values for use when the network configuration referenced entity model
   is updated or when new policy rules are
      configured

   Mobility-Context:   policies that instantiated.  For example: Figure 5 shows 2 entities:

      EntityA definition references an entityB model element.

      EntityB model elements are created or modified during the
      network's operation.  In most cases, on a per-flow or per session
      basis

   Monitor: indexed by entityB-Key.

   Each EntityB model element has an entityB-Key which allows it to be
   uniquely identified, and a list of events that trigger notification messages from
      FPC Agents Attributes (or, alternatively, a
   Type) which specifies its form.  This allows a referencing entity to FPC Clients

                    :
                    |
                    +-[Mobility]
                    |          +
                    |
   create an instance by supplying entityB-Values to be inserted, in a
   Settings container.

                           .
                           .
                           |
                    :          +-[Topology]
                           +-[entityA]
                           |
                               +-[Policy]      +-[entityB-Key]
                           |
                               +-[Configurable-Policy] <Set>      +-[entityB-Values]
                           .
                           .
                           |
                               +-[Mobility-Context]
                           +-[entityB] <L-Key> (M) <Set>
                           |
                               +-[Monitor] <Set>      +-[entityB-Type]
                           .
                           .

                    Figure 4: Mobility Information Model - Core Structure

4.3.  Topology

   The Topology sub-structure specifies virtual DPNs and the relations
   between them.  It is used by the network management entity to select 5: Indexed sets of entities

   Indexed sets are specified for each of the most appropriate following kinds of
   entities:

      Domain (See Section 4.9.4)
      DPN resources (See Section 4.9.5)
      Policy (See Section 4.9.6)
      Descriptor (See Figure 13)
      Action (See Figure 13)
      Service Group (See Section 4.9.1, and
      Mobility-Context (See Section 4.9.7)

   As an example, for handling specific session
   flows.

   A virtual DPN a Domain entity, there is a logical entity that performs DPN functionality
   (packet movement and management).  It may represent a physical DPN
   unit, a sub-function of a physical DPN or a collection of physical
   DPNs.  The motivation corresponding
   attribute denoted as "Domain-Key" whose value can be used to refer
   determine a reference to virtual DPNs in the information
   model rather than physical DPNs is to provide flexibility for network
   architects Domain.

4.2.  Templates and Attributes

   In order to define which DPN-selection capabilities are performed
   by simplify development and maintenance of the FPC Agent (distributed) needed
   policies and which other objects used by FPC, the FPC client
   (centralized). Information Models which
   are presented often have attributes that are not initialized with
   their final values.  When a virtual DPN an FPC entity is mapped instantiated according to
   a physical DPN, the FPC client has
   maximum knowledge of the DPN architecture and uses it to perform DPN
   selection for template definition, specific sessions.  When a virtual DPN is mapped values need to a
   collection of physical DPNs, the be configured for each
   such attribute.  For instance, suppose an entity Template has an
   Attribute named "IPv4-Address", and also suppose that an FPC client cannot select a specific
   physical DPN because it is hidden by Client
   instantiates the abstraction entity and only the FPC
   Agent can requests that it be installed on a DPN.
   An IPv4 address will be needed for the specific associated physical DPNs.

   The Topology sub-structure is comprised of the following sub-
   structures:

   DPN-Set:   the set of virtual DPNs in a network configuration

   DPN-Type-Set:   a set of DPN-Type entities

   DPN-Group-Set:   a set value of virtual DPNs that supports a specific
      administrative purpose (in/out bound, roaming, subnetwork with
      common specific configuration etc.)

   Domain:   a set of Domains tha represent a logical partition of
      network resources

                          |
                          +-[Topology]
                          |          +-[DPN] Attribute before
   the entity can be used.

                        +-[Template] <U-Key, Name> (M) <Set>
                        |          +-[DPN-Type]      +-[Attributes] <Set> (M)
                        |          +-[DPN-Group] <Set>      +-[Extensible ~ FALSE]
                        |      +-[Entity-State ~ Initial]
                        |          +-[Domain] <Set>      +-[Version]

                        Figure 5: Topology Substructure

4.3.1.  DPN

   The DPN 6: Template entities

   Attributes:  A set sub-structure specifies a subset of virtual DPNs in the
   network . Some of the DPNs may Attribute names MAY be identical included when defining a
      Template for instantiating FPC entities.  Any instantiation from a
      Template MUST have at least one Attribute in functionality and only
   differ by their key.

            |
            +-[DPN] <Set>
            |     +-[DPN-Id] <G-Key>, <Name> (O)
            |     +-[DPN-Resource-Mapping-Reference] (O)
            |     +-[Interface] <Set>
            |                 +-[Interface-Reference]
            |                 |           +-[Access-Technology] <U-Key>
            |                 |           +-[Role] <U-Key>
            |                 |           +-[Interface-Id] <L-Key>
            |                 +-[Interface-Settings] <Set> (O)

                        Figure 6: DPN Substructure

   Each DPN entry contains the following information:

   DPN-Id (Key):  A unique Identifier of the virtual DPN

   DPN-Id (Name):  the human-readable display string
   DPN-Resource-Mapping-Reference (O):  A reference order to the underlying
      implementation, e.g. physical node, virtual element, etc. that
      supports this DPN.  This value MUST be non-empty prior to Dynamic-
      Policies being installed upon a useful
      entity.

   Extensible:  Determines whether or not entities instantiated from the DPN.

   Interface-Set:
      Template can be extended with new non-mandatory Attributes not
      originally defined for the set of interfaces (through which data packets are
      received and transmitted) of that Virtual DPN.  The virtual DPN
      abstracts one or multiple physical DPNs each having one or more
      interfaces.  The Interface-set sub-structure Template.  Default value is FALSE.  If
      a collection of
      all interface types available by this virtual DPN.  The purpose of Template does not explicitly specify this information attribute, the default
      value is not to describe each interface of each DPN,
      but rather, considered to indicate the entire set of interface types be in effect.

   Entity-State:  Either Initial, PartiallyConfigured, Configured, or
      Active.  Default value is Initial.  See Section 4.6 for more
      information about how the
      sake Entity-Status changes during the
      configuration steps of the DPN selection process, when a DPN with specific
      interface capabilities is required.  Each interface entry has Entity.

   Version:  Provides a
      reference to a defined DPN-Type entry in version tag for the DPN-Type-Set sub-
      structure defined below and additional information that is
      specific to that interface:

         Interface-Reference - a 3-tuple key that uniquely references template.

   The Attributes in an
         entry Entity Template may be either mandatory or non-
   mandatory.  Attribute values may also be associated with the
   attributes in the DPN-Type-Set sub-structure: Access-Technology,
         Role and Interface-Id.

         Interface-Settings - An optional set of settings of this
         interface (that do not affect Entity Template.  If supplied, the DPN selection of active value may be
   either assigned with a default value that can be reconfigured later,
   or
         enabled interfaces).  Examples: MTU size, display name, etc.

4.3.2.  DPN-Type

   DPN-Type is the collection of all value can be assigned with a static value that cannot be
   reconfigured later (see Section 4.3).

   It is possible types of interfaces
   defined for DPNs in the network.  The interfaces are grouped
   according to their access technology, e.g. 3GPP, WiMAX, 802.x and
   Role, e.g.  LMA, MAG, PGW, AMF etc.  Within a group, interfaces may
   have additional properties Template to provide values for all of its
   Attributes, so that no additional values are more specific, needed before the entity
   can made Active.  Any instantiation from a list of features
   and optionally settings relevant to DPN selection.  This information
   is used when searching for resources Template MUST have at
   least one Attribute in a network order to carry out
   required operations on data traffic.

               |
               +-[DPN-Type] <Set>
               |     +-[Access-Technology] <U-Key>,<Name> (O)
               |     +-[Role] <U-Key>, <Name> (O)
               |     +-[Interface] <Set>
               |             +-[Interface-Id] <L-Key>, <Name> (O)
               |             +-[Interface-Protocol] <Set>
               |             +-[Features] <Set> (O)
               |             +-[Interface-Settings] <Set> (O)

                            Figure 7: DPN Type

   Each DPN-Type entry contains the following information:

   Access-technology: be a useful entity.

4.3.  Attribute-Expressions

   The syntax of the technology used Attribute definition is formatted to make it clear,
   for every Attribute in the access network that
      originated the signaling (WiMAX, 3GPP, 802.x etc.)

   Role:   the role (MAG, LMA, PGW, AMF etc.) Entity Template, which of the device sharing the
      interfaces specified below.

   Interface:   A set of interfaces possible for the group above.  Each
      interface carries the following information:

         Interface-Id: a key that six
   possibilities is used together with the 2-tuple
         Access-Technology specified, as follows:

   '[Att-Name: ]'  Mandatory Attribute is defined, but template does not
      provide any configured value.

   '[Att-Name: Att-Value]'  Mandatory Attribute is defined, and Role, to create has a 3-tuple key that
      statically configured value.

   '[Att-Name: ~ Att-Value]'  Mandatory Attribute is
         referred to defined, and has a
      default value.

   '[Att-Name]'  Non-mandatory Attribute may be the interface definition of virtual DPNs

         Interface-Protocols: rotocols supported included but template
      does not provide any configured value.

   '[Att-Name = Att-Value]'  Non-mandatory Attribute may be included and
      has a statically configured value.

   '[Att-Name ~ Att-Value]'  Non-mandatory Attribute may be included and
      has a default value.

   So, for example, a default value for a non-mandatory IPv4-Address
   attribute would be denoted by this interface -
         PMIP, S5-GTP, S5-PMIP etc.

         Features: [IPv4-Address ~ 127.0.0.1].

   After an optional set of supported features FPC Client identifies which further
         determine the suitability of the interface additional Attributes have been
   configured to be included in an instantiated entity, those configured
   Attributes MUST NOT be deleted by the desired
         operation

         Interface-Settings: FPC Agent.  Similarly, any
   statically configured value for an optional set entity Attribute MUST NOT be
   changed by the FPC Agent.

   Whenever there is danger of settings that confusion, the fully qualified Attribute
   name MUST be
         known used when determining supplying needed Attribute Values for a
   structured Attribute.

4.4.  Attribute Value Types

   For situations in which the suitability type of an interface for attribute value is required,
   the
         specific request.  The difference between 'Features' and
         'Settings' following syntax is recommended.  To declare than an attribute
   has data type "foo", typecast the attribute name by using the
   parenthesized data type (foo).  So, for instance, [(float) Max-
   Latency-in-ms:] would indicate that 'Features' are static while 'Settings' may the mandatory Attribute "Max-
   Latency-in-ms" requires to be configured.  Examples: SequenceNumber=ON/OFF

   The entries Access-Technology and Role represent configured with a tuple key that
   uniquely identifies floating point value
   before the set of interfaces that may instantiated entity could be available for
   DPNs of the specific type.

4.3.3.  DPN-Group

   A DPN-Group is used.  Similarly, [(float)
   Max-Latency-in-ms: 9.5] would statically configure a list floating point
   value of a group of DPNs serving some administrative
   purpose.  Each group contains a list of DPNs (referenced by DPN-Id) 9.5 to the mandatory Attribute "Max-Latency-in-ms".

4.5.  Namespace and selected interfaces (referenced Format

   The identifiers and names in FPC models which reside in the same
   namespace must be unique.  That uniqueness must be maintained by all
   Clients, Agents and DPNs that support the interface's 3-tuple key). tenant.  The interfaces are listed rather than referred implicitly by each
   specific DPN to enable tenant
   namespace uniqueness MUST be applied to define a subset all elements of the tenant
   model, i.e.  Topology, Policy and Mobility models.

   When a DPN interfaces Policy needs to be
   part of applied to Contexts in all tenants on an
   Agent, the group.

       |
       +-[DPN-Group] <Set>
       |           +-[DPN-Group-Id] <G-Key>, <Name> (O)
                   +-[Referenced-Interface] <Set>
                   |           +-[Interface-Id] <L-Key>
                   |           +-[Role] <U-Key>
                   |           +-[Access-Technology] <U-Key>
                   |           +-[Supporting-DPN-Id] <Set>
                   |           +-[DPN-Group-Peer-Reference] <Set> (O)
                   +-[DPN-Peer-Group] <Set>
                   |           +-[Remote-DPN-Group-Id] <L-key>
                   |           +-[Interface-Settings] <Set> (O)
                   +-[Domain-Id-Reference]

                            Figure 8: DPN Group

   Each DPN-Group entry contains Agent SHOULD define that policy to be visible from all the following information:

   DPN-Group (Key):  A unique Identifer of
   tenants.  In this case, the DPN-Group

   DPN-Group (Name): Agent assigns an unique identifier in the human-readable display string

   Referenced-Interfaces:  A set of interfaces
   agent namespace and the DPNs / associated
      DPN-Peer-Groups that support them.  Each entry contains

      Interface-Id: effectively creates a key that U-Key although only a G-Key
   is used together required.

   The notation for identifiers can utilize any format with the 2-tuple
         Access-Technology agreement
   between data-plane agent and Role, to create a 3-tuple key that is
         referred client operators.  The formats include
   but are not limited to be Globally Unique IDentifiers (GUIDs),
   Universally Unique IDentifiers (UUIDs), Fully Qualified Domain Names
   (FQDNs), Fully Qualified Path Names (FQPNs) and Uniform Resource
   Identifiers (URIs).  The FPC model does not limit the interface definition of virtual DPNs

      Role: format, which
   could dictate the role (MAG, LMA, PGW, AMF etc.) choice of FPC protocol.  Nevertheless, the device sharing
         the interfaces specified below.

      Access-technology:   the technology
   identifiers which are used in a Mobility model should be considered
   to efficiently handle runtime parameters.

   There are identifiers reserved for Protocol Operation.  See
   Section 5.1.1.5 for details.

4.6.  Configuring Attribute Values

   Attributes of Information Model components such as policy templates
   are configured with values as part of FPC configuration operations.
   There may be several such configuration operations before the access network
         that originated
   template instantiation is fully configured.

   When the signaling (WiMAX, 3GPP, 802.x etc.)

      Role: FPC Client instantiates a Policy from a Template, the role (MAG, LMA, PGW, AMF etc.) of
   Policy-Status is "Initial".  When the device sharing FPC Client sends the interfaces specified below.

      Supporting-DPN-Id (Set):   A set of DPN-Id-References that support policy to
   an FPC Agent for installation on a DPN, the specific interface Client often will
   configure appropriate attribute values for this DPN-Group.

      Interface-Settings:   an optional set of settings that MUST be
         known when determining the suitability of an interface installation, and
   accordingly changes the Policy-Status to "PartiallyConfigured" or
   "Configured".  The FPC Agent will also configure Domain-specific
   policies and DPN-specific policies (if any) on the DPN.  When
   configured to provide particular services for mobile nodes, the
         specific request.F

   DPN-Peer-Group:  A set of Remote (from FPC
   Agent will apply whatever service-specific policies are needed on the DPN-Group's point of view)
      DPN-Groups.
   DPN.  When communication occurs between a mobile node attaches to the DPN-Group and
      DPN-Peer-Group network data-plane within
   the Interface-Settings MUST be used.  Each entry
      contains topology under the following information: entry contains

      Remote-DPN-Group-Id:   A unique Identifier jurisdiction of the DPN-Peer-Group

      Interface-Settings: an optional set of FPC Agent, the Agent may
   apply policies and settings as appropriate for that MUST be
         known mobile node.
   Finally, when determining the suitability of an interface for mobile node launches new flows, or quenches
   existing flows, the
         specific request.

4.3.4.  Domain

   A Domain represents a logica abstraction DPN Agent, on behalf of a group of heterogeneous
   Topology resources.  Other models, outside of the scope of this
   specificaiton, provide the details FPC Client, applies
   or deactivates whatever policies and attribute values are appropriate
   for managing the Domain.

               |
               +-[Domain] <Set>
               |           +-[Domain-Id] <G-Key>, <Name> (O)
                           +-[Domain-Reference]

                             Figure 9: Domainn

   Each Domain entry contains the following information:

   Domain (Key):  A unique Identifier flows of the Domain

   Domain (Name):  the human-readable display string

   Domain-Reference:  A link mobile node.  When a "Configured"
   policy is de-activated, Policy-Status is changed to be "Active".
   When an "Active" policy is activated, Policy-Status is changed to be
   "Configured".

   Attribute values in DPN-resident Policies may be configured by the underlying resource / informaiton
   FPC Agent as follows:

   Domain-Settings:  Values for Policy attributes that provides further details regarding are required for
      every DPN in the domain.

4.4.  Policy

   The

   DPN-Settings:  Values for Policy substructure defines and identifies grouped Rules attributes that are required for
   enforcement on the data plane.  Rules comprise traffic descriptors
   and actions
      every policy configured on how this DPN.

   Service-Settings:  Values for Policy attributes that are required to treat traffic in case
      carry out the intended Service of the Service Group.

   MN-Settings:  Values for Policy attributes that are required for all
      traffic descriptor
   matches to/from a data packet.  The particular mobile node.

   Flow-Settings:  Values for Policy substructure is independent of a
   policy context, whether it's an administratively configurable policy
   which applies attributes that are required for
      traffic belonging to all or a defined aggregate of data flows, or a
   mobility context-related policy, which is associated with a mobility
   session and may apply only to data traffic particular set of an associated mobile
   node while being registered.

   In addition to the Policy substructure, flows on the Core Structure per
   Section 4.2 holds accordingly separate entries mobile node.

   Any of these configuration steps may also supply updated values for
   existing default attribute values that may have been previously
   configured on the Configurable- DPN-resident policy.

4.7.  Entity Configuration Blocks

   As described in Section 4.6, a Policy as well as Template may be configured in
   several stages by configuring default or missing values for Mobility-Context, which
   Attributes that do not only define
   their own policies by embedded rules, but comprise references to
   policy definitions in already have statically configured values.  A
   Policy-Configuration is the combination of a Policy-Key (to identify
   the Policy substructure, Template defining the Attributes) and the currently
   configured Attribute Values to which additional
   settings be applied to the Policy Template.

   More generally, an Entity-Configuration can be applies on a per-Configurable-Policy basis and on a
   per-Mobility-Context bases respectively.

   Traffic descriptions and traffic treatment actions are defined
   separately in Descriptor-Definition and Action-Definition
   respectively.  Binding between traffic descriptors and associated
   traffic treatment action is defined in a set of rule definition
   entries (Rule-Definition) which comprise references for any
   configurable Indexed Set to entries in be the
   set of traffic descriptors (Descriptor-Reference) and traffic
   treatment actions (Action-Reference).  Accordingly, a single rule or
   a group combination of rules are bound to a policy in the Entity-Key
   along with a set of policy
   definitions (Policy-Definition) by reference to entries in Attribute-Expressions that supply configuration
   information for the set of
   rule definitions (Rule-Id).

      |
      +-[Policy]
      |      +-[Policy-Definition] <Set>
      |      |             +-[Policy-Id] <G-Key> (M)
      |      |             +-[Rule-Reference] Set (M)
      |      |             +-[Precedence] <L-Key> (M)
      |      |             +-[Rule-Id-Reference] (M)
      |      +-[Rule-Definition] <Set>
      |      |             +-[Rule-Id] <L-Key> (M)
      |      |             +-[Descriptor-Match-Type] (M)
      |      |             +-[Descriptor-Reference] <Set>
      |      |             |                +-[Descriptor-Id-Reference]
      |      |             |                +-[Direction] (O)
      |      |             +-[Action-Reference] <Set>
      |      |                              +-[Action-Id-Reference]
      |      |                              +-[Action-Order]
      |      +-[Descriptor-Definition] <Set>
      | entity's Attributes.  Figure 7 shows a schematic
   representation for such Entity Configuration Blocks.

                   [Entity Configuration Block]
                   |             +-[Descriptor -Id] <L-Key>       +-[Entity-Key] (M)
                   |      |             +-[Descriptor-Type]
      |      |             +-[Descriptor-Value]
      |      +-[Action-Definition]       +-[Attribute-Expression] <Set>
      |                    +-[Action-Id] <L-Key> (M)
      |                    +-[Action-Type]
      |                    +-[Action-Value]
      |

                   Figure 10: Policy Substructure

   The Policy Substructure contains 7: Entity Configuration Block

   This document makes use of the following entries:

   Policy-Definition:   A set kinds of policy definitions which bind a single
      or multiple rules to a policy.

      Policy-Id:   Identifies a policy definition.

      Rule-Reference:   Assigns a set of rule definitions, which are
         bound to a policy definition, by reference Entity
   Configuration Blocks:

      Domain-Policy-Configuration

      DPN-Policy-Configuration

      Descriptor-Configuration

      Action-Configuration

      MN-Policy-Configuration

      Flow-Policy-Configuration

4.8.  Infomation Model Checkpoint

   The Information Model Checkpoint permits Clients and tenants with
   common scopes, referred to the associated
         Rule in this specification as Checkpoint
   BaseNames, to track the Rule-Definition Substructure.

      Precedence:   Defines the order with which state of provisioned information on an Agent.
   The Agent records the rules must be
         applied.

      Rule-Id-Reference:   Identifies a rule.

   Rule-Definition:   A Checkpoint BaseName and Checkpoint value set of rule definitions which bind a single or
      multiple traffic descriptors (by reference to Descriptor-
      Definition) to by
   a single or multiple traffic treatment actions (by
      reference to Action-Definition).

      Rule-Id:   Identifies Client.  If a rule definition.

      Descriptor-Match-Type:   Conjuction of Descriptor-Values to apply
         as match new Client attaches to DPN traffic, which the Agent it can be either OR or AND.  The
         identified conjunction applies query to all Descriptor-Definitions in
   determine the given Rule-Definition.

      Descriptor-Reference:   Assigns a set amount of descriptors to the rule
         by reference work that must be executed to configure the associated Descriptor-Definition.

      Descriptor-Id-Reference:   Identifies the referred Descriptor-
         Definition

      Direction:   Indicates if a rule applies to uplink traffic, to
         downlink traffic, or to both, uplink- and downlink traffic.
         Applying a rule
   Agent to both, uplink- and downlink traffic, in case
         of symmetric rules, allows omitting a separate entry specific BaseName / checkpoint revision.

   Checkpoints are defined for each
         direction.  When not present, the direction following information model
   components:

      Service-Group

      DPN Information Model

      Topology Information Model

      Policy Information Model

4.9.  Information Model Components

4.9.1.  Service-Group

   A Service-Group is implied by the
         Descriptor's values.

      Action-Reference:   Assigns collection of DPN interfaces serving some data-
   plane purpose.  Each Group contains a set list of actions to the rule DPNs (referenced by
         reference to the associated Action-Definition.

      Action-Id-Reference:   Identifies the
   DPN-Key) and selected interfaces (referenced by Interface-Key).  The
   Interfaces are listed explicitly (rather than referred Action-Definition.

      Action-Order:   Defines the order how actions are executed in case
         the rule applies per match of the associated traffic
         descriptor.

   Descriptor-Definition:   A set of descriptor definitions, each being
      identified implicitly by a key (Descriptor-Id)

      Descriptor-Id:   Identifies a descriptor definition.

      Descriptor-Type:   Identifies the type of descriptor, e.g. an IPv6
         traffic selector per [RFC 6088], for unambiguous 2
         interpretation
   its specific DPN) so that every Interface of a Descriptor-Value.

      Descriptor-Value:   Defines all DPN is not required attribute-value pairs per
         the traffic descriptor type identified in Descriptor-Type.

   Action-Definition:   A set of action definitions.

      Action-Id:   Identifies an action definition.

      Action-Type:   Identifies the type of an action for unambiguous
         interpretation to
   be part of an Action-Value entry.

      Action-Value:   Defines all required attribute-value pairs per the
         action type identified in Action-Type.

4.5.  Configurable Policy Group.

        |
           +-[Configurable-Policy]
        +-[Service-Group] <G-Key>, <Name> (O) <Set>
        |               +-[DPN-Id-Reference] <U-Key>
           |               +-[Installed-Policy] <List>           +-[Extensible: FALSE]
        |           +-[DPN-Key]
        |           +-[Installed-Policy-Id] <G-Key>           +-[Role] <U-Key>
        |           +-[Referenced-Interface] <Set>
        |           +-[Policy-Id-Reference]           |           +-[Interface-Key] <L-Key>
        |           +-[Policy-Settings] <Set> (O)           |               +-[Settings]           +-[Peer-Service-Group-Key] <Set> (O)
           |

                          Figure 11: Configurable Policy

   The Configurable-Policy Substructure 8: Service Group

   Each Service-Group contains the following entries:

   DPN-Id-Reference:   Refers to information:

   Service-Group (Key):  A unique ID of the DPN to which Service-Group

   Service-Group (Name):  a human-readable display string

   Role:   the policy applies.

   Installed-Policy:   A list role (MAG, LMA, PGW, AMF etc.) of policies that apply to an identified
      DPN.

      Installed-Policy-Id:   Holds the identifier device hosting the
      interfaces of the DPN at which
         the policy has been installed.

      Policy-Id-Reference:   Assigns Group.

   Referenced-Interface: <Set>  The Interfaces and peer Service-Groups
      associated with them.  Each entry contains

      Interface-Key:   a policy by reference to key that is used together with the
         associated Policy-Definition.

      Policy-Settings:   Settings Role, to
         create a key that apply is referred to be the previously
         referenced policy to complement rules or make them concrete,
         e.g. in case interface definition of
         DPNs

      Peer-Service-Group-Key:   Enables location of the descriptor representing a packet match has not
         or unambiguously been defined peer Service
         Group for this Interface.

4.9.2.  Service Endpoints

   Service Endpoint is the collection of all services provided by DPN
   interfaces in the poliicy sub-structure.

   Settings:   Settings that apply network.  The interfaces are grouped according to multiple policies at the
      identified DPN.

4.6.  Mobility-Context

   The Mobility-Context Substructure holds entries associated with
   their Role (e.g.  LMA, MAG, PGW, AMF, etc.)  Within a
   mobile node's mobility sessions.  At least one instance is created at
   the mobile node's registration to serve as parent context.
   Additional instances holding child context with reference to parent
   context can be created.  Child context holds, for example,
   descriptors of mobile node data traffic which needs to be treated
   different from traffic that matches descriptor of the parent context,
   e.g. in terms of QoS.  Child context can inherit some attributes/
   values from parent context, such as traffic encapsulation and
   forwarding information, but can hold different or group, DPN
   interfaces may have additional
   attributes/values that apply to traffic properties that matches the descriptor
   of the child context.

   Termination are more specific, as
   determined by a parent context implies termination of all dependent
   child context, e.g. at deregistration list of features and (optionally) settings relevant
   to DPN selection.  This information is used when searching for
   resources in a mobile node. network to carry out required operations on data-plane
   traffic.

               |
      +-[Mobility-Context]
               +-[Service-Endpoint] <Set>
               |            +-[Mobility-Context-Id] <G-Key>
      |            +-[DPN-Group-Id-Reference] (O)     +-[Extensible: FALSE]
               |            +-[Parent-Mobility-Context-Id-Reference]     +-[Role] <U-Key>, <Name> (O)
               |            +-[DPN-References] <List>
      |     +-[Service-Group-Key] <Set>
               |          +-[DPN-Id-Reference]     +-[Interface] <Set>
               |     |          +-[Direction]       +-[Interface-Key] <L-Key>, <Name> (O)
               |     |          +-[DPN-Settings-Complementary]       +-[DPN-Key]
               |     |          +-[Interface-Id-Reference]
      |            |          +-[Embedded-Rule]       +-[Protocol] <Set> (O)
               |     |          +-[Assigned-Policy-Reference]       +-[Features] <Set> (O)
               |            +-[Requested-Policy-Reference] <Set> (O)     |            +-[Context-Settings-Complementary]       +-[Settings] <Set> (O)

                            Figure 12: Mobility Context

   The Mobility-Context Substructure holds 9: DPN Type

   Each Service-Endpoint entry contains the following entries:

   Mobility-Context-Id:   Identifies a Mobility-Context

   DPN-Group-Id-Reference:   Assigns a DPN-Group, which groups DPN information:

   Service-Group-Key:   Keys enabling reference to the Service-Groups
      that are used during the DPN selection procedure, by reference.

   Parent-Mobility-Context-Id-Reference:   Assigns a parent Mobility-
      Context to aquire settings as required.

   DPN-References:   Holds a list be supported by this Service-Endpoint.

   Interface:   A set of DPNs with interfaces possible for the associated concrete
      policies group defined by
      the Role.  Each interface carries the following information:

         Interface-Key: a key that apply is used to locate the DPN.  An entry MUST have at least one
      value present in its Assigned-Policy-Refence or Embedded-Rule sets
      in order to be valid.

      DPN-Id-Reference:   Assigns a DPN, to which interface
         definition.

      Role:   the policy applies, by
         reference.

      Direction:   Indicates if a rule applies to uplink or downlink
         traffic, or to both, uplink- and downlink traffic.  Applying a
         rule to both, uplink- and downlink traffic, in case roles (MAG, LMA, PGW, AMF, etc.) of
         symmetric rules, allows omitting a separate entry for each
         direction.  When not present the value is assumed to apply to
         both directions.

      DPN-Settings-Complementary:   Complementary seeings that apply to the interface.

      DPN-Key:   The DPN for the given Mobility-Context.

      Interface-Id-Reference:   Assigns key of the selected associated interface.

         Protocol: set of protocols supported by this interface (e.g.,
         PMIP, S5-GTP, S5-PMIP etc.).

         Features (optional): a set of static features which further
         determine the
         DPN my reference.

      Embedded-Rule:   Rule that applies suitability of the interface to the DPN desired
         operation for this Mobility-
         Context.  This rule which selection is embedded and not refereced in underway.

         Settings (optional): configurable settings that further
         determine the Policy
         substructure.

      Assigned-Policy-Reference:   A set suitability of references to an interface for the list of
         Requested-Policy-References per this Mobility-Context.

   Requested-Policy-Reference:   Assigns a list specific
         request.  For example: SequenceNumber=ON/OFF.

   The Role uniquely identifies the kind of policies in Policy-
      Definitions interfaces that can apply to any DPN per this Mobility-Context.
      DPN-Reference entries can select from this list may be
   available for DPNs of policy
      references to apply to the associated DPN.

   Context-Settings-Complementary:   Complementary settings that apply
      to the referenced policies per this Mobility-Context. specific type.

4.9.3.  Topology Information Model

   The Rules Template format is aligned with Topology structure specifies DPNs and the Rule Substructure.  It communication paths
   between them.  A network management system can represent an Embedded-Rule per use the Mobility-Context Substructure. Topology to
   select the most appropriate DPN resources for handling specific
   session flows.

   The Topology structure is illustrated in Figure 10 (for definitions
   see Section 2):

                         |
             +-[Embedded-Rule] <List>
                         +-[Topology Information Model]
                         |         +-[Rule-Id] (M)          +-[Extensible: FALSE]
                         |         +-[Precedence] <L-Key>          +-[DPN] <Set>
                         |         +-[Descriptor-Match-Type] (M)          +-[Domain] <Set>

                       Figure 10: Topology Structure

4.9.4.  Domain Information Model

   A Domain represents a group of heterogeneous Topology resources
   typically sharing a common administrative authority.  Other models,
   outside of the scope of this specification, provide the details for
   the Domain.

             |         +-[Descriptor-Definition]
             +-[Domain] <G-Key>, <Name> (O) <Set>
             |       +-[Domain-Policy-Configuration] (O) <Set>
             |             +-[Descriptor-Id] <L-Key> (M)

                    Figure 11: Domain Information Model

   Each Domain entry contains the following information:

   Domain (Key):  Identifies and enables reference to the Domain

   Domain (Name):  A human-readable display string naming the Domain

4.9.5.  DPN Information Model

   A DPN-Set contains some or all of the DPNs in the tenant's network.
   Some of the DPNs in the Set may be identical in functionality and
   only differ by their Key.

                  |
                  +-[DPN] <G-Key>, <Name> (O) <Set>
                  |     +-[Extensible: FALSE]
                  |     +-[Interface] <L-Key> <Set>
                  |             +-[Descriptor-Type]     |      +-[Role] <U-Key>
                  |             +-[Descriptor-Value]     |         +-[Action-Definition]      +-[Protocol] <Set>
                  |                       +-[Action-Order] <L-Key> (M)     |                       +-[Action-Id]      +-[Settings] (O)
                  |                       +-[Action-Type]     +-[Domain-Key]
                  |     +-[Service-Group-Key] <Set> (O)
                  |     +-[DPN-Policy-Configuration] <List> (M)
                  |                       +-[Action-Value]     +-[DPN-Resource-Mapping-Reference] (O)

                     Figure 13: Rule Template

   The Embedded-Rule template holds 12: DPN Information Model

   Each DPN entry contains the following entries:

   Rule-Id:   Identifies a rule definition.  It is provided for
      convenience.

   Precedence:   Defines information:

   DPN-Key:  A unique Identifier of the order with DPN

   DPN-Name:  A human-readable display string

   Domain-Key:  A Key providing access to the Domain information about
      the Domain in which the rules must be applied DPN resides.

   Interface-Set:  The Interface-Set references all interfaces (through
      which data packets are received and is used as transmitted) available on the key.

   Descriptor-Match-Type:   Conjuction
      DPN.  Each Interface makes use of Descriptor-Values to apply as
      match attribute values that are
      specific to that interface, for example, the MTU size.  These do
      not affect the DPN traffic, which can be either OR selection of active or AND.  The
      identified conjunction applies to all Descriptor-Definitions in enabled interfaces.
      Interfaces contain the given Rule-Definition

   Descriptor-Definition:   A set of descriptor definitions, each being
      identified by a key (Descriptor-Id)

      Descriptor-Id:   Identifies a Descriptor-Definition

      Descriptor-Type:   Identifies the type of descriptor, e.g. an IPv6
         traffic selector per [RFC 6088], for unambiguous 2
         interpretation of a Descriptor-Value

      Descriptor-Value:   Defines all required attribute-value pairs per
         the traffic descriptor type identified in Descriptor-Type.

   Action-Definition:   A set of action definitions.

      Action-Order:   Defines the order how actions are executed in case following informaiton:

      Role:   the rule applies per match role (MAG, LMA, PGW, AMF, etc.) of the associated traffic
         descriptor.

      Action-Id:   Identifies an action definition.

      Action-Type:   Identifies DPN.

         Settings (optional): configurable settings that further
         determine the type suitability of an action interface for unambiguous
         interpretation of an Action-Value entry.

      Action-Value:   Defines the specific
         request.  For example: SequenceNumber=ON/OFF.

   Service-Group-Set:  The Service-Group-Set references all required attribute-value pairs per of the
         action type identified in Action-Type.

4.7.  Monitors

   Monitors provide a mechanism to produce reports when events occur.  A
   Monitor will
      Service-Groups which have a target that specifies what is to be watched.

   When a Monitor is specified, the configuration MUST be applicable to
   the attribute/entity monitored.  For example, a Monitor been configured using a
   Threshold configuration cannot be applied to a Context, because
   Contexts do not have thresholds.  But such a monitor could be applied
   to a numeric threshold property Interfaces hosted
      on this DPN.  The purpose of a Context.

                      |
                      +-[Monitor] <List>
                      |         +-[Monitor-Id] <U-Key>
                      |         +-[Target]
                      |         +-[Binding-Information] (O)
                      |         +-[Deterrable] (O)
                      |         +-[Configuration]

                      Figure 14: Monitor Substructure

   Monitor-Id:  Name of the Monitor.  The Id format MUST conform Service-Group is not to
      Section 4.8.

   Target:  Description describe
      each interface of what is each DPN, but rather to be monitored.  This can be an
      Event, a Dynamic Policy, an installed indicate interface types
      for use during the DPN Policy, or values of selection process, when a
      Dynamic-Policy attribute.  When the type DPN with specific
      interface capabilities is an attribute required.

   DPN-Policy-Configuration:  A list of
      Mobility-Context, the target name is Policies that have been
      configured on this DPN.  Some may have values for all attributes,
      and some may require further configuration.  Each Policy-
      Configuration has a concatenation of the
      Context-Id key to enable reference to its Policy-
      Template.  Each Policy-Configuration also has been configured to
      supply missing and the relative path (separated by '/') non-default values to the
      attribute(s) desired Attributes
      defined within the Policy-Template.

   DPN-Resident-Policy.Policy-Configuration:  A Policy Key providing
      access to be monitored.  Target must provide unambiguously
      identify Template from which the monitored attribute DPN-Resident-Policy was
      instantiated, as well as an Attribute-Expression for this
      instantiation from the Policy-Template, which supplies default
      values and statically configured values for the location (DPN).

   Binding-Information:  Complements (ambigous) Target information Attributes,
      according to
      define the Monitor syntax specified in an unambigous way.

   Deterrable:   Indicates Section 4.2.

   DPN-Resource-Mapping-Reference (O):  A reference to the underlying
      implementation, e.g. physical node, software module, etc.  that a monitoring report can
      supports this DPN.  This value MUST be delayed in a
      defined delay budget for possible bundling with other reports

   Configuration:  Determined by non-empty prior to Dynamic-
      Policies being installed upon the Monitor subtype.  The recipient DPN.  Further specification of
      a notification as monitor report
      this attribute is specified in the
      Configuration.  Four reporting types are defined:

      *  Periodic reporting specifies an interval by which a
         notification out of scope for this document.

4.9.6.  Policy Information Model

   The Policy Information Model defines and identifies Rules for
   enforcement at DPNs.  A Policy is sent.

      *  Event reporting specifies basically a list set of event types that, if they
         occur and Rules that are related
   to the monitored attribute, will result
         in sending be applied to each incoming or outgoing packet at a notification.

      *  Scheduled reporting specifies the time (in seconds since Jan 1,
         1970) when DPN interface.
   Rules comprise Descriptors and a notification for the monitor should be sent.  Once
         this Monitor's notification is completed the Monitor is
         automatically de-registered.

      *  Threshold reporting specifies one or both set of a low and high
         threshold.  When these values are crossed a corresponding
         notification is sent.

4.8.  Namespace and Format Actions.  The identifiers and names in FPC models which reside in the same
   namespace must be unique.  That uniqueness must be kept in agent Descriptors,
   when evaluated, determine whether or
   data-plane tenant namespace on an Agent.  The tenant namespace
   uniqueness MUST be applied to all elements not a set of Actions will be
   performed on the tenant model, i.e.
   Topology, packet.  The Policy and Mobility models.

   When structure is independent of a Policy needs to be applied to Contexts in all tenants on
   policy context, whether it's an
   Agent, the Agent SHOULD define that administratively configurable policy
   which applies to be visible from all the
   tenants.  In this case, the Agent assigns an unique identifier in the
   agent namespace and effectively creates data flows, or a U-Key although only defined aggregate of flows, or
   to a G-Key mobility context-related policy, which is required.

   The format of identifiers can utilize any format associated with agreement
   between data-plane agent a
   mobility session and client operators.  The formats include
   but are not limited may apply only to Globally Unique IDentifiers (GUIDs),
   Universally Unique IDentifiers (UUIDs), Fully Qualified Domain Names
   (FQDNs), Fully Qualified Path Names (FQPNs) and Uniform Resource
   Identifiers (URIs).

   The FPC model does not limit the types data traffic of format an associated
   mobile node when that dictate node is being registered.

   In addition to the
   choice of FPC protocol.  However Policy structure, the choice of identifiers which are
   used in Mobility model need to Information Model (per
   Section 4.9.7) defines Mobility-Context.  Each Mobility-Context may
   be considered to handle runtime
   parameters in real-time.

4.9. configured with appropriate Attribute Application

   When search for attributes in Settings to apply for Embeded Rules or
   Assigned-Policy-References the following search order is applied by
   the Agent / DPN for Mobilty-Contexts:

   1.  DPN-Settings-Complementary of the DPN-Reference entry

   2.  Context-Settings-Complementary of the Mobility-Context

   3.  If Parent-Mobility-Context-Id-Reference is not empty the
       following are also searched:

       1.  DPN-Settings-Complementary of the DPN-Reference entry values, for example
   depending on the
           same interface, if present.

       2.  Context-Settings-Complementary identity of this parent Mobility-
           Context

       3.  Optionally, if this Mobility-Context has a non-empty Parent-
           Mobility-Context-Id-Reference this step MAY be repeated but
           it is NOT reccommended as it could slow system performance.

   4.  Interface-Settings of the DPN interface

   Only looking at settings of the first Parent-Mobility-Context-Id-
   Reference is recommended for performance reasons.  If further depth
   of search mobile node.

   Traffic descriptions are defined in Descriptors, and treatments are
   defined separately in Actions.  A Rule-Set binds Descriptors and
   associated Actions by reference, using Descriptor-Key and Action-Key.
   A Rule-Set is supported the Agent MUST make this known bound to a policy in the Client.

   For Configurable Policy the following search order is applied:

   1.  Policy-Settings of the Installed-Policy

   2.  Settings of the Configurable-Policy

5.  Protocol

   NOTE - The terms Context Policy-Set (using Policy-Key),
   and Mobility-Context are used
   interchangeable throughout the rest of this document.

5.1.  Protocol Messages and Semantics

   Five message types are supported:

   +---------------+----------------+----------------------------------+
   | Message       | Type           | Description                      |
   +---------------+----------------+----------------------------------+
   | CONF          | HEADER OP_TYPE | Configure processes a single Policy references the Rule definitions (using Rule-Key).

              |
              +-[Policy Information Model]
              |      +-[Extensible:]
              | BODY      +-[Policy-Template] <G-Key> (M) <Set>
              | operation.      |       +-[Policy-Status]
              |      |       +-[Rule-Template-Key] <List> (M)
              |      |       | CONF_BUNDLE       +-[Precedence] (M)
              | HEADER OP_TYPE      +-[Rule-Template] <L-Key> (M) <Set>
              | A Conf-bundle takes multiple      |       +-[Descriptor-Match-Type] (M)
              |      | REF_SCOPE       +-[Descriptor-Configuration] <Set> (M)
              | operations that are to be      |       |       +-[Direction] (O)
              | TRANS_STRATEGY      | executed as a group with partial       +-[Action-Configuration] <Set> (M)
              |      |       | 1*[OP_ID BODY]       +-[Action-Order] (M)
              | failures allowed. They are      +-[Descriptor-Template] <L-Key> (M) <Set>
              |      |       +-[Descriptor-Type] (O)
              |      | executed according to the OP_ID       +-[Attribute-Expression] <Set> (M)
              |      +-[Action-Template] <L-Key> (M) <Set>
              |              +-[Action-Type] (O)
              |      |       +-[Attribute-Expression] <Set> (M)

                    Figure 13: Policy Information Model

   The Policy structure defines Policy-Set, Rule-Set, Descriptor-Set,
   and Action-Set, as follows:

   Policy-Template: <Set>  A set of Policy structures, indexed by
      Policy-Key, each of which is determined by a list of Rules
      referenced by their Rule-Key.  Each Policy structure contains the
      following:

      Policy-Key:   Identifies and enables reference to this Policy
         definition.

      Policy-Status:   Either Initial, PartiallyConfigured, Configured,
         or Active.  Default value coupled with is Initial.

      Rule-Template-Key:   Enables reference to a Rule template
         definition.

      Rule-Precedence:   For each Rule identified by a Rule-Template-Key
         in the Policy, specifies the BODY order in   |
   |               |                | ascending order. If a            |
   |               |                | CONF_BUNDLE fails, any entities  |
   |               |                | provisioned which that Rule must be
         applied.  The lower the numerical value of Precedence, the
         higher the rule precedence Rules with equal precedence MAY be
         executed in parallel if supported by the CURRENT       |
   |               |                | operation are removed.  However, |
   |               |                | any successful operations        |
   |               |                | completed prior to Resource Management
         Function.  If this value is absent, the current   |
   |               |                | operation are preserved rules SHOULD be applied
         in the order |
   |               |                | in which they appear in the Policy.

   Rule-Template-Set:   A set of Rule template definitions indexed by
      Rule-Key.  Each Rule is defined by a list of Descriptors (located
      by Descriptor-Key) and a list of Actions (located by Action-Key)
      as follows:

      Rule-Template-Key:   Identifies and enables reference to reduce system load.           |
   |               |                |                                  |
   | REG_MONITOR   | HEADER *[      | Register this Rule
         definition.

      Descriptor-Match-Type  Indicates whether the evaluation of the
         Rule proceeds by using conditional-AND, or conditional-OR, on
         the list of Descriptors.

      Descriptor-Configuration:   References a monitor at Descriptor template
         definition, along with an Agent.  |
   |               | MONITOR ]      | The message includes information |
   |               |                | about expression which names the attribute to monitor   |
   |               |                | and Attributes
         for this instantiation from the reporting method.  Note  |
   |               |                | that a MONITOR_CONFIG is         |
   |               |                | required for this operation.     |
   |               |                |                                  |
   | DEREG_MONITOR | HEADER 1*[     | Deregister monitors from an      |
   |               | MONITOR_ID ] [ | Agent. Monitor IDs are provided. |
   |               | SEND_DATA ]    | SEND_DATA is an optional boolen  |
   |               |                | that indicates if Descriptor-Template and also
         specifies whether each Attribute of the Descriptor has a successful   |
   |               |                | DEREG triggers
         default value or a NOTIFY with     |
   |               |                | final data.                      |
   |               |                |                                  |
   | PROBE         | HEADER         | Probe statically configured value, according to
         the status of syntax specified in Section 4.2.

      Direction:   Indicates if a registered |
   |               | MONITOR_ID     | monitor.                         |
   +---------------+----------------+----------------------------------+

                     Table 1: Client rule applies to Agent Messages

   Each message contains uplink traffic, to
         downlink traffic, or to both uplink and downlink traffic.
         Applying a header with the Client Identifier, an
   execution delay timer rule to both uplink and an operation identifier.  The delay, downlink traffic, in ms,
   is processed as case of
         symmetric rules, eliminates the delay requirement for operation execution from the time the
   operation is received by a separate
         entry for each direction.  When not present, the Agent.

   The Client Identifier direction is used by the Agent to associate specific
   configuration characteristics, e.g. options used
         implied by the Client when
   communicating Descriptor's values.

      Action-Configuration:   References an Action template definition,
         along with an expression which names the Agent, as well as the association of Attributes for this
         instantiation from the
   Client Action-Template and tenant in the information model.

   CONF_BUNDLE also has the Transaction Strategy (TRANS_STRATEGY)
   attribute.  This value specifies the behavior
         whether each Attribute of the Agent when an
   operation fails while processing Action has a CONF_BUNDLE message.  The value of
   'default' uses the default strategy defined for the message.  The value 'all_or_nothing' will roll back all successfully executed
   operations within or a
         statically configured value, according to the bundle as well as syntax specified
         in Section 4.2.

      Action-Order:   Defines the operation that failed.

   An FPC interface protocol used to support this specification may not
   need to support CONF_BUNDLE messages or specific TRANS_STRATEGY types
   beyond 'default' order in which actions are executed
         when the protocol provides similar semantics.
   However, this MUST associated traffic descriptor selects the packet.

   Descriptor-Template-Set:   A set of traffic Descriptors, each of
      which can be clearly evaluated on the incoming or outgoing packet,
      returning a TRUE or FALSE value, defined as follows:

      Descriptor-Template-Key:   Identifies and enables reference to
         this descriptor template definition.

      Attribute-Expression:  An expression which defines an Attribute in
         the specification that
   defines Descriptor-Template and also specifies whether the interface protocol.

   An Agent will respond with an ERROR, OK, Template
         also defines a default value or an OK WITH INDICATION
   that remaining data will be sent via a notify from statically configured value
         for the Agent Attribute of the Descriptor has, according to the
   Client
         syntax specified in Section 5.1.1.4.2 for CONFIG and CONF_BUNDLE requests.  When
   returning 4.2.

      Descriptor-Type:   Identifies the type of descriptor, e.g. an 'ok' IPv6
         traffic selector per [RFC6088].

   Action-Template-Set:   A set of any kind, optional data MAY be present.

   Two Agent notifications are supported:

   +----------------------+----------+---------------------------------+
   | Message              | Type     | Description                     |
   +----------------------+----------+---------------------------------+
   | CONFIG_RESULT_NOTIFY | See      | An asynchronous notification    |
   |                      | Table 13 | from Agent actions defined as follows:

      Action-Template-Key:   Identifies and enables reference to Client based upon |
   |                      |          | this
         action template definition.

      Attribute-Expression:  An expression which defines an Attribute in
         the Action-Template and also specifies whether the Template
         also defines a previous CONFIG default value or            |
   |                      |          | CONF_BUNDLE request.            |
   |                      |          |                                 |
   | NOTIFY               | See      | An asynchronous notification    |
   |                      | Table 14 | from Agent to Client based upon |
   |                      |          | a registered MONITOR.           |
   +----------------------+----------+---------------------------------+

             Table 2: Agent to Client Messages (notifications)

   The HEADER is a part of all messages and is comprised statically configured value
         for the Attribute of the
   following information:

   CLT_ID:  The Client Identifier

   DELAY (OPTIONAL):  The time (in ms) Action has, according to delay the execution syntax
         specified in Section 4.2.

      Action-Type:   Identifies the type of ther
       operaiton an action for unambiguous
         interpretation of an Action-Value entry.

4.9.7.  Mobility-Context Information Model

   The Mobility-Context structure holds entries associated with a mobile
   node and its mobility sessions (flows).  It is created on the a DPN once it is received by
   during the Agent.

   OP_ID:  Operation Identifier
   Results will be supplied per operation input.  Each result contains mobile node's registration to manage the RESULT_STATUS and OP_ID that it corresponds to.  RESULT_STATUS
   values are:

      OK - Success

      ERR - An Error has occurred

   If an error occurs, mobile node's
   flows.  Flow information MUST be returned in the response.
   Error informaiton is comprised of the following:

      ERROR_TYPE_ID (Unsigned 32, REQUIRED) - The identifier of a
      specific error type The values are TRANSPORT (0), RPC (1),
      PROTOCOL(2) added or APPLICATION (3).

      ERROR_TAG - (String, REQUIRED) - enumerated error tag.

      ERROR_APP_TAG - (String, OPTIONAL) - Application specific error
      tag.

      ERROR_MESSAGE - (String, OPTIONAL) - A message describing deleted from the
      error.

      ERROR_INFO - (Any Data, OPTIONAL) - Any data required Mobility-
   Context as needed to support new flows or to deallocate resources for
   flows that are deactivated.  Descriptors are used to characterize the
      response.

5.1.1.  CONFIG and CONF_BUNDLE Messages

   CONFIG
   nature and CONF_BUNDLE include OP_TYPE as part of the header
   information:

   OP_TYPE:  specifies the type resource requirement for each flow.

   Termination of operation.  Valid values are 'create'
       (0), 'update' (1), 'query' (2) or 'delete' (3).

   The BODY is comprised a Mobility-Context implies termination of all flows
   represented in the following information:

   COMMAND_SET:  Specifies the Command Set (see Section 5.1.1.2).

   REF_SCOPE:  If supported, specifies the Reference Scope (see
       Section 5.1.1.3)

   BODY INTERNALS:  A list of entities under Policy, Mobility-Context, e.g.  Policy-
       Definitions, Action-Definitions, etc. as well as Installed
       Policies and Contexts when after deregistration of a
   mobile node.  If any Child-Contexts are defined, they are also
   terminated.

      +-[Mobility-Context] <G-Key> <Set>
      |            +-[Extensible ~ FALSE]
      |            +-[Delegating-IP-Prefix:] <Set>
      |            +-[Parent-Context]
      |            +-[Child-Context] <Set>
      |            +-[Mobile-Node]
      |            |       +-[IP-Address] <Set>
      |            |       +-[MN-Policy-Configuration] <Set>
      |            +-[Domain-Key]
      |            |       +-[Domain-Policy-Configuration] <Set>
      |            +-[DPN-Key] <Set>
      |            |       +-[Role]
      |            |       +-[DPN-Policy-Configuration] <Set>
      |            |       +-[ServiceDataFlow]
      |            |       |       +-[Service-Group-Key]
      |            |       |       +-[Interface-Key] <Set>
      |            |       |       +-[Flow-Policy-Configuration] <Set>
      |            |       |       |       +-[Direction]

               Figure 14: Mobility-Context Information Model

   The Mobility-Context Substructure holds the OP_TYPE is 'create' following entries:

   Mobility-Context-Key:   Identifies a Mobility-Context

   Extensible:  Determines whether or 'update'.
       Otherwise it not entities instantiated from
      this Template can be extended with new non-mandatory Attributes
      not defined here.  Default value is FALSE.

   Parent-Context:   If present, a list Mobility Context from which the
      Attributes and Attribute Values of Targets for 'query' or 'deletion'.  See
       Section 6.1.3.2 for details.

   CONF_BUNDLES includes an OP_ID with each body for tracking this Mobility Context are
      inherited.

   Child-Context:   A set of the
   bundle's subtransactions.

5.1.1.1.  Agent Operation Processing

   The Agent will process entities provided in an operation in the
   following order:

   1.  Action-Definitions

   2.  Descriptor Defintions

   3.  Rule Definitions

   4.  Policy Definitions

   5.  Installed Policies

   6. Mobility Contexts according to COMMAND_SET

5.1.1.2.  Command Bitsets

   The COMMAND_SET is a technology which inherit the
      Attributes and Attribute Values of this Mobility Context.

   Mobile-Node:   Attributes specific bitset that allows for a
   single entity to be sent in an operation with multiple requested sub-
   transactions the Mobile Node.

   Domain-Key:   Enables access to be completed.  It can also provide clarity for a
   request. Domain instance.

   Domain-Policy-Configuration:   For example, a Mobility-Context could have the Home Network
   Prefix absent but it is unclear if the Client would like the address
   to be assigned by each Domain-Policy in the Agent or if this is an error.  Rather than
   creating set, a specific command
      key and relevant information for assigning the IP Policy Attributes.

   DPN-Key:   Enables access to a bit position DPN instance.

   Role:   Role this DPN fulfills in the Mobility-Context.

   DPN-Policy-Configuration:   For each DPN-Policy in the set, a
   COMMAND_SET is reserved key and
      relevant information for Agent based IP assignment.

5.1.1.3.  Reference Scope

   The Reference Scope is an optional feature the Policy Attributes.

   ServiceDataFlow:   Characterizes a traffic flow that provides has been
      configured (and provided resources) on the scope DPN to support data-
      plane traffic to and from the mobile device.

      Service-Group-Key:   Enables access to a Service-Group instance.

      Interface-Key:   Assigns the selected interface of
   references used the DPN.

      Flow-Policy-Configuration:   For each Flow-Policy in the set, a configuration command, i.e. CONFIG or
   CONF_BUNDLE.  These scopes are defined as

   o  none - All entities have no references to other entities.

   o  op - All references are contained in
         key and relevant information for the operation body, i.e. only
      intra-operation references exist.

   o  bundle - All references exist in bundle (inter-operation/intra-
      bundle).  NOTE - If this value is present in Policy Attributes.

         Direction:   Indicates if a CONFIG message it
      is equivalent rule applies to 'op'.

   o  storage - One uplink or more references exist outside of the operation downlink
            traffic, or to both, uplink- and bundle.  A lookup downlink traffic.  Applying
            a rule to cache / storage is required.

   o  unknown - the location both, uplink- and downlink traffic, in case of
            symmetric rules, allows omitting a separate entry for each
            direction.  When not present the references are unknown.  This value is
      treated as assumed to apply
            to both directions.

4.9.8.  Monitor Information Model

   Monitors provide a 'storage' type.

   An agent mechanism to produce reports when events occur.  A
   Monitor will have a target that only accepts 'op' or 'bundle' reference scope messages specifies what is referred to as 'stateless' as it has no direct memory of
   references outside messages themselves.  This permits low memory
   footprint Agents.  Even when an Agent supports all message types an
   'op' or 'bundle' scoped message can be processed quickly by watched.

   The attribute/entity to be monitored places certain constraints on
   the Agent
   as configuration that can be specified.  For example, a Monitor
   using a Threshold configuration cannot be applied to a Mobility-
   Context, because it does not require storage access.

5.1.1.4.  Operation Response

5.1.1.4.1.  Immediate Response

   For CONF and CONF_BUNDLE the Response MAY include the the following:

      NOTIFY_FOLLOWS - A boolean indicator that the Operation has been
      accepted by the Agent but further processing is required.  A
      CONFIG_RESULT_NOTIFY will have a threshold.  Such a monitor
   configuration could be sent once the processing has
      succeeded or failed.

      ENTITIES - Optionally, entities created or partially fulfilled as
      part applied to a numeric threshold property of a
   Context.

                        |
                        +-[Monitor] <List>
                        |         +-[Extensible:]
                        |         +-[Monitor-Key:] <U-Key>
                        |         +-[Target:]
                        |         +-[Deferrable]
                        |         +-[Configuration]

                      Figure 15: Monitor Substructure

   Monitor-Key:  Name of the operation as specified in Table 12 For Clients that
      need attributes back quickly for call processing, the AGENT MUST
      respond back with an OK_NOTIFY_FOLLOWS and minimally the
      attributes assigned by the Agent in the response.  These
      situations Monitor.  The format MUST be determined through the use of Command Sets (see conform to
      Section 5.1.1.2).

5.1.1.4.2.  Asynchronous Notification

   A CONFIG_RESULT_NOTIFY occurs after the Agent has completed
   processing related 4.5.

   Target:  Description of what is to be monitored.  This can be a CONFIG or CONF_BUNDLE request.  It
      Service Data Flow, a Policy installed upon a DPN, values of a
      Mobility-Context, etc.  The target name is an
   asynchronous communication from the Agent absolute
      information model path (separated by '/') to the Client.

   The values of the CONFIG_RESULT_NOTIFY are detailed in Table 13.

5.1.2.  Monitors

   An Agent may reject attribute /
      entity to be monitored.

   Deferrable:   Indicates that a registration if it or the DPN has insufficient
   resources.

   An Agent or DPN may temporarily suspend monitoring if insufficient
   resources exist.  In such report can be delayed up to
      a case the Agent MUST notify defined maximum delay for possible bundling with other reports.

   Configuration:  Determined by the Client.

   When a Monitor subtype.  The monitor has a reporting configuration of SCHEDULED it
      report is
   automatically de-registered after specified by the last NOTIFY occurs.

   If Configuration.  Four report types are
      defined:

      *  "Periodic" reporting specifies an interval by which a SCHEDULED or PERIODIC configuration
         notification is provided during
   registration with the time related value (time or period
   respectively) of 0 sent.

      *  "Event-List" reporting specifies a NOTIFY is sent list of event types that, if
         they occur and are related to the monitor is immediately
   de-registered.  This method should, when a MONITOR has not been
   installed, monitored attribute, will
         result in an immediate NOTIFY sufficient for the Client's
   needs and lets the Agent realize sending a notification.

      *  "Scheduled" reporting specifies the Client has no further need time (in seconds since Jan
         1, 1970) when a notification for the monitor to should be registered.

   PROBE messages sent.
         Once this Monitor's notification is completed the Monitor is
         automatically de-registered.

      *  "Threshold" reporting specifies one or both of a low and high
         threshold.  When these values are also used by crossed a corresponding
         notification is sent.

5.  Protocol

5.1.  Protocol Messages and Semantics

   Four Client to retrieve information
   about a previously installed monitor.  The PROBE Agent messages are supported.

   +---------------------+---------------------------------------------+
   | Message             | Description                                 |
   +---------------------+---------------------------------------------+
   | Configure           | A Configure message SHOULD
   identify includes multiple edits |
   |                     | to one or more monitors by means of including the associated
   monitor identifier.  An Agent receiving a PROBE information model entities.  |
   |                     | Edits are executed according to their Edit- |
   |                     | Id in ascending order.  The global status   |
   |                     | of the operation and the status of          |
   |                     | individual edits are returned. Partial      |
   |                     | failures, i.e. individual edit failures,    |
   |                     | are allowed.                                |
   | Register-Monitors   | Register monitors at an Agent. The message sends  |
   |                     | includes the
   requested Monitor information as         |
   |                     | specified in Section 4.9.8.                 |
   | Deregister-Monitors | Deregister monitors from an Agent. An       |
   |                     | optional boolean, Send-Data, indicates if a single or multiple NOTIFY messages.

   If the Monitor configuration associated with |
   |                     | successful deregistration triggers a NOTIFY is deterrable
   then the NOTIFY MAY be bundled Notify |
   |                     | with other messages back to final data from the Agent
   even if this results in a delay of for the NOTIFY.

5.1.2.1.  Asynchronous Notification

   A NOTIFY can be sent as part      |
   |                     | corresponding Monitor.                      |
   | Probe               | Probe the status of de-registraiton, a trigger based upon
   a Monitor Configuration or registered monitors.    |
   |                     | This triggers a PROBE.  A NOTIFY is comprised of unique
   Notification Identifier Notify with current data    |
   |                     | from the Agent, Agent for the Monitor ID corresponding        |
   |                     | Monitors.                                   |
   +---------------------+---------------------------------------------+

                     Table 1: Client to Agent Messages

   Each message contains a header with the
   notification applies to, following information:

   Client Identifier:  An Identifier used by the Trigger for Agent to associate
       specific configuration characteristics, e.g. options used by the notification, a
   timestamp of
       Client when communicating with the notification's associated event occurs and data
   that is specific to Agent, the association of the monitored value's type.

5.2.  Protocol Operation

5.2.1.  Simple RPC Operation

   An FPC
       Client and Agent MUST identify themselves using the CLI_ID tenant in the information model as well as tracking
       operations and
   AGT_ID respectively notifications.

   Delay:  An optional time (in ms) to ensure that for all transactions a recipient
   of an FPC message can unambiguously identify delay the sender execution of the FPC
   message.  A Client MAY direct
       operation on the Agent to enforce a rule in a
   particular DPN once it is received by including a DPN_ID value in a Context.  Otherwise
   the Agent selects a suitable DPN to enforce a Context and notifies the Client about the selected DPN using Agent.

   Operation Identifier:  A unique identifier created by the DPN_ID.

   All messages sent from a Client to an
       correlate responses and notifications

   An Agent MUST be acknowledged by
   the Agent.  The response must include all entities as well as will respond with an ERROR, indicating one or more Errors
   have occured, or an OK.

   For Configure messages, an OK status
   information, which indicates the result of processing for an edit MAY include
   subsquent edits in the message,
   using response that were required to properly
   execute the RESPONSE_BODY property.  In case edit.  It MAY also indicate that the processing of final status and any
   final edits required to fulfill the
   message results in request will be sent via a failure,
   Configure result notification from the Agent sets to the ERROR_TYPE and
   ERROR_TAG accordingly Client, see
   Section 5.1.1.4.2.

   If errors occur, they MUST be returned as a list in responses and MAY clear
   each Error contains the entity, e.g.  Context following information:

   Error-type:  The specific error type.  Values are TRANSPORT (0), RPC
       (1), PROTOCOL(2) or
   Configurable-Policy, which caused APPLICATION (3).

   Error-Tag:  An error tag.

   Error-App-Tag:  Application specific error tag.

   Error-Message:  A message describing the failure, in error.

   Error-Info:  Any data required for the response.

   If based upon Agent configuration or the processing of the request
   possibly taking a significant amount of time the Agent MAY respond
   with a NOTIFY_FOLLOWS indicaiton with an optional RESPONSE_BODY
   containing the partially completed entities.  When a NOTIFY_FOLLOWS
   indication is indicated, the

                         |
                         +-[Errors] <List>
                         |         +-[(Enumeration) Error-Type ]
                         |         +-[(String) Error-Tag ]
                         |         +-[(String) Error-App-Tag ] (O)
                         |         +-[(String) Error-Message ] (O)
                         |         +-[Error-Info] (O)

                    Figure 16: Error Information Model

   Two Agent will, upon completion or failure
   of the operation, respond with an asynchronous CONFIG_RESULT_NOTIFY to the Client.

   A Client MAY add a property notifications are supported.

   +-------------------------------+-----------------------------------+
   | Message                       | Description                       |
   +-------------------------------+-----------------------------------+
   | Configure-Result-Notification | An asynchronous notification from |
   |                               | Agent to Client based upon a Context without providing all
   required details of the attribute's value.  In such case the      |
   |                               | previous Configure request.       |
   | Notify                        | An asynchronous notification from |
   |                               | Agent
   SHOULD determine the missing details and provide the completed
   property description back to the Client.  If the processing will take
   too long or Client based upon Agent a      |
   |                               | registered Monitor's              |
   |                               | configuration, the a Monitor          |
   |                               | deregistration or Probe.          |
   +-------------------------------+-----------------------------------+

             Table 2: Agent MAY respond to Client Messages (notifications)

5.1.1.  Configure Message

   The Configure message follows edit formats proposed by [RFC8072] with
   more fields in each edit, an OK that indicates a NOTIFY_FOLLOWS extra operation (clone) and also includes a
   RESPONSE_BODY containing the partially completed entities.

   In case the Agent cannot determine different
   response format.

5.1.1.1.  Edit Operation Types

   +-----------+-------------------------------------------------------+
   | Operation | Description                                           |
   +-----------+-------------------------------------------------------+
   | create    | Creates a new data resource or Entity.  If the missing value of        |
   |           | resource exists an
   attribute's value per the Client's request, error is returned.                 |
   | delete    | Deletes a resource.  If it leaves the attribute's
   value cleared does not exist an error is |
   |           | returned.                                             |
   | insert    | Inserts data in a list or user ordered list.          |
   | merge     | Merges the RESPONSE_BODY and sets edit value with the RESULT to Error,
   ERROR_TYPE and ERROR_TAG.  As example, the Control-Plane needs to
   setup a tunnel configuration in target data resource;  |
   |           | the Data-Plane but has to rely on resource is created if it does not exist.         |
   | move      | Moves the
   Agent to determine target data resource.                       |
   | replace   | Replace the tunnel endpoint which is associated target data resource with the
   DPN that supports edit value. |
   | remove    | Removes a data resource if it already exists.         |
   | clone     | Clones a data resource and places the Context.  The Client adds copy at the tunnel property
   attribute to new |
   |           | location.  If the FPC message and clears resource does not exist an error is |
   |           | returned.                                             |
   +-----------+-------------------------------------------------------+

                    Table 3: Configure Edit Operations

5.1.1.2.  Edit Operation

   Each Configure includes one or more edits.  These edits include the value of
   following information:

   Edit-Id:  uniquely specifies the attribute
   (e.g.  IP address identifier of the local tunnel endpoint).  The Agent
   determines edit within the tunnel endpoint and includes
       operation.

   Edit-Type:  specifies the completed tunnel
   property in its response type of operation (see Section 5.1.1.1).

   Command-Set:  The Command-Set is a technology-specific bitset that
       allows for a single entity to the Client.

   Figure 15 illustrates be sent in an exemplary session life-cycle based on Proxy
   Mobile IPv6 registration via MAG Control-Plane function 1 (MAG-C1)
   and handover edit with multiple
       requested, technology specific sub-transactions to MAG Control-Plane function 2 (MAG-C2).  Edge DPN1
   represents be completed.
       It can also provide clarity for a request.  For example, a
       Mobility-Context could have the Proxy CoA after attachment, whereas Edge DPN2 serves
   as Proxy CoA after handover.  As exemplary architecture, Home Network Prefix absent but it
       is unclear if the FPC
   Agent and Client would like the network control function are assumed address to be co-located
   with assigned by
       the Anchor-DPN, e.g. a Router.

                                                 +-------Router--------+
                           +-----------+         |+-------+ +---------+|
   +------+ +------+     +-----+ FPC   |          | FPC   | |  Anchor |
   |MAG-C1| |MAG-C2|     |LMA-C| Client|          | Agent or if this is an error.  Rather than creating a
       specific command for assigning the IP a bit position in a
       Command-Set can be used to indicate Agent based IP assignment
       requests.

   Reference-Scope:  If supported, specifies the Reference Scope (see
       Section 5.1.1.3)

   Target:  Specifies the Target node (Data node path or FPC Identity)
       for the edit operation.  This MAY be a resource, e.g.  Mobility-
       Context, Descriptor-Template, etc., or a data node within a
       resource as specified by its path.

   Point:  The absolute URL path for the data node that is being used as
       the insertion point, clone point or move point for the target of
       this 'edit' entry.

   Where:  Identifies where a data resource will be inserted, cloned to
       or moved.  Only allowed these for lists and lists of data nodes
       that are 'ordered-by user'.  The values are 'before', 'after',
       'first', 'last' (default value).

   Value  The value used for this edit operation.

             |
             +-[Configure]
             |   DPN   |
   +------+ +------+     +-----+-------+          +-------+ +---------+
   [MN attach]  |            |                          |           |
      |-------------PBU----->|                          |           |
      |         |            |---(1)--CONFIG(CREATE)--->|           |
      |         |            |   [ MOBILTY_CONTEXT_ID,  |--tun1 up->|
      |         |            | DPNREFLIST:[[DPN1, BOTH  |           |
      |         |            |  DPN_SETTINGS_COMPL:[    |           |
      |         |            |   DOWNLINK(QOS/TUN),     |           |
      |         |            |   UPLINK(QOS/TUN)] ]]    |--tc qos-->|
      |         |            |   CTXT_SETTINGS_COMPL:[  |           |
      |         |            |     IP_PREFIX(HNP) ] ]   |           |
      |         |            |<---(2)- OK --------------|-route add>|
      |         |            |                          |           |
      |<------------PBA------|                          |           |
      |         |            |                          |           |
      | +----+  |            |                          |           |
      | |Edge|  |            |                          |           |
      | |DPN1|  |            |                          |           |
      | +----+  |            |                          |           |
      |   |         +-[Client-Id:]
             |         +-[(Unsigned 32) Execution-Delay]
             |   |-=======================================================-|         +-[Operation-Id:]
             |         +-[Edits:] <List>
             |         |    +-[Edit-Id:] <L-Key>
             |         |   [MN handover]    +-[(Enumeration) Edit-Type:]
             |         |    +-[(BitSet) Command-Set]
             |         |         |---PBU ---->|    +-[(Enumeration) Reference-Scope]
             |         |    +-[Target:]
             |         |            |--(3)- CONFIG(MODIFY)---->|    +-[Point]
             |         |         |<--PBA------|    [ MOBILTY_CONTEXT_ID  |-tun1 mod->|    +-[(Enumeration) Where]
             |         |    +-[Value]

                       Figure 17: Configure Request

   Edits sent to the Agent provided in an operation SHOULD be sent in
   the following order to avoid errors:

   1.  Action Templates

   2.  Descriptor Templates

   3.  Rule Templates

   4.  Policy Templates

   5.  DPN Templates
   6.  Mobility Contexts

5.1.1.3.  Reference Scope

   The Reference Scope is an optional feature that provides the scope of
   references used in a configuration command.  These scopes are defined
   as:

   o  none - All entities have no references to other entities.

   o  edit - All references are contained in the edit body, i.e. only
      intra-operation references exist.

   o  operation - All references exist in the operation (inter-edit/
      intra-operation).

   o  storage - One or more references exist outside of the operation.
      A lookup to cache / storage is required.

   o  unknown - the location of the references are unknown.  This is
      treated as a 'storage' type.

   An Agent that only accepts 'edit' or 'operation' reference scope
   messages is referred to as 'stateless' as it has no direct memory of
   references outside messages themselves.  This permits low memory
   footprint Agents/DPNs.  Even when an Agent supports all message types
   an 'edit' or 'operation' scoped message can be processed quickly by
   the Agent/DPN as it does not require storage access.

   Figure 18 shows an example containment hierarchy provided for all
   caches.

                         +---------------+
                         | DPNREFLIST:[[DPN1, BOTH  |           |
      |         |            |    DPN_SETTINGS_COMPL:[  |           |
      |         |            |   DOWNLINK(TUN),         | Global Cache  |
                         |  (storage)    |  +----+
                         +------+--------+
                                |   UPLINK(TUN)] ]] ]
                                +----------------+
                                |                |
                +------+-----------+      +------+-----------+
                | Operation Cache  |  |Edge|    |<---(4)- OK --------------|      | Operation Cache  |
                |  |DPN2|   (operation)    | .... |   (operation)    |
                +------+-----------+      +--------+---------+
                       |                           |  +----+
                   +---+-----------+               |
                   |               |               |
            +------+------+ +------+------+ +------+------+
            | Edit Cache  | | Edit Cache  | | Edit Cache  |
            |    |-============================================-|   (edit)    | |   (edit)    | |   (edit)    |
            +-------------+ +-------------+ +-------------+

                                (no cache)

                   Figure 15: Exemplary Message Sequence (focus on FPC reference point)

   After reception of the Proxy Binding Update (PBU) at the LMA Control-
   Plane function (LMA-C), the LMA-C selects a suitable DPN, which
   serves as Data-Plane anchor to the mobile node's (MN) traffic. 18: Exemple Hierarchical Cache

5.1.1.4.  Operation Response

5.1.1.4.1.  Immediate Response

   The
   LMA-C adds a new logical Context to the DPN to treat Response MUST include the MN's traffic
   (1) and includes a Context following:

      Operation Identifier (CONTEXT_ID) to the CONFIG
   command.  The LMA-C identifies the selected Anchor DPN by including
   the associated DPN identifier and the Direction the entry applies to,
   BOTH.

   The LMA-C adds properties during the creation of the new Context.
   One property is added to the DPN Settings Complimentary, to specify corresponding request.

      Global Status for the forwarding tunnel type and endpoints (Anchor DPN, Edge DPN1) in
   each direction (as required).  Another property operation (see Table 1).

      A list of Edit results (described below).

   An edit response, Edit-Status, is added to specify
   the QoS differentiation, which the MN's traffic should experience.
   At reception comprised of the Context, following:

      Edit-Id: Edit Indentifier.

      Edit-Status: OK.

      When the FPC Agent utilizes local
   configuration commands to create Edit-Status is OK the tunnel (tun1) as well as following values MAY be present

         Notify-Follows - A boolean indicator that the
   traffic control (tc) to enable QoS differentiation.  After
   configuration edit has been completed,
         accepted by the Agent applies a new route to
   forward all traffic destined to but further processing is required.  A
         Configure-Result-Notification will be sent once the MN's HNP specified as processing
         has succeeded or failed.

         Subsequent-Edits: This is a property
   in list of Edits that were required to
         fulfill the Context's Complementary Settings and applied request.  It follows the configured
   tunnel interface (tun1).

   During handover, edit request semantics
         (see Section 5.1.1.2).

      Errors: When the LMA-C receives an updating PBU from Edit-Status is ERROR the handover
   target MAG-C2. following values are
      present.  See Table 1 for details.

   The PBU refers to response will minimally contain an Edit-Status implying 'OK' or a new Data-Plane node (Edge DPN2)
   to represent the new tunnel endpoints in the downlink and uplink, as
   required.  The LMA-C sends a CONFIG message (3) to the Agent to
   modify the existing tunnel property of the existing Context and to
   update the tunnel endpoint from Edge DPN1 to Edge DPN2.  Upon
   reception
   list of the CONFIG message, the Agent applies updated tunnel
   property to the local configuration and responds to the Client (4).

                                                 +-------Router--------+
                           +-----------+         |+-------+ +---------+|
   +------+ +------+     +-----+ FPC   |          | FPC   | |  Anchor |
   |MAG-C1| |MAG-C2|     |LMA-C| Client|          | Agent | |   DPN   |
   +------+ +------+     +-----+-------+          +-------+ +---------+
   [MN attach]  |            |                          |           |
      |-------------PBU----->|                          |           |
      |         |            |---(1)--CONFIG(MODIFY)--->|           |
      |<------------PBA------|   [ CONTEXT_ID,          |--tun1   ->|
      |         |            | DPNREFLIST:[[DPN1, BOTH |           |
      |         |            |    DPN_SETTINGS_COMPL:[  |           |
      |         |            |   DOWNLINK(TUN delete),  |    down   |
      |         |            | UPLINK(TUN delete)] ]] ] |           |
      |         |            |                          |           |
      |         |            |<-(2)- OK ----------------|           |
      |         |            | errors.

             |
             +-[Operation-Id:]
             +-[Result-Status:]
             +-[Errors] <List>
             |         +-[(Enumeration) Error-Type:]
             |         +-[(String) Error-Tag:]
             |  [ MinDelayBeforeBCEDelete expires ]         +-[(String) Error-App-Tag]
             |         +-[(String) Error-Message]
             |         +-[Error-Info]
             +-[Edit-Status]
             |         +-[Edit-Id:]
             |         +-[Edit-Status: ~ OK]
             |         +-[Notify-Follows]
             |         +-[Subsequent-Edits] <List>
             |         |    +-[Edit-Id:] <L-Key>
             |            |---(3)--CONFIG(DELETE)--->|-- tun1 -->|         |    +-[(Enumeration) Edit-Type:]
             |         |    +-[Target:]
             |  delete         |    +-[Point]
             |         |            |<-(4)- OK ----------------|    +-[(Enumeration) Where]
             |         |    +-[Value]
             |         +-[Errors] <List>
             |                          |-- route ->|         |         +-[(Enumeration) Error-Type:]
             |         |         +-[(String) Error-Tag:]
             |   remove         |         +-[(String) Error-App-Tag]
             |         |         +-[(String) Error-Message]
             |         |         +-[Error-Info]
             |

                  Figure 16: Exemplary Message Sequence (focus on FPC reference point)

   When a teardown of 19: Configure Operation Response

5.1.1.4.2.  Asynchronous Notification

   A Configure-Result-Notification occurs after the session occurs, MAG-C1 will send a PBU with a
   lifetime value of zero.  The LMA-C sends a CONFIG message (1) Agent has completed
   processing related to a Configure request.  It is an asynchronous
   communication from the Agent to modify the existing tunnel property of the existing Context Client.

   It is identical to delete the tunnel information.)  Upon reception of the CONFIG
   message, the Agent removes immediate response with the tunnel configuration and responds to exception that the Client (2).  Per [RFC5213], the PBA is sent back immediately
   after the PBA is received.

   If no valid PBA
   Notify-Follows, if present, MUST be false.  As this value is received after
   unnecessary it SHOULD be ommitted.

5.1.1.5.  Reserved Identities

   Several identities are reserved in the expiration of Policy Information Model and
   Mobility-Context to faciliate specfic uses cases.

   Agents and tenants express their support for descriptors and actions
   using the
   MinDelayBeforeBCEDelete timer (see [RFC5213]), following Key patterns

      supported-<descriptor template name> indicates a support for the LMA-C will send
      descriptor template as defined in its original specification.  For
      example "base-rfc5777classifier" is a
   CONFIG (3) message with Descriptor Template that
      conforms to the rfc5777-classifier (Figure 28) as defined in this
      document.

      supported-<action template name> indicates a deletion request support for the Context.  Upon
   reception
      action template as defined in its original specification.

      "base-rule" is comprised of the message, the Agent deletes the tunnel all base descriptors using an 'or'
      Descriptor-Match-Type and route on all Actions in no specific order.

      "base-template" is comprised of the DPN base rule.

   "base-template" can be used to determine supported Action and responds
   Descriptor Templates.  It can also be used to support an open
   template where any specific Descriptors and Actions can be applied,
   however, depending upon the Order of Actions it is likely to produce
   undesirable results.

   One use case is supported via reservation of specific DPN-Keys:

      Requested policies are those that the Client (4).

   When would like to be
      assigned to a multi-DPN Agent DPN.  The naming convention is similar to those used the
      for DPN list permits several DPNs Assignment via an Agent.

         "Requested" is a Key that represents requested policies which
         have not been assigned to
   be provisioned in a single message for specific DPN.  No Role is assigned
         to the single Conext.

                           +-----------+           +-------+ +---------+
   +------+ +------+     +-----+ FPC   |           | FPC   | |  Anchor |
   |MAG-C1| |MAG-C2|     |LMA-C| Client|           | Agent | |   DPN1  |
   +------+ +------+     +-----+-------+           +-------+ +---------+
   [MN attach]  |            |                          |           |
      |-------------PBU----->|                          |           |
      |         |            |---(1)--CONFIG(CREATE)--->|           |
      |         |            |   [ MOBILTY_CONTEXT_ID,  |--tun1 up->|
      |         |            | DPNREFLIST:[[DPN1, BOTH  |           |
      |         |            |    DPN_SETTINGS_COMPL:[  |           |
      |         |            |   DOWNLINK(QOS/TUN),     |           |
      |         |            |   UPLINK(QOS/TUN) ] ],   |--tc qos-->|
      |         |            |    [DPN2, BOTH           |           |
      |         |            |    DPN_SETTINGS_COMPL:[  |           |
      |         |            |   DOWNLINK(QOS/TUN),     |           |
      |         |            |   UPLINK(QOS/TUN) ] ] ], |           |
      |         |            |   CTXT_SETTINGS_COMPL [  |           |
      |         |            |     IP_PREFIX(HNP) ] ]   |           |
      |         |            |<-(2)- OK_NOTIFY_FOLLOWS -|-route add>|
      |         |            |                          |           |
      |<------------PBA------|                          |           |
      |         |            |                          |           |
      | +----+               |                          |           |
      | |Edge|               |                          |           |
      | |DPN2|               |                          |           |
      | +----+               |                          |           |
      |   |<---------------------- tun1 up -------------|           |
      |   |<---------------------- tc qos --------------|           |
      |   |<---------------------- route add -----------|           |
      |   |                  |                          |           |
      |   |                  |<(3) CONFIG_RESULT_NOTIFY |           |
      |   |                  |   [ Response Data ]      |           |
      |   |                  |                          |           |

         Figure 17: Exemplary Message Sequence for Multi-DPN Agent

   Figure 17 shows how the first 2 messages in Figure 15 are supported
   when a multi-DPN Agent communicates with both Anchor DPN1 and Edge
   DPN2.  In such DPN.

         "Requested-<Role>" represents requested policies that have not
         been assigned to a case, the FPC Client sends the downlink DPN and uplink
   for both can only be assigned to DPNs that
         fulfill the specified Role.

      It is possible to have policies in the "Requested" DPN Reference List of that do not
      appear in other entries which reflects the same Context.  Message
   1 shows inability to
      successfully assign the DPN Reference List with all entries.  Each entry
   identifies policy.

5.1.2.  Monitor Messages

   An Agent may reject a registration if it or the DPN and direction (one of 'uplink', 'downlink' or
   'both').

   The has insufficient
   resources.

   An Agent responds with an OK and NOTIFY_FOLLOWS indication while it
   simultaneoulsy provisions both DPNs.  Upon successful completion, or DPN MAY temporarily suspend monitoring if insufficient
   resources exist.  In such a case the Agent responds to MUST notify the Client Client.

   When a monitor has a reporting configuration of SCHEDULED it is
   automatically de-registered after the last Notify occurs.

   If a SCHEDULED or PERIODIC configuration is provided during
   registration with the time related value (time or period
   respectively) of 0 a CONFIG_RESULT_NOTIFY indicating Notify is sent and the operation status.

5.2.2.  Policy And Mobility on monitor is immediately
   de-registered.  This method should, when a Monitor has not been
   installed, result in an immediate Notify sufficient for the Client's
   needs and lets the Agent

   A realize the Client may build Policy and Topology using any mechanism on has no further need for
   the
   Agent.  Such entities are not always required monitor to be constructed in
   realtime and, therefore, there are no specific registered.

   Probe messages defined for
   them in this specification.

   The Client may add, modify or delete many Installed Policies and
   Contexts in are used by a single FPC message.  This includes linking Contexts Client to
   Actions and Descriptors, i.e. a Rule.  As example, retrieve information about a Rule which
   performs re-writing
   previously installed monitor.  The Probe message SHOULD identify one
   or more monitors by means of an arriving packet's destination IP address
   from IP_A to IP_B matching an associated Descriptor, can be enforced
   in including the Data-Plane via an associated monitor
   identifier.  An Agent to implicitly consider matching
   arriving packet's source IP address against IP_B and re- write receiving a Probe message sends the
   source IP address requested
   information in a single or multiple Notify messages.

   If the Monitor configuration associated with a Notify can be
   deferred, then the Notify MAY be bundled with other messages back to IP_A.

   Figure 18 illustrates
   the generic policy Agent even if this results in a delay of the Notify.

   The Monitor messages use the following data:

   Monitor-Key:  Monitor Key.

   Monitor:  A Monitor configuration model (see Section 4.9.8).

   Send-Data:  An indicator that specifies that the final value MUST be
       sent as used
   between a FPC Client and a FPC notification from the Agent.

          Descriptor_1 -+          +- Action_1

             |
             +-[Register-Monitors]
             |
          Descriptor_2 -+--<Rule>--+- Action_2
                          +------+
                          /Order#/-------------+
                          +------+         +-[Client-Id:]
             |         +-[(Unsigned 32) Execution-Delay]
             |
          Descriptor_3 -+          +- Action_3 +-<Policy>         +-[Operation-Id:]
             |         +-[Monitors] <List>
             |         |  ^
          Descriptor_4 -+--<Rule>--+- Action_4         +-[Extensible:]
             |         |
                          +------+         +-[Monitor-Key:] <U-Key>
             |         |
                          /Order#/-------------+         +-[Target:]
             |
                          +------+         |
                                                 <Intsalled-Policy>

          +---------------------+     +----------------------+         +-[Binding-Information]
             | Bind 1..M traffic         |         +-[Deferrable]
             |  Bind 1..N traffic         |         +-[Configuration:]

             |  Descriptors to
             +-[Deregister-Monitors]
             | -->         +-[Client-Id:]
             |  treatment actions         +-[(Unsigned 32) Execution-Delay]
             |         +-[Operation-Id:]
             |  to a Policy and         +-[Monitors:] <List>
             |         |   to a Policy and         +-[Monitor-Key:] <U-Key>
             |         | Configurable-Policy         +-[(Boolean) Send-Data ~ False]

             |
             +-[Deregister-Monitors]
             |  Configurable-Policy         +-[Client-Id:]
             |
          +---------------------+     +----------------------+         +-[(Unsigned 32) Execution-Delay]
             |         +-[Operation-Id:]
             |
         +-------------- Data-Plane Rule ------------------+         +-[Monitor-Key:] <List>

                        Figure 18: Structure 20: Monitor Messages

5.1.2.1.  Asynchronous Notification

   A Monitor Report can be sent as part of de-registration, a trigger
   based upon a Monitor Configuration or a Probe.  A Report is comprised
   of Configurable Policies

   As depicted in Figure 18, the Configurable-Policy represents Monitor Key the
   anchor of Rules through report applies to, the Policy / Rule hierarchy.  A Client and
   Agent use Trigger for the identifier report,
   a timestamp of when the report's' associated Policy to directly access
   the Rule and perform modifications of traffic Descriptors or Action
   references.  A Client event occurs and Agent use the identifiers to access the
   Descriptors or Actions data
   that is specific to perform modifications.  From the viewpoint
   of packet processing, arriving packets monitored value's type.

   Triggers include but are matched against traffic
   Descriptors and processed according not limited to the treatment Actions
   specified

   o  Subscribed Event occurred

   o  Low Threshold Crossed

   o  High Threshold Crossed
   o  Periodic Report

   o  Scheduled Report

   o  Probe

   o  Deregistration Final Value

   o  Monitoring Suspended

   o  Monitoring Resumed

   o  DPN Availabile

   o  DPN Unavailable

   Multiple Reports are sent in the list of properties associated with the Configurable-
   Policy.

   A Client complements a rule's Descriptors with a Rule's Order
   (priority) value to allow unambiguous traffic matching on the Data-
   Plane.

   Figure 19 illustrates Notify message.  Each Notify is
   comprised of unique Notification Identifier from the generic context configuration model as used
   between a FPC Client Agent and a FPC Agent.

             TrafficSelector_1
                      |
             profile-parameters
                      |
             mobility-profile-- dl ------+
                                ^        |
                                |      qos-profile
                           <ContextID1>       |
                                ^        per-mn-agg-max-dl_2
                                |
                           <ContextID2>

             +-------------------+     +---------------------+
             | Bind 1..M traffic |     |  Bind 1..N traffic  |
             |    selectors to   | --> |  treatment / qos    |
   timestamp indicating when the notification was created.

           |     a Context
           +-[ Notify ]
           |         +-[(Unsigned 32) Notification-Identifier:]
           |  actions to a         +-[Timestamp:]
           |         +-[Report:] <List>
           |         |    +-[Trigger:]
           |       Context         |
             +-------------------+     +---------------------+    +-[Monitor-Key:]
           |         |
            +-------------- Data-Plane Rule ------------------+    +-[Value]

                        Figure 19: Structure of Contexts

   As depicted 21: Monitor Messages

5.2.  Protocol Operation

   Please note that JSON is used to represent the information in Figure 19, Figures
   in this section but any over the Context represents a mobility session
   hierarchy.  A wire representation that accurately
   reflects the information model MAY be used.

5.2.1.  Simple RPC Operation

   An FPC Client and Agent directly assigns values such as
   downlink traffic descriptors, QoS information, etc.  A MUST identify themselves using the Client
   Identifier and Agent use the context identifiers to access the descriptors, qos
   information, etc. Identifier respectively to perform modifications.  From ensure that for all
   transactions a recipient of an FPC message can unambiguously identify
   the viewpoint sender of
   packet processing, arriving packets are matched against traffic
   Descriptors and processed according to the qos or other mobility
   profile related Actions specified in the Context's properties.  If
   present, FPC message.

   A Client MAY direct the final action is Agent to use enforce a Context's tunnel information to
   encapsulate and forward the packet.

   A second Context also references context1 rule in the figure.  Based upon
   the technology a property particular DPN
   by including a DPN Key value in a parent context (parent mobility-
   context-id reference) MAY be inherited by its descendants.  This
   permits concise over Mobility Context.  Otherwise the wire representation.  When
   Agent selects a Client deletes suitable DPN to enforce one or more portions of a parent
   Mobility Context all children are also deleted.

5.2.3.  Optimization for Current and Subsequent Messages

5.2.3.1.  Configuration Bundles

   Bundles provide transaction boundaries around work in a single
   message.  Operations in notifies the Client about the selected DPN(s)
   using the DPN Identifier(s).

   All messages sent from a bundle Client to an Agent MUST be successfully executed in acknowledged by
   the
   order specified.  This allows references created in one operation to
   be used in a Agent.  The response must include all edit status as well as
   subsequent operation in edits, which indicates the bundle.

   The example bundle shows in Operation 1 (OP 1) result of processing the creation
   message, as part of the Configure response.  In case the processing
   of the message results in a failure, the Agent sets the global status
   Error-Type and Error-Tag accordingly and MAY clear the entity, e.g.
   Context 1 or Configurable-Policy, which is then referenced caused the failure, in Operation 2 (OP 2) by
   CONTEXT_ID 2. the
   response.

   If OP 1 fails then OP 2 will not be executed.  The
   advantage based upon Agent configuration or the processing of the CONF_BUNDLE is preservation request
   possibly taking a significant amount of dependency orders in time the Agent MAY respond
   with a single message as opposed to sending multiple CONFIG messages and
   awaiting results from Notify-Follows indication with optional Subsequent-Edit(s)
   containing the Agent. partially completed entity modifications.  When a CONF_BUNDLE fails, any entities provisioned in the CURRENT
   operation are removed, however, any successful operations completed
   prior to
   Notify-Follows indication is indicated, the current operation are preserved in order to reduce
   system load.

                                      +-------Router--------+
              +-----------+           |+-------+ +---------+|
              |   FPC     |            | FPC   | |  Anchor |
              |  Client   |            | Agent | |   DPN   |
              +-----------+            +-------+ +---------+
                   |                          |           |
                   |--CONF_BUNDLE(CREATE)---->|           |
                   | [ OP 1,                  |           |
                   |   [ MOBILTY_CONTEXT_ID 1,  |--tun1 up->|
                   | DPNREFLIST:[[DPN1, BOTH  |           |
                   |  DPN_SETTINGS_COMPL:[    |           |
                   |   DOWNLINK(QOS/TUN),     |           |
                   |   UPLINK(QOS/TUN)] ]]    |--tc qos-->|
                   |   CTXT_SETTINGS_COMPL:[  |           |
                   |     IP_PREFIX(HNP) ] ] ],|           |
                   | [ OP 2,                  |           |
                   |   [ MOBILTY_CONTEXT_ID,  |--tun1 up->|
                   | DPNREFLIST:[[DPN1, BOTH  |           |
                   |  DPN_SETTINGS_COMPL:[    |           |
                   |   DOWNLINK(QOS/TUN),     |           |
                   |   UPLINK(QOS/TUN)] ]]    |--tc qos-->|
                   | PARENT_CONTEXT_ID_REF=1  |           |
                   |  ] ]                     |           |
                   |                          |           |

    Figure 20: Exemplary Bundle Message (focus on FPC reference point)

5.2.3.2.  Command Bitsets (Optional)

   Command Sets permit the ability to provide a single, unified data
   structure, e.g.  Mobility-Context, and specify which activities are
   expected to be performed on the DPN.  This has some advantages

   o  Rather than sending N messages with a single operation performed
      on will, upon
   completion or failure of the DPN a single message can be used operation, respond with a Command Set that
      specifies the N DPN operations an asynchronous
   Configuration-Result-Notification to be executed.

   o  Errors become more obvious.  For example, if the HNP is NOT
      provided but the Client.

   A Client did not specify that the HNP should be
      assigned by the Agent this error is easily detected.  Without the
      Command Set the default behavior MAY add a property to a Mobilty-Context without providing
   all required details of the attribute's value.  In such case the
   Agent would be to assign SHOULD determine the HNP missing details and then respond provide the completed
   property description, via Subsequent-Edit(s) back to the Client where Client.  If
   the error would
      be detected and subsequent messaging would be required to remedy processing will take too long or based upon Agent configuration,
   the error.  Such situations can increase Agent MAY respond with an OK for the time to error
      detection Edit that indicates a
   Notify-Follows and overall system load without also includes Subsequent-Edit(s) containing the
   partially completed entity edits.

   In case the Command Set present.

   o  Unambiguous provisioning specification.  The Agent is exactly in
      sync with cannot determine the expectations missing value of an
   attribute's value per the Client as opposed to guessing
      what DPN work could be done based upon data present at Client's request, it leaves the Agent.
      This greatly increases attribute's
   value cleared ]and sets the speed by which Edit Result to Error and provides an
   Error-Type and Error-Tag. As example, the Agent can complete
      work.

   o  Permits different technologies with different instructions Control-Plane needs to be
      supported
   setup a tunnel configuration in FPC.

   As Command Bitsets are technology specific, e.g.  PMIP or 3GPP
   Mobility, the type of work varies Data-Plane but has to rely on the DPN and
   Agent to determine the amount of data
   present in a Context or Port will vary.  Using tunnel endpoint which is associated with the technology
   specific instructions allows
   DPN that supports the Mobility-Context.  The Client to serve multiple
   technologies and MAY result in a more stateless Client as the
   instructions are transferred the Agent which will match adds the desired,
   technology specific instructions with tunnel
   property attribute to the capabilities FPC message and over clears the
   wire protocol value of the DPN more efficiently.

5.2.3.3.  Reference Scope(Optional)

   Although entities MAY refer to any other entity
   attribute (e.g.  IP address of an appropriate
   type, e.g.  Contexts can refer to Policies or other Contexts, the
   Reference Scope gives the local tunnel endpoint).  The Agent an idea of where those references
   reside.  They may be in
   determines the same operation, an operation in tunnel endpoint and includes the same
   CONF_BUNDLE message or completed tunnel
   property in storage.  There may also be no references.
   This permits the Agent its response to understand when it can stop searching for
   reference it cannot find.  For example, if a CONF_BUNDLE message uses the Client in a Reference Scope of type 'op' then it merely needs to keep Subsequent-Edit entry.

   Figure 22 illustrates an
   operation level cache exemplary session life-cycle based on Proxy
   Mobile IPv6 registration via MAG Control-Plane function 1 (MAG-C1)
   and consume no memory or resources searching
   across handover to MAG Control-Plane function 2 (MAG-C2).  Edge DPN1
   represents the many operations in Proxy CoA after attachment, whereas Edge DPN2 serves
   as Proxy CoA after handover.  As exemplary architecture, the CONF_BUNDLE message or FPC
   Agent and the data
   store.

   Agents can also network control function are assumed to be stateless by only supporting the 'none', 'op' and
   'bundle' reference scopes.  This does not imply they lack storage but
   merely co-located
   with the search space they use when looking up references for an
   entity. Anchor-DPN, e.g. a Router.

   The figure below shows Target of the caching hierarchy provided second request uses the Mobility-Context by name.
   Alternatively, the
   Reference Scope

   Caches are temporarily created at each level and as Target could have included the scope
   includes more caches DPN-Key and Policy-
   Key to further reduce the amount of entities that are searched
   increases.  Figure 21 shows an example containment hierarchy provided
   for all caches.

                             +---------------+ information exchnanged.  Setting
   the Target's value to the most specific node SHOULD be followed
   whenever practicle.

                                                 +-------Router--------+
                           +-----------+         |+-------+ +---------+|
   +------+ +------+     +-----+ FPC   | Global Cache          | FPC   |  (storage) |
                             +------+--------+  Anchor |
                                    +----------------------+
   |MAG-C1| |MAG-C2|     |LMA-C| Client|          | Agent |
                             +------+--------+      +------+--------+ | Bundle Cache   DPN   |
   +------+ +------+     +-----+-------+          +-------+ +---------+
   [MN attach]  | Bundle Cache            |                          |   (bundle)           | ....
      |-------------PBU----->|                          |   (bundle)           |
                             +------+--------+      +------+--------+
      |
               +--------------------+--------------------+         |            |---(1)--Configure-------->|           |
      |
      +--------+---------+ +--------+---------+ +--------+---------+         | Operation Cache          "configure" : {              |           | Operation Cache
      |         | Operation Cache           "client-id" : 0,            |           |       (op)
      |         |       (op)           "operation-id" : 0,         |           |       (op)
      |
      +------------------+ +------------------+ +------------------+

                                (no cache)

                  Figure 21: Exemplary Hierarchical Cache

5.2.3.4.  Basename Registry Feature (Optional)

   The Optional BaseName Registry support feature is provided to permit
   Clients and tenants with common scopes, referred to in this
   specification as BaseNames, to track the state of provisioned policy
   information on an Agent.  The registry records the BaseName and
   Checkpoint set by a Client.  If a new Client attaches to the Agent it
   can query the Registry to determine the amount of work that must be
   executed to configure the Agent to a BaseName / checkpoint revision.
   A State value is also provided in the registry to help Clients
   coordinate work on common BaseNames.

6.  Protocol Message Details

6.1.  Data Structures And Type Assignment

   This section provides a type mapping for FPC structures.  When being
   mapped to a specific information such as YANG the data type MAY
   change.

6.1.1.  Policy Structures
   +------------+------------------+-----------------------------------+         | Structure           "edit" : [                  | Field           | Type
      |
   +------------+------------------+-----------------------------------+         | ACTION            "edit-id" : 0,             | ACTION_ID           | FPC-Identity (Section 4.8)
      |         |            "edit-type" : "create",    |           |
      |         | ACTION            "target" : "/mobility-context",        | ACTION_TYPE
      | [32, unsigned integer]         |            "value" : {                            |
      |         |              "mobility-context-key" : "ctxt1",    |
      | ACTION         | ACTION_VALUE              "delegating-ip-prefix" : [ <HNP> ],  | Type specific
      |         |              "dpn" : "[ {                         |
      |         |               "dpn-key" : "DPN1",                 | DESCRIPTOR
      | DESCRIPTOR_ID         | FPC-Identity (Section 4.8)               "service-data-flow" : [
      |         |                 "identifier" : 0,
      |         |                 "flow-settings" : [
      |         | DESCRIPTOR                   ...
      | DESCRIPTOR_TYPE         | [32, unsigned integer]                  {"policy-key" : "dl-tunnel-with-qos",
      |         |                   "qos-template" : <QOS Settings...>,
      |         |                   ...
      |         | DESCRIPTOR                   "tunnel" : <DL tunnel info...> },
      | DESCRIPTOR_VALUE         | Type specific                  {"policy-key" : "ul-tunnel",
      |         |                   ...
      |         |                   "tunnel" : <UL tunnel info...> } ]
      |         | POLICY           ] } ] } ] }                 | POLICY_ID           | FPC-Identity (Section 4.8)
      |         |            |                          |--tun1 up->|
      |         |            | POLICY                          | RULES           | *[ PRECEDENCE RULE_ID ]
      |         |            |                          |--tc qos-->|
      | PRECENDENCE is [32, unsigned         |            |                          |           | integer].  For Rule see Table 4
      |
   +------------+------------------+-----------------------------------+

                          Table 3: Action Fields

   Policies contain a list of Rules by their order value.  Each Rule
   contains Descriptors with optional directionality and Actions with
   order values that specifies action execution ordering if the Rule has
   multiple actions.

   Rules consist of the following fields.

   +------------------+-------------------+----------------------------+         | Field            |<---(2)- Response --------|-route add>|
      | Type         | Sub-Fields            |
   +------------------+-------------------+----------------------------+ {                        | RULE_ID           | FPC-Identity
      |         |            |  "agent-id" : "agent1"," | (Section 4.8)           |
      |         |            |  "operation-id" : 0,     |           |
      | MATCH_TYPE         | ENUMERATION [2,            |  "result-status" : "ok", |           |
      | unsigned bits]         |            |  "edit-status" : [       |           | ('AND' or 'OR')
      |         |            |    "edit-id" : 0,        |           |
      |         | RULE_DESCRIPTORS            | *[ DESCRIPTOR_ID    "edit-status" : "ok"  |           | DIRECTION [2, unsigned
      |         |            | DIRECTION ] }                      | bits] is an ENUMERATION           |
      |         |            | (uplink, downlink or                          |           |
      |<------------PBA------|                          |           | both).
      |         |            |                          |           |
      | RULE_ACTIONS +----+  | *[ ACTION_ID            | ACTION-ORDER [8, unsigned                          |           |
      | ACTION_ORDER ] |Edge|  | integer] specifies action  |
   |                  |                   | execution order.           |
   +------------------+-------------------+----------------------------+

                           Table 4: Rule Fields

6.1.2.  Mobility Structures

   +---------------------------------+---------------------------------+
   | Field                           | Type                            |
   +---------------------------------+---------------------------------+
   | DPN_ID                          | FPC-Identity (Section 4.8)      |
   |                                 |                                 |
   | 1*[ INSTALLED_POLICY_ID         |                                 |
   | POLICY_ID_REFERENCE             |                                 |
   | POLICY_SETTINGS ]               |                                 |
   | DPN_POLICY_SETTINGS            |                          |           |
      |                                 |
   | INSTALLED_POLICY_ID             | FPC-Identity (Section 4.8)      |
   |                                 |                                 |
   | POLICY_ID_REFERENCE             | POLICY_ID                       |
   |                                 |                                 |
   | POLICY_SETTINGS                 | A collection of policy specific |
   |                                 | setings (properties) |DPN1|  |            |                          |           |
      | DPN_POLICY_SETTINGS             | A collection of setings         |
   | +----+  | (properties) that affect            |                          |           | multiple installed policies.
      |
   +---------------------------------+---------------------------------+

                    Table 5: Configurable-Policy Fields

   +-------------------------------------+-----------------------------+   | Field                                                         | Type
      |
   +-------------------------------------+-----------------------------+   |-=======================================================-|
      | MOBILITY_CONTEXT_ID                      | FPC-Identity (Section 4.8)                          |           |
      |   [MN handover]      |                          | DPN_GROUP_ID_REFERENCE           | FPC-Identity (Section 4.8)
      |         |---PBU ---->|                          |           |
      |         | PARENT_MOBILITY_CONTEXT_ID_REFERNCE            |--(3)- CONFIG(MODIFY)---->|           | FPC-Identity (Section 4.8)
      |         |          "configure" : {              |-tun1 mod->|
      |         |           "client-id" : 0,            | DPNS [NOTE 2]           | *[  DPN_REFERENCE ]
      |         |           "operation-id" : 1,         |           |
      | REQUEST_POLICY_REFERENCES         | *           "edit" : [ POLICY_ID ]             |
   |                                     |                             |
   | CONTEXT_SETTINGS_COMPLEMENTARY      | A Collection of Settings    |
   |                                     | (properties).               |
   +-------------------------------------+-----------------------------+

                     Table 6: Mobility Context Fields

   +----------------------------+--------------------------------------+
   | Field                      | Type                                 |
   +----------------------------+--------------------------------------+
   | DPN_ID                     | FPC-Identity (Section 4.8)           |
   |                            |                                      |
   | DIRECTION                  | See Table 4                          |                  |           |
      |         | INTERFACE_ID_REF           | FPC-Identity (Section 4.8)            "edit-id" : 0,             |           |
      |         |            "edit-type" : "merge",     | EMBEDDED_RULES           | *[ EMBEDDED_RULE ]
      |         |            "target" : "/mobility-context/ctxt1",  |
      |         | DPN_SETTINGS_COMPLEMENTARY            "value" : {                | A Collection of Settings           |
      |         | (properties).              "dpn-set" : "[ {                     |
      |         |               "dpn-key" : "DPN1",                 |
      | ASSIGNED_POLICY_REFERENCES         | *               "service-data-flow" : [ POLICY_ID ]                      |
   +----------------------------+--------------------------------------+

                       Table 7: DPN_REFERENCE Fields

   +---------------------------+---------------------------------------+
   | Field                     | Type                                  |
   +---------------------------+---------------------------------------+
   | RULE_ID                   | FPC-Identity (Section 4.8)            |
   |                           |                                       |
      | MATCH_TYPE                | See Table 4                           |
   |                           |                                       |
   | PRECEDENCE                | See Table 3         |                 "identifier" : 0,
      |         |                 "flow-settings" : [
      |         | ACTION_DEFINITION_SET                   ...
      | *[ ACTION_ORDER ACTION_ID ACTION_TYPE         |                  {"policy-key" : "dl-tunnel-with-qos",
      |         | ACTION_VALUE                  "tunnel" : <NEW tunnel info...> } ]
      |         |                           |                                       |
   | DESCRIPTOR_DEFINITION_SET | *[ DESCRIPTOR_ID DESCRIPTOR_TYPE      |
   |                           | DESCRIPTOR_VALUE           } ] } ] }                   |
   +---------------------------+---------------------------------------+

                       Table 8: EMBEDDED_RULE Fields

6.1.2.1.  Monitors
   +---------------------+-------------------------+-------------------+
   | Field               | Type                    | Description       |
   +---------------------+-------------------------+-------------------+
   | MONITOR             | MONITOR_ID DETERRABLE   |                   |
   |                     | TARGET                  |                   |
   |                     | BINDING_INFORMATION     |                   |
   |                     | [REPORT_CONFIG]         |                   |
   |                     |                         |                   |
   | DETERRABLE          | boolean           | Deterrability
      |         |<--PBA------|                          |           |
      | indicator.         |            |                          |-tun1 mod->|
      |         |            |<---(4)- OK --------------|           |
      | BINDING_INFORMATION         | String            | {                        |           |
      |         |            |  "agent-id" : "agent1"," | MONITOR_ID           | FPC-Identity. See
      |         |            |  "operation-id" : 1,     | Section 4.8           |
      |         |            |  "result-status" : "ok", |           |
      | EVENT_TYPE_ID         | [8, Event Type ID]            | Event Type  "edit-status" : [       |           |
      |         | (unsigned            |    "edit-id" : 0,        |           |
      | integer).         |            |    "edit-status" : "ok"  |           |
      |         | TARGET            | OCTET STRING (See ] }                      |           |
      |         | Section 4.7)  +----+    |                          |           |
      |         |  |Edge|    |                          | REPORT_CONFIG           | [8, REPORT-TYPE]
      |         |  |DPN2|    |                          | [TYPE_SPECIFIC_INFO]           |
      |         |  +----+    |                          |           |
      | PERIODIC_CONFIG         | [32, period]    | report interval       |                          |           |
      | (ms).         |    |-============================================-|
      |         |            |                          |           | THRESHOLD_CONFIG    | [32, low] [32, hi]      | thresholds (at    |
   |                     |                         | least one value   |
   |                     |                         | must be present)  |
   |                     |                         |                   |
   | SCHEDULED_CONFIG    | [32, time]              |                   |
   |                     |                         |                   |
   | EVENTS_CONFIG       | *[EVENT_TYPE_ID]        |                   |
   +---------------------+-------------------------+-------------------+

                Table 9: Monitor Structures and Attributes

   TRIGGERS include but are not limited

    Figure 22: Example Message Sequence (focus on FPC reference point)

   After reception of the Proxy Binding Update (PBU) at the LMA Control-
   Plane function (LMA-C), the LMA-C selects a suitable DPN, which
   serves as Data-Plane anchor to the following values:

   o  Events specified mobile node's (MN) traffic.  The
   LMA-C adds a new logical Context to the DPN to treat the MN's traffic
   (1) and includes a Context Identifier (ctxt1) in the Event List Configure
   command.  The LMA-C identifies the selected Anchor DPN by including
   the associated DPN identifier.

   The LMA-C adds policy template properties during the creation of the
   new Mobility-Context.  One policy, "dl-tunnel-with-qos", is an EVENTS CONFIG

   o  LOW_THRESHOLD_CROSSED

   o  HIGH_THRESHOLD_CROSSED
   o  PERIODIC_REPORT

   o  SCHEDULED_REPORT

   o  PROBED

   o  DEREG_FINAL_VALUE

6.1.3.  Message Attributes

6.1.3.1.  Header

   Each operation contains a header
   example template that permits tunnel forwarding of traffic destined
   to the MN's HNP, i.e. downlink traffic, with optional QoS parameters.
   Another policy, "ul-tunnel", provides a simple uplink anchor
   termination template where the following fields:

   +--------------+----------------+-----------------------------------+
   | Field        | Type           | Messages                          |
   +--------------+----------------+-----------------------------------+
   | CLIENT_ID    | FPC-Identity   | All                               |
   |              | (Section 4.8)  |                                   |
   |              |                |                                   |
   | DELAY        | [32, unsigned  | All                               |
   |              | integer]       |                                   |
   |              |                |                                   |
   | OP_ID        | [64, unsigned  | All                               |
   |              | integer]       |                                   |
   |              |                |                                   |
   | OP_REF_SCOPE | [4,            | Values are none(0), op(1),        |
   |              | ENUMERATION]   | bundle(2), storage(3) or          |
   |              |                | unknown(4)                        |
   +--------------+----------------+-----------------------------------+

                      Table 10: Message Header Fields

6.1.3.2.  CONFIG and CONF_BUNDLE Attributes uplink tunnel information is provided.

   The downlink tunnel information specifies the destination endpoint
   (Edge DPN1).

   At reception of the Mobility-Context, the FPC Agent utilizes local
   configuration commands to create the tunnel (tun1) as well as the
   traffic control (tc) to enable QoS differentiation.  After
   configuration has been completed, the Agent applies a new route to
   forward all traffic destined to the MN's HNP specified as a property
   in the Mobility-Context and Notifications
   +--------------------+--------------------+-------------------------+ applied the configured tunnel interface
   (tun1).

   During handover, the LMA-C receives an updating PBU from the handover
   target MAG-C2.  The PBU refers to a new Data-Plane node (Edge DPN2)
   to represent the new tunnel endpoint in the downlink as required.
   The LMA-C sends a Configure message (3) to the Agent to modify the
   existing tunnel property of the existing Mobility-Context and to
   update the downlink tunnel endpoint from Edge DPN1 to Edge DPN2.
   Upon reception of the Configure message, the Agent applies updated
   tunnel property to the local configuration and responds to the Client
   (4).

                                                 +-------Router--------+
                           +-----------+         |+-------+ +---------+|
   +------+ +------+     +-----+ FPC   | Field          | Type FPC   | Operation Types |  Anchor |
   |MAG-C1| |MAG-C2|     |LMA-C| Client|          | Agent | |   DPN   | Create(C), Update(U),
   +------+ +------+     +-----+-------+          +-------+ +---------+

   [MN attach]  |            |                          |           | Query(Q) and Delete(D)
      |-------------PBU----->|                          |
   +--------------------+--------------------+-------------------------+           | OP_TYPE
      | [8, op type]         | CONFIG and CONF_BUNDLE            |---(1)--Configure-------->|           |
      |         |          "configure" : {              |           |
      | COMMAND_SET         | FPC Command           "client-identifier" : 0,    | C,U           |
      |         | Bitset. See           "operation-id" : 3,         |           |
      |         | Section 5.1.1.2.           "edits" : [                 |           |
      |         |            "edit-id" : 0,             |           |
      | INSTALLED_POLICIES         | *[            "edit-type" : "merge",     | C,U           |
      |         | INSTALLED_POLICY ]            "target" : "/mobility-context/ctxt1    |
      |         |                /dpn/DPN1/service-data-flow/0      |
      |         |                /flow-settings/dl-tunnel-with-qos  | MOBILITY-CONTEXTS
      | *[ MOBILITY-         | C,U                /0"                                |
      |         | CONTEXT [            "value" : {                |           |
      |         | COMMAND_SET [NOTE                  "tunnel" : null      |           |
      |         | 1] ]             } ] }                     |           |
      |<------------PBA------|                          |--tun1   ->|
      |         |            |                          |    down   | TARGETS
      | FPC-Identity         | Q,D            |                          |           | (Section 4.8)
      |         |            |<---(2)- Response --------|           |
      | *[DPN_ID]         |            | {                        |           |
      |         |            | POLICIES  "agent-id" : "agent1"," | *[ POLICY ]           | C,U
      |         |            |  "operation-id" : 3,     |           |
      | RULES         | *[ RULE ]            | C,U  "result-status" : "ok", |           |
      |         |            |  "edit-status" : [       | DESCRIPTORS           | *[ DESCRIPTOR ]
      | C,U         |            |    "edit-id" : 0,        |           |
      |         | ACTIONS            | *[ ACTION ]    "edit-status" : "ok"  | C,U           |
   +--------------------+--------------------+-------------------------+

              Table 11: CONFIG and CONF_BUNDLE OP_BODY Fields

   +--------------------+------------------+---------------------------+
      | Field         | Type            | Operation Types ] }                      |           |
      |         | Create(C), Update(U),            |                          |           |
      | Query(Q) and Delete(D)         |
   +--------------------+------------------+---------------------------+  [ MinDelayBeforeBCEDelete expires ]  | OP_ID           | [64, unsigned
      | All         |            |                          | integer]           |
      |         |            |---(3)--Configure-------->|-- tun1 -->|
      |         |          "configure" : {              |  delete   | STATUS
      | [1, Enumerated]         | OK(0) or Error(1)           "client-identifier" : 0,    |           |
      |         |           "operation-id" : 4,         |           | NOTIFY_FOLLOWS
      | boolean         |           "edits" : [                 |           |
      |         |            "edit-id" : 0,             |           | POLICIES
      | *[ POLICY ]         | C,U            "edit-type" : "delete",    |           |
      |         |            "target" : "/mobility-context/ctxt1"   |
      | RULES         | *[ RULE            ] }                        | C,U           |
      |         |            |                          |           | DESCRIPTORS
      | *[ DESCRIPTOR ]         | C,U            |<---(4)- Response --------|           |
      |         |            | {                        |           | ACTIONS
      | *[ ACTION ]         | C,U            |  "agent-id" : "agent1"," |           |
      |         |            | INSTALLED_POLICIES  "operation-id" : 4,     | *[           | C,U [NOTE 1]
      |         |            | INSTALLED_POLICY  "result-status" : "ok", |           |
      |         | ]            |  "edit-status" : [       |           |
      |         |            |    "edit-id" : 0,        | CONTEXTS           | *[ CONTEXT [
      | C,U [NOTE 1]         |            |    "edit-status" : "ok"  | COMMAND_SET           |
      |         |            | [NOTE 1] ] ] }                      |           |
      |         |            |                          |-- route ->|
      |         | TARGETS            | *[ FPC-Identity                          | Q,D [NOTE 1]   remove  |
      |         | (Section 4.8) ]            |                          |           |

   Figure 23: Exemplary Message Sequence (focus on FPC reference point)

   When a teardown of the session occurs, MAG-C1 will send a PBU with a
   lifetime value of zero.  The LMA-C sends a Configure message (1) to
   the Agent to modify the existing tunnel property of the existing
   Mobility-Context to delete the tunnel information.  Upon reception of
   the Configure message, the Agent removes the tunnel configuration and
   responds to the Client (2).  Per [RFC5213], the PBA is sent back
   immediately after the PBA is received.

   If no valid PBA is received after the expiration of the
   MinDelayBeforeBCEDelete timer (see [RFC5213]), the LMA-C will send a
   Configure (3) message with a deletion request for the Context.  Upon
   reception of the message, the Agent deletes the tunnel and route on
   the DPN and responds to the Client (4).

   When a multi-DPN Agent is used the DPN list permits several DPNs to
   be provisioned in a single message for the single Mobility-Conext.

                           +-----------+           +-------+ +---------+
   +------+ +------+     +-----+ FPC   |           | FPC   | | ERROR_TYPE_ID  Anchor | [32, unsigned
   |MAG-C1| |MAG-C2|     |LMA-C| Client|           | All [NOTE 2] Agent | |   DPN1  | integer]
   +------+ +------+     +-----+-------+           +-------+ +---------+
   [MN attach]  |            |                          |           |
      |-------------PBU----->|                          |           |
      | ERROR_TAG         | [1024, octet            |---(1)--Configure-------->|           | All [NOTE 2, 3]
      |         |          "configure" : {              |--tun1 up->|
      | string]         |           "client-identifier" : 0,    |
   +--------------------+------------------+---------------------------+

             Table 12: Immediate Response RESPONSE_BODY Fields

   Notes:

      NOTE 1 - Present in OK and OK with NOTIFY_FOLLOWS for both CONFIG
      and CONF_BUNDLE.  MAY also be present in an CONF_BUNDLE Error
      response (ERR) if one of the operations completed successfully.

      NOTE 2 - Present only for Error (ERR) responses.

      NOTE 3 - Other Error Info (Strings) MAY also be present.

   +-----------------+----------------------+--------------------------+
   | Field           | Type                 | Description              |
   +-----------------+----------------------+--------------------------+           | AGENT_ID
      | FPC-Identity         |                          |
   |                 | (Section 4.8)        |                          |
   |                 |                      |                          |
   | OP_ID           | [64, unsigned        | All         |
   |                 | integer]           "operation-id" : 0,         |           |
      |         |           "edit" : [                  |--tc qos-->|
      |         |            "edit-id" : 0,             | STATUS           | [1, Enumerated]
      | OK(0) or Error(1)         |            "edit-type" : "create",    |           |
      |         |            "target" : "mobility-context",         | NOTIFICATION_ID
      | [32, unsigned         | A Notification            "value" : {                            |
      |         | integer]              "mobility-context-key" : "ctxt1",    | Identifier used to
      |         |              "delegating-ip-prefix" : [ <HNP> ],  |
      | determine notification         |              "dpn" : "[ {                         |
      |         | order.               "dpn-key" : "DPN1",                 |
      |         |               "service-data-flow" : [
      |         |                 "identifier" : 0,
      | TIMESTAMP         | [32, unsigned                 "flow-settings" : [
      | The time that the         |                   ...

      |         | integer]                  {"policy-key" : "dl-tunnel-with-qos",
      | notification occurred.         |                   "qos-template" : <QOS Settings...>,
      |         |                   ...
      |         |                   "tunnel" : <DL tunnel info...> },
      | DATA         | *[ [OP_ID (if                  {"policy-key" : "ul-tunnel",
      |         |                   ...
      |         | CONF_BUNDLE)                   "tunnel" : <UL tunnel info...> } ]
      |         |               "dpn-key" : "DPN2",                 |
      | RESPONSE_BODY (Table |                          |
   |                 | 12) ]         |               "service-data-flow" : [
      |
   +-----------------+----------------------+--------------------------+

      Table 13: CONFIG_RESULT_NOTIFY Asynchronous Notification Fields

6.1.3.3.  Monitors
   +-----------------+---------------------+---------------------------+         | Field                 "identifier" : 0,
      | Type         | Description                 "flow-settings" : [
      |
   +-----------------+---------------------+---------------------------+         | NOTIFICATION_ID                   ...
      | [32, unsiged         |                  {"policy-key" : "dl-tunnel-with-qos",
      |         |                   "qos-template" : <QOS Settings...>,
      | integer]         |                   ...
      |         |                   "tunnel" : <DL tunnel info...> },
      |         |                  {"policy-key" : "ul-tunnel",
      |         | TIMESTAMP                   ...
      | [32, unsigned         |                   "tunnel" : <UL tunnel info...> } ]
      |         |                } ] } ] }              | integer]           |
      |         |            |                          |           |
      | CAUSE         | [32, unsigned            |<---(2)- Response --------|           |
      |         |            | integer] {                        |-route add>|
      |         |            |  "agent-id" : "agent1"," |           |
      |         | NOTIFY            | MONITOR  "operation-id" : 3,     | NOTIFICATION_DATA is the           |
      |         | [NOTIFICATION_DATA]            | value of the monitored  "result-status" : "ok", |           |
      |         | target if this is not ean            |  "notify-follows" : "true",          |
      |         | error.            |
   +-----------------+---------------------+---------------------------+

                      Table 14: Monitor Notifications

7.  Derived and Subtyped Attributes

   This section notes settings and derived attributes.

   +---------------------------+---------------------+-----------------+  "edit-status" : [       | Field           | Type
      | Detail         |
   +---------------------------+---------------------+-----------------+            | TUN_LOCAL_ADDRESS    "edit-id" : 0,        | IP Address           | [NOTE 1]
      |         |            |    "edit-status" : "ok"  |           |
      | TUN_REMOTE_ADDRESS         | IP Address            | [NOTE 1] ] }                      |           |
      |         |            |                          | TUN_MTU           | [32, unsigned
      |<------------PBA------|                          |           |
      |         | integer]            |                          |           |
      | +----+               |                          |           | TUN_PAYLOAD_TYPE
      | [2, bits] |Edge|               | Enumeration: pa                          |           |
      | |DPN2|               | yload_ipv4(0),                          |           |
      | +----+               | payload_ipv6(1)                          |           |
      |   |<---------------------- tun1 up -------------|           | or payload_dual
      |   |<---------------------- tc qos --------------|           |
      |   |<---------------------- route add -----------|           | (2).
      |   |                  |                          |           |
      | TUN_TYPE         | [8, unsigned            |<(3) Configure-Result-    | Enumeration:           |
      |         | integer]            | IP-in-IP(0),       Notification       |           |
      |         | UDP(1), GRE(2)            | {                        |-route add>|
      |         |            | and GTP(3).  "agent-id" : "agent1"," |           |
      |         |            |  "operation-id" : 3,     | TUN_IF           | [16, unsigned
      | Input interface         |            |  "result-status" : "ok", | integer]           | index.
      |         |            |  "notify-follows" : "true",          |
      |         | MOBILITY_SPECIFIC_TUN_PAR            |  "edit-status" : [ IETF_PMIP_MOB_PRO | [NOTE 1]        |
   | AMS                       | FILE |              |                 |
   |                           | 3GPP_MOB_PROFILE ]       |           |
      |         |            |    "edit-id" : 0,        |           | NEXTHOP
      | Varies         | [NOTE 1] See            |    "edit-status" : "ok"  |           |
      | Table 18.         |            | ] }                      |           |
      |         | QOS_PROFILE_PARAMS            | [ 3GPP_QOS                          |           | [NOTE 1]
      |   |                  | PMIP_QOS ]                          |           |
   +---------------------------+---------------------+-----------------+

   NOTE 1 - These parameters are extensible.  The Types may be extended

         Figure 24: Exemplary Message Sequence for Field value by future specifications or in Multi-DPN Agent

   Figure 24 shows how the case first 2 messages in Figure 22 are supported
   when a multi-DPN Agent communicates with both Anchor DPN1 and Edge
   DPN2.  In such a case, the FPC Client sends the downlink and uplink
   for both DPNs in the DPN Reference List of Vendor
                    Specific Attributes by enterprises.

                 Table 15: Context Tunnel the same Mobility-Context.
   Message 1 shows the DPN Set with all entries.  Each entry identifies
   the DPN.

   The Agent responds with an OK and Notify-Follows indication while it
   simultaneoulsy provisions both DPNs.  Upon successful completion, the
   Agent responds to the Client with a Configuration-Result-Notification
   indicating the operation status.

5.2.2.  Policy And QoS Settings

   +-----------+------------------+--------------------+---------------+ Mobility on the Agent

   A Client may build Policy and Topology using Configure messages.

   The Client may add, modify or delete many DPN Policies as DPN Policy
   Expressions and Mobility-Contexts in a single FPC message.  This
   includes linking Mobility-Contexts to DPN Policies as well as
   creating the Policy, Rules Actions and Descriptors.  As example, a
   Rule which performs re-writing of an arriving packet's destination IP
   address from IP_A to IP_B matching an associated Descriptor, can be
   enforced in the Data-Plane via an Agent to implicitly consider
   matching arriving packet's source IP address against IP_B and re-
   write the source IP address to IP_A.

   Figure 25 illustrates the generic policy configuration model as used
   between a FPC Client and a FPC Agent.

            Descriptor_1 -+          +- Action_1
                          | Field          | Type Value
            Descriptor_2 -+--<Rule>--+- Action_2
                            +-----------+
                            /Precendent#/--------+
                            +----------+         | Type
                                                 | Description
            Descriptor_3 -+          +- Action_3 +-<Policy>
                          |          | (Type           |  ^
            Descriptor_4 -+--<Rule>--+- Action_4 |  |
                            +-----------+        |  | Value)
                            /Precendent#/--------+  |
                            +----------+            |
                                                   <DPN-Settings>

            +---------------------+     +----------------------+
            | Bind 1..M traffic   |
   +-----------+------------------+--------------------+---------------+     | TO_PREFIX  Bind 1..N traffic   | [IP Address] [
            | Aggregated or per-  Descriptors to     | FROM_PREFIX --> |  treatment actions   | (0)
            | Prefix Len ]     | host destination   | (1)           |
   |           |                  | IP address/prefix  |               |
   |           |                  | descriptor.        |               |
   |           |                  |                    |               |
   | [IP       | Aggregated or    | TRAFFIC_SELECTOR   | Format per    |
   | Address]  | per-host source  | (2)                | specification |
   | [ Prefix  | IP               |                    | [RFC6088].    |
   | Len ]     | address/prefix   |                    |               |
   |           | descriptor.      |                    |               |
   |           |                  |                    |               |
   | Traffic   |
   | Selector. |
   +-----------+------------------+--------------------+---------------+

                       Table 16: Descriptor Subtypes

   +--------------+-------------------------+--------------------------+
   | Field (Type  | Type  to a Policy and    | Description     |   to a Policy and    | Value)
            | Configurable-Policy |     |
   +--------------+-------------------------+--------------------------+  Configurable-Policy | DROP (0)
            +---------------------+     +----------------------+

           | Empty                                                 | Drop
           +-------------- Data-Plane Rule ------------------+

               Figure 25: Structure of Configurable Policies

   As depicted in Figure 25, the DPN Settings represents the anchor of
   Rules through the Policy / Rule hierarchy.  A Client and Agent use
   the identifier of the associated      |
   |              |                         | packets.                 |
   |              |                         |                          |
   | REWRITE (1)  | [in_src_ip]             | Rewrite IP Address (NAT) |
   |              | [out_src_ip]            | Policy to directly access the Rule
   and perform modifications of traffic Descriptors or IP Address / Port     |
   |              | [in_dst_ip]             | (NAPT).                  |
   |              | [out_dst_ip]            |                          |
   |              | [in_src_port] Action
   references.  Arriving packets are matched against traffic according
   to Rule precedence and Descriptors.  If a Rule is applicable the
   packet is treated according to the ordered Action values.

   A Client associates a Precedence value for the Rule's Descriptors, to
   allow unambiguous traffic matching on the Data-Plane.

   Figure 26 illustrates the generic context configuration model as used
   between a Client and a Agent.

             <Policy 1>
                   ^
                   |
             <Service-Data-Flow 0> <--- <Mobility-Context-ID2>
                                                  ^
                                                  |
             <Policy 1>                           |
             ^                                    | [out_src_port]
             |                                    |
             <Service-Data-Flow 0> <--- <Mobility-Context-ID1>

             +-------------------+     +---------------------+
             | Bind 1..M traffic | [in_dst_port]     |  Bind 1..N traffic  |
             |    selectors to   | [out_dst_port] --> |  treatment / qos    |
             |     a Context     |     |  actions to a       |
             | COPY_FORWARD                   | FPC-Identity. See     | Copy all packets and       Context       |
             +-------------------+     +---------------------+

            | (2)                                                 | Section 4.8.            | forward them
            +-------------- Data-Plane Rule ------------------+

                   Figure 26: Mobility Context Heirarchy

   The figure Figure 26 represents a mobility session hierarchy.  A
   Client and Agent directly assigns values such as downlink traffic
   descriptors, QoS information, etc.  A Client and Agent use the
   context identifiers to access the      |
   |              |                         | provided identity.  The  |
   |              |                         | value descriptors, qos information, etc.
   to perform modifications.  From the viewpoint of packet processing,
   arriving packets are matched against traffic Descriptors and
   processed according to the identity    |
   |              |                         | MUST qos or other mobility profile related
   Actions specified in the Mobilty-Context's and Service-Data-Flow's'
   properties.  If present, a Policy could contain tunnel information to
   encapsulate and forward the packet.

   A second Mobility-Context also references Mobility-Context-ID1 in the
   figure.  Based upon the technology a property in a parent context
   (parent mobility-context-id reference) MAY be inherited by its
   descendants.  This permits concise over the wire representation.
   When a port Client deletes a parent Context all children are also deleted.

6.  Templates And Command Sets

   Configurations templates are shown below.

6.1.  Monitor Configuration Templates

   A periodic configuration specifies a time interval (ms) for
   reporting.

   A scheduled configuration specifies a time for reporting.

   A threshold configuration MUST have at least one hi or        |
   |              |                         | context.                 |
   +--------------+-------------------------+--------------------------+

                         Table 17: Action Subtypes

   +--------------------------------+----------------+-----------------+
   | Field (Type Value)             | Type           | Description     |
   +--------------------------------+----------------+-----------------+
   | IP_ADDR (0)                    | IP Address     | An IP Address.  |
   |                                |                |                 |
   | MAC_ADDR (1)                   | MAC Address    | low threshold
   and MAY have both.

   A MAC Address.  |
   |                                | Target-Events-Configuration is a list of Events that, when
   generated by the Target, results in a Monitor notification.

        |
        +-[Monitor] <List>
        ...
        |         +-[Configuration]
        | SERVICE_PATH_ID (2)         | [24, unsigned     +-[Periodic-Configuration]
        | Service Path         |     |       +-[(Unsigned32) Period:]
        ...
        | integer]         +-[Configuration]
        | Identifier         |     +-[Schedule-Configuration]
        |         |     | (SPI)       +-[(Unsigned32) Schedule:]
        ...
        |         +-[Configuration]
        |         |     +-[Threshold-Configuration]
        |         |     | MPLS_LABEL (3)       +-[(Unsigned32) Low]
        | [20, unsigned         | MPLS Label     |       +-[(Unsigned32) Hi]
        ...
        |                                | integer]         +-[Configuration]
        |         |     +-[Target-Events-Configuration]
        |         |     |       +-[(Unsigned32) Event-Key:] <List>

                Figure 27: Monitor Configuration Templates

6.2.  Descriptor Templates

   A IP-Prefix-Template MUST have at least the To or From IP Prefix /
   Length populated.  The IP Prefix specifies and Address and Length.

   The PMIP Traffic Selector template is mapped according to [RFC6088]

   The RFC 5777 Classifier is a structured version of common filter
   rules and follows the format specified in [RFC5777].  The Flow-Label,
   Flow-Label range and ECN-IP-Codepoint specified in [RFC7660] are
   added to the Descriptor as well.

     |
     +-[ip-prefix-template]
     | NSH (4)       +-[(IP Prefix / Length) To-IP-Prefix]
     | [SERVICE_PATH_       +-[(IP Prefix / Length) From-IP-Prefix]
     ...
     +-[pmip-traffic-selector]
     | See [I-D.ietf-s       +-[(Enumerated - IPv4 or IPv6) ts-format]
     |       +-[ipsec-spi-range]
     |       | ID] [8,   +-[ (ipsec-spi) start-spi: ]
     | fc-nsh]       |   +-[ (ipsec-spi) end-spi ]
     |       +-[source-port-range]
     | unsigned       |   +-[ (port-number) start-port: ]
     |       |   +-[ (port-number) end-port ]
     | integer]       +-[destination-port-range]
     |       |   +-[ (port-number) start-port: ]
     |       |   +-[ (port-number) end-port ]
     |       +-[source-address-range-v4]
     |       | INTERFACE_INDEX (5)   +-[ (ipv4-address) start-address: ]
     | [16, unsigned       | Interface Index   +-[ (ipv4-address) end-address ]
     |       +-[destination-address-range-v4]
     |       | integer]   +-[ (ipv4-address) start-address: ]
     | (an unsigned       |   +-[ (ipv4-address) end-address ]
     |       +-[ds-range]
     |       | integer).   +-[ (dscp) start-ds: ]
     |       |   +-[ (dscp) end-ds ]
     |       +-[protocol-range]
     |       |   +-[ (uint8) start-protocol: ]
     | SEGMENT_ID (6)       | [128, unsigned   +-[ (uint8) end-protocol ]
     | Segement       +-[source-address-range-v6]
     |       |   +-[(ipv6-address) start-address: ]
     | integer]       | Identifier.   +-[(ipv6-address) end-address ]
     |       +-[destination-address-range-v6]
     |       |   +-[(ipv6-address) start-address: ]
     |       |   +-[(ipv6-address) end-address ]
     | MPLS_LABEL_STACK (7)       +-[flow-label-range]
     | 7       | 1*[20 bit   +-[(ipv6-flow-label) start-flow-label ]
     |       |   +-[(ipv6-flow-label) end-flow-label ]
     |       +-[traffic-class-range]
     | labels]       |   +-[ (dscp) start-traffic-class ]
     |       |   +-[ (dscp) end-traffic-class ]
     |       +-[next-header-range]
     |       | MPLS SR Stack. See [I-D.ietf-s   +-[ (uint8) start-next-header ]
     | SRV6_STACK (8)       | 32+ Bytes   +-[ (uint8) end-next-header ]
     ...
     +-[rfc5777-classifier]
     |       +-[Extensible: True]
     | pring-segment-routing-mpls].       +-[(uint8) protocol]
     |       +-[(Enumerated - In/Out/Both) Direction]
     |       +-[From-Spec] <List>
     |       |    +-[(ip-address) IP-Address] <List>
     |       |    +-[IP-Address-Range] <List>
     |       | See [I-D.ietf-6man-segment-rou    |    +-[(ip-address) IP-Address-Start]
     | ting-header].       |
   +--------------------------------+----------------+-----------------+

                        Table 18: Next Hop Subtypes

   +----------+-------+------------------+-----------------------------+    | Field    +-[(ip-address) IP-Address-End]
     | Type       | Type    +-[IP-Address-Mask] <List>
     | Description       |    |    +-[(ip-address) IP-Address:]
     | Value       |    |    +-[(Unsigned 32) IP-Bit-Mask-Width:]
     |
   +----------+-------+------------------+-----------------------------+       | QOS    +-[(mac-address) MAC-Address] <List>
     | 0       | [qos index type]    +-[MAC-Address-Mask] <List>
     | Refers to a single index       |    |    +-[(mac-address) MAC-Address:]
     |       | [index] [DSCP]    | and DSCP to write to the    +-[(mac-address) MAC-Address-Mask-Pattern:]
     |       |    +-[(eui64-address) EUI64-Address] <List>
     |       |    +-[EUI64-Address-Mask] <List>
     | packet.       |    |    +-[(eui64-address) EUI64-Address:]
     |       |    |    +-[(eui64-address) EUI64-Address-Mask-Pattern:]
     |       | GBR    +-[(Integer 32) Port] <List>
     | 1       | [32, unsigned    +-[Port-Range] <List>
     | Guaranteed bit rate.       |    |    +-[(Integer 32) Port-Start]
     |       | integer]    |    +-[(Integer 32) Port-End]
     |       |    +-[(Boolean) Negated]
     |       |    +-[(Boolean) Use-Assigned-Address]
     |       +-[To-Spec] <List> (O)
     |       | MBR    +-[(ip-address) IP-Address] <List>
     | 2       | [32, unsigned    +-[IP-Address-Range] <List>
     | Maximum bit rate.       |    |    +-[(ip-address) IP-Address-Start]
     |       | integer]    |    +-[(ip-address) IP-Address-End]
     |       |    +-[IP-Address-Mask] <List>
     |       |    |    +-[(ip-address) IP-Address:]
     |       | PMIP_QOS    | 3    +-[(Unsigned 32) IP-Bit-Mask-Width:]
     | Varies by Type       | A non-traffic selector PMIP    +-[(mac-address) MAC-Address] <List>
     |       |    +-[MAC-Address-Mask] <List>
     |       |    | QoS Attribute per [RFC7222]    +-[(mac-address) MAC-Address:]
     |
   +----------+-------+------------------+-----------------------------+

                          Table 19: QoS Subtypes

   +----------+---------+----------------+-----------------------------+       | Field    | Type    +-[(mac-address) MAC-Address-Mask-Pattern:]
     | Type       | Description    +-[(eui64-address) EUI64-Address] <List>
     |       |    +-[EUI64-Address-Mask] <List>
     | Value       |    |    +-[(eui64-address) EUI64-Address:]
     |
   +----------+---------+----------------+-----------------------------+       | IPIP_TUN    | 0    +-[(eui64-address) EUI64-Address-Mask-Pattern:]
     |       | IP in IP Configuration    +-[(Integer 32) Port] <List>
     |       |    +-[Port-Range] <List>
     |       |    |    +-[(Integer 32) Port-Start]
     |       | UDP_TUN    | 1    +-[(Integer 32) Port-End]
     | [src_port]       | UDP Tunnel - source and/or    +-[(Boolean) Negated]
     |       |    +-[(Boolean) Use-Assigned-Address]
     |       +-[(dscp) Diffserv-Code-Point] <List>
     | [dst_port]       +-[(Boolean) Fragmentation-Flag ~ False]
     | destination port       +-[IP-Option] <List>
     |       +-[TCP-Option] <List>
     |       +-[TCP-Flags]
     |       +-[ICMP-Type] <List>
     |       +-[ETH-Option] <List>
     |       +-[ecn-ip-codepoint] <List>
     |       +-[(flowlabel) flow-label] <List>
     | GRE_TUN       +-[flow-label-range] <List>
     | 2       | [32, GRE Key]    +-[(flowlabel) flow-label-start]
     | GRE Tunnel.       |
   +----------+---------+----------------+-----------------------------+

                         Table 20:    +-[(flowlabel) flow-label-end]

                      Figure 28: Descriptor Templates

6.3.  Tunnel Subtypes Templates

   The following COMMAND_SET values are supported for IETF_PMIP.

   o  assign-ip - Assign Network Service Header is specified in [RFC8300].

   The MPLS SR Stack is specified in
   [I-D.ietf-spring-segment-routing-mpls].

   The IPv6 SR Stack is specified in
   [I-D.ietf-6man-segment-routing-header].

   A tunnel MUST have the IP Address for local-address or remote-address (or both)
   populated.

   For GRE, the mobile session.

   o  assign-dpn - Assign the Dataplane Node.

   o  session - Assign values for gre-key MUST be present.

   For GTP (GPRS Tunneling Protocol), the Session Level.

   o  uplink - Command applies to uplink.

   o  downlink following attributes MAY be
   present

      local tunnel endpoint identifier (teid) - Command applies to downlink.

7.1.  3GPP Specific Extenstions

   3GPP support MUST be present if
      local-address is optional and detailed in this section.  The following
   acronyms are used:

   APN-AMBR:  Access Point Name Aggregate Maximum Bit Rate

   ARP:  Allocation of Retention Priority

   EBI:  EPS Bearer Identity

   GBR:  Guaranteed Bit Rate

   GTP:  GPRS (General Packet Radio Service) Tunneling Protocol

   IMSI:  International Mobile Subscriber Identity

   MBR:  Maximum Bit Rate

   QCI:  QoS Class Identifier

   TEID:  Tunnel Endpoint Identifier.

   TFT:  Traffic Flow Template (TFT)

   UE-AMBR:  User Equipment Aggregate Maximum Bit Rate

   NOTE: GTP Sequence Number (SEQ_NUMBER) nonempty

      remote tunnel endpoint identifier (teid) - MUST be present if
      remote-address is nonempty

      sequence-numbers-on - Indicates that sequence numbers will be used in failover

   Tunnels can be used as Next Hop and
   handover.

   +-------------+-------+-------------+-------------------------------+
   | Field       | Type  | Namespace / | Type                          |
   |             | Value | Entity      |                               |
   |             |       | Extended    | Descriptor values.

     |
   +-------------+-------+-------------+-------------------------------+
     +-[next-hop-template]
     | GTPV1     +-[Extensible: True]
     | 3     +-[(ip-address) address]
     | Tunnel     +-[(mac-address) mac-address]
     | LOCAL_TEID REMOTE_TEID     +-[(service-path-id) service-path]
     |     +-[(mpls-label) mpls-path]
     |     +-[(network service header) nsh]
     |     +-[(Unsigned Integer) interface]
     |     +-[(Unsigned 128) segment-identifier]
     |     +-[(MPLS Stack) mpls-label-stack]
     | Subtypes     +-[(MPLS SR Stack) mpls-sr-stack]
     | SEQ_NUMBER     +-[(IPv6 SR Stack) srv6-stack]
     |     +-[tunnel-template]
     ...
     |
     +-[tunnel-template]
     |     +-[Extensible: True]
     | namespace.     +-[(address) local-address]
     |     +-[(address) remote-address]
     |     +-[mtu]
     |     +-[(Enumeration - ipv4(0), ipv6(1), dual(2) payload_type:]
     |     +-[(Enumeration - ip-in-ip(0),
                   udp(1), gre(2), gtpv1(3), gtpv2(4)) type:]
     |     +-[interface]
     |     +-[next-hop]
     |     +-[gre-key:] (type == gre)
     |     +-[gtp-info] (type == gtpv1 or type == gtpv2 )
     |     |    +-[(Unsigned 32) local-teid]
     |     | GTPV2    +-[(Unsigned 32) remote-teid]
     | 4     |    +-[(Boolean) sequence-numbers-on] (type == gtpv1)

                        Figure 29: Tunnel Templates

6.4.  Action Templates

   The following figure shows common next-hop (set next-hop) and tunnel
   templates for Actions.

   Drop action has no values.

   Rewrite uses a Descriptor to set the values of the packet.  Exactly
   one Descriptor MUST be present.  Only the Destination and Source port
   fields, if present, are used from the Descriptor.

   Copy-Forward creates a copy of the packet and then forwards it in
   accordance to the nexthop value.

                      | LOCAL_TEID REMOTE_TEID        |
   |             |       | Subtypes    | SEQ_NUMBER                    |
   |             |       | namespace.  |                               |
                      +-[drop-template]
                      ...
                      |
                      +-[rewrite-template]
                      |     +-[Extensible: True]
                      |     +-[ip-prefix-template]
                      |     +-[pmip-traffic-selector]
                      |     +-[rfc5777-classifier]
                      ...
                      | LOCAL_TEID
                      +-[copy-forward-template]
                      | N/A     +-[Extensible: True]
                      | N/A     +-[next-hop:]

                        Figure 30: Action Templates

6.5.  Quality of Service Action Templates

   PMIP QoS is specified in [RFC7222].

        | [32, unisgned integer]
        +-[qos-template]
        |     +-[Extensible: True]
        |     +-[(dscp) trafficclass]
        |     +-[pmip-qos]
        |     |     +-[(Unsigned 32) per-mn-agg-max-dl]
        |     | REMOTE_TEID     +-[(Unsigned 32) per-mn-agg-max-ul]
        | N/A     | N/A     +-[per-session-agg-max-dl]
        | [32, unisgned integer]     |     |    +-[(Unsigned 32) max-rate:]
        |     |     |    +-[(Boolean) service-flag:]
        |     | SEQ_NUMBER     | N/A    +-[(Boolean) exclude-flag:]
        | N/A     | [32, unisgned integer]     +-[per-session-agg-max-ul]
        |     |     |    +-[(Unsigned 32) max-rate:]
        |     |     |    +-[(Boolean) service-flag:]
        | TFT     | 3     | Descriptors    +-[(Boolean) exclude-flag:]
        | Format per TS 24.008 Section     |     +-[allocation-retention-priority]
        |     |     | Subtypes    +-[(Unsigned 8) prioirty-level:]
        | 10.5.6.12.     |     |    +-[(Enumeration) premption-capability:]
        |     | namespace.     |    +-[(Enumeration) premption-vulnerability:]
        |     |     +-[(Unsigned 32) agg-max-dl]
        |     |     +-[(Unsigned 32) agg-max-ul]
        |     |
   | IMSI        | N/A   | Context     | [64, unsigned integer]        |
   |             |       | (new        |                               |
   |             |       | attribute)  |                               |
   |             |       |     +-[(Unsigned 32) gbr-dl]
        |     |     +-[(Unsigned 32) gbr-ul]

                         Figure 31: QoS Templates

6.6.  PMIP Command-Set

   The following Command Set values are supported for IETF PMIP.

   o  assign-ip - Assign the IP Address for the mobile session.

   o  assign-dpn - Assign the Dataplane Node.

   o  session - Assign values for the Session Level.

   o  uplink - Command applies to uplink.

   o  downlink - Command applies to downlink.

6.7.  3GPP Specific Templates and Command-Set

   3GPP support is optional and detailed in this section.  The following
   acronyms are used:

   APN-AMBR:  Access Point Name Aggregate Maximum Bit Rate

   UE-AMBR:  User Equipment Aggregate Maximum Bit Rate

   QCI:  QoS Class Identifier

   EBI:  EPS Bearer Identity

   LBI:  Linked Bearer Identity

   IMSI:  International Mobile Subscriber Identity

   TFT:  Traffic Flow Template (TFT)

   Generally, 3GPP QoS values should use the qos-template.  Note: User
   Equipment Aggregate Maximum Bit Rate (UE-AMBR) maps to the per-mn-
   agg-max-dl and per-mn-agg-max-ul.

                      | EBI
                      +-[ MN-Policy-Template ]
                      | N/A     +-[(Unsigned 64) imsi:]
                      ...
                      +-[tunnel-template]
                      |     +-[Extensible: True]
                      |     +-[(unsigned 4) ebi:]
                      |     +-[(unsigned 4) lbi]
                      ...
                      +-[qos-template]
                      |     +-[Extensible: True]
                      |     +-[(unsigned 4) qos-class-identifier]
                      |     +-[(Unsigned 32) ue-agg-max-bitrate]
                      |     +-[(Unsigned 32) apn-agg-max-bitrate]
                      ...

                    Figure 32: 3GPP Mobility Templates

            | Context
            +-[ packet-filter ]
            | [4, unsigned integer]     +-[Extensible: True]
            |     +-[(Unsigned 8) identifier:]
            |     +-[Contents:] <List>
            |     | (new     +-[(ip-address) ipv4-ipv6-local]
            |     |     +-[(ipv6-prefix) ipv6-prefix-local]
            |     |     +-[(ip-address) ipv4-ipv6-remote]
            | attribute)     |     +-[(ipv6-prefix) ipv6-prefix-remote]
            |     |     +-[(Unsigned 8) protocol-next-header]
            |     |     +-[(Unsigned 16) local-port]
            |     |     +-[local-port-range]
            | 3GPP_QOS     | 4     | QoS      +-[(Unsigned 16) local-port-lo]
            | [8, qci] [32, gbr] [32, mbr]     |     |      +-[(Unsigned 16) local-port-hi]
            |     | Subtypes     +-[(Unsigned 16) remote-port]
            | [32, apn_ambr] [32, ue_ambr]     |     +-[remote-port-range]
            |     |     | namespace.      +-[(Unsigned 16) remote-port-lo]
            | ARP     |     |      +-[(Unsigned 16) remote-port-hi]
            |     |     +-[(Unsigned 32) sec-parameter-index]
            |     |     +-[(dscp) traffic-class]
            | ARP     | N/A     +-[traffic-class-range]
            | N/A     | See Allocation-Retention-     |      +-[(dscp) traffic-class-lo]
            |     |     |      +-[(dscp) traffic-class-hi]
            | Priority from [RFC7222]     |
   +-------------+-------+-------------+-------------------------------+

                 Table 21:     +-[(dscp) flow-label]
            ...

            Figure 33: 3GPP Attributes and Structures Packet Filter Template (Descriptor)

   The following COMMAND_SET Command Set values are supported for 3GPP.

   o  assign-ip - Assign the IP Address for the mobile session.

   o  assign-dpn - Assign the Dataplane Node.

   o  assign-fteid-ip - Assign the Fully Qualified TEID (F-TEID) LOCAL
      IP address.

   o  assign-fteid-teid - Assign the Fully Qualified TEID (F-TEID) LOCAL
      TEID.

   o  session - Assign values for the Session Level.  When this involves
      'assign-fteid-ip' and 'assign-fteid-teid' this implies 'assign-fteid-teid', the values are part of
      the default bearer.

   o  uplink - Command applies to uplink.

   o  downlink - Command applies to downlink.

8.

   o  assign-dpn - Assign the Dataplane Node.

7.  Implementation Status

   Three FPC Agent implementations have been made to date.  The first
   was based upon Version 03 of the draft and followed Model 1.  The
   second follows Version 04 of the document.  Both implementations were
   OpenDaylight plug-ins developed in Java by Sprint.  Version 03 was
   known as fpcagent and version 04's implementation is simply referred
   to as 'fpc'.  A third has been devloped on an ONOS Controller for use
   in MCORD projects.

   fpcagent's intent was to provide a proof of concept for FPC Version
   03 Model 1 in January 2016 and research various errors, corrections
   and optimizations that the Agent could make when supporting multiple
   DPNs.

   As the code developed to support OpenFlow and a proprietary DPN from
   a 3rd party, several of the advantages of a multi-DPN Agent became
   obvious including the use of machine learning to reduce the number of
   Flows and Policy entities placed on the DPN.  This work has driven
   new efforts in the DIME WG, namely Diameter Policy Groups
   [I-D.bertz-dime-policygroups].

   A throughput performance of tens per second using various NetConf
   based solutions in OpenDaylight made fpcagent undesirable for call
   processing.  The RPC implementation improved throughput by an order
   of magnitude but was not useful based upon FPC's Version 03 design
   using two information models.  During this time the features of
   version 04 and its converged model became attractive and the fpcagent
   project was closed in August 2016. fpcagent will no longer be
   developed and will remain a proprietary implementation.

   The learnings of fpcagent has influenced the second project, fpc.
   Fpc is also an OpenDaylight project but is an open source release as
   the Opendaylight FpcAgent plugin (https://wiki.opendaylight.org/view/
   Project_Proposals:FpcAgent).  This project is scoped to be a fully
   compliant FPC Agent that supports multiple DPNs including those that
   communicate via OpenFlow.  The following features present in this
   draft and others developed by the FPC development team have already
   lead
   led to an order of magnitude improvement.

       Migration of non-realtime provisioning of entities such as
       topology and policy allowed the implementation to focus only on
       the rpc.

       Using only 5 messages and 2 notifications has also reduced
       implementation time.

       Command Sets, an optional feature in this specification, have
       eliminated 80% of the time spent determining what needs to be
       done with a Context during a Create or Update operation.

       Op Reference is an optional feature modeled after video delivery.
       It has reduced unnecessary cache lookups.  It also has the
       additional benefit of allowing an Agent to become cacheless and
       effectively act as a FPC protocol adapter remotely with multi-DPN
       support or colocated on the DPN in a single-DPN support model.

       Multi-tenant support allows for Cache searches to be partitioned
       for clustering and performance improvements.  This has not been
       capitalized upon by the current implementation but is part of the
       development roadmap.

       Use of Contexts to pre-provision policy has also eliminated any
       processing of Ports for DPNs which permitted the code for
       CONFIGURE and CONF_BUNDLE to be implemented as a simple nested
       FOR loops (see below).

   Initial v04 performance results without code optimizations or tuning
   allow 2-5K FPC Contexts processed per second on a 2013 Mac laptop.
   This results in 2x the number of transactions on the southbound
   interface to a proprietary DPN API on the same machine.

   Current v04 performance results without code optimizations or tuning
   allow 1-2K FPC Contexts processed per second on a 2013 Mac laptop.
   This results in 2x the number of transactions on the southbound
   interface to a proprietary DPN API on the same machine.

   fpc currently supports the following:

                           1 proprietary DPN API

                           Policy and Topology as defined in this
                           specification using OpenDaylight North Bound
                           Interfaces such as NetConf and RestConf

                           CONFIG and CONF_BUNDLE (all operations)

                           DPN assignment, Tunnel allocations and IPv4
                           address assignment by the Agent or Client.

                           Immediate Response is always an
                           OK_NOTIFY_FOLLOWS.

        assignment system (receives rpc call):
          perform basic operation integrity check
          if CONFIG then
            goto assignments
            if assignments was ok then
              send request to activation system
              respond back to client with assignment data
            else
              send back error
            end if
          else if CONF_BUNDLE then
            for each operation in bundles
            goto assignments
            if assignments was ok then
              hold onto data
            else
              return error with the assignments that occurred in
                prior operations (best effort)
            end if
            end for
            send bundles to activation systems
          end if

        assignments:
          assign DPN, IPv4 Address and/or tunnel info as required
          if an error occurs undo all assignments in this operation
          return result

        activation system:
          build cache according to op-ref and operation type
          for each operation
            for each Context
              for each DPN / direction in Context
                perform actions on DPN according to Command Set
              end for
            end for
          end for
          commit changes to in memory cache
          log transaction for tracking and notification
                                        (CONFIG_RESULT_NOTIFY)

                        Figure 22: 34: fpc pseudo code

   For further information please contact Lyle Bertz who is also a co-
   author of this document.

   NOTE: Tenant support requires binding a Client ID to a Tenant ID (it
   is a one to many relation) but that is outside of the scope of this
   specification.  Otherwise, the specification is complete in terms of
   providing sufficient information to implement an Agent.

9.

8.  Security Considerations

   Detailed protocol implementations for DMM Forwarding Policy
   Configuration must ensure integrity of the information exchanged
   between an FPC Client and an FPC Agent.  Required Security
   Associations may be derived from co-located functions, which utilize
   the FPC Client and FPC Agent respectively.

   The YANG modules defined in this memo is designed to be accessed via
   the NETCONF [RFC6241] or RESTCONF [RFC8040] protocol.  The lowest
   NETCONF layer is the secure transport layer and the mandatory-to-
   implement secure transport is SSH [RFC6242].

   The information model defined in the memo is designed to be access by
   protocols specified in extensions to this document or, if using the
   YANG modules, as described above.

   There are a number of data nodes defined which are
   writable/creatable/deletable.  These data nodes may be considered
   sensitive or vulnerable in some network environments.  Write
   operations (e.g., a NETCONF edit-config) to these data nodes without
   proper protection can have a negative effect on network operations.
   These are the subtrees and data nodes and their sensitivity/
   vulnerability:

      Nodes under the Policy tree provide generic policy enforcement and
      traffic classification.  They can be used to block or permit
      traffic.  If this portion of the model was to be compromised it
      may be used to block, identify or permit traffic that was not
      intended by the Tenant or FPC CLient.

      Nodes under the Topology tree provide defintion definition of the Tenant's
      forwarding topology.  Any compromise of this information will
      provide topology information that could be used for subsequent
      attack vectors.  Removal of topology can limit services.

      Nodes under the Mobility Tree are

      Mobility-Context provides runtime only and manipulated by remote
      procedure calls.  The unwanted deletion or removal of such
      information would deny users service or provide services to
      unauthorized parties.

   Some of the readable data nodes defined may be considered sensitive
   or vulnerable in some network environments.  It is thus important to
   control read access (e.g., via get, get-config, or notification) to
   these data nodes.  These are the subtrees and data nodes and their
   sensitivity/vulnerability:

      IP address assignments in the Context Mobility-Context along with their
      associated tunnel configurations/identifiers (from the FPC base
      module)

      Internaional Mobile Subscriber Identity (IMSI) and bearer
      identifiers in the Context when using the optional 3GPP module FPC base model

   Some of the RPC operations defined may be considered sensitive or
   vulnerable in some network environments.  It is thus important to
   control access to these operations.  These are the operations and
   their sensitivity/vulnerability:

      CONFIG and CONF_BUNDLE send Context

      Configure sends Mobility-Context information which can include
      information of a sensitive or vulnerable nature in some network
      environments as described above.

      Monitor related RPC operations do not specicially provide
      sensitive or vulnerable informaiton information but care must be taken by
      users to avoid identifier values that expose sensitive or
      vulnerable information.

      Notications MUST be treated with same level of protection and
      scrutiny as the operations they correspond to.  For example, a
      CONFIG_RESULT_NOTIFY
      Configure-Result notification provides the same information that
      is sent as part of the input and output of the CONFIG and
      CONF_BUNDLE Configure RPC
      operations.

   General usage of FPC MUST consider the following:

      FPC Naming Section 4.8 4.5 permits arbirtrary string values but a
      users MUST avoid placing sensitive or vulnerable information in
      those values.

      Policies that are very narrow and permit the identification of
      specific traffic, e.g. that of a single user, SHOULD be avoided.

10.

9.  IANA Considerations

   This document registers six URIs in the "IETF XML Registry"
   [RFC3688].  Following the format in RFC 3688, the following
   registrations have been made.

       URI: urn:ietf:params:xml:ns:yang:ietf-dmm-fpc
       Registrant Contact: The DMM WG of the IETF.
       XML: N/A, the requested URI is an XML namespace.

       URI: urn:ietf:params:xml:ns:yang:ietf-dmm-pmip-qos
       Registrant Contact: The DMM WG of the IETF.
       XML: N/A, the requested URI is an XML namespace.

       URI: urn:ietf:params:xml:ns:yang:ietf-dmm-traffic-selector-types
       Registrant Contact: The DMM WG of the IETF.
       XML: N/A, the requested URI is an XML namespace.

       URI: urn:ietf:params:xml:ns:yang:ietf-dmm-fpc-settingsext
       Registrant Contact: The DMM WG of the IETF.
       XML: N/A, the requested URI is an XML namespace.

      URI: urn:ietf:params:xml:ns:yang:ietf-diam-trafficclassifier
      Registrant Contact: The DMM WG of the IETF.
      XML: N/A, the requested URI is an XML namespace.

   This document registers the following YANG modules in the "YANG
   Module Names" registry [RFC6020].

         name:         ietf-dmm-fpc
         namespace:    urn:ietf:params:xml:ns:yang:ietf-dmm-fpc
         prefix:       fpc
         reference:    TBD1

         name:         ietf-dmm-pmip-qos
         namespace:    urn:ietf:params:xml:ns:yang:ietf-dmm-pmip-qos
         prefix:       qos-pmip
         reference:    TBD2

         name:         ietf-dmm-traffic-selector-types
         namespace:    urn:ietf:params:xml:ns:yang:
           ietf-dmm-traffic-selector-types
         prefix:       traffic-selectors
         reference:    TBD3

         name:         ietf-dmm-fpc-settingsext
         namespace:    urn:ietf:params:xml:ns:yang:ietf-dmm-fpc-settingsext    urn:ietf:params:xml:ns:yang:
           ietf-dmm-fpc-settingsext
         prefix:       fpcbase
         reference:    TBD4

11.

           name:         ietf-diam-trafficclassifier
           namespace:    urn:ietf:params:xml:ns:yang:
           ietf-diam-trafficclassifier
           prefix:       diamclassifier
           reference:    TBD5

10.  Work Team Participants

   Participants in the FPSM work team discussion include Satoru
   Matsushima, Danny Moses, Sri Gundavelli, Marco Liebsch, Pierrick
   Seite, Alper Yegin, Carlos Bernardos, Charles Perkins and Fred
   Templin.

12.

11.  References
12.1.

11.1.  Normative References

   [I-D.ietf-6man-segment-routing-header]
              Previdi, S., Filsfils, C., Raza, K., Dukes, D., Leddy, J.,
              Field, B., daniel.voyer@bell.ca, d.,
              daniel.bernier@bell.ca, d., Matsushima, S., Leung, I.,
              Linkova, J., Aries, E., Kosugi, T., Vyncke, E., Lebrun,
              D., Steinberg, D., and R. Raszuk, "IPv6 Segment Routing
              Header (SRH)", draft-ietf-6man-
              segment-routing-header-07 draft-ietf-6man-segment-routing-header-08
              (work in progress), July 2017.

   [I-D.ietf-sfc-nsh]
              Quinn, P., Elzur, U., and C. Pignataro, "Network Service
              Header (NSH)", draft-ietf-sfc-nsh-27 (work in progress),
              October 2017. January 2018.

   [I-D.ietf-spring-segment-routing-mpls]
              Bashandy, A., Filsfils, C., Previdi, S., Bashandy, A., Decraene, B.,
              Litkowski, S., and R. Shakir, "Segment Routing with MPLS
              data plane", draft-ietf-spring-segment-routing-mpls-10 draft-ietf-spring-segment-routing-mpls-12
              (work in progress), June 2017. February 2018.

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119,
              DOI 10.17487/RFC2119, March 1997,
              <https://www.rfc-editor.org/info/rfc2119>.

   [RFC5777]  Korhonen, J., Tschofenig, H., Arumaithurai, M., Jones, M.,
              Ed., and A. Lior, "Traffic Classification and Quality of
              Service (QoS) Attributes for Diameter", RFC 5777,
              DOI 10.17487/RFC5777, February 2010,
              <https://www.rfc-editor.org/info/rfc5777>.

   [RFC6020]  Bjorklund, M., Ed., "YANG - A Data Modeling Language for
              the Network Configuration Protocol (NETCONF)", RFC 6020,
              DOI 10.17487/RFC6020, October 2010,
              <https://www.rfc-editor.org/info/rfc6020>.

   [RFC6088]  Tsirtsis, G., Giarreta, G., Soliman, H., and N. Montavont,
              "Traffic Selectors for Flow Bindings", RFC 6088,
              DOI 10.17487/RFC6088, January 2011,
              <https://www.rfc-editor.org/info/rfc6088>.

   [RFC6991]  Schoenwaelder, J., Ed., "Common YANG Data Types",
              RFC 6991, DOI 10.17487/RFC6991, July 2013,
              <https://www.rfc-editor.org/info/rfc6991>.

   [RFC7333]  Chan, H., Ed., Liu, D., Seite,

   [RFC8300]  Quinn, P., Yokota, H., Ed., Elzur, U., Ed., and J.
              Korhonen, "Requirements for Distributed Mobility
              Management", C. Pignataro, Ed.,
              "Network Service Header (NSH)", RFC 7333, 8300,
              DOI 10.17487/RFC7333, August 2014,
              <https://www.rfc-editor.org/info/rfc7333>.

12.2. 10.17487/RFC8300, January 2018,
              <https://www.rfc-editor.org/info/rfc8300>.

11.2.  Informative References

   [I-D.bertz-dime-policygroups]
              Bertz, L. and M. Bales, "Diameter Policy Groups and Sets",
              draft-bertz-dime-policygroups-04
              draft-bertz-dime-policygroups-05 (work in progress), June
              December 2017.

   [I-D.ietf-dmm-deployment-models]
              Gundavelli, S. and S. Jeon, "DMM Deployment Models and
              Architectural Considerations", draft-ietf-dmm-deployment-
              models-02
              models-03 (work in progress), August November 2017.

   [I-D.ietf-netconf-restconf]
              Bierman, A., Bjorklund, M., and K. Watsen, "RESTCONF
              Protocol", draft-ietf-netconf-restconf-18 (work in
              progress), October 2016.

   [RFC3688]  Mealling, M., "The IETF XML Registry", BCP 81, RFC 3688,
              DOI 10.17487/RFC3688, January 2004,
              <https://www.rfc-editor.org/info/rfc3688>.

   [RFC5213]  Gundavelli, S., Ed., Leung, K., Devarapalli, V.,
              Chowdhury, K., and B. Patil, "Proxy Mobile IPv6",
              RFC 5213, DOI 10.17487/RFC5213, August 2008,
              <https://www.rfc-editor.org/info/rfc5213>.

   [RFC6241]  Enns, R., Ed., Bjorklund, M., Ed., Schoenwaelder, J., Ed.,
              and A. Bierman, Ed., "Network Configuration Protocol
              (NETCONF)", RFC 6241, DOI 10.17487/RFC6241, June 2011,
              <https://www.rfc-editor.org/info/rfc6241>.

   [RFC6242]  Wasserman, M., "Using the NETCONF Protocol over Secure
              Shell (SSH)", RFC 6242, DOI 10.17487/RFC6242, June 2011,
              <https://www.rfc-editor.org/info/rfc6242>.

   [RFC7222]  Liebsch, M., Seite, P., Yokota, H., Korhonen, J., and S.
              Gundavelli, "Quality-of-Service Option for Proxy Mobile
              IPv6", RFC 7222, DOI 10.17487/RFC7222, May 2014,
              <https://www.rfc-editor.org/info/rfc7222>.

   [RFC7333]  Chan, H., Ed., Liu, D., Seite, P., Yokota, H., and J.
              Korhonen, "Requirements for Distributed Mobility
              Management", RFC 7333, DOI 10.17487/RFC7333, August 2014,
              <https://www.rfc-editor.org/info/rfc7333>.

   [RFC7660]  Bertz, L., Manning, S., and B. Hirschman, "Diameter
              Congestion and Filter Attributes", RFC 7660,
              DOI 10.17487/RFC7660, October 2015,
              <https://www.rfc-editor.org/info/rfc7660>.

   [RFC8040]  Bierman, A., Bjorklund, M., and K. Watsen, "RESTCONF
              Protocol", RFC 8040, DOI 10.17487/RFC8040, January 2017,
              <https://www.rfc-editor.org/info/rfc8040>.

   [RFC8072]  Bierman, A., Bjorklund, M., and K. Watsen, "YANG Patch
              Media Type", RFC 8072, DOI 10.17487/RFC8072, February
              2017, <https://www.rfc-editor.org/info/rfc8072>.

Appendix A.  YANG Data Model for the FPC protocol

   These modules define YANG definitions.  When

   This section provides a type mapping from the for FPC
   model was performed U-Key values, ACTION_TYPES and DESCRIPTOR_TYPES structures in YANG.
   When being mapped to a specific information such as well YANG the data
   type MAY change.

   L-Keys for Actions, Descriptors, Rules, Policies, DPNs, Domains and
   Mobility-Contexts are specified as many enumerations were FPC-Identity which follows rules
   according to Section 4.5.

   Action and Descriptor Templates are mapped as choices.  This was done
   to identity types.
   ACTION_TYPES ensure no duplication of Types and DESCRIPTOR_TYPES avoid use of identityref for
   typing.

   Policy Expressions are also optional provided as the type can default values.  NOTE that a
   static value CANNOT be inferred from the value.  Four supported in YANG.

   Five modules are defined:

   o  ietf-dmm-fpc (fpc) - Defines the base model and messages for FPC
      that are meant to be static in FPC.

   o  ietf-dmm-fpc-settingsext An FPC module that defines the
      information model elements that are likely to be extended in FPC.

   o  ietf-pmip-qos (pmip-qos) - Defines proxy mobile IPv6 QoS
      parameters per RFC 7222

   o  ietf-trafficselectors-types (traffic-selectors) - Defines Traffic
      Selectors per RFC 6088 [RFC6088]

   o  ietf-diam-trafficclassifier (diamclassifier) - Defines the
      Classifier per [RFC5777]

A.1.  FPC YANG Model

   This module defines the information model and protocol elements
   specified in this document.

   This module references [RFC6991], [RFC8040] and the fpc-settingsext
   module defined in this document.

   <CODE BEGINS> file "ietf-dmm-fpc@2017-09-27.yang" "ietf-dmm-fpc@2018-02-28.yang"
   module ietf-dmm-fpc {
     yang-version 1.1;
       namespace "urn:ietf:params:xml:ns:yang:ietf-dmm-fpc";
       prefix fpc;

       import ietf-inet-types { prefix inet;
           revision-date 2013-07-15; }
       import ietf-restconf ietf-dmm-fpc-settingsext { prefix restconf; fpcbase;
           revision-date 2018-02-28; }
       import ietf-diam-trafficclassifier { prefix rfc5777;
           revision-date 2018-02-28; }
       import ietf-restconf { prefix rc;
           revision-date 2017-01-26; }
       import ietf-dmm-fpc-settingsext ietf-yang-patch { prefix fpcbase; ypatch;
           revision-date 2017-09-27; 2017-02-22; }

       organization "IETF Distributed Mobility Management (DMM)
         Working Group";

       contact
          "WG Web:   <http://tools.ietf.org/wg/netmod/>
           WG List:  <mailto:netmod@ietf.org>

           WG Chair: Dapeng Liu
                     <mailto:maxpassion@gmail.com>

           WG Chair: Jouni Korhonen
                     <mailto:jouni.nospam@gmail.com> Sri Gundavelli
                     <mailto:sgundave@cisco.com>

           Editor:   Satoru Matsushima
                     <mailto:satoru.matsushima@g.softbank.co.jp>

           Editor:   Lyle Bertz
                     <mailto:lylebe551144@gmail.com>";

       description
       "This module contains YANG definition for
        Forwarding Policy Configuration Protocol (FPCP).

        Copyright (c) 2016 IETF Trust and the persons identified as the
        document authors. All rights reserved.

        This document is subject to BCP 78 and the IETF Trust's Legal
        Provisions Relating to IETF Documents
        (http://trustee.ietf.org/license-info) in effect on the date of
        publication of this document. Please review these documents
        carefully, as they describe your rights and restrictions with
        respect to this document. Code Components extracted from this
        document must include Simplified BSD License text as described
        in Section 4.e of the Trust Legal Provisions and are provided
        without warranty as described in the Simplified BSD License.";

       revision 2017-09-27 2018-02-28 {
       description "Version 10 updates.";
       reference "draft-ietf-dmm-fpc-cpdp-10";
     }
       revision 2017-09-27 {
       description "Version 10 updates.";
       reference "draft-ietf-dmm-fpc-cpdp-09";
     }
   revision 2017-07-22 {
       description "Version 08 updates.";
       reference "draft-ietf-dmm-fpc-cpdp-08";
   }
   revision 2017-03-08 {
       description "Version 06 updates.";
       reference "draft-ietf-dmm-fpc-cpdp-06";
   }
   revision 2016-08-03 {
       description "Initial Revision.";
       reference "draft-ietf-dmm-fpc-cpdp-05";
   }
       feature fpc-basename-registry

       //General Structures
       grouping templatedef {
           leaf extensible {
               type boolean;
               description "Ability to track Base Names already provisioned
           on "Indicates if the Agent"; template is
                   extensible";
           }
       feature fpc-bundles
           leaf-list mandatory-static-attributes {
               type string;
               description "Ability "Attribute (Name) that cannot change.
                   If it has not been defined in the template it
                   MUST NOT be present at all for Client to send multiple bundles of
           actions the template
                   to an Agent"; be valid.";
           }
       feature fpc-auto-binding
           leaf entity-state {
               type enumeration {
                   enum initial {
                       description "Allows a FPC Agent to advertise Topology Objects
           that could be DPNs"; "Inital Configuration";
                   }
       feature operation-ref-scope
                   enum partially-configured {
                       description "Provides the scope of refeneces in an operation.
           Used to optmize the Agent processing."; "Partial Configuration";
                   }
                   enum configured {
                       description "Confgured";
                   }
                   enum active {
                       description "Active";
                   }
               }
               default initial;
               description "Entity State";
           }
           description "Teamplate Definition";
       }

     //General Structures
       typedef fpc-identity {
           type union {
               type uint32;
               type string;
               type instance-identifier;
           }
           description "FPC Identity";
       }
       grouping target-value index {
           leaf target index {
               type fpc-identity;
         mandatory true; uint16;
               description "Target Identity"; "Index";
           }
           description "FPC Target "Index Value";
       }

       // Topology
     typedef fpc-interface-id {
           type fpc:fpc-identity;
           description "DPN interface Identifier";
     }
       identity interface-protocols {
           description "Protocol supported by the interface";
       }
       identity features {
           description "Protocol features";
       }
     // Settings
     grouping settings {
       container settings-set {
         uses fpcbase:fpc-settings;
         description "Settings";
       }
       description "Settings container";
     }
     //Topology - Groupings
     grouping interface-settings {
       container interface-settings-set {
         description "Interface settings";
       }
       description "Generic interface settings container";
     } Policy Structures
       grouping access-technology-key descriptor-template-key {
           leaf access-technology descriptor-template-key {
               type identityref {
           base "fpcbase:access-technology";
         } fpc:fpc-identity;
               mandatory true;
               description "Access Technology"; "Descriptor Key";
           }
           description "Access Technology key"; "Descriptor-Template Key";
       }
       grouping role-key action-template-key {
           leaf role action-template-key {
               type identityref {
           base "fpcbase:role";
         } fpc:fpc-identity;
               mandatory true;
               description "Access Technology Role"; "Action Key";
           }
           description "Access Technology Role key"; "Action-Template Key";
       }
       grouping interface-id-key rule-template-key {
           leaf interface-id rule-template-key {
               type fpc:fpc-interface-id; fpc:fpc-identity;
               mandatory true;
               description "interface identifier"; "Rule Identifier";
           }
           description "Interface Identifier key"; "Rule Key";
       }
       grouping dpn-identifier-key policy-template-key {
           leaf dpn-id policy-template-key {
               type fpc:fpc-identity;
               mandatory true;
               description "DPN Identifier Type"; "Rule Identifier";
           }
           description "DPN Identifier key"; "Rule Key";
       }

       // Settings
       grouping dpn-interface-reference {
       uses fpc:access-technology-key;
       uses fpc:role-key;
       uses fpc:interface-id-key;
       description "A reference to a DPN interface";
     }
     // Topology Grouping
     grouping fpc-topology policy-configuration {
           list dpn-set policy-configuration {
               key dpn-id;
         uses fpc:dpn-identifier-key; index;
               leaf dpn-name index {
                   type string; uint16;
                   description "DPN name"; "Index used for reference";
               }
         leaf dpn-resource-mapping-reference
               choice policy-setting {
           type string;
                   case descriptor-value {
                       uses fpcbase:fpc-descriptor-value;
                       description "Reference to underlying DPN resource(s)"; "Descriptor Value";
                   }
         list interface-set
                   case action-value {
           key "access-technology role interface-id";
                       uses fpc:dpn-interface-reference;
           uses fpc:interface-settings; fpcbase:fpc-action-value;
                       description "DPN interfaces"; "Action Value";
                   }
                   description "Set of DPNs"; "Policy Attributes";
               }
               description "Policy Configuration";
           }
           description "Policy Configuration Value";
       }

       // FPC Policy
       grouping policy-information-model {
         list dpn-type-set action-template {
           key "access-technology role"; action-template-key;
           uses fpc:access-technology-key;
         leaf access-technology-name {
           type string; fpc:action-template-key;
           uses fpcbase:fpc-action-value;
           uses fpc:templatedef;
           description "Access Technology Name"; "Action Template";
         }
         uses fpc:role-key;
         leaf role-name
         list descriptor-template {
           type string;
           key descriptor-template-key;
           uses fpc:descriptor-template-key;
           uses fpcbase:fpc-descriptor-value;
           uses fpc:templatedef;
           description "Access Technology Role Name"; "Descriptor Template";
         }
         list interface-set rule-template {
           key interface-id; rule-template-key;
           uses fpc:interface-id-key; fpc:rule-template-key;
           leaf interface-name descriptor-match-type {
               type string;
             description "DPN-Type Interface Name";
           }
           leaf-list interface-protocol-set enumeration {
             type identityref
                   enum or {
               base "interface-protocols";
             }
                       value 0;
                       description "Supported protocols"; "OR logic";
                   }
           leaf-list feature-set {
             type identityref
                   enum and {
               base "interface-protocols";
             }
                       value 1;
                       description "Supported features"; "AND logic";
                   }
           uses fpc:interface-settings;
           description "A DPN interface types";
               }
               default "and";
               description "Set "Type of DPN types"; Match (OR or AND)
                applied to the descriptor-configurations";
           }
           list dpn-group-set descriptor-configuration {
               key "dpn-group-id"; "descriptor-template-key";
               uses fpc:descriptor-template-key;
               leaf dpn-group-id direction {
                   type fpc:fpc-identity;
           mandatory true; rfc5777:direction-type;
                   description "DPN Group Identifier"; "Direction";
               }
               list referenced-dpns-set attribute-expression {
                   key "access-technology role interface-id"; index;
                   uses fpc:dpn-interface-reference;
           leaf-list supporting-dpn-id-set {
             type fpc:fpc-identity;
             description "DPNs that suppport this group";
           }
           leaf-list dpn-group-peer-id-set {
             type fpc:fpc-identity; fpc:index;
                   uses fpcbase:fpc-descriptor-value;
                   description "DPN Peer Groups reference"; "Descriptor Attributes";
               }
               description "A list set of DPNs supporting a group
             by DPN Type"; Descriptor references";
           }
           list dpn-group-peer-set action-configuration {
               key remote-dpn-group-id; "action-order";
               leaf remote-dpn-group-id action-order {
                   type fpc:fpc-identity; uint32;
                   mandatory true;
                   description "Remote DPN Group identifier"; "Action Execution Order";
               }
               uses fpc:interface-settings;
           description "Locally applied settings used for
             the referenced DPN-Group (peer group).";
         }
         leaf domain-id fpc:action-template-key;
               list attribute-expression {
           type fpc:fpc-identity;
                   key index;
                   uses fpc:index;
                   uses fpcbase:fpc-action-value;
                   description "Domain Identiifer"; "Action Attributes";
               }
               description "List "A set of DPN groups"; Action references";
           }
           uses fpc:templatedef;
           uses fpc:policy-configuration;
           description "Rule Template";
         }
         list domain-set policy-template {
           key policy-template-key;
           uses fpc:policy-template-key;
           list rule-template {
               key domain-id; "precedence";
               unique "rule-template-key";
               leaf domain-id precedence {
                   type fpc:fpc-identity; uint32;
                   mandatory true;
                   description "Domain Identifier"; "Rule Precedence";
               }
         leaf domain-name {
           type string;
               uses fpc:rule-template-key;
               description "Domain displayname";
         }
         leaf domain-reference {
           type string;
           description "Reference to domain resources"; "Rule Entry";
           }
           uses fpc:templatedef;
           uses fpc:policy-configuration;
           description "List of Domains"; "Policy Template";
         }
         description "FPC Topology grouping";
     }
     // Policy Structures Structures";
       }

       // Descriptor Structure Topology Information Model
       identity fpc-descriptor-type role {
           description "A traffic descriptor"; "Role";
       }
       grouping descriptor-definition dpn-key {
           leaf descriptor-id dpn-key {
               type fpc:fpc-identity;
               mandatory true;
               description "Descriptor Id"; "DPN Key";

           }
           description "DPN Key";
       }
       grouping role-key {
           leaf descriptor-type role-key {
               type identityref {
                   base "fpc-descriptor-type";
               }
               description "Descriptor Type Value"; "fpc:role";
               }
       uses fpcbase:fpc-descriptor-value;
               mandatory true;
               description "FPC Descriptor Definition"; "Access Technology Role";
           }
       // Action Structure
       identity fpc-action-type {
           description "Action Type"; "Access Technology Role key";
       }
       grouping action-definition interface-key {
           leaf action-id { interface-key{
               type fpc:fpc-identity;
               mandatory true;
               description "Action Identifier";
           }
           leaf action-type {
               type identityref {
                 base "fpc-action-type";
               }
               description "Action Type"; "interface identifier";
           }
           uses fpcbase:fpc-action-value;
           description "FPC Action Definition"; "Interface Identifier key";
       }
       // Rule Structure
       typedef fpc-direction-type {
          type enumeration {
            enum uplink
       identity interface-protocols {
           description "uplink"; "Protocol supported by the interface";
       }
            enum downlink
       identity features {
           description "Downlink"; "Protocol features";
       }
            enum both

     // Settings
     grouping interface-settings {
       list interface-settings {
           key policy-template-key;
           uses fpc:policy-template-key;
           uses fpc:policy-configuration;
           description "Both";
           } "Interface settings";
       }
       description "FPC Direction"; "Generic interface settings container";
     }

     // Mobility Context
     grouping fpc-rule-id mobility-context {
       leaf rule-id mobility-context-key {
         type fpc:fpc-identity;
         mandatory true;
         description "Rule Identifier"; "Mobility Context Key";
       }
       leaf-list delegating-ip-prefix {
           type inet:ip-prefix;
           description "FPC Rule-Id key"; "IP Prefix";
       }
       grouping match-type {
       leaf descriptor-match-type parent-context {
         type enumeration {
               enum or {
                 value 0; fpc:fpc-identity;
         description "OR logic"; "Parent Mobility Context";
       }
               enum and
       leaf-list child-context {
                 value 1;
                 description "AND logic";
               }
             }
             mandatory true;
             description "Type of Match (OR or AND) applied to the
               descriptor-reference-set.";
         }
           type fpc:fpc-identity;
           description "Map Type Grouping"; "Child Mobility Context";
       }
       grouping fpc-action-order
       container mobile-node {
           leaf action-order
           leaf-list ip-address {
               type uint32;
               mandatory true; inet:ip-address;
               description "Action Execution Order"; "IP Address";
           }
           leaf imsi {
               type fpcbase:imsi-type;
               description "Action Order Leaf"; "IMSI";
           }
       grouping rule-definition
           list mn-settings {
               key policy-template-key;
               uses fpc:fpc-rule-id; fpc:policy-template-key;
               uses fpc:match-type;
           list descriptor-reference-set fpc:policy-configuration;
               description "MN Policy Cofiguration";
           }
           description "Mobile Node";
       }
       container domain {
             key "descriptor-id-reference";
           leaf descriptor-id-reference domain-key {
               type fpc:fpc-identity;
                 mandatory true;
               description "Descriptor Id Reference"; "Domain Key";
           }
             leaf direction
           list domain-settings {
                 type fpc:fpc-direction-type;
               key policy-template-key;
               uses fpc:policy-template-key;
               uses fpc:policy-configuration;
               description "Direction"; "MN Policy Cofiguration";
           }
           description "A set of Descriptor references"; "Domain";
       }
       list action-reference-set dpn {
           key "action-order"; dpn-key;
           uses fpc:fpc-action-order;
             leaf action-id-reference fpc:dpn-key;
           list dpn-settings {
         type fpc:fpc-identity;
         mandatory true;
         description "Action Identifier Reference";
             }
             description "A set of Action references";
           }
               key policy-template-key;
               uses fpc:policy-template-key;
               uses fpc:policy-configuration;
               description
             "Rule.Definition";
       }
       // "DPN Policy Structures
       grouping fpc-precedence { Cofiguration";

           }
           leaf precedence role {
               type uint32;
         mandatory true;
         description "Rule Precedence"; identityref {
                   base "fpc:role";
               }
               description "FPC Rule Precedence"; "Role";
           }
       grouping policy
           list service-data-flow {
               key identifier;
               leaf policy-id identifier {
                   type fpc:fpc-identity; uint32;
                   description "Policy "Generic Identifier";
               }
           list rule-set {
               key "precedence";
               unique "rule-id-reference";
               uses fpc:fpc-precedence;
               leaf rule-id-reference service-group-key {
                   type fpc:fpc-identity;
                   mandatory true;
                   description "Rule Identifier";
               }
               description "Rule Entry";
           }
                   description "FPC Policy"; "Service Group Key";
               }
       // FPC Policy
     grouping fpc-policy {
               list action-definition-set interface {
                   key action-id; interface-key;
                   uses fpc:action-definition; fpc:interface-key;
                   description "List of Actions"; "interface assigned";
               }
               list descriptor-definition-set flow-settings {
                   key descriptor-id; policy-template-key;
                   uses fpc:policy-template-key;
                   uses fpc:descriptor-definition; fpc:policy-configuration;
                   description "List of Descriptors"; "Flow Policy Cofiguration";
               }
       list rule-definition-set {
         key rule-id;
         uses fpc:rule-definition;
               description "List of Rules"; "Service Dataflow";
           }
       list policy-definition-set {
         key policy-id;
         uses fpc:policy;
           description "List of Policies"; "DPN";
       }
       description "FPC Policy Structures"; "Mobility Context";
     }

     // Mobility Structures
     grouping configurable-policy-set {
       list installed-policy-list {
         key dpn-id-reference;
         leaf dpn-id-reference Events, Probes & Notifications
     identity event-type {
           type fpc:fpc-identity;
       description "Installed Policy identifier"; "Base Event Type";
     }
         list installed-policy-set {
           key installed-policy-id;
           leaf installed-policy-id
     typedef event-type-id {
       type fpc:fpc-identity; uint32;
       description "Installed Policy Identifier"; "Event ID Type";
     }
     grouping monitor-key {
       leaf policy-id-reference monitor-key {
         type fpc:fpc-identity;
         mandatory true;
         description "Installed Policy Identifier";
           }
           container policy-settings {
             uses fpcbase:fpc-settings;
             description "Policy Settings"; "Monitor Key";

       }
       description "Policy installed upon a DPN"; "Monitor Id";
     }
     grouping target-value {
       leaf target {
           type string;
           description "Configurable Policy";
         uses fpc:settings; "target";
       }
       description "List of installed DPN policies and settings"; "Target Value";
     }
       // Dynamic Policy
     grouping mobility-context monitor-config {
       leaf mobility-context-id
       uses fpc:templatedef;
       uses fpc:monitor-key;
       uses fpc:target-value;
       container binding-information {
         type fpc:fpc-identity;
         mandatory true;
           description "Mobility Context Identifier"; "Placeholder for information helpful
               to binding the monitor ot the correct target";
       }
       leaf dpn-group-id-reference deterrable {
         type fpc:fpc-identity; boolean;
         description "Group ID used when DPN selecitons were
           made"; "Indicates reports related to this
           config can be delayed.";
       }
       choice configuration {
         mandatory true;
         leaf parent-mobility-context-id-reference period {
             type fpc:fpc-identity; uint32;
             description "Parent Mobility Context"; "Period";
         }
       list dpn-reference-list
         case threshold-config {
         key "dpn-id-reference direction";
           leaf dpn-id-reference low {
             type fpc:fpc-identity;
           mandatory true; uint32;
             description "DPN Id reference"; "low threshold";
           }
           leaf direction hi {
             type fpc:fpc-direction-type;
           mandatory true; uint32;
             description "Direction of DPN assignment"; "high threshold";
           }
         container dpn-settings-complementary {
           uses fpcbase:fpc-settings;
           description "Complentary Settings"; "Threshold Config Case";
         }
         leaf interface-id-reference {
           type fpc:fpc-interface-id;
           mandatory true;
           description "referenced interface";
         }
         list embedded-rule-set {
           key "precedence";
           unique "rule-id";
           uses fpc:fpc-rule-id;
           uses fpc:match-type;
           uses fpc:fpc-precedence;
           list action-definition-set {
             key "action-order";
             uses fpc:fpc-action-order;
             uses fpc:action-definition;
             description "List of Actions";
           }
           list descriptor-definition-set {
             key descriptor-id;
             uses fpc:descriptor-definition;
             description "List of Descriptors";
           }
           description "List of FPC Embedded Rule Definitions";
         }
         leaf-list assigned-policy-reference-set schedule {
             type fpc:fpc-identity;
           description "List of Policies request to be enforced for
             this Mobility Context";
         } uint32;
             description "DPN List"; "Reporting Time";
         }
         leaf-list requested-policy-reference-set event-identities {
             type fpc:fpc-identity;
         description "List of Policies request to be enforced for
           this Mobility Context";
       }
       container context-settings-complementary identityref {
         uses fpcbase:fpc-settings;
         description "Context Settings";
       }
       description "Mobility Context";
               base "fpc:event-type";
             }
       // Events, Probes & Notifications
     identity event-type {
             description "Base Event Type"; "Event Identities";
         }
     typedef event-type-id
         leaf-list event-ids {
             type uint32;
               description "Event ID Type"; IDs";
         }
     grouping monitor-id {
       leaf monitor-id {
         type fpc:fpc-identity;
         mandatory true;
         description "Monitor Identifier"; "Event Config Value";
       }
       description "Monitor Id"; Configuration";
     }
       grouping monitor-config

     // Top Level Structures
     list tenant {
           uses fpc:monitor-id;
      key "tenant-key";
      leaf deterrable tenant-key {
           type boolean; fpc:fpc-identity;
           description "Indicates reports related to this
           config can be delayed."; "Tenant Key";
      }
      container binding-information {
         description "Placeholder for information helpful
           to binding the monitor ot the correct target";
       }
       uses fpc:target-value;
       choice configuration mobility-information-model {
         mandatory true;
         case periodic-config
       list dpn {
         key dpn-key;
         uses fpc:dpn-key;
         leaf period dpn-name {
           type uint32;
             description "Period";
           } string;
           description "Periodic Config Case"; "DPN name";
         }
         case threshold-config {
         leaf lo-thresh dpn-resource-mapping-reference {
           type uint32; string;
           description "lo threshold"; "Reference to underlying
               DPN resource(s)";
         }
           leaf hi-thresh
         leaf-list domain-key {
           type uint32; fpc:fpc-identity;
           description "hi threshold"; "Domains";
         }
         leaf-list service-group-key {
           type fpc:fpc-identity;
           description "Threshold Config Case"; "Service Group";
         }
         case scheduled-config
         list interface {
           key "interface-key";
           uses fpc:interface-key;
           leaf report-time interface-name {
               type uint32;
             description "Reporting Time";
           } string;
               description "Scheduled Config Case"; "Interface Name";
           }
         case events-config-ident {
           leaf-list event-identities roles {
               type identityref {
                   base "fpc:event-type";
             }
             description "Event Identities"; "fpc:role";
               }
               description "Events Config Identities Case"; "Roles supported";
           }
         case events-config {
           leaf-list event-ids protocol {
               type uint32;
               description "Event IDs"; identityref {
                    base "interface-protocols";
               }
               description "Events Config Case"; "Supported protocols";
           }
           uses fpc:interface-settings;
           description "Event Config Value"; "DPN interfaces";
         }
         list dpn-settings {
           key policy-template-key;
           uses fpc:policy-template-key;
           uses fpc:policy-configuration;
           description "Monitor "DPN Policy Configuration";
         }
       grouping report
         description "Set of DPNs";
       }
       description "Mobility Information Model";
      }
      container dpn-checkpoint {
           uses fpc:monitor-config;
         choice report-value fpc:basename-info;
           description "DPN Checkpoint information";
      }
      list service-group {
           key service-group-key;
           leaf trigger service-group-key {
               type fpc:event-type-id; fpc:fpc-identity;
               mandatory true;
               description "Trigger Identifier"; "Service Group Key";
           }
           case simple-empty {
           leaf nothing service-group-name {
               type empty;
               description "Empty Value";
             } string;
               description "Empty Case"; "Service Group Name";
           }
           case simple-val32
           list dpn {
             leaf val32
               key "dpn-key role-key";
               uses fpc:dpn-key;
               uses fpc:role-key;
               list referenced-interface {
                   key interface-key;
                   uses fpc:interface-key;
                   leaf-list peer-service-group-key {
                       type uint32; fpc:fpc-identity;
                       description "Unsigned 32 bit value"; "Peer Service Group";

                   }
                   description "Simple Value Case"; "Referenced Interface";
               }
           case list-simple-val32 {
               leaf-list  val32-list {
                 type uint32;
               description "Unsigned 32 bit value"; "DPN";
           }
           list service-settings {
               key policy-template-key;
               uses fpc:policy-template-key;
               uses fpc:policy-configuration;
               description "Simple Value Case"; "Service Configuration";
           }
           description "Report Value"; "Service Group";
      }
      container service-group-checkpoint {
           uses fpc:basename-info;
           description "Monitor Report"; "Service Group Checkpoint
               information";
      }
       typedef agent-identifier
      container topology-information-model {
       list service-endpoint {
         key role-key;
         uses fpc:role-key;
         leaf role-name {
           type fpc:fpc-identity; string;
           description "Agent Identifier"; "Role Name";
         }
       typedef client-identifier
         leaf-list service-group-key {
           type fpc:fpc-identity;
           description "Client Identifier"; "Service Group";
         }
       grouping basename-info
         list interface {
             leaf basename
           key "dpn-key interface-key";
           uses fpc:dpn-key;
           uses fpc:interface-key;
           leaf-list protocol {
             type fpc:fpc-identity; identityref {
               base "interface-protocols";
             }
             description "Rules Basename"; "Supported protocols";
           }
             leaf base-state
           leaf-list feature {
             type string; identityref {
               base "interface-protocols";
             }
             description "Current State"; "Supported features";
           }
             leaf base-checkpoint {
               type string;
           uses fpc:interface-settings;
           description "Checkpoint"; "A DPN interface types";

         }
         description "Basename Information"; "Set of DPN types";
       }
       // Top Level Structures
     container tenants {
       list tenant domain {
         key "tenant-id"; domain-key;
         leaf tenant-id domain-key {
           type fpc:fpc-identity;
           mandatory true;
           description "Tenant ID"; "Domain Key";
         }
             container mobility
         leaf domain-name {
              container topology
           type string;
           description "Domain displayname";
         }
         list domain-settings {
           key policy-template-key;
           uses fpc:fpc-topology; fpc:policy-template-key;
           uses fpc:basename-info {
                  if-feature fpc:fpc-basename-registry; fpc:policy-configuration;
           description "Domain Cofiguration";
         }
         description "Topology"; "List of Domains";
       }
       uses fpc:basename-info;
       description "FPC Topology grouping";
      }
      container policy policy-information-model {
           uses fpc:fpc-policy; fpc:policy-information-model;
           uses fpc:basename-info {
                  if-feature fpc:fpc-basename-registry;

                } fpc:basename-info;
           description "Policy";
      }
               uses fpc:configurable-policy-set;
      list mobility-context-set mobility-context {
           key "mobility-context-id";
                   config false; "mobility-context-key";
           uses fpc:mobility-context;
           description "Mobility Context Set"; Context";
      }
      list monitor-set monitor {
           key monitor-id; monitor-key;
           uses fpc:monitor-config;
           description "Monitor Configurations";
               }
               description "Mobility Elements"; "Monitor";
      }
      description "Tenant";
     }
       description "Tenant List";
     }
       // RPC
       // RPC Specific Structures

       typedef op-identifier agent-identifier {
           type uint64; fpc:fpc-identity;
           description "Operation "Agent Identifier";
       }
       typedef ref-scope client-identifier {
           type enumeration {
           enum none {
             value 0; fpc:fpc-identity;
           description "no references"; "Client Identifier";
       }
       grouping basename-info {
             leaf basename {
               type fpc:fpc-identity;
               description "Rules Basename";
             }
             leaf base-checkpoint {
               type string;
               description "Checkpoint";
             }
             description "Basename Information";
       }

       // RPCs
       grouping client-id {
           leaf client-id {
               type fpc:client-identifier;
               mandatory true;
               description "Client Id";
           }
           description "Client Identifier";
       }
       grouping execution-delay {
           leaf execution-delay {
               type uint32;
               description "Execution Delay (ms)";
           }
           description "Execution Delay";
       }
       typedef ref-scope {
         type enumeration {
           enum none {
             value 0;
             description "no references";
           }
           enum op {
             value 1;
             description "All references are intra-operation";
           }
           enum bundle {
             value 2;
             description "All references in exist in bundle";
           }
           enum storage {
             value 3;
             description "One or more references exist in
               storage.";
           }
           enum unknown {
             value 4;
             description "The location of the references
               are unknown.";
           }
         }
         description "Search scope for references in
           the operation.";
       }
       grouping context-operation
       rpc configure {
           description "Configure RPC";
           input {
               uses fpc:mobility-context; client-id;
               uses fpcbase:instructions;
         description "Context Operation"; execution-delay;
               uses ypatch:yang-patch;
           }
       grouping payload
           output {
               uses fpc:configurable-policy-set;
       list mobility-context-set ypatch:yang-patch-status;
           }
       }
       augment "/configure/input/yang-patch/edit" {
           key "mobility-context-id";
           uses fpc:mobility-context;
           leaf op-ref-scope {
               type fpc:ref-scope;
               description "Mobility Context Set"; "Reference Scope";
           }
           uses fpc:fpc-policy; fpcbase:instructions;
           description "Payload"; "yang-patch edit augments for
               configure rpc";
       }
       grouping op-header subsequent-edits {
       leaf client-id
            list subsequent-edit {
         type fpc:client-identifier;
         mandatory true;
              key edit-id;
              ordered-by user;

              description "Client ID";
       } "Edit list";

              leaf delay edit-id {
                type uint32; string;
                description "Operation Delay (ms)"; "Arbitrary string index
                   for the edit.";
              }

              leaf op-id operation {
                type op-identifier;
         mandatory true; enumeration {
                  enum create {
                    description "Operation Identifier"; "Create";

                  }
                  enum delete {
                    description "Common Operation header"; "Delete";
                  }
     grouping fpc-op-type {
       leaf op-type {
         type enumeration
                  enum insert {
                    description "Insert";
                  }
                  enum create merge {
             value 0;
                    description "create"; "Merge";
                  }
                  enum update move {
             value 1;
                    description "update"; "Move";
                  }
                  enum query replace {
             value 2;
                    description "query"; "Replace";
                  }
                  enum delete remove {
             value 3;
                    description "delete";
                      "Delete the target node if it currently
                           exists.";
                  }
                }
                mandatory true;
                description "Type";
       }
       description "FPC Operation Type";
                  "The datastore operation requested";
              }
     grouping fpc-op-ref-scope {

              leaf op-ref-scope target {
         if-feature operation-ref-scope;
                type fpc:ref-scope;
         description "Reference Scope";
       } ypatch:target-resource-offset;
                mandatory true;
                description "FPC OP-REF Scope";
                  "Identifies the target data node";
              }
     grouping op-input {
       uses fpc:fpc-op-ref-scope;
       uses fpcbase:instructions;
       choice op_body {
         case create_or_update
              leaf point {
           uses fpc:payload;
           description "Create/Update input";
         }
         case delete_or_query
               when "(../operation = 'insert' or ../operation = 'move')"
                + "and (../where = 'before' or ../where = 'after')" {
           uses fpc:target-value;
                  description "Delete/Query input";
                    "This leaf only applies for 'insert' or 'move'
                     operations, before or after an existing entry.";
               }
                type ypatch:target-resource-offset;
                description "Opeartion Input value";
                  "The absolute URL path for the data node";
              }

              leaf where {
               when "../operation = 'insert' or ../operation = 'move'" {
                  description "Operation Input";
                    "This leaf only applies for 'insert' or 'move'
                     operations.";
                }
     typedef result-status {
                type enumeration {
                  enum ok before {
           value 0;
                    description "OK";
         }
                      "Insert or move a data node before.";
                  }
                  enum err after {
           value 1;
                    description "Error";
         }
                      "Insert or move a data node after.";
                  }
                 enum first {
                    description "Result Status";
                      "Insert or move a data node so it becomes ordered
                       as the first entry.";
                  }
     grouping status-value {
       leaf op-id
                  enum last {
         type op-identifier;
         mandatory true;
                    description "Operation Identifier";
                      "Insert or move a data node so it becomes ordered
                       as the last entry.";
                  }
       leaf status
                }
                default last;
                description
                  "Identifies where a data resource will be inserted
                   or moved.";
              }

              anydata value {
                when "../operation = 'create' "
                   + "or ../operation = 'merge' "
                   + "or ../operation = 'replace' "
                   + "or ../operation = 'insert'" {
         type result-status;
         mandatory true;
                  description "Status";
                    "The anydata 'value' is only used for 'create',
                     'merge', 'replace', and 'insert' operations.";
                }
                description "Status value
                  "Value used for all messages"; this edit operation.";
              }
            }
     grouping result {
       uses fpc:status-value;
       uses fpc:result-body;
            description "General Result grouping"; "Subsequent Edits";
       }
     grouping result-body
       augment "/configure/output/yang-patch-status/edit-status/edit/"
           + "edit-status-choice/ok" {
           leaf notify-follows {
               type boolean;
               description "Indicates that a notification will
           follow regarding this result"; "Notify Follows Indication";
           }
       choice result-type {
         case err {
           uses restconf:errors; fpc:subsequent-edits;
           description "Error Information"; "Configure output augments";
       }
         case create-or-update-success

       grouping op-header {
           uses fpc:payload;
           description "Create/Update Success";
         }
         case delete_or_query-success { client-id;
           uses fpc:target-value;
           description "Delete/Query Success";
         }
         case empty-case execution-delay;
           leaf op-id {
               type uint64;
               mandatory true;
               description "Empty Case";
         }
         description "Result Value"; "Operation Identifier";
           }
           description "Common Result member body";
     }
     // Common RPCs
     rpc configure {
       description "CONF message";
       input {
         uses fpc:op-header;
         uses fpc:fpc-op-type;
         uses fpc:op-input;
       }
       output {
         uses fpc:result;
       } Operation header";
       }
     rpc configure-bundles {
       if-feature fpc:fpc-bundles;
       description "CONF_BUNDLES message";
       input {
         uses fpc:op-header;
         uses fpc:fpc-op-type;
         uses fpc:fpc-op-ref-scope;
         list bundles
       grouping monitor-response {
           key op-id;
           leaf op-id {
               type op-identifier; uint64;
               mandatory true;
               description "Operation Identifier";
           }
           uses fpc:op-input;
           choice edit-status-choice {
                  description "List
                    "A choice between different types of operations";
         }
       }
       output status
                     responses for each 'edit' entry.";
                  leaf ok {
         uses fpc:status-value;
         list bundles
                    type empty;
                    description
                      "This 'edit' entry was invoked without any
                       errors detected by the server associated
                       with this edit.";
                  }
                  case errors {
           key op-id;
                    uses fpc:result; rc:errors;
                    description "Operation Identifier";
                      "The server detected errors associated with the
                       edit identified by the same 'edit-id' value.";
                  }
           }
           description "Monitor Response";
       }

     // Common RPCs
     rpc reg_monitor {
       description "Used to register monitoring of parameters/events";
       input {
         uses fpc:op-header;
         list monitors {
           key monitor-key;
           uses fpc:monitor-config;
           description "Monitor Configuration";
         }
       }
       output {
           uses fpc:status-value;
         uses restconf:errors; fpc:monitor-response;
       }
     }
     rpc dereg_monitor {
       description "Used to de-register monitoring of
         parameters/events";
       input {
         uses fpc:op-header;
         leaf-list monitor-set
         list monitor {
           type fpc:fpc-identity;
           key monitor-key;
           uses fpc:monitor-key;
           min-elements 1;
           description "Monitor Identifier";
         }
           leaf send_data {
               type boolean;
               description "Indicates if NOTIFY with final data
                   is desired upon deregistration";
           }
           description "Monitor Identifier";
         }
       }
       output {
           uses fpc:status-value;
         uses restconf:errors; fpc:monitor-response;
       }
     }
     rpc probe {
       description "Probe the status of a registered monitor";
       input {
         uses fpc:op-header;
         list monitor {
           key monitor-key;
           uses fpc:monitor-id; fpc:monitor-key;
           min-elements 1;
           description "Monitor";
         }
       }
       output {
           uses fpc:status-value;
         uses restconf:errors; fpc:monitor-response;
       }
     }

     // Notification Messages & Structures
     grouping notification-header {
       leaf notification-id
     notification config-result-notification {
         type uint32;
       uses ypatch:yang-patch-status;
       description "Notification Identifier"; "Configuration Result Notification";
     }
       leaf timestamp
     augment "/config-result-notification" {
         type uint32;
           uses fpc:subsequent-edits;
           description "timestamp"; "config-result-notificatio augment";
     }

     identity notification-cause {
       description "Notification Header"; Cause";
     }
     notification config-result-notification {
       uses fpc:notification-header;
       uses fpc:status-value;
       choice value {
         case config-result
     identity subscribed-event-occured {
           uses result-body;
       base "notification-cause";
       description "CONF Result"; "Subscribed Event Occurence";
     }
         case config-bundle-result {
           list bundles
     identity low-threshold-crossed {
             key op-id;
             uses fpc:result;
       base "notification-cause";
       description "Operation Identifier"; "Subscribed Event Occurence";
     }
     identity high-threshold-crossed {
       base "notification-cause";
       description "CONF_BUNDLES Result"; "Subscribed Event Occurence";
     }
     identity periodic-report {
       base "notification-cause";
       description "Config Result value"; "Periodic Report";
     }
     identity scheduled-report {
       base "notification-cause";
       description "CONF/CONF_BUNDLES Async Result"; "Scheduled Report";
     }
     identity notification-cause probe {
       base "notification-cause";
       description "Notification Cause"; "Probe";
     }
     identity dpn-availabilty-change deregistration-final-value {
       base "notification-cause";
       description "DPN Candidate/Exisitng DPN Availablity Change"; "Probe";
     }
     identity monitoring-suspension {
       base "notification-cause";
       description "Indicates monitoring suspension";
     }
     identity monitoring-resumption {
       base "notification-cause";
       description "Indicates that monitoring has resumed";
     }
     identity monitor-notification dpn-available {
       base "notification-cause";
       description "Indicates 1+ monitor reports"; "DPN Candidate Available";
     }
     identity dpn-unavailable {
       base "notification-cause";
       description "DPN Unavailable";
     }
     notification notify {
       leaf notification-id {
         type uint32;
         description "Notification Identifier";
       }
       leaf timestamp {
         type uint32;
         description "timestamp";
       }
       list report {
           key monitor-key;
           uses fpc:notification-header; fpc:monitor-key;
           min-elements 1;
           leaf cause trigger {
               type identityref {
                   base "notification-cause";
               }
               description "Notification Cause";
           }
           choice value {
               case dpn-candidate-available {
           if-feature fpc:fpc-auto-binding;
                   leaf node-id {
                       type inet:uri;
                       description "Topology URI";
                   }
                   list supported-interface-list {
                       key "access-technology role";
             uses fpc:access-technology-key; role-key;
                       uses fpc:role-key;
                       description "Support Intefaces";
                   }
                   description "DPN Candidate Information";
               }
               case dpn-unavailable {
                   leaf dpn-id {
                       type fpc:fpc-identity;
                       description "DPN Identifier"; Identifier for DPN Unavailable";
                   }
                   description "DPN Unavailable";
               }
         case monitor-notification {
           list reports
               anydata report-value {
             uses fpc:report;
                   description "Reports"; "Any non integer report";
               }
               description "Monitor Notification"; "Report Value";
           }
           description "Notify Value"; "Report";
       }
       description "Notify Message";
     }
   }
   <CODE ENDS>

A.2.  YANG Models

A.2.1.  FPC YANG Settings and Extensions Model

   This module defines the base data elements in FPC that are likely to
   be extended.

   This module references [RFC6991], ietf-trafficselector-types and
   ietf-pmip-qos modules.

   <CODE BEGINS> file "ietf-dmm-fpc-settingsext@2017-09-27.yang" "ietf-dmm-fpc-settingsext@2018-02-28.yang"
   module ietf-dmm-fpc-settingsext {
     yang-version 1.1;
     namespace "urn:ietf:params:xml:ns:yang:ietf-dmm-fpc-settingsext";
     prefix fpcbase;

       import ietf-inet-types { prefix inet;
           revision-date 2013-07-15; }
       import ietf-trafficselector-types { prefix traffic-selectors;
           revision-date 2017-10-29; 2018-02-28; }
       import ietf-yang-types { prefix ytypes;
           revision-date 2013-07-15; }
       import ietf-pmip-qos { prefix pmipqos;
           revision-date 2016-02-10; 2018-02-28; }
       import ietf-diam-trafficclassifier { prefix rfc5777;
           revision-date 2018-02-28; }

       organization "IETF Distributed Mobility Management (DMM)
         Working Group";

       contact
          "WG Web:   <http://tools.ietf.org/wg/netmod/>
           WG List:  <mailto:netmod@ietf.org>

           WG Chair: Dapeng Liu
                     <mailto:maxpassion@gmail.com>

           WG Chair: Jouni Korhonen
                     <mailto:jouni.nospam@gmail.com> Sri Gundavelli
                     <mailto:sgundave@cisco.com>

           Editor:   Satoru Matsushima
                     <mailto:satoru.matsushima@g.softbank.co.jp>

           Editor:   Lyle Bertz
                     <mailto:lylebe551144@gmail.com>";

       description
       "This module contains YANG definition for
        Forwarding Policy Configuration Protocol(FPCP).

         It contains Settings defintions as well as Descriptor and
         Action extensions.

        Copyright (c) 2016 IETF Trust and the persons identified as the
        document authors. All rights reserved.

        This document is subject to BCP 78 and the IETF Trust's Legal
        Provisions Relating to IETF Documents
        (http://trustee.ietf.org/license-info) in effect on the date of
        publication of this document. Please review these documents
        carefully, as they describe your rights and restrictions with
        respect to this document. Code Components extracted from this
        document must include Simplified BSD License text as described
        in Section 4.e of the Trust Legal Provisions and are provided
        without warranty as described in the Simplified BSD License.";

   revision 2018-02-28 {
       description "Version updates.";
       reference "draft-ietf-dmm-fpc-cpdp-10";
   }
   revision 2017-09-27 {
       description "Version 10 updates.";
       reference "draft-ietf-dmm-fpc-cpdp-10";
   }
   revision 2017-07-22 {
       description "Version 08 updates.";
       reference "draft-ietf-dmm-fpc-cpdp-08";
   }
   revision 2017-03-08 {
       description "Version 06 updates.";
       reference "draft-ietf-dmm-fpc-cpdp-06";
   }
   revision 2016-08-03 {
       description "Initial Revision.";
       reference "draft-ietf-dmm-fpc-cpdp-05";

   }

       // Next Hop Structures - SETTING
       typedef fpc-service-path-id {
           type uint32

       //Tunnel Information
        identity tunnel-type {
               range "0..33554431";
           }
             description "SERVICE_PATH_ID"; "Tunnel Type";
         }
       typedef fpc-mpls-label {
           type uint32
         identity grev1 {
             range "0..1048575";
           }
             base "fpcbase:tunnel-type";
             description "MPLS label"; "GRE v1";
         }
         identity fpc-nexthop-type grev2 {
             base "fpcbase:tunnel-type";
             description "NAT Service"; "GRE v2";
         }

       grouping fpc-nexthop {
           leaf nexthop-type
         identity ipinip {
               type identityref
             base "fpcbase:tunnel-type";
             description "IP in IP";
         }
         identity gtpv1 {
             base "fpcbase:fpc-nexthop-type"; "fpcbase:tunnel-type";
             description "GTP version 1 Tunnel";
         }
               mandatory true;
         identity gtpv2 {
             base "fpcbase:tunnel-type";
             description "Nexthop Type"; "GTP version 2 Tunnel";
         }
           choice nexthop-value

       grouping tunnel-value {
                 mandatory true;
               case ip-nexthop
         container tunnel-info {
           leaf ip tunnel-local-address {
               type inet:ip-address;
               description "IP Value";
                   }
                   description "IP Case"; "local tunnel address";
           }
               case macaddress-nexthop {
           leaf macaddress tunnel-remote-address {
               type ytypes:mac-address; inet:ip-address;
               description "MAC Address Value";
                   } "remote tunnel address";
           }
               case servicepath-nexthop {
           leaf servicepath mtu-size {
               type fpcbase:fpc-service-path-id; uint32;
               description "Service Path Value"; "MTU size";
           }
                   description "Service Path Case";
               }
               case mplslabel-nexthop {
           leaf lsp tunnel {
               type fpcbase:fpc-mpls-label;
                       description "MPLS Value"; identityref {
                   base "fpcbase:tunnel-type";
               }
           description "Service Path Case"; "tunnel type";
           }
               case if-nexthop {
           leaf if-index payload-type {
               type uint16; enumeration {
                   enum ipv4 {
                       value 0;
                       description "If (interface) Value"; "IPv4";
                   }
                   enum ipv6 {
                       value 1;
                       description "Service Path Case"; "IPv6";
                   }
                   enum dual {
                       value 2;
                       description "Value"; "IPv4 and IPv6";
                   }
               }
               description "Nexthop Value"; "Payload Type";
           }

       // Address Translation - ACTION
       grouping simple-nat {
           leaf outbound-nat-address gre-key {
               type inet:ip-address;
           description "Outbound NAT Address";
         } uint32;
               description "Simple NAT value"; "GRE_KEY";
           }
       grouping simple-napt
           container gtp-tunnel-info {
               leaf source-port local-tunnel-identifier {
                   type inet:port-number; uint32;
                   description "Source Port"; "Tunnel Endpoint IDentifier (TEID)";
               }
               leaf outbound-napt-address remote-tunnel-identifier {
                   type inet:ip-address; uint32;
                   description "Outbound NAPT Address"; "Tunnel Endpoint IDentifier (TEID)";
               }
               leaf destination-port sequence-numbers-enabled {
                   type inet:port-number;
           description "Destination Port";
         }
         description "Simple NAPT Configuration";
       }

       // COPY FORWARD - ACTION
       grouping copy-forward {
         container destination {
           choice value {
             case nexthop-case {
         container nexthop {
                 uses fpcbase:fpc-nexthop;
                 description "Next Hop";
             }
               description "Port Forward Case";
             }
             description "Copy Forward Value";
           }
           description "destination";
         } boolean;
                   description "Copy Then Forward to Port/Context Action"; "Sequence No. Enabled";
               }

       //////////////////////////////
       // PMIP Integration         //
         identity pmip-tunnel-type {
               description "PMIP "GTP Tunnel Type";
         }
         identity grev1 {
             base "pmip-tunnel-type";
             description "GRE v1";
         }
         identity grev2 {
             base "pmip-tunnel-type";
             description "GRE v2";
         }
         identity ipinip {
             base "pmip-tunnel-type";
             description "IP in IP"; Information";
           }
         grouping pmip-tunnel-info {
           leaf pmip-tunnel-type ebi {
               type identityref {
                     base "pmip-tunnel-type";
                 } fpcbase:ebi-type;
               description "PMIP Mobility"; "EPS Bearier Identifier";
           }
             choice pmip-tunnel-value {
                 case gre {
           leaf gre-key lbi {
               type uint32;
                         description "GRE_KEY";
                     } fpcbase:ebi-type;
               description "GRE Value"; "Linked Bearier Identifier";
           }
           description "PMIP Mobility value"; "Tunnel Information";
         }
             uses traffic-selectors:traffic-selector;
         description "PMIP Tunnel Information"; "Tunnel Value";
       }

     //////////////////////////////
     // DESCRIPTOR DEFINITIONS

       // From 3GPP TS 24.008 version 13.5.0 Release 13
         typedef pmip-commandset packet-filter-direction {
             type bits enumeration {
                   bit assign-ip
               enum preRel7Tft {
                     position
                 value 0;
                 description "Assign IP"; "Pre-Release 7 TFT";
               }
                   bit assign-dpn
               enum uplink {
                     position
                 value 1;
                 description "Assign DPN"; "uplink";
               }
                   bit session
               enum downlink {
                     position
                 value 2;
                 description "Session Level"; "downlink";
               }
                   bit uplink
               enum bidirectional {
                     position
                 value 3;
                 description "Uplink"; "bi-direcitonal";
               }
             }
                   bit downlink {
                     position 4;
             description "Downlink";
                   }
               }
               description "PMIP Instructions";
           }
       ///////////////////////////////
       // 3GPP Integration         //
     //    Tunnel Types
         identity threeGPP-tunnel-type {
             description "3GPP Base Tunnel Type";
         }
         identity gtpv1 {
             base "fpcbase:threeGPP-tunnel-type";
             description "GTP version 1 Tunnel";
         }
         identity gtpv2 {
             base "fpcbase:threeGPP-tunnel-type";
             description "GTP version 2 Tunnel"; "Packet Filter Direction";
         }
         // QoS Profile
         typedef fpc-qos-class-identifier component-type-id {
             type uint8 {
               range "1..9"; "16 | 17 | 32 | 33 | 35 | 48 | 64 | 65 |"
               + " 80 | 81 | 96 | 112 | 128";
             }
             description "QoS Class Identifier (QCI)"; "Specifies the Component Type";
         }
         grouping threeGPP-QoS packet-filter {
             description "3GPP QoS Attributes";
           leaf qci direction {
               type fpc-qos-class-identifier; fpcbase:packet-filter-direction;
               description "QCI"; "Filter Direction";
           }
           leaf gbr identifier {
               type uint32;
                 description "Guaranteed Bit Rate";
             }
             leaf mbr uint8 {
                 type uint32;
                 description "Maximum Bit Rate";
                 range "1..15";
               }
             leaf apn-ambr {
                 type uint32;
               description "Access Point Name Aggregate Max Bit Rate"; "Filter Identifier";
           }
           leaf ue-ambr evaluation-precedence {
               type uint32; uint8;
               description "User Equipment Aggregate Max Bit Rate"; "Evaluation Precedence";
           }
             container arp
           list contents {
                 uses pmipqos:Allocation-Retention-Priority-Value;
             key component-type-identifier;
             description "Allocation Retention Priority";
             }
         }
         typedef ebi-type "Filter Contents";
             leaf component-type-identifier {
                 type uint8 {
             range "0..15";
           } fpcbase:component-type-id;
                 description "EUTRAN Bearere Identifier (EBI) "Component Type";
             }

        // From 3GPP TS 24.008 version 13.5.0 Release 13
        typedef component-type-enum {
             type enumeration {
                 enum ipv4RemoteAddress {
             choice value 16;
                   description "IPv4 Remote Address";
                 }
                 enum ipv4LocalAddress {
                   value 17;
               leaf ipv4-local {
                   type inet:ipv4-address;
                   description "IPv4 Local Address";
               }
                 enum ipv6RemoteAddress
               leaf ipv6-prefix-local {
                   value 32;
                   type inet:ipv6-prefix;
                   description "IPv6 Remote Address"; Local Prefix";
               }
                 enum ipv6RemoteAddressPrefix
               leaf ipv4-ipv6-remote {
                   value 33;
                   type inet:ip-address;
                   description "IPv6 Remote Address Prefix"; "Ipv4 Ipv6 remote address";
               }
                 enum ipv6LocalAddressPrefix
               leaf ipv6-prefix-remote {
                   value 35;
                   type inet:ipv6-prefix;
                   description "IPv6 Local Address Remote Prefix";
               }
                 enum protocolNextHeader
               leaf next-header {
                   value 48;
                   type uint8;
                   description "Protocol (IPv4) or NextHeader (IPv6)
                     value"; "Next Header";
               }
                 enum localPort
               leaf local-port {
                   value 64;
                   type inet:port-number;
                   description "Local Port";
               }
                 enum localPortRange
               case local-port-range {
                   value 65;
                 leaf local-port-lo {
                   type inet:port-number;
                   description "Local Port Range"; Min Value";
                 }
                 enum reomotePort
                 leaf local-port-hi {
                   value 80;
                   type inet:port-number;
                   description "Remote Port"; "Local Port Max Value";
                 }
                 enum remotePortRange
               }
               leaf remote-port {
                   value 81;
                   type inet:port-number;
                   description "Remote Port Range"; Port";
               }
                 enum secParamIndex
               case remote-port-range {
                   value 96;
                   description "Security Parameter Index (SPI)";
                 }
                 enum tosTraffClass
                 leaf remote-port-lo {
                   value 112;
                   type inet:port-number;
                   description "TOS Traffic Class"; "Remote Por Min Value";
                 }
                 enum flowLabel
                 leaf remote-port-hi {
                   value 128;
                   type inet:port-number;
                   description "Flow Label"; "Remote Port Max Value";
                 }
               }
               leaf ipsec-index {
                   type traffic-selectors:ipsec-spi;
                   description "TFT Component Type"; "IPSec Index";
               }
         typedef packet-filter-direction
               leaf traffic-class {
                   type enumeration {
               enum preRel7Tft {
                 value 0; inet:dscp;
                   description "Pre-Release 7 TFT"; "Traffic Class";
               }
               enum uplink
               case traffic-class-range {
                 value 1;
                   leaf traffic-class-lo {
                     type inet:dscp;
                     description "uplink"; "Traffic Class Min Value";
                   }
               enum downlink
                   leaf traffic-class-hi {
                 value 2;
                     type inet:dscp;
                     description "downlink"; "Traffic Class Max Value";
                   }
               enum bidirectional
               }
               leaf-list flow-label {
                 value 3;
                   type inet:ipv6-flow-label;
                   description "bi-direcitonal";
               } "Flow Label";
               }
               description "Packet Filter Direction"; "Component Value";
             }
         typedef component-type-id {
             type uint8 {
               range "16 | 17 | 32 | 33 | 35 | 48 | 64 | 65 |"
               + " 80 | 81 | 96 | 112 | 128";
           }
           description "Specifies the Component Type"; "Packet Filter";
         }

       grouping packet-filter prefix-descriptor {
           leaf direction destination-ip {
             type fpcbase:packet-filter-direction; inet:ip-prefix;
             description "Filter Direction"; "Rule of destination IP";
           }
           leaf identifier source-ip {
             type uint8 {
                 range "1..15";
               } inet:ip-prefix;
             description "Filter Identifier"; "Rule of source IP";
           }
           leaf evaluation-precedence {
               type uint8;
           description "Evaluation Precedence"; "Traffic descriptor based upon source/
             destination as IP prefixes";
       }
           list contents {
             key component-type-identifier;
             description "Filter Contents";
             leaf component-type-identifier

     grouping fpc-descriptor-value {
                 type fpcbase:component-type-id;
                 description "Component Type";
             }
       choice value {
               case ipv4-local descriptor-value {
         mandatory true;
         leaf ipv4-local all-traffic {
             type inet:ipv4-address; empty;
             description "IPv4 Local Address";
                 } "admit any";
         }
               case ipv6-prefix-local {
         leaf ipv6-prefix-local no-traffic {
             type inet:ipv6-prefix; empty;
             description "IPv6 Local Prefix";
                 } "deny any";
         }
         case ipv4-ipv6-remote prefix-descriptor {
                 leaf ipv4-ipv6-remote {
                   type inet:ip-address;
           uses fpcbase:prefix-descriptor;
           description "Ipv4 Ipv6 remote address";
                 } "IP Prefix descriptor";
         }
         case ipv6-prefix-remote pmip-selector {
                 leaf ipv6-prefix-remote
           uses traffic-selectors:traffic-selector;
           description "PMIP Selector";
         }
         container rfc5777-classifier-template {
                   type inet:ipv6-prefix;
               uses rfc5777:classifier;
               description "IPv6 Remote Prefix"; "RFC 5777 Classifier";
         }
         container packet-filter {
               uses fpcbase:packet-filter;
               description "Packet Filter";
         }
         case next-header {
                 leaf next-header tunnel-info {
                   type uint8;
           uses fpcbase:tunnel-value;
           description "Next Header"; "Tunnel Descriptor (only
               considers source info)";
         }
         description "Descriptor Value";
       }
               case local-port {
                 leaf local-port
       description "FPC Descriptor Values";
     }

       // Next Hop Structures
       typedef fpc-service-path-id {
           type inet:port-number;
                   description "Local Port"; uint32 {
               range "0..33554431";
           }
           description "SERVICE_PATH_ID";
       }
               case local-port-range {
                 leaf local-port-lo
       typedef fpc-mpls-label {
           type inet:port-number; uint32 {
             range "0..1048575";
           }
           description "Local Port Min Value"; "MPLS label";
       }
                 leaf local-port-hi
       typedef segment-id {
           type inet:port-number;
                   description "Local Port Max Value"; string {
               length "16";
           }
           description "SR Segement Identifier";
       }
               case remote-port
       grouping fpc-nexthop {
           choice next-hop-value {
               leaf remote-port ip-address {
                   type inet:port-number; inet:ip-address;
                   description "Remote Port";
                 } "IP Value";
               }
               case remote-port-range {
               leaf remote-port-lo mac-address {
                   type inet:port-number; ytypes:mac-address;
                   description "Remote Por Min "MAC Address Value";
               }
               leaf remote-port-hi service-path {
                   type inet:port-number; fpcbase:fpc-service-path-id;
                   description "Remote Port Max "Service Path Value";
               }
               }
               case ipsec-index {
               leaf ipsec-index mpls-path {
                   type traffic-selectors:ipsec-spi; fpcbase:fpc-mpls-label;
                   description "IPSec Index";
                 } "MPLS Value";
               }
               case traffic-class {
               leaf traffic-class nsh {
                   type inet:dscp;
                   description "Traffic Class"; string {
                       length "16";
                   }
                   description "Network Service Header";
               }
               case traffic-class-range {
               leaf traffic-class-lo interface {
                   type inet:dscp; uint16;
                   description "Traffic Class Min "If (interface) Value";
               }
               leaf traffic-class-hi segment-identifier {
                   type inet:dscp; fpcbase:segment-id;
                   description "Traffic Class Max Value";

                   } "Segment Id";
               }
               case flow-label-type {
               leaf-list flow-label mpls-label-stack {
                   type inet:ipv6-flow-label; fpcbase:fpc-mpls-label;
                   description "Flow Label";
                 } "MPLS Stack";
               }
               leaf-list mpls-sr-stack {
                   type fpcbase:fpc-mpls-label;
                   description "Component Value";
             } "MPLS SR Stack";
               }
               leaf-list srv6-stack {
                   type fpcbase:segment-id;
                   description "Packet Filter"; "Segment Id";
               }
         grouping tft {
           list packet-filters
               case tunnel-info {
               key identifier;
                   uses fpcbase:packet-filter; fpcbase:tunnel-value;
                   description "List of Packet Filters"; "Tunnel Descriptor (only
                   considers source info)";
               }
               description "Packet Filter List"; "Value";
           }
         typedef imsi-type {
             type uint64;
           description
                 "International Mobile Subscriber Identity (IMSI)
                   Value Type"; "Nexthop Value";
       }

       //////////////////////////////
       // PMIP Integration         //
         typedef threegpp-instr pmip-commandset {
               type bits {
                   bit assign-ip {
                     position 0;
                     description "Assign IP";
                   }
                   bit assign-dpn {
                     position 1;
                     description "Assign DPN";
                   }
                   bit session {
                     position 2;
                     description "Session Level";
                   }
                   bit uplink {
                     position 3;
                     description "Uplink";
                   }
                   bit downlink {
                     position 4;
                     description "Downlink";
                   }
               }
               description "PMIP Instructions";
           }
       ///////////////////////////////
       // 3GPP Integration         //

         // Type Defs
         typedef fpc-qos-class-identifier {
             type uint8 {
                 range "1..9";

             }
             description "QoS Class Identifier (QCI)";
         }
         typedef ebi-type {
           type uint8 {
             range "0..15";
           }
           description "EUTRAN Bearere Identifier (EBI) Type";
         }
         typedef imsi-type {
             type uint64;
             description
                 "International Mobile Subscriber Identity (IMSI)
                   Value Type";
         }
         // Instructions
         typedef threegpp-instr {
           type bits {
             bit assign-ip {
               position 0;
               description "Assign IP Address/Prefix";
             }
             bit assign-fteid-ip {
               position 1;
               description "Assign FTEID-IP";
             }
             bit assign-fteid-teid {
               position 2;
               description "Assign FTEID-TEID";
             }
             bit session {
               position 3;
               description "Commands apply to the Session Level";
             }
             bit uplink {
               position 4;
               description "Commands apply to the Uplink";
             }
             bit downlink {
               position 5;
               description "Commands apply to the Downlink";
             }
             bit assign-dpn {
               position 6;
               description "Assign DPN";
             }
           }
           description "Instruction Set for 3GPP R11";

         }

         grouping threegpp-tunnel-info {
             leaf tunnel-type {
                 type identityref  {
                   base "fpcbase:threeGPP-tunnel-type";
                 }
                 description "3GPP Tunnel Subtype";
             }
             leaf tunnel-identifier {
                 type uint32;
                 description "Tunnel Endpoint IDentifier (TEID)";
             }
             choice tft-or-ref {
               case defined-tft {
                 uses fpcbase:tft;
               }
               description "TFT Value";
             }
             description "3GPP TFT and Tunnel Information";
           }

         grouping threegpp-properties {
             leaf imsi {
               type fpcbase:imsi-type;
               description "IMSI";
             }
             leaf ebi {
               type fpcbase:ebi-type;
               description "EUTRAN Bearere Identifier (EBI)";
             }
             leaf lbi {
               type fpcbase:ebi-type;
               description "Linked Bearer Identifier (LBI)";
             }
             description "3GPP Mobility Session Properties";
           }

       //////////////////////////////
       // ACTION VALUE AUGMENTS
       grouping fpc-action-value {
           choice action-value {
               mandatory true;
               case drop {
               leaf drop {
                   type empty;
                   description "Drop Traffic";
               }
               }
               case simple-nat
               container rewrite {
                   uses fpcbase:simple-nat;
                   description "Simple NAT value";
               }
               case simple-napt
                   choice rewrite-value {
                   uses fpcbase:simple-napt;
                   description "Simple NAPT Value";
               }
                       case copy-forward prefix-descriptor {
                           uses fpcbase:copy-forward; fpcbase:prefix-descriptor;
                           description "Copy Forward Value"; "IP Prefix descriptor";
                       }
                       case pmip-selector {
                           uses traffic-selectors:traffic-selector;
                           description "PMIP Selector";
                       }
                       container rfc5777-classifier-template {
                           uses rfc5777:classifier;
                           description "Action Value"; "RFC 5777 Classifier";
                       }
                       description "FPC Action Value"; "Rewrite Choice";
                   }

       //////////////////////////////
       // DESCRIPTOR DEFINITIONS
     grouping fpc-descriptor-value
                   description "Rewrite/NAT value";
               }
               container copy-forward-nexthop {
       choice descriptor-value
                       uses fpcbase:fpc-nexthop;
                       description "Copy Forward Value";
               }
               container nexthop {
         mandatory true;
                       uses fpcbase:fpc-nexthop;
                       description "NextHop Value";
               }
               case all-traffic qos {
                   leaf all-traffic trafficclass {
                       type empty; inet:dscp;
                       description "admit any";
           } "Traffic Class";
                   }
         case no-traffic {
           leaf no-traffic {
             type empty;
             description "deny any";
           }

         }
         case prefix-descriptor {
           leaf destination-ip {
             type inet:ip-prefix;
             description "Rule of destination IP";
           }
           leaf source-ip {
             type inet:ip-prefix;
             description "Rule of source IP";
           }
           description "Traffic descriptor based upon source/
             destination as IP prefixes";
         }
         case pmip-selector {
           uses traffic-selectors:traffic-selector;
           description "PMIP Selector";
         }
         case threegpp-tft {
                   uses fpcbase:tft;
             description "3GPP TFT";
         }
         description "Descriptor Value";
       }
       description "FPC Descriptor Values";
     }

       //SETTINGS DEFINITIONS
       grouping fpc-settings {
           leaf-list delegated-ip-prefixes {
               type inet:ip-prefix;
               description "Delegated Prefix(es)";
           }
           leaf tunnel-local-address {
               type inet:ip-address;
               description "local tunnel address";
           } pmipqos:qosattribute;
                   leaf tunnel-remote-address qci {
                       type inet:ip-address; fpcbase:fpc-qos-class-identifier;
                       description "remote tunnel address"; "QCI";
                   }
                   leaf mtu-size ue-agg-max-bitrate {
                       type uint32;
                       description "MTU size"; "UE Aggregate Max Bitrate";
                   }
           container mobility-tunnel-parameters {
               choice profile-parameters {
                   case nothing {
                   leaf none apn-ambr {
                       type empty;
                       description "Empty Value";
                     }
                     description "No Parameters Case";
                   }
           case pmip {
             uses pmip-tunnel-info;
           }
           case threegpp {
             uses threegpp-tunnel-info;
             uses threegpp-properties;
           }
                   description "Mobility Profile Parameters";
               }
               description
               "Profile specific tunnel parameters";
           }
           container nexthop {
               uses fpcbase:fpc-nexthop;
               description "Next Hop";
           }
           container qos-profile-parameters {
               choice value { uint32;
                       description "QoS Value"; "Access Point Name
                         Aggregate Max Bit Rate";
                   }
                   description "QoS Parameters";
           }
           description "A collection of settings";
       }
       identity access-technology {
       description "The technology used in the access network";
     }
       identity role {
       description "The access-technology function of the DPN"; Attributes";
               }
     identity ietf-pmip-access-type {
       base "fpcbase:access-technology";
               description "PMIP Access"; "Action Value";
           }
     identity threeGPP-access-type {
       base "fpcbase:access-technology";
           description "3GPP Access Type"; "FPC Action Value";
       }

     // Instructions
     grouping instructions {
       container instructions {
         choice instr-type {
           case threegpp-instr {
           leaf instr-3gpp-mob {
               type fpcbase:threegpp-instr;
               description "3GPP GTP Mobility Instructions";
           }
           }
           case pmip-instr {
           leaf instr-pmip {
               type pmip-commandset;
               description "PMIP Instructions";
           }
           }
           description "Instruction Value Choice";
         }
         description "Instructions";
       }
       description "Instructions Value";
     }
   }
   <CODE ENDS>

A.2.2.  PMIP QoS Model

   This module defines the base protocol elements specified in this
   document.

   This module references [RFC6991].

   <CODE BEGINS> file "ietf-pmip-qos@2017-10-29.yang" "ietf-pmip-qos@2018-02-28.yang"
   module ietf-pmip-qos {
       yang-version 1.1;

       namespace
         "urn:ietf:params:xml:ns:yang:ietf-pmip-qos";

       prefix "qos-pmip";

       import ietf-inet-types {
         prefix inet;
         revision-date 2013-07-15;
       }
       import ietf-trafficselector-types { prefix traffic-selectors;
           revision-date 2018-02-28; }

       organization "IETF Distributed Mobility Management (DMM)
         Working Group";

       contact
          "WG Web:   <http://tools.ietf.org/wg/netmod/>
           WG List:  <mailto:netmod@ietf.org>

           WG Chair: Dapeng Liu
                     <mailto:maxpassion@gmail.com>

           WG Chair: Jouni Korhonen
                     <mailto:jouni.nospam@gmail.com> Sri Gundavelli
                     <mailto:sgundave@cisco.com>

           Editor:   Satoru Matsushima
                     <mailto:satoru.matsushima@g.softbank.co.jp>

           Editor:   Lyle Bertz
                     <mailto:lylebe551144@gmail.com>";

       description
         "This module contains a collection of YANG definitions for
        quality of service paramaters used in Proxy Mobile IPv6.

        Copyright (c) 2016 IETF Trust and the persons identified as the
        document authors. All rights reserved.

        This document is subject to BCP 78 and the IETF Trust's Legal
        Provisions Relating to IETF Documents
        (http://trustee.ietf.org/license-info) in effect on the date of
        publication of this document. Please review these documents
        carefully, as they describe your rights and restrictions with
        respect to this document. Code Components extracted from this
        document must include Simplified BSD License text as described
        in Section 4.e of the Trust Legal Provisions and are provided
        without warranty as described in the Simplified BSD License.";

     revision 2018-02-28 {
       description "Updated to drop unnecessary attribute types.
           Update WG co-chair.";
       reference "RFC 6088: Traffic Selectors for Flow Bindings";
     }
     revision 2017-10-29 {
        description "Base Version";
         reference
           "RFC 6088: Traffic Selectors for Flow Bindings";
      }

       // Type Definitions

       // QoS Option Field Type Definitions
     typedef sr-id {
       type uint8;
         description
          "An 8-bit unsigned integer used for identifying the QoS
           Service Request.";
       }

       typedef traffic-class {
         type inet:dscp;
         description
           "Traffic Class consists of a 6-bit DSCP field followed by a
            2-bit reserved field.";
        reference
            "RFC 3289: Management Information Base for the
                       Differentiated Services Architecture
             RFC 2474: Definition of the Differentiated Services Field
                       (DS Field) in the IPv4 and IPv6 Headers
             RFC 2780: IANA Allocation Guidelines For Values In
                       the Internet Protocol and Related Headers";
       }

       typedef operational-code {
         type enumeration {
           enum RESPONSE {
             value 0;
             description "Response to a QoS request";
           }
           enum ALLOCATE {
             value 1;
             description "Request to allocate QoS resources";
           }
           enum DE-ALLOCATE {
             value 2;
             description "Request to de-Allocate QoS resources";
           }
           enum MODIFY {
             value 3;
             description "Request to modify QoS parameters for a
                 previously negotiated QoS Service Request";
           }
           enum QUERY {
             value 4;
             description "Query to list the previously negotiated QoS
                 Service Requests that are still active";
           }
           enum NEGOTIATE {
             value 5;
             description "Response to a QoS Service Request with a
               counter QoS proposal";
           }
         }
         description
          "The type of QoS request. Reserved values:   (6) to (255)
                   Currently not used.  Receiver MUST ignore the option
                   received with any value in this range.";
       }

       // QoS Attribute Types
       //The enumeration value for mapping - don't confuse with the
       //  identities

     //Value definitions
     typedef qos-attrubite-type-enum Per-MN-Agg-Max-DL-Bit-Rate-Value {
         type enumeration {
           enum Reserved {
             value 0;
             description "This value is reserved and cannot be used";
           }
           enum Per-MN-Agg-Max-DL-Bit-Rate {
             value 1;
             description "Per-Mobile-Node Aggregate Maximum Downlink
                 Bit Rate.";
           }
           enum Per-MN-Agg-Max-UL-Bit-Rate {
             value 2;
             description "Per-Mobile-Node Aggregate Maximum Uplink Bit
               Rate.";
           }
           enum Per-Session-Agg-Max-DL-Bit-Rate {
             value 3;
             description "Per-Mobility-Session Aggregate Maximum
               Downlink Bit Rate.";
           }
           enum Per-Session-Agg-Max-UL-Bit-Rate {
             value 4;
             description "Per-Mobility-Session Aggregate Maximum
                Uplink Bit Rate.";
           }
           enum Allocation-Retention-Priority {
             value 5;
             description "Allocation and Retention Priority.";
           }
           enum Aggregate-Max-DL-Bit-Rate {
             value 6;
             description "Aggregate Maximum Downlink Bit Rate.";
           }
           enum Aggregate-Max-UL-Bit-Rate {
             value 7;
             description "Aggregate Maximum Uplink Bit Rate.";
           }
           enum Guaranteed-DL-Bit-Rate {
             value 8;
             description "Guaranteed Downlink Bit Rate.";
           }
           enum Guaranteed-UL-Bit-Rate {
             value 9;
             description "Guaranteed Uplink Bit Rate.";
           }
           enum QoS-Traffic-Selector {
             value 10;
             description "QoS Traffic Selector.";
           }
           enum QoS-Vendor-Specific-Attribute {
             value 11;
             description "QoS Vendor-Specific Attribute.";
           }
         }
        description
       "The type of the QoS attribute.  This specification reserves
          the following reserved values.
            (12) to (254) -  Reserved
               These values are reserved for future allocation.

            (255)  Reserved
               This value is reserved and cannot be used.";
       }

       // Attribute Type as Identities
       // Added for convenience of inclusion and extension in
       //    other YANG modules.
       identity qos-attribute-type {
         description
           "Base type for Quality of Service Attributes";
       }

       identity Per-MN-Agg-Max-DL-Bit-Rate-type {
         base qos-attribute-type;
         description
           "Per-Mobile-Node Aggregate Maximum Downlink Bit Rate.";
       }

      identity Per-MN-Agg-Max-UL-Bit-Rate-type {
         base qos-attribute-type;
         description
           "Per-Mobile-Node Aggregate Maximum Uplink Bit Rate";
      }

      identity Per-Session-Agg-Max-DL-Bit-Rate-type {
         base qos-attribute-type;
         description
          "Per-Mobility-Session Aggregate Maximum Downlink Bit Rate.";
     }

      identity Per-Session-Agg-Max-UL-Bit-Rate-type {
         base qos-attribute-type;
         description
          "Per-Mobility-Session Aggregate Maximum Uplink Bit Rate.";
      }

      identity Allocation-Retention-Priority-type {
         base qos-attribute-type;
         description
           "Allocation and Retention Priority.";
      }

      identity Aggregate-Max-DL-Bit-Rate-type {
         base qos-attribute-type;
         description "Aggregate Maximum Downlink Bit Rate.";
      }

     identity Aggregate-Max-UL-Bit-Rate-type {
         base qos-attribute-type;
         description "Aggregate Maximum Uplink Bit Rate.";
     }

     identity Guaranteed-DL-Bit-Rate-type {
         base qos-attribute-type;
         description "Guaranteed Downlink Bit Rate.";
     }

     identity Guaranteed-UL-Bit-Rate-type {
         base qos-attribute-type;
         description "Guaranteed Uplink Bit Rate.";
     }

     identity QoS-Traffic-Selector-type {
         base qos-attribute-type;
         description "QoS Traffic Selector.";
     }

     identity QoS-Vendor-Specific-Attribute-type {
         base qos-attribute-type;
         description "QoS Vendor-Specific Attribute.";
     }

     //value definitions
     typedef Per-MN-Agg-Max-DL-Bit-Rate-Value {
         type uint32; uint32;
         description
             "The aggregate maximum downlink bit rate that is
             requested/allocated for all the mobile node's IP flows.
             The measurement units are bits per second.";
     }

      typedef Per-MN-Agg-Max-UL-Bit-Rate-Value {
         type uint32;
         description
           "The aggregate maximum uplink bit rate that is
               requested/allocated for the mobile node's IP flows.  The
               measurement units are bits per second.";
      }

      // Generic Structure for the uplink and downlink
      grouping Per-Session-Agg-Max-Bit-Rate-Value {
        leaf max-rate {
          type uint32;
          mandatory true;
          description
          "The aggregate maximum bit rate that is requested/allocated
        for all the IP flows associated with that mobility session.
        The measurement units are bits per second.";
        }
        leaf service-flag {
         type boolean;
         mandatory true;
         description
          "This flag is used for extending the scope of the
           target flows for Per-Session-Agg-Max-UL/DL-Bit-Rate
           from(UL)/to(DL) the mobile node's other mobility sessions
           sharing the same Service Identifier.";
         reference
           "RFC 5149 - Service Selection mobility option";
        }
        leaf exclude-flag {
          type boolean;
          mandatory true;
          description
           "This flag is used to request that the uplink/downlink
          flows for which the network is providing
               Guaranteed-Bit-Rate service be excluded from the
               target IP flows for which
               Per-Session-Agg-Max-UL/DL-Bit-Rate is measured.";
        }
       description "Per-Session-Agg-Max-Bit-Rate Value";
      }

      grouping Allocation-Retention-Priority-Value {
        leaf prioirty-level {
          type uint8 {
            range "0..15";
          }
          mandatory true;
          description
          "This is a 4-bit unsigned integer value.  It is used to decide
           whether a mobility session establishment or modification
           request can be accepted; this is typically used for
           admission control of Guaranteed Bit Rate traffic in case of
           resource limitations.";
        }
        leaf premption-capability {
          type enumeration {
           enum enabled {
             value 0;
             description "enabled";
           }
           enum disabled {
             value 1;
             description "disabled";
           }
           enum reserved1 {
             value 2;
             description "reserved1";
           }
           enum reserved2 {
             value 3;
             description "reserved2";
           }
          }
          mandatory true;
          description
          "This is a 2-bit unsigned integer value.  It defines whether
           a service data flow can get resources that were already
           assigned to another service data flow with a lower priority
           level.";
        }
        leaf premption-vulnerability {
          type enumeration {
           enum enabled {
             value 0;
             description "enabled";
           }
           enum disabled {
             value 1;
             description "disabled";
           }
           enum reserved1 {
             value 2;
             description "reserved1";
           }
           enum reserved2 {
             value 3;
             description "reserved2";
           }
          }
          mandatory true;
          description
          "This is a 2-bit unsigned integer value.  It defines whether a
            service data flow can lose the resources assigned to it in
            order to admit a service data flow with a higher priority
            level.";
        }
       description "Allocation-Retention-Priority Value";
      }

      typedef Aggregate-Max-DL-Bit-Rate-Value {
         type uint32;
         description
           "The aggregate maximum downlink bit rate that is
            requested/allocated for downlink IP flows.  The measurement
            units are bits per second.";
      }

       typedef Aggregate-Max-UL-Bit-Rate-Value {
         type uint32;
         description
           "The aggregate maximum downlink bit rate that is
            requested/allocated for downlink IP flows.  The measurement
            units are bits per second.";
       }

       typedef Guaranteed-DL-Bit-Rate-Value {
         type uint32;
         description
         "The guaranteed bandwidth in bits per second for downlink
           IP flows.  The measurement units are bits per second.";
       }

       typedef Guaranteed-UL-Bit-Rate-Value {
         type uint32;
         description
           "The guaranteed bandwidth in bits per second for uplink
            IP flows.  The measurement units are bits per second.";
       }

       grouping QoS-Vendor-Specific-Attribute-Value-Base {
         leaf vendorid {
           type uint32;
           mandatory true;
           description
            "The Vendor ID is the SMI (Structure of Management
             Information) Network Management Private Enterprise Code of
             the IANA-maintained 'Private Enterprise Numbers'
             registry.";
           reference
             "'PRIVATE ENTERPRISE NUMBERS', SMI Network Management
               Private Enterprise Codes, April 2014,
                <http://www.iana.org/assignments/enterprise-numbers>";
         }
         leaf subtype {
           type uint8;
           mandatory true;
           description
             "An 8-bit field indicating the type of vendor-specific
              information carried in the option.  The namespace for this
              sub-type is managed by the vendor identified by the
              Vendor ID field.";
         }
         description
           "QoS Vendor-Specific Attribute.";
       }

       //NOTE - We do NOT add the Status Codes or other changes in
       // PMIP in this module

       //Primary Structures (groupings)
       grouping qosattribute {
           leaf attributetype per-mn-agg-max-dl {
               type identityref {
                   base qos-attribute-type;
               }
               mandatory true;
               description "the attribute type";
           }

           //All of the sub-types by constraint
           choice attribute-choice {
               case per-mn-agg-max-dl-case {
                   when "./attributetype = "
                      + "'Per-MN-Agg-Max-DL-Bit-Rate-type'";
                   leaf per-mn-agg-max-dl {
                       type qos-pmip:Per-MN-Agg-Max-DL-Bit-Rate-Value; qos-pmip:Per-MN-Agg-Max-DL-Bit-Rate-Value;
               description "Per-MN-Agg-Max-DL-Bit-Rate Value";
           }
                   description "Per-MN-Agg-Max-DL-Bit-Rate Case";
               }
               case per-mn-agg-max-ul-case {
                   when "./attributetype = "
                     + "'Per-MN-Agg-Max-UL-Bit-Rate-type'";
           leaf per-mn-agg-max-ul {
               type qos-pmip:Per-MN-Agg-Max-UL-Bit-Rate-Value;
               description "Per-MN-Agg-Max-UL-Bit-Rate Value";
           }
                   description "Per-MN-Agg-Max-UL-Bit-Rate Case";
               }
               case per-session-agg-max-dl-case {
                   when "./attributetype = "
                   + "'Per-Session-Agg-Max-DL-Bit-Rate-type'";
           container per-session-agg-max-dl {
               uses qos-pmip:Per-Session-Agg-Max-Bit-Rate-Value;
               description "Per-Session-Agg-Max-Bit-Rate Value";
           }
                   description "Per-Session-Agg-Max-Bit-Rate Case";
               }
               case per-session-agg-max-ul-case {
                   when "./attributetype = "
                   + "'Per-Session-Agg-Max-UL-Bit-Rate-type'";
           container per-session-agg-max-ul {
               uses qos-pmip:Per-Session-Agg-Max-Bit-Rate-Value;
               description "Per-Session-Agg-Max-Bit-Rate Value";
           }
                   description "Per-Session-Agg-Max-Bit-Rate Case";
               }
               case allocation-retention-priority-case {
                   when "./attributetype = "
                      + "'Allocation-Retention-Priority-type'";
           uses qos-pmip:Allocation-Retention-Priority-Value;
                   description "Allocation-Retention-Priority Case";
               }
               case agg-max-dl-case {
                   when "./attributetype = "
                     + "'Aggregate-Max-DL-Bit-Rate-type'";
           leaf agg-max-dl {
               type qos-pmip:Aggregate-Max-DL-Bit-Rate-Value;
               description "Aggregate-Max-DL-Bit-Rate Value";
           }
                   description "Aggregate-Max-DL-Bit-Rate Case";
               }
               case agg-max-ul-case {
                   when "./attributetype = "
                     + "'Aggregate-Max-UL-Bit-Rate-type'";
           leaf agg-max-ul {
               type qos-pmip:Aggregate-Max-UL-Bit-Rate-Value;
               description "Aggregate-Max-UL-Bit-Rate Value";
           }
                   description "Aggregate-Max-UL-Bit-Rate Case";
               }
               case gbr-dl-case {
                   when "./attributetype =
                      'Guaranteed-DL-Bit-Rate-type'";
           leaf gbr-dl {
               type qos-pmip:Guaranteed-DL-Bit-Rate-Value;
               description "Guaranteed-DL-Bit-Rate Value";
           }
                   description "Guaranteed-DL-Bit-Rate Case";
               }
               case gbr-ul-case {
                   when "./attributetype =
                    'Guaranteed-UL-Bit-Rate-type'";
           leaf gbr-ul {
               type qos-pmip:Guaranteed-UL-Bit-Rate-Value;
               description "Guaranteed-UL-Bit-Rate Value";
           }
           description "Guaranteed-UL-Bit-Rate Case";
               }
               case traffic-selector-case {
                   when "./attributetype = 'QoS-Traffic-Selector-type'";
                   container traffic-selector {
                       uses traffic-selectors:traffic-selector;
                       description "traffic selector";
                   }
                   description "traffic selector Case";
               }
               description "Attribute Value";
           }
           description "PMIP QoS Attribute"; Attributes";
       }

       grouping qosoption {
           leaf srid {
               type sr-id;
               mandatory true;
               description "Service Request Identifier";
           }
           leaf trafficclass {
               type traffic-class;
               mandatory true;
               description "Traffic Class";
           }
           leaf operationcode {
               type operational-code;
               mandatory true;
               description "Operation Code";
           }
           list attributes {
               unique "attributetype";
           uses qosattribute;
               min-elements 1;
           container traffic-selector {
               uses traffic-selectors:traffic-selector;
               description "Attributes"; "traffic selector";
           }
           description "PMIP QoS Option";
       }
   }
   <CODE ENDS>

A.2.3.  Traffic Selectors YANG Model

   This module defines traffic selector types commonly used in Proxy
   Mobile IP (PMIP).

   This module references [RFC6991].

   <CODE BEGINS> file "ietf-trafficselector-types@2017-10-29.yang" "ietf-trafficselector-types@2018-02-28.yang"
   module ietf-trafficselector-types {
    yang-version 1.1;

    namespace
    "urn:ietf:params:xml:ns:yang:ietf-trafficselector-types";

    prefix "traffic-selectors";

    import ietf-inet-types {
      prefix inet;
      revision-date 2013-07-15;
    }

    organization "IETF Distributed Mobility Management (DMM)
    Working Group";

    contact
    "WG Web: <http://tools.ietf.org/wg/netmod/>
    WG List: <mailto:netmod@ietf.org>

    WG Chair: Dapeng Liu
    <mailto:maxpassion@gmail.com>

    WG Chair: Jouni Korhonen
    <mailto:jouni.nospam@gmail.com> Sri Gundavelli
    <mailto:sgundave@cisco.com>

    Editor: Satoru Matsushima
    <mailto:satoru.matsushima@g.softbank.co.jp>

    Editor: Lyle Bertz
    <mailto:lylebe551144@gmail.com>";

    description
    "This module contains a collection of YANG definitions for
    traffic selectors for flow bindings.

    Copyright (c) 2016 IETF Trust and the persons identified as the
    document authors. All rights reserved.

    This document is subject to BCP 78 and the IETF Trust's Legal
    Provisions Relating to IETF Documents
    (http://trustee.ietf.org/license-info) in effect on the date of
    publication of this document. Please review these documents
    carefully, as they describe your rights and restrictions with
    respect to this document. Code Components extracted from this
    document must include Simplified BSD License text as described
    in Section 4.e of the Trust Legal Provisions and are provided
    without warranty as described in the Simplified BSD License.";

     revision 2018-02-28 {
       description
        "removed ts-list and updated WG co-chair.";
       reference
        "RFC 6088: Traffic Selectors for Flow Bindings";
     }

     revision 2017-10-29 {
        description "Base Version";
         reference
           "RFC 6088: Traffic Selectors for Flow Bindings";
      }

    // Identities
      identity traffic-selector-format {
        description
        "The base type for Traffic-Selector Formats";

      }

      identity ipv4-binary-selector-format {
        base traffic-selector-format;
        description
          "IPv4 Binary Traffic Selector Format";
      }

      identity ipv6-binary-selector-format {
        base traffic-selector-format;
        description
          "IPv6 Binary Traffic Selector Format";
      }

      // Type definitions and groupings
      typedef ipsec-spi {
        type uint32;
        description
         "The first 32-bit IPsec Security Parameter Index (SPI)
         value on data. This field is defined in [RFC4303].";
          reference
          "RFC 4303: IP Encapsulating Security
          Payload (ESP)";
      }

      grouping traffic-selector-base {
        description "A grouping of the commen leaves between the
          v4 and v6 Traffic Selectors";
        container ipsec-spi-range {
          presence "Enables setting ipsec spi range";
          description
          "Inclusive range representing IPSec Security Parameter
          Indices to be used. When only start-spi is present, it
          represents a single spi.";
      leaf start-spi {
          type ipsec-spi;
          mandatory true;
          description
            "The first 32-bit IPsec SPI value on data.";
          }
      leaf end-spi {
            type ipsec-spi;
            must ". >= ../start-spi" {
              error-message
                "The end-spi must be greater than or equal
                 to start-spi";
          }
         description
           "If more than one contiguous SPI value needs to be matched,
           then this field indicates the end value of a range.";
          }
       }
       container source-port-range {
         presence "Enables setting source port range";
         description
          "Inclusive range representing source ports to be used.
           When only start-port is present, it represents a single
        port. These value(s) are from the range of port numbers
           defined by IANA (http://www.iana.org).";
         leaf start-port {
            type inet:port-number;
            mandatory true;
            description
            "The first 16-bit source port number to be matched";
         }
         leaf end-port {
            type inet:port-number;
            must ". >= ../start-port" {
            error-message
             "The end-port must be greater than or equal to start-port";
           }
           description
            "The last 16-bit source port number to be matched";
          }
       }
       container destination-port-range {
         presence "Enables setting destination port range";
         description
          "Inclusive range representing destination ports to be used.
          When only start-port is present, it represents a single
          port.";
           leaf start-port {
             type inet:port-number;
             mandatory true;
             description
             "The first 16-bit destination port number to be matched";
          }
          leaf end-port {
            type inet:port-number;
            must ". >= ../start-port" {
            error-message
              "The end-port must be greater than or equal to
             start-port";
           }
           description
        "The last 16-bit destination port number to be matched";
        }
      }
    }

    grouping ipv4-binary-traffic-selector {
      container source-address-range-v4 {
         presence "Enables setting source IPv4 address range";
         description
          "Inclusive range representing IPv4 addresses to be used. When
          only start-address is present, it represents a single
          address.";
         leaf start-address {
           type inet:ipv4-address;
           mandatory true;
          description
           "The first source address to be matched";
         }
         leaf end-address {
           type inet:ipv4-address;
           description
            "The last source address to be matched";
          }
      }
      container destination-address-range-v4 {
         presence "Enables setting destination IPv4 address range";
         description
           "Inclusive range representing IPv4 addresses to be used.
           When only start-address is present, it represents a
           single address.";
         leaf start-address {
           type inet:ipv4-address;
           mandatory true;
           description
            "The first destination address to be matched";
         }
         leaf end-address {
           type inet:ipv4-address;
           description
            "The last destination address to be matched";
         }
      }
      container ds-range {
         presence "Enables setting dscp range";
         description
          "Inclusive range representing DiffServ Codepoints to be used.
          When only start-ds is present, it represents a single
          Codepoint.";
         leaf start-ds {
           type inet:dscp;
           mandatory true;
           description
            "The first differential service value to be matched";
       }
       leaf end-ds {
         type inet:dscp;
         must ". >= ../start-ds" {
           error-message
             "The end-ds must be greater than or equal to start-ds";
         }
         description
           "The last differential service value to be matched";
      }
     }
     container protocol-range {
       presence "Enables setting protocol range";
       description
         "Inclusive range representing IP protocol(s) to be used. When
          only start-protocol is present, it represents a single
          protocol.";
       leaf start-protocol {
         type uint8;
         mandatory true;
         description
           "The first 8-bit protocol value to be matched.";
        }
        leaf end-protocol {
          type uint8;
          must ". >= ../start-protocol" {
            error-message
              "The end-protocol must be greater than or equal to
             start-protocol";
          }
        description
          "The last 8-bit protocol value to be matched.";
        }
      }
      description "ipv4 binary traffic selector";
    }
     grouping ipv6-binary-traffic-selector {
      container source-address-range-v6 {
        presence "Enables setting source IPv6 address range";
         description
          "Inclusive range representing IPv6 addresses to be used.
          When only start-address is present, it represents a
          single address.";
         leaf start-address {
           type inet:ipv6-address;
           mandatory true;
           description
           "The first source address, from the
           range of 128-bit IPv6 addresses to be matched";
         }
         leaf end-address {
           type inet:ipv6-address;
           description
               "The last source address, from the
               range of 128-bit IPv6 addresses to be matched";
         }
      }
      container destination-address-range-v6 {
        presence "Enables setting destination IPv6 address range";
        description
          "Inclusive range representing IPv6 addresses to be used.
           When only start-address is present, it represents a
           single address.";
        leaf start-address {
          type inet:ipv6-address;
          mandatory true;
          description
              "The first destination address, from the
              range of 128-bit IPv6 addresses to be matched";
        }
        leaf end-address {
          type inet:ipv6-address;
          description
              "The last destination address, from the
              range of 128-bit IPv6 addresses to be matched";
       }
     }
     container flow-label-range {
       presence "Enables setting Flow Label range";
       description
         "Inclusive range representing IPv4 addresses to be used. When
          only start-flow-label is present, it represents a single
          flow label.";
       leaf start-flow-label {
         type inet:ipv6-flow-label;
         description
           "The first flow label value to be matched";
       }
       leaf end-flow-label {
         type inet:ipv6-flow-label;
         must ". >= ../start-flow-label" {
           error-message
             "The end-flow-lable must be greater than or equal to
              start-flow-label";
         }
         description
            "The first flow label value to be matched";
       }
      }
     container traffic-class-range {
       presence "Enables setting the traffic class range";
       description
        "Inclusive range representing IPv4 addresses to be used. When
         only start-traffic-class is present, it represents a single
         traffic class.";
       leaf start-traffic-class {
         type inet:dscp;
         description
          "The first traffic class value to be matched";
         reference
          "RFC 3260: New Terminology and Clarifications for Diffserv
           RFC 3168: The Addition of Explicit Congestion Notification
           (ECN) to IP";
       }
       leaf end-traffic-class {
         type inet:dscp;
         must ". >= ../start-traffic-class" {
           error-message
             "The end-traffic-class must be greater than or equal to
              start-traffic-class";
         }
         description
           "The last traffic class value to be matched";
       }
     }
     container next-header-range {
       presence "Enables setting Next Header range";
       description
        "Inclusive range representing Next Headers to be used. When
         only start-next-header is present, it represents a
         single Next Header.";
       leaf start-next-header {
         type uint8;
         description
          "The first 8-bit next header value to be matched.";
       }
       leaf end-next-header {
         type uint8;
         must ". >= ../start-next-header" {
           error-message
             "The end-next-header must be greater than or equal to
             start-next-header";
         }
         description
           "The last 8-bit next header value to be matched.";
       }
     }
     description "ipv6 binary traffic selector";
   }

     grouping traffic-selector {
       leaf ts-format {
          type identityref {
            base traffic-selector-format;
          }
          description "Traffic Selector Format";
        }
       uses traffic-selector-base;
       uses ipv4-binary-traffic-selector;
       uses ipv6-binary-traffic-selector;
       description
        "The traffic selector includes the parameters used to match
          packets for a specific flow binding.";
       reference
        "RFC 6089: Flow Bindings in Mobile IPv6 and Network
          Mobility (NEMO) Basic Support";
     }

     grouping ts-list {
       list selectors {
         key index;
         leaf index {
           type uint64;
           description "index";
         }
         uses traffic-selector;
         description "traffic selectors";
       }
       description "traffic selector list";
     }
   }
   <CODE ENDS>

A.3.  FPC

A.2.4.  RFC 5777 Classifier YANG Data Model Structure

   This section only shows module defines the structure for FPC RFC 5777 Classifer.

   This module references [RFC5777].

   <CODE BEGINS> file "ietf-diam-trafficclassifier@2018-02-28.yang"
   module ietf-diam-trafficclassifier {
    yang-version 1.1;

    namespace
    "urn:ietf:params:xml:ns:yang:ietf-diam-trafficclassifier";

    prefix "diamclassifier";

    import ietf-inet-types {
      prefix inet;
      revision-date 2013-07-15;

    }
    import ietf-yang-types { prefix yang-types; }

    organization "IETF Distributed Mobility Management (DMM)
    Working Group";

    contact
    "WG Web: <http://tools.ietf.org/wg/netmod/>
    WG List: <mailto:netmod@ietf.org>

    WG Chair: Dapeng Liu
    <mailto:maxpassion@gmail.com>

    WG Chair: Sri Gundavelli
    <mailto:sgundave@cisco.com>

    Editor: Satoru Matsushima
    <mailto:satoru.matsushima@g.softbank.co.jp>

    Editor: Lyle Bertz
    <mailto:lylebe551144@gmail.com>";

    description
    "This module contains a collection of YANG model.  NOTE, definitions for
    traffic classification and QoS Attributes for Diameter.

    Copyright (c) 2018 IETF Trust and the persons identified as the
    document authors. All rights reserved.

    This document is subject to BCP 78 and the IETF Trust's Legal
    Provisions Relating to IETF Documents
    (http://trustee.ietf.org/license-info) in effect on the date of
    publication of this document. Please review these documents
    carefully, as they describe your rights and restrictions with
    respect to this document. Code Components extracted from this
    document must include Simplified BSD License text as described
    in Section 4.e of the Trust Legal Provisions and are provided
    without warranty as described in the Simplified BSD License.";

     revision 2018-02-28 {
       description
           "Initial";
       reference
       "RFC 5777: Traffic Classification and Quality of Service (QoS)
           Attributes for Diameter";
     }

       typedef eui64-address-type {
           type string {
               length "6";
           }
           description
               "specifies a single layer 2 address in EUI-64 format.
                The value is an 8-octet encoding of the address as
                it
   does NOT show would appear in the settings, Action values frame header.";
       }
       typedef direction-type {
           type enumeration {
               enum IN {
                   value 0;
                   description
                       "Applies to flows from the managed terminal.";
               }
               enum OUT {
                   value 1;
                   description
                    "Applies to flows to the managed terminal.";
               }
               enum BOTH {
                   value 2;
                   description
                       "Applies to flows both to and from the managed
                           terminal.";
               }
           }
           description
               "Specifies in which direction to apply the classifier.";
       }
       typedef negated-flag-type {
           type enumeration {
               enum False { value 0;
                   description "false"; }
               enum True { value 1;
                   description "True"; }
           }
           description
               "When set to True, the meaning of the match is
                inverted and the classifier will match addresses
                other than those specified by the From-Spec or Descriptor Value.

   module: ietf-dmm-fpc
   +--rw mobility
      +--rw topology
                To-Spec AVP.

                Note that the negation does not impact the port
                   comparisons.";
       }
       grouping index {
           leaf index {
               type uint16;
               mandatory true;
               description "Identifier used for referencing";
           }
           description "Index Value";
       }
       grouping to-from-spec-value {
           leaf-list ip-address {
               type inet:ip-address;
               description "IP address";
           }
           list ip-address-range {
               key index;
               uses diamclassifier:index;
               leaf ip-address-start {
                   type inet:ip-address;
                   description "IP Address Start";
               }
               leaf ip-address-end {
                   type inet:ip-address;
                   description "IP Address End";
               }
               description "IP Address Range";
           }
           leaf-list ip-address-mask {
               type inet:ip-prefix;
               description "IP Address Mask";
           }
           leaf-list mac-address {
               type yang-types:mac-address;
               description "MAC address";
           }
           list mac-address-mask {
               key mac-address;
               leaf mac-address {
                   type yang-types:mac-address;
                   mandatory true;
                   description "MAC address";
               }
               leaf macaddress-mask-pattern {
                   type yang-types:mac-address;
                   mandatory true;
                   description
                    "The value specifies the bit positions of a
                     MAC address that are taken for matching.";
               }
               description "MAC Address Mask";
           }
           leaf-list eui64-address {
               type diamclassifier:eui64-address-type;
               description "EUI64 Address";
           }
           list eui64-address-mask {
               key eui64-address;
               leaf eui64-address {
                   type diamclassifier:eui64-address-type;
                   mandatory true;
                   description "eui64 address";
               }
               leaf eui64-address-mask-pattern {
                   type diamclassifier:eui64-address-type;
                   mandatory true;
                   description
                    "The value is 8 octets specifying the bit
                     positions of a EUI64 address that are taken
                    for matching.";
               }
               description "EUI64 Address Mask";
           }
           leaf-list port {
               type inet:port-number;
               description "Port Number";
           }
           list port-range {
               key index;
               uses diamclassifier:index;
               leaf ip-address-start {
                   type inet:port-number;
                   description "Port Start";
               }
               leaf ip-address-end {
                   type inet:port-number;
                   description "Port End";
               }
               description "Port Range";
           }
           leaf negated {
               type diamclassifier:negated-flag-type;
               description "Negated";
           }
           leaf use-assigned-address {
               type boolean;
               description "Use Assigned Address";
           }
           description
               "Basic traffic description value";

       }

       grouping option-type-group {
           leaf option-type {
               type uint8;
               mandatory true;
               description "Option Type";
           }
           leaf-list ip-option-value {
               type string;
               description "Option Value";
           }
           leaf negated {
               type diamclassifier:negated-flag-type;
               description "Negated";
           }
           description "Common X Option Pattern";
       }
       typedef vlan-id {
           type uint32 {
               range "0..4095";
           }
           description "VLAN ID";
       }

     grouping classifier {
       leaf protocol {
           type uint8;
           description "Protocol";
       }
       leaf direction {
           type diamclassifier:direction-type;
           description "Direction";
       }
       list from-spec {
           key index;
           uses diamclassifier:index;
           uses diamclassifier:to-from-spec-value;
           description "from specification";
       }
       list to-spec {
           key index;
           uses diamclassifier:index;
           uses diamclassifier:to-from-spec-value;
           description "to specification";
       }
       leaf-list disffserv-code-point {
           type inet:dscp;
           description "DSCP";
       }
       leaf fragmentation-flag {
       type enumeration {
               enum DF {
                   value 0;
                   description "Don't Fragment";
               }
               enum MF {
                   value 1;
                   description "More Fragments";
               }
           }
           description "Fragmenttation Flag";
       }
       list ip-option {
           key option-type;
           uses diamclassifier:option-type-group;
           description "IP Option Value";
       }
       list tcp-option {
           key option-type;
           uses diamclassifier:option-type-group;
           description "TCP Option Value";
       }
       list tcp-flag {
           key tcp-flag-type;
           leaf tcp-flag-type {
               type uint32;
               mandatory true;
               description "TCP Flag Type";
           }
           leaf negated {
               type diamclassifier:negated-flag-type;
               description "Negated";
           }
           description "TCP Flags";
       }
       list icmp-option {
           key option-type;
           uses diamclassifier:option-type-group;
           description "ICMP Option Value";
       }
       list eth-option {
           key index;
           uses diamclassifier:index;
           container eth-proto-type {
               leaf-list eth-ether-type {
                   type string {
                       length "2";
                   }
                   description "value of ethertype field";
               }
               leaf-list eth-sap {
                   type string {
                       length "2";
                   }
                   description "802.2 SAP";
               }
               description "Ether Proto Type";
           }
           list vlan-id-range {
               key index;
               uses diamclassifier:index;
               leaf-list s-vlan-id-start {
                   type diamclassifier:vlan-id;
                   description "S-VID  VLAN ID Start";
               }
               leaf-list s-vlan-id-end {
                   type diamclassifier:vlan-id;
                   description "S-VID VLAN ID End";
               }
               leaf-list c-vlan-id-start {
                   type diamclassifier:vlan-id;
                   description "C-VID  VLAN ID Start";
               }
               leaf-list c-vlan-id-end {
                   type diamclassifier:vlan-id;
                   description "C-VID  VLAN ID End";
               }
               description "VLAN ID Range";
           }
           list user-priority-range {
               key index;
               uses diamclassifier:index;
               leaf-list low-user-priority {
                   type uint32 {
                       range "0..7";
                   }
                   description "Low User Priority";
               }
               leaf-list high-user-priority {
                   type uint32 {
                       range "0..7";
                   }
                   description "High User Priority";

               }
               description "User priority range";
           }
           description "Ether Option";
       }
       description "RFC 5777 Classifier";
     }
   }
   <CODE ENDS>

A.3.  FPC YANG Data Model Structure

   This section only shows the structure for FPC YANG model.  NOTE, it
   does NOT show the settings, Action values or Descriptor Value.

   module: ietf-dmm-fpc
   +--rw tenant* [tenant-key]
   +--rw tenant-key                    fpc:fpc-identity
   +--rw mobility-information-model
   |  +--rw dpn* [dpn-key]
   |     +--rw dpn-key                           fpc:fpc-identity
   |     +--rw dpn-name?                         string
   |     +--rw dpn-resource-mapping-reference?   string
   |     +--rw domain-key*                       fpc:fpc-identity
   |     +--rw service-group-key*                fpc:fpc-identity
   |     +--rw interface* [interface-key]
   |     |  +--rw interface-key             fpc:fpc-identity
   |     |  +--rw interface-name?           string
   |     |  +--rw roles*                    identityref
   |     |  +--rw interface-settings
   |     |     +--rw index    uint16
   |     |     +--rw (policy-setting)?
   |     |        +--:(descriptor-value)
   |     |        +--:(action-value)
   |     +--rw dpn-settings* [policy-template-key]
   |        +--rw policy-template-key     fpc:fpc-identity
   |        +--rw policy-configuration* [index]
   |           +--rw index    uint16
   |           +--rw (policy-setting)?
   |              +--:(descriptor-value)
   |              +--:(action-value)
   +--rw dpn-checkpoint
   |  +--rw basename?          fpc:fpc-identity
   |  +--rw base-checkpoint?   string
   +--rw service-group* [service-group-key]
   |  +--rw service-group-key     fpc:fpc-identity
   |  +--rw service-group-name?   string
   |  +--rw dpn* [dpn-key role-key]
   |  |  +--rw dpn-key                 fpc:fpc-identity
   |  |  +--rw role-key                identityref
   |  |  +--rw referenced-interface* [interface-key]
   |  |     +--rw interface-key             fpc:fpc-identity
   |  |     +--rw peer-service-group-key*   fpc:fpc-identity
   |  +--rw service-settings* [policy-template-key]
   |     +--rw policy-template-key     fpc:fpc-identity
   |     +--rw policy-configuration* [index]
   |        +--rw index    uint16
   |        +--rw (policy-setting)?
   |           +--:(descriptor-value)
   |           +--:(action-value)
   +--rw service-group-checkpoint
   |  +--rw basename?          fpc:fpc-identity
   |  +--rw base-checkpoint?   string
   +--rw topology-information-model
   |  +--rw service-endpoint* [role-key]
   |  |  +--rw role-key             identityref
   |  |  +--rw role-name?           string
   |  |  +--rw service-group-key*   fpc:fpc-identity
   |  |  +--rw interface* [dpn-key interface-key]
   |  |     +--rw dpn-key                   fpc:fpc-identity
   |  |     +--rw interface-key             fpc:fpc-identity
   |  |     +--rw protocol*   identityref
   |  |     +--rw feature*              identityref
   |  |     +--rw interface-settings-set
   |  +--rw domain* [domain-key]
   |  |  +--rw domain-key         fpc:fpc-identity
   |  |  +--rw domain-name?       string
   |  |  +--rw domain-settings* [policy-template-key]
   |  |     +--rw policy-template-key     fpc:fpc-identity
   |  |     +--rw policy-configuration* [index]
   |  |        +--rw index    uint16
   |  |        +--rw (policy-setting)?
   |  |           +--:(descriptor-value)
   |  |           +--:(action-value)
   |  +--rw basename?          fpc:fpc-identity
   |  +--rw base-checkpoint?   string
   +--rw policy-information-model
   |  +--rw action-template* [action-template-key]
   |  |  +--rw action-template-key            fpc:fpc-identity
   |  |  +--rw extensible?                    boolean
   |  |  +--rw mandatory-static-attributes*   string
   |  |  +--rw entity-state?                  enumeration
   |  +--rw descriptor-template* [descriptor-template-key]
   |  |  +--rw descriptor-template-key        fpc:fpc-identity
   |  |  +--rw extensible?                    boolean
   |  |  +--rw mandatory-static-attributes*   string
   |  |  +--rw entity-state?                  enumeration
   |  +--rw rule-template* [rule-template-key]
   |  |  +--rw rule-template-key              fpc:fpc-identity
   |  |  +--rw descriptor-match-type?         enumeration
   |  |  +--rw descriptor-configuration* [descriptor-template-key]
   |  |  |  +--rw descriptor-template-key    fpc:fpc-identity
   |  |  |  +--rw direction?                 rfc5777:direction-type
   |  |  |  +--rw attribute-expression* [index]
   |  |  |     +--rw index    uint16
   |  |  +--rw action-configuration* [action-order]
   |  |  |  +--rw action-order            uint32
   |  |  |  +--rw action-template-key     fpc:fpc-identity
   |  |  |  +--rw attribute-expression* [index]
   |  |  |     +--rw index    uint16
   |  |  +--rw extensible?                    boolean
   |  |  +--rw mandatory-static-attributes*   string
   |  |  +--rw entity-state?                  enumeration
   |  |  +--rw policy-configuration* [index]
   |  |     +--rw index    uint16
   |  |     +--rw (policy-setting)?
   |  |        +--:(descriptor-value)
   |  |        +--:(action-value)
   |  +--rw policy-template* [policy-template-key]
   |  |  +--rw policy-template-key            fpc:fpc-identity
   |  |  +--rw rule-template* [precedence]
   |  |  |  +--rw precedence           uint32
   |  |  |  +--rw rule-template-key    fpc:fpc-identity
   |  |  +--rw extensible?                    boolean
   |  |  +--rw mandatory-static-attributes*   string
   |  |  +--rw entity-state?                  enumeration
   |  |  +--rw policy-configuration* [index]
   |  |     +--rw index    uint16
   |  |     +--rw (policy-setting)?
   |  |        +--:(descriptor-value)
   |  |        +--:(action-value)
   |  +--rw basename?              fpc:fpc-identity
   |  +--rw base-checkpoint?       string
   +--rw mobility-context* [mobility-context-key]
   |  +--rw mobility-context-key    fpc:fpc-identity
   |  +--rw delegating-ip-prefix*   inet:ip-prefix
   |  +--rw parent-context?         fpc:fpc-identity
   |  +--rw child-context*          fpc:fpc-identity
   |  +--rw mobile-node
   |  |  +--rw ip-address*    inet:ip-address
   |  |  +--rw imsi?          fpcbase:imsi-type
   |  |  +--rw mn-settings* [policy-template-key]
   |  |     +--rw policy-template-key     fpc:fpc-identity
   |  |     +--rw policy-configuration* [index]
   |  |        +--rw index    uint16
   |  |        +--rw (policy-setting)?
   |  |           +--:(descriptor-value)
   |  |           +--:(action-value)
   |  +--rw domain
   |  |  +--rw domain-key?        fpc:fpc-identity
   |  |  +--rw domain-settings* [policy-template-key]
   |  |     +--rw policy-template-key     fpc:fpc-identity
   |  |     +--rw policy-configuration* [index]
   |  |        +--rw index    uint16
   |  |        +--rw (policy-setting)?
   |  |           +--:(descriptor-value)
   |  |           +--:(action-value)
   |  +--rw dpn* [dpn-key]
   |     +--rw dpn-key              fpc:fpc-identity
   |     +--rw dpn-settings* [policy-template-key]
   |     |  +--rw policy-template-key     fpc:fpc-identity
   |     |  +--rw policy-configuration* [index]
   |     |     +--rw index    uint16
   |     |     +--rw (policy-setting)?
   |     |        +--:(descriptor-value)
   |     |        +--:(action-value)
   |     +--rw role?                identityref
   |     +--rw service-data-flow* [identifier]
   |        +--rw identifier           uint32
   |        +--rw service-group-key?   fpc:fpc-identity
   |        +--rw interface* [interface-key]
   |        |  +--rw interface-key    fpc:fpc-identity
   |        +--rw flow-settings* [policy-template-key]
   |           +--rw policy-template-key fpc:fpc-identity
   |           +--rw policy-configuration* [index]
   |              +--rw index    uint16
   |              +--rw (policy-setting)?
   |                 +--:(descriptor-value)
   |                 +--:(action-value)
   +--rw monitor* [monitor-key]
   +--rw extensible?                    boolean
   +--rw mandatory-static-attributes*   string
   +--rw entity-state?                  enumeration
   +--rw monitor-key                    fpc:fpc-identity
   +--rw target?                        string
   +--rw binding-information
   +--rw deterrable?                    boolean
   +--rw (configuration)
   +--:(period)
   |  +--rw period?                        uint32
   +--:(threshold-config)
   |  +--rw low?                           uint32
   |  +--rw hi?                            uint32
   +--:(schedule)
   |  +--rw schedule?                      uint32
   +--:(event-identities)
   |  +--rw event-identities*              identityref
   +--:(event-ids)
   +--rw event-ids*                     uint32

   rpcs:
           +---x configure
           |  +---w input
           |  |  +---w client-id          fpc:client-identifier
           |  |  +---w execution-delay?   uint32
           |  |  +---w yang-patch
           |  |     +---w patch-id    string
           |  |     +---w comment?    string
           |  |     +---w edit* [edit-id]
           |  |        +---w edit-id         string
           |  |        +---w operation       enumeration
           |  |        +---w target          target-resource-offset
           |  |        +---w point?          target-resource-offset
           |  |        +---w where?          enumeration
           |  |        +---w value?          <anydata>
           |  |        +---w op-ref-scope?   fpc:ref-scope
           |  |        +---w instructions
           |  |           +---w (instr-type)?
           |  |              +--:(instr-3gpp-mob)
           |  |              |  +---w instr-3gpp-mob?
                                           fpcbase:threegpp-instr
           |  |              +--:(instr-pmip)
           |  |                 +---w instr-pmip?       pmip-commandset
           |  +--ro output
           |     +--ro yang-patch-status
           |        +--ro patch-id       string
           |        +--ro (global-status)?
           |        |  +--:(global-errors)
           |        |  |  +--ro errors
           |        |  |     +--ro error*
           |        |  |        +--ro error-type       enumeration
           |        |  |        +--ro error-tag        string
           |        |  |        +--ro error-app-tag?   string
           |        |  |        +--ro error-path?   instance-identifier
           |        |  |        +--ro error-message?   string
           |        |  |        +--ro error-info?      <anydata>
           |        |  +--:(ok)
           |        |     +--ro ok?            empty
           |        +--ro edit-status
           |           +--ro edit* [edit-id]
           |              +--ro edit-id            string
           |  +--rw dpn-set* [dpn-id]              +--ro (edit-status-choice)?
           |                 +--:(ok)
           |  +--rw dpn-id                            fpc:fpc-identity                 |  +--ro ok?                empty
           |  +--rw dpn-name?                         string                 |  +--ro notify-follows?    boolean
           |                 |  +--rw dpn-resource-mapping-reference?  +--ro subsequent-edit* [edit-id]
           |                 |     +--ro edit-id      string
           |                 |  +--rw interface-set* [access-technology role interface-id]     +--ro operation    enumeration
           |                 |     +--rw access-technology         identityref     +--ro target
           ypatch:target-resource-offset
           |                 |     +--rw role                      identityref     +--ro point?
           ypatch:target-resource-offset
           |                 |     +--rw interface-id              fpc:fpc-interface-id     +--ro where?       enumeration
           |                 |     +--rw interface-settings-set     +--ro value?       <anydata>
           |  +--rw dpn-type-set* [access-technology role]                 +--:(errors)
           |                    +--ro errors
           |  +--rw access-technology         identityref                       +--ro error*
           |                          +--ro error-type enumeration
           |  +--rw access-technology-name?                          +--ro error-tag        string
           |                          +--ro error-app-tag?   string
           |  +--rw role                      identityref
      |                          +--ro error-path?
           instance-identifier
           |  +--rw role-name?                          +--ro error-message?   string
           |                          +--ro error-info?      <anydata>
           +---x reg_monitor
           |  +--rw interface-set* [interface-id]  +---w input
           |  |     +--rw interface-id              fpc:fpc-interface-id  +---w client-id          fpc:client-identifier
           |  |     +--rw interface-name?           string  +---w execution-delay?   uint32
           |  |     +--rw interface-protocol-set*   identityref  +---w op-id              uint64
           |  |     +--rw feature-set*              identityref  +---w monitors* [monitor-key]
           |  |     +--rw interface-settings-set     +---w extensible?                    boolean
           |  +--rw dpn-group-set* [dpn-group-id]  |     +---w mandatory-static-attributes*   string
           |  +--rw dpn-group-id  |     +---w entity-state?                  enumeration
           |  |     +---w monitor-key            fpc:fpc-identity
           |  |  +--rw referenced-dpns-set*
                          [access-technology role interface-id]     +---w target?                        string
           |  |     +---w binding-information
           |  +--rw access-technology        identityref  |     +---w deterrable?                    boolean
           |  |  +--rw role                     identityref     +---w (configuration)
           |  |        +--:(period)
           |  +--rw interface-id             fpc:fpc-interface-id  |        |  +---w period?               uint32
           |  +--rw supporting-dpn-id-set*   fpc:fpc-identity  |        +--:(threshold-config)
           |  |  +--rw dpn-group-peer-id-set*   fpc:fpc-identity        |  +---w low?                  uint32
           |  +--rw dpn-group-peer-set* [remote-dpn-group-id]  |        |  +---w hi?                   uint32
           |  +--rw remote-dpn-group-id       fpc:fpc-identity  |        +--:(schedule)
           |  |  +--rw interface-settings-set        |  +---w schedule?             uint32
           |  +--rw domain-id?             fpc:fpc-identity  |  +--rw domain-set* [domain-id]        +--:(event-identities)
           |  |  +--rw domain-id           fpc:fpc-identity        |  +---w event-identities*     identityref
           |  +--rw domain-name?        string  |        +--:(event-ids)
           |  +--rw domain-reference?   string  |  +--rw basename?          fpc:fpc-identity           +---w event-ids*            uint32
           |  +--rw base-state?        string  +--ro output
           |  +--rw base-checkpoint?   string
      +--rw policy     +--ro op-id     uint64
           |  +--rw action-definition-set* [action-id]     +--ro (edit-status-choice)?
           |        +--:(ok)
           |  +--rw action-id      fpc:fpc-identity        |  +--ro ok?       empty
           |  +--rw action-type?   identityref        +--:(errors)
           |           +--ro errors
           |  +--rw (action-value)?              +--ro error*
           |  +--rw descriptor-definition-set* [descriptor-id]                 +--ro error-type       enumeration
           |                 +--ro error-tag        string
           |  +--rw descriptor-id      fpc:fpc-identity                 +--ro error-app-tag?   string
           |                 +--ro error-path?      instance-identifier
           |  +--rw descriptor-type?   identityref                 +--ro error-message?   string
           |                 +--ro error-info?      <anydata>
           +---x dereg_monitor
           |  +--rw (descriptor-value)?  +---w input
           |  +--rw rule-definition-set* [rule-id]  |  +---w client-id          fpc:client-identifier
           |  +--rw rule-id                     fpc:fpc-identity  |  +---w execution-delay?   uint32
           |  +--rw descriptor-match-type       enumeration  |  +---w op-id              uint64
           |  +--rw descriptor-reference-set* [descriptor-id-reference]  |  +---w monitor* [monitor-key]
           |  |  +--rw descriptor-id-reference     +---w monitor-key    fpc:fpc-identity
           |  |     +---w send_data?     boolean
           |  +--rw direction?                 fpc:fpc-direction-type  +--ro output
           |     +--ro op-id     uint64
           |     +--ro (edit-status-choice)?
           |  +--rw action-reference-set* [action-order]        +--:(ok)
           |        |     +--rw action-order           uint32  +--ro ok?       empty
           |        +--:(errors)
           |     +--rw action-id-reference    fpc:fpc-identity           +--ro errors
           |  +--rw policy-definition-set* [policy-id]              +--ro error*
           |                 +--ro error-type       enumeration
           |  +--rw policy-id    fpc:fpc-identity                 +--ro error-tag        string
           |                 +--ro error-app-tag?   string
           |  +--rw rule-set* [precedence]                 +--ro error-path?      instance-identifier
           |                 +--ro error-message?   string
           |     +--rw precedence                 +--ro error-info?      <anydata>
           +---x probe
           +---w input
           |  +---w client-id          fpc:client-identifier
           |  +---w execution-delay?   uint32
           |  +---w op-id              uint64
           |     +--rw rule-id-reference    fpc:fpc-identity  +---w monitor* [monitor-key]
           |  +--rw basename?     +---w monitor-key    fpc:fpc-identity
           +--ro output
           +--ro op-id     uint64
           +--ro (edit-status-choice)?
           +--:(ok)
           |  +--rw base-state?  +--ro ok?       empty
           +--:(errors)
           +--ro errors
           +--ro error*
           +--ro error-type       enumeration
           +--ro error-tag        string
           +--ro error-app-tag?   string
           +--ro error-path?      instance-identifier
           +--ro error-message?   string
           +--ro error-info?      <anydata>

           notifications:
           +---n config-result-notification
           |  +--rw base-checkpoint?  +--ro yang-patch-status
           |  |  +--ro patch-id       string
      +--rw installed-policy-list* [dpn-id-reference]
           |  +--rw dpn-id-reference        fpc:fpc-identity  |  +--rw installed-policy-set* [installed-policy-id]  +--ro (global-status)?
           |  |  +--rw installed-policy-id    fpc:fpc-identity  |  +--:(global-errors)
           |  +--rw policy-id-reference?   fpc:fpc-identity  |  |  +--rw policy-settings  |  +--rw settings-set  +--ro mobility-context-set* [mobility-context-id] errors
           |  +--ro mobility-context-id                     fpc:fpc-identity  |  +--ro dpn-group-id-reference?                 fpc:fpc-identity  |  +--ro parent-mobility-context-id-reference?   fpc:fpc-identity  |     +--ro dpn-reference-list* [dpn-id-reference direction] error*
           |  |  +--ro dpn-id-reference                 fpc:fpc-identity  |  |        +--ro direction
                                     fpc:fpc-direction-type error-type       enumeration
           |  |  +--ro dpn-settings-complementary  |  |        +--ro interface-id-reference           fpc:fpc-interface-id error-tag        string
           |  |  |  |        +--ro embedded-rule-set* [precedence] error-app-tag?   string
           |  |  |  |        +--ro rule-id                      fpc:fpc-identity error-path?      instance-identifier
           |  |  |  |        +--ro descriptor-match-type        enumeration error-message?   string
           |  |  |  |        +--ro precedence                   uint32 error-info?      <anydata>
           |  |  |  +--:(ok)
           |  |  |     +--ro action-definition-set* [action-order] ok?            empty
           |  |  +--ro edit-status
           |  |     +--ro action-order    uint32 edit* [edit-id]
           |  |        +--ro edit-id    string
           |  |        +--ro action-id?      fpc:fpc-identity (edit-status-choice)?
           |  |           +--:(ok)
           |  |           |  +--ro action-type?    identityref ok?        empty
           |  |           +--:(errors)
           |  |              +--ro (action-value)?
      | errors
           |  |                 +--ro descriptor-definition-set* [descriptor-id] error*
           |  |                    +--ro error-type       enumeration
           |  |                    +--ro descriptor-id      fpc:fpc-identity error-tag        string
           |  |                    +--ro error-app-tag?   string
           |  |                    +--ro descriptor-type?   identityref error-path?
                                               instance-identifier
           |  |                    +--ro error-message?   string
           |  |                    +--ro (descriptor-value)? error-info?      <anydata>
           |  +--ro subsequent-edit* [edit-id]
           |     +--ro assigned-policy-reference-set*   fpc:fpc-identity edit-id      string
           |     +--ro requested-policy-reference-set*         fpc:fpc-identity operation    enumeration
           |     +--ro context-settings-complementary
      +--rw monitor-set* [monitor-id]
         +--rw monitor-id             fpc:fpc-identity
         +--rw deterrable?            boolean
         +--rw binding-information
         +--rw target                 fpc-identity
         +--rw (configuration)
            +--:(periodic-config)       ypatch:target-resource-offset
           |  +--rw period?                uint32
            +--:(threshold-config)     +--ro point?       ypatch:target-resource-offset
           |  +--rw lo-thresh?             uint32     +--ro where?       enumeration
           |  +--rw hi-thresh?     +--ro value?       <anydata>
           +---n notify
           +--ro notification-id?   uint32
            +--:(scheduled-config)
            |  +--rw report-time?
           +--ro timestamp?         uint32
            +--:(events-config-ident)
           +--ro report* [monitor-key]
           +--ro monitor-key                 fpc:fpc-identity
           +--ro trigger?                    identityref
           +--ro (value)?
           +--:(dpn-candidate-available)
           |  +--rw event-identities*  +--ro node-id?                    inet:uri
           |  +--ro supported-interface-list* [role-key]
           |     +--ro role-key    identityref
            +--:(events-config)
               +--rw event-ids*             uint32
           +--:(dpn-unavailable)
           |  +--ro dpn-id?                     fpc:fpc-identity
           +--:(report-value)
           +--ro report-value?               <anydata>

                      Figure 23: 35: YANG FPC Agent Tree

Appendix B.  Changes since Version 09

   The following changes have been made since version 09

      Migration to a Template based framework.  This affects all
      elements.  The framework has a template definition language.

      Basename is split into two aspects.  The first is version which
      applies to Templates.  The second is checkpointing which applies
      to specific sections only.

      Rule was inside Policy and now is Rule-Template and stands as a
      peer structure to Policy.

      Types, e.g.  Descriptor Types, Action Types, etc., are now
      templates that have no values filled in.

      The embedded rule has been replaced by a template that has no
      predefined variables.  All rules, pre-configured or embedded, are
      realized as Policy instantiations.

      The Unassigned DPN is used to track requests vs.  those that are
      installed, i.e. Agent assignment of Policy is supported.

      The Topology system supports selection information by ServiceGroup
      or ServiceEndpoint.

      DPN Peer Groups and DPN Groups are now PeerServiceGroup and
      ServiceGroup.

      Bulk Configuration and Configuration now follow a style similar to
      YANG Patch.  Agents MAY response back with edits it made to
      complete the Client edit request.

      RFC 5777 Classifiers have been added.

      All operations have a common error format.

Authors' Addresses

   Satoru Matsushima
   SoftBank
   1-9-1,Higashi-Shimbashi,Minato-Ku
   Tokyo  105-7322
   Japan

   Email: satoru.matsushima@g.softbank.co.jp

   Lyle Bertz
   6220 Sprint Parkway
   Overland Park  KS, 66251
   USA

   Email: lylebe551144@gmail.com

   Marco Liebsch
   NEC Laboratories Europe
   NEC Europe Ltd.
   Kurfuersten-Anlage 36
   D-69115 Heidelberg
   Germany

   Phone: +49 6221 4342146
   Email: liebsch@neclab.eu

   Sri Gundavelli
   Cisco
   170 West Tasman Drive
   San Jose, CA  95134
   USA

   Email: sgundave@cisco.com
   Danny Moses

   Email: danny.moses@intel.com

   Charles E. Perkins
   Futurewei Inc.
   2330 Central Expressway
   Santa Clara, CA  95050
   USA

   Phone: +1-408-330-4586
   Email: charliep@computer.org