socket.c

   1 /* -*- c-file-style: "linux" -*-
   2
   3    Copyright (C) 1992-2001 by Andrew Tridgell <tridge@samba.org>
   4    Copyright (C) 2001 by Martin Pool <mbp@samba.org>
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 /**
  22  * @file socket.c
  23  *
  24  * Socket functions used in rsync.
  25  **/
  26
  27 #include "rsync.h"
  28
  29 /* Establish a proxy connection on an open socket to a web roxy by
  30  * using the CONNECT method. */
  31 static int establish_proxy_connection(int fd, char *host, int port)
  32 {
  33         char buffer[1024];
  34         char *cp;
  35
  36         snprintf(buffer, sizeof(buffer), "CONNECT %s:%d HTTP/1.0\r\n\r\n", host, port);
  37         if (write(fd, buffer, strlen(buffer)) != strlen(buffer)) {
  38                 rprintf(FERROR, "failed to write to proxy: %s\n",
  39                         strerror(errno));
  40                 return -1;
  41         }
  42
  43         for (cp = buffer; cp < &buffer[sizeof(buffer) - 1]; cp++) {
  44                 if (read(fd, cp, 1) != 1) {
  45                         rprintf(FERROR, "failed to read from proxy: %s\n",
  46                                 strerror(errno));
  47                         return -1;
  48                 }
  49                 if (*cp == '\n')
  50                         break;
  51         }
  52
  53         if (*cp != '\n')
  54                 cp++;
  55         *cp-- = '\0';
  56         if (*cp == '\r')
  57                 *cp = '\0';
  58         if (strncmp(buffer, "HTTP/", 5) != 0) {
  59                 rprintf(FERROR, "bad response from proxy - %s\n",
  60                         buffer);
  61                 return -1;
  62         }
  63         for (cp = &buffer[5]; isdigit(*cp) || (*cp == '.'); cp++)
  64                 ;
  65         while (*cp == ' ')
  66                 cp++;
  67         if (*cp != '2') {
  68                 rprintf(FERROR, "bad response from proxy - %s\n",
  69                         buffer);
  70                 return -1;
  71         }
  72         /* throw away the rest of the HTTP header */
  73         while (1) {
  74                 for (cp = buffer; cp < &buffer[sizeof(buffer) - 1];
  75                      cp++) {
  76                         if (read(fd, cp, 1) != 1) {
  77                                 rprintf(FERROR, "failed to read from proxy: %s\n",
  78                                         strerror(errno));
  79                                 return -1;
  80                         }
  81                         if (*cp == '\n')
  82                                 break;
  83                 }
  84                 if ((cp > buffer) && (*cp == '\n'))
  85                         cp--;
  86                 if ((cp == buffer) && ((*cp == '\n') || (*cp == '\r')))
  87                         break;
  88         }
  89         return 0;
  90 }
  91
  92
  93
  94 /**
  95  * Open a socket to a tcp remote host with the specified port .
  96  *
  97  * Based on code from Warren.  Proxy support by Stephen Rothwell.
  98  * getaddrinfo() rewrite contributed by KAME.net.
  99  *
 100  * Now that we support IPv6 we need to look up the remote machine's
 101  * address first, using @p af_hint to set a preference for the type
 102  * of address.  Then depending on whether it has v4 or v6 addresses we
 103  * try to open a connection.
 104  *
 105  * The loop allows for machines with some addresses which may not be
 106  * reachable, perhaps because we can't e.g. route ipv6 to that network
 107  * but we can get ip4 packets through.
 108  *
 109  * @param bind_address Local address to use.  Normally NULL to bind
 110  * the wildcard address.
 111  *
 112  * @param af_hint Address family, e.g. AF_INET or AF_INET6.
 113  **/
 114 int open_socket_out(char *host, int port, const char *bind_address,
 115                     int af_hint)
 116 {
 117         int type = SOCK_STREAM;
 118         int error;
 119         int s;
 120         int result;
 121         struct addrinfo hints, *res0, *res;
 122         char portbuf[10];
 123         char *h;
 124         int proxied = 0;
 125         char buffer[1024];
 126         char *cp;
 127
 128         /* if we have a RSYNC_PROXY env variable then redirect our
 129          * connetcion via a web proxy at the given address. The format
 130          * is hostname:port */
 131         h = getenv("RSYNC_PROXY");
 132         proxied = (h != NULL) && (*h != '\0');
 133
 134         if (proxied) {
 135                 strlcpy(buffer, h, sizeof(buffer));
 136                 cp = strchr(buffer, ':');
 137                 if (cp == NULL) {
 138                         rprintf(FERROR,
 139                                 "invalid proxy specification: should be HOST:PORT\n");
 140                         return -1;
 141                 }
 142                 *cp++ = '\0';
 143                 strcpy(portbuf, cp);
 144                 h = buffer;
 145         } else {
 146                 snprintf(portbuf, sizeof(portbuf), "%d", port);
 147                 h = host;
 148         }
 149
 150         memset(&hints, 0, sizeof(hints));
 151         hints.ai_family = af_hint;
 152         hints.ai_socktype = type;
 153         error = getaddrinfo(h, portbuf, &hints, &res0);
 154         if (error) {
 155                 rprintf(FERROR, RSYNC_NAME ": getaddrinfo: %s %s: %s\n",
 156                         h, portbuf, gai_strerror(error));
 157                 return -1;
 158         }
 159
 160         s = -1;
 161         /* Try to connect to all addresses for this machine until we get
 162          * through.  It might e.g. be multi-homed, or have both IPv4 and IPv6
 163          * addresses.  We need to create a socket for each record, since the
 164          * address record tells us what protocol to use to try to connect. */
 165         for (res = res0; res; res = res->ai_next) {
 166                 s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
 167                 if (s < 0)
 168                         continue;
 169
 170                 if (bind_address) {
 171                         struct addrinfo bhints, *bres;
 172
 173                         memset(&bhints, 0, sizeof(bhints));
 174                         bhints.ai_family = res->ai_family;
 175                         bhints.ai_socktype = type;
 176                         bhints.ai_flags = AI_PASSIVE;
 177                         error = getaddrinfo(bind_address, NULL, &bhints, &bres);
 178                         if (error) {
 179                                 rprintf(FERROR, RSYNC_NAME ": getaddrinfo: "
 180                                         "bind address %s <noport>: %s\n",
 181                                         bind_address, gai_strerror(error));
 182                                 continue;
 183                         }
 184                         if (bres->ai_next) {
 185                                 /* I'm not at all sure that this is the right
 186                                  * response here... -- mbp */
 187                                 rprintf(FERROR, RSYNC_NAME ": getaddrinfo: "
 188                                         "bind address %s resolved to multiple hosts\n",
 189                                         bind_address);
 190                                 freeaddrinfo(bres);
 191                                 continue;
 192                         }
 193                         bind(s, bres->ai_addr, bres->ai_addrlen);
 194                 }
 195
 196                 if (connect(s, res->ai_addr, res->ai_addrlen) < 0) {
 197                         close(s);
 198                         s = -1;
 199                         continue;
 200                 }
 201                 if (proxied &&
 202                     establish_proxy_connection(s, host, port) != 0) {
 203                         close(s);
 204                         s = -1;
 205                         continue;
 206                 } else
 207                         break;
 208         }
 209         freeaddrinfo(res0);
 210         if (s < 0) {
 211                 rprintf(FERROR, RSYNC_NAME ": failed to connect to %s: %s\n",
 212                         h, strerror(errno));
 213                 return -1;
 214         }
 215         return s;
 216 }
 217
 218
 219 /**
 220  * Open an outgoing socket, but allow for it to be intercepted by
 221  * $RSYNC_CONNECT_PROG, which will execute a program across a TCP
 222  * socketpair rather than really opening a socket.
 223  *
 224  * We use this primarily in testing to detect TCP flow bugs, but not
 225  * cause security problems by really opening remote connections.
 226  *
 227  * This is based on the Samba LIBSMB_PROG feature.
 228  *
 229  * @param bind_address Local address to use.  Normally NULL to get the stack default.
 230  **/
 231 int open_socket_out_wrapped (char *host,
 232                              int port,
 233                              const char *bind_address,
 234                              int af_hint)
 235 {
 236         char *prog;
 237
 238         if ((prog = getenv ("RSYNC_CONNECT_PROG")) != NULL)
 239                 return sock_exec (prog);
 240         else
 241                 return open_socket_out (host, port, bind_address,
 242                                         af_hint);
 243 }
 244
 245
 246
 247 /**
 248  * Open a socket of the specified type, port and address for incoming data
 249  *
 250  * Try to be better about handling the results of getaddrinfo(): when
 251  * opening an inbound socket, we might get several address results,
 252  * e.g. for the machine's ipv4 and ipv6 name.
 253  *
 254  * If binding a wildcard, then any one of them should do.  If an address
 255  * was specified but it's insufficiently specific then that's not our
 256  * fault.
 257  *
 258  * However, some of the advertized addresses may not work because e.g. we
 259  * don't have IPv6 support in the kernel.  In that case go on and try all
 260  * addresses until one succeeds.
 261  *
 262  * @param bind_address Local address to bind, or NULL to allow it to
 263  * default.
 264  **/
 265 static int open_socket_in(int type, int port, const char *bind_address,
 266                           int af_hint)
 267 {
 268         int one=1;
 269         int s;
 270         struct addrinfo hints, *res, *resp;
 271         char portbuf[10];
 272         int error;
 273
 274         memset(&hints, 0, sizeof(hints));
 275         hints.ai_family = af_hint;
 276         hints.ai_socktype = type;
 277         hints.ai_flags = AI_PASSIVE;
 278         snprintf(portbuf, sizeof(portbuf), "%d", port);
 279         error = getaddrinfo(bind_address, portbuf, &hints, &res);
 280         if (error) {
 281                 rprintf(FERROR, RSYNC_NAME ": getaddrinfo: bind address %s: %s\n",
 282                         bind_address, gai_strerror(error));
 283                 return -1;
 284         }
 285         /* XXX: Do we need to care about getting multiple results
 286          * back?  I think probably not; if the user passed
 287          * bind_address == NULL and we set AI_PASSIVE then we ought to
 288          * get a wildcard result. */
 289
 290         resp = res;
 291         while (1) {
 292                 s = socket(resp->ai_family, resp->ai_socktype, resp->ai_protocol);
 293
 294                 if (s >= 0) {
 295                         break;  /* got a socket */
 296                 } else if ((resp = resp->ai_next)) {
 297                         switch (errno) {
 298                         case EPROTONOSUPPORT:
 299                         case EAFNOSUPPORT:
 300                         case EPFNOSUPPORT:
 301                                 /* See if there's another address that will work... */
 302                                 continue;
 303                         }
 304                 }
 305
 306                 rprintf(FERROR, RSYNC_NAME ": open inbound socket"
 307                         "(dom=%d, type=%d, proto=%d) failed: %s\n",
 308                         resp->ai_family, resp->ai_socktype, resp->ai_protocol,
 309                         strerror(errno));
 310                         goto fail;
 311         }
 312
 313         setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&one,sizeof(one));
 314
 315         /* now we've got a socket - we need to bind it */
 316         if (bind(s, res->ai_addr, res->ai_addrlen) < 0) {
 317                 rprintf(FERROR, RSYNC_NAME ": bind failed on port %d\n", port);
 318                 close(s);
 319                 goto fail;
 320         }
 321
 322         return s;
 323
 324 fail:
 325         freeaddrinfo(res);
 326         return -1;
 327 }
 328
 329
 330 /*
 331  * Determine if a file descriptor is in fact a socket
 332  */
 333 int is_a_socket(int fd)
 334 {
 335         int v;
 336         socklen_t l;
 337         l = sizeof(int);
 338
 339         /* Parameters to getsockopt, setsockopt etc are very
 340          * unstandardized across platforms, so don't be surprised if
 341          * there are compiler warnings on e.g. SCO OpenSwerver or AIX.
 342          * It seems they all eventually get the right idea.
 343          *
 344          * Debian says: ``The fifth argument of getsockopt and
 345          * setsockopt is in reality an int [*] (and this is what BSD
 346          * 4.* and libc4 and libc5 have).  Some POSIX confusion
 347          * resulted in the present socklen_t.  The draft standard has
 348          * not been adopted yet, but glibc2 already follows it and
 349          * also has socklen_t [*]. See also accept(2).''
 350          *
 351          * We now return to your regularly scheduled programming.  */
 352         return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
 353 }
 354
 355
 356 void start_accept_loop(int port, int (*fn)(int ))
 357 {
 358         int s;
 359         extern char *bind_address;
 360
 361         /* open an incoming socket */
 362         s = open_socket_in(SOCK_STREAM, port, bind_address,
 363                            global_opts.af_hint);
 364         if (s == -1)
 365                 exit_cleanup(RERR_SOCKETIO);
 366
 367         /* ready to listen */
 368         if (listen(s, 5) == -1) {
 369                 close(s);
 370                 exit_cleanup(RERR_SOCKETIO);
 371         }
 372
 373
 374         /* now accept incoming connections - forking a new process
 375            for each incoming connection */
 376         while (1) {
 377                 fd_set fds;
 378                 int fd;
 379                 struct sockaddr_storage addr;
 380                 int addrlen = sizeof(addr);
 381
 382                 /* close log file before the potentially very long select so
 383                    file can be trimmed by another process instead of growing
 384                    forever */
 385                 log_close();
 386
 387                 FD_ZERO(&fds);
 388                 FD_SET(s, &fds);
 389
 390                 if (select(s+1, &fds, NULL, NULL, NULL) != 1) {
 391                         continue;
 392                 }
 393
 394                 if(!FD_ISSET(s, &fds)) continue;
 395
 396                 fd = accept(s,(struct sockaddr *)&addr,&addrlen);
 397
 398                 if (fd == -1) continue;
 399
 400                 signal(SIGCHLD, SIG_IGN);
 401
 402                 /* we shouldn't have any children left hanging around
 403                    but I have had reports that on Digital Unix zombies
 404                    are produced, so this ensures that they are reaped */
 405 #ifdef WNOHANG
 406                 while (waitpid(-1, NULL, WNOHANG) > 0);
 407 #endif
 408
 409                 if (fork()==0) {
 410                         close(s);
 411                         /* open log file in child before possibly giving
 412                            up privileges  */
 413                         log_open();
 414                         _exit(fn(fd));
 415                 }
 416
 417                 close(fd);
 418         }
 419 }
 420
 421
 422 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
 423
 424 struct
 425 {
 426   char *name;
 427   int level;
 428   int option;
 429   int value;
 430   int opttype;
 431 } socket_options[] = {
 432   {"SO_KEEPALIVE",      SOL_SOCKET,    SO_KEEPALIVE,    0,                 OPT_BOOL},
 433   {"SO_REUSEADDR",      SOL_SOCKET,    SO_REUSEADDR,    0,                 OPT_BOOL},
 434   {"SO_BROADCAST",      SOL_SOCKET,    SO_BROADCAST,    0,                 OPT_BOOL},
 435 #ifdef TCP_NODELAY
 436   {"TCP_NODELAY",       IPPROTO_TCP,   TCP_NODELAY,     0,                 OPT_BOOL},
 437 #endif
 438 #ifdef IPTOS_LOWDELAY
 439   {"IPTOS_LOWDELAY",    IPPROTO_IP,    IP_TOS,          IPTOS_LOWDELAY,    OPT_ON},
 440 #endif
 441 #ifdef IPTOS_THROUGHPUT
 442   {"IPTOS_THROUGHPUT",  IPPROTO_IP,    IP_TOS,          IPTOS_THROUGHPUT,  OPT_ON},
 443 #endif
 444 #ifdef SO_SNDBUF
 445   {"SO_SNDBUF",         SOL_SOCKET,    SO_SNDBUF,       0,                 OPT_INT},
 446 #endif
 447 #ifdef SO_RCVBUF
 448   {"SO_RCVBUF",         SOL_SOCKET,    SO_RCVBUF,       0,                 OPT_INT},
 449 #endif
 450 #ifdef SO_SNDLOWAT
 451   {"SO_SNDLOWAT",       SOL_SOCKET,    SO_SNDLOWAT,     0,                 OPT_INT},
 452 #endif
 453 #ifdef SO_RCVLOWAT
 454   {"SO_RCVLOWAT",       SOL_SOCKET,    SO_RCVLOWAT,     0,                 OPT_INT},
 455 #endif
 456 #ifdef SO_SNDTIMEO
 457   {"SO_SNDTIMEO",       SOL_SOCKET,    SO_SNDTIMEO,     0,                 OPT_INT},
 458 #endif
 459 #ifdef SO_RCVTIMEO
 460   {"SO_RCVTIMEO",       SOL_SOCKET,    SO_RCVTIMEO,     0,                 OPT_INT},
 461 #endif
 462   {NULL,0,0,0,0}};
 463
 464
 465
 466 /****************************************************************************
 467 set user socket options
 468 ****************************************************************************/
 469 void set_socket_options(int fd, char *options)
 470 {
 471         char *tok;
 472         if (!options || !*options) return;
 473
 474         options = strdup(options);
 475
 476         if (!options) out_of_memory("set_socket_options");
 477
 478         for (tok=strtok(options, " \t,"); tok; tok=strtok(NULL," \t,")) {
 479                 int ret=0,i;
 480                 int value = 1;
 481                 char *p;
 482                 int got_value = 0;
 483
 484                 if ((p = strchr(tok,'='))) {
 485                         *p = 0;
 486                         value = atoi(p+1);
 487                         got_value = 1;
 488                 }
 489
 490                 for (i=0;socket_options[i].name;i++)
 491                         if (strcmp(socket_options[i].name,tok)==0)
 492                                 break;
 493
 494                 if (!socket_options[i].name) {
 495                         rprintf(FERROR,"Unknown socket option %s\n",tok);
 496                         continue;
 497                 }
 498
 499                 switch (socket_options[i].opttype) {
 500                 case OPT_BOOL:
 501                 case OPT_INT:
 502                         ret = setsockopt(fd,socket_options[i].level,
 503                                          socket_options[i].option,(char *)&value,sizeof(int));
 504                         break;
 505
 506                 case OPT_ON:
 507                         if (got_value)
 508                                 rprintf(FERROR,"syntax error - %s does not take a value\n",tok);
 509
 510                         {
 511                                 int on = socket_options[i].value;
 512                                 ret = setsockopt(fd,socket_options[i].level,
 513                                                  socket_options[i].option,(char *)&on,sizeof(int));
 514                         }
 515                         break;
 516                 }
 517
 518                 if (ret != 0)
 519                         rprintf(FERROR, "failed to set socket option %s: %s\n", tok,
 520                                 strerror(errno));
 521         }
 522
 523         free(options);
 524 }
 525
 526 /****************************************************************************
 527 become a daemon, discarding the controlling terminal
 528 ****************************************************************************/
 529 void become_daemon(void)
 530 {
 531         int i;
 532
 533         if (fork()) {
 534                 _exit(0);
 535         }
 536
 537         /* detach from the terminal */
 538 #ifdef HAVE_SETSID
 539         setsid();
 540 #else
 541 #ifdef TIOCNOTTY
 542         i = open("/dev/tty", O_RDWR);
 543         if (i >= 0) {
 544                 ioctl(i, (int) TIOCNOTTY, (char *)0);
 545                 close(i);
 546         }
 547 #endif /* TIOCNOTTY */
 548 #endif
 549         /* make sure that stdin, stdout an stderr don't stuff things
 550            up (library functions, for example) */
 551         for (i=0;i<3;i++) {
 552                 close(i);
 553                 open("/dev/null", O_RDWR);
 554         }
 555 }
 556
 557 /**
 558  * Return the IP addr of the client as a string
 559  **/
 560 char *client_addr(int fd)
 561 {
 562         struct sockaddr_storage ss;
 563         int     length = sizeof(ss);
 564         static char addr_buf[100];
 565         static int initialised;
 566
 567         if (initialised) return addr_buf;
 568
 569         initialised = 1;
 570
 571         if (getpeername(fd, (struct sockaddr *)&ss, &length)) {
 572                 exit_cleanup(RERR_SOCKETIO);
 573         }
 574
 575         getnameinfo((struct sockaddr *)&ss, length,
 576                 addr_buf, sizeof(addr_buf), NULL, 0, NI_NUMERICHOST);
 577         return addr_buf;
 578 }
 579
 580
 581 /**
 582  * Return the DNS name of the client
 583  **/
 584 char *client_name(int fd)
 585 {
 586         struct sockaddr_storage ss;
 587         int     length = sizeof(ss);
 588         static char name_buf[100];
 589         static char port_buf[100];
 590         char *def = "UNKNOWN";
 591         static int initialised;
 592         struct addrinfo hints, *res, *res0;
 593         int error;
 594
 595         if (initialised) return name_buf;
 596
 597         initialised = 1;
 598
 599         strcpy(name_buf,def);
 600
 601         if (getpeername(fd, (struct sockaddr *)&ss, &length)) {
 602                 /* FIXME: Can we really not continue? */
 603                 rprintf(FERROR, RSYNC_NAME ": getpeername on fd%d failed: %s\n",
 604                         fd, strerror(errno));
 605                 exit_cleanup(RERR_SOCKETIO);
 606         }
 607
 608 #ifdef INET6
 609         if (ss.ss_family == AF_INET6 &&
 610             IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)&ss)->sin6_addr)) {
 611                 struct sockaddr_in6 sin6;
 612                 struct sockaddr_in *sin;
 613
 614                 memcpy(&sin6, &ss, sizeof(sin6));
 615                 sin = (struct sockaddr_in *)&ss;
 616                 memset(sin, 0, sizeof(*sin));
 617                 sin->sin_family = AF_INET;
 618                 length = sizeof(struct sockaddr_in);
 619 #ifdef HAVE_SOCKADDR_LEN
 620                 sin->sin_len = length;
 621 #endif
 622                 sin->sin_port = sin6.sin6_port;
 623                 memcpy(&sin->sin_addr, &sin6.sin6_addr.s6_addr[12],
 624                         sizeof(sin->sin_addr));
 625         }
 626 #endif
 627
 628         /* reverse lookup */
 629         if (getnameinfo((struct sockaddr *)&ss, length,
 630                         name_buf, sizeof(name_buf), port_buf, sizeof(port_buf),
 631                         NI_NAMEREQD | NI_NUMERICSERV) != 0) {
 632                 strcpy(name_buf, def);
 633                 rprintf(FERROR, "reverse name lookup failed\n");
 634         }
 635
 636         /* forward lookup */
 637         memset(&hints, 0, sizeof(hints));
 638         hints.ai_family = PF_UNSPEC;
 639         hints.ai_flags = AI_CANONNAME;
 640         hints.ai_socktype = SOCK_STREAM;
 641         error = getaddrinfo(name_buf, port_buf, &hints, &res0);
 642         if (error) {
 643                 strcpy(name_buf, def);
 644                 rprintf(FERROR,
 645                         RSYNC_NAME ": forward name lookup for %s failed: %s\n",
 646                         port_buf,
 647                         gai_strerror(error));
 648                 return name_buf;
 649         }
 650
 651         /* XXX sin6_flowinfo and other fields */
 652         for (res = res0; res; res = res->ai_next) {
 653                 if (res->ai_family != ss.ss_family)
 654                         continue;
 655                 if (res->ai_addrlen != length)
 656                         continue;
 657                 if (memcmp(res->ai_addr, &ss, res->ai_addrlen) == 0)
 658                         break;
 659         }
 660
 661         /* TODO: Do a  forward lookup as well to prevent spoofing */
 662
 663         if (res == NULL) {
 664                 strcpy(name_buf, def);
 665                 rprintf(FERROR, RSYNC_NAME ": "
 666                         "reverse name lookup mismatch on fd%d - spoofed address?\n",
 667                         fd);
 668         }
 669
 670         freeaddrinfo(res0);
 671         return name_buf;
 672 }
 673
 674
 675 /*******************************************************************
 676 this is like socketpair but uses tcp. It is used by the Samba
 677 regression test code
 678 The function guarantees that nobody else can attach to the socket,
 679 or if they do that this function fails and the socket gets closed
 680 returns 0 on success, -1 on failure
 681 the resulting file descriptors are symmetrical
 682  ******************************************************************/
 683 static int socketpair_tcp(int fd[2])
 684 {
 685         int listener;
 686         struct sockaddr_in sock;
 687         struct sockaddr_in sock2;
 688         socklen_t socklen = sizeof(sock);
 689         int connect_done = 0;
 690
 691         fd[0] = fd[1] = listener = -1;
 692
 693         memset(&sock, 0, sizeof(sock));
 694
 695         if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
 696
 697         memset(&sock2, 0, sizeof(sock2));
 698 #ifdef HAVE_SOCK_SIN_LEN
 699         sock2.sin_len = sizeof(sock2);
 700 #endif
 701         sock2.sin_family = PF_INET;
 702
 703         bind(listener, (struct sockaddr *)&sock2, sizeof(sock2));
 704
 705         if (listen(listener, 1) != 0) goto failed;
 706
 707         if (getsockname(listener, (struct sockaddr *)&sock, &socklen) != 0) goto failed;
 708
 709         if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
 710
 711         set_nonblocking(fd[1]);
 712
 713         sock.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 714
 715         if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) == -1) {
 716                 if (errno != EINPROGRESS) goto failed;
 717         } else {
 718                 connect_done = 1;
 719         }
 720
 721         if ((fd[0] = accept(listener, (struct sockaddr *)&sock, &socklen)) == -1) goto failed;
 722
 723         close(listener);
 724         if (connect_done == 0) {
 725                 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) != 0
 726                     && errno != EISCONN) goto failed;
 727         }
 728
 729         set_blocking (fd[1]);
 730
 731         /* all OK! */
 732         return 0;
 733
 734  failed:
 735         if (fd[0] != -1) close(fd[0]);
 736         if (fd[1] != -1) close(fd[1]);
 737         if (listener != -1) close(listener);
 738         return -1;
 739 }
 740
 741
 742 /*******************************************************************
 743 run a program on a local tcp socket, this is used to launch smbd
 744 when regression testing
 745 the return value is a socket which is attached to a subprocess
 746 running "prog". stdin and stdout are attached. stderr is left
 747 attached to the original stderr
 748  ******************************************************************/
 749 int sock_exec(const char *prog)
 750 {
 751         int fd[2];
 752         if (socketpair_tcp(fd) != 0) {
 753                 rprintf (FERROR, RSYNC_NAME
 754                          ": socketpair_tcp failed (%s)\n",
 755                          strerror(errno));
 756                 return -1;
 757         }
 758         if (fork() == 0) {
 759                 close(fd[0]);
 760                 close(0);
 761                 close(1);
 762                 dup(fd[1]);
 763                 dup(fd[1]);
 764                 if (verbose > 3)
 765                         fprintf (stderr,
 766                                  RSYNC_NAME ": execute socket program \"%s\"\n",
 767                                  prog);
 768                 exit (system (prog));
 769         }
 770         close (fd[1]);
 771         return fd[0];
 772 }
 773
 774
 775