utilities/ovs-ofctl.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010 Nicira Networks.
   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 <errno.h>
  19 #include <getopt.h>
  20 #include <inttypes.h>
  21 #include <net/if.h>
  22 #include <signal.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/stat.h>
  27 #include <sys/time.h>
  28
  29 #include "byte-order.h"
  30 #include "classifier.h"
  31 #include "command-line.h"
  32 #include "compiler.h"
  33 #include "dirs.h"
  34 #include "dpif.h"
  35 #include "dynamic-string.h"
  36 #include "netlink.h"
  37 #include "nx-match.h"
  38 #include "odp-util.h"
  39 #include "ofp-parse.h"
  40 #include "ofp-print.h"
  41 #include "ofp-util.h"
  42 #include "ofpbuf.h"
  43 #include "openflow/nicira-ext.h"
  44 #include "openflow/openflow.h"
  45 #include "random.h"
  46 #include "stream-ssl.h"
  47 #include "timeval.h"
  48 #include "util.h"
  49 #include "vconn.h"
  50 #include "vlog.h"
  51
  52 VLOG_DEFINE_THIS_MODULE(ofctl);
  53
  54 /* Use strict matching for flow mod commands? */
  55 static bool strict;
  56
  57 static const struct command all_commands[];
  58
  59 static void usage(void) NO_RETURN;
  60 static void parse_options(int argc, char *argv[]);
  61
  62 int
  63 main(int argc, char *argv[])
  64 {
  65     set_program_name(argv[0]);
  66     parse_options(argc, argv);
  67     signal(SIGPIPE, SIG_IGN);
  68     run_command(argc - optind, argv + optind, all_commands);
  69     return 0;
  70 }
  71
  72 static void
  73 parse_options(int argc, char *argv[])
  74 {
  75     enum {
  76         OPT_STRICT = UCHAR_MAX + 1,
  77         VLOG_OPTION_ENUMS
  78     };
  79     static struct option long_options[] = {
  80         {"timeout", required_argument, 0, 't'},
  81         {"strict", no_argument, 0, OPT_STRICT},
  82         {"help", no_argument, 0, 'h'},
  83         {"version", no_argument, 0, 'V'},
  84         VLOG_LONG_OPTIONS,
  85         STREAM_SSL_LONG_OPTIONS
  86         {0, 0, 0, 0},
  87     };
  88     char *short_options = long_options_to_short_options(long_options);
  89
  90     for (;;) {
  91         unsigned long int timeout;
  92         int c;
  93
  94         c = getopt_long(argc, argv, short_options, long_options, NULL);
  95         if (c == -1) {
  96             break;
  97         }
  98
  99         switch (c) {
 100         case 't':
 101             timeout = strtoul(optarg, NULL, 10);
 102             if (timeout <= 0) {
 103                 ovs_fatal(0, "value %s on -t or --timeout is not at least 1",
 104                           optarg);
 105             } else {
 106                 time_alarm(timeout);
 107             }
 108             break;
 109
 110         case 'h':
 111             usage();
 112
 113         case 'V':
 114             OVS_PRINT_VERSION(OFP_VERSION, OFP_VERSION);
 115             exit(EXIT_SUCCESS);
 116
 117         case OPT_STRICT:
 118             strict = true;
 119             break;
 120
 121         VLOG_OPTION_HANDLERS
 122         STREAM_SSL_OPTION_HANDLERS
 123
 124         case '?':
 125             exit(EXIT_FAILURE);
 126
 127         default:
 128             abort();
 129         }
 130     }
 131     free(short_options);
 132 }
 133
 134 static void
 135 usage(void)
 136 {
 137     printf("%s: OpenFlow switch management utility\n"
 138            "usage: %s [OPTIONS] COMMAND [ARG...]\n"
 139            "\nFor OpenFlow switches:\n"
 140            "  show SWITCH                 show OpenFlow information\n"
 141            "  status SWITCH [KEY]         report statistics (about KEY)\n"
 142            "  dump-desc SWITCH            print switch description\n"
 143            "  dump-tables SWITCH          print table stats\n"
 144            "  mod-port SWITCH IFACE ACT   modify port behavior\n"
 145            "  dump-ports SWITCH [PORT]    print port statistics\n"
 146            "  dump-flows SWITCH           print all flow entries\n"
 147            "  dump-flows SWITCH FLOW      print matching FLOWs\n"
 148            "  dump-aggregate SWITCH       print aggregate flow statistics\n"
 149            "  dump-aggregate SWITCH FLOW  print aggregate stats for FLOWs\n"
 150            "  queue-stats SWITCH [PORT [QUEUE]]  dump queue stats\n"
 151            "  add-flow SWITCH FLOW        add flow described by FLOW\n"
 152            "  add-flows SWITCH FILE       add flows from FILE\n"
 153            "  mod-flows SWITCH FLOW       modify actions of matching FLOWs\n"
 154            "  del-flows SWITCH [FLOW]     delete matching FLOWs\n"
 155            "  monitor SWITCH [MISSLEN]    print packets received from SWITCH\n"
 156            "\nFor OpenFlow switches and controllers:\n"
 157            "  probe VCONN                 probe whether VCONN is up\n"
 158            "  ping VCONN [N]              latency of N-byte echos\n"
 159            "  benchmark VCONN N COUNT     bandwidth of COUNT N-byte echos\n"
 160            "where each SWITCH is an active OpenFlow connection method.\n",
 161            program_name, program_name);
 162     vconn_usage(true, false, false);
 163     vlog_usage();
 164     printf("\nOther options:\n"
 165            "  --strict                    use strict match for flow commands\n"
 166            "  -t, --timeout=SECS          give up after SECS seconds\n"
 167            "  -h, --help                  display this help message\n"
 168            "  -V, --version               display version information\n");
 169     exit(EXIT_SUCCESS);
 170 }
 171
 172 static void run(int retval, const char *message, ...)
 173     PRINTF_FORMAT(2, 3);
 174
 175 static void run(int retval, const char *message, ...)
 176 {
 177     if (retval) {
 178         va_list args;
 179
 180         fprintf(stderr, "%s: ", program_name);
 181         va_start(args, message);
 182         vfprintf(stderr, message, args);
 183         va_end(args);
 184         if (retval == EOF) {
 185             fputs(": unexpected end of file\n", stderr);
 186         } else {
 187             fprintf(stderr, ": %s\n", strerror(retval));
 188         }
 189
 190         exit(EXIT_FAILURE);
 191     }
 192 }
 193 \f
 194 /* Generic commands. */
 195
 196 static void
 197 open_vconn_socket(const char *name, struct vconn **vconnp)
 198 {
 199     char *vconn_name = xasprintf("unix:%s", name);
 200     VLOG_INFO("connecting to %s", vconn_name);
 201     run(vconn_open_block(vconn_name, OFP_VERSION, vconnp),
 202         "connecting to %s", vconn_name);
 203     free(vconn_name);
 204 }
 205
 206 static void
 207 open_vconn__(const char *name, const char *default_suffix,
 208              struct vconn **vconnp)
 209 {
 210     struct dpif *dpif;
 211     struct stat s;
 212     char *bridge_path, *datapath_name, *datapath_type;
 213
 214     bridge_path = xasprintf("%s/%s.%s", ovs_rundir(), name, default_suffix);
 215     dp_parse_name(name, &datapath_name, &datapath_type);
 216
 217     if (strstr(name, ":")) {
 218         run(vconn_open_block(name, OFP_VERSION, vconnp),
 219             "connecting to %s", name);
 220     } else if (!stat(name, &s) && S_ISSOCK(s.st_mode)) {
 221         open_vconn_socket(name, vconnp);
 222     } else if (!stat(bridge_path, &s) && S_ISSOCK(s.st_mode)) {
 223         open_vconn_socket(bridge_path, vconnp);
 224     } else if (!dpif_open(datapath_name, datapath_type, &dpif)) {
 225         char dpif_name[IF_NAMESIZE + 1];
 226         char *socket_name;
 227
 228         run(dpif_port_get_name(dpif, ODPP_LOCAL, dpif_name, sizeof dpif_name),
 229             "obtaining name of %s", dpif_name);
 230         dpif_close(dpif);
 231         if (strcmp(dpif_name, name)) {
 232             VLOG_INFO("datapath %s is named %s", name, dpif_name);
 233         }
 234
 235         socket_name = xasprintf("%s/%s.%s",
 236                                 ovs_rundir(), dpif_name, default_suffix);
 237         if (stat(socket_name, &s)) {
 238             ovs_fatal(errno, "cannot connect to %s: stat failed on %s",
 239                       name, socket_name);
 240         } else if (!S_ISSOCK(s.st_mode)) {
 241             ovs_fatal(0, "cannot connect to %s: %s is not a socket",
 242                       name, socket_name);
 243         }
 244
 245         open_vconn_socket(socket_name, vconnp);
 246         free(socket_name);
 247     } else {
 248         ovs_fatal(0, "%s is not a valid connection method", name);
 249     }
 250
 251     free(datapath_name);
 252     free(datapath_type);
 253     free(bridge_path);
 254 }
 255
 256 static void
 257 open_vconn(const char *name, struct vconn **vconnp)
 258 {
 259     return open_vconn__(name, "mgmt", vconnp);
 260 }
 261
 262 static void *
 263 alloc_stats_request(size_t body_len, uint16_t type, struct ofpbuf **bufferp)
 264 {
 265     struct ofp_stats_request *rq;
 266     rq = make_openflow((offsetof(struct ofp_stats_request, body)
 267                         + body_len), OFPT_STATS_REQUEST, bufferp);
 268     rq->type = htons(type);
 269     rq->flags = htons(0);
 270     return rq->body;
 271 }
 272
 273 static void
 274 send_openflow_buffer(struct vconn *vconn, struct ofpbuf *buffer)
 275 {
 276     update_openflow_length(buffer);
 277     run(vconn_send_block(vconn, buffer), "failed to send packet to switch");
 278 }
 279
 280 static void
 281 dump_transaction(const char *vconn_name, struct ofpbuf *request)
 282 {
 283     struct vconn *vconn;
 284     struct ofpbuf *reply;
 285
 286     update_openflow_length(request);
 287     open_vconn(vconn_name, &vconn);
 288     run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
 289     ofp_print(stdout, reply->data, reply->size, 1);
 290     vconn_close(vconn);
 291 }
 292
 293 static void
 294 dump_trivial_transaction(const char *vconn_name, uint8_t request_type)
 295 {
 296     struct ofpbuf *request;
 297     make_openflow(sizeof(struct ofp_header), request_type, &request);
 298     dump_transaction(vconn_name, request);
 299 }
 300
 301 static void
 302 dump_stats_transaction(const char *vconn_name, struct ofpbuf *request)
 303 {
 304     ovs_be32 send_xid = ((struct ofp_header *) request->data)->xid;
 305     struct vconn *vconn;
 306     bool done = false;
 307
 308     open_vconn(vconn_name, &vconn);
 309     send_openflow_buffer(vconn, request);
 310     while (!done) {
 311         uint32_t recv_xid;
 312         struct ofpbuf *reply;
 313
 314         run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed");
 315         recv_xid = ((struct ofp_header *) reply->data)->xid;
 316         if (send_xid == recv_xid) {
 317             struct ofp_stats_reply *osr;
 318
 319             ofp_print(stdout, reply->data, reply->size, 1);
 320
 321             osr = ofpbuf_at(reply, 0, sizeof *osr);
 322             done = !osr || !(ntohs(osr->flags) & OFPSF_REPLY_MORE);
 323         } else {
 324             VLOG_DBG("received reply with xid %08"PRIx32" "
 325                      "!= expected %08"PRIx32, recv_xid, send_xid);
 326         }
 327         ofpbuf_delete(reply);
 328     }
 329     vconn_close(vconn);
 330 }
 331
 332 static void
 333 dump_trivial_stats_transaction(const char *vconn_name, uint8_t stats_type)
 334 {
 335     struct ofpbuf *request;
 336     alloc_stats_request(0, stats_type, &request);
 337     dump_stats_transaction(vconn_name, request);
 338 }
 339
 340 static void
 341 do_show(int argc OVS_UNUSED, char *argv[])
 342 {
 343     dump_trivial_transaction(argv[1], OFPT_FEATURES_REQUEST);
 344     dump_trivial_transaction(argv[1], OFPT_GET_CONFIG_REQUEST);
 345 }
 346
 347 static void
 348 do_status(int argc, char *argv[])
 349 {
 350     struct nicira_header *request, *reply;
 351     struct vconn *vconn;
 352     struct ofpbuf *b;
 353
 354     request = make_nxmsg(sizeof *request, NXT_STATUS_REQUEST, &b);
 355     if (argc > 2) {
 356         ofpbuf_put(b, argv[2], strlen(argv[2]));
 357         update_openflow_length(b);
 358     }
 359     open_vconn(argv[1], &vconn);
 360     run(vconn_transact(vconn, b, &b), "talking to %s", argv[1]);
 361     vconn_close(vconn);
 362
 363     if (b->size < sizeof *reply) {
 364         ovs_fatal(0, "short reply (%zu bytes)", b->size);
 365     }
 366     reply = b->data;
 367     if (reply->header.type != OFPT_VENDOR
 368         || reply->vendor != ntohl(NX_VENDOR_ID)
 369         || reply->subtype != ntohl(NXT_STATUS_REPLY)) {
 370         ofp_print(stderr, b->data, b->size, 2);
 371         ovs_fatal(0, "bad reply");
 372     }
 373
 374     fwrite(reply + 1, b->size - sizeof *reply, 1, stdout);
 375 }
 376
 377 static void
 378 do_dump_desc(int argc OVS_UNUSED, char *argv[])
 379 {
 380     dump_trivial_stats_transaction(argv[1], OFPST_DESC);
 381 }
 382
 383 static void
 384 do_dump_tables(int argc OVS_UNUSED, char *argv[])
 385 {
 386     dump_trivial_stats_transaction(argv[1], OFPST_TABLE);
 387 }
 388
 389 /* Opens a connection to 'vconn_name', fetches the ofp_phy_port structure for
 390  * 'port_name' (which may be a port name or number), and copies it into
 391  * '*oppp'. */
 392 static void
 393 fetch_ofp_phy_port(const char *vconn_name, const char *port_name,
 394                    struct ofp_phy_port *oppp)
 395 {
 396     struct ofpbuf *request, *reply;
 397     struct ofp_switch_features *osf;
 398     unsigned int port_no;
 399     struct vconn *vconn;
 400     int n_ports;
 401     int port_idx;
 402
 403     /* Try to interpret the argument as a port number. */
 404     if (!str_to_uint(port_name, 10, &port_no)) {
 405         port_no = UINT_MAX;
 406     }
 407
 408     /* Fetch the switch's ofp_switch_features. */
 409     make_openflow(sizeof(struct ofp_header), OFPT_FEATURES_REQUEST, &request);
 410     open_vconn(vconn_name, &vconn);
 411     run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
 412
 413     osf = reply->data;
 414     if (reply->size < sizeof *osf) {
 415         ovs_fatal(0, "%s: received too-short features reply (only %zu bytes)",
 416                   vconn_name, reply->size);
 417     }
 418     n_ports = (reply->size - sizeof *osf) / sizeof *osf->ports;
 419
 420     for (port_idx = 0; port_idx < n_ports; port_idx++) {
 421         const struct ofp_phy_port *opp = &osf->ports[port_idx];
 422
 423         if (port_no != UINT_MAX
 424             ? htons(port_no) == opp->port_no
 425             : !strncmp((char *) opp->name, port_name, sizeof opp->name)) {
 426             *oppp = *opp;
 427             ofpbuf_delete(reply);
 428             vconn_close(vconn);
 429             return;
 430         }
 431     }
 432     ovs_fatal(0, "%s: couldn't find port `%s'", vconn_name, port_name);
 433 }
 434
 435 /* Returns the port number corresponding to 'port_name' (which may be a port
 436  * name or number) within the switch 'vconn_name'. */
 437 static uint16_t
 438 str_to_port_no(const char *vconn_name, const char *port_name)
 439 {
 440     unsigned int port_no;
 441
 442     if (str_to_uint(port_name, 10, &port_no)) {
 443         return port_no;
 444     } else {
 445         struct ofp_phy_port opp;
 446
 447         fetch_ofp_phy_port(vconn_name, port_name, &opp);
 448         return ntohs(opp.port_no);
 449     }
 450 }
 451
 452 static void
 453 do_dump_flows(int argc, char *argv[])
 454 {
 455     struct ofp_flow_stats_request *req;
 456     struct parsed_flow pf;
 457     struct ofpbuf *request;
 458
 459     req = alloc_stats_request(sizeof *req, OFPST_FLOW, &request);
 460     parse_ofp_str(&pf, NULL, argc > 2 ? argv[2] : "");
 461     ofputil_cls_rule_to_match(&pf.rule, NXFF_OPENFLOW10, &req->match);
 462     memset(&req->pad, 0, sizeof req->pad);
 463     req->out_port = htons(pf.out_port);
 464
 465     dump_stats_transaction(argv[1], request);
 466 }
 467
 468 static void
 469 do_dump_aggregate(int argc, char *argv[])
 470 {
 471     struct ofp_aggregate_stats_request *req;
 472     struct ofpbuf *request;
 473     struct parsed_flow pf;
 474
 475     req = alloc_stats_request(sizeof *req, OFPST_AGGREGATE, &request);
 476     parse_ofp_str(&pf, NULL, argc > 2 ? argv[2] : "");
 477     ofputil_cls_rule_to_match(&pf.rule, NXFF_OPENFLOW10, &req->match);
 478     memset(&req->pad, 0, sizeof req->pad);
 479     req->out_port = htons(pf.out_port);
 480
 481     dump_stats_transaction(argv[1], request);
 482 }
 483
 484 static void
 485 do_queue_stats(int argc, char *argv[])
 486 {
 487     struct ofp_queue_stats_request *req;
 488     struct ofpbuf *request;
 489
 490     req = alloc_stats_request(sizeof *req, OFPST_QUEUE, &request);
 491
 492     if (argc > 2 && argv[2][0] && strcasecmp(argv[2], "all")) {
 493         req->port_no = htons(str_to_port_no(argv[1], argv[2]));
 494     } else {
 495         req->port_no = htons(OFPP_ALL);
 496     }
 497     if (argc > 3 && argv[3][0] && strcasecmp(argv[3], "all")) {
 498         req->queue_id = htonl(atoi(argv[3]));
 499     } else {
 500         req->queue_id = htonl(OFPQ_ALL);
 501     }
 502
 503     memset(req->pad, 0, sizeof req->pad);
 504
 505     dump_stats_transaction(argv[1], request);
 506 }
 507
 508 static void
 509 do_add_flow(int argc OVS_UNUSED, char *argv[])
 510 {
 511     struct vconn *vconn;
 512     struct ofpbuf *buffer;
 513
 514     buffer = parse_ofp_flow_mod_str(argv[2], OFPFC_ADD);
 515
 516     open_vconn(argv[1], &vconn);
 517     send_openflow_buffer(vconn, buffer);
 518     vconn_close(vconn);
 519 }
 520
 521 static void
 522 do_add_flows(int argc OVS_UNUSED, char *argv[])
 523 {
 524     struct vconn *vconn;
 525     struct ofpbuf *b;
 526     FILE *file;
 527
 528     file = fopen(argv[2], "r");
 529     if (file == NULL) {
 530         ovs_fatal(errno, "%s: open", argv[2]);
 531     }
 532
 533     open_vconn(argv[1], &vconn);
 534     while ((b = parse_ofp_add_flow_file(file)) != NULL) {
 535         send_openflow_buffer(vconn, b);
 536     }
 537     vconn_close(vconn);
 538     fclose(file);
 539 }
 540
 541 static void
 542 do_mod_flows(int argc OVS_UNUSED, char *argv[])
 543 {
 544     struct vconn *vconn;
 545     struct ofpbuf *buffer;
 546     uint16_t command;
 547
 548     command = strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY;
 549     buffer = parse_ofp_flow_mod_str(argv[2], command);
 550     open_vconn(argv[1], &vconn);
 551     send_openflow_buffer(vconn, buffer);
 552     vconn_close(vconn);
 553 }
 554
 555 static void do_del_flows(int argc, char *argv[])
 556 {
 557     struct vconn *vconn;
 558     struct ofpbuf *buffer;
 559     uint16_t command;
 560
 561     command = strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE;
 562     buffer = parse_ofp_flow_mod_str(argc > 2 ? argv[2] : "", command);
 563
 564     open_vconn(argv[1], &vconn);
 565     send_openflow_buffer(vconn, buffer);
 566     vconn_close(vconn);
 567 }
 568
 569 static void
 570 do_tun_cookie(int argc OVS_UNUSED, char *argv[])
 571 {
 572     struct nxt_tun_id_cookie *tun_id_cookie;
 573     struct ofpbuf *buffer;
 574     struct vconn *vconn;
 575
 576     tun_id_cookie = make_nxmsg(sizeof *tun_id_cookie, NXT_TUN_ID_FROM_COOKIE,
 577                                &buffer);
 578     tun_id_cookie->set = !strcmp(argv[2], "true");
 579
 580     open_vconn(argv[1], &vconn);
 581     send_openflow_buffer(vconn, buffer);
 582     vconn_close(vconn);
 583 }
 584
 585 static void
 586 monitor_vconn(struct vconn *vconn)
 587 {
 588     for (;;) {
 589         struct ofpbuf *b;
 590         run(vconn_recv_block(vconn, &b), "vconn_recv");
 591         ofp_print(stderr, b->data, b->size, 2);
 592         ofpbuf_delete(b);
 593     }
 594 }
 595
 596 static void
 597 do_monitor(int argc, char *argv[])
 598 {
 599     struct vconn *vconn;
 600
 601     open_vconn(argv[1], &vconn);
 602     if (argc > 2) {
 603         int miss_send_len = atoi(argv[2]);
 604         struct ofp_switch_config *osc;
 605         struct ofpbuf *buf;
 606
 607         osc = make_openflow(sizeof *osc, OFPT_SET_CONFIG, &buf);
 608         osc->miss_send_len = htons(miss_send_len);
 609         send_openflow_buffer(vconn, buf);
 610     }
 611     monitor_vconn(vconn);
 612 }
 613
 614 static void
 615 do_snoop(int argc OVS_UNUSED, char *argv[])
 616 {
 617     struct vconn *vconn;
 618
 619     open_vconn__(argv[1], "snoop", &vconn);
 620     monitor_vconn(vconn);
 621 }
 622
 623 static void
 624 do_dump_ports(int argc, char *argv[])
 625 {
 626     struct ofp_port_stats_request *req;
 627     struct ofpbuf *request;
 628     uint16_t port;
 629
 630     req = alloc_stats_request(sizeof *req, OFPST_PORT, &request);
 631     port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_NONE;
 632     req->port_no = htons(port);
 633     dump_stats_transaction(argv[1], request);
 634 }
 635
 636 static void
 637 do_probe(int argc OVS_UNUSED, char *argv[])
 638 {
 639     struct ofpbuf *request;
 640     struct vconn *vconn;
 641     struct ofpbuf *reply;
 642
 643     make_openflow(sizeof(struct ofp_header), OFPT_ECHO_REQUEST, &request);
 644     open_vconn(argv[1], &vconn);
 645     run(vconn_transact(vconn, request, &reply), "talking to %s", argv[1]);
 646     if (reply->size != sizeof(struct ofp_header)) {
 647         ovs_fatal(0, "reply does not match request");
 648     }
 649     ofpbuf_delete(reply);
 650     vconn_close(vconn);
 651 }
 652
 653 static void
 654 do_mod_port(int argc OVS_UNUSED, char *argv[])
 655 {
 656     struct ofp_port_mod *opm;
 657     struct ofp_phy_port opp;
 658     struct ofpbuf *request;
 659     struct vconn *vconn;
 660
 661     fetch_ofp_phy_port(argv[1], argv[2], &opp);
 662
 663     opm = make_openflow(sizeof(struct ofp_port_mod), OFPT_PORT_MOD, &request);
 664     opm->port_no = opp.port_no;
 665     memcpy(opm->hw_addr, opp.hw_addr, sizeof opm->hw_addr);
 666     opm->config = htonl(0);
 667     opm->mask = htonl(0);
 668     opm->advertise = htonl(0);
 669
 670     if (!strcasecmp(argv[3], "up")) {
 671         opm->mask |= htonl(OFPPC_PORT_DOWN);
 672     } else if (!strcasecmp(argv[3], "down")) {
 673         opm->mask |= htonl(OFPPC_PORT_DOWN);
 674         opm->config |= htonl(OFPPC_PORT_DOWN);
 675     } else if (!strcasecmp(argv[3], "flood")) {
 676         opm->mask |= htonl(OFPPC_NO_FLOOD);
 677     } else if (!strcasecmp(argv[3], "noflood")) {
 678         opm->mask |= htonl(OFPPC_NO_FLOOD);
 679         opm->config |= htonl(OFPPC_NO_FLOOD);
 680     } else {
 681         ovs_fatal(0, "unknown mod-port command '%s'", argv[3]);
 682     }
 683
 684     open_vconn(argv[1], &vconn);
 685     send_openflow_buffer(vconn, request);
 686     vconn_close(vconn);
 687 }
 688
 689 static void
 690 do_ping(int argc, char *argv[])
 691 {
 692     size_t max_payload = 65535 - sizeof(struct ofp_header);
 693     unsigned int payload;
 694     struct vconn *vconn;
 695     int i;
 696
 697     payload = argc > 2 ? atoi(argv[2]) : 64;
 698     if (payload > max_payload) {
 699         ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload);
 700     }
 701
 702     open_vconn(argv[1], &vconn);
 703     for (i = 0; i < 10; i++) {
 704         struct timeval start, end;
 705         struct ofpbuf *request, *reply;
 706         struct ofp_header *rq_hdr, *rpy_hdr;
 707
 708         rq_hdr = make_openflow(sizeof(struct ofp_header) + payload,
 709                                OFPT_ECHO_REQUEST, &request);
 710         random_bytes(rq_hdr + 1, payload);
 711
 712         gettimeofday(&start, NULL);
 713         run(vconn_transact(vconn, ofpbuf_clone(request), &reply), "transact");
 714         gettimeofday(&end, NULL);
 715
 716         rpy_hdr = reply->data;
 717         if (reply->size != request->size
 718             || memcmp(rpy_hdr + 1, rq_hdr + 1, payload)
 719             || rpy_hdr->xid != rq_hdr->xid
 720             || rpy_hdr->type != OFPT_ECHO_REPLY) {
 721             printf("Reply does not match request.  Request:\n");
 722             ofp_print(stdout, request, request->size, 2);
 723             printf("Reply:\n");
 724             ofp_print(stdout, reply, reply->size, 2);
 725         }
 726         printf("%zu bytes from %s: xid=%08"PRIx32" time=%.1f ms\n",
 727                reply->size - sizeof *rpy_hdr, argv[1], ntohl(rpy_hdr->xid),
 728                    (1000*(double)(end.tv_sec - start.tv_sec))
 729                    + (.001*(end.tv_usec - start.tv_usec)));
 730         ofpbuf_delete(request);
 731         ofpbuf_delete(reply);
 732     }
 733     vconn_close(vconn);
 734 }
 735
 736 static void
 737 do_benchmark(int argc OVS_UNUSED, char *argv[])
 738 {
 739     size_t max_payload = 65535 - sizeof(struct ofp_header);
 740     struct timeval start, end;
 741     unsigned int payload_size, message_size;
 742     struct vconn *vconn;
 743     double duration;
 744     int count;
 745     int i;
 746
 747     payload_size = atoi(argv[2]);
 748     if (payload_size > max_payload) {
 749         ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload);
 750     }
 751     message_size = sizeof(struct ofp_header) + payload_size;
 752
 753     count = atoi(argv[3]);
 754
 755     printf("Sending %d packets * %u bytes (with header) = %u bytes total\n",
 756            count, message_size, count * message_size);
 757
 758     open_vconn(argv[1], &vconn);
 759     gettimeofday(&start, NULL);
 760     for (i = 0; i < count; i++) {
 761         struct ofpbuf *request, *reply;
 762         struct ofp_header *rq_hdr;
 763
 764         rq_hdr = make_openflow(message_size, OFPT_ECHO_REQUEST, &request);
 765         memset(rq_hdr + 1, 0, payload_size);
 766         run(vconn_transact(vconn, request, &reply), "transact");
 767         ofpbuf_delete(reply);
 768     }
 769     gettimeofday(&end, NULL);
 770     vconn_close(vconn);
 771
 772     duration = ((1000*(double)(end.tv_sec - start.tv_sec))
 773                 + (.001*(end.tv_usec - start.tv_usec)));
 774     printf("Finished in %.1f ms (%.0f packets/s) (%.0f bytes/s)\n",
 775            duration, count / (duration / 1000.0),
 776            count * message_size / (duration / 1000.0));
 777 }
 778
 779 static void
 780 do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 781 {
 782     usage();
 783 }
 784 \f
 785 /* Undocumented commands for unit testing. */
 786
 787 static void
 788 do_parse_flows(int argc OVS_UNUSED, char *argv[])
 789 {
 790     struct ofpbuf *b;
 791     FILE *file;
 792
 793     file = fopen(argv[1], "r");
 794     if (file == NULL) {
 795         ovs_fatal(errno, "%s: open", argv[2]);
 796     }
 797
 798     while ((b = parse_ofp_add_flow_file(file)) != NULL) {
 799         ofp_print(stdout, b->data, b->size, 0);
 800         ofpbuf_delete(b);
 801     }
 802     fclose(file);
 803 }
 804
 805 static void
 806 do_parse_nx_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 807 {
 808     struct ds in;
 809
 810     ds_init(&in);
 811     while (!ds_get_line(&in, stdin)) {
 812         struct ofpbuf nx_match;
 813         struct cls_rule rule;
 814         int match_len;
 815         int error;
 816         char *s;
 817
 818         /* Delete comments, skip blank lines. */
 819         s = ds_cstr(&in);
 820         if (*s == '#') {
 821             puts(s);
 822             continue;
 823         }
 824         if (strchr(s, '#')) {
 825             *strchr(s, '#') = '\0';
 826         }
 827         if (s[strspn(s, " ")] == '\0') {
 828             putchar('\n');
 829             continue;
 830         }
 831
 832         /* Convert string to nx_match. */
 833         ofpbuf_init(&nx_match, 0);
 834         match_len = nx_match_from_string(ds_cstr(&in), &nx_match);
 835
 836         /* Convert nx_match to cls_rule. */
 837         error = nx_pull_match(&nx_match, match_len, 0, &rule);
 838         if (!error) {
 839             char *out;
 840
 841             /* Convert cls_rule back to nx_match. */
 842             ofpbuf_uninit(&nx_match);
 843             ofpbuf_init(&nx_match, 0);
 844             match_len = nx_put_match(&nx_match, &rule);
 845
 846             /* Convert nx_match to string. */
 847             out = nx_match_to_string(nx_match.data, match_len);
 848             puts(out);
 849             free(out);
 850         } else {
 851             printf("nx_pull_match() returned error %x\n", error);
 852         }
 853
 854         ofpbuf_uninit(&nx_match);
 855     }
 856     ds_destroy(&in);
 857 }
 858
 859 static const struct command all_commands[] = {
 860     { "show", 1, 1, do_show },
 861     { "status", 1, 2, do_status },
 862     { "monitor", 1, 2, do_monitor },
 863     { "snoop", 1, 1, do_snoop },
 864     { "dump-desc", 1, 1, do_dump_desc },
 865     { "dump-tables", 1, 1, do_dump_tables },
 866     { "dump-flows", 1, 2, do_dump_flows },
 867     { "dump-aggregate", 1, 2, do_dump_aggregate },
 868     { "queue-stats", 1, 3, do_queue_stats },
 869     { "add-flow", 2, 2, do_add_flow },
 870     { "add-flows", 2, 2, do_add_flows },
 871     { "mod-flows", 2, 2, do_mod_flows },
 872     { "del-flows", 1, 2, do_del_flows },
 873     { "tun-cookie", 2, 2, do_tun_cookie },
 874     { "dump-ports", 1, 2, do_dump_ports },
 875     { "mod-port", 3, 3, do_mod_port },
 876     { "probe", 1, 1, do_probe },
 877     { "ping", 1, 2, do_ping },
 878     { "benchmark", 3, 3, do_benchmark },
 879     { "help", 0, INT_MAX, do_help },
 880
 881     /* Undocumented commands for testing. */
 882     { "parse-flows", 1, 1, do_parse_flows },
 883     { "parse-nx-match", 0, 0, do_parse_nx_match },
 884
 885     { NULL, 0, 0, NULL },
 886 };