Skip to main content

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

The information below is for an old version of the document.
Document Type
This is an older version of an Internet-Draft whose latest revision state is "Expired".
Authors Evangelos Haleplidis , Omar Cherkaoui, Susan Hares , Weiming Wang
Last updated 2012-05-24
RFC stream (None)
Formats
Stream Stream state (No stream defined)
Consensus boilerplate Unknown
RFC Editor Note (None)
IESG IESG state I-D Exists
Telechat date (None)
Responsible AD (None)
Send notices to (None)
draft-haleplidis-forces-openflow-lib-00
Internet Engineering Task Force                            E. Haleplidis
Internet-Draft                                      University of Patras
Intended status: Informational                              O. Cherkaoui
Expires: November 26, 2012              University of Quebec in Montreal
                                                                S. Hares
                                                                  Huawei
                                                                 W. Wang
                                           Zhejiang Gongshang University
                                                            May 25, 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 November 26, 2012.

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

Haleplidis, et al.      Expires November 26, 2012               [Page 1]
Internet-Draft           ForCES OpenFlow library                May 2012

   (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 . . . . . . . . . . . . . . . . . . . . . . . . .  5
     1.1.  ForCES . . . . . . . . . . . . . . . . . . . . . . . . . .  5
     1.2.  OpenFlow . . . . . . . . . . . . . . . . . . . . . . . . .  5
   2.  Terminology and Conventions  . . . . . . . . . . . . . . . . .  7
     2.1.  Requirements Language  . . . . . . . . . . . . . . . . . .  7
     2.2.  Definitions  . . . . . . . . . . . . . . . . . . . . . . .  7
   3.  OpenFlow ForCES library  . . . . . . . . . . . . . . . . . . . 10
     3.1.  OpenFlow Specification . . . . . . . . . . . . . . . . . . 10
     3.2.  ForCES-based OpenFlow Specification  . . . . . . . . . . . 12
   4.  OpenFlow Base Types  . . . . . . . . . . . . . . . . . . . . . 17
     4.1.  Data Types . . . . . . . . . . . . . . . . . . . . . . . . 17
       4.1.1.  Atomic . . . . . . . . . . . . . . . . . . . . . . . . 17
       4.1.2.  Compound Struct  . . . . . . . . . . . . . . . . . . . 17
       4.1.3.  Compound Array . . . . . . . . . . . . . . . . . . . . 19
     4.2.  Frame Types  . . . . . . . . . . . . . . . . . . . . . . . 19
     4.3.  MetaData Types . . . . . . . . . . . . . . . . . . . . . . 19
   5.  OpenFlow LFBs  . . . . . . . . . . . . . . . . . . . . . . . . 21
     5.1.  OpenFlowSwitchLFB  . . . . . . . . . . . . . . . . . . . . 21
       5.1.1.  Data Handling  . . . . . . . . . . . . . . . . . . . . 21
       5.1.2.  Components . . . . . . . . . . . . . . . . . . . . . . 21
       5.1.3.  Capabilities . . . . . . . . . . . . . . . . . . . . . 22
       5.1.4.  Events . . . . . . . . . . . . . . . . . . . . . . . . 22
     5.2.  OFFlowTableLFB . . . . . . . . . . . . . . . . . . . . . . 22
       5.2.1.  Data Handling  . . . . . . . . . . . . . . . . . . . . 22
       5.2.2.  Components . . . . . . . . . . . . . . . . . . . . . . 24
       5.2.3.  Capabilities . . . . . . . . . . . . . . . . . . . . . 25
       5.2.4.  Events . . . . . . . . . . . . . . . . . . . . . . . . 25
     5.3.  OFGroupTableLFB  . . . . . . . . . . . . . . . . . . . . . 25
       5.3.1.  Data Handling  . . . . . . . . . . . . . . . . . . . . 25
       5.3.2.  Components . . . . . . . . . . . . . . . . . . . . . . 25
       5.3.3.  Capabilities . . . . . . . . . . . . . . . . . . . . . 26
       5.3.4.  Events . . . . . . . . . . . . . . . . . . . . . . . . 26
     5.4.  OFPortLFB  . . . . . . . . . . . . . . . . . . . . . . . . 26
       5.4.1.  Data Handling  . . . . . . . . . . . . . . . . . . . . 26
       5.4.2.  Components . . . . . . . . . . . . . . . . . . . . . . 26
       5.4.3.  Capabilities . . . . . . . . . . . . . . . . . . . . . 27
       5.4.4.  Events . . . . . . . . . . . . . . . . . . . . . . . . 27

Haleplidis, et al.      Expires November 26, 2012               [Page 2]
Internet-Draft           ForCES OpenFlow library                May 2012

     5.5.  OFQueueLFB . . . . . . . . . . . . . . . . . . . . . . . . 27
       5.5.1.  Data Handling  . . . . . . . . . . . . . . . . . . . . 27
       5.5.2.  Components . . . . . . . . . . . . . . . . . . . . . . 27
       5.5.3.  Capabilities . . . . . . . . . . . . . . . . . . . . . 28
       5.5.4.  Events . . . . . . . . . . . . . . . . . . . . . . . . 28
     5.6.  OFActionSetLFB . . . . . . . . . . . . . . . . . . . . . . 28
       5.6.1.  Data Handling  . . . . . . . . . . . . . . . . . . . . 28
       5.6.2.  Components . . . . . . . . . . . . . . . . . . . . . . 28
       5.6.3.  Capabilities . . . . . . . . . . . . . . . . . . . . . 28
       5.6.4.  Events . . . . . . . . . . . . . . . . . . . . . . . . 29
     5.7.  OFActionLFB  . . . . . . . . . . . . . . . . . . . . . . . 29
       5.7.1.  Data Handling  . . . . . . . . . . . . . . . . . . . . 29
       5.7.2.  Components . . . . . . . . . . . . . . . . . . . . . . 29
       5.7.3.  Capabilities . . . . . . . . . . . . . . . . . . . . . 29
       5.7.4.  Events . . . . . . . . . . . . . . . . . . . . . . . . 29
     5.8.  OFActionLFBs . . . . . . . . . . . . . . . . . . . . . . . 29
       5.8.1.  OFOutputOFActionLFB  . . . . . . . . . . . . . . . . . 29
       5.8.2.  OFSetVLANVIDOFActionLFB  . . . . . . . . . . . . . . . 30
       5.8.3.  OFSetVLANPriorityOFActionLFB . . . . . . . . . . . . . 30
       5.8.4.  OFSetMACSourceOFActionLFB  . . . . . . . . . . . . . . 31
       5.8.5.  OFSetMACDestinationOFActionLFB . . . . . . . . . . . . 31
       5.8.6.  OFSetIPSourceOFActionLFB . . . . . . . . . . . . . . . 31
       5.8.7.  OFSetIPDestinationOFActionLFB  . . . . . . . . . . . . 31
       5.8.8.  OFSetIPTOSOFActionLFB  . . . . . . . . . . . . . . . . 32
       5.8.9.  OFSetIPECNOFActionLFB  . . . . . . . . . . . . . . . . 32
       5.8.10. OFSetTCPSourceOFActionLFB  . . . . . . . . . . . . . . 32
       5.8.11. OFSetTCPDestinationOFActionLFB . . . . . . . . . . . . 32
       5.8.12. OFCopyTTLOutOFActionLFB  . . . . . . . . . . . . . . . 33
       5.8.13. OFCopyTTLInOFActionLFB . . . . . . . . . . . . . . . . 33
       5.8.14. OFSetMPLSLabelOFActionLFB  . . . . . . . . . . . . . . 33
       5.8.15. OFSetMPLSTCOFActionLFB . . . . . . . . . . . . . . . . 33
       5.8.16. OFSetMPLSTTLOFActionLFB  . . . . . . . . . . . . . . . 34
       5.8.17. OFDecrementMPLSTTLOFActionLFB  . . . . . . . . . . . . 34
       5.8.18. OFPushVLanOFActionLFB  . . . . . . . . . . . . . . . . 34
       5.8.19. OFPopVLANOFActionLFB . . . . . . . . . . . . . . . . . 35
       5.8.20. OFPushMPLSOFActionLFB  . . . . . . . . . . . . . . . . 35
       5.8.21. OFPopMPLSOFActionLFB . . . . . . . . . . . . . . . . . 35
       5.8.22. OFSetQueueOFActionLFB  . . . . . . . . . . . . . . . . 35
       5.8.23. OFSetIPTTLOFActionLFB  . . . . . . . . . . . . . . . . 36
       5.8.24. OFDecrementIPTTLOFActionLFB  . . . . . . . . . . . . . 36
       5.8.25. OFExperimenterOFActionLFB  . . . . . . . . . . . . . . 36
   6.  XML for OpenFlow library . . . . . . . . . . . . . . . . . . . 37
   7.  Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . 87
   8.  IANA Considerations  . . . . . . . . . . . . . . . . . . . . . 88
   9.  Security Considerations  . . . . . . . . . . . . . . . . . . . 89
   10. References . . . . . . . . . . . . . . . . . . . . . . . . . . 90
     10.1. Normative References . . . . . . . . . . . . . . . . . . . 90
     10.2. Informative References . . . . . . . . . . . . . . . . . . 91

Haleplidis, et al.      Expires November 26, 2012               [Page 3]
Internet-Draft           ForCES OpenFlow library                May 2012

   Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . . 92

Haleplidis, et al.      Expires November 26, 2012               [Page 4]
Internet-Draft           ForCES OpenFlow library                May 2012

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

Haleplidis, et al.      Expires November 26, 2012               [Page 5]
Internet-Draft           ForCES OpenFlow library                May 2012

   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.

Haleplidis, et al.      Expires November 26, 2012               [Page 6]
Internet-Draft           ForCES OpenFlow library                May 2012

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

Haleplidis, et al.      Expires November 26, 2012               [Page 7]
Internet-Draft           ForCES OpenFlow library                May 2012

      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.

Haleplidis, et al.      Expires November 26, 2012               [Page 8]
Internet-Draft           ForCES OpenFlow library                May 2012

      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.

Haleplidis, et al.      Expires November 26, 2012               [Page 9]
Internet-Draft           ForCES OpenFlow library                May 2012

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:

   a.  Forward to the OpenFlow controllers

   b.  Send to the next flow table

   c.  Drop the frame

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

Haleplidis, et al.      Expires November 26, 2012              [Page 10]
Internet-Draft           ForCES OpenFlow library                May 2012

   o  Apply a List of actions

   o  Clear the Action Set

   o  Write a List of actions on the action set

   o  Write Metadata

   o  Go to Flow Table

   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:

   o  Setting of a field

   o  Push or Pop tags

   o  Copy TTL inwards or outwards

   o  Decrease TTLs

   o  Output the packet

   o  Apply QoS to a packet

   o  Apply the packet to a group

   o  Additionally a Flow Table may drop the packet as an action.  The
      drop action is implicit based on the Flow Table's configuration.

   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

Haleplidis, et al.      Expires November 26, 2012              [Page 11]
Internet-Draft           ForCES OpenFlow library                May 2012

   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.

Haleplidis, et al.      Expires November 26, 2012              [Page 12]
Internet-Draft           ForCES OpenFlow library                May 2012

                        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

Haleplidis, et al.      Expires November 26, 2012              [Page 13]
Internet-Draft           ForCES OpenFlow library                May 2012

                      +---------+  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

   o  OFOutputOFActionLFB

   Set Queue Actions

   o  OFSetQueueOFActionLFB

   Push/Pop Tag Actions

   o  OFPushVLanOFActionLFB

   o  OFPopVLANOFActionLFB

   o  OFPushMPLSOFActionLFB

   o  OFPopMPLSOFActionLFB

   Set Actions

Haleplidis, et al.      Expires November 26, 2012              [Page 14]
Internet-Draft           ForCES OpenFlow library                May 2012

   o  OFSetMACSourceOFActionLFB

   o  OFSetMACDestinationOFActionLFB

   o  OFSetVLANVIDOFActionLFB

   o  OFSetVLANPriorityOFActionLFB

   o  OFSetMPLSLabelOFActionLFB

   o  OFSetMPLSTCOFActionLFB

   o  OFSetMPLSTTLOFActionLFB

   o  OFDecrementMPLSTTLOFActionLFB

   o  OFSetIPSourceOFActionLFB

   o  OFSetIPDestinationOFActionLFB

   o  OFSetIPTOSOFActionLFB

   o  OFSetIPECNOFActionLFB

   o  OFSetIPTTLOFActionLFB

   o  OFDecrementIPTTLOFActionLFB

   o  OFSetTCPSourceOFActionLFB

   o  OFSetTCPDestinationOFActionLFB

   o  OFCopyTTLOutOFActionLFB

   o  OFCopyTTLInOFActionLFB

   Experimenter Actions

   o  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

Haleplidis, et al.      Expires November 26, 2012              [Page 15]
Internet-Draft           ForCES OpenFlow library                May 2012

   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

Haleplidis, et al.      Expires November 26, 2012              [Page 16]
Internet-Draft           ForCES OpenFlow library                May 2012

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:

   +-------------------------+-----------------------------------------+
   | 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.  |
   +-------------------------+-----------------------------------------+

                           OpenFlow Atomic Types

4.1.2.  Compound Struct

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

Haleplidis, et al.      Expires November 26, 2012              [Page 17]
Internet-Draft           ForCES OpenFlow library                May 2012

   +--------------------------+----------------------------------------+
   | 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                 |
   +--------------------------+----------------------------------------+

                           OpenFlow Struct Types

Haleplidis, et al.      Expires November 26, 2012              [Page 18]
Internet-Draft           ForCES OpenFlow library                May 2012

4.1.3.  Compound Array

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

   +-----------------+-------------------------------------------------+
   | Data Type Name  | Brief Description                               |
   +-----------------+-------------------------------------------------+
   | Actions         | Actions to perform.  An Array of ActionRowTypes |
   |                 |                                                 |
   | ActionSetPacket | The Action Set per packet                       |
   +-----------------+-------------------------------------------------+

                           OpenFlow Array Types

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:

   +-----------------------+----------+--------------------------------+
   | MetaData Name         | MetaData | Brief Description              |
   |                       | ID       |                                |
   +-----------------------+----------+--------------------------------+
   | 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                         |
   |                       |          |                                |

Haleplidis, et al.      Expires November 26, 2012              [Page 19]
Internet-Draft           ForCES OpenFlow library                May 2012

   | LFBInstanceIDMetadata | 1031     | uint32                         |
   +-----------------------+----------+--------------------------------+

                          OpenFlow Metadata Types

Haleplidis, et al.      Expires November 26, 2012              [Page 20]
Internet-Draft           ForCES OpenFlow library                May 2012

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:

   o  Manufacturer description

   o  Hardware description

   o  Software description

   o  Serial Number

   o  Human readable description of datapath

   Lastly the Ports component is an array which contains in its rows,

Haleplidis, et al.      Expires November 26, 2012              [Page 21]
Internet-Draft           ForCES OpenFlow library                May 2012

   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:

   o  FlowStatistics.  If the switch keeps flow statistics

   o  TableStatistics.  If the switch keep table statistics

   o  PortStatistics.  If the switch keep port statistics

   o  GroupStatistics.  If the switch keep group statistics

   o  IPReassembly.  If the switch can reassemble IP fragments

   o  QueueStats.  If the switch keeps queue statistics

   o  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

Haleplidis, et al.      Expires November 26, 2012              [Page 22]
Internet-Draft           ForCES OpenFlow library                May 2012

   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

Haleplidis, et al.      Expires November 26, 2012              [Page 23]
Internet-Draft           ForCES OpenFlow library                May 2012

   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.

Haleplidis, et al.      Expires November 26, 2012              [Page 24]
Internet-Draft           ForCES OpenFlow library                May 2012

   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

Haleplidis, et al.      Expires November 26, 2012              [Page 25]
Internet-Draft           ForCES OpenFlow library                May 2012

   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.

Haleplidis, et al.      Expires November 26, 2012              [Page 26]
Internet-Draft           ForCES OpenFlow library                May 2012

   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:

   o  Types of Speed supported

   o  Medium Connected to the port

   o  Auto-negotiation

   o  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.

Haleplidis, et al.      Expires November 26, 2012              [Page 27]
Internet-Draft           ForCES OpenFlow library                May 2012

   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.

Haleplidis, et al.      Expires November 26, 2012              [Page 28]
Internet-Draft           ForCES OpenFlow library                May 2012

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:

Haleplidis, et al.      Expires November 26, 2012              [Page 29]
Internet-Draft           ForCES OpenFlow library                May 2012

      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.

Haleplidis, et al.      Expires November 26, 2012              [Page 30]
Internet-Draft           ForCES OpenFlow library                May 2012

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.

Haleplidis, et al.      Expires November 26, 2012              [Page 31]
Internet-Draft           ForCES OpenFlow library                May 2012

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.

Haleplidis, et al.      Expires November 26, 2012              [Page 32]
Internet-Draft           ForCES OpenFlow library                May 2012

   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

Haleplidis, et al.      Expires November 26, 2012              [Page 33]
Internet-Draft           ForCES OpenFlow library                May 2012

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.

Haleplidis, et al.      Expires November 26, 2012              [Page 34]
Internet-Draft           ForCES OpenFlow library                May 2012

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.

Haleplidis, et al.      Expires November 26, 2012              [Page 35]
Internet-Draft           ForCES OpenFlow library                May 2012

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.

Haleplidis, et al.      Expires November 26, 2012              [Page 36]
Internet-Draft           ForCES OpenFlow library                May 2012

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>

Haleplidis, et al.      Expires November 26, 2012              [Page 37]
Internet-Draft           ForCES OpenFlow library                May 2012

         <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 38]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 39]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 40]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 41]
Internet-Draft           ForCES OpenFlow library                May 2012

         </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">

Haleplidis, et al.      Expires November 26, 2012              [Page 42]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 43]
Internet-Draft           ForCES OpenFlow library                May 2012

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

Haleplidis, et al.      Expires November 26, 2012              [Page 44]
Internet-Draft           ForCES OpenFlow library                May 2012

             <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 45]
Internet-Draft           ForCES OpenFlow library                May 2012

           </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

Haleplidis, et al.      Expires November 26, 2012              [Page 46]
Internet-Draft           ForCES OpenFlow library                May 2012

       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

Haleplidis, et al.      Expires November 26, 2012              [Page 47]
Internet-Draft           ForCES OpenFlow library                May 2012

             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>

Haleplidis, et al.      Expires November 26, 2012              [Page 48]
Internet-Draft           ForCES OpenFlow library                May 2012

       <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 49]
Internet-Draft           ForCES OpenFlow library                May 2012

         </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.

Haleplidis, et al.      Expires November 26, 2012              [Page 50]
Internet-Draft           ForCES OpenFlow library                May 2012

             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>

Haleplidis, et al.      Expires November 26, 2012              [Page 51]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 52]
Internet-Draft           ForCES OpenFlow library                May 2012

         </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

Haleplidis, et al.      Expires November 26, 2012              [Page 53]
Internet-Draft           ForCES OpenFlow library                May 2012

             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>

Haleplidis, et al.      Expires November 26, 2012              [Page 54]
Internet-Draft           ForCES OpenFlow library                May 2012

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

Haleplidis, et al.      Expires November 26, 2012              [Page 55]
Internet-Draft           ForCES OpenFlow library                May 2012

               <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 56]
Internet-Draft           ForCES OpenFlow library                May 2012

               <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 57]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 58]
Internet-Draft           ForCES OpenFlow library                May 2012

     <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 59]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 60]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 61]
Internet-Draft           ForCES OpenFlow library                May 2012

     </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

Haleplidis, et al.      Expires November 26, 2012              [Page 62]
Internet-Draft           ForCES OpenFlow library                May 2012

           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>

Haleplidis, et al.      Expires November 26, 2012              [Page 63]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 64]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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

Haleplidis, et al.      Expires November 26, 2012              [Page 65]
Internet-Draft           ForCES OpenFlow library                May 2012

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

Haleplidis, et al.      Expires November 26, 2012              [Page 66]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 67]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 68]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 69]
Internet-Draft           ForCES OpenFlow library                May 2012

             <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 70]
Internet-Draft           ForCES OpenFlow library                May 2012

       </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>

Haleplidis, et al.      Expires November 26, 2012              [Page 71]
Internet-Draft           ForCES OpenFlow library                May 2012

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

Haleplidis, et al.      Expires November 26, 2012              [Page 72]
Internet-Draft           ForCES OpenFlow library                May 2012

           <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 73]
Internet-Draft           ForCES OpenFlow library                May 2012

     <!-- 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>

Haleplidis, et al.      Expires November 26, 2012              [Page 74]
Internet-Draft           ForCES OpenFlow library                May 2012

           </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

Haleplidis, et al.      Expires November 26, 2012              [Page 75]
Internet-Draft           ForCES OpenFlow library                May 2012

           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

Haleplidis, et al.      Expires November 26, 2012              [Page 76]
Internet-Draft           ForCES OpenFlow library                May 2012

           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>

Haleplidis, et al.      Expires November 26, 2012              [Page 77]
Internet-Draft           ForCES OpenFlow library                May 2012

           </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>

Haleplidis, et al.      Expires November 26, 2012              [Page 78]
Internet-Draft           ForCES OpenFlow library                May 2012

             <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 79]
Internet-Draft           ForCES OpenFlow library                May 2012

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

Haleplidis, et al.      Expires November 26, 2012              [Page 80]
Internet-Draft           ForCES OpenFlow library                May 2012

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

Haleplidis, et al.      Expires November 26, 2012              [Page 81]
Internet-Draft           ForCES OpenFlow library                May 2012

       <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

Haleplidis, et al.      Expires November 26, 2012              [Page 82]
Internet-Draft           ForCES OpenFlow library                May 2012

       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>

Haleplidis, et al.      Expires November 26, 2012              [Page 83]
Internet-Draft           ForCES OpenFlow library                May 2012

       <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 84]
Internet-Draft           ForCES OpenFlow library                May 2012

     <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>

Haleplidis, et al.      Expires November 26, 2012              [Page 85]
Internet-Draft           ForCES OpenFlow library                May 2012

         </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>

                           OpenFlow XML Library

Haleplidis, et al.      Expires November 26, 2012              [Page 86]
Internet-Draft           ForCES OpenFlow library                May 2012

7.  Acknowledgements

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

Haleplidis, et al.      Expires November 26, 2012              [Page 87]
Internet-Draft           ForCES OpenFlow library                May 2012

8.  IANA Considerations

   (TBD)

Haleplidis, et al.      Expires November 26, 2012              [Page 88]
Internet-Draft           ForCES OpenFlow library                May 2012

9.  Security Considerations

   TBD

Haleplidis, et al.      Expires November 26, 2012              [Page 89]
Internet-Draft           ForCES OpenFlow library                May 2012

10.  References

10.1.  Normative References

   [I-D.ietf-forces-lfb-lib]
              Wang, W., Haleplidis, E., Ogawa, K., Li, C., and J.
              Halpern, "ForCES Logical Function Block (LFB) Library",
              draft-ietf-forces-lfb-lib-08 (work in progress),
              February 2012.

   [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.", <http://www.OpenFlow.org/documents/
              OpenFlow-spec-v1.1.0.pdf>.

   [OpenFlowSpec1.1]
              http://www.OpenFlow.org/, "The OpenFlow 1.1
              Specification.", <http://www.OpenFlow.org/documents/
              OpenFlow-spec-v1.1.0.pdf>.

   [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.

Haleplidis, et al.      Expires November 26, 2012              [Page 90]
Internet-Draft           ForCES OpenFlow library                May 2012

10.2.  Informative References

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

Haleplidis, et al.      Expires November 26, 2012              [Page 91]
Internet-Draft           ForCES OpenFlow library                May 2012

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

Haleplidis, et al.      Expires November 26, 2012              [Page 92]