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);
/*
- * 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.
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;
};
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);
* 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.
* 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);
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)
{
* 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.
* 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);
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;
*
* 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;
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;
}
}
* 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;
}
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;
return error;
}
- *new_vconnp = vconn_stream_new(stream, 0);
+ *new_vconnp = vconn_stream_new(stream, 0, pvconn->allowed_versions);
return 0;
}
*
* 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;
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) {
/* 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;
/* Success. */
assert(vconn->state != VCS_CONNECTING || vconn->class->connect);
- vconn->min_version = min_version;
*vconnp = vconn;
return 0;
}
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;
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);
}
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
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;
}
}
+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)
{
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);
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 {
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) {
{
enum vconn_state last_state;
- assert(vconn->min_version > 0);
do {
last_state = vconn->state;
switch (vconn->state) {
* 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;
check_vconn_classes();
+ if (!allowed_versions) {
+ allowed_versions = OFPUTIL_DEFAULT_VERSIONS;
+ }
+
/* Look up the class. */
error = pvconn_lookup_class(name, &class);
if (!class) {
/* 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;
*
* 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) {
} else {
assert((*new_vconn)->state != VCS_CONNECTING
|| (*new_vconn)->class->connect);
- (*new_vconn)->min_version = min_version;
}
return retval;
}
* 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
: 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;
}
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;
}
/* 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 *);
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 *);
/* 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
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;
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) {
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 {
struct pvconn *pvconn;
int error;
- error = pvconn_open(target, &pvconn, dscp);
+ error = pvconn_open(target, 0, &pvconn, dscp);
if (error) {
return error;
}
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);
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);
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);
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);
#include "vconn.h"
#include "vlog.h"
#include "socket-util.h"
+#include "ofp-util.h"
VLOG_DEFINE_THIS_MODULE(controller);
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);
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);
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);
{
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);
}
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)) {
projects / openvswitch / commitdiff