lib/vconn.c

   1 /*
   2  * Copyright (c) 2008, 2009 Nicira Networks.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #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]             "
 143                "listen to TCP PORT (default: %d)\n",
 144                OFP_TCP_PORT);
 145 #ifdef HAVE_OPENSSL
 146         printf("  pssl:[PORT]             "
 147                "listen for SSL on PORT (default: %d)\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;
 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;
 462
 463 again:
 464     retval = (vconn->class->recv)(vconn, msgp);
 465     if (!retval) {
 466         struct ofp_header *oh;
 467
 468         COVERAGE_INC(vconn_received);
 469         if (VLOG_IS_DBG_ENABLED()) {
 470             char *s = ofp_to_string((*msgp)->data, (*msgp)->size, 1);
 471             VLOG_DBG_RL(&ofmsg_rl, "%s: received: %s", vconn->name, s);
 472             free(s);
 473         }
 474
 475         oh = ofpbuf_at_assert(*msgp, 0, sizeof *oh);
 476         if (oh->version != vconn->version
 477             && oh->type != OFPT_HELLO
 478             && oh->type != OFPT_ERROR
 479             && oh->type != OFPT_ECHO_REQUEST
 480             && oh->type != OFPT_ECHO_REPLY
 481             && oh->type != OFPT_VENDOR)
 482         {
 483             if (vconn->version < 0) {
 484                 if (oh->type == OFPT_PACKET_IN
 485                     || oh->type == OFPT_FLOW_EXPIRED
 486                     || oh->type == OFPT_PORT_STATUS) {
 487                     /* The kernel datapath is stateless and doesn't really
 488                      * support version negotiation, so it can end up sending
 489                      * these asynchronous message before version negotiation
 490                      * is complete.  Just ignore them.
 491                      *
 492                      * (After we move OFPT_PORT_STATUS messages from the kernel
 493                      * into secchan, we won't get those here, since secchan
 494                      * does proper version negotiation.) */
 495                     ofpbuf_delete(*msgp);
 496                     goto again;
 497                 }
 498                 VLOG_ERR_RL(&bad_ofmsg_rl,
 499                             "%s: received OpenFlow message type %"PRIu8" "
 500                             "before version negotiation complete",
 501                             vconn->name, oh->type);
 502             } else {
 503                 VLOG_ERR_RL(&bad_ofmsg_rl,
 504                             "%s: received OpenFlow version 0x%02"PRIx8" "
 505                             "!= expected %02x",
 506                             vconn->name, oh->version, vconn->version);
 507             }
 508             ofpbuf_delete(*msgp);
 509             retval = EPROTO;
 510         }
 511     }
 512     if (retval) {
 513         *msgp = NULL;
 514     }
 515     return retval;
 516 }
 517
 518 /* Tries to queue 'msg' for transmission on 'vconn', which must be an active
 519  * vconn.  If successful, returns 0, in which case ownership of 'msg' is
 520  * transferred to the vconn.  Success does not guarantee that 'msg' has been or
 521  * ever will be delivered to the peer, only that it has been queued for
 522  * transmission.
 523  *
 524  * Returns a positive errno value on failure, in which case the caller
 525  * retains ownership of 'msg'.
 526  *
 527  * vconn_send will not block.  If 'msg' cannot be immediately accepted for
 528  * transmission, it returns EAGAIN immediately. */
 529 int
 530 vconn_send(struct vconn *vconn, struct ofpbuf *msg)
 531 {
 532     int retval = vconn_connect(vconn);
 533     if (!retval) {
 534         retval = do_send(vconn, msg);
 535     }
 536     return retval;
 537 }
 538
 539 static int
 540 do_send(struct vconn *vconn, struct ofpbuf *msg)
 541 {
 542     int retval;
 543
 544     assert(msg->size >= sizeof(struct ofp_header));
 545     assert(((struct ofp_header *) msg->data)->length == htons(msg->size));
 546     if (!VLOG_IS_DBG_ENABLED()) {
 547         COVERAGE_INC(vconn_sent);
 548         retval = (vconn->class->send)(vconn, msg);
 549     } else {
 550         char *s = ofp_to_string(msg->data, msg->size, 1);
 551         retval = (vconn->class->send)(vconn, msg);
 552         if (retval != EAGAIN) {
 553             VLOG_DBG_RL(&ofmsg_rl, "%s: sent (%s): %s",
 554                         vconn->name, strerror(retval), s);
 555         }
 556         free(s);
 557     }
 558     return retval;
 559 }
 560
 561 /* Same as vconn_send, except that it waits until 'msg' can be transmitted. */
 562 int
 563 vconn_send_block(struct vconn *vconn, struct ofpbuf *msg)
 564 {
 565     int retval;
 566     while ((retval = vconn_send(vconn, msg)) == EAGAIN) {
 567         vconn_send_wait(vconn);
 568         poll_block();
 569     }
 570     return retval;
 571 }
 572
 573 /* Same as vconn_recv, except that it waits until a message is received. */
 574 int
 575 vconn_recv_block(struct vconn *vconn, struct ofpbuf **msgp)
 576 {
 577     int retval;
 578     while ((retval = vconn_recv(vconn, msgp)) == EAGAIN) {
 579         vconn_recv_wait(vconn);
 580         poll_block();
 581     }
 582     return retval;
 583 }
 584
 585 /* Waits until a message with a transaction ID matching 'xid' is recived on
 586  * 'vconn'.  Returns 0 if successful, in which case the reply is stored in
 587  * '*replyp' for the caller to examine and free.  Otherwise returns a positive
 588  * errno value, or EOF, and sets '*replyp' to null.
 589  *
 590  * 'request' is always destroyed, regardless of the return value. */
 591 int
 592 vconn_recv_xid(struct vconn *vconn, uint32_t xid, struct ofpbuf **replyp)
 593 {
 594     for (;;) {
 595         uint32_t recv_xid;
 596         struct ofpbuf *reply;
 597         int error;
 598
 599         error = vconn_recv_block(vconn, &reply);
 600         if (error) {
 601             *replyp = NULL;
 602             return error;
 603         }
 604         recv_xid = ((struct ofp_header *) reply->data)->xid;
 605         if (xid == recv_xid) {
 606             *replyp = reply;
 607             return 0;
 608         }
 609
 610         VLOG_DBG_RL(&bad_ofmsg_rl, "%s: received reply with xid %08"PRIx32
 611                     " != expected %08"PRIx32, vconn->name, recv_xid, xid);
 612         ofpbuf_delete(reply);
 613     }
 614 }
 615
 616 /* Sends 'request' to 'vconn' and blocks until it receives a reply with a
 617  * matching transaction ID.  Returns 0 if successful, in which case the reply
 618  * is stored in '*replyp' for the caller to examine and free.  Otherwise
 619  * returns a positive errno value, or EOF, and sets '*replyp' to null.
 620  *
 621  * 'request' is always destroyed, regardless of the return value. */
 622 int
 623 vconn_transact(struct vconn *vconn, struct ofpbuf *request,
 624                struct ofpbuf **replyp)
 625 {
 626     uint32_t send_xid = ((struct ofp_header *) request->data)->xid;
 627     int error;
 628
 629     *replyp = NULL;
 630     error = vconn_send_block(vconn, request);
 631     if (error) {
 632         ofpbuf_delete(request);
 633     }
 634     return error ? error : vconn_recv_xid(vconn, send_xid, replyp);
 635 }
 636
 637 void
 638 vconn_wait(struct vconn *vconn, enum vconn_wait_type wait)
 639 {
 640     assert(wait == WAIT_CONNECT || wait == WAIT_RECV || wait == WAIT_SEND);
 641
 642     switch (vconn->state) {
 643     case VCS_CONNECTING:
 644         wait = WAIT_CONNECT;
 645         break;
 646
 647     case VCS_SEND_HELLO:
 648     case VCS_SEND_ERROR:
 649         wait = WAIT_SEND;
 650         break;
 651
 652     case VCS_RECV_HELLO:
 653         wait = WAIT_RECV;
 654         break;
 655
 656     case VCS_CONNECTED:
 657         break;
 658
 659     case VCS_DISCONNECTED:
 660         poll_immediate_wake();
 661         return;
 662     }
 663     (vconn->class->wait)(vconn, wait);
 664 }
 665
 666 void
 667 vconn_connect_wait(struct vconn *vconn)
 668 {
 669     vconn_wait(vconn, WAIT_CONNECT);
 670 }
 671
 672 void
 673 vconn_recv_wait(struct vconn *vconn)
 674 {
 675     vconn_wait(vconn, WAIT_RECV);
 676 }
 677
 678 void
 679 vconn_send_wait(struct vconn *vconn)
 680 {
 681     vconn_wait(vconn, WAIT_SEND);
 682 }
 683
 684 /* Attempts to start listening for OpenFlow connections.  'name' is a
 685  * connection name in the form "TYPE:ARGS", where TYPE is an passive vconn
 686  * class's name and ARGS are vconn class-specific.
 687  *
 688  * Returns 0 if successful, otherwise a positive errno value.  If successful,
 689  * stores a pointer to the new connection in '*pvconnp', otherwise a null
 690  * pointer.  */
 691 int
 692 pvconn_open(const char *name, struct pvconn **pvconnp)
 693 {
 694     size_t prefix_len;
 695     size_t i;
 696
 697     check_vconn_classes();
 698
 699     *pvconnp = NULL;
 700     prefix_len = strcspn(name, ":");
 701     if (prefix_len == strlen(name)) {
 702         return EAFNOSUPPORT;
 703     }
 704     for (i = 0; i < ARRAY_SIZE(pvconn_classes); i++) {
 705         struct pvconn_class *class = pvconn_classes[i];
 706         if (strlen(class->name) == prefix_len
 707             && !memcmp(class->name, name, prefix_len)) {
 708             char *suffix_copy = xstrdup(name + prefix_len + 1);
 709             int retval = class->listen(name, suffix_copy, pvconnp);
 710             free(suffix_copy);
 711             if (retval) {
 712                 *pvconnp = NULL;
 713             }
 714             return retval;
 715         }
 716     }
 717     return EAFNOSUPPORT;
 718 }
 719
 720 /* Returns the name that was used to open 'pvconn'.  The caller must not
 721  * modify or free the name. */
 722 const char *
 723 pvconn_get_name(const struct pvconn *pvconn)
 724 {
 725     return pvconn->name;
 726 }
 727
 728 /* Closes 'pvconn'. */
 729 void
 730 pvconn_close(struct pvconn *pvconn)
 731 {
 732     if (pvconn != NULL) {
 733         char *name = pvconn->name;
 734         (pvconn->class->close)(pvconn);
 735         free(name);
 736     }
 737 }
 738
 739 /* Tries to accept a new connection on 'pvconn'.  If successful, stores the new
 740  * connection in '*new_vconn' and returns 0.  Otherwise, returns a positive
 741  * errno value.
 742  *
 743  * The new vconn will automatically negotiate an OpenFlow protocol version
 744  * acceptable to both peers on the connection.  The version negotiated will be
 745  * no lower than 'min_version' and no higher than OFP_VERSION.
 746  *
 747  * pvconn_accept() will not block waiting for a connection.  If no connection
 748  * is ready to be accepted, it returns EAGAIN immediately. */
 749 int
 750 pvconn_accept(struct pvconn *pvconn, int min_version, struct vconn **new_vconn)
 751 {
 752     int retval = (pvconn->class->accept)(pvconn, new_vconn);
 753     if (retval) {
 754         *new_vconn = NULL;
 755     } else {
 756         assert((*new_vconn)->state != VCS_CONNECTING
 757                || (*new_vconn)->class->connect);
 758         (*new_vconn)->min_version = min_version;
 759     }
 760     return retval;
 761 }
 762
 763 void
 764 pvconn_wait(struct pvconn *pvconn)
 765 {
 766     (pvconn->class->wait)(pvconn);
 767 }
 768
 769 /* XXX we should really use consecutive xids to avoid probabilistic
 770  * failures. */
 771 static inline uint32_t
 772 alloc_xid(void)
 773 {
 774     return random_uint32();
 775 }
 776
 777 /* Allocates and stores in '*bufferp' a new ofpbuf with a size of
 778  * 'openflow_len', starting with an OpenFlow header with the given 'type' and
 779  * an arbitrary transaction id.  Allocated bytes beyond the header, if any, are
 780  * zeroed.
 781  *
 782  * The caller is responsible for freeing '*bufferp' when it is no longer
 783  * needed.
 784  *
 785  * The OpenFlow header length is initially set to 'openflow_len'; if the
 786  * message is later extended, the length should be updated with
 787  * update_openflow_length() before sending.
 788  *
 789  * Returns the header. */
 790 void *
 791 make_openflow(size_t openflow_len, uint8_t type, struct ofpbuf **bufferp)
 792 {
 793     *bufferp = ofpbuf_new(openflow_len);
 794     return put_openflow_xid(openflow_len, type, alloc_xid(), *bufferp);
 795 }
 796
 797 /* Allocates and stores in '*bufferp' a new ofpbuf with a size of
 798  * 'openflow_len', starting with an OpenFlow header with the given 'type' and
 799  * transaction id 'xid'.  Allocated bytes beyond the header, if any, are
 800  * zeroed.
 801  *
 802  * The caller is responsible for freeing '*bufferp' when it is no longer
 803  * needed.
 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 make_openflow_xid(size_t openflow_len, uint8_t type, uint32_t xid,
 812                   struct ofpbuf **bufferp)
 813 {
 814     *bufferp = ofpbuf_new(openflow_len);
 815     return put_openflow_xid(openflow_len, type, xid, *bufferp);
 816 }
 817
 818 /* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
 819  * with the given 'type' and an arbitrary transaction id.  Allocated bytes
 820  * beyond the header, if any, are zeroed.
 821  *
 822  * The OpenFlow header length is initially set to 'openflow_len'; if the
 823  * message is later extended, the length should be updated with
 824  * update_openflow_length() before sending.
 825  *
 826  * Returns the header. */
 827 void *
 828 put_openflow(size_t openflow_len, uint8_t type, struct ofpbuf *buffer)
 829 {
 830     return put_openflow_xid(openflow_len, type, alloc_xid(), buffer);
 831 }
 832
 833 /* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
 834  * with the given 'type' and an transaction id 'xid'.  Allocated bytes beyond
 835  * the header, if any, are zeroed.
 836  *
 837  * The OpenFlow header length is initially set to 'openflow_len'; if the
 838  * message is later extended, the length should be updated with
 839  * update_openflow_length() before sending.
 840  *
 841  * Returns the header. */
 842 void *
 843 put_openflow_xid(size_t openflow_len, uint8_t type, uint32_t xid,
 844                  struct ofpbuf *buffer)
 845 {
 846     struct ofp_header *oh;
 847
 848     assert(openflow_len >= sizeof *oh);
 849     assert(openflow_len <= UINT16_MAX);
 850
 851     oh = ofpbuf_put_uninit(buffer, openflow_len);
 852     oh->version = OFP_VERSION;
 853     oh->type = type;
 854     oh->length = htons(openflow_len);
 855     oh->xid = xid;
 856     memset(oh + 1, 0, openflow_len - sizeof *oh);
 857     return oh;
 858 }
 859
 860 /* Updates the 'length' field of the OpenFlow message in 'buffer' to
 861  * 'buffer->size'. */
 862 void
 863 update_openflow_length(struct ofpbuf *buffer)
 864 {
 865     struct ofp_header *oh = ofpbuf_at_assert(buffer, 0, sizeof *oh);
 866     oh->length = htons(buffer->size);
 867 }
 868
 869 struct ofpbuf *
 870 make_flow_mod(uint16_t command, const flow_t *flow, size_t actions_len)
 871 {
 872     struct ofp_flow_mod *ofm;
 873     size_t size = sizeof *ofm + actions_len;
 874     struct ofpbuf *out = ofpbuf_new(size);
 875     ofm = ofpbuf_put_zeros(out, sizeof *ofm);
 876     ofm->header.version = OFP_VERSION;
 877     ofm->header.type = OFPT_FLOW_MOD;
 878     ofm->header.length = htons(size);
 879     ofm->match.wildcards = htonl(0);
 880     ofm->match.in_port = htons(flow->in_port == ODPP_LOCAL ? OFPP_LOCAL
 881                                : flow->in_port);
 882     memcpy(ofm->match.dl_src, flow->dl_src, sizeof ofm->match.dl_src);
 883     memcpy(ofm->match.dl_dst, flow->dl_dst, sizeof ofm->match.dl_dst);
 884     ofm->match.dl_vlan = flow->dl_vlan;
 885     ofm->match.dl_type = flow->dl_type;
 886     ofm->match.nw_src = flow->nw_src;
 887     ofm->match.nw_dst = flow->nw_dst;
 888     ofm->match.nw_proto = flow->nw_proto;
 889     ofm->match.tp_src = flow->tp_src;
 890     ofm->match.tp_dst = flow->tp_dst;
 891     ofm->command = htons(command);
 892     return out;
 893 }
 894
 895 struct ofpbuf *
 896 make_add_flow(const flow_t *flow, uint32_t buffer_id,
 897               uint16_t idle_timeout, size_t actions_len)
 898 {
 899     struct ofpbuf *out = make_flow_mod(OFPFC_ADD, flow, actions_len);
 900     struct ofp_flow_mod *ofm = out->data;
 901     ofm->idle_timeout = htons(idle_timeout);
 902     ofm->hard_timeout = htons(OFP_FLOW_PERMANENT);
 903     ofm->buffer_id = htonl(buffer_id);
 904     return out;
 905 }
 906
 907 struct ofpbuf *
 908 make_del_flow(const flow_t *flow)
 909 {
 910     struct ofpbuf *out = make_flow_mod(OFPFC_DELETE_STRICT, flow, 0);
 911     struct ofp_flow_mod *ofm = out->data;
 912     ofm->out_port = htons(OFPP_NONE);
 913     return out;
 914 }
 915
 916 struct ofpbuf *
 917 make_add_simple_flow(const flow_t *flow,
 918                      uint32_t buffer_id, uint16_t out_port,
 919                      uint16_t idle_timeout)
 920 {
 921     struct ofp_action_output *oao;
 922     struct ofpbuf *buffer = make_add_flow(flow, buffer_id, idle_timeout,
 923                                           sizeof *oao);
 924     oao = ofpbuf_put_zeros(buffer, sizeof *oao);
 925     oao->type = htons(OFPAT_OUTPUT);
 926     oao->len = htons(sizeof *oao);
 927     oao->port = htons(out_port);
 928     return buffer;
 929 }
 930
 931 struct ofpbuf *
 932 make_packet_in(uint32_t buffer_id, uint16_t in_port, uint8_t reason,
 933                const struct ofpbuf *payload, int max_send_len)
 934 {
 935     struct ofp_packet_in *opi;
 936     struct ofpbuf *buf;
 937     int send_len;
 938
 939     send_len = MIN(max_send_len, payload->size);
 940     buf = ofpbuf_new(sizeof *opi + send_len);
 941     opi = put_openflow_xid(offsetof(struct ofp_packet_in, data),
 942                            OFPT_PACKET_IN, 0, buf);
 943     opi->buffer_id = htonl(buffer_id);
 944     opi->total_len = htons(payload->size);
 945     opi->in_port = htons(in_port);
 946     opi->reason = reason;
 947     ofpbuf_put(buf, payload->data, send_len);
 948     update_openflow_length(buf);
 949
 950     return buf;
 951 }
 952
 953 struct ofpbuf *
 954 make_packet_out(const struct ofpbuf *packet, uint32_t buffer_id,
 955                 uint16_t in_port,
 956                 const struct ofp_action_header *actions, size_t n_actions)
 957 {
 958     size_t actions_len = n_actions * sizeof *actions;
 959     struct ofp_packet_out *opo;
 960     size_t size = sizeof *opo + actions_len + (packet ? packet->size : 0);
 961     struct ofpbuf *out = ofpbuf_new(size);
 962
 963     opo = ofpbuf_put_uninit(out, sizeof *opo);
 964     opo->header.version = OFP_VERSION;
 965     opo->header.type = OFPT_PACKET_OUT;
 966     opo->header.length = htons(size);
 967     opo->header.xid = htonl(0);
 968     opo->buffer_id = htonl(buffer_id);
 969     opo->in_port = htons(in_port == ODPP_LOCAL ? OFPP_LOCAL : in_port);
 970     opo->actions_len = htons(actions_len);
 971     ofpbuf_put(out, actions, actions_len);
 972     if (packet) {
 973         ofpbuf_put(out, packet->data, packet->size);
 974     }
 975     return out;
 976 }
 977
 978 struct ofpbuf *
 979 make_unbuffered_packet_out(const struct ofpbuf *packet,
 980                            uint16_t in_port, uint16_t out_port)
 981 {
 982     struct ofp_action_output action;
 983     action.type = htons(OFPAT_OUTPUT);
 984     action.len = htons(sizeof action);
 985     action.port = htons(out_port);
 986     return make_packet_out(packet, UINT32_MAX, in_port,
 987                            (struct ofp_action_header *) &action, 1);
 988 }
 989
 990 struct ofpbuf *
 991 make_buffered_packet_out(uint32_t buffer_id,
 992                          uint16_t in_port, uint16_t out_port)
 993 {
 994     struct ofp_action_output action;
 995     action.type = htons(OFPAT_OUTPUT);
 996     action.len = htons(sizeof action);
 997     action.port = htons(out_port);
 998     return make_packet_out(NULL, buffer_id, in_port,
 999                            (struct ofp_action_header *) &action, 1);
1000 }
1001
1002 /* Creates and returns an OFPT_ECHO_REQUEST message with an empty payload. */
1003 struct ofpbuf *
1004 make_echo_request(void)
1005 {
1006     struct ofp_header *rq;
1007     struct ofpbuf *out = ofpbuf_new(sizeof *rq);
1008     rq = ofpbuf_put_uninit(out, sizeof *rq);
1009     rq->version = OFP_VERSION;
1010     rq->type = OFPT_ECHO_REQUEST;
1011     rq->length = htons(sizeof *rq);
1012     rq->xid = 0;
1013     return out;
1014 }
1015
1016 /* Creates and returns an OFPT_ECHO_REPLY message matching the
1017  * OFPT_ECHO_REQUEST message in 'rq'. */
1018 struct ofpbuf *
1019 make_echo_reply(const struct ofp_header *rq)
1020 {
1021     size_t size = ntohs(rq->length);
1022     struct ofpbuf *out = ofpbuf_new(size);
1023     struct ofp_header *reply = ofpbuf_put(out, rq, size);
1024     reply->type = OFPT_ECHO_REPLY;
1025     return out;
1026 }
1027
1028 static int
1029 check_message_type(uint8_t got_type, uint8_t want_type)
1030 {
1031     if (got_type != want_type) {
1032         char *want_type_name = ofp_message_type_to_string(want_type);
1033         char *got_type_name = ofp_message_type_to_string(got_type);
1034         VLOG_WARN_RL(&bad_ofmsg_rl,
1035                      "received bad message type %s (expected %s)",
1036                      got_type_name, want_type_name);
1037         free(want_type_name);
1038         free(got_type_name);
1039         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE);
1040     }
1041     return 0;
1042 }
1043
1044 /* Checks that 'msg' has type 'type' and that it is exactly 'size' bytes long.
1045  * Returns 0 if the checks pass, otherwise an OpenFlow error code (produced
1046  * with ofp_mkerr()). */
1047 int
1048 check_ofp_message(const struct ofp_header *msg, uint8_t type, size_t size)
1049 {
1050     size_t got_size;
1051     int error;
1052
1053     error = check_message_type(msg->type, type);
1054     if (error) {
1055         return error;
1056     }
1057
1058     got_size = ntohs(msg->length);
1059     if (got_size != size) {
1060         char *type_name = ofp_message_type_to_string(type);
1061         VLOG_WARN_RL(&bad_ofmsg_rl,
1062                      "received %s message of length %zu (expected %zu)",
1063                      type_name, got_size, size);
1064         free(type_name);
1065         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
1066     }
1067
1068     return 0;
1069 }
1070
1071 /* Checks that 'msg' has type 'type' and that 'msg' is 'size' plus a
1072  * nonnegative integer multiple of 'array_elt_size' bytes long.  Returns 0 if
1073  * the checks pass, otherwise an OpenFlow error code (produced with
1074  * ofp_mkerr()).
1075  *
1076  * If 'n_array_elts' is nonnull, then '*n_array_elts' is set to the number of
1077  * 'array_elt_size' blocks in 'msg' past the first 'min_size' bytes, when
1078  * successful. */
1079 int
1080 check_ofp_message_array(const struct ofp_header *msg, uint8_t type,
1081                         size_t min_size, size_t array_elt_size,
1082                         size_t *n_array_elts)
1083 {
1084     size_t got_size;
1085     int error;
1086
1087     assert(array_elt_size);
1088
1089     error = check_message_type(msg->type, type);
1090     if (error) {
1091         return error;
1092     }
1093
1094     got_size = ntohs(msg->length);
1095     if (got_size < min_size) {
1096         char *type_name = ofp_message_type_to_string(type);
1097         VLOG_WARN_RL(&bad_ofmsg_rl, "received %s message of length %zu "
1098                      "(expected at least %zu)",
1099                      type_name, got_size, min_size);
1100         free(type_name);
1101         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
1102     }
1103     if ((got_size - min_size) % array_elt_size) {
1104         char *type_name = ofp_message_type_to_string(type);
1105         VLOG_WARN_RL(&bad_ofmsg_rl,
1106                      "received %s message of bad length %zu: the "
1107                      "excess over %zu (%zu) is not evenly divisible by %zu "
1108                      "(remainder is %zu)",
1109                      type_name, got_size, min_size, got_size - min_size,
1110                      array_elt_size, (got_size - min_size) % array_elt_size);
1111         free(type_name);
1112         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
1113     }
1114     if (n_array_elts) {
1115         *n_array_elts = (got_size - min_size) / array_elt_size;
1116     }
1117     return 0;
1118 }
1119
1120 int
1121 check_ofp_packet_out(const struct ofp_header *oh, struct ofpbuf *data,
1122                      int *n_actionsp, int max_ports)
1123 {
1124     const struct ofp_packet_out *opo;
1125     unsigned int actions_len, n_actions;
1126     size_t extra;
1127     int error;
1128
1129     *n_actionsp = 0;
1130     error = check_ofp_message_array(oh, OFPT_PACKET_OUT,
1131                                     sizeof *opo, 1, &extra);
1132     if (error) {
1133         return error;
1134     }
1135     opo = (const struct ofp_packet_out *) oh;
1136
1137     actions_len = ntohs(opo->actions_len);
1138     if (actions_len > extra) {
1139         VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out claims %u bytes of actions "
1140                      "but message has room for only %zu bytes",
1141                      actions_len, extra);
1142         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
1143     }
1144     if (actions_len % sizeof(union ofp_action)) {
1145         VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out claims %u bytes of actions, "
1146                      "which is not a multiple of %zu",
1147                      actions_len, sizeof(union ofp_action));
1148         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
1149     }
1150
1151     n_actions = actions_len / sizeof(union ofp_action);
1152     error = validate_actions((const union ofp_action *) opo->actions,
1153                              n_actions, max_ports);
1154     if (error) {
1155         return error;
1156     }
1157
1158     data->data = (void *) &opo->actions[n_actions];
1159     data->size = extra - actions_len;
1160     *n_actionsp = n_actions;
1161     return 0;
1162 }
1163
1164 const struct ofp_flow_stats *
1165 flow_stats_first(struct flow_stats_iterator *iter,
1166                  const struct ofp_stats_reply *osr)
1167 {
1168     iter->pos = osr->body;
1169     iter->end = osr->body + (ntohs(osr->header.length)
1170                              - offsetof(struct ofp_stats_reply, body));
1171     return flow_stats_next(iter);
1172 }
1173
1174 const struct ofp_flow_stats *
1175 flow_stats_next(struct flow_stats_iterator *iter)
1176 {
1177     ptrdiff_t bytes_left = iter->end - iter->pos;
1178     const struct ofp_flow_stats *fs;
1179     size_t length;
1180
1181     if (bytes_left < sizeof *fs) {
1182         if (bytes_left != 0) {
1183             VLOG_WARN_RL(&bad_ofmsg_rl,
1184                          "%td leftover bytes in flow stats reply", bytes_left);
1185         }
1186         return NULL;
1187     }
1188
1189     fs = (const void *) iter->pos;
1190     length = ntohs(fs->length);
1191     if (length < sizeof *fs) {
1192         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu is shorter than "
1193                      "min %zu", length, sizeof *fs);
1194         return NULL;
1195     } else if (length > bytes_left) {
1196         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu but only %td "
1197                      "bytes left", length, bytes_left);
1198         return NULL;
1199     } else if ((length - sizeof *fs) % sizeof fs->actions[0]) {
1200         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu has %zu bytes "
1201                      "left over in final action", length,
1202                      (length - sizeof *fs) % sizeof fs->actions[0]);
1203         return NULL;
1204     }
1205     iter->pos += length;
1206     return fs;
1207 }
1208
1209 /* Alignment of ofp_actions. */
1210 #define ACTION_ALIGNMENT 8
1211
1212 static int
1213 check_action_exact_len(const union ofp_action *a, unsigned int len,
1214                        unsigned int required_len)
1215 {
1216     if (len != required_len) {
1217         VLOG_DBG_RL(&bad_ofmsg_rl,
1218                     "action %u has invalid length %"PRIu16" (must be %u)\n",
1219                     a->type, ntohs(a->header.len), required_len);
1220         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1221     }
1222     return 0;
1223 }
1224
1225 static int
1226 check_action_port(int port, int max_ports)
1227 {
1228     switch (port) {
1229     case OFPP_IN_PORT:
1230     case OFPP_TABLE:
1231     case OFPP_NORMAL:
1232     case OFPP_FLOOD:
1233     case OFPP_ALL:
1234     case OFPP_CONTROLLER:
1235     case OFPP_LOCAL:
1236         return 0;
1237
1238     default:
1239         if (port >= 0 && port < max_ports) {
1240             return 0;
1241         }
1242         VLOG_WARN_RL(&bad_ofmsg_rl, "unknown output port %x", port);
1243         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT);
1244     }
1245 }
1246
1247 static int
1248 check_nicira_action(const union ofp_action *a, unsigned int len)
1249 {
1250     const struct nx_action_header *nah;
1251
1252     if (len < 16) {
1253         VLOG_DBG_RL(&bad_ofmsg_rl,
1254                     "Nicira vendor action only %u bytes", len);
1255         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1256     }
1257     nah = (const struct nx_action_header *) a;
1258
1259     switch (ntohs(nah->subtype)) {
1260     case NXAST_RESUBMIT:
1261         return check_action_exact_len(a, len, 16);
1262     default:
1263         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE);
1264     }
1265 }
1266
1267 static int
1268 check_action(const union ofp_action *a, unsigned int len, int max_ports)
1269 {
1270     int error;
1271
1272     if (!len) {
1273         VLOG_DBG_RL(&bad_ofmsg_rl, "action has invalid length 0");
1274         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1275     }
1276
1277     if (len % ACTION_ALIGNMENT) {
1278         VLOG_DBG_RL(&bad_ofmsg_rl, "action length %u is not a multiple of %d",
1279                     len, ACTION_ALIGNMENT);
1280         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1281     }
1282
1283     switch (ntohs(a->type)) {
1284     case OFPAT_OUTPUT:
1285         error = check_action_port(ntohs(a->output.port), max_ports);
1286         if (error) {
1287             return error;
1288         }
1289         return check_action_exact_len(a, len, 8);
1290
1291     case OFPAT_SET_VLAN_VID:
1292     case OFPAT_SET_VLAN_PCP:
1293     case OFPAT_STRIP_VLAN:
1294     case OFPAT_SET_NW_SRC:
1295     case OFPAT_SET_NW_DST:
1296     case OFPAT_SET_TP_SRC:
1297     case OFPAT_SET_TP_DST:
1298         return check_action_exact_len(a, len, 8);
1299
1300     case OFPAT_SET_DL_SRC:
1301     case OFPAT_SET_DL_DST:
1302         return check_action_exact_len(a, len, 16);
1303
1304     case OFPAT_VENDOR:
1305         if (a->vendor.vendor == htonl(NX_VENDOR_ID)) {
1306             return check_nicira_action(a, len);
1307         } else {
1308             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR);
1309         }
1310         break;
1311
1312     default:
1313         VLOG_WARN_RL(&bad_ofmsg_rl, "unknown action type %"PRIu16, a->type);
1314         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE);
1315     }
1316 }
1317
1318 int
1319 validate_actions(const union ofp_action *actions, size_t n_actions,
1320                  int max_ports)
1321 {
1322     const union ofp_action *a;
1323
1324     for (a = actions; a < &actions[n_actions]; ) {
1325         unsigned int len = ntohs(a->header.len);
1326         unsigned int n_slots = len / ACTION_ALIGNMENT;
1327         unsigned int slots_left = &actions[n_actions] - a;
1328         int error;
1329
1330         if (n_slots > slots_left) {
1331             VLOG_DBG_RL(&bad_ofmsg_rl,
1332                         "action requires %u slots but only %u remain",
1333                         n_slots, slots_left);
1334             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1335         }
1336         error = check_action(a, len, max_ports);
1337         if (error) {
1338             return error;
1339         }
1340         a += n_slots;
1341     }
1342     return 0;
1343 }
1344
1345 /* The set of actions must either come from a trusted source or have been
1346  * previously validated with validate_actions(). */
1347 const union ofp_action *
1348 actions_first(struct actions_iterator *iter,
1349               const union ofp_action *oa, size_t n_actions)
1350 {
1351     iter->pos = oa;
1352     iter->end = oa + n_actions;
1353     return actions_next(iter);
1354 }
1355
1356 const union ofp_action *
1357 actions_next(struct actions_iterator *iter)
1358 {
1359     if (iter->pos < iter->end) {
1360         const union ofp_action *a = iter->pos;
1361         unsigned int len = ntohs(a->header.len);
1362         iter->pos += len / ACTION_ALIGNMENT;
1363         return a;
1364     } else {
1365         return NULL;
1366     }
1367 }
1368
1369 void
1370 normalize_match(struct ofp_match *m)
1371 {
1372     enum { OFPFW_NW = OFPFW_NW_SRC_MASK | OFPFW_NW_DST_MASK | OFPFW_NW_PROTO };
1373     enum { OFPFW_TP = OFPFW_TP_SRC | OFPFW_TP_DST };
1374     uint32_t wc;
1375
1376     wc = ntohl(m->wildcards) & OFPFW_ALL;
1377     if (wc & OFPFW_DL_TYPE) {
1378         m->dl_type = 0;
1379
1380         /* Can't sensibly match on network or transport headers if the
1381          * data link type is unknown. */
1382         wc |= OFPFW_NW | OFPFW_TP;
1383         m->nw_src = m->nw_dst = m->nw_proto = 0;
1384         m->tp_src = m->tp_dst = 0;
1385     } else if (m->dl_type == htons(ETH_TYPE_IP)) {
1386         if (wc & OFPFW_NW_PROTO) {
1387             m->nw_proto = 0;
1388
1389             /* Can't sensibly match on transport headers if the network
1390              * protocol is unknown. */
1391             wc |= OFPFW_TP;
1392             m->tp_src = m->tp_dst = 0;
1393         } else if (m->nw_proto == IPPROTO_TCP ||
1394                    m->nw_proto == IPPROTO_UDP ||
1395                    m->nw_proto == IPPROTO_ICMP) {
1396             if (wc & OFPFW_TP_SRC) {
1397                 m->tp_src = 0;
1398             }
1399             if (wc & OFPFW_TP_DST) {
1400                 m->tp_dst = 0;
1401             }
1402         } else {
1403             /* Transport layer fields will always be extracted as zeros, so we
1404              * can do an exact-match on those values.  */
1405             wc &= ~OFPFW_TP;
1406             m->tp_src = m->tp_dst = 0;
1407         }
1408         if (wc & OFPFW_NW_SRC_MASK) {
1409             m->nw_src &= flow_nw_bits_to_mask(wc, OFPFW_NW_SRC_SHIFT);
1410         }
1411         if (wc & OFPFW_NW_DST_MASK) {
1412             m->nw_dst &= flow_nw_bits_to_mask(wc, OFPFW_NW_DST_SHIFT);
1413         }
1414     } else {
1415         /* Network and transport layer fields will always be extracted as
1416          * zeros, so we can do an exact-match on those values. */
1417         wc &= ~(OFPFW_NW | OFPFW_TP);
1418         m->nw_proto = m->nw_src = m->nw_dst = 0;
1419         m->tp_src = m->tp_dst = 0;
1420     }
1421     if (wc & OFPFW_DL_SRC) {
1422         memset(m->dl_src, 0, sizeof m->dl_src);
1423     }
1424     if (wc & OFPFW_DL_DST) {
1425         memset(m->dl_dst, 0, sizeof m->dl_dst);
1426     }
1427     m->wildcards = htonl(wc);
1428 }
1429
1430 void
1431 vconn_init(struct vconn *vconn, struct vconn_class *class, int connect_status,
1432            const char *name, bool reconnectable)
1433 {
1434     vconn->class = class;
1435     vconn->state = (connect_status == EAGAIN ? VCS_CONNECTING
1436                     : !connect_status ? VCS_SEND_HELLO
1437                     : VCS_DISCONNECTED);
1438     vconn->error = connect_status;
1439     vconn->version = -1;
1440     vconn->min_version = -1;
1441     vconn->remote_ip = 0;
1442     vconn->remote_port = 0;
1443     vconn->local_ip = 0;
1444     vconn->local_port = 0;
1445     vconn->name = xstrdup(name);
1446     vconn->reconnectable = reconnectable;
1447 }
1448
1449 void
1450 vconn_set_remote_ip(struct vconn *vconn, uint32_t ip)
1451 {
1452     vconn->remote_ip = ip;
1453 }
1454
1455 void
1456 vconn_set_remote_port(struct vconn *vconn, uint16_t port)
1457 {
1458     vconn->remote_port = port;
1459 }
1460
1461 void
1462 vconn_set_local_ip(struct vconn *vconn, uint32_t ip)
1463 {
1464     vconn->local_ip = ip;
1465 }
1466
1467 void
1468 vconn_set_local_port(struct vconn *vconn, uint16_t port)
1469 {
1470     vconn->local_port = port;
1471 }
1472
1473 void
1474 pvconn_init(struct pvconn *pvconn, struct pvconn_class *class,
1475             const char *name)
1476 {
1477     pvconn->class = class;
1478     pvconn->name = xstrdup(name);
1479 }