1 /* -*- c-file-style: "linux" -*-
3 Copyright (C) 1992-2001 by Andrew Tridgell <tridge@samba.org>
4 Copyright (C) 2001 by Martin Pool <mbp@samba.org>
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.
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.
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.
22 socket functions used in rsync
28 #ifndef HAVE_GETADDRINFO
29 #include "lib/addrinfo.h"
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)
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",
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",
63 if (strncmp(buffer, "HTTP/", 5) != 0) {
64 rprintf(FERROR, "bad response from proxy - %s\n",
68 for (cp = &buffer[5]; isdigit(*cp) || (*cp == '.'); cp++)
73 rprintf(FERROR, "bad response from proxy - %s\n",
77 /* throw away the rest of the HTTP header */
79 for (cp = buffer; cp < &buffer[sizeof(buffer) - 1];
81 if (read(fd, cp, 1) != 1) {
82 rprintf(FERROR, "failed to read from proxy: %s\n",
89 if ((cp > buffer) && (*cp == '\n'))
91 if ((cp == buffer) && ((*cp == '\n') || (*cp == '\r')))
99 /** Open a socket to a tcp remote host with the specified port .
101 * Based on code from Warren. Proxy support by Stephen Rothwell
104 * @param bind_address Local address to use. Normally NULL to get the stack default.
106 int open_socket_out(char *host, int port, const char *bind_address)
108 int type = SOCK_STREAM;
112 struct addrinfo hints, *res0, *res;
119 /* if we have a RSYNC_PROXY env variable then redirect our
120 * connetcion via a web proxy at the given address. The format
121 * is hostname:port */
122 h = getenv("RSYNC_PROXY");
123 proxied = (h != NULL) && (*h != '\0');
126 strlcpy(buffer, h, sizeof(buffer));
127 cp = strchr(buffer, ':');
130 "invalid proxy specification: should be HOST:PORT\n");
137 snprintf(portbuf, sizeof(portbuf), "%d", port);
141 memset(&hints, 0, sizeof(hints));
142 hints.ai_family = af;
143 hints.ai_socktype = type;
144 error = getaddrinfo(h, portbuf, &hints, &res0);
146 rprintf(FERROR, RSYNC_NAME ": getaddrinfo: %s: %s\n", portbuf, gai_strerror(error));
151 for (res = res0; res; res = res->ai_next) {
152 s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
157 struct addrinfo bhints, *bres;
159 memset(&bhints, 0, sizeof(bhints));
160 bhints.ai_family = res->ai_family;
161 bhints.ai_socktype = type;
162 bhints.ai_flags = AI_PASSIVE;
163 error = getaddrinfo(bind_address, NULL, &bhints, &bres);
165 rprintf(FERROR, RSYNC_NAME ": getaddrinfo: bind address %s: %s\n",
166 bind_address, gai_strerror(error));
170 rprintf(FERROR, RSYNC_NAME ": getaddrinfo: bind address %s resolved to multiple hosts\n",
175 bind(s, bres->ai_addr, bres->ai_addrlen);
178 if (connect(s, res->ai_addr, res->ai_addrlen) < 0) {
184 establish_proxy_connection(s, host, port) != 0) {
193 rprintf(FERROR, RSYNC_NAME ": failed to connect to %s: %s\n",
202 * Open an outgoing socket, but allow for it to be intercepted by
203 * $RSYNC_CONNECT_PROG, which will execute a program across a TCP
204 * socketpair rather than really opening a socket.
206 * We use this primarily in testing to detect TCP flow bugs, but not
207 * cause security problems by really opening remote connections.
209 * This is based on the Samba LIBSMB_PROG feature.
211 * @param bind_address Local address to use. Normally NULL to get the stack default.
213 int open_socket_out_wrapped (char *host,
215 const char *bind_address)
219 if ((prog = getenv ("RSYNC_CONNECT_PROG")) != NULL)
220 return sock_exec (prog);
222 return open_socket_out (host, port, bind_address);
228 * Open a socket of the specified type, port and address for incoming data
230 * @param bind_address Local address to bind, or NULL to allow it to
233 static int open_socket_in(int type, int port, const char *bind_address)
237 struct addrinfo hints, *res;
241 memset(&hints, 0, sizeof(hints));
242 hints.ai_family = af;
243 hints.ai_socktype = type;
244 hints.ai_flags = AI_PASSIVE;
245 snprintf(portbuf, sizeof(portbuf), "%d", port);
246 error = getaddrinfo(bind_address, portbuf, &hints, &res);
248 rprintf(FERROR, RSYNC_NAME ": getaddrinfo: bind address %s: %s\n",
249 bind_address, gai_strerror(error));
253 rprintf(FERROR, RSYNC_NAME ": getaddrinfo: bind address %s: "
254 "resolved to multiple hosts\n",
260 s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
262 rprintf(FERROR, RSYNC_NAME ": open socket in failed: %s\n",
268 setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&one,sizeof(one));
270 /* now we've got a socket - we need to bind it */
271 if (bind(s, res->ai_addr, res->ai_addrlen) < 0) {
272 rprintf(FERROR, RSYNC_NAME ": bind failed on port %d\n", port);
283 * Determine if a file descriptor is in fact a socket
285 int is_a_socket(int fd)
291 /* Parameters to getsockopt, setsockopt etc are very
292 * unstandardized across platforms, so don't be surprised if
293 * there are compiler warnings on e.g. SCO OpenSwerver or AIX.
294 * It seems they all eventually get the right idea.
296 * Debian says: ``The fifth argument of getsockopt and
297 * setsockopt is in reality an int [*] (and this is what BSD
298 * 4.* and libc4 and libc5 have). Some POSIX confusion
299 * resulted in the present socklen_t. The draft standard has
300 * not been adopted yet, but glibc2 already follows it and
301 * also has socklen_t [*]. See also accept(2).''
303 * We now return to your regularly scheduled programming. */
304 return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
308 void start_accept_loop(int port, int (*fn)(int ))
311 extern char *bind_address;
313 /* open an incoming socket */
314 s = open_socket_in(SOCK_STREAM, port, bind_address);
316 exit_cleanup(RERR_SOCKETIO);
318 /* ready to listen */
319 if (listen(s, 5) == -1) {
321 exit_cleanup(RERR_SOCKETIO);
325 /* now accept incoming connections - forking a new process
326 for each incoming connection */
330 struct sockaddr addr;
331 int in_addrlen = sizeof(addr);
333 /* close log file before the potentially very long select so
334 file can be trimmed by another process instead of growing
341 if (select(s+1, &fds, NULL, NULL, NULL) != 1) {
345 if(!FD_ISSET(s, &fds)) continue;
347 fd = accept(s,(struct sockaddr *)&addr,&in_addrlen);
349 if (fd == -1) continue;
351 signal(SIGCHLD, SIG_IGN);
353 /* we shouldn't have any children left hanging around
354 but I have had reports that on Digital Unix zombies
355 are produced, so this ensures that they are reaped */
357 while (waitpid(-1, NULL, WNOHANG) > 0);
362 /* open log file in child before possibly giving
373 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
382 } socket_options[] = {
383 {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
384 {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
385 {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
387 {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
389 #ifdef IPTOS_LOWDELAY
390 {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
392 #ifdef IPTOS_THROUGHPUT
393 {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
396 {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
399 {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
402 {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
405 {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
408 {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
411 {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
417 /****************************************************************************
418 set user socket options
419 ****************************************************************************/
420 void set_socket_options(int fd, char *options)
423 if (!options || !*options) return;
425 options = strdup(options);
427 if (!options) out_of_memory("set_socket_options");
429 for (tok=strtok(options, " \t,"); tok; tok=strtok(NULL," \t,")) {
435 if ((p = strchr(tok,'='))) {
441 for (i=0;socket_options[i].name;i++)
442 if (strcmp(socket_options[i].name,tok)==0)
445 if (!socket_options[i].name) {
446 rprintf(FERROR,"Unknown socket option %s\n",tok);
450 switch (socket_options[i].opttype) {
453 ret = setsockopt(fd,socket_options[i].level,
454 socket_options[i].option,(char *)&value,sizeof(int));
459 rprintf(FERROR,"syntax error - %s does not take a value\n",tok);
462 int on = socket_options[i].value;
463 ret = setsockopt(fd,socket_options[i].level,
464 socket_options[i].option,(char *)&on,sizeof(int));
470 rprintf(FERROR, "failed to set socket option %s: %s\n", tok,
477 /****************************************************************************
478 become a daemon, discarding the controlling terminal
479 ****************************************************************************/
480 void become_daemon(void)
488 /* detach from the terminal */
493 i = open("/dev/tty", O_RDWR);
495 ioctl(i, (int) TIOCNOTTY, (char *)0);
498 #endif /* TIOCNOTTY */
500 /* make sure that stdin, stdout an stderr don't stuff things
501 up (library functions, for example) */
504 open("/dev/null", O_RDWR);
509 * Return the IP addr of the client as a string
511 char *client_addr(int fd)
514 int length = sizeof(ss);
515 static char addr_buf[100];
516 static int initialised;
518 if (initialised) return addr_buf;
522 if (getpeername(fd, &ss, &length)) {
523 exit_cleanup(RERR_SOCKETIO);
526 getnameinfo(&ss, length,
527 addr_buf, sizeof(addr_buf), NULL, 0, NI_NUMERICHOST);
533 * Return the DNS name of the client
535 char *client_name(int fd)
538 int length = sizeof(ss);
539 static char name_buf[100];
540 static char port_buf[100];
541 char *def = "UNKNOWN";
542 static int initialised;
543 struct addrinfo hints, *res, *res0;
546 if (initialised) return name_buf;
550 strcpy(name_buf,def);
552 if (getpeername(fd, (struct sockaddr *)&ss, &length)) {
553 exit_cleanup(RERR_SOCKETIO);
557 if (ss.ss_family == AF_INET6 &&
558 IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)&ss)->sin6_addr)) {
559 struct sockaddr_in6 sin6;
560 struct sockaddr_in *sin;
562 memcpy(&sin6, &ss, sizeof(sin6));
563 sin = (struct sockaddr_in *)&ss;
564 memset(sin, 0, sizeof(*sin));
565 sin->sin_family = AF_INET;
566 length = sizeof(struct sockaddr_in);
567 #ifdef HAVE_SOCKADDR_LEN
568 sin->sin_len = length;
570 sin->sin_port = sin6.sin6_port;
571 memcpy(&sin->sin_addr, &sin6.sin6_addr.s6_addr[12],
572 sizeof(sin->sin_addr));
577 if (getnameinfo((struct sockaddr *)&ss, length,
578 name_buf, sizeof(name_buf), port_buf, sizeof(port_buf),
579 NI_NAMEREQD | NI_NUMERICSERV) != 0) {
580 strcpy(name_buf, def);
581 rprintf(FERROR, "reverse name lookup failed\n");
585 memset(&hints, 0, sizeof(hints));
586 hints.ai_family = PF_UNSPEC;
587 hints.ai_flags = AI_CANONNAME;
588 hints.ai_socktype = SOCK_STREAM;
589 error = getaddrinfo(name_buf, port_buf, &hints, &res0);
591 strcpy(name_buf, def);
593 RSYNC_NAME ": forward name lookup for %s failed: %s\n",
595 gai_strerror(error));
599 /* XXX sin6_flowinfo and other fields */
600 for (res = res0; res; res = res->ai_next) {
601 if (res->ai_family != ss.sa_family)
603 if (res->ai_addrlen != length)
605 if (memcmp(res->ai_addr, &ss, res->ai_addrlen) == 0)
609 /* TODO: Do a forward lookup as well to prevent spoofing */
612 strcpy(name_buf, def);
614 "reverse name lookup mismatch - spoofed address?\n");
622 * Convert a string to an IP address. The string can be a name or
623 * dotted decimal number.
625 * Returns a pointer to a static in_addr struct -- if you call this
626 * more than once then you should copy it.
628 * TODO: Use getaddrinfo() instead, or make this function call getnameinfo
630 struct in_addr *ip_address(const char *str)
632 static struct in_addr ret;
636 rprintf (FERROR, "ip_address received NULL name\n");
640 /* try as an IP address */
641 if (inet_aton(str, &ret) != 0) {
645 /* otherwise assume it's a network name of some sort and use
647 if ((hp = gethostbyname (str)) == 0) {
648 rprintf(FERROR, "gethostbyname failed for \"%s\": unknown host?\n",str);
652 if (hp->h_addr == NULL) {
653 rprintf(FERROR, "gethostbyname: host address is invalid for host \"%s\"\n",str);
657 if (hp->h_length > sizeof ret) {
658 rprintf(FERROR, "gethostbyname: host address for \"%s\" is too large\n",
663 if (hp->h_addrtype != AF_INET) {
664 rprintf (FERROR, "gethostname: host address for \"%s\" is not IPv4\n",
669 /* This is kind of difficult. The only field in ret is
670 s_addr, which is the IP address as a 32-bit int. On
671 UNICOS, s_addr is in fact a *bitfield* for reasons best
672 know to Cray. This means we can't memcpy in to it. On the
673 other hand, h_addr is a char*, so we can't just assign.
675 Since there's meant to be only one field inside the in_addr
676 structure we will try just copying over the top and see how
678 memcpy (&ret, hp->h_addr, hp->h_length);
685 /*******************************************************************
686 this is like socketpair but uses tcp. It is used by the Samba
688 The function guarantees that nobody else can attach to the socket,
689 or if they do that this function fails and the socket gets closed
690 returns 0 on success, -1 on failure
691 the resulting file descriptors are symmetrical
692 ******************************************************************/
693 static int socketpair_tcp(int fd[2])
696 struct sockaddr_in sock;
697 struct sockaddr_in sock2;
698 socklen_t socklen = sizeof(sock);
699 int connect_done = 0;
701 fd[0] = fd[1] = listener = -1;
703 memset(&sock, 0, sizeof(sock));
705 if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
707 memset(&sock2, 0, sizeof(sock2));
708 #ifdef HAVE_SOCK_SIN_LEN
709 sock2.sin_len = sizeof(sock2);
711 sock2.sin_family = PF_INET;
713 bind(listener, (struct sockaddr *)&sock2, sizeof(sock2));
715 if (listen(listener, 1) != 0) goto failed;
717 if (getsockname(listener, (struct sockaddr *)&sock, &socklen) != 0) goto failed;
719 if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
721 set_nonblocking(fd[1]);
723 sock.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
725 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) == -1) {
726 if (errno != EINPROGRESS) goto failed;
731 if ((fd[0] = accept(listener, (struct sockaddr *)&sock, &socklen)) == -1) goto failed;
734 if (connect_done == 0) {
735 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) != 0
736 && errno != EISCONN) goto failed;
739 set_blocking (fd[1]);
745 if (fd[0] != -1) close(fd[0]);
746 if (fd[1] != -1) close(fd[1]);
747 if (listener != -1) close(listener);
752 /*******************************************************************
753 run a program on a local tcp socket, this is used to launch smbd
754 when regression testing
755 the return value is a socket which is attached to a subprocess
756 running "prog". stdin and stdout are attached. stderr is left
757 attached to the original stderr
758 ******************************************************************/
759 int sock_exec(const char *prog)
762 if (socketpair_tcp(fd) != 0) {
763 rprintf (FERROR, RSYNC_NAME
764 ": socketpair_tcp failed (%s)\n",
776 RSYNC_NAME ": execute socket program \"%s\"\n",
778 exit (system (prog));