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