source4/lib/socket_wrapper/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 #ifdef _SAMBA_BUILD_
  23 #include "includes.h"
  24 #undef SOCKET_WRAPPER
  25 #include "system/network.h"
  26 #include "system/filesys.h"
  27 #else
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <sys/socket.h>
  31 #include <errno.h>
  32 #include <sys/un.h>
  33 #include <netinet/in.h>
  34 #include <netinet/tcp.h>
  35 #include <stdlib.h>
  36 #include <unistd.h>
  37 #include <string.h>
  38 #include <stdio.h>
  39 #endif
  40 #include "dlinklist.h"
  41
  42 /* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
  43  * for now */
  44 #define REWRITE_CALLS
  45
  46 #ifdef REWRITE_CALLS
  47 #define real_accept accept
  48 #define real_connect connect
  49 #define real_bind bind
  50 #define real_getpeername getpeername
  51 #define real_getsockname getsockname
  52 #define real_getsockopt getsockopt
  53 #define real_setsockopt setsockopt
  54 #define real_recvfrom recvfrom
  55 #define real_sendto sendto
  56 #define real_socket socket
  57 #define real_close close
  58 #endif
  59
  60 /* we need to use a very terse format here as IRIX 6.4 silently
  61    truncates names to 16 chars, so if we use a longer name then we
  62    can't tell which port a packet came from with recvfrom()
  63
  64    with this format we have 8 chars left for the directory name
  65 */
  66 #define SOCKET_FORMAT "%u_%u"
  67
  68 static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
  69 {
  70         struct sockaddr *ret = (struct sockaddr *)malloc(len);
  71         memcpy(ret, data, len);
  72         return ret;
  73 }
  74
  75 struct socket_info
  76 {
  77         int fd;
  78
  79         int domain;
  80         int type;
  81         int protocol;
  82         int bound;
  83
  84         char *path;
  85         char *tmp_path;
  86
  87         struct sockaddr *myname;
  88         socklen_t myname_len;
  89
  90         struct sockaddr *peername;
  91         socklen_t peername_len;
  92
  93         struct socket_info *prev, *next;
  94 };
  95
  96 static struct socket_info *sockets = NULL;
  97
  98
  99 static const char *socket_wrapper_dir(void)
 100 {
 101         const char *s = getenv("SOCKET_WRAPPER_DIR");
 102         if (s == NULL) {
 103                 return NULL;
 104         }
 105         if (strncmp(s, "./", 2) == 0) {
 106                 s += 2;
 107         }
 108         return s;
 109 }
 110
 111 static int convert_un_in(const struct sockaddr_un *un, struct sockaddr_in *in, socklen_t *len)
 112 {
 113         unsigned int prt;
 114         const char *p;
 115         int type;
 116
 117         if ((*len) < sizeof(struct sockaddr_in)) {
 118                 return 0;
 119         }
 120
 121         in->sin_family = AF_INET;
 122         in->sin_port = htons(1025); /* Default to 1025 */
 123         p = strrchr(un->sun_path, '/');
 124         if (p) p++; else p = un->sun_path;
 125
 126         if (sscanf(p, SOCKET_FORMAT, &type, &prt) == 2) {
 127                 in->sin_port = htons(prt);
 128         }
 129         in->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 130         *len = sizeof(struct sockaddr_in);
 131         return 0;
 132 }
 133
 134 static int convert_in_un(struct socket_info *si, const struct sockaddr_in *in, struct sockaddr_un *un)
 135 {
 136         int type = si->type;
 137         uint16_t prt = ntohs(in->sin_port);
 138         if (prt == 0) {
 139                 struct stat st;
 140                 /* handle auto-allocation of ephemeral ports */
 141                 prt = 5000;
 142                 do {
 143                         snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
 144                                  socket_wrapper_dir(), type, ++prt);
 145                 } while (stat(un->sun_path, &st) == 0 && prt < 10000);
 146                 ((struct sockaddr_in *)si->myname)->sin_port = htons(prt);
 147         }
 148         snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT,
 149                  socket_wrapper_dir(), type, prt);
 150         return 0;
 151 }
 152
 153 static struct socket_info *find_socket_info(int fd)
 154 {
 155         struct socket_info *i;
 156         for (i = sockets; i; i = i->next) {
 157                 if (i->fd == fd)
 158                         return i;
 159         }
 160
 161         return NULL;
 162 }
 163
 164 static int sockaddr_convert_to_un(struct socket_info *si, const struct sockaddr *in_addr, socklen_t in_len,
 165                                          struct sockaddr_un *out_addr)
 166 {
 167         if (!out_addr)
 168                 return 0;
 169
 170         out_addr->sun_family = AF_UNIX;
 171
 172         switch (in_addr->sa_family) {
 173         case AF_INET:
 174                 return convert_in_un(si, (const struct sockaddr_in *)in_addr, out_addr);
 175         case AF_UNIX:
 176                 memcpy(out_addr, in_addr, sizeof(*out_addr));
 177                 return 0;
 178         default:
 179                 break;
 180         }
 181
 182         errno = EAFNOSUPPORT;
 183         return -1;
 184 }
 185
 186 static int sockaddr_convert_from_un(const struct socket_info *si,
 187                                     const struct sockaddr_un *in_addr,
 188                                     socklen_t un_addrlen,
 189                                     int family,
 190                                     struct sockaddr *out_addr,
 191                                     socklen_t *out_len)
 192 {
 193         if (out_addr == NULL || out_len == NULL)
 194                 return 0;
 195
 196         if (un_addrlen == 0) {
 197                 *out_len = 0;
 198                 return 0;
 199         }
 200
 201         switch (family) {
 202         case AF_INET:
 203                 return convert_un_in(in_addr, (struct sockaddr_in *)out_addr, out_len);
 204         case AF_UNIX:
 205                 memcpy(out_addr, in_addr, sizeof(*in_addr));
 206                 *out_len = sizeof(*in_addr);
 207                 return 0;
 208         default:
 209                 break;
 210         }
 211
 212         errno = EAFNOSUPPORT;
 213         return -1;
 214 }
 215
 216 int swrap_socket(int domain, int type, int protocol)
 217 {
 218         struct socket_info *si;
 219         int fd;
 220
 221         if (!socket_wrapper_dir()) {
 222                 return real_socket(domain, type, protocol);
 223         }
 224
 225         fd = real_socket(AF_UNIX, type, 0);
 226
 227         if (fd == -1) return -1;
 228
 229         si = calloc(1, sizeof(struct socket_info));
 230
 231         si->domain = domain;
 232         si->type = type;
 233         si->protocol = protocol;
 234         si->fd = fd;
 235
 236         DLIST_ADD(sockets, si);
 237
 238         return si->fd;
 239 }
 240
 241 int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
 242 {
 243         struct socket_info *parent_si, *child_si;
 244         int fd;
 245         socklen_t un_addrlen = sizeof(struct sockaddr_un);
 246         struct sockaddr_un un_addr;
 247         int ret;
 248
 249         parent_si = find_socket_info(s);
 250         if (!parent_si) {
 251                 return real_accept(s, addr, addrlen);
 252         }
 253
 254         memset(&un_addr, 0, sizeof(un_addr));
 255
 256         ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
 257         if (ret == -1) return ret;
 258
 259         fd = ret;
 260
 261         ret = sockaddr_convert_from_un(parent_si, &un_addr, un_addrlen,
 262                                        parent_si->domain, addr, addrlen);
 263         if (ret == -1) return ret;
 264
 265         child_si = malloc(sizeof(struct socket_info));
 266         memset(child_si, 0, sizeof(*child_si));
 267
 268         child_si->fd = fd;
 269         child_si->bound = 1;
 270
 271         child_si->myname_len = parent_si->myname_len;
 272         child_si->myname = sockaddr_dup(parent_si->myname, parent_si->myname_len);
 273
 274         child_si->peername_len = *addrlen;
 275         child_si->peername = sockaddr_dup(addr, *addrlen);
 276
 277         DLIST_ADD(sockets, child_si);
 278
 279         return fd;
 280 }
 281
 282 /* using sendto() or connect() on an unbound socket would give the
 283    recipient no way to reply, as unlike UDP and TCP, a unix domain
 284    socket can't auto-assign emphemeral port numbers, so we need to
 285    assign it here */
 286 static int swrap_auto_bind(struct socket_info *si)
 287 {
 288         struct sockaddr_un un_addr;
 289         struct sockaddr_in in;
 290         int i;
 291
 292         un_addr.sun_family = AF_UNIX;
 293
 294         for (i=0;i<1000;i++) {
 295                 snprintf(un_addr.sun_path, sizeof(un_addr.sun_path),
 296                          "%s/"SOCKET_FORMAT, socket_wrapper_dir(),
 297                          SOCK_DGRAM, i + 10000);
 298                 if (bind(si->fd, (struct sockaddr *)&un_addr,
 299                          sizeof(un_addr)) == 0) {
 300                         si->tmp_path = strdup(un_addr.sun_path);
 301                         si->bound = 1;
 302                         break;
 303                 }
 304         }
 305         if (i == 1000) {
 306                 return -1;
 307         }
 308
 309         memset(&in, 0, sizeof(in));
 310         in.sin_family = AF_INET;
 311         in.sin_port   = htons(i);
 312         in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 313
 314         si->myname_len = sizeof(in);
 315         si->myname = sockaddr_dup(&in, si->myname_len);
 316         si->bound = 1;
 317         return 0;
 318 }
 319
 320
 321 int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
 322 {
 323         int ret;
 324         struct sockaddr_un un_addr;
 325         struct socket_info *si = find_socket_info(s);
 326
 327         if (!si) {
 328                 return real_connect(s, serv_addr, addrlen);
 329         }
 330
 331         /* only allow pseudo loopback connections */
 332         if (serv_addr->sa_family == AF_INET &&
 333                 ((const struct sockaddr_in *)serv_addr)->sin_addr.s_addr !=
 334             htonl(INADDR_LOOPBACK)) {
 335                 errno = ENETUNREACH;
 336                 return -1;
 337         }
 338
 339         if (si->bound == 0 && si->domain != AF_UNIX) {
 340                 ret = swrap_auto_bind(si);
 341                 if (ret == -1) return -1;
 342         }
 343
 344         ret = sockaddr_convert_to_un(si, (const struct sockaddr *)serv_addr, addrlen, &un_addr);
 345         if (ret == -1) return -1;
 346
 347         ret = real_connect(s, (struct sockaddr *)&un_addr,
 348                            sizeof(struct sockaddr_un));
 349
 350         if (ret == 0) {
 351                 si->peername_len = addrlen;
 352                 si->peername = sockaddr_dup(serv_addr, addrlen);
 353         }
 354
 355         return ret;
 356 }
 357
 358 int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
 359 {
 360         int ret;
 361         struct sockaddr_un un_addr;
 362         struct socket_info *si = find_socket_info(s);
 363
 364         if (!si) {
 365                 return real_bind(s, myaddr, addrlen);
 366         }
 367
 368         si->myname_len = addrlen;
 369         si->myname = sockaddr_dup(myaddr, addrlen);
 370
 371         if (myaddr->sa_family == AF_INET &&
 372             ((const struct sockaddr_in *)myaddr)->sin_addr.s_addr == 0) {
 373                 ((struct sockaddr_in *)si->myname)->sin_addr.s_addr =
 374                         htonl(INADDR_LOOPBACK);
 375         }
 376         ret = sockaddr_convert_to_un(si, (const struct sockaddr *)myaddr, addrlen, &un_addr);
 377         if (ret == -1) return -1;
 378
 379         unlink(un_addr.sun_path);
 380
 381         ret = real_bind(s, (struct sockaddr *)&un_addr,
 382                         sizeof(struct sockaddr_un));
 383
 384         if (ret == 0) {
 385                 si->bound = 1;
 386         }
 387
 388         return ret;
 389 }
 390
 391 int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
 392 {
 393         struct socket_info *si = find_socket_info(s);
 394
 395         if (!si) {
 396                 return real_getpeername(s, name, addrlen);
 397         }
 398
 399         if (!si->peername)
 400         {
 401                 errno = ENOTCONN;
 402                 return -1;
 403         }
 404
 405         memcpy(name, si->peername, si->peername_len);
 406         *addrlen = si->peername_len;
 407
 408         return 0;
 409 }
 410
 411 int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
 412 {
 413         struct socket_info *si = find_socket_info(s);
 414
 415         if (!si) {
 416                 return real_getsockname(s, name, addrlen);
 417         }
 418
 419         memcpy(name, si->myname, si->myname_len);
 420         *addrlen = si->myname_len;
 421
 422         return 0;
 423 }
 424
 425 int swrap_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
 426 {
 427         struct socket_info *si = find_socket_info(s);
 428
 429         if (!si) {
 430                 return real_getsockopt(s, level, optname, optval, optlen);
 431         }
 432
 433         if (level == SOL_SOCKET) {
 434                 return real_getsockopt(s, level, optname, optval, optlen);
 435         }
 436
 437         switch (si->domain) {
 438         case AF_UNIX:
 439                 return real_getsockopt(s, level, optname, optval, optlen);
 440         default:
 441                 errno = ENOPROTOOPT;
 442                 return -1;
 443         }
 444 }
 445
 446 int swrap_setsockopt(int s, int  level,  int  optname,  const  void  *optval, socklen_t optlen)
 447 {
 448         struct socket_info *si = find_socket_info(s);
 449
 450         if (!si) {
 451                 return real_setsockopt(s, level, optname, optval, optlen);
 452         }
 453
 454         if (level == SOL_SOCKET) {
 455                 return real_setsockopt(s, level, optname, optval, optlen);
 456         }
 457
 458         switch (si->domain) {
 459         case AF_UNIX:
 460                 return real_setsockopt(s, level, optname, optval, optlen);
 461         case AF_INET:
 462                 /* Silence some warnings */
 463 #ifdef TCP_NODELAY
 464                 if (optname == TCP_NODELAY)
 465                         return 0;
 466 #endif
 467         default:
 468                 errno = ENOPROTOOPT;
 469                 return -1;
 470         }
 471 }
 472
 473 ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
 474 {
 475         struct sockaddr_un un_addr;
 476         socklen_t un_addrlen = sizeof(un_addr);
 477         int ret;
 478         struct socket_info *si = find_socket_info(s);
 479
 480         if (!si) {
 481                 return real_recvfrom(s, buf, len, flags, from, fromlen);
 482         }
 483
 484         /* irix 6.4 forgets to null terminate the sun_path string :-( */
 485         memset(&un_addr, 0, sizeof(un_addr));
 486         ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
 487         if (ret == -1)
 488                 return ret;
 489
 490         if (sockaddr_convert_from_un(si, &un_addr, un_addrlen,
 491                                      si->domain, from, fromlen) == -1) {
 492                 return -1;
 493         }
 494
 495         return ret;
 496 }
 497
 498
 499 ssize_t swrap_sendto(int  s,  const  void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
 500 {
 501         struct sockaddr_un un_addr;
 502         int ret;
 503         struct socket_info *si = find_socket_info(s);
 504
 505         if (!si) {
 506                 return real_sendto(s, buf, len, flags, to, tolen);
 507         }
 508
 509         if (si->bound == 0 && si->domain != AF_UNIX) {
 510                 ret = swrap_auto_bind(si);
 511                 if (ret == -1) return -1;
 512         }
 513
 514         ret = sockaddr_convert_to_un(si, to, tolen, &un_addr);
 515         if (ret == -1) return -1;
 516
 517         ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
 518
 519         return ret;
 520 }
 521
 522 int swrap_close(int fd)
 523 {
 524         struct socket_info *si = find_socket_info(fd);
 525
 526         if (si) {
 527                 DLIST_REMOVE(sockets, si);
 528
 529                 free(si->path);
 530                 free(si->myname);
 531                 free(si->peername);
 532                 if (si->tmp_path) {
 533                         unlink(si->tmp_path);
 534                         free(si->tmp_path);
 535                 }
 536                 free(si);
 537         }
 538
 539         return real_close(fd);
 540 }