vconn: Make errors in vconn names non-fatal errors.

[openvswitch] / lib / vconn.c

diff --git a/lib/vconn.c b/lib/vconn.c
index 6af60e7e847dee67c0a753fa85024ee4e24c00d4..103c9df58b20713c7008bd00eb2d92ca73c67acd 100644 (file)
--- a/lib/vconn.c
+++ b/lib/vconn.c
@@ -34,6 +34,7 @@
 #include "vconn.h"
 #include <assert.h>
 #include <errno.h>
+#include <inttypes.h>
 #include <netinet/in.h>
 #include <poll.h>
 #include <stdlib.h>
@@ -43,6 +44,7 @@
 #include "ofp-print.h"
 #include "openflow.h"
 #include "poll-loop.h"
+#include "random.h"
 #include "util.h"
 
 #define THIS_MODULE VLM_vconn
@@ -141,7 +143,8 @@ vconn_open(const char *name, struct vconn **vconnp)
 
     prefix_len = strcspn(name, ":");
     if (prefix_len == strlen(name)) {
-        fatal(0, "`%s' not correct format for peer name", name);
+        error(0, "`%s' not correct format for peer name", name);
+        return EAFNOSUPPORT;
     }
     for (i = 0; i < ARRAY_SIZE(vconn_classes); i++) {
         struct vconn_class *class = vconn_classes[i];
@@ -159,8 +162,8 @@ vconn_open(const char *name, struct vconn **vconnp)
             return retval;
         }
     }
-    fatal(0, "unknown peer type `%.*s'", (int) prefix_len, name);
-    abort();
+    error(0, "unknown peer type `%.*s'", (int) prefix_len, name);
+    return EAFNOSUPPORT;
 }
 
 int
@@ -204,6 +207,14 @@ vconn_is_passive(const struct vconn *vconn)
     return vconn->class->accept != NULL;
 }
 
+/* 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. */
+uint32_t
+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
@@ -282,6 +293,8 @@ vconn_send(struct vconn *vconn, struct buffer *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 {
@@ -322,6 +335,45 @@ vconn_recv_block(struct vconn *vconn, struct buffer **msgp)
     return retval;
 }
 
+/* Sends 'request' to 'vconn' and blocks until it receives a reply with a
+ * matching transaction ID.  Returns 0 if successful, in which case the reply
+ * is stored in '*replyp' for the caller to examine and free.  Otherwise
+ * returns a positive errno value, or EOF, and sets '*replyp' to null.
+ *
+ * 'request' is always destroyed, regardless of the return value. */
+int
+vconn_transact(struct vconn *vconn, struct buffer *request,
+               struct buffer **replyp)
+{
+    uint32_t send_xid = ((struct ofp_header *) request->data)->xid;
+    int error;
+
+    *replyp = NULL;
+    error = vconn_send_block(vconn, request);
+    if (error) {
+        buffer_delete(request);
+        return error;
+    }
+    for (;;) {
+        uint32_t recv_xid;
+        struct buffer *reply;
+
+        error = vconn_recv_block(vconn, &reply);
+        if (error) {
+            return error;
+        }
+        recv_xid = ((struct ofp_header *) reply->data)->xid;
+        if (send_xid == recv_xid) {
+            *replyp = reply;
+            return 0;
+        }
+
+        VLOG_DBG("received reply with xid %08"PRIx32" != expected %08"PRIx32,
+                 recv_xid, send_xid);
+        buffer_delete(reply);
+    }
+}
+
 void
 vconn_wait(struct vconn *vconn, enum vconn_wait_type wait)
 {
@@ -368,6 +420,48 @@ vconn_send_wait(struct vconn *vconn)
     vconn_wait(vconn, WAIT_SEND);
 }
 
+/* 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
+ * when it is no longer needed. */
+void *
+make_openflow(size_t openflow_len, uint8_t type, struct buffer **bufferp) 
+{
+    return make_openflow_xid(openflow_len, type, random_uint32(), bufferp);
+}
+
+/* Allocates and returns the first byte of a buffer 'openflow_len' bytes long,
+ * containing an OpenFlow header with the given 'type' and transaction id
+ * 'xid'.  Stores the new buffer in '*bufferp'.  The caller must free the
+ * buffer when it is no longer needed. */
+void *
+make_openflow_xid(size_t openflow_len, uint8_t type, uint32_t xid,
+                  struct buffer **bufferp)
+{
+    struct buffer *buffer;
+    struct ofp_header *oh;
+
+    assert(openflow_len >= sizeof *oh);
+    assert(openflow_len <= UINT16_MAX);
+    buffer = *bufferp = buffer_new(openflow_len);
+    oh = buffer_put_uninit(buffer, openflow_len);
+    memset(oh, 0, openflow_len);
+    oh->version = OFP_VERSION;
+    oh->type = type;
+    oh->length = htons(openflow_len);
+    oh->xid = xid;
+    return oh;
+}
+
+/* Updates the 'length' field of the OpenFlow message in 'buffer' to
+ * 'buffer->size'. */
+void
+update_openflow_length(struct buffer *buffer) 
+{
+    struct ofp_header *oh = buffer_at_assert(buffer, 0, sizeof *oh);
+    oh->length = htons(buffer->size); 
+}
+
 struct buffer *
 make_add_simple_flow(const struct flow *flow,
                      uint32_t buffer_id, uint16_t out_port, uint16_t max_idle)