socket.c

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