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