From: Simon Horman <horms@verge.net.au>
Date: Mon, 5 Nov 2012 05:41:02 +0000 (-0800)
Subject: vconn: Replace minimum version with bitmap of allowed versions.
X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=7a25bd99246a548891427d62ccefb65f765bbc48;p=openvswitch

vconn: Replace minimum version with bitmap of allowed versions.

This is in preparation for allowing the range of allowed OpenFlow versions
to be configured.

As part of this change pvconn_open() is now paramatised over the allowed
versions.  this is to avoid avoids needing to provide version information
as a parameter to pvconn_accept().  This will in turn avoid the need to
pass version information to connmgr_run().

Signed-off-by: Simon Horman <horms@verge.net.au>
[blp@nicira.com simplified slightly and generalize log messages]
Signed-off-by: Ben Pfaff <blp@nicira.com>
---

diff --git a/lib/rconn.c b/lib/rconn.c
index ddf578c1..5e5533ff 100644
--- a/lib/rconn.c
+++ b/lib/rconn.c
@@ -354,7 +354,7 @@ reconnect(struct rconn *rc)
         VLOG_INFO("%s: connecting...", rc->name);
     }
     rc->n_attempted_connections++;
-    retval = vconn_open(rc->target, OFP10_VERSION, &rc->vconn, rc->dscp);
+    retval = vconn_open(rc->target, 0, &rc->vconn, rc->dscp);
     if (!retval) {
         rc->remote_ip = vconn_get_remote_ip(rc->vconn);
         rc->local_ip = vconn_get_local_ip(rc->vconn);
diff --git a/lib/vconn-provider.h b/lib/vconn-provider.h
index 54ec2e6b..a26d9c55 100644
--- a/lib/vconn-provider.h
+++ b/lib/vconn-provider.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2009, 2010 Nicira, Inc.
+ * Copyright (c) 2008, 2009, 2010, 2012 Nicira, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,7 +33,8 @@ struct vconn {
     struct vconn_class *class;
     int state;
     int error;
-    enum ofp_version min_version;
+    uint32_t allowed_versions;
+    uint32_t peer_versions;
     enum ofp_version version;
     ovs_be32 remote_ip;
     ovs_be16 remote_port;
@@ -43,7 +44,8 @@ struct vconn {
 };
 
 void vconn_init(struct vconn *, struct vconn_class *, int connect_status,
-                const char *name);
+                const char *name, uint32_t allowed_versions);
+void vconn_free_data(struct vconn *vconn);
 void vconn_set_remote_ip(struct vconn *, ovs_be32 remote_ip);
 void vconn_set_remote_port(struct vconn *, ovs_be16 remote_port);
 void vconn_set_local_ip(struct vconn *, ovs_be32 local_ip);
@@ -62,6 +64,9 @@ struct vconn_class {
      * connection name provided by the user, e.g. "tcp:1.2.3.4".  This name is
      * useful for error messages but must not be modified.
      *
+     * 'allowed_verions' is the OpenFlow versions that may be
+     * negotiated for a connection.
+     *
      * 'suffix' is a copy of 'name' following the colon and may be modified.
      * 'dscp' is the DSCP value that the new connection should use in the IP
      * packets it sends.
@@ -73,8 +78,8 @@ struct vconn_class {
      * If the connection cannot be completed immediately, it should return
      * EAGAIN (not EINPROGRESS, as returned by the connect system call) and
      * continue the connection in the background. */
-    int (*open)(const char *name, char *suffix, struct vconn **vconnp,
-                uint8_t dscp);
+    int (*open)(const char *name, uint32_t allowed_versions,
+                char *suffix, struct vconn **vconnp, uint8_t dscp);
 
     /* Closes 'vconn' and frees associated memory. */
     void (*close)(struct vconn *vconn);
@@ -135,9 +140,11 @@ struct vconn_class {
 struct pvconn {
     struct pvconn_class *class;
     char *name;
+    uint32_t allowed_versions;
 };
 
-void pvconn_init(struct pvconn *, struct pvconn_class *, const char *name);
+void pvconn_init(struct pvconn *pvconn, struct pvconn_class *class,
+                 const char *name, uint32_t allowed_versions);
 static inline void pvconn_assert_class(const struct pvconn *pvconn,
                                        const struct pvconn_class *class)
 {
@@ -152,6 +159,9 @@ struct pvconn_class {
      * full connection name provided by the user, e.g. "ptcp:1234".  This name
      * is useful for error messages but must not be modified.
      *
+     * 'allowed_versions' is the OpenFlow protocol versions that may
+     * be negotiated for a session.
+     *
      * 'suffix' is a copy of 'name' following the colon and may be modified.
      * 'dscp' is the DSCP value that the new connection should use in the IP
      * packets it sends.
@@ -163,8 +173,8 @@ struct pvconn_class {
      * completed immediately, it should return EAGAIN (not EINPROGRESS, as
      * returned by the connect system call) and continue the connection in the
      * background. */
-    int (*listen)(const char *name, char *suffix, struct pvconn **pvconnp,
-                  uint8_t dscp);
+    int (*listen)(const char *name, uint32_t allowed_versions,
+                  char *suffix, struct pvconn **pvconnp, uint8_t dscp);
 
     /* Closes 'pvconn' and frees associated memory. */
     void (*close)(struct pvconn *pvconn);
diff --git a/lib/vconn-stream.c b/lib/vconn-stream.c
index d707e063..38ce3747 100644
--- a/lib/vconn-stream.c
+++ b/lib/vconn-stream.c
@@ -54,13 +54,14 @@ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(10, 25);
 static void vconn_stream_clear_txbuf(struct vconn_stream *);
 
 static struct vconn *
-vconn_stream_new(struct stream *stream, int connect_status)
+vconn_stream_new(struct stream *stream, int connect_status,
+                 uint32_t allowed_versions)
 {
     struct vconn_stream *s;
 
     s = xmalloc(sizeof *s);
     vconn_init(&s->vconn, &stream_vconn_class, connect_status,
-               stream_get_name(stream));
+               stream_get_name(stream), allowed_versions);
     s->stream = stream;
     s->txbuf = NULL;
     s->rxbuf = NULL;
@@ -77,8 +78,8 @@ vconn_stream_new(struct stream *stream, int connect_status)
  *
  * Returns 0 if successful, otherwise a positive errno value. */
 static int
-vconn_stream_open(const char *name, char *suffix OVS_UNUSED,
-                  struct vconn **vconnp, uint8_t dscp)
+vconn_stream_open(const char *name, uint32_t allowed_versions,
+                  char *suffix OVS_UNUSED, struct vconn **vconnp, uint8_t dscp)
 {
     struct stream *stream;
     int error;
@@ -88,7 +89,7 @@ vconn_stream_open(const char *name, char *suffix OVS_UNUSED,
     if (!error) {
         error = stream_connect(stream);
         if (!error || error == EAGAIN) {
-            *vconnp = vconn_stream_new(stream, error);
+            *vconnp = vconn_stream_new(stream, error, allowed_versions);
             return 0;
         }
     }
@@ -310,8 +311,9 @@ pvconn_pstream_cast(struct pvconn *pvconn)
  * Returns 0 if successful, otherwise a positive errno value.  (The current
  * implementation never fails.) */
 static int
-pvconn_pstream_listen(const char *name, char *suffix OVS_UNUSED,
-                      struct pvconn **pvconnp, uint8_t dscp)
+pvconn_pstream_listen(const char *name, uint32_t allowed_versions,
+                      char *suffix OVS_UNUSED, struct pvconn **pvconnp,
+                      uint8_t dscp)
 {
     struct pvconn_pstream *ps;
     struct pstream *pstream;
@@ -324,7 +326,7 @@ pvconn_pstream_listen(const char *name, char *suffix OVS_UNUSED,
     }
 
     ps = xmalloc(sizeof *ps);
-    pvconn_init(&ps->pvconn, &pstream_pvconn_class, name);
+    pvconn_init(&ps->pvconn, &pstream_pvconn_class, name, allowed_versions);
     ps->pstream = pstream;
     *pvconnp = &ps->pvconn;
     return 0;
@@ -354,7 +356,7 @@ pvconn_pstream_accept(struct pvconn *pvconn, struct vconn **new_vconnp)
         return error;
     }
 
-    *new_vconnp = vconn_stream_new(stream, 0);
+    *new_vconnp = vconn_stream_new(stream, 0, pvconn->allowed_versions);
     return 0;
 }
 
diff --git a/lib/vconn.c b/lib/vconn.c
index 9271f4f1..24a369d8 100644
--- a/lib/vconn.c
+++ b/lib/vconn.c
@@ -215,14 +215,16 @@ vconn_verify_name(const char *name)
  *
  * The vconn will automatically negotiate an OpenFlow protocol version
  * acceptable to both peers on the connection.  The version negotiated will be
- * no lower than 'min_version' and no higher than OFP10_VERSION.
+ * one of those in the 'allowed_versions' bitmap: version 'x' is allowed if
+ * allowed_versions & (1 << x) is nonzero.  If 'allowed_versions' is zero, then
+ * OFPUTIL_DEFAULT_VERSIONS are allowed.
  *
  * Returns 0 if successful, otherwise a positive errno value.  If successful,
  * stores a pointer to the new connection in '*vconnp', otherwise a null
  * pointer.  */
 int
-vconn_open(const char *name, int min_version, struct vconn **vconnp,
-           uint8_t dscp)
+vconn_open(const char *name, uint32_t allowed_versions,
+           struct vconn **vconnp, uint8_t dscp)
 {
     struct vconn_class *class;
     struct vconn *vconn;
@@ -232,6 +234,10 @@ vconn_open(const char *name, int min_version, struct vconn **vconnp,
     COVERAGE_INC(vconn_open);
     check_vconn_classes();
 
+    if (!allowed_versions) {
+        allowed_versions = OFPUTIL_DEFAULT_VERSIONS;
+    }
+
     /* Look up the class. */
     error = vconn_lookup_class(name, &class);
     if (!class) {
@@ -240,7 +246,7 @@ vconn_open(const char *name, int min_version, struct vconn **vconnp,
 
     /* Call class's "open" function. */
     suffix_copy = xstrdup(strchr(name, ':') + 1);
-    error = class->open(name, suffix_copy, &vconn, dscp);
+    error = class->open(name, allowed_versions, suffix_copy, &vconn, dscp);
     free(suffix_copy);
     if (error) {
         goto error;
@@ -248,7 +254,6 @@ vconn_open(const char *name, int min_version, struct vconn **vconnp,
 
     /* Success. */
     assert(vconn->state != VCS_CONNECTING || vconn->class->connect);
-    vconn->min_version = min_version;
     *vconnp = vconn;
     return 0;
 
@@ -290,7 +295,7 @@ vconn_run_wait(struct vconn *vconn)
 }
 
 int
-vconn_open_block(const char *name, enum ofp_version min_version,
+vconn_open_block(const char *name, uint32_t allowed_versions,
                  struct vconn **vconnp)
 {
     struct vconn *vconn;
@@ -298,7 +303,7 @@ vconn_open_block(const char *name, enum ofp_version min_version,
 
     fatal_signal_run();
 
-    error = vconn_open(name, min_version, &vconn, DSCP_DEFAULT);
+    error = vconn_open(name, allowed_versions, &vconn, DSCP_DEFAULT);
     if (!error) {
         error = vconn_connect_block(vconn);
     }
@@ -330,6 +335,14 @@ vconn_get_name(const struct vconn *vconn)
     return vconn->name;
 }
 
+/* Returns the allowed_versions of 'vconn', that is,
+ * the allowed_versions passed to vconn_open(). */
+uint32_t
+vconn_get_allowed_versions(const struct vconn *vconn)
+{
+    return vconn->allowed_versions;
+}
+
 /* Returns the IP address of the peer, or 0 if the peer is not connected over
  * an IP-based protocol or if its IP address is not yet known. */
 ovs_be32
@@ -393,7 +406,8 @@ vcs_send_hello(struct vconn *vconn)
     struct ofpbuf *b;
     int retval;
 
-    b = ofpraw_alloc(OFPRAW_OFPT_HELLO, OFP10_VERSION, 0);
+    b = ofpraw_alloc(OFPRAW_OFPT_HELLO,
+                     leftmost_1bit_idx(vconn->allowed_versions), 0);
     retval = do_send(vconn, b);
     if (!retval) {
         vconn->state = VCS_RECV_HELLO;
@@ -406,6 +420,28 @@ vcs_send_hello(struct vconn *vconn)
     }
 }
 
+static char *
+version_bitmap_to_string(uint32_t bitmap)
+{
+    struct ds s;
+
+    ds_init(&s);
+    if (!bitmap) {
+        ds_put_cstr(&s, "no versions");
+    } else if (is_pow2(bitmap)) {
+        ds_put_cstr(&s, "version ");
+        ofputil_format_version(&s, leftmost_1bit_idx(bitmap));
+    } else if (is_pow2((bitmap >> 1) + 1)) {
+        ds_put_cstr(&s, "version ");
+        ofputil_format_version(&s, leftmost_1bit_idx(bitmap));
+        ds_put_cstr(&s, "and earlier");
+    } else {
+        ds_put_cstr(&s, "versions ");
+        ofputil_format_version_bitmap(&s, bitmap);
+    }
+    return ds_steal_cstr(&s);
+}
+
 static void
 vcs_recv_hello(struct vconn *vconn)
 {
@@ -420,6 +456,9 @@ vcs_recv_hello(struct vconn *vconn)
 
         error = ofptype_decode(&type, b->data);
         if (!error && type == OFPTYPE_HELLO) {
+            char *peer_s, *local_s;
+            uint32_t common_versions;
+
             if (b->size > sizeof *oh) {
                 struct ds msg = DS_EMPTY_INITIALIZER;
                 ds_put_format(&msg, "%s: extra-long hello:\n", vconn->name);
@@ -428,23 +467,28 @@ vcs_recv_hello(struct vconn *vconn)
                 ds_destroy(&msg);
             }
 
-            vconn->version = MIN(OFP10_VERSION, oh->version);
-            if (vconn->version < vconn->min_version) {
+            local_s = version_bitmap_to_string(vconn->allowed_versions);
+            peer_s = version_bitmap_to_string(vconn->peer_versions);
+
+            common_versions = vconn->peer_versions & vconn->allowed_versions;
+            if (!common_versions) {
+                vconn->version = leftmost_1bit_idx(vconn->peer_versions);
                 VLOG_WARN_RL(&bad_ofmsg_rl,
-                             "%s: version negotiation failed: we support "
-                             "versions 0x%02x to 0x%02x inclusive but peer "
-                             "supports no later than version 0x%02"PRIx8,
-                             vconn->name, vconn->min_version, OFP10_VERSION,
-                             oh->version);
+                             "%s: version negotiation failed (we support "
+                             "%s, peer supports %s)",
+                             vconn->name, local_s, peer_s);
                 vconn->state = VCS_SEND_ERROR;
             } else {
+                vconn->version = leftmost_1bit_idx(common_versions);
                 VLOG_DBG("%s: negotiated OpenFlow version 0x%02x "
-                         "(we support versions 0x%02x to 0x%02x inclusive, "
-                         "peer no later than version 0x%02"PRIx8")",
-                         vconn->name, vconn->version, vconn->min_version,
-                         OFP10_VERSION, oh->version);
+                         "(we support %s, peer supports %s)", vconn->name,
+                         vconn->version, local_s, peer_s);
                 vconn->state = VCS_CONNECTED;
             }
+
+            free(local_s);
+            free(peer_s);
+
             ofpbuf_delete(b);
             return;
         } else {
@@ -470,10 +514,15 @@ vcs_send_error(struct vconn *vconn)
     struct ofpbuf *b;
     char s[128];
     int retval;
+    char *local_s, *peer_s;
+
+    local_s = version_bitmap_to_string(vconn->allowed_versions);
+    peer_s = version_bitmap_to_string(vconn->peer_versions);
+    snprintf(s, sizeof s, "We support %s, you support %s, no common versions.",
+             local_s, peer_s);
+    free(peer_s);
+    free(local_s);
 
-    snprintf(s, sizeof s, "We support versions 0x%02x to 0x%02x inclusive but "
-             "you support no later than version 0x%02"PRIx8".",
-             vconn->min_version, OFP12_VERSION, vconn->version);
     b = ofperr_encode_hello(OFPERR_OFPHFC_INCOMPATIBLE, vconn->version, s);
     retval = do_send(vconn, b);
     if (retval) {
@@ -494,7 +543,6 @@ vconn_connect(struct vconn *vconn)
 {
     enum vconn_state last_state;
 
-    assert(vconn->min_version > 0);
     do {
         last_state = vconn->state;
         switch (vconn->state) {
@@ -921,11 +969,18 @@ pvconn_verify_name(const char *name)
  * connection name in the form "TYPE:ARGS", where TYPE is an passive vconn
  * class's name and ARGS are vconn class-specific.
  *
+ * vconns accepted by the pvconn will automatically negotiate an OpenFlow
+ * protocol version acceptable to both peers on the connection.  The version
+ * negotiated will be one of those in the 'allowed_versions' bitmap: version
+ * 'x' is allowed if allowed_versions & (1 << x) is nonzero.  If
+ * 'allowed_versions' is zero, then OFPUTIL_DEFAULT_VERSIONS are allowed.
+ *
  * Returns 0 if successful, otherwise a positive errno value.  If successful,
  * stores a pointer to the new connection in '*pvconnp', otherwise a null
  * pointer.  */
 int
-pvconn_open(const char *name, struct pvconn **pvconnp, uint8_t dscp)
+pvconn_open(const char *name, uint32_t allowed_versions,
+            struct pvconn **pvconnp, uint8_t dscp)
 {
     struct pvconn_class *class;
     struct pvconn *pvconn;
@@ -934,6 +989,10 @@ pvconn_open(const char *name, struct pvconn **pvconnp, uint8_t dscp)
 
     check_vconn_classes();
 
+    if (!allowed_versions) {
+        allowed_versions = OFPUTIL_DEFAULT_VERSIONS;
+    }
+
     /* Look up the class. */
     error = pvconn_lookup_class(name, &class);
     if (!class) {
@@ -942,7 +1001,7 @@ pvconn_open(const char *name, struct pvconn **pvconnp, uint8_t dscp)
 
     /* Call class's "open" function. */
     suffix_copy = xstrdup(strchr(name, ':') + 1);
-    error = class->listen(name, suffix_copy, &pvconn, dscp);
+    error = class->listen(name, allowed_versions, suffix_copy, &pvconn, dscp);
     free(suffix_copy);
     if (error) {
         goto error;
@@ -982,12 +1041,12 @@ pvconn_close(struct pvconn *pvconn)
  *
  * The new vconn will automatically negotiate an OpenFlow protocol version
  * acceptable to both peers on the connection.  The version negotiated will be
- * no lower than 'min_version' and no higher than OFP10_VERSION.
+ * no lower than 'min_version' and no higher than 'max_version'.
  *
  * pvconn_accept() will not block waiting for a connection.  If no connection
  * is ready to be accepted, it returns EAGAIN immediately. */
 int
-pvconn_accept(struct pvconn *pvconn, int min_version, struct vconn **new_vconn)
+pvconn_accept(struct pvconn *pvconn, struct vconn **new_vconn)
 {
     int retval = (pvconn->class->accept)(pvconn, new_vconn);
     if (retval) {
@@ -995,7 +1054,6 @@ pvconn_accept(struct pvconn *pvconn, int min_version, struct vconn **new_vconn)
     } else {
         assert((*new_vconn)->state != VCS_CONNECTING
                || (*new_vconn)->class->connect);
-        (*new_vconn)->min_version = min_version;
     }
     return retval;
 }
@@ -1025,7 +1083,7 @@ pvconn_wait(struct pvconn *pvconn)
  * The caller retains ownership of 'name'. */
 void
 vconn_init(struct vconn *vconn, struct vconn_class *class, int connect_status,
-           const char *name)
+           const char *name, uint32_t allowed_versions)
 {
     vconn->class = class;
     vconn->state = (connect_status == EAGAIN ? VCS_CONNECTING
@@ -1033,7 +1091,7 @@ vconn_init(struct vconn *vconn, struct vconn_class *class, int connect_status,
                     : VCS_DISCONNECTED);
     vconn->error = connect_status;
     vconn->version = 0;
-    vconn->min_version = 0;
+    vconn->allowed_versions = allowed_versions;
     vconn->remote_ip = 0;
     vconn->remote_port = 0;
     vconn->local_ip = 0;
@@ -1067,9 +1125,10 @@ vconn_set_local_port(struct vconn *vconn, ovs_be16 port)
 }
 
 void
-pvconn_init(struct pvconn *pvconn, struct pvconn_class *class,
-            const char *name)
+pvconn_init(struct pvconn *pvconn,  struct pvconn_class *class,
+            const char *name, uint32_t allowed_versions)
 {
     pvconn->class = class;
     pvconn->name = xstrdup(name);
+    pvconn->allowed_versions = allowed_versions;
 }
diff --git a/lib/vconn.h b/lib/vconn.h
index 1a0bc60e..46ff17fa 100644
--- a/lib/vconn.h
+++ b/lib/vconn.h
@@ -34,10 +34,11 @@ void vconn_usage(bool active, bool passive, bool bootstrap);
 
 /* Active vconns: virtual connections to OpenFlow devices. */
 int vconn_verify_name(const char *name);
-int vconn_open(const char *name, int min_version,
-               struct vconn **, uint8_t dscp);
+int vconn_open(const char *name, uint32_t allowed_versions,
+               struct vconn **vconnp, uint8_t dscp);
 void vconn_close(struct vconn *);
 const char *vconn_get_name(const struct vconn *);
+uint32_t vconn_get_allowed_versions(const struct vconn *vconn);
 ovs_be32 vconn_get_remote_ip(const struct vconn *);
 ovs_be16 vconn_get_remote_port(const struct vconn *);
 ovs_be32 vconn_get_local_ip(const struct vconn *);
@@ -55,7 +56,7 @@ int vconn_transact_multiple_noreply(struct vconn *, struct list *requests,
 void vconn_run(struct vconn *);
 void vconn_run_wait(struct vconn *);
 
-int vconn_open_block(const char *name, enum ofp_version min_version,
+int vconn_open_block(const char *name, uint32_t allowed_versions,
                      struct vconn **);
 int vconn_connect_block(struct vconn *);
 int vconn_send_block(struct vconn *, struct ofpbuf *);
@@ -73,10 +74,11 @@ void vconn_send_wait(struct vconn *);
 
 /* Passive vconns: virtual listeners for incoming OpenFlow connections. */
 int pvconn_verify_name(const char *name);
-int pvconn_open(const char *name, struct pvconn **, uint8_t dscp);
+int pvconn_open(const char *name, uint32_t allowed_versions,
+                struct pvconn **pvconnp, uint8_t dscp);
 const char *pvconn_get_name(const struct pvconn *);
 void pvconn_close(struct pvconn *);
-int pvconn_accept(struct pvconn *, int min_version, struct vconn **);
+int pvconn_accept(struct pvconn *, struct vconn **);
 void pvconn_wait(struct pvconn *);
 
 #ifdef __cplusplus
diff --git a/ofproto/connmgr.c b/ofproto/connmgr.c
index 05e69c7f..5a0b0d3d 100644
--- a/ofproto/connmgr.c
+++ b/ofproto/connmgr.c
@@ -289,7 +289,7 @@ connmgr_run(struct connmgr *mgr,
         struct vconn *vconn;
         int retval;
 
-        retval = pvconn_accept(ofservice->pvconn, OFP10_VERSION, &vconn);
+        retval = pvconn_accept(ofservice->pvconn, &vconn);
         if (!retval) {
             struct rconn *rconn;
             char *name;
@@ -313,7 +313,7 @@ connmgr_run(struct connmgr *mgr,
         struct vconn *vconn;
         int retval;
 
-        retval = pvconn_accept(mgr->snoops[i], OFP10_VERSION, &vconn);
+        retval = pvconn_accept(mgr->snoops[i], &vconn);
         if (!retval) {
             add_snooper(mgr, vconn);
         } else if (retval != EAGAIN) {
@@ -720,8 +720,7 @@ set_pvconns(struct pvconn ***pvconnsp, size_t *n_pvconnsp,
     SSET_FOR_EACH (name, sset) {
         struct pvconn *pvconn;
         int error;
-
-        error = pvconn_open(name, &pvconn, 0);
+        error = pvconn_open(name, 0, &pvconn, 0);
         if (!error) {
             pvconns[n_pvconns++] = pvconn;
         } else {
@@ -1625,7 +1624,7 @@ ofservice_create(struct connmgr *mgr, const char *target, uint8_t dscp)
     struct pvconn *pvconn;
     int error;
 
-    error = pvconn_open(target, &pvconn, dscp);
+    error = pvconn_open(target, 0, &pvconn, dscp);
     if (error) {
         return error;
     }
diff --git a/tests/test-vconn.c b/tests/test-vconn.c
index 0b2b0635..11ff4920 100644
--- a/tests/test-vconn.c
+++ b/tests/test-vconn.c
@@ -148,8 +148,7 @@ test_refuse_connection(int argc OVS_UNUSED, char *argv[])
     int error;
 
     fpv_create(type, &fpv);
-    CHECK_ERRNO(vconn_open(fpv.vconn_name, OFP10_VERSION, &vconn,
-                           DSCP_DEFAULT), 0);
+    CHECK_ERRNO(vconn_open(fpv.vconn_name, 0, &vconn, DSCP_DEFAULT), 0);
     fpv_close(&fpv);
     vconn_run(vconn);
 
@@ -186,8 +185,7 @@ test_accept_then_close(int argc OVS_UNUSED, char *argv[])
     int error;
 
     fpv_create(type, &fpv);
-    CHECK_ERRNO(vconn_open(fpv.vconn_name, OFP10_VERSION, &vconn,
-                           DSCP_DEFAULT), 0);
+    CHECK_ERRNO(vconn_open(fpv.vconn_name, 0, &vconn, DSCP_DEFAULT), 0);
     vconn_run(vconn);
     stream_close(fpv_accept(&fpv));
     fpv_close(&fpv);
@@ -219,8 +217,7 @@ test_read_hello(int argc OVS_UNUSED, char *argv[])
     int error;
 
     fpv_create(type, &fpv);
-    CHECK_ERRNO(vconn_open(fpv.vconn_name, OFP10_VERSION, &vconn,
-                           DSCP_DEFAULT), 0);
+    CHECK_ERRNO(vconn_open(fpv.vconn_name, 0, &vconn, DSCP_DEFAULT), 0);
     vconn_run(vconn);
     stream = fpv_accept(&fpv);
     fpv_destroy(&fpv);
@@ -273,8 +270,7 @@ test_send_hello(const char *type, const void *out, size_t out_size,
     size_t n_sent;
 
     fpv_create(type, &fpv);
-    CHECK_ERRNO(vconn_open(fpv.vconn_name, OFP10_VERSION, &vconn,
-                           DSCP_DEFAULT), 0);
+    CHECK_ERRNO(vconn_open(fpv.vconn_name, 0, &vconn, DSCP_DEFAULT), 0);
     vconn_run(vconn);
     stream = fpv_accept(&fpv);
     fpv_destroy(&fpv);
diff --git a/utilities/ovs-controller.c b/utilities/ovs-controller.c
index 07e300bc..b1ba7c32 100644
--- a/utilities/ovs-controller.c
+++ b/utilities/ovs-controller.c
@@ -41,6 +41,7 @@
 #include "vconn.h"
 #include "vlog.h"
 #include "socket-util.h"
+#include "ofp-util.h"
 
 VLOG_DEFINE_THIS_MODULE(controller);
 
@@ -114,7 +115,7 @@ main(int argc, char *argv[])
         const char *name = argv[i];
         struct vconn *vconn;
 
-        retval = vconn_open(name, OFP10_VERSION, &vconn, DSCP_DEFAULT);
+        retval = vconn_open(name, 0, &vconn, DSCP_DEFAULT);
         if (!retval) {
             if (n_switches >= MAX_SWITCHES) {
                 ovs_fatal(0, "max %d switch connections", n_switches);
@@ -123,7 +124,7 @@ main(int argc, char *argv[])
             continue;
         } else if (retval == EAFNOSUPPORT) {
             struct pvconn *pvconn;
-            retval = pvconn_open(name, &pvconn, DSCP_DEFAULT);
+            retval = pvconn_open(name, 0, &pvconn, DSCP_DEFAULT);
             if (!retval) {
                 if (n_listeners >= MAX_LISTENERS) {
                     ovs_fatal(0, "max %d passive connections", n_listeners);
@@ -153,7 +154,7 @@ main(int argc, char *argv[])
         for (i = 0; i < n_listeners && n_switches < MAX_SWITCHES; ) {
             struct vconn *new_vconn;
 
-            retval = pvconn_accept(listeners[i], OFP10_VERSION, &new_vconn);
+            retval = pvconn_accept(listeners[i], &new_vconn);
             if (!retval || retval == EAGAIN) {
                 if (!retval) {
                     new_switch(&switches[n_switches++], new_vconn);
diff --git a/utilities/ovs-ofctl.c b/utilities/ovs-ofctl.c
index a67a5547..900c3d8d 100644
--- a/utilities/ovs-ofctl.c
+++ b/utilities/ovs-ofctl.c
@@ -336,7 +336,7 @@ open_vconn_socket(const char *name, struct vconn **vconnp)
 {
     char *vconn_name = xasprintf("unix:%s", name);
     VLOG_DBG("connecting to %s", vconn_name);
-    run(vconn_open_block(vconn_name, OFP10_VERSION, vconnp),
+    run(vconn_open_block(vconn_name, 0, vconnp),
         "connecting to %s", vconn_name);
     free(vconn_name);
 }
@@ -360,8 +360,7 @@ open_vconn__(const char *name, const char *default_suffix,
     free(datapath_type);
 
     if (strchr(name, ':')) {
-        run(vconn_open_block(name, OFP10_VERSION, vconnp),
-            "connecting to %s", name);
+        run(vconn_open_block(name, 0, vconnp), "connecting to %s", name);
     } else if (!stat(name, &s) && S_ISSOCK(s.st_mode)) {
         open_vconn_socket(name, vconnp);
     } else if (!stat(bridge_path, &s) && S_ISSOCK(s.st_mode)) {