2 Socket wrapper library. Passes all socket communication over
3 unix domain sockets if the environment variable SOCKET_WRAPPER_DIR
5 Copyright (C) Jelmer Vernooij 2005
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include "system/network.h"
26 #include <sys/types.h>
27 #include <sys/socket.h>
30 #include <netinet/in.h>
31 #include <netinet/tcp.h>
36 #include "dlinklist.h"
39 /* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
44 #define real_accept accept
45 #define real_connect connect
46 #define real_bind bind
47 #define real_getpeername getpeername
48 #define real_getsockname getsockname
49 #define real_getsockopt getsockopt
50 #define real_setsockopt setsockopt
51 #define real_recvfrom recvfrom
52 #define real_sendto sendto
53 #define real_socket socket
54 #define real_close close
57 static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
59 struct sockaddr *ret = (struct sockaddr *)malloc(len);
60 memcpy(ret, data, len);
76 struct sockaddr *myname;
79 struct sockaddr *peername;
80 socklen_t peername_len;
82 struct socket_info *prev, *next;
85 static struct socket_info *sockets = NULL;
87 static int convert_un_in(const struct sockaddr_un *un, struct sockaddr_in *in, socklen_t *len)
93 if ((*len) < sizeof(struct sockaddr_in)) {
97 in->sin_family = AF_INET;
98 in->sin_port = 1025; /* Default to 1025 */
99 p = strchr(un->sun_path, '/');
100 if (p) p++; else p = un->sun_path;
102 if (sscanf(p, "sock_ip_%d_%u", &type, &prt) == 2) {
103 in->sin_port = htons(prt);
105 in->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
106 *len = sizeof(struct sockaddr_in);
110 static int convert_in_un(int type, const struct sockaddr_in *in, struct sockaddr_un *un)
112 uint16_t prt = ntohs(in->sin_port);
113 snprintf(un->sun_path, sizeof(un->sun_path), "%s/sock_ip_%d_%u",
114 getenv("SOCKET_WRAPPER_DIR"), type, prt);
118 static struct socket_info *find_socket_info(int fd)
120 struct socket_info *i;
121 for (i = sockets; i; i = i->next) {
129 static int sockaddr_convert_to_un(const struct socket_info *si, const struct sockaddr *in_addr, socklen_t in_len,
130 struct sockaddr_un *out_addr)
135 out_addr->sun_family = AF_UNIX;
137 switch (in_addr->sa_family) {
139 return convert_in_un(si->type, (const struct sockaddr_in *)in_addr, out_addr);
141 memcpy(out_addr, in_addr, sizeof(*out_addr));
147 errno = EAFNOSUPPORT;
151 static int sockaddr_convert_from_un(const struct socket_info *si,
152 const struct sockaddr_un *in_addr,
153 socklen_t un_addrlen,
155 struct sockaddr *out_addr,
158 if (out_addr == NULL || out_len == NULL)
161 if (un_addrlen == 0) {
168 return convert_un_in(in_addr, (struct sockaddr_in *)out_addr, out_len);
170 memcpy(out_addr, in_addr, sizeof(*in_addr));
171 *out_len = sizeof(*in_addr);
177 errno = EAFNOSUPPORT;
181 int swrap_socket(int domain, int type, int protocol)
183 struct socket_info *si;
186 if (!getenv("SOCKET_WRAPPER_DIR")) {
187 return real_socket(domain, type, protocol);
190 fd = real_socket(AF_UNIX, type, 0);
192 if (fd == -1) return -1;
194 si = calloc(1, sizeof(struct socket_info));
198 si->protocol = protocol;
201 DLIST_ADD(sockets, si);
206 int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
208 struct socket_info *parent_si, *child_si;
210 socklen_t un_addrlen = sizeof(struct sockaddr_un);
211 struct sockaddr_un un_addr;
214 parent_si = find_socket_info(s);
216 return real_accept(s, addr, addrlen);
219 ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
220 if (ret == -1) return ret;
224 ret = sockaddr_convert_from_un(parent_si, &un_addr, un_addrlen,
225 parent_si->domain, addr, addrlen);
226 if (ret == -1) return ret;
228 child_si = malloc(sizeof(struct socket_info));
229 memset(child_si, 0, sizeof(*child_si));
233 if (addr && addrlen) {
234 child_si->myname_len = *addrlen;
235 child_si->myname = sockaddr_dup(addr, *addrlen);
241 int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
244 struct sockaddr_un un_addr;
245 struct socket_info *si = find_socket_info(s);
248 return real_connect(s, serv_addr, addrlen);
251 /* only allow pseudo loopback connections */
252 if (((const struct sockaddr_in *)serv_addr)->sin_addr.s_addr !=
253 htonl(INADDR_LOOPBACK)) {
258 ret = sockaddr_convert_to_un(si, (const struct sockaddr *)serv_addr, addrlen, &un_addr);
259 if (ret == -1) return -1;
261 ret = real_connect(s, (struct sockaddr *)&un_addr,
262 sizeof(struct sockaddr_un));
265 si->peername_len = addrlen;
266 si->peername = sockaddr_dup(serv_addr, addrlen);
272 int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
275 struct sockaddr_un un_addr;
276 struct socket_info *si = find_socket_info(s);
279 return real_bind(s, myaddr, addrlen);
282 ret = sockaddr_convert_to_un(si, (const struct sockaddr *)myaddr, addrlen, &un_addr);
283 if (ret == -1) return -1;
285 unlink(un_addr.sun_path);
287 ret = real_bind(s, (struct sockaddr *)&un_addr,
288 sizeof(struct sockaddr_un));
291 si->myname_len = addrlen;
292 si->myname = sockaddr_dup(myaddr, addrlen);
299 int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
301 struct socket_info *si = find_socket_info(s);
304 return real_getpeername(s, name, addrlen);
313 memcpy(name, si->peername, si->peername_len);
314 *addrlen = si->peername_len;
319 int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
321 struct socket_info *si = find_socket_info(s);
324 return real_getsockname(s, name, addrlen);
327 memcpy(name, si->myname, si->myname_len);
328 *addrlen = si->myname_len;
333 int swrap_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
335 struct socket_info *si = find_socket_info(s);
338 return real_getsockopt(s, level, optname, optval, optlen);
341 if (level == SOL_SOCKET) {
342 return real_getsockopt(s, level, optname, optval, optlen);
345 switch (si->domain) {
347 return real_getsockopt(s, level, optname, optval, optlen);
354 int swrap_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen)
356 struct socket_info *si = find_socket_info(s);
359 return real_setsockopt(s, level, optname, optval, optlen);
362 if (level == SOL_SOCKET) {
363 return real_setsockopt(s, level, optname, optval, optlen);
366 switch (si->domain) {
368 return real_setsockopt(s, level, optname, optval, optlen);
370 /* Silence some warnings */
372 if (optname == TCP_NODELAY)
381 ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
383 struct sockaddr_un un_addr;
384 socklen_t un_addrlen = sizeof(un_addr);
386 struct socket_info *si = find_socket_info(s);
389 return real_recvfrom(s, buf, len, flags, from, fromlen);
392 ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
396 if (sockaddr_convert_from_un(si, &un_addr, un_addrlen,
397 si->domain, from, fromlen) == -1) {
404 ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
406 struct sockaddr_un un_addr;
408 struct socket_info *si = find_socket_info(s);
411 return real_sendto(s, buf, len, flags, to, tolen);
414 /* using sendto() on an unbound DGRAM socket would give the
415 recipient no way to reply, as unlike UDP, a unix domain socket
416 can't auto-assign emphemeral port numbers, so we need to assign
418 if (si->bound == 0 && si->type == SOCK_DGRAM) {
421 un_addr.sun_family = AF_UNIX;
423 for (i=0;i<1000;i++) {
424 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path),
425 "%s/sock_ip_%u_%u", getenv("SOCKET_WRAPPER_DIR"),
426 SOCK_DGRAM, i + 10000);
427 if (bind(si->fd, (struct sockaddr *)&un_addr,
428 sizeof(un_addr)) == 0) {
429 si->tmp_path = strdup(un_addr.sun_path);
440 ret = sockaddr_convert_to_un(si, to, tolen, &un_addr);
441 if (ret == -1) return -1;
443 ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
448 int swrap_close(int fd)
450 struct socket_info *si = find_socket_info(fd);
453 DLIST_REMOVE(sockets, si);
459 unlink(si->tmp_path);
465 return real_close(fd);