?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
swrap: Call swrap_msghdr_filter_cmsghdr in swrap_sendmsg_before().
[Samba.git] / lib / socket_wrapper / socket_wrapper.c
blobc52f3d7182167c3297cded826573dd8c98efe718
1 /*
2 * Copyright (C) Jelmer Vernooij 2005,2008 <jelmer@samba.org>
3 * Copyright (C) Stefan Metzmacher 2006-2009 <metze@samba.org>
4 * Copyright (C) Andreas Schneider 2013 <asn@samba.org>
5 *
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * 3. Neither the name of the author nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 *
35 */
36
37 /*
38 Socket wrapper library. Passes all socket communication over
39 unix domain sockets if the environment variable SOCKET_WRAPPER_DIR
40 is set.
41 */
42
43 #include "config.h"
44
45 #include <sys/types.h>
46 #include <sys/time.h>
47 #include <sys/stat.h>
48 #include <sys/socket.h>
49 #include <sys/ioctl.h>
50 #ifdef HAVE_SYS_FILIO_H
51 #include <sys/filio.h>
52 #endif
53 #ifdef HAVE_SYS_SIGNALFD_H
54 #include <sys/signalfd.h>
55 #endif
56 #ifdef HAVE_SYS_EVENTFD_H
57 #include <sys/eventfd.h>
58 #endif
59 #ifdef HAVE_SYS_TIMERFD_H
60 #include <sys/timerfd.h>
61 #endif
62 #include <sys/uio.h>
63 #include <errno.h>
64 #include <sys/un.h>
65 #include <netinet/in.h>
66 #include <netinet/tcp.h>
67 #include <arpa/inet.h>
68 #include <fcntl.h>
69 #include <stdlib.h>
70 #include <string.h>
71 #include <stdio.h>
72 #include <stdint.h>
73 #include <stdarg.h>
74 #include <stdbool.h>
75 #include <unistd.h>
76 #ifdef HAVE_GNU_LIB_NAMES_H
77 #include <gnu/lib-names.h>
78 #endif
79
80 enum swrap_dbglvl_e {
81 SWRAP_LOG_ERROR = 0,
82 SWRAP_LOG_WARN,
83 SWRAP_LOG_DEBUG,
84 SWRAP_LOG_TRACE
85 };
86
87 /* GCC have printf type attribute check. */
88 #ifdef HAVE_FUNCTION_ATTRIBUTE_FORMAT
89 #define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b)))
90 #else
91 #define PRINTF_ATTRIBUTE(a,b)
92 #endif /* HAVE_FUNCTION_ATTRIBUTE_FORMAT */
93
94 #ifdef HAVE_DESTRUCTOR_ATTRIBUTE
95 #define DESTRUCTOR_ATTRIBUTE __attribute__ ((destructor))
96 #else
97 #define DESTRUCTOR_ATTRIBUTE
98 #endif
99
100 #ifdef HAVE_GCC_THREAD_LOCAL_STORAGE
101 # define SWRAP_THREAD __thread
102 #else
103 # define SWRAP_THREAD
104 #endif
105
106 #ifndef MIN
107 #define MIN(a,b) ((a)<(b)?(a):(b))
108 #endif
109
110 #ifndef ZERO_STRUCT
111 #define ZERO_STRUCT(x) memset((char *)&(x), 0, sizeof(x))
112 #endif
113
114 #ifndef discard_const
115 #define discard_const(ptr) ((void *)((uintptr_t)(ptr)))
116 #endif
117
118 #ifndef discard_const_p
119 #define discard_const_p(type, ptr) ((type *)discard_const(ptr))
120 #endif
121
122 #ifdef IPV6_PKTINFO
123 # ifndef IPV6_RECVPKTINFO
124 # define IPV6_RECVPKTINFO IPV6_PKTINFO
125 # endif /* IPV6_RECVPKTINFO */
126 #endif /* IPV6_PKTINFO */
127
128 /*
129 * On BSD IP_PKTINFO has a different name because during
130 * the time when they implemented it, there was no RFC.
131 * The name for IPv6 is the same as on Linux.
132 */
133 #ifndef IP_PKTINFO
134 # ifdef IP_RECVDSTADDR
135 # define IP_PKTINFO IP_RECVDSTADDR
136 # endif
137 #endif
138
139
140 #define SWRAP_DLIST_ADD(list,item) do { \
141 if (!(list)) { \
142 (item)->prev = NULL; \
143 (item)->next = NULL; \
144 (list) = (item); \
145 } else { \
146 (item)->prev = NULL; \
147 (item)->next = (list); \
148 (list)->prev = (item); \
149 (list) = (item); \
150 } \
151 } while (0)
152
153 #define SWRAP_DLIST_REMOVE(list,item) do { \
154 if ((list) == (item)) { \
155 (list) = (item)->next; \
156 if (list) { \
157 (list)->prev = NULL; \
158 } \
159 } else { \
160 if ((item)->prev) { \
161 (item)->prev->next = (item)->next; \
162 } \
163 if ((item)->next) { \
164 (item)->next->prev = (item)->prev; \
165 } \
166 } \
167 (item)->prev = NULL; \
168 (item)->next = NULL; \
169 } while (0)
170
171 #if defined(HAVE_GETTIMEOFDAY_TZ) || defined(HAVE_GETTIMEOFDAY_TZ_VOID)
172 #define swrapGetTimeOfDay(tval) gettimeofday(tval,NULL)
173 #else
174 #define swrapGetTimeOfDay(tval) gettimeofday(tval)
175 #endif
176
177 /* we need to use a very terse format here as IRIX 6.4 silently
178 truncates names to 16 chars, so if we use a longer name then we
179 can't tell which port a packet came from with recvfrom()
180
181 with this format we have 8 chars left for the directory name
182 */
183 #define SOCKET_FORMAT "%c%02X%04X"
184 #define SOCKET_TYPE_CHAR_TCP 'T'
185 #define SOCKET_TYPE_CHAR_UDP 'U'
186 #define SOCKET_TYPE_CHAR_TCP_V6 'X'
187 #define SOCKET_TYPE_CHAR_UDP_V6 'Y'
188
189 /*
190 * Cut down to 1500 byte packets for stream sockets,
191 * which makes it easier to format PCAP capture files
192 * (as the caller will simply continue from here)
193 */
194 #define SOCKET_MAX_PACKET 1500
195
196 #define SOCKET_MAX_SOCKETS 1024
197
198 /* This limit is to avoid broadcast sendto() needing to stat too many
199 * files. It may be raised (with a performance cost) to up to 254
200 * without changing the format above */
201 #define MAX_WRAPPED_INTERFACES 40
202
203 struct socket_info_fd {
204 struct socket_info_fd *prev, *next;
205 int fd;
206 };
207
208 struct socket_info
209 {
210 struct socket_info_fd *fds;
211
212 int family;
213 int type;
214 int protocol;
215 int bound;
216 int bcast;
217 int is_server;
218 int connected;
219 int defer_connect;
220 int pktinfo;
221
222 char *tmp_path;
223
224 struct sockaddr *bindname;
225 socklen_t bindname_len;
226
227 struct sockaddr *myname;
228 socklen_t myname_len;
229
230 struct sockaddr *peername;
231 socklen_t peername_len;
232
233 struct {
234 unsigned long pck_snd;
235 unsigned long pck_rcv;
236 } io;
237
238 struct socket_info *prev, *next;
239 };
240
241 /*
242 * File descriptors are shared between threads so we should share socket
243 * information too.
244 */
245 struct socket_info *sockets;
246
247 /* Function prototypes */
248
249 bool socket_wrapper_enabled(void);
250 void swrap_destructor(void) DESTRUCTOR_ATTRIBUTE;
251
252 #ifdef NDEBUG
253 # define SWRAP_LOG(...)
254 #else
255
256 static void swrap_log(enum swrap_dbglvl_e dbglvl, const char *format, ...) PRINTF_ATTRIBUTE(2, 3);
257 # define SWRAP_LOG(dbglvl, ...) swrap_log((dbglvl), __VA_ARGS__)
258
259 static void swrap_log(enum swrap_dbglvl_e dbglvl, const char *format, ...)
260 {
261 char buffer[1024];
262 va_list va;
263 const char *d;
264 unsigned int lvl = 0;
265
266 d = getenv("SOCKET_WRAPPER_DEBUGLEVEL");
267 if (d != NULL) {
268 lvl = atoi(d);
269 }
270
271 va_start(va, format);
272 vsnprintf(buffer, sizeof(buffer), format, va);
273 va_end(va);
274
275 if (lvl >= dbglvl) {
276 switch (dbglvl) {
277 case SWRAP_LOG_ERROR:
278 fprintf(stderr,
279 "SWRAP_ERROR(%d): %s\n",
280 (int)getpid(), buffer);
281 break;
282 case SWRAP_LOG_WARN:
283 fprintf(stderr,
284 "SWRAP_WARN(%d): %s\n",
285 (int)getpid(), buffer);
286 break;
287 case SWRAP_LOG_DEBUG:
288 fprintf(stderr,
289 "SWRAP_DEBUG(%d): %s\n",
290 (int)getpid(), buffer);
291 break;
292 case SWRAP_LOG_TRACE:
293 fprintf(stderr,
294 "SWRAP_TRACE(%d): %s\n",
295 (int)getpid(), buffer);
296 break;
297 }
298 }
299 }
300 #endif
301
302 /*********************************************************
303 * SWRAP LOADING LIBC FUNCTIONS
304 *********************************************************/
305
306 #include <dlfcn.h>
307
308 struct swrap_libc_fns {
309 int (*libc_accept)(int sockfd,
310 struct sockaddr *addr,
311 socklen_t *addrlen);
312 int (*libc_bind)(int sockfd,
313 const struct sockaddr *addr,
314 socklen_t addrlen);
315 int (*libc_close)(int fd);
316 int (*libc_connect)(int sockfd,
317 const struct sockaddr *addr,
318 socklen_t addrlen);
319 int (*libc_dup)(int fd);
320 int (*libc_dup2)(int oldfd, int newfd);
321 #ifdef HAVE_EVENTFD
322 int (*libc_eventfd)(int count, int flags);
323 #endif
324 int (*libc_getpeername)(int sockfd,
325 struct sockaddr *addr,
326 socklen_t *addrlen);
327 int (*libc_getsockname)(int sockfd,
328 struct sockaddr *addr,
329 socklen_t *addrlen);
330 int (*libc_getsockopt)(int sockfd,
331 int level,
332 int optname,
333 void *optval,
334 socklen_t *optlen);
335 int (*libc_ioctl)(int d, unsigned long int request, ...);
336 int (*libc_listen)(int sockfd, int backlog);
337 int (*libc_open)(const char *pathname, int flags, mode_t mode);
338 int (*libc_pipe)(int pipefd[2]);
339 int (*libc_read)(int fd, void *buf, size_t count);
340 ssize_t (*libc_readv)(int fd, const struct iovec *iov, int iovcnt);
341 int (*libc_recv)(int sockfd, void *buf, size_t len, int flags);
342 int (*libc_recvfrom)(int sockfd,
343 void *buf,
344 size_t len,
345 int flags,
346 struct sockaddr *src_addr,
347 socklen_t *addrlen);
348 int (*libc_recvmsg)(int sockfd, const struct msghdr *msg, int flags);
349 int (*libc_send)(int sockfd, const void *buf, size_t len, int flags);
350 int (*libc_sendmsg)(int sockfd, const struct msghdr *msg, int flags);
351 int (*libc_sendto)(int sockfd,
352 const void *buf,
353 size_t len,
354 int flags,
355 const struct sockaddr *dst_addr,
356 socklen_t addrlen);
357 int (*libc_setsockopt)(int sockfd,
358 int level,
359 int optname,
360 const void *optval,
361 socklen_t optlen);
362 #ifdef HAVE_SIGNALFD
363 int (*libc_signalfd)(int fd, const sigset_t *mask, int flags);
364 #endif
365 int (*libc_socket)(int domain, int type, int protocol);
366 int (*libc_socketpair)(int domain, int type, int protocol, int sv[2]);
367 #ifdef HAVE_TIMERFD_CREATE
368 int (*libc_timerfd_create)(int clockid, int flags);
369 #endif
370 ssize_t (*libc_writev)(int fd, const struct iovec *iov, int iovcnt);
371 };
372
373 struct swrap {
374 void *libc_handle;
375 void *libsocket_handle;
376
377 bool initialised;
378 bool enabled;
379
380 char *socket_dir;
381
382 struct swrap_libc_fns fns;
383 };
384
385 static struct swrap swrap;
386
387 /* prototypes */
388 static const char *socket_wrapper_dir(void);
389
390 #define LIBC_NAME "libc.so"
391
392 enum swrap_lib {
393 SWRAP_LIBC,
394 SWRAP_LIBNSL,
395 SWRAP_LIBSOCKET,
396 };
397
398 #ifndef NDEBUG
399 static const char *swrap_str_lib(enum swrap_lib lib)
400 {
401 switch (lib) {
402 case SWRAP_LIBC:
403 return "libc";
404 case SWRAP_LIBNSL:
405 return "libnsl";
406 case SWRAP_LIBSOCKET:
407 return "libsocket";
408 }
409
410 /* Compiler would warn us about unhandled enum value if we get here */
411 return "unknown";
412 }
413 #endif
414
415 static void *swrap_load_lib_handle(enum swrap_lib lib)
416 {
417 int flags = RTLD_LAZY;
418 void *handle = NULL;
419 int i;
420
421 #ifdef RTLD_DEEPBIND
422 flags |= RTLD_DEEPBIND;
423 #endif
424
425 switch (lib) {
426 case SWRAP_LIBNSL:
427 /* FALL TROUGH */
428 case SWRAP_LIBSOCKET:
429 #ifdef HAVE_LIBSOCKET
430 handle = swrap.libsocket_handle;
431 if (handle == NULL) {
432 for (handle = NULL, i = 10; handle == NULL && i >= 0; i--) {
433 char soname[256] = {0};
434
435 snprintf(soname, sizeof(soname), "libsocket.so.%d", i);
436 handle = dlopen(soname, flags);
437 }
438
439 swrap.libsocket_handle = handle;
440 }
441 break;
442 #endif
443 /* FALL TROUGH */
444 case SWRAP_LIBC:
445 handle = swrap.libc_handle;
446 #ifdef LIBC_SO
447 if (handle == NULL) {
448 handle = dlopen(LIBC_SO, flags);
449
450 swrap.libc_handle = handle;
451 }
452 #endif
453 if (handle == NULL) {
454 for (handle = NULL, i = 10; handle == NULL && i >= 0; i--) {
455 char soname[256] = {0};
456
457 snprintf(soname, sizeof(soname), "libc.so.%d", i);
458 handle = dlopen(soname, flags);
459 }
460
461 swrap.libc_handle = handle;
462 }
463 break;
464 }
465
466 if (handle == NULL) {
467 #ifdef RTLD_NEXT
468 handle = swrap.libc_handle = swrap.libsocket_handle = RTLD_NEXT;
469 #else
470 SWRAP_LOG(SWRAP_LOG_ERROR,
471 "Failed to dlopen library: %s\n",
472 dlerror());
473 exit(-1);
474 #endif
475 }
476
477 return handle;
478 }
479
480 static void *_swrap_load_lib_function(enum swrap_lib lib, const char *fn_name)
481 {
482 void *handle;
483 void *func;
484
485 handle = swrap_load_lib_handle(lib);
486
487 func = dlsym(handle, fn_name);
488 if (func == NULL) {
489 SWRAP_LOG(SWRAP_LOG_ERROR,
490 "Failed to find %s: %s\n",
491 fn_name, dlerror());
492 exit(-1);
493 }
494
495 SWRAP_LOG(SWRAP_LOG_TRACE,
496 "Loaded %s from %s",
497 fn_name, swrap_str_lib(lib));
498 return func;
499 }
500
501 #define swrap_load_lib_function(lib, fn_name) \
502 if (swrap.fns.libc_##fn_name == NULL) { \
503 *(void **) (&swrap.fns.libc_##fn_name) = \
504 _swrap_load_lib_function(lib, #fn_name); \
505 }
506
507
508 /*
509 * IMPORTANT
510 *
511 * Functions especially from libc need to be loaded individually, you can't load
512 * all at once or gdb will segfault at startup. The same applies to valgrind and
513 * has probably something todo with with the linker.
514 * So we need load each function at the point it is called the first time.
515 */
516 static int libc_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
517 {
518 swrap_load_lib_function(SWRAP_LIBSOCKET, accept);
519
520 return swrap.fns.libc_accept(sockfd, addr, addrlen);
521 }
522
523 static int libc_bind(int sockfd,
524 const struct sockaddr *addr,
525 socklen_t addrlen)
526 {
527 swrap_load_lib_function(SWRAP_LIBSOCKET, bind);
528
529 return swrap.fns.libc_bind(sockfd, addr, addrlen);
530 }
531
532 static int libc_close(int fd)
533 {
534 swrap_load_lib_function(SWRAP_LIBC, close);
535
536 return swrap.fns.libc_close(fd);
537 }
538
539 static int libc_connect(int sockfd,
540 const struct sockaddr *addr,
541 socklen_t addrlen)
542 {
543 swrap_load_lib_function(SWRAP_LIBSOCKET, connect);
544
545 return swrap.fns.libc_connect(sockfd, addr, addrlen);
546 }
547
548 static int libc_dup(int fd)
549 {
550 swrap_load_lib_function(SWRAP_LIBC, dup);
551
552 return swrap.fns.libc_dup(fd);
553 }
554
555 static int libc_dup2(int oldfd, int newfd)
556 {
557 swrap_load_lib_function(SWRAP_LIBC, dup2);
558
559 return swrap.fns.libc_dup2(oldfd, newfd);
560 }
561
562 #ifdef HAVE_EVENTFD
563 static int libc_eventfd(int count, int flags)
564 {
565 swrap_load_lib_function(SWRAP_LIBC, eventfd);
566
567 return swrap.fns.libc_eventfd(count, flags);
568 }
569 #endif
570
571 static int libc_getpeername(int sockfd,
572 struct sockaddr *addr,
573 socklen_t *addrlen)
574 {
575 swrap_load_lib_function(SWRAP_LIBSOCKET, getpeername);
576
577 return swrap.fns.libc_getpeername(sockfd, addr, addrlen);
578 }
579
580 static int libc_getsockname(int sockfd,
581 struct sockaddr *addr,
582 socklen_t *addrlen)
583 {
584 swrap_load_lib_function(SWRAP_LIBSOCKET, getsockname);
585
586 return swrap.fns.libc_getsockname(sockfd, addr, addrlen);
587 }
588
589 static int libc_getsockopt(int sockfd,
590 int level,
591 int optname,
592 void *optval,
593 socklen_t *optlen)
594 {
595 swrap_load_lib_function(SWRAP_LIBSOCKET, getsockopt);
596
597 return swrap.fns.libc_getsockopt(sockfd, level, optname, optval, optlen);
598 }
599
600 static int libc_vioctl(int d, unsigned long int request, va_list ap)
601 {
602 long int args[4];
603 int rc;
604 int i;
605
606 swrap_load_lib_function(SWRAP_LIBC, ioctl);
607
608 for (i = 0; i < 4; i++) {
609 args[i] = va_arg(ap, long int);
610 }
611
612 rc = swrap.fns.libc_ioctl(d,
613 request,
614 args[0],
615 args[1],
616 args[2],
617 args[3]);
618
619 return rc;
620 }
621
622 static int libc_listen(int sockfd, int backlog)
623 {
624 swrap_load_lib_function(SWRAP_LIBSOCKET, listen);
625
626 return swrap.fns.libc_listen(sockfd, backlog);
627 }
628
629 static int libc_vopen(const char *pathname, int flags, va_list ap)
630 {
631 long int mode = 0;
632 int fd;
633
634 swrap_load_lib_function(SWRAP_LIBC, open);
635
636 mode = va_arg(ap, long int);
637
638 fd = swrap.fns.libc_open(pathname, flags, (mode_t)mode);
639
640 return fd;
641 }
642
643 static int libc_open(const char *pathname, int flags, ...)
644 {
645 va_list ap;
646 int fd;
647
648 va_start(ap, flags);
649 fd = libc_vopen(pathname, flags, ap);
650 va_end(ap);
651
652 return fd;
653 }
654
655 static int libc_pipe(int pipefd[2])
656 {
657 swrap_load_lib_function(SWRAP_LIBSOCKET, pipe);
658
659 return swrap.fns.libc_pipe(pipefd);
660 }
661
662 static int libc_read(int fd, void *buf, size_t count)
663 {
664 swrap_load_lib_function(SWRAP_LIBC, read);
665
666 return swrap.fns.libc_read(fd, buf, count);
667 }
668
669 static ssize_t libc_readv(int fd, const struct iovec *iov, int iovcnt)
670 {
671 swrap_load_lib_function(SWRAP_LIBSOCKET, readv);
672
673 return swrap.fns.libc_readv(fd, iov, iovcnt);
674 }
675
676 static int libc_recv(int sockfd, void *buf, size_t len, int flags)
677 {
678 swrap_load_lib_function(SWRAP_LIBSOCKET, recv);
679
680 return swrap.fns.libc_recv(sockfd, buf, len, flags);
681 }
682
683 static int libc_recvfrom(int sockfd,
684 void *buf,
685 size_t len,
686 int flags,
687 struct sockaddr *src_addr,
688 socklen_t *addrlen)
689 {
690 swrap_load_lib_function(SWRAP_LIBSOCKET, recvfrom);
691
692 return swrap.fns.libc_recvfrom(sockfd, buf, len, flags, src_addr, addrlen);
693 }
694
695 static int libc_recvmsg(int sockfd, struct msghdr *msg, int flags)
696 {
697 swrap_load_lib_function(SWRAP_LIBSOCKET, recvmsg);
698
699 return swrap.fns.libc_recvmsg(sockfd, msg, flags);
700 }
701
702 static int libc_send(int sockfd, const void *buf, size_t len, int flags)
703 {
704 swrap_load_lib_function(SWRAP_LIBSOCKET, send);
705
706 return swrap.fns.libc_send(sockfd, buf, len, flags);
707 }
708
709 static int libc_sendmsg(int sockfd, const struct msghdr *msg, int flags)
710 {
711 swrap_load_lib_function(SWRAP_LIBSOCKET, sendmsg);
712
713 return swrap.fns.libc_sendmsg(sockfd, msg, flags);
714 }
715
716 static int libc_sendto(int sockfd,
717 const void *buf,
718 size_t len,
719 int flags,
720 const struct sockaddr *dst_addr,
721 socklen_t addrlen)
722 {
723 swrap_load_lib_function(SWRAP_LIBSOCKET, sendto);
724
725 return swrap.fns.libc_sendto(sockfd, buf, len, flags, dst_addr, addrlen);
726 }
727
728 static int libc_setsockopt(int sockfd,
729 int level,
730 int optname,
731 const void *optval,
732 socklen_t optlen)
733 {
734 swrap_load_lib_function(SWRAP_LIBSOCKET, setsockopt);
735
736 return swrap.fns.libc_setsockopt(sockfd, level, optname, optval, optlen);
737 }
738
739 #ifdef HAVE_SIGNALFD
740 static int libc_signalfd(int fd, const sigset_t *mask, int flags)
741 {
742 swrap_load_lib_function(SWRAP_LIBSOCKET, signalfd);
743
744 return swrap.fns.libc_signalfd(fd, mask, flags);
745 }
746 #endif
747
748 static int libc_socket(int domain, int type, int protocol)
749 {
750 swrap_load_lib_function(SWRAP_LIBSOCKET, socket);
751
752 return swrap.fns.libc_socket(domain, type, protocol);
753 }
754
755 static int libc_socketpair(int domain, int type, int protocol, int sv[2])
756 {
757 swrap_load_lib_function(SWRAP_LIBSOCKET, socketpair);
758
759 return swrap.fns.libc_socketpair(domain, type, protocol, sv);
760 }
761
762 #ifdef HAVE_TIMERFD_CREATE
763 static int libc_timerfd_create(int clockid, int flags)
764 {
765 swrap_load_lib_function(SWRAP_LIBC, timerfd_create);
766
767 return swrap.fns.libc_timerfd_create(clockid, flags);
768 }
769 #endif
770
771 static ssize_t libc_writev(int fd, const struct iovec *iov, int iovcnt)
772 {
773 swrap_load_lib_function(SWRAP_LIBSOCKET, writev);
774
775 return swrap.fns.libc_writev(fd, iov, iovcnt);
776 }
777
778 /*********************************************************
779 * SWRAP HELPER FUNCTIONS
780 *********************************************************/
781
782 #ifdef HAVE_IPV6
783 /*
784 * FD00::5357:5FXX
785 */
786 static const struct in6_addr *swrap_ipv6(void)
787 {
788 static struct in6_addr v;
789 static int initialized;
790 int ret;
791
792 if (initialized) {
793 return &v;
794 }
795 initialized = 1;
796
797 ret = inet_pton(AF_INET6, "FD00::5357:5F00", &v);
798 if (ret <= 0) {
799 abort();
800 }
801
802 return &v;
803 }
804 #endif
805
806 static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
807 {
808 struct sockaddr *ret = (struct sockaddr *)malloc(len);
809 memcpy(ret, data, len);
810 return ret;
811 }
812
813 static void set_port(int family, int prt, struct sockaddr *addr)
814 {
815 switch (family) {
816 case AF_INET:
817 ((struct sockaddr_in *)addr)->sin_port = htons(prt);
818 break;
819 #ifdef HAVE_IPV6
820 case AF_INET6:
821 ((struct sockaddr_in6 *)addr)->sin6_port = htons(prt);
822 break;
823 #endif
824 }
825 }
826
827 static size_t socket_length(int family)
828 {
829 switch (family) {
830 case AF_INET:
831 return sizeof(struct sockaddr_in);
832 #ifdef HAVE_IPV6
833 case AF_INET6:
834 return sizeof(struct sockaddr_in6);
835 #endif
836 }
837 return 0;
838 }
839
840 static const char *socket_wrapper_dir(void)
841 {
842 const char *s = getenv("SOCKET_WRAPPER_DIR");
843 if (s == NULL) {
844 return NULL;
845 }
846 if (strncmp(s, "./", 2) == 0) {
847 s += 2;
848 }
849
850 SWRAP_LOG(SWRAP_LOG_TRACE, "socket_wrapper_dir: %s", s);
851 return s;
852 }
853
854 bool socket_wrapper_enabled(void)
855 {
856 const char *s = socket_wrapper_dir();
857
858 return s != NULL ? true : false;
859 }
860
861 static unsigned int socket_wrapper_default_iface(void)
862 {
863 const char *s = getenv("SOCKET_WRAPPER_DEFAULT_IFACE");
864 if (s) {
865 unsigned int iface;
866 if (sscanf(s, "%u", &iface) == 1) {
867 if (iface >= 1 && iface <= MAX_WRAPPED_INTERFACES) {
868 return iface;
869 }
870 }
871 }
872
873 return 1;/* 127.0.0.1 */
874 }
875
876 static int convert_un_in(const struct sockaddr_un *un, struct sockaddr *in, socklen_t *len)
877 {
878 unsigned int iface;
879 unsigned int prt;
880 const char *p;
881 char type;
882
883 p = strrchr(un->sun_path, '/');
884 if (p) p++; else p = un->sun_path;
885
886 if (sscanf(p, SOCKET_FORMAT, &type, &iface, &prt) != 3) {
887 errno = EINVAL;
888 return -1;
889 }
890
891 SWRAP_LOG(SWRAP_LOG_TRACE, "type %c iface %u port %u",
892 type, iface, prt);
893
894 if (iface == 0 || iface > MAX_WRAPPED_INTERFACES) {
895 errno = EINVAL;
896 return -1;
897 }
898
899 if (prt > 0xFFFF) {
900 errno = EINVAL;
901 return -1;
902 }
903
904 switch(type) {
905 case SOCKET_TYPE_CHAR_TCP:
906 case SOCKET_TYPE_CHAR_UDP: {
907 struct sockaddr_in *in2 = (struct sockaddr_in *)(void *)in;
908
909 if ((*len) < sizeof(*in2)) {
910 errno = EINVAL;
911 return -1;
912 }
913
914 memset(in2, 0, sizeof(*in2));
915 in2->sin_family = AF_INET;
916 in2->sin_addr.s_addr = htonl((127<<24) | iface);
917 in2->sin_port = htons(prt);
918
919 *len = sizeof(*in2);
920 break;
921 }
922 #ifdef HAVE_IPV6
923 case SOCKET_TYPE_CHAR_TCP_V6:
924 case SOCKET_TYPE_CHAR_UDP_V6: {
925 struct sockaddr_in6 *in2 = (struct sockaddr_in6 *)(void *)in;
926
927 if ((*len) < sizeof(*in2)) {
928 errno = EINVAL;
929 return -1;
930 }
931
932 memset(in2, 0, sizeof(*in2));
933 in2->sin6_family = AF_INET6;
934 in2->sin6_addr = *swrap_ipv6();
935 in2->sin6_addr.s6_addr[15] = iface;
936 in2->sin6_port = htons(prt);
937
938 *len = sizeof(*in2);
939 break;
940 }
941 #endif
942 default:
943 errno = EINVAL;
944 return -1;
945 }
946
947 return 0;
948 }
949
950 static int convert_in_un_remote(struct socket_info *si, const struct sockaddr *inaddr, struct sockaddr_un *un,
951 int *bcast)
952 {
953 char type = '\0';
954 unsigned int prt;
955 unsigned int iface;
956 int is_bcast = 0;
957
958 if (bcast) *bcast = 0;
959
960 switch (inaddr->sa_family) {
961 case AF_INET: {
962 const struct sockaddr_in *in =
963 (const struct sockaddr_in *)(const void *)inaddr;
964 unsigned int addr = ntohl(in->sin_addr.s_addr);
965 char u_type = '\0';
966 char b_type = '\0';
967 char a_type = '\0';
968
969 switch (si->type) {
970 case SOCK_STREAM:
971 u_type = SOCKET_TYPE_CHAR_TCP;
972 break;
973 case SOCK_DGRAM:
974 u_type = SOCKET_TYPE_CHAR_UDP;
975 a_type = SOCKET_TYPE_CHAR_UDP;
976 b_type = SOCKET_TYPE_CHAR_UDP;
977 break;
978 default:
979 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n");
980 errno = ESOCKTNOSUPPORT;
981 return -1;
982 }
983
984 prt = ntohs(in->sin_port);
985 if (a_type && addr == 0xFFFFFFFF) {
986 /* 255.255.255.255 only udp */
987 is_bcast = 2;
988 type = a_type;
989 iface = socket_wrapper_default_iface();
990 } else if (b_type && addr == 0x7FFFFFFF) {
991 /* 127.255.255.255 only udp */
992 is_bcast = 1;
993 type = b_type;
994 iface = socket_wrapper_default_iface();
995 } else if ((addr & 0xFFFFFF00) == 0x7F000000) {
996 /* 127.0.0.X */
997 is_bcast = 0;
998 type = u_type;
999 iface = (addr & 0x000000FF);
1000 } else {
1001 errno = ENETUNREACH;
1002 return -1;
1003 }
1004 if (bcast) *bcast = is_bcast;
1005 break;
1006 }
1007 #ifdef HAVE_IPV6
1008 case AF_INET6: {
1009 const struct sockaddr_in6 *in =
1010 (const struct sockaddr_in6 *)(const void *)inaddr;
1011 struct in6_addr cmp1, cmp2;
1012
1013 switch (si->type) {
1014 case SOCK_STREAM:
1015 type = SOCKET_TYPE_CHAR_TCP_V6;
1016 break;
1017 case SOCK_DGRAM:
1018 type = SOCKET_TYPE_CHAR_UDP_V6;
1019 break;
1020 default:
1021 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n");
1022 errno = ESOCKTNOSUPPORT;
1023 return -1;
1024 }
1025
1026 /* XXX no multicast/broadcast */
1027
1028 prt = ntohs(in->sin6_port);
1029
1030 cmp1 = *swrap_ipv6();
1031 cmp2 = in->sin6_addr;
1032 cmp2.s6_addr[15] = 0;
1033 if (IN6_ARE_ADDR_EQUAL(&cmp1, &cmp2)) {
1034 iface = in->sin6_addr.s6_addr[15];
1035 } else {
1036 errno = ENETUNREACH;
1037 return -1;
1038 }
1039
1040 break;
1041 }
1042 #endif
1043 default:
1044 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family!\n");
1045 errno = ENETUNREACH;
1046 return -1;
1047 }
1048
1049 if (prt == 0) {
1050 SWRAP_LOG(SWRAP_LOG_WARN, "Port not set\n");
1051 errno = EINVAL;
1052 return -1;
1053 }
1054
1055 if (is_bcast) {
1056 snprintf(un->sun_path, sizeof(un->sun_path), "%s/EINVAL",
1057 socket_wrapper_dir());
1058 SWRAP_LOG(SWRAP_LOG_DEBUG, "un path [%s]", un->sun_path);
1059 /* the caller need to do more processing */
1060 return 0;
1061 }
1062
1063 snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
1064 socket_wrapper_dir(), type, iface, prt);
1065 SWRAP_LOG(SWRAP_LOG_DEBUG, "un path [%s]", un->sun_path);
1066
1067 return 0;
1068 }
1069
1070 static int convert_in_un_alloc(struct socket_info *si, const struct sockaddr *inaddr, struct sockaddr_un *un,
1071 int *bcast)
1072 {
1073 char type = '\0';
1074 unsigned int prt;
1075 unsigned int iface;
1076 struct stat st;
1077 int is_bcast = 0;
1078
1079 if (bcast) *bcast = 0;
1080
1081 switch (si->family) {
1082 case AF_INET: {
1083 const struct sockaddr_in *in =
1084 (const struct sockaddr_in *)(const void *)inaddr;
1085 unsigned int addr = ntohl(in->sin_addr.s_addr);
1086 char u_type = '\0';
1087 char d_type = '\0';
1088 char b_type = '\0';
1089 char a_type = '\0';
1090
1091 prt = ntohs(in->sin_port);
1092
1093 switch (si->type) {
1094 case SOCK_STREAM:
1095 u_type = SOCKET_TYPE_CHAR_TCP;
1096 d_type = SOCKET_TYPE_CHAR_TCP;
1097 break;
1098 case SOCK_DGRAM:
1099 u_type = SOCKET_TYPE_CHAR_UDP;
1100 d_type = SOCKET_TYPE_CHAR_UDP;
1101 a_type = SOCKET_TYPE_CHAR_UDP;
1102 b_type = SOCKET_TYPE_CHAR_UDP;
1103 break;
1104 default:
1105 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n");
1106 errno = ESOCKTNOSUPPORT;
1107 return -1;
1108 }
1109
1110 if (addr == 0) {
1111 /* 0.0.0.0 */
1112 is_bcast = 0;
1113 type = d_type;
1114 iface = socket_wrapper_default_iface();
1115 } else if (a_type && addr == 0xFFFFFFFF) {
1116 /* 255.255.255.255 only udp */
1117 is_bcast = 2;
1118 type = a_type;
1119 iface = socket_wrapper_default_iface();
1120 } else if (b_type && addr == 0x7FFFFFFF) {
1121 /* 127.255.255.255 only udp */
1122 is_bcast = 1;
1123 type = b_type;
1124 iface = socket_wrapper_default_iface();
1125 } else if ((addr & 0xFFFFFF00) == 0x7F000000) {
1126 /* 127.0.0.X */
1127 is_bcast = 0;
1128 type = u_type;
1129 iface = (addr & 0x000000FF);
1130 } else {
1131 errno = EADDRNOTAVAIL;
1132 return -1;
1133 }
1134
1135 /* Store the bind address for connect() */
1136 if (si->bindname == NULL) {
1137 struct sockaddr_in bind_in;
1138 socklen_t blen = sizeof(struct sockaddr_in);
1139
1140 ZERO_STRUCT(bind_in);
1141 bind_in.sin_family = in->sin_family;
1142 bind_in.sin_port = in->sin_port;
1143 bind_in.sin_addr.s_addr = htonl(0x7F000000 | iface);
1144
1145 si->bindname = sockaddr_dup(&bind_in, blen);
1146 si->bindname_len = blen;
1147 }
1148
1149 break;
1150 }
1151 #ifdef HAVE_IPV6
1152 case AF_INET6: {
1153 const struct sockaddr_in6 *in =
1154 (const struct sockaddr_in6 *)(const void *)inaddr;
1155 struct in6_addr cmp1, cmp2;
1156
1157 switch (si->type) {
1158 case SOCK_STREAM:
1159 type = SOCKET_TYPE_CHAR_TCP_V6;
1160 break;
1161 case SOCK_DGRAM:
1162 type = SOCKET_TYPE_CHAR_UDP_V6;
1163 break;
1164 default:
1165 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n");
1166 errno = ESOCKTNOSUPPORT;
1167 return -1;
1168 }
1169
1170 /* XXX no multicast/broadcast */
1171
1172 prt = ntohs(in->sin6_port);
1173
1174 cmp1 = *swrap_ipv6();
1175 cmp2 = in->sin6_addr;
1176 cmp2.s6_addr[15] = 0;
1177 if (IN6_IS_ADDR_UNSPECIFIED(&in->sin6_addr)) {
1178 iface = socket_wrapper_default_iface();
1179 } else if (IN6_ARE_ADDR_EQUAL(&cmp1, &cmp2)) {
1180 iface = in->sin6_addr.s6_addr[15];
1181 } else {
1182 errno = EADDRNOTAVAIL;
1183 return -1;
1184 }
1185
1186 /* Store the bind address for connect() */
1187 if (si->bindname == NULL) {
1188 struct sockaddr_in6 bind_in;
1189 socklen_t blen = sizeof(struct sockaddr_in6);
1190
1191 ZERO_STRUCT(bind_in);
1192 bind_in.sin6_family = in->sin6_family;
1193 bind_in.sin6_port = in->sin6_port;
1194
1195 bind_in.sin6_addr = *swrap_ipv6();
1196 bind_in.sin6_addr.s6_addr[15] = iface;
1197
1198 si->bindname = sockaddr_dup(&bind_in, blen);
1199 si->bindname_len = blen;
1200 }
1201
1202 break;
1203 }
1204 #endif
1205 default:
1206 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family\n");
1207 errno = EADDRNOTAVAIL;
1208 return -1;
1209 }
1210
1211
1212 if (bcast) *bcast = is_bcast;
1213
1214 if (iface == 0 || iface > MAX_WRAPPED_INTERFACES) {
1215 errno = EINVAL;
1216 return -1;
1217 }
1218
1219 if (prt == 0) {
1220 /* handle auto-allocation of ephemeral ports */
1221 for (prt = 5001; prt < 10000; prt++) {
1222 snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
1223 socket_wrapper_dir(), type, iface, prt);
1224 if (stat(un->sun_path, &st) == 0) continue;
1225
1226 set_port(si->family, prt, si->myname);
1227 set_port(si->family, prt, si->bindname);
1228
1229 break;
1230 }
1231 if (prt == 10000) {
1232 errno = ENFILE;
1233 return -1;
1234 }
1235 }
1236
1237 snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
1238 socket_wrapper_dir(), type, iface, prt);
1239 SWRAP_LOG(SWRAP_LOG_DEBUG, "un path [%s]", un->sun_path);
1240 return 0;
1241 }
1242
1243 static struct socket_info *find_socket_info(int fd)
1244 {
1245 struct socket_info *i;
1246
1247 for (i = sockets; i; i = i->next) {
1248 struct socket_info_fd *f;
1249 for (f = i->fds; f; f = f->next) {
1250 if (f->fd == fd) {
1251 return i;
1252 }
1253 }
1254 }
1255
1256 return NULL;
1257 }
1258
1259 static void swrap_remove_stale(int fd)
1260 {
1261 struct socket_info *si = find_socket_info(fd);
1262 struct socket_info_fd *fi;
1263
1264 if (si != NULL) {
1265 for (fi = si->fds; fi; fi = fi->next) {
1266 if (fi->fd == fd) {
1267 SWRAP_LOG(SWRAP_LOG_TRACE, "remove stale wrapper for %d", fd);
1268 SWRAP_DLIST_REMOVE(si->fds, fi);
1269 free(fi);
1270 break;
1271 }
1272 }
1273
1274 if (si->fds == NULL) {
1275 SWRAP_DLIST_REMOVE(sockets, si);
1276 }
1277 }
1278 }
1279
1280 static int sockaddr_convert_to_un(struct socket_info *si,
1281 const struct sockaddr *in_addr,
1282 socklen_t in_len,
1283 struct sockaddr_un *out_addr,
1284 int alloc_sock,
1285 int *bcast)
1286 {
1287 struct sockaddr *out = (struct sockaddr *)(void *)out_addr;
1288
1289 (void) in_len; /* unused */
1290
1291 if (out_addr == NULL) {
1292 return 0;
1293 }
1294
1295 out->sa_family = AF_UNIX;
1296 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
1297 out->sa_len = sizeof(*out_addr);
1298 #endif
1299
1300 switch (in_addr->sa_family) {
1301 case AF_INET:
1302 #ifdef HAVE_IPV6
1303 case AF_INET6:
1304 #endif
1305 switch (si->type) {
1306 case SOCK_STREAM:
1307 case SOCK_DGRAM:
1308 break;
1309 default:
1310 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n");
1311 errno = ESOCKTNOSUPPORT;
1312 return -1;
1313 }
1314 if (alloc_sock) {
1315 return convert_in_un_alloc(si, in_addr, out_addr, bcast);
1316 } else {
1317 return convert_in_un_remote(si, in_addr, out_addr, bcast);
1318 }
1319 default:
1320 break;
1321 }
1322
1323 errno = EAFNOSUPPORT;
1324 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family\n");
1325 return -1;
1326 }
1327
1328 static int sockaddr_convert_from_un(const struct socket_info *si,
1329 const struct sockaddr_un *in_addr,
1330 socklen_t un_addrlen,
1331 int family,
1332 struct sockaddr *out_addr,
1333 socklen_t *out_addrlen)
1334 {
1335 int ret;
1336
1337 if (out_addr == NULL || out_addrlen == NULL)
1338 return 0;
1339
1340 if (un_addrlen == 0) {
1341 *out_addrlen = 0;
1342 return 0;
1343 }
1344
1345 switch (family) {
1346 case AF_INET:
1347 #ifdef HAVE_IPV6
1348 case AF_INET6:
1349 #endif
1350 switch (si->type) {
1351 case SOCK_STREAM:
1352 case SOCK_DGRAM:
1353 break;
1354 default:
1355 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n");
1356 errno = ESOCKTNOSUPPORT;
1357 return -1;
1358 }
1359 ret = convert_un_in(in_addr, out_addr, out_addrlen);
1360 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
1361 out_addr->sa_len = *out_addrlen;
1362 #endif
1363 return ret;
1364 default:
1365 break;
1366 }
1367
1368 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family\n");
1369 errno = EAFNOSUPPORT;
1370 return -1;
1371 }
1372
1373 enum swrap_packet_type {
1374 SWRAP_CONNECT_SEND,
1375 SWRAP_CONNECT_UNREACH,
1376 SWRAP_CONNECT_RECV,
1377 SWRAP_CONNECT_ACK,
1378 SWRAP_ACCEPT_SEND,
1379 SWRAP_ACCEPT_RECV,
1380 SWRAP_ACCEPT_ACK,
1381 SWRAP_RECVFROM,
1382 SWRAP_SENDTO,
1383 SWRAP_SENDTO_UNREACH,
1384 SWRAP_PENDING_RST,
1385 SWRAP_RECV,
1386 SWRAP_RECV_RST,
1387 SWRAP_SEND,
1388 SWRAP_SEND_RST,
1389 SWRAP_CLOSE_SEND,
1390 SWRAP_CLOSE_RECV,
1391 SWRAP_CLOSE_ACK,
1392 };
1393
1394 struct swrap_file_hdr {
1395 uint32_t magic;
1396 uint16_t version_major;
1397 uint16_t version_minor;
1398 int32_t timezone;
1399 uint32_t sigfigs;
1400 uint32_t frame_max_len;
1401 #define SWRAP_FRAME_LENGTH_MAX 0xFFFF
1402 uint32_t link_type;
1403 };
1404 #define SWRAP_FILE_HDR_SIZE 24
1405
1406 struct swrap_packet_frame {
1407 uint32_t seconds;
1408 uint32_t micro_seconds;
1409 uint32_t recorded_length;
1410 uint32_t full_length;
1411 };
1412 #define SWRAP_PACKET_FRAME_SIZE 16
1413
1414 union swrap_packet_ip {
1415 struct {
1416 uint8_t ver_hdrlen;
1417 uint8_t tos;
1418 uint16_t packet_length;
1419 uint16_t identification;
1420 uint8_t flags;
1421 uint8_t fragment;
1422 uint8_t ttl;
1423 uint8_t protocol;
1424 uint16_t hdr_checksum;
1425 uint32_t src_addr;
1426 uint32_t dest_addr;
1427 } v4;
1428 #define SWRAP_PACKET_IP_V4_SIZE 20
1429 struct {
1430 uint8_t ver_prio;
1431 uint8_t flow_label_high;
1432 uint16_t flow_label_low;
1433 uint16_t payload_length;
1434 uint8_t next_header;
1435 uint8_t hop_limit;
1436 uint8_t src_addr[16];
1437 uint8_t dest_addr[16];
1438 } v6;
1439 #define SWRAP_PACKET_IP_V6_SIZE 40
1440 };
1441 #define SWRAP_PACKET_IP_SIZE 40
1442
1443 union swrap_packet_payload {
1444 struct {
1445 uint16_t source_port;
1446 uint16_t dest_port;
1447 uint32_t seq_num;
1448 uint32_t ack_num;
1449 uint8_t hdr_length;
1450 uint8_t control;
1451 uint16_t window;
1452 uint16_t checksum;
1453 uint16_t urg;
1454 } tcp;
1455 #define SWRAP_PACKET_PAYLOAD_TCP_SIZE 20
1456 struct {
1457 uint16_t source_port;
1458 uint16_t dest_port;
1459 uint16_t length;
1460 uint16_t checksum;
1461 } udp;
1462 #define SWRAP_PACKET_PAYLOAD_UDP_SIZE 8
1463 struct {
1464 uint8_t type;
1465 uint8_t code;
1466 uint16_t checksum;
1467 uint32_t unused;
1468 } icmp4;
1469 #define SWRAP_PACKET_PAYLOAD_ICMP4_SIZE 8
1470 struct {
1471 uint8_t type;
1472 uint8_t code;
1473 uint16_t checksum;
1474 uint32_t unused;
1475 } icmp6;
1476 #define SWRAP_PACKET_PAYLOAD_ICMP6_SIZE 8
1477 };
1478 #define SWRAP_PACKET_PAYLOAD_SIZE 20
1479
1480 #define SWRAP_PACKET_MIN_ALLOC \
1481 (SWRAP_PACKET_FRAME_SIZE + \
1482 SWRAP_PACKET_IP_SIZE + \
1483 SWRAP_PACKET_PAYLOAD_SIZE)
1484
1485 static const char *socket_wrapper_pcap_file(void)
1486 {
1487 static int initialized = 0;
1488 static const char *s = NULL;
1489 static const struct swrap_file_hdr h;
1490 static const struct swrap_packet_frame f;
1491 static const union swrap_packet_ip i;
1492 static const union swrap_packet_payload p;
1493
1494 if (initialized == 1) {
1495 return s;
1496 }
1497 initialized = 1;
1498
1499 /*
1500 * TODO: don't use the structs use plain buffer offsets
1501 * and PUSH_U8(), PUSH_U16() and PUSH_U32()
1502 *
1503 * for now make sure we disable PCAP support
1504 * if the struct has alignment!
1505 */
1506 if (sizeof(h) != SWRAP_FILE_HDR_SIZE) {
1507 return NULL;
1508 }
1509 if (sizeof(f) != SWRAP_PACKET_FRAME_SIZE) {
1510 return NULL;
1511 }
1512 if (sizeof(i) != SWRAP_PACKET_IP_SIZE) {
1513 return NULL;
1514 }
1515 if (sizeof(i.v4) != SWRAP_PACKET_IP_V4_SIZE) {
1516 return NULL;
1517 }
1518 if (sizeof(i.v6) != SWRAP_PACKET_IP_V6_SIZE) {
1519 return NULL;
1520 }
1521 if (sizeof(p) != SWRAP_PACKET_PAYLOAD_SIZE) {
1522 return NULL;
1523 }
1524 if (sizeof(p.tcp) != SWRAP_PACKET_PAYLOAD_TCP_SIZE) {
1525 return NULL;
1526 }
1527 if (sizeof(p.udp) != SWRAP_PACKET_PAYLOAD_UDP_SIZE) {
1528 return NULL;
1529 }
1530 if (sizeof(p.icmp4) != SWRAP_PACKET_PAYLOAD_ICMP4_SIZE) {
1531 return NULL;
1532 }
1533 if (sizeof(p.icmp6) != SWRAP_PACKET_PAYLOAD_ICMP6_SIZE) {
1534 return NULL;
1535 }
1536
1537 s = getenv("SOCKET_WRAPPER_PCAP_FILE");
1538 if (s == NULL) {
1539 return NULL;
1540 }
1541 if (strncmp(s, "./", 2) == 0) {
1542 s += 2;
1543 }
1544 return s;
1545 }
1546
1547 static uint8_t *swrap_packet_init(struct timeval *tval,
1548 const struct sockaddr *src,
1549 const struct sockaddr *dest,
1550 int socket_type,
1551 const uint8_t *payload,
1552 size_t payload_len,
1553 unsigned long tcp_seqno,
1554 unsigned long tcp_ack,
1555 unsigned char tcp_ctl,
1556 int unreachable,
1557 size_t *_packet_len)
1558 {
1559 uint8_t *base;
1560 uint8_t *buf;
1561 struct swrap_packet_frame *frame;
1562 union swrap_packet_ip *ip;
1563 union swrap_packet_payload *pay;
1564 size_t packet_len;
1565 size_t alloc_len;
1566 size_t nonwire_len = sizeof(*frame);
1567 size_t wire_hdr_len = 0;
1568 size_t wire_len = 0;
1569 size_t ip_hdr_len = 0;
1570 size_t icmp_hdr_len = 0;
1571 size_t icmp_truncate_len = 0;
1572 uint8_t protocol = 0, icmp_protocol = 0;
1573 const struct sockaddr_in *src_in = NULL;
1574 const struct sockaddr_in *dest_in = NULL;
1575 #ifdef HAVE_IPV6
1576 const struct sockaddr_in6 *src_in6 = NULL;
1577 const struct sockaddr_in6 *dest_in6 = NULL;
1578 #endif
1579 uint16_t src_port;
1580 uint16_t dest_port;
1581
1582 switch (src->sa_family) {
1583 case AF_INET:
1584 src_in = (const struct sockaddr_in *)src;
1585 dest_in = (const struct sockaddr_in *)dest;
1586 src_port = src_in->sin_port;
1587 dest_port = dest_in->sin_port;
1588 ip_hdr_len = sizeof(ip->v4);
1589 break;
1590 #ifdef HAVE_IPV6
1591 case AF_INET6:
1592 src_in6 = (const struct sockaddr_in6 *)src;
1593 dest_in6 = (const struct sockaddr_in6 *)dest;
1594 src_port = src_in6->sin6_port;
1595 dest_port = dest_in6->sin6_port;
1596 ip_hdr_len = sizeof(ip->v6);
1597 break;
1598 #endif
1599 default:
1600 return NULL;
1601 }
1602
1603 switch (socket_type) {
1604 case SOCK_STREAM:
1605 protocol = 0x06; /* TCP */
1606 wire_hdr_len = ip_hdr_len + sizeof(pay->tcp);
1607 wire_len = wire_hdr_len + payload_len;
1608 break;
1609
1610 case SOCK_DGRAM:
1611 protocol = 0x11; /* UDP */
1612 wire_hdr_len = ip_hdr_len + sizeof(pay->udp);
1613 wire_len = wire_hdr_len + payload_len;
1614 break;
1615
1616 default:
1617 return NULL;
1618 }
1619
1620 if (unreachable) {
1621 icmp_protocol = protocol;
1622 switch (src->sa_family) {
1623 case AF_INET:
1624 protocol = 0x01; /* ICMPv4 */
1625 icmp_hdr_len = ip_hdr_len + sizeof(pay->icmp4);
1626 break;
1627 #ifdef HAVE_IPV6
1628 case AF_INET6:
1629 protocol = 0x3A; /* ICMPv6 */
1630 icmp_hdr_len = ip_hdr_len + sizeof(pay->icmp6);
1631 break;
1632 #endif
1633 }
1634 if (wire_len > 64 ) {
1635 icmp_truncate_len = wire_len - 64;
1636 }
1637 wire_hdr_len += icmp_hdr_len;
1638 wire_len += icmp_hdr_len;
1639 }
1640
1641 packet_len = nonwire_len + wire_len;
1642 alloc_len = packet_len;
1643 if (alloc_len < SWRAP_PACKET_MIN_ALLOC) {
1644 alloc_len = SWRAP_PACKET_MIN_ALLOC;
1645 }
1646
1647 base = (uint8_t *)malloc(alloc_len);
1648 if (base == NULL) {
1649 return NULL;
1650 }
1651 memset(base, 0x0, alloc_len);
1652
1653 buf = base;
1654
1655 frame = (struct swrap_packet_frame *)buf;
1656 frame->seconds = tval->tv_sec;
1657 frame->micro_seconds = tval->tv_usec;
1658 frame->recorded_length = wire_len - icmp_truncate_len;
1659 frame->full_length = wire_len - icmp_truncate_len;
1660 buf += SWRAP_PACKET_FRAME_SIZE;
1661
1662 ip = (union swrap_packet_ip *)buf;
1663 switch (src->sa_family) {
1664 case AF_INET:
1665 ip->v4.ver_hdrlen = 0x45; /* version 4 and 5 * 32 bit words */
1666 ip->v4.tos = 0x00;
1667 ip->v4.packet_length = htons(wire_len - icmp_truncate_len);
1668 ip->v4.identification = htons(0xFFFF);
1669 ip->v4.flags = 0x40; /* BIT 1 set - means don't fragment */
1670 ip->v4.fragment = htons(0x0000);
1671 ip->v4.ttl = 0xFF;
1672 ip->v4.protocol = protocol;
1673 ip->v4.hdr_checksum = htons(0x0000);
1674 ip->v4.src_addr = src_in->sin_addr.s_addr;
1675 ip->v4.dest_addr = dest_in->sin_addr.s_addr;
1676 buf += SWRAP_PACKET_IP_V4_SIZE;
1677 break;
1678 #ifdef HAVE_IPV6
1679 case AF_INET6:
1680 ip->v6.ver_prio = 0x60; /* version 4 and 5 * 32 bit words */
1681 ip->v6.flow_label_high = 0x00;
1682 ip->v6.flow_label_low = 0x0000;
1683 ip->v6.payload_length = htons(wire_len - icmp_truncate_len); /* TODO */
1684 ip->v6.next_header = protocol;
1685 memcpy(ip->v6.src_addr, src_in6->sin6_addr.s6_addr, 16);
1686 memcpy(ip->v6.dest_addr, dest_in6->sin6_addr.s6_addr, 16);
1687 buf += SWRAP_PACKET_IP_V6_SIZE;
1688 break;
1689 #endif
1690 }
1691
1692 if (unreachable) {
1693 pay = (union swrap_packet_payload *)buf;
1694 switch (src->sa_family) {
1695 case AF_INET:
1696 pay->icmp4.type = 0x03; /* destination unreachable */
1697 pay->icmp4.code = 0x01; /* host unreachable */
1698 pay->icmp4.checksum = htons(0x0000);
1699 pay->icmp4.unused = htonl(0x00000000);
1700 buf += SWRAP_PACKET_PAYLOAD_ICMP4_SIZE;
1701
1702 /* set the ip header in the ICMP payload */
1703 ip = (union swrap_packet_ip *)buf;
1704 ip->v4.ver_hdrlen = 0x45; /* version 4 and 5 * 32 bit words */
1705 ip->v4.tos = 0x00;
1706 ip->v4.packet_length = htons(wire_len - icmp_hdr_len);
1707 ip->v4.identification = htons(0xFFFF);
1708 ip->v4.flags = 0x40; /* BIT 1 set - means don't fragment */
1709 ip->v4.fragment = htons(0x0000);
1710 ip->v4.ttl = 0xFF;
1711 ip->v4.protocol = icmp_protocol;
1712 ip->v4.hdr_checksum = htons(0x0000);
1713 ip->v4.src_addr = dest_in->sin_addr.s_addr;
1714 ip->v4.dest_addr = src_in->sin_addr.s_addr;
1715 buf += SWRAP_PACKET_IP_V4_SIZE;
1716
1717 src_port = dest_in->sin_port;
1718 dest_port = src_in->sin_port;
1719 break;
1720 #ifdef HAVE_IPV6
1721 case AF_INET6:
1722 pay->icmp6.type = 0x01; /* destination unreachable */
1723 pay->icmp6.code = 0x03; /* address unreachable */
1724 pay->icmp6.checksum = htons(0x0000);
1725 pay->icmp6.unused = htonl(0x00000000);
1726 buf += SWRAP_PACKET_PAYLOAD_ICMP6_SIZE;
1727
1728 /* set the ip header in the ICMP payload */
1729 ip = (union swrap_packet_ip *)buf;
1730 ip->v6.ver_prio = 0x60; /* version 4 and 5 * 32 bit words */
1731 ip->v6.flow_label_high = 0x00;
1732 ip->v6.flow_label_low = 0x0000;
1733 ip->v6.payload_length = htons(wire_len - icmp_truncate_len); /* TODO */
1734 ip->v6.next_header = protocol;
1735 memcpy(ip->v6.src_addr, dest_in6->sin6_addr.s6_addr, 16);
1736 memcpy(ip->v6.dest_addr, src_in6->sin6_addr.s6_addr, 16);
1737 buf += SWRAP_PACKET_IP_V6_SIZE;
1738
1739 src_port = dest_in6->sin6_port;
1740 dest_port = src_in6->sin6_port;
1741 break;
1742 #endif
1743 }
1744 }
1745
1746 pay = (union swrap_packet_payload *)buf;
1747
1748 switch (socket_type) {
1749 case SOCK_STREAM:
1750 pay->tcp.source_port = src_port;
1751 pay->tcp.dest_port = dest_port;
1752 pay->tcp.seq_num = htonl(tcp_seqno);
1753 pay->tcp.ack_num = htonl(tcp_ack);
1754 pay->tcp.hdr_length = 0x50; /* 5 * 32 bit words */
1755 pay->tcp.control = tcp_ctl;
1756 pay->tcp.window = htons(0x7FFF);
1757 pay->tcp.checksum = htons(0x0000);
1758 pay->tcp.urg = htons(0x0000);
1759 buf += SWRAP_PACKET_PAYLOAD_TCP_SIZE;
1760
1761 break;
1762
1763 case SOCK_DGRAM:
1764 pay->udp.source_port = src_port;
1765 pay->udp.dest_port = dest_port;
1766 pay->udp.length = htons(8 + payload_len);
1767 pay->udp.checksum = htons(0x0000);
1768 buf += SWRAP_PACKET_PAYLOAD_UDP_SIZE;
1769
1770 break;
1771 }
1772
1773 if (payload && payload_len > 0) {
1774 memcpy(buf, payload, payload_len);
1775 }
1776
1777 *_packet_len = packet_len - icmp_truncate_len;
1778 return base;
1779 }
1780
1781 static int swrap_get_pcap_fd(const char *fname)
1782 {
1783 static int fd = -1;
1784
1785 if (fd != -1) return fd;
1786
1787 fd = libc_open(fname, O_WRONLY|O_CREAT|O_EXCL|O_APPEND, 0644);
1788 if (fd != -1) {
1789 struct swrap_file_hdr file_hdr;
1790 file_hdr.magic = 0xA1B2C3D4;
1791 file_hdr.version_major = 0x0002;
1792 file_hdr.version_minor = 0x0004;
1793 file_hdr.timezone = 0x00000000;
1794 file_hdr.sigfigs = 0x00000000;
1795 file_hdr.frame_max_len = SWRAP_FRAME_LENGTH_MAX;
1796 file_hdr.link_type = 0x0065; /* 101 RAW IP */
1797
1798 if (write(fd, &file_hdr, sizeof(file_hdr)) != sizeof(file_hdr)) {
1799 close(fd);
1800 fd = -1;
1801 }
1802 return fd;
1803 }
1804
1805 fd = libc_open(fname, O_WRONLY|O_APPEND, 0644);
1806
1807 return fd;
1808 }
1809
1810 static uint8_t *swrap_marshall_packet(struct socket_info *si,
1811 const struct sockaddr *addr,
1812 enum swrap_packet_type type,
1813 const void *buf, size_t len,
1814 size_t *packet_len)
1815 {
1816 const struct sockaddr *src_addr;
1817 const struct sockaddr *dest_addr;
1818 unsigned long tcp_seqno = 0;
1819 unsigned long tcp_ack = 0;
1820 unsigned char tcp_ctl = 0;
1821 int unreachable = 0;
1822
1823 struct timeval tv;
1824
1825 switch (si->family) {
1826 case AF_INET:
1827 break;
1828 #ifdef HAVE_IPV6
1829 case AF_INET6:
1830 break;
1831 #endif
1832 default:
1833 return NULL;
1834 }
1835
1836 switch (type) {
1837 case SWRAP_CONNECT_SEND:
1838 if (si->type != SOCK_STREAM) return NULL;
1839
1840 src_addr = si->myname;
1841 dest_addr = addr;
1842
1843 tcp_seqno = si->io.pck_snd;
1844 tcp_ack = si->io.pck_rcv;
1845 tcp_ctl = 0x02; /* SYN */
1846
1847 si->io.pck_snd += 1;
1848
1849 break;
1850
1851 case SWRAP_CONNECT_RECV:
1852 if (si->type != SOCK_STREAM) return NULL;
1853
1854 dest_addr = si->myname;
1855 src_addr = addr;
1856
1857 tcp_seqno = si->io.pck_rcv;
1858 tcp_ack = si->io.pck_snd;
1859 tcp_ctl = 0x12; /** SYN,ACK */
1860
1861 si->io.pck_rcv += 1;
1862
1863 break;
1864
1865 case SWRAP_CONNECT_UNREACH:
1866 if (si->type != SOCK_STREAM) return NULL;
1867
1868 dest_addr = si->myname;
1869 src_addr = addr;
1870
1871 /* Unreachable: resend the data of SWRAP_CONNECT_SEND */
1872 tcp_seqno = si->io.pck_snd - 1;
1873 tcp_ack = si->io.pck_rcv;
1874 tcp_ctl = 0x02; /* SYN */
1875 unreachable = 1;
1876
1877 break;
1878
1879 case SWRAP_CONNECT_ACK:
1880 if (si->type != SOCK_STREAM) return NULL;
1881
1882 src_addr = si->myname;
1883 dest_addr = addr;
1884
1885 tcp_seqno = si->io.pck_snd;
1886 tcp_ack = si->io.pck_rcv;
1887 tcp_ctl = 0x10; /* ACK */
1888
1889 break;
1890
1891 case SWRAP_ACCEPT_SEND:
1892 if (si->type != SOCK_STREAM) return NULL;
1893
1894 dest_addr = si->myname;
1895 src_addr = addr;
1896
1897 tcp_seqno = si->io.pck_rcv;
1898 tcp_ack = si->io.pck_snd;
1899 tcp_ctl = 0x02; /* SYN */
1900
1901 si->io.pck_rcv += 1;
1902
1903 break;
1904
1905 case SWRAP_ACCEPT_RECV:
1906 if (si->type != SOCK_STREAM) return NULL;
1907
1908 src_addr = si->myname;
1909 dest_addr = addr;
1910
1911 tcp_seqno = si->io.pck_snd;
1912 tcp_ack = si->io.pck_rcv;
1913 tcp_ctl = 0x12; /* SYN,ACK */
1914
1915 si->io.pck_snd += 1;
1916
1917 break;
1918
1919 case SWRAP_ACCEPT_ACK:
1920 if (si->type != SOCK_STREAM) return NULL;
1921
1922 dest_addr = si->myname;
1923 src_addr = addr;
1924
1925 tcp_seqno = si->io.pck_rcv;
1926 tcp_ack = si->io.pck_snd;
1927 tcp_ctl = 0x10; /* ACK */
1928
1929 break;
1930
1931 case SWRAP_SEND:
1932 src_addr = si->myname;
1933 dest_addr = si->peername;
1934
1935 tcp_seqno = si->io.pck_snd;
1936 tcp_ack = si->io.pck_rcv;
1937 tcp_ctl = 0x18; /* PSH,ACK */
1938
1939 si->io.pck_snd += len;
1940
1941 break;
1942
1943 case SWRAP_SEND_RST:
1944 dest_addr = si->myname;
1945 src_addr = si->peername;
1946
1947 if (si->type == SOCK_DGRAM) {
1948 return swrap_marshall_packet(si, si->peername,
1949 SWRAP_SENDTO_UNREACH,
1950 buf, len, packet_len);
1951 }
1952
1953 tcp_seqno = si->io.pck_rcv;
1954 tcp_ack = si->io.pck_snd;
1955 tcp_ctl = 0x14; /** RST,ACK */
1956
1957 break;
1958
1959 case SWRAP_PENDING_RST:
1960 dest_addr = si->myname;
1961 src_addr = si->peername;
1962
1963 if (si->type == SOCK_DGRAM) {
1964 return NULL;
1965 }
1966
1967 tcp_seqno = si->io.pck_rcv;
1968 tcp_ack = si->io.pck_snd;
1969 tcp_ctl = 0x14; /* RST,ACK */
1970
1971 break;
1972
1973 case SWRAP_RECV:
1974 dest_addr = si->myname;
1975 src_addr = si->peername;
1976
1977 tcp_seqno = si->io.pck_rcv;
1978 tcp_ack = si->io.pck_snd;
1979 tcp_ctl = 0x18; /* PSH,ACK */
1980
1981 si->io.pck_rcv += len;
1982
1983 break;
1984
1985 case SWRAP_RECV_RST:
1986 dest_addr = si->myname;
1987 src_addr = si->peername;
1988
1989 if (si->type == SOCK_DGRAM) {
1990 return NULL;
1991 }
1992
1993 tcp_seqno = si->io.pck_rcv;
1994 tcp_ack = si->io.pck_snd;
1995 tcp_ctl = 0x14; /* RST,ACK */
1996
1997 break;
1998
1999 case SWRAP_SENDTO:
2000 src_addr = si->myname;
2001 dest_addr = addr;
2002
2003 si->io.pck_snd += len;
2004
2005 break;
2006
2007 case SWRAP_SENDTO_UNREACH:
2008 dest_addr = si->myname;
2009 src_addr = addr;
2010
2011 unreachable = 1;
2012
2013 break;
2014
2015 case SWRAP_RECVFROM:
2016 dest_addr = si->myname;
2017 src_addr = addr;
2018
2019 si->io.pck_rcv += len;
2020
2021 break;
2022
2023 case SWRAP_CLOSE_SEND:
2024 if (si->type != SOCK_STREAM) return NULL;
2025
2026 src_addr = si->myname;
2027 dest_addr = si->peername;
2028
2029 tcp_seqno = si->io.pck_snd;
2030 tcp_ack = si->io.pck_rcv;
2031 tcp_ctl = 0x11; /* FIN, ACK */
2032
2033 si->io.pck_snd += 1;
2034
2035 break;
2036
2037 case SWRAP_CLOSE_RECV:
2038 if (si->type != SOCK_STREAM) return NULL;
2039
2040 dest_addr = si->myname;
2041 src_addr = si->peername;
2042
2043 tcp_seqno = si->io.pck_rcv;
2044 tcp_ack = si->io.pck_snd;
2045 tcp_ctl = 0x11; /* FIN,ACK */
2046
2047 si->io.pck_rcv += 1;
2048
2049 break;
2050
2051 case SWRAP_CLOSE_ACK:
2052 if (si->type != SOCK_STREAM) return NULL;
2053
2054 src_addr = si->myname;
2055 dest_addr = si->peername;
2056
2057 tcp_seqno = si->io.pck_snd;
2058 tcp_ack = si->io.pck_rcv;
2059 tcp_ctl = 0x10; /* ACK */
2060
2061 break;
2062 default:
2063 return NULL;
2064 }
2065
2066 swrapGetTimeOfDay(&tv);
2067
2068 return swrap_packet_init(&tv, src_addr, dest_addr, si->type,
2069 (const uint8_t *)buf, len,
2070 tcp_seqno, tcp_ack, tcp_ctl, unreachable,
2071 packet_len);
2072 }
2073
2074 static void swrap_dump_packet(struct socket_info *si,
2075 const struct sockaddr *addr,
2076 enum swrap_packet_type type,
2077 const void *buf, size_t len)
2078 {
2079 const char *file_name;
2080 uint8_t *packet;
2081 size_t packet_len = 0;
2082 int fd;
2083
2084 file_name = socket_wrapper_pcap_file();
2085 if (!file_name) {
2086 return;
2087 }
2088
2089 packet = swrap_marshall_packet(si, addr, type, buf, len, &packet_len);
2090 if (!packet) {
2091 return;
2092 }
2093
2094 fd = swrap_get_pcap_fd(file_name);
2095 if (fd != -1) {
2096 if (write(fd, packet, packet_len) != (ssize_t)packet_len) {
2097 free(packet);
2098 return;
2099 }
2100 }
2101
2102 free(packet);
2103 }
2104
2105 /****************************************************************************
2106 * SIGNALFD
2107 ***************************************************************************/
2108
2109 #ifdef HAVE_SIGNALFD
2110 static int swrap_signalfd(int fd, const sigset_t *mask, int flags)
2111 {
2112 int rc;
2113
2114 rc = libc_signalfd(fd, mask, flags);
2115 if (rc != -1) {
2116 swrap_remove_stale(fd);
2117 }
2118
2119 return rc;
2120 }
2121
2122 int signalfd(int fd, const sigset_t *mask, int flags)
2123 {
2124 return swrap_signalfd(fd, mask, flags);
2125 }
2126 #endif
2127
2128 /****************************************************************************
2129 * SOCKET
2130 ***************************************************************************/
2131
2132 static int swrap_socket(int family, int type, int protocol)
2133 {
2134 struct socket_info *si;
2135 struct socket_info_fd *fi;
2136 int fd;
2137 int real_type = type;
2138
2139 /*
2140 * Remove possible addition flags passed to socket() so
2141 * do not fail checking the type.
2142 * See https://lwn.net/Articles/281965/
2143 */
2144 #ifdef SOCK_CLOEXEC
2145 real_type &= ~SOCK_CLOEXEC;
2146 #endif
2147 #ifdef SOCK_NONBLOCK
2148 real_type &= ~SOCK_NONBLOCK;
2149 #endif
2150
2151 if (!socket_wrapper_enabled()) {
2152 return libc_socket(family, type, protocol);
2153 }
2154
2155 switch (family) {
2156 case AF_INET:
2157 #ifdef HAVE_IPV6
2158 case AF_INET6:
2159 #endif
2160 break;
2161 case AF_UNIX:
2162 return libc_socket(family, type, protocol);
2163 default:
2164 errno = EAFNOSUPPORT;
2165 return -1;
2166 }
2167
2168 switch (real_type) {
2169 case SOCK_STREAM:
2170 break;
2171 case SOCK_DGRAM:
2172 break;
2173 default:
2174 errno = EPROTONOSUPPORT;
2175 return -1;
2176 }
2177
2178 switch (protocol) {
2179 case 0:
2180 break;
2181 case 6:
2182 if (real_type == SOCK_STREAM) {
2183 break;
2184 }
2185 /*fall through*/
2186 case 17:
2187 if (real_type == SOCK_DGRAM) {
2188 break;
2189 }
2190 /*fall through*/
2191 default:
2192 errno = EPROTONOSUPPORT;
2193 return -1;
2194 }
2195
2196 /*
2197 * We must call libc_socket with type, from the caller, not the version
2198 * we removed SOCK_CLOEXEC and SOCK_NONBLOCK from
2199 */
2200 fd = libc_socket(AF_UNIX, type, 0);
2201
2202 if (fd == -1) {
2203 return -1;
2204 }
2205
2206 /* Check if we have a stale fd and remove it */
2207 si = find_socket_info(fd);
2208 if (si != NULL) {
2209 swrap_remove_stale(fd);
2210 }
2211
2212 si = (struct socket_info *)malloc(sizeof(struct socket_info));
2213 memset(si, 0, sizeof(struct socket_info));
2214 if (si == NULL) {
2215 errno = ENOMEM;
2216 return -1;
2217 }
2218
2219 si->family = family;
2220
2221 /* however, the rest of the socket_wrapper code expects just
2222 * the type, not the flags */
2223 si->type = real_type;
2224 si->protocol = protocol;
2225
2226 fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd));
2227 if (fi == NULL) {
2228 free(si);
2229 errno = ENOMEM;
2230 return -1;
2231 }
2232
2233 fi->fd = fd;
2234
2235 SWRAP_DLIST_ADD(si->fds, fi);
2236 SWRAP_DLIST_ADD(sockets, si);
2237
2238 return fd;
2239 }
2240
2241 int socket(int family, int type, int protocol)
2242 {
2243 return swrap_socket(family, type, protocol);
2244 }
2245
2246 /****************************************************************************
2247 * SOCKETPAIR
2248 ***************************************************************************/
2249
2250 static int swrap_socketpair(int family, int type, int protocol, int sv[2])
2251 {
2252 int rc;
2253
2254 rc = libc_socketpair(family, type, protocol, sv);
2255 if (rc != -1) {
2256 swrap_remove_stale(sv[0]);
2257 swrap_remove_stale(sv[1]);
2258 }
2259
2260 return rc;
2261 }
2262
2263 int socketpair(int family, int type, int protocol, int sv[2])
2264 {
2265 return swrap_socketpair(family, type, protocol, sv);
2266 }
2267
2268 /****************************************************************************
2269 * SOCKETPAIR
2270 ***************************************************************************/
2271
2272 #ifdef HAVE_TIMERFD_CREATE
2273 static int swrap_timerfd_create(int clockid, int flags)
2274 {
2275 int fd;
2276
2277 fd = libc_timerfd_create(clockid, flags);
2278 if (fd != -1) {
2279 swrap_remove_stale(fd);
2280 }
2281
2282 return fd;
2283 }
2284
2285 int timerfd_create(int clockid, int flags)
2286 {
2287 return swrap_timerfd_create(clockid, flags);
2288 }
2289 #endif
2290
2291 /****************************************************************************
2292 * PIPE
2293 ***************************************************************************/
2294
2295 static int swrap_pipe(int pipefd[2])
2296 {
2297 int rc;
2298
2299 rc = libc_pipe(pipefd);
2300 if (rc != -1) {
2301 swrap_remove_stale(pipefd[0]);
2302 swrap_remove_stale(pipefd[1]);
2303 }
2304
2305 return rc;
2306 }
2307
2308 int pipe(int pipefd[2])
2309 {
2310 return swrap_pipe(pipefd);
2311 }
2312
2313 /****************************************************************************
2314 * ACCEPT
2315 ***************************************************************************/
2316
2317 static int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
2318 {
2319 struct socket_info *parent_si, *child_si;
2320 struct socket_info_fd *child_fi;
2321 int fd;
2322 struct sockaddr_un un_addr;
2323 socklen_t un_addrlen = sizeof(un_addr);
2324 struct sockaddr_un un_my_addr;
2325 socklen_t un_my_addrlen = sizeof(un_my_addr);
2326 struct sockaddr *my_addr;
2327 socklen_t my_addrlen, len;
2328 int ret;
2329
2330 parent_si = find_socket_info(s);
2331 if (!parent_si) {
2332 return libc_accept(s, addr, addrlen);
2333 }
2334
2335 /*
2336 * assume out sockaddr have the same size as the in parent
2337 * socket family
2338 */
2339 my_addrlen = socket_length(parent_si->family);
2340 if (my_addrlen <= 0) {
2341 errno = EINVAL;
2342 return -1;
2343 }
2344
2345 my_addr = (struct sockaddr *)malloc(my_addrlen);
2346 if (my_addr == NULL) {
2347 return -1;
2348 }
2349
2350 memset(&un_addr, 0, sizeof(un_addr));
2351 memset(&un_my_addr, 0, sizeof(un_my_addr));
2352
2353 ret = libc_accept(s, (struct sockaddr *)(void *)&un_addr, &un_addrlen);
2354 if (ret == -1) {
2355 if (errno == ENOTSOCK) {
2356 /* Remove stale fds */
2357 swrap_remove_stale(s);
2358 }
2359 free(my_addr);
2360 return ret;
2361 }
2362
2363 fd = ret;
2364
2365 len = my_addrlen;
2366 ret = sockaddr_convert_from_un(parent_si, &un_addr, un_addrlen,
2367 parent_si->family, my_addr, &len);
2368 if (ret == -1) {
2369 free(my_addr);
2370 close(fd);
2371 return ret;
2372 }
2373
2374 child_si = (struct socket_info *)malloc(sizeof(struct socket_info));
2375 memset(child_si, 0, sizeof(struct socket_info));
2376
2377 child_fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd));
2378 if (child_fi == NULL) {
2379 free(child_si);
2380 free(my_addr);
2381 close(fd);
2382 errno = ENOMEM;
2383 return -1;
2384 }
2385
2386 child_fi->fd = fd;
2387
2388 SWRAP_DLIST_ADD(child_si->fds, child_fi);
2389
2390 child_si->family = parent_si->family;
2391 child_si->type = parent_si->type;
2392 child_si->protocol = parent_si->protocol;
2393 child_si->bound = 1;
2394 child_si->is_server = 1;
2395 child_si->connected = 1;
2396
2397 child_si->peername_len = len;
2398 child_si->peername = sockaddr_dup(my_addr, len);
2399
2400 if (addr != NULL && addrlen != NULL) {
2401 size_t copy_len = MIN(*addrlen, len);
2402 if (copy_len > 0) {
2403 memcpy(addr, my_addr, copy_len);
2404 }
2405 *addrlen = len;
2406 }
2407
2408 ret = libc_getsockname(fd,
2409 (struct sockaddr *)(void *)&un_my_addr,
2410 &un_my_addrlen);
2411 if (ret == -1) {
2412 free(child_fi);
2413 free(child_si);
2414 free(my_addr);
2415 close(fd);
2416 return ret;
2417 }
2418
2419 len = my_addrlen;
2420 ret = sockaddr_convert_from_un(child_si, &un_my_addr, un_my_addrlen,
2421 child_si->family, my_addr, &len);
2422 if (ret == -1) {
2423 free(child_fi);
2424 free(child_si);
2425 free(my_addr);
2426 close(fd);
2427 return ret;
2428 }
2429
2430 SWRAP_LOG(SWRAP_LOG_TRACE,
2431 "accept() path=%s, fd=%d",
2432 un_my_addr.sun_path, s);
2433
2434 child_si->myname_len = len;
2435 child_si->myname = sockaddr_dup(my_addr, len);
2436 free(my_addr);
2437
2438 SWRAP_DLIST_ADD(sockets, child_si);
2439
2440 if (addr != NULL) {
2441 swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_SEND, NULL, 0);
2442 swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_RECV, NULL, 0);
2443 swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_ACK, NULL, 0);
2444 }
2445
2446 return fd;
2447 }
2448
2449 #ifdef HAVE_ACCEPT_PSOCKLEN_T
2450 int accept(int s, struct sockaddr *addr, Psocklen_t addrlen)
2451 #else
2452 int accept(int s, struct sockaddr *addr, socklen_t *addrlen)
2453 #endif
2454 {
2455 return swrap_accept(s, addr, (socklen_t *)addrlen);
2456 }
2457
2458 static int autobind_start_init;
2459 static int autobind_start;
2460
2461 /* using sendto() or connect() on an unbound socket would give the
2462 recipient no way to reply, as unlike UDP and TCP, a unix domain
2463 socket can't auto-assign ephemeral port numbers, so we need to
2464 assign it here.
2465 Note: this might change the family from ipv6 to ipv4
2466 */
2467 static int swrap_auto_bind(int fd, struct socket_info *si, int family)
2468 {
2469 struct sockaddr_un un_addr;
2470 int i;
2471 char type;
2472 int ret;
2473 int port;
2474 struct stat st;
2475
2476 if (autobind_start_init != 1) {
2477 autobind_start_init = 1;
2478 autobind_start = getpid();
2479 autobind_start %= 50000;
2480 autobind_start += 10000;
2481 }
2482
2483 un_addr.sun_family = AF_UNIX;
2484
2485 switch (family) {
2486 case AF_INET: {
2487 struct sockaddr_in in;
2488
2489 switch (si->type) {
2490 case SOCK_STREAM:
2491 type = SOCKET_TYPE_CHAR_TCP;
2492 break;
2493 case SOCK_DGRAM:
2494 type = SOCKET_TYPE_CHAR_UDP;
2495 break;
2496 default:
2497 errno = ESOCKTNOSUPPORT;
2498 return -1;
2499 }
2500
2501 memset(&in, 0, sizeof(in));
2502 in.sin_family = AF_INET;
2503 in.sin_addr.s_addr = htonl(127<<24 |
2504 socket_wrapper_default_iface());
2505
2506 si->myname_len = sizeof(in);
2507 si->myname = sockaddr_dup(&in, si->myname_len);
2508 break;
2509 }
2510 #ifdef HAVE_IPV6
2511 case AF_INET6: {
2512 struct sockaddr_in6 in6;
2513
2514 if (si->family != family) {
2515 errno = ENETUNREACH;
2516 return -1;
2517 }
2518
2519 switch (si->type) {
2520 case SOCK_STREAM:
2521 type = SOCKET_TYPE_CHAR_TCP_V6;
2522 break;
2523 case SOCK_DGRAM:
2524 type = SOCKET_TYPE_CHAR_UDP_V6;
2525 break;
2526 default:
2527 errno = ESOCKTNOSUPPORT;
2528 return -1;
2529 }
2530
2531 memset(&in6, 0, sizeof(in6));
2532 in6.sin6_family = AF_INET6;
2533 in6.sin6_addr = *swrap_ipv6();
2534 in6.sin6_addr.s6_addr[15] = socket_wrapper_default_iface();
2535 si->myname_len = sizeof(in6);
2536 si->myname = sockaddr_dup(&in6, si->myname_len);
2537 break;
2538 }
2539 #endif
2540 default:
2541 errno = ESOCKTNOSUPPORT;
2542 return -1;
2543 }
2544
2545 if (autobind_start > 60000) {
2546 autobind_start = 10000;
2547 }
2548
2549 for (i = 0; i < SOCKET_MAX_SOCKETS; i++) {
2550 port = autobind_start + i;
2551 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path),
2552 "%s/"SOCKET_FORMAT, socket_wrapper_dir(),
2553 type, socket_wrapper_default_iface(), port);
2554 if (stat(un_addr.sun_path, &st) == 0) continue;
2555
2556 ret = libc_bind(fd, (struct sockaddr *)(void *)&un_addr,
2557 sizeof(un_addr));
2558 if (ret == -1) return ret;
2559
2560 si->tmp_path = strdup(un_addr.sun_path);
2561 si->bound = 1;
2562 autobind_start = port + 1;
2563 break;
2564 }
2565 if (i == SOCKET_MAX_SOCKETS) {
2566 SWRAP_LOG(SWRAP_LOG_ERROR, "Too many open unix sockets (%u) for "
2567 "interface "SOCKET_FORMAT,
2568 SOCKET_MAX_SOCKETS,
2569 type,
2570 socket_wrapper_default_iface(),
2571 0);
2572 errno = ENFILE;
2573 return -1;
2574 }
2575
2576 si->family = family;
2577 set_port(si->family, port, si->myname);
2578
2579 return 0;
2580 }
2581
2582 /****************************************************************************
2583 * CONNECT
2584 ***************************************************************************/
2585
2586 static int swrap_connect(int s, const struct sockaddr *serv_addr,
2587 socklen_t addrlen)
2588 {
2589 int ret;
2590 struct sockaddr_un un_addr;
2591 struct socket_info *si = find_socket_info(s);
2592 int bcast = 0;
2593
2594 if (!si) {
2595 return libc_connect(s, serv_addr, addrlen);
2596 }
2597
2598 if (si->bound == 0) {
2599 ret = swrap_auto_bind(s, si, serv_addr->sa_family);
2600 if (ret == -1) return -1;
2601 }
2602
2603 if (si->family != serv_addr->sa_family) {
2604 errno = EINVAL;
2605 return -1;
2606 }
2607
2608 ret = sockaddr_convert_to_un(si, serv_addr,
2609 addrlen, &un_addr, 0, &bcast);
2610 if (ret == -1) return -1;
2611
2612 if (bcast) {
2613 errno = ENETUNREACH;
2614 return -1;
2615 }
2616
2617 if (si->type == SOCK_DGRAM) {
2618 si->defer_connect = 1;
2619 ret = 0;
2620 } else {
2621 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_SEND, NULL, 0);
2622
2623 ret = libc_connect(s,
2624 (struct sockaddr *)(void *)&un_addr,
2625 sizeof(struct sockaddr_un));
2626 }
2627
2628 SWRAP_LOG(SWRAP_LOG_TRACE,
2629 "connect() path=%s, fd=%d",
2630 un_addr.sun_path, s);
2631
2632
2633 /* to give better errors */
2634 if (ret == -1 && errno == ENOENT) {
2635 errno = EHOSTUNREACH;
2636 }
2637
2638 if (ret == 0) {
2639 si->peername_len = addrlen;
2640 si->peername = sockaddr_dup(serv_addr, addrlen);
2641 si->connected = 1;
2642
2643 /*
2644 * When we connect() on a socket than we have to bind the
2645 * outgoing connection on the interface we use for the
2646 * transport. We already bound it on the right interface
2647 * but here we have to update the name so getsockname()
2648 * returns correct information.
2649 */
2650 if (si->bindname != NULL) {
2651 free(si->myname);
2652
2653 si->myname = si->bindname;
2654 si->myname_len = si->bindname_len;
2655
2656 si->bindname = NULL;
2657 si->bindname_len = 0;
2658 }
2659
2660 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_RECV, NULL, 0);
2661 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_ACK, NULL, 0);
2662 } else {
2663 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_UNREACH, NULL, 0);
2664 }
2665
2666 return ret;
2667 }
2668
2669 int connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
2670 {
2671 return swrap_connect(s, serv_addr, addrlen);
2672 }
2673
2674 /****************************************************************************
2675 * BIND
2676 ***************************************************************************/
2677
2678 static int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
2679 {
2680 int ret;
2681 struct sockaddr_un un_addr;
2682 struct socket_info *si = find_socket_info(s);
2683
2684 if (!si) {
2685 return libc_bind(s, myaddr, addrlen);
2686 }
2687
2688 si->myname_len = addrlen;
2689 si->myname = sockaddr_dup(myaddr, addrlen);
2690
2691 ret = sockaddr_convert_to_un(si, myaddr, addrlen, &un_addr, 1, &si->bcast);
2692 if (ret == -1) return -1;
2693
2694 unlink(un_addr.sun_path);
2695
2696 ret = libc_bind(s, (struct sockaddr *)(void *)&un_addr,
2697 sizeof(struct sockaddr_un));
2698
2699 SWRAP_LOG(SWRAP_LOG_TRACE,
2700 "bind() path=%s, fd=%d",
2701 un_addr.sun_path, s);
2702
2703 if (ret == 0) {
2704 si->bound = 1;
2705 }
2706
2707 return ret;
2708 }
2709
2710 int bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
2711 {
2712 return swrap_bind(s, myaddr, addrlen);
2713 }
2714
2715 /****************************************************************************
2716 * LISTEN
2717 ***************************************************************************/
2718
2719 static int swrap_listen(int s, int backlog)
2720 {
2721 int ret;
2722 struct socket_info *si = find_socket_info(s);
2723
2724 if (!si) {
2725 return libc_listen(s, backlog);
2726 }
2727
2728 ret = libc_listen(s, backlog);
2729
2730 return ret;
2731 }
2732
2733 int listen(int s, int backlog)
2734 {
2735 return swrap_listen(s, backlog);
2736 }
2737
2738 /****************************************************************************
2739 * OPEN
2740 ***************************************************************************/
2741
2742 static int swrap_vopen(const char *pathname, int flags, va_list ap)
2743 {
2744 int ret;
2745
2746 ret = libc_vopen(pathname, flags, ap);
2747 if (ret != -1) {
2748 /*
2749 * There are methods for closing descriptors (libc-internal code
2750 * paths, direct syscalls) which close descriptors in ways that
2751 * we can't intercept, so try to recover when we notice that
2752 * that's happened
2753 */
2754 swrap_remove_stale(ret);
2755 }
2756 return ret;
2757 }
2758
2759 int open(const char *pathname, int flags, ...)
2760 {
2761 va_list ap;
2762 int fd;
2763
2764 va_start(ap, flags);
2765 fd = swrap_vopen(pathname, flags, ap);
2766 va_end(ap);
2767
2768 return fd;
2769 }
2770
2771 /****************************************************************************
2772 * GETPEERNAME
2773 ***************************************************************************/
2774
2775 static int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
2776 {
2777 struct socket_info *si = find_socket_info(s);
2778 socklen_t len;
2779
2780 if (!si) {
2781 return libc_getpeername(s, name, addrlen);
2782 }
2783
2784 if (!si->peername)
2785 {
2786 errno = ENOTCONN;
2787 return -1;
2788 }
2789
2790 len = MIN(*addrlen, si->peername_len);
2791 if (len == 0) {
2792 return 0;
2793 }
2794
2795 memcpy(name, si->peername, len);
2796 *addrlen = si->peername_len;
2797
2798 return 0;
2799 }
2800
2801 #ifdef HAVE_ACCEPT_PSOCKLEN_T
2802 int getpeername(int s, struct sockaddr *name, Psocklen_t addrlen)
2803 #else
2804 int getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
2805 #endif
2806 {
2807 return swrap_getpeername(s, name, (socklen_t *)addrlen);
2808 }
2809
2810 /****************************************************************************
2811 * GETSOCKNAME
2812 ***************************************************************************/
2813
2814 static int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
2815 {
2816 struct socket_info *si = find_socket_info(s);
2817 socklen_t len;
2818
2819 if (!si) {
2820 return libc_getsockname(s, name, addrlen);
2821 }
2822
2823 len = MIN(*addrlen, si->myname_len);
2824 if (len == 0) {
2825 return 0;
2826 }
2827
2828 memcpy(name, si->myname, len);
2829 *addrlen = si->myname_len;
2830
2831 return 0;
2832 }
2833
2834 #ifdef HAVE_ACCEPT_PSOCKLEN_T
2835 int getsockname(int s, struct sockaddr *name, Psocklen_t addrlen)
2836 #else
2837 int getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
2838 #endif
2839 {
2840 return swrap_getsockname(s, name, (socklen_t *)addrlen);
2841 }
2842
2843 /****************************************************************************
2844 * GETSOCKOPT
2845 ***************************************************************************/
2846
2847 static int swrap_getsockopt(int s, int level, int optname,
2848 void *optval, socklen_t *optlen)
2849 {
2850 struct socket_info *si = find_socket_info(s);
2851
2852 if (!si) {
2853 return libc_getsockopt(s,
2854 level,
2855 optname,
2856 optval,
2857 optlen);
2858 }
2859
2860 if (level == SOL_SOCKET) {
2861 return libc_getsockopt(s,
2862 level,
2863 optname,
2864 optval,
2865 optlen);
2866 }
2867
2868 errno = ENOPROTOOPT;
2869 return -1;
2870 }
2871
2872 #ifdef HAVE_ACCEPT_PSOCKLEN_T
2873 int getsockopt(int s, int level, int optname, void *optval, Psocklen_t optlen)
2874 #else
2875 int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
2876 #endif
2877 {
2878 return swrap_getsockopt(s, level, optname, optval, (socklen_t *)optlen);
2879 }
2880
2881 /****************************************************************************
2882 * SETSOCKOPT
2883 ***************************************************************************/
2884
2885 static int swrap_setsockopt(int s, int level, int optname,
2886 const void *optval, socklen_t optlen)
2887 {
2888 struct socket_info *si = find_socket_info(s);
2889
2890 if (!si) {
2891 return libc_setsockopt(s,
2892 level,
2893 optname,
2894 optval,
2895 optlen);
2896 }
2897
2898 if (level == SOL_SOCKET) {
2899 return libc_setsockopt(s,
2900 level,
2901 optname,
2902 optval,
2903 optlen);
2904 }
2905
2906 switch (si->family) {
2907 case AF_INET:
2908 if (level == IPPROTO_IP) {
2909 #ifdef IP_PKTINFO
2910 if (optname == IP_PKTINFO) {
2911 si->pktinfo = AF_INET;
2912 }
2913 #endif /* IP_PKTINFO */
2914 }
2915 return 0;
2916 #ifdef HAVE_IPV6
2917 case AF_INET6:
2918 if (level == IPPROTO_IPV6) {
2919 #ifdef IPV6_RECVPKTINFO
2920 if (optname == IPV6_RECVPKTINFO) {
2921 si->pktinfo = AF_INET6;
2922 }
2923 #endif /* IPV6_PKTINFO */
2924 }
2925 return 0;
2926 #endif
2927 default:
2928 errno = ENOPROTOOPT;
2929 return -1;
2930 }
2931 }
2932
2933 int setsockopt(int s, int level, int optname,
2934 const void *optval, socklen_t optlen)
2935 {
2936 return swrap_setsockopt(s, level, optname, optval, optlen);
2937 }
2938
2939 /****************************************************************************
2940 * IOCTL
2941 ***************************************************************************/
2942
2943 static int swrap_vioctl(int s, unsigned long int r, va_list va)
2944 {
2945 struct socket_info *si = find_socket_info(s);
2946 va_list ap;
2947 int value;
2948 int rc;
2949
2950 if (!si) {
2951 return libc_vioctl(s, r, va);
2952 }
2953
2954 va_copy(ap, va);
2955
2956 rc = libc_vioctl(s, r, va);
2957
2958 switch (r) {
2959 case FIONREAD:
2960 value = *((int *)va_arg(ap, int *));
2961
2962 if (rc == -1 && errno != EAGAIN && errno != ENOBUFS) {
2963 swrap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
2964 } else if (value == 0) { /* END OF FILE */
2965 swrap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
2966 }
2967 break;
2968 }
2969
2970 va_end(ap);
2971
2972 return rc;
2973 }
2974
2975 #ifdef HAVE_IOCTL_INT
2976 int ioctl(int s, int r, ...)
2977 #else
2978 int ioctl(int s, unsigned long int r, ...)
2979 #endif
2980 {
2981 va_list va;
2982 int rc;
2983
2984 va_start(va, r);
2985
2986 rc = swrap_vioctl(s, (unsigned long int) r, va);
2987
2988 va_end(va);
2989
2990 return rc;
2991 }
2992
2993 /*****************
2994 * CMSG
2995 *****************/
2996
2997 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
2998
2999 #ifndef CMSG_ALIGN
3000 # ifdef _ALIGN /* BSD */
3001 #define CMSG_ALIGN _ALIGN
3002 # else
3003 #error NO_CMSG_ALIGN
3004 # endif /* _ALIGN */
3005 #endif /* CMSG_ALIGN */
3006
3007 /**
3008 * @brief Add a cmsghdr to a msghdr.
3009 *
3010 * This is an function to add any type of cmsghdr. It will operate on the
3011 * msg->msg_control and msg->msg_controllen you pass in by adapting them to
3012 * the buffer position after the added cmsg element. Hence, this function is
3013 * intended to be used with an intermediate msghdr and not on the original
3014 * one handed in by the client.
3015 *
3016 * @param[in] msg The msghdr to which to add the cmsg.
3017 *
3018 * @param[in] level The cmsg level to set.
3019 *
3020 * @param[in] type The cmsg type to set.
3021 *
3022 * @param[in] data The cmsg data to set.
3023 *
3024 * @param[in] len the length of the data to set.
3025 */
3026 static void swrap_msghdr_add_cmsghdr(struct msghdr *msg,
3027 int level,
3028 int type,
3029 const void *data,
3030 size_t len)
3031 {
3032 size_t cmlen = CMSG_LEN(len);
3033 size_t cmspace = CMSG_SPACE(len);
3034 uint8_t cmbuf[cmspace];
3035 struct cmsghdr *cm = (struct cmsghdr *)cmbuf;
3036 uint8_t *p;
3037
3038 memset(cmbuf, 0, cmspace);
3039
3040 if (msg->msg_controllen < cmlen) {
3041 cmlen = msg->msg_controllen;
3042 msg->msg_flags |= MSG_CTRUNC;
3043 }
3044
3045 if (msg->msg_controllen < cmspace) {
3046 cmspace = msg->msg_controllen;
3047 }
3048
3049 /*
3050 * We copy the full input data into an intermediate cmsghdr first
3051 * in order to more easily cope with truncation.
3052 */
3053 cm->cmsg_len = cmlen;
3054 cm->cmsg_level = level;
3055 cm->cmsg_type = type;
3056 memcpy(CMSG_DATA(cm), data, len);
3057
3058 /*
3059 * We now copy the possibly truncated buffer.
3060 * We copy cmlen bytes, but consume cmspace bytes,
3061 * leaving the possible padding uninitialiazed.
3062 */
3063 p = (uint8_t *)msg->msg_control;
3064 memcpy(p, cm, cmlen);
3065 p += cmspace;
3066 msg->msg_control = p;
3067 msg->msg_controllen -= cmspace;
3068
3069 return;
3070 }
3071
3072 static int swrap_msghdr_add_pktinfo(struct socket_info *si,
3073 struct msghdr *msg)
3074 {
3075 /* Add packet info */
3076 switch (si->pktinfo) {
3077 #if defined(IP_PKTINFO)
3078 /* && (defined(HAVE_STRUCT_IN_PKTINFO) || defined(IP_RECVDSTADDR)) */
3079 case AF_INET: {
3080 struct sockaddr_in *sin;
3081 #if defined(HAVE_STRUCT_IN_PKTINFO)
3082 struct in_pktinfo pkt;
3083 #elif defined(IP_RECVDSTADDR)
3084 struct in_addr pkt;
3085 #endif
3086
3087 if (si->bindname_len == sizeof(struct sockaddr_in)) {
3088 sin = (struct sockaddr_in*)si->bindname;
3089 } else {
3090 if (si->myname_len != sizeof(struct sockaddr_in)) {
3091 return 0;
3092 }
3093 sin = (struct sockaddr_in*)si->myname;
3094 }
3095
3096 ZERO_STRUCT(pkt);
3097
3098 #if defined(HAVE_STRUCT_IN_PKTINFO)
3099 pkt.ipi_ifindex = socket_wrapper_default_iface();
3100 pkt.ipi_addr.s_addr = sin->sin_addr.s_addr;
3101 #elif defined(IP_RECVDSTADDR)
3102 pkt = sin->sin_addr;
3103 #endif
3104
3105 swrap_msghdr_add_cmsghdr(msg, IPPROTO_IP, IP_PKTINFO,
3106 &pkt, sizeof(pkt));
3107
3108 break;
3109 }
3110 #endif /* IP_PKTINFO */
3111 #if defined(HAVE_IPV6)
3112 case AF_INET6: {
3113 #if defined(IPV6_PKTINFO) && defined(HAVE_STRUCT_IN6_PKTINFO)
3114 struct sockaddr_in6 *sin6;
3115 struct in6_pktinfo pkt6;
3116
3117 if (si->bindname_len == sizeof(struct sockaddr_in6)) {
3118 sin6 = (struct sockaddr_in6*)si->bindname;
3119 } else {
3120 if (si->myname_len != sizeof(struct sockaddr_in6)) {
3121 return 0;
3122 }
3123 sin6 = (struct sockaddr_in6*)si->myname;
3124 }
3125
3126 ZERO_STRUCT(pkt6);
3127
3128 pkt6.ipi6_ifindex = socket_wrapper_default_iface();
3129 pkt6.ipi6_addr = sin6->sin6_addr;
3130
3131 swrap_msghdr_add_cmsghdr(msg, IPPROTO_IPV6, IPV6_PKTINFO,
3132 &pkt6, sizeof(pkt6));
3133 #endif /* HAVE_STRUCT_IN6_PKTINFO */
3134
3135 break;
3136 }
3137 #endif /* IPV6_PKTINFO */
3138 default:
3139 return -1;
3140 }
3141
3142 return 0;
3143 }
3144
3145 static int swrap_msghdr_add_socket_info(struct socket_info *si,
3146 struct msghdr *omsg)
3147 {
3148 int rc = 0;
3149
3150 if (si->pktinfo > 0) {
3151 rc = swrap_msghdr_add_pktinfo(si, omsg);
3152 }
3153
3154 return rc;
3155 }
3156
3157 static int swrap_sendmsg_copy_cmsg(struct cmsghdr *cmsg,
3158 uint8_t *cm_data,
3159 size_t *cm_data_space);
3160 static int swrap_sendmsg_filter_cmsg_socket(struct cmsghdr *cmsg,
3161 uint8_t *cm_data,
3162 size_t *cm_data_space);
3163
3164 static int swrap_sendmsg_filter_cmsghdr(struct msghdr *msg,
3165 uint8_t *cm_data,
3166 size_t *cm_data_space) {
3167 struct cmsghdr *cmsg;
3168 int rc = -1;
3169
3170 /* Nothing to do */
3171 if (msg->msg_controllen == 0 || msg->msg_control == NULL) {
3172 return 0;
3173 }
3174
3175 for (cmsg = CMSG_FIRSTHDR(msg);
3176 cmsg != NULL;
3177 cmsg = CMSG_NXTHDR(msg, cmsg)) {
3178 switch (cmsg->cmsg_level) {
3179 case IPPROTO_IP:
3180 rc = swrap_sendmsg_filter_cmsg_socket(cmsg,
3181 cm_data,
3182 cm_data_space);
3183 break;
3184 default:
3185 rc = swrap_sendmsg_copy_cmsg(cmsg,
3186 cm_data,
3187 cm_data_space);
3188 break;
3189 }
3190 }
3191
3192 return rc;
3193 }
3194
3195 static int swrap_sendmsg_copy_cmsg(struct cmsghdr *cmsg,
3196 uint8_t *cm_data,
3197 size_t *cm_data_space)
3198 {
3199 size_t cmspace;
3200 uint8_t *p;
3201
3202 cmspace =
3203 (*cm_data_space) +
3204 CMSG_SPACE(cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr)));
3205
3206 p = realloc(cm_data, cmspace);
3207 if (p == NULL) {
3208 return -1;
3209 }
3210 cm_data = p;
3211
3212 p = cm_data + (*cm_data_space);
3213 *cm_data_space = cmspace;
3214
3215 memcpy(p, cmsg, cmsg->cmsg_len);
3216
3217 return 0;
3218 }
3219
3220 static int swrap_sendmsg_filter_cmsg_pktinfo(struct cmsghdr *cmsg,
3221 uint8_t *cm_data,
3222 size_t *cm_data_space);
3223
3224
3225 static int swrap_sendmsg_filter_cmsg_socket(struct cmsghdr *cmsg,
3226 uint8_t *cm_data,
3227 size_t *cm_data_space)
3228 {
3229 int rc = -1;
3230
3231 switch(cmsg->cmsg_type) {
3232 #ifdef IP_PKTINFO
3233 case IP_PKTINFO:
3234 rc = swrap_sendmsg_filter_cmsg_pktinfo(cmsg,
3235 cm_data,
3236 cm_data_space);
3237 break;
3238 #endif
3239 #ifdef IPV6_PKTINFO
3240 case IPV6_PKTINFO:
3241 rc = swrap_sendmsg_filter_cmsg_pktinfo(cmsg,
3242 cm_data,
3243 cm_data_space);
3244 break;
3245 #endif
3246 default:
3247 break;
3248 }
3249
3250 return rc;
3251 }
3252
3253 static int swrap_sendmsg_filter_cmsg_pktinfo(struct cmsghdr *cmsg,
3254 uint8_t *cm_data,
3255 size_t *cm_data_space)
3256 {
3257 (void)cmsg; /* unused */
3258 (void)cm_data; /* unused */
3259 (void)cm_data_space; /* unused */
3260
3261 /*
3262 * Passing a IP pktinfo to a unix socket might be rejected by the
3263 * Kernel, at least on FreeBSD. So skip this cmsg.
3264 */
3265 return 0;
3266 }
3267 #endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL */
3268
3269 static ssize_t swrap_sendmsg_before(int fd,
3270 struct socket_info *si,
3271 struct msghdr *msg,
3272 struct iovec *tmp_iov,
3273 struct sockaddr_un *tmp_un,
3274 const struct sockaddr_un **to_un,
3275 const struct sockaddr **to,
3276 int *bcast)
3277 {
3278 size_t i, len = 0;
3279 ssize_t ret;
3280
3281 if (to_un) {
3282 *to_un = NULL;
3283 }
3284 if (to) {
3285 *to = NULL;
3286 }
3287 if (bcast) {
3288 *bcast = 0;
3289 }
3290
3291 switch (si->type) {
3292 case SOCK_STREAM:
3293 if (!si->connected) {
3294 errno = ENOTCONN;
3295 return -1;
3296 }
3297
3298 if (msg->msg_iovlen == 0) {
3299 break;
3300 }
3301
3302 for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
3303 size_t nlen;
3304 nlen = len + msg->msg_iov[i].iov_len;
3305 if (nlen > SOCKET_MAX_PACKET) {
3306 break;
3307 }
3308 }
3309 msg->msg_iovlen = i;
3310 if (msg->msg_iovlen == 0) {
3311 *tmp_iov = msg->msg_iov[0];
3312 tmp_iov->iov_len = MIN(tmp_iov->iov_len, SOCKET_MAX_PACKET);
3313 msg->msg_iov = tmp_iov;
3314 msg->msg_iovlen = 1;
3315 }
3316 break;
3317
3318 case SOCK_DGRAM:
3319 if (si->connected) {
3320 if (msg->msg_name) {
3321 errno = EISCONN;
3322 return -1;
3323 }
3324 } else {
3325 const struct sockaddr *msg_name;
3326 msg_name = (const struct sockaddr *)msg->msg_name;
3327
3328 if (msg_name == NULL) {
3329 errno = ENOTCONN;
3330 return -1;
3331 }
3332
3333
3334 ret = sockaddr_convert_to_un(si, msg_name, msg->msg_namelen,
3335 tmp_un, 0, bcast);
3336 if (ret == -1) return -1;
3337
3338 if (to_un) {
3339 *to_un = tmp_un;
3340 }
3341 if (to) {
3342 *to = msg_name;
3343 }
3344 msg->msg_name = tmp_un;
3345 msg->msg_namelen = sizeof(*tmp_un);
3346 }
3347
3348 if (si->bound == 0) {
3349 ret = swrap_auto_bind(fd, si, si->family);
3350 if (ret == -1) {
3351 if (errno == ENOTSOCK) {
3352 swrap_remove_stale(fd);
3353 return -ENOTSOCK;
3354 } else {
3355 SWRAP_LOG(SWRAP_LOG_ERROR, "swrap_sendmsg_before failed");
3356 return -1;
3357 }
3358 }
3359 }
3360
3361 if (!si->defer_connect) {
3362 break;
3363 }
3364
3365 ret = sockaddr_convert_to_un(si, si->peername, si->peername_len,
3366 tmp_un, 0, NULL);
3367 if (ret == -1) return -1;
3368
3369 ret = libc_connect(fd,
3370 (struct sockaddr *)(void *)tmp_un,
3371 sizeof(*tmp_un));
3372
3373 /* to give better errors */
3374 if (ret == -1 && errno == ENOENT) {
3375 errno = EHOSTUNREACH;
3376 }
3377
3378 if (ret == -1) {
3379 return ret;
3380 }
3381
3382 si->defer_connect = 0;
3383 break;
3384 default:
3385 errno = EHOSTUNREACH;
3386 return -1;
3387 }
3388
3389 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
3390 if (msg->msg_controllen > 0 && msg->msg_control != NULL) {
3391 uint8_t *cmbuf = NULL;
3392 size_t cmlen = 0;
3393
3394 ret = swrap_sendmsg_filter_cmsghdr(msg, cmbuf, &cmlen);
3395 if (ret < 0) {
3396 free(cmbuf);
3397 return -1;
3398 }
3399
3400 if (cmlen == 0) {
3401 msg->msg_controllen = 0;
3402 msg->msg_control = NULL;
3403 } else if (cmlen < msg->msg_controllen) {
3404 memcpy(msg->msg_control, cmbuf, cmlen);
3405 msg->msg_controllen = cmlen;
3406 }
3407 free(cmbuf);
3408 }
3409 #endif
3410
3411 return 0;
3412 }
3413
3414 static void swrap_sendmsg_after(int fd,
3415 struct socket_info *si,
3416 struct msghdr *msg,
3417 const struct sockaddr *to,
3418 ssize_t ret)
3419 {
3420 int saved_errno = errno;
3421 size_t i, len = 0;
3422 uint8_t *buf;
3423 off_t ofs = 0;
3424 size_t avail = 0;
3425 size_t remain;
3426
3427 /* to give better errors */
3428 if (ret == -1) {
3429 if (saved_errno == ENOENT) {
3430 saved_errno = EHOSTUNREACH;
3431 } else if (saved_errno == ENOTSOCK) {
3432 /* If the fd is not a socket, remove it */
3433 swrap_remove_stale(fd);
3434 }
3435 }
3436
3437 for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
3438 avail += msg->msg_iov[i].iov_len;
3439 }
3440
3441 if (ret == -1) {
3442 remain = MIN(80, avail);
3443 } else {
3444 remain = ret;
3445 }
3446
3447 /* we capture it as one single packet */
3448 buf = (uint8_t *)malloc(remain);
3449 if (!buf) {
3450 /* we just not capture the packet */
3451 errno = saved_errno;
3452 return;
3453 }
3454
3455 for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
3456 size_t this_time = MIN(remain, (size_t)msg->msg_iov[i].iov_len);
3457 memcpy(buf + ofs,
3458 msg->msg_iov[i].iov_base,
3459 this_time);
3460 ofs += this_time;
3461 remain -= this_time;
3462 }
3463 len = ofs;
3464
3465 switch (si->type) {
3466 case SOCK_STREAM:
3467 if (ret == -1) {
3468 swrap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
3469 swrap_dump_packet(si, NULL, SWRAP_SEND_RST, NULL, 0);
3470 } else {
3471 swrap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
3472 }
3473 break;
3474
3475 case SOCK_DGRAM:
3476 if (si->connected) {
3477 to = si->peername;
3478 }
3479 if (ret == -1) {
3480 swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
3481 swrap_dump_packet(si, to, SWRAP_SENDTO_UNREACH, buf, len);
3482 } else {
3483 swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
3484 }
3485 break;
3486 }
3487
3488 free(buf);
3489 errno = saved_errno;
3490 }
3491
3492 static int swrap_recvmsg_before(int fd,
3493 struct socket_info *si,
3494 struct msghdr *msg,
3495 struct iovec *tmp_iov)
3496 {
3497 size_t i, len = 0;
3498 ssize_t ret;
3499
3500 (void)fd; /* unused */
3501
3502 switch (si->type) {
3503 case SOCK_STREAM:
3504 if (!si->connected) {
3505 errno = ENOTCONN;
3506 return -1;
3507 }
3508
3509 if (msg->msg_iovlen == 0) {
3510 break;
3511 }
3512
3513 for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
3514 size_t nlen;
3515 nlen = len + msg->msg_iov[i].iov_len;
3516 if (nlen > SOCKET_MAX_PACKET) {
3517 break;
3518 }
3519 }
3520 msg->msg_iovlen = i;
3521 if (msg->msg_iovlen == 0) {
3522 *tmp_iov = msg->msg_iov[0];
3523 tmp_iov->iov_len = MIN(tmp_iov->iov_len, SOCKET_MAX_PACKET);
3524 msg->msg_iov = tmp_iov;
3525 msg->msg_iovlen = 1;
3526 }
3527 break;
3528
3529 case SOCK_DGRAM:
3530 if (msg->msg_name == NULL) {
3531 errno = EINVAL;
3532 return -1;
3533 }
3534
3535 if (msg->msg_iovlen == 0) {
3536 break;
3537 }
3538
3539 if (si->bound == 0) {
3540 ret = swrap_auto_bind(fd, si, si->family);
3541 if (ret == -1) {
3542 /*
3543 * When attempting to read or write to a
3544 * descriptor, if an underlying autobind fails
3545 * because it's not a socket, stop intercepting
3546 * uses of that descriptor.
3547 */
3548 if (errno == ENOTSOCK) {
3549 swrap_remove_stale(fd);
3550 return -ENOTSOCK;
3551 } else {
3552 SWRAP_LOG(SWRAP_LOG_ERROR,
3553 "swrap_recvmsg_before failed");
3554 return -1;
3555 }
3556 }
3557 }
3558 break;
3559 default:
3560 errno = EHOSTUNREACH;
3561 return -1;
3562 }
3563
3564 return 0;
3565 }
3566
3567 static int swrap_recvmsg_after(int fd,
3568 struct socket_info *si,
3569 struct msghdr *msg,
3570 const struct sockaddr_un *un_addr,
3571 socklen_t un_addrlen,
3572 ssize_t ret)
3573 {
3574 int saved_errno = errno;
3575 size_t i;
3576 uint8_t *buf = NULL;
3577 off_t ofs = 0;
3578 size_t avail = 0;
3579 size_t remain;
3580 int rc;
3581
3582 /* to give better errors */
3583 if (ret == -1) {
3584 if (saved_errno == ENOENT) {
3585 saved_errno = EHOSTUNREACH;
3586 } else if (saved_errno == ENOTSOCK) {
3587 /* If the fd is not a socket, remove it */
3588 swrap_remove_stale(fd);
3589 }
3590 }
3591
3592 for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
3593 avail += msg->msg_iov[i].iov_len;
3594 }
3595
3596 if (avail == 0) {
3597 rc = 0;
3598 goto done;
3599 }
3600
3601 if (ret == -1) {
3602 remain = MIN(80, avail);
3603 } else {
3604 remain = ret;
3605 }
3606
3607 /* we capture it as one single packet */
3608 buf = (uint8_t *)malloc(remain);
3609 if (buf == NULL) {
3610 /* we just not capture the packet */
3611 errno = saved_errno;
3612 return -1;
3613 }
3614
3615 for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
3616 size_t this_time = MIN(remain, (size_t)msg->msg_iov[i].iov_len);
3617 memcpy(buf + ofs,
3618 msg->msg_iov[i].iov_base,
3619 this_time);
3620 ofs += this_time;
3621 remain -= this_time;
3622 }
3623
3624 switch (si->type) {
3625 case SOCK_STREAM:
3626 if (ret == -1 && saved_errno != EAGAIN && saved_errno != ENOBUFS) {
3627 swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
3628 } else if (ret == 0) { /* END OF FILE */
3629 swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
3630 } else if (ret > 0) {
3631 swrap_dump_packet(si, NULL, SWRAP_RECV, buf, ret);
3632 }
3633 break;
3634
3635 case SOCK_DGRAM:
3636 if (ret == -1) {
3637 break;
3638 }
3639
3640 if (un_addr != NULL) {
3641 rc = sockaddr_convert_from_un(si,
3642 un_addr,
3643 un_addrlen,
3644 si->family,
3645 msg->msg_name,
3646 &msg->msg_namelen);
3647 if (rc == -1) {
3648 goto done;
3649 }
3650
3651 swrap_dump_packet(si,
3652 msg->msg_name,
3653 SWRAP_RECVFROM,
3654 buf,
3655 ret);
3656 } else {
3657 swrap_dump_packet(si,
3658 msg->msg_name,
3659 SWRAP_RECV,
3660 buf,
3661 ret);
3662 }
3663
3664 break;
3665 }
3666
3667 rc = 0;
3668 done:
3669 free(buf);
3670 errno = saved_errno;
3671
3672 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
3673 if (rc == 0 &&
3674 msg->msg_controllen > 0 &&
3675 msg->msg_control != NULL) {
3676 rc = swrap_msghdr_add_socket_info(si, msg);
3677 if (rc < 0) {
3678 return -1;
3679 }
3680 }
3681 #endif
3682
3683 return rc;
3684 }
3685
3686 /****************************************************************************
3687 * RECVFROM
3688 ***************************************************************************/
3689
3690 static ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags,
3691 struct sockaddr *from, socklen_t *fromlen)
3692 {
3693 struct sockaddr_un from_addr;
3694 socklen_t from_addrlen = sizeof(from_addr);
3695 ssize_t ret;
3696 struct socket_info *si = find_socket_info(s);
3697 struct sockaddr_storage ss;
3698 socklen_t ss_len = sizeof(ss);
3699 struct msghdr msg;
3700 struct iovec tmp;
3701 int tret;
3702
3703 if (!si) {
3704 return libc_recvfrom(s,
3705 buf,
3706 len,
3707 flags,
3708 from,
3709 fromlen);
3710 }
3711
3712 tmp.iov_base = buf;
3713 tmp.iov_len = len;
3714
3715 ZERO_STRUCT(msg);
3716 if (from != NULL && fromlen != NULL) {
3717 msg.msg_name = from; /* optional address */
3718 msg.msg_namelen = *fromlen; /* size of address */
3719 } else {
3720 msg.msg_name = (struct sockaddr *)(void *)&ss; /* optional address */
3721 msg.msg_namelen = ss_len; /* size of address */
3722 }
3723 msg.msg_iov = &tmp; /* scatter/gather array */
3724 msg.msg_iovlen = 1; /* # elements in msg_iov */
3725 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
3726 msg.msg_control = NULL; /* ancillary data, see below */
3727 msg.msg_controllen = 0; /* ancillary data buffer len */
3728 msg.msg_flags = 0; /* flags on received message */
3729 #endif
3730
3731 tret = swrap_recvmsg_before(s, si, &msg, &tmp);
3732 if (tret < 0) {
3733 return -1;
3734 }
3735
3736 buf = msg.msg_iov[0].iov_base;
3737 len = msg.msg_iov[0].iov_len;
3738
3739 /* irix 6.4 forgets to null terminate the sun_path string :-( */
3740 memset(&from_addr, 0, sizeof(from_addr));
3741 ret = libc_recvfrom(s,
3742 buf,
3743 len,
3744 flags,
3745 (struct sockaddr *)(void *)&from_addr,
3746 &from_addrlen);
3747 if (ret == -1) {
3748 return ret;
3749 }
3750
3751 tret = swrap_recvmsg_after(s,
3752 si,
3753 &msg,
3754 &from_addr,
3755 from_addrlen,
3756 ret);
3757 if (tret != 0) {
3758 return tret;
3759 }
3760
3761 if (from != NULL && fromlen != NULL) {
3762 *fromlen = msg.msg_namelen;
3763 }
3764
3765 return ret;
3766 }
3767
3768 #ifdef HAVE_ACCEPT_PSOCKLEN_T
3769 ssize_t recvfrom(int s, void *buf, size_t len, int flags,
3770 struct sockaddr *from, Psocklen_t fromlen)
3771 #else
3772 ssize_t recvfrom(int s, void *buf, size_t len, int flags,
3773 struct sockaddr *from, socklen_t *fromlen)
3774 #endif
3775 {
3776 return swrap_recvfrom(s, buf, len, flags, from, (socklen_t *)fromlen);
3777 }
3778
3779 /****************************************************************************
3780 * SENDTO
3781 ***************************************************************************/
3782
3783 static ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags,
3784 const struct sockaddr *to, socklen_t tolen)
3785 {
3786 struct msghdr msg;
3787 struct iovec tmp;
3788 struct sockaddr_un un_addr;
3789 const struct sockaddr_un *to_un = NULL;
3790 ssize_t ret;
3791 int rc;
3792 struct socket_info *si = find_socket_info(s);
3793 int bcast = 0;
3794
3795 if (!si) {
3796 return libc_sendto(s, buf, len, flags, to, tolen);
3797 }
3798
3799 tmp.iov_base = discard_const_p(char, buf);
3800 tmp.iov_len = len;
3801
3802 ZERO_STRUCT(msg);
3803 msg.msg_name = discard_const_p(struct sockaddr, to); /* optional address */
3804 msg.msg_namelen = tolen; /* size of address */
3805 msg.msg_iov = &tmp; /* scatter/gather array */
3806 msg.msg_iovlen = 1; /* # elements in msg_iov */
3807 #if HAVE_STRUCT_MSGHDR_MSG_CONTROL
3808 msg.msg_control = NULL; /* ancillary data, see below */
3809 msg.msg_controllen = 0; /* ancillary data buffer len */
3810 msg.msg_flags = 0; /* flags on received message */
3811 #endif
3812
3813 rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, &to_un, &to, &bcast);
3814 if (rc < 0) {
3815 return -1;
3816 }
3817
3818 buf = msg.msg_iov[0].iov_base;
3819 len = msg.msg_iov[0].iov_len;
3820
3821 if (bcast) {
3822 struct stat st;
3823 unsigned int iface;
3824 unsigned int prt = ntohs(((const struct sockaddr_in *)to)->sin_port);
3825 char type;
3826
3827 type = SOCKET_TYPE_CHAR_UDP;
3828
3829 for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
3830 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/"SOCKET_FORMAT,
3831 socket_wrapper_dir(), type, iface, prt);
3832 if (stat(un_addr.sun_path, &st) != 0) continue;
3833
3834 /* ignore the any errors in broadcast sends */
3835 libc_sendto(s,
3836 buf,
3837 len,
3838 flags,
3839 (struct sockaddr *)(void *)&un_addr,
3840 sizeof(un_addr));
3841 }
3842
3843 swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
3844
3845 return len;
3846 }
3847
3848 ret = libc_sendto(s,
3849 buf,
3850 len,
3851 flags,
3852 (struct sockaddr *)msg.msg_name,
3853 msg.msg_namelen);
3854
3855 swrap_sendmsg_after(s, si, &msg, to, ret);
3856
3857 return ret;
3858 }
3859
3860 ssize_t sendto(int s, const void *buf, size_t len, int flags,
3861 const struct sockaddr *to, socklen_t tolen)
3862 {
3863 return swrap_sendto(s, buf, len, flags, to, tolen);
3864 }
3865
3866 /****************************************************************************
3867 * READV
3868 ***************************************************************************/
3869
3870 static ssize_t swrap_recv(int s, void *buf, size_t len, int flags)
3871 {
3872 struct socket_info *si;
3873 struct msghdr msg;
3874 struct sockaddr_storage ss;
3875 socklen_t ss_len = sizeof(ss);
3876 struct iovec tmp;
3877 ssize_t ret;
3878 int tret;
3879
3880 si = find_socket_info(s);
3881 if (si == NULL) {
3882 return libc_recv(s, buf, len, flags);
3883 }
3884
3885 tmp.iov_base = buf;
3886 tmp.iov_len = len;
3887
3888 ZERO_STRUCT(msg);
3889 msg.msg_name = (struct sockaddr *)(void *)&ss; /* optional address */
3890 msg.msg_namelen = ss_len; /* size of address */
3891 msg.msg_iov = &tmp; /* scatter/gather array */
3892 msg.msg_iovlen = 1; /* # elements in msg_iov */
3893 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
3894 msg.msg_control = NULL; /* ancillary data, see below */
3895 msg.msg_controllen = 0; /* ancillary data buffer len */
3896 msg.msg_flags = 0; /* flags on received message */
3897 #endif
3898
3899 tret = swrap_recvmsg_before(s, si, &msg, &tmp);
3900 if (tret < 0) {
3901 return -1;
3902 }
3903
3904 buf = msg.msg_iov[0].iov_base;
3905 len = msg.msg_iov[0].iov_len;
3906
3907 ret = libc_recv(s, buf, len, flags);
3908
3909 tret = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret);
3910 if (tret != 0) {
3911 return tret;
3912 }
3913
3914 return ret;
3915 }
3916
3917 ssize_t recv(int s, void *buf, size_t len, int flags)
3918 {
3919 return swrap_recv(s, buf, len, flags);
3920 }
3921
3922 /****************************************************************************
3923 * READ
3924 ***************************************************************************/
3925
3926 static ssize_t swrap_read(int s, void *buf, size_t len)
3927 {
3928 struct socket_info *si;
3929 struct msghdr msg;
3930 struct iovec tmp;
3931 struct sockaddr_storage ss;
3932 socklen_t ss_len = sizeof(ss);
3933 ssize_t ret;
3934 int tret;
3935
3936 si = find_socket_info(s);
3937 if (si == NULL) {
3938 return libc_read(s, buf, len);
3939 }
3940
3941 tmp.iov_base = buf;
3942 tmp.iov_len = len;
3943
3944 ZERO_STRUCT(msg);
3945 msg.msg_name = (struct sockaddr *)(void *)&ss; /* optional address */
3946 msg.msg_namelen = ss_len; /* size of address */
3947 msg.msg_iov = &tmp; /* scatter/gather array */
3948 msg.msg_iovlen = 1; /* # elements in msg_iov */
3949 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
3950 msg.msg_control = NULL; /* ancillary data, see below */
3951 msg.msg_controllen = 0; /* ancillary data buffer len */
3952 msg.msg_flags = 0; /* flags on received message */
3953 #endif
3954
3955 tret = swrap_recvmsg_before(s, si, &msg, &tmp);
3956 if (tret < 0) {
3957 if (tret == -ENOTSOCK) {
3958 return libc_read(s, buf, len);
3959 }
3960 return -1;
3961 }
3962
3963 buf = msg.msg_iov[0].iov_base;
3964 len = msg.msg_iov[0].iov_len;
3965
3966 ret = libc_read(s, buf, len);
3967
3968 tret = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret);
3969 if (tret != 0) {
3970 return tret;
3971 }
3972
3973 return ret;
3974 }
3975
3976 ssize_t read(int s, void *buf, size_t len)
3977 {
3978 return swrap_read(s, buf, len);
3979 }
3980
3981 /****************************************************************************
3982 * SEND
3983 ***************************************************************************/
3984
3985 static ssize_t swrap_send(int s, const void *buf, size_t len, int flags)
3986 {
3987 struct msghdr msg;
3988 struct iovec tmp;
3989 struct sockaddr_un un_addr;
3990 ssize_t ret;
3991 int rc;
3992 struct socket_info *si = find_socket_info(s);
3993
3994 if (!si) {
3995 return libc_send(s, buf, len, flags);
3996 }
3997
3998 tmp.iov_base = discard_const_p(char, buf);
3999 tmp.iov_len = len;
4000
4001 ZERO_STRUCT(msg);
4002 msg.msg_name = NULL; /* optional address */
4003 msg.msg_namelen = 0; /* size of address */
4004 msg.msg_iov = &tmp; /* scatter/gather array */
4005 msg.msg_iovlen = 1; /* # elements in msg_iov */
4006 #if HAVE_STRUCT_MSGHDR_MSG_CONTROL
4007 msg.msg_control = NULL; /* ancillary data, see below */
4008 msg.msg_controllen = 0; /* ancillary data buffer len */
4009 msg.msg_flags = 0; /* flags on received message */
4010 #endif
4011
4012 rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
4013 if (rc < 0) {
4014 return -1;
4015 }
4016
4017 buf = msg.msg_iov[0].iov_base;
4018 len = msg.msg_iov[0].iov_len;
4019
4020 ret = libc_send(s, buf, len, flags);
4021
4022 swrap_sendmsg_after(s, si, &msg, NULL, ret);
4023
4024 return ret;
4025 }
4026
4027 ssize_t send(int s, const void *buf, size_t len, int flags)
4028 {
4029 return swrap_send(s, buf, len, flags);
4030 }
4031
4032 /****************************************************************************
4033 * RECVMSG
4034 ***************************************************************************/
4035
4036 static ssize_t swrap_recvmsg(int s, struct msghdr *omsg, int flags)
4037 {
4038 struct sockaddr_un from_addr;
4039 socklen_t from_addrlen = sizeof(from_addr);
4040 struct socket_info *si;
4041 struct msghdr msg;
4042 struct iovec tmp;
4043 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
4044 size_t msg_ctrllen_filled;
4045 size_t msg_ctrllen_left;
4046 #endif
4047
4048 ssize_t ret;
4049 int rc;
4050
4051 si = find_socket_info(s);
4052 if (si == NULL) {
4053 return libc_recvmsg(s, omsg, flags);
4054 }
4055
4056 tmp.iov_base = NULL;
4057 tmp.iov_len = 0;
4058
4059 ZERO_STRUCT(msg);
4060 msg.msg_name = (struct sockaddr *)&from_addr; /* optional address */
4061 msg.msg_namelen = from_addrlen; /* size of address */
4062 msg.msg_iov = omsg->msg_iov; /* scatter/gather array */
4063 msg.msg_iovlen = omsg->msg_iovlen; /* # elements in msg_iov */
4064 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
4065 msg_ctrllen_filled = 0;
4066 msg_ctrllen_left = omsg->msg_controllen;
4067
4068 msg.msg_control = omsg->msg_control; /* ancillary data, see below */
4069 msg.msg_controllen = omsg->msg_controllen; /* ancillary data buffer len */
4070 msg.msg_flags = omsg->msg_flags; /* flags on received message */
4071 #endif
4072
4073 rc = swrap_recvmsg_before(s, si, &msg, &tmp);
4074 if (rc < 0) {
4075 return -1;
4076 }
4077
4078 ret = libc_recvmsg(s, &msg, flags);
4079
4080 msg.msg_name = omsg->msg_name;
4081 msg.msg_namelen = omsg->msg_namelen;
4082
4083 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
4084 msg_ctrllen_filled += msg.msg_controllen;
4085 msg_ctrllen_left -= msg.msg_controllen;
4086
4087 if (omsg->msg_control != NULL) {
4088 uint8_t *p;
4089
4090 p = omsg->msg_control;
4091 p += msg_ctrllen_filled;
4092
4093 msg.msg_control = p;
4094 msg.msg_controllen = msg_ctrllen_left;
4095 } else {
4096 msg.msg_control = NULL;
4097 msg.msg_controllen = 0;
4098 }
4099 #endif
4100
4101 rc = swrap_recvmsg_after(s, si, &msg, &from_addr, from_addrlen, ret);
4102 if (rc != 0) {
4103 return rc;
4104 }
4105
4106 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
4107 if (omsg->msg_control != NULL) {
4108 /* msg.msg_controllen = space left */
4109 msg_ctrllen_left = msg.msg_controllen;
4110 msg_ctrllen_filled = omsg->msg_controllen - msg_ctrllen_left;
4111 }
4112
4113 /* Update the original message length */
4114 omsg->msg_controllen = msg_ctrllen_filled;
4115 omsg->msg_flags = msg.msg_flags;
4116 #endif
4117 omsg->msg_iovlen = msg.msg_iovlen;
4118
4119 return ret;
4120 }
4121
4122 ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)
4123 {
4124 return swrap_recvmsg(sockfd, msg, flags);
4125 }
4126
4127 /****************************************************************************
4128 * SENDMSG
4129 ***************************************************************************/
4130
4131 static ssize_t swrap_sendmsg(int s, const struct msghdr *omsg, int flags)
4132 {
4133 struct msghdr msg;
4134 struct iovec tmp;
4135 struct sockaddr_un un_addr;
4136 const struct sockaddr_un *to_un = NULL;
4137 const struct sockaddr *to = NULL;
4138 ssize_t ret;
4139 int rc;
4140 struct socket_info *si = find_socket_info(s);
4141 int bcast = 0;
4142
4143 if (!si) {
4144 return libc_sendmsg(s, omsg, flags);
4145 }
4146
4147 ZERO_STRUCT(un_addr);
4148
4149 tmp.iov_base = NULL;
4150 tmp.iov_len = 0;
4151
4152 ZERO_STRUCT(msg);
4153 msg.msg_name = omsg->msg_name; /* optional address */
4154 msg.msg_namelen = omsg->msg_namelen; /* size of address */
4155 msg.msg_iov = omsg->msg_iov; /* scatter/gather array */
4156 msg.msg_iovlen = omsg->msg_iovlen; /* # elements in msg_iov */
4157 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
4158 if (msg.msg_controllen > 0 && msg.msg_control != NULL) {
4159 /* omsg is a const so use a local buffer for modifications */
4160 uint8_t cmbuf[omsg->msg_controllen];
4161
4162 memcpy(cmbuf, omsg->msg_control, omsg->msg_controllen);
4163
4164 msg.msg_control = cmbuf; /* ancillary data, see below */
4165 msg.msg_controllen = omsg->msg_controllen; /* ancillary data buffer len */
4166 }
4167 msg.msg_flags = omsg->msg_flags; /* flags on received message */
4168 #endif
4169
4170 rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, &to_un, &to, &bcast);
4171 if (rc < 0) {
4172 return -1;
4173 }
4174
4175 if (bcast) {
4176 struct stat st;
4177 unsigned int iface;
4178 unsigned int prt = ntohs(((const struct sockaddr_in *)to)->sin_port);
4179 char type;
4180 size_t i, len = 0;
4181 uint8_t *buf;
4182 off_t ofs = 0;
4183 size_t avail = 0;
4184 size_t remain;
4185
4186 for (i = 0; i < (size_t)msg.msg_iovlen; i++) {
4187 avail += msg.msg_iov[i].iov_len;
4188 }
4189
4190 len = avail;
4191 remain = avail;
4192
4193 /* we capture it as one single packet */
4194 buf = (uint8_t *)malloc(remain);
4195 if (!buf) {
4196 return -1;
4197 }
4198
4199 for (i = 0; i < (size_t)msg.msg_iovlen; i++) {
4200 size_t this_time = MIN(remain, (size_t)msg.msg_iov[i].iov_len);
4201 memcpy(buf + ofs,
4202 msg.msg_iov[i].iov_base,
4203 this_time);
4204 ofs += this_time;
4205 remain -= this_time;
4206 }
4207
4208 type = SOCKET_TYPE_CHAR_UDP;
4209
4210 for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
4211 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/"SOCKET_FORMAT,
4212 socket_wrapper_dir(), type, iface, prt);
4213 if (stat(un_addr.sun_path, &st) != 0) continue;
4214
4215 msg.msg_name = &un_addr; /* optional address */
4216 msg.msg_namelen = sizeof(un_addr); /* size of address */
4217
4218 /* ignore the any errors in broadcast sends */
4219 libc_sendmsg(s, &msg, flags);
4220 }
4221
4222 swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
4223 free(buf);
4224
4225 return len;
4226 }
4227
4228 ret = libc_sendmsg(s, &msg, flags);
4229
4230 swrap_sendmsg_after(s, si, &msg, to, ret);
4231
4232 return ret;
4233 }
4234
4235 ssize_t sendmsg(int s, const struct msghdr *omsg, int flags)
4236 {
4237 return swrap_sendmsg(s, omsg, flags);
4238 }
4239
4240 /****************************************************************************
4241 * READV
4242 ***************************************************************************/
4243
4244 static ssize_t swrap_readv(int s, const struct iovec *vector, int count)
4245 {
4246 struct socket_info *si;
4247 struct msghdr msg;
4248 struct iovec tmp;
4249 struct sockaddr_storage ss;
4250 socklen_t ss_len = sizeof(ss);
4251 ssize_t ret;
4252 int rc;
4253
4254 si = find_socket_info(s);
4255 if (si == NULL) {
4256 return libc_readv(s, vector, count);
4257 }
4258
4259 tmp.iov_base = NULL;
4260 tmp.iov_len = 0;
4261
4262 ZERO_STRUCT(msg);
4263 msg.msg_name = (struct sockaddr *)(void *)&ss; /* optional address */
4264 msg.msg_namelen = ss_len; /* size of address */
4265 msg.msg_iov = discard_const_p(struct iovec, vector); /* scatter/gather array */
4266 msg.msg_iovlen = count; /* # elements in msg_iov */
4267 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
4268 msg.msg_control = NULL; /* ancillary data, see below */
4269 msg.msg_controllen = 0; /* ancillary data buffer len */
4270 msg.msg_flags = 0; /* flags on received message */
4271 #endif
4272
4273 rc = swrap_recvmsg_before(s, si, &msg, &tmp);
4274 if (rc < 0) {
4275 if (rc == -ENOTSOCK) {
4276 return libc_readv(s, vector, count);
4277 }
4278 return -1;
4279 }
4280
4281 ret = libc_readv(s, msg.msg_iov, msg.msg_iovlen);
4282
4283 rc = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret);
4284 if (rc != 0) {
4285 return rc;
4286 }
4287
4288 return ret;
4289 }
4290
4291 ssize_t readv(int s, const struct iovec *vector, int count)
4292 {
4293 return swrap_readv(s, vector, count);
4294 }
4295
4296 /****************************************************************************
4297 * WRITEV
4298 ***************************************************************************/
4299
4300 static ssize_t swrap_writev(int s, const struct iovec *vector, int count)
4301 {
4302 struct msghdr msg;
4303 struct iovec tmp;
4304 struct sockaddr_un un_addr;
4305 ssize_t ret;
4306 int rc;
4307 struct socket_info *si = find_socket_info(s);
4308
4309 if (!si) {
4310 return libc_writev(s, vector, count);
4311 }
4312
4313 tmp.iov_base = NULL;
4314 tmp.iov_len = 0;
4315
4316 ZERO_STRUCT(msg);
4317 msg.msg_name = NULL; /* optional address */
4318 msg.msg_namelen = 0; /* size of address */
4319 msg.msg_iov = discard_const_p(struct iovec, vector); /* scatter/gather array */
4320 msg.msg_iovlen = count; /* # elements in msg_iov */
4321 #if HAVE_STRUCT_MSGHDR_MSG_CONTROL
4322 msg.msg_control = NULL; /* ancillary data, see below */
4323 msg.msg_controllen = 0; /* ancillary data buffer len */
4324 msg.msg_flags = 0; /* flags on received message */
4325 #endif
4326
4327 rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
4328 if (rc < 0) {
4329 if (rc == -ENOTSOCK) {
4330 return libc_readv(s, vector, count);
4331 }
4332 return -1;
4333 }
4334
4335 ret = libc_writev(s, msg.msg_iov, msg.msg_iovlen);
4336
4337 swrap_sendmsg_after(s, si, &msg, NULL, ret);
4338
4339 return ret;
4340 }
4341
4342 ssize_t writev(int s, const struct iovec *vector, int count)
4343 {
4344 return swrap_writev(s, vector, count);
4345 }
4346
4347 /****************************
4348 * CLOSE
4349 ***************************/
4350
4351 static int swrap_close(int fd)
4352 {
4353 struct socket_info *si = find_socket_info(fd);
4354 struct socket_info_fd *fi;
4355 int ret;
4356
4357 if (!si) {
4358 return libc_close(fd);
4359 }
4360
4361 for (fi = si->fds; fi; fi = fi->next) {
4362 if (fi->fd == fd) {
4363 SWRAP_DLIST_REMOVE(si->fds, fi);
4364 free(fi);
4365 break;
4366 }
4367 }
4368
4369 if (si->fds) {
4370 /* there are still references left */
4371 return libc_close(fd);
4372 }
4373
4374 SWRAP_DLIST_REMOVE(sockets, si);
4375
4376 if (si->myname && si->peername) {
4377 swrap_dump_packet(si, NULL, SWRAP_CLOSE_SEND, NULL, 0);
4378 }
4379
4380 ret = libc_close(fd);
4381
4382 if (si->myname && si->peername) {
4383 swrap_dump_packet(si, NULL, SWRAP_CLOSE_RECV, NULL, 0);
4384 swrap_dump_packet(si, NULL, SWRAP_CLOSE_ACK, NULL, 0);
4385 }
4386
4387 if (si->bindname != NULL) {
4388 free(si->bindname);
4389 }
4390
4391 if (si->myname) free(si->myname);
4392 if (si->peername) free(si->peername);
4393 if (si->tmp_path) {
4394 unlink(si->tmp_path);
4395 free(si->tmp_path);
4396 }
4397 free(si);
4398
4399 return ret;
4400 }
4401
4402 int close(int fd)
4403 {
4404 return swrap_close(fd);
4405 }
4406
4407 /****************************
4408 * DUP
4409 ***************************/
4410
4411 static int swrap_dup(int fd)
4412 {
4413 struct socket_info *si;
4414 struct socket_info_fd *fi;
4415
4416 si = find_socket_info(fd);
4417
4418 if (!si) {
4419 return libc_dup(fd);
4420 }
4421
4422 fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd));
4423 if (fi == NULL) {
4424 errno = ENOMEM;
4425 return -1;
4426 }
4427
4428 fi->fd = libc_dup(fd);
4429 if (fi->fd == -1) {
4430 int saved_errno = errno;
4431 free(fi);
4432 errno = saved_errno;
4433 return -1;
4434 }
4435
4436 /* Make sure we don't have an entry for the fd */
4437 swrap_remove_stale(fi->fd);
4438
4439 SWRAP_DLIST_ADD(si->fds, fi);
4440 return fi->fd;
4441 }
4442
4443 int dup(int fd)
4444 {
4445 return swrap_dup(fd);
4446 }
4447
4448 /****************************
4449 * DUP2
4450 ***************************/
4451
4452 static int swrap_dup2(int fd, int newfd)
4453 {
4454 struct socket_info *si;
4455 struct socket_info_fd *fi;
4456
4457 si = find_socket_info(fd);
4458
4459 if (!si) {
4460 return libc_dup2(fd, newfd);
4461 }
4462
4463 if (find_socket_info(newfd)) {
4464 /* dup2() does an implicit close of newfd, which we
4465 * need to emulate */
4466 swrap_close(newfd);
4467 }
4468
4469 fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd));
4470 if (fi == NULL) {
4471 errno = ENOMEM;
4472 return -1;
4473 }
4474
4475 fi->fd = libc_dup2(fd, newfd);
4476 if (fi->fd == -1) {
4477 int saved_errno = errno;
4478 free(fi);
4479 errno = saved_errno;
4480 return -1;
4481 }
4482
4483 /* Make sure we don't have an entry for the fd */
4484 swrap_remove_stale(fi->fd);
4485
4486 SWRAP_DLIST_ADD(si->fds, fi);
4487 return fi->fd;
4488 }
4489
4490 int dup2(int fd, int newfd)
4491 {
4492 return swrap_dup2(fd, newfd);
4493 }
4494
4495 /****************************
4496 * DUP2
4497 ***************************/
4498
4499 #ifdef HAVE_EVENTFD
4500 static int swrap_eventfd(int count, int flags)
4501 {
4502 int fd;
4503
4504 fd = libc_eventfd(count, flags);
4505 if (fd != -1) {
4506 swrap_remove_stale(fd);
4507 }
4508
4509 return fd;
4510 }
4511
4512 int eventfd(int count, int flags)
4513 {
4514 return swrap_eventfd(count, flags);
4515 }
4516 #endif
4517
4518 /****************************
4519 * DESTRUCTOR
4520 ***************************/
4521
4522 /*
4523 * This function is called when the library is unloaded and makes sure that
4524 * sockets get closed and the unix file for the socket are unlinked.
4525 */
4526 void swrap_destructor(void)
4527 {
4528 struct socket_info *s = sockets;
4529
4530 while (s != NULL) {
4531 struct socket_info_fd *f = s->fds;
4532 if (f != NULL) {
4533 swrap_close(f->fd);
4534 }
4535 s = sockets;
4536 }
4537 }
Samba GIT mirror