2 * Copyright (c) 2008, 2009, 2010 Nicira Networks.
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.
18 #include "ofp-print.h"
21 #include "byte-order.h"
28 VLOG_DEFINE_THIS_MODULE(ofp_util
);
30 /* Rate limit for OpenFlow message parse errors. These always indicate a bug
31 * in the peer and so there's not much point in showing a lot of them. */
32 static struct vlog_rate_limit bad_ofmsg_rl
= VLOG_RATE_LIMIT_INIT(1, 5);
34 /* XXX we should really use consecutive xids to avoid probabilistic
36 static inline uint32_t
39 return random_uint32();
42 /* Allocates and stores in '*bufferp' a new ofpbuf with a size of
43 * 'openflow_len', starting with an OpenFlow header with the given 'type' and
44 * an arbitrary transaction id. Allocated bytes beyond the header, if any, are
47 * The caller is responsible for freeing '*bufferp' when it is no longer
50 * The OpenFlow header length is initially set to 'openflow_len'; if the
51 * message is later extended, the length should be updated with
52 * update_openflow_length() before sending.
54 * Returns the header. */
56 make_openflow(size_t openflow_len
, uint8_t type
, struct ofpbuf
**bufferp
)
58 *bufferp
= ofpbuf_new(openflow_len
);
59 return put_openflow_xid(openflow_len
, type
, alloc_xid(), *bufferp
);
62 /* Similar to make_openflow() but creates a Nicira vendor extension message
63 * with the specific 'subtype'. 'subtype' should be in host byte order. */
65 make_nxmsg(size_t openflow_len
, uint32_t subtype
, struct ofpbuf
**bufferp
)
67 return make_nxmsg_xid(openflow_len
, subtype
, alloc_xid(), bufferp
);
70 /* Allocates and stores in '*bufferp' a new ofpbuf with a size of
71 * 'openflow_len', starting with an OpenFlow header with the given 'type' and
72 * transaction id 'xid'. Allocated bytes beyond the header, if any, are
75 * The caller is responsible for freeing '*bufferp' when it is no longer
78 * The OpenFlow header length is initially set to 'openflow_len'; if the
79 * message is later extended, the length should be updated with
80 * update_openflow_length() before sending.
82 * Returns the header. */
84 make_openflow_xid(size_t openflow_len
, uint8_t type
, uint32_t xid
,
85 struct ofpbuf
**bufferp
)
87 *bufferp
= ofpbuf_new(openflow_len
);
88 return put_openflow_xid(openflow_len
, type
, xid
, *bufferp
);
91 /* Similar to make_openflow_xid() but creates a Nicira vendor extension message
92 * with the specific 'subtype'. 'subtype' should be in host byte order. */
94 make_nxmsg_xid(size_t openflow_len
, uint32_t subtype
, uint32_t xid
,
95 struct ofpbuf
**bufferp
)
97 struct nicira_header
*nxh
= make_openflow_xid(openflow_len
, OFPT_VENDOR
,
99 nxh
->vendor
= htonl(NX_VENDOR_ID
);
100 nxh
->subtype
= htonl(subtype
);
104 /* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
105 * with the given 'type' and an arbitrary transaction id. Allocated bytes
106 * beyond the header, if any, are zeroed.
108 * The OpenFlow header length is initially set to 'openflow_len'; if the
109 * message is later extended, the length should be updated with
110 * update_openflow_length() before sending.
112 * Returns the header. */
114 put_openflow(size_t openflow_len
, uint8_t type
, struct ofpbuf
*buffer
)
116 return put_openflow_xid(openflow_len
, type
, alloc_xid(), buffer
);
119 /* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
120 * with the given 'type' and an transaction id 'xid'. Allocated bytes beyond
121 * the header, if any, are zeroed.
123 * The OpenFlow header length is initially set to 'openflow_len'; if the
124 * message is later extended, the length should be updated with
125 * update_openflow_length() before sending.
127 * Returns the header. */
129 put_openflow_xid(size_t openflow_len
, uint8_t type
, uint32_t xid
,
130 struct ofpbuf
*buffer
)
132 struct ofp_header
*oh
;
134 assert(openflow_len
>= sizeof *oh
);
135 assert(openflow_len
<= UINT16_MAX
);
137 oh
= ofpbuf_put_uninit(buffer
, openflow_len
);
138 oh
->version
= OFP_VERSION
;
140 oh
->length
= htons(openflow_len
);
142 memset(oh
+ 1, 0, openflow_len
- sizeof *oh
);
146 /* Updates the 'length' field of the OpenFlow message in 'buffer' to
149 update_openflow_length(struct ofpbuf
*buffer
)
151 struct ofp_header
*oh
= ofpbuf_at_assert(buffer
, 0, sizeof *oh
);
152 oh
->length
= htons(buffer
->size
);
156 make_flow_mod(uint16_t command
, const struct flow
*flow
, size_t actions_len
)
158 struct ofp_flow_mod
*ofm
;
159 size_t size
= sizeof *ofm
+ actions_len
;
160 struct ofpbuf
*out
= ofpbuf_new(size
);
161 ofm
= ofpbuf_put_zeros(out
, sizeof *ofm
);
162 ofm
->header
.version
= OFP_VERSION
;
163 ofm
->header
.type
= OFPT_FLOW_MOD
;
164 ofm
->header
.length
= htons(size
);
166 ofm
->match
.wildcards
= htonl(0);
167 ofm
->match
.in_port
= htons(flow
->in_port
== ODPP_LOCAL
? OFPP_LOCAL
169 memcpy(ofm
->match
.dl_src
, flow
->dl_src
, sizeof ofm
->match
.dl_src
);
170 memcpy(ofm
->match
.dl_dst
, flow
->dl_dst
, sizeof ofm
->match
.dl_dst
);
171 ofm
->match
.dl_vlan
= flow
->dl_vlan
;
172 ofm
->match
.dl_vlan_pcp
= flow
->dl_vlan_pcp
;
173 ofm
->match
.dl_type
= flow
->dl_type
;
174 ofm
->match
.nw_src
= flow
->nw_src
;
175 ofm
->match
.nw_dst
= flow
->nw_dst
;
176 ofm
->match
.nw_proto
= flow
->nw_proto
;
177 ofm
->match
.nw_tos
= flow
->nw_tos
;
178 ofm
->match
.tp_src
= flow
->tp_src
;
179 ofm
->match
.tp_dst
= flow
->tp_dst
;
180 ofm
->command
= htons(command
);
185 make_add_flow(const struct flow
*flow
, uint32_t buffer_id
,
186 uint16_t idle_timeout
, size_t actions_len
)
188 struct ofpbuf
*out
= make_flow_mod(OFPFC_ADD
, flow
, actions_len
);
189 struct ofp_flow_mod
*ofm
= out
->data
;
190 ofm
->idle_timeout
= htons(idle_timeout
);
191 ofm
->hard_timeout
= htons(OFP_FLOW_PERMANENT
);
192 ofm
->buffer_id
= htonl(buffer_id
);
197 make_del_flow(const struct flow
*flow
)
199 struct ofpbuf
*out
= make_flow_mod(OFPFC_DELETE_STRICT
, flow
, 0);
200 struct ofp_flow_mod
*ofm
= out
->data
;
201 ofm
->out_port
= htons(OFPP_NONE
);
206 make_add_simple_flow(const struct flow
*flow
,
207 uint32_t buffer_id
, uint16_t out_port
,
208 uint16_t idle_timeout
)
210 if (out_port
!= OFPP_NONE
) {
211 struct ofp_action_output
*oao
;
212 struct ofpbuf
*buffer
;
214 buffer
= make_add_flow(flow
, buffer_id
, idle_timeout
, sizeof *oao
);
215 oao
= ofpbuf_put_zeros(buffer
, sizeof *oao
);
216 oao
->type
= htons(OFPAT_OUTPUT
);
217 oao
->len
= htons(sizeof *oao
);
218 oao
->port
= htons(out_port
);
221 return make_add_flow(flow
, buffer_id
, idle_timeout
, 0);
226 make_packet_in(uint32_t buffer_id
, uint16_t in_port
, uint8_t reason
,
227 const struct ofpbuf
*payload
, int max_send_len
)
229 struct ofp_packet_in
*opi
;
233 send_len
= MIN(max_send_len
, payload
->size
);
234 buf
= ofpbuf_new(sizeof *opi
+ send_len
);
235 opi
= put_openflow_xid(offsetof(struct ofp_packet_in
, data
),
236 OFPT_PACKET_IN
, 0, buf
);
237 opi
->buffer_id
= htonl(buffer_id
);
238 opi
->total_len
= htons(payload
->size
);
239 opi
->in_port
= htons(in_port
);
240 opi
->reason
= reason
;
241 ofpbuf_put(buf
, payload
->data
, send_len
);
242 update_openflow_length(buf
);
248 make_packet_out(const struct ofpbuf
*packet
, uint32_t buffer_id
,
250 const struct ofp_action_header
*actions
, size_t n_actions
)
252 size_t actions_len
= n_actions
* sizeof *actions
;
253 struct ofp_packet_out
*opo
;
254 size_t size
= sizeof *opo
+ actions_len
+ (packet
? packet
->size
: 0);
255 struct ofpbuf
*out
= ofpbuf_new(size
);
257 opo
= ofpbuf_put_uninit(out
, sizeof *opo
);
258 opo
->header
.version
= OFP_VERSION
;
259 opo
->header
.type
= OFPT_PACKET_OUT
;
260 opo
->header
.length
= htons(size
);
261 opo
->header
.xid
= htonl(0);
262 opo
->buffer_id
= htonl(buffer_id
);
263 opo
->in_port
= htons(in_port
== ODPP_LOCAL
? OFPP_LOCAL
: in_port
);
264 opo
->actions_len
= htons(actions_len
);
265 ofpbuf_put(out
, actions
, actions_len
);
267 ofpbuf_put(out
, packet
->data
, packet
->size
);
273 make_unbuffered_packet_out(const struct ofpbuf
*packet
,
274 uint16_t in_port
, uint16_t out_port
)
276 struct ofp_action_output action
;
277 action
.type
= htons(OFPAT_OUTPUT
);
278 action
.len
= htons(sizeof action
);
279 action
.port
= htons(out_port
);
280 return make_packet_out(packet
, UINT32_MAX
, in_port
,
281 (struct ofp_action_header
*) &action
, 1);
285 make_buffered_packet_out(uint32_t buffer_id
,
286 uint16_t in_port
, uint16_t out_port
)
288 if (out_port
!= OFPP_NONE
) {
289 struct ofp_action_output action
;
290 action
.type
= htons(OFPAT_OUTPUT
);
291 action
.len
= htons(sizeof action
);
292 action
.port
= htons(out_port
);
293 return make_packet_out(NULL
, buffer_id
, in_port
,
294 (struct ofp_action_header
*) &action
, 1);
296 return make_packet_out(NULL
, buffer_id
, in_port
, NULL
, 0);
300 /* Creates and returns an OFPT_ECHO_REQUEST message with an empty payload. */
302 make_echo_request(void)
304 struct ofp_header
*rq
;
305 struct ofpbuf
*out
= ofpbuf_new(sizeof *rq
);
306 rq
= ofpbuf_put_uninit(out
, sizeof *rq
);
307 rq
->version
= OFP_VERSION
;
308 rq
->type
= OFPT_ECHO_REQUEST
;
309 rq
->length
= htons(sizeof *rq
);
314 /* Creates and returns an OFPT_ECHO_REPLY message matching the
315 * OFPT_ECHO_REQUEST message in 'rq'. */
317 make_echo_reply(const struct ofp_header
*rq
)
319 size_t size
= ntohs(rq
->length
);
320 struct ofpbuf
*out
= ofpbuf_new(size
);
321 struct ofp_header
*reply
= ofpbuf_put(out
, rq
, size
);
322 reply
->type
= OFPT_ECHO_REPLY
;
327 check_message_type(uint8_t got_type
, uint8_t want_type
)
329 if (got_type
!= want_type
) {
330 char *want_type_name
= ofp_message_type_to_string(want_type
);
331 char *got_type_name
= ofp_message_type_to_string(got_type
);
332 VLOG_WARN_RL(&bad_ofmsg_rl
,
333 "received bad message type %s (expected %s)",
334 got_type_name
, want_type_name
);
335 free(want_type_name
);
337 return ofp_mkerr(OFPET_BAD_REQUEST
, OFPBRC_BAD_TYPE
);
342 /* Checks that 'msg' has type 'type' and that it is exactly 'size' bytes long.
343 * Returns 0 if the checks pass, otherwise an OpenFlow error code (produced
344 * with ofp_mkerr()). */
346 check_ofp_message(const struct ofp_header
*msg
, uint8_t type
, size_t size
)
351 error
= check_message_type(msg
->type
, type
);
356 got_size
= ntohs(msg
->length
);
357 if (got_size
!= size
) {
358 char *type_name
= ofp_message_type_to_string(type
);
359 VLOG_WARN_RL(&bad_ofmsg_rl
,
360 "received %s message of length %zu (expected %zu)",
361 type_name
, got_size
, size
);
363 return ofp_mkerr(OFPET_BAD_REQUEST
, OFPBRC_BAD_LEN
);
369 /* Checks that 'msg' has type 'type' and that 'msg' is 'size' plus a
370 * nonnegative integer multiple of 'array_elt_size' bytes long. Returns 0 if
371 * the checks pass, otherwise an OpenFlow error code (produced with
374 * If 'n_array_elts' is nonnull, then '*n_array_elts' is set to the number of
375 * 'array_elt_size' blocks in 'msg' past the first 'min_size' bytes, when
378 check_ofp_message_array(const struct ofp_header
*msg
, uint8_t type
,
379 size_t min_size
, size_t array_elt_size
,
380 size_t *n_array_elts
)
385 assert(array_elt_size
);
387 error
= check_message_type(msg
->type
, type
);
392 got_size
= ntohs(msg
->length
);
393 if (got_size
< min_size
) {
394 char *type_name
= ofp_message_type_to_string(type
);
395 VLOG_WARN_RL(&bad_ofmsg_rl
, "received %s message of length %zu "
396 "(expected at least %zu)",
397 type_name
, got_size
, min_size
);
399 return ofp_mkerr(OFPET_BAD_REQUEST
, OFPBRC_BAD_LEN
);
401 if ((got_size
- min_size
) % array_elt_size
) {
402 char *type_name
= ofp_message_type_to_string(type
);
403 VLOG_WARN_RL(&bad_ofmsg_rl
,
404 "received %s message of bad length %zu: the "
405 "excess over %zu (%zu) is not evenly divisible by %zu "
406 "(remainder is %zu)",
407 type_name
, got_size
, min_size
, got_size
- min_size
,
408 array_elt_size
, (got_size
- min_size
) % array_elt_size
);
410 return ofp_mkerr(OFPET_BAD_REQUEST
, OFPBRC_BAD_LEN
);
413 *n_array_elts
= (got_size
- min_size
) / array_elt_size
;
418 const struct ofp_flow_stats
*
419 flow_stats_first(struct flow_stats_iterator
*iter
,
420 const struct ofp_stats_reply
*osr
)
422 iter
->pos
= osr
->body
;
423 iter
->end
= osr
->body
+ (ntohs(osr
->header
.length
)
424 - offsetof(struct ofp_stats_reply
, body
));
425 return flow_stats_next(iter
);
428 const struct ofp_flow_stats
*
429 flow_stats_next(struct flow_stats_iterator
*iter
)
431 ptrdiff_t bytes_left
= iter
->end
- iter
->pos
;
432 const struct ofp_flow_stats
*fs
;
435 if (bytes_left
< sizeof *fs
) {
436 if (bytes_left
!= 0) {
437 VLOG_WARN_RL(&bad_ofmsg_rl
,
438 "%td leftover bytes in flow stats reply", bytes_left
);
443 fs
= (const void *) iter
->pos
;
444 length
= ntohs(fs
->length
);
445 if (length
< sizeof *fs
) {
446 VLOG_WARN_RL(&bad_ofmsg_rl
, "flow stats length %zu is shorter than "
447 "min %zu", length
, sizeof *fs
);
449 } else if (length
> bytes_left
) {
450 VLOG_WARN_RL(&bad_ofmsg_rl
, "flow stats length %zu but only %td "
451 "bytes left", length
, bytes_left
);
453 } else if ((length
- sizeof *fs
) % sizeof fs
->actions
[0]) {
454 VLOG_WARN_RL(&bad_ofmsg_rl
, "flow stats length %zu has %zu bytes "
455 "left over in final action", length
,
456 (length
- sizeof *fs
) % sizeof fs
->actions
[0]);
463 /* Alignment of ofp_actions. */
464 #define ACTION_ALIGNMENT 8
467 check_action_exact_len(const union ofp_action
*a
, unsigned int len
,
468 unsigned int required_len
)
470 if (len
!= required_len
) {
471 VLOG_DBG_RL(&bad_ofmsg_rl
,
472 "action %u has invalid length %"PRIu16
" (must be %u)\n",
473 a
->type
, ntohs(a
->header
.len
), required_len
);
474 return ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_LEN
);
479 /* Checks that 'port' is a valid output port for the OFPAT_OUTPUT action, given
480 * that the switch will never have more than 'max_ports' ports. Returns 0 if
481 * 'port' is valid, otherwise an ofp_mkerr() return code. */
483 check_output_port(uint16_t port
, int max_ports
)
491 case OFPP_CONTROLLER
:
496 if (port
< max_ports
) {
499 VLOG_WARN_RL(&bad_ofmsg_rl
, "unknown output port %x", port
);
500 return ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_OUT_PORT
);
504 /* Checks that 'action' is a valid OFPAT_ENQUEUE action, given that the switch
505 * will never have more than 'max_ports' ports. Returns 0 if 'port' is valid,
506 * otherwise an ofp_mkerr() return code. */
508 check_enqueue_action(const union ofp_action
*a
, unsigned int len
,
511 const struct ofp_action_enqueue
*oae
;
515 error
= check_action_exact_len(a
, len
, 16);
520 oae
= (const struct ofp_action_enqueue
*) a
;
521 port
= ntohs(oae
->port
);
522 if (port
< max_ports
|| port
== OFPP_IN_PORT
) {
525 VLOG_WARN_RL(&bad_ofmsg_rl
, "unknown enqueue port %x", port
);
526 return ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_OUT_PORT
);
530 check_nicira_action(const union ofp_action
*a
, unsigned int len
)
532 const struct nx_action_header
*nah
;
535 VLOG_DBG_RL(&bad_ofmsg_rl
,
536 "Nicira vendor action only %u bytes", len
);
537 return ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_LEN
);
539 nah
= (const struct nx_action_header
*) a
;
541 switch (ntohs(nah
->subtype
)) {
543 case NXAST_SET_TUNNEL
:
544 case NXAST_DROP_SPOOFED_ARP
:
545 case NXAST_SET_QUEUE
:
546 case NXAST_POP_QUEUE
:
547 return check_action_exact_len(a
, len
, 16);
549 return ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_VENDOR_TYPE
);
554 check_action(const union ofp_action
*a
, unsigned int len
, int max_ports
)
558 switch (ntohs(a
->type
)) {
560 error
= check_action_exact_len(a
, len
, 8);
564 return check_output_port(ntohs(a
->output
.port
), max_ports
);
566 case OFPAT_SET_VLAN_VID
:
567 error
= check_action_exact_len(a
, len
, 8);
571 if (a
->vlan_vid
.vlan_vid
& ~htons(0xfff)) {
572 return ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_ARGUMENT
);
576 case OFPAT_SET_VLAN_PCP
:
577 error
= check_action_exact_len(a
, len
, 8);
581 if (a
->vlan_vid
.vlan_vid
& ~7) {
582 return ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_ARGUMENT
);
586 case OFPAT_STRIP_VLAN
:
587 case OFPAT_SET_NW_SRC
:
588 case OFPAT_SET_NW_DST
:
589 case OFPAT_SET_NW_TOS
:
590 case OFPAT_SET_TP_SRC
:
591 case OFPAT_SET_TP_DST
:
592 return check_action_exact_len(a
, len
, 8);
594 case OFPAT_SET_DL_SRC
:
595 case OFPAT_SET_DL_DST
:
596 return check_action_exact_len(a
, len
, 16);
599 return (a
->vendor
.vendor
== htonl(NX_VENDOR_ID
)
600 ? check_nicira_action(a
, len
)
601 : ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_VENDOR
));
604 return check_enqueue_action(a
, len
, max_ports
);
607 VLOG_WARN_RL(&bad_ofmsg_rl
, "unknown action type %"PRIu16
,
609 return ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_TYPE
);
614 validate_actions(const union ofp_action
*actions
, size_t n_actions
,
619 for (i
= 0; i
< n_actions
; ) {
620 const union ofp_action
*a
= &actions
[i
];
621 unsigned int len
= ntohs(a
->header
.len
);
622 unsigned int n_slots
= len
/ ACTION_ALIGNMENT
;
623 unsigned int slots_left
= &actions
[n_actions
] - a
;
626 if (n_slots
> slots_left
) {
627 VLOG_DBG_RL(&bad_ofmsg_rl
,
628 "action requires %u slots but only %u remain",
629 n_slots
, slots_left
);
630 return ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_LEN
);
632 VLOG_DBG_RL(&bad_ofmsg_rl
, "action has invalid length 0");
633 return ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_LEN
);
634 } else if (len
% ACTION_ALIGNMENT
) {
635 VLOG_DBG_RL(&bad_ofmsg_rl
, "action length %u is not a multiple "
636 "of %d", len
, ACTION_ALIGNMENT
);
637 return ofp_mkerr(OFPET_BAD_ACTION
, OFPBAC_BAD_LEN
);
640 error
= check_action(a
, len
, max_ports
);
649 /* Returns true if 'action' outputs to 'port' (which must be in network byte
650 * order), false otherwise. */
652 action_outputs_to_port(const union ofp_action
*action
, uint16_t port
)
654 switch (ntohs(action
->type
)) {
656 return action
->output
.port
== port
;
658 return ((const struct ofp_action_enqueue
*) action
)->port
== port
;
664 /* The set of actions must either come from a trusted source or have been
665 * previously validated with validate_actions(). */
666 const union ofp_action
*
667 actions_first(struct actions_iterator
*iter
,
668 const union ofp_action
*oa
, size_t n_actions
)
671 iter
->end
= oa
+ n_actions
;
672 return actions_next(iter
);
675 const union ofp_action
*
676 actions_next(struct actions_iterator
*iter
)
678 if (iter
->pos
!= iter
->end
) {
679 const union ofp_action
*a
= iter
->pos
;
680 unsigned int len
= ntohs(a
->header
.len
);
681 iter
->pos
+= len
/ ACTION_ALIGNMENT
;
689 normalize_match(struct ofp_match
*m
)
691 enum { OFPFW_NW
= (OFPFW_NW_SRC_MASK
| OFPFW_NW_DST_MASK
| OFPFW_NW_PROTO
693 enum { OFPFW_TP
= OFPFW_TP_SRC
| OFPFW_TP_DST
};
696 wc
= ntohl(m
->wildcards
) & OVSFW_ALL
;
697 if (wc
& OFPFW_DL_TYPE
) {
700 /* Can't sensibly match on network or transport headers if the
701 * data link type is unknown. */
702 wc
|= OFPFW_NW
| OFPFW_TP
;
703 m
->nw_src
= m
->nw_dst
= m
->nw_proto
= m
->nw_tos
= 0;
704 m
->tp_src
= m
->tp_dst
= 0;
705 } else if (m
->dl_type
== htons(ETH_TYPE_IP
)) {
706 if (wc
& OFPFW_NW_PROTO
) {
709 /* Can't sensibly match on transport headers if the network
710 * protocol is unknown. */
712 m
->tp_src
= m
->tp_dst
= 0;
713 } else if (m
->nw_proto
== IPPROTO_TCP
||
714 m
->nw_proto
== IPPROTO_UDP
||
715 m
->nw_proto
== IPPROTO_ICMP
) {
716 if (wc
& OFPFW_TP_SRC
) {
719 if (wc
& OFPFW_TP_DST
) {
723 /* Transport layer fields will always be extracted as zeros, so we
724 * can do an exact-match on those values. */
726 m
->tp_src
= m
->tp_dst
= 0;
728 if (wc
& OFPFW_NW_SRC_MASK
) {
729 m
->nw_src
&= flow_nw_bits_to_mask(wc
, OFPFW_NW_SRC_SHIFT
);
731 if (wc
& OFPFW_NW_DST_MASK
) {
732 m
->nw_dst
&= flow_nw_bits_to_mask(wc
, OFPFW_NW_DST_SHIFT
);
734 if (wc
& OFPFW_NW_TOS
) {
737 m
->nw_tos
&= IP_DSCP_MASK
;
739 } else if (m
->dl_type
== htons(ETH_TYPE_ARP
)) {
740 if (wc
& OFPFW_NW_PROTO
) {
743 if (wc
& OFPFW_NW_SRC_MASK
) {
744 m
->nw_src
&= flow_nw_bits_to_mask(wc
, OFPFW_NW_SRC_SHIFT
);
746 if (wc
& OFPFW_NW_DST_MASK
) {
747 m
->nw_dst
&= flow_nw_bits_to_mask(wc
, OFPFW_NW_DST_SHIFT
);
749 m
->tp_src
= m
->tp_dst
= m
->nw_tos
= 0;
751 /* Network and transport layer fields will always be extracted as
752 * zeros, so we can do an exact-match on those values. */
753 wc
&= ~(OFPFW_NW
| OFPFW_TP
);
754 m
->nw_proto
= m
->nw_src
= m
->nw_dst
= m
->nw_tos
= 0;
755 m
->tp_src
= m
->tp_dst
= 0;
757 if (wc
& OFPFW_DL_SRC
) {
758 memset(m
->dl_src
, 0, sizeof m
->dl_src
);
760 if (wc
& OFPFW_DL_DST
) {
761 memset(m
->dl_dst
, 0, sizeof m
->dl_dst
);
763 m
->wildcards
= htonl(wc
);
766 /* Returns a string that describes 'match' in a very literal way, without
767 * interpreting its contents except in a very basic fashion. The returned
768 * string is intended to be fixed-length, so that it is easy to see differences
769 * between two such strings if one is put above another. This is useful for
770 * describing changes made by normalize_match().
772 * The caller must free the returned string (with free()). */
774 ofp_match_to_literal_string(const struct ofp_match
*match
)
776 return xasprintf("wildcards=%#10"PRIx32
" "
777 " in_port=%5"PRId16
" "
778 " dl_src="ETH_ADDR_FMT
" "
779 " dl_dst="ETH_ADDR_FMT
" "
780 " dl_vlan=%5"PRId16
" "
781 " dl_vlan_pcp=%3"PRId8
" "
782 " dl_type=%#6"PRIx16
" "
783 " nw_tos=%#4"PRIx8
" "
784 " nw_proto=%#4"PRIx16
" "
785 " nw_src=%#10"PRIx32
" "
786 " nw_dst=%#10"PRIx32
" "
787 " tp_src=%5"PRId16
" "
789 ntohl(match
->wildcards
),
790 ntohs(match
->in_port
),
791 ETH_ADDR_ARGS(match
->dl_src
),
792 ETH_ADDR_ARGS(match
->dl_dst
),
793 ntohs(match
->dl_vlan
),
795 ntohs(match
->dl_type
),
798 ntohl(match
->nw_src
),
799 ntohl(match
->nw_dst
),
800 ntohs(match
->tp_src
),
801 ntohs(match
->tp_dst
));
805 vendor_code_to_id(uint8_t code
)
808 #define OFPUTIL_VENDOR(NAME, VENDOR_ID) case NAME: return VENDOR_ID;
810 #undef OFPUTIL_VENDOR
816 /* Creates and returns an OpenFlow message of type OFPT_ERROR with the error
817 * information taken from 'error', whose encoding must be as described in the
818 * large comment in ofp-util.h. If 'oh' is nonnull, then the error will use
819 * oh->xid as its transaction ID, and it will include up to the first 64 bytes
822 * Returns NULL if 'error' is not an OpenFlow error code. */
824 make_ofp_error_msg(int error
, const struct ofp_header
*oh
)
826 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
836 if (!is_ofp_error(error
)) {
837 /* We format 'error' with strerror() here since it seems likely to be
838 * a system errno value. */
839 VLOG_WARN_RL(&rl
, "invalid OpenFlow error code %d (%s)",
840 error
, strerror(error
));
847 len
= ntohs(oh
->length
);
857 vendor
= get_ofp_err_vendor(error
);
858 type
= get_ofp_err_type(error
);
859 code
= get_ofp_err_code(error
);
860 if (vendor
== OFPUTIL_VENDOR_OPENFLOW
) {
861 struct ofp_error_msg
*oem
;
863 oem
= make_openflow_xid(len
+ sizeof *oem
, OFPT_ERROR
, xid
, &buf
);
864 oem
->type
= htons(type
);
865 oem
->code
= htons(code
);
867 struct ofp_error_msg
*oem
;
868 struct nx_vendor_error
*nve
;
871 vendor_id
= vendor_code_to_id(vendor
);
872 if (vendor_id
== UINT32_MAX
) {
873 VLOG_WARN_RL(&rl
, "error %x contains invalid vendor code %d",
878 oem
= make_openflow_xid(len
+ sizeof *oem
+ sizeof *nve
,
879 OFPT_ERROR
, xid
, &buf
);
880 oem
->type
= htons(NXET_VENDOR
);
881 oem
->code
= htons(NXVC_VENDOR_ERROR
);
883 nve
= ofpbuf_put_uninit(buf
, sizeof *nve
);
884 nve
->vendor
= htonl(vendor_id
);
885 nve
->type
= htons(type
);
886 nve
->code
= htons(code
);
890 ofpbuf_put(buf
, data
, len
);
896 /* Attempts to pull 'actions_len' bytes from the front of 'b'. Returns 0 if
897 * successful, otherwise an OpenFlow error.
899 * If successful, the first action is stored in '*actionsp' and the number of
900 * "union ofp_action" size elements into '*n_actionsp'. Otherwise NULL and 0
901 * are stored, respectively.
903 * This function does not check that the actions are valid (the caller should
904 * do so, with validate_actions()). The caller is also responsible for making
905 * sure that 'b->data' is initially aligned appropriately for "union
908 ofputil_pull_actions(struct ofpbuf
*b
, unsigned int actions_len
,
909 union ofp_action
**actionsp
, size_t *n_actionsp
)
911 if (actions_len
% ACTION_ALIGNMENT
!= 0) {
912 VLOG_DBG_RL(&bad_ofmsg_rl
, "OpenFlow message actions length %u "
913 "is not a multiple of %d", actions_len
, ACTION_ALIGNMENT
);
917 *actionsp
= ofpbuf_try_pull(b
, actions_len
);
918 if (*actionsp
== NULL
) {
919 VLOG_DBG_RL(&bad_ofmsg_rl
, "OpenFlow message actions length %u "
920 "exceeds remaining message length (%zu)",
921 actions_len
, b
->size
);
925 *n_actionsp
= actions_len
/ ACTION_ALIGNMENT
;
931 return ofp_mkerr(OFPET_BAD_REQUEST
, OFPBRC_BAD_LEN
);