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