release/src/router/samba3/source/lib/socket_wrapper.c

   1 /*
   2    Socket wrapper library. Passes all socket communication over
   3    unix domain sockets if the environment variable SOCKET_WRAPPER_DIR
   4    is set.
   5    Copyright (C) Jelmer Vernooij 2005
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 #ifdef _PUBLIC_
  25 #undef _PUBLIC_
  26 #endif
  27 #define _PUBLIC_
  28
  29 #ifdef SOCKET_WRAPPER_REPLACE
  30 #undef accept
  31 #undef connect
  32 #undef bind
  33 #undef getpeername
  34 #undef getsockname
  35 #undef getsockopt
  36 #undef setsockopt
  37 #undef recvfrom
  38 #undef sendto
  39 #undef socket
  40 #undef close
  41 #endif
  42
  43 /* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
  44  * for now */
  45 #define REWRITE_CALLS
  46
  47 #ifdef REWRITE_CALLS
  48 #define real_accept accept
  49 #define real_connect connect
  50 #define real_bind bind
  51 #define real_getpeername getpeername
  52 #define real_getsockname getsockname
  53 #define real_getsockopt getsockopt
  54 #define real_setsockopt setsockopt
  55 #define real_recvfrom recvfrom
  56 #define real_sendto sendto
  57 #define real_socket socket
  58 #define real_close close
  59 #endif
  60
  61 #undef malloc
  62 #undef calloc
  63 #undef strdup
  64 /* we need to use a very terse format here as IRIX 6.4 silently
  65    truncates names to 16 chars, so if we use a longer name then we
  66    can't tell which port a packet came from with recvfrom()
  67
  68    with this format we have 8 chars left for the directory name
  69 */
  70 #define SOCKET_FORMAT "%c%02X%04X"
  71 #define SOCKET_TYPE_CHAR_TCP            'T'
  72 #define SOCKET_TYPE_CHAR_UDP            'U'
  73
  74 static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
  75 {
  76         struct sockaddr *ret = (struct sockaddr *)malloc(len);
  77         memcpy(ret, data, len);
  78         return ret;
  79 }
  80
  81 struct socket_info
  82 {
  83         int fd;
  84
  85         int domain;
  86         int type;
  87         int protocol;
  88         int bound;
  89         int bcast;
  90
  91         char *path;
  92         char *tmp_path;
  93
  94         struct sockaddr *myname;
  95         socklen_t myname_len;
  96
  97         struct sockaddr *peername;
  98         socklen_t peername_len;
  99
 100         struct socket_info *prev, *next;
 101 };
 102
 103 static struct socket_info *sockets = NULL;
 104
 105
 106 static const char *socket_wrapper_dir(void)
 107 {
 108         const char *s = getenv("SOCKET_WRAPPER_DIR");
 109         if (s == NULL) {
 110                 return NULL;
 111         }
 112         if (strncmp(s, "./", 2) == 0) {
 113                 s += 2;
 114         }
 115         return s;
 116 }
 117
 118 static unsigned int socket_wrapper_default_iface(void)
 119 {
 120         const char *s = getenv("SOCKET_WRAPPER_DEFAULT_IFACE");
 121         if (s) {
 122                 unsigned int iface;
 123                 if (sscanf(s, "%u", &iface) == 1) {
 124                         if (iface >= 1 && iface <= 0xFF) {
 125                                 return iface;
 126                         }
 127                 }
 128         }
 129
 130         return 1;/* 127.0.0.1 */
 131 }
 132
 133 static int convert_un_in(const struct sockaddr_un *un, struct sockaddr_in *in, socklen_t *len)
 134 {
 135         unsigned int iface;
 136         unsigned int prt;
 137         const char *p;
 138         char type;
 139
 140         if ((*len) < sizeof(struct sockaddr_in)) {
 141                 return 0;
 142         }
 143
 144         p = strrchr(un->sun_path, '/');
 145         if (p) p++; else p = un->sun_path;
 146
 147         if (sscanf(p, SOCKET_FORMAT, &type, &iface, &prt) != 3) {
 148                 errno = EINVAL;
 149                 return -1;
 150         }
 151
 152         if (type != SOCKET_TYPE_CHAR_TCP && type != SOCKET_TYPE_CHAR_UDP) {
 153                 errno = EINVAL;
 154                 return -1;
 155         }
 156
 157         if (iface == 0 || iface > 0xFF) {
 158                 errno = EINVAL;
 159                 return -1;
 160         }
 161
 162         if (prt > 0xFFFF) {
 163                 errno = EINVAL;
 164                 return -1;
 165         }
 166
 167         in->sin_family = AF_INET;
 168         in->sin_addr.s_addr = htonl((127<<24) | iface);
 169         in->sin_port = htons(prt);
 170
 171         *len = sizeof(struct sockaddr_in);
 172         return 0;
 173 }
 174
 175 static int convert_in_un_remote(struct socket_info *si, const struct sockaddr_in *in, struct sockaddr_un *un,
 176                                 int *bcast)
 177 {
 178         char u_type = '\0';
 179         char b_type = '\0';
 180         char a_type = '\0';
 181         char type = '\0';
 182         unsigned int addr= ntohl(in->sin_addr.s_addr);
 183         unsigned int prt = ntohs(in->sin_port);
 184         unsigned int iface;
 185         int is_bcast = 0;
 186
 187         if (bcast) *bcast = 0;
 188
 189         if (prt == 0) {
 190                 errno = EINVAL;
 191                 return -1;
 192         }
 193
 194         switch (si->type) {
 195         case SOCK_STREAM:
 196                 u_type = SOCKET_TYPE_CHAR_TCP;
 197                 break;
 198         case SOCK_DGRAM:
 199                 u_type = SOCKET_TYPE_CHAR_UDP;
 200                 a_type = SOCKET_TYPE_CHAR_UDP;
 201                 b_type = SOCKET_TYPE_CHAR_UDP;
 202                 break;
 203         }
 204
 205         if (a_type && addr == 0xFFFFFFFF) {
 206                 /* 255.255.255.255 only udp */
 207                 is_bcast = 2;
 208                 type = a_type;
 209                 iface = socket_wrapper_default_iface();
 210         } else if (b_type && addr == 0x7FFFFFFF) {
 211                 /* 127.255.255.255 only udp */
 212                 is_bcast = 1;
 213                 type = b_type;
 214                 iface = socket_wrapper_default_iface();
 215         } else if ((addr & 0xFFFFFF00) == 0x7F000000) {
 216                 /* 127.0.0.X */
 217                 is_bcast = 0;
 218                 type = u_type;
 219                 iface = (addr & 0x000000FF);
 220         } else {
 221                 errno = ENETUNREACH;
 222                 return -1;
 223         }
 224
 225         if (bcast) *bcast = is_bcast;
 226
 227         if (is_bcast) {
 228                 snprintf(un->sun_path, sizeof(un->sun_path), "%s/EINVAL",
 229                          socket_wrapper_dir());
 230                 /* the caller need to do more processing */
 231                 return 0;
 232         }
 233
 234         snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
 235                  socket_wrapper_dir(), type, iface, prt);
 236
 237         return 0;
 238 }
 239
 240 static int convert_in_un_alloc(struct socket_info *si, const struct sockaddr_in *in, struct sockaddr_un *un,
 241                                int *bcast)
 242 {
 243         char u_type = '\0';
 244         char d_type = '\0';
 245         char b_type = '\0';
 246         char a_type = '\0';
 247         char type = '\0';
 248         unsigned int addr= ntohl(in->sin_addr.s_addr);
 249         unsigned int prt = ntohs(in->sin_port);
 250         unsigned int iface;
 251         struct stat st;
 252         int is_bcast = 0;
 253
 254         if (bcast) *bcast = 0;
 255
 256         switch (si->type) {
 257         case SOCK_STREAM:
 258                 u_type = SOCKET_TYPE_CHAR_TCP;
 259                 d_type = SOCKET_TYPE_CHAR_TCP;
 260                 break;
 261         case SOCK_DGRAM:
 262                 u_type = SOCKET_TYPE_CHAR_UDP;
 263                 d_type = SOCKET_TYPE_CHAR_UDP;
 264                 a_type = SOCKET_TYPE_CHAR_UDP;
 265                 b_type = SOCKET_TYPE_CHAR_UDP;
 266                 break;
 267         }
 268
 269         if (addr == 0) {
 270                 /* 0.0.0.0 */
 271                 is_bcast = 0;
 272                 type = d_type;
 273                 iface = socket_wrapper_default_iface();
 274         } else if (a_type && addr == 0xFFFFFFFF) {
 275                 /* 255.255.255.255 only udp */
 276                 is_bcast = 2;
 277                 type = a_type;
 278                 iface = socket_wrapper_default_iface();
 279         } else if (b_type && addr == 0x7FFFFFFF) {
 280                 /* 127.255.255.255 only udp */
 281                 is_bcast = 1;
 282                 type = b_type;
 283                 iface = socket_wrapper_default_iface();
 284         } else if ((addr & 0xFFFFFF00) == 0x7F000000) {
 285                 /* 127.0.0.X */
 286                 is_bcast = 0;
 287                 type = u_type;
 288                 iface = (addr & 0x000000FF);
 289         } else {
 290                 errno = EADDRNOTAVAIL;
 291                 return -1;
 292         }
 293
 294         if (bcast) *bcast = is_bcast;
 295
 296         if (prt == 0) {
 297                 /* handle auto-allocation of ephemeral ports */
 298                 for (prt = 5001; prt < 10000; prt++) {
 299                         snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
 300                                  socket_wrapper_dir(), type, iface, prt);
 301                         if (stat(un->sun_path, &st) == 0) continue;
 302
 303                         ((struct sockaddr_in *)si->myname)->sin_port = htons(prt);
 304                         return 0;
 305                 }
 306                 errno = ENFILE;
 307                 return -1;
 308         }
 309
 310         snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
 311                  socket_wrapper_dir(), type, iface, prt);
 312         return 0;
 313 }
 314
 315 static struct socket_info *find_socket_info(int fd)
 316 {
 317         struct socket_info *i;
 318         for (i = sockets; i; i = i->next) {
 319                 if (i->fd == fd)
 320                         return i;
 321         }
 322
 323         return NULL;
 324 }
 325
 326 static int sockaddr_convert_to_un(struct socket_info *si, const struct sockaddr *in_addr, socklen_t in_len,
 327                                   struct sockaddr_un *out_addr, int alloc_sock, int *bcast)
 328 {
 329         if (!out_addr)
 330                 return 0;
 331
 332         out_addr->sun_family = AF_UNIX;
 333
 334         switch (in_addr->sa_family) {
 335         case AF_INET:
 336                 switch (si->type) {
 337                 case SOCK_STREAM:
 338                 case SOCK_DGRAM:
 339                         break;
 340                 default:
 341                         errno = ESOCKTNOSUPPORT;
 342                         return -1;
 343                 }
 344                 if (alloc_sock) {
 345                         return convert_in_un_alloc(si, (const struct sockaddr_in *)in_addr, out_addr, bcast);
 346                 } else {
 347                         return convert_in_un_remote(si, (const struct sockaddr_in *)in_addr, out_addr, bcast);
 348                 }
 349         case AF_UNIX:
 350                 memcpy(out_addr, in_addr, sizeof(*out_addr));
 351                 return 0;
 352         default:
 353                 break;
 354         }
 355
 356         errno = EAFNOSUPPORT;
 357         return -1;
 358 }
 359
 360 static int sockaddr_convert_from_un(const struct socket_info *si,
 361                                     const struct sockaddr_un *in_addr,
 362                                     socklen_t un_addrlen,
 363                                     int family,
 364                                     struct sockaddr *out_addr,
 365                                     socklen_t *_out_addrlen)
 366 {
 367         socklen_t out_addrlen;
 368
 369         if (out_addr == NULL || _out_addrlen == NULL)
 370                 return 0;
 371
 372         if (un_addrlen == 0) {
 373                 *_out_addrlen = 0;
 374                 return 0;
 375         }
 376
 377         out_addrlen = *_out_addrlen;
 378         if (out_addrlen > un_addrlen) {
 379                 out_addrlen = un_addrlen;
 380         }
 381
 382         switch (family) {
 383         case AF_INET:
 384                 switch (si->type) {
 385                 case SOCK_STREAM:
 386                 case SOCK_DGRAM:
 387                         break;
 388                 default:
 389                         errno = ESOCKTNOSUPPORT;
 390                         return -1;
 391                 }
 392                 return convert_un_in(in_addr, (struct sockaddr_in *)out_addr, _out_addrlen);
 393         case AF_UNIX:
 394                 memcpy(out_addr, in_addr, out_addrlen);
 395                 *_out_addrlen = out_addrlen;
 396                 return 0;
 397         default:
 398                 break;
 399         }
 400
 401         errno = EAFNOSUPPORT;
 402         return -1;
 403 }
 404
 405 _PUBLIC_ int swrap_socket(int domain, int type, int protocol)
 406 {
 407         struct socket_info *si;
 408         int fd;
 409
 410         if (!socket_wrapper_dir()) {
 411                 return real_socket(domain, type, protocol);
 412         }
 413
 414         fd = real_socket(AF_UNIX, type, 0);
 415
 416         if (fd == -1) return -1;
 417
 418         si = calloc(1, sizeof(struct socket_info));
 419
 420         si->domain = domain;
 421         si->type = type;
 422         si->protocol = protocol;
 423         si->fd = fd;
 424
 425         DLIST_ADD(sockets, si);
 426
 427         return si->fd;
 428 }
 429
 430 _PUBLIC_ int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
 431 {
 432         struct socket_info *parent_si, *child_si;
 433         int fd;
 434         struct sockaddr_un un_addr;
 435         socklen_t un_addrlen = sizeof(un_addr);
 436         struct sockaddr_un un_my_addr;
 437         socklen_t un_my_addrlen = sizeof(un_my_addr);
 438         struct sockaddr my_addr;
 439         socklen_t my_addrlen = sizeof(my_addr);
 440         int ret;
 441
 442         parent_si = find_socket_info(s);
 443         if (!parent_si) {
 444                 return real_accept(s, addr, addrlen);
 445         }
 446
 447         memset(&un_addr, 0, sizeof(un_addr));
 448         memset(&un_my_addr, 0, sizeof(un_my_addr));
 449         memset(&my_addr, 0, sizeof(my_addr));
 450
 451         ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
 452         if (ret == -1) return ret;
 453
 454         fd = ret;
 455
 456         ret = sockaddr_convert_from_un(parent_si, &un_addr, un_addrlen,
 457                                        parent_si->domain, addr, addrlen);
 458         if (ret == -1) return ret;
 459
 460         child_si = malloc(sizeof(struct socket_info));
 461         memset(child_si, 0, sizeof(*child_si));
 462
 463         child_si->fd = fd;
 464         child_si->domain = parent_si->domain;
 465         child_si->type = parent_si->type;
 466         child_si->protocol = parent_si->protocol;
 467         child_si->bound = 1;
 468
 469         ret = real_getsockname(fd, &un_my_addr, &un_my_addrlen);
 470         if (ret == -1) return ret;
 471
 472         ret = sockaddr_convert_from_un(child_si, &un_my_addr, un_my_addrlen,
 473                                        child_si->domain, &my_addr, &my_addrlen);
 474         if (ret == -1) return ret;
 475
 476         child_si->myname_len = my_addrlen;
 477         child_si->myname = sockaddr_dup(&my_addr, my_addrlen);
 478
 479         child_si->peername_len = *addrlen;
 480         child_si->peername = sockaddr_dup(addr, *addrlen);
 481
 482         DLIST_ADD(sockets, child_si);
 483
 484         return fd;
 485 }
 486
 487 /* using sendto() or connect() on an unbound socket would give the
 488    recipient no way to reply, as unlike UDP and TCP, a unix domain
 489    socket can't auto-assign emphemeral port numbers, so we need to
 490    assign it here */
 491 static int swrap_auto_bind(struct socket_info *si)
 492 {
 493         struct sockaddr_un un_addr;
 494         struct sockaddr_in in;
 495         int i;
 496         char type;
 497         int ret;
 498         struct stat st;
 499
 500         un_addr.sun_family = AF_UNIX;
 501
 502         switch (si->type) {
 503         case SOCK_STREAM:
 504                 type = SOCKET_TYPE_CHAR_TCP;
 505                 break;
 506         case SOCK_DGRAM:
 507                 type = SOCKET_TYPE_CHAR_UDP;
 508                 break;
 509         default:
 510                 errno = ESOCKTNOSUPPORT;
 511                 return -1;
 512         }
 513
 514         for (i=0;i<1000;i++) {
 515                 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path),
 516                          "%s/"SOCKET_FORMAT, socket_wrapper_dir(),
 517                          type, socket_wrapper_default_iface(), i + 10000);
 518                 if (stat(un_addr.sun_path, &st) == 0) continue;
 519
 520                 ret = real_bind(si->fd, (struct sockaddr *)&un_addr, sizeof(un_addr));
 521                 if (ret == -1) return ret;
 522
 523                 si->tmp_path = strdup(un_addr.sun_path);
 524                 si->bound = 1;
 525                 break;
 526         }
 527         if (i == 1000) {
 528                 errno = ENFILE;
 529                 return -1;
 530         }
 531
 532         memset(&in, 0, sizeof(in));
 533         in.sin_family = AF_INET;
 534         in.sin_port   = htons(i);
 535         in.sin_addr.s_addr = htonl(127<<24 | socket_wrapper_default_iface());
 536
 537         si->myname_len = sizeof(in);
 538         si->myname = sockaddr_dup(&in, si->myname_len);
 539         si->bound = 1;
 540         return 0;
 541 }
 542
 543
 544 _PUBLIC_ int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
 545 {
 546         int ret;
 547         struct sockaddr_un un_addr;
 548         struct socket_info *si = find_socket_info(s);
 549
 550         if (!si) {
 551                 return real_connect(s, serv_addr, addrlen);
 552         }
 553
 554         if (si->bound == 0 && si->domain != AF_UNIX) {
 555                 ret = swrap_auto_bind(si);
 556                 if (ret == -1) return -1;
 557         }
 558
 559         ret = sockaddr_convert_to_un(si, (const struct sockaddr *)serv_addr, addrlen, &un_addr, 0, NULL);
 560         if (ret == -1) return -1;
 561
 562         ret = real_connect(s, (struct sockaddr *)&un_addr,
 563                            sizeof(struct sockaddr_un));
 564
 565         /* to give better errors */
 566         if (serv_addr->sa_family == AF_INET) {
 567                 if (ret == -1 && errno == ENOENT) {
 568                         errno = EHOSTUNREACH;
 569                 }
 570         }
 571
 572         if (ret == 0) {
 573                 si->peername_len = addrlen;
 574                 si->peername = sockaddr_dup(serv_addr, addrlen);
 575         }
 576
 577         return ret;
 578 }
 579
 580 _PUBLIC_ int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
 581 {
 582         int ret;
 583         struct sockaddr_un un_addr;
 584         struct socket_info *si = find_socket_info(s);
 585
 586         if (!si) {
 587                 return real_bind(s, myaddr, addrlen);
 588         }
 589
 590         si->myname_len = addrlen;
 591         si->myname = sockaddr_dup(myaddr, addrlen);
 592
 593         ret = sockaddr_convert_to_un(si, (const struct sockaddr *)myaddr, addrlen, &un_addr, 1, &si->bcast);
 594         if (ret == -1) return -1;
 595
 596         unlink(un_addr.sun_path);
 597
 598         ret = real_bind(s, (struct sockaddr *)&un_addr,
 599                         sizeof(struct sockaddr_un));
 600
 601         if (ret == 0) {
 602                 si->bound = 1;
 603         }
 604
 605         return ret;
 606 }
 607
 608 _PUBLIC_ int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
 609 {
 610         struct socket_info *si = find_socket_info(s);
 611
 612         if (!si) {
 613                 return real_getpeername(s, name, addrlen);
 614         }
 615
 616         if (!si->peername)
 617         {
 618                 errno = ENOTCONN;
 619                 return -1;
 620         }
 621
 622         memcpy(name, si->peername, si->peername_len);
 623         *addrlen = si->peername_len;
 624
 625         return 0;
 626 }
 627
 628 _PUBLIC_ int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
 629 {
 630         struct socket_info *si = find_socket_info(s);
 631
 632         if (!si) {
 633                 return real_getsockname(s, name, addrlen);
 634         }
 635
 636         memcpy(name, si->myname, si->myname_len);
 637         *addrlen = si->myname_len;
 638
 639         return 0;
 640 }
 641
 642 _PUBLIC_ int swrap_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
 643 {
 644         struct socket_info *si = find_socket_info(s);
 645
 646         if (!si) {
 647                 return real_getsockopt(s, level, optname, optval, optlen);
 648         }
 649
 650         if (level == SOL_SOCKET) {
 651                 return real_getsockopt(s, level, optname, optval, optlen);
 652         }
 653
 654         switch (si->domain) {
 655         case AF_UNIX:
 656                 return real_getsockopt(s, level, optname, optval, optlen);
 657         default:
 658                 errno = ENOPROTOOPT;
 659                 return -1;
 660         }
 661 }
 662
 663 _PUBLIC_ int swrap_setsockopt(int s, int  level,  int  optname,  const  void  *optval, socklen_t optlen)
 664 {
 665         struct socket_info *si = find_socket_info(s);
 666
 667         if (!si) {
 668                 return real_setsockopt(s, level, optname, optval, optlen);
 669         }
 670
 671         if (level == SOL_SOCKET) {
 672                 return real_setsockopt(s, level, optname, optval, optlen);
 673         }
 674
 675         switch (si->domain) {
 676         case AF_UNIX:
 677                 return real_setsockopt(s, level, optname, optval, optlen);
 678         case AF_INET:
 679                 /* Silence some warnings */
 680 #ifdef TCP_NODELAY
 681                 if (optname == TCP_NODELAY)
 682                         return 0;
 683 #endif
 684         default:
 685                 errno = ENOPROTOOPT;
 686                 return -1;
 687         }
 688 }
 689
 690 _PUBLIC_ ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
 691 {
 692         struct sockaddr_un un_addr;
 693         socklen_t un_addrlen = sizeof(un_addr);
 694         int ret;
 695         struct socket_info *si = find_socket_info(s);
 696
 697         if (!si) {
 698                 return real_recvfrom(s, buf, len, flags, from, fromlen);
 699         }
 700
 701         /* irix 6.4 forgets to null terminate the sun_path string :-( */
 702         memset(&un_addr, 0, sizeof(un_addr));
 703         ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
 704         if (ret == -1)
 705                 return ret;
 706
 707         if (sockaddr_convert_from_un(si, &un_addr, un_addrlen,
 708                                      si->domain, from, fromlen) == -1) {
 709                 return -1;
 710         }
 711
 712         return ret;
 713 }
 714
 715
 716 _PUBLIC_ ssize_t swrap_sendto(int  s,  const  void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
 717 {
 718         struct sockaddr_un un_addr;
 719         int ret;
 720         struct socket_info *si = find_socket_info(s);
 721         int bcast = 0;
 722
 723         if (!si) {
 724                 return real_sendto(s, buf, len, flags, to, tolen);
 725         }
 726
 727         if (si->bound == 0 && si->domain != AF_UNIX) {
 728                 ret = swrap_auto_bind(si);
 729                 if (ret == -1) return -1;
 730         }
 731
 732         ret = sockaddr_convert_to_un(si, to, tolen, &un_addr, 0, &bcast);
 733         if (ret == -1) return -1;
 734
 735         if (bcast) {
 736                 struct stat st;
 737                 unsigned int iface;
 738                 unsigned int prt = ntohs(((const struct sockaddr_in *)to)->sin_port);
 739                 char type;
 740
 741                 type = SOCKET_TYPE_CHAR_UDP;
 742
 743                 for(iface=0; iface <= 0xFF; iface++) {
 744                         snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/"SOCKET_FORMAT,
 745                                  socket_wrapper_dir(), type, iface, prt);
 746                         if (stat(un_addr.sun_path, &st) != 0) continue;
 747
 748                         /* ignore the any errors in broadcast sends */
 749                         real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
 750                 }
 751                 return len;
 752         }
 753
 754         ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
 755
 756         /* to give better errors */
 757         if (to->sa_family == AF_INET) {
 758                 if (ret == -1 && errno == ENOENT) {
 759                         errno = EHOSTUNREACH;
 760                 }
 761         }
 762
 763         return ret;
 764 }
 765
 766 _PUBLIC_ int swrap_close(int fd)
 767 {
 768         struct socket_info *si = find_socket_info(fd);
 769
 770         if (si) {
 771                 DLIST_REMOVE(sockets, si);
 772
 773                 free(si->path);
 774                 free(si->myname);
 775                 free(si->peername);
 776                 if (si->tmp_path) {
 777                         unlink(si->tmp_path);
 778                         free(si->tmp_path);
 779                 }
 780                 free(si);
 781         }
 782
 783         return real_close(fd);
 784 }