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 ntohs(osf->ports[port_idx].port_no);
 435 }
 436
 437 static void
 438 do_dump_flows(int argc, char *argv[])
 439 {
 440     struct ofp_flow_stats_request *req;
 441     struct parsed_flow pf;
 442     struct ofpbuf *request;
 443
 444     req = alloc_stats_request(sizeof *req, OFPST_FLOW, &request);
 445     parse_ofp_str(&pf, NULL, argc > 2 ? argv[2] : "");
 446     flow_to_match(&pf.rule.flow, pf.rule.wc.wildcards, NXFF_OPENFLOW10,
 447                   &req->match);
 448     memset(&req->pad, 0, sizeof req->pad);
 449     req->out_port = htons(pf.out_port);
 450
 451     dump_stats_transaction(argv[1], request);
 452 }
 453
 454 static void
 455 do_dump_aggregate(int argc, char *argv[])
 456 {
 457     struct ofp_aggregate_stats_request *req;
 458     struct ofpbuf *request;
 459     struct parsed_flow pf;
 460
 461     req = alloc_stats_request(sizeof *req, OFPST_AGGREGATE, &request);
 462     parse_ofp_str(&pf, NULL, argc > 2 ? argv[2] : "");
 463     flow_to_match(&pf.rule.flow, pf.rule.wc.wildcards, NXFF_OPENFLOW10,
 464                   &req->match);
 465     memset(&req->pad, 0, sizeof req->pad);
 466     req->out_port = htons(pf.out_port);
 467
 468     dump_stats_transaction(argv[1], request);
 469 }
 470
 471 static void
 472 do_queue_stats(int argc, char *argv[])
 473 {
 474     struct ofp_queue_stats_request *req;
 475     struct ofpbuf *request;
 476
 477     req = alloc_stats_request(sizeof *req, OFPST_QUEUE, &request);
 478
 479     if (argc > 2 && argv[2][0] && strcasecmp(argv[2], "all")) {
 480         req->port_no = htons(str_to_port_no(argv[1], argv[2]));
 481     } else {
 482         req->port_no = htons(OFPP_ALL);
 483     }
 484     if (argc > 3 && argv[3][0] && strcasecmp(argv[3], "all")) {
 485         req->queue_id = htonl(atoi(argv[3]));
 486     } else {
 487         req->queue_id = htonl(OFPQ_ALL);
 488     }
 489
 490     memset(req->pad, 0, sizeof req->pad);
 491
 492     dump_stats_transaction(argv[1], request);
 493 }
 494
 495 static void
 496 do_add_flow(int argc OVS_UNUSED, char *argv[])
 497 {
 498     struct vconn *vconn;
 499     struct ofpbuf *buffer;
 500
 501     buffer = parse_ofp_flow_mod_str(argv[2], OFPFC_ADD);
 502
 503     open_vconn(argv[1], &vconn);
 504     send_openflow_buffer(vconn, buffer);
 505     vconn_close(vconn);
 506 }
 507
 508 static void
 509 do_add_flows(int argc OVS_UNUSED, char *argv[])
 510 {
 511     struct vconn *vconn;
 512     struct ofpbuf *b;
 513     FILE *file;
 514
 515     file = fopen(argv[2], "r");
 516     if (file == NULL) {
 517         ovs_fatal(errno, "%s: open", argv[2]);
 518     }
 519
 520     open_vconn(argv[1], &vconn);
 521     while ((b = parse_ofp_add_flow_file(file)) != NULL) {
 522         send_openflow_buffer(vconn, b);
 523     }
 524     vconn_close(vconn);
 525     fclose(file);
 526 }
 527
 528 static void
 529 do_mod_flows(int argc OVS_UNUSED, char *argv[])
 530 {
 531     struct vconn *vconn;
 532     struct ofpbuf *buffer;
 533     uint16_t command;
 534
 535     command = strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY;
 536     buffer = parse_ofp_flow_mod_str(argv[2], command);
 537     open_vconn(argv[1], &vconn);
 538     send_openflow_buffer(vconn, buffer);
 539     vconn_close(vconn);
 540 }
 541
 542 static void do_del_flows(int argc, char *argv[])
 543 {
 544     struct vconn *vconn;
 545     struct ofpbuf *buffer;
 546     uint16_t command;
 547
 548     command = strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE;
 549     buffer = parse_ofp_flow_mod_str(argc > 2 ? argv[2] : "", command);
 550
 551     open_vconn(argv[1], &vconn);
 552     send_openflow_buffer(vconn, buffer);
 553     vconn_close(vconn);
 554 }
 555
 556 static void
 557 do_tun_cookie(int argc OVS_UNUSED, char *argv[])
 558 {
 559     struct nxt_tun_id_cookie *tun_id_cookie;
 560     struct ofpbuf *buffer;
 561     struct vconn *vconn;
 562
 563     tun_id_cookie = make_nxmsg(sizeof *tun_id_cookie, NXT_TUN_ID_FROM_COOKIE,
 564                                &buffer);
 565     tun_id_cookie->set = !strcmp(argv[2], "true");
 566
 567     open_vconn(argv[1], &vconn);
 568     send_openflow_buffer(vconn, buffer);
 569     vconn_close(vconn);
 570 }
 571
 572 static void
 573 monitor_vconn(struct vconn *vconn)
 574 {
 575     for (;;) {
 576         struct ofpbuf *b;
 577         run(vconn_recv_block(vconn, &b), "vconn_recv");
 578         ofp_print(stderr, b->data, b->size, 2);
 579         ofpbuf_delete(b);
 580     }
 581 }
 582
 583 static void
 584 do_monitor(int argc, char *argv[])
 585 {
 586     struct vconn *vconn;
 587
 588     open_vconn(argv[1], &vconn);
 589     if (argc > 2) {
 590         int miss_send_len = atoi(argv[2]);
 591         struct ofp_switch_config *osc;
 592         struct ofpbuf *buf;
 593
 594         osc = make_openflow(sizeof *osc, OFPT_SET_CONFIG, &buf);
 595         osc->miss_send_len = htons(miss_send_len);
 596         send_openflow_buffer(vconn, buf);
 597     }
 598     monitor_vconn(vconn);
 599 }
 600
 601 static void
 602 do_snoop(int argc OVS_UNUSED, char *argv[])
 603 {
 604     struct vconn *vconn;
 605
 606     open_vconn__(argv[1], "snoop", &vconn);
 607     monitor_vconn(vconn);
 608 }
 609
 610 static void
 611 do_dump_ports(int argc, char *argv[])
 612 {
 613     struct ofp_port_stats_request *req;
 614     struct ofpbuf *request;
 615     uint16_t port;
 616
 617     req = alloc_stats_request(sizeof *req, OFPST_PORT, &request);
 618     port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_NONE;
 619     req->port_no = htons(port);
 620     dump_stats_transaction(argv[1], request);
 621 }
 622
 623 static void
 624 do_probe(int argc OVS_UNUSED, char *argv[])
 625 {
 626     struct ofpbuf *request;
 627     struct vconn *vconn;
 628     struct ofpbuf *reply;
 629
 630     make_openflow(sizeof(struct ofp_header), OFPT_ECHO_REQUEST, &request);
 631     open_vconn(argv[1], &vconn);
 632     run(vconn_transact(vconn, request, &reply), "talking to %s", argv[1]);
 633     if (reply->size != sizeof(struct ofp_header)) {
 634         ovs_fatal(0, "reply does not match request");
 635     }
 636     ofpbuf_delete(reply);
 637     vconn_close(vconn);
 638 }
 639
 640 static void
 641 do_mod_port(int argc OVS_UNUSED, char *argv[])
 642 {
 643     struct ofpbuf *request, *reply;
 644     struct ofp_switch_features *osf;
 645     struct ofp_port_mod *opm;
 646     struct vconn *vconn;
 647     char *endptr;
 648     int n_ports;
 649     int port_idx;
 650     int port_no;
 651
 652
 653     /* Check if the argument is a port index.  Otherwise, treat it as
 654      * the port name. */
 655     port_no = strtol(argv[2], &endptr, 10);
 656     if (port_no == 0 && endptr == argv[2]) {
 657         port_no = -1;
 658     }
 659
 660     /* Send a "Features Request" to get the information we need in order
 661      * to modify the port. */
 662     make_openflow(sizeof(struct ofp_header), OFPT_FEATURES_REQUEST, &request);
 663     open_vconn(argv[1], &vconn);
 664     run(vconn_transact(vconn, request, &reply), "talking to %s", argv[1]);
 665
 666     osf = reply->data;
 667     n_ports = (reply->size - sizeof *osf) / sizeof *osf->ports;
 668
 669     for (port_idx = 0; port_idx < n_ports; port_idx++) {
 670         if (port_no != -1) {
 671             /* Check argument as a port index */
 672             if (osf->ports[port_idx].port_no == htons(port_no)) {
 673                 break;
 674             }
 675         } else {
 676             /* Check argument as an interface name */
 677             if (!strncmp((char *)osf->ports[port_idx].name, argv[2],
 678                         sizeof osf->ports[0].name)) {
 679                 break;
 680             }
 681
 682         }
 683     }
 684     if (port_idx == n_ports) {
 685         ovs_fatal(0, "couldn't find monitored port: %s", argv[2]);
 686     }
 687
 688     opm = make_openflow(sizeof(struct ofp_port_mod), OFPT_PORT_MOD, &request);
 689     opm->port_no = osf->ports[port_idx].port_no;
 690     memcpy(opm->hw_addr, osf->ports[port_idx].hw_addr, sizeof opm->hw_addr);
 691     opm->config = htonl(0);
 692     opm->mask = htonl(0);
 693     opm->advertise = htonl(0);
 694
 695     printf("modifying port: %s\n", osf->ports[port_idx].name);
 696
 697     if (!strncasecmp(argv[3], MOD_PORT_CMD_UP, sizeof MOD_PORT_CMD_UP)) {
 698         opm->mask |= htonl(OFPPC_PORT_DOWN);
 699     } else if (!strncasecmp(argv[3], MOD_PORT_CMD_DOWN,
 700                 sizeof MOD_PORT_CMD_DOWN)) {
 701         opm->mask |= htonl(OFPPC_PORT_DOWN);
 702         opm->config |= htonl(OFPPC_PORT_DOWN);
 703     } else if (!strncasecmp(argv[3], MOD_PORT_CMD_FLOOD,
 704                 sizeof MOD_PORT_CMD_FLOOD)) {
 705         opm->mask |= htonl(OFPPC_NO_FLOOD);
 706     } else if (!strncasecmp(argv[3], MOD_PORT_CMD_NOFLOOD,
 707                 sizeof MOD_PORT_CMD_NOFLOOD)) {
 708         opm->mask |= htonl(OFPPC_NO_FLOOD);
 709         opm->config |= htonl(OFPPC_NO_FLOOD);
 710     } else {
 711         ovs_fatal(0, "unknown mod-port command '%s'", argv[3]);
 712     }
 713
 714     send_openflow_buffer(vconn, request);
 715
 716     ofpbuf_delete(reply);
 717     vconn_close(vconn);
 718 }
 719
 720 static void
 721 do_ping(int argc, char *argv[])
 722 {
 723     size_t max_payload = 65535 - sizeof(struct ofp_header);
 724     unsigned int payload;
 725     struct vconn *vconn;
 726     int i;
 727
 728     payload = argc > 2 ? atoi(argv[2]) : 64;
 729     if (payload > max_payload) {
 730         ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload);
 731     }
 732
 733     open_vconn(argv[1], &vconn);
 734     for (i = 0; i < 10; i++) {
 735         struct timeval start, end;
 736         struct ofpbuf *request, *reply;
 737         struct ofp_header *rq_hdr, *rpy_hdr;
 738
 739         rq_hdr = make_openflow(sizeof(struct ofp_header) + payload,
 740                                OFPT_ECHO_REQUEST, &request);
 741         random_bytes(rq_hdr + 1, payload);
 742
 743         gettimeofday(&start, NULL);
 744         run(vconn_transact(vconn, ofpbuf_clone(request), &reply), "transact");
 745         gettimeofday(&end, NULL);
 746
 747         rpy_hdr = reply->data;
 748         if (reply->size != request->size
 749             || memcmp(rpy_hdr + 1, rq_hdr + 1, payload)
 750             || rpy_hdr->xid != rq_hdr->xid
 751             || rpy_hdr->type != OFPT_ECHO_REPLY) {
 752             printf("Reply does not match request.  Request:\n");
 753             ofp_print(stdout, request, request->size, 2);
 754             printf("Reply:\n");
 755             ofp_print(stdout, reply, reply->size, 2);
 756         }
 757         printf("%zu bytes from %s: xid=%08"PRIx32" time=%.1f ms\n",
 758                reply->size - sizeof *rpy_hdr, argv[1], rpy_hdr->xid,
 759                    (1000*(double)(end.tv_sec - start.tv_sec))
 760                    + (.001*(end.tv_usec - start.tv_usec)));
 761         ofpbuf_delete(request);
 762         ofpbuf_delete(reply);
 763     }
 764     vconn_close(vconn);
 765 }
 766
 767 static void
 768 do_benchmark(int argc OVS_UNUSED, char *argv[])
 769 {
 770     size_t max_payload = 65535 - sizeof(struct ofp_header);
 771     struct timeval start, end;
 772     unsigned int payload_size, message_size;
 773     struct vconn *vconn;
 774     double duration;
 775     int count;
 776     int i;
 777
 778     payload_size = atoi(argv[2]);
 779     if (payload_size > max_payload) {
 780         ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload);
 781     }
 782     message_size = sizeof(struct ofp_header) + payload_size;
 783
 784     count = atoi(argv[3]);
 785
 786     printf("Sending %d packets * %u bytes (with header) = %u bytes total\n",
 787            count, message_size, count * message_size);
 788
 789     open_vconn(argv[1], &vconn);
 790     gettimeofday(&start, NULL);
 791     for (i = 0; i < count; i++) {
 792         struct ofpbuf *request, *reply;
 793         struct ofp_header *rq_hdr;
 794
 795         rq_hdr = make_openflow(message_size, OFPT_ECHO_REQUEST, &request);
 796         memset(rq_hdr + 1, 0, payload_size);
 797         run(vconn_transact(vconn, request, &reply), "transact");
 798         ofpbuf_delete(reply);
 799     }
 800     gettimeofday(&end, NULL);
 801     vconn_close(vconn);
 802
 803     duration = ((1000*(double)(end.tv_sec - start.tv_sec))
 804                 + (.001*(end.tv_usec - start.tv_usec)));
 805     printf("Finished in %.1f ms (%.0f packets/s) (%.0f bytes/s)\n",
 806            duration, count / (duration / 1000.0),
 807            count * message_size / (duration / 1000.0));
 808 }
 809
 810 static void
 811 do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 812 {
 813     usage();
 814 }
 815 \f
 816 /* Undocumented commands for unit testing. */
 817
 818 static void
 819 do_parse_flows(int argc OVS_UNUSED, char *argv[])
 820 {
 821     struct ofpbuf *b;
 822     FILE *file;
 823
 824     file = fopen(argv[1], "r");
 825     if (file == NULL) {
 826         ovs_fatal(errno, "%s: open", argv[2]);
 827     }
 828
 829     while ((b = parse_ofp_add_flow_file(file)) != NULL) {
 830         ofp_print(stdout, b->data, b->size, 0);
 831         ofpbuf_delete(b);
 832     }
 833     fclose(file);
 834 }
 835
 836 static void
 837 do_parse_nx_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 838 {
 839     struct ds in;
 840
 841     ds_init(&in);
 842     while (!ds_get_line(&in, stdin)) {
 843         struct ofpbuf nx_match;
 844         struct cls_rule rule;
 845         int match_len;
 846         int error;
 847         char *s;
 848
 849         /* Delete comments, skip blank lines. */
 850         s = ds_cstr(&in);
 851         if (*s == '#') {
 852             puts(s);
 853             continue;
 854         }
 855         if (strchr(s, '#')) {
 856             *strchr(s, '#') = '\0';
 857         }
 858         if (s[strspn(s, " ")] == '\0') {
 859             putchar('\n');
 860             continue;
 861         }
 862
 863         /* Convert string to nx_match. */
 864         ofpbuf_init(&nx_match, 0);
 865         match_len = nx_match_from_string(ds_cstr(&in), &nx_match);
 866
 867         /* Convert nx_match to cls_rule. */
 868         error = nx_pull_match(&nx_match, match_len, 0, &rule);
 869         if (!error) {
 870             char *out;
 871
 872             /* Convert cls_rule back to nx_match. */
 873             ofpbuf_uninit(&nx_match);
 874             ofpbuf_init(&nx_match, 0);
 875             match_len = nx_put_match(&nx_match, &rule);
 876
 877             /* Convert nx_match to string. */
 878             out = nx_match_to_string(nx_match.data, match_len);
 879             puts(out);
 880             free(out);
 881         } else {
 882             printf("nx_pull_match() returned error %x\n", error);
 883         }
 884
 885         ofpbuf_uninit(&nx_match);
 886     }
 887     ds_destroy(&in);
 888 }
 889
 890 static const struct command all_commands[] = {
 891     { "show", 1, 1, do_show },
 892     { "status", 1, 2, do_status },
 893     { "monitor", 1, 2, do_monitor },
 894     { "snoop", 1, 1, do_snoop },
 895     { "dump-desc", 1, 1, do_dump_desc },
 896     { "dump-tables", 1, 1, do_dump_tables },
 897     { "dump-flows", 1, 2, do_dump_flows },
 898     { "dump-aggregate", 1, 2, do_dump_aggregate },
 899     { "queue-stats", 1, 3, do_queue_stats },
 900     { "add-flow", 2, 2, do_add_flow },
 901     { "add-flows", 2, 2, do_add_flows },
 902     { "mod-flows", 2, 2, do_mod_flows },
 903     { "del-flows", 1, 2, do_del_flows },
 904     { "tun-cookie", 2, 2, do_tun_cookie },
 905     { "dump-ports", 1, 2, do_dump_ports },
 906     { "mod-port", 3, 3, do_mod_port },
 907     { "probe", 1, 1, do_probe },
 908     { "ping", 1, 2, do_ping },
 909     { "benchmark", 3, 3, do_benchmark },
 910     { "help", 0, INT_MAX, do_help },
 911
 912     /* Undocumented commands for testing. */
 913     { "parse-flows", 1, 1, do_parse_flows },
 914     { "parse-nx-match", 0, 0, do_parse_nx_match },
 915
 916     { NULL, 0, 0, NULL },
 917 };