summaryrefslogtreecommitdiffstats
path: root/vpp-classifier/api/src
diff options
context:
space:
mode:
authorJan Srnicek <jsrnicek@cisco.com>2017-03-08 14:01:34 +0100
committerMarek Gradzki <mgradzki@cisco.com>2017-03-09 07:09:36 +0000
commitbf1d5db448edc1ae352960f14bca9ccb41612186 (patch)
treecdf6f5feebf650050bde23ffe7a9a2f8d6389a94 /vpp-classifier/api/src
parent6532b1524bb841cac2b559415b85ac6e9d2ff934 (diff)
HC2VPP-7 - split vpp-classifiers to separate module
Split vpp-classifiers and vpp-classifiers acls' to separate modules. Contains TODO's for future change of dependencies Change-Id: I94f92ce2ec8960c67bd406f085f2fe928079ee23 Signed-off-by: Jan Srnicek <jsrnicek@cisco.com>
Diffstat (limited to 'vpp-classifier/api/src')
-rw-r--r--vpp-classifier/api/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpp/classifier/rev161214/OpaqueIndexBuilder.java40
-rw-r--r--vpp-classifier/api/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpp/classifier/rev161214/VppNodeBuilder.java41
-rw-r--r--vpp-classifier/api/src/main/yang/ietf-access-control-list.yang208
-rw-r--r--vpp-classifier/api/src/main/yang/ietf-packet-fields.yang180
-rw-r--r--vpp-classifier/api/src/main/yang/vpp-classifier-acl.yang183
-rw-r--r--vpp-classifier/api/src/main/yang/vpp-classifier-context.yang68
-rw-r--r--vpp-classifier/api/src/main/yang/vpp-classifier.yang215
-rw-r--r--vpp-classifier/api/src/main/yang/vpp-interface-acl.yang32
-rw-r--r--vpp-classifier/api/src/main/yang/vpp-subinterface-acl.yang36
9 files changed, 1003 insertions, 0 deletions
diff --git a/vpp-classifier/api/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpp/classifier/rev161214/OpaqueIndexBuilder.java b/vpp-classifier/api/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpp/classifier/rev161214/OpaqueIndexBuilder.java
new file mode 100644
index 000000000..a0c086bda
--- /dev/null
+++ b/vpp-classifier/api/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpp/classifier/rev161214/OpaqueIndexBuilder.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2017 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classifier.rev161214;
+
+
+/**
+ * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation.
+ * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32).
+ *
+ * The reason behind putting it under src/main/java is:
+ * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent
+ * loss of user code.
+ *
+ */
+public class OpaqueIndexBuilder {
+
+ public static OpaqueIndex getDefaultInstance(java.lang.String defaultValue) {
+ try {
+ final long value = Long.parseLong(defaultValue); // u32 value
+ return new OpaqueIndex(value);
+ } catch (NumberFormatException e) {
+ return new OpaqueIndex(VppNodeBuilder.getDefaultInstance(defaultValue));
+ }
+ }
+
+}
diff --git a/vpp-classifier/api/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpp/classifier/rev161214/VppNodeBuilder.java b/vpp-classifier/api/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpp/classifier/rev161214/VppNodeBuilder.java
new file mode 100644
index 000000000..1c13e80d7
--- /dev/null
+++ b/vpp-classifier/api/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpp/classifier/rev161214/VppNodeBuilder.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2017 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classifier.rev161214;
+
+
+/**
+ * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation.
+ * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32).
+ *
+ * The reason behind putting it under src/main/java is:
+ * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent
+ * loss of user code.
+ *
+ */
+public class VppNodeBuilder {
+
+ public static VppNode getDefaultInstance(java.lang.String defaultValue) {
+ if (PacketHandlingAction.Deny.toString().equalsIgnoreCase(defaultValue)) {
+ return new VppNode(PacketHandlingAction.Deny);
+ } else if (PacketHandlingAction.Permit.toString().equalsIgnoreCase(defaultValue)) {
+ return new VppNode(PacketHandlingAction.Permit);
+ } else {
+ return new VppNode(new VppNodeName(defaultValue));
+ }
+ }
+
+}
diff --git a/vpp-classifier/api/src/main/yang/ietf-access-control-list.yang b/vpp-classifier/api/src/main/yang/ietf-access-control-list.yang
new file mode 100644
index 000000000..3083ee2a0
--- /dev/null
+++ b/vpp-classifier/api/src/main/yang/ietf-access-control-list.yang
@@ -0,0 +1,208 @@
+module ietf-access-control-list {
+ yang-version 1.1;
+ namespace "urn:ietf:params:xml:ns:yang:ietf-access-control-list";
+ prefix acl;
+ import ietf-yang-types {
+ prefix yang;
+ }
+ import ietf-packet-fields {
+ prefix packet-fields;
+ }
+ organization "IETF NETMOD (NETCONF Data Modeling Language)
+ Working Group";
+ contact
+ "WG Web: http://tools.ietf.org/wg/netmod/
+ WG List: netmod@ietf.org
+ WG Chair: Juergen Schoenwaelder
+ j.schoenwaelder@jacobs-university.de
+ WG Chair: Tom Nadeau
+ tnadeau@lucidvision.com
+ Editor: Dean Bogdanovic
+ ivandean@gmail.com
+ Editor: Kiran Agrahara Sreenivasa
+ kkoushik@cisco.com
+ Editor: Lisa Huang
+ lyihuang16@gmail.com
+ Editor: Dana Blair
+ dblair@cisco.com";
+ description
+ "This YANG module defines a component that describing the
+ configuration of Access Control Lists (ACLs).
+ Copyright (c) 2015 IETF Trust and the persons identified as
+ the document authors. All rights reserved.
+ Redistribution and use in source and binary forms, with or
+ without modification, is permitted pursuant to, and subject
+ to the license terms contained in, the Simplified BSD
+ License set forth in Section 4.c of the IETF Trust's Legal
+ Provisions Relating to IETF Documents
+ (http://trustee.ietf.org/license-info).
+ This version of this YANG module is part of RFC XXXX; see
+ the RFC itself for full legal notices.";
+ revision 2016-07-08 {
+ description
+ "Base model for Network Access Control List (ACL).";
+ reference
+ "RFC XXXX: Network Access Control List (ACL)
+ YANG Data Model";
+ }
+ identity acl-base {
+ description
+ "Base Access Control List type for all Access Control List type
+ identifiers.";
+ }
+ identity ipv4-acl {
+ base acl:acl-base;
+ description
+ "ACL that primarily matches on fields from the IPv4 header
+ (e.g. IPv4 destination address) and layer 4 headers (e.g. TCP
+ destination port). An acl of type ipv4-acl does not contain
+ matches on fields in the ethernet header or the IPv6 header.";
+ }
+ identity ipv6-acl {
+ base acl:acl-base;
+ description
+ "ACL that primarily matches on fields from the IPv6 header
+ (e.g. IPv6 destination address) and layer 4 headers (e.g. TCP
+ destination port). An acl of type ipv6-acl does not contain
+ matches on fields in the ethernet header or the IPv4 header.";
+ }
+ identity eth-acl {
+ base acl:acl-base;
+ description
+ "ACL that primarily matches on fields in the ethernet header,
+ like 10/100/1000baseT or WiFi Access Control List. An acl of
+ type eth-acl does not contain matches on fields in the IPv4
+ header, IPv6 header or layer 4 headers.";
+ }
+ typedef acl-type {
+ type identityref {
+ base acl:acl-base;
+ }
+ description
+ "This type is used to refer to an Access Control List
+ (ACL) type";
+ }
+ typedef access-control-list-ref {
+ type leafref {
+ path "/access-lists/acl/acl-name";
+ }
+ description
+ "This type is used by data models that need to reference an
+ Access Control List";
+ }
+ container access-lists {
+ description
+ "This is a top level container for Access Control Lists.
+ It can have one or more Access Control Lists.";
+ list acl {
+ key "acl-type acl-name";
+ description
+ "An Access Control List(ACL) is an ordered list of
+ Access List Entries (ACE). Each Access Control Entry has a
+ list of match criteria and a list of actions.
+ Since there are several kinds of Access Control Lists
+ implemented with different attributes for
+ different vendors, this
+ model accommodates customizing Access Control Lists for
+ each kind and for each vendor.";
+ leaf acl-name {
+ type string;
+ description
+ "The name of access-list. A device MAY restrict the length
+ and value of this name, possibly space and special
+ characters are not allowed.";
+ }
+ leaf acl-type {
+ type acl-type;
+ description
+ "Type of access control list. Indicates the primary intended
+ type of match criteria (e.g. ethernet, IPv4, IPv6, mixed, etc)
+ used in the list instance.";
+ }
+ container acl-oper-data {
+ config false;
+ description
+ "Overall Access Control List operational data";
+ }
+ container access-list-entries {
+ description
+ "The access-list-entries container contains
+ a list of access-list-entries(ACE).";
+ list ace {
+ key "rule-name";
+ ordered-by user;
+ description
+ "List of access list entries(ACE)";
+ leaf rule-name {
+ type string;
+ description
+ "A unique name identifying this Access List
+ Entry(ACE).";
+ }
+ container matches {
+ description
+ "Definitions for match criteria for this Access List
+ Entry.";
+ choice ace-type {
+ description
+ "Type of access list entry.";
+ case ace-ip {
+ description "IP Access List Entry.";
+ choice ace-ip-version {
+ description
+ "IP version used in this Access List Entry.";
+ case ace-ipv4 {
+ uses packet-fields:acl-ipv4-header-fields;
+ }
+ case ace-ipv6 {
+ uses packet-fields:acl-ipv6-header-fields;
+ }
+ }
+ uses packet-fields:acl-ip-header-fields;
+ }
+ case ace-eth {
+ description
+ "Ethernet Access List entry.";
+ uses packet-fields:acl-eth-header-fields;
+ }
+ }
+ }
+ container actions {
+ description
+ "Definitions of action criteria for this Access List
+ Entry.";
+ choice packet-handling {
+ default "deny";
+ description
+ "Packet handling action.";
+ case deny {
+ leaf deny {
+ type empty;
+ description
+ "Deny action.";
+ }
+ }
+ case permit {
+ leaf permit {
+ type empty;
+ description
+ "Permit action.";
+ }
+ }
+ }
+ }
+ container ace-oper-data {
+ config false;
+ description
+ "Operational data for this Access List Entry.";
+ leaf match-counter {
+ type yang:counter64;
+ description
+ "Number of matches for this Access List Entry";
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/vpp-classifier/api/src/main/yang/ietf-packet-fields.yang b/vpp-classifier/api/src/main/yang/ietf-packet-fields.yang
new file mode 100644
index 000000000..0b1ce5cdd
--- /dev/null
+++ b/vpp-classifier/api/src/main/yang/ietf-packet-fields.yang
@@ -0,0 +1,180 @@
+module ietf-packet-fields {
+ yang-version 1.1;
+ namespace "urn:ietf:params:xml:ns:yang:ietf-packet-fields";
+ prefix packet-fields;
+ import ietf-inet-types {
+ prefix inet;
+ }
+ import ietf-yang-types {
+ prefix yang;
+ }
+ organization "IETF NETMOD (NETCONF Data Modeling Language) Working
+ Group";
+ contact
+ "WG Web: http://tools.ietf.org/wg/netmod/
+ WG List: netmod@ietf.org
+ WG Chair: Juergen Schoenwaelder
+ j.schoenwaelder@jacobs-university.de
+ WG Chair: Tom Nadeau
+ tnadeau@lucidvision.com
+ Editor: Dean Bogdanovic
+ deanb@juniper.net
+ Editor: Kiran Agrahara Sreenivasa
+ kkoushik@cisco.com
+ Editor: Lisa Huang
+ lyihuang16@gmail.com
+ Editor: Dana Blair
+ dblair@cisco.com";
+ description
+ "This YANG module defines groupings that are used by
+ ietf-access-control-list YANG module. Their usage is not
+ limited to ietf-access-control-list and can be
+ used anywhere as applicable.
+ Copyright (c) 2015 IETF Trust and the persons identified as
+ the document authors. All rights reserved.
+ Redistribution and use in source and binary forms, with or
+ without modification, is permitted pursuant to, and subject
+ to the license terms contained in, the Simplified BSD
+ License set forth in Section 4.c of the IETF Trust's Legal
+ Provisions Relating to IETF Documents
+ (http://trustee.ietf.org/license-info).
+ This version of this YANG module is part of RFC XXXX; see
+ the RFC itself for full legal notices.";
+ revision 2016-07-08 {
+ description
+ "Initial version of packet fields used by
+ ietf-access-control-list";
+ reference
+ "RFC XXXX: Network Access Control List (ACL)
+ YANG Data Model";
+ }
+ grouping acl-transport-header-fields {
+ description
+ "Transport header fields";
+ container source-port-range {
+ presence "Enables setting source port range";
+ description
+ "Inclusive range representing source ports to be used.
+ When only lower-port is present, it represents a single port.";
+ leaf lower-port {
+ type inet:port-number;
+ mandatory true;
+ description
+ "Lower boundary for port.";
+ }
+ leaf upper-port {
+ type inet:port-number;
+ must ". >= ../lower-port" {
+ error-message
+ "The upper-port must be greater than or equal to lower-port";
+ }
+ description
+ "Upper boundary for port . If existing, the upper port
+ must be greater or equal to lower-port.";
+ }
+ }
+ container destination-port-range {
+ presence "Enables setting destination port range";
+ description
+ "Inclusive range representing destination ports to be used. When
+ only lower-port is present, it represents a single port.";
+ leaf lower-port {
+ type inet:port-number;
+ mandatory true;
+ description
+ "Lower boundary for port.";
+ }
+ leaf upper-port {
+ type inet:port-number;
+ must ". >= ../lower-port" {
+ error-message
+ "The upper-port must be greater than or equal to lower-port";
+ }
+
+ description
+ "Upper boundary for port. If existing, the upper port must
+ be greater or equal to lower-port";
+ }
+ }
+ }
+ grouping acl-ip-header-fields {
+ description
+ "IP header fields common to ipv4 and ipv6";
+ leaf dscp {
+ type inet:dscp;
+ description
+ "Value of dscp.";
+ }
+ leaf protocol {
+ type uint8;
+ description
+ "Internet Protocol number.";
+ }
+ uses acl-transport-header-fields;
+ }
+ grouping acl-ipv4-header-fields {
+ description
+ "Fields in IPv4 header.";
+ leaf destination-ipv4-network {
+ type inet:ipv4-prefix;
+ description
+ "Destination IPv4 address prefix.";
+ }
+ leaf source-ipv4-network {
+ type inet:ipv4-prefix;
+ description
+ "Source IPv4 address prefix.";
+ }
+ }
+ grouping acl-ipv6-header-fields {
+ description
+ "Fields in IPv6 header";
+ leaf destination-ipv6-network {
+ type inet:ipv6-prefix;
+ description
+ "Destination IPv6 address prefix.";
+ }
+ leaf source-ipv6-network {
+ type inet:ipv6-prefix;
+ description
+ "Source IPv6 address prefix.";
+ }
+ leaf flow-label {
+ type inet:ipv6-flow-label;
+ description
+ "IPv6 Flow label.";
+ }
+ reference
+ "RFC 4291: IP Version 6 Addressing Architecture
+ RFC 4007: IPv6 Scoped Address Architecture
+ RFC 5952: A Recommendation for IPv6 Address Text Representation";
+ }
+ grouping acl-eth-header-fields {
+ description
+ "Fields in Ethernet header.";
+ leaf destination-mac-address {
+ type yang:mac-address;
+ description
+ "Destination IEEE 802 MAC address.";
+ }
+ leaf destination-mac-address-mask {
+ type yang:mac-address;
+ description
+ "Destination IEEE 802 MAC address mask.";
+ }
+ leaf source-mac-address {
+ type yang:mac-address;
+ description
+ "Source IEEE 802 MAC address.";
+ }
+ leaf source-mac-address-mask {
+ type yang:mac-address;
+ description
+ "Source IEEE 802 MAC address mask.";
+ }
+ reference
+ "IEEE 802: IEEE Standard for Local and Metropolitan Area
+ Networks: Overview and Architecture.";
+ }
+
+} \ No newline at end of file
diff --git a/vpp-classifier/api/src/main/yang/vpp-classifier-acl.yang b/vpp-classifier/api/src/main/yang/vpp-classifier-acl.yang
new file mode 100644
index 000000000..ccf3e286a
--- /dev/null
+++ b/vpp-classifier/api/src/main/yang/vpp-classifier-acl.yang
@@ -0,0 +1,183 @@
+module vpp-classifier-acl {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:vpp:classifier:acl";
+ prefix "vpp-classifier-acl";
+
+ revision "2016-12-14" {
+ description
+ "Initial revision of vpp-classfier-acl model.";
+ }
+
+ import ietf-access-control-list {
+ prefix "acl";
+ }
+
+ import vpp-classifier {
+ prefix "vpp-classifier";
+ }
+
+ import yang-ext {
+ prefix "ext";
+ }
+
+ import ietf-packet-fields {
+ prefix packet-fields;
+ }
+
+ identity mixed-acl {
+ base acl:acl-base;
+ description
+ "ACL that can match on any of L2/L3/L4 fields.";
+ }
+
+ typedef interface-mode {
+ type enumeration {
+ enum "l2";
+ enum "l3";
+ }
+ }
+
+ grouping acl-base-attributes {
+ description
+ "Defines references to classify tables.
+ At least one table reference should be specified.";
+ container l2-acl {
+ leaf classify-table {
+ type vpp-classifier:classify-table-ref;
+ description
+ "An L2 ACL table";
+ }
+ }
+ container ip4-acl {
+ leaf classify-table {
+ type vpp-classifier:classify-table-ref;
+ description
+ "An IPv4 ACL table";
+ }
+ }
+ container ip6-acl {
+ leaf classify-table {
+ type vpp-classifier:classify-table-ref;
+ description
+ "An IPv6 ACL table";
+ }
+ }
+ }
+
+ grouping ietf-acl-base-attributes {
+ description
+ "Provides limited support for ietf-acl model.";
+
+ container access-lists {
+ description
+ "Defines references to ietf-acl lists.
+ ACLs are translated into classify tables and sessions when assigned to interface.
+
+ In case of L2 interfaces, acls are translated into a chain of classify tables and assigned as L2 table.
+ In case of L3 interfaces, acls are translated into ip4 and ip6 chains (eth only rules go to both chains,
+ rest - depending on ip-version).
+ User ordering is preserved in both cases.
+
+ Assignment update/delete removes all created tables and sessions and repeats process described above.
+ Update/delete of ACL lists referenced here is not permitted (assignment needs to be removed first).
+
+ Read is supported only for acls that were created and assigned by Honeycomb agent
+ (corresponding metadata is present).
+
+ Extensions:
+ - mixing ACEs of different type in one list is permited
+ - mixing L2/L3/L4 rules in one ACE is permited
+
+ Limitations (due to vpp limitations):
+ - egress rules are currently ignored (HONEYCOMB-234)
+ - L4 rules support is limited (every <src,dst> port pair from provided ranges is translated to single classify
+ session; which can very slow or even crash vpp if ranges are big, see HONEYCOMB-260)
+ - ace-ip-version needs to be provided for all aces (consequence of posibility to mix ACEs of different types,
+ and vpp classfier api limitation: common header fields for IP4/IP6 have different offsets)
+ - L2 rules on L3 interfaces are applied only to IP traffic (vpp classfier limitation)
+ - vlan tags are supported only for sub-interfaces defined as exact-match";
+
+ list acl {
+ key "type name";
+ ordered-by user;
+
+ leaf type {
+ type acl:acl-type;
+ }
+
+ leaf name {
+ type acl:access-control-list-ref;
+ }
+ }
+
+ leaf default-action {
+ type enumeration {
+ enum "deny";
+ enum "permit";
+ }
+ default "deny";
+ description
+ "Default action applied to packet that does not match any of rules defined in assigned ACLs.
+ It is translated to single classify table and applied at the end of assigned chains.";
+ }
+
+ leaf mode {
+ type interface-mode;
+ default l3;
+ description
+ "The way ACLs are translated depends on the interface mode.
+ In case of L2 interfaces (bridge/interconnection)
+ classify tables are assigned as l2_table using input_acl_set_interface (ether type matching is automatically
+ added in case of L3 rules).
+ In case of L3 interfaces, classify tables are assigned as ip4/ip6 tables.
+
+ It is the user responsibility to choose mode that matches target interface.
+ ";
+ }
+ }
+ }
+
+ grouping vpp-acl-attributes {
+ container acl {
+ container ingress {
+ uses vpp-classifier-acl:acl-base-attributes;
+ }
+ container egress {
+ uses vpp-classifier-acl:acl-base-attributes;
+ }
+ }
+
+ container ietf-acl {
+ container ingress {
+ uses vpp-classifier-acl:ietf-acl-base-attributes;
+ }
+ container egress {
+ uses vpp-classifier-acl:ietf-acl-base-attributes;
+ }
+ }
+ }
+
+ augment /acl:access-lists/acl:acl/acl:access-list-entries/acl:ace/acl:matches/acl:ace-type {
+ ext:augment-identifier "vpp-classfier-acl-type-augmentation";
+ case ace-ip-and-eth {
+ description
+ "Access List entry that can define both ip and eth rules.";
+ container ace-ip-and-eth-nodes {
+
+ choice ace-ip-version {
+ description
+ "IP version used in this Access List Entry.";
+ mandatory true;
+ case ace-ipv4 {
+ uses packet-fields:acl-ipv4-header-fields;
+ }
+ case ace-ipv6 {
+ uses packet-fields:acl-ipv6-header-fields;
+ }
+ }
+ uses packet-fields:acl-ip-header-fields;
+ uses packet-fields:acl-eth-header-fields;
+ }
+ }
+ }
+} \ No newline at end of file
diff --git a/vpp-classifier/api/src/main/yang/vpp-classifier-context.yang b/vpp-classifier/api/src/main/yang/vpp-classifier-context.yang
new file mode 100644
index 000000000..01eae862d
--- /dev/null
+++ b/vpp-classifier/api/src/main/yang/vpp-classifier-context.yang
@@ -0,0 +1,68 @@
+module vpp-classifier-context {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:vpp:classifier";
+ prefix "vpp-classifier-context";
+
+ description
+ "This module contains vpp classfier metadata definition";
+
+ revision "2016-09-09" {
+ description
+ "Initial revision.";
+ }
+
+ container vpp-classifier-context {
+
+ config "false";
+
+ description
+ "Classify tables and sessions contain relative node indexes. Management agent like Honeycomb,
+ needs to use node names instead (indexes might change after vpp restart).
+ VPP does not provide relative index to node name conversion (https://jira.fd.io/browse/VPP-219),
+ also finding base node that is needed to perform the conversion
+ is not allways possible (https://jira.fd.io/browse/VPP-220).
+
+ Therefore Honeycomb needs to provide relative node to index mapping.
+ ";
+
+ list classify-table-context {
+ key "name";
+ unique "index";
+
+ leaf name {
+ type string;
+ description
+ "Name of the classify table.";
+ }
+
+ leaf index {
+ type int32;
+ description
+ "Classify table index used by VPP.";
+ }
+
+ leaf classifier-node-name {
+ type string;
+ description
+ "Name of VPP node the table is defined for.";
+ }
+
+ list node-context {
+ key "name";
+ unique "index";
+
+ leaf name {
+ type string;
+ description
+ "Name of vpp node (neighbour of classifier-node-name)";
+ }
+
+ leaf index {
+ type int32;
+ description
+ "Inted of the vpp node relative to classifier-node-name";
+ }
+ }
+ }
+ }
+} \ No newline at end of file
diff --git a/vpp-classifier/api/src/main/yang/vpp-classifier.yang b/vpp-classifier/api/src/main/yang/vpp-classifier.yang
new file mode 100644
index 000000000..beb4def85
--- /dev/null
+++ b/vpp-classifier/api/src/main/yang/vpp-classifier.yang
@@ -0,0 +1,215 @@
+module vpp-classifier {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:vpp:classifier";
+ prefix "vpp-classifier";
+
+ revision "2016-12-14" {
+ description
+ "This revision adds the following new features:
+ - updates order of union types for opaque-index";
+ }
+
+ revision "2015-06-03" {
+ description
+ "Initial revision of model for VPP packet classifier.
+ The model can be used ony to implement ACLs.
+ Other classify table usages are not supported yet,
+ see https://jira.fd.io/browse/VPP-203 for details.";
+ reference
+ "https://wiki.fd.io/view/VPP/Introduction_To_N-tuple_Classifiers";
+ }
+
+ import ietf-yang-types {
+ prefix "yang";
+ }
+
+ typedef classify-table-ref {
+ type leafref {
+ path "/vpp-classifier:vpp-classifier/classify-table/name";
+ }
+ description
+ "This type is used by data models that need to reference
+ configured classify tables.";
+ }
+
+ typedef packet-handling-action {
+ type enumeration {
+ enum "deny" {
+ // by VPP convention, first neighbour node (at index 0) is a drop node
+ value 0;
+ }
+ enum "permit" {
+ value -1; // indicates that the next node not set
+ }
+ }
+ }
+
+ typedef vpp-node-name {
+ type string;
+ }
+
+ typedef vpp-node {
+ type union {
+ type packet-handling-action;
+ type vpp-node-name;
+ }
+ description
+ "Defines VPP node reference using packet handling action or relative node name
+ (if definition in terms of packet handling action is not possible).";
+ }
+
+ typedef opaque-index {
+ type union {
+ type uint32;
+ type vpp-node;
+ }
+ description
+ "Defines opaque-index type - metadata that can be attached to session-hit packets.
+ Vpp nodes can't be referenced by index, because node indexes might change after vpp restart.";
+ }
+
+ grouping classify-session-attributes {
+ description
+ "Defines classify session attributes that are mapped to classify_add_del_session
+ and classify_session_details messages parameters.";
+
+ leaf hit_next {
+ type vpp-node;
+ mandatory true;
+ description
+ "Vpp node to which packet will be send when it produces a match.";
+ }
+ leaf opaque_index {
+ type opaque-index;
+ }
+ leaf advance {
+ type int32;
+ default 0;
+ description
+ "Nodes like ip4/6-classify use the parameter to \"consume\" networking layer.
+ Example: tunnel decapsulation.";
+ }
+ }
+
+ grouping classify-table-base-attributes {
+ description
+ "Defines classify table attributes that are mapped to classify_add_del_table message parameters.";
+
+ leaf classifier-node {
+ type vpp-node-name;
+ description
+ "Name of VPP node the table is defined for.";
+ }
+ leaf nbuckets {
+ mandatory true;
+ type uint32;
+ description
+ "Used by classifier hashing algorithm. It is not possible to resize the bucket array,
+ therefore suggested value is approximate number of expected entries.";
+ }
+ leaf skip_n_vectors {
+ type uint32;
+ default 0;
+ description
+ "Number of 16 byte vectors to be skipped before applying mask.";
+ }
+ leaf next_table {
+ type classify-table-ref;
+ description
+ "Reference to the next classify table. Required when multiple table chaining is used.";
+ }
+ leaf miss_next {
+ mandatory true;
+ type vpp-node;
+ description
+ "Vpp node to which packet will be send when it falis to produce a match";
+ }
+ leaf mask {
+ type yang:hex-string;
+ mandatory true;
+ description
+ "Defines match mask (multiple of 16 bytes)";
+ }
+
+ list classify-session {
+ key "match";
+
+ leaf match {
+ type yang:hex-string;
+ description
+ "Defines actual value to be matched that is
+ a byte vector, which length is multiple of 16 bytes";
+
+ must "string-length(match) = string-length(../../mask)" {
+ error-message
+ "Match length is not equal to classify table mask length.";
+ description
+ "Match length must be equal to classify table mask length.";
+ }
+ }
+
+ uses classify-session-attributes;
+ }
+ }
+
+ grouping classify-table-config-attributes {
+ description
+ "Defines classify table config only attributes (present in classify_add_del_table message
+ but not in classify_table_info_reply).";
+
+ // TODO(HC2VPP-10): move to classify-table-base-attributes
+ // after https://jira.fd.io/browse/VPP-208 is fixed
+ leaf memory_size {
+ type uint32;
+ // mandatory true; // TODO(HC2VPP-10): uncomment
+ description
+ "Memory size for classify table and its entries.";
+ }
+ }
+
+ grouping classify-table-operational-attributes {
+ description
+ "Defines classify table operational attributes (present in classify_table_info_reply message
+ but not in classify_add_del_table).";
+
+ leaf active_sessions {
+ type uint32;
+ config false;
+ description
+ "Number of sessions defined for the classify table.";
+ }
+ }
+
+ container vpp-classifier {
+ list classify-table {
+ key "name";
+
+ leaf name {
+ type string;
+ description
+ "Hides classify table identifier managed by vpp.";
+ }
+
+ uses classify-table-base-attributes;
+ uses classify-table-config-attributes;
+ }
+ }
+
+ container vpp-classifier-state {
+ config false;
+
+ list classify-table {
+ key "name";
+
+ leaf name {
+ type string;
+ description
+ "Hides classify table identifier managed by vpp.";
+ }
+
+ uses classify-table-base-attributes;
+ uses classify-table-operational-attributes;
+ }
+ }
+
+}
diff --git a/vpp-classifier/api/src/main/yang/vpp-interface-acl.yang b/vpp-classifier/api/src/main/yang/vpp-interface-acl.yang
new file mode 100644
index 000000000..1932e9c97
--- /dev/null
+++ b/vpp-classifier/api/src/main/yang/vpp-interface-acl.yang
@@ -0,0 +1,32 @@
+module vpp-interface-acl {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:vpp:interface:acl";
+ prefix "vpp-ifc-acl";
+
+ revision "2016-12-14" {
+ description
+ "Initial revision of vpp-acl model.";
+ }
+
+ import ietf-interfaces {
+ prefix "if";
+ }
+
+ import vpp-classifier-acl {
+ prefix "vpp-classifier-acl";
+ }
+
+ import yang-ext {
+ prefix "ext";
+ }
+
+ augment /if:interfaces/if:interface {
+ ext:augment-identifier "vpp-interface-acl-augmentation";
+ uses vpp-classifier-acl:vpp-acl-attributes;
+ }
+
+ augment /if:interfaces-state/if:interface {
+ ext:augment-identifier "vpp-interface-acl-state-augmentation";
+ uses vpp-classifier-acl:vpp-acl-attributes;
+ }
+} \ No newline at end of file
diff --git a/vpp-classifier/api/src/main/yang/vpp-subinterface-acl.yang b/vpp-classifier/api/src/main/yang/vpp-subinterface-acl.yang
new file mode 100644
index 000000000..892a64586
--- /dev/null
+++ b/vpp-classifier/api/src/main/yang/vpp-subinterface-acl.yang
@@ -0,0 +1,36 @@
+module vpp-subinterface-acl {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:vpp:subinterface:acl";
+ prefix "vpp-subifc-acl";
+
+ revision "2016-12-14" {
+ description
+ "Initial revision of vpp-acl model.";
+ }
+
+ import ietf-interfaces {
+ prefix "if";
+ }
+
+ import vpp-vlan {
+ prefix "vpp-vlan";
+ }
+
+ import vpp-classifier-acl {
+ prefix "vpp-classifier-acl";
+ }
+
+ import yang-ext {
+ prefix "ext";
+ }
+
+ augment /if:interfaces/if:interface/vpp-vlan:sub-interfaces/vpp-vlan:sub-interface {
+ ext:augment-identifier "vpp-subinterface-acl-augmentation";
+ uses vpp-classifier-acl:vpp-acl-attributes;
+ }
+
+ augment /if:interfaces-state/if:interface/vpp-vlan:sub-interfaces/vpp-vlan:sub-interface {
+ ext:augment-identifier "vpp-subinterface-acl-state-augmentation";
+ uses vpp-classifier-acl:vpp-acl-attributes;
+ }
+} \ No newline at end of file