socket.c

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