r11037:
[bbaumbach/samba-autobuild/.git] / source4 / lib / socket_wrapper / socket_wrapper.c
index 238155b26b17276aeac5c68b93182dd274b76904..1c3d5c3bfcb3663330d846f1ca24bf555518135e 100644 (file)
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-#ifdef _SAMBA_BUILD
+#ifdef _SAMBA_BUILD_
 #include "includes.h"
 #include "includes.h"
+#undef SOCKET_WRAPPER
 #include "system/network.h"
 #include "system/network.h"
+#include "system/filesys.h"
 #else
 #include <sys/types.h>
 #else
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <sys/socket.h>
 #include <errno.h>
 #include <sys/un.h>
 #include <sys/socket.h>
 #include <errno.h>
 #include <sys/un.h>
@@ -33,8 +36,8 @@
 #include <unistd.h>
 #include <string.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
 #include <stdio.h>
-#include "dlinklist.h"
 #endif
 #endif
+#include "dlinklist.h"
 
 /* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
  * for now */
 
 /* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
  * for now */
 #define real_close close
 #endif
 
 #define real_close close
 #endif
 
+/* we need to use a very terse format here as IRIX 6.4 silently
+   truncates names to 16 chars, so if we use a longer name then we
+   can't tell which port a packet came from with recvfrom() 
+   
+   with this format we have 8 chars left for the directory name
+*/
+#define SOCKET_FORMAT "%u_%u"
+
 static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
 {
        struct sockaddr *ret = (struct sockaddr *)malloc(len);
 static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
 {
        struct sockaddr *ret = (struct sockaddr *)malloc(len);
@@ -68,8 +79,10 @@ struct socket_info
        int domain;
        int type;
        int protocol;
        int domain;
        int type;
        int protocol;
+       int bound;
 
        char *path;
 
        char *path;
+       char *tmp_path;
 
        struct sockaddr *myname;
        socklen_t myname_len;
 
        struct sockaddr *myname;
        socklen_t myname_len;
@@ -78,7 +91,22 @@ struct socket_info
        socklen_t peername_len;
 
        struct socket_info *prev, *next;
        socklen_t peername_len;
 
        struct socket_info *prev, *next;
-} *sockets = NULL;
+};
+
+static struct socket_info *sockets = NULL;
+
+
+static const char *socket_wrapper_dir(void)
+{
+       const char *s = getenv("SOCKET_WRAPPER_DIR");
+       if (s == NULL) {
+               return NULL;
+       }
+       if (strncmp(s, "./", 2) == 0) {
+               s += 2;
+       }
+       return s;
+}
 
 static int convert_un_in(const struct sockaddr_un *un, struct sockaddr_in *in, socklen_t *len)
 {
 
 static int convert_un_in(const struct sockaddr_un *un, struct sockaddr_in *in, socklen_t *len)
 {
@@ -91,24 +119,34 @@ static int convert_un_in(const struct sockaddr_un *un, struct sockaddr_in *in, s
        }
 
        in->sin_family = AF_INET;
        }
 
        in->sin_family = AF_INET;
-       in->sin_port = 1025; /* Default to 1025 */
-       p = strchr(un->sun_path, '/');
+       in->sin_port = htons(1025); /* Default to 1025 */
+       p = strrchr(un->sun_path, '/');
        if (p) p++; else p = un->sun_path;
 
        if (p) p++; else p = un->sun_path;
 
-       if(sscanf(p, "sock_ip_%d_%u", &type, &prt) == 1) 
-       {
+       if (sscanf(p, SOCKET_FORMAT, &type, &prt) == 2) {
                in->sin_port = htons(prt);
        }
                in->sin_port = htons(prt);
        }
-       in->sin_addr.s_addr = INADDR_LOOPBACK;
+       in->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
        *len = sizeof(struct sockaddr_in);
        return 0;
 }
 
        *len = sizeof(struct sockaddr_in);
        return 0;
 }
 
-static int convert_in_un(int type, const struct sockaddr_in *in, struct sockaddr_un *un)
+static int convert_in_un(struct socket_info *si, const struct sockaddr_in *in, struct sockaddr_un *un)
 {
 {
+       int type = si->type;
        uint16_t prt = ntohs(in->sin_port);
        uint16_t prt = ntohs(in->sin_port);
-       /* FIXME: ENETUNREACH if in->sin_addr is not loopback */
-       snprintf(un->sun_path, sizeof(un->sun_path), "%s/sock_ip_%d_%u", getenv("SOCKET_WRAPPER_DIR"), type, prt);
+       if (prt == 0) {
+               struct stat st;
+               /* handle auto-allocation of ephemeral ports */
+               prt = 5000;
+               do {
+                       snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT, 
+                                socket_wrapper_dir(), type, ++prt);
+               } while (stat(un->sun_path, &st) == 0 && prt < 10000);
+               ((struct sockaddr_in *)si->myname)->sin_port = htons(prt);
+       } 
+       snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT, 
+                socket_wrapper_dir(), type, prt);
        return 0;
 }
 
        return 0;
 }
 
@@ -123,7 +161,7 @@ static struct socket_info *find_socket_info(int fd)
        return NULL;
 }
 
        return NULL;
 }
 
-static int sockaddr_convert_to_un(const struct socket_info *si, const struct sockaddr *in_addr, socklen_t in_len, 
+static int sockaddr_convert_to_un(struct socket_info *si, const struct sockaddr *in_addr, socklen_t in_len, 
                                         struct sockaddr_un *out_addr)
 {
        if (!out_addr)
                                         struct sockaddr_un *out_addr)
 {
        if (!out_addr)
@@ -133,7 +171,7 @@ static int sockaddr_convert_to_un(const struct socket_info *si, const struct soc
 
        switch (in_addr->sa_family) {
        case AF_INET:
 
        switch (in_addr->sa_family) {
        case AF_INET:
-               return convert_in_un(si->type, (const struct sockaddr_in *)in_addr, out_addr);
+               return convert_in_un(si, (const struct sockaddr_in *)in_addr, out_addr);
        case AF_UNIX:
                memcpy(out_addr, in_addr, sizeof(*out_addr));
                return 0;
        case AF_UNIX:
                memcpy(out_addr, in_addr, sizeof(*out_addr));
                return 0;
@@ -146,13 +184,19 @@ static int sockaddr_convert_to_un(const struct socket_info *si, const struct soc
 }
 
 static int sockaddr_convert_from_un(const struct socket_info *si, 
 }
 
 static int sockaddr_convert_from_un(const struct socket_info *si, 
-                                                                       const struct sockaddr_un *in_addr, 
-                                                                       int family,
-                                                struct sockaddr *out_addr,
-                                                socklen_t *out_len)
+                                   const struct sockaddr_un *in_addr, 
+                                   socklen_t un_addrlen,
+                                   int family,
+                                   struct sockaddr *out_addr,
+                                   socklen_t *out_len)
 {
 {
-       if (!out_addr) 
+       if (out_addr == NULL || out_len == NULL) 
+               return 0;
+
+       if (un_addrlen == 0) {
+               *out_len = 0;
                return 0;
                return 0;
+       }
 
        switch (family) {
        case AF_INET:
 
        switch (family) {
        case AF_INET:
@@ -174,17 +218,15 @@ int swrap_socket(int domain, int type, int protocol)
        struct socket_info *si;
        int fd;
 
        struct socket_info *si;
        int fd;
 
-       if (!getenv("SOCKET_WRAPPER_DIR")) {
+       if (!socket_wrapper_dir()) {
                return real_socket(domain, type, protocol);
        }
        
        fd = real_socket(AF_UNIX, type, 0);
 
                return real_socket(domain, type, protocol);
        }
        
        fd = real_socket(AF_UNIX, type, 0);
 
-       if (fd < 0) 
-               return fd;
+       if (fd == -1) return -1;
 
 
-       si = malloc(sizeof(struct socket_info));
-       memset(si, 0, sizeof(*si));
+       si = calloc(1, sizeof(struct socket_info));
 
        si->domain = domain;
        si->type = type;
 
        si->domain = domain;
        si->type = type;
@@ -209,28 +251,73 @@ int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
                return real_accept(s, addr, addrlen);
        }
 
                return real_accept(s, addr, addrlen);
        }
 
+       memset(&un_addr, 0, sizeof(un_addr));
+
        ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
        ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
-       if (ret < 0) return ret;
+       if (ret == -1) return ret;
 
        fd = ret;
 
 
        fd = ret;
 
-       ret = sockaddr_convert_from_un(parent_si, &un_addr, parent_si->domain, addr, addrlen);
-
-       if (ret < 0) return ret;
+       ret = sockaddr_convert_from_un(parent_si, &un_addr, un_addrlen,
+                                      parent_si->domain, addr, addrlen);
+       if (ret == -1) return ret;
 
        child_si = malloc(sizeof(struct socket_info));
        memset(child_si, 0, sizeof(*child_si));
 
        child_si->fd = fd;
 
        child_si = malloc(sizeof(struct socket_info));
        memset(child_si, 0, sizeof(*child_si));
 
        child_si->fd = fd;
+       child_si->bound = 1;
 
 
-       if (addr && addrlen) {
-               child_si->myname_len = *addrlen;
-               child_si->myname = sockaddr_dup(addr, *addrlen);
-       }
+       child_si->myname_len = parent_si->myname_len;
+       child_si->myname = sockaddr_dup(parent_si->myname, parent_si->myname_len);
+
+       child_si->peername_len = *addrlen;
+       child_si->peername = sockaddr_dup(addr, *addrlen);
+
+       DLIST_ADD(sockets, child_si);
 
        return fd;
 }
 
 
        return fd;
 }
 
+/* using sendto() or connect() on an unbound socket would give the
+   recipient no way to reply, as unlike UDP and TCP, a unix domain
+   socket can't auto-assign emphemeral port numbers, so we need to
+   assign it here */
+static int swrap_auto_bind(struct socket_info *si)
+{
+       struct sockaddr_un un_addr;
+       struct sockaddr_in in;
+       int i;
+       
+       un_addr.sun_family = AF_UNIX;
+       
+       for (i=0;i<1000;i++) {
+               snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), 
+                        "%s/"SOCKET_FORMAT, socket_wrapper_dir(),
+                        SOCK_DGRAM, i + 10000);
+               if (bind(si->fd, (struct sockaddr *)&un_addr, 
+                        sizeof(un_addr)) == 0) {
+                       si->tmp_path = strdup(un_addr.sun_path);
+                       si->bound = 1;
+                       break;
+               }
+       }
+       if (i == 1000) {
+               return -1;
+       }
+       
+       memset(&in, 0, sizeof(in));
+       in.sin_family = AF_INET;
+       in.sin_port   = htons(i);
+       in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+       
+       si->myname_len = sizeof(in);
+       si->myname = sockaddr_dup(&in, si->myname_len);
+       si->bound = 1;
+       return 0;
+}
+
+
 int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
 {
        int ret;
 int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
 {
        int ret;
@@ -241,14 +328,26 @@ int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
                return real_connect(s, serv_addr, addrlen);
        }
 
                return real_connect(s, serv_addr, addrlen);
        }
 
+       /* only allow pseudo loopback connections */
+       if (serv_addr->sa_family == AF_INET &&
+               ((const struct sockaddr_in *)serv_addr)->sin_addr.s_addr != 
+           htonl(INADDR_LOOPBACK)) {
+               errno = ENETUNREACH;
+               return -1;
+       }
+
+       if (si->bound == 0 && si->domain != AF_UNIX) {
+               ret = swrap_auto_bind(si);
+               if (ret == -1) return -1;
+       }
+
        ret = sockaddr_convert_to_un(si, (const struct sockaddr *)serv_addr, addrlen, &un_addr);
        ret = sockaddr_convert_to_un(si, (const struct sockaddr *)serv_addr, addrlen, &un_addr);
-       if (ret < 0) return ret;
+       if (ret == -1) return -1;
 
 
-       ret = real_connect(s, 
-                                          (struct sockaddr *)&un_addr, 
-                                          sizeof(struct sockaddr_un));
+       ret = real_connect(s, (struct sockaddr *)&un_addr, 
+                          sizeof(struct sockaddr_un));
 
 
-       if (ret >= 0) {
+       if (ret == 0) {
                si->peername_len = addrlen;
                si->peername = sockaddr_dup(serv_addr, addrlen);
        }
                si->peername_len = addrlen;
                si->peername = sockaddr_dup(serv_addr, addrlen);
        }
@@ -266,18 +365,24 @@ int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
                return real_bind(s, myaddr, addrlen);
        }
 
                return real_bind(s, myaddr, addrlen);
        }
 
+       si->myname_len = addrlen;
+       si->myname = sockaddr_dup(myaddr, addrlen);
+
+       if (myaddr->sa_family == AF_INET &&
+           ((const struct sockaddr_in *)myaddr)->sin_addr.s_addr == 0) {
+               ((struct sockaddr_in *)si->myname)->sin_addr.s_addr = 
+                       htonl(INADDR_LOOPBACK);
+       }
        ret = sockaddr_convert_to_un(si, (const struct sockaddr *)myaddr, addrlen, &un_addr);
        ret = sockaddr_convert_to_un(si, (const struct sockaddr *)myaddr, addrlen, &un_addr);
-       if (ret < 0) return ret;
+       if (ret == -1) return -1;
 
        unlink(un_addr.sun_path);
 
 
        unlink(un_addr.sun_path);
 
-       ret = real_bind(s, 
-                                       (struct sockaddr *)&un_addr,
-                                       sizeof(struct sockaddr_un));
+       ret = real_bind(s, (struct sockaddr *)&un_addr,
+                       sizeof(struct sockaddr_un));
 
 
-       if (ret >= 0) {
-               si->myname_len = addrlen;
-               si->myname = sockaddr_dup(myaddr, addrlen);
+       if (ret == 0) {
+               si->bound = 1;
        }
 
        return ret;
        }
 
        return ret;
@@ -308,7 +413,7 @@ int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
        struct socket_info *si = find_socket_info(s);
 
        if (!si) {
        struct socket_info *si = find_socket_info(s);
 
        if (!si) {
-               return real_getpeername(s, name, addrlen);
+               return real_getsockname(s, name, addrlen);
        }
 
        memcpy(name, si->myname, si->myname_len);
        }
 
        memcpy(name, si->myname, si->myname_len);
@@ -367,8 +472,8 @@ int swrap_setsockopt(int s, int  level,  int  optname,  const  void  *optval, so
 
 ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
 {
 
 ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
 {
-       socklen_t un_addrlen;
        struct sockaddr_un un_addr;
        struct sockaddr_un un_addr;
+       socklen_t un_addrlen = sizeof(un_addr);
        int ret;
        struct socket_info *si = find_socket_info(s);
 
        int ret;
        struct socket_info *si = find_socket_info(s);
 
@@ -376,15 +481,21 @@ ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr
                return real_recvfrom(s, buf, len, flags, from, fromlen);
        }
 
                return real_recvfrom(s, buf, len, flags, from, fromlen);
        }
 
+       /* irix 6.4 forgets to null terminate the sun_path string :-( */
+       memset(&un_addr, 0, sizeof(un_addr));
        ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
        ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
-       if (ret < 0
+       if (ret == -1
                return ret;
 
                return ret;
 
-       ret = sockaddr_convert_from_un(si, &un_addr, si->domain, from, fromlen);
+       if (sockaddr_convert_from_un(si, &un_addr, un_addrlen,
+                                    si->domain, from, fromlen) == -1) {
+               return -1;
+       }
        
        return ret;
 }
 
        
        return ret;
 }
 
+
 ssize_t swrap_sendto(int  s,  const  void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
 {
        struct sockaddr_un un_addr;
 ssize_t swrap_sendto(int  s,  const  void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
 {
        struct sockaddr_un un_addr;
@@ -395,12 +506,16 @@ ssize_t swrap_sendto(int  s,  const  void *buf, size_t len, int flags, const str
                return real_sendto(s, buf, len, flags, to, tolen);
        }
 
                return real_sendto(s, buf, len, flags, to, tolen);
        }
 
+       if (si->bound == 0 && si->domain != AF_UNIX) {
+               ret = swrap_auto_bind(si);
+               if (ret == -1) return -1;
+       }
+
        ret = sockaddr_convert_to_un(si, to, tolen, &un_addr);
        ret = sockaddr_convert_to_un(si, to, tolen, &un_addr);
-       if (ret < 0) 
-               return ret;
+       if (ret == -1) return -1;
 
        ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
 
        ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
-       
+
        return ret;
 }
 
        return ret;
 }
 
@@ -414,6 +529,10 @@ int swrap_close(int fd)
                free(si->path);
                free(si->myname);
                free(si->peername);
                free(si->path);
                free(si->myname);
                free(si->peername);
+               if (si->tmp_path) {
+                       unlink(si->tmp_path);
+                       free(si->tmp_path);
+               }
                free(si);
        }
 
                free(si);
        }