source4/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 #ifdef SAMBA_MAJOR_VERSION
  23 #include "includes.h"
  24 #include "system/network.h"
  25 #else
  26 #include <sys/types.h>
  27 #include <sys/socket.h>
  28 #include <errno.h>
  29 #include <sys/un.h>
  30 #include <netinet/in.h>
  31 #include <stdlib.h>
  32 #include <unistd.h>
  33 #include <string.h>
  34 #include <stdio.h>
  35 #include "dlinklist.h"
  36 #endif
  37
  38 /* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
  39  * for now */
  40 #define REWRITE_CALLS
  41
  42 #ifdef REWRITE_CALLS
  43 #define real_accept accept
  44 #define real_connect connect
  45 #define real_bind bind
  46 #define real_getpeername getpeername
  47 #define real_getsockname getsockname
  48 #define real_getsockopt getsockopt
  49 #define real_setsockopt setsockopt
  50 #define real_recvfrom recvfrom
  51 #define real_sendto sendto
  52 #define real_socket socket
  53 #define real_close close
  54 #endif
  55
  56 static struct sockaddr *memdup(const void *data, socklen_t len)
  57 {
  58         struct sockaddr *ret = (struct sockaddr *)malloc(len);
  59         memcpy(ret, data, len);
  60         return ret;
  61 }
  62
  63 struct socket_info
  64 {
  65         int fd;
  66
  67         int domain;
  68         int type;
  69         int protocol;
  70
  71         char *path;
  72
  73         struct sockaddr *myname;
  74         socklen_t myname_len;
  75
  76         struct sockaddr *peername;
  77         socklen_t peername_len;
  78
  79         struct socket_info *prev, *next;
  80 } *sockets = NULL;
  81
  82 static int convert_un_in(const struct sockaddr_un *un, struct sockaddr_in *in, socklen_t *len)
  83 {
  84         unsigned int prt;
  85         const char *p;
  86
  87         if ((*len) < sizeof(struct sockaddr_in)) {
  88                 return 0;
  89         }
  90
  91         in->sin_family = AF_INET;
  92         in->sin_port = 1025; /* Default to 1025 */
  93         p = strchr(un->sun_path, '/');
  94         if (p) p++; else p = un->sun_path;
  95
  96         if(sscanf(p, "sock_ip_%u", &prt) == 1)
  97         {
  98                 in->sin_port = htons(prt);
  99         }
 100         in->sin_addr.s_addr = INADDR_LOOPBACK;
 101         *len = sizeof(struct sockaddr_in);
 102         return 0;
 103 }
 104
 105 static int convert_in_un(const struct sockaddr_in *in, struct sockaddr_un *un)
 106 {
 107         uint16_t prt = ntohs(in->sin_port);
 108         /* FIXME: ENETUNREACH if in->sin_addr is not loopback */
 109         un->sun_family = AF_LOCAL;
 110         snprintf(un->sun_path, sizeof(un->sun_path), "%s/sock_ip_%u", getenv("SOCKET_WRAPPER_DIR"), prt);
 111         return 0;
 112 }
 113
 114 static struct socket_info *find_socket_info(int fd)
 115 {
 116         struct socket_info *i;
 117         for (i = sockets; i; i = i->next) {
 118                 if (i->fd == fd)
 119                         return i;
 120         }
 121
 122         return NULL;
 123 }
 124
 125 static int sockaddr_convert_to_un(const struct sockaddr *in_addr, socklen_t in_len,
 126                                          struct sockaddr_un *out_addr)
 127 {
 128         if (!out_addr)
 129                 return 0;
 130
 131         switch (in_addr->sa_family) {
 132         case AF_INET:
 133                 return convert_in_un((const struct sockaddr_in *)in_addr, out_addr);
 134         case AF_LOCAL:
 135                 memcpy(out_addr, in_addr, sizeof(*out_addr));
 136                 return 0;
 137         default:
 138                 break;
 139         }
 140
 141         errno = EAFNOSUPPORT;
 142         return -1;
 143 }
 144
 145 static int sockaddr_convert_from_un(const struct sockaddr_un *in_addr,
 146                                                                         int family,
 147                                                  struct sockaddr *out_addr,
 148                                                  socklen_t *out_len)
 149 {
 150         if (!out_addr)
 151                 return 0;
 152
 153         switch (family) {
 154         case AF_INET:
 155                 return convert_un_in(in_addr, (struct sockaddr_in *)out_addr, out_len);
 156         case AF_LOCAL:
 157                 memcpy(out_addr, in_addr, sizeof(*in_addr));
 158                 *out_len = sizeof(*in_addr);
 159                 return 0;
 160         default:
 161                 break;
 162         }
 163
 164         errno = EAFNOSUPPORT;
 165         return -1;
 166 }
 167
 168 int swrap_socket(int domain, int type, int protocol)
 169 {
 170         struct socket_info *si;
 171         int fd;
 172
 173         if (!getenv("SOCKET_WRAPPER_DIR")) {
 174                 return real_socket(domain, type, protocol);
 175         }
 176
 177         fd = real_socket(PF_LOCAL, type, 0);
 178
 179         if (fd < 0)
 180                 return fd;
 181
 182         si = malloc(sizeof(struct socket_info));
 183         memset(si, 0, sizeof(*si));
 184
 185         si->domain = domain;
 186         si->type = type;
 187         si->protocol = protocol;
 188         si->fd = fd;
 189
 190         DLIST_ADD(sockets, si);
 191
 192         return si->fd;
 193 }
 194
 195 int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
 196 {
 197         struct socket_info *parent_si, *child_si;
 198         int fd;
 199         socklen_t un_addrlen = sizeof(struct sockaddr_un);
 200         struct sockaddr_un un_addr;
 201         int ret;
 202
 203         parent_si = find_socket_info(s);
 204         if (!parent_si) {
 205                 return real_accept(s, addr, addrlen);
 206         }
 207
 208         ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
 209         if (ret < 0) return ret;
 210
 211         fd = ret;
 212
 213         ret = sockaddr_convert_from_un(&un_addr, parent_si->domain, addr, addrlen);
 214
 215         if (ret < 0) return ret;
 216
 217         child_si = malloc(sizeof(struct socket_info));
 218         memset(child_si, 0, sizeof(*child_si));
 219
 220         child_si->fd = fd;
 221
 222         if (addr && addrlen) {
 223                 child_si->myname_len = *addrlen;
 224                 child_si->myname = memdup(addr, *addrlen);
 225         }
 226
 227         return fd;
 228 }
 229
 230 int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
 231 {
 232         int ret;
 233         struct sockaddr_un un_addr;
 234         struct socket_info *si = find_socket_info(s);
 235
 236         if (!si) {
 237                 return real_connect(s, serv_addr, addrlen);
 238         }
 239
 240         ret = sockaddr_convert_to_un((const struct sockaddr *)serv_addr, addrlen, &un_addr);
 241         if (ret < 0) return ret;
 242
 243         ret = real_connect(s,
 244                                            (struct sockaddr *)&un_addr,
 245                                            sizeof(struct sockaddr_un));
 246
 247         if (ret >= 0) {
 248                 si->peername_len = addrlen;
 249                 si->peername = memdup(serv_addr, addrlen);
 250         }
 251
 252         return ret;
 253 }
 254
 255 int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
 256 {
 257         int ret;
 258         struct sockaddr_un un_addr;
 259         struct socket_info *si = find_socket_info(s);
 260
 261         if (!si) {
 262                 return real_bind(s, myaddr, addrlen);
 263         }
 264
 265         ret = sockaddr_convert_to_un((const struct sockaddr *)myaddr, addrlen, &un_addr);
 266         if (ret < 0) return ret;
 267
 268         unlink(un_addr.sun_path);
 269
 270         ret = real_bind(s,
 271                                         (struct sockaddr *)&un_addr,
 272                                         sizeof(struct sockaddr_un));
 273
 274         if (ret >= 0) {
 275                 si->myname_len = addrlen;
 276                 si->myname = memdup(myaddr, addrlen);
 277         }
 278
 279         return ret;
 280 }
 281
 282 int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
 283 {
 284         struct socket_info *si = find_socket_info(s);
 285
 286         if (!si) {
 287                 return real_getpeername(s, name, addrlen);
 288         }
 289
 290         if (!si->peername)
 291         {
 292                 errno = ENOTCONN;
 293                 return -1;
 294         }
 295
 296         memcpy(name, si->peername, si->peername_len);
 297         *addrlen = si->peername_len;
 298
 299         return 0;
 300 }
 301
 302 int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
 303 {
 304         struct socket_info *si = find_socket_info(s);
 305
 306         if (!si) {
 307                 return real_getpeername(s, name, addrlen);
 308         }
 309
 310         memcpy(name, si->myname, si->myname_len);
 311         *addrlen = si->myname_len;
 312
 313         return 0;
 314 }
 315
 316 int swrap_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
 317 {
 318         struct socket_info *si = find_socket_info(s);
 319
 320         if (!si) {
 321                 return real_getsockopt(s, level, optname, optval, optlen);
 322         }
 323
 324         if (level != SOL_SOCKET) {
 325                 errno = ENOPROTOOPT;
 326                 return -1;
 327         }
 328
 329         return real_getsockopt(s, level, optname, optval, optlen);
 330 }
 331
 332 int swrap_setsockopt(int s, int  level,  int  optname,  const  void  *optval, socklen_t optlen)
 333 {
 334         struct socket_info *si = find_socket_info(s);
 335
 336         if (!si) {
 337                 return real_setsockopt(s, level, optname, optval, optlen);
 338         }
 339
 340         if (level != SOL_SOCKET) {
 341                 errno = ENOPROTOOPT;
 342                 return -1;
 343         }
 344
 345         return real_setsockopt(s, level, optname, optval, optlen);
 346 }
 347
 348 ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
 349 {
 350         socklen_t un_addrlen;
 351         struct sockaddr_un un_addr;
 352         int ret;
 353         struct socket_info *si = find_socket_info(s);
 354
 355         if (!si) {
 356                 return real_recvfrom(s, buf, len, flags, from, fromlen);
 357         }
 358
 359         ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
 360         if (ret < 0)
 361                 return ret;
 362
 363         ret = sockaddr_convert_from_un(&un_addr, si->domain, from, fromlen);
 364
 365         return ret;
 366 }
 367
 368 ssize_t swrap_sendto(int  s,  const  void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
 369 {
 370         struct sockaddr_un un_addr;
 371         int ret;
 372         struct socket_info *si = find_socket_info(s);
 373
 374         if (!si) {
 375                 return real_sendto(s, buf, len, flags, to, tolen);
 376         }
 377
 378         ret = sockaddr_convert_to_un(to, tolen, &un_addr);
 379         if (ret < 0)
 380                 return ret;
 381
 382         ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
 383
 384         return ret;
 385 }
 386
 387 int swrap_close(int fd)
 388 {
 389         struct socket_info *si = find_socket_info(fd);
 390
 391         if (si) {
 392                 DLIST_REMOVE(sockets, si);
 393
 394                 free(si->path);
 395                 free(si->myname);
 396                 free(si->peername);
 397                 free(si);
 398         }
 399
 400         return real_close(fd);
 401 }