Merge branch 'master' of git://openvswitch.org/openvswitch
[sliver-openvswitch.git] / lib / ofp-msgs.c
1 /*
2  * Copyright (c) 2012 Nicira, Inc.
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-msgs.h"
19 #include <assert.h>
20 #include "byte-order.h"
21 #include "dynamic-string.h"
22 #include "hash.h"
23 #include "hmap.h"
24 #include "ofpbuf.h"
25 #include "openflow/nicira-ext.h"
26 #include "openflow/openflow.h"
27 #include "vlog.h"
28
29 VLOG_DEFINE_THIS_MODULE(ofp_msgs);
30
31 #define OFPT_VENDOR 4
32 #define OFPT10_STATS_REQUEST 16
33 #define OFPT10_STATS_REPLY 17
34 #define OFPT11_STATS_REQUEST 18
35 #define OFPT11_STATS_REPLY 19
36 #define OFPST_VENDOR 0xffff
37
38 /* A thin abstraction of OpenFlow headers:
39  *
40  *   - 'version' and 'type' come straight from struct ofp_header, so these are
41  *     always present and meaningful.
42  *
43  *   - 'stat' comes from the 'type' member in statistics messages only.  It is
44  *     meaningful, therefore, only if 'version' and 'type' taken together
45  *     specify a statistics request or reply.  Otherwise it is 0.
46  *
47  *   - 'vendor' is meaningful only for vendor messages, that is, if 'version'
48  *     and 'type' specify a vendor message or if 'version' and 'type' specify
49  *     a statistics message and 'stat' specifies a vendor statistic type.
50  *     Otherwise it is 0.
51  *
52  *   - 'subtype' is meaningful only for vendor messages and otherwise 0.  It
53  *     specifies a vendor-defined subtype.  There is no standard format for
54  *     these but 32 bits seems like it should be enough. */
55 struct ofphdrs {
56     uint8_t version;            /* From ofp_header. */
57     uint8_t type;               /* From ofp_header. */
58     uint16_t stat;              /* From ofp10_stats_msg or ofp11_stats_msg. */
59     uint32_t vendor;            /* From ofp_vendor_header,
60                                  * ofp10_vendor_stats_msg, or
61                                  * ofp11_vendor_stats_msg. */
62     uint32_t subtype;           /* From nicira_header, nicira10_stats_msg, or
63                                  * nicira11_stats_msg. */
64 };
65 BUILD_ASSERT_DECL(sizeof(struct ofphdrs) == 12);
66
67 /* A mapping from OpenFlow headers to OFPRAW_*.  */
68 struct raw_instance {
69     struct hmap_node hmap_node; /* In 'raw_instance_map'. */
70     struct ofphdrs hdrs;        /* Key. */
71     enum ofpraw raw;            /* Value. */
72     unsigned int hdrs_len;      /* ofphdrs_len(hdrs). */
73 };
74
75 /* Information about a particular 'enum ofpraw'. */
76 struct raw_info {
77     /* All possible instantiations of this OFPRAW_* into OpenFlow headers. */
78     struct raw_instance *instances; /* min_version - max_version + 1 elems. */
79     uint8_t min_version;
80     uint8_t max_version;
81
82     unsigned int min_body;
83     unsigned int extra_multiple;
84     enum ofptype type;
85     const char *name;
86 };
87
88 /* All understood OpenFlow message types, indexed by their 'struct ofphdrs'. */
89 static struct hmap raw_instance_map;
90 #include "ofp-msgs.inc"
91
92 static ovs_be32 alloc_xid(void);
93
94 /* ofphdrs functions. */
95 static uint32_t ofphdrs_hash(const struct ofphdrs *);
96 static bool ofphdrs_equal(const struct ofphdrs *a, const struct ofphdrs *b);
97 static enum ofperr ofphdrs_decode(struct ofphdrs *,
98                                   const struct ofp_header *oh, size_t length);
99 static void ofphdrs_decode_assert(struct ofphdrs *,
100                                   const struct ofp_header *oh, size_t length);
101 size_t ofphdrs_len(const struct ofphdrs *);
102
103 static const struct raw_info *raw_info_get(enum ofpraw);
104 static struct raw_instance *raw_instance_get(const struct raw_info *,
105                                              uint8_t version);
106
107 static enum ofperr ofpraw_from_ofphdrs(enum ofpraw *, const struct ofphdrs *);
108 \f
109 /* Returns a transaction ID to use for an outgoing OpenFlow message. */
110 static ovs_be32
111 alloc_xid(void)
112 {
113     static uint32_t next_xid = 1;
114     return htonl(next_xid++);
115 }
116 \f
117 static uint32_t
118 ofphdrs_hash(const struct ofphdrs *hdrs)
119 {
120     BUILD_ASSERT_DECL(sizeof *hdrs == 12);
121     return hash_words((const uint32_t *) hdrs, 3, 0);
122 }
123
124 static bool
125 ofphdrs_equal(const struct ofphdrs *a, const struct ofphdrs *b)
126 {
127     return !memcmp(a, b, sizeof *a);
128 }
129
130 static void
131 log_bad_vendor(uint32_t vendor)
132 {
133     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
134
135     VLOG_WARN_RL(&rl, "OpenFlow message has unknown vendor %#"PRIx32, vendor);
136 }
137
138 static enum ofperr
139 ofphdrs_decode(struct ofphdrs *hdrs,
140                const struct ofp_header *oh, size_t length)
141 {
142     memset(hdrs, 0, sizeof *hdrs);
143     if (length < sizeof *oh) {
144         return OFPERR_OFPBRC_BAD_LEN;
145     }
146
147     /* Get base message version and type (OFPT_*). */
148     hdrs->version = oh->version;
149     hdrs->type = oh->type;
150
151     if (hdrs->type == OFPT_VENDOR) {
152         /* Get vendor. */
153         const struct ofp_vendor_header *ovh;
154
155         if (length < sizeof *ovh) {
156             return OFPERR_OFPBRC_BAD_LEN;
157         }
158
159         ovh = (const struct ofp_vendor_header *) oh;
160         hdrs->vendor = ntohl(ovh->vendor);
161         if (hdrs->vendor == NX_VENDOR_ID) {
162             /* Get Nicira message subtype (NXT_*). */
163             const struct nicira_header *nh;
164
165             if (length < sizeof *nh) {
166                 return OFPERR_OFPBRC_BAD_LEN;
167             }
168             nh = (const struct nicira_header *) oh;
169             hdrs->subtype = ntohl(nh->subtype);
170         } else {
171             log_bad_vendor(hdrs->vendor);
172             return OFPERR_OFPBRC_BAD_VENDOR;
173         }
174     } else if (hdrs->version == OFP10_VERSION
175                && (hdrs->type == OFPT10_STATS_REQUEST ||
176                    hdrs->type == OFPT10_STATS_REPLY)) {
177         const struct ofp10_stats_msg *osm;
178
179         /* Get statistic type (OFPST_*). */
180         if (length < sizeof *osm) {
181             return OFPERR_OFPBRC_BAD_LEN;
182         }
183         osm = (const struct ofp10_stats_msg *) oh;
184         hdrs->stat = ntohs(osm->type);
185
186         if (hdrs->stat == OFPST_VENDOR) {
187             /* Get vendor. */
188             const struct ofp10_vendor_stats_msg *ovsm;
189
190             if (length < sizeof *ovsm) {
191                 return OFPERR_OFPBRC_BAD_LEN;
192             }
193
194             ovsm = (const struct ofp10_vendor_stats_msg *) oh;
195             hdrs->vendor = ntohl(ovsm->vendor);
196             if (hdrs->vendor == NX_VENDOR_ID) {
197                 /* Get Nicira statistic type (NXST_*). */
198                 const struct nicira10_stats_msg *nsm;
199
200                 if (length < sizeof *nsm) {
201                     return OFPERR_OFPBRC_BAD_LEN;
202                 }
203                 nsm = (const struct nicira10_stats_msg *) oh;
204                 hdrs->subtype = ntohl(nsm->subtype);
205             } else {
206                 log_bad_vendor(hdrs->vendor);
207                 return OFPERR_OFPBRC_BAD_VENDOR;
208             }
209         }
210     } else if (hdrs->version != OFP10_VERSION
211                && (hdrs->type == OFPT11_STATS_REQUEST ||
212                    hdrs->type == OFPT11_STATS_REPLY)) {
213         const struct ofp11_stats_msg *osm;
214
215         /* Get statistic type (OFPST_*). */
216         if (length < sizeof *osm) {
217             return OFPERR_OFPBRC_BAD_LEN;
218         }
219         osm = (const struct ofp11_stats_msg *) oh;
220         hdrs->stat = ntohs(osm->type);
221
222         if (hdrs->stat == OFPST_VENDOR) {
223             /* Get vendor. */
224             const struct ofp11_vendor_stats_msg *ovsm;
225
226             if (length < sizeof *ovsm) {
227                 return OFPERR_OFPBRC_BAD_LEN;
228             }
229
230             ovsm = (const struct ofp11_vendor_stats_msg *) oh;
231             hdrs->vendor = ntohl(ovsm->vendor);
232             if (hdrs->vendor == NX_VENDOR_ID) {
233                 /* Get Nicira statistic type (NXST_*). */
234                 const struct nicira11_stats_msg *nsm;
235
236                 if (length < sizeof *nsm) {
237                     return OFPERR_OFPBRC_BAD_LEN;
238                 }
239                 nsm = (const struct nicira11_stats_msg *) oh;
240                 hdrs->subtype = ntohl(nsm->subtype);
241             } else {
242                 log_bad_vendor(hdrs->vendor);
243                 return OFPERR_OFPBRC_BAD_VENDOR;
244             }
245         }
246     }
247
248     return 0;
249 }
250
251 static void
252 ofphdrs_decode_assert(struct ofphdrs *hdrs,
253                       const struct ofp_header *oh, size_t length)
254 {
255     enum ofperr error = ofphdrs_decode(hdrs, oh, length);
256     assert(!error);
257 }
258
259 static bool
260 ofphdrs_is_stat(const struct ofphdrs *hdrs)
261 {
262     switch ((enum ofp_version) hdrs->version) {
263     case OFP10_VERSION:
264         return (hdrs->type == OFPT10_STATS_REQUEST ||
265                 hdrs->type == OFPT10_STATS_REPLY);
266     case OFP11_VERSION:
267     case OFP12_VERSION:
268         return (hdrs->type == OFPT11_STATS_REQUEST ||
269                 hdrs->type == OFPT11_STATS_REPLY);
270     }
271
272     return false;
273 }
274
275 size_t
276 ofphdrs_len(const struct ofphdrs *hdrs)
277 {
278     if (hdrs->type == OFPT_VENDOR) {
279         return sizeof(struct nicira_header);
280     }
281
282     switch ((enum ofp_version) hdrs->version) {
283     case OFP10_VERSION:
284         if (hdrs->type == OFPT10_STATS_REQUEST ||
285             hdrs->type == OFPT10_STATS_REPLY) {
286             return (hdrs->stat == OFPST_VENDOR
287                     ? sizeof(struct nicira10_stats_msg)
288                     : sizeof(struct ofp10_stats_msg));
289         }
290         break;
291
292     case OFP11_VERSION:
293     case OFP12_VERSION:
294         if (hdrs->type == OFPT11_STATS_REQUEST ||
295             hdrs->type == OFPT11_STATS_REPLY) {
296             return (hdrs->stat == OFPST_VENDOR
297                     ? sizeof(struct nicira11_stats_msg)
298                     : sizeof(struct ofp11_stats_msg));
299         }
300         break;
301     }
302
303     return sizeof(struct ofp_header);
304 }
305 \f
306 /* Determines the OFPRAW_* type of the OpenFlow message at 'oh', which has
307  * length 'oh->length'.  (The caller must ensure that 'oh->length' bytes of
308  * data are readable at 'oh'.)  On success, returns 0 and stores the type into
309  * '*raw'.  On failure, returns an OFPERR_* error code and zeros '*raw'.
310  *
311  * This function checks that 'oh' is a valid length for its particular type of
312  * message, and returns an error if not. */
313 enum ofperr
314 ofpraw_decode(enum ofpraw *raw, const struct ofp_header *oh)
315 {
316     struct ofpbuf msg;
317
318     ofpbuf_use_const(&msg, oh, ntohs(oh->length));
319     return ofpraw_pull(raw, &msg);
320 }
321
322 /* Determines the OFPRAW_* type of the OpenFlow message in 'msg', which starts
323  * at 'msg->data' and has length 'msg->size' bytes.  On success, returns 0 and
324  * stores the type into '*rawp'.  On failure, returns an OFPERR_* error code
325  * and zeros '*rawp'.
326  *
327  * This function checks that the message has a valid length for its particular
328  * type of message, and returns an error if not.
329  *
330  * In addition to setting '*rawp', this function pulls off the OpenFlow header
331  * (including the stats headers, vendor header, and any subtype header) with
332  * ofpbuf_pull().  It also sets 'msg->l2' to the start of the OpenFlow header
333  * and 'msg->l3' just beyond the headers (that is, to the final value of
334  * msg->data). */
335 enum ofperr
336 ofpraw_pull(enum ofpraw *rawp, struct ofpbuf *msg)
337 {
338     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
339
340     const struct raw_instance *instance;
341     const struct raw_info *info;
342     struct ofphdrs hdrs;
343
344     unsigned int min_len;
345     unsigned int len;
346
347     enum ofperr error;
348     enum ofpraw raw;
349
350     /* Set default outputs. */
351     msg->l2 = msg->l3 = msg->data;
352     *rawp = 0;
353
354     len = msg->size;
355     error = ofphdrs_decode(&hdrs, msg->data, len);
356     if (error) {
357         return error;
358     }
359
360     error = ofpraw_from_ofphdrs(&raw, &hdrs);
361     if (error) {
362         return error;
363     }
364
365     info = raw_info_get(raw);
366     instance = raw_instance_get(info, hdrs.version);
367     msg->l2 = ofpbuf_pull(msg, instance->hdrs_len);
368     msg->l3 = msg->data;
369
370     min_len = instance->hdrs_len + info->min_body;
371     switch (info->extra_multiple) {
372     case 0:
373         if (len != min_len) {
374             VLOG_WARN_RL(&rl, "received %s with incorrect length %u (expected "
375                          "length %u)", info->name, len, min_len);
376             return OFPERR_OFPBRC_BAD_LEN;
377         }
378         break;
379
380     case 1:
381         if (len < min_len) {
382             VLOG_WARN_RL(&rl, "received %s with incorrect length %u (expected "
383                          "length at least %u bytes)",
384                          info->name, len, min_len);
385             return OFPERR_OFPBRC_BAD_LEN;
386         }
387         break;
388
389     default:
390         if (len < min_len || (len - min_len) % info->extra_multiple) {
391             VLOG_WARN_RL(&rl, "received %s with incorrect length %u (must be "
392                          "exactly %u bytes or longer by an integer multiple "
393                          "of %u bytes)",
394                          info->name, len, min_len, info->extra_multiple);
395             return OFPERR_OFPBRC_BAD_LEN;
396         }
397         break;
398     }
399
400     *rawp = raw;
401     return 0;
402 }
403
404 /* Does the same job as ofpraw_pull(), except that it assert-fails if
405  * ofpbuf_pull() would have reported an error.  Thus, it's able to use the
406  * return value for the OFPRAW_* message type instead of an error code.
407  *
408  * (It only makes sense to use this function if you previously called
409  * ofpbuf_decode() on the message and thus know that it's OK.) */
410 enum ofpraw
411 ofpraw_pull_assert(struct ofpbuf *msg)
412 {
413     enum ofperr error;
414     enum ofpraw raw;
415
416     error = ofpraw_pull(&raw, msg);
417     assert(!error);
418     return raw;
419 }
420
421 /* Determines the OFPRAW_* type of the OpenFlow message that starts at 'oh' and
422  * has length 'length' bytes.  On success, returns 0 and stores the type into
423  * '*rawp'.  On failure, returns an OFPERR_* error code and zeros '*rawp'.
424  *
425  * Unlike other functions for decoding message types, this one is not picky
426  * about message length.  For example, it will successfully decode a message
427  * whose body is shorter than the minimum length for a message of its type.
428  * Thus, this is the correct function to use for decoding the type of a message
429  * that might have been truncated, such as the payload of an OpenFlow error
430  * message (which is allowed to be truncated to 64 bytes). */
431 enum ofperr
432 ofpraw_decode_partial(enum ofpraw *raw,
433                       const struct ofp_header *oh, size_t length)
434 {
435     struct ofphdrs hdrs;
436     enum ofperr error;
437
438     error = ofphdrs_decode(&hdrs, oh, length);
439     if (!error) {
440         error = ofpraw_from_ofphdrs(raw, &hdrs);
441     }
442
443     if (error) {
444         *raw = 0;
445     }
446     return error;
447 }
448 \f
449 /* Encoding messages using OFPRAW_* values. */
450
451 static void ofpraw_put__(enum ofpraw, uint8_t version, ovs_be32 xid,
452                          size_t extra_tailroom, struct ofpbuf *);
453
454 /* Allocates and returns a new ofpbuf that contains an OpenFlow header for
455  * 'raw' with OpenFlow version 'version' and a fresh OpenFlow transaction ID.
456  * The ofpbuf has enough tailroom for the minimum body length of 'raw', plus
457  * 'extra_tailroom' additional bytes.
458  *
459  * Each 'raw' value is valid only for certain OpenFlow versions.  The caller
460  * must specify a valid (raw, version) pair.
461  *
462  * In the returned ofpbuf, 'l2' points to the beginning of the OpenFlow header
463  * and 'l3' points just after it, to where the message's body will start.  The
464  * caller must actually allocate the body into the space reserved for it,
465  * e.g. with ofpbuf_put_uninit().
466  *
467  * The caller owns the returned ofpbuf and must free it when it is no longer
468  * needed, e.g. with ofpbuf_delete(). */
469 struct ofpbuf *
470 ofpraw_alloc(enum ofpraw raw, uint8_t version, size_t extra_tailroom)
471 {
472     return ofpraw_alloc_xid(raw, version, alloc_xid(), extra_tailroom);
473 }
474
475 /* Same as ofpraw_alloc() but the caller provides the transaction ID. */
476 struct ofpbuf *
477 ofpraw_alloc_xid(enum ofpraw raw, uint8_t version, ovs_be32 xid,
478                  size_t extra_tailroom)
479 {
480     struct ofpbuf *buf = ofpbuf_new(0);
481     ofpraw_put__(raw, version, xid, extra_tailroom, buf);
482     return buf;
483 }
484
485 /* Same as ofpraw_alloc(), but obtains the OpenFlow version and transaction ID
486  * from 'request->version' and 'request->xid', respectively.
487  *
488  * Even though the version comes from 'request->version', the caller must still
489  * know what it is doing, by specifying a valid pairing of 'raw' and
490  * 'request->version', just like ofpraw_alloc(). */
491 struct ofpbuf *
492 ofpraw_alloc_reply(enum ofpraw raw, const struct ofp_header *request,
493                    size_t extra_tailroom)
494 {
495     return ofpraw_alloc_xid(raw, request->version, request->xid,
496                             extra_tailroom);
497 }
498
499 /* Allocates and returns a new ofpbuf that contains an OpenFlow header that is
500  * a stats reply to the stats request in 'request', using the same OpenFlow
501  * version and transaction ID as 'request'.  The ofpbuf has enough tailroom for
502  * the stats reply's minimum body length, plus 'extra_tailroom' additional
503  * bytes.
504  *
505  * 'request' must be a stats request, that is, an OFPRAW_OFPST* or OFPRAW_NXST*
506  * value.  Every stats request has a corresponding reply, so the (raw, version)
507  * pairing pitfalls of the other ofpraw_alloc_*() functions don't apply here.
508  *
509  * In the returned ofpbuf, 'l2' points to the beginning of the OpenFlow header
510  * and 'l3' points just after it, to where the message's body will start.  The
511  * caller must actually allocate the body into the space reserved for it,
512  * e.g. with ofpbuf_put_uninit().
513  *
514  * The caller owns the returned ofpbuf and must free it when it is no longer
515  * needed, e.g. with ofpbuf_delete(). */
516 struct ofpbuf *
517 ofpraw_alloc_stats_reply(const struct ofp_header *request,
518                          size_t extra_tailroom)
519 {
520     enum ofpraw request_raw;
521     enum ofpraw reply_raw;
522     enum ofperr error;
523
524     error = ofpraw_decode_partial(&request_raw, request,
525                                   ntohs(request->length));
526     assert(!error);
527
528     reply_raw = ofpraw_stats_request_to_reply(request_raw, request->version);
529     assert(reply_raw);
530
531     return ofpraw_alloc_reply(reply_raw, request, extra_tailroom);
532 }
533
534 /* Appends to 'buf' an OpenFlow header for 'raw' with OpenFlow version
535  * 'version' and a fresh OpenFlow transaction ID.  Preallocates enough tailroom
536  * in 'buf' for the minimum body length of 'raw', plus 'extra_tailroom'
537  * additional bytes.
538  *
539  * Each 'raw' value is valid only for certain OpenFlow versions.  The caller
540  * must specify a valid (raw, version) pair.
541  *
542  * Upon return, 'buf->l2' points to the beginning of the OpenFlow header and
543  * 'buf->l3' points just after it, to where the message's body will start.  The
544  * caller must actually allocating the body into the space reserved for it,
545  * e.g. with ofpbuf_put_uninit(). */
546 void
547 ofpraw_put(enum ofpraw raw, uint8_t version, struct ofpbuf *buf)
548 {
549     ofpraw_put__(raw, version, alloc_xid(), 0, buf);
550 }
551
552 /* Same as ofpraw_put() but the caller provides the transaction ID. */
553 void
554 ofpraw_put_xid(enum ofpraw raw, uint8_t version, ovs_be32 xid,
555                struct ofpbuf *buf)
556 {
557     ofpraw_put__(raw, version, xid, 0, buf);
558 }
559
560 /* Same as ofpraw_put(), but obtains the OpenFlow version and transaction ID
561  * from 'request->version' and 'request->xid', respectively.
562  *
563  * Even though the version comes from 'request->version', the caller must still
564  * know what it is doing, by specifying a valid pairing of 'raw' and
565  * 'request->version', just like ofpraw_put(). */
566 void
567 ofpraw_put_reply(enum ofpraw raw, const struct ofp_header *request,
568                  struct ofpbuf *buf)
569 {
570     ofpraw_put__(raw, request->version, request->xid, 0, buf);
571 }
572
573 /* Appends to 'buf' an OpenFlow header that is a stats reply to the stats
574  * request in 'request', using the same OpenFlow version and transaction ID as
575  * 'request'.  Preallocate enough tailroom in 'buf for the stats reply's
576  * minimum body length, plus 'extra_tailroom' additional bytes.
577  *
578  * 'request' must be a stats request, that is, an OFPRAW_OFPST* or OFPRAW_NXST*
579  * value.  Every stats request has a corresponding reply, so the (raw, version)
580  * pairing pitfalls of the other ofpraw_alloc_*() functions don't apply here.
581  *
582  * In the returned ofpbuf, 'l2' points to the beginning of the OpenFlow header
583  * and 'l3' points just after it, to where the message's body will start.  The
584  * caller must actually allocate the body into the space reserved for it,
585  * e.g. with ofpbuf_put_uninit().
586  *
587  * The caller owns the returned ofpbuf and must free it when it is no longer
588  * needed, e.g. with ofpbuf_delete(). */
589 void
590 ofpraw_put_stats_reply(const struct ofp_header *request, struct ofpbuf *buf)
591 {
592     enum ofperr error;
593     enum ofpraw raw;
594
595     error = ofpraw_decode_partial(&raw, request, ntohs(request->length));
596     assert(!error);
597
598     raw = ofpraw_stats_request_to_reply(raw, request->version);
599     assert(raw);
600
601     ofpraw_put__(raw, request->version, request->xid, 0, buf);
602 }
603
604 static void
605 ofpraw_put__(enum ofpraw raw, uint8_t version, ovs_be32 xid,
606              size_t extra_tailroom, struct ofpbuf *buf)
607 {
608     const struct raw_info *info = raw_info_get(raw);
609     const struct raw_instance *instance = raw_instance_get(info, version);
610     const struct ofphdrs *hdrs = &instance->hdrs;
611     struct ofp_header *oh;
612
613     ofpbuf_prealloc_tailroom(buf, (instance->hdrs_len + info->min_body
614                                    + extra_tailroom));
615     buf->l2 = ofpbuf_put_uninit(buf, instance->hdrs_len);
616     buf->l3 = ofpbuf_tail(buf);
617
618     oh = buf->l2;
619     oh->version = version;
620     oh->type = hdrs->type;
621     oh->length = htons(buf->size);
622     oh->xid = xid;
623
624     if (hdrs->type == OFPT_VENDOR) {
625         struct nicira_header *nh = buf->l2;
626
627         assert(hdrs->vendor == NX_VENDOR_ID);
628         nh->vendor = htonl(hdrs->vendor);
629         nh->subtype = htonl(hdrs->subtype);
630     } else if (version == OFP10_VERSION
631                && (hdrs->type == OFPT10_STATS_REQUEST ||
632                    hdrs->type == OFPT10_STATS_REPLY)) {
633         struct ofp10_stats_msg *osm = buf->l2;
634
635         osm->type = htons(hdrs->stat);
636         osm->flags = htons(0);
637
638         if (hdrs->stat == OFPST_VENDOR) {
639             struct ofp10_vendor_stats_msg *ovsm = buf->l2;
640
641             ovsm->vendor = htonl(hdrs->vendor);
642             if (hdrs->vendor == NX_VENDOR_ID) {
643                 struct nicira10_stats_msg *nsm = buf->l2;
644
645                 nsm->subtype = htonl(hdrs->subtype);
646                 memset(nsm->pad, 0, sizeof nsm->pad);
647             } else {
648                 NOT_REACHED();
649             }
650         }
651     } else if (version != OFP10_VERSION
652                && (hdrs->type == OFPT11_STATS_REQUEST ||
653                    hdrs->type == OFPT11_STATS_REPLY)) {
654         struct ofp11_stats_msg *osm = buf->l2;
655
656         osm->type = htons(hdrs->stat);
657         osm->flags = htons(0);
658         memset(osm->pad, 0, sizeof osm->pad);
659
660         if (hdrs->stat == OFPST_VENDOR) {
661             struct ofp11_vendor_stats_msg *ovsm = buf->l2;
662
663             ovsm->vendor = htonl(hdrs->vendor);
664             if (hdrs->vendor == NX_VENDOR_ID) {
665                 struct nicira11_stats_msg *nsm = buf->l2;
666
667                 nsm->subtype = htonl(hdrs->subtype);
668             } else {
669                 NOT_REACHED();
670             }
671         }
672     }
673 }
674 \f
675 /* Returns 'raw''s name.
676  *
677  * The name is the name used for 'raw' in the OpenFlow specification.  For
678  * example, ofpraw_get_name(OFPRAW_OFPT10_FEATURES_REPLY) is
679  * "OFPT_FEATURES_REPLY".
680  *
681  * The caller must not modify or free the returned string. */
682 const char *
683 ofpraw_get_name(enum ofpraw raw)
684 {
685     return raw_info_get(raw)->name;
686 }
687
688 /* Returns the stats reply that corresponds to 'raw' in the given OpenFlow
689  * 'version'. */
690 enum ofpraw
691 ofpraw_stats_request_to_reply(enum ofpraw raw, uint8_t version)
692 {
693     const struct raw_info *info = raw_info_get(raw);
694     const struct raw_instance *instance = raw_instance_get(info, version);
695     enum ofpraw reply_raw;
696     struct ofphdrs hdrs;
697     enum ofperr error;
698
699     hdrs = instance->hdrs;
700     switch ((enum ofp_version)hdrs.version) {
701     case OFP10_VERSION:
702         assert(hdrs.type == OFPT10_STATS_REQUEST);
703         hdrs.type = OFPT10_STATS_REPLY;
704         break;
705     case OFP11_VERSION:
706     case OFP12_VERSION:
707         assert(hdrs.type == OFPT11_STATS_REQUEST);
708         hdrs.type = OFPT11_STATS_REPLY;
709         break;
710     default:
711         NOT_REACHED();
712     }
713
714     error = ofpraw_from_ofphdrs(&reply_raw, &hdrs);
715     assert(!error);
716
717     return reply_raw;
718 }
719 \f
720 /* Determines the OFPTYPE_* type of the OpenFlow message at 'oh', which has
721  * length 'oh->length'.  (The caller must ensure that 'oh->length' bytes of
722  * data are readable at 'oh'.)  On success, returns 0 and stores the type into
723  * '*typep'.  On failure, returns an OFPERR_* error code and zeros '*typep'.
724  *
725  * This function checks that 'oh' is a valid length for its particular type of
726  * message, and returns an error if not. */
727 enum ofperr
728 ofptype_decode(enum ofptype *typep, const struct ofp_header *oh)
729 {
730     enum ofperr error;
731     enum ofpraw raw;
732
733     error = ofpraw_decode(&raw, oh);
734     *typep = error ? 0 : ofptype_from_ofpraw(raw);
735     return error;
736 }
737
738 /* Determines the OFPTYPE_* type of the OpenFlow message in 'msg', which starts
739  * at 'msg->data' and has length 'msg->size' bytes.  On success, returns 0 and
740  * stores the type into '*typep'.  On failure, returns an OFPERR_* error code
741  * and zeros '*typep'.
742  *
743  * This function checks that the message has a valid length for its particular
744  * type of message, and returns an error if not.
745  *
746  * In addition to setting '*typep', this function pulls off the OpenFlow header
747  * (including the stats headers, vendor header, and any subtype header) with
748  * ofpbuf_pull().  It also sets 'msg->l2' to the start of the OpenFlow header
749  * and 'msg->l3' just beyond the headers (that is, to the final value of
750  * msg->data). */
751 enum ofperr
752 ofptype_pull(enum ofptype *typep, struct ofpbuf *buf)
753 {
754     enum ofperr error;
755     enum ofpraw raw;
756
757     error = ofpraw_pull(&raw, buf);
758     *typep = error ? 0 : ofptype_from_ofpraw(raw);
759     return error;
760 }
761
762 /* Returns the OFPTYPE_* type that corresponds to 'raw'.
763  *
764  * (This is a one-way trip, because the mapping from ofpraw to ofptype is
765  * many-to-one.)  */
766 enum ofptype
767 ofptype_from_ofpraw(enum ofpraw raw)
768 {
769     return raw_info_get(raw)->type;
770 }
771 \f
772 /* Updates the 'length' field of the OpenFlow message in 'buf' to
773  * 'buf->size'. */
774 void
775 ofpmsg_update_length(struct ofpbuf *buf)
776 {
777     struct ofp_header *oh = ofpbuf_at_assert(buf, 0, sizeof *oh);
778     oh->length = htons(buf->size);
779 }
780
781 /* Returns just past the Openflow header (including the stats headers, vendor
782  * header, and any subtype header) in 'oh'. */
783 const void *
784 ofpmsg_body(const struct ofp_header *oh)
785 {
786     struct ofphdrs hdrs;
787
788     ofphdrs_decode_assert(&hdrs, oh, ntohs(oh->length));
789     return (const uint8_t *) oh + ofphdrs_len(&hdrs);
790 }
791 \f
792 static ovs_be16 *ofpmp_flags__(const struct ofp_header *);
793
794 /* Initializes 'replies' as a new list of stats messages that reply to
795  * 'request', which must be a stats request message.  Initially the list will
796  * consist of only a single reply part without any body.  The caller should
797  * use calls to the other ofpmp_*() functions to add to the body and split the
798  * message into multiple parts, if necessary. */
799 void
800 ofpmp_init(struct list *replies, const struct ofp_header *request)
801 {
802     struct ofpbuf *msg;
803
804     list_init(replies);
805
806     msg = ofpraw_alloc_stats_reply(request, 1000);
807     list_push_back(replies, &msg->list_node);
808 }
809
810 /* Prepares to append up to 'len' bytes to the series of statistics replies in
811  * 'replies', which should have been initialized with ofpmp_init(), if
812  * necessary adding a new reply to the list.
813  *
814  * Returns an ofpbuf with at least 'len' bytes of tailroom.  The 'len' bytes
815  * have not actually been allocated, so the caller must do so with
816  * e.g. ofpbuf_put_uninit(). */
817 struct ofpbuf *
818 ofpmp_reserve(struct list *replies, size_t len)
819 {
820     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
821
822     if (msg->size + len <= UINT16_MAX) {
823         ofpbuf_prealloc_tailroom(msg, len);
824         return msg;
825     } else {
826         unsigned int hdrs_len;
827         struct ofpbuf *next;
828         struct ofphdrs hdrs;
829
830         ofphdrs_decode_assert(&hdrs, msg->data, msg->size);
831         hdrs_len = ofphdrs_len(&hdrs);
832
833         next = ofpbuf_new(MAX(1024, hdrs_len + len));
834         ofpbuf_put(next, msg->data, hdrs_len);
835         list_push_back(replies, &next->list_node);
836
837         *ofpmp_flags__(msg->data) |= htons(OFPSF_REPLY_MORE);
838
839         return next;
840     }
841 }
842
843 /* Appends 'len' bytes to the series of statistics replies in 'replies', and
844  * returns the first byte. */
845 void *
846 ofpmp_append(struct list *replies, size_t len)
847 {
848     return ofpbuf_put_uninit(ofpmp_reserve(replies, len), len);
849 }
850
851 /* Sometimes, when composing stats replies, it's difficult to predict how long
852  * an individual reply chunk will be before actually encoding it into the reply
853  * buffer.  This function allows easy handling of this case: just encode the
854  * reply, then use this function to break the message into two pieces if it
855  * exceeds the OpenFlow message limit.
856  *
857  * In detail, if the final stats message in 'replies' is too long for OpenFlow,
858  * this function breaks it into two separate stats replies, the first one with
859  * the first 'start_ofs' bytes, the second one containing the bytes from that
860  * offset onward. */
861 void
862 ofpmp_postappend(struct list *replies, size_t start_ofs)
863 {
864     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
865
866     assert(start_ofs <= UINT16_MAX);
867     if (msg->size > UINT16_MAX) {
868         size_t len = msg->size - start_ofs;
869         memcpy(ofpmp_append(replies, len),
870                (const uint8_t *) msg->data + start_ofs, len);
871         msg->size = start_ofs;
872     }
873 }
874
875 static ovs_be16 *
876 ofpmp_flags__(const struct ofp_header *oh)
877 {
878     switch ((enum ofp_version)oh->version) {
879     case OFP10_VERSION:
880         return &((struct ofp10_stats_msg *) oh)->flags;
881     case OFP11_VERSION:
882     case OFP12_VERSION:
883         return &((struct ofp11_stats_msg *) oh)->flags;
884     default:
885         NOT_REACHED();
886     }
887 }
888
889 /* Returns the OFPSF_* flags found in the OpenFlow stats header of 'oh', which
890  * must be an OpenFlow stats request or reply.
891  *
892  * (OFPSF_REPLY_MORE is the only defined flag.) */
893 uint16_t
894 ofpmp_flags(const struct ofp_header *oh)
895 {
896     return ntohs(*ofpmp_flags__(oh));
897 }
898
899 /* Returns true if the OFPSF_REPLY_MORE flag is set in the OpenFlow stats
900  * header of 'oh', which must be an OpenFlow stats request or reply, false if
901  * it is not set. */
902 bool
903 ofpmp_more(const struct ofp_header *oh)
904 {
905     return (ofpmp_flags(oh) & OFPSF_REPLY_MORE) != 0;
906 }
907 \f
908 static void ofpmsgs_init(void);
909
910 static const struct raw_info *
911 raw_info_get(enum ofpraw raw)
912 {
913     ofpmsgs_init();
914
915     assert(raw < ARRAY_SIZE(raw_infos));
916     return &raw_infos[raw];
917 }
918
919 static struct raw_instance *
920 raw_instance_get(const struct raw_info *info, uint8_t version)
921 {
922     assert(version >= info->min_version && version <= info->max_version);
923     return &info->instances[version - info->min_version];
924 }
925
926 static enum ofperr
927 ofpraw_from_ofphdrs(enum ofpraw *raw, const struct ofphdrs *hdrs)
928 {
929     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
930
931     struct raw_instance *raw_hdrs;
932     uint32_t hash;
933
934     ofpmsgs_init();
935
936     hash = ofphdrs_hash(hdrs);
937     HMAP_FOR_EACH_WITH_HASH (raw_hdrs, hmap_node, hash, &raw_instance_map) {
938         if (ofphdrs_equal(hdrs, &raw_hdrs->hdrs)) {
939             *raw = raw_hdrs->raw;
940             return 0;
941         }
942     }
943
944     if (!VLOG_DROP_WARN(&rl)) {
945         struct ds s;
946
947         ds_init(&s);
948         ds_put_format(&s, "version %"PRIu8", type %"PRIu8,
949                       hdrs->version, hdrs->type);
950         if (ofphdrs_is_stat(hdrs)) {
951             ds_put_format(&s, ", stat %"PRIu16, hdrs->stat);
952         }
953         if (hdrs->vendor) {
954             ds_put_format(&s, ", vendor 0x%"PRIx32", subtype %"PRIu32,
955                           hdrs->vendor, hdrs->subtype);
956         }
957         VLOG_WARN("unknown OpenFlow message (%s)", ds_cstr(&s));
958         ds_destroy(&s);
959     }
960
961     return (hdrs->vendor ? OFPERR_OFPBRC_BAD_SUBTYPE
962             : ofphdrs_is_stat(hdrs) ? OFPERR_OFPBRC_BAD_STAT
963             : OFPERR_OFPBRC_BAD_TYPE);
964 }
965
966 static void
967 ofpmsgs_init(void)
968 {
969     const struct raw_info *info;
970
971     if (raw_instance_map.buckets) {
972         return;
973     }
974
975     hmap_init(&raw_instance_map);
976     for (info = raw_infos; info < &raw_infos[ARRAY_SIZE(raw_infos)]; info++)
977     {
978         int n_instances = info->max_version - info->min_version + 1;
979         struct raw_instance *inst;
980
981         for (inst = info->instances;
982              inst < &info->instances[n_instances];
983              inst++) {
984             inst->hdrs_len = ofphdrs_len(&inst->hdrs);
985             hmap_insert(&raw_instance_map, &inst->hmap_node,
986                         ofphdrs_hash(&inst->hdrs));
987         }
988     }
989 }