src/socket_wrapper.c

   1 /*
   2  * BSD 3-Clause License
   3  *
   4  * Copyright (c) 2005-2008, Jelmer Vernooij <jelmer@samba.org>
   5  * Copyright (c) 2006-2018, Stefan Metzmacher <metze@samba.org>
   6  * Copyright (c) 2013-2018, Andreas Schneider <asn@samba.org>
   7  * Copyright (c) 2014-2017, Michael Adam <obnox@samba.org>
   8  * Copyright (c) 2016-2018, Anoop C S <anoopcs@redhat.com>
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  *
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  *
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * 3. Neither the name of the author nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  */
  38
  39 /*
  40    Socket wrapper library. Passes all socket communication over
  41    unix domain sockets if the environment variable SOCKET_WRAPPER_DIR
  42    is set.
  43 */
  44
  45 #include "config.h"
  46
  47 #include <sys/types.h>
  48 #include <sys/time.h>
  49 #include <sys/stat.h>
  50 #include <sys/socket.h>
  51 #include <sys/ioctl.h>
  52 #ifdef HAVE_SYS_FILIO_H
  53 #include <sys/filio.h>
  54 #endif
  55 #ifdef HAVE_SYS_SIGNALFD_H
  56 #include <sys/signalfd.h>
  57 #endif
  58 #ifdef HAVE_SYS_EVENTFD_H
  59 #include <sys/eventfd.h>
  60 #endif
  61 #ifdef HAVE_SYS_TIMERFD_H
  62 #include <sys/timerfd.h>
  63 #endif
  64 #include <sys/uio.h>
  65 #include <errno.h>
  66 #include <sys/un.h>
  67 #include <netinet/in.h>
  68 #include <netinet/tcp.h>
  69 #ifdef HAVE_NETINET_TCP_FSM_H
  70 #include <netinet/tcp_fsm.h>
  71 #endif
  72 #include <arpa/inet.h>
  73 #include <fcntl.h>
  74 #include <stdlib.h>
  75 #include <string.h>
  76 #include <stdio.h>
  77 #include <stdint.h>
  78 #include <stdarg.h>
  79 #include <stdbool.h>
  80 #include <unistd.h>
  81 #ifdef HAVE_GNU_LIB_NAMES_H
  82 #include <gnu/lib-names.h>
  83 #endif
  84 #ifdef HAVE_RPC_RPC_H
  85 #include <rpc/rpc.h>
  86 #endif
  87 #include <pthread.h>
  88
  89 enum swrap_dbglvl_e {
  90         SWRAP_LOG_ERROR = 0,
  91         SWRAP_LOG_WARN,
  92         SWRAP_LOG_DEBUG,
  93         SWRAP_LOG_TRACE
  94 };
  95
  96 /* GCC have printf type attribute check. */
  97 #ifdef HAVE_FUNCTION_ATTRIBUTE_FORMAT
  98 #define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b)))
  99 #else
 100 #define PRINTF_ATTRIBUTE(a,b)
 101 #endif /* HAVE_FUNCTION_ATTRIBUTE_FORMAT */
 102
 103 #ifdef HAVE_CONSTRUCTOR_ATTRIBUTE
 104 #define CONSTRUCTOR_ATTRIBUTE __attribute__ ((constructor))
 105 #else
 106 #define CONSTRUCTOR_ATTRIBUTE
 107 #endif /* HAVE_CONSTRUCTOR_ATTRIBUTE */
 108
 109 #ifdef HAVE_DESTRUCTOR_ATTRIBUTE
 110 #define DESTRUCTOR_ATTRIBUTE __attribute__ ((destructor))
 111 #else
 112 #define DESTRUCTOR_ATTRIBUTE
 113 #endif
 114
 115 #ifndef FALL_THROUGH
 116 # ifdef HAVE_FALLTHROUGH_ATTRIBUTE
 117 #  define FALL_THROUGH __attribute__ ((fallthrough))
 118 # else /* HAVE_FALLTHROUGH_ATTRIBUTE */
 119 #  define FALL_THROUGH ((void)0)
 120 # endif /* HAVE_FALLTHROUGH_ATTRIBUTE */
 121 #endif /* FALL_THROUGH */
 122
 123 #ifdef HAVE_ADDRESS_SANITIZER_ATTRIBUTE
 124 #define DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE __attribute__((no_sanitize_address))
 125 #else
 126 #define DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE
 127 #endif
 128
 129 #ifdef HAVE_GCC_THREAD_LOCAL_STORAGE
 130 # define SWRAP_THREAD __thread
 131 #else
 132 # define SWRAP_THREAD
 133 #endif
 134
 135 #ifndef MIN
 136 #define MIN(a,b) ((a)<(b)?(a):(b))
 137 #endif
 138
 139 #ifndef ZERO_STRUCT
 140 #define ZERO_STRUCT(x) memset((char *)&(x), 0, sizeof(x))
 141 #endif
 142
 143 #ifndef ZERO_STRUCTP
 144 #define ZERO_STRUCTP(x) do { \
 145                 if ((x) != NULL) \
 146                         memset((char *)(x), 0, sizeof(*(x))); \
 147         } while(0)
 148 #endif
 149
 150 #ifndef SAFE_FREE
 151 #define SAFE_FREE(x) do { if ((x) != NULL) {free(x); (x)=NULL;} } while(0)
 152 #endif
 153
 154 #ifndef discard_const
 155 #define discard_const(ptr) ((void *)((uintptr_t)(ptr)))
 156 #endif
 157
 158 #ifndef discard_const_p
 159 #define discard_const_p(type, ptr) ((type *)discard_const(ptr))
 160 #endif
 161
 162 #define UNUSED(x) (void)(x)
 163
 164 #ifdef IPV6_PKTINFO
 165 # ifndef IPV6_RECVPKTINFO
 166 #  define IPV6_RECVPKTINFO IPV6_PKTINFO
 167 # endif /* IPV6_RECVPKTINFO */
 168 #endif /* IPV6_PKTINFO */
 169
 170 /*
 171  * On BSD IP_PKTINFO has a different name because during
 172  * the time when they implemented it, there was no RFC.
 173  * The name for IPv6 is the same as on Linux.
 174  */
 175 #ifndef IP_PKTINFO
 176 # ifdef IP_RECVDSTADDR
 177 #  define IP_PKTINFO IP_RECVDSTADDR
 178 # endif
 179 #endif
 180
 181 #define socket_wrapper_init_mutex(m) \
 182         _socket_wrapper_init_mutex(m, #m)
 183
 184 /* Add new global locks here please */
 185 # define SWRAP_REINIT_ALL do { \
 186         size_t __i; \
 187         int ret; \
 188         ret = socket_wrapper_init_mutex(&sockets_mutex); \
 189         if (ret != 0) exit(-1); \
 190         ret = socket_wrapper_init_mutex(&socket_reset_mutex); \
 191         if (ret != 0) exit(-1); \
 192         ret = socket_wrapper_init_mutex(&first_free_mutex); \
 193         if (ret != 0) exit(-1); \
 194         for (__i = 0; (sockets != NULL) && __i < socket_info_max; __i++) { \
 195                 ret = socket_wrapper_init_mutex(&sockets[__i].meta.mutex); \
 196                 if (ret != 0) exit(-1); \
 197         } \
 198         ret = socket_wrapper_init_mutex(&autobind_start_mutex); \
 199         if (ret != 0) exit(-1); \
 200         ret = socket_wrapper_init_mutex(&pcap_dump_mutex); \
 201         if (ret != 0) exit(-1); \
 202         ret = socket_wrapper_init_mutex(&mtu_update_mutex); \
 203         if (ret != 0) exit(-1); \
 204 } while(0)
 205
 206 # define SWRAP_LOCK_ALL do { \
 207         size_t __i; \
 208         swrap_mutex_lock(&sockets_mutex); \
 209         swrap_mutex_lock(&socket_reset_mutex); \
 210         swrap_mutex_lock(&first_free_mutex); \
 211         for (__i = 0; (sockets != NULL) && __i < socket_info_max; __i++) { \
 212                 swrap_mutex_lock(&sockets[__i].meta.mutex); \
 213         } \
 214         swrap_mutex_lock(&autobind_start_mutex); \
 215         swrap_mutex_lock(&pcap_dump_mutex); \
 216         swrap_mutex_lock(&mtu_update_mutex); \
 217 } while(0)
 218
 219 # define SWRAP_UNLOCK_ALL do { \
 220         size_t __s; \
 221         swrap_mutex_unlock(&mtu_update_mutex); \
 222         swrap_mutex_unlock(&pcap_dump_mutex); \
 223         swrap_mutex_unlock(&autobind_start_mutex); \
 224         for (__s = 0; (sockets != NULL) && __s < socket_info_max; __s++) { \
 225                 size_t __i = (socket_info_max - 1) - __s; \
 226                 swrap_mutex_unlock(&sockets[__i].meta.mutex); \
 227         } \
 228         swrap_mutex_unlock(&first_free_mutex); \
 229         swrap_mutex_unlock(&socket_reset_mutex); \
 230         swrap_mutex_unlock(&sockets_mutex); \
 231 } while(0)
 232
 233 #define SOCKET_INFO_CONTAINER(si) \
 234         (struct socket_info_container *)(si)
 235
 236 #define SWRAP_LOCK_SI(si) do { \
 237         struct socket_info_container *sic = SOCKET_INFO_CONTAINER(si); \
 238         swrap_mutex_lock(&sic->meta.mutex); \
 239 } while(0)
 240
 241 #define SWRAP_UNLOCK_SI(si) do { \
 242         struct socket_info_container *sic = SOCKET_INFO_CONTAINER(si); \
 243         swrap_mutex_unlock(&sic->meta.mutex); \
 244 } while(0)
 245
 246 #if defined(HAVE_GETTIMEOFDAY_TZ) || defined(HAVE_GETTIMEOFDAY_TZ_VOID)
 247 #define swrapGetTimeOfDay(tval) gettimeofday(tval,NULL)
 248 #else
 249 #define swrapGetTimeOfDay(tval) gettimeofday(tval)
 250 #endif
 251
 252 /* we need to use a very terse format here as IRIX 6.4 silently
 253    truncates names to 16 chars, so if we use a longer name then we
 254    can't tell which port a packet came from with recvfrom()
 255
 256    with this format we have 8 chars left for the directory name
 257 */
 258 #define SOCKET_FORMAT "%c%02X%04X"
 259 #define SOCKET_TYPE_CHAR_TCP            'T'
 260 #define SOCKET_TYPE_CHAR_UDP            'U'
 261 #define SOCKET_TYPE_CHAR_TCP_V6         'X'
 262 #define SOCKET_TYPE_CHAR_UDP_V6         'Y'
 263
 264 /*
 265  * Set the packet MTU to 1500 bytes for stream sockets to make it it easier to
 266  * format PCAP capture files (as the caller will simply continue from here).
 267  */
 268 #define SOCKET_WRAPPER_MTU_DEFAULT 1500
 269 #define SOCKET_WRAPPER_MTU_MIN     512
 270 #define SOCKET_WRAPPER_MTU_MAX     32768
 271
 272 #define SOCKET_MAX_SOCKETS 1024
 273
 274 /*
 275  * Maximum number of socket_info structures that can
 276  * be used. Can be overriden by the environment variable
 277  * SOCKET_WRAPPER_MAX_SOCKETS.
 278  */
 279 #define SOCKET_WRAPPER_MAX_SOCKETS_DEFAULT 65535
 280
 281 #define SOCKET_WRAPPER_MAX_SOCKETS_LIMIT 262140
 282
 283 /* This limit is to avoid broadcast sendto() needing to stat too many
 284  * files.  It may be raised (with a performance cost) to up to 254
 285  * without changing the format above */
 286 #define MAX_WRAPPED_INTERFACES 64
 287
 288 struct swrap_address {
 289         socklen_t sa_socklen;
 290         union {
 291                 struct sockaddr s;
 292                 struct sockaddr_in in;
 293 #ifdef HAVE_IPV6
 294                 struct sockaddr_in6 in6;
 295 #endif
 296                 struct sockaddr_un un;
 297                 struct sockaddr_storage ss;
 298         } sa;
 299 };
 300
 301 static int first_free;
 302
 303 struct socket_info
 304 {
 305         /*
 306          * Remember to update swrap_unix_scm_right_magic
 307          * on any change.
 308          */
 309
 310         int family;
 311         int type;
 312         int protocol;
 313         int bound;
 314         int bcast;
 315         int is_server;
 316         int connected;
 317         int defer_connect;
 318         int pktinfo;
 319         int tcp_nodelay;
 320         int listening;
 321         int fd_passed;
 322
 323         /* The unix path so we can unlink it on close() */
 324         struct sockaddr_un un_addr;
 325
 326         struct swrap_address bindname;
 327         struct swrap_address myname;
 328         struct swrap_address peername;
 329
 330         struct {
 331                 unsigned long pck_snd;
 332                 unsigned long pck_rcv;
 333         } io;
 334 };
 335
 336 struct socket_info_meta
 337 {
 338         unsigned int refcount;
 339         int next_free;
 340         pthread_mutex_t mutex;
 341 };
 342
 343 struct socket_info_container
 344 {
 345         struct socket_info info;
 346         struct socket_info_meta meta;
 347 };
 348
 349 static struct socket_info_container *sockets;
 350
 351 static size_t socket_info_max = 0;
 352
 353 /*
 354  * Allocate the socket array always on the limit value. We want it to be
 355  * at least bigger than the default so if we reach the limit we can
 356  * still deal with duplicate fds pointing to the same socket_info.
 357  */
 358 static size_t socket_fds_max = SOCKET_WRAPPER_MAX_SOCKETS_LIMIT;
 359
 360 /* Hash table to map fds to corresponding socket_info index */
 361 static int *socket_fds_idx;
 362
 363 /* Mutex for syncronizing port selection during swrap_auto_bind() */
 364 static pthread_mutex_t autobind_start_mutex = PTHREAD_MUTEX_INITIALIZER;
 365
 366 /* Mutex to guard the initialization of array of socket_info structures */
 367 static pthread_mutex_t sockets_mutex = PTHREAD_MUTEX_INITIALIZER;
 368
 369 /* Mutex to guard the socket reset in swrap_close() and swrap_remove_stale() */
 370 static pthread_mutex_t socket_reset_mutex = PTHREAD_MUTEX_INITIALIZER;
 371
 372 /* Mutex to synchronize access to first free index in socket_info array */
 373 static pthread_mutex_t first_free_mutex = PTHREAD_MUTEX_INITIALIZER;
 374
 375 /* Mutex to synchronize access to packet capture dump file */
 376 static pthread_mutex_t pcap_dump_mutex = PTHREAD_MUTEX_INITIALIZER;
 377
 378 /* Mutex for synchronizing mtu value fetch*/
 379 static pthread_mutex_t mtu_update_mutex = PTHREAD_MUTEX_INITIALIZER;
 380
 381 /* Function prototypes */
 382
 383 bool socket_wrapper_enabled(void);
 384
 385 #if ! defined(HAVE_CONSTRUCTOR_ATTRIBUTE) && defined(HAVE_PRAGMA_INIT)
 386 /* xlC and other oldschool compilers support (only) this */
 387 #pragma init (swrap_constructor)
 388 #endif
 389 void swrap_constructor(void) CONSTRUCTOR_ATTRIBUTE;
 390 #if ! defined(HAVE_DESTRUCTOR_ATTRIBUTE) && defined(HAVE_PRAGMA_FINI)
 391 #pragma fini (swrap_destructor)
 392 #endif
 393 void swrap_destructor(void) DESTRUCTOR_ATTRIBUTE;
 394
 395 #ifndef HAVE_GETPROGNAME
 396 static const char *getprogname(void)
 397 {
 398 #if defined(HAVE_PROGRAM_INVOCATION_SHORT_NAME)
 399         return program_invocation_short_name;
 400 #elif defined(HAVE_GETEXECNAME)
 401         return getexecname();
 402 #else
 403         return NULL;
 404 #endif /* HAVE_PROGRAM_INVOCATION_SHORT_NAME */
 405 }
 406 #endif /* HAVE_GETPROGNAME */
 407
 408 static void swrap_log(enum swrap_dbglvl_e dbglvl, const char *func, const char *format, ...) PRINTF_ATTRIBUTE(3, 4);
 409 # define SWRAP_LOG(dbglvl, ...) swrap_log((dbglvl), __func__, __VA_ARGS__)
 410
 411 static void swrap_log(enum swrap_dbglvl_e dbglvl,
 412                       const char *func,
 413                       const char *format, ...)
 414 {
 415         char buffer[1024];
 416         va_list va;
 417         const char *d;
 418         unsigned int lvl = 0;
 419         const char *prefix = "SWRAP";
 420         const char *progname = getprogname();
 421
 422         d = getenv("SOCKET_WRAPPER_DEBUGLEVEL");
 423         if (d != NULL) {
 424                 lvl = atoi(d);
 425         }
 426
 427         if (lvl < dbglvl) {
 428                 return;
 429         }
 430
 431         va_start(va, format);
 432         vsnprintf(buffer, sizeof(buffer), format, va);
 433         va_end(va);
 434
 435         switch (dbglvl) {
 436                 case SWRAP_LOG_ERROR:
 437                         prefix = "SWRAP_ERROR";
 438                         break;
 439                 case SWRAP_LOG_WARN:
 440                         prefix = "SWRAP_WARN";
 441                         break;
 442                 case SWRAP_LOG_DEBUG:
 443                         prefix = "SWRAP_DEBUG";
 444                         break;
 445                 case SWRAP_LOG_TRACE:
 446                         prefix = "SWRAP_TRACE";
 447                         break;
 448         }
 449
 450         if (progname == NULL) {
 451                 progname = "<unknown>";
 452         }
 453
 454         fprintf(stderr,
 455                 "%s[%s (%u)] - %s: %s\n",
 456                 prefix,
 457                 progname,
 458                 (unsigned int)getpid(),
 459                 func,
 460                 buffer);
 461 }
 462
 463 /*********************************************************
 464  * SWRAP LOADING LIBC FUNCTIONS
 465  *********************************************************/
 466
 467 #include <dlfcn.h>
 468
 469 #ifdef HAVE_ACCEPT4
 470 typedef int (*__libc_accept4)(int sockfd,
 471                               struct sockaddr *addr,
 472                               socklen_t *addrlen,
 473                               int flags);
 474 #else
 475 typedef int (*__libc_accept)(int sockfd,
 476                              struct sockaddr *addr,
 477                              socklen_t *addrlen);
 478 #endif
 479 typedef int (*__libc_bind)(int sockfd,
 480                            const struct sockaddr *addr,
 481                            socklen_t addrlen);
 482 typedef int (*__libc_close)(int fd);
 483 typedef int (*__libc_connect)(int sockfd,
 484                               const struct sockaddr *addr,
 485                               socklen_t addrlen);
 486 typedef int (*__libc_dup)(int fd);
 487 typedef int (*__libc_dup2)(int oldfd, int newfd);
 488 typedef int (*__libc_fcntl)(int fd, int cmd, ...);
 489 typedef FILE *(*__libc_fopen)(const char *name, const char *mode);
 490 #ifdef HAVE_FOPEN64
 491 typedef FILE *(*__libc_fopen64)(const char *name, const char *mode);
 492 #endif
 493 #ifdef HAVE_EVENTFD
 494 typedef int (*__libc_eventfd)(int count, int flags);
 495 #endif
 496 typedef int (*__libc_getpeername)(int sockfd,
 497                                   struct sockaddr *addr,
 498                                   socklen_t *addrlen);
 499 typedef int (*__libc_getsockname)(int sockfd,
 500                                   struct sockaddr *addr,
 501                                   socklen_t *addrlen);
 502 typedef int (*__libc_getsockopt)(int sockfd,
 503                                int level,
 504                                int optname,
 505                                void *optval,
 506                                socklen_t *optlen);
 507 typedef int (*__libc_ioctl)(int d, unsigned long int request, ...);
 508 typedef int (*__libc_listen)(int sockfd, int backlog);
 509 typedef int (*__libc_open)(const char *pathname, int flags, ...);
 510 #ifdef HAVE_OPEN64
 511 typedef int (*__libc_open64)(const char *pathname, int flags, ...);
 512 #endif /* HAVE_OPEN64 */
 513 typedef int (*__libc_openat)(int dirfd, const char *path, int flags, ...);
 514 typedef int (*__libc_pipe)(int pipefd[2]);
 515 typedef int (*__libc_read)(int fd, void *buf, size_t count);
 516 typedef ssize_t (*__libc_readv)(int fd, const struct iovec *iov, int iovcnt);
 517 typedef int (*__libc_recv)(int sockfd, void *buf, size_t len, int flags);
 518 typedef int (*__libc_recvfrom)(int sockfd,
 519                              void *buf,
 520                              size_t len,
 521                              int flags,
 522                              struct sockaddr *src_addr,
 523                              socklen_t *addrlen);
 524 typedef int (*__libc_recvmsg)(int sockfd, const struct msghdr *msg, int flags);
 525 typedef int (*__libc_send)(int sockfd, const void *buf, size_t len, int flags);
 526 typedef int (*__libc_sendmsg)(int sockfd, const struct msghdr *msg, int flags);
 527 typedef int (*__libc_sendto)(int sockfd,
 528                            const void *buf,
 529                            size_t len,
 530                            int flags,
 531                            const  struct sockaddr *dst_addr,
 532                            socklen_t addrlen);
 533 typedef int (*__libc_setsockopt)(int sockfd,
 534                                int level,
 535                                int optname,
 536                                const void *optval,
 537                                socklen_t optlen);
 538 #ifdef HAVE_SIGNALFD
 539 typedef int (*__libc_signalfd)(int fd, const sigset_t *mask, int flags);
 540 #endif
 541 typedef int (*__libc_socket)(int domain, int type, int protocol);
 542 typedef int (*__libc_socketpair)(int domain, int type, int protocol, int sv[2]);
 543 #ifdef HAVE_TIMERFD_CREATE
 544 typedef int (*__libc_timerfd_create)(int clockid, int flags);
 545 #endif
 546 typedef ssize_t (*__libc_write)(int fd, const void *buf, size_t count);
 547 typedef ssize_t (*__libc_writev)(int fd, const struct iovec *iov, int iovcnt);
 548
 549 #define SWRAP_SYMBOL_ENTRY(i) \
 550         union { \
 551                 __libc_##i f; \
 552                 void *obj; \
 553         } _libc_##i
 554
 555 struct swrap_libc_symbols {
 556 #ifdef HAVE_ACCEPT4
 557         SWRAP_SYMBOL_ENTRY(accept4);
 558 #else
 559         SWRAP_SYMBOL_ENTRY(accept);
 560 #endif
 561         SWRAP_SYMBOL_ENTRY(bind);
 562         SWRAP_SYMBOL_ENTRY(close);
 563         SWRAP_SYMBOL_ENTRY(connect);
 564         SWRAP_SYMBOL_ENTRY(dup);
 565         SWRAP_SYMBOL_ENTRY(dup2);
 566         SWRAP_SYMBOL_ENTRY(fcntl);
 567         SWRAP_SYMBOL_ENTRY(fopen);
 568 #ifdef HAVE_FOPEN64
 569         SWRAP_SYMBOL_ENTRY(fopen64);
 570 #endif
 571 #ifdef HAVE_EVENTFD
 572         SWRAP_SYMBOL_ENTRY(eventfd);
 573 #endif
 574         SWRAP_SYMBOL_ENTRY(getpeername);
 575         SWRAP_SYMBOL_ENTRY(getsockname);
 576         SWRAP_SYMBOL_ENTRY(getsockopt);
 577         SWRAP_SYMBOL_ENTRY(ioctl);
 578         SWRAP_SYMBOL_ENTRY(listen);
 579         SWRAP_SYMBOL_ENTRY(open);
 580 #ifdef HAVE_OPEN64
 581         SWRAP_SYMBOL_ENTRY(open64);
 582 #endif
 583         SWRAP_SYMBOL_ENTRY(openat);
 584         SWRAP_SYMBOL_ENTRY(pipe);
 585         SWRAP_SYMBOL_ENTRY(read);
 586         SWRAP_SYMBOL_ENTRY(readv);
 587         SWRAP_SYMBOL_ENTRY(recv);
 588         SWRAP_SYMBOL_ENTRY(recvfrom);
 589         SWRAP_SYMBOL_ENTRY(recvmsg);
 590         SWRAP_SYMBOL_ENTRY(send);
 591         SWRAP_SYMBOL_ENTRY(sendmsg);
 592         SWRAP_SYMBOL_ENTRY(sendto);
 593         SWRAP_SYMBOL_ENTRY(setsockopt);
 594 #ifdef HAVE_SIGNALFD
 595         SWRAP_SYMBOL_ENTRY(signalfd);
 596 #endif
 597         SWRAP_SYMBOL_ENTRY(socket);
 598         SWRAP_SYMBOL_ENTRY(socketpair);
 599 #ifdef HAVE_TIMERFD_CREATE
 600         SWRAP_SYMBOL_ENTRY(timerfd_create);
 601 #endif
 602         SWRAP_SYMBOL_ENTRY(write);
 603         SWRAP_SYMBOL_ENTRY(writev);
 604 };
 605
 606 struct swrap {
 607         struct {
 608                 void *handle;
 609                 void *socket_handle;
 610                 struct swrap_libc_symbols symbols;
 611         } libc;
 612 };
 613
 614 static struct swrap swrap;
 615
 616 /* prototypes */
 617 static char *socket_wrapper_dir(void);
 618
 619 #define LIBC_NAME "libc.so"
 620
 621 enum swrap_lib {
 622     SWRAP_LIBC,
 623     SWRAP_LIBSOCKET,
 624 };
 625
 626 static const char *swrap_str_lib(enum swrap_lib lib)
 627 {
 628         switch (lib) {
 629         case SWRAP_LIBC:
 630                 return "libc";
 631         case SWRAP_LIBSOCKET:
 632                 return "libsocket";
 633         }
 634
 635         /* Compiler would warn us about unhandled enum value if we get here */
 636         return "unknown";
 637 }
 638
 639 static void *swrap_load_lib_handle(enum swrap_lib lib)
 640 {
 641         int flags = RTLD_LAZY;
 642         void *handle = NULL;
 643         int i;
 644
 645 #ifdef RTLD_DEEPBIND
 646         const char *env_preload = getenv("LD_PRELOAD");
 647         const char *env_deepbind = getenv("SOCKET_WRAPPER_DISABLE_DEEPBIND");
 648         bool enable_deepbind = true;
 649
 650         /* Don't do a deepbind if we run with libasan */
 651         if (env_preload != NULL && strlen(env_preload) < 1024) {
 652                 const char *p = strstr(env_preload, "libasan.so");
 653                 if (p != NULL) {
 654                         enable_deepbind = false;
 655                 }
 656         }
 657
 658         if (env_deepbind != NULL && strlen(env_deepbind) >= 1) {
 659                 enable_deepbind = false;
 660         }
 661
 662         if (enable_deepbind) {
 663                 flags |= RTLD_DEEPBIND;
 664         }
 665 #endif
 666
 667         switch (lib) {
 668         case SWRAP_LIBSOCKET:
 669 #ifdef HAVE_LIBSOCKET
 670                 handle = swrap.libc.socket_handle;
 671                 if (handle == NULL) {
 672                         for (i = 10; i >= 0; i--) {
 673                                 char soname[256] = {0};
 674
 675                                 snprintf(soname, sizeof(soname), "libsocket.so.%d", i);
 676                                 handle = dlopen(soname, flags);
 677                                 if (handle != NULL) {
 678                                         break;
 679                                 }
 680                         }
 681
 682                         swrap.libc.socket_handle = handle;
 683                 }
 684                 break;
 685 #endif
 686         case SWRAP_LIBC:
 687                 handle = swrap.libc.handle;
 688 #ifdef LIBC_SO
 689                 if (handle == NULL) {
 690                         handle = dlopen(LIBC_SO, flags);
 691
 692                         swrap.libc.handle = handle;
 693                 }
 694 #endif
 695                 if (handle == NULL) {
 696                         for (i = 10; i >= 0; i--) {
 697                                 char soname[256] = {0};
 698
 699                                 snprintf(soname, sizeof(soname), "libc.so.%d", i);
 700                                 handle = dlopen(soname, flags);
 701                                 if (handle != NULL) {
 702                                         break;
 703                                 }
 704                         }
 705
 706                         swrap.libc.handle = handle;
 707                 }
 708                 break;
 709         }
 710
 711         if (handle == NULL) {
 712 #ifdef RTLD_NEXT
 713                 handle = swrap.libc.handle = swrap.libc.socket_handle = RTLD_NEXT;
 714 #else
 715                 SWRAP_LOG(SWRAP_LOG_ERROR,
 716                           "Failed to dlopen library: %s",
 717                           dlerror());
 718                 exit(-1);
 719 #endif
 720         }
 721
 722         return handle;
 723 }
 724
 725 static void *_swrap_bind_symbol(enum swrap_lib lib, const char *fn_name)
 726 {
 727         void *handle;
 728         void *func;
 729
 730         handle = swrap_load_lib_handle(lib);
 731
 732         func = dlsym(handle, fn_name);
 733         if (func == NULL) {
 734                 SWRAP_LOG(SWRAP_LOG_ERROR,
 735                           "Failed to find %s: %s",
 736                           fn_name,
 737                           dlerror());
 738                 exit(-1);
 739         }
 740
 741         SWRAP_LOG(SWRAP_LOG_TRACE,
 742                   "Loaded %s from %s",
 743                   fn_name,
 744                   swrap_str_lib(lib));
 745
 746         return func;
 747 }
 748
 749 #define swrap_mutex_lock(m) _swrap_mutex_lock(m, #m, __func__, __LINE__)
 750 static void _swrap_mutex_lock(pthread_mutex_t *mutex, const char *name, const char *caller, unsigned line)
 751 {
 752         int ret;
 753
 754         ret = pthread_mutex_lock(mutex);
 755         if (ret != 0) {
 756                 SWRAP_LOG(SWRAP_LOG_ERROR, "PID(%d):PPID(%d): %s(%u): Couldn't lock pthread mutex(%s) - %s",
 757                           getpid(), getppid(), caller, line, name, strerror(ret));
 758         }
 759 }
 760
 761 #define swrap_mutex_unlock(m) _swrap_mutex_unlock(m, #m, __func__, __LINE__)
 762 static void _swrap_mutex_unlock(pthread_mutex_t *mutex, const char *name, const char *caller, unsigned line)
 763 {
 764         int ret;
 765
 766         ret = pthread_mutex_unlock(mutex);
 767         if (ret != 0) {
 768                 SWRAP_LOG(SWRAP_LOG_ERROR, "PID(%d):PPID(%d): %s(%u): Couldn't unlock pthread mutex(%s) - %s",
 769                           getpid(), getppid(), caller, line, name, strerror(ret));
 770         }
 771 }
 772
 773 /*
 774  * These macros have a thread race condition on purpose!
 775  *
 776  * This is an optimization to avoid locking each time we check if the symbol is
 777  * bound.
 778  */
 779 #define _swrap_bind_symbol_generic(lib, sym_name) do { \
 780         swrap.libc.symbols._libc_##sym_name.obj = \
 781                 _swrap_bind_symbol(lib, #sym_name); \
 782 } while(0);
 783
 784 #define swrap_bind_symbol_libc(sym_name) \
 785         _swrap_bind_symbol_generic(SWRAP_LIBC, sym_name)
 786
 787 #define swrap_bind_symbol_libsocket(sym_name) \
 788         _swrap_bind_symbol_generic(SWRAP_LIBSOCKET, sym_name)
 789
 790 static void swrap_bind_symbol_all(void);
 791
 792 /****************************************************************************
 793  *                               IMPORTANT
 794  ****************************************************************************
 795  *
 796  * Functions especially from libc need to be loaded individually, you can't
 797  * load all at once or gdb will segfault at startup. The same applies to
 798  * valgrind and has probably something todo with with the linker.  So we need
 799  * load each function at the point it is called the first time.
 800  *
 801  ****************************************************************************/
 802
 803 #ifdef HAVE_ACCEPT4
 804 static int libc_accept4(int sockfd,
 805                         struct sockaddr *addr,
 806                         socklen_t *addrlen,
 807                         int flags)
 808 {
 809         swrap_bind_symbol_all();
 810
 811         return swrap.libc.symbols._libc_accept4.f(sockfd, addr, addrlen, flags);
 812 }
 813
 814 #else /* HAVE_ACCEPT4 */
 815
 816 static int libc_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
 817 {
 818         swrap_bind_symbol_all();
 819
 820         return swrap.libc.symbols._libc_accept.f(sockfd, addr, addrlen);
 821 }
 822 #endif /* HAVE_ACCEPT4 */
 823
 824 static int libc_bind(int sockfd,
 825                      const struct sockaddr *addr,
 826                      socklen_t addrlen)
 827 {
 828         swrap_bind_symbol_all();
 829
 830         return swrap.libc.symbols._libc_bind.f(sockfd, addr, addrlen);
 831 }
 832
 833 static int libc_close(int fd)
 834 {
 835         swrap_bind_symbol_all();
 836
 837         return swrap.libc.symbols._libc_close.f(fd);
 838 }
 839
 840 static int libc_connect(int sockfd,
 841                         const struct sockaddr *addr,
 842                         socklen_t addrlen)
 843 {
 844         swrap_bind_symbol_all();
 845
 846         return swrap.libc.symbols._libc_connect.f(sockfd, addr, addrlen);
 847 }
 848
 849 static int libc_dup(int fd)
 850 {
 851         swrap_bind_symbol_all();
 852
 853         return swrap.libc.symbols._libc_dup.f(fd);
 854 }
 855
 856 static int libc_dup2(int oldfd, int newfd)
 857 {
 858         swrap_bind_symbol_all();
 859
 860         return swrap.libc.symbols._libc_dup2.f(oldfd, newfd);
 861 }
 862
 863 #ifdef HAVE_EVENTFD
 864 static int libc_eventfd(int count, int flags)
 865 {
 866         swrap_bind_symbol_all();
 867
 868         return swrap.libc.symbols._libc_eventfd.f(count, flags);
 869 }
 870 #endif
 871
 872 DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE
 873 static int libc_vfcntl(int fd, int cmd, va_list ap)
 874 {
 875         void *arg;
 876         int rc;
 877
 878         swrap_bind_symbol_all();
 879
 880         arg = va_arg(ap, void *);
 881
 882         rc = swrap.libc.symbols._libc_fcntl.f(fd, cmd, arg);
 883
 884         return rc;
 885 }
 886
 887 static int libc_getpeername(int sockfd,
 888                             struct sockaddr *addr,
 889                             socklen_t *addrlen)
 890 {
 891         swrap_bind_symbol_all();
 892
 893         return swrap.libc.symbols._libc_getpeername.f(sockfd, addr, addrlen);
 894 }
 895
 896 static int libc_getsockname(int sockfd,
 897                             struct sockaddr *addr,
 898                             socklen_t *addrlen)
 899 {
 900         swrap_bind_symbol_all();
 901
 902         return swrap.libc.symbols._libc_getsockname.f(sockfd, addr, addrlen);
 903 }
 904
 905 static int libc_getsockopt(int sockfd,
 906                            int level,
 907                            int optname,
 908                            void *optval,
 909                            socklen_t *optlen)
 910 {
 911         swrap_bind_symbol_all();
 912
 913         return swrap.libc.symbols._libc_getsockopt.f(sockfd,
 914                                                      level,
 915                                                      optname,
 916                                                      optval,
 917                                                      optlen);
 918 }
 919
 920 DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE
 921 static int libc_vioctl(int d, unsigned long int request, va_list ap)
 922 {
 923         void *arg;
 924         int rc;
 925
 926         swrap_bind_symbol_all();
 927
 928         arg = va_arg(ap, void *);
 929
 930         rc = swrap.libc.symbols._libc_ioctl.f(d, request, arg);
 931
 932         return rc;
 933 }
 934
 935 static int libc_listen(int sockfd, int backlog)
 936 {
 937         swrap_bind_symbol_all();
 938
 939         return swrap.libc.symbols._libc_listen.f(sockfd, backlog);
 940 }
 941
 942 static FILE *libc_fopen(const char *name, const char *mode)
 943 {
 944         swrap_bind_symbol_all();
 945
 946         return swrap.libc.symbols._libc_fopen.f(name, mode);
 947 }
 948
 949 #ifdef HAVE_FOPEN64
 950 static FILE *libc_fopen64(const char *name, const char *mode)
 951 {
 952         swrap_bind_symbol_all();
 953
 954         return swrap.libc.symbols._libc_fopen64.f(name, mode);
 955 }
 956 #endif /* HAVE_FOPEN64 */
 957
 958 static int libc_vopen(const char *pathname, int flags, va_list ap)
 959 {
 960         int mode = 0;
 961         int fd;
 962
 963         swrap_bind_symbol_all();
 964
 965         if (flags & O_CREAT) {
 966                 mode = va_arg(ap, int);
 967         }
 968         fd = swrap.libc.symbols._libc_open.f(pathname, flags, (mode_t)mode);
 969
 970         return fd;
 971 }
 972
 973 static int libc_open(const char *pathname, int flags, ...)
 974 {
 975         va_list ap;
 976         int fd;
 977
 978         va_start(ap, flags);
 979         fd = libc_vopen(pathname, flags, ap);
 980         va_end(ap);
 981
 982         return fd;
 983 }
 984
 985 #ifdef HAVE_OPEN64
 986 static int libc_vopen64(const char *pathname, int flags, va_list ap)
 987 {
 988         int mode = 0;
 989         int fd;
 990
 991         swrap_bind_symbol_all();
 992
 993         if (flags & O_CREAT) {
 994                 mode = va_arg(ap, int);
 995         }
 996         fd = swrap.libc.symbols._libc_open64.f(pathname, flags, (mode_t)mode);
 997
 998         return fd;
 999 }
1000 #endif /* HAVE_OPEN64 */
1001
1002 static int libc_vopenat(int dirfd, const char *path, int flags, va_list ap)
1003 {
1004         int mode = 0;
1005         int fd;
1006
1007         swrap_bind_symbol_all();
1008
1009         if (flags & O_CREAT) {
1010                 mode = va_arg(ap, int);
1011         }
1012         fd = swrap.libc.symbols._libc_openat.f(dirfd,
1013                                                path,
1014                                                flags,
1015                                                (mode_t)mode);
1016
1017         return fd;
1018 }
1019
1020 #if 0
1021 static int libc_openat(int dirfd, const char *path, int flags, ...)
1022 {
1023         va_list ap;
1024         int fd;
1025
1026         va_start(ap, flags);
1027         fd = libc_vopenat(dirfd, path, flags, ap);
1028         va_end(ap);
1029
1030         return fd;
1031 }
1032 #endif
1033
1034 static int libc_pipe(int pipefd[2])
1035 {
1036         swrap_bind_symbol_all();
1037
1038         return swrap.libc.symbols._libc_pipe.f(pipefd);
1039 }
1040
1041 static int libc_read(int fd, void *buf, size_t count)
1042 {
1043         swrap_bind_symbol_all();
1044
1045         return swrap.libc.symbols._libc_read.f(fd, buf, count);
1046 }
1047
1048 static ssize_t libc_readv(int fd, const struct iovec *iov, int iovcnt)
1049 {
1050         swrap_bind_symbol_all();
1051
1052         return swrap.libc.symbols._libc_readv.f(fd, iov, iovcnt);
1053 }
1054
1055 static int libc_recv(int sockfd, void *buf, size_t len, int flags)
1056 {
1057         swrap_bind_symbol_all();
1058
1059         return swrap.libc.symbols._libc_recv.f(sockfd, buf, len, flags);
1060 }
1061
1062 static int libc_recvfrom(int sockfd,
1063                          void *buf,
1064                          size_t len,
1065                          int flags,
1066                          struct sockaddr *src_addr,
1067                          socklen_t *addrlen)
1068 {
1069         swrap_bind_symbol_all();
1070
1071         return swrap.libc.symbols._libc_recvfrom.f(sockfd,
1072                                                    buf,
1073                                                    len,
1074                                                    flags,
1075                                                    src_addr,
1076                                                    addrlen);
1077 }
1078
1079 static int libc_recvmsg(int sockfd, struct msghdr *msg, int flags)
1080 {
1081         swrap_bind_symbol_all();
1082
1083         return swrap.libc.symbols._libc_recvmsg.f(sockfd, msg, flags);
1084 }
1085
1086 static int libc_send(int sockfd, const void *buf, size_t len, int flags)
1087 {
1088         swrap_bind_symbol_all();
1089
1090         return swrap.libc.symbols._libc_send.f(sockfd, buf, len, flags);
1091 }
1092
1093 static int libc_sendmsg(int sockfd, const struct msghdr *msg, int flags)
1094 {
1095         swrap_bind_symbol_all();
1096
1097         return swrap.libc.symbols._libc_sendmsg.f(sockfd, msg, flags);
1098 }
1099
1100 static int libc_sendto(int sockfd,
1101                        const void *buf,
1102                        size_t len,
1103                        int flags,
1104                        const  struct sockaddr *dst_addr,
1105                        socklen_t addrlen)
1106 {
1107         swrap_bind_symbol_all();
1108
1109         return swrap.libc.symbols._libc_sendto.f(sockfd,
1110                                                  buf,
1111                                                  len,
1112                                                  flags,
1113                                                  dst_addr,
1114                                                  addrlen);
1115 }
1116
1117 static int libc_setsockopt(int sockfd,
1118                            int level,
1119                            int optname,
1120                            const void *optval,
1121                            socklen_t optlen)
1122 {
1123         swrap_bind_symbol_all();
1124
1125         return swrap.libc.symbols._libc_setsockopt.f(sockfd,
1126                                                      level,
1127                                                      optname,
1128                                                      optval,
1129                                                      optlen);
1130 }
1131
1132 #ifdef HAVE_SIGNALFD
1133 static int libc_signalfd(int fd, const sigset_t *mask, int flags)
1134 {
1135         swrap_bind_symbol_all();
1136
1137         return swrap.libc.symbols._libc_signalfd.f(fd, mask, flags);
1138 }
1139 #endif
1140
1141 static int libc_socket(int domain, int type, int protocol)
1142 {
1143         swrap_bind_symbol_all();
1144
1145         return swrap.libc.symbols._libc_socket.f(domain, type, protocol);
1146 }
1147
1148 static int libc_socketpair(int domain, int type, int protocol, int sv[2])
1149 {
1150         swrap_bind_symbol_all();
1151
1152         return swrap.libc.symbols._libc_socketpair.f(domain, type, protocol, sv);
1153 }
1154
1155 #ifdef HAVE_TIMERFD_CREATE
1156 static int libc_timerfd_create(int clockid, int flags)
1157 {
1158         swrap_bind_symbol_all();
1159
1160         return swrap.libc.symbols._libc_timerfd_create.f(clockid, flags);
1161 }
1162 #endif
1163
1164 static ssize_t libc_write(int fd, const void *buf, size_t count)
1165 {
1166         swrap_bind_symbol_all();
1167
1168         return swrap.libc.symbols._libc_write.f(fd, buf, count);
1169 }
1170
1171 static ssize_t libc_writev(int fd, const struct iovec *iov, int iovcnt)
1172 {
1173         swrap_bind_symbol_all();
1174
1175         return swrap.libc.symbols._libc_writev.f(fd, iov, iovcnt);
1176 }
1177
1178 /* DO NOT call this function during library initialization! */
1179 static void __swrap_bind_symbol_all_once(void)
1180 {
1181 #ifdef HAVE_ACCEPT4
1182         swrap_bind_symbol_libsocket(accept4);
1183 #else
1184         swrap_bind_symbol_libsocket(accept);
1185 #endif
1186         swrap_bind_symbol_libsocket(bind);
1187         swrap_bind_symbol_libc(close);
1188         swrap_bind_symbol_libsocket(connect);
1189         swrap_bind_symbol_libc(dup);
1190         swrap_bind_symbol_libc(dup2);
1191         swrap_bind_symbol_libc(fcntl);
1192         swrap_bind_symbol_libc(fopen);
1193 #ifdef HAVE_FOPEN64
1194         swrap_bind_symbol_libc(fopen64);
1195 #endif
1196 #ifdef HAVE_EVENTFD
1197         swrap_bind_symbol_libc(eventfd);
1198 #endif
1199         swrap_bind_symbol_libsocket(getpeername);
1200         swrap_bind_symbol_libsocket(getsockname);
1201         swrap_bind_symbol_libsocket(getsockopt);
1202         swrap_bind_symbol_libc(ioctl);
1203         swrap_bind_symbol_libsocket(listen);
1204         swrap_bind_symbol_libc(open);
1205 #ifdef HAVE_OPEN64
1206         swrap_bind_symbol_libc(open64);
1207 #endif
1208         swrap_bind_symbol_libc(openat);
1209         swrap_bind_symbol_libsocket(pipe);
1210         swrap_bind_symbol_libc(read);
1211         swrap_bind_symbol_libsocket(readv);
1212         swrap_bind_symbol_libsocket(recv);
1213         swrap_bind_symbol_libsocket(recvfrom);
1214         swrap_bind_symbol_libsocket(recvmsg);
1215         swrap_bind_symbol_libsocket(send);
1216         swrap_bind_symbol_libsocket(sendmsg);
1217         swrap_bind_symbol_libsocket(sendto);
1218         swrap_bind_symbol_libsocket(setsockopt);
1219 #ifdef HAVE_SIGNALFD
1220         swrap_bind_symbol_libsocket(signalfd);
1221 #endif
1222         swrap_bind_symbol_libsocket(socket);
1223         swrap_bind_symbol_libsocket(socketpair);
1224 #ifdef HAVE_TIMERFD_CREATE
1225         swrap_bind_symbol_libc(timerfd_create);
1226 #endif
1227         swrap_bind_symbol_libc(write);
1228         swrap_bind_symbol_libsocket(writev);
1229 }
1230
1231 static void swrap_bind_symbol_all(void)
1232 {
1233         static pthread_once_t all_symbol_binding_once = PTHREAD_ONCE_INIT;
1234
1235         pthread_once(&all_symbol_binding_once, __swrap_bind_symbol_all_once);
1236 }
1237
1238 /*********************************************************
1239  * SWRAP HELPER FUNCTIONS
1240  *********************************************************/
1241
1242 /*
1243  * We return 127.0.0.0 (default) or 10.53.57.0.
1244  *
1245  * This can be controlled by:
1246  * SOCKET_WRAPPER_IPV4_NETWORK=127.0.0.0 (default)
1247  * or
1248  * SOCKET_WRAPPER_IPV4_NETWORK=10.53.57.0
1249  */
1250 static in_addr_t swrap_ipv4_net(void)
1251 {
1252         static int initialized;
1253         static in_addr_t hv;
1254         const char *net_str = NULL;
1255         struct in_addr nv;
1256         int ret;
1257
1258         if (initialized) {
1259                 return hv;
1260         }
1261         initialized = 1;
1262
1263         net_str = getenv("SOCKET_WRAPPER_IPV4_NETWORK");
1264         if (net_str == NULL) {
1265                 net_str = "127.0.0.0";
1266         }
1267
1268         ret = inet_pton(AF_INET, net_str, &nv);
1269         if (ret <= 0) {
1270                 SWRAP_LOG(SWRAP_LOG_ERROR,
1271                           "INVALID IPv4 Network [%s]",
1272                           net_str);
1273                 abort();
1274         }
1275
1276         hv = ntohl(nv.s_addr);
1277
1278         switch (hv) {
1279         case 0x7f000000:
1280                 /* 127.0.0.0 */
1281                 break;
1282         case 0x0a353900:
1283                 /* 10.53.57.0 */
1284                 break;
1285         default:
1286                 SWRAP_LOG(SWRAP_LOG_ERROR,
1287                           "INVALID IPv4 Network [%s][0x%x] should be "
1288                           "127.0.0.0 or 10.53.57.0",
1289                           net_str, (unsigned)hv);
1290                 abort();
1291         }
1292
1293         return hv;
1294 }
1295
1296 /*
1297  * This returns 127.255.255.255 or 10.255.255.255
1298  */
1299 static in_addr_t swrap_ipv4_bcast(void)
1300 {
1301         in_addr_t hv;
1302
1303         hv = swrap_ipv4_net();
1304         hv |= IN_CLASSA_HOST;
1305
1306         return hv;
1307 }
1308
1309 /*
1310  * This returns 127.0.0.${iface} or 10.53.57.${iface}
1311  */
1312 static in_addr_t swrap_ipv4_iface(unsigned int iface)
1313 {
1314         in_addr_t hv;
1315
1316         if (iface == 0 || iface > MAX_WRAPPED_INTERFACES) {
1317                 SWRAP_LOG(SWRAP_LOG_ERROR,
1318                           "swrap_ipv4_iface(%u) invalid!",
1319                           iface);
1320                 abort();
1321                 return -1;
1322         }
1323
1324         hv = swrap_ipv4_net();
1325         hv |= iface;
1326
1327         return hv;
1328 }
1329
1330 #ifdef HAVE_IPV6
1331 /*
1332  * FD00::5357:5FXX
1333  */
1334 static const struct in6_addr *swrap_ipv6(void)
1335 {
1336         static struct in6_addr v;
1337         static int initialized;
1338         int ret;
1339
1340         if (initialized) {
1341                 return &v;
1342         }
1343         initialized = 1;
1344
1345         ret = inet_pton(AF_INET6, "FD00::5357:5F00", &v);
1346         if (ret <= 0) {
1347                 abort();
1348         }
1349
1350         return &v;
1351 }
1352 #endif
1353
1354 static void set_port(int family, int prt, struct swrap_address *addr)
1355 {
1356         switch (family) {
1357         case AF_INET:
1358                 addr->sa.in.sin_port = htons(prt);
1359                 break;
1360 #ifdef HAVE_IPV6
1361         case AF_INET6:
1362                 addr->sa.in6.sin6_port = htons(prt);
1363                 break;
1364 #endif
1365         }
1366 }
1367
1368 static size_t socket_length(int family)
1369 {
1370         switch (family) {
1371         case AF_INET:
1372                 return sizeof(struct sockaddr_in);
1373 #ifdef HAVE_IPV6
1374         case AF_INET6:
1375                 return sizeof(struct sockaddr_in6);
1376 #endif
1377         }
1378         return 0;
1379 }
1380
1381 static struct socket_info *swrap_get_socket_info(int si_index)
1382 {
1383         return (struct socket_info *)(&(sockets[si_index].info));
1384 }
1385
1386 static int swrap_get_refcount(struct socket_info *si)
1387 {
1388         struct socket_info_container *sic = SOCKET_INFO_CONTAINER(si);
1389         return sic->meta.refcount;
1390 }
1391
1392 static void swrap_inc_refcount(struct socket_info *si)
1393 {
1394         struct socket_info_container *sic = SOCKET_INFO_CONTAINER(si);
1395
1396         sic->meta.refcount += 1;
1397 }
1398
1399 static void swrap_dec_refcount(struct socket_info *si)
1400 {
1401         struct socket_info_container *sic = SOCKET_INFO_CONTAINER(si);
1402
1403         sic->meta.refcount -= 1;
1404 }
1405
1406 static int swrap_get_next_free(struct socket_info *si)
1407 {
1408         struct socket_info_container *sic = SOCKET_INFO_CONTAINER(si);
1409
1410         return sic->meta.next_free;
1411 }
1412
1413 static void swrap_set_next_free(struct socket_info *si, int next_free)
1414 {
1415         struct socket_info_container *sic = SOCKET_INFO_CONTAINER(si);
1416
1417         sic->meta.next_free = next_free;
1418 }
1419
1420 static int swrap_un_path(struct sockaddr_un *un,
1421                          const char *swrap_dir,
1422                          char type,
1423                          unsigned int iface,
1424                          unsigned int prt)
1425 {
1426         int ret;
1427
1428         ret = snprintf(un->sun_path,
1429                        sizeof(un->sun_path),
1430                        "%s/"SOCKET_FORMAT,
1431                        swrap_dir,
1432                        type,
1433                        iface,
1434                        prt);
1435         if ((size_t)ret >= sizeof(un->sun_path)) {
1436                 return ENAMETOOLONG;
1437         }
1438
1439         return 0;
1440 }
1441
1442 static int swrap_un_path_EINVAL(struct sockaddr_un *un,
1443                                 const char *swrap_dir)
1444 {
1445         int ret;
1446
1447         ret = snprintf(un->sun_path,
1448                        sizeof(un->sun_path),
1449                        "%s/EINVAL",
1450                        swrap_dir);
1451
1452         if ((size_t)ret >= sizeof(un->sun_path)) {
1453                 return ENAMETOOLONG;
1454         }
1455
1456         return 0;
1457 }
1458
1459 static bool swrap_dir_usable(const char *swrap_dir)
1460 {
1461         struct sockaddr_un un;
1462         int ret;
1463
1464         ret = swrap_un_path(&un, swrap_dir, SOCKET_TYPE_CHAR_TCP, 0, 0);
1465         if (ret == 0) {
1466                 return true;
1467         }
1468
1469         ret = swrap_un_path_EINVAL(&un, swrap_dir);
1470         if (ret == 0) {
1471                 return true;
1472         }
1473
1474         return false;
1475 }
1476
1477 static char *socket_wrapper_dir(void)
1478 {
1479         char *swrap_dir = NULL;
1480         char *s = getenv("SOCKET_WRAPPER_DIR");
1481         char *t;
1482         bool ok;
1483
1484         if (s == NULL || s[0] == '\0') {
1485                 SWRAP_LOG(SWRAP_LOG_WARN, "SOCKET_WRAPPER_DIR not set");
1486                 return NULL;
1487         }
1488
1489         swrap_dir = realpath(s, NULL);
1490         if (swrap_dir == NULL) {
1491                 SWRAP_LOG(SWRAP_LOG_ERROR,
1492                           "Unable to resolve socket_wrapper dir path: %s - %s",
1493                           s,
1494                           strerror(errno));
1495                 abort();
1496         }
1497
1498         ok = swrap_dir_usable(swrap_dir);
1499         if (ok) {
1500                 goto done;
1501         }
1502
1503         free(swrap_dir);
1504
1505         ok = swrap_dir_usable(s);
1506         if (!ok) {
1507                 SWRAP_LOG(SWRAP_LOG_ERROR, "SOCKET_WRAPPER_DIR is too long");
1508                 abort();
1509         }
1510
1511         t = getenv("SOCKET_WRAPPER_DIR_ALLOW_ORIG");
1512         if (t == NULL) {
1513                 SWRAP_LOG(SWRAP_LOG_ERROR,
1514                           "realpath(SOCKET_WRAPPER_DIR) too long and "
1515                           "SOCKET_WRAPPER_DIR_ALLOW_ORIG not set");
1516                 abort();
1517
1518         }
1519
1520         swrap_dir = strdup(s);
1521         if (swrap_dir == NULL) {
1522                 SWRAP_LOG(SWRAP_LOG_ERROR,
1523                           "Unable to duplicate socket_wrapper dir path");
1524                 abort();
1525         }
1526
1527         SWRAP_LOG(SWRAP_LOG_WARN,
1528                   "realpath(SOCKET_WRAPPER_DIR) too long, "
1529                   "using original SOCKET_WRAPPER_DIR\n");
1530
1531 done:
1532         SWRAP_LOG(SWRAP_LOG_TRACE, "socket_wrapper_dir: %s", swrap_dir);
1533         return swrap_dir;
1534 }
1535
1536 static unsigned int socket_wrapper_mtu(void)
1537 {
1538         static unsigned int max_mtu = 0;
1539         unsigned int tmp;
1540         const char *s;
1541         char *endp;
1542
1543         swrap_mutex_lock(&mtu_update_mutex);
1544
1545         if (max_mtu != 0) {
1546                 goto done;
1547         }
1548
1549         max_mtu = SOCKET_WRAPPER_MTU_DEFAULT;
1550
1551         s = getenv("SOCKET_WRAPPER_MTU");
1552         if (s == NULL) {
1553                 goto done;
1554         }
1555
1556         tmp = strtol(s, &endp, 10);
1557         if (s == endp) {
1558                 goto done;
1559         }
1560
1561         if (tmp < SOCKET_WRAPPER_MTU_MIN || tmp > SOCKET_WRAPPER_MTU_MAX) {
1562                 goto done;
1563         }
1564         max_mtu = tmp;
1565
1566 done:
1567         swrap_mutex_unlock(&mtu_update_mutex);
1568         return max_mtu;
1569 }
1570
1571 static int _socket_wrapper_init_mutex(pthread_mutex_t *m, const char *name)
1572 {
1573         pthread_mutexattr_t ma;
1574         bool need_destroy = false;
1575         int ret = 0;
1576
1577 #define __CHECK(cmd) do { \
1578         ret = cmd; \
1579         if (ret != 0) { \
1580                 SWRAP_LOG(SWRAP_LOG_ERROR, \
1581                           "%s: %s - failed %d", \
1582                           name, #cmd, ret); \
1583                 goto done; \
1584         } \
1585 } while(0)
1586
1587         *m = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
1588         __CHECK(pthread_mutexattr_init(&ma));
1589         need_destroy = true;
1590         __CHECK(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK));
1591         __CHECK(pthread_mutex_init(m, &ma));
1592 done:
1593         if (need_destroy) {
1594                 pthread_mutexattr_destroy(&ma);
1595         }
1596         return ret;
1597 }
1598
1599 static size_t socket_wrapper_max_sockets(void)
1600 {
1601         const char *s;
1602         size_t tmp;
1603         char *endp;
1604
1605         if (socket_info_max != 0) {
1606                 return socket_info_max;
1607         }
1608
1609         socket_info_max = SOCKET_WRAPPER_MAX_SOCKETS_DEFAULT;
1610
1611         s = getenv("SOCKET_WRAPPER_MAX_SOCKETS");
1612         if (s == NULL || s[0] == '\0') {
1613                 goto done;
1614         }
1615
1616         tmp = strtoul(s, &endp, 10);
1617         if (s == endp) {
1618                 goto done;
1619         }
1620         if (tmp == 0) {
1621                 tmp = SOCKET_WRAPPER_MAX_SOCKETS_DEFAULT;
1622                 SWRAP_LOG(SWRAP_LOG_ERROR,
1623                           "Invalid number of sockets specified, "
1624                           "using default (%zu)",
1625                           tmp);
1626         }
1627
1628         if (tmp > SOCKET_WRAPPER_MAX_SOCKETS_LIMIT) {
1629                 tmp = SOCKET_WRAPPER_MAX_SOCKETS_LIMIT;
1630                 SWRAP_LOG(SWRAP_LOG_ERROR,
1631                           "Invalid number of sockets specified, "
1632                           "using maximum (%zu).",
1633                           tmp);
1634         }
1635
1636         socket_info_max = tmp;
1637
1638 done:
1639         return socket_info_max;
1640 }
1641
1642 static void socket_wrapper_init_fds_idx(void)
1643 {
1644         int *tmp = NULL;
1645         size_t i;
1646
1647         if (socket_fds_idx != NULL) {
1648                 return;
1649         }
1650
1651         tmp = (int *)calloc(socket_fds_max, sizeof(int));
1652         if (tmp == NULL) {
1653                 SWRAP_LOG(SWRAP_LOG_ERROR,
1654                           "Failed to allocate socket fds index array: %s",
1655                           strerror(errno));
1656                 exit(-1);
1657         }
1658
1659         for (i = 0; i < socket_fds_max; i++) {
1660                 tmp[i] = -1;
1661         }
1662
1663         socket_fds_idx = tmp;
1664 }
1665
1666 static void socket_wrapper_init_sockets(void)
1667 {
1668         size_t max_sockets;
1669         size_t i;
1670         int ret = 0;
1671
1672         swrap_bind_symbol_all();
1673
1674         swrap_mutex_lock(&sockets_mutex);
1675
1676         if (sockets != NULL) {
1677                 swrap_mutex_unlock(&sockets_mutex);
1678                 return;
1679         }
1680
1681         SWRAP_LOG(SWRAP_LOG_DEBUG,
1682                   "SOCKET_WRAPPER_PACKAGE[%s] SOCKET_WRAPPER_VERSION[%s]",
1683                   SOCKET_WRAPPER_PACKAGE, SOCKET_WRAPPER_VERSION);
1684
1685         /*
1686          * Intialize the static cache early before
1687          * any thread is able to start.
1688          */
1689         (void)swrap_ipv4_net();
1690
1691         socket_wrapper_init_fds_idx();
1692
1693         /* Needs to be called inside the sockets_mutex lock here. */
1694         max_sockets = socket_wrapper_max_sockets();
1695
1696         sockets = (struct socket_info_container *)calloc(max_sockets,
1697                                         sizeof(struct socket_info_container));
1698
1699         if (sockets == NULL) {
1700                 SWRAP_LOG(SWRAP_LOG_ERROR,
1701                           "Failed to allocate sockets array: %s",
1702                           strerror(errno));
1703                 swrap_mutex_unlock(&sockets_mutex);
1704                 exit(-1);
1705         }
1706
1707         swrap_mutex_lock(&first_free_mutex);
1708
1709         first_free = 0;
1710
1711         for (i = 0; i < max_sockets; i++) {
1712                 swrap_set_next_free(&sockets[i].info, i+1);
1713                 sockets[i].meta.mutex = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
1714         }
1715
1716         for (i = 0; i < max_sockets; i++) {
1717                 ret = socket_wrapper_init_mutex(&sockets[i].meta.mutex);
1718                 if (ret != 0) {
1719                         SWRAP_LOG(SWRAP_LOG_ERROR,
1720                                   "Failed to initialize pthread mutex i=%zu", i);
1721                         goto done;
1722                 }
1723         }
1724
1725         /* mark the end of the free list */
1726         swrap_set_next_free(&sockets[max_sockets-1].info, -1);
1727
1728 done:
1729         swrap_mutex_unlock(&first_free_mutex);
1730         swrap_mutex_unlock(&sockets_mutex);
1731         if (ret != 0) {
1732                 exit(-1);
1733         }
1734 }
1735
1736 bool socket_wrapper_enabled(void)
1737 {
1738         char *s = socket_wrapper_dir();
1739
1740         if (s == NULL) {
1741                 return false;
1742         }
1743
1744         SAFE_FREE(s);
1745
1746         socket_wrapper_init_sockets();
1747
1748         return true;
1749 }
1750
1751 static unsigned int socket_wrapper_default_iface(void)
1752 {
1753         const char *s = getenv("SOCKET_WRAPPER_DEFAULT_IFACE");
1754         if (s) {
1755                 unsigned int iface;
1756                 if (sscanf(s, "%u", &iface) == 1) {
1757                         if (iface >= 1 && iface <= MAX_WRAPPED_INTERFACES) {
1758                                 return iface;
1759                         }
1760                 }
1761         }
1762
1763         return 1;/* 127.0.0.1 */
1764 }
1765
1766 static void set_socket_info_index(int fd, int idx)
1767 {
1768         SWRAP_LOG(SWRAP_LOG_TRACE,
1769                   "fd=%d idx=%d",
1770                   fd, idx);
1771         socket_fds_idx[fd] = idx;
1772         /* This builtin issues a full memory barrier. */
1773         __sync_synchronize();
1774 }
1775
1776 static void reset_socket_info_index(int fd)
1777 {
1778         SWRAP_LOG(SWRAP_LOG_TRACE,
1779                   "fd=%d idx=%d",
1780                   fd, -1);
1781         set_socket_info_index(fd, -1);
1782 }
1783
1784 static int find_socket_info_index(int fd)
1785 {
1786         if (fd < 0) {
1787                 return -1;
1788         }
1789
1790         if (socket_fds_idx == NULL) {
1791                 return -1;
1792         }
1793
1794         if ((size_t)fd >= socket_fds_max) {
1795                 /*
1796                  * Do not add a log here as some applications do stupid things
1797                  * like:
1798                  *
1799                  *     for (fd = 0; fd <= getdtablesize(); fd++) {
1800                  *         close(fd)
1801                  *     };
1802                  *
1803                  * This would produce millions of lines of debug messages.
1804                  */
1805 #if 0
1806                 SWRAP_LOG(SWRAP_LOG_ERROR,
1807                           "Looking for a socket info for the fd %d is over the "
1808                           "max socket index limit of %zu.",
1809                           fd,
1810                           socket_fds_max);
1811 #endif
1812                 return -1;
1813         }
1814
1815         /* This builtin issues a full memory barrier. */
1816         __sync_synchronize();
1817         return socket_fds_idx[fd];
1818 }
1819
1820 static int swrap_add_socket_info(const struct socket_info *si_input)
1821 {
1822         struct socket_info *si = NULL;
1823         int si_index = -1;
1824
1825         if (si_input == NULL) {
1826                 errno = EINVAL;
1827                 return -1;
1828         }
1829
1830         swrap_mutex_lock(&first_free_mutex);
1831         if (first_free == -1) {
1832                 errno = ENFILE;
1833                 goto out;
1834         }
1835
1836         si_index = first_free;
1837         si = swrap_get_socket_info(si_index);
1838
1839         SWRAP_LOCK_SI(si);
1840
1841         first_free = swrap_get_next_free(si);
1842         *si = *si_input;
1843         swrap_inc_refcount(si);
1844
1845         SWRAP_UNLOCK_SI(si);
1846
1847 out:
1848         swrap_mutex_unlock(&first_free_mutex);
1849
1850         return si_index;
1851 }
1852
1853 static int swrap_create_socket(struct socket_info *si, int fd)
1854 {
1855         int idx;
1856
1857         if ((size_t)fd >= socket_fds_max) {
1858                 SWRAP_LOG(SWRAP_LOG_ERROR,
1859                           "The max socket index limit of %zu has been reached, "
1860                           "trying to add %d",
1861                           socket_fds_max,
1862                           fd);
1863                 errno = EMFILE;
1864                 return -1;
1865         }
1866
1867         idx = swrap_add_socket_info(si);
1868         if (idx == -1) {
1869                 return -1;
1870         }
1871
1872         set_socket_info_index(fd, idx);
1873
1874         return idx;
1875 }
1876
1877 static int convert_un_in(const struct sockaddr_un *un, struct sockaddr *in, socklen_t *len)
1878 {
1879         unsigned int iface;
1880         unsigned int prt;
1881         const char *p;
1882         char type;
1883
1884         p = strrchr(un->sun_path, '/');
1885         if (p) p++; else p = un->sun_path;
1886
1887         if (sscanf(p, SOCKET_FORMAT, &type, &iface, &prt) != 3) {
1888                 SWRAP_LOG(SWRAP_LOG_ERROR, "sun_path[%s] p[%s]",
1889                           un->sun_path, p);
1890                 errno = EINVAL;
1891                 return -1;
1892         }
1893
1894         if (iface == 0 || iface > MAX_WRAPPED_INTERFACES) {
1895                 SWRAP_LOG(SWRAP_LOG_ERROR, "type %c iface %u port %u",
1896                           type, iface, prt);
1897                 errno = EINVAL;
1898                 return -1;
1899         }
1900
1901         if (prt > 0xFFFF) {
1902                 SWRAP_LOG(SWRAP_LOG_ERROR, "type %c iface %u port %u",
1903                           type, iface, prt);
1904                 errno = EINVAL;
1905                 return -1;
1906         }
1907
1908         SWRAP_LOG(SWRAP_LOG_TRACE, "type %c iface %u port %u",
1909                   type, iface, prt);
1910
1911         switch(type) {
1912         case SOCKET_TYPE_CHAR_TCP:
1913         case SOCKET_TYPE_CHAR_UDP: {
1914                 struct sockaddr_in *in2 = (struct sockaddr_in *)(void *)in;
1915
1916                 if ((*len) < sizeof(*in2)) {
1917                         SWRAP_LOG(SWRAP_LOG_ERROR,
1918                                   "V4: *len(%zu) < sizeof(*in2)=%zu",
1919                                   (size_t)*len, sizeof(*in2));
1920                         errno = EINVAL;
1921                         return -1;
1922                 }
1923
1924                 memset(in2, 0, sizeof(*in2));
1925                 in2->sin_family = AF_INET;
1926                 in2->sin_addr.s_addr = htonl(swrap_ipv4_iface(iface));
1927                 in2->sin_port = htons(prt);
1928
1929                 *len = sizeof(*in2);
1930                 break;
1931         }
1932 #ifdef HAVE_IPV6
1933         case SOCKET_TYPE_CHAR_TCP_V6:
1934         case SOCKET_TYPE_CHAR_UDP_V6: {
1935                 struct sockaddr_in6 *in2 = (struct sockaddr_in6 *)(void *)in;
1936
1937                 if ((*len) < sizeof(*in2)) {
1938                         SWRAP_LOG(SWRAP_LOG_ERROR,
1939                                   "V6: *len(%zu) < sizeof(*in2)=%zu",
1940                                   (size_t)*len, sizeof(*in2));
1941                         SWRAP_LOG(SWRAP_LOG_ERROR, "LINE:%d", __LINE__);
1942                         errno = EINVAL;
1943                         return -1;
1944                 }
1945
1946                 memset(in2, 0, sizeof(*in2));
1947                 in2->sin6_family = AF_INET6;
1948                 in2->sin6_addr = *swrap_ipv6();
1949                 in2->sin6_addr.s6_addr[15] = iface;
1950                 in2->sin6_port = htons(prt);
1951
1952                 *len = sizeof(*in2);
1953                 break;
1954         }
1955 #endif
1956         default:
1957                 SWRAP_LOG(SWRAP_LOG_ERROR, "type %c iface %u port %u",
1958                           type, iface, prt);
1959                 errno = EINVAL;
1960                 return -1;
1961         }
1962
1963         return 0;
1964 }
1965
1966 static int convert_in_un_remote(struct socket_info *si, const struct sockaddr *inaddr, struct sockaddr_un *un,
1967                                 int *bcast)
1968 {
1969         char type = '\0';
1970         unsigned int prt;
1971         unsigned int iface;
1972         int is_bcast = 0;
1973         char *swrap_dir = NULL;
1974
1975         if (bcast) *bcast = 0;
1976
1977         switch (inaddr->sa_family) {
1978         case AF_INET: {
1979                 const struct sockaddr_in *in =
1980                     (const struct sockaddr_in *)(const void *)inaddr;
1981                 unsigned int addr = ntohl(in->sin_addr.s_addr);
1982                 char u_type = '\0';
1983                 char b_type = '\0';
1984                 char a_type = '\0';
1985                 const unsigned int sw_net_addr = swrap_ipv4_net();
1986                 const unsigned int sw_bcast_addr = swrap_ipv4_bcast();
1987
1988                 switch (si->type) {
1989                 case SOCK_STREAM:
1990                         u_type = SOCKET_TYPE_CHAR_TCP;
1991                         break;
1992                 case SOCK_DGRAM:
1993                         u_type = SOCKET_TYPE_CHAR_UDP;
1994                         a_type = SOCKET_TYPE_CHAR_UDP;
1995                         b_type = SOCKET_TYPE_CHAR_UDP;
1996                         break;
1997                 default:
1998                         SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!");
1999                         errno = ESOCKTNOSUPPORT;
2000                         return -1;
2001                 }
2002
2003                 prt = ntohs(in->sin_port);
2004                 if (a_type && addr == 0xFFFFFFFF) {
2005                         /* 255.255.255.255 only udp */
2006                         is_bcast = 2;
2007                         type = a_type;
2008                         iface = socket_wrapper_default_iface();
2009                 } else if (b_type && addr == sw_bcast_addr) {
2010                         /*
2011                          * 127.255.255.255
2012                          * or
2013                          * 10.255.255.255
2014                          * only udp
2015                          */
2016                         is_bcast = 1;
2017                         type = b_type;
2018                         iface = socket_wrapper_default_iface();
2019                 } else if ((addr & 0xFFFFFF00) == sw_net_addr) {
2020                         /* 127.0.0.X or 10.53.57.X */
2021                         is_bcast = 0;
2022                         type = u_type;
2023                         iface = (addr & 0x000000FF);
2024                 } else {
2025                         errno = ENETUNREACH;
2026                         return -1;
2027                 }
2028                 if (bcast) *bcast = is_bcast;
2029                 break;
2030         }
2031 #ifdef HAVE_IPV6
2032         case AF_INET6: {
2033                 const struct sockaddr_in6 *in =
2034                     (const struct sockaddr_in6 *)(const void *)inaddr;
2035                 struct in6_addr cmp1, cmp2;
2036
2037                 switch (si->type) {
2038                 case SOCK_STREAM:
2039                         type = SOCKET_TYPE_CHAR_TCP_V6;
2040                         break;
2041                 case SOCK_DGRAM:
2042                         type = SOCKET_TYPE_CHAR_UDP_V6;
2043                         break;
2044                 default:
2045                         SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!");
2046                         errno = ESOCKTNOSUPPORT;
2047                         return -1;
2048                 }
2049
2050                 /* XXX no multicast/broadcast */
2051
2052                 prt = ntohs(in->sin6_port);
2053
2054                 cmp1 = *swrap_ipv6();
2055                 cmp2 = in->sin6_addr;
2056                 cmp2.s6_addr[15] = 0;
2057                 if (IN6_ARE_ADDR_EQUAL(&cmp1, &cmp2)) {
2058                         iface = in->sin6_addr.s6_addr[15];
2059                 } else {
2060                         errno = ENETUNREACH;
2061                         return -1;
2062                 }
2063
2064                 break;
2065         }
2066 #endif
2067         default:
2068                 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family!");
2069                 errno = ENETUNREACH;
2070                 return -1;
2071         }
2072
2073         if (prt == 0) {
2074                 SWRAP_LOG(SWRAP_LOG_WARN, "Port not set");
2075                 errno = EINVAL;
2076                 return -1;
2077         }
2078
2079         swrap_dir = socket_wrapper_dir();
2080         if (swrap_dir == NULL) {
2081                 errno = EINVAL;
2082                 return -1;
2083         }
2084
2085         if (is_bcast) {
2086                 swrap_un_path_EINVAL(un, swrap_dir);
2087                 SWRAP_LOG(SWRAP_LOG_DEBUG, "un path [%s]", un->sun_path);
2088                 SAFE_FREE(swrap_dir);
2089                 /* the caller need to do more processing */
2090                 return 0;
2091         }
2092
2093         swrap_un_path(un, swrap_dir, type, iface, prt);
2094         SWRAP_LOG(SWRAP_LOG_DEBUG, "un path [%s]", un->sun_path);
2095
2096         SAFE_FREE(swrap_dir);
2097
2098         return 0;
2099 }
2100
2101 static int convert_in_un_alloc(struct socket_info *si, const struct sockaddr *inaddr, struct sockaddr_un *un,
2102                                int *bcast)
2103 {
2104         char type = '\0';
2105         unsigned int prt;
2106         unsigned int iface;
2107         struct stat st;
2108         int is_bcast = 0;
2109         char *swrap_dir = NULL;
2110
2111         if (bcast) *bcast = 0;
2112
2113         switch (si->family) {
2114         case AF_INET: {
2115                 const struct sockaddr_in *in =
2116                     (const struct sockaddr_in *)(const void *)inaddr;
2117                 unsigned int addr = ntohl(in->sin_addr.s_addr);
2118                 char u_type = '\0';
2119                 char d_type = '\0';
2120                 char b_type = '\0';
2121                 char a_type = '\0';
2122                 const unsigned int sw_net_addr = swrap_ipv4_net();
2123                 const unsigned int sw_bcast_addr = swrap_ipv4_bcast();
2124
2125                 prt = ntohs(in->sin_port);
2126
2127                 switch (si->type) {
2128                 case SOCK_STREAM:
2129                         u_type = SOCKET_TYPE_CHAR_TCP;
2130                         d_type = SOCKET_TYPE_CHAR_TCP;
2131                         break;
2132                 case SOCK_DGRAM:
2133                         u_type = SOCKET_TYPE_CHAR_UDP;
2134                         d_type = SOCKET_TYPE_CHAR_UDP;
2135                         a_type = SOCKET_TYPE_CHAR_UDP;
2136                         b_type = SOCKET_TYPE_CHAR_UDP;
2137                         break;
2138                 default:
2139                         SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!");
2140                         errno = ESOCKTNOSUPPORT;
2141                         return -1;
2142                 }
2143
2144                 if (addr == 0) {
2145                         /* 0.0.0.0 */
2146                         is_bcast = 0;
2147                         type = d_type;
2148                         iface = socket_wrapper_default_iface();
2149                 } else if (a_type && addr == 0xFFFFFFFF) {
2150                         /* 255.255.255.255 only udp */
2151                         is_bcast = 2;
2152                         type = a_type;
2153                         iface = socket_wrapper_default_iface();
2154                 } else if (b_type && addr == sw_bcast_addr) {
2155                         /* 127.255.255.255 only udp */
2156                         is_bcast = 1;
2157                         type = b_type;
2158                         iface = socket_wrapper_default_iface();
2159                 } else if ((addr & 0xFFFFFF00) == sw_net_addr) {
2160                         /* 127.0.0.X */
2161                         is_bcast = 0;
2162                         type = u_type;
2163                         iface = (addr & 0x000000FF);
2164                 } else {
2165                         errno = EADDRNOTAVAIL;
2166                         return -1;
2167                 }
2168
2169                 /* Store the bind address for connect() */
2170                 if (si->bindname.sa_socklen == 0) {
2171                         struct sockaddr_in bind_in;
2172                         socklen_t blen = sizeof(struct sockaddr_in);
2173
2174                         ZERO_STRUCT(bind_in);
2175                         bind_in.sin_family = in->sin_family;
2176                         bind_in.sin_port = in->sin_port;
2177                         bind_in.sin_addr.s_addr = htonl(swrap_ipv4_iface(iface));
2178                         si->bindname.sa_socklen = blen;
2179                         memcpy(&si->bindname.sa.in, &bind_in, blen);
2180                 }
2181
2182                 break;
2183         }
2184 #ifdef HAVE_IPV6
2185         case AF_INET6: {
2186                 const struct sockaddr_in6 *in =
2187                     (const struct sockaddr_in6 *)(const void *)inaddr;
2188                 struct in6_addr cmp1, cmp2;
2189
2190                 switch (si->type) {
2191                 case SOCK_STREAM:
2192                         type = SOCKET_TYPE_CHAR_TCP_V6;
2193                         break;
2194                 case SOCK_DGRAM:
2195                         type = SOCKET_TYPE_CHAR_UDP_V6;
2196                         break;
2197                 default:
2198                         SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!");
2199                         errno = ESOCKTNOSUPPORT;
2200                         return -1;
2201                 }
2202
2203                 /* XXX no multicast/broadcast */
2204
2205                 prt = ntohs(in->sin6_port);
2206
2207                 cmp1 = *swrap_ipv6();
2208                 cmp2 = in->sin6_addr;
2209                 cmp2.s6_addr[15] = 0;
2210                 if (IN6_IS_ADDR_UNSPECIFIED(&in->sin6_addr)) {
2211                         iface = socket_wrapper_default_iface();
2212                 } else if (IN6_ARE_ADDR_EQUAL(&cmp1, &cmp2)) {
2213                         iface = in->sin6_addr.s6_addr[15];
2214                 } else {
2215                         errno = EADDRNOTAVAIL;
2216                         return -1;
2217                 }
2218
2219                 /* Store the bind address for connect() */
2220                 if (si->bindname.sa_socklen == 0) {
2221                         struct sockaddr_in6 bind_in;
2222                         socklen_t blen = sizeof(struct sockaddr_in6);
2223
2224                         ZERO_STRUCT(bind_in);
2225                         bind_in.sin6_family = in->sin6_family;
2226                         bind_in.sin6_port = in->sin6_port;
2227
2228                         bind_in.sin6_addr = *swrap_ipv6();
2229                         bind_in.sin6_addr.s6_addr[15] = iface;
2230
2231                         memcpy(&si->bindname.sa.in6, &bind_in, blen);
2232                         si->bindname.sa_socklen = blen;
2233                 }
2234
2235                 break;
2236         }
2237 #endif
2238         default:
2239                 SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family");
2240                 errno = EADDRNOTAVAIL;
2241                 return -1;
2242         }
2243
2244
2245         if (bcast) *bcast = is_bcast;
2246
2247         if (iface == 0 || iface > MAX_WRAPPED_INTERFACES) {
2248                 errno = EINVAL;
2249                 return -1;
2250         }
2251
2252         swrap_dir = socket_wrapper_dir();
2253         if (swrap_dir == NULL) {
2254                 errno = EINVAL;
2255                 return -1;
2256         }
2257
2258         if (prt == 0) {
2259                 /* handle auto-allocation of ephemeral ports */
2260                 for (prt = 5001; prt < 10000; prt++) {
2261                         swrap_un_path(un, swrap_dir, type, iface, prt);
2262                         if (stat(un->sun_path, &st) == 0) continue;
2263
2264                         set_port(si->family, prt, &si->myname);
2265                         set_port(si->family, prt, &si->bindname);
2266
2267                         break;
2268                 }
2269
2270                 if (prt == 10000) {
2271                         errno = ENFILE;
2272                         SAFE_FREE(swrap_dir);
2273                         return -1;
2274                 }
2275         }
2276
2277         swrap_un_path(un, swrap_dir, type, iface, prt);
2278         SWRAP_LOG(SWRAP_LOG_DEBUG, "un path [%s]", un->sun_path);
2279
2280         SAFE_FREE(swrap_dir);
2281
2282         return 0;
2283 }
2284
2285 static struct socket_info *find_socket_info(int fd)
2286 {
2287         int idx = find_socket_info_index(fd);
2288
2289         if (idx == -1) {
2290                 return NULL;
2291         }
2292
2293         return swrap_get_socket_info(idx);
2294 }
2295
2296 #if 0 /* FIXME */
2297 static bool check_addr_port_in_use(const struct sockaddr *sa, socklen_t len)
2298 {
2299         struct socket_info_fd *f;
2300         const struct socket_info *last_s = NULL;
2301
2302         /* first catch invalid input */
2303         switch (sa->sa_family) {
2304         case AF_INET:
2305                 if (len < sizeof(struct sockaddr_in)) {
2306                         return false;
2307                 }
2308                 break;
2309 #ifdef HAVE_IPV6
2310         case AF_INET6:
2311                 if (len < sizeof(struct sockaddr_in6)) {
2312                         return false;
2313                 }
2314                 break;
2315 #endif
2316         default:
2317                 return false;
2318                 break;
2319         }
2320
2321         for (f = socket_fds; f; f = f->next) {
2322                 struct socket_info *s = swrap_get_socket_info(f->si_index);
2323
2324                 if (s == last_s) {
2325                         continue;
2326                 }
2327                 last_s = s;
2328
2329                 if (s->myname == NULL) {
2330                         continue;
2331                 }
2332                 if (s->myname->sa_family != sa->sa_family) {
2333                         continue;
2334                 }
2335                 switch (s->myname->sa_family) {
2336                 case AF_INET: {
2337                         struct sockaddr_in *sin1, *sin2;
2338
2339                         sin1 = (struct sockaddr_in *)s->myname;
2340                         sin2 = (struct sockaddr_in *)sa;
2341
2342                         if (sin1->sin_addr.s_addr == htonl(INADDR_ANY)) {
2343                                 continue;
2344                         }
2345                         if (sin1->sin_port != sin2->sin_port) {
2346                                 continue;
2347                         }
2348                         if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) {
2349                                 continue;
2350                         }
2351
2352                         /* found */
2353                         return true;
2354                         break;
2355                 }
2356 #ifdef HAVE_IPV6
2357                 case AF_INET6: {
2358                         struct sockaddr_in6 *sin1, *sin2;
2359
2360                         sin1 = (struct sockaddr_in6 *)s->myname;
2361                         sin2 = (struct sockaddr_in6 *)sa;
2362
2363                         if (sin1->sin6_port != sin2->sin6_port) {
2364                                 continue;
2365                         }
2366                         if (!IN6_ARE_ADDR_EQUAL(&sin1->sin6_addr,
2367                                                 &sin2->sin6_addr))
2368                         {
2369                                 continue;
2370                         }
2371
2372                         /* found */
2373                         return true;
2374                         break;
2375                 }
2376 #endif
2377                 default:
2378                         continue;
2379                         break;
2380
2381                 }
2382         }
2383
2384         return false;
2385 }
2386 #endif
2387
2388 static void swrap_remove_stale(int fd)
2389 {
2390         struct socket_info *si;
2391         int si_index;
2392
2393         SWRAP_LOG(SWRAP_LOG_TRACE, "remove stale wrapper for %d", fd);
2394
2395         swrap_mutex_lock(&socket_reset_mutex);
2396
2397         si_index = find_socket_info_index(fd);
2398         if (si_index == -1) {
2399                 swrap_mutex_unlock(&socket_reset_mutex);
2400                 return;
2401         }
2402
2403         reset_socket_info_index(fd);
2404
2405         si = swrap_get_socket_info(si_index);
2406
2407         swrap_mutex_lock(&first_free_mutex);
2408         SWRAP_LOCK_SI(si);
2409
2410         swrap_dec_refcount(si);
2411
2412         if (swrap_get_refcount(si) > 0) {
2413                 goto out;
2414         }
2415
2416         if (si->un_addr.sun_path[0] != '\0') {
2417                 unlink(si->un_addr.sun_path);
2418         }
2419
2420         swrap_set_next_free(si, first_free);
2421         first_free = si_index;
2422
2423 out:
2424         SWRAP_UNLOCK_SI(si);
2425         swrap_mutex_unlock(&first_free_mutex);
2426         swrap_mutex_unlock(&socket_reset_mutex);
2427 }
2428
2429 static int sockaddr_convert_to_un(struct socket_info *si,
2430                                   const struct sockaddr *in_addr,
2431                                   socklen_t in_len,
2432                                   struct sockaddr_un *out_addr,
2433                                   int alloc_sock,
2434                                   int *bcast)
2435 {
2436         struct sockaddr *out = (struct sockaddr *)(void *)out_addr;
2437
2438         (void) in_len; /* unused */
2439
2440         if (out_addr == NULL) {
2441                 return 0;
2442         }
2443
2444         out->sa_family = AF_UNIX;
2445 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
2446         out->sa_len = sizeof(*out_addr);
2447 #endif
2448
2449         switch (in_addr->sa_family) {
2450         case AF_UNSPEC: {
2451                 const struct sockaddr_in *sin;
2452                 if (si->family != AF_INET) {
2453                         break;
2454                 }
2455                 if (in_len < sizeof(struct sockaddr_in)) {
2456                         break;
2457                 }
2458                 sin = (const struct sockaddr_in *)(const void *)in_addr;
2459                 if(sin->sin_addr.s_addr != htonl(INADDR_ANY)) {
2460                         break;
2461                 }
2462
2463                 /*
2464                  * Note: in the special case of AF_UNSPEC and INADDR_ANY,
2465                  * AF_UNSPEC is mapped to AF_INET and must be treated here.
2466                  */
2467
2468                 FALL_THROUGH;
2469         }
2470         case AF_INET:
2471 #ifdef HAVE_IPV6
2472         case AF_INET6:
2473 #endif
2474                 switch (si->type) {
2475                 case SOCK_STREAM:
2476                 case SOCK_DGRAM:
2477                         break;
2478                 default:
2479                         SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!");
2480                         errno = ESOCKTNOSUPPORT;
2481                         return -1;
2482                 }
2483                 if (alloc_sock) {
2484                         return convert_in_un_alloc(si, in_addr, out_addr, bcast);
2485                 } else {
2486                         return convert_in_un_remote(si, in_addr, out_addr, bcast);
2487                 }
2488         default:
2489                 break;
2490         }
2491
2492         errno = EAFNOSUPPORT;
2493         SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family");
2494         return -1;
2495 }
2496
2497 static int sockaddr_convert_from_un(const struct socket_info *si,
2498                                     const struct sockaddr_un *in_addr,
2499                                     socklen_t un_addrlen,
2500                                     int family,
2501                                     struct sockaddr *out_addr,
2502                                     socklen_t *out_addrlen)
2503 {
2504         int ret;
2505
2506         if (out_addr == NULL || out_addrlen == NULL)
2507                 return 0;
2508
2509         if (un_addrlen == 0) {
2510                 *out_addrlen = 0;
2511                 return 0;
2512         }
2513
2514         switch (family) {
2515         case AF_INET:
2516 #ifdef HAVE_IPV6
2517         case AF_INET6:
2518 #endif
2519                 switch (si->type) {
2520                 case SOCK_STREAM:
2521                 case SOCK_DGRAM:
2522                         break;
2523                 default:
2524                         SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!");
2525                         errno = ESOCKTNOSUPPORT;
2526                         return -1;
2527                 }
2528                 ret = convert_un_in(in_addr, out_addr, out_addrlen);
2529 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
2530                 out_addr->sa_len = *out_addrlen;
2531 #endif
2532                 return ret;
2533         default:
2534                 break;
2535         }
2536
2537         SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family");
2538         errno = EAFNOSUPPORT;
2539         return -1;
2540 }
2541
2542 enum swrap_packet_type {
2543         SWRAP_CONNECT_SEND,
2544         SWRAP_CONNECT_UNREACH,
2545         SWRAP_CONNECT_RECV,
2546         SWRAP_CONNECT_ACK,
2547         SWRAP_ACCEPT_SEND,
2548         SWRAP_ACCEPT_RECV,
2549         SWRAP_ACCEPT_ACK,
2550         SWRAP_RECVFROM,
2551         SWRAP_SENDTO,
2552         SWRAP_SENDTO_UNREACH,
2553         SWRAP_PENDING_RST,
2554         SWRAP_RECV,
2555         SWRAP_RECV_RST,
2556         SWRAP_SEND,
2557         SWRAP_SEND_RST,
2558         SWRAP_CLOSE_SEND,
2559         SWRAP_CLOSE_RECV,
2560         SWRAP_CLOSE_ACK,
2561 };
2562
2563 struct swrap_file_hdr {
2564         uint32_t        magic;
2565         uint16_t        version_major;
2566         uint16_t        version_minor;
2567         int32_t         timezone;
2568         uint32_t        sigfigs;
2569         uint32_t        frame_max_len;
2570 #define SWRAP_FRAME_LENGTH_MAX 0xFFFF
2571         uint32_t        link_type;
2572 };
2573 #define SWRAP_FILE_HDR_SIZE 24
2574
2575 struct swrap_packet_frame {
2576         uint32_t seconds;
2577         uint32_t micro_seconds;
2578         uint32_t recorded_length;
2579         uint32_t full_length;
2580 };
2581 #define SWRAP_PACKET_FRAME_SIZE 16
2582
2583 union swrap_packet_ip {
2584         struct {
2585                 uint8_t         ver_hdrlen;
2586                 uint8_t         tos;
2587                 uint16_t        packet_length;
2588                 uint16_t        identification;
2589                 uint8_t         flags;
2590                 uint8_t         fragment;
2591                 uint8_t         ttl;
2592                 uint8_t         protocol;
2593                 uint16_t        hdr_checksum;
2594                 uint32_t        src_addr;
2595                 uint32_t        dest_addr;
2596         } v4;
2597 #define SWRAP_PACKET_IP_V4_SIZE 20
2598         struct {
2599                 uint8_t         ver_prio;
2600                 uint8_t         flow_label_high;
2601                 uint16_t        flow_label_low;
2602                 uint16_t        payload_length;
2603                 uint8_t         next_header;
2604                 uint8_t         hop_limit;
2605                 uint8_t         src_addr[16];
2606                 uint8_t         dest_addr[16];
2607         } v6;
2608 #define SWRAP_PACKET_IP_V6_SIZE 40
2609 };
2610 #define SWRAP_PACKET_IP_SIZE 40
2611
2612 union swrap_packet_payload {
2613         struct {
2614                 uint16_t        source_port;
2615                 uint16_t        dest_port;
2616                 uint32_t        seq_num;
2617                 uint32_t        ack_num;
2618                 uint8_t         hdr_length;
2619                 uint8_t         control;
2620                 uint16_t        window;
2621                 uint16_t        checksum;
2622                 uint16_t        urg;
2623         } tcp;
2624 #define SWRAP_PACKET_PAYLOAD_TCP_SIZE 20
2625         struct {
2626                 uint16_t        source_port;
2627                 uint16_t        dest_port;
2628                 uint16_t        length;
2629                 uint16_t        checksum;
2630         } udp;
2631 #define SWRAP_PACKET_PAYLOAD_UDP_SIZE 8
2632         struct {
2633                 uint8_t         type;
2634                 uint8_t         code;
2635                 uint16_t        checksum;
2636                 uint32_t        unused;
2637         } icmp4;
2638 #define SWRAP_PACKET_PAYLOAD_ICMP4_SIZE 8
2639         struct {
2640                 uint8_t         type;
2641                 uint8_t         code;
2642                 uint16_t        checksum;
2643                 uint32_t        unused;
2644         } icmp6;
2645 #define SWRAP_PACKET_PAYLOAD_ICMP6_SIZE 8
2646 };
2647 #define SWRAP_PACKET_PAYLOAD_SIZE 20
2648
2649 #define SWRAP_PACKET_MIN_ALLOC \
2650         (SWRAP_PACKET_FRAME_SIZE + \
2651          SWRAP_PACKET_IP_SIZE + \
2652          SWRAP_PACKET_PAYLOAD_SIZE)
2653
2654 static const char *swrap_pcap_init_file(void)
2655 {
2656         static int initialized = 0;
2657         static const char *s = NULL;
2658         static const struct swrap_file_hdr h;
2659         static const struct swrap_packet_frame f;
2660         static const union swrap_packet_ip i;
2661         static const union swrap_packet_payload p;
2662
2663         if (initialized == 1) {
2664                 return s;
2665         }
2666         initialized = 1;
2667
2668         /*
2669          * TODO: don't use the structs use plain buffer offsets
2670          *       and PUSH_U8(), PUSH_U16() and PUSH_U32()
2671          *
2672          * for now make sure we disable PCAP support
2673          * if the struct has alignment!
2674          */
2675         if (sizeof(h) != SWRAP_FILE_HDR_SIZE) {
2676                 return NULL;
2677         }
2678         if (sizeof(f) != SWRAP_PACKET_FRAME_SIZE) {
2679                 return NULL;
2680         }
2681         if (sizeof(i) != SWRAP_PACKET_IP_SIZE) {
2682                 return NULL;
2683         }
2684         if (sizeof(i.v4) != SWRAP_PACKET_IP_V4_SIZE) {
2685                 return NULL;
2686         }
2687         if (sizeof(i.v6) != SWRAP_PACKET_IP_V6_SIZE) {
2688                 return NULL;
2689         }
2690         if (sizeof(p) != SWRAP_PACKET_PAYLOAD_SIZE) {
2691                 return NULL;
2692         }
2693         if (sizeof(p.tcp) != SWRAP_PACKET_PAYLOAD_TCP_SIZE) {
2694                 return NULL;
2695         }
2696         if (sizeof(p.udp) != SWRAP_PACKET_PAYLOAD_UDP_SIZE) {
2697                 return NULL;
2698         }
2699         if (sizeof(p.icmp4) != SWRAP_PACKET_PAYLOAD_ICMP4_SIZE) {
2700                 return NULL;
2701         }
2702         if (sizeof(p.icmp6) != SWRAP_PACKET_PAYLOAD_ICMP6_SIZE) {
2703                 return NULL;
2704         }
2705
2706         s = getenv("SOCKET_WRAPPER_PCAP_FILE");
2707         if (s == NULL) {
2708                 return NULL;
2709         }
2710         if (strncmp(s, "./", 2) == 0) {
2711                 s += 2;
2712         }
2713         SWRAP_LOG(SWRAP_LOG_TRACE, "SOCKET_WRAPPER_PCAP_FILE: %s", s);
2714         return s;
2715 }
2716
2717 static uint8_t *swrap_pcap_packet_init(struct timeval *tval,
2718                                        const struct sockaddr *src,
2719                                        const struct sockaddr *dest,
2720                                        int socket_type,
2721                                        const uint8_t *payload,
2722                                        size_t payload_len,
2723                                        unsigned long tcp_seqno,
2724                                        unsigned long tcp_ack,
2725                                        unsigned char tcp_ctl,
2726                                        int unreachable,
2727                                        size_t *_packet_len)
2728 {
2729         uint8_t *base = NULL;
2730         uint8_t *buf = NULL;
2731         union {
2732                 uint8_t *ptr;
2733                 struct swrap_packet_frame *frame;
2734         } f;
2735         union {
2736                 uint8_t *ptr;
2737                 union swrap_packet_ip *ip;
2738         } i;
2739         union swrap_packet_payload *pay;
2740         size_t packet_len;
2741         size_t alloc_len;
2742         size_t nonwire_len = sizeof(struct swrap_packet_frame);
2743         size_t wire_hdr_len = 0;
2744         size_t wire_len = 0;
2745         size_t ip_hdr_len = 0;
2746         size_t icmp_hdr_len = 0;
2747         size_t icmp_truncate_len = 0;
2748         uint8_t protocol = 0, icmp_protocol = 0;
2749         const struct sockaddr_in *src_in = NULL;
2750         const struct sockaddr_in *dest_in = NULL;
2751 #ifdef HAVE_IPV6
2752         const struct sockaddr_in6 *src_in6 = NULL;
2753         const struct sockaddr_in6 *dest_in6 = NULL;
2754 #endif
2755         uint16_t src_port;
2756         uint16_t dest_port;
2757
2758         switch (src->sa_family) {
2759         case AF_INET:
2760                 src_in = (const struct sockaddr_in *)(const void *)src;
2761                 dest_in = (const struct sockaddr_in *)(const void *)dest;
2762                 src_port = src_in->sin_port;
2763                 dest_port = dest_in->sin_port;
2764                 ip_hdr_len = sizeof(i.ip->v4);
2765                 break;
2766 #ifdef HAVE_IPV6
2767         case AF_INET6:
2768                 src_in6 = (const struct sockaddr_in6 *)(const void *)src;
2769                 dest_in6 = (const struct sockaddr_in6 *)(const void *)dest;
2770                 src_port = src_in6->sin6_port;
2771                 dest_port = dest_in6->sin6_port;
2772                 ip_hdr_len = sizeof(i.ip->v6);
2773                 break;
2774 #endif
2775         default:
2776                 return NULL;
2777         }
2778
2779         switch (socket_type) {
2780         case SOCK_STREAM:
2781                 protocol = 0x06; /* TCP */
2782                 wire_hdr_len = ip_hdr_len + sizeof(pay->tcp);
2783                 wire_len = wire_hdr_len + payload_len;
2784                 break;
2785
2786         case SOCK_DGRAM:
2787                 protocol = 0x11; /* UDP */
2788                 wire_hdr_len = ip_hdr_len + sizeof(pay->udp);
2789                 wire_len = wire_hdr_len + payload_len;
2790                 break;
2791
2792         default:
2793                 return NULL;
2794         }
2795
2796         if (unreachable) {
2797                 icmp_protocol = protocol;
2798                 switch (src->sa_family) {
2799                 case AF_INET:
2800                         protocol = 0x01; /* ICMPv4 */
2801                         icmp_hdr_len = ip_hdr_len + sizeof(pay->icmp4);
2802                         break;
2803 #ifdef HAVE_IPV6
2804                 case AF_INET6:
2805                         protocol = 0x3A; /* ICMPv6 */
2806                         icmp_hdr_len = ip_hdr_len + sizeof(pay->icmp6);
2807                         break;
2808 #endif
2809                 }
2810                 if (wire_len > 64 ) {
2811                         icmp_truncate_len = wire_len - 64;
2812                 }
2813                 wire_len += icmp_hdr_len;
2814         }
2815
2816         packet_len = nonwire_len + wire_len;
2817         alloc_len = packet_len;
2818         if (alloc_len < SWRAP_PACKET_MIN_ALLOC) {
2819                 alloc_len = SWRAP_PACKET_MIN_ALLOC;
2820         }
2821
2822         base = (uint8_t *)calloc(1, alloc_len);
2823         if (base == NULL) {
2824                 return NULL;
2825         }
2826
2827         buf = base;
2828         f.ptr = buf;
2829
2830         f.frame->seconds                = tval->tv_sec;
2831         f.frame->micro_seconds  = tval->tv_usec;
2832         f.frame->recorded_length        = wire_len - icmp_truncate_len;
2833         f.frame->full_length    = wire_len - icmp_truncate_len;
2834
2835         buf += SWRAP_PACKET_FRAME_SIZE;
2836
2837         i.ptr = buf;
2838         switch (src->sa_family) {
2839         case AF_INET:
2840                 if (src_in == NULL || dest_in == NULL) {
2841                         SAFE_FREE(base);
2842                         return NULL;
2843                 }
2844
2845                 i.ip->v4.ver_hdrlen     = 0x45; /* version 4 and 5 * 32 bit words */
2846                 i.ip->v4.tos            = 0x00;
2847                 i.ip->v4.packet_length  = htons(wire_len - icmp_truncate_len);
2848                 i.ip->v4.identification = htons(0xFFFF);
2849                 i.ip->v4.flags          = 0x40; /* BIT 1 set - means don't fragment */
2850                 i.ip->v4.fragment       = htons(0x0000);
2851                 i.ip->v4.ttl            = 0xFF;
2852                 i.ip->v4.protocol       = protocol;
2853                 i.ip->v4.hdr_checksum   = htons(0x0000);
2854                 i.ip->v4.src_addr       = src_in->sin_addr.s_addr;
2855                 i.ip->v4.dest_addr      = dest_in->sin_addr.s_addr;
2856                 buf += SWRAP_PACKET_IP_V4_SIZE;
2857                 break;
2858 #ifdef HAVE_IPV6
2859         case AF_INET6:
2860                 if (src_in6 == NULL || dest_in6 == NULL) {
2861                         SAFE_FREE(base);
2862                         return NULL;
2863                 }
2864
2865                 i.ip->v6.ver_prio               = 0x60; /* version 4 and 5 * 32 bit words */
2866                 i.ip->v6.flow_label_high        = 0x00;
2867                 i.ip->v6.flow_label_low = 0x0000;
2868                 i.ip->v6.payload_length = htons(wire_len - icmp_truncate_len); /* TODO */
2869                 i.ip->v6.next_header    = protocol;
2870                 memcpy(i.ip->v6.src_addr, src_in6->sin6_addr.s6_addr, 16);
2871                 memcpy(i.ip->v6.dest_addr, dest_in6->sin6_addr.s6_addr, 16);
2872                 buf += SWRAP_PACKET_IP_V6_SIZE;
2873                 break;
2874 #endif
2875         }
2876
2877         if (unreachable) {
2878                 pay = (union swrap_packet_payload *)(void *)buf;
2879                 switch (src->sa_family) {
2880                 case AF_INET:
2881                         pay->icmp4.type         = 0x03; /* destination unreachable */
2882                         pay->icmp4.code         = 0x01; /* host unreachable */
2883                         pay->icmp4.checksum     = htons(0x0000);
2884                         pay->icmp4.unused       = htonl(0x00000000);
2885
2886                         buf += SWRAP_PACKET_PAYLOAD_ICMP4_SIZE;
2887
2888                         /* set the ip header in the ICMP payload */
2889                         i.ptr = buf;
2890                         i.ip->v4.ver_hdrlen     = 0x45; /* version 4 and 5 * 32 bit words */
2891                         i.ip->v4.tos            = 0x00;
2892                         i.ip->v4.packet_length  = htons(wire_len - icmp_hdr_len);
2893                         i.ip->v4.identification = htons(0xFFFF);
2894                         i.ip->v4.flags          = 0x40; /* BIT 1 set - means don't fragment */
2895                         i.ip->v4.fragment       = htons(0x0000);
2896                         i.ip->v4.ttl            = 0xFF;
2897                         i.ip->v4.protocol       = icmp_protocol;
2898                         i.ip->v4.hdr_checksum   = htons(0x0000);
2899                         i.ip->v4.src_addr       = dest_in->sin_addr.s_addr;
2900                         i.ip->v4.dest_addr      = src_in->sin_addr.s_addr;
2901
2902                         buf += SWRAP_PACKET_IP_V4_SIZE;
2903
2904                         src_port = dest_in->sin_port;
2905                         dest_port = src_in->sin_port;
2906                         break;
2907 #ifdef HAVE_IPV6
2908                 case AF_INET6:
2909                         pay->icmp6.type         = 0x01; /* destination unreachable */
2910                         pay->icmp6.code         = 0x03; /* address unreachable */
2911                         pay->icmp6.checksum     = htons(0x0000);
2912                         pay->icmp6.unused       = htonl(0x00000000);
2913                         buf += SWRAP_PACKET_PAYLOAD_ICMP6_SIZE;
2914
2915                         /* set the ip header in the ICMP payload */
2916                         i.ptr = buf;
2917                         i.ip->v6.ver_prio               = 0x60; /* version 4 and 5 * 32 bit words */
2918                         i.ip->v6.flow_label_high        = 0x00;
2919                         i.ip->v6.flow_label_low = 0x0000;
2920                         i.ip->v6.payload_length = htons(wire_len - icmp_truncate_len); /* TODO */
2921                         i.ip->v6.next_header    = protocol;
2922                         memcpy(i.ip->v6.src_addr, dest_in6->sin6_addr.s6_addr, 16);
2923                         memcpy(i.ip->v6.dest_addr, src_in6->sin6_addr.s6_addr, 16);
2924
2925                         buf += SWRAP_PACKET_IP_V6_SIZE;
2926
2927                         src_port = dest_in6->sin6_port;
2928                         dest_port = src_in6->sin6_port;
2929                         break;
2930 #endif
2931                 }
2932         }
2933
2934         pay = (union swrap_packet_payload *)(void *)buf;
2935
2936         switch (socket_type) {
2937         case SOCK_STREAM:
2938                 pay->tcp.source_port    = src_port;
2939                 pay->tcp.dest_port      = dest_port;
2940                 pay->tcp.seq_num        = htonl(tcp_seqno);
2941                 pay->tcp.ack_num        = htonl(tcp_ack);
2942                 pay->tcp.hdr_length     = 0x50; /* 5 * 32 bit words */
2943                 pay->tcp.control        = tcp_ctl;
2944                 pay->tcp.window         = htons(0x7FFF);
2945                 pay->tcp.checksum       = htons(0x0000);
2946                 pay->tcp.urg            = htons(0x0000);
2947                 buf += SWRAP_PACKET_PAYLOAD_TCP_SIZE;
2948
2949                 break;
2950
2951         case SOCK_DGRAM:
2952                 pay->udp.source_port    = src_port;
2953                 pay->udp.dest_port      = dest_port;
2954                 pay->udp.length         = htons(8 + payload_len);
2955                 pay->udp.checksum       = htons(0x0000);
2956                 buf += SWRAP_PACKET_PAYLOAD_UDP_SIZE;
2957
2958                 break;
2959         }
2960
2961         if (payload && payload_len > 0) {
2962                 memcpy(buf, payload, payload_len);
2963         }
2964
2965         *_packet_len = packet_len - icmp_truncate_len;
2966         return base;
2967 }
2968
2969 static int swrap_pcap_get_fd(const char *fname)
2970 {
2971         static int fd = -1;
2972
2973         if (fd != -1) {
2974                 return fd;
2975         }
2976
2977         fd = libc_open(fname, O_WRONLY|O_CREAT|O_EXCL|O_APPEND, 0644);
2978         if (fd != -1) {
2979                 struct swrap_file_hdr file_hdr;
2980                 file_hdr.magic          = 0xA1B2C3D4;
2981                 file_hdr.version_major  = 0x0002;
2982                 file_hdr.version_minor  = 0x0004;
2983                 file_hdr.timezone       = 0x00000000;
2984                 file_hdr.sigfigs        = 0x00000000;
2985                 file_hdr.frame_max_len  = SWRAP_FRAME_LENGTH_MAX;
2986                 file_hdr.link_type      = 0x0065; /* 101 RAW IP */
2987
2988                 if (write(fd, &file_hdr, sizeof(file_hdr)) != sizeof(file_hdr)) {
2989                         libc_close(fd);
2990                         fd = -1;
2991                 }
2992                 return fd;
2993         }
2994
2995         fd = libc_open(fname, O_WRONLY|O_APPEND, 0644);
2996
2997         return fd;
2998 }
2999
3000 static uint8_t *swrap_pcap_marshall_packet(struct socket_info *si,
3001                                            const struct sockaddr *addr,
3002                                            enum swrap_packet_type type,
3003                                            const void *buf, size_t len,
3004                                            size_t *packet_len)
3005 {
3006         const struct sockaddr *src_addr;
3007         const struct sockaddr *dest_addr;
3008         unsigned long tcp_seqno = 0;
3009         unsigned long tcp_ack = 0;
3010         unsigned char tcp_ctl = 0;
3011         int unreachable = 0;
3012
3013         struct timeval tv;
3014
3015         switch (si->family) {
3016         case AF_INET:
3017                 break;
3018 #ifdef HAVE_IPV6
3019         case AF_INET6:
3020                 break;
3021 #endif
3022         default:
3023                 return NULL;
3024         }
3025
3026         switch (type) {
3027         case SWRAP_CONNECT_SEND:
3028                 if (si->type != SOCK_STREAM) {
3029                         return NULL;
3030                 }
3031
3032                 src_addr  = &si->myname.sa.s;
3033                 dest_addr = addr;
3034
3035                 tcp_seqno = si->io.pck_snd;
3036                 tcp_ack = si->io.pck_rcv;
3037                 tcp_ctl = 0x02; /* SYN */
3038
3039                 si->io.pck_snd += 1;
3040
3041                 break;
3042
3043         case SWRAP_CONNECT_RECV:
3044                 if (si->type != SOCK_STREAM) {
3045                         return NULL;
3046                 }
3047
3048                 dest_addr = &si->myname.sa.s;
3049                 src_addr = addr;
3050
3051                 tcp_seqno = si->io.pck_rcv;
3052                 tcp_ack = si->io.pck_snd;
3053                 tcp_ctl = 0x12; /** SYN,ACK */
3054
3055                 si->io.pck_rcv += 1;
3056
3057                 break;
3058
3059         case SWRAP_CONNECT_UNREACH:
3060                 if (si->type != SOCK_STREAM) {
3061                         return NULL;
3062                 }
3063
3064                 dest_addr = &si->myname.sa.s;
3065                 src_addr  = addr;
3066
3067                 /* Unreachable: resend the data of SWRAP_CONNECT_SEND */
3068                 tcp_seqno = si->io.pck_snd - 1;
3069                 tcp_ack = si->io.pck_rcv;
3070                 tcp_ctl = 0x02; /* SYN */
3071                 unreachable = 1;
3072
3073                 break;
3074
3075         case SWRAP_CONNECT_ACK:
3076                 if (si->type != SOCK_STREAM) {
3077                         return NULL;
3078                 }
3079
3080                 src_addr  = &si->myname.sa.s;
3081                 dest_addr = addr;
3082
3083                 tcp_seqno = si->io.pck_snd;
3084                 tcp_ack = si->io.pck_rcv;
3085                 tcp_ctl = 0x10; /* ACK */
3086
3087                 break;
3088
3089         case SWRAP_ACCEPT_SEND:
3090                 if (si->type != SOCK_STREAM) {
3091                         return NULL;
3092                 }
3093
3094                 dest_addr = &si->myname.sa.s;
3095                 src_addr = addr;
3096
3097                 tcp_seqno = si->io.pck_rcv;
3098                 tcp_ack = si->io.pck_snd;
3099                 tcp_ctl = 0x02; /* SYN */
3100
3101                 si->io.pck_rcv += 1;
3102
3103                 break;
3104
3105         case SWRAP_ACCEPT_RECV:
3106                 if (si->type != SOCK_STREAM) {
3107                         return NULL;
3108                 }
3109
3110                 src_addr = &si->myname.sa.s;
3111                 dest_addr = addr;
3112
3113                 tcp_seqno = si->io.pck_snd;
3114                 tcp_ack = si->io.pck_rcv;
3115                 tcp_ctl = 0x12; /* SYN,ACK */
3116
3117                 si->io.pck_snd += 1;
3118
3119                 break;
3120
3121         case SWRAP_ACCEPT_ACK:
3122                 if (si->type != SOCK_STREAM) {
3123                         return NULL;
3124                 }
3125
3126                 dest_addr = &si->myname.sa.s;
3127                 src_addr = addr;
3128
3129                 tcp_seqno = si->io.pck_rcv;
3130                 tcp_ack = si->io.pck_snd;
3131                 tcp_ctl = 0x10; /* ACK */
3132
3133                 break;
3134
3135         case SWRAP_SEND:
3136                 src_addr  = &si->myname.sa.s;
3137                 dest_addr = &si->peername.sa.s;
3138
3139                 tcp_seqno = si->io.pck_snd;
3140                 tcp_ack = si->io.pck_rcv;
3141                 tcp_ctl = 0x18; /* PSH,ACK */
3142
3143                 si->io.pck_snd += len;
3144
3145                 break;
3146
3147         case SWRAP_SEND_RST:
3148                 dest_addr = &si->myname.sa.s;
3149                 src_addr  = &si->peername.sa.s;
3150
3151                 if (si->type == SOCK_DGRAM) {
3152                         return swrap_pcap_marshall_packet(si,
3153                                                           &si->peername.sa.s,
3154                                                           SWRAP_SENDTO_UNREACH,
3155                                                           buf,
3156                                                           len,
3157                                                           packet_len);
3158                 }
3159
3160                 tcp_seqno = si->io.pck_rcv;
3161                 tcp_ack = si->io.pck_snd;
3162                 tcp_ctl = 0x14; /** RST,ACK */
3163
3164                 break;
3165
3166         case SWRAP_PENDING_RST:
3167                 dest_addr = &si->myname.sa.s;
3168                 src_addr  = &si->peername.sa.s;
3169
3170                 if (si->type == SOCK_DGRAM) {
3171                         return NULL;
3172                 }
3173
3174                 tcp_seqno = si->io.pck_rcv;
3175                 tcp_ack = si->io.pck_snd;
3176                 tcp_ctl = 0x14; /* RST,ACK */
3177
3178                 break;
3179
3180         case SWRAP_RECV:
3181                 dest_addr = &si->myname.sa.s;
3182                 src_addr  = &si->peername.sa.s;
3183
3184                 tcp_seqno = si->io.pck_rcv;
3185                 tcp_ack = si->io.pck_snd;
3186                 tcp_ctl = 0x18; /* PSH,ACK */
3187
3188                 si->io.pck_rcv += len;
3189
3190                 break;
3191
3192         case SWRAP_RECV_RST:
3193                 dest_addr = &si->myname.sa.s;
3194                 src_addr  = &si->peername.sa.s;
3195
3196                 if (si->type == SOCK_DGRAM) {
3197                         return NULL;
3198                 }
3199
3200                 tcp_seqno = si->io.pck_rcv;
3201                 tcp_ack = si->io.pck_snd;
3202                 tcp_ctl = 0x14; /* RST,ACK */
3203
3204                 break;
3205
3206         case SWRAP_SENDTO:
3207                 src_addr = &si->myname.sa.s;
3208                 dest_addr = addr;
3209
3210                 si->io.pck_snd += len;
3211
3212                 break;
3213
3214         case SWRAP_SENDTO_UNREACH:
3215                 dest_addr = &si->myname.sa.s;
3216                 src_addr = addr;
3217
3218                 unreachable = 1;
3219
3220                 break;
3221
3222         case SWRAP_RECVFROM:
3223                 dest_addr = &si->myname.sa.s;
3224                 src_addr = addr;
3225
3226                 si->io.pck_rcv += len;
3227
3228                 break;
3229
3230         case SWRAP_CLOSE_SEND:
3231                 if (si->type != SOCK_STREAM) {
3232                         return NULL;
3233                 }
3234
3235                 src_addr  = &si->myname.sa.s;
3236                 dest_addr = &si->peername.sa.s;
3237
3238                 tcp_seqno = si->io.pck_snd;
3239                 tcp_ack = si->io.pck_rcv;
3240                 tcp_ctl = 0x11; /* FIN, ACK */
3241
3242                 si->io.pck_snd += 1;
3243
3244                 break;
3245
3246         case SWRAP_CLOSE_RECV:
3247                 if (si->type != SOCK_STREAM) {
3248                         return NULL;
3249                 }
3250
3251                 dest_addr = &si->myname.sa.s;
3252                 src_addr  = &si->peername.sa.s;
3253
3254                 tcp_seqno = si->io.pck_rcv;
3255                 tcp_ack = si->io.pck_snd;
3256                 tcp_ctl = 0x11; /* FIN,ACK */
3257
3258                 si->io.pck_rcv += 1;
3259
3260                 break;
3261
3262         case SWRAP_CLOSE_ACK:
3263                 if (si->type != SOCK_STREAM) {
3264                         return NULL;
3265                 }
3266
3267                 src_addr  = &si->myname.sa.s;
3268                 dest_addr = &si->peername.sa.s;
3269
3270                 tcp_seqno = si->io.pck_snd;
3271                 tcp_ack = si->io.pck_rcv;
3272                 tcp_ctl = 0x10; /* ACK */
3273
3274                 break;
3275         default:
3276                 return NULL;
3277         }
3278
3279         swrapGetTimeOfDay(&tv);
3280
3281         return swrap_pcap_packet_init(&tv,
3282                                       src_addr,
3283                                       dest_addr,
3284                                       si->type,
3285                                       (const uint8_t *)buf,
3286                                       len,
3287                                       tcp_seqno,
3288                                       tcp_ack,
3289                                       tcp_ctl,
3290                                       unreachable,
3291                                       packet_len);
3292 }
3293
3294 static void swrap_pcap_dump_packet(struct socket_info *si,
3295                                    const struct sockaddr *addr,
3296                                    enum swrap_packet_type type,
3297                                    const void *buf, size_t len)
3298 {
3299         const char *file_name;
3300         uint8_t *packet;
3301         size_t packet_len = 0;
3302         int fd;
3303
3304         swrap_mutex_lock(&pcap_dump_mutex);
3305
3306         file_name = swrap_pcap_init_file();
3307         if (!file_name) {
3308                 goto done;
3309         }
3310
3311         packet = swrap_pcap_marshall_packet(si,
3312                                             addr,
3313                                             type,
3314                                             buf,
3315                                             len,
3316                                             &packet_len);
3317         if (packet == NULL) {
3318                 goto done;
3319         }
3320
3321         fd = swrap_pcap_get_fd(file_name);
3322         if (fd != -1) {
3323                 if (write(fd, packet, packet_len) != (ssize_t)packet_len) {
3324                         free(packet);
3325                         goto done;
3326                 }
3327         }
3328
3329         free(packet);
3330
3331 done:
3332         swrap_mutex_unlock(&pcap_dump_mutex);
3333 }
3334
3335 /****************************************************************************
3336  *   SIGNALFD
3337  ***************************************************************************/
3338
3339 #ifdef HAVE_SIGNALFD
3340 static int swrap_signalfd(int fd, const sigset_t *mask, int flags)
3341 {
3342         int rc;
3343
3344         rc = libc_signalfd(fd, mask, flags);
3345         if (rc != -1) {
3346                 swrap_remove_stale(fd);
3347         }
3348
3349         return rc;
3350 }
3351
3352 int signalfd(int fd, const sigset_t *mask, int flags)
3353 {
3354         return swrap_signalfd(fd, mask, flags);
3355 }
3356 #endif
3357
3358 /****************************************************************************
3359  *   SOCKET
3360  ***************************************************************************/
3361
3362 static int swrap_socket(int family, int type, int protocol)
3363 {
3364         struct socket_info *si = NULL;
3365         struct socket_info _si = { 0 };
3366         int fd;
3367         int ret;
3368         int real_type = type;
3369
3370         /*
3371          * Remove possible addition flags passed to socket() so
3372          * do not fail checking the type.
3373          * See https://lwn.net/Articles/281965/
3374          */
3375 #ifdef SOCK_CLOEXEC
3376         real_type &= ~SOCK_CLOEXEC;
3377 #endif
3378 #ifdef SOCK_NONBLOCK
3379         real_type &= ~SOCK_NONBLOCK;
3380 #endif
3381
3382         if (!socket_wrapper_enabled()) {
3383                 return libc_socket(family, type, protocol);
3384         }
3385
3386         switch (family) {
3387         case AF_INET:
3388 #ifdef HAVE_IPV6
3389         case AF_INET6:
3390 #endif
3391                 break;
3392 #ifdef AF_NETLINK
3393         case AF_NETLINK:
3394 #endif /* AF_NETLINK */
3395 #ifdef AF_PACKET
3396         case AF_PACKET:
3397 #endif /* AF_PACKET */
3398         case AF_UNIX:
3399                 fd = libc_socket(family, type, protocol);
3400                 if (fd != -1) {
3401                         /* Check if we have a stale fd and remove it */
3402                         swrap_remove_stale(fd);
3403                         SWRAP_LOG(SWRAP_LOG_TRACE,
3404                                   "Unix socket fd=%d",
3405                                   fd);
3406                 }
3407                 return fd;
3408         default:
3409                 errno = EAFNOSUPPORT;
3410                 return -1;
3411         }
3412
3413         switch (real_type) {
3414         case SOCK_STREAM:
3415                 break;
3416         case SOCK_DGRAM:
3417                 break;
3418         default:
3419                 errno = EPROTONOSUPPORT;
3420                 return -1;
3421         }
3422
3423         switch (protocol) {
3424         case 0:
3425                 break;
3426         case 6:
3427                 if (real_type == SOCK_STREAM) {
3428                         break;
3429                 }
3430                 FALL_THROUGH;
3431         case 17:
3432                 if (real_type == SOCK_DGRAM) {
3433                         break;
3434                 }
3435                 FALL_THROUGH;
3436         default:
3437                 errno = EPROTONOSUPPORT;
3438                 return -1;
3439         }
3440
3441         /*
3442          * We must call libc_socket with type, from the caller, not the version
3443          * we removed SOCK_CLOEXEC and SOCK_NONBLOCK from
3444          */
3445         fd = libc_socket(AF_UNIX, type, 0);
3446
3447         if (fd == -1) {
3448                 return -1;
3449         }
3450
3451         /* Check if we have a stale fd and remove it */
3452         swrap_remove_stale(fd);
3453
3454         si = &_si;
3455         si->family = family;
3456
3457         /* however, the rest of the socket_wrapper code expects just
3458          * the type, not the flags */
3459         si->type = real_type;
3460         si->protocol = protocol;
3461
3462         /*
3463          * Setup myname so getsockname() can succeed to find out the socket
3464          * type.
3465          */
3466         switch(si->family) {
3467         case AF_INET: {
3468                 struct sockaddr_in sin = {
3469                         .sin_family = AF_INET,
3470                 };
3471
3472                 si->myname.sa_socklen = sizeof(struct sockaddr_in);
3473                 memcpy(&si->myname.sa.in, &sin, si->myname.sa_socklen);
3474                 break;
3475         }
3476 #ifdef HAVE_IPV6
3477         case AF_INET6: {
3478                 struct sockaddr_in6 sin6 = {
3479                         .sin6_family = AF_INET6,
3480                 };
3481
3482                 si->myname.sa_socklen = sizeof(struct sockaddr_in6);
3483                 memcpy(&si->myname.sa.in6, &sin6, si->myname.sa_socklen);
3484                 break;
3485         }
3486 #endif
3487         default:
3488                 errno = EINVAL;
3489                 return -1;
3490         }
3491
3492         ret = swrap_create_socket(si, fd);
3493         if (ret == -1) {
3494                 int saved_errno = errno;
3495                 libc_close(fd);
3496                 errno = saved_errno;
3497                 return -1;
3498         }
3499
3500         SWRAP_LOG(SWRAP_LOG_TRACE,
3501                   "Created %s socket for protocol %s, fd=%d",
3502                   family == AF_INET ? "IPv4" : "IPv6",
3503                   real_type == SOCK_DGRAM ? "UDP" : "TCP",
3504                   fd);
3505
3506         return fd;
3507 }
3508
3509 int socket(int family, int type, int protocol)
3510 {
3511         return swrap_socket(family, type, protocol);
3512 }
3513
3514 /****************************************************************************
3515  *   SOCKETPAIR
3516  ***************************************************************************/
3517
3518 static int swrap_socketpair(int family, int type, int protocol, int sv[2])
3519 {
3520         int rc;
3521
3522         rc = libc_socketpair(family, type, protocol, sv);
3523         if (rc != -1) {
3524                 swrap_remove_stale(sv[0]);
3525                 swrap_remove_stale(sv[1]);
3526         }
3527
3528         return rc;
3529 }
3530
3531 int socketpair(int family, int type, int protocol, int sv[2])
3532 {
3533         return swrap_socketpair(family, type, protocol, sv);
3534 }
3535
3536 /****************************************************************************
3537  *   SOCKETPAIR
3538  ***************************************************************************/
3539
3540 #ifdef HAVE_TIMERFD_CREATE
3541 static int swrap_timerfd_create(int clockid, int flags)
3542 {
3543         int fd;
3544
3545         fd = libc_timerfd_create(clockid, flags);
3546         if (fd != -1) {
3547                 swrap_remove_stale(fd);
3548         }
3549
3550         return fd;
3551 }
3552
3553 int timerfd_create(int clockid, int flags)
3554 {
3555         return swrap_timerfd_create(clockid, flags);
3556 }
3557 #endif
3558
3559 /****************************************************************************
3560  *   PIPE
3561  ***************************************************************************/
3562
3563 static int swrap_pipe(int pipefd[2])
3564 {
3565         int rc;
3566
3567         rc = libc_pipe(pipefd);
3568         if (rc != -1) {
3569                 swrap_remove_stale(pipefd[0]);
3570                 swrap_remove_stale(pipefd[1]);
3571         }
3572
3573         return rc;
3574 }
3575
3576 int pipe(int pipefd[2])
3577 {
3578         return swrap_pipe(pipefd);
3579 }
3580
3581 /****************************************************************************
3582  *   ACCEPT
3583  ***************************************************************************/
3584
3585 static int swrap_accept(int s,
3586                         struct sockaddr *addr,
3587                         socklen_t *addrlen,
3588                         int flags)
3589 {
3590         struct socket_info *parent_si, *child_si;
3591         struct socket_info new_si = { 0 };
3592         int fd;
3593         int idx;
3594         struct swrap_address un_addr = {
3595                 .sa_socklen = sizeof(struct sockaddr_un),
3596         };
3597         struct swrap_address un_my_addr = {
3598                 .sa_socklen = sizeof(struct sockaddr_un),
3599         };
3600         struct swrap_address in_addr = {
3601                 .sa_socklen = sizeof(struct sockaddr_storage),
3602         };
3603         struct swrap_address in_my_addr = {
3604                 .sa_socklen = sizeof(struct sockaddr_storage),
3605         };
3606         int ret;
3607
3608         parent_si = find_socket_info(s);
3609         if (!parent_si) {
3610 #ifdef HAVE_ACCEPT4
3611                 return libc_accept4(s, addr, addrlen, flags);
3612 #else
3613                 UNUSED(flags);
3614                 return libc_accept(s, addr, addrlen);
3615 #endif
3616         }
3617
3618
3619         /*
3620          * prevent parent_si from being altered / closed
3621          * while we read it
3622          */
3623         SWRAP_LOCK_SI(parent_si);
3624
3625         /*
3626          * assume out sockaddr have the same size as the in parent
3627          * socket family
3628          */
3629         in_addr.sa_socklen = socket_length(parent_si->family);
3630         if (in_addr.sa_socklen <= 0) {
3631                 SWRAP_UNLOCK_SI(parent_si);
3632                 errno = EINVAL;
3633                 return -1;
3634         }
3635
3636         SWRAP_UNLOCK_SI(parent_si);
3637
3638 #ifdef HAVE_ACCEPT4
3639         ret = libc_accept4(s, &un_addr.sa.s, &un_addr.sa_socklen, flags);
3640 #else
3641         UNUSED(flags);
3642         ret = libc_accept(s, &un_addr.sa.s, &un_addr.sa_socklen);
3643 #endif
3644         if (ret == -1) {
3645                 if (errno == ENOTSOCK) {
3646                         /* Remove stale fds */
3647                         swrap_remove_stale(s);
3648                 }
3649                 return ret;
3650         }
3651
3652         fd = ret;
3653
3654         /* Check if we have a stale fd and remove it */
3655         swrap_remove_stale(fd);
3656
3657         SWRAP_LOCK_SI(parent_si);
3658
3659         ret = sockaddr_convert_from_un(parent_si,
3660                                        &un_addr.sa.un,
3661                                        un_addr.sa_socklen,
3662                                        parent_si->family,
3663                                        &in_addr.sa.s,
3664                                        &in_addr.sa_socklen);
3665         if (ret == -1) {
3666                 SWRAP_UNLOCK_SI(parent_si);
3667                 libc_close(fd);
3668                 return ret;
3669         }
3670
3671         child_si = &new_si;
3672
3673         child_si->family = parent_si->family;
3674         child_si->type = parent_si->type;
3675         child_si->protocol = parent_si->protocol;
3676         child_si->bound = 1;
3677         child_si->is_server = 1;
3678         child_si->connected = 1;
3679
3680         SWRAP_UNLOCK_SI(parent_si);
3681
3682         child_si->peername = (struct swrap_address) {
3683                 .sa_socklen = in_addr.sa_socklen,
3684         };
3685         memcpy(&child_si->peername.sa.ss, &in_addr.sa.ss, in_addr.sa_socklen);
3686
3687         if (addr != NULL && addrlen != NULL) {
3688                 size_t copy_len = MIN(*addrlen, in_addr.sa_socklen);
3689                 if (copy_len > 0) {
3690                         memcpy(addr, &in_addr.sa.ss, copy_len);
3691                 }
3692                 *addrlen = in_addr.sa_socklen;
3693         }
3694
3695         ret = libc_getsockname(fd,
3696                                &un_my_addr.sa.s,
3697                                &un_my_addr.sa_socklen);
3698         if (ret == -1) {
3699                 libc_close(fd);
3700                 return ret;
3701         }
3702
3703         ret = sockaddr_convert_from_un(child_si,
3704                                        &un_my_addr.sa.un,
3705                                        un_my_addr.sa_socklen,
3706                                        child_si->family,
3707                                        &in_my_addr.sa.s,
3708                                        &in_my_addr.sa_socklen);
3709         if (ret == -1) {
3710                 libc_close(fd);
3711                 return ret;
3712         }
3713
3714         SWRAP_LOG(SWRAP_LOG_TRACE,
3715                   "accept() path=%s, fd=%d",
3716                   un_my_addr.sa.un.sun_path, s);
3717
3718         child_si->myname = (struct swrap_address) {
3719                 .sa_socklen = in_my_addr.sa_socklen,
3720         };
3721         memcpy(&child_si->myname.sa.ss, &in_my_addr.sa.ss, in_my_addr.sa_socklen);
3722
3723         idx = swrap_create_socket(&new_si, fd);
3724         if (idx == -1) {
3725                 int saved_errno = errno;
3726                 libc_close(fd);
3727                 errno = saved_errno;
3728                 return -1;
3729         }
3730
3731         if (addr != NULL) {
3732                 struct socket_info *si = swrap_get_socket_info(idx);
3733
3734                 SWRAP_LOCK_SI(si);
3735                 swrap_pcap_dump_packet(si, addr, SWRAP_ACCEPT_SEND, NULL, 0);
3736                 swrap_pcap_dump_packet(si, addr, SWRAP_ACCEPT_RECV, NULL, 0);
3737                 swrap_pcap_dump_packet(si, addr, SWRAP_ACCEPT_ACK, NULL, 0);
3738                 SWRAP_UNLOCK_SI(si);
3739         }
3740
3741         return fd;
3742 }
3743
3744 #ifdef HAVE_ACCEPT4
3745 int accept4(int s, struct sockaddr *addr, socklen_t *addrlen, int flags)
3746 {
3747         return swrap_accept(s, addr, (socklen_t *)addrlen, flags);
3748 }
3749 #endif
3750
3751 #ifdef HAVE_ACCEPT_PSOCKLEN_T
3752 int accept(int s, struct sockaddr *addr, Psocklen_t addrlen)
3753 #else
3754 int accept(int s, struct sockaddr *addr, socklen_t *addrlen)
3755 #endif
3756 {
3757         return swrap_accept(s, addr, (socklen_t *)addrlen, 0);
3758 }
3759
3760 static int autobind_start_init;
3761 static int autobind_start;
3762
3763 /* using sendto() or connect() on an unbound socket would give the
3764    recipient no way to reply, as unlike UDP and TCP, a unix domain
3765    socket can't auto-assign ephemeral port numbers, so we need to
3766    assign it here.
3767    Note: this might change the family from ipv6 to ipv4
3768 */
3769 static int swrap_auto_bind(int fd, struct socket_info *si, int family)
3770 {
3771         struct swrap_address un_addr = {
3772                 .sa_socklen = sizeof(struct sockaddr_un),
3773         };
3774         int i;
3775         char type;
3776         int ret;
3777         int port;
3778         struct stat st;
3779         char *swrap_dir = NULL;
3780
3781         swrap_mutex_lock(&autobind_start_mutex);
3782
3783         if (autobind_start_init != 1) {
3784                 autobind_start_init = 1;
3785                 autobind_start = getpid();
3786                 autobind_start %= 50000;
3787                 autobind_start += 10000;
3788         }
3789
3790         un_addr.sa.un.sun_family = AF_UNIX;
3791
3792         switch (family) {
3793         case AF_INET: {
3794                 struct sockaddr_in in;
3795
3796                 switch (si->type) {
3797                 case SOCK_STREAM:
3798                         type = SOCKET_TYPE_CHAR_TCP;
3799                         break;
3800                 case SOCK_DGRAM:
3801                         type = SOCKET_TYPE_CHAR_UDP;
3802                         break;
3803                 default:
3804                         errno = ESOCKTNOSUPPORT;
3805                         ret = -1;
3806                         goto done;
3807                 }
3808
3809                 memset(&in, 0, sizeof(in));
3810                 in.sin_family = AF_INET;
3811                 in.sin_addr.s_addr = htonl(swrap_ipv4_iface(
3812                                            socket_wrapper_default_iface()));
3813
3814                 si->myname = (struct swrap_address) {
3815                         .sa_socklen = sizeof(in),
3816                 };
3817                 memcpy(&si->myname.sa.in, &in, si->myname.sa_socklen);
3818                 break;
3819         }
3820 #ifdef HAVE_IPV6
3821         case AF_INET6: {
3822                 struct sockaddr_in6 in6;
3823
3824                 if (si->family != family) {
3825                         errno = ENETUNREACH;
3826                         ret = -1;
3827                         goto done;
3828                 }
3829
3830                 switch (si->type) {
3831                 case SOCK_STREAM:
3832                         type = SOCKET_TYPE_CHAR_TCP_V6;
3833                         break;
3834                 case SOCK_DGRAM:
3835                         type = SOCKET_TYPE_CHAR_UDP_V6;
3836                         break;
3837                 default:
3838                         errno = ESOCKTNOSUPPORT;
3839                         ret = -1;
3840                         goto done;
3841                 }
3842
3843                 memset(&in6, 0, sizeof(in6));
3844                 in6.sin6_family = AF_INET6;
3845                 in6.sin6_addr = *swrap_ipv6();
3846                 in6.sin6_addr.s6_addr[15] = socket_wrapper_default_iface();
3847
3848                 si->myname = (struct swrap_address) {
3849                         .sa_socklen = sizeof(in6),
3850                 };
3851                 memcpy(&si->myname.sa.in6, &in6, si->myname.sa_socklen);
3852                 break;
3853         }
3854 #endif
3855         default:
3856                 errno = ESOCKTNOSUPPORT;
3857                 ret = -1;
3858                 goto done;
3859         }
3860
3861         if (autobind_start > 60000) {
3862                 autobind_start = 10000;
3863         }
3864
3865         swrap_dir = socket_wrapper_dir();
3866         if (swrap_dir == NULL) {
3867                 errno = EINVAL;
3868                 ret = -1;
3869                 goto done;
3870         }
3871
3872         for (i = 0; i < SOCKET_MAX_SOCKETS; i++) {
3873                 port = autobind_start + i;
3874                 swrap_un_path(&un_addr.sa.un,
3875                               swrap_dir,
3876                               type,
3877                               socket_wrapper_default_iface(),
3878                               port);
3879                 if (stat(un_addr.sa.un.sun_path, &st) == 0) continue;
3880
3881                 ret = libc_bind(fd, &un_addr.sa.s, un_addr.sa_socklen);
3882                 if (ret == -1) {
3883                         goto done;
3884                 }
3885
3886                 si->un_addr = un_addr.sa.un;
3887
3888                 si->bound = 1;
3889                 autobind_start = port + 1;
3890                 break;
3891         }
3892         if (i == SOCKET_MAX_SOCKETS) {
3893                 SWRAP_LOG(SWRAP_LOG_ERROR, "Too many open unix sockets (%u) for "
3894                                            "interface "SOCKET_FORMAT,
3895                                            SOCKET_MAX_SOCKETS,
3896                                            type,
3897                                            socket_wrapper_default_iface(),
3898                                            0);
3899                 errno = ENFILE;
3900                 ret = -1;
3901                 goto done;
3902         }
3903
3904         si->family = family;
3905         set_port(si->family, port, &si->myname);
3906
3907         ret = 0;
3908
3909 done:
3910         SAFE_FREE(swrap_dir);
3911         swrap_mutex_unlock(&autobind_start_mutex);
3912         return ret;
3913 }
3914
3915 /****************************************************************************
3916  *   CONNECT
3917  ***************************************************************************/
3918
3919 static int swrap_connect(int s, const struct sockaddr *serv_addr,
3920                          socklen_t addrlen)
3921 {
3922         int ret;
3923         struct swrap_address un_addr = {
3924                 .sa_socklen = sizeof(struct sockaddr_un),
3925         };
3926         struct socket_info *si = find_socket_info(s);
3927         int bcast = 0;
3928
3929         if (!si) {
3930                 return libc_connect(s, serv_addr, addrlen);
3931         }
3932
3933         SWRAP_LOCK_SI(si);
3934
3935         if (si->bound == 0) {
3936                 ret = swrap_auto_bind(s, si, serv_addr->sa_family);
3937                 if (ret == -1) {
3938                         goto done;
3939                 }
3940         }
3941
3942         if (si->family != serv_addr->sa_family) {
3943                 SWRAP_LOG(SWRAP_LOG_ERROR,
3944                           "called for fd=%d (family=%d) called with invalid family=%d",
3945                           s, si->family, serv_addr->sa_family);
3946                 errno = EINVAL;
3947                 ret = -1;
3948                 goto done;
3949         }
3950
3951         ret = sockaddr_convert_to_un(si, serv_addr,
3952                                      addrlen, &un_addr.sa.un, 0, &bcast);
3953         if (ret == -1) {
3954                 goto done;
3955         }
3956
3957         if (bcast) {
3958                 errno = ENETUNREACH;
3959                 ret = -1;
3960                 goto done;
3961         }
3962
3963         if (si->type == SOCK_DGRAM) {
3964                 si->defer_connect = 1;
3965                 ret = 0;
3966         } else {
3967                 swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_SEND, NULL, 0);
3968
3969                 ret = libc_connect(s,
3970                                    &un_addr.sa.s,
3971                                    un_addr.sa_socklen);
3972         }
3973
3974         SWRAP_LOG(SWRAP_LOG_TRACE,
3975                   "connect() path=%s, fd=%d",
3976                   un_addr.sa.un.sun_path, s);
3977
3978
3979         /* to give better errors */
3980         if (ret == -1 && errno == ENOENT) {
3981                 errno = EHOSTUNREACH;
3982         }
3983
3984         if (ret == 0) {
3985                 si->peername = (struct swrap_address) {
3986                         .sa_socklen = addrlen,
3987                 };
3988
3989                 memcpy(&si->peername.sa.ss, serv_addr, addrlen);
3990                 si->connected = 1;
3991
3992                 /*
3993                  * When we connect() on a socket than we have to bind the
3994                  * outgoing connection on the interface we use for the
3995                  * transport. We already bound it on the right interface
3996                  * but here we have to update the name so getsockname()
3997                  * returns correct information.
3998                  */
3999                 if (si->bindname.sa_socklen > 0) {
4000                         si->myname = (struct swrap_address) {
4001                                 .sa_socklen = si->bindname.sa_socklen,
4002                         };
4003
4004                         memcpy(&si->myname.sa.ss,
4005                                &si->bindname.sa.ss,
4006                                si->bindname.sa_socklen);
4007
4008                         /* Cleanup bindname */
4009                         si->bindname = (struct swrap_address) {
4010                                 .sa_socklen = 0,
4011                         };
4012                 }
4013
4014                 swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_RECV, NULL, 0);
4015                 swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_ACK, NULL, 0);
4016         } else {
4017                 swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_UNREACH, NULL, 0);
4018         }
4019
4020 done:
4021         SWRAP_UNLOCK_SI(si);
4022         return ret;
4023 }
4024
4025 int connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
4026 {
4027         return swrap_connect(s, serv_addr, addrlen);
4028 }
4029
4030 /****************************************************************************
4031  *   BIND
4032  ***************************************************************************/
4033
4034 static int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
4035 {
4036         int ret;
4037         struct swrap_address un_addr = {
4038                 .sa_socklen = sizeof(struct sockaddr_un),
4039         };
4040         struct socket_info *si = find_socket_info(s);
4041         int bind_error = 0;
4042 #if 0 /* FIXME */
4043         bool in_use;
4044 #endif
4045
4046         if (!si) {
4047                 return libc_bind(s, myaddr, addrlen);
4048         }
4049
4050         SWRAP_LOCK_SI(si);
4051
4052         switch (si->family) {
4053         case AF_INET: {
4054                 const struct sockaddr_in *sin;
4055                 if (addrlen < sizeof(struct sockaddr_in)) {
4056                         bind_error = EINVAL;
4057                         break;
4058                 }
4059
4060                 sin = (const struct sockaddr_in *)(const void *)myaddr;
4061
4062                 if (sin->sin_family != AF_INET) {
4063                         bind_error = EAFNOSUPPORT;
4064                 }
4065
4066                 /* special case for AF_UNSPEC */
4067                 if (sin->sin_family == AF_UNSPEC &&
4068                     (sin->sin_addr.s_addr == htonl(INADDR_ANY)))
4069                 {
4070                         bind_error = 0;
4071                 }
4072
4073                 break;
4074         }
4075 #ifdef HAVE_IPV6
4076         case AF_INET6: {
4077                 const struct sockaddr_in6 *sin6;
4078                 if (addrlen < sizeof(struct sockaddr_in6)) {
4079                         bind_error = EINVAL;
4080                         break;
4081                 }
4082
4083                 sin6 = (const struct sockaddr_in6 *)(const void *)myaddr;
4084
4085                 if (sin6->sin6_family != AF_INET6) {
4086                         bind_error = EAFNOSUPPORT;
4087                 }
4088
4089                 break;
4090         }
4091 #endif
4092         default:
4093                 bind_error = EINVAL;
4094                 break;
4095         }
4096
4097         if (bind_error != 0) {
4098                 errno = bind_error;
4099                 ret = -1;
4100                 goto out;
4101         }
4102
4103 #if 0 /* FIXME */
4104         in_use = check_addr_port_in_use(myaddr, addrlen);
4105         if (in_use) {
4106                 errno = EADDRINUSE;
4107                 ret = -1;
4108                 goto out;
4109         }
4110 #endif
4111
4112         si->myname.sa_socklen = addrlen;
4113         memcpy(&si->myname.sa.ss, myaddr, addrlen);
4114
4115         ret = sockaddr_convert_to_un(si,
4116                                      myaddr,
4117                                      addrlen,
4118                                      &un_addr.sa.un,
4119                                      1,
4120                                      &si->bcast);
4121         if (ret == -1) {
4122                 goto out;
4123         }
4124
4125         unlink(un_addr.sa.un.sun_path);
4126
4127         ret = libc_bind(s, &un_addr.sa.s, un_addr.sa_socklen);
4128
4129         SWRAP_LOG(SWRAP_LOG_TRACE,
4130                   "bind() path=%s, fd=%d",
4131                   un_addr.sa.un.sun_path, s);
4132
4133         if (ret == 0) {
4134                 si->bound = 1;
4135         }
4136
4137 out:
4138         SWRAP_UNLOCK_SI(si);
4139
4140         return ret;
4141 }
4142
4143 int bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
4144 {
4145         return swrap_bind(s, myaddr, addrlen);
4146 }
4147
4148 /****************************************************************************
4149  *   BINDRESVPORT
4150  ***************************************************************************/
4151
4152 #ifdef HAVE_BINDRESVPORT
4153 static int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen);
4154
4155 static int swrap_bindresvport_sa(int sd, struct sockaddr *sa)
4156 {
4157         struct swrap_address myaddr = {
4158                 .sa_socklen = sizeof(struct sockaddr_storage),
4159         };
4160         socklen_t salen;
4161         static uint16_t port;
4162         uint16_t i;
4163         int rc = -1;
4164         int af;
4165
4166 #define SWRAP_STARTPORT 600
4167 #define SWRAP_ENDPORT (IPPORT_RESERVED - 1)
4168 #define SWRAP_NPORTS (SWRAP_ENDPORT - SWRAP_STARTPORT + 1)
4169
4170         if (port == 0) {
4171                 port = (getpid() % SWRAP_NPORTS) + SWRAP_STARTPORT;
4172         }
4173
4174         if (sa == NULL) {
4175                 salen = myaddr.sa_socklen;
4176                 sa = &myaddr.sa.s;
4177
4178                 rc = swrap_getsockname(sd, &myaddr.sa.s, &salen);
4179                 if (rc < 0) {
4180                         return -1;
4181                 }
4182
4183                 af = sa->sa_family;
4184                 memset(&myaddr.sa.ss, 0, salen);
4185         } else {
4186                 af = sa->sa_family;
4187         }
4188
4189         for (i = 0; i < SWRAP_NPORTS; i++, port++) {
4190                 switch(af) {
4191                 case AF_INET: {
4192                         struct sockaddr_in *sinp = (struct sockaddr_in *)(void *)sa;
4193
4194                         salen = sizeof(struct sockaddr_in);
4195                         sinp->sin_port = htons(port);
4196                         break;
4197                 }
4198                 case AF_INET6: {
4199                         struct sockaddr_in6 *sin6p = (struct sockaddr_in6 *)(void *)sa;
4200
4201                         salen = sizeof(struct sockaddr_in6);
4202                         sin6p->sin6_port = htons(port);
4203                         break;
4204                 }
4205                 default:
4206                         errno = EAFNOSUPPORT;
4207                         return -1;
4208                 }
4209                 sa->sa_family = af;
4210
4211                 if (port > SWRAP_ENDPORT) {
4212                         port = SWRAP_STARTPORT;
4213                 }
4214
4215                 rc = swrap_bind(sd, (struct sockaddr *)sa, salen);
4216                 if (rc == 0 || errno != EADDRINUSE) {
4217                         break;
4218                 }
4219         }
4220
4221         return rc;
4222 }
4223
4224 int bindresvport(int sockfd, struct sockaddr_in *sinp)
4225 {
4226         return swrap_bindresvport_sa(sockfd, (struct sockaddr *)sinp);
4227 }
4228 #endif
4229
4230 /****************************************************************************
4231  *   LISTEN
4232  ***************************************************************************/
4233
4234 static int swrap_listen(int s, int backlog)
4235 {
4236         int ret;
4237         struct socket_info *si = find_socket_info(s);
4238
4239         if (!si) {
4240                 return libc_listen(s, backlog);
4241         }
4242
4243         SWRAP_LOCK_SI(si);
4244
4245         if (si->bound == 0) {
4246                 ret = swrap_auto_bind(s, si, si->family);
4247                 if (ret == -1) {
4248                         errno = EADDRINUSE;
4249                         goto out;
4250                 }
4251         }
4252
4253         ret = libc_listen(s, backlog);
4254         if (ret == 0) {
4255                 si->listening = 1;
4256         }
4257
4258 out:
4259         SWRAP_UNLOCK_SI(si);
4260
4261         return ret;
4262 }
4263
4264 int listen(int s, int backlog)
4265 {
4266         return swrap_listen(s, backlog);
4267 }
4268
4269 /****************************************************************************
4270  *   FOPEN
4271  ***************************************************************************/
4272
4273 static FILE *swrap_fopen(const char *name, const char *mode)
4274 {
4275         FILE *fp;
4276
4277         fp = libc_fopen(name, mode);
4278         if (fp != NULL) {
4279                 int fd = fileno(fp);
4280
4281                 swrap_remove_stale(fd);
4282         }
4283
4284         return fp;
4285 }
4286
4287 FILE *fopen(const char *name, const char *mode)
4288 {
4289         return swrap_fopen(name, mode);
4290 }
4291
4292 /****************************************************************************
4293  *   FOPEN64
4294  ***************************************************************************/
4295
4296 #ifdef HAVE_FOPEN64
4297 static FILE *swrap_fopen64(const char *name, const char *mode)
4298 {
4299         FILE *fp;
4300
4301         fp = libc_fopen64(name, mode);
4302         if (fp != NULL) {
4303                 int fd = fileno(fp);
4304
4305                 swrap_remove_stale(fd);
4306         }
4307
4308         return fp;
4309 }
4310
4311 FILE *fopen64(const char *name, const char *mode)
4312 {
4313         return swrap_fopen64(name, mode);
4314 }
4315 #endif /* HAVE_FOPEN64 */
4316
4317 /****************************************************************************
4318  *   OPEN
4319  ***************************************************************************/
4320
4321 static int swrap_vopen(const char *pathname, int flags, va_list ap)
4322 {
4323         int ret;
4324
4325         ret = libc_vopen(pathname, flags, ap);
4326         if (ret != -1) {
4327                 /*
4328                  * There are methods for closing descriptors (libc-internal code
4329                  * paths, direct syscalls) which close descriptors in ways that
4330                  * we can't intercept, so try to recover when we notice that
4331                  * that's happened
4332                  */
4333                 swrap_remove_stale(ret);
4334         }
4335         return ret;
4336 }
4337
4338 int open(const char *pathname, int flags, ...)
4339 {
4340         va_list ap;
4341         int fd;
4342
4343         va_start(ap, flags);
4344         fd = swrap_vopen(pathname, flags, ap);
4345         va_end(ap);
4346
4347         return fd;
4348 }
4349
4350 /****************************************************************************
4351  *   OPEN64
4352  ***************************************************************************/
4353
4354 #ifdef HAVE_OPEN64
4355 static int swrap_vopen64(const char *pathname, int flags, va_list ap)
4356 {
4357         int ret;
4358
4359         ret = libc_vopen64(pathname, flags, ap);
4360         if (ret != -1) {
4361                 /*
4362                  * There are methods for closing descriptors (libc-internal code
4363                  * paths, direct syscalls) which close descriptors in ways that
4364                  * we can't intercept, so try to recover when we notice that
4365                  * that's happened
4366                  */
4367                 swrap_remove_stale(ret);
4368         }
4369         return ret;
4370 }
4371
4372 int open64(const char *pathname, int flags, ...)
4373 {
4374         va_list ap;
4375         int fd;
4376
4377         va_start(ap, flags);
4378         fd = swrap_vopen64(pathname, flags, ap);
4379         va_end(ap);
4380
4381         return fd;
4382 }
4383 #endif /* HAVE_OPEN64 */
4384
4385 /****************************************************************************
4386  *   OPENAT
4387  ***************************************************************************/
4388
4389 static int swrap_vopenat(int dirfd, const char *path, int flags, va_list ap)
4390 {
4391         int ret;
4392
4393         ret = libc_vopenat(dirfd, path, flags, ap);
4394         if (ret != -1) {
4395                 /*
4396                  * There are methods for closing descriptors (libc-internal code
4397                  * paths, direct syscalls) which close descriptors in ways that
4398                  * we can't intercept, so try to recover when we notice that
4399                  * that's happened
4400                  */
4401                 swrap_remove_stale(ret);
4402         }
4403
4404         return ret;
4405 }
4406
4407 int openat(int dirfd, const char *path, int flags, ...)
4408 {
4409         va_list ap;
4410         int fd;
4411
4412         va_start(ap, flags);
4413         fd = swrap_vopenat(dirfd, path, flags, ap);
4414         va_end(ap);
4415
4416         return fd;
4417 }
4418
4419 /****************************************************************************
4420  *   GETPEERNAME
4421  ***************************************************************************/
4422
4423 static int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
4424 {
4425         struct socket_info *si = find_socket_info(s);
4426         socklen_t len;
4427         int ret = -1;
4428
4429         if (!si) {
4430                 return libc_getpeername(s, name, addrlen);
4431         }
4432
4433         SWRAP_LOCK_SI(si);
4434
4435         if (si->peername.sa_socklen == 0)
4436         {
4437                 errno = ENOTCONN;
4438                 goto out;
4439         }
4440
4441         len = MIN(*addrlen, si->peername.sa_socklen);
4442         if (len == 0) {
4443                 ret = 0;
4444                 goto out;
4445         }
4446
4447         memcpy(name, &si->peername.sa.ss, len);
4448         *addrlen = si->peername.sa_socklen;
4449
4450         ret = 0;
4451 out:
4452         SWRAP_UNLOCK_SI(si);
4453
4454         return ret;
4455 }
4456
4457 #ifdef HAVE_ACCEPT_PSOCKLEN_T
4458 int getpeername(int s, struct sockaddr *name, Psocklen_t addrlen)
4459 #else
4460 int getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
4461 #endif
4462 {
4463         return swrap_getpeername(s, name, (socklen_t *)addrlen);
4464 }
4465
4466 /****************************************************************************
4467  *   GETSOCKNAME
4468  ***************************************************************************/
4469
4470 static int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
4471 {
4472         struct socket_info *si = find_socket_info(s);
4473         socklen_t len;
4474         int ret = -1;
4475
4476         if (!si) {
4477                 return libc_getsockname(s, name, addrlen);
4478         }
4479
4480         SWRAP_LOCK_SI(si);
4481
4482         len = MIN(*addrlen, si->myname.sa_socklen);
4483         if (len == 0) {
4484                 ret = 0;
4485                 goto out;
4486         }
4487
4488         memcpy(name, &si->myname.sa.ss, len);
4489         *addrlen = si->myname.sa_socklen;
4490
4491         ret = 0;
4492 out:
4493         SWRAP_UNLOCK_SI(si);
4494
4495         return ret;
4496 }
4497
4498 #ifdef HAVE_ACCEPT_PSOCKLEN_T
4499 int getsockname(int s, struct sockaddr *name, Psocklen_t addrlen)
4500 #else
4501 int getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
4502 #endif
4503 {
4504         return swrap_getsockname(s, name, (socklen_t *)addrlen);
4505 }
4506
4507 /****************************************************************************
4508  *   GETSOCKOPT
4509  ***************************************************************************/
4510
4511 #ifndef SO_PROTOCOL
4512 # ifdef SO_PROTOTYPE /* The Solaris name */
4513 #  define SO_PROTOCOL SO_PROTOTYPE
4514 # endif /* SO_PROTOTYPE */
4515 #endif /* SO_PROTOCOL */
4516
4517 static int swrap_getsockopt(int s, int level, int optname,
4518                             void *optval, socklen_t *optlen)
4519 {
4520         struct socket_info *si = find_socket_info(s);
4521         int ret;
4522
4523         if (!si) {
4524                 return libc_getsockopt(s,
4525                                        level,
4526                                        optname,
4527                                        optval,
4528                                        optlen);
4529         }
4530
4531         SWRAP_LOCK_SI(si);
4532
4533         if (level == SOL_SOCKET) {
4534                 switch (optname) {
4535 #ifdef SO_DOMAIN
4536                 case SO_DOMAIN:
4537                         if (optval == NULL || optlen == NULL ||
4538                             *optlen < (socklen_t)sizeof(int)) {
4539                                 errno = EINVAL;
4540                                 ret = -1;
4541                                 goto done;
4542                         }
4543
4544                         *optlen = sizeof(int);
4545                         *(int *)optval = si->family;
4546                         ret = 0;
4547                         goto done;
4548 #endif /* SO_DOMAIN */
4549
4550 #ifdef SO_PROTOCOL
4551                 case SO_PROTOCOL:
4552                         if (optval == NULL || optlen == NULL ||
4553                             *optlen < (socklen_t)sizeof(int)) {
4554                                 errno = EINVAL;
4555                                 ret = -1;
4556                                 goto done;
4557                         }
4558
4559                         *optlen = sizeof(int);
4560                         *(int *)optval = si->protocol;
4561                         ret = 0;
4562                         goto done;
4563 #endif /* SO_PROTOCOL */
4564                 case SO_TYPE:
4565                         if (optval == NULL || optlen == NULL ||
4566                             *optlen < (socklen_t)sizeof(int)) {
4567                                 errno = EINVAL;
4568                                 ret = -1;
4569                                 goto done;
4570                         }
4571
4572                         *optlen = sizeof(int);
4573                         *(int *)optval = si->type;
4574                         ret = 0;
4575                         goto done;
4576                 default:
4577                         ret = libc_getsockopt(s,
4578                                               level,
4579                                               optname,
4580                                               optval,
4581                                               optlen);
4582                         goto done;
4583                 }
4584         } else if (level == IPPROTO_TCP) {
4585                 switch (optname) {
4586 #ifdef TCP_NODELAY
4587                 case TCP_NODELAY:
4588                         /*
4589                          * This enables sending packets directly out over TCP.
4590                          * As a unix socket is doing that any way, report it as
4591                          * enabled.
4592                          */
4593                         if (optval == NULL || optlen == NULL ||
4594                             *optlen < (socklen_t)sizeof(int)) {
4595                                 errno = EINVAL;
4596                                 ret = -1;
4597                                 goto done;
4598                         }
4599
4600                         *optlen = sizeof(int);
4601                         *(int *)optval = si->tcp_nodelay;
4602
4603                         ret = 0;
4604                         goto done;
4605 #endif /* TCP_NODELAY */
4606 #ifdef TCP_INFO
4607                 case TCP_INFO: {
4608                         struct tcp_info info;
4609                         socklen_t ilen = sizeof(info);
4610
4611 #ifdef HAVE_NETINET_TCP_FSM_H
4612 /* This is FreeBSD */
4613 # define __TCP_LISTEN TCPS_LISTEN
4614 # define __TCP_ESTABLISHED TCPS_ESTABLISHED
4615 # define __TCP_CLOSE TCPS_CLOSED
4616 #else
4617 /* This is Linux */
4618 # define __TCP_LISTEN TCP_LISTEN
4619 # define __TCP_ESTABLISHED TCP_ESTABLISHED
4620 # define __TCP_CLOSE TCP_CLOSE
4621 #endif
4622
4623                         ZERO_STRUCT(info);
4624                         if (si->listening) {
4625                                 info.tcpi_state = __TCP_LISTEN;
4626                         } else if (si->connected) {
4627                                 /*
4628                                  * For now we just fake a few values
4629                                  * supported both by FreeBSD and Linux
4630                                  */
4631                                 info.tcpi_state = __TCP_ESTABLISHED;
4632                                 info.tcpi_rto = 200000;  /* 200 msec */
4633                                 info.tcpi_rtt = 5000;    /* 5 msec */
4634                                 info.tcpi_rttvar = 5000; /* 5 msec */
4635                         } else {
4636                                 info.tcpi_state = __TCP_CLOSE;
4637                                 info.tcpi_rto = 1000000;  /* 1 sec */
4638                                 info.tcpi_rtt = 0;
4639                                 info.tcpi_rttvar = 250000; /* 250 msec */
4640                         }
4641
4642                         if (optval == NULL || optlen == NULL ||
4643                             *optlen < (socklen_t)ilen) {
4644                                 errno = EINVAL;
4645                                 ret = -1;
4646                                 goto done;
4647                         }
4648
4649                         *optlen = ilen;
4650                         memcpy(optval, &info, ilen);
4651
4652                         ret = 0;
4653                         goto done;
4654                 }
4655 #endif /* TCP_INFO */
4656                 default:
4657                         break;
4658                 }
4659         }
4660
4661         errno = ENOPROTOOPT;
4662         ret = -1;
4663
4664 done:
4665         SWRAP_UNLOCK_SI(si);
4666         return ret;
4667 }
4668
4669 #ifdef HAVE_ACCEPT_PSOCKLEN_T
4670 int getsockopt(int s, int level, int optname, void *optval, Psocklen_t optlen)
4671 #else
4672 int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
4673 #endif
4674 {
4675         return swrap_getsockopt(s, level, optname, optval, (socklen_t *)optlen);
4676 }
4677
4678 /****************************************************************************
4679  *   SETSOCKOPT
4680  ***************************************************************************/
4681
4682 static int swrap_setsockopt(int s, int level, int optname,
4683                             const void *optval, socklen_t optlen)
4684 {
4685         struct socket_info *si = find_socket_info(s);
4686         int ret;
4687
4688         if (!si) {
4689                 return libc_setsockopt(s,
4690                                        level,
4691                                        optname,
4692                                        optval,
4693                                        optlen);
4694         }
4695
4696         if (level == SOL_SOCKET) {
4697                 return libc_setsockopt(s,
4698                                        level,
4699                                        optname,
4700                                        optval,
4701                                        optlen);
4702         }
4703
4704         SWRAP_LOCK_SI(si);
4705
4706         if (level == IPPROTO_TCP) {
4707                 switch (optname) {
4708 #ifdef TCP_NODELAY
4709                 case TCP_NODELAY: {
4710                         int i;
4711
4712                         /*
4713                          * This enables sending packets directly out over TCP.
4714                          * A unix socket is doing that any way.
4715                          */
4716                         if (optval == NULL || optlen == 0 ||
4717                             optlen < (socklen_t)sizeof(int)) {
4718                                 errno = EINVAL;
4719                                 ret = -1;
4720                                 goto done;
4721                         }
4722
4723                         i = *discard_const_p(int, optval);
4724                         if (i != 0 && i != 1) {
4725                                 errno = EINVAL;
4726                                 ret = -1;
4727                                 goto done;
4728                         }
4729                         si->tcp_nodelay = i;
4730
4731                         ret = 0;
4732                         goto done;
4733                 }
4734 #endif /* TCP_NODELAY */
4735                 default:
4736                         break;
4737                 }
4738         }
4739
4740         switch (si->family) {
4741         case AF_INET:
4742                 if (level == IPPROTO_IP) {
4743 #ifdef IP_PKTINFO
4744                         if (optname == IP_PKTINFO) {
4745                                 si->pktinfo = AF_INET;
4746                         }
4747 #endif /* IP_PKTINFO */
4748                 }
4749                 ret = 0;
4750                 goto done;
4751 #ifdef HAVE_IPV6
4752         case AF_INET6:
4753                 if (level == IPPROTO_IPV6) {
4754 #ifdef IPV6_RECVPKTINFO
4755                         if (optname == IPV6_RECVPKTINFO) {
4756                                 si->pktinfo = AF_INET6;
4757                         }
4758 #endif /* IPV6_PKTINFO */
4759                 }
4760                 ret = 0;
4761                 goto done;
4762 #endif
4763         default:
4764                 errno = ENOPROTOOPT;
4765                 ret = -1;
4766                 goto done;
4767         }
4768
4769 done:
4770         SWRAP_UNLOCK_SI(si);
4771         return ret;
4772 }
4773
4774 int setsockopt(int s, int level, int optname,
4775                const void *optval, socklen_t optlen)
4776 {
4777         return swrap_setsockopt(s, level, optname, optval, optlen);
4778 }
4779
4780 /****************************************************************************
4781  *   IOCTL
4782  ***************************************************************************/
4783
4784 static int swrap_vioctl(int s, unsigned long int r, va_list va)
4785 {
4786         struct socket_info *si = find_socket_info(s);
4787         va_list ap;
4788         int *value_ptr = NULL;
4789         int rc;
4790
4791         if (!si) {
4792                 return libc_vioctl(s, r, va);
4793         }
4794
4795         SWRAP_LOCK_SI(si);
4796
4797         va_copy(ap, va);
4798
4799         rc = libc_vioctl(s, r, va);
4800
4801         switch (r) {
4802         case FIONREAD:
4803                 if (rc == 0) {
4804                         value_ptr = ((int *)va_arg(ap, int *));
4805                 }
4806
4807                 if (rc == -1 && errno != EAGAIN && errno != ENOBUFS) {
4808                         swrap_pcap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
4809                 } else if (value_ptr != NULL && *value_ptr == 0) { /* END OF FILE */
4810                         swrap_pcap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
4811                 }
4812                 break;
4813 #ifdef FIONWRITE
4814         case FIONWRITE:
4815                 /* this is FreeBSD */
4816                 FALL_THROUGH; /* to TIOCOUTQ */
4817 #endif /* FIONWRITE */
4818         case TIOCOUTQ: /* same as SIOCOUTQ on Linux */
4819                 /*
4820                  * This may return more bytes then the application
4821                  * sent into the socket, for tcp it should
4822                  * return the number of unacked bytes.
4823                  *
4824                  * On AF_UNIX, all bytes are immediately acked!
4825                  */
4826                 if (rc == 0) {
4827                         value_ptr = ((int *)va_arg(ap, int *));
4828                         *value_ptr = 0;
4829                 }
4830                 break;
4831         }
4832
4833         va_end(ap);
4834
4835         SWRAP_UNLOCK_SI(si);
4836         return rc;
4837 }
4838
4839 #ifdef HAVE_IOCTL_INT
4840 int ioctl(int s, int r, ...)
4841 #else
4842 int ioctl(int s, unsigned long int r, ...)
4843 #endif
4844 {
4845         va_list va;
4846         int rc;
4847
4848         va_start(va, r);
4849
4850         rc = swrap_vioctl(s, (unsigned long int) r, va);
4851
4852         va_end(va);
4853
4854         return rc;
4855 }
4856
4857 /*****************
4858  * CMSG
4859  *****************/
4860
4861 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
4862
4863 #ifndef CMSG_ALIGN
4864 # ifdef _ALIGN /* BSD */
4865 #define CMSG_ALIGN _ALIGN
4866 # else
4867 #define CMSG_ALIGN(len) (((len) + sizeof(size_t) - 1) & ~(sizeof(size_t) - 1))
4868 # endif /* _ALIGN */
4869 #endif /* CMSG_ALIGN */
4870
4871 /**
4872  * @brief Add a cmsghdr to a msghdr.
4873  *
4874  * This is an function to add any type of cmsghdr. It will operate on the
4875  * msg->msg_control and msg->msg_controllen you pass in by adapting them to
4876  * the buffer position after the added cmsg element. Hence, this function is
4877  * intended to be used with an intermediate msghdr and not on the original
4878  * one handed in by the client.
4879  *
4880  * @param[in]  msg      The msghdr to which to add the cmsg.
4881  *
4882  * @param[in]  level    The cmsg level to set.
4883  *
4884  * @param[in]  type     The cmsg type to set.
4885  *
4886  * @param[in]  data     The cmsg data to set.
4887  *
4888  * @param[in]  len      the length of the data to set.
4889  */
4890 static void swrap_msghdr_add_cmsghdr(struct msghdr *msg,
4891                                      int level,
4892                                      int type,
4893                                      const void *data,
4894                                      size_t len)
4895 {
4896         size_t cmlen = CMSG_LEN(len);
4897         size_t cmspace = CMSG_SPACE(len);
4898         uint8_t cmbuf[cmspace];
4899         void *cast_ptr = (void *)cmbuf;
4900         struct cmsghdr *cm = (struct cmsghdr *)cast_ptr;
4901         uint8_t *p;
4902
4903         memset(cmbuf, 0, cmspace);
4904
4905         if (msg->msg_controllen < cmlen) {
4906                 cmlen = msg->msg_controllen;
4907                 msg->msg_flags |= MSG_CTRUNC;
4908         }
4909
4910         if (msg->msg_controllen < cmspace) {
4911                 cmspace = msg->msg_controllen;
4912         }
4913
4914         /*
4915          * We copy the full input data into an intermediate cmsghdr first
4916          * in order to more easily cope with truncation.
4917          */
4918         cm->cmsg_len = cmlen;
4919         cm->cmsg_level = level;
4920         cm->cmsg_type = type;
4921         memcpy(CMSG_DATA(cm), data, len);
4922
4923         /*
4924          * We now copy the possibly truncated buffer.
4925          * We copy cmlen bytes, but consume cmspace bytes,
4926          * leaving the possible padding uninitialiazed.
4927          */
4928         p = (uint8_t *)msg->msg_control;
4929         memcpy(p, cm, cmlen);
4930         p += cmspace;
4931         msg->msg_control = p;
4932         msg->msg_controllen -= cmspace;
4933
4934         return;
4935 }
4936
4937 static int swrap_msghdr_add_pktinfo(struct socket_info *si,
4938                                     struct msghdr *msg)
4939 {
4940         /* Add packet info */
4941         switch (si->pktinfo) {
4942 #if defined(IP_PKTINFO) && (defined(HAVE_STRUCT_IN_PKTINFO) || defined(IP_RECVDSTADDR))
4943         case AF_INET: {
4944                 struct sockaddr_in *sin;
4945 #if defined(HAVE_STRUCT_IN_PKTINFO)
4946                 struct in_pktinfo pkt;
4947 #elif defined(IP_RECVDSTADDR)
4948                 struct in_addr pkt;
4949 #endif
4950
4951                 if (si->bindname.sa_socklen == sizeof(struct sockaddr_in)) {
4952                         sin = &si->bindname.sa.in;
4953                 } else {
4954                         if (si->myname.sa_socklen != sizeof(struct sockaddr_in)) {
4955                                 return 0;
4956                         }
4957                         sin = &si->myname.sa.in;
4958                 }
4959
4960                 ZERO_STRUCT(pkt);
4961
4962 #if defined(HAVE_STRUCT_IN_PKTINFO)
4963                 pkt.ipi_ifindex = socket_wrapper_default_iface();
4964                 pkt.ipi_addr.s_addr = sin->sin_addr.s_addr;
4965 #elif defined(IP_RECVDSTADDR)
4966                 pkt = sin->sin_addr;
4967 #endif
4968
4969                 swrap_msghdr_add_cmsghdr(msg, IPPROTO_IP, IP_PKTINFO,
4970                                          &pkt, sizeof(pkt));
4971
4972                 break;
4973         }
4974 #endif /* IP_PKTINFO */
4975 #if defined(HAVE_IPV6)
4976         case AF_INET6: {
4977 #if defined(IPV6_PKTINFO) && defined(HAVE_STRUCT_IN6_PKTINFO)
4978                 struct sockaddr_in6 *sin6;
4979                 struct in6_pktinfo pkt6;
4980
4981                 if (si->bindname.sa_socklen == sizeof(struct sockaddr_in6)) {
4982                         sin6 = &si->bindname.sa.in6;
4983                 } else {
4984                         if (si->myname.sa_socklen != sizeof(struct sockaddr_in6)) {
4985                                 return 0;
4986                         }
4987                         sin6 = &si->myname.sa.in6;
4988                 }
4989
4990                 ZERO_STRUCT(pkt6);
4991
4992                 pkt6.ipi6_ifindex = socket_wrapper_default_iface();
4993                 pkt6.ipi6_addr = sin6->sin6_addr;
4994
4995                 swrap_msghdr_add_cmsghdr(msg, IPPROTO_IPV6, IPV6_PKTINFO,
4996                                         &pkt6, sizeof(pkt6));
4997 #endif /* HAVE_STRUCT_IN6_PKTINFO */
4998
4999                 break;
5000         }
5001 #endif /* IPV6_PKTINFO */
5002         default:
5003                 return -1;
5004         }
5005
5006         return 0;
5007 }
5008
5009 static int swrap_msghdr_add_socket_info(struct socket_info *si,
5010                                         struct msghdr *omsg)
5011 {
5012         int rc = 0;
5013
5014         if (si->pktinfo > 0) {
5015                 rc = swrap_msghdr_add_pktinfo(si, omsg);
5016         }
5017
5018         return rc;
5019 }
5020
5021 static int swrap_sendmsg_copy_cmsg(const struct cmsghdr *cmsg,
5022                                    uint8_t **cm_data,
5023                                    size_t *cm_data_space);
5024 static int swrap_sendmsg_filter_cmsg_ipproto_ip(const struct cmsghdr *cmsg,
5025                                                 uint8_t **cm_data,
5026                                                 size_t *cm_data_space);
5027 static int swrap_sendmsg_filter_cmsg_sol_socket(const struct cmsghdr *cmsg,
5028                                                 uint8_t **cm_data,
5029                                                 size_t *cm_data_space);
5030
5031 static int swrap_sendmsg_filter_cmsghdr(const struct msghdr *_msg,
5032                                         uint8_t **cm_data,
5033                                         size_t *cm_data_space)
5034 {
5035         struct msghdr *msg = discard_const_p(struct msghdr, _msg);
5036         struct cmsghdr *cmsg;
5037         int rc = -1;
5038
5039         /* Nothing to do */
5040         if (msg->msg_controllen == 0 || msg->msg_control == NULL) {
5041                 return 0;
5042         }
5043
5044         for (cmsg = CMSG_FIRSTHDR(msg);
5045              cmsg != NULL;
5046              cmsg = CMSG_NXTHDR(msg, cmsg)) {
5047                 switch (cmsg->cmsg_level) {
5048                 case IPPROTO_IP:
5049                         rc = swrap_sendmsg_filter_cmsg_ipproto_ip(cmsg,
5050                                                                   cm_data,
5051                                                                   cm_data_space);
5052                         break;
5053                 case SOL_SOCKET:
5054                         rc = swrap_sendmsg_filter_cmsg_sol_socket(cmsg,
5055                                                                   cm_data,
5056                                                                   cm_data_space);
5057                         break;
5058                 default:
5059                         rc = swrap_sendmsg_copy_cmsg(cmsg,
5060                                                      cm_data,
5061                                                      cm_data_space);
5062                         break;
5063                 }
5064                 if (rc < 0) {
5065                         int saved_errno = errno;
5066                         SAFE_FREE(*cm_data);
5067                         *cm_data_space = 0;
5068                         errno = saved_errno;
5069                         return rc;
5070                 }
5071         }
5072
5073         return rc;
5074 }
5075
5076 static int swrap_sendmsg_copy_cmsg(const struct cmsghdr *cmsg,
5077                                    uint8_t **cm_data,
5078                                    size_t *cm_data_space)
5079 {
5080         size_t cmspace;
5081         uint8_t *p;
5082
5083         cmspace = *cm_data_space + CMSG_ALIGN(cmsg->cmsg_len);
5084
5085         p = realloc((*cm_data), cmspace);
5086         if (p == NULL) {
5087                 return -1;
5088         }
5089         (*cm_data) = p;
5090
5091         p = (*cm_data) + (*cm_data_space);
5092         *cm_data_space = cmspace;
5093
5094         memcpy(p, cmsg, cmsg->cmsg_len);
5095
5096         return 0;
5097 }
5098
5099 static int swrap_sendmsg_filter_cmsg_pktinfo(const struct cmsghdr *cmsg,
5100                                             uint8_t **cm_data,
5101                                             size_t *cm_data_space);
5102
5103
5104 static int swrap_sendmsg_filter_cmsg_ipproto_ip(const struct cmsghdr *cmsg,
5105                                                 uint8_t **cm_data,
5106                                                 size_t *cm_data_space)
5107 {
5108         int rc = -1;
5109
5110         switch(cmsg->cmsg_type) {
5111 #ifdef IP_PKTINFO
5112         case IP_PKTINFO:
5113                 rc = swrap_sendmsg_filter_cmsg_pktinfo(cmsg,
5114                                                        cm_data,
5115                                                        cm_data_space);
5116                 break;
5117 #endif
5118 #ifdef IPV6_PKTINFO
5119         case IPV6_PKTINFO:
5120                 rc = swrap_sendmsg_filter_cmsg_pktinfo(cmsg,
5121                                                        cm_data,
5122                                                        cm_data_space);
5123                 break;
5124 #endif
5125         default:
5126                 break;
5127         }
5128
5129         return rc;
5130 }
5131
5132 static int swrap_sendmsg_filter_cmsg_pktinfo(const struct cmsghdr *cmsg,
5133                                              uint8_t **cm_data,
5134                                              size_t *cm_data_space)
5135 {
5136         (void)cmsg; /* unused */
5137         (void)cm_data; /* unused */
5138         (void)cm_data_space; /* unused */
5139
5140         /*
5141          * Passing a IP pktinfo to a unix socket might be rejected by the
5142          * Kernel, at least on FreeBSD. So skip this cmsg.
5143          */
5144         return 0;
5145 }
5146
5147 static int swrap_sendmsg_filter_cmsg_sol_socket(const struct cmsghdr *cmsg,
5148                                                 uint8_t **cm_data,
5149                                                 size_t *cm_data_space)
5150 {
5151         int rc = -1;
5152
5153         switch (cmsg->cmsg_type) {
5154         case SCM_RIGHTS:
5155                 SWRAP_LOG(SWRAP_LOG_TRACE,
5156                           "Ignoring SCM_RIGHTS on inet socket!");
5157                 rc = 0;
5158                 break;
5159 #ifdef SCM_CREDENTIALS
5160         case SCM_CREDENTIALS:
5161                 SWRAP_LOG(SWRAP_LOG_TRACE,
5162                           "Ignoring SCM_CREDENTIALS on inet socket!");
5163                 rc = 0;
5164                 break;
5165 #endif /* SCM_CREDENTIALS */
5166         default:
5167                 rc = swrap_sendmsg_copy_cmsg(cmsg,
5168                                              cm_data,
5169                                              cm_data_space);
5170                 break;
5171         }
5172
5173         return rc;
5174 }
5175
5176 static const uint64_t swrap_unix_scm_right_magic = 0x8e0e13f27c42fc36;
5177
5178 /*
5179  * We only allow up to 6 fds at a time
5180  * as that's more than enough for Samba
5181  * and it means we can keep the logic simple
5182  * and work with fixed size arrays.
5183  *
5184  * We also keep sizeof(struct swrap_unix_scm_rights)
5185  * under PIPE_BUF (4096) in order to allow a non-blocking
5186  * write into the pipe.
5187  */
5188 #ifndef PIPE_BUF
5189 #define PIPE_BUF 4096
5190 #endif
5191 #define SWRAP_MAX_PASSED_FDS ((size_t)6)
5192 #define SWRAP_MAX_PASSED_SOCKET_INFO SWRAP_MAX_PASSED_FDS
5193 struct swrap_unix_scm_rights_payload {
5194         uint8_t num_idxs;
5195         int8_t idxs[SWRAP_MAX_PASSED_FDS];
5196         struct socket_info infos[SWRAP_MAX_PASSED_SOCKET_INFO];
5197 };
5198 struct swrap_unix_scm_rights {
5199         uint64_t magic;
5200         char package_name[sizeof(SOCKET_WRAPPER_PACKAGE)];
5201         char package_version[sizeof(SOCKET_WRAPPER_VERSION)];
5202         uint32_t full_size;
5203         uint32_t payload_size;
5204         struct swrap_unix_scm_rights_payload payload;
5205 };
5206
5207 static void swrap_dec_fd_passed_array(size_t num, struct socket_info **array)
5208 {
5209         int saved_errno = errno;
5210         size_t i;
5211
5212         for (i = 0; i < num; i++) {
5213                 struct socket_info *si = array[i];
5214                 if (si == NULL) {
5215                         continue;
5216                 }
5217
5218                 SWRAP_LOCK_SI(si);
5219                 swrap_dec_refcount(si);
5220                 if (si->fd_passed > 0) {
5221                         si->fd_passed -= 1;
5222                 }
5223                 SWRAP_UNLOCK_SI(si);
5224                 array[i] = NULL;
5225         }
5226
5227         errno = saved_errno;
5228 }
5229
5230 static void swrap_undo_si_idx_array(size_t num, int *array)
5231 {
5232         int saved_errno = errno;
5233         size_t i;
5234
5235         swrap_mutex_lock(&first_free_mutex);
5236
5237         for (i = 0; i < num; i++) {
5238                 struct socket_info *si = NULL;
5239
5240                 if (array[i] == -1) {
5241                         continue;
5242                 }
5243
5244                 si = swrap_get_socket_info(array[i]);
5245                 if (si == NULL) {
5246                         continue;
5247                 }
5248
5249                 SWRAP_LOCK_SI(si);
5250                 swrap_dec_refcount(si);
5251                 SWRAP_UNLOCK_SI(si);
5252
5253                 swrap_set_next_free(si, first_free);
5254                 first_free = array[i];
5255                 array[i] = -1;
5256         }
5257
5258         swrap_mutex_unlock(&first_free_mutex);
5259         errno = saved_errno;
5260 }
5261
5262 static void swrap_close_fd_array(size_t num, const int *array)
5263 {
5264         int saved_errno = errno;
5265         size_t i;
5266
5267         for (i = 0; i < num; i++) {
5268                 if (array[i] == -1) {
5269                         continue;
5270                 }
5271                 libc_close(array[i]);
5272         }
5273
5274         errno = saved_errno;
5275 }
5276
5277 union __swrap_fds {
5278         const uint8_t *p;
5279         int *fds;
5280 };
5281
5282 union __swrap_cmsghdr {
5283         const uint8_t *p;
5284         struct cmsghdr *cmsg;
5285 };
5286
5287 static int swrap_sendmsg_unix_scm_rights(const struct cmsghdr *cmsg,
5288                                          uint8_t **cm_data,
5289                                          size_t *cm_data_space,
5290                                          int *scm_rights_pipe_fd)
5291 {
5292         struct swrap_unix_scm_rights info;
5293         struct swrap_unix_scm_rights_payload *payload = NULL;
5294         int si_idx_array[SWRAP_MAX_PASSED_FDS];
5295         struct socket_info *si_array[SWRAP_MAX_PASSED_FDS] = { NULL, };
5296         size_t info_idx = 0;
5297         size_t size_fds_in;
5298         size_t num_fds_in;
5299         union __swrap_fds __fds_in = { .p = NULL, };
5300         const int *fds_in = NULL;
5301         size_t num_fds_out;
5302         size_t size_fds_out;
5303         union __swrap_fds __fds_out = { .p = NULL, };
5304         int *fds_out = NULL;
5305         size_t cmsg_len;
5306         size_t cmsg_space;
5307         size_t new_cm_data_space;
5308         union __swrap_cmsghdr __new_cmsg = { .p = NULL, };
5309         struct cmsghdr *new_cmsg = NULL;
5310         uint8_t *p = NULL;
5311         size_t i;
5312         int pipefd[2] = { -1, -1 };
5313         int rc;
5314         ssize_t sret;
5315
5316         /*
5317          * We pass this a buffer to the kernel make sure any padding
5318          * is also cleared.
5319          */
5320         ZERO_STRUCT(info);
5321         info.magic = swrap_unix_scm_right_magic;
5322         memcpy(info.package_name,
5323                SOCKET_WRAPPER_PACKAGE,
5324                sizeof(info.package_name));
5325         memcpy(info.package_version,
5326                SOCKET_WRAPPER_VERSION,
5327                sizeof(info.package_version));
5328         info.full_size = sizeof(info);
5329         info.payload_size = sizeof(info.payload);
5330         payload = &info.payload;
5331
5332         if (*scm_rights_pipe_fd != -1) {
5333                 SWRAP_LOG(SWRAP_LOG_ERROR,
5334                           "Two SCM_RIGHTS headers are not supported by socket_wrapper");
5335                 errno = EINVAL;
5336                 return -1;
5337         }
5338
5339         if (cmsg->cmsg_len < CMSG_LEN(0)) {
5340                 SWRAP_LOG(SWRAP_LOG_ERROR,
5341                           "cmsg->cmsg_len=%zu < CMSG_LEN(0)=%zu",
5342                           (size_t)cmsg->cmsg_len,
5343                           CMSG_LEN(0));
5344                 errno = EINVAL;
5345                 return -1;
5346         }
5347         size_fds_in = cmsg->cmsg_len - CMSG_LEN(0);
5348         if ((size_fds_in % sizeof(int)) != 0) {
5349                 SWRAP_LOG(SWRAP_LOG_ERROR,
5350                           "cmsg->cmsg_len=%zu => (size_fds_in=%zu %% sizeof(int)=%zu) != 0",
5351                           (size_t)cmsg->cmsg_len,
5352                           size_fds_in,
5353                           sizeof(int));
5354                 errno = EINVAL;
5355                 return -1;
5356         }
5357         num_fds_in = size_fds_in / sizeof(int);
5358         if (num_fds_in > SWRAP_MAX_PASSED_FDS) {
5359                 SWRAP_LOG(SWRAP_LOG_ERROR,
5360                           "cmsg->cmsg_len=%zu,size_fds_in=%zu => "
5361                           "num_fds_in=%zu > "
5362                           "SWRAP_MAX_PASSED_FDS(%zu)",
5363                           (size_t)cmsg->cmsg_len,
5364                           size_fds_in,
5365                           num_fds_in,
5366                           SWRAP_MAX_PASSED_FDS);
5367                 errno = EINVAL;
5368                 return -1;
5369         }
5370         if (num_fds_in == 0) {
5371                 SWRAP_LOG(SWRAP_LOG_ERROR,
5372                           "cmsg->cmsg_len=%zu,size_fds_in=%zu => "
5373                           "num_fds_in=%zu",
5374                           (size_t)cmsg->cmsg_len,
5375                           size_fds_in,
5376                           num_fds_in);
5377                 errno = EINVAL;
5378                 return -1;
5379         }
5380         __fds_in.p = CMSG_DATA(cmsg);
5381         fds_in = __fds_in.fds;
5382         num_fds_out = num_fds_in + 1;
5383
5384         SWRAP_LOG(SWRAP_LOG_TRACE,
5385                   "num_fds_in=%zu num_fds_out=%zu",
5386                   num_fds_in, num_fds_out);
5387
5388         size_fds_out = sizeof(int) * num_fds_out;
5389         cmsg_len = CMSG_LEN(size_fds_out);
5390         cmsg_space = CMSG_SPACE(size_fds_out);
5391
5392         new_cm_data_space = *cm_data_space + cmsg_space;
5393
5394         p = realloc((*cm_data), new_cm_data_space);
5395         if (p == NULL) {
5396                 return -1;
5397         }
5398         (*cm_data) = p;
5399         p = (*cm_data) + (*cm_data_space);
5400         memset(p, 0, cmsg_space);
5401         __new_cmsg.p = p;
5402         new_cmsg = __new_cmsg.cmsg;
5403         *new_cmsg = *cmsg;
5404         __fds_out.p = CMSG_DATA(new_cmsg);
5405         fds_out = __fds_out.fds;
5406         memcpy(fds_out, fds_in, size_fds_out);
5407         new_cmsg->cmsg_len = cmsg->cmsg_len;
5408
5409         for (i = 0; i < num_fds_in; i++) {
5410                 size_t j;
5411
5412                 payload->idxs[i] = -1;
5413                 payload->num_idxs++;
5414
5415                 si_idx_array[i] = find_socket_info_index(fds_in[i]);
5416                 if (si_idx_array[i] == -1) {
5417                         continue;
5418                 }
5419
5420                 si_array[i] = swrap_get_socket_info(si_idx_array[i]);
5421                 if (si_array[i] == NULL) {
5422                         SWRAP_LOG(SWRAP_LOG_ERROR,
5423                                   "fds_in[%zu]=%d si_idx_array[%zu]=%d missing!",
5424                                   i, fds_in[i], i, si_idx_array[i]);
5425                         errno = EINVAL;
5426                         return -1;
5427                 }
5428
5429                 for (j = 0; j < i; j++) {
5430                         if (si_array[j] == si_array[i]) {
5431                                 payload->idxs[i] = payload->idxs[j];
5432                                 break;
5433                         }
5434                 }
5435                 if (payload->idxs[i] == -1) {
5436                         if (info_idx >= SWRAP_MAX_PASSED_SOCKET_INFO) {
5437                                 SWRAP_LOG(SWRAP_LOG_ERROR,
5438                                           "fds_in[%zu]=%d,si_idx_array[%zu]=%d: "
5439                                           "info_idx=%zu >= SWRAP_MAX_PASSED_FDS(%zu)!",
5440                                           i, fds_in[i], i, si_idx_array[i],
5441                                           info_idx,
5442                                           SWRAP_MAX_PASSED_SOCKET_INFO);
5443                                 errno = EINVAL;
5444                                 return -1;
5445                         }
5446                         payload->idxs[i] = info_idx;
5447                         info_idx += 1;
5448                         continue;
5449                 }
5450         }
5451
5452         for (i = 0; i < num_fds_in; i++) {
5453                 struct socket_info *si = si_array[i];
5454
5455                 if (si == NULL) {
5456                         SWRAP_LOG(SWRAP_LOG_TRACE,
5457                                   "fds_in[%zu]=%d not an inet socket",
5458                                   i, fds_in[i]);
5459                         continue;
5460                 }
5461
5462                 SWRAP_LOG(SWRAP_LOG_TRACE,
5463                           "fds_in[%zu]=%d si_idx_array[%zu]=%d "
5464                           "passing as info.idxs[%zu]=%d!",
5465                           i, fds_in[i],
5466                           i, si_idx_array[i],
5467                           i, payload->idxs[i]);
5468
5469                 SWRAP_LOCK_SI(si);
5470                 si->fd_passed += 1;
5471                 payload->infos[payload->idxs[i]] = *si;
5472                 payload->infos[payload->idxs[i]].fd_passed = 0;
5473                 SWRAP_UNLOCK_SI(si);
5474         }
5475
5476         rc = pipe(pipefd);
5477         if (rc == -1) {
5478                 int saved_errno = errno;
5479                 SWRAP_LOG(SWRAP_LOG_ERROR,
5480                           "pipe() failed - %d %s",
5481                           saved_errno,
5482                           strerror(saved_errno));
5483                 swrap_dec_fd_passed_array(num_fds_in, si_array);
5484                 errno = saved_errno;
5485                 return -1;
5486         }
5487
5488         sret = write(pipefd[1], &info, sizeof(info));
5489         if (sret != sizeof(info)) {
5490                 int saved_errno = errno;
5491                 if (sret != -1) {
5492                         saved_errno = EINVAL;
5493                 }
5494                 SWRAP_LOG(SWRAP_LOG_ERROR,
5495                           "write() failed - sret=%zd - %d %s",
5496                           sret, saved_errno,
5497                           strerror(saved_errno));
5498                 swrap_dec_fd_passed_array(num_fds_in, si_array);
5499                 libc_close(pipefd[1]);
5500                 libc_close(pipefd[0]);
5501                 errno = saved_errno;
5502                 return -1;
5503         }
5504         libc_close(pipefd[1]);
5505
5506         /*
5507          * Add the pipe read end to the end of the passed fd array
5508          */
5509         fds_out[num_fds_in] = pipefd[0];
5510         new_cmsg->cmsg_len = cmsg_len;
5511
5512         /* we're done ... */
5513         *scm_rights_pipe_fd = pipefd[0];
5514         *cm_data_space = new_cm_data_space;
5515
5516         return 0;
5517 }
5518
5519 static int swrap_sendmsg_unix_sol_socket(const struct cmsghdr *cmsg,
5520                                          uint8_t **cm_data,
5521                                          size_t *cm_data_space,
5522                                          int *scm_rights_pipe_fd)
5523 {
5524         int rc = -1;
5525
5526         switch (cmsg->cmsg_type) {
5527         case SCM_RIGHTS:
5528                 rc = swrap_sendmsg_unix_scm_rights(cmsg,
5529                                                    cm_data,
5530                                                    cm_data_space,
5531                                                    scm_rights_pipe_fd);
5532                 break;
5533         default:
5534                 rc = swrap_sendmsg_copy_cmsg(cmsg,
5535                                              cm_data,
5536                                              cm_data_space);
5537                 break;
5538         }
5539
5540         return rc;
5541 }
5542
5543 static int swrap_recvmsg_unix_scm_rights(const struct cmsghdr *cmsg,
5544                                          uint8_t **cm_data,
5545                                          size_t *cm_data_space)
5546 {
5547         int scm_rights_pipe_fd = -1;
5548         struct swrap_unix_scm_rights info;
5549         struct swrap_unix_scm_rights_payload *payload = NULL;
5550         int si_idx_array[SWRAP_MAX_PASSED_FDS];
5551         size_t size_fds_in;
5552         size_t num_fds_in;
5553         union __swrap_fds __fds_in = { .p = NULL, };
5554         const int *fds_in = NULL;
5555         size_t num_fds_out;
5556         size_t size_fds_out;
5557         union __swrap_fds __fds_out = { .p = NULL, };
5558         int *fds_out = NULL;
5559         size_t cmsg_len;
5560         size_t cmsg_space;
5561         size_t new_cm_data_space;
5562         union __swrap_cmsghdr __new_cmsg = { .p = NULL, };
5563         struct cmsghdr *new_cmsg = NULL;
5564         uint8_t *p = NULL;
5565         ssize_t sret;
5566         size_t i;
5567         int cmp;
5568
5569         if (cmsg->cmsg_len < CMSG_LEN(0)) {
5570                 SWRAP_LOG(SWRAP_LOG_ERROR,
5571                           "cmsg->cmsg_len=%zu < CMSG_LEN(0)=%zu",
5572                           (size_t)cmsg->cmsg_len,
5573                           CMSG_LEN(0));
5574                 errno = EINVAL;
5575                 return -1;
5576         }
5577         size_fds_in = cmsg->cmsg_len - CMSG_LEN(0);
5578         if ((size_fds_in % sizeof(int)) != 0) {
5579                 SWRAP_LOG(SWRAP_LOG_ERROR,
5580                           "cmsg->cmsg_len=%zu => (size_fds_in=%zu %% sizeof(int)=%zu) != 0",
5581                           (size_t)cmsg->cmsg_len,
5582                           size_fds_in,
5583                           sizeof(int));
5584                 errno = EINVAL;
5585                 return -1;
5586         }
5587         num_fds_in = size_fds_in / sizeof(int);
5588         if (num_fds_in > (SWRAP_MAX_PASSED_FDS + 1)) {
5589                 SWRAP_LOG(SWRAP_LOG_ERROR,
5590                           "cmsg->cmsg_len=%zu,size_fds_in=%zu => "
5591                           "num_fds_in=%zu > SWRAP_MAX_PASSED_FDS+1(%zu)",
5592                           (size_t)cmsg->cmsg_len,
5593                           size_fds_in,
5594                           num_fds_in,
5595                           SWRAP_MAX_PASSED_FDS+1);
5596                 errno = EINVAL;
5597                 return -1;
5598         }
5599         if (num_fds_in <= 1) {
5600                 SWRAP_LOG(SWRAP_LOG_ERROR,
5601                           "cmsg->cmsg_len=%zu,size_fds_in=%zu => "
5602                           "num_fds_in=%zu",
5603                           (size_t)cmsg->cmsg_len,
5604                           size_fds_in,
5605                           num_fds_in);
5606                 errno = EINVAL;
5607                 return -1;
5608         }
5609         __fds_in.p = CMSG_DATA(cmsg);
5610         fds_in = __fds_in.fds;
5611         num_fds_out = num_fds_in - 1;
5612
5613         SWRAP_LOG(SWRAP_LOG_TRACE,
5614                   "num_fds_in=%zu num_fds_out=%zu",
5615                   num_fds_in, num_fds_out);
5616
5617         for (i = 0; i < num_fds_in; i++) {
5618                 /* Check if we have a stale fd and remove it */
5619                 swrap_remove_stale(fds_in[i]);
5620         }
5621
5622         scm_rights_pipe_fd = fds_in[num_fds_out];
5623         size_fds_out = sizeof(int) * num_fds_out;
5624         cmsg_len = CMSG_LEN(size_fds_out);
5625         cmsg_space = CMSG_SPACE(size_fds_out);
5626
5627         new_cm_data_space = *cm_data_space + cmsg_space;
5628
5629         p = realloc((*cm_data), new_cm_data_space);
5630         if (p == NULL) {
5631                 swrap_close_fd_array(num_fds_in, fds_in);
5632                 return -1;
5633         }
5634         (*cm_data) = p;
5635         p = (*cm_data) + (*cm_data_space);
5636         memset(p, 0, cmsg_space);
5637         __new_cmsg.p = p;
5638         new_cmsg = __new_cmsg.cmsg;
5639         *new_cmsg = *cmsg;
5640         __fds_out.p = CMSG_DATA(new_cmsg);
5641         fds_out = __fds_out.fds;
5642         memcpy(fds_out, fds_in, size_fds_out);
5643         new_cmsg->cmsg_len = cmsg_len;
5644
5645         sret = read(scm_rights_pipe_fd, &info, sizeof(info));
5646         if (sret != sizeof(info)) {
5647                 int saved_errno = errno;
5648                 if (sret != -1) {
5649                         saved_errno = EINVAL;
5650                 }
5651                 SWRAP_LOG(SWRAP_LOG_ERROR,
5652                           "read() failed - sret=%zd - %d %s",
5653                           sret, saved_errno,
5654                           strerror(saved_errno));
5655                 swrap_close_fd_array(num_fds_in, fds_in);
5656                 errno = saved_errno;
5657                 return -1;
5658         }
5659         libc_close(scm_rights_pipe_fd);
5660         payload = &info.payload;
5661
5662         if (info.magic != swrap_unix_scm_right_magic) {
5663                 SWRAP_LOG(SWRAP_LOG_ERROR,
5664                           "info.magic=0x%llx != swrap_unix_scm_right_magic=0x%llx",
5665                           (unsigned long long)info.magic,
5666                           (unsigned long long)swrap_unix_scm_right_magic);
5667                 swrap_close_fd_array(num_fds_out, fds_out);
5668                 errno = EINVAL;
5669                 return -1;
5670         }
5671
5672         cmp = memcmp(info.package_name,
5673                      SOCKET_WRAPPER_PACKAGE,
5674                      sizeof(info.package_name));
5675         if (cmp != 0) {
5676                 SWRAP_LOG(SWRAP_LOG_ERROR,
5677                           "info.package_name='%.*s' != '%s'",
5678                           (int)sizeof(info.package_name),
5679                           info.package_name,
5680                           SOCKET_WRAPPER_PACKAGE);
5681                 swrap_close_fd_array(num_fds_out, fds_out);
5682                 errno = EINVAL;
5683                 return -1;
5684         }
5685
5686         cmp = memcmp(info.package_version,
5687                      SOCKET_WRAPPER_VERSION,
5688                      sizeof(info.package_version));
5689         if (cmp != 0) {
5690                 SWRAP_LOG(SWRAP_LOG_ERROR,
5691                           "info.package_version='%.*s' != '%s'",
5692                           (int)sizeof(info.package_version),
5693                           info.package_version,
5694                           SOCKET_WRAPPER_VERSION);
5695                 swrap_close_fd_array(num_fds_out, fds_out);
5696                 errno = EINVAL;
5697                 return -1;
5698         }
5699
5700         if (info.full_size != sizeof(info)) {
5701                 SWRAP_LOG(SWRAP_LOG_ERROR,
5702                           "info.full_size=%zu != sizeof(info)=%zu",
5703                           (size_t)info.full_size,
5704                           sizeof(info));
5705                 swrap_close_fd_array(num_fds_out, fds_out);
5706                 errno = EINVAL;
5707                 return -1;
5708         }
5709
5710         if (info.payload_size != sizeof(info.payload)) {
5711                 SWRAP_LOG(SWRAP_LOG_ERROR,
5712                           "info.payload_size=%zu != sizeof(info.payload)=%zu",
5713                           (size_t)info.payload_size,
5714                           sizeof(info.payload));
5715                 swrap_close_fd_array(num_fds_out, fds_out);
5716                 errno = EINVAL;
5717                 return -1;
5718         }
5719
5720         if (payload->num_idxs != num_fds_out) {
5721                 SWRAP_LOG(SWRAP_LOG_ERROR,
5722                           "info.num_idxs=%u != num_fds_out=%zu",
5723                           payload->num_idxs, num_fds_out);
5724                 swrap_close_fd_array(num_fds_out, fds_out);
5725                 errno = EINVAL;
5726                 return -1;
5727         }
5728
5729         for (i = 0; i < num_fds_out; i++) {
5730                 size_t j;
5731
5732                 si_idx_array[i] = -1;
5733
5734                 if (payload->idxs[i] == -1) {
5735                         SWRAP_LOG(SWRAP_LOG_TRACE,
5736                                   "fds_out[%zu]=%d not an inet socket",
5737                                   i, fds_out[i]);
5738                         continue;
5739                 }
5740
5741                 if (payload->idxs[i] < 0) {
5742                         SWRAP_LOG(SWRAP_LOG_ERROR,
5743                                   "fds_out[%zu]=%d info.idxs[%zu]=%d < 0!",
5744                                   i, fds_out[i], i, payload->idxs[i]);
5745                         swrap_close_fd_array(num_fds_out, fds_out);
5746                         errno = EINVAL;
5747                         return -1;
5748                 }
5749
5750                 if (payload->idxs[i] >= payload->num_idxs) {
5751                         SWRAP_LOG(SWRAP_LOG_ERROR,
5752                                   "fds_out[%zu]=%d info.idxs[%zu]=%d >= %u!",
5753                                   i, fds_out[i], i, payload->idxs[i],
5754                                   payload->num_idxs);
5755                         swrap_close_fd_array(num_fds_out, fds_out);
5756                         errno = EINVAL;
5757                         return -1;
5758                 }
5759
5760                 if ((size_t)fds_out[i] >= socket_fds_max) {
5761                         SWRAP_LOG(SWRAP_LOG_ERROR,
5762                                   "The max socket index limit of %zu has been reached, "
5763                                   "trying to add %d",
5764                                   socket_fds_max,
5765                                   fds_out[i]);
5766                         swrap_close_fd_array(num_fds_out, fds_out);
5767                         errno = EMFILE;
5768                         return -1;
5769                 }
5770
5771                 SWRAP_LOG(SWRAP_LOG_TRACE,
5772                           "fds_in[%zu]=%d "
5773                           "received as info.idxs[%zu]=%d!",
5774                           i, fds_out[i],
5775                           i, payload->idxs[i]);
5776
5777                 for (j = 0; j < i; j++) {
5778                         if (payload->idxs[j] == -1) {
5779                                 continue;
5780                         }
5781                         if (payload->idxs[j] == payload->idxs[i]) {
5782                                 si_idx_array[i] = si_idx_array[j];
5783                         }
5784                 }
5785                 if (si_idx_array[i] == -1) {
5786                         const struct socket_info *si = &payload->infos[payload->idxs[i]];
5787
5788                         si_idx_array[i] = swrap_add_socket_info(si);
5789                         if (si_idx_array[i] == -1) {
5790                                 int saved_errno = errno;
5791                                 SWRAP_LOG(SWRAP_LOG_ERROR,
5792                                           "The max socket index limit of %zu has been reached, "
5793                                           "trying to add %d",
5794                                           socket_fds_max,
5795                                           fds_out[i]);
5796                                 swrap_undo_si_idx_array(i, si_idx_array);
5797                                 swrap_close_fd_array(num_fds_out, fds_out);
5798                                 errno = saved_errno;
5799                                 return -1;
5800                         }
5801                         SWRAP_LOG(SWRAP_LOG_TRACE,
5802                                   "Imported %s socket for protocol %s, fd=%d",
5803                                   si->family == AF_INET ? "IPv4" : "IPv6",
5804                                   si->type == SOCK_DGRAM ? "UDP" : "TCP",
5805                                   fds_out[i]);
5806                 }
5807         }
5808
5809         for (i = 0; i < num_fds_out; i++) {
5810                 if (si_idx_array[i] == -1) {
5811                         continue;
5812                 }
5813                 set_socket_info_index(fds_out[i], si_idx_array[i]);
5814         }
5815
5816         /* we're done ... */
5817         *cm_data_space = new_cm_data_space;
5818
5819         return 0;
5820 }
5821
5822 static int swrap_recvmsg_unix_sol_socket(const struct cmsghdr *cmsg,
5823                                          uint8_t **cm_data,
5824                                          size_t *cm_data_space)
5825 {
5826         int rc = -1;
5827
5828         switch (cmsg->cmsg_type) {
5829         case SCM_RIGHTS:
5830                 rc = swrap_recvmsg_unix_scm_rights(cmsg,
5831                                                    cm_data,
5832                                                    cm_data_space);
5833                 break;
5834         default:
5835                 rc = swrap_sendmsg_copy_cmsg(cmsg,
5836                                              cm_data,
5837                                              cm_data_space);
5838                 break;
5839         }
5840
5841         return rc;
5842 }
5843
5844 #endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL */
5845
5846 static int swrap_sendmsg_before_unix(const struct msghdr *_msg_in,
5847                                      struct msghdr *msg_tmp,
5848                                      int *scm_rights_pipe_fd)
5849 {
5850 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
5851         struct msghdr *msg_in = discard_const_p(struct msghdr, _msg_in);
5852         struct cmsghdr *cmsg = NULL;
5853         uint8_t *cm_data = NULL;
5854         size_t cm_data_space = 0;
5855         int rc = -1;
5856
5857         *msg_tmp = *msg_in;
5858         *scm_rights_pipe_fd = -1;
5859
5860         /* Nothing to do */
5861         if (msg_in->msg_controllen == 0 || msg_in->msg_control == NULL) {
5862                 return 0;
5863         }
5864
5865         for (cmsg = CMSG_FIRSTHDR(msg_in);
5866              cmsg != NULL;
5867              cmsg = CMSG_NXTHDR(msg_in, cmsg)) {
5868                 switch (cmsg->cmsg_level) {
5869                 case SOL_SOCKET:
5870                         rc = swrap_sendmsg_unix_sol_socket(cmsg,
5871                                                            &cm_data,
5872                                                            &cm_data_space,
5873                                                            scm_rights_pipe_fd);
5874                         break;
5875
5876                 default:
5877                         rc = swrap_sendmsg_copy_cmsg(cmsg,
5878                                                      &cm_data,
5879                                                      &cm_data_space);
5880                         break;
5881                 }
5882                 if (rc < 0) {
5883                         int saved_errno = errno;
5884                         SAFE_FREE(cm_data);
5885                         errno = saved_errno;
5886                         return rc;
5887                 }
5888         }
5889
5890         msg_tmp->msg_controllen = cm_data_space;
5891         msg_tmp->msg_control = cm_data;
5892
5893         return 0;
5894 #else /* HAVE_STRUCT_MSGHDR_MSG_CONTROL */
5895         *msg_tmp = *_msg_in;
5896         return 0;
5897 #endif /* ! HAVE_STRUCT_MSGHDR_MSG_CONTROL */
5898 }
5899
5900 static ssize_t swrap_sendmsg_after_unix(struct msghdr *msg_tmp,
5901                                         ssize_t ret,
5902                                         int scm_rights_pipe_fd)
5903 {
5904 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
5905         int saved_errno = errno;
5906         SAFE_FREE(msg_tmp->msg_control);
5907         if (scm_rights_pipe_fd != -1) {
5908                 libc_close(scm_rights_pipe_fd);
5909         }
5910         errno = saved_errno;
5911 #endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL */
5912         return ret;
5913 }
5914
5915 static int swrap_recvmsg_before_unix(struct msghdr *msg_in,
5916                                      struct msghdr *msg_tmp)
5917 {
5918         *msg_tmp = *msg_in;
5919         return 0;
5920 }
5921
5922 static ssize_t swrap_recvmsg_after_unix(struct msghdr *msg_tmp,
5923                                         struct msghdr *msg_out,
5924                                         ssize_t ret)
5925 {
5926 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
5927         struct cmsghdr *cmsg = NULL;
5928         uint8_t *cm_data = NULL;
5929         size_t cm_data_space = 0;
5930         int rc = -1;
5931
5932         /* Nothing to do */
5933         if (msg_tmp->msg_controllen == 0 || msg_tmp->msg_control == NULL) {
5934                 goto done;
5935         }
5936
5937         for (cmsg = CMSG_FIRSTHDR(msg_tmp);
5938              cmsg != NULL;
5939              cmsg = CMSG_NXTHDR(msg_tmp, cmsg)) {
5940                 switch (cmsg->cmsg_level) {
5941                 case SOL_SOCKET:
5942                         rc = swrap_recvmsg_unix_sol_socket(cmsg,
5943                                                            &cm_data,
5944                                                            &cm_data_space);
5945                         break;
5946
5947                 default:
5948                         rc = swrap_sendmsg_copy_cmsg(cmsg,
5949                                                      &cm_data,
5950                                                      &cm_data_space);
5951                         break;
5952                 }
5953                 if (rc < 0) {
5954                         int saved_errno = errno;
5955                         SAFE_FREE(cm_data);
5956                         errno = saved_errno;
5957                         return rc;
5958                 }
5959         }
5960
5961         /*
5962          * msg_tmp->msg_control is still the buffer of the caller.
5963          */
5964         memcpy(msg_tmp->msg_control, cm_data, cm_data_space);
5965         msg_tmp->msg_controllen = cm_data_space;
5966         SAFE_FREE(cm_data);
5967 done:
5968 #endif /* ! HAVE_STRUCT_MSGHDR_MSG_CONTROL */
5969         *msg_out = *msg_tmp;
5970         return ret;
5971 }
5972
5973 static ssize_t swrap_sendmsg_before(int fd,
5974                                     struct socket_info *si,
5975                                     struct msghdr *msg,
5976                                     struct iovec *tmp_iov,
5977                                     struct sockaddr_un *tmp_un,
5978                                     const struct sockaddr_un **to_un,
5979                                     const struct sockaddr **to,
5980                                     int *bcast)
5981 {
5982         size_t i, len = 0;
5983         ssize_t ret = -1;
5984
5985         if (to_un) {
5986                 *to_un = NULL;
5987         }
5988         if (to) {
5989                 *to = NULL;
5990         }
5991         if (bcast) {
5992                 *bcast = 0;
5993         }
5994
5995         SWRAP_LOCK_SI(si);
5996
5997         switch (si->type) {
5998         case SOCK_STREAM: {
5999                 unsigned long mtu;
6000
6001                 if (!si->connected) {
6002                         errno = ENOTCONN;
6003                         goto out;
6004                 }
6005
6006                 if (msg->msg_iovlen == 0) {
6007                         break;
6008                 }
6009
6010                 mtu = socket_wrapper_mtu();
6011                 for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6012                         size_t nlen;
6013                         nlen = len + msg->msg_iov[i].iov_len;
6014                         if (nlen < len) {
6015                                 /* overflow */
6016                                 errno = EMSGSIZE;
6017                                 goto out;
6018                         }
6019                         if (nlen > mtu) {
6020                                 break;
6021                         }
6022                 }
6023                 msg->msg_iovlen = i;
6024                 if (msg->msg_iovlen == 0) {
6025                         *tmp_iov = msg->msg_iov[0];
6026                         tmp_iov->iov_len = MIN((size_t)tmp_iov->iov_len,
6027                                                (size_t)mtu);
6028                         msg->msg_iov = tmp_iov;
6029                         msg->msg_iovlen = 1;
6030                 }
6031                 break;
6032         }
6033         case SOCK_DGRAM:
6034                 if (si->connected) {
6035                         if (msg->msg_name != NULL) {
6036                                 /*
6037                                  * We are dealing with unix sockets and if we
6038                                  * are connected, we should only talk to the
6039                                  * connected unix path. Using the fd to send
6040                                  * to another server would be hard to achieve.
6041                                  */
6042                                 msg->msg_name = NULL;
6043                                 msg->msg_namelen = 0;
6044                         }
6045                 } else {
6046                         const struct sockaddr *msg_name;
6047                         msg_name = (const struct sockaddr *)msg->msg_name;
6048
6049                         if (msg_name == NULL) {
6050                                 errno = ENOTCONN;
6051                                 goto out;
6052                         }
6053
6054
6055                         ret = sockaddr_convert_to_un(si, msg_name, msg->msg_namelen,
6056                                                      tmp_un, 0, bcast);
6057                         if (ret == -1) {
6058                                 goto out;
6059                         }
6060
6061                         if (to_un) {
6062                                 *to_un = tmp_un;
6063                         }
6064                         if (to) {
6065                                 *to = msg_name;
6066                         }
6067                         msg->msg_name = tmp_un;
6068                         msg->msg_namelen = sizeof(*tmp_un);
6069                 }
6070
6071                 if (si->bound == 0) {
6072                         ret = swrap_auto_bind(fd, si, si->family);
6073                         if (ret == -1) {
6074                                 SWRAP_UNLOCK_SI(si);
6075                                 if (errno == ENOTSOCK) {
6076                                         swrap_remove_stale(fd);
6077                                         ret = -ENOTSOCK;
6078                                 } else {
6079                                         SWRAP_LOG(SWRAP_LOG_ERROR, "swrap_sendmsg_before failed");
6080                                 }
6081                                 return ret;
6082                         }
6083                 }
6084
6085                 if (!si->defer_connect) {
6086                         break;
6087                 }
6088
6089                 ret = sockaddr_convert_to_un(si,
6090                                              &si->peername.sa.s,
6091                                              si->peername.sa_socklen,
6092                                              tmp_un,
6093                                              0,
6094                                              NULL);
6095                 if (ret == -1) {
6096                         goto out;
6097                 }
6098
6099                 ret = libc_connect(fd,
6100                                    (struct sockaddr *)(void *)tmp_un,
6101                                    sizeof(*tmp_un));
6102
6103                 /* to give better errors */
6104                 if (ret == -1 && errno == ENOENT) {
6105                         errno = EHOSTUNREACH;
6106                 }
6107
6108                 if (ret == -1) {
6109                         goto out;
6110                 }
6111
6112                 si->defer_connect = 0;
6113                 break;
6114         default:
6115                 errno = EHOSTUNREACH;
6116                 goto out;
6117         }
6118
6119         ret = 0;
6120 out:
6121         SWRAP_UNLOCK_SI(si);
6122
6123         return ret;
6124 }
6125
6126 static void swrap_sendmsg_after(int fd,
6127                                 struct socket_info *si,
6128                                 struct msghdr *msg,
6129                                 const struct sockaddr *to,
6130                                 ssize_t ret)
6131 {
6132         int saved_errno = errno;
6133         size_t i, len = 0;
6134         uint8_t *buf;
6135         off_t ofs = 0;
6136         size_t avail = 0;
6137         size_t remain;
6138
6139         /* to give better errors */
6140         if (ret == -1) {
6141                 if (saved_errno == ENOENT) {
6142                         saved_errno = EHOSTUNREACH;
6143                 } else if (saved_errno == ENOTSOCK) {
6144                         /* If the fd is not a socket, remove it */
6145                         swrap_remove_stale(fd);
6146                 }
6147         }
6148
6149         for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6150                 avail += msg->msg_iov[i].iov_len;
6151         }
6152
6153         if (ret == -1) {
6154                 remain = MIN(80, avail);
6155         } else {
6156                 remain = ret;
6157         }
6158
6159         /* we capture it as one single packet */
6160         buf = (uint8_t *)malloc(remain);
6161         if (!buf) {
6162                 /* we just not capture the packet */
6163                 errno = saved_errno;
6164                 return;
6165         }
6166
6167         for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6168                 size_t this_time = MIN(remain, (size_t)msg->msg_iov[i].iov_len);
6169                 memcpy(buf + ofs,
6170                        msg->msg_iov[i].iov_base,
6171                        this_time);
6172                 ofs += this_time;
6173                 remain -= this_time;
6174         }
6175         len = ofs;
6176
6177         SWRAP_LOCK_SI(si);
6178
6179         switch (si->type) {
6180         case SOCK_STREAM:
6181                 if (ret == -1) {
6182                         swrap_pcap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
6183                         swrap_pcap_dump_packet(si, NULL, SWRAP_SEND_RST, NULL, 0);
6184                 } else {
6185                         swrap_pcap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
6186                 }
6187                 break;
6188
6189         case SOCK_DGRAM:
6190                 if (si->connected) {
6191                         to = &si->peername.sa.s;
6192                 }
6193                 if (ret == -1) {
6194                         swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
6195                         swrap_pcap_dump_packet(si, to, SWRAP_SENDTO_UNREACH, buf, len);
6196                 } else {
6197                         swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
6198                 }
6199                 break;
6200         }
6201
6202         SWRAP_UNLOCK_SI(si);
6203
6204         free(buf);
6205         errno = saved_errno;
6206 }
6207
6208 static int swrap_recvmsg_before(int fd,
6209                                 struct socket_info *si,
6210                                 struct msghdr *msg,
6211                                 struct iovec *tmp_iov)
6212 {
6213         size_t i, len = 0;
6214         int ret = -1;
6215
6216         SWRAP_LOCK_SI(si);
6217
6218         (void)fd; /* unused */
6219
6220         switch (si->type) {
6221         case SOCK_STREAM: {
6222                 unsigned int mtu;
6223                 if (!si->connected) {
6224                         errno = ENOTCONN;
6225                         goto out;
6226                 }
6227
6228                 if (msg->msg_iovlen == 0) {
6229                         break;
6230                 }
6231
6232                 mtu = socket_wrapper_mtu();
6233                 for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6234                         size_t nlen;
6235                         nlen = len + msg->msg_iov[i].iov_len;
6236                         if (nlen > mtu) {
6237                                 break;
6238                         }
6239                 }
6240                 msg->msg_iovlen = i;
6241                 if (msg->msg_iovlen == 0) {
6242                         *tmp_iov = msg->msg_iov[0];
6243                         tmp_iov->iov_len = MIN((size_t)tmp_iov->iov_len,
6244                                                (size_t)mtu);
6245                         msg->msg_iov = tmp_iov;
6246                         msg->msg_iovlen = 1;
6247                 }
6248                 break;
6249         }
6250         case SOCK_DGRAM:
6251                 if (msg->msg_name == NULL) {
6252                         errno = EINVAL;
6253                         goto out;
6254                 }
6255
6256                 if (msg->msg_iovlen == 0) {
6257                         break;
6258                 }
6259
6260                 if (si->bound == 0) {
6261                         ret = swrap_auto_bind(fd, si, si->family);
6262                         if (ret == -1) {
6263                                 SWRAP_UNLOCK_SI(si);
6264                                 /*
6265                                  * When attempting to read or write to a
6266                                  * descriptor, if an underlying autobind fails
6267                                  * because it's not a socket, stop intercepting
6268                                  * uses of that descriptor.
6269                                  */
6270                                 if (errno == ENOTSOCK) {
6271                                         swrap_remove_stale(fd);
6272                                         ret = -ENOTSOCK;
6273                                 } else {
6274                                         SWRAP_LOG(SWRAP_LOG_ERROR,
6275                                                   "swrap_recvmsg_before failed");
6276                                 }
6277                                 return ret;
6278                         }
6279                 }
6280                 break;
6281         default:
6282                 errno = EHOSTUNREACH;
6283                 goto out;
6284         }
6285
6286         ret = 0;
6287 out:
6288         SWRAP_UNLOCK_SI(si);
6289
6290         return ret;
6291 }
6292
6293 static int swrap_recvmsg_after(int fd,
6294                                struct socket_info *si,
6295                                struct msghdr *msg,
6296                                const struct sockaddr_un *un_addr,
6297                                socklen_t un_addrlen,
6298                                ssize_t ret)
6299 {
6300         int saved_errno = errno;
6301         size_t i;
6302         uint8_t *buf = NULL;
6303         off_t ofs = 0;
6304         size_t avail = 0;
6305         size_t remain;
6306         int rc;
6307
6308         /* to give better errors */
6309         if (ret == -1) {
6310                 if (saved_errno == ENOENT) {
6311                         saved_errno = EHOSTUNREACH;
6312                 } else if (saved_errno == ENOTSOCK) {
6313                         /* If the fd is not a socket, remove it */
6314                         swrap_remove_stale(fd);
6315                 }
6316         }
6317
6318         for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6319                 avail += msg->msg_iov[i].iov_len;
6320         }
6321
6322         SWRAP_LOCK_SI(si);
6323
6324         /* Convert the socket address before we leave */
6325         if (si->type == SOCK_DGRAM && un_addr != NULL) {
6326                 rc = sockaddr_convert_from_un(si,
6327                                               un_addr,
6328                                               un_addrlen,
6329                                               si->family,
6330                                               msg->msg_name,
6331                                               &msg->msg_namelen);
6332                 if (rc == -1) {
6333                         goto done;
6334                 }
6335         }
6336
6337         if (avail == 0) {
6338                 rc = 0;
6339                 goto done;
6340         }
6341
6342         if (ret == -1) {
6343                 remain = MIN(80, avail);
6344         } else {
6345                 remain = ret;
6346         }
6347
6348         /* we capture it as one single packet */
6349         buf = (uint8_t *)malloc(remain);
6350         if (buf == NULL) {
6351                 /* we just not capture the packet */
6352                 SWRAP_UNLOCK_SI(si);
6353                 errno = saved_errno;
6354                 return -1;
6355         }
6356
6357         for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6358                 size_t this_time = MIN(remain, (size_t)msg->msg_iov[i].iov_len);
6359                 memcpy(buf + ofs,
6360                        msg->msg_iov[i].iov_base,
6361                        this_time);
6362                 ofs += this_time;
6363                 remain -= this_time;
6364         }
6365
6366         switch (si->type) {
6367         case SOCK_STREAM:
6368                 if (ret == -1 && saved_errno != EAGAIN && saved_errno != ENOBUFS) {
6369                         swrap_pcap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
6370                 } else if (ret == 0) { /* END OF FILE */
6371                         swrap_pcap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
6372                 } else if (ret > 0) {
6373                         swrap_pcap_dump_packet(si, NULL, SWRAP_RECV, buf, ret);
6374                 }
6375                 break;
6376
6377         case SOCK_DGRAM:
6378                 if (ret == -1) {
6379                         break;
6380                 }
6381
6382                 if (un_addr != NULL) {
6383                         swrap_pcap_dump_packet(si,
6384                                           msg->msg_name,
6385                                           SWRAP_RECVFROM,
6386                                           buf,
6387                                           ret);
6388                 } else {
6389                         swrap_pcap_dump_packet(si,
6390                                           msg->msg_name,
6391                                           SWRAP_RECV,
6392                                           buf,
6393                                           ret);
6394                 }
6395
6396                 break;
6397         }
6398
6399         rc = 0;
6400 done:
6401         free(buf);
6402         errno = saved_errno;
6403
6404 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6405         if (rc == 0 &&
6406             msg->msg_controllen > 0 &&
6407             msg->msg_control != NULL) {
6408                 rc = swrap_msghdr_add_socket_info(si, msg);
6409                 if (rc < 0) {
6410                         SWRAP_UNLOCK_SI(si);
6411                         return -1;
6412                 }
6413         }
6414 #endif
6415
6416         SWRAP_UNLOCK_SI(si);
6417         return rc;
6418 }
6419
6420 /****************************************************************************
6421  *   RECVFROM
6422  ***************************************************************************/
6423
6424 static ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags,
6425                               struct sockaddr *from, socklen_t *fromlen)
6426 {
6427         struct swrap_address from_addr = {
6428                 .sa_socklen = sizeof(struct sockaddr_un),
6429         };
6430         ssize_t ret;
6431         struct socket_info *si = find_socket_info(s);
6432         struct swrap_address saddr = {
6433                 .sa_socklen = sizeof(struct sockaddr_storage),
6434         };
6435         struct msghdr msg;
6436         struct iovec tmp;
6437         int tret;
6438
6439         if (!si) {
6440                 return libc_recvfrom(s,
6441                                      buf,
6442                                      len,
6443                                      flags,
6444                                      from,
6445                                      fromlen);
6446         }
6447
6448         tmp.iov_base = buf;
6449         tmp.iov_len = len;
6450
6451         ZERO_STRUCT(msg);
6452         if (from != NULL && fromlen != NULL) {
6453                 msg.msg_name = from;   /* optional address */
6454                 msg.msg_namelen = *fromlen; /* size of address */
6455         } else {
6456                 msg.msg_name = &saddr.sa.s; /* optional address */
6457                 msg.msg_namelen = saddr.sa_socklen; /* size of address */
6458         }
6459         msg.msg_iov = &tmp;            /* scatter/gather array */
6460         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6461 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6462         msg.msg_control = NULL;        /* ancillary data, see below */
6463         msg.msg_controllen = 0;        /* ancillary data buffer len */
6464         msg.msg_flags = 0;             /* flags on received message */
6465 #endif
6466
6467         tret = swrap_recvmsg_before(s, si, &msg, &tmp);
6468         if (tret < 0) {
6469                 return -1;
6470         }
6471
6472         buf = msg.msg_iov[0].iov_base;
6473         len = msg.msg_iov[0].iov_len;
6474
6475         ret = libc_recvfrom(s,
6476                             buf,
6477                             len,
6478                             flags,
6479                             &from_addr.sa.s,
6480                             &from_addr.sa_socklen);
6481         if (ret == -1) {
6482                 return ret;
6483         }
6484
6485         tret = swrap_recvmsg_after(s,
6486                                    si,
6487                                    &msg,
6488                                    &from_addr.sa.un,
6489                                    from_addr.sa_socklen,
6490                                    ret);
6491         if (tret != 0) {
6492                 return tret;
6493         }
6494
6495         if (from != NULL && fromlen != NULL) {
6496                 *fromlen = msg.msg_namelen;
6497         }
6498
6499         return ret;
6500 }
6501
6502 #ifdef HAVE_ACCEPT_PSOCKLEN_T
6503 ssize_t recvfrom(int s, void *buf, size_t len, int flags,
6504                  struct sockaddr *from, Psocklen_t fromlen)
6505 #else
6506 ssize_t recvfrom(int s, void *buf, size_t len, int flags,
6507                  struct sockaddr *from, socklen_t *fromlen)
6508 #endif
6509 {
6510         return swrap_recvfrom(s, buf, len, flags, from, (socklen_t *)fromlen);
6511 }
6512
6513 /****************************************************************************
6514  *   SENDTO
6515  ***************************************************************************/
6516
6517 static ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags,
6518                             const struct sockaddr *to, socklen_t tolen)
6519 {
6520         struct msghdr msg;
6521         struct iovec tmp;
6522         struct swrap_address un_addr = {
6523                 .sa_socklen = sizeof(struct sockaddr_un),
6524         };
6525         const struct sockaddr_un *to_un = NULL;
6526         ssize_t ret;
6527         int rc;
6528         struct socket_info *si = find_socket_info(s);
6529         int bcast = 0;
6530
6531         if (!si) {
6532                 return libc_sendto(s, buf, len, flags, to, tolen);
6533         }
6534
6535         tmp.iov_base = discard_const_p(char, buf);
6536         tmp.iov_len = len;
6537
6538         ZERO_STRUCT(msg);
6539         msg.msg_name = discard_const_p(struct sockaddr, to); /* optional address */
6540         msg.msg_namelen = tolen;       /* size of address */
6541         msg.msg_iov = &tmp;            /* scatter/gather array */
6542         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6543 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6544         msg.msg_control = NULL;        /* ancillary data, see below */
6545         msg.msg_controllen = 0;        /* ancillary data buffer len */
6546         msg.msg_flags = 0;             /* flags on received message */
6547 #endif
6548
6549         rc = swrap_sendmsg_before(s,
6550                                   si,
6551                                   &msg,
6552                                   &tmp,
6553                                   &un_addr.sa.un,
6554                                   &to_un,
6555                                   &to,
6556                                   &bcast);
6557         if (rc < 0) {
6558                 return -1;
6559         }
6560
6561         buf = msg.msg_iov[0].iov_base;
6562         len = msg.msg_iov[0].iov_len;
6563
6564         if (bcast) {
6565                 struct stat st;
6566                 unsigned int iface;
6567                 unsigned int prt = ntohs(((const struct sockaddr_in *)(const void *)to)->sin_port);
6568                 char type;
6569                 char *swrap_dir = NULL;
6570
6571                 type = SOCKET_TYPE_CHAR_UDP;
6572
6573                 swrap_dir = socket_wrapper_dir();
6574                 if (swrap_dir == NULL) {
6575                         return -1;
6576                 }
6577
6578                 for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
6579                         swrap_un_path(&un_addr.sa.un,
6580                                       swrap_dir,
6581                                       type,
6582                                       iface,
6583                                       prt);
6584                         if (stat(un_addr.sa.un.sun_path, &st) != 0) continue;
6585
6586                         /* ignore the any errors in broadcast sends */
6587                         libc_sendto(s,
6588                                     buf,
6589                                     len,
6590                                     flags,
6591                                     &un_addr.sa.s,
6592                                     un_addr.sa_socklen);
6593                 }
6594
6595                 SAFE_FREE(swrap_dir);
6596
6597                 SWRAP_LOCK_SI(si);
6598
6599                 swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
6600
6601                 SWRAP_UNLOCK_SI(si);
6602
6603                 return len;
6604         }
6605
6606         SWRAP_LOCK_SI(si);
6607         /*
6608          * If it is a dgram socket and we are connected, don't include the
6609          * 'to' address.
6610          */
6611         if (si->type == SOCK_DGRAM && si->connected) {
6612                 ret = libc_sendto(s,
6613                                   buf,
6614                                   len,
6615                                   flags,
6616                                   NULL,
6617                                   0);
6618         } else {
6619                 ret = libc_sendto(s,
6620                                   buf,
6621                                   len,
6622                                   flags,
6623                                   (struct sockaddr *)msg.msg_name,
6624                                   msg.msg_namelen);
6625         }
6626
6627         SWRAP_UNLOCK_SI(si);
6628
6629         swrap_sendmsg_after(s, si, &msg, to, ret);
6630
6631         return ret;
6632 }
6633
6634 ssize_t sendto(int s, const void *buf, size_t len, int flags,
6635                const struct sockaddr *to, socklen_t tolen)
6636 {
6637         return swrap_sendto(s, buf, len, flags, to, tolen);
6638 }
6639
6640 /****************************************************************************
6641  *   READV
6642  ***************************************************************************/
6643
6644 static ssize_t swrap_recv(int s, void *buf, size_t len, int flags)
6645 {
6646         struct socket_info *si;
6647         struct msghdr msg;
6648         struct swrap_address saddr = {
6649                 .sa_socklen = sizeof(struct sockaddr_storage),
6650         };
6651         struct iovec tmp;
6652         ssize_t ret;
6653         int tret;
6654
6655         si = find_socket_info(s);
6656         if (si == NULL) {
6657                 return libc_recv(s, buf, len, flags);
6658         }
6659
6660         tmp.iov_base = buf;
6661         tmp.iov_len = len;
6662
6663         ZERO_STRUCT(msg);
6664         msg.msg_name = &saddr.sa.s;    /* optional address */
6665         msg.msg_namelen = saddr.sa_socklen; /* size of address */
6666         msg.msg_iov = &tmp;            /* scatter/gather array */
6667         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6668 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6669         msg.msg_control = NULL;        /* ancillary data, see below */
6670         msg.msg_controllen = 0;        /* ancillary data buffer len */
6671         msg.msg_flags = 0;             /* flags on received message */
6672 #endif
6673
6674         tret = swrap_recvmsg_before(s, si, &msg, &tmp);
6675         if (tret < 0) {
6676                 return -1;
6677         }
6678
6679         buf = msg.msg_iov[0].iov_base;
6680         len = msg.msg_iov[0].iov_len;
6681
6682         ret = libc_recv(s, buf, len, flags);
6683
6684         tret = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret);
6685         if (tret != 0) {
6686                 return tret;
6687         }
6688
6689         return ret;
6690 }
6691
6692 ssize_t recv(int s, void *buf, size_t len, int flags)
6693 {
6694         return swrap_recv(s, buf, len, flags);
6695 }
6696
6697 /****************************************************************************
6698  *   READ
6699  ***************************************************************************/
6700
6701 static ssize_t swrap_read(int s, void *buf, size_t len)
6702 {
6703         struct socket_info *si;
6704         struct msghdr msg;
6705         struct iovec tmp;
6706         struct swrap_address saddr = {
6707                 .sa_socklen = sizeof(struct sockaddr_storage),
6708         };
6709         ssize_t ret;
6710         int tret;
6711
6712         si = find_socket_info(s);
6713         if (si == NULL) {
6714                 return libc_read(s, buf, len);
6715         }
6716
6717         tmp.iov_base = buf;
6718         tmp.iov_len = len;
6719
6720         ZERO_STRUCT(msg);
6721         msg.msg_name = &saddr.sa.ss;   /* optional address */
6722         msg.msg_namelen = saddr.sa_socklen; /* size of address */
6723         msg.msg_iov = &tmp;            /* scatter/gather array */
6724         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6725 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6726         msg.msg_control = NULL;        /* ancillary data, see below */
6727         msg.msg_controllen = 0;        /* ancillary data buffer len */
6728         msg.msg_flags = 0;             /* flags on received message */
6729 #endif
6730
6731         tret = swrap_recvmsg_before(s, si, &msg, &tmp);
6732         if (tret < 0) {
6733                 if (tret == -ENOTSOCK) {
6734                         return libc_read(s, buf, len);
6735                 }
6736                 return -1;
6737         }
6738
6739         buf = msg.msg_iov[0].iov_base;
6740         len = msg.msg_iov[0].iov_len;
6741
6742         ret = libc_read(s, buf, len);
6743
6744         tret = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret);
6745         if (tret != 0) {
6746                 return tret;
6747         }
6748
6749         return ret;
6750 }
6751
6752 ssize_t read(int s, void *buf, size_t len)
6753 {
6754         return swrap_read(s, buf, len);
6755 }
6756
6757 /****************************************************************************
6758  *   WRITE
6759  ***************************************************************************/
6760
6761 static ssize_t swrap_write(int s, const void *buf, size_t len)
6762 {
6763         struct msghdr msg;
6764         struct iovec tmp;
6765         struct sockaddr_un un_addr;
6766         ssize_t ret;
6767         int rc;
6768         struct socket_info *si;
6769
6770         si = find_socket_info(s);
6771         if (si == NULL) {
6772                 return libc_write(s, buf, len);
6773         }
6774
6775         tmp.iov_base = discard_const_p(char, buf);
6776         tmp.iov_len = len;
6777
6778         ZERO_STRUCT(msg);
6779         msg.msg_name = NULL;           /* optional address */
6780         msg.msg_namelen = 0;           /* size of address */
6781         msg.msg_iov = &tmp;            /* scatter/gather array */
6782         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6783 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6784         msg.msg_control = NULL;        /* ancillary data, see below */
6785         msg.msg_controllen = 0;        /* ancillary data buffer len */
6786         msg.msg_flags = 0;             /* flags on received message */
6787 #endif
6788
6789         rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
6790         if (rc < 0) {
6791                 return -1;
6792         }
6793
6794         buf = msg.msg_iov[0].iov_base;
6795         len = msg.msg_iov[0].iov_len;
6796
6797         ret = libc_write(s, buf, len);
6798
6799         swrap_sendmsg_after(s, si, &msg, NULL, ret);
6800
6801         return ret;
6802 }
6803
6804 ssize_t write(int s, const void *buf, size_t len)
6805 {
6806         return swrap_write(s, buf, len);
6807 }
6808
6809 /****************************************************************************
6810  *   SEND
6811  ***************************************************************************/
6812
6813 static ssize_t swrap_send(int s, const void *buf, size_t len, int flags)
6814 {
6815         struct msghdr msg;
6816         struct iovec tmp;
6817         struct sockaddr_un un_addr;
6818         ssize_t ret;
6819         int rc;
6820         struct socket_info *si = find_socket_info(s);
6821
6822         if (!si) {
6823                 return libc_send(s, buf, len, flags);
6824         }
6825
6826         tmp.iov_base = discard_const_p(char, buf);
6827         tmp.iov_len = len;
6828
6829         ZERO_STRUCT(msg);
6830         msg.msg_name = NULL;           /* optional address */
6831         msg.msg_namelen = 0;           /* size of address */
6832         msg.msg_iov = &tmp;            /* scatter/gather array */
6833         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6834 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6835         msg.msg_control = NULL;        /* ancillary data, see below */
6836         msg.msg_controllen = 0;        /* ancillary data buffer len */
6837         msg.msg_flags = 0;             /* flags on received message */
6838 #endif
6839
6840         rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
6841         if (rc < 0) {
6842                 return -1;
6843         }
6844
6845         buf = msg.msg_iov[0].iov_base;
6846         len = msg.msg_iov[0].iov_len;
6847
6848         ret = libc_send(s, buf, len, flags);
6849
6850         swrap_sendmsg_after(s, si, &msg, NULL, ret);
6851
6852         return ret;
6853 }
6854
6855 ssize_t send(int s, const void *buf, size_t len, int flags)
6856 {
6857         return swrap_send(s, buf, len, flags);
6858 }
6859
6860 /****************************************************************************
6861  *   RECVMSG
6862  ***************************************************************************/
6863
6864 static ssize_t swrap_recvmsg(int s, struct msghdr *omsg, int flags)
6865 {
6866         struct swrap_address from_addr = {
6867                 .sa_socklen = sizeof(struct sockaddr_un),
6868         };
6869         struct swrap_address convert_addr = {
6870                 .sa_socklen = sizeof(struct sockaddr_storage),
6871         };
6872         struct socket_info *si;
6873         struct msghdr msg;
6874         struct iovec tmp;
6875 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6876         size_t msg_ctrllen_filled;
6877         size_t msg_ctrllen_left;
6878 #endif
6879
6880         ssize_t ret;
6881         int rc;
6882
6883         si = find_socket_info(s);
6884         if (si == NULL) {
6885                 rc = swrap_recvmsg_before_unix(omsg, &msg);
6886                 if (rc < 0) {
6887                         return rc;
6888                 }
6889                 ret = libc_recvmsg(s, &msg, flags);
6890                 return swrap_recvmsg_after_unix(&msg, omsg, ret);
6891         }
6892
6893         tmp.iov_base = NULL;
6894         tmp.iov_len = 0;
6895
6896         ZERO_STRUCT(msg);
6897         msg.msg_name = &from_addr.sa;              /* optional address */
6898         msg.msg_namelen = from_addr.sa_socklen;    /* size of address */
6899         msg.msg_iov = omsg->msg_iov;               /* scatter/gather array */
6900         msg.msg_iovlen = omsg->msg_iovlen;         /* # elements in msg_iov */
6901 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6902         msg_ctrllen_filled = 0;
6903         msg_ctrllen_left = omsg->msg_controllen;
6904
6905         msg.msg_control = omsg->msg_control;       /* ancillary data, see below */
6906         msg.msg_controllen = omsg->msg_controllen; /* ancillary data buffer len */
6907         msg.msg_flags = omsg->msg_flags;           /* flags on received message */
6908 #endif
6909
6910         rc = swrap_recvmsg_before(s, si, &msg, &tmp);
6911         if (rc < 0) {
6912                 return -1;
6913         }
6914
6915         ret = libc_recvmsg(s, &msg, flags);
6916
6917 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6918         msg_ctrllen_filled += msg.msg_controllen;
6919         msg_ctrllen_left -= msg.msg_controllen;
6920
6921         if (omsg->msg_control != NULL) {
6922                 uint8_t *p;
6923
6924                 p = omsg->msg_control;
6925                 p += msg_ctrllen_filled;
6926
6927                 msg.msg_control = p;
6928                 msg.msg_controllen = msg_ctrllen_left;
6929         } else {
6930                 msg.msg_control = NULL;
6931                 msg.msg_controllen = 0;
6932         }
6933 #endif
6934
6935         /*
6936          * We convert the unix address to a IP address so we need a buffer
6937          * which can store the address in case of SOCK_DGRAM, see below.
6938          */
6939         msg.msg_name = &convert_addr.sa;
6940         msg.msg_namelen = convert_addr.sa_socklen;
6941
6942         rc = swrap_recvmsg_after(s,
6943                                  si,
6944                                  &msg,
6945                                  &from_addr.sa.un,
6946                                  from_addr.sa_socklen,
6947                                  ret);
6948         if (rc != 0) {
6949                 return rc;
6950         }
6951
6952 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6953         if (omsg->msg_control != NULL) {
6954                 /* msg.msg_controllen = space left */
6955                 msg_ctrllen_left = msg.msg_controllen;
6956                 msg_ctrllen_filled = omsg->msg_controllen - msg_ctrllen_left;
6957         }
6958
6959         /* Update the original message length */
6960         omsg->msg_controllen = msg_ctrllen_filled;
6961         omsg->msg_flags = msg.msg_flags;
6962 #endif
6963         omsg->msg_iovlen = msg.msg_iovlen;
6964
6965         SWRAP_LOCK_SI(si);
6966
6967         /*
6968          * From the manpage:
6969          *
6970          * The  msg_name  field  points  to a caller-allocated buffer that is
6971          * used to return the source address if the socket is unconnected.  The
6972          * caller should set msg_namelen to the size of this buffer before this
6973          * call; upon return from a successful call, msg_name will contain the
6974          * length of the returned address.  If the application  does  not  need
6975          * to know the source address, msg_name can be specified as NULL.
6976          */
6977         if (si->type == SOCK_STREAM) {
6978                 omsg->msg_namelen = 0;
6979         } else if (omsg->msg_name != NULL &&
6980                    omsg->msg_namelen != 0 &&
6981                    omsg->msg_namelen >= msg.msg_namelen) {
6982                 memcpy(omsg->msg_name, msg.msg_name, msg.msg_namelen);
6983                 omsg->msg_namelen = msg.msg_namelen;
6984         }
6985
6986         SWRAP_UNLOCK_SI(si);
6987
6988         return ret;
6989 }
6990
6991 ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)
6992 {
6993         return swrap_recvmsg(sockfd, msg, flags);
6994 }
6995
6996 /****************************************************************************
6997  *   SENDMSG
6998  ***************************************************************************/
6999
7000 static ssize_t swrap_sendmsg(int s, const struct msghdr *omsg, int flags)
7001 {
7002         struct msghdr msg;
7003         struct iovec tmp;
7004         struct sockaddr_un un_addr;
7005         const struct sockaddr_un *to_un = NULL;
7006         const struct sockaddr *to = NULL;
7007         ssize_t ret;
7008         int rc;
7009         struct socket_info *si = find_socket_info(s);
7010         int bcast = 0;
7011
7012         if (!si) {
7013                 int scm_rights_pipe_fd = -1;
7014
7015                 rc = swrap_sendmsg_before_unix(omsg, &msg,
7016                                                &scm_rights_pipe_fd);
7017                 if (rc < 0) {
7018                         return rc;
7019                 }
7020                 ret = libc_sendmsg(s, &msg, flags);
7021                 return swrap_sendmsg_after_unix(&msg, ret, scm_rights_pipe_fd);
7022         }
7023
7024         ZERO_STRUCT(un_addr);
7025
7026         tmp.iov_base = NULL;
7027         tmp.iov_len = 0;
7028
7029         ZERO_STRUCT(msg);
7030
7031         SWRAP_LOCK_SI(si);
7032
7033         if (si->connected == 0) {
7034                 msg.msg_name = omsg->msg_name;             /* optional address */
7035                 msg.msg_namelen = omsg->msg_namelen;       /* size of address */
7036         }
7037         msg.msg_iov = omsg->msg_iov;               /* scatter/gather array */
7038         msg.msg_iovlen = omsg->msg_iovlen;         /* # elements in msg_iov */
7039
7040         SWRAP_UNLOCK_SI(si);
7041
7042 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7043         if (omsg != NULL && omsg->msg_controllen > 0 && omsg->msg_control != NULL) {
7044                 uint8_t *cmbuf = NULL;
7045                 size_t cmlen = 0;
7046
7047                 rc = swrap_sendmsg_filter_cmsghdr(omsg, &cmbuf, &cmlen);
7048                 if (rc < 0) {
7049                         return rc;
7050                 }
7051
7052                 if (cmlen == 0) {
7053                         msg.msg_controllen = 0;
7054                         msg.msg_control = NULL;
7055                 } else {
7056                         msg.msg_control = cmbuf;
7057                         msg.msg_controllen = cmlen;
7058                 }
7059         }
7060         msg.msg_flags = omsg->msg_flags;           /* flags on received message */
7061 #endif
7062         rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, &to_un, &to, &bcast);
7063         if (rc < 0) {
7064                 int saved_errno = errno;
7065 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7066                 SAFE_FREE(msg.msg_control);
7067 #endif
7068                 errno = saved_errno;
7069                 return -1;
7070         }
7071
7072         if (bcast) {
7073                 struct stat st;
7074                 unsigned int iface;
7075                 unsigned int prt = ntohs(((const struct sockaddr_in *)(const void *)to)->sin_port);
7076                 char type;
7077                 size_t i, len = 0;
7078                 uint8_t *buf;
7079                 off_t ofs = 0;
7080                 size_t avail = 0;
7081                 size_t remain;
7082                 char *swrap_dir = NULL;
7083
7084                 for (i = 0; i < (size_t)msg.msg_iovlen; i++) {
7085                         avail += msg.msg_iov[i].iov_len;
7086                 }
7087
7088                 len = avail;
7089                 remain = avail;
7090
7091                 /* we capture it as one single packet */
7092                 buf = (uint8_t *)malloc(remain);
7093                 if (!buf) {
7094                         int saved_errno = errno;
7095 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7096                         SAFE_FREE(msg.msg_control);
7097 #endif
7098                         errno = saved_errno;
7099                         return -1;
7100                 }
7101
7102                 for (i = 0; i < (size_t)msg.msg_iovlen; i++) {
7103                         size_t this_time = MIN(remain, (size_t)msg.msg_iov[i].iov_len);
7104                         memcpy(buf + ofs,
7105                                msg.msg_iov[i].iov_base,
7106                                this_time);
7107                         ofs += this_time;
7108                         remain -= this_time;
7109                 }
7110
7111                 type = SOCKET_TYPE_CHAR_UDP;
7112
7113                 swrap_dir = socket_wrapper_dir();
7114                 if (swrap_dir == NULL) {
7115                         int saved_errno = errno;
7116 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7117                         SAFE_FREE(msg.msg_control);
7118 #endif
7119                         SAFE_FREE(buf);
7120                         errno = saved_errno;
7121                         return -1;
7122                 }
7123
7124                 for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
7125                         swrap_un_path(&un_addr, swrap_dir, type, iface, prt);
7126                         if (stat(un_addr.sun_path, &st) != 0) continue;
7127
7128                         msg.msg_name = &un_addr;           /* optional address */
7129                         msg.msg_namelen = sizeof(un_addr); /* size of address */
7130
7131                         /* ignore the any errors in broadcast sends */
7132                         libc_sendmsg(s, &msg, flags);
7133                 }
7134
7135                 SAFE_FREE(swrap_dir);
7136
7137                 SWRAP_LOCK_SI(si);
7138
7139                 swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
7140                 free(buf);
7141
7142                 SWRAP_UNLOCK_SI(si);
7143
7144                 return len;
7145         }
7146
7147         ret = libc_sendmsg(s, &msg, flags);
7148
7149         swrap_sendmsg_after(s, si, &msg, to, ret);
7150
7151 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7152         {
7153                 int saved_errno = errno;
7154                 SAFE_FREE(msg.msg_control);
7155                 errno = saved_errno;
7156         }
7157 #endif
7158
7159         return ret;
7160 }
7161
7162 ssize_t sendmsg(int s, const struct msghdr *omsg, int flags)
7163 {
7164         return swrap_sendmsg(s, omsg, flags);
7165 }
7166
7167 /****************************************************************************
7168  *   READV
7169  ***************************************************************************/
7170
7171 static ssize_t swrap_readv(int s, const struct iovec *vector, int count)
7172 {
7173         struct socket_info *si;
7174         struct msghdr msg;
7175         struct iovec tmp;
7176         struct swrap_address saddr = {
7177                 .sa_socklen = sizeof(struct sockaddr_storage)
7178         };
7179         ssize_t ret;
7180         int rc;
7181
7182         si = find_socket_info(s);
7183         if (si == NULL) {
7184                 return libc_readv(s, vector, count);
7185         }
7186
7187         tmp.iov_base = NULL;
7188         tmp.iov_len = 0;
7189
7190         ZERO_STRUCT(msg);
7191         msg.msg_name = &saddr.sa.s; /* optional address */
7192         msg.msg_namelen = saddr.sa_socklen;      /* size of address */
7193         msg.msg_iov = discard_const_p(struct iovec, vector); /* scatter/gather array */
7194         msg.msg_iovlen = count;        /* # elements in msg_iov */
7195 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7196         msg.msg_control = NULL;        /* ancillary data, see below */
7197         msg.msg_controllen = 0;        /* ancillary data buffer len */
7198         msg.msg_flags = 0;             /* flags on received message */
7199 #endif
7200
7201         rc = swrap_recvmsg_before(s, si, &msg, &tmp);
7202         if (rc < 0) {
7203                 if (rc == -ENOTSOCK) {
7204                         return libc_readv(s, vector, count);
7205                 }
7206                 return -1;
7207         }
7208
7209         ret = libc_readv(s, msg.msg_iov, msg.msg_iovlen);
7210
7211         rc = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret);
7212         if (rc != 0) {
7213                 return rc;
7214         }
7215
7216         return ret;
7217 }
7218
7219 ssize_t readv(int s, const struct iovec *vector, int count)
7220 {
7221         return swrap_readv(s, vector, count);
7222 }
7223
7224 /****************************************************************************
7225  *   WRITEV
7226  ***************************************************************************/
7227
7228 static ssize_t swrap_writev(int s, const struct iovec *vector, int count)
7229 {
7230         struct msghdr msg;
7231         struct iovec tmp;
7232         struct sockaddr_un un_addr;
7233         ssize_t ret;
7234         int rc;
7235         struct socket_info *si = find_socket_info(s);
7236
7237         if (!si) {
7238                 return libc_writev(s, vector, count);
7239         }
7240
7241         tmp.iov_base = NULL;
7242         tmp.iov_len = 0;
7243
7244         ZERO_STRUCT(msg);
7245         msg.msg_name = NULL;           /* optional address */
7246         msg.msg_namelen = 0;           /* size of address */
7247         msg.msg_iov = discard_const_p(struct iovec, vector); /* scatter/gather array */
7248         msg.msg_iovlen = count;        /* # elements in msg_iov */
7249 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7250         msg.msg_control = NULL;        /* ancillary data, see below */
7251         msg.msg_controllen = 0;        /* ancillary data buffer len */
7252         msg.msg_flags = 0;             /* flags on received message */
7253 #endif
7254
7255         rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
7256         if (rc < 0) {
7257                 if (rc == -ENOTSOCK) {
7258                         return libc_readv(s, vector, count);
7259                 }
7260                 return -1;
7261         }
7262
7263         ret = libc_writev(s, msg.msg_iov, msg.msg_iovlen);
7264
7265         swrap_sendmsg_after(s, si, &msg, NULL, ret);
7266
7267         return ret;
7268 }
7269
7270 ssize_t writev(int s, const struct iovec *vector, int count)
7271 {
7272         return swrap_writev(s, vector, count);
7273 }
7274
7275 /****************************
7276  * CLOSE
7277  ***************************/
7278
7279 static int swrap_close(int fd)
7280 {
7281         struct socket_info *si = NULL;
7282         int si_index;
7283         int ret;
7284
7285         swrap_mutex_lock(&socket_reset_mutex);
7286
7287         si_index = find_socket_info_index(fd);
7288         if (si_index == -1) {
7289                 swrap_mutex_unlock(&socket_reset_mutex);
7290                 return libc_close(fd);
7291         }
7292
7293         SWRAP_LOG(SWRAP_LOG_TRACE, "Close wrapper for fd=%d", fd);
7294         reset_socket_info_index(fd);
7295
7296         si = swrap_get_socket_info(si_index);
7297
7298         swrap_mutex_lock(&first_free_mutex);
7299         SWRAP_LOCK_SI(si);
7300
7301         ret = libc_close(fd);
7302
7303         swrap_dec_refcount(si);
7304
7305         if (swrap_get_refcount(si) > 0) {
7306                 /* there are still references left */
7307                 goto out;
7308         }
7309
7310         if (si->fd_passed) {
7311                 goto set_next_free;
7312         }
7313
7314         if (si->myname.sa_socklen > 0 && si->peername.sa_socklen > 0) {
7315                 swrap_pcap_dump_packet(si, NULL, SWRAP_CLOSE_SEND, NULL, 0);
7316         }
7317
7318         if (si->myname.sa_socklen > 0 && si->peername.sa_socklen > 0) {
7319                 swrap_pcap_dump_packet(si, NULL, SWRAP_CLOSE_RECV, NULL, 0);
7320                 swrap_pcap_dump_packet(si, NULL, SWRAP_CLOSE_ACK, NULL, 0);
7321         }
7322
7323         if (si->un_addr.sun_path[0] != '\0') {
7324                 unlink(si->un_addr.sun_path);
7325         }
7326
7327 set_next_free:
7328         swrap_set_next_free(si, first_free);
7329         first_free = si_index;
7330
7331 out:
7332         SWRAP_UNLOCK_SI(si);
7333         swrap_mutex_unlock(&first_free_mutex);
7334         swrap_mutex_unlock(&socket_reset_mutex);
7335
7336         return ret;
7337 }
7338
7339 int close(int fd)
7340 {
7341         return swrap_close(fd);
7342 }
7343
7344 /****************************
7345  * DUP
7346  ***************************/
7347
7348 static int swrap_dup(int fd)
7349 {
7350         struct socket_info *si;
7351         int dup_fd, idx;
7352
7353         idx = find_socket_info_index(fd);
7354         if (idx == -1) {
7355                 return libc_dup(fd);
7356         }
7357
7358         si = swrap_get_socket_info(idx);
7359
7360         dup_fd = libc_dup(fd);
7361         if (dup_fd == -1) {
7362                 int saved_errno = errno;
7363                 errno = saved_errno;
7364                 return -1;
7365         }
7366
7367         if ((size_t)dup_fd >= socket_fds_max) {
7368                 SWRAP_LOG(SWRAP_LOG_ERROR,
7369                           "The max socket index limit of %zu has been reached, "
7370                           "trying to add %d",
7371                           socket_fds_max,
7372                           dup_fd);
7373                 libc_close(dup_fd);
7374                 errno = EMFILE;
7375                 return -1;
7376         }
7377
7378         SWRAP_LOCK_SI(si);
7379
7380         swrap_inc_refcount(si);
7381
7382         SWRAP_UNLOCK_SI(si);
7383
7384         /* Make sure we don't have an entry for the fd */
7385         swrap_remove_stale(dup_fd);
7386
7387         set_socket_info_index(dup_fd, idx);
7388
7389         return dup_fd;
7390 }
7391
7392 int dup(int fd)
7393 {
7394         return swrap_dup(fd);
7395 }
7396
7397 /****************************
7398  * DUP2
7399  ***************************/
7400
7401 static int swrap_dup2(int fd, int newfd)
7402 {
7403         struct socket_info *si;
7404         int dup_fd, idx;
7405
7406         idx = find_socket_info_index(fd);
7407         if (idx == -1) {
7408                 return libc_dup2(fd, newfd);
7409         }
7410
7411         si = swrap_get_socket_info(idx);
7412
7413         if (fd == newfd) {
7414                 /*
7415                  * According to the manpage:
7416                  *
7417                  * "If oldfd is a valid file descriptor, and newfd has the same
7418                  * value as oldfd, then dup2() does nothing, and returns newfd."
7419                  */
7420                 return newfd;
7421         }
7422
7423         if ((size_t)newfd >= socket_fds_max) {
7424                 SWRAP_LOG(SWRAP_LOG_ERROR,
7425                           "The max socket index limit of %zu has been reached, "
7426                           "trying to add %d",
7427                           socket_fds_max,
7428                           newfd);
7429                 errno = EMFILE;
7430                 return -1;
7431         }
7432
7433         if (find_socket_info(newfd)) {
7434                 /* dup2() does an implicit close of newfd, which we
7435                  * need to emulate */
7436                 swrap_close(newfd);
7437         }
7438
7439         dup_fd = libc_dup2(fd, newfd);
7440         if (dup_fd == -1) {
7441                 int saved_errno = errno;
7442                 errno = saved_errno;
7443                 return -1;
7444         }
7445
7446         SWRAP_LOCK_SI(si);
7447
7448         swrap_inc_refcount(si);
7449
7450         SWRAP_UNLOCK_SI(si);
7451
7452         /* Make sure we don't have an entry for the fd */
7453         swrap_remove_stale(dup_fd);
7454
7455         set_socket_info_index(dup_fd, idx);
7456
7457         return dup_fd;
7458 }
7459
7460 int dup2(int fd, int newfd)
7461 {
7462         return swrap_dup2(fd, newfd);
7463 }
7464
7465 /****************************
7466  * FCNTL
7467  ***************************/
7468
7469 static int swrap_vfcntl(int fd, int cmd, va_list va)
7470 {
7471         struct socket_info *si;
7472         int rc, dup_fd, idx;
7473
7474         idx = find_socket_info_index(fd);
7475         if (idx == -1) {
7476                 return libc_vfcntl(fd, cmd, va);
7477         }
7478
7479         si = swrap_get_socket_info(idx);
7480
7481         switch (cmd) {
7482         case F_DUPFD:
7483                 dup_fd = libc_vfcntl(fd, cmd, va);
7484                 if (dup_fd == -1) {
7485                         int saved_errno = errno;
7486                         errno = saved_errno;
7487                         return -1;
7488                 }
7489
7490                 /* Make sure we don't have an entry for the fd */
7491                 swrap_remove_stale(dup_fd);
7492
7493                 if ((size_t)dup_fd >= socket_fds_max) {
7494                         SWRAP_LOG(SWRAP_LOG_ERROR,
7495                           "The max socket index limit of %zu has been reached, "
7496                           "trying to add %d",
7497                           socket_fds_max,
7498                           dup_fd);
7499                         libc_close(dup_fd);
7500                         errno = EMFILE;
7501                         return -1;
7502                 }
7503
7504                 SWRAP_LOCK_SI(si);
7505
7506                 swrap_inc_refcount(si);
7507
7508                 SWRAP_UNLOCK_SI(si);
7509
7510
7511                 set_socket_info_index(dup_fd, idx);
7512
7513                 rc = dup_fd;
7514                 break;
7515         default:
7516                 rc = libc_vfcntl(fd, cmd, va);
7517                 break;
7518         }
7519
7520         return rc;
7521 }
7522
7523 int fcntl(int fd, int cmd, ...)
7524 {
7525         va_list va;
7526         int rc;
7527
7528         va_start(va, cmd);
7529
7530         rc = swrap_vfcntl(fd, cmd, va);
7531
7532         va_end(va);
7533
7534         return rc;
7535 }
7536
7537 /****************************
7538  * EVENTFD
7539  ***************************/
7540
7541 #ifdef HAVE_EVENTFD
7542 static int swrap_eventfd(int count, int flags)
7543 {
7544         int fd;
7545
7546         fd = libc_eventfd(count, flags);
7547         if (fd != -1) {
7548                 swrap_remove_stale(fd);
7549         }
7550
7551         return fd;
7552 }
7553
7554 #ifdef HAVE_EVENTFD_UNSIGNED_INT
7555 int eventfd(unsigned int count, int flags)
7556 #else
7557 int eventfd(int count, int flags)
7558 #endif
7559 {
7560         return swrap_eventfd(count, flags);
7561 }
7562 #endif
7563
7564 #ifdef HAVE_PLEDGE
7565 int pledge(const char *promises, const char *paths[])
7566 {
7567         (void)promises; /* unused */
7568         (void)paths; /* unused */
7569
7570         return 0;
7571 }
7572 #endif /* HAVE_PLEDGE */
7573
7574 static void swrap_thread_prepare(void)
7575 {
7576         /*
7577          * This function should only be called here!!
7578          *
7579          * We bind all symobls to avoid deadlocks of the fork is
7580          * interrupted by a signal handler using a symbol of this
7581          * library.
7582          */
7583         swrap_bind_symbol_all();
7584
7585         SWRAP_LOCK_ALL;
7586 }
7587
7588 static void swrap_thread_parent(void)
7589 {
7590         SWRAP_UNLOCK_ALL;
7591 }
7592
7593 static void swrap_thread_child(void)
7594 {
7595         SWRAP_REINIT_ALL;
7596 }
7597
7598 /****************************
7599  * CONSTRUCTOR
7600  ***************************/
7601 void swrap_constructor(void)
7602 {
7603         if (PIPE_BUF < sizeof(struct swrap_unix_scm_rights)) {
7604                 SWRAP_LOG(SWRAP_LOG_ERROR,
7605                           "PIPE_BUF=%zu < "
7606                           "sizeof(struct swrap_unix_scm_rights)=%zu\n"
7607                           "sizeof(struct swrap_unix_scm_rights_payload)=%zu "
7608                           "sizeof(struct socket_info)=%zu",
7609                           (size_t)PIPE_BUF,
7610                           sizeof(struct swrap_unix_scm_rights),
7611                           sizeof(struct swrap_unix_scm_rights_payload),
7612                           sizeof(struct socket_info));
7613                 exit(-1);
7614         }
7615
7616         SWRAP_REINIT_ALL;
7617
7618         /*
7619         * If we hold a lock and the application forks, then the child
7620         * is not able to unlock the mutex and we are in a deadlock.
7621         * This should prevent such deadlocks.
7622         */
7623         pthread_atfork(&swrap_thread_prepare,
7624                        &swrap_thread_parent,
7625                        &swrap_thread_child);
7626 }
7627
7628 /****************************
7629  * DESTRUCTOR
7630  ***************************/
7631
7632 /*
7633  * This function is called when the library is unloaded and makes sure that
7634  * sockets get closed and the unix file for the socket are unlinked.
7635  */
7636 void swrap_destructor(void)
7637 {
7638         size_t i;
7639
7640         if (socket_fds_idx != NULL) {
7641                 for (i = 0; i < socket_fds_max; ++i) {
7642                         if (socket_fds_idx[i] != -1) {
7643                                 swrap_close(i);
7644                         }
7645                 }
7646                 SAFE_FREE(socket_fds_idx);
7647         }
7648
7649         SAFE_FREE(sockets);
7650
7651         if (swrap.libc.handle != NULL) {
7652                 dlclose(swrap.libc.handle);
7653         }
7654         if (swrap.libc.socket_handle) {
7655                 dlclose(swrap.libc.socket_handle);
7656         }
7657 }
7658
7659 #if defined(HAVE__SOCKET) && defined(HAVE__CLOSE)
7660 /*
7661  * On FreeBSD 12 (and maybe other platforms)
7662  * system libraries like libresolv prefix there
7663  * syscalls with '_' in order to always use
7664  * the symbols from libc.
7665  *
7666  * In the interaction with resolv_wrapper,
7667  * we need to inject socket wrapper into libresolv,
7668  * which means we need to private all socket
7669  * related syscalls also with the '_' prefix.
7670  *
7671  * This is tested in Samba's 'make test',
7672  * there we noticed that providing '_read'
7673  * and '_open' would cause errors, which
7674  * means we skip '_read', '_write' and
7675  * all non socket related calls without
7676  * further analyzing the problem.
7677  */
7678 #define SWRAP_SYMBOL_ALIAS(__sym, __aliassym) \
7679         extern typeof(__sym) __aliassym __attribute__ ((alias(#__sym)))
7680
7681 #ifdef HAVE_ACCEPT4
7682 SWRAP_SYMBOL_ALIAS(accept4, _accept4);
7683 #endif
7684 SWRAP_SYMBOL_ALIAS(accept, _accept);
7685 SWRAP_SYMBOL_ALIAS(bind, _bind);
7686 SWRAP_SYMBOL_ALIAS(close, _close);
7687 SWRAP_SYMBOL_ALIAS(connect, _connect);
7688 SWRAP_SYMBOL_ALIAS(dup, _dup);
7689 SWRAP_SYMBOL_ALIAS(dup2, _dup2);
7690 SWRAP_SYMBOL_ALIAS(fcntl, _fcntl);
7691 SWRAP_SYMBOL_ALIAS(getpeername, _getpeername);
7692 SWRAP_SYMBOL_ALIAS(getsockname, _getsockname);
7693 SWRAP_SYMBOL_ALIAS(getsockopt, _getsockopt);
7694 SWRAP_SYMBOL_ALIAS(ioctl, _ioctl);
7695 SWRAP_SYMBOL_ALIAS(listen, _listen);
7696 SWRAP_SYMBOL_ALIAS(readv, _readv);
7697 SWRAP_SYMBOL_ALIAS(recv, _recv);
7698 SWRAP_SYMBOL_ALIAS(recvfrom, _recvfrom);
7699 SWRAP_SYMBOL_ALIAS(recvmsg, _recvmsg);
7700 SWRAP_SYMBOL_ALIAS(send, _send);
7701 SWRAP_SYMBOL_ALIAS(sendmsg, _sendmsg);
7702 SWRAP_SYMBOL_ALIAS(sendto, _sendto);
7703 SWRAP_SYMBOL_ALIAS(setsockopt, _setsockopt);
7704 SWRAP_SYMBOL_ALIAS(socket, _socket);
7705 SWRAP_SYMBOL_ALIAS(socketpair, _socketpair);
7706 SWRAP_SYMBOL_ALIAS(writev, _writev);
7707
7708 #endif /* SOCKET_WRAPPER_EXPORT_UNDERSCORE_SYMBOLS */