utilities/ovs-vsctl.c

   1 /*
   2  * Copyright (c) 2009 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
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <getopt.h>
  22 #include <inttypes.h>
  23 #include <signal.h>
  24 #include <stdarg.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "command-line.h"
  29 #include "compiler.h"
  30 #include "dirs.h"
  31 #include "dynamic-string.h"
  32 #include "ovsdb-idl.h"
  33 #include "poll-loop.h"
  34 #include "svec.h"
  35 #include "vswitchd/vswitch-idl.h"
  36 #include "timeval.h"
  37 #include "util.h"
  38
  39 #include "vlog.h"
  40 #define THIS_MODULE VLM_vsctl
  41
  42 /* --db: The database server to contact. */
  43 static const char *db;
  44
  45 /* --oneline: Write each command's output as a single line? */
  46 static bool oneline;
  47
  48 static char *default_db(void);
  49 static void usage(void) NO_RETURN;
  50 static void parse_options(int argc, char *argv[]);
  51
  52 static void check_vsctl_command(int argc, char *argv[]);
  53 static void do_vsctl(int argc, char *argv[], struct ovsdb_idl *idl);
  54
  55 int
  56 main(int argc, char *argv[])
  57 {
  58     struct ovsdb_idl *idl;
  59     unsigned int seqno;
  60     struct ds args;
  61     int start, n_commands;
  62     int trials;
  63     int i;
  64
  65     set_program_name(argv[0]);
  66     signal(SIGPIPE, SIG_IGN);
  67     time_init();
  68     vlog_init();
  69     vlog_set_levels(VLM_ANY_MODULE, VLF_CONSOLE, VLL_WARN);
  70     vlog_set_levels(VLM_reconnect, VLF_ANY_FACILITY, VLL_WARN);
  71     parse_options(argc, argv);
  72
  73     /* Log our arguments.  This is often valuable for debugging systems. */
  74     ds_init(&args);
  75     for (i = 1; i < argc; i++) {
  76         ds_put_format(&args, " %s", argv[i]);
  77     }
  78     VLOG_INFO("Called as%s", ds_cstr(&args));
  79     ds_destroy(&args);
  80
  81     /* Do basic command syntax checking. */
  82     n_commands = 0;
  83     for (start = i = optind; i <= argc; i++) {
  84         if (i == argc || !strcmp(argv[i], "--")) {
  85             if (i > start) {
  86                 check_vsctl_command(i - start, &argv[start]);
  87                 n_commands++;
  88             }
  89             start = i + 1;
  90         }
  91     }
  92     if (!n_commands) {
  93         ovs_fatal(0, "missing command name (use --help for help)");
  94     }
  95
  96     /* Now execut the commands. */
  97     idl = ovsdb_idl_create(db, &ovsrec_idl_class);
  98     seqno = ovsdb_idl_get_seqno(idl);
  99     trials = 0;
 100     for (;;) {
 101         unsigned int new_seqno;
 102
 103         ovsdb_idl_run(idl);
 104         new_seqno = ovsdb_idl_get_seqno(idl);
 105         if (new_seqno != seqno) {
 106             if (++trials > 5) {
 107                 ovs_fatal(0, "too many database inconsistency failures");
 108             }
 109             do_vsctl(argc - optind, argv + optind, idl);
 110             seqno = new_seqno;
 111         }
 112
 113         ovsdb_idl_wait(idl);
 114         poll_block();
 115     }
 116 }
 117
 118 static void
 119 parse_options(int argc, char *argv[])
 120 {
 121     enum {
 122         OPT_DB = UCHAR_MAX + 1,
 123         OPT_ONELINE,
 124         OPT_NO_SYSLOG
 125     };
 126     static struct option long_options[] = {
 127         {"db", required_argument, 0, OPT_DB},
 128         {"no-syslog", no_argument, 0, OPT_NO_SYSLOG},
 129         {"oneline", no_argument, 0, OPT_ONELINE},
 130         {"verbose", optional_argument, 0, 'v'},
 131         {"help", no_argument, 0, 'h'},
 132         {"version", no_argument, 0, 'V'},
 133         {0, 0, 0, 0},
 134     };
 135
 136     for (;;) {
 137         int c;
 138
 139         c = getopt_long(argc, argv, "+v::hV", long_options, NULL);
 140         if (c == -1) {
 141             break;
 142         }
 143
 144         switch (c) {
 145         case OPT_DB:
 146             db = optarg;
 147             break;
 148
 149         case OPT_ONELINE:
 150             oneline = true;
 151             break;
 152
 153         case OPT_NO_SYSLOG:
 154             vlog_set_levels(VLM_vsctl, VLF_SYSLOG, VLL_WARN);
 155             break;
 156
 157         case 'h':
 158             usage();
 159
 160         case 'V':
 161             OVS_PRINT_VERSION(0, 0);
 162             exit(EXIT_SUCCESS);
 163
 164         case 'v':
 165             vlog_set_verbosity(optarg);
 166             break;
 167
 168         case '?':
 169             exit(EXIT_FAILURE);
 170
 171         default:
 172             abort();
 173         }
 174     }
 175
 176     if (!db) {
 177         db = default_db();
 178     }
 179 }
 180
 181 static void
 182 usage(void)
 183 {
 184     printf("%s: ovs-vswitchd management utility\n"
 185            "usage: %s [OPTIONS] COMMAND [ARG...]\n",
 186            program_name, program_name);
 187     printf("\nBridge commands:\n"
 188            "  add-br BRIDGE               "
 189            "create a new bridge named BRIDGE\n"
 190            "  add-br BRIDGE PARENT VLAN   "
 191            "create new fake bridge BRIDGE in PARENT on VLAN\n"
 192            "  del-br BRIDGE               "
 193            "delete BRIDGE and all of its ports\n"
 194            "  list-br                     "
 195            "print the names of all the bridges\n"
 196            "  br-exists BRIDGE            "
 197            "test whether BRIDGE exists\n"
 198            "  br-to-vlan BRIDGE           "
 199            "print the VLAN which BRIDGE is on\n"
 200            "  br-to-parent BRIDGE         "
 201            "print the parent of BRIDGE\n");
 202     printf("\nPort commands:\n"
 203            "  list-ports BRIDGE           "
 204            "print the names of all the ports on BRIDGE\n"
 205            "  add-port BRIDGE PORT        "
 206            "add network device PORT to BRIDGE\n"
 207            "  add-bond BRIDGE PORT IFACE...  "
 208            "add new bonded port PORT in BRIDGE from IFACES\n"
 209            "  del-port [BRIDGE] PORT      "
 210            "delete PORT (which may be bonded) from BRIDGE\n"
 211            "  port-to-br PORT             "
 212            "print name of bridge that contains PORT\n"
 213            "A bond is considered to be a single port.\n");
 214     printf("\nInterface commands (a bond consists of multiple interfaces):\n"
 215            "  list-ifaces BRIDGE          "
 216            "print the names of all the interfaces on BRIDGE\n"
 217            "  iface-to-br IFACE           "
 218            "print name of bridge that contains IFACE\n");
 219     printf("\nOptions:\n"
 220            "  --db=DATABASE               "
 221            "connect to DATABASE\n"
 222            "                              "
 223            "(default: %s)\n"
 224            "  --oneline                   "
 225            "print exactly one line of output per command\n",
 226            default_db());
 227     vlog_usage();
 228     printf("\nOther options:\n"
 229            "  -h, --help                  "
 230            "display this help message\n"
 231            "  -V, --version               "
 232            "display version information\n");
 233     exit(EXIT_SUCCESS);
 234 }
 235
 236 static char *
 237 default_db(void)
 238 {
 239     static char *def;
 240     if (!def) {
 241         def = xasprintf("unix:%s/ovsdb-server", ovs_rundir);
 242     }
 243     return def;
 244 }
 245 \f
 246 struct vsctl_bridge {
 247     struct ovsrec_bridge *br_cfg;
 248     char *name;
 249     struct vsctl_bridge *parent;
 250     int vlan;
 251 };
 252
 253 struct vsctl_port {
 254     struct ovsrec_port *port_cfg;
 255     struct vsctl_bridge *bridge;
 256 };
 257
 258 struct vsctl_iface {
 259     struct ovsrec_interface *iface_cfg;
 260     struct vsctl_port *port;
 261 };
 262
 263 struct vsctl_info {
 264     struct shash bridges;
 265     struct shash ports;
 266     struct shash ifaces;
 267 };
 268
 269 static struct ovsdb_idl_txn *
 270 txn_from_openvswitch(const struct ovsrec_open_vswitch *ovs)
 271 {
 272     return ovsdb_idl_txn_get(&ovs->header_);
 273 }
 274
 275 static struct vsctl_bridge *
 276 add_bridge(struct vsctl_info *b,
 277            struct ovsrec_bridge *br_cfg, const char *name,
 278            struct vsctl_bridge *parent, int vlan)
 279 {
 280     struct vsctl_bridge *br = xmalloc(sizeof *br);
 281     br->br_cfg = br_cfg;
 282     br->name = xstrdup(name);
 283     br->parent = parent;
 284     br->vlan = vlan;
 285     shash_add(&b->bridges, br->name, br);
 286     return br;
 287 }
 288
 289 static bool
 290 port_is_fake_bridge(const struct ovsrec_port *port_cfg)
 291 {
 292     return (port_cfg->fake_bridge
 293             && port_cfg->tag
 294             && *port_cfg->tag >= 1 && *port_cfg->tag <= 4095);
 295 }
 296
 297 static struct vsctl_bridge *
 298 find_vlan_bridge(struct vsctl_info *info,
 299                  struct vsctl_bridge *parent, int vlan)
 300 {
 301     struct shash_node *node;
 302
 303     SHASH_FOR_EACH (node, &info->bridges) {
 304         struct vsctl_bridge *br = node->data;
 305         if (br->parent == parent && br->vlan == vlan) {
 306             return br;
 307         }
 308     }
 309
 310     return NULL;
 311 }
 312
 313 static void
 314 free_info(struct vsctl_info *info)
 315 {
 316     struct shash_node *node;
 317
 318     SHASH_FOR_EACH (node, &info->bridges) {
 319         struct vsctl_bridge *bridge = node->data;
 320         free(bridge->name);
 321         free(bridge);
 322     }
 323     shash_destroy(&info->bridges);
 324
 325     SHASH_FOR_EACH (node, &info->ports) {
 326         struct vsctl_port *port = node->data;
 327         free(port);
 328     }
 329     shash_destroy(&info->ports);
 330
 331     SHASH_FOR_EACH (node, &info->ifaces) {
 332         struct vsctl_iface *iface = node->data;
 333         free(iface);
 334     }
 335     shash_destroy(&info->ifaces);
 336 }
 337
 338 static void
 339 get_info(const struct ovsrec_open_vswitch *ovs, struct vsctl_info *info)
 340 {
 341     struct shash bridges, ports;
 342     size_t i;
 343
 344     shash_init(&info->bridges);
 345     shash_init(&info->ports);
 346     shash_init(&info->ifaces);
 347
 348     shash_init(&bridges);
 349     shash_init(&ports);
 350     for (i = 0; i < ovs->n_bridges; i++) {
 351         struct ovsrec_bridge *br_cfg = ovs->bridges[i];
 352         struct vsctl_bridge *br;
 353         size_t j;
 354
 355         if (!shash_add_once(&bridges, br_cfg->name, NULL)) {
 356             VLOG_WARN("%s: database contains duplicate bridge name",
 357                       br_cfg->name);
 358             continue;
 359         }
 360         br = add_bridge(info, br_cfg, br_cfg->name, NULL, 0);
 361         if (!br) {
 362             continue;
 363         }
 364
 365         for (j = 0; j < br_cfg->n_ports; j++) {
 366             struct ovsrec_port *port_cfg = br_cfg->ports[j];
 367
 368             if (!shash_add_once(&ports, port_cfg->name, NULL)) {
 369                 VLOG_WARN("%s: database contains duplicate port name",
 370                           port_cfg->name);
 371                 continue;
 372             }
 373
 374             if (port_is_fake_bridge(port_cfg)
 375                 && shash_add_once(&bridges, port_cfg->name, NULL)) {
 376                 add_bridge(info, NULL, port_cfg->name, br, *port_cfg->tag);
 377             }
 378         }
 379     }
 380     shash_destroy(&bridges);
 381     shash_destroy(&ports);
 382
 383     shash_init(&bridges);
 384     shash_init(&ports);
 385     for (i = 0; i < ovs->n_bridges; i++) {
 386         struct ovsrec_bridge *br_cfg = ovs->bridges[i];
 387         struct vsctl_bridge *br;
 388         size_t j;
 389
 390         if (!shash_add_once(&bridges, br_cfg->name, NULL)) {
 391             continue;
 392         }
 393         br = shash_find_data(&info->bridges, br_cfg->name);
 394         for (j = 0; j < br_cfg->n_ports; j++) {
 395             struct ovsrec_port *port_cfg = br_cfg->ports[j];
 396             struct vsctl_port *port;
 397             size_t k;
 398
 399             if (!shash_add_once(&ports, port_cfg->name, NULL)) {
 400                 continue;
 401             }
 402
 403             if (port_is_fake_bridge(port_cfg)
 404                 && !shash_add_once(&bridges, port_cfg->name, NULL)) {
 405                 continue;
 406             }
 407
 408             port = xmalloc(sizeof *port);
 409             port->port_cfg = port_cfg;
 410             if (port_cfg->tag
 411                 && *port_cfg->tag >= 1 && *port_cfg->tag <= 4095) {
 412                 port->bridge = find_vlan_bridge(info, br, *port_cfg->tag);
 413                 if (!port->bridge) {
 414                     port->bridge = br;
 415                 }
 416             } else {
 417                 port->bridge = br;
 418             }
 419             shash_add(&info->ports, port_cfg->name, port);
 420
 421             for (k = 0; k < port_cfg->n_interfaces; k++) {
 422                 struct ovsrec_interface *iface_cfg = port_cfg->interfaces[k];
 423                 struct vsctl_iface *iface;
 424
 425                 if (shash_find(&info->ifaces, iface_cfg->name)) {
 426                     VLOG_WARN("%s: database contains duplicate interface name",
 427                               iface_cfg->name);
 428                     continue;
 429                 }
 430
 431                 iface = xmalloc(sizeof *iface);
 432                 iface->iface_cfg = iface_cfg;
 433                 iface->port = port;
 434                 shash_add(&info->ifaces, iface_cfg->name, iface);
 435             }
 436         }
 437     }
 438     shash_destroy(&bridges);
 439     shash_destroy(&ports);
 440 }
 441
 442 static void
 443 check_conflicts(struct vsctl_info *info, const char *name,
 444                 char *msg)
 445 {
 446     struct vsctl_iface *iface;
 447     struct vsctl_port *port;
 448
 449     if (shash_find(&info->bridges, name)) {
 450         ovs_fatal(0, "%s because a bridge named %s already exists", msg, name);
 451     }
 452
 453     port = shash_find_data(&info->ports, name);
 454     if (port) {
 455         ovs_fatal(0, "%s because a port named %s already exists on bridge %s",
 456                   msg, name, port->bridge->name);
 457     }
 458
 459     iface = shash_find_data(&info->ifaces, name);
 460     if (iface) {
 461         ovs_fatal(0, "%s because an interface named %s already exists "
 462                   "on bridge %s", msg, name, iface->port->bridge->name);
 463     }
 464
 465     free(msg);
 466 }
 467
 468 static struct vsctl_bridge *
 469 find_bridge(struct vsctl_info *info, const char *name)
 470 {
 471     struct vsctl_bridge *br = shash_find_data(&info->bridges, name);
 472     if (!br) {
 473         ovs_fatal(0, "no bridge named %s", name);
 474     }
 475     return br;
 476 }
 477
 478 static struct vsctl_port *
 479 find_port(struct vsctl_info *info, const char *name)
 480 {
 481     struct vsctl_port *port = shash_find_data(&info->ports, name);
 482     if (!port || !strcmp(name, port->bridge->name)) {
 483         ovs_fatal(0, "no port named %s", name);
 484     }
 485     return port;
 486 }
 487
 488 static struct vsctl_iface *
 489 find_iface(struct vsctl_info *info, const char *name)
 490 {
 491     struct vsctl_iface *iface = shash_find_data(&info->ifaces, name);
 492     if (!iface || !strcmp(name, iface->port->bridge->name)) {
 493         ovs_fatal(0, "no interface named %s", name);
 494     }
 495     return iface;
 496 }
 497
 498 static void
 499 bridge_insert_port(struct ovsrec_bridge *br, struct ovsrec_port *port)
 500 {
 501     struct ovsrec_port **ports;
 502     size_t i;
 503
 504     ports = xmalloc(sizeof *br->ports * (br->n_ports + 1));
 505     for (i = 0; i < br->n_ports; i++) {
 506         ports[i] = br->ports[i];
 507     }
 508     ports[br->n_ports] = port;
 509     ovsrec_bridge_set_ports(br, ports, br->n_ports + 1);
 510     free(ports);
 511 }
 512
 513 static void
 514 bridge_delete_port(struct ovsrec_bridge *br, struct ovsrec_port *port)
 515 {
 516     struct ovsrec_port **ports;
 517     size_t i, n;
 518
 519     ports = xmalloc(sizeof *br->ports * br->n_ports);
 520     for (i = n = 0; i < br->n_ports; i++) {
 521         if (br->ports[i] != port) {
 522             ports[n++] = br->ports[i];
 523         }
 524     }
 525     ovsrec_bridge_set_ports(br, ports, n);
 526     free(ports);
 527 }
 528
 529 static void
 530 ovs_insert_bridge(const struct ovsrec_open_vswitch *ovs,
 531                   struct ovsrec_bridge *bridge)
 532 {
 533     struct ovsrec_bridge **bridges;
 534     size_t i;
 535
 536     bridges = xmalloc(sizeof *ovs->bridges * (ovs->n_bridges + 1));
 537     for (i = 0; i < ovs->n_bridges; i++) {
 538         bridges[i] = ovs->bridges[i];
 539     }
 540     bridges[ovs->n_bridges] = bridge;
 541     ovsrec_open_vswitch_set_bridges(ovs, bridges, ovs->n_bridges + 1);
 542     free(bridges);
 543 }
 544
 545 static void
 546 ovs_delete_bridge(const struct ovsrec_open_vswitch *ovs,
 547                   struct ovsrec_bridge *bridge)
 548 {
 549     struct ovsrec_bridge **bridges;
 550     size_t i, n;
 551
 552     bridges = xmalloc(sizeof *ovs->bridges * ovs->n_bridges);
 553     for (i = n = 0; i < ovs->n_bridges; i++) {
 554         if (ovs->bridges[i] != bridge) {
 555             bridges[n++] = ovs->bridges[i];
 556         }
 557     }
 558     ovsrec_open_vswitch_set_bridges(ovs, bridges, n);
 559     free(bridges);
 560 }
 561
 562 static void
 563 cmd_add_br(int argc, char *argv[], const struct ovsrec_open_vswitch *ovs,
 564            struct ds *output UNUSED)
 565 {
 566     const char *br_name = argv[1];
 567     struct vsctl_info info;
 568
 569     get_info(ovs, &info);
 570     check_conflicts(&info, br_name,
 571                     xasprintf("cannot create a bridge named %s", br_name));
 572
 573     if (argc == 2) {
 574         struct ovsrec_bridge *br;
 575         struct ovsrec_port *port;
 576         struct ovsrec_interface *iface;
 577
 578         iface = ovsrec_interface_insert(txn_from_openvswitch(ovs));
 579         ovsrec_interface_set_name(iface, br_name);
 580
 581         port = ovsrec_port_insert(txn_from_openvswitch(ovs));
 582         ovsrec_port_set_name(port, br_name);
 583         ovsrec_port_set_interfaces(port, &iface, 1);
 584
 585         br = ovsrec_bridge_insert(txn_from_openvswitch(ovs));
 586         ovsrec_bridge_set_name(br, br_name);
 587         ovsrec_bridge_set_ports(br, &port, 1);
 588
 589         ovs_insert_bridge(ovs, br);
 590     } else if (argc == 3) {
 591         ovs_fatal(0, "'%s' comamnd takes exactly 1 or 3 arguments", argv[0]);
 592     } else if (argc == 4) {
 593         const char *parent_name = argv[2];
 594         int vlan = atoi(argv[3]);
 595         struct ovsrec_bridge *br;
 596         struct vsctl_bridge *parent;
 597         struct ovsrec_port *port;
 598         struct ovsrec_interface *iface;
 599         int64_t tag = vlan;
 600
 601         if (vlan < 1 || vlan > 4095) {
 602             ovs_fatal(0, "%s: vlan must be between 1 and 4095", argv[0]);
 603         }
 604
 605         parent = shash_find_data(&info.bridges, parent_name);
 606         if (parent && parent->vlan) {
 607             ovs_fatal(0, "cannot create brdige with fake bridge as parent");
 608         }
 609         if (!parent) {
 610             ovs_fatal(0, "parent bridge %s does not exist", parent_name);
 611         }
 612         br = parent->br_cfg;
 613
 614         iface = ovsrec_interface_insert(txn_from_openvswitch(ovs));
 615         ovsrec_interface_set_name(iface, br_name);
 616         ovsrec_interface_set_type(iface, "internal");
 617
 618         port = ovsrec_port_insert(txn_from_openvswitch(ovs));
 619         ovsrec_port_set_name(port, br_name);
 620         ovsrec_port_set_interfaces(port, &iface, 1);
 621         ovsrec_port_set_fake_bridge(port, true);
 622         ovsrec_port_set_tag(port, &tag, 1);
 623
 624         bridge_insert_port(br, port);
 625     } else {
 626         NOT_REACHED();
 627     }
 628
 629     free_info(&info);
 630 }
 631
 632 static void
 633 del_port(struct vsctl_info *info, struct vsctl_port *port)
 634 {
 635     struct shash_node *node;
 636
 637     SHASH_FOR_EACH (node, &info->ifaces) {
 638         struct vsctl_iface *iface = node->data;
 639         if (iface->port == port) {
 640             ovsrec_interface_delete(iface->iface_cfg);
 641         }
 642     }
 643     ovsrec_port_delete(port->port_cfg);
 644
 645     bridge_delete_port((port->bridge->parent
 646                         ? port->bridge->parent->br_cfg
 647                         : port->bridge->br_cfg), port->port_cfg);
 648 }
 649
 650 static void
 651 cmd_del_br(int argc UNUSED, char *argv[],
 652            const struct ovsrec_open_vswitch *ovs, struct ds *output UNUSED)
 653 {
 654     struct shash_node *node;
 655     struct vsctl_info info;
 656     struct vsctl_bridge *bridge;
 657
 658     get_info(ovs, &info);
 659     bridge = find_bridge(&info, argv[1]);
 660     SHASH_FOR_EACH (node, &info.ports) {
 661         struct vsctl_port *port = node->data;
 662         if (port->bridge == bridge
 663             || !strcmp(port->port_cfg->name, bridge->name)) {
 664             del_port(&info, port);
 665         }
 666     }
 667     if (bridge->br_cfg) {
 668         ovsrec_bridge_delete(bridge->br_cfg);
 669         ovs_delete_bridge(ovs, bridge->br_cfg);
 670     }
 671     free_info(&info);
 672 }
 673
 674 static void
 675 output_sorted(struct svec *svec, struct ds *output)
 676 {
 677     const char *name;
 678     size_t i;
 679
 680     svec_sort(svec);
 681     SVEC_FOR_EACH (i, name, svec) {
 682         ds_put_format(output, "%s\n", name);
 683     }
 684 }
 685
 686 static void
 687 cmd_list_br(int argc UNUSED, char *argv[] UNUSED,
 688             const struct ovsrec_open_vswitch *ovs, struct ds *output)
 689 {
 690     struct shash_node *node;
 691     struct vsctl_info info;
 692     struct svec bridges;
 693
 694     get_info(ovs, &info);
 695
 696     svec_init(&bridges);
 697     SHASH_FOR_EACH (node, &info.bridges) {
 698         struct vsctl_bridge *br = node->data;
 699         svec_add(&bridges, br->name);
 700     }
 701     output_sorted(&bridges, output);
 702     svec_destroy(&bridges);
 703
 704     free_info(&info);
 705 }
 706
 707 static void
 708 cmd_br_exists(int argc UNUSED, char *argv[],
 709               const struct ovsrec_open_vswitch *ovs, struct ds *output UNUSED)
 710 {
 711     struct vsctl_info info;
 712
 713     get_info(ovs, &info);
 714     if (!shash_find_data(&info.bridges, argv[1])) {
 715         exit(2);
 716     }
 717     free_info(&info);
 718 }
 719
 720 /* Returns true if 'b_prefix' (of length 'b_prefix_len') concatenated with 'b'
 721  * equals 'a', false otherwise. */
 722 static bool
 723 key_matches(const char *a,
 724             const char *b_prefix, size_t b_prefix_len, const char *b)
 725 {
 726     return !strncmp(a, b_prefix, b_prefix_len) && !strcmp(a + b_prefix_len, b);
 727 }
 728
 729 static void
 730 set_external_id(char **old_keys, char **old_values, size_t old_n,
 731                 char *key, char *value,
 732                 char ***new_keysp, char ***new_valuesp, size_t *new_np)
 733 {
 734     char **new_keys;
 735     char **new_values;
 736     size_t new_n;
 737     size_t i;
 738
 739     new_keys = xmalloc(sizeof *new_keys * (old_n + 1));
 740     new_values = xmalloc(sizeof *new_values * (old_n + 1));
 741     new_n = 0;
 742     for (i = 0; i < old_n; i++) {
 743         if (strcmp(key, old_keys[i])) {
 744             new_keys[new_n] = old_keys[i];
 745             new_values[new_n] = old_values[i];
 746             new_n++;
 747         }
 748     }
 749     if (value) {
 750         new_keys[new_n] = key;
 751         new_values[new_n] = value;
 752         new_n++;
 753     }
 754     *new_keysp = new_keys;
 755     *new_valuesp = new_values;
 756     *new_np = new_n;
 757 }
 758
 759 static void
 760 cmd_br_set_external_id(int argc, char *argv[],
 761                        const struct ovsrec_open_vswitch *ovs,
 762                        struct ds *output UNUSED)
 763 {
 764     struct vsctl_info info;
 765     struct vsctl_bridge *bridge;
 766     char **keys, **values;
 767     size_t n;
 768
 769     get_info(ovs, &info);
 770     bridge = find_bridge(&info, argv[1]);
 771     if (bridge->br_cfg) {
 772         set_external_id(bridge->br_cfg->key_external_ids,
 773                         bridge->br_cfg->value_external_ids,
 774                         bridge->br_cfg->n_external_ids,
 775                         argv[2], argc >= 4 ? argv[3] : NULL,
 776                         &keys, &values, &n);
 777         ovsrec_bridge_set_external_ids(bridge->br_cfg, keys, values, n);
 778     } else {
 779         char *key = xasprintf("fake-bridge-%s", argv[2]);
 780         struct vsctl_port *port = shash_find_data(&info.ports, argv[1]);
 781         set_external_id(port->port_cfg->key_external_ids,
 782                         port->port_cfg->value_external_ids,
 783                         port->port_cfg->n_external_ids,
 784                         key, argc >= 4 ? argv[3] : NULL,
 785                         &keys, &values, &n);
 786         ovsrec_port_set_external_ids(port->port_cfg, keys, values, n);
 787         free(key);
 788     }
 789     free(keys);
 790     free(values);
 791
 792     free_info(&info);
 793 }
 794
 795 static void
 796 get_external_id(char **keys, char **values, size_t n,
 797                 const char *prefix, const char *key,
 798                 struct ds *output)
 799 {
 800     size_t prefix_len = strlen(prefix);
 801     struct svec svec;
 802     size_t i;
 803
 804     svec_init(&svec);
 805     for (i = 0; i < n; i++) {
 806         if (!key && !strncmp(keys[i], prefix, prefix_len)) {
 807             svec_add_nocopy(&svec, xasprintf("%s=%s",
 808                                              keys[i] + prefix_len, values[i]));
 809         } else if (key_matches(keys[i], prefix, prefix_len, key)) {
 810             svec_add(&svec, values[i]);
 811             break;
 812         }
 813     }
 814     output_sorted(&svec, output);
 815     svec_destroy(&svec);
 816 }
 817
 818 static void
 819 cmd_br_get_external_id(int argc, char *argv[],
 820                        const struct ovsrec_open_vswitch *ovs,
 821                        struct ds *output)
 822 {
 823     struct vsctl_info info;
 824     struct vsctl_bridge *bridge;
 825
 826     get_info(ovs, &info);
 827     bridge = find_bridge(&info, argv[1]);
 828     if (bridge->br_cfg) {
 829         get_external_id(bridge->br_cfg->key_external_ids,
 830                         bridge->br_cfg->value_external_ids,
 831                         bridge->br_cfg->n_external_ids,
 832                         "", argc >= 3 ? argv[2] : NULL, output);
 833     } else {
 834         struct vsctl_port *port = shash_find_data(&info.ports, argv[1]);
 835         get_external_id(port->port_cfg->key_external_ids,
 836                         port->port_cfg->value_external_ids,
 837                         port->port_cfg->n_external_ids,
 838                         "fake-bridge-", argc >= 3 ? argv[2] : NULL, output);
 839     }
 840     free_info(&info);
 841 }
 842
 843
 844 static void
 845 cmd_list_ports(int argc UNUSED, char *argv[],
 846                const struct ovsrec_open_vswitch *ovs, struct ds *output)
 847 {
 848     struct vsctl_bridge *br;
 849     struct shash_node *node;
 850     struct vsctl_info info;
 851     struct svec ports;
 852
 853     get_info(ovs, &info);
 854     br = find_bridge(&info, argv[1]);
 855
 856     svec_init(&ports);
 857     SHASH_FOR_EACH (node, &info.ports) {
 858         struct vsctl_port *port = node->data;
 859
 860         if (strcmp(port->port_cfg->name, br->name) && br == port->bridge) {
 861             svec_add(&ports, port->port_cfg->name);
 862         }
 863     }
 864     output_sorted(&ports, output);
 865     svec_destroy(&ports);
 866
 867     free_info(&info);
 868 }
 869
 870 static void
 871 add_port(const struct ovsrec_open_vswitch *ovs,
 872          const char *br_name, const char *port_name,
 873          char *iface_names[], int n_ifaces)
 874 {
 875     struct vsctl_info info;
 876     struct vsctl_bridge *bridge;
 877     struct ovsrec_interface **ifaces;
 878     struct ovsrec_port *port;
 879     size_t i;
 880
 881     get_info(ovs, &info);
 882     check_conflicts(&info, port_name,
 883                     xasprintf("cannot create a port named %s", port_name));
 884     /* XXX need to check for conflicts on interfaces too */
 885     bridge = find_bridge(&info, br_name);
 886
 887     ifaces = xmalloc(n_ifaces * sizeof *ifaces);
 888     for (i = 0; i < n_ifaces; i++) {
 889         ifaces[i] = ovsrec_interface_insert(txn_from_openvswitch(ovs));
 890         ovsrec_interface_set_name(ifaces[i], iface_names[i]);
 891     }
 892
 893     port = ovsrec_port_insert(txn_from_openvswitch(ovs));
 894     ovsrec_port_set_name(port, port_name);
 895     ovsrec_port_set_interfaces(port, ifaces, n_ifaces);
 896     free(ifaces);
 897
 898     if (bridge->vlan) {
 899         int64_t tag = bridge->vlan;
 900         ovsrec_port_set_tag(port, &tag, 1);
 901     }
 902
 903     bridge_insert_port((bridge->parent ? bridge->parent->br_cfg
 904                         : bridge->br_cfg), port);
 905
 906     free_info(&info);
 907 }
 908
 909 static void
 910 cmd_add_port(int argc UNUSED, char *argv[],
 911              const struct ovsrec_open_vswitch *ovs, struct ds *output UNUSED)
 912 {
 913     add_port(ovs, argv[1], argv[2], &argv[2], 1);
 914 }
 915
 916 static void
 917 cmd_add_bond(int argc, char *argv[],
 918              const struct ovsrec_open_vswitch *ovs, struct ds *output UNUSED)
 919 {
 920     add_port(ovs, argv[1], argv[2], &argv[3], argc - 3);
 921 }
 922
 923 static void
 924 cmd_del_port(int argc, char *argv[],
 925              const struct ovsrec_open_vswitch *ovs, struct ds *output UNUSED)
 926 {
 927     struct vsctl_info info;
 928
 929     get_info(ovs, &info);
 930     if (argc == 2) {
 931         struct vsctl_port *port = find_port(&info, argv[1]);
 932         del_port(&info, port);
 933     } else if (argc == 3) {
 934         struct vsctl_bridge *bridge = find_bridge(&info, argv[1]);
 935         struct vsctl_port *port = find_port(&info, argv[2]);
 936
 937         if (port->bridge == bridge) {
 938             del_port(&info, port);
 939         } else if (port->bridge->parent == bridge) {
 940             ovs_fatal(0, "bridge %s does not have a port %s (although its "
 941                       "parent bridge %s does)",
 942                       argv[1], argv[2], bridge->parent->name);
 943         } else {
 944             ovs_fatal(0, "bridge %s does not have a port %s",
 945                       argv[1], argv[2]);
 946         }
 947     }
 948     free_info(&info);
 949 }
 950
 951 static void
 952 cmd_port_to_br(int argc UNUSED, char *argv[],
 953                const struct ovsrec_open_vswitch *ovs, struct ds *output)
 954 {
 955     struct vsctl_port *port;
 956     struct vsctl_info info;
 957
 958     get_info(ovs, &info);
 959     port = find_port(&info, argv[1]);
 960     ds_put_format(output, "%s\n", port->bridge->name);
 961     free_info(&info);
 962 }
 963
 964 static void
 965 cmd_port_set_external_id(int argc, char *argv[],
 966                          const struct ovsrec_open_vswitch *ovs,
 967                          struct ds *output UNUSED)
 968 {
 969     struct vsctl_info info;
 970     struct vsctl_port *port;
 971     char **keys, **values;
 972     size_t n;
 973
 974     get_info(ovs, &info);
 975     port = find_port(&info, argv[1]);
 976     set_external_id(port->port_cfg->key_external_ids,
 977                     port->port_cfg->value_external_ids,
 978                     port->port_cfg->n_external_ids,
 979                     argv[2], argc >= 4 ? argv[3] : NULL,
 980                     &keys, &values, &n);
 981     ovsrec_port_set_external_ids(port->port_cfg, keys, values, n);
 982     free(keys);
 983     free(values);
 984
 985     free_info(&info);
 986 }
 987
 988 static void
 989 cmd_port_get_external_id(int argc, char *argv[],
 990                          const struct ovsrec_open_vswitch *ovs,
 991                          struct ds *output)
 992 {
 993     struct vsctl_info info;
 994     struct vsctl_port *port;
 995
 996     get_info(ovs, &info);
 997     port = find_port(&info, argv[1]);
 998     get_external_id(port->port_cfg->key_external_ids,
 999                     port->port_cfg->value_external_ids,
1000                     port->port_cfg->n_external_ids,
1001                     "",  argc >= 3 ? argv[2] : NULL, output);
1002     free_info(&info);
1003 }
1004
1005 static void
1006 cmd_br_to_vlan(int argc UNUSED, char *argv[],
1007                const struct ovsrec_open_vswitch *ovs, struct ds *output)
1008 {
1009     struct vsctl_bridge *bridge;
1010     struct vsctl_info info;
1011
1012     get_info(ovs, &info);
1013     bridge = find_bridge(&info, argv[1]);
1014     ds_put_format(output, "%d\n", bridge->vlan);
1015     free_info(&info);
1016 }
1017
1018 static void
1019 cmd_br_to_parent(int argc UNUSED, char *argv[],
1020                  const struct ovsrec_open_vswitch *ovs, struct ds *output)
1021 {
1022     struct vsctl_bridge *bridge;
1023     struct vsctl_info info;
1024
1025     get_info(ovs, &info);
1026     bridge = find_bridge(&info, argv[1]);
1027     if (bridge->parent) {
1028         bridge = bridge->parent;
1029     }
1030     ds_put_format(output, "%s\n", bridge->name);
1031     free_info(&info);
1032 }
1033
1034 static void
1035 cmd_list_ifaces(int argc UNUSED, char *argv[],
1036                 const struct ovsrec_open_vswitch *ovs, struct ds *output)
1037 {
1038     struct vsctl_bridge *br;
1039     struct shash_node *node;
1040     struct vsctl_info info;
1041     struct svec ifaces;
1042
1043     get_info(ovs, &info);
1044     br = find_bridge(&info, argv[1]);
1045
1046     svec_init(&ifaces);
1047     SHASH_FOR_EACH (node, &info.ifaces) {
1048         struct vsctl_iface *iface = node->data;
1049
1050         if (strcmp(iface->iface_cfg->name, br->name)
1051             && br == iface->port->bridge) {
1052             svec_add(&ifaces, iface->iface_cfg->name);
1053         }
1054     }
1055     output_sorted(&ifaces, output);
1056     svec_destroy(&ifaces);
1057
1058     free_info(&info);
1059 }
1060
1061 static void
1062 cmd_iface_to_br(int argc UNUSED, char *argv[],
1063                 const struct ovsrec_open_vswitch *ovs, struct ds *output)
1064 {
1065     struct vsctl_iface *iface;
1066     struct vsctl_info info;
1067
1068     get_info(ovs, &info);
1069     iface = find_iface(&info, argv[1]);
1070     ds_put_format(output, "%s\n", iface->port->bridge->name);
1071     free_info(&info);
1072 }
1073
1074 static void
1075 cmd_iface_set_external_id(int argc, char *argv[],
1076                          const struct ovsrec_open_vswitch *ovs,
1077                          struct ds *output UNUSED)
1078 {
1079     struct vsctl_info info;
1080     struct vsctl_iface *iface;
1081     char **keys, **values;
1082     size_t n;
1083
1084     get_info(ovs, &info);
1085     iface = find_iface(&info, argv[1]);
1086     set_external_id(iface->iface_cfg->key_external_ids,
1087                     iface->iface_cfg->value_external_ids,
1088                     iface->iface_cfg->n_external_ids,
1089                     argv[2], argc >= 4 ? argv[3] : NULL,
1090                     &keys, &values, &n);
1091     ovsrec_interface_set_external_ids(iface->iface_cfg, keys, values, n);
1092     free(keys);
1093     free(values);
1094
1095     free_info(&info);
1096 }
1097
1098 static void
1099 cmd_iface_get_external_id(int argc, char *argv[],
1100                           const struct ovsrec_open_vswitch *ovs,
1101                           struct ds *output)
1102 {
1103     struct vsctl_info info;
1104     struct vsctl_iface *iface;
1105
1106     get_info(ovs, &info);
1107     iface = find_iface(&info, argv[1]);
1108     get_external_id(iface->iface_cfg->key_external_ids,
1109                     iface->iface_cfg->value_external_ids,
1110                     iface->iface_cfg->n_external_ids,
1111                     "",  argc >= 3 ? argv[2] : NULL, output);
1112     free_info(&info);
1113 }
1114 \f
1115 typedef void vsctl_handler_func(int argc, char *argv[],
1116                                 const struct ovsrec_open_vswitch *,
1117                                 struct ds *output);
1118
1119 struct vsctl_command {
1120     const char *name;
1121     int min_args;
1122     int max_args;
1123     vsctl_handler_func *handler;
1124 };
1125
1126 static void run_vsctl_command(int argc, char *argv[],
1127                               const struct ovsrec_open_vswitch *ovs,
1128                               struct ds *output);
1129
1130 static void
1131 do_vsctl(int argc, char *argv[], struct ovsdb_idl *idl)
1132 {
1133     struct ovsdb_idl_txn *txn;
1134     const struct ovsrec_open_vswitch *ovs;
1135     enum ovsdb_idl_txn_status status;
1136     struct ds *output;
1137     int n_output;
1138     int i, start;
1139
1140     ovs = ovsrec_open_vswitch_first(idl);
1141     if (!ovs) {
1142         /* XXX it would be more user-friendly to create a record ourselves
1143          * (while verifying that the table is empty before doing so). */
1144         ovs_fatal(0, "%s: database does not contain any Open vSwitch "
1145                   "configuration", db);
1146     }
1147
1148     txn = ovsdb_idl_txn_create(idl);
1149     output = xmalloc(argc * sizeof *output);
1150     n_output = 0;
1151     for (start = i = 0; i <= argc; i++) {
1152         if (i == argc || !strcmp(argv[i], "--")) {
1153             if (i > start) {
1154                 ds_init(&output[n_output]);
1155                 run_vsctl_command(i - start, &argv[start], ovs,
1156                                   &output[n_output++]);
1157             }
1158             start = i + 1;
1159         }
1160     }
1161
1162     while ((status = ovsdb_idl_txn_commit(txn)) == TXN_INCOMPLETE) {
1163         ovsdb_idl_run(idl);
1164         ovsdb_idl_wait(idl);
1165         ovsdb_idl_txn_wait(txn);
1166         poll_block();
1167     }
1168     ovsdb_idl_txn_destroy(txn);
1169
1170     switch (status) {
1171     case TXN_INCOMPLETE:
1172         NOT_REACHED();
1173
1174     case TXN_ABORTED:
1175         /* Should not happen--we never call ovsdb_idl_txn_abort(). */
1176         ovs_fatal(0, "transaction aborted");
1177
1178     case TXN_SUCCESS:
1179         break;
1180
1181     case TXN_TRY_AGAIN:
1182         for (i = 0; i < n_output; i++) {
1183             ds_destroy(&output[i]);
1184         }
1185         return;
1186
1187     case TXN_ERROR:
1188         ovs_fatal(0, "transaction error");
1189
1190     default:
1191         NOT_REACHED();
1192     }
1193
1194     for (i = 0; i < n_output; i++) {
1195         struct ds *ds = &output[i];
1196         if (oneline) {
1197             size_t j;
1198
1199             ds_chomp(ds, '\n');
1200             for (j = 0; j < ds->length; j++) {
1201                 int c = ds->string[j];
1202                 switch (c) {
1203                 case '\n':
1204                     fputs("\\n", stdout);
1205                     break;
1206
1207                 case '\\':
1208                     fputs("\\\\", stdout);
1209                     break;
1210
1211                 default:
1212                     putchar(c);
1213                 }
1214             }
1215             putchar('\n');
1216         } else {
1217             fputs(ds_cstr(ds), stdout);
1218         }
1219     }
1220     exit(EXIT_SUCCESS);
1221 }
1222
1223 static vsctl_handler_func *
1224 get_vsctl_handler(int argc, char *argv[])
1225 {
1226     static const struct vsctl_command all_commands[] = {
1227         /* Bridge commands. */
1228         {"add-br", 1, 3, cmd_add_br},
1229         {"del-br", 1, 1, cmd_del_br},
1230         {"list-br", 0, 0, cmd_list_br},
1231         {"br-exists", 1, 1, cmd_br_exists},
1232         {"br-to-vlan", 1, 1, cmd_br_to_vlan},
1233         {"br-to-parent", 1, 1, cmd_br_to_parent},
1234         {"br-set-external-id", 2, 3, cmd_br_set_external_id},
1235         {"br-get-external-id", 1, 2, cmd_br_get_external_id},
1236
1237         /* Port commands. */
1238         {"list-ports", 1, 1, cmd_list_ports},
1239         {"add-port", 2, 2, cmd_add_port},
1240         {"add-bond", 4, INT_MAX, cmd_add_bond},
1241         {"del-port", 1, 2, cmd_del_port},
1242         {"port-to-br", 1, 1, cmd_port_to_br},
1243         {"port-set-external-id", 2, 3, cmd_port_set_external_id},
1244         {"port-get-external-id", 1, 2, cmd_port_get_external_id},
1245
1246         /* Interface commands. */
1247         {"list-ifaces", 1, 1, cmd_list_ifaces},
1248         {"iface-to-br", 1, 1, cmd_iface_to_br},
1249         {"iface-set-external-id", 2, 3, cmd_iface_set_external_id},
1250         {"iface-get-external-id", 1, 2, cmd_iface_get_external_id},
1251     };
1252
1253     const struct vsctl_command *p;
1254
1255     assert(argc > 0);
1256     for (p = all_commands; p < &all_commands[ARRAY_SIZE(all_commands)]; p++) {
1257         if (!strcmp(p->name, argv[0])) {
1258             int n_arg = argc - 1;
1259             if (n_arg < p->min_args) {
1260                 ovs_fatal(0, "'%s' command requires at least %d arguments",
1261                           p->name, p->min_args);
1262             } else if (n_arg > p->max_args) {
1263                 ovs_fatal(0, "'%s' command takes at most %d arguments",
1264                           p->name, p->max_args);
1265             } else {
1266                 return p->handler;
1267             }
1268         }
1269     }
1270
1271     ovs_fatal(0, "unknown command '%s'; use --help for help", argv[0]);
1272 }
1273
1274 static void
1275 check_vsctl_command(int argc, char *argv[])
1276 {
1277     get_vsctl_handler(argc, argv);
1278 }
1279
1280 static void
1281 run_vsctl_command(int argc, char *argv[],
1282                   const struct ovsrec_open_vswitch *ovs, struct ds *output)
1283 {
1284     get_vsctl_handler(argc, argv)(argc, argv, ovs, output);
1285 }