From 7a25bd99246a548891427d62ccefb65f765bbc48 Mon Sep 17 00:00:00 2001 From: Simon Horman Date: Sun, 4 Nov 2012 21:41:02 -0800 Subject: [PATCH] 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 [blp@nicira.com simplified slightly and generalize log messages] Signed-off-by: Ben Pfaff --- lib/rconn.c | 2 +- lib/vconn-provider.h | 26 +++++--- lib/vconn-stream.c | 20 +++--- lib/vconn.c | 123 +++++++++++++++++++++++++++---------- lib/vconn.h | 12 ++-- ofproto/connmgr.c | 9 ++- tests/test-vconn.c | 12 ++-- utilities/ovs-controller.c | 7 ++- utilities/ovs-ofctl.c | 5 +- 9 files changed, 142 insertions(+), 74 deletions(-) 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)) { -- 2.30.2