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