lib/vconn.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 "vconn-provider.h"
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <inttypes.h>
  22 #include <netinet/in.h>
  23 #include <poll.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include "coverage.h"
  27 #include "dynamic-string.h"
  28 #include "flow.h"
  29 #include "ofp-print.h"
  30 #include "ofpbuf.h"
  31 #include "openflow/nicira-ext.h"
  32 #include "openflow/openflow.h"
  33 #include "packets.h"
  34 #include "poll-loop.h"
  35 #include "random.h"
  36 #include "util.h"
  37
  38 #define THIS_MODULE VLM_vconn
  39 #include "vlog.h"
  40
  41 /* State of an active vconn.*/
  42 enum vconn_state {
  43     /* This is the ordinary progression of states. */
  44     VCS_CONNECTING,             /* Underlying vconn is not connected. */
  45     VCS_SEND_HELLO,             /* Waiting to send OFPT_HELLO message. */
  46     VCS_RECV_HELLO,             /* Waiting to receive OFPT_HELLO message. */
  47     VCS_CONNECTED,              /* Connection established. */
  48
  49     /* These states are entered only when something goes wrong. */
  50     VCS_SEND_ERROR,             /* Sending OFPT_ERROR message. */
  51     VCS_DISCONNECTED            /* Connection failed or connection closed. */
  52 };
  53
  54 static struct vconn_class *vconn_classes[] = {
  55     &tcp_vconn_class,
  56     &unix_vconn_class,
  57 #ifdef HAVE_OPENSSL
  58     &ssl_vconn_class,
  59 #endif
  60 };
  61
  62 static struct pvconn_class *pvconn_classes[] = {
  63     &ptcp_pvconn_class,
  64     &punix_pvconn_class,
  65 #ifdef HAVE_OPENSSL
  66     &pssl_pvconn_class,
  67 #endif
  68 };
  69
  70 /* Rate limit for individual OpenFlow messages going over the vconn, output at
  71  * DBG level.  This is very high because, if these are enabled, it is because
  72  * we really need to see them. */
  73 static struct vlog_rate_limit ofmsg_rl = VLOG_RATE_LIMIT_INIT(600, 600);
  74
  75 /* Rate limit for OpenFlow message parse errors.  These always indicate a bug
  76  * in the peer and so there's not much point in showing a lot of them. */
  77 static struct vlog_rate_limit bad_ofmsg_rl = VLOG_RATE_LIMIT_INIT(1, 5);
  78
  79 static int do_recv(struct vconn *, struct ofpbuf **);
  80 static int do_send(struct vconn *, struct ofpbuf *);
  81
  82 /* Check the validity of the vconn class structures. */
  83 static void
  84 check_vconn_classes(void)
  85 {
  86 #ifndef NDEBUG
  87     size_t i;
  88
  89     for (i = 0; i < ARRAY_SIZE(vconn_classes); i++) {
  90         struct vconn_class *class = vconn_classes[i];
  91         assert(class->name != NULL);
  92         assert(class->open != NULL);
  93         if (class->close || class->recv || class->send || class->wait) {
  94             assert(class->close != NULL);
  95             assert(class->recv != NULL);
  96             assert(class->send != NULL);
  97             assert(class->wait != NULL);
  98         } else {
  99             /* This class delegates to another one. */
 100         }
 101     }
 102
 103     for (i = 0; i < ARRAY_SIZE(pvconn_classes); i++) {
 104         struct pvconn_class *class = pvconn_classes[i];
 105         assert(class->name != NULL);
 106         assert(class->listen != NULL);
 107         if (class->close || class->accept || class->wait) {
 108             assert(class->close != NULL);
 109             assert(class->accept != NULL);
 110             assert(class->wait != NULL);
 111         } else {
 112             /* This class delegates to another one. */
 113         }
 114     }
 115 #endif
 116 }
 117
 118 /* Prints information on active (if 'active') and passive (if 'passive')
 119  * connection methods supported by the vconn.  If 'bootstrap' is true, also
 120  * advertises options to bootstrap the CA certificate. */
 121 void
 122 vconn_usage(bool active, bool passive, bool bootstrap UNUSED)
 123 {
 124     /* Really this should be implemented via callbacks into the vconn
 125      * providers, but that seems too heavy-weight to bother with at the
 126      * moment. */
 127
 128     printf("\n");
 129     if (active) {
 130         printf("Active OpenFlow connection methods:\n");
 131         printf("  tcp:IP[:PORT]         "
 132                "PORT (default: %d) at remote IP\n", OFP_TCP_PORT);
 133 #ifdef HAVE_OPENSSL
 134         printf("  ssl:IP[:PORT]         "
 135                "SSL PORT (default: %d) at remote IP\n", OFP_SSL_PORT);
 136 #endif
 137         printf("  unix:FILE               Unix domain socket named FILE\n");
 138     }
 139
 140     if (passive) {
 141         printf("Passive OpenFlow connection methods:\n");
 142         printf("  ptcp:[PORT][:IP]        "
 143                "listen to TCP PORT (default: %d) on IP\n",
 144                OFP_TCP_PORT);
 145 #ifdef HAVE_OPENSSL
 146         printf("  pssl:[PORT][:IP]        "
 147                "listen for SSL on PORT (default: %d) on IP\n",
 148                OFP_SSL_PORT);
 149 #endif
 150         printf("  punix:FILE              "
 151                "listen on Unix domain socket FILE\n");
 152     }
 153
 154 #ifdef HAVE_OPENSSL
 155     printf("PKI configuration (required to use SSL):\n"
 156            "  -p, --private-key=FILE  file with private key\n"
 157            "  -c, --certificate=FILE  file with certificate for private key\n"
 158            "  -C, --ca-cert=FILE      file with peer CA certificate\n");
 159     if (bootstrap) {
 160         printf("  --bootstrap-ca-cert=FILE  file with peer CA certificate "
 161                "to read or create\n");
 162     }
 163 #endif
 164 }
 165
 166 /* Attempts to connect to an OpenFlow device.  'name' is a connection name in
 167  * the form "TYPE:ARGS", where TYPE is an active vconn class's name and ARGS
 168  * are vconn class-specific.
 169  *
 170  * The vconn will automatically negotiate an OpenFlow protocol version
 171  * acceptable to both peers on the connection.  The version negotiated will be
 172  * no lower than 'min_version' and no higher than OFP_VERSION.
 173  *
 174  * Returns 0 if successful, otherwise a positive errno value.  If successful,
 175  * stores a pointer to the new connection in '*vconnp', otherwise a null
 176  * pointer.  */
 177 int
 178 vconn_open(const char *name, int min_version, struct vconn **vconnp)
 179 {
 180     size_t prefix_len;
 181     size_t i;
 182
 183     COVERAGE_INC(vconn_open);
 184     check_vconn_classes();
 185
 186     *vconnp = NULL;
 187     prefix_len = strcspn(name, ":");
 188     if (prefix_len == strlen(name)) {
 189         return EAFNOSUPPORT;
 190     }
 191     for (i = 0; i < ARRAY_SIZE(vconn_classes); i++) {
 192         struct vconn_class *class = vconn_classes[i];
 193         if (strlen(class->name) == prefix_len
 194             && !memcmp(class->name, name, prefix_len)) {
 195             struct vconn *vconn;
 196             char *suffix_copy = xstrdup(name + prefix_len + 1);
 197             int retval = class->open(name, suffix_copy, &vconn);
 198             free(suffix_copy);
 199             if (!retval) {
 200                 assert(vconn->state != VCS_CONNECTING
 201                        || vconn->class->connect);
 202                 vconn->min_version = min_version;
 203                 *vconnp = vconn;
 204             }
 205             return retval;
 206         }
 207     }
 208     return EAFNOSUPPORT;
 209 }
 210
 211 int
 212 vconn_open_block(const char *name, int min_version, struct vconn **vconnp)
 213 {
 214     struct vconn *vconn;
 215     int error;
 216
 217     error = vconn_open(name, min_version, &vconn);
 218     while (error == EAGAIN) {
 219         vconn_connect_wait(vconn);
 220         poll_block();
 221         error = vconn_connect(vconn);
 222         assert(error != EINPROGRESS);
 223     }
 224     if (error) {
 225         vconn_close(vconn);
 226         *vconnp = NULL;
 227     } else {
 228         *vconnp = vconn;
 229     }
 230     return error;
 231 }
 232
 233 /* Closes 'vconn'. */
 234 void
 235 vconn_close(struct vconn *vconn)
 236 {
 237     if (vconn != NULL) {
 238         char *name = vconn->name;
 239         (vconn->class->close)(vconn);
 240         free(name);
 241     }
 242 }
 243
 244 /* Returns the name of 'vconn', that is, the string passed to vconn_open(). */
 245 const char *
 246 vconn_get_name(const struct vconn *vconn)
 247 {
 248     return vconn->name;
 249 }
 250
 251 /* Returns the IP address of the peer, or 0 if the peer is not connected over
 252  * an IP-based protocol or if its IP address is not yet known. */
 253 uint32_t
 254 vconn_get_remote_ip(const struct vconn *vconn)
 255 {
 256     return vconn->remote_ip;
 257 }
 258
 259 /* Returns the transport port of the peer, or 0 if the connection does not
 260  * contain a port or if the port is not yet known. */
 261 uint16_t
 262 vconn_get_remote_port(const struct vconn *vconn)
 263 {
 264     return vconn->remote_port;
 265 }
 266
 267 /* Returns the IP address used to connect to the peer, or 0 if the
 268  * connection is not an IP-based protocol or if its IP address is not
 269  * yet known. */
 270 uint32_t
 271 vconn_get_local_ip(const struct vconn *vconn)
 272 {
 273     return vconn->local_ip;
 274 }
 275
 276 /* Returns the transport port used to connect to the peer, or 0 if the
 277  * connection does not contain a port or if the port is not yet known. */
 278 uint16_t
 279 vconn_get_local_port(const struct vconn *vconn)
 280 {
 281     return vconn->local_port;
 282 }
 283
 284 static void
 285 vcs_connecting(struct vconn *vconn)
 286 {
 287     int retval = (vconn->class->connect)(vconn);
 288     assert(retval != EINPROGRESS);
 289     if (!retval) {
 290         vconn->state = VCS_SEND_HELLO;
 291     } else if (retval != EAGAIN) {
 292         vconn->state = VCS_DISCONNECTED;
 293         vconn->error = retval;
 294     }
 295 }
 296
 297 static void
 298 vcs_send_hello(struct vconn *vconn)
 299 {
 300     struct ofpbuf *b;
 301     int retval;
 302
 303     make_openflow(sizeof(struct ofp_header), OFPT_HELLO, &b);
 304     retval = do_send(vconn, b);
 305     if (!retval) {
 306         vconn->state = VCS_RECV_HELLO;
 307     } else {
 308         ofpbuf_delete(b);
 309         if (retval != EAGAIN) {
 310             vconn->state = VCS_DISCONNECTED;
 311             vconn->error = retval;
 312         }
 313     }
 314 }
 315
 316 static void
 317 vcs_recv_hello(struct vconn *vconn)
 318 {
 319     struct ofpbuf *b;
 320     int retval;
 321
 322     retval = do_recv(vconn, &b);
 323     if (!retval) {
 324         struct ofp_header *oh = b->data;
 325
 326         if (oh->type == OFPT_HELLO) {
 327             if (b->size > sizeof *oh) {
 328                 struct ds msg = DS_EMPTY_INITIALIZER;
 329                 ds_put_format(&msg, "%s: extra-long hello:\n", vconn->name);
 330                 ds_put_hex_dump(&msg, b->data, b->size, 0, true);
 331                 VLOG_WARN_RL(&bad_ofmsg_rl, "%s", ds_cstr(&msg));
 332                 ds_destroy(&msg);
 333             }
 334
 335             vconn->version = MIN(OFP_VERSION, oh->version);
 336             if (vconn->version < vconn->min_version) {
 337                 VLOG_WARN_RL(&bad_ofmsg_rl,
 338                              "%s: version negotiation failed: we support "
 339                              "versions 0x%02x to 0x%02x inclusive but peer "
 340                              "supports no later than version 0x%02"PRIx8,
 341                              vconn->name, vconn->min_version, OFP_VERSION,
 342                              oh->version);
 343                 vconn->state = VCS_SEND_ERROR;
 344             } else {
 345                 VLOG_DBG("%s: negotiated OpenFlow version 0x%02x "
 346                          "(we support versions 0x%02x to 0x%02x inclusive, "
 347                          "peer no later than version 0x%02"PRIx8")",
 348                          vconn->name, vconn->version, vconn->min_version,
 349                          OFP_VERSION, oh->version);
 350                 vconn->state = VCS_CONNECTED;
 351             }
 352             ofpbuf_delete(b);
 353             return;
 354         } else {
 355             char *s = ofp_to_string(b->data, b->size, 1);
 356             VLOG_WARN_RL(&bad_ofmsg_rl,
 357                          "%s: received message while expecting hello: %s",
 358                          vconn->name, s);
 359             free(s);
 360             retval = EPROTO;
 361             ofpbuf_delete(b);
 362         }
 363     }
 364
 365     if (retval != EAGAIN) {
 366         vconn->state = VCS_DISCONNECTED;
 367         vconn->error = retval == EOF ? ECONNRESET : retval;
 368     }
 369 }
 370
 371 static void
 372 vcs_send_error(struct vconn *vconn)
 373 {
 374     struct ofp_error_msg *error;
 375     struct ofpbuf *b;
 376     char s[128];
 377     int retval;
 378
 379     snprintf(s, sizeof s, "We support versions 0x%02x to 0x%02x inclusive but "
 380              "you support no later than version 0x%02"PRIx8".",
 381              vconn->min_version, OFP_VERSION, vconn->version);
 382     error = make_openflow(sizeof *error, OFPT_ERROR, &b);
 383     error->type = htons(OFPET_HELLO_FAILED);
 384     error->code = htons(OFPHFC_INCOMPATIBLE);
 385     ofpbuf_put(b, s, strlen(s));
 386     update_openflow_length(b);
 387     retval = do_send(vconn, b);
 388     if (retval) {
 389         ofpbuf_delete(b);
 390     }
 391     if (retval != EAGAIN) {
 392         vconn->state = VCS_DISCONNECTED;
 393         vconn->error = retval ? retval : EPROTO;
 394     }
 395 }
 396
 397 /* Tries to complete the connection on 'vconn', which must be an active
 398  * vconn.  If 'vconn''s connection is complete, returns 0 if the connection
 399  * was successful or a positive errno value if it failed.  If the
 400  * connection is still in progress, returns EAGAIN. */
 401 int
 402 vconn_connect(struct vconn *vconn)
 403 {
 404     enum vconn_state last_state;
 405
 406     assert(vconn->min_version >= 0);
 407     do {
 408         last_state = vconn->state;
 409         switch (vconn->state) {
 410         case VCS_CONNECTING:
 411             vcs_connecting(vconn);
 412             break;
 413
 414         case VCS_SEND_HELLO:
 415             vcs_send_hello(vconn);
 416             break;
 417
 418         case VCS_RECV_HELLO:
 419             vcs_recv_hello(vconn);
 420             break;
 421
 422         case VCS_CONNECTED:
 423             return 0;
 424
 425         case VCS_SEND_ERROR:
 426             vcs_send_error(vconn);
 427             break;
 428
 429         case VCS_DISCONNECTED:
 430             return vconn->error;
 431
 432         default:
 433             NOT_REACHED();
 434         }
 435     } while (vconn->state != last_state);
 436
 437     return EAGAIN;
 438 }
 439
 440 /* Tries to receive an OpenFlow message from 'vconn', which must be an active
 441  * vconn.  If successful, stores the received message into '*msgp' and returns
 442  * 0.  The caller is responsible for destroying the message with
 443  * ofpbuf_delete().  On failure, returns a positive errno value and stores a
 444  * null pointer into '*msgp'.  On normal connection close, returns EOF.
 445  *
 446  * vconn_recv will not block waiting for a packet to arrive.  If no packets
 447  * have been received, it returns EAGAIN immediately. */
 448 int
 449 vconn_recv(struct vconn *vconn, struct ofpbuf **msgp)
 450 {
 451     int retval = vconn_connect(vconn);
 452     if (!retval) {
 453         retval = do_recv(vconn, msgp);
 454     }
 455     return retval;
 456 }
 457
 458 static int
 459 do_recv(struct vconn *vconn, struct ofpbuf **msgp)
 460 {
 461     int retval = (vconn->class->recv)(vconn, msgp);
 462     if (!retval) {
 463         struct ofp_header *oh;
 464
 465         COVERAGE_INC(vconn_received);
 466         if (VLOG_IS_DBG_ENABLED()) {
 467             char *s = ofp_to_string((*msgp)->data, (*msgp)->size, 1);
 468             VLOG_DBG_RL(&ofmsg_rl, "%s: received: %s", vconn->name, s);
 469             free(s);
 470         }
 471
 472         oh = ofpbuf_at_assert(*msgp, 0, sizeof *oh);
 473         if (oh->version != vconn->version
 474             && oh->type != OFPT_HELLO
 475             && oh->type != OFPT_ERROR
 476             && oh->type != OFPT_ECHO_REQUEST
 477             && oh->type != OFPT_ECHO_REPLY
 478             && oh->type != OFPT_VENDOR)
 479         {
 480             if (vconn->version < 0) {
 481                 VLOG_ERR_RL(&bad_ofmsg_rl,
 482                             "%s: received OpenFlow message type %"PRIu8" "
 483                             "before version negotiation complete",
 484                             vconn->name, oh->type);
 485             } else {
 486                 VLOG_ERR_RL(&bad_ofmsg_rl,
 487                             "%s: received OpenFlow version 0x%02"PRIx8" "
 488                             "!= expected %02x",
 489                             vconn->name, oh->version, vconn->version);
 490             }
 491             ofpbuf_delete(*msgp);
 492             retval = EPROTO;
 493         }
 494     }
 495     if (retval) {
 496         *msgp = NULL;
 497     }
 498     return retval;
 499 }
 500
 501 /* Tries to queue 'msg' for transmission on 'vconn', which must be an active
 502  * vconn.  If successful, returns 0, in which case ownership of 'msg' is
 503  * transferred to the vconn.  Success does not guarantee that 'msg' has been or
 504  * ever will be delivered to the peer, only that it has been queued for
 505  * transmission.
 506  *
 507  * Returns a positive errno value on failure, in which case the caller
 508  * retains ownership of 'msg'.
 509  *
 510  * vconn_send will not block.  If 'msg' cannot be immediately accepted for
 511  * transmission, it returns EAGAIN immediately. */
 512 int
 513 vconn_send(struct vconn *vconn, struct ofpbuf *msg)
 514 {
 515     int retval = vconn_connect(vconn);
 516     if (!retval) {
 517         retval = do_send(vconn, msg);
 518     }
 519     return retval;
 520 }
 521
 522 static int
 523 do_send(struct vconn *vconn, struct ofpbuf *msg)
 524 {
 525     int retval;
 526
 527     assert(msg->size >= sizeof(struct ofp_header));
 528     assert(((struct ofp_header *) msg->data)->length == htons(msg->size));
 529     if (!VLOG_IS_DBG_ENABLED()) {
 530         COVERAGE_INC(vconn_sent);
 531         retval = (vconn->class->send)(vconn, msg);
 532     } else {
 533         char *s = ofp_to_string(msg->data, msg->size, 1);
 534         retval = (vconn->class->send)(vconn, msg);
 535         if (retval != EAGAIN) {
 536             VLOG_DBG_RL(&ofmsg_rl, "%s: sent (%s): %s",
 537                         vconn->name, strerror(retval), s);
 538         }
 539         free(s);
 540     }
 541     return retval;
 542 }
 543
 544 /* Same as vconn_send, except that it waits until 'msg' can be transmitted. */
 545 int
 546 vconn_send_block(struct vconn *vconn, struct ofpbuf *msg)
 547 {
 548     int retval;
 549     while ((retval = vconn_send(vconn, msg)) == EAGAIN) {
 550         vconn_send_wait(vconn);
 551         poll_block();
 552     }
 553     return retval;
 554 }
 555
 556 /* Same as vconn_recv, except that it waits until a message is received. */
 557 int
 558 vconn_recv_block(struct vconn *vconn, struct ofpbuf **msgp)
 559 {
 560     int retval;
 561     while ((retval = vconn_recv(vconn, msgp)) == EAGAIN) {
 562         vconn_recv_wait(vconn);
 563         poll_block();
 564     }
 565     return retval;
 566 }
 567
 568 /* Waits until a message with a transaction ID matching 'xid' is recived on
 569  * 'vconn'.  Returns 0 if successful, in which case the reply is stored in
 570  * '*replyp' for the caller to examine and free.  Otherwise returns a positive
 571  * errno value, or EOF, and sets '*replyp' to null.
 572  *
 573  * 'request' is always destroyed, regardless of the return value. */
 574 int
 575 vconn_recv_xid(struct vconn *vconn, uint32_t xid, struct ofpbuf **replyp)
 576 {
 577     for (;;) {
 578         uint32_t recv_xid;
 579         struct ofpbuf *reply;
 580         int error;
 581
 582         error = vconn_recv_block(vconn, &reply);
 583         if (error) {
 584             *replyp = NULL;
 585             return error;
 586         }
 587         recv_xid = ((struct ofp_header *) reply->data)->xid;
 588         if (xid == recv_xid) {
 589             *replyp = reply;
 590             return 0;
 591         }
 592
 593         VLOG_DBG_RL(&bad_ofmsg_rl, "%s: received reply with xid %08"PRIx32
 594                     " != expected %08"PRIx32, vconn->name, recv_xid, xid);
 595         ofpbuf_delete(reply);
 596     }
 597 }
 598
 599 /* Sends 'request' to 'vconn' and blocks until it receives a reply with a
 600  * matching transaction ID.  Returns 0 if successful, in which case the reply
 601  * is stored in '*replyp' for the caller to examine and free.  Otherwise
 602  * returns a positive errno value, or EOF, and sets '*replyp' to null.
 603  *
 604  * 'request' is always destroyed, regardless of the return value. */
 605 int
 606 vconn_transact(struct vconn *vconn, struct ofpbuf *request,
 607                struct ofpbuf **replyp)
 608 {
 609     uint32_t send_xid = ((struct ofp_header *) request->data)->xid;
 610     int error;
 611
 612     *replyp = NULL;
 613     error = vconn_send_block(vconn, request);
 614     if (error) {
 615         ofpbuf_delete(request);
 616     }
 617     return error ? error : vconn_recv_xid(vconn, send_xid, replyp);
 618 }
 619
 620 void
 621 vconn_wait(struct vconn *vconn, enum vconn_wait_type wait)
 622 {
 623     assert(wait == WAIT_CONNECT || wait == WAIT_RECV || wait == WAIT_SEND);
 624
 625     switch (vconn->state) {
 626     case VCS_CONNECTING:
 627         wait = WAIT_CONNECT;
 628         break;
 629
 630     case VCS_SEND_HELLO:
 631     case VCS_SEND_ERROR:
 632         wait = WAIT_SEND;
 633         break;
 634
 635     case VCS_RECV_HELLO:
 636         wait = WAIT_RECV;
 637         break;
 638
 639     case VCS_CONNECTED:
 640         break;
 641
 642     case VCS_DISCONNECTED:
 643         poll_immediate_wake();
 644         return;
 645     }
 646     (vconn->class->wait)(vconn, wait);
 647 }
 648
 649 void
 650 vconn_connect_wait(struct vconn *vconn)
 651 {
 652     vconn_wait(vconn, WAIT_CONNECT);
 653 }
 654
 655 void
 656 vconn_recv_wait(struct vconn *vconn)
 657 {
 658     vconn_wait(vconn, WAIT_RECV);
 659 }
 660
 661 void
 662 vconn_send_wait(struct vconn *vconn)
 663 {
 664     vconn_wait(vconn, WAIT_SEND);
 665 }
 666
 667 /* Attempts to start listening for OpenFlow connections.  'name' is a
 668  * connection name in the form "TYPE:ARGS", where TYPE is an passive vconn
 669  * class's name and ARGS are vconn class-specific.
 670  *
 671  * Returns 0 if successful, otherwise a positive errno value.  If successful,
 672  * stores a pointer to the new connection in '*pvconnp', otherwise a null
 673  * pointer.  */
 674 int
 675 pvconn_open(const char *name, struct pvconn **pvconnp)
 676 {
 677     size_t prefix_len;
 678     size_t i;
 679
 680     check_vconn_classes();
 681
 682     *pvconnp = NULL;
 683     prefix_len = strcspn(name, ":");
 684     if (prefix_len == strlen(name)) {
 685         return EAFNOSUPPORT;
 686     }
 687     for (i = 0; i < ARRAY_SIZE(pvconn_classes); i++) {
 688         struct pvconn_class *class = pvconn_classes[i];
 689         if (strlen(class->name) == prefix_len
 690             && !memcmp(class->name, name, prefix_len)) {
 691             char *suffix_copy = xstrdup(name + prefix_len + 1);
 692             int retval = class->listen(name, suffix_copy, pvconnp);
 693             free(suffix_copy);
 694             if (retval) {
 695                 *pvconnp = NULL;
 696             }
 697             return retval;
 698         }
 699     }
 700     return EAFNOSUPPORT;
 701 }
 702
 703 /* Returns the name that was used to open 'pvconn'.  The caller must not
 704  * modify or free the name. */
 705 const char *
 706 pvconn_get_name(const struct pvconn *pvconn)
 707 {
 708     return pvconn->name;
 709 }
 710
 711 /* Closes 'pvconn'. */
 712 void
 713 pvconn_close(struct pvconn *pvconn)
 714 {
 715     if (pvconn != NULL) {
 716         char *name = pvconn->name;
 717         (pvconn->class->close)(pvconn);
 718         free(name);
 719     }
 720 }
 721
 722 /* Tries to accept a new connection on 'pvconn'.  If successful, stores the new
 723  * connection in '*new_vconn' and returns 0.  Otherwise, returns a positive
 724  * errno value.
 725  *
 726  * The new vconn will automatically negotiate an OpenFlow protocol version
 727  * acceptable to both peers on the connection.  The version negotiated will be
 728  * no lower than 'min_version' and no higher than OFP_VERSION.
 729  *
 730  * pvconn_accept() will not block waiting for a connection.  If no connection
 731  * is ready to be accepted, it returns EAGAIN immediately. */
 732 int
 733 pvconn_accept(struct pvconn *pvconn, int min_version, struct vconn **new_vconn)
 734 {
 735     int retval = (pvconn->class->accept)(pvconn, new_vconn);
 736     if (retval) {
 737         *new_vconn = NULL;
 738     } else {
 739         assert((*new_vconn)->state != VCS_CONNECTING
 740                || (*new_vconn)->class->connect);
 741         (*new_vconn)->min_version = min_version;
 742     }
 743     return retval;
 744 }
 745
 746 void
 747 pvconn_wait(struct pvconn *pvconn)
 748 {
 749     (pvconn->class->wait)(pvconn);
 750 }
 751
 752 /* XXX we should really use consecutive xids to avoid probabilistic
 753  * failures. */
 754 static inline uint32_t
 755 alloc_xid(void)
 756 {
 757     return random_uint32();
 758 }
 759
 760 /* Allocates and stores in '*bufferp' a new ofpbuf with a size of
 761  * 'openflow_len', starting with an OpenFlow header with the given 'type' and
 762  * an arbitrary transaction id.  Allocated bytes beyond the header, if any, are
 763  * zeroed.
 764  *
 765  * The caller is responsible for freeing '*bufferp' when it is no longer
 766  * needed.
 767  *
 768  * The OpenFlow header length is initially set to 'openflow_len'; if the
 769  * message is later extended, the length should be updated with
 770  * update_openflow_length() before sending.
 771  *
 772  * Returns the header. */
 773 void *
 774 make_openflow(size_t openflow_len, uint8_t type, struct ofpbuf **bufferp)
 775 {
 776     *bufferp = ofpbuf_new(openflow_len);
 777     return put_openflow_xid(openflow_len, type, alloc_xid(), *bufferp);
 778 }
 779
 780 /* Allocates and stores in '*bufferp' a new ofpbuf with a size of
 781  * 'openflow_len', starting with an OpenFlow header with the given 'type' and
 782  * transaction id 'xid'.  Allocated bytes beyond the header, if any, are
 783  * zeroed.
 784  *
 785  * The caller is responsible for freeing '*bufferp' when it is no longer
 786  * needed.
 787  *
 788  * The OpenFlow header length is initially set to 'openflow_len'; if the
 789  * message is later extended, the length should be updated with
 790  * update_openflow_length() before sending.
 791  *
 792  * Returns the header. */
 793 void *
 794 make_openflow_xid(size_t openflow_len, uint8_t type, uint32_t xid,
 795                   struct ofpbuf **bufferp)
 796 {
 797     *bufferp = ofpbuf_new(openflow_len);
 798     return put_openflow_xid(openflow_len, type, xid, *bufferp);
 799 }
 800
 801 /* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
 802  * with the given 'type' and an arbitrary transaction id.  Allocated bytes
 803  * beyond the header, if any, are zeroed.
 804  *
 805  * The OpenFlow header length is initially set to 'openflow_len'; if the
 806  * message is later extended, the length should be updated with
 807  * update_openflow_length() before sending.
 808  *
 809  * Returns the header. */
 810 void *
 811 put_openflow(size_t openflow_len, uint8_t type, struct ofpbuf *buffer)
 812 {
 813     return put_openflow_xid(openflow_len, type, alloc_xid(), buffer);
 814 }
 815
 816 /* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
 817  * with the given 'type' and an transaction id 'xid'.  Allocated bytes beyond
 818  * the header, if any, are zeroed.
 819  *
 820  * The OpenFlow header length is initially set to 'openflow_len'; if the
 821  * message is later extended, the length should be updated with
 822  * update_openflow_length() before sending.
 823  *
 824  * Returns the header. */
 825 void *
 826 put_openflow_xid(size_t openflow_len, uint8_t type, uint32_t xid,
 827                  struct ofpbuf *buffer)
 828 {
 829     struct ofp_header *oh;
 830
 831     assert(openflow_len >= sizeof *oh);
 832     assert(openflow_len <= UINT16_MAX);
 833
 834     oh = ofpbuf_put_uninit(buffer, openflow_len);
 835     oh->version = OFP_VERSION;
 836     oh->type = type;
 837     oh->length = htons(openflow_len);
 838     oh->xid = xid;
 839     memset(oh + 1, 0, openflow_len - sizeof *oh);
 840     return oh;
 841 }
 842
 843 /* Updates the 'length' field of the OpenFlow message in 'buffer' to
 844  * 'buffer->size'. */
 845 void
 846 update_openflow_length(struct ofpbuf *buffer)
 847 {
 848     struct ofp_header *oh = ofpbuf_at_assert(buffer, 0, sizeof *oh);
 849     oh->length = htons(buffer->size);
 850 }
 851
 852 struct ofpbuf *
 853 make_flow_mod(uint16_t command, const flow_t *flow, size_t actions_len)
 854 {
 855     struct ofp_flow_mod *ofm;
 856     size_t size = sizeof *ofm + actions_len;
 857     struct ofpbuf *out = ofpbuf_new(size);
 858     ofm = ofpbuf_put_zeros(out, sizeof *ofm);
 859     ofm->header.version = OFP_VERSION;
 860     ofm->header.type = OFPT_FLOW_MOD;
 861     ofm->header.length = htons(size);
 862     ofm->cookie = 0;
 863     ofm->match.wildcards = htonl(0);
 864     ofm->match.in_port = htons(flow->in_port == ODPP_LOCAL ? OFPP_LOCAL
 865                                : flow->in_port);
 866     memcpy(ofm->match.dl_src, flow->dl_src, sizeof ofm->match.dl_src);
 867     memcpy(ofm->match.dl_dst, flow->dl_dst, sizeof ofm->match.dl_dst);
 868     ofm->match.dl_vlan = flow->dl_vlan;
 869     ofm->match.dl_vlan_pcp = flow->dl_vlan_pcp;
 870     ofm->match.dl_type = flow->dl_type;
 871     ofm->match.nw_src = flow->nw_src;
 872     ofm->match.nw_dst = flow->nw_dst;
 873     ofm->match.nw_proto = flow->nw_proto;
 874     ofm->match.tp_src = flow->tp_src;
 875     ofm->match.tp_dst = flow->tp_dst;
 876     ofm->command = htons(command);
 877     return out;
 878 }
 879
 880 struct ofpbuf *
 881 make_add_flow(const flow_t *flow, uint32_t buffer_id,
 882               uint16_t idle_timeout, size_t actions_len)
 883 {
 884     struct ofpbuf *out = make_flow_mod(OFPFC_ADD, flow, actions_len);
 885     struct ofp_flow_mod *ofm = out->data;
 886     ofm->idle_timeout = htons(idle_timeout);
 887     ofm->hard_timeout = htons(OFP_FLOW_PERMANENT);
 888     ofm->buffer_id = htonl(buffer_id);
 889     return out;
 890 }
 891
 892 struct ofpbuf *
 893 make_del_flow(const flow_t *flow)
 894 {
 895     struct ofpbuf *out = make_flow_mod(OFPFC_DELETE_STRICT, flow, 0);
 896     struct ofp_flow_mod *ofm = out->data;
 897     ofm->out_port = htons(OFPP_NONE);
 898     return out;
 899 }
 900
 901 struct ofpbuf *
 902 make_add_simple_flow(const flow_t *flow,
 903                      uint32_t buffer_id, uint16_t out_port,
 904                      uint16_t idle_timeout)
 905 {
 906     struct ofp_action_output *oao;
 907     struct ofpbuf *buffer = make_add_flow(flow, buffer_id, idle_timeout,
 908                                           sizeof *oao);
 909     oao = ofpbuf_put_zeros(buffer, sizeof *oao);
 910     oao->type = htons(OFPAT_OUTPUT);
 911     oao->len = htons(sizeof *oao);
 912     oao->port = htons(out_port);
 913     return buffer;
 914 }
 915
 916 struct ofpbuf *
 917 make_packet_in(uint32_t buffer_id, uint16_t in_port, uint8_t reason,
 918                const struct ofpbuf *payload, int max_send_len)
 919 {
 920     struct ofp_packet_in *opi;
 921     struct ofpbuf *buf;
 922     int send_len;
 923
 924     send_len = MIN(max_send_len, payload->size);
 925     buf = ofpbuf_new(sizeof *opi + send_len);
 926     opi = put_openflow_xid(offsetof(struct ofp_packet_in, data),
 927                            OFPT_PACKET_IN, 0, buf);
 928     opi->buffer_id = htonl(buffer_id);
 929     opi->total_len = htons(payload->size);
 930     opi->in_port = htons(in_port);
 931     opi->reason = reason;
 932     ofpbuf_put(buf, payload->data, send_len);
 933     update_openflow_length(buf);
 934
 935     return buf;
 936 }
 937
 938 struct ofpbuf *
 939 make_packet_out(const struct ofpbuf *packet, uint32_t buffer_id,
 940                 uint16_t in_port,
 941                 const struct ofp_action_header *actions, size_t n_actions)
 942 {
 943     size_t actions_len = n_actions * sizeof *actions;
 944     struct ofp_packet_out *opo;
 945     size_t size = sizeof *opo + actions_len + (packet ? packet->size : 0);
 946     struct ofpbuf *out = ofpbuf_new(size);
 947
 948     opo = ofpbuf_put_uninit(out, sizeof *opo);
 949     opo->header.version = OFP_VERSION;
 950     opo->header.type = OFPT_PACKET_OUT;
 951     opo->header.length = htons(size);
 952     opo->header.xid = htonl(0);
 953     opo->buffer_id = htonl(buffer_id);
 954     opo->in_port = htons(in_port == ODPP_LOCAL ? OFPP_LOCAL : in_port);
 955     opo->actions_len = htons(actions_len);
 956     ofpbuf_put(out, actions, actions_len);
 957     if (packet) {
 958         ofpbuf_put(out, packet->data, packet->size);
 959     }
 960     return out;
 961 }
 962
 963 struct ofpbuf *
 964 make_unbuffered_packet_out(const struct ofpbuf *packet,
 965                            uint16_t in_port, uint16_t out_port)
 966 {
 967     struct ofp_action_output action;
 968     action.type = htons(OFPAT_OUTPUT);
 969     action.len = htons(sizeof action);
 970     action.port = htons(out_port);
 971     return make_packet_out(packet, UINT32_MAX, in_port,
 972                            (struct ofp_action_header *) &action, 1);
 973 }
 974
 975 struct ofpbuf *
 976 make_buffered_packet_out(uint32_t buffer_id,
 977                          uint16_t in_port, uint16_t out_port)
 978 {
 979     struct ofp_action_output action;
 980     action.type = htons(OFPAT_OUTPUT);
 981     action.len = htons(sizeof action);
 982     action.port = htons(out_port);
 983     return make_packet_out(NULL, buffer_id, in_port,
 984                            (struct ofp_action_header *) &action, 1);
 985 }
 986
 987 /* Creates and returns an OFPT_ECHO_REQUEST message with an empty payload. */
 988 struct ofpbuf *
 989 make_echo_request(void)
 990 {
 991     struct ofp_header *rq;
 992     struct ofpbuf *out = ofpbuf_new(sizeof *rq);
 993     rq = ofpbuf_put_uninit(out, sizeof *rq);
 994     rq->version = OFP_VERSION;
 995     rq->type = OFPT_ECHO_REQUEST;
 996     rq->length = htons(sizeof *rq);
 997     rq->xid = 0;
 998     return out;
 999 }
1000
1001 /* Creates and returns an OFPT_ECHO_REPLY message matching the
1002  * OFPT_ECHO_REQUEST message in 'rq'. */
1003 struct ofpbuf *
1004 make_echo_reply(const struct ofp_header *rq)
1005 {
1006     size_t size = ntohs(rq->length);
1007     struct ofpbuf *out = ofpbuf_new(size);
1008     struct ofp_header *reply = ofpbuf_put(out, rq, size);
1009     reply->type = OFPT_ECHO_REPLY;
1010     return out;
1011 }
1012
1013 static int
1014 check_message_type(uint8_t got_type, uint8_t want_type)
1015 {
1016     if (got_type != want_type) {
1017         char *want_type_name = ofp_message_type_to_string(want_type);
1018         char *got_type_name = ofp_message_type_to_string(got_type);
1019         VLOG_WARN_RL(&bad_ofmsg_rl,
1020                      "received bad message type %s (expected %s)",
1021                      got_type_name, want_type_name);
1022         free(want_type_name);
1023         free(got_type_name);
1024         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE);
1025     }
1026     return 0;
1027 }
1028
1029 /* Checks that 'msg' has type 'type' and that it is exactly 'size' bytes long.
1030  * Returns 0 if the checks pass, otherwise an OpenFlow error code (produced
1031  * with ofp_mkerr()). */
1032 int
1033 check_ofp_message(const struct ofp_header *msg, uint8_t type, size_t size)
1034 {
1035     size_t got_size;
1036     int error;
1037
1038     error = check_message_type(msg->type, type);
1039     if (error) {
1040         return error;
1041     }
1042
1043     got_size = ntohs(msg->length);
1044     if (got_size != size) {
1045         char *type_name = ofp_message_type_to_string(type);
1046         VLOG_WARN_RL(&bad_ofmsg_rl,
1047                      "received %s message of length %zu (expected %zu)",
1048                      type_name, got_size, size);
1049         free(type_name);
1050         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
1051     }
1052
1053     return 0;
1054 }
1055
1056 /* Checks that 'msg' has type 'type' and that 'msg' is 'size' plus a
1057  * nonnegative integer multiple of 'array_elt_size' bytes long.  Returns 0 if
1058  * the checks pass, otherwise an OpenFlow error code (produced with
1059  * ofp_mkerr()).
1060  *
1061  * If 'n_array_elts' is nonnull, then '*n_array_elts' is set to the number of
1062  * 'array_elt_size' blocks in 'msg' past the first 'min_size' bytes, when
1063  * successful. */
1064 int
1065 check_ofp_message_array(const struct ofp_header *msg, uint8_t type,
1066                         size_t min_size, size_t array_elt_size,
1067                         size_t *n_array_elts)
1068 {
1069     size_t got_size;
1070     int error;
1071
1072     assert(array_elt_size);
1073
1074     error = check_message_type(msg->type, type);
1075     if (error) {
1076         return error;
1077     }
1078
1079     got_size = ntohs(msg->length);
1080     if (got_size < min_size) {
1081         char *type_name = ofp_message_type_to_string(type);
1082         VLOG_WARN_RL(&bad_ofmsg_rl, "received %s message of length %zu "
1083                      "(expected at least %zu)",
1084                      type_name, got_size, min_size);
1085         free(type_name);
1086         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
1087     }
1088     if ((got_size - min_size) % array_elt_size) {
1089         char *type_name = ofp_message_type_to_string(type);
1090         VLOG_WARN_RL(&bad_ofmsg_rl,
1091                      "received %s message of bad length %zu: the "
1092                      "excess over %zu (%zu) is not evenly divisible by %zu "
1093                      "(remainder is %zu)",
1094                      type_name, got_size, min_size, got_size - min_size,
1095                      array_elt_size, (got_size - min_size) % array_elt_size);
1096         free(type_name);
1097         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
1098     }
1099     if (n_array_elts) {
1100         *n_array_elts = (got_size - min_size) / array_elt_size;
1101     }
1102     return 0;
1103 }
1104
1105 int
1106 check_ofp_packet_out(const struct ofp_header *oh, struct ofpbuf *data,
1107                      int *n_actionsp, int max_ports)
1108 {
1109     const struct ofp_packet_out *opo;
1110     unsigned int actions_len, n_actions;
1111     size_t extra;
1112     int error;
1113
1114     *n_actionsp = 0;
1115     error = check_ofp_message_array(oh, OFPT_PACKET_OUT,
1116                                     sizeof *opo, 1, &extra);
1117     if (error) {
1118         return error;
1119     }
1120     opo = (const struct ofp_packet_out *) oh;
1121
1122     actions_len = ntohs(opo->actions_len);
1123     if (actions_len > extra) {
1124         VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out claims %u bytes of actions "
1125                      "but message has room for only %zu bytes",
1126                      actions_len, extra);
1127         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
1128     }
1129     if (actions_len % sizeof(union ofp_action)) {
1130         VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out claims %u bytes of actions, "
1131                      "which is not a multiple of %zu",
1132                      actions_len, sizeof(union ofp_action));
1133         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
1134     }
1135
1136     n_actions = actions_len / sizeof(union ofp_action);
1137     error = validate_actions((const union ofp_action *) opo->actions,
1138                              n_actions, max_ports);
1139     if (error) {
1140         return error;
1141     }
1142
1143     data->data = (void *) &opo->actions[n_actions];
1144     data->size = extra - actions_len;
1145     *n_actionsp = n_actions;
1146     return 0;
1147 }
1148
1149 const struct ofp_flow_stats *
1150 flow_stats_first(struct flow_stats_iterator *iter,
1151                  const struct ofp_stats_reply *osr)
1152 {
1153     iter->pos = osr->body;
1154     iter->end = osr->body + (ntohs(osr->header.length)
1155                              - offsetof(struct ofp_stats_reply, body));
1156     return flow_stats_next(iter);
1157 }
1158
1159 const struct ofp_flow_stats *
1160 flow_stats_next(struct flow_stats_iterator *iter)
1161 {
1162     ptrdiff_t bytes_left = iter->end - iter->pos;
1163     const struct ofp_flow_stats *fs;
1164     size_t length;
1165
1166     if (bytes_left < sizeof *fs) {
1167         if (bytes_left != 0) {
1168             VLOG_WARN_RL(&bad_ofmsg_rl,
1169                          "%td leftover bytes in flow stats reply", bytes_left);
1170         }
1171         return NULL;
1172     }
1173
1174     fs = (const void *) iter->pos;
1175     length = ntohs(fs->length);
1176     if (length < sizeof *fs) {
1177         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu is shorter than "
1178                      "min %zu", length, sizeof *fs);
1179         return NULL;
1180     } else if (length > bytes_left) {
1181         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu but only %td "
1182                      "bytes left", length, bytes_left);
1183         return NULL;
1184     } else if ((length - sizeof *fs) % sizeof fs->actions[0]) {
1185         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu has %zu bytes "
1186                      "left over in final action", length,
1187                      (length - sizeof *fs) % sizeof fs->actions[0]);
1188         return NULL;
1189     }
1190     iter->pos += length;
1191     return fs;
1192 }
1193
1194 /* Alignment of ofp_actions. */
1195 #define ACTION_ALIGNMENT 8
1196
1197 static int
1198 check_action_exact_len(const union ofp_action *a, unsigned int len,
1199                        unsigned int required_len)
1200 {
1201     if (len != required_len) {
1202         VLOG_DBG_RL(&bad_ofmsg_rl,
1203                     "action %u has invalid length %"PRIu16" (must be %u)\n",
1204                     a->type, ntohs(a->header.len), required_len);
1205         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1206     }
1207     return 0;
1208 }
1209
1210 static int
1211 check_action_port(int port, int max_ports)
1212 {
1213     switch (port) {
1214     case OFPP_IN_PORT:
1215     case OFPP_TABLE:
1216     case OFPP_NORMAL:
1217     case OFPP_FLOOD:
1218     case OFPP_ALL:
1219     case OFPP_CONTROLLER:
1220     case OFPP_LOCAL:
1221         return 0;
1222
1223     default:
1224         if (port >= 0 && port < max_ports) {
1225             return 0;
1226         }
1227         VLOG_WARN_RL(&bad_ofmsg_rl, "unknown output port %x", port);
1228         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT);
1229     }
1230 }
1231
1232 static int
1233 check_nicira_action(const union ofp_action *a, unsigned int len)
1234 {
1235     const struct nx_action_header *nah;
1236
1237     if (len < 16) {
1238         VLOG_DBG_RL(&bad_ofmsg_rl,
1239                     "Nicira vendor action only %u bytes", len);
1240         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1241     }
1242     nah = (const struct nx_action_header *) a;
1243
1244     switch (ntohs(nah->subtype)) {
1245     case NXAST_RESUBMIT:
1246         return check_action_exact_len(a, len, 16);
1247     default:
1248         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE);
1249     }
1250 }
1251
1252 static int
1253 check_action(const union ofp_action *a, unsigned int len, int max_ports)
1254 {
1255     int error;
1256
1257     switch (ntohs(a->type)) {
1258     case OFPAT_OUTPUT:
1259         error = check_action_port(ntohs(a->output.port), max_ports);
1260         if (error) {
1261             return error;
1262         }
1263         return check_action_exact_len(a, len, 8);
1264
1265     case OFPAT_SET_VLAN_VID:
1266     case OFPAT_SET_VLAN_PCP:
1267     case OFPAT_STRIP_VLAN:
1268     case OFPAT_SET_NW_SRC:
1269     case OFPAT_SET_NW_DST:
1270     case OFPAT_SET_NW_TOS:
1271     case OFPAT_SET_TP_SRC:
1272     case OFPAT_SET_TP_DST:
1273         return check_action_exact_len(a, len, 8);
1274
1275     case OFPAT_SET_DL_SRC:
1276     case OFPAT_SET_DL_DST:
1277         return check_action_exact_len(a, len, 16);
1278
1279     case OFPAT_VENDOR:
1280         if (a->vendor.vendor == htonl(NX_VENDOR_ID)) {
1281             return check_nicira_action(a, len);
1282         } else {
1283             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR);
1284         }
1285         break;
1286
1287     default:
1288         VLOG_WARN_RL(&bad_ofmsg_rl, "unknown action type %"PRIu16,
1289                 ntohs(a->type));
1290         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE);
1291     }
1292
1293     if (!len) {
1294         VLOG_DBG_RL(&bad_ofmsg_rl, "action has invalid length 0");
1295         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1296     }
1297     if (len % ACTION_ALIGNMENT) {
1298         VLOG_DBG_RL(&bad_ofmsg_rl, "action length %u is not a multiple of %d",
1299                     len, ACTION_ALIGNMENT);
1300         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1301     }
1302     return 0;
1303 }
1304
1305 int
1306 validate_actions(const union ofp_action *actions, size_t n_actions,
1307                  int max_ports)
1308 {
1309     const union ofp_action *a;
1310
1311     for (a = actions; a < &actions[n_actions]; ) {
1312         unsigned int len = ntohs(a->header.len);
1313         unsigned int n_slots = len / ACTION_ALIGNMENT;
1314         unsigned int slots_left = &actions[n_actions] - a;
1315         int error;
1316
1317         if (n_slots > slots_left) {
1318             VLOG_DBG_RL(&bad_ofmsg_rl,
1319                         "action requires %u slots but only %u remain",
1320                         n_slots, slots_left);
1321             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1322         }
1323         error = check_action(a, len, max_ports);
1324         if (error) {
1325             return error;
1326         }
1327         a += n_slots;
1328     }
1329     return 0;
1330 }
1331
1332 /* The set of actions must either come from a trusted source or have been
1333  * previously validated with validate_actions(). */
1334 const union ofp_action *
1335 actions_first(struct actions_iterator *iter,
1336               const union ofp_action *oa, size_t n_actions)
1337 {
1338     iter->pos = oa;
1339     iter->end = oa + n_actions;
1340     return actions_next(iter);
1341 }
1342
1343 const union ofp_action *
1344 actions_next(struct actions_iterator *iter)
1345 {
1346     if (iter->pos < iter->end) {
1347         const union ofp_action *a = iter->pos;
1348         unsigned int len = ntohs(a->header.len);
1349         iter->pos += len / ACTION_ALIGNMENT;
1350         return a;
1351     } else {
1352         return NULL;
1353     }
1354 }
1355
1356 void
1357 normalize_match(struct ofp_match *m)
1358 {
1359     enum { OFPFW_NW = OFPFW_NW_SRC_MASK | OFPFW_NW_DST_MASK | OFPFW_NW_PROTO };
1360     enum { OFPFW_TP = OFPFW_TP_SRC | OFPFW_TP_DST };
1361     uint32_t wc;
1362
1363     wc = ntohl(m->wildcards) & OFPFW_ALL;
1364     if (wc & OFPFW_DL_TYPE) {
1365         m->dl_type = 0;
1366
1367         /* Can't sensibly match on network or transport headers if the
1368          * data link type is unknown. */
1369         wc |= OFPFW_NW | OFPFW_TP;
1370         m->nw_src = m->nw_dst = m->nw_proto = 0;
1371         m->tp_src = m->tp_dst = 0;
1372     } else if (m->dl_type == htons(ETH_TYPE_IP)) {
1373         if (wc & OFPFW_NW_PROTO) {
1374             m->nw_proto = 0;
1375
1376             /* Can't sensibly match on transport headers if the network
1377              * protocol is unknown. */
1378             wc |= OFPFW_TP;
1379             m->tp_src = m->tp_dst = 0;
1380         } else if (m->nw_proto == IPPROTO_TCP ||
1381                    m->nw_proto == IPPROTO_UDP ||
1382                    m->nw_proto == IPPROTO_ICMP) {
1383             if (wc & OFPFW_TP_SRC) {
1384                 m->tp_src = 0;
1385             }
1386             if (wc & OFPFW_TP_DST) {
1387                 m->tp_dst = 0;
1388             }
1389         } else {
1390             /* Transport layer fields will always be extracted as zeros, so we
1391              * can do an exact-match on those values.  */
1392             wc &= ~OFPFW_TP;
1393             m->tp_src = m->tp_dst = 0;
1394         }
1395         if (wc & OFPFW_NW_SRC_MASK) {
1396             m->nw_src &= flow_nw_bits_to_mask(wc, OFPFW_NW_SRC_SHIFT);
1397         }
1398         if (wc & OFPFW_NW_DST_MASK) {
1399             m->nw_dst &= flow_nw_bits_to_mask(wc, OFPFW_NW_DST_SHIFT);
1400         }
1401     } else {
1402         /* Network and transport layer fields will always be extracted as
1403          * zeros, so we can do an exact-match on those values. */
1404         wc &= ~(OFPFW_NW | OFPFW_TP);
1405         m->nw_proto = m->nw_src = m->nw_dst = 0;
1406         m->tp_src = m->tp_dst = 0;
1407     }
1408     if (wc & OFPFW_DL_SRC) {
1409         memset(m->dl_src, 0, sizeof m->dl_src);
1410     }
1411     if (wc & OFPFW_DL_DST) {
1412         memset(m->dl_dst, 0, sizeof m->dl_dst);
1413     }
1414     m->wildcards = htonl(wc);
1415 }
1416
1417 /* Initializes 'vconn' as a new vconn named 'name', implemented via 'class'.
1418  * The initial connection status, supplied as 'connect_status', is interpreted
1419  * as follows:
1420  *
1421  *      - 0: 'vconn' is connected.  Its 'send' and 'recv' functions may be
1422  *        called in the normal fashion.
1423  *
1424  *      - EAGAIN: 'vconn' is trying to complete a connection.  Its 'connect'
1425  *        function should be called to complete the connection.
1426  *
1427  *      - Other positive errno values indicate that the connection failed with
1428  *        the specified error.
1429  *
1430  * After calling this function, vconn_close() must be used to destroy 'vconn',
1431  * otherwise resources will be leaked.
1432  *
1433  * The caller retains ownership of 'name'. */
1434 void
1435 vconn_init(struct vconn *vconn, struct vconn_class *class, int connect_status,
1436            const char *name)
1437 {
1438     vconn->class = class;
1439     vconn->state = (connect_status == EAGAIN ? VCS_CONNECTING
1440                     : !connect_status ? VCS_SEND_HELLO
1441                     : VCS_DISCONNECTED);
1442     vconn->error = connect_status;
1443     vconn->version = -1;
1444     vconn->min_version = -1;
1445     vconn->remote_ip = 0;
1446     vconn->remote_port = 0;
1447     vconn->local_ip = 0;
1448     vconn->local_port = 0;
1449     vconn->name = xstrdup(name);
1450 }
1451
1452 void
1453 vconn_set_remote_ip(struct vconn *vconn, uint32_t ip)
1454 {
1455     vconn->remote_ip = ip;
1456 }
1457
1458 void
1459 vconn_set_remote_port(struct vconn *vconn, uint16_t port)
1460 {
1461     vconn->remote_port = port;
1462 }
1463
1464 void
1465 vconn_set_local_ip(struct vconn *vconn, uint32_t ip)
1466 {
1467     vconn->local_ip = ip;
1468 }
1469
1470 void
1471 vconn_set_local_port(struct vconn *vconn, uint16_t port)
1472 {
1473     vconn->local_port = port;
1474 }
1475
1476 void
1477 pvconn_init(struct pvconn *pvconn, struct pvconn_class *class,
1478             const char *name)
1479 {
1480     pvconn->class = class;
1481     pvconn->name = xstrdup(name);
1482 }