utilities/ovs-ofctl.c

   1 /*
   2  * Copyright (c) 2008, 2009, 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 #include <ctype.h>
  19 #include <errno.h>
  20 #include <getopt.h>
  21 #include <inttypes.h>
  22 #include <sys/socket.h>
  23 #include <net/if.h>
  24 #include <signal.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <sys/fcntl.h>
  29 #include <sys/stat.h>
  30 #include <sys/time.h>
  31
  32 #include "byte-order.h"
  33 #include "classifier.h"
  34 #include "command-line.h"
  35 #include "daemon.h"
  36 #include "compiler.h"
  37 #include "dirs.h"
  38 #include "dynamic-string.h"
  39 #include "nx-match.h"
  40 #include "odp-util.h"
  41 #include "ofp-actions.h"
  42 #include "ofp-errors.h"
  43 #include "ofp-msgs.h"
  44 #include "ofp-parse.h"
  45 #include "ofp-print.h"
  46 #include "ofp-util.h"
  47 #include "ofp-version-opt.h"
  48 #include "ofpbuf.h"
  49 #include "ofproto/ofproto.h"
  50 #include "openflow/nicira-ext.h"
  51 #include "openflow/openflow.h"
  52 #include "packets.h"
  53 #include "pcap-file.h"
  54 #include "poll-loop.h"
  55 #include "random.h"
  56 #include "stream-ssl.h"
  57 #include "socket-util.h"
  58 #include "timeval.h"
  59 #include "unixctl.h"
  60 #include "util.h"
  61 #include "vconn.h"
  62 #include "vlog.h"
  63 #include "meta-flow.h"
  64 #include "sort.h"
  65
  66 VLOG_DEFINE_THIS_MODULE(ofctl);
  67
  68 /* --strict: Use strict matching for flow mod commands?  Additionally governs
  69  * use of nx_pull_match() instead of nx_pull_match_loose() in parse-nx-match.
  70  */
  71 static bool strict;
  72
  73 /* --readd: If true, on replace-flows, re-add even flows that have not changed
  74  * (to reset flow counters). */
  75 static bool readd;
  76
  77 /* -F, --flow-format: Allowed protocols.  By default, any protocol is
  78  * allowed. */
  79 static enum ofputil_protocol allowed_protocols = OFPUTIL_P_ANY;
  80
  81 /* -P, --packet-in-format: Packet IN format to use in monitor and snoop
  82  * commands.  Either one of NXPIF_* to force a particular packet_in format, or
  83  * -1 to let ovs-ofctl choose the default. */
  84 static int preferred_packet_in_format = -1;
  85
  86 /* -m, --more: Additional verbosity for ofp-print functions. */
  87 static int verbosity;
  88
  89 /* --timestamp: Print a timestamp before each received packet on "monitor" and
  90  * "snoop" command? */
  91 static bool timestamp;
  92
  93 /* --sort, --rsort: Sort order. */
  94 enum sort_order { SORT_ASC, SORT_DESC };
  95 struct sort_criterion {
  96     const struct mf_field *field; /* NULL means to sort by priority. */
  97     enum sort_order order;
  98 };
  99 static struct sort_criterion *criteria;
 100 static size_t n_criteria, allocated_criteria;
 101
 102 static const struct command *get_all_commands(void);
 103
 104 static void usage(void) NO_RETURN;
 105 static void parse_options(int argc, char *argv[]);
 106
 107 static bool recv_flow_stats_reply(struct vconn *, ovs_be32 send_xid,
 108                                   struct ofpbuf **replyp,
 109                                   struct ofputil_flow_stats *,
 110                                   struct ofpbuf *ofpacts);
 111 int
 112 main(int argc, char *argv[])
 113 {
 114     set_program_name(argv[0]);
 115     parse_options(argc, argv);
 116     signal(SIGPIPE, SIG_IGN);
 117     run_command(argc - optind, argv + optind, get_all_commands());
 118     return 0;
 119 }
 120
 121 static void
 122 add_sort_criterion(enum sort_order order, const char *field)
 123 {
 124     struct sort_criterion *sc;
 125
 126     if (n_criteria >= allocated_criteria) {
 127         criteria = x2nrealloc(criteria, &allocated_criteria, sizeof *criteria);
 128     }
 129
 130     sc = &criteria[n_criteria++];
 131     if (!field || !strcasecmp(field, "priority")) {
 132         sc->field = NULL;
 133     } else {
 134         sc->field = mf_from_name(field);
 135         if (!sc->field) {
 136             ovs_fatal(0, "%s: unknown field name", field);
 137         }
 138     }
 139     sc->order = order;
 140 }
 141
 142 static void
 143 parse_options(int argc, char *argv[])
 144 {
 145     enum {
 146         OPT_STRICT = UCHAR_MAX + 1,
 147         OPT_READD,
 148         OPT_TIMESTAMP,
 149         OPT_SORT,
 150         OPT_RSORT,
 151         DAEMON_OPTION_ENUMS,
 152         OFP_VERSION_OPTION_ENUMS,
 153         VLOG_OPTION_ENUMS
 154     };
 155     static const struct option long_options[] = {
 156         {"timeout", required_argument, NULL, 't'},
 157         {"strict", no_argument, NULL, OPT_STRICT},
 158         {"readd", no_argument, NULL, OPT_READD},
 159         {"flow-format", required_argument, NULL, 'F'},
 160         {"packet-in-format", required_argument, NULL, 'P'},
 161         {"more", no_argument, NULL, 'm'},
 162         {"timestamp", no_argument, NULL, OPT_TIMESTAMP},
 163         {"sort", optional_argument, NULL, OPT_SORT},
 164         {"rsort", optional_argument, NULL, OPT_RSORT},
 165         {"help", no_argument, NULL, 'h'},
 166         DAEMON_LONG_OPTIONS,
 167         OFP_VERSION_LONG_OPTIONS,
 168         VLOG_LONG_OPTIONS,
 169         STREAM_SSL_LONG_OPTIONS,
 170         {NULL, 0, NULL, 0},
 171     };
 172     char *short_options = long_options_to_short_options(long_options);
 173     uint32_t versions;
 174     enum ofputil_protocol version_protocols;
 175
 176     for (;;) {
 177         unsigned long int timeout;
 178         int c;
 179
 180         c = getopt_long(argc, argv, short_options, long_options, NULL);
 181         if (c == -1) {
 182             break;
 183         }
 184
 185         switch (c) {
 186         case 't':
 187             timeout = strtoul(optarg, NULL, 10);
 188             if (timeout <= 0) {
 189                 ovs_fatal(0, "value %s on -t or --timeout is not at least 1",
 190                           optarg);
 191             } else {
 192                 time_alarm(timeout);
 193             }
 194             break;
 195
 196         case 'F':
 197             allowed_protocols = ofputil_protocols_from_string(optarg);
 198             if (!allowed_protocols) {
 199                 ovs_fatal(0, "%s: invalid flow format(s)", optarg);
 200             }
 201             break;
 202
 203         case 'P':
 204             preferred_packet_in_format =
 205                 ofputil_packet_in_format_from_string(optarg);
 206             if (preferred_packet_in_format < 0) {
 207                 ovs_fatal(0, "unknown packet-in format `%s'", optarg);
 208             }
 209             break;
 210
 211         case 'm':
 212             verbosity++;
 213             break;
 214
 215         case 'h':
 216             usage();
 217
 218         case OPT_STRICT:
 219             strict = true;
 220             break;
 221
 222         case OPT_READD:
 223             readd = true;
 224             break;
 225
 226         case OPT_TIMESTAMP:
 227             timestamp = true;
 228             break;
 229
 230         case OPT_SORT:
 231             add_sort_criterion(SORT_ASC, optarg);
 232             break;
 233
 234         case OPT_RSORT:
 235             add_sort_criterion(SORT_DESC, optarg);
 236             break;
 237
 238         DAEMON_OPTION_HANDLERS
 239         OFP_VERSION_OPTION_HANDLERS
 240         VLOG_OPTION_HANDLERS
 241         STREAM_SSL_OPTION_HANDLERS
 242
 243         case '?':
 244             exit(EXIT_FAILURE);
 245
 246         default:
 247             abort();
 248         }
 249     }
 250
 251     if (n_criteria) {
 252         /* Always do a final sort pass based on priority. */
 253         add_sort_criterion(SORT_DESC, "priority");
 254     }
 255
 256     free(short_options);
 257
 258     versions = get_allowed_ofp_versions();
 259     version_protocols = ofputil_protocols_from_version_bitmap(versions);
 260     if (!(allowed_protocols & version_protocols)) {
 261         char *protocols = ofputil_protocols_to_string(allowed_protocols);
 262         struct ds version_s = DS_EMPTY_INITIALIZER;
 263
 264         ofputil_format_version_bitmap_names(&version_s, versions);
 265         ovs_fatal(0, "None of the enabled OpenFlow versions (%s) supports "
 266                   "any of the enabled flow formats (%s).  (Use -O to enable "
 267                   "additional OpenFlow versions or -F to enable additional "
 268                   "flow formats.)", ds_cstr(&version_s), protocols);
 269     }
 270     allowed_protocols &= version_protocols;
 271     mask_allowed_ofp_versions(ofputil_protocols_to_version_bitmap(
 272                                   allowed_protocols));
 273 }
 274
 275 static void
 276 usage(void)
 277 {
 278     printf("%s: OpenFlow switch management utility\n"
 279            "usage: %s [OPTIONS] COMMAND [ARG...]\n"
 280            "\nFor OpenFlow switches:\n"
 281            "  show SWITCH                 show OpenFlow information\n"
 282            "  dump-desc SWITCH            print switch description\n"
 283            "  dump-tables SWITCH          print table stats\n"
 284            "  mod-port SWITCH IFACE ACT   modify port behavior\n"
 285            "  mod-table SWITCH MOD        modify flow table behavior\n"
 286            "  get-frags SWITCH            print fragment handling behavior\n"
 287            "  set-frags SWITCH FRAG_MODE  set fragment handling behavior\n"
 288            "  dump-ports SWITCH [PORT]    print port statistics\n"
 289            "  dump-ports-desc SWITCH      print port descriptions\n"
 290            "  dump-flows SWITCH           print all flow entries\n"
 291            "  dump-flows SWITCH FLOW      print matching FLOWs\n"
 292            "  dump-aggregate SWITCH       print aggregate flow statistics\n"
 293            "  dump-aggregate SWITCH FLOW  print aggregate stats for FLOWs\n"
 294            "  queue-stats SWITCH [PORT [QUEUE]]  dump queue stats\n"
 295            "  add-flow SWITCH FLOW        add flow described by FLOW\n"
 296            "  add-flows SWITCH FILE       add flows from FILE\n"
 297            "  mod-flows SWITCH FLOW       modify actions of matching FLOWs\n"
 298            "  del-flows SWITCH [FLOW]     delete matching FLOWs\n"
 299            "  replace-flows SWITCH FILE   replace flows with those in FILE\n"
 300            "  diff-flows SOURCE1 SOURCE2  compare flows from two sources\n"
 301            "  packet-out SWITCH IN_PORT ACTIONS PACKET...\n"
 302            "                              execute ACTIONS on PACKET\n"
 303            "  monitor SWITCH [MISSLEN] [invalid_ttl] [watch:[...]]\n"
 304            "                              print packets received from SWITCH\n"
 305            "  snoop SWITCH                snoop on SWITCH and its controller\n"
 306            "  add-group SWITCH GROUP      add group described by GROUP\n"
 307            "  add-group SWITCH FILE       add group from FILE\n"
 308            "  mod-group SWITCH GROUP      modify specific group\n"
 309            "  del-groups SWITCH [GROUP]   delete matching GROUPs\n"
 310            "  dump-group-features SWITCH  print group features\n"
 311            "  dump-groups SWITCH          print group description\n"
 312            "  dump-group-stats SWITCH [GROUP]  print group statistics\n"
 313            "  add-meter SWITCH METER      add meter described by METER\n"
 314            "  mod-meter SWITCH METER      modify specific METER\n"
 315            "  del-meter SWITCH METER      delete METER\n"
 316            "  del-meters SWITCH           delete all meters\n"
 317            "  dump-meter SWITCH METER     print METER configuration\n"
 318            "  dump-meters SWITCH          print all meter configuration\n"
 319            "  meter-stats SWITCH [METER]  print meter statistics\n"
 320            "  meter-features SWITCH       print meter features\n"
 321            "\nFor OpenFlow switches and controllers:\n"
 322            "  probe TARGET                probe whether TARGET is up\n"
 323            "  ping TARGET [N]             latency of N-byte echos\n"
 324            "  benchmark TARGET N COUNT    bandwidth of COUNT N-byte echos\n"
 325            "SWITCH or TARGET is an active OpenFlow connection method.\n"
 326            "\nOther commands:\n"
 327            "  ofp-parse FILE              print messages read from FILE\n",
 328            program_name, program_name);
 329     vconn_usage(true, false, false);
 330     daemon_usage();
 331     ofp_version_usage();
 332     vlog_usage();
 333     printf("\nOther options:\n"
 334            "  --strict                    use strict match for flow commands\n"
 335            "  --readd                     replace flows that haven't changed\n"
 336            "  -F, --flow-format=FORMAT    force particular flow format\n"
 337            "  -P, --packet-in-format=FRMT force particular packet in format\n"
 338            "  -m, --more                  be more verbose printing OpenFlow\n"
 339            "  --timestamp                 (monitor, snoop) print timestamps\n"
 340            "  -t, --timeout=SECS          give up after SECS seconds\n"
 341            "  --sort[=field]              sort in ascending order\n"
 342            "  --rsort[=field]             sort in descending order\n"
 343            "  -h, --help                  display this help message\n"
 344            "  -V, --version               display version information\n");
 345     exit(EXIT_SUCCESS);
 346 }
 347
 348 static void
 349 ofctl_exit(struct unixctl_conn *conn, int argc OVS_UNUSED,
 350            const char *argv[] OVS_UNUSED, void *exiting_)
 351 {
 352     bool *exiting = exiting_;
 353     *exiting = true;
 354     unixctl_command_reply(conn, NULL);
 355 }
 356
 357 static void run(int retval, const char *message, ...)
 358     PRINTF_FORMAT(2, 3);
 359
 360 static void
 361 run(int retval, const char *message, ...)
 362 {
 363     if (retval) {
 364         va_list args;
 365
 366         va_start(args, message);
 367         ovs_fatal_valist(retval, message, args);
 368     }
 369 }
 370 \f
 371 /* Generic commands. */
 372
 373 static int
 374 open_vconn_socket(const char *name, struct vconn **vconnp)
 375 {
 376     char *vconn_name = xasprintf("unix:%s", name);
 377     int error;
 378
 379     error = vconn_open(vconn_name, get_allowed_ofp_versions(), DSCP_DEFAULT,
 380                        vconnp);
 381     if (error && error != ENOENT) {
 382         ovs_fatal(0, "%s: failed to open socket (%s)", name,
 383                   ovs_strerror(error));
 384     }
 385     free(vconn_name);
 386
 387     return error;
 388 }
 389
 390 enum open_target { MGMT, SNOOP };
 391
 392 static enum ofputil_protocol
 393 open_vconn__(const char *name, enum open_target target,
 394              struct vconn **vconnp)
 395 {
 396     const char *suffix = target == MGMT ? "mgmt" : "snoop";
 397     char *datapath_name, *datapath_type, *socket_name;
 398     enum ofputil_protocol protocol;
 399     char *bridge_path;
 400     int ofp_version;
 401     int error;
 402
 403     bridge_path = xasprintf("%s/%s.%s", ovs_rundir(), name, suffix);
 404
 405     ofproto_parse_name(name, &datapath_name, &datapath_type);
 406     socket_name = xasprintf("%s/%s.%s", ovs_rundir(), datapath_name, suffix);
 407     free(datapath_name);
 408     free(datapath_type);
 409
 410     if (strchr(name, ':')) {
 411         run(vconn_open(name, get_allowed_ofp_versions(), DSCP_DEFAULT, vconnp),
 412             "connecting to %s", name);
 413     } else if (!open_vconn_socket(name, vconnp)) {
 414         /* Fall Through. */
 415     } else if (!open_vconn_socket(bridge_path, vconnp)) {
 416         /* Fall Through. */
 417     } else if (!open_vconn_socket(socket_name, vconnp)) {
 418         /* Fall Through. */
 419     } else {
 420         ovs_fatal(0, "%s is not a bridge or a socket", name);
 421     }
 422
 423     if (target == SNOOP) {
 424         vconn_set_recv_any_version(*vconnp);
 425     }
 426
 427     free(bridge_path);
 428     free(socket_name);
 429
 430     VLOG_DBG("connecting to %s", vconn_get_name(*vconnp));
 431     error = vconn_connect_block(*vconnp);
 432     if (error) {
 433         ovs_fatal(0, "%s: failed to connect to socket (%s)", name,
 434                   ovs_strerror(error));
 435     }
 436
 437     ofp_version = vconn_get_version(*vconnp);
 438     protocol = ofputil_protocol_from_ofp_version(ofp_version);
 439     if (!protocol) {
 440         ovs_fatal(0, "%s: unsupported OpenFlow version 0x%02x",
 441                   name, ofp_version);
 442     }
 443     return protocol;
 444 }
 445
 446 static enum ofputil_protocol
 447 open_vconn(const char *name, struct vconn **vconnp)
 448 {
 449     return open_vconn__(name, MGMT, vconnp);
 450 }
 451
 452 static void
 453 send_openflow_buffer(struct vconn *vconn, struct ofpbuf *buffer)
 454 {
 455     ofpmsg_update_length(buffer);
 456     run(vconn_send_block(vconn, buffer), "failed to send packet to switch");
 457 }
 458
 459 static void
 460 dump_transaction(struct vconn *vconn, struct ofpbuf *request)
 461 {
 462     struct ofpbuf *reply;
 463
 464     ofpmsg_update_length(request);
 465     run(vconn_transact(vconn, request, &reply), "talking to %s",
 466         vconn_get_name(vconn));
 467     ofp_print(stdout, reply->data, reply->size, verbosity + 1);
 468     ofpbuf_delete(reply);
 469 }
 470
 471 static void
 472 dump_trivial_transaction(const char *vconn_name, enum ofpraw raw)
 473 {
 474     struct ofpbuf *request;
 475     struct vconn *vconn;
 476
 477     open_vconn(vconn_name, &vconn);
 478     request = ofpraw_alloc(raw, vconn_get_version(vconn), 0);
 479     dump_transaction(vconn, request);
 480     vconn_close(vconn);
 481 }
 482
 483 static void
 484 dump_stats_transaction(struct vconn *vconn, struct ofpbuf *request)
 485 {
 486     const struct ofp_header *request_oh = request->data;
 487     ovs_be32 send_xid = request_oh->xid;
 488     enum ofpraw request_raw;
 489     enum ofpraw reply_raw;
 490     bool done = false;
 491
 492     ofpraw_decode_partial(&request_raw, request->data, request->size);
 493     reply_raw = ofpraw_stats_request_to_reply(request_raw,
 494                                               request_oh->version);
 495
 496     send_openflow_buffer(vconn, request);
 497     while (!done) {
 498         ovs_be32 recv_xid;
 499         struct ofpbuf *reply;
 500
 501         run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed");
 502         recv_xid = ((struct ofp_header *) reply->data)->xid;
 503         if (send_xid == recv_xid) {
 504             enum ofpraw raw;
 505
 506             ofp_print(stdout, reply->data, reply->size, verbosity + 1);
 507
 508             ofpraw_decode(&raw, reply->data);
 509             if (ofptype_from_ofpraw(raw) == OFPTYPE_ERROR) {
 510                 done = true;
 511             } else if (raw == reply_raw) {
 512                 done = !ofpmp_more(reply->data);
 513             } else {
 514                 ovs_fatal(0, "received bad reply: %s",
 515                           ofp_to_string(reply->data, reply->size,
 516                                         verbosity + 1));
 517             }
 518         } else {
 519             VLOG_DBG("received reply with xid %08"PRIx32" "
 520                      "!= expected %08"PRIx32, recv_xid, send_xid);
 521         }
 522         ofpbuf_delete(reply);
 523     }
 524 }
 525
 526 static void
 527 dump_trivial_stats_transaction(const char *vconn_name, enum ofpraw raw)
 528 {
 529     struct ofpbuf *request;
 530     struct vconn *vconn;
 531
 532     open_vconn(vconn_name, &vconn);
 533     request = ofpraw_alloc(raw, vconn_get_version(vconn), 0);
 534     dump_stats_transaction(vconn, request);
 535     vconn_close(vconn);
 536 }
 537
 538 /* Sends all of the 'requests', which should be requests that only have replies
 539  * if an error occurs, and waits for them to succeed or fail.  If an error does
 540  * occur, prints it and exits with an error.
 541  *
 542  * Destroys all of the 'requests'. */
 543 static void
 544 transact_multiple_noreply(struct vconn *vconn, struct list *requests)
 545 {
 546     struct ofpbuf *request, *reply;
 547
 548     LIST_FOR_EACH (request, list_node, requests) {
 549         ofpmsg_update_length(request);
 550     }
 551
 552     run(vconn_transact_multiple_noreply(vconn, requests, &reply),
 553         "talking to %s", vconn_get_name(vconn));
 554     if (reply) {
 555         ofp_print(stderr, reply->data, reply->size, verbosity + 2);
 556         exit(1);
 557     }
 558     ofpbuf_delete(reply);
 559 }
 560
 561 /* Sends 'request', which should be a request that only has a reply if an error
 562  * occurs, and waits for it to succeed or fail.  If an error does occur, prints
 563  * it and exits with an error.
 564  *
 565  * Destroys 'request'. */
 566 static void
 567 transact_noreply(struct vconn *vconn, struct ofpbuf *request)
 568 {
 569     struct list requests;
 570
 571     list_init(&requests);
 572     list_push_back(&requests, &request->list_node);
 573     transact_multiple_noreply(vconn, &requests);
 574 }
 575
 576 static void
 577 fetch_switch_config(struct vconn *vconn, struct ofp_switch_config *config_)
 578 {
 579     struct ofp_switch_config *config;
 580     struct ofpbuf *request;
 581     struct ofpbuf *reply;
 582     enum ofptype type;
 583
 584     request = ofpraw_alloc(OFPRAW_OFPT_GET_CONFIG_REQUEST,
 585                            vconn_get_version(vconn), 0);
 586     run(vconn_transact(vconn, request, &reply),
 587         "talking to %s", vconn_get_name(vconn));
 588
 589     if (ofptype_pull(&type, reply) || type != OFPTYPE_GET_CONFIG_REPLY) {
 590         ovs_fatal(0, "%s: bad reply to config request", vconn_get_name(vconn));
 591     }
 592
 593     config = ofpbuf_pull(reply, sizeof *config);
 594     *config_ = *config;
 595
 596     ofpbuf_delete(reply);
 597 }
 598
 599 static void
 600 set_switch_config(struct vconn *vconn, const struct ofp_switch_config *config)
 601 {
 602     struct ofpbuf *request;
 603
 604     request = ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, vconn_get_version(vconn), 0);
 605     ofpbuf_put(request, config, sizeof *config);
 606
 607     transact_noreply(vconn, request);
 608 }
 609
 610 static void
 611 ofctl_show(int argc OVS_UNUSED, char *argv[])
 612 {
 613     const char *vconn_name = argv[1];
 614     struct vconn *vconn;
 615     struct ofpbuf *request;
 616     struct ofpbuf *reply;
 617     bool trunc;
 618
 619     open_vconn(vconn_name, &vconn);
 620     request = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST,
 621                            vconn_get_version(vconn), 0);
 622     run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
 623
 624     trunc = ofputil_switch_features_ports_trunc(reply);
 625     ofp_print(stdout, reply->data, reply->size, verbosity + 1);
 626
 627     ofpbuf_delete(reply);
 628
 629     if (trunc) {
 630         /* The Features Reply may not contain all the ports, so send a
 631          * Port Description stats request, which doesn't have size
 632          * constraints. */
 633         dump_trivial_stats_transaction(vconn_name,
 634                                        OFPRAW_OFPST_PORT_DESC_REQUEST);
 635     }
 636     dump_trivial_transaction(vconn_name, OFPRAW_OFPT_GET_CONFIG_REQUEST);
 637     vconn_close(vconn);
 638 }
 639
 640 static void
 641 ofctl_dump_desc(int argc OVS_UNUSED, char *argv[])
 642 {
 643     dump_trivial_stats_transaction(argv[1], OFPRAW_OFPST_DESC_REQUEST);
 644 }
 645
 646 static void
 647 ofctl_dump_tables(int argc OVS_UNUSED, char *argv[])
 648 {
 649     dump_trivial_stats_transaction(argv[1], OFPRAW_OFPST_TABLE_REQUEST);
 650 }
 651
 652 static bool
 653 fetch_port_by_features(const char *vconn_name,
 654                        const char *port_name, ofp_port_t port_no,
 655                        struct ofputil_phy_port *pp, bool *trunc)
 656 {
 657     struct ofputil_switch_features features;
 658     const struct ofp_header *oh;
 659     struct ofpbuf *request, *reply;
 660     struct vconn *vconn;
 661     enum ofperr error;
 662     enum ofptype type;
 663     struct ofpbuf b;
 664     bool found = false;
 665
 666     /* Fetch the switch's ofp_switch_features. */
 667     open_vconn(vconn_name, &vconn);
 668     request = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST,
 669                            vconn_get_version(vconn), 0);
 670     run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
 671     vconn_close(vconn);
 672
 673     oh = reply->data;
 674     if (ofptype_decode(&type, reply->data)
 675         || type != OFPTYPE_FEATURES_REPLY) {
 676         ovs_fatal(0, "%s: received bad features reply", vconn_name);
 677     }
 678
 679     *trunc = false;
 680     if (ofputil_switch_features_ports_trunc(reply)) {
 681         *trunc = true;
 682         goto exit;
 683     }
 684
 685     error = ofputil_decode_switch_features(oh, &features, &b);
 686     if (error) {
 687         ovs_fatal(0, "%s: failed to decode features reply (%s)",
 688                   vconn_name, ofperr_to_string(error));
 689     }
 690
 691     while (!ofputil_pull_phy_port(oh->version, &b, pp)) {
 692         if (port_no != OFPP_NONE
 693             ? port_no == pp->port_no
 694             : !strcmp(pp->name, port_name)) {
 695             found = true;
 696             goto exit;
 697         }
 698     }
 699
 700 exit:
 701     ofpbuf_delete(reply);
 702     return found;
 703 }
 704
 705 static bool
 706 fetch_port_by_stats(const char *vconn_name,
 707                     const char *port_name, ofp_port_t port_no,
 708                     struct ofputil_phy_port *pp)
 709 {
 710     struct ofpbuf *request;
 711     struct vconn *vconn;
 712     ovs_be32 send_xid;
 713     bool done = false;
 714     bool found = false;
 715
 716     request = ofpraw_alloc(OFPRAW_OFPST_PORT_DESC_REQUEST, OFP10_VERSION, 0);
 717     send_xid = ((struct ofp_header *) request->data)->xid;
 718
 719     open_vconn(vconn_name, &vconn);
 720     send_openflow_buffer(vconn, request);
 721     while (!done) {
 722         ovs_be32 recv_xid;
 723         struct ofpbuf *reply;
 724
 725         run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed");
 726         recv_xid = ((struct ofp_header *) reply->data)->xid;
 727         if (send_xid == recv_xid) {
 728             struct ofp_header *oh = reply->data;
 729             enum ofptype type;
 730             struct ofpbuf b;
 731             uint16_t flags;
 732
 733             ofpbuf_use_const(&b, oh, ntohs(oh->length));
 734             if (ofptype_pull(&type, &b)
 735                 || type != OFPTYPE_PORT_DESC_STATS_REPLY) {
 736                 ovs_fatal(0, "received bad reply: %s",
 737                           ofp_to_string(reply->data, reply->size,
 738                                         verbosity + 1));
 739             }
 740
 741             flags = ofpmp_flags(oh);
 742             done = !(flags & OFPSF_REPLY_MORE);
 743
 744             if (found) {
 745                 /* We've already found the port, but we need to drain
 746                  * the queue of any other replies for this request. */
 747                 continue;
 748             }
 749
 750             while (!ofputil_pull_phy_port(oh->version, &b, pp)) {
 751                 if (port_no != OFPP_NONE ? port_no == pp->port_no
 752                                          : !strcmp(pp->name, port_name)) {
 753                     found = true;
 754                     break;
 755                 }
 756             }
 757         } else {
 758             VLOG_DBG("received reply with xid %08"PRIx32" "
 759                      "!= expected %08"PRIx32, recv_xid, send_xid);
 760         }
 761         ofpbuf_delete(reply);
 762     }
 763     vconn_close(vconn);
 764
 765     return found;
 766 }
 767
 768 static bool
 769 str_to_ofp(const char *s, ofp_port_t *ofp_port)
 770 {
 771     bool ret;
 772     uint32_t port_;
 773
 774     ret = str_to_uint(s, 10, &port_);
 775     *ofp_port = u16_to_ofp(port_);
 776     return ret;
 777 }
 778
 779 /* Opens a connection to 'vconn_name', fetches the port structure for
 780  * 'port_name' (which may be a port name or number), and copies it into
 781  * '*pp'. */
 782 static void
 783 fetch_ofputil_phy_port(const char *vconn_name, const char *port_name,
 784                        struct ofputil_phy_port *pp)
 785 {
 786     ofp_port_t port_no;
 787     bool found;
 788     bool trunc;
 789
 790     /* Try to interpret the argument as a port number. */
 791     if (!str_to_ofp(port_name, &port_no)) {
 792         port_no = OFPP_NONE;
 793     }
 794
 795     /* Try to find the port based on the Features Reply.  If it looks
 796      * like the results may be truncated, then use the Port Description
 797      * stats message introduced in OVS 1.7. */
 798     found = fetch_port_by_features(vconn_name, port_name, port_no, pp,
 799                                    &trunc);
 800     if (trunc) {
 801         found = fetch_port_by_stats(vconn_name, port_name, port_no, pp);
 802     }
 803
 804     if (!found) {
 805         ovs_fatal(0, "%s: couldn't find port `%s'", vconn_name, port_name);
 806     }
 807 }
 808
 809 /* Returns the port number corresponding to 'port_name' (which may be a port
 810  * name or number) within the switch 'vconn_name'. */
 811 static ofp_port_t
 812 str_to_port_no(const char *vconn_name, const char *port_name)
 813 {
 814     ofp_port_t port_no;
 815
 816     if (ofputil_port_from_string(port_name, &port_no)) {
 817         return port_no;
 818     } else {
 819         struct ofputil_phy_port pp;
 820
 821         fetch_ofputil_phy_port(vconn_name, port_name, &pp);
 822         return pp.port_no;
 823     }
 824 }
 825
 826 static bool
 827 try_set_protocol(struct vconn *vconn, enum ofputil_protocol want,
 828                  enum ofputil_protocol *cur)
 829 {
 830     for (;;) {
 831         struct ofpbuf *request, *reply;
 832         enum ofputil_protocol next;
 833
 834         request = ofputil_encode_set_protocol(*cur, want, &next);
 835         if (!request) {
 836             return *cur == want;
 837         }
 838
 839         run(vconn_transact_noreply(vconn, request, &reply),
 840             "talking to %s", vconn_get_name(vconn));
 841         if (reply) {
 842             char *s = ofp_to_string(reply->data, reply->size, 2);
 843             VLOG_DBG("%s: failed to set protocol, switch replied: %s",
 844                      vconn_get_name(vconn), s);
 845             free(s);
 846             ofpbuf_delete(reply);
 847             return false;
 848         }
 849
 850         *cur = next;
 851     }
 852 }
 853
 854 static enum ofputil_protocol
 855 set_protocol_for_flow_dump(struct vconn *vconn,
 856                            enum ofputil_protocol cur_protocol,
 857                            enum ofputil_protocol usable_protocols)
 858 {
 859     char *usable_s;
 860     int i;
 861
 862     for (i = 0; i < ofputil_n_flow_dump_protocols; i++) {
 863         enum ofputil_protocol f = ofputil_flow_dump_protocols[i];
 864         if (f & usable_protocols & allowed_protocols
 865             && try_set_protocol(vconn, f, &cur_protocol)) {
 866             return f;
 867         }
 868     }
 869
 870     usable_s = ofputil_protocols_to_string(usable_protocols);
 871     if (usable_protocols & allowed_protocols) {
 872         ovs_fatal(0, "switch does not support any of the usable flow "
 873                   "formats (%s)", usable_s);
 874     } else {
 875         char *allowed_s = ofputil_protocols_to_string(allowed_protocols);
 876         ovs_fatal(0, "none of the usable flow formats (%s) is among the "
 877                   "allowed flow formats (%s)", usable_s, allowed_s);
 878     }
 879 }
 880
 881 static struct vconn *
 882 prepare_dump_flows(int argc, char *argv[], bool aggregate,
 883                    struct ofpbuf **requestp)
 884 {
 885     enum ofputil_protocol usable_protocols, protocol;
 886     struct ofputil_flow_stats_request fsr;
 887     struct vconn *vconn;
 888     char *error;
 889
 890     error = parse_ofp_flow_stats_request_str(&fsr, aggregate,
 891                                              argc > 2 ? argv[2] : "",
 892                                              &usable_protocols,
 893                                              !(allowed_protocols
 894                                                & OFPUTIL_P_OF10_ANY));
 895     if (error) {
 896         ovs_fatal(0, "%s", error);
 897     }
 898
 899     protocol = open_vconn(argv[1], &vconn);
 900     protocol = set_protocol_for_flow_dump(vconn, protocol, usable_protocols);
 901     *requestp = ofputil_encode_flow_stats_request(&fsr, protocol);
 902     return vconn;
 903 }
 904
 905 static void
 906 ofctl_dump_flows__(int argc, char *argv[], bool aggregate)
 907 {
 908     struct ofpbuf *request;
 909     struct vconn *vconn;
 910
 911     vconn = prepare_dump_flows(argc, argv, aggregate, &request);
 912     dump_stats_transaction(vconn, request);
 913     vconn_close(vconn);
 914 }
 915
 916 static int
 917 compare_flows(const void *afs_, const void *bfs_)
 918 {
 919     const struct ofputil_flow_stats *afs = afs_;
 920     const struct ofputil_flow_stats *bfs = bfs_;
 921     const struct match *a = &afs->match;
 922     const struct match *b = &bfs->match;
 923     const struct sort_criterion *sc;
 924
 925     for (sc = criteria; sc < &criteria[n_criteria]; sc++) {
 926         const struct mf_field *f = sc->field;
 927         int ret;
 928
 929         if (!f) {
 930             unsigned int a_pri = afs->priority;
 931             unsigned int b_pri = bfs->priority;
 932             ret = a_pri < b_pri ? -1 : a_pri > b_pri;
 933         } else {
 934             bool ina, inb;
 935
 936             ina = mf_are_prereqs_ok(f, &a->flow) && !mf_is_all_wild(f, &a->wc);
 937             inb = mf_are_prereqs_ok(f, &b->flow) && !mf_is_all_wild(f, &b->wc);
 938             if (ina != inb) {
 939                 /* Skip the test for sc->order, so that missing fields always
 940                  * sort to the end whether we're sorting in ascending or
 941                  * descending order. */
 942                 return ina ? -1 : 1;
 943             } else {
 944                 union mf_value aval, bval;
 945
 946                 mf_get_value(f, &a->flow, &aval);
 947                 mf_get_value(f, &b->flow, &bval);
 948                 ret = memcmp(&aval, &bval, f->n_bytes);
 949             }
 950         }
 951
 952         if (ret) {
 953             return sc->order == SORT_ASC ? ret : -ret;
 954         }
 955     }
 956
 957     return 0;
 958 }
 959
 960 static void
 961 ofctl_dump_flows(int argc, char *argv[])
 962 {
 963     if (!n_criteria) {
 964         return ofctl_dump_flows__(argc, argv, false);
 965     } else {
 966         struct ofputil_flow_stats *fses;
 967         size_t n_fses, allocated_fses;
 968         struct ofpbuf *request;
 969         struct ofpbuf ofpacts;
 970         struct ofpbuf *reply;
 971         struct vconn *vconn;
 972         ovs_be32 send_xid;
 973         struct ds s;
 974         size_t i;
 975
 976         vconn = prepare_dump_flows(argc, argv, false, &request);
 977         send_xid = ((struct ofp_header *) request->data)->xid;
 978         send_openflow_buffer(vconn, request);
 979
 980         fses = NULL;
 981         n_fses = allocated_fses = 0;
 982         reply = NULL;
 983         ofpbuf_init(&ofpacts, 0);
 984         for (;;) {
 985             struct ofputil_flow_stats *fs;
 986
 987             if (n_fses >= allocated_fses) {
 988                 fses = x2nrealloc(fses, &allocated_fses, sizeof *fses);
 989             }
 990
 991             fs = &fses[n_fses];
 992             if (!recv_flow_stats_reply(vconn, send_xid, &reply, fs,
 993                                        &ofpacts)) {
 994                 break;
 995             }
 996             fs->ofpacts = xmemdup(fs->ofpacts, fs->ofpacts_len);
 997             n_fses++;
 998         }
 999         ofpbuf_uninit(&ofpacts);
1000
1001         qsort(fses, n_fses, sizeof *fses, compare_flows);
1002
1003         ds_init(&s);
1004         for (i = 0; i < n_fses; i++) {
1005             ds_clear(&s);
1006             ofp_print_flow_stats(&s, &fses[i]);
1007             puts(ds_cstr(&s));
1008         }
1009         ds_destroy(&s);
1010
1011         for (i = 0; i < n_fses; i++) {
1012             free(fses[i].ofpacts);
1013         }
1014         free(fses);
1015
1016         vconn_close(vconn);
1017     }
1018 }
1019
1020 static void
1021 ofctl_dump_aggregate(int argc, char *argv[])
1022 {
1023     return ofctl_dump_flows__(argc, argv, true);
1024 }
1025
1026 static void
1027 ofctl_queue_stats(int argc, char *argv[])
1028 {
1029     struct ofpbuf *request;
1030     struct vconn *vconn;
1031     struct ofputil_queue_stats_request oqs;
1032
1033     open_vconn(argv[1], &vconn);
1034
1035     if (argc > 2 && argv[2][0] && strcasecmp(argv[2], "all")) {
1036         oqs.port_no = str_to_port_no(argv[1], argv[2]);
1037     } else {
1038         oqs.port_no = OFPP_ANY;
1039     }
1040     if (argc > 3 && argv[3][0] && strcasecmp(argv[3], "all")) {
1041         oqs.queue_id = atoi(argv[3]);
1042     } else {
1043         oqs.queue_id = OFPQ_ALL;
1044     }
1045
1046     request = ofputil_encode_queue_stats_request(vconn_get_version(vconn), &oqs);
1047     dump_stats_transaction(vconn, request);
1048     vconn_close(vconn);
1049 }
1050
1051 static enum ofputil_protocol
1052 open_vconn_for_flow_mod(const char *remote, struct vconn **vconnp,
1053                         enum ofputil_protocol usable_protocols)
1054 {
1055     enum ofputil_protocol cur_protocol;
1056     char *usable_s;
1057     int i;
1058
1059     if (!(usable_protocols & allowed_protocols)) {
1060         char *allowed_s = ofputil_protocols_to_string(allowed_protocols);
1061         usable_s = ofputil_protocols_to_string(usable_protocols);
1062         ovs_fatal(0, "none of the usable flow formats (%s) is among the "
1063                   "allowed flow formats (%s)", usable_s, allowed_s);
1064     }
1065
1066     /* If the initial flow format is allowed and usable, keep it. */
1067     cur_protocol = open_vconn(remote, vconnp);
1068     if (usable_protocols & allowed_protocols & cur_protocol) {
1069         return cur_protocol;
1070     }
1071
1072     /* Otherwise try each flow format in turn. */
1073     for (i = 0; i < sizeof(enum ofputil_protocol) * CHAR_BIT; i++) {
1074         enum ofputil_protocol f = 1 << i;
1075
1076         if (f != cur_protocol
1077             && f & usable_protocols & allowed_protocols
1078             && try_set_protocol(*vconnp, f, &cur_protocol)) {
1079             return f;
1080         }
1081     }
1082
1083     usable_s = ofputil_protocols_to_string(usable_protocols);
1084     ovs_fatal(0, "switch does not support any of the usable flow "
1085               "formats (%s)", usable_s);
1086 }
1087
1088 static void
1089 ofctl_flow_mod__(const char *remote, struct ofputil_flow_mod *fms,
1090                  size_t n_fms, enum ofputil_protocol usable_protocols)
1091 {
1092     enum ofputil_protocol protocol;
1093     struct vconn *vconn;
1094     size_t i;
1095
1096     protocol = open_vconn_for_flow_mod(remote, &vconn, usable_protocols);
1097
1098     for (i = 0; i < n_fms; i++) {
1099         struct ofputil_flow_mod *fm = &fms[i];
1100
1101         transact_noreply(vconn, ofputil_encode_flow_mod(fm, protocol));
1102         free(fm->ofpacts);
1103     }
1104     vconn_close(vconn);
1105 }
1106
1107 static void
1108 ofctl_flow_mod_file(int argc OVS_UNUSED, char *argv[], uint16_t command)
1109 {
1110     enum ofputil_protocol usable_protocols;
1111     struct ofputil_flow_mod *fms = NULL;
1112     size_t n_fms = 0;
1113     char *error;
1114
1115     error = parse_ofp_flow_mod_file(argv[2], command, &fms, &n_fms,
1116                                     &usable_protocols,
1117                                     !(allowed_protocols & OFPUTIL_P_OF10_ANY));
1118     if (error) {
1119         ovs_fatal(0, "%s", error);
1120     }
1121     ofctl_flow_mod__(argv[1], fms, n_fms, usable_protocols);
1122     free(fms);
1123 }
1124
1125 static void
1126 ofctl_flow_mod(int argc, char *argv[], uint16_t command)
1127 {
1128     if (argc > 2 && !strcmp(argv[2], "-")) {
1129         ofctl_flow_mod_file(argc, argv, command);
1130     } else {
1131         struct ofputil_flow_mod fm;
1132         char *error;
1133         enum ofputil_protocol usable_protocols;
1134
1135         error = parse_ofp_flow_mod_str(&fm, argc > 2 ? argv[2] : "", command,
1136                                        &usable_protocols,
1137                                        !(allowed_protocols
1138                                          & OFPUTIL_P_OF10_ANY));
1139         if (error) {
1140             ovs_fatal(0, "%s", error);
1141         }
1142         ofctl_flow_mod__(argv[1], &fm, 1, usable_protocols);
1143     }
1144 }
1145
1146 static void
1147 ofctl_add_flow(int argc, char *argv[])
1148 {
1149     ofctl_flow_mod(argc, argv, OFPFC_ADD);
1150 }
1151
1152 static void
1153 ofctl_add_flows(int argc, char *argv[])
1154 {
1155     ofctl_flow_mod_file(argc, argv, OFPFC_ADD);
1156 }
1157
1158 static void
1159 ofctl_mod_flows(int argc, char *argv[])
1160 {
1161     ofctl_flow_mod(argc, argv, strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY);
1162 }
1163
1164 static void
1165 ofctl_del_flows(int argc, char *argv[])
1166 {
1167     ofctl_flow_mod(argc, argv, strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE);
1168 }
1169
1170 static void
1171 set_packet_in_format(struct vconn *vconn,
1172                      enum nx_packet_in_format packet_in_format)
1173 {
1174     struct ofpbuf *spif;
1175
1176     spif = ofputil_make_set_packet_in_format(vconn_get_version(vconn),
1177                                              packet_in_format);
1178     transact_noreply(vconn, spif);
1179     VLOG_DBG("%s: using user-specified packet in format %s",
1180              vconn_get_name(vconn),
1181              ofputil_packet_in_format_to_string(packet_in_format));
1182 }
1183
1184 static int
1185 monitor_set_invalid_ttl_to_controller(struct vconn *vconn)
1186 {
1187     struct ofp_switch_config config;
1188     enum ofp_config_flags flags;
1189
1190     fetch_switch_config(vconn, &config);
1191     flags = ntohs(config.flags);
1192     if (!(flags & OFPC_INVALID_TTL_TO_CONTROLLER)) {
1193         /* Set the invalid ttl config. */
1194         flags |= OFPC_INVALID_TTL_TO_CONTROLLER;
1195
1196         config.flags = htons(flags);
1197         set_switch_config(vconn, &config);
1198
1199         /* Then retrieve the configuration to see if it really took.  OpenFlow
1200          * doesn't define error reporting for bad modes, so this is all we can
1201          * do. */
1202         fetch_switch_config(vconn, &config);
1203         flags = ntohs(config.flags);
1204         if (!(flags & OFPC_INVALID_TTL_TO_CONTROLLER)) {
1205             ovs_fatal(0, "setting invalid_ttl_to_controller failed (this "
1206                       "switch probably doesn't support mode)");
1207             return -EOPNOTSUPP;
1208         }
1209     }
1210     return 0;
1211 }
1212
1213 /* Converts hex digits in 'hex' to an OpenFlow message in '*msgp'.  The
1214  * caller must free '*msgp'.  On success, returns NULL.  On failure, returns
1215  * an error message and stores NULL in '*msgp'. */
1216 static const char *
1217 openflow_from_hex(const char *hex, struct ofpbuf **msgp)
1218 {
1219     struct ofp_header *oh;
1220     struct ofpbuf *msg;
1221
1222     msg = ofpbuf_new(strlen(hex) / 2);
1223     *msgp = NULL;
1224
1225     if (ofpbuf_put_hex(msg, hex, NULL)[0] != '\0') {
1226         ofpbuf_delete(msg);
1227         return "Trailing garbage in hex data";
1228     }
1229
1230     if (msg->size < sizeof(struct ofp_header)) {
1231         ofpbuf_delete(msg);
1232         return "Message too short for OpenFlow";
1233     }
1234
1235     oh = msg->data;
1236     if (msg->size != ntohs(oh->length)) {
1237         ofpbuf_delete(msg);
1238         return "Message size does not match length in OpenFlow header";
1239     }
1240
1241     *msgp = msg;
1242     return NULL;
1243 }
1244
1245 static void
1246 ofctl_send(struct unixctl_conn *conn, int argc,
1247            const char *argv[], void *vconn_)
1248 {
1249     struct vconn *vconn = vconn_;
1250     struct ds reply;
1251     bool ok;
1252     int i;
1253
1254     ok = true;
1255     ds_init(&reply);
1256     for (i = 1; i < argc; i++) {
1257         const char *error_msg;
1258         struct ofpbuf *msg;
1259         int error;
1260
1261         error_msg = openflow_from_hex(argv[i], &msg);
1262         if (error_msg) {
1263             ds_put_format(&reply, "%s\n", error_msg);
1264             ok = false;
1265             continue;
1266         }
1267
1268         fprintf(stderr, "send: ");
1269         ofp_print(stderr, msg->data, msg->size, verbosity);
1270
1271         error = vconn_send_block(vconn, msg);
1272         if (error) {
1273             ofpbuf_delete(msg);
1274             ds_put_format(&reply, "%s\n", ovs_strerror(error));
1275             ok = false;
1276         } else {
1277             ds_put_cstr(&reply, "sent\n");
1278         }
1279     }
1280
1281     if (ok) {
1282         unixctl_command_reply(conn, ds_cstr(&reply));
1283     } else {
1284         unixctl_command_reply_error(conn, ds_cstr(&reply));
1285     }
1286     ds_destroy(&reply);
1287 }
1288
1289 struct barrier_aux {
1290     struct vconn *vconn;        /* OpenFlow connection for sending barrier. */
1291     struct unixctl_conn *conn;  /* Connection waiting for barrier response. */
1292 };
1293
1294 static void
1295 ofctl_barrier(struct unixctl_conn *conn, int argc OVS_UNUSED,
1296               const char *argv[] OVS_UNUSED, void *aux_)
1297 {
1298     struct barrier_aux *aux = aux_;
1299     struct ofpbuf *msg;
1300     int error;
1301
1302     if (aux->conn) {
1303         unixctl_command_reply_error(conn, "already waiting for barrier reply");
1304         return;
1305     }
1306
1307     msg = ofputil_encode_barrier_request(vconn_get_version(aux->vconn));
1308     error = vconn_send_block(aux->vconn, msg);
1309     if (error) {
1310         ofpbuf_delete(msg);
1311         unixctl_command_reply_error(conn, ovs_strerror(error));
1312     } else {
1313         aux->conn = conn;
1314     }
1315 }
1316
1317 static void
1318 ofctl_set_output_file(struct unixctl_conn *conn, int argc OVS_UNUSED,
1319                       const char *argv[], void *aux OVS_UNUSED)
1320 {
1321     int fd;
1322
1323     fd = open(argv[1], O_CREAT | O_TRUNC | O_WRONLY, 0666);
1324     if (fd < 0) {
1325         unixctl_command_reply_error(conn, ovs_strerror(errno));
1326         return;
1327     }
1328
1329     fflush(stderr);
1330     dup2(fd, STDERR_FILENO);
1331     close(fd);
1332     unixctl_command_reply(conn, NULL);
1333 }
1334
1335 static void
1336 ofctl_block(struct unixctl_conn *conn, int argc OVS_UNUSED,
1337             const char *argv[] OVS_UNUSED, void *blocked_)
1338 {
1339     bool *blocked = blocked_;
1340
1341     if (!*blocked) {
1342         *blocked = true;
1343         unixctl_command_reply(conn, NULL);
1344     } else {
1345         unixctl_command_reply(conn, "already blocking");
1346     }
1347 }
1348
1349 static void
1350 ofctl_unblock(struct unixctl_conn *conn, int argc OVS_UNUSED,
1351               const char *argv[] OVS_UNUSED, void *blocked_)
1352 {
1353     bool *blocked = blocked_;
1354
1355     if (*blocked) {
1356         *blocked = false;
1357         unixctl_command_reply(conn, NULL);
1358     } else {
1359         unixctl_command_reply(conn, "already unblocked");
1360     }
1361 }
1362
1363 /* Prints to stdout all of the messages received on 'vconn'.
1364  *
1365  * Iff 'reply_to_echo_requests' is true, sends a reply to any echo request
1366  * received on 'vconn'. */
1367 static void
1368 monitor_vconn(struct vconn *vconn, bool reply_to_echo_requests)
1369 {
1370     struct barrier_aux barrier_aux = { vconn, NULL };
1371     struct unixctl_server *server;
1372     bool exiting = false;
1373     bool blocked = false;
1374     int error;
1375
1376     daemon_save_fd(STDERR_FILENO);
1377     daemonize_start();
1378     error = unixctl_server_create(NULL, &server);
1379     if (error) {
1380         ovs_fatal(error, "failed to create unixctl server");
1381     }
1382     unixctl_command_register("exit", "", 0, 0, ofctl_exit, &exiting);
1383     unixctl_command_register("ofctl/send", "OFMSG...", 1, INT_MAX,
1384                              ofctl_send, vconn);
1385     unixctl_command_register("ofctl/barrier", "", 0, 0,
1386                              ofctl_barrier, &barrier_aux);
1387     unixctl_command_register("ofctl/set-output-file", "FILE", 1, 1,
1388                              ofctl_set_output_file, NULL);
1389
1390     unixctl_command_register("ofctl/block", "", 0, 0, ofctl_block, &blocked);
1391     unixctl_command_register("ofctl/unblock", "", 0, 0, ofctl_unblock,
1392                              &blocked);
1393
1394     daemonize_complete();
1395
1396     for (;;) {
1397         struct ofpbuf *b;
1398         int retval;
1399
1400         unixctl_server_run(server);
1401
1402         while (!blocked) {
1403             enum ofptype type;
1404
1405             retval = vconn_recv(vconn, &b);
1406             if (retval == EAGAIN) {
1407                 break;
1408             }
1409             run(retval, "vconn_recv");
1410
1411             if (timestamp) {
1412                 char *s = xastrftime_msec("%Y-%m-%d %H:%M:%S.###: ",
1413                                           time_wall_msec(), true);
1414                 fputs(s, stderr);
1415                 free(s);
1416             }
1417
1418             ofptype_decode(&type, b->data);
1419             ofp_print(stderr, b->data, b->size, verbosity + 2);
1420
1421             switch ((int) type) {
1422             case OFPTYPE_BARRIER_REPLY:
1423                 if (barrier_aux.conn) {
1424                     unixctl_command_reply(barrier_aux.conn, NULL);
1425                     barrier_aux.conn = NULL;
1426                 }
1427                 break;
1428
1429             case OFPTYPE_ECHO_REQUEST:
1430                 if (reply_to_echo_requests) {
1431                     struct ofpbuf *reply;
1432
1433                     reply = make_echo_reply(b->data);
1434                     retval = vconn_send_block(vconn, reply);
1435                     if (retval) {
1436                         ovs_fatal(retval, "failed to send echo reply");
1437                     }
1438                 }
1439                 break;
1440             }
1441             ofpbuf_delete(b);
1442         }
1443
1444         if (exiting) {
1445             break;
1446         }
1447
1448         vconn_run(vconn);
1449         vconn_run_wait(vconn);
1450         if (!blocked) {
1451             vconn_recv_wait(vconn);
1452         }
1453         unixctl_server_wait(server);
1454         poll_block();
1455     }
1456     vconn_close(vconn);
1457     unixctl_server_destroy(server);
1458 }
1459
1460 static void
1461 ofctl_monitor(int argc, char *argv[])
1462 {
1463     struct vconn *vconn;
1464     int i;
1465     enum ofputil_protocol usable_protocols;
1466
1467     open_vconn(argv[1], &vconn);
1468     for (i = 2; i < argc; i++) {
1469         const char *arg = argv[i];
1470
1471         if (isdigit((unsigned char) *arg)) {
1472             struct ofp_switch_config config;
1473
1474             fetch_switch_config(vconn, &config);
1475             config.miss_send_len = htons(atoi(arg));
1476             set_switch_config(vconn, &config);
1477         } else if (!strcmp(arg, "invalid_ttl")) {
1478             monitor_set_invalid_ttl_to_controller(vconn);
1479         } else if (!strncmp(arg, "watch:", 6)) {
1480             struct ofputil_flow_monitor_request fmr;
1481             struct ofpbuf *msg;
1482             char *error;
1483
1484             error = parse_flow_monitor_request(&fmr, arg + 6,
1485                                                &usable_protocols);
1486             if (error) {
1487                 ovs_fatal(0, "%s", error);
1488             }
1489
1490             msg = ofpbuf_new(0);
1491             ofputil_append_flow_monitor_request(&fmr, msg);
1492             dump_stats_transaction(vconn, msg);
1493         } else {
1494             ovs_fatal(0, "%s: unsupported \"monitor\" argument", arg);
1495         }
1496     }
1497
1498     if (preferred_packet_in_format >= 0) {
1499         set_packet_in_format(vconn, preferred_packet_in_format);
1500     } else {
1501         enum ofp_version version = vconn_get_version(vconn);
1502
1503         switch (version) {
1504         case OFP10_VERSION: {
1505             struct ofpbuf *spif, *reply;
1506
1507             spif = ofputil_make_set_packet_in_format(vconn_get_version(vconn),
1508                                                      NXPIF_NXM);
1509             run(vconn_transact_noreply(vconn, spif, &reply),
1510                 "talking to %s", vconn_get_name(vconn));
1511             if (reply) {
1512                 char *s = ofp_to_string(reply->data, reply->size, 2);
1513                 VLOG_DBG("%s: failed to set packet in format to nxm, controller"
1514                         " replied: %s. Falling back to the switch default.",
1515                         vconn_get_name(vconn), s);
1516                 free(s);
1517                 ofpbuf_delete(reply);
1518             }
1519             break;
1520         }
1521         case OFP11_VERSION:
1522         case OFP12_VERSION:
1523         case OFP13_VERSION:
1524             break;
1525         default:
1526             NOT_REACHED();
1527         }
1528     }
1529
1530     monitor_vconn(vconn, true);
1531 }
1532
1533 static void
1534 ofctl_snoop(int argc OVS_UNUSED, char *argv[])
1535 {
1536     struct vconn *vconn;
1537
1538     open_vconn__(argv[1], SNOOP, &vconn);
1539     monitor_vconn(vconn, false);
1540 }
1541
1542 static void
1543 ofctl_dump_ports(int argc, char *argv[])
1544 {
1545     struct ofpbuf *request;
1546     struct vconn *vconn;
1547     ofp_port_t port;
1548
1549     open_vconn(argv[1], &vconn);
1550     port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_ANY;
1551     request = ofputil_encode_dump_ports_request(vconn_get_version(vconn), port);
1552     dump_stats_transaction(vconn, request);
1553     vconn_close(vconn);
1554 }
1555
1556 static void
1557 ofctl_dump_ports_desc(int argc OVS_UNUSED, char *argv[])
1558 {
1559     dump_trivial_stats_transaction(argv[1], OFPRAW_OFPST_PORT_DESC_REQUEST);
1560 }
1561
1562 static void
1563 ofctl_probe(int argc OVS_UNUSED, char *argv[])
1564 {
1565     struct ofpbuf *request;
1566     struct vconn *vconn;
1567     struct ofpbuf *reply;
1568
1569     open_vconn(argv[1], &vconn);
1570     request = make_echo_request(vconn_get_version(vconn));
1571     run(vconn_transact(vconn, request, &reply), "talking to %s", argv[1]);
1572     if (reply->size != sizeof(struct ofp_header)) {
1573         ovs_fatal(0, "reply does not match request");
1574     }
1575     ofpbuf_delete(reply);
1576     vconn_close(vconn);
1577 }
1578
1579 static void
1580 ofctl_packet_out(int argc, char *argv[])
1581 {
1582     enum ofputil_protocol protocol;
1583     struct ofputil_packet_out po;
1584     struct ofpbuf ofpacts;
1585     struct vconn *vconn;
1586     char *error;
1587     int i;
1588     enum ofputil_protocol usable_protocols; /* TODO: Use in proto selection */
1589
1590     ofpbuf_init(&ofpacts, 64);
1591     error = parse_ofpacts(argv[3], &ofpacts, &usable_protocols);
1592     if (error) {
1593         ovs_fatal(0, "%s", error);
1594     }
1595
1596     po.buffer_id = UINT32_MAX;
1597     po.in_port = str_to_port_no(argv[1], argv[2]);
1598     po.ofpacts = ofpacts.data;
1599     po.ofpacts_len = ofpacts.size;
1600
1601     protocol = open_vconn(argv[1], &vconn);
1602     for (i = 4; i < argc; i++) {
1603         struct ofpbuf *packet, *opo;
1604         const char *error_msg;
1605
1606         error_msg = eth_from_hex(argv[i], &packet);
1607         if (error_msg) {
1608             ovs_fatal(0, "%s", error_msg);
1609         }
1610
1611         po.packet = packet->data;
1612         po.packet_len = packet->size;
1613         opo = ofputil_encode_packet_out(&po, protocol);
1614         transact_noreply(vconn, opo);
1615         ofpbuf_delete(packet);
1616     }
1617     vconn_close(vconn);
1618     ofpbuf_uninit(&ofpacts);
1619 }
1620
1621 static void
1622 ofctl_mod_port(int argc OVS_UNUSED, char *argv[])
1623 {
1624     struct ofp_config_flag {
1625         const char *name;             /* The flag's name. */
1626         enum ofputil_port_config bit; /* Bit to turn on or off. */
1627         bool on;                      /* Value to set the bit to. */
1628     };
1629     static const struct ofp_config_flag flags[] = {
1630         { "up",          OFPUTIL_PC_PORT_DOWN,    false },
1631         { "down",        OFPUTIL_PC_PORT_DOWN,    true  },
1632         { "stp",         OFPUTIL_PC_NO_STP,       false },
1633         { "receive",     OFPUTIL_PC_NO_RECV,      false },
1634         { "receive-stp", OFPUTIL_PC_NO_RECV_STP,  false },
1635         { "flood",       OFPUTIL_PC_NO_FLOOD,     false },
1636         { "forward",     OFPUTIL_PC_NO_FWD,       false },
1637         { "packet-in",   OFPUTIL_PC_NO_PACKET_IN, false },
1638     };
1639
1640     const struct ofp_config_flag *flag;
1641     enum ofputil_protocol protocol;
1642     struct ofputil_port_mod pm;
1643     struct ofputil_phy_port pp;
1644     struct vconn *vconn;
1645     const char *command;
1646     bool not;
1647
1648     fetch_ofputil_phy_port(argv[1], argv[2], &pp);
1649
1650     pm.port_no = pp.port_no;
1651     memcpy(pm.hw_addr, pp.hw_addr, ETH_ADDR_LEN);
1652     pm.config = 0;
1653     pm.mask = 0;
1654     pm.advertise = 0;
1655
1656     if (!strncasecmp(argv[3], "no-", 3)) {
1657         command = argv[3] + 3;
1658         not = true;
1659     } else if (!strncasecmp(argv[3], "no", 2)) {
1660         command = argv[3] + 2;
1661         not = true;
1662     } else {
1663         command = argv[3];
1664         not = false;
1665     }
1666     for (flag = flags; flag < &flags[ARRAY_SIZE(flags)]; flag++) {
1667         if (!strcasecmp(command, flag->name)) {
1668             pm.mask = flag->bit;
1669             pm.config = flag->on ^ not ? flag->bit : 0;
1670             goto found;
1671         }
1672     }
1673     ovs_fatal(0, "unknown mod-port command '%s'", argv[3]);
1674
1675 found:
1676     protocol = open_vconn(argv[1], &vconn);
1677     transact_noreply(vconn, ofputil_encode_port_mod(&pm, protocol));
1678     vconn_close(vconn);
1679 }
1680
1681 static void
1682 ofctl_mod_table(int argc OVS_UNUSED, char *argv[])
1683 {
1684     enum ofputil_protocol protocol, usable_protocols;
1685     struct ofputil_table_mod tm;
1686     struct vconn *vconn;
1687     char *error;
1688     int i;
1689
1690     error = parse_ofp_table_mod(&tm, argv[2], argv[3], &usable_protocols);
1691     if (error) {
1692         ovs_fatal(0, "%s", error);
1693     }
1694
1695     protocol = open_vconn(argv[1], &vconn);
1696     if (!(protocol & usable_protocols)) {
1697         for (i = 0; i < sizeof(enum ofputil_protocol) * CHAR_BIT; i++) {
1698             enum ofputil_protocol f = 1 << i;
1699             if (f != protocol
1700                 && f & usable_protocols
1701                 && try_set_protocol(vconn, f, &protocol)) {
1702                 protocol = f;
1703                 break;
1704             }
1705         }
1706     }
1707
1708     if (!(protocol & usable_protocols)) {
1709         char *usable_s = ofputil_protocols_to_string(usable_protocols);
1710         ovs_fatal(0, "Switch does not support table mod message(%s)", usable_s);
1711     }
1712
1713     transact_noreply(vconn, ofputil_encode_table_mod(&tm, protocol));
1714     vconn_close(vconn);
1715 }
1716
1717 static void
1718 ofctl_get_frags(int argc OVS_UNUSED, char *argv[])
1719 {
1720     struct ofp_switch_config config;
1721     struct vconn *vconn;
1722
1723     open_vconn(argv[1], &vconn);
1724     fetch_switch_config(vconn, &config);
1725     puts(ofputil_frag_handling_to_string(ntohs(config.flags)));
1726     vconn_close(vconn);
1727 }
1728
1729 static void
1730 ofctl_set_frags(int argc OVS_UNUSED, char *argv[])
1731 {
1732     struct ofp_switch_config config;
1733     enum ofp_config_flags mode;
1734     struct vconn *vconn;
1735     ovs_be16 flags;
1736
1737     if (!ofputil_frag_handling_from_string(argv[2], &mode)) {
1738         ovs_fatal(0, "%s: unknown fragment handling mode", argv[2]);
1739     }
1740
1741     open_vconn(argv[1], &vconn);
1742     fetch_switch_config(vconn, &config);
1743     flags = htons(mode) | (config.flags & htons(~OFPC_FRAG_MASK));
1744     if (flags != config.flags) {
1745         /* Set the configuration. */
1746         config.flags = flags;
1747         set_switch_config(vconn, &config);
1748
1749         /* Then retrieve the configuration to see if it really took.  OpenFlow
1750          * doesn't define error reporting for bad modes, so this is all we can
1751          * do. */
1752         fetch_switch_config(vconn, &config);
1753         if (flags != config.flags) {
1754             ovs_fatal(0, "%s: setting fragment handling mode failed (this "
1755                       "switch probably doesn't support mode \"%s\")",
1756                       argv[1], ofputil_frag_handling_to_string(mode));
1757         }
1758     }
1759     vconn_close(vconn);
1760 }
1761
1762 static void
1763 ofctl_ofp_parse(int argc OVS_UNUSED, char *argv[])
1764 {
1765     const char *filename = argv[1];
1766     struct ofpbuf b;
1767     FILE *file;
1768
1769     file = !strcmp(filename, "-") ? stdin : fopen(filename, "r");
1770     if (file == NULL) {
1771         ovs_fatal(errno, "%s: open", filename);
1772     }
1773
1774     ofpbuf_init(&b, 65536);
1775     for (;;) {
1776         struct ofp_header *oh;
1777         size_t length, tail_len;
1778         void *tail;
1779         size_t n;
1780
1781         ofpbuf_clear(&b);
1782         oh = ofpbuf_put_uninit(&b, sizeof *oh);
1783         n = fread(oh, 1, sizeof *oh, file);
1784         if (n == 0) {
1785             break;
1786         } else if (n < sizeof *oh) {
1787             ovs_fatal(0, "%s: unexpected end of file mid-message", filename);
1788         }
1789
1790         length = ntohs(oh->length);
1791         if (length < sizeof *oh) {
1792             ovs_fatal(0, "%s: %zu-byte message is too short for OpenFlow",
1793                       filename, length);
1794         }
1795
1796         tail_len = length - sizeof *oh;
1797         tail = ofpbuf_put_uninit(&b, tail_len);
1798         n = fread(tail, 1, tail_len, file);
1799         if (n < tail_len) {
1800             ovs_fatal(0, "%s: unexpected end of file mid-message", filename);
1801         }
1802
1803         ofp_print(stdout, b.data, b.size, verbosity + 2);
1804     }
1805     ofpbuf_uninit(&b);
1806
1807     if (file != stdin) {
1808         fclose(file);
1809     }
1810 }
1811
1812 static void
1813 ofctl_ping(int argc, char *argv[])
1814 {
1815     size_t max_payload = 65535 - sizeof(struct ofp_header);
1816     unsigned int payload;
1817     struct vconn *vconn;
1818     int i;
1819
1820     payload = argc > 2 ? atoi(argv[2]) : 64;
1821     if (payload > max_payload) {
1822         ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload);
1823     }
1824
1825     open_vconn(argv[1], &vconn);
1826     for (i = 0; i < 10; i++) {
1827         struct timeval start, end;
1828         struct ofpbuf *request, *reply;
1829         const struct ofp_header *rpy_hdr;
1830         enum ofptype type;
1831
1832         request = ofpraw_alloc(OFPRAW_OFPT_ECHO_REQUEST,
1833                                vconn_get_version(vconn), payload);
1834         random_bytes(ofpbuf_put_uninit(request, payload), payload);
1835
1836         xgettimeofday(&start);
1837         run(vconn_transact(vconn, ofpbuf_clone(request), &reply), "transact");
1838         xgettimeofday(&end);
1839
1840         rpy_hdr = reply->data;
1841         if (ofptype_pull(&type, reply)
1842             || type != OFPTYPE_ECHO_REPLY
1843             || reply->size != payload
1844             || memcmp(request->l3, reply->l3, payload)) {
1845             printf("Reply does not match request.  Request:\n");
1846             ofp_print(stdout, request, request->size, verbosity + 2);
1847             printf("Reply:\n");
1848             ofp_print(stdout, reply, reply->size, verbosity + 2);
1849         }
1850         printf("%zu bytes from %s: xid=%08"PRIx32" time=%.1f ms\n",
1851                reply->size, argv[1], ntohl(rpy_hdr->xid),
1852                    (1000*(double)(end.tv_sec - start.tv_sec))
1853                    + (.001*(end.tv_usec - start.tv_usec)));
1854         ofpbuf_delete(request);
1855         ofpbuf_delete(reply);
1856     }
1857     vconn_close(vconn);
1858 }
1859
1860 static void
1861 ofctl_benchmark(int argc OVS_UNUSED, char *argv[])
1862 {
1863     size_t max_payload = 65535 - sizeof(struct ofp_header);
1864     struct timeval start, end;
1865     unsigned int payload_size, message_size;
1866     struct vconn *vconn;
1867     double duration;
1868     int count;
1869     int i;
1870
1871     payload_size = atoi(argv[2]);
1872     if (payload_size > max_payload) {
1873         ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload);
1874     }
1875     message_size = sizeof(struct ofp_header) + payload_size;
1876
1877     count = atoi(argv[3]);
1878
1879     printf("Sending %d packets * %u bytes (with header) = %u bytes total\n",
1880            count, message_size, count * message_size);
1881
1882     open_vconn(argv[1], &vconn);
1883     xgettimeofday(&start);
1884     for (i = 0; i < count; i++) {
1885         struct ofpbuf *request, *reply;
1886
1887         request = ofpraw_alloc(OFPRAW_OFPT_ECHO_REQUEST,
1888                                vconn_get_version(vconn), payload_size);
1889         ofpbuf_put_zeros(request, payload_size);
1890         run(vconn_transact(vconn, request, &reply), "transact");
1891         ofpbuf_delete(reply);
1892     }
1893     xgettimeofday(&end);
1894     vconn_close(vconn);
1895
1896     duration = ((1000*(double)(end.tv_sec - start.tv_sec))
1897                 + (.001*(end.tv_usec - start.tv_usec)));
1898     printf("Finished in %.1f ms (%.0f packets/s) (%.0f bytes/s)\n",
1899            duration, count / (duration / 1000.0),
1900            count * message_size / (duration / 1000.0));
1901 }
1902
1903 static void
1904 ofctl_group_mod__(const char *remote, struct ofputil_group_mod *gms,
1905                  size_t n_gms)
1906 {
1907     struct ofputil_group_mod *gm;
1908     struct ofpbuf *request;
1909
1910     struct vconn *vconn;
1911     size_t i;
1912
1913     open_vconn(remote, &vconn);
1914
1915     for (i = 0; i < n_gms; i++) {
1916         gm = &gms[i];
1917         request = ofputil_encode_group_mod(vconn_get_version(vconn), gm);
1918         if (request) {
1919             transact_noreply(vconn, request);
1920         }
1921     }
1922
1923     vconn_close(vconn);
1924
1925 }
1926
1927
1928 static void
1929 ofctl_group_mod_file(int argc OVS_UNUSED, char *argv[], uint16_t command)
1930 {
1931     struct ofputil_group_mod *gms = NULL;
1932     enum ofputil_protocol usable_protocols;
1933     size_t n_gms = 0;
1934     char *error;
1935
1936     error = parse_ofp_group_mod_file(argv[2], command, &gms, &n_gms,
1937                                      &usable_protocols);
1938     if (error) {
1939         ovs_fatal(0, "%s", error);
1940     }
1941     ofctl_group_mod__(argv[1], gms, n_gms);
1942     free(gms);
1943 }
1944
1945 static void
1946 ofctl_group_mod(int argc, char *argv[], uint16_t command)
1947 {
1948     if (argc > 2 && !strcmp(argv[2], "-")) {
1949         ofctl_group_mod_file(argc, argv, command);
1950     } else {
1951         enum ofputil_protocol usable_protocols;
1952         struct ofputil_group_mod gm;
1953         char *error;
1954
1955         error = parse_ofp_group_mod_str(&gm, command, argc > 2 ? argv[2] : "",
1956                                         &usable_protocols);
1957         if (error) {
1958             ovs_fatal(0, "%s", error);
1959         }
1960         ofctl_group_mod__(argv[1], &gm, 1);
1961     }
1962 }
1963
1964 static void
1965 ofctl_add_group(int argc, char *argv[])
1966 {
1967     ofctl_group_mod(argc, argv, OFPGC11_ADD);
1968 }
1969
1970 static void
1971 ofctl_add_groups(int argc, char *argv[])
1972 {
1973     ofctl_group_mod_file(argc, argv, OFPGC11_ADD);
1974 }
1975
1976 static void
1977 ofctl_mod_group(int argc, char *argv[])
1978 {
1979     ofctl_group_mod(argc, argv, OFPGC11_MODIFY);
1980 }
1981
1982 static void
1983 ofctl_del_groups(int argc, char *argv[])
1984 {
1985     ofctl_group_mod(argc, argv, OFPGC11_DELETE);
1986 }
1987
1988 static void
1989 ofctl_dump_group_stats(int argc, char *argv[])
1990 {
1991     enum ofputil_protocol usable_protocols;
1992     struct ofputil_group_mod gm;
1993     struct ofpbuf *request;
1994     struct vconn *vconn;
1995     uint32_t group_id;
1996     char *error;
1997
1998     memset(&gm, 0, sizeof gm);
1999
2000     error = parse_ofp_group_mod_str(&gm, OFPGC11_DELETE,
2001                                     argc > 2 ? argv[2] : "",
2002                                     &usable_protocols);
2003     if (error) {
2004         ovs_fatal(0, "%s", error);
2005     }
2006
2007     group_id = gm.group_id;
2008
2009     open_vconn(argv[1], &vconn);
2010     request = ofputil_encode_group_stats_request(vconn_get_version(vconn),
2011                                                  group_id);
2012     if (request) {
2013         dump_stats_transaction(vconn, request);
2014     }
2015
2016     vconn_close(vconn);
2017 }
2018
2019 static void
2020 ofctl_dump_group_desc(int argc OVS_UNUSED, char *argv[])
2021 {
2022     struct ofpbuf *request;
2023     struct vconn *vconn;
2024
2025     open_vconn(argv[1], &vconn);
2026
2027     request = ofputil_encode_group_desc_request(vconn_get_version(vconn));
2028     if (request) {
2029         dump_stats_transaction(vconn, request);
2030     }
2031
2032     vconn_close(vconn);
2033 }
2034
2035 static void
2036 ofctl_dump_group_features(int argc OVS_UNUSED, char *argv[])
2037 {
2038     struct ofpbuf *request;
2039     struct vconn *vconn;
2040
2041     open_vconn(argv[1], &vconn);
2042     request = ofputil_encode_group_features_request(vconn_get_version(vconn));
2043     if (request) {
2044         dump_stats_transaction(vconn, request);
2045     }
2046
2047     vconn_close(vconn);
2048 }
2049
2050 static void
2051 ofctl_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2052 {
2053     usage();
2054 }
2055 \f
2056 /* replace-flows and diff-flows commands. */
2057
2058 /* A flow table entry, possibly with two different versions. */
2059 struct fte {
2060     struct cls_rule rule;       /* Within a "struct classifier". */
2061     struct fte_version *versions[2];
2062 };
2063
2064 /* One version of a Flow Table Entry. */
2065 struct fte_version {
2066     ovs_be64 cookie;
2067     uint16_t idle_timeout;
2068     uint16_t hard_timeout;
2069     uint16_t flags;
2070     struct ofpact *ofpacts;
2071     size_t ofpacts_len;
2072 };
2073
2074 /* Frees 'version' and the data that it owns. */
2075 static void
2076 fte_version_free(struct fte_version *version)
2077 {
2078     if (version) {
2079         free(version->ofpacts);
2080         free(version);
2081     }
2082 }
2083
2084 /* Returns true if 'a' and 'b' are the same, false if they differ.
2085  *
2086  * Ignores differences in 'flags' because there's no way to retrieve flags from
2087  * an OpenFlow switch.  We have to assume that they are the same. */
2088 static bool
2089 fte_version_equals(const struct fte_version *a, const struct fte_version *b)
2090 {
2091     return (a->cookie == b->cookie
2092             && a->idle_timeout == b->idle_timeout
2093             && a->hard_timeout == b->hard_timeout
2094             && ofpacts_equal(a->ofpacts, a->ofpacts_len,
2095                              b->ofpacts, b->ofpacts_len));
2096 }
2097
2098 /* Clears 's', then if 's' has a version 'index', formats 'fte' and version
2099  * 'index' into 's', followed by a new-line. */
2100 static void
2101 fte_version_format(const struct fte *fte, int index, struct ds *s)
2102 {
2103     const struct fte_version *version = fte->versions[index];
2104
2105     ds_clear(s);
2106     if (!version) {
2107         return;
2108     }
2109
2110     cls_rule_format(&fte->rule, s);
2111     if (version->cookie != htonll(0)) {
2112         ds_put_format(s, " cookie=0x%"PRIx64, ntohll(version->cookie));
2113     }
2114     if (version->idle_timeout != OFP_FLOW_PERMANENT) {
2115         ds_put_format(s, " idle_timeout=%"PRIu16, version->idle_timeout);
2116     }
2117     if (version->hard_timeout != OFP_FLOW_PERMANENT) {
2118         ds_put_format(s, " hard_timeout=%"PRIu16, version->hard_timeout);
2119     }
2120
2121     ds_put_cstr(s, " actions=");
2122     ofpacts_format(version->ofpacts, version->ofpacts_len, s);
2123
2124     ds_put_char(s, '\n');
2125 }
2126
2127 static struct fte *
2128 fte_from_cls_rule(const struct cls_rule *cls_rule)
2129 {
2130     return cls_rule ? CONTAINER_OF(cls_rule, struct fte, rule) : NULL;
2131 }
2132
2133 /* Frees 'fte' and its versions. */
2134 static void
2135 fte_free(struct fte *fte)
2136 {
2137     if (fte) {
2138         fte_version_free(fte->versions[0]);
2139         fte_version_free(fte->versions[1]);
2140         cls_rule_destroy(&fte->rule);
2141         free(fte);
2142     }
2143 }
2144
2145 /* Frees all of the FTEs within 'cls'. */
2146 static void
2147 fte_free_all(struct classifier *cls)
2148 {
2149     struct cls_cursor cursor;
2150     struct fte *fte, *next;
2151
2152     ovs_rwlock_wrlock(&cls->rwlock);
2153     cls_cursor_init(&cursor, cls, NULL);
2154     CLS_CURSOR_FOR_EACH_SAFE (fte, next, rule, &cursor) {
2155         classifier_remove(cls, &fte->rule);
2156         fte_free(fte);
2157     }
2158     ovs_rwlock_unlock(&cls->rwlock);
2159     classifier_destroy(cls);
2160 }
2161
2162 /* Searches 'cls' for an FTE matching 'rule', inserting a new one if
2163  * necessary.  Sets 'version' as the version of that rule with the given
2164  * 'index', replacing any existing version, if any.
2165  *
2166  * Takes ownership of 'version'. */
2167 static void
2168 fte_insert(struct classifier *cls, const struct match *match,
2169            unsigned int priority, struct fte_version *version, int index)
2170 {
2171     struct fte *old, *fte;
2172
2173     fte = xzalloc(sizeof *fte);
2174     cls_rule_init(&fte->rule, match, priority);
2175     fte->versions[index] = version;
2176
2177     ovs_rwlock_wrlock(&cls->rwlock);
2178     old = fte_from_cls_rule(classifier_replace(cls, &fte->rule));
2179     ovs_rwlock_unlock(&cls->rwlock);
2180     if (old) {
2181         fte_version_free(old->versions[index]);
2182         fte->versions[!index] = old->versions[!index];
2183         cls_rule_destroy(&old->rule);
2184         free(old);
2185     }
2186 }
2187
2188 /* Reads the flows in 'filename' as flow table entries in 'cls' for the version
2189  * with the specified 'index'.  Returns the flow formats able to represent the
2190  * flows that were read. */
2191 static enum ofputil_protocol
2192 read_flows_from_file(const char *filename, struct classifier *cls, int index)
2193 {
2194     enum ofputil_protocol usable_protocols;
2195     int line_number;
2196     struct ds s;
2197     FILE *file;
2198
2199     file = !strcmp(filename, "-") ? stdin : fopen(filename, "r");
2200     if (file == NULL) {
2201         ovs_fatal(errno, "%s: open", filename);
2202     }
2203
2204     ds_init(&s);
2205     usable_protocols = OFPUTIL_P_ANY;
2206     line_number = 0;
2207     while (!ds_get_preprocessed_line(&s, file, &line_number)) {
2208         struct fte_version *version;
2209         struct ofputil_flow_mod fm;
2210         char *error;
2211         enum ofputil_protocol usable;
2212
2213         error = parse_ofp_str(&fm, OFPFC_ADD, ds_cstr(&s), &usable,
2214                               !(allowed_protocols & OFPUTIL_P_OF10_ANY));
2215         if (error) {
2216             ovs_fatal(0, "%s:%d: %s", filename, line_number, error);
2217         }
2218         usable_protocols &= usable;
2219
2220         version = xmalloc(sizeof *version);
2221         version->cookie = fm.new_cookie;
2222         version->idle_timeout = fm.idle_timeout;
2223         version->hard_timeout = fm.hard_timeout;
2224         version->flags = fm.flags & (OFPUTIL_FF_SEND_FLOW_REM
2225                                      | OFPUTIL_FF_EMERG);
2226         version->ofpacts = fm.ofpacts;
2227         version->ofpacts_len = fm.ofpacts_len;
2228
2229         fte_insert(cls, &fm.match, fm.priority, version, index);
2230     }
2231     ds_destroy(&s);
2232
2233     if (file != stdin) {
2234         fclose(file);
2235     }
2236
2237     return usable_protocols;
2238 }
2239
2240 static bool
2241 recv_flow_stats_reply(struct vconn *vconn, ovs_be32 send_xid,
2242                       struct ofpbuf **replyp,
2243                       struct ofputil_flow_stats *fs, struct ofpbuf *ofpacts)
2244 {
2245     struct ofpbuf *reply = *replyp;
2246
2247     for (;;) {
2248         int retval;
2249         bool more;
2250
2251         /* Get a flow stats reply message, if we don't already have one. */
2252         if (!reply) {
2253             enum ofptype type;
2254             enum ofperr error;
2255
2256             do {
2257                 run(vconn_recv_block(vconn, &reply),
2258                     "OpenFlow packet receive failed");
2259             } while (((struct ofp_header *) reply->data)->xid != send_xid);
2260
2261             error = ofptype_decode(&type, reply->data);
2262             if (error || type != OFPTYPE_FLOW_STATS_REPLY) {
2263                 ovs_fatal(0, "received bad reply: %s",
2264                           ofp_to_string(reply->data, reply->size,
2265                                         verbosity + 1));
2266             }
2267         }
2268
2269         /* Pull an individual flow stats reply out of the message. */
2270         retval = ofputil_decode_flow_stats_reply(fs, reply, false, ofpacts);
2271         switch (retval) {
2272         case 0:
2273             *replyp = reply;
2274             return true;
2275
2276         case EOF:
2277             more = ofpmp_more(reply->l2);
2278             ofpbuf_delete(reply);
2279             reply = NULL;
2280             if (!more) {
2281                 *replyp = NULL;
2282                 return false;
2283             }
2284             break;
2285
2286         default:
2287             ovs_fatal(0, "parse error in reply (%s)",
2288                       ofperr_to_string(retval));
2289         }
2290     }
2291 }
2292
2293 /* Reads the OpenFlow flow table from 'vconn', which has currently active flow
2294  * format 'protocol', and adds them as flow table entries in 'cls' for the
2295  * version with the specified 'index'. */
2296 static void
2297 read_flows_from_switch(struct vconn *vconn,
2298                        enum ofputil_protocol protocol,
2299                        struct classifier *cls, int index)
2300 {
2301     struct ofputil_flow_stats_request fsr;
2302     struct ofputil_flow_stats fs;
2303     struct ofpbuf *request;
2304     struct ofpbuf ofpacts;
2305     struct ofpbuf *reply;
2306     ovs_be32 send_xid;
2307
2308     fsr.aggregate = false;
2309     match_init_catchall(&fsr.match);
2310     fsr.out_port = OFPP_ANY;
2311     fsr.table_id = 0xff;
2312     fsr.cookie = fsr.cookie_mask = htonll(0);
2313     request = ofputil_encode_flow_stats_request(&fsr, protocol);
2314     send_xid = ((struct ofp_header *) request->data)->xid;
2315     send_openflow_buffer(vconn, request);
2316
2317     reply = NULL;
2318     ofpbuf_init(&ofpacts, 0);
2319     while (recv_flow_stats_reply(vconn, send_xid, &reply, &fs, &ofpacts)) {
2320         struct fte_version *version;
2321
2322         version = xmalloc(sizeof *version);
2323         version->cookie = fs.cookie;
2324         version->idle_timeout = fs.idle_timeout;
2325         version->hard_timeout = fs.hard_timeout;
2326         version->flags = 0;
2327         version->ofpacts_len = fs.ofpacts_len;
2328         version->ofpacts = xmemdup(fs.ofpacts, fs.ofpacts_len);
2329
2330         fte_insert(cls, &fs.match, fs.priority, version, index);
2331     }
2332     ofpbuf_uninit(&ofpacts);
2333 }
2334
2335 static void
2336 fte_make_flow_mod(const struct fte *fte, int index, uint16_t command,
2337                   enum ofputil_protocol protocol, struct list *packets)
2338 {
2339     const struct fte_version *version = fte->versions[index];
2340     struct ofputil_flow_mod fm;
2341     struct ofpbuf *ofm;
2342
2343     minimatch_expand(&fte->rule.match, &fm.match);
2344     fm.priority = fte->rule.priority;
2345     fm.cookie = htonll(0);
2346     fm.cookie_mask = htonll(0);
2347     fm.new_cookie = version->cookie;
2348     fm.modify_cookie = true;
2349     fm.table_id = 0xff;
2350     fm.command = command;
2351     fm.idle_timeout = version->idle_timeout;
2352     fm.hard_timeout = version->hard_timeout;
2353     fm.buffer_id = UINT32_MAX;
2354     fm.out_port = OFPP_ANY;
2355     fm.flags = version->flags;
2356     if (command == OFPFC_ADD || command == OFPFC_MODIFY ||
2357         command == OFPFC_MODIFY_STRICT) {
2358         fm.ofpacts = version->ofpacts;
2359         fm.ofpacts_len = version->ofpacts_len;
2360     } else {
2361         fm.ofpacts = NULL;
2362         fm.ofpacts_len = 0;
2363     }
2364
2365     ofm = ofputil_encode_flow_mod(&fm, protocol);
2366     list_push_back(packets, &ofm->list_node);
2367 }
2368
2369 static void
2370 ofctl_replace_flows(int argc OVS_UNUSED, char *argv[])
2371 {
2372     enum { FILE_IDX = 0, SWITCH_IDX = 1 };
2373     enum ofputil_protocol usable_protocols, protocol;
2374     struct cls_cursor cursor;
2375     struct classifier cls;
2376     struct list requests;
2377     struct vconn *vconn;
2378     struct fte *fte;
2379
2380     classifier_init(&cls);
2381     usable_protocols = read_flows_from_file(argv[2], &cls, FILE_IDX);
2382
2383     protocol = open_vconn(argv[1], &vconn);
2384     protocol = set_protocol_for_flow_dump(vconn, protocol, usable_protocols);
2385
2386     read_flows_from_switch(vconn, protocol, &cls, SWITCH_IDX);
2387
2388     list_init(&requests);
2389
2390     /* Delete flows that exist on the switch but not in the file. */
2391     ovs_rwlock_rdlock(&cls.rwlock);
2392     cls_cursor_init(&cursor, &cls, NULL);
2393     CLS_CURSOR_FOR_EACH (fte, rule, &cursor) {
2394         struct fte_version *file_ver = fte->versions[FILE_IDX];
2395         struct fte_version *sw_ver = fte->versions[SWITCH_IDX];
2396
2397         if (sw_ver && !file_ver) {
2398             fte_make_flow_mod(fte, SWITCH_IDX, OFPFC_DELETE_STRICT,
2399                               protocol, &requests);
2400         }
2401     }
2402
2403     /* Add flows that exist in the file but not on the switch.
2404      * Update flows that exist in both places but differ. */
2405     cls_cursor_init(&cursor, &cls, NULL);
2406     CLS_CURSOR_FOR_EACH (fte, rule, &cursor) {
2407         struct fte_version *file_ver = fte->versions[FILE_IDX];
2408         struct fte_version *sw_ver = fte->versions[SWITCH_IDX];
2409
2410         if (file_ver
2411             && (readd || !sw_ver || !fte_version_equals(sw_ver, file_ver))) {
2412             fte_make_flow_mod(fte, FILE_IDX, OFPFC_ADD, protocol, &requests);
2413         }
2414     }
2415     ovs_rwlock_unlock(&cls.rwlock);
2416     transact_multiple_noreply(vconn, &requests);
2417     vconn_close(vconn);
2418
2419     fte_free_all(&cls);
2420 }
2421
2422 static void
2423 read_flows_from_source(const char *source, struct classifier *cls, int index)
2424 {
2425     struct stat s;
2426
2427     if (source[0] == '/' || source[0] == '.'
2428         || (!strchr(source, ':') && !stat(source, &s))) {
2429         read_flows_from_file(source, cls, index);
2430     } else {
2431         enum ofputil_protocol protocol;
2432         struct vconn *vconn;
2433
2434         protocol = open_vconn(source, &vconn);
2435         protocol = set_protocol_for_flow_dump(vconn, protocol, OFPUTIL_P_ANY);
2436         read_flows_from_switch(vconn, protocol, cls, index);
2437         vconn_close(vconn);
2438     }
2439 }
2440
2441 static void
2442 ofctl_diff_flows(int argc OVS_UNUSED, char *argv[])
2443 {
2444     bool differences = false;
2445     struct cls_cursor cursor;
2446     struct classifier cls;
2447     struct ds a_s, b_s;
2448     struct fte *fte;
2449
2450     classifier_init(&cls);
2451     read_flows_from_source(argv[1], &cls, 0);
2452     read_flows_from_source(argv[2], &cls, 1);
2453
2454     ds_init(&a_s);
2455     ds_init(&b_s);
2456
2457     ovs_rwlock_rdlock(&cls.rwlock);
2458     cls_cursor_init(&cursor, &cls, NULL);
2459     CLS_CURSOR_FOR_EACH (fte, rule, &cursor) {
2460         struct fte_version *a = fte->versions[0];
2461         struct fte_version *b = fte->versions[1];
2462
2463         if (!a || !b || !fte_version_equals(a, b)) {
2464             fte_version_format(fte, 0, &a_s);
2465             fte_version_format(fte, 1, &b_s);
2466             if (strcmp(ds_cstr(&a_s), ds_cstr(&b_s))) {
2467                 if (a_s.length) {
2468                     printf("-%s", ds_cstr(&a_s));
2469                 }
2470                 if (b_s.length) {
2471                     printf("+%s", ds_cstr(&b_s));
2472                 }
2473                 differences = true;
2474             }
2475         }
2476     }
2477     ovs_rwlock_unlock(&cls.rwlock);
2478
2479     ds_destroy(&a_s);
2480     ds_destroy(&b_s);
2481
2482     fte_free_all(&cls);
2483
2484     if (differences) {
2485         exit(2);
2486     }
2487 }
2488
2489 static void
2490 ofctl_meter_mod__(const char *bridge, const char *str, int command)
2491 {
2492     struct ofputil_meter_mod mm;
2493     struct vconn *vconn;
2494     enum ofputil_protocol protocol;
2495     enum ofputil_protocol usable_protocols;
2496     enum ofp_version version;
2497
2498     if (str) {
2499         char *error;
2500         error = parse_ofp_meter_mod_str(&mm, str, command, &usable_protocols);
2501         if (error) {
2502             ovs_fatal(0, "%s", error);
2503         }
2504     } else {
2505         usable_protocols = OFPUTIL_P_OF13_UP;
2506         mm.command = command;
2507         mm.meter.meter_id = OFPM13_ALL;
2508     }
2509
2510     protocol = open_vconn_for_flow_mod(bridge, &vconn, usable_protocols);
2511     version = ofputil_protocol_to_ofp_version(protocol);
2512     transact_noreply(vconn, ofputil_encode_meter_mod(version, &mm));
2513     vconn_close(vconn);
2514 }
2515
2516 static void
2517 ofctl_meter_request__(const char *bridge, const char *str,
2518                       enum ofputil_meter_request_type type)
2519 {
2520     struct ofputil_meter_mod mm;
2521     struct vconn *vconn;
2522     enum ofputil_protocol usable_protocols;
2523     enum ofputil_protocol protocol;
2524     enum ofp_version version;
2525
2526     if (str) {
2527         char *error;
2528         error = parse_ofp_meter_mod_str(&mm, str, -1, &usable_protocols);
2529         if (error) {
2530             ovs_fatal(0, "%s", error);
2531         }
2532     } else {
2533         usable_protocols = OFPUTIL_P_OF13_UP;
2534         mm.meter.meter_id = OFPM13_ALL;
2535     }
2536
2537     protocol = open_vconn_for_flow_mod(bridge, &vconn, usable_protocols);
2538     version = ofputil_protocol_to_ofp_version(protocol);
2539     transact_noreply(vconn, ofputil_encode_meter_request(version,
2540                                                          type,
2541                                                          mm.meter.meter_id));
2542     vconn_close(vconn);
2543 }
2544
2545
2546 static void
2547 ofctl_add_meter(int argc OVS_UNUSED, char *argv[])
2548 {
2549     ofctl_meter_mod__(argv[1], argv[2], OFPMC13_ADD);
2550 }
2551
2552 static void
2553 ofctl_mod_meter(int argc OVS_UNUSED, char *argv[])
2554 {
2555     ofctl_meter_mod__(argv[1], argv[2], OFPMC13_MODIFY);
2556 }
2557
2558 static void
2559 ofctl_del_meters(int argc, char *argv[])
2560 {
2561     ofctl_meter_mod__(argv[1], argc > 2 ? argv[2] : NULL, OFPMC13_DELETE);
2562 }
2563
2564 static void
2565 ofctl_dump_meters(int argc, char *argv[])
2566 {
2567     ofctl_meter_request__(argv[1], argc > 2 ? argv[2] : NULL,
2568                           OFPUTIL_METER_CONFIG);
2569 }
2570
2571 static void
2572 ofctl_meter_stats(int argc, char *argv[])
2573 {
2574     ofctl_meter_request__(argv[1], argc > 2 ? argv[2] : NULL,
2575                           OFPUTIL_METER_STATS);
2576 }
2577
2578 static void
2579 ofctl_meter_features(int argc OVS_UNUSED, char *argv[])
2580 {
2581     ofctl_meter_request__(argv[1], NULL, OFPUTIL_METER_FEATURES);
2582 }
2583
2584 \f
2585 /* Undocumented commands for unit testing. */
2586
2587 static void
2588 ofctl_parse_flows__(struct ofputil_flow_mod *fms, size_t n_fms,
2589                     enum ofputil_protocol usable_protocols)
2590 {
2591     enum ofputil_protocol protocol = 0;
2592     char *usable_s;
2593     size_t i;
2594
2595     usable_s = ofputil_protocols_to_string(usable_protocols);
2596     printf("usable protocols: %s\n", usable_s);
2597     free(usable_s);
2598
2599     if (!(usable_protocols & allowed_protocols)) {
2600         ovs_fatal(0, "no usable protocol");
2601     }
2602     for (i = 0; i < sizeof(enum ofputil_protocol) * CHAR_BIT; i++) {
2603         protocol = 1 << i;
2604         if (protocol & usable_protocols & allowed_protocols) {
2605             break;
2606         }
2607     }
2608     ovs_assert(is_pow2(protocol));
2609
2610     printf("chosen protocol: %s\n", ofputil_protocol_to_string(protocol));
2611
2612     for (i = 0; i < n_fms; i++) {
2613         struct ofputil_flow_mod *fm = &fms[i];
2614         struct ofpbuf *msg;
2615
2616         msg = ofputil_encode_flow_mod(fm, protocol);
2617         ofp_print(stdout, msg->data, msg->size, verbosity);
2618         ofpbuf_delete(msg);
2619
2620         free(fm->ofpacts);
2621     }
2622 }
2623
2624 /* "parse-flow FLOW": parses the argument as a flow (like add-flow) and prints
2625  * it back to stdout.  */
2626 static void
2627 ofctl_parse_flow(int argc OVS_UNUSED, char *argv[])
2628 {
2629     enum ofputil_protocol usable_protocols;
2630     struct ofputil_flow_mod fm;
2631     char *error;
2632
2633     error = parse_ofp_flow_mod_str(&fm, argv[1], OFPFC_ADD, &usable_protocols,
2634                                    !(allowed_protocols & OFPUTIL_P_OF10_ANY));
2635     if (error) {
2636         ovs_fatal(0, "%s", error);
2637     }
2638     ofctl_parse_flows__(&fm, 1, usable_protocols);
2639 }
2640
2641 /* "parse-flows FILENAME": reads the named file as a sequence of flows (like
2642  * add-flows) and prints each of the flows back to stdout.  */
2643 static void
2644 ofctl_parse_flows(int argc OVS_UNUSED, char *argv[])
2645 {
2646     enum ofputil_protocol usable_protocols;
2647     struct ofputil_flow_mod *fms = NULL;
2648     size_t n_fms = 0;
2649     char *error;
2650
2651     error = parse_ofp_flow_mod_file(argv[1], OFPFC_ADD, &fms, &n_fms,
2652                                     &usable_protocols,
2653                                     !(allowed_protocols & OFPUTIL_P_OF10_ANY));
2654     if (error) {
2655         ovs_fatal(0, "%s", error);
2656     }
2657     ofctl_parse_flows__(fms, n_fms, usable_protocols);
2658     free(fms);
2659 }
2660
2661 static void
2662 ofctl_parse_nxm__(bool oxm)
2663 {
2664     struct ds in;
2665
2666     ds_init(&in);
2667     while (!ds_get_test_line(&in, stdin)) {
2668         struct ofpbuf nx_match;
2669         struct match match;
2670         ovs_be64 cookie, cookie_mask;
2671         enum ofperr error;
2672         int match_len;
2673
2674         /* Convert string to nx_match. */
2675         ofpbuf_init(&nx_match, 0);
2676         if (oxm) {
2677             match_len = oxm_match_from_string(ds_cstr(&in), &nx_match);
2678         } else {
2679             match_len = nx_match_from_string(ds_cstr(&in), &nx_match);
2680         }
2681
2682         /* Convert nx_match to match. */
2683         if (strict) {
2684             if (oxm) {
2685                 error = oxm_pull_match(&nx_match, &match);
2686             } else {
2687                 error = nx_pull_match(&nx_match, match_len, &match,
2688                                       &cookie, &cookie_mask);
2689             }
2690         } else {
2691             if (oxm) {
2692                 error = oxm_pull_match_loose(&nx_match, &match);
2693             } else {
2694                 error = nx_pull_match_loose(&nx_match, match_len, &match,
2695                                             &cookie, &cookie_mask);
2696             }
2697         }
2698
2699
2700         if (!error) {
2701             char *out;
2702
2703             /* Convert match back to nx_match. */
2704             ofpbuf_uninit(&nx_match);
2705             ofpbuf_init(&nx_match, 0);
2706             if (oxm) {
2707                 match_len = oxm_put_match(&nx_match, &match);
2708                 out = oxm_match_to_string(&nx_match, match_len);
2709             } else {
2710                 match_len = nx_put_match(&nx_match, &match,
2711                                          cookie, cookie_mask);
2712                 out = nx_match_to_string(nx_match.data, match_len);
2713             }
2714
2715             puts(out);
2716             free(out);
2717         } else {
2718             printf("nx_pull_match() returned error %s\n",
2719                    ofperr_get_name(error));
2720         }
2721
2722         ofpbuf_uninit(&nx_match);
2723     }
2724     ds_destroy(&in);
2725 }
2726
2727 /* "parse-nxm": reads a series of NXM nx_match specifications as strings from
2728  * stdin, does some internal fussing with them, and then prints them back as
2729  * strings on stdout. */
2730 static void
2731 ofctl_parse_nxm(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2732 {
2733     return ofctl_parse_nxm__(false);
2734 }
2735
2736 /* "parse-oxm": reads a series of OXM nx_match specifications as strings from
2737  * stdin, does some internal fussing with them, and then prints them back as
2738  * strings on stdout. */
2739 static void
2740 ofctl_parse_oxm(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2741 {
2742     return ofctl_parse_nxm__(true);
2743 }
2744
2745 static void
2746 print_differences(const char *prefix,
2747                   const void *a_, size_t a_len,
2748                   const void *b_, size_t b_len)
2749 {
2750     const uint8_t *a = a_;
2751     const uint8_t *b = b_;
2752     size_t i;
2753
2754     for (i = 0; i < MIN(a_len, b_len); i++) {
2755         if (a[i] != b[i]) {
2756             printf("%s%2zu: %02"PRIx8" -> %02"PRIx8"\n",
2757                    prefix, i, a[i], b[i]);
2758         }
2759     }
2760     for (i = a_len; i < b_len; i++) {
2761         printf("%s%2zu: (none) -> %02"PRIx8"\n", prefix, i, b[i]);
2762     }
2763     for (i = b_len; i < a_len; i++) {
2764         printf("%s%2zu: %02"PRIx8" -> (none)\n", prefix, i, a[i]);
2765     }
2766 }
2767
2768 /* "parse-ofp10-actions": reads a series of OpenFlow 1.0 action specifications
2769  * as hex bytes from stdin, converts them to ofpacts, prints them as strings
2770  * on stdout, and then converts them back to hex bytes and prints any
2771  * differences from the input. */
2772 static void
2773 ofctl_parse_ofp10_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2774 {
2775     struct ds in;
2776
2777     ds_init(&in);
2778     while (!ds_get_preprocessed_line(&in, stdin, NULL)) {
2779         struct ofpbuf of10_out;
2780         struct ofpbuf of10_in;
2781         struct ofpbuf ofpacts;
2782         enum ofperr error;
2783         size_t size;
2784         struct ds s;
2785
2786         /* Parse hex bytes. */
2787         ofpbuf_init(&of10_in, 0);
2788         if (ofpbuf_put_hex(&of10_in, ds_cstr(&in), NULL)[0] != '\0') {
2789             ovs_fatal(0, "Trailing garbage in hex data");
2790         }
2791
2792         /* Convert to ofpacts. */
2793         ofpbuf_init(&ofpacts, 0);
2794         size = of10_in.size;
2795         error = ofpacts_pull_openflow10(&of10_in, of10_in.size, &ofpacts);
2796         if (error) {
2797             printf("bad OF1.1 actions: %s\n\n", ofperr_get_name(error));
2798             ofpbuf_uninit(&ofpacts);
2799             ofpbuf_uninit(&of10_in);
2800             continue;
2801         }
2802         ofpbuf_push_uninit(&of10_in, size);
2803
2804         /* Print cls_rule. */
2805         ds_init(&s);
2806         ds_put_cstr(&s, "actions=");
2807         ofpacts_format(ofpacts.data, ofpacts.size, &s);
2808         puts(ds_cstr(&s));
2809         ds_destroy(&s);
2810
2811         /* Convert back to ofp10 actions and print differences from input. */
2812         ofpbuf_init(&of10_out, 0);
2813         ofpacts_put_openflow10(ofpacts.data, ofpacts.size, &of10_out);
2814
2815         print_differences("", of10_in.data, of10_in.size,
2816                           of10_out.data, of10_out.size);
2817         putchar('\n');
2818
2819         ofpbuf_uninit(&ofpacts);
2820         ofpbuf_uninit(&of10_in);
2821         ofpbuf_uninit(&of10_out);
2822     }
2823     ds_destroy(&in);
2824 }
2825
2826 /* "parse-ofp10-match": reads a series of ofp10_match specifications as hex
2827  * bytes from stdin, converts them to cls_rules, prints them as strings on
2828  * stdout, and then converts them back to hex bytes and prints any differences
2829  * from the input.
2830  *
2831  * The input hex bytes may contain "x"s to represent "don't-cares", bytes whose
2832  * values are ignored in the input and will be set to zero when OVS converts
2833  * them back to hex bytes.  ovs-ofctl actually sets "x"s to random bits when
2834  * it does the conversion to hex, to ensure that in fact they are ignored. */
2835 static void
2836 ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2837 {
2838     struct ds expout;
2839     struct ds in;
2840
2841     ds_init(&in);
2842     ds_init(&expout);
2843     while (!ds_get_preprocessed_line(&in, stdin, NULL)) {
2844         struct ofpbuf match_in, match_expout;
2845         struct ofp10_match match_out;
2846         struct ofp10_match match_normal;
2847         struct match match;
2848         char *p;
2849
2850         /* Parse hex bytes to use for expected output. */
2851         ds_clear(&expout);
2852         ds_put_cstr(&expout, ds_cstr(&in));
2853         for (p = ds_cstr(&expout); *p; p++) {
2854             if (*p == 'x') {
2855                 *p = '0';
2856             }
2857         }
2858         ofpbuf_init(&match_expout, 0);
2859         if (ofpbuf_put_hex(&match_expout, ds_cstr(&expout), NULL)[0] != '\0') {
2860             ovs_fatal(0, "Trailing garbage in hex data");
2861         }
2862         if (match_expout.size != sizeof(struct ofp10_match)) {
2863             ovs_fatal(0, "Input is %zu bytes, expected %zu",
2864                       match_expout.size, sizeof(struct ofp10_match));
2865         }
2866
2867         /* Parse hex bytes for input. */
2868         for (p = ds_cstr(&in); *p; p++) {
2869             if (*p == 'x') {
2870                 *p = "0123456789abcdef"[random_uint32() & 0xf];
2871             }
2872         }
2873         ofpbuf_init(&match_in, 0);
2874         if (ofpbuf_put_hex(&match_in, ds_cstr(&in), NULL)[0] != '\0') {
2875             ovs_fatal(0, "Trailing garbage in hex data");
2876         }
2877         if (match_in.size != sizeof(struct ofp10_match)) {
2878             ovs_fatal(0, "Input is %zu bytes, expected %zu",
2879                       match_in.size, sizeof(struct ofp10_match));
2880         }
2881
2882         /* Convert to cls_rule and print. */
2883         ofputil_match_from_ofp10_match(match_in.data, &match);
2884         match_print(&match);
2885
2886         /* Convert back to ofp10_match and print differences from input. */
2887         ofputil_match_to_ofp10_match(&match, &match_out);
2888         print_differences("", match_expout.data, match_expout.size,
2889                           &match_out, sizeof match_out);
2890
2891         /* Normalize, then convert and compare again. */
2892         ofputil_normalize_match(&match);
2893         ofputil_match_to_ofp10_match(&match, &match_normal);
2894         print_differences("normal: ", &match_out, sizeof match_out,
2895                           &match_normal, sizeof match_normal);
2896         putchar('\n');
2897
2898         ofpbuf_uninit(&match_in);
2899         ofpbuf_uninit(&match_expout);
2900     }
2901     ds_destroy(&in);
2902     ds_destroy(&expout);
2903 }
2904
2905 /* "parse-ofp11-match": reads a series of ofp11_match specifications as hex
2906  * bytes from stdin, converts them to "struct match"es, prints them as strings
2907  * on stdout, and then converts them back to hex bytes and prints any
2908  * differences from the input. */
2909 static void
2910 ofctl_parse_ofp11_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2911 {
2912     struct ds in;
2913
2914     ds_init(&in);
2915     while (!ds_get_preprocessed_line(&in, stdin, NULL)) {
2916         struct ofpbuf match_in;
2917         struct ofp11_match match_out;
2918         struct match match;
2919         enum ofperr error;
2920
2921         /* Parse hex bytes. */
2922         ofpbuf_init(&match_in, 0);
2923         if (ofpbuf_put_hex(&match_in, ds_cstr(&in), NULL)[0] != '\0') {
2924             ovs_fatal(0, "Trailing garbage in hex data");
2925         }
2926         if (match_in.size != sizeof(struct ofp11_match)) {
2927             ovs_fatal(0, "Input is %zu bytes, expected %zu",
2928                       match_in.size, sizeof(struct ofp11_match));
2929         }
2930
2931         /* Convert to match. */
2932         error = ofputil_match_from_ofp11_match(match_in.data, &match);
2933         if (error) {
2934             printf("bad ofp11_match: %s\n\n", ofperr_get_name(error));
2935             ofpbuf_uninit(&match_in);
2936             continue;
2937         }
2938
2939         /* Print match. */
2940         match_print(&match);
2941
2942         /* Convert back to ofp11_match and print differences from input. */
2943         ofputil_match_to_ofp11_match(&match, &match_out);
2944
2945         print_differences("", match_in.data, match_in.size,
2946                           &match_out, sizeof match_out);
2947         putchar('\n');
2948
2949         ofpbuf_uninit(&match_in);
2950     }
2951     ds_destroy(&in);
2952 }
2953
2954 /* "parse-ofp11-actions": reads a series of OpenFlow 1.1 action specifications
2955  * as hex bytes from stdin, converts them to ofpacts, prints them as strings
2956  * on stdout, and then converts them back to hex bytes and prints any
2957  * differences from the input. */
2958 static void
2959 ofctl_parse_ofp11_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2960 {
2961     struct ds in;
2962
2963     ds_init(&in);
2964     while (!ds_get_preprocessed_line(&in, stdin, NULL)) {
2965         struct ofpbuf of11_out;
2966         struct ofpbuf of11_in;
2967         struct ofpbuf ofpacts;
2968         enum ofperr error;
2969         size_t size;
2970         struct ds s;
2971
2972         /* Parse hex bytes. */
2973         ofpbuf_init(&of11_in, 0);
2974         if (ofpbuf_put_hex(&of11_in, ds_cstr(&in), NULL)[0] != '\0') {
2975             ovs_fatal(0, "Trailing garbage in hex data");
2976         }
2977
2978         /* Convert to ofpacts. */
2979         ofpbuf_init(&ofpacts, 0);
2980         size = of11_in.size;
2981         error = ofpacts_pull_openflow11_actions(&of11_in, OFP11_VERSION,
2982                                                 of11_in.size, &ofpacts);
2983         if (error) {
2984             printf("bad OF1.1 actions: %s\n\n", ofperr_get_name(error));
2985             ofpbuf_uninit(&ofpacts);
2986             ofpbuf_uninit(&of11_in);
2987             continue;
2988         }
2989         ofpbuf_push_uninit(&of11_in, size);
2990
2991         /* Print cls_rule. */
2992         ds_init(&s);
2993         ds_put_cstr(&s, "actions=");
2994         ofpacts_format(ofpacts.data, ofpacts.size, &s);
2995         puts(ds_cstr(&s));
2996         ds_destroy(&s);
2997
2998         /* Convert back to ofp11 actions and print differences from input. */
2999         ofpbuf_init(&of11_out, 0);
3000         ofpacts_put_openflow11_actions(ofpacts.data, ofpacts.size, &of11_out);
3001
3002         print_differences("", of11_in.data, of11_in.size,
3003                           of11_out.data, of11_out.size);
3004         putchar('\n');
3005
3006         ofpbuf_uninit(&ofpacts);
3007         ofpbuf_uninit(&of11_in);
3008         ofpbuf_uninit(&of11_out);
3009     }
3010     ds_destroy(&in);
3011 }
3012
3013 /* "parse-ofp11-instructions": reads a series of OpenFlow 1.1 instruction
3014  * specifications as hex bytes from stdin, converts them to ofpacts, prints
3015  * them as strings on stdout, and then converts them back to hex bytes and
3016  * prints any differences from the input. */
3017 static void
3018 ofctl_parse_ofp11_instructions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
3019 {
3020     struct ds in;
3021
3022     ds_init(&in);
3023     while (!ds_get_preprocessed_line(&in, stdin, NULL)) {
3024         struct ofpbuf of11_out;
3025         struct ofpbuf of11_in;
3026         struct ofpbuf ofpacts;
3027         enum ofperr error;
3028         size_t size;
3029         struct ds s;
3030         const char *table_id;
3031         char *instructions;
3032
3033         /* Parse table_id separated with the follow-up instructions by ",", if
3034          * any. */
3035         instructions = ds_cstr(&in);
3036         table_id = NULL;
3037         if (strstr(instructions, ",")) {
3038             table_id = strsep(&instructions, ",");
3039         }
3040
3041         /* Parse hex bytes. */
3042         ofpbuf_init(&of11_in, 0);
3043         if (ofpbuf_put_hex(&of11_in, instructions, NULL)[0] != '\0') {
3044             ovs_fatal(0, "Trailing garbage in hex data");
3045         }
3046
3047         /* Convert to ofpacts. */
3048         ofpbuf_init(&ofpacts, 0);
3049         size = of11_in.size;
3050         error = ofpacts_pull_openflow11_instructions(&of11_in, OFP11_VERSION,
3051                                                      of11_in.size, &ofpacts);
3052         if (!error) {
3053             /* Verify actions, enforce consistency. */
3054             struct flow flow;
3055             memset(&flow, 0, sizeof flow);
3056             error = ofpacts_check(ofpacts.data, ofpacts.size, &flow, OFPP_MAX,
3057                                   table_id ? atoi(table_id) : 0, true);
3058         }
3059         if (error) {
3060             printf("bad OF1.1 instructions: %s\n\n", ofperr_get_name(error));
3061             ofpbuf_uninit(&ofpacts);
3062             ofpbuf_uninit(&of11_in);
3063             continue;
3064         }
3065         ofpbuf_push_uninit(&of11_in, size);
3066
3067         /* Print cls_rule. */
3068         ds_init(&s);
3069         ds_put_cstr(&s, "actions=");
3070         ofpacts_format(ofpacts.data, ofpacts.size, &s);
3071         puts(ds_cstr(&s));
3072         ds_destroy(&s);
3073
3074         /* Convert back to ofp11 instructions and print differences from
3075          * input. */
3076         ofpbuf_init(&of11_out, 0);
3077         ofpacts_put_openflow11_instructions(ofpacts.data, ofpacts.size,
3078                                             &of11_out);
3079
3080         print_differences("", of11_in.data, of11_in.size,
3081                           of11_out.data, of11_out.size);
3082         putchar('\n');
3083
3084         ofpbuf_uninit(&ofpacts);
3085         ofpbuf_uninit(&of11_in);
3086         ofpbuf_uninit(&of11_out);
3087     }
3088     ds_destroy(&in);
3089 }
3090
3091 /* "parse-pcap PCAP": read packets from PCAP and print their flows. */
3092 static void
3093 ofctl_parse_pcap(int argc OVS_UNUSED, char *argv[])
3094 {
3095     FILE *pcap;
3096
3097     pcap = pcap_open(argv[1], "rb");
3098     if (!pcap) {
3099         ovs_fatal(errno, "%s: open failed", argv[1]);
3100     }
3101
3102     for (;;) {
3103         struct ofpbuf *packet;
3104         struct flow flow;
3105         int error;
3106
3107         error = pcap_read(pcap, &packet);
3108         if (error == EOF) {
3109             break;
3110         } else if (error) {
3111             ovs_fatal(error, "%s: read failed", argv[1]);
3112         }
3113
3114         flow_extract(packet, 0, 0, NULL, NULL, &flow);
3115         flow_print(stdout, &flow);
3116         putchar('\n');
3117         ofpbuf_delete(packet);
3118     }
3119 }
3120
3121 /* "check-vlan VLAN_TCI VLAN_TCI_MASK": converts the specified vlan_tci and
3122  * mask values to and from various formats and prints the results. */
3123 static void
3124 ofctl_check_vlan(int argc OVS_UNUSED, char *argv[])
3125 {
3126     struct match match;
3127
3128     char *string_s;
3129     struct ofputil_flow_mod fm;
3130
3131     struct ofpbuf nxm;
3132     struct match nxm_match;
3133     int nxm_match_len;
3134     char *nxm_s;
3135
3136     struct ofp10_match of10_raw;
3137     struct match of10_match;
3138
3139     struct ofp11_match of11_raw;
3140     struct match of11_match;
3141
3142     enum ofperr error;
3143     char *error_s;
3144
3145     enum ofputil_protocol usable_protocols; /* Unused for now. */
3146
3147     match_init_catchall(&match);
3148     match.flow.vlan_tci = htons(strtoul(argv[1], NULL, 16));
3149     match.wc.masks.vlan_tci = htons(strtoul(argv[2], NULL, 16));
3150
3151     /* Convert to and from string. */
3152     string_s = match_to_string(&match, OFP_DEFAULT_PRIORITY);
3153     printf("%s -> ", string_s);
3154     fflush(stdout);
3155     error_s = parse_ofp_str(&fm, -1, string_s, &usable_protocols,
3156                             !(allowed_protocols & OFPUTIL_P_OF10_ANY));
3157     if (error_s) {
3158         ovs_fatal(0, "%s", error_s);
3159     }
3160     printf("%04"PRIx16"/%04"PRIx16"\n",
3161            ntohs(fm.match.flow.vlan_tci),
3162            ntohs(fm.match.wc.masks.vlan_tci));
3163     free(string_s);
3164
3165     /* Convert to and from NXM. */
3166     ofpbuf_init(&nxm, 0);
3167     nxm_match_len = nx_put_match(&nxm, &match, htonll(0), htonll(0));
3168     nxm_s = nx_match_to_string(nxm.data, nxm_match_len);
3169     error = nx_pull_match(&nxm, nxm_match_len, &nxm_match, NULL, NULL);
3170     printf("NXM: %s -> ", nxm_s);
3171     if (error) {
3172         printf("%s\n", ofperr_to_string(error));
3173     } else {
3174         printf("%04"PRIx16"/%04"PRIx16"\n",
3175                ntohs(nxm_match.flow.vlan_tci),
3176                ntohs(nxm_match.wc.masks.vlan_tci));
3177     }
3178     free(nxm_s);
3179     ofpbuf_uninit(&nxm);
3180
3181     /* Convert to and from OXM. */
3182     ofpbuf_init(&nxm, 0);
3183     nxm_match_len = oxm_put_match(&nxm, &match);
3184     nxm_s = oxm_match_to_string(&nxm, nxm_match_len);
3185     error = oxm_pull_match(&nxm, &nxm_match);
3186     printf("OXM: %s -> ", nxm_s);
3187     if (error) {
3188         printf("%s\n", ofperr_to_string(error));
3189     } else {
3190         uint16_t vid = ntohs(nxm_match.flow.vlan_tci) &
3191             (VLAN_VID_MASK | VLAN_CFI);
3192         uint16_t mask = ntohs(nxm_match.wc.masks.vlan_tci) &
3193             (VLAN_VID_MASK | VLAN_CFI);
3194
3195         printf("%04"PRIx16"/%04"PRIx16",", vid, mask);
3196         if (vid && vlan_tci_to_pcp(nxm_match.wc.masks.vlan_tci)) {
3197             printf("%02"PRIx8"\n", vlan_tci_to_pcp(nxm_match.flow.vlan_tci));
3198         } else {
3199             printf("--\n");
3200         }
3201     }
3202     free(nxm_s);
3203     ofpbuf_uninit(&nxm);
3204
3205     /* Convert to and from OpenFlow 1.0. */
3206     ofputil_match_to_ofp10_match(&match, &of10_raw);
3207     ofputil_match_from_ofp10_match(&of10_raw, &of10_match);
3208     printf("OF1.0: %04"PRIx16"/%d,%02"PRIx8"/%d -> %04"PRIx16"/%04"PRIx16"\n",
3209            ntohs(of10_raw.dl_vlan),
3210            (of10_raw.wildcards & htonl(OFPFW10_DL_VLAN)) != 0,
3211            of10_raw.dl_vlan_pcp,
3212            (of10_raw.wildcards & htonl(OFPFW10_DL_VLAN_PCP)) != 0,
3213            ntohs(of10_match.flow.vlan_tci),
3214            ntohs(of10_match.wc.masks.vlan_tci));
3215
3216     /* Convert to and from OpenFlow 1.1. */
3217     ofputil_match_to_ofp11_match(&match, &of11_raw);
3218     ofputil_match_from_ofp11_match(&of11_raw, &of11_match);
3219     printf("OF1.1: %04"PRIx16"/%d,%02"PRIx8"/%d -> %04"PRIx16"/%04"PRIx16"\n",
3220            ntohs(of11_raw.dl_vlan),
3221            (of11_raw.wildcards & htonl(OFPFW11_DL_VLAN)) != 0,
3222            of11_raw.dl_vlan_pcp,
3223            (of11_raw.wildcards & htonl(OFPFW11_DL_VLAN_PCP)) != 0,
3224            ntohs(of11_match.flow.vlan_tci),
3225            ntohs(of11_match.wc.masks.vlan_tci));
3226 }
3227
3228 /* "print-error ENUM": Prints the type and code of ENUM for every OpenFlow
3229  * version. */
3230 static void
3231 ofctl_print_error(int argc OVS_UNUSED, char *argv[])
3232 {
3233     enum ofperr error;
3234     int version;
3235
3236     error = ofperr_from_name(argv[1]);
3237     if (!error) {
3238         ovs_fatal(0, "unknown error \"%s\"", argv[1]);
3239     }
3240
3241     for (version = 0; version <= UINT8_MAX; version++) {
3242         const char *name = ofperr_domain_get_name(version);
3243         if (name) {
3244             int vendor = ofperr_get_vendor(error, version);
3245             int type = ofperr_get_type(error, version);
3246             int code = ofperr_get_code(error, version);
3247
3248             if (vendor != -1 || type != -1 || code != -1) {
3249                 printf("%s: vendor %#x, type %d, code %d\n",
3250                        name, vendor, type, code);
3251             }
3252         }
3253     }
3254 }
3255
3256 /* "encode-error-reply ENUM REQUEST": Encodes an error reply to REQUEST for the
3257  * error named ENUM and prints the error reply in hex. */
3258 static void
3259 ofctl_encode_error_reply(int argc OVS_UNUSED, char *argv[])
3260 {
3261     const struct ofp_header *oh;
3262     struct ofpbuf request, *reply;
3263     enum ofperr error;
3264
3265     error = ofperr_from_name(argv[1]);
3266     if (!error) {
3267         ovs_fatal(0, "unknown error \"%s\"", argv[1]);
3268     }
3269
3270     ofpbuf_init(&request, 0);
3271     if (ofpbuf_put_hex(&request, argv[2], NULL)[0] != '\0') {
3272         ovs_fatal(0, "Trailing garbage in hex data");
3273     }
3274     if (request.size < sizeof(struct ofp_header)) {
3275         ovs_fatal(0, "Request too short");
3276     }
3277
3278     oh = request.data;
3279     if (request.size != ntohs(oh->length)) {
3280         ovs_fatal(0, "Request size inconsistent");
3281     }
3282
3283     reply = ofperr_encode_reply(error, request.data);
3284     ofpbuf_uninit(&request);
3285
3286     ovs_hex_dump(stdout, reply->data, reply->size, 0, false);
3287     ofpbuf_delete(reply);
3288 }
3289
3290 /* "ofp-print HEXSTRING [VERBOSITY]": Converts the hex digits in HEXSTRING into
3291  * binary data, interpreting them as an OpenFlow message, and prints the
3292  * OpenFlow message on stdout, at VERBOSITY (level 2 by default).  */
3293 static void
3294 ofctl_ofp_print(int argc, char *argv[])
3295 {
3296     struct ofpbuf packet;
3297
3298     ofpbuf_init(&packet, strlen(argv[1]) / 2);
3299     if (ofpbuf_put_hex(&packet, argv[1], NULL)[0] != '\0') {
3300         ovs_fatal(0, "trailing garbage following hex bytes");
3301     }
3302     ofp_print(stdout, packet.data, packet.size, argc > 2 ? atoi(argv[2]) : 2);
3303     ofpbuf_uninit(&packet);
3304 }
3305
3306 /* "encode-hello BITMAP...": Encodes each BITMAP as an OpenFlow hello message
3307  * and dumps each message in hex.  */
3308 static void
3309 ofctl_encode_hello(int argc OVS_UNUSED, char *argv[])
3310 {
3311     uint32_t bitmap = strtol(argv[1], NULL, 0);
3312     struct ofpbuf *hello;
3313
3314     hello = ofputil_encode_hello(bitmap);
3315     ovs_hex_dump(stdout, hello->data, hello->size, 0, false);
3316     ofp_print(stdout, hello->data, hello->size, verbosity);
3317     ofpbuf_delete(hello);
3318 }
3319
3320 static const struct command all_commands[] = {
3321     { "show", 1, 1, ofctl_show },
3322     { "monitor", 1, 3, ofctl_monitor },
3323     { "snoop", 1, 1, ofctl_snoop },
3324     { "dump-desc", 1, 1, ofctl_dump_desc },
3325     { "dump-tables", 1, 1, ofctl_dump_tables },
3326     { "dump-flows", 1, 2, ofctl_dump_flows },
3327     { "dump-aggregate", 1, 2, ofctl_dump_aggregate },
3328     { "queue-stats", 1, 3, ofctl_queue_stats },
3329     { "add-flow", 2, 2, ofctl_add_flow },
3330     { "add-flows", 2, 2, ofctl_add_flows },
3331     { "mod-flows", 2, 2, ofctl_mod_flows },
3332     { "del-flows", 1, 2, ofctl_del_flows },
3333     { "replace-flows", 2, 2, ofctl_replace_flows },
3334     { "diff-flows", 2, 2, ofctl_diff_flows },
3335     { "add-meter", 2, 2, ofctl_add_meter },
3336     { "mod-meter", 2, 2, ofctl_mod_meter },
3337     { "del-meter", 2, 2, ofctl_del_meters },
3338     { "del-meters", 1, 1, ofctl_del_meters },
3339     { "dump-meter", 2, 2, ofctl_dump_meters },
3340     { "dump-meters", 1, 1, ofctl_dump_meters },
3341     { "meter-stats", 1, 2, ofctl_meter_stats },
3342     { "meter-features", 1, 1, ofctl_meter_features },
3343     { "packet-out", 4, INT_MAX, ofctl_packet_out },
3344     { "dump-ports", 1, 2, ofctl_dump_ports },
3345     { "dump-ports-desc", 1, 1, ofctl_dump_ports_desc },
3346     { "mod-port", 3, 3, ofctl_mod_port },
3347     { "mod-table", 3, 3, ofctl_mod_table },
3348     { "get-frags", 1, 1, ofctl_get_frags },
3349     { "set-frags", 2, 2, ofctl_set_frags },
3350     { "ofp-parse", 1, 1, ofctl_ofp_parse },
3351     { "probe", 1, 1, ofctl_probe },
3352     { "ping", 1, 2, ofctl_ping },
3353     { "benchmark", 3, 3, ofctl_benchmark },
3354
3355     { "add-group", 1, 2, ofctl_add_group },
3356     { "add-groups", 1, 2, ofctl_add_groups },
3357     { "mod-group", 1, 2, ofctl_mod_group },
3358     { "del-groups", 1, 2, ofctl_del_groups },
3359     { "dump-groups", 1, 1, ofctl_dump_group_desc },
3360     { "dump-group-stats", 1, 2, ofctl_dump_group_stats },
3361     { "dump-group-features", 1, 1, ofctl_dump_group_features },
3362     { "help", 0, INT_MAX, ofctl_help },
3363
3364     /* Undocumented commands for testing. */
3365     { "parse-flow", 1, 1, ofctl_parse_flow },
3366     { "parse-flows", 1, 1, ofctl_parse_flows },
3367     { "parse-nx-match", 0, 0, ofctl_parse_nxm },
3368     { "parse-nxm", 0, 0, ofctl_parse_nxm },
3369     { "parse-oxm", 0, 0, ofctl_parse_oxm },
3370     { "parse-ofp10-actions", 0, 0, ofctl_parse_ofp10_actions },
3371     { "parse-ofp10-match", 0, 0, ofctl_parse_ofp10_match },
3372     { "parse-ofp11-match", 0, 0, ofctl_parse_ofp11_match },
3373     { "parse-ofp11-actions", 0, 0, ofctl_parse_ofp11_actions },
3374     { "parse-ofp11-instructions", 0, 0, ofctl_parse_ofp11_instructions },
3375     { "parse-pcap", 1, 1, ofctl_parse_pcap },
3376     { "check-vlan", 2, 2, ofctl_check_vlan },
3377     { "print-error", 1, 1, ofctl_print_error },
3378     { "encode-error-reply", 2, 2, ofctl_encode_error_reply },
3379     { "ofp-print", 1, 2, ofctl_ofp_print },
3380     { "encode-hello", 1, 1, ofctl_encode_hello },
3381
3382     { NULL, 0, 0, NULL },
3383 };
3384
3385 static const struct command *get_all_commands(void)
3386 {
3387     return all_commands;
3388 }