controller/controller.c

   1 /* Copyright (c) 2008 The Board of Trustees of The Leland Stanford
   2  * Junior University
   3  *
   4  * We are making the OpenFlow specification and associated documentation
   5  * (Software) available for public use and benefit with the expectation
   6  * that others will use, modify and enhance the Software and contribute
   7  * those enhancements back to the community. However, since we would
   8  * like to make the Software available for broadest use, with as few
   9  * restrictions as possible permission is hereby granted, free of
  10  * charge, to any person obtaining a copy of this Software to deal in
  11  * the Software under the copyrights without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sublicense, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be
  18  * included in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  24  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  25  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  27  * SOFTWARE.
  28  *
  29  * The name and trademarks of copyright holder(s) may NOT be used in
  30  * advertising or publicity pertaining to the Software or any
  31  * derivatives without specific, written prior permission.
  32  */
  33
  34 #include <assert.h>
  35 #include <errno.h>
  36 #include <getopt.h>
  37 #include <inttypes.h>
  38 #include <netinet/in.h>
  39 #include <poll.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <unistd.h>
  43
  44 #include "buffer.h"
  45 #include "command-line.h"
  46 #include "compiler.h"
  47 #include "fault.h"
  48 #include "flow.h"
  49 #include "hash.h"
  50 #include "list.h"
  51 #include "mac.h"
  52 #include "ofp-print.h"
  53 #include "openflow.h"
  54 #include "poll-loop.h"
  55 #include "queue.h"
  56 #include "time.h"
  57 #include "util.h"
  58 #include "vconn-ssl.h"
  59 #include "vconn.h"
  60 #include "vlog-socket.h"
  61 #include "xtoxll.h"
  62
  63 #include "vlog.h"
  64 #define THIS_MODULE VLM_controller
  65
  66 #define MAX_SWITCHES 16
  67 #define MAX_TXQ 128
  68
  69 struct switch_ {
  70     char *name;
  71     struct vconn *vconn;
  72
  73     uint64_t datapath_id;
  74     time_t last_control_hello;
  75
  76     struct queue txq;
  77 };
  78
  79 /* -H, --hub: Use dumb hub instead of learning switch? */
  80 static bool hub = false;
  81
  82 /* -n, --noflow: Pass traffic, but don't setup flows in switch */
  83 static bool noflow = false;
  84
  85 static void parse_options(int argc, char *argv[]);
  86 static void usage(void) NO_RETURN;
  87
  88 static struct switch_ *connect_switch(const char *name);
  89 static struct switch_ *new_switch(const char *name, struct vconn *);
  90 static void close_switch(struct switch_ *);
  91
  92 static void queue_tx(struct switch_ *, struct buffer *);
  93
  94 static void send_control_hello(struct switch_ *);
  95
  96 static int do_switch_recv(struct switch_ *this);
  97 static int do_switch_send(struct switch_ *this);
  98
  99 static void process_packet(struct switch_ *, struct buffer *);
 100 static void process_hub(struct switch_ *, struct ofp_packet_in *);
 101 static void process_noflow(struct switch_ *, struct ofp_packet_in *);
 102
 103 static void switch_init(void);
 104 static void process_switch(struct switch_ *, struct ofp_packet_in *);
 105
 106 int
 107 main(int argc, char *argv[])
 108 {
 109     struct switch_ *switches[MAX_SWITCHES];
 110     int n_switches;
 111     int retval;
 112     int i;
 113
 114     set_program_name(argv[0]);
 115     register_fault_handlers();
 116     vlog_init();
 117     parse_options(argc, argv);
 118
 119     if (!hub && !noflow) {
 120         switch_init();
 121     }
 122
 123     if (argc - optind < 1) {
 124         fatal(0, "at least one vconn argument required; use --help for usage");
 125     }
 126
 127     retval = vlog_server_listen(NULL, NULL);
 128     if (retval) {
 129         fatal(retval, "Could not listen for vlog connections");
 130     }
 131
 132     n_switches = 0;
 133     for (i = 0; i < argc - optind; i++) {
 134         struct switch_ *this = connect_switch(argv[optind + i]);
 135         if (this) {
 136             if (n_switches >= MAX_SWITCHES) {
 137                 fatal(0, "max %d switch connections", n_switches);
 138             }
 139             switches[n_switches++] = this;
 140         }
 141     }
 142     if (n_switches == 0) {
 143         fatal(0, "could not connect to any switches");
 144     }
 145
 146     while (n_switches > 0) {
 147         /* Do some work.  Limit the number of iterations so that callbacks
 148          * registered with the poll loop don't starve. */
 149         int iteration;
 150         int i;
 151         for (iteration = 0; iteration < 50; iteration++) {
 152             bool progress = false;
 153             for (i = 0; i < n_switches; ) {
 154                 struct switch_ *this = switches[i];
 155                 int retval;
 156
 157                 if (vconn_is_passive(this->vconn)) {
 158                     retval = 0;
 159                     while (n_switches < MAX_SWITCHES) {
 160                         struct vconn *new_vconn;
 161                         retval = vconn_accept(this->vconn, &new_vconn);
 162                         if (retval) {
 163                             break;
 164                         }
 165                         switches[n_switches++] = new_switch("tcp", new_vconn);
 166                     }
 167                 } else {
 168                     retval = do_switch_recv(this);
 169                     if (!retval || retval == EAGAIN) {
 170                         do {
 171                             retval = do_switch_send(this);
 172                             if (!retval) {
 173                                 progress = true;
 174                             }
 175                         } while (!retval);
 176                     }
 177                 }
 178
 179                 if (retval && retval != EAGAIN) {
 180                     close_switch(this);
 181                     switches[i] = switches[--n_switches];
 182                 } else {
 183                     i++;
 184                 }
 185             }
 186             if (!progress) {
 187                 break;
 188             }
 189         }
 190
 191         /* Wait for something to happen. */
 192         for (i = 0; i < n_switches; i++) {
 193             struct switch_ *this = switches[i];
 194             if (vconn_is_passive(this->vconn)) {
 195                 if (n_switches < MAX_SWITCHES) {
 196                     vconn_accept_wait(this->vconn);
 197                 }
 198             } else {
 199                 vconn_recv_wait(this->vconn);
 200                 if (this->txq.n) {
 201                     vconn_send_wait(this->vconn);
 202                 }
 203             }
 204         }
 205         poll_block();
 206     }
 207
 208     return 0;
 209 }
 210
 211 static int
 212 do_switch_recv(struct switch_ *this)
 213 {
 214     struct buffer *msg;
 215     int retval;
 216
 217     retval = vconn_recv(this->vconn, &msg);
 218     if (!retval) {
 219         process_packet(this, msg);
 220         buffer_delete(msg);
 221     }
 222     return retval;
 223 }
 224
 225 static int
 226 do_switch_send(struct switch_ *this)
 227 {
 228     int retval = 0;
 229     if (this->txq.n) {
 230         struct buffer *next = this->txq.head->next;
 231         retval = vconn_send(this->vconn, this->txq.head);
 232         if (retval) {
 233             return retval;
 234         }
 235         queue_advance_head(&this->txq, next);
 236         return 0;
 237     }
 238     return EAGAIN;
 239 }
 240
 241 struct switch_ *
 242 connect_switch(const char *name)
 243 {
 244     struct vconn *vconn;
 245     int retval;
 246
 247     retval = vconn_open(name, &vconn);
 248     if (retval) {
 249         VLOG_ERR("%s: connect: %s", name, strerror(retval));
 250         return NULL;
 251     }
 252
 253     return new_switch(name, vconn);
 254 }
 255
 256 static struct switch_ *
 257 new_switch(const char *name, struct vconn *vconn)
 258 {
 259     struct switch_ *this = xmalloc(sizeof *this);
 260     memset(this, 0, sizeof *this);
 261     this->name = xstrdup(name);
 262     this->vconn = vconn;
 263     queue_init(&this->txq);
 264     this->last_control_hello = 0;
 265     if (!vconn_is_passive(vconn)) {
 266         send_control_hello(this);
 267     }
 268     return this;
 269 }
 270
 271 static void
 272 close_switch(struct switch_ *this)
 273 {
 274     if (this) {
 275         free(this->name);
 276         vconn_close(this->vconn);
 277         queue_destroy(&this->txq);
 278         free(this);
 279     }
 280 }
 281
 282 static void
 283 send_control_hello(struct switch_ *this)
 284 {
 285     time_t now = time(0);
 286     if (now >= this->last_control_hello + 1) {
 287         struct buffer *b;
 288         struct ofp_control_hello *och;
 289
 290         b = buffer_new(0);
 291         och = buffer_put_uninit(b, sizeof *och);
 292         memset(och, 0, sizeof *och);
 293         och->header.version = OFP_VERSION;
 294         och->header.length = htons(sizeof *och);
 295
 296         och->version = htonl(OFP_VERSION);
 297         och->flags = htons(OFP_CHELLO_SEND_FLOW_EXP);
 298         och->miss_send_len = htons(OFP_DEFAULT_MISS_SEND_LEN);
 299         queue_tx(this, b);
 300
 301         this->last_control_hello = now;
 302     }
 303 }
 304
 305 static void
 306 queue_tx(struct switch_ *this, struct buffer *b)
 307 {
 308     queue_push_tail(&this->txq, b);
 309 }
 310
 311 static void
 312 process_packet(struct switch_ *sw, struct buffer *msg)
 313 {
 314     static const size_t min_size[UINT8_MAX + 1] = {
 315         [0 ... UINT8_MAX] = SIZE_MAX,
 316         [OFPT_CONTROL_HELLO] = sizeof (struct ofp_control_hello),
 317         [OFPT_DATA_HELLO] = sizeof (struct ofp_data_hello),
 318         [OFPT_PACKET_IN] = offsetof (struct ofp_packet_in, data),
 319         [OFPT_PACKET_OUT] = sizeof (struct ofp_packet_out),
 320         [OFPT_FLOW_MOD] = sizeof (struct ofp_flow_mod),
 321         [OFPT_FLOW_EXPIRED] = sizeof (struct ofp_flow_expired),
 322         [OFPT_TABLE] = sizeof (struct ofp_table),
 323         [OFPT_PORT_MOD] = sizeof (struct ofp_port_mod),
 324         [OFPT_PORT_STATUS] = sizeof (struct ofp_port_status),
 325         [OFPT_FLOW_STAT_REQUEST] = sizeof (struct ofp_flow_stat_request),
 326         [OFPT_FLOW_STAT_REPLY] = sizeof (struct ofp_flow_stat_reply),
 327     };
 328     struct ofp_header *oh;
 329
 330     oh = msg->data;
 331     if (msg->size < min_size[oh->type]) {
 332         VLOG_WARN("%s: too short (%zu bytes) for type %"PRIu8" (min %zu)",
 333                   sw->name, msg->size, oh->type, min_size[oh->type]);
 334         return;
 335     }
 336
 337     if (oh->type == OFPT_DATA_HELLO) {
 338         struct ofp_data_hello *odh = msg->data;
 339         sw->datapath_id = odh->datapath_id;
 340     } else if (sw->datapath_id == 0) {
 341         send_control_hello(sw);
 342         return;
 343     }
 344
 345     if (oh->type == OFPT_PACKET_IN) {
 346         if (sw->txq.n >= MAX_TXQ) {
 347             /* FIXME: ratelimit. */
 348             VLOG_WARN("%s: tx queue overflow", sw->name);
 349         } else if (noflow) {
 350             process_noflow(sw, msg->data);
 351         } else if (hub) {
 352             process_hub(sw, msg->data);
 353         } else {
 354             process_switch(sw, msg->data);
 355         }
 356         return;
 357     }
 358
 359     ofp_print(stdout, msg->data, msg->size, 2);
 360 }
 361
 362 static void
 363 process_hub(struct switch_ *sw, struct ofp_packet_in *opi)
 364 {
 365     size_t pkt_ofs, pkt_len;
 366     struct buffer pkt;
 367     struct flow flow;
 368
 369     /* Extract flow data from 'opi' into 'flow'. */
 370     pkt_ofs = offsetof(struct ofp_packet_in, data);
 371     pkt_len = ntohs(opi->header.length) - pkt_ofs;
 372     pkt.data = opi->data;
 373     pkt.size = pkt_len;
 374     flow_extract(&pkt, ntohs(opi->in_port), &flow);
 375
 376     /* Add new flow. */
 377     queue_tx(sw, make_add_simple_flow(&flow, ntohl(opi->buffer_id),
 378                                       OFPP_FLOOD));
 379
 380     /* If the switch didn't buffer the packet, we need to send a copy. */
 381     if (ntohl(opi->buffer_id) == UINT32_MAX) {
 382         queue_tx(sw, make_unbuffered_packet_out(&pkt, ntohs(flow.in_port),
 383                                                 OFPP_FLOOD));
 384     }
 385 }
 386
 387 static void
 388 process_noflow(struct switch_ *sw, struct ofp_packet_in *opi)
 389 {
 390     /* If the switch didn't buffer the packet, we need to send a copy. */
 391     if (ntohl(opi->buffer_id) == UINT32_MAX) {
 392         size_t pkt_ofs, pkt_len;
 393         struct buffer pkt;
 394
 395         /* Extract flow data from 'opi' into 'flow'. */
 396         pkt_ofs = offsetof(struct ofp_packet_in, data);
 397         pkt_len = ntohs(opi->header.length) - pkt_ofs;
 398         pkt.data = opi->data;
 399         pkt.size = pkt_len;
 400
 401         queue_tx(sw, make_unbuffered_packet_out(&pkt, ntohs(opi->in_port),
 402                     OFPP_FLOOD));
 403     } else {
 404         queue_tx(sw, make_buffered_packet_out(ntohl(opi->buffer_id),
 405                     ntohs(opi->in_port), OFPP_FLOOD));
 406     }
 407 }
 408
 409
 410 #define MAC_HASH_BITS 10
 411 #define MAC_HASH_MASK (MAC_HASH_SIZE - 1)
 412 #define MAC_HASH_SIZE (1u << MAC_HASH_BITS)
 413
 414 #define MAC_MAX 1024
 415
 416 struct mac_source {
 417     struct list hash_list;
 418     struct list lru_list;
 419     uint64_t datapath_id;
 420     uint8_t mac[ETH_ADDR_LEN];
 421     uint16_t port;
 422 };
 423
 424 static struct list mac_table[MAC_HASH_SIZE];
 425 static struct list lrus;
 426 static size_t mac_count;
 427
 428 static void
 429 switch_init(void)
 430 {
 431     int i;
 432
 433     list_init(&lrus);
 434     for (i = 0; i < MAC_HASH_SIZE; i++) {
 435         list_init(&mac_table[i]);
 436     }
 437 }
 438
 439 static struct list *
 440 mac_table_bucket(uint64_t datapath_id, const uint8_t mac[ETH_ADDR_LEN])
 441 {
 442     uint32_t hash;
 443     hash = hash_fnv(&datapath_id, sizeof datapath_id, HASH_FNV_BASIS);
 444     hash = hash_fnv(mac, ETH_ADDR_LEN, hash);
 445     return &mac_table[hash & MAC_HASH_BITS];
 446 }
 447
 448 static void
 449 process_switch(struct switch_ *sw, struct ofp_packet_in *opi)
 450 {
 451     size_t pkt_ofs, pkt_len;
 452     struct buffer pkt;
 453     struct flow flow;
 454
 455     uint16_t out_port;
 456
 457     /* Extract flow data from 'opi' into 'flow'. */
 458     pkt_ofs = offsetof(struct ofp_packet_in, data);
 459     pkt_len = ntohs(opi->header.length) - pkt_ofs;
 460     pkt.data = opi->data;
 461     pkt.size = pkt_len;
 462     flow_extract(&pkt, ntohs(opi->in_port), &flow);
 463
 464     /* Learn the source. */
 465     if (!mac_is_multicast(flow.dl_src)) {
 466         struct mac_source *src;
 467         struct list *bucket;
 468         bool found;
 469
 470         bucket = mac_table_bucket(sw->datapath_id, flow.dl_src);
 471         found = false;
 472         LIST_FOR_EACH (src, struct mac_source, hash_list, bucket) {
 473             if (src->datapath_id == sw->datapath_id
 474                 && mac_equals(src->mac, flow.dl_src)) {
 475                 found = true;
 476                 break;
 477             }
 478         }
 479
 480         if (!found) {
 481             /* Learn a new address. */
 482
 483             if (mac_count >= MAC_MAX) {
 484                 /* Drop the least recently used mac source. */
 485                 struct mac_source *lru;
 486                 lru = CONTAINER_OF(lrus.next, struct mac_source, lru_list);
 487                 list_remove(&lru->hash_list);
 488                 list_remove(&lru->lru_list);
 489                 free(lru);
 490             } else {
 491                 mac_count++;
 492             }
 493
 494             /* Create new mac source */
 495             src = xmalloc(sizeof *src);
 496             src->datapath_id = sw->datapath_id;
 497             memcpy(src->mac, flow.dl_src, ETH_ADDR_LEN);
 498             src->port = -1;
 499             list_push_front(bucket, &src->hash_list);
 500             list_push_back(&lrus, &src->lru_list);
 501         } else {
 502             /* Make 'src' most-recently-used.  */
 503             list_remove(&src->lru_list);
 504             list_push_back(&lrus, &src->lru_list);
 505         }
 506
 507         if (ntohs(flow.in_port) != src->port) {
 508             src->port = ntohs(flow.in_port);
 509             VLOG_DBG("learned that "MAC_FMT" is on datapath %"PRIx64" port %d",
 510                      MAC_ARGS(src->mac), ntohll(src->datapath_id),
 511                      src->port);
 512         }
 513     } else {
 514         VLOG_DBG("multicast packet source "MAC_FMT, MAC_ARGS(flow.dl_src));
 515     }
 516
 517     /* Figure out the destination. */
 518     out_port = OFPP_FLOOD;
 519     if (!mac_is_multicast(flow.dl_dst)) {
 520         struct mac_source *dst;
 521         struct list *bucket;
 522
 523         bucket = mac_table_bucket(sw->datapath_id, flow.dl_dst);
 524         LIST_FOR_EACH (dst, struct mac_source, hash_list, bucket) {
 525             if (dst->datapath_id == sw->datapath_id
 526                 && mac_equals(dst->mac, flow.dl_dst)) {
 527                 out_port = dst->port;
 528                 break;
 529             }
 530         }
 531     }
 532
 533     if (out_port != OFPP_FLOOD) {
 534         /* The output port is known, so add a new flow. */
 535         queue_tx(sw, make_add_simple_flow(&flow, ntohl(opi->buffer_id),
 536                     out_port));
 537
 538         /* If the switch didn't buffer the packet, we need to send a copy. */
 539         if (ntohl(opi->buffer_id) == UINT32_MAX) {
 540             queue_tx(sw, make_unbuffered_packet_out(&pkt, ntohs(flow.in_port),
 541                                                     out_port));
 542         }
 543     } else {
 544         /* We don't know that MAC.  Flood the packet. */
 545         struct buffer *b;
 546         if (ntohl(opi->buffer_id) == UINT32_MAX) {
 547             b = make_unbuffered_packet_out(&pkt, ntohs(flow.in_port), out_port);
 548         } else {
 549             b = make_buffered_packet_out(ntohl(opi->buffer_id),
 550                         ntohs(flow.in_port), out_port);
 551         }
 552         queue_tx(sw, b);
 553     }
 554 }
 555
 556 static void
 557 parse_options(int argc, char *argv[])
 558 {
 559     static struct option long_options[] = {
 560         {"hub",         no_argument, 0, 'H'},
 561         {"noflow",      no_argument, 0, 'n'},
 562         {"verbose",     optional_argument, 0, 'v'},
 563         {"help",        no_argument, 0, 'h'},
 564         {"version",     no_argument, 0, 'V'},
 565 #ifdef HAVE_OPENSSL
 566         {"private-key", required_argument, 0, 'p'},
 567         {"certificate", required_argument, 0, 'c'},
 568         {"ca-cert",     required_argument, 0, 'C'},
 569 #endif
 570         {0, 0, 0, 0},
 571     };
 572     char *short_options = long_options_to_short_options(long_options);
 573
 574     for (;;) {
 575         int indexptr;
 576         int c;
 577
 578         c = getopt_long(argc, argv, short_options, long_options, &indexptr);
 579         if (c == -1) {
 580             break;
 581         }
 582
 583         switch (c) {
 584         case 'H':
 585             hub = true;
 586             break;
 587
 588         case 'n':
 589             noflow = true;
 590             break;
 591
 592         case 'h':
 593             usage();
 594
 595         case 'V':
 596             printf("%s "VERSION" compiled "__DATE__" "__TIME__"\n", argv[0]);
 597             exit(EXIT_SUCCESS);
 598
 599         case 'v':
 600             vlog_set_verbosity(optarg);
 601             break;
 602
 603 #ifdef HAVE_OPENSSL
 604         case 'p':
 605             vconn_ssl_set_private_key_file(optarg);
 606             break;
 607
 608         case 'c':
 609             vconn_ssl_set_certificate_file(optarg);
 610             break;
 611
 612         case 'C':
 613             vconn_ssl_set_ca_cert_file(optarg);
 614             break;
 615 #endif
 616
 617         case '?':
 618             exit(EXIT_FAILURE);
 619
 620         default:
 621             abort();
 622         }
 623     }
 624     free(short_options);
 625 }
 626
 627 static void
 628 usage(void)
 629 {
 630     printf("%s: OpenFlow controller\n"
 631            "usage: %s [OPTIONS] VCONN\n"
 632            "where VCONN is one of the following:\n"
 633            "  ptcp:[PORT]             listen to TCP PORT (default: %d)\n",
 634            program_name, program_name, OFP_TCP_PORT);
 635 #ifdef HAVE_NETLINK
 636     printf("  nl:DP_IDX               via netlink to local datapath DP_IDX\n");
 637 #endif
 638 #ifdef HAVE_OPENSSL
 639     printf("  pssl:[PORT]             listen for SSL on PORT (default: %d)\n"
 640            "\nPKI configuration (required to use SSL):\n"
 641            "  -p, --private-key=FILE  file with private key\n"
 642            "  -c, --certificate=FILE  file with certificate for private key\n"
 643            "  -C, --ca-cert=FILE      file with peer CA certificate\n",
 644            OFP_SSL_PORT);
 645 #endif
 646     printf("\nOther options:\n"
 647            "  -H, --hub               act as hub instead of learning switch\n"
 648            "  -n, --noflow            pass traffic, but don't add flows\n"
 649            "  -v, --verbose           set maximum verbosity level\n"
 650            "  -h, --help              display this help message\n"
 651            "  -V, --version           display version information\n");
 652     exit(EXIT_SUCCESS);
 653 }