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 27: 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. 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 protocol [RFC6241]. 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 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 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 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

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 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 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 notification provides the same information that is sent as part of the input and output of the CONFIG and CONF_BUNDLE RPC operations.

General usage of FPC MUST consider the following:

• FPC Naming Section 4.4 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. 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-threegpp
   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-policyext
   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-pmip
   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-threegpp
  namespace:    urn:ietf:params:xml:ns:yang:ietf-dmm-threegpp
  prefix:       threegpp
  reference:    TBD1
  

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

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

  name:         ietf-dmm-traffic-selector-types
  namespace:    urn:ietf:params:xml:ns:yang:ietf-dmm-fpc-policyext
  prefix:       fpcpolicyext
  reference:    TBD1
  

  name:         ietf-dmm-traffic-selector-types
  namespace:    urn:ietf:params:xml:ns:yang:ietf-dmm-fpc-pmip
  prefix:       fpc-pmip
  reference:    TBD1
  

The document registers the following YANG submodules in the "YANG Module Names" registry [RFC6020].

        name:         ietf-dmm-fpc-base
        parent:       ietf-dmm-fpc
        reference:    TBD1
  

11. 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. References

12.1. Normative References

12.2. Informative References

Appendix A. YANG Data Model for the FPC protocol

These modules define YANG definitions. Seven modules are defined:

• ietf-dmm-fpc (fpc) - Defines the base model and messages for FPC
• ietf-dmm-fpc-base An FPC submodule that defines the information model that is specified in this document
• ietf-pmip-qos (pmip-qos) - Defines proxy mobile IPv6 QoS parameters per RFC 7222
• ietf-traffic-selectors-types (traffic-selectors) - Defines Traffic Selectors per RFC 6088
• ietf-dmm-threegpp - Defines the base structures for 3GPP based IP mobility and augments fpcagent to support these parameters.
• ietf-dmm-fpc-pmip - Augments fpcp-base to include PMIP Traffic Selectors as a Traffic Descriptor subtype and pmip-qos QoS parameters, where applicable, as properties.
• ietf-dmm-fpc-policyext - defines basic policy extensions, e.g. Actions and Descriptors, to fpcbase and as defined in this document.

A.1. FPC Agent YANG Model

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

This module references [RFC6991] and the fpc-base module defined in this document.

<CODE BEGINS> file "ietf-dmm-fpc@2017-03-08.yang"
module ietf-dmm-fpc {
    namespace "urn:ietf:params:xml:ns:yang:ietf-dmm-fpc";
    prefix fpc;

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

    include ietf-dmm-fpc-base;

    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>

        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-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-cloning {
      description "An ability to support cloning in the RPC.";
    }
    feature fpc-basename-registry {
      description "Ability to track Base Names already provisioned
        on the Agent";
    }
    feature fpc-bundles {
      description "Ability for Client to send multiple bundles of
        actions to an Agent";
    }
    feature fpc-client-binding {
      description "Allows a FPC Client to bind a DPN to an Topology
        Object";
    }
    feature fpc-auto-binding {
      description "Allows a FPC Agent to advertise Topology Objects
        that could be DPNs";
    }
    feature instruction-bitset {
      description "Allows the expression of instructions (bit sets)
        over FPC.";
    }
    feature operation-ref-scope {
      description "Provides the scope of refeneces in an operation.
        Used to optmize the Agent processing.";
    }
    feature policy-rpc-provisioning {
      description "Enables the ability to send policy elements
        (Policy Groups, Policies, Descriptors and Actions) to be sent
        in CONF or CONF_BUNDLE operations.";
    }

    typedef agent-identifier {
        type fpc:fpc-identity;
        description "Agent Identifier";
    }

    typedef client-identifier {
        type fpc:fpc-identity;
        description "Client Identifier";
    }

    grouping basename-info {
          leaf basename {
            if-feature fpc:fpc-basename-registry;
            type fpc:fpc-identity;
            description "Rules Basename";
          }
          leaf base-state {
            if-feature fpc:fpc-basename-registry;
            type string;
            description "Current State";
          }
          leaf base-checkpoint {
            if-feature fpc:fpc-basename-registry;
            type string;
            description "Checkpoint";
          }
          description "Basename Information";
    }

    // Top Level Structures
    container tenants {
        list tenant {
            key "tenant-id";
            leaf tenant-id {
                type fpc:fpc-identity;
                description "Tenant ID";
            }

            container fpc-policy {
              list policy-groups {
                  key "policy-group-id";
                  uses fpc:fpc-policy-group;
                  description "Policy Groups";
              }
              list policies {
                  key "policy-id";
                  uses fpc:fpc-policy;
                  description "Policies";
              }
              list descriptors {
                key descriptor-id;
                uses fpc:fpc-descriptor;
                description "Descriptors";
              }
              list actions {
                  key action-id;
                  uses fpc:fpc-action;
                  description "Actions";
              }
              description "Policy";
            }

            container fpc-mobility {
              config false;
              list contexts {
                  key context-id;
                  uses fpc:fpc-context;
                  description "Contexts";
              }
              list vports {
                  key vport-id;
                  uses fpc:fpc-vport;
                  description "Ports";
              }
              list monitors {
                  uses fpc:monitor-config;
                  description "Monitors";
              }
              description "Mobility";
            }
            container fpc-topology {
              // Basic Agent Topology Structures
              list domains {
                key domain-id;
                uses fpc:fpc-domain;
                uses fpc:basename-info;
                description "Domains";
              }

              leaf dpn-id {
                if-feature fpc:fpc-basic-agent;
                type fpc:fpc-dpn-id;
                description "DPN ID";
              }
              leaf-list control-protocols {
                if-feature fpc:fpc-basic-agent;
                type identityref {
                  base "fpc:fpc-dpn-control-protocol";
                }
                description "Control Protocols";
              }

              list dpn-groups {
                  if-feature fpc:fpc-multi-dpn;
                  key dpn-group-id;
                  uses fpc:fpc-dpn-group;
                  list domains {
                    key domain-id;
                    uses fpc:fpc-domain;
                    uses fpc:basename-info;
                    description "Domains";
                  }
                  description "DPN Groups";
              }
              list dpns {
                  if-feature fpc:fpc-multi-dpn;
                  key dpn-id;
                  uses fpc:fpc-dpn;
                  description "DPNs";
              }
              description "Topology";
            }
          description "Tenant";
        }
        description "Tenant List";
    }

    container fpc-agent-info {
      // General Agent Structures
      leaf-list supported-features {
        type string;
        description "Agent Features";
      }

      // Common Agent Info
      list supported-events {
        key event;
        leaf event {
          type identityref {
            base "fpc:event-type";
          }
          description "Event Types";
        }
        leaf event-id {
          type fpc:event-type-id;
          description "Event ID";
        }
        description "Supported Events";
      }

      list supported-error-types {
        key error-type;
        leaf error-type {
          type identityref {
            base "fpc:error-type";
          }
          description "Error Type";
        }
        leaf error-type-id {
          type fpc:error-type-id;
          description "Error Type ID";
        }
        description "Supported Error Types";
      }
      description "General Agent Information";
    }


    // Multi-DPN Agent Structures
    grouping fpc-dpn-group {
        leaf dpn-group-id {
            type fpc:fpc-dpn-group-id;
            description "DPN Group ID";
        }
        leaf data-plane-role {
            type identityref {
                base "fpc:fpc-data-plane-role";
            }
            description "Dataplane Role";
        }
        leaf access-type {
            type identityref {
                base "fpc:fpc-access-type";
            }
            description "Access Type";
        }
        leaf mobility-profile {
            type identityref {
                base "fpc:fpc-mobility-profile-type";
            }
            description "Mobility Profile";
        }
        list dpn-group-peers {
            key "remote-dpn-group-id";
            uses fpc:fpc-dpn-peer-group;
            description "Peer DPN Groups";
        }
        description "FPC DPN Group";
    }


    // RPC
    // RPC Specific Structures
    //Input Structures
    typedef admin-status {
        type enumeration {
            enum enabled {
              value 0;
              description "enabled";
            }
            enum disabled {
              value 1;
              description "disabled";
            }
            enum virtual {
              value 2;
              description "virtual";
            }
        }
        description "Adminstrative Status";
    }

    typedef session-status {
        type enumeration {
            enum complete {
              value 0;
              description "complete";
            }
            enum incomplete {
              value 1;
              description "incomplete";
            }
            enum outdated {
              value 2;
              description "outdated";
            }
        }
        description "Session Status";
    }

    typedef op-delay {
        type uint32;
        description "Operation Delay (ms)";
    }

    typedef op-identifier {
        type uint64;
        description "Operation Identifier";
    }

    typedef ref-scope {
      type enumeration {
        enum none {
          value 0;
          description "no references";
        }
        enum op {
          value 1;
          description "op - All references are contained in the
            operation body (intra-op)";
        }
        enum bundle {
          value 2;
          description "bundle - All references in exist in bundle
            (inter-operation/intra-bundle).
            NOTE - If this value comes in CONFIG call it is
              equivalent to 'op'.";
        }
        enum storage {
          value 3;
          description "storage - One or more references exist outside
            of the operation and bundle. A lookup to a cache /
            storage is required.";
        }
        enum unknown {
          value 4;
          description " unknown - the location of the references are
            unknown.  This is treated as a 'storage' type.";
        }
      }
      description "Search scope for references in the operation.";
    }

    grouping instructions {
      container instructions {
        if-feature instruction-bitset;
        choice instr-type {
          description "Instruction Value Choice";
        }
        description "Instructions";
      }
      description "Instructions Value";
    }

    grouping op-header {
      leaf client-id {
        type fpc:client-identifier;
        description "Client ID";
      }
      leaf delay {
        type op-delay;
        description "Delay";
      }
      leaf session-state {
        type session-status;
        description "Session State";
      }
      leaf admin-state {
        type admin-status;
        description "Admin State";
      }
      leaf op-type {
        type enumeration {
          enum create {
            value 0;
            description "create";
          }
          enum update {
            value 1;
            description "update";
          }
          enum query {
            value 2;
            description "query";
          }
          enum delete {
            value 3;
            description "delete";
          }
        }
        description "Type";
      }
      leaf op-ref-scope {
          if-feature operation-ref-scope;
          type fpc:ref-scope;
          description "Reference Scope";
      }
      uses fpc:instructions;
      description "Operation Header";
    }

    grouping clone-ref {
      leaf entity {
        type fpc:fpc-identity;
        description "Clone ID";
      }
      leaf source {
        type fpc:fpc-identity;
        description "Source";
      }
      description "Clone Reference";
    }

    identity command-set {
      description "protocol specific commands";
    }

    grouping context-operation {
      uses fpc:fpc-context;
      uses fpc:instructions;
      description "Context Operation";
    }

    // Output Structure
    grouping payload {
      list ports {
        uses fpc:fpc-vport;
        description "Ports";
      }
      list contexts {
        uses fpc:context-operation;
        description "Contexts";
      }
      list policy-groups {
        if-feature fpc:policy-rpc-provisioning;
        key "policy-group-id";
        uses fpc:fpc-policy-group;
        description "Policy Groups";
      }
      list policies {
        if-feature fpc:policy-rpc-provisioning;
        key "policy-id";
        uses fpc:fpc-policy;
        description "Policies";
      }
      list descriptors {
        if-feature fpc:policy-rpc-provisioning;
        key descriptor-id;
        uses fpc:fpc-descriptor;
        description "Descriptors";
      }
      list actions {
        if-feature fpc:policy-rpc-provisioning;
        key action-id;
        uses fpc:fpc-action;
        description "Actions";
      }
      description "Payload";
    }

    grouping op-input {
      uses fpc:op-header;
      leaf op-id {
        type op-identifier;
        description "Operation ID";
      }
      choice op_body {
        case create_or_update {
          list clones {
            if-feature fpc-cloning;
            key entity;
            uses fpc:clone-ref;
            description "Clones";
          }
          uses fpc:payload;
          description "Create/Update input";
        }
        case delete_or_query {
          uses fpc:targets-value;
          description "Delete/Query input";
        }
        description "Opeartion Input value";
      }
      description "Operation Input";
    }

    typedef result {
      type enumeration {
        enum ok {
          value 0;
          description "OK";
        }
        enum err {
          value 1;
          description "Error";
        }
        enum ok-notify-follows {
          value 2;
          description "OK with NOTIFY following";
        }
      }
      description "Result Status";
    }

    identity error-type {
      description "Base Error Type";
    }
    identity name-already-exists {
      description "Notification that an entity of the same name
        already exists";
    }

    typedef error-type-id {
      type uint32;
      description "Integer form of the Error Type";
    }

    grouping op-status-value {
      leaf op-status {
        type enumeration {
          enum ok {
            value 0;
            description "OK";
          }
          enum err {
            value 1;
            description "Error";
          }
        }
        description "Operation Status";
      }
      description "Operation Status Value";
    }

    grouping error-info {
          leaf error-type-id {
            type fpc:error-type-id;
            description "Error ID";
          }
          leaf error-info {
            type string {
              length "1..1024";
            }
            description "Error Detail";
          }
          description "Error Information";
    }

    grouping result-body {
      leaf op-id {
        type op-identifier;
        description "Operation Identifier";
      }
      choice result-type {
        case err {
          uses fpc:error-info;
          description "Error Information";
        }
        case create-or-update-success {
          uses fpc:payload;
          description "Create/Update Success";
        }
        case delete_or_query-success {
          uses fpc:targets-value;
          description "Delete/Query Success";
        }
        case empty-case {
          description "Empty Case";
        }
        description "Result Value";
      }
      description "Result Body";
    }

    // Common RPCs
    rpc configure {
      description "CONF message";
      input {
        uses fpc:op-input;
      }
      output {
        leaf result {
          type result;
          description "Result";
        }
        uses fpc:result-body;
      }
    }

    rpc configure-bundles {
      if-feature fpc:fpc-bundles;
      description "CONF_BUNDLES message";
      input {
        leaf highest-op-ref-scope {
            if-feature operation-ref-scope;
            type fpc:ref-scope;
            description "Highest Op-Ref used in the input";
        }
        list bundles {
          key op-id;
          uses fpc:op-input;
          description "List of operations";
        }
      }
      output {
        list bundles {
          key op-id;
          uses fpc:result-body;
          description "Operation Identifier";
        }
      }
    }

    // Notification Messages & Structures
    typedef notification-id {
      type uint32;
      description "Notification Identifier";
    }

    grouping notification-header {
      leaf notification-id {
          type fpc:notification-id;
          description "Notification ID";
      }
      leaf timestamp {
          type uint32;
          description "timestamp";
      }
      description "Notification Header";
    }

    notification config-result-notification {
      uses fpc:notification-header;
      choice value {
        case config-result {
          uses fpc:op-status-value;
          uses fpc:result-body;
          description "CONF Result";
        }
        case config-bundle-result {
          list bundles {
            uses fpc:op-status-value;
            uses fpc:result-body;
            description "Operation Results";
          }
          description "CONF_BUNDLES Result";
        }
        description "Config Result value";
      }
      description "CONF/CONF_BUNDLES Async Result";
    }

    rpc event_register {
      description "Used to register monitoring of parameters/events";
        input {
          uses fpc:monitor-config;
        }
        output {
          leaf monitor-result {
            type fpc:result;
            description "Result";
          }
          uses fpc:error-info;
        }
    }

    rpc event_deregister {
      description "Used to de-register monitoring of
          parameters/events";
        input {
          list monitors {
            uses fpc:monitor-id;
            description "Monitor ID";
          }
        }
        output {
          leaf monitor-result {
            type fpc:result;
            description "Result";
          }
          uses fpc:error-info;
        }

    }

    rpc probe {
        description "Probe the status of a registered monitor";
        input {
          uses fpc:targets-value;
        }
        output {
          leaf monitor-result {
            type fpc:result;
            description "Result";
          }
          uses fpc:error-info;
        }
    }

    notification notify {
        uses fpc:notification-header;
        choice value {
            case dpn-candidate-available {
              if-feature fpc:fpc-auto-binding;
              leaf node-id {
                type inet:uri;
                description "Topology URI";
              }
              leaf-list access-types {
                type identityref {
                  base "fpc:fpc-access-type";
                }
                description "Access Types";
              }
              leaf-list mobility-profiles {
                type identityref {
                  base "fpc:fpc-mobility-profile-type";
                }
                description "Mobility Profiles";
              }
              leaf-list forwarding-plane-roles {
                type identityref {
                  base "fpc:fpc-data-plane-role";
                }
                description "Forwarding Plane Role";
              }
              description "DPN Candidate Availability";
            }
            case monitor-notification {
              choice monitor-notification-value {
                case monitoring-suspension {
                  leaf monitoring-suspended {
                    type empty;
                    description "Indicates that monitoring has
                      uspended";
                  }
                  leaf suspension-note {
                    type string;
                    description "Indicates the monitoring
                      suspension reason";
                  }
                }
                case monitoring-resumption {
                  leaf monitoring-resumed {
                    type empty;
                    description "Indicates that monitoring
                      has resumed";
                  }
                }
                case simple-monitor {
                  uses fpc:report;
                  description "Report";
                }
                case bulk-monitors {
                  list reports {
                    uses fpc:report;
                    description "Reports";
                  }
                  description "Bulk Monitor Response";
                }
                description "Monitor Notification value";
              }
              description "Monitor Notification";
            }
            description "Notify Value";
        }
        description "Notify Message";
    }
}
<CODE ENDS>

A.2. YANG Models

A.2.1. FPC YANG Model

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

This module references [RFC6991].

<CODE BEGINS> file "ietf-dmm-fpc-base@2017-03-08.yang"
submodule ietf-dmm-fpc-base {
    belongs-to ietf-dmm-fpc {
       prefix fpc;
    }

    import ietf-inet-types { prefix inet; revision-date 2013-07-15; }
    import ietf-yang-types { prefix ytypes;
        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>

        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-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-basic-agent {
        description "This is an agent co-located with a DPN.  In this
        case only DPN Peer Groups, the DPN Id and Control Protocols
        are exposed along with the core structures.";
    }
    feature fpc-multi-dpn {
        description "The agent supports multiple DPNs.";
    }

    typedef fpc-identity {
        type union {
            type uint32;
            type string;
            type instance-identifier;
        }
        description "FPC Identity";
    }

    grouping target-value {
      leaf target {
          type fpc-identity;
          description "Target Identity";
      }
      description "FPC Target Value";
    }

    grouping targets-value {
      list targets {
          key "target";
          leaf target {
            type fpc-identity;
            description "Target Id";
          }
          leaf dpn-id {
                type fpc:fpc-dpn-id;
                description "DPN Id";
          }
          description "List of Targets";
      }
      description "Targets Value";
    }

    // Descriptor Structure
    typedef fpc-descriptor-id-type {
        type fpc:fpc-identity;
        description "Descriptor-ID";
    }
    identity fpc-descriptor-type {
        description "A traffic descriptor";
    }
    grouping fpc-descriptor-id {
      leaf descriptor-id {
        type fpc:fpc-identity;
        description "Descriptor Id";
      }
      description "FPC Descriptor ID value";
    }
    grouping fpc-descriptor {
        uses fpc:fpc-descriptor-id;
        leaf descriptor-type {
          type identityref {
            base "fpc-descriptor-type";
          }
          mandatory true;
          description "Descriptor Type";
        }
        choice descriptor-value {
          case all-traffic {
            leaf all-traffic {
              type empty;
              description "Empty Value";
            }
          }
          description "Descriptor Value";
        }
        description "FPC Descriptor";
    }

    // Action Structure
    typedef fpc-action-id-type {
        type fpc:fpc-identity;
        description "Action-ID";
    }
    identity fpc-action-type {
        description "Action Type";
    }
    grouping fpc-action-id {
      leaf action-id {
        type fpc:fpc-action-id-type;
        description "Action Identifier";
      }
      description "FPC Action ID";
    }
    grouping fpc-action {
        uses fpc:fpc-action-id;
        leaf action-type {
          type identityref {
            base "fpc-action-type";
          }
          mandatory true;
          description "Action Type";
        }
        choice action-value {
          case drop {
            leaf drop {
              type empty;
              description "Empty Value";
            }
          }
          description "FPC Action Value";
        }
        description "FPC Action";
    }

    // Rule Structure
    grouping fpc-rule {
        list descriptors {
          key descriptor-id;
          uses fpc:fpc-descriptor-id;
          leaf direction {
            type fpc:fpc-direction;
            description "Direction";
          }
          description "Descriptors";
        }
        list actions {
          key action-id;
          leaf action-order {
              type uint32;
              description "Action Execution Order";
          }
          uses fpc:fpc-action-id;
          description "Actions";
        }
        description
          "FPC Rule.  When no actions are present the action is DROP.
          When no Descriptors are empty the default is
          'all traffic'.";
    }

    // Policy Structures
    typedef fpc-policy-id {
        type fpc:fpc-identity;
        description "Policy Identifier";
    }
    grouping fpc-policy {
        leaf policy-id {
            type fpc:fpc-policy-id;
            description "Policy Id";
        }
        list rules {
            key order;
            leaf order {
              type uint32;
              description "Rule Order";
            }
            uses fpc:fpc-rule;
            description "Rules";
        }
        description "FPC Policy";
    }

    // Policy Group
    typedef fpc-policy-group-id {
        type fpc:fpc-identity;
        description "Policy Group Identifier";
    }
    grouping fpc-policy-group {
      leaf policy-group-id {
        type fpc:fpc-policy-group-id;
        description "Policy Group ID";
      }
      leaf-list policies {
        type fpc:fpc-policy-id;
        description "Policies";
      }
      description "FPC Policy Group";
    }

    // Mobility Structures
    // Port Group
    typedef fpc-vport-id {
        type fpc:fpc-identity;
        description "FPC Port Identifier";
    }
    grouping fpc-vport {
        leaf vport-id {
            type fpc:fpc-vport-id;
            description "Port ID";
        }
        leaf-list policy-groups {
            type fpc:fpc-policy-group-id;
            description "Policy Groups";
        }
        description "FPC Port";
    }

    // Context Group
    typedef fpc-context-id {
        type fpc:fpc-identity;
        description "FPC Context Identifier";
    }
    grouping fpc-context-profile {
        leaf tunnel-local-address {
            type inet:ip-address;
            description "endpoint address of the DPN which a
              gent exists.";
        }
        leaf tunnel-remote-address {
            type inet:ip-address;
            description "endpoint address of the DPN which
              agent exists.";
        }
        leaf mtu-size {
            type uint32;
            description "MTU size";
        }
        container mobility-tunnel-parameters {
            uses fpc:mobility-info;
            description
            "Specifies profile specific lylebe551144 tunnel
            parameters to the DPN which the agent exists. The
            profiles includes GTP/TEID for 3gpp profile, GRE/Key for
            ietf-pmip profile, or new profile if anyone will define
            it.";
        }
        container nexthop {
            uses fpc:fpc-nexthop;
            description "Next Hop";
        }
        container qos-profile-parameters {
            uses fpc:fpc-qos-profile;
            description "QoS Parameters";
        }
        container dpn-parameters {
            description "DPN Parameters";
        }
        list vendor-parameters {
            key "vendor-id vendor-type";
            uses fpc:vendor-attributes;
            description "Vendor Parameters";
        }
        description "A profile that applies to a specific direction";
    }

    typedef fpc-direction {
       type enumeration {
         enum lylebe551144 {
           description "lylebe551144";
         }
         enum downlink {
           description "Downlink";
         }
         enum both {
           description "Both";
        }
       }
       description "FPC Direction";
    }

    grouping fpc-context {
        leaf context-id {
            type fpc:fpc-context-id;
            description "Context ID";
        }
        leaf-list vports {
            type fpc:fpc-vport-id;
            description "Vports";
        }
        leaf dpn-group {
          type fpc:fpc-dpn-group-id;
          description "DPN Group";
        }
        leaf-list delegated-ip-prefixes {
            type inet:ip-prefix;
            description "Delegated Prefix(es)";
        }
        container ul {
            if-feature fpc:fpc-basic-agent;
            uses fpc:fpc-context-profile;
            description "lylebe551144";
        }
        container dl {
            if-feature fpc:fpc-basic-agent;
            uses fpc:fpc-context-profile;
            description "Downlink";
        }
        list dpns {
            if-feature fpc:fpc-multi-dpn;
            key "dpn-id direction";
            leaf dpn-id {
                type fpc:fpc-dpn-id;
                description "DPN";
            }
            leaf direction {
                type fpc:fpc-direction;
                mandatory true;
                description "Direction";
            }
            uses fpc:fpc-context-profile;
            description "DPNs";
        }
        leaf parent-context {
            type fpc:fpc-context-id;
            description "Parent Context";
        }
        description "FCP Context";
    }

    // Mobility (Tunnel) Information
    grouping mobility-info {
        choice profile-parameters {
            case nothing {
              leaf none {
                type empty;
                description "Empty Value";
              }
              description "No Parameters Case";
            }
            description "Mobility Profile Parameters";
        }
        description "Mobility Information";
    }

    // Next Hop Structures
    typedef fpc-service-path-id {
        type uint32 {
            range "0..33554431";
        }
        description "SERVICE_PATH_ID";
    }
    typedef fpc-mpls-label {
        type uint32 {
          range "0..1048575";
        }
        description "MPLS label";
    }

    identity fpc-nexthop-type {
        description "Next Hop Type";
    }
    identity fpc-nexthop-ip {
        base "fpc:fpc-nexthop-type";
        description "Nexthop IP";
    }
    identity fpc-nexthop-servicepath {
        base "fpc:fpc-nexthop-type";
        description "Nexthop Service Path";
    }
    identity fpc-nexthop-mac {
        base "fpc:fpc-nexthop-type";
        description "Nexthop MAC-Address";
    }
    identity fpc-nexthop-mpls {
        base "fpc:fpc-nexthop-type";
        description "Nexthop MPLS";
    }
    identity fpc-nexthop-if {
        base "fpc:fpc-nexthop-type";
        description "Nexthop If index";
    }
    grouping fpc-nexthop {
        leaf nexthop-type {
            type identityref {
              base "fpc:fpc-nexthop-type";
            }
            description "Nexthop Type";
        }
        choice nexthop-value {
            case ip-nexthop {
                leaf ip {
                  type inet:ip-address;
                  description "IP Value";
                }
                description "IP Case";
            }
            case macaddress-nexthop {
                leaf macaddress {
                  type ytypes:mac-address;
                  description "MAC Address Value";
                }
            }
            case servicepath-nexthop {
                leaf servicepath {
                    type fpc:fpc-service-path-id;
                    description "Service Path Value";
                }
                description "Service Path Case";
            }
            case mplslabel-nexthop {
                leaf lsp {
                    type fpc:fpc-mpls-label;
                    description "MPLS Value";
                }
                description "Service Path Case";
            }
            case if-nexthop {
                leaf if-index {
                    type uint16;
                    description "If (interface) Value";
                }
                description "Service Path Case";
            }
            description "Value";
        }
        description "Nexthop Value";
    }

    // QoS Information
    identity fpc-qos-type {
        description "Base identity from which specific uses of QoS
          types are derived.";
    }
    grouping fpc-qos-profile {
        leaf qos-type {
            type identityref {
                base fpc:fpc-qos-type;
            }
            description "the profile type";
        }
        choice value {
            description "QoS Value";
        }
        description "QoS Profile";
    }

    // Vendor Specific Attributes
    identity vendor-specific-type {
        description "Vendor Specific Attribute Type";
    }
    grouping vendor-attributes {
        leaf vendor-id {
            type fpc:fpc-identity;
            description "Vendor ID";
        }
        leaf vendor-type {
            type identityref {
                base "fpc:vendor-specific-type";
            }
            description "Attribute Type";
        }
        choice value {
            case empty-type {
                leaf empty-type {
                    type empty;
                    description "Empty Value";
                }
                description "Empty Case";
            }
            description "Atttribute Value";
        }
        description "Vendor Specific Attributes";
    }

    // Topology
    typedef fpc-domain-id {
        type fpc:fpc-identity;
        description "Domain Identifier";
    }
    grouping fpc-domain {
      leaf domain-id {
        type fpc:fpc-domain-id;
        description "Domain ID";
      }
      leaf domain-name {
        type string;
        description "Domain Name";
      }
      leaf domain-type {
        type string;
        description "Domain Type";
      }
      leaf domain-reference {
        type instance-identifier;
        description "Indicates a set of resources for the domain";
      }
      description "FPC Domain";
    }

    typedef fpc-dpn-id {
        type fpc:fpc-identity;
        description "DPN Identifier";
    }
    identity fpc-dpn-control-protocol {
        description "DPN Control Protocol";
    }
    grouping fpc-dpn {
        leaf dpn-id {
          type fpc:fpc-dpn-id;
          description "DPN ID";
        }
        leaf dpn-name {
          type string;
          description "DPN Name";
        }
        leaf-list dpn-groups {
          type fpc:fpc-dpn-group-id;
          description "DPN Groups";
        }
        leaf node-reference {
          type instance-identifier;
          description "DPN => Node (Topology) Mapping";
        }
        description "FPC DPN";
    }

    typedef fpc-dpn-group-id {
        type fpc:fpc-identity;
        description "DPN Group Identifier";
    }
    identity fpc-data-plane-role {
        description "Role of DPN Group in the Forwarding Plane";
    }
    identity fpc-access-dpn-role {
       base "fpc:fpc-data-plane-role";
       description "Access DPN Role";
    }
    identity fpc-anchor-dpn-role {
       base "fpc:fpc-data-plane-role";
       description "Anchor DPN Role";
    }

    identity fpc-access-type {
        description "Access Type of the DPN Group";
    }
    identity fpc-mobility-profile-type {
        description "Mobility Profile Type";
    }

    grouping fpc-dpn-peer-group {
        leaf remote-dpn-group-id {
            type fpc:fpc-dpn-group-id;
            description "Remote DPN Group ID";
        }
        leaf remote-mobility-profile {
            type identityref {
                base "fpc:fpc-mobility-profile-type";
            }
            description "Mobility Profile";
        }
        leaf remote-data-plane-role {
            type identityref {
                base "fpc:fpc-data-plane-role";
            }
            description "Forwarding Plane Role";
        }
        leaf remote-endpoint-address {
            type inet:ip-address;
            description "Remote Endpoint Address";
        }
        leaf local-endpoint-address {
            type inet:ip-address;
            description "Local Endpoint Address";
        }
        leaf mtu-size {
            type uint32;
            description "MTU Size";
        }
        description "FPC DPN Peer Group";
    }

    // Events, Probes & Notifications
    identity event-type {
        description "Base Event Type";
    }
    typedef event-type-id {
        type uint32;
        description "Event ID Type";
    }

    grouping monitor-id {
      leaf monitor-id {
        type fpc:fpc-identity;
        description "Monitor Identifier";
      }
      description "Monitor ID";
    }

    identity report-type {
      description "Type of Report";
    }
    identity periodic-report {
      base "fpc:report-type";
      description "Periodic Report";
    }
    identity threshold-report {
      base "fpc:report-type";
      description "Threshold Report";
    }
    identity scheduled-report {
      base "fpc:report-type";
      description "Scheduled Report";
    }
    identity events-report {
      base "fpc:report-type";
      description "Events Report";
    }

    grouping report-config {
      choice event-config-value {
        case periodic-config {
            leaf period {
              type uint32;
              description "Period";
            }
            description "Periodic Config Case";
        }
        case threshold-config {
            leaf lo-thresh {
              type uint32;
              description "lo threshold";
            }
            leaf hi-thresh {
              type uint32;
              description "hi threshold";
            }
            description "Threshold Config Case";
        }
        case scheduled-config {
            leaf report-time {
              type uint32;
              description "Reporting Time";
            }
            description "Scheduled Config Case";
        }
        case events-config-ident {
            leaf-list event-identities {
              type identityref {
                base "fpc:event-type";
              }
              description "Event Identities";
            }
            description "Events Config Identities Case";
        }
        case events-config {
            leaf-list event-ids {
              type uint32;
              description "Event IDs";
            }
            description "Events Config Case";
        }
        description "Event Config Value";
      }
      description "Report Configuration";
    }

    grouping monitor-config {
      uses fpc:monitor-id;
      uses fpc:target-value;
      uses fpc:report-config;
      description "Monitor Configuration";
    }

    grouping report {
      uses fpc:monitor-config;
      choice report-value {
        leaf trigger {
          type fpc:event-type-id;
          description "Trigger Identifier";
        }
        case simple-empty {
          leaf nothing {
            type empty;
            description "Empty Value";
          }
          description "Empty Case";
        }
        case simple-val32 {
          leaf val32 {
            type uint32;
            description "Unsigned 32 bit value";
          }
          description "Simple Value Case";
        }
        description "Report Value";
      }
      description "Monitor Report";
    }
}
<CODE ENDS>

A.2.2. PMIP QoS Model

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

This module references [RFC6991] and the traffic-selector-types module defined in this document.

<CODE BEGINS> file "ietf-pmip-qos@2016-02-10.yang"
module ietf-pmip-qos {
    yang-version 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-traffic-selector-types { prefix traffic-selectors; }

    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>

        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 2016-02-10 {
        description "Initial revision";
        reference
         "RFC 7222: Quality-of-Service Option for Proxy Mobile IPv6";
    }

    // 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.  Its uniqueness is
        within the scope of a mobility session.  The local mobility
        anchor always allocates the Service Request Identifier.
        When a new QoS Service Request is initiated by a mobile
        access gateway, the Service Request Identifier in the initial
        request message is set to a value of (0), and the local
        mobility anchor allocates a Service Request Identifier and
        includes it in the response.  For any new QoS Service
        Requests initiated by a local mobility anchor, the
        Service Request Identifier is set to the allocated value.";
    }

    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
       "1-octet Operational code indicates 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
    typedef qos-attrubite-type-enum {
        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
        "8-bit unsigned integer indicating 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;
      description
          "This is a 32-bit unsigned integer that
          indicates the aggregate maximum downlink bit rate that is
          requested/allocated for all the mobile node's IP flows.
          The measurement units for Per-MN-Agg-Max-DL-Bit-Rate are
          bits per second.";
    }

    typedef Per-MN-Agg-Max-UL-Bit-Rate-Value {
        type uint32;
        description
            "This is a 32-bit unsigned integer that
              indicates the aggregate maximum uplink bit rate that is
            requested/allocated for the mobile node's IP flows.  The
            measurement units for Per-MN-Agg-Max-UL-Bit-Rate 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
       "This is a 32-bit unsigned integer
        that indicates the aggregate maximum bit rate that is
        requested/allocated for all the IP flows associated with
        that mobility session.  The measurement units for
        Per-Session-Agg-Max-UL/DL-Bit-Rate 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. 3GPP Access Point Name
            (APN) is an example of a Service Identifier, and that
            identifier is carried using the Service Selection mobility
            option [RFC5149].

            -  When the (S) flag is set to a value of (1), then the
               Per-Session-Agg-Max-Bit-Rate is measured as an
               aggregate across all the mobile node's other mobility
               sessions sharing the same Service Identifier associated
               with this mobility session.

            -  When the (S) flag is set to a value of (0), then the
               target flows are limited to the current mobility
               session.

            -  The (S) flag MUST NOT be set to a value of (1) when there
               is no Service Identifier associated with the mobility
               session.";
            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.

            -  When the (E) flag is set to a value of (1), then the
               request is to exclude the IP flows for which
               Guaranteed-UL/DL-Bit-Rate is negotiated from the flows
               for which Per-Session-Agg-Max-UL/DL-Bit-Rate
                   is measured.

            -  When the (E) flag is set to a value of (0), then the
               request is not to exclude any IP flows from the target
               IP flows for which Per-Session-Agg-Max-UL/DL-Bit-Rate
               is measured.

            -  When the (S) flag and (E) flag are both set to a value
               of (1), then the request is to exclude all the IP flows
               sharing the Service Identifier associated with this
               mobility session from the target 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.  The priority level can also be used to
        decide which existing mobility session to preempt during
        resource limitations.  The priority level defines the
        relative timeliness of a resource request.

        Values 1 to 15 are defined, with value 1 as the highest level
        of priority.

        Values 1 to 8 should only be assigned for services that are
        authorized to receive prioritized treatment within an
        operator domain.  Values 9 to 15 may be assigned to resources
        that are authorized by the home network and thus applicable
        when a mobile node is roaming.";
        }
        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.  The following values are defined:

         Enabled (0): This value indicates that the service data flow
         is allowed to get resources that were already assigned to
         another IP data flow with a lower priority level.

         Disabled (1): This value indicates that the service data flow
         is not allowed to get resources that were already assigned to
         another IP data flow with a lower priority level.  The values
         (2) and (3) are reserved.";
        }
        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.  The following values are defined:

           Enabled (0): This value indicates that the resources
           assigned to the IP data flow can be preempted and
           allocated to a service data flow with a higher
           priority level.

           Disabled (1): This value indicates that the resources
           assigned to the IP data flow shall not be preempted and
           allocated to a service data flow with a higher priority
           level.  The values (2) and (3) are reserved.";
        }
    description "Allocation-Retention-Priority Value";
    }

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

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

    typedef Guaranteed-DL-Bit-Rate-Value {
        type uint32;
        description
            "This is a 32-bit unsigned integer that
         indicates the guaranteed bandwidth in bits per second for
         downlink IP flows.  The measurement units for
         Guaranteed-DL-Bit-Rate are bits per second.";
    }

    typedef Guaranteed-UL-Bit-Rate-Value {
        type uint32;
        description
            "This is a 32-bit unsigned integer that
         indicates the guaranteed bandwidth in bits per second
         for uplink IP flows.  The measurement units for
         Guaranteed-UL-Bit-Rate 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 {
            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;
                    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";
    }

    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;
            description "Attributes";
        }
        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-traffic-selector-types@2016-01-14.yang"
module ietf-traffic-selector-types {
 yang-version 1;

 namespace
 "urn:ietf:params:xml:ns:yang:ietf-traffic-selector-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>

 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 2016-01-14 {
    description "Updated for IETF-PACKET-FIELDS module alignment";
    reference
        "draft-ietf-netmod-acl-model-06";
 }

 revision 2016-01-12 {
 description "Initial revision";
 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
            "This type defines the first 32-bit IPsec
             Security Parameter Index (SPI) value on data
             packets sent from a corresponding node to the
       mobile node as seen by the home agent. 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
         "This field identifies the first 32-bit IPsec SPI value,
         from the range of SPI values to be matched, on data
         packets sent from a corresponding node to the mobile
         node as seen by the home agent.
         This field is defined in [RFC4303].";
            }
            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 can be used to indicate the end value of
        a range starting from the value of the Start SPI field.
        This field MUST NOT be included unless the Start SPI
        field is included and has a value less than or equal to
        this field.

        When this field is included, the receiver will match all
        of the SPI values between fields start-spi and end-spi,
        inclusive of start-spi and end-spi.";
            }
     }
     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.";
         leaf start-port {
            type inet:port-number;
            mandatory true;
            description
         "This field identifies the first 16-bit source port number,
         from the range of port numbers to be matched, on data
         packets sent from a corresponding node to the mobile node
         as seen by the home agent.
         This is from the range of port numbers defined by IANA
               (http://www.iana.org).";
         }
         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
         "If more than one contiguous source port number needs to be
          matched, then this field can be used to indicate the end
          value of a range starting from the value of the Start
          Port field. This field MUST NOT be included unless the
          Start Port field is included and has a value less than
          or equal to this field.

          When this field is included, the receiver will match
          all of the port numbers between fields start-port and
          end-port, inclusive of start-port and end-port.";
            }
     }
     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
          "This field identifies the first 16-bit destination port
          number, from the range of port numbers to be matched, on
          data packets sent from a corresponding node to the mobile
          node as seen by the home agent.";
            }
            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
        "If more than one contiguous destination port number needs
        to be matched, then this field can be used to indicate
        the end value of a range starting from the value of the
        Start Destination Port field. This field MUST NOT be
        included unless the Start Port field is included and has
        a value less than or equal to this field.

        When this field is included, the receiver will match
        all of the port numbers between fields start-port and
        end-port, inclusive of start-port and end-port.";
        }
    }
 }

 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
        "This field identifies the first source address, from the range
        of 32-bit IPv4 addresses to be matched, on data packets sent
        from a corresponding node to the mobile node as seen by the
        home agent. In other words, this is one of the addresses of
        the correspondent node.";
         }
         leaf end-address {
             type inet:ipv4-address;
             description
         "If more than one contiguous source address needs to be
         matched, then this field can be used to indicate the end
         value of a range starting from the value of the Start
         Address field. This field MUST NOT be included unless the
         Start Address field is included. When this field is
         included, the receiver will match all of the addresses
         between fields start-address and end-address, inclusive of
         start-address and end-address.";
            }
     }
     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
         "This field identifies the first destination address, from the
         range of 32-bit IPv4 addresses to be matched, on data packets
         sent from a corresponding node to the mobile node as seen by
         the home agent. In other words, this is one of the registered
         home addresses of the mobile node.";
         }
         leaf end-address {
           type inet:ipv4-address;
             description
         "If more than one contiguous destination address needs to be
         matched, then this field can be used to indicate the end
         value of a range starting from the value of the Start
         Destination Address field. This field MUST NOT be included
         unless the Start Address field is included. When this field
         is included, the receiver will match all of the addresses
         between fields start-address and end-address, inclusive of
         start-address and end-address.";
         }
     }
     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
         "This field identifies the first differential service value,
         from the range of differential services values to be
         matched, on data packets sent from a corresponding node to
         the mobile node as seen by the home agent. Note that this
         field is called a 'Type of Service field' in [RFC0791].
         [RFC3260] then clarified that the field has been redefined
         as a 6-bit DS field with 2 bits reserved, later claimed by
         Explicit Congestion Notification (ECN) [RFC3168]. For the
         purpose of this specification, the Start DS field is 8 bits
         long, where the 6 most significant bits indicate the DS field
         to be matched and the 2 least significant bits' values MUST be
         ignored in any comparison.";
    }
    leaf end-ds {
      type inet:dscp;
      must ". >= ../start-ds" {
        error-message
          "The end-ds must be greater than or equal to start-ds";
      }
      description
       "If more than one contiguous DS value needs to be matched, then
       this field can be used to indicate the end value of a range
       starting from the value of the Start DS field. This field MUST
       NOT be included unless the Start DS field is included. When this
       field is included, it MUST be coded the same way as defined for
       start-ds. When this field is included, the receiver will match
       all of the values between fields start-ds and end-ds, inclusive
       of start-ds and end-ds.";
     }
  }
    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
        "This field identifies the first 8-bit protocol value, from the
         range of protocol values to be matched, on data packets sent
         from a corresponding node to the mobile node as seen by the
         home agent.";
        }
        leaf end-protocol {
            type uint8;
        must ". >= ../start-protocol" {
          error-message
            "The end-protocol must be greater than or equal to
          start-protocol";
        }
            description
       "If more than one contiguous protocol value needs to be matched,
       then this field can be used to indicate the end value of a range
       starting from the value of the Start Protocol field. This field
       MUST NOT be included unless the Start Protocol field is
       included. When this field is included, the receiver will match
       all of the values between fields start-protocol and
       end-protocol, inclusive of start-protocol and end-protocol.";
        }
     }
   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
        "This field identifies the first source address, from the
        range of 128-bit IPv6 addresses to be matched, on data
        packets sent from a corresponding node to the mobile node as
        seen by the home agent. In other words, this is one of the
        addresses of the correspondent node.";
      }
      leaf end-address {
        type inet:ipv6-address;
        description
         "If more than one contiguous source address needs to be
         matched, then this field can be used to indicate the end
         value of a range starting from the value of the Start
         Address field. This field MUST NOT be included unless the
         Start Address field is included. When this field is
         included, the receiver will match all of the addresses
         between fields start-address and end-address, inclusive of
         start-address and end-address .";
      }
   }
   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
         "This field identifies the first destination address, from
         the range of 128-bit IPv6 addresses to be matched, on data
         packets sent from a corresponding node to the mobile node as
         seen by the home agent. In other words, this is one of the
         registered home addresses of the mobile node.";
     }
     leaf end-address {
       type inet:ipv6-address;
       description
         "If more than one contiguous destination address needs to be
          matched, then this field can be used to indicate the end
          value of a range starting from the value of the Start
          Address field. This field MUST NOT be included unless the
          Start Address field is included. When this field is
          included, the receiver will match all of the addresses
          between fields start-address and end-address, inclusive of
          start-address and end-address.";
    }
  }
  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
        "This field identifies the first flow label value, from the
        range of flow label values to be matched, on data packets
        sent from a corresponding node to the mobile node as seen
        by the home agent. According to [RFC2460], the flow label
        is 24 bits long. For the purpose of this specification, the
        sender of this option MUST prefix the flow label value with
        8 bits of '0' before inserting it in the start-flow-label
        field. The receiver SHOULD ignore the first 8 bits of this
        field before using it in comparisons with flow labels in
        packets.";
    }
    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
        "If more than one contiguous flow label value needs to be
         matched, then this field can be used to indicate the end
         value of a range starting from the value of the Start Flow
         Label field. This field MUST NOT be included unless the
         Start Flow Label field is included. When this field is
         included, the receiver will match all of the flow label
         values between fields start-flow-label and end-flow-label,
         inclusive of start-flow-label and end-flow-label. When this
         field is included, it MUST be coded the same way as defined
         for end-flow-label.";
    }
    }
  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
       "This field identifies the first traffic class value, from the
        range of traffic class values to be matched, on data packets
        sent from a corresponding node to the mobile node as seen by
        the home agent. This field is equivalent to the Start DS field
        in the IPv4 traffic selector in Figure 1. As per RFC 3260, the
        field is defined as a 6-bit DS field with 2 bits reserved,
        later claimed by Explicit Congestion Notification (ECN)
        RFC 3168. For the purpose of this specification, the
        start-traffic-class field is 8 bits long, where the 6 most
        significant bits indicate the DS field to be matched and the 2
        least significant bits' values MUST be ignored in any
        comparison.";
      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
       "If more than one contiguous TC value needs to be matched,
       then this field can be used to indicate the end value of a
       range starting from the value of the Start TC field. This
       field MUST NOT be included unless the Start TC field is
       included. When this field is included, it MUST be coded the
       same way as defined for start-traffic-class. When this field
       is included, the receiver will match all of the values
       between fields start-traffic-class and end-traffic-class,
       inclusive of start-traffic-class and end-traffic-class.";
    }
  }
  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
       "This field identifies the first 8-bit next header value, from
       the range of next header values to be matched, on data packets
       sent from a corresponding node to the mobile node as seen by
       the home agent.";
    }
    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
      "If more than one contiguous next header value needs to be
       matched, then this field can be used to indicate the end value
       of a range starting from the value of the Start NH field. This
       field MUST NOT be included unless the Start next header field
       is included. When this field is included, the receiver will
       match all of the values between fields start-next-header and
       end-next-header, inclusive of start-next-header and
       end-next-header.";
    }
  }
  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 {
            when "boolean(../ts-format/text() ="
            + "'ipv6-binary-selector-format') |"
            + " boolean(../ts-format/text() ="
            + " 'ipv4-binary-selector-format')";
        }
        uses ipv4-binary-traffic-selector {
            when "boolean(../ts-format/text() ="
            + " 'ipv4-binary-selector-format')";
        }
        uses ipv6-binary-traffic-selector {
            when "boolean(../ts-format/text() = "
        + "'ipv6-binary-selector-format')";
        }
    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.2.4. FPC 3GPP Mobility YANG Model

This module defines the base protocol elements of 3GPP mobility..

This module references [RFC6991], the fpc-base, fpc-agent, ietf- traffic-selector and pmip-qos modules defined in this document.

<CODE BEGINS> file "ietf-dmm-threegpp@2017-03-08.yang"
module ietf-dmm-threegpp {
    namespace "urn:ietf:params:xml:ns:yang:ietf-dmm-threegpp";
    prefix threegpp;

    import ietf-inet-types { prefix inet; revision-date 2013-07-15; }
    import ietf-dmm-fpc { prefix fpc; revision-date 2017-03-08; }
    import ietf-traffic-selector-types { prefix traffic-selectors;
      revision-date 2016-01-14; }
    import ietf-pmip-qos { prefix pmipqos;
        revision-date 2016-02-10; }

    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>

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

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

    description
    "This module contains YANG definition for 3GPP Related Mobility
     Structures.

     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-03-08 {
        description "Version 06 updates.";
        reference "draft-ietf-dmm-fpc-cpdp-06";
    }

    revision 2016-08-03 {
        description "Initial";
        reference "draft-ietf-dmm-fpc-cpdp-04";
    }

    identity threeGPP-access-type {
      base "fpc:fpc-access-type";
      description "3GPP Access Type";
    }

    // Profile Type
    identity threeGPP-mobility {
         base "fpc:fpc-mobility-profile-type";
         description "3GPP Mobility Profile";
    }

    // Tunnel Types
    identity threeGPP-tunnel-type {
        description "3GPP Base Tunnel Type";
    }

    identity gtpv1 {
        base "threegpp:threeGPP-tunnel-type";
        description "GTP version 1 Tunnel";
    }

    identity gtpv2 {
        base "threegpp:threeGPP-tunnel-type";
        description "GTP version 2 Tunnel";
    }

    grouping teid-value {
         description "TEID value holder";
         leaf tunnel-identifier {
            type uint32;
            description "Tunnel Endpoint IDentifier (TEID)";
        }
    }

    grouping threeGPP-tunnel {
        description "3GPP Tunnel Definition";
        leaf tunnel-type {
            type identityref  {
              base "threegpp:threeGPP-tunnel-type";
            }
            description "3GPP Tunnel Subtype";
        }
        uses threegpp:teid-value;
    }

    // QoS Profile
    identity threeGPP-qos-profile-parameters {
        base "fpc:fpc-qos-type";
        description "3GPP QoS Profile";
    }

    typedef fpc-qos-class-identifier {
        type uint8 {
            range "1..9";
        }
        description "QoS Class Identifier (QCI)";
    }

    grouping threeGPP-QoS {
        description "3GPP QoS Attributes";
        leaf qci {
            type fpc-qos-class-identifier;
            description "QCI";
        }
        leaf gbr {
            type uint32;
            description "Guaranteed Bit Rate";
        }
        leaf mbr {
            type uint32;
            description "Maximum Bit Rate";
        }
        leaf apn-ambr {
            type uint32;
            description "Access Point Name Aggregate Max Bit Rate";
        }
        leaf ue-ambr {
            type uint32;
            description "User Equipment Aggregate Max Bit Rate";
        }
        container arp {
            uses pmipqos:Allocation-Retention-Priority-Value;
            description "Allocation Retention Priority";
        }
    }

    typedef ebi-type {
      type uint8 {
        range "0..15";
      }
      description "EUTRAN Bearere Identifier (EBI) Type";
    }

   // From 3GPP TS 24.008 version 13.5.0 Release 13
   typedef component-type-enum {
        type enumeration {
            enum ipv4RemoteAddress {
              value 16;
              description "IPv4 Remote Address";
            }
            enum ipv4LocalAddress  {
              value 17;
              description "IPv4 Local Address";
            }
            enum ipv6RemoteAddress {
              value 32;
              description "IPv6 Remote Address";
            }
            enum ipv6RemoteAddressPrefix {
              value 33;
              description "IPv6 Remote Address Prefix";
            }
            enum ipv6LocalAddressPrefix {
              value 35;
              description "IPv6 Local Address Prefix";
            }
            enum protocolNextHeader {
              value 48;
              description "Protocol (IPv4) or NextHeader (IPv6)
                value";
            }
            enum localPort {
              value 64;
              description "Local Port";
            }
            enum localPortRange {
              value 65;
              description "Local Port Range";
            }
            enum reomotePort {
              value 80;
              description "Remote Port";
            }
            enum remotePortRange {
              value 81;
              description "Remote Port Range";
            }
            enum secParamIndex {
              value 96;
              description "Security Parameter Index (SPI)";
            }
            enum tosTraffClass {
              value 112;
              description "TOS Traffic Class";
            }
            enum flowLabel {
              value 128;
              description "Flow Label";
            }
        }
        description "TFT Component Type";
    }

    typedef packet-filter-direction {
        type enumeration {
          enum preRel7Tft {
            value 0;
            description "Pre-Release 7 TFT";
          }
          enum uplink {
            value 1;
            description "uplink";
          }
          enum downlink {
            value 2;
            description "downlink";
          }
          enum bidirectional {
            value 3;
            description "bi-direcitonal";
          }
        }
        description "Packet Filter Direction";
    }

    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";
    }

    grouping packet-filter {
      leaf direction {
          type threegpp:packet-filter-direction;
          description "Filter Direction";
      }
      leaf identifier {
          type uint8 {
            range "1..15";
          }
          description "Filter Identifier";
      }
      leaf evaluation-precedence {
          type uint8;
          description "Evaluation Precedence";
      }
      list contents {
        key component-type-identifier;
        description "Filter Contents";
        leaf component-type-identifier {
            type threegpp:component-type-id;
            description "Component Type";
        }
        choice value {
          case ipv4-local {
            leaf ipv4-local {
              type inet:ipv4-address;
              description "IPv4 Local Address";
            }
          }
          case ipv6-prefix-local {
            leaf ipv6-prefix-local {
              type inet:ipv6-prefix;
              description "IPv6 Local Prefix";
            }
          }
          case ipv4-ipv6-remote {
            leaf ipv4-ipv6-remote {
              type inet:ip-address;
              description "Ipv4 Ipv6 remote address";
            }
          }
          case ipv6-prefix-remote {
            leaf ipv6-prefix-remote {
              type inet:ipv6-prefix;
              description "IPv6 Remote Prefix";
            }
          }
          case next-header {
            leaf next-header {
              type uint8;
              description "Next Header";
            }
          }
          case local-port {
            leaf local-port {
              type inet:port-number;
              description "Local Port";
            }
          }
          case local-port-range {
            leaf local-port-lo {
              type inet:port-number;
              description "Local Port Min Value";
            }
            leaf local-port-hi {
              type inet:port-number;
              description "Local Port Max Value";
            }
          }
          case remote-port {
            leaf remote-port {
              type inet:port-number;
              description "Remote Port";
            }
          }
          case remote-port-range {
            leaf remote-port-lo {
              type inet:port-number;
              description "Remote Por Min Value";
            }
            leaf remote-port-hi {
              type inet:port-number;
              description "Remote Port Max Value";
            }
          }
          case ipsec-index {
            leaf ipsec-index {
              type traffic-selectors:ipsec-spi;
              description "IPSec Index";
            }
          }
          case traffic-class {
            leaf traffic-class {
              type inet:dscp;
              description "Traffic Class";
            }
          }
          case traffic-class-range {
              leaf traffic-class-lo {
                type inet:dscp;
                description "Traffic Class Min Value";
              }
              leaf traffic-class-hi {
                type inet:dscp;
                description "Traffic Class Max Value";
              }
          }
          case flow-label-type {
            leaf-list flow-label {
              type inet:ipv6-flow-label;
              description "Flow Label";
            }
          }
          description "Component Value";
        }
      }
      description "Packet Filter";
    }

    grouping tft {
      list packet-filters {
          key identifier;
          uses threegpp:packet-filter;
          description "List of Packet Filters";
      }
      description "Packet Filter List";
    }

    typedef imsi-type {
        type uint64;
        description
            "International Mobile Subscriber Identity (IMSI)
              Value Type";
    }

    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";
    }

    // Descriptors update - goes to Entities, Configure
    //              and Configure Bundles
    augment "/fpc:tenants/fpc:tenant/fpc:fpc-policy/fpc:"
       + "descriptors/fpc:descriptor-value" {
      case threegpp-tft {
          uses threegpp:tft;
          description "3GPP TFT";
      }
      description "3GPP TFT Descriptor";
    }

    grouping threegpp-tunnel-info {
      uses threegpp:threeGPP-tunnel;
      choice tft-or-ref {
        case defined-tft {
          uses threegpp:tft;
        }
        case predefined-tft {
          leaf tft-reference {
            type fpc:fpc-identity;
            description "Pre-configured TFT";
          }
        }
        description "TFT Value";
      }
      description "3GPP TFT and Tunnel Information";
    }

    // Contexts Update - Contexts / UL / mob-profile
    augment "/fpc:tenants/fpc:tenant/fpc:fpc-mobility/fpc:"
        + "contexts/fpc:ul/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Context UL Tunnel";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:ul/fpc:"
        + "mobility-tunnel-parameters/fpc:profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Create Context UL Tunnel";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:bundles/fpc:"
        + "op_body/fpc:create_or_update/fpc:contexts/fpc:"
        + "ul/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Bundles Create Context UL Tunnel";
    }
    augment "/fpc:configure/fpc:output/fpc:result-type/fpc:"
        + "create-or-update-success/fpc:contexts/fpc:"
        + "ul/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Create Context UL Tunnel Response";
    }
    augment "/fpc:configure-bundles/fpc:output/fpc:bundles/fpc:"
       + "result-type/fpc:create-or-update-success/fpc:contexts/fpc:"
       + "ul/fpc:mobility-tunnel-parameters/fpc:profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Bundles Create Context UL Tunnel Response";
    }

    // Contexts Update - Contexts / DL / mob-profile
    augment "/fpc:tenants/fpc:tenant/fpc:fpc-mobility/fpc:"
        + "contexts/fpc:dl/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Context DL Tunnel";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:dl/fpc:"
        + "mobility-tunnel-parameters/fpc:profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Bundles Create Context DL Tunnel";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:bundles/fpc:"
        + "op_body/fpc:create_or_update/fpc:contexts/fpc:dl/fpc:"
        + "mobility-tunnel-parameters/fpc:profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Bundles Create Context DL Tunnel";
    }
    augment "/fpc:configure/fpc:output/fpc:result-type/fpc:"
        + "create-or-update-success/fpc:contexts/fpc:dl/fpc:"
        + "mobility-tunnel-parameters/fpc:profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Create Context DL Tunnel Response";
    }
    augment "/fpc:configure-bundles/fpc:output/fpc:bundles/fpc:"
        + "result-type/fpc:create-or-update-success/fpc:"
        + "contexts/fpc:dl/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Bundles Create Context DL Tunnel Response";
    }


    // Contexts Update -  Contexts / dpns /
    //   mobility-tunnel-parameters
    augment "/fpc:tenants/fpc:tenant/fpc:fpc-mobility/fpc:"
        + "contexts/fpc:dpns/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Context 3GPP TFT and Tunnel Information";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:dpns/fpc:"
        + "mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Configure 3GPP TFT and Tunnel Information";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:bundles/fpc:"
        + "op_body/fpc:create_or_update/fpc:contexts/fpc:"
        + "dpns/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Configure Bundles 3GPP TFT and Tunnel
        Information";
    }
    augment "/fpc:configure/fpc:output/fpc:result-type/fpc:"
        + "create-or-update-success/fpc:contexts/fpc:"
        + "dpns/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Configure 3GPP TFT and Tunnel Information
        Response";
    }
    augment "/fpc:configure-bundles/fpc:output/fpc:bundles/fpc:"
        + "result-type/fpc:create-or-update-success/fpc:"
        + "contexts/fpc:dpns/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case threegpp-tunnel {
          uses threegpp:threegpp-tunnel-info;
      }
      description "Configure Bundles 3GPP TFT and Tunnel Information
        Response";
    }


    // QoS Updates - Context / UL / qosprofile
    augment "/fpc:tenants/fpc:tenant/fpc:fpc-mobility/fpc:"
        + "contexts/fpc:ul/fpc:qos-profile-parameters/fpc:value" {
      case threegpp-qos {
          uses threegpp:threeGPP-QoS;
          description "3GPP QoS Values";
      }
      description "Context UL 3GPP QoS Values";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:ul/fpc:"
        + "qos-profile-parameters/fpc:value" {
      case threegpp-qos {
          uses threegpp:threeGPP-QoS;
          description "3GPP QoS Values";
      }
      description "Configure Context UL 3GPP QoS Values";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:bundles/fpc:"
        + "op_body/fpc:create_or_update/fpc:contexts/fpc:"
        + "ul/fpc:qos-profile-parameters/fpc:value" {
      case threegpp-qos {
          uses threegpp:threeGPP-QoS;
          description "3GPP QoS Values";
      }
      description "Configure Bundles Context UL 3GPP QoS Values";
    }
    augment "/fpc:configure/fpc:output/fpc:result-type/fpc:"
        + "create-or-update-success/fpc:contexts/fpc:ul/fpc:"
        + "qos-profile-parameters/fpc:value" {
      case threegpp-qos {
          uses threegpp:threeGPP-QoS;
          description "3GPP QoS Values";
      }
      description "Configure Context UL 3GPP QoS Values Response";
    }
    augment "/fpc:configure-bundles/fpc:output/fpc:bundles/fpc:"
        + "result-type/fpc:create-or-update-success/fpc:"
        + "contexts/fpc:ul/fpc:qos-profile-parameters/fpc:value" {
      case threegpp-qos {
          uses threegpp:threeGPP-QoS;
          description "3GPP QoS Values";
      }
      description "Configure Bundles Context UL 3GPP QoS Values
        Response";
    }

    // QoS Updates -  Context / DL / QoS Profile
    augment "/fpc:tenants/fpc:tenant/fpc:fpc-mobility/fpc:"
        + "contexts/fpc:dl/fpc:qos-profile-parameters/fpc:value" {
      case threegpp-qos {
          uses threegpp:threeGPP-QoS;
          description "3GPP QoS Values";
      }
      description "Context DL 3GPP QoS Values";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:dl/fpc:"
        + "qos-profile-parameters/fpc:value" {
      case threegpp-qos {
          uses threegpp:threeGPP-QoS;
          description "3GPP QoS Values";
      }
      description "Configure Context DL 3GPP QoS Values";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:bundles/fpc:"
        + "op_body/fpc:create_or_update/fpc:contexts/fpc:dl/fpc:"
        + "qos-profile-parameters/fpc:value" {
      case threegpp-qos {
          uses threegpp:threeGPP-QoS;
          description "3GPP QoS Values";
      }
      description "Configure Bundles Context DL 3GPP QoS Values";
    }
    augment "/fpc:configure/fpc:output/fpc:result-type/fpc:"
        + "create-or-update-success/fpc:contexts/fpc:dl/fpc:"
        + "qos-profile-parameters/fpc:value" {
      case threegpp-qos {
          uses threegpp:threeGPP-QoS;
          description "3GPP QoS Values";
      }
      description "Configure Context DL 3GPP QoS Values Response";
    }
    augment "/fpc:configure-bundles/fpc:output/fpc:bundles/fpc:"
        + "result-type/fpc:create-or-update-success/fpc:"
        + "contexts/fpc:dl/fpc:qos-profile-parameters/fpc:value" {
      case threegpp-qos {
          uses threegpp:threeGPP-QoS;
          description "3GPP QoS Values";
      }
      description "Configure Bundles Context DL 3GPP QoS Values
        Response";
    }

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

    augment "/fpc:tenants/fpc:tenant/fpc:fpc-mobility/fpc:contexts" {
      uses threegpp:threegpp-properties;
      description "3GPP Mobility Session Properties";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts" {
      uses threegpp:threegpp-properties;
      description "3GPP Mobility Session Properties";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:"
        + "bundles/fpc:op_body/fpc:create_or_update/fpc:contexts" {
       uses threegpp:threegpp-properties;
       description "3GPP Mobility Session Properties";
    }
    augment "/fpc:configure/fpc:output/fpc:result-type/fpc:"
        + "create-or-update-success/fpc:contexts" {
      uses threegpp:threegpp-properties;
      description "3GPP Mobility Session Properties";
    }
    augment "/fpc:configure-bundles/fpc:output/fpc:bundles/fpc:"
        + "result-type/fpc:create-or-update-success/fpc:contexts" {
       uses threegpp:threegpp-properties;
       description "3GPP Mobility Session Properties";
    }

    grouping threegpp-commandset {
      leaf instr-3gpp-mob {
        type threegpp:threegpp-instr;
        description "3GPP Specific Command Set";
      }
      description "3GPP Instructions";
    }

    augment "/fpc:configure/fpc:input/fpc:instructions/fpc:"
        + "instr-type" {
      case instr-3gpp-mob {
        uses threegpp:threegpp-commandset;
        description "3GPP Instructions";
      }
      description "Configure 3GPP Instructions";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:instructions/fpc:"
        + "instr-type" {
      case instr-3gpp-mob {
        uses threegpp:threegpp-commandset;
        description "3GPP Instructions";
      }
      description "Configure 3GPP Context Instructions";
    }
    augment "/fpc:configure/fpc:output/fpc:result-type/fpc:"
        + "create-or-update-success/fpc:contexts/fpc:"
        + "instructions/fpc:instr-type" {
      case instr-3gpp-mob {
        uses threegpp:threegpp-commandset;
        description "3GPP Instructions";
      }
      description "Configure 3GPP Context Instructions Response";
    }


    augment "/fpc:configure-bundles/fpc:input/fpc:bundles/fpc:"
        + "instructions/fpc:instr-type" {
      case instr-3gpp-mob {
        uses threegpp:threegpp-commandset;
        description "3GPP Instructions";
      }
      description "Configure Bundles 3GPP Instructions";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:bundles/fpc:"
        + "op_body/fpc:create_or_update/fpc:contexts/fpc:"
        + "instructions/fpc:instr-type" {
      case instr-3gpp-mob {
        uses threegpp:threegpp-commandset;
        description "3GPP Instructions";
      }
      description "Configure Bundles 3GPP Context Instructions";
    }
    augment "/fpc:configure-bundles/fpc:output/fpc:bundles/fpc:"
        + "result-type/fpc:create-or-update-success/fpc:"
        + "contexts/fpc:instructions/fpc:instr-type" {
      case instr-3gpp-mob {
        uses threegpp:threegpp-commandset;
        description "3GPP Instructions";
      }
      description "Configure Bundles 3GPP Context Instructions
          Response";
    }
}

<CODE ENDS>

A.2.5. FPC / PMIP Integration YANG Model

This module defines the integration between FPC and PMIP models.

This module references the fpc-base, fpc-agent, pmip-qos and traffic-selector-types module defined in this document.

<CODE BEGINS> file "ietf-dmm-fpc-pmip@2017-03-08.yang"
module ietf-dmm-fpc-pmip {
    namespace "urn:ietf:params:xml:ns:yang:ietf-dmm-fpc-pmip";
    prefix fpc-pmip;

    import ietf-dmm-fpc { prefix fpc; revision-date 2017-03-08; }
    import ietf-pmip-qos { prefix qos-pmip; }
    import ietf-traffic-selector-types { prefix traffic-selectors; }

    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>

        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-03-08 {
        description "Version 06 update. Adds predfined selector.";
        reference "draft-ietf-dmm-fpc-cpdp-06";
    }

    revision 2016-01-19 {
        description "Changes based on -01 version of FPCP draft.";
        reference "draft-ietf-dmm-fpc-cpdp-01";
    }

    identity ietf-pmip-access-type {
      base "fpc:fpc-access-type";
      description "PMIP Access";
    }

    identity fpcp-qos-index-pmip {
        base "fpc:fpc-qos-type";
        description "PMIP QoS";
    }
    identity traffic-selector-mip6 {
        base "fpc:fpc-descriptor-type";
        description "MIP6 Traffic Selector";
    }
    identity ietf-pmip {
        base "fpc:fpc-mobility-profile-type";
        description "PMIP Mobility";
    }

    identity pmip-tunnel-type {
        description "PMIP Tunnel Type";
    }
    identity grev1 {
        base "fpc-pmip:pmip-tunnel-type";
        description "GRE v1";
    }
    identity grev2 {
        base "fpc-pmip:pmip-tunnel-type";
        description "GRE v2";
    }
    identity ipinip {
        base "fpc-pmip:pmip-tunnel-type";
        description "IP in IP";
    }
    grouping pmip-mobility {
        leaf type {
            type identityref {
                base "fpc-pmip:pmip-tunnel-type";
            }
            description "PMIP Mobility";
        }
        choice value {
            case gre {
                leaf key {
                    type uint32;
                    description "GRE_KEY";
                }
                description "GRE Value";
            }
            description "PMIP Mobility value";
        }
        description "PMIP Mobility Value";
    }

    typedef pmip-instr {
      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 "Instruction Set for PMIP";
    }

    // Descriptors update - goes to Entities, Configure and
    // Configure Bundles
    augment "/fpc:tenants/fpc:tenant/fpc:fpc-policy/"
      + "fpc:descriptors/fpc:descriptor-value" {
      case pmip-selector {
          uses traffic-selectors:traffic-selector;
          description "PMIP Selector";
      }
      description "Policy Descriptor";
    }

    grouping pmip-tunnel-info {
        uses fpc-pmip:pmip-mobility;
        choice pmiptunnel-or-ref {
          case defined-selector {
            uses traffic-selectors:traffic-selector;
          }
          case predefined-selector {
            leaf selector-reference {
              type fpc:fpc-identity;
              description "Pre-configured selector";
            }
          }
          description "Traffic Selector Value";
        }
        description "PMIP Tunnel Information";
    }

    // Contexts Update - Contexts/UL/mob-profile, Contexts/DL/
    //   mob-profile and Contexts/dpns/mobility-tunnel-parameters
    augment "/fpc:tenants/fpc:tenant/fpc:fpc-mobility/fpc:"
        + "contexts/fpc:ul/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case pmip-tunnel {
        uses fpc-pmip:pmip-tunnel-info;
      }
      description "Context UL Mobility";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:ul/fpc:"
        + "mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case pmip-tunnel {
        uses fpc-pmip:pmip-tunnel-info;
      }
      description "CONF Context UL Mobility";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:bundles/fpc:"
        + "op_body/fpc:create_or_update/fpc:contexts/fpc:"
        + "ul/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case pmip-tunnel {
        uses fpc-pmip:pmip-tunnel-info;
      }
      description "CONF_BUNDLES Context UL Mobility";
    }

    augment "/fpc:tenants/fpc:tenant/fpc:fpc-mobility/fpc:"
        + "contexts/fpc:dl/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case pmip-tunnel {
        uses fpc-pmip:pmip-tunnel-info;
      }
      description "Context DL Mobility";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:dl/fpc:"
        + "mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case pmip-tunnel {
        uses fpc-pmip:pmip-tunnel-info;
      }
      description "CONF Context DL Mobility";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:"
        + "bundles/fpc:op_body/fpc:create_or_update/fpc:"
        + "contexts/fpc:dl/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case pmip-tunnel {
        uses fpc-pmip:pmip-tunnel-info;
      }
      description "CONF_BUNDLES Context DL Mobility";
    }

    augment "/fpc:tenants/fpc:tenant/fpc:fpc-mobility/fpc:"
        + "contexts/fpc:dpns/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case pmip-tunnel {
        uses fpc-pmip:pmip-tunnel-info;
      }
      description "Context DPN Mobility";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:dpns/fpc:"
        + "mobility-tunnel-parameters/fpc:profile-parameters" {
      case pmip-tunnel {
        uses fpc-pmip:pmip-tunnel-info;
      }
      description "CONF Context DPN Mobility";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:"
        + "bundles/fpc:op_body/fpc:create_or_update/fpc:"
        + "contexts/fpc:dpns/fpc:mobility-tunnel-parameters/fpc:"
        + "profile-parameters" {
      case pmip-tunnel {
        uses fpc-pmip:pmip-tunnel-info;
      }
      description "CONF_BUNDLES Context DPN Mobility";
    }

    // QoS Updates - Context / UL / qosprofile, Context / DL /
    // QoS Profile
    augment "/fpc:tenants/fpc:tenant/fpc:fpc-mobility/fpc:"
        + "contexts/fpc:ul/fpc:qos-profile-parameters/fpc:value" {
      case qos-pmip {
          uses qos-pmip:qosattribute;
          description "PMIP QoS Information";
      }
      description "Context UL QoS";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:ul/fpc:"
        + "qos-profile-parameters/fpc:value" {
      case qos-pmip {
          uses qos-pmip:qosattribute;
          description "PMIP QoS Information";
      }
      description "CONF Context UL QoS";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:"
        + "bundles/fpc:op_body/fpc:create_or_update/fpc:"
        + "contexts/fpc:ul/fpc:qos-profile-parameters/fpc:value" {
      case qos-pmip {
          uses qos-pmip:qosattribute;
          description "PMIP QoS Information";
      }
      description "CONF_BUNDLES Context UL QoS";
    }

    augment "/fpc:tenants/fpc:tenant/fpc:fpc-mobility/fpc:"
        + "contexts/fpc:dl/fpc:qos-profile-parameters/fpc:value" {
      case qos-pmip {
          uses qos-pmip:qosattribute;
          description "PMIP QoS Information";
      }
      description "Context DL QoS";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:dl/fpc:"
        + "qos-profile-parameters/fpc:value" {
      case qos-pmip {
          uses qos-pmip:qosattribute;
          description "PMIP QoS Information";
      }
      description "CONF Context DL QoS";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:"
        + "bundles/fpc:op_body/fpc:create_or_update/fpc:"
        + "contexts/fpc:dl/fpc:qos-profile-parameters/fpc:value" {
      case qos-pmip {
          uses qos-pmip:qosattribute;
          description "PMIP QoS Information";
      }
      description "CONF_BUNDLES Context DL QoS";
    }

    grouping pmip-commandset {
      leaf instr-pmip {
        type fpc-pmip:pmip-instr;
        description "PMIP Instructions";
      }
      description "PMIP Commandset";
    }

    // Instructions Update - OP BODY, Context, Port
    augment "/fpc:configure/fpc:input/fpc:instructions/fpc:"
        + "instr-type" {
      case pmip-instr {
        uses fpc-pmip:pmip-commandset;
        description "PMIP Commandset";
      }
      description "CONF Instructions";
    }
    augment "/fpc:configure/fpc:input/fpc:op_body/fpc:"
        + "create_or_update/fpc:contexts/fpc:instructions/fpc:"
        + "instr-type" {
      case pmip-instr {
        uses fpc-pmip:pmip-commandset;
        description "PMIP Commandset";
      }
      description "CONF Context Instructions";
    }
    augment "/fpc:configure/fpc:output/fpc:result-type/fpc:"
        + "create-or-update-success/fpc:contexts/fpc:"
        + "instructions/fpc:instr-type" {
      case pmip-instr {
        uses fpc-pmip:pmip-commandset;
        description "PMIP Commandset";
      }
      description "CONF Result Context Instructions";
    }

    augment "/fpc:configure-bundles/fpc:input/fpc:"
        + "bundles/fpc:instructions/fpc:instr-type" {
      case pmip-instr {
        uses fpc-pmip:pmip-commandset;
        description "PMIP Commandset";
      }
      description "CONF_BUNDLES Instructions";
    }
    augment "/fpc:configure-bundles/fpc:input/fpc:bundles/fpc:"
        + "op_body/fpc:create_or_update/fpc:contexts/fpc:"
        + "instructions/fpc:instr-type" {
      case pmip-instr {
        uses fpc-pmip:pmip-commandset;
        description "PMIP Commandset";
      }
      description "CONF_BUNDLES Context Instructions";
    }
    augment "/fpc:configure-bundles/fpc:output/fpc:"
        + "bundles/fpc:result-type/fpc:create-or-update-success/fpc:"
        + "contexts/fpc:instructions/fpc:instr-type" {
      case pmip-instr {
        uses fpc-pmip:pmip-commandset;
        description "PMIP Commandset";
      }
      description "CONF_BUNDLES Result Context Instructions";
    }
}
<CODE ENDS>

A.2.6. FPC Policy Extension YANG Model

This module defines extensions to FPC policy structures.

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

<CODE BEGINS> file "ietf-dmm-fpc-policyext@2017-03-08.yang"
module ietf-dmm-fpc-policyext {
    namespace "urn:ietf:params:xml:ns:yang:ietf-dmm-fpc-policyext";
    prefix fpcpolicyext;

    import ietf-dmm-fpc { prefix fpc; revision-date 2017-03-08; }
    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>

        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) common Policy Action and
     Descriptor 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 2017-03-08 {
        description "Version 06 update.";
        reference "draft-ietf-dmm-fpc-cpdp-06";
    }

    revision 2016-08-03 {
        description "Changes based on -04 version of FPC draft.";
        reference "draft-ietf-dmm-fpc-cpdp-04";
    }

    identity service-function {
        base "fpc:fpc-descriptor-type";
        description "Base Identifier for Service Functions.";
    }
    identity napt-service {
        base "service-function";
        description "NAPT Service";
    }
    grouping simple-nat {
      leaf outbound-nat-address {
        type inet:ip-address;
        description "Outbound NAT Address";
      }
      description "Simple NAT value";
    }

    identity nat-service {
        base "service-function";
        description "NAT Service";
    }
    grouping simple-napt {
      leaf source-port {
        type inet:port-number;
        description "Source Port";
      }
      leaf outbound-napt-address {
        type inet:ip-address;
        description "Outbound NAPT Address";
      }
      leaf destination-port {
        type inet:port-number;
        description "Destination Port";
      }
      description "Simple NAPT Configuration";
    }

    identity copy-forward {
      base "fpc:fpc-descriptor-type";
      description "Copies a packet then forwards to a specific
        destination";
    }
    grouping copy-forward {
      container destination {
        choice value {
          case port-ref {
            leaf port-ref {
              type fpc:fpc-vport-id;
              description "Port";
            }
            description "Port Forward Case";
          }
          case context-ref {
            leaf context-ref {
              type fpc:fpc-context-id;
              description "Context";
            }
            description "Context Forward Case";
          }
          description "Copy Forward Value";
        }
        description "destination";
      }
      description "Copy Then Forward to Port/Context Action";
    }

    augment "/fpc:tenants/fpc:tenant/fpc:fpc-policy/fpc:actions/fpc:"
        + "action-value" {
      case simple-nat {
          uses fpcpolicyext:simple-nat;
          description "Simple NAT value";
      }
      case simple-napt {
          uses fpcpolicyext:simple-napt;
          description "Simple NAPT Value";
      }
      case copy-forward {
          uses fpcpolicyext:copy-forward;
          description "Copy Forward Value";
      }
      description "Policy Actions Augmentations";
    }

    grouping prefix-traffic-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 group collects parameters to
         identify target traffic flow.  It represents
         source/destination as IP prefixes";
    }

    augment "/fpc:tenants/fpc:tenant/fpc:fpc-policy/fpc:"
        + "descriptors/fpc:descriptor-value" {
      case prefix-descriptor {
          uses fpcpolicyext:prefix-traffic-descriptor;
          description "traffic descriptor value";
      }
      description "Descriptor Augments";
    }
}
<CODE ENDS>

A.3. FPC YANG Data Model Structure

This section only shows the structure for FPC YANG model.

module: ietf-dmm-fpc
+--rw tenants
|  +--rw tenant* [tenant-id]
|     +--rw tenant-id       fpc:fpc-identity
|     +--rw fpc-policy
|     |  +--rw policy-groups* [policy-group-id]
|     |  |  +--rw policy-group-id    fpc:fpc-policy-group-id
|     |  |  +--rw policies*          fpc:fpc-policy-id
|     |  +--rw policies* [policy-id]
|     |  |  +--rw policy-id    fpc:fpc-policy-id
|     |  |  +--rw rules* [order]
|     |  |     +--rw order          uint32
|     |  |     +--rw descriptors* [descriptor-id]
|     |  |     |  +--rw descriptor-id    fpc:fpc-identity
|     |  |     |  +--rw direction?       fpc:fpc-direction
|     |  |     +--rw actions* [action-id]
|     |  |        +--rw action-order?   uint32
|     |  |        +--rw action-id       fpc:fpc-action-id-type
|     |  +--rw descriptors* [descriptor-id]
|     |  |  +--rw descriptor-id      fpc:fpc-identity
|     |  |  +--rw descriptor-type    identityref
|     |  |  +--rw (descriptor-value)?
|     |  |     +--:(all-traffic)
|     |  |        +--rw all-traffic?       empty
|     |  +--rw actions* [action-id]
|     |     +--rw action-id      fpc:fpc-action-id-type
|     |     +--rw action-type    identityref
|     |     +--rw (action-value)?
|     |        +--:(drop)
|     |           +--rw drop?          empty
|     +--ro fpc-mobility
|     |  +--ro contexts* [context-id]
|     |  |  +--ro context-id               fpc:fpc-context-id
|     |  |  +--ro vports*                  fpc:fpc-vport-id
|     |  |  +--ro dpn-group?               fpc:fpc-dpn-group-id
|     |  |  +--ro delegated-ip-prefixes*   inet:ip-prefix
|     |  |  +--ro ul {fpc:fpc-basic-agent}?
|     |  |  |  +--ro tunnel-local-address?         inet:ip-address
|     |  |  |  +--ro tunnel-remote-address?        inet:ip-address
|     |  |  |  +--ro mtu-size?                     uint32
|     |  |  |  +--ro mobility-tunnel-parameters
|     |  |  |  |  +--ro (profile-parameters)?
|     |  |  |  |     +--:(nothing)
|     |  |  |  |        +--ro none?   empty
|     |  |  |  +--ro nexthop
|     |  |  |  |  +--ro nexthop-type?   identityref
|     |  |  |  |  +--ro (nexthop-value)?
|     |  |  |  |     +--:(ip-nexthop)
|     |  |  |  |     |  +--ro ip?             inet:ip-address
|     |  |  |  |     +--:(macaddress-nexthop)
|     |  |  |  |     |  +--ro macaddress?     ytypes:mac-address
|     |  |  |  |     +--:(servicepath-nexthop)
|     |  |  |  |     |  +--ro servicepath?  fpc:fpc-service-path-id
|     |  |  |  |     +--:(mplslabel-nexthop)
|     |  |  |  |     |  +--ro lsp?            fpc:fpc-mpls-label
|     |  |  |  |     +--:(if-nexthop)
|     |  |  |  |        +--ro if-index?       uint16
|     |  |  |  +--ro qos-profile-parameters
|     |  |  |  |  +--ro qos-type?   identityref
|     |  |  |  |  +--ro (value)?
|     |  |  |  +--ro dpn-parameters
|     |  |  |  +--ro vendor-parameters* [vendor-id vendor-type]
|     |  |  |     +--ro vendor-id      fpc:fpc-identity
|     |  |  |     +--ro vendor-type    identityref
|     |  |  |     +--ro (value)?
|     |  |  |        +--:(empty-type)
|     |  |  |           +--ro empty-type?    empty
|     |  |  +--ro dl {fpc:fpc-basic-agent}?
|     |  |  |  +--ro tunnel-local-address?         inet:ip-address
|     |  |  |  +--ro tunnel-remote-address?        inet:ip-address
|     |  |  |  +--ro mtu-size?                     uint32
|     |  |  |  +--ro mobility-tunnel-parameters
|     |  |  |  |  +--ro (profile-parameters)?
|     |  |  |  |     +--:(nothing)
|     |  |  |  |        +--ro none?   empty
|     |  |  |  +--ro nexthop
|     |  |  |  |  +--ro nexthop-type?   identityref
|     |  |  |  |  +--ro (nexthop-value)?
|     |  |  |  |     +--:(ip-nexthop)
|     |  |  |  |     |  +--ro ip?             inet:ip-address
|     |  |  |  |     +--:(macaddress-nexthop)
|     |  |  |  |     |  +--ro macaddress?     ytypes:mac-address
|     |  |  |  |     +--:(servicepath-nexthop)
|     |  |  |  |     |  +--ro servicepath?  fpc:fpc-service-path-id
|     |  |  |  |     +--:(mplslabel-nexthop)
|     |  |  |  |     |  +--ro lsp?            fpc:fpc-mpls-label
|     |  |  |  |     +--:(if-nexthop)
|     |  |  |  |        +--ro if-index?       uint16
|     |  |  |  +--ro qos-profile-parameters
|     |  |  |  |  +--ro qos-type?   identityref
|     |  |  |  |  +--ro (value)?
|     |  |  |  +--ro dpn-parameters
|     |  |  |  +--ro vendor-parameters* [vendor-id vendor-type]
|     |  |  |     +--ro vendor-id      fpc:fpc-identity
|     |  |  |     +--ro vendor-type    identityref
|     |  |  |     +--ro (value)?
|     |  |  |        +--:(empty-type)
|     |  |  |           +--ro empty-type?    empty
|     |  |  +--ro dpns* [dpn-id direction] {fpc:fpc-multi-dpn}?
|     |  |  |  +--ro dpn-id                        fpc:fpc-dpn-id
|     |  |  |  +--ro direction                     fpc:fpc-direction
|     |  |  |  +--ro tunnel-local-address?         inet:ip-address
|     |  |  |  +--ro tunnel-remote-address?        inet:ip-address
|     |  |  |  +--ro mtu-size?                     uint32
|     |  |  |  +--ro mobility-tunnel-parameters
|     |  |  |  |  +--ro (profile-parameters)?
|     |  |  |  |     +--:(nothing)
|     |  |  |  |        +--ro none?   empty
|     |  |  |  +--ro nexthop
|     |  |  |  |  +--ro nexthop-type?   identityref
|     |  |  |  |  +--ro (nexthop-value)?
|     |  |  |  |     +--:(ip-nexthop)
|     |  |  |  |     |  +--ro ip?             inet:ip-address
|     |  |  |  |     +--:(macaddress-nexthop)
|     |  |  |  |     |  +--ro macaddress?     ytypes:mac-address
|     |  |  |  |     +--:(servicepath-nexthop)
|     |  |  |  |     |  +--ro servicepath? fpc:fpc-service-path-id
|     |  |  |  |     +--:(mplslabel-nexthop)
|     |  |  |  |     |  +--ro lsp?            fpc:fpc-mpls-label
|     |  |  |  |     +--:(if-nexthop)
|     |  |  |  |        +--ro if-index?       uint16
|     |  |  |  +--ro qos-profile-parameters
|     |  |  |  |  +--ro qos-type?   identityref
|     |  |  |  |  +--ro (value)?
|     |  |  |  +--ro dpn-parameters
|     |  |  |  +--ro vendor-parameters* [vendor-id vendor-type]
|     |  |  |     +--ro vendor-id      fpc:fpc-identity
|     |  |  |     +--ro vendor-type    identityref
|     |  |  |     +--ro (value)?
|     |  |  |        +--:(empty-type)
|     |  |  |           +--ro empty-type?    empty
|     |  |  +--ro parent-context?          fpc:fpc-context-id
|     |  +--ro vports* [vport-id]
|     |  |  +--ro vport-id         fpc:fpc-vport-id
|     |  |  +--ro policy-groups*   fpc:fpc-policy-group-id
|     |  +--ro monitors*
|     |     +--ro monitor-id?         fpc:fpc-identity
|     |     +--ro target?             fpc-identity
|     |     +--ro (event-config-value)?
|     |        +--:(periodic-config)
|     |        |  +--ro period?             uint32
|     |        +--:(threshold-config)
|     |        |  +--ro lo-thresh?          uint32
|     |        |  +--ro hi-thresh?          uint32
|     |        +--:(scheduled-config)
|     |        |  +--ro report-time?        uint32
|     |        +--:(events-config-ident)
|     |        |  +--ro event-identities*   identityref
|     |        +--:(events-config)
|     |           +--ro event-ids*          uint32
|     +--rw fpc-topology
|        +--rw domains* [domain-id]
|        |  +--rw domain-id           fpc:fpc-domain-id
|        |  +--rw domain-name?        string
|        |  +--rw domain-type?        string
|        |  +--rw domain-reference?   instance-identifier
|        |  +--rw basename?           fpc:fpc-identity
|        |  |       {fpc:fpc-basename-registry}?
|        |  +--rw base-state?         string
|        |  |       {fpc:fpc-basename-registry}?
|        |  +--rw base-checkpoint?    string
|        |          {fpc:fpc-basename-registry}?
|        +--rw dpn-id?              fpc:fpc-dpn-id
|        |       {fpc:fpc-basic-agent}?
|        +--rw control-protocols*   identityref
|        |       {fpc:fpc-basic-agent}?
|        +--rw dpn-groups* [dpn-group-id] {fpc:fpc-multi-dpn}?
|        |  +--rw dpn-group-id        fpc:fpc-dpn-group-id
|        |  +--rw data-plane-role?    identityref
|        |  +--rw access-type?        identityref
|        |  +--rw mobility-profile?   identityref
|        |  +--rw dpn-group-peers* [remote-dpn-group-id]
|        |  |  +--rw remote-dpn-group-id     fpc:fpc-dpn-group-id
|        |  |  +--rw remote-mobility-profile?   identityref
|        |  |  +--rw remote-data-plane-role?    identityref
|        |  |  +--rw remote-endpoint-address?   inet:ip-address
|        |  |  +--rw local-endpoint-address?    inet:ip-address
|        |  |  +--rw mtu-size?                  uint32
|        |  +--rw domains* [domain-id]
|        |     +--rw domain-id           fpc:fpc-domain-id
|        |     +--rw domain-name?        string
|        |     +--rw domain-type?        string
|        |     +--rw domain-reference?   instance-identifier
|        |     +--rw basename?           fpc:fpc-identity
|        |     |       {fpc:fpc-basename-registry}?
|        |     +--rw base-state?         string
|        |     |       {fpc:fpc-basename-registry}?
|        |     +--rw base-checkpoint?    string
|        |             {fpc:fpc-basename-registry}?
|        +--rw dpns* [dpn-id] {fpc:fpc-multi-dpn}?
|           +--rw dpn-id            fpc:fpc-dpn-id
|           +--rw dpn-name?         string
|           +--rw dpn-groups*       fpc:fpc-dpn-group-id
|           +--rw node-reference?   instance-identifier
+--rw fpc-agent-info
   +--rw supported-features*      string
   +--rw supported-events* [event]
   |  +--rw event       identityref
   |  +--rw event-id?   fpc:event-type-id
   +--rw supported-error-types* [error-type]
      +--rw error-type       identityref
      +--rw error-type-id?   fpc:error-type-id