single config file - LINKS get defined in conf.mk
[sliver-openvswitch.git] / lib / ofp-actions.c
1 /*
2  * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "ofp-actions.h"
19 #include "autopath.h"
20 #include "bundle.h"
21 #include "byte-order.h"
22 #include "compiler.h"
23 #include "dynamic-string.h"
24 #include "learn.h"
25 #include "meta-flow.h"
26 #include "multipath.h"
27 #include "nx-match.h"
28 #include "ofp-util.h"
29 #include "ofpbuf.h"
30 #include "vlog.h"
31
32 VLOG_DEFINE_THIS_MODULE(ofp_actions);
33
34 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
35 \f
36 /* Converting OpenFlow 1.0 to ofpacts. */
37
38 static enum ofperr
39 output_from_openflow10(const struct ofp10_action_output *oao,
40                        struct ofpbuf *out)
41 {
42     struct ofpact_output *output;
43
44     output = ofpact_put_OUTPUT(out);
45     output->port = ntohs(oao->port);
46     output->max_len = ntohs(oao->max_len);
47
48     return ofputil_check_output_port(output->port, OFPP_MAX);
49 }
50
51 static enum ofperr
52 enqueue_from_openflow10(const struct ofp_action_enqueue *oae,
53                         struct ofpbuf *out)
54 {
55     struct ofpact_enqueue *enqueue;
56
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;
63     }
64     return 0;
65 }
66
67 static void
68 resubmit_from_openflow(const struct nx_action_resubmit *nar,
69                        struct ofpbuf *out)
70 {
71     struct ofpact_resubmit *resubmit;
72
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;
77 }
78
79 static enum ofperr
80 resubmit_table_from_openflow(const struct nx_action_resubmit *nar,
81                              struct ofpbuf *out)
82 {
83     struct ofpact_resubmit *resubmit;
84
85     if (nar->pad[0] || nar->pad[1] || nar->pad[2]) {
86         return OFPERR_OFPBAC_BAD_ARGUMENT;
87     }
88
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;
93     return 0;
94 }
95
96 static enum ofperr
97 output_reg_from_openflow(const struct nx_action_output_reg *naor,
98                          struct ofpbuf *out)
99 {
100     struct ofpact_output_reg *output_reg;
101
102     if (!is_all_zeros(naor->zero, sizeof naor->zero)) {
103         return OFPERR_OFPBAC_BAD_ARGUMENT;
104     }
105
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);
111
112     return mf_check_src(&output_reg->src, NULL);
113 }
114
115 static void
116 fin_timeout_from_openflow(const struct nx_action_fin_timeout *naft,
117                           struct ofpbuf *out)
118 {
119     struct ofpact_fin_timeout *oft;
120
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);
124 }
125
126 static void
127 controller_from_openflow(const struct nx_action_controller *nac,
128                          struct ofpbuf *out)
129 {
130     struct ofpact_controller *oc;
131
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;
136 }
137
138 static void
139 note_from_openflow(const struct nx_action_note *nan, struct ofpbuf *out)
140 {
141     struct ofpact_note *note;
142     unsigned int length;
143
144     length = ntohs(nan->len) - offsetof(struct nx_action_note, note);
145     note = ofpact_put(out, OFPACT_NOTE,
146                       offsetof(struct ofpact_note, data) + length);
147     note->length = length;
148     memcpy(note->data, nan->note, length);
149 }
150
151 static enum ofperr
152 dec_ttl_from_openflow(struct ofpbuf *out)
153 {
154     uint16_t id = 0;
155     struct ofpact_cnt_ids *ids;
156     enum ofperr error = 0;
157
158     ids = ofpact_put_DEC_TTL(out);
159     ids->ofpact.compat = OFPUTIL_NXAST_DEC_TTL;
160     ids->n_controllers = 1;
161     ofpbuf_put(out, &id, sizeof id);
162     ids = out->l2;
163     ofpact_update_len(out, &ids->ofpact);
164     return error;
165 }
166
167 static enum ofperr
168 dec_ttl_cnt_ids_from_openflow(const struct nx_action_cnt_ids *nac_ids,
169                       struct ofpbuf *out)
170 {
171     struct ofpact_cnt_ids *ids;
172     size_t ids_size;
173     int i;
174
175     ids = ofpact_put_DEC_TTL(out);
176     ids->ofpact.compat = OFPUTIL_NXAST_DEC_TTL_CNT_IDS;
177     ids->n_controllers = ntohs(nac_ids->n_controllers);
178     ids_size = ntohs(nac_ids->len) - sizeof *nac_ids;
179
180     if (!is_all_zeros(nac_ids->zeros, sizeof nac_ids->zeros)) {
181         return OFPERR_NXBRC_MUST_BE_ZERO;
182     }
183
184     if (ids_size < ids->n_controllers * sizeof(ovs_be16)) {
185         VLOG_WARN_RL(&rl, "Nicira action dec_ttl_cnt_ids only has %zu bytes "
186                      "allocated for controller ids.  %zu bytes are required for "
187                      "%"PRIu16" controllers.", ids_size,
188                      ids->n_controllers * sizeof(ovs_be16), ids->n_controllers);
189         return OFPERR_OFPBAC_BAD_LEN;
190     }
191
192     for (i = 0; i < ids->n_controllers; i++) {
193         uint16_t id = ntohs(((ovs_be16 *)(nac_ids + 1))[i]);
194         ofpbuf_put(out, &id, sizeof id);
195     }
196
197     ids = out->l2;
198     ofpact_update_len(out, &ids->ofpact);
199
200     return 0;
201 }
202
203 static enum ofperr
204 decode_nxast_action(const union ofp_action *a, enum ofputil_action_code *code)
205 {
206     const struct nx_action_header *nah = (const struct nx_action_header *) a;
207     uint16_t len = ntohs(a->header.len);
208
209     if (len < sizeof(struct nx_action_header)) {
210         return OFPERR_OFPBAC_BAD_LEN;
211     } else if (a->vendor.vendor != CONSTANT_HTONL(NX_VENDOR_ID)) {
212         return OFPERR_OFPBAC_BAD_VENDOR;
213     }
214
215     switch (nah->subtype) {
216 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME)    \
217         case CONSTANT_HTONS(ENUM):                      \
218             if (EXTENSIBLE                              \
219                 ? len >= sizeof(struct STRUCT)          \
220                 : len == sizeof(struct STRUCT)) {       \
221                 *code = OFPUTIL_##ENUM;                 \
222                 return 0;                               \
223             } else {                                    \
224                 return OFPERR_OFPBAC_BAD_LEN;           \
225             }                                           \
226             NOT_REACHED();
227 #include "ofp-util.def"
228
229     case CONSTANT_HTONS(NXAST_SNAT__OBSOLETE):
230     case CONSTANT_HTONS(NXAST_DROP_SPOOFED_ARP__OBSOLETE):
231     default:
232         return OFPERR_OFPBAC_BAD_TYPE;
233     }
234 }
235
236 /* Parses 'a' to determine its type.  On success stores the correct type into
237  * '*code' and returns 0.  On failure returns an OFPERR_* error code and
238  * '*code' is indeterminate.
239  *
240  * The caller must have already verified that 'a''s length is potentially
241  * correct (that is, a->header.len is nonzero and a multiple of sizeof(union
242  * ofp_action) and no longer than the amount of space allocated to 'a').
243  *
244  * This function verifies that 'a''s length is correct for the type of action
245  * that it represents. */
246 static enum ofperr
247 decode_openflow10_action(const union ofp_action *a,
248                          enum ofputil_action_code *code)
249 {
250     switch (a->type) {
251     case CONSTANT_HTONS(OFPAT10_VENDOR):
252         return decode_nxast_action(a, code);
253
254 #define OFPAT10_ACTION(ENUM, STRUCT, NAME)                          \
255         case CONSTANT_HTONS(ENUM):                                  \
256             if (a->header.len == htons(sizeof(struct STRUCT))) {    \
257                 *code = OFPUTIL_##ENUM;                             \
258                 return 0;                                           \
259             } else {                                                \
260                 return OFPERR_OFPBAC_BAD_LEN;                       \
261             }                                                       \
262             break;
263 #include "ofp-util.def"
264
265     default:
266         return OFPERR_OFPBAC_BAD_TYPE;
267     }
268 }
269
270 static enum ofperr
271 ofpact_from_nxast(const union ofp_action *a, enum ofputil_action_code code,
272                   struct ofpbuf *out)
273 {
274     const struct nx_action_resubmit *nar;
275     const struct nx_action_set_tunnel *nast;
276     const struct nx_action_set_queue *nasq;
277     const struct nx_action_note *nan;
278     const struct nx_action_set_tunnel64 *nast64;
279     struct ofpact_tunnel *tunnel;
280     enum ofperr error = 0;
281
282     switch (code) {
283     case OFPUTIL_ACTION_INVALID:
284 #define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
285 #define OFPAT11_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
286 #include "ofp-util.def"
287         NOT_REACHED();
288
289     case OFPUTIL_NXAST_RESUBMIT:
290         resubmit_from_openflow((const struct nx_action_resubmit *) a, out);
291         break;
292
293     case OFPUTIL_NXAST_SET_TUNNEL:
294         nast = (const struct nx_action_set_tunnel *) a;
295         tunnel = ofpact_put_SET_TUNNEL(out);
296         tunnel->ofpact.compat = code;
297         tunnel->tun_id = ntohl(nast->tun_id);
298         break;
299
300     case OFPUTIL_NXAST_SET_QUEUE:
301         nasq = (const struct nx_action_set_queue *) a;
302         ofpact_put_SET_QUEUE(out)->queue_id = ntohl(nasq->queue_id);
303         break;
304
305     case OFPUTIL_NXAST_POP_QUEUE:
306         ofpact_put_POP_QUEUE(out);
307         break;
308
309     case OFPUTIL_NXAST_REG_MOVE:
310         error = nxm_reg_move_from_openflow(
311             (const struct nx_action_reg_move *) a, out);
312         break;
313
314     case OFPUTIL_NXAST_REG_LOAD:
315         error = nxm_reg_load_from_openflow(
316             (const struct nx_action_reg_load *) a, out);
317         break;
318
319     case OFPUTIL_NXAST_NOTE:
320         nan = (const struct nx_action_note *) a;
321         note_from_openflow(nan, out);
322         break;
323
324     case OFPUTIL_NXAST_SET_TUNNEL64:
325         nast64 = (const struct nx_action_set_tunnel64 *) a;
326         tunnel = ofpact_put_SET_TUNNEL(out);
327         tunnel->ofpact.compat = code;
328         tunnel->tun_id = ntohll(nast64->tun_id);
329         break;
330
331     case OFPUTIL_NXAST_MULTIPATH:
332         error = multipath_from_openflow((const struct nx_action_multipath *) a,
333                                         ofpact_put_MULTIPATH(out));
334         break;
335
336     case OFPUTIL_NXAST_AUTOPATH__DEPRECATED:
337         error = autopath_from_openflow((const struct nx_action_autopath *) a,
338                                        ofpact_put_AUTOPATH(out));
339         break;
340
341     case OFPUTIL_NXAST_BUNDLE:
342     case OFPUTIL_NXAST_BUNDLE_LOAD:
343         error = bundle_from_openflow((const struct nx_action_bundle *) a, out);
344         break;
345
346     case OFPUTIL_NXAST_OUTPUT_REG:
347         error = output_reg_from_openflow(
348             (const struct nx_action_output_reg *) a, out);
349         break;
350
351     case OFPUTIL_NXAST_RESUBMIT_TABLE:
352         nar = (const struct nx_action_resubmit *) a;
353         error = resubmit_table_from_openflow(nar, out);
354         break;
355
356     case OFPUTIL_NXAST_LEARN:
357         error = learn_from_openflow((const struct nx_action_learn *) a, out);
358         break;
359
360     case OFPUTIL_NXAST_EXIT:
361         ofpact_put_EXIT(out);
362         break;
363
364     case OFPUTIL_NXAST_DEC_TTL:
365         error = dec_ttl_from_openflow(out);
366         break;
367
368     case OFPUTIL_NXAST_DEC_TTL_CNT_IDS:
369         error = dec_ttl_cnt_ids_from_openflow(
370                     (const struct nx_action_cnt_ids *) a, out);
371         break;
372
373     case OFPUTIL_NXAST_FIN_TIMEOUT:
374         fin_timeout_from_openflow(
375             (const struct nx_action_fin_timeout *) a, out);
376         break;
377
378     case OFPUTIL_NXAST_CONTROLLER:
379         controller_from_openflow((const struct nx_action_controller *) a, out);
380         break;
381     }
382
383     return error;
384 }
385
386 static enum ofperr
387 ofpact_from_openflow10(const union ofp_action *a, struct ofpbuf *out)
388 {
389     enum ofputil_action_code code;
390     enum ofperr error;
391
392     error = decode_openflow10_action(a, &code);
393     if (error) {
394         return error;
395     }
396
397     switch (code) {
398     case OFPUTIL_ACTION_INVALID:
399 #define OFPAT11_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
400 #include "ofp-util.def"
401         NOT_REACHED();
402
403     case OFPUTIL_OFPAT10_OUTPUT:
404         return output_from_openflow10(&a->output10, out);
405
406     case OFPUTIL_OFPAT10_SET_VLAN_VID:
407         if (a->vlan_vid.vlan_vid & ~htons(0xfff)) {
408             return OFPERR_OFPBAC_BAD_ARGUMENT;
409         }
410         ofpact_put_SET_VLAN_VID(out)->vlan_vid = ntohs(a->vlan_vid.vlan_vid);
411         break;
412
413     case OFPUTIL_OFPAT10_SET_VLAN_PCP:
414         if (a->vlan_pcp.vlan_pcp & ~7) {
415             return OFPERR_OFPBAC_BAD_ARGUMENT;
416         }
417         ofpact_put_SET_VLAN_PCP(out)->vlan_pcp = a->vlan_pcp.vlan_pcp;
418         break;
419
420     case OFPUTIL_OFPAT10_STRIP_VLAN:
421         ofpact_put_STRIP_VLAN(out);
422         break;
423
424     case OFPUTIL_OFPAT10_SET_DL_SRC:
425         memcpy(ofpact_put_SET_ETH_SRC(out)->mac,
426                ((const struct ofp_action_dl_addr *) a)->dl_addr, ETH_ADDR_LEN);
427         break;
428
429     case OFPUTIL_OFPAT10_SET_DL_DST:
430         memcpy(ofpact_put_SET_ETH_DST(out)->mac,
431                ((const struct ofp_action_dl_addr *) a)->dl_addr, ETH_ADDR_LEN);
432         break;
433
434     case OFPUTIL_OFPAT10_SET_NW_SRC:
435         ofpact_put_SET_IPV4_SRC(out)->ipv4 = a->nw_addr.nw_addr;
436         break;
437
438     case OFPUTIL_OFPAT10_SET_NW_DST:
439         ofpact_put_SET_IPV4_DST(out)->ipv4 = a->nw_addr.nw_addr;
440         break;
441
442     case OFPUTIL_OFPAT10_SET_NW_TOS:
443         if (a->nw_tos.nw_tos & ~IP_DSCP_MASK) {
444             return OFPERR_OFPBAC_BAD_ARGUMENT;
445         }
446         ofpact_put_SET_IPV4_DSCP(out)->dscp = a->nw_tos.nw_tos;
447         break;
448
449     case OFPUTIL_OFPAT10_SET_TP_SRC:
450         ofpact_put_SET_L4_SRC_PORT(out)->port = ntohs(a->tp_port.tp_port);
451         break;
452
453     case OFPUTIL_OFPAT10_SET_TP_DST:
454         ofpact_put_SET_L4_DST_PORT(out)->port = ntohs(a->tp_port.tp_port);
455
456         break;
457
458     case OFPUTIL_OFPAT10_ENQUEUE:
459         error = enqueue_from_openflow10((const struct ofp_action_enqueue *) a,
460                                         out);
461         break;
462
463 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
464 #include "ofp-util.def"
465         return ofpact_from_nxast(a, code, out);
466     }
467
468     return error;
469 }
470
471 static inline union ofp_action *
472 action_next(const union ofp_action *a)
473 {
474     return ((union ofp_action *) (void *)
475             ((uint8_t *) a + ntohs(a->header.len)));
476 }
477
478 static inline bool
479 action_is_valid(const union ofp_action *a, size_t n_actions)
480 {
481     uint16_t len = ntohs(a->header.len);
482     return (!(len % OFP_ACTION_ALIGN)
483             && len >= sizeof *a
484             && len / sizeof *a <= n_actions);
485 }
486
487 /* This macro is careful to check for actions with bad lengths. */
488 #define ACTION_FOR_EACH(ITER, LEFT, ACTIONS, N_ACTIONS)                 \
489     for ((ITER) = (ACTIONS), (LEFT) = (N_ACTIONS);                      \
490          (LEFT) > 0 && action_is_valid(ITER, LEFT);                     \
491          ((LEFT) -= ntohs((ITER)->header.len) / sizeof(union ofp_action), \
492           (ITER) = action_next(ITER)))
493
494 static void
495 log_bad_action(const union ofp_action *actions, size_t n_actions, size_t ofs,
496                enum ofperr error)
497 {
498     if (!VLOG_DROP_WARN(&rl)) {
499         struct ds s;
500
501         ds_init(&s);
502         ds_put_hex_dump(&s, actions, n_actions * sizeof *actions, 0, false);
503         VLOG_WARN("bad action at offset %#zx (%s):\n%s",
504                   ofs * sizeof *actions, ofperr_get_name(error), ds_cstr(&s));
505         ds_destroy(&s);
506     }
507 }
508
509 static enum ofperr
510 ofpacts_from_openflow(const union ofp_action *in, size_t n_in,
511                       struct ofpbuf *out,
512                       enum ofperr (*ofpact_from_openflow)(
513                           const union ofp_action *a, struct ofpbuf *out))
514 {
515     const union ofp_action *a;
516     size_t left;
517
518     ACTION_FOR_EACH (a, left, in, n_in) {
519         enum ofperr error = ofpact_from_openflow(a, out);
520         if (error) {
521             log_bad_action(in, n_in, a - in, error);
522             return error;
523         }
524     }
525     if (left) {
526         enum ofperr error = OFPERR_OFPBAC_BAD_LEN;
527         log_bad_action(in, n_in, n_in - left, error);
528         return error;
529     }
530
531     ofpact_pad(out);
532     return 0;
533 }
534
535 static enum ofperr
536 ofpacts_from_openflow10(const union ofp_action *in, size_t n_in,
537                         struct ofpbuf *out)
538 {
539     return ofpacts_from_openflow(in, n_in, out, ofpact_from_openflow10);
540 }
541
542 static enum ofperr
543 ofpacts_pull_actions(struct ofpbuf *openflow, unsigned int actions_len,
544                      struct ofpbuf *ofpacts,
545                      enum ofperr (*translate)(const union ofp_action *actions,
546                                               size_t n_actions,
547                                               struct ofpbuf *ofpacts))
548 {
549     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
550     const union ofp_action *actions;
551     enum ofperr error;
552
553     ofpbuf_clear(ofpacts);
554
555     if (actions_len % OFP_ACTION_ALIGN != 0) {
556         VLOG_WARN_RL(&rl, "OpenFlow message actions length %u is not a "
557                      "multiple of %d", actions_len, OFP_ACTION_ALIGN);
558         return OFPERR_OFPBRC_BAD_LEN;
559     }
560
561     actions = ofpbuf_try_pull(openflow, actions_len);
562     if (actions == NULL) {
563         VLOG_WARN_RL(&rl, "OpenFlow message actions length %u exceeds "
564                      "remaining message length (%zu)",
565                      actions_len, openflow->size);
566         return OFPERR_OFPBRC_BAD_LEN;
567     }
568
569     error = translate(actions, actions_len / OFP_ACTION_ALIGN, ofpacts);
570     if (error) {
571         ofpbuf_clear(ofpacts);
572     }
573     return error;
574 }
575
576 /* Attempts to convert 'actions_len' bytes of OpenFlow 1.0 actions from the
577  * front of 'openflow' into ofpacts.  On success, replaces any existing content
578  * in 'ofpacts' by the converted ofpacts; on failure, clears 'ofpacts'.
579  * Returns 0 if successful, otherwise an OpenFlow error.
580  *
581  * The parsed actions are valid generically, but they may not be valid in a
582  * specific context.  For example, port numbers up to OFPP_MAX are valid
583  * generically, but specific datapaths may only support port numbers in a
584  * smaller range.  Use ofpacts_check() to additional check whether actions are
585  * valid in a specific context. */
586 enum ofperr
587 ofpacts_pull_openflow10(struct ofpbuf *openflow, unsigned int actions_len,
588                         struct ofpbuf *ofpacts)
589 {
590     return ofpacts_pull_actions(openflow, actions_len, ofpacts,
591                                 ofpacts_from_openflow10);
592 }
593 \f
594 /* OpenFlow 1.1 actions. */
595
596 /* Parses 'a' to determine its type.  On success stores the correct type into
597  * '*code' and returns 0.  On failure returns an OFPERR_* error code and
598  * '*code' is indeterminate.
599  *
600  * The caller must have already verified that 'a''s length is potentially
601  * correct (that is, a->header.len is nonzero and a multiple of sizeof(union
602  * ofp_action) and no longer than the amount of space allocated to 'a').
603  *
604  * This function verifies that 'a''s length is correct for the type of action
605  * that it represents. */
606 static enum ofperr
607 decode_openflow11_action(const union ofp_action *a,
608                          enum ofputil_action_code *code)
609 {
610     switch (a->type) {
611     case CONSTANT_HTONS(OFPAT11_EXPERIMENTER):
612         return decode_nxast_action(a, code);
613
614 #define OFPAT11_ACTION(ENUM, STRUCT, NAME)                          \
615         case CONSTANT_HTONS(ENUM):                                  \
616             if (a->header.len == htons(sizeof(struct STRUCT))) {    \
617                 *code = OFPUTIL_##ENUM;                             \
618                 return 0;                                           \
619             } else {                                                \
620                 return OFPERR_OFPBAC_BAD_LEN;                       \
621             }                                                       \
622             break;
623 #include "ofp-util.def"
624
625     default:
626         return OFPERR_OFPBAC_BAD_TYPE;
627     }
628 }
629
630 static enum ofperr
631 output_from_openflow11(const struct ofp11_action_output *oao,
632                        struct ofpbuf *out)
633 {
634     struct ofpact_output *output;
635     enum ofperr error;
636
637     output = ofpact_put_OUTPUT(out);
638     output->max_len = ntohs(oao->max_len);
639
640     error = ofputil_port_from_ofp11(oao->port, &output->port);
641     if (error) {
642         return error;
643     }
644
645     return ofputil_check_output_port(output->port, OFPP_MAX);
646 }
647
648 static enum ofperr
649 ofpact_from_openflow11(const union ofp_action *a, struct ofpbuf *out)
650 {
651     enum ofputil_action_code code;
652     enum ofperr error;
653
654     error = decode_openflow11_action(a, &code);
655     if (error) {
656         return error;
657     }
658
659     switch (code) {
660     case OFPUTIL_ACTION_INVALID:
661 #define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
662 #include "ofp-util.def"
663         NOT_REACHED();
664
665     case OFPUTIL_OFPAT11_OUTPUT:
666         return output_from_openflow11((const struct ofp11_action_output *) a,
667                                       out);
668
669     case OFPUTIL_OFPAT11_SET_VLAN_VID:
670         if (a->vlan_vid.vlan_vid & ~htons(0xfff)) {
671             return OFPERR_OFPBAC_BAD_ARGUMENT;
672         }
673         ofpact_put_SET_VLAN_VID(out)->vlan_vid = ntohs(a->vlan_vid.vlan_vid);
674         break;
675
676     case OFPUTIL_OFPAT11_SET_VLAN_PCP:
677         if (a->vlan_pcp.vlan_pcp & ~7) {
678             return OFPERR_OFPBAC_BAD_ARGUMENT;
679         }
680         ofpact_put_SET_VLAN_PCP(out)->vlan_pcp = a->vlan_pcp.vlan_pcp;
681         break;
682
683     case OFPUTIL_OFPAT11_SET_DL_SRC:
684         memcpy(ofpact_put_SET_ETH_SRC(out)->mac,
685                ((const struct ofp_action_dl_addr *) a)->dl_addr, ETH_ADDR_LEN);
686         break;
687
688     case OFPUTIL_OFPAT11_SET_DL_DST:
689         memcpy(ofpact_put_SET_ETH_DST(out)->mac,
690                ((const struct ofp_action_dl_addr *) a)->dl_addr, ETH_ADDR_LEN);
691         break;
692
693     case OFPUTIL_OFPAT11_SET_NW_SRC:
694         ofpact_put_SET_IPV4_SRC(out)->ipv4 = a->nw_addr.nw_addr;
695         break;
696
697     case OFPUTIL_OFPAT11_SET_NW_DST:
698         ofpact_put_SET_IPV4_DST(out)->ipv4 = a->nw_addr.nw_addr;
699         break;
700
701     case OFPUTIL_OFPAT11_SET_NW_TOS:
702         if (a->nw_tos.nw_tos & ~IP_DSCP_MASK) {
703             return OFPERR_OFPBAC_BAD_ARGUMENT;
704         }
705         ofpact_put_SET_IPV4_DSCP(out)->dscp = a->nw_tos.nw_tos;
706         break;
707
708     case OFPUTIL_OFPAT11_SET_TP_SRC:
709         ofpact_put_SET_L4_SRC_PORT(out)->port = ntohs(a->tp_port.tp_port);
710         break;
711
712     case OFPUTIL_OFPAT11_SET_TP_DST:
713         ofpact_put_SET_L4_DST_PORT(out)->port = ntohs(a->tp_port.tp_port);
714         break;
715
716 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
717 #include "ofp-util.def"
718         return ofpact_from_nxast(a, code, out);
719     }
720
721     return error;
722 }
723
724 static enum ofperr
725 ofpacts_from_openflow11(const union ofp_action *in, size_t n_in,
726                         struct ofpbuf *out)
727 {
728     return ofpacts_from_openflow(in, n_in, out, ofpact_from_openflow11);
729 }
730 \f
731 /* OpenFlow 1.1 instructions. */
732
733 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME)             \
734     static inline const struct STRUCT *                         \
735     instruction_get_##ENUM(const struct ofp11_instruction *inst)\
736     {                                                           \
737         assert(inst->type == htons(ENUM));                      \
738         return (struct STRUCT *)inst;                           \
739     }                                                           \
740                                                                 \
741     static inline void                                          \
742     instruction_init_##ENUM(struct STRUCT *s)                   \
743     {                                                           \
744         memset(s, 0, sizeof *s);                                \
745         s->type = htons(ENUM);                                  \
746         s->len = htons(sizeof *s);                              \
747     }                                                           \
748                                                                 \
749     static inline struct STRUCT *                               \
750     instruction_put_##ENUM(struct ofpbuf *buf)                  \
751     {                                                           \
752         struct STRUCT *s = ofpbuf_put_uninit(buf, sizeof *s);   \
753         instruction_init_##ENUM(s);                             \
754         return s;                                               \
755     }
756 OVS_INSTRUCTIONS
757 #undef DEFINE_INST
758
759 struct instruction_type_info {
760     enum ovs_instruction_type type;
761     const char *name;
762 };
763
764 static const struct instruction_type_info inst_info[] = {
765 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME)    {OVSINST_##ENUM, NAME},
766 OVS_INSTRUCTIONS
767 #undef DEFINE_INST
768 };
769
770 const char *
771 ofpact_instruction_name_from_type(enum ovs_instruction_type type)
772 {
773     return inst_info[type].name;
774 }
775
776 int
777 ofpact_instruction_type_from_name(const char *name)
778 {
779     const struct instruction_type_info *p;
780     for (p = inst_info; p < &inst_info[ARRAY_SIZE(inst_info)]; p++) {
781         if (!strcasecmp(name, p->name)) {
782             return p->type;
783         }
784     }
785     return -1;
786 }
787
788 static inline struct ofp11_instruction *
789 instruction_next(const struct ofp11_instruction *inst)
790 {
791     return ((struct ofp11_instruction *) (void *)
792             ((uint8_t *) inst + ntohs(inst->len)));
793 }
794
795 static inline bool
796 instruction_is_valid(const struct ofp11_instruction *inst,
797                      size_t n_instructions)
798 {
799     uint16_t len = ntohs(inst->len);
800     return (!(len % OFP11_INSTRUCTION_ALIGN)
801             && len >= sizeof *inst
802             && len / sizeof *inst <= n_instructions);
803 }
804
805 /* This macro is careful to check for instructions with bad lengths. */
806 #define INSTRUCTION_FOR_EACH(ITER, LEFT, INSTRUCTIONS, N_INSTRUCTIONS)  \
807     for ((ITER) = (INSTRUCTIONS), (LEFT) = (N_INSTRUCTIONS);            \
808          (LEFT) > 0 && instruction_is_valid(ITER, LEFT);                \
809          ((LEFT) -= (ntohs((ITER)->len)                                 \
810                      / sizeof(struct ofp11_instruction)),               \
811           (ITER) = instruction_next(ITER)))
812
813 static enum ofperr
814 decode_openflow11_instruction(const struct ofp11_instruction *inst,
815                               enum ovs_instruction_type *type)
816 {
817     uint16_t len = ntohs(inst->len);
818
819     switch (inst->type) {
820     case CONSTANT_HTONS(OFPIT11_EXPERIMENTER):
821         return OFPERR_OFPBIC_BAD_EXPERIMENTER;
822
823 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME)     \
824         case CONSTANT_HTONS(ENUM):                      \
825             if (EXTENSIBLE                              \
826                 ? len >= sizeof(struct STRUCT)          \
827                 : len == sizeof(struct STRUCT)) {       \
828                 *type = OVSINST_##ENUM;                 \
829                 return 0;                               \
830             } else {                                    \
831                 return OFPERR_OFPBIC_BAD_LEN;           \
832             }
833 OVS_INSTRUCTIONS
834 #undef DEFINE_INST
835
836     default:
837         return OFPERR_OFPBIC_UNKNOWN_INST;
838     }
839 }
840
841 static enum ofperr
842 decode_openflow11_instructions(const struct ofp11_instruction insts[],
843                                size_t n_insts,
844                                const struct ofp11_instruction *out[])
845 {
846     const struct ofp11_instruction *inst;
847     size_t left;
848
849     memset(out, 0, N_OVS_INSTRUCTIONS * sizeof *out);
850     INSTRUCTION_FOR_EACH (inst, left, insts, n_insts) {
851         enum ovs_instruction_type type;
852         enum ofperr error;
853
854         error = decode_openflow11_instruction(inst, &type);
855         if (error) {
856             return error;
857         }
858
859         if (out[type]) {
860             return OFPERR_NXBIC_DUP_TYPE;
861         }
862         out[type] = inst;
863     }
864
865     if (left) {
866         VLOG_WARN_RL(&rl, "bad instruction format at offset %zu",
867                      (n_insts - left) * sizeof *inst);
868         return OFPERR_OFPBIC_BAD_LEN;
869     }
870     return 0;
871 }
872
873 static void
874 get_actions_from_instruction(const struct ofp11_instruction *inst,
875                          const union ofp_action **actions,
876                          size_t *n_actions)
877 {
878     *actions = (const union ofp_action *) (inst + 1);
879     *n_actions = (ntohs(inst->len) - sizeof *inst) / OFP11_INSTRUCTION_ALIGN;
880 }
881
882 /* Attempts to convert 'actions_len' bytes of OpenFlow 1.1 actions from the
883  * front of 'openflow' into ofpacts.  On success, replaces any existing content
884  * in 'ofpacts' by the converted ofpacts; on failure, clears 'ofpacts'.
885  * Returns 0 if successful, otherwise an OpenFlow error.
886  *
887  * In most places in OpenFlow 1.1 and 1.2, actions appear encapsulated in
888  * instructions, so you should call ofpacts_pull_openflow11_instructions()
889  * instead of this function.
890  *
891  * The parsed actions are valid generically, but they may not be valid in a
892  * specific context.  For example, port numbers up to OFPP_MAX are valid
893  * generically, but specific datapaths may only support port numbers in a
894  * smaller range.  Use ofpacts_check() to additional check whether actions are
895  * valid in a specific context. */
896 enum ofperr
897 ofpacts_pull_openflow11_actions(struct ofpbuf *openflow,
898                                 unsigned int actions_len,
899                                 struct ofpbuf *ofpacts)
900 {
901     return ofpacts_pull_actions(openflow, actions_len, ofpacts,
902                                 ofpacts_from_openflow11);
903 }
904
905 enum ofperr
906 ofpacts_pull_openflow11_instructions(struct ofpbuf *openflow,
907                                      unsigned int instructions_len,
908                                      struct ofpbuf *ofpacts)
909 {
910     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
911     const struct ofp11_instruction *instructions;
912     const struct ofp11_instruction *insts[N_OVS_INSTRUCTIONS];
913     enum ofperr error;
914
915     ofpbuf_clear(ofpacts);
916
917     if (instructions_len % OFP11_INSTRUCTION_ALIGN != 0) {
918         VLOG_WARN_RL(&rl, "OpenFlow message instructions length %u is not a "
919                      "multiple of %d",
920                      instructions_len, OFP11_INSTRUCTION_ALIGN);
921         error = OFPERR_OFPBIC_BAD_LEN;
922         goto exit;
923     }
924
925     instructions = ofpbuf_try_pull(openflow, instructions_len);
926     if (instructions == NULL) {
927         VLOG_WARN_RL(&rl, "OpenFlow message instructions length %u exceeds "
928                      "remaining message length (%zu)",
929                      instructions_len, openflow->size);
930         error = OFPERR_OFPBIC_BAD_LEN;
931         goto exit;
932     }
933
934     error = decode_openflow11_instructions(
935         instructions, instructions_len / OFP11_INSTRUCTION_ALIGN,
936         insts);
937     if (error) {
938         goto exit;
939     }
940
941     if (insts[OVSINST_OFPIT11_APPLY_ACTIONS]) {
942         const union ofp_action *actions;
943         size_t n_actions;
944
945         get_actions_from_instruction(insts[OVSINST_OFPIT11_APPLY_ACTIONS],
946                                      &actions, &n_actions);
947         error = ofpacts_from_openflow11(actions, n_actions, ofpacts);
948         if (error) {
949             goto exit;
950         }
951     }
952
953     if (insts[OVSINST_OFPIT11_GOTO_TABLE] ||
954         insts[OVSINST_OFPIT11_WRITE_METADATA] ||
955         insts[OVSINST_OFPIT11_WRITE_ACTIONS] ||
956         insts[OVSINST_OFPIT11_CLEAR_ACTIONS]) {
957         error = OFPERR_OFPBIC_UNSUP_INST;
958         goto exit;
959     }
960
961 exit:
962     if (error) {
963         ofpbuf_clear(ofpacts);
964     }
965     return error;
966 }
967 \f
968 static enum ofperr
969 ofpact_check__(const struct ofpact *a, const struct flow *flow, int max_ports)
970 {
971     const struct ofpact_enqueue *enqueue;
972
973     switch (a->type) {
974     case OFPACT_OUTPUT:
975         return ofputil_check_output_port(ofpact_get_OUTPUT(a)->port,
976                                          max_ports);
977
978     case OFPACT_CONTROLLER:
979         return 0;
980
981     case OFPACT_ENQUEUE:
982         enqueue = ofpact_get_ENQUEUE(a);
983         if (enqueue->port >= max_ports && enqueue->port != OFPP_IN_PORT
984             && enqueue->port != OFPP_LOCAL) {
985             return OFPERR_OFPBAC_BAD_OUT_PORT;
986         }
987         return 0;
988
989     case OFPACT_OUTPUT_REG:
990         return mf_check_src(&ofpact_get_OUTPUT_REG(a)->src, flow);
991
992     case OFPACT_BUNDLE:
993         return bundle_check(ofpact_get_BUNDLE(a), max_ports, flow);
994
995     case OFPACT_SET_VLAN_VID:
996     case OFPACT_SET_VLAN_PCP:
997     case OFPACT_STRIP_VLAN:
998     case OFPACT_SET_ETH_SRC:
999     case OFPACT_SET_ETH_DST:
1000     case OFPACT_SET_IPV4_SRC:
1001     case OFPACT_SET_IPV4_DST:
1002     case OFPACT_SET_IPV4_DSCP:
1003     case OFPACT_SET_L4_SRC_PORT:
1004     case OFPACT_SET_L4_DST_PORT:
1005         return 0;
1006
1007     case OFPACT_REG_MOVE:
1008         return nxm_reg_move_check(ofpact_get_REG_MOVE(a), flow);
1009
1010     case OFPACT_REG_LOAD:
1011         return nxm_reg_load_check(ofpact_get_REG_LOAD(a), flow);
1012
1013     case OFPACT_DEC_TTL:
1014     case OFPACT_SET_TUNNEL:
1015     case OFPACT_SET_QUEUE:
1016     case OFPACT_POP_QUEUE:
1017     case OFPACT_FIN_TIMEOUT:
1018     case OFPACT_RESUBMIT:
1019         return 0;
1020
1021     case OFPACT_LEARN:
1022         return learn_check(ofpact_get_LEARN(a), flow);
1023
1024     case OFPACT_MULTIPATH:
1025         return multipath_check(ofpact_get_MULTIPATH(a), flow);
1026
1027     case OFPACT_AUTOPATH:
1028         return autopath_check(ofpact_get_AUTOPATH(a), flow);
1029
1030     case OFPACT_NOTE:
1031     case OFPACT_EXIT:
1032         return 0;
1033
1034     default:
1035         NOT_REACHED();
1036     }
1037 }
1038
1039 /* Checks that the 'ofpacts_len' bytes of actions in 'ofpacts' are
1040  * appropriate for a packet with the prerequisites satisfied by 'flow' in a
1041  * switch with no more than 'max_ports' ports. */
1042 enum ofperr
1043 ofpacts_check(const struct ofpact ofpacts[], size_t ofpacts_len,
1044               const struct flow *flow, int max_ports)
1045 {
1046     const struct ofpact *a;
1047
1048     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
1049         enum ofperr error = ofpact_check__(a, flow, max_ports);
1050         if (error) {
1051             return error;
1052         }
1053     }
1054
1055     return 0;
1056 }
1057 \f
1058 /* Converting ofpacts to Nicira OpenFlow extensions. */
1059
1060 static void
1061 ofpact_output_reg_to_nxast(const struct ofpact_output_reg *output_reg,
1062                                 struct ofpbuf *out)
1063 {
1064     struct nx_action_output_reg *naor = ofputil_put_NXAST_OUTPUT_REG(out);
1065
1066     naor->ofs_nbits = nxm_encode_ofs_nbits(output_reg->src.ofs,
1067                                            output_reg->src.n_bits);
1068     naor->src = htonl(output_reg->src.field->nxm_header);
1069     naor->max_len = htons(output_reg->max_len);
1070 }
1071
1072 static void
1073 ofpact_resubmit_to_nxast(const struct ofpact_resubmit *resubmit,
1074                          struct ofpbuf *out)
1075 {
1076     struct nx_action_resubmit *nar;
1077
1078     if (resubmit->table_id == 0xff
1079         && resubmit->ofpact.compat != OFPUTIL_NXAST_RESUBMIT_TABLE) {
1080         nar = ofputil_put_NXAST_RESUBMIT(out);
1081     } else {
1082         nar = ofputil_put_NXAST_RESUBMIT_TABLE(out);
1083         nar->table = resubmit->table_id;
1084     }
1085     nar->in_port = htons(resubmit->in_port);
1086 }
1087
1088 static void
1089 ofpact_set_tunnel_to_nxast(const struct ofpact_tunnel *tunnel,
1090                            struct ofpbuf *out)
1091 {
1092     uint64_t tun_id = tunnel->tun_id;
1093
1094     if (tun_id <= UINT32_MAX
1095         && tunnel->ofpact.compat != OFPUTIL_NXAST_SET_TUNNEL64) {
1096         ofputil_put_NXAST_SET_TUNNEL(out)->tun_id = htonl(tun_id);
1097     } else {
1098         ofputil_put_NXAST_SET_TUNNEL64(out)->tun_id = htonll(tun_id);
1099     }
1100 }
1101
1102 static void
1103 ofpact_note_to_nxast(const struct ofpact_note *note, struct ofpbuf *out)
1104 {
1105     size_t start_ofs = out->size;
1106     struct nx_action_note *nan;
1107     unsigned int remainder;
1108     unsigned int len;
1109
1110     nan = ofputil_put_NXAST_NOTE(out);
1111     out->size -= sizeof nan->note;
1112
1113     ofpbuf_put(out, note->data, note->length);
1114
1115     len = out->size - start_ofs;
1116     remainder = len % OFP_ACTION_ALIGN;
1117     if (remainder) {
1118         ofpbuf_put_zeros(out, OFP_ACTION_ALIGN - remainder);
1119     }
1120     nan = (struct nx_action_note *)((char *)out->data + start_ofs);
1121     nan->len = htons(out->size - start_ofs);
1122 }
1123
1124 static void
1125 ofpact_controller_to_nxast(const struct ofpact_controller *oc,
1126                            struct ofpbuf *out)
1127 {
1128     struct nx_action_controller *nac;
1129
1130     nac = ofputil_put_NXAST_CONTROLLER(out);
1131     nac->max_len = htons(oc->max_len);
1132     nac->controller_id = htons(oc->controller_id);
1133     nac->reason = oc->reason;
1134 }
1135
1136 static void
1137 ofpact_dec_ttl_to_nxast(const struct ofpact_cnt_ids *oc_ids,
1138                         struct ofpbuf *out)
1139 {
1140     if (oc_ids->ofpact.compat == OFPUTIL_NXAST_DEC_TTL) {
1141         ofputil_put_NXAST_DEC_TTL(out);
1142     } else {
1143         struct nx_action_cnt_ids *nac_ids =
1144             ofputil_put_NXAST_DEC_TTL_CNT_IDS(out);
1145         int ids_len = ROUND_UP(2 * oc_ids->n_controllers, OFP_ACTION_ALIGN);
1146         ovs_be16 *ids;
1147         size_t i;
1148
1149         nac_ids->len = htons(ntohs(nac_ids->len) + ids_len);
1150         nac_ids->n_controllers = htons(oc_ids->n_controllers);
1151
1152         ids = ofpbuf_put_zeros(out, ids_len);
1153         for (i = 0; i < oc_ids->n_controllers; i++) {
1154             ids[i] = htons(oc_ids->cnt_ids[i]);
1155         }
1156     }
1157 }
1158
1159 static void
1160 ofpact_fin_timeout_to_nxast(const struct ofpact_fin_timeout *fin_timeout,
1161                             struct ofpbuf *out)
1162 {
1163     struct nx_action_fin_timeout *naft = ofputil_put_NXAST_FIN_TIMEOUT(out);
1164     naft->fin_idle_timeout = htons(fin_timeout->fin_idle_timeout);
1165     naft->fin_hard_timeout = htons(fin_timeout->fin_hard_timeout);
1166 }
1167
1168 static void
1169 ofpact_to_nxast(const struct ofpact *a, struct ofpbuf *out)
1170 {
1171     switch (a->type) {
1172     case OFPACT_CONTROLLER:
1173         ofpact_controller_to_nxast(ofpact_get_CONTROLLER(a), out);
1174         break;
1175
1176     case OFPACT_OUTPUT_REG:
1177         ofpact_output_reg_to_nxast(ofpact_get_OUTPUT_REG(a), out);
1178         break;
1179
1180     case OFPACT_BUNDLE:
1181         bundle_to_nxast(ofpact_get_BUNDLE(a), out);
1182         break;
1183
1184     case OFPACT_REG_MOVE:
1185         nxm_reg_move_to_nxast(ofpact_get_REG_MOVE(a), out);
1186         break;
1187
1188     case OFPACT_REG_LOAD:
1189         nxm_reg_load_to_nxast(ofpact_get_REG_LOAD(a), out);
1190         break;
1191
1192     case OFPACT_DEC_TTL:
1193         ofpact_dec_ttl_to_nxast(ofpact_get_DEC_TTL(a), out);
1194         break;
1195
1196     case OFPACT_SET_TUNNEL:
1197         ofpact_set_tunnel_to_nxast(ofpact_get_SET_TUNNEL(a), out);
1198         break;
1199
1200     case OFPACT_SET_QUEUE:
1201         ofputil_put_NXAST_SET_QUEUE(out)->queue_id
1202             = htonl(ofpact_get_SET_QUEUE(a)->queue_id);
1203         break;
1204
1205     case OFPACT_POP_QUEUE:
1206         ofputil_put_NXAST_POP_QUEUE(out);
1207         break;
1208
1209     case OFPACT_FIN_TIMEOUT:
1210         ofpact_fin_timeout_to_nxast(ofpact_get_FIN_TIMEOUT(a), out);
1211         break;
1212
1213     case OFPACT_RESUBMIT:
1214         ofpact_resubmit_to_nxast(ofpact_get_RESUBMIT(a), out);
1215         break;
1216
1217     case OFPACT_LEARN:
1218         learn_to_nxast(ofpact_get_LEARN(a), out);
1219         break;
1220
1221     case OFPACT_MULTIPATH:
1222         multipath_to_nxast(ofpact_get_MULTIPATH(a), out);
1223         break;
1224
1225     case OFPACT_AUTOPATH:
1226         autopath_to_nxast(ofpact_get_AUTOPATH(a), out);
1227         break;
1228
1229     case OFPACT_NOTE:
1230         ofpact_note_to_nxast(ofpact_get_NOTE(a), out);
1231         break;
1232
1233     case OFPACT_EXIT:
1234         ofputil_put_NXAST_EXIT(out);
1235         break;
1236
1237     case OFPACT_OUTPUT:
1238     case OFPACT_ENQUEUE:
1239     case OFPACT_SET_VLAN_VID:
1240     case OFPACT_SET_VLAN_PCP:
1241     case OFPACT_STRIP_VLAN:
1242     case OFPACT_SET_ETH_SRC:
1243     case OFPACT_SET_ETH_DST:
1244     case OFPACT_SET_IPV4_SRC:
1245     case OFPACT_SET_IPV4_DST:
1246     case OFPACT_SET_IPV4_DSCP:
1247     case OFPACT_SET_L4_SRC_PORT:
1248     case OFPACT_SET_L4_DST_PORT:
1249         NOT_REACHED();
1250     }
1251 }
1252 \f
1253 /* Converting ofpacts to OpenFlow 1.0. */
1254
1255 static void
1256 ofpact_output_to_openflow10(const struct ofpact_output *output,
1257                             struct ofpbuf *out)
1258 {
1259     struct ofp10_action_output *oao;
1260
1261     oao = ofputil_put_OFPAT10_OUTPUT(out);
1262     oao->port = htons(output->port);
1263     oao->max_len = htons(output->max_len);
1264 }
1265
1266 static void
1267 ofpact_enqueue_to_openflow10(const struct ofpact_enqueue *enqueue,
1268                              struct ofpbuf *out)
1269 {
1270     struct ofp_action_enqueue *oae;
1271
1272     oae = ofputil_put_OFPAT10_ENQUEUE(out);
1273     oae->port = htons(enqueue->port);
1274     oae->queue_id = htonl(enqueue->queue);
1275 }
1276
1277 static void
1278 ofpact_to_openflow10(const struct ofpact *a, struct ofpbuf *out)
1279 {
1280     switch (a->type) {
1281     case OFPACT_OUTPUT:
1282         ofpact_output_to_openflow10(ofpact_get_OUTPUT(a), out);
1283         break;
1284
1285     case OFPACT_ENQUEUE:
1286         ofpact_enqueue_to_openflow10(ofpact_get_ENQUEUE(a), out);
1287         break;
1288
1289     case OFPACT_SET_VLAN_VID:
1290         ofputil_put_OFPAT10_SET_VLAN_VID(out)->vlan_vid
1291             = htons(ofpact_get_SET_VLAN_VID(a)->vlan_vid);
1292         break;
1293
1294     case OFPACT_SET_VLAN_PCP:
1295         ofputil_put_OFPAT10_SET_VLAN_PCP(out)->vlan_pcp
1296             = ofpact_get_SET_VLAN_PCP(a)->vlan_pcp;
1297         break;
1298
1299     case OFPACT_STRIP_VLAN:
1300         ofputil_put_OFPAT10_STRIP_VLAN(out);
1301         break;
1302
1303     case OFPACT_SET_ETH_SRC:
1304         memcpy(ofputil_put_OFPAT10_SET_DL_SRC(out)->dl_addr,
1305                ofpact_get_SET_ETH_SRC(a)->mac, ETH_ADDR_LEN);
1306         break;
1307
1308     case OFPACT_SET_ETH_DST:
1309         memcpy(ofputil_put_OFPAT10_SET_DL_DST(out)->dl_addr,
1310                ofpact_get_SET_ETH_DST(a)->mac, ETH_ADDR_LEN);
1311         break;
1312
1313     case OFPACT_SET_IPV4_SRC:
1314         ofputil_put_OFPAT10_SET_NW_SRC(out)->nw_addr
1315             = ofpact_get_SET_IPV4_SRC(a)->ipv4;
1316         break;
1317
1318     case OFPACT_SET_IPV4_DST:
1319         ofputil_put_OFPAT10_SET_NW_DST(out)->nw_addr
1320             = ofpact_get_SET_IPV4_DST(a)->ipv4;
1321         break;
1322
1323     case OFPACT_SET_IPV4_DSCP:
1324         ofputil_put_OFPAT10_SET_NW_TOS(out)->nw_tos
1325             = ofpact_get_SET_IPV4_DSCP(a)->dscp;
1326         break;
1327
1328     case OFPACT_SET_L4_SRC_PORT:
1329         ofputil_put_OFPAT10_SET_TP_SRC(out)->tp_port
1330             = htons(ofpact_get_SET_L4_SRC_PORT(a)->port);
1331         break;
1332
1333     case OFPACT_SET_L4_DST_PORT:
1334         ofputil_put_OFPAT10_SET_TP_DST(out)->tp_port
1335             = htons(ofpact_get_SET_L4_DST_PORT(a)->port);
1336         break;
1337
1338     case OFPACT_CONTROLLER:
1339     case OFPACT_OUTPUT_REG:
1340     case OFPACT_BUNDLE:
1341     case OFPACT_REG_MOVE:
1342     case OFPACT_REG_LOAD:
1343     case OFPACT_DEC_TTL:
1344     case OFPACT_SET_TUNNEL:
1345     case OFPACT_SET_QUEUE:
1346     case OFPACT_POP_QUEUE:
1347     case OFPACT_FIN_TIMEOUT:
1348     case OFPACT_RESUBMIT:
1349     case OFPACT_LEARN:
1350     case OFPACT_MULTIPATH:
1351     case OFPACT_AUTOPATH:
1352     case OFPACT_NOTE:
1353     case OFPACT_EXIT:
1354         ofpact_to_nxast(a, out);
1355         break;
1356     }
1357 }
1358
1359 /* Converts the 'ofpacts_len' bytes of ofpacts in 'ofpacts' into OpenFlow 1.0
1360  * actions in 'openflow', appending the actions to any existing data in
1361  * 'openflow'. */
1362 void
1363 ofpacts_put_openflow10(const struct ofpact ofpacts[], size_t ofpacts_len,
1364                        struct ofpbuf *openflow)
1365 {
1366     const struct ofpact *a;
1367
1368     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
1369         ofpact_to_openflow10(a, openflow);
1370     }
1371 }
1372 \f
1373 /* Converting ofpacts to OpenFlow 1.1. */
1374
1375 static void
1376 ofpact_output_to_openflow11(const struct ofpact_output *output,
1377                             struct ofpbuf *out)
1378 {
1379     struct ofp11_action_output *oao;
1380
1381     oao = ofputil_put_OFPAT11_OUTPUT(out);
1382     oao->port = ofputil_port_to_ofp11(output->port);
1383     oao->max_len = htons(output->max_len);
1384 }
1385
1386 static void
1387 ofpact_to_openflow11(const struct ofpact *a, struct ofpbuf *out)
1388 {
1389     switch (a->type) {
1390     case OFPACT_OUTPUT:
1391         return ofpact_output_to_openflow11(ofpact_get_OUTPUT(a), out);
1392
1393     case OFPACT_ENQUEUE:
1394         /* XXX */
1395         break;
1396
1397     case OFPACT_SET_VLAN_VID:
1398         ofputil_put_OFPAT11_SET_VLAN_VID(out)->vlan_vid
1399             = htons(ofpact_get_SET_VLAN_VID(a)->vlan_vid);
1400         break;
1401
1402     case OFPACT_SET_VLAN_PCP:
1403         ofputil_put_OFPAT11_SET_VLAN_PCP(out)->vlan_pcp
1404             = ofpact_get_SET_VLAN_PCP(a)->vlan_pcp;
1405         break;
1406
1407     case OFPACT_STRIP_VLAN:
1408         /* XXX */
1409         break;
1410
1411     case OFPACT_SET_ETH_SRC:
1412         memcpy(ofputil_put_OFPAT11_SET_DL_SRC(out)->dl_addr,
1413                ofpact_get_SET_ETH_SRC(a)->mac, ETH_ADDR_LEN);
1414         break;
1415
1416     case OFPACT_SET_ETH_DST:
1417         memcpy(ofputil_put_OFPAT11_SET_DL_DST(out)->dl_addr,
1418                ofpact_get_SET_ETH_DST(a)->mac, ETH_ADDR_LEN);
1419         break;
1420
1421     case OFPACT_SET_IPV4_SRC:
1422         ofputil_put_OFPAT11_SET_NW_SRC(out)->nw_addr
1423             = ofpact_get_SET_IPV4_SRC(a)->ipv4;
1424         break;
1425
1426     case OFPACT_SET_IPV4_DST:
1427         ofputil_put_OFPAT11_SET_NW_DST(out)->nw_addr
1428             = ofpact_get_SET_IPV4_DST(a)->ipv4;
1429         break;
1430
1431     case OFPACT_SET_IPV4_DSCP:
1432         ofputil_put_OFPAT11_SET_NW_TOS(out)->nw_tos
1433             = ofpact_get_SET_IPV4_DSCP(a)->dscp;
1434         break;
1435
1436     case OFPACT_SET_L4_SRC_PORT:
1437         ofputil_put_OFPAT11_SET_TP_SRC(out)->tp_port
1438             = htons(ofpact_get_SET_L4_SRC_PORT(a)->port);
1439         break;
1440
1441     case OFPACT_SET_L4_DST_PORT:
1442         ofputil_put_OFPAT11_SET_TP_DST(out)->tp_port
1443             = htons(ofpact_get_SET_L4_DST_PORT(a)->port);
1444         break;
1445
1446     case OFPACT_CONTROLLER:
1447     case OFPACT_OUTPUT_REG:
1448     case OFPACT_BUNDLE:
1449     case OFPACT_REG_MOVE:
1450     case OFPACT_REG_LOAD:
1451     case OFPACT_DEC_TTL:
1452     case OFPACT_SET_TUNNEL:
1453     case OFPACT_SET_QUEUE:
1454     case OFPACT_POP_QUEUE:
1455     case OFPACT_FIN_TIMEOUT:
1456     case OFPACT_RESUBMIT:
1457     case OFPACT_LEARN:
1458     case OFPACT_MULTIPATH:
1459     case OFPACT_AUTOPATH:
1460     case OFPACT_NOTE:
1461     case OFPACT_EXIT:
1462         ofpact_to_nxast(a, out);
1463         break;
1464     }
1465 }
1466
1467 /* Converts the ofpacts in 'ofpacts' (terminated by OFPACT_END) into OpenFlow
1468  * 1.1 actions in 'openflow', appending the actions to any existing data in
1469  * 'openflow'. */
1470 size_t
1471 ofpacts_put_openflow11_actions(const struct ofpact ofpacts[],
1472                                size_t ofpacts_len, struct ofpbuf *openflow)
1473 {
1474     const struct ofpact *a;
1475     size_t start_size = openflow->size;
1476
1477     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
1478         ofpact_to_openflow11(a, openflow);
1479     }
1480
1481     return openflow->size - start_size;
1482 }
1483
1484 void
1485 ofpacts_put_openflow11_instructions(const struct ofpact ofpacts[],
1486                                     size_t ofpacts_len,
1487                                     struct ofpbuf *openflow)
1488 {
1489     struct ofp11_instruction_actions *oia;
1490     size_t ofs;
1491
1492     /* Put an OFPIT11_APPLY_ACTIONS instruction and fill it in. */
1493     ofs = openflow->size;
1494     instruction_put_OFPIT11_APPLY_ACTIONS(openflow);
1495     ofpacts_put_openflow11_actions(ofpacts, ofpacts_len, openflow);
1496
1497     /* Update the instruction's length (or, if it's empty, delete it). */
1498     oia = ofpbuf_at_assert(openflow, ofs, sizeof *oia);
1499     if (openflow->size > ofs + sizeof *oia) {
1500         oia->len = htons(openflow->size - ofs);
1501     } else {
1502         openflow->size = ofs;
1503     }
1504 }
1505 \f
1506 /* Returns true if 'action' outputs to 'port', false otherwise. */
1507 static bool
1508 ofpact_outputs_to_port(const struct ofpact *ofpact, uint16_t port)
1509 {
1510     switch (ofpact->type) {
1511     case OFPACT_OUTPUT:
1512         return ofpact_get_OUTPUT(ofpact)->port == port;
1513     case OFPACT_ENQUEUE:
1514         return ofpact_get_ENQUEUE(ofpact)->port == port;
1515     case OFPACT_CONTROLLER:
1516         return port == OFPP_CONTROLLER;
1517
1518     case OFPACT_OUTPUT_REG:
1519     case OFPACT_BUNDLE:
1520     case OFPACT_SET_VLAN_VID:
1521     case OFPACT_SET_VLAN_PCP:
1522     case OFPACT_STRIP_VLAN:
1523     case OFPACT_SET_ETH_SRC:
1524     case OFPACT_SET_ETH_DST:
1525     case OFPACT_SET_IPV4_SRC:
1526     case OFPACT_SET_IPV4_DST:
1527     case OFPACT_SET_IPV4_DSCP:
1528     case OFPACT_SET_L4_SRC_PORT:
1529     case OFPACT_SET_L4_DST_PORT:
1530     case OFPACT_REG_MOVE:
1531     case OFPACT_REG_LOAD:
1532     case OFPACT_DEC_TTL:
1533     case OFPACT_SET_TUNNEL:
1534     case OFPACT_SET_QUEUE:
1535     case OFPACT_POP_QUEUE:
1536     case OFPACT_FIN_TIMEOUT:
1537     case OFPACT_RESUBMIT:
1538     case OFPACT_LEARN:
1539     case OFPACT_MULTIPATH:
1540     case OFPACT_AUTOPATH:
1541     case OFPACT_NOTE:
1542     case OFPACT_EXIT:
1543     default:
1544         return false;
1545     }
1546 }
1547
1548 /* Returns true if any action in the 'ofpacts_len' bytes of 'ofpacts' outputs
1549  * to 'port', false otherwise. */
1550 bool
1551 ofpacts_output_to_port(const struct ofpact *ofpacts, size_t ofpacts_len,
1552                        uint16_t port)
1553 {
1554     const struct ofpact *a;
1555
1556     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
1557         if (ofpact_outputs_to_port(a, port)) {
1558             return true;
1559         }
1560     }
1561
1562     return false;
1563 }
1564
1565 bool
1566 ofpacts_equal(const struct ofpact *a, size_t a_len,
1567               const struct ofpact *b, size_t b_len)
1568 {
1569     return a_len == b_len && !memcmp(a, b, a_len);
1570 }
1571 \f
1572 /* Formatting ofpacts. */
1573
1574 static void
1575 print_note(const struct ofpact_note *note, struct ds *string)
1576 {
1577     size_t i;
1578
1579     ds_put_cstr(string, "note:");
1580     for (i = 0; i < note->length; i++) {
1581         if (i) {
1582             ds_put_char(string, '.');
1583         }
1584         ds_put_format(string, "%02"PRIx8, note->data[i]);
1585     }
1586 }
1587
1588 static void
1589 print_dec_ttl(const struct ofpact_cnt_ids *ids,
1590               struct ds *s)
1591 {
1592     size_t i;
1593
1594     ds_put_cstr(s, "dec_ttl");
1595     if (ids->ofpact.compat == OFPUTIL_NXAST_DEC_TTL_CNT_IDS) {
1596         ds_put_cstr(s, "(");
1597         for (i = 0; i < ids->n_controllers; i++) {
1598             if (i) {
1599                 ds_put_cstr(s, ",");
1600             }
1601             ds_put_format(s, "%"PRIu16, ids->cnt_ids[i]);
1602         }
1603         ds_put_cstr(s, ")");
1604     }
1605 }
1606
1607 static void
1608 print_fin_timeout(const struct ofpact_fin_timeout *fin_timeout,
1609                   struct ds *s)
1610 {
1611     ds_put_cstr(s, "fin_timeout(");
1612     if (fin_timeout->fin_idle_timeout) {
1613         ds_put_format(s, "idle_timeout=%"PRIu16",",
1614                       fin_timeout->fin_idle_timeout);
1615     }
1616     if (fin_timeout->fin_hard_timeout) {
1617         ds_put_format(s, "hard_timeout=%"PRIu16",",
1618                       fin_timeout->fin_hard_timeout);
1619     }
1620     ds_chomp(s, ',');
1621     ds_put_char(s, ')');
1622 }
1623
1624 static void
1625 ofpact_format(const struct ofpact *a, struct ds *s)
1626 {
1627     const struct ofpact_enqueue *enqueue;
1628     const struct ofpact_resubmit *resubmit;
1629     const struct ofpact_autopath *autopath;
1630     const struct ofpact_controller *controller;
1631     const struct ofpact_tunnel *tunnel;
1632     uint16_t port;
1633
1634     switch (a->type) {
1635     case OFPACT_OUTPUT:
1636         port = ofpact_get_OUTPUT(a)->port;
1637         if (port < OFPP_MAX) {
1638             ds_put_format(s, "output:%"PRIu16, port);
1639         } else {
1640             ofputil_format_port(port, s);
1641             if (port == OFPP_CONTROLLER) {
1642                 ds_put_format(s, ":%"PRIu16, ofpact_get_OUTPUT(a)->max_len);
1643             }
1644         }
1645         break;
1646
1647     case OFPACT_CONTROLLER:
1648         controller = ofpact_get_CONTROLLER(a);
1649         if (controller->reason == OFPR_ACTION &&
1650             controller->controller_id == 0) {
1651             ds_put_format(s, "CONTROLLER:%"PRIu16,
1652                           ofpact_get_CONTROLLER(a)->max_len);
1653         } else {
1654             enum ofp_packet_in_reason reason = controller->reason;
1655
1656             ds_put_cstr(s, "controller(");
1657             if (reason != OFPR_ACTION) {
1658                 ds_put_format(s, "reason=%s,",
1659                               ofputil_packet_in_reason_to_string(reason));
1660             }
1661             if (controller->max_len != UINT16_MAX) {
1662                 ds_put_format(s, "max_len=%"PRIu16",", controller->max_len);
1663             }
1664             if (controller->controller_id != 0) {
1665                 ds_put_format(s, "id=%"PRIu16",", controller->controller_id);
1666             }
1667             ds_chomp(s, ',');
1668             ds_put_char(s, ')');
1669         }
1670         break;
1671
1672     case OFPACT_ENQUEUE:
1673         enqueue = ofpact_get_ENQUEUE(a);
1674         ds_put_format(s, "enqueue:");
1675         ofputil_format_port(enqueue->port, s);
1676         ds_put_format(s, "q%"PRIu32, enqueue->queue);
1677         break;
1678
1679     case OFPACT_OUTPUT_REG:
1680         ds_put_cstr(s, "output:");
1681         mf_format_subfield(&ofpact_get_OUTPUT_REG(a)->src, s);
1682         break;
1683
1684     case OFPACT_BUNDLE:
1685         bundle_format(ofpact_get_BUNDLE(a), s);
1686         break;
1687
1688     case OFPACT_SET_VLAN_VID:
1689         ds_put_format(s, "mod_vlan_vid:%"PRIu16,
1690                       ofpact_get_SET_VLAN_VID(a)->vlan_vid);
1691         break;
1692
1693     case OFPACT_SET_VLAN_PCP:
1694         ds_put_format(s, "mod_vlan_pcp:%"PRIu8,
1695                       ofpact_get_SET_VLAN_PCP(a)->vlan_pcp);
1696         break;
1697
1698     case OFPACT_STRIP_VLAN:
1699         ds_put_cstr(s, "strip_vlan");
1700         break;
1701
1702     case OFPACT_SET_ETH_SRC:
1703         ds_put_format(s, "mod_dl_src:"ETH_ADDR_FMT,
1704                       ETH_ADDR_ARGS(ofpact_get_SET_ETH_SRC(a)->mac));
1705         break;
1706
1707     case OFPACT_SET_ETH_DST:
1708         ds_put_format(s, "mod_dl_dst:"ETH_ADDR_FMT,
1709                       ETH_ADDR_ARGS(ofpact_get_SET_ETH_DST(a)->mac));
1710         break;
1711
1712     case OFPACT_SET_IPV4_SRC:
1713         ds_put_format(s, "mod_nw_src:"IP_FMT,
1714                       IP_ARGS(&ofpact_get_SET_IPV4_SRC(a)->ipv4));
1715         break;
1716
1717     case OFPACT_SET_IPV4_DST:
1718         ds_put_format(s, "mod_nw_dst:"IP_FMT,
1719                       IP_ARGS(&ofpact_get_SET_IPV4_DST(a)->ipv4));
1720         break;
1721
1722     case OFPACT_SET_IPV4_DSCP:
1723         ds_put_format(s, "mod_nw_tos:%d", ofpact_get_SET_IPV4_DSCP(a)->dscp);
1724         break;
1725
1726     case OFPACT_SET_L4_SRC_PORT:
1727         ds_put_format(s, "mod_tp_src:%d", ofpact_get_SET_L4_SRC_PORT(a)->port);
1728         break;
1729
1730     case OFPACT_SET_L4_DST_PORT:
1731         ds_put_format(s, "mod_tp_dst:%d", ofpact_get_SET_L4_DST_PORT(a)->port);
1732         break;
1733
1734     case OFPACT_REG_MOVE:
1735         nxm_format_reg_move(ofpact_get_REG_MOVE(a), s);
1736         break;
1737
1738     case OFPACT_REG_LOAD:
1739         nxm_format_reg_load(ofpact_get_REG_LOAD(a), s);
1740         break;
1741
1742     case OFPACT_DEC_TTL:
1743         print_dec_ttl(ofpact_get_DEC_TTL(a), s);
1744         break;
1745
1746     case OFPACT_SET_TUNNEL:
1747         tunnel = ofpact_get_SET_TUNNEL(a);
1748         ds_put_format(s, "set_tunnel%s:%#"PRIx64,
1749                       (tunnel->tun_id > UINT32_MAX
1750                        || a->compat == OFPUTIL_NXAST_SET_TUNNEL64 ? "64" : ""),
1751                       tunnel->tun_id);
1752         break;
1753
1754     case OFPACT_SET_QUEUE:
1755         ds_put_format(s, "set_queue:%"PRIu32,
1756                       ofpact_get_SET_QUEUE(a)->queue_id);
1757         break;
1758
1759     case OFPACT_POP_QUEUE:
1760         ds_put_cstr(s, "pop_queue");
1761         break;
1762
1763     case OFPACT_FIN_TIMEOUT:
1764         print_fin_timeout(ofpact_get_FIN_TIMEOUT(a), s);
1765         break;
1766
1767     case OFPACT_RESUBMIT:
1768         resubmit = ofpact_get_RESUBMIT(a);
1769         if (resubmit->in_port != OFPP_IN_PORT && resubmit->table_id == 255) {
1770             ds_put_format(s, "resubmit:%"PRIu16, resubmit->in_port);
1771         } else {
1772             ds_put_format(s, "resubmit(");
1773             if (resubmit->in_port != OFPP_IN_PORT) {
1774                 ofputil_format_port(resubmit->in_port, s);
1775             }
1776             ds_put_char(s, ',');
1777             if (resubmit->table_id != 255) {
1778                 ds_put_format(s, "%"PRIu8, resubmit->table_id);
1779             }
1780             ds_put_char(s, ')');
1781         }
1782         break;
1783
1784     case OFPACT_LEARN:
1785         learn_format(ofpact_get_LEARN(a), s);
1786         break;
1787
1788     case OFPACT_MULTIPATH:
1789         multipath_format(ofpact_get_MULTIPATH(a), s);
1790         break;
1791
1792     case OFPACT_AUTOPATH:
1793         autopath = ofpact_get_AUTOPATH(a);
1794         ds_put_format(s, "autopath(%u,", autopath->port);
1795         mf_format_subfield(&autopath->dst, s);
1796         ds_put_char(s, ')');
1797         break;
1798
1799     case OFPACT_NOTE:
1800         print_note(ofpact_get_NOTE(a), s);
1801         break;
1802
1803     case OFPACT_EXIT:
1804         ds_put_cstr(s, "exit");
1805         break;
1806     }
1807 }
1808
1809 /* Appends a string representing the 'ofpacts_len' bytes of ofpacts in
1810  * 'ofpacts' to 'string'. */
1811 void
1812 ofpacts_format(const struct ofpact *ofpacts, size_t ofpacts_len,
1813                struct ds *string)
1814 {
1815     ds_put_cstr(string, "actions=");
1816     if (!ofpacts_len) {
1817         ds_put_cstr(string, "drop");
1818     } else {
1819         const struct ofpact *a;
1820
1821         OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
1822             if (a != ofpacts) {
1823                 ds_put_cstr(string, ",");
1824             }
1825             ofpact_format(a, string);
1826         }
1827     }
1828 }
1829 \f
1830 /* Internal use by helpers. */
1831
1832 void *
1833 ofpact_put(struct ofpbuf *ofpacts, enum ofpact_type type, size_t len)
1834 {
1835     struct ofpact *ofpact;
1836
1837     ofpact_pad(ofpacts);
1838     ofpact = ofpacts->l2 = ofpbuf_put_uninit(ofpacts, len);
1839     ofpact_init(ofpact, type, len);
1840     return ofpact;
1841 }
1842
1843 void
1844 ofpact_init(struct ofpact *ofpact, enum ofpact_type type, size_t len)
1845 {
1846     memset(ofpact, 0, len);
1847     ofpact->type = type;
1848     ofpact->compat = OFPUTIL_ACTION_INVALID;
1849     ofpact->len = len;
1850 }
1851 \f
1852 /* Updates 'ofpact->len' to the number of bytes in the tail of 'ofpacts'
1853  * starting at 'ofpact'.
1854  *
1855  * This is the correct way to update a variable-length ofpact's length after
1856  * adding the variable-length part of the payload.  (See the large comment
1857  * near the end of ofp-actions.h for more information.) */
1858 void
1859 ofpact_update_len(struct ofpbuf *ofpacts, struct ofpact *ofpact)
1860 {
1861     assert(ofpact == ofpacts->l2);
1862     ofpact->len = (char *) ofpbuf_tail(ofpacts) - (char *) ofpact;
1863 }
1864
1865 /* Pads out 'ofpacts' to a multiple of OFPACT_ALIGNTO bytes in length.  Each
1866  * ofpact_put_<ENUM>() calls this function automatically beforehand, but the
1867  * client must call this itself after adding the final ofpact to an array of
1868  * them.
1869  *
1870  * (The consequences of failing to call this function are probably not dire.
1871  * OFPACT_FOR_EACH will calculate a pointer beyond the end of the ofpacts, but
1872  * not dereference it.  That's undefined behavior, technically, but it will not
1873  * cause a real problem on common systems.  Still, it seems better to call
1874  * it.) */
1875 void
1876 ofpact_pad(struct ofpbuf *ofpacts)
1877 {
1878     unsigned int rem = ofpacts->size % OFPACT_ALIGNTO;
1879     if (rem) {
1880         ofpbuf_put_zeros(ofpacts, OFPACT_ALIGNTO - rem);
1881     }
1882 }