r7913: prevent recursion in the socket wrapper code
[bbaumbach/samba-autobuild/.git] / source4 / lib / socket_wrapper / socket_wrapper.c
1 /* 
2    Socket wrapper library. Passes all socket communication over 
3    unix domain sockets if the environment variable SOCKET_WRAPPER_DIR 
4    is set.
5    Copyright (C) Jelmer Vernooij 2005
6    
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.
11    
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.
16    
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.
20 */
21
22 #ifdef _SAMBA_BUILD_
23 #include "includes.h"
24 #undef SOCKET_WRAPPER
25 #include "system/network.h"
26 #include "system/filesys.h"
27 #else
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <sys/socket.h>
31 #include <errno.h>
32 #include <sys/un.h>
33 #include <netinet/in.h>
34 #include <netinet/tcp.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <string.h>
38 #include <stdio.h>
39 #endif
40 #include "dlinklist.h"
41
42 /* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
43  * for now */
44 #define REWRITE_CALLS 
45
46 #ifdef REWRITE_CALLS
47 #define real_accept accept
48 #define real_connect connect
49 #define real_bind bind
50 #define real_getpeername getpeername
51 #define real_getsockname getsockname
52 #define real_getsockopt getsockopt
53 #define real_setsockopt setsockopt
54 #define real_recvfrom recvfrom
55 #define real_sendto sendto
56 #define real_socket socket
57 #define real_close close
58 #endif
59
60 static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
61 {
62         struct sockaddr *ret = (struct sockaddr *)malloc(len);
63         memcpy(ret, data, len);
64         return ret;
65 }
66
67 struct socket_info
68 {
69         int fd;
70
71         int domain;
72         int type;
73         int protocol;
74         int bound;
75
76         char *path;
77         char *tmp_path;
78
79         struct sockaddr *myname;
80         socklen_t myname_len;
81
82         struct sockaddr *peername;
83         socklen_t peername_len;
84
85         struct socket_info *prev, *next;
86 };
87
88 static struct socket_info *sockets = NULL;
89
90 static int convert_un_in(const struct sockaddr_un *un, struct sockaddr_in *in, socklen_t *len)
91 {
92         unsigned int prt;
93         const char *p;
94         int type;
95
96         if ((*len) < sizeof(struct sockaddr_in)) {
97                 return 0;
98         }
99
100         in->sin_family = AF_INET;
101         in->sin_port = htons(1025); /* Default to 1025 */
102         p = strrchr(un->sun_path, '/');
103         if (p) p++; else p = un->sun_path;
104
105         if (sscanf(p, "sock_ip_%d_%u", &type, &prt) == 2) {
106                 in->sin_port = htons(prt);
107         }
108         in->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
109         *len = sizeof(struct sockaddr_in);
110         return 0;
111 }
112
113 static int convert_in_un(struct socket_info *si, const struct sockaddr_in *in, struct sockaddr_un *un)
114 {
115         int type = si->type;
116         uint16_t prt = ntohs(in->sin_port);
117         if (prt == 0) {
118                 struct stat st;
119                 /* handle auto-allocation of ephemeral ports */
120                 prt = 5000;
121                 do {
122                         snprintf(un->sun_path, sizeof(un->sun_path), "%s/sock_ip_%d_%u", 
123                                  getenv("SOCKET_WRAPPER_DIR"), type, ++prt);
124                 } while (stat(un->sun_path, &st) == 0 && prt < 10000);
125                 ((struct sockaddr_in *)si->myname)->sin_port = htons(prt);
126         } 
127         snprintf(un->sun_path, sizeof(un->sun_path), "%s/sock_ip_%d_%u", 
128                  getenv("SOCKET_WRAPPER_DIR"), type, prt);
129         return 0;
130 }
131
132 static struct socket_info *find_socket_info(int fd)
133 {
134         struct socket_info *i;
135         for (i = sockets; i; i = i->next) {
136                 if (i->fd == fd) 
137                         return i;
138         }
139
140         return NULL;
141 }
142
143 static int sockaddr_convert_to_un(struct socket_info *si, const struct sockaddr *in_addr, socklen_t in_len, 
144                                          struct sockaddr_un *out_addr)
145 {
146         if (!out_addr)
147                 return 0;
148
149         out_addr->sun_family = AF_UNIX;
150
151         switch (in_addr->sa_family) {
152         case AF_INET:
153                 return convert_in_un(si, (const struct sockaddr_in *)in_addr, out_addr);
154         case AF_UNIX:
155                 memcpy(out_addr, in_addr, sizeof(*out_addr));
156                 return 0;
157         default:
158                 break;
159         }
160         
161         errno = EAFNOSUPPORT;
162         return -1;
163 }
164
165 static int sockaddr_convert_from_un(const struct socket_info *si, 
166                                     const struct sockaddr_un *in_addr, 
167                                     socklen_t un_addrlen,
168                                     int family,
169                                     struct sockaddr *out_addr,
170                                     socklen_t *out_len)
171 {
172         if (out_addr == NULL || out_len == NULL) 
173                 return 0;
174
175         if (un_addrlen == 0) {
176                 *out_len = 0;
177                 return 0;
178         }
179
180         switch (family) {
181         case AF_INET:
182                 return convert_un_in(in_addr, (struct sockaddr_in *)out_addr, out_len);
183         case AF_UNIX:
184                 memcpy(out_addr, in_addr, sizeof(*in_addr));
185                 *out_len = sizeof(*in_addr);
186                 return 0;
187         default:
188                 break;
189         }
190
191         errno = EAFNOSUPPORT;
192         return -1;
193 }
194
195 int swrap_socket(int domain, int type, int protocol)
196 {
197         struct socket_info *si;
198         int fd;
199
200         if (!getenv("SOCKET_WRAPPER_DIR")) {
201                 return real_socket(domain, type, protocol);
202         }
203         
204         fd = real_socket(AF_UNIX, type, 0);
205
206         if (fd == -1) return -1;
207
208         si = calloc(1, sizeof(struct socket_info));
209
210         si->domain = domain;
211         si->type = type;
212         si->protocol = protocol;
213         si->fd = fd;
214
215         DLIST_ADD(sockets, si);
216
217         return si->fd;
218 }
219
220 int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
221 {
222         struct socket_info *parent_si, *child_si;
223         int fd;
224         socklen_t un_addrlen = sizeof(struct sockaddr_un);
225         struct sockaddr_un un_addr;
226         int ret;
227
228         parent_si = find_socket_info(s);
229         if (!parent_si) {
230                 return real_accept(s, addr, addrlen);
231         }
232
233         ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
234         if (ret == -1) return ret;
235
236         fd = ret;
237
238         ret = sockaddr_convert_from_un(parent_si, &un_addr, un_addrlen,
239                                        parent_si->domain, addr, addrlen);
240         if (ret == -1) return ret;
241
242         child_si = malloc(sizeof(struct socket_info));
243         memset(child_si, 0, sizeof(*child_si));
244
245         child_si->fd = fd;
246         child_si->bound = 1;
247
248         child_si->myname_len = parent_si->myname_len;
249         child_si->myname = sockaddr_dup(parent_si->myname, parent_si->myname_len);
250
251         child_si->peername_len = *addrlen;
252         child_si->peername = sockaddr_dup(addr, *addrlen);
253
254         DLIST_ADD(sockets, child_si);
255
256         return fd;
257 }
258
259 /* using sendto() or connect() on an unbound socket would give the
260    recipient no way to reply, as unlike UDP and TCP, a unix domain
261    socket can't auto-assign emphemeral port numbers, so we need to
262    assign it here */
263 static int swrap_auto_bind(struct socket_info *si)
264 {
265         struct sockaddr_un un_addr;
266         struct sockaddr_in in;
267         int i;
268         
269         un_addr.sun_family = AF_UNIX;
270         
271         for (i=0;i<1000;i++) {
272                 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), 
273                          "%s/sock_ip_%u_%u", getenv("SOCKET_WRAPPER_DIR"), 
274                          SOCK_DGRAM, i + 10000);
275                 if (bind(si->fd, (struct sockaddr *)&un_addr, 
276                          sizeof(un_addr)) == 0) {
277                         si->tmp_path = strdup(un_addr.sun_path);
278                         si->bound = 1;
279                         break;
280                 }
281         }
282         if (i == 1000) {
283                 return -1;
284         }
285         
286         memset(&in, 0, sizeof(in));
287         in.sin_family = AF_INET;
288         in.sin_port   = htons(i);
289         in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
290         
291         si->myname_len = sizeof(in);
292         si->myname = sockaddr_dup(&in, si->myname_len);
293         si->bound = 1;
294         return 0;
295 }
296
297
298 int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
299 {
300         int ret;
301         struct sockaddr_un un_addr;
302         struct socket_info *si = find_socket_info(s);
303
304         if (!si) {
305                 return real_connect(s, serv_addr, addrlen);
306         }
307
308         /* only allow pseudo loopback connections */
309         if (serv_addr->sa_family == AF_INET &&
310                 ((const struct sockaddr_in *)serv_addr)->sin_addr.s_addr != 
311             htonl(INADDR_LOOPBACK)) {
312                 errno = ENETUNREACH;
313                 return -1;
314         }
315
316         if (si->bound == 0 && si->domain != AF_UNIX) {
317                 ret = swrap_auto_bind(si);
318                 if (ret == -1) return -1;
319         }
320
321         ret = sockaddr_convert_to_un(si, (const struct sockaddr *)serv_addr, addrlen, &un_addr);
322         if (ret == -1) return -1;
323
324         ret = real_connect(s, (struct sockaddr *)&un_addr, 
325                            sizeof(struct sockaddr_un));
326
327         if (ret == 0) {
328                 si->peername_len = addrlen;
329                 si->peername = sockaddr_dup(serv_addr, addrlen);
330         }
331
332         return ret;
333 }
334
335 int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
336 {
337         int ret;
338         struct sockaddr_un un_addr;
339         struct socket_info *si = find_socket_info(s);
340
341         if (!si) {
342                 return real_bind(s, myaddr, addrlen);
343         }
344
345         si->myname_len = addrlen;
346         si->myname = sockaddr_dup(myaddr, addrlen);
347
348         if (myaddr->sa_family == AF_INET &&
349             ((const struct sockaddr_in *)myaddr)->sin_addr.s_addr == 0) {
350                 ((struct sockaddr_in *)si->myname)->sin_addr.s_addr = 
351                         htonl(INADDR_LOOPBACK);
352         }
353         ret = sockaddr_convert_to_un(si, (const struct sockaddr *)myaddr, addrlen, &un_addr);
354         if (ret == -1) return -1;
355
356         unlink(un_addr.sun_path);
357
358         ret = real_bind(s, (struct sockaddr *)&un_addr,
359                         sizeof(struct sockaddr_un));
360
361         if (ret == 0) {
362                 si->bound = 1;
363         }
364
365         return ret;
366 }
367
368 int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
369 {
370         struct socket_info *si = find_socket_info(s);
371
372         if (!si) {
373                 return real_getpeername(s, name, addrlen);
374         }
375
376         if (!si->peername) 
377         {
378                 errno = ENOTCONN;
379                 return -1;
380         }
381
382         memcpy(name, si->peername, si->peername_len);
383         *addrlen = si->peername_len;
384
385         return 0;
386 }
387
388 int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
389 {
390         struct socket_info *si = find_socket_info(s);
391
392         if (!si) {
393                 return real_getsockname(s, name, addrlen);
394         }
395
396         memcpy(name, si->myname, si->myname_len);
397         *addrlen = si->myname_len;
398
399         return 0;
400 }
401
402 int swrap_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
403 {
404         struct socket_info *si = find_socket_info(s);
405
406         if (!si) {
407                 return real_getsockopt(s, level, optname, optval, optlen);
408         }
409
410         if (level == SOL_SOCKET) {
411                 return real_getsockopt(s, level, optname, optval, optlen);
412         } 
413
414         switch (si->domain) {
415         case AF_UNIX:
416                 return real_getsockopt(s, level, optname, optval, optlen);
417         default:
418                 errno = ENOPROTOOPT;
419                 return -1;
420         }
421 }
422
423 int swrap_setsockopt(int s, int  level,  int  optname,  const  void  *optval, socklen_t optlen)
424 {
425         struct socket_info *si = find_socket_info(s);
426
427         if (!si) {
428                 return real_setsockopt(s, level, optname, optval, optlen);
429         }
430
431         if (level == SOL_SOCKET) {
432                 return real_setsockopt(s, level, optname, optval, optlen);
433         }
434
435         switch (si->domain) {
436         case AF_UNIX:
437                 return real_setsockopt(s, level, optname, optval, optlen);
438         case AF_INET:
439                 /* Silence some warnings */
440 #ifdef TCP_NODELAY
441                 if (optname == TCP_NODELAY) 
442                         return 0;
443 #endif
444         default:
445                 errno = ENOPROTOOPT;
446                 return -1;
447         }
448 }
449
450 ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
451 {
452         struct sockaddr_un un_addr;
453         socklen_t un_addrlen = sizeof(un_addr);
454         int ret;
455         struct socket_info *si = find_socket_info(s);
456
457         if (!si) {
458                 return real_recvfrom(s, buf, len, flags, from, fromlen);
459         }
460
461         ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
462         if (ret == -1) 
463                 return ret;
464
465         if (sockaddr_convert_from_un(si, &un_addr, un_addrlen,
466                                      si->domain, from, fromlen) == -1) {
467                 return -1;
468         }
469         
470         return ret;
471 }
472
473
474 ssize_t swrap_sendto(int  s,  const  void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
475 {
476         struct sockaddr_un un_addr;
477         int ret;
478         struct socket_info *si = find_socket_info(s);
479
480         if (!si) {
481                 return real_sendto(s, buf, len, flags, to, tolen);
482         }
483
484         if (si->bound == 0 && si->domain != AF_UNIX) {
485                 ret = swrap_auto_bind(si);
486                 if (ret == -1) return -1;
487         }
488
489         ret = sockaddr_convert_to_un(si, to, tolen, &un_addr);
490         if (ret == -1) return -1;
491
492         ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
493
494         return ret;
495 }
496
497 int swrap_close(int fd)
498 {
499         struct socket_info *si = find_socket_info(fd);
500
501         if (si) {
502                 DLIST_REMOVE(sockets, si);
503
504                 free(si->path);
505                 free(si->myname);
506                 free(si->peername);
507                 if (si->tmp_path) {
508                         unlink(si->tmp_path);
509                         free(si->tmp_path);
510                 }
511                 free(si);
512         }
513
514         return real_close(fd);
515 }