2 * Copyright (c) 2012, 2013 Nicira, Inc.
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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include "byte-order.h"
20 #include "dynamic-string.h"
24 #include "openflow/nicira-ext.h"
25 #include "openflow/openflow.h"
26 #include "ovs-thread.h"
29 VLOG_DEFINE_THIS_MODULE(ofp_msgs
);
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
38 /* A thin abstraction of OpenFlow headers:
40 * - 'version' and 'type' come straight from struct ofp_header, so these are
41 * always present and meaningful.
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.
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.
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. */
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. */
65 BUILD_ASSERT_DECL(sizeof(struct ofphdrs
) == 12);
67 /* A mapping from OpenFlow headers to OFPRAW_*. */
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). */
75 /* Information about a particular 'enum ofpraw'. */
77 /* All possible instantiations of this OFPRAW_* into OpenFlow headers. */
78 struct raw_instance
*instances
; /* min_version - max_version + 1 elems. */
82 unsigned int min_body
;
83 unsigned int extra_multiple
;
88 /* All understood OpenFlow message types, indexed by their 'struct ofphdrs'. */
89 static struct hmap raw_instance_map
;
90 #include "ofp-msgs.inc"
92 static ovs_be32
alloc_xid(void);
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
*);
103 static const struct raw_info
*raw_info_get(enum ofpraw
);
104 static struct raw_instance
*raw_instance_get(const struct raw_info
*,
107 static enum ofperr
ofpraw_from_ofphdrs(enum ofpraw
*, const struct ofphdrs
*);
109 /* Returns a transaction ID to use for an outgoing OpenFlow message. */
113 static atomic_uint32_t next_xid
= ATOMIC_VAR_INIT(1);
116 atomic_add(&next_xid
, 1, &xid
);
121 ofphdrs_hash(const struct ofphdrs
*hdrs
)
123 BUILD_ASSERT_DECL(sizeof *hdrs
== 12);
124 return hash_words((const uint32_t *) hdrs
, 3, 0);
128 ofphdrs_equal(const struct ofphdrs
*a
, const struct ofphdrs
*b
)
130 return !memcmp(a
, b
, sizeof *a
);
134 log_bad_vendor(uint32_t vendor
)
136 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 1);
138 VLOG_WARN_RL(&rl
, "OpenFlow message has unknown vendor %#"PRIx32
, vendor
);
142 ofphdrs_decode(struct ofphdrs
*hdrs
,
143 const struct ofp_header
*oh
, size_t length
)
145 memset(hdrs
, 0, sizeof *hdrs
);
146 if (length
< sizeof *oh
) {
147 return OFPERR_OFPBRC_BAD_LEN
;
150 /* Get base message version and type (OFPT_*). */
151 hdrs
->version
= oh
->version
;
152 hdrs
->type
= oh
->type
;
154 if (hdrs
->type
== OFPT_VENDOR
) {
156 const struct ofp_vendor_header
*ovh
;
158 if (length
< sizeof *ovh
) {
159 return OFPERR_OFPBRC_BAD_LEN
;
162 ovh
= (const struct ofp_vendor_header
*) oh
;
163 hdrs
->vendor
= ntohl(ovh
->vendor
);
164 if (hdrs
->vendor
== NX_VENDOR_ID
) {
165 /* Get Nicira message subtype (NXT_*). */
166 const struct nicira_header
*nh
;
168 if (length
< sizeof *nh
) {
169 return OFPERR_OFPBRC_BAD_LEN
;
171 nh
= (const struct nicira_header
*) oh
;
172 hdrs
->subtype
= ntohl(nh
->subtype
);
174 log_bad_vendor(hdrs
->vendor
);
175 return OFPERR_OFPBRC_BAD_VENDOR
;
177 } else if (hdrs
->version
== OFP10_VERSION
178 && (hdrs
->type
== OFPT10_STATS_REQUEST
||
179 hdrs
->type
== OFPT10_STATS_REPLY
)) {
180 const struct ofp10_stats_msg
*osm
;
182 /* Get statistic type (OFPST_*). */
183 if (length
< sizeof *osm
) {
184 return OFPERR_OFPBRC_BAD_LEN
;
186 osm
= (const struct ofp10_stats_msg
*) oh
;
187 hdrs
->stat
= ntohs(osm
->type
);
189 if (hdrs
->stat
== OFPST_VENDOR
) {
191 const struct ofp10_vendor_stats_msg
*ovsm
;
193 if (length
< sizeof *ovsm
) {
194 return OFPERR_OFPBRC_BAD_LEN
;
197 ovsm
= (const struct ofp10_vendor_stats_msg
*) oh
;
198 hdrs
->vendor
= ntohl(ovsm
->vendor
);
199 if (hdrs
->vendor
== NX_VENDOR_ID
) {
200 /* Get Nicira statistic type (NXST_*). */
201 const struct nicira10_stats_msg
*nsm
;
203 if (length
< sizeof *nsm
) {
204 return OFPERR_OFPBRC_BAD_LEN
;
206 nsm
= (const struct nicira10_stats_msg
*) oh
;
207 hdrs
->subtype
= ntohl(nsm
->subtype
);
209 log_bad_vendor(hdrs
->vendor
);
210 return OFPERR_OFPBRC_BAD_VENDOR
;
213 } else if (hdrs
->version
!= OFP10_VERSION
214 && (hdrs
->type
== OFPT11_STATS_REQUEST
||
215 hdrs
->type
== OFPT11_STATS_REPLY
)) {
216 const struct ofp11_stats_msg
*osm
;
218 /* Get statistic type (OFPST_*). */
219 if (length
< sizeof *osm
) {
220 return OFPERR_OFPBRC_BAD_LEN
;
222 osm
= (const struct ofp11_stats_msg
*) oh
;
223 hdrs
->stat
= ntohs(osm
->type
);
225 if (hdrs
->stat
== OFPST_VENDOR
) {
227 const struct ofp11_vendor_stats_msg
*ovsm
;
229 if (length
< sizeof *ovsm
) {
230 return OFPERR_OFPBRC_BAD_LEN
;
233 ovsm
= (const struct ofp11_vendor_stats_msg
*) oh
;
234 hdrs
->vendor
= ntohl(ovsm
->vendor
);
235 if (hdrs
->vendor
== NX_VENDOR_ID
) {
236 /* Get Nicira statistic type (NXST_*). */
237 const struct nicira11_stats_msg
*nsm
;
239 if (length
< sizeof *nsm
) {
240 return OFPERR_OFPBRC_BAD_LEN
;
242 nsm
= (const struct nicira11_stats_msg
*) oh
;
243 hdrs
->subtype
= ntohl(nsm
->subtype
);
245 log_bad_vendor(hdrs
->vendor
);
246 return OFPERR_OFPBRC_BAD_VENDOR
;
255 ofphdrs_decode_assert(struct ofphdrs
*hdrs
,
256 const struct ofp_header
*oh
, size_t length
)
258 enum ofperr error
= ofphdrs_decode(hdrs
, oh
, length
);
263 ofp_is_stat_request(enum ofp_version version
, uint8_t type
)
267 return type
== OFPT10_STATS_REQUEST
;
271 return type
== OFPT11_STATS_REQUEST
;
278 ofp_is_stat_reply(enum ofp_version version
, uint8_t type
)
282 return type
== OFPT10_STATS_REPLY
;
286 return type
== OFPT11_STATS_REPLY
;
293 ofp_is_stat(enum ofp_version version
, uint8_t type
)
295 return (ofp_is_stat_request(version
, type
) ||
296 ofp_is_stat_reply(version
, type
));
300 ofphdrs_is_stat(const struct ofphdrs
*hdrs
)
302 return ofp_is_stat(hdrs
->version
, hdrs
->type
);
306 ofphdrs_len(const struct ofphdrs
*hdrs
)
308 if (hdrs
->type
== OFPT_VENDOR
) {
309 return sizeof(struct nicira_header
);
312 switch ((enum ofp_version
) hdrs
->version
) {
314 if (hdrs
->type
== OFPT10_STATS_REQUEST
||
315 hdrs
->type
== OFPT10_STATS_REPLY
) {
316 return (hdrs
->stat
== OFPST_VENDOR
317 ? sizeof(struct nicira10_stats_msg
)
318 : sizeof(struct ofp10_stats_msg
));
325 if (hdrs
->type
== OFPT11_STATS_REQUEST
||
326 hdrs
->type
== OFPT11_STATS_REPLY
) {
327 return (hdrs
->stat
== OFPST_VENDOR
328 ? sizeof(struct nicira11_stats_msg
)
329 : sizeof(struct ofp11_stats_msg
));
334 return sizeof(struct ofp_header
);
337 /* Determines the OFPRAW_* type of the OpenFlow message at 'oh', which has
338 * length 'oh->length'. (The caller must ensure that 'oh->length' bytes of
339 * data are readable at 'oh'.) On success, returns 0 and stores the type into
340 * '*raw'. On failure, returns an OFPERR_* error code and zeros '*raw'.
342 * This function checks that 'oh' is a valid length for its particular type of
343 * message, and returns an error if not. */
345 ofpraw_decode(enum ofpraw
*raw
, const struct ofp_header
*oh
)
349 ofpbuf_use_const(&msg
, oh
, ntohs(oh
->length
));
350 return ofpraw_pull(raw
, &msg
);
353 /* Does the same job as ofpraw_decode(), except that it assert-fails if
354 * ofpraw_decode() would have reported an error. Thus, it's able to use the
355 * return value for the OFPRAW_* message type instead of an error code.
357 * (It only makes sense to use this function if you previously called
358 * ofpraw_decode() on the message and thus know that it's OK.) */
360 ofpraw_decode_assert(const struct ofp_header
*oh
)
365 error
= ofpraw_decode(&raw
, oh
);
370 /* Determines the OFPRAW_* type of the OpenFlow message in 'msg', which starts
371 * at 'msg->data' and has length 'msg->size' bytes. On success, returns 0 and
372 * stores the type into '*rawp'. On failure, returns an OFPERR_* error code
375 * This function checks that the message has a valid length for its particular
376 * type of message, and returns an error if not.
378 * In addition to setting '*rawp', this function pulls off the OpenFlow header
379 * (including the stats headers, vendor header, and any subtype header) with
380 * ofpbuf_pull(). It also sets 'msg->l2' to the start of the OpenFlow header
381 * and 'msg->l3' just beyond the headers (that is, to the final value of
384 ofpraw_pull(enum ofpraw
*rawp
, struct ofpbuf
*msg
)
386 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
388 const struct raw_instance
*instance
;
389 const struct raw_info
*info
;
392 unsigned int min_len
;
398 /* Set default outputs. */
399 msg
->l2
= msg
->l3
= msg
->data
;
403 error
= ofphdrs_decode(&hdrs
, msg
->data
, len
);
408 error
= ofpraw_from_ofphdrs(&raw
, &hdrs
);
413 info
= raw_info_get(raw
);
414 instance
= raw_instance_get(info
, hdrs
.version
);
415 msg
->l2
= ofpbuf_pull(msg
, instance
->hdrs_len
);
418 min_len
= instance
->hdrs_len
+ info
->min_body
;
419 switch (info
->extra_multiple
) {
421 if (len
!= min_len
) {
422 VLOG_WARN_RL(&rl
, "received %s with incorrect length %u (expected "
423 "length %u)", info
->name
, len
, min_len
);
424 return OFPERR_OFPBRC_BAD_LEN
;
430 VLOG_WARN_RL(&rl
, "received %s with incorrect length %u (expected "
431 "length at least %u bytes)",
432 info
->name
, len
, min_len
);
433 return OFPERR_OFPBRC_BAD_LEN
;
438 if (len
< min_len
|| (len
- min_len
) % info
->extra_multiple
) {
439 VLOG_WARN_RL(&rl
, "received %s with incorrect length %u (must be "
440 "exactly %u bytes or longer by an integer multiple "
442 info
->name
, len
, min_len
, info
->extra_multiple
);
443 return OFPERR_OFPBRC_BAD_LEN
;
452 /* Does the same job as ofpraw_pull(), except that it assert-fails if
453 * ofpraw_pull() would have reported an error. Thus, it's able to use the
454 * return value for the OFPRAW_* message type instead of an error code.
456 * (It only makes sense to use this function if you previously called
457 * ofpraw_decode() on the message and thus know that it's OK.) */
459 ofpraw_pull_assert(struct ofpbuf
*msg
)
464 error
= ofpraw_pull(&raw
, msg
);
469 /* Determines the OFPRAW_* type of the OpenFlow message that starts at 'oh' and
470 * has length 'length' bytes. On success, returns 0 and stores the type into
471 * '*rawp'. On failure, returns an OFPERR_* error code and zeros '*rawp'.
473 * Unlike other functions for decoding message types, this one is not picky
474 * about message length. For example, it will successfully decode a message
475 * whose body is shorter than the minimum length for a message of its type.
476 * Thus, this is the correct function to use for decoding the type of a message
477 * that might have been truncated, such as the payload of an OpenFlow error
478 * message (which is allowed to be truncated to 64 bytes). */
480 ofpraw_decode_partial(enum ofpraw
*raw
,
481 const struct ofp_header
*oh
, size_t length
)
486 error
= ofphdrs_decode(&hdrs
, oh
, length
);
488 error
= ofpraw_from_ofphdrs(raw
, &hdrs
);
497 /* Encoding messages using OFPRAW_* values. */
499 static void ofpraw_put__(enum ofpraw
, uint8_t version
, ovs_be32 xid
,
500 size_t extra_tailroom
, struct ofpbuf
*);
502 /* Allocates and returns a new ofpbuf that contains an OpenFlow header for
503 * 'raw' with OpenFlow version 'version' and a fresh OpenFlow transaction ID.
504 * The ofpbuf has enough tailroom for the minimum body length of 'raw', plus
505 * 'extra_tailroom' additional bytes.
507 * Each 'raw' value is valid only for certain OpenFlow versions. The caller
508 * must specify a valid (raw, version) pair.
510 * In the returned ofpbuf, 'l2' points to the beginning of the OpenFlow header
511 * and 'l3' points just after it, to where the message's body will start. The
512 * caller must actually allocate the body into the space reserved for it,
513 * e.g. with ofpbuf_put_uninit().
515 * The caller owns the returned ofpbuf and must free it when it is no longer
516 * needed, e.g. with ofpbuf_delete(). */
518 ofpraw_alloc(enum ofpraw raw
, uint8_t version
, size_t extra_tailroom
)
520 return ofpraw_alloc_xid(raw
, version
, alloc_xid(), extra_tailroom
);
523 /* Same as ofpraw_alloc() but the caller provides the transaction ID. */
525 ofpraw_alloc_xid(enum ofpraw raw
, uint8_t version
, ovs_be32 xid
,
526 size_t extra_tailroom
)
528 struct ofpbuf
*buf
= ofpbuf_new(0);
529 ofpraw_put__(raw
, version
, xid
, extra_tailroom
, buf
);
533 /* Same as ofpraw_alloc(), but obtains the OpenFlow version and transaction ID
534 * from 'request->version' and 'request->xid', respectively.
536 * Even though the version comes from 'request->version', the caller must still
537 * know what it is doing, by specifying a valid pairing of 'raw' and
538 * 'request->version', just like ofpraw_alloc(). */
540 ofpraw_alloc_reply(enum ofpraw raw
, const struct ofp_header
*request
,
541 size_t extra_tailroom
)
543 return ofpraw_alloc_xid(raw
, request
->version
, request
->xid
,
547 /* Allocates and returns a new ofpbuf that contains an OpenFlow header that is
548 * a stats reply to the stats request in 'request', using the same OpenFlow
549 * version and transaction ID as 'request'. The ofpbuf has enough tailroom for
550 * the stats reply's minimum body length, plus 'extra_tailroom' additional
553 * 'request' must be a stats request, that is, an OFPRAW_OFPST* or OFPRAW_NXST*
554 * value. Every stats request has a corresponding reply, so the (raw, version)
555 * pairing pitfalls of the other ofpraw_alloc_*() functions don't apply here.
557 * In the returned ofpbuf, 'l2' points to the beginning of the OpenFlow header
558 * and 'l3' points just after it, to where the message's body will start. The
559 * caller must actually allocate the body into the space reserved for it,
560 * e.g. with ofpbuf_put_uninit().
562 * The caller owns the returned ofpbuf and must free it when it is no longer
563 * needed, e.g. with ofpbuf_delete(). */
565 ofpraw_alloc_stats_reply(const struct ofp_header
*request
,
566 size_t extra_tailroom
)
568 enum ofpraw request_raw
;
569 enum ofpraw reply_raw
;
572 error
= ofpraw_decode_partial(&request_raw
, request
,
573 ntohs(request
->length
));
576 reply_raw
= ofpraw_stats_request_to_reply(request_raw
, request
->version
);
577 ovs_assert(reply_raw
);
579 return ofpraw_alloc_reply(reply_raw
, request
, extra_tailroom
);
582 /* Appends to 'buf' an OpenFlow header for 'raw' with OpenFlow version
583 * 'version' and a fresh OpenFlow transaction ID. Preallocates enough tailroom
584 * in 'buf' for the minimum body length of 'raw', plus 'extra_tailroom'
587 * Each 'raw' value is valid only for certain OpenFlow versions. The caller
588 * must specify a valid (raw, version) pair.
590 * Upon return, 'buf->l2' points to the beginning of the OpenFlow header and
591 * 'buf->l3' points just after it, to where the message's body will start. The
592 * caller must actually allocating the body into the space reserved for it,
593 * e.g. with ofpbuf_put_uninit(). */
595 ofpraw_put(enum ofpraw raw
, uint8_t version
, struct ofpbuf
*buf
)
597 ofpraw_put__(raw
, version
, alloc_xid(), 0, buf
);
600 /* Same as ofpraw_put() but the caller provides the transaction ID. */
602 ofpraw_put_xid(enum ofpraw raw
, uint8_t version
, ovs_be32 xid
,
605 ofpraw_put__(raw
, version
, xid
, 0, buf
);
608 /* Same as ofpraw_put(), but obtains the OpenFlow version and transaction ID
609 * from 'request->version' and 'request->xid', respectively.
611 * Even though the version comes from 'request->version', the caller must still
612 * know what it is doing, by specifying a valid pairing of 'raw' and
613 * 'request->version', just like ofpraw_put(). */
615 ofpraw_put_reply(enum ofpraw raw
, const struct ofp_header
*request
,
618 ofpraw_put__(raw
, request
->version
, request
->xid
, 0, buf
);
621 /* Appends to 'buf' an OpenFlow header that is a stats reply to the stats
622 * request in 'request', using the same OpenFlow version and transaction ID as
623 * 'request'. Preallocate enough tailroom in 'buf for the stats reply's
624 * minimum body length, plus 'extra_tailroom' additional bytes.
626 * 'request' must be a stats request, that is, an OFPRAW_OFPST* or OFPRAW_NXST*
627 * value. Every stats request has a corresponding reply, so the (raw, version)
628 * pairing pitfalls of the other ofpraw_alloc_*() functions don't apply here.
630 * In the returned ofpbuf, 'l2' points to the beginning of the OpenFlow header
631 * and 'l3' points just after it, to where the message's body will start. The
632 * caller must actually allocate the body into the space reserved for it,
633 * e.g. with ofpbuf_put_uninit().
635 * The caller owns the returned ofpbuf and must free it when it is no longer
636 * needed, e.g. with ofpbuf_delete(). */
638 ofpraw_put_stats_reply(const struct ofp_header
*request
, struct ofpbuf
*buf
)
643 error
= ofpraw_decode_partial(&raw
, request
, ntohs(request
->length
));
646 raw
= ofpraw_stats_request_to_reply(raw
, request
->version
);
649 ofpraw_put__(raw
, request
->version
, request
->xid
, 0, buf
);
653 ofpraw_put__(enum ofpraw raw
, uint8_t version
, ovs_be32 xid
,
654 size_t extra_tailroom
, struct ofpbuf
*buf
)
656 const struct raw_info
*info
= raw_info_get(raw
);
657 const struct raw_instance
*instance
= raw_instance_get(info
, version
);
658 const struct ofphdrs
*hdrs
= &instance
->hdrs
;
659 struct ofp_header
*oh
;
661 ofpbuf_prealloc_tailroom(buf
, (instance
->hdrs_len
+ info
->min_body
663 buf
->l2
= ofpbuf_put_uninit(buf
, instance
->hdrs_len
);
664 buf
->l3
= ofpbuf_tail(buf
);
667 oh
->version
= version
;
668 oh
->type
= hdrs
->type
;
669 oh
->length
= htons(buf
->size
);
672 if (hdrs
->type
== OFPT_VENDOR
) {
673 struct nicira_header
*nh
= buf
->l2
;
675 ovs_assert(hdrs
->vendor
== NX_VENDOR_ID
);
676 nh
->vendor
= htonl(hdrs
->vendor
);
677 nh
->subtype
= htonl(hdrs
->subtype
);
678 } else if (version
== OFP10_VERSION
679 && (hdrs
->type
== OFPT10_STATS_REQUEST
||
680 hdrs
->type
== OFPT10_STATS_REPLY
)) {
681 struct ofp10_stats_msg
*osm
= buf
->l2
;
683 osm
->type
= htons(hdrs
->stat
);
684 osm
->flags
= htons(0);
686 if (hdrs
->stat
== OFPST_VENDOR
) {
687 struct ofp10_vendor_stats_msg
*ovsm
= buf
->l2
;
689 ovsm
->vendor
= htonl(hdrs
->vendor
);
690 if (hdrs
->vendor
== NX_VENDOR_ID
) {
691 struct nicira10_stats_msg
*nsm
= buf
->l2
;
693 nsm
->subtype
= htonl(hdrs
->subtype
);
694 memset(nsm
->pad
, 0, sizeof nsm
->pad
);
699 } else if (version
!= OFP10_VERSION
700 && (hdrs
->type
== OFPT11_STATS_REQUEST
||
701 hdrs
->type
== OFPT11_STATS_REPLY
)) {
702 struct ofp11_stats_msg
*osm
= buf
->l2
;
704 osm
->type
= htons(hdrs
->stat
);
705 osm
->flags
= htons(0);
706 memset(osm
->pad
, 0, sizeof osm
->pad
);
708 if (hdrs
->stat
== OFPST_VENDOR
) {
709 struct ofp11_vendor_stats_msg
*ovsm
= buf
->l2
;
711 ovsm
->vendor
= htonl(hdrs
->vendor
);
712 if (hdrs
->vendor
== NX_VENDOR_ID
) {
713 struct nicira11_stats_msg
*nsm
= buf
->l2
;
715 nsm
->subtype
= htonl(hdrs
->subtype
);
723 /* Returns 'raw''s name.
725 * The name is the name used for 'raw' in the OpenFlow specification. For
726 * example, ofpraw_get_name(OFPRAW_OFPT10_FEATURES_REPLY) is
727 * "OFPT_FEATURES_REPLY".
729 * The caller must not modify or free the returned string. */
731 ofpraw_get_name(enum ofpraw raw
)
733 return raw_info_get(raw
)->name
;
736 /* Returns the stats reply that corresponds to 'raw' in the given OpenFlow
739 ofpraw_stats_request_to_reply(enum ofpraw raw
, uint8_t version
)
741 const struct raw_info
*info
= raw_info_get(raw
);
742 const struct raw_instance
*instance
= raw_instance_get(info
, version
);
743 enum ofpraw reply_raw
;
747 hdrs
= instance
->hdrs
;
748 switch ((enum ofp_version
)hdrs
.version
) {
750 ovs_assert(hdrs
.type
== OFPT10_STATS_REQUEST
);
751 hdrs
.type
= OFPT10_STATS_REPLY
;
756 ovs_assert(hdrs
.type
== OFPT11_STATS_REQUEST
);
757 hdrs
.type
= OFPT11_STATS_REPLY
;
763 error
= ofpraw_from_ofphdrs(&reply_raw
, &hdrs
);
769 /* Determines the OFPTYPE_* type of the OpenFlow message at 'oh', which has
770 * length 'oh->length'. (The caller must ensure that 'oh->length' bytes of
771 * data are readable at 'oh'.) On success, returns 0 and stores the type into
772 * '*typep'. On failure, returns an OFPERR_* error code and zeros '*typep'.
774 * This function checks that 'oh' is a valid length for its particular type of
775 * message, and returns an error if not. */
777 ofptype_decode(enum ofptype
*typep
, const struct ofp_header
*oh
)
782 error
= ofpraw_decode(&raw
, oh
);
783 *typep
= error
? 0 : ofptype_from_ofpraw(raw
);
787 /* Determines the OFPTYPE_* type of the OpenFlow message in 'msg', which starts
788 * at 'msg->data' and has length 'msg->size' bytes. On success, returns 0 and
789 * stores the type into '*typep'. On failure, returns an OFPERR_* error code
790 * and zeros '*typep'.
792 * This function checks that the message has a valid length for its particular
793 * type of message, and returns an error if not.
795 * In addition to setting '*typep', this function pulls off the OpenFlow header
796 * (including the stats headers, vendor header, and any subtype header) with
797 * ofpbuf_pull(). It also sets 'msg->l2' to the start of the OpenFlow header
798 * and 'msg->l3' just beyond the headers (that is, to the final value of
801 ofptype_pull(enum ofptype
*typep
, struct ofpbuf
*buf
)
806 error
= ofpraw_pull(&raw
, buf
);
807 *typep
= error
? 0 : ofptype_from_ofpraw(raw
);
811 /* Returns the OFPTYPE_* type that corresponds to 'raw'.
813 * (This is a one-way trip, because the mapping from ofpraw to ofptype is
816 ofptype_from_ofpraw(enum ofpraw raw
)
818 return raw_info_get(raw
)->type
;
821 /* Updates the 'length' field of the OpenFlow message in 'buf' to
824 ofpmsg_update_length(struct ofpbuf
*buf
)
826 struct ofp_header
*oh
= ofpbuf_at_assert(buf
, 0, sizeof *oh
);
827 oh
->length
= htons(buf
->size
);
830 /* Returns just past the Openflow header (including the stats headers, vendor
831 * header, and any subtype header) in 'oh'. */
833 ofpmsg_body(const struct ofp_header
*oh
)
837 ofphdrs_decode_assert(&hdrs
, oh
, ntohs(oh
->length
));
838 return (const uint8_t *) oh
+ ofphdrs_len(&hdrs
);
841 /* Return if it's a stat/multipart (OFPST) request message. */
843 ofpmsg_is_stat_request(const struct ofp_header
*oh
)
845 return ofp_is_stat_request(oh
->version
, oh
->type
);
848 static ovs_be16
*ofpmp_flags__(const struct ofp_header
*);
850 /* Initializes 'replies' as a new list of stats messages that reply to
851 * 'request', which must be a stats request message. Initially the list will
852 * consist of only a single reply part without any body. The caller should
853 * use calls to the other ofpmp_*() functions to add to the body and split the
854 * message into multiple parts, if necessary. */
856 ofpmp_init(struct list
*replies
, const struct ofp_header
*request
)
862 msg
= ofpraw_alloc_stats_reply(request
, 1000);
863 list_push_back(replies
, &msg
->list_node
);
866 /* Prepares to append up to 'len' bytes to the series of statistics replies in
867 * 'replies', which should have been initialized with ofpmp_init(), if
868 * necessary adding a new reply to the list.
870 * Returns an ofpbuf with at least 'len' bytes of tailroom. The 'len' bytes
871 * have not actually been allocated, so the caller must do so with
872 * e.g. ofpbuf_put_uninit(). */
874 ofpmp_reserve(struct list
*replies
, size_t len
)
876 struct ofpbuf
*msg
= ofpbuf_from_list(list_back(replies
));
878 if (msg
->size
+ len
<= UINT16_MAX
) {
879 ofpbuf_prealloc_tailroom(msg
, len
);
882 unsigned int hdrs_len
;
886 ofphdrs_decode_assert(&hdrs
, msg
->data
, msg
->size
);
887 hdrs_len
= ofphdrs_len(&hdrs
);
889 next
= ofpbuf_new(MAX(1024, hdrs_len
+ len
));
890 ofpbuf_put(next
, msg
->data
, hdrs_len
);
891 next
->l2
= next
->data
;
892 next
->l3
= ofpbuf_tail(next
);
893 list_push_back(replies
, &next
->list_node
);
895 *ofpmp_flags__(msg
->data
) |= htons(OFPSF_REPLY_MORE
);
901 /* Appends 'len' bytes to the series of statistics replies in 'replies', and
902 * returns the first byte. */
904 ofpmp_append(struct list
*replies
, size_t len
)
906 return ofpbuf_put_uninit(ofpmp_reserve(replies
, len
), len
);
909 /* Sometimes, when composing stats replies, it's difficult to predict how long
910 * an individual reply chunk will be before actually encoding it into the reply
911 * buffer. This function allows easy handling of this case: just encode the
912 * reply, then use this function to break the message into two pieces if it
913 * exceeds the OpenFlow message limit.
915 * In detail, if the final stats message in 'replies' is too long for OpenFlow,
916 * this function breaks it into two separate stats replies, the first one with
917 * the first 'start_ofs' bytes, the second one containing the bytes from that
920 ofpmp_postappend(struct list
*replies
, size_t start_ofs
)
922 struct ofpbuf
*msg
= ofpbuf_from_list(list_back(replies
));
924 ovs_assert(start_ofs
<= UINT16_MAX
);
925 if (msg
->size
> UINT16_MAX
) {
926 size_t len
= msg
->size
- start_ofs
;
927 memcpy(ofpmp_append(replies
, len
),
928 (const uint8_t *) msg
->data
+ start_ofs
, len
);
929 msg
->size
= start_ofs
;
934 ofpmp_flags__(const struct ofp_header
*oh
)
936 switch ((enum ofp_version
)oh
->version
) {
938 return &((struct ofp10_stats_msg
*) oh
)->flags
;
942 return &((struct ofp11_stats_msg
*) oh
)->flags
;
948 /* Returns the OFPSF_* flags found in the OpenFlow stats header of 'oh', which
949 * must be an OpenFlow stats request or reply.
951 * (OFPSF_REPLY_MORE is the only defined flag.) */
953 ofpmp_flags(const struct ofp_header
*oh
)
955 return ntohs(*ofpmp_flags__(oh
));
958 /* Returns true if the OFPSF_REPLY_MORE flag is set in the OpenFlow stats
959 * header of 'oh', which must be an OpenFlow stats request or reply, false if
962 ofpmp_more(const struct ofp_header
*oh
)
964 return (ofpmp_flags(oh
) & OFPSF_REPLY_MORE
) != 0;
967 static void ofpmsgs_init(void);
969 static const struct raw_info
*
970 raw_info_get(enum ofpraw raw
)
974 ovs_assert(raw
< ARRAY_SIZE(raw_infos
));
975 return &raw_infos
[raw
];
978 static struct raw_instance
*
979 raw_instance_get(const struct raw_info
*info
, uint8_t version
)
981 ovs_assert(version
>= info
->min_version
&& version
<= info
->max_version
);
982 return &info
->instances
[version
- info
->min_version
];
986 ofpraw_from_ofphdrs(enum ofpraw
*raw
, const struct ofphdrs
*hdrs
)
988 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 1);
990 struct raw_instance
*raw_hdrs
;
995 hash
= ofphdrs_hash(hdrs
);
996 HMAP_FOR_EACH_WITH_HASH (raw_hdrs
, hmap_node
, hash
, &raw_instance_map
) {
997 if (ofphdrs_equal(hdrs
, &raw_hdrs
->hdrs
)) {
998 *raw
= raw_hdrs
->raw
;
1003 if (!VLOG_DROP_WARN(&rl
)) {
1007 ds_put_format(&s
, "version %"PRIu8
", type %"PRIu8
,
1008 hdrs
->version
, hdrs
->type
);
1009 if (ofphdrs_is_stat(hdrs
)) {
1010 ds_put_format(&s
, ", stat %"PRIu16
, hdrs
->stat
);
1013 ds_put_format(&s
, ", vendor 0x%"PRIx32
", subtype %"PRIu32
,
1014 hdrs
->vendor
, hdrs
->subtype
);
1016 VLOG_WARN("unknown OpenFlow message (%s)", ds_cstr(&s
));
1020 return (hdrs
->vendor
? OFPERR_OFPBRC_BAD_SUBTYPE
1021 : ofphdrs_is_stat(hdrs
) ? OFPERR_OFPBRC_BAD_STAT
1022 : OFPERR_OFPBRC_BAD_TYPE
);
1028 static struct ovsthread_once once
= OVSTHREAD_ONCE_INITIALIZER
;
1029 const struct raw_info
*info
;
1031 if (!ovsthread_once_start(&once
)) {
1035 hmap_init(&raw_instance_map
);
1036 for (info
= raw_infos
; info
< &raw_infos
[ARRAY_SIZE(raw_infos
)]; info
++)
1038 int n_instances
= info
->max_version
- info
->min_version
+ 1;
1039 struct raw_instance
*inst
;
1041 for (inst
= info
->instances
;
1042 inst
< &info
->instances
[n_instances
];
1044 inst
->hdrs_len
= ofphdrs_len(&inst
->hdrs
);
1045 hmap_insert(&raw_instance_map
, &inst
->hmap_node
,
1046 ofphdrs_hash(&inst
->hdrs
));
1050 ovsthread_once_done(&once
);