diff --git a/netopeer/voltha-transapi/voltha.yang b/netopeer/voltha-transapi/voltha.yang
new file mode 100644
index 0000000..3b15ebf
--- /dev/null
+++ b/netopeer/voltha-transapi/voltha.yang
@@ -0,0 +1,7504 @@
+
+module voltha {
+
+
+
+
+
+    namespace "urn:opencord:params:xml:ns:voltha:voltha";
+    prefix voltha;
+
+    organization "CORD";
+    contact
+        " Any name";
+
+    description
+        "";
+
+    revision "2016-11-15" {
+        description "Initial revision.";
+        reference "reference";
+    }
+
+
+    grouping DeviceGroup {
+        description
+            "";
+        leaf id {
+            type  string; 
+            description
+                "";
+        }
+
+        list logical_devices {
+            key "id";
+            uses  LogicalDevice;
+
+            description
+                "";
+        }
+
+        list devices {
+            key "id";
+            uses  Device;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping DeviceGroups {
+        description
+            "";
+        list items {
+            key "id";
+            uses  DeviceGroup;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+        typedef AlarmFilterRuleKey {
+            type enumeration {
+                enum id {
+                    description "";
+                }
+                enum type {
+                    description "";
+                }
+                enum severity {
+                    description "";
+                }
+                enum resource_id {
+                    description "";
+                }
+                enum category {
+                    description "";
+                }
+                enum device_id {
+                    description "";
+                }
+            }
+            description
+                "";
+        }
+
+    grouping AlarmFilterRule {
+        description
+            "";
+        leaf key {
+            type  AlarmFilterRuleKey;
+
+            description
+                "";
+        }
+
+        leaf value {
+            type  string; 
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping AlarmFilter {
+        description
+            "";
+        leaf id {
+            type  string; 
+            description
+                "";
+        }
+
+        list rules {
+            key "key";
+            uses  AlarmFilterRule;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping AlarmFilters {
+        description
+            "";
+        list filters {
+            key "id";
+            uses  AlarmFilter;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    container VolthaInstance {
+        description
+            "Top-level (root) node for a Voltha Instance";
+        leaf instance_id {
+            type  string; 
+            description
+                "";
+        }
+
+        leaf version {
+            type  string; 
+            description
+                "";
+        }
+
+        leaf log_level {
+            type  LogLevel;
+
+            description
+                "";
+        }
+
+        container health {
+            uses  HealthStatus;
+
+            description
+                "";
+        }
+
+        list adapters {
+            key "id";
+            uses  Adapter;
+
+            description
+                "";
+        }
+
+        list logical_devices {
+            key "id";
+            uses  LogicalDevice;
+
+            description
+                "";
+        }
+
+        list devices {
+            key "id";
+            uses  Device;
+
+            description
+                "";
+        }
+
+        list device_types {
+            key "id";
+            uses  DeviceType;
+
+            description
+                "";
+        }
+
+        list device_groups {
+            key "id";
+            uses  DeviceGroup;
+
+            description
+                "";
+        }
+
+        list alarm_filters {
+            key "id";
+            uses  AlarmFilter;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    container VolthaInstances {
+        description
+            "";
+        list items {
+            key "items";
+            leaf items {
+                type  string; 
+                description
+                    "";
+            }
+            description
+                "";
+        }
+
+
+
+    }
+
+    container Voltha {
+        description
+            "Voltha representing the entire Voltha cluster";
+        leaf version {
+            type  string; 
+            description
+                "";
+        }
+
+        leaf log_level {
+            type  LogLevel;
+
+            description
+                "";
+        }
+
+        list instances {
+            key "instance_id";
+            uses  VolthaInstance_grouping; 
+            description
+                "";
+        }
+
+        list adapters {
+            key "id";
+            uses  Adapter;
+
+            description
+                "";
+        }
+
+        list logical_devices {
+            key "id";
+            uses  LogicalDevice;
+
+            description
+                "";
+        }
+
+        list devices {
+            key "id";
+            uses  Device;
+
+            description
+                "";
+        }
+
+        list device_groups {
+            key "id";
+            uses  DeviceGroup;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping VolthaInstance_grouping {
+        description
+            "Top-level (root) node for a Voltha Instance";
+        leaf instance_id {
+            type  string; 
+            description
+                "";
+        }
+
+        leaf version {
+            type  string; 
+            description
+                "";
+        }
+
+        leaf log_level {
+            type  LogLevel;
+
+            description
+                "";
+        }
+
+        container health {
+            uses  HealthStatus;
+
+            description
+                "";
+        }
+
+        list adapters {
+            key "id";
+            uses  Adapter;
+
+            description
+                "";
+        }
+
+        list logical_devices {
+            key "id";
+            uses  LogicalDevice;
+
+            description
+                "";
+        }
+
+        list devices {
+            key "id";
+            uses  Device;
+
+            description
+                "";
+        }
+
+        list device_types {
+            key "id";
+            uses  DeviceType;
+
+            description
+                "";
+        }
+
+        list device_groups {
+            key "id";
+            uses  DeviceGroup;
+
+            description
+                "";
+        }
+
+        list alarm_filters {
+            key "id";
+            uses  AlarmFilter;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping VolthaInstances_grouping {
+        description
+            "";
+        list items {
+            key "items";
+            leaf items {
+                type  string; 
+                description
+                    "";
+            }
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping Voltha_grouping {
+        description
+            "Voltha representing the entire Voltha cluster";
+        leaf version {
+            type  string; 
+            description
+                "";
+        }
+
+        leaf log_level {
+            type  LogLevel;
+
+            description
+                "";
+        }
+
+        list instances {
+            key "instance_id";
+            uses  VolthaInstance_grouping; 
+            description
+                "";
+        }
+
+        list adapters {
+            key "id";
+            uses  Adapter;
+
+            description
+                "";
+        }
+
+        list logical_devices {
+            key "id";
+            uses  LogicalDevice;
+
+            description
+                "";
+        }
+
+        list devices {
+            key "id";
+            uses  Device;
+
+            description
+                "";
+        }
+
+        list device_groups {
+            key "id";
+            uses  DeviceGroup;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping AdapterConfig {
+        description
+            "";
+        leaf log_level {
+            type  LogLevel;
+
+            description
+                "Common adapter config attributes here";
+        }
+
+        container additional_config {
+            uses  Any;
+
+            description
+                "Custom (vendor-specific) configuration attributes";
+        }
+
+
+
+    }
+
+    grouping Adapter {
+        description
+            "Adapter (software plugin)";
+        leaf id {
+            type  string;
+            description
+                "Unique name of adapter, matching the python packate name under
+ voltha adapters.";
+        }
+
+        leaf vendor {
+            type  string;
+            description
+                "";
+        }
+
+        leaf version {
+            type  string;
+            description
+                "";
+        }
+
+        container config {
+            uses  AdapterConfig;
+
+            description
+                "Adapter configuration";
+        }
+
+        container additional_description {
+            uses  Any;
+
+            description
+                "Custom descriptors and custom configuration";
+        }
+
+        list logical_device_ids {
+            key "logical_device_ids";
+            leaf logical_device_ids {
+                type  string;
+                description
+                    "Logical devices  owned ";
+            }
+            description
+                "Logical devices  owned ";
+        }
+
+
+
+    }
+
+    grouping Adapters {
+        description
+            "";
+        list items {
+            key "id";
+            uses  Adapter;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping Any {
+        description
+            "`Any` contains an arbitrary serialized protocol buffer message along with a
+ URL that describes the type of the serialized message.
+
+ Protobuf library provides support to pack unpack Any values in the form
+ of utility functions or additional generated methods of the Any type.
+
+ Example 1: Pack and unpack a message in C++.
+
+     Foo foo = ...;
+     Any any;
+     any.PackFrom(foo);
+     ...
+     if (any.UnpackTo(&amp;foo))
+       ...
+
+
+ Example 2: Pack and unpack a message in Java.
+
+     Foo foo = ...;
+     Any any = Any.pack(foo);
+     ...
+     if (any.is(Foo.class))
+       foo = any.unpack(Foo.class);
+
+
+  Example 3: Pack and unpack a message in Python.
+
+     foo = Foo(...)
+     any = Any()
+     any.Pack(foo)
+     ...
+     if any.Is(Foo.DESCRIPTOR):
+       any.Unpack(foo)
+       ...
+
+ The pack methods provided by protobuf library will by default use
+ 'type.googleapis.com full.type.name' as the type URL and the unpack
+ methods only use the fully qualified type name after the last ' '
+ in the type URL, for example  foo.bar.com x y.z  will yield type
+ name  y.z .
+
+
+ JSON
+ ====
+ The JSON representation of an `Any` value uses the regular
+ representation of the deserialized, embedded message, with an
+ additional field `@type` which contains the type URL. Example:
+
+     package google.profile;
+     message Person
+       string first_name = 1;
+       string last_name = 2;
+
+
+
+        @type :  type.googleapis.com google.profile.Person ,
+        firstName :  string ,
+        lastName :  string
+
+
+ If the embedded message type is well-known and has a custom JSON
+ representation, that representation will be embedded adding a field
+ `value` which holds the custom JSON in addition to the `@type`
+ field. Example (for message  google.protobuf.Duration   ):
+
+
+        @type :  type.googleapis.com google.protobuf.Duration ,
+        value :  1.212s
+      ";
+        leaf type_url {
+            type  string;
+            description
+                "A URL resource name whose content describes the type of the
+ serialized protocol buffer message.
+
+ For URLs which use the scheme `http`, `https`, or no scheme, the
+ following restrictions and interpretations apply:
+
+   If no scheme is provided, `https` is assumed.
+   The last segment of the URL's path must represent the fully
+   qualified name of the type (as in `path google.protobuf.Duration`).
+   The name should be in a canonical form (e.g., leading  .  is
+   not accepted).
+   An HTTP GET on the URL must yield a  google.protobuf.Type
+   value in binary format, or produce an error.
+   Applications are allowed to cache lookup results based on the
+   URL, or have them precompiled into a binary to avoid any
+   lookup. Therefore, binary compatibility needs to be preserved
+   on changes to types. (Use versioned type names to manage
+   breaking changes.)
+
+ Schemes other than `http`, `https` (or the empty scheme) might be
+ used with implementation specific semantics.";
+        }
+
+        leaf value {
+            type  binary;
+            description
+                "Must be a valid serialized protocol buffer of the above specified type.";
+        }
+
+
+
+    }
+
+    typedef LogLevel {
+        type enumeration {
+            enum DEBUG {
+                description "";
+            }
+            enum INFO {
+                description "";
+            }
+            enum WARNING {
+                description "";
+            }
+            enum ERROR {
+                description "";
+            }
+            enum CRITICAL {
+                description "";
+            }
+        }
+        description
+            "Logging verbosity level";
+    }
+    typedef AdminState {
+        type enumeration {
+            enum UNKNOWN {
+                description "";
+            }
+            enum PREPROVISIONED {
+                description "";
+            }
+            enum ENABLED {
+                description "";
+            }
+            enum DISABLED {
+                description "";
+            }
+        }
+        description
+            "Administrative State";
+    }
+    typedef OperStatus {
+        type enumeration {
+            enum UNKNOWN {
+                description "";
+            }
+            enum DISCOVERED {
+                description "";
+            }
+            enum ACTIVATING {
+                description "";
+            }
+            enum TESTING {
+                description "";
+            }
+            enum ACTIVE {
+                description "";
+            }
+            enum FAILED {
+                description "";
+            }
+        }
+        description
+            "Operational Status";
+    }
+    typedef ConnectStatus {
+        type enumeration {
+            enum UNKNOWN {
+                description "";
+            }
+            enum UNREACHABLE {
+                description "";
+            }
+            enum REACHABLE {
+                description "";
+            }
+        }
+        description
+            "Connectivity Status";
+    }
+
+    grouping ID {
+        description
+            "Convey a resource identifier";
+        leaf id {
+            type  string;
+            description
+                "";
+        }
+
+
+
+    }
+
+    typedef PortType {
+        type enumeration {
+            enum UNKNOWN {
+                description "";
+            }
+            enum ETHERNET_NNI {
+                description "";
+            }
+            enum ETHERNET_UNI {
+                description "";
+            }
+            enum PON_OLT {
+                description "";
+            }
+            enum PON_ONU {
+                description "";
+            }
+        }
+        description
+            "";
+    }
+
+    grouping DeviceType {
+        description
+            "A Device Type";
+        leaf id {
+            type  string;
+            description
+                "Unique name for the device type";
+        }
+
+        leaf adapter {
+            type  string;
+            description
+                "Name of the adapter that handles device type";
+        }
+
+        leaf accepts_bulk_flow_update {
+            type  boolean;
+            description
+                "Capabilitities";
+        }
+
+        leaf accepts_add_remove_flow_updates {
+            type  boolean;
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping DeviceTypes {
+        description
+            "A plurality of device types";
+        list items {
+            key "id";
+            uses  DeviceType;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping PmConfig {
+        description
+            "";
+        leaf name {
+            type  string;
+            description
+                "";
+        }
+
+        leaf type {
+            type  PmType;
+            description
+                "";
+        }
+
+        leaf enabled {
+            type  boolean;
+            description
+                "Whether or not this metric makes it to Kafka";
+        }
+
+        leaf sample_freq {
+            type  uint32;
+            description
+                "Sample rate in 10ths of a second";
+        }
+
+
+
+        typedef PmType {
+            type enumeration {
+                enum COUNTER {
+                    description "";
+                }
+                enum GUAGE {
+                    description "";
+                }
+                enum STATE {
+                    description "";
+                }
+            }
+            description
+                "";
+        }
+
+    }
+
+    grouping PmGroupConfig {
+        description
+            "";
+        leaf group_name {
+            type  string;
+            description
+                "";
+        }
+
+        leaf group_freq {
+            type  uint32;
+            description
+                "Frequency applicable to the grop";
+        }
+
+        leaf enabled {
+            type  boolean;
+            description
+                "Enable disable group level only";
+        }
+
+        list metrics {
+            key "name";
+            uses  PmConfig;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping PmConfigs {
+        description
+            "";
+        leaf id {
+            type  string;
+            description
+                "To work around a chameleon POST bug";
+        }
+
+        leaf default_freq {
+            type  uint32;
+            description
+                "Default sample rate";
+        }
+
+        leaf grouped {
+            type  boolean;
+            description
+                "Forces group names and group semantics";
+        }
+
+        leaf freq_override {
+            type  boolean;
+            description
+                "Allows Pm to set an individual sample frequency";
+        }
+
+        list groups {
+            key "group_name";
+            uses  PmGroupConfig;
+
+            description
+                "The groups if grouped is true";
+        }
+
+        list metrics {
+            key "name";
+            uses  PmConfig;
+
+            description
+                "The metrics themselves if grouped is false.";
+        }
+
+
+
+    }
+
+    grouping PeerPort {
+        description
+            "";
+        leaf device_id {
+            type  string;
+            description
+                "";
+        }
+
+        leaf port_no {
+            type  uint32;
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping Port {
+        description
+            "";
+        leaf port_no {
+            type  uint32;
+            description
+                "Device-unique port number";
+        }
+
+        leaf label {
+            type  string;
+            description
+                "Arbitrary port label";
+        }
+
+        leaf type {
+            type  PortType;
+            description
+                "Type of port";
+        }
+
+        leaf admin_state {
+            type  AdminState;
+
+            description
+                "";
+        }
+
+        leaf oper_status {
+            type  OperStatus;
+
+            description
+                "";
+        }
+
+        leaf device_id {
+            type  string;
+            description
+                "Unique .id of device that owns this port";
+        }
+
+        list peers {
+            key "device_id";
+            uses  PeerPort;
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping Ports {
+        description
+            "";
+        list items {
+            key "port_no";
+            uses  Port;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping ProxyAddress {
+        description
+            "";
+        leaf device_id {
+            type  string;
+            description
+                "Which device to use as proxy to this device";
+        }
+
+        leaf channel_id {
+            type  uint32;
+            description
+                "Sub-address within proxy";
+        }
+
+        leaf onu_id {
+            type  uint32;
+            description
+                "onu identifier; optional";
+        }
+
+        leaf onu_session_id {
+            type  uint32;
+            description
+                "session identifier for the ONU; optional";
+        }
+
+
+
+    }
+
+    grouping Device {
+        description
+            "A Physical Device instance";
+        leaf id {
+            type  string;
+            description
+                "Voltha's device identifier";
+        }
+
+        leaf type {
+            type  string;
+            description
+                "Device type, refers to one of the registered device types";
+        }
+
+        leaf root {
+            type  boolean;
+            description
+                "Is this device a root device. Each logical switch has one root
+ device that is associated with the logical flow switch.";
+        }
+
+        leaf parent_id {
+            type  string;
+            description
+                "Parent device id, in the device tree (for a root device, the parent_id
+ is the logical_device.id)";
+        }
+
+        leaf parent_port_no {
+            type  uint32;
+            description
+                "";
+        }
+
+        leaf vendor {
+            type  string;
+            description
+                "Vendor, version, serial number, etc.";
+        }
+
+        leaf model {
+            type  string;
+            description
+                "";
+        }
+
+        leaf hardware_version {
+            type  string;
+            description
+                "";
+        }
+
+        leaf firmware_version {
+            type  string;
+            description
+                "";
+        }
+
+        leaf software_version {
+            type  string;
+            description
+                "";
+        }
+
+        leaf serial_number {
+            type  string;
+            description
+                "";
+        }
+
+        leaf adapter {
+            type  string;
+            description
+                "Addapter that takes care of device";
+        }
+
+        leaf vlan {
+            type  uint32;
+            description
+                "Device contact on vlan (if 0, no vlan)";
+        }
+
+        container proxy_address {
+            uses  ProxyAddress;
+            description
+                "";
+        }
+
+        leaf admin_state {
+            type  AdminState;
+
+            description
+                "";
+        }
+
+        leaf oper_status {
+            type  OperStatus;
+
+            description
+                "";
+        }
+
+        leaf reason {
+            type  string;
+            description
+                "Used in FAILED state";
+        }
+
+        leaf connect_status {
+            type  ConnectStatus;
+
+            description
+                "";
+        }
+
+        container custom {
+            uses  Any;
+
+            description
+                "Device type specific attributes
+TODO additional common attribute here";
+        }
+
+        list ports {
+            key "port_no";
+            uses  Port;
+
+            description
+                "";
+        }
+
+        container flows {
+            uses  Flows;
+
+            description
+                "";
+        }
+
+        container flow_groups {
+            uses  FlowGroups;
+
+            description
+                "";
+        }
+
+        container pm_configs {
+            uses  PmConfigs;
+
+            description
+                "PmConfigs will eventually converted to a child node of the
+ device to falicitata callbacks and to simplify manipulation.";
+        }
+
+
+
+        choice choice_0 {
+            case mac_address {
+                leaf mac_address {
+                    type  string;
+                    description
+                        "Device contact MAC address (format:  xx:xx:xx:xx:xx:xx )";
+                }
+            }
+            case ipv4_address {
+                leaf ipv4_address {
+                    type  string;
+                    description
+                        "Device contact IPv4 address (format:  a.b.c.d  or can use hostname too)";
+                }
+            }
+            case ipv6_address {
+                leaf ipv6_address {
+                    type  string;
+                    description
+                        "Device contact IPv6 address using the canonical string form
+ ( xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx )";
+                }
+            }
+            case host_and_port {
+                leaf host_and_port {
+                    type  string;
+                    description
+                        "";
+                }
+            }
+        }
+
+
+    }
+
+    grouping Devices {
+        description
+            "";
+        list items {
+            key "id";
+            uses  Device;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+
+    grouping Empty {
+        description
+            "A generic empty message that you can re-use to avoid defining duplicated
+ empty messages in your APIs. A typical example is to use it as the request
+ or the response type of an API method. For instance:
+
+     service Foo
+       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+
+
+ The JSON representation for `Empty` is empty JSON object `  `.";
+
+
+    }
+
+
+    grouping HealthStatus {
+        description
+            "Encode health status of a Voltha instance";
+        leaf state {
+            type  HealthState;
+            description
+                "Current state of health of this Voltha instance";
+        }
+
+
+
+        typedef HealthState {
+            type enumeration {
+                enum HEALTHY {
+                    description "";
+                }
+                enum OVERLOADED {
+                    description "";
+                }
+                enum DYING {
+                    description "";
+                }
+            }
+            description
+                "Health states";
+        }
+
+    }
+
+    grouping LogicalPort {
+        description
+            "";
+        leaf id {
+            type  string;
+            description
+                "";
+        }
+
+        container ofp_port {
+            uses  ofp_port;
+
+            description
+                "";
+        }
+
+        leaf device_id {
+            type  string;
+            description
+                "";
+        }
+
+        leaf device_port_no {
+            type  uint32;
+            description
+                "";
+        }
+
+        leaf root_port {
+            type  boolean;
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping LogicalPorts {
+        description
+            "";
+        list items {
+            key "id";
+            uses  LogicalPort;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping LogicalDevice {
+        description
+            "";
+        leaf id {
+            type  string;
+            description
+                "unique id of logical device";
+        }
+
+        leaf datapath_id {
+            type  uint64;
+            description
+                "unique datapath id for the logical device (used by the SDN controller)";
+        }
+
+        container desc {
+            uses  ofp_desc;
+
+            description
+                "device description";
+        }
+
+        container switch_features {
+            uses  ofp_switch_features;
+
+            description
+                "device features";
+        }
+
+        leaf root_device_id {
+            type  string;
+            description
+                "name of the root device anchoring logical device";
+        }
+
+        list ports {
+            key "id";
+            uses  LogicalPort;
+
+            description
+                "logical device ports";
+        }
+
+        container flows {
+            uses  Flows;
+
+            description
+                "flows configured on the logical device";
+        }
+
+        container flow_groups {
+            uses  FlowGroups;
+
+            description
+                "flow groups configured on the logical device";
+        }
+
+
+
+    }
+
+    grouping LogicalDevices {
+        description
+            "";
+        list items {
+            key "id";
+            uses  LogicalDevice;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+
+    typedef Access {
+        type enumeration {
+            enum CONFIG {
+                description "";
+            }
+            enum READ_ONLY {
+                description "";
+            }
+            enum REAL_TIME {
+                description "";
+            }
+        }
+        description
+            "";
+    }
+
+    container ChildNode {
+        description
+            "";
+        leaf key {
+            type  string;
+            description
+                "";
+        }
+
+
+
+    }
+
+    typedef ofp_port_no {
+        type enumeration {
+            enum OFPP_INVALID {
+                description "";
+            }
+            enum OFPP_MAX {
+                description "";
+            }
+            enum OFPP_IN_PORT {
+                description "";
+            }
+            enum OFPP_TABLE {
+                description "";
+            }
+            enum OFPP_NORMAL {
+                description "";
+            }
+            enum OFPP_FLOOD {
+                description "";
+            }
+            enum OFPP_ALL {
+                description "";
+            }
+            enum OFPP_CONTROLLER {
+                description "";
+            }
+            enum OFPP_LOCAL {
+                description "";
+            }
+            enum OFPP_ANY {
+                description "";
+            }
+        }
+        description
+            "Port numbering. Ports are numbered starting from 1.Version number:
+ OpenFlow versions released: 0x01 = 1.0 ; 0x02 = 1.1 ; 0x03 = 1.2
+     0x04 = 1.3
+The most significant bit in the version field is reserved and must
+ be set to zero.
+#define OFP_VERSION   0x04
+#define PIPELINE_TABLES 64
+#define OFP_MAX_TABLE_NAME_LEN 32
+#define OFP_MAX_PORT_NAME_LEN  16
+Official IANA registered port for OpenFlow.#define OFP_TCP_PORT  6653
+#define OFP_SSL_PORT  6653
+#define OFP_ETH_ALEN 6             Bytes in an Ethernet address.   ";
+    }
+    typedef ofp_type {
+        type enumeration {
+            enum OFPT_HELLO {
+                description "";
+            }
+            enum OFPT_ERROR {
+                description "";
+            }
+            enum OFPT_ECHO_REQUEST {
+                description "";
+            }
+            enum OFPT_ECHO_REPLY {
+                description "";
+            }
+            enum OFPT_EXPERIMENTER {
+                description "";
+            }
+            enum OFPT_FEATURES_REQUEST {
+                description "";
+            }
+            enum OFPT_FEATURES_REPLY {
+                description "";
+            }
+            enum OFPT_GET_CONFIG_REQUEST {
+                description "";
+            }
+            enum OFPT_GET_CONFIG_REPLY {
+                description "";
+            }
+            enum OFPT_SET_CONFIG {
+                description "";
+            }
+            enum OFPT_PACKET_IN {
+                description "";
+            }
+            enum OFPT_FLOW_REMOVED {
+                description "";
+            }
+            enum OFPT_PORT_STATUS {
+                description "";
+            }
+            enum OFPT_PACKET_OUT {
+                description "";
+            }
+            enum OFPT_FLOW_MOD {
+                description "";
+            }
+            enum OFPT_GROUP_MOD {
+                description "";
+            }
+            enum OFPT_PORT_MOD {
+                description "";
+            }
+            enum OFPT_TABLE_MOD {
+                description "";
+            }
+            enum OFPT_MULTIPART_REQUEST {
+                description "";
+            }
+            enum OFPT_MULTIPART_REPLY {
+                description "";
+            }
+            enum OFPT_BARRIER_REQUEST {
+                description "";
+            }
+            enum OFPT_BARRIER_REPLY {
+                description "";
+            }
+            enum OFPT_QUEUE_GET_CONFIG_REQUEST {
+                description "";
+            }
+            enum OFPT_QUEUE_GET_CONFIG_REPLY {
+                description "";
+            }
+            enum OFPT_ROLE_REQUEST {
+                description "";
+            }
+            enum OFPT_ROLE_REPLY {
+                description "";
+            }
+            enum OFPT_GET_ASYNC_REQUEST {
+                description "";
+            }
+            enum OFPT_GET_ASYNC_REPLY {
+                description "";
+            }
+            enum OFPT_SET_ASYNC {
+                description "";
+            }
+            enum OFPT_METER_MOD {
+                description "";
+            }
+        }
+        description
+            "";
+    }
+    typedef ofp_hello_elem_type {
+        type enumeration {
+            enum OFPHET_INVALID {
+                description "";
+            }
+            enum OFPHET_VERSIONBITMAP {
+                description "";
+            }
+        }
+        description
+            "Hello elements types.";
+    }
+    typedef ofp_config_flags {
+        type enumeration {
+            enum OFPC_FRAG_NORMAL {
+                description "";
+            }
+            enum OFPC_FRAG_DROP {
+                description "";
+            }
+            enum OFPC_FRAG_REASM {
+                description "";
+            }
+            enum OFPC_FRAG_MASK {
+                description "";
+            }
+        }
+        description
+            "#define OFP_DEFAULT_MISS_SEND_LEN   128";
+    }
+    typedef ofp_table_config {
+        type enumeration {
+            enum OFPTC_INVALID {
+                description "";
+            }
+            enum OFPTC_DEPRECATED_MASK {
+                description "";
+            }
+        }
+        description
+            "Flags to configure the table. Reserved for future use.";
+    }
+    typedef ofp_table {
+        type enumeration {
+            enum OFPTT_INVALID {
+                description "";
+            }
+            enum OFPTT_MAX {
+                description "";
+            }
+            enum OFPTT_ALL {
+                description "";
+            }
+        }
+        description
+            "Table numbering. Tables can use any number up to OFPT_MAX.";
+    }
+    typedef ofp_capabilities {
+        type enumeration {
+            enum OFPC_INVALID {
+                description "";
+            }
+            enum OFPC_FLOW_STATS {
+                description "";
+            }
+            enum OFPC_TABLE_STATS {
+                description "";
+            }
+            enum OFPC_PORT_STATS {
+                description "";
+            }
+            enum OFPC_GROUP_STATS {
+                description "";
+            }
+            enum OFPC_IP_REASM {
+                description "";
+            }
+            enum OFPC_QUEUE_STATS {
+                description "";
+            }
+            enum OFPC_PORT_BLOCKED {
+                description "";
+            }
+        }
+        description
+            "Capabilities supported by the datapath.";
+    }
+    typedef ofp_port_config {
+        type enumeration {
+            enum OFPPC_INVALID {
+                description "";
+            }
+            enum OFPPC_PORT_DOWN {
+                description "";
+            }
+            enum OFPPC_NO_RECV {
+                description "";
+            }
+            enum OFPPC_NO_FWD {
+                description "";
+            }
+            enum OFPPC_NO_PACKET_IN {
+                description "";
+            }
+        }
+        description
+            "Flags to indicate behavior of the physical port.  These flags are
+ used in ofp_port to describe the current configuration.  They are
+ used in the ofp_port_mod message to configure the port's behavior.";
+    }
+    typedef ofp_port_state {
+        type enumeration {
+            enum OFPPS_INVALID {
+                description "";
+            }
+            enum OFPPS_LINK_DOWN {
+                description "";
+            }
+            enum OFPPS_BLOCKED {
+                description "";
+            }
+            enum OFPPS_LIVE {
+                description "";
+            }
+        }
+        description
+            "Current state of the physical port.  These are not configurable from
+ the controller.";
+    }
+    typedef ofp_port_features {
+        type enumeration {
+            enum OFPPF_INVALID {
+                description "";
+            }
+            enum OFPPF_10MB_HD {
+                description "";
+            }
+            enum OFPPF_10MB_FD {
+                description "";
+            }
+            enum OFPPF_100MB_HD {
+                description "";
+            }
+            enum OFPPF_100MB_FD {
+                description "";
+            }
+            enum OFPPF_1GB_HD {
+                description "";
+            }
+            enum OFPPF_1GB_FD {
+                description "";
+            }
+            enum OFPPF_10GB_FD {
+                description "";
+            }
+            enum OFPPF_40GB_FD {
+                description "";
+            }
+            enum OFPPF_100GB_FD {
+                description "";
+            }
+            enum OFPPF_1TB_FD {
+                description "";
+            }
+            enum OFPPF_OTHER {
+                description "";
+            }
+            enum OFPPF_COPPER {
+                description "";
+            }
+            enum OFPPF_FIBER {
+                description "";
+            }
+            enum OFPPF_AUTONEG {
+                description "";
+            }
+            enum OFPPF_PAUSE {
+                description "";
+            }
+            enum OFPPF_PAUSE_ASYM {
+                description "";
+            }
+        }
+        description
+            "Features of ports available in a datapath.";
+    }
+    typedef ofp_port_reason {
+        type enumeration {
+            enum OFPPR_ADD {
+                description "";
+            }
+            enum OFPPR_DELETE {
+                description "";
+            }
+            enum OFPPR_MODIFY {
+                description "";
+            }
+        }
+        description
+            "What changed about the physical port";
+    }
+    typedef ofp_match_type {
+        type enumeration {
+            enum OFPMT_STANDARD {
+                description "";
+            }
+            enum OFPMT_OXM {
+                description "";
+            }
+        }
+        description
+            "The match type indicates the match structure (set of fields that compose the
+ match) in use. The match type is placed in the type field at the beginning
+ of all match structures. The  OpenFlow Extensible Match  type corresponds
+ to OXM TLV format described below and must be supported by all OpenFlow
+ switches. Extensions that define other match types may be published on the
+ ONF wiki. Support for extensions is optional.
+## -------------------------- #### OpenFlow Extensible Match. #### -------------------------- ##";
+    }
+    typedef ofp_oxm_class {
+        type enumeration {
+            enum OFPXMC_NXM_0 {
+                description "";
+            }
+            enum OFPXMC_NXM_1 {
+                description "";
+            }
+            enum OFPXMC_OPENFLOW_BASIC {
+                description "";
+            }
+            enum OFPXMC_EXPERIMENTER {
+                description "";
+            }
+        }
+        description
+            "OXM Class IDs.
+ The high order bit differentiate reserved classes from member classes.
+ Classes 0x0000 to 0x7FFF are member classes, allocated by ONF.
+ Classes 0x8000 to 0xFFFE are reserved classes, reserved for standardisation.
+Components of a OXM TLV header.
+ Those macros are not valid for the experimenter class, macros for the
+ experimenter class will depend on the experimenter header used.#define OXM_HEADER__(CLASS, FIELD, HASMASK, LENGTH)
+    (((CLASS)    16) | ((FIELD)    9) | ((HASMASK)    8) | (LENGTH))
+#define OXM_HEADER(CLASS, FIELD, LENGTH)
+    OXM_HEADER__(CLASS, FIELD, 0, LENGTH)
+#define OXM_HEADER_W(CLASS, FIELD, LENGTH)
+    OXM_HEADER__(CLASS, FIELD, 1, (LENGTH)   2)
+#define OXM_CLASS(HEADER) ((HEADER)    16)
+#define OXM_FIELD(HEADER) (((HEADER)    9) &amp; 0x7f)
+#define OXM_TYPE(HEADER) (((HEADER)    9) &amp; 0x7fffff)
+#define OXM_HASMASK(HEADER) (((HEADER)    8) &amp; 1)
+#define OXM_LENGTH(HEADER) ((HEADER) &amp; 0xff)
+
+#define OXM_MAKE_WILD_HEADER(HEADER)
+    OXM_HEADER_W(OXM_CLASS(HEADER), OXM_FIELD(HEADER), OXM_LENGTH(HEADER))";
+    }
+    typedef oxm_ofb_field_types {
+        type enumeration {
+            enum OFPXMT_OFB_IN_PORT {
+                description "";
+            }
+            enum OFPXMT_OFB_IN_PHY_PORT {
+                description "";
+            }
+            enum OFPXMT_OFB_METADATA {
+                description "";
+            }
+            enum OFPXMT_OFB_ETH_DST {
+                description "";
+            }
+            enum OFPXMT_OFB_ETH_SRC {
+                description "";
+            }
+            enum OFPXMT_OFB_ETH_TYPE {
+                description "";
+            }
+            enum OFPXMT_OFB_VLAN_VID {
+                description "";
+            }
+            enum OFPXMT_OFB_VLAN_PCP {
+                description "";
+            }
+            enum OFPXMT_OFB_IP_DSCP {
+                description "";
+            }
+            enum OFPXMT_OFB_IP_ECN {
+                description "";
+            }
+            enum OFPXMT_OFB_IP_PROTO {
+                description "";
+            }
+            enum OFPXMT_OFB_IPV4_SRC {
+                description "";
+            }
+            enum OFPXMT_OFB_IPV4_DST {
+                description "";
+            }
+            enum OFPXMT_OFB_TCP_SRC {
+                description "";
+            }
+            enum OFPXMT_OFB_TCP_DST {
+                description "";
+            }
+            enum OFPXMT_OFB_UDP_SRC {
+                description "";
+            }
+            enum OFPXMT_OFB_UDP_DST {
+                description "";
+            }
+            enum OFPXMT_OFB_SCTP_SRC {
+                description "";
+            }
+            enum OFPXMT_OFB_SCTP_DST {
+                description "";
+            }
+            enum OFPXMT_OFB_ICMPV4_TYPE {
+                description "";
+            }
+            enum OFPXMT_OFB_ICMPV4_CODE {
+                description "";
+            }
+            enum OFPXMT_OFB_ARP_OP {
+                description "";
+            }
+            enum OFPXMT_OFB_ARP_SPA {
+                description "";
+            }
+            enum OFPXMT_OFB_ARP_TPA {
+                description "";
+            }
+            enum OFPXMT_OFB_ARP_SHA {
+                description "";
+            }
+            enum OFPXMT_OFB_ARP_THA {
+                description "";
+            }
+            enum OFPXMT_OFB_IPV6_SRC {
+                description "";
+            }
+            enum OFPXMT_OFB_IPV6_DST {
+                description "";
+            }
+            enum OFPXMT_OFB_IPV6_FLABEL {
+                description "";
+            }
+            enum OFPXMT_OFB_ICMPV6_TYPE {
+                description "";
+            }
+            enum OFPXMT_OFB_ICMPV6_CODE {
+                description "";
+            }
+            enum OFPXMT_OFB_IPV6_ND_TARGET {
+                description "";
+            }
+            enum OFPXMT_OFB_IPV6_ND_SLL {
+                description "";
+            }
+            enum OFPXMT_OFB_IPV6_ND_TLL {
+                description "";
+            }
+            enum OFPXMT_OFB_MPLS_LABEL {
+                description "";
+            }
+            enum OFPXMT_OFB_MPLS_TC {
+                description "";
+            }
+            enum OFPXMT_OFB_MPLS_BOS {
+                description "";
+            }
+            enum OFPXMT_OFB_PBB_ISID {
+                description "";
+            }
+            enum OFPXMT_OFB_TUNNEL_ID {
+                description "";
+            }
+            enum OFPXMT_OFB_IPV6_EXTHDR {
+                description "";
+            }
+        }
+        description
+            "OXM Flow field types for OpenFlow basic class.";
+    }
+    typedef ofp_vlan_id {
+        type enumeration {
+            enum OFPVID_NONE {
+                description "";
+            }
+            enum OFPVID_PRESENT {
+                description "";
+            }
+        }
+        description
+            "The VLAN id is 12-bits, so we can use the entire 16 bits to indicate
+ special conditions.";
+    }
+    typedef ofp_ipv6exthdr_flags {
+        type enumeration {
+            enum OFPIEH_INVALID {
+                description "";
+            }
+            enum OFPIEH_NONEXT {
+                description "";
+            }
+            enum OFPIEH_ESP {
+                description "";
+            }
+            enum OFPIEH_AUTH {
+                description "";
+            }
+            enum OFPIEH_DEST {
+                description "";
+            }
+            enum OFPIEH_FRAG {
+                description "";
+            }
+            enum OFPIEH_ROUTER {
+                description "";
+            }
+            enum OFPIEH_HOP {
+                description "";
+            }
+            enum OFPIEH_UNREP {
+                description "";
+            }
+            enum OFPIEH_UNSEQ {
+                description "";
+            }
+        }
+        description
+            "Bit definitions for IPv6 Extension Header pseudo-field.#define OFP_VLAN_NONE      OFPVID_NONE";
+    }
+    typedef ofp_action_type {
+        type enumeration {
+            enum OFPAT_OUTPUT {
+                description "";
+            }
+            enum OFPAT_COPY_TTL_OUT {
+                description "";
+            }
+            enum OFPAT_COPY_TTL_IN {
+                description "";
+            }
+            enum OFPAT_SET_MPLS_TTL {
+                description "";
+            }
+            enum OFPAT_DEC_MPLS_TTL {
+                description "";
+            }
+            enum OFPAT_PUSH_VLAN {
+                description "";
+            }
+            enum OFPAT_POP_VLAN {
+                description "";
+            }
+            enum OFPAT_PUSH_MPLS {
+                description "";
+            }
+            enum OFPAT_POP_MPLS {
+                description "";
+            }
+            enum OFPAT_SET_QUEUE {
+                description "";
+            }
+            enum OFPAT_GROUP {
+                description "";
+            }
+            enum OFPAT_SET_NW_TTL {
+                description "";
+            }
+            enum OFPAT_DEC_NW_TTL {
+                description "";
+            }
+            enum OFPAT_SET_FIELD {
+                description "";
+            }
+            enum OFPAT_PUSH_PBB {
+                description "";
+            }
+            enum OFPAT_POP_PBB {
+                description "";
+            }
+            enum OFPAT_EXPERIMENTER {
+                description "";
+            }
+        }
+        description
+            "## ----------------- #### OpenFlow Actions. #### ----------------- ##";
+    }
+    typedef ofp_controller_max_len {
+        type enumeration {
+            enum OFPCML_INVALID {
+                description "";
+            }
+            enum OFPCML_MAX {
+                description "";
+            }
+            enum OFPCML_NO_BUFFER {
+                description "";
+            }
+        }
+        description
+            "";
+    }
+    typedef ofp_instruction_type {
+        type enumeration {
+            enum OFPIT_INVALID {
+                description "";
+            }
+            enum OFPIT_GOTO_TABLE {
+                description "";
+            }
+            enum OFPIT_WRITE_METADATA {
+                description "";
+            }
+            enum OFPIT_WRITE_ACTIONS {
+                description "";
+            }
+            enum OFPIT_APPLY_ACTIONS {
+                description "";
+            }
+            enum OFPIT_CLEAR_ACTIONS {
+                description "";
+            }
+            enum OFPIT_METER {
+                description "";
+            }
+            enum OFPIT_EXPERIMENTER {
+                description "";
+            }
+        }
+        description
+            "## ---------------------- #### OpenFlow Instructions. #### ---------------------- ##";
+    }
+    typedef ofp_flow_mod_command {
+        type enumeration {
+            enum OFPFC_ADD {
+                description "";
+            }
+            enum OFPFC_MODIFY {
+                description "";
+            }
+            enum OFPFC_MODIFY_STRICT {
+                description "";
+            }
+            enum OFPFC_DELETE {
+                description "";
+            }
+            enum OFPFC_DELETE_STRICT {
+                description "";
+            }
+        }
+        description
+            "## --------------------------- #### OpenFlow Flow Modification. #### --------------------------- ##";
+    }
+    typedef ofp_flow_mod_flags {
+        type enumeration {
+            enum OFPFF_INVALID {
+                description "";
+            }
+            enum OFPFF_SEND_FLOW_REM {
+                description "";
+            }
+            enum OFPFF_CHECK_OVERLAP {
+                description "";
+            }
+            enum OFPFF_RESET_COUNTS {
+                description "";
+            }
+            enum OFPFF_NO_PKT_COUNTS {
+                description "";
+            }
+            enum OFPFF_NO_BYT_COUNTS {
+                description "";
+            }
+        }
+        description
+            "Value used in  idle_timeout  and  hard_timeout  to indicate that the entry
+ is permanent.#define OFP_FLOW_PERMANENT 0
+By default, choose a priority in the middle.#define OFP_DEFAULT_PRIORITY 0x8000";
+    }
+    typedef ofp_group {
+        type enumeration {
+            enum OFPG_INVALID {
+                description "";
+            }
+            enum OFPG_MAX {
+                description "";
+            }
+            enum OFPG_ALL {
+                description "";
+            }
+            enum OFPG_ANY {
+                description "";
+            }
+        }
+        description
+            "Group numbering. Groups can use any number up to OFPG_MAX.";
+    }
+    typedef ofp_group_mod_command {
+        type enumeration {
+            enum OFPGC_ADD {
+                description "";
+            }
+            enum OFPGC_MODIFY {
+                description "";
+            }
+            enum OFPGC_DELETE {
+                description "";
+            }
+        }
+        description
+            "Group commands";
+    }
+    typedef ofp_group_type {
+        type enumeration {
+            enum OFPGT_ALL {
+                description "";
+            }
+            enum OFPGT_SELECT {
+                description "";
+            }
+            enum OFPGT_INDIRECT {
+                description "";
+            }
+            enum OFPGT_FF {
+                description "";
+            }
+        }
+        description
+            "Group types.  Values in the range  128; 255  are reserved for experimental
+ use.";
+    }
+    typedef ofp_packet_in_reason {
+        type enumeration {
+            enum OFPR_NO_MATCH {
+                description "";
+            }
+            enum OFPR_ACTION {
+                description "";
+            }
+            enum OFPR_INVALID_TTL {
+                description "";
+            }
+        }
+        description
+            "Why is this packet being sent to the controller?";
+    }
+    typedef ofp_flow_removed_reason {
+        type enumeration {
+            enum OFPRR_IDLE_TIMEOUT {
+                description "";
+            }
+            enum OFPRR_HARD_TIMEOUT {
+                description "";
+            }
+            enum OFPRR_DELETE {
+                description "";
+            }
+            enum OFPRR_GROUP_DELETE {
+                description "";
+            }
+            enum OFPRR_METER_DELETE {
+                description "";
+            }
+        }
+        description
+            "Why was this flow removed?";
+    }
+    typedef ofp_meter {
+        type enumeration {
+            enum OFPM_ZERO {
+                description "";
+            }
+            enum OFPM_MAX {
+                description "";
+            }
+            enum OFPM_SLOWPATH {
+                description "";
+            }
+            enum OFPM_CONTROLLER {
+                description "";
+            }
+            enum OFPM_ALL {
+                description "";
+            }
+        }
+        description
+            "Meter numbering. Flow meters can use any number up to OFPM_MAX.";
+    }
+    typedef ofp_meter_band_type {
+        type enumeration {
+            enum OFPMBT_INVALID {
+                description "";
+            }
+            enum OFPMBT_DROP {
+                description "";
+            }
+            enum OFPMBT_DSCP_REMARK {
+                description "";
+            }
+            enum OFPMBT_EXPERIMENTER {
+                description "";
+            }
+        }
+        description
+            "Meter band types";
+    }
+    typedef ofp_meter_mod_command {
+        type enumeration {
+            enum OFPMC_ADD {
+                description "";
+            }
+            enum OFPMC_MODIFY {
+                description "";
+            }
+            enum OFPMC_DELETE {
+                description "";
+            }
+        }
+        description
+            "Meter commands";
+    }
+    typedef ofp_meter_flags {
+        type enumeration {
+            enum OFPMF_INVALID {
+                description "";
+            }
+            enum OFPMF_KBPS {
+                description "";
+            }
+            enum OFPMF_PKTPS {
+                description "";
+            }
+            enum OFPMF_BURST {
+                description "";
+            }
+            enum OFPMF_STATS {
+                description "";
+            }
+        }
+        description
+            "Meter configuration flags";
+    }
+    typedef ofp_error_type {
+        type enumeration {
+            enum OFPET_HELLO_FAILED {
+                description "";
+            }
+            enum OFPET_BAD_REQUEST {
+                description "";
+            }
+            enum OFPET_BAD_ACTION {
+                description "";
+            }
+            enum OFPET_BAD_INSTRUCTION {
+                description "";
+            }
+            enum OFPET_BAD_MATCH {
+                description "";
+            }
+            enum OFPET_FLOW_MOD_FAILED {
+                description "";
+            }
+            enum OFPET_GROUP_MOD_FAILED {
+                description "";
+            }
+            enum OFPET_PORT_MOD_FAILED {
+                description "";
+            }
+            enum OFPET_TABLE_MOD_FAILED {
+                description "";
+            }
+            enum OFPET_QUEUE_OP_FAILED {
+                description "";
+            }
+            enum OFPET_SWITCH_CONFIG_FAILED {
+                description "";
+            }
+            enum OFPET_ROLE_REQUEST_FAILED {
+                description "";
+            }
+            enum OFPET_METER_MOD_FAILED {
+                description "";
+            }
+            enum OFPET_TABLE_FEATURES_FAILED {
+                description "";
+            }
+            enum OFPET_EXPERIMENTER {
+                description "";
+            }
+        }
+        description
+            "Values for 'type' in ofp_error_message.  These values are immutable: they
+ will not change in future versions of the protocol (although new values may
+ be added).";
+    }
+    typedef ofp_hello_failed_code {
+        type enumeration {
+            enum OFPHFC_INCOMPATIBLE {
+                description "";
+            }
+            enum OFPHFC_EPERM {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_HELLO_FAILED.  'data' contains an
+ ASCII text string that may give failure details.";
+    }
+    typedef ofp_bad_request_code {
+        type enumeration {
+            enum OFPBRC_BAD_VERSION {
+                description "";
+            }
+            enum OFPBRC_BAD_TYPE {
+                description "";
+            }
+            enum OFPBRC_BAD_MULTIPART {
+                description "";
+            }
+            enum OFPBRC_BAD_EXPERIMENTER {
+                description "";
+            }
+            enum OFPBRC_BAD_EXP_TYPE {
+                description "";
+            }
+            enum OFPBRC_EPERM {
+                description "";
+            }
+            enum OFPBRC_BAD_LEN {
+                description "";
+            }
+            enum OFPBRC_BUFFER_EMPTY {
+                description "";
+            }
+            enum OFPBRC_BUFFER_UNKNOWN {
+                description "";
+            }
+            enum OFPBRC_BAD_TABLE_ID {
+                description "";
+            }
+            enum OFPBRC_IS_SLAVE {
+                description "";
+            }
+            enum OFPBRC_BAD_PORT {
+                description "";
+            }
+            enum OFPBRC_BAD_PACKET {
+                description "";
+            }
+            enum OFPBRC_MULTIPART_BUFFER_OVERFLOW {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_BAD_REQUEST.  'data' contains at least
+ the first 64 bytes of the failed request.";
+    }
+    typedef ofp_bad_action_code {
+        type enumeration {
+            enum OFPBAC_BAD_TYPE {
+                description "";
+            }
+            enum OFPBAC_BAD_LEN {
+                description "";
+            }
+            enum OFPBAC_BAD_EXPERIMENTER {
+                description "";
+            }
+            enum OFPBAC_BAD_EXP_TYPE {
+                description "";
+            }
+            enum OFPBAC_BAD_OUT_PORT {
+                description "";
+            }
+            enum OFPBAC_BAD_ARGUMENT {
+                description "";
+            }
+            enum OFPBAC_EPERM {
+                description "";
+            }
+            enum OFPBAC_TOO_MANY {
+                description "";
+            }
+            enum OFPBAC_BAD_QUEUE {
+                description "";
+            }
+            enum OFPBAC_BAD_OUT_GROUP {
+                description "";
+            }
+            enum OFPBAC_MATCH_INCONSISTENT {
+                description "";
+            }
+            enum OFPBAC_UNSUPPORTED_ORDER {
+                description "";
+            }
+            enum OFPBAC_BAD_TAG {
+                description "";
+            }
+            enum OFPBAC_BAD_SET_TYPE {
+                description "";
+            }
+            enum OFPBAC_BAD_SET_LEN {
+                description "";
+            }
+            enum OFPBAC_BAD_SET_ARGUMENT {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_BAD_ACTION.  'data' contains at least
+ the first 64 bytes of the failed request.";
+    }
+    typedef ofp_bad_instruction_code {
+        type enumeration {
+            enum OFPBIC_UNKNOWN_INST {
+                description "";
+            }
+            enum OFPBIC_UNSUP_INST {
+                description "";
+            }
+            enum OFPBIC_BAD_TABLE_ID {
+                description "";
+            }
+            enum OFPBIC_UNSUP_METADATA {
+                description "";
+            }
+            enum OFPBIC_UNSUP_METADATA_MASK {
+                description "";
+            }
+            enum OFPBIC_BAD_EXPERIMENTER {
+                description "";
+            }
+            enum OFPBIC_BAD_EXP_TYPE {
+                description "";
+            }
+            enum OFPBIC_BAD_LEN {
+                description "";
+            }
+            enum OFPBIC_EPERM {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_BAD_INSTRUCTION.  'data' contains at
+ least the first 64 bytes of the failed request.";
+    }
+    typedef ofp_bad_match_code {
+        type enumeration {
+            enum OFPBMC_BAD_TYPE {
+                description "";
+            }
+            enum OFPBMC_BAD_LEN {
+                description "";
+            }
+            enum OFPBMC_BAD_TAG {
+                description "";
+            }
+            enum OFPBMC_BAD_DL_ADDR_MASK {
+                description "";
+            }
+            enum OFPBMC_BAD_NW_ADDR_MASK {
+                description "";
+            }
+            enum OFPBMC_BAD_WILDCARDS {
+                description "";
+            }
+            enum OFPBMC_BAD_FIELD {
+                description "";
+            }
+            enum OFPBMC_BAD_VALUE {
+                description "";
+            }
+            enum OFPBMC_BAD_MASK {
+                description "";
+            }
+            enum OFPBMC_BAD_PREREQ {
+                description "";
+            }
+            enum OFPBMC_DUP_FIELD {
+                description "";
+            }
+            enum OFPBMC_EPERM {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_BAD_MATCH.  'data' contains at least
+ the first 64 bytes of the failed request.";
+    }
+    typedef ofp_flow_mod_failed_code {
+        type enumeration {
+            enum OFPFMFC_UNKNOWN {
+                description "";
+            }
+            enum OFPFMFC_TABLE_FULL {
+                description "";
+            }
+            enum OFPFMFC_BAD_TABLE_ID {
+                description "";
+            }
+            enum OFPFMFC_OVERLAP {
+                description "";
+            }
+            enum OFPFMFC_EPERM {
+                description "";
+            }
+            enum OFPFMFC_BAD_TIMEOUT {
+                description "";
+            }
+            enum OFPFMFC_BAD_COMMAND {
+                description "";
+            }
+            enum OFPFMFC_BAD_FLAGS {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_FLOW_MOD_FAILED.  'data' contains
+ at least the first 64 bytes of the failed request.";
+    }
+    typedef ofp_group_mod_failed_code {
+        type enumeration {
+            enum OFPGMFC_GROUP_EXISTS {
+                description "";
+            }
+            enum OFPGMFC_INVALID_GROUP {
+                description "";
+            }
+            enum OFPGMFC_WEIGHT_UNSUPPORTED {
+                description "";
+            }
+            enum OFPGMFC_OUT_OF_GROUPS {
+                description "";
+            }
+            enum OFPGMFC_OUT_OF_BUCKETS {
+                description "";
+            }
+            enum OFPGMFC_CHAINING_UNSUPPORTED {
+                description "";
+            }
+            enum OFPGMFC_WATCH_UNSUPPORTED {
+                description "";
+            }
+            enum OFPGMFC_LOOP {
+                description "";
+            }
+            enum OFPGMFC_UNKNOWN_GROUP {
+                description "";
+            }
+            enum OFPGMFC_CHAINED_GROUP {
+                description "";
+            }
+            enum OFPGMFC_BAD_TYPE {
+                description "";
+            }
+            enum OFPGMFC_BAD_COMMAND {
+                description "";
+            }
+            enum OFPGMFC_BAD_BUCKET {
+                description "";
+            }
+            enum OFPGMFC_BAD_WATCH {
+                description "";
+            }
+            enum OFPGMFC_EPERM {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_GROUP_MOD_FAILED.  'data' contains
+ at least the first 64 bytes of the failed request.";
+    }
+    typedef ofp_port_mod_failed_code {
+        type enumeration {
+            enum OFPPMFC_BAD_PORT {
+                description "";
+            }
+            enum OFPPMFC_BAD_HW_ADDR {
+                description "";
+            }
+            enum OFPPMFC_BAD_CONFIG {
+                description "";
+            }
+            enum OFPPMFC_BAD_ADVERTISE {
+                description "";
+            }
+            enum OFPPMFC_EPERM {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_PORT_MOD_FAILED.  'data' contains
+ at least the first 64 bytes of the failed request.";
+    }
+    typedef ofp_table_mod_failed_code {
+        type enumeration {
+            enum OFPTMFC_BAD_TABLE {
+                description "";
+            }
+            enum OFPTMFC_BAD_CONFIG {
+                description "";
+            }
+            enum OFPTMFC_EPERM {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_TABLE_MOD_FAILED.  'data' contains
+ at least the first 64 bytes of the failed request.";
+    }
+    typedef ofp_queue_op_failed_code {
+        type enumeration {
+            enum OFPQOFC_BAD_PORT {
+                description "";
+            }
+            enum OFPQOFC_BAD_QUEUE {
+                description "";
+            }
+            enum OFPQOFC_EPERM {
+                description "";
+            }
+        }
+        description
+            "ofp_error msg 'code' values for OFPET_QUEUE_OP_FAILED. 'data' contains
+ at least the first 64 bytes of the failed request";
+    }
+    typedef ofp_switch_config_failed_code {
+        type enumeration {
+            enum OFPSCFC_BAD_FLAGS {
+                description "";
+            }
+            enum OFPSCFC_BAD_LEN {
+                description "";
+            }
+            enum OFPSCFC_EPERM {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_SWITCH_CONFIG_FAILED. 'data' contains
+ at least the first 64 bytes of the failed request.";
+    }
+    typedef ofp_role_request_failed_code {
+        type enumeration {
+            enum OFPRRFC_STALE {
+                description "";
+            }
+            enum OFPRRFC_UNSUP {
+                description "";
+            }
+            enum OFPRRFC_BAD_ROLE {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_ROLE_REQUEST_FAILED. 'data' contains
+ at least the first 64 bytes of the failed request.";
+    }
+    typedef ofp_meter_mod_failed_code {
+        type enumeration {
+            enum OFPMMFC_UNKNOWN {
+                description "";
+            }
+            enum OFPMMFC_METER_EXISTS {
+                description "";
+            }
+            enum OFPMMFC_INVALID_METER {
+                description "";
+            }
+            enum OFPMMFC_UNKNOWN_METER {
+                description "";
+            }
+            enum OFPMMFC_BAD_COMMAND {
+                description "";
+            }
+            enum OFPMMFC_BAD_FLAGS {
+                description "";
+            }
+            enum OFPMMFC_BAD_RATE {
+                description "";
+            }
+            enum OFPMMFC_BAD_BURST {
+                description "";
+            }
+            enum OFPMMFC_BAD_BAND {
+                description "";
+            }
+            enum OFPMMFC_BAD_BAND_VALUE {
+                description "";
+            }
+            enum OFPMMFC_OUT_OF_METERS {
+                description "";
+            }
+            enum OFPMMFC_OUT_OF_BANDS {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_METER_MOD_FAILED.  'data' contains
+ at least the first 64 bytes of the failed request.";
+    }
+    typedef ofp_table_features_failed_code {
+        type enumeration {
+            enum OFPTFFC_BAD_TABLE {
+                description "";
+            }
+            enum OFPTFFC_BAD_METADATA {
+                description "";
+            }
+            enum OFPTFFC_BAD_TYPE {
+                description "";
+            }
+            enum OFPTFFC_BAD_LEN {
+                description "";
+            }
+            enum OFPTFFC_BAD_ARGUMENT {
+                description "";
+            }
+            enum OFPTFFC_EPERM {
+                description "";
+            }
+        }
+        description
+            "ofp_error_msg 'code' values for OFPET_TABLE_FEATURES_FAILED. 'data' contains
+ at least the first 64 bytes of the failed request.";
+    }
+    typedef ofp_multipart_type {
+        type enumeration {
+            enum OFPMP_DESC {
+                description "";
+            }
+            enum OFPMP_FLOW {
+                description "";
+            }
+            enum OFPMP_AGGREGATE {
+                description "";
+            }
+            enum OFPMP_TABLE {
+                description "";
+            }
+            enum OFPMP_PORT_STATS {
+                description "";
+            }
+            enum OFPMP_QUEUE {
+                description "";
+            }
+            enum OFPMP_GROUP {
+                description "";
+            }
+            enum OFPMP_GROUP_DESC {
+                description "";
+            }
+            enum OFPMP_GROUP_FEATURES {
+                description "";
+            }
+            enum OFPMP_METER {
+                description "";
+            }
+            enum OFPMP_METER_CONFIG {
+                description "";
+            }
+            enum OFPMP_METER_FEATURES {
+                description "";
+            }
+            enum OFPMP_TABLE_FEATURES {
+                description "";
+            }
+            enum OFPMP_PORT_DESC {
+                description "";
+            }
+            enum OFPMP_EXPERIMENTER {
+                description "";
+            }
+        }
+        description
+            "";
+    }
+    typedef ofp_multipart_request_flags {
+        type enumeration {
+            enum OFPMPF_REQ_INVALID {
+                description "";
+            }
+            enum OFPMPF_REQ_MORE {
+                description "";
+            }
+        }
+        description
+            "Backward compatibility with 1.3.1 - avoid breaking the API.#define ofp_multipart_types ofp_multipart_type";
+    }
+    typedef ofp_multipart_reply_flags {
+        type enumeration {
+            enum OFPMPF_REPLY_INVALID {
+                description "";
+            }
+            enum OFPMPF_REPLY_MORE {
+                description "";
+            }
+        }
+        description
+            "";
+    }
+    typedef ofp_table_feature_prop_type {
+        type enumeration {
+            enum OFPTFPT_INSTRUCTIONS {
+                description "";
+            }
+            enum OFPTFPT_INSTRUCTIONS_MISS {
+                description "";
+            }
+            enum OFPTFPT_NEXT_TABLES {
+                description "";
+            }
+            enum OFPTFPT_NEXT_TABLES_MISS {
+                description "";
+            }
+            enum OFPTFPT_WRITE_ACTIONS {
+                description "";
+            }
+            enum OFPTFPT_WRITE_ACTIONS_MISS {
+                description "";
+            }
+            enum OFPTFPT_APPLY_ACTIONS {
+                description "";
+            }
+            enum OFPTFPT_APPLY_ACTIONS_MISS {
+                description "";
+            }
+            enum OFPTFPT_MATCH {
+                description "";
+            }
+            enum OFPTFPT_WILDCARDS {
+                description "";
+            }
+            enum OFPTFPT_WRITE_SETFIELD {
+                description "";
+            }
+            enum OFPTFPT_WRITE_SETFIELD_MISS {
+                description "";
+            }
+            enum OFPTFPT_APPLY_SETFIELD {
+                description "";
+            }
+            enum OFPTFPT_APPLY_SETFIELD_MISS {
+                description "";
+            }
+            enum OFPTFPT_EXPERIMENTER {
+                description "";
+            }
+            enum OFPTFPT_EXPERIMENTER_MISS {
+                description "";
+            }
+        }
+        description
+            "Table Feature property types.
+ Low order bit cleared indicates a property for a regular Flow Entry.
+ Low order bit set indicates a property for the Table-Miss Flow Entry.";
+    }
+    typedef ofp_group_capabilities {
+        type enumeration {
+            enum OFPGFC_INVALID {
+                description "";
+            }
+            enum OFPGFC_SELECT_WEIGHT {
+                description "";
+            }
+            enum OFPGFC_SELECT_LIVENESS {
+                description "";
+            }
+            enum OFPGFC_CHAINING {
+                description "";
+            }
+            enum OFPGFC_CHAINING_CHECKS {
+                description "";
+            }
+        }
+        description
+            "Group configuration flagsBackward compatibility with 1.3.1 - avoid breaking the API.#define ofp_group_desc_stats ofp_group_desc";
+    }
+    typedef ofp_queue_properties {
+        type enumeration {
+            enum OFPQT_INVALID {
+                description "";
+            }
+            enum OFPQT_MIN_RATE {
+                description "";
+            }
+            enum OFPQT_MAX_RATE {
+                description "";
+            }
+            enum OFPQT_EXPERIMENTER {
+                description "";
+            }
+        }
+        description
+            "All ones is used to indicate all queues in a port (for stats retrieval).#define OFPQ_ALL      0xffffffff
+Min rate   1000 means not configured.#define OFPQ_MIN_RATE_UNCFG      0xffff
+Max rate   1000 means not configured.#define OFPQ_MAX_RATE_UNCFG      0xffff";
+    }
+    typedef ofp_controller_role {
+        type enumeration {
+            enum OFPCR_ROLE_NOCHANGE {
+                description "";
+            }
+            enum OFPCR_ROLE_EQUAL {
+                description "";
+            }
+            enum OFPCR_ROLE_MASTER {
+                description "";
+            }
+            enum OFPCR_ROLE_SLAVE {
+                description "";
+            }
+        }
+        description
+            "Controller roles.Configures the  role  of the sending controller.  The default role is:
+
+    - Equal (OFPCR_ROLE_EQUAL), which allows the controller access to all
+      OpenFlow features. All controllers have equal responsibility.
+
+ The other possible roles are a related pair:
+
+    - Master (OFPCR_ROLE_MASTER) is equivalent to Equal, except that there
+      may be at most one Master controller at a time: when a controller
+      configures itself as Master, any existing Master is demoted to the
+      Slave role.
+
+    - Slave (OFPCR_ROLE_SLAVE) allows the controller read-only access to
+      OpenFlow features.  In particular attempts to modify the flow table
+      will be rejected with an OFPBRC_EPERM error.
+
+      Slave controllers do not receive OFPT_PACKET_IN or OFPT_FLOW_REMOVED
+      messages, but they do receive OFPT_PORT_STATUS messages.";
+    }
+
+    container ofp_header {
+        description
+            "Header on all OpenFlow packets.";
+        leaf version {
+            type  uint32;
+            description
+                "OFP_VERSION.";
+        }
+
+        leaf type {
+            type  ofp_type;
+
+            description
+                "One of the OFPT_ constants.";
+        }
+
+        leaf xid {
+            type  uint32;
+            description
+                "Transaction id associated with this packet.
+Replies use the same id as was in the request
+to facilitate pairing.";
+        }
+
+
+
+    }
+
+    grouping ofp_hello_elem_header {
+        description
+            "Common header for all Hello Elements";
+        leaf type {
+            type  ofp_hello_elem_type;
+
+            description
+                "One of OFPHET_ .";
+        }
+
+
+
+        choice choice_0 {
+            case versionbitmap {
+                container versionbitmap {
+                    uses  ofp_hello_elem_versionbitmap;
+
+                    description
+                        "";
+                }
+            }
+        }
+
+
+    }
+
+    grouping ofp_hello_elem_versionbitmap {
+        description
+            "Version bitmap Hello Element";
+        list bitmaps {
+            key "bitmaps";
+            leaf bitmaps {
+                type  uint32;
+                description
+                    "List of bitmaps - supported versions";
+            }
+            description
+                "List of bitmaps - supported versions";
+        }
+
+
+
+    }
+
+    container ofp_hello {
+        description
+            "OFPT_HELLO.  This message includes zero or more hello elements having
+ variable size. Unknown elements types must be ignored skipped, to allow
+ for future extensions.ofp_header header;";
+        list elements {
+            key "type";
+            uses  ofp_hello_elem_header;
+
+            description
+                "Hello element list0 or more";
+        }
+
+
+
+    }
+
+    container ofp_switch_config {
+        description
+            "Switch configuration.";
+        leaf flags {
+            type  uint32;
+            description
+                "ofp_header header;
+Bitmap of OFPC_  flags.";
+        }
+
+        leaf miss_send_len {
+            type  uint32;
+            description
+                "Max bytes of packet that datapath
+should send to the controller. See
+ofp_controller_max_len for valid values.";
+        }
+
+
+
+    }
+
+    container ofp_table_mod {
+        description
+            "Configure Modify behavior of a flow table";
+        leaf table_id {
+            type  uint32;
+            description
+                "ofp_header header;
+ID of the table, OFPTT_ALL indicates all tables";
+        }
+
+        leaf config {
+            type  uint32;
+            description
+                "Bitmap of OFPTC_  flags";
+        }
+
+
+
+    }
+
+    grouping ofp_port {
+        description
+            "Description of a port";
+        leaf port_no {
+            type  uint32;
+            description
+                "";
+        }
+
+        list hw_addr {
+            key "hw_addr";
+            leaf hw_addr {
+                type  uint32;
+                description
+                    " OFP_ETH_ALEN ;";
+            }
+            description
+                " OFP_ETH_ALEN ;";
+        }
+
+        leaf name {
+            type  string;
+            description
+                "Null-terminated";
+        }
+
+        leaf config {
+            type  uint32;
+            description
+                "Bitmap of OFPPC_  flags.";
+        }
+
+        leaf state {
+            type  uint32;
+            description
+                "Bitmap of OFPPS_  flags.";
+        }
+
+        leaf curr {
+            type  uint32;
+            description
+                "Bitmaps of OFPPF_  that describe features.  All bits zeroed if
+ unsupported or unavailable.Current features.";
+        }
+
+        leaf advertised {
+            type  uint32;
+            description
+                "Features being advertised by the port.";
+        }
+
+        leaf supported {
+            type  uint32;
+            description
+                "Features supported by the port.";
+        }
+
+        leaf peer {
+            type  uint32;
+            description
+                "Features advertised by peer.";
+        }
+
+        leaf curr_speed {
+            type  uint32;
+            description
+                "Current port bitrate in kbps.";
+        }
+
+        leaf max_speed {
+            type  uint32;
+            description
+                "Max port bitrate in kbps";
+        }
+
+
+
+    }
+
+    grouping ofp_switch_features {
+        description
+            "Switch features.";
+        leaf datapath_id {
+            type  uint64;
+            description
+                "ofp_header header;
+Datapath unique ID.  The lower 48-bits are for
+a MAC address, while the upper 16-bits are
+implementer-defined.";
+        }
+
+        leaf n_buffers {
+            type  uint32;
+            description
+                "Max packets buffered at once.";
+        }
+
+        leaf n_tables {
+            type  uint32;
+            description
+                "Number of tables supported by datapath.";
+        }
+
+        leaf auxiliary_id {
+            type  uint32;
+            description
+                "Identify auxiliary connections";
+        }
+
+        leaf capabilities {
+            type  uint32;
+            description
+                "Features.Bitmap of support  ofp_capabilities .";
+        }
+
+
+
+    }
+
+    grouping ofp_port_status {
+        description
+            "A physical port has changed in the datapath";
+        leaf reason {
+            type  ofp_port_reason;
+
+            description
+                "ofp_header header;
+One of OFPPR_ .";
+        }
+
+        container desc {
+            uses  ofp_port;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    container ofp_port_mod {
+        description
+            "Modify behavior of the physical port";
+        leaf port_no {
+            type  uint32;
+            description
+                "ofp_header header;";
+        }
+
+        list hw_addr {
+            key "hw_addr";
+            leaf hw_addr {
+                type  uint32;
+                description
+                    " OFP_ETH_ALEN ;";
+            }
+            description
+                " OFP_ETH_ALEN ;";
+        }
+
+        leaf config {
+            type  uint32;
+            description
+                "The hardware address is not
+configurable.  This is used to
+sanity-check the request, so it must
+be the same as returned in an
+ofp_port struct.Bitmap of OFPPC_  flags.";
+        }
+
+        leaf mask {
+            type  uint32;
+            description
+                "Bitmap of OFPPC_  flags to be changed.";
+        }
+
+        leaf advertise {
+            type  uint32;
+            description
+                "Bitmap of OFPPF_ .  Zero all bits to prevent
+any action taking place.";
+        }
+
+
+
+    }
+
+    grouping ofp_match {
+        description
+            "Fields to match against flows";
+        leaf type {
+            type  ofp_match_type;
+
+            description
+                "One of OFPMT_ ";
+        }
+
+        list oxm_fields {
+            key "oxm_class";
+            uses  ofp_oxm_field;
+
+            description
+                "0 or more";
+        }
+
+
+
+    }
+
+    grouping ofp_oxm_field {
+        description
+            "OXM Flow match fields";
+        leaf oxm_class {
+            type  ofp_oxm_class;
+
+            description
+                "";
+        }
+
+
+
+        choice choice_0 {
+            case ofb_field {
+                container ofb_field {
+                    uses  ofp_oxm_ofb_field;
+
+                    description
+                        "2 and 3 reserved for NXM_0 and NXM-1 OXM classes";
+                }
+            }
+            case experimenter_field {
+                container experimenter_field {
+                    uses  ofp_oxm_experimenter_field;
+
+                    description
+                        "";
+                }
+            }
+        }
+
+
+    }
+
+    grouping ofp_oxm_ofb_field {
+        description
+            "OXM OpenFlow Basic Match Field";
+        leaf type {
+            type  oxm_ofb_field_types;
+
+            description
+                "";
+        }
+
+        leaf has_mask {
+            type  boolean;
+            description
+                "";
+        }
+
+
+
+        choice choice_0 {
+            case port {
+                leaf port {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_IN_PORT    OXM_HEADER  (0x8000, OFPXMT_OFB_IN_PORT, 4)
+Used for OFPXMT_OFB_IN_PORTOpenFlow port on which the packet was received.
+ May be a physical port, a logical port, or the reserved port OFPP_LOCAL
+
+ Prereqs: None.
+
+ Format: 32-bit integer in network byte order.
+
+ Masking: Not maskable.";
+                }
+            }
+            case physical_port {
+                leaf physical_port {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_IN_PHY_PORT OXM_HEADER  (0x8000, OFPXMT_OFB_IN_PHY_PORT, 4)
+Used for OFPXMT_OF_IN_PHY_PORTPhysical port on which the packet was received.
+
+ Consider a packet received on a tunnel interface defined over a link
+ aggregation group (LAG) with two physical port members.  If the tunnel
+ interface is the logical port bound to OpenFlow.  In this case,
+ OFPXMT_OF_IN_PORT is the tunnel's port number and OFPXMT_OF_IN_PHY_PORT is
+ the physical port number of the LAG on which the tunnel is configured.
+
+ When a packet is received directly on a physical port and not processed by a
+ logical port, OFPXMT_OF_IN_PORT and OFPXMT_OF_IN_PHY_PORT have the same
+ value.
+
+ This field is usually not available in a regular match and only available
+ in ofp_packet_in messages when it's different from OXM_OF_IN_PORT.
+
+ Prereqs: OXM_OF_IN_PORT must be present.
+
+ Format: 32-bit integer in network byte order.
+
+ Masking: Not maskable.";
+                }
+            }
+            case table_metadata {
+                leaf table_metadata {
+                    type  uint64;
+                    description
+                        "#define OXM_OF_METADATA   OXM_HEADER  (0x8000, OFPXMT_OFB_METADATA, 8)
+#define OXM_OF_METADATA_W OXM_HEADER_W(0x8000, OFPXMT_OFB_METADATA, 8)
+Used for OFPXMT_OFB_METADATATable metadata.
+
+ Prereqs: None.
+
+ Format: 64-bit integer in network byte order.
+
+ Masking: Arbitrary masks.";
+                }
+            }
+            case eth_dst {
+                leaf eth_dst {
+                    type  binary;
+                    description
+                        "#define OXM_OF_ETH_DST    OXM_HEADER  (0x8000, OFPXMT_OFB_ETH_DST, 6)
+#define OXM_OF_ETH_DST_W  OXM_HEADER_W(0x8000, OFPXMT_OFB_ETH_DST, 6)
+#define OXM_OF_ETH_SRC    OXM_HEADER  (0x8000, OFPXMT_OFB_ETH_SRC, 6)
+#define OXM_OF_ETH_SRC_W  OXM_HEADER_W(0x8000, OFPXMT_OFB_ETH_SRC, 6)
+Used for OFPXMT_OFB_ETH_DST (exactly 6 bytes)Source or destination address in Ethernet header.
+
+ Prereqs: None.
+
+ Format: 48-bit Ethernet MAC address.
+
+ Masking: Arbitrary masks.";
+                }
+            }
+            case eth_src {
+                leaf eth_src {
+                    type  binary;
+                    description
+                        "Used for OFPXMT_OFB_ETH_SRC (exactly 6 bytes)";
+                }
+            }
+            case eth_type {
+                leaf eth_type {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_ETH_TYPE   OXM_HEADER  (0x8000, OFPXMT_OFB_ETH_TYPE,2)
+Used for OFPXMT_OFB_ETH_TYPEPacket's Ethernet type.
+
+ Prereqs: None.
+
+ Format: 16-bit integer in network byte order.
+
+ Masking: Not maskable.";
+                }
+            }
+            case vlan_vid {
+                leaf vlan_vid {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_VLAN_VID   OXM_HEADER  (0x8000, OFPXMT_OFB_VLAN_VID, 2)
+#define OXM_OF_VLAN_VID_W OXM_HEADER_W(0x8000, OFPXMT_OFB_VLAN_VID, 2)
+Used for OFPXMT_OFB_VLAN_VID802.1Q VID.
+
+ For a packet with an 802.1Q header, this is the VLAN-ID (VID) from the
+ outermost tag, with the CFI bit forced to 1. For a packet with no 802.1Q
+ header, this has value OFPVID_NONE.
+
+ Prereqs: None.
+
+ Format: 16-bit integer in network byte order with bit 13 indicating
+ presence of VLAN header and 3 most-significant bits forced to 0.
+ Only the lower 13 bits have meaning.
+
+ Masking: Arbitrary masks.
+
+ This field can be used in various ways:
+
+   - If it is not constrained at all, the nx_match matches packets without
+     an 802.1Q header or with an 802.1Q header that has any VID value.
+
+   - Testing for an exact match with 0x0 matches only packets without
+     an 802.1Q header.
+
+   - Testing for an exact match with a VID value with CFI=1 matches packets
+     that have an 802.1Q header with a specified VID.
+
+   - Testing for an exact match with a nonzero VID value with CFI=0 does
+     not make sense.  The switch may reject this combination.
+
+   - Testing with nxm_value=0, nxm_mask=0x0fff matches packets with no 802.1Q
+     header or with an 802.1Q header with a VID of 0.
+
+   - Testing with nxm_value=0x1000, nxm_mask=0x1000 matches packets with
+     an 802.1Q header that has any VID value.";
+                }
+            }
+            case vlan_pcp {
+                leaf vlan_pcp {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_VLAN_PCP   OXM_HEADER  (0x8000, OFPXMT_OFB_VLAN_PCP, 1)
+Used for OFPXMT_OFB_VLAN_PCP802.1Q PCP.
+
+ For a packet with an 802.1Q header, this is the VLAN-PCP from the
+ outermost tag.  For a packet with no 802.1Q header, this has value
+ 0.
+
+ Prereqs: OXM_OF_VLAN_VID must be different from OFPVID_NONE.
+
+ Format: 8-bit integer with 5 most-significant bits forced to 0.
+ Only the lower 3 bits have meaning.
+
+ Masking: Not maskable.";
+                }
+            }
+            case ip_dscp {
+                leaf ip_dscp {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_IP_DSCP     OXM_HEADER  (0x8000, OFPXMT_OFB_IP_DSCP, 1)
+Used for OFPXMT_OFB_IP_DSCPThe Diff Serv Code Point (DSCP) bits of the IP header.
+ Part of the IPv4 ToS field or the IPv6 Traffic Class field.
+
+ Prereqs: OXM_OF_ETH_TYPE must be either 0x0800 or 0x86dd.
+
+ Format: 8-bit integer with 2 most-significant bits forced to 0.
+ Only the lower 6 bits have meaning.
+
+ Masking: Not maskable.";
+                }
+            }
+            case ip_ecn {
+                leaf ip_ecn {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_IP_ECN     OXM_HEADER  (0x8000, OFPXMT_OFB_IP_ECN, 1)
+Used for OFPXMT_OFB_IP_ECNThe ECN bits of the IP header.
+ Part of the IPv4 ToS field or the IPv6 Traffic Class field.
+
+ Prereqs: OXM_OF_ETH_TYPE must be either 0x0800 or 0x86dd.
+
+ Format: 8-bit integer with 6 most-significant bits forced to 0.
+ Only the lower 2 bits have meaning.
+
+ Masking: Not maskable.";
+                }
+            }
+            case ip_proto {
+                leaf ip_proto {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_IP_PROTO   OXM_HEADER  (0x8000, OFPXMT_OFB_IP_PROTO, 1)
+Used for OFPXMT_OFB_IP_PROTOThe  protocol  byte in the IP header.
+
+ Prereqs: OXM_OF_ETH_TYPE must be either 0x0800 or 0x86dd.
+
+ Format: 8-bit integer.
+
+ Masking: Not maskable.";
+                }
+            }
+            case ipv4_src {
+                leaf ipv4_src {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_IPV4_SRC     OXM_HEADER  (0x8000, OFPXMT_OFB_IPV4_SRC, 4)
+#define OXM_OF_IPV4_SRC_W   OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV4_SRC, 4)
+#define OXM_OF_IPV4_DST     OXM_HEADER  (0x8000, OFPXMT_OFB_IPV4_DST, 4)
+#define OXM_OF_IPV4_DST_W   OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV4_DST, 4)
+Used for OFPXMT_OFB_IPV4_SRCThe source or destination address in the IP header.
+
+ Prereqs: OXM_OF_ETH_TYPE must match 0x0800 exactly.
+
+ Format: 32-bit integer in network byte order.
+
+ Masking: Arbitrary masks.";
+                }
+            }
+            case ipv4_dst {
+                leaf ipv4_dst {
+                    type  uint32;
+                    description
+                        "Used for OFPXMT_OFB_IPV4_DST";
+                }
+            }
+            case tcp_src {
+                leaf tcp_src {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_TCP_SRC    OXM_HEADER  (0x8000, OFPXMT_OFB_TCP_SRC, 2)
+#define OXM_OF_TCP_DST    OXM_HEADER  (0x8000, OFPXMT_OFB_TCP_DST, 2)
+Used for OFPXMT_OFB_TCP_SRCThe source or destination port in the TCP header.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must be either 0x0800 or 0x86dd.
+   OXM_OF_IP_PROTO must match 6 exactly.
+
+ Format: 16-bit integer in network byte order.
+
+ Masking: Not maskable.";
+                }
+            }
+            case tcp_dst {
+                leaf tcp_dst {
+                    type  uint32;
+                    description
+                        "Used for OFPXMT_OFB_TCP_DST";
+                }
+            }
+            case udp_src {
+                leaf udp_src {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_UDP_SRC    OXM_HEADER  (0x8000, OFPXMT_OFB_UDP_SRC, 2)
+#define OXM_OF_UDP_DST    OXM_HEADER  (0x8000, OFPXMT_OFB_UDP_DST, 2)
+Used for OFPXMT_OFB_UDP_SRCThe source or destination port in the UDP header.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match either 0x0800 or 0x86dd.
+   OXM_OF_IP_PROTO must match 17 exactly.
+
+ Format: 16-bit integer in network byte order.
+
+ Masking: Not maskable.";
+                }
+            }
+            case udp_dst {
+                leaf udp_dst {
+                    type  uint32;
+                    description
+                        "Used for OFPXMT_OFB_UDP_DST";
+                }
+            }
+            case sctp_src {
+                leaf sctp_src {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_SCTP_SRC   OXM_HEADER  (0x8000, OFPXMT_OFB_SCTP_SRC, 2)
+#define OXM_OF_SCTP_DST   OXM_HEADER  (0x8000, OFPXMT_OFB_SCTP_DST, 2)
+Used for OFPXMT_OFB_SCTP_SRCThe source or destination port in the SCTP header.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match either 0x0800 or 0x86dd.
+   OXM_OF_IP_PROTO must match 132 exactly.
+
+ Format: 16-bit integer in network byte order.
+
+ Masking: Not maskable.";
+                }
+            }
+            case sctp_dst {
+                leaf sctp_dst {
+                    type  uint32;
+                    description
+                        "Used for OFPXMT_OFB_SCTP_DST";
+                }
+            }
+            case icmpv4_type {
+                leaf icmpv4_type {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_ICMPV4_TYPE  OXM_HEADER  (0x8000, OFPXMT_OFB_ICMPV4_TYPE, 1)
+#define OXM_OF_ICMPV4_CODE  OXM_HEADER  (0x8000, OFPXMT_OFB_ICMPV4_CODE, 1)
+Used for OFPXMT_OFB_ICMPV4_TYPEThe type or code in the ICMP header.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match 0x0800 exactly.
+   OXM_OF_IP_PROTO must match 1 exactly.
+
+ Format: 8-bit integer.
+
+ Masking: Not maskable.";
+                }
+            }
+            case icmpv4_code {
+                leaf icmpv4_code {
+                    type  uint32;
+                    description
+                        "Used for OFPXMT_OFB_ICMPV4_CODE";
+                }
+            }
+            case arp_op {
+                leaf arp_op {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_ARP_OP     OXM_HEADER  (0x8000, OFPXMT_OFB_ARP_OP, 2)
+Used for OFPXMT_OFB_ARP_OPARP opcode.
+
+ For an Ethernet+IP ARP packet, the opcode in the ARP header.  Always 0
+ otherwise.
+
+ Prereqs: OXM_OF_ETH_TYPE must match 0x0806 exactly.
+
+ Format: 16-bit integer in network byte order.
+
+ Masking: Not maskable.";
+                }
+            }
+            case arp_spa {
+                leaf arp_spa {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_ARP_SPA    OXM_HEADER  (0x8000, OFPXMT_OFB_ARP_SPA, 4)
+#define OXM_OF_ARP_SPA_W  OXM_HEADER_W(0x8000, OFPXMT_OFB_ARP_SPA, 4)
+#define OXM_OF_ARP_TPA    OXM_HEADER  (0x8000, OFPXMT_OFB_ARP_TPA, 4)
+#define OXM_OF_ARP_TPA_W  OXM_HEADER_W(0x8000, OFPXMT_OFB_ARP_TPA, 4)
+For OFPXMT_OFB_ARP_SPAFor an Ethernet+IP ARP packet, the source or target protocol address
+ in the ARP header.  Always 0 otherwise.
+
+ Prereqs: OXM_OF_ETH_TYPE must match 0x0806 exactly.
+
+ Format: 32-bit integer in network byte order.
+
+ Masking: Arbitrary masks.";
+                }
+            }
+            case arp_tpa {
+                leaf arp_tpa {
+                    type  uint32;
+                    description
+                        "For OFPXMT_OFB_ARP_TPA";
+                }
+            }
+            case arp_sha {
+                leaf arp_sha {
+                    type  binary;
+                    description
+                        "#define OXM_OF_ARP_SHA    OXM_HEADER   (0x8000, OFPXMT_OFB_ARP_SHA, 6)
+#define OXM_OF_ARP_SHA_W  OXM_HEADER_W (0x8000, OFPXMT_OFB_ARP_SHA, 6)
+#define OXM_OF_ARP_THA    OXM_HEADER   (0x8000, OFPXMT_OFB_ARP_THA, 6)
+#define OXM_OF_ARP_THA_W  OXM_HEADER_W (0x8000, OFPXMT_OFB_ARP_THA, 6)
+For OFPXMT_OFB_ARP_SHA (6 bytes)For an Ethernet+IP ARP packet, the source or target hardware address
+ in the ARP header.  Always 0 otherwise.
+
+ Prereqs: OXM_OF_ETH_TYPE must match 0x0806 exactly.
+
+ Format: 48-bit Ethernet MAC address.
+
+ Masking: Not maskable.";
+                }
+            }
+            case arp_tha {
+                leaf arp_tha {
+                    type  binary;
+                    description
+                        "For OFPXMT_OFB_ARP_THA (6 bytes)";
+                }
+            }
+            case ipv6_src {
+                leaf ipv6_src {
+                    type  binary;
+                    description
+                        "#define OXM_OF_IPV6_SRC    OXM_HEADER  (0x8000, OFPXMT_OFB_IPV6_SRC, 16)
+#define OXM_OF_IPV6_SRC_W  OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV6_SRC, 16)
+#define OXM_OF_IPV6_DST    OXM_HEADER  (0x8000, OFPXMT_OFB_IPV6_DST, 16)
+#define OXM_OF_IPV6_DST_W  OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV6_DST, 16)
+For OFPXMT_OFB_IPV6_SRCThe source or destination address in the IPv6 header.
+
+ Prereqs: OXM_OF_ETH_TYPE must match 0x86dd exactly.
+
+ Format: 128-bit IPv6 address.
+
+ Masking: Arbitrary masks.";
+                }
+            }
+            case ipv6_dst {
+                leaf ipv6_dst {
+                    type  binary;
+                    description
+                        "For OFPXMT_OFB_IPV6_DST";
+                }
+            }
+            case ipv6_flabel {
+                leaf ipv6_flabel {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_IPV6_FLABEL   OXM_HEADER  (0x8000, OFPXMT_OFB_IPV6_FLABEL, 4)
+#define OXM_OF_IPV6_FLABEL_W OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV6_FLABEL, 4)
+For OFPXMT_OFB_IPV6_FLABELThe IPv6 Flow Label
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match 0x86dd exactly
+
+ Format: 32-bit integer with 12 most-significant bits forced to 0.
+ Only the lower 20 bits have meaning.
+
+ Masking: Arbitrary masks.";
+                }
+            }
+            case icmpv6_type {
+                leaf icmpv6_type {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_ICMPV6_TYPE OXM_HEADER  (0x8000, OFPXMT_OFB_ICMPV6_TYPE, 1)
+#define OXM_OF_ICMPV6_CODE OXM_HEADER  (0x8000, OFPXMT_OFB_ICMPV6_CODE, 1)
+For OFPXMT_OFB_ICMPV6_TYPEThe type or code in the ICMPv6 header.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match 0x86dd exactly.
+   OXM_OF_IP_PROTO must match 58 exactly.
+
+ Format: 8-bit integer.
+
+ Masking: Not maskable.";
+                }
+            }
+            case icmpv6_code {
+                leaf icmpv6_code {
+                    type  uint32;
+                    description
+                        "For OFPXMT_OFB_ICMPV6_CODE";
+                }
+            }
+            case ipv6_nd_target {
+                leaf ipv6_nd_target {
+                    type  binary;
+                    description
+                        "#define OXM_OF_IPV6_ND_TARGET OXM_HEADER
+    (0x8000, OFPXMT_OFB_IPV6_ND_TARGET, 16)
+For OFPXMT_OFB_IPV6_ND_TARGETThe target address in an IPv6 Neighbor Discovery message.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match 0x86dd exactly.
+   OXM_OF_IP_PROTO must match 58 exactly.
+   OXM_OF_ICMPV6_TYPE must be either 135 or 136.
+
+ Format: 128-bit IPv6 address.
+
+ Masking: Not maskable.";
+                }
+            }
+            case ipv6_nd_ssl {
+                leaf ipv6_nd_ssl {
+                    type  binary;
+                    description
+                        "#define OXM_OF_IPV6_ND_SLL  OXM_HEADER  (0x8000, OFPXMT_OFB_IPV6_ND_SLL, 6)
+For OFPXMT_OFB_IPV6_ND_SLLThe source link-layer address option in an IPv6 Neighbor Discovery
+ message.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match 0x86dd exactly.
+   OXM_OF_IP_PROTO must match 58 exactly.
+   OXM_OF_ICMPV6_TYPE must be exactly 135.
+
+ Format: 48-bit Ethernet MAC address.
+
+ Masking: Not maskable.";
+                }
+            }
+            case ipv6_nd_tll {
+                leaf ipv6_nd_tll {
+                    type  binary;
+                    description
+                        "#define OXM_OF_IPV6_ND_TLL  OXM_HEADER  (0x8000, OFPXMT_OFB_IPV6_ND_TLL, 6)
+For OFPXMT_OFB_IPV6_ND_TLLThe target link-layer address option in an IPv6 Neighbor Discovery
+ message.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match 0x86dd exactly.
+   OXM_OF_IP_PROTO must match 58 exactly.
+   OXM_OF_ICMPV6_TYPE must be exactly 136.
+
+ Format: 48-bit Ethernet MAC address.
+
+ Masking: Not maskable.";
+                }
+            }
+            case mpls_label {
+                leaf mpls_label {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_MPLS_LABEL  OXM_HEADER  (0x8000, OFPXMT_OFB_MPLS_LABEL, 4)
+For OFPXMT_OFB_MPLS_LABELThe LABEL in the first MPLS shim header.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match 0x8847 or 0x8848 exactly.
+
+ Format: 32-bit integer in network byte order with 12 most-significant
+ bits forced to 0. Only the lower 20 bits have meaning.
+
+ Masking: Not maskable.";
+                }
+            }
+            case mpls_tc {
+                leaf mpls_tc {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_MPLS_TC     OXM_HEADER  (0x8000, OFPXMT_OFB_MPLS_TC, 1)
+For OFPXMT_OFB_MPLS_TCThe TC in the first MPLS shim header.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match 0x8847 or 0x8848 exactly.
+
+ Format: 8-bit integer with 5 most-significant bits forced to 0.
+ Only the lower 3 bits have meaning.
+
+ Masking: Not maskable.";
+                }
+            }
+            case mpls_bos {
+                leaf mpls_bos {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_MPLS_BOS     OXM_HEADER  (0x8000, OFPXMT_OFB_MPLS_BOS, 1)
+For OFPXMT_OFB_MPLS_BOSThe BoS bit in the first MPLS shim header.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match 0x8847 or 0x8848 exactly.
+
+ Format: 8-bit integer with 7 most-significant bits forced to 0.
+ Only the lowest bit have a meaning.
+
+ Masking: Not maskable.";
+                }
+            }
+            case pbb_isid {
+                leaf pbb_isid {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_PBB_ISID   OXM_HEADER  (0x8000, OFPXMT_OFB_PBB_ISID, 3)
+#define OXM_OF_PBB_ISID_W OXM_HEADER_W(0x8000, OFPXMT_OFB_PBB_ISID, 3)
+For OFPXMT_OFB_PBB_ISIDIEEE 802.1ah I-SID.
+
+ For a packet with a PBB header, this is the I-SID from the
+ outermost service tag.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match 0x88E7 exactly.
+
+ Format: 24-bit integer in network byte order.
+
+ Masking: Arbitrary masks.";
+                }
+            }
+            case tunnel_id {
+                leaf tunnel_id {
+                    type  uint64;
+                    description
+                        "#define OXM_OF_TUNNEL_ID    OXM_HEADER  (0x8000, OFPXMT_OFB_TUNNEL_ID, 8)
+#define OXM_OF_TUNNEL_ID_W  OXM_HEADER_W(0x8000, OFPXMT_OFB_TUNNEL_ID, 8)
+For OFPXMT_OFB_TUNNEL_IDLogical Port Metadata.
+
+ Metadata associated with a logical port.
+ If the logical port performs encapsulation and decapsulation, this
+ is the demultiplexing field from the encapsulation header.
+ For example, for a packet received via GRE tunnel including a (32-bit) key,
+ the key is stored in the low 32-bits and the high bits are zeroed.
+ For a MPLS logical port, the low 20 bits represent the MPLS Label.
+ For a VxLAN logical port, the low 24 bits represent the VNI.
+ If the packet is not received through a logical port, the value is 0.
+
+ Prereqs: None.
+
+ Format: 64-bit integer in network byte order.
+
+ Masking: Arbitrary masks.";
+                }
+            }
+            case ipv6_exthdr {
+                leaf ipv6_exthdr {
+                    type  uint32;
+                    description
+                        "#define OXM_OF_IPV6_EXTHDR   OXM_HEADER  (0x8000, OFPXMT_OFB_IPV6_EXTHDR, 2)
+#define OXM_OF_IPV6_EXTHDR_W OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV6_EXTHDR, 2)
+For OFPXMT_OFB_IPV6_EXTHDRThe IPv6 Extension Header pseudo-field.
+
+ Prereqs:
+   OXM_OF_ETH_TYPE must match 0x86dd exactly
+
+ Format: 16-bit integer with 7 most-significant bits forced to 0.
+ Only the lower 9 bits have meaning.
+
+ Masking: Maskable.";
+                }
+            }
+        }
+        choice choice_1 {
+            case table_metadata_mask {
+                leaf table_metadata_mask {
+                    type  uint64;
+                    description
+                        "For OFPXMT_OFB_METADATA";
+                }
+            }
+            case eth_dst_mask {
+                leaf eth_dst_mask {
+                    type  binary;
+                    description
+                        "For OFPXMT_OFB_ETH_DST (exactly 6 bytes)";
+                }
+            }
+            case eth_src_mask {
+                leaf eth_src_mask {
+                    type  binary;
+                    description
+                        "For OFPXMT_OFB_ETH_SRC (exactly 6 bytes)";
+                }
+            }
+            case vlan_vid_mask {
+                leaf vlan_vid_mask {
+                    type  uint32;
+                    description
+                        "For OFPXMT_OFB_VLAN_VID";
+                }
+            }
+            case ipv4_src_mask {
+                leaf ipv4_src_mask {
+                    type  uint32;
+                    description
+                        "For OFPXMT_OFB_IPV4_SRC";
+                }
+            }
+            case ipv4_dst_mask {
+                leaf ipv4_dst_mask {
+                    type  uint32;
+                    description
+                        "For OFPXMT_OFB_IPV4_DST";
+                }
+            }
+            case arp_spa_mask {
+                leaf arp_spa_mask {
+                    type  uint32;
+                    description
+                        "For OFPXMT_OFB_ARP_SPA";
+                }
+            }
+            case arp_tpa_mask {
+                leaf arp_tpa_mask {
+                    type  uint32;
+                    description
+                        "For OFPXMT_OFB_ARP_TPA";
+                }
+            }
+            case ipv6_src_mask {
+                leaf ipv6_src_mask {
+                    type  binary;
+                    description
+                        "For OFPXMT_OFB_IPV6_SRC";
+                }
+            }
+            case ipv6_dst_mask {
+                leaf ipv6_dst_mask {
+                    type  binary;
+                    description
+                        "For OFPXMT_OFB_IPV6_DST";
+                }
+            }
+            case ipv6_flabel_mask {
+                leaf ipv6_flabel_mask {
+                    type  uint32;
+                    description
+                        "For OFPXMT_OFB_IPV6_FLABEL";
+                }
+            }
+            case pbb_isid_mask {
+                leaf pbb_isid_mask {
+                    type  uint32;
+                    description
+                        "For OFPXMT_OFB_PBB_ISID";
+                }
+            }
+            case tunnel_id_mask {
+                leaf tunnel_id_mask {
+                    type  uint64;
+                    description
+                        "For OFPXMT_OFB_TUNNEL_ID";
+                }
+            }
+            case ipv6_exthdr_mask {
+                leaf ipv6_exthdr_mask {
+                    type  uint32;
+                    description
+                        "For OFPXMT_OFB_IPV6_EXTHDR";
+                }
+            }
+        }
+
+
+    }
+
+    grouping ofp_oxm_experimenter_field {
+        description
+            "Header for OXM experimenter match fields.
+ The experimenter class should not use OXM_HEADER() macros for defining
+ fields due to this extra header.";
+        leaf oxm_header {
+            type  uint32;
+            description
+                "oxm_class = OFPXMC_EXPERIMENTER";
+        }
+
+        leaf experimenter {
+            type  uint32;
+            description
+                "Experimenter ID which takes the same
+form as in struct ofp_experimenter_header.";
+        }
+
+
+
+    }
+
+    grouping ofp_action {
+        description
+            "Action header that is common to all actions.  The length includes the
+ header and any padding used to make the action 64-bit aligned.
+ NB: The length of an action  must  always be a multiple of eight.";
+        leaf type {
+            type  ofp_action_type;
+
+            description
+                "One of OFPAT_ .";
+        }
+
+
+
+        choice choice_0 {
+            case output {
+                container output {
+                    uses  ofp_action_output;
+
+                    description
+                        "";
+                }
+            }
+            case mpls_ttl {
+                container mpls_ttl {
+                    uses  ofp_action_mpls_ttl;
+
+                    description
+                        "";
+                }
+            }
+            case push {
+                container push {
+                    uses  ofp_action_push;
+
+                    description
+                        "";
+                }
+            }
+            case pop_mpls {
+                container pop_mpls {
+                    uses  ofp_action_pop_mpls;
+
+                    description
+                        "";
+                }
+            }
+            case group {
+                container group {
+                    uses  ofp_action_group;
+
+                    description
+                        "";
+                }
+            }
+            case nw_ttl {
+                container nw_ttl {
+                    uses  ofp_action_nw_ttl;
+
+                    description
+                        "";
+                }
+            }
+            case set_field {
+                container set_field {
+                    uses  ofp_action_set_field;
+f
+                    description
+                        "";
+                }
+            }
+            case experimenter {
+                container experimenter {
+                    uses  ofp_action_experimenter;
+
+                    description
+                        "";
+                }
+            }
+        }
+
+
+    }
+
+    grouping ofp_action_output {
+        description
+            "Action structure for OFPAT_OUTPUT, which sends packets out 'port'.
+ When the 'port' is the OFPP_CONTROLLER, 'max_len' indicates the max
+ number of bytes to send.  A 'max_len' of zero means no bytes of the
+ packet should be sent. A 'max_len' of OFPCML_NO_BUFFER means that
+ the packet is not buffered and the complete packet is to be sent to
+ the controller.";
+        leaf port {
+            type  uint32;
+            description
+                "Output port.";
+        }
+
+        leaf max_len {
+            type  uint32;
+            description
+                "Max length to send to controller.";
+        }
+
+
+
+    }
+
+    grouping ofp_action_mpls_ttl {
+        description
+            "Action structure for OFPAT_SET_MPLS_TTL.";
+        leaf mpls_ttl {
+            type  uint32;
+            description
+                "MPLS TTL";
+        }
+
+
+
+    }
+
+    grouping ofp_action_push {
+        description
+            "Action structure for OFPAT_PUSH_VLAN MPLS PBB.";
+        leaf ethertype {
+            type  uint32;
+            description
+                "Ethertype";
+        }
+
+
+
+    }
+
+    grouping ofp_action_pop_mpls {
+        description
+            "Action structure for OFPAT_POP_MPLS.";
+        leaf ethertype {
+            type  uint32;
+            description
+                "Ethertype";
+        }
+
+
+
+    }
+
+    grouping ofp_action_group {
+        description
+            "Action structure for OFPAT_GROUP.";
+        leaf group_id {
+            type  uint32;
+            description
+                "Group identifier.";
+        }
+
+
+
+    }
+
+    grouping ofp_action_nw_ttl {
+        description
+            "Action structure for OFPAT_SET_NW_TTL.";
+        leaf nw_ttl {
+            type  uint32;
+            description
+                "IP TTL";
+        }
+
+
+
+    }
+
+    grouping ofp_action_set_field {
+        description
+            "Action structure for OFPAT_SET_FIELD.";
+        container field {
+            uses  ofp_oxm_field;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping ofp_action_experimenter {
+        description
+            "Action header for OFPAT_EXPERIMENTER.
+ The rest of the body is experimenter-defined.";
+        leaf experimenter {
+            type  uint32;
+            description
+                "Experimenter ID which takes the same
+form as in struct
+ofp_experimenter_header.";
+        }
+
+        leaf data {
+            type  binary;
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping ofp_instruction {
+        description
+            "Instruction header that is common to all instructions.  The length includes
+ the header and any padding used to make the instruction 64-bit aligned.
+ NB: The length of an instruction  must  always be a multiple of eight.";
+        leaf type {
+            type  uint32;
+            description
+                "Instruction type";
+        }
+
+
+
+        choice choice_0 {
+            case goto_table {
+                container goto_table {
+                    uses  ofp_instruction_goto_table;
+
+                    description
+                        "";
+                }
+            }
+            case write_metadata {
+                container write_metadata {
+                    uses  ofp_instruction_write_metadata;
+
+                    description
+                        "";
+                }
+            }
+            case actions {
+                container actions {
+                    uses  ofp_instruction_actions;
+
+                    description
+                        "";
+                }
+            }
+            case meter {
+                container meter {
+                    uses  ofp_instruction_meter;
+
+                    description
+                        "";
+                }
+            }
+            case experimenter {
+                container experimenter {
+                    uses  ofp_instruction_experimenter;
+
+                    description
+                        "";
+                }
+            }
+        }
+
+
+    }
+
+    grouping ofp_instruction_goto_table {
+        description
+            "Instruction structure for OFPIT_GOTO_TABLE";
+        leaf table_id {
+            type  uint32;
+            description
+                "Set next table in the lookup pipeline";
+        }
+
+
+
+    }
+
+    grouping ofp_instruction_write_metadata {
+        description
+            "Instruction structure for OFPIT_WRITE_METADATA";
+        leaf metadata {
+            type  uint64;
+            description
+                "Metadata value to write";
+        }
+
+        leaf metadata_mask {
+            type  uint64;
+            description
+                "Metadata write bitmask";
+        }
+
+
+
+    }
+
+    grouping ofp_instruction_actions {
+        description
+            "Instruction structure for OFPIT_WRITE APPLY CLEAR_ACTIONS";
+        list actions {
+            key "type";
+            uses  ofp_action;
+
+            description
+                "0 or more actions associated
+with OFPIT_WRITE_ACTIONS and
+OFPIT_APPLY_ACTIONS";
+        }
+
+
+
+    }
+
+    grouping ofp_instruction_meter {
+        description
+            "Instruction structure for OFPIT_METER";
+        leaf meter_id {
+            type  uint32;
+            description
+                "Meter instance.";
+        }
+
+
+
+    }
+
+    grouping ofp_instruction_experimenter {
+        description
+            "Instruction structure for experimental instructions";
+        leaf experimenter {
+            type  uint32;
+            description
+                "Experimenter ID which takes the same form
+as in struct ofp_experimenter_header.";
+        }
+
+        leaf data {
+            type  binary;
+            description
+                "Experimenter-defined arbitrary additional data.";
+        }
+
+
+
+    }
+
+    grouping ofp_flow_mod {
+        description
+            "Flow setup and teardown (controller -  datapath).";
+        leaf cookie {
+            type  uint64;
+            description
+                "ofp_header header;
+Opaque controller-issued identifier.";
+        }
+
+        leaf cookie_mask {
+            type  uint64;
+            description
+                "Mask used to restrict the cookie bits
+that must match when the command is
+OFPFC_MODIFY  or OFPFC_DELETE . A value
+of 0 indicates no restriction.";
+        }
+
+        leaf table_id {
+            type  uint32;
+            description
+                "ID of the table to put the flow in.
+For OFPFC_DELETE_  commands, OFPTT_ALL
+can also be used to delete matching
+flows from all tables.";
+        }
+
+        leaf command {
+            type  ofp_flow_mod_command;
+
+            description
+                "One of OFPFC_ .";
+        }
+
+        leaf idle_timeout {
+            type  uint32;
+            description
+                "Idle time before discarding (seconds).";
+        }
+
+        leaf hard_timeout {
+            type  uint32;
+            description
+                "Max time before discarding (seconds).";
+        }
+
+        leaf priority {
+            type  uint32;
+            description
+                "Priority level of flow entry.";
+        }
+
+        leaf buffer_id {
+            type  uint32;
+            description
+                "Buffered packet to apply to, or
+OFP_NO_BUFFER.
+Not meaningful for OFPFC_DELETE .";
+        }
+
+        leaf out_port {
+            type  uint32;
+            description
+                "For OFPFC_DELETE  commands, require
+matching entries to include this as an
+output port.  A value of OFPP_ANY
+indicates no restriction.";
+        }
+
+        leaf out_group {
+            type  uint32;
+            description
+                "For OFPFC_DELETE  commands, require
+matching entries to include this as an
+output group.  A value of OFPG_ANY
+indicates no restriction.";
+        }
+
+        leaf flags {
+            type  uint32;
+            description
+                "Bitmap of OFPFF_  flags.";
+        }
+
+        container match {
+            uses  ofp_match;
+
+            description
+                "Fields to match. Variable size.";
+        }
+
+        list instructions {
+            key "type";
+            uses  ofp_instruction;
+
+            description
+                "0 or more.";
+        }
+
+
+
+    }
+
+    grouping ofp_bucket {
+        description
+            "Bucket for use in groups.";
+        leaf weight {
+            type  uint32;
+            description
+                "Relative weight of bucket.  Only
+defined for select groups.";
+        }
+
+        leaf watch_port {
+            type  uint32;
+            description
+                "Port whose state affects whether this
+bucket is live.  Only required for fast
+failover groups.";
+        }
+
+        leaf watch_group {
+            type  uint32;
+            description
+                "Group whose state affects whether this
+bucket is live.  Only required for fast
+failover groups.";
+        }
+
+        list actions {
+            key "type";
+            uses  ofp_action;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping ofp_group_mod {
+        description
+            "Group setup and teardown (controller -  datapath).";
+        leaf command {
+            type  ofp_group_mod_command;
+
+            description
+                "ofp_header header;
+One of OFPGC_ .";
+        }
+
+        leaf type {
+            type  ofp_group_type;
+
+            description
+                "One of OFPGT_ .";
+        }
+
+        leaf group_id {
+            type  uint32;
+            description
+                "Group identifier.";
+        }
+
+        list buckets {
+            key "weight";
+            uses  ofp_bucket;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping ofp_packet_out {
+        description
+            "Send packet (controller -  datapath).Special buffer-id to indicate 'no buffer'#define OFP_NO_BUFFER 0xffffffff";
+        leaf buffer_id {
+            type  uint32;
+            description
+                "ofp_header header;
+ID assigned by datapath (OFP_NO_BUFFER
+if none).";
+        }
+
+        leaf in_port {
+            type  uint32;
+            description
+                "Packet's input port or OFPP_CONTROLLER.";
+        }
+
+        list actions {
+            key "type";
+            uses  ofp_action;
+
+            description
+                "Action list - 0 or more.";
+        }
+
+        leaf data {
+            type  binary;
+            description
+                "The variable size action list is optionally followed by packet data.
+ This data is only present and meaningful if buffer_id == -1.Packet data.";
+        }
+
+
+
+    }
+
+    grouping ofp_packet_in {
+        description
+            "Packet received on port (datapath -  controller).";
+        leaf buffer_id {
+            type  uint32;
+            description
+                "ofp_header header;
+ID assigned by datapath.";
+        }
+
+        leaf reason {
+            type  ofp_packet_in_reason;
+
+            description
+                "Reason packet is being sent";
+        }
+
+        leaf table_id {
+            type  uint32;
+            description
+                "ID of the table that was looked up";
+        }
+
+        leaf cookie {
+            type  uint64;
+            description
+                "Cookie of the flow entry that was looked up.";
+        }
+
+        container match {
+            uses  ofp_match;
+
+            description
+                "Packet metadata. Variable size.";
+        }
+
+        leaf data {
+            type  binary;
+            description
+                "Ethernet frame";
+        }
+
+
+
+    }
+
+    container ofp_flow_removed {
+        description
+            "Flow removed (datapath -  controller).";
+        leaf cookie {
+            type  uint64;
+            description
+                "ofp_header header;
+Opaque controller-issued identifier.";
+        }
+
+        leaf priority {
+            type  uint32;
+            description
+                "Priority level of flow entry.";
+        }
+
+        leaf reason {
+            type  ofp_flow_removed_reason;
+
+            description
+                "One of OFPRR_ .";
+        }
+
+        leaf table_id {
+            type  uint32;
+            description
+                "ID of the table";
+        }
+
+        leaf duration_sec {
+            type  uint32;
+            description
+                "Time flow was alive in seconds.";
+        }
+
+        leaf duration_nsec {
+            type  uint32;
+            description
+                "Time flow was alive in nanoseconds beyond
+duration_sec.";
+        }
+
+        leaf idle_timeout {
+            type  uint32;
+            description
+                "Idle timeout from original flow mod.";
+        }
+
+        leaf hard_timeout {
+            type  uint32;
+            description
+                "Hard timeout from original flow mod.";
+        }
+
+        leaf packet_count {
+            type  uint64;
+            description
+                "";
+        }
+
+        leaf byte_count {
+            type  uint64;
+            description
+                "";
+        }
+
+        container match {
+            uses  ofp_match;
+
+            description
+                "Description of fields. Variable size.";
+        }
+
+
+
+    }
+
+    grouping ofp_meter_band_header {
+        description
+            "Common header for all meter bands";
+        leaf type {
+            type  ofp_meter_band_type;
+
+            description
+                "One of OFPMBT_ .";
+        }
+
+        leaf len {
+            type  uint32;
+            description
+                "Length in bytes of this band.";
+        }
+
+        leaf rate {
+            type  uint32;
+            description
+                "Rate for this band.";
+        }
+
+        leaf burst_size {
+            type  uint32;
+            description
+                "Size of bursts.";
+        }
+
+
+
+    }
+
+    container ofp_meter_band_drop {
+        description
+            "OFPMBT_DROP band - drop packets";
+        leaf type {
+            type  uint32;
+            description
+                "OFPMBT_DROP.";
+        }
+
+        leaf len {
+            type  uint32;
+            description
+                "Length in bytes of this band.";
+        }
+
+        leaf rate {
+            type  uint32;
+            description
+                "Rate for dropping packets.";
+        }
+
+        leaf burst_size {
+            type  uint32;
+            description
+                "Size of bursts.";
+        }
+
+
+
+    }
+
+    container ofp_meter_band_dscp_remark {
+        description
+            "OFPMBT_DSCP_REMARK band - Remark DSCP in the IP header";
+        leaf type {
+            type  uint32;
+            description
+                "OFPMBT_DSCP_REMARK.";
+        }
+
+        leaf len {
+            type  uint32;
+            description
+                "Length in bytes of this band.";
+        }
+
+        leaf rate {
+            type  uint32;
+            description
+                "Rate for remarking packets.";
+        }
+
+        leaf burst_size {
+            type  uint32;
+            description
+                "Size of bursts.";
+        }
+
+        leaf prec_level {
+            type  uint32;
+            description
+                "Number of drop precedence level to add.";
+        }
+
+
+
+    }
+
+    container ofp_meter_band_experimenter {
+        description
+            "OFPMBT_EXPERIMENTER band - Experimenter type.
+ The rest of the band is experimenter-defined.";
+        leaf type {
+            type  ofp_meter_band_type;
+
+            description
+                "One of OFPMBT_ .";
+        }
+
+        leaf len {
+            type  uint32;
+            description
+                "Length in bytes of this band.";
+        }
+
+        leaf rate {
+            type  uint32;
+            description
+                "Rate for this band.";
+        }
+
+        leaf burst_size {
+            type  uint32;
+            description
+                "Size of bursts.";
+        }
+
+        leaf experimenter {
+            type  uint32;
+            description
+                "Experimenter ID which takes the
+same form as in struct
+ofp_experimenter_header.";
+        }
+
+
+
+    }
+
+    container ofp_meter_mod {
+        description
+            "Meter configuration. OFPT_METER_MOD.";
+        leaf command {
+            type  ofp_meter_mod_command;
+
+            description
+                "ofp_header   header = 1;
+One of OFPMC_ .";
+        }
+
+        leaf flags {
+            type  uint32;
+            description
+                "Bitmap of OFPMF_  flags.";
+        }
+
+        leaf meter_id {
+            type  uint32;
+            description
+                "Meter instance.";
+        }
+
+        list bands {
+            key "type";
+            uses  ofp_meter_band_header;
+
+            description
+                "The band list length is
+inferred from the length field
+in the header.";
+        }
+
+
+
+    }
+
+    container ofp_error_msg {
+        description
+            "OFPT_ERROR: Error message (datapath -  controller).";
+        leaf type {
+            type  uint32;
+            description
+                "ofp_header header;";
+        }
+
+        leaf code {
+            type  uint32;
+            description
+                "";
+        }
+
+        leaf data {
+            type  binary;
+            description
+                "Variable-length data.  Interpreted based
+on the type and code.  No padding.";
+        }
+
+
+
+    }
+
+    container ofp_error_experimenter_msg {
+        description
+            "OFPET_EXPERIMENTER: Error message (datapath -  controller).ofp_header header;";
+        leaf type {
+            type  uint32;
+            description
+                "OFPET_EXPERIMENTER.";
+        }
+
+        leaf exp_type {
+            type  uint32;
+            description
+                "Experimenter defined.";
+        }
+
+        leaf experimenter {
+            type  uint32;
+            description
+                "Experimenter ID which takes the same form
+as in struct ofp_experimenter_header.";
+        }
+
+        leaf data {
+            type  binary;
+            description
+                "Variable-length data.  Interpreted based
+on the type and code.  No padding.";
+        }
+
+
+
+    }
+
+    container ofp_multipart_request {
+        description
+            "";
+        leaf type {
+            type  ofp_multipart_type;
+
+            description
+                "ofp_header header;
+One of the OFPMP_  constants.";
+        }
+
+        leaf flags {
+            type  uint32;
+            description
+                "OFPMPF_REQ_  flags.";
+        }
+
+        leaf body {
+            type  binary;
+            description
+                "Body of the request. 0 or more bytes.";
+        }
+
+
+
+    }
+
+    container ofp_multipart_reply {
+        description
+            "";
+        leaf type {
+            type  ofp_multipart_type;
+
+            description
+                "ofp_header header;
+One of the OFPMP_  constants.";
+        }
+
+        leaf flags {
+            type  uint32;
+            description
+                "OFPMPF_REPLY_  flags.";
+        }
+
+        leaf body {
+            type  binary;
+            description
+                "Body of the reply. 0 or more bytes.";
+        }
+
+
+
+    }
+
+    grouping ofp_desc {
+        description
+            "Body of reply to OFPMP_DESC request.  Each entry is a NULL-terminated
+ ASCII string.#define DESC_STR_LEN   256
+#define SERIAL_NUM_LEN 32";
+        leaf mfr_desc {
+            type  string;
+            description
+                "Manufacturer description.";
+        }
+
+        leaf hw_desc {
+            type  string;
+            description
+                "Hardware description.";
+        }
+
+        leaf sw_desc {
+            type  string;
+            description
+                "Software description.";
+        }
+
+        leaf serial_num {
+            type  string;
+            description
+                "Serial number.";
+        }
+
+        leaf dp_desc {
+            type  string;
+            description
+                "Human readable description of datapath.";
+        }
+
+
+
+    }
+
+    container ofp_flow_stats_request {
+        description
+            "Body for ofp_multipart_request of type OFPMP_FLOW.";
+        leaf table_id {
+            type  uint32;
+            description
+                "ID of table to read (from ofp_table_stats),
+OFPTT_ALL for all tables.";
+        }
+
+        leaf out_port {
+            type  uint32;
+            description
+                "Require matching entries to include this
+as an output port.  A value of OFPP_ANY
+indicates no restriction.";
+        }
+
+        leaf out_group {
+            type  uint32;
+            description
+                "Require matching entries to include this
+as an output group.  A value of OFPG_ANY
+indicates no restriction.";
+        }
+
+        leaf cookie {
+            type  uint64;
+            description
+                "Require matching entries to contain this
+cookie value";
+        }
+
+        leaf cookie_mask {
+            type  uint64;
+            description
+                "Mask used to restrict the cookie bits that
+must match. A value of 0 indicates
+no restriction.";
+        }
+
+        container match {
+            uses  ofp_match;
+
+            description
+                "Fields to match. Variable size.";
+        }
+
+
+
+    }
+
+    grouping ofp_flow_stats {
+        description
+            "Body of reply to OFPMP_FLOW request.";
+        leaf id {
+            type  uint64;
+            description
+                "Unique ID of flow within device.";
+        }
+
+        leaf table_id {
+            type  uint32;
+            description
+                "ID of table flow came from.";
+        }
+
+        leaf duration_sec {
+            type  uint32;
+            description
+                "Time flow has been alive in seconds.";
+        }
+
+        leaf duration_nsec {
+            type  uint32;
+            description
+                "Time flow has been alive in nanoseconds
+beyond duration_sec.";
+        }
+
+        leaf priority {
+            type  uint32;
+            description
+                "Priority of the entry.";
+        }
+
+        leaf idle_timeout {
+            type  uint32;
+            description
+                "Number of seconds idle before expiration.";
+        }
+
+        leaf hard_timeout {
+            type  uint32;
+            description
+                "Number of seconds before expiration.";
+        }
+
+        leaf flags {
+            type  uint32;
+            description
+                "Bitmap of OFPFF_  flags.";
+        }
+
+        leaf cookie {
+            type  uint64;
+            description
+                "Opaque controller-issued identifier.";
+        }
+
+        leaf packet_count {
+            type  uint64;
+            description
+                "Number of packets in flow.";
+        }
+
+        leaf byte_count {
+            type  uint64;
+            description
+                "Number of bytes in flow.";
+        }
+
+        container match {
+            uses  ofp_match;
+
+            description
+                "Description of fields. Variable size.";
+        }
+
+        list instructions {
+            key "type";
+            uses  ofp_instruction;
+
+            description
+                "Instruction set
+(0 or more)";
+        }
+
+
+
+    }
+
+    container ofp_aggregate_stats_request {
+        description
+            "Body for ofp_multipart_request of type OFPMP_AGGREGATE.";
+        leaf table_id {
+            type  uint32;
+            description
+                "ID of table to read (from ofp_table_stats)
+OFPTT_ALL for all tables.";
+        }
+
+        leaf out_port {
+            type  uint32;
+            description
+                "Require matching entries to include this
+as an output port.  A value of OFPP_ANY
+indicates no restriction.";
+        }
+
+        leaf out_group {
+            type  uint32;
+            description
+                "Require matching entries to include this
+as an output group.  A value of OFPG_ANY
+indicates no restriction.";
+        }
+
+        leaf cookie {
+            type  uint64;
+            description
+                "Require matching entries to contain this
+cookie value";
+        }
+
+        leaf cookie_mask {
+            type  uint64;
+            description
+                "Mask used to restrict the cookie bits that
+must match. A value of 0 indicates
+no restriction.";
+        }
+
+        container match {
+            uses  ofp_match;
+
+            description
+                "Fields to match. Variable size.";
+        }
+
+
+
+    }
+
+    container ofp_aggregate_stats_reply {
+        description
+            "Body of reply to OFPMP_AGGREGATE request.";
+        leaf packet_count {
+            type  uint64;
+            description
+                "Number of packets in flows.";
+        }
+
+        leaf byte_count {
+            type  uint64;
+            description
+                "Number of bytes in flows.";
+        }
+
+        leaf flow_count {
+            type  uint32;
+            description
+                "Number of flows.";
+        }
+
+
+
+    }
+
+    grouping ofp_table_feature_property {
+        description
+            "Common header for all Table Feature Properties";
+        leaf type {
+            type  ofp_table_feature_prop_type;
+
+            description
+                "One of OFPTFPT_ .";
+        }
+
+
+
+        choice choice_0 {
+            case instructions {
+                container instructions {
+                    uses  ofp_table_feature_prop_instructions;
+
+                    description
+                        "";
+                }
+            }
+            case next_tables {
+                container next_tables {
+                    uses  ofp_table_feature_prop_next_tables;
+
+                    description
+                        "";
+                }
+            }
+            case actions {
+                container actions {
+                    uses  ofp_table_feature_prop_actions;
+
+                    description
+                        "";
+                }
+            }
+            case oxm {
+                container oxm {
+                    uses  ofp_table_feature_prop_oxm;
+
+                    description
+                        "";
+                }
+            }
+            case experimenter {
+                container experimenter {
+                    uses  ofp_table_feature_prop_experimenter;
+
+                    description
+                        "";
+                }
+            }
+        }
+
+
+    }
+
+    grouping ofp_table_feature_prop_instructions {
+        description
+            "Instructions property";
+        list instructions {
+            key "type";
+            uses  ofp_instruction;
+
+            description
+                "One of OFPTFPT_INSTRUCTIONS,
+OFPTFPT_INSTRUCTIONS_MISS.List of instructions";
+        }
+
+
+
+    }
+
+    grouping ofp_table_feature_prop_next_tables {
+        description
+            "Next Tables property";
+        list next_table_ids {
+            key "next_table_ids";
+            leaf next_table_ids {
+                type  uint32;
+                description
+                    "One of OFPTFPT_NEXT_TABLES,
+OFPTFPT_NEXT_TABLES_MISS.List of table ids.";
+            }
+            description
+                "One of OFPTFPT_NEXT_TABLES,
+OFPTFPT_NEXT_TABLES_MISS.List of table ids.";
+        }
+
+
+
+    }
+
+    grouping ofp_table_feature_prop_actions {
+        description
+            "Actions property";
+        list actions {
+            key "type";
+            uses  ofp_action;
+
+            description
+                "One of OFPTFPT_WRITE_ACTIONS,
+OFPTFPT_WRITE_ACTIONS_MISS,
+OFPTFPT_APPLY_ACTIONS,
+OFPTFPT_APPLY_ACTIONS_MISS.List of actions";
+        }
+
+
+
+    }
+
+    grouping ofp_table_feature_prop_oxm {
+        description
+            "Match, Wildcard or Set-Field propertyOne of OFPTFPT_MATCH,
+OFPTFPT_WILDCARDS,
+OFPTFPT_WRITE_SETFIELD,
+OFPTFPT_WRITE_SETFIELD_MISS,
+OFPTFPT_APPLY_SETFIELD,
+OFPTFPT_APPLY_SETFIELD_MISS.";
+        list oxm_ids {
+            key "oxm_ids";
+            leaf oxm_ids {
+                type  uint32;
+                description
+                    "TODO is this a uint32???Array of OXM headers";
+            }
+            description
+                "TODO is this a uint32???Array of OXM headers";
+        }
+
+
+
+    }
+
+    grouping ofp_table_feature_prop_experimenter {
+        description
+            "Experimenter table feature property";
+        leaf experimenter {
+            type  uint32;
+            description
+                "One of OFPTFPT_EXPERIMENTER,
+OFPTFPT_EXPERIMENTER_MISS.Experimenter ID which takes the same
+form as in struct
+ofp_experimenter_header.";
+        }
+
+        leaf exp_type {
+            type  uint32;
+            description
+                "Experimenter defined.";
+        }
+
+        list experimenter_data {
+            key "experimenter_data";
+            leaf experimenter_data {
+                type  uint32;
+                description
+                    "";
+            }
+            description
+                "";
+        }
+
+
+
+    }
+
+    container ofp_table_features {
+        description
+            "Body for ofp_multipart_request of type OFPMP_TABLE_FEATURES.
+ Body of reply to OFPMP_TABLE_FEATURES request.";
+        leaf table_id {
+            type  uint32;
+            description
+                "Identifier of table.  Lower numbered tables
+are consulted first.";
+        }
+
+        leaf name {
+            type  string;
+            description
+                "";
+        }
+
+        leaf metadata_match {
+            type  uint64;
+            description
+                "Bits of metadata table can match.";
+        }
+
+        leaf metadata_write {
+            type  uint64;
+            description
+                "Bits of metadata table can write.";
+        }
+
+        leaf config {
+            type  uint32;
+            description
+                "Bitmap of OFPTC_  values";
+        }
+
+        leaf max_entries {
+            type  uint32;
+            description
+                "Max number of entries supported.";
+        }
+
+        list properties {
+            key "type";
+            uses  ofp_table_feature_property;
+
+            description
+                "Table Feature Property list";
+        }
+
+
+
+    }
+
+    container ofp_table_stats {
+        description
+            "Body of reply to OFPMP_TABLE request.";
+        leaf table_id {
+            type  uint32;
+            description
+                "Identifier of table.  Lower numbered tables
+are consulted first.";
+        }
+
+        leaf active_count {
+            type  uint32;
+            description
+                "Number of active entries.";
+        }
+
+        leaf lookup_count {
+            type  uint64;
+            description
+                "Number of packets looked up in table.";
+        }
+
+        leaf matched_count {
+            type  uint64;
+            description
+                "Number of packets that hit table.";
+        }
+
+
+
+    }
+
+    container ofp_port_stats_request {
+        description
+            "Body for ofp_multipart_request of type OFPMP_PORT.";
+        leaf port_no {
+            type  uint32;
+            description
+                "OFPMP_PORT message must request statistics
+ either for a single port (specified in
+ port_no) or for all ports (if port_no ==
+ OFPP_ANY).";
+        }
+
+
+
+    }
+
+    container ofp_port_stats {
+        description
+            "Body of reply to OFPMP_PORT request. If a counter is unsupported, set
+ the field to all ones.";
+        leaf port_no {
+            type  uint32;
+            description
+                "";
+        }
+
+        leaf rx_packets {
+            type  uint64;
+            description
+                "Number of received packets.";
+        }
+
+        leaf tx_packets {
+            type  uint64;
+            description
+                "Number of transmitted packets.";
+        }
+
+        leaf rx_bytes {
+            type  uint64;
+            description
+                "Number of received bytes.";
+        }
+
+        leaf tx_bytes {
+            type  uint64;
+            description
+                "Number of transmitted bytes.";
+        }
+
+        leaf rx_dropped {
+            type  uint64;
+            description
+                "Number of packets dropped by RX.";
+        }
+
+        leaf tx_dropped {
+            type  uint64;
+            description
+                "Number of packets dropped by TX.";
+        }
+
+        leaf rx_errors {
+            type  uint64;
+            description
+                "Number of receive errors.  This is a super-set
+of more specific receive errors and should be
+greater than or equal to the sum of all
+rx_ _err values.";
+        }
+
+        leaf tx_errors {
+            type  uint64;
+            description
+                "Number of transmit errors.  This is a super-set
+of more specific transmit errors and should be
+greater than or equal to the sum of all
+tx_ _err values (none currently defined.)";
+        }
+
+        leaf rx_frame_err {
+            type  uint64;
+            description
+                "Number of frame alignment errors.";
+        }
+
+        leaf rx_over_err {
+            type  uint64;
+            description
+                "Number of packets with RX overrun.";
+        }
+
+        leaf rx_crc_err {
+            type  uint64;
+            description
+                "Number of CRC errors.";
+        }
+
+        leaf collisions {
+            type  uint64;
+            description
+                "Number of collisions.";
+        }
+
+        leaf duration_sec {
+            type  uint32;
+            description
+                "Time port has been alive in seconds.";
+        }
+
+        leaf duration_nsec {
+            type  uint32;
+            description
+                "Time port has been alive in nanoseconds
+beyond duration_sec.";
+        }
+
+
+
+    }
+
+    container ofp_group_stats_request {
+        description
+            "Body of OFPMP_GROUP request.";
+        leaf group_id {
+            type  uint32;
+            description
+                "All groups if OFPG_ALL.";
+        }
+
+
+
+    }
+
+    grouping ofp_bucket_counter {
+        description
+            "Used in group stats replies.";
+        leaf packet_count {
+            type  uint64;
+            description
+                "Number of packets processed by bucket.";
+        }
+
+        leaf byte_count {
+            type  uint64;
+            description
+                "Number of bytes processed by bucket.";
+        }
+
+
+
+    }
+
+    grouping ofp_group_stats {
+        description
+            "Body of reply to OFPMP_GROUP request.";
+        leaf group_id {
+            type  uint32;
+            description
+                "Group identifier.";
+        }
+
+        leaf ref_count {
+            type  uint32;
+            description
+                "Number of flows or groups that directly
+forward to this group.";
+        }
+
+        leaf packet_count {
+            type  uint64;
+            description
+                "Number of packets processed by group.";
+        }
+
+        leaf byte_count {
+            type  uint64;
+            description
+                "Number of bytes processed by group.";
+        }
+
+        leaf duration_sec {
+            type  uint32;
+            description
+                "Time group has been alive in seconds.";
+        }
+
+        leaf duration_nsec {
+            type  uint32;
+            description
+                "Time group has been alive in nanoseconds
+beyond duration_sec.";
+        }
+
+        list bucket_stats {
+            key "packet_count";
+            uses  ofp_bucket_counter;
+
+            description
+                "One counter set per
+bucket.";
+        }
+
+
+
+    }
+
+    grouping ofp_group_desc {
+        description
+            "Body of reply to OFPMP_GROUP_DESC request.";
+        leaf type {
+            type  ofp_group_type;
+
+            description
+                "One of OFPGT_ .";
+        }
+
+        leaf group_id {
+            type  uint32;
+            description
+                "Group identifier.";
+        }
+
+        list buckets {
+            key "weight";
+            uses  ofp_bucket;
+
+            description
+                "List of buckets - 0 or more.";
+        }
+
+
+
+    }
+
+    grouping ofp_group_entry {
+        description
+            "";
+        leaf type {
+            type  ofp_group_type;
+
+            description
+                "One of OFPGT_ .";
+        }
+
+        leaf group_id {
+            type  uint32;
+            description
+                "Group identifier.";
+        }
+
+        list buckets {
+            key "weight";
+            uses  ofp_bucket;
+
+            description
+                "List of buckets - 0 or more.";
+        }
+
+        container stats {
+            uses  ofp_group_stats;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    container ofp_group_features {
+        description
+            "Body of reply to OFPMP_GROUP_FEATURES request. Group features.";
+        leaf types {
+            type  uint32;
+            description
+                "Bitmap of (1    OFPGT_ ) values supported.";
+        }
+
+        leaf capabilities {
+            type  uint32;
+            description
+                "Bitmap of OFPGFC_  capability supported.";
+        }
+
+        list max_groups {
+            key "max_groups";
+            leaf max_groups {
+                type  uint32;
+                description
+                    "Maximum number of groups for each type.";
+            }
+            description
+                "Maximum number of groups for each type.";
+        }
+
+        list actions {
+            key "actions";
+            leaf actions {
+                type  uint32;
+                description
+                    "Bitmaps of (1    OFPAT_ ) values
+supported.";
+            }
+            description
+                "Bitmaps of (1    OFPAT_ ) values
+supported.";
+        }
+
+
+
+    }
+
+    container ofp_meter_multipart_request {
+        description
+            "Body of OFPMP_METER and OFPMP_METER_CONFIG requests.";
+        leaf meter_id {
+            type  uint32;
+            description
+                "Meter instance, or OFPM_ALL.";
+        }
+
+
+
+    }
+
+    grouping ofp_meter_band_stats {
+        description
+            "Statistics for each meter band";
+        leaf packet_band_count {
+            type  uint64;
+            description
+                "Number of packets in band.";
+        }
+
+        leaf byte_band_count {
+            type  uint64;
+            description
+                "Number of bytes in band.";
+        }
+
+
+
+    }
+
+    container ofp_meter_stats {
+        description
+            "Body of reply to OFPMP_METER request. Meter statistics.";
+        leaf meter_id {
+            type  uint32;
+            description
+                "Meter instance.";
+        }
+
+        leaf flow_count {
+            type  uint32;
+            description
+                "Number of flows bound to meter.";
+        }
+
+        leaf packet_in_count {
+            type  uint64;
+            description
+                "Number of packets in input.";
+        }
+
+        leaf byte_in_count {
+            type  uint64;
+            description
+                "Number of bytes in input.";
+        }
+
+        leaf duration_sec {
+            type  uint32;
+            description
+                "Time meter has been alive in seconds.";
+        }
+
+        leaf duration_nsec {
+            type  uint32;
+            description
+                "Time meter has been alive in nanoseconds
+beyond duration_sec.";
+        }
+
+        list band_stats {
+            key "packet_band_count";
+            uses  ofp_meter_band_stats;
+
+            description
+                "The band_stats length is
+inferred from the length field.";
+        }
+
+
+
+    }
+
+    container ofp_meter_config {
+        description
+            "Body of reply to OFPMP_METER_CONFIG request. Meter configuration.";
+        leaf flags {
+            type  uint32;
+            description
+                "All OFPMF_  that apply.";
+        }
+
+        leaf meter_id {
+            type  uint32;
+            description
+                "Meter instance.";
+        }
+
+        list bands {
+            key "type";
+            uses  ofp_meter_band_header;
+
+            description
+                "The bands length is
+inferred from the length field.";
+        }
+
+
+
+    }
+
+    container ofp_meter_features {
+        description
+            "Body of reply to OFPMP_METER_FEATURES request. Meter features.";
+        leaf max_meter {
+            type  uint32;
+            description
+                "Maximum number of meters.";
+        }
+
+        leaf band_types {
+            type  uint32;
+            description
+                "Bitmaps of (1    OFPMBT_ ) values supported.";
+        }
+
+        leaf capabilities {
+            type  uint32;
+            description
+                "Bitmaps of  ofp_meter_flags .";
+        }
+
+        leaf max_bands {
+            type  uint32;
+            description
+                "Maximum bands per meters";
+        }
+
+        leaf max_color {
+            type  uint32;
+            description
+                "Maximum color value";
+        }
+
+
+
+    }
+
+    container ofp_experimenter_multipart_header {
+        description
+            "Body for ofp_multipart_request reply of type OFPMP_EXPERIMENTER.";
+        leaf experimenter {
+            type  uint32;
+            description
+                "Experimenter ID which takes the same form
+as in struct ofp_experimenter_header.";
+        }
+
+        leaf exp_type {
+            type  uint32;
+            description
+                "Experimenter defined.";
+        }
+
+        leaf data {
+            type  binary;
+            description
+                "Experimenter-defined arbitrary additional data.";
+        }
+
+
+
+    }
+
+    container ofp_experimenter_header {
+        description
+            "Experimenter extension.";
+        leaf experimenter {
+            type  uint32;
+            description
+                "ofp_header header;     Type OFPT_EXPERIMENTER.
+Experimenter ID:
+ - MSB 0: low-order bytes are IEEE OUI.
+ - MSB != 0: defined by ONF.";
+        }
+
+        leaf exp_type {
+            type  uint32;
+            description
+                "Experimenter defined.";
+        }
+
+        leaf data {
+            type  binary;
+            description
+                "Experimenter-defined arbitrary additional data.";
+        }
+
+
+
+    }
+
+    grouping ofp_queue_prop_header {
+        description
+            "Common description for a queue.";
+        leaf property {
+            type  uint32;
+            description
+                "One of OFPQT_.";
+        }
+
+        leaf len {
+            type  uint32;
+            description
+                "Length of property, including this header.";
+        }
+
+
+
+    }
+
+    container ofp_queue_prop_min_rate {
+        description
+            "Min-Rate queue property description.";
+        container prop_header {
+            uses  ofp_queue_prop_header;
+
+            description
+                "prop: OFPQT_MIN, len: 16.";
+        }
+
+        leaf rate {
+            type  uint32;
+            description
+                "In 1 10 of a percent = 0; 1000 -  disabled.";
+        }
+
+
+
+    }
+
+    container ofp_queue_prop_max_rate {
+        description
+            "Max-Rate queue property description.";
+        container prop_header {
+            uses  ofp_queue_prop_header;
+
+            description
+                "prop: OFPQT_MAX, len: 16.";
+        }
+
+        leaf rate {
+            type  uint32;
+            description
+                "In 1 10 of a percent = 0; 1000 -  disabled.";
+        }
+
+
+
+    }
+
+    container ofp_queue_prop_experimenter {
+        description
+            "Experimenter queue property description.";
+        container prop_header {
+            uses  ofp_queue_prop_header;
+
+            description
+                "prop: OFPQT_EXPERIMENTER";
+        }
+
+        leaf experimenter {
+            type  uint32;
+            description
+                "Experimenter ID which takes the same
+form as in struct
+ofp_experimenter_header.";
+        }
+
+        leaf data {
+            type  binary;
+            description
+                "Experimenter defined data.";
+        }
+
+
+
+    }
+
+    grouping ofp_packet_queue {
+        description
+            "Full description for a queue.";
+        leaf queue_id {
+            type  uint32;
+            description
+                "id for the specific queue.";
+        }
+
+        leaf port {
+            type  uint32;
+            description
+                "Port this queue is attached to.";
+        }
+
+        list properties {
+            key "property";
+            uses  ofp_queue_prop_header;
+
+            description
+                "List of properties.";
+        }
+
+
+
+    }
+
+    container ofp_queue_get_config_request {
+        description
+            "Query for port queue configuration.";
+        leaf port {
+            type  uint32;
+            description
+                "ofp_header header;
+Port to be queried. Should refer
+to a valid physical port (i.e.  = OFPP_MAX),
+or OFPP_ANY to request all configured
+queues.";
+        }
+
+
+
+    }
+
+    container ofp_queue_get_config_reply {
+        description
+            "Queue configuration for a given port.";
+        leaf port {
+            type  uint32;
+            description
+                "ofp_header header;";
+        }
+
+        list queues {
+            key "queue_id";
+            uses  ofp_packet_queue;
+
+            description
+                "List of configured queues.";
+        }
+
+
+
+    }
+
+    container ofp_action_set_queue {
+        description
+            "OFPAT_SET_QUEUE action struct: send packets to given queue on port.";
+        leaf type {
+            type  uint32;
+            description
+                "OFPAT_SET_QUEUE.";
+        }
+
+        leaf queue_id {
+            type  uint32;
+            description
+                "Queue id for the packets.";
+        }
+
+
+
+    }
+
+    container ofp_queue_stats_request {
+        description
+            "";
+        leaf port_no {
+            type  uint32;
+            description
+                "All ports if OFPP_ANY.";
+        }
+
+        leaf queue_id {
+            type  uint32;
+            description
+                "All queues if OFPQ_ALL.";
+        }
+
+
+
+    }
+
+    container ofp_queue_stats {
+        description
+            "";
+        leaf port_no {
+            type  uint32;
+            description
+                "";
+        }
+
+        leaf queue_id {
+            type  uint32;
+            description
+                "Queue i.d";
+        }
+
+        leaf tx_bytes {
+            type  uint64;
+            description
+                "Number of transmitted bytes.";
+        }
+
+        leaf tx_packets {
+            type  uint64;
+            description
+                "Number of transmitted packets.";
+        }
+
+        leaf tx_errors {
+            type  uint64;
+            description
+                "Number of packets dropped due to overrun.";
+        }
+
+        leaf duration_sec {
+            type  uint32;
+            description
+                "Time queue has been alive in seconds.";
+        }
+
+        leaf duration_nsec {
+            type  uint32;
+            description
+                "Time queue has been alive in nanoseconds
+beyond duration_sec.";
+        }
+
+
+
+    }
+
+    container ofp_role_request {
+        description
+            "Role request and reply message.";
+        leaf role {
+            type  ofp_controller_role;
+
+            description
+                "ofp_header header;           Type OFPT_ROLE_REQUEST OFPT_ROLE_REPLY.
+One of OFPCR_ROLE_ .";
+        }
+
+        leaf generation_id {
+            type  uint64;
+            description
+                "Master Election Generation Id";
+        }
+
+
+
+    }
+
+    container ofp_async_config {
+        description
+            "Asynchronous message configuration.";
+        list packet_in_mask {
+            key "packet_in_mask";
+            leaf packet_in_mask {
+                type  uint32;
+                description
+                    "ofp_header header;       OFPT_GET_ASYNC_REPLY or OFPT_SET_ASYNC.
+Bitmasks of OFPR_  values.";
+            }
+            description
+                "ofp_header header;       OFPT_GET_ASYNC_REPLY or OFPT_SET_ASYNC.
+Bitmasks of OFPR_  values.";
+        }
+
+        list port_status_mask {
+            key "port_status_mask";
+            leaf port_status_mask {
+                type  uint32;
+                description
+                    "Bitmasks of OFPPR_  values.";
+            }
+            description
+                "Bitmasks of OFPPR_  values.";
+        }
+
+        list flow_removed_mask {
+            key "flow_removed_mask";
+            leaf flow_removed_mask {
+                type  uint32;
+                description
+                    "Bitmasks of OFPRR_  values.";
+            }
+            description
+                "Bitmasks of OFPRR_  values.";
+        }
+
+
+
+    }
+
+    grouping FlowTableUpdate {
+        description
+            "ADDITIONAL VOLTHA SPECIFIC MESSAGE TYPES, AIDING RPC CALLS";
+        leaf id {
+            type  string;
+            description
+                "Device.id or LogicalDevice.id";
+        }
+
+        container flow_mod {
+            uses  ofp_flow_mod;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping FlowGroupTableUpdate {
+        description
+            "";
+        leaf id {
+            type  string;
+            description
+                "Device.id or LogicalDevice.id";
+        }
+
+        container group_mod {
+            uses  ofp_group_mod;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping Flows {
+        description
+            "";
+        list items {
+            key "id";
+            uses  ofp_flow_stats;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping FlowGroups {
+        description
+            "";
+        list items {
+            key "type";
+            uses  ofp_group_entry;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping PacketIn {
+        description
+            "";
+        leaf id {
+            type  string;
+            description
+                "LogicalDevice.id";
+        }
+
+        container packet_in {
+            uses  ofp_packet_in;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping PacketOut {
+        description
+            "";
+        leaf id {
+            type  string;
+            description
+                "LogicalDevice.id";
+        }
+
+        container packet_out {
+            uses  ofp_packet_out;
+
+            description
+                "";
+        }
+
+
+
+    }
+
+    grouping ChangeEvent {
+        description
+            "";
+        leaf id {
+            type  string;
+            description
+                "LogicalDevice.id";
+        }
+
+
+
+        choice choice_0 {
+            case port_status {
+                container port_status {
+                    uses  ofp_port_status;
+
+                    description
+                        "";
+                }
+            }
+        }
+
+
+    }
+
+
+    /*  Health related services" */
+    rpc HealthService-GetHealthStatus {
+        description
+            "Return current health status of a Voltha instance";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  HealthStatus;
+
+        }
+    }
+
+    /*  Cluster-wide Voltha APIs
+
+ These APIs are potentially dispatched to the leader of the Voltha cluster,
+ to a specific Voltha instance which owns the given device or logical device." */
+    rpc VolthaGlobalService-GetVoltha {
+        description
+            "Get high level information on the Voltha cluster";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  Voltha_grouping; 
+        }
+    }
+
+    rpc VolthaGlobalService-ListVolthaInstances {
+        description
+            "List all Voltha cluster instances";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  VolthaInstances_grouping; 
+        }
+    }
+
+    rpc VolthaGlobalService-GetVolthaInstance {
+        description
+            "Get details on a Voltha cluster instance";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  VolthaInstance_grouping; 
+        }
+    }
+
+    rpc VolthaGlobalService-ListLogicalDevices {
+        description
+            "List all logical devices managed by the Voltha cluster";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  LogicalDevices;
+
+        }
+    }
+
+    rpc VolthaGlobalService-GetLogicalDevice {
+        description
+            "Get additional information on a given logical device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  LogicalDevice;
+
+        }
+    }
+
+    rpc VolthaGlobalService-ListLogicalDevicePorts {
+        description
+            "List ports of a logical device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  LogicalPorts;
+
+        }
+    }
+
+    rpc VolthaGlobalService-ListLogicalDeviceFlows {
+        description
+            "List all flows of a logical device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Flows;
+
+        }
+    }
+
+    rpc VolthaGlobalService-UpdateLogicalDeviceFlowTable {
+        description
+            "Update flow table for logical device";
+        input {
+            uses  FlowTableUpdate;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaGlobalService-ListLogicalDeviceFlowGroups {
+        description
+            "List all flow groups of a logical device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  FlowGroups;
+
+        }
+    }
+
+    rpc VolthaGlobalService-UpdateLogicalDeviceFlowGroupTable {
+        description
+            "Update group table for device";
+        input {
+            uses  FlowGroupTableUpdate;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaGlobalService-ListDevices {
+        description
+            "List all physical devices controlled by the Voltha cluster";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  Devices;
+
+        }
+    }
+
+    rpc VolthaGlobalService-GetDevice {
+        description
+            "Get more information on a given physical device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Device;
+
+        }
+    }
+
+    rpc VolthaGlobalService-CreateDevice {
+        description
+            "Pre-provision a new physical device";
+        input {
+            uses  Device;
+
+        }
+        output {
+            uses  Device;
+
+        }
+    }
+
+    rpc VolthaGlobalService-EnableDevice {
+        description
+            "Enable a device.  If the device was in pre-provisioned state then it
+ will tansition to ENABLED state.  If it was is DISABLED state then it
+ will tansition to ENABLED state as well.";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaGlobalService-DisableDevice {
+        description
+            "Disable a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaGlobalService-RebootDevice {
+        description
+            "Reboot a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaGlobalService-DeleteDevice {
+        description
+            "Delete a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaGlobalService-ListDevicePorts {
+        description
+            "List ports of a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Ports;
+
+        }
+    }
+
+    rpc VolthaGlobalService-ListDevicePmConfigs {
+        description
+            "List pm config of a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  PmConfigs;
+
+        }
+    }
+
+    rpc VolthaGlobalService-UpdateDevicePmConfigs {
+        description
+            "Update the pm config of a device";
+        input {
+            uses  PmConfigs;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaGlobalService-ListDeviceFlows {
+        description
+            "List all flows of a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Flows;
+
+        }
+    }
+
+    rpc VolthaGlobalService-ListDeviceFlowGroups {
+        description
+            "List all flow groups of a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  FlowGroups;
+
+        }
+    }
+
+    rpc VolthaGlobalService-ListDeviceTypes {
+        description
+            "List device types known to Voltha";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  DeviceTypes;
+
+        }
+    }
+
+    rpc VolthaGlobalService-GetDeviceType {
+        description
+            "Get additional information on a device type";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  DeviceType;
+
+        }
+    }
+
+    rpc VolthaGlobalService-ListDeviceGroups {
+        description
+            "List all device sharding groups";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  DeviceGroups;
+
+        }
+    }
+
+    rpc VolthaGlobalService-GetDeviceGroup {
+        description
+            "Get additional information on a device group";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  DeviceGroup;
+
+        }
+    }
+
+    rpc VolthaGlobalService-CreateAlarmFilter {
+        description
+            "";
+        input {
+            uses  AlarmFilter;
+
+        }
+        output {
+            uses  AlarmFilter;
+
+        }
+    }
+
+    rpc VolthaGlobalService-GetAlarmFilter {
+        description
+            "";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  AlarmFilter;
+
+        }
+    }
+
+    rpc VolthaGlobalService-UpdateAlarmFilter {
+        description
+            "";
+        input {
+            uses  AlarmFilter;
+
+        }
+        output {
+            uses  AlarmFilter;
+
+        }
+    }
+
+    rpc VolthaGlobalService-DeleteAlarmFilter {
+        description
+            "";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaGlobalService-ListAlarmFilters {
+        description
+            "";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  AlarmFilters;
+
+        }
+    }
+
+
+    /*  Per-instance APIs
+
+ These APIs are always served locally by the Voltha instance on which the
+ call is made." */
+    rpc VolthaLocalService-GetVolthaInstance {
+        description
+            "Get information on this Voltha instance";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  VolthaInstance_grouping; 
+        }
+    }
+
+    rpc VolthaLocalService-GetHealth {
+        description
+            "Get the health state of the Voltha instance";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  HealthStatus;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListAdapters {
+        description
+            "List all active adapters (plugins) in this Voltha instance";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  Adapters;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListLogicalDevices {
+        description
+            "List all logical devices managed by this Voltha instance";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  LogicalDevices;
+
+        }
+    }
+
+    rpc VolthaLocalService-GetLogicalDevice {
+        description
+            "Get additional information on given logical device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  LogicalDevice;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListLogicalDevicePorts {
+        description
+            "List ports of a logical device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  LogicalPorts;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListLogicalDeviceFlows {
+        description
+            "List all flows of a logical device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Flows;
+
+        }
+    }
+
+    rpc VolthaLocalService-UpdateLogicalDeviceFlowTable {
+        description
+            "Update flow table for logical device";
+        input {
+            uses  FlowTableUpdate;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListLogicalDeviceFlowGroups {
+        description
+            "List all flow groups of a logical device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  FlowGroups;
+
+        }
+    }
+
+    rpc VolthaLocalService-UpdateLogicalDeviceFlowGroupTable {
+        description
+            "Update group table for logical device";
+        input {
+            uses  FlowGroupTableUpdate;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListDevices {
+        description
+            "List all physical devices managed by this Voltha instance";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  Devices;
+
+        }
+    }
+
+    rpc VolthaLocalService-GetDevice {
+        description
+            "Get additional information on this device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Device;
+
+        }
+    }
+
+    rpc VolthaLocalService-CreateDevice {
+        description
+            "Pre-provision a new physical device";
+        input {
+            uses  Device;
+
+        }
+        output {
+            uses  Device;
+
+        }
+    }
+
+    rpc VolthaLocalService-EnableDevice {
+        description
+            "Enable a device.  If the device was in pre-provisioned state then it
+ will tansition to ENABLED state.  If it was is DISABLED state then it
+ will tansition to ENABLED state as well.";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaLocalService-DisableDevice {
+        description
+            "Disable a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaLocalService-RebootDevice {
+        description
+            "Reboot a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaLocalService-DeleteDevice {
+        description
+            "Delete a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListDevicePorts {
+        description
+            "List ports of a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Ports;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListDevicePmConfigs {
+        description
+            "List pm config of a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  PmConfigs;
+
+        }
+    }
+
+    rpc VolthaLocalService-UpdateDevicePmConfigs {
+        description
+            "Update the pm config of a device";
+        input {
+            uses  PmConfigs;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListDeviceFlows {
+        description
+            "List all flows of a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Flows;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListDeviceFlowGroups {
+        description
+            "List all flow groups of a device";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  FlowGroups;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListDeviceTypes {
+        description
+            "List device types know to Voltha instance";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  DeviceTypes;
+
+        }
+    }
+
+    rpc VolthaLocalService-GetDeviceType {
+        description
+            "Get additional information on given device type";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  DeviceType;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListDeviceGroups {
+        description
+            "List device sharding groups managed by this Voltha instance";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  DeviceGroups;
+
+        }
+    }
+
+    rpc VolthaLocalService-GetDeviceGroup {
+        description
+            "Get more information on given device shard";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  DeviceGroup;
+
+        }
+    }
+
+    rpc VolthaLocalService-StreamPacketsOut {
+        description
+            "Stream control packets to the dataplane
+This does not have an HTTP representation";
+        input {
+            uses  PacketOut;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaLocalService-ReceivePacketsIn {
+        description
+            "Receive control packet stream
+This does not have an HTTP representation";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  PacketIn;
+
+        }
+    }
+
+    rpc VolthaLocalService-ReceiveChangeEvents {
+        description
+            "This does not have an HTTP representation";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  ChangeEvent;
+
+        }
+    }
+
+    rpc VolthaLocalService-CreateAlarmFilter {
+        description
+            "";
+        input {
+            uses  AlarmFilter;
+
+        }
+        output {
+            uses  AlarmFilter;
+
+        }
+    }
+
+    rpc VolthaLocalService-GetAlarmFilter {
+        description
+            "";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  AlarmFilter;
+
+        }
+    }
+
+    rpc VolthaLocalService-UpdateAlarmFilter {
+        description
+            "";
+        input {
+            uses  AlarmFilter;
+
+        }
+        output {
+            uses  AlarmFilter;
+
+        }
+    }
+
+    rpc VolthaLocalService-DeleteAlarmFilter {
+        description
+            "";
+        input {
+            uses  ID;
+
+        }
+        output {
+            uses  Empty;
+
+        }
+    }
+
+    rpc VolthaLocalService-ListAlarmFilters {
+        description
+            "";
+        input {
+            uses  Empty;
+
+        }
+        output {
+            uses  AlarmFilters;
+
+        }
+    }
+
+
+}