include/openflow.h

   1 /* Copyright (C) 2007 Board of Trustees, Leland Stanford Jr. University.
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to
   5  * deal in the Software without restriction, including without limitation the
   6  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   7  * sell copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  18  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  19  * IN THE SOFTWARE.
  20  */
  21
  22 /* OpenFlow: protocol between controller and datapath. */
  23
  24 #ifndef OPENFLOW_H
  25 #define OPENFLOW_H 1
  26
  27 #ifdef __KERNEL__
  28 #include <linux/types.h>
  29 #else
  30 #include <stdint.h>
  31 #endif
  32
  33 /* Maximum length of a OpenFlow packet. */
  34 #define OFP_MAXLEN (sizeof(struct ofp_data_hello) \
  35         + (sizeof(struct ofp_phy_port) * OFPP_MAX) + 200)
  36
  37 #define OFP_VERSION   1
  38 #define OFP_MAX_TABLE_NAME_LEN 32
  39 #define OFP_MAX_PORT_NAME_LEN  16
  40
  41 #define OFP_TCP_PORT  975
  42 #define OFP_SSL_PORT  976
  43
  44 #define OFP_ETH_ALEN 6          /* Bytes in an Ethernet address. */
  45
  46 /* Port numbering.  Physical ports are numbered starting from 0. */
  47 enum ofp_port {
  48     /* Maximum number of physical switch ports. */
  49     OFPP_MAX = 0x100,
  50
  51     /* Fake output "ports". */
  52     OFPP_NORMAL     = 0xfffa,  /* Process with normal L2/L3 switching */
  53     OFPP_FLOOD      = 0xfffb,  /* All physical ports except input port and
  54                                   those disabled by STP. */
  55     OFPP_ALL        = 0xfffc,  /* All physical ports except input port. */
  56     OFPP_CONTROLLER = 0xfffd,  /* Send to controller. */
  57     OFPP_LOCAL      = 0xfffe,  /* Local openflow "port". */ /* xxx Want?! */
  58     OFPP_NONE       = 0xffff   /* Not associated with a physical port. */
  59 };
  60
  61 enum ofp_type {
  62     OFPT_CONTROL_HELLO,      /* 0  Controller/switch message */
  63     OFPT_DATA_HELLO,         /* 1  Controller/switch message */
  64     OFPT_PACKET_IN,          /* 2  Async message */
  65     OFPT_PACKET_OUT,         /* 3  Controller/switch message */
  66     OFPT_FLOW_MOD,           /* 4  Controller/switch message */
  67     OFPT_FLOW_EXPIRED,       /* 5  Async message */
  68     OFPT_TABLE,              /* 6  Controller/switch message */
  69     OFPT_PORT_MOD,           /* 7  Controller/switch message */
  70     OFPT_PORT_STATUS,        /* 8  Async message */
  71     OFPT_FLOW_STAT_REQUEST,  /* 9  Controller/switch message */
  72     OFPT_FLOW_STAT_REPLY,    /* 10 Controller/switch message */
  73     OFPT_TABLE_STAT_REQUEST, /* 11 Controller/switch message */
  74     OFPT_TABLE_STAT_REPLY,   /* 12 Controller/switch message */
  75     OFPT_PORT_STAT_REQUEST,  /* 13 Controller/switch message */
  76     OFPT_PORT_STAT_REPLY     /* 14 Controller/switch message */
  77 };
  78
  79 /* Header on all OpenFlow packets. */
  80 struct ofp_header {
  81     uint8_t version;    /* Always 1. */
  82     uint8_t type;       /* One of the OFPT_ constants. */
  83     uint16_t length;    /* Length including this ofp_header. */
  84     uint32_t xid;       /* Transactin id associated with this packet.
  85                            Replies use the same id as was in the request
  86                            to facilitate pairing. */
  87 };
  88
  89 #define OFP_DEFAULT_MISS_SEND_LEN   128
  90 #define OFP_MISS_SEND_LEN_UNCHANGED 0xffff
  91
  92 /* Flag to indicate that datapath should notify the controller of
  93  * expired flow entries.
  94  */
  95 #define OFP_CHELLO_SEND_FLOW_EXP 0x0001
  96
  97 /* Controller hello (controller -> datapath). */
  98 struct ofp_control_hello {
  99     struct ofp_header header;
 100     uint32_t version;         /* Max supported protocol version (?) */
 101     uint16_t flags;
 102     uint16_t miss_send_len;   /* Max bytes of new flow that datapath should
 103                                  send to the controller.  A value of
 104                                  OFP_MISS_SEND_LEN_UNCHANGED leaves the
 105                                  currently configured value unchanged. */
 106 };
 107
 108 /* Capabilities supported by the datapath. */
 109 enum ofp_capabilities {
 110     OFPC_FLOW_STATS   = 1 << 0, /* Flow statistics. */
 111     OFPC_TABLE_STATS  = 1 << 1, /* Table statistics. */
 112     OFPC_PORT_STATS   = 1 << 2, /* Port statistics. */
 113     OFPC_STP          = 1 << 3, /* 802.11d spanning tree. */
 114     OFPC_MULTI_PHY_TX = 1 << 4  /* Supports transmitting through multiple
 115                                    physical interfaces */
 116 };
 117
 118 /* Flags to indicate behavior of the physical port */
 119 enum ofp_port_flags {
 120     OFPPFL_NO_FLOOD  = 1 << 0, /* Do not include this port when flooding */
 121 };
 122
 123 /* Features of physical ports available in a datapath. */
 124 enum ofp_port_features {
 125     OFPPF_10MB_HD    = 1 << 0, /* 10 Mb half-duplex rate support. */
 126     OFPPF_10MB_FD    = 1 << 1, /* 10 Mb full-duplex rate support. */
 127     OFPPF_100MB_HD   = 1 << 2, /* 100 Mb half-duplex rate support. */
 128     OFPPF_100MB_FD   = 1 << 3, /* 100 Mb full-duplex rate support. */
 129     OFPPF_1GB_HD     = 1 << 4, /* 1 Gb half-duplex rate support. */
 130     OFPPF_1GB_FD     = 1 << 5, /* 1 Gb full-duplex rate support. */
 131     OFPPF_10GB_FD    = 1 << 6, /* 10 Gb full-duplex rate support. */
 132 };
 133
 134
 135 /* Description of a physical port */
 136 struct ofp_phy_port {
 137     uint16_t port_no;
 138     uint8_t hw_addr[OFP_ETH_ALEN];
 139     uint8_t name[OFP_MAX_PORT_NAME_LEN]; /* Null-terminated */
 140     uint32_t flags;         /* Bitmap of "ofp_port_flags". */
 141     uint32_t speed;         /* Current speed in Mbps */
 142     uint32_t features;      /* Bitmap of supported "ofp_port_features"s. */
 143 };
 144
 145 /* Datapath hello (datapath -> controller). */
 146 struct ofp_data_hello {
 147     struct ofp_header header;
 148     uint64_t datapath_id;   /* Datapath unique ID */
 149
 150     /* Table info. */
 151     uint32_t n_exact;       /* Max exact-match table entries. */
 152     uint32_t n_mac_only;    /* Max mac-only table entries. */
 153     uint32_t n_compression; /* Max entries compressed on service port.  */
 154     uint32_t n_general;     /* Max entries of arbitrary form. */
 155
 156     /* Buffer limits.  A datapath that cannot buffer reports 0.*/
 157     uint32_t buffer_mb;     /* Space for buffering packets, in MB. */
 158     uint32_t n_buffers;     /* Max packets buffered at once. */
 159
 160     /* Features. */
 161     uint32_t capabilities;  /* Bitmap of support "ofp_capabilities". */
 162     uint32_t actions;       /* Bitmap of supported "ofp_action_type"s. */
 163
 164     /* Miscellany */
 165     uint16_t miss_send_len; /* Currently configured value for max bytes
 166                                of new flow that datapath will send to the
 167                                controller. */
 168     uint8_t pad[2];         /* Align to 32-bits */
 169
 170     /* Port info.*/
 171     struct ofp_phy_port ports[0];   /* Port definitions.  The number of ports
 172                                       is inferred from the length field in
 173                                       the header. */
 174 };
 175
 176 /* What changed about the phsyical port */
 177 enum ofp_port_reason {
 178     OFPPR_ADD,              /* The port was added */
 179     OFPPR_DELETE,           /* The port was removed */
 180     OFPPR_MOD               /* Some attribute of the port has changed */
 181 };
 182
 183 /* A physical port has changed in the datapath */
 184 struct ofp_port_status {
 185     struct ofp_header header;
 186     uint8_t reason;          /* One of OFPPR_* */
 187     uint8_t pad[3];          /* Align to 32-bits */
 188     struct ofp_phy_port desc;
 189 };
 190
 191 /* Modify behavior of the physical port */
 192 struct ofp_port_mod {
 193     struct ofp_header header;
 194     struct ofp_phy_port desc;
 195 };
 196
 197 /* Why is this packet being sent to the controller? */
 198 enum ofp_reason {
 199     OFPR_NO_MATCH,          /* No matching flow. */
 200     OFPR_ACTION             /* Action explicitly output to controller. */
 201 };
 202
 203 /* Packet received on port (datapath -> controller). */
 204 struct ofp_packet_in {
 205     struct ofp_header header;
 206     uint32_t buffer_id;     /* ID assigned by datapath. */
 207     uint16_t total_len;     /* Full length of frame. */
 208     uint16_t in_port;       /* Port on which frame was received. */
 209     uint8_t reason;         /* Reason packet is being sent (one of OFPR_*) */
 210     uint8_t pad;
 211     uint8_t data[0];        /* Ethernet frame, halfway through 32-bit word,
 212                                so the IP header is 32-bit aligned.  The
 213                                amount of data is inferred from the length
 214                                field in the header.  Because of padding,
 215                                offsetof(struct ofp_packet_in, data) ==
 216                                sizeof(struct ofp_packet_in) - 2. */
 217 };
 218
 219 enum ofp_action_type {
 220     OFPAT_OUTPUT,           /* Output to switch port. */
 221     OFPAT_SET_DL_VLAN,      /* VLAN. */
 222     OFPAT_SET_DL_SRC,       /* Ethernet source address. */
 223     OFPAT_SET_DL_DST,       /* Ethernet destination address. */
 224     OFPAT_SET_NW_SRC,       /* IP source address. */
 225     OFPAT_SET_NW_DST,       /* IP destination address. */
 226     OFPAT_SET_TP_SRC,       /* TCP/UDP source port. */
 227     OFPAT_SET_TP_DST        /* TCP/UDP destination port. */
 228 };
 229
 230 /* An output action sends packets out 'port'.  When the 'port' is the
 231  * OFPP_CONTROLLER, 'max_len' indicates the max number of bytes to
 232  * send.  A 'max_len' of zero means the entire packet should be sent. */
 233 struct ofp_action_output {
 234     uint16_t max_len;
 235     uint16_t port;
 236 };
 237
 238 /* The VLAN id is 12-bits, so we'll use the entire 16 bits to indicate
 239  * special conditions.  All ones is used to indicate that no VLAN id was
 240  * set, or if used as an action, that the VLAN header should be
 241  * stripped.
 242  */
 243 #define OFP_VLAN_NONE      0xffff
 244
 245 struct ofp_action {
 246     uint16_t type;                       /* One of OFPAT_* */
 247     union {
 248         struct ofp_action_output output; /* OFPAT_OUTPUT: output struct. */
 249         uint16_t vlan_id;                /* OFPAT_SET_DL_VLAN: VLAN id. */
 250         uint8_t  dl_addr[OFP_ETH_ALEN];  /* OFPAT_SET_DL_SRC/DST */
 251         uint32_t nw_addr;                /* OFPAT_SET_NW_SRC/DST */
 252         uint16_t tp;                     /* OFPAT_SET_TP_SRC/DST */
 253     } arg;
 254 };
 255
 256 /* Send packet (controller -> datapath). */
 257 struct ofp_packet_out {
 258     struct ofp_header header;
 259     uint32_t buffer_id;     /* ID assigned by datapath (-1 if none). */
 260     uint16_t in_port;       /* Packet's input port (OFPP_NONE if none). */
 261     uint16_t out_port;      /* Output port (if buffer_id == -1). */
 262     union {
 263         struct ofp_action actions[0]; /* buffer_id != -1 */
 264         uint8_t data[0];              /* buffer_id == -1 */
 265     } u;
 266 };
 267
 268 enum ofp_flow_mod_command {
 269     OFPFC_ADD,              /* New flow. */
 270     OFPFC_DELETE,           /* Delete all matching flows. */
 271     OFPFC_DELETE_STRICT     /* Strictly match wildcards. */
 272 };
 273
 274 /* Flow wildcards. */
 275 enum ofp_flow_wildcards {
 276     OFPFW_IN_PORT  = 1 << 0,  /* Switch input port. */
 277     OFPFW_DL_VLAN  = 1 << 1,  /* VLAN. */
 278     OFPFW_DL_SRC   = 1 << 2,  /* Ethernet source address. */
 279     OFPFW_DL_DST   = 1 << 3,  /* Ethernet destination address. */
 280     OFPFW_DL_TYPE  = 1 << 4,  /* Ethernet frame type. */
 281     OFPFW_NW_SRC   = 1 << 5,  /* IP source address. */
 282     OFPFW_NW_DST   = 1 << 6,  /* IP destination address. */
 283     OFPFW_NW_PROTO = 1 << 7,  /* IP protocol. */
 284     OFPFW_TP_SRC   = 1 << 8,  /* TCP/UDP source port. */
 285     OFPFW_TP_DST   = 1 << 9,  /* TCP/UDP destination port. */
 286     OFPFW_ALL      = (1 << 10) - 1
 287 };
 288
 289 /* Values below this cutoff are 802.3 packets and the two bytes
 290  * following MAC addresses are used as a frame length.  Otherwise, the
 291  * two bytes are used as the Ethernet type.
 292  */
 293 #define OFP_DL_TYPE_ETH2_CUTOFF   0x0600
 294
 295 /* Value of dl_type to indicate that the frame does not include an
 296  * Ethernet type.
 297  */
 298 #define OFP_DL_TYPE_NOT_ETH_TYPE  0x05ff
 299
 300 /* Fields to match against flows */
 301 struct ofp_match {
 302     uint16_t wildcards;        /* Wildcard fields. */
 303     uint16_t in_port;          /* Input switch port. */
 304     uint8_t dl_src[OFP_ETH_ALEN]; /* Ethernet source address. */
 305     uint8_t dl_dst[OFP_ETH_ALEN]; /* Ethernet destination address. */
 306     uint16_t dl_vlan;          /* Input VLAN. */
 307     uint16_t dl_type;          /* Ethernet frame type. */
 308     uint32_t nw_src;           /* IP source address. */
 309     uint32_t nw_dst;           /* IP destination address. */
 310     uint8_t nw_proto;          /* IP protocol. */
 311     uint8_t pad[3];            /* Align to 32-bits */
 312     uint16_t tp_src;           /* TCP/UDP source port. */
 313     uint16_t tp_dst;           /* TCP/UDP destination port. */
 314 };
 315
 316 /* Value used in "max_idle" to indicate that the entry is permanent */
 317 #define OFP_FLOW_PERMANENT 0
 318
 319 /* Flow setup and teardown (controller -> datapath). */
 320 struct ofp_flow_mod {
 321     struct ofp_header header;
 322     struct ofp_match match;      /* Fields to match */
 323
 324     /* Flow actions. */
 325     uint16_t command;            /* One of OFPFC_*. */
 326     uint16_t max_idle;           /* Idle time before discarding (seconds). */
 327     uint32_t buffer_id;          /* Buffered packet to apply to (or -1). */
 328     uint32_t group_id;           /* Flow group ID (for QoS). */
 329     struct ofp_action actions[0]; /* The number of actions is inferred from
 330                                     the length field in the header. */
 331 };
 332
 333 /* Flow expiration (datapath -> controller). */
 334 struct ofp_flow_expired {
 335     struct ofp_header header;
 336     struct ofp_match match;   /* Description of fields */
 337
 338     uint32_t duration;        /* Time flow was alive in seconds. */
 339     uint64_t packet_count;
 340     uint64_t byte_count;
 341 };
 342
 343 /* Statistics about flows that match the "match" field */
 344 struct ofp_flow_stats {
 345     struct ofp_match match;   /* Description of fields */
 346     uint32_t duration;        /* Time flow has been alive in seconds.  Only
 347                                  used for non-aggregated results. */
 348     uint64_t packet_count;
 349     uint64_t byte_count;
 350 };
 351
 352 enum {
 353     OFPFS_INDIV,              /* Send an entry for each matching flow */
 354     OFPFS_AGGREGATE           /* Aggregate matching flows */
 355 };
 356
 357 /* Current flow statistics request */
 358 struct ofp_flow_stat_request {
 359     struct ofp_header header;
 360     struct ofp_match match;   /* Fields to match */
 361     uint8_t type;             /* One of OFPFS_ */
 362     uint8_t pad[3];           /* Align to 32-bits */
 363 };
 364
 365 /* Current flow statistics reply */
 366 struct ofp_flow_stat_reply {
 367     struct ofp_header header;
 368
 369     /* If request was of type OFPFS_INDIV, this will contain an array of
 370      * flow statistic entries.  The number of matching flows is likely
 371      * much larger than can fit in a single OpenFlow message, so a
 372      * a response with no flows included is sent to indicate the end.
 373      * If it was a OFPFS_AGGREGATE request, only a single flow stats
 374      * entry will be contained in the response.
 375      */
 376     struct ofp_flow_stats flows[0];
 377 };
 378
 379 /* Table attributes collected at runtime */
 380 struct ofp_table {
 381     struct ofp_header header;
 382     char              name[OFP_MAX_TABLE_NAME_LEN];
 383     uint16_t          table_id;
 384     unsigned long int n_flows;
 385     unsigned long int max_flows;
 386 };
 387
 388 #endif /* openflow.h */