r6088: Add the socket_wrapper library. This is a very simple library that

redirects traffic (currently just IP traffic) over unix domain sockets
if the SOCKET_WRAPPER_DIR environment variable has been set.
Aim is to use this for the Samba4 torture suite on the buildfarm.

The socket_wrapper library can only be used if Samba was compiled with
--enable-developer.

test_rpc.sh passes against a local smbd with SOCKET_WRAPPER_DIR set.
(and ethereal showed no traffic whatsoever)

Stuff that still needs to be fixed in socketwrapper:
 - Give ENETUNREACH if target is not localhost
 - A given port number can only be used for UDP /or/ TCP, not both.
 - Perhaps allow some calls to circumvent socketwrapper (do we need DNS?)
(This used to be commit f8a63a843ccca092d9756b64e09175d37c08550a)

4 files changed, 463 insertions, 1 deletions

diff --git a/source4/include/system/network.h b/source4/include/system/network.h
index bad4339666..f661194831 100644
--- a/source4/include/system/network.h
+++ b/source4/include/system/network.h
@@ -57,6 +57,10 @@
 #include <net/if.h>
 #endif
 
+#ifdef DEVELOPER
+#define SOCKET_WRAPPER_REPLACE
+#include "lib/socket_wrapper.h"
+#endif
 
 #ifdef REPLACE_INET_NTOA
 #define inet_ntoa rep_inet_ntoa
diff --git a/source4/lib/basic.mk b/source4/lib/basic.mk
index 7d6847c465..560234a00c 100644
--- a/source4/lib/basic.mk
+++ b/source4/lib/basic.mk
@@ -33,6 +33,14 @@ ADD_OBJ_FILES = \
 ##############################
 
 ##############################
+# Start SUBSYSTEM SOCKET_WRAPPER
+[SUBSYSTEM::SOCKET_WRAPPER]
+NOPROTO = YES
+INIT_OBJ_FILES = lib/socket_wrapper.o
+# End SUBSYSTEM SOCKET_WRAPPER
+##############################
+
+##############################
 # Start SUBSYSTEM LIBBASIC
 [SUBSYSTEM::LIBBASIC]
 INIT_OBJ_FILES = lib/version.o
@@ -68,7 +76,8 @@ ADD_OBJ_FILES = \
 		lib/gendb.o \
 		lib/credentials.o
 REQUIRED_SUBSYSTEMS = \
-		LIBLDB CHARSET LIBREPLACE LIBNETIF LIBCRYPTO EXT_LIB_DL LIBTALLOC
+		LIBLDB CHARSET LIBREPLACE LIBNETIF LIBCRYPTO EXT_LIB_DL LIBTALLOC \
+		SOCKET_WRAPPER
 # End SUBSYSTEM LIBBASIC
 ##############################
 
diff --git a/source4/lib/socket_wrapper.c b/source4/lib/socket_wrapper.c
new file mode 100644
index 0000000000..5decde2cea
--- /dev/null
+++ b/source4/lib/socket_wrapper.c
@@ -0,0 +1,401 @@
+/* 
+   Socket wrapper library. Passes all socket communication over 
+   unix domain sockets if the environment variable SOCKET_WRAPPER_DIR 
+   is set.
+   Copyright (C) Jelmer Vernooij 2005
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifdef SAMBA_MAJOR_VERSION
+#include "includes.h"
+#include "system/network.h"
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <errno.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include "dlinklist.h"
+#endif
+
+/* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
+ * for now */
+#define REWRITE_CALLS 
+
+#ifdef REWRITE_CALLS
+#define real_accept accept
+#define real_connect connect
+#define real_bind bind
+#define real_getpeername getpeername
+#define real_getsockname getsockname
+#define real_getsockopt getsockopt
+#define real_setsockopt setsockopt
+#define real_recvfrom recvfrom
+#define real_sendto sendto
+#define real_socket socket
+#define real_close close
+#endif
+
+static struct sockaddr *memdup(const void *data, socklen_t len)
+{
+	struct sockaddr *ret = (struct sockaddr *)malloc(len);
+	memcpy(ret, data, len);
+	return ret;
+}
+
+struct socket_info
+{
+	int fd;
+
+	int domain;
+	int type;
+	int protocol;
+
+	char *path;
+
+	struct sockaddr *myname;
+	socklen_t myname_len;
+
+	struct sockaddr *peername;
+	socklen_t peername_len;
+
+	struct socket_info *prev, *next;
+} *sockets = NULL;
+
+static int convert_un_in(const struct sockaddr_un *un, struct sockaddr_in *in, socklen_t *len)
+{
+	unsigned int prt;
+	const char *p;
+
+	if ((*len) < sizeof(struct sockaddr_in)) {
+		return 0;
+	}
+
+	in->sin_family = AF_INET;
+	in->sin_port = 1025; /* Default to 1025 */
+	p = strchr(un->sun_path, '/');
+	if (p) p++; else p = un->sun_path;
+
+	if(sscanf(p, "sock_ip_%u", &prt) == 1) 
+	{
+		in->sin_port = htons(prt);
+	}
+	in->sin_addr.s_addr = INADDR_LOOPBACK;
+	*len = sizeof(struct sockaddr_in);
+	return 0;
+}
+
+static int convert_in_un(const struct sockaddr_in *in, struct sockaddr_un *un)
+{
+	uint16_t prt = ntohs(in->sin_port);
+	/* FIXME: ENETUNREACH if in->sin_addr is not loopback */
+	un->sun_family = AF_LOCAL;
+	snprintf(un->sun_path, sizeof(un->sun_path), "%s/sock_ip_%u", getenv("SOCKET_WRAPPER_DIR"), prt);
+	return 0;
+}
+
+static struct socket_info *find_socket_info(int fd)
+{
+	struct socket_info *i;
+	for (i = sockets; i; i = i->next) {
+		if (i->fd == fd) 
+			return i;
+	}
+
+	return NULL;
+}
+
+static int sockaddr_convert_to_un(const struct sockaddr *in_addr, socklen_t in_len, 
+					 struct sockaddr_un *out_addr)
+{
+	if (!out_addr)
+		return 0;
+
+	switch (in_addr->sa_family) {
+	case AF_INET:
+		return convert_in_un((const struct sockaddr_in *)in_addr, out_addr);
+	case AF_LOCAL:
+		memcpy(out_addr, in_addr, sizeof(*out_addr));
+		return 0;
+	default:
+		break;
+	}
+	
+	errno = EAFNOSUPPORT;
+	return -1;
+}
+
+static int sockaddr_convert_from_un(const struct sockaddr_un *in_addr, 
+									int family,
+					 	 struct sockaddr *out_addr,
+						 socklen_t *out_len)
+{
+	if (!out_addr) 
+		return 0;
+
+	switch (family) {
+	case AF_INET:
+		return convert_un_in(in_addr, (struct sockaddr_in *)out_addr, out_len);
+	case AF_LOCAL:
+		memcpy(out_addr, in_addr, sizeof(*in_addr));
+		*out_len = sizeof(*in_addr);
+		return 0;
+	default:
+		break;
+	}
+
+	errno = EAFNOSUPPORT;
+	return -1;
+}
+
+int swrap_socket(int domain, int type, int protocol)
+{
+	struct socket_info *si;
+	int fd;
+
+	if (!getenv("SOCKET_WRAPPER_DIR")) {
+		return real_socket(domain, type, protocol);
+	}
+	
+	fd = real_socket(PF_LOCAL, type, 0);
+
+	if (fd < 0) 
+		return fd;
+
+	si = malloc(sizeof(struct socket_info));
+	memset(si, 0, sizeof(*si));
+
+	si->domain = domain;
+	si->type = type;
+	si->protocol = protocol;
+	si->fd = fd;
+
+	DLIST_ADD(sockets, si);
+
+	return si->fd;
+}
+
+int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
+{
+	struct socket_info *parent_si, *child_si;
+	int fd;
+	socklen_t un_addrlen = sizeof(struct sockaddr_un);
+	struct sockaddr_un un_addr;
+	int ret;
+
+	parent_si = find_socket_info(s);
+	if (!parent_si) {
+		return real_accept(s, addr, addrlen);
+	}
+
+	ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
+	if (ret < 0) return ret;
+
+	fd = ret;
+
+	ret = sockaddr_convert_from_un(&un_addr, parent_si->domain, addr, addrlen);
+
+	if (ret < 0) return ret;
+
+	child_si = malloc(sizeof(struct socket_info));
+	memset(child_si, 0, sizeof(*child_si));
+
+	child_si->fd = fd;
+
+	if (addr && addrlen) {
+		child_si->myname_len = *addrlen;
+		child_si->myname = memdup(addr, *addrlen);
+	}
+
+	return fd;
+}
+
+int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
+{
+	int ret;
+	struct sockaddr_un un_addr;
+	struct socket_info *si = find_socket_info(s);
+
+	if (!si) {
+		return real_connect(s, serv_addr, addrlen);
+	}
+
+	ret = sockaddr_convert_to_un((const struct sockaddr *)serv_addr, addrlen, &un_addr);
+	if (ret < 0) return ret;
+
+	ret = real_connect(s, 
+					   (struct sockaddr *)&un_addr, 
+					   sizeof(struct sockaddr_un));
+
+	if (ret >= 0) {
+		si->peername_len = addrlen;
+		si->peername = memdup(serv_addr, addrlen);
+	}
+
+	return ret;
+}
+
+int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
+{
+	int ret;
+	struct sockaddr_un un_addr;
+	struct socket_info *si = find_socket_info(s);
+
+	if (!si) {
+		return real_bind(s, myaddr, addrlen);
+	}
+
+	ret = sockaddr_convert_to_un((const struct sockaddr *)myaddr, addrlen, &un_addr);
+	if (ret < 0) return ret;
+
+	unlink(un_addr.sun_path);
+
+	ret = real_bind(s, 
+					(struct sockaddr *)&un_addr,
+					sizeof(struct sockaddr_un));
+
+	if (ret >= 0) {
+		si->myname_len = addrlen;
+		si->myname = memdup(myaddr, addrlen);
+	}
+
+	return ret;
+}
+
+int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
+{
+	struct socket_info *si = find_socket_info(s);
+
+	if (!si) {
+		return real_getpeername(s, name, addrlen);
+	}
+
+	if (!si->peername) 
+	{
+		errno = ENOTCONN;
+		return -1;
+	}
+
+	memcpy(name, si->peername, si->peername_len);
+	*addrlen = si->peername_len;
+
+	return 0;
+}
+
+int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
+{
+	struct socket_info *si = find_socket_info(s);
+
+	if (!si) {
+		return real_getpeername(s, name, addrlen);
+	}
+
+	memcpy(name, si->myname, si->myname_len);
+	*addrlen = si->myname_len;
+
+	return 0;
+}
+
+int swrap_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
+{
+	struct socket_info *si = find_socket_info(s);
+
+	if (!si) {
+		return real_getsockopt(s, level, optname, optval, optlen);
+	}
+
+	if (level != SOL_SOCKET) {
+		errno = ENOPROTOOPT;
+		return -1;
+	}
+
+	return real_getsockopt(s, level, optname, optval, optlen);
+}
+
+int swrap_setsockopt(int s, int  level,  int  optname,  const  void  *optval, socklen_t optlen)
+{
+	struct socket_info *si = find_socket_info(s);
+
+	if (!si) {
+		return real_setsockopt(s, level, optname, optval, optlen);
+	}
+
+	if (level != SOL_SOCKET) {
+		errno = ENOPROTOOPT;
+		return -1;
+	}
+
+	return real_setsockopt(s, level, optname, optval, optlen);
+}
+
+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;
+	int ret;
+	struct socket_info *si = find_socket_info(s);
+
+	if (!si) {
+		return real_recvfrom(s, buf, len, flags, from, fromlen);
+	}
+
+	ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
+	if (ret < 0) 
+		return ret;
+
+	ret = sockaddr_convert_from_un(&un_addr, si->domain, from, fromlen);
+	
+	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;
+	int ret;
+	struct socket_info *si = find_socket_info(s);
+
+	if (!si) {
+		return real_sendto(s, buf, len, flags, to, tolen);
+	}
+
+	ret = sockaddr_convert_to_un(to, tolen, &un_addr);
+	if (ret < 0) 
+		return ret;
+
+	ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
+	
+	return ret;
+}
+
+int swrap_close(int fd)
+{
+	struct socket_info *si = find_socket_info(fd);
+
+	if (si) {
+		DLIST_REMOVE(sockets, si);
+
+		free(si->path);
+		free(si->myname);
+		free(si->peername);
+		free(si);
+	}
+
+	return real_close(fd);
+}
diff --git a/source4/lib/socket_wrapper.h b/source4/lib/socket_wrapper.h
new file mode 100644
index 0000000000..6da5a2980c
--- /dev/null
+++ b/source4/lib/socket_wrapper.h
@@ -0,0 +1,48 @@
+/* 
+   Copyright (C) Jelmer Vernooij 2005 <jelmer@samba.org>
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __SOCKET_WRAPPER_H__
+#define __SOCKET_WRAPPER_H__
+
+int swrap_socket(int domain, int type, int protocol);
+int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen);
+int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen);
+int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen);
+int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen);
+int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen);
+int swrap_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen);
+int swrap_setsockopt(int s, int  level,  int  optname,  const  void  *optval, socklen_t optlen);
+ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);
+ssize_t swrap_sendto(int  s,  const  void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);
+int swrap_close(int);
+
+#ifdef SOCKET_WRAPPER_REPLACE
+#define accept 				swrap_accept
+#define connect 			swrap_connect
+#define bind 				swrap_bind
+#define getpeername 		swrap_getpeername
+#define getsockname 		swrap_getsockname
+#define getsockopt 			swrap_getsockopt
+#define setsockopt 			swrap_setsockopt
+#define recvfrom 			swrap_recvfrom
+#define sendto 				swrap_sendto
+#define socket				swrap_socket
+#define close				swrap_close
+#endif
+
+#endif /* __SOCKET_WRAPPER_H__ */