2 * Copyright (c) 2008, 2009, 2010, 2011, 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.
18 #include "ofp-actions.h"
20 #include "byte-order.h"
22 #include "dynamic-string.h"
24 #include "meta-flow.h"
25 #include "multipath.h"
32 VLOG_DEFINE_THIS_MODULE(ofp_actions
);
34 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
36 /* Converting OpenFlow 1.0 to ofpacts. */
39 output_from_openflow10(const struct ofp10_action_output
*oao
,
42 struct ofpact_output
*output
;
44 output
= ofpact_put_OUTPUT(out
);
45 output
->port
= ntohs(oao
->port
);
46 output
->max_len
= ntohs(oao
->max_len
);
48 return ofputil_check_output_port(output
->port
, OFPP_MAX
);
52 enqueue_from_openflow10(const struct ofp10_action_enqueue
*oae
,
55 struct ofpact_enqueue
*enqueue
;
57 enqueue
= ofpact_put_ENQUEUE(out
);
58 enqueue
->port
= ntohs(oae
->port
);
59 enqueue
->queue
= ntohl(oae
->queue_id
);
60 if (enqueue
->port
>= OFPP_MAX
&& enqueue
->port
!= OFPP_IN_PORT
61 && enqueue
->port
!= OFPP_LOCAL
) {
62 return OFPERR_OFPBAC_BAD_OUT_PORT
;
68 resubmit_from_openflow(const struct nx_action_resubmit
*nar
,
71 struct ofpact_resubmit
*resubmit
;
73 resubmit
= ofpact_put_RESUBMIT(out
);
74 resubmit
->ofpact
.compat
= OFPUTIL_NXAST_RESUBMIT
;
75 resubmit
->in_port
= ntohs(nar
->in_port
);
76 resubmit
->table_id
= 0xff;
80 resubmit_table_from_openflow(const struct nx_action_resubmit
*nar
,
83 struct ofpact_resubmit
*resubmit
;
85 if (nar
->pad
[0] || nar
->pad
[1] || nar
->pad
[2]) {
86 return OFPERR_OFPBAC_BAD_ARGUMENT
;
89 resubmit
= ofpact_put_RESUBMIT(out
);
90 resubmit
->ofpact
.compat
= OFPUTIL_NXAST_RESUBMIT_TABLE
;
91 resubmit
->in_port
= ntohs(nar
->in_port
);
92 resubmit
->table_id
= nar
->table
;
97 output_reg_from_openflow(const struct nx_action_output_reg
*naor
,
100 struct ofpact_output_reg
*output_reg
;
102 if (!is_all_zeros(naor
->zero
, sizeof naor
->zero
)) {
103 return OFPERR_OFPBAC_BAD_ARGUMENT
;
106 output_reg
= ofpact_put_OUTPUT_REG(out
);
107 output_reg
->src
.field
= mf_from_nxm_header(ntohl(naor
->src
));
108 output_reg
->src
.ofs
= nxm_decode_ofs(naor
->ofs_nbits
);
109 output_reg
->src
.n_bits
= nxm_decode_n_bits(naor
->ofs_nbits
);
110 output_reg
->max_len
= ntohs(naor
->max_len
);
112 return mf_check_src(&output_reg
->src
, NULL
);
116 fin_timeout_from_openflow(const struct nx_action_fin_timeout
*naft
,
119 struct ofpact_fin_timeout
*oft
;
121 oft
= ofpact_put_FIN_TIMEOUT(out
);
122 oft
->fin_idle_timeout
= ntohs(naft
->fin_idle_timeout
);
123 oft
->fin_hard_timeout
= ntohs(naft
->fin_hard_timeout
);
127 controller_from_openflow(const struct nx_action_controller
*nac
,
130 struct ofpact_controller
*oc
;
132 oc
= ofpact_put_CONTROLLER(out
);
133 oc
->max_len
= ntohs(nac
->max_len
);
134 oc
->controller_id
= ntohs(nac
->controller_id
);
135 oc
->reason
= nac
->reason
;
139 metadata_from_nxast(const struct nx_action_write_metadata
*nawm
,
142 struct ofpact_metadata
*om
;
144 if (!is_all_zeros(nawm
->zeros
, sizeof nawm
->zeros
)) {
145 return OFPERR_NXBRC_MUST_BE_ZERO
;
148 om
= ofpact_put_WRITE_METADATA(out
);
149 om
->metadata
= nawm
->metadata
;
150 om
->mask
= nawm
->mask
;
156 note_from_openflow(const struct nx_action_note
*nan
, struct ofpbuf
*out
)
158 struct ofpact_note
*note
;
161 length
= ntohs(nan
->len
) - offsetof(struct nx_action_note
, note
);
162 note
= ofpact_put(out
, OFPACT_NOTE
,
163 offsetof(struct ofpact_note
, data
) + length
);
164 note
->length
= length
;
165 memcpy(note
->data
, nan
->note
, length
);
169 dec_ttl_from_openflow(struct ofpbuf
*out
, enum ofputil_action_code compat
)
172 struct ofpact_cnt_ids
*ids
;
173 enum ofperr error
= 0;
175 ids
= ofpact_put_DEC_TTL(out
);
176 ids
->ofpact
.compat
= compat
;
177 ids
->n_controllers
= 1;
178 ofpbuf_put(out
, &id
, sizeof id
);
180 ofpact_update_len(out
, &ids
->ofpact
);
185 dec_ttl_cnt_ids_from_openflow(const struct nx_action_cnt_ids
*nac_ids
,
188 struct ofpact_cnt_ids
*ids
;
192 ids
= ofpact_put_DEC_TTL(out
);
193 ids
->ofpact
.compat
= OFPUTIL_NXAST_DEC_TTL_CNT_IDS
;
194 ids
->n_controllers
= ntohs(nac_ids
->n_controllers
);
195 ids_size
= ntohs(nac_ids
->len
) - sizeof *nac_ids
;
197 if (!is_all_zeros(nac_ids
->zeros
, sizeof nac_ids
->zeros
)) {
198 return OFPERR_NXBRC_MUST_BE_ZERO
;
201 if (ids_size
< ids
->n_controllers
* sizeof(ovs_be16
)) {
202 VLOG_WARN_RL(&rl
, "Nicira action dec_ttl_cnt_ids only has %zu bytes "
203 "allocated for controller ids. %zu bytes are required for "
204 "%"PRIu16
" controllers.", ids_size
,
205 ids
->n_controllers
* sizeof(ovs_be16
), ids
->n_controllers
);
206 return OFPERR_OFPBAC_BAD_LEN
;
209 for (i
= 0; i
< ids
->n_controllers
; i
++) {
210 uint16_t id
= ntohs(((ovs_be16
*)(nac_ids
+ 1))[i
]);
211 ofpbuf_put(out
, &id
, sizeof id
);
215 ofpact_update_len(out
, &ids
->ofpact
);
221 decode_nxast_action(const union ofp_action
*a
, enum ofputil_action_code
*code
)
223 const struct nx_action_header
*nah
= (const struct nx_action_header
*) a
;
224 uint16_t len
= ntohs(a
->header
.len
);
226 if (len
< sizeof(struct nx_action_header
)) {
227 return OFPERR_OFPBAC_BAD_LEN
;
228 } else if (a
->vendor
.vendor
!= CONSTANT_HTONL(NX_VENDOR_ID
)) {
229 return OFPERR_OFPBAC_BAD_VENDOR
;
232 switch (nah
->subtype
) {
233 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \
234 case CONSTANT_HTONS(ENUM): \
236 ? len >= sizeof(struct STRUCT) \
237 : len == sizeof(struct STRUCT)) { \
238 *code = OFPUTIL_##ENUM; \
241 return OFPERR_OFPBAC_BAD_LEN; \
244 #include "ofp-util.def"
246 case CONSTANT_HTONS(NXAST_SNAT__OBSOLETE
):
247 case CONSTANT_HTONS(NXAST_DROP_SPOOFED_ARP__OBSOLETE
):
249 return OFPERR_OFPBAC_BAD_TYPE
;
253 /* Parses 'a' to determine its type. On success stores the correct type into
254 * '*code' and returns 0. On failure returns an OFPERR_* error code and
255 * '*code' is indeterminate.
257 * The caller must have already verified that 'a''s length is potentially
258 * correct (that is, a->header.len is nonzero and a multiple of sizeof(union
259 * ofp_action) and no longer than the amount of space allocated to 'a').
261 * This function verifies that 'a''s length is correct for the type of action
262 * that it represents. */
264 decode_openflow10_action(const union ofp_action
*a
,
265 enum ofputil_action_code
*code
)
268 case CONSTANT_HTONS(OFPAT10_VENDOR
):
269 return decode_nxast_action(a
, code
);
271 #define OFPAT10_ACTION(ENUM, STRUCT, NAME) \
272 case CONSTANT_HTONS(ENUM): \
273 if (a->header.len == htons(sizeof(struct STRUCT))) { \
274 *code = OFPUTIL_##ENUM; \
277 return OFPERR_OFPBAC_BAD_LEN; \
280 #include "ofp-util.def"
283 return OFPERR_OFPBAC_BAD_TYPE
;
288 ofpact_from_nxast(const union ofp_action
*a
, enum ofputil_action_code code
,
291 const struct nx_action_resubmit
*nar
;
292 const struct nx_action_set_tunnel
*nast
;
293 const struct nx_action_set_queue
*nasq
;
294 const struct nx_action_note
*nan
;
295 const struct nx_action_set_tunnel64
*nast64
;
296 const struct nx_action_write_metadata
*nawm
;
297 struct ofpact_tunnel
*tunnel
;
298 enum ofperr error
= 0;
301 case OFPUTIL_ACTION_INVALID
:
302 #define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
303 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
304 #include "ofp-util.def"
307 case OFPUTIL_NXAST_RESUBMIT
:
308 resubmit_from_openflow((const struct nx_action_resubmit
*) a
, out
);
311 case OFPUTIL_NXAST_SET_TUNNEL
:
312 nast
= (const struct nx_action_set_tunnel
*) a
;
313 tunnel
= ofpact_put_SET_TUNNEL(out
);
314 tunnel
->ofpact
.compat
= code
;
315 tunnel
->tun_id
= ntohl(nast
->tun_id
);
318 case OFPUTIL_NXAST_WRITE_METADATA
:
319 nawm
= (const struct nx_action_write_metadata
*) a
;
320 error
= metadata_from_nxast(nawm
, out
);
323 case OFPUTIL_NXAST_SET_QUEUE
:
324 nasq
= (const struct nx_action_set_queue
*) a
;
325 ofpact_put_SET_QUEUE(out
)->queue_id
= ntohl(nasq
->queue_id
);
328 case OFPUTIL_NXAST_POP_QUEUE
:
329 ofpact_put_POP_QUEUE(out
);
332 case OFPUTIL_NXAST_REG_MOVE
:
333 error
= nxm_reg_move_from_openflow(
334 (const struct nx_action_reg_move
*) a
, out
);
337 case OFPUTIL_NXAST_REG_LOAD
:
338 error
= nxm_reg_load_from_openflow(
339 (const struct nx_action_reg_load
*) a
, out
);
342 case OFPUTIL_NXAST_NOTE
:
343 nan
= (const struct nx_action_note
*) a
;
344 note_from_openflow(nan
, out
);
347 case OFPUTIL_NXAST_SET_TUNNEL64
:
348 nast64
= (const struct nx_action_set_tunnel64
*) a
;
349 tunnel
= ofpact_put_SET_TUNNEL(out
);
350 tunnel
->ofpact
.compat
= code
;
351 tunnel
->tun_id
= ntohll(nast64
->tun_id
);
354 case OFPUTIL_NXAST_MULTIPATH
:
355 error
= multipath_from_openflow((const struct nx_action_multipath
*) a
,
356 ofpact_put_MULTIPATH(out
));
359 case OFPUTIL_NXAST_BUNDLE
:
360 case OFPUTIL_NXAST_BUNDLE_LOAD
:
361 error
= bundle_from_openflow((const struct nx_action_bundle
*) a
, out
);
364 case OFPUTIL_NXAST_OUTPUT_REG
:
365 error
= output_reg_from_openflow(
366 (const struct nx_action_output_reg
*) a
, out
);
369 case OFPUTIL_NXAST_RESUBMIT_TABLE
:
370 nar
= (const struct nx_action_resubmit
*) a
;
371 error
= resubmit_table_from_openflow(nar
, out
);
374 case OFPUTIL_NXAST_LEARN
:
375 error
= learn_from_openflow((const struct nx_action_learn
*) a
, out
);
378 case OFPUTIL_NXAST_EXIT
:
379 ofpact_put_EXIT(out
);
382 case OFPUTIL_NXAST_DEC_TTL
:
383 error
= dec_ttl_from_openflow(out
, code
);
386 case OFPUTIL_NXAST_DEC_TTL_CNT_IDS
:
387 error
= dec_ttl_cnt_ids_from_openflow(
388 (const struct nx_action_cnt_ids
*) a
, out
);
391 case OFPUTIL_NXAST_FIN_TIMEOUT
:
392 fin_timeout_from_openflow(
393 (const struct nx_action_fin_timeout
*) a
, out
);
396 case OFPUTIL_NXAST_CONTROLLER
:
397 controller_from_openflow((const struct nx_action_controller
*) a
, out
);
400 case OFPUTIL_NXAST_PUSH_MPLS
: {
401 struct nx_action_push_mpls
*nxapm
= (struct nx_action_push_mpls
*)a
;
402 if (!eth_type_mpls(nxapm
->ethertype
)) {
403 return OFPERR_OFPBAC_BAD_ARGUMENT
;
405 ofpact_put_PUSH_MPLS(out
)->ethertype
= nxapm
->ethertype
;
409 case OFPUTIL_NXAST_SET_MPLS_TTL
: {
410 struct nx_action_mpls_ttl
*nxamt
= (struct nx_action_mpls_ttl
*)a
;
411 ofpact_put_SET_MPLS_TTL(out
)->ttl
= nxamt
->ttl
;
415 case OFPUTIL_NXAST_DEC_MPLS_TTL
:
416 ofpact_put_DEC_MPLS_TTL(out
);
419 case OFPUTIL_NXAST_POP_MPLS
: {
420 struct nx_action_pop_mpls
*nxapm
= (struct nx_action_pop_mpls
*)a
;
421 if (eth_type_mpls(nxapm
->ethertype
)) {
422 return OFPERR_OFPBAC_BAD_ARGUMENT
;
424 ofpact_put_POP_MPLS(out
)->ethertype
= nxapm
->ethertype
;
433 ofpact_from_openflow10(const union ofp_action
*a
, struct ofpbuf
*out
)
435 enum ofputil_action_code code
;
438 error
= decode_openflow10_action(a
, &code
);
444 case OFPUTIL_ACTION_INVALID
:
445 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
446 #include "ofp-util.def"
449 case OFPUTIL_OFPAT10_OUTPUT
:
450 return output_from_openflow10(&a
->output10
, out
);
452 case OFPUTIL_OFPAT10_SET_VLAN_VID
:
453 if (a
->vlan_vid
.vlan_vid
& ~htons(0xfff)) {
454 return OFPERR_OFPBAC_BAD_ARGUMENT
;
456 ofpact_put_SET_VLAN_VID(out
)->vlan_vid
= ntohs(a
->vlan_vid
.vlan_vid
);
459 case OFPUTIL_OFPAT10_SET_VLAN_PCP
:
460 if (a
->vlan_pcp
.vlan_pcp
& ~7) {
461 return OFPERR_OFPBAC_BAD_ARGUMENT
;
463 ofpact_put_SET_VLAN_PCP(out
)->vlan_pcp
= a
->vlan_pcp
.vlan_pcp
;
466 case OFPUTIL_OFPAT10_STRIP_VLAN
:
467 ofpact_put_STRIP_VLAN(out
);
470 case OFPUTIL_OFPAT10_SET_DL_SRC
:
471 memcpy(ofpact_put_SET_ETH_SRC(out
)->mac
,
472 ((const struct ofp_action_dl_addr
*) a
)->dl_addr
, ETH_ADDR_LEN
);
475 case OFPUTIL_OFPAT10_SET_DL_DST
:
476 memcpy(ofpact_put_SET_ETH_DST(out
)->mac
,
477 ((const struct ofp_action_dl_addr
*) a
)->dl_addr
, ETH_ADDR_LEN
);
480 case OFPUTIL_OFPAT10_SET_NW_SRC
:
481 ofpact_put_SET_IPV4_SRC(out
)->ipv4
= a
->nw_addr
.nw_addr
;
484 case OFPUTIL_OFPAT10_SET_NW_DST
:
485 ofpact_put_SET_IPV4_DST(out
)->ipv4
= a
->nw_addr
.nw_addr
;
488 case OFPUTIL_OFPAT10_SET_NW_TOS
:
489 if (a
->nw_tos
.nw_tos
& ~IP_DSCP_MASK
) {
490 return OFPERR_OFPBAC_BAD_ARGUMENT
;
492 ofpact_put_SET_IPV4_DSCP(out
)->dscp
= a
->nw_tos
.nw_tos
;
495 case OFPUTIL_OFPAT10_SET_TP_SRC
:
496 ofpact_put_SET_L4_SRC_PORT(out
)->port
= ntohs(a
->tp_port
.tp_port
);
499 case OFPUTIL_OFPAT10_SET_TP_DST
:
500 ofpact_put_SET_L4_DST_PORT(out
)->port
= ntohs(a
->tp_port
.tp_port
);
504 case OFPUTIL_OFPAT10_ENQUEUE
:
505 error
= enqueue_from_openflow10((const struct ofp10_action_enqueue
*) a
,
509 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
510 #include "ofp-util.def"
511 return ofpact_from_nxast(a
, code
, out
);
517 static inline union ofp_action
*
518 action_next(const union ofp_action
*a
)
520 return ((union ofp_action
*) (void *)
521 ((uint8_t *) a
+ ntohs(a
->header
.len
)));
525 action_is_valid(const union ofp_action
*a
, size_t n_actions
)
527 uint16_t len
= ntohs(a
->header
.len
);
528 return (!(len
% OFP_ACTION_ALIGN
)
530 && len
/ sizeof *a
<= n_actions
);
533 /* This macro is careful to check for actions with bad lengths. */
534 #define ACTION_FOR_EACH(ITER, LEFT, ACTIONS, N_ACTIONS) \
535 for ((ITER) = (ACTIONS), (LEFT) = (N_ACTIONS); \
536 (LEFT) > 0 && action_is_valid(ITER, LEFT); \
537 ((LEFT) -= ntohs((ITER)->header.len) / sizeof(union ofp_action), \
538 (ITER) = action_next(ITER)))
541 log_bad_action(const union ofp_action
*actions
, size_t n_actions
, size_t ofs
,
544 if (!VLOG_DROP_WARN(&rl
)) {
548 ds_put_hex_dump(&s
, actions
, n_actions
* sizeof *actions
, 0, false);
549 VLOG_WARN("bad action at offset %#zx (%s):\n%s",
550 ofs
* sizeof *actions
, ofperr_get_name(error
), ds_cstr(&s
));
556 ofpacts_from_openflow(const union ofp_action
*in
, size_t n_in
,
558 enum ofperr (*ofpact_from_openflow
)(
559 const union ofp_action
*a
, struct ofpbuf
*out
))
561 const union ofp_action
*a
;
564 ACTION_FOR_EACH (a
, left
, in
, n_in
) {
565 enum ofperr error
= ofpact_from_openflow(a
, out
);
567 log_bad_action(in
, n_in
, a
- in
, error
);
572 enum ofperr error
= OFPERR_OFPBAC_BAD_LEN
;
573 log_bad_action(in
, n_in
, n_in
- left
, error
);
582 ofpacts_from_openflow10(const union ofp_action
*in
, size_t n_in
,
585 return ofpacts_from_openflow(in
, n_in
, out
, ofpact_from_openflow10
);
589 ofpacts_pull_actions(struct ofpbuf
*openflow
, unsigned int actions_len
,
590 struct ofpbuf
*ofpacts
,
591 enum ofperr (*translate
)(const union ofp_action
*actions
,
593 struct ofpbuf
*ofpacts
))
595 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
596 const union ofp_action
*actions
;
599 ofpbuf_clear(ofpacts
);
601 if (actions_len
% OFP_ACTION_ALIGN
!= 0) {
602 VLOG_WARN_RL(&rl
, "OpenFlow message actions length %u is not a "
603 "multiple of %d", actions_len
, OFP_ACTION_ALIGN
);
604 return OFPERR_OFPBRC_BAD_LEN
;
607 actions
= ofpbuf_try_pull(openflow
, actions_len
);
608 if (actions
== NULL
) {
609 VLOG_WARN_RL(&rl
, "OpenFlow message actions length %u exceeds "
610 "remaining message length (%zu)",
611 actions_len
, openflow
->size
);
612 return OFPERR_OFPBRC_BAD_LEN
;
615 error
= translate(actions
, actions_len
/ OFP_ACTION_ALIGN
, ofpacts
);
617 ofpbuf_clear(ofpacts
);
621 error
= ofpacts_verify(ofpacts
->data
, ofpacts
->size
);
623 ofpbuf_clear(ofpacts
);
628 /* Attempts to convert 'actions_len' bytes of OpenFlow 1.0 actions from the
629 * front of 'openflow' into ofpacts. On success, replaces any existing content
630 * in 'ofpacts' by the converted ofpacts; on failure, clears 'ofpacts'.
631 * Returns 0 if successful, otherwise an OpenFlow error.
633 * The parsed actions are valid generically, but they may not be valid in a
634 * specific context. For example, port numbers up to OFPP_MAX are valid
635 * generically, but specific datapaths may only support port numbers in a
636 * smaller range. Use ofpacts_check() to additional check whether actions are
637 * valid in a specific context. */
639 ofpacts_pull_openflow10(struct ofpbuf
*openflow
, unsigned int actions_len
,
640 struct ofpbuf
*ofpacts
)
642 return ofpacts_pull_actions(openflow
, actions_len
, ofpacts
,
643 ofpacts_from_openflow10
);
646 /* OpenFlow 1.1 actions. */
648 /* Parses 'a' to determine its type. On success stores the correct type into
649 * '*code' and returns 0. On failure returns an OFPERR_* error code and
650 * '*code' is indeterminate.
652 * The caller must have already verified that 'a''s length is potentially
653 * correct (that is, a->header.len is nonzero and a multiple of sizeof(union
654 * ofp_action) and no longer than the amount of space allocated to 'a').
656 * This function verifies that 'a''s length is correct for the type of action
657 * that it represents. */
659 decode_openflow11_action(const union ofp_action
*a
,
660 enum ofputil_action_code
*code
)
665 case CONSTANT_HTONS(OFPAT11_EXPERIMENTER
):
666 return decode_nxast_action(a
, code
);
668 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \
669 case CONSTANT_HTONS(ENUM): \
670 len = ntohs(a->header.len); \
672 ? len >= sizeof(struct STRUCT) \
673 : len == sizeof(struct STRUCT)) { \
674 *code = OFPUTIL_##ENUM; \
677 return OFPERR_OFPBAC_BAD_LEN; \
680 #include "ofp-util.def"
683 return OFPERR_OFPBAC_BAD_TYPE
;
688 output_from_openflow11(const struct ofp11_action_output
*oao
,
691 struct ofpact_output
*output
;
694 output
= ofpact_put_OUTPUT(out
);
695 output
->max_len
= ntohs(oao
->max_len
);
697 error
= ofputil_port_from_ofp11(oao
->port
, &output
->port
);
702 return ofputil_check_output_port(output
->port
, OFPP_MAX
);
706 ofpact_from_openflow11(const union ofp_action
*a
, struct ofpbuf
*out
)
708 enum ofputil_action_code code
;
711 error
= decode_openflow11_action(a
, &code
);
717 case OFPUTIL_ACTION_INVALID
:
718 #define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
719 #include "ofp-util.def"
722 case OFPUTIL_OFPAT11_OUTPUT
:
723 return output_from_openflow11((const struct ofp11_action_output
*) a
,
726 case OFPUTIL_OFPAT11_SET_VLAN_VID
:
727 if (a
->vlan_vid
.vlan_vid
& ~htons(0xfff)) {
728 return OFPERR_OFPBAC_BAD_ARGUMENT
;
730 ofpact_put_SET_VLAN_VID(out
)->vlan_vid
= ntohs(a
->vlan_vid
.vlan_vid
);
733 case OFPUTIL_OFPAT11_SET_VLAN_PCP
:
734 if (a
->vlan_pcp
.vlan_pcp
& ~7) {
735 return OFPERR_OFPBAC_BAD_ARGUMENT
;
737 ofpact_put_SET_VLAN_PCP(out
)->vlan_pcp
= a
->vlan_pcp
.vlan_pcp
;
740 case OFPUTIL_OFPAT11_PUSH_VLAN
:
741 if (((const struct ofp11_action_push
*)a
)->ethertype
!=
742 htons(ETH_TYPE_VLAN_8021Q
)) {
743 /* XXX 802.1AD(QinQ) isn't supported at the moment */
744 return OFPERR_OFPBAC_BAD_ARGUMENT
;
746 ofpact_put_PUSH_VLAN(out
);
749 case OFPUTIL_OFPAT11_POP_VLAN
:
750 ofpact_put_STRIP_VLAN(out
);
753 case OFPUTIL_OFPAT11_SET_QUEUE
:
754 ofpact_put_SET_QUEUE(out
)->queue_id
=
755 ntohl(((const struct ofp11_action_set_queue
*)a
)->queue_id
);
758 case OFPUTIL_OFPAT11_SET_DL_SRC
:
759 memcpy(ofpact_put_SET_ETH_SRC(out
)->mac
,
760 ((const struct ofp_action_dl_addr
*) a
)->dl_addr
, ETH_ADDR_LEN
);
763 case OFPUTIL_OFPAT11_SET_DL_DST
:
764 memcpy(ofpact_put_SET_ETH_DST(out
)->mac
,
765 ((const struct ofp_action_dl_addr
*) a
)->dl_addr
, ETH_ADDR_LEN
);
768 case OFPUTIL_OFPAT11_DEC_NW_TTL
:
769 dec_ttl_from_openflow(out
, code
);
772 case OFPUTIL_OFPAT11_SET_NW_SRC
:
773 ofpact_put_SET_IPV4_SRC(out
)->ipv4
= a
->nw_addr
.nw_addr
;
776 case OFPUTIL_OFPAT11_SET_NW_DST
:
777 ofpact_put_SET_IPV4_DST(out
)->ipv4
= a
->nw_addr
.nw_addr
;
780 case OFPUTIL_OFPAT11_SET_NW_TOS
:
781 if (a
->nw_tos
.nw_tos
& ~IP_DSCP_MASK
) {
782 return OFPERR_OFPBAC_BAD_ARGUMENT
;
784 ofpact_put_SET_IPV4_DSCP(out
)->dscp
= a
->nw_tos
.nw_tos
;
787 case OFPUTIL_OFPAT11_SET_TP_SRC
:
788 ofpact_put_SET_L4_SRC_PORT(out
)->port
= ntohs(a
->tp_port
.tp_port
);
791 case OFPUTIL_OFPAT11_SET_TP_DST
:
792 ofpact_put_SET_L4_DST_PORT(out
)->port
= ntohs(a
->tp_port
.tp_port
);
795 case OFPUTIL_OFPAT12_SET_FIELD
:
796 return nxm_reg_load_from_openflow12_set_field(
797 (const struct ofp12_action_set_field
*)a
, out
);
799 case OFPUTIL_OFPAT11_SET_MPLS_TTL
: {
800 struct ofp11_action_mpls_ttl
*oamt
= (struct ofp11_action_mpls_ttl
*)a
;
801 ofpact_put_SET_MPLS_TTL(out
)->ttl
= oamt
->mpls_ttl
;
805 case OFPUTIL_OFPAT11_DEC_MPLS_TTL
:
806 ofpact_put_DEC_MPLS_TTL(out
);
809 case OFPUTIL_OFPAT11_PUSH_MPLS
: {
810 struct ofp11_action_push
*oap
= (struct ofp11_action_push
*)a
;
811 if (!eth_type_mpls(oap
->ethertype
)) {
812 return OFPERR_OFPBAC_BAD_ARGUMENT
;
814 ofpact_put_PUSH_MPLS(out
)->ethertype
= oap
->ethertype
;
818 case OFPUTIL_OFPAT11_POP_MPLS
: {
819 struct ofp11_action_pop_mpls
*oapm
= (struct ofp11_action_pop_mpls
*)a
;
820 if (eth_type_mpls(oapm
->ethertype
)) {
821 return OFPERR_OFPBAC_BAD_ARGUMENT
;
823 ofpact_put_POP_MPLS(out
)->ethertype
= oapm
->ethertype
;
827 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
828 #include "ofp-util.def"
829 return ofpact_from_nxast(a
, code
, out
);
836 ofpacts_from_openflow11(const union ofp_action
*in
, size_t n_in
,
839 return ofpacts_from_openflow(in
, n_in
, out
, ofpact_from_openflow11
);
842 /* OpenFlow 1.1 instructions. */
844 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME) \
845 static inline const struct STRUCT * \
846 instruction_get_##ENUM(const struct ofp11_instruction *inst)\
848 ovs_assert(inst->type == htons(ENUM)); \
849 return (struct STRUCT *)inst; \
853 instruction_init_##ENUM(struct STRUCT *s) \
855 memset(s, 0, sizeof *s); \
856 s->type = htons(ENUM); \
857 s->len = htons(sizeof *s); \
860 static inline struct STRUCT * \
861 instruction_put_##ENUM(struct ofpbuf *buf) \
863 struct STRUCT *s = ofpbuf_put_uninit(buf, sizeof *s); \
864 instruction_init_##ENUM(s); \
870 struct instruction_type_info
{
871 enum ovs_instruction_type type
;
875 static const struct instruction_type_info inst_info
[] = {
876 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME) {OVSINST_##ENUM, NAME},
882 ofpact_instruction_name_from_type(enum ovs_instruction_type type
)
884 return inst_info
[type
].name
;
888 ofpact_instruction_type_from_name(const char *name
)
890 const struct instruction_type_info
*p
;
891 for (p
= inst_info
; p
< &inst_info
[ARRAY_SIZE(inst_info
)]; p
++) {
892 if (!strcasecmp(name
, p
->name
)) {
899 static inline struct ofp11_instruction
*
900 instruction_next(const struct ofp11_instruction
*inst
)
902 return ((struct ofp11_instruction
*) (void *)
903 ((uint8_t *) inst
+ ntohs(inst
->len
)));
907 instruction_is_valid(const struct ofp11_instruction
*inst
,
908 size_t n_instructions
)
910 uint16_t len
= ntohs(inst
->len
);
911 return (!(len
% OFP11_INSTRUCTION_ALIGN
)
912 && len
>= sizeof *inst
913 && len
/ sizeof *inst
<= n_instructions
);
916 /* This macro is careful to check for instructions with bad lengths. */
917 #define INSTRUCTION_FOR_EACH(ITER, LEFT, INSTRUCTIONS, N_INSTRUCTIONS) \
918 for ((ITER) = (INSTRUCTIONS), (LEFT) = (N_INSTRUCTIONS); \
919 (LEFT) > 0 && instruction_is_valid(ITER, LEFT); \
920 ((LEFT) -= (ntohs((ITER)->len) \
921 / sizeof(struct ofp11_instruction)), \
922 (ITER) = instruction_next(ITER)))
925 decode_openflow11_instruction(const struct ofp11_instruction
*inst
,
926 enum ovs_instruction_type
*type
)
928 uint16_t len
= ntohs(inst
->len
);
930 switch (inst
->type
) {
931 case CONSTANT_HTONS(OFPIT11_EXPERIMENTER
):
932 return OFPERR_OFPBIC_BAD_EXPERIMENTER
;
934 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME) \
935 case CONSTANT_HTONS(ENUM): \
937 ? len >= sizeof(struct STRUCT) \
938 : len == sizeof(struct STRUCT)) { \
939 *type = OVSINST_##ENUM; \
942 return OFPERR_OFPBIC_BAD_LEN; \
948 return OFPERR_OFPBIC_UNKNOWN_INST
;
953 decode_openflow11_instructions(const struct ofp11_instruction insts
[],
955 const struct ofp11_instruction
*out
[])
957 const struct ofp11_instruction
*inst
;
960 memset(out
, 0, N_OVS_INSTRUCTIONS
* sizeof *out
);
961 INSTRUCTION_FOR_EACH (inst
, left
, insts
, n_insts
) {
962 enum ovs_instruction_type type
;
965 error
= decode_openflow11_instruction(inst
, &type
);
971 return OFPERR_OFPBAC_UNSUPPORTED_ORDER
; /* No specific code for
972 * a duplicate instruction
979 VLOG_WARN_RL(&rl
, "bad instruction format at offset %zu",
980 (n_insts
- left
) * sizeof *inst
);
981 return OFPERR_OFPBIC_BAD_LEN
;
987 get_actions_from_instruction(const struct ofp11_instruction
*inst
,
988 const union ofp_action
**actions
,
991 *actions
= (const union ofp_action
*) (inst
+ 1);
992 *n_actions
= (ntohs(inst
->len
) - sizeof *inst
) / OFP11_INSTRUCTION_ALIGN
;
995 /* Attempts to convert 'actions_len' bytes of OpenFlow 1.1 actions from the
996 * front of 'openflow' into ofpacts. On success, replaces any existing content
997 * in 'ofpacts' by the converted ofpacts; on failure, clears 'ofpacts'.
998 * Returns 0 if successful, otherwise an OpenFlow error.
1000 * In most places in OpenFlow 1.1 and 1.2, actions appear encapsulated in
1001 * instructions, so you should call ofpacts_pull_openflow11_instructions()
1002 * instead of this function.
1004 * The parsed actions are valid generically, but they may not be valid in a
1005 * specific context. For example, port numbers up to OFPP_MAX are valid
1006 * generically, but specific datapaths may only support port numbers in a
1007 * smaller range. Use ofpacts_check() to additional check whether actions are
1008 * valid in a specific context. */
1010 ofpacts_pull_openflow11_actions(struct ofpbuf
*openflow
,
1011 unsigned int actions_len
,
1012 struct ofpbuf
*ofpacts
)
1014 return ofpacts_pull_actions(openflow
, actions_len
, ofpacts
,
1015 ofpacts_from_openflow11
);
1019 ofpacts_pull_openflow11_instructions(struct ofpbuf
*openflow
,
1020 unsigned int instructions_len
,
1021 struct ofpbuf
*ofpacts
)
1023 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
1024 const struct ofp11_instruction
*instructions
;
1025 const struct ofp11_instruction
*insts
[N_OVS_INSTRUCTIONS
];
1028 ofpbuf_clear(ofpacts
);
1030 if (instructions_len
% OFP11_INSTRUCTION_ALIGN
!= 0) {
1031 VLOG_WARN_RL(&rl
, "OpenFlow message instructions length %u is not a "
1033 instructions_len
, OFP11_INSTRUCTION_ALIGN
);
1034 error
= OFPERR_OFPBIC_BAD_LEN
;
1038 instructions
= ofpbuf_try_pull(openflow
, instructions_len
);
1039 if (instructions
== NULL
) {
1040 VLOG_WARN_RL(&rl
, "OpenFlow message instructions length %u exceeds "
1041 "remaining message length (%zu)",
1042 instructions_len
, openflow
->size
);
1043 error
= OFPERR_OFPBIC_BAD_LEN
;
1047 error
= decode_openflow11_instructions(
1048 instructions
, instructions_len
/ OFP11_INSTRUCTION_ALIGN
,
1054 if (insts
[OVSINST_OFPIT11_APPLY_ACTIONS
]) {
1055 const union ofp_action
*actions
;
1058 get_actions_from_instruction(insts
[OVSINST_OFPIT11_APPLY_ACTIONS
],
1059 &actions
, &n_actions
);
1060 error
= ofpacts_from_openflow11(actions
, n_actions
, ofpacts
);
1065 if (insts
[OVSINST_OFPIT11_CLEAR_ACTIONS
]) {
1066 instruction_get_OFPIT11_CLEAR_ACTIONS(
1067 insts
[OVSINST_OFPIT11_CLEAR_ACTIONS
]);
1068 ofpact_put_CLEAR_ACTIONS(ofpacts
);
1070 /* XXX Write-Actions */
1071 if (insts
[OVSINST_OFPIT11_WRITE_METADATA
]) {
1072 const struct ofp11_instruction_write_metadata
*oiwm
;
1073 struct ofpact_metadata
*om
;
1075 oiwm
= (const struct ofp11_instruction_write_metadata
*)
1076 insts
[OVSINST_OFPIT11_WRITE_METADATA
];
1078 om
= ofpact_put_WRITE_METADATA(ofpacts
);
1079 om
->metadata
= oiwm
->metadata
;
1080 om
->mask
= oiwm
->metadata_mask
;
1082 if (insts
[OVSINST_OFPIT11_GOTO_TABLE
]) {
1083 const struct ofp11_instruction_goto_table
*oigt
;
1084 struct ofpact_goto_table
*ogt
;
1086 oigt
= instruction_get_OFPIT11_GOTO_TABLE(
1087 insts
[OVSINST_OFPIT11_GOTO_TABLE
]);
1088 ogt
= ofpact_put_GOTO_TABLE(ofpacts
);
1089 ogt
->table_id
= oigt
->table_id
;
1092 if (insts
[OVSINST_OFPIT11_WRITE_ACTIONS
]) {
1093 error
= OFPERR_OFPBIC_UNSUP_INST
;
1097 error
= ofpacts_verify(ofpacts
->data
, ofpacts
->size
);
1100 ofpbuf_clear(ofpacts
);
1106 ofpact_check__(const struct ofpact
*a
, const struct flow
*flow
, int max_ports
,
1109 const struct ofpact_enqueue
*enqueue
;
1113 return ofputil_check_output_port(ofpact_get_OUTPUT(a
)->port
,
1116 case OFPACT_CONTROLLER
:
1119 case OFPACT_ENQUEUE
:
1120 enqueue
= ofpact_get_ENQUEUE(a
);
1121 if (enqueue
->port
>= max_ports
&& enqueue
->port
!= OFPP_IN_PORT
1122 && enqueue
->port
!= OFPP_LOCAL
) {
1123 return OFPERR_OFPBAC_BAD_OUT_PORT
;
1127 case OFPACT_OUTPUT_REG
:
1128 return mf_check_src(&ofpact_get_OUTPUT_REG(a
)->src
, flow
);
1131 return bundle_check(ofpact_get_BUNDLE(a
), max_ports
, flow
);
1133 case OFPACT_SET_VLAN_VID
:
1134 case OFPACT_SET_VLAN_PCP
:
1135 case OFPACT_STRIP_VLAN
:
1136 case OFPACT_PUSH_VLAN
:
1137 case OFPACT_SET_ETH_SRC
:
1138 case OFPACT_SET_ETH_DST
:
1139 case OFPACT_SET_IPV4_SRC
:
1140 case OFPACT_SET_IPV4_DST
:
1141 case OFPACT_SET_IPV4_DSCP
:
1142 case OFPACT_SET_L4_SRC_PORT
:
1143 case OFPACT_SET_L4_DST_PORT
:
1146 case OFPACT_REG_MOVE
:
1147 return nxm_reg_move_check(ofpact_get_REG_MOVE(a
), flow
);
1149 case OFPACT_REG_LOAD
:
1150 if (*dl_type
!= flow
->dl_type
) {
1151 struct flow updated_flow
= *flow
;
1152 updated_flow
.dl_type
= *dl_type
;
1153 return nxm_reg_load_check(ofpact_get_REG_LOAD(a
), &updated_flow
);
1155 return nxm_reg_load_check(ofpact_get_REG_LOAD(a
), flow
);
1158 case OFPACT_DEC_TTL
:
1159 case OFPACT_SET_MPLS_TTL
:
1160 case OFPACT_DEC_MPLS_TTL
:
1161 case OFPACT_SET_TUNNEL
:
1162 case OFPACT_SET_QUEUE
:
1163 case OFPACT_POP_QUEUE
:
1164 case OFPACT_FIN_TIMEOUT
:
1165 case OFPACT_RESUBMIT
:
1169 return learn_check(ofpact_get_LEARN(a
), flow
);
1171 case OFPACT_MULTIPATH
:
1172 return multipath_check(ofpact_get_MULTIPATH(a
), flow
);
1178 case OFPACT_PUSH_MPLS
:
1179 *dl_type
= ofpact_get_PUSH_MPLS(a
)->ethertype
;
1182 case OFPACT_POP_MPLS
:
1183 *dl_type
= ofpact_get_POP_MPLS(a
)->ethertype
;
1186 case OFPACT_CLEAR_ACTIONS
:
1187 case OFPACT_WRITE_METADATA
:
1188 case OFPACT_GOTO_TABLE
:
1196 /* Checks that the 'ofpacts_len' bytes of actions in 'ofpacts' are
1197 * appropriate for a packet with the prerequisites satisfied by 'flow' in a
1198 * switch with no more than 'max_ports' ports. */
1200 ofpacts_check(const struct ofpact ofpacts
[], size_t ofpacts_len
,
1201 const struct flow
*flow
, int max_ports
)
1203 const struct ofpact
*a
;
1204 ovs_be16 dl_type
= flow
->dl_type
;
1206 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
1207 enum ofperr error
= ofpact_check__(a
, flow
, max_ports
, &dl_type
);
1216 /* Verifies that the 'ofpacts_len' bytes of actions in 'ofpacts' are
1217 * in the appropriate order as defined by the OpenFlow spec. */
1219 ofpacts_verify(const struct ofpact ofpacts
[], size_t ofpacts_len
)
1221 const struct ofpact
*a
;
1222 enum ovs_instruction_type inst
;
1224 inst
= OVSINST_OFPIT11_APPLY_ACTIONS
;
1225 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
1226 enum ovs_instruction_type next
;
1228 if (a
->type
== OFPACT_CLEAR_ACTIONS
) {
1229 next
= OVSINST_OFPIT11_CLEAR_ACTIONS
;
1230 } else if (a
->type
== OFPACT_WRITE_METADATA
) {
1231 next
= OVSINST_OFPIT11_WRITE_METADATA
;
1232 } else if (a
->type
== OFPACT_GOTO_TABLE
) {
1233 next
= OVSINST_OFPIT11_GOTO_TABLE
;
1235 next
= OVSINST_OFPIT11_APPLY_ACTIONS
;
1238 if (inst
!= OVSINST_OFPIT11_APPLY_ACTIONS
&& next
<= inst
) {
1239 const char *name
= ofpact_instruction_name_from_type(inst
);
1240 const char *next_name
= ofpact_instruction_name_from_type(next
);
1243 VLOG_WARN("duplicate %s instruction not allowed, for OpenFlow "
1244 "1.1+ compatibility", name
);
1246 VLOG_WARN("invalid instruction ordering: %s must appear "
1247 "before %s, for OpenFlow 1.1+ compatibility",
1250 return OFPERR_OFPBAC_UNSUPPORTED_ORDER
;
1259 /* Converting ofpacts to Nicira OpenFlow extensions. */
1262 ofpact_output_reg_to_nxast(const struct ofpact_output_reg
*output_reg
,
1265 struct nx_action_output_reg
*naor
= ofputil_put_NXAST_OUTPUT_REG(out
);
1267 naor
->ofs_nbits
= nxm_encode_ofs_nbits(output_reg
->src
.ofs
,
1268 output_reg
->src
.n_bits
);
1269 naor
->src
= htonl(output_reg
->src
.field
->nxm_header
);
1270 naor
->max_len
= htons(output_reg
->max_len
);
1274 ofpact_resubmit_to_nxast(const struct ofpact_resubmit
*resubmit
,
1277 struct nx_action_resubmit
*nar
;
1279 if (resubmit
->table_id
== 0xff
1280 && resubmit
->ofpact
.compat
!= OFPUTIL_NXAST_RESUBMIT_TABLE
) {
1281 nar
= ofputil_put_NXAST_RESUBMIT(out
);
1283 nar
= ofputil_put_NXAST_RESUBMIT_TABLE(out
);
1284 nar
->table
= resubmit
->table_id
;
1286 nar
->in_port
= htons(resubmit
->in_port
);
1290 ofpact_set_tunnel_to_nxast(const struct ofpact_tunnel
*tunnel
,
1293 uint64_t tun_id
= tunnel
->tun_id
;
1295 if (tun_id
<= UINT32_MAX
1296 && tunnel
->ofpact
.compat
!= OFPUTIL_NXAST_SET_TUNNEL64
) {
1297 ofputil_put_NXAST_SET_TUNNEL(out
)->tun_id
= htonl(tun_id
);
1299 ofputil_put_NXAST_SET_TUNNEL64(out
)->tun_id
= htonll(tun_id
);
1304 ofpact_write_metadata_to_nxast(const struct ofpact_metadata
*om
,
1307 struct nx_action_write_metadata
*nawm
;
1309 nawm
= ofputil_put_NXAST_WRITE_METADATA(out
);
1310 nawm
->metadata
= om
->metadata
;
1311 nawm
->mask
= om
->mask
;
1315 ofpact_note_to_nxast(const struct ofpact_note
*note
, struct ofpbuf
*out
)
1317 size_t start_ofs
= out
->size
;
1318 struct nx_action_note
*nan
;
1319 unsigned int remainder
;
1322 nan
= ofputil_put_NXAST_NOTE(out
);
1323 out
->size
-= sizeof nan
->note
;
1325 ofpbuf_put(out
, note
->data
, note
->length
);
1327 len
= out
->size
- start_ofs
;
1328 remainder
= len
% OFP_ACTION_ALIGN
;
1330 ofpbuf_put_zeros(out
, OFP_ACTION_ALIGN
- remainder
);
1332 nan
= (struct nx_action_note
*)((char *)out
->data
+ start_ofs
);
1333 nan
->len
= htons(out
->size
- start_ofs
);
1337 ofpact_controller_to_nxast(const struct ofpact_controller
*oc
,
1340 struct nx_action_controller
*nac
;
1342 nac
= ofputil_put_NXAST_CONTROLLER(out
);
1343 nac
->max_len
= htons(oc
->max_len
);
1344 nac
->controller_id
= htons(oc
->controller_id
);
1345 nac
->reason
= oc
->reason
;
1349 ofpact_dec_ttl_to_nxast(const struct ofpact_cnt_ids
*oc_ids
,
1352 if (oc_ids
->ofpact
.compat
== OFPUTIL_NXAST_DEC_TTL
) {
1353 ofputil_put_NXAST_DEC_TTL(out
);
1355 struct nx_action_cnt_ids
*nac_ids
=
1356 ofputil_put_NXAST_DEC_TTL_CNT_IDS(out
);
1357 int ids_len
= ROUND_UP(2 * oc_ids
->n_controllers
, OFP_ACTION_ALIGN
);
1361 nac_ids
->len
= htons(ntohs(nac_ids
->len
) + ids_len
);
1362 nac_ids
->n_controllers
= htons(oc_ids
->n_controllers
);
1364 ids
= ofpbuf_put_zeros(out
, ids_len
);
1365 for (i
= 0; i
< oc_ids
->n_controllers
; i
++) {
1366 ids
[i
] = htons(oc_ids
->cnt_ids
[i
]);
1372 ofpact_fin_timeout_to_nxast(const struct ofpact_fin_timeout
*fin_timeout
,
1375 struct nx_action_fin_timeout
*naft
= ofputil_put_NXAST_FIN_TIMEOUT(out
);
1376 naft
->fin_idle_timeout
= htons(fin_timeout
->fin_idle_timeout
);
1377 naft
->fin_hard_timeout
= htons(fin_timeout
->fin_hard_timeout
);
1381 ofpact_to_nxast(const struct ofpact
*a
, struct ofpbuf
*out
)
1384 case OFPACT_CONTROLLER
:
1385 ofpact_controller_to_nxast(ofpact_get_CONTROLLER(a
), out
);
1388 case OFPACT_OUTPUT_REG
:
1389 ofpact_output_reg_to_nxast(ofpact_get_OUTPUT_REG(a
), out
);
1393 bundle_to_nxast(ofpact_get_BUNDLE(a
), out
);
1396 case OFPACT_REG_MOVE
:
1397 nxm_reg_move_to_nxast(ofpact_get_REG_MOVE(a
), out
);
1400 case OFPACT_REG_LOAD
:
1401 nxm_reg_load_to_nxast(ofpact_get_REG_LOAD(a
), out
);
1404 case OFPACT_DEC_TTL
:
1405 ofpact_dec_ttl_to_nxast(ofpact_get_DEC_TTL(a
), out
);
1408 case OFPACT_SET_MPLS_TTL
:
1409 ofputil_put_NXAST_SET_MPLS_TTL(out
)->ttl
1410 = ofpact_get_SET_MPLS_TTL(a
)->ttl
;
1413 case OFPACT_DEC_MPLS_TTL
:
1414 ofputil_put_NXAST_DEC_MPLS_TTL(out
);
1417 case OFPACT_SET_TUNNEL
:
1418 ofpact_set_tunnel_to_nxast(ofpact_get_SET_TUNNEL(a
), out
);
1421 case OFPACT_WRITE_METADATA
:
1422 ofpact_write_metadata_to_nxast(ofpact_get_WRITE_METADATA(a
), out
);
1425 case OFPACT_SET_QUEUE
:
1426 ofputil_put_NXAST_SET_QUEUE(out
)->queue_id
1427 = htonl(ofpact_get_SET_QUEUE(a
)->queue_id
);
1430 case OFPACT_POP_QUEUE
:
1431 ofputil_put_NXAST_POP_QUEUE(out
);
1434 case OFPACT_FIN_TIMEOUT
:
1435 ofpact_fin_timeout_to_nxast(ofpact_get_FIN_TIMEOUT(a
), out
);
1438 case OFPACT_RESUBMIT
:
1439 ofpact_resubmit_to_nxast(ofpact_get_RESUBMIT(a
), out
);
1443 learn_to_nxast(ofpact_get_LEARN(a
), out
);
1446 case OFPACT_MULTIPATH
:
1447 multipath_to_nxast(ofpact_get_MULTIPATH(a
), out
);
1451 ofpact_note_to_nxast(ofpact_get_NOTE(a
), out
);
1455 ofputil_put_NXAST_EXIT(out
);
1458 case OFPACT_PUSH_MPLS
:
1459 ofputil_put_NXAST_PUSH_MPLS(out
)->ethertype
=
1460 ofpact_get_PUSH_MPLS(a
)->ethertype
;
1463 case OFPACT_POP_MPLS
:
1464 ofputil_put_NXAST_POP_MPLS(out
)->ethertype
=
1465 ofpact_get_POP_MPLS(a
)->ethertype
;
1469 case OFPACT_ENQUEUE
:
1470 case OFPACT_SET_VLAN_VID
:
1471 case OFPACT_SET_VLAN_PCP
:
1472 case OFPACT_STRIP_VLAN
:
1473 case OFPACT_PUSH_VLAN
:
1474 case OFPACT_SET_ETH_SRC
:
1475 case OFPACT_SET_ETH_DST
:
1476 case OFPACT_SET_IPV4_SRC
:
1477 case OFPACT_SET_IPV4_DST
:
1478 case OFPACT_SET_IPV4_DSCP
:
1479 case OFPACT_SET_L4_SRC_PORT
:
1480 case OFPACT_SET_L4_DST_PORT
:
1481 case OFPACT_CLEAR_ACTIONS
:
1482 case OFPACT_GOTO_TABLE
:
1487 /* Converting ofpacts to OpenFlow 1.0. */
1490 ofpact_output_to_openflow10(const struct ofpact_output
*output
,
1493 struct ofp10_action_output
*oao
;
1495 oao
= ofputil_put_OFPAT10_OUTPUT(out
);
1496 oao
->port
= htons(output
->port
);
1497 oao
->max_len
= htons(output
->max_len
);
1501 ofpact_enqueue_to_openflow10(const struct ofpact_enqueue
*enqueue
,
1504 struct ofp10_action_enqueue
*oae
;
1506 oae
= ofputil_put_OFPAT10_ENQUEUE(out
);
1507 oae
->port
= htons(enqueue
->port
);
1508 oae
->queue_id
= htonl(enqueue
->queue
);
1512 ofpact_to_openflow10(const struct ofpact
*a
, struct ofpbuf
*out
)
1516 ofpact_output_to_openflow10(ofpact_get_OUTPUT(a
), out
);
1519 case OFPACT_ENQUEUE
:
1520 ofpact_enqueue_to_openflow10(ofpact_get_ENQUEUE(a
), out
);
1523 case OFPACT_SET_VLAN_VID
:
1524 ofputil_put_OFPAT10_SET_VLAN_VID(out
)->vlan_vid
1525 = htons(ofpact_get_SET_VLAN_VID(a
)->vlan_vid
);
1528 case OFPACT_SET_VLAN_PCP
:
1529 ofputil_put_OFPAT10_SET_VLAN_PCP(out
)->vlan_pcp
1530 = ofpact_get_SET_VLAN_PCP(a
)->vlan_pcp
;
1533 case OFPACT_STRIP_VLAN
:
1534 ofputil_put_OFPAT10_STRIP_VLAN(out
);
1537 case OFPACT_SET_ETH_SRC
:
1538 memcpy(ofputil_put_OFPAT10_SET_DL_SRC(out
)->dl_addr
,
1539 ofpact_get_SET_ETH_SRC(a
)->mac
, ETH_ADDR_LEN
);
1542 case OFPACT_SET_ETH_DST
:
1543 memcpy(ofputil_put_OFPAT10_SET_DL_DST(out
)->dl_addr
,
1544 ofpact_get_SET_ETH_DST(a
)->mac
, ETH_ADDR_LEN
);
1547 case OFPACT_SET_IPV4_SRC
:
1548 ofputil_put_OFPAT10_SET_NW_SRC(out
)->nw_addr
1549 = ofpact_get_SET_IPV4_SRC(a
)->ipv4
;
1552 case OFPACT_SET_IPV4_DST
:
1553 ofputil_put_OFPAT10_SET_NW_DST(out
)->nw_addr
1554 = ofpact_get_SET_IPV4_DST(a
)->ipv4
;
1557 case OFPACT_SET_IPV4_DSCP
:
1558 ofputil_put_OFPAT10_SET_NW_TOS(out
)->nw_tos
1559 = ofpact_get_SET_IPV4_DSCP(a
)->dscp
;
1562 case OFPACT_SET_L4_SRC_PORT
:
1563 ofputil_put_OFPAT10_SET_TP_SRC(out
)->tp_port
1564 = htons(ofpact_get_SET_L4_SRC_PORT(a
)->port
);
1567 case OFPACT_SET_L4_DST_PORT
:
1568 ofputil_put_OFPAT10_SET_TP_DST(out
)->tp_port
1569 = htons(ofpact_get_SET_L4_DST_PORT(a
)->port
);
1572 case OFPACT_PUSH_VLAN
:
1573 case OFPACT_CLEAR_ACTIONS
:
1574 case OFPACT_GOTO_TABLE
:
1578 case OFPACT_CONTROLLER
:
1579 case OFPACT_OUTPUT_REG
:
1581 case OFPACT_REG_MOVE
:
1582 case OFPACT_REG_LOAD
:
1583 case OFPACT_DEC_TTL
:
1584 case OFPACT_SET_MPLS_TTL
:
1585 case OFPACT_DEC_MPLS_TTL
:
1586 case OFPACT_SET_TUNNEL
:
1587 case OFPACT_WRITE_METADATA
:
1588 case OFPACT_SET_QUEUE
:
1589 case OFPACT_POP_QUEUE
:
1590 case OFPACT_FIN_TIMEOUT
:
1591 case OFPACT_RESUBMIT
:
1593 case OFPACT_MULTIPATH
:
1596 case OFPACT_PUSH_MPLS
:
1597 case OFPACT_POP_MPLS
:
1598 ofpact_to_nxast(a
, out
);
1603 /* Converts the 'ofpacts_len' bytes of ofpacts in 'ofpacts' into OpenFlow 1.0
1604 * actions in 'openflow', appending the actions to any existing data in
1607 ofpacts_put_openflow10(const struct ofpact ofpacts
[], size_t ofpacts_len
,
1608 struct ofpbuf
*openflow
)
1610 const struct ofpact
*a
;
1612 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
1613 ofpact_to_openflow10(a
, openflow
);
1617 /* Converting ofpacts to OpenFlow 1.1. */
1620 ofpact_output_to_openflow11(const struct ofpact_output
*output
,
1623 struct ofp11_action_output
*oao
;
1625 oao
= ofputil_put_OFPAT11_OUTPUT(out
);
1626 oao
->port
= ofputil_port_to_ofp11(output
->port
);
1627 oao
->max_len
= htons(output
->max_len
);
1631 ofpact_dec_ttl_to_openflow11(const struct ofpact_cnt_ids
*dec_ttl
,
1634 if (dec_ttl
->n_controllers
== 1 && dec_ttl
->cnt_ids
[0] == 0
1635 && (!dec_ttl
->ofpact
.compat
||
1636 dec_ttl
->ofpact
.compat
== OFPUTIL_OFPAT11_DEC_NW_TTL
)) {
1637 ofputil_put_OFPAT11_DEC_NW_TTL(out
);
1639 ofpact_dec_ttl_to_nxast(dec_ttl
, out
);
1644 ofpact_to_openflow11(const struct ofpact
*a
, struct ofpbuf
*out
)
1648 return ofpact_output_to_openflow11(ofpact_get_OUTPUT(a
), out
);
1650 case OFPACT_ENQUEUE
:
1654 case OFPACT_SET_VLAN_VID
:
1655 ofputil_put_OFPAT11_SET_VLAN_VID(out
)->vlan_vid
1656 = htons(ofpact_get_SET_VLAN_VID(a
)->vlan_vid
);
1659 case OFPACT_SET_VLAN_PCP
:
1660 ofputil_put_OFPAT11_SET_VLAN_PCP(out
)->vlan_pcp
1661 = ofpact_get_SET_VLAN_PCP(a
)->vlan_pcp
;
1664 case OFPACT_STRIP_VLAN
:
1665 ofputil_put_OFPAT11_POP_VLAN(out
);
1668 case OFPACT_PUSH_VLAN
:
1669 /* XXX ETH_TYPE_VLAN_8021AD case */
1670 ofputil_put_OFPAT11_PUSH_VLAN(out
)->ethertype
=
1671 htons(ETH_TYPE_VLAN_8021Q
);
1674 case OFPACT_SET_QUEUE
:
1675 ofputil_put_OFPAT11_SET_QUEUE(out
)->queue_id
1676 = htonl(ofpact_get_SET_QUEUE(a
)->queue_id
);
1679 case OFPACT_SET_ETH_SRC
:
1680 memcpy(ofputil_put_OFPAT11_SET_DL_SRC(out
)->dl_addr
,
1681 ofpact_get_SET_ETH_SRC(a
)->mac
, ETH_ADDR_LEN
);
1684 case OFPACT_SET_ETH_DST
:
1685 memcpy(ofputil_put_OFPAT11_SET_DL_DST(out
)->dl_addr
,
1686 ofpact_get_SET_ETH_DST(a
)->mac
, ETH_ADDR_LEN
);
1689 case OFPACT_SET_IPV4_SRC
:
1690 ofputil_put_OFPAT11_SET_NW_SRC(out
)->nw_addr
1691 = ofpact_get_SET_IPV4_SRC(a
)->ipv4
;
1694 case OFPACT_SET_IPV4_DST
:
1695 ofputil_put_OFPAT11_SET_NW_DST(out
)->nw_addr
1696 = ofpact_get_SET_IPV4_DST(a
)->ipv4
;
1699 case OFPACT_SET_IPV4_DSCP
:
1700 ofputil_put_OFPAT11_SET_NW_TOS(out
)->nw_tos
1701 = ofpact_get_SET_IPV4_DSCP(a
)->dscp
;
1704 case OFPACT_SET_L4_SRC_PORT
:
1705 ofputil_put_OFPAT11_SET_TP_SRC(out
)->tp_port
1706 = htons(ofpact_get_SET_L4_SRC_PORT(a
)->port
);
1709 case OFPACT_SET_L4_DST_PORT
:
1710 ofputil_put_OFPAT11_SET_TP_DST(out
)->tp_port
1711 = htons(ofpact_get_SET_L4_DST_PORT(a
)->port
);
1714 case OFPACT_DEC_TTL
:
1715 ofpact_dec_ttl_to_openflow11(ofpact_get_DEC_TTL(a
), out
);
1718 case OFPACT_SET_MPLS_TTL
:
1719 ofputil_put_OFPAT11_SET_MPLS_TTL(out
)->mpls_ttl
1720 = ofpact_get_SET_MPLS_TTL(a
)->ttl
;
1723 case OFPACT_DEC_MPLS_TTL
:
1724 ofputil_put_OFPAT11_DEC_MPLS_TTL(out
);
1727 case OFPACT_WRITE_METADATA
:
1728 /* OpenFlow 1.1 uses OFPIT_WRITE_METADATA to express this action. */
1731 case OFPACT_PUSH_MPLS
:
1732 ofputil_put_OFPAT11_PUSH_MPLS(out
)->ethertype
=
1733 ofpact_get_PUSH_MPLS(a
)->ethertype
;
1736 case OFPACT_POP_MPLS
:
1737 ofputil_put_OFPAT11_POP_MPLS(out
)->ethertype
=
1738 ofpact_get_POP_MPLS(a
)->ethertype
;
1742 case OFPACT_CLEAR_ACTIONS
:
1743 case OFPACT_GOTO_TABLE
:
1746 case OFPACT_CONTROLLER
:
1747 case OFPACT_OUTPUT_REG
:
1749 case OFPACT_REG_MOVE
:
1750 case OFPACT_REG_LOAD
:
1751 case OFPACT_SET_TUNNEL
:
1752 case OFPACT_POP_QUEUE
:
1753 case OFPACT_FIN_TIMEOUT
:
1754 case OFPACT_RESUBMIT
:
1756 case OFPACT_MULTIPATH
:
1759 ofpact_to_nxast(a
, out
);
1764 /* Converts the ofpacts in 'ofpacts' (terminated by OFPACT_END) into OpenFlow
1765 * 1.1 actions in 'openflow', appending the actions to any existing data in
1768 ofpacts_put_openflow11_actions(const struct ofpact ofpacts
[],
1769 size_t ofpacts_len
, struct ofpbuf
*openflow
)
1771 const struct ofpact
*a
;
1772 size_t start_size
= openflow
->size
;
1774 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
1775 ofpact_to_openflow11(a
, openflow
);
1778 return openflow
->size
- start_size
;
1782 ofpacts_update_instruction_actions(struct ofpbuf
*openflow
, size_t ofs
)
1784 struct ofp11_instruction_actions
*oia
;
1786 /* Update the instruction's length (or, if it's empty, delete it). */
1787 oia
= ofpbuf_at_assert(openflow
, ofs
, sizeof *oia
);
1788 if (openflow
->size
> ofs
+ sizeof *oia
) {
1789 oia
->len
= htons(openflow
->size
- ofs
);
1791 openflow
->size
= ofs
;
1796 ofpacts_put_openflow11_instructions(const struct ofpact ofpacts
[],
1798 struct ofpbuf
*openflow
)
1800 const struct ofpact
*a
;
1802 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
1803 /* XXX Write-Actions */
1805 if (a
->type
== OFPACT_CLEAR_ACTIONS
) {
1806 instruction_put_OFPIT11_CLEAR_ACTIONS(openflow
);
1807 } else if (a
->type
== OFPACT_GOTO_TABLE
) {
1808 struct ofp11_instruction_goto_table
*oigt
;
1810 oigt
= instruction_put_OFPIT11_GOTO_TABLE(openflow
);
1811 oigt
->table_id
= ofpact_get_GOTO_TABLE(a
)->table_id
;
1812 memset(oigt
->pad
, 0, sizeof oigt
->pad
);
1813 } else if (a
->type
== OFPACT_WRITE_METADATA
) {
1814 const struct ofpact_metadata
*om
;
1815 struct ofp11_instruction_write_metadata
*oiwm
;
1817 om
= ofpact_get_WRITE_METADATA(a
);
1818 oiwm
= instruction_put_OFPIT11_WRITE_METADATA(openflow
);
1819 oiwm
->metadata
= om
->metadata
;
1820 oiwm
->metadata_mask
= om
->mask
;
1821 } else if (!ofpact_is_instruction(a
)) {
1823 const size_t ofs
= openflow
->size
;
1824 const size_t ofpacts_len_left
=
1825 (uint8_t*)ofpact_end(ofpacts
, ofpacts_len
) - (uint8_t*)a
;
1826 const struct ofpact
*action
;
1827 const struct ofpact
*processed
= a
;
1829 instruction_put_OFPIT11_APPLY_ACTIONS(openflow
);
1830 OFPACT_FOR_EACH(action
, a
, ofpacts_len_left
) {
1831 if (ofpact_is_instruction(action
)) {
1834 ofpact_to_openflow11(action
, openflow
);
1837 ofpacts_update_instruction_actions(openflow
, ofs
);
1843 /* Returns true if 'action' outputs to 'port', false otherwise. */
1845 ofpact_outputs_to_port(const struct ofpact
*ofpact
, uint16_t port
)
1847 switch (ofpact
->type
) {
1849 return ofpact_get_OUTPUT(ofpact
)->port
== port
;
1850 case OFPACT_ENQUEUE
:
1851 return ofpact_get_ENQUEUE(ofpact
)->port
== port
;
1852 case OFPACT_CONTROLLER
:
1853 return port
== OFPP_CONTROLLER
;
1855 case OFPACT_OUTPUT_REG
:
1857 case OFPACT_SET_VLAN_VID
:
1858 case OFPACT_SET_VLAN_PCP
:
1859 case OFPACT_STRIP_VLAN
:
1860 case OFPACT_PUSH_VLAN
:
1861 case OFPACT_SET_ETH_SRC
:
1862 case OFPACT_SET_ETH_DST
:
1863 case OFPACT_SET_IPV4_SRC
:
1864 case OFPACT_SET_IPV4_DST
:
1865 case OFPACT_SET_IPV4_DSCP
:
1866 case OFPACT_SET_L4_SRC_PORT
:
1867 case OFPACT_SET_L4_DST_PORT
:
1868 case OFPACT_REG_MOVE
:
1869 case OFPACT_REG_LOAD
:
1870 case OFPACT_DEC_TTL
:
1871 case OFPACT_SET_MPLS_TTL
:
1872 case OFPACT_DEC_MPLS_TTL
:
1873 case OFPACT_SET_TUNNEL
:
1874 case OFPACT_WRITE_METADATA
:
1875 case OFPACT_SET_QUEUE
:
1876 case OFPACT_POP_QUEUE
:
1877 case OFPACT_FIN_TIMEOUT
:
1878 case OFPACT_RESUBMIT
:
1880 case OFPACT_MULTIPATH
:
1883 case OFPACT_PUSH_MPLS
:
1884 case OFPACT_POP_MPLS
:
1885 case OFPACT_CLEAR_ACTIONS
:
1886 case OFPACT_GOTO_TABLE
:
1892 /* Returns true if any action in the 'ofpacts_len' bytes of 'ofpacts' outputs
1893 * to 'port', false otherwise. */
1895 ofpacts_output_to_port(const struct ofpact
*ofpacts
, size_t ofpacts_len
,
1898 const struct ofpact
*a
;
1900 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
1901 if (ofpact_outputs_to_port(a
, port
)) {
1910 ofpacts_equal(const struct ofpact
*a
, size_t a_len
,
1911 const struct ofpact
*b
, size_t b_len
)
1913 return a_len
== b_len
&& !memcmp(a
, b
, a_len
);
1916 /* Formatting ofpacts. */
1919 print_note(const struct ofpact_note
*note
, struct ds
*string
)
1923 ds_put_cstr(string
, "note:");
1924 for (i
= 0; i
< note
->length
; i
++) {
1926 ds_put_char(string
, '.');
1928 ds_put_format(string
, "%02"PRIx8
, note
->data
[i
]);
1933 print_dec_ttl(const struct ofpact_cnt_ids
*ids
,
1938 ds_put_cstr(s
, "dec_ttl");
1939 if (ids
->ofpact
.compat
== OFPUTIL_NXAST_DEC_TTL_CNT_IDS
) {
1940 ds_put_cstr(s
, "(");
1941 for (i
= 0; i
< ids
->n_controllers
; i
++) {
1943 ds_put_cstr(s
, ",");
1945 ds_put_format(s
, "%"PRIu16
, ids
->cnt_ids
[i
]);
1947 ds_put_cstr(s
, ")");
1952 print_fin_timeout(const struct ofpact_fin_timeout
*fin_timeout
,
1955 ds_put_cstr(s
, "fin_timeout(");
1956 if (fin_timeout
->fin_idle_timeout
) {
1957 ds_put_format(s
, "idle_timeout=%"PRIu16
",",
1958 fin_timeout
->fin_idle_timeout
);
1960 if (fin_timeout
->fin_hard_timeout
) {
1961 ds_put_format(s
, "hard_timeout=%"PRIu16
",",
1962 fin_timeout
->fin_hard_timeout
);
1965 ds_put_char(s
, ')');
1969 ofpact_format(const struct ofpact
*a
, struct ds
*s
)
1971 const struct ofpact_enqueue
*enqueue
;
1972 const struct ofpact_resubmit
*resubmit
;
1973 const struct ofpact_controller
*controller
;
1974 const struct ofpact_metadata
*metadata
;
1975 const struct ofpact_tunnel
*tunnel
;
1980 port
= ofpact_get_OUTPUT(a
)->port
;
1981 if (port
< OFPP_MAX
) {
1982 ds_put_format(s
, "output:%"PRIu16
, port
);
1984 ofputil_format_port(port
, s
);
1985 if (port
== OFPP_CONTROLLER
) {
1986 ds_put_format(s
, ":%"PRIu16
, ofpact_get_OUTPUT(a
)->max_len
);
1991 case OFPACT_CONTROLLER
:
1992 controller
= ofpact_get_CONTROLLER(a
);
1993 if (controller
->reason
== OFPR_ACTION
&&
1994 controller
->controller_id
== 0) {
1995 ds_put_format(s
, "CONTROLLER:%"PRIu16
,
1996 ofpact_get_CONTROLLER(a
)->max_len
);
1998 enum ofp_packet_in_reason reason
= controller
->reason
;
2000 ds_put_cstr(s
, "controller(");
2001 if (reason
!= OFPR_ACTION
) {
2002 ds_put_format(s
, "reason=%s,",
2003 ofputil_packet_in_reason_to_string(reason
));
2005 if (controller
->max_len
!= UINT16_MAX
) {
2006 ds_put_format(s
, "max_len=%"PRIu16
",", controller
->max_len
);
2008 if (controller
->controller_id
!= 0) {
2009 ds_put_format(s
, "id=%"PRIu16
",", controller
->controller_id
);
2012 ds_put_char(s
, ')');
2016 case OFPACT_ENQUEUE
:
2017 enqueue
= ofpact_get_ENQUEUE(a
);
2018 ds_put_format(s
, "enqueue:");
2019 ofputil_format_port(enqueue
->port
, s
);
2020 ds_put_format(s
, "q%"PRIu32
, enqueue
->queue
);
2023 case OFPACT_OUTPUT_REG
:
2024 ds_put_cstr(s
, "output:");
2025 mf_format_subfield(&ofpact_get_OUTPUT_REG(a
)->src
, s
);
2029 bundle_format(ofpact_get_BUNDLE(a
), s
);
2032 case OFPACT_SET_VLAN_VID
:
2033 ds_put_format(s
, "mod_vlan_vid:%"PRIu16
,
2034 ofpact_get_SET_VLAN_VID(a
)->vlan_vid
);
2037 case OFPACT_SET_VLAN_PCP
:
2038 ds_put_format(s
, "mod_vlan_pcp:%"PRIu8
,
2039 ofpact_get_SET_VLAN_PCP(a
)->vlan_pcp
);
2042 case OFPACT_STRIP_VLAN
:
2043 ds_put_cstr(s
, "strip_vlan");
2046 case OFPACT_PUSH_VLAN
:
2047 /* XXX 802.1AD case*/
2048 ds_put_format(s
, "push_vlan:%#"PRIx16
, ETH_TYPE_VLAN_8021Q
);
2051 case OFPACT_SET_ETH_SRC
:
2052 ds_put_format(s
, "mod_dl_src:"ETH_ADDR_FMT
,
2053 ETH_ADDR_ARGS(ofpact_get_SET_ETH_SRC(a
)->mac
));
2056 case OFPACT_SET_ETH_DST
:
2057 ds_put_format(s
, "mod_dl_dst:"ETH_ADDR_FMT
,
2058 ETH_ADDR_ARGS(ofpact_get_SET_ETH_DST(a
)->mac
));
2061 case OFPACT_SET_IPV4_SRC
:
2062 ds_put_format(s
, "mod_nw_src:"IP_FMT
,
2063 IP_ARGS(ofpact_get_SET_IPV4_SRC(a
)->ipv4
));
2066 case OFPACT_SET_IPV4_DST
:
2067 ds_put_format(s
, "mod_nw_dst:"IP_FMT
,
2068 IP_ARGS(ofpact_get_SET_IPV4_DST(a
)->ipv4
));
2071 case OFPACT_SET_IPV4_DSCP
:
2072 ds_put_format(s
, "mod_nw_tos:%d", ofpact_get_SET_IPV4_DSCP(a
)->dscp
);
2075 case OFPACT_SET_L4_SRC_PORT
:
2076 ds_put_format(s
, "mod_tp_src:%d", ofpact_get_SET_L4_SRC_PORT(a
)->port
);
2079 case OFPACT_SET_L4_DST_PORT
:
2080 ds_put_format(s
, "mod_tp_dst:%d", ofpact_get_SET_L4_DST_PORT(a
)->port
);
2083 case OFPACT_REG_MOVE
:
2084 nxm_format_reg_move(ofpact_get_REG_MOVE(a
), s
);
2087 case OFPACT_REG_LOAD
:
2088 nxm_format_reg_load(ofpact_get_REG_LOAD(a
), s
);
2091 case OFPACT_DEC_TTL
:
2092 print_dec_ttl(ofpact_get_DEC_TTL(a
), s
);
2095 case OFPACT_SET_MPLS_TTL
:
2096 ds_put_format(s
, "set_mpls_ttl(%"PRIu8
")",
2097 ofpact_get_SET_MPLS_TTL(a
)->ttl
);
2100 case OFPACT_DEC_MPLS_TTL
:
2101 ds_put_cstr(s
, "dec_mpls_ttl");
2104 case OFPACT_SET_TUNNEL
:
2105 tunnel
= ofpact_get_SET_TUNNEL(a
);
2106 ds_put_format(s
, "set_tunnel%s:%#"PRIx64
,
2107 (tunnel
->tun_id
> UINT32_MAX
2108 || a
->compat
== OFPUTIL_NXAST_SET_TUNNEL64
? "64" : ""),
2112 case OFPACT_SET_QUEUE
:
2113 ds_put_format(s
, "set_queue:%"PRIu32
,
2114 ofpact_get_SET_QUEUE(a
)->queue_id
);
2117 case OFPACT_POP_QUEUE
:
2118 ds_put_cstr(s
, "pop_queue");
2121 case OFPACT_FIN_TIMEOUT
:
2122 print_fin_timeout(ofpact_get_FIN_TIMEOUT(a
), s
);
2125 case OFPACT_RESUBMIT
:
2126 resubmit
= ofpact_get_RESUBMIT(a
);
2127 if (resubmit
->in_port
!= OFPP_IN_PORT
&& resubmit
->table_id
== 255) {
2128 ds_put_cstr(s
, "resubmit:");
2129 ofputil_format_port(resubmit
->in_port
, s
);
2131 ds_put_format(s
, "resubmit(");
2132 if (resubmit
->in_port
!= OFPP_IN_PORT
) {
2133 ofputil_format_port(resubmit
->in_port
, s
);
2135 ds_put_char(s
, ',');
2136 if (resubmit
->table_id
!= 255) {
2137 ds_put_format(s
, "%"PRIu8
, resubmit
->table_id
);
2139 ds_put_char(s
, ')');
2144 learn_format(ofpact_get_LEARN(a
), s
);
2147 case OFPACT_MULTIPATH
:
2148 multipath_format(ofpact_get_MULTIPATH(a
), s
);
2152 print_note(ofpact_get_NOTE(a
), s
);
2155 case OFPACT_PUSH_MPLS
:
2156 ds_put_format(s
, "push_mpls:0x%04"PRIx16
,
2157 ntohs(ofpact_get_PUSH_MPLS(a
)->ethertype
));
2160 case OFPACT_POP_MPLS
:
2161 ds_put_format(s
, "pop_mpls:0x%04"PRIx16
,
2162 ntohs(ofpact_get_POP_MPLS(a
)->ethertype
));
2166 ds_put_cstr(s
, "exit");
2169 case OFPACT_CLEAR_ACTIONS
:
2170 ds_put_format(s
, "%s",
2171 ofpact_instruction_name_from_type(
2172 OVSINST_OFPIT11_CLEAR_ACTIONS
));
2175 case OFPACT_WRITE_METADATA
:
2176 metadata
= ofpact_get_WRITE_METADATA(a
);
2177 ds_put_format(s
, "%s:%#"PRIx64
,
2178 ofpact_instruction_name_from_type(
2179 OVSINST_OFPIT11_WRITE_METADATA
),
2180 ntohll(metadata
->metadata
));
2181 if (metadata
->mask
!= htonll(UINT64_MAX
)) {
2182 ds_put_format(s
, "/%#"PRIx64
, ntohll(metadata
->mask
));
2186 case OFPACT_GOTO_TABLE
:
2187 ds_put_format(s
, "%s:%"PRIu8
,
2188 ofpact_instruction_name_from_type(
2189 OVSINST_OFPIT11_GOTO_TABLE
),
2190 ofpact_get_GOTO_TABLE(a
)->table_id
);
2195 /* Appends a string representing the 'ofpacts_len' bytes of ofpacts in
2196 * 'ofpacts' to 'string'. */
2198 ofpacts_format(const struct ofpact
*ofpacts
, size_t ofpacts_len
,
2201 ds_put_cstr(string
, "actions=");
2203 ds_put_cstr(string
, "drop");
2205 const struct ofpact
*a
;
2207 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
2209 ds_put_cstr(string
, ",");
2212 /* XXX write-actions */
2213 ofpact_format(a
, string
);
2218 /* Internal use by helpers. */
2221 ofpact_put(struct ofpbuf
*ofpacts
, enum ofpact_type type
, size_t len
)
2223 struct ofpact
*ofpact
;
2225 ofpact_pad(ofpacts
);
2226 ofpact
= ofpacts
->l2
= ofpbuf_put_uninit(ofpacts
, len
);
2227 ofpact_init(ofpact
, type
, len
);
2232 ofpact_init(struct ofpact
*ofpact
, enum ofpact_type type
, size_t len
)
2234 memset(ofpact
, 0, len
);
2235 ofpact
->type
= type
;
2236 ofpact
->compat
= OFPUTIL_ACTION_INVALID
;
2240 /* Updates 'ofpact->len' to the number of bytes in the tail of 'ofpacts'
2241 * starting at 'ofpact'.
2243 * This is the correct way to update a variable-length ofpact's length after
2244 * adding the variable-length part of the payload. (See the large comment
2245 * near the end of ofp-actions.h for more information.) */
2247 ofpact_update_len(struct ofpbuf
*ofpacts
, struct ofpact
*ofpact
)
2249 ovs_assert(ofpact
== ofpacts
->l2
);
2250 ofpact
->len
= (char *) ofpbuf_tail(ofpacts
) - (char *) ofpact
;
2253 /* Pads out 'ofpacts' to a multiple of OFPACT_ALIGNTO bytes in length. Each
2254 * ofpact_put_<ENUM>() calls this function automatically beforehand, but the
2255 * client must call this itself after adding the final ofpact to an array of
2258 * (The consequences of failing to call this function are probably not dire.
2259 * OFPACT_FOR_EACH will calculate a pointer beyond the end of the ofpacts, but
2260 * not dereference it. That's undefined behavior, technically, but it will not
2261 * cause a real problem on common systems. Still, it seems better to call
2264 ofpact_pad(struct ofpbuf
*ofpacts
)
2266 unsigned int rem
= ofpacts
->size
% OFPACT_ALIGNTO
;
2268 ofpbuf_put_zeros(ofpacts
, OFPACT_ALIGNTO
- rem
);
2273 ofpact_set_field_init(struct ofpact_reg_load
*load
, const struct mf_field
*mf
,
2276 load
->ofpact
.compat
= OFPUTIL_OFPAT12_SET_FIELD
;
2277 load
->dst
.field
= mf
;
2279 load
->dst
.n_bits
= mf
->n_bits
;
2280 bitwise_copy(src
, mf
->n_bytes
, load
->dst
.ofs
,
2281 &load
->subvalue
, sizeof load
->subvalue
, 0, mf
->n_bits
);