datapath: Convert odp_flow_key to use Netlink attributes instead.
[openvswitch] / lib / ofp-util.c
1 /*
2  * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "ofp-print.h"
19 #include <errno.h>
20 #include <inttypes.h>
21 #include <stdlib.h>
22 #include "byte-order.h"
23 #include "classifier.h"
24 #include "dynamic-string.h"
25 #include "multipath.h"
26 #include "nx-match.h"
27 #include "ofp-errors.h"
28 #include "ofp-util.h"
29 #include "ofpbuf.h"
30 #include "packets.h"
31 #include "random.h"
32 #include "type-props.h"
33 #include "vlog.h"
34
35 VLOG_DEFINE_THIS_MODULE(ofp_util);
36
37 /* Rate limit for OpenFlow message parse errors.  These always indicate a bug
38  * in the peer and so there's not much point in showing a lot of them. */
39 static struct vlog_rate_limit bad_ofmsg_rl = VLOG_RATE_LIMIT_INIT(1, 5);
40
41 /* Given the wildcard bit count in the least-significant 6 of 'wcbits', returns
42  * an IP netmask with a 1 in each bit that must match and a 0 in each bit that
43  * is wildcarded.
44  *
45  * The bits in 'wcbits' are in the format used in enum ofp_flow_wildcards: 0
46  * is exact match, 1 ignores the LSB, 2 ignores the 2 least-significant bits,
47  * ..., 32 and higher wildcard the entire field.  This is the *opposite* of the
48  * usual convention where e.g. /24 indicates that 8 bits (not 24 bits) are
49  * wildcarded. */
50 ovs_be32
51 ofputil_wcbits_to_netmask(int wcbits)
52 {
53     wcbits &= 0x3f;
54     return wcbits < 32 ? htonl(~((1u << wcbits) - 1)) : 0;
55 }
56
57 /* Given the IP netmask 'netmask', returns the number of bits of the IP address
58  * that it wildcards.  'netmask' must be a CIDR netmask (see ip_is_cidr()). */
59 int
60 ofputil_netmask_to_wcbits(ovs_be32 netmask)
61 {
62     assert(ip_is_cidr(netmask));
63 #if __GNUC__ >= 4
64     return netmask == htonl(0) ? 32 : __builtin_ctz(ntohl(netmask));
65 #else
66     int wcbits;
67
68     for (wcbits = 32; netmask; wcbits--) {
69         netmask &= netmask - 1;
70     }
71
72     return wcbits;
73 #endif
74 }
75
76 /* A list of the FWW_* and OFPFW_ bits that have the same value, meaning, and
77  * name. */
78 #define WC_INVARIANT_LIST \
79     WC_INVARIANT_BIT(IN_PORT) \
80     WC_INVARIANT_BIT(DL_SRC) \
81     WC_INVARIANT_BIT(DL_DST) \
82     WC_INVARIANT_BIT(DL_TYPE) \
83     WC_INVARIANT_BIT(NW_PROTO) \
84     WC_INVARIANT_BIT(TP_SRC) \
85     WC_INVARIANT_BIT(TP_DST)
86
87 /* Verify that all of the invariant bits (as defined on WC_INVARIANT_LIST)
88  * actually have the same names and values. */
89 #define WC_INVARIANT_BIT(NAME) BUILD_ASSERT_DECL(FWW_##NAME == OFPFW_##NAME);
90     WC_INVARIANT_LIST
91 #undef WC_INVARIANT_BIT
92
93 /* WC_INVARIANTS is the invariant bits (as defined on WC_INVARIANT_LIST) all
94  * OR'd together. */
95 enum {
96     WC_INVARIANTS = 0
97 #define WC_INVARIANT_BIT(NAME) | FWW_##NAME
98     WC_INVARIANT_LIST
99 #undef WC_INVARIANT_BIT
100 };
101
102 /* Converts the ofp_match in 'match' into a cls_rule in 'rule', with the given
103  * 'priority'.
104  *
105  * 'flow_format' must either NXFF_OPENFLOW10 or NXFF_TUN_ID_FROM_COOKIE.  In
106  * the latter case only, 'flow''s tun_id field will be taken from the high bits
107  * of 'cookie', if 'match''s wildcards do not indicate that tun_id is
108  * wildcarded. */
109 void
110 ofputil_cls_rule_from_match(const struct ofp_match *match,
111                             unsigned int priority,
112                             enum nx_flow_format flow_format,
113                             ovs_be64 cookie, struct cls_rule *rule)
114 {
115     struct flow_wildcards *wc = &rule->wc;
116     unsigned int ofpfw;
117     ovs_be16 vid, pcp;
118
119     /* Initialize rule->priority. */
120     ofpfw = ntohl(match->wildcards);
121     ofpfw &= flow_format == NXFF_TUN_ID_FROM_COOKIE ? OVSFW_ALL : OFPFW_ALL;
122     rule->priority = !ofpfw ? UINT16_MAX : priority;
123
124     /* Initialize most of rule->wc. */
125     flow_wildcards_init_catchall(wc);
126     wc->wildcards = ofpfw & WC_INVARIANTS;
127     if (ofpfw & OFPFW_NW_TOS) {
128         wc->wildcards |= FWW_NW_TOS;
129     }
130     wc->nw_src_mask = ofputil_wcbits_to_netmask(ofpfw >> OFPFW_NW_SRC_SHIFT);
131     wc->nw_dst_mask = ofputil_wcbits_to_netmask(ofpfw >> OFPFW_NW_DST_SHIFT);
132
133     if (flow_format == NXFF_TUN_ID_FROM_COOKIE && !(ofpfw & NXFW_TUN_ID)) {
134         rule->flow.tun_id = htonll(ntohll(cookie) >> 32);
135     }
136
137     if (ofpfw & OFPFW_DL_DST) {
138         /* OpenFlow 1.0 OFPFW_DL_DST covers the whole Ethernet destination, but
139          * Open vSwitch breaks the Ethernet destination into bits as FWW_DL_DST
140          * and FWW_ETH_MCAST. */
141         wc->wildcards |= FWW_ETH_MCAST;
142     }
143
144     /* Initialize most of rule->flow. */
145     rule->flow.nw_src = match->nw_src;
146     rule->flow.nw_dst = match->nw_dst;
147     rule->flow.in_port = (match->in_port == htons(OFPP_LOCAL) ? ODPP_LOCAL
148                      : ntohs(match->in_port));
149     rule->flow.dl_type = ofputil_dl_type_from_openflow(match->dl_type);
150     rule->flow.tp_src = match->tp_src;
151     rule->flow.tp_dst = match->tp_dst;
152     memcpy(rule->flow.dl_src, match->dl_src, ETH_ADDR_LEN);
153     memcpy(rule->flow.dl_dst, match->dl_dst, ETH_ADDR_LEN);
154     rule->flow.nw_tos = match->nw_tos;
155     rule->flow.nw_proto = match->nw_proto;
156
157     /* Translate VLANs. */
158     vid = match->dl_vlan & htons(VLAN_VID_MASK);
159     pcp = htons((match->dl_vlan_pcp << VLAN_PCP_SHIFT) & VLAN_PCP_MASK);
160     switch (ofpfw & (OFPFW_DL_VLAN | OFPFW_DL_VLAN_PCP)) {
161     case OFPFW_DL_VLAN | OFPFW_DL_VLAN_PCP:
162         /* Wildcard everything. */
163         rule->flow.vlan_tci = htons(0);
164         rule->wc.vlan_tci_mask = htons(0);
165         break;
166
167     case OFPFW_DL_VLAN_PCP:
168         if (match->dl_vlan == htons(OFP_VLAN_NONE)) {
169             /* Match only packets without 802.1Q header. */
170             rule->flow.vlan_tci = htons(0);
171             rule->wc.vlan_tci_mask = htons(0xffff);
172         } else {
173             /* Wildcard PCP, specific VID. */
174             rule->flow.vlan_tci = vid | htons(VLAN_CFI);
175             rule->wc.vlan_tci_mask = htons(VLAN_VID_MASK | VLAN_CFI);
176         }
177         break;
178
179     case OFPFW_DL_VLAN:
180         /* Wildcard VID, specific PCP. */
181         rule->flow.vlan_tci = pcp | htons(VLAN_CFI);
182         rule->wc.vlan_tci_mask = htons(VLAN_PCP_MASK | VLAN_CFI);
183         break;
184
185     case 0:
186         if (match->dl_vlan == htons(OFP_VLAN_NONE)) {
187             /* This case is odd, since we can't have a specific PCP without an
188              * 802.1Q header.  However, older versions of OVS treated this as
189              * matching packets withut an 802.1Q header, so we do here too. */
190             rule->flow.vlan_tci = htons(0);
191             rule->wc.vlan_tci_mask = htons(0xffff);
192         } else {
193             /* Specific VID and PCP. */
194             rule->flow.vlan_tci = vid | pcp | htons(VLAN_CFI);
195             rule->wc.vlan_tci_mask = htons(0xffff);
196         }
197         break;
198     }
199
200     /* Clean up. */
201     cls_rule_zero_wildcarded_fields(rule);
202 }
203
204 /* Convert 'rule' into the OpenFlow match structure 'match'.  'flow_format'
205  * must either NXFF_OPENFLOW10 or NXFF_TUN_ID_FROM_COOKIE.
206  *
207  * The NXFF_TUN_ID_FROM_COOKIE flow format requires modifying the flow cookie.
208  * This function can help with that, if 'cookie_out' is nonnull.  For
209  * NXFF_OPENFLOW10, or if the tunnel ID is wildcarded, 'cookie_in' will be
210  * copied directly to '*cookie_out'.  For NXFF_TUN_ID_FROM_COOKIE when tunnel
211  * ID is matched, 'cookie_in' will be modified appropriately before setting
212  * '*cookie_out'.
213  */
214 void
215 ofputil_cls_rule_to_match(const struct cls_rule *rule,
216                           enum nx_flow_format flow_format,
217                           struct ofp_match *match,
218                           ovs_be64 cookie_in, ovs_be64 *cookie_out)
219 {
220     const struct flow_wildcards *wc = &rule->wc;
221     unsigned int ofpfw;
222
223     /* Figure out most OpenFlow wildcards. */
224     ofpfw = wc->wildcards & WC_INVARIANTS;
225     ofpfw |= ofputil_netmask_to_wcbits(wc->nw_src_mask) << OFPFW_NW_SRC_SHIFT;
226     ofpfw |= ofputil_netmask_to_wcbits(wc->nw_dst_mask) << OFPFW_NW_DST_SHIFT;
227     if (wc->wildcards & FWW_NW_TOS) {
228         ofpfw |= OFPFW_NW_TOS;
229     }
230
231     /* Tunnel ID. */
232     if (flow_format == NXFF_TUN_ID_FROM_COOKIE) {
233         if (wc->tun_id_mask == htonll(0)) {
234             ofpfw |= NXFW_TUN_ID;
235         } else {
236             uint32_t cookie_lo = ntohll(cookie_in);
237             uint32_t cookie_hi = ntohll(rule->flow.tun_id);
238             cookie_in = htonll(cookie_lo | ((uint64_t) cookie_hi << 32));
239         }
240     }
241     if (cookie_out) {
242         *cookie_out = cookie_in;
243     }
244
245     /* Translate VLANs. */
246     match->dl_vlan = htons(0);
247     match->dl_vlan_pcp = 0;
248     if (rule->wc.vlan_tci_mask == htons(0)) {
249         ofpfw |= OFPFW_DL_VLAN | OFPFW_DL_VLAN_PCP;
250     } else if (rule->wc.vlan_tci_mask & htons(VLAN_CFI)
251                && !(rule->flow.vlan_tci & htons(VLAN_CFI))) {
252         match->dl_vlan = htons(OFP_VLAN_NONE);
253     } else {
254         if (!(rule->wc.vlan_tci_mask & htons(VLAN_VID_MASK))) {
255             ofpfw |= OFPFW_DL_VLAN;
256         } else {
257             match->dl_vlan = htons(vlan_tci_to_vid(rule->flow.vlan_tci));
258         }
259
260         if (!(rule->wc.vlan_tci_mask & htons(VLAN_PCP_MASK))) {
261             ofpfw |= OFPFW_DL_VLAN_PCP;
262         } else {
263             match->dl_vlan_pcp = vlan_tci_to_pcp(rule->flow.vlan_tci);
264         }
265     }
266
267     /* Compose most of the match structure. */
268     match->wildcards = htonl(ofpfw);
269     match->in_port = htons(rule->flow.in_port == ODPP_LOCAL ? OFPP_LOCAL
270                            : rule->flow.in_port);
271     memcpy(match->dl_src, rule->flow.dl_src, ETH_ADDR_LEN);
272     memcpy(match->dl_dst, rule->flow.dl_dst, ETH_ADDR_LEN);
273     match->dl_type = ofputil_dl_type_to_openflow(rule->flow.dl_type);
274     match->nw_src = rule->flow.nw_src;
275     match->nw_dst = rule->flow.nw_dst;
276     match->nw_tos = rule->flow.nw_tos;
277     match->nw_proto = rule->flow.nw_proto;
278     match->tp_src = rule->flow.tp_src;
279     match->tp_dst = rule->flow.tp_dst;
280     memset(match->pad1, '\0', sizeof match->pad1);
281     memset(match->pad2, '\0', sizeof match->pad2);
282 }
283
284 /* Given a 'dl_type' value in the format used in struct flow, returns the
285  * corresponding 'dl_type' value for use in an OpenFlow ofp_match structure. */
286 ovs_be16
287 ofputil_dl_type_to_openflow(ovs_be16 flow_dl_type)
288 {
289     return (flow_dl_type == htons(FLOW_DL_TYPE_NONE)
290             ? htons(OFP_DL_TYPE_NOT_ETH_TYPE)
291             : flow_dl_type);
292 }
293
294 /* Given a 'dl_type' value in the format used in an OpenFlow ofp_match
295  * structure, returns the corresponding 'dl_type' value for use in struct
296  * flow. */
297 ovs_be16
298 ofputil_dl_type_from_openflow(ovs_be16 ofp_dl_type)
299 {
300     return (ofp_dl_type == htons(OFP_DL_TYPE_NOT_ETH_TYPE)
301             ? htons(FLOW_DL_TYPE_NONE)
302             : ofp_dl_type);
303 }
304
305 /* Returns a transaction ID to use for an outgoing OpenFlow message. */
306 static ovs_be32
307 alloc_xid(void)
308 {
309     static uint32_t next_xid = 1;
310     return htonl(next_xid++);
311 }
312 \f
313 /* Basic parsing of OpenFlow messages. */
314
315 struct ofputil_msg_type {
316     enum ofputil_msg_code code; /* OFPUTIL_*. */
317     uint32_t value;             /* OFPT_*, OFPST_*, NXT_*, or NXST_*. */
318     const char *name;           /* e.g. "OFPT_FLOW_REMOVED". */
319     unsigned int min_size;      /* Minimum total message size in bytes. */
320     /* 0 if 'min_size' is the exact size that the message must be.  Otherwise,
321      * the message may exceed 'min_size' by an even multiple of this value. */
322     unsigned int extra_multiple;
323 };
324
325 struct ofputil_msg_category {
326     const char *name;           /* e.g. "OpenFlow message" */
327     const struct ofputil_msg_type *types;
328     size_t n_types;
329     int missing_error;          /* ofp_mkerr() value for missing type. */
330 };
331
332 static bool
333 ofputil_length_ok(const struct ofputil_msg_category *cat,
334                   const struct ofputil_msg_type *type,
335                   unsigned int size)
336 {
337     switch (type->extra_multiple) {
338     case 0:
339         if (size != type->min_size) {
340             VLOG_WARN_RL(&bad_ofmsg_rl, "received %s %s with incorrect "
341                          "length %u (expected length %u)",
342                          cat->name, type->name, size, type->min_size);
343             return false;
344         }
345         return true;
346
347     case 1:
348         if (size < type->min_size) {
349             VLOG_WARN_RL(&bad_ofmsg_rl, "received %s %s with incorrect "
350                          "length %u (expected length at least %u bytes)",
351                          cat->name, type->name, size, type->min_size);
352             return false;
353         }
354         return true;
355
356     default:
357         if (size < type->min_size
358             || (size - type->min_size) % type->extra_multiple) {
359             VLOG_WARN_RL(&bad_ofmsg_rl, "received %s %s with incorrect "
360                          "length %u (must be exactly %u bytes or longer "
361                          "by an integer multiple of %u bytes)",
362                          cat->name, type->name, size,
363                          type->min_size, type->extra_multiple);
364             return false;
365         }
366         return true;
367     }
368 }
369
370 static int
371 ofputil_lookup_openflow_message(const struct ofputil_msg_category *cat,
372                                 uint32_t value, unsigned int size,
373                                 const struct ofputil_msg_type **typep)
374 {
375     const struct ofputil_msg_type *type;
376
377     for (type = cat->types; type < &cat->types[cat->n_types]; type++) {
378         if (type->value == value) {
379             if (!ofputil_length_ok(cat, type, size)) {
380                 return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
381             }
382             *typep = type;
383             return 0;
384         }
385     }
386
387     VLOG_WARN_RL(&bad_ofmsg_rl, "received %s of unknown type %"PRIu32,
388                  cat->name, value);
389     return cat->missing_error;
390 }
391
392 static int
393 ofputil_decode_vendor(const struct ofp_header *oh,
394                       const struct ofputil_msg_type **typep)
395 {
396     static const struct ofputil_msg_type nxt_messages[] = {
397         { OFPUTIL_NXT_STATUS_REQUEST,
398           NXT_STATUS_REQUEST, "NXT_STATUS_REQUEST",
399           sizeof(struct nicira_header), 1 },
400
401         { OFPUTIL_NXT_STATUS_REPLY,
402           NXT_STATUS_REPLY, "NXT_STATUS_REPLY",
403           sizeof(struct nicira_header), 1 },
404
405         { OFPUTIL_NXT_TUN_ID_FROM_COOKIE,
406           NXT_TUN_ID_FROM_COOKIE, "NXT_TUN_ID_FROM_COOKIE",
407           sizeof(struct nxt_tun_id_cookie), 0 },
408
409         { OFPUTIL_NXT_ROLE_REQUEST,
410           NXT_ROLE_REQUEST, "NXT_ROLE_REQUEST",
411           sizeof(struct nx_role_request), 0 },
412
413         { OFPUTIL_NXT_ROLE_REPLY,
414           NXT_ROLE_REPLY, "NXT_ROLE_REPLY",
415           sizeof(struct nx_role_request), 0 },
416
417         { OFPUTIL_NXT_SET_FLOW_FORMAT,
418           NXT_SET_FLOW_FORMAT, "NXT_SET_FLOW_FORMAT",
419           sizeof(struct nxt_set_flow_format), 0 },
420
421         { OFPUTIL_NXT_FLOW_MOD,
422           NXT_FLOW_MOD, "NXT_FLOW_MOD",
423           sizeof(struct nx_flow_mod), 8 },
424
425         { OFPUTIL_NXT_FLOW_REMOVED,
426           NXT_FLOW_REMOVED, "NXT_FLOW_REMOVED",
427           sizeof(struct nx_flow_removed), 8 },
428     };
429
430     static const struct ofputil_msg_category nxt_category = {
431         "Nicira extension message",
432         nxt_messages, ARRAY_SIZE(nxt_messages),
433         OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE)
434     };
435
436     const struct ofp_vendor_header *ovh;
437     const struct nicira_header *nh;
438
439     ovh = (const struct ofp_vendor_header *) oh;
440     if (ovh->vendor != htonl(NX_VENDOR_ID)) {
441         VLOG_WARN_RL(&bad_ofmsg_rl, "received vendor message for unknown "
442                      "vendor %"PRIx32, ntohl(ovh->vendor));
443         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR);
444     }
445
446     if (ntohs(ovh->header.length) < sizeof(struct nicira_header)) {
447         VLOG_WARN_RL(&bad_ofmsg_rl, "received Nicira vendor message of "
448                      "length %u (expected at least %zu)",
449                      ntohs(ovh->header.length), sizeof(struct nicira_header));
450         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
451     }
452
453     nh = (const struct nicira_header *) oh;
454     return ofputil_lookup_openflow_message(&nxt_category, ntohl(nh->subtype),
455                                            ntohs(oh->length), typep);
456 }
457
458 static int
459 check_nxstats_msg(const struct ofp_header *oh)
460 {
461     const struct ofp_stats_request *osr;
462     ovs_be32 vendor;
463
464     osr = (const struct ofp_stats_request *) oh;
465
466     memcpy(&vendor, osr->body, sizeof vendor);
467     if (vendor != htonl(NX_VENDOR_ID)) {
468         VLOG_WARN_RL(&bad_ofmsg_rl, "received vendor stats message for "
469                      "unknown vendor %"PRIx32, ntohl(vendor));
470         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR);
471     }
472
473     if (ntohs(osr->header.length) < sizeof(struct nicira_stats_msg)) {
474         VLOG_WARN_RL(&bad_ofmsg_rl, "truncated Nicira stats message");
475         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
476     }
477
478     return 0;
479 }
480
481 static int
482 ofputil_decode_nxst_request(const struct ofp_header *oh,
483                             const struct ofputil_msg_type **typep)
484 {
485     static const struct ofputil_msg_type nxst_requests[] = {
486         { OFPUTIL_NXST_FLOW_REQUEST,
487           NXST_FLOW, "NXST_FLOW request",
488           sizeof(struct nx_flow_stats_request), 8 },
489
490         { OFPUTIL_NXST_AGGREGATE_REQUEST,
491           NXST_AGGREGATE, "NXST_AGGREGATE request",
492           sizeof(struct nx_aggregate_stats_request), 8 },
493     };
494
495     static const struct ofputil_msg_category nxst_request_category = {
496         "Nicira extension statistics request",
497         nxst_requests, ARRAY_SIZE(nxst_requests),
498         OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE)
499     };
500
501     const struct nicira_stats_msg *nsm;
502     int error;
503
504     error = check_nxstats_msg(oh);
505     if (error) {
506         return error;
507     }
508
509     nsm = (struct nicira_stats_msg *) oh;
510     return ofputil_lookup_openflow_message(&nxst_request_category,
511                                            ntohl(nsm->subtype),
512                                            ntohs(oh->length), typep);
513 }
514
515 static int
516 ofputil_decode_nxst_reply(const struct ofp_header *oh,
517                           const struct ofputil_msg_type **typep)
518 {
519     static const struct ofputil_msg_type nxst_replies[] = {
520         { OFPUTIL_NXST_FLOW_REPLY,
521           NXST_FLOW, "NXST_FLOW reply",
522           sizeof(struct nicira_stats_msg), 8 },
523
524         { OFPUTIL_NXST_AGGREGATE_REPLY,
525           NXST_AGGREGATE, "NXST_AGGREGATE reply",
526           sizeof(struct nx_aggregate_stats_reply), 0 },
527     };
528
529     static const struct ofputil_msg_category nxst_reply_category = {
530         "Nicira extension statistics reply",
531         nxst_replies, ARRAY_SIZE(nxst_replies),
532         OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE)
533     };
534
535     const struct nicira_stats_msg *nsm;
536     int error;
537
538     error = check_nxstats_msg(oh);
539     if (error) {
540         return error;
541     }
542
543     nsm = (struct nicira_stats_msg *) oh;
544     return ofputil_lookup_openflow_message(&nxst_reply_category,
545                                            ntohl(nsm->subtype),
546                                            ntohs(oh->length), typep);
547 }
548
549 static int
550 ofputil_decode_ofpst_request(const struct ofp_header *oh,
551                              const struct ofputil_msg_type **typep)
552 {
553     enum { OSR_SIZE = sizeof(struct ofp_stats_request) };
554     static const struct ofputil_msg_type ofpst_requests[] = {
555         { OFPUTIL_OFPST_DESC_REQUEST,
556           OFPST_DESC, "OFPST_DESC request",
557           OSR_SIZE, 0 },
558
559         { OFPUTIL_OFPST_FLOW_REQUEST,
560           OFPST_FLOW, "OFPST_FLOW request",
561           OSR_SIZE + sizeof(struct ofp_flow_stats_request), 0 },
562
563         { OFPUTIL_OFPST_AGGREGATE_REQUEST,
564           OFPST_AGGREGATE, "OFPST_AGGREGATE request",
565           OSR_SIZE + sizeof(struct ofp_aggregate_stats_request), 0 },
566
567         { OFPUTIL_OFPST_TABLE_REQUEST,
568           OFPST_TABLE, "OFPST_TABLE request",
569           OSR_SIZE, 0 },
570
571         { OFPUTIL_OFPST_PORT_REQUEST,
572           OFPST_PORT, "OFPST_PORT request",
573           OSR_SIZE + sizeof(struct ofp_port_stats_request), 0 },
574
575         { OFPUTIL_OFPST_QUEUE_REQUEST,
576           OFPST_QUEUE, "OFPST_QUEUE request",
577           OSR_SIZE + sizeof(struct ofp_queue_stats_request), 0 },
578
579         { 0,
580           OFPST_VENDOR, "OFPST_VENDOR request",
581           OSR_SIZE + sizeof(uint32_t), 1 },
582     };
583
584     static const struct ofputil_msg_category ofpst_request_category = {
585         "OpenFlow statistics",
586         ofpst_requests, ARRAY_SIZE(ofpst_requests),
587         OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT)
588     };
589
590     const struct ofp_stats_request *osr;
591     int error;
592
593     osr = (const struct ofp_stats_request *) oh;
594     error = ofputil_lookup_openflow_message(&ofpst_request_category,
595                                             ntohs(osr->type),
596                                             ntohs(oh->length), typep);
597     if (!error && osr->type == htons(OFPST_VENDOR)) {
598         error = ofputil_decode_nxst_request(oh, typep);
599     }
600     return error;
601 }
602
603 static int
604 ofputil_decode_ofpst_reply(const struct ofp_header *oh,
605                            const struct ofputil_msg_type **typep)
606 {
607     enum { OSR_SIZE = sizeof(struct ofp_stats_reply) };
608     static const struct ofputil_msg_type ofpst_replies[] = {
609         { OFPUTIL_OFPST_DESC_REPLY,
610           OFPST_DESC, "OFPST_DESC reply",
611           OSR_SIZE + sizeof(struct ofp_desc_stats), 0 },
612
613         { OFPUTIL_OFPST_FLOW_REPLY,
614           OFPST_FLOW, "OFPST_FLOW reply",
615           OSR_SIZE, 1 },
616
617         { OFPUTIL_OFPST_AGGREGATE_REPLY,
618           OFPST_AGGREGATE, "OFPST_AGGREGATE reply",
619           OSR_SIZE + sizeof(struct ofp_aggregate_stats_reply), 0 },
620
621         { OFPUTIL_OFPST_TABLE_REPLY,
622           OFPST_TABLE, "OFPST_TABLE reply",
623           OSR_SIZE, sizeof(struct ofp_table_stats) },
624
625         { OFPUTIL_OFPST_PORT_REPLY,
626           OFPST_PORT, "OFPST_PORT reply",
627           OSR_SIZE, sizeof(struct ofp_port_stats) },
628
629         { OFPUTIL_OFPST_QUEUE_REPLY,
630           OFPST_QUEUE, "OFPST_QUEUE reply",
631           OSR_SIZE, sizeof(struct ofp_queue_stats) },
632
633         { 0,
634           OFPST_VENDOR, "OFPST_VENDOR reply",
635           OSR_SIZE + sizeof(uint32_t), 1 },
636     };
637
638     static const struct ofputil_msg_category ofpst_reply_category = {
639         "OpenFlow statistics",
640         ofpst_replies, ARRAY_SIZE(ofpst_replies),
641         OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT)
642     };
643
644     const struct ofp_stats_reply *osr = (const struct ofp_stats_reply *) oh;
645     int error;
646
647     error = ofputil_lookup_openflow_message(&ofpst_reply_category,
648                                            ntohs(osr->type),
649                                            ntohs(oh->length), typep);
650     if (!error && osr->type == htons(OFPST_VENDOR)) {
651         error = ofputil_decode_nxst_reply(oh, typep);
652     }
653     return error;
654 }
655
656 /* Decodes the message type represented by 'oh'.  Returns 0 if successful or
657  * an OpenFlow error code constructed with ofp_mkerr() on failure.  Either
658  * way, stores in '*typep' a type structure that can be inspected with the
659  * ofputil_msg_type_*() functions.
660  *
661  * oh->length must indicate the correct length of the message (and must be at
662  * least sizeof(struct ofp_header)).
663  *
664  * Success indicates that 'oh' is at least as long as the minimum-length
665  * message of its type. */
666 int
667 ofputil_decode_msg_type(const struct ofp_header *oh,
668                         const struct ofputil_msg_type **typep)
669 {
670     static const struct ofputil_msg_type ofpt_messages[] = {
671         { OFPUTIL_OFPT_HELLO,
672           OFPT_HELLO, "OFPT_HELLO",
673           sizeof(struct ofp_hello), 1 },
674
675         { OFPUTIL_OFPT_ERROR,
676           OFPT_ERROR, "OFPT_ERROR",
677           sizeof(struct ofp_error_msg), 1 },
678
679         { OFPUTIL_OFPT_ECHO_REQUEST,
680           OFPT_ECHO_REQUEST, "OFPT_ECHO_REQUEST",
681           sizeof(struct ofp_header), 1 },
682
683         { OFPUTIL_OFPT_ECHO_REPLY,
684           OFPT_ECHO_REPLY, "OFPT_ECHO_REPLY",
685           sizeof(struct ofp_header), 1 },
686
687         { OFPUTIL_OFPT_FEATURES_REQUEST,
688           OFPT_FEATURES_REQUEST, "OFPT_FEATURES_REQUEST",
689           sizeof(struct ofp_header), 0 },
690
691         { OFPUTIL_OFPT_FEATURES_REPLY,
692           OFPT_FEATURES_REPLY, "OFPT_FEATURES_REPLY",
693           sizeof(struct ofp_switch_features), sizeof(struct ofp_phy_port) },
694
695         { OFPUTIL_OFPT_GET_CONFIG_REQUEST,
696           OFPT_GET_CONFIG_REQUEST, "OFPT_GET_CONFIG_REQUEST",
697           sizeof(struct ofp_header), 0 },
698
699         { OFPUTIL_OFPT_GET_CONFIG_REPLY,
700           OFPT_GET_CONFIG_REPLY, "OFPT_GET_CONFIG_REPLY",
701           sizeof(struct ofp_switch_config), 0 },
702
703         { OFPUTIL_OFPT_SET_CONFIG,
704           OFPT_SET_CONFIG, "OFPT_SET_CONFIG",
705           sizeof(struct ofp_switch_config), 0 },
706
707         { OFPUTIL_OFPT_PACKET_IN,
708           OFPT_PACKET_IN, "OFPT_PACKET_IN",
709           offsetof(struct ofp_packet_in, data), 1 },
710
711         { OFPUTIL_OFPT_FLOW_REMOVED,
712           OFPT_FLOW_REMOVED, "OFPT_FLOW_REMOVED",
713           sizeof(struct ofp_flow_removed), 0 },
714
715         { OFPUTIL_OFPT_PORT_STATUS,
716           OFPT_PORT_STATUS, "OFPT_PORT_STATUS",
717           sizeof(struct ofp_port_status), 0 },
718
719         { OFPUTIL_OFPT_PACKET_OUT,
720           OFPT_PACKET_OUT, "OFPT_PACKET_OUT",
721           sizeof(struct ofp_packet_out), 1 },
722
723         { OFPUTIL_OFPT_FLOW_MOD,
724           OFPT_FLOW_MOD, "OFPT_FLOW_MOD",
725           sizeof(struct ofp_flow_mod), 1 },
726
727         { OFPUTIL_OFPT_PORT_MOD,
728           OFPT_PORT_MOD, "OFPT_PORT_MOD",
729           sizeof(struct ofp_port_mod), 0 },
730
731         { 0,
732           OFPT_STATS_REQUEST, "OFPT_STATS_REQUEST",
733           sizeof(struct ofp_stats_request), 1 },
734
735         { 0,
736           OFPT_STATS_REPLY, "OFPT_STATS_REPLY",
737           sizeof(struct ofp_stats_reply), 1 },
738
739         { OFPUTIL_OFPT_BARRIER_REQUEST,
740           OFPT_BARRIER_REQUEST, "OFPT_BARRIER_REQUEST",
741           sizeof(struct ofp_header), 0 },
742
743         { OFPUTIL_OFPT_BARRIER_REPLY,
744           OFPT_BARRIER_REPLY, "OFPT_BARRIER_REPLY",
745           sizeof(struct ofp_header), 0 },
746
747         { 0,
748           OFPT_VENDOR, "OFPT_VENDOR",
749           sizeof(struct ofp_vendor_header), 1 },
750     };
751
752     static const struct ofputil_msg_category ofpt_category = {
753         "OpenFlow message",
754         ofpt_messages, ARRAY_SIZE(ofpt_messages),
755         OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE)
756     };
757
758     int error;
759
760     error = ofputil_lookup_openflow_message(&ofpt_category, oh->type,
761                                             ntohs(oh->length), typep);
762     if (!error) {
763         switch (oh->type) {
764         case OFPT_VENDOR:
765             error = ofputil_decode_vendor(oh, typep);
766             break;
767
768         case OFPT_STATS_REQUEST:
769             error = ofputil_decode_ofpst_request(oh, typep);
770             break;
771
772         case OFPT_STATS_REPLY:
773             error = ofputil_decode_ofpst_reply(oh, typep);
774
775         default:
776             break;
777         }
778     }
779     if (error) {
780         static const struct ofputil_msg_type ofputil_invalid_type = {
781             OFPUTIL_INVALID,
782             0, "OFPUTIL_INVALID",
783             0, 0
784         };
785
786         *typep = &ofputil_invalid_type;
787     }
788     return error;
789 }
790
791 /* Returns an OFPUTIL_* message type code for 'type'. */
792 enum ofputil_msg_code
793 ofputil_msg_type_code(const struct ofputil_msg_type *type)
794 {
795     return type->code;
796 }
797 \f
798 /* Flow formats. */
799
800 bool
801 ofputil_flow_format_is_valid(enum nx_flow_format flow_format)
802 {
803     switch (flow_format) {
804     case NXFF_OPENFLOW10:
805     case NXFF_TUN_ID_FROM_COOKIE:
806     case NXFF_NXM:
807         return true;
808     }
809
810     return false;
811 }
812
813 const char *
814 ofputil_flow_format_to_string(enum nx_flow_format flow_format)
815 {
816     switch (flow_format) {
817     case NXFF_OPENFLOW10:
818         return "openflow10";
819     case NXFF_TUN_ID_FROM_COOKIE:
820         return "tun_id_from_cookie";
821     case NXFF_NXM:
822         return "nxm";
823     default:
824         NOT_REACHED();
825     }
826 }
827
828 int
829 ofputil_flow_format_from_string(const char *s)
830 {
831     return (!strcmp(s, "openflow10") ? NXFF_OPENFLOW10
832             : !strcmp(s, "tun_id_from_cookie") ? NXFF_TUN_ID_FROM_COOKIE
833             : !strcmp(s, "nxm") ? NXFF_NXM
834             : -1);
835 }
836
837 static bool
838 regs_fully_wildcarded(const struct flow_wildcards *wc)
839 {
840     int i;
841
842     for (i = 0; i < FLOW_N_REGS; i++) {
843         if (wc->reg_masks[i] != 0) {
844             return false;
845         }
846     }
847     return true;
848 }
849
850 static inline bool
851 is_nxm_required(const struct cls_rule *rule, bool cookie_support,
852                 ovs_be64 cookie)
853 {
854     const struct flow_wildcards *wc = &rule->wc;
855     ovs_be32 cookie_hi;
856
857     /* Only NXM supports separately wildcards the Ethernet multicast bit. */
858     if (!(wc->wildcards & FWW_DL_DST) != !(wc->wildcards & FWW_ETH_MCAST)) {
859         return true;
860     }
861
862     /* Only NXM supports matching registers. */
863     if (!regs_fully_wildcarded(wc)) {
864         return true;
865     }
866
867     switch (wc->tun_id_mask) {
868     case CONSTANT_HTONLL(0):
869         /* Other formats can fully wildcard tun_id. */
870         break;
871
872     case CONSTANT_HTONLL(UINT64_MAX):
873         /* Only NXM supports matching tunnel ID, unless there is a cookie and
874          * the top 32 bits of the cookie are the desired tunnel ID value. */
875         cookie_hi = htonl(ntohll(cookie) >> 32);
876         if (!cookie_support
877             || (cookie_hi && cookie_hi != ntohll(rule->flow.tun_id))) {
878             return true;
879         }
880         break;
881
882     default:
883         /* Only NXM supports partial matches on tunnel ID. */
884         return true;
885     }
886
887     /* Other formats can express this rule. */
888     return false;
889 }
890
891 /* Returns the minimum nx_flow_format to use for sending 'rule' to a switch
892  * (e.g. to add or remove a flow).  'cookie_support' should be true if the
893  * command to be sent includes a flow cookie (as OFPT_FLOW_MOD does, for
894  * example) or false if the command does not (OFPST_FLOW and OFPST_AGGREGATE do
895  * not, for example).  If 'cookie_support' is true, then 'cookie' should be the
896  * cookie to be sent; otherwise its value is ignored.
897  *
898  * The "best" flow format is chosen on this basis:
899  *
900  *   - It must be capable of expressing the rule.  NXFF_OPENFLOW10 flows can't
901  *     handle tunnel IDs.  NXFF_TUN_ID_FROM_COOKIE flows can't handle registers
902  *     or fixing the Ethernet multicast bit, and can't handle tunnel IDs that
903  *     conflict with the high 32 bits of the cookie or commands that don't
904  *     support cookies.
905  *
906  *   - Otherwise, the chosen format should be as backward compatible as
907  *     possible.  (NXFF_OPENFLOW10 is more backward compatible than
908  *     NXFF_TUN_ID_FROM_COOKIE, which is more backward compatible than
909  *     NXFF_NXM.)
910  */
911 enum nx_flow_format
912 ofputil_min_flow_format(const struct cls_rule *rule, bool cookie_support,
913                         ovs_be64 cookie)
914 {
915     if (is_nxm_required(rule, cookie_support, cookie)) {
916         return NXFF_NXM;
917     } else if (rule->wc.tun_id_mask != htonll(0)) {
918         return NXFF_TUN_ID_FROM_COOKIE;
919     } else {
920         return NXFF_OPENFLOW10;
921     }
922 }
923
924 /* Returns an OpenFlow message that can be used to set the flow format to
925  * 'flow_format'.  */
926 struct ofpbuf *
927 ofputil_make_set_flow_format(enum nx_flow_format flow_format)
928 {
929     struct ofpbuf *msg;
930
931     if (flow_format == NXFF_OPENFLOW10
932         || flow_format == NXFF_TUN_ID_FROM_COOKIE) {
933         struct nxt_tun_id_cookie *tic;
934
935         tic = make_nxmsg(sizeof *tic, NXT_TUN_ID_FROM_COOKIE, &msg);
936         tic->set = flow_format == NXFF_TUN_ID_FROM_COOKIE;
937     } else {
938         struct nxt_set_flow_format *sff;
939
940         sff = make_nxmsg(sizeof *sff, NXT_SET_FLOW_FORMAT, &msg);
941         sff->format = htonl(flow_format);
942     }
943
944     return msg;
945 }
946
947 /* Converts an OFPT_FLOW_MOD or NXT_FLOW_MOD message 'oh' into an abstract
948  * flow_mod in 'fm'.  Returns 0 if successful, otherwise an OpenFlow error
949  * code.
950  *
951  * For OFPT_FLOW_MOD messages, 'flow_format' should be the current flow format
952  * at the time when the message was received.  Otherwise 'flow_format' is
953  * ignored.
954  *
955  * Does not validate the flow_mod actions. */
956 int
957 ofputil_decode_flow_mod(struct flow_mod *fm, const struct ofp_header *oh,
958                         enum nx_flow_format flow_format)
959 {
960     const struct ofputil_msg_type *type;
961     struct ofpbuf b;
962
963     ofpbuf_use_const(&b, oh, ntohs(oh->length));
964
965     ofputil_decode_msg_type(oh, &type);
966     if (ofputil_msg_type_code(type) == OFPUTIL_OFPT_FLOW_MOD) {
967         /* Standard OpenFlow flow_mod. */
968         struct ofp_match match, orig_match;
969         const struct ofp_flow_mod *ofm;
970         int error;
971
972         /* Dissect the message. */
973         ofm = ofpbuf_pull(&b, sizeof *ofm);
974         error = ofputil_pull_actions(&b, b.size, &fm->actions, &fm->n_actions);
975         if (error) {
976             return error;
977         }
978
979         /* Normalize ofm->match.  If normalization actually changes anything,
980          * then log the differences. */
981         match = ofm->match;
982         match.pad1[0] = match.pad2[0] = 0;
983         orig_match = match;
984         normalize_match(&match);
985         if (memcmp(&match, &orig_match, sizeof orig_match)) {
986             if (!VLOG_DROP_INFO(&bad_ofmsg_rl)) {
987                 char *old = ofp_match_to_literal_string(&orig_match);
988                 char *new = ofp_match_to_literal_string(&match);
989                 VLOG_INFO("normalization changed ofp_match, details:");
990                 VLOG_INFO(" pre: %s", old);
991                 VLOG_INFO("post: %s", new);
992                 free(old);
993                 free(new);
994             }
995         }
996
997         /* Translate the message. */
998         ofputil_cls_rule_from_match(&match, ntohs(ofm->priority), flow_format,
999                                     ofm->cookie, &fm->cr);
1000         fm->cookie = ofm->cookie;
1001         fm->command = ntohs(ofm->command);
1002         fm->idle_timeout = ntohs(ofm->idle_timeout);
1003         fm->hard_timeout = ntohs(ofm->hard_timeout);
1004         fm->buffer_id = ntohl(ofm->buffer_id);
1005         fm->out_port = ntohs(ofm->out_port);
1006         fm->flags = ntohs(ofm->flags);
1007     } else if (ofputil_msg_type_code(type) == OFPUTIL_NXT_FLOW_MOD) {
1008         /* Nicira extended flow_mod. */
1009         const struct nx_flow_mod *nfm;
1010         int error;
1011
1012         /* Dissect the message. */
1013         nfm = ofpbuf_pull(&b, sizeof *nfm);
1014         error = nx_pull_match(&b, ntohs(nfm->match_len), ntohs(nfm->priority),
1015                               &fm->cr);
1016         if (error) {
1017             return error;
1018         }
1019         error = ofputil_pull_actions(&b, b.size, &fm->actions, &fm->n_actions);
1020         if (error) {
1021             return error;
1022         }
1023
1024         /* Translate the message. */
1025         fm->cookie = nfm->cookie;
1026         fm->command = ntohs(nfm->command);
1027         fm->idle_timeout = ntohs(nfm->idle_timeout);
1028         fm->hard_timeout = ntohs(nfm->hard_timeout);
1029         fm->buffer_id = ntohl(nfm->buffer_id);
1030         fm->out_port = ntohs(nfm->out_port);
1031         fm->flags = ntohs(nfm->flags);
1032     } else {
1033         NOT_REACHED();
1034     }
1035
1036     return 0;
1037 }
1038
1039 /* Converts 'fm' into an OFPT_FLOW_MOD or NXT_FLOW_MOD message according to
1040  * 'flow_format' and returns the message. */
1041 struct ofpbuf *
1042 ofputil_encode_flow_mod(const struct flow_mod *fm,
1043                         enum nx_flow_format flow_format)
1044 {
1045     size_t actions_len = fm->n_actions * sizeof *fm->actions;
1046     struct ofpbuf *msg;
1047
1048     if (flow_format == NXFF_OPENFLOW10
1049         || flow_format == NXFF_TUN_ID_FROM_COOKIE) {
1050         struct ofp_flow_mod *ofm;
1051
1052         msg = ofpbuf_new(sizeof *ofm + actions_len);
1053         ofm = put_openflow(sizeof *ofm, OFPT_FLOW_MOD, msg);
1054         ofputil_cls_rule_to_match(&fm->cr, flow_format, &ofm->match,
1055                                   fm->cookie, &ofm->cookie);
1056         ofm->command = htons(fm->command);
1057         ofm->idle_timeout = htons(fm->idle_timeout);
1058         ofm->hard_timeout = htons(fm->hard_timeout);
1059         ofm->priority = htons(fm->cr.priority);
1060         ofm->buffer_id = htonl(fm->buffer_id);
1061         ofm->out_port = htons(fm->out_port);
1062         ofm->flags = htons(fm->flags);
1063     } else if (flow_format == NXFF_NXM) {
1064         struct nx_flow_mod *nfm;
1065         int match_len;
1066
1067         msg = ofpbuf_new(sizeof *nfm + NXM_TYPICAL_LEN + actions_len);
1068         put_nxmsg(sizeof *nfm, NXT_FLOW_MOD, msg);
1069         match_len = nx_put_match(msg, &fm->cr);
1070
1071         nfm = msg->data;
1072         nfm->cookie = fm->cookie;
1073         nfm->command = htons(fm->command);
1074         nfm->idle_timeout = htons(fm->idle_timeout);
1075         nfm->hard_timeout = htons(fm->hard_timeout);
1076         nfm->priority = htons(fm->cr.priority);
1077         nfm->buffer_id = htonl(fm->buffer_id);
1078         nfm->out_port = htons(fm->out_port);
1079         nfm->flags = htons(fm->flags);
1080         nfm->match_len = htons(match_len);
1081     } else {
1082         NOT_REACHED();
1083     }
1084
1085     ofpbuf_put(msg, fm->actions, actions_len);
1086     update_openflow_length(msg);
1087     return msg;
1088 }
1089
1090 static int
1091 ofputil_decode_ofpst_flow_request(struct flow_stats_request *fsr,
1092                                   const struct ofp_header *oh,
1093                                   enum nx_flow_format flow_format,
1094                                   bool aggregate)
1095 {
1096     const struct ofp_flow_stats_request *ofsr = ofputil_stats_body(oh);
1097
1098     fsr->aggregate = aggregate;
1099     ofputil_cls_rule_from_match(&ofsr->match, 0, flow_format, 0, &fsr->match);
1100     fsr->out_port = ntohs(ofsr->out_port);
1101     fsr->table_id = ofsr->table_id;
1102
1103     return 0;
1104 }
1105
1106 static int
1107 ofputil_decode_nxst_flow_request(struct flow_stats_request *fsr,
1108                                  const struct ofp_header *oh,
1109                                  bool aggregate)
1110 {
1111     const struct nx_flow_stats_request *nfsr;
1112     struct ofpbuf b;
1113     int error;
1114
1115     ofpbuf_use_const(&b, oh, ntohs(oh->length));
1116
1117     nfsr = ofpbuf_pull(&b, sizeof *nfsr);
1118     error = nx_pull_match(&b, ntohs(nfsr->match_len), 0, &fsr->match);
1119     if (error) {
1120         return error;
1121     }
1122     if (b.size) {
1123         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
1124     }
1125
1126     fsr->aggregate = aggregate;
1127     fsr->out_port = ntohs(nfsr->out_port);
1128     fsr->table_id = nfsr->table_id;
1129
1130     return 0;
1131 }
1132
1133 /* Converts an OFPST_FLOW, OFPST_AGGREGATE, NXST_FLOW, or NXST_AGGREGATE
1134  * message 'oh', received when the current flow format was 'flow_format', into
1135  * an abstract flow_stats_request in 'fsr'.  Returns 0 if successful, otherwise
1136  * an OpenFlow error code.
1137  *
1138  * For OFPST_FLOW and OFPST_AGGREGATE messages, 'flow_format' should be the
1139  * current flow format at the time when the message was received.  Otherwise
1140  * 'flow_format' is ignored. */
1141 int
1142 ofputil_decode_flow_stats_request(struct flow_stats_request *fsr,
1143                                   const struct ofp_header *oh,
1144                                   enum nx_flow_format flow_format)
1145 {
1146     const struct ofputil_msg_type *type;
1147     struct ofpbuf b;
1148     int code;
1149
1150     ofpbuf_use_const(&b, oh, ntohs(oh->length));
1151
1152     ofputil_decode_msg_type(oh, &type);
1153     code = ofputil_msg_type_code(type);
1154     switch (code) {
1155     case OFPUTIL_OFPST_FLOW_REQUEST:
1156         return ofputil_decode_ofpst_flow_request(fsr, oh, flow_format, false);
1157
1158     case OFPUTIL_OFPST_AGGREGATE_REQUEST:
1159         return ofputil_decode_ofpst_flow_request(fsr, oh, flow_format, true);
1160
1161     case OFPUTIL_NXST_FLOW_REQUEST:
1162         return ofputil_decode_nxst_flow_request(fsr, oh, false);
1163
1164     case OFPUTIL_NXST_AGGREGATE_REQUEST:
1165         return ofputil_decode_nxst_flow_request(fsr, oh, true);
1166
1167     default:
1168         /* Hey, the caller lied. */
1169         NOT_REACHED();
1170     }
1171 }
1172
1173 /* Converts abstract flow_stats_request 'fsr' into an OFPST_FLOW,
1174  * OFPST_AGGREGATE, NXST_FLOW, or NXST_AGGREGATE message 'oh' according to
1175  * 'flow_format', and returns the message. */
1176 struct ofpbuf *
1177 ofputil_encode_flow_stats_request(const struct flow_stats_request *fsr,
1178                                   enum nx_flow_format flow_format)
1179 {
1180     struct ofpbuf *msg;
1181
1182     if (flow_format == NXFF_OPENFLOW10
1183         || flow_format == NXFF_TUN_ID_FROM_COOKIE) {
1184         struct ofp_flow_stats_request *ofsr;
1185         int type;
1186
1187         BUILD_ASSERT_DECL(sizeof(struct ofp_flow_stats_request)
1188                           == sizeof(struct ofp_aggregate_stats_request));
1189
1190         type = fsr->aggregate ? OFPST_AGGREGATE : OFPST_FLOW;
1191         ofsr = ofputil_make_stats_request(sizeof *ofsr, type, &msg);
1192         ofputil_cls_rule_to_match(&fsr->match, flow_format, &ofsr->match,
1193                                   0, NULL);
1194         ofsr->table_id = fsr->table_id;
1195         ofsr->out_port = htons(fsr->out_port);
1196     } else if (flow_format == NXFF_NXM) {
1197         struct nx_flow_stats_request *nfsr;
1198         int match_len;
1199         int subtype;
1200
1201         subtype = fsr->aggregate ? NXST_AGGREGATE : NXST_FLOW;
1202         ofputil_make_nxstats_request(sizeof *nfsr, subtype, &msg);
1203         match_len = nx_put_match(msg, &fsr->match);
1204
1205         nfsr = msg->data;
1206         nfsr->out_port = htons(fsr->out_port);
1207         nfsr->match_len = htons(match_len);
1208         nfsr->table_id = fsr->table_id;
1209     } else {
1210         NOT_REACHED();
1211     }
1212
1213     return msg;
1214 }
1215
1216 /* Converts an OFPT_FLOW_REMOVED or NXT_FLOW_REMOVED message 'oh', received
1217  * when the current flow format was 'flow_format', into an abstract
1218  * ofputil_flow_removed in 'fr'.  Returns 0 if successful, otherwise an
1219  * OpenFlow error code.
1220  *
1221  * For OFPT_FLOW_REMOVED messages, 'flow_format' should be the current flow
1222  * format at the time when the message was received.  Otherwise 'flow_format'
1223  * is ignored. */
1224 int
1225 ofputil_decode_flow_removed(struct ofputil_flow_removed *fr,
1226                             const struct ofp_header *oh,
1227                             enum nx_flow_format flow_format)
1228 {
1229     const struct ofputil_msg_type *type;
1230     enum ofputil_msg_code code;
1231
1232     ofputil_decode_msg_type(oh, &type);
1233     code = ofputil_msg_type_code(type);
1234     if (code == OFPUTIL_OFPT_FLOW_REMOVED) {
1235         const struct ofp_flow_removed *ofr;
1236
1237         ofr = (const struct ofp_flow_removed *) oh;
1238         ofputil_cls_rule_from_match(&ofr->match, ntohs(ofr->priority),
1239                                     flow_format, ofr->cookie, &fr->rule);
1240         fr->cookie = ofr->cookie;
1241         fr->reason = ofr->reason;
1242         fr->duration_sec = ntohl(ofr->duration_sec);
1243         fr->duration_nsec = ntohl(ofr->duration_nsec);
1244         fr->idle_timeout = ntohs(ofr->idle_timeout);
1245         fr->packet_count = ntohll(ofr->packet_count);
1246         fr->byte_count = ntohll(ofr->byte_count);
1247     } else if (code == OFPUTIL_NXT_FLOW_REMOVED) {
1248         struct nx_flow_removed *nfr;
1249         struct ofpbuf b;
1250         int error;
1251
1252         ofpbuf_use_const(&b, oh, ntohs(oh->length));
1253
1254         nfr = ofpbuf_pull(&b, sizeof *nfr);
1255         error = nx_pull_match(&b, ntohs(nfr->match_len), ntohs(nfr->priority),
1256                               &fr->rule);
1257         if (error) {
1258             return error;
1259         }
1260         if (b.size) {
1261             return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
1262         }
1263
1264         fr->cookie = nfr->cookie;
1265         fr->reason = nfr->reason;
1266         fr->duration_sec = ntohl(nfr->duration_sec);
1267         fr->duration_nsec = ntohl(nfr->duration_nsec);
1268         fr->idle_timeout = ntohs(nfr->idle_timeout);
1269         fr->packet_count = ntohll(nfr->packet_count);
1270         fr->byte_count = ntohll(nfr->byte_count);
1271     } else {
1272         NOT_REACHED();
1273     }
1274
1275     return 0;
1276 }
1277
1278 /* Returns a string representing the message type of 'type'.  The string is the
1279  * enumeration constant for the type, e.g. "OFPT_HELLO".  For statistics
1280  * messages, the constant is followed by "request" or "reply",
1281  * e.g. "OFPST_AGGREGATE reply". */
1282 const char *
1283 ofputil_msg_type_name(const struct ofputil_msg_type *type)
1284 {
1285     return type->name;
1286 }
1287 \f
1288 /* Allocates and stores in '*bufferp' a new ofpbuf with a size of
1289  * 'openflow_len', starting with an OpenFlow header with the given 'type' and
1290  * an arbitrary transaction id.  Allocated bytes beyond the header, if any, are
1291  * zeroed.
1292  *
1293  * The caller is responsible for freeing '*bufferp' when it is no longer
1294  * needed.
1295  *
1296  * The OpenFlow header length is initially set to 'openflow_len'; if the
1297  * message is later extended, the length should be updated with
1298  * update_openflow_length() before sending.
1299  *
1300  * Returns the header. */
1301 void *
1302 make_openflow(size_t openflow_len, uint8_t type, struct ofpbuf **bufferp)
1303 {
1304     *bufferp = ofpbuf_new(openflow_len);
1305     return put_openflow_xid(openflow_len, type, alloc_xid(), *bufferp);
1306 }
1307
1308 /* Similar to make_openflow() but creates a Nicira vendor extension message
1309  * with the specific 'subtype'.  'subtype' should be in host byte order. */
1310 void *
1311 make_nxmsg(size_t openflow_len, uint32_t subtype, struct ofpbuf **bufferp)
1312 {
1313     return make_nxmsg_xid(openflow_len, subtype, alloc_xid(), bufferp);
1314 }
1315
1316 /* Allocates and stores in '*bufferp' a new ofpbuf with a size of
1317  * 'openflow_len', starting with an OpenFlow header with the given 'type' and
1318  * transaction id 'xid'.  Allocated bytes beyond the header, if any, are
1319  * zeroed.
1320  *
1321  * The caller is responsible for freeing '*bufferp' when it is no longer
1322  * needed.
1323  *
1324  * The OpenFlow header length is initially set to 'openflow_len'; if the
1325  * message is later extended, the length should be updated with
1326  * update_openflow_length() before sending.
1327  *
1328  * Returns the header. */
1329 void *
1330 make_openflow_xid(size_t openflow_len, uint8_t type, ovs_be32 xid,
1331                   struct ofpbuf **bufferp)
1332 {
1333     *bufferp = ofpbuf_new(openflow_len);
1334     return put_openflow_xid(openflow_len, type, xid, *bufferp);
1335 }
1336
1337 /* Similar to make_openflow_xid() but creates a Nicira vendor extension message
1338  * with the specific 'subtype'.  'subtype' should be in host byte order. */
1339 void *
1340 make_nxmsg_xid(size_t openflow_len, uint32_t subtype, ovs_be32 xid,
1341                struct ofpbuf **bufferp)
1342 {
1343     *bufferp = ofpbuf_new(openflow_len);
1344     return put_nxmsg_xid(openflow_len, subtype, xid, *bufferp);
1345 }
1346
1347 /* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
1348  * with the given 'type' and an arbitrary transaction id.  Allocated bytes
1349  * beyond the header, if any, are zeroed.
1350  *
1351  * The OpenFlow header length is initially set to 'openflow_len'; if the
1352  * message is later extended, the length should be updated with
1353  * update_openflow_length() before sending.
1354  *
1355  * Returns the header. */
1356 void *
1357 put_openflow(size_t openflow_len, uint8_t type, struct ofpbuf *buffer)
1358 {
1359     return put_openflow_xid(openflow_len, type, alloc_xid(), buffer);
1360 }
1361
1362 /* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
1363  * with the given 'type' and an transaction id 'xid'.  Allocated bytes beyond
1364  * the header, if any, are zeroed.
1365  *
1366  * The OpenFlow header length is initially set to 'openflow_len'; if the
1367  * message is later extended, the length should be updated with
1368  * update_openflow_length() before sending.
1369  *
1370  * Returns the header. */
1371 void *
1372 put_openflow_xid(size_t openflow_len, uint8_t type, ovs_be32 xid,
1373                  struct ofpbuf *buffer)
1374 {
1375     struct ofp_header *oh;
1376
1377     assert(openflow_len >= sizeof *oh);
1378     assert(openflow_len <= UINT16_MAX);
1379
1380     oh = ofpbuf_put_uninit(buffer, openflow_len);
1381     oh->version = OFP_VERSION;
1382     oh->type = type;
1383     oh->length = htons(openflow_len);
1384     oh->xid = xid;
1385     memset(oh + 1, 0, openflow_len - sizeof *oh);
1386     return oh;
1387 }
1388
1389 /* Similar to put_openflow() but append a Nicira vendor extension message with
1390  * the specific 'subtype'.  'subtype' should be in host byte order. */
1391 void *
1392 put_nxmsg(size_t openflow_len, uint32_t subtype, struct ofpbuf *buffer)
1393 {
1394     return put_nxmsg_xid(openflow_len, subtype, alloc_xid(), buffer);
1395 }
1396
1397 /* Similar to put_openflow_xid() but append a Nicira vendor extension message
1398  * with the specific 'subtype'.  'subtype' should be in host byte order. */
1399 void *
1400 put_nxmsg_xid(size_t openflow_len, uint32_t subtype, ovs_be32 xid,
1401               struct ofpbuf *buffer)
1402 {
1403     struct nicira_header *nxh;
1404
1405     nxh = put_openflow_xid(openflow_len, OFPT_VENDOR, xid, buffer);
1406     nxh->vendor = htonl(NX_VENDOR_ID);
1407     nxh->subtype = htonl(subtype);
1408     return nxh;
1409 }
1410
1411 /* Updates the 'length' field of the OpenFlow message in 'buffer' to
1412  * 'buffer->size'. */
1413 void
1414 update_openflow_length(struct ofpbuf *buffer)
1415 {
1416     struct ofp_header *oh = ofpbuf_at_assert(buffer, 0, sizeof *oh);
1417     oh->length = htons(buffer->size);
1418 }
1419
1420 /* Creates an ofp_stats_request with the given 'type' and 'body_len' bytes of
1421  * space allocated for the 'body' member.  Returns the first byte of the 'body'
1422  * member. */
1423 void *
1424 ofputil_make_stats_request(size_t body_len, uint16_t type,
1425                            struct ofpbuf **bufferp)
1426 {
1427     struct ofp_stats_request *osr;
1428     osr = make_openflow((offsetof(struct ofp_stats_request, body)
1429                         + body_len), OFPT_STATS_REQUEST, bufferp);
1430     osr->type = htons(type);
1431     osr->flags = htons(0);
1432     return osr->body;
1433 }
1434
1435 /* Creates a stats request message with Nicira as vendor and the given
1436  * 'subtype', of total length 'openflow_len'.  Returns the message. */
1437 void *
1438 ofputil_make_nxstats_request(size_t openflow_len, uint32_t subtype,
1439                              struct ofpbuf **bufferp)
1440 {
1441     struct nicira_stats_msg *nsm;
1442
1443     nsm = make_openflow(openflow_len, OFPT_STATS_REQUEST, bufferp);
1444     nsm->type = htons(OFPST_VENDOR);
1445     nsm->flags = htons(0);
1446     nsm->vendor = htonl(NX_VENDOR_ID);
1447     nsm->subtype = htonl(subtype);
1448     return nsm;
1449 }
1450
1451 /* Returns the first byte of the 'body' member of the ofp_stats_request or
1452  * ofp_stats_reply in 'oh'. */
1453 const void *
1454 ofputil_stats_body(const struct ofp_header *oh)
1455 {
1456     assert(oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY);
1457     return ((const struct ofp_stats_request *) oh)->body;
1458 }
1459
1460 /* Returns the length of the 'body' member of the ofp_stats_request or
1461  * ofp_stats_reply in 'oh'. */
1462 size_t
1463 ofputil_stats_body_len(const struct ofp_header *oh)
1464 {
1465     assert(oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY);
1466     return ntohs(oh->length) - sizeof(struct ofp_stats_request);
1467 }
1468
1469 /* Returns the first byte of the body of the nicira_stats_msg in 'oh'. */
1470 const void *
1471 ofputil_nxstats_body(const struct ofp_header *oh)
1472 {
1473     assert(oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY);
1474     return ((const struct nicira_stats_msg *) oh) + 1;
1475 }
1476
1477 /* Returns the length of the body of the nicira_stats_msg in 'oh'. */
1478 size_t
1479 ofputil_nxstats_body_len(const struct ofp_header *oh)
1480 {
1481     assert(oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY);
1482     return ntohs(oh->length) - sizeof(struct nicira_stats_msg);
1483 }
1484
1485 struct ofpbuf *
1486 make_flow_mod(uint16_t command, const struct cls_rule *rule,
1487               size_t actions_len)
1488 {
1489     struct ofp_flow_mod *ofm;
1490     size_t size = sizeof *ofm + actions_len;
1491     struct ofpbuf *out = ofpbuf_new(size);
1492     ofm = ofpbuf_put_zeros(out, sizeof *ofm);
1493     ofm->header.version = OFP_VERSION;
1494     ofm->header.type = OFPT_FLOW_MOD;
1495     ofm->header.length = htons(size);
1496     ofm->cookie = 0;
1497     ofm->priority = htons(MIN(rule->priority, UINT16_MAX));
1498     ofputil_cls_rule_to_match(rule, NXFF_OPENFLOW10, &ofm->match, 0, NULL);
1499     ofm->command = htons(command);
1500     return out;
1501 }
1502
1503 struct ofpbuf *
1504 make_add_flow(const struct cls_rule *rule, uint32_t buffer_id,
1505               uint16_t idle_timeout, size_t actions_len)
1506 {
1507     struct ofpbuf *out = make_flow_mod(OFPFC_ADD, rule, actions_len);
1508     struct ofp_flow_mod *ofm = out->data;
1509     ofm->idle_timeout = htons(idle_timeout);
1510     ofm->hard_timeout = htons(OFP_FLOW_PERMANENT);
1511     ofm->buffer_id = htonl(buffer_id);
1512     return out;
1513 }
1514
1515 struct ofpbuf *
1516 make_del_flow(const struct cls_rule *rule)
1517 {
1518     struct ofpbuf *out = make_flow_mod(OFPFC_DELETE_STRICT, rule, 0);
1519     struct ofp_flow_mod *ofm = out->data;
1520     ofm->out_port = htons(OFPP_NONE);
1521     return out;
1522 }
1523
1524 struct ofpbuf *
1525 make_add_simple_flow(const struct cls_rule *rule,
1526                      uint32_t buffer_id, uint16_t out_port,
1527                      uint16_t idle_timeout)
1528 {
1529     if (out_port != OFPP_NONE) {
1530         struct ofp_action_output *oao;
1531         struct ofpbuf *buffer;
1532
1533         buffer = make_add_flow(rule, buffer_id, idle_timeout, sizeof *oao);
1534         oao = ofpbuf_put_zeros(buffer, sizeof *oao);
1535         oao->type = htons(OFPAT_OUTPUT);
1536         oao->len = htons(sizeof *oao);
1537         oao->port = htons(out_port);
1538         return buffer;
1539     } else {
1540         return make_add_flow(rule, buffer_id, idle_timeout, 0);
1541     }
1542 }
1543
1544 struct ofpbuf *
1545 make_packet_in(uint32_t buffer_id, uint16_t in_port, uint8_t reason,
1546                const struct ofpbuf *payload, int max_send_len)
1547 {
1548     struct ofp_packet_in *opi;
1549     struct ofpbuf *buf;
1550     int send_len;
1551
1552     send_len = MIN(max_send_len, payload->size);
1553     buf = ofpbuf_new(sizeof *opi + send_len);
1554     opi = put_openflow_xid(offsetof(struct ofp_packet_in, data),
1555                            OFPT_PACKET_IN, 0, buf);
1556     opi->buffer_id = htonl(buffer_id);
1557     opi->total_len = htons(payload->size);
1558     opi->in_port = htons(in_port);
1559     opi->reason = reason;
1560     ofpbuf_put(buf, payload->data, send_len);
1561     update_openflow_length(buf);
1562
1563     return buf;
1564 }
1565
1566 struct ofpbuf *
1567 make_packet_out(const struct ofpbuf *packet, uint32_t buffer_id,
1568                 uint16_t in_port,
1569                 const struct ofp_action_header *actions, size_t n_actions)
1570 {
1571     size_t actions_len = n_actions * sizeof *actions;
1572     struct ofp_packet_out *opo;
1573     size_t size = sizeof *opo + actions_len + (packet ? packet->size : 0);
1574     struct ofpbuf *out = ofpbuf_new(size);
1575
1576     opo = ofpbuf_put_uninit(out, sizeof *opo);
1577     opo->header.version = OFP_VERSION;
1578     opo->header.type = OFPT_PACKET_OUT;
1579     opo->header.length = htons(size);
1580     opo->header.xid = htonl(0);
1581     opo->buffer_id = htonl(buffer_id);
1582     opo->in_port = htons(in_port == ODPP_LOCAL ? OFPP_LOCAL : in_port);
1583     opo->actions_len = htons(actions_len);
1584     ofpbuf_put(out, actions, actions_len);
1585     if (packet) {
1586         ofpbuf_put(out, packet->data, packet->size);
1587     }
1588     return out;
1589 }
1590
1591 struct ofpbuf *
1592 make_unbuffered_packet_out(const struct ofpbuf *packet,
1593                            uint16_t in_port, uint16_t out_port)
1594 {
1595     struct ofp_action_output action;
1596     action.type = htons(OFPAT_OUTPUT);
1597     action.len = htons(sizeof action);
1598     action.port = htons(out_port);
1599     return make_packet_out(packet, UINT32_MAX, in_port,
1600                            (struct ofp_action_header *) &action, 1);
1601 }
1602
1603 struct ofpbuf *
1604 make_buffered_packet_out(uint32_t buffer_id,
1605                          uint16_t in_port, uint16_t out_port)
1606 {
1607     if (out_port != OFPP_NONE) {
1608         struct ofp_action_output action;
1609         action.type = htons(OFPAT_OUTPUT);
1610         action.len = htons(sizeof action);
1611         action.port = htons(out_port);
1612         return make_packet_out(NULL, buffer_id, in_port,
1613                                (struct ofp_action_header *) &action, 1);
1614     } else {
1615         return make_packet_out(NULL, buffer_id, in_port, NULL, 0);
1616     }
1617 }
1618
1619 /* Creates and returns an OFPT_ECHO_REQUEST message with an empty payload. */
1620 struct ofpbuf *
1621 make_echo_request(void)
1622 {
1623     struct ofp_header *rq;
1624     struct ofpbuf *out = ofpbuf_new(sizeof *rq);
1625     rq = ofpbuf_put_uninit(out, sizeof *rq);
1626     rq->version = OFP_VERSION;
1627     rq->type = OFPT_ECHO_REQUEST;
1628     rq->length = htons(sizeof *rq);
1629     rq->xid = htonl(0);
1630     return out;
1631 }
1632
1633 /* Creates and returns an OFPT_ECHO_REPLY message matching the
1634  * OFPT_ECHO_REQUEST message in 'rq'. */
1635 struct ofpbuf *
1636 make_echo_reply(const struct ofp_header *rq)
1637 {
1638     size_t size = ntohs(rq->length);
1639     struct ofpbuf *out = ofpbuf_new(size);
1640     struct ofp_header *reply = ofpbuf_put(out, rq, size);
1641     reply->type = OFPT_ECHO_REPLY;
1642     return out;
1643 }
1644
1645 const struct ofp_flow_stats *
1646 flow_stats_first(struct flow_stats_iterator *iter,
1647                  const struct ofp_stats_reply *osr)
1648 {
1649     iter->pos = osr->body;
1650     iter->end = osr->body + (ntohs(osr->header.length)
1651                              - offsetof(struct ofp_stats_reply, body));
1652     return flow_stats_next(iter);
1653 }
1654
1655 const struct ofp_flow_stats *
1656 flow_stats_next(struct flow_stats_iterator *iter)
1657 {
1658     ptrdiff_t bytes_left = iter->end - iter->pos;
1659     const struct ofp_flow_stats *fs;
1660     size_t length;
1661
1662     if (bytes_left < sizeof *fs) {
1663         if (bytes_left != 0) {
1664             VLOG_WARN_RL(&bad_ofmsg_rl,
1665                          "%td leftover bytes in flow stats reply", bytes_left);
1666         }
1667         return NULL;
1668     }
1669
1670     fs = (const void *) iter->pos;
1671     length = ntohs(fs->length);
1672     if (length < sizeof *fs) {
1673         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu is shorter than "
1674                      "min %zu", length, sizeof *fs);
1675         return NULL;
1676     } else if (length > bytes_left) {
1677         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu but only %td "
1678                      "bytes left", length, bytes_left);
1679         return NULL;
1680     } else if ((length - sizeof *fs) % sizeof fs->actions[0]) {
1681         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu has %zu bytes "
1682                      "left over in final action", length,
1683                      (length - sizeof *fs) % sizeof fs->actions[0]);
1684         return NULL;
1685     }
1686     iter->pos += length;
1687     return fs;
1688 }
1689
1690 static int
1691 check_action_exact_len(const union ofp_action *a, unsigned int len,
1692                        unsigned int required_len)
1693 {
1694     if (len != required_len) {
1695         VLOG_WARN_RL(&bad_ofmsg_rl, "action %"PRIu16" has invalid length "
1696                      "%"PRIu16" (must be %u)\n",
1697                      ntohs(a->type), ntohs(a->header.len), required_len);
1698         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1699     }
1700     return 0;
1701 }
1702
1703 static int
1704 check_nx_action_exact_len(const struct nx_action_header *a,
1705                           unsigned int len, unsigned int required_len)
1706 {
1707     if (len != required_len) {
1708         VLOG_WARN_RL(&bad_ofmsg_rl,
1709                      "Nicira action %"PRIu16" has invalid length %"PRIu16" "
1710                      "(must be %u)\n",
1711                      ntohs(a->subtype), ntohs(a->len), required_len);
1712         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1713     }
1714     return 0;
1715 }
1716
1717 /* Checks that 'port' is a valid output port for the OFPAT_OUTPUT action, given
1718  * that the switch will never have more than 'max_ports' ports.  Returns 0 if
1719  * 'port' is valid, otherwise an ofp_mkerr() return code. */
1720 static int
1721 check_output_port(uint16_t port, int max_ports)
1722 {
1723     switch (port) {
1724     case OFPP_IN_PORT:
1725     case OFPP_TABLE:
1726     case OFPP_NORMAL:
1727     case OFPP_FLOOD:
1728     case OFPP_ALL:
1729     case OFPP_CONTROLLER:
1730     case OFPP_LOCAL:
1731         return 0;
1732
1733     default:
1734         if (port < max_ports) {
1735             return 0;
1736         }
1737         VLOG_WARN_RL(&bad_ofmsg_rl, "unknown output port %x", port);
1738         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT);
1739     }
1740 }
1741
1742 /* Checks that 'action' is a valid OFPAT_ENQUEUE action, given that the switch
1743  * will never have more than 'max_ports' ports.  Returns 0 if 'port' is valid,
1744  * otherwise an ofp_mkerr() return code. */
1745 static int
1746 check_enqueue_action(const union ofp_action *a, unsigned int len,
1747                      int max_ports)
1748 {
1749     const struct ofp_action_enqueue *oae;
1750     uint16_t port;
1751     int error;
1752
1753     error = check_action_exact_len(a, len, 16);
1754     if (error) {
1755         return error;
1756     }
1757
1758     oae = (const struct ofp_action_enqueue *) a;
1759     port = ntohs(oae->port);
1760     if (port < max_ports || port == OFPP_IN_PORT) {
1761         return 0;
1762     }
1763     VLOG_WARN_RL(&bad_ofmsg_rl, "unknown enqueue port %x", port);
1764     return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT);
1765 }
1766
1767 static int
1768 check_nicira_action(const union ofp_action *a, unsigned int len,
1769                     const struct flow *flow)
1770 {
1771     const struct nx_action_header *nah;
1772     uint16_t subtype;
1773     int error;
1774
1775     if (len < 16) {
1776         VLOG_WARN_RL(&bad_ofmsg_rl,
1777                      "Nicira vendor action only %u bytes", len);
1778         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1779     }
1780     nah = (const struct nx_action_header *) a;
1781
1782     subtype = ntohs(nah->subtype);
1783     if (subtype > TYPE_MAXIMUM(enum nx_action_subtype)) {
1784         /* This is necessary because enum nx_action_subtype is probably an
1785          * 8-bit type, so the cast below throws away the top 8 bits. */
1786         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE);
1787     }
1788
1789     switch ((enum nx_action_subtype) subtype) {
1790     case NXAST_RESUBMIT:
1791     case NXAST_SET_TUNNEL:
1792     case NXAST_DROP_SPOOFED_ARP:
1793     case NXAST_SET_QUEUE:
1794     case NXAST_POP_QUEUE:
1795         return check_nx_action_exact_len(nah, len, 16);
1796
1797     case NXAST_REG_MOVE:
1798         error = check_nx_action_exact_len(nah, len,
1799                                           sizeof(struct nx_action_reg_move));
1800         if (error) {
1801             return error;
1802         }
1803         return nxm_check_reg_move((const struct nx_action_reg_move *) a, flow);
1804
1805     case NXAST_REG_LOAD:
1806         error = check_nx_action_exact_len(nah, len,
1807                                           sizeof(struct nx_action_reg_load));
1808         if (error) {
1809             return error;
1810         }
1811         return nxm_check_reg_load((const struct nx_action_reg_load *) a, flow);
1812
1813     case NXAST_NOTE:
1814         return 0;
1815
1816     case NXAST_SET_TUNNEL64:
1817         return check_nx_action_exact_len(
1818             nah, len, sizeof(struct nx_action_set_tunnel64));
1819
1820     case NXAST_MULTIPATH:
1821         error = check_nx_action_exact_len(
1822             nah, len, sizeof(struct nx_action_multipath));
1823         if (error) {
1824             return error;
1825         }
1826         return multipath_check((const struct nx_action_multipath *) a);
1827
1828     case NXAST_SNAT__OBSOLETE:
1829     default:
1830         VLOG_WARN_RL(&bad_ofmsg_rl,
1831                      "unknown Nicira vendor action subtype %"PRIu16,
1832                      ntohs(nah->subtype));
1833         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE);
1834     }
1835 }
1836
1837 static int
1838 check_action(const union ofp_action *a, unsigned int len,
1839              const struct flow *flow, int max_ports)
1840 {
1841     enum ofp_action_type type = ntohs(a->type);
1842     int error;
1843
1844     switch (type) {
1845     case OFPAT_OUTPUT:
1846         error = check_action_exact_len(a, len, 8);
1847         if (error) {
1848             return error;
1849         }
1850         return check_output_port(ntohs(a->output.port), max_ports);
1851
1852     case OFPAT_SET_VLAN_VID:
1853         error = check_action_exact_len(a, len, 8);
1854         if (error) {
1855             return error;
1856         }
1857         if (a->vlan_vid.vlan_vid & ~htons(0xfff)) {
1858             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT);
1859         }
1860         return 0;
1861
1862     case OFPAT_SET_VLAN_PCP:
1863         error = check_action_exact_len(a, len, 8);
1864         if (error) {
1865             return error;
1866         }
1867         if (a->vlan_vid.vlan_vid & ~7) {
1868             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT);
1869         }
1870         return 0;
1871
1872     case OFPAT_STRIP_VLAN:
1873     case OFPAT_SET_NW_SRC:
1874     case OFPAT_SET_NW_DST:
1875     case OFPAT_SET_NW_TOS:
1876     case OFPAT_SET_TP_SRC:
1877     case OFPAT_SET_TP_DST:
1878         return check_action_exact_len(a, len, 8);
1879
1880     case OFPAT_SET_DL_SRC:
1881     case OFPAT_SET_DL_DST:
1882         return check_action_exact_len(a, len, 16);
1883
1884     case OFPAT_VENDOR:
1885         return (a->vendor.vendor == htonl(NX_VENDOR_ID)
1886                 ? check_nicira_action(a, len, flow)
1887                 : ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR));
1888
1889     case OFPAT_ENQUEUE:
1890         return check_enqueue_action(a, len, max_ports);
1891
1892     default:
1893         VLOG_WARN_RL(&bad_ofmsg_rl, "unknown action type %d", (int) type);
1894         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE);
1895     }
1896 }
1897
1898 int
1899 validate_actions(const union ofp_action *actions, size_t n_actions,
1900                  const struct flow *flow, int max_ports)
1901 {
1902     size_t i;
1903
1904     for (i = 0; i < n_actions; ) {
1905         const union ofp_action *a = &actions[i];
1906         unsigned int len = ntohs(a->header.len);
1907         unsigned int n_slots = len / OFP_ACTION_ALIGN;
1908         unsigned int slots_left = &actions[n_actions] - a;
1909         int error;
1910
1911         if (n_slots > slots_left) {
1912             VLOG_WARN_RL(&bad_ofmsg_rl,
1913                          "action requires %u slots but only %u remain",
1914                          n_slots, slots_left);
1915             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1916         } else if (!len) {
1917             VLOG_WARN_RL(&bad_ofmsg_rl, "action has invalid length 0");
1918             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1919         } else if (len % OFP_ACTION_ALIGN) {
1920             VLOG_WARN_RL(&bad_ofmsg_rl, "action length %u is not a multiple "
1921                          "of %d", len, OFP_ACTION_ALIGN);
1922             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1923         }
1924
1925         error = check_action(a, len, flow, max_ports);
1926         if (error) {
1927             return error;
1928         }
1929         i += n_slots;
1930     }
1931     return 0;
1932 }
1933
1934 /* Returns true if 'action' outputs to 'port' (which must be in network byte
1935  * order), false otherwise. */
1936 bool
1937 action_outputs_to_port(const union ofp_action *action, uint16_t port)
1938 {
1939     switch (ntohs(action->type)) {
1940     case OFPAT_OUTPUT:
1941         return action->output.port == port;
1942     case OFPAT_ENQUEUE:
1943         return ((const struct ofp_action_enqueue *) action)->port == port;
1944     default:
1945         return false;
1946     }
1947 }
1948
1949 /* The set of actions must either come from a trusted source or have been
1950  * previously validated with validate_actions(). */
1951 const union ofp_action *
1952 actions_first(struct actions_iterator *iter,
1953               const union ofp_action *oa, size_t n_actions)
1954 {
1955     iter->pos = oa;
1956     iter->end = oa + n_actions;
1957     return actions_next(iter);
1958 }
1959
1960 const union ofp_action *
1961 actions_next(struct actions_iterator *iter)
1962 {
1963     if (iter->pos != iter->end) {
1964         const union ofp_action *a = iter->pos;
1965         unsigned int len = ntohs(a->header.len);
1966         iter->pos += len / OFP_ACTION_ALIGN;
1967         return a;
1968     } else {
1969         return NULL;
1970     }
1971 }
1972
1973 void
1974 normalize_match(struct ofp_match *m)
1975 {
1976     enum { OFPFW_NW = (OFPFW_NW_SRC_MASK | OFPFW_NW_DST_MASK | OFPFW_NW_PROTO
1977                        | OFPFW_NW_TOS) };
1978     enum { OFPFW_TP = OFPFW_TP_SRC | OFPFW_TP_DST };
1979     uint32_t wc;
1980
1981     wc = ntohl(m->wildcards) & OVSFW_ALL;
1982     if (wc & OFPFW_DL_TYPE) {
1983         m->dl_type = 0;
1984
1985         /* Can't sensibly match on network or transport headers if the
1986          * data link type is unknown. */
1987         wc |= OFPFW_NW | OFPFW_TP;
1988         m->nw_src = m->nw_dst = m->nw_proto = m->nw_tos = 0;
1989         m->tp_src = m->tp_dst = 0;
1990     } else if (m->dl_type == htons(ETH_TYPE_IP)) {
1991         if (wc & OFPFW_NW_PROTO) {
1992             m->nw_proto = 0;
1993
1994             /* Can't sensibly match on transport headers if the network
1995              * protocol is unknown. */
1996             wc |= OFPFW_TP;
1997             m->tp_src = m->tp_dst = 0;
1998         } else if (m->nw_proto == IPPROTO_TCP ||
1999                    m->nw_proto == IPPROTO_UDP ||
2000                    m->nw_proto == IPPROTO_ICMP) {
2001             if (wc & OFPFW_TP_SRC) {
2002                 m->tp_src = 0;
2003             }
2004             if (wc & OFPFW_TP_DST) {
2005                 m->tp_dst = 0;
2006             }
2007         } else {
2008             /* Transport layer fields will always be extracted as zeros, so we
2009              * can do an exact-match on those values.  */
2010             wc &= ~OFPFW_TP;
2011             m->tp_src = m->tp_dst = 0;
2012         }
2013         if (wc & OFPFW_NW_SRC_MASK) {
2014             m->nw_src &= ofputil_wcbits_to_netmask(wc >> OFPFW_NW_SRC_SHIFT);
2015         }
2016         if (wc & OFPFW_NW_DST_MASK) {
2017             m->nw_dst &= ofputil_wcbits_to_netmask(wc >> OFPFW_NW_DST_SHIFT);
2018         }
2019         if (wc & OFPFW_NW_TOS) {
2020             m->nw_tos = 0;
2021         } else {
2022             m->nw_tos &= IP_DSCP_MASK;
2023         }
2024     } else if (m->dl_type == htons(ETH_TYPE_ARP)) {
2025         if (wc & OFPFW_NW_PROTO) {
2026             m->nw_proto = 0;
2027         }
2028         if (wc & OFPFW_NW_SRC_MASK) {
2029             m->nw_src &= ofputil_wcbits_to_netmask(wc >> OFPFW_NW_SRC_SHIFT);
2030         }
2031         if (wc & OFPFW_NW_DST_MASK) {
2032             m->nw_dst &= ofputil_wcbits_to_netmask(wc >> OFPFW_NW_DST_SHIFT);
2033         }
2034         m->tp_src = m->tp_dst = m->nw_tos = 0;
2035     } else {
2036         /* Network and transport layer fields will always be extracted as
2037          * zeros, so we can do an exact-match on those values. */
2038         wc &= ~(OFPFW_NW | OFPFW_TP);
2039         m->nw_proto = m->nw_src = m->nw_dst = m->nw_tos = 0;
2040         m->tp_src = m->tp_dst = 0;
2041     }
2042     if (wc & OFPFW_DL_SRC) {
2043         memset(m->dl_src, 0, sizeof m->dl_src);
2044     }
2045     if (wc & OFPFW_DL_DST) {
2046         memset(m->dl_dst, 0, sizeof m->dl_dst);
2047     }
2048     m->wildcards = htonl(wc);
2049 }
2050
2051 /* Returns a string that describes 'match' in a very literal way, without
2052  * interpreting its contents except in a very basic fashion.  The returned
2053  * string is intended to be fixed-length, so that it is easy to see differences
2054  * between two such strings if one is put above another.  This is useful for
2055  * describing changes made by normalize_match().
2056  *
2057  * The caller must free the returned string (with free()). */
2058 char *
2059 ofp_match_to_literal_string(const struct ofp_match *match)
2060 {
2061     return xasprintf("wildcards=%#10"PRIx32" "
2062                      " in_port=%5"PRId16" "
2063                      " dl_src="ETH_ADDR_FMT" "
2064                      " dl_dst="ETH_ADDR_FMT" "
2065                      " dl_vlan=%5"PRId16" "
2066                      " dl_vlan_pcp=%3"PRId8" "
2067                      " dl_type=%#6"PRIx16" "
2068                      " nw_tos=%#4"PRIx8" "
2069                      " nw_proto=%#4"PRIx16" "
2070                      " nw_src=%#10"PRIx32" "
2071                      " nw_dst=%#10"PRIx32" "
2072                      " tp_src=%5"PRId16" "
2073                      " tp_dst=%5"PRId16,
2074                      ntohl(match->wildcards),
2075                      ntohs(match->in_port),
2076                      ETH_ADDR_ARGS(match->dl_src),
2077                      ETH_ADDR_ARGS(match->dl_dst),
2078                      ntohs(match->dl_vlan),
2079                      match->dl_vlan_pcp,
2080                      ntohs(match->dl_type),
2081                      match->nw_tos,
2082                      match->nw_proto,
2083                      ntohl(match->nw_src),
2084                      ntohl(match->nw_dst),
2085                      ntohs(match->tp_src),
2086                      ntohs(match->tp_dst));
2087 }
2088
2089 static uint32_t
2090 vendor_code_to_id(uint8_t code)
2091 {
2092     switch (code) {
2093 #define OFPUTIL_VENDOR(NAME, VENDOR_ID) case NAME: return VENDOR_ID;
2094         OFPUTIL_VENDORS
2095 #undef OFPUTIL_VENDOR
2096     default:
2097         return UINT32_MAX;
2098     }
2099 }
2100
2101 static int
2102 vendor_id_to_code(uint32_t id)
2103 {
2104     switch (id) {
2105 #define OFPUTIL_VENDOR(NAME, VENDOR_ID) case VENDOR_ID: return NAME;
2106         OFPUTIL_VENDORS
2107 #undef OFPUTIL_VENDOR
2108     default:
2109         return -1;
2110     }
2111 }
2112
2113 /* Creates and returns an OpenFlow message of type OFPT_ERROR with the error
2114  * information taken from 'error', whose encoding must be as described in the
2115  * large comment in ofp-util.h.  If 'oh' is nonnull, then the error will use
2116  * oh->xid as its transaction ID, and it will include up to the first 64 bytes
2117  * of 'oh'.
2118  *
2119  * Returns NULL if 'error' is not an OpenFlow error code. */
2120 struct ofpbuf *
2121 ofputil_encode_error_msg(int error, const struct ofp_header *oh)
2122 {
2123     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2124
2125     struct ofpbuf *buf;
2126     const void *data;
2127     size_t len;
2128     uint8_t vendor;
2129     uint16_t type;
2130     uint16_t code;
2131     ovs_be32 xid;
2132
2133     if (!is_ofp_error(error)) {
2134         /* We format 'error' with strerror() here since it seems likely to be
2135          * a system errno value. */
2136         VLOG_WARN_RL(&rl, "invalid OpenFlow error code %d (%s)",
2137                      error, strerror(error));
2138         return NULL;
2139     }
2140
2141     if (oh) {
2142         xid = oh->xid;
2143         data = oh;
2144         len = ntohs(oh->length);
2145         if (len > 64) {
2146             len = 64;
2147         }
2148     } else {
2149         xid = 0;
2150         data = NULL;
2151         len = 0;
2152     }
2153
2154     vendor = get_ofp_err_vendor(error);
2155     type = get_ofp_err_type(error);
2156     code = get_ofp_err_code(error);
2157     if (vendor == OFPUTIL_VENDOR_OPENFLOW) {
2158         struct ofp_error_msg *oem;
2159
2160         oem = make_openflow_xid(len + sizeof *oem, OFPT_ERROR, xid, &buf);
2161         oem->type = htons(type);
2162         oem->code = htons(code);
2163     } else {
2164         struct ofp_error_msg *oem;
2165         struct nx_vendor_error *nve;
2166         uint32_t vendor_id;
2167
2168         vendor_id = vendor_code_to_id(vendor);
2169         if (vendor_id == UINT32_MAX) {
2170             VLOG_WARN_RL(&rl, "error %x contains invalid vendor code %d",
2171                          error, vendor);
2172             return NULL;
2173         }
2174
2175         oem = make_openflow_xid(len + sizeof *oem + sizeof *nve,
2176                                 OFPT_ERROR, xid, &buf);
2177         oem->type = htons(NXET_VENDOR);
2178         oem->code = htons(NXVC_VENDOR_ERROR);
2179
2180         nve = (struct nx_vendor_error *)oem->data;
2181         nve->vendor = htonl(vendor_id);
2182         nve->type = htons(type);
2183         nve->code = htons(code);
2184     }
2185
2186     if (len) {
2187         buf->size -= len;
2188         ofpbuf_put(buf, data, len);
2189     }
2190
2191     return buf;
2192 }
2193
2194 /* Decodes 'oh', which should be an OpenFlow OFPT_ERROR message, and returns an
2195  * Open vSwitch internal error code in the format described in the large
2196  * comment in ofp-util.h.
2197  *
2198  * If 'payload_ofs' is nonnull, on success '*payload_ofs' is set to the offset
2199  * to the payload starting from 'oh' and on failure it is set to 0. */
2200 int
2201 ofputil_decode_error_msg(const struct ofp_header *oh, size_t *payload_ofs)
2202 {
2203     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2204
2205     const struct ofp_error_msg *oem;
2206     uint16_t type, code;
2207     struct ofpbuf b;
2208     int vendor;
2209
2210     if (payload_ofs) {
2211         *payload_ofs = 0;
2212     }
2213     if (oh->type != OFPT_ERROR) {
2214         return EPROTO;
2215     }
2216
2217     ofpbuf_use_const(&b, oh, ntohs(oh->length));
2218     oem = ofpbuf_try_pull(&b, sizeof *oem);
2219     if (!oem) {
2220         return EPROTO;
2221     }
2222
2223     type = ntohs(oem->type);
2224     code = ntohs(oem->code);
2225     if (type == NXET_VENDOR && code == NXVC_VENDOR_ERROR) {
2226         const struct nx_vendor_error *nve = ofpbuf_try_pull(&b, sizeof *nve);
2227         if (!nve) {
2228             return EPROTO;
2229         }
2230
2231         vendor = vendor_id_to_code(ntohl(nve->vendor));
2232         if (vendor < 0) {
2233             VLOG_WARN_RL(&rl, "error contains unknown vendor ID %#"PRIx32,
2234                          ntohl(nve->vendor));
2235             return EPROTO;
2236         }
2237         type = ntohs(nve->type);
2238         code = ntohs(nve->code);
2239     } else {
2240         vendor = OFPUTIL_VENDOR_OPENFLOW;
2241     }
2242
2243     if (type >= 1024) {
2244         VLOG_WARN_RL(&rl, "error contains type %"PRIu16" greater than "
2245                      "supported maximum value 1023", type);
2246         return EPROTO;
2247     }
2248
2249     if (payload_ofs) {
2250         *payload_ofs = (uint8_t *) b.data - (uint8_t *) oh;
2251     }
2252     return ofp_mkerr_vendor(vendor, type, code);
2253 }
2254
2255 void
2256 ofputil_format_error(struct ds *s, int error)
2257 {
2258     if (is_errno(error)) {
2259         ds_put_cstr(s, strerror(error));
2260     } else {
2261         uint16_t type = get_ofp_err_type(error);
2262         uint16_t code = get_ofp_err_code(error);
2263         const char *type_s = ofp_error_type_to_string(type);
2264         const char *code_s = ofp_error_code_to_string(type, code);
2265
2266         ds_put_format(s, "type ");
2267         if (type_s) {
2268             ds_put_cstr(s, type_s);
2269         } else {
2270             ds_put_format(s, "%"PRIu16, type);
2271         }
2272
2273         ds_put_cstr(s, ", code ");
2274         if (code_s) {
2275             ds_put_cstr(s, code_s);
2276         } else {
2277             ds_put_format(s, "%"PRIu16, code);
2278         }
2279     }
2280 }
2281
2282 char *
2283 ofputil_error_to_string(int error)
2284 {
2285     struct ds s = DS_EMPTY_INITIALIZER;
2286     ofputil_format_error(&s, error);
2287     return ds_steal_cstr(&s);
2288 }
2289
2290 /* Attempts to pull 'actions_len' bytes from the front of 'b'.  Returns 0 if
2291  * successful, otherwise an OpenFlow error.
2292  *
2293  * If successful, the first action is stored in '*actionsp' and the number of
2294  * "union ofp_action" size elements into '*n_actionsp'.  Otherwise NULL and 0
2295  * are stored, respectively.
2296  *
2297  * This function does not check that the actions are valid (the caller should
2298  * do so, with validate_actions()).  The caller is also responsible for making
2299  * sure that 'b->data' is initially aligned appropriately for "union
2300  * ofp_action". */
2301 int
2302 ofputil_pull_actions(struct ofpbuf *b, unsigned int actions_len,
2303                      union ofp_action **actionsp, size_t *n_actionsp)
2304 {
2305     if (actions_len % OFP_ACTION_ALIGN != 0) {
2306         VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message actions length %u "
2307                      "is not a multiple of %d", actions_len, OFP_ACTION_ALIGN);
2308         goto error;
2309     }
2310
2311     *actionsp = ofpbuf_try_pull(b, actions_len);
2312     if (*actionsp == NULL) {
2313         VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message actions length %u "
2314                      "exceeds remaining message length (%zu)",
2315                      actions_len, b->size);
2316         goto error;
2317     }
2318
2319     *n_actionsp = actions_len / OFP_ACTION_ALIGN;
2320     return 0;
2321
2322 error:
2323     *actionsp = NULL;
2324     *n_actionsp = 0;
2325     return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
2326 }