lib/ofp-actions.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include "ofp-actions.h"
  19 #include "bundle.h"
  20 #include "byte-order.h"
  21 #include "compiler.h"
  22 #include "dynamic-string.h"
  23 #include "learn.h"
  24 #include "meta-flow.h"
  25 #include "multipath.h"
  26 #include "nx-match.h"
  27 #include "ofp-util.h"
  28 #include "ofpbuf.h"
  29 #include "util.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 union ofp_action {
  39     ovs_be16 type;
  40     struct ofp_action_header header;
  41     struct ofp_action_vendor_header vendor;
  42     struct ofp10_action_output output10;
  43     struct ofp_action_vlan_vid vlan_vid;
  44     struct ofp_action_vlan_pcp vlan_pcp;
  45     struct ofp_action_nw_addr nw_addr;
  46     struct ofp_action_nw_tos nw_tos;
  47     struct ofp11_action_nw_ecn nw_ecn;
  48     struct ofp11_action_nw_ttl nw_ttl;
  49     struct ofp_action_tp_port tp_port;
  50     struct ofp_action_dl_addr dl_addr;
  51     struct ofp10_action_enqueue enqueue;
  52     struct ofp11_action_output ofp11_output;
  53     struct ofp11_action_push push;
  54     struct ofp11_action_pop_mpls ofp11_pop_mpls;
  55     struct ofp11_action_set_queue ofp11_set_queue;
  56     struct ofp11_action_mpls_label ofp11_mpls_label;
  57     struct ofp11_action_mpls_tc ofp11_mpls_tc;
  58     struct ofp11_action_mpls_ttl ofp11_mpls_ttl;
  59     struct ofp11_action_group group;
  60     struct ofp12_action_set_field set_field;
  61     struct nx_action_header nxa_header;
  62     struct nx_action_resubmit resubmit;
  63     struct nx_action_set_tunnel set_tunnel;
  64     struct nx_action_set_tunnel64 set_tunnel64;
  65     struct nx_action_write_metadata write_metadata;
  66     struct nx_action_set_queue set_queue;
  67     struct nx_action_reg_move reg_move;
  68     struct nx_action_reg_load reg_load;
  69     struct nx_action_stack stack;
  70     struct nx_action_note note;
  71     struct nx_action_multipath multipath;
  72     struct nx_action_bundle bundle;
  73     struct nx_action_output_reg output_reg;
  74     struct nx_action_cnt_ids cnt_ids;
  75     struct nx_action_fin_timeout fin_timeout;
  76     struct nx_action_controller controller;
  77     struct nx_action_push_mpls push_mpls;
  78     struct nx_action_mpls_ttl mpls_ttl;
  79     struct nx_action_pop_mpls pop_mpls;
  80     struct nx_action_sample sample;
  81     struct nx_action_learn learn;
  82     struct nx_action_mpls_label mpls_label;
  83     struct nx_action_mpls_tc mpls_tc;
  84 };
  85
  86 static enum ofperr
  87 output_from_openflow10(const struct ofp10_action_output *oao,
  88                        struct ofpbuf *out)
  89 {
  90     struct ofpact_output *output;
  91
  92     output = ofpact_put_OUTPUT(out);
  93     output->port = u16_to_ofp(ntohs(oao->port));
  94     output->max_len = ntohs(oao->max_len);
  95
  96     return ofpact_check_output_port(output->port, OFPP_MAX);
  97 }
  98
  99 static enum ofperr
 100 enqueue_from_openflow10(const struct ofp10_action_enqueue *oae,
 101                         struct ofpbuf *out)
 102 {
 103     struct ofpact_enqueue *enqueue;
 104
 105     enqueue = ofpact_put_ENQUEUE(out);
 106     enqueue->port = u16_to_ofp(ntohs(oae->port));
 107     enqueue->queue = ntohl(oae->queue_id);
 108     if (ofp_to_u16(enqueue->port) >= ofp_to_u16(OFPP_MAX)
 109         && enqueue->port != OFPP_IN_PORT
 110         && enqueue->port != OFPP_LOCAL) {
 111         return OFPERR_OFPBAC_BAD_OUT_PORT;
 112     }
 113     return 0;
 114 }
 115
 116 static void
 117 resubmit_from_openflow(const struct nx_action_resubmit *nar,
 118                        struct ofpbuf *out)
 119 {
 120     struct ofpact_resubmit *resubmit;
 121
 122     resubmit = ofpact_put_RESUBMIT(out);
 123     resubmit->ofpact.compat = OFPUTIL_NXAST_RESUBMIT;
 124     resubmit->in_port = u16_to_ofp(ntohs(nar->in_port));
 125     resubmit->table_id = 0xff;
 126 }
 127
 128 static enum ofperr
 129 resubmit_table_from_openflow(const struct nx_action_resubmit *nar,
 130                              struct ofpbuf *out)
 131 {
 132     struct ofpact_resubmit *resubmit;
 133
 134     if (nar->pad[0] || nar->pad[1] || nar->pad[2]) {
 135         return OFPERR_OFPBAC_BAD_ARGUMENT;
 136     }
 137
 138     resubmit = ofpact_put_RESUBMIT(out);
 139     resubmit->ofpact.compat = OFPUTIL_NXAST_RESUBMIT_TABLE;
 140     resubmit->in_port = u16_to_ofp(ntohs(nar->in_port));
 141     resubmit->table_id = nar->table;
 142     return 0;
 143 }
 144
 145 static enum ofperr
 146 output_reg_from_openflow(const struct nx_action_output_reg *naor,
 147                          struct ofpbuf *out)
 148 {
 149     struct ofpact_output_reg *output_reg;
 150
 151     if (!is_all_zeros(naor->zero, sizeof naor->zero)) {
 152         return OFPERR_OFPBAC_BAD_ARGUMENT;
 153     }
 154
 155     output_reg = ofpact_put_OUTPUT_REG(out);
 156     output_reg->src.field = mf_from_nxm_header(ntohl(naor->src));
 157     output_reg->src.ofs = nxm_decode_ofs(naor->ofs_nbits);
 158     output_reg->src.n_bits = nxm_decode_n_bits(naor->ofs_nbits);
 159     output_reg->max_len = ntohs(naor->max_len);
 160
 161     return mf_check_src(&output_reg->src, NULL);
 162 }
 163
 164 static void
 165 fin_timeout_from_openflow(const struct nx_action_fin_timeout *naft,
 166                           struct ofpbuf *out)
 167 {
 168     struct ofpact_fin_timeout *oft;
 169
 170     oft = ofpact_put_FIN_TIMEOUT(out);
 171     oft->fin_idle_timeout = ntohs(naft->fin_idle_timeout);
 172     oft->fin_hard_timeout = ntohs(naft->fin_hard_timeout);
 173 }
 174
 175 static void
 176 controller_from_openflow(const struct nx_action_controller *nac,
 177                          struct ofpbuf *out)
 178 {
 179     struct ofpact_controller *oc;
 180
 181     oc = ofpact_put_CONTROLLER(out);
 182     oc->max_len = ntohs(nac->max_len);
 183     oc->controller_id = ntohs(nac->controller_id);
 184     oc->reason = nac->reason;
 185 }
 186
 187 static enum ofperr
 188 metadata_from_nxast(const struct nx_action_write_metadata *nawm,
 189                     struct ofpbuf *out)
 190 {
 191     struct ofpact_metadata *om;
 192
 193     if (!is_all_zeros(nawm->zeros, sizeof nawm->zeros)) {
 194         return OFPERR_NXBRC_MUST_BE_ZERO;
 195     }
 196
 197     om = ofpact_put_WRITE_METADATA(out);
 198     om->metadata = nawm->metadata;
 199     om->mask = nawm->mask;
 200
 201     return 0;
 202 }
 203
 204 static void
 205 note_from_openflow(const struct nx_action_note *nan, struct ofpbuf *out)
 206 {
 207     struct ofpact_note *note;
 208     unsigned int length;
 209
 210     length = ntohs(nan->len) - offsetof(struct nx_action_note, note);
 211     note = ofpact_put(out, OFPACT_NOTE,
 212                       offsetof(struct ofpact_note, data) + length);
 213     note->length = length;
 214     memcpy(note->data, nan->note, length);
 215 }
 216
 217 static enum ofperr
 218 dec_ttl_from_openflow(struct ofpbuf *out, enum ofputil_action_code compat)
 219 {
 220     uint16_t id = 0;
 221     struct ofpact_cnt_ids *ids;
 222     enum ofperr error = 0;
 223
 224     ids = ofpact_put_DEC_TTL(out);
 225     ids->ofpact.compat = compat;
 226     ids->n_controllers = 1;
 227     ofpbuf_put(out, &id, sizeof id);
 228     ids = out->frame;
 229     ofpact_update_len(out, &ids->ofpact);
 230     return error;
 231 }
 232
 233 static enum ofperr
 234 dec_ttl_cnt_ids_from_openflow(const struct nx_action_cnt_ids *nac_ids,
 235                               struct ofpbuf *out)
 236 {
 237     struct ofpact_cnt_ids *ids;
 238     size_t ids_size;
 239     int i;
 240
 241     ids = ofpact_put_DEC_TTL(out);
 242     ids->ofpact.compat = OFPUTIL_NXAST_DEC_TTL_CNT_IDS;
 243     ids->n_controllers = ntohs(nac_ids->n_controllers);
 244     ids_size = ntohs(nac_ids->len) - sizeof *nac_ids;
 245
 246     if (!is_all_zeros(nac_ids->zeros, sizeof nac_ids->zeros)) {
 247         return OFPERR_NXBRC_MUST_BE_ZERO;
 248     }
 249
 250     if (ids_size < ids->n_controllers * sizeof(ovs_be16)) {
 251         VLOG_WARN_RL(&rl, "Nicira action dec_ttl_cnt_ids only has %"PRIuSIZE" bytes "
 252                      "allocated for controller ids.  %"PRIuSIZE" bytes are required for "
 253                      "%"PRIu16" controllers.", ids_size,
 254                      ids->n_controllers * sizeof(ovs_be16), ids->n_controllers);
 255         return OFPERR_OFPBAC_BAD_LEN;
 256     }
 257
 258     for (i = 0; i < ids->n_controllers; i++) {
 259         uint16_t id = ntohs(((ovs_be16 *)(nac_ids + 1))[i]);
 260         ofpbuf_put(out, &id, sizeof id);
 261         ids = out->frame;
 262     }
 263
 264     ofpact_update_len(out, &ids->ofpact);
 265
 266     return 0;
 267 }
 268
 269 static enum ofperr
 270 sample_from_openflow(const struct nx_action_sample *nas,
 271                      struct ofpbuf *out)
 272 {
 273     struct ofpact_sample *sample;
 274
 275     sample = ofpact_put_SAMPLE(out);
 276     sample->probability = ntohs(nas->probability);
 277     sample->collector_set_id = ntohl(nas->collector_set_id);
 278     sample->obs_domain_id = ntohl(nas->obs_domain_id);
 279     sample->obs_point_id = ntohl(nas->obs_point_id);
 280
 281     if (sample->probability == 0) {
 282         return OFPERR_OFPBAC_BAD_ARGUMENT;
 283     }
 284
 285     return 0;
 286 }
 287
 288 static enum ofperr
 289 push_mpls_from_openflow(ovs_be16 ethertype, struct ofpbuf *out)
 290 {
 291     struct ofpact_push_mpls *oam;
 292
 293     if (!eth_type_mpls(ethertype)) {
 294         return OFPERR_OFPBAC_BAD_ARGUMENT;
 295     }
 296     oam = ofpact_put_PUSH_MPLS(out);
 297     oam->ethertype = ethertype;
 298
 299     return 0;
 300 }
 301
 302 static enum ofperr
 303 decode_nxast_action(const union ofp_action *a, enum ofputil_action_code *code)
 304 {
 305     const struct nx_action_header *nah = &a->nxa_header;
 306     uint16_t len = ntohs(a->header.len);
 307
 308     if (len < sizeof(struct nx_action_header)) {
 309         return OFPERR_OFPBAC_BAD_LEN;
 310     } else if (a->vendor.vendor != CONSTANT_HTONL(NX_VENDOR_ID)) {
 311         return OFPERR_OFPBAC_BAD_VENDOR;
 312     }
 313
 314     switch (nah->subtype) {
 315 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME)    \
 316         case CONSTANT_HTONS(ENUM):                      \
 317             if (EXTENSIBLE                              \
 318                 ? len >= sizeof(struct STRUCT)          \
 319                 : len == sizeof(struct STRUCT)) {       \
 320                 *code = OFPUTIL_##ENUM;                 \
 321                 return 0;                               \
 322             } else {                                    \
 323                 return OFPERR_OFPBAC_BAD_LEN;           \
 324             }                                           \
 325             OVS_NOT_REACHED();
 326 #include "ofp-util.def"
 327
 328     case CONSTANT_HTONS(NXAST_SNAT__OBSOLETE):
 329     case CONSTANT_HTONS(NXAST_DROP_SPOOFED_ARP__OBSOLETE):
 330     default:
 331         return OFPERR_OFPBAC_BAD_TYPE;
 332     }
 333 }
 334
 335 /* Parses 'a' to determine its type.  On success stores the correct type into
 336  * '*code' and returns 0.  On failure returns an OFPERR_* error code and
 337  * '*code' is indeterminate.
 338  *
 339  * The caller must have already verified that 'a''s length is potentially
 340  * correct (that is, a->header.len is nonzero and a multiple of
 341  * OFP_ACTION_ALIGN and no longer than the amount of space allocated to 'a').
 342  *
 343  * This function verifies that 'a''s length is correct for the type of action
 344  * that it represents. */
 345 static enum ofperr
 346 decode_openflow10_action(const union ofp_action *a,
 347                          enum ofputil_action_code *code)
 348 {
 349     switch (a->type) {
 350     case CONSTANT_HTONS(OFPAT10_VENDOR):
 351         return decode_nxast_action(a, code);
 352
 353 #define OFPAT10_ACTION(ENUM, STRUCT, NAME)                          \
 354         case CONSTANT_HTONS(ENUM):                                  \
 355             if (a->header.len == htons(sizeof(struct STRUCT))) {    \
 356                 *code = OFPUTIL_##ENUM;                             \
 357                 return 0;                                           \
 358             } else {                                                \
 359                 return OFPERR_OFPBAC_BAD_LEN;                       \
 360             }                                                       \
 361             break;
 362 #include "ofp-util.def"
 363
 364     default:
 365         return OFPERR_OFPBAC_BAD_TYPE;
 366     }
 367 }
 368
 369 static enum ofperr
 370 ofpact_from_nxast(const union ofp_action *a, enum ofputil_action_code code,
 371                   struct ofpbuf *out)
 372 {
 373     struct ofpact_tunnel *tunnel;
 374     enum ofperr error = 0;
 375
 376     switch (code) {
 377     case OFPUTIL_ACTION_INVALID:
 378 #define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
 379 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
 380 #define OFPAT13_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
 381 #include "ofp-util.def"
 382         OVS_NOT_REACHED();
 383
 384     case OFPUTIL_NXAST_RESUBMIT:
 385         resubmit_from_openflow(&a->resubmit, out);
 386         break;
 387
 388     case OFPUTIL_NXAST_SET_TUNNEL:
 389         tunnel = ofpact_put_SET_TUNNEL(out);
 390         tunnel->ofpact.compat = code;
 391         tunnel->tun_id = ntohl(a->set_tunnel.tun_id);
 392         break;
 393
 394     case OFPUTIL_NXAST_WRITE_METADATA:
 395         error = metadata_from_nxast(&a->write_metadata, out);
 396         break;
 397
 398     case OFPUTIL_NXAST_SET_QUEUE:
 399         ofpact_put_SET_QUEUE(out)->queue_id = ntohl(a->set_queue.queue_id);
 400         break;
 401
 402     case OFPUTIL_NXAST_POP_QUEUE:
 403         ofpact_put_POP_QUEUE(out);
 404         break;
 405
 406     case OFPUTIL_NXAST_REG_MOVE:
 407         error = nxm_reg_move_from_openflow(&a->reg_move, out);
 408         break;
 409
 410     case OFPUTIL_NXAST_REG_LOAD:
 411         error = nxm_reg_load_from_openflow(&a->reg_load, out);
 412         break;
 413
 414     case OFPUTIL_NXAST_STACK_PUSH:
 415         error = nxm_stack_push_from_openflow(&a->stack, out);
 416         break;
 417
 418     case OFPUTIL_NXAST_STACK_POP:
 419         error = nxm_stack_pop_from_openflow(&a->stack, out);
 420         break;
 421
 422     case OFPUTIL_NXAST_NOTE:
 423         note_from_openflow(&a->note, out);
 424         break;
 425
 426     case OFPUTIL_NXAST_SET_TUNNEL64:
 427         tunnel = ofpact_put_SET_TUNNEL(out);
 428         tunnel->ofpact.compat = code;
 429         tunnel->tun_id = ntohll(a->set_tunnel64.tun_id);
 430         break;
 431
 432     case OFPUTIL_NXAST_MULTIPATH:
 433         error = multipath_from_openflow(&a->multipath,
 434                                         ofpact_put_MULTIPATH(out));
 435         break;
 436
 437     case OFPUTIL_NXAST_BUNDLE:
 438     case OFPUTIL_NXAST_BUNDLE_LOAD:
 439         error = bundle_from_openflow(&a->bundle, out);
 440         break;
 441
 442     case OFPUTIL_NXAST_OUTPUT_REG:
 443         error = output_reg_from_openflow(&a->output_reg, out);
 444         break;
 445
 446     case OFPUTIL_NXAST_RESUBMIT_TABLE:
 447         error = resubmit_table_from_openflow(&a->resubmit, out);
 448         break;
 449
 450     case OFPUTIL_NXAST_LEARN:
 451         error = learn_from_openflow(&a->learn, out);
 452         break;
 453
 454     case OFPUTIL_NXAST_EXIT:
 455         ofpact_put_EXIT(out);
 456         break;
 457
 458     case OFPUTIL_NXAST_DEC_TTL:
 459         error = dec_ttl_from_openflow(out, code);
 460         break;
 461
 462     case OFPUTIL_NXAST_DEC_TTL_CNT_IDS:
 463         error = dec_ttl_cnt_ids_from_openflow(&a->cnt_ids, out);
 464         break;
 465
 466     case OFPUTIL_NXAST_FIN_TIMEOUT:
 467         fin_timeout_from_openflow(&a->fin_timeout, out);
 468         break;
 469
 470     case OFPUTIL_NXAST_CONTROLLER:
 471         controller_from_openflow(&a->controller, out);
 472         break;
 473
 474     case OFPUTIL_NXAST_PUSH_MPLS:
 475         error = push_mpls_from_openflow(a->push_mpls.ethertype, out);
 476         break;
 477
 478     case OFPUTIL_NXAST_SET_MPLS_LABEL:
 479         ofpact_put_SET_MPLS_LABEL(out)->label = a->mpls_label.label;
 480         break;
 481
 482     case OFPUTIL_NXAST_SET_MPLS_TC:
 483         ofpact_put_SET_MPLS_TC(out)->tc = a->mpls_tc.tc;
 484         break;
 485
 486     case OFPUTIL_NXAST_SET_MPLS_TTL:
 487         ofpact_put_SET_MPLS_TTL(out)->ttl = a->mpls_ttl.ttl;
 488         break;
 489
 490     case OFPUTIL_NXAST_DEC_MPLS_TTL:
 491         ofpact_put_DEC_MPLS_TTL(out);
 492         break;
 493
 494     case OFPUTIL_NXAST_POP_MPLS:
 495         ofpact_put_POP_MPLS(out)->ethertype = a->pop_mpls.ethertype;
 496         break;
 497
 498     case OFPUTIL_NXAST_SAMPLE:
 499         error = sample_from_openflow(&a->sample, out);
 500         break;
 501     }
 502
 503     return error;
 504 }
 505
 506 static enum ofperr
 507 ofpact_from_openflow10(const union ofp_action *a,
 508                        enum ofp_version version OVS_UNUSED,
 509                        struct ofpbuf *out)
 510 {
 511     enum ofputil_action_code code;
 512     enum ofperr error;
 513     struct ofpact_vlan_vid *vlan_vid;
 514     struct ofpact_vlan_pcp *vlan_pcp;
 515
 516     error = decode_openflow10_action(a, &code);
 517     if (error) {
 518         return error;
 519     }
 520
 521     switch (code) {
 522     case OFPUTIL_ACTION_INVALID:
 523 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
 524 #define OFPAT13_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
 525 #include "ofp-util.def"
 526         OVS_NOT_REACHED();
 527
 528     case OFPUTIL_OFPAT10_OUTPUT:
 529         return output_from_openflow10(&a->output10, out);
 530
 531     case OFPUTIL_OFPAT10_SET_VLAN_VID:
 532         if (a->vlan_vid.vlan_vid & ~htons(0xfff)) {
 533             return OFPERR_OFPBAC_BAD_ARGUMENT;
 534         }
 535         vlan_vid = ofpact_put_SET_VLAN_VID(out);
 536         vlan_vid->vlan_vid = ntohs(a->vlan_vid.vlan_vid);
 537         vlan_vid->push_vlan_if_needed = true;
 538         vlan_vid->ofpact.compat = code;
 539         break;
 540
 541     case OFPUTIL_OFPAT10_SET_VLAN_PCP:
 542         if (a->vlan_pcp.vlan_pcp & ~7) {
 543             return OFPERR_OFPBAC_BAD_ARGUMENT;
 544         }
 545         vlan_pcp = ofpact_put_SET_VLAN_PCP(out);
 546         vlan_pcp->vlan_pcp = a->vlan_pcp.vlan_pcp;
 547         vlan_pcp->push_vlan_if_needed = true;
 548         vlan_pcp->ofpact.compat = code;
 549         break;
 550
 551     case OFPUTIL_OFPAT10_STRIP_VLAN:
 552         ofpact_put_STRIP_VLAN(out)->ofpact.compat = code;
 553         break;
 554
 555     case OFPUTIL_OFPAT10_SET_DL_SRC:
 556         memcpy(ofpact_put_SET_ETH_SRC(out)->mac, a->dl_addr.dl_addr,
 557                ETH_ADDR_LEN);
 558         break;
 559
 560     case OFPUTIL_OFPAT10_SET_DL_DST:
 561         memcpy(ofpact_put_SET_ETH_DST(out)->mac, a->dl_addr.dl_addr,
 562                ETH_ADDR_LEN);
 563         break;
 564
 565     case OFPUTIL_OFPAT10_SET_NW_SRC:
 566         ofpact_put_SET_IPV4_SRC(out)->ipv4 = a->nw_addr.nw_addr;
 567         break;
 568
 569     case OFPUTIL_OFPAT10_SET_NW_DST:
 570         ofpact_put_SET_IPV4_DST(out)->ipv4 = a->nw_addr.nw_addr;
 571         break;
 572
 573     case OFPUTIL_OFPAT10_SET_NW_TOS:
 574         if (a->nw_tos.nw_tos & ~IP_DSCP_MASK) {
 575             return OFPERR_OFPBAC_BAD_ARGUMENT;
 576         }
 577         ofpact_put_SET_IP_DSCP(out)->dscp = a->nw_tos.nw_tos;
 578         break;
 579
 580     case OFPUTIL_OFPAT10_SET_TP_SRC:
 581         ofpact_put_SET_L4_SRC_PORT(out)->port = ntohs(a->tp_port.tp_port);
 582         break;
 583
 584     case OFPUTIL_OFPAT10_SET_TP_DST:
 585         ofpact_put_SET_L4_DST_PORT(out)->port = ntohs(a->tp_port.tp_port);
 586
 587         break;
 588
 589     case OFPUTIL_OFPAT10_ENQUEUE:
 590         error = enqueue_from_openflow10(&a->enqueue, out);
 591         break;
 592
 593 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
 594 #include "ofp-util.def"
 595         return ofpact_from_nxast(a, code, out);
 596     }
 597
 598     return error;
 599 }
 600
 601 static enum ofperr ofpact_from_openflow11(const union ofp_action *,
 602                                           enum ofp_version,
 603                                           struct ofpbuf *out);
 604
 605 static inline union ofp_action *
 606 action_next(const union ofp_action *a)
 607 {
 608     return ((union ofp_action *) (void *)
 609             ((uint8_t *) a + ntohs(a->header.len)));
 610 }
 611
 612 static inline bool
 613 action_is_valid(const union ofp_action *a, size_t max_actions)
 614 {
 615     uint16_t len = ntohs(a->header.len);
 616     return (!(len % OFP_ACTION_ALIGN)
 617             && len >= OFP_ACTION_ALIGN
 618             && len / OFP_ACTION_ALIGN <= max_actions);
 619 }
 620
 621 /* This macro is careful to check for actions with bad lengths. */
 622 #define ACTION_FOR_EACH(ITER, LEFT, ACTIONS, MAX_ACTIONS)                 \
 623     for ((ITER) = (ACTIONS), (LEFT) = (MAX_ACTIONS);                      \
 624          (LEFT) > 0 && action_is_valid(ITER, LEFT);                     \
 625          ((LEFT) -= ntohs((ITER)->header.len) / OFP_ACTION_ALIGN, \
 626           (ITER) = action_next(ITER)))
 627
 628 static void
 629 log_bad_action(const union ofp_action *actions, size_t max_actions,
 630                const union ofp_action *bad_action, enum ofperr error)
 631 {
 632     if (!VLOG_DROP_WARN(&rl)) {
 633         struct ds s;
 634
 635         ds_init(&s);
 636         ds_put_hex_dump(&s, actions, max_actions * OFP_ACTION_ALIGN, 0, false);
 637         VLOG_WARN("bad action at offset %#"PRIxPTR" (%s):\n%s",
 638                   (char *)bad_action - (char *)actions,
 639                   ofperr_get_name(error), ds_cstr(&s));
 640         ds_destroy(&s);
 641     }
 642 }
 643
 644 static enum ofperr
 645 ofpacts_from_openflow(const union ofp_action *in, size_t n_in,
 646                       enum ofp_version version, struct ofpbuf *out)
 647 {
 648     const union ofp_action *a;
 649     size_t left;
 650
 651     enum ofperr (*ofpact_from_openflow)(const union ofp_action *a,
 652                                         enum ofp_version,
 653                                         struct ofpbuf *out) =
 654         (version == OFP10_VERSION) ?
 655         ofpact_from_openflow10 : ofpact_from_openflow11;
 656
 657     ACTION_FOR_EACH (a, left, in, n_in) {
 658         enum ofperr error = ofpact_from_openflow(a, version, out);
 659         if (error) {
 660             log_bad_action(in, n_in, a, error);
 661             return error;
 662         }
 663     }
 664     if (left) {
 665         enum ofperr error = OFPERR_OFPBAC_BAD_LEN;
 666         log_bad_action(in, n_in, a, error);
 667         return error;
 668     }
 669
 670     ofpact_pad(out);
 671     return 0;
 672 }
 673
 674 /* Attempts to convert 'actions_len' bytes of OpenFlow actions from the
 675  * front of 'openflow' into ofpacts.  On success, replaces any existing content
 676  * in 'ofpacts' by the converted ofpacts; on failure, clears 'ofpacts'.
 677  * Returns 0 if successful, otherwise an OpenFlow error.
 678  *
 679  * Actions are processed according to their OpenFlow version which
 680  * is provided in the 'version' parameter.
 681  *
 682  * In most places in OpenFlow 1.1 and 1.2, actions appear encapsulated in
 683  * instructions, so you should call ofpacts_pull_openflow_instructions()
 684  * instead of this function.
 685  *
 686  * The parsed actions are valid generically, but they may not be valid in a
 687  * specific context.  For example, port numbers up to OFPP_MAX are valid
 688  * generically, but specific datapaths may only support port numbers in a
 689  * smaller range.  Use ofpacts_check() to additional check whether actions are
 690  * valid in a specific context. */
 691 enum ofperr
 692 ofpacts_pull_openflow_actions(struct ofpbuf *openflow,
 693                               unsigned int actions_len,
 694                               enum ofp_version version,
 695                               struct ofpbuf *ofpacts) {
 696     const union ofp_action *actions;
 697     enum ofperr error;
 698
 699     ofpbuf_clear(ofpacts);
 700
 701     if (actions_len % OFP_ACTION_ALIGN != 0) {
 702         VLOG_WARN_RL(&rl, "OpenFlow message actions length %u is not a "
 703                      "multiple of %d", actions_len, OFP_ACTION_ALIGN);
 704         return OFPERR_OFPBRC_BAD_LEN;
 705     }
 706
 707     actions = ofpbuf_try_pull(openflow, actions_len);
 708     if (actions == NULL) {
 709         VLOG_WARN_RL(&rl, "OpenFlow message actions length %u exceeds "
 710                      "remaining message length (%"PRIu32")",
 711                      actions_len, ofpbuf_size(openflow));
 712         return OFPERR_OFPBRC_BAD_LEN;
 713     }
 714
 715     error = ofpacts_from_openflow(actions, actions_len / OFP_ACTION_ALIGN,
 716                                   version, ofpacts);
 717     if (error) {
 718         ofpbuf_clear(ofpacts);
 719         return error;
 720     }
 721
 722     error = ofpacts_verify(ofpbuf_data(ofpacts), ofpbuf_size(ofpacts));
 723     if (error) {
 724         ofpbuf_clear(ofpacts);
 725     }
 726     return error;
 727 }
 728
 729 \f
 730 /* OpenFlow 1.1 actions. */
 731
 732 /* Parses 'a' to determine its type.  On success stores the correct type into
 733  * '*code' and returns 0.  On failure returns an OFPERR_* error code and
 734  * '*code' is indeterminate.
 735  *
 736  * The caller must have already verified that 'a''s length is potentially
 737  * correct (that is, a->header.len is nonzero and a multiple of
 738  * OFP_ACTION_ALIGN and no longer than the amount of space allocated to 'a').
 739  *
 740  * This function verifies that 'a''s length is correct for the type of action
 741  * that it represents. */
 742 static enum ofperr
 743 decode_openflow11_action(const union ofp_action *a,
 744                          enum ofputil_action_code *code)
 745 {
 746     uint16_t len;
 747
 748     switch (a->type) {
 749     case CONSTANT_HTONS(OFPAT11_EXPERIMENTER):
 750         return decode_nxast_action(a, code);
 751
 752 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME)  \
 753         case CONSTANT_HTONS(ENUM):                      \
 754             len = ntohs(a->header.len);                 \
 755             if (EXTENSIBLE                              \
 756                 ? len >= sizeof(struct STRUCT)          \
 757                 : len == sizeof(struct STRUCT)) {       \
 758                 *code = OFPUTIL_##ENUM;                 \
 759                 return 0;                               \
 760             } else {                                    \
 761                 return OFPERR_OFPBAC_BAD_LEN;           \
 762             }                                           \
 763             OVS_NOT_REACHED();
 764 #include "ofp-util.def"
 765
 766     default:
 767         return OFPERR_OFPBAC_BAD_TYPE;
 768     }
 769 }
 770
 771 static enum ofperr
 772 set_field_from_openflow(const struct ofp12_action_set_field *oasf,
 773                         struct ofpbuf *ofpacts)
 774 {
 775     uint16_t oasf_len = ntohs(oasf->len);
 776     uint32_t oxm_header = ntohl(oasf->dst);
 777     uint8_t oxm_length = NXM_LENGTH(oxm_header);
 778     struct ofpact_set_field *sf;
 779     const struct mf_field *mf;
 780
 781     /* ofp12_action_set_field is padded to 64 bits by zero */
 782     if (oasf_len != ROUND_UP(sizeof *oasf + oxm_length, 8)) {
 783         return OFPERR_OFPBAC_BAD_SET_LEN;
 784     }
 785     if (!is_all_zeros((const uint8_t *)oasf + sizeof *oasf + oxm_length,
 786                       oasf_len - oxm_length - sizeof *oasf)) {
 787         return OFPERR_OFPBAC_BAD_SET_ARGUMENT;
 788     }
 789
 790     if (NXM_HASMASK(oxm_header)) {
 791         return OFPERR_OFPBAC_BAD_SET_TYPE;
 792     }
 793     mf = mf_from_nxm_header(oxm_header);
 794     if (!mf) {
 795         return OFPERR_OFPBAC_BAD_SET_TYPE;
 796     }
 797     ovs_assert(mf->n_bytes == oxm_length);
 798     /* oxm_length is now validated to be compatible with mf_value. */
 799     if (!mf->writable) {
 800         VLOG_WARN_RL(&rl, "destination field %s is not writable", mf->name);
 801         return OFPERR_OFPBAC_BAD_SET_ARGUMENT;
 802     }
 803     sf = ofpact_put_SET_FIELD(ofpacts);
 804     sf->field = mf;
 805     memcpy(&sf->value, oasf + 1, mf->n_bytes);
 806
 807     /* The value must be valid for match and must have the OFPVID_PRESENT bit
 808      * on for OXM_OF_VLAN_VID. */
 809     if (!mf_is_value_valid(mf, &sf->value)
 810         || (mf->id == MFF_VLAN_VID
 811             && !(sf->value.be16 & htons(OFPVID12_PRESENT)))) {
 812         struct ds ds = DS_EMPTY_INITIALIZER;
 813         mf_format(mf, &sf->value, NULL, &ds);
 814         VLOG_WARN_RL(&rl, "Invalid value for set field %s: %s",
 815                      mf->name, ds_cstr(&ds));
 816         ds_destroy(&ds);
 817
 818         return OFPERR_OFPBAC_BAD_SET_ARGUMENT;
 819     }
 820     return 0;
 821 }
 822
 823 static void
 824 set_field_to_openflow12(const struct ofpact_set_field *sf,
 825                         struct ofpbuf *openflow,
 826                         enum ofp_version version)
 827 {
 828     uint16_t padded_value_len = ROUND_UP(sf->field->n_bytes, 8);
 829     struct ofp12_action_set_field *oasf;
 830     char *value;
 831
 832     oasf = ofputil_put_OFPAT12_SET_FIELD(openflow);
 833     oasf->dst = htonl(mf_oxm_header(sf->field->id, version));
 834     oasf->len = htons(sizeof *oasf + padded_value_len);
 835
 836     value = ofpbuf_put_zeros(openflow, padded_value_len);
 837     memcpy(value, &sf->value, sf->field->n_bytes);
 838 }
 839
 840 /* Convert 'sf' to one or two REG_LOADs. */
 841 static void
 842 set_field_to_nxast(const struct ofpact_set_field *sf, struct ofpbuf *openflow)
 843 {
 844     const struct mf_field *mf = sf->field;
 845     struct nx_action_reg_load *narl;
 846
 847     if (mf->n_bits > 64) {
 848         ovs_assert(mf->n_bytes == 16); /* IPv6 addr. */
 849         /* Split into 64bit chunks */
 850         /* Lower bits first. */
 851         narl = ofputil_put_NXAST_REG_LOAD(openflow);
 852         narl->ofs_nbits = nxm_encode_ofs_nbits(0, 64);
 853         narl->dst = htonl(mf->nxm_header);
 854         memcpy(&narl->value, &sf->value.ipv6.s6_addr[8], sizeof narl->value);
 855         /* Higher bits next. */
 856         narl = ofputil_put_NXAST_REG_LOAD(openflow);
 857         narl->ofs_nbits = nxm_encode_ofs_nbits(64, mf->n_bits - 64);
 858         narl->dst = htonl(mf->nxm_header);
 859         memcpy(&narl->value, &sf->value.ipv6.s6_addr[0], sizeof narl->value);
 860     } else {
 861         narl = ofputil_put_NXAST_REG_LOAD(openflow);
 862         narl->ofs_nbits = nxm_encode_ofs_nbits(0, mf->n_bits);
 863         narl->dst = htonl(mf->nxm_header);
 864         memset(&narl->value, 0, 8 - mf->n_bytes);
 865         memcpy((char*)&narl->value + (8 - mf->n_bytes),
 866                &sf->value, mf->n_bytes);
 867     }
 868 }
 869
 870 /* Convert 'sf' to standard OpenFlow 1.1 actions, if we can, falling back
 871  * to Nicira extensions if we must.
 872  *
 873  * We check only meta-flow types that can appear within set field actions and
 874  * that have a mapping to compatible action types.  These struct mf_field
 875  * definitions have a defined OXM or NXM header value and specify the field as
 876  * writable. */
 877 static void
 878 set_field_to_openflow11(const struct ofpact_set_field *sf,
 879                         struct ofpbuf *openflow)
 880 {
 881     switch ((int) sf->field->id) {
 882     case MFF_VLAN_TCI:
 883         /* NXM_OF_VLAN_TCI to OpenFlow 1.1 mapping:
 884          *
 885          * If CFI=1, Add or modify VLAN VID & PCP.
 886          *    OpenFlow 1.1 set actions only apply if the packet
 887          *    already has VLAN tags.  To be sure that is the case
 888          *    we have to push a VLAN header.  As we do not support
 889          *    multiple layers of VLANs, this is a no-op, if a VLAN
 890          *    header already exists.  This may backfire, however,
 891          *    when we start supporting multiple layers of VLANs.
 892          * If CFI=0, strip VLAN header, if any.
 893          */
 894         if (sf->value.be16 & htons(VLAN_CFI)) {
 895             /* Push a VLAN tag, if one was not seen at action validation
 896              * time. */
 897             if (!sf->flow_has_vlan) {
 898                 ofputil_put_OFPAT11_PUSH_VLAN(openflow)->ethertype
 899                     = htons(ETH_TYPE_VLAN_8021Q);
 900             }
 901             ofputil_put_OFPAT11_SET_VLAN_VID(openflow)->vlan_vid
 902                 = sf->value.be16 & htons(VLAN_VID_MASK);
 903             ofputil_put_OFPAT11_SET_VLAN_PCP(openflow)->vlan_pcp
 904                 = vlan_tci_to_pcp(sf->value.be16);
 905         } else {
 906             /* If the flow did not match on vlan, we have no way of
 907              * knowing if the vlan tag exists, so we must POP just to be
 908              * sure. */
 909             ofputil_put_OFPAT11_POP_VLAN(openflow);
 910         }
 911         break;
 912
 913     case MFF_VLAN_VID:
 914         /* OXM VLAN_PCP to OpenFlow 1.1.
 915          * Set field on OXM_OF_VLAN_VID onlyapplies to an existing vlan
 916          * tag.  Clear the OFPVID_PRESENT bit.
 917          */
 918         ofputil_put_OFPAT11_SET_VLAN_VID(openflow)->vlan_vid
 919             = sf->value.be16 & htons(VLAN_VID_MASK);
 920         break;
 921
 922     case MFF_VLAN_PCP:
 923         /* OXM VLAN_PCP to OpenFlow 1.1.
 924          * OXM_OF_VLAN_PCP only applies to existing vlan tag. */
 925         ofputil_put_OFPAT11_SET_VLAN_PCP(openflow)->vlan_pcp = sf->value.u8;
 926         break;
 927
 928     case MFF_ETH_SRC:
 929         memcpy(ofputil_put_OFPAT11_SET_DL_SRC(openflow)->dl_addr,
 930                sf->value.mac, ETH_ADDR_LEN);
 931         break;
 932
 933     case MFF_ETH_DST:
 934         memcpy(ofputil_put_OFPAT11_SET_DL_DST(openflow)->dl_addr,
 935                sf->value.mac, ETH_ADDR_LEN);
 936         break;
 937
 938     case MFF_MPLS_LABEL:
 939         ofputil_put_OFPAT11_SET_MPLS_LABEL(openflow)->mpls_label =
 940             sf->value.be32;
 941         break;
 942
 943     case MFF_MPLS_TC:
 944         ofputil_put_OFPAT11_SET_MPLS_TC(openflow)->mpls_tc = sf->value.u8;
 945         break;
 946
 947     case MFF_IPV4_SRC:
 948         ofputil_put_OFPAT11_SET_NW_SRC(openflow)->nw_addr = sf->value.be32;
 949         break;
 950
 951     case MFF_IPV4_DST:
 952         ofputil_put_OFPAT11_SET_NW_DST(openflow)->nw_addr = sf->value.be32;
 953         break;
 954
 955     case MFF_IP_DSCP:
 956         ofputil_put_OFPAT11_SET_NW_TOS(openflow)->nw_tos = sf->value.u8;
 957         break;
 958
 959     case MFF_IP_DSCP_SHIFTED:
 960         ofputil_put_OFPAT11_SET_NW_TOS(openflow)->nw_tos = sf->value.u8 << 2;
 961         break;
 962
 963     case MFF_IP_ECN:
 964         ofputil_put_OFPAT11_SET_NW_ECN(openflow)->nw_ecn = sf->value.u8;
 965         break;
 966
 967     case MFF_IP_TTL:
 968         ofputil_put_OFPAT11_SET_NW_TTL(openflow)->nw_ttl = sf->value.u8;
 969         break;
 970
 971     case MFF_TCP_SRC:
 972     case MFF_UDP_SRC:
 973     case MFF_SCTP_SRC:
 974         ofputil_put_OFPAT11_SET_TP_SRC(openflow)->tp_port = sf->value.be16;
 975         break;
 976
 977     case MFF_TCP_DST:
 978     case MFF_UDP_DST:
 979     case MFF_SCTP_DST:
 980         ofputil_put_OFPAT11_SET_TP_DST(openflow)->tp_port = sf->value.be16;
 981         break;
 982
 983     default:
 984         set_field_to_nxast(sf, openflow);
 985         break;
 986     }
 987 }
 988
 989 /* Convert 'sf' to standard OpenFlow 1.0 actions, if we can, falling back
 990  * to Nicira extensions if we must.
 991  *
 992  * We check only meta-flow types that can appear within set field actions and
 993  * that have a mapping to compatible action types.  These struct mf_field
 994  * definitions have a defined OXM or NXM header value and specify the field as
 995  * writable. */
 996 static void
 997 set_field_to_openflow10(const struct ofpact_set_field *sf,
 998                         struct ofpbuf *openflow)
 999 {
1000     switch ((int) sf->field->id) {
1001     case MFF_VLAN_TCI:
1002         /* NXM_OF_VLAN_TCI to OpenFlow 1.0 mapping:
1003          *
1004          * If CFI=1, Add or modify VLAN VID & PCP.
1005          * If CFI=0, strip VLAN header, if any.
1006          */
1007         if (sf->value.be16 & htons(VLAN_CFI)) {
1008             ofputil_put_OFPAT10_SET_VLAN_VID(openflow)->vlan_vid
1009                 = sf->value.be16 & htons(VLAN_VID_MASK);
1010             ofputil_put_OFPAT10_SET_VLAN_PCP(openflow)->vlan_pcp
1011                 = vlan_tci_to_pcp(sf->value.be16);
1012         } else {
1013             ofputil_put_OFPAT10_STRIP_VLAN(openflow);
1014         }
1015         break;
1016
1017     case MFF_VLAN_VID:
1018         /* OXM VLAN_VID to OpenFlow 1.0.
1019          * Set field on OXM_OF_VLAN_VID onlyapplies to an existing vlan
1020          * tag.  Clear the OFPVID_PRESENT bit.
1021          */
1022         ofputil_put_OFPAT10_SET_VLAN_VID(openflow)->vlan_vid
1023             = sf->value.be16 & htons(VLAN_VID_MASK);
1024         break;
1025
1026     case MFF_VLAN_PCP:
1027         /* OXM VLAN_PCP to OpenFlow 1.0.
1028          * OXM_OF_VLAN_PCP only applies to existing vlan tag. */
1029         ofputil_put_OFPAT10_SET_VLAN_PCP(openflow)->vlan_pcp = sf->value.u8;
1030         break;
1031
1032     case MFF_ETH_SRC:
1033         memcpy(ofputil_put_OFPAT10_SET_DL_SRC(openflow)->dl_addr,
1034                sf->value.mac, ETH_ADDR_LEN);
1035         break;
1036
1037     case MFF_ETH_DST:
1038         memcpy(ofputil_put_OFPAT10_SET_DL_DST(openflow)->dl_addr,
1039                sf->value.mac, ETH_ADDR_LEN);
1040         break;
1041
1042     case MFF_IPV4_SRC:
1043         ofputil_put_OFPAT10_SET_NW_SRC(openflow)->nw_addr = sf->value.be32;
1044         break;
1045
1046     case MFF_IPV4_DST:
1047         ofputil_put_OFPAT10_SET_NW_DST(openflow)->nw_addr = sf->value.be32;
1048         break;
1049
1050     case MFF_IP_DSCP:
1051         ofputil_put_OFPAT10_SET_NW_TOS(openflow)->nw_tos = sf->value.u8;
1052         break;
1053
1054     case MFF_IP_DSCP_SHIFTED:
1055         ofputil_put_OFPAT10_SET_NW_TOS(openflow)->nw_tos = sf->value.u8 << 2;
1056         break;
1057
1058     case MFF_TCP_SRC:
1059     case MFF_UDP_SRC:
1060         ofputil_put_OFPAT10_SET_TP_SRC(openflow)->tp_port = sf->value.be16;
1061         break;
1062
1063     case MFF_TCP_DST:
1064     case MFF_UDP_DST:
1065         ofputil_put_OFPAT10_SET_TP_DST(openflow)->tp_port = sf->value.be16;
1066         break;
1067
1068     default:
1069         set_field_to_nxast(sf, openflow);
1070         break;
1071     }
1072 }
1073
1074 static void
1075 set_field_to_openflow(const struct ofpact_set_field *sf,
1076                       struct ofpbuf *openflow)
1077 {
1078     struct ofp_header *oh = (struct ofp_header *)openflow->frame;
1079
1080     if (oh->version >= OFP12_VERSION) {
1081         set_field_to_openflow12(sf, openflow, oh->version);
1082     } else if (oh->version == OFP11_VERSION) {
1083         set_field_to_openflow11(sf, openflow);
1084     } else if (oh->version == OFP10_VERSION) {
1085         set_field_to_openflow10(sf, openflow);
1086     } else {
1087         OVS_NOT_REACHED();
1088     }
1089 }
1090
1091 static enum ofperr
1092 output_from_openflow11(const struct ofp11_action_output *oao,
1093                        struct ofpbuf *out)
1094 {
1095     struct ofpact_output *output;
1096     enum ofperr error;
1097
1098     output = ofpact_put_OUTPUT(out);
1099     output->max_len = ntohs(oao->max_len);
1100
1101     error = ofputil_port_from_ofp11(oao->port, &output->port);
1102     if (error) {
1103         return error;
1104     }
1105
1106     return ofpact_check_output_port(output->port, OFPP_MAX);
1107 }
1108
1109 static enum ofperr
1110 ofpact_from_openflow11(const union ofp_action *a, enum ofp_version version,
1111                        struct ofpbuf *out)
1112 {
1113     enum ofputil_action_code code;
1114     enum ofperr error;
1115     struct ofpact_vlan_vid *vlan_vid;
1116     struct ofpact_vlan_pcp *vlan_pcp;
1117
1118     error = decode_openflow11_action(a, &code);
1119     if (error) {
1120         return error;
1121     }
1122
1123     if (version >= OFP12_VERSION) {
1124         switch ((int)code) {
1125         case OFPUTIL_OFPAT11_SET_VLAN_VID:
1126         case OFPUTIL_OFPAT11_SET_VLAN_PCP:
1127         case OFPUTIL_OFPAT11_SET_DL_SRC:
1128         case OFPUTIL_OFPAT11_SET_DL_DST:
1129         case OFPUTIL_OFPAT11_SET_NW_SRC:
1130         case OFPUTIL_OFPAT11_SET_NW_DST:
1131         case OFPUTIL_OFPAT11_SET_NW_TOS:
1132         case OFPUTIL_OFPAT11_SET_NW_ECN:
1133         case OFPUTIL_OFPAT11_SET_TP_SRC:
1134         case OFPUTIL_OFPAT11_SET_TP_DST:
1135             VLOG_WARN_RL(&rl, "Deprecated action %s received over %s",
1136                          ofputil_action_name_from_code(code),
1137                          ofputil_version_to_string(version));
1138         }
1139     }
1140
1141     switch (code) {
1142     case OFPUTIL_ACTION_INVALID:
1143 #define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
1144 #define OFPAT13_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
1145 #include "ofp-util.def"
1146         OVS_NOT_REACHED();
1147
1148     case OFPUTIL_OFPAT11_OUTPUT:
1149         return output_from_openflow11(&a->ofp11_output, out);
1150
1151     case OFPUTIL_OFPAT11_SET_VLAN_VID:
1152         if (a->vlan_vid.vlan_vid & ~htons(0xfff)) {
1153             return OFPERR_OFPBAC_BAD_ARGUMENT;
1154         }
1155         vlan_vid = ofpact_put_SET_VLAN_VID(out);
1156         vlan_vid->vlan_vid = ntohs(a->vlan_vid.vlan_vid);
1157         vlan_vid->push_vlan_if_needed = false;
1158         vlan_vid->ofpact.compat = code;
1159         break;
1160
1161     case OFPUTIL_OFPAT11_SET_VLAN_PCP:
1162         if (a->vlan_pcp.vlan_pcp & ~7) {
1163             return OFPERR_OFPBAC_BAD_ARGUMENT;
1164         }
1165         vlan_pcp = ofpact_put_SET_VLAN_PCP(out);
1166         vlan_pcp->vlan_pcp = a->vlan_pcp.vlan_pcp;
1167         vlan_pcp->push_vlan_if_needed = false;
1168         vlan_pcp->ofpact.compat = code;
1169         break;
1170
1171     case OFPUTIL_OFPAT11_PUSH_VLAN:
1172         if (a->push.ethertype != htons(ETH_TYPE_VLAN_8021Q)) {
1173             /* XXX 802.1AD(QinQ) isn't supported at the moment */
1174             return OFPERR_OFPBAC_BAD_ARGUMENT;
1175         }
1176         ofpact_put_PUSH_VLAN(out);
1177         break;
1178
1179     case OFPUTIL_OFPAT11_POP_VLAN:
1180         ofpact_put_STRIP_VLAN(out)->ofpact.compat = code;
1181         break;
1182
1183     case OFPUTIL_OFPAT11_SET_QUEUE:
1184         ofpact_put_SET_QUEUE(out)->queue_id =
1185             ntohl(a->ofp11_set_queue.queue_id);
1186         break;
1187
1188     case OFPUTIL_OFPAT11_SET_DL_SRC:
1189         memcpy(ofpact_put_SET_ETH_SRC(out)->mac, a->dl_addr.dl_addr,
1190                ETH_ADDR_LEN);
1191         break;
1192
1193     case OFPUTIL_OFPAT11_SET_DL_DST:
1194         memcpy(ofpact_put_SET_ETH_DST(out)->mac, a->dl_addr.dl_addr,
1195                ETH_ADDR_LEN);
1196         break;
1197
1198     case OFPUTIL_OFPAT11_DEC_NW_TTL:
1199         dec_ttl_from_openflow(out, code);
1200         break;
1201
1202     case OFPUTIL_OFPAT11_SET_NW_SRC:
1203         ofpact_put_SET_IPV4_SRC(out)->ipv4 = a->nw_addr.nw_addr;
1204         break;
1205
1206     case OFPUTIL_OFPAT11_SET_NW_DST:
1207         ofpact_put_SET_IPV4_DST(out)->ipv4 = a->nw_addr.nw_addr;
1208         break;
1209
1210     case OFPUTIL_OFPAT11_SET_NW_TOS:
1211         if (a->nw_tos.nw_tos & ~IP_DSCP_MASK) {
1212             return OFPERR_OFPBAC_BAD_ARGUMENT;
1213         }
1214         ofpact_put_SET_IP_DSCP(out)->dscp = a->nw_tos.nw_tos;
1215         break;
1216
1217     case OFPUTIL_OFPAT11_SET_NW_ECN:
1218         if (a->nw_ecn.nw_ecn & ~IP_ECN_MASK) {
1219             return OFPERR_OFPBAC_BAD_ARGUMENT;
1220         }
1221         ofpact_put_SET_IP_ECN(out)->ecn = a->nw_ecn.nw_ecn;
1222         break;
1223
1224     case OFPUTIL_OFPAT11_SET_NW_TTL:
1225         ofpact_put_SET_IP_TTL(out)->ttl = a->nw_ttl.nw_ttl;
1226         break;
1227
1228     case OFPUTIL_OFPAT11_SET_TP_SRC:
1229         ofpact_put_SET_L4_SRC_PORT(out)->port = ntohs(a->tp_port.tp_port);
1230         break;
1231
1232     case OFPUTIL_OFPAT11_SET_TP_DST:
1233         ofpact_put_SET_L4_DST_PORT(out)->port = ntohs(a->tp_port.tp_port);
1234         break;
1235
1236     case OFPUTIL_OFPAT12_SET_FIELD:
1237         return set_field_from_openflow(&a->set_field, out);
1238
1239     case OFPUTIL_OFPAT11_SET_MPLS_LABEL:
1240         ofpact_put_SET_MPLS_LABEL(out)->label = a->ofp11_mpls_label.mpls_label;
1241         break;
1242
1243     case OFPUTIL_OFPAT11_SET_MPLS_TC:
1244         ofpact_put_SET_MPLS_TC(out)->tc = a->ofp11_mpls_tc.mpls_tc;
1245         break;
1246
1247     case OFPUTIL_OFPAT11_SET_MPLS_TTL:
1248         ofpact_put_SET_MPLS_TTL(out)->ttl = a->ofp11_mpls_ttl.mpls_ttl;
1249         break;
1250
1251     case OFPUTIL_OFPAT11_DEC_MPLS_TTL:
1252         ofpact_put_DEC_MPLS_TTL(out);
1253         break;
1254
1255     case OFPUTIL_OFPAT11_PUSH_MPLS:
1256         error = push_mpls_from_openflow(a->push.ethertype, out);
1257         break;
1258
1259     case OFPUTIL_OFPAT11_POP_MPLS:
1260         ofpact_put_POP_MPLS(out)->ethertype = a->ofp11_pop_mpls.ethertype;
1261         break;
1262
1263     case OFPUTIL_OFPAT11_GROUP:
1264         ofpact_put_GROUP(out)->group_id = ntohl(a->group.group_id);
1265         break;
1266
1267 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
1268 #include "ofp-util.def"
1269         return ofpact_from_nxast(a, code, out);
1270     }
1271
1272     return error;
1273 }
1274
1275 /* True if an action sets the value of a field
1276  * in a way that is compatibile with the action set.
1277  * False otherwise. */
1278 static bool
1279 ofpact_is_set_action(const struct ofpact *a)
1280 {
1281     switch (a->type) {
1282     case OFPACT_SET_FIELD:
1283     case OFPACT_REG_LOAD:
1284     case OFPACT_SET_ETH_DST:
1285     case OFPACT_SET_ETH_SRC:
1286     case OFPACT_SET_IP_DSCP:
1287     case OFPACT_SET_IP_ECN:
1288     case OFPACT_SET_IP_TTL:
1289     case OFPACT_SET_IPV4_DST:
1290     case OFPACT_SET_IPV4_SRC:
1291     case OFPACT_SET_L4_DST_PORT:
1292     case OFPACT_SET_L4_SRC_PORT:
1293     case OFPACT_SET_MPLS_LABEL:
1294     case OFPACT_SET_MPLS_TC:
1295     case OFPACT_SET_MPLS_TTL:
1296     case OFPACT_SET_QUEUE:
1297     case OFPACT_SET_TUNNEL:
1298     case OFPACT_SET_VLAN_PCP:
1299     case OFPACT_SET_VLAN_VID:
1300         return true;
1301     case OFPACT_BUNDLE:
1302     case OFPACT_CLEAR_ACTIONS:
1303     case OFPACT_CONTROLLER:
1304     case OFPACT_DEC_MPLS_TTL:
1305     case OFPACT_DEC_TTL:
1306     case OFPACT_ENQUEUE:
1307     case OFPACT_EXIT:
1308     case OFPACT_FIN_TIMEOUT:
1309     case OFPACT_GOTO_TABLE:
1310     case OFPACT_GROUP:
1311     case OFPACT_LEARN:
1312     case OFPACT_METER:
1313     case OFPACT_MULTIPATH:
1314     case OFPACT_NOTE:
1315     case OFPACT_OUTPUT:
1316     case OFPACT_OUTPUT_REG:
1317     case OFPACT_POP_MPLS:
1318     case OFPACT_POP_QUEUE:
1319     case OFPACT_PUSH_MPLS:
1320     case OFPACT_PUSH_VLAN:
1321     case OFPACT_REG_MOVE:
1322     case OFPACT_RESUBMIT:
1323     case OFPACT_SAMPLE:
1324     case OFPACT_STACK_POP:
1325     case OFPACT_STACK_PUSH:
1326     case OFPACT_STRIP_VLAN:
1327     case OFPACT_WRITE_ACTIONS:
1328     case OFPACT_WRITE_METADATA:
1329         return false;
1330     default:
1331         OVS_NOT_REACHED();
1332     }
1333 }
1334
1335 /* True if an action is allowed in the action set.
1336  * False otherwise. */
1337 static bool
1338 ofpact_is_allowed_in_actions_set(const struct ofpact *a)
1339 {
1340     switch (a->type) {
1341     case OFPACT_DEC_MPLS_TTL:
1342     case OFPACT_DEC_TTL:
1343     case OFPACT_GROUP:
1344     case OFPACT_OUTPUT:
1345     case OFPACT_POP_MPLS:
1346     case OFPACT_PUSH_MPLS:
1347     case OFPACT_PUSH_VLAN:
1348     case OFPACT_REG_LOAD:
1349     case OFPACT_SET_FIELD:
1350     case OFPACT_SET_ETH_DST:
1351     case OFPACT_SET_ETH_SRC:
1352     case OFPACT_SET_IP_DSCP:
1353     case OFPACT_SET_IP_ECN:
1354     case OFPACT_SET_IP_TTL:
1355     case OFPACT_SET_IPV4_DST:
1356     case OFPACT_SET_IPV4_SRC:
1357     case OFPACT_SET_L4_DST_PORT:
1358     case OFPACT_SET_L4_SRC_PORT:
1359     case OFPACT_SET_MPLS_LABEL:
1360     case OFPACT_SET_MPLS_TC:
1361     case OFPACT_SET_MPLS_TTL:
1362     case OFPACT_SET_QUEUE:
1363     case OFPACT_SET_TUNNEL:
1364     case OFPACT_SET_VLAN_PCP:
1365     case OFPACT_SET_VLAN_VID:
1366     case OFPACT_STRIP_VLAN:
1367         return true;
1368
1369     /* In general these actions are excluded because they are not part of
1370      * the OpenFlow specification nor map to actions that are defined in
1371      * the specification.  Thus the order in which they should be applied
1372      * in the action set is undefined. */
1373     case OFPACT_BUNDLE:
1374     case OFPACT_CONTROLLER:
1375     case OFPACT_ENQUEUE:
1376     case OFPACT_EXIT:
1377     case OFPACT_FIN_TIMEOUT:
1378     case OFPACT_LEARN:
1379     case OFPACT_MULTIPATH:
1380     case OFPACT_NOTE:
1381     case OFPACT_OUTPUT_REG:
1382     case OFPACT_POP_QUEUE:
1383     case OFPACT_REG_MOVE:
1384     case OFPACT_RESUBMIT:
1385     case OFPACT_SAMPLE:
1386     case OFPACT_STACK_POP:
1387     case OFPACT_STACK_PUSH:
1388
1389     /* The action set may only include actions and thus
1390      * may not include any instructions */
1391     case OFPACT_CLEAR_ACTIONS:
1392     case OFPACT_GOTO_TABLE:
1393     case OFPACT_METER:
1394     case OFPACT_WRITE_ACTIONS:
1395     case OFPACT_WRITE_METADATA:
1396         return false;
1397     default:
1398         OVS_NOT_REACHED();
1399     }
1400 }
1401
1402 /* Append ofpact 'a' onto the tail of 'out' */
1403 static void
1404 ofpact_copy(struct ofpbuf *out, const struct ofpact *a)
1405 {
1406     ofpbuf_put(out, a, OFPACT_ALIGN(a->len));
1407 }
1408
1409 /* Copies the last ofpact whose type is 'filter' from 'in' to 'out'. */
1410 static bool
1411 ofpacts_copy_last(struct ofpbuf *out, const struct ofpbuf *in,
1412                   enum ofpact_type filter)
1413 {
1414     const struct ofpact *target;
1415     const struct ofpact *a;
1416
1417     target = NULL;
1418     OFPACT_FOR_EACH (a, ofpbuf_data(in), ofpbuf_size(in)) {
1419         if (a->type == filter) {
1420             target = a;
1421         }
1422     }
1423     if (target) {
1424         ofpact_copy(out, target);
1425     }
1426     return target != NULL;
1427 }
1428
1429 /* Append all ofpacts, for which 'filter' returns true, from 'in' to 'out'.
1430  * The order of appended ofpacts is preserved between 'in' and 'out' */
1431 static void
1432 ofpacts_copy_all(struct ofpbuf *out, const struct ofpbuf *in,
1433                  bool (*filter)(const struct ofpact *))
1434 {
1435     const struct ofpact *a;
1436
1437     OFPACT_FOR_EACH (a, ofpbuf_data(in), ofpbuf_size(in)) {
1438         if (filter(a)) {
1439             ofpact_copy(out, a);
1440         }
1441     }
1442 }
1443
1444 /* Reads 'action_set', which contains ofpacts accumulated by
1445  * OFPACT_WRITE_ACTIONS instructions, and writes equivalent actions to be
1446  * executed directly into 'action_list'.  (These names correspond to the
1447  * "Action Set" and "Action List" terms used in OpenFlow 1.1+.)
1448  *
1449  * In general this involves appending the last instance of each action that is
1450  * adimissible in the action set in the order described in the OpenFlow
1451  * specification.
1452  *
1453  * Exceptions:
1454  * + output action is only appended if no group action was present in 'in'.
1455  * + As a simplification all set actions are copied in the order the are
1456  *   provided in 'in' as many set actions applied to a field has the same
1457  *   affect as only applying the last action that sets a field and
1458  *   duplicates are removed by do_xlate_actions().
1459  *   This has an unwanted side-effect of compsoting multiple
1460  *   LOAD_REG actions that touch different regions of the same field. */
1461 void
1462 ofpacts_execute_action_set(struct ofpbuf *action_list,
1463                            const struct ofpbuf *action_set)
1464 {
1465     /* The OpenFlow spec "Action Set" section specifies this order. */
1466     ofpacts_copy_last(action_list, action_set, OFPACT_STRIP_VLAN);
1467     ofpacts_copy_last(action_list, action_set, OFPACT_POP_MPLS);
1468     ofpacts_copy_last(action_list, action_set, OFPACT_PUSH_MPLS);
1469     ofpacts_copy_last(action_list, action_set, OFPACT_PUSH_VLAN);
1470     ofpacts_copy_last(action_list, action_set, OFPACT_DEC_TTL);
1471     ofpacts_copy_last(action_list, action_set, OFPACT_DEC_MPLS_TTL);
1472     ofpacts_copy_all(action_list, action_set, ofpact_is_set_action);
1473     ofpacts_copy_last(action_list, action_set, OFPACT_SET_QUEUE);
1474
1475     /* If both OFPACT_GROUP and OFPACT_OUTPUT are present, OpenFlow says that
1476      * we should execute only OFPACT_GROUP.
1477      *
1478      * If neither OFPACT_GROUP nor OFPACT_OUTPUT is present, then we can drop
1479      * all the actions because there's no point in modifying a packet that will
1480      * not be sent anywhere. */
1481     if (!ofpacts_copy_last(action_list, action_set, OFPACT_GROUP) &&
1482         !ofpacts_copy_last(action_list, action_set, OFPACT_OUTPUT)) {
1483         ofpbuf_clear(action_list);
1484     }
1485 }
1486
1487
1488 static enum ofperr
1489 ofpacts_from_openflow11_for_action_set(const union ofp_action *in,
1490                                        size_t n_in, enum ofp_version version,
1491                                        struct ofpbuf *out)
1492 {
1493     enum ofperr error;
1494     struct ofpact *a;
1495     size_t start = ofpbuf_size(out);
1496
1497     error = ofpacts_from_openflow(in, n_in, version, out);
1498
1499     if (error) {
1500         return error;
1501     }
1502
1503     OFPACT_FOR_EACH (a, ofpact_end(ofpbuf_data(out), start), ofpbuf_size(out) - start) {
1504         if (!ofpact_is_allowed_in_actions_set(a)) {
1505             VLOG_WARN_RL(&rl, "disallowed action in action set");
1506             return OFPERR_OFPBAC_BAD_TYPE;
1507         }
1508     }
1509
1510     return 0;
1511 }
1512
1513 \f
1514 /* OpenFlow 1.1 instructions. */
1515
1516 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME)             \
1517     static inline const struct STRUCT * OVS_UNUSED              \
1518     instruction_get_##ENUM(const struct ofp11_instruction *inst)\
1519     {                                                           \
1520         ovs_assert(inst->type == htons(ENUM));                  \
1521         return ALIGNED_CAST(struct STRUCT *, inst);             \
1522     }                                                           \
1523                                                                 \
1524     static inline void OVS_UNUSED                               \
1525     instruction_init_##ENUM(struct STRUCT *s)                   \
1526     {                                                           \
1527         memset(s, 0, sizeof *s);                                \
1528         s->type = htons(ENUM);                                  \
1529         s->len = htons(sizeof *s);                              \
1530     }                                                           \
1531                                                                 \
1532     static inline struct STRUCT * OVS_UNUSED                    \
1533     instruction_put_##ENUM(struct ofpbuf *buf)                  \
1534     {                                                           \
1535         struct STRUCT *s = ofpbuf_put_uninit(buf, sizeof *s);   \
1536         instruction_init_##ENUM(s);                             \
1537         return s;                                               \
1538     }
1539 OVS_INSTRUCTIONS
1540 #undef DEFINE_INST
1541
1542 struct instruction_type_info {
1543     enum ovs_instruction_type type;
1544     const char *name;
1545 };
1546
1547 static const struct instruction_type_info inst_info[] = {
1548 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME)    {OVSINST_##ENUM, NAME},
1549 OVS_INSTRUCTIONS
1550 #undef DEFINE_INST
1551 };
1552
1553 const char *
1554 ovs_instruction_name_from_type(enum ovs_instruction_type type)
1555 {
1556     return inst_info[type].name;
1557 }
1558
1559 int
1560 ovs_instruction_type_from_name(const char *name)
1561 {
1562     const struct instruction_type_info *p;
1563     for (p = inst_info; p < &inst_info[ARRAY_SIZE(inst_info)]; p++) {
1564         if (!strcasecmp(name, p->name)) {
1565             return p->type;
1566         }
1567     }
1568     return -1;
1569 }
1570
1571 enum ovs_instruction_type
1572 ovs_instruction_type_from_ofpact_type(enum ofpact_type type)
1573 {
1574     switch (type) {
1575     case OFPACT_METER:
1576         return OVSINST_OFPIT13_METER;
1577     case OFPACT_CLEAR_ACTIONS:
1578         return OVSINST_OFPIT11_CLEAR_ACTIONS;
1579     case OFPACT_WRITE_ACTIONS:
1580         return OVSINST_OFPIT11_WRITE_ACTIONS;
1581     case OFPACT_WRITE_METADATA:
1582         return OVSINST_OFPIT11_WRITE_METADATA;
1583     case OFPACT_GOTO_TABLE:
1584         return OVSINST_OFPIT11_GOTO_TABLE;
1585     case OFPACT_OUTPUT:
1586     case OFPACT_GROUP:
1587     case OFPACT_CONTROLLER:
1588     case OFPACT_ENQUEUE:
1589     case OFPACT_OUTPUT_REG:
1590     case OFPACT_BUNDLE:
1591     case OFPACT_SET_VLAN_VID:
1592     case OFPACT_SET_VLAN_PCP:
1593     case OFPACT_STRIP_VLAN:
1594     case OFPACT_PUSH_VLAN:
1595     case OFPACT_SET_ETH_SRC:
1596     case OFPACT_SET_ETH_DST:
1597     case OFPACT_SET_IPV4_SRC:
1598     case OFPACT_SET_IPV4_DST:
1599     case OFPACT_SET_IP_DSCP:
1600     case OFPACT_SET_IP_ECN:
1601     case OFPACT_SET_IP_TTL:
1602     case OFPACT_SET_L4_SRC_PORT:
1603     case OFPACT_SET_L4_DST_PORT:
1604     case OFPACT_REG_MOVE:
1605     case OFPACT_REG_LOAD:
1606     case OFPACT_SET_FIELD:
1607     case OFPACT_STACK_PUSH:
1608     case OFPACT_STACK_POP:
1609     case OFPACT_DEC_TTL:
1610     case OFPACT_SET_MPLS_LABEL:
1611     case OFPACT_SET_MPLS_TC:
1612     case OFPACT_SET_MPLS_TTL:
1613     case OFPACT_DEC_MPLS_TTL:
1614     case OFPACT_PUSH_MPLS:
1615     case OFPACT_POP_MPLS:
1616     case OFPACT_SET_TUNNEL:
1617     case OFPACT_SET_QUEUE:
1618     case OFPACT_POP_QUEUE:
1619     case OFPACT_FIN_TIMEOUT:
1620     case OFPACT_RESUBMIT:
1621     case OFPACT_LEARN:
1622     case OFPACT_MULTIPATH:
1623     case OFPACT_NOTE:
1624     case OFPACT_EXIT:
1625     case OFPACT_SAMPLE:
1626     default:
1627         return OVSINST_OFPIT11_APPLY_ACTIONS;
1628     }
1629 }
1630
1631 enum ofperr
1632 ovs_instruction_type_from_inst_type(enum ovs_instruction_type *instruction_type,
1633                                     const uint16_t inst_type)
1634 {
1635     switch (inst_type) {
1636
1637 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME) \
1638     case ENUM:                                      \
1639         *instruction_type = OVSINST_##ENUM;         \
1640         return 0;
1641 OVS_INSTRUCTIONS
1642 #undef DEFINE_INST
1643
1644     default:
1645         return OFPERR_OFPBIC_UNKNOWN_INST;
1646     }
1647 }
1648
1649 static inline struct ofp11_instruction *
1650 instruction_next(const struct ofp11_instruction *inst)
1651 {
1652     return ((struct ofp11_instruction *) (void *)
1653             ((uint8_t *) inst + ntohs(inst->len)));
1654 }
1655
1656 static inline bool
1657 instruction_is_valid(const struct ofp11_instruction *inst,
1658                      size_t n_instructions)
1659 {
1660     uint16_t len = ntohs(inst->len);
1661     return (!(len % OFP11_INSTRUCTION_ALIGN)
1662             && len >= sizeof *inst
1663             && len / sizeof *inst <= n_instructions);
1664 }
1665
1666 /* This macro is careful to check for instructions with bad lengths. */
1667 #define INSTRUCTION_FOR_EACH(ITER, LEFT, INSTRUCTIONS, N_INSTRUCTIONS)  \
1668     for ((ITER) = (INSTRUCTIONS), (LEFT) = (N_INSTRUCTIONS);            \
1669          (LEFT) > 0 && instruction_is_valid(ITER, LEFT);                \
1670          ((LEFT) -= (ntohs((ITER)->len)                                 \
1671                      / sizeof(struct ofp11_instruction)),               \
1672           (ITER) = instruction_next(ITER)))
1673
1674 static enum ofperr
1675 decode_openflow11_instruction(const struct ofp11_instruction *inst,
1676                               enum ovs_instruction_type *type)
1677 {
1678     uint16_t len = ntohs(inst->len);
1679
1680     switch (inst->type) {
1681     case CONSTANT_HTONS(OFPIT11_EXPERIMENTER):
1682         return OFPERR_OFPBIC_BAD_EXPERIMENTER;
1683
1684 #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME)     \
1685         case CONSTANT_HTONS(ENUM):                      \
1686             if (EXTENSIBLE                              \
1687                 ? len >= sizeof(struct STRUCT)          \
1688                 : len == sizeof(struct STRUCT)) {       \
1689                 *type = OVSINST_##ENUM;                 \
1690                 return 0;                               \
1691             } else {                                    \
1692                 return OFPERR_OFPBIC_BAD_LEN;           \
1693             }
1694 OVS_INSTRUCTIONS
1695 #undef DEFINE_INST
1696
1697     default:
1698         return OFPERR_OFPBIC_UNKNOWN_INST;
1699     }
1700 }
1701
1702 static enum ofperr
1703 decode_openflow11_instructions(const struct ofp11_instruction insts[],
1704                                size_t n_insts,
1705                                const struct ofp11_instruction *out[])
1706 {
1707     const struct ofp11_instruction *inst;
1708     size_t left;
1709
1710     memset(out, 0, N_OVS_INSTRUCTIONS * sizeof *out);
1711     INSTRUCTION_FOR_EACH (inst, left, insts, n_insts) {
1712         enum ovs_instruction_type type;
1713         enum ofperr error;
1714
1715         error = decode_openflow11_instruction(inst, &type);
1716         if (error) {
1717             return error;
1718         }
1719
1720         if (out[type]) {
1721             return OFPERR_OFPBIC_DUP_INST;
1722         }
1723         out[type] = inst;
1724     }
1725
1726     if (left) {
1727         VLOG_WARN_RL(&rl, "bad instruction format at offset %"PRIuSIZE,
1728                      (n_insts - left) * sizeof *inst);
1729         return OFPERR_OFPBIC_BAD_LEN;
1730     }
1731     return 0;
1732 }
1733
1734 static void
1735 get_actions_from_instruction(const struct ofp11_instruction *inst,
1736                              const union ofp_action **actions,
1737                              size_t *max_actions)
1738 {
1739     *actions = ALIGNED_CAST(const union ofp_action *, inst + 1);
1740     *max_actions = (ntohs(inst->len) - sizeof *inst) / OFP11_INSTRUCTION_ALIGN;
1741 }
1742
1743 enum ofperr
1744 ofpacts_pull_openflow_instructions(struct ofpbuf *openflow,
1745                                    unsigned int instructions_len,
1746                                    enum ofp_version version,
1747                                    struct ofpbuf *ofpacts)
1748 {
1749     const struct ofp11_instruction *instructions;
1750     const struct ofp11_instruction *insts[N_OVS_INSTRUCTIONS];
1751     enum ofperr error;
1752
1753     ofpbuf_clear(ofpacts);
1754
1755     if (instructions_len % OFP11_INSTRUCTION_ALIGN != 0) {
1756         VLOG_WARN_RL(&rl, "OpenFlow message instructions length %u is not a "
1757                      "multiple of %d",
1758                      instructions_len, OFP11_INSTRUCTION_ALIGN);
1759         error = OFPERR_OFPBIC_BAD_LEN;
1760         goto exit;
1761     }
1762
1763     instructions = ofpbuf_try_pull(openflow, instructions_len);
1764     if (instructions == NULL) {
1765         VLOG_WARN_RL(&rl, "OpenFlow message instructions length %u exceeds "
1766                      "remaining message length (%"PRIu32")",
1767                      instructions_len, ofpbuf_size(openflow));
1768         error = OFPERR_OFPBIC_BAD_LEN;
1769         goto exit;
1770     }
1771
1772     error = decode_openflow11_instructions(
1773         instructions, instructions_len / OFP11_INSTRUCTION_ALIGN,
1774         insts);
1775     if (error) {
1776         goto exit;
1777     }
1778
1779     if (insts[OVSINST_OFPIT13_METER]) {
1780         const struct ofp13_instruction_meter *oim;
1781         struct ofpact_meter *om;
1782
1783         oim = ALIGNED_CAST(const struct ofp13_instruction_meter *,
1784                            insts[OVSINST_OFPIT13_METER]);
1785
1786         om = ofpact_put_METER(ofpacts);
1787         om->meter_id = ntohl(oim->meter_id);
1788     }
1789     if (insts[OVSINST_OFPIT11_APPLY_ACTIONS]) {
1790         const union ofp_action *actions;
1791         size_t max_actions;
1792
1793         get_actions_from_instruction(insts[OVSINST_OFPIT11_APPLY_ACTIONS],
1794                                      &actions, &max_actions);
1795         error = ofpacts_from_openflow(actions, max_actions, version, ofpacts);
1796         if (error) {
1797             goto exit;
1798         }
1799     }
1800     if (insts[OVSINST_OFPIT11_CLEAR_ACTIONS]) {
1801         instruction_get_OFPIT11_CLEAR_ACTIONS(
1802             insts[OVSINST_OFPIT11_CLEAR_ACTIONS]);
1803         ofpact_put_CLEAR_ACTIONS(ofpacts);
1804     }
1805     if (insts[OVSINST_OFPIT11_WRITE_ACTIONS]) {
1806         struct ofpact_nest *on;
1807         const union ofp_action *actions;
1808         size_t max_actions;
1809         size_t start;
1810
1811         ofpact_pad(ofpacts);
1812         start = ofpbuf_size(ofpacts);
1813         ofpact_put(ofpacts, OFPACT_WRITE_ACTIONS,
1814                    offsetof(struct ofpact_nest, actions));
1815         get_actions_from_instruction(insts[OVSINST_OFPIT11_WRITE_ACTIONS],
1816                                      &actions, &max_actions);
1817         error = ofpacts_from_openflow11_for_action_set(actions, max_actions,
1818                                                        version, ofpacts);
1819         if (error) {
1820             goto exit;
1821         }
1822         on = ofpbuf_at_assert(ofpacts, start, sizeof *on);
1823         on->ofpact.len = ofpbuf_size(ofpacts) - start;
1824     }
1825     if (insts[OVSINST_OFPIT11_WRITE_METADATA]) {
1826         const struct ofp11_instruction_write_metadata *oiwm;
1827         struct ofpact_metadata *om;
1828
1829         oiwm = ALIGNED_CAST(const struct ofp11_instruction_write_metadata *,
1830                             insts[OVSINST_OFPIT11_WRITE_METADATA]);
1831
1832         om = ofpact_put_WRITE_METADATA(ofpacts);
1833         om->metadata = oiwm->metadata;
1834         om->mask = oiwm->metadata_mask;
1835     }
1836     if (insts[OVSINST_OFPIT11_GOTO_TABLE]) {
1837         const struct ofp11_instruction_goto_table *oigt;
1838         struct ofpact_goto_table *ogt;
1839
1840         oigt = instruction_get_OFPIT11_GOTO_TABLE(
1841             insts[OVSINST_OFPIT11_GOTO_TABLE]);
1842         ogt = ofpact_put_GOTO_TABLE(ofpacts);
1843         ogt->table_id = oigt->table_id;
1844     }
1845
1846     error = ofpacts_verify(ofpbuf_data(ofpacts), ofpbuf_size(ofpacts));
1847 exit:
1848     if (error) {
1849         ofpbuf_clear(ofpacts);
1850     }
1851     return error;
1852 }
1853 \f
1854 /* Checks that 'port' is a valid output port for OFPACT_OUTPUT, given that the
1855  * switch will never have more than 'max_ports' ports.  Returns 0 if 'port' is
1856  * valid, otherwise an OpenFlow error code. */
1857 enum ofperr
1858 ofpact_check_output_port(ofp_port_t port, ofp_port_t max_ports)
1859 {
1860     switch (port) {
1861     case OFPP_IN_PORT:
1862     case OFPP_TABLE:
1863     case OFPP_NORMAL:
1864     case OFPP_FLOOD:
1865     case OFPP_ALL:
1866     case OFPP_CONTROLLER:
1867     case OFPP_NONE:
1868     case OFPP_LOCAL:
1869         return 0;
1870
1871     default:
1872         if (ofp_to_u16(port) < ofp_to_u16(max_ports)) {
1873             return 0;
1874         }
1875         return OFPERR_OFPBAC_BAD_OUT_PORT;
1876     }
1877 }
1878
1879 /* Removes the protocols that require consistency between match and actions
1880  * (that's everything but OpenFlow 1.0) from '*usable_protocols'.
1881  *
1882  * (An example of an inconsistency between match and actions is a flow that
1883  * does not match on an MPLS Ethertype but has an action that pops an MPLS
1884  * label.) */
1885 static void
1886 inconsistent_match(enum ofputil_protocol *usable_protocols)
1887 {
1888     *usable_protocols &= OFPUTIL_P_OF10_ANY;
1889 }
1890
1891 /* May modify flow->dl_type, flow->nw_proto and flow->vlan_tci,
1892  * caller must restore them.
1893  *
1894  * Modifies some actions, filling in fields that could not be properly set
1895  * without context. */
1896 static enum ofperr
1897 ofpact_check__(enum ofputil_protocol *usable_protocols, struct ofpact *a,
1898                struct flow *flow, ofp_port_t max_ports,
1899                uint8_t table_id, uint8_t n_tables)
1900 {
1901     const struct ofpact_enqueue *enqueue;
1902     const struct mf_field *mf;
1903
1904     switch (a->type) {
1905     case OFPACT_OUTPUT:
1906         return ofpact_check_output_port(ofpact_get_OUTPUT(a)->port,
1907                                         max_ports);
1908
1909     case OFPACT_CONTROLLER:
1910         return 0;
1911
1912     case OFPACT_ENQUEUE:
1913         enqueue = ofpact_get_ENQUEUE(a);
1914         if (ofp_to_u16(enqueue->port) >= ofp_to_u16(max_ports)
1915             && enqueue->port != OFPP_IN_PORT
1916             && enqueue->port != OFPP_LOCAL) {
1917             return OFPERR_OFPBAC_BAD_OUT_PORT;
1918         }
1919         return 0;
1920
1921     case OFPACT_OUTPUT_REG:
1922         return mf_check_src(&ofpact_get_OUTPUT_REG(a)->src, flow);
1923
1924     case OFPACT_BUNDLE:
1925         return bundle_check(ofpact_get_BUNDLE(a), max_ports, flow);
1926
1927     case OFPACT_SET_VLAN_VID:
1928         /* Remember if we saw a vlan tag in the flow to aid translating to
1929          * OpenFlow 1.1+ if need be. */
1930         ofpact_get_SET_VLAN_VID(a)->flow_has_vlan =
1931             (flow->vlan_tci & htons(VLAN_CFI)) == htons(VLAN_CFI);
1932         if (!(flow->vlan_tci & htons(VLAN_CFI)) &&
1933             !ofpact_get_SET_VLAN_VID(a)->push_vlan_if_needed) {
1934             inconsistent_match(usable_protocols);
1935         }
1936         /* Temporary mark that we have a vlan tag. */
1937         flow->vlan_tci |= htons(VLAN_CFI);
1938         return 0;
1939
1940     case OFPACT_SET_VLAN_PCP:
1941         /* Remember if we saw a vlan tag in the flow to aid translating to
1942          * OpenFlow 1.1+ if need be. */
1943         ofpact_get_SET_VLAN_PCP(a)->flow_has_vlan =
1944             (flow->vlan_tci & htons(VLAN_CFI)) == htons(VLAN_CFI);
1945         if (!(flow->vlan_tci & htons(VLAN_CFI)) &&
1946             !ofpact_get_SET_VLAN_PCP(a)->push_vlan_if_needed) {
1947             inconsistent_match(usable_protocols);
1948         }
1949         /* Temporary mark that we have a vlan tag. */
1950         flow->vlan_tci |= htons(VLAN_CFI);
1951         return 0;
1952
1953     case OFPACT_STRIP_VLAN:
1954         if (!(flow->vlan_tci & htons(VLAN_CFI))) {
1955             inconsistent_match(usable_protocols);
1956         }
1957         /* Temporary mark that we have no vlan tag. */
1958         flow->vlan_tci = htons(0);
1959         return 0;
1960
1961     case OFPACT_PUSH_VLAN:
1962         if (flow->vlan_tci & htons(VLAN_CFI)) {
1963             /* Multiple VLAN headers not supported. */
1964             return OFPERR_OFPBAC_BAD_TAG;
1965         }
1966         /* Temporary mark that we have a vlan tag. */
1967         flow->vlan_tci |= htons(VLAN_CFI);
1968         return 0;
1969
1970     case OFPACT_SET_ETH_SRC:
1971     case OFPACT_SET_ETH_DST:
1972         return 0;
1973
1974     case OFPACT_SET_IPV4_SRC:
1975     case OFPACT_SET_IPV4_DST:
1976         if (flow->dl_type != htons(ETH_TYPE_IP)) {
1977             inconsistent_match(usable_protocols);
1978         }
1979         return 0;
1980
1981     case OFPACT_SET_IP_DSCP:
1982     case OFPACT_SET_IP_ECN:
1983     case OFPACT_SET_IP_TTL:
1984     case OFPACT_DEC_TTL:
1985         if (!is_ip_any(flow)) {
1986             inconsistent_match(usable_protocols);
1987         }
1988         return 0;
1989
1990     case OFPACT_SET_L4_SRC_PORT:
1991         if (!is_ip_any(flow) ||
1992             (flow->nw_proto != IPPROTO_TCP && flow->nw_proto != IPPROTO_UDP
1993              && flow->nw_proto != IPPROTO_SCTP)) {
1994             inconsistent_match(usable_protocols);
1995         }
1996         /* Note on which transport protocol the port numbers are set.
1997          * This allows this set action to be converted to an OF1.2 set field
1998          * action. */
1999         ofpact_get_SET_L4_SRC_PORT(a)->flow_ip_proto = flow->nw_proto;
2000         return 0;
2001
2002     case OFPACT_SET_L4_DST_PORT:
2003         if (!is_ip_any(flow) ||
2004             (flow->nw_proto != IPPROTO_TCP && flow->nw_proto != IPPROTO_UDP
2005              && flow->nw_proto != IPPROTO_SCTP)) {
2006             inconsistent_match(usable_protocols);
2007         }
2008         /* Note on which transport protocol the port numbers are set.
2009          * This allows this set action to be converted to an OF1.2 set field
2010          * action. */
2011         ofpact_get_SET_L4_DST_PORT(a)->flow_ip_proto = flow->nw_proto;
2012         return 0;
2013
2014     case OFPACT_REG_MOVE:
2015         return nxm_reg_move_check(ofpact_get_REG_MOVE(a), flow);
2016
2017     case OFPACT_REG_LOAD:
2018         return nxm_reg_load_check(ofpact_get_REG_LOAD(a), flow);
2019
2020     case OFPACT_SET_FIELD:
2021         mf = ofpact_get_SET_FIELD(a)->field;
2022         /* Require OXM_OF_VLAN_VID to have an existing VLAN header. */
2023         if (!mf_are_prereqs_ok(mf, flow) ||
2024             (mf->id == MFF_VLAN_VID && !(flow->vlan_tci & htons(VLAN_CFI)))) {
2025             VLOG_WARN_RL(&rl, "set_field %s lacks correct prerequisities",
2026                          mf->name);
2027             return OFPERR_OFPBAC_MATCH_INCONSISTENT;
2028         }
2029         /* Remember if we saw a vlan tag in the flow to aid translating to
2030          * OpenFlow 1.1 if need be. */
2031         ofpact_get_SET_FIELD(a)->flow_has_vlan =
2032             (flow->vlan_tci & htons(VLAN_CFI)) == htons(VLAN_CFI);
2033         if (mf->id == MFF_VLAN_TCI) {
2034             /* The set field may add or remove the vlan tag,
2035              * Mark the status temporarily. */
2036             flow->vlan_tci = ofpact_get_SET_FIELD(a)->value.be16;
2037         }
2038         return 0;
2039
2040     case OFPACT_STACK_PUSH:
2041         return nxm_stack_push_check(ofpact_get_STACK_PUSH(a), flow);
2042
2043     case OFPACT_STACK_POP:
2044         return nxm_stack_pop_check(ofpact_get_STACK_POP(a), flow);
2045
2046     case OFPACT_SET_MPLS_LABEL:
2047     case OFPACT_SET_MPLS_TC:
2048     case OFPACT_SET_MPLS_TTL:
2049     case OFPACT_DEC_MPLS_TTL:
2050         if (!eth_type_mpls(flow->dl_type)) {
2051             inconsistent_match(usable_protocols);
2052         }
2053         return 0;
2054
2055     case OFPACT_SET_TUNNEL:
2056     case OFPACT_SET_QUEUE:
2057     case OFPACT_POP_QUEUE:
2058     case OFPACT_RESUBMIT:
2059         return 0;
2060
2061     case OFPACT_FIN_TIMEOUT:
2062         if (flow->nw_proto != IPPROTO_TCP) {
2063             inconsistent_match(usable_protocols);
2064         }
2065         return 0;
2066
2067     case OFPACT_LEARN:
2068         return learn_check(ofpact_get_LEARN(a), flow);
2069
2070     case OFPACT_MULTIPATH:
2071         return multipath_check(ofpact_get_MULTIPATH(a), flow);
2072
2073     case OFPACT_NOTE:
2074     case OFPACT_EXIT:
2075         return 0;
2076
2077     case OFPACT_PUSH_MPLS:
2078         flow->dl_type = ofpact_get_PUSH_MPLS(a)->ethertype;
2079         /* The packet is now MPLS and the MPLS payload is opaque.
2080          * Thus nothing can be assumed about the network protocol.
2081          * Temporarily mark that we have no nw_proto. */
2082         flow->nw_proto = 0;
2083         return 0;
2084
2085     case OFPACT_POP_MPLS:
2086         if (!eth_type_mpls(flow->dl_type)) {
2087             inconsistent_match(usable_protocols);
2088         }
2089         flow->dl_type = ofpact_get_POP_MPLS(a)->ethertype;
2090         return 0;
2091
2092     case OFPACT_SAMPLE:
2093         return 0;
2094
2095     case OFPACT_CLEAR_ACTIONS:
2096         return 0;
2097
2098     case OFPACT_WRITE_ACTIONS: {
2099         /* Use a temporary copy of 'usable_protocols' because we can't check
2100          * consistency of an action set. */
2101         struct ofpact_nest *on = ofpact_get_WRITE_ACTIONS(a);
2102         enum ofputil_protocol p = *usable_protocols;
2103         return ofpacts_check(on->actions, ofpact_nest_get_action_len(on),
2104                              flow, max_ports, table_id, n_tables, &p);
2105     }
2106
2107     case OFPACT_WRITE_METADATA:
2108         return 0;
2109
2110     case OFPACT_METER: {
2111         uint32_t mid = ofpact_get_METER(a)->meter_id;
2112         if (mid == 0 || mid > OFPM13_MAX) {
2113             return OFPERR_OFPMMFC_INVALID_METER;
2114         }
2115         return 0;
2116     }
2117
2118     case OFPACT_GOTO_TABLE: {
2119         uint8_t goto_table = ofpact_get_GOTO_TABLE(a)->table_id;
2120         if ((table_id != 255 && goto_table <= table_id)
2121             || (n_tables != 255 && goto_table >= n_tables)) {
2122             return OFPERR_OFPBRC_BAD_TABLE_ID;
2123         }
2124         return 0;
2125     }
2126
2127     case OFPACT_GROUP:
2128         return 0;
2129
2130     default:
2131         OVS_NOT_REACHED();
2132     }
2133 }
2134
2135 /* Checks that the 'ofpacts_len' bytes of actions in 'ofpacts' are
2136  * appropriate for a packet with the prerequisites satisfied by 'flow' in a
2137  * switch with no more than 'max_ports' ports.
2138  *
2139  * If 'ofpacts' and 'flow' are inconsistent with one another, un-sets in
2140  * '*usable_protocols' the protocols that forbid the inconsistency.  (An
2141  * example of an inconsistency between match and actions is a flow that does
2142  * not match on an MPLS Ethertype but has an action that pops an MPLS label.)
2143  *
2144  * May annotate ofpacts with information gathered from the 'flow'.
2145  *
2146  * May temporarily modify 'flow', but restores the changes before returning. */
2147 enum ofperr
2148 ofpacts_check(struct ofpact ofpacts[], size_t ofpacts_len,
2149               struct flow *flow, ofp_port_t max_ports,
2150               uint8_t table_id, uint8_t n_tables,
2151               enum ofputil_protocol *usable_protocols)
2152 {
2153     struct ofpact *a;
2154     ovs_be16 dl_type = flow->dl_type;
2155     ovs_be16 vlan_tci = flow->vlan_tci;
2156     uint8_t nw_proto = flow->nw_proto;
2157     enum ofperr error = 0;
2158
2159     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
2160         error = ofpact_check__(usable_protocols, a, flow,
2161                                max_ports, table_id, n_tables);
2162         if (error) {
2163             break;
2164         }
2165     }
2166     /* Restore fields that may have been modified. */
2167     flow->dl_type = dl_type;
2168     flow->vlan_tci = vlan_tci;
2169     flow->nw_proto = nw_proto;
2170     return error;
2171 }
2172
2173 /* Like ofpacts_check(), but reports inconsistencies as
2174  * OFPERR_OFPBAC_MATCH_INCONSISTENT rather than clearing bits. */
2175 enum ofperr
2176 ofpacts_check_consistency(struct ofpact ofpacts[], size_t ofpacts_len,
2177                           struct flow *flow, ofp_port_t max_ports,
2178                           uint8_t table_id, uint8_t n_tables,
2179                           enum ofputil_protocol usable_protocols)
2180 {
2181     enum ofputil_protocol p = usable_protocols;
2182     enum ofperr error;
2183
2184     error = ofpacts_check(ofpacts, ofpacts_len, flow, max_ports,
2185                           table_id, n_tables, &p);
2186     return (error ? error
2187             : p != usable_protocols ? OFPERR_OFPBAC_MATCH_INCONSISTENT
2188             : 0);
2189 }
2190
2191 /* Verifies that the 'ofpacts_len' bytes of actions in 'ofpacts' are
2192  * in the appropriate order as defined by the OpenFlow spec. */
2193 enum ofperr
2194 ofpacts_verify(const struct ofpact ofpacts[], size_t ofpacts_len)
2195 {
2196     const struct ofpact *a;
2197     enum ovs_instruction_type inst;
2198
2199     inst = OVSINST_OFPIT13_METER;
2200     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
2201         enum ovs_instruction_type next;
2202
2203         next = ovs_instruction_type_from_ofpact_type(a->type);
2204         if (a > ofpacts
2205             && (inst == OVSINST_OFPIT11_APPLY_ACTIONS
2206                 ? next < inst
2207                 : next <= inst)) {
2208             const char *name = ovs_instruction_name_from_type(inst);
2209             const char *next_name = ovs_instruction_name_from_type(next);
2210
2211             if (next == inst) {
2212                 VLOG_WARN("duplicate %s instruction not allowed, for OpenFlow "
2213                           "1.1+ compatibility", name);
2214             } else {
2215                 VLOG_WARN("invalid instruction ordering: %s must appear "
2216                           "before %s, for OpenFlow 1.1+ compatibility",
2217                           next_name, name);
2218             }
2219             return OFPERR_OFPBAC_UNSUPPORTED_ORDER;
2220         }
2221
2222         inst = next;
2223     }
2224
2225     return 0;
2226 }
2227 \f
2228 /* Converting ofpacts to Nicira OpenFlow extensions. */
2229
2230 static void
2231 ofpact_output_reg_to_nxast(const struct ofpact_output_reg *output_reg,
2232                                 struct ofpbuf *out)
2233 {
2234     struct nx_action_output_reg *naor = ofputil_put_NXAST_OUTPUT_REG(out);
2235
2236     naor->ofs_nbits = nxm_encode_ofs_nbits(output_reg->src.ofs,
2237                                            output_reg->src.n_bits);
2238     naor->src = htonl(output_reg->src.field->nxm_header);
2239     naor->max_len = htons(output_reg->max_len);
2240 }
2241
2242 static void
2243 ofpact_resubmit_to_nxast(const struct ofpact_resubmit *resubmit,
2244                          struct ofpbuf *out)
2245 {
2246     struct nx_action_resubmit *nar;
2247
2248     if (resubmit->table_id == 0xff
2249         && resubmit->ofpact.compat != OFPUTIL_NXAST_RESUBMIT_TABLE) {
2250         nar = ofputil_put_NXAST_RESUBMIT(out);
2251     } else {
2252         nar = ofputil_put_NXAST_RESUBMIT_TABLE(out);
2253         nar->table = resubmit->table_id;
2254     }
2255     nar->in_port = htons(ofp_to_u16(resubmit->in_port));
2256 }
2257
2258 static void
2259 ofpact_set_tunnel_to_nxast(const struct ofpact_tunnel *tunnel,
2260                            struct ofpbuf *out)
2261 {
2262     uint64_t tun_id = tunnel->tun_id;
2263
2264     if (tun_id <= UINT32_MAX
2265         && tunnel->ofpact.compat != OFPUTIL_NXAST_SET_TUNNEL64) {
2266         ofputil_put_NXAST_SET_TUNNEL(out)->tun_id = htonl(tun_id);
2267     } else {
2268         ofputil_put_NXAST_SET_TUNNEL64(out)->tun_id = htonll(tun_id);
2269     }
2270 }
2271
2272 static void
2273 ofpact_write_metadata_to_nxast(const struct ofpact_metadata *om,
2274                                struct ofpbuf *out)
2275 {
2276     struct nx_action_write_metadata *nawm;
2277
2278     nawm = ofputil_put_NXAST_WRITE_METADATA(out);
2279     nawm->metadata = om->metadata;
2280     nawm->mask = om->mask;
2281 }
2282
2283 static void
2284 ofpact_note_to_nxast(const struct ofpact_note *note, struct ofpbuf *out)
2285 {
2286     size_t start_ofs = ofpbuf_size(out);
2287     struct nx_action_note *nan;
2288     unsigned int remainder;
2289     unsigned int len;
2290
2291     ofputil_put_NXAST_NOTE(out);
2292     ofpbuf_set_size(out, ofpbuf_size(out) - sizeof nan->note);
2293
2294     ofpbuf_put(out, note->data, note->length);
2295
2296     len = ofpbuf_size(out) - start_ofs;
2297     remainder = len % OFP_ACTION_ALIGN;
2298     if (remainder) {
2299         ofpbuf_put_zeros(out, OFP_ACTION_ALIGN - remainder);
2300     }
2301     nan = ofpbuf_at(out, start_ofs, sizeof *nan);
2302     nan->len = htons(ofpbuf_size(out) - start_ofs);
2303 }
2304
2305 static void
2306 ofpact_controller_to_nxast(const struct ofpact_controller *oc,
2307                            struct ofpbuf *out)
2308 {
2309     struct nx_action_controller *nac;
2310
2311     nac = ofputil_put_NXAST_CONTROLLER(out);
2312     nac->max_len = htons(oc->max_len);
2313     nac->controller_id = htons(oc->controller_id);
2314     nac->reason = oc->reason;
2315 }
2316
2317 static void
2318 ofpact_dec_ttl_to_nxast(const struct ofpact_cnt_ids *oc_ids,
2319                         struct ofpbuf *out)
2320 {
2321     if (oc_ids->ofpact.compat == OFPUTIL_NXAST_DEC_TTL) {
2322         ofputil_put_NXAST_DEC_TTL(out);
2323     } else {
2324         struct nx_action_cnt_ids *nac_ids =
2325             ofputil_put_NXAST_DEC_TTL_CNT_IDS(out);
2326         int ids_len = ROUND_UP(2 * oc_ids->n_controllers, OFP_ACTION_ALIGN);
2327         ovs_be16 *ids;
2328         size_t i;
2329
2330         nac_ids->len = htons(ntohs(nac_ids->len) + ids_len);
2331         nac_ids->n_controllers = htons(oc_ids->n_controllers);
2332
2333         ids = ofpbuf_put_zeros(out, ids_len);
2334         for (i = 0; i < oc_ids->n_controllers; i++) {
2335             ids[i] = htons(oc_ids->cnt_ids[i]);
2336         }
2337     }
2338 }
2339
2340 static void
2341 ofpact_fin_timeout_to_nxast(const struct ofpact_fin_timeout *fin_timeout,
2342                             struct ofpbuf *out)
2343 {
2344     struct nx_action_fin_timeout *naft = ofputil_put_NXAST_FIN_TIMEOUT(out);
2345     naft->fin_idle_timeout = htons(fin_timeout->fin_idle_timeout);
2346     naft->fin_hard_timeout = htons(fin_timeout->fin_hard_timeout);
2347 }
2348
2349 static void
2350 ofpact_sample_to_nxast(const struct ofpact_sample *os,
2351                        struct ofpbuf *out)
2352 {
2353     struct nx_action_sample *nas;
2354
2355     nas = ofputil_put_NXAST_SAMPLE(out);
2356     nas->probability = htons(os->probability);
2357     nas->collector_set_id = htonl(os->collector_set_id);
2358     nas->obs_domain_id = htonl(os->obs_domain_id);
2359     nas->obs_point_id = htonl(os->obs_point_id);
2360 }
2361
2362 static void
2363 ofpact_to_nxast(const struct ofpact *a, struct ofpbuf *out)
2364 {
2365     switch (a->type) {
2366     case OFPACT_CONTROLLER:
2367         ofpact_controller_to_nxast(ofpact_get_CONTROLLER(a), out);
2368         break;
2369
2370     case OFPACT_OUTPUT_REG:
2371         ofpact_output_reg_to_nxast(ofpact_get_OUTPUT_REG(a), out);
2372         break;
2373
2374     case OFPACT_BUNDLE:
2375         bundle_to_nxast(ofpact_get_BUNDLE(a), out);
2376         break;
2377
2378     case OFPACT_REG_MOVE:
2379         nxm_reg_move_to_nxast(ofpact_get_REG_MOVE(a), out);
2380         break;
2381
2382     case OFPACT_REG_LOAD:
2383         nxm_reg_load_to_nxast(ofpact_get_REG_LOAD(a), out);
2384         break;
2385
2386     case OFPACT_STACK_PUSH:
2387         nxm_stack_push_to_nxast(ofpact_get_STACK_PUSH(a), out);
2388         break;
2389
2390     case OFPACT_STACK_POP:
2391         nxm_stack_pop_to_nxast(ofpact_get_STACK_POP(a), out);
2392         break;
2393
2394     case OFPACT_DEC_TTL:
2395         ofpact_dec_ttl_to_nxast(ofpact_get_DEC_TTL(a), out);
2396         break;
2397
2398     case OFPACT_SET_MPLS_LABEL:
2399         ofputil_put_NXAST_SET_MPLS_LABEL(out)->label
2400             = ofpact_get_SET_MPLS_LABEL(a)->label;
2401         break;
2402
2403     case OFPACT_SET_MPLS_TC:
2404         ofputil_put_NXAST_SET_MPLS_TC(out)->tc
2405             = ofpact_get_SET_MPLS_TC(a)->tc;
2406         break;
2407
2408     case OFPACT_SET_MPLS_TTL:
2409         ofputil_put_NXAST_SET_MPLS_TTL(out)->ttl
2410             = ofpact_get_SET_MPLS_TTL(a)->ttl;
2411         break;
2412
2413     case OFPACT_DEC_MPLS_TTL:
2414         ofputil_put_NXAST_DEC_MPLS_TTL(out);
2415         break;
2416
2417     case OFPACT_SET_TUNNEL:
2418         ofpact_set_tunnel_to_nxast(ofpact_get_SET_TUNNEL(a), out);
2419         break;
2420
2421     case OFPACT_WRITE_METADATA:
2422         ofpact_write_metadata_to_nxast(ofpact_get_WRITE_METADATA(a), out);
2423         break;
2424
2425     case OFPACT_SET_QUEUE:
2426         ofputil_put_NXAST_SET_QUEUE(out)->queue_id
2427             = htonl(ofpact_get_SET_QUEUE(a)->queue_id);
2428         break;
2429
2430     case OFPACT_POP_QUEUE:
2431         ofputil_put_NXAST_POP_QUEUE(out);
2432         break;
2433
2434     case OFPACT_FIN_TIMEOUT:
2435         ofpact_fin_timeout_to_nxast(ofpact_get_FIN_TIMEOUT(a), out);
2436         break;
2437
2438     case OFPACT_RESUBMIT:
2439         ofpact_resubmit_to_nxast(ofpact_get_RESUBMIT(a), out);
2440         break;
2441
2442     case OFPACT_LEARN:
2443         learn_to_nxast(ofpact_get_LEARN(a), out);
2444         break;
2445
2446     case OFPACT_MULTIPATH:
2447         multipath_to_nxast(ofpact_get_MULTIPATH(a), out);
2448         break;
2449
2450     case OFPACT_NOTE:
2451         ofpact_note_to_nxast(ofpact_get_NOTE(a), out);
2452         break;
2453
2454     case OFPACT_EXIT:
2455         ofputil_put_NXAST_EXIT(out);
2456         break;
2457
2458     case OFPACT_PUSH_MPLS:
2459         ofputil_put_NXAST_PUSH_MPLS(out)->ethertype =
2460             ofpact_get_PUSH_MPLS(a)->ethertype;
2461         break;
2462
2463     case OFPACT_POP_MPLS:
2464         ofputil_put_NXAST_POP_MPLS(out)->ethertype =
2465             ofpact_get_POP_MPLS(a)->ethertype;
2466         break;
2467
2468     case OFPACT_SAMPLE:
2469         ofpact_sample_to_nxast(ofpact_get_SAMPLE(a), out);
2470         break;
2471
2472     case OFPACT_GROUP:
2473     case OFPACT_OUTPUT:
2474     case OFPACT_ENQUEUE:
2475     case OFPACT_SET_VLAN_VID:
2476     case OFPACT_SET_VLAN_PCP:
2477     case OFPACT_STRIP_VLAN:
2478     case OFPACT_PUSH_VLAN:
2479     case OFPACT_SET_ETH_SRC:
2480     case OFPACT_SET_ETH_DST:
2481     case OFPACT_SET_IPV4_SRC:
2482     case OFPACT_SET_IPV4_DST:
2483     case OFPACT_SET_IP_DSCP:
2484     case OFPACT_SET_IP_ECN:
2485     case OFPACT_SET_IP_TTL:
2486     case OFPACT_SET_L4_SRC_PORT:
2487     case OFPACT_SET_L4_DST_PORT:
2488     case OFPACT_WRITE_ACTIONS:
2489     case OFPACT_CLEAR_ACTIONS:
2490     case OFPACT_GOTO_TABLE:
2491     case OFPACT_METER:
2492     case OFPACT_SET_FIELD:
2493         OVS_NOT_REACHED();
2494     }
2495 }
2496 \f
2497 /* Converting ofpacts to OpenFlow 1.0. */
2498
2499 static void
2500 ofpact_output_to_openflow10(const struct ofpact_output *output,
2501                             struct ofpbuf *out)
2502 {
2503     struct ofp10_action_output *oao;
2504
2505     oao = ofputil_put_OFPAT10_OUTPUT(out);
2506     oao->port = htons(ofp_to_u16(output->port));
2507     oao->max_len = htons(output->max_len);
2508 }
2509
2510 static void
2511 ofpact_enqueue_to_openflow10(const struct ofpact_enqueue *enqueue,
2512                              struct ofpbuf *out)
2513 {
2514     struct ofp10_action_enqueue *oae;
2515
2516     oae = ofputil_put_OFPAT10_ENQUEUE(out);
2517     oae->port = htons(ofp_to_u16(enqueue->port));
2518     oae->queue_id = htonl(enqueue->queue);
2519 }
2520
2521 static void
2522 ofpact_to_openflow10(const struct ofpact *a, struct ofpbuf *out)
2523 {
2524     switch (a->type) {
2525     case OFPACT_OUTPUT:
2526         ofpact_output_to_openflow10(ofpact_get_OUTPUT(a), out);
2527         break;
2528
2529     case OFPACT_ENQUEUE:
2530         ofpact_enqueue_to_openflow10(ofpact_get_ENQUEUE(a), out);
2531         break;
2532
2533     case OFPACT_SET_VLAN_VID:
2534         ofputil_put_OFPAT10_SET_VLAN_VID(out)->vlan_vid
2535             = htons(ofpact_get_SET_VLAN_VID(a)->vlan_vid);
2536         break;
2537
2538     case OFPACT_SET_VLAN_PCP:
2539         ofputil_put_OFPAT10_SET_VLAN_PCP(out)->vlan_pcp
2540             = ofpact_get_SET_VLAN_PCP(a)->vlan_pcp;
2541         break;
2542
2543     case OFPACT_STRIP_VLAN:
2544         ofputil_put_OFPAT10_STRIP_VLAN(out);
2545         break;
2546
2547     case OFPACT_SET_ETH_SRC:
2548         memcpy(ofputil_put_OFPAT10_SET_DL_SRC(out)->dl_addr,
2549                ofpact_get_SET_ETH_SRC(a)->mac, ETH_ADDR_LEN);
2550         break;
2551
2552     case OFPACT_SET_ETH_DST:
2553         memcpy(ofputil_put_OFPAT10_SET_DL_DST(out)->dl_addr,
2554                ofpact_get_SET_ETH_DST(a)->mac, ETH_ADDR_LEN);
2555         break;
2556
2557     case OFPACT_SET_IPV4_SRC:
2558         ofputil_put_OFPAT10_SET_NW_SRC(out)->nw_addr
2559             = ofpact_get_SET_IPV4_SRC(a)->ipv4;
2560         break;
2561
2562     case OFPACT_SET_IPV4_DST:
2563         ofputil_put_OFPAT10_SET_NW_DST(out)->nw_addr
2564             = ofpact_get_SET_IPV4_DST(a)->ipv4;
2565         break;
2566
2567     case OFPACT_SET_IP_DSCP:
2568         ofputil_put_OFPAT10_SET_NW_TOS(out)->nw_tos
2569             = ofpact_get_SET_IP_DSCP(a)->dscp;
2570         break;
2571
2572     case OFPACT_SET_L4_SRC_PORT:
2573         ofputil_put_OFPAT10_SET_TP_SRC(out)->tp_port
2574             = htons(ofpact_get_SET_L4_SRC_PORT(a)->port);
2575         break;
2576
2577     case OFPACT_SET_L4_DST_PORT:
2578         ofputil_put_OFPAT10_SET_TP_DST(out)->tp_port
2579             = htons(ofpact_get_SET_L4_DST_PORT(a)->port);
2580         break;
2581
2582     case OFPACT_PUSH_VLAN:
2583         /* PUSH is a side effect of a SET_VLAN_VID/PCP, which should
2584          * follow this action. */
2585         break;
2586
2587     case OFPACT_SET_IP_ECN:
2588     case OFPACT_SET_IP_TTL:
2589     case OFPACT_CLEAR_ACTIONS:
2590     case OFPACT_WRITE_ACTIONS:
2591     case OFPACT_GOTO_TABLE:
2592     case OFPACT_METER:
2593         /* XXX */
2594         break;
2595
2596     case OFPACT_GROUP:
2597         break;
2598
2599     case OFPACT_SET_FIELD:
2600         set_field_to_openflow(ofpact_get_SET_FIELD(a), out);
2601         break;
2602
2603     case OFPACT_CONTROLLER:
2604     case OFPACT_OUTPUT_REG:
2605     case OFPACT_BUNDLE:
2606     case OFPACT_REG_MOVE:
2607     case OFPACT_REG_LOAD:
2608     case OFPACT_STACK_PUSH:
2609     case OFPACT_STACK_POP:
2610     case OFPACT_DEC_TTL:
2611     case OFPACT_SET_MPLS_LABEL:
2612     case OFPACT_SET_MPLS_TC:
2613     case OFPACT_SET_MPLS_TTL:
2614     case OFPACT_DEC_MPLS_TTL:
2615     case OFPACT_SET_TUNNEL:
2616     case OFPACT_WRITE_METADATA:
2617     case OFPACT_SET_QUEUE:
2618     case OFPACT_POP_QUEUE:
2619     case OFPACT_FIN_TIMEOUT:
2620     case OFPACT_RESUBMIT:
2621     case OFPACT_LEARN:
2622     case OFPACT_MULTIPATH:
2623     case OFPACT_NOTE:
2624     case OFPACT_EXIT:
2625     case OFPACT_PUSH_MPLS:
2626     case OFPACT_POP_MPLS:
2627     case OFPACT_SAMPLE:
2628         ofpact_to_nxast(a, out);
2629         break;
2630     }
2631 }
2632 \f
2633 /* Converting ofpacts to OpenFlow 1.1. */
2634
2635 static void
2636 ofpact_output_to_openflow11(const struct ofpact_output *output,
2637                             struct ofpbuf *out)
2638 {
2639     struct ofp11_action_output *oao;
2640
2641     oao = ofputil_put_OFPAT11_OUTPUT(out);
2642     oao->port = ofputil_port_to_ofp11(output->port);
2643     oao->max_len = htons(output->max_len);
2644 }
2645
2646 static void
2647 ofpact_dec_ttl_to_openflow11(const struct ofpact_cnt_ids *dec_ttl,
2648                              struct ofpbuf *out)
2649 {
2650     if (dec_ttl->n_controllers == 1 && dec_ttl->cnt_ids[0] == 0
2651         && (!dec_ttl->ofpact.compat ||
2652             dec_ttl->ofpact.compat == OFPUTIL_OFPAT11_DEC_NW_TTL)) {
2653         ofputil_put_OFPAT11_DEC_NW_TTL(out);
2654     } else {
2655         ofpact_dec_ttl_to_nxast(dec_ttl, out);
2656     }
2657 }
2658
2659 static void
2660 ofpact_to_openflow11(const struct ofpact *a, struct ofpbuf *out)
2661 {
2662     switch (a->type) {
2663     case OFPACT_OUTPUT:
2664         return ofpact_output_to_openflow11(ofpact_get_OUTPUT(a), out);
2665
2666     case OFPACT_ENQUEUE:
2667         /* XXX */
2668         break;
2669
2670     case OFPACT_SET_VLAN_VID:
2671         /* Push a VLAN tag, if one was not seen at action validation time. */
2672         if (!ofpact_get_SET_VLAN_VID(a)->flow_has_vlan
2673             && ofpact_get_SET_VLAN_VID(a)->push_vlan_if_needed) {
2674             ofputil_put_OFPAT11_PUSH_VLAN(out)->ethertype
2675                 = htons(ETH_TYPE_VLAN_8021Q);
2676         }
2677         ofputil_put_OFPAT11_SET_VLAN_VID(out)->vlan_vid
2678             = htons(ofpact_get_SET_VLAN_VID(a)->vlan_vid);
2679         break;
2680
2681     case OFPACT_SET_VLAN_PCP:
2682         /* Push a VLAN tag, if one was not seen at action validation time. */
2683         if (!ofpact_get_SET_VLAN_PCP(a)->flow_has_vlan
2684             && ofpact_get_SET_VLAN_PCP(a)->push_vlan_if_needed) {
2685             ofputil_put_OFPAT11_PUSH_VLAN(out)->ethertype
2686                 = htons(ETH_TYPE_VLAN_8021Q);
2687         }
2688         ofputil_put_OFPAT11_SET_VLAN_PCP(out)->vlan_pcp
2689             = ofpact_get_SET_VLAN_PCP(a)->vlan_pcp;
2690         break;
2691
2692     case OFPACT_STRIP_VLAN:
2693         ofputil_put_OFPAT11_POP_VLAN(out);
2694         break;
2695
2696     case OFPACT_PUSH_VLAN:
2697         /* XXX ETH_TYPE_VLAN_8021AD case */
2698         ofputil_put_OFPAT11_PUSH_VLAN(out)->ethertype =
2699             htons(ETH_TYPE_VLAN_8021Q);
2700         break;
2701
2702     case OFPACT_SET_QUEUE:
2703         ofputil_put_OFPAT11_SET_QUEUE(out)->queue_id
2704             = htonl(ofpact_get_SET_QUEUE(a)->queue_id);
2705         break;
2706
2707     case OFPACT_SET_ETH_SRC:
2708         memcpy(ofputil_put_OFPAT11_SET_DL_SRC(out)->dl_addr,
2709                ofpact_get_SET_ETH_SRC(a)->mac, ETH_ADDR_LEN);
2710         break;
2711
2712     case OFPACT_SET_ETH_DST:
2713         memcpy(ofputil_put_OFPAT11_SET_DL_DST(out)->dl_addr,
2714                ofpact_get_SET_ETH_DST(a)->mac, ETH_ADDR_LEN);
2715         break;
2716
2717     case OFPACT_SET_IPV4_SRC:
2718         ofputil_put_OFPAT11_SET_NW_SRC(out)->nw_addr
2719             = ofpact_get_SET_IPV4_SRC(a)->ipv4;
2720         break;
2721
2722     case OFPACT_SET_IPV4_DST:
2723         ofputil_put_OFPAT11_SET_NW_DST(out)->nw_addr
2724             = ofpact_get_SET_IPV4_DST(a)->ipv4;
2725         break;
2726
2727     case OFPACT_SET_IP_DSCP:
2728         ofputil_put_OFPAT11_SET_NW_TOS(out)->nw_tos
2729             = ofpact_get_SET_IP_DSCP(a)->dscp;
2730         break;
2731
2732     case OFPACT_SET_IP_ECN:
2733         ofputil_put_OFPAT11_SET_NW_ECN(out)->nw_ecn
2734             = ofpact_get_SET_IP_ECN(a)->ecn;
2735         break;
2736
2737     case OFPACT_SET_IP_TTL:
2738         ofputil_put_OFPAT11_SET_NW_TTL(out)->nw_ttl
2739             = ofpact_get_SET_IP_TTL(a)->ttl;
2740         break;
2741
2742     case OFPACT_SET_L4_SRC_PORT:
2743         ofputil_put_OFPAT11_SET_TP_SRC(out)->tp_port
2744             = htons(ofpact_get_SET_L4_SRC_PORT(a)->port);
2745         break;
2746
2747     case OFPACT_SET_L4_DST_PORT:
2748         ofputil_put_OFPAT11_SET_TP_DST(out)->tp_port
2749             = htons(ofpact_get_SET_L4_DST_PORT(a)->port);
2750         break;
2751
2752     case OFPACT_DEC_TTL:
2753         ofpact_dec_ttl_to_openflow11(ofpact_get_DEC_TTL(a), out);
2754         break;
2755
2756     case OFPACT_SET_MPLS_LABEL:
2757         ofputil_put_OFPAT11_SET_MPLS_LABEL(out)->mpls_label
2758             = ofpact_get_SET_MPLS_LABEL(a)->label;
2759         break;
2760
2761     case OFPACT_SET_MPLS_TC:
2762         ofputil_put_OFPAT11_SET_MPLS_TC(out)->mpls_tc
2763             = ofpact_get_SET_MPLS_TC(a)->tc;
2764         break;
2765
2766     case OFPACT_SET_MPLS_TTL:
2767         ofputil_put_OFPAT11_SET_MPLS_TTL(out)->mpls_ttl
2768             = ofpact_get_SET_MPLS_TTL(a)->ttl;
2769         break;
2770
2771     case OFPACT_DEC_MPLS_TTL:
2772         ofputil_put_OFPAT11_DEC_MPLS_TTL(out);
2773         break;
2774
2775     case OFPACT_WRITE_METADATA:
2776         /* OpenFlow 1.1 uses OFPIT_WRITE_METADATA to express this action. */
2777         break;
2778
2779     case OFPACT_PUSH_MPLS:
2780         ofputil_put_OFPAT11_PUSH_MPLS(out)->ethertype =
2781             ofpact_get_PUSH_MPLS(a)->ethertype;
2782         break;
2783
2784     case OFPACT_POP_MPLS:
2785         ofputil_put_OFPAT11_POP_MPLS(out)->ethertype =
2786             ofpact_get_POP_MPLS(a)->ethertype;
2787
2788         break;
2789
2790     case OFPACT_CLEAR_ACTIONS:
2791     case OFPACT_WRITE_ACTIONS:
2792     case OFPACT_GOTO_TABLE:
2793     case OFPACT_METER:
2794         OVS_NOT_REACHED();
2795
2796     case OFPACT_GROUP:
2797         ofputil_put_OFPAT11_GROUP(out)->group_id =
2798             htonl(ofpact_get_GROUP(a)->group_id);
2799         break;
2800
2801     case OFPACT_SET_FIELD:
2802         set_field_to_openflow(ofpact_get_SET_FIELD(a), out);
2803         break;
2804
2805     case OFPACT_CONTROLLER:
2806     case OFPACT_OUTPUT_REG:
2807     case OFPACT_BUNDLE:
2808     case OFPACT_REG_MOVE:
2809     case OFPACT_REG_LOAD:
2810     case OFPACT_STACK_PUSH:
2811     case OFPACT_STACK_POP:
2812     case OFPACT_SET_TUNNEL:
2813     case OFPACT_POP_QUEUE:
2814     case OFPACT_FIN_TIMEOUT:
2815     case OFPACT_RESUBMIT:
2816     case OFPACT_LEARN:
2817     case OFPACT_MULTIPATH:
2818     case OFPACT_NOTE:
2819     case OFPACT_EXIT:
2820     case OFPACT_SAMPLE:
2821         ofpact_to_nxast(a, out);
2822         break;
2823     }
2824 }
2825
2826 /* Output deprecated set actions as set_field actions. */
2827 static void
2828 ofpact_to_openflow12(const struct ofpact *a, struct ofpbuf *out)
2829 {
2830     enum mf_field_id field;
2831     union mf_value value;
2832     struct ofpact_l4_port *l4port;
2833     uint8_t proto;
2834
2835     /*
2836      * Convert actions deprecated in OpenFlow 1.2 to Set Field actions,
2837      * if possible.
2838      */
2839     switch ((int)a->type) {
2840     case OFPACT_SET_VLAN_VID:
2841     case OFPACT_SET_VLAN_PCP:
2842     case OFPACT_SET_ETH_SRC:
2843     case OFPACT_SET_ETH_DST:
2844     case OFPACT_SET_IPV4_SRC:
2845     case OFPACT_SET_IPV4_DST:
2846     case OFPACT_SET_IP_DSCP:
2847     case OFPACT_SET_IP_ECN:
2848     case OFPACT_SET_L4_SRC_PORT:
2849     case OFPACT_SET_L4_DST_PORT:
2850     case OFPACT_SET_MPLS_LABEL:
2851     case OFPACT_SET_MPLS_TC:
2852     case OFPACT_SET_TUNNEL:  /* Convert to a set_field, too. */
2853
2854         switch ((int)a->type) {
2855
2856         case OFPACT_SET_VLAN_VID:
2857             if (!ofpact_get_SET_VLAN_VID(a)->flow_has_vlan &&
2858                 ofpact_get_SET_VLAN_VID(a)->push_vlan_if_needed) {
2859                 ofputil_put_OFPAT11_PUSH_VLAN(out)->ethertype
2860                     = htons(ETH_TYPE_VLAN_8021Q);
2861             }
2862             field = MFF_VLAN_VID;
2863             /* Set-Field on OXM_OF_VLAN_VID must have OFPVID_PRESENT set. */
2864             value.be16 = htons(ofpact_get_SET_VLAN_VID(a)->vlan_vid
2865                                | OFPVID12_PRESENT);
2866             break;
2867
2868         case OFPACT_SET_VLAN_PCP:
2869             if (!ofpact_get_SET_VLAN_PCP(a)->flow_has_vlan &&
2870                 ofpact_get_SET_VLAN_PCP(a)->push_vlan_if_needed) {
2871                 ofputil_put_OFPAT11_PUSH_VLAN(out)->ethertype
2872                     = htons(ETH_TYPE_VLAN_8021Q);
2873             }
2874             field = MFF_VLAN_PCP;
2875             value.u8 = ofpact_get_SET_VLAN_PCP(a)->vlan_pcp;
2876             break;
2877
2878         case OFPACT_SET_ETH_SRC:
2879             field = MFF_ETH_SRC;
2880             memcpy(value.mac, ofpact_get_SET_ETH_SRC(a)->mac, ETH_ADDR_LEN);
2881             break;
2882
2883         case OFPACT_SET_ETH_DST:
2884             field = MFF_ETH_DST;
2885             memcpy(value.mac, ofpact_get_SET_ETH_DST(a)->mac, ETH_ADDR_LEN);
2886             break;
2887
2888         case OFPACT_SET_IPV4_SRC:
2889             field = MFF_IPV4_SRC;
2890             value.be32 = ofpact_get_SET_IPV4_SRC(a)->ipv4;
2891             break;
2892
2893         case OFPACT_SET_IPV4_DST:
2894             field = MFF_IPV4_DST;
2895             value.be32 = ofpact_get_SET_IPV4_DST(a)->ipv4;
2896             break;
2897
2898         case OFPACT_SET_IP_DSCP:
2899             field = MFF_IP_DSCP_SHIFTED; /* OXM_OF_IP_DSCP */
2900             value.u8 = ofpact_get_SET_IP_DSCP(a)->dscp >> 2;
2901             break;
2902
2903         case OFPACT_SET_IP_ECN:
2904             field = MFF_IP_ECN;
2905             value.u8 = ofpact_get_SET_IP_ECN(a)->ecn;
2906             break;
2907
2908         case OFPACT_SET_L4_SRC_PORT:
2909             /* We keep track of IP protocol while translating actions to be
2910              * able to translate to the proper OXM type.
2911              * If the IP protocol type is unknown, the translation cannot
2912              * be performed and we will send the action using the original
2913              * action type. */
2914             l4port = ofpact_get_SET_L4_SRC_PORT(a);
2915             proto = l4port->flow_ip_proto;
2916             field = proto == IPPROTO_TCP ? MFF_TCP_SRC
2917                 : proto == IPPROTO_UDP ? MFF_UDP_SRC
2918                 : proto == IPPROTO_SCTP ? MFF_SCTP_SRC
2919                 : MFF_N_IDS; /* RFC: Unknown IP proto, do not translate. */
2920             value.be16 = htons(l4port->port);
2921             break;
2922
2923         case OFPACT_SET_L4_DST_PORT:
2924             l4port = ofpact_get_SET_L4_DST_PORT(a);
2925             proto = l4port->flow_ip_proto;
2926             field = proto == IPPROTO_TCP ? MFF_TCP_DST
2927                 : proto == IPPROTO_UDP ? MFF_UDP_DST
2928                 : proto == IPPROTO_SCTP ? MFF_SCTP_DST
2929                 : MFF_N_IDS; /* RFC: Unknown IP proto, do not translate. */
2930             value.be16 = htons(l4port->port);
2931             break;
2932
2933         case OFPACT_SET_MPLS_LABEL:
2934             field = MFF_MPLS_LABEL;
2935             value.be32 = ofpact_get_SET_MPLS_LABEL(a)->label;
2936             break;
2937
2938         case OFPACT_SET_MPLS_TC:
2939             field = MFF_MPLS_TC;
2940             value.u8 = ofpact_get_SET_MPLS_TC(a)->tc;
2941             break;
2942
2943         case OFPACT_SET_TUNNEL:
2944             field = MFF_TUN_ID;
2945             value.be64 = htonll(ofpact_get_SET_TUNNEL(a)->tun_id);
2946             break;
2947
2948         default:
2949             field = MFF_N_IDS;
2950         }
2951
2952         /* Put the action out as a set field action, if possible. */
2953         if (field < MFF_N_IDS) {
2954             uint64_t ofpacts_stub[128 / 8];
2955             struct ofpbuf sf_act;
2956             struct ofpact_set_field *sf;
2957
2958             ofpbuf_use_stub(&sf_act, ofpacts_stub, sizeof ofpacts_stub);
2959             sf = ofpact_put_SET_FIELD(&sf_act);
2960             sf->field = mf_from_id(field);
2961             memcpy(&sf->value, &value, sf->field->n_bytes);
2962             set_field_to_openflow(sf, out);
2963             return;
2964         }
2965     }
2966
2967     ofpact_to_openflow11(a, out);
2968 }
2969
2970 /* Converts the 'ofpacts_len' bytes of ofpacts in 'ofpacts' into OpenFlow
2971  * actions in 'openflow', appending the actions to any existing data in
2972  * 'openflow'. */
2973 size_t
2974 ofpacts_put_openflow_actions(const struct ofpact ofpacts[], size_t ofpacts_len,
2975                              struct ofpbuf *openflow,
2976                              enum ofp_version ofp_version)
2977 {
2978     const struct ofpact *a;
2979     size_t start_size = ofpbuf_size(openflow);
2980
2981     void (*translate)(const struct ofpact *a, struct ofpbuf *out) =
2982         (ofp_version == OFP10_VERSION) ? ofpact_to_openflow10 :
2983         (ofp_version == OFP11_VERSION) ? ofpact_to_openflow11 :
2984         ofpact_to_openflow12;
2985
2986     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
2987         translate(a, openflow);
2988     }
2989     return ofpbuf_size(openflow) - start_size;
2990 }
2991
2992 static void
2993 ofpacts_update_instruction_actions(struct ofpbuf *openflow, size_t ofs)
2994 {
2995     struct ofp11_instruction_actions *oia;
2996
2997     /* Update the instruction's length (or, if it's empty, delete it). */
2998     oia = ofpbuf_at_assert(openflow, ofs, sizeof *oia);
2999     if (ofpbuf_size(openflow) > ofs + sizeof *oia) {
3000         oia->len = htons(ofpbuf_size(openflow) - ofs);
3001     } else {
3002         ofpbuf_set_size(openflow, ofs);
3003     }
3004 }
3005
3006 void
3007 ofpacts_put_openflow_instructions(const struct ofpact ofpacts[],
3008                                   size_t ofpacts_len,
3009                                   struct ofpbuf *openflow,
3010                                   enum ofp_version ofp_version)
3011 {
3012     const struct ofpact *a;
3013
3014     ovs_assert(ofp_version >= OFP11_VERSION);
3015
3016     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
3017         switch (ovs_instruction_type_from_ofpact_type(a->type)) {
3018         case OVSINST_OFPIT11_CLEAR_ACTIONS:
3019             instruction_put_OFPIT11_CLEAR_ACTIONS(openflow);
3020             break;
3021
3022         case OVSINST_OFPIT11_GOTO_TABLE: {
3023             struct ofp11_instruction_goto_table *oigt;
3024             oigt = instruction_put_OFPIT11_GOTO_TABLE(openflow);
3025             oigt->table_id = ofpact_get_GOTO_TABLE(a)->table_id;
3026             memset(oigt->pad, 0, sizeof oigt->pad);
3027             break;
3028         }
3029
3030         case OVSINST_OFPIT11_WRITE_METADATA: {
3031             const struct ofpact_metadata *om;
3032             struct ofp11_instruction_write_metadata *oiwm;
3033
3034             om = ofpact_get_WRITE_METADATA(a);
3035             oiwm = instruction_put_OFPIT11_WRITE_METADATA(openflow);
3036             oiwm->metadata = om->metadata;
3037             oiwm->metadata_mask = om->mask;
3038             break;
3039         }
3040
3041         case OVSINST_OFPIT13_METER:
3042             if (ofp_version >= OFP13_VERSION) {
3043                 const struct ofpact_meter *om;
3044                 struct ofp13_instruction_meter *oim;
3045
3046                 om = ofpact_get_METER(a);
3047                 oim = instruction_put_OFPIT13_METER(openflow);
3048                 oim->meter_id = htonl(om->meter_id);
3049             }
3050             break;
3051
3052         case OVSINST_OFPIT11_APPLY_ACTIONS: {
3053             const size_t ofs = ofpbuf_size(openflow);
3054             const size_t ofpacts_len_left =
3055                 (uint8_t*)ofpact_end(ofpacts, ofpacts_len) - (uint8_t*)a;
3056             const struct ofpact *action;
3057             const struct ofpact *processed = a;
3058
3059             instruction_put_OFPIT11_APPLY_ACTIONS(openflow);
3060             OFPACT_FOR_EACH(action, a, ofpacts_len_left) {
3061                 if (ovs_instruction_type_from_ofpact_type(action->type)
3062                     != OVSINST_OFPIT11_APPLY_ACTIONS) {
3063                     break;
3064                 }
3065                 if (ofp_version == OFP11_VERSION) {
3066                     ofpact_to_openflow11(action, openflow);
3067                 } else {
3068                     ofpact_to_openflow12(action, openflow);
3069                 }
3070                 processed = action;
3071             }
3072             ofpacts_update_instruction_actions(openflow, ofs);
3073             a = processed;
3074             break;
3075         }
3076
3077         case OVSINST_OFPIT11_WRITE_ACTIONS: {
3078             const size_t ofs = ofpbuf_size(openflow);
3079             const struct ofpact_nest *on;
3080
3081             on = ofpact_get_WRITE_ACTIONS(a);
3082             instruction_put_OFPIT11_WRITE_ACTIONS(openflow);
3083             ofpacts_put_openflow_actions(on->actions,
3084                                          ofpact_nest_get_action_len(on),
3085                                          openflow, ofp_version);
3086             ofpacts_update_instruction_actions(openflow, ofs);
3087
3088             break;
3089         }
3090         }
3091     }
3092 }
3093 \f
3094 /* Returns true if 'action' outputs to 'port', false otherwise. */
3095 static bool
3096 ofpact_outputs_to_port(const struct ofpact *ofpact, ofp_port_t port)
3097 {
3098     switch (ofpact->type) {
3099     case OFPACT_OUTPUT:
3100         return ofpact_get_OUTPUT(ofpact)->port == port;
3101     case OFPACT_ENQUEUE:
3102         return ofpact_get_ENQUEUE(ofpact)->port == port;
3103     case OFPACT_CONTROLLER:
3104         return port == OFPP_CONTROLLER;
3105
3106     case OFPACT_OUTPUT_REG:
3107     case OFPACT_BUNDLE:
3108     case OFPACT_SET_VLAN_VID:
3109     case OFPACT_SET_VLAN_PCP:
3110     case OFPACT_STRIP_VLAN:
3111     case OFPACT_PUSH_VLAN:
3112     case OFPACT_SET_ETH_SRC:
3113     case OFPACT_SET_ETH_DST:
3114     case OFPACT_SET_IPV4_SRC:
3115     case OFPACT_SET_IPV4_DST:
3116     case OFPACT_SET_IP_DSCP:
3117     case OFPACT_SET_IP_ECN:
3118     case OFPACT_SET_IP_TTL:
3119     case OFPACT_SET_L4_SRC_PORT:
3120     case OFPACT_SET_L4_DST_PORT:
3121     case OFPACT_REG_MOVE:
3122     case OFPACT_REG_LOAD:
3123     case OFPACT_SET_FIELD:
3124     case OFPACT_STACK_PUSH:
3125     case OFPACT_STACK_POP:
3126     case OFPACT_DEC_TTL:
3127     case OFPACT_SET_MPLS_LABEL:
3128     case OFPACT_SET_MPLS_TC:
3129     case OFPACT_SET_MPLS_TTL:
3130     case OFPACT_DEC_MPLS_TTL:
3131     case OFPACT_SET_TUNNEL:
3132     case OFPACT_WRITE_METADATA:
3133     case OFPACT_SET_QUEUE:
3134     case OFPACT_POP_QUEUE:
3135     case OFPACT_FIN_TIMEOUT:
3136     case OFPACT_RESUBMIT:
3137     case OFPACT_LEARN:
3138     case OFPACT_MULTIPATH:
3139     case OFPACT_NOTE:
3140     case OFPACT_EXIT:
3141     case OFPACT_PUSH_MPLS:
3142     case OFPACT_POP_MPLS:
3143     case OFPACT_SAMPLE:
3144     case OFPACT_CLEAR_ACTIONS:
3145     case OFPACT_WRITE_ACTIONS:
3146     case OFPACT_GOTO_TABLE:
3147     case OFPACT_METER:
3148     case OFPACT_GROUP:
3149     default:
3150         return false;
3151     }
3152 }
3153
3154 /* Returns true if any action in the 'ofpacts_len' bytes of 'ofpacts' outputs
3155  * to 'port', false otherwise. */
3156 bool
3157 ofpacts_output_to_port(const struct ofpact *ofpacts, size_t ofpacts_len,
3158                        ofp_port_t port)
3159 {
3160     const struct ofpact *a;
3161
3162     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
3163         if (ofpact_outputs_to_port(a, port)) {
3164             return true;
3165         }
3166     }
3167
3168     return false;
3169 }
3170
3171 /* Returns true if any action in the 'ofpacts_len' bytes of 'ofpacts' outputs
3172  * to 'group', false otherwise. */
3173 bool
3174 ofpacts_output_to_group(const struct ofpact *ofpacts, size_t ofpacts_len,
3175                         uint32_t group_id)
3176 {
3177     const struct ofpact *a;
3178
3179     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
3180         if (a->type == OFPACT_GROUP
3181             && ofpact_get_GROUP(a)->group_id == group_id) {
3182             return true;
3183         }
3184     }
3185
3186     return false;
3187 }
3188
3189 bool
3190 ofpacts_equal(const struct ofpact *a, size_t a_len,
3191               const struct ofpact *b, size_t b_len)
3192 {
3193     return a_len == b_len && !memcmp(a, b, a_len);
3194 }
3195
3196 /* Finds the OFPACT_METER action, if any, in the 'ofpacts_len' bytes of
3197  * 'ofpacts'.  If found, returns its meter ID; if not, returns 0.
3198  *
3199  * This function relies on the order of 'ofpacts' being correct (as checked by
3200  * ofpacts_verify()). */
3201 uint32_t
3202 ofpacts_get_meter(const struct ofpact ofpacts[], size_t ofpacts_len)
3203 {
3204     const struct ofpact *a;
3205
3206     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
3207         enum ovs_instruction_type inst;
3208
3209         inst = ovs_instruction_type_from_ofpact_type(a->type);
3210         if (a->type == OFPACT_METER) {
3211             return ofpact_get_METER(a)->meter_id;
3212         } else if (inst > OVSINST_OFPIT13_METER) {
3213             break;
3214         }
3215     }
3216
3217     return 0;
3218 }
3219 \f
3220 /* Formatting ofpacts. */
3221
3222 static void
3223 print_note(const struct ofpact_note *note, struct ds *string)
3224 {
3225     size_t i;
3226
3227     ds_put_cstr(string, "note:");
3228     for (i = 0; i < note->length; i++) {
3229         if (i) {
3230             ds_put_char(string, '.');
3231         }
3232         ds_put_format(string, "%02"PRIx8, note->data[i]);
3233     }
3234 }
3235
3236 static void
3237 print_dec_ttl(const struct ofpact_cnt_ids *ids,
3238               struct ds *s)
3239 {
3240     size_t i;
3241
3242     ds_put_cstr(s, "dec_ttl");
3243     if (ids->ofpact.compat == OFPUTIL_NXAST_DEC_TTL_CNT_IDS) {
3244         ds_put_cstr(s, "(");
3245         for (i = 0; i < ids->n_controllers; i++) {
3246             if (i) {
3247                 ds_put_cstr(s, ",");
3248             }
3249             ds_put_format(s, "%"PRIu16, ids->cnt_ids[i]);
3250         }
3251         ds_put_cstr(s, ")");
3252     }
3253 }
3254
3255 static void
3256 print_fin_timeout(const struct ofpact_fin_timeout *fin_timeout,
3257                   struct ds *s)
3258 {
3259     ds_put_cstr(s, "fin_timeout(");
3260     if (fin_timeout->fin_idle_timeout) {
3261         ds_put_format(s, "idle_timeout=%"PRIu16",",
3262                       fin_timeout->fin_idle_timeout);
3263     }
3264     if (fin_timeout->fin_hard_timeout) {
3265         ds_put_format(s, "hard_timeout=%"PRIu16",",
3266                       fin_timeout->fin_hard_timeout);
3267     }
3268     ds_chomp(s, ',');
3269     ds_put_char(s, ')');
3270 }
3271
3272 static void
3273 ofpact_format(const struct ofpact *a, struct ds *s)
3274 {
3275     const struct ofpact_enqueue *enqueue;
3276     const struct ofpact_resubmit *resubmit;
3277     const struct ofpact_controller *controller;
3278     const struct ofpact_metadata *metadata;
3279     const struct ofpact_tunnel *tunnel;
3280     const struct ofpact_sample *sample;
3281     const struct ofpact_set_field *set_field;
3282     const struct mf_field *mf;
3283     ofp_port_t port;
3284
3285     switch (a->type) {
3286     case OFPACT_OUTPUT:
3287         port = ofpact_get_OUTPUT(a)->port;
3288         if (ofp_to_u16(port) < ofp_to_u16(OFPP_MAX)) {
3289             ds_put_format(s, "output:%"PRIu16, port);
3290         } else {
3291             ofputil_format_port(port, s);
3292             if (port == OFPP_CONTROLLER) {
3293                 ds_put_format(s, ":%"PRIu16, ofpact_get_OUTPUT(a)->max_len);
3294             }
3295         }
3296         break;
3297
3298     case OFPACT_CONTROLLER:
3299         controller = ofpact_get_CONTROLLER(a);
3300         if (controller->reason == OFPR_ACTION &&
3301             controller->controller_id == 0) {
3302             ds_put_format(s, "CONTROLLER:%"PRIu16,
3303                           ofpact_get_CONTROLLER(a)->max_len);
3304         } else {
3305             enum ofp_packet_in_reason reason = controller->reason;
3306
3307             ds_put_cstr(s, "controller(");
3308             if (reason != OFPR_ACTION) {
3309                 char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE];
3310
3311                 ds_put_format(s, "reason=%s,",
3312                               ofputil_packet_in_reason_to_string(
3313                                   reason, reasonbuf, sizeof reasonbuf));
3314             }
3315             if (controller->max_len != UINT16_MAX) {
3316                 ds_put_format(s, "max_len=%"PRIu16",", controller->max_len);
3317             }
3318             if (controller->controller_id != 0) {
3319                 ds_put_format(s, "id=%"PRIu16",", controller->controller_id);
3320             }
3321             ds_chomp(s, ',');
3322             ds_put_char(s, ')');
3323         }
3324         break;
3325
3326     case OFPACT_ENQUEUE:
3327         enqueue = ofpact_get_ENQUEUE(a);
3328         ds_put_format(s, "enqueue:");
3329         ofputil_format_port(enqueue->port, s);
3330         ds_put_format(s, ":%"PRIu32, enqueue->queue);
3331         break;
3332
3333     case OFPACT_OUTPUT_REG:
3334         ds_put_cstr(s, "output:");
3335         mf_format_subfield(&ofpact_get_OUTPUT_REG(a)->src, s);
3336         break;
3337
3338     case OFPACT_BUNDLE:
3339         bundle_format(ofpact_get_BUNDLE(a), s);
3340         break;
3341
3342     case OFPACT_SET_VLAN_VID:
3343         ds_put_format(s, "%s:%"PRIu16,
3344                       (a->compat == OFPUTIL_OFPAT11_SET_VLAN_VID
3345                        ? "set_vlan_vid"
3346                        : "mod_vlan_vid"),
3347                       ofpact_get_SET_VLAN_VID(a)->vlan_vid);
3348         break;
3349
3350     case OFPACT_SET_VLAN_PCP:
3351         ds_put_format(s, "%s:%"PRIu8,
3352                       (a->compat == OFPUTIL_OFPAT11_SET_VLAN_PCP
3353                        ? "set_vlan_pcp"
3354                        : "mod_vlan_pcp"),
3355                       ofpact_get_SET_VLAN_PCP(a)->vlan_pcp);
3356         break;
3357
3358     case OFPACT_STRIP_VLAN:
3359         ds_put_cstr(s, a->compat == OFPUTIL_OFPAT11_POP_VLAN
3360                     ? "pop_vlan" : "strip_vlan");
3361         break;
3362
3363     case OFPACT_PUSH_VLAN:
3364         /* XXX 802.1AD case*/
3365         ds_put_format(s, "push_vlan:%#"PRIx16, ETH_TYPE_VLAN_8021Q);
3366         break;
3367
3368     case OFPACT_SET_ETH_SRC:
3369         ds_put_format(s, "mod_dl_src:"ETH_ADDR_FMT,
3370                       ETH_ADDR_ARGS(ofpact_get_SET_ETH_SRC(a)->mac));
3371         break;
3372
3373     case OFPACT_SET_ETH_DST:
3374         ds_put_format(s, "mod_dl_dst:"ETH_ADDR_FMT,
3375                       ETH_ADDR_ARGS(ofpact_get_SET_ETH_DST(a)->mac));
3376         break;
3377
3378     case OFPACT_SET_IPV4_SRC:
3379         ds_put_format(s, "mod_nw_src:"IP_FMT,
3380                       IP_ARGS(ofpact_get_SET_IPV4_SRC(a)->ipv4));
3381         break;
3382
3383     case OFPACT_SET_IPV4_DST:
3384         ds_put_format(s, "mod_nw_dst:"IP_FMT,
3385                       IP_ARGS(ofpact_get_SET_IPV4_DST(a)->ipv4));
3386         break;
3387
3388     case OFPACT_SET_IP_DSCP:
3389         ds_put_format(s, "mod_nw_tos:%d", ofpact_get_SET_IP_DSCP(a)->dscp);
3390         break;
3391
3392     case OFPACT_SET_IP_ECN:
3393         ds_put_format(s, "mod_nw_ecn:%d", ofpact_get_SET_IP_ECN(a)->ecn);
3394         break;
3395
3396     case OFPACT_SET_IP_TTL:
3397         ds_put_format(s, "mod_nw_ttl:%d", ofpact_get_SET_IP_TTL(a)->ttl);
3398         break;
3399
3400     case OFPACT_SET_L4_SRC_PORT:
3401         ds_put_format(s, "mod_tp_src:%d", ofpact_get_SET_L4_SRC_PORT(a)->port);
3402         break;
3403
3404     case OFPACT_SET_L4_DST_PORT:
3405         ds_put_format(s, "mod_tp_dst:%d", ofpact_get_SET_L4_DST_PORT(a)->port);
3406         break;
3407
3408     case OFPACT_REG_MOVE:
3409         nxm_format_reg_move(ofpact_get_REG_MOVE(a), s);
3410         break;
3411
3412     case OFPACT_REG_LOAD:
3413         nxm_format_reg_load(ofpact_get_REG_LOAD(a), s);
3414         break;
3415
3416     case OFPACT_SET_FIELD:
3417         set_field = ofpact_get_SET_FIELD(a);
3418         mf = set_field->field;
3419         ds_put_format(s, "set_field:");
3420         mf_format(mf, &set_field->value, NULL, s);
3421         ds_put_format(s, "->%s", mf->name);
3422         break;
3423
3424     case OFPACT_STACK_PUSH:
3425         nxm_format_stack_push(ofpact_get_STACK_PUSH(a), s);
3426         break;
3427
3428     case OFPACT_STACK_POP:
3429         nxm_format_stack_pop(ofpact_get_STACK_POP(a), s);
3430         break;
3431
3432     case OFPACT_DEC_TTL:
3433         print_dec_ttl(ofpact_get_DEC_TTL(a), s);
3434         break;
3435
3436     case OFPACT_SET_MPLS_LABEL:
3437         ds_put_format(s, "set_mpls_label(%"PRIu32")",
3438                       ntohl(ofpact_get_SET_MPLS_LABEL(a)->label));
3439         break;
3440
3441     case OFPACT_SET_MPLS_TC:
3442         ds_put_format(s, "set_mpls_ttl(%"PRIu8")",
3443                       ofpact_get_SET_MPLS_TC(a)->tc);
3444         break;
3445
3446     case OFPACT_SET_MPLS_TTL:
3447         ds_put_format(s, "set_mpls_ttl(%"PRIu8")",
3448                       ofpact_get_SET_MPLS_TTL(a)->ttl);
3449         break;
3450
3451     case OFPACT_DEC_MPLS_TTL:
3452         ds_put_cstr(s, "dec_mpls_ttl");
3453         break;
3454
3455     case OFPACT_SET_TUNNEL:
3456         tunnel = ofpact_get_SET_TUNNEL(a);
3457         ds_put_format(s, "set_tunnel%s:%#"PRIx64,
3458                       (tunnel->tun_id > UINT32_MAX
3459                        || a->compat == OFPUTIL_NXAST_SET_TUNNEL64 ? "64" : ""),
3460                       tunnel->tun_id);
3461         break;
3462
3463     case OFPACT_SET_QUEUE:
3464         ds_put_format(s, "set_queue:%"PRIu32,
3465                       ofpact_get_SET_QUEUE(a)->queue_id);
3466         break;
3467
3468     case OFPACT_POP_QUEUE:
3469         ds_put_cstr(s, "pop_queue");
3470         break;
3471
3472     case OFPACT_FIN_TIMEOUT:
3473         print_fin_timeout(ofpact_get_FIN_TIMEOUT(a), s);
3474         break;
3475
3476     case OFPACT_RESUBMIT:
3477         resubmit = ofpact_get_RESUBMIT(a);
3478         if (resubmit->in_port != OFPP_IN_PORT && resubmit->table_id == 255) {
3479             ds_put_cstr(s, "resubmit:");
3480             ofputil_format_port(resubmit->in_port, s);
3481         } else {
3482             ds_put_format(s, "resubmit(");
3483             if (resubmit->in_port != OFPP_IN_PORT) {
3484                 ofputil_format_port(resubmit->in_port, s);
3485             }
3486             ds_put_char(s, ',');
3487             if (resubmit->table_id != 255) {
3488                 ds_put_format(s, "%"PRIu8, resubmit->table_id);
3489             }
3490             ds_put_char(s, ')');
3491         }
3492         break;
3493
3494     case OFPACT_LEARN:
3495         learn_format(ofpact_get_LEARN(a), s);
3496         break;
3497
3498     case OFPACT_MULTIPATH:
3499         multipath_format(ofpact_get_MULTIPATH(a), s);
3500         break;
3501
3502     case OFPACT_NOTE:
3503         print_note(ofpact_get_NOTE(a), s);
3504         break;
3505
3506     case OFPACT_PUSH_MPLS:
3507         ds_put_format(s, "push_mpls:0x%04"PRIx16,
3508                       ntohs(ofpact_get_PUSH_MPLS(a)->ethertype));
3509         break;
3510
3511     case OFPACT_POP_MPLS:
3512         ds_put_format(s, "pop_mpls:0x%04"PRIx16,
3513                       ntohs(ofpact_get_POP_MPLS(a)->ethertype));
3514         break;
3515
3516     case OFPACT_EXIT:
3517         ds_put_cstr(s, "exit");
3518         break;
3519
3520     case OFPACT_SAMPLE:
3521         sample = ofpact_get_SAMPLE(a);
3522         ds_put_format(
3523             s, "sample(probability=%"PRIu16",collector_set_id=%"PRIu32
3524             ",obs_domain_id=%"PRIu32",obs_point_id=%"PRIu32")",
3525             sample->probability, sample->collector_set_id,
3526             sample->obs_domain_id, sample->obs_point_id);
3527         break;
3528
3529     case OFPACT_WRITE_ACTIONS: {
3530         struct ofpact_nest *on = ofpact_get_WRITE_ACTIONS(a);
3531         ds_put_format(s, "%s(",
3532                       ovs_instruction_name_from_type(
3533                           OVSINST_OFPIT11_WRITE_ACTIONS));
3534         ofpacts_format(on->actions, ofpact_nest_get_action_len(on), s);
3535         ds_put_char(s, ')');
3536         break;
3537     }
3538
3539     case OFPACT_CLEAR_ACTIONS:
3540         ds_put_format(s, "%s",
3541                       ovs_instruction_name_from_type(
3542                           OVSINST_OFPIT11_CLEAR_ACTIONS));
3543         break;
3544
3545     case OFPACT_WRITE_METADATA:
3546         metadata = ofpact_get_WRITE_METADATA(a);
3547         ds_put_format(s, "%s:%#"PRIx64,
3548                       ovs_instruction_name_from_type(
3549                           OVSINST_OFPIT11_WRITE_METADATA),
3550                       ntohll(metadata->metadata));
3551         if (metadata->mask != OVS_BE64_MAX) {
3552             ds_put_format(s, "/%#"PRIx64, ntohll(metadata->mask));
3553         }
3554         break;
3555
3556     case OFPACT_GOTO_TABLE:
3557         ds_put_format(s, "%s:%"PRIu8,
3558                       ovs_instruction_name_from_type(
3559                           OVSINST_OFPIT11_GOTO_TABLE),
3560                       ofpact_get_GOTO_TABLE(a)->table_id);
3561         break;
3562
3563     case OFPACT_METER:
3564         ds_put_format(s, "%s:%"PRIu32,
3565                       ovs_instruction_name_from_type(OVSINST_OFPIT13_METER),
3566                       ofpact_get_METER(a)->meter_id);
3567         break;
3568
3569     case OFPACT_GROUP:
3570         ds_put_format(s, "group:%"PRIu32,
3571                       ofpact_get_GROUP(a)->group_id);
3572         break;
3573     }
3574 }
3575
3576 /* Appends a string representing the 'ofpacts_len' bytes of ofpacts in
3577  * 'ofpacts' to 'string'. */
3578 void
3579 ofpacts_format(const struct ofpact *ofpacts, size_t ofpacts_len,
3580                struct ds *string)
3581 {
3582     if (!ofpacts_len) {
3583         ds_put_cstr(string, "drop");
3584     } else {
3585         const struct ofpact *a;
3586
3587         OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
3588             if (a != ofpacts) {
3589                 ds_put_cstr(string, ",");
3590             }
3591
3592             /* XXX write-actions */
3593             ofpact_format(a, string);
3594         }
3595     }
3596 }
3597 \f
3598 /* Internal use by helpers. */
3599
3600 void *
3601 ofpact_put(struct ofpbuf *ofpacts, enum ofpact_type type, size_t len)
3602 {
3603     struct ofpact *ofpact;
3604
3605     ofpact_pad(ofpacts);
3606     ofpact = ofpacts->frame = ofpbuf_put_uninit(ofpacts, len);
3607     ofpact_init(ofpact, type, len);
3608     return ofpact;
3609 }
3610
3611 void
3612 ofpact_init(struct ofpact *ofpact, enum ofpact_type type, size_t len)
3613 {
3614     memset(ofpact, 0, len);
3615     ofpact->type = type;
3616     ofpact->compat = OFPUTIL_ACTION_INVALID;
3617     ofpact->len = len;
3618 }
3619 \f
3620 /* Updates 'ofpact->len' to the number of bytes in the tail of 'ofpacts'
3621  * starting at 'ofpact'.
3622  *
3623  * This is the correct way to update a variable-length ofpact's length after
3624  * adding the variable-length part of the payload.  (See the large comment
3625  * near the end of ofp-actions.h for more information.) */
3626 void
3627 ofpact_update_len(struct ofpbuf *ofpacts, struct ofpact *ofpact)
3628 {
3629     ovs_assert(ofpact == ofpacts->frame);
3630     ofpact->len = (char *) ofpbuf_tail(ofpacts) - (char *) ofpact;
3631 }
3632
3633 /* Pads out 'ofpacts' to a multiple of OFPACT_ALIGNTO bytes in length.  Each
3634  * ofpact_put_<ENUM>() calls this function automatically beforehand, but the
3635  * client must call this itself after adding the final ofpact to an array of
3636  * them.
3637  *
3638  * (The consequences of failing to call this function are probably not dire.
3639  * OFPACT_FOR_EACH will calculate a pointer beyond the end of the ofpacts, but
3640  * not dereference it.  That's undefined behavior, technically, but it will not
3641  * cause a real problem on common systems.  Still, it seems better to call
3642  * it.) */
3643 void
3644 ofpact_pad(struct ofpbuf *ofpacts)
3645 {
3646     unsigned int pad = PAD_SIZE(ofpbuf_size(ofpacts), OFPACT_ALIGNTO);
3647     if (pad) {
3648         ofpbuf_put_zeros(ofpacts, pad);
3649     }
3650 }