?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x
[heimdal.git] / lib / roken / socket_wrapper.c
blob9e6bfdd09811e34f22d4e282e61c09d53176229b
1 /*
2 * Copyright (C) Jelmer Vernooij 2005 <jelmer@samba.org>
3 * Copyright (C) Stefan Metzmacher 2006 <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 #define SOCKET_WRAPPER_NOT_REPLACE
43
44 #ifdef _SAMBA_BUILD_
45
46 #include "includes.h"
47 #include "system/network.h"
48 #include "system/filesys.h"
49
50 #ifdef malloc
51 #undef malloc
52 #endif
53 #ifdef calloc
54 #undef calloc
55 #endif
56 #ifdef strdup
57 #undef strdup
58 #endif
59
60 #else /* _SAMBA_BUILD_ */
61
62 #ifdef HAVE_CONFIG_H
63 #include <config.h>
64 #endif
65 #undef SOCKET_WRAPPER_REPLACE
66
67 #include <sys/types.h>
68 #ifdef TIME_WITH_SYS_TIME
69 #include <sys/time.h>
70 #include <time.h>
71 #elif defined(HAVE_SYS_TIME_H)
72 #include <sys/time.h>
73 #else
74 #include <time.h>
75 #endif
76 #include <sys/stat.h>
77 #include <sys/socket.h>
78 #include <sys/ioctl.h>
79 #ifdef HAVE_SYS_FILIO_H
80 #include <sys/filio.h>
81 #endif
82 #include <errno.h>
83 #include <sys/un.h>
84 #include <netinet/in.h>
85 #include <netinet/tcp.h>
86 #include <fcntl.h>
87 #include <stdlib.h>
88 #include <unistd.h>
89 #include <string.h>
90 #include <stdio.h>
91 #include "roken.h"
92
93 #include "socket_wrapper.h"
94
95 #define HAVE_GETTIMEOFDAY_TZ 1
96
97 #define _PUBLIC_
98
99 #endif
100
101 #define SWRAP_DLIST_ADD(list,item) do { \
102 if (!(list)) { \
103 (item)->prev = NULL; \
104 (item)->next = NULL; \
105 (list) = (item); \
106 } else { \
107 (item)->prev = NULL; \
108 (item)->next = (list); \
109 (list)->prev = (item); \
110 (list) = (item); \
111 } \
112 } while (0)
113
114 #define SWRAP_DLIST_REMOVE(list,item) do { \
115 if ((list) == (item)) { \
116 (list) = (item)->next; \
117 if (list) { \
118 (list)->prev = NULL; \
119 } \
120 } else { \
121 if ((item)->prev) { \
122 (item)->prev->next = (item)->next; \
123 } \
124 if ((item)->next) { \
125 (item)->next->prev = (item)->prev; \
126 } \
127 } \
128 (item)->prev = NULL; \
129 (item)->next = NULL; \
130 } while (0)
131
132 /* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
133 * for now */
134 #define REWRITE_CALLS
135
136 #ifdef REWRITE_CALLS
137 #define real_accept accept
138 #define real_connect connect
139 #define real_bind bind
140 #define real_listen listen
141 #define real_getpeername getpeername
142 #define real_getsockname getsockname
143 #define real_getsockopt getsockopt
144 #define real_setsockopt setsockopt
145 #define real_recvfrom recvfrom
146 #define real_sendto sendto
147 #define real_ioctl ioctl
148 #define real_recv recv
149 #define real_send send
150 #define real_socket socket
151 #define real_close close
152 #define real_dup dup
153 #define real_dup2 dup2
154 #endif
155
156 #ifdef HAVE_GETTIMEOFDAY_TZ
157 #define swrapGetTimeOfDay(tval) gettimeofday(tval,NULL)
158 #else
159 #define swrapGetTimeOfDay(tval) gettimeofday(tval)
160 #endif
161
162 /* we need to use a very terse format here as IRIX 6.4 silently
163 truncates names to 16 chars, so if we use a longer name then we
164 can't tell which port a packet came from with recvfrom()
165
166 with this format we have 8 chars left for the directory name
167 */
168 #define SOCKET_FORMAT "%c%02X%04X"
169 #define SOCKET_TYPE_CHAR_TCP 'T'
170 #define SOCKET_TYPE_CHAR_UDP 'U'
171 #define SOCKET_TYPE_CHAR_TCP_V6 'X'
172 #define SOCKET_TYPE_CHAR_UDP_V6 'Y'
173
174 #define MAX_WRAPPED_INTERFACES 16
175
176 #define SW_IPV6_ADDRESS 1
177
178 static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
179 {
180 struct sockaddr *ret = (struct sockaddr *)malloc(len);
181 memcpy(ret, data, len);
182 return ret;
183 }
184
185 static void set_port(int family, int prt, struct sockaddr *addr)
186 {
187 switch (family) {
188 case AF_INET:
189 ((struct sockaddr_in *)addr)->sin_port = htons(prt);
190 break;
191 #ifdef HAVE_IPV6
192 case AF_INET6:
193 ((struct sockaddr_in6 *)addr)->sin6_port = htons(prt);
194 break;
195 #endif
196 }
197 }
198
199 static int socket_length(int family)
200 {
201 switch (family) {
202 case AF_INET:
203 return sizeof(struct sockaddr_in);
204 #ifdef HAVE_IPV6
205 case AF_INET6:
206 return sizeof(struct sockaddr_in6);
207 #endif
208 }
209 return -1;
210 }
211
212
213
214 struct socket_info
215 {
216 int fd;
217
218 int family;
219 int type;
220 int protocol;
221 int bound;
222 int bcast;
223 int is_server;
224
225 char *path;
226 char *tmp_path;
227
228 struct sockaddr *myname;
229 socklen_t myname_len;
230
231 struct sockaddr *peername;
232 socklen_t peername_len;
233
234 struct {
235 unsigned long pck_snd;
236 unsigned long pck_rcv;
237 } io;
238
239 struct socket_info *prev, *next;
240 };
241
242 static struct socket_info *sockets;
243
244
245 static const char *socket_wrapper_dir(void)
246 {
247 const char *s = getenv("SOCKET_WRAPPER_DIR");
248 if (s == NULL) {
249 return NULL;
250 }
251 if (strncmp(s, "./", 2) == 0) {
252 s += 2;
253 }
254 return s;
255 }
256
257 static unsigned int socket_wrapper_default_iface(void)
258 {
259 const char *s = getenv("SOCKET_WRAPPER_DEFAULT_IFACE");
260 if (s) {
261 unsigned int iface;
262 if (sscanf(s, "%u", &iface) == 1) {
263 if (iface >= 1 && iface <= MAX_WRAPPED_INTERFACES) {
264 return iface;
265 }
266 }
267 }
268
269 return 1;/* 127.0.0.1 */
270 }
271
272 static int convert_un_in(const struct sockaddr_un *un, struct sockaddr *in, socklen_t *len)
273 {
274 unsigned int iface;
275 unsigned int prt;
276 const char *p;
277 char type;
278
279 p = strrchr(un->sun_path, '/');
280 if (p) p++; else p = un->sun_path;
281
282 if (sscanf(p, SOCKET_FORMAT, &type, &iface, &prt) != 3) {
283 errno = EINVAL;
284 return -1;
285 }
286
287 if (iface == 0 || iface > MAX_WRAPPED_INTERFACES) {
288 errno = EINVAL;
289 return -1;
290 }
291
292 if (prt > 0xFFFF) {
293 errno = EINVAL;
294 return -1;
295 }
296
297 switch(type) {
298 case SOCKET_TYPE_CHAR_TCP:
299 case SOCKET_TYPE_CHAR_UDP: {
300 struct sockaddr_in *in2 = (struct sockaddr_in *)in;
301
302 if ((*len) < sizeof(*in2)) {
303 errno = EINVAL;
304 return -1;
305 }
306
307 memset(in2, 0, sizeof(*in2));
308 in2->sin_family = AF_INET;
309 in2->sin_addr.s_addr = htonl((127<<24) | iface);
310 in2->sin_port = htons(prt);
311
312 *len = sizeof(*in2);
313 break;
314 }
315 #ifdef HAVE_IPV6
316 case SOCKET_TYPE_CHAR_TCP_V6:
317 case SOCKET_TYPE_CHAR_UDP_V6: {
318 struct sockaddr_in6 *in2 = (struct sockaddr_in6 *)in;
319
320 if ((*len) < sizeof(*in2)) {
321 errno = EINVAL;
322 return -1;
323 }
324
325 memset(in2, 0, sizeof(*in2));
326 in2->sin6_family = AF_INET6;
327 in2->sin6_addr.s6_addr[0] = SW_IPV6_ADDRESS;
328 in2->sin6_port = htons(prt);
329
330 *len = sizeof(*in2);
331 break;
332 }
333 #endif
334 default:
335 errno = EINVAL;
336 return -1;
337 }
338
339 return 0;
340 }
341
342 static int convert_in_un_remote(struct socket_info *si, const struct sockaddr *inaddr, struct sockaddr_un *un,
343 int *bcast)
344 {
345 char type = '\0';
346 unsigned int prt;
347 unsigned int iface;
348 int is_bcast = 0;
349
350 if (bcast) *bcast = 0;
351
352 switch (si->family) {
353 case AF_INET: {
354 const struct sockaddr_in *in =
355 (const struct sockaddr_in *)inaddr;
356 unsigned int addr = ntohl(in->sin_addr.s_addr);
357 char u_type = '\0';
358 char b_type = '\0';
359 char a_type = '\0';
360
361 switch (si->type) {
362 case SOCK_STREAM:
363 u_type = SOCKET_TYPE_CHAR_TCP;
364 break;
365 case SOCK_DGRAM:
366 u_type = SOCKET_TYPE_CHAR_UDP;
367 a_type = SOCKET_TYPE_CHAR_UDP;
368 b_type = SOCKET_TYPE_CHAR_UDP;
369 break;
370 }
371
372 prt = ntohs(in->sin_port);
373 if (a_type && addr == 0xFFFFFFFF) {
374 /* 255.255.255.255 only udp */
375 is_bcast = 2;
376 type = a_type;
377 iface = socket_wrapper_default_iface();
378 } else if (b_type && addr == 0x7FFFFFFF) {
379 /* 127.255.255.255 only udp */
380 is_bcast = 1;
381 type = b_type;
382 iface = socket_wrapper_default_iface();
383 } else if ((addr & 0xFFFFFF00) == 0x7F000000) {
384 /* 127.0.0.X */
385 is_bcast = 0;
386 type = u_type;
387 iface = (addr & 0x000000FF);
388 } else {
389 errno = ENETUNREACH;
390 return -1;
391 }
392 if (bcast) *bcast = is_bcast;
393 break;
394 }
395 #ifdef HAVE_IPV6
396 case AF_INET6: {
397 const struct sockaddr_in6 *in =
398 (const struct sockaddr_in6 *)inaddr;
399
400 switch (si->type) {
401 case SOCK_STREAM:
402 type = SOCKET_TYPE_CHAR_TCP_V6;
403 break;
404 case SOCK_DGRAM:
405 type = SOCKET_TYPE_CHAR_UDP_V6;
406 break;
407 }
408
409 /* XXX no multicast/broadcast */
410
411 prt = ntohs(in->sin6_port);
412 iface = SW_IPV6_ADDRESS;
413
414 break;
415 }
416 #endif
417 default:
418 errno = ENETUNREACH;
419 return -1;
420 }
421
422 if (prt == 0) {
423 errno = EINVAL;
424 return -1;
425 }
426
427 if (is_bcast) {
428 snprintf(un->sun_path, sizeof(un->sun_path), "%s/EINVAL",
429 socket_wrapper_dir());
430 /* the caller need to do more processing */
431 return 0;
432 }
433
434 snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
435 socket_wrapper_dir(), type, iface, prt);
436
437 return 0;
438 }
439
440 static int convert_in_un_alloc(struct socket_info *si, const struct sockaddr *inaddr, struct sockaddr_un *un,
441 int *bcast)
442 {
443 char type = '\0';
444 unsigned int prt;
445 unsigned int iface;
446 struct stat st;
447 int is_bcast = 0;
448
449 if (bcast) *bcast = 0;
450
451 switch (si->family) {
452 case AF_INET: {
453 const struct sockaddr_in *in =
454 (const struct sockaddr_in *)inaddr;
455 unsigned int addr = ntohl(in->sin_addr.s_addr);
456 char u_type = '\0';
457 char d_type = '\0';
458 char b_type = '\0';
459 char a_type = '\0';
460
461 prt = ntohs(in->sin_port);
462
463 switch (si->type) {
464 case SOCK_STREAM:
465 u_type = SOCKET_TYPE_CHAR_TCP;
466 d_type = SOCKET_TYPE_CHAR_TCP;
467 break;
468 case SOCK_DGRAM:
469 u_type = SOCKET_TYPE_CHAR_UDP;
470 d_type = SOCKET_TYPE_CHAR_UDP;
471 a_type = SOCKET_TYPE_CHAR_UDP;
472 b_type = SOCKET_TYPE_CHAR_UDP;
473 break;
474 }
475
476 if (addr == 0) {
477 /* 0.0.0.0 */
478 is_bcast = 0;
479 type = d_type;
480 iface = socket_wrapper_default_iface();
481 } else if (a_type && addr == 0xFFFFFFFF) {
482 /* 255.255.255.255 only udp */
483 is_bcast = 2;
484 type = a_type;
485 iface = socket_wrapper_default_iface();
486 } else if (b_type && addr == 0x7FFFFFFF) {
487 /* 127.255.255.255 only udp */
488 is_bcast = 1;
489 type = b_type;
490 iface = socket_wrapper_default_iface();
491 } else if ((addr & 0xFFFFFF00) == 0x7F000000) {
492 /* 127.0.0.X */
493 is_bcast = 0;
494 type = u_type;
495 iface = (addr & 0x000000FF);
496 } else {
497 errno = EADDRNOTAVAIL;
498 return -1;
499 }
500 break;
501 }
502 #ifdef HAVE_IPV6
503 case AF_INET6: {
504 const struct sockaddr_in6 *in =
505 (const struct sockaddr_in6 *)inaddr;
506
507 switch (si->type) {
508 case SOCK_STREAM:
509 type = SOCKET_TYPE_CHAR_TCP_V6;
510 break;
511 case SOCK_DGRAM:
512 type = SOCKET_TYPE_CHAR_UDP_V6;
513 break;
514 }
515
516 /* XXX no multicast/broadcast */
517
518 prt = ntohs(in->sin6_port);
519 iface = SW_IPV6_ADDRESS;
520
521 break;
522 }
523 #endif
524 default:
525 errno = ENETUNREACH;
526 return -1;
527 }
528
529
530 if (bcast) *bcast = is_bcast;
531
532 if (prt == 0) {
533 /* handle auto-allocation of ephemeral ports */
534 for (prt = 5001; prt < 10000; prt++) {
535 snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
536 socket_wrapper_dir(), type, iface, prt);
537 if (stat(un->sun_path, &st) == 0) continue;
538
539 set_port(si->family, prt, si->myname);
540 }
541 }
542
543 snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
544 socket_wrapper_dir(), type, iface, prt);
545 return 0;
546 }
547
548 static struct socket_info *find_socket_info(int fd)
549 {
550 struct socket_info *i;
551 for (i = sockets; i; i = i->next) {
552 if (i->fd == fd)
553 return i;
554 }
555
556 return NULL;
557 }
558
559 static int sockaddr_convert_to_un(struct socket_info *si, const struct sockaddr *in_addr, socklen_t in_len,
560 struct sockaddr_un *out_addr, int alloc_sock, int *bcast)
561 {
562 if (!out_addr)
563 return 0;
564
565 out_addr->sun_family = AF_UNIX;
566
567 switch (in_addr->sa_family) {
568 case AF_INET:
569 #ifdef HAVE_IPV6
570 case AF_INET6:
571 #endif
572 switch (si->type) {
573 case SOCK_STREAM:
574 case SOCK_DGRAM:
575 break;
576 default:
577 errno = ESOCKTNOSUPPORT;
578 return -1;
579 }
580 if (alloc_sock) {
581 return convert_in_un_alloc(si, in_addr, out_addr, bcast);
582 } else {
583 return convert_in_un_remote(si, in_addr, out_addr, bcast);
584 }
585 default:
586 break;
587 }
588
589 errno = EAFNOSUPPORT;
590 return -1;
591 }
592
593 static int sockaddr_convert_from_un(const struct socket_info *si,
594 const struct sockaddr_un *in_addr,
595 socklen_t un_addrlen,
596 int family,
597 struct sockaddr *out_addr,
598 socklen_t *out_addrlen)
599 {
600 if (out_addr == NULL || out_addrlen == NULL)
601 return 0;
602
603 if (un_addrlen == 0) {
604 *out_addrlen = 0;
605 return 0;
606 }
607
608 switch (family) {
609 case AF_INET:
610 #ifdef HAVE_IPV6
611 case AF_INET6:
612 #endif
613 switch (si->type) {
614 case SOCK_STREAM:
615 case SOCK_DGRAM:
616 break;
617 default:
618 errno = ESOCKTNOSUPPORT;
619 return -1;
620 }
621 return convert_un_in(in_addr, out_addr, out_addrlen);
622 default:
623 break;
624 }
625
626 errno = EAFNOSUPPORT;
627 return -1;
628 }
629
630 enum swrap_packet_type {
631 SWRAP_CONNECT_SEND,
632 SWRAP_CONNECT_UNREACH,
633 SWRAP_CONNECT_RECV,
634 SWRAP_CONNECT_ACK,
635 SWRAP_ACCEPT_SEND,
636 SWRAP_ACCEPT_RECV,
637 SWRAP_ACCEPT_ACK,
638 SWRAP_RECVFROM,
639 SWRAP_SENDTO,
640 SWRAP_SENDTO_UNREACH,
641 SWRAP_PENDING_RST,
642 SWRAP_RECV,
643 SWRAP_RECV_RST,
644 SWRAP_SEND,
645 SWRAP_SEND_RST,
646 SWRAP_CLOSE_SEND,
647 SWRAP_CLOSE_RECV,
648 SWRAP_CLOSE_ACK
649 };
650
651 struct swrap_file_hdr {
652 unsigned long magic;
653 unsigned short version_major;
654 unsigned short version_minor;
655 long timezone;
656 unsigned long sigfigs;
657 unsigned long frame_max_len;
658 #define SWRAP_FRAME_LENGTH_MAX 0xFFFF
659 unsigned long link_type;
660 };
661 #define SWRAP_FILE_HDR_SIZE 24
662
663 struct swrap_packet {
664 struct {
665 unsigned long seconds;
666 unsigned long micro_seconds;
667 unsigned long recorded_length;
668 unsigned long full_length;
669 } frame;
670 #define SWRAP_PACKET__FRAME_SIZE 16
671
672 struct {
673 struct {
674 unsigned char ver_hdrlen;
675 unsigned char tos;
676 unsigned short packet_length;
677 unsigned short identification;
678 unsigned char flags;
679 unsigned char fragment;
680 unsigned char ttl;
681 unsigned char protocol;
682 unsigned short hdr_checksum;
683 unsigned long src_addr;
684 unsigned long dest_addr;
685 } hdr;
686 #define SWRAP_PACKET__IP_HDR_SIZE 20
687
688 union {
689 struct {
690 unsigned short source_port;
691 unsigned short dest_port;
692 unsigned long seq_num;
693 unsigned long ack_num;
694 unsigned char hdr_length;
695 unsigned char control;
696 unsigned short window;
697 unsigned short checksum;
698 unsigned short urg;
699 } tcp;
700 #define SWRAP_PACKET__IP_P_TCP_SIZE 20
701 struct {
702 unsigned short source_port;
703 unsigned short dest_port;
704 unsigned short length;
705 unsigned short checksum;
706 } udp;
707 #define SWRAP_PACKET__IP_P_UDP_SIZE 8
708 struct {
709 unsigned char type;
710 unsigned char code;
711 unsigned short checksum;
712 unsigned long unused;
713 } icmp;
714 #define SWRAP_PACKET__IP_P_ICMP_SIZE 8
715 } p;
716 } ip;
717 };
718 #define SWRAP_PACKET_SIZE 56
719
720 static const char *socket_wrapper_pcap_file(void)
721 {
722 static int initialized = 0;
723 static const char *s = NULL;
724 static const struct swrap_file_hdr h;
725 static const struct swrap_packet p;
726
727 if (initialized == 1) {
728 return s;
729 }
730 initialized = 1;
731
732 /*
733 * TODO: don't use the structs use plain buffer offsets
734 * and PUSH_U8(), PUSH_U16() and PUSH_U32()
735 *
736 * for now make sure we disable PCAP support
737 * if the struct has alignment!
738 */
739 if (sizeof(h) != SWRAP_FILE_HDR_SIZE) {
740 return NULL;
741 }
742 if (sizeof(p) != SWRAP_PACKET_SIZE) {
743 return NULL;
744 }
745 if (sizeof(p.frame) != SWRAP_PACKET__FRAME_SIZE) {
746 return NULL;
747 }
748 if (sizeof(p.ip.hdr) != SWRAP_PACKET__IP_HDR_SIZE) {
749 return NULL;
750 }
751 if (sizeof(p.ip.p.tcp) != SWRAP_PACKET__IP_P_TCP_SIZE) {
752 return NULL;
753 }
754 if (sizeof(p.ip.p.udp) != SWRAP_PACKET__IP_P_UDP_SIZE) {
755 return NULL;
756 }
757 if (sizeof(p.ip.p.icmp) != SWRAP_PACKET__IP_P_ICMP_SIZE) {
758 return NULL;
759 }
760
761 s = getenv("SOCKET_WRAPPER_PCAP_FILE");
762 if (s == NULL) {
763 return NULL;
764 }
765 if (strncmp(s, "./", 2) == 0) {
766 s += 2;
767 }
768 return s;
769 }
770
771 static struct swrap_packet *swrap_packet_init(struct timeval *tval,
772 const struct sockaddr_in *src_addr,
773 const struct sockaddr_in *dest_addr,
774 int socket_type,
775 const unsigned char *payload,
776 size_t payload_len,
777 unsigned long tcp_seq,
778 unsigned long tcp_ack,
779 unsigned char tcp_ctl,
780 int unreachable,
781 size_t *_packet_len)
782 {
783 struct swrap_packet *ret;
784 struct swrap_packet *packet;
785 size_t packet_len;
786 size_t alloc_len;
787 size_t nonwire_len = sizeof(packet->frame);
788 size_t wire_hdr_len = 0;
789 size_t wire_len = 0;
790 size_t icmp_hdr_len = 0;
791 size_t icmp_truncate_len = 0;
792 unsigned char protocol = 0, icmp_protocol = 0;
793 unsigned short src_port = src_addr->sin_port;
794 unsigned short dest_port = dest_addr->sin_port;
795
796 switch (socket_type) {
797 case SOCK_STREAM:
798 protocol = 0x06; /* TCP */
799 wire_hdr_len = sizeof(packet->ip.hdr) + sizeof(packet->ip.p.tcp);
800 wire_len = wire_hdr_len + payload_len;
801 break;
802
803 case SOCK_DGRAM:
804 protocol = 0x11; /* UDP */
805 wire_hdr_len = sizeof(packet->ip.hdr) + sizeof(packet->ip.p.udp);
806 wire_len = wire_hdr_len + payload_len;
807 break;
808 }
809
810 if (unreachable) {
811 icmp_protocol = protocol;
812 protocol = 0x01; /* ICMP */
813 if (wire_len > 64 ) {
814 icmp_truncate_len = wire_len - 64;
815 }
816 icmp_hdr_len = sizeof(packet->ip.hdr) + sizeof(packet->ip.p.icmp);
817 wire_hdr_len += icmp_hdr_len;
818 wire_len += icmp_hdr_len;
819 }
820
821 packet_len = nonwire_len + wire_len;
822 alloc_len = packet_len;
823 if (alloc_len < sizeof(struct swrap_packet)) {
824 alloc_len = sizeof(struct swrap_packet);
825 }
826 ret = (struct swrap_packet *)malloc(alloc_len);
827 if (!ret) return NULL;
828
829 packet = ret;
830
831 packet->frame.seconds = tval->tv_sec;
832 packet->frame.micro_seconds = tval->tv_usec;
833 packet->frame.recorded_length = wire_len - icmp_truncate_len;
834 packet->frame.full_length = wire_len - icmp_truncate_len;
835
836 packet->ip.hdr.ver_hdrlen = 0x45; /* version 4 and 5 * 32 bit words */
837 packet->ip.hdr.tos = 0x00;
838 packet->ip.hdr.packet_length = htons(wire_len - icmp_truncate_len);
839 packet->ip.hdr.identification = htons(0xFFFF);
840 packet->ip.hdr.flags = 0x40; /* BIT 1 set - means don't fraqment */
841 packet->ip.hdr.fragment = htons(0x0000);
842 packet->ip.hdr.ttl = 0xFF;
843 packet->ip.hdr.protocol = protocol;
844 packet->ip.hdr.hdr_checksum = htons(0x0000);
845 packet->ip.hdr.src_addr = src_addr->sin_addr.s_addr;
846 packet->ip.hdr.dest_addr = dest_addr->sin_addr.s_addr;
847
848 if (unreachable) {
849 packet->ip.p.icmp.type = 0x03; /* destination unreachable */
850 packet->ip.p.icmp.code = 0x01; /* host unreachable */
851 packet->ip.p.icmp.checksum = htons(0x0000);
852 packet->ip.p.icmp.unused = htonl(0x00000000);
853
854 /* set the ip header in the ICMP payload */
855 packet = (struct swrap_packet *)(((unsigned char *)ret) + icmp_hdr_len);
856 packet->ip.hdr.ver_hdrlen = 0x45; /* version 4 and 5 * 32 bit words */
857 packet->ip.hdr.tos = 0x00;
858 packet->ip.hdr.packet_length = htons(wire_len - icmp_hdr_len);
859 packet->ip.hdr.identification = htons(0xFFFF);
860 packet->ip.hdr.flags = 0x40; /* BIT 1 set - means don't fraqment */
861 packet->ip.hdr.fragment = htons(0x0000);
862 packet->ip.hdr.ttl = 0xFF;
863 packet->ip.hdr.protocol = icmp_protocol;
864 packet->ip.hdr.hdr_checksum = htons(0x0000);
865 packet->ip.hdr.src_addr = dest_addr->sin_addr.s_addr;
866 packet->ip.hdr.dest_addr = src_addr->sin_addr.s_addr;
867
868 src_port = dest_addr->sin_port;
869 dest_port = src_addr->sin_port;
870 }
871
872 switch (socket_type) {
873 case SOCK_STREAM:
874 packet->ip.p.tcp.source_port = src_port;
875 packet->ip.p.tcp.dest_port = dest_port;
876 packet->ip.p.tcp.seq_num = htonl(tcp_seq);
877 packet->ip.p.tcp.ack_num = htonl(tcp_ack);
878 packet->ip.p.tcp.hdr_length = 0x50; /* 5 * 32 bit words */
879 packet->ip.p.tcp.control = tcp_ctl;
880 packet->ip.p.tcp.window = htons(0x7FFF);
881 packet->ip.p.tcp.checksum = htons(0x0000);
882 packet->ip.p.tcp.urg = htons(0x0000);
883
884 break;
885
886 case SOCK_DGRAM:
887 packet->ip.p.udp.source_port = src_addr->sin_port;
888 packet->ip.p.udp.dest_port = dest_addr->sin_port;
889 packet->ip.p.udp.length = htons(8 + payload_len);
890 packet->ip.p.udp.checksum = htons(0x0000);
891
892 break;
893 }
894
895 if (payload && payload_len > 0) {
896 unsigned char *p = (unsigned char *)ret;
897 p += nonwire_len;
898 p += wire_hdr_len;
899 memcpy(p, payload, payload_len);
900 }
901
902 *_packet_len = packet_len - icmp_truncate_len;
903 return ret;
904 }
905
906 static int swrap_get_pcap_fd(const char *fname)
907 {
908 static int fd = -1;
909
910 if (fd != -1) return fd;
911
912 fd = open(fname, O_WRONLY|O_CREAT|O_EXCL|O_APPEND, 0644);
913 if (fd != -1) {
914 struct swrap_file_hdr file_hdr;
915 file_hdr.magic = 0xA1B2C3D4;
916 file_hdr.version_major = 0x0002;
917 file_hdr.version_minor = 0x0004;
918 file_hdr.timezone = 0x00000000;
919 file_hdr.sigfigs = 0x00000000;
920 file_hdr.frame_max_len = SWRAP_FRAME_LENGTH_MAX;
921 file_hdr.link_type = 0x0065; /* 101 RAW IP */
922
923 write(fd, &file_hdr, sizeof(file_hdr));
924 return fd;
925 }
926
927 fd = open(fname, O_WRONLY|O_APPEND, 0644);
928
929 return fd;
930 }
931
932 static void swrap_dump_packet(struct socket_info *si, const struct sockaddr *addr,
933 enum swrap_packet_type type,
934 const void *buf, size_t len)
935 {
936 const struct sockaddr_in *src_addr;
937 const struct sockaddr_in *dest_addr;
938 const char *file_name;
939 unsigned long tcp_seq = 0;
940 unsigned long tcp_ack = 0;
941 unsigned char tcp_ctl = 0;
942 int unreachable = 0;
943 struct timeval tv;
944 struct swrap_packet *packet;
945 size_t packet_len = 0;
946 int fd;
947
948 file_name = socket_wrapper_pcap_file();
949 if (!file_name) {
950 return;
951 }
952
953 switch (si->family) {
954 case AF_INET:
955 #ifdef HAVE_IPV6
956 case AF_INET6:
957 #endif
958 break;
959 default:
960 return;
961 }
962
963 switch (type) {
964 case SWRAP_CONNECT_SEND:
965 if (si->type != SOCK_STREAM) return;
966
967 src_addr = (const struct sockaddr_in *)si->myname;
968 dest_addr = (const struct sockaddr_in *)addr;
969
970 tcp_seq = si->io.pck_snd;
971 tcp_ack = si->io.pck_rcv;
972 tcp_ctl = 0x02; /* SYN */
973
974 si->io.pck_snd += 1;
975
976 break;
977
978 case SWRAP_CONNECT_RECV:
979 if (si->type != SOCK_STREAM) return;
980
981 dest_addr = (const struct sockaddr_in *)si->myname;
982 src_addr = (const struct sockaddr_in *)addr;
983
984 tcp_seq = si->io.pck_rcv;
985 tcp_ack = si->io.pck_snd;
986 tcp_ctl = 0x12; /** SYN,ACK */
987
988 si->io.pck_rcv += 1;
989
990 break;
991
992 case SWRAP_CONNECT_UNREACH:
993 if (si->type != SOCK_STREAM) return;
994
995 dest_addr = (const struct sockaddr_in *)si->myname;
996 src_addr = (const struct sockaddr_in *)addr;
997
998 /* Unreachable: resend the data of SWRAP_CONNECT_SEND */
999 tcp_seq = si->io.pck_snd - 1;
1000 tcp_ack = si->io.pck_rcv;
1001 tcp_ctl = 0x02; /* SYN */
1002 unreachable = 1;
1003
1004 break;
1005
1006 case SWRAP_CONNECT_ACK:
1007 if (si->type != SOCK_STREAM) return;
1008
1009 src_addr = (const struct sockaddr_in *)si->myname;
1010 dest_addr = (const struct sockaddr_in *)addr;
1011
1012 tcp_seq = si->io.pck_snd;
1013 tcp_ack = si->io.pck_rcv;
1014 tcp_ctl = 0x10; /* ACK */
1015
1016 break;
1017
1018 case SWRAP_ACCEPT_SEND:
1019 if (si->type != SOCK_STREAM) return;
1020
1021 dest_addr = (const struct sockaddr_in *)si->myname;
1022 src_addr = (const struct sockaddr_in *)addr;
1023
1024 tcp_seq = si->io.pck_rcv;
1025 tcp_ack = si->io.pck_snd;
1026 tcp_ctl = 0x02; /* SYN */
1027
1028 si->io.pck_rcv += 1;
1029
1030 break;
1031
1032 case SWRAP_ACCEPT_RECV:
1033 if (si->type != SOCK_STREAM) return;
1034
1035 src_addr = (const struct sockaddr_in *)si->myname;
1036 dest_addr = (const struct sockaddr_in *)addr;
1037
1038 tcp_seq = si->io.pck_snd;
1039 tcp_ack = si->io.pck_rcv;
1040 tcp_ctl = 0x12; /* SYN,ACK */
1041
1042 si->io.pck_snd += 1;
1043
1044 break;
1045
1046 case SWRAP_ACCEPT_ACK:
1047 if (si->type != SOCK_STREAM) return;
1048
1049 dest_addr = (const struct sockaddr_in *)si->myname;
1050 src_addr = (const struct sockaddr_in *)addr;
1051
1052 tcp_seq = si->io.pck_rcv;
1053 tcp_ack = si->io.pck_snd;
1054 tcp_ctl = 0x10; /* ACK */
1055
1056 break;
1057
1058 case SWRAP_SEND:
1059 src_addr = (const struct sockaddr_in *)si->myname;
1060 dest_addr = (const struct sockaddr_in *)si->peername;
1061
1062 tcp_seq = si->io.pck_snd;
1063 tcp_ack = si->io.pck_rcv;
1064 tcp_ctl = 0x18; /* PSH,ACK */
1065
1066 si->io.pck_snd += len;
1067
1068 break;
1069
1070 case SWRAP_SEND_RST:
1071 dest_addr = (const struct sockaddr_in *)si->myname;
1072 src_addr = (const struct sockaddr_in *)si->peername;
1073
1074 if (si->type == SOCK_DGRAM) {
1075 swrap_dump_packet(si, si->peername,
1076 SWRAP_SENDTO_UNREACH,
1077 buf, len);
1078 return;
1079 }
1080
1081 tcp_seq = si->io.pck_rcv;
1082 tcp_ack = si->io.pck_snd;
1083 tcp_ctl = 0x14; /** RST,ACK */
1084
1085 break;
1086
1087 case SWRAP_PENDING_RST:
1088 dest_addr = (const struct sockaddr_in *)si->myname;
1089 src_addr = (const struct sockaddr_in *)si->peername;
1090
1091 if (si->type == SOCK_DGRAM) {
1092 return;
1093 }
1094
1095 tcp_seq = si->io.pck_rcv;
1096 tcp_ack = si->io.pck_snd;
1097 tcp_ctl = 0x14; /* RST,ACK */
1098
1099 break;
1100
1101 case SWRAP_RECV:
1102 dest_addr = (const struct sockaddr_in *)si->myname;
1103 src_addr = (const struct sockaddr_in *)si->peername;
1104
1105 tcp_seq = si->io.pck_rcv;
1106 tcp_ack = si->io.pck_snd;
1107 tcp_ctl = 0x18; /* PSH,ACK */
1108
1109 si->io.pck_rcv += len;
1110
1111 break;
1112
1113 case SWRAP_RECV_RST:
1114 dest_addr = (const struct sockaddr_in *)si->myname;
1115 src_addr = (const struct sockaddr_in *)si->peername;
1116
1117 if (si->type == SOCK_DGRAM) {
1118 return;
1119 }
1120
1121 tcp_seq = si->io.pck_rcv;
1122 tcp_ack = si->io.pck_snd;
1123 tcp_ctl = 0x14; /* RST,ACK */
1124
1125 break;
1126
1127 case SWRAP_SENDTO:
1128 src_addr = (const struct sockaddr_in *)si->myname;
1129 dest_addr = (const struct sockaddr_in *)addr;
1130
1131 si->io.pck_snd += len;
1132
1133 break;
1134
1135 case SWRAP_SENDTO_UNREACH:
1136 dest_addr = (const struct sockaddr_in *)si->myname;
1137 src_addr = (const struct sockaddr_in *)addr;
1138
1139 unreachable = 1;
1140
1141 break;
1142
1143 case SWRAP_RECVFROM:
1144 dest_addr = (const struct sockaddr_in *)si->myname;
1145 src_addr = (const struct sockaddr_in *)addr;
1146
1147 si->io.pck_rcv += len;
1148
1149 break;
1150
1151 case SWRAP_CLOSE_SEND:
1152 if (si->type != SOCK_STREAM) return;
1153
1154 src_addr = (const struct sockaddr_in *)si->myname;
1155 dest_addr = (const struct sockaddr_in *)si->peername;
1156
1157 tcp_seq = si->io.pck_snd;
1158 tcp_ack = si->io.pck_rcv;
1159 tcp_ctl = 0x11; /* FIN, ACK */
1160
1161 si->io.pck_snd += 1;
1162
1163 break;
1164
1165 case SWRAP_CLOSE_RECV:
1166 if (si->type != SOCK_STREAM) return;
1167
1168 dest_addr = (const struct sockaddr_in *)si->myname;
1169 src_addr = (const struct sockaddr_in *)si->peername;
1170
1171 tcp_seq = si->io.pck_rcv;
1172 tcp_ack = si->io.pck_snd;
1173 tcp_ctl = 0x11; /* FIN,ACK */
1174
1175 si->io.pck_rcv += 1;
1176
1177 break;
1178
1179 case SWRAP_CLOSE_ACK:
1180 if (si->type != SOCK_STREAM) return;
1181
1182 src_addr = (const struct sockaddr_in *)si->myname;
1183 dest_addr = (const struct sockaddr_in *)si->peername;
1184
1185 tcp_seq = si->io.pck_snd;
1186 tcp_ack = si->io.pck_rcv;
1187 tcp_ctl = 0x10; /* ACK */
1188
1189 break;
1190 default:
1191 return;
1192 }
1193
1194 swrapGetTimeOfDay(&tv);
1195
1196 packet = swrap_packet_init(&tv, src_addr, dest_addr, si->type,
1197 (const unsigned char *)buf, len,
1198 tcp_seq, tcp_ack, tcp_ctl, unreachable,
1199 &packet_len);
1200 if (!packet) {
1201 return;
1202 }
1203
1204 fd = swrap_get_pcap_fd(file_name);
1205 if (fd != -1) {
1206 write(fd, packet, packet_len);
1207 }
1208
1209 free(packet);
1210 }
1211
1212 _PUBLIC_ int swrap_socket(int family, int type, int protocol)
1213 {
1214 struct socket_info *si;
1215 int fd;
1216
1217 if (!socket_wrapper_dir()) {
1218 return real_socket(family, type, protocol);
1219 }
1220
1221 switch (family) {
1222 case AF_INET:
1223 #ifdef HAVE_IPV6
1224 case AF_INET6:
1225 #endif
1226 break;
1227 case AF_UNIX:
1228 return real_socket(family, type, protocol);
1229 default:
1230 errno = EAFNOSUPPORT;
1231 return -1;
1232 }
1233
1234 switch (type) {
1235 case SOCK_STREAM:
1236 break;
1237 case SOCK_DGRAM:
1238 break;
1239 default:
1240 errno = EPROTONOSUPPORT;
1241 return -1;
1242 }
1243
1244 #if 0
1245 switch (protocol) {
1246 case 0:
1247 break;
1248 default:
1249 errno = EPROTONOSUPPORT;
1250 return -1;
1251 }
1252 #endif
1253
1254 fd = real_socket(AF_UNIX, type, 0);
1255
1256 if (fd == -1) return -1;
1257
1258 si = (struct socket_info *)calloc(1, sizeof(struct socket_info));
1259
1260 si->family = family;
1261 si->type = type;
1262 si->protocol = protocol;
1263 si->fd = fd;
1264
1265 SWRAP_DLIST_ADD(sockets, si);
1266
1267 return si->fd;
1268 }
1269
1270 _PUBLIC_ int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
1271 {
1272 struct socket_info *parent_si, *child_si;
1273 int fd;
1274 struct sockaddr_un un_addr;
1275 socklen_t un_addrlen = sizeof(un_addr);
1276 struct sockaddr_un un_my_addr;
1277 socklen_t un_my_addrlen = sizeof(un_my_addr);
1278 struct sockaddr *my_addr;
1279 socklen_t my_addrlen, len;
1280 int ret;
1281
1282 parent_si = find_socket_info(s);
1283 if (!parent_si) {
1284 return real_accept(s, addr, addrlen);
1285 }
1286
1287 /*
1288 * assume out sockaddr have the same size as the in parent
1289 * socket family
1290 */
1291 my_addrlen = socket_length(parent_si->family);
1292 if (my_addrlen < 0) {
1293 errno = EINVAL;
1294 return -1;
1295 }
1296
1297 my_addr = malloc(my_addrlen);
1298 if (my_addr == NULL) {
1299 return -1;
1300 }
1301
1302 memset(&un_addr, 0, sizeof(un_addr));
1303 memset(&un_my_addr, 0, sizeof(un_my_addr));
1304
1305 ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
1306 if (ret == -1) {
1307 free(my_addr);
1308 return ret;
1309 }
1310
1311 fd = ret;
1312
1313 len = my_addrlen;
1314 ret = sockaddr_convert_from_un(parent_si, &un_addr, un_addrlen,
1315 parent_si->family, my_addr, &len);
1316 if (ret == -1) {
1317 free(my_addr);
1318 close(fd);
1319 return ret;
1320 }
1321
1322 child_si = (struct socket_info *)malloc(sizeof(struct socket_info));
1323 memset(child_si, 0, sizeof(*child_si));
1324
1325 child_si->fd = fd;
1326 child_si->family = parent_si->family;
1327 child_si->type = parent_si->type;
1328 child_si->protocol = parent_si->protocol;
1329 child_si->bound = 1;
1330 child_si->is_server = 1;
1331
1332 child_si->peername_len = len;
1333 child_si->peername = sockaddr_dup(my_addr, len);
1334
1335 if (addr != NULL && addrlen != NULL) {
1336 *addrlen = len;
1337 if (*addrlen >= len)
1338 memcpy(addr, my_addr, len);
1339 *addrlen = 0;
1340 }
1341
1342 ret = real_getsockname(fd, (struct sockaddr *)&un_my_addr, &un_my_addrlen);
1343 if (ret == -1) {
1344 free(child_si);
1345 close(fd);
1346 return ret;
1347 }
1348
1349 len = my_addrlen;
1350 ret = sockaddr_convert_from_un(child_si, &un_my_addr, un_my_addrlen,
1351 child_si->family, my_addr, &len);
1352 if (ret == -1) {
1353 free(child_si);
1354 free(my_addr);
1355 close(fd);
1356 return ret;
1357 }
1358
1359 child_si->myname_len = len;
1360 child_si->myname = sockaddr_dup(my_addr, len);
1361 free(my_addr);
1362
1363 SWRAP_DLIST_ADD(sockets, child_si);
1364
1365 swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_SEND, NULL, 0);
1366 swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_RECV, NULL, 0);
1367 swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_ACK, NULL, 0);
1368
1369 return fd;
1370 }
1371
1372 static int autobind_start_init;
1373 static int autobind_start;
1374
1375 /* using sendto() or connect() on an unbound socket would give the
1376 recipient no way to reply, as unlike UDP and TCP, a unix domain
1377 socket can't auto-assign emphemeral port numbers, so we need to
1378 assign it here */
1379 static int swrap_auto_bind(struct socket_info *si)
1380 {
1381 struct sockaddr_un un_addr;
1382 int i;
1383 char type;
1384 int ret;
1385 int port;
1386 struct stat st;
1387
1388 if (autobind_start_init != 1) {
1389 autobind_start_init = 1;
1390 autobind_start = getpid();
1391 autobind_start %= 50000;
1392 autobind_start += 10000;
1393 }
1394
1395 un_addr.sun_family = AF_UNIX;
1396
1397 switch (si->family) {
1398 case AF_INET: {
1399 struct sockaddr_in in;
1400
1401 switch (si->type) {
1402 case SOCK_STREAM:
1403 type = SOCKET_TYPE_CHAR_TCP;
1404 break;
1405 case SOCK_DGRAM:
1406 type = SOCKET_TYPE_CHAR_UDP;
1407 break;
1408 default:
1409 errno = ESOCKTNOSUPPORT;
1410 return -1;
1411 }
1412
1413 memset(&in, 0, sizeof(in));
1414 in.sin_family = AF_INET;
1415 in.sin_addr.s_addr = htonl(127<<24 |
1416 socket_wrapper_default_iface());
1417
1418 si->myname_len = sizeof(in);
1419 si->myname = sockaddr_dup(&in, si->myname_len);
1420 break;
1421 }
1422 #ifdef HAVE_IPV6
1423 case AF_INET6: {
1424 struct sockaddr_in6 in6;
1425
1426 switch (si->type) {
1427 case SOCK_STREAM:
1428 type = SOCKET_TYPE_CHAR_TCP_V6;
1429 break;
1430 case SOCK_DGRAM:
1431 type = SOCKET_TYPE_CHAR_UDP_V6;
1432 break;
1433 default:
1434 errno = ESOCKTNOSUPPORT;
1435 return -1;
1436 }
1437
1438 memset(&in6, 0, sizeof(in6));
1439 in6.sin6_family = AF_INET6;
1440 in6.sin6_addr.s6_addr[0] = SW_IPV6_ADDRESS;
1441 si->myname_len = sizeof(in6);
1442 si->myname = sockaddr_dup(&in6, si->myname_len);
1443 break;
1444 }
1445 #endif
1446 default:
1447 errno = ESOCKTNOSUPPORT;
1448 return -1;
1449 }
1450
1451 if (autobind_start > 60000) {
1452 autobind_start = 10000;
1453 }
1454
1455 for (i=0;i<1000;i++) {
1456 port = autobind_start + i;
1457 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path),
1458 "%s/"SOCKET_FORMAT, socket_wrapper_dir(),
1459 type, socket_wrapper_default_iface(), port);
1460 if (stat(un_addr.sun_path, &st) == 0) continue;
1461
1462 ret = real_bind(si->fd, (struct sockaddr *)&un_addr, sizeof(un_addr));
1463 if (ret == -1) return ret;
1464
1465 si->tmp_path = strdup(un_addr.sun_path);
1466 si->bound = 1;
1467 autobind_start = port + 1;
1468 break;
1469 }
1470 if (i == 1000) {
1471 errno = ENFILE;
1472 return -1;
1473 }
1474
1475 set_port(si->family, port, si->myname);
1476
1477 return 0;
1478 }
1479
1480
1481 _PUBLIC_ int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
1482 {
1483 int ret;
1484 struct sockaddr_un un_addr;
1485 struct socket_info *si = find_socket_info(s);
1486
1487 if (!si) {
1488 return real_connect(s, serv_addr, addrlen);
1489 }
1490
1491 if (si->bound == 0) {
1492 ret = swrap_auto_bind(si);
1493 if (ret == -1) return -1;
1494 }
1495
1496 if (si->family != serv_addr->sa_family) {
1497 errno = EINVAL;
1498 return -1;
1499 }
1500
1501 ret = sockaddr_convert_to_un(si, (const struct sockaddr *)serv_addr, addrlen, &un_addr, 0, NULL);
1502 if (ret == -1) return -1;
1503
1504 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_SEND, NULL, 0);
1505
1506 ret = real_connect(s, (struct sockaddr *)&un_addr,
1507 sizeof(struct sockaddr_un));
1508
1509 /* to give better errors */
1510 if (ret == -1 && errno == ENOENT) {
1511 errno = EHOSTUNREACH;
1512 }
1513
1514 if (ret == 0) {
1515 si->peername_len = addrlen;
1516 si->peername = sockaddr_dup(serv_addr, addrlen);
1517
1518 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_RECV, NULL, 0);
1519 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_ACK, NULL, 0);
1520 } else {
1521 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_UNREACH, NULL, 0);
1522 }
1523
1524 return ret;
1525 }
1526
1527 _PUBLIC_ int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
1528 {
1529 int ret;
1530 struct sockaddr_un un_addr;
1531 struct socket_info *si = find_socket_info(s);
1532
1533 if (!si) {
1534 return real_bind(s, myaddr, addrlen);
1535 }
1536
1537 si->myname_len = addrlen;
1538 si->myname = sockaddr_dup(myaddr, addrlen);
1539
1540 ret = sockaddr_convert_to_un(si, (const struct sockaddr *)myaddr, addrlen, &un_addr, 1, &si->bcast);
1541 if (ret == -1) return -1;
1542
1543 unlink(un_addr.sun_path);
1544
1545 ret = real_bind(s, (struct sockaddr *)&un_addr,
1546 sizeof(struct sockaddr_un));
1547
1548 if (ret == 0) {
1549 si->bound = 1;
1550 }
1551
1552 return ret;
1553 }
1554
1555 _PUBLIC_ int swrap_listen(int s, int backlog)
1556 {
1557 int ret;
1558 struct socket_info *si = find_socket_info(s);
1559
1560 if (!si) {
1561 return real_listen(s, backlog);
1562 }
1563
1564 ret = real_listen(s, backlog);
1565
1566 return ret;
1567 }
1568
1569 _PUBLIC_ int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
1570 {
1571 struct socket_info *si = find_socket_info(s);
1572
1573 if (!si) {
1574 return real_getpeername(s, name, addrlen);
1575 }
1576
1577 if (!si->peername)
1578 {
1579 errno = ENOTCONN;
1580 return -1;
1581 }
1582
1583 memcpy(name, si->peername, si->peername_len);
1584 *addrlen = si->peername_len;
1585
1586 return 0;
1587 }
1588
1589 _PUBLIC_ int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
1590 {
1591 struct socket_info *si = find_socket_info(s);
1592
1593 if (!si) {
1594 return real_getsockname(s, name, addrlen);
1595 }
1596
1597 memcpy(name, si->myname, si->myname_len);
1598 *addrlen = si->myname_len;
1599
1600 return 0;
1601 }
1602
1603 _PUBLIC_ int swrap_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
1604 {
1605 struct socket_info *si = find_socket_info(s);
1606
1607 if (!si) {
1608 return real_getsockopt(s, level, optname, optval, optlen);
1609 }
1610
1611 if (level == SOL_SOCKET) {
1612 return real_getsockopt(s, level, optname, optval, optlen);
1613 }
1614
1615 errno = ENOPROTOOPT;
1616 return -1;
1617 }
1618
1619 _PUBLIC_ int swrap_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen)
1620 {
1621 struct socket_info *si = find_socket_info(s);
1622
1623 if (!si) {
1624 return real_setsockopt(s, level, optname, optval, optlen);
1625 }
1626
1627 if (level == SOL_SOCKET) {
1628 return real_setsockopt(s, level, optname, optval, optlen);
1629 }
1630
1631 switch (si->family) {
1632 case AF_INET:
1633 return 0;
1634 default:
1635 errno = ENOPROTOOPT;
1636 return -1;
1637 }
1638 }
1639
1640 _PUBLIC_ ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
1641 {
1642 struct sockaddr_un un_addr;
1643 socklen_t un_addrlen = sizeof(un_addr);
1644 int ret;
1645 struct socket_info *si = find_socket_info(s);
1646
1647 if (!si) {
1648 return real_recvfrom(s, buf, len, flags, from, fromlen);
1649 }
1650
1651 /* irix 6.4 forgets to null terminate the sun_path string :-( */
1652 memset(&un_addr, 0, sizeof(un_addr));
1653 ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
1654 if (ret == -1)
1655 return ret;
1656
1657 if (sockaddr_convert_from_un(si, &un_addr, un_addrlen,
1658 si->family, from, fromlen) == -1) {
1659 return -1;
1660 }
1661
1662 swrap_dump_packet(si, from, SWRAP_RECVFROM, buf, ret);
1663
1664 return ret;
1665 }
1666
1667
1668 _PUBLIC_ ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
1669 {
1670 struct sockaddr_un un_addr;
1671 int ret;
1672 struct socket_info *si = find_socket_info(s);
1673 int bcast = 0;
1674
1675 if (!si) {
1676 return real_sendto(s, buf, len, flags, to, tolen);
1677 }
1678
1679 switch (si->type) {
1680 case SOCK_STREAM:
1681 ret = real_send(s, buf, len, flags);
1682 break;
1683 case SOCK_DGRAM:
1684 if (si->bound == 0) {
1685 ret = swrap_auto_bind(si);
1686 if (ret == -1) return -1;
1687 }
1688
1689 ret = sockaddr_convert_to_un(si, to, tolen, &un_addr, 0, &bcast);
1690 if (ret == -1) return -1;
1691
1692 if (bcast) {
1693 struct stat st;
1694 unsigned int iface;
1695 unsigned int prt = ntohs(((const struct sockaddr_in *)to)->sin_port);
1696 char type;
1697
1698 type = SOCKET_TYPE_CHAR_UDP;
1699
1700 for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
1701 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/"SOCKET_FORMAT,
1702 socket_wrapper_dir(), type, iface, prt);
1703 if (stat(un_addr.sun_path, &st) != 0) continue;
1704
1705 /* ignore the any errors in broadcast sends */
1706 real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
1707 }
1708
1709 swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
1710
1711 return len;
1712 }
1713
1714 ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
1715 break;
1716 default:
1717 ret = -1;
1718 errno = EHOSTUNREACH;
1719 break;
1720 }
1721
1722 /* to give better errors */
1723 if (ret == -1 && errno == ENOENT) {
1724 errno = EHOSTUNREACH;
1725 }
1726
1727 if (ret == -1) {
1728 swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
1729 swrap_dump_packet(si, to, SWRAP_SENDTO_UNREACH, buf, len);
1730 } else {
1731 swrap_dump_packet(si, to, SWRAP_SENDTO, buf, ret);
1732 }
1733
1734 return ret;
1735 }
1736
1737 _PUBLIC_ int swrap_ioctl(int s, int r, void *p)
1738 {
1739 int ret;
1740 struct socket_info *si = find_socket_info(s);
1741 int value;
1742
1743 if (!si) {
1744 return real_ioctl(s, r, p);
1745 }
1746
1747 ret = real_ioctl(s, r, p);
1748
1749 switch (r) {
1750 case FIONREAD:
1751 value = *((int *)p);
1752 if (ret == -1 && errno != EAGAIN && errno != ENOBUFS) {
1753 swrap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
1754 } else if (value == 0) { /* END OF FILE */
1755 swrap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
1756 }
1757 break;
1758 }
1759
1760 return ret;
1761 }
1762
1763 _PUBLIC_ ssize_t swrap_recv(int s, void *buf, size_t len, int flags)
1764 {
1765 int ret;
1766 struct socket_info *si = find_socket_info(s);
1767
1768 if (!si) {
1769 return real_recv(s, buf, len, flags);
1770 }
1771
1772 ret = real_recv(s, buf, len, flags);
1773 if (ret == -1 && errno != EAGAIN && errno != ENOBUFS) {
1774 swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
1775 } else if (ret == 0) { /* END OF FILE */
1776 swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
1777 } else {
1778 swrap_dump_packet(si, NULL, SWRAP_RECV, buf, ret);
1779 }
1780
1781 return ret;
1782 }
1783
1784
1785 _PUBLIC_ ssize_t swrap_send(int s, const void *buf, size_t len, int flags)
1786 {
1787 int ret;
1788 struct socket_info *si = find_socket_info(s);
1789
1790 if (!si) {
1791 return real_send(s, buf, len, flags);
1792 }
1793
1794 ret = real_send(s, buf, len, flags);
1795
1796 if (ret == -1) {
1797 swrap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
1798 swrap_dump_packet(si, NULL, SWRAP_SEND_RST, NULL, 0);
1799 } else {
1800 swrap_dump_packet(si, NULL, SWRAP_SEND, buf, ret);
1801 }
1802
1803 return ret;
1804 }
1805
1806 _PUBLIC_ int swrap_close(int fd)
1807 {
1808 struct socket_info *si = find_socket_info(fd);
1809 int ret;
1810
1811 if (!si) {
1812 return real_close(fd);
1813 }
1814
1815 SWRAP_DLIST_REMOVE(sockets, si);
1816
1817 if (si->myname && si->peername) {
1818 swrap_dump_packet(si, NULL, SWRAP_CLOSE_SEND, NULL, 0);
1819 }
1820
1821 ret = real_close(fd);
1822
1823 if (si->myname && si->peername) {
1824 swrap_dump_packet(si, NULL, SWRAP_CLOSE_RECV, NULL, 0);
1825 swrap_dump_packet(si, NULL, SWRAP_CLOSE_ACK, NULL, 0);
1826 }
1827
1828 if (si->path) free(si->path);
1829 if (si->myname) free(si->myname);
1830 if (si->peername) free(si->peername);
1831 if (si->tmp_path) {
1832 unlink(si->tmp_path);
1833 free(si->tmp_path);
1834 }
1835 free(si);
1836
1837 return ret;
1838 }
1839
1840 static int
1841 dup_internal(const struct socket_info *si_oldd, int fd)
1842 {
1843 struct socket_info *si_newd;
1844
1845 si_newd = (struct socket_info *)calloc(1, sizeof(struct socket_info));
1846
1847 si_newd->fd = fd;
1848
1849 si_newd->family = si_oldd->family;
1850 si_newd->type = si_oldd->type;
1851 si_newd->protocol = si_oldd->protocol;
1852 si_newd->bound = si_oldd->bound;
1853 si_newd->bcast = si_oldd->bcast;
1854 if (si_oldd->path)
1855 si_newd->path = strdup(si_oldd->path);
1856 if (si_oldd->tmp_path)
1857 si_newd->tmp_path = strdup(si_oldd->tmp_path);
1858 si_newd->myname =
1859 sockaddr_dup(si_oldd->myname, si_oldd->myname_len);
1860 si_newd->myname_len = si_oldd->myname_len;
1861 si_newd->peername =
1862 sockaddr_dup(si_oldd->peername, si_oldd->peername_len);
1863 si_newd->peername_len = si_oldd->peername_len;
1864
1865 si_newd->io = si_oldd->io;
1866
1867 SWRAP_DLIST_ADD(sockets, si_newd);
1868
1869 return fd;
1870 }
1871
1872
1873 _PUBLIC_ int swrap_dup(int oldd)
1874 {
1875 struct socket_info *si;
1876 int fd;
1877
1878 si = find_socket_info(oldd);
1879 if (si == NULL)
1880 return real_dup(oldd);
1881
1882 fd = real_dup(si->fd);
1883 if (fd < 0)
1884 return fd;
1885
1886 return dup_internal(si, fd);
1887 }
1888
1889
1890 _PUBLIC_ int swrap_dup2(int oldd, int newd)
1891 {
1892 struct socket_info *si_newd, *si_oldd;
1893 int fd;
1894
1895 if (newd == oldd)
1896 return newd;
1897
1898 si_oldd = find_socket_info(oldd);
1899 si_newd = find_socket_info(newd);
1900
1901 if (si_oldd == NULL && si_newd == NULL)
1902 return real_dup2(oldd, newd);
1903
1904 fd = real_dup2(si_oldd->fd, newd);
1905 if (fd < 0)
1906 return fd;
1907
1908 /* close new socket first */
1909 if (si_newd)
1910 swrap_close(newd);
1911
1912 return dup_internal(si_oldd, fd);
1913 }
Heimdal