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 /* Sends 'request', which should be a request that only has a reply if an error
 341  * occurs, and waits for it to succeed or fail.  If an error does occur, prints
 342  * it and exits with an error. */
 343 static void
 344 dump_noreply_transaction(struct vconn *vconn, struct ofpbuf *request)
 345 {
 346     struct ofpbuf *reply;
 347
 348     update_openflow_length(request);
 349     run(vconn_transact_noreply(vconn, request, &reply),
 350         "talking to %s", vconn_get_name(vconn));
 351     if (reply) {
 352         ofp_print(stderr, reply->data, reply->size, 2);
 353         exit(1);
 354     }
 355     ofpbuf_delete(reply);
 356 }
 357
 358 static void
 359 do_show(int argc OVS_UNUSED, char *argv[])
 360 {
 361     dump_trivial_transaction(argv[1], OFPT_FEATURES_REQUEST);
 362     dump_trivial_transaction(argv[1], OFPT_GET_CONFIG_REQUEST);
 363 }
 364
 365 static void
 366 do_status(int argc, char *argv[])
 367 {
 368     struct nicira_header *request, *reply;
 369     struct vconn *vconn;
 370     struct ofpbuf *b;
 371
 372     request = make_nxmsg(sizeof *request, NXT_STATUS_REQUEST, &b);
 373     if (argc > 2) {
 374         ofpbuf_put(b, argv[2], strlen(argv[2]));
 375         update_openflow_length(b);
 376     }
 377     open_vconn(argv[1], &vconn);
 378     run(vconn_transact(vconn, b, &b), "talking to %s", argv[1]);
 379     vconn_close(vconn);
 380
 381     if (b->size < sizeof *reply) {
 382         ovs_fatal(0, "short reply (%zu bytes)", b->size);
 383     }
 384     reply = b->data;
 385     if (reply->header.type != OFPT_VENDOR
 386         || reply->vendor != ntohl(NX_VENDOR_ID)
 387         || reply->subtype != ntohl(NXT_STATUS_REPLY)) {
 388         ofp_print(stderr, b->data, b->size, 2);
 389         ovs_fatal(0, "bad reply");
 390     }
 391
 392     fwrite(reply + 1, b->size - sizeof *reply, 1, stdout);
 393 }
 394
 395 static void
 396 do_dump_desc(int argc OVS_UNUSED, char *argv[])
 397 {
 398     dump_trivial_stats_transaction(argv[1], OFPST_DESC);
 399 }
 400
 401 static void
 402 do_dump_tables(int argc OVS_UNUSED, char *argv[])
 403 {
 404     dump_trivial_stats_transaction(argv[1], OFPST_TABLE);
 405 }
 406
 407 /* Opens a connection to 'vconn_name', fetches the ofp_phy_port structure for
 408  * 'port_name' (which may be a port name or number), and copies it into
 409  * '*oppp'. */
 410 static void
 411 fetch_ofp_phy_port(const char *vconn_name, const char *port_name,
 412                    struct ofp_phy_port *oppp)
 413 {
 414     struct ofpbuf *request, *reply;
 415     struct ofp_switch_features *osf;
 416     unsigned int port_no;
 417     struct vconn *vconn;
 418     int n_ports;
 419     int port_idx;
 420
 421     /* Try to interpret the argument as a port number. */
 422     if (!str_to_uint(port_name, 10, &port_no)) {
 423         port_no = UINT_MAX;
 424     }
 425
 426     /* Fetch the switch's ofp_switch_features. */
 427     make_openflow(sizeof(struct ofp_header), OFPT_FEATURES_REQUEST, &request);
 428     open_vconn(vconn_name, &vconn);
 429     run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
 430
 431     osf = reply->data;
 432     if (reply->size < sizeof *osf) {
 433         ovs_fatal(0, "%s: received too-short features reply (only %zu bytes)",
 434                   vconn_name, reply->size);
 435     }
 436     n_ports = (reply->size - sizeof *osf) / sizeof *osf->ports;
 437
 438     for (port_idx = 0; port_idx < n_ports; port_idx++) {
 439         const struct ofp_phy_port *opp = &osf->ports[port_idx];
 440
 441         if (port_no != UINT_MAX
 442             ? htons(port_no) == opp->port_no
 443             : !strncmp((char *) opp->name, port_name, sizeof opp->name)) {
 444             *oppp = *opp;
 445             ofpbuf_delete(reply);
 446             vconn_close(vconn);
 447             return;
 448         }
 449     }
 450     ovs_fatal(0, "%s: couldn't find port `%s'", vconn_name, port_name);
 451 }
 452
 453 /* Returns the port number corresponding to 'port_name' (which may be a port
 454  * name or number) within the switch 'vconn_name'. */
 455 static uint16_t
 456 str_to_port_no(const char *vconn_name, const char *port_name)
 457 {
 458     unsigned int port_no;
 459
 460     if (str_to_uint(port_name, 10, &port_no)) {
 461         return port_no;
 462     } else {
 463         struct ofp_phy_port opp;
 464
 465         fetch_ofp_phy_port(vconn_name, port_name, &opp);
 466         return ntohs(opp.port_no);
 467     }
 468 }
 469
 470 static void
 471 do_dump_flows(int argc, char *argv[])
 472 {
 473     struct ofp_flow_stats_request *req;
 474     struct parsed_flow pf;
 475     struct ofpbuf *request;
 476
 477     req = alloc_stats_request(sizeof *req, OFPST_FLOW, &request);
 478     parse_ofp_str(&pf, NULL, argc > 2 ? argv[2] : "");
 479     ofputil_cls_rule_to_match(&pf.rule, NXFF_OPENFLOW10, &req->match);
 480     memset(&req->pad, 0, sizeof req->pad);
 481     req->out_port = htons(pf.out_port);
 482
 483     dump_stats_transaction(argv[1], request);
 484 }
 485
 486 static void
 487 do_dump_aggregate(int argc, char *argv[])
 488 {
 489     struct ofp_aggregate_stats_request *req;
 490     struct ofpbuf *request;
 491     struct parsed_flow pf;
 492
 493     req = alloc_stats_request(sizeof *req, OFPST_AGGREGATE, &request);
 494     parse_ofp_str(&pf, NULL, argc > 2 ? argv[2] : "");
 495     ofputil_cls_rule_to_match(&pf.rule, NXFF_OPENFLOW10, &req->match);
 496     memset(&req->pad, 0, sizeof req->pad);
 497     req->out_port = htons(pf.out_port);
 498
 499     dump_stats_transaction(argv[1], request);
 500 }
 501
 502 static void
 503 do_queue_stats(int argc, char *argv[])
 504 {
 505     struct ofp_queue_stats_request *req;
 506     struct ofpbuf *request;
 507
 508     req = alloc_stats_request(sizeof *req, OFPST_QUEUE, &request);
 509
 510     if (argc > 2 && argv[2][0] && strcasecmp(argv[2], "all")) {
 511         req->port_no = htons(str_to_port_no(argv[1], argv[2]));
 512     } else {
 513         req->port_no = htons(OFPP_ALL);
 514     }
 515     if (argc > 3 && argv[3][0] && strcasecmp(argv[3], "all")) {
 516         req->queue_id = htonl(atoi(argv[3]));
 517     } else {
 518         req->queue_id = htonl(OFPQ_ALL);
 519     }
 520
 521     memset(req->pad, 0, sizeof req->pad);
 522
 523     dump_stats_transaction(argv[1], request);
 524 }
 525
 526 static void
 527 do_add_flow(int argc OVS_UNUSED, char *argv[])
 528 {
 529     struct vconn *vconn;
 530     struct ofpbuf *request;
 531
 532     request = parse_ofp_flow_mod_str(argv[2], OFPFC_ADD);
 533
 534     open_vconn(argv[1], &vconn);
 535     dump_noreply_transaction(vconn, request);
 536     vconn_close(vconn);
 537 }
 538
 539 static void
 540 do_add_flows(int argc OVS_UNUSED, char *argv[])
 541 {
 542     struct vconn *vconn;
 543     struct ofpbuf *b;
 544     FILE *file;
 545
 546     file = fopen(argv[2], "r");
 547     if (file == NULL) {
 548         ovs_fatal(errno, "%s: open", argv[2]);
 549     }
 550
 551     open_vconn(argv[1], &vconn);
 552     while ((b = parse_ofp_add_flow_file(file)) != NULL) {
 553         dump_noreply_transaction(vconn, b);
 554     }
 555     vconn_close(vconn);
 556     fclose(file);
 557 }
 558
 559 static void
 560 do_mod_flows(int argc OVS_UNUSED, char *argv[])
 561 {
 562     struct vconn *vconn;
 563     struct ofpbuf *buffer;
 564     uint16_t command;
 565
 566     command = strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY;
 567     buffer = parse_ofp_flow_mod_str(argv[2], command);
 568     open_vconn(argv[1], &vconn);
 569     dump_noreply_transaction(vconn, buffer);
 570     vconn_close(vconn);
 571 }
 572
 573 static void do_del_flows(int argc, char *argv[])
 574 {
 575     struct vconn *vconn;
 576     struct ofpbuf *buffer;
 577     uint16_t command;
 578
 579     command = strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE;
 580     buffer = parse_ofp_flow_mod_str(argc > 2 ? argv[2] : "", command);
 581
 582     open_vconn(argv[1], &vconn);
 583     dump_noreply_transaction(vconn, buffer);
 584     vconn_close(vconn);
 585 }
 586
 587 static void
 588 monitor_vconn(struct vconn *vconn)
 589 {
 590     for (;;) {
 591         struct ofpbuf *b;
 592         run(vconn_recv_block(vconn, &b), "vconn_recv");
 593         ofp_print(stderr, b->data, b->size, 2);
 594         ofpbuf_delete(b);
 595     }
 596 }
 597
 598 static void
 599 do_monitor(int argc, char *argv[])
 600 {
 601     struct vconn *vconn;
 602
 603     open_vconn(argv[1], &vconn);
 604     if (argc > 2) {
 605         int miss_send_len = atoi(argv[2]);
 606         struct ofp_switch_config *osc;
 607         struct ofpbuf *buf;
 608
 609         osc = make_openflow(sizeof *osc, OFPT_SET_CONFIG, &buf);
 610         osc->miss_send_len = htons(miss_send_len);
 611         dump_noreply_transaction(vconn, buf);
 612     }
 613     monitor_vconn(vconn);
 614 }
 615
 616 static void
 617 do_snoop(int argc OVS_UNUSED, char *argv[])
 618 {
 619     struct vconn *vconn;
 620
 621     open_vconn__(argv[1], "snoop", &vconn);
 622     monitor_vconn(vconn);
 623 }
 624
 625 static void
 626 do_dump_ports(int argc, char *argv[])
 627 {
 628     struct ofp_port_stats_request *req;
 629     struct ofpbuf *request;
 630     uint16_t port;
 631
 632     req = alloc_stats_request(sizeof *req, OFPST_PORT, &request);
 633     port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_NONE;
 634     req->port_no = htons(port);
 635     dump_stats_transaction(argv[1], request);
 636 }
 637
 638 static void
 639 do_probe(int argc OVS_UNUSED, char *argv[])
 640 {
 641     struct ofpbuf *request;
 642     struct vconn *vconn;
 643     struct ofpbuf *reply;
 644
 645     make_openflow(sizeof(struct ofp_header), OFPT_ECHO_REQUEST, &request);
 646     open_vconn(argv[1], &vconn);
 647     run(vconn_transact(vconn, request, &reply), "talking to %s", argv[1]);
 648     if (reply->size != sizeof(struct ofp_header)) {
 649         ovs_fatal(0, "reply does not match request");
 650     }
 651     ofpbuf_delete(reply);
 652     vconn_close(vconn);
 653 }
 654
 655 static void
 656 do_mod_port(int argc OVS_UNUSED, char *argv[])
 657 {
 658     struct ofp_port_mod *opm;
 659     struct ofp_phy_port opp;
 660     struct ofpbuf *request;
 661     struct vconn *vconn;
 662
 663     fetch_ofp_phy_port(argv[1], argv[2], &opp);
 664
 665     opm = make_openflow(sizeof(struct ofp_port_mod), OFPT_PORT_MOD, &request);
 666     opm->port_no = opp.port_no;
 667     memcpy(opm->hw_addr, opp.hw_addr, sizeof opm->hw_addr);
 668     opm->config = htonl(0);
 669     opm->mask = htonl(0);
 670     opm->advertise = htonl(0);
 671
 672     if (!strcasecmp(argv[3], "up")) {
 673         opm->mask |= htonl(OFPPC_PORT_DOWN);
 674     } else if (!strcasecmp(argv[3], "down")) {
 675         opm->mask |= htonl(OFPPC_PORT_DOWN);
 676         opm->config |= htonl(OFPPC_PORT_DOWN);
 677     } else if (!strcasecmp(argv[3], "flood")) {
 678         opm->mask |= htonl(OFPPC_NO_FLOOD);
 679     } else if (!strcasecmp(argv[3], "noflood")) {
 680         opm->mask |= htonl(OFPPC_NO_FLOOD);
 681         opm->config |= htonl(OFPPC_NO_FLOOD);
 682     } else {
 683         ovs_fatal(0, "unknown mod-port command '%s'", argv[3]);
 684     }
 685
 686     open_vconn(argv[1], &vconn);
 687     dump_noreply_transaction(vconn, request);
 688     vconn_close(vconn);
 689 }
 690
 691 static void
 692 do_ping(int argc, char *argv[])
 693 {
 694     size_t max_payload = 65535 - sizeof(struct ofp_header);
 695     unsigned int payload;
 696     struct vconn *vconn;
 697     int i;
 698
 699     payload = argc > 2 ? atoi(argv[2]) : 64;
 700     if (payload > max_payload) {
 701         ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload);
 702     }
 703
 704     open_vconn(argv[1], &vconn);
 705     for (i = 0; i < 10; i++) {
 706         struct timeval start, end;
 707         struct ofpbuf *request, *reply;
 708         struct ofp_header *rq_hdr, *rpy_hdr;
 709
 710         rq_hdr = make_openflow(sizeof(struct ofp_header) + payload,
 711                                OFPT_ECHO_REQUEST, &request);
 712         random_bytes(rq_hdr + 1, payload);
 713
 714         gettimeofday(&start, NULL);
 715         run(vconn_transact(vconn, ofpbuf_clone(request), &reply), "transact");
 716         gettimeofday(&end, NULL);
 717
 718         rpy_hdr = reply->data;
 719         if (reply->size != request->size
 720             || memcmp(rpy_hdr + 1, rq_hdr + 1, payload)
 721             || rpy_hdr->xid != rq_hdr->xid
 722             || rpy_hdr->type != OFPT_ECHO_REPLY) {
 723             printf("Reply does not match request.  Request:\n");
 724             ofp_print(stdout, request, request->size, 2);
 725             printf("Reply:\n");
 726             ofp_print(stdout, reply, reply->size, 2);
 727         }
 728         printf("%zu bytes from %s: xid=%08"PRIx32" time=%.1f ms\n",
 729                reply->size - sizeof *rpy_hdr, argv[1], ntohl(rpy_hdr->xid),
 730                    (1000*(double)(end.tv_sec - start.tv_sec))
 731                    + (.001*(end.tv_usec - start.tv_usec)));
 732         ofpbuf_delete(request);
 733         ofpbuf_delete(reply);
 734     }
 735     vconn_close(vconn);
 736 }
 737
 738 static void
 739 do_benchmark(int argc OVS_UNUSED, char *argv[])
 740 {
 741     size_t max_payload = 65535 - sizeof(struct ofp_header);
 742     struct timeval start, end;
 743     unsigned int payload_size, message_size;
 744     struct vconn *vconn;
 745     double duration;
 746     int count;
 747     int i;
 748
 749     payload_size = atoi(argv[2]);
 750     if (payload_size > max_payload) {
 751         ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload);
 752     }
 753     message_size = sizeof(struct ofp_header) + payload_size;
 754
 755     count = atoi(argv[3]);
 756
 757     printf("Sending %d packets * %u bytes (with header) = %u bytes total\n",
 758            count, message_size, count * message_size);
 759
 760     open_vconn(argv[1], &vconn);
 761     gettimeofday(&start, NULL);
 762     for (i = 0; i < count; i++) {
 763         struct ofpbuf *request, *reply;
 764         struct ofp_header *rq_hdr;
 765
 766         rq_hdr = make_openflow(message_size, OFPT_ECHO_REQUEST, &request);
 767         memset(rq_hdr + 1, 0, payload_size);
 768         run(vconn_transact(vconn, request, &reply), "transact");
 769         ofpbuf_delete(reply);
 770     }
 771     gettimeofday(&end, NULL);
 772     vconn_close(vconn);
 773
 774     duration = ((1000*(double)(end.tv_sec - start.tv_sec))
 775                 + (.001*(end.tv_usec - start.tv_usec)));
 776     printf("Finished in %.1f ms (%.0f packets/s) (%.0f bytes/s)\n",
 777            duration, count / (duration / 1000.0),
 778            count * message_size / (duration / 1000.0));
 779 }
 780
 781 static void
 782 do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 783 {
 784     usage();
 785 }
 786 \f
 787 /* Undocumented commands for unit testing. */
 788
 789 static void
 790 do_parse_flows(int argc OVS_UNUSED, char *argv[])
 791 {
 792     struct ofpbuf *b;
 793     FILE *file;
 794
 795     file = fopen(argv[1], "r");
 796     if (file == NULL) {
 797         ovs_fatal(errno, "%s: open", argv[2]);
 798     }
 799
 800     while ((b = parse_ofp_add_flow_file(file)) != NULL) {
 801         ofp_print(stdout, b->data, b->size, 0);
 802         ofpbuf_delete(b);
 803     }
 804     fclose(file);
 805 }
 806
 807 static void
 808 do_parse_nx_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 809 {
 810     struct ds in;
 811
 812     ds_init(&in);
 813     while (!ds_get_line(&in, stdin)) {
 814         struct ofpbuf nx_match;
 815         struct cls_rule rule;
 816         int match_len;
 817         int error;
 818         char *s;
 819
 820         /* Delete comments, skip blank lines. */
 821         s = ds_cstr(&in);
 822         if (*s == '#') {
 823             puts(s);
 824             continue;
 825         }
 826         if (strchr(s, '#')) {
 827             *strchr(s, '#') = '\0';
 828         }
 829         if (s[strspn(s, " ")] == '\0') {
 830             putchar('\n');
 831             continue;
 832         }
 833
 834         /* Convert string to nx_match. */
 835         ofpbuf_init(&nx_match, 0);
 836         match_len = nx_match_from_string(ds_cstr(&in), &nx_match);
 837
 838         /* Convert nx_match to cls_rule. */
 839         error = nx_pull_match(&nx_match, match_len, 0, &rule);
 840         if (!error) {
 841             char *out;
 842
 843             /* Convert cls_rule back to nx_match. */
 844             ofpbuf_uninit(&nx_match);
 845             ofpbuf_init(&nx_match, 0);
 846             match_len = nx_put_match(&nx_match, &rule);
 847
 848             /* Convert nx_match to string. */
 849             out = nx_match_to_string(nx_match.data, match_len);
 850             puts(out);
 851             free(out);
 852         } else {
 853             printf("nx_pull_match() returned error %x\n", error);
 854         }
 855
 856         ofpbuf_uninit(&nx_match);
 857     }
 858     ds_destroy(&in);
 859 }
 860
 861 static const struct command all_commands[] = {
 862     { "show", 1, 1, do_show },
 863     { "status", 1, 2, do_status },
 864     { "monitor", 1, 2, do_monitor },
 865     { "snoop", 1, 1, do_snoop },
 866     { "dump-desc", 1, 1, do_dump_desc },
 867     { "dump-tables", 1, 1, do_dump_tables },
 868     { "dump-flows", 1, 2, do_dump_flows },
 869     { "dump-aggregate", 1, 2, do_dump_aggregate },
 870     { "queue-stats", 1, 3, do_queue_stats },
 871     { "add-flow", 2, 2, do_add_flow },
 872     { "add-flows", 2, 2, do_add_flows },
 873     { "mod-flows", 2, 2, do_mod_flows },
 874     { "del-flows", 1, 2, do_del_flows },
 875     { "dump-ports", 1, 2, do_dump_ports },
 876     { "mod-port", 3, 3, do_mod_port },
 877     { "probe", 1, 1, do_probe },
 878     { "ping", 1, 2, do_ping },
 879     { "benchmark", 3, 3, do_benchmark },
 880     { "help", 0, INT_MAX, do_help },
 881
 882     /* Undocumented commands for testing. */
 883     { "parse-flows", 1, 1, do_parse_flows },
 884     { "parse-nx-match", 0, 0, do_parse_nx_match },
 885
 886     { NULL, 0, 0, NULL },
 887 };