pintos-os.org Git - openvswitch/blob - utilities/ovs-discover.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 <getopt.h>
  19 #include <limits.h>
  20 #include <regex.h>
  21 #include <signal.h>
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24 #include "command-line.h"
  25 #include "daemon.h"
  26 #include "dhcp-client.h"
  27 #include "dhcp.h"
  28 #include "dirs.h"
  29 #include "dynamic-string.h"
  30 #include "fatal-signal.h"
  31 #include "netdev.h"
  32 #include "poll-loop.h"
  33 #include "timeval.h"
  34 #include "unixctl.h"
  35 #include "util.h"
  36
  37 #include "vlog.h"
  38 #define THIS_MODULE VLM_ovs_discover
  39
  40 struct iface {
  41     const char *name;
  42     struct dhclient *dhcp;
  43 };
  44
  45 /* The interfaces that we serve. */
  46 static struct iface *ifaces;
  47 static int n_ifaces;
  48
  49 /* --accept-vconn: Regular expression specifying the class of controller vconns
  50  * that we will accept during autodiscovery. */
  51 static const char *accept_controller_re = "tcp:.*";
  52 static regex_t accept_controller_regex;
  53
  54 /* --exit-without-bind: Exit after discovering the controller, without binding
  55  * the network device to an IP address? */
  56 static bool exit_without_bind;
  57
  58 /* --exit-after-bind: Exit after discovering the controller, after binding the
  59  * network device to an IP address? */
  60 static bool exit_after_bind;
  61
  62 static bool iface_init(struct iface *, const char *netdev_name);
  63 static void release_ifaces(void *aux OVS_UNUSED);
  64
  65 static void parse_options(int argc, char *argv[]);
  66 static void usage(void) NO_RETURN;
  67
  68 static void modify_dhcp_request(struct dhcp_msg *, void *aux);
  69 static bool validate_dhcp_offer(const struct dhcp_msg *, void *aux);
  70
  71 int
  72 main(int argc, char *argv[])
  73 {
  74     struct unixctl_server *unixctl;
  75     int retval;
  76     int i;
  77
  78     proctitle_init(argc, argv);
  79     set_program_name(argv[0]);
  80     time_init();
  81     vlog_init();
  82     parse_options(argc, argv);
  83
  84     argc -= optind;
  85     argv += optind;
  86     if (argc < 1) {
  87         ovs_fatal(0, "need at least one non-option argument; "
  88                   "use --help for usage");
  89     }
  90
  91     ifaces = xmalloc(argc * sizeof *ifaces);
  92     n_ifaces = 0;
  93     for (i = 0; i < argc; i++) {
  94         if (iface_init(&ifaces[n_ifaces], argv[i])) {
  95             n_ifaces++;
  96         }
  97     }
  98     if (!n_ifaces) {
  99         ovs_fatal(0, "failed to initialize any DHCP clients");
 100     }
 101
 102     for (i = 0; i < n_ifaces; i++) {
 103         struct iface *iface = &ifaces[i];
 104         dhclient_init(iface->dhcp, 0);
 105     }
 106     fatal_signal_add_hook(release_ifaces, NULL, NULL, true);
 107
 108     retval = regcomp(&accept_controller_regex, accept_controller_re,
 109                      REG_NOSUB | REG_EXTENDED);
 110     if (retval) {
 111         size_t length = regerror(retval, &accept_controller_regex, NULL, 0);
 112         char *buffer = xmalloc(length);
 113         regerror(retval, &accept_controller_regex, buffer, length);
 114         ovs_fatal(0, "%s: %s", accept_controller_re, buffer);
 115     }
 116
 117     retval = unixctl_server_create(NULL, &unixctl);
 118     if (retval) {
 119         exit(EXIT_FAILURE);
 120     }
 121
 122     die_if_already_running();
 123
 124     signal(SIGPIPE, SIG_IGN);
 125     for (;;) {
 126         for (i = 0; i < n_ifaces; i++) {
 127             struct iface *iface = &ifaces[i];
 128             dhclient_run(iface->dhcp);
 129             if (dhclient_changed(iface->dhcp)) {
 130                 bool is_bound = dhclient_is_bound(iface->dhcp);
 131                 int j;
 132
 133                 /* Configure network device. */
 134                 if (!exit_without_bind) {
 135                     dhclient_configure_netdev(iface->dhcp);
 136                     dhclient_update_resolv_conf(iface->dhcp);
 137                 }
 138
 139                 if (is_bound) {
 140                     static bool detached = false;
 141                     struct ds ds;
 142
 143                     /* Disable timeout, since discovery was successful. */
 144                     time_alarm(0);
 145
 146                     /* Print discovered parameters. */
 147                     ds_init(&ds);
 148                     dhcp_msg_to_string(dhclient_get_config(iface->dhcp),
 149                                        true, &ds);
 150                     fputs(ds_cstr(&ds), stdout);
 151                     putchar('\n');
 152                     fflush(stdout);
 153                     ds_destroy(&ds);
 154
 155                     /* Exit if the user requested it. */
 156                     if (exit_without_bind) {
 157                         VLOG_DBG("exiting because of successful binding on %s "
 158                                  "and --exit-without-bind specified",
 159                                  iface->name);
 160                         exit(0);
 161                     }
 162                     if (exit_after_bind) {
 163                         VLOG_DBG("exiting because of successful binding on %s "
 164                                  "and --exit-after-bind specified",
 165                                  iface->name);
 166                         exit(0);
 167                     }
 168
 169                     /* Detach into background, if we haven't already. */
 170                     if (!detached) {
 171                         detached = true;
 172                         daemonize();
 173                     }
 174                 }
 175
 176                 /* We only want an address on a single one of our interfaces.
 177                  * So: if we have an address on this interface, stop looking
 178                  * for one on the others; if we don't have an address on this
 179                  * interface, start looking everywhere. */
 180                 for (j = 0; j < n_ifaces; j++) {
 181                     struct iface *if2 = &ifaces[j];
 182                     if (iface != if2) {
 183                         if (is_bound) {
 184                             dhclient_release(if2->dhcp);
 185                         } else {
 186                             dhclient_init(if2->dhcp, 0);
 187                         }
 188                     }
 189                 }
 190             }
 191         }
 192         unixctl_server_run(unixctl);
 193         for (i = 0; i < n_ifaces; i++) {
 194             struct iface *iface = &ifaces[i];
 195             dhclient_wait(iface->dhcp);
 196         }
 197         unixctl_server_wait(unixctl);
 198         poll_block();
 199     }
 200
 201     return 0;
 202 }
 203
 204 static bool
 205 iface_init(struct iface *iface, const char *netdev_name)
 206 {
 207     int retval;
 208
 209     iface->name = netdev_name;
 210     iface->dhcp = NULL;
 211
 212     if (exit_after_bind) {
 213         /* Bring this interface up permanently, so that the bound address
 214          * persists past program termination. */
 215         struct netdev *netdev;
 216
 217         retval = netdev_open_default(iface->name, &netdev);
 218         if (retval) {
 219             ovs_error(retval, "Could not open %s device", iface->name);
 220             return false;
 221         }
 222         retval = netdev_turn_flags_on(netdev, NETDEV_UP, true);
 223         if (retval) {
 224             ovs_error(retval, "Could not bring %s device up", iface->name);
 225             return false;
 226         }
 227         netdev_close(netdev);
 228     }
 229
 230     retval = dhclient_create(iface->name, modify_dhcp_request,
 231                              validate_dhcp_offer, NULL, &iface->dhcp);
 232     if (retval) {
 233         ovs_error(retval, "%s: failed to initialize DHCP client", iface->name);
 234         return false;
 235     }
 236
 237     return true;
 238 }
 239
 240 static void
 241 release_ifaces(void *aux OVS_UNUSED)
 242 {
 243     int i;
 244
 245     for (i = 0; i < n_ifaces; i++) {
 246         struct dhclient *dhcp = ifaces[i].dhcp;
 247         dhclient_release(dhcp);
 248         if (dhclient_changed(dhcp)) {
 249             dhclient_configure_netdev(dhcp);
 250         }
 251     }
 252 }
 253
 254 static void
 255 modify_dhcp_request(struct dhcp_msg *msg, void *aux OVS_UNUSED)
 256 {
 257     dhcp_msg_put_string(msg, DHCP_CODE_VENDOR_CLASS, "OpenFlow");
 258 }
 259
 260 static bool
 261 validate_dhcp_offer(const struct dhcp_msg *msg, void *aux OVS_UNUSED)
 262 {
 263     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(60, 60);
 264     char *vconn_name;
 265     bool accept;
 266
 267     vconn_name = dhcp_msg_get_string(msg, DHCP_CODE_OFP_CONTROLLER_VCONN);
 268     if (!vconn_name) {
 269         VLOG_WARN_RL(&rl, "rejecting DHCP offer missing controller vconn");
 270         return false;
 271     }
 272     accept = !regexec(&accept_controller_regex, vconn_name, 0, NULL, 0);
 273     free(vconn_name);
 274     return accept;
 275 }
 276
 277 static void
 278 parse_options(int argc, char *argv[])
 279 {
 280     enum {
 281         OPT_ACCEPT_VCONN = UCHAR_MAX + 1,
 282         OPT_EXIT_WITHOUT_BIND,
 283         OPT_EXIT_AFTER_BIND,
 284         OPT_NO_DETACH,
 285         VLOG_OPTION_ENUMS
 286     };
 287     static struct option long_options[] = {
 288         {"accept-vconn", required_argument, 0, OPT_ACCEPT_VCONN},
 289         {"exit-without-bind", no_argument, 0, OPT_EXIT_WITHOUT_BIND},
 290         {"exit-after-bind", no_argument, 0, OPT_EXIT_AFTER_BIND},
 291         {"no-detach",   no_argument, 0, OPT_NO_DETACH},
 292         {"timeout",     required_argument, 0, 't'},
 293         {"pidfile",     optional_argument, 0, OPT_PIDFILE},
 294         {"overwrite-pidfile", no_argument, 0, OPT_OVERWRITE_PIDFILE},
 295         {"help",        no_argument, 0, 'h'},
 296         {"version",     no_argument, 0, 'V'},
 297         VLOG_LONG_OPTIONS,
 298         {0, 0, 0, 0},
 299     };
 300     char *short_options = long_options_to_short_options(long_options);
 301     bool detach_after_bind = true;
 302
 303     for (;;) {
 304         unsigned long int timeout;
 305         int c;
 306
 307         c = getopt_long(argc, argv, short_options, long_options, NULL);
 308         if (c == -1) {
 309             break;
 310         }
 311
 312         switch (c) {
 313         case OPT_ACCEPT_VCONN:
 314             accept_controller_re = (optarg[0] == '^'
 315                                     ? optarg
 316                                     : xasprintf("^%s", optarg));
 317             break;
 318
 319         case OPT_EXIT_WITHOUT_BIND:
 320             exit_without_bind = true;
 321             break;
 322
 323         case OPT_EXIT_AFTER_BIND:
 324             exit_after_bind = true;
 325             break;
 326
 327         case OPT_NO_DETACH:
 328             detach_after_bind = false;
 329             break;
 330
 331         case OPT_PIDFILE:
 332             set_pidfile(optarg);
 333             break;
 334
 335         case OPT_OVERWRITE_PIDFILE:
 336             ignore_existing_pidfile();
 337             break;
 338
 339         case 't':
 340             timeout = strtoul(optarg, NULL, 10);
 341             if (timeout <= 0) {
 342                 ovs_fatal(0, "value %s on -t or --timeout is not at least 1",
 343                           optarg);
 344             } else {
 345                 time_alarm(timeout);
 346             }
 347             signal(SIGALRM, SIG_DFL);
 348             break;
 349
 350         case 'h':
 351             usage();
 352
 353         case 'V':
 354             OVS_PRINT_VERSION(0, 0);
 355             exit(EXIT_SUCCESS);
 356
 357         VLOG_OPTION_HANDLERS
 358
 359         case '?':
 360             exit(EXIT_FAILURE);
 361
 362         default:
 363             abort();
 364         }
 365     }
 366     free(short_options);
 367
 368     if ((exit_without_bind + exit_after_bind + !detach_after_bind) > 1) {
 369         ovs_fatal(0, "--exit-without-bind, --exit-after-bind, and --no-detach "
 370                   "are mutually exclusive");
 371     }
 372     if (detach_after_bind) {
 373         set_detach();
 374     }
 375 }
 376
 377 static void
 378 usage(void)
 379 {
 380     printf("%s: a tool for discovering OpenFlow controllers.\n"
 381            "usage: %s [OPTIONS] NETDEV [NETDEV...]\n"
 382            "where each NETDEV is a network device on which to perform\n"
 383            "controller discovery.\n"
 384            "\nOrdinarily, ovs-discover runs in the foreground until it\n"
 385            "obtains an IP address and discovers an OpenFlow controller via\n"
 386            "DHCP, then it prints information about the controller to stdout\n"
 387            "and detaches to the background to maintain the IP address lease.\n"
 388            "\nNetworking options:\n"
 389            "  --accept-vconn=REGEX    accept matching discovered controllers\n"
 390            "  --exit-without-bind     exit after discovery, without binding\n"
 391            "  --exit-after-bind       exit after discovery, after binding\n"
 392            "  --no-detach             do not detach after discovery\n",
 393            program_name, program_name);
 394     vlog_usage();
 395     printf("\nOther options:\n"
 396            "  -t, --timeout=SECS      give up discovery after SECS seconds\n"
 397            "  --pidfile[=FILE]        create pidfile (default: %s/%s.pid)\n"
 398            "  --overwrite-pidfile     with --pidfile, start even if already "
 399                                       "running\n"
 400            "  -h, --help              display this help message\n"
 401            "  -V, --version           display version information\n",
 402            ovs_rundir, program_name);
 403     exit(EXIT_SUCCESS);
 404 }