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                 int saved_errno = errno;
3646                 if (saved_errno == ENOTSOCK) {
3647                         /* Remove stale fds */
3648                         swrap_remove_stale(s);
3649                 }
3650                 errno = saved_errno;
3651                 return ret;
3652         }
3653
3654         fd = ret;
3655
3656         /* Check if we have a stale fd and remove it */
3657         swrap_remove_stale(fd);
3658
3659         ret = libc_getsockname(fd,
3660                                &un_my_addr.sa.s,
3661                                &un_my_addr.sa_socklen);
3662         if (ret == -1) {
3663                 int saved_errno = errno;
3664                 libc_close(fd);
3665                 if (saved_errno == ENOTCONN) {
3666                         /*
3667                          * If the connection is already disconnected
3668                          * we should return ECONNABORTED.
3669                          */
3670                         saved_errno = ECONNABORTED;
3671                 }
3672                 errno = saved_errno;
3673                 return ret;
3674         }
3675
3676         SWRAP_LOCK_SI(parent_si);
3677
3678         ret = sockaddr_convert_from_un(parent_si,
3679                                        &un_addr.sa.un,
3680                                        un_addr.sa_socklen,
3681                                        parent_si->family,
3682                                        &in_addr.sa.s,
3683                                        &in_addr.sa_socklen);
3684         if (ret == -1) {
3685                 int saved_errno = errno;
3686                 SWRAP_UNLOCK_SI(parent_si);
3687                 libc_close(fd);
3688                 errno = saved_errno;
3689                 return ret;
3690         }
3691
3692         child_si = &new_si;
3693
3694         child_si->family = parent_si->family;
3695         child_si->type = parent_si->type;
3696         child_si->protocol = parent_si->protocol;
3697         child_si->bound = 1;
3698         child_si->is_server = 1;
3699         child_si->connected = 1;
3700
3701         SWRAP_UNLOCK_SI(parent_si);
3702
3703         child_si->peername = (struct swrap_address) {
3704                 .sa_socklen = in_addr.sa_socklen,
3705         };
3706         memcpy(&child_si->peername.sa.ss, &in_addr.sa.ss, in_addr.sa_socklen);
3707
3708         if (addr != NULL && addrlen != NULL) {
3709                 size_t copy_len = MIN(*addrlen, in_addr.sa_socklen);
3710                 if (copy_len > 0) {
3711                         memcpy(addr, &in_addr.sa.ss, copy_len);
3712                 }
3713                 *addrlen = in_addr.sa_socklen;
3714         }
3715
3716         ret = sockaddr_convert_from_un(child_si,
3717                                        &un_my_addr.sa.un,
3718                                        un_my_addr.sa_socklen,
3719                                        child_si->family,
3720                                        &in_my_addr.sa.s,
3721                                        &in_my_addr.sa_socklen);
3722         if (ret == -1) {
3723                 int saved_errno = errno;
3724                 libc_close(fd);
3725                 errno = saved_errno;
3726                 return ret;
3727         }
3728
3729         SWRAP_LOG(SWRAP_LOG_TRACE,
3730                   "accept() path=%s, fd=%d",
3731                   un_my_addr.sa.un.sun_path, s);
3732
3733         child_si->myname = (struct swrap_address) {
3734                 .sa_socklen = in_my_addr.sa_socklen,
3735         };
3736         memcpy(&child_si->myname.sa.ss, &in_my_addr.sa.ss, in_my_addr.sa_socklen);
3737
3738         idx = swrap_create_socket(&new_si, fd);
3739         if (idx == -1) {
3740                 int saved_errno = errno;
3741                 libc_close(fd);
3742                 errno = saved_errno;
3743                 return -1;
3744         }
3745
3746         if (addr != NULL) {
3747                 struct socket_info *si = swrap_get_socket_info(idx);
3748
3749                 SWRAP_LOCK_SI(si);
3750                 swrap_pcap_dump_packet(si, addr, SWRAP_ACCEPT_SEND, NULL, 0);
3751                 swrap_pcap_dump_packet(si, addr, SWRAP_ACCEPT_RECV, NULL, 0);
3752                 swrap_pcap_dump_packet(si, addr, SWRAP_ACCEPT_ACK, NULL, 0);
3753                 SWRAP_UNLOCK_SI(si);
3754         }
3755
3756         return fd;
3757 }
3758
3759 #ifdef HAVE_ACCEPT4
3760 int accept4(int s, struct sockaddr *addr, socklen_t *addrlen, int flags)
3761 {
3762         return swrap_accept(s, addr, (socklen_t *)addrlen, flags);
3763 }
3764 #endif
3765
3766 #ifdef HAVE_ACCEPT_PSOCKLEN_T
3767 int accept(int s, struct sockaddr *addr, Psocklen_t addrlen)
3768 #else
3769 int accept(int s, struct sockaddr *addr, socklen_t *addrlen)
3770 #endif
3771 {
3772         return swrap_accept(s, addr, (socklen_t *)addrlen, 0);
3773 }
3774
3775 static int autobind_start_init;
3776 static int autobind_start;
3777
3778 /* using sendto() or connect() on an unbound socket would give the
3779    recipient no way to reply, as unlike UDP and TCP, a unix domain
3780    socket can't auto-assign ephemeral port numbers, so we need to
3781    assign it here.
3782    Note: this might change the family from ipv6 to ipv4
3783 */
3784 static int swrap_auto_bind(int fd, struct socket_info *si, int family)
3785 {
3786         struct swrap_address un_addr = {
3787                 .sa_socklen = sizeof(struct sockaddr_un),
3788         };
3789         int i;
3790         char type;
3791         int ret;
3792         int port;
3793         struct stat st;
3794         char *swrap_dir = NULL;
3795
3796         swrap_mutex_lock(&autobind_start_mutex);
3797
3798         if (autobind_start_init != 1) {
3799                 autobind_start_init = 1;
3800                 autobind_start = getpid();
3801                 autobind_start %= 50000;
3802                 autobind_start += 10000;
3803         }
3804
3805         un_addr.sa.un.sun_family = AF_UNIX;
3806
3807         switch (family) {
3808         case AF_INET: {
3809                 struct sockaddr_in in;
3810
3811                 switch (si->type) {
3812                 case SOCK_STREAM:
3813                         type = SOCKET_TYPE_CHAR_TCP;
3814                         break;
3815                 case SOCK_DGRAM:
3816                         type = SOCKET_TYPE_CHAR_UDP;
3817                         break;
3818                 default:
3819                         errno = ESOCKTNOSUPPORT;
3820                         ret = -1;
3821                         goto done;
3822                 }
3823
3824                 memset(&in, 0, sizeof(in));
3825                 in.sin_family = AF_INET;
3826                 in.sin_addr.s_addr = htonl(swrap_ipv4_iface(
3827                                            socket_wrapper_default_iface()));
3828
3829                 si->myname = (struct swrap_address) {
3830                         .sa_socklen = sizeof(in),
3831                 };
3832                 memcpy(&si->myname.sa.in, &in, si->myname.sa_socklen);
3833                 break;
3834         }
3835 #ifdef HAVE_IPV6
3836         case AF_INET6: {
3837                 struct sockaddr_in6 in6;
3838
3839                 if (si->family != family) {
3840                         errno = ENETUNREACH;
3841                         ret = -1;
3842                         goto done;
3843                 }
3844
3845                 switch (si->type) {
3846                 case SOCK_STREAM:
3847                         type = SOCKET_TYPE_CHAR_TCP_V6;
3848                         break;
3849                 case SOCK_DGRAM:
3850                         type = SOCKET_TYPE_CHAR_UDP_V6;
3851                         break;
3852                 default:
3853                         errno = ESOCKTNOSUPPORT;
3854                         ret = -1;
3855                         goto done;
3856                 }
3857
3858                 memset(&in6, 0, sizeof(in6));
3859                 in6.sin6_family = AF_INET6;
3860                 in6.sin6_addr = *swrap_ipv6();
3861                 in6.sin6_addr.s6_addr[15] = socket_wrapper_default_iface();
3862
3863                 si->myname = (struct swrap_address) {
3864                         .sa_socklen = sizeof(in6),
3865                 };
3866                 memcpy(&si->myname.sa.in6, &in6, si->myname.sa_socklen);
3867                 break;
3868         }
3869 #endif
3870         default:
3871                 errno = ESOCKTNOSUPPORT;
3872                 ret = -1;
3873                 goto done;
3874         }
3875
3876         if (autobind_start > 60000) {
3877                 autobind_start = 10000;
3878         }
3879
3880         swrap_dir = socket_wrapper_dir();
3881         if (swrap_dir == NULL) {
3882                 errno = EINVAL;
3883                 ret = -1;
3884                 goto done;
3885         }
3886
3887         for (i = 0; i < SOCKET_MAX_SOCKETS; i++) {
3888                 port = autobind_start + i;
3889                 swrap_un_path(&un_addr.sa.un,
3890                               swrap_dir,
3891                               type,
3892                               socket_wrapper_default_iface(),
3893                               port);
3894                 if (stat(un_addr.sa.un.sun_path, &st) == 0) continue;
3895
3896                 ret = libc_bind(fd, &un_addr.sa.s, un_addr.sa_socklen);
3897                 if (ret == -1) {
3898                         goto done;
3899                 }
3900
3901                 si->un_addr = un_addr.sa.un;
3902
3903                 si->bound = 1;
3904                 autobind_start = port + 1;
3905                 break;
3906         }
3907         if (i == SOCKET_MAX_SOCKETS) {
3908                 SWRAP_LOG(SWRAP_LOG_ERROR, "Too many open unix sockets (%u) for "
3909                                            "interface "SOCKET_FORMAT,
3910                                            SOCKET_MAX_SOCKETS,
3911                                            type,
3912                                            socket_wrapper_default_iface(),
3913                                            0);
3914                 errno = ENFILE;
3915                 ret = -1;
3916                 goto done;
3917         }
3918
3919         si->family = family;
3920         set_port(si->family, port, &si->myname);
3921
3922         ret = 0;
3923
3924 done:
3925         SAFE_FREE(swrap_dir);
3926         swrap_mutex_unlock(&autobind_start_mutex);
3927         return ret;
3928 }
3929
3930 /****************************************************************************
3931  *   CONNECT
3932  ***************************************************************************/
3933
3934 static int swrap_connect(int s, const struct sockaddr *serv_addr,
3935                          socklen_t addrlen)
3936 {
3937         int ret;
3938         struct swrap_address un_addr = {
3939                 .sa_socklen = sizeof(struct sockaddr_un),
3940         };
3941         struct socket_info *si = find_socket_info(s);
3942         int bcast = 0;
3943
3944         if (!si) {
3945                 return libc_connect(s, serv_addr, addrlen);
3946         }
3947
3948         SWRAP_LOCK_SI(si);
3949
3950         if (si->bound == 0) {
3951                 ret = swrap_auto_bind(s, si, serv_addr->sa_family);
3952                 if (ret == -1) {
3953                         goto done;
3954                 }
3955         }
3956
3957         if (si->family != serv_addr->sa_family) {
3958                 SWRAP_LOG(SWRAP_LOG_ERROR,
3959                           "called for fd=%d (family=%d) called with invalid family=%d",
3960                           s, si->family, serv_addr->sa_family);
3961                 errno = EINVAL;
3962                 ret = -1;
3963                 goto done;
3964         }
3965
3966         ret = sockaddr_convert_to_un(si, serv_addr,
3967                                      addrlen, &un_addr.sa.un, 0, &bcast);
3968         if (ret == -1) {
3969                 goto done;
3970         }
3971
3972         if (bcast) {
3973                 errno = ENETUNREACH;
3974                 ret = -1;
3975                 goto done;
3976         }
3977
3978         if (si->type == SOCK_DGRAM) {
3979                 si->defer_connect = 1;
3980                 ret = 0;
3981         } else {
3982                 swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_SEND, NULL, 0);
3983
3984                 ret = libc_connect(s,
3985                                    &un_addr.sa.s,
3986                                    un_addr.sa_socklen);
3987         }
3988
3989         SWRAP_LOG(SWRAP_LOG_TRACE,
3990                   "connect() path=%s, fd=%d",
3991                   un_addr.sa.un.sun_path, s);
3992
3993
3994         /* to give better errors */
3995         if (ret == -1 && errno == ENOENT) {
3996                 errno = EHOSTUNREACH;
3997         }
3998
3999         if (ret == 0) {
4000                 si->peername = (struct swrap_address) {
4001                         .sa_socklen = addrlen,
4002                 };
4003
4004                 memcpy(&si->peername.sa.ss, serv_addr, addrlen);
4005                 si->connected = 1;
4006
4007                 /*
4008                  * When we connect() on a socket than we have to bind the
4009                  * outgoing connection on the interface we use for the
4010                  * transport. We already bound it on the right interface
4011                  * but here we have to update the name so getsockname()
4012                  * returns correct information.
4013                  */
4014                 if (si->bindname.sa_socklen > 0) {
4015                         si->myname = (struct swrap_address) {
4016                                 .sa_socklen = si->bindname.sa_socklen,
4017                         };
4018
4019                         memcpy(&si->myname.sa.ss,
4020                                &si->bindname.sa.ss,
4021                                si->bindname.sa_socklen);
4022
4023                         /* Cleanup bindname */
4024                         si->bindname = (struct swrap_address) {
4025                                 .sa_socklen = 0,
4026                         };
4027                 }
4028
4029                 swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_RECV, NULL, 0);
4030                 swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_ACK, NULL, 0);
4031         } else {
4032                 swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_UNREACH, NULL, 0);
4033         }
4034
4035 done:
4036         SWRAP_UNLOCK_SI(si);
4037         return ret;
4038 }
4039
4040 int connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
4041 {
4042         return swrap_connect(s, serv_addr, addrlen);
4043 }
4044
4045 /****************************************************************************
4046  *   BIND
4047  ***************************************************************************/
4048
4049 static int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
4050 {
4051         int ret;
4052         struct swrap_address un_addr = {
4053                 .sa_socklen = sizeof(struct sockaddr_un),
4054         };
4055         struct socket_info *si = find_socket_info(s);
4056         int bind_error = 0;
4057 #if 0 /* FIXME */
4058         bool in_use;
4059 #endif
4060
4061         if (!si) {
4062                 return libc_bind(s, myaddr, addrlen);
4063         }
4064
4065         SWRAP_LOCK_SI(si);
4066
4067         switch (si->family) {
4068         case AF_INET: {
4069                 const struct sockaddr_in *sin;
4070                 if (addrlen < sizeof(struct sockaddr_in)) {
4071                         bind_error = EINVAL;
4072                         break;
4073                 }
4074
4075                 sin = (const struct sockaddr_in *)(const void *)myaddr;
4076
4077                 if (sin->sin_family != AF_INET) {
4078                         bind_error = EAFNOSUPPORT;
4079                 }
4080
4081                 /* special case for AF_UNSPEC */
4082                 if (sin->sin_family == AF_UNSPEC &&
4083                     (sin->sin_addr.s_addr == htonl(INADDR_ANY)))
4084                 {
4085                         bind_error = 0;
4086                 }
4087
4088                 break;
4089         }
4090 #ifdef HAVE_IPV6
4091         case AF_INET6: {
4092                 const struct sockaddr_in6 *sin6;
4093                 if (addrlen < sizeof(struct sockaddr_in6)) {
4094                         bind_error = EINVAL;
4095                         break;
4096                 }
4097
4098                 sin6 = (const struct sockaddr_in6 *)(const void *)myaddr;
4099
4100                 if (sin6->sin6_family != AF_INET6) {
4101                         bind_error = EAFNOSUPPORT;
4102                 }
4103
4104                 break;
4105         }
4106 #endif
4107         default:
4108                 bind_error = EINVAL;
4109                 break;
4110         }
4111
4112         if (bind_error != 0) {
4113                 errno = bind_error;
4114                 ret = -1;
4115                 goto out;
4116         }
4117
4118 #if 0 /* FIXME */
4119         in_use = check_addr_port_in_use(myaddr, addrlen);
4120         if (in_use) {
4121                 errno = EADDRINUSE;
4122                 ret = -1;
4123                 goto out;
4124         }
4125 #endif
4126
4127         si->myname.sa_socklen = addrlen;
4128         memcpy(&si->myname.sa.ss, myaddr, addrlen);
4129
4130         ret = sockaddr_convert_to_un(si,
4131                                      myaddr,
4132                                      addrlen,
4133                                      &un_addr.sa.un,
4134                                      1,
4135                                      &si->bcast);
4136         if (ret == -1) {
4137                 goto out;
4138         }
4139
4140         unlink(un_addr.sa.un.sun_path);
4141
4142         ret = libc_bind(s, &un_addr.sa.s, un_addr.sa_socklen);
4143
4144         SWRAP_LOG(SWRAP_LOG_TRACE,
4145                   "bind() path=%s, fd=%d",
4146                   un_addr.sa.un.sun_path, s);
4147
4148         if (ret == 0) {
4149                 si->bound = 1;
4150         }
4151
4152 out:
4153         SWRAP_UNLOCK_SI(si);
4154
4155         return ret;
4156 }
4157
4158 int bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
4159 {
4160         return swrap_bind(s, myaddr, addrlen);
4161 }
4162
4163 /****************************************************************************
4164  *   BINDRESVPORT
4165  ***************************************************************************/
4166
4167 #ifdef HAVE_BINDRESVPORT
4168 static int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen);
4169
4170 static int swrap_bindresvport_sa(int sd, struct sockaddr *sa)
4171 {
4172         struct swrap_address myaddr = {
4173                 .sa_socklen = sizeof(struct sockaddr_storage),
4174         };
4175         socklen_t salen;
4176         static uint16_t port;
4177         uint16_t i;
4178         int rc = -1;
4179         int af;
4180
4181 #define SWRAP_STARTPORT 600
4182 #define SWRAP_ENDPORT (IPPORT_RESERVED - 1)
4183 #define SWRAP_NPORTS (SWRAP_ENDPORT - SWRAP_STARTPORT + 1)
4184
4185         if (port == 0) {
4186                 port = (getpid() % SWRAP_NPORTS) + SWRAP_STARTPORT;
4187         }
4188
4189         if (sa == NULL) {
4190                 salen = myaddr.sa_socklen;
4191                 sa = &myaddr.sa.s;
4192
4193                 rc = swrap_getsockname(sd, &myaddr.sa.s, &salen);
4194                 if (rc < 0) {
4195                         return -1;
4196                 }
4197
4198                 af = sa->sa_family;
4199                 memset(&myaddr.sa.ss, 0, salen);
4200         } else {
4201                 af = sa->sa_family;
4202         }
4203
4204         for (i = 0; i < SWRAP_NPORTS; i++, port++) {
4205                 switch(af) {
4206                 case AF_INET: {
4207                         struct sockaddr_in *sinp = (struct sockaddr_in *)(void *)sa;
4208
4209                         salen = sizeof(struct sockaddr_in);
4210                         sinp->sin_port = htons(port);
4211                         break;
4212                 }
4213                 case AF_INET6: {
4214                         struct sockaddr_in6 *sin6p = (struct sockaddr_in6 *)(void *)sa;
4215
4216                         salen = sizeof(struct sockaddr_in6);
4217                         sin6p->sin6_port = htons(port);
4218                         break;
4219                 }
4220                 default:
4221                         errno = EAFNOSUPPORT;
4222                         return -1;
4223                 }
4224                 sa->sa_family = af;
4225
4226                 if (port > SWRAP_ENDPORT) {
4227                         port = SWRAP_STARTPORT;
4228                 }
4229
4230                 rc = swrap_bind(sd, (struct sockaddr *)sa, salen);
4231                 if (rc == 0 || errno != EADDRINUSE) {
4232                         break;
4233                 }
4234         }
4235
4236         return rc;
4237 }
4238
4239 int bindresvport(int sockfd, struct sockaddr_in *sinp)
4240 {
4241         return swrap_bindresvport_sa(sockfd, (struct sockaddr *)sinp);
4242 }
4243 #endif
4244
4245 /****************************************************************************
4246  *   LISTEN
4247  ***************************************************************************/
4248
4249 static int swrap_listen(int s, int backlog)
4250 {
4251         int ret;
4252         struct socket_info *si = find_socket_info(s);
4253
4254         if (!si) {
4255                 return libc_listen(s, backlog);
4256         }
4257
4258         SWRAP_LOCK_SI(si);
4259
4260         if (si->bound == 0) {
4261                 ret = swrap_auto_bind(s, si, si->family);
4262                 if (ret == -1) {
4263                         errno = EADDRINUSE;
4264                         goto out;
4265                 }
4266         }
4267
4268         ret = libc_listen(s, backlog);
4269         if (ret == 0) {
4270                 si->listening = 1;
4271         }
4272
4273 out:
4274         SWRAP_UNLOCK_SI(si);
4275
4276         return ret;
4277 }
4278
4279 int listen(int s, int backlog)
4280 {
4281         return swrap_listen(s, backlog);
4282 }
4283
4284 /****************************************************************************
4285  *   FOPEN
4286  ***************************************************************************/
4287
4288 static FILE *swrap_fopen(const char *name, const char *mode)
4289 {
4290         FILE *fp;
4291
4292         fp = libc_fopen(name, mode);
4293         if (fp != NULL) {
4294                 int fd = fileno(fp);
4295
4296                 swrap_remove_stale(fd);
4297         }
4298
4299         return fp;
4300 }
4301
4302 FILE *fopen(const char *name, const char *mode)
4303 {
4304         return swrap_fopen(name, mode);
4305 }
4306
4307 /****************************************************************************
4308  *   FOPEN64
4309  ***************************************************************************/
4310
4311 #ifdef HAVE_FOPEN64
4312 static FILE *swrap_fopen64(const char *name, const char *mode)
4313 {
4314         FILE *fp;
4315
4316         fp = libc_fopen64(name, mode);
4317         if (fp != NULL) {
4318                 int fd = fileno(fp);
4319
4320                 swrap_remove_stale(fd);
4321         }
4322
4323         return fp;
4324 }
4325
4326 FILE *fopen64(const char *name, const char *mode)
4327 {
4328         return swrap_fopen64(name, mode);
4329 }
4330 #endif /* HAVE_FOPEN64 */
4331
4332 /****************************************************************************
4333  *   OPEN
4334  ***************************************************************************/
4335
4336 static int swrap_vopen(const char *pathname, int flags, va_list ap)
4337 {
4338         int ret;
4339
4340         ret = libc_vopen(pathname, flags, ap);
4341         if (ret != -1) {
4342                 /*
4343                  * There are methods for closing descriptors (libc-internal code
4344                  * paths, direct syscalls) which close descriptors in ways that
4345                  * we can't intercept, so try to recover when we notice that
4346                  * that's happened
4347                  */
4348                 swrap_remove_stale(ret);
4349         }
4350         return ret;
4351 }
4352
4353 int open(const char *pathname, int flags, ...)
4354 {
4355         va_list ap;
4356         int fd;
4357
4358         va_start(ap, flags);
4359         fd = swrap_vopen(pathname, flags, ap);
4360         va_end(ap);
4361
4362         return fd;
4363 }
4364
4365 /****************************************************************************
4366  *   OPEN64
4367  ***************************************************************************/
4368
4369 #ifdef HAVE_OPEN64
4370 static int swrap_vopen64(const char *pathname, int flags, va_list ap)
4371 {
4372         int ret;
4373
4374         ret = libc_vopen64(pathname, flags, ap);
4375         if (ret != -1) {
4376                 /*
4377                  * There are methods for closing descriptors (libc-internal code
4378                  * paths, direct syscalls) which close descriptors in ways that
4379                  * we can't intercept, so try to recover when we notice that
4380                  * that's happened
4381                  */
4382                 swrap_remove_stale(ret);
4383         }
4384         return ret;
4385 }
4386
4387 int open64(const char *pathname, int flags, ...)
4388 {
4389         va_list ap;
4390         int fd;
4391
4392         va_start(ap, flags);
4393         fd = swrap_vopen64(pathname, flags, ap);
4394         va_end(ap);
4395
4396         return fd;
4397 }
4398 #endif /* HAVE_OPEN64 */
4399
4400 /****************************************************************************
4401  *   OPENAT
4402  ***************************************************************************/
4403
4404 static int swrap_vopenat(int dirfd, const char *path, int flags, va_list ap)
4405 {
4406         int ret;
4407
4408         ret = libc_vopenat(dirfd, path, flags, ap);
4409         if (ret != -1) {
4410                 /*
4411                  * There are methods for closing descriptors (libc-internal code
4412                  * paths, direct syscalls) which close descriptors in ways that
4413                  * we can't intercept, so try to recover when we notice that
4414                  * that's happened
4415                  */
4416                 swrap_remove_stale(ret);
4417         }
4418
4419         return ret;
4420 }
4421
4422 int openat(int dirfd, const char *path, int flags, ...)
4423 {
4424         va_list ap;
4425         int fd;
4426
4427         va_start(ap, flags);
4428         fd = swrap_vopenat(dirfd, path, flags, ap);
4429         va_end(ap);
4430
4431         return fd;
4432 }
4433
4434 /****************************************************************************
4435  *   GETPEERNAME
4436  ***************************************************************************/
4437
4438 static int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
4439 {
4440         struct socket_info *si = find_socket_info(s);
4441         socklen_t len;
4442         int ret = -1;
4443
4444         if (!si) {
4445                 return libc_getpeername(s, name, addrlen);
4446         }
4447
4448         SWRAP_LOCK_SI(si);
4449
4450         if (si->peername.sa_socklen == 0)
4451         {
4452                 errno = ENOTCONN;
4453                 goto out;
4454         }
4455
4456         len = MIN(*addrlen, si->peername.sa_socklen);
4457         if (len == 0) {
4458                 ret = 0;
4459                 goto out;
4460         }
4461
4462         memcpy(name, &si->peername.sa.ss, len);
4463         *addrlen = si->peername.sa_socklen;
4464
4465         ret = 0;
4466 out:
4467         SWRAP_UNLOCK_SI(si);
4468
4469         return ret;
4470 }
4471
4472 #ifdef HAVE_ACCEPT_PSOCKLEN_T
4473 int getpeername(int s, struct sockaddr *name, Psocklen_t addrlen)
4474 #else
4475 int getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
4476 #endif
4477 {
4478         return swrap_getpeername(s, name, (socklen_t *)addrlen);
4479 }
4480
4481 /****************************************************************************
4482  *   GETSOCKNAME
4483  ***************************************************************************/
4484
4485 static int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
4486 {
4487         struct socket_info *si = find_socket_info(s);
4488         socklen_t len;
4489         int ret = -1;
4490
4491         if (!si) {
4492                 return libc_getsockname(s, name, addrlen);
4493         }
4494
4495         SWRAP_LOCK_SI(si);
4496
4497         len = MIN(*addrlen, si->myname.sa_socklen);
4498         if (len == 0) {
4499                 ret = 0;
4500                 goto out;
4501         }
4502
4503         memcpy(name, &si->myname.sa.ss, len);
4504         *addrlen = si->myname.sa_socklen;
4505
4506         ret = 0;
4507 out:
4508         SWRAP_UNLOCK_SI(si);
4509
4510         return ret;
4511 }
4512
4513 #ifdef HAVE_ACCEPT_PSOCKLEN_T
4514 int getsockname(int s, struct sockaddr *name, Psocklen_t addrlen)
4515 #else
4516 int getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
4517 #endif
4518 {
4519         return swrap_getsockname(s, name, (socklen_t *)addrlen);
4520 }
4521
4522 /****************************************************************************
4523  *   GETSOCKOPT
4524  ***************************************************************************/
4525
4526 #ifndef SO_PROTOCOL
4527 # ifdef SO_PROTOTYPE /* The Solaris name */
4528 #  define SO_PROTOCOL SO_PROTOTYPE
4529 # endif /* SO_PROTOTYPE */
4530 #endif /* SO_PROTOCOL */
4531
4532 static int swrap_getsockopt(int s, int level, int optname,
4533                             void *optval, socklen_t *optlen)
4534 {
4535         struct socket_info *si = find_socket_info(s);
4536         int ret;
4537
4538         if (!si) {
4539                 return libc_getsockopt(s,
4540                                        level,
4541                                        optname,
4542                                        optval,
4543                                        optlen);
4544         }
4545
4546         SWRAP_LOCK_SI(si);
4547
4548         if (level == SOL_SOCKET) {
4549                 switch (optname) {
4550 #ifdef SO_DOMAIN
4551                 case SO_DOMAIN:
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->family;
4561                         ret = 0;
4562                         goto done;
4563 #endif /* SO_DOMAIN */
4564
4565 #ifdef SO_PROTOCOL
4566                 case SO_PROTOCOL:
4567                         if (optval == NULL || optlen == NULL ||
4568                             *optlen < (socklen_t)sizeof(int)) {
4569                                 errno = EINVAL;
4570                                 ret = -1;
4571                                 goto done;
4572                         }
4573
4574                         *optlen = sizeof(int);
4575                         *(int *)optval = si->protocol;
4576                         ret = 0;
4577                         goto done;
4578 #endif /* SO_PROTOCOL */
4579                 case SO_TYPE:
4580                         if (optval == NULL || optlen == NULL ||
4581                             *optlen < (socklen_t)sizeof(int)) {
4582                                 errno = EINVAL;
4583                                 ret = -1;
4584                                 goto done;
4585                         }
4586
4587                         *optlen = sizeof(int);
4588                         *(int *)optval = si->type;
4589                         ret = 0;
4590                         goto done;
4591                 default:
4592                         ret = libc_getsockopt(s,
4593                                               level,
4594                                               optname,
4595                                               optval,
4596                                               optlen);
4597                         goto done;
4598                 }
4599         } else if (level == IPPROTO_TCP) {
4600                 switch (optname) {
4601 #ifdef TCP_NODELAY
4602                 case TCP_NODELAY:
4603                         /*
4604                          * This enables sending packets directly out over TCP.
4605                          * As a unix socket is doing that any way, report it as
4606                          * enabled.
4607                          */
4608                         if (optval == NULL || optlen == NULL ||
4609                             *optlen < (socklen_t)sizeof(int)) {
4610                                 errno = EINVAL;
4611                                 ret = -1;
4612                                 goto done;
4613                         }
4614
4615                         *optlen = sizeof(int);
4616                         *(int *)optval = si->tcp_nodelay;
4617
4618                         ret = 0;
4619                         goto done;
4620 #endif /* TCP_NODELAY */
4621 #ifdef TCP_INFO
4622                 case TCP_INFO: {
4623                         struct tcp_info info;
4624                         socklen_t ilen = sizeof(info);
4625
4626 #ifdef HAVE_NETINET_TCP_FSM_H
4627 /* This is FreeBSD */
4628 # define __TCP_LISTEN TCPS_LISTEN
4629 # define __TCP_ESTABLISHED TCPS_ESTABLISHED
4630 # define __TCP_CLOSE TCPS_CLOSED
4631 #else
4632 /* This is Linux */
4633 # define __TCP_LISTEN TCP_LISTEN
4634 # define __TCP_ESTABLISHED TCP_ESTABLISHED
4635 # define __TCP_CLOSE TCP_CLOSE
4636 #endif
4637
4638                         ZERO_STRUCT(info);
4639                         if (si->listening) {
4640                                 info.tcpi_state = __TCP_LISTEN;
4641                         } else if (si->connected) {
4642                                 /*
4643                                  * For now we just fake a few values
4644                                  * supported both by FreeBSD and Linux
4645                                  */
4646                                 info.tcpi_state = __TCP_ESTABLISHED;
4647                                 info.tcpi_rto = 200000;  /* 200 msec */
4648                                 info.tcpi_rtt = 5000;    /* 5 msec */
4649                                 info.tcpi_rttvar = 5000; /* 5 msec */
4650                         } else {
4651                                 info.tcpi_state = __TCP_CLOSE;
4652                                 info.tcpi_rto = 1000000;  /* 1 sec */
4653                                 info.tcpi_rtt = 0;
4654                                 info.tcpi_rttvar = 250000; /* 250 msec */
4655                         }
4656
4657                         if (optval == NULL || optlen == NULL ||
4658                             *optlen < (socklen_t)ilen) {
4659                                 errno = EINVAL;
4660                                 ret = -1;
4661                                 goto done;
4662                         }
4663
4664                         *optlen = ilen;
4665                         memcpy(optval, &info, ilen);
4666
4667                         ret = 0;
4668                         goto done;
4669                 }
4670 #endif /* TCP_INFO */
4671                 default:
4672                         break;
4673                 }
4674         }
4675
4676         errno = ENOPROTOOPT;
4677         ret = -1;
4678
4679 done:
4680         SWRAP_UNLOCK_SI(si);
4681         return ret;
4682 }
4683
4684 #ifdef HAVE_ACCEPT_PSOCKLEN_T
4685 int getsockopt(int s, int level, int optname, void *optval, Psocklen_t optlen)
4686 #else
4687 int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
4688 #endif
4689 {
4690         return swrap_getsockopt(s, level, optname, optval, (socklen_t *)optlen);
4691 }
4692
4693 /****************************************************************************
4694  *   SETSOCKOPT
4695  ***************************************************************************/
4696
4697 static int swrap_setsockopt(int s, int level, int optname,
4698                             const void *optval, socklen_t optlen)
4699 {
4700         struct socket_info *si = find_socket_info(s);
4701         int ret;
4702
4703         if (!si) {
4704                 return libc_setsockopt(s,
4705                                        level,
4706                                        optname,
4707                                        optval,
4708                                        optlen);
4709         }
4710
4711         if (level == SOL_SOCKET) {
4712                 return libc_setsockopt(s,
4713                                        level,
4714                                        optname,
4715                                        optval,
4716                                        optlen);
4717         }
4718
4719         SWRAP_LOCK_SI(si);
4720
4721         if (level == IPPROTO_TCP) {
4722                 switch (optname) {
4723 #ifdef TCP_NODELAY
4724                 case TCP_NODELAY: {
4725                         int i;
4726
4727                         /*
4728                          * This enables sending packets directly out over TCP.
4729                          * A unix socket is doing that any way.
4730                          */
4731                         if (optval == NULL || optlen == 0 ||
4732                             optlen < (socklen_t)sizeof(int)) {
4733                                 errno = EINVAL;
4734                                 ret = -1;
4735                                 goto done;
4736                         }
4737
4738                         i = *discard_const_p(int, optval);
4739                         if (i != 0 && i != 1) {
4740                                 errno = EINVAL;
4741                                 ret = -1;
4742                                 goto done;
4743                         }
4744                         si->tcp_nodelay = i;
4745
4746                         ret = 0;
4747                         goto done;
4748                 }
4749 #endif /* TCP_NODELAY */
4750                 default:
4751                         break;
4752                 }
4753         }
4754
4755         switch (si->family) {
4756         case AF_INET:
4757                 if (level == IPPROTO_IP) {
4758 #ifdef IP_PKTINFO
4759                         if (optname == IP_PKTINFO) {
4760                                 si->pktinfo = AF_INET;
4761                         }
4762 #endif /* IP_PKTINFO */
4763                 }
4764                 ret = 0;
4765                 goto done;
4766 #ifdef HAVE_IPV6
4767         case AF_INET6:
4768                 if (level == IPPROTO_IPV6) {
4769 #ifdef IPV6_RECVPKTINFO
4770                         if (optname == IPV6_RECVPKTINFO) {
4771                                 si->pktinfo = AF_INET6;
4772                         }
4773 #endif /* IPV6_PKTINFO */
4774                 }
4775                 ret = 0;
4776                 goto done;
4777 #endif
4778         default:
4779                 errno = ENOPROTOOPT;
4780                 ret = -1;
4781                 goto done;
4782         }
4783
4784 done:
4785         SWRAP_UNLOCK_SI(si);
4786         return ret;
4787 }
4788
4789 int setsockopt(int s, int level, int optname,
4790                const void *optval, socklen_t optlen)
4791 {
4792         return swrap_setsockopt(s, level, optname, optval, optlen);
4793 }
4794
4795 /****************************************************************************
4796  *   IOCTL
4797  ***************************************************************************/
4798
4799 static int swrap_vioctl(int s, unsigned long int r, va_list va)
4800 {
4801         struct socket_info *si = find_socket_info(s);
4802         va_list ap;
4803         int *value_ptr = NULL;
4804         int rc;
4805
4806         if (!si) {
4807                 return libc_vioctl(s, r, va);
4808         }
4809
4810         SWRAP_LOCK_SI(si);
4811
4812         va_copy(ap, va);
4813
4814         rc = libc_vioctl(s, r, va);
4815
4816         switch (r) {
4817         case FIONREAD:
4818                 if (rc == 0) {
4819                         value_ptr = ((int *)va_arg(ap, int *));
4820                 }
4821
4822                 if (rc == -1 && errno != EAGAIN && errno != ENOBUFS) {
4823                         swrap_pcap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
4824                 } else if (value_ptr != NULL && *value_ptr == 0) { /* END OF FILE */
4825                         swrap_pcap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
4826                 }
4827                 break;
4828 #ifdef FIONWRITE
4829         case FIONWRITE:
4830                 /* this is FreeBSD */
4831                 FALL_THROUGH; /* to TIOCOUTQ */
4832 #endif /* FIONWRITE */
4833         case TIOCOUTQ: /* same as SIOCOUTQ on Linux */
4834                 /*
4835                  * This may return more bytes then the application
4836                  * sent into the socket, for tcp it should
4837                  * return the number of unacked bytes.
4838                  *
4839                  * On AF_UNIX, all bytes are immediately acked!
4840                  */
4841                 if (rc == 0) {
4842                         value_ptr = ((int *)va_arg(ap, int *));
4843                         *value_ptr = 0;
4844                 }
4845                 break;
4846         }
4847
4848         va_end(ap);
4849
4850         SWRAP_UNLOCK_SI(si);
4851         return rc;
4852 }
4853
4854 #ifdef HAVE_IOCTL_INT
4855 int ioctl(int s, int r, ...)
4856 #else
4857 int ioctl(int s, unsigned long int r, ...)
4858 #endif
4859 {
4860         va_list va;
4861         int rc;
4862
4863         va_start(va, r);
4864
4865         rc = swrap_vioctl(s, (unsigned long int) r, va);
4866
4867         va_end(va);
4868
4869         return rc;
4870 }
4871
4872 /*****************
4873  * CMSG
4874  *****************/
4875
4876 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
4877
4878 #ifndef CMSG_ALIGN
4879 # ifdef _ALIGN /* BSD */
4880 #define CMSG_ALIGN _ALIGN
4881 # else
4882 #define CMSG_ALIGN(len) (((len) + sizeof(size_t) - 1) & ~(sizeof(size_t) - 1))
4883 # endif /* _ALIGN */
4884 #endif /* CMSG_ALIGN */
4885
4886 /**
4887  * @brief Add a cmsghdr to a msghdr.
4888  *
4889  * This is an function to add any type of cmsghdr. It will operate on the
4890  * msg->msg_control and msg->msg_controllen you pass in by adapting them to
4891  * the buffer position after the added cmsg element. Hence, this function is
4892  * intended to be used with an intermediate msghdr and not on the original
4893  * one handed in by the client.
4894  *
4895  * @param[in]  msg      The msghdr to which to add the cmsg.
4896  *
4897  * @param[in]  level    The cmsg level to set.
4898  *
4899  * @param[in]  type     The cmsg type to set.
4900  *
4901  * @param[in]  data     The cmsg data to set.
4902  *
4903  * @param[in]  len      the length of the data to set.
4904  */
4905 static void swrap_msghdr_add_cmsghdr(struct msghdr *msg,
4906                                      int level,
4907                                      int type,
4908                                      const void *data,
4909                                      size_t len)
4910 {
4911         size_t cmlen = CMSG_LEN(len);
4912         size_t cmspace = CMSG_SPACE(len);
4913         uint8_t cmbuf[cmspace];
4914         void *cast_ptr = (void *)cmbuf;
4915         struct cmsghdr *cm = (struct cmsghdr *)cast_ptr;
4916         uint8_t *p;
4917
4918         memset(cmbuf, 0, cmspace);
4919
4920         if (msg->msg_controllen < cmlen) {
4921                 cmlen = msg->msg_controllen;
4922                 msg->msg_flags |= MSG_CTRUNC;
4923         }
4924
4925         if (msg->msg_controllen < cmspace) {
4926                 cmspace = msg->msg_controllen;
4927         }
4928
4929         /*
4930          * We copy the full input data into an intermediate cmsghdr first
4931          * in order to more easily cope with truncation.
4932          */
4933         cm->cmsg_len = cmlen;
4934         cm->cmsg_level = level;
4935         cm->cmsg_type = type;
4936         memcpy(CMSG_DATA(cm), data, len);
4937
4938         /*
4939          * We now copy the possibly truncated buffer.
4940          * We copy cmlen bytes, but consume cmspace bytes,
4941          * leaving the possible padding uninitialiazed.
4942          */
4943         p = (uint8_t *)msg->msg_control;
4944         memcpy(p, cm, cmlen);
4945         p += cmspace;
4946         msg->msg_control = p;
4947         msg->msg_controllen -= cmspace;
4948
4949         return;
4950 }
4951
4952 static int swrap_msghdr_add_pktinfo(struct socket_info *si,
4953                                     struct msghdr *msg)
4954 {
4955         /* Add packet info */
4956         switch (si->pktinfo) {
4957 #if defined(IP_PKTINFO) && (defined(HAVE_STRUCT_IN_PKTINFO) || defined(IP_RECVDSTADDR))
4958         case AF_INET: {
4959                 struct sockaddr_in *sin;
4960 #if defined(HAVE_STRUCT_IN_PKTINFO)
4961                 struct in_pktinfo pkt;
4962 #elif defined(IP_RECVDSTADDR)
4963                 struct in_addr pkt;
4964 #endif
4965
4966                 if (si->bindname.sa_socklen == sizeof(struct sockaddr_in)) {
4967                         sin = &si->bindname.sa.in;
4968                 } else {
4969                         if (si->myname.sa_socklen != sizeof(struct sockaddr_in)) {
4970                                 return 0;
4971                         }
4972                         sin = &si->myname.sa.in;
4973                 }
4974
4975                 ZERO_STRUCT(pkt);
4976
4977 #if defined(HAVE_STRUCT_IN_PKTINFO)
4978                 pkt.ipi_ifindex = socket_wrapper_default_iface();
4979                 pkt.ipi_addr.s_addr = sin->sin_addr.s_addr;
4980 #elif defined(IP_RECVDSTADDR)
4981                 pkt = sin->sin_addr;
4982 #endif
4983
4984                 swrap_msghdr_add_cmsghdr(msg, IPPROTO_IP, IP_PKTINFO,
4985                                          &pkt, sizeof(pkt));
4986
4987                 break;
4988         }
4989 #endif /* IP_PKTINFO */
4990 #if defined(HAVE_IPV6)
4991         case AF_INET6: {
4992 #if defined(IPV6_PKTINFO) && defined(HAVE_STRUCT_IN6_PKTINFO)
4993                 struct sockaddr_in6 *sin6;
4994                 struct in6_pktinfo pkt6;
4995
4996                 if (si->bindname.sa_socklen == sizeof(struct sockaddr_in6)) {
4997                         sin6 = &si->bindname.sa.in6;
4998                 } else {
4999                         if (si->myname.sa_socklen != sizeof(struct sockaddr_in6)) {
5000                                 return 0;
5001                         }
5002                         sin6 = &si->myname.sa.in6;
5003                 }
5004
5005                 ZERO_STRUCT(pkt6);
5006
5007                 pkt6.ipi6_ifindex = socket_wrapper_default_iface();
5008                 pkt6.ipi6_addr = sin6->sin6_addr;
5009
5010                 swrap_msghdr_add_cmsghdr(msg, IPPROTO_IPV6, IPV6_PKTINFO,
5011                                         &pkt6, sizeof(pkt6));
5012 #endif /* HAVE_STRUCT_IN6_PKTINFO */
5013
5014                 break;
5015         }
5016 #endif /* IPV6_PKTINFO */
5017         default:
5018                 return -1;
5019         }
5020
5021         return 0;
5022 }
5023
5024 static int swrap_msghdr_add_socket_info(struct socket_info *si,
5025                                         struct msghdr *omsg)
5026 {
5027         int rc = 0;
5028
5029         if (si->pktinfo > 0) {
5030                 rc = swrap_msghdr_add_pktinfo(si, omsg);
5031         }
5032
5033         return rc;
5034 }
5035
5036 static int swrap_sendmsg_copy_cmsg(const struct cmsghdr *cmsg,
5037                                    uint8_t **cm_data,
5038                                    size_t *cm_data_space);
5039 static int swrap_sendmsg_filter_cmsg_ipproto_ip(const struct cmsghdr *cmsg,
5040                                                 uint8_t **cm_data,
5041                                                 size_t *cm_data_space);
5042 static int swrap_sendmsg_filter_cmsg_sol_socket(const struct cmsghdr *cmsg,
5043                                                 uint8_t **cm_data,
5044                                                 size_t *cm_data_space);
5045
5046 static int swrap_sendmsg_filter_cmsghdr(const struct msghdr *_msg,
5047                                         uint8_t **cm_data,
5048                                         size_t *cm_data_space)
5049 {
5050         struct msghdr *msg = discard_const_p(struct msghdr, _msg);
5051         struct cmsghdr *cmsg;
5052         int rc = -1;
5053
5054         /* Nothing to do */
5055         if (msg->msg_controllen == 0 || msg->msg_control == NULL) {
5056                 return 0;
5057         }
5058
5059         for (cmsg = CMSG_FIRSTHDR(msg);
5060              cmsg != NULL;
5061              cmsg = CMSG_NXTHDR(msg, cmsg)) {
5062                 switch (cmsg->cmsg_level) {
5063                 case IPPROTO_IP:
5064                         rc = swrap_sendmsg_filter_cmsg_ipproto_ip(cmsg,
5065                                                                   cm_data,
5066                                                                   cm_data_space);
5067                         break;
5068                 case SOL_SOCKET:
5069                         rc = swrap_sendmsg_filter_cmsg_sol_socket(cmsg,
5070                                                                   cm_data,
5071                                                                   cm_data_space);
5072                         break;
5073                 default:
5074                         rc = swrap_sendmsg_copy_cmsg(cmsg,
5075                                                      cm_data,
5076                                                      cm_data_space);
5077                         break;
5078                 }
5079                 if (rc < 0) {
5080                         int saved_errno = errno;
5081                         SAFE_FREE(*cm_data);
5082                         *cm_data_space = 0;
5083                         errno = saved_errno;
5084                         return rc;
5085                 }
5086         }
5087
5088         return rc;
5089 }
5090
5091 static int swrap_sendmsg_copy_cmsg(const struct cmsghdr *cmsg,
5092                                    uint8_t **cm_data,
5093                                    size_t *cm_data_space)
5094 {
5095         size_t cmspace;
5096         uint8_t *p;
5097
5098         cmspace = *cm_data_space + CMSG_ALIGN(cmsg->cmsg_len);
5099
5100         p = realloc((*cm_data), cmspace);
5101         if (p == NULL) {
5102                 return -1;
5103         }
5104         (*cm_data) = p;
5105
5106         p = (*cm_data) + (*cm_data_space);
5107         *cm_data_space = cmspace;
5108
5109         memcpy(p, cmsg, cmsg->cmsg_len);
5110
5111         return 0;
5112 }
5113
5114 static int swrap_sendmsg_filter_cmsg_pktinfo(const struct cmsghdr *cmsg,
5115                                             uint8_t **cm_data,
5116                                             size_t *cm_data_space);
5117
5118
5119 static int swrap_sendmsg_filter_cmsg_ipproto_ip(const struct cmsghdr *cmsg,
5120                                                 uint8_t **cm_data,
5121                                                 size_t *cm_data_space)
5122 {
5123         int rc = -1;
5124
5125         switch(cmsg->cmsg_type) {
5126 #ifdef IP_PKTINFO
5127         case IP_PKTINFO:
5128                 rc = swrap_sendmsg_filter_cmsg_pktinfo(cmsg,
5129                                                        cm_data,
5130                                                        cm_data_space);
5131                 break;
5132 #endif
5133 #ifdef IPV6_PKTINFO
5134         case IPV6_PKTINFO:
5135                 rc = swrap_sendmsg_filter_cmsg_pktinfo(cmsg,
5136                                                        cm_data,
5137                                                        cm_data_space);
5138                 break;
5139 #endif
5140         default:
5141                 break;
5142         }
5143
5144         return rc;
5145 }
5146
5147 static int swrap_sendmsg_filter_cmsg_pktinfo(const struct cmsghdr *cmsg,
5148                                              uint8_t **cm_data,
5149                                              size_t *cm_data_space)
5150 {
5151         (void)cmsg; /* unused */
5152         (void)cm_data; /* unused */
5153         (void)cm_data_space; /* unused */
5154
5155         /*
5156          * Passing a IP pktinfo to a unix socket might be rejected by the
5157          * Kernel, at least on FreeBSD. So skip this cmsg.
5158          */
5159         return 0;
5160 }
5161
5162 static int swrap_sendmsg_filter_cmsg_sol_socket(const struct cmsghdr *cmsg,
5163                                                 uint8_t **cm_data,
5164                                                 size_t *cm_data_space)
5165 {
5166         int rc = -1;
5167
5168         switch (cmsg->cmsg_type) {
5169         case SCM_RIGHTS:
5170                 SWRAP_LOG(SWRAP_LOG_TRACE,
5171                           "Ignoring SCM_RIGHTS on inet socket!");
5172                 rc = 0;
5173                 break;
5174 #ifdef SCM_CREDENTIALS
5175         case SCM_CREDENTIALS:
5176                 SWRAP_LOG(SWRAP_LOG_TRACE,
5177                           "Ignoring SCM_CREDENTIALS on inet socket!");
5178                 rc = 0;
5179                 break;
5180 #endif /* SCM_CREDENTIALS */
5181         default:
5182                 rc = swrap_sendmsg_copy_cmsg(cmsg,
5183                                              cm_data,
5184                                              cm_data_space);
5185                 break;
5186         }
5187
5188         return rc;
5189 }
5190
5191 static const uint64_t swrap_unix_scm_right_magic = 0x8e0e13f27c42fc36;
5192
5193 /*
5194  * We only allow up to 6 fds at a time
5195  * as that's more than enough for Samba
5196  * and it means we can keep the logic simple
5197  * and work with fixed size arrays.
5198  *
5199  * We also keep sizeof(struct swrap_unix_scm_rights)
5200  * under PIPE_BUF (4096) in order to allow a non-blocking
5201  * write into the pipe.
5202  */
5203 #ifndef PIPE_BUF
5204 #define PIPE_BUF 4096
5205 #endif
5206 #define SWRAP_MAX_PASSED_FDS ((size_t)6)
5207 #define SWRAP_MAX_PASSED_SOCKET_INFO SWRAP_MAX_PASSED_FDS
5208 struct swrap_unix_scm_rights_payload {
5209         uint8_t num_idxs;
5210         int8_t idxs[SWRAP_MAX_PASSED_FDS];
5211         struct socket_info infos[SWRAP_MAX_PASSED_SOCKET_INFO];
5212 };
5213 struct swrap_unix_scm_rights {
5214         uint64_t magic;
5215         char package_name[sizeof(SOCKET_WRAPPER_PACKAGE)];
5216         char package_version[sizeof(SOCKET_WRAPPER_VERSION)];
5217         uint32_t full_size;
5218         uint32_t payload_size;
5219         struct swrap_unix_scm_rights_payload payload;
5220 };
5221
5222 static void swrap_dec_fd_passed_array(size_t num, struct socket_info **array)
5223 {
5224         int saved_errno = errno;
5225         size_t i;
5226
5227         for (i = 0; i < num; i++) {
5228                 struct socket_info *si = array[i];
5229                 if (si == NULL) {
5230                         continue;
5231                 }
5232
5233                 SWRAP_LOCK_SI(si);
5234                 swrap_dec_refcount(si);
5235                 if (si->fd_passed > 0) {
5236                         si->fd_passed -= 1;
5237                 }
5238                 SWRAP_UNLOCK_SI(si);
5239                 array[i] = NULL;
5240         }
5241
5242         errno = saved_errno;
5243 }
5244
5245 static void swrap_undo_si_idx_array(size_t num, int *array)
5246 {
5247         int saved_errno = errno;
5248         size_t i;
5249
5250         swrap_mutex_lock(&first_free_mutex);
5251
5252         for (i = 0; i < num; i++) {
5253                 struct socket_info *si = NULL;
5254
5255                 if (array[i] == -1) {
5256                         continue;
5257                 }
5258
5259                 si = swrap_get_socket_info(array[i]);
5260                 if (si == NULL) {
5261                         continue;
5262                 }
5263
5264                 SWRAP_LOCK_SI(si);
5265                 swrap_dec_refcount(si);
5266                 SWRAP_UNLOCK_SI(si);
5267
5268                 swrap_set_next_free(si, first_free);
5269                 first_free = array[i];
5270                 array[i] = -1;
5271         }
5272
5273         swrap_mutex_unlock(&first_free_mutex);
5274         errno = saved_errno;
5275 }
5276
5277 static void swrap_close_fd_array(size_t num, const int *array)
5278 {
5279         int saved_errno = errno;
5280         size_t i;
5281
5282         for (i = 0; i < num; i++) {
5283                 if (array[i] == -1) {
5284                         continue;
5285                 }
5286                 libc_close(array[i]);
5287         }
5288
5289         errno = saved_errno;
5290 }
5291
5292 union __swrap_fds {
5293         const uint8_t *p;
5294         int *fds;
5295 };
5296
5297 union __swrap_cmsghdr {
5298         const uint8_t *p;
5299         struct cmsghdr *cmsg;
5300 };
5301
5302 static int swrap_sendmsg_unix_scm_rights(const struct cmsghdr *cmsg,
5303                                          uint8_t **cm_data,
5304                                          size_t *cm_data_space,
5305                                          int *scm_rights_pipe_fd)
5306 {
5307         struct swrap_unix_scm_rights info;
5308         struct swrap_unix_scm_rights_payload *payload = NULL;
5309         int si_idx_array[SWRAP_MAX_PASSED_FDS];
5310         struct socket_info *si_array[SWRAP_MAX_PASSED_FDS] = { NULL, };
5311         size_t info_idx = 0;
5312         size_t size_fds_in;
5313         size_t num_fds_in;
5314         union __swrap_fds __fds_in = { .p = NULL, };
5315         const int *fds_in = NULL;
5316         size_t num_fds_out;
5317         size_t size_fds_out;
5318         union __swrap_fds __fds_out = { .p = NULL, };
5319         int *fds_out = NULL;
5320         size_t cmsg_len;
5321         size_t cmsg_space;
5322         size_t new_cm_data_space;
5323         union __swrap_cmsghdr __new_cmsg = { .p = NULL, };
5324         struct cmsghdr *new_cmsg = NULL;
5325         uint8_t *p = NULL;
5326         size_t i;
5327         int pipefd[2] = { -1, -1 };
5328         int rc;
5329         ssize_t sret;
5330
5331         /*
5332          * We pass this a buffer to the kernel make sure any padding
5333          * is also cleared.
5334          */
5335         ZERO_STRUCT(info);
5336         info.magic = swrap_unix_scm_right_magic;
5337         memcpy(info.package_name,
5338                SOCKET_WRAPPER_PACKAGE,
5339                sizeof(info.package_name));
5340         memcpy(info.package_version,
5341                SOCKET_WRAPPER_VERSION,
5342                sizeof(info.package_version));
5343         info.full_size = sizeof(info);
5344         info.payload_size = sizeof(info.payload);
5345         payload = &info.payload;
5346
5347         if (*scm_rights_pipe_fd != -1) {
5348                 SWRAP_LOG(SWRAP_LOG_ERROR,
5349                           "Two SCM_RIGHTS headers are not supported by socket_wrapper");
5350                 errno = EINVAL;
5351                 return -1;
5352         }
5353
5354         if (cmsg->cmsg_len < CMSG_LEN(0)) {
5355                 SWRAP_LOG(SWRAP_LOG_ERROR,
5356                           "cmsg->cmsg_len=%zu < CMSG_LEN(0)=%zu",
5357                           (size_t)cmsg->cmsg_len,
5358                           CMSG_LEN(0));
5359                 errno = EINVAL;
5360                 return -1;
5361         }
5362         size_fds_in = cmsg->cmsg_len - CMSG_LEN(0);
5363         if ((size_fds_in % sizeof(int)) != 0) {
5364                 SWRAP_LOG(SWRAP_LOG_ERROR,
5365                           "cmsg->cmsg_len=%zu => (size_fds_in=%zu %% sizeof(int)=%zu) != 0",
5366                           (size_t)cmsg->cmsg_len,
5367                           size_fds_in,
5368                           sizeof(int));
5369                 errno = EINVAL;
5370                 return -1;
5371         }
5372         num_fds_in = size_fds_in / sizeof(int);
5373         if (num_fds_in > SWRAP_MAX_PASSED_FDS) {
5374                 SWRAP_LOG(SWRAP_LOG_ERROR,
5375                           "cmsg->cmsg_len=%zu,size_fds_in=%zu => "
5376                           "num_fds_in=%zu > "
5377                           "SWRAP_MAX_PASSED_FDS(%zu)",
5378                           (size_t)cmsg->cmsg_len,
5379                           size_fds_in,
5380                           num_fds_in,
5381                           SWRAP_MAX_PASSED_FDS);
5382                 errno = EINVAL;
5383                 return -1;
5384         }
5385         if (num_fds_in == 0) {
5386                 SWRAP_LOG(SWRAP_LOG_ERROR,
5387                           "cmsg->cmsg_len=%zu,size_fds_in=%zu => "
5388                           "num_fds_in=%zu",
5389                           (size_t)cmsg->cmsg_len,
5390                           size_fds_in,
5391                           num_fds_in);
5392                 errno = EINVAL;
5393                 return -1;
5394         }
5395         __fds_in.p = CMSG_DATA(cmsg);
5396         fds_in = __fds_in.fds;
5397         num_fds_out = num_fds_in + 1;
5398
5399         SWRAP_LOG(SWRAP_LOG_TRACE,
5400                   "num_fds_in=%zu num_fds_out=%zu",
5401                   num_fds_in, num_fds_out);
5402
5403         size_fds_out = sizeof(int) * num_fds_out;
5404         cmsg_len = CMSG_LEN(size_fds_out);
5405         cmsg_space = CMSG_SPACE(size_fds_out);
5406
5407         new_cm_data_space = *cm_data_space + cmsg_space;
5408
5409         p = realloc((*cm_data), new_cm_data_space);
5410         if (p == NULL) {
5411                 return -1;
5412         }
5413         (*cm_data) = p;
5414         p = (*cm_data) + (*cm_data_space);
5415         memset(p, 0, cmsg_space);
5416         __new_cmsg.p = p;
5417         new_cmsg = __new_cmsg.cmsg;
5418         *new_cmsg = *cmsg;
5419         __fds_out.p = CMSG_DATA(new_cmsg);
5420         fds_out = __fds_out.fds;
5421         memcpy(fds_out, fds_in, size_fds_out);
5422         new_cmsg->cmsg_len = cmsg->cmsg_len;
5423
5424         for (i = 0; i < num_fds_in; i++) {
5425                 size_t j;
5426
5427                 payload->idxs[i] = -1;
5428                 payload->num_idxs++;
5429
5430                 si_idx_array[i] = find_socket_info_index(fds_in[i]);
5431                 if (si_idx_array[i] == -1) {
5432                         continue;
5433                 }
5434
5435                 si_array[i] = swrap_get_socket_info(si_idx_array[i]);
5436                 if (si_array[i] == NULL) {
5437                         SWRAP_LOG(SWRAP_LOG_ERROR,
5438                                   "fds_in[%zu]=%d si_idx_array[%zu]=%d missing!",
5439                                   i, fds_in[i], i, si_idx_array[i]);
5440                         errno = EINVAL;
5441                         return -1;
5442                 }
5443
5444                 for (j = 0; j < i; j++) {
5445                         if (si_array[j] == si_array[i]) {
5446                                 payload->idxs[i] = payload->idxs[j];
5447                                 break;
5448                         }
5449                 }
5450                 if (payload->idxs[i] == -1) {
5451                         if (info_idx >= SWRAP_MAX_PASSED_SOCKET_INFO) {
5452                                 SWRAP_LOG(SWRAP_LOG_ERROR,
5453                                           "fds_in[%zu]=%d,si_idx_array[%zu]=%d: "
5454                                           "info_idx=%zu >= SWRAP_MAX_PASSED_FDS(%zu)!",
5455                                           i, fds_in[i], i, si_idx_array[i],
5456                                           info_idx,
5457                                           SWRAP_MAX_PASSED_SOCKET_INFO);
5458                                 errno = EINVAL;
5459                                 return -1;
5460                         }
5461                         payload->idxs[i] = info_idx;
5462                         info_idx += 1;
5463                         continue;
5464                 }
5465         }
5466
5467         for (i = 0; i < num_fds_in; i++) {
5468                 struct socket_info *si = si_array[i];
5469
5470                 if (si == NULL) {
5471                         SWRAP_LOG(SWRAP_LOG_TRACE,
5472                                   "fds_in[%zu]=%d not an inet socket",
5473                                   i, fds_in[i]);
5474                         continue;
5475                 }
5476
5477                 SWRAP_LOG(SWRAP_LOG_TRACE,
5478                           "fds_in[%zu]=%d si_idx_array[%zu]=%d "
5479                           "passing as info.idxs[%zu]=%d!",
5480                           i, fds_in[i],
5481                           i, si_idx_array[i],
5482                           i, payload->idxs[i]);
5483
5484                 SWRAP_LOCK_SI(si);
5485                 si->fd_passed += 1;
5486                 payload->infos[payload->idxs[i]] = *si;
5487                 payload->infos[payload->idxs[i]].fd_passed = 0;
5488                 SWRAP_UNLOCK_SI(si);
5489         }
5490
5491         rc = pipe(pipefd);
5492         if (rc == -1) {
5493                 int saved_errno = errno;
5494                 SWRAP_LOG(SWRAP_LOG_ERROR,
5495                           "pipe() failed - %d %s",
5496                           saved_errno,
5497                           strerror(saved_errno));
5498                 swrap_dec_fd_passed_array(num_fds_in, si_array);
5499                 errno = saved_errno;
5500                 return -1;
5501         }
5502
5503         sret = write(pipefd[1], &info, sizeof(info));
5504         if (sret != sizeof(info)) {
5505                 int saved_errno = errno;
5506                 if (sret != -1) {
5507                         saved_errno = EINVAL;
5508                 }
5509                 SWRAP_LOG(SWRAP_LOG_ERROR,
5510                           "write() failed - sret=%zd - %d %s",
5511                           sret, saved_errno,
5512                           strerror(saved_errno));
5513                 swrap_dec_fd_passed_array(num_fds_in, si_array);
5514                 libc_close(pipefd[1]);
5515                 libc_close(pipefd[0]);
5516                 errno = saved_errno;
5517                 return -1;
5518         }
5519         libc_close(pipefd[1]);
5520
5521         /*
5522          * Add the pipe read end to the end of the passed fd array
5523          */
5524         fds_out[num_fds_in] = pipefd[0];
5525         new_cmsg->cmsg_len = cmsg_len;
5526
5527         /* we're done ... */
5528         *scm_rights_pipe_fd = pipefd[0];
5529         *cm_data_space = new_cm_data_space;
5530
5531         return 0;
5532 }
5533
5534 static int swrap_sendmsg_unix_sol_socket(const struct cmsghdr *cmsg,
5535                                          uint8_t **cm_data,
5536                                          size_t *cm_data_space,
5537                                          int *scm_rights_pipe_fd)
5538 {
5539         int rc = -1;
5540
5541         switch (cmsg->cmsg_type) {
5542         case SCM_RIGHTS:
5543                 rc = swrap_sendmsg_unix_scm_rights(cmsg,
5544                                                    cm_data,
5545                                                    cm_data_space,
5546                                                    scm_rights_pipe_fd);
5547                 break;
5548         default:
5549                 rc = swrap_sendmsg_copy_cmsg(cmsg,
5550                                              cm_data,
5551                                              cm_data_space);
5552                 break;
5553         }
5554
5555         return rc;
5556 }
5557
5558 static int swrap_recvmsg_unix_scm_rights(const struct cmsghdr *cmsg,
5559                                          uint8_t **cm_data,
5560                                          size_t *cm_data_space)
5561 {
5562         int scm_rights_pipe_fd = -1;
5563         struct swrap_unix_scm_rights info;
5564         struct swrap_unix_scm_rights_payload *payload = NULL;
5565         int si_idx_array[SWRAP_MAX_PASSED_FDS];
5566         size_t size_fds_in;
5567         size_t num_fds_in;
5568         union __swrap_fds __fds_in = { .p = NULL, };
5569         const int *fds_in = NULL;
5570         size_t num_fds_out;
5571         size_t size_fds_out;
5572         union __swrap_fds __fds_out = { .p = NULL, };
5573         int *fds_out = NULL;
5574         size_t cmsg_len;
5575         size_t cmsg_space;
5576         size_t new_cm_data_space;
5577         union __swrap_cmsghdr __new_cmsg = { .p = NULL, };
5578         struct cmsghdr *new_cmsg = NULL;
5579         uint8_t *p = NULL;
5580         ssize_t sret;
5581         size_t i;
5582         int cmp;
5583
5584         if (cmsg->cmsg_len < CMSG_LEN(0)) {
5585                 SWRAP_LOG(SWRAP_LOG_ERROR,
5586                           "cmsg->cmsg_len=%zu < CMSG_LEN(0)=%zu",
5587                           (size_t)cmsg->cmsg_len,
5588                           CMSG_LEN(0));
5589                 errno = EINVAL;
5590                 return -1;
5591         }
5592         size_fds_in = cmsg->cmsg_len - CMSG_LEN(0);
5593         if ((size_fds_in % sizeof(int)) != 0) {
5594                 SWRAP_LOG(SWRAP_LOG_ERROR,
5595                           "cmsg->cmsg_len=%zu => (size_fds_in=%zu %% sizeof(int)=%zu) != 0",
5596                           (size_t)cmsg->cmsg_len,
5597                           size_fds_in,
5598                           sizeof(int));
5599                 errno = EINVAL;
5600                 return -1;
5601         }
5602         num_fds_in = size_fds_in / sizeof(int);
5603         if (num_fds_in > (SWRAP_MAX_PASSED_FDS + 1)) {
5604                 SWRAP_LOG(SWRAP_LOG_ERROR,
5605                           "cmsg->cmsg_len=%zu,size_fds_in=%zu => "
5606                           "num_fds_in=%zu > SWRAP_MAX_PASSED_FDS+1(%zu)",
5607                           (size_t)cmsg->cmsg_len,
5608                           size_fds_in,
5609                           num_fds_in,
5610                           SWRAP_MAX_PASSED_FDS+1);
5611                 errno = EINVAL;
5612                 return -1;
5613         }
5614         if (num_fds_in <= 1) {
5615                 SWRAP_LOG(SWRAP_LOG_ERROR,
5616                           "cmsg->cmsg_len=%zu,size_fds_in=%zu => "
5617                           "num_fds_in=%zu",
5618                           (size_t)cmsg->cmsg_len,
5619                           size_fds_in,
5620                           num_fds_in);
5621                 errno = EINVAL;
5622                 return -1;
5623         }
5624         __fds_in.p = CMSG_DATA(cmsg);
5625         fds_in = __fds_in.fds;
5626         num_fds_out = num_fds_in - 1;
5627
5628         SWRAP_LOG(SWRAP_LOG_TRACE,
5629                   "num_fds_in=%zu num_fds_out=%zu",
5630                   num_fds_in, num_fds_out);
5631
5632         for (i = 0; i < num_fds_in; i++) {
5633                 /* Check if we have a stale fd and remove it */
5634                 swrap_remove_stale(fds_in[i]);
5635         }
5636
5637         scm_rights_pipe_fd = fds_in[num_fds_out];
5638         size_fds_out = sizeof(int) * num_fds_out;
5639         cmsg_len = CMSG_LEN(size_fds_out);
5640         cmsg_space = CMSG_SPACE(size_fds_out);
5641
5642         new_cm_data_space = *cm_data_space + cmsg_space;
5643
5644         p = realloc((*cm_data), new_cm_data_space);
5645         if (p == NULL) {
5646                 swrap_close_fd_array(num_fds_in, fds_in);
5647                 return -1;
5648         }
5649         (*cm_data) = p;
5650         p = (*cm_data) + (*cm_data_space);
5651         memset(p, 0, cmsg_space);
5652         __new_cmsg.p = p;
5653         new_cmsg = __new_cmsg.cmsg;
5654         *new_cmsg = *cmsg;
5655         __fds_out.p = CMSG_DATA(new_cmsg);
5656         fds_out = __fds_out.fds;
5657         memcpy(fds_out, fds_in, size_fds_out);
5658         new_cmsg->cmsg_len = cmsg_len;
5659
5660         sret = read(scm_rights_pipe_fd, &info, sizeof(info));
5661         if (sret != sizeof(info)) {
5662                 int saved_errno = errno;
5663                 if (sret != -1) {
5664                         saved_errno = EINVAL;
5665                 }
5666                 SWRAP_LOG(SWRAP_LOG_ERROR,
5667                           "read() failed - sret=%zd - %d %s",
5668                           sret, saved_errno,
5669                           strerror(saved_errno));
5670                 swrap_close_fd_array(num_fds_in, fds_in);
5671                 errno = saved_errno;
5672                 return -1;
5673         }
5674         libc_close(scm_rights_pipe_fd);
5675         payload = &info.payload;
5676
5677         if (info.magic != swrap_unix_scm_right_magic) {
5678                 SWRAP_LOG(SWRAP_LOG_ERROR,
5679                           "info.magic=0x%llx != swrap_unix_scm_right_magic=0x%llx",
5680                           (unsigned long long)info.magic,
5681                           (unsigned long long)swrap_unix_scm_right_magic);
5682                 swrap_close_fd_array(num_fds_out, fds_out);
5683                 errno = EINVAL;
5684                 return -1;
5685         }
5686
5687         cmp = memcmp(info.package_name,
5688                      SOCKET_WRAPPER_PACKAGE,
5689                      sizeof(info.package_name));
5690         if (cmp != 0) {
5691                 SWRAP_LOG(SWRAP_LOG_ERROR,
5692                           "info.package_name='%.*s' != '%s'",
5693                           (int)sizeof(info.package_name),
5694                           info.package_name,
5695                           SOCKET_WRAPPER_PACKAGE);
5696                 swrap_close_fd_array(num_fds_out, fds_out);
5697                 errno = EINVAL;
5698                 return -1;
5699         }
5700
5701         cmp = memcmp(info.package_version,
5702                      SOCKET_WRAPPER_VERSION,
5703                      sizeof(info.package_version));
5704         if (cmp != 0) {
5705                 SWRAP_LOG(SWRAP_LOG_ERROR,
5706                           "info.package_version='%.*s' != '%s'",
5707                           (int)sizeof(info.package_version),
5708                           info.package_version,
5709                           SOCKET_WRAPPER_VERSION);
5710                 swrap_close_fd_array(num_fds_out, fds_out);
5711                 errno = EINVAL;
5712                 return -1;
5713         }
5714
5715         if (info.full_size != sizeof(info)) {
5716                 SWRAP_LOG(SWRAP_LOG_ERROR,
5717                           "info.full_size=%zu != sizeof(info)=%zu",
5718                           (size_t)info.full_size,
5719                           sizeof(info));
5720                 swrap_close_fd_array(num_fds_out, fds_out);
5721                 errno = EINVAL;
5722                 return -1;
5723         }
5724
5725         if (info.payload_size != sizeof(info.payload)) {
5726                 SWRAP_LOG(SWRAP_LOG_ERROR,
5727                           "info.payload_size=%zu != sizeof(info.payload)=%zu",
5728                           (size_t)info.payload_size,
5729                           sizeof(info.payload));
5730                 swrap_close_fd_array(num_fds_out, fds_out);
5731                 errno = EINVAL;
5732                 return -1;
5733         }
5734
5735         if (payload->num_idxs != num_fds_out) {
5736                 SWRAP_LOG(SWRAP_LOG_ERROR,
5737                           "info.num_idxs=%u != num_fds_out=%zu",
5738                           payload->num_idxs, num_fds_out);
5739                 swrap_close_fd_array(num_fds_out, fds_out);
5740                 errno = EINVAL;
5741                 return -1;
5742         }
5743
5744         for (i = 0; i < num_fds_out; i++) {
5745                 size_t j;
5746
5747                 si_idx_array[i] = -1;
5748
5749                 if (payload->idxs[i] == -1) {
5750                         SWRAP_LOG(SWRAP_LOG_TRACE,
5751                                   "fds_out[%zu]=%d not an inet socket",
5752                                   i, fds_out[i]);
5753                         continue;
5754                 }
5755
5756                 if (payload->idxs[i] < 0) {
5757                         SWRAP_LOG(SWRAP_LOG_ERROR,
5758                                   "fds_out[%zu]=%d info.idxs[%zu]=%d < 0!",
5759                                   i, fds_out[i], i, payload->idxs[i]);
5760                         swrap_close_fd_array(num_fds_out, fds_out);
5761                         errno = EINVAL;
5762                         return -1;
5763                 }
5764
5765                 if (payload->idxs[i] >= payload->num_idxs) {
5766                         SWRAP_LOG(SWRAP_LOG_ERROR,
5767                                   "fds_out[%zu]=%d info.idxs[%zu]=%d >= %u!",
5768                                   i, fds_out[i], i, payload->idxs[i],
5769                                   payload->num_idxs);
5770                         swrap_close_fd_array(num_fds_out, fds_out);
5771                         errno = EINVAL;
5772                         return -1;
5773                 }
5774
5775                 if ((size_t)fds_out[i] >= socket_fds_max) {
5776                         SWRAP_LOG(SWRAP_LOG_ERROR,
5777                                   "The max socket index limit of %zu has been reached, "
5778                                   "trying to add %d",
5779                                   socket_fds_max,
5780                                   fds_out[i]);
5781                         swrap_close_fd_array(num_fds_out, fds_out);
5782                         errno = EMFILE;
5783                         return -1;
5784                 }
5785
5786                 SWRAP_LOG(SWRAP_LOG_TRACE,
5787                           "fds_in[%zu]=%d "
5788                           "received as info.idxs[%zu]=%d!",
5789                           i, fds_out[i],
5790                           i, payload->idxs[i]);
5791
5792                 for (j = 0; j < i; j++) {
5793                         if (payload->idxs[j] == -1) {
5794                                 continue;
5795                         }
5796                         if (payload->idxs[j] == payload->idxs[i]) {
5797                                 si_idx_array[i] = si_idx_array[j];
5798                         }
5799                 }
5800                 if (si_idx_array[i] == -1) {
5801                         const struct socket_info *si = &payload->infos[payload->idxs[i]];
5802
5803                         si_idx_array[i] = swrap_add_socket_info(si);
5804                         if (si_idx_array[i] == -1) {
5805                                 int saved_errno = errno;
5806                                 SWRAP_LOG(SWRAP_LOG_ERROR,
5807                                           "The max socket index limit of %zu has been reached, "
5808                                           "trying to add %d",
5809                                           socket_fds_max,
5810                                           fds_out[i]);
5811                                 swrap_undo_si_idx_array(i, si_idx_array);
5812                                 swrap_close_fd_array(num_fds_out, fds_out);
5813                                 errno = saved_errno;
5814                                 return -1;
5815                         }
5816                         SWRAP_LOG(SWRAP_LOG_TRACE,
5817                                   "Imported %s socket for protocol %s, fd=%d",
5818                                   si->family == AF_INET ? "IPv4" : "IPv6",
5819                                   si->type == SOCK_DGRAM ? "UDP" : "TCP",
5820                                   fds_out[i]);
5821                 }
5822         }
5823
5824         for (i = 0; i < num_fds_out; i++) {
5825                 if (si_idx_array[i] == -1) {
5826                         continue;
5827                 }
5828                 set_socket_info_index(fds_out[i], si_idx_array[i]);
5829         }
5830
5831         /* we're done ... */
5832         *cm_data_space = new_cm_data_space;
5833
5834         return 0;
5835 }
5836
5837 static int swrap_recvmsg_unix_sol_socket(const struct cmsghdr *cmsg,
5838                                          uint8_t **cm_data,
5839                                          size_t *cm_data_space)
5840 {
5841         int rc = -1;
5842
5843         switch (cmsg->cmsg_type) {
5844         case SCM_RIGHTS:
5845                 rc = swrap_recvmsg_unix_scm_rights(cmsg,
5846                                                    cm_data,
5847                                                    cm_data_space);
5848                 break;
5849         default:
5850                 rc = swrap_sendmsg_copy_cmsg(cmsg,
5851                                              cm_data,
5852                                              cm_data_space);
5853                 break;
5854         }
5855
5856         return rc;
5857 }
5858
5859 #endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL */
5860
5861 static int swrap_sendmsg_before_unix(const struct msghdr *_msg_in,
5862                                      struct msghdr *msg_tmp,
5863                                      int *scm_rights_pipe_fd)
5864 {
5865 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
5866         struct msghdr *msg_in = discard_const_p(struct msghdr, _msg_in);
5867         struct cmsghdr *cmsg = NULL;
5868         uint8_t *cm_data = NULL;
5869         size_t cm_data_space = 0;
5870         int rc = -1;
5871
5872         *msg_tmp = *msg_in;
5873         *scm_rights_pipe_fd = -1;
5874
5875         /* Nothing to do */
5876         if (msg_in->msg_controllen == 0 || msg_in->msg_control == NULL) {
5877                 return 0;
5878         }
5879
5880         for (cmsg = CMSG_FIRSTHDR(msg_in);
5881              cmsg != NULL;
5882              cmsg = CMSG_NXTHDR(msg_in, cmsg)) {
5883                 switch (cmsg->cmsg_level) {
5884                 case SOL_SOCKET:
5885                         rc = swrap_sendmsg_unix_sol_socket(cmsg,
5886                                                            &cm_data,
5887                                                            &cm_data_space,
5888                                                            scm_rights_pipe_fd);
5889                         break;
5890
5891                 default:
5892                         rc = swrap_sendmsg_copy_cmsg(cmsg,
5893                                                      &cm_data,
5894                                                      &cm_data_space);
5895                         break;
5896                 }
5897                 if (rc < 0) {
5898                         int saved_errno = errno;
5899                         SAFE_FREE(cm_data);
5900                         errno = saved_errno;
5901                         return rc;
5902                 }
5903         }
5904
5905         msg_tmp->msg_controllen = cm_data_space;
5906         msg_tmp->msg_control = cm_data;
5907
5908         return 0;
5909 #else /* HAVE_STRUCT_MSGHDR_MSG_CONTROL */
5910         *msg_tmp = *_msg_in;
5911         return 0;
5912 #endif /* ! HAVE_STRUCT_MSGHDR_MSG_CONTROL */
5913 }
5914
5915 static ssize_t swrap_sendmsg_after_unix(struct msghdr *msg_tmp,
5916                                         ssize_t ret,
5917                                         int scm_rights_pipe_fd)
5918 {
5919 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
5920         int saved_errno = errno;
5921         SAFE_FREE(msg_tmp->msg_control);
5922         if (scm_rights_pipe_fd != -1) {
5923                 libc_close(scm_rights_pipe_fd);
5924         }
5925         errno = saved_errno;
5926 #endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL */
5927         return ret;
5928 }
5929
5930 static int swrap_recvmsg_before_unix(struct msghdr *msg_in,
5931                                      struct msghdr *msg_tmp)
5932 {
5933         *msg_tmp = *msg_in;
5934         return 0;
5935 }
5936
5937 static ssize_t swrap_recvmsg_after_unix(struct msghdr *msg_tmp,
5938                                         struct msghdr *msg_out,
5939                                         ssize_t ret)
5940 {
5941 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
5942         struct cmsghdr *cmsg = NULL;
5943         uint8_t *cm_data = NULL;
5944         size_t cm_data_space = 0;
5945         int rc = -1;
5946
5947         /* Nothing to do */
5948         if (msg_tmp->msg_controllen == 0 || msg_tmp->msg_control == NULL) {
5949                 goto done;
5950         }
5951
5952         for (cmsg = CMSG_FIRSTHDR(msg_tmp);
5953              cmsg != NULL;
5954              cmsg = CMSG_NXTHDR(msg_tmp, cmsg)) {
5955                 switch (cmsg->cmsg_level) {
5956                 case SOL_SOCKET:
5957                         rc = swrap_recvmsg_unix_sol_socket(cmsg,
5958                                                            &cm_data,
5959                                                            &cm_data_space);
5960                         break;
5961
5962                 default:
5963                         rc = swrap_sendmsg_copy_cmsg(cmsg,
5964                                                      &cm_data,
5965                                                      &cm_data_space);
5966                         break;
5967                 }
5968                 if (rc < 0) {
5969                         int saved_errno = errno;
5970                         SAFE_FREE(cm_data);
5971                         errno = saved_errno;
5972                         return rc;
5973                 }
5974         }
5975
5976         /*
5977          * msg_tmp->msg_control is still the buffer of the caller.
5978          */
5979         memcpy(msg_tmp->msg_control, cm_data, cm_data_space);
5980         msg_tmp->msg_controllen = cm_data_space;
5981         SAFE_FREE(cm_data);
5982 done:
5983 #endif /* ! HAVE_STRUCT_MSGHDR_MSG_CONTROL */
5984         *msg_out = *msg_tmp;
5985         return ret;
5986 }
5987
5988 static ssize_t swrap_sendmsg_before(int fd,
5989                                     struct socket_info *si,
5990                                     struct msghdr *msg,
5991                                     struct iovec *tmp_iov,
5992                                     struct sockaddr_un *tmp_un,
5993                                     const struct sockaddr_un **to_un,
5994                                     const struct sockaddr **to,
5995                                     int *bcast)
5996 {
5997         size_t i, len = 0;
5998         ssize_t ret = -1;
5999
6000         if (to_un) {
6001                 *to_un = NULL;
6002         }
6003         if (to) {
6004                 *to = NULL;
6005         }
6006         if (bcast) {
6007                 *bcast = 0;
6008         }
6009
6010         SWRAP_LOCK_SI(si);
6011
6012         switch (si->type) {
6013         case SOCK_STREAM: {
6014                 unsigned long mtu;
6015
6016                 if (!si->connected) {
6017                         errno = ENOTCONN;
6018                         goto out;
6019                 }
6020
6021                 if (msg->msg_iovlen == 0) {
6022                         break;
6023                 }
6024
6025                 mtu = socket_wrapper_mtu();
6026                 for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6027                         size_t nlen;
6028                         nlen = len + msg->msg_iov[i].iov_len;
6029                         if (nlen < len) {
6030                                 /* overflow */
6031                                 errno = EMSGSIZE;
6032                                 goto out;
6033                         }
6034                         if (nlen > mtu) {
6035                                 break;
6036                         }
6037                 }
6038                 msg->msg_iovlen = i;
6039                 if (msg->msg_iovlen == 0) {
6040                         *tmp_iov = msg->msg_iov[0];
6041                         tmp_iov->iov_len = MIN((size_t)tmp_iov->iov_len,
6042                                                (size_t)mtu);
6043                         msg->msg_iov = tmp_iov;
6044                         msg->msg_iovlen = 1;
6045                 }
6046                 break;
6047         }
6048         case SOCK_DGRAM:
6049                 if (si->connected) {
6050                         if (msg->msg_name != NULL) {
6051                                 /*
6052                                  * We are dealing with unix sockets and if we
6053                                  * are connected, we should only talk to the
6054                                  * connected unix path. Using the fd to send
6055                                  * to another server would be hard to achieve.
6056                                  */
6057                                 msg->msg_name = NULL;
6058                                 msg->msg_namelen = 0;
6059                         }
6060                 } else {
6061                         const struct sockaddr *msg_name;
6062                         msg_name = (const struct sockaddr *)msg->msg_name;
6063
6064                         if (msg_name == NULL) {
6065                                 errno = ENOTCONN;
6066                                 goto out;
6067                         }
6068
6069
6070                         ret = sockaddr_convert_to_un(si, msg_name, msg->msg_namelen,
6071                                                      tmp_un, 0, bcast);
6072                         if (ret == -1) {
6073                                 goto out;
6074                         }
6075
6076                         if (to_un) {
6077                                 *to_un = tmp_un;
6078                         }
6079                         if (to) {
6080                                 *to = msg_name;
6081                         }
6082                         msg->msg_name = tmp_un;
6083                         msg->msg_namelen = sizeof(*tmp_un);
6084                 }
6085
6086                 if (si->bound == 0) {
6087                         ret = swrap_auto_bind(fd, si, si->family);
6088                         if (ret == -1) {
6089                                 SWRAP_UNLOCK_SI(si);
6090                                 if (errno == ENOTSOCK) {
6091                                         swrap_remove_stale(fd);
6092                                         ret = -ENOTSOCK;
6093                                 } else {
6094                                         SWRAP_LOG(SWRAP_LOG_ERROR, "swrap_sendmsg_before failed");
6095                                 }
6096                                 return ret;
6097                         }
6098                 }
6099
6100                 if (!si->defer_connect) {
6101                         break;
6102                 }
6103
6104                 ret = sockaddr_convert_to_un(si,
6105                                              &si->peername.sa.s,
6106                                              si->peername.sa_socklen,
6107                                              tmp_un,
6108                                              0,
6109                                              NULL);
6110                 if (ret == -1) {
6111                         goto out;
6112                 }
6113
6114                 ret = libc_connect(fd,
6115                                    (struct sockaddr *)(void *)tmp_un,
6116                                    sizeof(*tmp_un));
6117
6118                 /* to give better errors */
6119                 if (ret == -1 && errno == ENOENT) {
6120                         errno = EHOSTUNREACH;
6121                 }
6122
6123                 if (ret == -1) {
6124                         goto out;
6125                 }
6126
6127                 si->defer_connect = 0;
6128                 break;
6129         default:
6130                 errno = EHOSTUNREACH;
6131                 goto out;
6132         }
6133
6134         ret = 0;
6135 out:
6136         SWRAP_UNLOCK_SI(si);
6137
6138         return ret;
6139 }
6140
6141 static void swrap_sendmsg_after(int fd,
6142                                 struct socket_info *si,
6143                                 struct msghdr *msg,
6144                                 const struct sockaddr *to,
6145                                 ssize_t ret)
6146 {
6147         int saved_errno = errno;
6148         size_t i, len = 0;
6149         uint8_t *buf;
6150         off_t ofs = 0;
6151         size_t avail = 0;
6152         size_t remain;
6153
6154         /* to give better errors */
6155         if (ret == -1) {
6156                 if (saved_errno == ENOENT) {
6157                         saved_errno = EHOSTUNREACH;
6158                 } else if (saved_errno == ENOTSOCK) {
6159                         /* If the fd is not a socket, remove it */
6160                         swrap_remove_stale(fd);
6161                 }
6162         }
6163
6164         for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6165                 avail += msg->msg_iov[i].iov_len;
6166         }
6167
6168         if (ret == -1) {
6169                 remain = MIN(80, avail);
6170         } else {
6171                 remain = ret;
6172         }
6173
6174         /* we capture it as one single packet */
6175         buf = (uint8_t *)malloc(remain);
6176         if (!buf) {
6177                 /* we just not capture the packet */
6178                 errno = saved_errno;
6179                 return;
6180         }
6181
6182         for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6183                 size_t this_time = MIN(remain, (size_t)msg->msg_iov[i].iov_len);
6184                 memcpy(buf + ofs,
6185                        msg->msg_iov[i].iov_base,
6186                        this_time);
6187                 ofs += this_time;
6188                 remain -= this_time;
6189         }
6190         len = ofs;
6191
6192         SWRAP_LOCK_SI(si);
6193
6194         switch (si->type) {
6195         case SOCK_STREAM:
6196                 if (ret == -1) {
6197                         swrap_pcap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
6198                         swrap_pcap_dump_packet(si, NULL, SWRAP_SEND_RST, NULL, 0);
6199                 } else {
6200                         swrap_pcap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
6201                 }
6202                 break;
6203
6204         case SOCK_DGRAM:
6205                 if (si->connected) {
6206                         to = &si->peername.sa.s;
6207                 }
6208                 if (ret == -1) {
6209                         swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
6210                         swrap_pcap_dump_packet(si, to, SWRAP_SENDTO_UNREACH, buf, len);
6211                 } else {
6212                         swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
6213                 }
6214                 break;
6215         }
6216
6217         SWRAP_UNLOCK_SI(si);
6218
6219         free(buf);
6220         errno = saved_errno;
6221 }
6222
6223 static int swrap_recvmsg_before(int fd,
6224                                 struct socket_info *si,
6225                                 struct msghdr *msg,
6226                                 struct iovec *tmp_iov)
6227 {
6228         size_t i, len = 0;
6229         int ret = -1;
6230
6231         SWRAP_LOCK_SI(si);
6232
6233         (void)fd; /* unused */
6234
6235         switch (si->type) {
6236         case SOCK_STREAM: {
6237                 unsigned int mtu;
6238                 if (!si->connected) {
6239                         errno = ENOTCONN;
6240                         goto out;
6241                 }
6242
6243                 if (msg->msg_iovlen == 0) {
6244                         break;
6245                 }
6246
6247                 mtu = socket_wrapper_mtu();
6248                 for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6249                         size_t nlen;
6250                         nlen = len + msg->msg_iov[i].iov_len;
6251                         if (nlen > mtu) {
6252                                 break;
6253                         }
6254                 }
6255                 msg->msg_iovlen = i;
6256                 if (msg->msg_iovlen == 0) {
6257                         *tmp_iov = msg->msg_iov[0];
6258                         tmp_iov->iov_len = MIN((size_t)tmp_iov->iov_len,
6259                                                (size_t)mtu);
6260                         msg->msg_iov = tmp_iov;
6261                         msg->msg_iovlen = 1;
6262                 }
6263                 break;
6264         }
6265         case SOCK_DGRAM:
6266                 if (msg->msg_name == NULL) {
6267                         errno = EINVAL;
6268                         goto out;
6269                 }
6270
6271                 if (msg->msg_iovlen == 0) {
6272                         break;
6273                 }
6274
6275                 if (si->bound == 0) {
6276                         ret = swrap_auto_bind(fd, si, si->family);
6277                         if (ret == -1) {
6278                                 SWRAP_UNLOCK_SI(si);
6279                                 /*
6280                                  * When attempting to read or write to a
6281                                  * descriptor, if an underlying autobind fails
6282                                  * because it's not a socket, stop intercepting
6283                                  * uses of that descriptor.
6284                                  */
6285                                 if (errno == ENOTSOCK) {
6286                                         swrap_remove_stale(fd);
6287                                         ret = -ENOTSOCK;
6288                                 } else {
6289                                         SWRAP_LOG(SWRAP_LOG_ERROR,
6290                                                   "swrap_recvmsg_before failed");
6291                                 }
6292                                 return ret;
6293                         }
6294                 }
6295                 break;
6296         default:
6297                 errno = EHOSTUNREACH;
6298                 goto out;
6299         }
6300
6301         ret = 0;
6302 out:
6303         SWRAP_UNLOCK_SI(si);
6304
6305         return ret;
6306 }
6307
6308 static int swrap_recvmsg_after(int fd,
6309                                struct socket_info *si,
6310                                struct msghdr *msg,
6311                                const struct sockaddr_un *un_addr,
6312                                socklen_t un_addrlen,
6313                                ssize_t ret)
6314 {
6315         int saved_errno = errno;
6316         size_t i;
6317         uint8_t *buf = NULL;
6318         off_t ofs = 0;
6319         size_t avail = 0;
6320         size_t remain;
6321         int rc;
6322
6323         /* to give better errors */
6324         if (ret == -1) {
6325                 if (saved_errno == ENOENT) {
6326                         saved_errno = EHOSTUNREACH;
6327                 } else if (saved_errno == ENOTSOCK) {
6328                         /* If the fd is not a socket, remove it */
6329                         swrap_remove_stale(fd);
6330                 }
6331         }
6332
6333         for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6334                 avail += msg->msg_iov[i].iov_len;
6335         }
6336
6337         SWRAP_LOCK_SI(si);
6338
6339         /* Convert the socket address before we leave */
6340         if (si->type == SOCK_DGRAM && un_addr != NULL) {
6341                 rc = sockaddr_convert_from_un(si,
6342                                               un_addr,
6343                                               un_addrlen,
6344                                               si->family,
6345                                               msg->msg_name,
6346                                               &msg->msg_namelen);
6347                 if (rc == -1) {
6348                         goto done;
6349                 }
6350         }
6351
6352         if (avail == 0) {
6353                 rc = 0;
6354                 goto done;
6355         }
6356
6357         if (ret == -1) {
6358                 remain = MIN(80, avail);
6359         } else {
6360                 remain = ret;
6361         }
6362
6363         /* we capture it as one single packet */
6364         buf = (uint8_t *)malloc(remain);
6365         if (buf == NULL) {
6366                 /* we just not capture the packet */
6367                 SWRAP_UNLOCK_SI(si);
6368                 errno = saved_errno;
6369                 return -1;
6370         }
6371
6372         for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
6373                 size_t this_time = MIN(remain, (size_t)msg->msg_iov[i].iov_len);
6374                 memcpy(buf + ofs,
6375                        msg->msg_iov[i].iov_base,
6376                        this_time);
6377                 ofs += this_time;
6378                 remain -= this_time;
6379         }
6380
6381         switch (si->type) {
6382         case SOCK_STREAM:
6383                 if (ret == -1 && saved_errno != EAGAIN && saved_errno != ENOBUFS) {
6384                         swrap_pcap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
6385                 } else if (ret == 0) { /* END OF FILE */
6386                         swrap_pcap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
6387                 } else if (ret > 0) {
6388                         swrap_pcap_dump_packet(si, NULL, SWRAP_RECV, buf, ret);
6389                 }
6390                 break;
6391
6392         case SOCK_DGRAM:
6393                 if (ret == -1) {
6394                         break;
6395                 }
6396
6397                 if (un_addr != NULL) {
6398                         swrap_pcap_dump_packet(si,
6399                                           msg->msg_name,
6400                                           SWRAP_RECVFROM,
6401                                           buf,
6402                                           ret);
6403                 } else {
6404                         swrap_pcap_dump_packet(si,
6405                                           msg->msg_name,
6406                                           SWRAP_RECV,
6407                                           buf,
6408                                           ret);
6409                 }
6410
6411                 break;
6412         }
6413
6414         rc = 0;
6415 done:
6416         free(buf);
6417         errno = saved_errno;
6418
6419 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6420         if (rc == 0 &&
6421             msg->msg_controllen > 0 &&
6422             msg->msg_control != NULL) {
6423                 rc = swrap_msghdr_add_socket_info(si, msg);
6424                 if (rc < 0) {
6425                         SWRAP_UNLOCK_SI(si);
6426                         return -1;
6427                 }
6428         }
6429 #endif
6430
6431         SWRAP_UNLOCK_SI(si);
6432         return rc;
6433 }
6434
6435 /****************************************************************************
6436  *   RECVFROM
6437  ***************************************************************************/
6438
6439 static ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags,
6440                               struct sockaddr *from, socklen_t *fromlen)
6441 {
6442         struct swrap_address from_addr = {
6443                 .sa_socklen = sizeof(struct sockaddr_un),
6444         };
6445         ssize_t ret;
6446         struct socket_info *si = find_socket_info(s);
6447         struct swrap_address saddr = {
6448                 .sa_socklen = sizeof(struct sockaddr_storage),
6449         };
6450         struct msghdr msg;
6451         struct iovec tmp;
6452         int tret;
6453
6454         if (!si) {
6455                 return libc_recvfrom(s,
6456                                      buf,
6457                                      len,
6458                                      flags,
6459                                      from,
6460                                      fromlen);
6461         }
6462
6463         tmp.iov_base = buf;
6464         tmp.iov_len = len;
6465
6466         ZERO_STRUCT(msg);
6467         if (from != NULL && fromlen != NULL) {
6468                 msg.msg_name = from;   /* optional address */
6469                 msg.msg_namelen = *fromlen; /* size of address */
6470         } else {
6471                 msg.msg_name = &saddr.sa.s; /* optional address */
6472                 msg.msg_namelen = saddr.sa_socklen; /* size of address */
6473         }
6474         msg.msg_iov = &tmp;            /* scatter/gather array */
6475         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6476 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6477         msg.msg_control = NULL;        /* ancillary data, see below */
6478         msg.msg_controllen = 0;        /* ancillary data buffer len */
6479         msg.msg_flags = 0;             /* flags on received message */
6480 #endif
6481
6482         tret = swrap_recvmsg_before(s, si, &msg, &tmp);
6483         if (tret < 0) {
6484                 return -1;
6485         }
6486
6487         buf = msg.msg_iov[0].iov_base;
6488         len = msg.msg_iov[0].iov_len;
6489
6490         ret = libc_recvfrom(s,
6491                             buf,
6492                             len,
6493                             flags,
6494                             &from_addr.sa.s,
6495                             &from_addr.sa_socklen);
6496         if (ret == -1) {
6497                 return ret;
6498         }
6499
6500         tret = swrap_recvmsg_after(s,
6501                                    si,
6502                                    &msg,
6503                                    &from_addr.sa.un,
6504                                    from_addr.sa_socklen,
6505                                    ret);
6506         if (tret != 0) {
6507                 return tret;
6508         }
6509
6510         if (from != NULL && fromlen != NULL) {
6511                 *fromlen = msg.msg_namelen;
6512         }
6513
6514         return ret;
6515 }
6516
6517 #ifdef HAVE_ACCEPT_PSOCKLEN_T
6518 ssize_t recvfrom(int s, void *buf, size_t len, int flags,
6519                  struct sockaddr *from, Psocklen_t fromlen)
6520 #else
6521 ssize_t recvfrom(int s, void *buf, size_t len, int flags,
6522                  struct sockaddr *from, socklen_t *fromlen)
6523 #endif
6524 {
6525         return swrap_recvfrom(s, buf, len, flags, from, (socklen_t *)fromlen);
6526 }
6527
6528 /****************************************************************************
6529  *   SENDTO
6530  ***************************************************************************/
6531
6532 static ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags,
6533                             const struct sockaddr *to, socklen_t tolen)
6534 {
6535         struct msghdr msg;
6536         struct iovec tmp;
6537         struct swrap_address un_addr = {
6538                 .sa_socklen = sizeof(struct sockaddr_un),
6539         };
6540         const struct sockaddr_un *to_un = NULL;
6541         ssize_t ret;
6542         int rc;
6543         struct socket_info *si = find_socket_info(s);
6544         int bcast = 0;
6545
6546         if (!si) {
6547                 return libc_sendto(s, buf, len, flags, to, tolen);
6548         }
6549
6550         tmp.iov_base = discard_const_p(char, buf);
6551         tmp.iov_len = len;
6552
6553         ZERO_STRUCT(msg);
6554         msg.msg_name = discard_const_p(struct sockaddr, to); /* optional address */
6555         msg.msg_namelen = tolen;       /* size of address */
6556         msg.msg_iov = &tmp;            /* scatter/gather array */
6557         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6558 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6559         msg.msg_control = NULL;        /* ancillary data, see below */
6560         msg.msg_controllen = 0;        /* ancillary data buffer len */
6561         msg.msg_flags = 0;             /* flags on received message */
6562 #endif
6563
6564         rc = swrap_sendmsg_before(s,
6565                                   si,
6566                                   &msg,
6567                                   &tmp,
6568                                   &un_addr.sa.un,
6569                                   &to_un,
6570                                   &to,
6571                                   &bcast);
6572         if (rc < 0) {
6573                 return -1;
6574         }
6575
6576         buf = msg.msg_iov[0].iov_base;
6577         len = msg.msg_iov[0].iov_len;
6578
6579         if (bcast) {
6580                 struct stat st;
6581                 unsigned int iface;
6582                 unsigned int prt = ntohs(((const struct sockaddr_in *)(const void *)to)->sin_port);
6583                 char type;
6584                 char *swrap_dir = NULL;
6585
6586                 type = SOCKET_TYPE_CHAR_UDP;
6587
6588                 swrap_dir = socket_wrapper_dir();
6589                 if (swrap_dir == NULL) {
6590                         return -1;
6591                 }
6592
6593                 for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
6594                         swrap_un_path(&un_addr.sa.un,
6595                                       swrap_dir,
6596                                       type,
6597                                       iface,
6598                                       prt);
6599                         if (stat(un_addr.sa.un.sun_path, &st) != 0) continue;
6600
6601                         /* ignore the any errors in broadcast sends */
6602                         libc_sendto(s,
6603                                     buf,
6604                                     len,
6605                                     flags,
6606                                     &un_addr.sa.s,
6607                                     un_addr.sa_socklen);
6608                 }
6609
6610                 SAFE_FREE(swrap_dir);
6611
6612                 SWRAP_LOCK_SI(si);
6613
6614                 swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
6615
6616                 SWRAP_UNLOCK_SI(si);
6617
6618                 return len;
6619         }
6620
6621         SWRAP_LOCK_SI(si);
6622         /*
6623          * If it is a dgram socket and we are connected, don't include the
6624          * 'to' address.
6625          */
6626         if (si->type == SOCK_DGRAM && si->connected) {
6627                 ret = libc_sendto(s,
6628                                   buf,
6629                                   len,
6630                                   flags,
6631                                   NULL,
6632                                   0);
6633         } else {
6634                 ret = libc_sendto(s,
6635                                   buf,
6636                                   len,
6637                                   flags,
6638                                   (struct sockaddr *)msg.msg_name,
6639                                   msg.msg_namelen);
6640         }
6641
6642         SWRAP_UNLOCK_SI(si);
6643
6644         swrap_sendmsg_after(s, si, &msg, to, ret);
6645
6646         return ret;
6647 }
6648
6649 ssize_t sendto(int s, const void *buf, size_t len, int flags,
6650                const struct sockaddr *to, socklen_t tolen)
6651 {
6652         return swrap_sendto(s, buf, len, flags, to, tolen);
6653 }
6654
6655 /****************************************************************************
6656  *   READV
6657  ***************************************************************************/
6658
6659 static ssize_t swrap_recv(int s, void *buf, size_t len, int flags)
6660 {
6661         struct socket_info *si;
6662         struct msghdr msg;
6663         struct swrap_address saddr = {
6664                 .sa_socklen = sizeof(struct sockaddr_storage),
6665         };
6666         struct iovec tmp;
6667         ssize_t ret;
6668         int tret;
6669
6670         si = find_socket_info(s);
6671         if (si == NULL) {
6672                 return libc_recv(s, buf, len, flags);
6673         }
6674
6675         tmp.iov_base = buf;
6676         tmp.iov_len = len;
6677
6678         ZERO_STRUCT(msg);
6679         msg.msg_name = &saddr.sa.s;    /* optional address */
6680         msg.msg_namelen = saddr.sa_socklen; /* size of address */
6681         msg.msg_iov = &tmp;            /* scatter/gather array */
6682         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6683 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6684         msg.msg_control = NULL;        /* ancillary data, see below */
6685         msg.msg_controllen = 0;        /* ancillary data buffer len */
6686         msg.msg_flags = 0;             /* flags on received message */
6687 #endif
6688
6689         tret = swrap_recvmsg_before(s, si, &msg, &tmp);
6690         if (tret < 0) {
6691                 return -1;
6692         }
6693
6694         buf = msg.msg_iov[0].iov_base;
6695         len = msg.msg_iov[0].iov_len;
6696
6697         ret = libc_recv(s, buf, len, flags);
6698
6699         tret = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret);
6700         if (tret != 0) {
6701                 return tret;
6702         }
6703
6704         return ret;
6705 }
6706
6707 ssize_t recv(int s, void *buf, size_t len, int flags)
6708 {
6709         return swrap_recv(s, buf, len, flags);
6710 }
6711
6712 /****************************************************************************
6713  *   READ
6714  ***************************************************************************/
6715
6716 static ssize_t swrap_read(int s, void *buf, size_t len)
6717 {
6718         struct socket_info *si;
6719         struct msghdr msg;
6720         struct iovec tmp;
6721         struct swrap_address saddr = {
6722                 .sa_socklen = sizeof(struct sockaddr_storage),
6723         };
6724         ssize_t ret;
6725         int tret;
6726
6727         si = find_socket_info(s);
6728         if (si == NULL) {
6729                 return libc_read(s, buf, len);
6730         }
6731
6732         tmp.iov_base = buf;
6733         tmp.iov_len = len;
6734
6735         ZERO_STRUCT(msg);
6736         msg.msg_name = &saddr.sa.ss;   /* optional address */
6737         msg.msg_namelen = saddr.sa_socklen; /* size of address */
6738         msg.msg_iov = &tmp;            /* scatter/gather array */
6739         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6740 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6741         msg.msg_control = NULL;        /* ancillary data, see below */
6742         msg.msg_controllen = 0;        /* ancillary data buffer len */
6743         msg.msg_flags = 0;             /* flags on received message */
6744 #endif
6745
6746         tret = swrap_recvmsg_before(s, si, &msg, &tmp);
6747         if (tret < 0) {
6748                 if (tret == -ENOTSOCK) {
6749                         return libc_read(s, buf, len);
6750                 }
6751                 return -1;
6752         }
6753
6754         buf = msg.msg_iov[0].iov_base;
6755         len = msg.msg_iov[0].iov_len;
6756
6757         ret = libc_read(s, buf, len);
6758
6759         tret = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret);
6760         if (tret != 0) {
6761                 return tret;
6762         }
6763
6764         return ret;
6765 }
6766
6767 ssize_t read(int s, void *buf, size_t len)
6768 {
6769         return swrap_read(s, buf, len);
6770 }
6771
6772 /****************************************************************************
6773  *   WRITE
6774  ***************************************************************************/
6775
6776 static ssize_t swrap_write(int s, const void *buf, size_t len)
6777 {
6778         struct msghdr msg;
6779         struct iovec tmp;
6780         struct sockaddr_un un_addr;
6781         ssize_t ret;
6782         int rc;
6783         struct socket_info *si;
6784
6785         si = find_socket_info(s);
6786         if (si == NULL) {
6787                 return libc_write(s, buf, len);
6788         }
6789
6790         tmp.iov_base = discard_const_p(char, buf);
6791         tmp.iov_len = len;
6792
6793         ZERO_STRUCT(msg);
6794         msg.msg_name = NULL;           /* optional address */
6795         msg.msg_namelen = 0;           /* size of address */
6796         msg.msg_iov = &tmp;            /* scatter/gather array */
6797         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6798 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6799         msg.msg_control = NULL;        /* ancillary data, see below */
6800         msg.msg_controllen = 0;        /* ancillary data buffer len */
6801         msg.msg_flags = 0;             /* flags on received message */
6802 #endif
6803
6804         rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
6805         if (rc < 0) {
6806                 return -1;
6807         }
6808
6809         buf = msg.msg_iov[0].iov_base;
6810         len = msg.msg_iov[0].iov_len;
6811
6812         ret = libc_write(s, buf, len);
6813
6814         swrap_sendmsg_after(s, si, &msg, NULL, ret);
6815
6816         return ret;
6817 }
6818
6819 ssize_t write(int s, const void *buf, size_t len)
6820 {
6821         return swrap_write(s, buf, len);
6822 }
6823
6824 /****************************************************************************
6825  *   SEND
6826  ***************************************************************************/
6827
6828 static ssize_t swrap_send(int s, const void *buf, size_t len, int flags)
6829 {
6830         struct msghdr msg;
6831         struct iovec tmp;
6832         struct sockaddr_un un_addr;
6833         ssize_t ret;
6834         int rc;
6835         struct socket_info *si = find_socket_info(s);
6836
6837         if (!si) {
6838                 return libc_send(s, buf, len, flags);
6839         }
6840
6841         tmp.iov_base = discard_const_p(char, buf);
6842         tmp.iov_len = len;
6843
6844         ZERO_STRUCT(msg);
6845         msg.msg_name = NULL;           /* optional address */
6846         msg.msg_namelen = 0;           /* size of address */
6847         msg.msg_iov = &tmp;            /* scatter/gather array */
6848         msg.msg_iovlen = 1;            /* # elements in msg_iov */
6849 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6850         msg.msg_control = NULL;        /* ancillary data, see below */
6851         msg.msg_controllen = 0;        /* ancillary data buffer len */
6852         msg.msg_flags = 0;             /* flags on received message */
6853 #endif
6854
6855         rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
6856         if (rc < 0) {
6857                 return -1;
6858         }
6859
6860         buf = msg.msg_iov[0].iov_base;
6861         len = msg.msg_iov[0].iov_len;
6862
6863         ret = libc_send(s, buf, len, flags);
6864
6865         swrap_sendmsg_after(s, si, &msg, NULL, ret);
6866
6867         return ret;
6868 }
6869
6870 ssize_t send(int s, const void *buf, size_t len, int flags)
6871 {
6872         return swrap_send(s, buf, len, flags);
6873 }
6874
6875 /****************************************************************************
6876  *   RECVMSG
6877  ***************************************************************************/
6878
6879 static ssize_t swrap_recvmsg(int s, struct msghdr *omsg, int flags)
6880 {
6881         struct swrap_address from_addr = {
6882                 .sa_socklen = sizeof(struct sockaddr_un),
6883         };
6884         struct swrap_address convert_addr = {
6885                 .sa_socklen = sizeof(struct sockaddr_storage),
6886         };
6887         struct socket_info *si;
6888         struct msghdr msg;
6889         struct iovec tmp;
6890 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6891         size_t msg_ctrllen_filled;
6892         size_t msg_ctrllen_left;
6893 #endif
6894
6895         ssize_t ret;
6896         int rc;
6897
6898         si = find_socket_info(s);
6899         if (si == NULL) {
6900                 rc = swrap_recvmsg_before_unix(omsg, &msg);
6901                 if (rc < 0) {
6902                         return rc;
6903                 }
6904                 ret = libc_recvmsg(s, &msg, flags);
6905                 return swrap_recvmsg_after_unix(&msg, omsg, ret);
6906         }
6907
6908         tmp.iov_base = NULL;
6909         tmp.iov_len = 0;
6910
6911         ZERO_STRUCT(msg);
6912         msg.msg_name = &from_addr.sa;              /* optional address */
6913         msg.msg_namelen = from_addr.sa_socklen;    /* size of address */
6914         msg.msg_iov = omsg->msg_iov;               /* scatter/gather array */
6915         msg.msg_iovlen = omsg->msg_iovlen;         /* # elements in msg_iov */
6916 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6917         msg_ctrllen_filled = 0;
6918         msg_ctrllen_left = omsg->msg_controllen;
6919
6920         msg.msg_control = omsg->msg_control;       /* ancillary data, see below */
6921         msg.msg_controllen = omsg->msg_controllen; /* ancillary data buffer len */
6922         msg.msg_flags = omsg->msg_flags;           /* flags on received message */
6923 #endif
6924
6925         rc = swrap_recvmsg_before(s, si, &msg, &tmp);
6926         if (rc < 0) {
6927                 return -1;
6928         }
6929
6930         ret = libc_recvmsg(s, &msg, flags);
6931
6932 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6933         msg_ctrllen_filled += msg.msg_controllen;
6934         msg_ctrllen_left -= msg.msg_controllen;
6935
6936         if (omsg->msg_control != NULL) {
6937                 uint8_t *p;
6938
6939                 p = omsg->msg_control;
6940                 p += msg_ctrllen_filled;
6941
6942                 msg.msg_control = p;
6943                 msg.msg_controllen = msg_ctrllen_left;
6944         } else {
6945                 msg.msg_control = NULL;
6946                 msg.msg_controllen = 0;
6947         }
6948 #endif
6949
6950         /*
6951          * We convert the unix address to a IP address so we need a buffer
6952          * which can store the address in case of SOCK_DGRAM, see below.
6953          */
6954         msg.msg_name = &convert_addr.sa;
6955         msg.msg_namelen = convert_addr.sa_socklen;
6956
6957         rc = swrap_recvmsg_after(s,
6958                                  si,
6959                                  &msg,
6960                                  &from_addr.sa.un,
6961                                  from_addr.sa_socklen,
6962                                  ret);
6963         if (rc != 0) {
6964                 return rc;
6965         }
6966
6967 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
6968         if (omsg->msg_control != NULL) {
6969                 /* msg.msg_controllen = space left */
6970                 msg_ctrllen_left = msg.msg_controllen;
6971                 msg_ctrllen_filled = omsg->msg_controllen - msg_ctrllen_left;
6972         }
6973
6974         /* Update the original message length */
6975         omsg->msg_controllen = msg_ctrllen_filled;
6976         omsg->msg_flags = msg.msg_flags;
6977 #endif
6978         omsg->msg_iovlen = msg.msg_iovlen;
6979
6980         SWRAP_LOCK_SI(si);
6981
6982         /*
6983          * From the manpage:
6984          *
6985          * The  msg_name  field  points  to a caller-allocated buffer that is
6986          * used to return the source address if the socket is unconnected.  The
6987          * caller should set msg_namelen to the size of this buffer before this
6988          * call; upon return from a successful call, msg_name will contain the
6989          * length of the returned address.  If the application  does  not  need
6990          * to know the source address, msg_name can be specified as NULL.
6991          */
6992         if (si->type == SOCK_STREAM) {
6993                 omsg->msg_namelen = 0;
6994         } else if (omsg->msg_name != NULL &&
6995                    omsg->msg_namelen != 0 &&
6996                    omsg->msg_namelen >= msg.msg_namelen) {
6997                 memcpy(omsg->msg_name, msg.msg_name, msg.msg_namelen);
6998                 omsg->msg_namelen = msg.msg_namelen;
6999         }
7000
7001         SWRAP_UNLOCK_SI(si);
7002
7003         return ret;
7004 }
7005
7006 ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)
7007 {
7008         return swrap_recvmsg(sockfd, msg, flags);
7009 }
7010
7011 /****************************************************************************
7012  *   SENDMSG
7013  ***************************************************************************/
7014
7015 static ssize_t swrap_sendmsg(int s, const struct msghdr *omsg, int flags)
7016 {
7017         struct msghdr msg;
7018         struct iovec tmp;
7019         struct sockaddr_un un_addr;
7020         const struct sockaddr_un *to_un = NULL;
7021         const struct sockaddr *to = NULL;
7022         ssize_t ret;
7023         int rc;
7024         struct socket_info *si = find_socket_info(s);
7025         int bcast = 0;
7026
7027         if (!si) {
7028                 int scm_rights_pipe_fd = -1;
7029
7030                 rc = swrap_sendmsg_before_unix(omsg, &msg,
7031                                                &scm_rights_pipe_fd);
7032                 if (rc < 0) {
7033                         return rc;
7034                 }
7035                 ret = libc_sendmsg(s, &msg, flags);
7036                 return swrap_sendmsg_after_unix(&msg, ret, scm_rights_pipe_fd);
7037         }
7038
7039         ZERO_STRUCT(un_addr);
7040
7041         tmp.iov_base = NULL;
7042         tmp.iov_len = 0;
7043
7044         ZERO_STRUCT(msg);
7045
7046         SWRAP_LOCK_SI(si);
7047
7048         if (si->connected == 0) {
7049                 msg.msg_name = omsg->msg_name;             /* optional address */
7050                 msg.msg_namelen = omsg->msg_namelen;       /* size of address */
7051         }
7052         msg.msg_iov = omsg->msg_iov;               /* scatter/gather array */
7053         msg.msg_iovlen = omsg->msg_iovlen;         /* # elements in msg_iov */
7054
7055         SWRAP_UNLOCK_SI(si);
7056
7057 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7058         if (omsg != NULL && omsg->msg_controllen > 0 && omsg->msg_control != NULL) {
7059                 uint8_t *cmbuf = NULL;
7060                 size_t cmlen = 0;
7061
7062                 rc = swrap_sendmsg_filter_cmsghdr(omsg, &cmbuf, &cmlen);
7063                 if (rc < 0) {
7064                         return rc;
7065                 }
7066
7067                 if (cmlen == 0) {
7068                         msg.msg_controllen = 0;
7069                         msg.msg_control = NULL;
7070                 } else {
7071                         msg.msg_control = cmbuf;
7072                         msg.msg_controllen = cmlen;
7073                 }
7074         }
7075         msg.msg_flags = omsg->msg_flags;           /* flags on received message */
7076 #endif
7077         rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, &to_un, &to, &bcast);
7078         if (rc < 0) {
7079                 int saved_errno = errno;
7080 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7081                 SAFE_FREE(msg.msg_control);
7082 #endif
7083                 errno = saved_errno;
7084                 return -1;
7085         }
7086
7087         if (bcast) {
7088                 struct stat st;
7089                 unsigned int iface;
7090                 unsigned int prt = ntohs(((const struct sockaddr_in *)(const void *)to)->sin_port);
7091                 char type;
7092                 size_t i, len = 0;
7093                 uint8_t *buf;
7094                 off_t ofs = 0;
7095                 size_t avail = 0;
7096                 size_t remain;
7097                 char *swrap_dir = NULL;
7098
7099                 for (i = 0; i < (size_t)msg.msg_iovlen; i++) {
7100                         avail += msg.msg_iov[i].iov_len;
7101                 }
7102
7103                 len = avail;
7104                 remain = avail;
7105
7106                 /* we capture it as one single packet */
7107                 buf = (uint8_t *)malloc(remain);
7108                 if (!buf) {
7109                         int saved_errno = errno;
7110 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7111                         SAFE_FREE(msg.msg_control);
7112 #endif
7113                         errno = saved_errno;
7114                         return -1;
7115                 }
7116
7117                 for (i = 0; i < (size_t)msg.msg_iovlen; i++) {
7118                         size_t this_time = MIN(remain, (size_t)msg.msg_iov[i].iov_len);
7119                         memcpy(buf + ofs,
7120                                msg.msg_iov[i].iov_base,
7121                                this_time);
7122                         ofs += this_time;
7123                         remain -= this_time;
7124                 }
7125
7126                 type = SOCKET_TYPE_CHAR_UDP;
7127
7128                 swrap_dir = socket_wrapper_dir();
7129                 if (swrap_dir == NULL) {
7130                         int saved_errno = errno;
7131 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7132                         SAFE_FREE(msg.msg_control);
7133 #endif
7134                         SAFE_FREE(buf);
7135                         errno = saved_errno;
7136                         return -1;
7137                 }
7138
7139                 for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
7140                         swrap_un_path(&un_addr, swrap_dir, type, iface, prt);
7141                         if (stat(un_addr.sun_path, &st) != 0) continue;
7142
7143                         msg.msg_name = &un_addr;           /* optional address */
7144                         msg.msg_namelen = sizeof(un_addr); /* size of address */
7145
7146                         /* ignore the any errors in broadcast sends */
7147                         libc_sendmsg(s, &msg, flags);
7148                 }
7149
7150                 SAFE_FREE(swrap_dir);
7151
7152                 SWRAP_LOCK_SI(si);
7153
7154                 swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
7155                 free(buf);
7156
7157                 SWRAP_UNLOCK_SI(si);
7158
7159                 return len;
7160         }
7161
7162         ret = libc_sendmsg(s, &msg, flags);
7163
7164         swrap_sendmsg_after(s, si, &msg, to, ret);
7165
7166 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7167         {
7168                 int saved_errno = errno;
7169                 SAFE_FREE(msg.msg_control);
7170                 errno = saved_errno;
7171         }
7172 #endif
7173
7174         return ret;
7175 }
7176
7177 ssize_t sendmsg(int s, const struct msghdr *omsg, int flags)
7178 {
7179         return swrap_sendmsg(s, omsg, flags);
7180 }
7181
7182 /****************************************************************************
7183  *   READV
7184  ***************************************************************************/
7185
7186 static ssize_t swrap_readv(int s, const struct iovec *vector, int count)
7187 {
7188         struct socket_info *si;
7189         struct msghdr msg;
7190         struct iovec tmp;
7191         struct swrap_address saddr = {
7192                 .sa_socklen = sizeof(struct sockaddr_storage)
7193         };
7194         ssize_t ret;
7195         int rc;
7196
7197         si = find_socket_info(s);
7198         if (si == NULL) {
7199                 return libc_readv(s, vector, count);
7200         }
7201
7202         tmp.iov_base = NULL;
7203         tmp.iov_len = 0;
7204
7205         ZERO_STRUCT(msg);
7206         msg.msg_name = &saddr.sa.s; /* optional address */
7207         msg.msg_namelen = saddr.sa_socklen;      /* size of address */
7208         msg.msg_iov = discard_const_p(struct iovec, vector); /* scatter/gather array */
7209         msg.msg_iovlen = count;        /* # elements in msg_iov */
7210 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7211         msg.msg_control = NULL;        /* ancillary data, see below */
7212         msg.msg_controllen = 0;        /* ancillary data buffer len */
7213         msg.msg_flags = 0;             /* flags on received message */
7214 #endif
7215
7216         rc = swrap_recvmsg_before(s, si, &msg, &tmp);
7217         if (rc < 0) {
7218                 if (rc == -ENOTSOCK) {
7219                         return libc_readv(s, vector, count);
7220                 }
7221                 return -1;
7222         }
7223
7224         ret = libc_readv(s, msg.msg_iov, msg.msg_iovlen);
7225
7226         rc = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret);
7227         if (rc != 0) {
7228                 return rc;
7229         }
7230
7231         return ret;
7232 }
7233
7234 ssize_t readv(int s, const struct iovec *vector, int count)
7235 {
7236         return swrap_readv(s, vector, count);
7237 }
7238
7239 /****************************************************************************
7240  *   WRITEV
7241  ***************************************************************************/
7242
7243 static ssize_t swrap_writev(int s, const struct iovec *vector, int count)
7244 {
7245         struct msghdr msg;
7246         struct iovec tmp;
7247         struct sockaddr_un un_addr;
7248         ssize_t ret;
7249         int rc;
7250         struct socket_info *si = find_socket_info(s);
7251
7252         if (!si) {
7253                 return libc_writev(s, vector, count);
7254         }
7255
7256         tmp.iov_base = NULL;
7257         tmp.iov_len = 0;
7258
7259         ZERO_STRUCT(msg);
7260         msg.msg_name = NULL;           /* optional address */
7261         msg.msg_namelen = 0;           /* size of address */
7262         msg.msg_iov = discard_const_p(struct iovec, vector); /* scatter/gather array */
7263         msg.msg_iovlen = count;        /* # elements in msg_iov */
7264 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
7265         msg.msg_control = NULL;        /* ancillary data, see below */
7266         msg.msg_controllen = 0;        /* ancillary data buffer len */
7267         msg.msg_flags = 0;             /* flags on received message */
7268 #endif
7269
7270         rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
7271         if (rc < 0) {
7272                 if (rc == -ENOTSOCK) {
7273                         return libc_readv(s, vector, count);
7274                 }
7275                 return -1;
7276         }
7277
7278         ret = libc_writev(s, msg.msg_iov, msg.msg_iovlen);
7279
7280         swrap_sendmsg_after(s, si, &msg, NULL, ret);
7281
7282         return ret;
7283 }
7284
7285 ssize_t writev(int s, const struct iovec *vector, int count)
7286 {
7287         return swrap_writev(s, vector, count);
7288 }
7289
7290 /****************************
7291  * CLOSE
7292  ***************************/
7293
7294 static int swrap_close(int fd)
7295 {
7296         struct socket_info *si = NULL;
7297         int si_index;
7298         int ret;
7299
7300         swrap_mutex_lock(&socket_reset_mutex);
7301
7302         si_index = find_socket_info_index(fd);
7303         if (si_index == -1) {
7304                 swrap_mutex_unlock(&socket_reset_mutex);
7305                 return libc_close(fd);
7306         }
7307
7308         SWRAP_LOG(SWRAP_LOG_TRACE, "Close wrapper for fd=%d", fd);
7309         reset_socket_info_index(fd);
7310
7311         si = swrap_get_socket_info(si_index);
7312
7313         swrap_mutex_lock(&first_free_mutex);
7314         SWRAP_LOCK_SI(si);
7315
7316         ret = libc_close(fd);
7317
7318         swrap_dec_refcount(si);
7319
7320         if (swrap_get_refcount(si) > 0) {
7321                 /* there are still references left */
7322                 goto out;
7323         }
7324
7325         if (si->fd_passed) {
7326                 goto set_next_free;
7327         }
7328
7329         if (si->myname.sa_socklen > 0 && si->peername.sa_socklen > 0) {
7330                 swrap_pcap_dump_packet(si, NULL, SWRAP_CLOSE_SEND, NULL, 0);
7331         }
7332
7333         if (si->myname.sa_socklen > 0 && si->peername.sa_socklen > 0) {
7334                 swrap_pcap_dump_packet(si, NULL, SWRAP_CLOSE_RECV, NULL, 0);
7335                 swrap_pcap_dump_packet(si, NULL, SWRAP_CLOSE_ACK, NULL, 0);
7336         }
7337
7338         if (si->un_addr.sun_path[0] != '\0') {
7339                 unlink(si->un_addr.sun_path);
7340         }
7341
7342 set_next_free:
7343         swrap_set_next_free(si, first_free);
7344         first_free = si_index;
7345
7346 out:
7347         SWRAP_UNLOCK_SI(si);
7348         swrap_mutex_unlock(&first_free_mutex);
7349         swrap_mutex_unlock(&socket_reset_mutex);
7350
7351         return ret;
7352 }
7353
7354 int close(int fd)
7355 {
7356         return swrap_close(fd);
7357 }
7358
7359 /****************************
7360  * DUP
7361  ***************************/
7362
7363 static int swrap_dup(int fd)
7364 {
7365         struct socket_info *si;
7366         int dup_fd, idx;
7367
7368         idx = find_socket_info_index(fd);
7369         if (idx == -1) {
7370                 return libc_dup(fd);
7371         }
7372
7373         si = swrap_get_socket_info(idx);
7374
7375         dup_fd = libc_dup(fd);
7376         if (dup_fd == -1) {
7377                 int saved_errno = errno;
7378                 errno = saved_errno;
7379                 return -1;
7380         }
7381
7382         if ((size_t)dup_fd >= socket_fds_max) {
7383                 SWRAP_LOG(SWRAP_LOG_ERROR,
7384                           "The max socket index limit of %zu has been reached, "
7385                           "trying to add %d",
7386                           socket_fds_max,
7387                           dup_fd);
7388                 libc_close(dup_fd);
7389                 errno = EMFILE;
7390                 return -1;
7391         }
7392
7393         SWRAP_LOCK_SI(si);
7394
7395         swrap_inc_refcount(si);
7396
7397         SWRAP_UNLOCK_SI(si);
7398
7399         /* Make sure we don't have an entry for the fd */
7400         swrap_remove_stale(dup_fd);
7401
7402         set_socket_info_index(dup_fd, idx);
7403
7404         return dup_fd;
7405 }
7406
7407 int dup(int fd)
7408 {
7409         return swrap_dup(fd);
7410 }
7411
7412 /****************************
7413  * DUP2
7414  ***************************/
7415
7416 static int swrap_dup2(int fd, int newfd)
7417 {
7418         struct socket_info *si;
7419         int dup_fd, idx;
7420
7421         idx = find_socket_info_index(fd);
7422         if (idx == -1) {
7423                 return libc_dup2(fd, newfd);
7424         }
7425
7426         si = swrap_get_socket_info(idx);
7427
7428         if (fd == newfd) {
7429                 /*
7430                  * According to the manpage:
7431                  *
7432                  * "If oldfd is a valid file descriptor, and newfd has the same
7433                  * value as oldfd, then dup2() does nothing, and returns newfd."
7434                  */
7435                 return newfd;
7436         }
7437
7438         if ((size_t)newfd >= socket_fds_max) {
7439                 SWRAP_LOG(SWRAP_LOG_ERROR,
7440                           "The max socket index limit of %zu has been reached, "
7441                           "trying to add %d",
7442                           socket_fds_max,
7443                           newfd);
7444                 errno = EMFILE;
7445                 return -1;
7446         }
7447
7448         if (find_socket_info(newfd)) {
7449                 /* dup2() does an implicit close of newfd, which we
7450                  * need to emulate */
7451                 swrap_close(newfd);
7452         }
7453
7454         dup_fd = libc_dup2(fd, newfd);
7455         if (dup_fd == -1) {
7456                 int saved_errno = errno;
7457                 errno = saved_errno;
7458                 return -1;
7459         }
7460
7461         SWRAP_LOCK_SI(si);
7462
7463         swrap_inc_refcount(si);
7464
7465         SWRAP_UNLOCK_SI(si);
7466
7467         /* Make sure we don't have an entry for the fd */
7468         swrap_remove_stale(dup_fd);
7469
7470         set_socket_info_index(dup_fd, idx);
7471
7472         return dup_fd;
7473 }
7474
7475 int dup2(int fd, int newfd)
7476 {
7477         return swrap_dup2(fd, newfd);
7478 }
7479
7480 /****************************
7481  * FCNTL
7482  ***************************/
7483
7484 static int swrap_vfcntl(int fd, int cmd, va_list va)
7485 {
7486         struct socket_info *si;
7487         int rc, dup_fd, idx;
7488
7489         idx = find_socket_info_index(fd);
7490         if (idx == -1) {
7491                 return libc_vfcntl(fd, cmd, va);
7492         }
7493
7494         si = swrap_get_socket_info(idx);
7495
7496         switch (cmd) {
7497         case F_DUPFD:
7498                 dup_fd = libc_vfcntl(fd, cmd, va);
7499                 if (dup_fd == -1) {
7500                         int saved_errno = errno;
7501                         errno = saved_errno;
7502                         return -1;
7503                 }
7504
7505                 /* Make sure we don't have an entry for the fd */
7506                 swrap_remove_stale(dup_fd);
7507
7508                 if ((size_t)dup_fd >= socket_fds_max) {
7509                         SWRAP_LOG(SWRAP_LOG_ERROR,
7510                           "The max socket index limit of %zu has been reached, "
7511                           "trying to add %d",
7512                           socket_fds_max,
7513                           dup_fd);
7514                         libc_close(dup_fd);
7515                         errno = EMFILE;
7516                         return -1;
7517                 }
7518
7519                 SWRAP_LOCK_SI(si);
7520
7521                 swrap_inc_refcount(si);
7522
7523                 SWRAP_UNLOCK_SI(si);
7524
7525
7526                 set_socket_info_index(dup_fd, idx);
7527
7528                 rc = dup_fd;
7529                 break;
7530         default:
7531                 rc = libc_vfcntl(fd, cmd, va);
7532                 break;
7533         }
7534
7535         return rc;
7536 }
7537
7538 int fcntl(int fd, int cmd, ...)
7539 {
7540         va_list va;
7541         int rc;
7542
7543         va_start(va, cmd);
7544
7545         rc = swrap_vfcntl(fd, cmd, va);
7546
7547         va_end(va);
7548
7549         return rc;
7550 }
7551
7552 /****************************
7553  * EVENTFD
7554  ***************************/
7555
7556 #ifdef HAVE_EVENTFD
7557 static int swrap_eventfd(int count, int flags)
7558 {
7559         int fd;
7560
7561         fd = libc_eventfd(count, flags);
7562         if (fd != -1) {
7563                 swrap_remove_stale(fd);
7564         }
7565
7566         return fd;
7567 }
7568
7569 #ifdef HAVE_EVENTFD_UNSIGNED_INT
7570 int eventfd(unsigned int count, int flags)
7571 #else
7572 int eventfd(int count, int flags)
7573 #endif
7574 {
7575         return swrap_eventfd(count, flags);
7576 }
7577 #endif
7578
7579 #ifdef HAVE_PLEDGE
7580 int pledge(const char *promises, const char *paths[])
7581 {
7582         (void)promises; /* unused */
7583         (void)paths; /* unused */
7584
7585         return 0;
7586 }
7587 #endif /* HAVE_PLEDGE */
7588
7589 static void swrap_thread_prepare(void)
7590 {
7591         /*
7592          * This function should only be called here!!
7593          *
7594          * We bind all symobls to avoid deadlocks of the fork is
7595          * interrupted by a signal handler using a symbol of this
7596          * library.
7597          */
7598         swrap_bind_symbol_all();
7599
7600         SWRAP_LOCK_ALL;
7601 }
7602
7603 static void swrap_thread_parent(void)
7604 {
7605         SWRAP_UNLOCK_ALL;
7606 }
7607
7608 static void swrap_thread_child(void)
7609 {
7610         SWRAP_REINIT_ALL;
7611 }
7612
7613 /****************************
7614  * CONSTRUCTOR
7615  ***************************/
7616 void swrap_constructor(void)
7617 {
7618         if (PIPE_BUF < sizeof(struct swrap_unix_scm_rights)) {
7619                 SWRAP_LOG(SWRAP_LOG_ERROR,
7620                           "PIPE_BUF=%zu < "
7621                           "sizeof(struct swrap_unix_scm_rights)=%zu\n"
7622                           "sizeof(struct swrap_unix_scm_rights_payload)=%zu "
7623                           "sizeof(struct socket_info)=%zu",
7624                           (size_t)PIPE_BUF,
7625                           sizeof(struct swrap_unix_scm_rights),
7626                           sizeof(struct swrap_unix_scm_rights_payload),
7627                           sizeof(struct socket_info));
7628                 exit(-1);
7629         }
7630
7631         SWRAP_REINIT_ALL;
7632
7633         /*
7634         * If we hold a lock and the application forks, then the child
7635         * is not able to unlock the mutex and we are in a deadlock.
7636         * This should prevent such deadlocks.
7637         */
7638         pthread_atfork(&swrap_thread_prepare,
7639                        &swrap_thread_parent,
7640                        &swrap_thread_child);
7641 }
7642
7643 /****************************
7644  * DESTRUCTOR
7645  ***************************/
7646
7647 /*
7648  * This function is called when the library is unloaded and makes sure that
7649  * sockets get closed and the unix file for the socket are unlinked.
7650  */
7651 void swrap_destructor(void)
7652 {
7653         size_t i;
7654
7655         if (socket_fds_idx != NULL) {
7656                 for (i = 0; i < socket_fds_max; ++i) {
7657                         if (socket_fds_idx[i] != -1) {
7658                                 swrap_close(i);
7659                         }
7660                 }
7661                 SAFE_FREE(socket_fds_idx);
7662         }
7663
7664         SAFE_FREE(sockets);
7665
7666         if (swrap.libc.handle != NULL) {
7667                 dlclose(swrap.libc.handle);
7668         }
7669         if (swrap.libc.socket_handle) {
7670                 dlclose(swrap.libc.socket_handle);
7671         }
7672 }
7673
7674 #if defined(HAVE__SOCKET) && defined(HAVE__CLOSE)
7675 /*
7676  * On FreeBSD 12 (and maybe other platforms)
7677  * system libraries like libresolv prefix there
7678  * syscalls with '_' in order to always use
7679  * the symbols from libc.
7680  *
7681  * In the interaction with resolv_wrapper,
7682  * we need to inject socket wrapper into libresolv,
7683  * which means we need to private all socket
7684  * related syscalls also with the '_' prefix.
7685  *
7686  * This is tested in Samba's 'make test',
7687  * there we noticed that providing '_read'
7688  * and '_open' would cause errors, which
7689  * means we skip '_read', '_write' and
7690  * all non socket related calls without
7691  * further analyzing the problem.
7692  */
7693 #define SWRAP_SYMBOL_ALIAS(__sym, __aliassym) \
7694         extern typeof(__sym) __aliassym __attribute__ ((alias(#__sym)))
7695
7696 #ifdef HAVE_ACCEPT4
7697 SWRAP_SYMBOL_ALIAS(accept4, _accept4);
7698 #endif
7699 SWRAP_SYMBOL_ALIAS(accept, _accept);
7700 SWRAP_SYMBOL_ALIAS(bind, _bind);
7701 SWRAP_SYMBOL_ALIAS(close, _close);
7702 SWRAP_SYMBOL_ALIAS(connect, _connect);
7703 SWRAP_SYMBOL_ALIAS(dup, _dup);
7704 SWRAP_SYMBOL_ALIAS(dup2, _dup2);
7705 SWRAP_SYMBOL_ALIAS(fcntl, _fcntl);
7706 SWRAP_SYMBOL_ALIAS(getpeername, _getpeername);
7707 SWRAP_SYMBOL_ALIAS(getsockname, _getsockname);
7708 SWRAP_SYMBOL_ALIAS(getsockopt, _getsockopt);
7709 SWRAP_SYMBOL_ALIAS(ioctl, _ioctl);
7710 SWRAP_SYMBOL_ALIAS(listen, _listen);
7711 SWRAP_SYMBOL_ALIAS(readv, _readv);
7712 SWRAP_SYMBOL_ALIAS(recv, _recv);
7713 SWRAP_SYMBOL_ALIAS(recvfrom, _recvfrom);
7714 SWRAP_SYMBOL_ALIAS(recvmsg, _recvmsg);
7715 SWRAP_SYMBOL_ALIAS(send, _send);
7716 SWRAP_SYMBOL_ALIAS(sendmsg, _sendmsg);
7717 SWRAP_SYMBOL_ALIAS(sendto, _sendto);
7718 SWRAP_SYMBOL_ALIAS(setsockopt, _setsockopt);
7719 SWRAP_SYMBOL_ALIAS(socket, _socket);
7720 SWRAP_SYMBOL_ALIAS(socketpair, _socketpair);
7721 SWRAP_SYMBOL_ALIAS(writev, _writev);
7722
7723 #endif /* SOCKET_WRAPPER_EXPORT_UNDERSCORE_SYMBOLS */