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:HOST[:PORT]         "
 132                "PORT (default: %d) on remote TCP HOST\n", OFP_TCP_PORT);
 133 #ifdef HAVE_OPENSSL
 134         printf("  ssl:HOST[:PORT]         "
 135                "SSL PORT (default: %d) on remote HOST\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->match.wildcards = htonl(0);
 863     ofm->match.in_port = htons(flow->in_port == ODPP_LOCAL ? OFPP_LOCAL
 864                                : flow->in_port);
 865     memcpy(ofm->match.dl_src, flow->dl_src, sizeof ofm->match.dl_src);
 866     memcpy(ofm->match.dl_dst, flow->dl_dst, sizeof ofm->match.dl_dst);
 867     ofm->match.dl_vlan = flow->dl_vlan;
 868     ofm->match.dl_type = flow->dl_type;
 869     ofm->match.nw_src = flow->nw_src;
 870     ofm->match.nw_dst = flow->nw_dst;
 871     ofm->match.nw_proto = flow->nw_proto;
 872     ofm->match.tp_src = flow->tp_src;
 873     ofm->match.tp_dst = flow->tp_dst;
 874     ofm->command = htons(command);
 875     return out;
 876 }
 877
 878 struct ofpbuf *
 879 make_add_flow(const flow_t *flow, uint32_t buffer_id,
 880               uint16_t idle_timeout, size_t actions_len)
 881 {
 882     struct ofpbuf *out = make_flow_mod(OFPFC_ADD, flow, actions_len);
 883     struct ofp_flow_mod *ofm = out->data;
 884     ofm->idle_timeout = htons(idle_timeout);
 885     ofm->hard_timeout = htons(OFP_FLOW_PERMANENT);
 886     ofm->buffer_id = htonl(buffer_id);
 887     return out;
 888 }
 889
 890 struct ofpbuf *
 891 make_del_flow(const flow_t *flow)
 892 {
 893     struct ofpbuf *out = make_flow_mod(OFPFC_DELETE_STRICT, flow, 0);
 894     struct ofp_flow_mod *ofm = out->data;
 895     ofm->out_port = htons(OFPP_NONE);
 896     return out;
 897 }
 898
 899 struct ofpbuf *
 900 make_add_simple_flow(const flow_t *flow,
 901                      uint32_t buffer_id, uint16_t out_port,
 902                      uint16_t idle_timeout)
 903 {
 904     struct ofp_action_output *oao;
 905     struct ofpbuf *buffer = make_add_flow(flow, buffer_id, idle_timeout,
 906                                           sizeof *oao);
 907     oao = ofpbuf_put_zeros(buffer, sizeof *oao);
 908     oao->type = htons(OFPAT_OUTPUT);
 909     oao->len = htons(sizeof *oao);
 910     oao->port = htons(out_port);
 911     return buffer;
 912 }
 913
 914 struct ofpbuf *
 915 make_packet_out(const struct ofpbuf *packet, uint32_t buffer_id,
 916                 uint16_t in_port,
 917                 const struct ofp_action_header *actions, size_t n_actions)
 918 {
 919     size_t actions_len = n_actions * sizeof *actions;
 920     struct ofp_packet_out *opo;
 921     size_t size = sizeof *opo + actions_len + (packet ? packet->size : 0);
 922     struct ofpbuf *out = ofpbuf_new(size);
 923
 924     opo = ofpbuf_put_uninit(out, sizeof *opo);
 925     opo->header.version = OFP_VERSION;
 926     opo->header.type = OFPT_PACKET_OUT;
 927     opo->header.length = htons(size);
 928     opo->header.xid = htonl(0);
 929     opo->buffer_id = htonl(buffer_id);
 930     opo->in_port = htons(in_port == ODPP_LOCAL ? OFPP_LOCAL : in_port);
 931     opo->actions_len = htons(actions_len);
 932     ofpbuf_put(out, actions, actions_len);
 933     if (packet) {
 934         ofpbuf_put(out, packet->data, packet->size);
 935     }
 936     return out;
 937 }
 938
 939 struct ofpbuf *
 940 make_unbuffered_packet_out(const struct ofpbuf *packet,
 941                            uint16_t in_port, uint16_t out_port)
 942 {
 943     struct ofp_action_output action;
 944     action.type = htons(OFPAT_OUTPUT);
 945     action.len = htons(sizeof action);
 946     action.port = htons(out_port);
 947     return make_packet_out(packet, UINT32_MAX, in_port,
 948                            (struct ofp_action_header *) &action, 1);
 949 }
 950
 951 struct ofpbuf *
 952 make_buffered_packet_out(uint32_t buffer_id,
 953                          uint16_t in_port, uint16_t out_port)
 954 {
 955     struct ofp_action_output action;
 956     action.type = htons(OFPAT_OUTPUT);
 957     action.len = htons(sizeof action);
 958     action.port = htons(out_port);
 959     return make_packet_out(NULL, buffer_id, in_port,
 960                            (struct ofp_action_header *) &action, 1);
 961 }
 962
 963 /* Creates and returns an OFPT_ECHO_REQUEST message with an empty payload. */
 964 struct ofpbuf *
 965 make_echo_request(void)
 966 {
 967     struct ofp_header *rq;
 968     struct ofpbuf *out = ofpbuf_new(sizeof *rq);
 969     rq = ofpbuf_put_uninit(out, sizeof *rq);
 970     rq->version = OFP_VERSION;
 971     rq->type = OFPT_ECHO_REQUEST;
 972     rq->length = htons(sizeof *rq);
 973     rq->xid = 0;
 974     return out;
 975 }
 976
 977 /* Creates and returns an OFPT_ECHO_REPLY message matching the
 978  * OFPT_ECHO_REQUEST message in 'rq'. */
 979 struct ofpbuf *
 980 make_echo_reply(const struct ofp_header *rq)
 981 {
 982     size_t size = ntohs(rq->length);
 983     struct ofpbuf *out = ofpbuf_new(size);
 984     struct ofp_header *reply = ofpbuf_put(out, rq, size);
 985     reply->type = OFPT_ECHO_REPLY;
 986     return out;
 987 }
 988
 989 static int
 990 check_message_type(uint8_t got_type, uint8_t want_type)
 991 {
 992     if (got_type != want_type) {
 993         char *want_type_name = ofp_message_type_to_string(want_type);
 994         char *got_type_name = ofp_message_type_to_string(got_type);
 995         VLOG_WARN_RL(&bad_ofmsg_rl,
 996                      "received bad message type %s (expected %s)",
 997                      got_type_name, want_type_name);
 998         free(want_type_name);
 999         free(got_type_name);
1000         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE);
1001     }
1002     return 0;
1003 }
1004
1005 /* Checks that 'msg' has type 'type' and that it is exactly 'size' bytes long.
1006  * Returns 0 if the checks pass, otherwise an OpenFlow error code (produced
1007  * with ofp_mkerr()). */
1008 int
1009 check_ofp_message(const struct ofp_header *msg, uint8_t type, size_t size)
1010 {
1011     size_t got_size;
1012     int error;
1013
1014     error = check_message_type(msg->type, type);
1015     if (error) {
1016         return error;
1017     }
1018
1019     got_size = ntohs(msg->length);
1020     if (got_size != size) {
1021         char *type_name = ofp_message_type_to_string(type);
1022         VLOG_WARN_RL(&bad_ofmsg_rl,
1023                      "received %s message of length %"PRIu16" (expected %zu)",
1024                      type_name, got_size, size);
1025         free(type_name);
1026         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
1027     }
1028
1029     return 0;
1030 }
1031
1032 /* Checks that 'msg' has type 'type' and that 'msg' is 'size' plus a
1033  * nonnegative integer multiple of 'array_elt_size' bytes long.  Returns 0 if
1034  * the checks pass, otherwise an OpenFlow error code (produced with
1035  * ofp_mkerr()).
1036  *
1037  * If 'n_array_elts' is nonnull, then '*n_array_elts' is set to the number of
1038  * 'array_elt_size' blocks in 'msg' past the first 'min_size' bytes, when
1039  * successful. */
1040 int
1041 check_ofp_message_array(const struct ofp_header *msg, uint8_t type,
1042                         size_t min_size, size_t array_elt_size,
1043                         size_t *n_array_elts)
1044 {
1045     size_t got_size;
1046     int error;
1047
1048     assert(array_elt_size);
1049
1050     error = check_message_type(msg->type, type);
1051     if (error) {
1052         return error;
1053     }
1054
1055     got_size = ntohs(msg->length);
1056     if (got_size < min_size) {
1057         char *type_name = ofp_message_type_to_string(type);
1058         VLOG_WARN_RL(&bad_ofmsg_rl, "received %s message of length %"PRIu16" "
1059                      "(expected at least %zu)",
1060                      type_name, got_size, min_size);
1061         free(type_name);
1062         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
1063     }
1064     if ((got_size - min_size) % array_elt_size) {
1065         char *type_name = ofp_message_type_to_string(type);
1066         VLOG_WARN_RL(&bad_ofmsg_rl,
1067                      "received %s message of bad length %"PRIu16": the "
1068                      "excess over %zu (%zu) is not evenly divisible by %zu "
1069                      "(remainder is %zu)",
1070                      type_name, got_size, min_size, got_size - min_size,
1071                      array_elt_size, (got_size - min_size) % array_elt_size);
1072         free(type_name);
1073         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
1074     }
1075     if (n_array_elts) {
1076         *n_array_elts = (got_size - min_size) / array_elt_size;
1077     }
1078     return 0;
1079 }
1080
1081 int
1082 check_ofp_packet_out(const struct ofp_header *oh, struct ofpbuf *data,
1083                      int *n_actionsp, int max_ports)
1084 {
1085     const struct ofp_packet_out *opo;
1086     unsigned int actions_len, n_actions;
1087     size_t extra;
1088     int error;
1089
1090     *n_actionsp = 0;
1091     error = check_ofp_message_array(oh, OFPT_PACKET_OUT,
1092                                     sizeof *opo, 1, &extra);
1093     if (error) {
1094         return error;
1095     }
1096     opo = (const struct ofp_packet_out *) oh;
1097
1098     actions_len = ntohs(opo->actions_len);
1099     if (actions_len > extra) {
1100         VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out claims %zu bytes of actions "
1101                      "but message has room for only %zu bytes",
1102                      actions_len, extra);
1103         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
1104     }
1105     if (actions_len % sizeof(union ofp_action)) {
1106         VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out claims %zu bytes of actions, "
1107                      "which is not a multiple of %zu",
1108                      actions_len, sizeof(union ofp_action));
1109         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
1110     }
1111
1112     n_actions = actions_len / sizeof(union ofp_action);
1113     error = validate_actions((const union ofp_action *) opo->actions,
1114                              n_actions, max_ports);
1115     if (error) {
1116         return error;
1117     }
1118
1119     data->data = (void *) &opo->actions[n_actions];
1120     data->size = extra - actions_len;
1121     *n_actionsp = n_actions;
1122     return 0;
1123 }
1124
1125 const struct ofp_flow_stats *
1126 flow_stats_first(struct flow_stats_iterator *iter,
1127                  const struct ofp_stats_reply *osr)
1128 {
1129     iter->pos = osr->body;
1130     iter->end = osr->body + (ntohs(osr->header.length)
1131                              - offsetof(struct ofp_stats_reply, body));
1132     return flow_stats_next(iter);
1133 }
1134
1135 const struct ofp_flow_stats *
1136 flow_stats_next(struct flow_stats_iterator *iter)
1137 {
1138     ptrdiff_t bytes_left = iter->end - iter->pos;
1139     const struct ofp_flow_stats *fs;
1140     size_t length;
1141
1142     if (bytes_left < sizeof *fs) {
1143         if (bytes_left != 0) {
1144             VLOG_WARN_RL(&bad_ofmsg_rl,
1145                          "%td leftover bytes in flow stats reply", bytes_left);
1146         }
1147         return NULL;
1148     }
1149
1150     fs = (const void *) iter->pos;
1151     length = ntohs(fs->length);
1152     if (length < sizeof *fs) {
1153         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu is shorter than "
1154                      "min %zu", length, sizeof *fs);
1155         return NULL;
1156     } else if (length > bytes_left) {
1157         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu but only %td "
1158                      "bytes left", length, bytes_left);
1159         return NULL;
1160     } else if ((length - sizeof *fs) % sizeof fs->actions[0]) {
1161         VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu has %zu bytes "
1162                      "left over in final action", length,
1163                      (length - sizeof *fs) % sizeof fs->actions[0]);
1164         return NULL;
1165     }
1166     iter->pos += length;
1167     return fs;
1168 }
1169
1170 /* Alignment of ofp_actions. */
1171 #define ACTION_ALIGNMENT 8
1172
1173 static int
1174 check_action_exact_len(const union ofp_action *a, unsigned int len,
1175                        unsigned int required_len)
1176 {
1177     if (len != required_len) {
1178         VLOG_DBG_RL(&bad_ofmsg_rl,
1179                     "action %u has invalid length %"PRIu16" (must be %u)\n",
1180                     a->type, ntohs(a->header.len), required_len);
1181         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1182     }
1183     return 0;
1184 }
1185
1186 static int
1187 check_action_port(int port, int max_ports)
1188 {
1189     switch (port) {
1190     case OFPP_IN_PORT:
1191     case OFPP_TABLE:
1192     case OFPP_NORMAL:
1193     case OFPP_FLOOD:
1194     case OFPP_ALL:
1195     case OFPP_CONTROLLER:
1196     case OFPP_LOCAL:
1197         return 0;
1198
1199     default:
1200         if (port >= 0 && port < max_ports) {
1201             return 0;
1202         }
1203         VLOG_WARN_RL(&bad_ofmsg_rl, "unknown output port %x", port);
1204         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT);
1205     }
1206 }
1207
1208 static int
1209 check_nicira_action(const union ofp_action *a, unsigned int len)
1210 {
1211     const struct nx_action_header *nah;
1212
1213     if (len < 16) {
1214         VLOG_DBG_RL(&bad_ofmsg_rl,
1215                     "Nicira vendor action only %u bytes", len);
1216         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1217     }
1218     nah = (const struct nx_action_header *) a;
1219
1220     switch (ntohs(nah->subtype)) {
1221     case NXAST_RESUBMIT:
1222         return check_action_exact_len(a, len, 16);
1223     default:
1224         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE);
1225     }
1226 }
1227
1228 static int
1229 check_action(const union ofp_action *a, unsigned int len, int max_ports)
1230 {
1231     int error;
1232
1233     switch (a->type) {
1234     case OFPAT_OUTPUT:
1235         error = check_action_port(ntohs(a->output.port), max_ports);
1236         if (error) {
1237             return error;
1238         }
1239         return check_action_exact_len(a, len, 8);
1240
1241     case OFPAT_SET_VLAN_VID:
1242     case OFPAT_SET_VLAN_PCP:
1243     case OFPAT_STRIP_VLAN:
1244     case OFPAT_SET_NW_SRC:
1245     case OFPAT_SET_NW_DST:
1246     case OFPAT_SET_TP_SRC:
1247     case OFPAT_SET_TP_DST:
1248         return check_action_exact_len(a, len, 8);
1249
1250     case OFPAT_SET_DL_SRC:
1251     case OFPAT_SET_DL_DST:
1252         return check_action_exact_len(a, len, 16);
1253
1254     case OFPAT_VENDOR:
1255         if (a->vendor.vendor == htonl(NX_VENDOR_ID)) {
1256             return check_nicira_action(a, len);
1257         } else {
1258             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR);
1259         }
1260         break;
1261
1262     default:
1263         VLOG_WARN_RL(&bad_ofmsg_rl, "unknown action type %"PRIu16, a->type);
1264         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE);
1265     }
1266
1267     if (!len) {
1268         VLOG_DBG_RL(&bad_ofmsg_rl, "action has invalid length 0");
1269         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1270     }
1271     if (len % ACTION_ALIGNMENT) {
1272         VLOG_DBG_RL(&bad_ofmsg_rl, "action length %u is not a multiple of %d",
1273                     len, ACTION_ALIGNMENT);
1274         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1275     }
1276     return 0;
1277 }
1278
1279 int
1280 validate_actions(const union ofp_action *actions, size_t n_actions,
1281                  int max_ports)
1282 {
1283     const union ofp_action *a;
1284
1285     for (a = actions; a < &actions[n_actions]; ) {
1286         unsigned int len = ntohs(a->header.len);
1287         unsigned int n_slots = len / ACTION_ALIGNMENT;
1288         unsigned int slots_left = &actions[n_actions] - a;
1289         int error;
1290
1291         if (n_slots > slots_left) {
1292             VLOG_DBG_RL(&bad_ofmsg_rl,
1293                         "action requires %u slots but only %td remain",
1294                         n_slots, slots_left);
1295             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
1296         }
1297         error = check_action(a, len, max_ports);
1298         if (error) {
1299             return error;
1300         }
1301         a += n_slots;
1302     }
1303     return 0;
1304 }
1305
1306 /* The set of actions must either come from a trusted source or have been
1307  * previously validated with validate_actions(). */
1308 const union ofp_action *
1309 actions_first(struct actions_iterator *iter,
1310               const union ofp_action *oa, size_t n_actions)
1311 {
1312     iter->pos = oa;
1313     iter->end = oa + n_actions;
1314     return actions_next(iter);
1315 }
1316
1317 const union ofp_action *
1318 actions_next(struct actions_iterator *iter)
1319 {
1320     if (iter->pos < iter->end) {
1321         const union ofp_action *a = iter->pos;
1322         unsigned int len = ntohs(a->header.len);
1323         iter->pos += len / ACTION_ALIGNMENT;
1324         return a;
1325     } else {
1326         return NULL;
1327     }
1328 }
1329
1330 void
1331 normalize_match(struct ofp_match *m)
1332 {
1333     enum { OFPFW_NW = OFPFW_NW_SRC_MASK | OFPFW_NW_DST_MASK | OFPFW_NW_PROTO };
1334     enum { OFPFW_TP = OFPFW_TP_SRC | OFPFW_TP_DST };
1335     uint32_t wc;
1336
1337     wc = ntohl(m->wildcards) & OFPFW_ALL;
1338     if (wc & OFPFW_DL_TYPE) {
1339         m->dl_type = 0;
1340
1341         /* Can't sensibly m on network or transport headers if the
1342          * data link type is unknown. */
1343         wc |= OFPFW_NW | OFPFW_TP;
1344         m->nw_src = m->nw_dst = m->nw_proto = 0;
1345         m->tp_src = m->tp_dst = 0;
1346     } else if (m->dl_type == htons(ETH_TYPE_IP)) {
1347         if (wc & OFPFW_NW_PROTO) {
1348             m->nw_proto = 0;
1349
1350             /* Can't sensibly m on transport headers if the network
1351              * protocol is unknown. */
1352             wc |= OFPFW_TP;
1353             m->tp_src = m->tp_dst = 0;
1354         } else if (m->nw_proto == IPPROTO_TCP ||
1355                    m->nw_proto == IPPROTO_UDP ||
1356                    m->nw_proto == IPPROTO_ICMP) {
1357             if (wc & OFPFW_TP_SRC) {
1358                 m->tp_src = 0;
1359             }
1360             if (wc & OFPFW_TP_DST) {
1361                 m->tp_dst = 0;
1362             }
1363         } else {
1364             /* Transport layer fields will always be extracted as zeros, so we
1365              * can do an exact-m on those values.  */
1366             wc &= ~OFPFW_TP;
1367             m->tp_src = m->tp_dst = 0;
1368         }
1369         if (wc & OFPFW_NW_SRC_MASK) {
1370             m->nw_src &= flow_nw_bits_to_mask(wc, OFPFW_NW_SRC_SHIFT);
1371         }
1372         if (wc & OFPFW_NW_DST_MASK) {
1373             m->nw_dst &= flow_nw_bits_to_mask(wc, OFPFW_NW_DST_SHIFT);
1374         }
1375     } else {
1376         /* Network and transport layer fields will always be extracted as
1377          * zeros, so we can do an exact-m on those values. */
1378         wc &= ~(OFPFW_NW | OFPFW_TP);
1379         m->nw_proto = m->nw_src = m->nw_dst = 0;
1380         m->tp_src = m->tp_dst = 0;
1381     }
1382     if (wc & OFPFW_DL_SRC) {
1383         memset(m->dl_src, 0, sizeof m->dl_src);
1384     }
1385     if (wc & OFPFW_DL_DST) {
1386         memset(m->dl_dst, 0, sizeof m->dl_dst);
1387     }
1388     m->wildcards = htonl(wc);
1389 }
1390
1391 void
1392 vconn_init(struct vconn *vconn, struct vconn_class *class, int connect_status,
1393            const char *name, bool reconnectable)
1394 {
1395     vconn->class = class;
1396     vconn->state = (connect_status == EAGAIN ? VCS_CONNECTING
1397                     : !connect_status ? VCS_SEND_HELLO
1398                     : VCS_DISCONNECTED);
1399     vconn->error = connect_status;
1400     vconn->version = -1;
1401     vconn->min_version = -1;
1402     vconn->remote_ip = 0;
1403     vconn->remote_port = 0;
1404     vconn->local_ip = 0;
1405     vconn->local_port = 0;
1406     vconn->name = xstrdup(name);
1407     vconn->reconnectable = reconnectable;
1408 }
1409
1410 void
1411 vconn_set_remote_ip(struct vconn *vconn, uint32_t ip)
1412 {
1413     vconn->remote_ip = ip;
1414 }
1415
1416 void
1417 vconn_set_remote_port(struct vconn *vconn, uint16_t port)
1418 {
1419     vconn->remote_port = port;
1420 }
1421
1422 void
1423 vconn_set_local_ip(struct vconn *vconn, uint32_t ip)
1424 {
1425     vconn->local_ip = ip;
1426 }
1427
1428 void
1429 vconn_set_local_port(struct vconn *vconn, uint16_t port)
1430 {
1431     vconn->local_port = port;
1432 }
1433
1434 void
1435 pvconn_init(struct pvconn *pvconn, struct pvconn_class *class,
1436             const char *name)
1437 {
1438     pvconn->class = class;
1439     pvconn->name = xstrdup(name);
1440 }