lib/ofp-parse.c

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