Netopeer NETCONF server integration
Amendments:
- Removed local copy of golang package. Added instructions to download it.
- Removed cached files which are created when transapi is built.
- Added netopeer as a build-able Makefile component.
Updated documentation.
Change-Id: I532e813b81a0531648c5a6bcb048208700cf57a4
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(&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) & 0x7f)
+#define OXM_TYPE(HEADER) (((HEADER) 9) & 0x7fffff)
+#define OXM_HASMASK(HEADER) (((HEADER) 8) & 1)
+#define OXM_LENGTH(HEADER) ((HEADER) & 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;
+
+ }
+ }
+
+
+}