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
= u16_to_ofp(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
= u16_to_ofp(ntohs(oae
->port
));
59 enqueue
->queue
= ntohl(oae
->queue_id
);
60 if (ofp_to_u16(enqueue
->port
) >= ofp_to_u16(OFPP_MAX
)
61 && enqueue
->port
!= OFPP_IN_PORT
62 && enqueue
->port
!= OFPP_LOCAL
) {
63 return OFPERR_OFPBAC_BAD_OUT_PORT
;
69 resubmit_from_openflow(const struct nx_action_resubmit
*nar
,
72 struct ofpact_resubmit
*resubmit
;
74 resubmit
= ofpact_put_RESUBMIT(out
);
75 resubmit
->ofpact
.compat
= OFPUTIL_NXAST_RESUBMIT
;
76 resubmit
->in_port
= u16_to_ofp(ntohs(nar
->in_port
));
77 resubmit
->table_id
= 0xff;
81 resubmit_table_from_openflow(const struct nx_action_resubmit
*nar
,
84 struct ofpact_resubmit
*resubmit
;
86 if (nar
->pad
[0] || nar
->pad
[1] || nar
->pad
[2]) {
87 return OFPERR_OFPBAC_BAD_ARGUMENT
;
90 resubmit
= ofpact_put_RESUBMIT(out
);
91 resubmit
->ofpact
.compat
= OFPUTIL_NXAST_RESUBMIT_TABLE
;
92 resubmit
->in_port
= u16_to_ofp(ntohs(nar
->in_port
));
93 resubmit
->table_id
= nar
->table
;
98 output_reg_from_openflow(const struct nx_action_output_reg
*naor
,
101 struct ofpact_output_reg
*output_reg
;
103 if (!is_all_zeros(naor
->zero
, sizeof naor
->zero
)) {
104 return OFPERR_OFPBAC_BAD_ARGUMENT
;
107 output_reg
= ofpact_put_OUTPUT_REG(out
);
108 output_reg
->src
.field
= mf_from_nxm_header(ntohl(naor
->src
));
109 output_reg
->src
.ofs
= nxm_decode_ofs(naor
->ofs_nbits
);
110 output_reg
->src
.n_bits
= nxm_decode_n_bits(naor
->ofs_nbits
);
111 output_reg
->max_len
= ntohs(naor
->max_len
);
113 return mf_check_src(&output_reg
->src
, NULL
);
117 fin_timeout_from_openflow(const struct nx_action_fin_timeout
*naft
,
120 struct ofpact_fin_timeout
*oft
;
122 oft
= ofpact_put_FIN_TIMEOUT(out
);
123 oft
->fin_idle_timeout
= ntohs(naft
->fin_idle_timeout
);
124 oft
->fin_hard_timeout
= ntohs(naft
->fin_hard_timeout
);
128 controller_from_openflow(const struct nx_action_controller
*nac
,
131 struct ofpact_controller
*oc
;
133 oc
= ofpact_put_CONTROLLER(out
);
134 oc
->max_len
= ntohs(nac
->max_len
);
135 oc
->controller_id
= ntohs(nac
->controller_id
);
136 oc
->reason
= nac
->reason
;
140 metadata_from_nxast(const struct nx_action_write_metadata
*nawm
,
143 struct ofpact_metadata
*om
;
145 if (!is_all_zeros(nawm
->zeros
, sizeof nawm
->zeros
)) {
146 return OFPERR_NXBRC_MUST_BE_ZERO
;
149 om
= ofpact_put_WRITE_METADATA(out
);
150 om
->metadata
= nawm
->metadata
;
151 om
->mask
= nawm
->mask
;
157 note_from_openflow(const struct nx_action_note
*nan
, struct ofpbuf
*out
)
159 struct ofpact_note
*note
;
162 length
= ntohs(nan
->len
) - offsetof(struct nx_action_note
, note
);
163 note
= ofpact_put(out
, OFPACT_NOTE
,
164 offsetof(struct ofpact_note
, data
) + length
);
165 note
->length
= length
;
166 memcpy(note
->data
, nan
->note
, length
);
170 dec_ttl_from_openflow(struct ofpbuf
*out
, enum ofputil_action_code compat
)
173 struct ofpact_cnt_ids
*ids
;
174 enum ofperr error
= 0;
176 ids
= ofpact_put_DEC_TTL(out
);
177 ids
->ofpact
.compat
= compat
;
178 ids
->n_controllers
= 1;
179 ofpbuf_put(out
, &id
, sizeof id
);
181 ofpact_update_len(out
, &ids
->ofpact
);
186 dec_ttl_cnt_ids_from_openflow(const struct nx_action_cnt_ids
*nac_ids
,
189 struct ofpact_cnt_ids
*ids
;
193 ids
= ofpact_put_DEC_TTL(out
);
194 ids
->ofpact
.compat
= OFPUTIL_NXAST_DEC_TTL_CNT_IDS
;
195 ids
->n_controllers
= ntohs(nac_ids
->n_controllers
);
196 ids_size
= ntohs(nac_ids
->len
) - sizeof *nac_ids
;
198 if (!is_all_zeros(nac_ids
->zeros
, sizeof nac_ids
->zeros
)) {
199 return OFPERR_NXBRC_MUST_BE_ZERO
;
202 if (ids_size
< ids
->n_controllers
* sizeof(ovs_be16
)) {
203 VLOG_WARN_RL(&rl
, "Nicira action dec_ttl_cnt_ids only has %zu bytes "
204 "allocated for controller ids. %zu bytes are required for "
205 "%"PRIu16
" controllers.", ids_size
,
206 ids
->n_controllers
* sizeof(ovs_be16
), ids
->n_controllers
);
207 return OFPERR_OFPBAC_BAD_LEN
;
210 for (i
= 0; i
< ids
->n_controllers
; i
++) {
211 uint16_t id
= ntohs(((ovs_be16
*)(nac_ids
+ 1))[i
]);
212 ofpbuf_put(out
, &id
, sizeof id
);
216 ofpact_update_len(out
, &ids
->ofpact
);
222 sample_from_openflow(const struct nx_action_sample
*nas
,
225 struct ofpact_sample
*sample
;
227 sample
= ofpact_put_SAMPLE(out
);
228 sample
->probability
= ntohs(nas
->probability
);
229 sample
->collector_set_id
= ntohl(nas
->collector_set_id
);
230 sample
->obs_domain_id
= ntohl(nas
->obs_domain_id
);
231 sample
->obs_point_id
= ntohl(nas
->obs_point_id
);
233 if (sample
->probability
== 0) {
234 return OFPERR_OFPBAC_BAD_ARGUMENT
;
241 decode_nxast_action(const union ofp_action
*a
, enum ofputil_action_code
*code
)
243 const struct nx_action_header
*nah
= (const struct nx_action_header
*) a
;
244 uint16_t len
= ntohs(a
->header
.len
);
246 if (len
< sizeof(struct nx_action_header
)) {
247 return OFPERR_OFPBAC_BAD_LEN
;
248 } else if (a
->vendor
.vendor
!= CONSTANT_HTONL(NX_VENDOR_ID
)) {
249 return OFPERR_OFPBAC_BAD_VENDOR
;
252 switch (nah
->subtype
) {
253 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \
254 case CONSTANT_HTONS(ENUM): \
256 ? len >= sizeof(struct STRUCT) \
257 : len == sizeof(struct STRUCT)) { \
258 *code = OFPUTIL_##ENUM; \
261 return OFPERR_OFPBAC_BAD_LEN; \
264 #include "ofp-util.def"
266 case CONSTANT_HTONS(NXAST_SNAT__OBSOLETE
):
267 case CONSTANT_HTONS(NXAST_DROP_SPOOFED_ARP__OBSOLETE
):
269 return OFPERR_OFPBAC_BAD_TYPE
;
273 /* Parses 'a' to determine its type. On success stores the correct type into
274 * '*code' and returns 0. On failure returns an OFPERR_* error code and
275 * '*code' is indeterminate.
277 * The caller must have already verified that 'a''s length is potentially
278 * correct (that is, a->header.len is nonzero and a multiple of sizeof(union
279 * ofp_action) and no longer than the amount of space allocated to 'a').
281 * This function verifies that 'a''s length is correct for the type of action
282 * that it represents. */
284 decode_openflow10_action(const union ofp_action
*a
,
285 enum ofputil_action_code
*code
)
288 case CONSTANT_HTONS(OFPAT10_VENDOR
):
289 return decode_nxast_action(a
, code
);
291 #define OFPAT10_ACTION(ENUM, STRUCT, NAME) \
292 case CONSTANT_HTONS(ENUM): \
293 if (a->header.len == htons(sizeof(struct STRUCT))) { \
294 *code = OFPUTIL_##ENUM; \
297 return OFPERR_OFPBAC_BAD_LEN; \
300 #include "ofp-util.def"
303 return OFPERR_OFPBAC_BAD_TYPE
;
308 ofpact_from_nxast(const union ofp_action
*a
, enum ofputil_action_code code
,
311 const struct nx_action_resubmit
*nar
;
312 const struct nx_action_set_tunnel
*nast
;
313 const struct nx_action_set_queue
*nasq
;
314 const struct nx_action_note
*nan
;
315 const struct nx_action_set_tunnel64
*nast64
;
316 const struct nx_action_write_metadata
*nawm
;
317 struct ofpact_tunnel
*tunnel
;
318 enum ofperr error
= 0;
321 case OFPUTIL_ACTION_INVALID
:
322 #define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
323 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
324 #include "ofp-util.def"
327 case OFPUTIL_NXAST_RESUBMIT
:
328 resubmit_from_openflow((const struct nx_action_resubmit
*) a
, out
);
331 case OFPUTIL_NXAST_SET_TUNNEL
:
332 nast
= (const struct nx_action_set_tunnel
*) a
;
333 tunnel
= ofpact_put_SET_TUNNEL(out
);
334 tunnel
->ofpact
.compat
= code
;
335 tunnel
->tun_id
= ntohl(nast
->tun_id
);
338 case OFPUTIL_NXAST_WRITE_METADATA
:
339 nawm
= (const struct nx_action_write_metadata
*) a
;
340 error
= metadata_from_nxast(nawm
, out
);
343 case OFPUTIL_NXAST_SET_QUEUE
:
344 nasq
= (const struct nx_action_set_queue
*) a
;
345 ofpact_put_SET_QUEUE(out
)->queue_id
= ntohl(nasq
->queue_id
);
348 case OFPUTIL_NXAST_POP_QUEUE
:
349 ofpact_put_POP_QUEUE(out
);
352 case OFPUTIL_NXAST_REG_MOVE
:
353 error
= nxm_reg_move_from_openflow(
354 (const struct nx_action_reg_move
*) a
, out
);
357 case OFPUTIL_NXAST_REG_LOAD
:
358 error
= nxm_reg_load_from_openflow(
359 (const struct nx_action_reg_load
*) a
, out
);
362 case OFPUTIL_NXAST_STACK_PUSH
:
363 error
= nxm_stack_push_from_openflow(
364 (const struct nx_action_stack
*) a
, out
);
367 case OFPUTIL_NXAST_STACK_POP
:
368 error
= nxm_stack_pop_from_openflow(
369 (const struct nx_action_stack
*) a
, out
);
372 case OFPUTIL_NXAST_NOTE
:
373 nan
= (const struct nx_action_note
*) a
;
374 note_from_openflow(nan
, out
);
377 case OFPUTIL_NXAST_SET_TUNNEL64
:
378 nast64
= (const struct nx_action_set_tunnel64
*) a
;
379 tunnel
= ofpact_put_SET_TUNNEL(out
);
380 tunnel
->ofpact
.compat
= code
;
381 tunnel
->tun_id
= ntohll(nast64
->tun_id
);
384 case OFPUTIL_NXAST_MULTIPATH
:
385 error
= multipath_from_openflow((const struct nx_action_multipath
*) a
,
386 ofpact_put_MULTIPATH(out
));
389 case OFPUTIL_NXAST_BUNDLE
:
390 case OFPUTIL_NXAST_BUNDLE_LOAD
:
391 error
= bundle_from_openflow((const struct nx_action_bundle
*) a
, out
);
394 case OFPUTIL_NXAST_OUTPUT_REG
:
395 error
= output_reg_from_openflow(
396 (const struct nx_action_output_reg
*) a
, out
);
399 case OFPUTIL_NXAST_RESUBMIT_TABLE
:
400 nar
= (const struct nx_action_resubmit
*) a
;
401 error
= resubmit_table_from_openflow(nar
, out
);
404 case OFPUTIL_NXAST_LEARN
:
405 error
= learn_from_openflow((const struct nx_action_learn
*) a
, out
);
408 case OFPUTIL_NXAST_EXIT
:
409 ofpact_put_EXIT(out
);
412 case OFPUTIL_NXAST_DEC_TTL
:
413 error
= dec_ttl_from_openflow(out
, code
);
416 case OFPUTIL_NXAST_DEC_TTL_CNT_IDS
:
417 error
= dec_ttl_cnt_ids_from_openflow(
418 (const struct nx_action_cnt_ids
*) a
, out
);
421 case OFPUTIL_NXAST_FIN_TIMEOUT
:
422 fin_timeout_from_openflow(
423 (const struct nx_action_fin_timeout
*) a
, out
);
426 case OFPUTIL_NXAST_CONTROLLER
:
427 controller_from_openflow((const struct nx_action_controller
*) a
, out
);
430 case OFPUTIL_NXAST_PUSH_MPLS
: {
431 struct nx_action_push_mpls
*nxapm
= (struct nx_action_push_mpls
*)a
;
432 if (!eth_type_mpls(nxapm
->ethertype
)) {
433 return OFPERR_OFPBAC_BAD_ARGUMENT
;
435 ofpact_put_PUSH_MPLS(out
)->ethertype
= nxapm
->ethertype
;
439 case OFPUTIL_NXAST_SET_MPLS_TTL
: {
440 struct nx_action_mpls_ttl
*nxamt
= (struct nx_action_mpls_ttl
*)a
;
441 ofpact_put_SET_MPLS_TTL(out
)->ttl
= nxamt
->ttl
;
445 case OFPUTIL_NXAST_DEC_MPLS_TTL
:
446 ofpact_put_DEC_MPLS_TTL(out
);
449 case OFPUTIL_NXAST_POP_MPLS
: {
450 struct nx_action_pop_mpls
*nxapm
= (struct nx_action_pop_mpls
*)a
;
451 if (eth_type_mpls(nxapm
->ethertype
)) {
452 return OFPERR_OFPBAC_BAD_ARGUMENT
;
454 ofpact_put_POP_MPLS(out
)->ethertype
= nxapm
->ethertype
;
458 case OFPUTIL_NXAST_SAMPLE
:
459 error
= sample_from_openflow(
460 (const struct nx_action_sample
*) a
, out
);
468 ofpact_from_openflow10(const union ofp_action
*a
, struct ofpbuf
*out
)
470 enum ofputil_action_code code
;
473 error
= decode_openflow10_action(a
, &code
);
479 case OFPUTIL_ACTION_INVALID
:
480 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
481 #include "ofp-util.def"
484 case OFPUTIL_OFPAT10_OUTPUT
:
485 return output_from_openflow10(&a
->output10
, out
);
487 case OFPUTIL_OFPAT10_SET_VLAN_VID
:
488 if (a
->vlan_vid
.vlan_vid
& ~htons(0xfff)) {
489 return OFPERR_OFPBAC_BAD_ARGUMENT
;
491 ofpact_put_SET_VLAN_VID(out
)->vlan_vid
= ntohs(a
->vlan_vid
.vlan_vid
);
494 case OFPUTIL_OFPAT10_SET_VLAN_PCP
:
495 if (a
->vlan_pcp
.vlan_pcp
& ~7) {
496 return OFPERR_OFPBAC_BAD_ARGUMENT
;
498 ofpact_put_SET_VLAN_PCP(out
)->vlan_pcp
= a
->vlan_pcp
.vlan_pcp
;
501 case OFPUTIL_OFPAT10_STRIP_VLAN
:
502 ofpact_put_STRIP_VLAN(out
);
505 case OFPUTIL_OFPAT10_SET_DL_SRC
:
506 memcpy(ofpact_put_SET_ETH_SRC(out
)->mac
,
507 ((const struct ofp_action_dl_addr
*) a
)->dl_addr
, ETH_ADDR_LEN
);
510 case OFPUTIL_OFPAT10_SET_DL_DST
:
511 memcpy(ofpact_put_SET_ETH_DST(out
)->mac
,
512 ((const struct ofp_action_dl_addr
*) a
)->dl_addr
, ETH_ADDR_LEN
);
515 case OFPUTIL_OFPAT10_SET_NW_SRC
:
516 ofpact_put_SET_IPV4_SRC(out
)->ipv4
= a
->nw_addr
.nw_addr
;
519 case OFPUTIL_OFPAT10_SET_NW_DST
:
520 ofpact_put_SET_IPV4_DST(out
)->ipv4
= a
->nw_addr
.nw_addr
;
523 case OFPUTIL_OFPAT10_SET_NW_TOS
:
524 if (a
->nw_tos
.nw_tos
& ~IP_DSCP_MASK
) {
525 return OFPERR_OFPBAC_BAD_ARGUMENT
;
527 ofpact_put_SET_IPV4_DSCP(out
)->dscp
= a
->nw_tos
.nw_tos
;
530 case OFPUTIL_OFPAT10_SET_TP_SRC
:
531 ofpact_put_SET_L4_SRC_PORT(out
)->port
= ntohs(a
->tp_port
.tp_port
);
534 case OFPUTIL_OFPAT10_SET_TP_DST
:
535 ofpact_put_SET_L4_DST_PORT(out
)->port
= ntohs(a
->tp_port
.tp_port
);
539 case OFPUTIL_OFPAT10_ENQUEUE
:
540 error
= enqueue_from_openflow10((const struct ofp10_action_enqueue
*) a
,
544 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
545 #include "ofp-util.def"
546 return ofpact_from_nxast(a
, code
, out
);
552 static inline union ofp_action
*
553 action_next(const union ofp_action
*a
)
555 return ((union ofp_action
*) (void *)
556 ((uint8_t *) a
+ ntohs(a
->header
.len
)));
560 action_is_valid(const union ofp_action
*a
, size_t n_actions
)
562 uint16_t len
= ntohs(a
->header
.len
);
563 return (!(len
% OFP_ACTION_ALIGN
)
565 && len
/ sizeof *a
<= n_actions
);
568 /* This macro is careful to check for actions with bad lengths. */
569 #define ACTION_FOR_EACH(ITER, LEFT, ACTIONS, N_ACTIONS) \
570 for ((ITER) = (ACTIONS), (LEFT) = (N_ACTIONS); \
571 (LEFT) > 0 && action_is_valid(ITER, LEFT); \
572 ((LEFT) -= ntohs((ITER)->header.len) / sizeof(union ofp_action), \
573 (ITER) = action_next(ITER)))
576 log_bad_action(const union ofp_action
*actions
, size_t n_actions
, size_t ofs
,
579 if (!VLOG_DROP_WARN(&rl
)) {
583 ds_put_hex_dump(&s
, actions
, n_actions
* sizeof *actions
, 0, false);
584 VLOG_WARN("bad action at offset %#zx (%s):\n%s",
585 ofs
* sizeof *actions
, ofperr_get_name(error
), ds_cstr(&s
));
591 ofpacts_from_openflow(const union ofp_action
*in
, size_t n_in
,
593 enum ofperr (*ofpact_from_openflow
)(
594 const union ofp_action
*a
, struct ofpbuf
*out
))
596 const union ofp_action
*a
;
599 ACTION_FOR_EACH (a
, left
, in
, n_in
) {
600 enum ofperr error
= ofpact_from_openflow(a
, out
);
602 log_bad_action(in
, n_in
, a
- in
, error
);
607 enum ofperr error
= OFPERR_OFPBAC_BAD_LEN
;
608 log_bad_action(in
, n_in
, n_in
- left
, error
);
617 ofpacts_from_openflow10(const union ofp_action
*in
, size_t n_in
,
620 return ofpacts_from_openflow(in
, n_in
, out
, ofpact_from_openflow10
);
624 ofpacts_pull_actions(struct ofpbuf
*openflow
, unsigned int actions_len
,
625 struct ofpbuf
*ofpacts
,
626 enum ofperr (*translate
)(const union ofp_action
*actions
,
628 struct ofpbuf
*ofpacts
))
630 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
631 const union ofp_action
*actions
;
634 ofpbuf_clear(ofpacts
);
636 if (actions_len
% OFP_ACTION_ALIGN
!= 0) {
637 VLOG_WARN_RL(&rl
, "OpenFlow message actions length %u is not a "
638 "multiple of %d", actions_len
, OFP_ACTION_ALIGN
);
639 return OFPERR_OFPBRC_BAD_LEN
;
642 actions
= ofpbuf_try_pull(openflow
, actions_len
);
643 if (actions
== NULL
) {
644 VLOG_WARN_RL(&rl
, "OpenFlow message actions length %u exceeds "
645 "remaining message length (%zu)",
646 actions_len
, openflow
->size
);
647 return OFPERR_OFPBRC_BAD_LEN
;
650 error
= translate(actions
, actions_len
/ OFP_ACTION_ALIGN
, ofpacts
);
652 ofpbuf_clear(ofpacts
);
656 error
= ofpacts_verify(ofpacts
->data
, ofpacts
->size
);
658 ofpbuf_clear(ofpacts
);
663 /* Attempts to convert 'actions_len' bytes of OpenFlow 1.0 actions from the
664 * front of 'openflow' into ofpacts. On success, replaces any existing content
665 * in 'ofpacts' by the converted ofpacts; on failure, clears 'ofpacts'.
666 * Returns 0 if successful, otherwise an OpenFlow error.
668 * The parsed actions are valid generically, but they may not be valid in a
669 * specific context. For example, port numbers up to OFPP_MAX are valid
670 * generically, but specific datapaths may only support port numbers in a
671 * smaller range. Use ofpacts_check() to additional check whether actions are
672 * valid in a specific context. */
674 ofpacts_pull_openflow10(struct ofpbuf
*openflow
, unsigned int actions_len
,
675 struct ofpbuf
*ofpacts
)
677 return ofpacts_pull_actions(openflow
, actions_len
, ofpacts
,
678 ofpacts_from_openflow10
);
681 /* OpenFlow 1.1 actions. */
683 /* Parses 'a' to determine its type. On success stores the correct type into
684 * '*code' and returns 0. On failure returns an OFPERR_* error code and
685 * '*code' is indeterminate.
687 * The caller must have already verified that 'a''s length is potentially
688 * correct (that is, a->header.len is nonzero and a multiple of sizeof(union
689 * ofp_action) and no longer than the amount of space allocated to 'a').
691 * This function verifies that 'a''s length is correct for the type of action
692 * that it represents. */
694 decode_openflow11_action(const union ofp_action
*a
,
695 enum ofputil_action_code
*code
)
700 case CONSTANT_HTONS(OFPAT11_EXPERIMENTER
):
701 return decode_nxast_action(a
, code
);
703 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \
704 case CONSTANT_HTONS(ENUM): \
705 len = ntohs(a->header.len); \
707 ? len >= sizeof(struct STRUCT) \
708 : len == sizeof(struct STRUCT)) { \
709 *code = OFPUTIL_##ENUM; \
712 return OFPERR_OFPBAC_BAD_LEN; \
715 #include "ofp-util.def"
718 return OFPERR_OFPBAC_BAD_TYPE
;
723 output_from_openflow11(const struct ofp11_action_output
*oao
,
726 struct ofpact_output
*output
;
729 output
= ofpact_put_OUTPUT(out
);
730 output
->max_len
= ntohs(oao
->max_len
);
732 error
= ofputil_port_from_ofp11(oao
->port
, &output
->port
);
737 return ofputil_check_output_port(output
->port
, OFPP_MAX
);
741 ofpact_from_openflow11(const union ofp_action
*a
, struct ofpbuf
*out
)
743 enum ofputil_action_code code
;
746 error
= decode_openflow11_action(a
, &code
);
752 case OFPUTIL_ACTION_INVALID
:
753 #define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
754 #include "ofp-util.def"
757 case OFPUTIL_OFPAT11_OUTPUT
:
758 return output_from_openflow11((const struct ofp11_action_output
*) a
,
761 case OFPUTIL_OFPAT11_SET_VLAN_VID
:
762 if (a
->vlan_vid
.vlan_vid
& ~htons(0xfff)) {
763 return OFPERR_OFPBAC_BAD_ARGUMENT
;
765 ofpact_put_SET_VLAN_VID(out
)->vlan_vid
= ntohs(a
->vlan_vid
.vlan_vid
);
768 case OFPUTIL_OFPAT11_SET_VLAN_PCP
:
769 if (a
->vlan_pcp
.vlan_pcp
& ~7) {
770 return OFPERR_OFPBAC_BAD_ARGUMENT
;
772 ofpact_put_SET_VLAN_PCP(out
)->vlan_pcp
= a
->vlan_pcp
.vlan_pcp
;
775 case OFPUTIL_OFPAT11_PUSH_VLAN
:
776 if (((const struct ofp11_action_push
*)a
)->ethertype
!=
777 htons(ETH_TYPE_VLAN_8021Q
)) {
778 /* XXX 802.1AD(QinQ) isn't supported at the moment */
779 return OFPERR_OFPBAC_BAD_ARGUMENT
;
781 ofpact_put_PUSH_VLAN(out
);
784 case OFPUTIL_OFPAT11_POP_VLAN
:
785 ofpact_put_STRIP_VLAN(out
);
788 case OFPUTIL_OFPAT11_SET_QUEUE
:
789 ofpact_put_SET_QUEUE(out
)->queue_id
=
790 ntohl(((const struct ofp11_action_set_queue
*)a
)->queue_id
);
793 case OFPUTIL_OFPAT11_SET_DL_SRC
:
794 memcpy(ofpact_put_SET_ETH_SRC(out
)->mac
,
795 ((const struct ofp_action_dl_addr
*) a
)->dl_addr
, ETH_ADDR_LEN
);
798 case OFPUTIL_OFPAT11_SET_DL_DST
:
799 memcpy(ofpact_put_SET_ETH_DST(out
)->mac
,
800 ((const struct ofp_action_dl_addr
*) a
)->dl_addr
, ETH_ADDR_LEN
);
803 case OFPUTIL_OFPAT11_DEC_NW_TTL
:
804 dec_ttl_from_openflow(out
, code
);
807 case OFPUTIL_OFPAT11_SET_NW_SRC
:
808 ofpact_put_SET_IPV4_SRC(out
)->ipv4
= a
->nw_addr
.nw_addr
;
811 case OFPUTIL_OFPAT11_SET_NW_DST
:
812 ofpact_put_SET_IPV4_DST(out
)->ipv4
= a
->nw_addr
.nw_addr
;
815 case OFPUTIL_OFPAT11_SET_NW_TOS
:
816 if (a
->nw_tos
.nw_tos
& ~IP_DSCP_MASK
) {
817 return OFPERR_OFPBAC_BAD_ARGUMENT
;
819 ofpact_put_SET_IPV4_DSCP(out
)->dscp
= a
->nw_tos
.nw_tos
;
822 case OFPUTIL_OFPAT11_SET_TP_SRC
:
823 ofpact_put_SET_L4_SRC_PORT(out
)->port
= ntohs(a
->tp_port
.tp_port
);
826 case OFPUTIL_OFPAT11_SET_TP_DST
:
827 ofpact_put_SET_L4_DST_PORT(out
)->port
= ntohs(a
->tp_port
.tp_port
);
830 case OFPUTIL_OFPAT12_SET_FIELD
:
831 return nxm_reg_load_from_openflow12_set_field(
832 (const struct ofp12_action_set_field
*)a
, out
);
834 case OFPUTIL_OFPAT11_SET_MPLS_TTL
: {
835 struct ofp11_action_mpls_ttl
*oamt
= (struct ofp11_action_mpls_ttl
*)a
;
836 ofpact_put_SET_MPLS_TTL(out
)->ttl
= oamt
->mpls_ttl
;
840 case OFPUTIL_OFPAT11_DEC_MPLS_TTL
:
841 ofpact_put_DEC_MPLS_TTL(out
);
844 case OFPUTIL_OFPAT11_PUSH_MPLS
: {
845 struct ofp11_action_push
*oap
= (struct ofp11_action_push
*)a
;
846 if (!eth_type_mpls(oap
->ethertype
)) {
847 return OFPERR_OFPBAC_BAD_ARGUMENT
;
849 ofpact_put_PUSH_MPLS(out
)->ethertype
= oap
->ethertype
;
853 case OFPUTIL_OFPAT11_POP_MPLS
: {
854 struct ofp11_action_pop_mpls
*oapm
= (struct ofp11_action_pop_mpls
*)a
;
855 if (eth_type_mpls(oapm
->ethertype
)) {
856 return OFPERR_OFPBAC_BAD_ARGUMENT
;
858 ofpact_put_POP_MPLS(out
)->ethertype
= oapm
->ethertype
;
862 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
863 #include "ofp-util.def"
864 return ofpact_from_nxast(a
, code
, out
);
871 ofpacts_from_openflow11(const union ofp_action
*in
, size_t n_in
,
874 return ofpacts_from_openflow(in
, n_in
, out
, ofpact_from_openflow11
);
877 /* OpenFlow 1.1 instructions. */
879 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME) \
880 static inline const struct STRUCT * \
881 instruction_get_##ENUM(const struct ofp11_instruction *inst)\
883 ovs_assert(inst->type == htons(ENUM)); \
884 return (struct STRUCT *)inst; \
888 instruction_init_##ENUM(struct STRUCT *s) \
890 memset(s, 0, sizeof *s); \
891 s->type = htons(ENUM); \
892 s->len = htons(sizeof *s); \
895 static inline struct STRUCT * \
896 instruction_put_##ENUM(struct ofpbuf *buf) \
898 struct STRUCT *s = ofpbuf_put_uninit(buf, sizeof *s); \
899 instruction_init_##ENUM(s); \
905 struct instruction_type_info
{
906 enum ovs_instruction_type type
;
910 static const struct instruction_type_info inst_info
[] = {
911 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME) {OVSINST_##ENUM, NAME},
917 ovs_instruction_name_from_type(enum ovs_instruction_type type
)
919 return inst_info
[type
].name
;
923 ovs_instruction_type_from_name(const char *name
)
925 const struct instruction_type_info
*p
;
926 for (p
= inst_info
; p
< &inst_info
[ARRAY_SIZE(inst_info
)]; p
++) {
927 if (!strcasecmp(name
, p
->name
)) {
934 enum ovs_instruction_type
935 ovs_instruction_type_from_ofpact_type(enum ofpact_type type
)
939 return OVSINST_OFPIT13_METER
;
940 case OFPACT_CLEAR_ACTIONS
:
941 return OVSINST_OFPIT11_CLEAR_ACTIONS
;
942 case OFPACT_WRITE_METADATA
:
943 return OVSINST_OFPIT11_WRITE_METADATA
;
944 case OFPACT_GOTO_TABLE
:
945 return OVSINST_OFPIT11_GOTO_TABLE
;
947 case OFPACT_CONTROLLER
:
949 case OFPACT_OUTPUT_REG
:
951 case OFPACT_SET_VLAN_VID
:
952 case OFPACT_SET_VLAN_PCP
:
953 case OFPACT_STRIP_VLAN
:
954 case OFPACT_PUSH_VLAN
:
955 case OFPACT_SET_ETH_SRC
:
956 case OFPACT_SET_ETH_DST
:
957 case OFPACT_SET_IPV4_SRC
:
958 case OFPACT_SET_IPV4_DST
:
959 case OFPACT_SET_IPV4_DSCP
:
960 case OFPACT_SET_L4_SRC_PORT
:
961 case OFPACT_SET_L4_DST_PORT
:
962 case OFPACT_REG_MOVE
:
963 case OFPACT_REG_LOAD
:
964 case OFPACT_STACK_PUSH
:
965 case OFPACT_STACK_POP
:
967 case OFPACT_SET_MPLS_TTL
:
968 case OFPACT_DEC_MPLS_TTL
:
969 case OFPACT_PUSH_MPLS
:
970 case OFPACT_POP_MPLS
:
971 case OFPACT_SET_TUNNEL
:
972 case OFPACT_SET_QUEUE
:
973 case OFPACT_POP_QUEUE
:
974 case OFPACT_FIN_TIMEOUT
:
975 case OFPACT_RESUBMIT
:
977 case OFPACT_MULTIPATH
:
982 return OVSINST_OFPIT11_APPLY_ACTIONS
;
986 static inline struct ofp11_instruction
*
987 instruction_next(const struct ofp11_instruction
*inst
)
989 return ((struct ofp11_instruction
*) (void *)
990 ((uint8_t *) inst
+ ntohs(inst
->len
)));
994 instruction_is_valid(const struct ofp11_instruction
*inst
,
995 size_t n_instructions
)
997 uint16_t len
= ntohs(inst
->len
);
998 return (!(len
% OFP11_INSTRUCTION_ALIGN
)
999 && len
>= sizeof *inst
1000 && len
/ sizeof *inst
<= n_instructions
);
1003 /* This macro is careful to check for instructions with bad lengths. */
1004 #define INSTRUCTION_FOR_EACH(ITER, LEFT, INSTRUCTIONS, N_INSTRUCTIONS) \
1005 for ((ITER) = (INSTRUCTIONS), (LEFT) = (N_INSTRUCTIONS); \
1006 (LEFT) > 0 && instruction_is_valid(ITER, LEFT); \
1007 ((LEFT) -= (ntohs((ITER)->len) \
1008 / sizeof(struct ofp11_instruction)), \
1009 (ITER) = instruction_next(ITER)))
1012 decode_openflow11_instruction(const struct ofp11_instruction
*inst
,
1013 enum ovs_instruction_type
*type
)
1015 uint16_t len
= ntohs(inst
->len
);
1017 switch (inst
->type
) {
1018 case CONSTANT_HTONS(OFPIT11_EXPERIMENTER
):
1019 return OFPERR_OFPBIC_BAD_EXPERIMENTER
;
1021 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME) \
1022 case CONSTANT_HTONS(ENUM): \
1024 ? len >= sizeof(struct STRUCT) \
1025 : len == sizeof(struct STRUCT)) { \
1026 *type = OVSINST_##ENUM; \
1029 return OFPERR_OFPBIC_BAD_LEN; \
1035 return OFPERR_OFPBIC_UNKNOWN_INST
;
1040 decode_openflow11_instructions(const struct ofp11_instruction insts
[],
1042 const struct ofp11_instruction
*out
[])
1044 const struct ofp11_instruction
*inst
;
1047 memset(out
, 0, N_OVS_INSTRUCTIONS
* sizeof *out
);
1048 INSTRUCTION_FOR_EACH (inst
, left
, insts
, n_insts
) {
1049 enum ovs_instruction_type type
;
1052 error
= decode_openflow11_instruction(inst
, &type
);
1058 return OFPERR_ONFBIC_DUP_INSTRUCTION
;
1064 VLOG_WARN_RL(&rl
, "bad instruction format at offset %zu",
1065 (n_insts
- left
) * sizeof *inst
);
1066 return OFPERR_OFPBIC_BAD_LEN
;
1072 get_actions_from_instruction(const struct ofp11_instruction
*inst
,
1073 const union ofp_action
**actions
,
1076 *actions
= (const union ofp_action
*) (inst
+ 1);
1077 *n_actions
= (ntohs(inst
->len
) - sizeof *inst
) / OFP11_INSTRUCTION_ALIGN
;
1080 /* Attempts to convert 'actions_len' bytes of OpenFlow 1.1 actions from the
1081 * front of 'openflow' into ofpacts. On success, replaces any existing content
1082 * in 'ofpacts' by the converted ofpacts; on failure, clears 'ofpacts'.
1083 * Returns 0 if successful, otherwise an OpenFlow error.
1085 * In most places in OpenFlow 1.1 and 1.2, actions appear encapsulated in
1086 * instructions, so you should call ofpacts_pull_openflow11_instructions()
1087 * instead of this function.
1089 * The parsed actions are valid generically, but they may not be valid in a
1090 * specific context. For example, port numbers up to OFPP_MAX are valid
1091 * generically, but specific datapaths may only support port numbers in a
1092 * smaller range. Use ofpacts_check() to additional check whether actions are
1093 * valid in a specific context. */
1095 ofpacts_pull_openflow11_actions(struct ofpbuf
*openflow
,
1096 unsigned int actions_len
,
1097 struct ofpbuf
*ofpacts
)
1099 return ofpacts_pull_actions(openflow
, actions_len
, ofpacts
,
1100 ofpacts_from_openflow11
);
1104 ofpacts_pull_openflow11_instructions(struct ofpbuf
*openflow
,
1105 unsigned int instructions_len
,
1107 struct ofpbuf
*ofpacts
)
1109 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
1110 const struct ofp11_instruction
*instructions
;
1111 const struct ofp11_instruction
*insts
[N_OVS_INSTRUCTIONS
];
1114 ofpbuf_clear(ofpacts
);
1116 if (instructions_len
% OFP11_INSTRUCTION_ALIGN
!= 0) {
1117 VLOG_WARN_RL(&rl
, "OpenFlow message instructions length %u is not a "
1119 instructions_len
, OFP11_INSTRUCTION_ALIGN
);
1120 error
= OFPERR_OFPBIC_BAD_LEN
;
1124 instructions
= ofpbuf_try_pull(openflow
, instructions_len
);
1125 if (instructions
== NULL
) {
1126 VLOG_WARN_RL(&rl
, "OpenFlow message instructions length %u exceeds "
1127 "remaining message length (%zu)",
1128 instructions_len
, openflow
->size
);
1129 error
= OFPERR_OFPBIC_BAD_LEN
;
1133 error
= decode_openflow11_instructions(
1134 instructions
, instructions_len
/ OFP11_INSTRUCTION_ALIGN
,
1140 if (insts
[OVSINST_OFPIT13_METER
]) {
1141 const struct ofp13_instruction_meter
*oim
;
1142 struct ofpact_meter
*om
;
1144 oim
= (const struct ofp13_instruction_meter
*)
1145 insts
[OVSINST_OFPIT13_METER
];
1147 om
= ofpact_put_METER(ofpacts
);
1148 om
->meter_id
= ntohl(oim
->meter_id
);
1150 if (insts
[OVSINST_OFPIT11_APPLY_ACTIONS
]) {
1151 const union ofp_action
*actions
;
1154 get_actions_from_instruction(insts
[OVSINST_OFPIT11_APPLY_ACTIONS
],
1155 &actions
, &n_actions
);
1156 error
= ofpacts_from_openflow11(actions
, n_actions
, ofpacts
);
1161 if (insts
[OVSINST_OFPIT11_CLEAR_ACTIONS
]) {
1162 instruction_get_OFPIT11_CLEAR_ACTIONS(
1163 insts
[OVSINST_OFPIT11_CLEAR_ACTIONS
]);
1164 ofpact_put_CLEAR_ACTIONS(ofpacts
);
1166 /* XXX Write-Actions */
1167 if (insts
[OVSINST_OFPIT11_WRITE_METADATA
]) {
1168 const struct ofp11_instruction_write_metadata
*oiwm
;
1169 struct ofpact_metadata
*om
;
1171 oiwm
= (const struct ofp11_instruction_write_metadata
*)
1172 insts
[OVSINST_OFPIT11_WRITE_METADATA
];
1174 om
= ofpact_put_WRITE_METADATA(ofpacts
);
1175 om
->metadata
= oiwm
->metadata
;
1176 om
->mask
= oiwm
->metadata_mask
;
1178 if (insts
[OVSINST_OFPIT11_GOTO_TABLE
]) {
1179 const struct ofp11_instruction_goto_table
*oigt
;
1180 struct ofpact_goto_table
*ogt
;
1182 oigt
= instruction_get_OFPIT11_GOTO_TABLE(
1183 insts
[OVSINST_OFPIT11_GOTO_TABLE
]);
1184 if (table_id
>= oigt
->table_id
) {
1185 error
= OFPERR_OFPBRC_BAD_TABLE_ID
;
1188 ogt
= ofpact_put_GOTO_TABLE(ofpacts
);
1189 ogt
->table_id
= oigt
->table_id
;
1192 if (insts
[OVSINST_OFPIT11_WRITE_ACTIONS
]) {
1193 error
= OFPERR_OFPBIC_UNSUP_INST
;
1197 error
= ofpacts_verify(ofpacts
->data
, ofpacts
->size
);
1200 ofpbuf_clear(ofpacts
);
1205 /* May modify flow->dl_type, caller must restore it. */
1207 ofpact_check__(const struct ofpact
*a
, struct flow
*flow
, ofp_port_t max_ports
)
1209 const struct ofpact_enqueue
*enqueue
;
1213 return ofputil_check_output_port(ofpact_get_OUTPUT(a
)->port
,
1216 case OFPACT_CONTROLLER
:
1219 case OFPACT_ENQUEUE
:
1220 enqueue
= ofpact_get_ENQUEUE(a
);
1221 if (ofp_to_u16(enqueue
->port
) >= ofp_to_u16(max_ports
)
1222 && enqueue
->port
!= OFPP_IN_PORT
1223 && enqueue
->port
!= OFPP_LOCAL
) {
1224 return OFPERR_OFPBAC_BAD_OUT_PORT
;
1228 case OFPACT_OUTPUT_REG
:
1229 return mf_check_src(&ofpact_get_OUTPUT_REG(a
)->src
, flow
);
1232 return bundle_check(ofpact_get_BUNDLE(a
), max_ports
, flow
);
1234 case OFPACT_SET_VLAN_VID
:
1235 case OFPACT_SET_VLAN_PCP
:
1236 case OFPACT_STRIP_VLAN
:
1237 case OFPACT_PUSH_VLAN
:
1238 case OFPACT_SET_ETH_SRC
:
1239 case OFPACT_SET_ETH_DST
:
1240 case OFPACT_SET_IPV4_SRC
:
1241 case OFPACT_SET_IPV4_DST
:
1242 case OFPACT_SET_IPV4_DSCP
:
1243 case OFPACT_SET_L4_SRC_PORT
:
1244 case OFPACT_SET_L4_DST_PORT
:
1247 case OFPACT_REG_MOVE
:
1248 return nxm_reg_move_check(ofpact_get_REG_MOVE(a
), flow
);
1250 case OFPACT_REG_LOAD
:
1251 return nxm_reg_load_check(ofpact_get_REG_LOAD(a
), flow
);
1253 case OFPACT_STACK_PUSH
:
1254 return nxm_stack_push_check(ofpact_get_STACK_PUSH(a
), flow
);
1256 case OFPACT_STACK_POP
:
1257 return nxm_stack_pop_check(ofpact_get_STACK_POP(a
), flow
);
1259 case OFPACT_DEC_TTL
:
1260 case OFPACT_SET_MPLS_TTL
:
1261 case OFPACT_DEC_MPLS_TTL
:
1262 case OFPACT_SET_TUNNEL
:
1263 case OFPACT_SET_QUEUE
:
1264 case OFPACT_POP_QUEUE
:
1265 case OFPACT_FIN_TIMEOUT
:
1266 case OFPACT_RESUBMIT
:
1270 return learn_check(ofpact_get_LEARN(a
), flow
);
1272 case OFPACT_MULTIPATH
:
1273 return multipath_check(ofpact_get_MULTIPATH(a
), flow
);
1279 case OFPACT_PUSH_MPLS
:
1280 flow
->dl_type
= ofpact_get_PUSH_MPLS(a
)->ethertype
;
1283 case OFPACT_POP_MPLS
:
1284 flow
->dl_type
= ofpact_get_POP_MPLS(a
)->ethertype
;
1290 case OFPACT_CLEAR_ACTIONS
:
1291 case OFPACT_WRITE_METADATA
:
1292 case OFPACT_GOTO_TABLE
:
1295 case OFPACT_METER
: {
1296 uint32_t mid
= ofpact_get_METER(a
)->meter_id
;
1297 if (mid
== 0 || mid
> OFPM13_MAX
) {
1298 return OFPERR_OFPMMFC_INVALID_METER
;
1307 /* Checks that the 'ofpacts_len' bytes of actions in 'ofpacts' are
1308 * appropriate for a packet with the prerequisites satisfied by 'flow' in a
1309 * switch with no more than 'max_ports' ports.
1311 * May temporarily modify 'flow', but restores the changes before returning. */
1313 ofpacts_check(const struct ofpact ofpacts
[], size_t ofpacts_len
,
1314 struct flow
*flow
, ofp_port_t max_ports
)
1316 const struct ofpact
*a
;
1317 ovs_be16 dl_type
= flow
->dl_type
;
1318 enum ofperr error
= 0;
1320 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
1321 error
= ofpact_check__(a
, flow
, max_ports
);
1326 flow
->dl_type
= dl_type
; /* Restore. */
1330 /* Verifies that the 'ofpacts_len' bytes of actions in 'ofpacts' are
1331 * in the appropriate order as defined by the OpenFlow spec. */
1333 ofpacts_verify(const struct ofpact ofpacts
[], size_t ofpacts_len
)
1335 const struct ofpact
*a
;
1336 enum ovs_instruction_type inst
;
1338 inst
= OVSINST_OFPIT11_APPLY_ACTIONS
;
1339 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
1340 enum ovs_instruction_type next
;
1342 next
= ovs_instruction_type_from_ofpact_type(a
->type
);
1343 if (inst
!= OVSINST_OFPIT11_APPLY_ACTIONS
&& next
<= inst
) {
1344 const char *name
= ovs_instruction_name_from_type(inst
);
1345 const char *next_name
= ovs_instruction_name_from_type(next
);
1348 VLOG_WARN("duplicate %s instruction not allowed, for OpenFlow "
1349 "1.1+ compatibility", name
);
1351 VLOG_WARN("invalid instruction ordering: %s must appear "
1352 "before %s, for OpenFlow 1.1+ compatibility",
1355 return OFPERR_OFPBAC_UNSUPPORTED_ORDER
;
1364 /* Converting ofpacts to Nicira OpenFlow extensions. */
1367 ofpact_output_reg_to_nxast(const struct ofpact_output_reg
*output_reg
,
1370 struct nx_action_output_reg
*naor
= ofputil_put_NXAST_OUTPUT_REG(out
);
1372 naor
->ofs_nbits
= nxm_encode_ofs_nbits(output_reg
->src
.ofs
,
1373 output_reg
->src
.n_bits
);
1374 naor
->src
= htonl(output_reg
->src
.field
->nxm_header
);
1375 naor
->max_len
= htons(output_reg
->max_len
);
1379 ofpact_resubmit_to_nxast(const struct ofpact_resubmit
*resubmit
,
1382 struct nx_action_resubmit
*nar
;
1384 if (resubmit
->table_id
== 0xff
1385 && resubmit
->ofpact
.compat
!= OFPUTIL_NXAST_RESUBMIT_TABLE
) {
1386 nar
= ofputil_put_NXAST_RESUBMIT(out
);
1388 nar
= ofputil_put_NXAST_RESUBMIT_TABLE(out
);
1389 nar
->table
= resubmit
->table_id
;
1391 nar
->in_port
= htons(ofp_to_u16(resubmit
->in_port
));
1395 ofpact_set_tunnel_to_nxast(const struct ofpact_tunnel
*tunnel
,
1398 uint64_t tun_id
= tunnel
->tun_id
;
1400 if (tun_id
<= UINT32_MAX
1401 && tunnel
->ofpact
.compat
!= OFPUTIL_NXAST_SET_TUNNEL64
) {
1402 ofputil_put_NXAST_SET_TUNNEL(out
)->tun_id
= htonl(tun_id
);
1404 ofputil_put_NXAST_SET_TUNNEL64(out
)->tun_id
= htonll(tun_id
);
1409 ofpact_write_metadata_to_nxast(const struct ofpact_metadata
*om
,
1412 struct nx_action_write_metadata
*nawm
;
1414 nawm
= ofputil_put_NXAST_WRITE_METADATA(out
);
1415 nawm
->metadata
= om
->metadata
;
1416 nawm
->mask
= om
->mask
;
1420 ofpact_note_to_nxast(const struct ofpact_note
*note
, struct ofpbuf
*out
)
1422 size_t start_ofs
= out
->size
;
1423 struct nx_action_note
*nan
;
1424 unsigned int remainder
;
1427 nan
= ofputil_put_NXAST_NOTE(out
);
1428 out
->size
-= sizeof nan
->note
;
1430 ofpbuf_put(out
, note
->data
, note
->length
);
1432 len
= out
->size
- start_ofs
;
1433 remainder
= len
% OFP_ACTION_ALIGN
;
1435 ofpbuf_put_zeros(out
, OFP_ACTION_ALIGN
- remainder
);
1437 nan
= (struct nx_action_note
*)((char *)out
->data
+ start_ofs
);
1438 nan
->len
= htons(out
->size
- start_ofs
);
1442 ofpact_controller_to_nxast(const struct ofpact_controller
*oc
,
1445 struct nx_action_controller
*nac
;
1447 nac
= ofputil_put_NXAST_CONTROLLER(out
);
1448 nac
->max_len
= htons(oc
->max_len
);
1449 nac
->controller_id
= htons(oc
->controller_id
);
1450 nac
->reason
= oc
->reason
;
1454 ofpact_dec_ttl_to_nxast(const struct ofpact_cnt_ids
*oc_ids
,
1457 if (oc_ids
->ofpact
.compat
== OFPUTIL_NXAST_DEC_TTL
) {
1458 ofputil_put_NXAST_DEC_TTL(out
);
1460 struct nx_action_cnt_ids
*nac_ids
=
1461 ofputil_put_NXAST_DEC_TTL_CNT_IDS(out
);
1462 int ids_len
= ROUND_UP(2 * oc_ids
->n_controllers
, OFP_ACTION_ALIGN
);
1466 nac_ids
->len
= htons(ntohs(nac_ids
->len
) + ids_len
);
1467 nac_ids
->n_controllers
= htons(oc_ids
->n_controllers
);
1469 ids
= ofpbuf_put_zeros(out
, ids_len
);
1470 for (i
= 0; i
< oc_ids
->n_controllers
; i
++) {
1471 ids
[i
] = htons(oc_ids
->cnt_ids
[i
]);
1477 ofpact_fin_timeout_to_nxast(const struct ofpact_fin_timeout
*fin_timeout
,
1480 struct nx_action_fin_timeout
*naft
= ofputil_put_NXAST_FIN_TIMEOUT(out
);
1481 naft
->fin_idle_timeout
= htons(fin_timeout
->fin_idle_timeout
);
1482 naft
->fin_hard_timeout
= htons(fin_timeout
->fin_hard_timeout
);
1486 ofpact_sample_to_nxast(const struct ofpact_sample
*os
,
1489 struct nx_action_sample
*nas
;
1491 nas
= ofputil_put_NXAST_SAMPLE(out
);
1492 nas
->probability
= htons(os
->probability
);
1493 nas
->collector_set_id
= htonl(os
->collector_set_id
);
1494 nas
->obs_domain_id
= htonl(os
->obs_domain_id
);
1495 nas
->obs_point_id
= htonl(os
->obs_point_id
);
1499 ofpact_to_nxast(const struct ofpact
*a
, struct ofpbuf
*out
)
1502 case OFPACT_CONTROLLER
:
1503 ofpact_controller_to_nxast(ofpact_get_CONTROLLER(a
), out
);
1506 case OFPACT_OUTPUT_REG
:
1507 ofpact_output_reg_to_nxast(ofpact_get_OUTPUT_REG(a
), out
);
1511 bundle_to_nxast(ofpact_get_BUNDLE(a
), out
);
1514 case OFPACT_REG_MOVE
:
1515 nxm_reg_move_to_nxast(ofpact_get_REG_MOVE(a
), out
);
1518 case OFPACT_REG_LOAD
:
1519 nxm_reg_load_to_nxast(ofpact_get_REG_LOAD(a
), out
);
1522 case OFPACT_STACK_PUSH
:
1523 nxm_stack_push_to_nxast(ofpact_get_STACK_PUSH(a
), out
);
1526 case OFPACT_STACK_POP
:
1527 nxm_stack_pop_to_nxast(ofpact_get_STACK_POP(a
), out
);
1530 case OFPACT_DEC_TTL
:
1531 ofpact_dec_ttl_to_nxast(ofpact_get_DEC_TTL(a
), out
);
1534 case OFPACT_SET_MPLS_TTL
:
1535 ofputil_put_NXAST_SET_MPLS_TTL(out
)->ttl
1536 = ofpact_get_SET_MPLS_TTL(a
)->ttl
;
1539 case OFPACT_DEC_MPLS_TTL
:
1540 ofputil_put_NXAST_DEC_MPLS_TTL(out
);
1543 case OFPACT_SET_TUNNEL
:
1544 ofpact_set_tunnel_to_nxast(ofpact_get_SET_TUNNEL(a
), out
);
1547 case OFPACT_WRITE_METADATA
:
1548 ofpact_write_metadata_to_nxast(ofpact_get_WRITE_METADATA(a
), out
);
1551 case OFPACT_SET_QUEUE
:
1552 ofputil_put_NXAST_SET_QUEUE(out
)->queue_id
1553 = htonl(ofpact_get_SET_QUEUE(a
)->queue_id
);
1556 case OFPACT_POP_QUEUE
:
1557 ofputil_put_NXAST_POP_QUEUE(out
);
1560 case OFPACT_FIN_TIMEOUT
:
1561 ofpact_fin_timeout_to_nxast(ofpact_get_FIN_TIMEOUT(a
), out
);
1564 case OFPACT_RESUBMIT
:
1565 ofpact_resubmit_to_nxast(ofpact_get_RESUBMIT(a
), out
);
1569 learn_to_nxast(ofpact_get_LEARN(a
), out
);
1572 case OFPACT_MULTIPATH
:
1573 multipath_to_nxast(ofpact_get_MULTIPATH(a
), out
);
1577 ofpact_note_to_nxast(ofpact_get_NOTE(a
), out
);
1581 ofputil_put_NXAST_EXIT(out
);
1584 case OFPACT_PUSH_MPLS
:
1585 ofputil_put_NXAST_PUSH_MPLS(out
)->ethertype
=
1586 ofpact_get_PUSH_MPLS(a
)->ethertype
;
1589 case OFPACT_POP_MPLS
:
1590 ofputil_put_NXAST_POP_MPLS(out
)->ethertype
=
1591 ofpact_get_POP_MPLS(a
)->ethertype
;
1595 ofpact_sample_to_nxast(ofpact_get_SAMPLE(a
), out
);
1599 case OFPACT_ENQUEUE
:
1600 case OFPACT_SET_VLAN_VID
:
1601 case OFPACT_SET_VLAN_PCP
:
1602 case OFPACT_STRIP_VLAN
:
1603 case OFPACT_PUSH_VLAN
:
1604 case OFPACT_SET_ETH_SRC
:
1605 case OFPACT_SET_ETH_DST
:
1606 case OFPACT_SET_IPV4_SRC
:
1607 case OFPACT_SET_IPV4_DST
:
1608 case OFPACT_SET_IPV4_DSCP
:
1609 case OFPACT_SET_L4_SRC_PORT
:
1610 case OFPACT_SET_L4_DST_PORT
:
1611 case OFPACT_CLEAR_ACTIONS
:
1612 case OFPACT_GOTO_TABLE
:
1618 /* Converting ofpacts to OpenFlow 1.0. */
1621 ofpact_output_to_openflow10(const struct ofpact_output
*output
,
1624 struct ofp10_action_output
*oao
;
1626 oao
= ofputil_put_OFPAT10_OUTPUT(out
);
1627 oao
->port
= htons(ofp_to_u16(output
->port
));
1628 oao
->max_len
= htons(output
->max_len
);
1632 ofpact_enqueue_to_openflow10(const struct ofpact_enqueue
*enqueue
,
1635 struct ofp10_action_enqueue
*oae
;
1637 oae
= ofputil_put_OFPAT10_ENQUEUE(out
);
1638 oae
->port
= htons(ofp_to_u16(enqueue
->port
));
1639 oae
->queue_id
= htonl(enqueue
->queue
);
1643 ofpact_to_openflow10(const struct ofpact
*a
, struct ofpbuf
*out
)
1647 ofpact_output_to_openflow10(ofpact_get_OUTPUT(a
), out
);
1650 case OFPACT_ENQUEUE
:
1651 ofpact_enqueue_to_openflow10(ofpact_get_ENQUEUE(a
), out
);
1654 case OFPACT_SET_VLAN_VID
:
1655 ofputil_put_OFPAT10_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_OFPAT10_SET_VLAN_PCP(out
)->vlan_pcp
1661 = ofpact_get_SET_VLAN_PCP(a
)->vlan_pcp
;
1664 case OFPACT_STRIP_VLAN
:
1665 ofputil_put_OFPAT10_STRIP_VLAN(out
);
1668 case OFPACT_SET_ETH_SRC
:
1669 memcpy(ofputil_put_OFPAT10_SET_DL_SRC(out
)->dl_addr
,
1670 ofpact_get_SET_ETH_SRC(a
)->mac
, ETH_ADDR_LEN
);
1673 case OFPACT_SET_ETH_DST
:
1674 memcpy(ofputil_put_OFPAT10_SET_DL_DST(out
)->dl_addr
,
1675 ofpact_get_SET_ETH_DST(a
)->mac
, ETH_ADDR_LEN
);
1678 case OFPACT_SET_IPV4_SRC
:
1679 ofputil_put_OFPAT10_SET_NW_SRC(out
)->nw_addr
1680 = ofpact_get_SET_IPV4_SRC(a
)->ipv4
;
1683 case OFPACT_SET_IPV4_DST
:
1684 ofputil_put_OFPAT10_SET_NW_DST(out
)->nw_addr
1685 = ofpact_get_SET_IPV4_DST(a
)->ipv4
;
1688 case OFPACT_SET_IPV4_DSCP
:
1689 ofputil_put_OFPAT10_SET_NW_TOS(out
)->nw_tos
1690 = ofpact_get_SET_IPV4_DSCP(a
)->dscp
;
1693 case OFPACT_SET_L4_SRC_PORT
:
1694 ofputil_put_OFPAT10_SET_TP_SRC(out
)->tp_port
1695 = htons(ofpact_get_SET_L4_SRC_PORT(a
)->port
);
1698 case OFPACT_SET_L4_DST_PORT
:
1699 ofputil_put_OFPAT10_SET_TP_DST(out
)->tp_port
1700 = htons(ofpact_get_SET_L4_DST_PORT(a
)->port
);
1703 case OFPACT_PUSH_VLAN
:
1704 case OFPACT_CLEAR_ACTIONS
:
1705 case OFPACT_GOTO_TABLE
:
1710 case OFPACT_CONTROLLER
:
1711 case OFPACT_OUTPUT_REG
:
1713 case OFPACT_REG_MOVE
:
1714 case OFPACT_REG_LOAD
:
1715 case OFPACT_STACK_PUSH
:
1716 case OFPACT_STACK_POP
:
1717 case OFPACT_DEC_TTL
:
1718 case OFPACT_SET_MPLS_TTL
:
1719 case OFPACT_DEC_MPLS_TTL
:
1720 case OFPACT_SET_TUNNEL
:
1721 case OFPACT_WRITE_METADATA
:
1722 case OFPACT_SET_QUEUE
:
1723 case OFPACT_POP_QUEUE
:
1724 case OFPACT_FIN_TIMEOUT
:
1725 case OFPACT_RESUBMIT
:
1727 case OFPACT_MULTIPATH
:
1730 case OFPACT_PUSH_MPLS
:
1731 case OFPACT_POP_MPLS
:
1733 ofpact_to_nxast(a
, out
);
1738 /* Converts the 'ofpacts_len' bytes of ofpacts in 'ofpacts' into OpenFlow 1.0
1739 * actions in 'openflow', appending the actions to any existing data in
1742 ofpacts_put_openflow10(const struct ofpact ofpacts
[], size_t ofpacts_len
,
1743 struct ofpbuf
*openflow
)
1745 const struct ofpact
*a
;
1747 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
1748 ofpact_to_openflow10(a
, openflow
);
1752 /* Converting ofpacts to OpenFlow 1.1. */
1755 ofpact_output_to_openflow11(const struct ofpact_output
*output
,
1758 struct ofp11_action_output
*oao
;
1760 oao
= ofputil_put_OFPAT11_OUTPUT(out
);
1761 oao
->port
= ofputil_port_to_ofp11(output
->port
);
1762 oao
->max_len
= htons(output
->max_len
);
1766 ofpact_dec_ttl_to_openflow11(const struct ofpact_cnt_ids
*dec_ttl
,
1769 if (dec_ttl
->n_controllers
== 1 && dec_ttl
->cnt_ids
[0] == 0
1770 && (!dec_ttl
->ofpact
.compat
||
1771 dec_ttl
->ofpact
.compat
== OFPUTIL_OFPAT11_DEC_NW_TTL
)) {
1772 ofputil_put_OFPAT11_DEC_NW_TTL(out
);
1774 ofpact_dec_ttl_to_nxast(dec_ttl
, out
);
1779 ofpact_to_openflow11(const struct ofpact
*a
, struct ofpbuf
*out
)
1783 return ofpact_output_to_openflow11(ofpact_get_OUTPUT(a
), out
);
1785 case OFPACT_ENQUEUE
:
1789 case OFPACT_SET_VLAN_VID
:
1790 ofputil_put_OFPAT11_SET_VLAN_VID(out
)->vlan_vid
1791 = htons(ofpact_get_SET_VLAN_VID(a
)->vlan_vid
);
1794 case OFPACT_SET_VLAN_PCP
:
1795 ofputil_put_OFPAT11_SET_VLAN_PCP(out
)->vlan_pcp
1796 = ofpact_get_SET_VLAN_PCP(a
)->vlan_pcp
;
1799 case OFPACT_STRIP_VLAN
:
1800 ofputil_put_OFPAT11_POP_VLAN(out
);
1803 case OFPACT_PUSH_VLAN
:
1804 /* XXX ETH_TYPE_VLAN_8021AD case */
1805 ofputil_put_OFPAT11_PUSH_VLAN(out
)->ethertype
=
1806 htons(ETH_TYPE_VLAN_8021Q
);
1809 case OFPACT_SET_QUEUE
:
1810 ofputil_put_OFPAT11_SET_QUEUE(out
)->queue_id
1811 = htonl(ofpact_get_SET_QUEUE(a
)->queue_id
);
1814 case OFPACT_SET_ETH_SRC
:
1815 memcpy(ofputil_put_OFPAT11_SET_DL_SRC(out
)->dl_addr
,
1816 ofpact_get_SET_ETH_SRC(a
)->mac
, ETH_ADDR_LEN
);
1819 case OFPACT_SET_ETH_DST
:
1820 memcpy(ofputil_put_OFPAT11_SET_DL_DST(out
)->dl_addr
,
1821 ofpact_get_SET_ETH_DST(a
)->mac
, ETH_ADDR_LEN
);
1824 case OFPACT_SET_IPV4_SRC
:
1825 ofputil_put_OFPAT11_SET_NW_SRC(out
)->nw_addr
1826 = ofpact_get_SET_IPV4_SRC(a
)->ipv4
;
1829 case OFPACT_SET_IPV4_DST
:
1830 ofputil_put_OFPAT11_SET_NW_DST(out
)->nw_addr
1831 = ofpact_get_SET_IPV4_DST(a
)->ipv4
;
1834 case OFPACT_SET_IPV4_DSCP
:
1835 ofputil_put_OFPAT11_SET_NW_TOS(out
)->nw_tos
1836 = ofpact_get_SET_IPV4_DSCP(a
)->dscp
;
1839 case OFPACT_SET_L4_SRC_PORT
:
1840 ofputil_put_OFPAT11_SET_TP_SRC(out
)->tp_port
1841 = htons(ofpact_get_SET_L4_SRC_PORT(a
)->port
);
1844 case OFPACT_SET_L4_DST_PORT
:
1845 ofputil_put_OFPAT11_SET_TP_DST(out
)->tp_port
1846 = htons(ofpact_get_SET_L4_DST_PORT(a
)->port
);
1849 case OFPACT_DEC_TTL
:
1850 ofpact_dec_ttl_to_openflow11(ofpact_get_DEC_TTL(a
), out
);
1853 case OFPACT_SET_MPLS_TTL
:
1854 ofputil_put_OFPAT11_SET_MPLS_TTL(out
)->mpls_ttl
1855 = ofpact_get_SET_MPLS_TTL(a
)->ttl
;
1858 case OFPACT_DEC_MPLS_TTL
:
1859 ofputil_put_OFPAT11_DEC_MPLS_TTL(out
);
1862 case OFPACT_WRITE_METADATA
:
1863 /* OpenFlow 1.1 uses OFPIT_WRITE_METADATA to express this action. */
1866 case OFPACT_PUSH_MPLS
:
1867 ofputil_put_OFPAT11_PUSH_MPLS(out
)->ethertype
=
1868 ofpact_get_PUSH_MPLS(a
)->ethertype
;
1871 case OFPACT_POP_MPLS
:
1872 ofputil_put_OFPAT11_POP_MPLS(out
)->ethertype
=
1873 ofpact_get_POP_MPLS(a
)->ethertype
;
1877 case OFPACT_CLEAR_ACTIONS
:
1878 case OFPACT_GOTO_TABLE
:
1882 case OFPACT_CONTROLLER
:
1883 case OFPACT_OUTPUT_REG
:
1885 case OFPACT_REG_MOVE
:
1886 case OFPACT_REG_LOAD
:
1887 case OFPACT_STACK_PUSH
:
1888 case OFPACT_STACK_POP
:
1889 case OFPACT_SET_TUNNEL
:
1890 case OFPACT_POP_QUEUE
:
1891 case OFPACT_FIN_TIMEOUT
:
1892 case OFPACT_RESUBMIT
:
1894 case OFPACT_MULTIPATH
:
1898 ofpact_to_nxast(a
, out
);
1903 /* Converts the ofpacts in 'ofpacts' (terminated by OFPACT_END) into OpenFlow
1904 * 1.1 actions in 'openflow', appending the actions to any existing data in
1907 ofpacts_put_openflow11_actions(const struct ofpact ofpacts
[],
1908 size_t ofpacts_len
, struct ofpbuf
*openflow
)
1910 const struct ofpact
*a
;
1911 size_t start_size
= openflow
->size
;
1913 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
1914 ofpact_to_openflow11(a
, openflow
);
1917 return openflow
->size
- start_size
;
1921 ofpacts_update_instruction_actions(struct ofpbuf
*openflow
, size_t ofs
)
1923 struct ofp11_instruction_actions
*oia
;
1925 /* Update the instruction's length (or, if it's empty, delete it). */
1926 oia
= ofpbuf_at_assert(openflow
, ofs
, sizeof *oia
);
1927 if (openflow
->size
> ofs
+ sizeof *oia
) {
1928 oia
->len
= htons(openflow
->size
- ofs
);
1930 openflow
->size
= ofs
;
1935 ofpacts_put_openflow11_instructions(const struct ofpact ofpacts
[],
1937 struct ofpbuf
*openflow
)
1939 const struct ofpact
*a
;
1941 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
1942 switch (ovs_instruction_type_from_ofpact_type(a
->type
)) {
1943 case OVSINST_OFPIT11_CLEAR_ACTIONS
:
1944 instruction_put_OFPIT11_CLEAR_ACTIONS(openflow
);
1947 case OVSINST_OFPIT11_GOTO_TABLE
: {
1948 struct ofp11_instruction_goto_table
*oigt
;
1949 oigt
= instruction_put_OFPIT11_GOTO_TABLE(openflow
);
1950 oigt
->table_id
= ofpact_get_GOTO_TABLE(a
)->table_id
;
1951 memset(oigt
->pad
, 0, sizeof oigt
->pad
);
1955 case OVSINST_OFPIT11_WRITE_METADATA
: {
1956 const struct ofpact_metadata
*om
;
1957 struct ofp11_instruction_write_metadata
*oiwm
;
1959 om
= ofpact_get_WRITE_METADATA(a
);
1960 oiwm
= instruction_put_OFPIT11_WRITE_METADATA(openflow
);
1961 oiwm
->metadata
= om
->metadata
;
1962 oiwm
->metadata_mask
= om
->mask
;
1966 case OVSINST_OFPIT13_METER
: {
1967 const struct ofpact_meter
*om
;
1968 struct ofp13_instruction_meter
*oim
;
1970 om
= ofpact_get_METER(a
);
1971 oim
= instruction_put_OFPIT13_METER(openflow
);
1972 oim
->meter_id
= htonl(om
->meter_id
);
1976 case OVSINST_OFPIT11_APPLY_ACTIONS
: {
1977 const size_t ofs
= openflow
->size
;
1978 const size_t ofpacts_len_left
=
1979 (uint8_t*)ofpact_end(ofpacts
, ofpacts_len
) - (uint8_t*)a
;
1980 const struct ofpact
*action
;
1981 const struct ofpact
*processed
= a
;
1983 instruction_put_OFPIT11_APPLY_ACTIONS(openflow
);
1984 OFPACT_FOR_EACH(action
, a
, ofpacts_len_left
) {
1985 if (ovs_instruction_type_from_ofpact_type(action
->type
)
1986 != OVSINST_OFPIT11_APPLY_ACTIONS
) {
1989 ofpact_to_openflow11(action
, openflow
);
1992 ofpacts_update_instruction_actions(openflow
, ofs
);
1997 case OVSINST_OFPIT11_WRITE_ACTIONS
:
2003 /* Returns true if 'action' outputs to 'port', false otherwise. */
2005 ofpact_outputs_to_port(const struct ofpact
*ofpact
, ofp_port_t port
)
2007 switch (ofpact
->type
) {
2009 return ofpact_get_OUTPUT(ofpact
)->port
== port
;
2010 case OFPACT_ENQUEUE
:
2011 return ofpact_get_ENQUEUE(ofpact
)->port
== port
;
2012 case OFPACT_CONTROLLER
:
2013 return port
== OFPP_CONTROLLER
;
2015 case OFPACT_OUTPUT_REG
:
2017 case OFPACT_SET_VLAN_VID
:
2018 case OFPACT_SET_VLAN_PCP
:
2019 case OFPACT_STRIP_VLAN
:
2020 case OFPACT_PUSH_VLAN
:
2021 case OFPACT_SET_ETH_SRC
:
2022 case OFPACT_SET_ETH_DST
:
2023 case OFPACT_SET_IPV4_SRC
:
2024 case OFPACT_SET_IPV4_DST
:
2025 case OFPACT_SET_IPV4_DSCP
:
2026 case OFPACT_SET_L4_SRC_PORT
:
2027 case OFPACT_SET_L4_DST_PORT
:
2028 case OFPACT_REG_MOVE
:
2029 case OFPACT_REG_LOAD
:
2030 case OFPACT_STACK_PUSH
:
2031 case OFPACT_STACK_POP
:
2032 case OFPACT_DEC_TTL
:
2033 case OFPACT_SET_MPLS_TTL
:
2034 case OFPACT_DEC_MPLS_TTL
:
2035 case OFPACT_SET_TUNNEL
:
2036 case OFPACT_WRITE_METADATA
:
2037 case OFPACT_SET_QUEUE
:
2038 case OFPACT_POP_QUEUE
:
2039 case OFPACT_FIN_TIMEOUT
:
2040 case OFPACT_RESUBMIT
:
2042 case OFPACT_MULTIPATH
:
2045 case OFPACT_PUSH_MPLS
:
2046 case OFPACT_POP_MPLS
:
2048 case OFPACT_CLEAR_ACTIONS
:
2049 case OFPACT_GOTO_TABLE
:
2056 /* Returns true if any action in the 'ofpacts_len' bytes of 'ofpacts' outputs
2057 * to 'port', false otherwise. */
2059 ofpacts_output_to_port(const struct ofpact
*ofpacts
, size_t ofpacts_len
,
2062 const struct ofpact
*a
;
2064 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
2065 if (ofpact_outputs_to_port(a
, port
)) {
2074 ofpacts_equal(const struct ofpact
*a
, size_t a_len
,
2075 const struct ofpact
*b
, size_t b_len
)
2077 return a_len
== b_len
&& !memcmp(a
, b
, a_len
);
2080 /* Formatting ofpacts. */
2083 print_note(const struct ofpact_note
*note
, struct ds
*string
)
2087 ds_put_cstr(string
, "note:");
2088 for (i
= 0; i
< note
->length
; i
++) {
2090 ds_put_char(string
, '.');
2092 ds_put_format(string
, "%02"PRIx8
, note
->data
[i
]);
2097 print_dec_ttl(const struct ofpact_cnt_ids
*ids
,
2102 ds_put_cstr(s
, "dec_ttl");
2103 if (ids
->ofpact
.compat
== OFPUTIL_NXAST_DEC_TTL_CNT_IDS
) {
2104 ds_put_cstr(s
, "(");
2105 for (i
= 0; i
< ids
->n_controllers
; i
++) {
2107 ds_put_cstr(s
, ",");
2109 ds_put_format(s
, "%"PRIu16
, ids
->cnt_ids
[i
]);
2111 ds_put_cstr(s
, ")");
2116 print_fin_timeout(const struct ofpact_fin_timeout
*fin_timeout
,
2119 ds_put_cstr(s
, "fin_timeout(");
2120 if (fin_timeout
->fin_idle_timeout
) {
2121 ds_put_format(s
, "idle_timeout=%"PRIu16
",",
2122 fin_timeout
->fin_idle_timeout
);
2124 if (fin_timeout
->fin_hard_timeout
) {
2125 ds_put_format(s
, "hard_timeout=%"PRIu16
",",
2126 fin_timeout
->fin_hard_timeout
);
2129 ds_put_char(s
, ')');
2133 ofpact_format(const struct ofpact
*a
, struct ds
*s
)
2135 const struct ofpact_enqueue
*enqueue
;
2136 const struct ofpact_resubmit
*resubmit
;
2137 const struct ofpact_controller
*controller
;
2138 const struct ofpact_metadata
*metadata
;
2139 const struct ofpact_tunnel
*tunnel
;
2140 const struct ofpact_sample
*sample
;
2145 port
= ofpact_get_OUTPUT(a
)->port
;
2146 if (ofp_to_u16(port
) < ofp_to_u16(OFPP_MAX
)) {
2147 ds_put_format(s
, "output:%"PRIu16
, port
);
2149 ofputil_format_port(port
, s
);
2150 if (port
== OFPP_CONTROLLER
) {
2151 ds_put_format(s
, ":%"PRIu16
, ofpact_get_OUTPUT(a
)->max_len
);
2156 case OFPACT_CONTROLLER
:
2157 controller
= ofpact_get_CONTROLLER(a
);
2158 if (controller
->reason
== OFPR_ACTION
&&
2159 controller
->controller_id
== 0) {
2160 ds_put_format(s
, "CONTROLLER:%"PRIu16
,
2161 ofpact_get_CONTROLLER(a
)->max_len
);
2163 enum ofp_packet_in_reason reason
= controller
->reason
;
2165 ds_put_cstr(s
, "controller(");
2166 if (reason
!= OFPR_ACTION
) {
2167 char reasonbuf
[OFPUTIL_PACKET_IN_REASON_BUFSIZE
];
2169 ds_put_format(s
, "reason=%s,",
2170 ofputil_packet_in_reason_to_string(
2171 reason
, reasonbuf
, sizeof reasonbuf
));
2173 if (controller
->max_len
!= UINT16_MAX
) {
2174 ds_put_format(s
, "max_len=%"PRIu16
",", controller
->max_len
);
2176 if (controller
->controller_id
!= 0) {
2177 ds_put_format(s
, "id=%"PRIu16
",", controller
->controller_id
);
2180 ds_put_char(s
, ')');
2184 case OFPACT_ENQUEUE
:
2185 enqueue
= ofpact_get_ENQUEUE(a
);
2186 ds_put_format(s
, "enqueue:");
2187 ofputil_format_port(enqueue
->port
, s
);
2188 ds_put_format(s
, "q%"PRIu32
, enqueue
->queue
);
2191 case OFPACT_OUTPUT_REG
:
2192 ds_put_cstr(s
, "output:");
2193 mf_format_subfield(&ofpact_get_OUTPUT_REG(a
)->src
, s
);
2197 bundle_format(ofpact_get_BUNDLE(a
), s
);
2200 case OFPACT_SET_VLAN_VID
:
2201 ds_put_format(s
, "mod_vlan_vid:%"PRIu16
,
2202 ofpact_get_SET_VLAN_VID(a
)->vlan_vid
);
2205 case OFPACT_SET_VLAN_PCP
:
2206 ds_put_format(s
, "mod_vlan_pcp:%"PRIu8
,
2207 ofpact_get_SET_VLAN_PCP(a
)->vlan_pcp
);
2210 case OFPACT_STRIP_VLAN
:
2211 ds_put_cstr(s
, "strip_vlan");
2214 case OFPACT_PUSH_VLAN
:
2215 /* XXX 802.1AD case*/
2216 ds_put_format(s
, "push_vlan:%#"PRIx16
, ETH_TYPE_VLAN_8021Q
);
2219 case OFPACT_SET_ETH_SRC
:
2220 ds_put_format(s
, "mod_dl_src:"ETH_ADDR_FMT
,
2221 ETH_ADDR_ARGS(ofpact_get_SET_ETH_SRC(a
)->mac
));
2224 case OFPACT_SET_ETH_DST
:
2225 ds_put_format(s
, "mod_dl_dst:"ETH_ADDR_FMT
,
2226 ETH_ADDR_ARGS(ofpact_get_SET_ETH_DST(a
)->mac
));
2229 case OFPACT_SET_IPV4_SRC
:
2230 ds_put_format(s
, "mod_nw_src:"IP_FMT
,
2231 IP_ARGS(ofpact_get_SET_IPV4_SRC(a
)->ipv4
));
2234 case OFPACT_SET_IPV4_DST
:
2235 ds_put_format(s
, "mod_nw_dst:"IP_FMT
,
2236 IP_ARGS(ofpact_get_SET_IPV4_DST(a
)->ipv4
));
2239 case OFPACT_SET_IPV4_DSCP
:
2240 ds_put_format(s
, "mod_nw_tos:%d", ofpact_get_SET_IPV4_DSCP(a
)->dscp
);
2243 case OFPACT_SET_L4_SRC_PORT
:
2244 ds_put_format(s
, "mod_tp_src:%d", ofpact_get_SET_L4_SRC_PORT(a
)->port
);
2247 case OFPACT_SET_L4_DST_PORT
:
2248 ds_put_format(s
, "mod_tp_dst:%d", ofpact_get_SET_L4_DST_PORT(a
)->port
);
2251 case OFPACT_REG_MOVE
:
2252 nxm_format_reg_move(ofpact_get_REG_MOVE(a
), s
);
2255 case OFPACT_REG_LOAD
:
2256 nxm_format_reg_load(ofpact_get_REG_LOAD(a
), s
);
2259 case OFPACT_STACK_PUSH
:
2260 nxm_format_stack_push(ofpact_get_STACK_PUSH(a
), s
);
2263 case OFPACT_STACK_POP
:
2264 nxm_format_stack_pop(ofpact_get_STACK_POP(a
), s
);
2267 case OFPACT_DEC_TTL
:
2268 print_dec_ttl(ofpact_get_DEC_TTL(a
), s
);
2271 case OFPACT_SET_MPLS_TTL
:
2272 ds_put_format(s
, "set_mpls_ttl(%"PRIu8
")",
2273 ofpact_get_SET_MPLS_TTL(a
)->ttl
);
2276 case OFPACT_DEC_MPLS_TTL
:
2277 ds_put_cstr(s
, "dec_mpls_ttl");
2280 case OFPACT_SET_TUNNEL
:
2281 tunnel
= ofpact_get_SET_TUNNEL(a
);
2282 ds_put_format(s
, "set_tunnel%s:%#"PRIx64
,
2283 (tunnel
->tun_id
> UINT32_MAX
2284 || a
->compat
== OFPUTIL_NXAST_SET_TUNNEL64
? "64" : ""),
2288 case OFPACT_SET_QUEUE
:
2289 ds_put_format(s
, "set_queue:%"PRIu32
,
2290 ofpact_get_SET_QUEUE(a
)->queue_id
);
2293 case OFPACT_POP_QUEUE
:
2294 ds_put_cstr(s
, "pop_queue");
2297 case OFPACT_FIN_TIMEOUT
:
2298 print_fin_timeout(ofpact_get_FIN_TIMEOUT(a
), s
);
2301 case OFPACT_RESUBMIT
:
2302 resubmit
= ofpact_get_RESUBMIT(a
);
2303 if (resubmit
->in_port
!= OFPP_IN_PORT
&& resubmit
->table_id
== 255) {
2304 ds_put_cstr(s
, "resubmit:");
2305 ofputil_format_port(resubmit
->in_port
, s
);
2307 ds_put_format(s
, "resubmit(");
2308 if (resubmit
->in_port
!= OFPP_IN_PORT
) {
2309 ofputil_format_port(resubmit
->in_port
, s
);
2311 ds_put_char(s
, ',');
2312 if (resubmit
->table_id
!= 255) {
2313 ds_put_format(s
, "%"PRIu8
, resubmit
->table_id
);
2315 ds_put_char(s
, ')');
2320 learn_format(ofpact_get_LEARN(a
), s
);
2323 case OFPACT_MULTIPATH
:
2324 multipath_format(ofpact_get_MULTIPATH(a
), s
);
2328 print_note(ofpact_get_NOTE(a
), s
);
2331 case OFPACT_PUSH_MPLS
:
2332 ds_put_format(s
, "push_mpls:0x%04"PRIx16
,
2333 ntohs(ofpact_get_PUSH_MPLS(a
)->ethertype
));
2336 case OFPACT_POP_MPLS
:
2337 ds_put_format(s
, "pop_mpls:0x%04"PRIx16
,
2338 ntohs(ofpact_get_POP_MPLS(a
)->ethertype
));
2342 ds_put_cstr(s
, "exit");
2346 sample
= ofpact_get_SAMPLE(a
);
2348 s
, "sample(probability=%"PRIu16
",collector_set_id=%"PRIu32
2349 ",obs_domain_id=%"PRIu32
",obs_point_id=%"PRIu32
")",
2350 sample
->probability
, sample
->collector_set_id
,
2351 sample
->obs_domain_id
, sample
->obs_point_id
);
2354 case OFPACT_CLEAR_ACTIONS
:
2355 ds_put_format(s
, "%s",
2356 ovs_instruction_name_from_type(
2357 OVSINST_OFPIT11_CLEAR_ACTIONS
));
2360 case OFPACT_WRITE_METADATA
:
2361 metadata
= ofpact_get_WRITE_METADATA(a
);
2362 ds_put_format(s
, "%s:%#"PRIx64
,
2363 ovs_instruction_name_from_type(
2364 OVSINST_OFPIT11_WRITE_METADATA
),
2365 ntohll(metadata
->metadata
));
2366 if (metadata
->mask
!= htonll(UINT64_MAX
)) {
2367 ds_put_format(s
, "/%#"PRIx64
, ntohll(metadata
->mask
));
2371 case OFPACT_GOTO_TABLE
:
2372 ds_put_format(s
, "%s:%"PRIu8
,
2373 ovs_instruction_name_from_type(
2374 OVSINST_OFPIT11_GOTO_TABLE
),
2375 ofpact_get_GOTO_TABLE(a
)->table_id
);
2379 ds_put_format(s
, "%s:%"PRIu32
,
2380 ovs_instruction_name_from_type(OVSINST_OFPIT13_METER
),
2381 ofpact_get_METER(a
)->meter_id
);
2386 /* Appends a string representing the 'ofpacts_len' bytes of ofpacts in
2387 * 'ofpacts' to 'string'. */
2389 ofpacts_format(const struct ofpact
*ofpacts
, size_t ofpacts_len
,
2392 ds_put_cstr(string
, "actions=");
2394 ds_put_cstr(string
, "drop");
2396 const struct ofpact
*a
;
2398 OFPACT_FOR_EACH (a
, ofpacts
, ofpacts_len
) {
2400 ds_put_cstr(string
, ",");
2403 /* XXX write-actions */
2404 ofpact_format(a
, string
);
2409 /* Internal use by helpers. */
2412 ofpact_put(struct ofpbuf
*ofpacts
, enum ofpact_type type
, size_t len
)
2414 struct ofpact
*ofpact
;
2416 ofpact_pad(ofpacts
);
2417 ofpact
= ofpacts
->l2
= ofpbuf_put_uninit(ofpacts
, len
);
2418 ofpact_init(ofpact
, type
, len
);
2423 ofpact_init(struct ofpact
*ofpact
, enum ofpact_type type
, size_t len
)
2425 memset(ofpact
, 0, len
);
2426 ofpact
->type
= type
;
2427 ofpact
->compat
= OFPUTIL_ACTION_INVALID
;
2431 /* Updates 'ofpact->len' to the number of bytes in the tail of 'ofpacts'
2432 * starting at 'ofpact'.
2434 * This is the correct way to update a variable-length ofpact's length after
2435 * adding the variable-length part of the payload. (See the large comment
2436 * near the end of ofp-actions.h for more information.) */
2438 ofpact_update_len(struct ofpbuf
*ofpacts
, struct ofpact
*ofpact
)
2440 ovs_assert(ofpact
== ofpacts
->l2
);
2441 ofpact
->len
= (char *) ofpbuf_tail(ofpacts
) - (char *) ofpact
;
2444 /* Pads out 'ofpacts' to a multiple of OFPACT_ALIGNTO bytes in length. Each
2445 * ofpact_put_<ENUM>() calls this function automatically beforehand, but the
2446 * client must call this itself after adding the final ofpact to an array of
2449 * (The consequences of failing to call this function are probably not dire.
2450 * OFPACT_FOR_EACH will calculate a pointer beyond the end of the ofpacts, but
2451 * not dereference it. That's undefined behavior, technically, but it will not
2452 * cause a real problem on common systems. Still, it seems better to call
2455 ofpact_pad(struct ofpbuf
*ofpacts
)
2457 unsigned int rem
= ofpacts
->size
% OFPACT_ALIGNTO
;
2459 ofpbuf_put_zeros(ofpacts
, OFPACT_ALIGNTO
- rem
);
2464 ofpact_set_field_init(struct ofpact_reg_load
*load
, const struct mf_field
*mf
,
2467 load
->ofpact
.compat
= OFPUTIL_OFPAT12_SET_FIELD
;
2468 load
->dst
.field
= mf
;
2470 load
->dst
.n_bits
= mf
->n_bits
;
2471 bitwise_copy(src
, mf
->n_bytes
, load
->dst
.ofs
,
2472 &load
->subvalue
, sizeof load
->subvalue
, 0, mf
->n_bits
);