X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fsocket-util.c;h=939cd90ff8a8eef55cb809a775c424dadad9d4ac;hb=a0505c49dd98b393f4c47a423f325008443eb1ee;hp=935e7477771b494edcc09170c490492b1d62e913;hpb=dbba996be2f0d96f4d2999d51c4ef1d16809bad9;p=openvswitch

diff --git a/lib/socket-util.c b/lib/socket-util.c
index 935e7477..939cd90f 100644
--- a/lib/socket-util.c
+++ b/lib/socket-util.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010, 2011, 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.
@@ -17,6 +17,7 @@
 #include <config.h>
 #include "socket-util.h"
 #include <arpa/inet.h>
+#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <net/if.h>
@@ -59,6 +60,9 @@ VLOG_DEFINE_THIS_MODULE(socket_util);
 #define O_DIRECTORY 0
 #endif
 
+static int getsockopt_int(int fd, int level, int option, const char *optname,
+                          int *valuep);
+
 /* Sets 'fd' to non-blocking mode.  Returns 0 if successful, otherwise a
  * positive errno value. */
 int
@@ -78,6 +82,29 @@ set_nonblocking(int fd)
     }
 }
 
+void
+xset_nonblocking(int fd)
+{
+    if (set_nonblocking(fd)) {
+        exit(EXIT_FAILURE);
+    }
+}
+
+static int
+set_dscp(int fd, uint8_t dscp)
+{
+    if (dscp > 63) {
+        return EINVAL;
+    }
+
+    dscp = dscp << 2;
+    if (setsockopt(fd, IPPROTO_IP, IP_TOS, &dscp, sizeof dscp)) {
+        return errno;
+    }
+
+    return 0;
+}
+
 static bool
 rlim_is_finite(rlim_t limit)
 {
@@ -145,17 +172,46 @@ lookup_ipv6(const char *host_name, struct in6_addr *addr)
     return 0;
 }
 
+/* Translates 'host_name', which must be a host name or a string representation
+ * of an IP address, into a numeric IP address in '*addr'.  Returns 0 if
+ * successful, otherwise a positive errno value.
+ *
+ * Most Open vSwitch code should not use this because it causes deadlocks:
+ * gethostbyname() sends out a DNS request but that starts a new flow for which
+ * OVS must set up a flow, but it can't because it's waiting for a DNS reply.
+ * The synchronous lookup also delays other activty.  (Of course we can solve
+ * this but it doesn't seem worthwhile quite yet.)  */
+int
+lookup_hostname(const char *host_name, struct in_addr *addr)
+{
+    struct hostent *h;
+
+    if (inet_aton(host_name, addr)) {
+        return 0;
+    }
+
+    h = gethostbyname(host_name);
+    if (h) {
+        *addr = *(struct in_addr *) h->h_addr;
+        return 0;
+    }
+
+    return (h_errno == HOST_NOT_FOUND ? ENOENT
+            : h_errno == TRY_AGAIN ? EAGAIN
+            : h_errno == NO_RECOVERY ? EIO
+            : h_errno == NO_ADDRESS ? ENXIO
+            : EINVAL);
+}
+
 /* Returns the error condition associated with socket 'fd' and resets the
  * socket's error status. */
 int
 get_socket_error(int fd)
 {
     int error;
-    socklen_t len = sizeof(error);
-    if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
-        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 10);
+
+    if (getsockopt_int(fd, SOL_SOCKET, SO_ERROR, "SO_ERROR", &error)) {
         error = errno;
-        VLOG_ERR_RL(&rl, "getsockopt(SO_ERROR): %s", strerror(error));
     }
     return error;
 }
@@ -190,15 +246,13 @@ check_connection_completion(int fd)
 int
 drain_rcvbuf(int fd)
 {
-    socklen_t rcvbuf_len;
-    size_t rcvbuf;
+    int rcvbuf;
 
-    rcvbuf_len = sizeof rcvbuf;
-    if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, &rcvbuf_len) < 0) {
-        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 10);
-        VLOG_ERR_RL(&rl, "getsockopt(SO_RCVBUF) failed: %s", strerror(errno));
-        return errno;
+    rcvbuf = get_socket_rcvbuf(fd);
+    if (rcvbuf < 0) {
+        return -rcvbuf;
     }
+
     while (rcvbuf > 0) {
         /* In Linux, specifying MSG_TRUNC in the flags argument causes the
          * datagram length to be returned, even if that is longer than the
@@ -219,6 +273,18 @@ drain_rcvbuf(int fd)
     return 0;
 }
 
+/* Returns the size of socket 'sock''s receive buffer (SO_RCVBUF), or a
+ * negative errno value if an error occurs. */
+int
+get_socket_rcvbuf(int sock)
+{
+    int rcvbuf;
+    int error;
+
+    error = getsockopt_int(sock, SOL_SOCKET, SO_RCVBUF, "SO_RCVBUF", &rcvbuf);
+    return error ? -error : rcvbuf;
+}
+
 /* Reads and discards up to 'n' datagrams from 'fd', stopping as soon as no
  * more data can be immediately read.  ('fd' should therefore be in
  * non-blocking mode.)*/
@@ -326,12 +392,11 @@ bind_unix_socket(int fd, struct sockaddr *sun, socklen_t sun_len)
 /* Creates a Unix domain socket in the given 'style' (either SOCK_DGRAM or
  * SOCK_STREAM) that is bound to '*bind_path' (if 'bind_path' is non-null) and
  * connected to '*connect_path' (if 'connect_path' is non-null).  If 'nonblock'
- * is true, the socket is made non-blocking.  If 'passcred' is true, the socket
- * is configured to receive SCM_CREDENTIALS control messages.
+ * is true, the socket is made non-blocking.
  *
  * Returns the socket's fd if successful, otherwise a negative errno value. */
 int
-make_unix_socket(int style, bool nonblock, bool passcred OVS_UNUSED,
+make_unix_socket(int style, bool nonblock,
                  const char *bind_path, const char *connect_path)
 {
     int error;
@@ -399,16 +464,6 @@ make_unix_socket(int style, bool nonblock, bool passcred OVS_UNUSED,
         }
     }
 
-#ifdef SCM_CREDENTIALS
-    if (passcred) {
-        int enable = 1;
-        if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable))) {
-            error = errno;
-            goto error;
-        }
-    }
-#endif
-
     return fd;
 
 error:
@@ -416,7 +471,7 @@ error:
         error = EPROTO;
     }
     if (bind_path) {
-        fatal_signal_remove_file_to_unlink(bind_path);
+        fatal_signal_unlink_file_now(bind_path);
     }
     close(fd);
     return -error;
@@ -502,10 +557,14 @@ exit:
  * and stores -1 into '*fdp'.
  *
  * If 'sinp' is non-null, then on success the target address is stored into
- * '*sinp'. */
+ * '*sinp'.
+ *
+ * 'dscp' becomes the DSCP bits in the IP headers for the new connection.  It
+ * should be in the range [0, 63] and will automatically be shifted to the
+ * appropriately place in the IP tos field. */
 int
 inet_open_active(int style, const char *target, uint16_t default_port,
-                 struct sockaddr_in *sinp, int *fdp)
+                 struct sockaddr_in *sinp, int *fdp, uint8_t dscp)
 {
     struct sockaddr_in sin;
     int fd = -1;
@@ -526,37 +585,37 @@ inet_open_active(int style, const char *target, uint16_t default_port,
     }
     error = set_nonblocking(fd);
     if (error) {
-        goto exit_close;
+        goto exit;
+    }
+
+    /* The dscp bits must be configured before connect() to ensure that the TOS
+     * field is set during the connection establishment.  If set after
+     * connect(), the handshake SYN frames will be sent with a TOS of 0. */
+    error = set_dscp(fd, dscp);
+    if (error) {
+        VLOG_ERR("%s: socket: %s", target, strerror(error));
+        goto exit;
     }
 
     /* Connect. */
     error = connect(fd, (struct sockaddr *) &sin, sizeof sin) == 0 ? 0 : errno;
     if (error == EINPROGRESS) {
         error = EAGAIN;
-    } else if (error && error != EAGAIN) {
-        goto exit_close;
     }
 
-    /* Success: error is 0 or EAGAIN. */
-    goto exit;
-
-exit_close:
-    close(fd);
 exit:
     if (!error || error == EAGAIN) {
         if (sinp) {
             *sinp = sin;
         }
-        *fdp = fd;
-    } else {
-        *fdp = -1;
+    } else if (fd >= 0) {
+        close(fd);
     }
+    *fdp = fd;
     return error;
 }
 
-/* Opens a non-blocking IPv4 socket of the specified 'style', binds to
- * 'target', and listens for incoming connections.  'target' should be a string
- * in the format "[<port>][:<ip>]":
+/* Parses 'target', which should be a string in the format "[<port>][:<ip>]":
  *
  *      - If 'default_port' is -1, then <port> is required.  Otherwise, if
  *        <port> is omitted, then 'default_port' is used instead.
@@ -566,106 +625,141 @@ exit:
  *
  *      - If <ip> is omitted then the IP address is wildcarded.
  *
- * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP).
- *
- * For TCP, the socket will have SO_REUSEADDR turned on.
- *
- * On success, returns a non-negative file descriptor.  On failure, returns a
- * negative errno value.
- *
- * If 'sinp' is non-null, then on success the bound address is stored into
- * '*sinp'. */
-int
-inet_open_passive(int style, const char *target_, int default_port,
-                  struct sockaddr_in *sinp)
+ * If successful, stores the address into '*sinp' and returns true; otherwise
+ * zeros '*sinp' and returns false. */
+bool
+inet_parse_passive(const char *target_, int default_port,
+                   struct sockaddr_in *sinp)
 {
     char *target = xstrdup(target_);
     char *string_ptr = target;
-    struct sockaddr_in sin;
     const char *host_name;
     const char *port_string;
-    int fd = 0, error, port;
-    unsigned int yes  = 1;
+    bool ok = false;
+    int port;
 
     /* Address defaults. */
-    memset(&sin, 0, sizeof sin);
-    sin.sin_family = AF_INET;
-    sin.sin_addr.s_addr = htonl(INADDR_ANY);
-    sin.sin_port = htons(default_port);
+    memset(sinp, 0, sizeof *sinp);
+    sinp->sin_family = AF_INET;
+    sinp->sin_addr.s_addr = htonl(INADDR_ANY);
+    sinp->sin_port = htons(default_port);
 
     /* Parse optional port number. */
     port_string = strsep(&string_ptr, ":");
     if (port_string && str_to_int(port_string, 10, &port)) {
-        sin.sin_port = htons(port);
+        sinp->sin_port = htons(port);
     } else if (default_port < 0) {
         VLOG_ERR("%s: port number must be specified", target_);
-        error = EAFNOSUPPORT;
         goto exit;
     }
 
     /* Parse optional bind IP. */
     host_name = strsep(&string_ptr, ":");
-    if (host_name && host_name[0]) {
-        error = lookup_ip(host_name, &sin.sin_addr);
-        if (error) {
-            goto exit;
-        }
+    if (host_name && host_name[0] && lookup_ip(host_name, &sinp->sin_addr)) {
+        goto exit;
+    }
+
+    ok = true;
+
+exit:
+    if (!ok) {
+        memset(sinp, 0, sizeof *sinp);
+    }
+    free(target);
+    return ok;
+}
+
+
+/* Opens a non-blocking IPv4 socket of the specified 'style', binds to
+ * 'target', and listens for incoming connections.  Parses 'target' in the same
+ * way was inet_parse_passive().
+ *
+ * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP).
+ *
+ * For TCP, the socket will have SO_REUSEADDR turned on.
+ *
+ * On success, returns a non-negative file descriptor.  On failure, returns a
+ * negative errno value.
+ *
+ * If 'sinp' is non-null, then on success the bound address is stored into
+ * '*sinp'.
+ *
+ * 'dscp' becomes the DSCP bits in the IP headers for the new connection.  It
+ * should be in the range [0, 63] and will automatically be shifted to the
+ * appropriately place in the IP tos field. */
+int
+inet_open_passive(int style, const char *target, int default_port,
+                  struct sockaddr_in *sinp, uint8_t dscp)
+{
+    struct sockaddr_in sin;
+    int fd = 0, error;
+    unsigned int yes = 1;
+
+    if (!inet_parse_passive(target, default_port, &sin)) {
+        return -EAFNOSUPPORT;
     }
 
     /* Create non-blocking socket, set SO_REUSEADDR. */
     fd = socket(AF_INET, style, 0);
     if (fd < 0) {
         error = errno;
-        VLOG_ERR("%s: socket: %s", target_, strerror(error));
-        goto exit;
+        VLOG_ERR("%s: socket: %s", target, strerror(error));
+        return -error;
     }
     error = set_nonblocking(fd);
     if (error) {
-        goto exit_close;
+        goto error;
     }
     if (style == SOCK_STREAM
         && setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) < 0) {
         error = errno;
-        VLOG_ERR("%s: setsockopt(SO_REUSEADDR): %s", target_, strerror(error));
-        goto exit_close;
+        VLOG_ERR("%s: setsockopt(SO_REUSEADDR): %s", target, strerror(error));
+        goto error;
     }
 
     /* Bind. */
     if (bind(fd, (struct sockaddr *) &sin, sizeof sin) < 0) {
         error = errno;
-        VLOG_ERR("%s: bind: %s", target_, strerror(error));
-        goto exit_close;
+        VLOG_ERR("%s: bind: %s", target, strerror(error));
+        goto error;
+    }
+
+    /* The dscp bits must be configured before connect() to ensure that the TOS
+     * field is set during the connection establishment.  If set after
+     * connect(), the handshake SYN frames will be sent with a TOS of 0. */
+    error = set_dscp(fd, dscp);
+    if (error) {
+        VLOG_ERR("%s: socket: %s", target, strerror(error));
+        goto error;
     }
 
     /* Listen. */
-    if (listen(fd, 10) < 0) {
+    if (style == SOCK_STREAM && listen(fd, 10) < 0) {
         error = errno;
-        VLOG_ERR("%s: listen: %s", target_, strerror(error));
-        goto exit_close;
+        VLOG_ERR("%s: listen: %s", target, strerror(error));
+        goto error;
     }
 
     if (sinp) {
         socklen_t sin_len = sizeof sin;
         if (getsockname(fd, (struct sockaddr *) &sin, &sin_len) < 0){
             error = errno;
-            VLOG_ERR("%s: getsockname: %s", target_, strerror(error));
-            goto exit_close;
+            VLOG_ERR("%s: getsockname: %s", target, strerror(error));
+            goto error;
         }
         if (sin.sin_family != AF_INET || sin_len != sizeof sin) {
-            VLOG_ERR("%s: getsockname: invalid socket name", target_);
-            goto exit_close;
+            error = EAFNOSUPPORT;
+            VLOG_ERR("%s: getsockname: invalid socket name", target);
+            goto error;
         }
         *sinp = sin;
     }
 
-    error = 0;
-    goto exit;
+    return fd;
 
-exit_close:
+error:
     close(fd);
-exit:
-    free(target);
-    return error ? -error : fd;
+    return -error;
 }
 
 /* Returns a readable and writable fd for /dev/null, if successful, otherwise
@@ -796,13 +890,27 @@ xpipe(int fds[2])
 }
 
 static int
-getsockopt_int(int fd, int level, int optname, int *valuep)
+getsockopt_int(int fd, int level, int option, const char *optname, int *valuep)
 {
-    socklen_t len = sizeof *valuep;
+    static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 10);
+    socklen_t len;
+    int value;
+    int error;
 
-    return (getsockopt(fd, level, optname, valuep, &len) ? errno
-            : len == sizeof *valuep ? 0
-            : EINVAL);
+    len = sizeof value;
+    if (getsockopt(fd, level, option, &value, &len)) {
+        error = errno;
+        VLOG_ERR_RL(&rl, "getsockopt(%s): %s", optname, strerror(error));
+    } else if (len != sizeof value) {
+        error = EINVAL;
+        VLOG_ERR_RL(&rl, "getsockopt(%s): value is %u bytes (expected %zu)",
+                    optname, (unsigned int) len, sizeof value);
+    } else {
+        error = 0;
+    }
+
+    *valuep = error ? 0 : value;
+    return error;
 }
 
 static void
@@ -840,7 +948,8 @@ describe_sockaddr(struct ds *string, int fd,
 #define SO_PROTOCOL 38
 #endif
 
-            if (!getsockopt_int(fd, SOL_SOCKET, SO_PROTOCOL, &protocol)) {
+            if (!getsockopt_int(fd, SOL_SOCKET, SO_PROTOCOL, "SO_PROTOCOL",
+                                &protocol)) {
                 switch (protocol) {
                 case NETLINK_ROUTE:
                     ds_put_cstr(string, "NETLINK_ROUTE");