X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fvconn.c;h=1c3b699ce06d19df68bffb1ab7065cf02915252b;hb=f593e3ab70ab06acbf97cbb0a9f897dc4f078011;hp=7162f6b34f252b90ebe4839e0ed627c97aff656d;hpb=a3d01200b1d94d54b6da7c34f6d56bd6da8465f4;p=sliver-openvswitch.git

diff --git a/lib/vconn.c b/lib/vconn.c
index 7162f6b34..1c3b699ce 100644
--- a/lib/vconn.c
+++ b/lib/vconn.c
@@ -40,6 +40,7 @@
 #include <poll.h>
 #include <stdlib.h>
 #include <string.h>
+#include "dynamic-string.h"
 #include "flow.h"
 #include "ofp-print.h"
 #include "ofpbuf.h"
@@ -51,18 +52,36 @@
 #define THIS_MODULE VLM_vconn
 #include "vlog.h"
 
+/* State of an active vconn.*/
+enum vconn_state {
+    /* This is the ordinary progression of states. */
+    VCS_CONNECTING,             /* Underlying vconn is not connected. */
+    VCS_SEND_HELLO,             /* Waiting to send OFPT_HELLO message. */
+    VCS_RECV_HELLO,             /* Waiting to receive OFPT_HELLO message. */
+    VCS_CONNECTED,              /* Connection established. */
+
+    /* These states are entered only when something goes wrong. */
+    VCS_SEND_ERROR,             /* Sending OFPT_ERROR message. */
+    VCS_DISCONNECTED            /* Connection failed or connection closed. */
+};
+
 static struct vconn_class *vconn_classes[] = {
     &tcp_vconn_class,
-    &ptcp_vconn_class,
+    &unix_vconn_class,
 #ifdef HAVE_NETLINK
     &netlink_vconn_class,
 #endif
 #ifdef HAVE_OPENSSL
     &ssl_vconn_class,
-    &pssl_vconn_class,
 #endif
-    &unix_vconn_class,
-    &punix_vconn_class,
+};
+
+static struct pvconn_class *pvconn_classes[] = {
+    &ptcp_pvconn_class,
+    &punix_pvconn_class,
+#ifdef HAVE_OPENSSL
+    &pssl_pvconn_class,
+#endif
 };
 
 /* High rate limit because most of the rate-limiting here is individual
@@ -70,6 +89,9 @@ static struct vconn_class *vconn_classes[] = {
  * really need to see them. */
 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(600, 600);
 
+static int do_recv(struct vconn *, struct ofpbuf **);
+static int do_send(struct vconn *, struct ofpbuf *);
+
 /* Check the validity of the vconn class structures. */
 static void
 check_vconn_classes(void)
@@ -81,12 +103,23 @@ check_vconn_classes(void)
         struct vconn_class *class = vconn_classes[i];
         assert(class->name != NULL);
         assert(class->open != NULL);
-        if (class->close || class->accept || class->recv || class->send
-            || class->wait) {
+        if (class->close || class->recv || class->send || class->wait) {
             assert(class->close != NULL);
-            assert(class->accept
-                   ? !class->recv && !class->send
-                   :  class->recv && class->send);
+            assert(class->recv != NULL);
+            assert(class->send != NULL);
+            assert(class->wait != NULL);
+        } else {
+            /* This class delegates to another one. */
+        }
+    }
+
+    for (i = 0; i < ARRAY_SIZE(pvconn_classes); i++) {
+        struct pvconn_class *class = pvconn_classes[i];
+        assert(class->name != NULL);
+        assert(class->listen != NULL);
+        if (class->close || class->accept || class->wait) {
+            assert(class->close != NULL);
+            assert(class->accept != NULL);
             assert(class->wait != NULL);
         } else {
             /* This class delegates to another one. */
@@ -143,14 +176,18 @@ vconn_usage(bool active, bool passive)
 }
 
 /* Attempts to connect to an OpenFlow device.  'name' is a connection name in
- * the form "TYPE:ARGS", where TYPE is the vconn class's name and ARGS are
- * vconn class-specific.
+ * the form "TYPE:ARGS", where TYPE is an active vconn class's name and ARGS
+ * are vconn class-specific.
+ *
+ * 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 OFP_VERSION.
  *
  * 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, struct vconn **vconnp)
+vconn_open(const char *name, int min_version, struct vconn **vconnp)
 {
     size_t prefix_len;
     size_t i;
@@ -160,7 +197,6 @@ vconn_open(const char *name, struct vconn **vconnp)
     *vconnp = NULL;
     prefix_len = strcspn(name, ":");
     if (prefix_len == strlen(name)) {
-        ofp_error(0, "`%s' not correct format for peer name", name);
         return EAFNOSUPPORT;
     }
     for (i = 0; i < ARRAY_SIZE(vconn_classes); i++) {
@@ -172,25 +208,24 @@ vconn_open(const char *name, struct vconn **vconnp)
             int retval = class->open(name, suffix_copy, &vconn);
             free(suffix_copy);
             if (!retval) {
-                assert(vconn->connect_status != EAGAIN
+                assert(vconn->state != VCS_CONNECTING
                        || vconn->class->connect);
-                vconn->name = xstrdup(name);
+                vconn->min_version = min_version;
                 *vconnp = vconn;
             }
             return retval;
         }
     }
-    ofp_error(0, "unknown peer type `%.*s'", (int) prefix_len, name);
     return EAFNOSUPPORT;
 }
 
 int
-vconn_open_block(const char *name, struct vconn **vconnp)
+vconn_open_block(const char *name, int min_version, struct vconn **vconnp)
 {
     struct vconn *vconn;
     int error;
 
-    error = vconn_open(name, &vconn);
+    error = vconn_open(name, min_version, &vconn);
     while (error == EAGAIN) {
         vconn_connect_wait(vconn);
         poll_block();
@@ -217,14 +252,11 @@ vconn_close(struct vconn *vconn)
     }
 }
 
-/* Returns true if 'vconn' is a passive vconn, that is, its purpose is to
- * wait for connections to arrive, not to transfer data.  Returns false if
- * 'vconn' is an active vconn, that is, its purpose is to transfer data, not
- * to wait for new connections to arrive. */
-bool
-vconn_is_passive(const struct vconn *vconn)
+/* Returns the name of 'vconn', that is, the string passed to vconn_open(). */
+const char *
+vconn_get_name(const struct vconn *vconn)
 {
-    return vconn->class->accept != NULL;
+    return vconn->name;
 }
 
 /* Returns the IP address of the peer, or 0 if the peer is not connected over
@@ -235,40 +267,157 @@ vconn_get_ip(const struct vconn *vconn)
     return vconn->ip;
 }
 
-/* Tries to complete the connection on 'vconn', which must be an active
- * vconn.  If 'vconn''s connection is complete, returns 0 if the connection
- * was successful or a positive errno value if it failed.  If the
- * connection is still in progress, returns EAGAIN. */
-int
-vconn_connect(struct vconn *vconn)
+static void
+vcs_connecting(struct vconn *vconn) 
 {
-    if (vconn->connect_status == EAGAIN) {
-        vconn->connect_status = (vconn->class->connect)(vconn);
-        assert(vconn->connect_status != EINPROGRESS);
+    int retval = (vconn->class->connect)(vconn);
+    assert(retval != EINPROGRESS);
+    if (!retval) {
+        vconn->state = VCS_SEND_HELLO;
+    } else if (retval != EAGAIN) {
+        vconn->state = VCS_DISCONNECTED;
+        vconn->error = retval;
     }
-    return vconn->connect_status;
 }
 
-/* Tries to accept a new connection on 'vconn', which must be a passive vconn.
- * If successful, stores the new connection in '*new_vconn' and returns 0.
- * Otherwise, returns a positive errno value.
- *
- * vconn_accept will not block waiting for a connection.  If no connection is
- * ready to be accepted, it returns EAGAIN immediately. */
-int
-vconn_accept(struct vconn *vconn, struct vconn **new_vconn)
+static void
+vcs_send_hello(struct vconn *vconn)
 {
+    struct ofpbuf *b;
     int retval;
 
-    retval = (vconn->class->accept)(vconn, new_vconn);
+    make_openflow(sizeof(struct ofp_header), OFPT_HELLO, &b);
+    retval = do_send(vconn, b);
+    if (!retval) {
+        vconn->state = VCS_RECV_HELLO;
+    } else {
+        ofpbuf_delete(b);
+        if (retval != EAGAIN) {
+            vconn->state = VCS_DISCONNECTED;
+            vconn->error = retval;
+        }
+    }
+}
+
+static void
+vcs_recv_hello(struct vconn *vconn)
+{
+    struct ofpbuf *b;
+    int retval;
 
+    retval = do_recv(vconn, &b);
+    if (!retval) {
+        struct ofp_header *oh = b->data;
+
+        if (oh->type == OFPT_HELLO) {
+            if (b->size > sizeof *oh) {
+                struct ds msg = DS_EMPTY_INITIALIZER;
+                ds_put_format(&msg, "%s: extra-long hello:\n", vconn->name);
+                ds_put_hex_dump(&msg, b->data, b->size, 0, true);
+                VLOG_WARN_RL(&rl, ds_cstr(&msg));
+                ds_destroy(&msg);
+            }
+
+            vconn->version = MIN(OFP_VERSION, oh->version);
+            if (vconn->version < vconn->min_version) {
+                VLOG_WARN_RL(&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, OFP_VERSION,
+                             oh->version);
+                vconn->state = VCS_SEND_ERROR;
+            } else {
+                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,
+                         OFP_VERSION, oh->version);
+                vconn->state = VCS_CONNECTED;
+            }
+            ofpbuf_delete(b);
+            return;
+        } else {
+            char *s = ofp_to_string(b->data, b->size, 1);
+            VLOG_WARN_RL(&rl, "%s: received message while expecting hello: %s",
+                         vconn->name, s);
+            free(s);
+            retval = EPROTO;
+            ofpbuf_delete(b);
+        }
+    }
+
+    if (retval != EAGAIN) {
+        vconn->state = VCS_DISCONNECTED;
+        vconn->error = retval;
+    }
+}
+
+static void
+vcs_send_error(struct vconn *vconn)
+{
+    struct ofp_error_msg *error;
+    struct ofpbuf *b;
+    char s[128];
+    int retval;
+
+    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, OFP_VERSION, vconn->version);
+    error = make_openflow(sizeof *error, OFPT_ERROR, &b);
+    error->type = htons(OFPET_HELLO_FAILED);
+    error->code = htons(OFPHFC_INCOMPATIBLE);
+    ofpbuf_put(b, s, strlen(s));
+    retval = do_send(vconn, b);
     if (retval) {
-        *new_vconn = NULL;
-    } else {
-        assert((*new_vconn)->connect_status != EAGAIN
-               || (*new_vconn)->class->connect);
+        ofpbuf_delete(b);
+    }
+    if (retval != EAGAIN) {
+        vconn->state = VCS_DISCONNECTED;
+        vconn->error = retval ? retval : EPROTO;
     }
-    return retval;
+}
+
+/* Tries to complete the connection on 'vconn', which must be an active
+ * vconn.  If 'vconn''s connection is complete, returns 0 if the connection
+ * was successful or a positive errno value if it failed.  If the
+ * connection is still in progress, returns EAGAIN. */
+int
+vconn_connect(struct vconn *vconn)
+{
+    enum vconn_state last_state;
+
+    assert(vconn->min_version >= 0);
+    do {
+        last_state = vconn->state;
+        switch (vconn->state) {
+        case VCS_CONNECTING:
+            vcs_connecting(vconn);
+            break;
+
+        case VCS_SEND_HELLO:
+            vcs_send_hello(vconn);
+            break;
+
+        case VCS_RECV_HELLO:
+            vcs_recv_hello(vconn);
+            break;
+
+        case VCS_CONNECTED:
+            return 0;
+
+        case VCS_SEND_ERROR:
+            vcs_send_error(vconn);
+            break;
+
+        case VCS_DISCONNECTED:
+            return vconn->error;
+
+        default:
+            NOT_REACHED();
+        }
+    } while (vconn->state != last_state);
+
+    return EAGAIN;
 }
 
 /* Tries to receive an OpenFlow message from 'vconn', which must be an active
@@ -284,25 +433,45 @@ vconn_recv(struct vconn *vconn, struct ofpbuf **msgp)
 {
     int retval = vconn_connect(vconn);
     if (!retval) {
-        retval = (vconn->class->recv)(vconn, msgp);
-        if (!retval) {
-            struct ofp_header *oh;
-
-            if (VLOG_IS_DBG_ENABLED()) {
-                char *s = ofp_to_string((*msgp)->data, (*msgp)->size, 1);
-                VLOG_DBG_RL(&rl, "%s: received: %s", vconn->name, s);
-                free(s);
-            }
+        retval = do_recv(vconn, msgp);
+    }
+    return retval;
+}
 
-            oh = ofpbuf_at_assert(*msgp, 0, sizeof *oh);
-            if (oh->version != OFP_VERSION) {
+static int
+do_recv(struct vconn *vconn, struct ofpbuf **msgp)
+{
+    int retval;
+
+    retval = (vconn->class->recv)(vconn, msgp);
+    if (!retval) {
+        struct ofp_header *oh;
+
+        if (VLOG_IS_DBG_ENABLED()) {
+            char *s = ofp_to_string((*msgp)->data, (*msgp)->size, 1);
+            VLOG_DBG_RL(&rl, "%s: received: %s", vconn->name, s);
+            free(s);
+        }
+
+        oh = ofpbuf_at_assert(*msgp, 0, sizeof *oh);
+        if (oh->version != vconn->version
+            && oh->type != OFPT_HELLO
+            && oh->type != OFPT_ERROR
+            && oh->type != OFPT_ECHO_REQUEST
+            && oh->type != OFPT_ECHO_REPLY
+            && oh->type != OFPT_VENDOR)
+        {
+            if (vconn->version < 0) {
+                VLOG_ERR_RL(&rl, "%s: received OpenFlow version %02"PRIx8" "
+                            "before version negotiation complete",
+                            vconn->name, oh->version);
+            } else {
                 VLOG_ERR_RL(&rl, "%s: received OpenFlow version %02"PRIx8" "
                             "!= expected %02x",
-                            vconn->name, oh->version, OFP_VERSION);
-                ofpbuf_delete(*msgp);
-                *msgp = NULL;
-                return EPROTO;
+                            vconn->name, oh->version, vconn->version);
             }
+            ofpbuf_delete(*msgp);
+            retval = EPROTO;
         }
     }
     if (retval) {
@@ -327,18 +496,28 @@ vconn_send(struct vconn *vconn, struct ofpbuf *msg)
 {
     int retval = vconn_connect(vconn);
     if (!retval) {
-        assert(msg->size >= sizeof(struct ofp_header));
-        assert(((struct ofp_header *) msg->data)->length == htons(msg->size));
-        if (!VLOG_IS_DBG_ENABLED()) { 
-            retval = (vconn->class->send)(vconn, msg);
-        } else {
-            char *s = ofp_to_string(msg->data, msg->size, 1);
-            retval = (vconn->class->send)(vconn, msg);
-            if (retval != EAGAIN) {
-                VLOG_DBG_RL(&rl, "%s: sent (%s): %s", vconn->name, strerror(retval), s);
-            }
-            free(s);
+        retval = do_send(vconn, msg);
+    }
+    return retval;
+}
+
+static int
+do_send(struct vconn *vconn, struct ofpbuf *msg)
+{
+    int retval;
+
+    assert(msg->size >= sizeof(struct ofp_header));
+    assert(((struct ofp_header *) msg->data)->length == htons(msg->size));
+    if (!VLOG_IS_DBG_ENABLED()) {
+        retval = (vconn->class->send)(vconn, msg);
+    } else {
+        char *s = ofp_to_string(msg->data, msg->size, 1);
+        retval = (vconn->class->send)(vconn, msg);
+        if (retval != EAGAIN) {
+            VLOG_DBG_RL(&rl, "%s: sent (%s): %s",
+                        vconn->name, strerror(retval), s);
         }
+        free(s);
     }
     return retval;
 }
@@ -409,22 +588,29 @@ vconn_transact(struct vconn *vconn, struct ofpbuf *request,
 void
 vconn_wait(struct vconn *vconn, enum vconn_wait_type wait)
 {
-    int connect_status;
+    assert(wait == WAIT_CONNECT || wait == WAIT_RECV || wait == WAIT_SEND);
 
-    assert(vconn_is_passive(vconn)
-           ? wait == WAIT_ACCEPT || wait == WAIT_CONNECT
-           : wait == WAIT_CONNECT || wait == WAIT_RECV || wait == WAIT_SEND);
+    switch (vconn->state) {
+    case VCS_CONNECTING:
+        wait = WAIT_CONNECT;
+        break;
 
-    connect_status = vconn_connect(vconn);
-    if (connect_status) {
-        if (connect_status == EAGAIN) {
-            wait = WAIT_CONNECT;
-        } else {
-            poll_immediate_wake();
-            return;
-        }
-    }
+    case VCS_SEND_HELLO:
+    case VCS_SEND_ERROR:
+        wait = WAIT_SEND;
+        break;
+
+    case VCS_RECV_HELLO:
+        wait = WAIT_RECV;
+        break;
+
+    case VCS_CONNECTED:
+        break;
 
+    case VCS_DISCONNECTED:
+        poll_immediate_wake();
+        return;
+    }
     (vconn->class->wait)(vconn, wait);
 }
 
@@ -434,12 +620,6 @@ vconn_connect_wait(struct vconn *vconn)
     vconn_wait(vconn, WAIT_CONNECT);
 }
 
-void
-vconn_accept_wait(struct vconn *vconn)
-{
-    vconn_wait(vconn, WAIT_ACCEPT);
-}
-
 void
 vconn_recv_wait(struct vconn *vconn)
 {
@@ -452,6 +632,83 @@ vconn_send_wait(struct vconn *vconn)
     vconn_wait(vconn, WAIT_SEND);
 }
 
+/* Attempts to start listening for OpenFlow connections.  'name' is a
+ * connection name in the form "TYPE:ARGS", where TYPE is an passive vconn
+ * class's name and ARGS are vconn class-specific.
+ *
+ * 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)
+{
+    size_t prefix_len;
+    size_t i;
+
+    check_vconn_classes();
+
+    *pvconnp = NULL;
+    prefix_len = strcspn(name, ":");
+    if (prefix_len == strlen(name)) {
+        return EAFNOSUPPORT;
+    }
+    for (i = 0; i < ARRAY_SIZE(pvconn_classes); i++) {
+        struct pvconn_class *class = pvconn_classes[i];
+        if (strlen(class->name) == prefix_len
+            && !memcmp(class->name, name, prefix_len)) {
+            char *suffix_copy = xstrdup(name + prefix_len + 1);
+            int retval = class->listen(name, suffix_copy, pvconnp);
+            free(suffix_copy);
+            if (retval) {
+                *pvconnp = NULL;
+            }
+            return retval;
+        }
+    }
+    return EAFNOSUPPORT;
+}
+
+/* Closes 'pvconn'. */
+void
+pvconn_close(struct pvconn *pvconn)
+{
+    if (pvconn != NULL) {
+        char *name = pvconn->name;
+        (pvconn->class->close)(pvconn);
+        free(name);
+    }
+}
+
+/* Tries to accept a new connection on 'pvconn'.  If successful, stores the new
+ * connection in '*new_vconn' and returns 0.  Otherwise, returns a positive
+ * errno value.
+ *
+ * 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 OFP_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)
+{
+    int retval = (pvconn->class->accept)(pvconn, new_vconn);
+    if (retval) {
+        *new_vconn = NULL;
+    } else {
+        assert((*new_vconn)->state != VCS_CONNECTING
+               || (*new_vconn)->class->connect);
+        (*new_vconn)->min_version = min_version;
+    }
+    return retval;
+}
+
+void
+pvconn_wait(struct pvconn *pvconn)
+{
+    (pvconn->class->wait)(pvconn);
+}
+
 /* Allocates and returns the first byte of a buffer 'openflow_len' bytes long,
  * containing an OpenFlow header with the given 'type' and a random transaction
  * id.  Stores the new buffer in '*bufferp'.  The caller must free the buffer
@@ -545,7 +802,7 @@ make_unbuffered_packet_out(const struct ofpbuf *packet,
     size_t size = sizeof *opo + sizeof opo->actions[0];
     struct ofpbuf *out = ofpbuf_new(size + packet->size);
     opo = ofpbuf_put_uninit(out, size);
-    memset(opo, 0, sizeof *opo);
+    memset(opo, 0, size);
     opo->header.version = OFP_VERSION;
     opo->header.type = OFPT_PACKET_OUT;
     opo->buffer_id = htonl(UINT32_MAX);
@@ -611,8 +868,20 @@ vconn_init(struct vconn *vconn, struct vconn_class *class, int connect_status,
            uint32_t ip, const char *name)
 {
     vconn->class = class;
-    vconn->connect_status = connect_status;
+    vconn->state = (connect_status == EAGAIN ? VCS_CONNECTING
+                    : !connect_status ? VCS_SEND_HELLO
+                    : VCS_DISCONNECTED);
+    vconn->error = connect_status;
+    vconn->version = -1;
+    vconn->min_version = -1;
     vconn->ip = ip;
     vconn->name = xstrdup(name);
 }
 
+void
+pvconn_init(struct pvconn *pvconn, struct pvconn_class *class,
+            const char *name)
+{
+    pvconn->class = class;
+    pvconn->name = xstrdup(name);
+}