lib/ofp-parse.c

   1 /*
   2  * Copyright (c) 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
  19 #include "ofp-parse.h"
  20
  21 #include <ctype.h>
  22 #include <errno.h>
  23 #include <stdlib.h>
  24
  25 #include "bundle.h"
  26 #include "byte-order.h"
  27 #include "dynamic-string.h"
  28 #include "learn.h"
  29 #include "meta-flow.h"
  30 #include "multipath.h"
  31 #include "netdev.h"
  32 #include "nx-match.h"
  33 #include "ofp-actions.h"
  34 #include "ofp-util.h"
  35 #include "ofpbuf.h"
  36 #include "openflow/openflow.h"
  37 #include "ovs-thread.h"
  38 #include "packets.h"
  39 #include "simap.h"
  40 #include "socket-util.h"
  41 #include "vconn.h"
  42
  43 /* Parses 'str' as an 8-bit unsigned integer into '*valuep'.
  44  *
  45  * 'name' describes the value parsed in an error message, if any.
  46  *
  47  * Returns NULL if successful, otherwise a malloc()'d string describing the
  48  * error.  The caller is responsible for freeing the returned string. */
  49 char * WARN_UNUSED_RESULT
  50 str_to_u8(const char *str, const char *name, uint8_t *valuep)
  51 {
  52     int value;
  53
  54     if (!str_to_int(str, 0, &value) || value < 0 || value > 255) {
  55         return xasprintf("invalid %s \"%s\"", name, str);
  56     }
  57     *valuep = value;
  58     return NULL;
  59 }
  60
  61 /* Parses 'str' as a 16-bit unsigned integer into '*valuep'.
  62  *
  63  * 'name' describes the value parsed in an error message, if any.
  64  *
  65  * Returns NULL if successful, otherwise a malloc()'d string describing the
  66  * error.  The caller is responsible for freeing the returned string. */
  67 char * WARN_UNUSED_RESULT
  68 str_to_u16(const char *str, const char *name, uint16_t *valuep)
  69 {
  70     int value;
  71
  72     if (!str_to_int(str, 0, &value) || value < 0 || value > 65535) {
  73         return xasprintf("invalid %s \"%s\"", name, str);
  74     }
  75     *valuep = value;
  76     return NULL;
  77 }
  78
  79 /* Parses 'str' as a 32-bit unsigned integer into '*valuep'.
  80  *
  81  * Returns NULL if successful, otherwise a malloc()'d string describing the
  82  * error.  The caller is responsible for freeing the returned string. */
  83 char * WARN_UNUSED_RESULT
  84 str_to_u32(const char *str, uint32_t *valuep)
  85 {
  86     char *tail;
  87     uint32_t value;
  88
  89     if (!str[0]) {
  90         return xstrdup("missing required numeric argument");
  91     }
  92
  93     errno = 0;
  94     value = strtoul(str, &tail, 0);
  95     if (errno == EINVAL || errno == ERANGE || *tail) {
  96         return xasprintf("invalid numeric format %s", str);
  97     }
  98     *valuep = value;
  99     return NULL;
 100 }
 101
 102 /* Parses 'str' as an 64-bit unsigned integer into '*valuep'.
 103  *
 104  * Returns NULL if successful, otherwise a malloc()'d string describing the
 105  * error.  The caller is responsible for freeing the returned string. */
 106 char * WARN_UNUSED_RESULT
 107 str_to_u64(const char *str, uint64_t *valuep)
 108 {
 109     char *tail;
 110     uint64_t value;
 111
 112     if (!str[0]) {
 113         return xstrdup("missing required numeric argument");
 114     }
 115
 116     errno = 0;
 117     value = strtoull(str, &tail, 0);
 118     if (errno == EINVAL || errno == ERANGE || *tail) {
 119         return xasprintf("invalid numeric format %s", str);
 120     }
 121     *valuep = value;
 122     return NULL;
 123 }
 124
 125 /* Parses 'str' as an 64-bit unsigned integer in network byte order into
 126  * '*valuep'.
 127  *
 128  * Returns NULL if successful, otherwise a malloc()'d string describing the
 129  * error.  The caller is responsible for freeing the returned string. */
 130 char * WARN_UNUSED_RESULT
 131 str_to_be64(const char *str, ovs_be64 *valuep)
 132 {
 133     uint64_t value = 0;
 134     char *error;
 135
 136     error = str_to_u64(str, &value);
 137     if (!error) {
 138         *valuep = htonll(value);
 139     }
 140     return error;
 141 }
 142
 143 /* Parses 'str' as an Ethernet address into 'mac'.
 144  *
 145  * Returns NULL if successful, otherwise a malloc()'d string describing the
 146  * error.  The caller is responsible for freeing the returned string. */
 147 char * WARN_UNUSED_RESULT
 148 str_to_mac(const char *str, uint8_t mac[6])
 149 {
 150     if (!ovs_scan(str, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(mac))) {
 151         return xasprintf("invalid mac address %s", str);
 152     }
 153     return NULL;
 154 }
 155
 156 /* Parses 'str' as an IP address into '*ip'.
 157  *
 158  * Returns NULL if successful, otherwise a malloc()'d string describing the
 159  * error.  The caller is responsible for freeing the returned string. */
 160 char * WARN_UNUSED_RESULT
 161 str_to_ip(const char *str, ovs_be32 *ip)
 162 {
 163     struct in_addr in_addr;
 164
 165     if (lookup_ip(str, &in_addr)) {
 166         return xasprintf("%s: could not convert to IP address", str);
 167     }
 168     *ip = in_addr.s_addr;
 169     return NULL;
 170 }
 171
 172 /* Parses 'arg' as the argument to an "enqueue" action, and appends such an
 173  * action to 'ofpacts'.
 174  *
 175  * Returns NULL if successful, otherwise a malloc()'d string describing the
 176  * error.  The caller is responsible for freeing the returned string. */
 177 static char * WARN_UNUSED_RESULT
 178 parse_enqueue(char *arg, struct ofpbuf *ofpacts)
 179 {
 180     char *sp = NULL;
 181     char *port = strtok_r(arg, ":q,", &sp);
 182     char *queue = strtok_r(NULL, "", &sp);
 183     struct ofpact_enqueue *enqueue;
 184
 185     if (port == NULL || queue == NULL) {
 186         return xstrdup("\"enqueue\" syntax is \"enqueue:PORT:QUEUE\" or "
 187                        "\"enqueue(PORT,QUEUE)\"");
 188     }
 189
 190     enqueue = ofpact_put_ENQUEUE(ofpacts);
 191     if (!ofputil_port_from_string(port, &enqueue->port)) {
 192         return xasprintf("%s: enqueue to unknown port", port);
 193     }
 194     return str_to_u32(queue, &enqueue->queue);
 195 }
 196
 197 /* Parses 'arg' as the argument to an "output" action, and appends such an
 198  * action to 'ofpacts'.
 199  *
 200  * Returns NULL if successful, otherwise a malloc()'d string describing the
 201  * error.  The caller is responsible for freeing the returned string. */
 202 static char * WARN_UNUSED_RESULT
 203 parse_output(const char *arg, struct ofpbuf *ofpacts)
 204 {
 205     if (strchr(arg, '[')) {
 206         struct ofpact_output_reg *output_reg;
 207
 208         output_reg = ofpact_put_OUTPUT_REG(ofpacts);
 209         output_reg->max_len = UINT16_MAX;
 210         return mf_parse_subfield(&output_reg->src, arg);
 211     } else {
 212         struct ofpact_output *output;
 213
 214         output = ofpact_put_OUTPUT(ofpacts);
 215         if (!ofputil_port_from_string(arg, &output->port)) {
 216             return xasprintf("%s: output to unknown port", arg);
 217         }
 218         output->max_len = output->port == OFPP_CONTROLLER ? UINT16_MAX : 0;
 219         return NULL;
 220     }
 221 }
 222
 223 /* Parses 'arg' as the argument to an "resubmit" action, and appends such an
 224  * action to 'ofpacts'.
 225  *
 226  * Returns NULL if successful, otherwise a malloc()'d string describing the
 227  * error.  The caller is responsible for freeing the returned string. */
 228 static char * WARN_UNUSED_RESULT
 229 parse_resubmit(char *arg, struct ofpbuf *ofpacts)
 230 {
 231     struct ofpact_resubmit *resubmit;
 232     char *in_port_s, *table_s;
 233
 234     resubmit = ofpact_put_RESUBMIT(ofpacts);
 235
 236     in_port_s = strsep(&arg, ",");
 237     if (in_port_s && in_port_s[0]) {
 238         if (!ofputil_port_from_string(in_port_s, &resubmit->in_port)) {
 239             return xasprintf("%s: resubmit to unknown port", in_port_s);
 240         }
 241     } else {
 242         resubmit->in_port = OFPP_IN_PORT;
 243     }
 244
 245     table_s = strsep(&arg, ",");
 246     if (table_s && table_s[0]) {
 247         uint32_t table_id = 0;
 248         char *error;
 249
 250         error = str_to_u32(table_s, &table_id);
 251         if (error) {
 252             return error;
 253         }
 254         resubmit->table_id = table_id;
 255     } else {
 256         resubmit->table_id = 255;
 257     }
 258
 259     if (resubmit->in_port == OFPP_IN_PORT && resubmit->table_id == 255) {
 260         return xstrdup("at least one \"in_port\" or \"table\" must be "
 261                        "specified  on resubmit");
 262     }
 263     return NULL;
 264 }
 265
 266 /* Parses 'arg' as the argument to a "note" action, and appends such an action
 267  * to 'ofpacts'.
 268  *
 269  * Returns NULL if successful, otherwise a malloc()'d string describing the
 270  * error.  The caller is responsible for freeing the returned string. */
 271 static char * WARN_UNUSED_RESULT
 272 parse_note(const char *arg, struct ofpbuf *ofpacts)
 273 {
 274     struct ofpact_note *note;
 275
 276     note = ofpact_put_NOTE(ofpacts);
 277     while (*arg != '\0') {
 278         uint8_t byte;
 279         bool ok;
 280
 281         if (*arg == '.') {
 282             arg++;
 283         }
 284         if (*arg == '\0') {
 285             break;
 286         }
 287
 288         byte = hexits_value(arg, 2, &ok);
 289         if (!ok) {
 290             return xstrdup("bad hex digit in `note' argument");
 291         }
 292         ofpbuf_put(ofpacts, &byte, 1);
 293
 294         note = ofpacts->frame;
 295         note->length++;
 296
 297         arg += 2;
 298     }
 299     ofpact_update_len(ofpacts, &note->ofpact);
 300     return NULL;
 301 }
 302
 303 /* Parses 'arg' as the argument to a "fin_timeout" action, and appends such an
 304  * action to 'ofpacts'.
 305  *
 306  * Returns NULL if successful, otherwise a malloc()'d string describing the
 307  * error.  The caller is responsible for freeing the returned string. */
 308 static char * WARN_UNUSED_RESULT
 309 parse_fin_timeout(struct ofpbuf *b, char *arg)
 310 {
 311     struct ofpact_fin_timeout *oft = ofpact_put_FIN_TIMEOUT(b);
 312     char *key, *value;
 313
 314     while (ofputil_parse_key_value(&arg, &key, &value)) {
 315         char *error;
 316
 317         if (!strcmp(key, "idle_timeout")) {
 318             error =  str_to_u16(value, key, &oft->fin_idle_timeout);
 319         } else if (!strcmp(key, "hard_timeout")) {
 320             error = str_to_u16(value, key, &oft->fin_hard_timeout);
 321         } else {
 322             error = xasprintf("invalid key '%s' in 'fin_timeout' argument",
 323                               key);
 324         }
 325
 326         if (error) {
 327             return error;
 328         }
 329     }
 330     return NULL;
 331 }
 332
 333 /* Parses 'arg' as the argument to a "controller" action, and appends such an
 334  * action to 'ofpacts'.
 335  *
 336  * Returns NULL if successful, otherwise a malloc()'d string describing the
 337  * error.  The caller is responsible for freeing the returned string. */
 338 static char * WARN_UNUSED_RESULT
 339 parse_controller(struct ofpbuf *b, char *arg)
 340 {
 341     enum ofp_packet_in_reason reason = OFPR_ACTION;
 342     uint16_t controller_id = 0;
 343     uint16_t max_len = UINT16_MAX;
 344
 345     if (!arg[0]) {
 346         /* Use defaults. */
 347     } else if (strspn(arg, "0123456789") == strlen(arg)) {
 348         char *error = str_to_u16(arg, "max_len", &max_len);
 349         if (error) {
 350             return error;
 351         }
 352     } else {
 353         char *name, *value;
 354
 355         while (ofputil_parse_key_value(&arg, &name, &value)) {
 356             if (!strcmp(name, "reason")) {
 357                 if (!ofputil_packet_in_reason_from_string(value, &reason)) {
 358                     return xasprintf("unknown reason \"%s\"", value);
 359                 }
 360             } else if (!strcmp(name, "max_len")) {
 361                 char *error = str_to_u16(value, "max_len", &max_len);
 362                 if (error) {
 363                     return error;
 364                 }
 365             } else if (!strcmp(name, "id")) {
 366                 char *error = str_to_u16(value, "id", &controller_id);
 367                 if (error) {
 368                     return error;
 369                 }
 370             } else {
 371                 return xasprintf("unknown key \"%s\" parsing controller "
 372                                  "action", name);
 373             }
 374         }
 375     }
 376
 377     if (reason == OFPR_ACTION && controller_id == 0) {
 378         struct ofpact_output *output;
 379
 380         output = ofpact_put_OUTPUT(b);
 381         output->port = OFPP_CONTROLLER;
 382         output->max_len = max_len;
 383     } else {
 384         struct ofpact_controller *controller;
 385
 386         controller = ofpact_put_CONTROLLER(b);
 387         controller->max_len = max_len;
 388         controller->reason = reason;
 389         controller->controller_id = controller_id;
 390     }
 391
 392     return NULL;
 393 }
 394
 395 static void
 396 parse_noargs_dec_ttl(struct ofpbuf *b)
 397 {
 398     struct ofpact_cnt_ids *ids;
 399     uint16_t id = 0;
 400
 401     ofpact_put_DEC_TTL(b);
 402     ofpbuf_put(b, &id, sizeof id);
 403     ids = b->frame;
 404     ids->n_controllers++;
 405     ofpact_update_len(b, &ids->ofpact);
 406 }
 407
 408 /* Parses 'arg' as the argument to a "dec_ttl" action, and appends such an
 409  * action to 'ofpacts'.
 410  *
 411  * Returns NULL if successful, otherwise a malloc()'d string describing the
 412  * error.  The caller is responsible for freeing the returned string. */
 413 static char * WARN_UNUSED_RESULT
 414 parse_dec_ttl(struct ofpbuf *b, char *arg)
 415 {
 416     if (*arg == '\0') {
 417         parse_noargs_dec_ttl(b);
 418     } else {
 419         struct ofpact_cnt_ids *ids;
 420         char *cntr;
 421
 422         ids = ofpact_put_DEC_TTL(b);
 423         ids->ofpact.compat = OFPUTIL_NXAST_DEC_TTL_CNT_IDS;
 424         for (cntr = strtok_r(arg, ", ", &arg); cntr != NULL;
 425              cntr = strtok_r(NULL, ", ", &arg)) {
 426             uint16_t id = atoi(cntr);
 427
 428             ofpbuf_put(b, &id, sizeof id);
 429             ids = b->frame;
 430             ids->n_controllers++;
 431         }
 432         if (!ids->n_controllers) {
 433             return xstrdup("dec_ttl_cnt_ids: expected at least one controller "
 434                            "id.");
 435         }
 436         ofpact_update_len(b, &ids->ofpact);
 437     }
 438     return NULL;
 439 }
 440
 441 /* Parses 'arg' as the argument to a "set_mpls_label" action, and appends such
 442  * an action to 'b'.
 443  *
 444  * Returns NULL if successful, otherwise a malloc()'d string describing the
 445  * error.  The caller is responsible for freeing the returned string. */
 446 static char * WARN_UNUSED_RESULT
 447 parse_set_mpls_label(struct ofpbuf *b, const char *arg)
 448 {
 449     struct ofpact_mpls_label *mpls_label = ofpact_put_SET_MPLS_LABEL(b);
 450
 451     if (*arg == '\0') {
 452         return xstrdup("parse_set_mpls_label: expected label.");
 453     }
 454
 455     mpls_label->label = htonl(atoi(arg));
 456     return NULL;
 457 }
 458
 459 /* Parses 'arg' as the argument to a "set_mpls_tc" action, and appends such an
 460  * action to 'b'.
 461  *
 462  * Returns NULL if successful, otherwise a malloc()'d string describing the
 463  * error.  The caller is responsible for freeing the returned string. */
 464 static char * WARN_UNUSED_RESULT
 465 parse_set_mpls_tc(struct ofpbuf *b, const char *arg)
 466 {
 467     struct ofpact_mpls_tc *mpls_tc = ofpact_put_SET_MPLS_TC(b);
 468
 469     if (*arg == '\0') {
 470         return xstrdup("parse_set_mpls_tc: expected tc.");
 471     }
 472
 473     mpls_tc->tc = atoi(arg);
 474     return NULL;
 475 }
 476
 477 /* Parses 'arg' as the argument to a "set_mpls_ttl" action, and appends such an
 478  * action to 'ofpacts'.
 479  *
 480  * Returns NULL if successful, otherwise a malloc()'d string describing the
 481  * error.  The caller is responsible for freeing the returned string. */
 482 static char * WARN_UNUSED_RESULT
 483 parse_set_mpls_ttl(struct ofpbuf *b, const char *arg)
 484 {
 485     struct ofpact_mpls_ttl *mpls_ttl = ofpact_put_SET_MPLS_TTL(b);
 486
 487     if (*arg == '\0') {
 488         return xstrdup("parse_set_mpls_ttl: expected ttl.");
 489     }
 490
 491     mpls_ttl->ttl = atoi(arg);
 492     return NULL;
 493 }
 494
 495 /* Parses a "set_field" action with argument 'arg', appending the parsed
 496  * action to 'ofpacts'.
 497  *
 498  * Returns NULL if successful, otherwise a malloc()'d string describing the
 499  * error.  The caller is responsible for freeing the returned string. */
 500 static char * WARN_UNUSED_RESULT
 501 set_field_parse__(char *arg, struct ofpbuf *ofpacts,
 502                   enum ofputil_protocol *usable_protocols)
 503 {
 504     struct ofpact_set_field *sf = ofpact_put_SET_FIELD(ofpacts);
 505     char *value;
 506     char *delim;
 507     char *key;
 508     const struct mf_field *mf;
 509     char *error;
 510
 511     value = arg;
 512     delim = strstr(arg, "->");
 513     if (!delim) {
 514         return xasprintf("%s: missing `->'", arg);
 515     }
 516     if (strlen(delim) <= strlen("->")) {
 517         return xasprintf("%s: missing field name following `->'", arg);
 518     }
 519
 520     key = delim + strlen("->");
 521     mf = mf_from_name(key);
 522     if (!mf) {
 523         return xasprintf("%s is not a valid OXM field name", key);
 524     }
 525     if (!mf->writable) {
 526         return xasprintf("%s is read-only", key);
 527     }
 528     sf->field = mf;
 529     delim[0] = '\0';
 530     error = mf_parse_value(mf, value, &sf->value);
 531     if (error) {
 532         return error;
 533     }
 534
 535     if (!mf_is_value_valid(mf, &sf->value)) {
 536         return xasprintf("%s is not a valid value for field %s", value, key);
 537     }
 538
 539     *usable_protocols &= mf->usable_protocols;
 540     return NULL;
 541 }
 542
 543 /* Parses 'arg' as the argument to a "set_field" action, and appends such an
 544  * action to 'ofpacts'.
 545  *
 546  * Returns NULL if successful, otherwise a malloc()'d string describing the
 547  * error.  The caller is responsible for freeing the returned string. */
 548 static char * WARN_UNUSED_RESULT
 549 set_field_parse(const char *arg, struct ofpbuf *ofpacts,
 550                 enum ofputil_protocol *usable_protocols)
 551 {
 552     char *copy = xstrdup(arg);
 553     char *error = set_field_parse__(copy, ofpacts, usable_protocols);
 554     free(copy);
 555     return error;
 556 }
 557
 558 /* Parses 'arg' as the argument to a "write_metadata" instruction, and appends
 559  * such an action to 'ofpacts'.
 560  *
 561  * Returns NULL if successful, otherwise a malloc()'d string describing the
 562  * error.  The caller is responsible for freeing the returned string. */
 563 static char * WARN_UNUSED_RESULT
 564 parse_metadata(struct ofpbuf *b, char *arg)
 565 {
 566     struct ofpact_metadata *om;
 567     char *mask = strchr(arg, '/');
 568
 569     om = ofpact_put_WRITE_METADATA(b);
 570
 571     if (mask) {
 572         char *error;
 573
 574         *mask = '\0';
 575         error = str_to_be64(mask + 1, &om->mask);
 576         if (error) {
 577             return error;
 578         }
 579     } else {
 580         om->mask = OVS_BE64_MAX;
 581     }
 582
 583     return str_to_be64(arg, &om->metadata);
 584 }
 585
 586 /* Parses 'arg' as the argument to a "sample" action, and appends such an
 587  * action to 'ofpacts'.
 588  *
 589  * Returns NULL if successful, otherwise a malloc()'d string describing the
 590  * error.  The caller is responsible for freeing the returned string. */
 591 static char * WARN_UNUSED_RESULT
 592 parse_sample(struct ofpbuf *b, char *arg)
 593 {
 594     struct ofpact_sample *os = ofpact_put_SAMPLE(b);
 595     char *key, *value;
 596
 597     while (ofputil_parse_key_value(&arg, &key, &value)) {
 598         char *error = NULL;
 599
 600         if (!strcmp(key, "probability")) {
 601             error = str_to_u16(value, "probability", &os->probability);
 602             if (!error && os->probability == 0) {
 603                 error = xasprintf("invalid probability value \"%s\"", value);
 604             }
 605         } else if (!strcmp(key, "collector_set_id")) {
 606             error = str_to_u32(value, &os->collector_set_id);
 607         } else if (!strcmp(key, "obs_domain_id")) {
 608             error = str_to_u32(value, &os->obs_domain_id);
 609         } else if (!strcmp(key, "obs_point_id")) {
 610             error = str_to_u32(value, &os->obs_point_id);
 611         } else {
 612             error = xasprintf("invalid key \"%s\" in \"sample\" argument",
 613                               key);
 614         }
 615         if (error) {
 616             return error;
 617         }
 618     }
 619     if (os->probability == 0) {
 620         return xstrdup("non-zero \"probability\" must be specified on sample");
 621     }
 622     return NULL;
 623 }
 624
 625 /* Parses 'arg' as the argument to action 'code', and appends such an action to
 626  * 'ofpacts'.
 627  *
 628  * Returns NULL if successful, otherwise a malloc()'d string describing the
 629  * error.  The caller is responsible for freeing the returned string. */
 630 static char * WARN_UNUSED_RESULT
 631 parse_named_action(enum ofputil_action_code code,
 632                    char *arg, struct ofpbuf *ofpacts,
 633                    enum ofputil_protocol *usable_protocols)
 634 {
 635     size_t orig_size = ofpbuf_size(ofpacts);
 636     struct ofpact_tunnel *tunnel;
 637     struct ofpact_vlan_vid *vlan_vid;
 638     struct ofpact_vlan_pcp *vlan_pcp;
 639     char *error = NULL;
 640     uint16_t ethertype = 0;
 641     uint16_t vid = 0;
 642     uint8_t tos = 0;
 643     uint8_t ecn = 0;
 644     uint8_t ttl = 0;
 645     uint8_t pcp = 0;
 646
 647     switch (code) {
 648     case OFPUTIL_ACTION_INVALID:
 649         OVS_NOT_REACHED();
 650
 651     case OFPUTIL_OFPAT10_OUTPUT:
 652     case OFPUTIL_OFPAT11_OUTPUT:
 653     case OFPUTIL_OFPAT13_OUTPUT:
 654         error = parse_output(arg, ofpacts);
 655         break;
 656
 657     case OFPUTIL_OFPAT10_SET_VLAN_VID:
 658     case OFPUTIL_OFPAT11_SET_VLAN_VID:
 659         error = str_to_u16(arg, "VLAN VID", &vid);
 660         if (error) {
 661             return error;
 662         }
 663
 664         if (vid & ~VLAN_VID_MASK) {
 665             return xasprintf("%s: not a valid VLAN VID", arg);
 666         }
 667         vlan_vid = ofpact_put_SET_VLAN_VID(ofpacts);
 668         vlan_vid->vlan_vid = vid;
 669         vlan_vid->ofpact.compat = code;
 670         vlan_vid->push_vlan_if_needed = code == OFPUTIL_OFPAT10_SET_VLAN_VID;
 671         break;
 672
 673     case OFPUTIL_OFPAT10_SET_VLAN_PCP:
 674     case OFPUTIL_OFPAT11_SET_VLAN_PCP:
 675         error = str_to_u8(arg, "VLAN PCP", &pcp);
 676         if (error) {
 677             return error;
 678         }
 679
 680         if (pcp & ~7) {
 681             return xasprintf("%s: not a valid VLAN PCP", arg);
 682         }
 683         vlan_pcp = ofpact_put_SET_VLAN_PCP(ofpacts);
 684         vlan_pcp->vlan_pcp = pcp;
 685         vlan_pcp->ofpact.compat = code;
 686         vlan_pcp->push_vlan_if_needed = code == OFPUTIL_OFPAT10_SET_VLAN_PCP;
 687         break;
 688
 689     case OFPUTIL_OFPAT12_SET_FIELD:
 690     case OFPUTIL_OFPAT13_SET_FIELD:
 691         return set_field_parse(arg, ofpacts, usable_protocols);
 692
 693     case OFPUTIL_OFPAT10_STRIP_VLAN:
 694     case OFPUTIL_OFPAT11_POP_VLAN:
 695     case OFPUTIL_OFPAT13_POP_VLAN:
 696         ofpact_put_STRIP_VLAN(ofpacts)->ofpact.compat = code;
 697         break;
 698
 699     case OFPUTIL_OFPAT11_PUSH_VLAN:
 700     case OFPUTIL_OFPAT13_PUSH_VLAN:
 701         *usable_protocols &= OFPUTIL_P_OF11_UP;
 702         error = str_to_u16(arg, "ethertype", &ethertype);
 703         if (error) {
 704             return error;
 705         }
 706
 707         if (ethertype != ETH_TYPE_VLAN_8021Q) {
 708             /* XXX ETH_TYPE_VLAN_8021AD case isn't supported */
 709             return xasprintf("%s: not a valid VLAN ethertype", arg);
 710         }
 711
 712         ofpact_put_PUSH_VLAN(ofpacts);
 713         break;
 714
 715     case OFPUTIL_OFPAT11_SET_QUEUE:
 716     case OFPUTIL_OFPAT13_SET_QUEUE:
 717         error = str_to_u32(arg, &ofpact_put_SET_QUEUE(ofpacts)->queue_id);
 718         break;
 719
 720     case OFPUTIL_OFPAT10_SET_DL_SRC:
 721     case OFPUTIL_OFPAT11_SET_DL_SRC:
 722         error = str_to_mac(arg, ofpact_put_SET_ETH_SRC(ofpacts)->mac);
 723         break;
 724
 725     case OFPUTIL_OFPAT10_SET_DL_DST:
 726     case OFPUTIL_OFPAT11_SET_DL_DST:
 727         error = str_to_mac(arg, ofpact_put_SET_ETH_DST(ofpacts)->mac);
 728         break;
 729
 730     case OFPUTIL_OFPAT10_SET_NW_SRC:
 731     case OFPUTIL_OFPAT11_SET_NW_SRC:
 732         error = str_to_ip(arg, &ofpact_put_SET_IPV4_SRC(ofpacts)->ipv4);
 733         break;
 734
 735     case OFPUTIL_OFPAT10_SET_NW_DST:
 736     case OFPUTIL_OFPAT11_SET_NW_DST:
 737         error = str_to_ip(arg, &ofpact_put_SET_IPV4_DST(ofpacts)->ipv4);
 738         break;
 739
 740     case OFPUTIL_OFPAT10_SET_NW_TOS:
 741     case OFPUTIL_OFPAT11_SET_NW_TOS:
 742         error = str_to_u8(arg, "TOS", &tos);
 743         if (error) {
 744             return error;
 745         }
 746
 747         if (tos & ~IP_DSCP_MASK) {
 748             return xasprintf("%s: not a valid TOS", arg);
 749         }
 750         ofpact_put_SET_IP_DSCP(ofpacts)->dscp = tos;
 751         break;
 752
 753     case OFPUTIL_OFPAT11_SET_NW_ECN:
 754         error = str_to_u8(arg, "ECN", &ecn);
 755         if (error) {
 756             return error;
 757         }
 758
 759         if (ecn & ~IP_ECN_MASK) {
 760             return xasprintf("%s: not a valid ECN", arg);
 761         }
 762         ofpact_put_SET_IP_ECN(ofpacts)->ecn = ecn;
 763         break;
 764
 765     case OFPUTIL_OFPAT11_SET_NW_TTL:
 766     case OFPUTIL_OFPAT13_SET_NW_TTL:
 767         error = str_to_u8(arg, "TTL", &ttl);
 768         if (error) {
 769             return error;
 770         }
 771
 772         ofpact_put_SET_IP_TTL(ofpacts)->ttl = ttl;
 773         break;
 774
 775     case OFPUTIL_OFPAT11_DEC_NW_TTL:
 776     case OFPUTIL_OFPAT13_DEC_NW_TTL:
 777         OVS_NOT_REACHED();
 778
 779     case OFPUTIL_OFPAT10_SET_TP_SRC:
 780     case OFPUTIL_OFPAT11_SET_TP_SRC:
 781         error = str_to_u16(arg, "source port",
 782                            &ofpact_put_SET_L4_SRC_PORT(ofpacts)->port);
 783         break;
 784
 785     case OFPUTIL_OFPAT10_SET_TP_DST:
 786     case OFPUTIL_OFPAT11_SET_TP_DST:
 787         error = str_to_u16(arg, "destination port",
 788                            &ofpact_put_SET_L4_DST_PORT(ofpacts)->port);
 789         break;
 790
 791     case OFPUTIL_OFPAT10_ENQUEUE:
 792         error = parse_enqueue(arg, ofpacts);
 793         break;
 794
 795     case OFPUTIL_NXAST_RESUBMIT:
 796         error = parse_resubmit(arg, ofpacts);
 797         break;
 798
 799     case OFPUTIL_NXAST_SET_TUNNEL:
 800     case OFPUTIL_NXAST_SET_TUNNEL64:
 801         tunnel = ofpact_put_SET_TUNNEL(ofpacts);
 802         tunnel->ofpact.compat = code;
 803         error = str_to_u64(arg, &tunnel->tun_id);
 804         break;
 805
 806     case OFPUTIL_NXAST_WRITE_METADATA:
 807         error = parse_metadata(ofpacts, arg);
 808         break;
 809
 810     case OFPUTIL_NXAST_SET_QUEUE:
 811         error = str_to_u32(arg, &ofpact_put_SET_QUEUE(ofpacts)->queue_id);
 812         break;
 813
 814     case OFPUTIL_NXAST_POP_QUEUE:
 815         ofpact_put_POP_QUEUE(ofpacts);
 816         break;
 817
 818     case OFPUTIL_NXAST_REG_MOVE:
 819         error = nxm_parse_reg_move(ofpact_put_REG_MOVE(ofpacts), arg);
 820         break;
 821
 822     case OFPUTIL_NXAST_REG_LOAD:
 823         error = nxm_parse_reg_load(ofpact_put_REG_LOAD(ofpacts), arg);
 824         break;
 825
 826     case OFPUTIL_NXAST_NOTE:
 827         error = parse_note(arg, ofpacts);
 828         break;
 829
 830     case OFPUTIL_NXAST_MULTIPATH:
 831         error = multipath_parse(ofpact_put_MULTIPATH(ofpacts), arg);
 832         break;
 833
 834     case OFPUTIL_NXAST_BUNDLE:
 835         error = bundle_parse(arg, ofpacts);
 836         break;
 837
 838     case OFPUTIL_NXAST_BUNDLE_LOAD:
 839         error = bundle_parse_load(arg, ofpacts);
 840         break;
 841
 842     case OFPUTIL_NXAST_RESUBMIT_TABLE:
 843     case OFPUTIL_NXAST_OUTPUT_REG:
 844     case OFPUTIL_NXAST_DEC_TTL_CNT_IDS:
 845         OVS_NOT_REACHED();
 846
 847     case OFPUTIL_NXAST_LEARN:
 848         error = learn_parse(arg, ofpacts);
 849         break;
 850
 851     case OFPUTIL_NXAST_EXIT:
 852         ofpact_put_EXIT(ofpacts);
 853         break;
 854
 855     case OFPUTIL_NXAST_DEC_TTL:
 856         error = parse_dec_ttl(ofpacts, arg);
 857         break;
 858
 859     case OFPUTIL_NXAST_SET_MPLS_LABEL:
 860     case OFPUTIL_OFPAT11_SET_MPLS_LABEL:
 861         error = parse_set_mpls_label(ofpacts, arg);
 862         break;
 863
 864     case OFPUTIL_NXAST_SET_MPLS_TC:
 865     case OFPUTIL_OFPAT11_SET_MPLS_TC:
 866         error = parse_set_mpls_tc(ofpacts, arg);
 867         break;
 868
 869     case OFPUTIL_NXAST_SET_MPLS_TTL:
 870     case OFPUTIL_OFPAT11_SET_MPLS_TTL:
 871     case OFPUTIL_OFPAT13_SET_MPLS_TTL:
 872         error = parse_set_mpls_ttl(ofpacts, arg);
 873         break;
 874
 875     case OFPUTIL_OFPAT11_DEC_MPLS_TTL:
 876     case OFPUTIL_OFPAT13_DEC_MPLS_TTL:
 877     case OFPUTIL_NXAST_DEC_MPLS_TTL:
 878         ofpact_put_DEC_MPLS_TTL(ofpacts);
 879         break;
 880
 881     case OFPUTIL_NXAST_FIN_TIMEOUT:
 882         error = parse_fin_timeout(ofpacts, arg);
 883         break;
 884
 885     case OFPUTIL_NXAST_CONTROLLER:
 886         error = parse_controller(ofpacts, arg);
 887         break;
 888
 889     case OFPUTIL_OFPAT11_PUSH_MPLS:
 890     case OFPUTIL_OFPAT13_PUSH_MPLS:
 891     case OFPUTIL_NXAST_PUSH_MPLS:
 892         error = str_to_u16(arg, "push_mpls", &ethertype);
 893         if (!error) {
 894             ofpact_put_PUSH_MPLS(ofpacts)->ethertype = htons(ethertype);
 895         }
 896         break;
 897
 898     case OFPUTIL_OFPAT11_POP_MPLS:
 899     case OFPUTIL_OFPAT13_POP_MPLS:
 900     case OFPUTIL_NXAST_POP_MPLS:
 901         error = str_to_u16(arg, "pop_mpls", &ethertype);
 902         if (!error) {
 903             ofpact_put_POP_MPLS(ofpacts)->ethertype = htons(ethertype);
 904         }
 905         break;
 906
 907     case OFPUTIL_OFPAT11_GROUP:
 908     case OFPUTIL_OFPAT13_GROUP:
 909         error = str_to_u32(arg, &ofpact_put_GROUP(ofpacts)->group_id);
 910         break;
 911
 912     /* FIXME when implement OFPAT13_* */
 913     case OFPUTIL_OFPAT13_COPY_TTL_OUT:
 914     case OFPUTIL_OFPAT13_COPY_TTL_IN:
 915     case OFPUTIL_OFPAT13_PUSH_PBB:
 916     case OFPUTIL_OFPAT13_POP_PBB:
 917         OVS_NOT_REACHED();
 918
 919     case OFPUTIL_NXAST_STACK_PUSH:
 920         error = nxm_parse_stack_action(ofpact_put_STACK_PUSH(ofpacts), arg);
 921         break;
 922     case OFPUTIL_NXAST_STACK_POP:
 923         error = nxm_parse_stack_action(ofpact_put_STACK_POP(ofpacts), arg);
 924         break;
 925
 926     case OFPUTIL_NXAST_SAMPLE:
 927         error = parse_sample(ofpacts, arg);
 928         break;
 929     }
 930
 931     if (error) {
 932         ofpbuf_set_size(ofpacts, orig_size);
 933     }
 934     return error;
 935 }
 936
 937 /* Parses action 'act', with argument 'arg', and appends a parsed version to
 938  * 'ofpacts'.
 939  *
 940  * 'n_actions' specifies the number of actions already parsed (for proper
 941  * handling of "drop" actions).
 942  *
 943  * Returns NULL if successful, otherwise a malloc()'d string describing the
 944  * error.  The caller is responsible for freeing the returned string. */
 945 static char * WARN_UNUSED_RESULT
 946 str_to_ofpact__(char *pos, char *act, char *arg,
 947                 struct ofpbuf *ofpacts, int n_actions,
 948                 enum ofputil_protocol *usable_protocols)
 949 {
 950     int code = ofputil_action_code_from_name(act);
 951     if (code >= 0) {
 952         return parse_named_action(code, arg, ofpacts, usable_protocols);
 953     } else if (!strcasecmp(act, "drop")) {
 954         if (n_actions) {
 955             return xstrdup("Drop actions must not be preceded by other "
 956                            "actions");
 957         } else if (ofputil_parse_key_value(&pos, &act, &arg)) {
 958             return xstrdup("Drop actions must not be followed by other "
 959                            "actions");
 960         }
 961     } else {
 962         ofp_port_t port;
 963         if (ofputil_port_from_string(act, &port)) {
 964             ofpact_put_OUTPUT(ofpacts)->port = port;
 965         } else {
 966             return xasprintf("Unknown action: %s", act);
 967         }
 968     }
 969
 970     return NULL;
 971 }
 972
 973 /* Parses 'str' as a series of actions, and appends them to 'ofpacts'.
 974  *
 975  * Returns NULL if successful, otherwise a malloc()'d string describing the
 976  * error.  The caller is responsible for freeing the returned string. */
 977 static char * WARN_UNUSED_RESULT
 978 str_to_ofpacts__(char *str, struct ofpbuf *ofpacts,
 979                  enum ofputil_protocol *usable_protocols)
 980 {
 981     size_t orig_size = ofpbuf_size(ofpacts);
 982     char *pos, *act, *arg;
 983     int n_actions;
 984
 985     pos = str;
 986     n_actions = 0;
 987     while (ofputil_parse_key_value(&pos, &act, &arg)) {
 988         char *error = str_to_ofpact__(pos, act, arg, ofpacts, n_actions,
 989                                       usable_protocols);
 990         if (error) {
 991             ofpbuf_set_size(ofpacts, orig_size);
 992             return error;
 993         }
 994         n_actions++;
 995     }
 996
 997     ofpact_pad(ofpacts);
 998     return NULL;
 999 }
1000
1001
1002 /* Parses 'str' as a series of actions, and appends them to 'ofpacts'.
1003  *
1004  * Returns NULL if successful, otherwise a malloc()'d string describing the
1005  * error.  The caller is responsible for freeing the returned string. */
1006 static char * WARN_UNUSED_RESULT
1007 str_to_ofpacts(char *str, struct ofpbuf *ofpacts,
1008                enum ofputil_protocol *usable_protocols)
1009 {
1010     size_t orig_size = ofpbuf_size(ofpacts);
1011     char *error_s;
1012     enum ofperr error;
1013
1014     error_s = str_to_ofpacts__(str, ofpacts, usable_protocols);
1015     if (error_s) {
1016         return error_s;
1017     }
1018
1019     error = ofpacts_verify(ofpbuf_data(ofpacts), ofpbuf_size(ofpacts),
1020                            (1u << OVSINST_OFPIT11_APPLY_ACTIONS));
1021     if (error) {
1022         ofpbuf_set_size(ofpacts, orig_size);
1023         return xstrdup("Incorrect action ordering");
1024     }
1025
1026     return NULL;
1027 }
1028
1029 /* Parses 'arg' as the argument to instruction 'type', and appends such an
1030  * instruction to 'ofpacts'.
1031  *
1032  * Returns NULL if successful, otherwise a malloc()'d string describing the
1033  * error.  The caller is responsible for freeing the returned string. */
1034 static char * WARN_UNUSED_RESULT
1035 parse_named_instruction(enum ovs_instruction_type type,
1036                         char *arg, struct ofpbuf *ofpacts,
1037                         enum ofputil_protocol *usable_protocols)
1038 {
1039     char *error_s = NULL;
1040     enum ofperr error;
1041
1042     *usable_protocols &= OFPUTIL_P_OF11_UP;
1043
1044     switch (type) {
1045     case OVSINST_OFPIT11_APPLY_ACTIONS:
1046         OVS_NOT_REACHED();  /* This case is handled by str_to_inst_ofpacts() */
1047         break;
1048
1049     case OVSINST_OFPIT11_WRITE_ACTIONS: {
1050         struct ofpact_nest *on;
1051         size_t ofs;
1052
1053         ofpact_pad(ofpacts);
1054         ofs = ofpbuf_size(ofpacts);
1055         ofpact_put(ofpacts, OFPACT_WRITE_ACTIONS,
1056                    offsetof(struct ofpact_nest, actions));
1057         error_s = str_to_ofpacts__(arg, ofpacts, usable_protocols);
1058
1059         on = ofpbuf_at_assert(ofpacts, ofs, sizeof *on);
1060         on->ofpact.len = ofpbuf_size(ofpacts) - ofs;
1061
1062         if (error_s) {
1063             ofpbuf_set_size(ofpacts, ofs);
1064         }
1065         break;
1066     }
1067
1068     case OVSINST_OFPIT11_CLEAR_ACTIONS:
1069         ofpact_put_CLEAR_ACTIONS(ofpacts);
1070         break;
1071
1072     case OVSINST_OFPIT13_METER:
1073         *usable_protocols &= OFPUTIL_P_OF13_UP;
1074         error_s = str_to_u32(arg, &ofpact_put_METER(ofpacts)->meter_id);
1075         break;
1076
1077     case OVSINST_OFPIT11_WRITE_METADATA:
1078         *usable_protocols &= OFPUTIL_P_NXM_OF11_UP;
1079         error_s = parse_metadata(ofpacts, arg);
1080         break;
1081
1082     case OVSINST_OFPIT11_GOTO_TABLE: {
1083         struct ofpact_goto_table *ogt = ofpact_put_GOTO_TABLE(ofpacts);
1084         char *table_s = strsep(&arg, ",");
1085         if (!table_s || !table_s[0]) {
1086             return xstrdup("instruction goto-table needs table id");
1087         }
1088         error_s = str_to_u8(table_s, "table", &ogt->table_id);
1089         break;
1090     }
1091     }
1092
1093     if (error_s) {
1094         return error_s;
1095     }
1096
1097     /* If write_metadata is specified as an action AND an instruction, ofpacts
1098        could be invalid. */
1099     error = ofpacts_verify(ofpbuf_data(ofpacts), ofpbuf_size(ofpacts),
1100                            (1u << N_OVS_INSTRUCTIONS) - 1);
1101     if (error) {
1102         return xstrdup("Incorrect instruction ordering");
1103     }
1104     return NULL;
1105 }
1106
1107 /* Parses 'str' as a series of instructions, and appends them to 'ofpacts'.
1108  *
1109  * Returns NULL if successful, otherwise a malloc()'d string describing the
1110  * error.  The caller is responsible for freeing the returned string. */
1111 static char * WARN_UNUSED_RESULT
1112 str_to_inst_ofpacts(char *str, struct ofpbuf *ofpacts,
1113                     enum ofputil_protocol *usable_protocols)
1114 {
1115     size_t orig_size = ofpbuf_size(ofpacts);
1116     char *pos, *inst, *arg;
1117     int type;
1118     const char *prev_inst = NULL;
1119     int prev_type = -1;
1120     int n_actions = 0;
1121
1122     pos = str;
1123     while (ofputil_parse_key_value(&pos, &inst, &arg)) {
1124         type = ovs_instruction_type_from_name(inst);
1125         if (type < 0) {
1126             char *error = str_to_ofpact__(pos, inst, arg, ofpacts, n_actions,
1127                                           usable_protocols);
1128             if (error) {
1129                 ofpbuf_set_size(ofpacts, orig_size);
1130                 return error;
1131             }
1132
1133             type = OVSINST_OFPIT11_APPLY_ACTIONS;
1134             if (prev_type == type) {
1135                 n_actions++;
1136                 continue;
1137             }
1138         } else if (type == OVSINST_OFPIT11_APPLY_ACTIONS) {
1139             ofpbuf_set_size(ofpacts, orig_size);
1140             return xasprintf("%s isn't supported. Just write actions then "
1141                              "it is interpreted as apply_actions", inst);
1142         } else {
1143             char *error = parse_named_instruction(type, arg, ofpacts,
1144                                                   usable_protocols);
1145             if (error) {
1146                 ofpbuf_set_size(ofpacts, orig_size);
1147                 return error;
1148             }
1149         }
1150
1151         if (type <= prev_type) {
1152             ofpbuf_set_size(ofpacts, orig_size);
1153             if (type == prev_type) {
1154                 return xasprintf("instruction %s may be specified only once",
1155                                  inst);
1156             } else {
1157                 return xasprintf("instruction %s must be specified before %s",
1158                                  inst, prev_inst);
1159             }
1160         }
1161
1162         prev_inst = inst;
1163         prev_type = type;
1164         n_actions++;
1165     }
1166     ofpact_pad(ofpacts);
1167
1168     return NULL;
1169 }
1170
1171 struct protocol {
1172     const char *name;
1173     uint16_t dl_type;
1174     uint8_t nw_proto;
1175 };
1176
1177 static bool
1178 parse_protocol(const char *name, const struct protocol **p_out)
1179 {
1180     static const struct protocol protocols[] = {
1181         { "ip", ETH_TYPE_IP, 0 },
1182         { "arp", ETH_TYPE_ARP, 0 },
1183         { "icmp", ETH_TYPE_IP, IPPROTO_ICMP },
1184         { "tcp", ETH_TYPE_IP, IPPROTO_TCP },
1185         { "udp", ETH_TYPE_IP, IPPROTO_UDP },
1186         { "sctp", ETH_TYPE_IP, IPPROTO_SCTP },
1187         { "ipv6", ETH_TYPE_IPV6, 0 },
1188         { "ip6", ETH_TYPE_IPV6, 0 },
1189         { "icmp6", ETH_TYPE_IPV6, IPPROTO_ICMPV6 },
1190         { "tcp6", ETH_TYPE_IPV6, IPPROTO_TCP },
1191         { "udp6", ETH_TYPE_IPV6, IPPROTO_UDP },
1192         { "sctp6", ETH_TYPE_IPV6, IPPROTO_SCTP },
1193         { "rarp", ETH_TYPE_RARP, 0},
1194         { "mpls", ETH_TYPE_MPLS, 0 },
1195         { "mplsm", ETH_TYPE_MPLS_MCAST, 0 },
1196     };
1197     const struct protocol *p;
1198
1199     for (p = protocols; p < &protocols[ARRAY_SIZE(protocols)]; p++) {
1200         if (!strcmp(p->name, name)) {
1201             *p_out = p;
1202             return true;
1203         }
1204     }
1205     *p_out = NULL;
1206     return false;
1207 }
1208
1209 /* Parses 's' as the (possibly masked) value of field 'mf', and updates
1210  * 'match' appropriately.  Restricts the set of usable protocols to ones
1211  * supporting the parsed field.
1212  *
1213  * Returns NULL if successful, otherwise a malloc()'d string describing the
1214  * error.  The caller is responsible for freeing the returned string. */
1215 static char * WARN_UNUSED_RESULT
1216 parse_field(const struct mf_field *mf, const char *s, struct match *match,
1217             enum ofputil_protocol *usable_protocols)
1218 {
1219     union mf_value value, mask;
1220     char *error;
1221
1222     error = mf_parse(mf, s, &value, &mask);
1223     if (!error) {
1224         *usable_protocols &= mf_set(mf, &value, &mask, match);
1225     }
1226     return error;
1227 }
1228
1229 static char * WARN_UNUSED_RESULT
1230 parse_ofp_str__(struct ofputil_flow_mod *fm, int command, char *string,
1231                 enum ofputil_protocol *usable_protocols)
1232 {
1233     enum {
1234         F_OUT_PORT = 1 << 0,
1235         F_ACTIONS = 1 << 1,
1236         F_TIMEOUT = 1 << 3,
1237         F_PRIORITY = 1 << 4,
1238         F_FLAGS = 1 << 5,
1239     } fields;
1240     char *save_ptr = NULL;
1241     char *act_str = NULL;
1242     char *name;
1243
1244     *usable_protocols = OFPUTIL_P_ANY;
1245
1246     switch (command) {
1247     case -1:
1248         fields = F_OUT_PORT;
1249         break;
1250
1251     case OFPFC_ADD:
1252         fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
1253         break;
1254
1255     case OFPFC_DELETE:
1256         fields = F_OUT_PORT;
1257         break;
1258
1259     case OFPFC_DELETE_STRICT:
1260         fields = F_OUT_PORT | F_PRIORITY;
1261         break;
1262
1263     case OFPFC_MODIFY:
1264         fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
1265         break;
1266
1267     case OFPFC_MODIFY_STRICT:
1268         fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
1269         break;
1270
1271     default:
1272         OVS_NOT_REACHED();
1273     }
1274
1275     match_init_catchall(&fm->match);
1276     fm->priority = OFP_DEFAULT_PRIORITY;
1277     fm->cookie = htonll(0);
1278     fm->cookie_mask = htonll(0);
1279     if (command == OFPFC_MODIFY || command == OFPFC_MODIFY_STRICT) {
1280         /* For modify, by default, don't update the cookie. */
1281         fm->new_cookie = OVS_BE64_MAX;
1282     } else{
1283         fm->new_cookie = htonll(0);
1284     }
1285     fm->modify_cookie = false;
1286     fm->table_id = 0xff;
1287     fm->command = command;
1288     fm->idle_timeout = OFP_FLOW_PERMANENT;
1289     fm->hard_timeout = OFP_FLOW_PERMANENT;
1290     fm->buffer_id = UINT32_MAX;
1291     fm->out_port = OFPP_ANY;
1292     fm->flags = 0;
1293     fm->out_group = OFPG11_ANY;
1294     fm->delete_reason = OFPRR_DELETE;
1295     if (fields & F_ACTIONS) {
1296         act_str = strstr(string, "action");
1297         if (!act_str) {
1298             return xstrdup("must specify an action");
1299         }
1300         *act_str = '\0';
1301
1302         act_str = strchr(act_str + 1, '=');
1303         if (!act_str) {
1304             return xstrdup("must specify an action");
1305         }
1306
1307         act_str++;
1308     }
1309     for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
1310          name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
1311         const struct protocol *p;
1312         char *error = NULL;
1313
1314         if (parse_protocol(name, &p)) {
1315             match_set_dl_type(&fm->match, htons(p->dl_type));
1316             if (p->nw_proto) {
1317                 match_set_nw_proto(&fm->match, p->nw_proto);
1318             }
1319         } else if (fields & F_FLAGS && !strcmp(name, "send_flow_rem")) {
1320             fm->flags |= OFPUTIL_FF_SEND_FLOW_REM;
1321         } else if (fields & F_FLAGS && !strcmp(name, "check_overlap")) {
1322             fm->flags |= OFPUTIL_FF_CHECK_OVERLAP;
1323         } else if (fields & F_FLAGS && !strcmp(name, "reset_counts")) {
1324             fm->flags |= OFPUTIL_FF_RESET_COUNTS;
1325             *usable_protocols &= OFPUTIL_P_OF12_UP;
1326         } else if (fields & F_FLAGS && !strcmp(name, "no_packet_counts")) {
1327             fm->flags |= OFPUTIL_FF_NO_PKT_COUNTS;
1328             *usable_protocols &= OFPUTIL_P_OF13_UP;
1329         } else if (fields & F_FLAGS && !strcmp(name, "no_byte_counts")) {
1330             fm->flags |= OFPUTIL_FF_NO_BYT_COUNTS;
1331             *usable_protocols &= OFPUTIL_P_OF13_UP;
1332         } else if (!strcmp(name, "no_readonly_table")
1333                    || !strcmp(name, "allow_hidden_fields")) {
1334              /* ignore these fields. */
1335         } else {
1336             char *value;
1337
1338             value = strtok_r(NULL, ", \t\r\n", &save_ptr);
1339             if (!value) {
1340                 return xasprintf("field %s missing value", name);
1341             }
1342
1343             if (!strcmp(name, "table")) {
1344                 error = str_to_u8(value, "table", &fm->table_id);
1345                 if (fm->table_id != 0xff) {
1346                     *usable_protocols &= OFPUTIL_P_TID;
1347                 }
1348             } else if (!strcmp(name, "out_port")) {
1349                 if (!ofputil_port_from_string(value, &fm->out_port)) {
1350                     error = xasprintf("%s is not a valid OpenFlow port",
1351                                       value);
1352                 }
1353             } else if (fields & F_PRIORITY && !strcmp(name, "priority")) {
1354                 uint16_t priority = 0;
1355
1356                 error = str_to_u16(value, name, &priority);
1357                 fm->priority = priority;
1358             } else if (fields & F_TIMEOUT && !strcmp(name, "idle_timeout")) {
1359                 error = str_to_u16(value, name, &fm->idle_timeout);
1360             } else if (fields & F_TIMEOUT && !strcmp(name, "hard_timeout")) {
1361                 error = str_to_u16(value, name, &fm->hard_timeout);
1362             } else if (!strcmp(name, "cookie")) {
1363                 char *mask = strchr(value, '/');
1364
1365                 if (mask) {
1366                     /* A mask means we're searching for a cookie. */
1367                     if (command == OFPFC_ADD) {
1368                         return xstrdup("flow additions cannot use "
1369                                        "a cookie mask");
1370                     }
1371                     *mask = '\0';
1372                     error = str_to_be64(value, &fm->cookie);
1373                     if (error) {
1374                         return error;
1375                     }
1376                     error = str_to_be64(mask + 1, &fm->cookie_mask);
1377
1378                     /* Matching of the cookie is only supported through NXM or
1379                      * OF1.1+. */
1380                     if (fm->cookie_mask != htonll(0)) {
1381                         *usable_protocols &= OFPUTIL_P_NXM_OF11_UP;
1382                     }
1383                 } else {
1384                     /* No mask means that the cookie is being set. */
1385                     if (command != OFPFC_ADD && command != OFPFC_MODIFY
1386                         && command != OFPFC_MODIFY_STRICT) {
1387                         return xstrdup("cannot set cookie");
1388                     }
1389                     error = str_to_be64(value, &fm->new_cookie);
1390                     fm->modify_cookie = true;
1391                 }
1392             } else if (mf_from_name(name)) {
1393                 error = parse_field(mf_from_name(name), value, &fm->match,
1394                                     usable_protocols);
1395             } else if (!strcmp(name, "duration")
1396                        || !strcmp(name, "n_packets")
1397                        || !strcmp(name, "n_bytes")
1398                        || !strcmp(name, "idle_age")
1399                        || !strcmp(name, "hard_age")) {
1400                 /* Ignore these, so that users can feed the output of
1401                  * "ovs-ofctl dump-flows" back into commands that parse
1402                  * flows. */
1403             } else {
1404                 error = xasprintf("unknown keyword %s", name);
1405             }
1406
1407             if (error) {
1408                 return error;
1409             }
1410         }
1411     }
1412     /* Check for usable protocol interdependencies between match fields. */
1413     if (fm->match.flow.dl_type == htons(ETH_TYPE_IPV6)) {
1414         const struct flow_wildcards *wc = &fm->match.wc;
1415         /* Only NXM and OXM support matching L3 and L4 fields within IPv6.
1416          *
1417          * (IPv6 specific fields as well as arp_sha, arp_tha, nw_frag, and
1418          *  nw_ttl are covered elsewhere so they don't need to be included in
1419          *  this test too.)
1420          */
1421         if (wc->masks.nw_proto || wc->masks.nw_tos
1422             || wc->masks.tp_src || wc->masks.tp_dst) {
1423             *usable_protocols &= OFPUTIL_P_NXM_OXM_ANY;
1424         }
1425     }
1426     if (!fm->cookie_mask && fm->new_cookie == OVS_BE64_MAX
1427         && (command == OFPFC_MODIFY || command == OFPFC_MODIFY_STRICT)) {
1428         /* On modifies without a mask, we are supposed to add a flow if
1429          * one does not exist.  If a cookie wasn't been specified, use a
1430          * default of zero. */
1431         fm->new_cookie = htonll(0);
1432     }
1433     if (fields & F_ACTIONS) {
1434         struct ofpbuf ofpacts;
1435         char *error;
1436
1437         ofpbuf_init(&ofpacts, 32);
1438         error = str_to_inst_ofpacts(act_str, &ofpacts, usable_protocols);
1439         if (!error) {
1440             enum ofperr err;
1441
1442             err = ofpacts_check(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), &fm->match.flow,
1443                                 OFPP_MAX, fm->table_id, 255, usable_protocols);
1444             if (!err && !usable_protocols) {
1445                 err = OFPERR_OFPBAC_MATCH_INCONSISTENT;
1446             }
1447             if (err) {
1448                 error = xasprintf("actions are invalid with specified match "
1449                                   "(%s)", ofperr_to_string(err));
1450             }
1451
1452         }
1453         if (error) {
1454             ofpbuf_uninit(&ofpacts);
1455             return error;
1456         }
1457
1458         fm->ofpacts_len = ofpbuf_size(&ofpacts);
1459         fm->ofpacts = ofpbuf_steal_data(&ofpacts);
1460     } else {
1461         fm->ofpacts_len = 0;
1462         fm->ofpacts = NULL;
1463     }
1464
1465     return NULL;
1466 }
1467
1468 /* Convert 'str_' (as described in the Flow Syntax section of the ovs-ofctl man
1469  * page) into 'fm' for sending the specified flow_mod 'command' to a switch.
1470  * Returns the set of usable protocols in '*usable_protocols'.
1471  *
1472  * To parse syntax for an OFPT_FLOW_MOD (or NXT_FLOW_MOD), use an OFPFC_*
1473  * constant for 'command'.  To parse syntax for an OFPST_FLOW or
1474  * OFPST_AGGREGATE (or NXST_FLOW or NXST_AGGREGATE), use -1 for 'command'.
1475  *
1476  * Returns NULL if successful, otherwise a malloc()'d string describing the
1477  * error.  The caller is responsible for freeing the returned string. */
1478 char * WARN_UNUSED_RESULT
1479 parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
1480               enum ofputil_protocol *usable_protocols)
1481 {
1482     char *string = xstrdup(str_);
1483     char *error;
1484
1485     error = parse_ofp_str__(fm, command, string, usable_protocols);
1486     if (error) {
1487         fm->ofpacts = NULL;
1488         fm->ofpacts_len = 0;
1489     }
1490
1491     free(string);
1492     return error;
1493 }
1494
1495 static char * WARN_UNUSED_RESULT
1496 parse_ofp_meter_mod_str__(struct ofputil_meter_mod *mm, char *string,
1497                           struct ofpbuf *bands, int command,
1498                           enum ofputil_protocol *usable_protocols)
1499 {
1500     enum {
1501         F_METER = 1 << 0,
1502         F_FLAGS = 1 << 1,
1503         F_BANDS = 1 << 2,
1504     } fields;
1505     char *save_ptr = NULL;
1506     char *band_str = NULL;
1507     char *name;
1508
1509     /* Meters require at least OF 1.3. */
1510     *usable_protocols = OFPUTIL_P_OF13_UP;
1511
1512     switch (command) {
1513     case -1:
1514         fields = F_METER;
1515         break;
1516
1517     case OFPMC13_ADD:
1518         fields = F_METER | F_FLAGS | F_BANDS;
1519         break;
1520
1521     case OFPMC13_DELETE:
1522         fields = F_METER;
1523         break;
1524
1525     case OFPMC13_MODIFY:
1526         fields = F_METER | F_FLAGS | F_BANDS;
1527         break;
1528
1529     default:
1530         OVS_NOT_REACHED();
1531     }
1532
1533     mm->command = command;
1534     mm->meter.meter_id = 0;
1535     mm->meter.flags = 0;
1536     if (fields & F_BANDS) {
1537         band_str = strstr(string, "band");
1538         if (!band_str) {
1539             return xstrdup("must specify bands");
1540         }
1541         *band_str = '\0';
1542
1543         band_str = strchr(band_str + 1, '=');
1544         if (!band_str) {
1545             return xstrdup("must specify bands");
1546         }
1547
1548         band_str++;
1549     }
1550     for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
1551          name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
1552
1553         if (fields & F_FLAGS && !strcmp(name, "kbps")) {
1554             mm->meter.flags |= OFPMF13_KBPS;
1555         } else if (fields & F_FLAGS && !strcmp(name, "pktps")) {
1556             mm->meter.flags |= OFPMF13_PKTPS;
1557         } else if (fields & F_FLAGS && !strcmp(name, "burst")) {
1558             mm->meter.flags |= OFPMF13_BURST;
1559         } else if (fields & F_FLAGS && !strcmp(name, "stats")) {
1560             mm->meter.flags |= OFPMF13_STATS;
1561         } else {
1562             char *value;
1563
1564             value = strtok_r(NULL, ", \t\r\n", &save_ptr);
1565             if (!value) {
1566                 return xasprintf("field %s missing value", name);
1567             }
1568
1569             if (!strcmp(name, "meter")) {
1570                 if (!strcmp(value, "all")) {
1571                     mm->meter.meter_id = OFPM13_ALL;
1572                 } else if (!strcmp(value, "controller")) {
1573                     mm->meter.meter_id = OFPM13_CONTROLLER;
1574                 } else if (!strcmp(value, "slowpath")) {
1575                     mm->meter.meter_id = OFPM13_SLOWPATH;
1576                 } else {
1577                     char *error = str_to_u32(value, &mm->meter.meter_id);
1578                     if (error) {
1579                         return error;
1580                     }
1581                     if (mm->meter.meter_id > OFPM13_MAX) {
1582                         return xasprintf("invalid value for %s", name);
1583                     }
1584                 }
1585             } else {
1586                 return xasprintf("unknown keyword %s", name);
1587             }
1588         }
1589     }
1590     if (fields & F_METER && !mm->meter.meter_id) {
1591         return xstrdup("must specify 'meter'");
1592     }
1593     if (fields & F_FLAGS && !mm->meter.flags) {
1594         return xstrdup("meter must specify either 'kbps' or 'pktps'");
1595     }
1596
1597     if (fields & F_BANDS) {
1598         uint16_t n_bands = 0;
1599         struct ofputil_meter_band *band = NULL;
1600         int i;
1601
1602         for (name = strtok_r(band_str, "=, \t\r\n", &save_ptr); name;
1603              name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
1604
1605             char *value;
1606
1607             value = strtok_r(NULL, ", \t\r\n", &save_ptr);
1608             if (!value) {
1609                 return xasprintf("field %s missing value", name);
1610             }
1611
1612             if (!strcmp(name, "type")) {
1613                 /* Start a new band */
1614                 band = ofpbuf_put_zeros(bands, sizeof *band);
1615                 n_bands++;
1616
1617                 if (!strcmp(value, "drop")) {
1618                     band->type = OFPMBT13_DROP;
1619                 } else if (!strcmp(value, "dscp_remark")) {
1620                     band->type = OFPMBT13_DSCP_REMARK;
1621                 } else {
1622                     return xasprintf("field %s unknown value %s", name, value);
1623                 }
1624             } else if (!band || !band->type) {
1625                 return xstrdup("band must start with the 'type' keyword");
1626             } else if (!strcmp(name, "rate")) {
1627                 char *error = str_to_u32(value, &band->rate);
1628                 if (error) {
1629                     return error;
1630                 }
1631             } else if (!strcmp(name, "burst_size")) {
1632                 char *error = str_to_u32(value, &band->burst_size);
1633                 if (error) {
1634                     return error;
1635                 }
1636             } else if (!strcmp(name, "prec_level")) {
1637                 char *error = str_to_u8(value, name, &band->prec_level);
1638                 if (error) {
1639                     return error;
1640                 }
1641             } else {
1642                 return xasprintf("unknown keyword %s", name);
1643             }
1644         }
1645         /* validate bands */
1646         if (!n_bands) {
1647             return xstrdup("meter must have bands");
1648         }
1649
1650         mm->meter.n_bands = n_bands;
1651         mm->meter.bands = ofpbuf_steal_data(bands);
1652
1653         for (i = 0; i < n_bands; ++i) {
1654             band = &mm->meter.bands[i];
1655
1656             if (!band->type) {
1657                 return xstrdup("band must have 'type'");
1658             }
1659             if (band->type == OFPMBT13_DSCP_REMARK) {
1660                 if (!band->prec_level) {
1661                     return xstrdup("'dscp_remark' band must have"
1662                                    " 'prec_level'");
1663                 }
1664             } else {
1665                 if (band->prec_level) {
1666                     return xstrdup("Only 'dscp_remark' band may have"
1667                                    " 'prec_level'");
1668                 }
1669             }
1670             if (!band->rate) {
1671                 return xstrdup("band must have 'rate'");
1672             }
1673             if (mm->meter.flags & OFPMF13_BURST) {
1674                 if (!band->burst_size) {
1675                     return xstrdup("band must have 'burst_size' "
1676                                    "when 'burst' flag is set");
1677                 }
1678             } else {
1679                 if (band->burst_size) {
1680                     return xstrdup("band may have 'burst_size' only "
1681                                    "when 'burst' flag is set");
1682                 }
1683             }
1684         }
1685     } else {
1686         mm->meter.n_bands = 0;
1687         mm->meter.bands = NULL;
1688     }
1689
1690     return NULL;
1691 }
1692
1693 /* Convert 'str_' (as described in the Flow Syntax section of the ovs-ofctl man
1694  * page) into 'mm' for sending the specified meter_mod 'command' to a switch.
1695  *
1696  * Returns NULL if successful, otherwise a malloc()'d string describing the
1697  * error.  The caller is responsible for freeing the returned string. */
1698 char * WARN_UNUSED_RESULT
1699 parse_ofp_meter_mod_str(struct ofputil_meter_mod *mm, const char *str_,
1700                         int command, enum ofputil_protocol *usable_protocols)
1701 {
1702     struct ofpbuf bands;
1703     char *string;
1704     char *error;
1705
1706     ofpbuf_init(&bands, 64);
1707     string = xstrdup(str_);
1708
1709     error = parse_ofp_meter_mod_str__(mm, string, &bands, command,
1710                                       usable_protocols);
1711
1712     free(string);
1713     ofpbuf_uninit(&bands);
1714
1715     return error;
1716 }
1717
1718 static char * WARN_UNUSED_RESULT
1719 parse_flow_monitor_request__(struct ofputil_flow_monitor_request *fmr,
1720                              const char *str_, char *string,
1721                              enum ofputil_protocol *usable_protocols)
1722 {
1723     static atomic_uint32_t id = ATOMIC_VAR_INIT(0);
1724     char *save_ptr = NULL;
1725     char *name;
1726
1727     atomic_add(&id, 1, &fmr->id);
1728
1729     fmr->flags = (NXFMF_INITIAL | NXFMF_ADD | NXFMF_DELETE | NXFMF_MODIFY
1730                   | NXFMF_OWN | NXFMF_ACTIONS);
1731     fmr->out_port = OFPP_NONE;
1732     fmr->table_id = 0xff;
1733     match_init_catchall(&fmr->match);
1734
1735     for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
1736          name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
1737         const struct protocol *p;
1738
1739         if (!strcmp(name, "!initial")) {
1740             fmr->flags &= ~NXFMF_INITIAL;
1741         } else if (!strcmp(name, "!add")) {
1742             fmr->flags &= ~NXFMF_ADD;
1743         } else if (!strcmp(name, "!delete")) {
1744             fmr->flags &= ~NXFMF_DELETE;
1745         } else if (!strcmp(name, "!modify")) {
1746             fmr->flags &= ~NXFMF_MODIFY;
1747         } else if (!strcmp(name, "!actions")) {
1748             fmr->flags &= ~NXFMF_ACTIONS;
1749         } else if (!strcmp(name, "!own")) {
1750             fmr->flags &= ~NXFMF_OWN;
1751         } else if (parse_protocol(name, &p)) {
1752             match_set_dl_type(&fmr->match, htons(p->dl_type));
1753             if (p->nw_proto) {
1754                 match_set_nw_proto(&fmr->match, p->nw_proto);
1755             }
1756         } else {
1757             char *value;
1758
1759             value = strtok_r(NULL, ", \t\r\n", &save_ptr);
1760             if (!value) {
1761                 return xasprintf("%s: field %s missing value", str_, name);
1762             }
1763
1764             if (!strcmp(name, "table")) {
1765                 char *error = str_to_u8(value, "table", &fmr->table_id);
1766                 if (error) {
1767                     return error;
1768                 }
1769             } else if (!strcmp(name, "out_port")) {
1770                 fmr->out_port = u16_to_ofp(atoi(value));
1771             } else if (mf_from_name(name)) {
1772                 char *error;
1773
1774                 error = parse_field(mf_from_name(name), value, &fmr->match,
1775                                     usable_protocols);
1776                 if (error) {
1777                     return error;
1778                 }
1779             } else {
1780                 return xasprintf("%s: unknown keyword %s", str_, name);
1781             }
1782         }
1783     }
1784     return NULL;
1785 }
1786
1787 /* Convert 'str_' (as described in the documentation for the "monitor" command
1788  * in the ovs-ofctl man page) into 'fmr'.
1789  *
1790  * Returns NULL if successful, otherwise a malloc()'d string describing the
1791  * error.  The caller is responsible for freeing the returned string. */
1792 char * WARN_UNUSED_RESULT
1793 parse_flow_monitor_request(struct ofputil_flow_monitor_request *fmr,
1794                            const char *str_,
1795                            enum ofputil_protocol *usable_protocols)
1796 {
1797     char *string = xstrdup(str_);
1798     char *error = parse_flow_monitor_request__(fmr, str_, string,
1799                                                usable_protocols);
1800     free(string);
1801     return error;
1802 }
1803
1804 /* Parses 's' as a set of OpenFlow actions and appends the actions to
1805  * 'actions'.
1806  *
1807  * Returns NULL if successful, otherwise a malloc()'d string describing the
1808  * error.  The caller is responsible for freeing the returned string. */
1809 char * WARN_UNUSED_RESULT
1810 parse_ofpacts(const char *s_, struct ofpbuf *ofpacts,
1811               enum ofputil_protocol *usable_protocols)
1812 {
1813     char *s = xstrdup(s_);
1814     char *error;
1815
1816     *usable_protocols = OFPUTIL_P_ANY;
1817
1818     error = str_to_ofpacts(s, ofpacts, usable_protocols);
1819     free(s);
1820
1821     return error;
1822 }
1823
1824 /* Parses 'string' as an OFPT_FLOW_MOD or NXT_FLOW_MOD with command 'command'
1825  * (one of OFPFC_*) into 'fm'.
1826  *
1827  * Returns NULL if successful, otherwise a malloc()'d string describing the
1828  * error.  The caller is responsible for freeing the returned string. */
1829 char * WARN_UNUSED_RESULT
1830 parse_ofp_flow_mod_str(struct ofputil_flow_mod *fm, const char *string,
1831                        uint16_t command,
1832                        enum ofputil_protocol *usable_protocols)
1833 {
1834     char *error = parse_ofp_str(fm, command, string, usable_protocols);
1835     if (!error) {
1836         /* Normalize a copy of the match.  This ensures that non-normalized
1837          * flows get logged but doesn't affect what gets sent to the switch, so
1838          * that the switch can do whatever it likes with the flow. */
1839         struct match match_copy = fm->match;
1840         ofputil_normalize_match(&match_copy);
1841     }
1842
1843     return error;
1844 }
1845
1846 /* Convert 'table_id' and 'flow_miss_handling' (as described for the
1847  * "mod-table" command in the ovs-ofctl man page) into 'tm' for sending the
1848  * specified table_mod 'command' to a switch.
1849  *
1850  * Returns NULL if successful, otherwise a malloc()'d string describing the
1851  * error.  The caller is responsible for freeing the returned string. */
1852 char * WARN_UNUSED_RESULT
1853 parse_ofp_table_mod(struct ofputil_table_mod *tm, const char *table_id,
1854                     const char *flow_miss_handling,
1855                     enum ofputil_protocol *usable_protocols)
1856 {
1857     /* Table mod requires at least OF 1.1. */
1858     *usable_protocols = OFPUTIL_P_OF11_UP;
1859
1860     if (!strcasecmp(table_id, "all")) {
1861         tm->table_id = OFPTT_ALL;
1862     } else {
1863         char *error = str_to_u8(table_id, "table_id", &tm->table_id);
1864         if (error) {
1865             return error;
1866         }
1867     }
1868
1869     if (strcmp(flow_miss_handling, "controller") == 0) {
1870         tm->miss_config = OFPUTIL_TABLE_MISS_CONTROLLER;
1871     } else if (strcmp(flow_miss_handling, "continue") == 0) {
1872         tm->miss_config = OFPUTIL_TABLE_MISS_CONTINUE;
1873     } else if (strcmp(flow_miss_handling, "drop") == 0) {
1874         tm->miss_config = OFPUTIL_TABLE_MISS_DROP;
1875     } else {
1876         return xasprintf("invalid flow_miss_handling %s", flow_miss_handling);
1877     }
1878
1879     if (tm->table_id == 0xfe
1880         && tm->miss_config == OFPUTIL_TABLE_MISS_CONTINUE) {
1881         return xstrdup("last table's flow miss handling can not be continue");
1882     }
1883
1884     return NULL;
1885 }
1886
1887
1888 /* Opens file 'file_name' and reads each line as a flow_mod of the specified
1889  * type (one of OFPFC_*).  Stores each flow_mod in '*fm', an array allocated
1890  * on the caller's behalf, and the number of flow_mods in '*n_fms'.
1891  *
1892  * Returns NULL if successful, otherwise a malloc()'d string describing the
1893  * error.  The caller is responsible for freeing the returned string. */
1894 char * WARN_UNUSED_RESULT
1895 parse_ofp_flow_mod_file(const char *file_name, uint16_t command,
1896                         struct ofputil_flow_mod **fms, size_t *n_fms,
1897                         enum ofputil_protocol *usable_protocols)
1898 {
1899     size_t allocated_fms;
1900     int line_number;
1901     FILE *stream;
1902     struct ds s;
1903
1904     *usable_protocols = OFPUTIL_P_ANY;
1905
1906     *fms = NULL;
1907     *n_fms = 0;
1908
1909     stream = !strcmp(file_name, "-") ? stdin : fopen(file_name, "r");
1910     if (stream == NULL) {
1911         return xasprintf("%s: open failed (%s)",
1912                          file_name, ovs_strerror(errno));
1913     }
1914
1915     allocated_fms = *n_fms;
1916     ds_init(&s);
1917     line_number = 0;
1918     while (!ds_get_preprocessed_line(&s, stream, &line_number)) {
1919         char *error;
1920         enum ofputil_protocol usable;
1921
1922         if (*n_fms >= allocated_fms) {
1923             *fms = x2nrealloc(*fms, &allocated_fms, sizeof **fms);
1924         }
1925         error = parse_ofp_flow_mod_str(&(*fms)[*n_fms], ds_cstr(&s), command,
1926                                        &usable);
1927         if (error) {
1928             size_t i;
1929
1930             for (i = 0; i < *n_fms; i++) {
1931                 free(CONST_CAST(struct ofpact *, (*fms)[i].ofpacts));
1932             }
1933             free(*fms);
1934             *fms = NULL;
1935             *n_fms = 0;
1936
1937             ds_destroy(&s);
1938             if (stream != stdin) {
1939                 fclose(stream);
1940             }
1941
1942             return xasprintf("%s:%d: %s", file_name, line_number, error);
1943         }
1944         *usable_protocols &= usable; /* Each line can narrow the set. */
1945         *n_fms += 1;
1946     }
1947
1948     ds_destroy(&s);
1949     if (stream != stdin) {
1950         fclose(stream);
1951     }
1952     return NULL;
1953 }
1954
1955 char * WARN_UNUSED_RESULT
1956 parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request *fsr,
1957                                  bool aggregate, const char *string,
1958                                  enum ofputil_protocol *usable_protocols)
1959 {
1960     struct ofputil_flow_mod fm;
1961     char *error;
1962
1963     error = parse_ofp_str(&fm, -1, string, usable_protocols);
1964     if (error) {
1965         return error;
1966     }
1967
1968     /* Special table ID support not required for stats requests. */
1969     if (*usable_protocols & OFPUTIL_P_OF10_STD_TID) {
1970         *usable_protocols |= OFPUTIL_P_OF10_STD;
1971     }
1972     if (*usable_protocols & OFPUTIL_P_OF10_NXM_TID) {
1973         *usable_protocols |= OFPUTIL_P_OF10_NXM;
1974     }
1975
1976     fsr->aggregate = aggregate;
1977     fsr->cookie = fm.cookie;
1978     fsr->cookie_mask = fm.cookie_mask;
1979     fsr->match = fm.match;
1980     fsr->out_port = fm.out_port;
1981     fsr->out_group = fm.out_group;
1982     fsr->table_id = fm.table_id;
1983     return NULL;
1984 }
1985
1986 /* Parses a specification of a flow from 's' into 'flow'.  's' must take the
1987  * form FIELD=VALUE[,FIELD=VALUE]... where each FIELD is the name of a
1988  * mf_field.  Fields must be specified in a natural order for satisfying
1989  * prerequisites. If 'mask' is specified, fills the mask field for each of the
1990  * field specified in flow. If the map, 'names_portno' is specfied, converts
1991  * the in_port name into port no while setting the 'flow'.
1992  *
1993  * Returns NULL on success, otherwise a malloc()'d string that explains the
1994  * problem. */
1995 char *
1996 parse_ofp_exact_flow(struct flow *flow, struct flow *mask, const char *s,
1997                      const struct simap *portno_names)
1998 {
1999     char *pos, *key, *value_s;
2000     char *error = NULL;
2001     char *copy;
2002
2003     memset(flow, 0, sizeof *flow);
2004     if (mask) {
2005         memset(mask, 0, sizeof *mask);
2006     }
2007
2008     pos = copy = xstrdup(s);
2009     while (ofputil_parse_key_value(&pos, &key, &value_s)) {
2010         const struct protocol *p;
2011         if (parse_protocol(key, &p)) {
2012             if (flow->dl_type) {
2013                 error = xasprintf("%s: Ethernet type set multiple times", s);
2014                 goto exit;
2015             }
2016             flow->dl_type = htons(p->dl_type);
2017             if (mask) {
2018                 mask->dl_type = OVS_BE16_MAX;
2019             }
2020
2021             if (p->nw_proto) {
2022                 if (flow->nw_proto) {
2023                     error = xasprintf("%s: network protocol set "
2024                                       "multiple times", s);
2025                     goto exit;
2026                 }
2027                 flow->nw_proto = p->nw_proto;
2028                 if (mask) {
2029                     mask->nw_proto = UINT8_MAX;
2030                 }
2031             }
2032         } else {
2033             const struct mf_field *mf;
2034             union mf_value value;
2035             char *field_error;
2036
2037             mf = mf_from_name(key);
2038             if (!mf) {
2039                 error = xasprintf("%s: unknown field %s", s, key);
2040                 goto exit;
2041             }
2042
2043             if (!mf_are_prereqs_ok(mf, flow)) {
2044                 error = xasprintf("%s: prerequisites not met for setting %s",
2045                                   s, key);
2046                 goto exit;
2047             }
2048
2049             if (!mf_is_zero(mf, flow)) {
2050                 error = xasprintf("%s: field %s set multiple times", s, key);
2051                 goto exit;
2052             }
2053
2054             if (!strcmp(key, "in_port")
2055                 && portno_names
2056                 && simap_contains(portno_names, value_s)) {
2057                 flow->in_port.ofp_port = u16_to_ofp(
2058                     simap_get(portno_names, value_s));
2059                 if (mask) {
2060                     mask->in_port.ofp_port = u16_to_ofp(ntohs(OVS_BE16_MAX));
2061                 }
2062             } else {
2063                 field_error = mf_parse_value(mf, value_s, &value);
2064                 if (field_error) {
2065                     error = xasprintf("%s: bad value for %s (%s)",
2066                                       s, key, field_error);
2067                     free(field_error);
2068                     goto exit;
2069                 }
2070
2071                 mf_set_flow_value(mf, &value, flow);
2072                 if (mask) {
2073                     mf_mask_field(mf, mask);
2074                 }
2075             }
2076         }
2077     }
2078
2079     if (!flow->in_port.ofp_port) {
2080         flow->in_port.ofp_port = OFPP_NONE;
2081     }
2082
2083 exit:
2084     free(copy);
2085
2086     if (error) {
2087         memset(flow, 0, sizeof *flow);
2088         if (mask) {
2089             memset(mask, 0, sizeof *mask);
2090         }
2091     }
2092     return error;
2093 }
2094
2095 static char * WARN_UNUSED_RESULT
2096 parse_bucket_str(struct ofputil_bucket *bucket, char *str_,
2097                   enum ofputil_protocol *usable_protocols)
2098 {
2099     struct ofpbuf ofpacts;
2100     char *pos, *act, *arg;
2101     int n_actions;
2102
2103     bucket->weight = 1;
2104     bucket->watch_port = OFPP_ANY;
2105     bucket->watch_group = OFPG11_ANY;
2106
2107     pos = str_;
2108     n_actions = 0;
2109     ofpbuf_init(&ofpacts, 64);
2110     while (ofputil_parse_key_value(&pos, &act, &arg)) {
2111         char *error = NULL;
2112
2113         if (!strcasecmp(act, "weight")) {
2114             error = str_to_u16(arg, "weight", &bucket->weight);
2115         } else if (!strcasecmp(act, "watch_port")) {
2116             if (!ofputil_port_from_string(arg, &bucket->watch_port)
2117                 || (ofp_to_u16(bucket->watch_port) >= ofp_to_u16(OFPP_MAX)
2118                     && bucket->watch_port != OFPP_ANY)) {
2119                 error = xasprintf("%s: invalid watch_port", arg);
2120             }
2121         } else if (!strcasecmp(act, "watch_group")) {
2122             error = str_to_u32(arg, &bucket->watch_group);
2123             if (!error && bucket->watch_group > OFPG_MAX) {
2124                 error = xasprintf("invalid watch_group id %"PRIu32,
2125                                   bucket->watch_group);
2126             }
2127         } else if (!strcasecmp(act, "actions")) {
2128             if (ofputil_parse_key_value(&arg, &act, &arg)) {
2129                 error = str_to_ofpact__(pos, act, arg, &ofpacts, n_actions,
2130                                         usable_protocols);
2131                 n_actions++;
2132             }
2133         } else {
2134             error = str_to_ofpact__(pos, act, arg, &ofpacts, n_actions,
2135                                     usable_protocols);
2136             n_actions++;
2137         }
2138
2139         if (error) {
2140             ofpbuf_uninit(&ofpacts);
2141             return error;
2142         }
2143     }
2144
2145     ofpact_pad(&ofpacts);
2146     bucket->ofpacts = ofpbuf_data(&ofpacts);
2147     bucket->ofpacts_len = ofpbuf_size(&ofpacts);
2148
2149     return NULL;
2150 }
2151
2152 static char * WARN_UNUSED_RESULT
2153 parse_ofp_group_mod_str__(struct ofputil_group_mod *gm, uint16_t command,
2154                           char *string,
2155                           enum ofputil_protocol *usable_protocols)
2156 {
2157     enum {
2158         F_GROUP_TYPE  = 1 << 0,
2159         F_BUCKETS     = 1 << 1,
2160     } fields;
2161     char *save_ptr = NULL;
2162     bool had_type = false;
2163     char *name;
2164     struct ofputil_bucket *bucket;
2165     char *error = NULL;
2166
2167     *usable_protocols = OFPUTIL_P_OF11_UP;
2168
2169     switch (command) {
2170     case OFPGC11_ADD:
2171         fields = F_GROUP_TYPE | F_BUCKETS;
2172         break;
2173
2174     case OFPGC11_DELETE:
2175         fields = 0;
2176         break;
2177
2178     case OFPGC11_MODIFY:
2179         fields = F_GROUP_TYPE | F_BUCKETS;
2180         break;
2181
2182     default:
2183         OVS_NOT_REACHED();
2184     }
2185
2186     memset(gm, 0, sizeof *gm);
2187     gm->command = command;
2188     gm->group_id = OFPG_ANY;
2189     list_init(&gm->buckets);
2190     if (command == OFPGC11_DELETE && string[0] == '\0') {
2191         gm->group_id = OFPG_ALL;
2192         return NULL;
2193     }
2194
2195     *usable_protocols = OFPUTIL_P_OF11_UP;
2196
2197     if (fields & F_BUCKETS) {
2198         char *bkt_str = strstr(string, "bucket");
2199
2200         if (bkt_str) {
2201             *bkt_str = '\0';
2202         }
2203
2204         while (bkt_str) {
2205             char *next_bkt_str;
2206
2207             bkt_str = strchr(bkt_str + 1, '=');
2208             if (!bkt_str) {
2209                 error = xstrdup("must specify bucket content");
2210                 goto out;
2211             }
2212             bkt_str++;
2213
2214             next_bkt_str = strstr(bkt_str, "bucket");
2215             if (next_bkt_str) {
2216                 *next_bkt_str = '\0';
2217             }
2218
2219             bucket = xzalloc(sizeof(struct ofputil_bucket));
2220             error = parse_bucket_str(bucket, bkt_str, usable_protocols);
2221             if (error) {
2222                 free(bucket);
2223                 goto out;
2224             }
2225             list_push_back(&gm->buckets, &bucket->list_node);
2226
2227             bkt_str = next_bkt_str;
2228         }
2229     }
2230
2231     for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
2232          name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
2233         char *value;
2234
2235         value = strtok_r(NULL, ", \t\r\n", &save_ptr);
2236         if (!value) {
2237             error = xasprintf("field %s missing value", name);
2238             goto out;
2239         }
2240
2241         if (!strcmp(name, "group_id")) {
2242             if(!strcmp(value, "all")) {
2243                 gm->group_id = OFPG_ALL;
2244             } else {
2245                 char *error = str_to_u32(value, &gm->group_id);
2246                 if (error) {
2247                     goto out;
2248                 }
2249                 if (gm->group_id != OFPG_ALL && gm->group_id > OFPG_MAX) {
2250                     error = xasprintf("invalid group id %"PRIu32,
2251                                       gm->group_id);
2252                     goto out;
2253                 }
2254             }
2255         } else if (!strcmp(name, "type")){
2256             if (!(fields & F_GROUP_TYPE)) {
2257                 error = xstrdup("type is not needed");
2258                 goto out;
2259             }
2260             if (!strcmp(value, "all")) {
2261                 gm->type = OFPGT11_ALL;
2262             } else if (!strcmp(value, "select")) {
2263                 gm->type = OFPGT11_SELECT;
2264             } else if (!strcmp(value, "indirect")) {
2265                 gm->type = OFPGT11_INDIRECT;
2266             } else if (!strcmp(value, "ff") ||
2267                        !strcmp(value, "fast_failover")) {
2268                 gm->type = OFPGT11_FF;
2269             } else {
2270                 error = xasprintf("invalid group type %s", value);
2271                 goto out;
2272             }
2273             had_type = true;
2274         } else if (!strcmp(name, "bucket")) {
2275             error = xstrdup("bucket is not needed");
2276             goto out;
2277         } else {
2278             error = xasprintf("unknown keyword %s", name);
2279             goto out;
2280         }
2281     }
2282     if (gm->group_id == OFPG_ANY) {
2283         error = xstrdup("must specify a group_id");
2284         goto out;
2285     }
2286     if (fields & F_GROUP_TYPE && !had_type) {
2287         error = xstrdup("must specify a type");
2288         goto out;
2289     }
2290
2291     /* Validate buckets. */
2292     LIST_FOR_EACH (bucket, list_node, &gm->buckets) {
2293         if (bucket->weight != 1 && gm->type != OFPGT11_SELECT) {
2294             error = xstrdup("Only select groups can have bucket weights.");
2295             goto out;
2296         }
2297     }
2298     if (gm->type == OFPGT11_INDIRECT && !list_is_short(&gm->buckets)) {
2299         error = xstrdup("Indirect groups can have at most one bucket.");
2300         goto out;
2301     }
2302
2303     return NULL;
2304  out:
2305     ofputil_bucket_list_destroy(&gm->buckets);
2306     return error;
2307 }
2308
2309 char * WARN_UNUSED_RESULT
2310 parse_ofp_group_mod_str(struct ofputil_group_mod *gm, uint16_t command,
2311                         const char *str_,
2312                         enum ofputil_protocol *usable_protocols)
2313 {
2314     char *string = xstrdup(str_);
2315     char *error = parse_ofp_group_mod_str__(gm, command, string,
2316                                             usable_protocols);
2317     free(string);
2318
2319     if (error) {
2320         ofputil_bucket_list_destroy(&gm->buckets);
2321     }
2322     return error;
2323 }
2324
2325 char * WARN_UNUSED_RESULT
2326 parse_ofp_group_mod_file(const char *file_name, uint16_t command,
2327                          struct ofputil_group_mod **gms, size_t *n_gms,
2328                          enum ofputil_protocol *usable_protocols)
2329 {
2330     size_t allocated_gms;
2331     int line_number;
2332     FILE *stream;
2333     struct ds s;
2334
2335     *gms = NULL;
2336     *n_gms = 0;
2337
2338     stream = !strcmp(file_name, "-") ? stdin : fopen(file_name, "r");
2339     if (stream == NULL) {
2340         return xasprintf("%s: open failed (%s)",
2341                          file_name, ovs_strerror(errno));
2342     }
2343
2344     allocated_gms = *n_gms;
2345     ds_init(&s);
2346     line_number = 0;
2347     *usable_protocols = OFPUTIL_P_OF11_UP;
2348     while (!ds_get_preprocessed_line(&s, stream, &line_number)) {
2349         enum ofputil_protocol usable;
2350         char *error;
2351
2352         if (*n_gms >= allocated_gms) {
2353             size_t i;
2354
2355             *gms = x2nrealloc(*gms, &allocated_gms, sizeof **gms);
2356             for (i = 0; i < *n_gms; i++) {
2357                 list_moved(&(*gms)[i].buckets);
2358             }
2359         }
2360         error = parse_ofp_group_mod_str(&(*gms)[*n_gms], command, ds_cstr(&s),
2361                                         &usable);
2362         if (error) {
2363             size_t i;
2364
2365             for (i = 0; i < *n_gms; i++) {
2366                 ofputil_bucket_list_destroy(&(*gms)[i].buckets);
2367             }
2368             free(*gms);
2369             *gms = NULL;
2370             *n_gms = 0;
2371
2372             ds_destroy(&s);
2373             if (stream != stdin) {
2374                 fclose(stream);
2375             }
2376
2377             return xasprintf("%s:%d: %s", file_name, line_number, error);
2378         }
2379         *usable_protocols &= usable;
2380         *n_gms += 1;
2381     }
2382
2383     ds_destroy(&s);
2384     if (stream != stdin) {
2385         fclose(stream);
2386     }
2387     return NULL;
2388 }