Internet Engineering Task Force E.H. Haleplidis
Internet-Draft University of Patras
Intended status: Informational O.C. Cherkaoui
Expires: April 19, 2013 University of Quebec in Montreal
S.H. Hares
Huawei
W.M.W. Wang
Zhejiang Gongshang University
October 18, 2012

Forwarding and Control Element Separation (ForCES) OpenFlow Model Library
draft-haleplidis-forces-openflow-lib-00

Abstract

This document describes the OpenFlow switch in Logical Function Blocks (LFBs) used in the Forwarding and Control Element Separation (ForCES). The LFB classes are defined according to the ForCES Forwading Element (FE) model and ForCES protocol specifications. The library includes the descriptions of the OpenFlow LFBs and the XML definitions.

Status of This Memo

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

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

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on April 19, 2013.

Copyright Notice

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

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

Table of Contents

1. Introduction

The purpose of this document is to create a library of Logical Functional Blocks that are necessary to describe an OpenFlow switch using the ForCES model. This includes DataTypes, MetaData and of course the LFBs.

Readers of this document can get a better understanding of what are the internal parts of an OpenFlow switch in a more formal approach. Additionally having a ForCES-defined OpenFlow switch developers can build a middleware so that a ForCES-implemented OpenFlow switch may be controlled by an OpenFlow controller, or a ForCES Control Element (CE) may control an OpenFlow switch.

1.1. ForCES

ForCES [RFC3746], focuses on the communication and model necessary to separate control-plane functionality such as routing protocols, signaling protocols, and admission control, from data-forwarding-plane per-packet activities, such as packet forwarding, queuing, and header editing.

The modeling of FEs is based on an abstraction using distinct Logical Functional Blocks (LFBs), which are interconnected in a directed graph, and receive, process, modify, and transmit packets along with metadata. An LFB is a block of encapsulated fine-grained operation of the forwarding plane. The ForCES model [RFC5812] additionally includes both a capability and a state model. One of the advantages of the ForCES Model is that it is independent of the actual implementation of the FE; it only provides a view of its capabilities and state that can be acted upon using the ForCES protocol. It is left to the forwarding plane developers to define how the FE functionality is represented using the model.

The ForCES protocol [RFC5810] was developed to allow the CEs to determine the capabilities of each FE expressed by the FE model, to add and remove entries, parameters, query for statistics, and register for and receive events in a scalable fashion over secure and reliable means. The strength of the ForCES protocol stems from the fact that it is agnostic of the model, as a CE can control any Forwarding Element described with the ForCES model.

1.2. OpenFlow

OpenFlow [OpenFlowSpec1.1] is conceptually similar to ForCES on separating the control and forwarding plane. It provides a protocol that mediates between the controller and the switch. Unlike ForCES, the OpenFlow switch is statically defined to deal with flows and the protocol is aware of the flow components. An OpenFlow Switch consists of one or more flow tables, a group table that performs packet lookups and forwarding, and an OpenFlow channel to an external controller. A flow table is consisted of flow entries, each containing a set of match fields to match against packets, counters and instructions. The controller manages the switch via the OpenFlow protocol. Using this protocol, the controller can add, update, and delete flow entries.

2. Terminology and Conventions

2.1. Requirements Language

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC2119].

2.2. Definitions

This document follows the terminology defined by ForCES related documents of RFC3654, RFC3746, RFC5810,RFC5811,RFC5812,RFC5812. The definitions are repeated below for clarity. Also additional definitions from the OpenFlow specification 1.1 [OpenFlowSpec1.1] are also included.

Control Element (CE) - A logical entity that implements the ForCES protocol and uses it to instruct one or more FEs on how to process packets. CEs handle functionality such as the execution of control and signaling protocols.
Forwarding Element (FE) - A logical entity that implements the ForCES protocol. FEs use the underlying hardware to provide per-packet processing and handling as directed/controlled by one or more CEs via the ForCES protocol.
LFB (Logical Functional Block) - The basic building block that is operated on by the ForCES protocol. The LFB is a well defined, logically separable functional block that resides in an FE and is controlled by the CE via the ForCES protocol. The LFB may reside at the FE's datapath and process packets or may be purely an FE control or configuration entity that is operated on by the CE. Note that the LFB is a functionally accurate abstraction of the FE's processing capabilities, but not a hardware-accurate representation of the FE implementation.
LFB Class and LFB Instance - LFBs are categorized by LFB Classes. An LFB Instance represents an LFB Class (or Type) existence. There may be multiple instances of the same LFB Class (or Type) in an FE. An LFB Class is represented by an LFB Class ID, and an LFB Instance is represented by an LFB Instance ID. As a result, an LFB Class ID associated with an LFB Instance ID uniquely specifies an LFB existence.
LFB Metadata - Metadata is used to communicate per-packet state from one LFB to another, but is not sent across the network. The FE model defines how such metadata is identified, produced, and consumed by the LFBs. It defines the functionality but not how metadata is encoded within an implementation.
LFB Components - Operational parameters of the LFBs that must be visible to the CEs are conceptualized in the FE model as the LFB components. The LFB components include, for example, flags, single-parameter arguments, complex arguments, and tables that the CE can read and/or write via the ForCES protocol (see below).
ForCES Protocol - While there may be multiple protocols used within the overall ForCES architecture, the term "ForCES protocol" and "protocol" refer to the "Fp" reference points in the ForCES framework in [RFC3746]. This protocol does not apply to CE-to-CE communication, FE-to-FE communication, or to communication between FE and CE managers. Basically, the ForCES protocol works in a master-slave mode in which FEs are slaves and CEs are masters.
ForCES Protocol Transport Mapping Layer (ForCES TML) - A layer in ForCES protocol architecture that uses the capabilities of existing transport protocols to specifically address protocol message transportation issues, such as how the protocol messages are mapped to different transport media (like TCP, IP, ATM, Ethernet, etc.), and how to achieve and implement reliability, multicast, ordering, etc. The ForCES TML specifications are detailed in separate ForCES documents, one for each TML.
OpenFlow pipeline - the set of linked flow tables that provide matching, forwarding, and packet modifications in an OpenFlow switch.
Match Field - a field against which a packet is matched, including packet headers, the ingress port, and the metadata value.
Instruction - an operation that either contains a set of actions to add to the action set, contains a list of actions to apply immediately to the packet, or modifies pipeline processing.
Action - an operation that forwards the packet to a port or modifies the packet, such as decrementing the TTL field. Actions may be specified as part of the instruction set associated with a flow entry or in an action bucket associated with a group entry.
Action Set - a set of actions associated with the packet that are accumulated while the packet is processed by each table and that are executed when the instruction set instructs the packet to exit the processing pipeline.
Action Bucket - a set of actions and associated parameters, defined for groups.
Group - a list of action buckets and some means of choosing one or more of those buckets to apply on a per-packet basis.

3. OpenFlow ForCES library

3.1. OpenFlow Specification

An OpenFlow switch as described in the OpenFlow Specification document [OpenFlowSpec1.1] appears in Figure 1 

+---------+                +---------+                   +---------+
|         |                |         |                   |         |
|  Port   |                |  Group  |                   |  Port   |
|         |                |  Table  |                   |         |
+---------+                +---------+                   +---------+
     | M1: Ingress Port                                       /\
     | M2: Action Set{}                                       |
     \/                                                       |
+---------+      +---------+            +---------+      +---------+
|         | M1   |         | M1         |         | M2   | Execute |
|  Flow   | ---> |  Flow   | -->...---> |  Flow   | ---> |  Action |
| Table 0 | M2   | Table 1 | M2         | Table N |      |   Set   |
+---------+ M3   +---------+ M3         +---------+      +---------+

Figure 1: OpenFlow switch datapath

A frame enters the switch through a Port and is passed on the first Flow Table along with the Ingress Port as a Metadata (M1). Additionally each frame carries around a list of actions, called Action Set (M2), which have initially no actions in it. The Action Set will be executed at the end of the DataPath. After the first Flow Table another metadata called Metadata (M3) also accompanies the frame. This data inside the metadata is written by the Flow Tables using the Write Metadata action.

Each Flow Table performs a match based on certain fields (e.g IP Source Address or Source MAC Address) and then perform a specific instruction if there is a match. If no match occurs, the frame is processed based on the Flow Table's configuration. The choices are either:

  1. Forward to the OpenFlow controllers
  2. Send to the next flow table
  3. Drop the frame

The list of actions a Flow Table may perform upon a match are:

The Goto Flow table allows a FlowTable X to send the packet and metadata to any FlowTable Y, provided that X>Y

The list of actions the Flow Table can perform or write in the Action Set is:

An Action Set contains a maximum of one action of each of the following types which MUST be executed in the order specified below regardless of the order they were added to the Action Set. The output action in the action set is executed last. If both an output action and a group action are specified in an action set, the output action is ignored and the group action takes precedence. If no output action and no group action were specified in an action set, the packet is dropped.

  1. Copy TTL outwards
  2. Pop a tag
  3. Push a tags
  4. Copy TTL outwards
  5. Decrease TTL
  6. Setting of a field
  7. Apply QoS to a packet
  8. Apply the packet to a group
  9. Output the packet

The Group Table contains a set of actions, called action buckets which can be applied to a group of packets that don't have the same set of matching fields. This alleviates the problem of having to set up the same set of actions in flow tables for different set of matching fields by having these set of actions in one place only.

3.2. ForCES-based OpenFlow Specification

ForCES models FEs using LFBs, fine-grained operations of the forwarding plane. It is logical to have at least the following LFB classes:

  1. OFPortLFB
  2. OFFlowTableLFB
  3. OFGroupTableLFB
  4. OFActionSetLFB

However, since the OFFlowTableLFB contains multiple operations like matching and all the probable actions, it seems reasonable to separate each action as a separate LFB that performs that specific action. For each packet, the OFFlowTable will check for a match, and then upon that, decide the appropriate order of action LFB(s) the packet will be sent to. Once the packet has been processed from an Action LFB, it MUST be returned to the OFFlowTableLFB instance that made that call. Each OFFlowTable could have its own set of instances of Action LFBs, or there could be only one or some instances of Action LFBs. Figure 2 depicts how an OFFlowTable with its own set of ActionLFBs look like. Figure 3 depicts how multiple OFFlowTables work with a shared set of ActionLFBs look like. Figure 4 depicts how a OFGroupTableLFB works with a shared set of ActionLFBs.

              FlowTableIndex  FlowTableIndex       
      +------+ ActionIndex    ActionIndex +---------+
      | Push | Packet(2)      Packet(1)   |   Set   |
      | Vlan |<---------+    +----------->|   IP    |
      |Header|          |    |            | Address |
      +------+          |    |            +---------+
         |              |    |                |
         | Packet(3)   +--------+ Packet(2)   |
         +------------>|        |<------------+
                       |        |
---------------------->| OFFlow |---------------------->
   Packet+M1,M2,M3     | Table  | Packet(3)+M1,M2,M3
                       |        |
        FlowTableIndex |        |
  +---------+ <------- |        |
  |Decrement| Packet   |        |
  |  IP TTL |          +--------+
  |         |  Packet(1)   ^
  +---------+ -------------+

Figure 2: ForCES FlowTable with each own set of ActionLFBs

   M4: FlowTableIndex           
   M5: ActionIndex
    P: Packet                   +------+    M5: ActionIndex, P(2)
  +---------------------------->| Push |<--------------------------+
  |    +-----------------------<| Vlan |                           |
  |    |            +---------->|Header|----------------------+    |
  |    |            |  +-------<|      |    Packet(3)         |    |
  |    | P(1)   M4  |  |        +------+                      |    |
  |    |        M5  |  |P(2)                                  |    |
  |    \/       P(1)|  \/                                     \/   |
+---------+ P(1) +---------+ P(2)       +---------+ P(2) +---------+
|         | M1   |         | M1         |         | M2   | Execute |
|  Flow   | ---> |  Flow   | -->...---> |  Flow   | ---> |  Action |
| Table 0 | M2   | Table 1 | M2         | Table N |      |   Set   |
+---------+ M3   +---------+ M3         +---------+      +---------+

Figure 3: Multiple ForCES FlowTables with a common ActionLFB

                  +---------+  P(2), M5
                  | Set IP  |<-----------------+
                  | Address |                  |
                  |         |--------------+   |
                  +---------+  P(3)        |   |
                                           |   | 
   M4: FlowTableIndex                      |   |
   M5: ActionIndex                         \/  |
    P: Packet       +------+  P(1), M5  +---------+
  +---------------->| Push | <--------- |  Group  |
  |    +-----------<| Vlan |            |  Table  |
  |    |            |Header| ---------> |         |
  |    | P(1)       +------+   P(2)     +---------+
  |    |                             P(1) /\   | P(3)
  |    |                   M6: GroupIndex |    |
  |    \/                              M4 |    \/            
+---------+ P(1) +---------+ P(1)       +---------+ P(3) +---------+
|         | M1   |         | M1         |         | M2   | Execute |
|  Flow   | ---> |  Flow   | -->...---> |  Flow   | ---> |  Action |
| Table 0 | M2   | Table 1 | M2         | Table N |      |   Set   |
+---------+ M3   +---------+ M3         +---------+      +---------+

Figure 4: ForCES FlowTables and GroupTable with a common ActionLFB

Current specified Action LFBs are:

Output Actions

  • OFOutputOFActionLFB

Set Queue Actions

  • OFSetQueueOFActionLFB

Push/Pop Tag Actions

  • OFPushVLanOFActionLFB
  • OFPopVLANOFActionLFB
  • OFPushMPLSOFActionLFB
  • OFPopMPLSOFActionLFB

Set Actions

  • OFSetMACSourceOFActionLFB
  • OFSetMACDestinationOFActionLFB
  • OFSetVLANVIDOFActionLFB
  • OFSetVLANPriorityOFActionLFB
  • OFSetMPLSLabelOFActionLFB
  • OFSetMPLSTCOFActionLFB
  • OFSetMPLSTTLOFActionLFB
  • OFDecrementMPLSTTLOFActionLFB
  • OFSetIPSourceOFActionLFB
  • OFSetIPDestinationOFActionLFB
  • OFSetIPTOSOFActionLFB
  • OFSetIPECNOFActionLFB
  • OFSetIPTTLOFActionLFB
  • OFDecrementIPTTLOFActionLFB
  • OFSetTCPSourceOFActionLFB
  • OFSetTCPDestinationOFActionLFB
  • OFCopyTTLOutOFActionLFB
  • OFCopyTTLInOFActionLFB

Experimenter Actions

  • OFExperimenterOFActionLFB

Most Action LFBs have data associated with the action stored in a table. The sender of a packet needs to send additionally an index pointing to the action that needs to be done. Each Action LFB has one group input port that accepts a packet, the instance of the LFB that sent the packet, so that it can be returned after the action has been performed, and optionally the Action Index. Additionally each Action LFB has one group output port that returns the altered packet to the sender. Since the action LFBs have these ports in common and the ForCES model can support augmentation of LFB classes, similar to inheritance in object oriented programming, an OFActionLFB has been specified from which all Action LFBs are derived from.

The Action LFBs can be used by the OFGroupTableLFB as well as the OFActionSetLFB using the same input and output port.

Additionally each OFFlowTable can output a packet to a specific port. This creates a topology of almost full mesh connections for the LFBs. Figure 5 shows an example of a topology and how the various LFBs are interconnected. The topology information can be obtained by the FEObject's LFBTopology.

+--------+     +--------+          +--------+       +--------+
|        |     |        |          |        |       |        |
| OFPort |     | OFPort |          | OFPort |       | OFPort |
|        |     |        |          |        |       |        |
+--------+     +--------+          +--------+       +--------+
    |              |                    |                |        
    |              |                    |                |        
    +--------------+--------------------+----------------+--------+
    |              |                    |                |        |
    |              |                    |                |        |
+--------+     +--------+           +--------+       +--------+   |
|        | --> |        |           |        |       |        |   |
| OFFlow |     | OFFlow |--+---+--> | OFFlow |-+--+->|OFAction|   |
| Table 0|--+  | Table 1|  |   /\   | Table N| /\ /\ |   Set  |   |
+--------+  |  +--------+  |   |    +--------+ |  |  +--------+   |
    |       |       |      |   |        |      |  |       |       |
    |       |       |      +-------------------+  |       |       |
    |       |       |          |        |         |       |       |
    |       +------------------+------------------+       |       |
    |               |                   |                 |       |
    +---------------+--------------+----+--------+--------+---+   |
    |               |              |             |            |   |
+--------+     +--------+     +--------+     +--------+     +-------+
|        |     |        |     |        |     |        |     |       |
|OFAction|     |OFAction|     |OFAction|     |OFAction|     |OFGroup|
|        |     |        |     |        |     |        |     |Table  |
+--------+     +--------+     +--------+     +--------+     +-------+

Figure 5: ForCES OpenFlow Switch example LFB connectivity

4. OpenFlow Base Types

4.1. Data Types

Data types defined in the OpenFlow library are categorized by types of atomic, compound struct, and compound array.

4.1.1. Atomic

The following data types are defined as atomic data types in the OpenFlow library:

OpenFlow Atomic Types
Data Type Name Brief Description
MPLSLabelValue An MPLS label
MPLSTrafficClassValues The MPLS Traffic Class
IPv4ToSbits TOSBits
ActionType The possible actions
InstructionTypes Instructions supported
FlowTableMissConfigType Types to configure the default behavior of unmatched packets
BufferReasonTypes Buffer Reason Types
GroupTypeType To determine group semantics
PortNumberType Port Number values
QueuePropertyType Property type for a queue
ActionSetType The actionset type. 9 possible values.

4.1.2. Compound Struct

The following data types are defined as struct data types in the OpenFlow library:

OpenFlow Struct Types
Data Type Name Brief Description
SwitchDescriptionType Fields of the switch description
WildcardsType Wildcards for fields
MatchFieldType A Match Field Type
FlowEntry A Flow entry
ActionRowType An Action Row for the action table
TableCounterType Counter per table
FlowCounterType Counter per flow
WriteMetadataTableType Metadata and mask for the write metadata instruction per row
GroupCounterType Counters per group
BucketCounterType Counters per bucket
GroupTableEntry A Row of the Group Table
ActionBucket An Action Bucket
PortConfigurationType Types of configuration for the OpenFlow port
PortStateType Current State of the port
PortFeaturesType Port Features
PortCounterType Counter per port
QueueArrayPropertiesType Type Definition for property
QueueCounterType Counters per queue
ActionSetRowType The ActionSet Row Type

4.1.3. Compound Array

The following data types are defined as an array data type in the OpenFlow library

OpenFlow Array Types
Data Type Name Brief Description
Actions Actions to perform. An Array of ActionRowTypes
ActionSetPacket The Action Set per packet

4.2. Frame Types

No frames are specified in the LFB library as the required have already been defined in the Base LFB Library [I-D.ietf-forces-lfb-lib].

4.3. MetaData Types

The following metadata are defined in the OpenFlow type library:

OpenFlow Metadata Types
MetaData Name MetaData ID Brief Description
IngressPort 1024 The Ingress port the packet has arrived from.
ActionSet 1025 The action set that is passed along flow tables. This is an index that points to a row in the ActionSetTable array in the ActionSetLFB
Arbitrary 1026 Arbitrary metadata of uint64
FlowTableInstanceID 1027 uint32
ActionSetIndex 1028 uint32
GroupIndex 1029 uint32
LFBClassIDMetadata 1030 uint32
LFBInstanceIDMetadata 1031 uint32

5. OpenFlow LFBs

5.1. OpenFlowSwitchLFB

Similar to the concept of the FEProtocol LFB and the FEObject LFB, the OpenFlowSwitchLFB contains information and configuration parameters regarding the functionality of the switch but play no role in the datapath processing. Therefore there are no input or output ports.

5.1.1. Data Handling

This LFB does not handle data.

5.1.2. Components

The DatapathID component, a unsigned integer of 64 bits, uniquely identifies a datapath. The lower 48 bits are intended for the switch MAC address, while the top 16 bits are up to the implementer.

The MissSendLen component, an unsigned integer of 16 bits, defines the maximum number of bytes of new flow that datapath should send to the controller.

The HandleFragments component, a Boolean, defines what the switch does with fragments. If true the switch will drop fragments. If false there is no special handling.

The ReassembleFragments component, a Boolean, defines if the switch will reassemble fragments.

The InvalidTTLtoController component, a Boolean, defines whether the switch will send packets with invalid TTL to the controller.

The SwitchDescription component, a structure, contains the following information about the switch:

  • Manufacturer description
  • Hardware description
  • Software description
  • Serial Number
  • Human readable description of datapath

Lastly the Ports component is an array which contains in its rows, all the port numbers.

5.1.3. Capabilities

The following capabilities have been defined for the OpenFlowSwitch LFB

An assortment of Boolean type capabilities to define:

  • FlowStatistics. If the switch keeps flow statistics
  • TableStatistics. If the switch keep table statistics
  • PortStatistics. If the switch keep port statistics
  • GroupStatistics. If the switch keep group statistics
  • IPReassembly. If the switch can reassemble IP fragments
  • QueueStats. If the switch keeps queue statistics
  • ARPMatchIP. If the switch matches IP addresses in APR packets

The MaxBufferedPackets capability, an unsigned integer of 32 bits, defines the maximum packets the switch can buffer when sending packets to the controller.

The TablesSupported capability, an unsigned integer of 8 bits, defines the number of tables supported by the switch, each of which can have a different set of supported wildcard bits and number of entries.

Additionally the another capability, the ActionSupported, defines the supported actions for the switch.

5.1.4. Events

Three events have been specified regarding the ports. The first event will be triggered when a new port is added to the switch, the second when a port has been removed from the switch and the third when a port has been modified

5.2. OFFlowTableLFB

5.2.1. Data Handling

The OFFlowTableLFB describes the process of selecting packets and classify them into specific flows based on specific match fields assigned by the controller.

The LFB is expected to receive all types of Ethernet packets through a group input named Input Port, either from a OFPortLFB or a OFFlowTableLFB, along with metadata. The metadata will contain only the Ingress Port if the OFFlowTableLFB is receiving packets from the OFPortLFB, or the IngressPort, the ActionSetIndex metadata and an arbitrary Metadata of an unsigned integer of 64 bits if receives packets from another OFFlowTableLFB.

The OFFlowTableLFB compares the packet with the MatchFields inside the FlowEntries Table. If there is no match, depending upon the MissBehaviour component, the LFB may either send the packet to the controller, send it to the next table in the pipeline, or even drop it. If there is a match the LFB will decide based on the InstructionType of the struct Instructions inside the matched FlowEntry.

If the instruction is Apply Actions, the LFB will use the InstructionIndex to find the Actions inside the ApplyActionTable. Each row of the ApplyActionTable is an array containing rows of ActionRowTypes. For every ActionRowType, the LFB will send the packet to the corresponding Action LFB through the group output ActionPort port alongside with the LFBClassIDMetadata and LFBInstanceIDMetadata of the LFB and the ActionIndex, if the specific action has any parameters, like the Set MAC Address action. The ActionIndex is used as an index for the table inside the Action LFB. The packet is then returned from the Action LFB through the group input port PacketReturn to continue further processing if exists.

One exception to the Action LFBs is the Group action. Instead there is the OFGroupLFB which handle groups. The OFFlowTableLFB using the ActionIndex locates the Group Identifier in the OFFlowTableLFB's GroupTable component. Then it sends the packet to the GroupTableLFB using the group output ActionPort and expects the packet to return through the PacketReturn group input port.

If the instruction is Clear Actions, the LFB will use the ActionSetIndex to locate the entry in the ActionSet and remove all the rows of Actions. The ActionSet is an alias with the actual data located in the ActionSetLFB.

If the instruction is Write Actions, the LFB will use the ActionSetIndex to locate the entry in the ActionSet and add all the rows of Actions with the Actions located in the ApplyActionTable in the row with the Index InstructionIndex.

If the instruction is Write Metadata, the LFB will write the Metadata using the InstructionIndex to find the value in the WriteMetadataValue Table.

If the instruction is Goto Table, the LFB will use the InstructionIndex to find the value OFFlowTableLFB InstanceID in the GoToFlowTable table and send the packet using the group OutputPort to send the packet to the corresponding OFFlowTableLFB along with IngressPort, the ActionSetIndex and the Metadata.

5.2.2. Components

A FlowTableID component holds the flow table sequence number.

The FlowEntries component defines the MatchField, the Counters and the instructions of the OpenFlow switch. It is an array and each row of the array is a struct containing the cookie, the MatchFields, the Counters, the Instructions, the Timeouts, the Timers and the priority of the specific flow entry.

The FlowTableCounter is a component for counters of the whole FlowTable.

The ApplyActionTable is a component to maintain the actions required per flow. It is an array of Actions, which is an array of a struct of ActionType and ActionTableIndex.

The WriteActions is a component to maintain the actions to be writen for a write actions instruction. It is an array of Actions, which is an array of a struct of ActionType and ActionTableIndex.

The WriteMetadataTable is a component to hold the metadata values required for the write metadata value. It is an array of WriteMetadataTableType, which is a struct of the Metadata value and the MetadataMask.

The GotoFlowTable component contains the FlowTable IDs flows should go to for the goto table action. It is an array of uint32. The value is selected using the InstructionIndex.

The GroupTable component contains group identifiers. It is an array of group identifiers indexed by the ActionTableIndex.

The ActionSet component contains the Action set that is build for the packet along its way through the datapath. It is an alias pointing to the value residing in the OFActionSetLFB.

The MissBehaviour component specifies what the OFFlowTableLFB shall do with the packet if there is no match with the match fields.

The buffer component contains information for packets waiting in the buffer of the OFFlowTable. It is an array of a struct component containing the BufferID, an ID assigned by the datapath and the reason the packet is buffered.

5.2.3. Capabilities

This LFB has no capabilities specified.

5.2.4. Events

One event have been defined regarding the Flow Table. The event will be triggered when a flow is deleted from the Flow Table whether due to the idle timeout, or to the hard timeout or a flow was deleted by the controller.

5.3. OFGroupTableLFB

The Group LFB contains Action Buckets that can be applied to a packet during its path in the Flow Tables pipeline.

5.3.1. Data Handling

This LFB does not take part in the actual handling of the data. It rather contains the action per group which are required by all Flow Tables in the pipeline. Packets initially enter the LFB from an OFActionSet LFB or a OFFlowTableLFB via the group input port PacketIn and using the GroupIndex metadata the LFB finds the group requested for this packet. Then the LFB depending on the requested actions sends the packet to the required OFActionLFBs via the group output ActionPort and expects results via the group input PacketReturn. Once all actions have been completed, the LFB returns the packet to the initial caller LFB, the OFActionSet LFB or the OFFlowTable LFB, based on the metadata LFBClassID and LFBInstance ID.

5.3.2. Components

The LFB has only one component which is the Group Table. This is an array of GroupTableEntry types. Each GroupTableEntry contains a Group Identifier, the type of Group, the required counters and an array of action buckets.

An action bucket is a struct which contains the Group weight required for select groups, the watch port and watch group required for fast failover groups, the bucket counters and the actions for this bucket.

The structure of actions in a bucket are identical to the actions in the flow table LFB containing the type of action and an action table index. With the action type and action index the Group LFB can identify the component and index of the action details.

5.3.3. Capabilities

This LFB has no capabilities specified.

5.3.4. Events

This LFB has no events specified.

5.4. OFPortLFB

5.4.1. Data Handling

This LFB is the interface to the Ethernet physical media. The LFB handles Ethernet frames coming in or going out to/of the OpenFlow switch. Ethernet frames are received from the physical media port and passed to an OFFlowTableLFB through the singleton output port PacketIn, along with the IngressPortID metadata.

When a packet is ready to be send on the wire, it is sent to an OFPortLFB instance through the group input port PacketOut.

5.4.2. Components

The PortNumber component uniquely identifies the port within a switch.

The IEEEMAC component contains the MAC Address of the port.

The Name component is a human readable name of the port.

The Configuration component specifies port behaviour. It's a struct component with the following boolean fields. PortDown, NoReceiving, NoForwarding and NoPacket_In.

The State component defines the current state of the OpenFlow Switch. It is a struct component that defines whether the link is down, the port is blocked or the port can be used for live fast failover.

The Current Features component describes the current features of the port. It is a struct component and specifies the Speed Types, the Connected Medium, the Auto Negotiation and the Pause Types

The Advertised Features component describes the advertised features of the port. The component is of the same structure as the current features.

The CurrentSpeed component defines the current port bitrate in kbps.

The MaximumSpeed component defines the maximum port bitrate in kbps.

The PortCounter component contains the necessary counters for the port. It is a struct component comprised of counters for Packets Received, Packets Transmitted, Bytes Received, Bytes Transmitted, Drops Received, Transmit Drops, Errors in reception, Errors in transmittion, Frame Alignment Errors received, Received Overrun Errors, CRC Errors in received packets, Collisions.

5.4.3. Capabilities

Two capabilities has been defined for the Port LFB. Supported Features and Peer Features. These include:

  • Types of Speed supported
  • Medium Connected to the port
  • Auto-negotiation
  • Pause Types supported of the port

5.4.4. Events

This LFB has no events specified.

5.5. OFQueueLFB

5.5.1. Data Handling

This LFB manages the queue algorithm for handling packets prior to be forwarded to a port. Multiple OFQueueLFBs can be attached to the OFPortLFBs to handle queues. If a packet has been set a QueueID with a Set Queue action, before it is sent to OFPortLFB to be sent on the wire, it enters this LFB via the group input port PacketIn where it will be handled according to the LFBs configuration and then be sent via the singleton output port PacketOut to the OFPortLFB.

5.5.2. Components

The QueueID component, a uint32, defines the ID for the specific queue.

The Length component, a uint16, defines the length in bytes of this queue.

The Properties component, is an array of Property Types an the length of the property, defines the current queue mode. Current specified modes are none and minimum rate.

The QueueCounter component, a struct of TransmitPackets, TransmitBytes, TransimtOverrunErrors holds the necessary counter for the LFB.

5.5.3. Capabilities

This LFB has no capabilities specified.

5.5.4. Events

This LFB has no events specified.

5.6. OFActionSetLFB

5.6.1. Data Handling

A packet arrives in the OFActionSetLFB via the group input InputPort from an OFFlowTableLFB along with the ActionSetIndex metadata, required to uniquely identify the index of the row in the ActionSetTable. The LFB locates the action set in the specified row of the ActionSetTable which is itself a table of maximum 9 actions. The LFB then performs each action in ascending order sorted by the ActionSetType by sending the packet to the specified Action LFBs or the Group LFB via the group output ActionPort and getting the result from the group input port PacketReturn, until all actions are finished. Last action is either the group or the output action where the packet is not expected to return to the LFB and the ActionSet is removed from the ActionSetTable.

5.6.2. Components

This LFB has only one component, the ActionSetTable which is an Array per packet. Each row is an array of maximum size 9 rows and is a struct of the major type of action, e.g. pop, push, set, the LFBClassID this action is directed, the LFBInstanceID this action is stored and the ActionTableIndex of the table inside the action LFB. If the LFBClassID is a group LFB then the ActionTableIndex is the Group Table Index.

5.6.3. Capabilities

This LFB has no capabilities specified.

5.6.4. Events

This LFB has no events specified.

5.7. OFActionLFB

This LFB is a template used for create OFActionLFBs. All OFActionLFBs have the input and output port in common but have different components. This LFB defines how input and output port of all OFActionLFBs. Inside OFActionLFBs there is a table with the required attributes where applicable as some OFActionLFBs don't require attributes.

5.7.1. Data Handling

A packet arrives in an OFActionLFB via the group input PacketIn from an OFFlowTableLFB, an OFGroupTableLFB or the OFActionSet LFB, along with the LFBClassID and LFBInstanceID metadata, required to uniquely identify the sender, and optionally the ActionIndex metadata if the action requires a specific attributes. Once the packet has been processed it is return to the sender LFB via the group output PacketOut.

5.7.2. Components

This LFB has no components specified.

5.7.3. Capabilities

This LFB has no capabilities specified.

5.7.4. Events

This LFB has no events specified.

5.8. OFActionLFBs

As none of the OFActionLFBs have no capabilities or events, these sections are ommited from the draft.

5.8.1. OFOutputOFActionLFB

5.8.1.1. Data Handling

The OFOutputOFActionLFB does not modify the packet in any way, rather forwards a packet to a specified OFPortLFB. Additionally there are several virtual ports that the OFOutputOFActionLFB may send the packet to:

  • All - Sends the packet out all standard ports, but not to the ingress port or ports configured not to forward
  • Controller - Sends the packet to the controller
  • Table - Submit the packet to the first flow table so that the packet can be processed through the regular OpenFlow pipeline. Only valid in the aciton set of a packet-out message
  • InPort - Sends the packet out the ingress port.
  • Local - Sends the packet to the switch's local networking stack
  • Normal - Processes the packet using the traditional non-OpenFlow pipeline of the switch.
  • Flood - Floods the packet using the normal pipeline of the switch.

5.8.1.2. Components

This LFB has only one component, the OutputActionTable, which is an array of a struct of the port number and optionally the maximum length in bytes, if the receiving end is the controller.

5.8.2. OFSetVLANVIDOFActionLFB

5.8.2.1. Data Handling

The OFSetVLANVIDOFActionLFB replaces the existing VLAN ID. Only applies to packets with an existing VLAN tag.

5.8.2.2. Components

This LFB has only one component, the SetVLANVIDActionTable, which is an array of uint16 VLAN tag values.

5.8.3. OFSetVLANPriorityOFActionLFB

5.8.3.1. Data Handling

The OFSetVLANPriorityOFActionLFB replaces the existing VLAN priority. Only applies to packets with an existing VLAN tag.

5.8.3.2. Components

This LFB has only one component, the SetVLANPriorityActionTable, which is an array of uchar VLAN priority values.

5.8.4. OFSetMACSourceOFActionLFB

5.8.4.1. Data Handling

The OFSetMACSourceOFActionLFB replaces the existing Ethernet source MAC address.

5.8.4.2. Components

This LFB has only one component, the SetMACSourceActionTable, which is an array of IEEEMAC addresses.

5.8.5. OFSetMACDestinationOFActionLFB

5.8.5.1. Data Handling

The OFSetMACDestinationOFActionLFB replaces the existing Ethernet source MAC address.

5.8.5.2. Components

This LFB has only one component, the SetMACSourceActionTable, which is an array of IEEEMAC addresses.

5.8.6. OFSetIPSourceOFActionLFB

5.8.6.1. Data Handling

The OFSetIPSourceOFActionLFB replaces the existing IP source address with new value and update the IP checksum (and TCP/UDP/SCTP checksum if applicable). This action is only applicable to IPv4 packets.

5.8.6.2. Components

This LFB has only one component, the SetIPSourceActionTable, which is an array of IPv4 addresses.

5.8.7. OFSetIPDestinationOFActionLFB

5.8.7.1. Data Handling

The OFSetIPDestinationOFActionLFB replaces the existing IP destination address with new value and update the IP checksum (and TCP/UDP/SCTP checksum if applicable). This action is only applicable to IPv4 packets.

5.8.7.2. Components

This LFB has only one component, the SetIPDestinationActionTable, which is an array of IPv4 addresses.

5.8.8. OFSetIPTOSOFActionLFB

5.8.8.1. Data Handling

The OFSetIPTOSOFActionLFB replaces the existing IP TOS value and update the IP checksum. Only applies to IPv4 packets.

5.8.8.2. Components

This LFB has only one component, the SetIPTOSActionTable, which is an array of IPv4 uchar TOS values.

5.8.9. OFSetIPECNOFActionLFB

5.8.9.1. Data Handling

The OFSetIPECNOFActionLFB replaces the existing IP ECN value and update the IP checksum. Only applies to IPv4 packets.

5.8.9.2. Components

This LFB has only one component, the SetIPECNActionTable, which is an array of IPv4 uchar ECN values.

5.8.10. OFSetTCPSourceOFActionLFB

5.8.10.1. Data Handling

The OFSetTCPSourceOFActionLFB replaces the existing TCP/UDP/SCTP source port with new value and update the TCP/UDP/SCTP checksum. This action is only applicable to TCP, UDP and SCTP packets.

5.8.10.2. Components

This LFB has only one component, the SetTCPSourceActionTable, which is an array of uint16 values.

5.8.11. OFSetTCPDestinationOFActionLFB

5.8.11.1. Data Handling

The OFSetTCPDestinationOFActionLFB replaces the existing TCP/UDP/SCTP destination port with new value and update the TCP/UDP/SCTP checksum. This action is only applicable to TCP, UDP and SCTP packets.

5.8.11.2. Components

This LFB has only one component, the SetTCPDestinationActionTable, which is an array of uint16 values.

5.8.12. OFCopyTTLOutOFActionLFB

5.8.12.1. Data Handling

The OFCopyTTLOutOFActionLFB copies the TTL from next-to-outermost to outermost header with TTL. Copy can be IP-to-IP, MPLS-to-MPLS, or IP-to-MPLS.

5.8.12.2. Components

This LFB has no components specified.

5.8.13. OFCopyTTLInOFActionLFB

5.8.13.1. Data Handling

The OFCopyTTLOutOFActionLFB copies the TTL from outermost to next-to-outermost header with TTL. Copy can be IP-to-IP, MPLS-to-MPLS, or IP-to-MPLS.

5.8.13.2. Components

This LFB has no components specified.

5.8.14. OFSetMPLSLabelOFActionLFB

5.8.14.1. Data Handling

The OFSetMPLSLabelOFActionLFB replaces the existing MPLS label. Only applies to packets with an existing MPLS shim header.

5.8.14.2. Components

This LFB has only one component, the SetMPLSLabelActionTable, which is an array of uint32 MPLS label values.

5.8.15. OFSetMPLSTCOFActionLFB

5.8.15.1. Data Handling

The OFSetMPLSTCOFActionLFB replaces the existing MPLS traffic class. Only applies to packets with an existing MPLS shim header.

5.8.15.2. Components

This LFB has only one component, the SetMPLSTCActionTable, which is an array of uchar MPLS label values.

5.8.16. OFSetMPLSTTLOFActionLFB

5.8.16.1. Data Handling

The OFSetMPLSTTLOFActionLFB replaces the existing MPLS TTL. Only applies to packets with an existing MPLS shim header.

5.8.16.2. Components

This LFB has only one component, the SetMPLSTTLTable, which is an array of uchar MPLS TTL values.

5.8.17. OFDecrementMPLSTTLOFActionLFB

5.8.17.1. Data Handling

The OFDecrementMPLSTTLOFActionLFB decrements the MPLS TTL. Only applies to packets with an existing MPLS shim header.

5.8.17.2. Components

This LFB has no components specified.

5.8.18. OFPushVLanOFActionLFB

5.8.18.1. Data Handling

The OFPushVLanOFActionLFB pushes a new VLAN header onto the packet. The Ethertype is used as the Ethertype for the tag. Only Ethertype 0x8100 and 0x88a8 should be used.

5.8.18.2. Components

This LFB has only one component, the PushVLANTable, which is an array of uint16 VLAN header values.

5.8.19. OFPopVLANOFActionLFB

5.8.19.1. Data Handling

The OFPopVLANOFActionLFB pops the outer-most VLAN header from the packet.

5.8.19.2. Components

This LFB has no components specified.

5.8.20. OFPushMPLSOFActionLFB

5.8.20.1. Data Handling

The OFPushMPLSOFActionLFB pushes a new MPLS shim header onto the packet. The Ethertype is used as the Ethertype for the tag. Only Ethertype 0x8847 and 0x8848 should be used.

5.8.20.2. Components

This LFB has only one component, the PushMPLSTable, which is an array of uint16 MPLS header values.

5.8.21. OFPopMPLSOFActionLFB

5.8.21.1. Data Handling

The OFPopMPLSOFActionLFB pops the outer-most MPLS tag or shim header from the packet. The Ethertype is used as the Ethertype for the resulting packet (Ethertype for the MPLS payload).

5.8.21.2. Components

This LFB has only one component, the PopMPLSTable, which is an array of uint16 ethertype values.

5.8.22. OFSetQueueOFActionLFB

5.8.22.1. Data Handling

The OFSetQueueOFActionLFB sets the queue ID for the packet.

5.8.22.2. Components

This LFB has only one component, the SetQueueTable, which is an array of uint32 queue identifiers.

5.8.23. OFSetIPTTLOFActionLFB

5.8.23.1. Data Handling

The OFSetIPTTLOFActionLFB replaces the existing IP TTL and update the IP checksum. Only applies to IPv4 packets.

5.8.23.2. Components

This LFB has only one component, the SetIPTTLTable, which is an array of uchar TTL values.

5.8.24. OFDecrementIPTTLOFActionLFB

5.8.24.1. Data Handling

The OFDecrementIPTTLOFActionLFB decrements the existing IP TTL and update the IP checksum. Only applies to IPv4 packets.

5.8.24.2. Components

This LFB has no components specified.

5.8.25. OFExperimenterOFActionLFB

5.8.25.1. Data Handling

The OFExperimenterOFActionLFB handles experimenter actions.

5.8.25.2. Components

This LFB has only one component, the SetIPTTLTable, which is an array of uint32 Experimenter ID values.

6. XML for OpenFlow library

<?xml version="1.0" encoding="UTF-8"?>
<LFBLibrary xmlns="urn:ietf:params:xml:ns:forces:lfbmodel:1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="urn:ietf:params:xml:ns:forces:lfbmodel:1.0
C:\Workspace\ForCES\XML\LFBSchemaRFC.xsd" provides="OpenFlow">
  <load library="BaseTypeLibrary"
   location="urn:ietf:params:xml:ns:forces:lfbmodel:1.0"/>
  <dataTypeDefs>
    <!-- Data Type Definition for the OpenFlow Switch -->
    <dataTypeDef>
      <name>SwitchDescriptionType</name>
      <synopsis>The type of the switch description</synopsis>
      <struct>
        <component componentID="1">
          <name>MFR</name>
          <synopsis>Manufacturer description</synopsis>
          <typeRef>string[256]</typeRef>
        </component>
        <component componentID="2">
          <name>HW</name>
          <synopsis>Hardware description</synopsis>
          <typeRef>string[256]</typeRef>
        </component>
        <component componentID="3">
          <name>SF</name>
          <synopsis>Software description</synopsis>
          <typeRef>string[256]</typeRef>
        </component>
        <component componentID="4">
          <name>SerialNum</name>
          <synopsis>Serial Number</synopsis>
          <typeRef>string[32]</typeRef>
        </component>
        <component componentID="5">
          <name>DP</name>
          <synopsis>Human readable description of datapath</synopsis>
          <typeRef>string[256]</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <!-- Data Type Definition for the Flow Match -->
    <dataTypeDef>
      <name>MPLSLabelValue</name>
      <synopsis>An MPLS label.</synopsis>
      <atomic>
        <baseType>uint32</baseType>
        <rangeRestriction>
          <allowedRange min="0" max="1048576"/>
        </rangeRestriction>
      </atomic>
    </dataTypeDef>
    <dataTypeDef>
      <name>MPLSTrafficClassValues</name>
      <synopsis>The MPLS Traffic Class</synopsis>
      <atomic>
        <baseType>uchar</baseType>
        <rangeRestriction>
          <allowedRange min="0" max="7"/>
        </rangeRestriction>
      </atomic>
    </dataTypeDef>
    <dataTypeDef>
      <name>IPv4ToSbits</name>
      <synopsis>TOSBits</synopsis>
      <atomic>
        <baseType>uchar</baseType>
        <rangeRestriction>
          <allowedRange min="0" max="64"/>
        </rangeRestriction>
      </atomic>
    </dataTypeDef>
    <dataTypeDef>
      <name>WildcardsType</name>
      <synopsis>Wildcards for fields</synopsis>
      <struct>
        <component componentID="1">
          <name>InPort</name>
          <synopsis>Input Port Wildcard</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="2">
          <name>VLANID</name>
          <synopsis>Vlan ID Wildcard</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="3">
          <name>VLANPCP</name>
          <synopsis>Vlan priority Wildcard</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="4">
          <name>DLType</name>
          <synopsis>Ethernet frame typ Wildcard</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="5">
          <name>IPToS</name>
          <synopsis>IP ToS Wildcard</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="6">
          <name>IPProtocol</name>
          <synopsis>IP Protocol Wildcard</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="7">
          <name>TPSource</name>
          <synopsis>TCP/UDP/SCTP source port Wildcard</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="8">
          <name>TPDestination</name>
          <synopsis>TCP/UDP/SCTP destination port Wildcard</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="9">
          <name>MPLSLabel</name>
          <synopsis>MPLS label Wildcard</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="10">
          <name>MPLSTC</name>
          <synopsis>MPLS TC Wildcard</synopsis>
          <typeRef>boolean</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>MatchFieldType</name>
      <synopsis>A Match Field Type</synopsis>
      <struct>
        <component componentID="1">
          <name>IngressPort</name>
          <synopsis>Numerical representation of incoming port, starting
          at 1. This may be a physical or switch-defined virtual port.
          </synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="2">
          <name>Wildcards</name>
          <synopsis>Wildcards for match fields</synopsis>
          <typeRef>WildcardsType</typeRef>
        </component>
        <component componentID="3">
          <name>EthernetSourceAddress</name>
          <synopsis>Ethernet source address</synopsis>
          <typeRef>IEEEMAC</typeRef>
        </component>
        <component componentID="4">
          <name>EthernetSourceAddressMask</name>
          <synopsis>Ethernet source address mask</synopsis>
          <typeRef>IEEEMAC</typeRef>
        </component>
        <component componentID="5">
          <name>EthernetDestinationAddress</name>
          <synopsis>Ethernet destination address</synopsis>
          <typeRef>IEEEMAC</typeRef>
        </component>
        <component componentID="6">
          <name>EthernetDestinationAddressMask</name>
          <synopsis>Ethernet destination address mask</synopsis>
          <typeRef>IEEEMAC</typeRef>
        </component>
        <component componentID="7">
          <name>VlanID</name>
          <synopsis>VLAN identifier of outermost VLAN tag.</synopsis>
          <typeRef>VlanIDType</typeRef>
        </component>
        <component componentID="8">
          <name>VlanPriority</name>
          <synopsis>VLAN PCP Field of outermost VLAN tag.</synopsis>
          <typeRef>VlanPriorityType</typeRef>
        </component>
        <component componentID="9">
          <name>EtherType</name>
          <synopsis>Ethernet type of the OpenFlow packet payload, after
           VLAN tags. 802.3 frames have special handling.</synopsis>
          <typeRef>uint16</typeRef>
        </component>
        <component componentID="10">
          <name>IPv4TOS</name>
          <synopsis>Specify as 8-bit value and place ToS in upper 6 
          bits for match</synopsis>
          <typeRef>IPv4ToSbits</typeRef>
        </component>
        <component componentID="11">
          <name>ArpOpcode</name>
          <synopsis>Only the lower 8 bits of the ARP opcode are used 
          for the match</synopsis>
          <typeRef>uchar8</typeRef>
        </component>
        <component componentID="12">
          <name>IPv4SourceAddress</name>
          <synopsis>IPv4 Source Address to match</synopsis>
          <typeRef>IPv4Addr</typeRef>
        </component>
        <component componentID="13">
          <name>IPv4SourceAddressMask</name>
          <synopsis>IPv4 Source Address mask</synopsis>
          <typeRef>IPv4Addr</typeRef>
        </component>
        <component componentID="14">
          <name>IPv4DestinationAddress</name>
          <synopsis>IPv4 Destination Address to match</synopsis>
          <typeRef>IPv4Addr</typeRef>
        </component>
        <component componentID="15">
          <name>IPv4DestinationAddressMask</name>
          <synopsis>IPv4 Destination Address mask</synopsis>
          <typeRef>IPv4Addr</typeRef>
        </component>
        <component componentID="16">
          <name>TCPSourcePort</name>
          <synopsis>Source Port for TCP and ICMP to match</synopsis>
          <typeRef>uint16</typeRef>
        </component>
        <component componentID="17">
          <name>TCPDestinationPort</name>
          <synopsis>Destination Port for TCP and ICMP to 
          match</synopsis>
          <typeRef>uint16</typeRef>
        </component>
        <component componentID="18">
          <name>MPLSlabel</name>
          <synopsis>Match on outermost MPLS tag.</synopsis>
          <typeRef>MPLSLabelValue</typeRef>
        </component>
        <component componentID="19">
          <name>MPLSTrafficClass</name>
          <synopsis>Match on outermost MPLS tag for traffic 
          class.</synopsis>
          <typeRef>MPLSTrafficClassValues</typeRef>
        </component>
        <component componentID="20">
          <name>Metadata</name>
          <synopsis>MetaData</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="21">
          <name>MetadataMask</name>
          <synopsis>MetaData Mask</synopsis>
          <typeRef>uint64</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <!-- Datatype Definition for Flow Table -->
    <dataTypeDef>
      <name>FlowEntry</name>
      <synopsis>A Flow entry</synopsis>
      <struct>
        <component componentID="1">
          <name>Cookie</name>
          <synopsis>Opaque data chosen by controller</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="2">
          <name>MatchFields</name>
          <synopsis>Match Fields: to match against packets. These 
         consist of the ingress port and packet headers, and optionally
          metadata specified by a previous table</synopsis>
          <typeRef>MatchFieldType</typeRef>
        </component>
        <component componentID="3">
          <name>Counters</name>
          <synopsis>Counters: to update for matching packets</synopsis>
          <typeRef>FlowCounterType</typeRef>
        </component>
        <component componentID="4">
          <name>Instructions</name>
          <synopsis>Instruction: what to do with the packet of the 
          flow</synopsis>
          <struct>
            <component componentID="1">
              <name>InstructionType</name>
              <synopsis>The instruction type</synopsis>
              <typeRef>InstructionTypes</typeRef>
            </component>
            <component componentID="2">
              <name>InstructionIndex</name>
              <synopsis>The instruction index.</synopsis>
              <typeRef>uint32</typeRef>
            </component>
          </struct>
        </component>
        <component componentID="5">
          <name>Timeouts</name>
          <synopsis>Timeouts for the flow entry</synopsis>
          <struct>
            <component componentID="1">
              <name>IdleTimeout</name>
              <synopsis>Timeout to expire if no flows are matched for 
              this flow entry</synopsis>
              <typeRef>uint16</typeRef>
            </component>
            <component componentID="2">
              <name>HardTimeout</name>
              <synopsis>Timeout to expire for this flow entry 
              regardless of idle timeout</synopsis>
              <typeRef>uint16</typeRef>
            </component>
          </struct>
        </component>
        <component componentID="6">
          <name>Timers</name>
          <synopsis>Timers per flow</synopsis>
          <struct>
            <component componentID="1">
              <name>Duration_Sec</name>
              <synopsis>Time flow has been alive in seconds</synopsis>
              <typeRef>uint32</typeRef>
            </component>
            <component componentID="2">
              <name>Duration_nSec</name>
              <synopsis>Time flow has been alive in nanoseconds beyond 
              Duration_Sec</synopsis>
              <typeRef>uint32</typeRef>
            </component>
          </struct>
        </component>
        <component componentID="7">
          <name>Priority</name>
          <synopsis>Priority within the specified flow table</synopsis>
          <typeRef>uint16</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>ActionRowType</name>
      <synopsis>An Action Row for the action table</synopsis>
      <struct>
        <component componentID="1">
          <name>Action</name>
          <synopsis>The type of action</synopsis>
          <typeRef>ActionType</typeRef>
        </component>
        <component componentID="2">
          <name>ActionTableIndex</name>
         <synopsis>Index of the Table this action applies to</synopsis>
          <typeRef>uint32</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>ActionType</name>
      <synopsis>The type of action</synopsis>
      <atomic>
        <baseType>uint16</baseType>
        <specialValues>
          <specialValue value="1">
            <name>OUTPUT</name>
            <synopsis>Output to switch port</synopsis>
          </specialValue>
          <specialValue value="2">
            <name>SetVLANVID</name>
            <synopsis>Set the 802.1q VLAN id</synopsis>
          </specialValue>
          <specialValue value="3">
            <name>SetVLANPCP</name>
            <synopsis>Set the 802.1q priority</synopsis>
          </specialValue>
          <specialValue value="4">
            <name>SetDLSrc</name>
            <synopsis>Set Ethernet source address</synopsis>
          </specialValue>
          <specialValue value="5">
            <name>SetDLDst</name>
            <synopsis>Set Ethernet destination address</synopsis>
          </specialValue>
          <specialValue value="6">
            <name>SetIPSrc</name>
            <synopsis>Set IP source address</synopsis>
          </specialValue>
          <specialValue value="7">
            <name>SetIPDst</name>
            <synopsis>Set IP Destination address</synopsis>
          </specialValue>
          <specialValue value="8">
            <name>SetIPTOS</name>
            <synopsis>Set ToS field</synopsis>
          </specialValue>
          <specialValue value="9">
            <name>SetIPECN</name>
            <synopsis>Set ECN field</synopsis>
          </specialValue>
          <specialValue value="10">
            <name>SetTPSource</name>
            <synopsis>TCP/UDP/SCTP source port</synopsis>
          </specialValue>
          <specialValue value="11">
            <name>SetTPDestination</name>
            <synopsis>TCP/UDP/SCTP destination port</synopsis>
          </specialValue>
          <specialValue value="12">
            <name>CopyTTLOut</name>
            <synopsis>Copy TTL "outwards" -- from next-to-outermost to 
            outermost</synopsis>
          </specialValue>
          <specialValue value="13">
            <name>CopyTTLIn</name>
            <synopsis>Copy TTL "inwards" -- from outermost to next-to-
            outermost</synopsis>
          </specialValue>
          <specialValue value="14">
            <name>SetMPLSLabel</name>
            <synopsis>Set MPLS label</synopsis>
          </specialValue>
          <specialValue value="15">
            <name>SetMPLSTC</name>
            <synopsis>Set MPLS TC</synopsis>
          </specialValue>
          <specialValue value="16">
            <name>SetMPLSTTL</name>
            <synopsis>Set MPLS TTL</synopsis>
          </specialValue>
          <specialValue value="17">
            <name>PushVLANTag</name>
            <synopsis>Push a new VLAN tag</synopsis>
          </specialValue>
          <specialValue value="18">
            <name>PopVLANTag</name>
            <synopsis>Pop the outer VLAN tag</synopsis>
          </specialValue>
          <specialValue value="19">
            <name>PushMPLSTag</name>
            <synopsis>Push a new MPLS tag</synopsis>
          </specialValue>
          <specialValue value="20">
            <name>PopMPLSTag</name>
            <synopsis>Pop the outer MPLS tag</synopsis>
          </specialValue>
          <specialValue value="21">
            <name>SetQueue</name>
            <synopsis>Set queue ID when outputting to a port</synopsis>
          </specialValue>
          <specialValue value="22">
            <name>Group</name>
            <synopsis>Apply group</synopsis>
          </specialValue>
          <specialValue value="23">
            <name>SetIPTTL</name>
            <synopsis>Set IP TTL</synopsis>
          </specialValue>
          <specialValue value="24">
            <name>DecIPTTL</name>
            <synopsis>Decrement IP TTL</synopsis>
          </specialValue>
          <specialValue value="0xffff">
            <name>Experimenter</name>
            <synopsis>Experimental field</synopsis>
          </specialValue>
        </specialValues>
      </atomic>
    </dataTypeDef>
    <dataTypeDef>
      <name>TableCounterType</name>
      <synopsis>Counter per table</synopsis>
      <struct>
        <component componentID="1">
          <name>ReferenceCount</name>
          <synopsis>Active Entries</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="2">
          <name>PacketLookups</name>
          <synopsis>Packet Lookups</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="3">
          <name>PacketMatches</name>
          <synopsis>Packet Matches</synopsis>
          <typeRef>uint64</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>Actions</name>
      <synopsis>Actions to perform. An Array of 
      ActionRowTypes</synopsis>
      <array>
        <typeRef>ActionRowType</typeRef>
      </array>
    </dataTypeDef>
    <dataTypeDef>
      <name>FlowCounterType</name>
      <synopsis>Counter per flow</synopsis>
      <struct>
        <component componentID="1">
          <name>ReceivedPackets</name>
          <synopsis>Packets Received</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="2">
          <name>ReceivedBytes</name>
          <synopsis>Bytes Received</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="3">
          <name>DurationS</name>
          <synopsis>Duration in seconds</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="4">
          <name>DurationNS</name>
          <synopsis>Duration in nanoseconds</synopsis>
          <typeRef>uint32</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>InstructionTypes</name>
      <synopsis>Instructions supported</synopsis>
      <atomic>
        <baseType>short</baseType>
        <specialValues>
          <specialValue value="1">
            <name>GotoTable</name>
            <synopsis>Indicates the next table in the processing
            pipeline. The table-id must be greater than the current
            table-id. The flows of last table of the pipeline can not
            include this instruction</synopsis>
          </specialValue>
          <specialValue value="2">
            <name>WriteMetadata</name>
            <synopsis>Writes the masked metadata value into the
            metadata field. The mask specifies which bits of the
            metadata register should be modified (i.e. new metadata=old
            metadata and ~mask | value and mask)</synopsis>
          </specialValue>
          <specialValue value="3">
            <name>WriteAction</name>
            <synopsis>Merges the specifieed action(s) into the current
            action set. If an action of the given type exists in the
             current set, overwrite it, otherwise add it.</synopsis>
          </specialValue>
          <specialValue value="4">
            <name>ApplyActions</name>
            <synopsis>Applies the specific action(s) immediately,
            without any change to the Action Set. This instruction may
            be used to modify the packet between two tables or to
            execute multiple actions of the same type. The actions are
            specified as an action list</synopsis>
          </specialValue>
          <specialValue value="5">
            <name>ClearActions</name>
            <synopsis>Clears all the actions in the action set
            immediately.</synopsis>
          </specialValue>
          <specialValue value="65535">
            <name>ExperimenterInstruction</name>
            <synopsis>Experimental instruction</synopsis>
          </specialValue>
        </specialValues>
      </atomic>
    </dataTypeDef>
    <dataTypeDef>
      <name>WriteMetadataTableType</name>
      <synopsis>Metadata and mask for the write metadata instruction
      per row</synopsis>
      <struct>
        <component componentID="1">
          <name>Metadata</name>
          <synopsis>The metadata</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="2">
          <name>MetadataMask</name>
          <synopsis>The metadata mask</synopsis>
          <typeRef>uint64</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>FlowTableMissConfigType</name>
      <synopsis>Types to configure the default behavior of unmatched
      packets</synopsis>
      <atomic>
        <baseType>uint32</baseType>
        <specialValues>
          <specialValue value="0">
            <name>Controller</name>
            <synopsis>Send to the controller</synopsis>
          </specialValue>
          <specialValue value="1">
            <name>Continue</name>
            <synopsis>Continue to the next table in the pipeline or
            send to the controller if the FlowTable is the
            last.</synopsis>
          </specialValue>
          <specialValue value="2">
            <name>Drop</name>
            <synopsis>Drop the packet</synopsis>
          </specialValue>
        </specialValues>
      </atomic>
    </dataTypeDef>
    <dataTypeDef>
      <name>BufferReasonTypes</name>
      <synopsis>Buffer Reason Types</synopsis>
      <atomic>
        <baseType>uchar</baseType>
        <specialValues>
          <specialValue value="0">
            <name>NoMatch</name>
            <synopsis>No Matching flow</synopsis>
          </specialValue>
          <specialValue value="1">
            <name>Action</name>
            <synopsis>Explicit action to send to controller</synopsis>
          </specialValue>
        </specialValues>
      </atomic>
    </dataTypeDef>
    <!-- Data Type Definition for the group -->
    <dataTypeDef>
      <name>GroupCounterType</name>
      <synopsis>Counters per group</synopsis>
      <struct>
        <component componentID="1">
          <name>ReferenceCount</name>
          <synopsis>Flow Entries</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="2">
          <name>PacketCount</name>
          <synopsis>Packet Count</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="3">
          <name>ByteCount</name>
          <synopsis>Byte Count</synopsis>
          <typeRef>uint64</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>GroupTypeType</name>
      <synopsis>To determine group semantics</synopsis>
      <atomic>
        <baseType>uchar</baseType>
        <specialValues>
          <specialValue value="1">
            <name>all</name>
            <synopsis>Execute all buckets in the group. This group is
            used for multicast or broadcast forwarding. The packet is
            effectively cloned for each bucket; one packet is processed
            for each bucket of the group. If a bucket directs a packet
            explicitly out the ingress port, this packet clone is
            dropped. If the controller writer wants to forward out the
            ingress port, the group should include an extra bucket
            which includes an output action to the OFPP_IN_PORT
            virtual port.</synopsis>
          </specialValue>
          <specialValue value="2">
            <name>select</name>
            <synopsis>Execute one bucket in the group. Packets are sent
            to a single bucket in the group, based on a switch-computed
            selection algorithm (e.g. hash on some user-configured
            tuple or simple round robin). All configuration and state
            for the selection algorithm is external to OpenFlow. When a
            port speciffied in a bucket in a select group goes down,
            the switch may restrict bucket selection to the remaining
            set (those with forwarding actions to live ports) instead
            of dropping packets destined to that port. This behavior
            may reduce the disruption of a downed link or
            switch.</synopsis>
          </specialValue>
          <specialValue value="3">
            <name>indirect</name>
            <synopsis>Execute the one defined bucket in this group.
            Allows multiple ows or groups to point to a common group
            identifier, supporting faster, more efficient convergence
            (e.g. next hops for IP forwarding). This group type is
            effectively identical to an all group with one
            bucket.</synopsis>
          </specialValue>
          <specialValue value="4">
            <name>fastfailover</name>
            <synopsis>Execute the first live bucket. Each action bucket
            is associated with a speciffic port and/or group that
            controls its liveness. Enables the switch to change
           forwarding without requiring a round trip to the controller.
           If no buckets are live, packets are dropped. This group type
           must implement a liveness mechanism</synopsis>
          </specialValue>
        </specialValues>
      </atomic>
    </dataTypeDef>
    <dataTypeDef>
      <name>BucketCounterType</name>
      <synopsis>Counters per bucket</synopsis>
      <struct>
        <component componentID="1">
          <name>PacketCount</name>
          <synopsis>Packet Count</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="2">
          <name>ByteCount</name>
          <synopsis>Byte Count</synopsis>
          <typeRef>uint64</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>GroupTableEntry</name>
      <synopsis>A Row of the Group Table</synopsis>
      <struct>
        <component componentID="1">
          <name>GroupID</name>
          <synopsis>Group Identifier uniquely identifying the
          group</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="2">
          <name>GroupType</name>
          <synopsis>The group type to determine group
          semantics</synopsis>
          <typeRef>GroupTypeType</typeRef>
        </component>
        <component componentID="3">
          <name>GroupCounters</name>
          <synopsis>Counters per group</synopsis>
          <typeRef>GroupCounterType</typeRef>
        </component>
        <component componentID="4">
          <name>ActionBuckets</name>
          <synopsis>An ordered list of action buckets. Each action
          bucket is a set of actions similar to a flow table</synopsis>
          <array>
            <typeRef>ActionBucket</typeRef>
          </array>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>ActionBucket</name>
      <synopsis>An Action Bucket</synopsis>
      <struct>
        <component componentID="1">
          <name>Weight</name>
          <synopsis>Relative weight of bucket. Only defined for select
          groups.</synopsis>
          <typeRef>uint16</typeRef>
        </component>
        <component componentID="2">
          <name>WatchPort</name>
          <synopsis>Port whose state affects whether this bucket is
          live.Required for fast failover group</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="3">
          <name>WatchGroup</name>
          <synopsis>Group whose state affects whether this group is
          live. Only required for fast failover groups</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="4">
          <name>Actions</name>
          <synopsis>Actions for this bucket</synopsis>
          <typeRef>Actions</typeRef>
        </component>
        <component componentID="5">
          <name>BucketCounter</name>
          <synopsis>A counter for this bucket</synopsis>
          <typeRef>BucketCounterType</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <!-- Data Type Definition for ports -->
    <dataTypeDef>
      <name>PortNumberType</name>
      <synopsis>Port Number values</synopsis>
      <atomic>
        <baseType>uint32</baseType>
        <specialValues>
          <specialValue value="0xfffffff8">
            <name>InPort</name>
            <synopsis>Sent the packet out the input port. This virtual
            port must be explicitly used in order to send back out of
            the input port</synopsis>
          </specialValue>
          <specialValue value="0xfffffff9">
            <name>Table</name>
            <synopsis>Submit the packet to the first flow table. NBL 
            This destination port can only be used in packet-out
            messages</synopsis>
          </specialValue>
          <specialValue value="0xfffffffa">
            <name>Normal</name>
            <synopsis>Process with normal L2/L3 switching</synopsis>
          </specialValue>
          <specialValue value="0xfffffffb">
            <name>Flood</name>
            <synopsis>Send the packet to all physical ports in VLNA,
            except input port and those blocked or link down</synopsis>
          </specialValue>
          <specialValue value="0xfffffffc">
            <name>All</name>
            <synopsis>Send the packet to all physical ports, except
            input port.</synopsis>
          </specialValue>
          <specialValue value="0xfffffffd">
            <name>Controller</name>
            <synopsis>Send the packet to the controller.</synopsis>
          </specialValue>
          <specialValue value="0xfffffffe">
            <name>Local</name>
            <synopsis>Local openflow "port".</synopsis>
          </specialValue>
          <specialValue value="0xffffffff">
            <name>Any</name>
            <synopsis>Wildcard port used only for flow mod (delete) and
            flow stats requests. Selects all flows regardless of output
            port (including flows with no output port).</synopsis>
          </specialValue>
        </specialValues>
      </atomic>
    </dataTypeDef>
    <dataTypeDef>
      <name>PortConfigurationType</name>
      <synopsis>Types of configuration for the OpenFlow port</synopsis>
      <struct>
        <component componentID="1">
          <name>PortDown</name>
          <synopsis>Port is administatively down</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="2">
          <name>NoReceiving</name>
          <synopsis>Drop all packets received by this port</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="3">
          <name>NoForwarding</name>
          <synopsis>Drop packets forwarded to the port</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="4">
          <name>NoPacket_In</name>
          <synopsis>Do not send packet-in messages for port</synopsis>
          <typeRef>boolean</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>PortStateType</name>
      <synopsis>Current State of the port</synopsis>
      <struct>
        <component componentID="1">
          <name>LinkDown</name>
          <synopsis>No physical link present</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="2">
          <name>PortBlocked</name>
          <synopsis>Port is blocked</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="3">
          <name>PortLive</name>
          <synopsis>Live for Fast Failover Group</synopsis>
          <typeRef>boolean</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>PortFeaturesType</name>
      <synopsis>Port Features</synopsis>
      <struct>
        <component componentID="1">
          <name>SpeedTypes</name>
          <synopsis>Types of Speed supported</synopsis>
          <struct>
            <component componentID="1">
              <name>10MB_HD</name>
              <synopsis>10 Mb half-duplex rate support.</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="2">
              <name>10MB_FD</name>
              <synopsis>10 Mb full-duplex rate support.</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="3">
              <name>100MB_HD</name>
              <synopsis>100 Mb half-duplex rate support.</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="4">
              <name>100MB_FD</name>
              <synopsis>100 Mb full-duplex rate support.</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="5">
              <name>1GB_HD</name>
              <synopsis>1 Gb half-duplex rate support.</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="6">
              <name>1GB_FD</name>
              <synopsis>1 Gb full-duplex rate support.</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="7">
              <name>10GB_FD</name>
              <synopsis>10 Gb full-duplex rate support.</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="8">
              <name>40GB_FD</name>
              <synopsis>40 Gb full-duplex rate support.</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="9">
              <name>100GB_FD</name>
              <synopsis>100 Gb full-duplex rate support.</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="10">
              <name>1TB_FD</name>
              <synopsis>1 Tb full-duplex rate support.</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="11">
              <name>Other</name>
              <synopsis>Other rate, not listed.</synopsis>
              <typeRef>boolean</typeRef>
            </component>
          </struct>
        </component>
        <component componentID="2">
          <name>MediumConnected</name>
          <synopsis>Medium Connected to the port</synopsis>
          <struct>
            <component componentID="1">
              <name>Copper</name>
              <synopsis>Copper Medium</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="2">
              <name>Fiber</name>
              <synopsis>Fiber Medium</synopsis>
              <typeRef>boolean</typeRef>
            </component>
          </struct>
        </component>
        <component componentID="3">
          <name>Auto</name>
          <synopsis>Auto-negotiation</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="4">
          <name>PauseTypes</name>
          <synopsis>Pause Types supported of the port</synopsis>
          <struct>
            <component componentID="1">
              <name>Pause</name>
              <synopsis>Pause</synopsis>
              <typeRef>boolean</typeRef>
            </component>
            <component componentID="2">
              <name>AsymmetricPause</name>
              <synopsis>Asymmetric pause</synopsis>
              <typeRef>boolean</typeRef>
            </component>
          </struct>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>PortCounterType</name>
      <synopsis>Counter per port</synopsis>
      <struct>
        <component componentID="1">
          <name>ReceivedPackets</name>
          <synopsis>Packets Received</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="2">
          <name>TransmittedPackets</name>
          <synopsis>Packets Transmitted</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="3">
          <name>ReceivedBytes</name>
          <synopsis>Bytes Received</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="4">
          <name>TransmittedBytes</name>
          <synopsis>Bytes Transmitted</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="5">
          <name>ReceivedDrops</name>
          <synopsis>Drops Received</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="6">
          <name>TransmitDrops</name>
          <synopsis>Transmit Drops</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="7">
          <name>RecieveErrors</name>
          <synopsis>Errors in reception</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="8">
          <name>TransmitErrors</name>
          <synopsis>Errors in transmittion</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="9">
          <name>ReceivedFrameAlignmentErrors</name>
          <synopsis>Frame Alignment Errors received</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="10">
          <name>ReceiveOverrunErrors</name>
          <synopsis>Received Overrun Errors</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="11">
          <name>ReceivedCRCErrors</name>
          <synopsis>CRC Errors in received packets</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="12">
          <name>Collisions</name>
          <synopsis>Collisions</synopsis>
          <typeRef>uint64</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <!-- Data Type definitions for Queues -->
    <dataTypeDef>
      <name>QueuePropertyType</name>
      <synopsis>Property type for a queue</synopsis>
      <atomic>
        <baseType>uint16</baseType>
        <specialValues>
          <specialValue value="0">
            <name>None</name>
            <synopsis>No property defined</synopsis>
          </specialValue>
          <specialValue value="1">
            <name>MinimumRate</name>
            <synopsis>Minimum datarate guaranteed</synopsis>
          </specialValue>
        </specialValues>
      </atomic>
    </dataTypeDef>
    <dataTypeDef>
      <name>QueueArrayPropertiesType</name>
      <synopsis>Type Definition for property</synopsis>
      <struct>
        <component componentID="1">
          <name>Property</name>
          <synopsis>One of Queue Priority Types</synopsis>
          <typeRef>QueuePropertyType</typeRef>
        </component>
        <component componentID="2">
          <name>Length</name>
          <synopsis>Length of property</synopsis>
          <typeRef>uint32</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>QueueCounterType</name>
      <synopsis>Counters per queue</synopsis>
      <struct>
        <component componentID="1">
          <name>TransmitPackets</name>
          <synopsis>Packets Transmitted</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="2">
          <name>TransmitBytes</name>
          <synopsis>Bytes Transmitted</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="3">
          <name>TransimtOverrunErrors</name>
          <synopsis>Overrun Errors</synopsis>
          <typeRef>uint64</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <!-- Datatype Def for ActionSet LFB-->
    <dataTypeDef>
      <name>ActionSetType</name>
      <synopsis>The action set type. 9 possible values.</synopsis>
      <atomic>
        <baseType>uchar</baseType>
        <specialValues>
          <specialValue value="0">
            <name>CopyTTLoutwards</name>
            <synopsis>Copy TTL Outwards</synopsis>
          </specialValue>
          <specialValue value="1">
            <name>Pop</name>
            <synopsis>Pop action</synopsis>
          </specialValue>
          <specialValue value="2">
            <name>Push</name>
            <synopsis>Push action</synopsis>
          </specialValue>
          <specialValue value="3">
            <name>CopyTTLinwards</name>
            <synopsis>Copy TTL inwards</synopsis>
          </specialValue>
          <specialValue value="4">
            <name>DecrementTTL</name>
            <synopsis>Decrement TTL</synopsis>
          </specialValue>
          <specialValue value="5">
            <name>Set</name>
            <synopsis>SetAction</synopsis>
          </specialValue>
          <specialValue value="6">
            <name>Qos</name>
            <synopsis>Qos action, such as set queue</synopsis>
          </specialValue>
          <specialValue value="7">
            <name>Group</name>
            <synopsis>Group action</synopsis>
          </specialValue>
          <specialValue value="8">
            <name>Output</name>
            <synopsis>Output Action</synopsis>
          </specialValue>
        </specialValues>
      </atomic>
    </dataTypeDef>
    <dataTypeDef>
      <name>ActionSetRowType</name>
      <synopsis>The ActionSet Row Type</synopsis>
      <struct>
        <component componentID="1">
          <name>ActionType</name>
          <synopsis>The type of action for the action set.</synopsis>
          <typeRef>ActionSetType</typeRef>
        </component>
        <component componentID="2">
          <name>LFBClassID</name>
          <synopsis>The LFBClassID this action is supposed to
          go</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="3">
          <name>LFBInstanceID</name>
          <synopsis>The LFBInstanceID this action is supposed to
          go</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="4">
          <name>ActionTableIndex</name>
          <synopsis>The index of the action in the LFBClass.LFBInstance
          If the LFB class is a group, then the index is the group
          index.</synopsis>
          <typeRef>uint32</typeRef>
        </component>
      </struct>
    </dataTypeDef>
    <dataTypeDef>
      <name>ActionSetPacket</name>
      <synopsis>The Action Set per packet.</synopsis>
      <array maxLength="9">
        <typeRef>ActionSetRowType</typeRef>
        <contentKey contentKeyID="1">
          <contentKeyField>ActionType</contentKeyField>
        </contentKey>
      </array>
    </dataTypeDef>
  </dataTypeDefs>
  <metadataDefs>
    <metadataDef>
      <name>IngressPort</name>
      <synopsis>The Ingress port the packet has arrived from</synopsis>
      <metadataID>1024</metadataID>
      <typeRef>uint32</typeRef>
    </metadataDef>
    <metadataDef>
      <name>ActionSetIndex</name>
      <synopsis>The action set that is passed along flow tables. This
      is an index that points to the array in the
      ActionSetLFB</synopsis>
      <metadataID>1025</metadataID>
      <typeRef>uint32</typeRef>
    </metadataDef>
    <metadataDef>
      <name>Arbitrary</name>
      <synopsis>Arbitrary metadata of uint64</synopsis>
      <metadataID>1026</metadataID>
      <typeRef>uint64</typeRef>
    </metadataDef>
    <metadataDef>
      <name>FlowTableInstanceID</name>
      <synopsis>The FlowTableInstanceID metadata is used to reference
      the Flow Table from which a packet has been sent from.</synopsis>
      <metadataID>1027</metadataID>
      <typeRef>uint32</typeRef>
    </metadataDef>
    <metadataDef>
      <name>ActionIndex</name>
      <synopsis>The Action Index metadata is used to point the row in
      the array in an Action LFB </synopsis>
      <metadataID>1028</metadataID>
      <typeRef>uint32</typeRef>
    </metadataDef>
    <metadataDef>
      <name>GroupIndex</name>
      <synopsis>The Group index metadata is used to point to the row of
      the array in an Group LFB</synopsis>
      <metadataID>1029</metadataID>
      <typeRef>uint32</typeRef>
    </metadataDef>
    <metadataDef>
      <name>LFBClassIDMetadata</name>
      <synopsis>The LFBClassID</synopsis>
      <metadataID>1030</metadataID>
      <typeRef>uint32</typeRef>
    </metadataDef>
    <metadataDef>
      <name>LFBInstanceIDMetadata</name>
      <synopsis>The LFBInstanceID</synopsis>
      <metadataID>1031</metadataID>
      <typeRef>uint32</typeRef>
    </metadataDef>
  </metadataDefs>
  <LFBClassDefs>
    <!-- OpenFlow Switch LFB -->
    <LFBClassDef LFBClassID="1024">
      <name>OFSwitchLFB</name>
      <synopsis>Similar to the FEProtocol and FEObject LFB, the
      OpenFlowSwitch LFB contains information required for the openflow
      protocol.</synopsis>
      <version>1.1</version>
      <components>
        <component componentID="1" access="read-only">
          <name>DatapathID</name>
          <synopsis>Datapath unique ID. The lower 48-bits are for a MAC
          address, while the upper 16-bits are
          implementer-defined.</synopsis>
          <typeRef>uint64</typeRef>
        </component>
        <component componentID="4" access="read-write">
          <name>MissSendLen</name>
          <synopsis>Max bytes of new flow that datapath should send to
          the controller.</synopsis>
          <typeRef>uint16</typeRef>
        </component>
        <component componentID="5" access="read-write">
          <name>HandleFragments</name>
          <synopsis>if true drop fragments. If false no special
          handling.</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="6" access="read-write">
          <name>ReassembleFragments</name>
          <synopsis>If true, reassemble fragments</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="7" access="read-write">
          <name>InvalidTTLtoController</name>
          <synopsis>Send packets with invalid TTL ie. 0 or 1 to
          controller</synopsis>
          <typeRef>boolean</typeRef>
        </component>
        <component componentID="8" access="read-only">
          <name>SwitchDescription</name>
          <synopsis>Information about the switch</synopsis>
          <typeRef>SwitchDescriptionType</typeRef>
        </component>
        <component componentID="9" access="read-write">
          <name>Ports</name>
          <synopsis>The Ports that this switch has. It is an array of
          the Port Numbers</synopsis>
          <array>
            <typeRef>uint32</typeRef>
          </array>
        </component>
      </components>
      <capabilities>
        <capability componentID="31">
          <name>FlowStatistics</name>
          <synopsis>Whether the switch keep flow statistics</synopsis>
          <typeRef>boolean</typeRef>
        </capability>
        <capability componentID="32">
          <name>TableStatistics</name>
          <synopsis>Whether the switch keep table statistics</synopsis>
          <typeRef>boolean</typeRef>
        </capability>
        <capability componentID="33">
          <name>PortStatistics</name>
          <synopsis>Whether the switch keep port statistics</synopsis>
          <typeRef>boolean</typeRef>
        </capability>
        <capability componentID="34">
          <name>GroupStatistics</name>
          <synopsis>Whether the switch keep group statistics</synopsis>
          <typeRef>boolean</typeRef>
        </capability>
        <capability componentID="35">
          <name>IPReassembly</name>
          <synopsis>Whether the switch can reassemble IP
          fragments</synopsis>
          <typeRef>boolean</typeRef>
        </capability>
        <capability componentID="36">
          <name>QueueStats</name>
          <synopsis>Whether the switch keeps queue
          statistics</synopsis>
          <typeRef>boolean</typeRef>
        </capability>
        <capability componentID="37">
          <name>ARPMatchIP</name>
          <synopsis>Whether the switch matches IP addresses in APR
          packets</synopsis>
          <typeRef>boolean</typeRef>
        </capability>
        <capability componentID="38">
          <name>ActionsSupported</name>
          <synopsis>What actions are supported</synopsis>
          <array>
            <atomic>
              <baseType>ActionType</baseType>
              <rangeRestriction>
                <allowedRange max="65534" min="0"/>
              </rangeRestriction>
            </atomic>
            <contentKey contentKeyID="1">
              <contentKeyField>ActionType</contentKeyField>
            </contentKey>
          </array>
        </capability>
        <capability componentID="39">
          <name>MaxBufferedPackets</name>
          <synopsis>Maximum packets buffered at once.</synopsis>
          <typeRef>uint32</typeRef>
        </capability>
        <capability componentID="40">
          <name>TablesSupported</name>
          <synopsis>Number of tables supported by the
          datapath</synopsis>
          <typeRef>uchar</typeRef>
        </capability>
      </capabilities>
      <events baseID="61">
        <event eventID="1">
          <name>PortAdded</name>
          <synopsis>This event is sent when a port is added</synopsis>
          <eventTarget>
            <eventField>Ports</eventField>
          </eventTarget>
          <eventCreated/>
        </event>
        <event eventID="2">
          <name>PortDeleted</name>
          <synopsis>This event is sent when a port is
          deleted</synopsis>
          <eventTarget>
            <eventField>Ports</eventField>
          </eventTarget>
          <eventDeleted/>
        </event>
        <event eventID="3">
          <name>PortModified</name>
          <synopsis>This event is sent when a port is
          modified</synopsis>
          <eventTarget>
            <eventField>Ports</eventField>
          </eventTarget>
          <eventChanged/>
        </event>
      </events>
    </LFBClassDef>
    <!--FlowTable LFB -->
    <LFBClassDef LFBClassID="1025">
      <name>OFFlowTableLFB</name>
      <synopsis>An OpenFlow Flow Table</synopsis>
      <version>1.1</version>
      <inputPorts>
        <inputPort group="true">
          <name>InputPort</name>
          <synopsis>An Input port that expects packets from a port or
          another Flow Table</synopsis>
          <expectation>
            <frameExpected>
              <ref>Arbitrary</ref>
            </frameExpected>
            <metadataExpected>
              <one-of>
                <metadataSet>
                  <ref>IngressPort</ref>
                  <ref>ActionSetIndex</ref>
                  <ref>Arbitrary</ref>
                </metadataSet>
                <ref>IngressPort</ref>
              </one-of>
            </metadataExpected>
          </expectation>
        </inputPort>
        <inputPort group="true">
          <name>PacketReturn</name>
          <synopsis>A port that expects the packet to be returned from
          an OFActionLFB</synopsis>
          <expectation>
            <frameExpected>
              <ref>Arbitrary</ref>
            </frameExpected>
          </expectation>
        </inputPort>
      </inputPorts>
      <outputPorts>
        <outputPort group="true">
          <name>OutputPort</name>
          <synopsis>An Output port that produces packets after having
          been checked against the flow table along with metadata. A
          packet may leave this flow table to go to the next flow
          table, any flow table if a goto-table instruction is invoked,
          or into the GroupTable.</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
            <metadataProduced>
              <ref>IngressPort</ref>
              <ref>ActionSet</ref>
              <ref>Arbitrary</ref>
            </metadataProduced>
          </product>
        </outputPort>
        <outputPort group="true">
          <name>ActionPort</name>
          <synopsis>A port that sends the packet to an
          OFActionLFB</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
            <metadataProduced>
              <one-of>
                <metadataSet>
                  <ref>LFBClassIDMetadata</ref>
                  <ref>LFBInstanceIDMetadata</ref>
                </metadataSet>
                <metadataSet>
                  <ref>LFBClassIDMetadata</ref>
                  <ref>LFBInstanceIDMetadata</ref>
                  <ref>ActionIndex</ref>
                </metadataSet>
              </one-of>
            </metadataProduced>
          </product>
        </outputPort>
        <outputPort group="false">
          <name>Drop</name>
          <synopsis>A port for dropping packets</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
      </outputPorts>
      <components>
        <component componentID="1" access="read-only">
          <name>FlowTableID</name>
          <synopsis>The flow table sequence number</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="2" access="read-write">
          <name>FlowEntries</name>
          <synopsis>Flow entries inside the FlowTable LFB</synopsis>
          <array>
            <typeRef>FlowEntry</typeRef>
          </array>
        </component>
        <component componentID="3" access="read-only">
          <name>FlowTableCounter</name>
          <synopsis>A counter for the whole Flow Table</synopsis>
          <typeRef>TableCounterType</typeRef>
        </component>
        <component componentID="4" access="read-write">
          <name>ApplyActionTable</name>
          <synopsis>Table of actions for each flow</synopsis>
          <array>
            <typeRef>Actions</typeRef>
          </array>
        </component>
        <component componentID="5" access="read-write">
          <name>WriteActions</name>
          <synopsis>Table of Actions to write to the
          ActionSet</synopsis>
          <array>
            <typeRef>Actions</typeRef>
          </array>
        </component>
        <component componentID="6" access="read-write">
          <name>WriteMetadataTable</name>
          <synopsis>The write MetaDataTable</synopsis>
          <array>
            <typeRef>WriteMetadataTableType</typeRef>
          </array>
        </component>
        <component componentID="7" access="read-write">
          <name>GotoFlowTable</name>
          <synopsis>Containing the FlowTable IDs this flow should go
          to.</synopsis>
          <array>
            <typeRef>uchar</typeRef>
          </array>
        </component>
        <component componentID="8" access="read-write">
          <name>GroupTable</name>
          <synopsis>Table of group indeces to point a packet
          to</synopsis>
          <array>
            <typeRef>uint32</typeRef>
          </array>
        </component>
        <component componentID="9" access="read-only">
          <name>ActionSet</name>
          <synopsis>The action set that may be changed. This table
          resides in the ActionSetLFB</synopsis>
          <alias>ActionSetTable</alias>
        </component>
        <component componentID="10" access="read-write">
          <name>MissBehaviour</name>
          <synopsis>What should the FlowTable do if a miss
          occurs</synopsis>
          <typeRef>FlowTableMissConfigType</typeRef>
        </component>
        <component componentID="11" access="read-only">
          <name>Buffer</name>
          <synopsis>Buffer of packets waiting for a packet-out
          message</synopsis>
          <array>
            <struct>
              <component componentID="1">
                <name>BufferID</name>
                <synopsis>ID assigned by datapath</synopsis>
                <typeRef>uint32</typeRef>
              </component>
              <component componentID="2">
                <name>Reason</name>
                <synopsis>Reason pacekt is being sent</synopsis>
                <typeRef>BufferReasonTypes</typeRef>
              </component>
            </struct>
          </array>
        </component>
      </components>
      <events baseID="61">
        <event eventID="1">
          <name>FlowRemoved</name>
          <synopsis>If a CE subscribes to this event, it will send an
          event when a flow is removed.</synopsis>
          <eventTarget>
            <eventField>FlowEntries</eventField>
            <eventSubscript>FlowEntry</eventSubscript>
          </eventTarget>
          <eventDeleted/>
          <eventReports>
            <eventReport>
              <eventField>FlowTableID</eventField>
            </eventReport>
            <eventReport>
              <eventField>FlowEntries</eventField>
              <eventSubscript>FlowEntry</eventSubscript>
              <eventField>Cookie</eventField>
            </eventReport>
            <eventReport>
              <eventField>FlowEntries</eventField>
              <eventSubscript>FlowEntry</eventSubscript>
              <eventField>MatchFields</eventField>
            </eventReport>
            <eventReport>
              <eventField>FlowEntries</eventField>
              <eventSubscript>FlowEntry</eventSubscript>
              <eventField>Timeouts</eventField>
              <eventSubscript>IdleTimeout</eventSubscript>
            </eventReport>
            <eventReport>
              <eventField>FlowEntries</eventField>
              <eventSubscript>FlowEntry</eventSubscript>
              <eventField>Priority</eventField>
            </eventReport>
          </eventReports>
        </event>
      </events>
    </LFBClassDef>
    <!-- GroupTable LFB -->
    <LFBClassDef LFBClassID="1026">
      <name>OFGroupTableLFB</name>
      <synopsis>An OpenFlow Group Table</synopsis>
      <version>1.1</version>
      <inputPorts>
        <inputPort group="true">
          <name>PacketIn</name>
          <synopsis>A port to expect packets, the GroupIndex metadata
          and optionally a FlowTable Index. If only GroupIndex is
          received, then the packet has arrived from the ActionSet
          LFB.</synopsis>
          <expectation>
            <frameExpected>
              <ref>Arbitrary</ref>
            </frameExpected>
            <metadataExpected>
              <ref>LFBClassIDMetadata</ref>
              <ref>LFBInstanceIDMetadata</ref>
              <ref>GroupIndex</ref>
            </metadataExpected>
          </expectation>
        </inputPort>
        <inputPort group="true">
          <name>PacketReturn</name>
          <synopsis>A port that expects the packet to be returned from
          an OFActionLFB</synopsis>
          <expectation>
            <frameExpected>
              <ref>Arbitrary</ref>
            </frameExpected>
          </expectation>
        </inputPort>
      </inputPorts>
      <outputPorts>
        <outputPort group="true">
          <name>PacketOut</name>
          <synopsis>The port to return the packet to caller</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
        <outputPort group="true">
          <name>ActionPort</name>
          <synopsis>A port that sends the packet to an
          OFActionLFB</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
            <metadataProduced>
              <one-of>
                <metadataSet>
                  <ref>LFBClassIDMetadata</ref>
                  <ref>LFBInstanceIDMetadata</ref>
                </metadataSet>
                <metadataSet>
                  <ref>LFBClassIDMetadata</ref>
                  <ref>LFBInstanceIDMetadata</ref>
                  <ref>ActionIndex</ref>
                </metadataSet>
              </one-of>
            </metadataProduced>
          </product>
        </outputPort>
      </outputPorts>
      <components>
        <component componentID="1">
          <name>GroupTable</name>
          <synopsis>The group table</synopsis>
          <array>
            <typeRef>GroupTableEntry</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <!-- Port LFB -->
    <LFBClassDef LFBClassID="1027">
      <name>OFPortLFB</name>
      <synopsis>Input or Output port of an OpenFlow switch</synopsis>
      <version>1.1</version>
      <inputPorts>
        <inputPort group="true">
          <name>PacketOut</name>
          <synopsis>The input port of the Port LFB from other LFBs to
          put packets on the wire.</synopsis>
          <expectation>
            <frameExpected>
              <ref>Arbitrary</ref>
            </frameExpected>
          </expectation>
        </inputPort>
      </inputPorts>
      <outputPorts>
        <outputPort group="false">
          <name>PacketIn</name>
          <synopsis>The input port of the port from the wire. It 
          expects any kind of frame and passes it to the first
          FlowTable.</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
            <metadataProduced>
              <ref>IngressPort</ref>
            </metadataProduced>
          </product>
        </outputPort>
      </outputPorts>
      <components>
        <component componentID="1" access="read-only">
          <name>PortNumber</name>
          <synopsis>The port number uniquely identifies a port within a
          switch.</synopsis>
          <typeRef>PortNumberType</typeRef>
        </component>
        <component componentID="2" access="read-only">
          <name>IEEEMAC</name>
          <synopsis>MAC Address of the port</synopsis>
          <typeRef>IEEEMAC</typeRef>
        </component>
        <component componentID="3" access="read-only">
          <name>Name</name>
          <synopsis>Human readable name of the port</synopsis>
          <typeRef>string[16]</typeRef>
        </component>
        <component componentID="4" access="read-write">
          <name>Configuration</name>
          <synopsis>Configuration of the port</synopsis>
          <typeRef>PortConfigurationType</typeRef>
        </component>
        <component componentID="5" access="read-only">
          <name>State</name>
          <synopsis>State of the OpenFlow Switch</synopsis>
          <typeRef>PortState</typeRef>
        </component>
        <component componentID="6" access="read-only">
          <name>CurrentFeatures</name>
          <synopsis>Current features of the port</synopsis>
          <typeRef>PortFeaturesType</typeRef>
        </component>
        <component componentID="7" access="read-write">
          <name>Advertised</name>
          <synopsis>Features advertised by the port</synopsis>
          <typeRef>PortFeaturesType</typeRef>
        </component>
        <component componentID="8" access="read-only">
          <name>CurrentSpeed</name>
          <synopsis>Current port bitrate in kbps</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="9" access="read-only">
          <name>MaximumSpeed</name>
          <synopsis>Maximum port bitrate in kbps</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="10" access="read-only">
          <name>PortCounter</name>
          <synopsis>Counters for the port</synopsis>
          <typeRef>PortCounterType</typeRef>
        </component>
      </components>
      <capabilities>
        <capability componentID="31">
          <name>Supported</name>
          <synopsis>Features Supported by the port</synopsis>
          <typeRef>PortFeaturesType</typeRef>
        </capability>
        <capability componentID="32">
          <name>Peer</name>
          <synopsis>Features advertised by the peer</synopsis>
          <typeRef>PortFeaturesType</typeRef>
        </capability>
      </capabilities>
    </LFBClassDef>
    <!-- Queue LFB -->
    <LFBClassDef LFBClassID="1028">
      <name>OFQueueLFB</name>
      <synopsis>A queue LFB that can be attached to a port and be used
      to map flows on it. Flows mapped to a queue will be treated
      according to that queue's configuration</synopsis>
      <version>1.1</version>
      <inputPorts>
        <inputPort group="true">
          <name>PacketIn</name>
          <synopsis>An input port that expects any kind of
          frame.</synopsis>
          <expectation>
            <frameExpected>
              <ref>Arbitrary</ref>
            </frameExpected>
          </expectation>
        </inputPort>
      </inputPorts>
      <outputPorts>
        <outputPort group="false">
          <name>PacketOut</name>
          <synopsis>The output port that produces any kind of frame and
          passes it along to the OFPortLFB to be sent on the
          wire</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
      </outputPorts>
      <components>
        <component componentID="1" access="read-only">
          <name>QueueID</name>
          <synopsis>ID for the specific queue</synopsis>
          <typeRef>uint32</typeRef>
        </component>
        <component componentID="2" access="read-only">
          <name>Length</name>
          <synopsis>Length in bytes of this queue</synopsis>
          <typeRef>uint16</typeRef>
        </component>
        <component componentID="3" access="read-write">
          <name>Properties</name>
          <synopsis>List of queue properties</synopsis>
          <array>
            <typeRef>QueueArrayPropertiesType</typeRef>
          </array>
        </component>
        <component componentID="4" access="read-only">
          <name>QueueCounter</name>
          <synopsis>Counters for the queue</synopsis>
          <typeRef>QueueCounterType</typeRef>
        </component>
      </components>
    </LFBClassDef>
    <!-- Action Set LFB -->
    <LFBClassDef LFBClassID="1029">
      <name>OFActionSetLFB</name>
      <synopsis>An LFB that contains all action sets for each
      packet</synopsis>
      <version>1.1</version>
      <inputPorts>
        <inputPort group="true">
          <name>InputPort</name>
          <synopsis>An Input port that expects packets from Flow
          Tables</synopsis>
          <expectation>
            <frameExpected>
              <ref>Arbitrary</ref>
            </frameExpected>
            <metadataExpected>
              <metadataSet>
                <ref>IngressPort</ref>
                <ref>ActionSetIndex</ref>
                <ref>Arbitrary</ref>
              </metadataSet>
            </metadataExpected>
          </expectation>
        </inputPort>
        <inputPort group="true">
          <name>PacketReturn</name>
          <synopsis>A port that expects the packet to be returned from
          an OFActionLFB</synopsis>
          <expectation>
            <frameExpected>
              <ref>Arbitrary</ref>
            </frameExpected>
          </expectation>
        </inputPort>
      </inputPorts>
      <outputPorts>
        <outputPort group="true">
          <name>ActionPort</name>
          <synopsis>A port that sends the packet to an
          OFActionLFB</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
            <metadataProduced>
              <one-of>
                <metadataSet>
                  <ref>LFBClassIDMetadata</ref>
                  <ref>LFBInstanceIDMetadata</ref>
                </metadataSet>
                <metadataSet>
                  <ref>LFBClassIDMetadata</ref>
                  <ref>LFBInstanceIDMetadata</ref>
                  <ref>ActionIndex</ref>
                </metadataSet>
              </one-of>
            </metadataProduced>
          </product>
        </outputPort>
      </outputPorts>
      <components>
        <component componentID="1" access="read-only">
          <name>ActionSetTable</name>
          <synopsis>Table of actions for each flow</synopsis>
          <array>
            <typeRef>ActionSetPacket</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <!-- Action LFBs -->
    <LFBClassDef LFBClassID="1030">
      <name>OFActionLFB</name>
      <synopsis>An LFB that performs one specific action on a packet in
      the OpenFlow switch. The OFActionLFB expects any kind of packet
      and as metadata the FlowTableInstanceID to know from which Flow
      Table the packet has arrived from and the Action Index to specify
      the row in the Action Table, if there is an Action
      table.</synopsis>
      <version>1.1</version>
      <inputPorts>
        <inputPort group="true">
          <name>PacketIn</name>
          <synopsis>An input port that gets the packet to perform the
          action on. Expects the ClassID and InstanceID of the LFB that
          calls it to know to which LFB to return it to. Can accept
          calls from OFActionLFBs or OFGroupLFB or
          OFActionSetLFB</synopsis>
          <expectation>
            <frameExpected>
              <ref>Arbitrary</ref>
            </frameExpected>
            <metadataExpected>
              <one-of>
                <metadataSet>
                  <ref>LFBClassIDMetadata</ref>
                  <ref>LFBInstanceIDMetadata</ref>
                </metadataSet>
                <metadataSet>
                  <ref>LFBClassIDMetadata</ref>
                  <ref>LFBInstanceIDMetadata</ref>
                  <ref>ActionIndex</ref>
                </metadataSet>
              </one-of>
            </metadataExpected>
          </expectation>
        </inputPort>
      </inputPorts>
      <outputPorts>
        <outputPort group="true">
          <name>PacketOut</name>
          <synopsis>The output port from which the packet will be send
          back to the Flow Table from which it came from.</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
      </outputPorts>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1031">
      <name>OFOutputOFActionLFB</name>
      <synopsis>An LFB that performs the Output Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <outputPorts>
        <outputPort group="true">
          <name>PortOutput</name>
          <synopsis>Send a copy of the packet to the specified
          port</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
        <outputPort group="true">
          <name>All</name>
          <synopsis>Send the packet out all standard ports, but not to
          the ingress port or ports configured not to
          forward</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
        <outputPort group="false">
          <name>Controller</name>
          <synopsis>Send the packet to the controller</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
        <outputPort group="false">
          <name>Table</name>
          <synopsis>Submit the packet to the first flow table so that
          the packet can be processed through the regular OpenFlow
          pipeline. Only valid in the aciton set of a packet-out
          message</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
        <outputPort group="false">
          <name>InPort</name>
          <synopsis>Send the packet out the ingress port.</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
        <outputPort group="false">
          <name>Local</name>
          <synopsis>Send the packet to the switch's local networking
          stack</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
        <outputPort group="false">
          <name>Normal</name>
          <synopsis>Process the packet using the traditional
          non-OpenFlow pipeline of the switch.</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
        <outputPort group="true">
          <name>Flood</name>
          <synopsis>Flood the packet using the normal pipeline of the
          switch.</synopsis>
          <product>
            <frameProduced>
              <ref>Arbitrary</ref>
            </frameProduced>
          </product>
        </outputPort>
      </outputPorts>
      <components>
        <component componentID="1" access="read-write">
          <name>OutputActionTable</name>
          <synopsis>Output to switch port</synopsis>
          <array>
            <struct>
              <component componentID="1">
                <name>Port</name>
                <synopsis>The port to send the packet out</synopsis>
                <typeRef>PortNumberType</typeRef>
              </component>
              <component componentID="2">
                <name>MaxLength</name>
                <synopsis>If the port is the controller sets the
                maximum number of bytes to send.</synopsis>
                <typeRef>uint16</typeRef>
              </component>
            </struct>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1032">
      <name>OFSetVLANVIDOFActionLFB</name>
      <synopsis>An LFB that performs the Set VLANID Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetVLANVIDActionTable</name>
          <synopsis>Set the 802.1q VLAN ID</synopsis>
          <array>
            <typeRef>uint16</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1033">
      <name>OFSetVLANPriorityOFActionLFB</name>
      <synopsis>An LFB that performs the Set VLAN Priority
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetVLANPriorityActionTable</name>
          <synopsis>Set the 802.1q VLAN Priority</synopsis>
          <array>
            <typeRef>uchar</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1034">
      <name>OFSetMACSourceOFActionLFB</name>
      <synopsis>An LFB that performs the Set MAC Source
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetMACSourceActionTable</name>
          <synopsis>Set MAC source address</synopsis>
          <array>
            <typeRef>IEEEMAC</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1035">
      <name>OFSetMACDestinationOFActionLFB</name>
      <synopsis>An LFB that performs the Set MAC Destionation
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetMACDestinationActionTable</name>
          <synopsis>Set MAC destination address</synopsis>
          <array>
            <typeRef>IEEEMAC</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1036">
      <name>OFSetIPSourceOFActionLFB</name>
      <synopsis>An LFB that performs the Set IP Source
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetIPSourceActionTable</name>
          <synopsis>Set the IP source address</synopsis>
          <array>
            <typeRef>IPv4Addr</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1037">
      <name>OFSetIPDestinationOFActionLFB</name>
      <synopsis>An LFB that performs the Set IP Destination
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetIPDestinationActionTable</name>
          <synopsis>Set the IP destination address</synopsis>
          <array>
            <typeRef>IPv4Addr</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1038">
      <name>OFSetIPTOSOFActionLFB</name>
      <synopsis>An LFB that performs the Set VLANID Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetIPTOSActionTable</name>
          <synopsis>Set IP ToS field</synopsis>
          <array>
            <typeRef>uchar</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1039">
      <name>OFSetIPECNOFActionLFB</name>
      <synopsis>An LFB that performs the Set IP ECN Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetIPECNActionTable</name>
          <synopsis>Set IP ECN field</synopsis>
          <array>
            <typeRef>uchar</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1040">
      <name>OFSetTCPSourceOFActionLFB</name>
      <synopsis>An LFB that performs the Set TCP/UDP/SCTP Source port
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetTCPSourceActionTable</name>
          <synopsis>Sets TCP/UDP/SCTP source port</synopsis>
          <array>
            <typeRef>uint16</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1041">
      <name>OFSetTCPDestinationOFActionLFB</name>
      <synopsis>An LFB that performs the Set TCP/UDP/SCTP Destination
      port Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetTCPDestinationActionTable</name>
          <synopsis>Sets TCP/UDP/SCTP destination port</synopsis>
          <array>
            <typeRef>uint16</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1042">
      <name>OFCopyTTLOutOFActionLFB</name>
      <synopsis>An LFB that performs the copy TTL outwards
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1043">
      <name>OFCopyTTLInOFActionLFB</name>
      <synopsis>An LFB that performs the copy TTL inwards
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1044">
      <name>OFSetMPLSLabelOFActionLFB</name>
      <synopsis>An LFB that performs the Set MPLS Label
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetMPLSLabelActionTable</name>
          <synopsis>Sets MPLS Label Table</synopsis>
          <array>
            <typeRef>uint32</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1045">
      <name>OFSetMPLSTCOFActionLFB</name>
      <synopsis>An LFB that performs the Set MPLS Traffic Class
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetMPLSTCActionTable</name>
          <synopsis>Sets MPLS Traffic Class Table</synopsis>
          <array>
            <typeRef>uchar</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1046">
      <name>OFSetMPLSTTLLFB</name>
      <synopsis>An LFB that performs the Set MPLS TTL Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetMPLSTTLTable</name>
          <synopsis>Sets MPLS TTL Table</synopsis>
          <array>
            <typeRef>uchar</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1047">
      <name>OFDecrementMPLSTTLOFActionLFB</name>
      <synopsis>An LFB that performs the decrementation of the MPLS TTL
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1048">
      <name>OFPushVLanLFB</name>
      <synopsis>An LFB that performs the Push VLAN Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>PushVLANTable</name>
          <synopsis>Push VLAN Table</synopsis>
          <array>
            <typeRef>uint16</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1049">
      <name>OFPopVLANLFB</name>
      <synopsis>An LFB that performs the Pop VLAN Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1050">
      <name>OFPushMPLSLFB</name>
      <synopsis>An LFB that performs the Push MPLS Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>PushMPLSTable</name>
          <synopsis>Push MPLS Table</synopsis>
          <array>
            <typeRef>uint16</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1051">
      <name>OFPopMPLSLFB</name>
      <synopsis>An LFB that performs the Pop MPLS Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>PopMPLSTable</name>
          <synopsis>Pop MPLS Table</synopsis>
          <array>
            <typeRef>uint16</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1052">
      <name>OFSetQueue</name>
      <synopsis>An LFB that performs the Set Queue Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetQueueTable</name>
          <synopsis>Sets Queue Table</synopsis>
          <array>
            <typeRef>uint32</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1053">
      <name>OFSetIPTTLLFB</name>
      <synopsis>An LFB that performs the Set IP TTL Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>SetIPTTLTable</name>
          <synopsis>Sets IP TTL Table</synopsis>
          <array>
            <typeRef>uchar</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1054">
      <name>OFDecrementIPTTLOFActionLFB</name>
      <synopsis>An LFB that performs the decrementation of the IP TTL
      Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
    </LFBClassDef>
    <LFBClassDef LFBClassID="1055">
      <name>OFExperimenter</name>
      <synopsis>An LFB that performs the Experimenter Action</synopsis>
      <version>1.1</version>
      <derivedFrom>OFActionLFB</derivedFrom>
      <components>
        <component componentID="1" access="read-write">
          <name>ExperimenterTable</name>
          <synopsis>Experimenter Table</synopsis>
          <array>
            <typeRef>uint32</typeRef>
          </array>
        </component>
      </components>
    </LFBClassDef>
  </LFBClassDefs>
</LFBLibrary>

7. Acknowledgements

The authors would like to thank Ahmad N. Quttoum and especially Jamal Hadi Salim, for discussions which helped shape this document.

8. IANA Considerations

(TBD)

9. Security Considerations

TBD

10. References

10.1. Normative References

, "
[RFC3654] Khosravi, H. and T. Anderson, "Requirements for Separation of IP Control and Forwarding", RFC 3654, November 2003.
[RFC3746] Yang, L., Dantu, R., Anderson, T. and R. Gopal, "Forwarding and Control Element Separation (ForCES) Framework", RFC 3746, April 2004.
[RFC5810] Doria, A., Hadi Salim, J., Haas, R., Khosravi, H., Wang, W., Dong, L., Gopal, R. and J. Halpern, "Forwarding and Control Element Separation (ForCES) Protocol Specification", RFC 5810, March 2010.
[RFC5811] Hadi Salim, J. and K. Ogawa, "SCTP-Based Transport Mapping Layer (TML) for the Forwarding and Control Element Separation (ForCES) Protocol", RFC 5811, March 2010.
[RFC5812] Halpern, J. and J. Hadi Salim, "Forwarding and Control Element Separation (ForCES) Forwarding Element Model", RFC 5812, March 2010.
[RFC5813] Haas, R., "Forwarding and Control Element Separation (ForCES) MIB", RFC 5813, March 2010.
[RFC6053] Haleplidis, E., Ogawa, K., Wang, W. and J. Hadi Salim, "Implementation Report for Forwarding and Control Element Separation (ForCES)", RFC 6053, November 2010.
[I-D.ietf-forces-lfb-lib] Wang, W, Haleplidis, E, Ogawa, K, Li, C and J Halpern, "ForCES Logical Function Block (LFB) Library", Internet-Draft draft-ietf-forces-lfb-lib-08, February 2012.
[OpenFlowSpec1.1] http://www.OpenFlow.org/, "The OpenFlow 1.1 Specification.", .
[McKeown]McKeown, N., Anderson, T., Balakrishnan, H., et al, "OpenFlow: enabling innovation in campus networks", ACM SIGCOMM Computer Communication Review. 2008, 38(2):69-74.", .

10.2. Informative References

[RFC2629] Rose, M.T., "Writing I-Ds and RFCs using XML", RFC 2629, June 1999.

Authors' Addresses

Evangelos Haleplidis University of Patras Department of Electrical & Computer Engineering Patras, 26500 Greece EMail: ehalep@ece.upatras.gr
Omar Cherkaoui University of Quebec in Montreal Montreal, Canada EMail: cherkaoui.omar@uqam.ca
Susan Hares Huawei USA EMail: shares@ndzh.com
Weiming Wang Zhejiang Gongshang University 18 Xuezheng Str., Xiasha University Town Hangzhou, 310018 P.R.China Phone: +86-571-28877721 EMail: wmwang@zjgsu.edu.cn