vswitchd/mgmt.c

   1 /* Copyright (c) 2009 Nicira Networks
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * In addition, as a special exception, Nicira Networks gives permission
  17  * to link the code of its release of vswitchd with the OpenSSL project's
  18  * "OpenSSL" library (or with modified versions of it that use the same
  19  * license as the "OpenSSL" library), and distribute the linked
  20  * executables.  You must obey the GNU General Public License in all
  21  * respects for all of the code used other than "OpenSSL".  If you modify
  22  * this file, you may extend this exception to your version of the file,
  23  * but you are not obligated to do so.  If you do not wish to do so,
  24  * delete this exception statement from your version.
  25  *
  26  */
  27
  28 #include <config.h>
  29
  30 #include <arpa/inet.h>
  31 #include <assert.h>
  32 #include <errno.h>
  33 #include <stdlib.h>
  34
  35 #include "bridge.h"
  36 #include "cfg.h"
  37 #include "coverage.h"
  38 #include "list.h"
  39 #include "mgmt.h"
  40 #include "openflow/nicira-ext.h"
  41 #include "openflow/openflow.h"
  42 #include "openflow/openflow-mgmt.h"
  43 #include "ofpbuf.h"
  44 #include "ovs-vswitchd.h"
  45 #include "packets.h"
  46 #include "rconn.h"
  47 #include "svec.h"
  48 #include "vconn.h"
  49 #include "vconn-ssl.h"
  50 #include "xenserver.h"
  51 #include "xtoxll.h"
  52
  53 #define THIS_MODULE VLM_mgmt
  54 #include "vlog.h"
  55
  56 #define MAX_BACKOFF_DEFAULT 15
  57 #define INACTIVITY_PROBE_DEFAULT 15
  58
  59 static struct svec mgmt_cfg;
  60 static uint8_t cfg_cookie[CFG_COOKIE_LEN];
  61 static struct rconn *mgmt_rconn;
  62 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(60, 60);
  63 static struct svec capabilities;
  64 uint64_t mgmt_id;
  65
  66
  67 #define TXQ_LIMIT 128         /* Max number of packets to queue for tx. */
  68 struct rconn_packet_counter *txqlen; /* # pkts queued for tx on mgmt_rconn. */
  69
  70 static uint64_t pick_fallback_mgmt_id(void);
  71 static void send_config_update(uint32_t xid, bool use_xid);
  72 static void send_resources_update(uint32_t xid, bool use_xid);
  73
  74 void
  75 mgmt_init(void)
  76 {
  77     txqlen = rconn_packet_counter_create();
  78
  79     svec_init(&mgmt_cfg);
  80     svec_init(&capabilities);
  81     svec_add_nocopy(&capabilities,
  82             xasprintf("com.nicira.mgmt.manager=true\n"));
  83
  84     mgmt_id = cfg_get_dpid(0, "mgmt.id");
  85     if (!mgmt_id) {
  86         /* Randomly generate a mgmt id */
  87         mgmt_id = pick_fallback_mgmt_id();
  88     }
  89 }
  90
  91 #ifdef HAVE_OPENSSL
  92 static bool
  93 config_string_change(const char *key, char **valuep)
  94 {
  95     const char *value = cfg_get_string(0, "%s", key);
  96     if (value && (!*valuep || strcmp(value, *valuep))) {
  97         free(*valuep);
  98         *valuep = xstrdup(value);
  99         return true;
 100     } else {
 101         return false;
 102     }
 103 }
 104
 105 static void
 106 mgmt_configure_ssl(void)
 107 {
 108     static char *private_key_file;
 109     static char *certificate_file;
 110     static char *cacert_file;
 111
 112     /* XXX SSL should be configurable separate from the bridges.
 113      * XXX should be possible to de-configure SSL. */
 114     if (config_string_change("ssl.private-key", &private_key_file)) {
 115         vconn_ssl_set_private_key_file(private_key_file);
 116     }
 117
 118     if (config_string_change("ssl.certificate", &certificate_file)) {
 119         vconn_ssl_set_certificate_file(certificate_file);
 120     }
 121
 122     if (config_string_change("ssl.ca-cert", &cacert_file)) {
 123         vconn_ssl_set_ca_cert_file(cacert_file,
 124                 cfg_get_bool(0, "ssl.bootstrap-ca-cert"));
 125     }
 126 }
 127 #endif
 128
 129 void
 130 mgmt_reconfigure(void)
 131 {
 132     struct svec new_cfg;
 133     uint8_t new_cookie[CFG_COOKIE_LEN];
 134     bool cfg_updated = false;
 135     const char *controller_name;
 136     int max_backoff;
 137     int inactivity_probe;
 138     int retval;
 139
 140     if (!cfg_has_section("mgmt")) {
 141         if (mgmt_rconn) {
 142             rconn_destroy(mgmt_rconn);
 143             mgmt_rconn = NULL;
 144         }
 145         return;
 146     }
 147
 148     /* If this is an established connection, send a resources update. */
 149     /* xxx This is wasteful if there were no resource changes!!! */
 150     if (mgmt_rconn) {
 151         send_resources_update(0, false);
 152     }
 153
 154     cfg_get_cookie(new_cookie);
 155     if (memcmp(cfg_cookie, new_cookie, sizeof(cfg_cookie))) {
 156         memcpy(cfg_cookie, new_cookie, sizeof(cfg_cookie));
 157         cfg_updated = true;
 158     }
 159
 160     svec_init(&new_cfg);
 161     cfg_get_section(&new_cfg, "mgmt");
 162     if (svec_equal(&mgmt_cfg, &new_cfg)) {
 163         /* Reconnecting to the controller causes the config file to be
 164          * resent automatically.  If we're not reconnecting and the
 165          * config file has changed, we need to notify the controller of
 166          * changes. */
 167         if (cfg_updated && mgmt_rconn) {
 168             send_config_update(0, false);
 169         }
 170         svec_destroy(&new_cfg);
 171         return;
 172     }
 173
 174     controller_name = cfg_get_string(0, "mgmt.controller");
 175     if (!controller_name) {
 176         VLOG_ERR("no controller specified for managment");
 177         svec_destroy(&new_cfg);
 178         return;
 179     }
 180
 181     max_backoff = cfg_get_int(0, "mgmt.max-backoff");
 182     if (max_backoff < 1) {
 183         max_backoff = MAX_BACKOFF_DEFAULT;
 184     } else if (max_backoff > 3600) {
 185         max_backoff = 3600;
 186     }
 187
 188     inactivity_probe = cfg_get_int(0, "mgmt.inactivity-probe");
 189     if (inactivity_probe < 5) {
 190         inactivity_probe = INACTIVITY_PROBE_DEFAULT;
 191     }
 192
 193     /* xxx If this changes, we need to restart bridges to use new id,
 194      * xxx but they need the id before the connect to controller, but we
 195      * xxx need their dpids. */
 196     /* Check if a different mgmt id has been assigned. */
 197     if (cfg_has("mgmt.id")) {
 198         uint64_t cfg_mgmt_id = cfg_get_dpid(0, "mgmt.id");
 199         if (cfg_mgmt_id != mgmt_id) {
 200             mgmt_id = cfg_mgmt_id;
 201         }
 202     }
 203
 204     svec_swap(&new_cfg, &mgmt_cfg);
 205     svec_destroy(&new_cfg);
 206
 207 #ifdef HAVE_OPENSSL
 208     /* Configure SSL. */
 209     mgmt_configure_ssl();
 210 #endif
 211
 212     if (mgmt_rconn) {
 213         rconn_destroy(mgmt_rconn);
 214         mgmt_rconn = NULL;
 215     }
 216     mgmt_rconn = rconn_create(inactivity_probe, max_backoff);
 217     retval = rconn_connect(mgmt_rconn, controller_name);
 218     if (retval == EAFNOSUPPORT) {
 219         VLOG_ERR("no support for %s vconn", controller_name);
 220     }
 221 }
 222
 223 static int
 224 send_openflow_buffer(struct ofpbuf *buffer)
 225 {
 226     int retval;
 227
 228     if (!mgmt_rconn) {
 229         VLOG_ERR("attempt to send openflow packet with no rconn\n");
 230         return EINVAL;
 231     }
 232
 233     update_openflow_length(buffer);
 234     retval = rconn_send_with_limit(mgmt_rconn, buffer, txqlen, TXQ_LIMIT);
 235     if (retval) {
 236         VLOG_WARN_RL(&rl, "send to %s failed: %s",
 237                      rconn_get_name(mgmt_rconn), strerror(retval));
 238     }
 239     return retval;
 240 }
 241
 242 static void
 243 send_features_reply(uint32_t xid)
 244 {
 245     struct ofpbuf *buffer;
 246     struct ofp_switch_features *ofr;
 247
 248     ofr = make_openflow_xid(sizeof *ofr, OFPT_FEATURES_REPLY, xid, &buffer);
 249     ofr->datapath_id  = 0;
 250     ofr->n_tables     = 0;
 251     ofr->n_buffers    = 0;
 252     ofr->capabilities = 0;
 253     ofr->actions      = 0;
 254     send_openflow_buffer(buffer);
 255 }
 256
 257 static void *
 258 make_ofmp_xid(size_t ofmp_len, uint16_t type, uint32_t xid,
 259         struct ofpbuf **bufferp)
 260 {
 261     struct ofmp_header *oh;
 262
 263     oh = make_openflow_xid(ofmp_len, OFPT_VENDOR, xid, bufferp);
 264     oh->header.vendor = htonl(NX_VENDOR_ID);
 265     oh->header.subtype = htonl(NXT_MGMT);
 266     oh->type = htons(type);
 267
 268     return oh;
 269 }
 270
 271 static void *
 272 make_ofmp(size_t ofmp_len, uint16_t type, struct ofpbuf **bufferp)
 273 {
 274     struct ofmp_header *oh;
 275
 276     oh = make_openflow(ofmp_len, OFPT_VENDOR, bufferp);
 277     oh->header.vendor = htonl(NX_VENDOR_ID);
 278     oh->header.subtype = htonl(NXT_MGMT);
 279     oh->type = htons(type);
 280
 281     return oh;
 282 }
 283
 284 static void
 285 send_capability_reply(uint32_t xid)
 286 {
 287     int i;
 288     struct ofpbuf *buffer;
 289     struct ofmp_capability_reply *ofmpcr;
 290
 291     ofmpcr = make_ofmp_xid(sizeof *ofmpcr, OFMPT_CAPABILITY_REPLY,
 292             xid, &buffer);
 293     ofmpcr->format = htonl(OFMPCOF_SIMPLE);
 294     ofmpcr->mgmt_id = htonll(mgmt_id);
 295     for (i=0; i<capabilities.n; i++) {
 296         ofpbuf_put(buffer, capabilities.names[i],
 297                 strlen(capabilities.names[i]));
 298     }
 299     send_openflow_buffer(buffer);
 300 }
 301
 302 static void
 303 send_resources_update(uint32_t xid, bool use_xid)
 304 {
 305     struct ofpbuf *buffer;
 306     struct ofmp_resources_update *ofmpru;
 307     struct ofmp_tlv *tlv;
 308     struct svec br_list;
 309     const char *host_uuid;
 310     int i;
 311
 312     if (use_xid) {
 313         ofmpru = make_ofmp_xid(sizeof *ofmpru, OFMPT_RESOURCES_UPDATE,
 314                 xid, &buffer);
 315     } else {
 316         ofmpru = make_ofmp(sizeof *ofmpru, OFMPT_RESOURCES_UPDATE, &buffer);
 317     }
 318
 319     /* On XenServer systems, each host has its own UUID, which we provide
 320      * to the controller.
 321      */
 322     host_uuid = xenserver_get_host_uuid();
 323     if (host_uuid) {
 324         struct ofmptsr_mgmt_uuid *mgmt_uuid_tlv;
 325
 326         mgmt_uuid_tlv = ofpbuf_put_zeros(buffer, sizeof(*mgmt_uuid_tlv));
 327         mgmt_uuid_tlv->type = htons(OFMPTSR_MGMT_UUID);
 328         mgmt_uuid_tlv->len = htons(sizeof(*mgmt_uuid_tlv));
 329         mgmt_uuid_tlv->mgmt_id = htonll(mgmt_id);
 330         memcpy(mgmt_uuid_tlv->uuid, host_uuid, OFMP_UUID_LEN);
 331     }
 332
 333     svec_init(&br_list);
 334     cfg_get_subsections(&br_list, "bridge");
 335     for (i=0; i < br_list.n; i++) {
 336         struct ofmptsr_dp *dp_tlv;
 337         uint64_t dp_id;
 338         int n_uuid;
 339
 340         dp_id = bridge_get_datapathid(br_list.names[i]);
 341         if (!dp_id) {
 342             VLOG_WARN_RL(&rl, "bridge %s doesn't seem to exist",
 343                     br_list.names[i]);
 344             continue;
 345         }
 346         dp_tlv = ofpbuf_put_zeros(buffer, sizeof(*dp_tlv));
 347         dp_tlv->type = htons(OFMPTSR_DP);
 348         dp_tlv->len = htons(sizeof(*dp_tlv));
 349
 350         dp_tlv->dp_id = htonll(dp_id);
 351         memcpy(dp_tlv->name, br_list.names[i], strlen(br_list.names[i])+1);
 352
 353         /* On XenServer systems, each network has one or more UUIDs
 354          * associated with it, which we provide to the controller.
 355          */
 356         n_uuid = cfg_count("bridge.%s.xs-network-uuids", br_list.names[i]);
 357         if (n_uuid) {
 358             struct ofmptsr_dp_uuid *dp_uuid_tlv;
 359             size_t tlv_len = sizeof(*dp_uuid_tlv) + n_uuid * OFMP_UUID_LEN;
 360             int j;
 361
 362             dp_uuid_tlv = ofpbuf_put_zeros(buffer, sizeof(*dp_uuid_tlv));
 363             dp_uuid_tlv->type = htons(OFMPTSR_DP_UUID);
 364             dp_uuid_tlv->len = htons(tlv_len);
 365             dp_uuid_tlv->dp_id = htonll(dp_id);
 366
 367             for (j=0; j<n_uuid; j++) {
 368                 const char *dp_uuid = cfg_get_string(j,
 369                         "bridge.%s.xs-network-uuids", br_list.names[i]);
 370
 371                 /* The UUID list could change underneath us, so just
 372                  * fill with zeros in that case.  Another update will be
 373                  * initiated shortly, which should contain corrected data.
 374                  */
 375                 if (dp_uuid) {
 376                     ofpbuf_put(buffer, dp_uuid, OFMP_UUID_LEN);
 377                 } else {
 378                     ofpbuf_put_zeros(buffer, OFMP_UUID_LEN);
 379                 }
 380             }
 381         }
 382     }
 383
 384     /* Put end marker. */
 385     tlv = ofpbuf_put_zeros(buffer, sizeof(*tlv));
 386     tlv->type = htons(OFMPTSR_END);
 387     tlv->len = htons(sizeof(*tlv));
 388     send_openflow_buffer(buffer);
 389 }
 390
 391 static void
 392 send_config_update(uint32_t xid, bool use_xid)
 393 {
 394     struct ofpbuf *buffer;
 395     struct ofmp_config_update *ofmpcu;
 396
 397     if (use_xid) {
 398         ofmpcu = make_ofmp_xid(sizeof *ofmpcu, OFMPT_CONFIG_UPDATE,
 399                 xid, &buffer);
 400     } else {
 401         ofmpcu = make_ofmp(sizeof *ofmpcu, OFMPT_CONFIG_UPDATE, &buffer);
 402     }
 403
 404     ofmpcu->format = htonl(OFMPCOF_SIMPLE);
 405     memcpy(ofmpcu->cookie, cfg_cookie, sizeof(ofmpcu->cookie));
 406     cfg_buf_put(buffer);
 407     send_openflow_buffer(buffer);
 408 }
 409
 410 static void
 411 send_config_update_ack(uint32_t xid, bool success)
 412 {
 413     struct ofpbuf *buffer;
 414     struct ofmp_config_update_ack *ofmpcua;
 415
 416     ofmpcua = make_ofmp_xid(sizeof *ofmpcua, OFMPT_CONFIG_UPDATE_ACK,
 417             xid, &buffer);
 418
 419     ofmpcua->format = htonl(OFMPCOF_SIMPLE);
 420     if (success) {
 421         ofmpcua->flags = htonl(OFMPCUAF_SUCCESS);
 422     }
 423     cfg_get_cookie(ofmpcua->cookie);
 424     send_openflow_buffer(buffer);
 425 }
 426
 427 static void
 428 send_ofmp_error_msg(uint32_t xid, uint16_t type, uint16_t code,
 429             const void *data, size_t len)
 430 {
 431     struct ofpbuf *buffer;
 432     struct ofmp_error_msg *oem;
 433
 434     oem = make_ofmp_xid(sizeof(*oem)+len, OFMPT_ERROR, xid, &buffer);
 435     oem->type = htons(type);
 436     oem->code = htons(code);
 437     memcpy(oem->data, data, len);
 438     send_openflow_buffer(buffer);
 439 }
 440
 441 static void
 442 send_error_msg(uint32_t xid, uint16_t type, uint16_t code,
 443             const void *data, size_t len)
 444 {
 445     struct ofpbuf *buffer;
 446     struct ofp_error_msg *oem;
 447
 448     oem = make_openflow_xid(sizeof(*oem)+len, OFPT_ERROR, xid, &buffer);
 449     oem->type = htons(type);
 450     oem->code = htons(code);
 451     memcpy(oem->data, data, len);
 452     send_openflow_buffer(buffer);
 453 }
 454
 455 static int
 456 recv_echo_request(uint32_t xid UNUSED, const void *msg)
 457 {
 458     const struct ofp_header *rq = msg;
 459     send_openflow_buffer(make_echo_reply(rq));
 460     return 0;
 461 }
 462
 463 static int
 464 recv_features_request(uint32_t xid, const void *msg UNUSED)
 465 {
 466     send_features_reply(xid);
 467     return 0;
 468 }
 469
 470 static int
 471 recv_set_config(uint32_t xid UNUSED, const void *msg UNUSED)
 472 {
 473     /* Nothing to configure! */
 474     return 0;
 475 }
 476
 477 static int
 478 recv_ofmp_capability_request(uint32_t xid, const struct ofmp_header *ofmph)
 479 {
 480     struct ofmp_capability_request *ofmpcr;
 481
 482     if (htons(ofmph->header.header.length) != sizeof(*ofmpcr)) {
 483         /* xxx Send error */
 484         return -EINVAL;
 485     }
 486
 487     ofmpcr = (struct ofmp_capability_request *)ofmph;
 488     if (ofmpcr->format != htonl(OFMPCAF_SIMPLE)) {
 489         /* xxx Send error */
 490         return -EINVAL;
 491     }
 492
 493     send_capability_reply(xid);
 494
 495     return 0;
 496 }
 497
 498 static int
 499 recv_ofmp_resources_request(uint32_t xid, const void *msg UNUSED)
 500 {
 501     send_resources_update(xid, true);
 502     return 0;
 503 }
 504
 505 static int
 506 recv_ofmp_config_request(uint32_t xid, const struct ofmp_header *ofmph)
 507 {
 508     struct ofmp_config_request *ofmpcr;
 509
 510     if (htons(ofmph->header.header.length) != sizeof(*ofmpcr)) {
 511         /* xxx Send error */
 512         return -EINVAL;
 513     }
 514
 515     ofmpcr = (struct ofmp_config_request *)ofmph;
 516     if (ofmpcr->format != htonl(OFMPCOF_SIMPLE)) {
 517         /* xxx Send error */
 518         return -EINVAL;
 519     }
 520
 521     send_config_update(xid, true);
 522
 523     return 0;
 524 }
 525
 526 static int
 527 recv_ofmp_config_update(uint32_t xid, const struct ofmp_header *ofmph)
 528 {
 529     struct ofmp_config_update *ofmpcu;
 530     int data_len;
 531
 532     data_len = htons(ofmph->header.header.length) - sizeof(*ofmpcu);
 533     if (data_len <= sizeof(*ofmpcu)) {
 534         /* xxx Send error. */
 535         return -EINVAL;
 536     }
 537
 538     ofmpcu = (struct ofmp_config_update *)ofmph;
 539     if (ofmpcu->format != htonl(OFMPCOF_SIMPLE)) {
 540         /* xxx Send error */
 541         return -EINVAL;
 542     }
 543
 544     /* Check if the supplied cookie matches our current understanding of
 545      * it.  If they don't match, tell the controller and let it sort
 546      * things out. */
 547     if (cfg_lock(ofmpcu->cookie, 0)) {
 548         /* xxx cfg_lock can fail for other reasons, such as being
 549          * xxx locked... */
 550         VLOG_WARN_RL(&rl, "config update failed due to bad cookie\n");
 551         send_config_update_ack(xid, false);
 552         return 0;
 553     }
 554
 555     /* xxx We should probably do more sanity checking than this. */
 556
 557     cfg_write_data(ofmpcu->data, data_len);
 558     cfg_unlock();
 559
 560     /* Send the ACK before running reconfigure, since our management
 561      * connection settings may have changed. */
 562     send_config_update_ack(xid, true);
 563
 564     reconfigure();
 565
 566
 567     return 0;
 568 }
 569
 570 static
 571 int recv_ofmp(uint32_t xid, struct ofmp_header *ofmph)
 572 {
 573     /* xxx Should sanity-check for min/max length */
 574     switch (ntohs(ofmph->type))
 575     {
 576         case OFMPT_CAPABILITY_REQUEST:
 577             return recv_ofmp_capability_request(xid, ofmph);
 578         case OFMPT_RESOURCES_REQUEST:
 579             return recv_ofmp_resources_request(xid, ofmph);
 580         case OFMPT_CONFIG_REQUEST:
 581             return recv_ofmp_config_request(xid, ofmph);
 582         case OFMPT_CONFIG_UPDATE:
 583             return recv_ofmp_config_update(xid, ofmph);
 584         default:
 585             VLOG_WARN_RL(&rl, "unknown mgmt message: %d",
 586                     ntohs(ofmph->type));
 587             return -EINVAL;
 588     }
 589 }
 590
 591 static int
 592 recv_nx_msg(uint32_t xid, const void *oh)
 593 {
 594     const struct nicira_header *nh = oh;
 595
 596     switch (ntohl(nh->subtype)) {
 597
 598     case NXT_MGMT:
 599         return recv_ofmp(xid, (struct ofmp_header *)oh);
 600
 601     default:
 602         send_error_msg(xid, OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE,
 603                 oh, htons(nh->header.length));
 604         return -EINVAL;
 605     }
 606 }
 607
 608 static int
 609 recv_vendor(uint32_t xid, const void *oh)
 610 {
 611     const struct ofp_vendor_header *ovh = oh;
 612
 613     switch (ntohl(ovh->vendor))
 614     {
 615     case NX_VENDOR_ID:
 616         return recv_nx_msg(xid, oh);
 617
 618     default:
 619         VLOG_WARN_RL(&rl, "unknown vendor: 0x%x", ntohl(ovh->vendor));
 620         send_error_msg(xid, OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR,
 621                 oh, ntohs(ovh->header.length));
 622         return -EINVAL;
 623     }
 624 }
 625
 626 static int
 627 handle_msg(uint32_t xid, const void *msg, size_t length)
 628 {
 629     int (*handler)(uint32_t, const void *);
 630     struct ofp_header *oh;
 631     size_t min_size;
 632
 633     COVERAGE_INC(mgmt_received);
 634
 635     /* Check encapsulated length. */
 636     oh = (struct ofp_header *) msg;
 637     if (ntohs(oh->length) > length) {
 638         return -EINVAL;
 639     }
 640     assert(oh->version == OFP_VERSION);
 641
 642     /* Figure out how to handle it. */
 643     switch (oh->type) {
 644     case OFPT_ECHO_REQUEST:
 645         min_size = sizeof(struct ofp_header);
 646         handler = recv_echo_request;
 647         break;
 648     case OFPT_ECHO_REPLY:
 649         return 0;
 650     case OFPT_FEATURES_REQUEST:
 651         min_size = sizeof(struct ofp_header);
 652         handler = recv_features_request;
 653         break;
 654     case OFPT_SET_CONFIG:
 655         min_size = sizeof(struct ofp_switch_config);
 656         handler = recv_set_config;
 657         break;
 658     case OFPT_VENDOR:
 659         min_size = sizeof(struct ofp_vendor_header);
 660         handler = recv_vendor;
 661         break;
 662     default:
 663         VLOG_WARN_RL(&rl, "unknown openflow type: %d", oh->type);
 664         send_error_msg(xid, OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE,
 665                 msg, length);
 666         return -EINVAL;
 667     }
 668
 669     /* Handle it. */
 670     if (length < min_size) {
 671         return -EFAULT;
 672     }
 673     return handler(xid, msg);
 674 }
 675
 676 void
 677 mgmt_run(void)
 678 {
 679     int i;
 680
 681     if (!mgmt_rconn) {
 682         return;
 683     }
 684
 685     rconn_run(mgmt_rconn);
 686
 687     /* Do some processing, but cap it at a reasonable amount so that
 688      * other processing doesn't starve. */
 689     for (i=0; i<50; i++) {
 690         struct ofpbuf *buffer;
 691         struct ofp_header *oh;
 692
 693         buffer = rconn_recv(mgmt_rconn);
 694         if (!buffer) {
 695             break;
 696         }
 697
 698         if (buffer->size >= sizeof *oh) {
 699             oh = buffer->data;
 700             handle_msg(oh->xid, buffer->data, buffer->size);
 701             ofpbuf_delete(buffer);
 702         } else {
 703             VLOG_WARN_RL(&rl, "received too-short OpenFlow message");
 704         }
 705     }
 706 }
 707
 708 void
 709 mgmt_wait(void)
 710 {
 711     if (!mgmt_rconn) {
 712         return;
 713     }
 714
 715     rconn_run_wait(mgmt_rconn);
 716     rconn_recv_wait(mgmt_rconn);
 717 }
 718
 719 static uint64_t
 720 pick_fallback_mgmt_id(void)
 721 {
 722     uint8_t ea[ETH_ADDR_LEN];
 723     eth_addr_random(ea);
 724     ea[0] = 0x00;               /* Set Nicira OUI. */
 725     ea[1] = 0x23;
 726     ea[2] = 0x20;
 727     return eth_addr_to_uint64(ea);
 728 }