?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Improve the VFS Makefile so that it is easier for use out of tree but still works...
[Samba/gebeck_regimport.git] / lib / socket_wrapper / socket_wrapper.c
blob2c24ab79241111ac0baa52452003624fbf43af97
1 /*
2 * Copyright (C) Jelmer Vernooij 2005,2008 <jelmer@samba.org>
3 * Copyright (C) Stefan Metzmacher 2006-2009 <metze@samba.org>
4 *
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 *
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * 3. Neither the name of the author nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 */
35
36 /*
37 Socket wrapper library. Passes all socket communication over
38 unix domain sockets if the environment variable SOCKET_WRAPPER_DIR
39 is set.
40 */
41
42 #include "config.h"
43
44 #ifdef HAVE_LIBREPLACE
45
46 #define SOCKET_WRAPPER_NOT_REPLACE
47 #include "replace.h"
48 #include "system/network.h"
49 #include "system/filesys.h"
50 #include "system/time.h"
51
52 #else /* HAVE_LIBREPLACE */
53
54 #include <sys/types.h>
55 #include <sys/time.h>
56 #include <sys/stat.h>
57 #include <sys/socket.h>
58 #include <sys/ioctl.h>
59 #include <sys/filio.h>
60 #include <errno.h>
61 #include <sys/un.h>
62 #include <netinet/in.h>
63 #include <netinet/tcp.h>
64 #include <fcntl.h>
65 #include <stdlib.h>
66 #include <unistd.h>
67 #include <string.h>
68 #include <stdio.h>
69 #include <stdint.h>
70
71 #endif /* HAVE_LIBREPLACE */
72
73 #ifndef _PUBLIC_
74 #define _PUBLIC_
75 #endif
76
77 #define SWRAP_DLIST_ADD(list,item) do { \
78 if (!(list)) { \
79 (item)->prev = NULL; \
80 (item)->next = NULL; \
81 (list) = (item); \
82 } else { \
83 (item)->prev = NULL; \
84 (item)->next = (list); \
85 (list)->prev = (item); \
86 (list) = (item); \
87 } \
88 } while (0)
89
90 #define SWRAP_DLIST_REMOVE(list,item) do { \
91 if ((list) == (item)) { \
92 (list) = (item)->next; \
93 if (list) { \
94 (list)->prev = NULL; \
95 } \
96 } else { \
97 if ((item)->prev) { \
98 (item)->prev->next = (item)->next; \
99 } \
100 if ((item)->next) { \
101 (item)->next->prev = (item)->prev; \
102 } \
103 } \
104 (item)->prev = NULL; \
105 (item)->next = NULL; \
106 } while (0)
107
108 /* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
109 * for now */
110 #define REWRITE_CALLS
111
112 #ifdef REWRITE_CALLS
113 #define real_accept accept
114 #define real_connect connect
115 #define real_bind bind
116 #define real_listen listen
117 #define real_getpeername getpeername
118 #define real_getsockname getsockname
119 #define real_getsockopt getsockopt
120 #define real_setsockopt setsockopt
121 #define real_recvfrom recvfrom
122 #define real_sendto sendto
123 #define real_sendmsg sendmsg
124 #define real_ioctl ioctl
125 #define real_recv recv
126 #define real_read read
127 #define real_send send
128 #define real_readv readv
129 #define real_writev writev
130 #define real_socket socket
131 #define real_close close
132 #define real_dup dup
133 #define real_dup2 dup2
134 #endif
135
136 #ifdef HAVE_GETTIMEOFDAY_TZ
137 #define swrapGetTimeOfDay(tval) gettimeofday(tval,NULL)
138 #else
139 #define swrapGetTimeOfDay(tval) gettimeofday(tval)
140 #endif
141
142 /* we need to use a very terse format here as IRIX 6.4 silently
143 truncates names to 16 chars, so if we use a longer name then we
144 can't tell which port a packet came from with recvfrom()
145
146 with this format we have 8 chars left for the directory name
147 */
148 #define SOCKET_FORMAT "%c%02X%04X"
149 #define SOCKET_TYPE_CHAR_TCP 'T'
150 #define SOCKET_TYPE_CHAR_UDP 'U'
151 #define SOCKET_TYPE_CHAR_TCP_V6 'X'
152 #define SOCKET_TYPE_CHAR_UDP_V6 'Y'
153
154 /* This limit is to avoid broadcast sendto() needing to stat too many
155 * files. It may be raised (with a performance cost) to up to 254
156 * without changing the format above */
157 #define MAX_WRAPPED_INTERFACES 32
158
159 #ifdef HAVE_IPV6
160 /*
161 * FD00::5357:5FXX
162 */
163 static const struct in6_addr *swrap_ipv6(void)
164 {
165 static struct in6_addr v;
166 static int initialized;
167 int ret;
168
169 if (initialized) {
170 return &v;
171 }
172 initialized = 1;
173
174 ret = inet_pton(AF_INET6, "FD00::5357:5F00", &v);
175 if (ret <= 0) {
176 abort();
177 }
178
179 return &v;
180 }
181 #endif
182
183 static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
184 {
185 struct sockaddr *ret = (struct sockaddr *)malloc(len);
186 memcpy(ret, data, len);
187 return ret;
188 }
189
190 static void set_port(int family, int prt, struct sockaddr *addr)
191 {
192 switch (family) {
193 case AF_INET:
194 ((struct sockaddr_in *)addr)->sin_port = htons(prt);
195 break;
196 #ifdef HAVE_IPV6
197 case AF_INET6:
198 ((struct sockaddr_in6 *)addr)->sin6_port = htons(prt);
199 break;
200 #endif
201 }
202 }
203
204 static size_t socket_length(int family)
205 {
206 switch (family) {
207 case AF_INET:
208 return sizeof(struct sockaddr_in);
209 #ifdef HAVE_IPV6
210 case AF_INET6:
211 return sizeof(struct sockaddr_in6);
212 #endif
213 }
214 return 0;
215 }
216
217 struct socket_info_fd {
218 struct socket_info_fd *prev, *next;
219 int fd;
220 };
221
222 struct socket_info
223 {
224 struct socket_info_fd *fds;
225
226 int family;
227 int type;
228 int protocol;
229 int bound;
230 int bcast;
231 int is_server;
232 int connected;
233 int defer_connect;
234
235 char *tmp_path;
236
237 struct sockaddr *myname;
238 socklen_t myname_len;
239
240 struct sockaddr *peername;
241 socklen_t peername_len;
242
243 struct {
244 unsigned long pck_snd;
245 unsigned long pck_rcv;
246 } io;
247
248 struct socket_info *prev, *next;
249 };
250
251 static struct socket_info *sockets;
252
253 const char *socket_wrapper_dir(void)
254 {
255 const char *s = getenv("SOCKET_WRAPPER_DIR");
256 if (s == NULL) {
257 return NULL;
258 }
259 if (strncmp(s, "./", 2) == 0) {
260 s += 2;
261 }
262 return s;
263 }
264
265 unsigned int socket_wrapper_default_iface(void)
266 {
267 const char *s = getenv("SOCKET_WRAPPER_DEFAULT_IFACE");
268 if (s) {
269 unsigned int iface;
270 if (sscanf(s, "%u", &iface) == 1) {
271 if (iface >= 1 && iface <= MAX_WRAPPED_INTERFACES) {
272 return iface;
273 }
274 }
275 }
276
277 return 1;/* 127.0.0.1 */
278 }
279
280 static int convert_un_in(const struct sockaddr_un *un, struct sockaddr *in, socklen_t *len)
281 {
282 unsigned int iface;
283 unsigned int prt;
284 const char *p;
285 char type;
286
287 p = strrchr(un->sun_path, '/');
288 if (p) p++; else p = un->sun_path;
289
290 if (sscanf(p, SOCKET_FORMAT, &type, &iface, &prt) != 3) {
291 errno = EINVAL;
292 return -1;
293 }
294
295 if (iface == 0 || iface > MAX_WRAPPED_INTERFACES) {
296 errno = EINVAL;
297 return -1;
298 }
299
300 if (prt > 0xFFFF) {
301 errno = EINVAL;
302 return -1;
303 }
304
305 switch(type) {
306 case SOCKET_TYPE_CHAR_TCP:
307 case SOCKET_TYPE_CHAR_UDP: {
308 struct sockaddr_in *in2 = (struct sockaddr_in *)(void *)in;
309
310 if ((*len) < sizeof(*in2)) {
311 errno = EINVAL;
312 return -1;
313 }
314
315 memset(in2, 0, sizeof(*in2));
316 in2->sin_family = AF_INET;
317 in2->sin_addr.s_addr = htonl((127<<24) | iface);
318 in2->sin_port = htons(prt);
319
320 *len = sizeof(*in2);
321 break;
322 }
323 #ifdef HAVE_IPV6
324 case SOCKET_TYPE_CHAR_TCP_V6:
325 case SOCKET_TYPE_CHAR_UDP_V6: {
326 struct sockaddr_in6 *in2 = (struct sockaddr_in6 *)(void *)in;
327
328 if ((*len) < sizeof(*in2)) {
329 errno = EINVAL;
330 return -1;
331 }
332
333 memset(in2, 0, sizeof(*in2));
334 in2->sin6_family = AF_INET6;
335 in2->sin6_addr = *swrap_ipv6();
336 in2->sin6_addr.s6_addr[15] = iface;
337 in2->sin6_port = htons(prt);
338
339 *len = sizeof(*in2);
340 break;
341 }
342 #endif
343 default:
344 errno = EINVAL;
345 return -1;
346 }
347
348 return 0;
349 }
350
351 static int convert_in_un_remote(struct socket_info *si, const struct sockaddr *inaddr, struct sockaddr_un *un,
352 int *bcast)
353 {
354 char type = '\0';
355 unsigned int prt;
356 unsigned int iface;
357 int is_bcast = 0;
358
359 if (bcast) *bcast = 0;
360
361 switch (inaddr->sa_family) {
362 case AF_INET: {
363 const struct sockaddr_in *in =
364 (const struct sockaddr_in *)(const void *)inaddr;
365 unsigned int addr = ntohl(in->sin_addr.s_addr);
366 char u_type = '\0';
367 char b_type = '\0';
368 char a_type = '\0';
369
370 switch (si->type) {
371 case SOCK_STREAM:
372 u_type = SOCKET_TYPE_CHAR_TCP;
373 break;
374 case SOCK_DGRAM:
375 u_type = SOCKET_TYPE_CHAR_UDP;
376 a_type = SOCKET_TYPE_CHAR_UDP;
377 b_type = SOCKET_TYPE_CHAR_UDP;
378 break;
379 }
380
381 prt = ntohs(in->sin_port);
382 if (a_type && addr == 0xFFFFFFFF) {
383 /* 255.255.255.255 only udp */
384 is_bcast = 2;
385 type = a_type;
386 iface = socket_wrapper_default_iface();
387 } else if (b_type && addr == 0x7FFFFFFF) {
388 /* 127.255.255.255 only udp */
389 is_bcast = 1;
390 type = b_type;
391 iface = socket_wrapper_default_iface();
392 } else if ((addr & 0xFFFFFF00) == 0x7F000000) {
393 /* 127.0.0.X */
394 is_bcast = 0;
395 type = u_type;
396 iface = (addr & 0x000000FF);
397 } else {
398 errno = ENETUNREACH;
399 return -1;
400 }
401 if (bcast) *bcast = is_bcast;
402 break;
403 }
404 #ifdef HAVE_IPV6
405 case AF_INET6: {
406 const struct sockaddr_in6 *in =
407 (const struct sockaddr_in6 *)(const void *)inaddr;
408 struct in6_addr cmp1, cmp2;
409
410 switch (si->type) {
411 case SOCK_STREAM:
412 type = SOCKET_TYPE_CHAR_TCP_V6;
413 break;
414 case SOCK_DGRAM:
415 type = SOCKET_TYPE_CHAR_UDP_V6;
416 break;
417 }
418
419 /* XXX no multicast/broadcast */
420
421 prt = ntohs(in->sin6_port);
422
423 cmp1 = *swrap_ipv6();
424 cmp2 = in->sin6_addr;
425 cmp2.s6_addr[15] = 0;
426 if (IN6_ARE_ADDR_EQUAL(&cmp1, &cmp2)) {
427 iface = in->sin6_addr.s6_addr[15];
428 } else {
429 errno = ENETUNREACH;
430 return -1;
431 }
432
433 break;
434 }
435 #endif
436 default:
437 errno = ENETUNREACH;
438 return -1;
439 }
440
441 if (prt == 0) {
442 errno = EINVAL;
443 return -1;
444 }
445
446 if (is_bcast) {
447 snprintf(un->sun_path, sizeof(un->sun_path), "%s/EINVAL",
448 socket_wrapper_dir());
449 /* the caller need to do more processing */
450 return 0;
451 }
452
453 snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
454 socket_wrapper_dir(), type, iface, prt);
455
456 return 0;
457 }
458
459 static int convert_in_un_alloc(struct socket_info *si, const struct sockaddr *inaddr, struct sockaddr_un *un,
460 int *bcast)
461 {
462 char type = '\0';
463 unsigned int prt;
464 unsigned int iface;
465 struct stat st;
466 int is_bcast = 0;
467
468 if (bcast) *bcast = 0;
469
470 switch (si->family) {
471 case AF_INET: {
472 const struct sockaddr_in *in =
473 (const struct sockaddr_in *)(const void *)inaddr;
474 unsigned int addr = ntohl(in->sin_addr.s_addr);
475 char u_type = '\0';
476 char d_type = '\0';
477 char b_type = '\0';
478 char a_type = '\0';
479
480 prt = ntohs(in->sin_port);
481
482 switch (si->type) {
483 case SOCK_STREAM:
484 u_type = SOCKET_TYPE_CHAR_TCP;
485 d_type = SOCKET_TYPE_CHAR_TCP;
486 break;
487 case SOCK_DGRAM:
488 u_type = SOCKET_TYPE_CHAR_UDP;
489 d_type = SOCKET_TYPE_CHAR_UDP;
490 a_type = SOCKET_TYPE_CHAR_UDP;
491 b_type = SOCKET_TYPE_CHAR_UDP;
492 break;
493 }
494
495 if (addr == 0) {
496 /* 0.0.0.0 */
497 is_bcast = 0;
498 type = d_type;
499 iface = socket_wrapper_default_iface();
500 } else if (a_type && addr == 0xFFFFFFFF) {
501 /* 255.255.255.255 only udp */
502 is_bcast = 2;
503 type = a_type;
504 iface = socket_wrapper_default_iface();
505 } else if (b_type && addr == 0x7FFFFFFF) {
506 /* 127.255.255.255 only udp */
507 is_bcast = 1;
508 type = b_type;
509 iface = socket_wrapper_default_iface();
510 } else if ((addr & 0xFFFFFF00) == 0x7F000000) {
511 /* 127.0.0.X */
512 is_bcast = 0;
513 type = u_type;
514 iface = (addr & 0x000000FF);
515 } else {
516 errno = EADDRNOTAVAIL;
517 return -1;
518 }
519 break;
520 }
521 #ifdef HAVE_IPV6
522 case AF_INET6: {
523 const struct sockaddr_in6 *in =
524 (const struct sockaddr_in6 *)(const void *)inaddr;
525 struct in6_addr cmp1, cmp2;
526
527 switch (si->type) {
528 case SOCK_STREAM:
529 type = SOCKET_TYPE_CHAR_TCP_V6;
530 break;
531 case SOCK_DGRAM:
532 type = SOCKET_TYPE_CHAR_UDP_V6;
533 break;
534 }
535
536 /* XXX no multicast/broadcast */
537
538 prt = ntohs(in->sin6_port);
539
540 cmp1 = *swrap_ipv6();
541 cmp2 = in->sin6_addr;
542 cmp2.s6_addr[15] = 0;
543 if (IN6_IS_ADDR_UNSPECIFIED(&in->sin6_addr)) {
544 iface = socket_wrapper_default_iface();
545 } else if (IN6_ARE_ADDR_EQUAL(&cmp1, &cmp2)) {
546 iface = in->sin6_addr.s6_addr[15];
547 } else {
548 errno = EADDRNOTAVAIL;
549 return -1;
550 }
551
552 break;
553 }
554 #endif
555 default:
556 errno = EADDRNOTAVAIL;
557 return -1;
558 }
559
560
561 if (bcast) *bcast = is_bcast;
562
563 if (iface == 0 || iface > MAX_WRAPPED_INTERFACES) {
564 errno = EINVAL;
565 return -1;
566 }
567
568 if (prt == 0) {
569 /* handle auto-allocation of ephemeral ports */
570 for (prt = 5001; prt < 10000; prt++) {
571 snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
572 socket_wrapper_dir(), type, iface, prt);
573 if (stat(un->sun_path, &st) == 0) continue;
574
575 set_port(si->family, prt, si->myname);
576 break;
577 }
578 if (prt == 10000) {
579 errno = ENFILE;
580 return -1;
581 }
582 }
583
584 snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
585 socket_wrapper_dir(), type, iface, prt);
586 return 0;
587 }
588
589 static struct socket_info *find_socket_info(int fd)
590 {
591 struct socket_info *i;
592 for (i = sockets; i; i = i->next) {
593 struct socket_info_fd *f;
594 for (f = i->fds; f; f = f->next) {
595 if (f->fd == fd) {
596 return i;
597 }
598 }
599 }
600
601 return NULL;
602 }
603
604 static int sockaddr_convert_to_un(struct socket_info *si, const struct sockaddr *in_addr, socklen_t in_len,
605 struct sockaddr_un *out_addr, int alloc_sock, int *bcast)
606 {
607 struct sockaddr *out = (struct sockaddr *)(void *)out_addr;
608 if (!out_addr)
609 return 0;
610
611 out->sa_family = AF_UNIX;
612 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
613 out->sa_len = sizeof(*out_addr);
614 #endif
615
616 switch (in_addr->sa_family) {
617 case AF_INET:
618 #ifdef HAVE_IPV6
619 case AF_INET6:
620 #endif
621 switch (si->type) {
622 case SOCK_STREAM:
623 case SOCK_DGRAM:
624 break;
625 default:
626 errno = ESOCKTNOSUPPORT;
627 return -1;
628 }
629 if (alloc_sock) {
630 return convert_in_un_alloc(si, in_addr, out_addr, bcast);
631 } else {
632 return convert_in_un_remote(si, in_addr, out_addr, bcast);
633 }
634 default:
635 break;
636 }
637
638 errno = EAFNOSUPPORT;
639 return -1;
640 }
641
642 static int sockaddr_convert_from_un(const struct socket_info *si,
643 const struct sockaddr_un *in_addr,
644 socklen_t un_addrlen,
645 int family,
646 struct sockaddr *out_addr,
647 socklen_t *out_addrlen)
648 {
649 int ret;
650
651 if (out_addr == NULL || out_addrlen == NULL)
652 return 0;
653
654 if (un_addrlen == 0) {
655 *out_addrlen = 0;
656 return 0;
657 }
658
659 switch (family) {
660 case AF_INET:
661 #ifdef HAVE_IPV6
662 case AF_INET6:
663 #endif
664 switch (si->type) {
665 case SOCK_STREAM:
666 case SOCK_DGRAM:
667 break;
668 default:
669 errno = ESOCKTNOSUPPORT;
670 return -1;
671 }
672 ret = convert_un_in(in_addr, out_addr, out_addrlen);
673 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
674 out_addr->sa_len = *out_addrlen;
675 #endif
676 return ret;
677 default:
678 break;
679 }
680
681 errno = EAFNOSUPPORT;
682 return -1;
683 }
684
685 enum swrap_packet_type {
686 SWRAP_CONNECT_SEND,
687 SWRAP_CONNECT_UNREACH,
688 SWRAP_CONNECT_RECV,
689 SWRAP_CONNECT_ACK,
690 SWRAP_ACCEPT_SEND,
691 SWRAP_ACCEPT_RECV,
692 SWRAP_ACCEPT_ACK,
693 SWRAP_RECVFROM,
694 SWRAP_SENDTO,
695 SWRAP_SENDTO_UNREACH,
696 SWRAP_PENDING_RST,
697 SWRAP_RECV,
698 SWRAP_RECV_RST,
699 SWRAP_SEND,
700 SWRAP_SEND_RST,
701 SWRAP_CLOSE_SEND,
702 SWRAP_CLOSE_RECV,
703 SWRAP_CLOSE_ACK,
704 };
705
706 struct swrap_file_hdr {
707 uint32_t magic;
708 uint16_t version_major;
709 uint16_t version_minor;
710 int32_t timezone;
711 uint32_t sigfigs;
712 uint32_t frame_max_len;
713 #define SWRAP_FRAME_LENGTH_MAX 0xFFFF
714 uint32_t link_type;
715 };
716 #define SWRAP_FILE_HDR_SIZE 24
717
718 struct swrap_packet_frame {
719 uint32_t seconds;
720 uint32_t micro_seconds;
721 uint32_t recorded_length;
722 uint32_t full_length;
723 };
724 #define SWRAP_PACKET_FRAME_SIZE 16
725
726 union swrap_packet_ip {
727 struct {
728 uint8_t ver_hdrlen;
729 uint8_t tos;
730 uint16_t packet_length;
731 uint16_t identification;
732 uint8_t flags;
733 uint8_t fragment;
734 uint8_t ttl;
735 uint8_t protocol;
736 uint16_t hdr_checksum;
737 uint32_t src_addr;
738 uint32_t dest_addr;
739 } v4;
740 #define SWRAP_PACKET_IP_V4_SIZE 20
741 struct {
742 uint8_t ver_prio;
743 uint8_t flow_label_high;
744 uint16_t flow_label_low;
745 uint16_t payload_length;
746 uint8_t next_header;
747 uint8_t hop_limit;
748 uint8_t src_addr[16];
749 uint8_t dest_addr[16];
750 } v6;
751 #define SWRAP_PACKET_IP_V6_SIZE 40
752 };
753 #define SWRAP_PACKET_IP_SIZE 40
754
755 union swrap_packet_payload {
756 struct {
757 uint16_t source_port;
758 uint16_t dest_port;
759 uint32_t seq_num;
760 uint32_t ack_num;
761 uint8_t hdr_length;
762 uint8_t control;
763 uint16_t window;
764 uint16_t checksum;
765 uint16_t urg;
766 } tcp;
767 #define SWRAP_PACKET_PAYLOAD_TCP_SIZE 20
768 struct {
769 uint16_t source_port;
770 uint16_t dest_port;
771 uint16_t length;
772 uint16_t checksum;
773 } udp;
774 #define SWRAP_PACKET_PAYLOAD_UDP_SIZE 8
775 struct {
776 uint8_t type;
777 uint8_t code;
778 uint16_t checksum;
779 uint32_t unused;
780 } icmp4;
781 #define SWRAP_PACKET_PAYLOAD_ICMP4_SIZE 8
782 struct {
783 uint8_t type;
784 uint8_t code;
785 uint16_t checksum;
786 uint32_t unused;
787 } icmp6;
788 #define SWRAP_PACKET_PAYLOAD_ICMP6_SIZE 8
789 };
790 #define SWRAP_PACKET_PAYLOAD_SIZE 20
791
792 #define SWRAP_PACKET_MIN_ALLOC \
793 (SWRAP_PACKET_FRAME_SIZE + \
794 SWRAP_PACKET_IP_SIZE + \
795 SWRAP_PACKET_PAYLOAD_SIZE)
796
797 static const char *socket_wrapper_pcap_file(void)
798 {
799 static int initialized = 0;
800 static const char *s = NULL;
801 static const struct swrap_file_hdr h;
802 static const struct swrap_packet_frame f;
803 static const union swrap_packet_ip i;
804 static const union swrap_packet_payload p;
805
806 if (initialized == 1) {
807 return s;
808 }
809 initialized = 1;
810
811 /*
812 * TODO: don't use the structs use plain buffer offsets
813 * and PUSH_U8(), PUSH_U16() and PUSH_U32()
814 *
815 * for now make sure we disable PCAP support
816 * if the struct has alignment!
817 */
818 if (sizeof(h) != SWRAP_FILE_HDR_SIZE) {
819 return NULL;
820 }
821 if (sizeof(f) != SWRAP_PACKET_FRAME_SIZE) {
822 return NULL;
823 }
824 if (sizeof(i) != SWRAP_PACKET_IP_SIZE) {
825 return NULL;
826 }
827 if (sizeof(i.v4) != SWRAP_PACKET_IP_V4_SIZE) {
828 return NULL;
829 }
830 if (sizeof(i.v6) != SWRAP_PACKET_IP_V6_SIZE) {
831 return NULL;
832 }
833 if (sizeof(p) != SWRAP_PACKET_PAYLOAD_SIZE) {
834 return NULL;
835 }
836 if (sizeof(p.tcp) != SWRAP_PACKET_PAYLOAD_TCP_SIZE) {
837 return NULL;
838 }
839 if (sizeof(p.udp) != SWRAP_PACKET_PAYLOAD_UDP_SIZE) {
840 return NULL;
841 }
842 if (sizeof(p.icmp4) != SWRAP_PACKET_PAYLOAD_ICMP4_SIZE) {
843 return NULL;
844 }
845 if (sizeof(p.icmp6) != SWRAP_PACKET_PAYLOAD_ICMP6_SIZE) {
846 return NULL;
847 }
848
849 s = getenv("SOCKET_WRAPPER_PCAP_FILE");
850 if (s == NULL) {
851 return NULL;
852 }
853 if (strncmp(s, "./", 2) == 0) {
854 s += 2;
855 }
856 return s;
857 }
858
859 static uint8_t *swrap_packet_init(struct timeval *tval,
860 const struct sockaddr *src,
861 const struct sockaddr *dest,
862 int socket_type,
863 const uint8_t *payload,
864 size_t payload_len,
865 unsigned long tcp_seqno,
866 unsigned long tcp_ack,
867 unsigned char tcp_ctl,
868 int unreachable,
869 size_t *_packet_len)
870 {
871 uint8_t *base;
872 uint8_t *buf;
873 struct swrap_packet_frame *frame;
874 union swrap_packet_ip *ip;
875 union swrap_packet_payload *pay;
876 size_t packet_len;
877 size_t alloc_len;
878 size_t nonwire_len = sizeof(*frame);
879 size_t wire_hdr_len = 0;
880 size_t wire_len = 0;
881 size_t ip_hdr_len = 0;
882 size_t icmp_hdr_len = 0;
883 size_t icmp_truncate_len = 0;
884 uint8_t protocol = 0, icmp_protocol = 0;
885 const struct sockaddr_in *src_in = NULL;
886 const struct sockaddr_in *dest_in = NULL;
887 #ifdef HAVE_IPV6
888 const struct sockaddr_in6 *src_in6 = NULL;
889 const struct sockaddr_in6 *dest_in6 = NULL;
890 #endif
891 uint16_t src_port;
892 uint16_t dest_port;
893
894 switch (src->sa_family) {
895 case AF_INET:
896 src_in = (const struct sockaddr_in *)src;
897 dest_in = (const struct sockaddr_in *)dest;
898 src_port = src_in->sin_port;
899 dest_port = dest_in->sin_port;
900 ip_hdr_len = sizeof(ip->v4);
901 break;
902 #ifdef HAVE_IPV6
903 case AF_INET6:
904 src_in6 = (const struct sockaddr_in6 *)src;
905 dest_in6 = (const struct sockaddr_in6 *)dest;
906 src_port = src_in6->sin6_port;
907 dest_port = dest_in6->sin6_port;
908 ip_hdr_len = sizeof(ip->v6);
909 break;
910 #endif
911 default:
912 return NULL;
913 }
914
915 switch (socket_type) {
916 case SOCK_STREAM:
917 protocol = 0x06; /* TCP */
918 wire_hdr_len = ip_hdr_len + sizeof(pay->tcp);
919 wire_len = wire_hdr_len + payload_len;
920 break;
921
922 case SOCK_DGRAM:
923 protocol = 0x11; /* UDP */
924 wire_hdr_len = ip_hdr_len + sizeof(pay->udp);
925 wire_len = wire_hdr_len + payload_len;
926 break;
927
928 default:
929 return NULL;
930 }
931
932 if (unreachable) {
933 icmp_protocol = protocol;
934 switch (src->sa_family) {
935 case AF_INET:
936 protocol = 0x01; /* ICMPv4 */
937 icmp_hdr_len = ip_hdr_len + sizeof(pay->icmp4);
938 break;
939 #ifdef HAVE_IPV6
940 case AF_INET6:
941 protocol = 0x3A; /* ICMPv6 */
942 icmp_hdr_len = ip_hdr_len + sizeof(pay->icmp6);
943 break;
944 #endif
945 }
946 if (wire_len > 64 ) {
947 icmp_truncate_len = wire_len - 64;
948 }
949 wire_hdr_len += icmp_hdr_len;
950 wire_len += icmp_hdr_len;
951 }
952
953 packet_len = nonwire_len + wire_len;
954 alloc_len = packet_len;
955 if (alloc_len < SWRAP_PACKET_MIN_ALLOC) {
956 alloc_len = SWRAP_PACKET_MIN_ALLOC;
957 }
958
959 base = (uint8_t *)malloc(alloc_len);
960 if (!base) return NULL;
961
962 buf = base;
963
964 frame = (struct swrap_packet_frame *)buf;
965 frame->seconds = tval->tv_sec;
966 frame->micro_seconds = tval->tv_usec;
967 frame->recorded_length = wire_len - icmp_truncate_len;
968 frame->full_length = wire_len - icmp_truncate_len;
969 buf += SWRAP_PACKET_FRAME_SIZE;
970
971 ip = (union swrap_packet_ip *)buf;
972 switch (src->sa_family) {
973 case AF_INET:
974 ip->v4.ver_hdrlen = 0x45; /* version 4 and 5 * 32 bit words */
975 ip->v4.tos = 0x00;
976 ip->v4.packet_length = htons(wire_len - icmp_truncate_len);
977 ip->v4.identification = htons(0xFFFF);
978 ip->v4.flags = 0x40; /* BIT 1 set - means don't fraqment */
979 ip->v4.fragment = htons(0x0000);
980 ip->v4.ttl = 0xFF;
981 ip->v4.protocol = protocol;
982 ip->v4.hdr_checksum = htons(0x0000);
983 ip->v4.src_addr = src_in->sin_addr.s_addr;
984 ip->v4.dest_addr = dest_in->sin_addr.s_addr;
985 buf += SWRAP_PACKET_IP_V4_SIZE;
986 break;
987 #ifdef HAVE_IPV6
988 case AF_INET6:
989 ip->v6.ver_prio = 0x60; /* version 4 and 5 * 32 bit words */
990 ip->v6.flow_label_high = 0x00;
991 ip->v6.flow_label_low = 0x0000;
992 ip->v6.payload_length = htons(wire_len - icmp_truncate_len); /* TODO */
993 ip->v6.next_header = protocol;
994 memcpy(ip->v6.src_addr, src_in6->sin6_addr.s6_addr, 16);
995 memcpy(ip->v6.dest_addr, dest_in6->sin6_addr.s6_addr, 16);
996 buf += SWRAP_PACKET_IP_V6_SIZE;
997 break;
998 #endif
999 }
1000
1001 if (unreachable) {
1002 pay = (union swrap_packet_payload *)buf;
1003 switch (src->sa_family) {
1004 case AF_INET:
1005 pay->icmp4.type = 0x03; /* destination unreachable */
1006 pay->icmp4.code = 0x01; /* host unreachable */
1007 pay->icmp4.checksum = htons(0x0000);
1008 pay->icmp4.unused = htonl(0x00000000);
1009 buf += SWRAP_PACKET_PAYLOAD_ICMP4_SIZE;
1010
1011 /* set the ip header in the ICMP payload */
1012 ip = (union swrap_packet_ip *)buf;
1013 ip->v4.ver_hdrlen = 0x45; /* version 4 and 5 * 32 bit words */
1014 ip->v4.tos = 0x00;
1015 ip->v4.packet_length = htons(wire_len - icmp_hdr_len);
1016 ip->v4.identification = htons(0xFFFF);
1017 ip->v4.flags = 0x40; /* BIT 1 set - means don't fraqment */
1018 ip->v4.fragment = htons(0x0000);
1019 ip->v4.ttl = 0xFF;
1020 ip->v4.protocol = icmp_protocol;
1021 ip->v4.hdr_checksum = htons(0x0000);
1022 ip->v4.src_addr = dest_in->sin_addr.s_addr;
1023 ip->v4.dest_addr = src_in->sin_addr.s_addr;
1024 buf += SWRAP_PACKET_IP_V4_SIZE;
1025
1026 src_port = dest_in->sin_port;
1027 dest_port = src_in->sin_port;
1028 break;
1029 #ifdef HAVE_IPV6
1030 case AF_INET6:
1031 pay->icmp6.type = 0x01; /* destination unreachable */
1032 pay->icmp6.code = 0x03; /* address unreachable */
1033 pay->icmp6.checksum = htons(0x0000);
1034 pay->icmp6.unused = htonl(0x00000000);
1035 buf += SWRAP_PACKET_PAYLOAD_ICMP6_SIZE;
1036
1037 /* set the ip header in the ICMP payload */
1038 ip = (union swrap_packet_ip *)buf;
1039 ip->v6.ver_prio = 0x60; /* version 4 and 5 * 32 bit words */
1040 ip->v6.flow_label_high = 0x00;
1041 ip->v6.flow_label_low = 0x0000;
1042 ip->v6.payload_length = htons(wire_len - icmp_truncate_len); /* TODO */
1043 ip->v6.next_header = protocol;
1044 memcpy(ip->v6.src_addr, dest_in6->sin6_addr.s6_addr, 16);
1045 memcpy(ip->v6.dest_addr, src_in6->sin6_addr.s6_addr, 16);
1046 buf += SWRAP_PACKET_IP_V6_SIZE;
1047
1048 src_port = dest_in6->sin6_port;
1049 dest_port = src_in6->sin6_port;
1050 break;
1051 #endif
1052 }
1053 }
1054
1055 pay = (union swrap_packet_payload *)buf;
1056
1057 switch (socket_type) {
1058 case SOCK_STREAM:
1059 pay->tcp.source_port = src_port;
1060 pay->tcp.dest_port = dest_port;
1061 pay->tcp.seq_num = htonl(tcp_seqno);
1062 pay->tcp.ack_num = htonl(tcp_ack);
1063 pay->tcp.hdr_length = 0x50; /* 5 * 32 bit words */
1064 pay->tcp.control = tcp_ctl;
1065 pay->tcp.window = htons(0x7FFF);
1066 pay->tcp.checksum = htons(0x0000);
1067 pay->tcp.urg = htons(0x0000);
1068 buf += SWRAP_PACKET_PAYLOAD_TCP_SIZE;
1069
1070 break;
1071
1072 case SOCK_DGRAM:
1073 pay->udp.source_port = src_port;
1074 pay->udp.dest_port = dest_port;
1075 pay->udp.length = htons(8 + payload_len);
1076 pay->udp.checksum = htons(0x0000);
1077 buf += SWRAP_PACKET_PAYLOAD_UDP_SIZE;
1078
1079 break;
1080 }
1081
1082 if (payload && payload_len > 0) {
1083 memcpy(buf, payload, payload_len);
1084 }
1085
1086 *_packet_len = packet_len - icmp_truncate_len;
1087 return base;
1088 }
1089
1090 static int swrap_get_pcap_fd(const char *fname)
1091 {
1092 static int fd = -1;
1093
1094 if (fd != -1) return fd;
1095
1096 fd = open(fname, O_WRONLY|O_CREAT|O_EXCL|O_APPEND, 0644);
1097 if (fd != -1) {
1098 struct swrap_file_hdr file_hdr;
1099 file_hdr.magic = 0xA1B2C3D4;
1100 file_hdr.version_major = 0x0002;
1101 file_hdr.version_minor = 0x0004;
1102 file_hdr.timezone = 0x00000000;
1103 file_hdr.sigfigs = 0x00000000;
1104 file_hdr.frame_max_len = SWRAP_FRAME_LENGTH_MAX;
1105 file_hdr.link_type = 0x0065; /* 101 RAW IP */
1106
1107 if (write(fd, &file_hdr, sizeof(file_hdr)) != sizeof(file_hdr)) {
1108 close(fd);
1109 fd = -1;
1110 }
1111 return fd;
1112 }
1113
1114 fd = open(fname, O_WRONLY|O_APPEND, 0644);
1115
1116 return fd;
1117 }
1118
1119 static uint8_t *swrap_marshall_packet(struct socket_info *si,
1120 const struct sockaddr *addr,
1121 enum swrap_packet_type type,
1122 const void *buf, size_t len,
1123 size_t *packet_len)
1124 {
1125 const struct sockaddr *src_addr;
1126 const struct sockaddr *dest_addr;
1127 unsigned long tcp_seqno = 0;
1128 unsigned long tcp_ack = 0;
1129 unsigned char tcp_ctl = 0;
1130 int unreachable = 0;
1131
1132 struct timeval tv;
1133
1134 switch (si->family) {
1135 case AF_INET:
1136 break;
1137 #ifdef HAVE_IPV6
1138 case AF_INET6:
1139 break;
1140 #endif
1141 default:
1142 return NULL;
1143 }
1144
1145 switch (type) {
1146 case SWRAP_CONNECT_SEND:
1147 if (si->type != SOCK_STREAM) return NULL;
1148
1149 src_addr = si->myname;
1150 dest_addr = addr;
1151
1152 tcp_seqno = si->io.pck_snd;
1153 tcp_ack = si->io.pck_rcv;
1154 tcp_ctl = 0x02; /* SYN */
1155
1156 si->io.pck_snd += 1;
1157
1158 break;
1159
1160 case SWRAP_CONNECT_RECV:
1161 if (si->type != SOCK_STREAM) return NULL;
1162
1163 dest_addr = si->myname;
1164 src_addr = addr;
1165
1166 tcp_seqno = si->io.pck_rcv;
1167 tcp_ack = si->io.pck_snd;
1168 tcp_ctl = 0x12; /** SYN,ACK */
1169
1170 si->io.pck_rcv += 1;
1171
1172 break;
1173
1174 case SWRAP_CONNECT_UNREACH:
1175 if (si->type != SOCK_STREAM) return NULL;
1176
1177 dest_addr = si->myname;
1178 src_addr = addr;
1179
1180 /* Unreachable: resend the data of SWRAP_CONNECT_SEND */
1181 tcp_seqno = si->io.pck_snd - 1;
1182 tcp_ack = si->io.pck_rcv;
1183 tcp_ctl = 0x02; /* SYN */
1184 unreachable = 1;
1185
1186 break;
1187
1188 case SWRAP_CONNECT_ACK:
1189 if (si->type != SOCK_STREAM) return NULL;
1190
1191 src_addr = si->myname;
1192 dest_addr = addr;
1193
1194 tcp_seqno = si->io.pck_snd;
1195 tcp_ack = si->io.pck_rcv;
1196 tcp_ctl = 0x10; /* ACK */
1197
1198 break;
1199
1200 case SWRAP_ACCEPT_SEND:
1201 if (si->type != SOCK_STREAM) return NULL;
1202
1203 dest_addr = si->myname;
1204 src_addr = addr;
1205
1206 tcp_seqno = si->io.pck_rcv;
1207 tcp_ack = si->io.pck_snd;
1208 tcp_ctl = 0x02; /* SYN */
1209
1210 si->io.pck_rcv += 1;
1211
1212 break;
1213
1214 case SWRAP_ACCEPT_RECV:
1215 if (si->type != SOCK_STREAM) return NULL;
1216
1217 src_addr = si->myname;
1218 dest_addr = addr;
1219
1220 tcp_seqno = si->io.pck_snd;
1221 tcp_ack = si->io.pck_rcv;
1222 tcp_ctl = 0x12; /* SYN,ACK */
1223
1224 si->io.pck_snd += 1;
1225
1226 break;
1227
1228 case SWRAP_ACCEPT_ACK:
1229 if (si->type != SOCK_STREAM) return NULL;
1230
1231 dest_addr = si->myname;
1232 src_addr = addr;
1233
1234 tcp_seqno = si->io.pck_rcv;
1235 tcp_ack = si->io.pck_snd;
1236 tcp_ctl = 0x10; /* ACK */
1237
1238 break;
1239
1240 case SWRAP_SEND:
1241 src_addr = si->myname;
1242 dest_addr = si->peername;
1243
1244 tcp_seqno = si->io.pck_snd;
1245 tcp_ack = si->io.pck_rcv;
1246 tcp_ctl = 0x18; /* PSH,ACK */
1247
1248 si->io.pck_snd += len;
1249
1250 break;
1251
1252 case SWRAP_SEND_RST:
1253 dest_addr = si->myname;
1254 src_addr = si->peername;
1255
1256 if (si->type == SOCK_DGRAM) {
1257 return swrap_marshall_packet(si, si->peername,
1258 SWRAP_SENDTO_UNREACH,
1259 buf, len, packet_len);
1260 }
1261
1262 tcp_seqno = si->io.pck_rcv;
1263 tcp_ack = si->io.pck_snd;
1264 tcp_ctl = 0x14; /** RST,ACK */
1265
1266 break;
1267
1268 case SWRAP_PENDING_RST:
1269 dest_addr = si->myname;
1270 src_addr = si->peername;
1271
1272 if (si->type == SOCK_DGRAM) {
1273 return NULL;
1274 }
1275
1276 tcp_seqno = si->io.pck_rcv;
1277 tcp_ack = si->io.pck_snd;
1278 tcp_ctl = 0x14; /* RST,ACK */
1279
1280 break;
1281
1282 case SWRAP_RECV:
1283 dest_addr = si->myname;
1284 src_addr = si->peername;
1285
1286 tcp_seqno = si->io.pck_rcv;
1287 tcp_ack = si->io.pck_snd;
1288 tcp_ctl = 0x18; /* PSH,ACK */
1289
1290 si->io.pck_rcv += len;
1291
1292 break;
1293
1294 case SWRAP_RECV_RST:
1295 dest_addr = si->myname;
1296 src_addr = si->peername;
1297
1298 if (si->type == SOCK_DGRAM) {
1299 return NULL;
1300 }
1301
1302 tcp_seqno = si->io.pck_rcv;
1303 tcp_ack = si->io.pck_snd;
1304 tcp_ctl = 0x14; /* RST,ACK */
1305
1306 break;
1307
1308 case SWRAP_SENDTO:
1309 src_addr = si->myname;
1310 dest_addr = addr;
1311
1312 si->io.pck_snd += len;
1313
1314 break;
1315
1316 case SWRAP_SENDTO_UNREACH:
1317 dest_addr = si->myname;
1318 src_addr = addr;
1319
1320 unreachable = 1;
1321
1322 break;
1323
1324 case SWRAP_RECVFROM:
1325 dest_addr = si->myname;
1326 src_addr = addr;
1327
1328 si->io.pck_rcv += len;
1329
1330 break;
1331
1332 case SWRAP_CLOSE_SEND:
1333 if (si->type != SOCK_STREAM) return NULL;
1334
1335 src_addr = si->myname;
1336 dest_addr = si->peername;
1337
1338 tcp_seqno = si->io.pck_snd;
1339 tcp_ack = si->io.pck_rcv;
1340 tcp_ctl = 0x11; /* FIN, ACK */
1341
1342 si->io.pck_snd += 1;
1343
1344 break;
1345
1346 case SWRAP_CLOSE_RECV:
1347 if (si->type != SOCK_STREAM) return NULL;
1348
1349 dest_addr = si->myname;
1350 src_addr = si->peername;
1351
1352 tcp_seqno = si->io.pck_rcv;
1353 tcp_ack = si->io.pck_snd;
1354 tcp_ctl = 0x11; /* FIN,ACK */
1355
1356 si->io.pck_rcv += 1;
1357
1358 break;
1359
1360 case SWRAP_CLOSE_ACK:
1361 if (si->type != SOCK_STREAM) return NULL;
1362
1363 src_addr = si->myname;
1364 dest_addr = si->peername;
1365
1366 tcp_seqno = si->io.pck_snd;
1367 tcp_ack = si->io.pck_rcv;
1368 tcp_ctl = 0x10; /* ACK */
1369
1370 break;
1371 default:
1372 return NULL;
1373 }
1374
1375 swrapGetTimeOfDay(&tv);
1376
1377 return swrap_packet_init(&tv, src_addr, dest_addr, si->type,
1378 (const uint8_t *)buf, len,
1379 tcp_seqno, tcp_ack, tcp_ctl, unreachable,
1380 packet_len);
1381 }
1382
1383 static void swrap_dump_packet(struct socket_info *si,
1384 const struct sockaddr *addr,
1385 enum swrap_packet_type type,
1386 const void *buf, size_t len)
1387 {
1388 const char *file_name;
1389 uint8_t *packet;
1390 size_t packet_len = 0;
1391 int fd;
1392
1393 file_name = socket_wrapper_pcap_file();
1394 if (!file_name) {
1395 return;
1396 }
1397
1398 packet = swrap_marshall_packet(si, addr, type, buf, len, &packet_len);
1399 if (!packet) {
1400 return;
1401 }
1402
1403 fd = swrap_get_pcap_fd(file_name);
1404 if (fd != -1) {
1405 if (write(fd, packet, packet_len) != packet_len) {
1406 free(packet);
1407 return;
1408 }
1409 }
1410
1411 free(packet);
1412 }
1413
1414 _PUBLIC_ int swrap_socket(int family, int type, int protocol)
1415 {
1416 struct socket_info *si;
1417 struct socket_info_fd *fi;
1418 int fd;
1419 int real_type = type;
1420 #ifdef SOCK_CLOEXEC
1421 real_type &= ~SOCK_CLOEXEC;
1422 #endif
1423 #ifdef SOCK_NONBLOCK
1424 real_type &= ~SOCK_NONBLOCK;
1425 #endif
1426
1427 if (!socket_wrapper_dir()) {
1428 return real_socket(family, type, protocol);
1429 }
1430
1431 switch (family) {
1432 case AF_INET:
1433 #ifdef HAVE_IPV6
1434 case AF_INET6:
1435 #endif
1436 break;
1437 case AF_UNIX:
1438 return real_socket(family, type, protocol);
1439 default:
1440 errno = EAFNOSUPPORT;
1441 return -1;
1442 }
1443
1444 switch (real_type) {
1445 case SOCK_STREAM:
1446 break;
1447 case SOCK_DGRAM:
1448 break;
1449 default:
1450 errno = EPROTONOSUPPORT;
1451 return -1;
1452 }
1453
1454 switch (protocol) {
1455 case 0:
1456 break;
1457 case 6:
1458 if (real_type == SOCK_STREAM) {
1459 break;
1460 }
1461 /*fall through*/
1462 case 17:
1463 if (real_type == SOCK_DGRAM) {
1464 break;
1465 }
1466 /*fall through*/
1467 default:
1468 errno = EPROTONOSUPPORT;
1469 return -1;
1470 }
1471
1472 /* We must call real_socket with type, from the caller, not the version we removed
1473 SOCK_CLOEXEC and SOCK_NONBLOCK from */
1474 fd = real_socket(AF_UNIX, type, 0);
1475
1476 if (fd == -1) return -1;
1477
1478 si = (struct socket_info *)calloc(1, sizeof(struct socket_info));
1479 if (si == NULL) {
1480 errno = ENOMEM;
1481 return -1;
1482 }
1483
1484 si->family = family;
1485
1486 /* however, the rest of the socket_wrapper code expects just
1487 * the type, not the flags */
1488 si->type = real_type;
1489 si->protocol = protocol;
1490
1491 fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd));
1492 if (fi == NULL) {
1493 free(si);
1494 errno = ENOMEM;
1495 return -1;
1496 }
1497
1498 fi->fd = fd;
1499
1500 SWRAP_DLIST_ADD(si->fds, fi);
1501 SWRAP_DLIST_ADD(sockets, si);
1502
1503 return fd;
1504 }
1505
1506 _PUBLIC_ int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
1507 {
1508 struct socket_info *parent_si, *child_si;
1509 struct socket_info_fd *child_fi;
1510 int fd;
1511 struct sockaddr_un un_addr;
1512 socklen_t un_addrlen = sizeof(un_addr);
1513 struct sockaddr_un un_my_addr;
1514 socklen_t un_my_addrlen = sizeof(un_my_addr);
1515 struct sockaddr *my_addr;
1516 socklen_t my_addrlen, len;
1517 int ret;
1518
1519 parent_si = find_socket_info(s);
1520 if (!parent_si) {
1521 return real_accept(s, addr, addrlen);
1522 }
1523
1524 /*
1525 * assume out sockaddr have the same size as the in parent
1526 * socket family
1527 */
1528 my_addrlen = socket_length(parent_si->family);
1529 if (my_addrlen <= 0) {
1530 errno = EINVAL;
1531 return -1;
1532 }
1533
1534 my_addr = (struct sockaddr *)malloc(my_addrlen);
1535 if (my_addr == NULL) {
1536 return -1;
1537 }
1538
1539 memset(&un_addr, 0, sizeof(un_addr));
1540 memset(&un_my_addr, 0, sizeof(un_my_addr));
1541
1542 ret = real_accept(s, (struct sockaddr *)(void *)&un_addr, &un_addrlen);
1543 if (ret == -1) {
1544 free(my_addr);
1545 return ret;
1546 }
1547
1548 fd = ret;
1549
1550 len = my_addrlen;
1551 ret = sockaddr_convert_from_un(parent_si, &un_addr, un_addrlen,
1552 parent_si->family, my_addr, &len);
1553 if (ret == -1) {
1554 free(my_addr);
1555 close(fd);
1556 return ret;
1557 }
1558
1559 child_si = (struct socket_info *)malloc(sizeof(struct socket_info));
1560 memset(child_si, 0, sizeof(*child_si));
1561
1562 child_fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd));
1563 if (child_fi == NULL) {
1564 free(child_si);
1565 free(my_addr);
1566 close(fd);
1567 errno = ENOMEM;
1568 return -1;
1569 }
1570
1571 child_fi->fd = fd;
1572
1573 SWRAP_DLIST_ADD(child_si->fds, child_fi);
1574
1575 child_si->family = parent_si->family;
1576 child_si->type = parent_si->type;
1577 child_si->protocol = parent_si->protocol;
1578 child_si->bound = 1;
1579 child_si->is_server = 1;
1580 child_si->connected = 1;
1581
1582 child_si->peername_len = len;
1583 child_si->peername = sockaddr_dup(my_addr, len);
1584
1585 if (addr != NULL && addrlen != NULL) {
1586 size_t copy_len = MIN(*addrlen, len);
1587 if (copy_len > 0) {
1588 memcpy(addr, my_addr, copy_len);
1589 }
1590 *addrlen = len;
1591 }
1592
1593 ret = real_getsockname(fd, (struct sockaddr *)(void *)&un_my_addr,
1594 &un_my_addrlen);
1595 if (ret == -1) {
1596 free(child_fi);
1597 free(child_si);
1598 close(fd);
1599 return ret;
1600 }
1601
1602 len = my_addrlen;
1603 ret = sockaddr_convert_from_un(child_si, &un_my_addr, un_my_addrlen,
1604 child_si->family, my_addr, &len);
1605 if (ret == -1) {
1606 free(child_fi);
1607 free(child_si);
1608 free(my_addr);
1609 close(fd);
1610 return ret;
1611 }
1612
1613 child_si->myname_len = len;
1614 child_si->myname = sockaddr_dup(my_addr, len);
1615 free(my_addr);
1616
1617 SWRAP_DLIST_ADD(sockets, child_si);
1618
1619 swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_SEND, NULL, 0);
1620 swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_RECV, NULL, 0);
1621 swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_ACK, NULL, 0);
1622
1623 return fd;
1624 }
1625
1626 static int autobind_start_init;
1627 static int autobind_start;
1628
1629 /* using sendto() or connect() on an unbound socket would give the
1630 recipient no way to reply, as unlike UDP and TCP, a unix domain
1631 socket can't auto-assign emphemeral port numbers, so we need to
1632 assign it here.
1633 Note: this might change the family from ipv6 to ipv4
1634 */
1635 static int swrap_auto_bind(int fd, struct socket_info *si, int family)
1636 {
1637 struct sockaddr_un un_addr;
1638 int i;
1639 char type;
1640 int ret;
1641 int port;
1642 struct stat st;
1643
1644 if (autobind_start_init != 1) {
1645 autobind_start_init = 1;
1646 autobind_start = getpid();
1647 autobind_start %= 50000;
1648 autobind_start += 10000;
1649 }
1650
1651 un_addr.sun_family = AF_UNIX;
1652
1653 switch (family) {
1654 case AF_INET: {
1655 struct sockaddr_in in;
1656
1657 switch (si->type) {
1658 case SOCK_STREAM:
1659 type = SOCKET_TYPE_CHAR_TCP;
1660 break;
1661 case SOCK_DGRAM:
1662 type = SOCKET_TYPE_CHAR_UDP;
1663 break;
1664 default:
1665 errno = ESOCKTNOSUPPORT;
1666 return -1;
1667 }
1668
1669 memset(&in, 0, sizeof(in));
1670 in.sin_family = AF_INET;
1671 in.sin_addr.s_addr = htonl(127<<24 |
1672 socket_wrapper_default_iface());
1673
1674 si->myname_len = sizeof(in);
1675 si->myname = sockaddr_dup(&in, si->myname_len);
1676 break;
1677 }
1678 #ifdef HAVE_IPV6
1679 case AF_INET6: {
1680 struct sockaddr_in6 in6;
1681
1682 if (si->family != family) {
1683 errno = ENETUNREACH;
1684 return -1;
1685 }
1686
1687 switch (si->type) {
1688 case SOCK_STREAM:
1689 type = SOCKET_TYPE_CHAR_TCP_V6;
1690 break;
1691 case SOCK_DGRAM:
1692 type = SOCKET_TYPE_CHAR_UDP_V6;
1693 break;
1694 default:
1695 errno = ESOCKTNOSUPPORT;
1696 return -1;
1697 }
1698
1699 memset(&in6, 0, sizeof(in6));
1700 in6.sin6_family = AF_INET6;
1701 in6.sin6_addr = *swrap_ipv6();
1702 in6.sin6_addr.s6_addr[15] = socket_wrapper_default_iface();
1703 si->myname_len = sizeof(in6);
1704 si->myname = sockaddr_dup(&in6, si->myname_len);
1705 break;
1706 }
1707 #endif
1708 default:
1709 errno = ESOCKTNOSUPPORT;
1710 return -1;
1711 }
1712
1713 if (autobind_start > 60000) {
1714 autobind_start = 10000;
1715 }
1716
1717 for (i=0;i<1000;i++) {
1718 port = autobind_start + i;
1719 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path),
1720 "%s/"SOCKET_FORMAT, socket_wrapper_dir(),
1721 type, socket_wrapper_default_iface(), port);
1722 if (stat(un_addr.sun_path, &st) == 0) continue;
1723
1724 ret = real_bind(fd, (struct sockaddr *)(void *)&un_addr,
1725 sizeof(un_addr));
1726 if (ret == -1) return ret;
1727
1728 si->tmp_path = strdup(un_addr.sun_path);
1729 si->bound = 1;
1730 autobind_start = port + 1;
1731 break;
1732 }
1733 if (i == 1000) {
1734 errno = ENFILE;
1735 return -1;
1736 }
1737
1738 si->family = family;
1739 set_port(si->family, port, si->myname);
1740
1741 return 0;
1742 }
1743
1744
1745 _PUBLIC_ int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
1746 {
1747 int ret;
1748 struct sockaddr_un un_addr;
1749 struct socket_info *si = find_socket_info(s);
1750 int bcast = 0;
1751
1752 if (!si) {
1753 return real_connect(s, serv_addr, addrlen);
1754 }
1755
1756 if (si->bound == 0) {
1757 ret = swrap_auto_bind(s, si, serv_addr->sa_family);
1758 if (ret == -1) return -1;
1759 }
1760
1761 if (si->family != serv_addr->sa_family) {
1762 errno = EINVAL;
1763 return -1;
1764 }
1765
1766 ret = sockaddr_convert_to_un(si, serv_addr,
1767 addrlen, &un_addr, 0, &bcast);
1768 if (ret == -1) return -1;
1769
1770 if (bcast) {
1771 errno = ENETUNREACH;
1772 return -1;
1773 }
1774
1775 if (si->type == SOCK_DGRAM) {
1776 si->defer_connect = 1;
1777 ret = 0;
1778 } else {
1779 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_SEND, NULL, 0);
1780
1781 ret = real_connect(s, (struct sockaddr *)(void *)&un_addr,
1782 sizeof(struct sockaddr_un));
1783 }
1784
1785 /* to give better errors */
1786 if (ret == -1 && errno == ENOENT) {
1787 errno = EHOSTUNREACH;
1788 }
1789
1790 if (ret == 0) {
1791 si->peername_len = addrlen;
1792 si->peername = sockaddr_dup(serv_addr, addrlen);
1793 si->connected = 1;
1794
1795 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_RECV, NULL, 0);
1796 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_ACK, NULL, 0);
1797 } else {
1798 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_UNREACH, NULL, 0);
1799 }
1800
1801 return ret;
1802 }
1803
1804 _PUBLIC_ int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
1805 {
1806 int ret;
1807 struct sockaddr_un un_addr;
1808 struct socket_info *si = find_socket_info(s);
1809
1810 if (!si) {
1811 return real_bind(s, myaddr, addrlen);
1812 }
1813
1814 si->myname_len = addrlen;
1815 si->myname = sockaddr_dup(myaddr, addrlen);
1816
1817 ret = sockaddr_convert_to_un(si, myaddr, addrlen, &un_addr, 1, &si->bcast);
1818 if (ret == -1) return -1;
1819
1820 unlink(un_addr.sun_path);
1821
1822 ret = real_bind(s, (struct sockaddr *)(void *)&un_addr,
1823 sizeof(struct sockaddr_un));
1824
1825 if (ret == 0) {
1826 si->bound = 1;
1827 }
1828
1829 return ret;
1830 }
1831
1832 _PUBLIC_ int swrap_listen(int s, int backlog)
1833 {
1834 int ret;
1835 struct socket_info *si = find_socket_info(s);
1836
1837 if (!si) {
1838 return real_listen(s, backlog);
1839 }
1840
1841 ret = real_listen(s, backlog);
1842
1843 return ret;
1844 }
1845
1846 _PUBLIC_ int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
1847 {
1848 struct socket_info *si = find_socket_info(s);
1849
1850 if (!si) {
1851 return real_getpeername(s, name, addrlen);
1852 }
1853
1854 if (!si->peername)
1855 {
1856 errno = ENOTCONN;
1857 return -1;
1858 }
1859
1860 memcpy(name, si->peername, si->peername_len);
1861 *addrlen = si->peername_len;
1862
1863 return 0;
1864 }
1865
1866 _PUBLIC_ int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
1867 {
1868 struct socket_info *si = find_socket_info(s);
1869
1870 if (!si) {
1871 return real_getsockname(s, name, addrlen);
1872 }
1873
1874 memcpy(name, si->myname, si->myname_len);
1875 *addrlen = si->myname_len;
1876
1877 return 0;
1878 }
1879
1880 _PUBLIC_ int swrap_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
1881 {
1882 struct socket_info *si = find_socket_info(s);
1883
1884 if (!si) {
1885 return real_getsockopt(s, level, optname, optval, optlen);
1886 }
1887
1888 if (level == SOL_SOCKET) {
1889 return real_getsockopt(s, level, optname, optval, optlen);
1890 }
1891
1892 errno = ENOPROTOOPT;
1893 return -1;
1894 }
1895
1896 _PUBLIC_ int swrap_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen)
1897 {
1898 struct socket_info *si = find_socket_info(s);
1899
1900 if (!si) {
1901 return real_setsockopt(s, level, optname, optval, optlen);
1902 }
1903
1904 if (level == SOL_SOCKET) {
1905 return real_setsockopt(s, level, optname, optval, optlen);
1906 }
1907
1908 switch (si->family) {
1909 case AF_INET:
1910 return 0;
1911 #ifdef HAVE_IPV6
1912 case AF_INET6:
1913 return 0;
1914 #endif
1915 default:
1916 errno = ENOPROTOOPT;
1917 return -1;
1918 }
1919 }
1920
1921 _PUBLIC_ int swrap_ioctl(int s, int r, void *p)
1922 {
1923 int ret;
1924 struct socket_info *si = find_socket_info(s);
1925 int value;
1926
1927 if (!si) {
1928 return real_ioctl(s, r, p);
1929 }
1930
1931 ret = real_ioctl(s, r, p);
1932
1933 switch (r) {
1934 case FIONREAD:
1935 value = *((int *)p);
1936 if (ret == -1 && errno != EAGAIN && errno != ENOBUFS) {
1937 swrap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
1938 } else if (value == 0) { /* END OF FILE */
1939 swrap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
1940 }
1941 break;
1942 }
1943
1944 return ret;
1945 }
1946
1947 static ssize_t swrap_sendmsg_before(int fd,
1948 struct socket_info *si,
1949 struct msghdr *msg,
1950 struct iovec *tmp_iov,
1951 struct sockaddr_un *tmp_un,
1952 const struct sockaddr_un **to_un,
1953 const struct sockaddr **to,
1954 int *bcast)
1955 {
1956 size_t i, len = 0;
1957 ssize_t ret;
1958
1959 if (to_un) {
1960 *to_un = NULL;
1961 }
1962 if (to) {
1963 *to = NULL;
1964 }
1965 if (bcast) {
1966 *bcast = 0;
1967 }
1968
1969 switch (si->type) {
1970 case SOCK_STREAM:
1971 if (!si->connected) {
1972 errno = ENOTCONN;
1973 return -1;
1974 }
1975
1976 if (msg->msg_iovlen == 0) {
1977 break;
1978 }
1979
1980 /*
1981 * cut down to 1500 byte packets for stream sockets,
1982 * which makes it easier to format PCAP capture files
1983 * (as the caller will simply continue from here)
1984 */
1985
1986 for (i=0; i < msg->msg_iovlen; i++) {
1987 size_t nlen;
1988 nlen = len + msg->msg_iov[i].iov_len;
1989 if (nlen > 1500) {
1990 break;
1991 }
1992 }
1993 msg->msg_iovlen = i;
1994 if (msg->msg_iovlen == 0) {
1995 *tmp_iov = msg->msg_iov[0];
1996 tmp_iov->iov_len = MIN(tmp_iov->iov_len, 1500);
1997 msg->msg_iov = tmp_iov;
1998 msg->msg_iovlen = 1;
1999 }
2000 break;
2001
2002 case SOCK_DGRAM:
2003 if (si->connected) {
2004 if (msg->msg_name) {
2005 errno = EISCONN;
2006 return -1;
2007 }
2008 } else {
2009 const struct sockaddr *msg_name;
2010 msg_name = (const struct sockaddr *)msg->msg_name;
2011
2012 if (msg_name == NULL) {
2013 errno = ENOTCONN;
2014 return -1;
2015 }
2016
2017
2018 ret = sockaddr_convert_to_un(si, msg_name, msg->msg_namelen,
2019 tmp_un, 0, bcast);
2020 if (ret == -1) return -1;
2021
2022 if (to_un) {
2023 *to_un = tmp_un;
2024 }
2025 if (to) {
2026 *to = msg_name;
2027 }
2028 msg->msg_name = tmp_un;
2029 msg->msg_namelen = sizeof(*tmp_un);
2030 }
2031
2032 if (si->bound == 0) {
2033 ret = swrap_auto_bind(fd, si, si->family);
2034 if (ret == -1) return -1;
2035 }
2036
2037 if (!si->defer_connect) {
2038 break;
2039 }
2040
2041 ret = sockaddr_convert_to_un(si, si->peername, si->peername_len,
2042 tmp_un, 0, NULL);
2043 if (ret == -1) return -1;
2044
2045 ret = real_connect(fd, (struct sockaddr *)(void *)tmp_un,
2046 sizeof(*tmp_un));
2047
2048 /* to give better errors */
2049 if (ret == -1 && errno == ENOENT) {
2050 errno = EHOSTUNREACH;
2051 }
2052
2053 if (ret == -1) {
2054 return ret;
2055 }
2056
2057 si->defer_connect = 0;
2058 break;
2059 default:
2060 errno = EHOSTUNREACH;
2061 return -1;
2062 }
2063
2064 return 0;
2065 }
2066
2067 static void swrap_sendmsg_after(struct socket_info *si,
2068 struct msghdr *msg,
2069 const struct sockaddr *to,
2070 ssize_t ret)
2071 {
2072 int saved_errno = errno;
2073 size_t i, len = 0;
2074 uint8_t *buf;
2075 off_t ofs = 0;
2076 size_t avail = 0;
2077 size_t remain;
2078
2079 /* to give better errors */
2080 if (ret == -1 && saved_errno == ENOENT) {
2081 saved_errno = EHOSTUNREACH;
2082 }
2083
2084 for (i=0; i < msg->msg_iovlen; i++) {
2085 avail += msg->msg_iov[i].iov_len;
2086 }
2087
2088 if (ret == -1) {
2089 remain = MIN(80, avail);
2090 } else {
2091 remain = ret;
2092 }
2093
2094 /* we capture it as one single packet */
2095 buf = (uint8_t *)malloc(remain);
2096 if (!buf) {
2097 /* we just not capture the packet */
2098 errno = saved_errno;
2099 return;
2100 }
2101
2102 for (i=0; i < msg->msg_iovlen; i++) {
2103 size_t this_time = MIN(remain, msg->msg_iov[i].iov_len);
2104 memcpy(buf + ofs,
2105 msg->msg_iov[i].iov_base,
2106 this_time);
2107 ofs += this_time;
2108 remain -= this_time;
2109 }
2110 len = ofs;
2111
2112 switch (si->type) {
2113 case SOCK_STREAM:
2114 if (ret == -1) {
2115 swrap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
2116 swrap_dump_packet(si, NULL, SWRAP_SEND_RST, NULL, 0);
2117 } else {
2118 swrap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
2119 }
2120 break;
2121
2122 case SOCK_DGRAM:
2123 if (si->connected) {
2124 to = si->peername;
2125 }
2126 if (ret == -1) {
2127 swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
2128 swrap_dump_packet(si, to, SWRAP_SENDTO_UNREACH, buf, len);
2129 } else {
2130 swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
2131 }
2132 break;
2133 }
2134
2135 free(buf);
2136 errno = saved_errno;
2137 }
2138
2139 _PUBLIC_ ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
2140 {
2141 struct sockaddr_un un_addr;
2142 socklen_t un_addrlen = sizeof(un_addr);
2143 int ret;
2144 struct socket_info *si = find_socket_info(s);
2145 struct sockaddr_storage ss;
2146 socklen_t ss_len = sizeof(ss);
2147
2148 if (!si) {
2149 return real_recvfrom(s, buf, len, flags, from, fromlen);
2150 }
2151
2152 if (!from) {
2153 from = (struct sockaddr *)(void *)&ss;
2154 fromlen = &ss_len;
2155 }
2156
2157 if (si->type == SOCK_STREAM) {
2158 /* cut down to 1500 byte packets for stream sockets,
2159 * which makes it easier to format PCAP capture files
2160 * (as the caller will simply continue from here) */
2161 len = MIN(len, 1500);
2162 }
2163
2164 /* irix 6.4 forgets to null terminate the sun_path string :-( */
2165 memset(&un_addr, 0, sizeof(un_addr));
2166 ret = real_recvfrom(s, buf, len, flags,
2167 (struct sockaddr *)(void *)&un_addr, &un_addrlen);
2168 if (ret == -1)
2169 return ret;
2170
2171 if (sockaddr_convert_from_un(si, &un_addr, un_addrlen,
2172 si->family, from, fromlen) == -1) {
2173 return -1;
2174 }
2175
2176 swrap_dump_packet(si, from, SWRAP_RECVFROM, buf, ret);
2177
2178 return ret;
2179 }
2180
2181
2182 _PUBLIC_ ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
2183 {
2184 struct msghdr msg;
2185 struct iovec tmp;
2186 struct sockaddr_un un_addr;
2187 const struct sockaddr_un *to_un = NULL;
2188 ssize_t ret;
2189 struct socket_info *si = find_socket_info(s);
2190 int bcast = 0;
2191
2192 if (!si) {
2193 return real_sendto(s, buf, len, flags, to, tolen);
2194 }
2195
2196 tmp.iov_base = discard_const_p(char, buf);
2197 tmp.iov_len = len;
2198
2199 ZERO_STRUCT(msg);
2200 msg.msg_name = discard_const_p(struct sockaddr, to); /* optional address */
2201 msg.msg_namelen = tolen; /* size of address */
2202 msg.msg_iov = &tmp; /* scatter/gather array */
2203 msg.msg_iovlen = 1; /* # elements in msg_iov */
2204 #if 0 /* not available on solaris */
2205 msg.msg_control = NULL; /* ancillary data, see below */
2206 msg.msg_controllen = 0; /* ancillary data buffer len */
2207 msg.msg_flags = 0; /* flags on received message */
2208 #endif
2209
2210 ret = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, &to_un, &to, &bcast);
2211 if (ret == -1) return -1;
2212
2213 buf = msg.msg_iov[0].iov_base;
2214 len = msg.msg_iov[0].iov_len;
2215
2216 if (bcast) {
2217 struct stat st;
2218 unsigned int iface;
2219 unsigned int prt = ntohs(((const struct sockaddr_in *)to)->sin_port);
2220 char type;
2221
2222 type = SOCKET_TYPE_CHAR_UDP;
2223
2224 for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
2225 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/"SOCKET_FORMAT,
2226 socket_wrapper_dir(), type, iface, prt);
2227 if (stat(un_addr.sun_path, &st) != 0) continue;
2228
2229 /* ignore the any errors in broadcast sends */
2230 real_sendto(s, buf, len, flags,
2231 (struct sockaddr *)(void *)&un_addr,
2232 sizeof(un_addr));
2233 }
2234
2235 swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
2236
2237 return len;
2238 }
2239
2240 ret = real_sendto(s, buf, len, flags, (struct sockaddr *)msg.msg_name,
2241 msg.msg_namelen);
2242
2243 swrap_sendmsg_after(si, &msg, to, ret);
2244
2245 return ret;
2246 }
2247
2248 _PUBLIC_ ssize_t swrap_recv(int s, void *buf, size_t len, int flags)
2249 {
2250 int ret;
2251 struct socket_info *si = find_socket_info(s);
2252
2253 if (!si) {
2254 return real_recv(s, buf, len, flags);
2255 }
2256
2257 if (si->type == SOCK_STREAM) {
2258 /* cut down to 1500 byte packets for stream sockets,
2259 * which makes it easier to format PCAP capture files
2260 * (as the caller will simply continue from here) */
2261 len = MIN(len, 1500);
2262 }
2263
2264 ret = real_recv(s, buf, len, flags);
2265 if (ret == -1 && errno != EAGAIN && errno != ENOBUFS) {
2266 swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
2267 } else if (ret == 0) { /* END OF FILE */
2268 swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
2269 } else if (ret > 0) {
2270 swrap_dump_packet(si, NULL, SWRAP_RECV, buf, ret);
2271 }
2272
2273 return ret;
2274 }
2275
2276 _PUBLIC_ ssize_t swrap_read(int s, void *buf, size_t len)
2277 {
2278 int ret;
2279 struct socket_info *si = find_socket_info(s);
2280
2281 if (!si) {
2282 return real_read(s, buf, len);
2283 }
2284
2285 if (si->type == SOCK_STREAM) {
2286 /* cut down to 1500 byte packets for stream sockets,
2287 * which makes it easier to format PCAP capture files
2288 * (as the caller will simply continue from here) */
2289 len = MIN(len, 1500);
2290 }
2291
2292 ret = real_read(s, buf, len);
2293 if (ret == -1 && errno != EAGAIN && errno != ENOBUFS) {
2294 swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
2295 } else if (ret == 0) { /* END OF FILE */
2296 swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
2297 } else if (ret > 0) {
2298 swrap_dump_packet(si, NULL, SWRAP_RECV, buf, ret);
2299 }
2300
2301 return ret;
2302 }
2303
2304
2305 _PUBLIC_ ssize_t swrap_send(int s, const void *buf, size_t len, int flags)
2306 {
2307 struct msghdr msg;
2308 struct iovec tmp;
2309 struct sockaddr_un un_addr;
2310 ssize_t ret;
2311 struct socket_info *si = find_socket_info(s);
2312
2313 if (!si) {
2314 return real_send(s, buf, len, flags);
2315 }
2316
2317 tmp.iov_base = discard_const_p(char, buf);
2318 tmp.iov_len = len;
2319
2320 ZERO_STRUCT(msg);
2321 msg.msg_name = NULL; /* optional address */
2322 msg.msg_namelen = 0; /* size of address */
2323 msg.msg_iov = &tmp; /* scatter/gather array */
2324 msg.msg_iovlen = 1; /* # elements in msg_iov */
2325 #if 0 /* not available on solaris */
2326 msg.msg_control = NULL; /* ancillary data, see below */
2327 msg.msg_controllen = 0; /* ancillary data buffer len */
2328 msg.msg_flags = 0; /* flags on received message */
2329 #endif
2330
2331 ret = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
2332 if (ret == -1) return -1;
2333
2334 buf = msg.msg_iov[0].iov_base;
2335 len = msg.msg_iov[0].iov_len;
2336
2337 ret = real_send(s, buf, len, flags);
2338
2339 swrap_sendmsg_after(si, &msg, NULL, ret);
2340
2341 return ret;
2342 }
2343
2344 _PUBLIC_ ssize_t swrap_sendmsg(int s, const struct msghdr *omsg, int flags)
2345 {
2346 struct msghdr msg;
2347 struct iovec tmp;
2348 struct sockaddr_un un_addr;
2349 const struct sockaddr_un *to_un = NULL;
2350 const struct sockaddr *to = NULL;
2351 ssize_t ret;
2352 struct socket_info *si = find_socket_info(s);
2353 int bcast = 0;
2354
2355 if (!si) {
2356 return real_sendmsg(s, omsg, flags);
2357 }
2358
2359 tmp.iov_base = NULL;
2360 tmp.iov_len = 0;
2361
2362 msg = *omsg;
2363 #if 0
2364 msg.msg_name = omsg->msg_name; /* optional address */
2365 msg.msg_namelen = omsg->msg_namelen; /* size of address */
2366 msg.msg_iov = omsg->msg_iov; /* scatter/gather array */
2367 msg.msg_iovlen = omsg->msg_iovlen; /* # elements in msg_iov */
2368 /* the following is not available on solaris */
2369 msg.msg_control = omsg->msg_control; /* ancillary data, see below */
2370 msg.msg_controllen = omsg->msg_controllen; /* ancillary data buffer len */
2371 msg.msg_flags = omsg->msg_flags; /* flags on received message */
2372 #endif
2373
2374 ret = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, &to_un, &to, &bcast);
2375 if (ret == -1) return -1;
2376
2377 if (bcast) {
2378 struct stat st;
2379 unsigned int iface;
2380 unsigned int prt = ntohs(((const struct sockaddr_in *)to)->sin_port);
2381 char type;
2382 size_t i, len = 0;
2383 uint8_t *buf;
2384 off_t ofs = 0;
2385 size_t avail = 0;
2386 size_t remain;
2387
2388 for (i=0; i < msg.msg_iovlen; i++) {
2389 avail += msg.msg_iov[i].iov_len;
2390 }
2391
2392 len = avail;
2393 remain = avail;
2394
2395 /* we capture it as one single packet */
2396 buf = (uint8_t *)malloc(remain);
2397 if (!buf) {
2398 return -1;
2399 }
2400
2401 for (i=0; i < msg.msg_iovlen; i++) {
2402 size_t this_time = MIN(remain, msg.msg_iov[i].iov_len);
2403 memcpy(buf + ofs,
2404 msg.msg_iov[i].iov_base,
2405 this_time);
2406 ofs += this_time;
2407 remain -= this_time;
2408 }
2409
2410 type = SOCKET_TYPE_CHAR_UDP;
2411
2412 for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
2413 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/"SOCKET_FORMAT,
2414 socket_wrapper_dir(), type, iface, prt);
2415 if (stat(un_addr.sun_path, &st) != 0) continue;
2416
2417 msg.msg_name = &un_addr; /* optional address */
2418 msg.msg_namelen = sizeof(un_addr); /* size of address */
2419
2420 /* ignore the any errors in broadcast sends */
2421 real_sendmsg(s, &msg, flags);
2422 }
2423
2424 swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
2425 free(buf);
2426
2427 return len;
2428 }
2429
2430 ret = real_sendmsg(s, &msg, flags);
2431
2432 swrap_sendmsg_after(si, &msg, to, ret);
2433
2434 return ret;
2435 }
2436
2437 int swrap_readv(int s, const struct iovec *vector, size_t count)
2438 {
2439 int ret;
2440 struct socket_info *si = find_socket_info(s);
2441 struct iovec v;
2442
2443 if (!si) {
2444 return real_readv(s, vector, count);
2445 }
2446
2447 if (!si->connected) {
2448 errno = ENOTCONN;
2449 return -1;
2450 }
2451
2452 if (si->type == SOCK_STREAM && count > 0) {
2453 /* cut down to 1500 byte packets for stream sockets,
2454 * which makes it easier to format PCAP capture files
2455 * (as the caller will simply continue from here) */
2456 size_t i, len = 0;
2457
2458 for (i=0; i < count; i++) {
2459 size_t nlen;
2460 nlen = len + vector[i].iov_len;
2461 if (nlen > 1500) {
2462 break;
2463 }
2464 }
2465 count = i;
2466 if (count == 0) {
2467 v = vector[0];
2468 v.iov_len = MIN(v.iov_len, 1500);
2469 vector = &v;
2470 count = 1;
2471 }
2472 }
2473
2474 ret = real_readv(s, vector, count);
2475 if (ret == -1 && errno != EAGAIN && errno != ENOBUFS) {
2476 swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
2477 } else if (ret == 0) { /* END OF FILE */
2478 swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
2479 } else if (ret > 0) {
2480 uint8_t *buf;
2481 off_t ofs = 0;
2482 size_t i;
2483 size_t remain = ret;
2484
2485 /* we capture it as one single packet */
2486 buf = (uint8_t *)malloc(ret);
2487 if (!buf) {
2488 /* we just not capture the packet */
2489 errno = 0;
2490 return ret;
2491 }
2492
2493 for (i=0; i < count; i++) {
2494 size_t this_time = MIN(remain, vector[i].iov_len);
2495 memcpy(buf + ofs,
2496 vector[i].iov_base,
2497 this_time);
2498 ofs += this_time;
2499 remain -= this_time;
2500 }
2501
2502 swrap_dump_packet(si, NULL, SWRAP_RECV, buf, ret);
2503 free(buf);
2504 }
2505
2506 return ret;
2507 }
2508
2509 int swrap_writev(int s, const struct iovec *vector, size_t count)
2510 {
2511 struct msghdr msg;
2512 struct iovec tmp;
2513 struct sockaddr_un un_addr;
2514 ssize_t ret;
2515 struct socket_info *si = find_socket_info(s);
2516
2517 if (!si) {
2518 return real_writev(s, vector, count);
2519 }
2520
2521 tmp.iov_base = NULL;
2522 tmp.iov_len = 0;
2523
2524 ZERO_STRUCT(msg);
2525 msg.msg_name = NULL; /* optional address */
2526 msg.msg_namelen = 0; /* size of address */
2527 msg.msg_iov = discard_const_p(struct iovec, vector); /* scatter/gather array */
2528 msg.msg_iovlen = count; /* # elements in msg_iov */
2529 #if 0 /* not available on solaris */
2530 msg.msg_control = NULL; /* ancillary data, see below */
2531 msg.msg_controllen = 0; /* ancillary data buffer len */
2532 msg.msg_flags = 0; /* flags on received message */
2533 #endif
2534
2535 ret = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
2536 if (ret == -1) return -1;
2537
2538 ret = real_writev(s, msg.msg_iov, msg.msg_iovlen);
2539
2540 swrap_sendmsg_after(si, &msg, NULL, ret);
2541
2542 return ret;
2543 }
2544
2545 _PUBLIC_ int swrap_close(int fd)
2546 {
2547 struct socket_info *si = find_socket_info(fd);
2548 struct socket_info_fd *fi;
2549 int ret;
2550
2551 if (!si) {
2552 return real_close(fd);
2553 }
2554
2555 for (fi = si->fds; fi; fi = fi->next) {
2556 if (fi->fd == fd) {
2557 SWRAP_DLIST_REMOVE(si->fds, fi);
2558 free(fi);
2559 break;
2560 }
2561 }
2562
2563 if (si->fds) {
2564 /* there are still references left */
2565 return real_close(fd);
2566 }
2567
2568 SWRAP_DLIST_REMOVE(sockets, si);
2569
2570 if (si->myname && si->peername) {
2571 swrap_dump_packet(si, NULL, SWRAP_CLOSE_SEND, NULL, 0);
2572 }
2573
2574 ret = real_close(fd);
2575
2576 if (si->myname && si->peername) {
2577 swrap_dump_packet(si, NULL, SWRAP_CLOSE_RECV, NULL, 0);
2578 swrap_dump_packet(si, NULL, SWRAP_CLOSE_ACK, NULL, 0);
2579 }
2580
2581 if (si->myname) free(si->myname);
2582 if (si->peername) free(si->peername);
2583 if (si->tmp_path) {
2584 unlink(si->tmp_path);
2585 free(si->tmp_path);
2586 }
2587 free(si);
2588
2589 return ret;
2590 }
2591
2592 _PUBLIC_ int swrap_dup(int fd)
2593 {
2594 struct socket_info *si;
2595 struct socket_info_fd *fi;
2596
2597 si = find_socket_info(fd);
2598
2599 if (!si) {
2600 return real_dup(fd);
2601 }
2602
2603 fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd));
2604 if (fi == NULL) {
2605 errno = ENOMEM;
2606 return -1;
2607 }
2608
2609 fi->fd = real_dup(fd);
2610 if (fi->fd == -1) {
2611 int saved_errno = errno;
2612 free(fi);
2613 errno = saved_errno;
2614 return -1;
2615 }
2616
2617 SWRAP_DLIST_ADD(si->fds, fi);
2618 return fi->fd;
2619 }
2620
2621 _PUBLIC_ int swrap_dup2(int fd, int newfd)
2622 {
2623 struct socket_info *si;
2624 struct socket_info_fd *fi;
2625
2626 si = find_socket_info(fd);
2627
2628 if (!si) {
2629 return real_dup2(fd, newfd);
2630 }
2631
2632 if (find_socket_info(newfd)) {
2633 /* dup2() does an implicit close of newfd, which we
2634 * need to emulate */
2635 swrap_close(newfd);
2636 }
2637
2638 fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd));
2639 if (fi == NULL) {
2640 errno = ENOMEM;
2641 return -1;
2642 }
2643
2644 fi->fd = real_dup2(fd, newfd);
2645 if (fi->fd == -1) {
2646 int saved_errno = errno;
2647 free(fi);
2648 errno = saved_errno;
2649 return -1;
2650 }
2651
2652 SWRAP_DLIST_ADD(si->fds, fi);
2653 return fi->fd;
2654 }
reg import