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