diff options
| -rw-r--r-- | source4/include/system/network.h | 4 | ||||
| -rw-r--r-- | source4/lib/basic.mk | 11 | ||||
| -rw-r--r-- | source4/lib/socket_wrapper.c | 401 | ||||
| -rw-r--r-- | source4/lib/socket_wrapper.h | 48 |
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__ */ |