preparing for release of 2.4.5

patch from Charles Levert <charles@comm.polymtl.ca>

Makefile.in

@@ -3,8 +3,8 @@
 
 prefix=@prefix@
 exec_prefix=@exec_prefix@
-INSTALL_BIN=$(exec_prefix)/bin
-INSTALL_MAN=$(prefix)/man
+bindir=@bindir@
+mandir=@mandir@
 
 LIBS=@LIBS@
 CC=@CC@
@@ -12,38 +12,46 @@ CFLAGS=@CFLAGS@
 
 INSTALLCMD=@INSTALL@
 
-VPATH=@srcdir@
 srcdir=@srcdir@
+VPATH=$(srcdir)
 SHELL=/bin/sh
 
 
 .SUFFIXES:
 .SUFFIXES: .c .o
 
-LIBOBJ=lib/getopt.o lib/fnmatch.o lib/zlib.o lib/compat.o
-OBJS1=rsync.o exclude.o util.o md4.o main.o checksum.o match.o syscall.o log.o
-OBJS2=options.o flist.o io.o compat.o hlink.o token.o uidlist.o socket.o 
+LIBOBJ=lib/getopt.o lib/fnmatch.o lib/compat.o lib/snprintf.o lib/mdfour.o
+ZLIBOBJ=zlib/deflate.o zlib/infblock.o zlib/infcodes.o zlib/inffast.o \
+	zlib/inflate.o zlib/inftrees.o zlib/infutil.o zlib/trees.o \
+	zlib/zutil.o zlib/adler32.o 
+OBJS1=rsync.o generator.o receiver.o cleanup.o sender.o exclude.o util.o main.o checksum.o match.o syscall.o log.o backup.o
+OBJS2=options.o flist.o io.o compat.o hlink.o token.o uidlist.o socket.o fileio.o
 DAEMON_OBJ = params.o loadparm.o clientserver.o access.o connection.o authenticate.o
-OBJS=$(OBJS1) $(OBJS2) $(DAEMON_OBJ) $(LIBOBJ)
+OBJS=$(OBJS1) $(OBJS2) $(DAEMON_OBJ) $(LIBOBJ) $(ZLIBOBJ)
 
 # note that the -I. is needed to handle config.h when using VPATH
 .c.o:
-	$(CC) -I. -I$(srcdir) $(CFLAGS) -c $< -o $@
+@OBJ_SAVE@
+	$(CC) -I. -I$(srcdir) $(CFLAGS) -c $< @CC_SHOBJ_FLAG@
+@OBJ_RESTORE@
 
 all: rsync
 
 man: rsync.1 rsyncd.conf.5
 
 install: all
-	-mkdir -p ${INSTALL_BIN}
-	${INSTALLCMD} -m 755 rsync ${INSTALL_BIN}
-	-mkdir -p ${INSTALL_MAN}/man1
-	-mkdir -p ${INSTALL_MAN}/man5
-	${INSTALLCMD} -m 644 $(srcdir)/rsync.1 ${INSTALL_MAN}/man1
-	${INSTALLCMD} -m 644 $(srcdir)/rsyncd.conf.5 ${INSTALL_MAN}/man5
+	-mkdir -p ${bindir}
+	${INSTALLCMD} -m 755 rsync ${bindir}
+	-mkdir -p ${mandir}/man1
+	-mkdir -p ${mandir}/man5
+	${INSTALLCMD} -m 644 $(srcdir)/rsync.1 ${mandir}/man1
+	${INSTALLCMD} -m 644 $(srcdir)/rsyncd.conf.5 ${mandir}/man5
+
+install-strip:
+	$(MAKE) INSTALLCMD='$(INSTALLCMD) -s' install
 
 rsync: $(OBJS)
-	$(CC) $(CFLAGS) -o rsync $(OBJS) $(LIBS)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o rsync $(OBJS) $(LIBS)
 
 rsync.1: rsync.yo
 	yodl2man -o rsync.1 rsync.yo
@@ -52,15 +60,19 @@ rsyncd.conf.5: rsyncd.conf.yo
 	yodl2man -o rsyncd.conf.5 rsyncd.conf.yo
 
 proto:
-	cat *.c | awk -f mkproto.awk > proto.h
+	cat *.c lib/compat.c | awk -f mkproto.awk > proto.h
 
 clean:
-	rm -f *~ $(OBJS) rsync config.cache config.log config.status
+	rm -f *~ $(OBJS) rsync 
 
-dist:
-	tar --exclude-from .ignore -czf dist.tar.gz .
-	-mkdir rsync-$(VERSION)
-	(cd rsync-$(VERSION) ; tar xzf ../dist.tar.gz)
-	tar -czf rsync-$(VERSION).tar.gz rsync-$(VERSION)
-	rm -f dist.tar.gz
-	echo rsync-$(VERSION) >> .cvsignore
+distclean: clean
+	rm -f config.h config.cache config.status Makefile
+
+
+# this target is really just for my use. It only works on a limited
+# range of machines and is used to produce a list of potentially
+# dead (ie. unused) functions in the code. (tridge)
+finddead:
+	nm *.o */*.o |grep 'U ' | awk '{print $$2}' | sort -u > nmused.txt
+	nm *.o */*.o |grep 'T ' | awk '{print $$3}' | sort -u > nmfns.txt
+	comm -13 nmused.txt nmfns.txt 

README

@@ -20,53 +20,78 @@ USAGE
 
 Basically you use rsync just like rcp, but rsync has many additional options.
 
-Here is a brief description of available options:
+Here is a brief description of rsync usage:
+
+Usage: rsync [OPTION]... SRC [SRC]... [USER@]HOST:DEST
+  or   rsync [OPTION]... [USER@]HOST:SRC DEST
+  or   rsync [OPTION]... SRC [SRC]... DEST
+  or   rsync [OPTION]... [USER@]HOST::SRC [DEST]
+  or   rsync [OPTION]... SRC [SRC]... [USER@]HOST::DEST
+  or   rsync [OPTION]... rsync://[USER@]HOST[:PORT]/SRC [DEST]
+SRC on single-colon remote HOST will be expanded by remote shell
+SRC on server remote HOST may contain shell wildcards or multiple
+  sources separated by space as long as they have same top-level
+
+Options
+ -v, --verbose               increase verbosity
+ -q, --quiet                 decrease verbosity
+ -c, --checksum              always checksum
+ -a, --archive               archive mode
+ -r, --recursive             recurse into directories
+ -R, --relative              use relative path names
+ -b, --backup                make backups (default ~ suffix)
+     --suffix=SUFFIX         override backup suffix
+ -u, --update                update only (don't overwrite newer files)
+ -l, --links                 preserve soft links
+ -L, --copy-links            treat soft links like regular files
+     --copy-unsafe-links     copy links outside the source tree
+     --safe-links            ignore links outside the destination tree
+ -H, --hard-links            preserve hard links
+ -p, --perms                 preserve permissions
+ -o, --owner                 preserve owner (root only)
+ -g, --group                 preserve group
+ -D, --devices               preserve devices (root only)
+ -t, --times                 preserve times
+ -S, --sparse                handle sparse files efficiently
+ -n, --dry-run               show what would have been transferred
+ -W, --whole-file            copy whole files, no incremental checks
+ -x, --one-file-system       don't cross filesystem boundaries
+ -B, --block-size=SIZE       checksum blocking size (default 700)
+ -e, --rsh=COMMAND           specify rsh replacement
+     --rsync-path=PATH       specify path to rsync on the remote machine
+ -C, --cvs-exclude           auto ignore files in the same way CVS does
+     --delete                delete files that don't exist on the sending side
+     --delete-excluded       also delete excluded files on the receiving side
+     --partial               keep partially transferred files
+     --force                 force deletion of directories even if not empty
+     --numeric-ids           don't map uid/gid values by user/group name
+     --timeout=TIME          set IO timeout in seconds
+ -I, --ignore-times          don't exclude files that match length and time
+     --size-only             only use file size when determining if a file should be transferred
+ -T  --temp-dir=DIR          create temporary files in directory DIR
+     --compare-dest=DIR      also compare destination files relative to DIR
+ -z, --compress              compress file data
+     --exclude=PATTERN       exclude files matching PATTERN
+     --exclude-from=FILE     exclude patterns listed in FILE
+     --include=PATTERN       don't exclude files matching PATTERN
+     --include-from=FILE     don't exclude patterns listed in FILE
+     --version               print version number
+     --daemon                run as a rsync daemon
+     --config=FILE           specify alternate rsyncd.conf file
+     --port=PORT             specify alternate rsyncd port number
+     --stats                 give some file transfer stats
+     --progress              show progress during transfer
+     --log-format=FORMAT     log file transfers using specified format
+     --password-file=FILE    get password from FILE
+ -h, --help                  show this help screen
 
-Options:
--v, --verbose            increase verbosity
--c, --checksum           always checksum
--a, --archive            archive mode (same as -rlptDog)
--r, --recursive          recurse into directories
--R, --relative           use relative path names
--b, --backup             make backups (default ~ extension)
--u, --update             update only (don't overwrite newer files)
--l, --links              preserve soft links
--L, --copy-links         treat soft links like regular files
--H, --hard-links         preserve hard links
--p, --perms              preserve permissions
--o, --owner              preserve owner (root only)
--g, --group              preserve group
--D, --devices            preserve devices (root only)
--t, --times              preserve times
--S, --sparse             handle sparse files efficiently
--n, --dry-run            show what would have been transferred
--W, --whole-file         copy whole files, no incremental checks
--x, --one-file-system    don't cross filesystem boundaries
--B, --block-size SIZE    checksum blocking size
--e, --rsh COMMAND        specify rsh replacement
-    --rsync-path PATH    specify path to rsync on the remote machine
--C, --cvs-exclude        auto ignore files in the same way CVS does
-    --delete             delete files that don't exist on the sending side
-    --force              force deletion of directories even if not empty
-    --numeric-ids        don't map uid/gid values by user/group name
-    --timeout TIME       set IO timeout in seconds
--I, --ignore-times       don't exclude files that match length and time
--T  --temp-dir DIR       create temporary files in directory DIR
--z, --compress           compress file data
-    --exclude FILE       exclude file FILE
-    --exclude-from FILE  exclude files listed in FILE
-    --suffix SUFFIX      override backup suffix
-    --version            print version number
-    --daemon             run as a rsync daemon
-    --config FILE        specify alternate rsyncd.conf file
-    --port PORT          specify alternate rsyncd port number
 
 
 SETUP
 -----
 
 Rsync uses rsh or ssh for communication. It does not need to be setuid
-and requires no special privilages for installation. It does not
+and requires no special privileges for installation. It does not
 require a inetd entry or a daemon. You must, however, have a working
 rsh or ssh system. Using ssh is recommended for its security
 features. 
@@ -88,7 +113,7 @@ RSYNC SERVERS
 -------------
 
 rsync can also talk to "rsync servers" which can provide anonymous or
-authenticated rsync. See the rsync.conf(5) man page for details on how
+authenticated rsync. See the rsyncd.conf(5) man page for details on how
 to setup a rsync server. See the rsync(1) man page for info on how to
 connect to a rsync server.
 
@@ -100,25 +125,25 @@ There is a mailing list for the discussion of rsync and its
 applications. It is open to anyone to join. I will announce new
 versions on this list. 
 
-To join the mailing list send mail to listproc@samba.anu.edu.au with
+To join the mailing list send mail to listproc@samba.org with
 no subject and a body of "subscribe rsync Your Name".
 
-To send mail to everyone on the list send it to rsync@samba.anu.edu.au
+To send mail to everyone on the list send it to rsync@samba.org
 
 
 BUG REPORTS
 -----------
 
 If you have web access then please look at
-http://samba.anu.edu.au/rsync/ 
+http://rsync.samba.org/rsync/ 
 
 This will give you access to the bug tracking system used by the
 developers of rsync and will allow you to look at other bug reports or
 submit a new bug report.
 
 If you don't have web access then mail bug reports to
-rsync-bugs@samba.anu.edu.au or (if you think it will be of interest to
-lots of people) send it to rsync@samba.anu.edu.au
+rsync-bugs@samba.org or (if you think it will be of interest to lots
+of people) send it to rsync@samba.org
 
 
 CVS TREE
@@ -128,10 +153,10 @@ If you want to get the very latest version of rsync direct from the
 source code repository then you can use anonymous cvs. You will need a
 recent version of cvs then use the following commands:
 
-	cvs -d :pserver:cvs@samba.anu.edu.au:/cvsroot login
+	cvs -d :pserver:cvs@cvs.samba.org:/cvsroot login
 	Password: cvs
 
-	cvs -d :pserver:cvs@samba.anu.edu.au:/cvsroot co rsync
+	cvs -d :pserver:cvs@cvs.samba.org:/cvsroot co rsync
 
 Look at the cvs documentation for more details.
 
@@ -142,18 +167,13 @@ COPYRIGHT
 Rsync was written by Andrew Tridgell and Paul Mackerras, and is
 available under the Gnu Public License.
 
-tridge@samba.anu.edu.au
+tridge@samba.org
 paulus@cs.anu.edu.au
 
 
 AVAILABILITY
 ------------
 
-The main ftp site for rsync is ftp://samba.anu.edu.au/pub/rsync 
-This is also available as rsync://samba.anu.edu.au/rsyncftp/
-
-Mirrors are available at:
-
-ftp://sunsite.auc.dk/pub/unix/rsync
-ftp://ftp.sunet.se/pub/unix/admin/rsync
-ftp://ftp.fu-berlin.de/pub/unix/network/rsync/
+The main web site for rsync is http://rsync.samba.org/
+The main ftp site is ftp://rsync.samba.org/pub/rsync/
+This is also available as rsync://rsync.samba.org/rsyncftp/

access.c

@@ -34,7 +34,7 @@ static int match_hostname(char *host, char *tok)
 static int match_address(char *addr, char *tok)
 {
 	char *p;
-	unsigned long a, t, mask = ~0;
+	unsigned long a, t, mask = (unsigned long)~0;
 
 	if (!addr || !*addr) return 0;
 
@@ -68,6 +68,7 @@ static int match_address(char *addr, char *tok)
 			mask = ntohl(mask);
 		} else {
 			int bits = atoi(p+1);
+			if (bits == 0) return 1;
 			if (bits <= 0 || bits > 32) {
 				rprintf(FERROR,"malformed mask in %s\n", tok);
 				return 0;

acconfig.h

@@ -7,3 +7,9 @@
 #undef HAVE_UTIMBUF
 #undef ino_t
 #undef HAVE_CONNECT
+#undef HAVE_SHORT_INO_T
+#undef HAVE_GETOPT_LONG
+#undef REPLACE_INET_NTOA
+#undef REPLACE_INET_ATON
+#undef HAVE_GETTIMEOFDAY_TZ
+#undef HAVE_SOCKETPAIR

aclocal.m4

@@ -0,0 +1,23 @@
+dnl AC_VALIDATE_CACHE_SYSTEM_TYPE[(cmd)]
+dnl if the cache file is inconsistent with the current host,
+dnl target and build system types, execute CMD or print a default
+dnl error message.
+AC_DEFUN(AC_VALIDATE_CACHE_SYSTEM_TYPE, [
+    AC_REQUIRE([AC_CANONICAL_SYSTEM])
+    AC_MSG_CHECKING([config.cache system type])
+    if { test x"${ac_cv_host_system_type+set}" = x"set" &&
+         test x"$ac_cv_host_system_type" != x"$host"; } ||
+       { test x"${ac_cv_build_system_type+set}" = x"set" &&
+         test x"$ac_cv_build_system_type" != x"$build"; } ||
+       { test x"${ac_cv_target_system_type+set}" = x"set" &&
+         test x"$ac_cv_target_system_type" != x"$target"; }; then
+	AC_MSG_RESULT([different])
+	ifelse($#, 1, [$1],
+		[AC_MSG_ERROR(["you must remove config.cache and restart configure"])])
+    else
+	AC_MSG_RESULT([same])
+    fi
+    ac_cv_host_system_type="$host"
+    ac_cv_build_system_type="$build"
+    ac_cv_target_system_type="$target"
+])

authenticate.c

@@ -55,8 +55,8 @@ static void gen_challenge(char *addr, char *challenge)
 
 	memset(input, 0, sizeof(input));
 
-	strlcpy((char *)input, addr, 16);
-	gettimeofday(&tv, NULL);
+	strlcpy((char *)input, addr, 17);
+	sys_gettimeofday(&tv);
 	SIVAL(input, 16, tv.tv_sec);
 	SIVAL(input, 20, tv.tv_usec);
 	SIVAL(input, 24, getpid());
@@ -75,12 +75,33 @@ static int get_secret(int module, char *user, char *secret, int len)
 	int fd, found=0;
 	char line[MAXPATHLEN];
 	char *p, *pass=NULL;
+	STRUCT_STAT st;
+	int ok = 1;
+	extern int am_root;
 
 	if (!fname || !*fname) return 0;
 
 	fd = open(fname,O_RDONLY);
 	if (fd == -1) return 0;
 
+	if (do_stat(fname, &st) == -1) {
+		rprintf(FERROR,"stat(%s) : %s\n", fname, strerror(errno));
+		ok = 0;
+	} else if (lp_strict_modes(module)) {
+		if ((st.st_mode & 06) != 0) {
+			rprintf(FERROR,"secrets file must not be other-accessible (see strict modes option)\n");
+			ok = 0;
+		} else if (am_root && (st.st_uid != 0)) {
+			rprintf(FERROR,"secrets file must be owned by root when running as root (see strict modes)\n");
+			ok = 0;
+		}
+	}
+	if (!ok) {
+		rprintf(FERROR,"continuing without secrets file\n");
+		close(fd);
+		return 0;
+	}
+
 	while (!found) {
 		int i = 0;
 		memset(line, 0, sizeof(line));
@@ -111,8 +132,57 @@ static int get_secret(int module, char *user, char *secret, int len)
 	return 1;
 }
 
+static char *getpassf(char *filename)
+{
+	char buffer[100];
+	int len=0;
+	int fd=0;
+	STRUCT_STAT st;
+	int ok = 1;
+	extern int am_root;
+	char *envpw=getenv("RSYNC_PASSWORD");
+
+	if (!filename) return NULL;
+
+	if ( (fd=open(filename,O_RDONLY)) == -1) {
+		rprintf(FERROR,"could not open password file \"%s\"\n",filename);
+		if (envpw) rprintf(FERROR,"falling back to RSYNC_PASSWORD environment variable.\n");	
+		return NULL;
+	}
+	
+	if (do_stat(filename, &st) == -1) {
+		rprintf(FERROR,"stat(%s) : %s\n", filename, strerror(errno));
+		ok = 0;
+	} else if ((st.st_mode & 06) != 0) {
+		rprintf(FERROR,"password file must not be other-accessible\n");
+		ok = 0;
+	} else if (am_root && (st.st_uid != 0)) {
+		rprintf(FERROR,"password file must be owned by root when running as root\n");
+		ok = 0;
+	}
+	if (!ok) {
+		rprintf(FERROR,"continuing without password file\n");
+		if (envpw) rprintf(FERROR,"using RSYNC_PASSWORD environment variable.\n");
+		close(fd);
+		return NULL;
+	}
+
+	if (envpw) rprintf(FERROR,"RSYNC_PASSWORD environment variable ignored\n");
+
+	buffer[sizeof(buffer)-1]='\0';
+	if ( (len=read(fd,buffer,sizeof(buffer)-1)) > 0)
+	{
+		char *p = strtok(buffer,"\n\r");
+		close(fd);
+		if (p) p = strdup(p);
+		return p;
+	}	
+
+	return NULL;
+}
+
 /* generate a 16 byte hash from a password and challenge */
-void generate_hash(char *in, char *challenge, char *out)
+static void generate_hash(char *in, char *challenge, char *out)
 {
 	char buf[16];
 
@@ -125,21 +195,28 @@ void generate_hash(char *in, char *challenge, char *out)
 }
 
 /* possible negotiate authentication with the client. Use "leader" to
-   start off the auth if necessary */
-int auth_server(int fd, int module, char *addr, char *leader)
+   start off the auth if necessary 
+
+   return NULL if authentication failed
+
+   return "" if anonymous access
+
+   otherwise return username
+*/
+char *auth_server(int fd, int module, char *addr, char *leader)
 {
 	char *users = lp_auth_users(module);
 	char challenge[16];
 	char b64_challenge[30];
 	char line[MAXPATHLEN];
-	char user[100];
+	static char user[100];
 	char secret[100];
 	char pass[30];
 	char pass2[30];
 	char *tok;
 
 	/* if no auth list then allow anyone in! */
-	if (!users || !*users) return 1;
+	if (!users || !*users) return "";
 
 	gen_challenge(addr, challenge);
 	
@@ -148,18 +225,18 @@ int auth_server(int fd, int module, char *addr, char *leader)
 	io_printf(fd,"%s%s\n", leader, b64_challenge);
 
 	if (!read_line(fd, line, sizeof(line)-1)) {
-		return 0;
+		return NULL;
 	}
 
 	memset(user, 0, sizeof(user));
 	memset(pass, 0, sizeof(pass));
 
 	if (sscanf(line,"%99s %29s", user, pass) != 2) {
-		return 0;
+		return NULL;
 	}
 
 	users = strdup(users);
-	if (!users) return 0;
+	if (!users) return NULL;
 
 	for (tok=strtok(users," ,\t"); tok; tok = strtok(NULL," ,\t")) {
 		if (strcmp(tok, user) == 0) break;
@@ -167,19 +244,22 @@ int auth_server(int fd, int module, char *addr, char *leader)
 	free(users);
 
 	if (!tok) {
-		return 0;
+		return NULL;
 	}
 	
 	memset(secret, 0, sizeof(secret));
 	if (!get_secret(module, user, secret, sizeof(secret)-1)) {
 		memset(secret, 0, sizeof(secret));
-		return 0;
+		return NULL;
 	}
 
 	generate_hash(secret, b64_challenge, pass2);
 	memset(secret, 0, sizeof(secret));
 	
-	return (strcmp(pass, pass2) == 0);
+	if (strcmp(pass, pass2) == 0)
+		return user;
+
+	return NULL;
 }
 
 
@@ -187,10 +267,11 @@ void auth_client(int fd, char *user, char *challenge)
 {
 	char *pass;
 	char pass2[30];
+	extern char *password_file;
 
 	if (!user || !*user) return;
 
-	if (!(pass=getenv("RSYNC_PASSWORD"))) {
+	if (!(pass=getpassf(password_file)) && !(pass=getenv("RSYNC_PASSWORD"))) {
 		pass = getpass("Password: ");
 	}
 
@@ -199,7 +280,7 @@ void auth_client(int fd, char *user, char *challenge)
 	}
 
 	generate_hash(pass, challenge, pass2);
-	
 	io_printf(fd, "%s %s\n", user, pass2);
 }
 
+

backup.c

@@ -0,0 +1,291 @@
+/* 
+   Copyright (C) Andrew Tridgell 1999
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* backup handling code */
+
+#include "rsync.h"
+
+extern int verbose;
+extern char *backup_suffix;
+extern char *backup_dir;
+
+
+extern int am_root;
+extern int preserve_devices;
+extern int preserve_links;
+extern int preserve_hard_links;
+
+/* simple backup creates a backup with a suffix in the same directory */
+static int make_simple_backup(char *fname)
+{
+	char fnamebak[MAXPATHLEN];
+	if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
+		rprintf(FERROR,"backup filename too long\n");
+		return 0;
+	}
+
+	slprintf(fnamebak,sizeof(fnamebak),"%s%s",fname,backup_suffix);
+	if (do_rename(fname,fnamebak) != 0) {
+		/* cygwin (at least version b19) reports EINVAL */
+		if (errno != ENOENT && errno != EINVAL) {
+			rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
+			return 0;
+		}
+	} else if (verbose > 1) {
+		rprintf(FINFO,"backed up %s to %s\n",fname,fnamebak);
+	}
+	return 1;
+}
+
+
+/* recursively make a directory path */
+static int make_dir(char *name, int mask)
+{
+	char newdir [MAXPATHLEN];
+	char *p, *d;
+
+	/* copy pathname over, look for last '/' */
+	for (p = d = newdir; *name; *d++ = *name++)
+		if (*name == '/')
+			p = d;
+	if (p == newdir)
+		return 0;
+	*p = 0;
+
+	/* make the new directory, if that fails then make its parent */
+	while (do_mkdir (newdir, mask) != 0)
+		if ((errno != ENOENT) || !make_dir (newdir, mask))
+			return 0;
+
+	return 1;
+} /* make_dir */
+
+
+/****************************************************************************
+Create a directory given an absolute path, perms based upon another directory
+path
+****************************************************************************/
+static int make_bak_dir(char *fname,char *bak_path)
+{
+        STRUCT_STAT st;
+        STRUCT_STAT *st2;
+        char fullpath[MAXPATHLEN];
+        extern int orig_umask;
+        char *p;
+        char *q;
+
+        while(strncmp(bak_path,"./",2)==0) bak_path += 2;
+
+        if(bak_path[strlen(bak_path)-1]!='/') {
+                slprintf(fullpath,sizeof(fullpath),"%s/",bak_path);
+        } else {
+                slprintf(fullpath,sizeof(fullpath),"%s",bak_path);
+        }
+        p=fullpath;
+        q=&fullpath[strlen(fullpath)];  /* End of bak_path string */
+        strcat(fullpath,fname);
+
+        /* Make the directories */
+        while ((p=strchr(p,'/'))) {
+                *p = 0;
+                if(do_lstat(fullpath,&st)!=0) {
+                        do_mkdir(fullpath,0777 & ~orig_umask);
+                        if(p>q) {
+                                if(do_lstat(q,&st)!=0) {
+                                        rprintf(FERROR,"make_bak_dir stat %s : %s\n",fullpath,strerror(errno));
+                                } else {
+                                        st2=&st;
+                                        set_modtime(fullpath,st2->st_mtime);
+                                        if(do_lchown(fullpath,st2->st_uid,st2->st_gid)!=0) {
+                                                rprintf(FERROR,"make_bak_dir chown %s : %s\n",fullpath,strerror(errno));
+                                        };
+                                        if(do_chmod(fullpath,st2->st_mode)!=0) {
+                                                rprintf(FERROR,"make_bak_dir failed to set permissions on %s : %s\n",fullpath,strerror(errno));
+                                        };
+                                };
+                        }
+                };
+                *p = '/';
+                p++;
+        }
+        return 0;
+}
+
+/* robustly move a file, creating new directory structures if necessary */
+static int robust_move(char *src, char *dst)
+{
+	int keep_trying = 4;
+	int keep_path_extfs = 0;
+	int failed;
+
+	while (keep_trying) {
+		if (keep_path_extfs) {
+			failed = copy_file(src, dst, 0755);
+			if (!failed) {
+				do_unlink(src);
+			}
+		} else {
+			failed = robust_rename (src, dst);
+		}
+
+		if (failed) {
+			if (verbose > 2)
+				rprintf (FERROR, "robust_move failed: %s(%d)\n",
+					strerror (errno), errno);
+			switch (errno) {
+				/* external filesystem */
+				case EXDEV:
+					keep_path_extfs = 1;
+					keep_trying--;
+					break;
+				/* no directory to write to */
+				case ENOENT:
+					make_dir (dst, 0755);
+					keep_trying--;
+					break;
+				default:
+					keep_trying = 0;
+			} /* switch */
+		} else
+			keep_trying = 0;
+	} /* while */
+	return (!failed);
+} /* robust_move */
+
+
+/* if we have a backup_dir, then we get here from make_backup().
+   We will move the file to be deleted into a parallel directory tree */
+static int keep_backup(char *fname)
+{
+
+	static int initialised;
+
+	char keep_name [MAXPATHLEN];
+	STRUCT_STAT st;
+	struct file_struct *file;
+
+	int kept=0;
+	int ret_code;
+
+	if (!initialised) {
+		if (backup_dir[strlen(backup_dir) - 1] == '/')
+			backup_dir[strlen(backup_dir) - 1] = 0;
+		if (verbose > 0)
+			rprintf (FINFO, "backup_dir is %s\n", backup_dir);
+		initialised = 1;
+	}
+
+	/* return if no file to keep */
+#if SUPPORT_LINKS
+	if (do_lstat (fname, &st)) return 1;
+#else
+	if (do_stat (fname, &st)) return 1;
+#endif
+
+	file = make_file(-1, fname, NULL, 1);
+
+	/* the file could have disappeared */
+	if (!file) return 1;
+
+        /* make a complete pathname for backup file */
+        if (strlen(backup_dir) + strlen(fname) > (MAXPATHLEN - 1)) {
+                rprintf (FERROR, "keep_backup filename too long\n");
+                return 0;
+        }
+
+        slprintf(keep_name, sizeof (keep_name), "%s/%s", backup_dir, fname);
+
+
+#ifdef HAVE_MKNOD
+	/* Check to see if this is a device file, or link */
+        if(IS_DEVICE(file->mode)) {
+                if(am_root && preserve_devices) {
+                        make_bak_dir(fname,backup_dir);
+                        if(do_mknod(keep_name,file->mode,file->rdev)!=0) {
+                                rprintf(FERROR,"mknod %s : %s\n",keep_name,strerror(errno));
+                        } else {
+                                if(verbose>2)
+                                        rprintf(FINFO,"make_backup : DEVICE %s successful.\n",fname);
+                        };
+                };
+		kept=1;
+                do_unlink(fname);
+        };
+#endif
+
+	if(!kept && S_ISDIR(file->mode)) {
+		/* make an empty directory */
+                make_bak_dir(fname,backup_dir);
+                do_mkdir(keep_name,file->mode);
+                ret_code=do_rmdir(fname);
+                if(verbose>2)
+                        rprintf(FINFO,"make_backup : RMDIR %s returns %i\n",fname,ret_code);
+		kept=1;
+        };
+
+#if SUPPORT_LINKS
+        if(!kept && preserve_links && S_ISLNK(file->mode)) {
+                extern int safe_symlinks;
+                if (safe_symlinks && unsafe_symlink(file->link, keep_name)) {
+                        if (verbose) {
+                                rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n",
+                                        keep_name,file->link);
+                        }
+			kept=1;
+                }
+                make_bak_dir(fname,backup_dir);
+                if(do_symlink(file->link,keep_name) != 0) {
+                        rprintf(FERROR,"link %s -> %s : %s\n",keep_name,file->link,strerror(errno));
+                };
+                do_unlink(fname);
+		kept=1;
+        };
+#endif
+        if(!kept && preserve_hard_links && check_hard_link(file)) {
+                if(verbose > 1) rprintf(FINFO,"%s is a hard link\n",f_name(file));
+        };
+
+        if(!kept && !S_ISREG(file->mode)) {
+                rprintf(FINFO,"make_bak: skipping non-regular file %s\n",fname);
+        }
+
+	/* move to keep tree if a file */
+	if(!kept) {
+		if (!robust_move (fname, keep_name))
+			rprintf(FERROR, "keep_backup failed %s -> %s : %s\n",
+				fname, keep_name, strerror(errno));
+	};
+	set_perms (keep_name, file, NULL, 0);
+	free_file (file);
+	free (file);
+
+	if (verbose > 1)
+		rprintf (FINFO, "keep_backup %s -> %s\n", fname, keep_name);
+	return 1;
+} /* keep_backup */
+
+
+/* main backup switch routine */
+int make_backup(char *fname)
+{
+	if (backup_dir)
+		return (keep_backup(fname));
+	else
+		return (make_simple_backup(fname));
+}
+

checksum.c

@@ -49,82 +49,71 @@ uint32 get_checksum1(char *buf1,int len)
 }
 
 
-static void sum_put(MDstruct *md,char *sum)
-{
-  SIVAL(sum,0,md->buffer[0]);
-  if (csum_length <= 4) return;
-  SIVAL(sum,4,md->buffer[1]);
-  if (csum_length <= 8) return;
-  SIVAL(sum,8,md->buffer[2]);
-  if (csum_length <= 12) return;
-  SIVAL(sum,12,md->buffer[3]);
-}
-
-
 void get_checksum2(char *buf,int len,char *sum)
 {
-  int i;
-  MDstruct MD;
-  static char *buf1;
-  static int len1;
+	int i;
+	static char *buf1;
+	static int len1;
+	struct mdfour m;
 
-  if (len > len1) {
-    if (buf1) free(buf1);
-    buf1 = (char *)malloc(len+4);
-    len1 = len;
-    if (!buf1) out_of_memory("get_checksum2");
-  }
-
-  MDbegin(&MD);
-
-  bcopy(buf,buf1,len);
-  if (checksum_seed) {
-    SIVAL(buf1,len,checksum_seed);
-    len += 4;
-  }
-
-  for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
-    MDupdate(&MD, buf1+i, CSUM_CHUNK*8);
-  }
-  if (len - i > 0)
-    MDupdate(&MD, buf1+i, (len-i)*8);
-
-  sum_put(&MD,sum);
+	if (len > len1) {
+		if (buf1) free(buf1);
+		buf1 = (char *)malloc(len+4);
+		len1 = len;
+		if (!buf1) out_of_memory("get_checksum2");
+	}
+	
+	mdfour_begin(&m);
+	
+	memcpy(buf1,buf,len);
+	if (checksum_seed) {
+		SIVAL(buf1,len,checksum_seed);
+		len += 4;
+	}
+	
+	for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
+		mdfour_update(&m, (uchar *)(buf1+i), CSUM_CHUNK);
+	}
+	if (len - i > 0) {
+		mdfour_update(&m, (uchar *)(buf1+i), (len-i));
+	}
+	
+	mdfour_result(&m, (uchar *)sum);
 }
 
 
 void file_checksum(char *fname,char *sum,OFF_T size)
 {
-  OFF_T i;
-  MDstruct MD;
-  struct map_struct *buf;
-  int fd;
-  OFF_T len = size;
-  char tmpchunk[CSUM_CHUNK];
+	OFF_T i;
+	struct map_struct *buf;
+	int fd;
+	OFF_T len = size;
+	char tmpchunk[CSUM_CHUNK];
+	struct mdfour m;
+	
+	memset(sum,0,MD4_SUM_LENGTH);
+	
+	fd = do_open(fname, O_RDONLY, 0);
+	if (fd == -1) return;
+	
+	buf = map_file(fd,size);
+	
+	mdfour_begin(&m);
 
-  bzero(sum,csum_length);
+	for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
+		memcpy(tmpchunk, map_ptr(buf,i,CSUM_CHUNK), CSUM_CHUNK);
+		mdfour_update(&m, (uchar *)tmpchunk, CSUM_CHUNK);
+	}
 
-  fd = open(fname,O_RDONLY);
-  if (fd == -1) return;
+	if (len - i > 0) {
+		memcpy(tmpchunk, map_ptr(buf,i,len-i), len-i);
+		mdfour_update(&m, (uchar *)tmpchunk, (len-i));
+	}
 
-  buf = map_file(fd,size);
+	mdfour_result(&m, (uchar *)sum);
 
-  MDbegin(&MD);
-
-  for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
-    bcopy(map_ptr(buf,i,CSUM_CHUNK),tmpchunk,CSUM_CHUNK);
-    MDupdate(&MD, tmpchunk, CSUM_CHUNK*8);
-  }
-
-  if (len - i > 0) {
-    bcopy(map_ptr(buf,i,len-i),tmpchunk,len-i);
-    MDupdate(&MD, tmpchunk, (len-i)*8);
-  }
-
-  sum_put(&MD,sum);
-
-  close(fd);
-  unmap_file(buf);
+	close(fd);
+	unmap_file(buf);
 }
 
 
@@ -138,58 +127,54 @@ void checksum_init(void)
 
 
 
-static MDstruct sumMD;
 static int sumresidue;
 static char sumrbuf[CSUM_CHUNK];
+static struct mdfour md;
 
 void sum_init(void)
 {
-  char s[4];
-  MDbegin(&sumMD);  
-  sumresidue=0;
-  SIVAL(s,0,checksum_seed);
-  sum_update(s,4);
+	char s[4];
+	mdfour_begin(&md);
+	sumresidue=0;
+	SIVAL(s,0,checksum_seed);
+	sum_update(s,4);
 }
 
 void sum_update(char *p,int len)
 {
-  int i;
-  if (len + sumresidue < CSUM_CHUNK) {
-    bcopy(p,sumrbuf+sumresidue,len);
-    sumresidue += len;
-    return;
-  }
+	int i;
+	if (len + sumresidue < CSUM_CHUNK) {
+		memcpy(sumrbuf+sumresidue, p, len);
+		sumresidue += len;
+		return;
+	}
 
-  if (sumresidue) {
-    i = MIN(CSUM_CHUNK-sumresidue,len);
-    bcopy(p,sumrbuf+sumresidue,i);
-    MDupdate(&sumMD, sumrbuf, (i+sumresidue)*8);
-    len -= i;
-    p += i;
-  }
+	if (sumresidue) {
+		i = MIN(CSUM_CHUNK-sumresidue,len);
+		memcpy(sumrbuf+sumresidue,p,i);
+		mdfour_update(&md, (uchar *)sumrbuf, (i+sumresidue));
+		len -= i;
+		p += i;
+	}
 
-  for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
-    bcopy(p+i,sumrbuf,CSUM_CHUNK);
-    MDupdate(&sumMD, sumrbuf, CSUM_CHUNK*8);
-  }
+	for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
+		memcpy(sumrbuf,p+i,CSUM_CHUNK);
+		mdfour_update(&md, (uchar *)sumrbuf, CSUM_CHUNK);
+	}
 
-  if (len - i > 0) {
-    sumresidue = len-i;
-    bcopy(p+i,sumrbuf,sumresidue);
-  } else {
-    sumresidue = 0;    
-  }
+	if (len - i > 0) {
+		sumresidue = len-i;
+		memcpy(sumrbuf,p+i,sumresidue);
+	} else {
+		sumresidue = 0;    
+	}
 }
 
 void sum_end(char *sum)
 {
-  if (sumresidue)
-    MDupdate(&sumMD, sumrbuf, sumresidue*8);
+	if (sumresidue) {
+		mdfour_update(&md, (uchar *)sumrbuf, sumresidue);
+	}
 
-  SIVAL(sum,0,sumMD.buffer[0]);
-  SIVAL(sum,4,sumMD.buffer[1]);
-  SIVAL(sum,8,sumMD.buffer[2]);
-  SIVAL(sum,12,sumMD.buffer[3]);  
+	mdfour_result(&md, (uchar *)sum);
 }
-
-

cleanup.c

@@ -0,0 +1,91 @@
+/* 
+   Copyright (C) Andrew Tridgell 1996
+   Copyright (C) Paul Mackerras 1996
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "rsync.h"
+
+/* handling the cleanup when a transfer is interrupted is tricky when
+   --partial is selected. We need to ensure that the partial file is
+   kept if any real data has been transferred */
+int cleanup_got_literal=0;
+
+static char *cleanup_fname;
+static char *cleanup_new_fname;
+static struct file_struct *cleanup_file;
+static int cleanup_fd1, cleanup_fd2;
+static struct map_struct *cleanup_buf;
+static int cleanup_pid = 0;
+extern int io_error;
+
+void _exit_cleanup(int code, const char *file, int line)
+{
+	extern int keep_partial;
+
+	if (code == 0 && io_error) code = RERR_FILEIO;
+
+	signal(SIGUSR1, SIG_IGN);
+	signal(SIGUSR2, SIG_IGN);
+
+	if (cleanup_got_literal && cleanup_fname && keep_partial) {
+		char *fname = cleanup_fname;
+		cleanup_fname = NULL;
+		if (cleanup_buf) unmap_file(cleanup_buf);
+		if (cleanup_fd1 != -1) close(cleanup_fd1);
+		if (cleanup_fd2 != -1) close(cleanup_fd2);
+		finish_transfer(cleanup_new_fname, fname, cleanup_file);
+	}
+	io_flush();
+	if (cleanup_fname)
+		do_unlink(cleanup_fname);
+	if (code) {
+		kill_all(SIGUSR1);
+	}
+	if ((cleanup_pid != 0) && (cleanup_pid == (int) getpid())) {
+		char *pidf = lp_pid_file();
+		if (pidf && *pidf) {
+			unlink(lp_pid_file());
+		}
+	}
+
+	if (code) log_exit(code, file, line);
+
+	exit(code);
+}
+
+void cleanup_disable(void)
+{
+	cleanup_fname = NULL;
+	cleanup_got_literal = 0;
+}
+
+
+void cleanup_set(char *fnametmp, char *fname, struct file_struct *file,
+		 struct map_struct *buf, int fd1, int fd2)
+{
+	cleanup_fname = fnametmp;
+	cleanup_new_fname = fname;
+	cleanup_file = file;
+	cleanup_buf = buf;
+	cleanup_fd1 = fd1;
+	cleanup_fd2 = fd2;
+}
+
+void cleanup_set_pid(int pid)
+{
+	cleanup_pid = pid;
+}

clientserver.c

@@ -24,6 +24,8 @@ extern int module_id;
 extern int read_only;
 extern int verbose;
 extern int rsync_port;
+char *auth_user;
+int sanitize_paths = 0;
 
 int start_socket_client(char *host, char *path, int argc, char *argv[])
 {
@@ -33,6 +35,13 @@ int start_socket_client(char *host, char *path, int argc, char *argv[])
 	char line[MAXPATHLEN];
 	char *p, *user=NULL;
 	extern int remote_version;
+	extern int am_sender;
+	extern struct in_addr socket_address;
+
+	if (*path == '/') {
+		rprintf(FERROR,"ERROR: The remote path must start with a module name\n");
+		return -1;
+	}
 
 	p = strchr(host, '@');
 	if (p) {
@@ -44,9 +53,9 @@ int start_socket_client(char *host, char *path, int argc, char *argv[])
 	if (!user) user = getenv("USER");
 	if (!user) user = getenv("LOGNAME");
 
-	fd = open_socket_out(host, rsync_port);
+	fd = open_socket_out(host, rsync_port, &socket_address);
 	if (fd == -1) {
-		exit_cleanup(1);
+		exit_cleanup(RERR_SOCKETIO);
 	}
 	
 	server_options(sargs,&sargc);
@@ -92,6 +101,11 @@ int start_socket_client(char *host, char *path, int argc, char *argv[])
 	}
 	io_printf(fd,"\n");
 
+	if (remote_version < 23) {
+		if (remote_version == 22 || (remote_version > 17 && !am_sender))
+			io_start_multiplex_in(fd);
+	}
+
 	return client_run(fd, fd, -1, argc, argv);
 }
 
@@ -109,7 +123,13 @@ static int rsync_module(int fd, int i)
 	char *addr = client_addr(fd);
 	char *host = client_name(fd);
 	char *name = lp_name(i);
+	int use_chroot = lp_use_chroot(i);
 	int start_glob=0;
+	int ret;
+	char *request=NULL;
+	extern int am_sender;
+	extern int remote_version;
+	extern int am_root;
 
 	if (!allow_access(addr, host, lp_hosts_allow(i), lp_hosts_deny(i))) {
 		rprintf(FERROR,"rsync denied on module %s from %s (%s)\n",
@@ -119,76 +139,106 @@ static int rsync_module(int fd, int i)
 		return -1;
 	}
 
-	if (!auth_server(fd, i, addr, "@RSYNCD: AUTHREQD ")) {
+	if (!claim_connection(lp_lock_file(i), lp_max_connections(i))) {
+		if (errno) {
+			rprintf(FERROR,"failed to open lock file %s : %s\n",
+				lp_lock_file(i), strerror(errno));
+			io_printf(fd,"@ERROR: failed to open lock file %s : %s\n",
+				  lp_lock_file(i), strerror(errno));
+		} else {
+			rprintf(FERROR,"max connections (%d) reached\n",
+				lp_max_connections(i));
+			io_printf(fd,"@ERROR: max connections (%d) reached - try again later\n", lp_max_connections(i));
+		}
+		return -1;
+	}
+
+	
+	auth_user = auth_server(fd, i, addr, "@RSYNCD: AUTHREQD ");
+
+	if (!auth_user) {
 		rprintf(FERROR,"auth failed on module %s from %s (%s)\n",
 			name, client_name(fd), client_addr(fd));
 		io_printf(fd,"@ERROR: auth failed on module %s\n",name);
 		return -1;		
 	}
 
-	if (!claim_connection(lp_lock_file(), lp_max_connections())) {
-		rprintf(FERROR,"max connections (%d) reached\n",
-			lp_max_connections());
-		io_printf(fd,"@ERROR: max connections (%d) reached - try again later\n", lp_max_connections());
-		return -1;
-	}
-
-	
 	module_id = i;
 
-	if (lp_read_only(i))
-		read_only = 1;
+	am_root = (getuid() == 0);
 
-	p = lp_uid(i);
-	if (!name_to_uid(p, &uid)) {
-		if (!isdigit(*p)) {
-			rprintf(FERROR,"Invalid uid %s\n", p);
-			io_printf(fd,"@ERROR: invalid uid\n");
-			return -1;
-		} 
-		uid = atoi(p);
+	if (am_root) {
+		p = lp_uid(i);
+		if (!name_to_uid(p, &uid)) {
+			if (!isdigit(*p)) {
+				rprintf(FERROR,"Invalid uid %s\n", p);
+				io_printf(fd,"@ERROR: invalid uid\n");
+				return -1;
+			} 
+			uid = atoi(p);
+		}
+
+		p = lp_gid(i);
+		if (!name_to_gid(p, &gid)) {
+			if (!isdigit(*p)) {
+				rprintf(FERROR,"Invalid gid %s\n", p);
+				io_printf(fd,"@ERROR: invalid gid\n");
+				return -1;
+			} 
+			gid = atoi(p);
+		}
 	}
 
-	p = lp_gid(i);
-	if (!name_to_gid(p, &gid)) {
-		if (!isdigit(*p)) {
-			rprintf(FERROR,"Invalid gid %s\n", p);
-			io_printf(fd,"@ERROR: invalid gid\n");
-			return -1;
-		} 
-		gid = atoi(p);
-	}
+	p = lp_include_from(i);
+	add_exclude_file(p, 1, 1);
+
+	p = lp_include(i);
+	add_include_line(p);
 
 	p = lp_exclude_from(i);
-	add_exclude_file(p, 1);
+	add_exclude_file(p, 1, 0);
 
 	p = lp_exclude(i);
 	add_exclude_line(p);
 
 	log_open();
 
-	if (chroot(lp_path(i))) {
-		rprintf(FERROR,"chroot %s failed\n", lp_path(i));
-		io_printf(fd,"@ERROR: chroot failed\n");
-		return -1;
+	if (use_chroot) {
+		if (chroot(lp_path(i))) {
+			rprintf(FERROR,"chroot %s failed\n", lp_path(i));
+			io_printf(fd,"@ERROR: chroot failed\n");
+			return -1;
+		}
+
+		if (!push_dir("/", 0)) {
+			rprintf(FERROR,"chdir %s failed\n", lp_path(i));
+			io_printf(fd,"@ERROR: chdir failed\n");
+			return -1;
+		}
+
+	} else {
+		if (!push_dir(lp_path(i), 0)) {
+			rprintf(FERROR,"chdir %s failed\n", lp_path(i));
+			io_printf(fd,"@ERROR: chdir failed\n");
+			return -1;
+		}
+		sanitize_paths = 1;
 	}
 
-	if (chdir("/")) {
-		rprintf(FERROR,"chdir %s failed\n", lp_path(i));
-		io_printf(fd,"@ERROR: chdir failed\n");
-		return -1;
-	}
+	if (am_root) {
+		if (setgid(gid)) {
+			rprintf(FERROR,"setgid %d failed\n", gid);
+			io_printf(fd,"@ERROR: setgid failed\n");
+			return -1;
+		}
 
-	if (setgid(gid) || getgid() != gid) {
-		rprintf(FERROR,"setgid %d failed\n", gid);
-		io_printf(fd,"@ERROR: setgid failed\n");
-		return -1;
-	}
+		if (setuid(uid)) {
+			rprintf(FERROR,"setuid %d failed\n", uid);
+			io_printf(fd,"@ERROR: setuid failed\n");
+			return -1;
+		}
 
-	if (setuid(uid) || getuid() != uid) {
-		rprintf(FERROR,"setuid %d failed\n", uid);
-		io_printf(fd,"@ERROR: setuid failed\n");
-		return -1;
+		am_root = (getuid() == 0);
 	}
 
 	io_printf(fd,"@RSYNCD: OK\n");
@@ -211,8 +261,7 @@ static int rsync_module(int fd, int i)
 
 		if (start_glob) {
 			if (start_glob == 1) {
-				rprintf(FINFO,"rsync on %s from %s (%s)\n",
-					p, host, addr);
+				request = strdup(p);
 				start_glob++;
 			}
 			glob_expand(name, argv, &argc, MAX_ARGS);
@@ -229,15 +278,57 @@ static int rsync_module(int fd, int i)
 		}
 	}
 
-	parse_arguments(argc, argv);
+	if (sanitize_paths) {
+		/*
+		 * Note that this is applied to all parameters, whether or not
+		 *    they are filenames, but no other legal parameters contain
+		 *    the forms that need to be sanitized so it doesn't hurt;
+		 *    it is not known at this point which parameters are files
+		 *    and which aren't.
+		 */
+		for (i = 1; i < argc; i++) {
+			sanitize_path(argv[i], NULL);
+		}
+	}
 
+	ret = parse_arguments(argc, argv, 0);
+
+	if (request) {
+		if (*auth_user) {
+			rprintf(FINFO,"rsync %s %s from %s@%s (%s)\n",
+				am_sender?"on":"to",
+				request, auth_user, host, addr);
+		} else {
+			rprintf(FINFO,"rsync %s %s from %s (%s)\n",
+				am_sender?"on":"to",
+				request, host, addr);
+		}
+		free(request);
+	}
+
+#if !TRIDGE
 	/* don't allow the logs to be flooded too fast */
 	if (verbose > 1) verbose = 1;
+#endif
 
 	argc -= optind;
 	argp = argv + optind;
 	optind = 0;
 
+	if (remote_version < 23) {
+		if (remote_version == 22 || (remote_version > 17 && am_sender))
+			io_start_multiplex_out(fd);
+	}
+
+	if (!ret) {
+		option_error();
+	}
+
+	if (lp_timeout(i)) {
+		extern int io_timeout;
+		io_timeout = lp_timeout(i);
+	}
+
 	start_server(fd, fd, argc, argp);
 
 	return 0;
@@ -267,17 +358,17 @@ static int start_daemon(int fd)
 	extern int remote_version;
 
 	if (!lp_load(config_file, 0)) {
-		exit_cleanup(1);
+		exit_cleanup(RERR_SYNTAX);
 	}
 
 	set_socket_options(fd,"SO_KEEPALIVE");
 	set_socket_options(fd,lp_socket_options());
-	
+	set_nonblocking(fd);
 
 	io_printf(fd,"@RSYNCD: %d\n", PROTOCOL_VERSION);
 
 	motd = lp_motd_file();
-	if (*motd) {
+	if (motd && *motd) {
 		FILE *f = fopen(motd,"r");
 		while (f && !feof(f)) {
 			int len = fread(line, 1, sizeof(line)-1, f);
@@ -330,23 +421,49 @@ static int start_daemon(int fd)
 int daemon_main(void)
 {
 	extern char *config_file;
+	extern int orig_umask;
+	char *pid_file;
 
 	if (is_a_socket(STDIN_FILENO)) {
-		/* we are running via inetd */
+		int i;
+
+		/* we are running via inetd - close off stdout and
+		   stderr so that library functions (and getopt) don't
+		   try to use them. Redirect them to /dev/null */
+		for (i=1;i<3;i++) {
+			close(i); 
+			open("/dev/null", O_RDWR);
+		}
+
 		return start_daemon(STDIN_FILENO);
 	}
 
 	become_daemon();
 
 	if (!lp_load(config_file, 1)) {
-		fprintf(stderr,"failed to load config file %s\n", config_file);
-		exit_cleanup(1);
+		exit_cleanup(RERR_SYNTAX);
 	}
 
 	log_open();
 
 	rprintf(FINFO,"rsyncd version %s starting\n",VERSION);
 
+	if (((pid_file = lp_pid_file()) != NULL) && (*pid_file != '\0')) {
+		char pidbuf[16];
+		int fd;
+		int pid = (int) getpid();
+		cleanup_set_pid(pid);
+		if ((fd = do_open(lp_pid_file(), O_WRONLY|O_CREAT|O_TRUNC,
+					0666 & ~orig_umask)) == -1) {
+		    cleanup_set_pid(0);
+		    rprintf(FLOG,"failed to create pid file %s\n", pid_file);
+		    exit_cleanup(RERR_FILEIO);
+		}
+		slprintf(pidbuf, sizeof(pidbuf), "%d\n", pid);
+		write(fd, pidbuf, strlen(pidbuf));
+		close(fd);
+	}
+
 	start_accept_loop(rsync_port, start_daemon);
 	return -1;
 }

compat.c

@@ -23,8 +23,6 @@
 
 extern int am_server;
 
-extern int csum_length;
-
 extern int preserve_links;
 extern int preserve_perms;
 extern int preserve_devices;
@@ -44,10 +42,8 @@ void setup_protocol(int f_out,int f_in)
 		if (am_server) {
 			remote_version = read_int(f_in);
 			write_int(f_out,PROTOCOL_VERSION);
-			write_flush(f_out);
 		} else {
 			write_int(f_out,PROTOCOL_VERSION);
-			write_flush(f_out);
 			remote_version = read_int(f_in);
 		}
 	}
@@ -55,7 +51,8 @@ void setup_protocol(int f_out,int f_in)
 	if (remote_version < MIN_PROTOCOL_VERSION ||
 	    remote_version > MAX_PROTOCOL_VERSION) {
 		rprintf(FERROR,"protocol version mismatch - is your shell clean?\n");
-		exit_cleanup(1);
+		rprintf(FERROR,"(see the rsync man page for an explanation)\n");
+		exit_cleanup(RERR_PROTOCOL);
 	}	
 	
 	if (verbose > 2)

config.sub

@@ -0,0 +1,956 @@
+#! /bin/sh
+# Configuration validation subroutine script, version 1.1.
+#   Copyright (C) 1991, 92-97, 1998 Free Software Foundation, Inc.
+# This file is (in principle) common to ALL GNU software.
+# The presence of a machine in this file suggests that SOME GNU software
+# can handle that machine.  It does not imply ALL GNU software can.
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support.  The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+if [ x$1 = x ]
+then
+	echo Configuration name missing. 1>&2
+	echo "Usage: $0 CPU-MFR-OPSYS" 1>&2
+	echo "or     $0 ALIAS" 1>&2
+	echo where ALIAS is a recognized configuration type. 1>&2
+	exit 1
+fi
+
+# First pass through any local machine types.
+case $1 in
+	*local*)
+		echo $1
+		exit 0
+		;;
+	*)
+	;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+  linux-gnu*)
+    os=-$maybe_os
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+    ;;
+  *)
+    basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+    if [ $basic_machine != $1 ]
+    then os=`echo $1 | sed 's/.*-/-/'`
+    else os=; fi
+    ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work.  We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+	-sun*os*)
+		# Prevent following clause from handling this invalid input.
+		;;
+	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+	-apple)
+		os=
+		basic_machine=$1
+		;;
+	-hiux*)
+		os=-hiuxwe2
+		;;
+	-sco5)
+		os=sco3.2v5
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco4)
+		os=-sco3.2v4
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2.[4-9]*)
+		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2v[4-9]*)
+		# Don't forget version if it is 3.2v4 or newer.
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco*)
+		os=-sco3.2v2
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-isc)
+		os=-isc2.2
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-clix*)
+		basic_machine=clipper-intergraph
+		;;
+	-isc*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-lynx*)
+		os=-lynxos
+		;;
+	-ptx*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+		;;
+	-windowsnt*)
+		os=`echo $os | sed -e 's/windowsnt/winnt/'`
+		;;
+	-psos*)
+		os=-psos
+		;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+	# Recognize the basic CPU types without company name.
+	# Some are omitted here because they have special meanings below.
+	tahoe | i860 | m32r | m68k | m68000 | m88k | ns32k | arc | arm \
+		| arme[lb] | pyramid | mn10200 | mn10300 | tron | a29k \
+		| 580 | i960 | h8300 | hppa | hppa1.0 | hppa1.1 | hppa2.0 \
+		| alpha | alphaev5 | alphaev56 | we32k | ns16k | clipper \
+		| i370 | sh | powerpc | powerpcle | 1750a | dsp16xx | pdp11 \
+		| mips64 | mipsel | mips64el | mips64orion | mips64orionel \
+		| mipstx39 | mipstx39el \
+		| sparc | sparclet | sparclite | sparc64 | v850)
+		basic_machine=$basic_machine-unknown
+		;;
+	# We use `pc' rather than `unknown'
+	# because (1) that's what they normally are, and
+	# (2) the word "unknown" tends to confuse beginning users.
+	i[34567]86)
+	  basic_machine=$basic_machine-pc
+	  ;;
+	# Object if more than one company name word.
+	*-*-*)
+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+		exit 1
+		;;
+	# Recognize the basic CPU types with company name.
+	vax-* | tahoe-* | i[34567]86-* | i860-* | m32r-* | m68k-* | m68000-* \
+	      | m88k-* | sparc-* | ns32k-* | fx80-* | arc-* | arm-* | c[123]* \
+	      | mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \
+	      | power-* | none-* | 580-* | cray2-* | h8300-* | i960-* \
+	      | xmp-* | ymp-* | hppa-* | hppa1.0-* | hppa1.1-* | hppa2.0-* \
+	      | alpha-* | alphaev5-* | alphaev56-* | we32k-* | cydra-* \
+	      | ns16k-* | pn-* | np1-* | xps100-* | clipper-* | orion-* \
+	      | sparclite-* | pdp11-* | sh-* | powerpc-* | powerpcle-* \
+	      | sparc64-* | mips64-* | mipsel-* \
+	      | mips64el-* | mips64orion-* | mips64orionel-*  \
+	      | mipstx39-* | mipstx39el-* \
+	      | f301-*)
+		;;
+	# Recognize the various machine names and aliases which stand
+	# for a CPU type and a company and sometimes even an OS.
+	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+		basic_machine=m68000-att
+		;;
+	3b*)
+		basic_machine=we32k-att
+		;;
+	alliant | fx80)
+		basic_machine=fx80-alliant
+		;;
+	altos | altos3068)
+		basic_machine=m68k-altos
+		;;
+	am29k)
+		basic_machine=a29k-none
+		os=-bsd
+		;;
+	amdahl)
+		basic_machine=580-amdahl
+		os=-sysv
+		;;
+	amiga | amiga-*)
+		basic_machine=m68k-cbm
+		;;
+	amigaos | amigados)
+		basic_machine=m68k-cbm
+		os=-amigaos
+		;;
+	amigaunix | amix)
+		basic_machine=m68k-cbm
+		os=-sysv4
+		;;
+	apollo68)
+		basic_machine=m68k-apollo
+		os=-sysv
+		;;
+	aux)
+		basic_machine=m68k-apple
+		os=-aux
+		;;
+	balance)
+		basic_machine=ns32k-sequent
+		os=-dynix
+		;;
+	convex-c1)
+		basic_machine=c1-convex
+		os=-bsd
+		;;
+	convex-c2)
+		basic_machine=c2-convex
+		os=-bsd
+		;;
+	convex-c32)
+		basic_machine=c32-convex
+		os=-bsd
+		;;
+	convex-c34)
+		basic_machine=c34-convex
+		os=-bsd
+		;;
+	convex-c38)
+		basic_machine=c38-convex
+		os=-bsd
+		;;
+	cray | ymp)
+		basic_machine=ymp-cray
+		os=-unicos
+		;;
+	cray2)
+		basic_machine=cray2-cray
+		os=-unicos
+		;;
+	[ctj]90-cray)
+		basic_machine=c90-cray
+		os=-unicos
+		;;
+	crds | unos)
+		basic_machine=m68k-crds
+		;;
+	da30 | da30-*)
+		basic_machine=m68k-da30
+		;;
+	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+		basic_machine=mips-dec
+		;;
+	delta | 3300 | motorola-3300 | motorola-delta \
+	      | 3300-motorola | delta-motorola)
+		basic_machine=m68k-motorola
+		;;
+	delta88)
+		basic_machine=m88k-motorola
+		os=-sysv3
+		;;
+	dpx20 | dpx20-*)
+		basic_machine=rs6000-bull
+		os=-bosx
+		;;
+	dpx2* | dpx2*-bull)
+		basic_machine=m68k-bull
+		os=-sysv3
+		;;
+	ebmon29k)
+		basic_machine=a29k-amd
+		os=-ebmon
+		;;
+	elxsi)
+		basic_machine=elxsi-elxsi
+		os=-bsd
+		;;
+	encore | umax | mmax)
+		basic_machine=ns32k-encore
+		;;
+	fx2800)
+		basic_machine=i860-alliant
+		;;
+	genix)
+		basic_machine=ns32k-ns
+		;;
+	gmicro)
+		basic_machine=tron-gmicro
+		os=-sysv
+		;;
+	h3050r* | hiux*)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	h8300hms)
+		basic_machine=h8300-hitachi
+		os=-hms
+		;;
+	harris)
+		basic_machine=m88k-harris
+		os=-sysv3
+		;;
+	hp300-*)
+		basic_machine=m68k-hp
+		;;
+	hp300bsd)
+		basic_machine=m68k-hp
+		os=-bsd
+		;;
+	hp300hpux)
+		basic_machine=m68k-hp
+		os=-hpux
+		;;
+	hp9k2[0-9][0-9] | hp9k31[0-9])
+		basic_machine=m68000-hp
+		;;
+	hp9k3[2-9][0-9])
+		basic_machine=m68k-hp
+		;;
+	hp9k7[0-9][0-9] | hp7[0-9][0-9] | hp9k8[0-9]7 | hp8[0-9]7)
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[0-9][0-9] | hp8[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hppa-next)
+		os=-nextstep3
+		;;
+	i370-ibm* | ibm*)
+		basic_machine=i370-ibm
+		os=-mvs
+		;;
+# I'm not sure what "Sysv32" means.  Should this be sysv3.2?
+	i[34567]86v32)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv32
+		;;
+	i[34567]86v4*)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv4
+		;;
+	i[34567]86v)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv
+		;;
+	i[34567]86sol2)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-solaris2
+		;;
+	iris | iris4d)
+		basic_machine=mips-sgi
+		case $os in
+		    -irix*)
+			;;
+		    *)
+			os=-irix4
+			;;
+		esac
+		;;
+	isi68 | isi)
+		basic_machine=m68k-isi
+		os=-sysv
+		;;
+	m88k-omron*)
+		basic_machine=m88k-omron
+		;;
+	magnum | m3230)
+		basic_machine=mips-mips
+		os=-sysv
+		;;
+	merlin)
+		basic_machine=ns32k-utek
+		os=-sysv
+		;;
+	miniframe)
+		basic_machine=m68000-convergent
+		;;
+	mipsel*-linux*)
+		basic_machine=mipsel-unknown
+		os=-linux-gnu
+		;;
+	mips*-linux*)
+		basic_machine=mips-unknown
+		os=-linux-gnu
+		;;
+	mips3*-*)
+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+		;;
+	mips3*)
+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+		;;
+	ncr3000)
+		basic_machine=i486-ncr
+		os=-sysv4
+		;;
+	news | news700 | news800 | news900)
+		basic_machine=m68k-sony
+		os=-newsos
+		;;
+	news1000)
+		basic_machine=m68030-sony
+		os=-newsos
+		;;
+	news-3600 | risc-news)
+		basic_machine=mips-sony
+		os=-newsos
+		;;
+	next | m*-next )
+		basic_machine=m68k-next
+		case $os in
+		    -nextstep* )
+			;;
+		    -ns2*)
+		      os=-nextstep2
+			;;
+		    *)
+		      os=-nextstep3
+			;;
+		esac
+		;;
+	nh3000)
+		basic_machine=m68k-harris
+		os=-cxux
+		;;
+	nh[45]000)
+		basic_machine=m88k-harris
+		os=-cxux
+		;;
+	nindy960)
+		basic_machine=i960-intel
+		os=-nindy
+		;;
+	np1)
+		basic_machine=np1-gould
+		;;
+	pa-hitachi)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	paragon)
+		basic_machine=i860-intel
+		os=-osf
+		;;
+	pbd)
+		basic_machine=sparc-tti
+		;;
+	pbb)
+		basic_machine=m68k-tti
+		;;
+        pc532 | pc532-*)
+		basic_machine=ns32k-pc532
+		;;
+	pentium | p5 | k5 | nexen)
+		basic_machine=i586-pc
+		;;
+	pentiumpro | p6 | k6 | 6x86)
+		basic_machine=i686-pc
+		;;
+	pentiumii | pentium2)
+		basic_machine=i786-pc
+		;;
+	pentium-* | p5-* | k5-* | nexen-*)
+		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentiumpro-* | p6-* | k6-* | 6x86-*)
+		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentiumii-* | pentium2-*)
+		basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pn)
+		basic_machine=pn-gould
+		;;
+	power)	basic_machine=rs6000-ibm
+		;;
+	ppc)	basic_machine=powerpc-unknown
+	        ;;
+	ppc-*)	basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppcle | powerpclittle | ppc-le | powerpc-little)
+		basic_machine=powerpcle-unknown
+	        ;;
+	ppcle-* | powerpclittle-*)
+		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ps2)
+		basic_machine=i386-ibm
+		;;
+	rm[46]00)
+		basic_machine=mips-siemens
+		;;
+	rtpc | rtpc-*)
+		basic_machine=romp-ibm
+		;;
+	sequent)
+		basic_machine=i386-sequent
+		;;
+	sh)
+		basic_machine=sh-hitachi
+		os=-hms
+		;;
+	sps7)
+		basic_machine=m68k-bull
+		os=-sysv2
+		;;
+	spur)
+		basic_machine=spur-unknown
+		;;
+	sun2)
+		basic_machine=m68000-sun
+		;;
+	sun2os3)
+		basic_machine=m68000-sun
+		os=-sunos3
+		;;
+	sun2os4)
+		basic_machine=m68000-sun
+		os=-sunos4
+		;;
+	sun3os3)
+		basic_machine=m68k-sun
+		os=-sunos3
+		;;
+	sun3os4)
+		basic_machine=m68k-sun
+		os=-sunos4
+		;;
+	sun4os3)
+		basic_machine=sparc-sun
+		os=-sunos3
+		;;
+	sun4os4)
+		basic_machine=sparc-sun
+		os=-sunos4
+		;;
+	sun4sol2)
+		basic_machine=sparc-sun
+		os=-solaris2
+		;;
+	sun3 | sun3-*)
+		basic_machine=m68k-sun
+		;;
+	sun4)
+		basic_machine=sparc-sun
+		;;
+	sun386 | sun386i | roadrunner)
+		basic_machine=i386-sun
+		;;
+	symmetry)
+		basic_machine=i386-sequent
+		os=-dynix
+		;;
+	tx39)
+		basic_machine=mipstx39-unknown
+		;;
+	tx39el)
+		basic_machine=mipstx39el-unknown
+		;;
+	tower | tower-32)
+		basic_machine=m68k-ncr
+		;;
+	udi29k)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	ultra3)
+		basic_machine=a29k-nyu
+		os=-sym1
+		;;
+	vaxv)
+		basic_machine=vax-dec
+		os=-sysv
+		;;
+	vms)
+		basic_machine=vax-dec
+		os=-vms
+		;;
+	vpp*|vx|vx-*)
+               basic_machine=f301-fujitsu
+               ;;
+	vxworks960)
+		basic_machine=i960-wrs
+		os=-vxworks
+		;;
+	vxworks68)
+		basic_machine=m68k-wrs
+		os=-vxworks
+		;;
+	vxworks29k)
+		basic_machine=a29k-wrs
+		os=-vxworks
+		;;
+	xmp)
+		basic_machine=xmp-cray
+		os=-unicos
+		;;
+        xps | xps100)
+		basic_machine=xps100-honeywell
+		;;
+	none)
+		basic_machine=none-none
+		os=-none
+		;;
+
+# Here we handle the default manufacturer of certain CPU types.  It is in
+# some cases the only manufacturer, in others, it is the most popular.
+	mips)
+		if [ x$os = x-linux-gnu ]; then
+			basic_machine=mips-unknown
+		else
+			basic_machine=mips-mips
+		fi
+		;;
+	romp)
+		basic_machine=romp-ibm
+		;;
+	rs6000)
+		basic_machine=rs6000-ibm
+		;;
+	vax)
+		basic_machine=vax-dec
+		;;
+	pdp11)
+		basic_machine=pdp11-dec
+		;;
+	we32k)
+		basic_machine=we32k-att
+		;;
+	sparc)
+		basic_machine=sparc-sun
+		;;
+        cydra)
+		basic_machine=cydra-cydrome
+		;;
+	orion)
+		basic_machine=orion-highlevel
+		;;
+	orion105)
+		basic_machine=clipper-highlevel
+		;;
+	*)
+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+		exit 1
+		;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+	*-digital*)
+		basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+		;;
+	*-commodore*)
+		basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+		;;
+	*)
+		;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+        # First match some system type aliases
+        # that might get confused with valid system types.
+	# -solaris* is a basic system type, with this one exception.
+	-solaris1 | -solaris1.*)
+		os=`echo $os | sed -e 's|solaris1|sunos4|'`
+		;;
+	-solaris)
+		os=-solaris2
+		;;
+	-svr4*)
+		os=-sysv4
+		;;
+	-unixware*)
+		os=-sysv4.2uw
+		;;
+	-gnu/linux*)
+		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+		;;
+	# First accept the basic system types.
+	# The portable systems comes first.
+	# Each alternative MUST END IN A *, to match a version number.
+	# -sysv* is not here because it comes later, after sysvr4.
+	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\
+	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \
+	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+	      | -aos* \
+	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+	      | -hiux* | -386bsd* | -netbsd* | -openbsd* | -freebsd* | -riscix* \
+	      | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* \
+	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+	      | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+	      | -mingw32* | -linux-gnu* | -uxpv* | -beos* | -rhapsody* \
+	      | -openstep*)
+	# Remember, each alternative MUST END IN *, to match a version number.
+		;;
+	-linux*)
+		os=`echo $os | sed -e 's|linux|linux-gnu|'`
+		;;
+	-sunos5*)
+		os=`echo $os | sed -e 's|sunos5|solaris2|'`
+		;;
+	-sunos6*)
+		os=`echo $os | sed -e 's|sunos6|solaris3|'`
+		;;
+	-osfrose*)
+		os=-osfrose
+		;;
+	-osf*)
+		os=-osf
+		;;
+	-utek*)
+		os=-bsd
+		;;
+	-dynix*)
+		os=-bsd
+		;;
+	-acis*)
+		os=-aos
+		;;
+	-ctix* | -uts*)
+		os=-sysv
+		;;
+	-ns2 )
+	        os=-nextstep2
+		;;
+	# Preserve the version number of sinix5.
+	-sinix5.*)
+		os=`echo $os | sed -e 's|sinix|sysv|'`
+		;;
+	-sinix*)
+		os=-sysv4
+		;;
+	-triton*)
+		os=-sysv3
+		;;
+	-oss*)
+		os=-sysv3
+		;;
+	-svr4)
+		os=-sysv4
+		;;
+	-svr3)
+		os=-sysv3
+		;;
+	-sysvr4)
+		os=-sysv4
+		;;
+	# This must come after -sysvr4.
+	-sysv*)
+		;;
+	-xenix)
+		os=-xenix
+		;;
+	-none)
+		;;
+	*)
+		# Get rid of the `-' at the beginning of $os.
+		os=`echo $os | sed 's/[^-]*-//'`
+		echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+		exit 1
+		;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system.  Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+	*-acorn)
+		os=-riscix1.2
+		;;
+	arm*-semi)
+		os=-aout
+		;;
+        pdp11-*)
+		os=-none
+		;;
+	*-dec | vax-*)
+		os=-ultrix4.2
+		;;
+	m68*-apollo)
+		os=-domain
+		;;
+	i386-sun)
+		os=-sunos4.0.2
+		;;
+	m68000-sun)
+		os=-sunos3
+		# This also exists in the configure program, but was not the
+		# default.
+		# os=-sunos4
+		;;
+	*-tti)	# must be before sparc entry or we get the wrong os.
+		os=-sysv3
+		;;
+	sparc-* | *-sun)
+		os=-sunos4.1.1
+		;;
+	*-be)
+		os=-beos
+		;;
+	*-ibm)
+		os=-aix
+		;;
+	*-hp)
+		os=-hpux
+		;;
+	*-hitachi)
+		os=-hiux
+		;;
+	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+		os=-sysv
+		;;
+	*-cbm)
+		os=-amigaos
+		;;
+	*-dg)
+		os=-dgux
+		;;
+	*-dolphin)
+		os=-sysv3
+		;;
+	m68k-ccur)
+		os=-rtu
+		;;
+	m88k-omron*)
+		os=-luna
+		;;
+	*-next )
+		os=-nextstep
+		;;
+	*-sequent)
+		os=-ptx
+		;;
+	*-crds)
+		os=-unos
+		;;
+	*-ns)
+		os=-genix
+		;;
+	i370-*)
+		os=-mvs
+		;;
+	*-next)
+		os=-nextstep3
+		;;
+        *-gould)
+		os=-sysv
+		;;
+        *-highlevel)
+		os=-bsd
+		;;
+	*-encore)
+		os=-bsd
+		;;
+        *-sgi)
+		os=-irix
+		;;
+        *-siemens)
+		os=-sysv4
+		;;
+	*-masscomp)
+		os=-rtu
+		;;
+	f301-fujitsu)
+		os=-uxpv
+		;;
+	*)
+		os=-none
+		;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer.  We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+	*-unknown)
+		case $os in
+			-riscix*)
+				vendor=acorn
+				;;
+			-sunos*)
+				vendor=sun
+				;;
+			-aix*)
+				vendor=ibm
+				;;
+			-hpux*)
+				vendor=hp
+				;;
+			-hiux*)
+				vendor=hitachi
+				;;
+			-unos*)
+				vendor=crds
+				;;
+			-dgux*)
+				vendor=dg
+				;;
+			-luna*)
+				vendor=omron
+				;;
+			-genix*)
+				vendor=ns
+				;;
+			-mvs*)
+				vendor=ibm
+				;;
+			-ptx*)
+				vendor=sequent
+				;;
+			-vxsim* | -vxworks*)
+				vendor=wrs
+				;;
+			-aux*)
+				vendor=apple
+				;;
+		esac
+		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+		;;
+esac
+
+echo $basic_machine$os

configure.in

@@ -2,6 +2,12 @@ dnl Process this file with autoconf to produce a configure script.
 AC_INIT(byteorder.h)
 AC_CONFIG_HEADER(config.h)
 
+# compile with optimisation and without debugging by default
+CFLAGS=${CFLAGS-"-O"}
+
+AC_CANONICAL_SYSTEM
+AC_VALIDATE_CACHE_SYSTEM_TYPE
+
 dnl Checks for programs.
 AC_PROG_CC
 AC_PROG_INSTALL
@@ -10,12 +16,14 @@ AC_SUBST(SHELL)
 AC_CHECK_PROG(HAVE_REMSH, remsh, 1, 0)
 AC_DEFINE_UNQUOTED(HAVE_REMSH, $HAVE_REMSH)
 
+AC_C_BIGENDIAN
 AC_HEADER_DIRENT
 AC_HEADER_TIME
 AC_HEADER_SYS_WAIT
 AC_CHECK_HEADERS(sys/fcntl.h sys/select.h fcntl.h sys/time.h sys/unistd.h unistd.h utime.h grp.h)
 AC_CHECK_HEADERS(compat.h sys/param.h ctype.h sys/wait.h sys/ioctl.h)
 AC_CHECK_HEADERS(sys/filio.h string.h stdlib.h sys/socket.h sys/mode.h)
+AC_CHECK_HEADERS(glob.h)
 
 AC_CHECK_SIZEOF(int)
 AC_CHECK_SIZEOF(long)
@@ -29,92 +37,229 @@ AC_TYPE_MODE_T
 AC_TYPE_OFF_T
 AC_TYPE_SIZE_T
 AC_TYPE_PID_T
+AC_TYPE_GETGROUPS
 AC_STRUCT_ST_RDEV
 AC_CHECK_TYPE(ino_t,unsigned)
 
-echo $ac_n "checking for errno in errno.h... $ac_c"
-AC_TRY_COMPILE([#include <errno.h>],[int i = errno],
-echo yes; AC_DEFINE(HAVE_ERRNO_DECL),
-echo no)
-
-AC_FUNC_MEMCMP
-AC_FUNC_MMAP
-AC_FUNC_UTIME_NULL
-AC_CHECK_FUNCS(waitpid strtok pipe getcwd mkdir strdup strerror chown chmod mknod)
-AC_CHECK_FUNCS(fchmod fstat strchr bcopy bzero readlink link utime utimes)
-AC_CHECK_FUNCS(memmove getopt_long lchown setlinebuf vsnprintf setsid glob)
-
-echo $ac_n "checking for working fnmatch... $ac_c"
-AC_TRY_RUN([#include <fnmatch.h>
-main() { exit(fnmatch("*.o", "x.o", 0) == 0? 0: 1); }],
-echo yes;AC_DEFINE(HAVE_FNMATCH), 
-echo no)
-
-echo $ac_n "checking for long long ... $ac_c"
-AC_TRY_RUN([#include <stdio.h>
-main() { long long x = 1000000; x *= x; exit(((x/1000000) == 1000000)? 0: 1); }],
-echo yes;AC_DEFINE(HAVE_LONGLONG), 
-echo no)
-
-echo $ac_n "checking for off64_t ... $ac_c"
-AC_TRY_RUN([#include <stdio.h>
-#include <sys/stat.h>
-main() { struct stat64 st; off64_t s; if (sizeof(off_t) == sizeof(off64_t)) return 1; exit((lstat64("/dev/null", &st)==0)?0:1); }],
-echo yes;AC_DEFINE(HAVE_OFF64_T), 
-echo no)
-
-echo $ac_n "checking for unsigned char ... $ac_c"
-AC_TRY_RUN([#include <stdio.h>
-main() { char c; c=250; exit((c > 0)?0:1); }],
-echo yes;AC_DEFINE(HAVE_UNSIGNED_CHAR), 
-echo no)
-
-echo $ac_n "checking for broken readdir ... $ac_c"
-AC_TRY_RUN([#include <sys/types.h>
-#include <dirent.h>
-main() { struct dirent *di; DIR *d = opendir("."); di = readdir(d);
-if (di && di->d_name[-2] == '.' && di->d_name[-1] == 0 &&
-di->d_name[0] == 0) return 0; return 1;} ],
-echo yes - you are using the broken /usr/ucb/cc;AC_DEFINE(HAVE_BROKEN_READDIR), 
-echo no)
-
-echo $ac_n "checking for utimbuf ... $ac_c"
-AC_TRY_COMPILE([#include <sys/types.h>
-#include <utime.h>],
-[struct utimbuf tbuf;  tbuf.actime = 0; tbuf.modtime = 1; return utime("foo.c",&tbuf);],
-echo yes;AC_DEFINE(HAVE_UTIMBUF), 
-echo no)
+AC_CACHE_CHECK([for errno in errno.h],rsync_cv_errno, [
+    AC_TRY_COMPILE([#include <errno.h>],[int i = errno],
+	rsync_cv_errno=yes,rsync_cv_have_errno_decl=no)])
+if test x"$rsync_cv_errno" = x"yes"; then
+   AC_DEFINE(HAVE_ERRNO_DECL)
+fi
 
 # The following test taken from the cvs sources
 # If we can't find connect, try looking in -lsocket, -lnsl, and -linet.
+# These need checks to be before checks for any other functions that
+#    might be in the same libraries.
 # The Irix 5 libc.so has connect and gethostbyname, but Irix 5 also has
 # libsocket.so which has a bad implementation of gethostbyname (it
 # only looks in /etc/hosts), so we only look for -lsocket if we need
 # it.
-AC_CHECK_FUNC(connect, :, 
-[case "$LIBS" in
-*-lnsl*) ;;
-*) AC_CHECK_LIB(nsl_s, printf) ;;
-esac
-case "$LIBS" in
-*-lnsl*) ;;
-*) AC_CHECK_LIB(nsl, printf) ;;
-esac
-case "$LIBS" in
-*-lsocket*) ;;
-*) AC_CHECK_LIB(socket, connect) ;;
-esac
-case "$LIBS" in
-*-linet*) ;;
-*) AC_CHECK_LIB(inet, connect) ;;
-esac
-dnl We can't just call AC_CHECK_FUNCS(connect) here, because the value
-dnl has been cached.
-if test "$ac_cv_lib_socket_connect" = "yes" || 
-   test "$ac_cv_lib_inet_connect" = "yes"; then
-  ac_cv_func_connect=yes
-  AC_DEFINE(HAVE_CONNECT)
-fi])
+AC_CHECK_FUNCS(connect)
+if test x"$ac_cv_func_connect" = x"no"; then
+    case "$LIBS" in
+    *-lnsl*) ;;
+    *) AC_CHECK_LIB(nsl_s, printf) ;;
+    esac
+    case "$LIBS" in
+    *-lnsl*) ;;
+    *) AC_CHECK_LIB(nsl, printf) ;;
+    esac
+    case "$LIBS" in
+    *-lsocket*) ;;
+    *) AC_CHECK_LIB(socket, connect) ;;
+    esac
+    case "$LIBS" in
+    *-linet*) ;;
+    *) AC_CHECK_LIB(inet, connect) ;;
+    esac
+    dnl We can't just call AC_CHECK_FUNCS(connect) here, because the value
+    dnl has been cached.
+    if test x"$ac_cv_lib_socket_connect" = x"yes" || 
+       test x"$ac_cv_lib_inet_connect" = x"yes"; then
+        # ac_cv_func_connect=yes
+        # don't!  it would cause AC_CHECK_FUNC to succeed next time configure is run
+        AC_DEFINE(HAVE_CONNECT)
+    fi
+fi
+
+# 
+# if we can't find strcasecmp, look in -lresolv (for Unixware at least)
+#
+AC_CHECK_FUNCS(strcasecmp)
+if test x"$ac_cv_func_strcasecmp" = x"no"; then
+    AC_CHECK_LIB(resolv, strcasecmp)
+fi
+
+AC_FUNC_MEMCMP
+AC_FUNC_UTIME_NULL
+AC_CHECK_FUNCS(waitpid wait4 getcwd strdup strerror chown chmod mknod)
+AC_CHECK_FUNCS(fchmod fstat strchr readlink link utime utimes strftime)
+AC_CHECK_FUNCS(memmove lchown vsnprintf snprintf setsid glob strpbrk)
+AC_CHECK_FUNCS(strlcat strlcpy)
+
+AC_CACHE_CHECK([for working socketpair],rsync_cv_HAVE_SOCKETPAIR,[
+AC_TRY_RUN([#include <sys/types.h>
+	    #include <sys/socket.h>
+	    main() {
+		int fd[2];
+		exit((socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != -1) ? 0 : 1);
+	    }],
+rsync_cv_HAVE_SOCKETPAIR=yes,rsync_cv_HAVE_SOCKETPAIR=no,rsync_cv_HAVE_SOCKETPAIR=cross)])
+if test x"$rsync_cv_HAVE_SOCKETPAIR" = x"yes"; then
+    AC_DEFINE(HAVE_SOCKETPAIR)
+fi
+
+AC_CACHE_CHECK([for working fnmatch],rsync_cv_HAVE_FNMATCH,[
+AC_TRY_RUN([#include <fnmatch.h>
+main() { exit((fnmatch("*.o", "x.o", FNM_PATHNAME) == 0 &&
+               fnmatch("a/b/*", "a/b/c/d", FNM_PATHNAME) != 0) ? 0: 1); }],
+rsync_cv_HAVE_FNMATCH=yes,rsync_cv_HAVE_FNMATCH=no,rsync_cv_HAVE_FNMATCH=cross)])
+if test x"$rsync_cv_HAVE_FNMATCH" = x"yes"; then
+    AC_DEFINE(HAVE_FNMATCH)
+fi
+
+# sometimes getopt_long cannot parse same arguments twice
+# e.g. on certain versions of CygWin32
+AC_CACHE_CHECK([for working getopt_long],rsync_cv_HAVE_GETOPT_LONG,[
+AC_TRY_RUN([#include <getopt.h>
+main() {
+    int i, x = 0; char *argv[] = { "x", "--xx" };
+    struct option o[] = {{"xx", 0, 0, 1}, {0,0,0,0}};
+    getopt_long(2, argv, "x", o, &i) == 1 ? x++ : 0; optind = 0;
+    getopt_long(2, argv, "x", o, &i) == 1 ? x++ : 0;
+    exit(x == 2 ? 0 : 1);
+}], rsync_cv_HAVE_GETOPT_LONG=yes,rsync_cv_HAVE_GETOPT_LONG=no,
+    rsync_cv_HAVE_GETOPT_LONG=cross)])
+if test x"$rsync_cv_HAVE_GETOPT_LONG" = x"yes"; then
+    AC_DEFINE(HAVE_GETOPT_LONG)
+fi
+
+AC_CACHE_CHECK([for long long],rsync_cv_HAVE_LONGLONG,[
+AC_TRY_RUN([#include <stdio.h>
+main() { long long x = 1000000; x *= x; exit(((x/1000000) == 1000000)? 0: 1); }],
+rsync_cv_HAVE_LONGLONG=yes,rsync_cv_HAVE_LONGLONG=no,rsync_cv_HAVE_LONGLONG=cross)])
+if test x"$rsync_cv_HAVE_LONGLONG" = x"yes"; then
+    AC_DEFINE(HAVE_LONGLONG)
+fi
+
+AC_CACHE_CHECK([for off64_t],rsync_cv_HAVE_OFF64_T,[
+AC_TRY_RUN([#include <stdio.h>
+#include <sys/stat.h>
+main() { struct stat64 st; off64_t s; if (sizeof(off_t) == sizeof(off64_t)) exit(1); exit((lstat64("/dev/null", &st)==0)?0:1); }],
+rsync_cv_HAVE_OFF64_T=yes,rsync_cv_HAVE_OFF64_T=no,rsync_cv_HAVE_OFF64_T=cross)])
+if test x"$rsync_cv_HAVE_OFF64_T" = x"yes"; then
+    AC_DEFINE(HAVE_OFF64_T)
+fi
+
+AC_CACHE_CHECK([for short ino_t],rsync_cv_HAVE_SHORT_INO_T,[
+AC_TRY_RUN([#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+main() { if (sizeof(ino_t) < sizeof(unsigned int)) return 0; return 1; }],
+rsync_cv_HAVE_SHORT_INO_T=yes,rsync_cv_HAVE_SHORT_INO_T=no,rsync_cv_HAVE_SHORT_INO_T=cross)])
+if test x"$rsync_cv_HAVE_SHORT_INO_T" = x"yes"; then
+    AC_DEFINE(HAVE_SHORT_INO_T)
+fi
+
+AC_CACHE_CHECK([for unsigned char],rsync_cv_HAVE_UNSIGNED_CHAR,[
+AC_TRY_RUN([#include <stdio.h>
+main() { char c; c=250; exit((c > 0)?0:1); }],
+rsync_cv_HAVE_UNSIGNED_CHAR=yes,rsync_cv_HAVE_UNSIGNED_CHAR=no,rsync_cv_HAVE_UNSIGNED_CHAR=cross)])
+if test x"$rsync_cv_HAVE_UNSIGNED_CHAR" = x"yes"; then
+    AC_DEFINE(HAVE_UNSIGNED_CHAR)
+fi
+
+AC_CACHE_CHECK([for broken readdir],rsync_cv_HAVE_BROKEN_READDIR,[
+AC_TRY_RUN([#include <sys/types.h>
+#include <dirent.h>
+main() { struct dirent *di; DIR *d = opendir("."); di = readdir(d);
+if (di && di->d_name[-2] == '.' && di->d_name[-1] == 0 &&
+di->d_name[0] == 0) exit(0); exit(1);} ],
+rsync_cv_HAVE_BROKEN_READDIR=yes,rsync_cv_HAVE_BROKEN_READDIR=no,rsync_cv_HAVE_BROKEN_READDIR=cross)])
+if test x"$rsync_cv_HAVE_BROKEN_READDIR" = x"yes"; then
+    AC_DEFINE(HAVE_BROKEN_READDIR)
+fi
+
+AC_CACHE_CHECK([for utimbuf],rsync_cv_HAVE_UTIMBUF,[
+AC_TRY_COMPILE([#include <sys/types.h>
+#include <utime.h>],
+[struct utimbuf tbuf;  tbuf.actime = 0; tbuf.modtime = 1; exit(utime("foo.c",&tbuf));],
+rsync_cv_HAVE_UTIMBUF=yes,rsync_cv_HAVE_UTIMBUF=no,rsync_cv_HAVE_UTIMBUF=cross)])
+if test x"$rsync_cv_HAVE_UTIMBUF" = x"yes"; then
+    AC_DEFINE(HAVE_UTIMBUF)
+fi
+
+AC_CACHE_CHECK([if gettimeofday takes tz argument],rsync_cv_HAVE_GETTIMEOFDAY_TZ,[
+AC_TRY_RUN([
+#include <sys/time.h>
+#include <unistd.h>
+main() { struct timeval tv; exit(gettimeofday(&tv, NULL));}],
+           rsync_cv_HAVE_GETTIMEOFDAY_TZ=yes,rsync_cv_HAVE_GETTIMEOFDAY_TZ=no,rsync_cv_HAVE_GETTIMEOFDAY_TZ=cross)])
+if test x"$rsync_cv_HAVE_GETTIMEOFDAY_TZ" = x"yes"; then
+    AC_DEFINE(HAVE_GETTIMEOFDAY_TZ)
+fi
 
 
-AC_OUTPUT(Makefile lib/dummy)
+AC_CACHE_CHECK([for broken inet_ntoa],rsync_cv_REPLACE_INET_NTOA,[
+AC_TRY_RUN([
+#include <stdio.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+main() { struct in_addr ip; ip.s_addr = 0x12345678;
+if (strcmp(inet_ntoa(ip),"18.52.86.120") &&
+    strcmp(inet_ntoa(ip),"120.86.52.18")) { exit(1); } 
+exit(0);}],
+           rsync_cv_REPLACE_INET_NTOA=no,rsync_cv_REPLACE_INET_NTOA=yes,rsync_cv_REPLACE_INET_NTOA=cross)])
+if test x"$rsync_cv_REPLACE_INET_NTOA" = x"yes"; then
+    AC_DEFINE(REPLACE_INET_NTOA)
+fi
+
+
+AC_CACHE_CHECK([for broken inet_aton],rsync_cv_REPLACE_INET_ATON,[
+AC_TRY_RUN([
+#include <stdio.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+main() { struct in_addr ip; 
+if (inet_aton("example", &ip) == 0) exit(0); exit(1);}],
+           rsync_cv_REPLACE_INET_ATON=no,rsync_cv_REPLACE_INET_ATON=yes,rsync_cv_REPLACE_INET_ATON=cross)])
+if test x"$rsync_cv_REPLACE_INET_ATON" = x"yes"; then
+    AC_DEFINE(REPLACE_INET_ATON)
+fi
+
+#
+# The following test was mostly taken from the tcl/tk plus patches
+#
+AC_CACHE_CHECK([whether -c -o works],rsync_cv_DASHC_WORKS_WITH_DASHO,[
+rm -rf conftest*
+cat > conftest.$ac_ext <<EOF
+int main() { return 0; }
+EOF
+${CC-cc} -c -o conftest..o conftest.$ac_ext
+if test -f conftest..o; then
+    rsync_cv_DASHC_WORKS_WITH_DASHO=yes
+else
+    rsync_cv_DASHC_WORKS_WITH_DASHO=no
+fi
+rm -rf conftest*
+])
+if test x"$rsync_cv_DASHC_WORKS_WITH_DASHO" = x"yes"; then
+    OBJ_SAVE="#"
+    OBJ_RESTORE="#"
+    CC_SHOBJ_FLAG='-o $@'
+else
+    OBJ_SAVE='	@b=`basename $@ .o`;rm -f $$b.o.sav;if test -f $$b.o; then mv $$b.o $$b.o.sav;fi;'
+    OBJ_RESTORE='	@b=`basename $@ .o`;if test "$$b.o" != "$@"; then mv $$b.o $@; if test -f $$b.o.sav; then mv $$b.o.sav $$b.o; fi; fi'
+    CC_SHOBJ_FLAG=""
+fi
+
+AC_SUBST(OBJ_SAVE)
+AC_SUBST(OBJ_RESTORE)
+AC_SUBST(CC_SHOBJ_FLAG)
+
+
+AC_OUTPUT(Makefile lib/dummy zlib/dummy)

connection.c

@@ -29,7 +29,7 @@ int claim_connection(char *fname,int max_connections)
 
 	if (max_connections <= 0)
 		return 1;
-	
+
 	fd = open(fname,O_RDWR|O_CREAT, 0600);
 
 	if (fd == -1) {
@@ -41,6 +41,9 @@ int claim_connection(char *fname,int max_connections)
 		if (lock_range(fd, i*4, 4)) return 1;
 	}		
 
+	/* only interested in open failures */
+	errno = 0;
+
 	close(fd);
 	return 0;
 }

errcode.h

@@ -0,0 +1,18 @@
+/* error codes returned by rsync */
+
+#define RERR_SYNTAX     1       /* syntax or usage error */
+#define RERR_PROTOCOL   2       /* protocol incompatibility */
+#define RERR_FILESELECT 3       /* errors selecting input/output files, dirs */
+#define RERR_UNSUPPORTED 4       /* requested action not supported */
+
+#define RERR_SOCKETIO   10      /* error in socket IO */
+#define RERR_FILEIO     11      /* error in file IO */
+#define RERR_STREAMIO   12      /* error in rsync protocol data stream */
+#define RERR_MESSAGEIO  13      /* errors with program diagnostics */
+#define RERR_IPC        14      /* error in IPC code */
+
+#define RERR_SIGNAL     20      /* status returned when sent SIGUSR1, SIGINT */
+#define RERR_WAITCHILD  21      /* some error returned by waitpid() */
+#define RERR_MALLOC     22      /* error allocating core memory buffers */
+
+#define RERR_TIMEOUT    30      /* timeout in data send/receive */

exclude.c

@@ -17,171 +17,322 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-/*
-  a lot of this stuff was derived from GNU tar
-  */
+/* a lot of this stuff was originally derived from GNU tar, although
+   it has now changed so much that it is hard to tell :) */
 
 #include "rsync.h"
 
 extern int verbose;
+extern int delete_mode;
 
-static char **exclude_list;
+static struct exclude_struct **exclude_list;
 
-static int is_regex(char *str)
+/* build an exclude structure given a exclude pattern */
+static struct exclude_struct *make_exclude(char *pattern, int include)
 {
-  return strchr(str, '*') || strchr(str, '[') || strchr(str, '?');
+	struct exclude_struct *ret;
+
+	ret = (struct exclude_struct *)malloc(sizeof(*ret));
+	if (!ret) out_of_memory("make_exclude");
+
+	memset(ret, 0, sizeof(*ret));
+
+	if (strncmp(pattern,"- ",2) == 0) {
+		pattern += 2;
+	} else if (strncmp(pattern,"+ ",2) == 0) {
+		ret->include = 1;
+		pattern += 2;
+	} else {
+		ret->include = include;
+	}
+
+	ret->pattern = strdup(pattern);
+
+	if (!ret->pattern) out_of_memory("make_exclude");
+
+	if (strpbrk(pattern, "*[?")) {
+	    ret->regular_exp = 1;
+	    ret->fnmatch_flags = FNM_PATHNAME;
+	    if (strstr(pattern, "**")) {
+		    static int tested;
+		    if (!tested) {
+			    tested = 1;
+			    if (fnmatch("a/b/*", "a/b/c/d", FNM_PATHNAME)==0) {
+				    rprintf(FERROR,"WARNING: fnmatch FNM_PATHNAME is broken on your system\n");
+			    }
+		    }
+		    ret->fnmatch_flags = 0;
+	    }
+	}
+
+	if (strlen(pattern) > 1 && pattern[strlen(pattern)-1] == '/') {
+		ret->pattern[strlen(pattern)-1] = 0;
+		ret->directory = 1;
+	}
+
+	if (!strchr(ret->pattern,'/')) {
+		ret->local = 1;
+	}
+
+	return ret;
+}
+
+static void free_exclude(struct exclude_struct *ex)
+{
+	free(ex->pattern);
+	memset(ex,0,sizeof(*ex));
+	free(ex);
+}
+
+static int check_one_exclude(char *name,struct exclude_struct *ex,
+			     STRUCT_STAT *st)
+{
+	char *p;
+	int match_start=0;
+	char *pattern = ex->pattern;
+
+	if (ex->local && (p=strrchr(name,'/')))
+		name = p+1;
+
+	if (!name[0]) return 0;
+
+	if (ex->directory && !S_ISDIR(st->st_mode)) return 0;
+
+	if (*pattern == '/' && *name != '/') {
+		match_start = 1;
+		pattern++;
+	}
+
+	if (ex->regular_exp) {
+		if (fnmatch(pattern, name, ex->fnmatch_flags) == 0) {
+			return 1;
+		}
+	} else {
+		int l1 = strlen(name);
+		int l2 = strlen(pattern);
+		if (l2 <= l1 && 
+		    strcmp(name+(l1-l2),pattern) == 0 &&
+		    (l1==l2 || (!match_start && name[l1-(l2+1)] == '/'))) {
+			return 1;
+		}
+	}
+
+	return 0;
 }
 
 
-static int check_one_exclude(char *name,char *pattern)
+int check_exclude(char *name,struct exclude_struct **local_exclude_list,
+		  STRUCT_STAT *st)
 {
-  char *p;
+	int n;
 
-  if (!strchr(pattern,'/') && (p=strrchr(name,'/')))
-    name = p+1;
+	if (name && (name[0] == '.') && !name[1])
+		/* never exclude '.', even if somebody does --exclude '*' */
+		return 0;
 
-  if (!name[0]) return 0;
+	if (exclude_list) {
+		for (n=0; exclude_list[n]; n++)
+			if (check_one_exclude(name,exclude_list[n],st))
+				return !exclude_list[n]->include;
+	}
 
-  if (*pattern == '/' && *name != '/') pattern++;
+	if (local_exclude_list) {
+		for (n=0; local_exclude_list[n]; n++)
+			if (check_one_exclude(name,local_exclude_list[n],st))
+				return !local_exclude_list[n]->include;
+	}
 
-  if (is_regex(pattern)) {
-    if (fnmatch(pattern, name, 0) == 0)
-      return 1;
-  } else {
-    int l1 = strlen(name);
-    int l2 = strlen(pattern);
-    if (l2 <= l1 && 
-	strcmp(name+(l1-l2),pattern) == 0 &&
-	(l1==l2 || name[l1-(l2+1)] == '/'))
-      return 1;
-  }
-
-  return 0;
+	return 0;
 }
 
 
-int check_exclude(char *name,char **local_exclude_list)
+void add_exclude_list(char *pattern,struct exclude_struct ***list, int include)
 {
-  int n;
+	int len=0;
+	if (list && *list)
+		for (; (*list)[len]; len++) ;
 
-  if (exclude_list) {
-    for (n=0; exclude_list[n]; n++)
-      if (check_one_exclude(name,exclude_list[n]))
-	return 1;
-  }
+	if (strcmp(pattern,"!") == 0) {
+		if (verbose > 2)
+			rprintf(FINFO,"clearing exclude list\n");
+		while ((len)--) {
+			free_exclude((*list)[len]);
+		}
+		free((*list));
+		*list = NULL;
+		return;
+	}
 
-  if (local_exclude_list) {
-    for (n=0; local_exclude_list[n]; n++)
-      if (check_one_exclude(name,local_exclude_list[n]))
-	return 1;      
-  }
+	*list = (struct exclude_struct **)Realloc(*list,sizeof(struct exclude_struct *)*(len+2));
+	
+	if (!*list || !((*list)[len] = make_exclude(pattern, include)))
+		out_of_memory("add_exclude");
+	
+	if (verbose > 2)
+		rprintf(FINFO,"add_exclude(%s)\n",pattern);
+	
+	(*list)[len+1] = NULL;
+}
 
-  return 0;
+void add_exclude(char *pattern, int include)
+{
+	add_exclude_list(pattern,&exclude_list, include);
+}
+
+struct exclude_struct **make_exclude_list(char *fname,
+					  struct exclude_struct **list1,
+					  int fatal, int include)
+{
+	struct exclude_struct **list=list1;
+	FILE *f = fopen(fname,"r");
+	char line[MAXPATHLEN];
+	if (!f) {
+		if (fatal) {
+			rprintf(FERROR,"%s : %s\n",fname,strerror(errno));
+			exit_cleanup(RERR_FILEIO);
+		}
+		return list;
+	}
+
+	while (fgets(line,MAXPATHLEN,f)) {
+		int l = strlen(line);
+		if (l && line[l-1] == '\n') l--;
+		line[l] = 0;
+		if (line[0] && (line[0] != ';') && (line[0] != '#')) {
+			/* Skip lines starting with semicolon or pound.
+			   It probably wouldn't cause any harm to not skip
+			     them but there's no need to save them. */
+			add_exclude_list(line,&list,include);
+		}
+	}
+	fclose(f);
+	return list;
 }
 
 
-void add_exclude_list(char *pattern,char ***list)
-{
-  int len=0;
-  if (list && *list)
-    for (; (*list)[len]; len++) ;
-
-  if (strcmp(pattern,"!") == 0) {
-    if (verbose > 2)
-      rprintf(FINFO,"clearing exclude list\n");
-    while ((len)--) 
-      free((*list)[len]);
-    free((*list));
-    *list = NULL;
-    return;
-  }
-
-  if (!*list) {
-    *list = (char **)malloc(sizeof(char *)*2);
-  } else {
-    *list = (char **)realloc(*list,sizeof(char *)*(len+2));
-  }
-
-  if (!*list || !((*list)[len] = strdup(pattern)))
-    out_of_memory("add_exclude");
-
-  if (verbose > 2)
-    rprintf(FINFO,"add_exclude(%s)\n",pattern);
-  
-  (*list)[len+1] = NULL;
-}
-
-void add_exclude(char *pattern)
-{
-  add_exclude_list(pattern,&exclude_list);
-}
-
-char **make_exclude_list(char *fname,char **list1,int fatal)
-{
-  char **list=list1;
-  FILE *f = fopen(fname,"r");
-  char line[MAXPATHLEN];
-  if (!f) {
-    if (fatal) {
-      rprintf(FERROR,"%s : %s\n",fname,strerror(errno));
-      exit_cleanup(1);
-    }
-    return list;
-  }
-
-  while (fgets(line,MAXPATHLEN,f)) {
-    int l = strlen(line);
-    if (l && line[l-1] == '\n') l--;
-    line[l] = 0;
-    if (line[0]) add_exclude_list(line,&list);
-  }
-  fclose(f);
-  return list;
-}
-
-
-void add_exclude_file(char *fname,int fatal)
+void add_exclude_file(char *fname,int fatal,int include)
 {
 	if (!fname || !*fname) return;
 
-	exclude_list = make_exclude_list(fname,exclude_list,fatal);
+	exclude_list = make_exclude_list(fname,exclude_list,fatal,include);
 }
 
 
 void send_exclude_list(int f)
 {
-  int i;
-  if (exclude_list) 
-    for (i=0;exclude_list[i];i++) {
-      int l = strlen(exclude_list[i]);
-      if (l == 0) continue;
-      write_int(f,l);
-      write_buf(f,exclude_list[i],l);
-    }    
-  write_int(f,0);
+	int i;
+	extern int remote_version;
+
+	if (!exclude_list) {
+		write_int(f,0);
+		return;
+	}
+
+	for (i=0;exclude_list[i];i++) {
+		int l;
+		char pattern[MAXPATHLEN];
+
+		strlcpy(pattern,exclude_list[i]->pattern,sizeof(pattern)); 
+		if (exclude_list[i]->directory) strlcat(pattern,"/", sizeof(pattern));
+
+		l = strlen(pattern);
+		if (l == 0) continue;
+		if (exclude_list[i]->include) {
+			if (remote_version < 19) {
+				rprintf(FERROR,"remote rsync does not support include syntax - aborting\n");
+				exit_cleanup(RERR_UNSUPPORTED);
+			}
+			write_int(f,l+2);
+			write_buf(f,"+ ",2);
+		} else {
+			write_int(f,l);
+		}
+		write_buf(f,pattern,l);
+	}    
+
+	write_int(f,0);
 }
 
 
 void recv_exclude_list(int f)
 {
-  char line[MAXPATHLEN];
-  int l;
-  while ((l=read_int(f))) {
-	  if (l >= MAXPATHLEN) overflow("recv_exclude_list");
-	  read_sbuf(f,line,l);
-	  add_exclude(line);
-  }
+	char line[MAXPATHLEN];
+	int l;
+	while ((l=read_int(f))) {
+		if (l >= MAXPATHLEN) overflow("recv_exclude_list");
+		read_sbuf(f,line,l);
+		add_exclude(line,0);
+	}
 }
 
+/* Get the next include/exclude arg from the string. It works in a similar way
+** to strtok - initially an arg is sent over, from then on NULL. This
+** routine takes into account any +/- in the strings and does not
+** consider the space following it as a delimeter.
+*/
+char *get_exclude_tok(char *p)
+{
+	static char *s;
+	static int more;
+	char *t;
 
+	if (p) {
+		s=p;
+		if (*p)
+			more=1;
+	}
+
+	if (!more)
+		return(NULL);
+
+	/* Skip over any initial spaces */
+	while(isspace(*s))
+		s++;
+
+	/* Are we at the end of the string? */
+	if (*s) {
+		/* remember the beginning of the token */
+		t=s;
+
+		/* Is this a '+' or '-' followed by a space (not whitespace)? */
+		if ((*s=='+' || *s=='-') && *(s+1)==' ')
+			s+=2;
+	
+		/* Skip to the next space or the end of the string */
+		while(!isspace(*s) && *s!='\0')
+			s++;
+	} else {
+		t=NULL;
+	}
+
+	/* Have we reached the end of the string? */
+	if (*s)
+		*s++='\0';
+	else
+		more=0;
+	return(t);
+}
+
+	
 void add_exclude_line(char *p)
 {
 	char *tok;
 	if (!p || !*p) return;
 	p = strdup(p);
 	if (!p) out_of_memory("add_exclude_line");
-	for (tok=strtok(p," "); tok; tok=strtok(NULL," "))
-		add_exclude(tok);
+ 	for (tok=get_exclude_tok(p); tok; tok=get_exclude_tok(NULL))
+		add_exclude(tok, 0);
+	free(p);
+}
+
+void add_include_line(char *p)
+{
+	char *tok;
+	if (!p || !*p) return;
+	p = strdup(p);
+	if (!p) out_of_memory("add_include_line");
+	for (tok=get_exclude_tok(p); tok; tok=get_exclude_tok(NULL))
+		add_exclude(tok, 1);
 	free(p);
 }
 
@@ -197,17 +348,17 @@ static char *cvs_ignore_list[] = {
 
 void add_cvs_excludes(void)
 {
-  char fname[MAXPATHLEN];
-  char *p;
-  int i;
+	char fname[MAXPATHLEN];
+	char *p;
+	int i;
   
-  for (i=0; cvs_ignore_list[i]; i++)
-    add_exclude(cvs_ignore_list[i]);
+	for (i=0; cvs_ignore_list[i]; i++)
+		add_exclude(cvs_ignore_list[i], 0);
 
-  if ((p=getenv("HOME")) && strlen(p) < (MAXPATHLEN-12)) {
-	  slprintf(fname,sizeof(fname)-1, "%s/.cvsignore",p);
-	  add_exclude_file(fname,0);
-  }
+	if ((p=getenv("HOME")) && strlen(p) < (MAXPATHLEN-12)) {
+		slprintf(fname,sizeof(fname), "%s/.cvsignore",p);
+		add_exclude_file(fname,0,0);
+	}
 
-  add_exclude_line(getenv("CVSIGNORE"));
+	add_exclude_line(getenv("CVSIGNORE"));
 }

fileio.c

@@ -0,0 +1,213 @@
+/* 
+   Copyright (C) Andrew Tridgell 1998
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+  File IO utilities used in rsync 
+  */
+#include "rsync.h"
+
+static char last_byte;
+static int last_sparse;
+extern int sparse_files;
+
+int sparse_end(int f)
+{
+	if (last_sparse) {
+		do_lseek(f,-1,SEEK_CUR);
+		return (write(f,&last_byte,1) == 1 ? 0 : -1);
+	}
+	last_sparse = 0;
+	return 0;
+}
+
+
+static int write_sparse(int f,char *buf,int len)
+{
+	int l1=0,l2=0;
+	int ret;
+
+	for (l1=0;l1<len && buf[l1]==0;l1++) ;
+	for (l2=0;l2<(len-l1) && buf[len-(l2+1)]==0;l2++) ;
+
+	last_byte = buf[len-1];
+
+	if (l1 == len || l2 > 0)
+		last_sparse=1;
+
+	if (l1 > 0) {
+		do_lseek(f,l1,SEEK_CUR);  
+	}
+
+	if (l1 == len) 
+		return len;
+
+	if ((ret=write(f,buf+l1,len-(l1+l2))) != len-(l1+l2)) {
+		if (ret == -1 || ret == 0) return ret;
+		return (l1+ret);
+	}
+
+	if (l2 > 0)
+		do_lseek(f,l2,SEEK_CUR);
+	
+	return len;
+}
+
+
+
+int write_file(int f,char *buf,int len)
+{
+	int ret = 0;
+
+	if (!sparse_files) {
+		return write(f,buf,len);
+	}
+
+	while (len>0) {
+		int len1 = MIN(len, SPARSE_WRITE_SIZE);
+		int r1 = write_sparse(f, buf, len1);
+		if (r1 <= 0) {
+			if (ret > 0) return ret;
+			return r1;
+		}
+		len -= r1;
+		buf += r1;
+		ret += r1;
+	}
+	return ret;
+}
+
+
+
+/* this provides functionality somewhat similar to mmap() but using
+   read(). It gives sliding window access to a file. mmap() is not
+   used because of the possibility of another program (such as a
+   mailer) truncating the file thus giving us a SIGBUS */
+struct map_struct *map_file(int fd,OFF_T len)
+{
+	struct map_struct *map;
+	map = (struct map_struct *)malloc(sizeof(*map));
+	if (!map) out_of_memory("map_file");
+
+	map->fd = fd;
+	map->file_size = len;
+	map->p = NULL;
+	map->p_size = 0;
+	map->p_offset = 0;
+	map->p_fd_offset = 0;
+	map->p_len = 0;
+
+	return map;
+}
+
+/* slide the read window in the file */
+char *map_ptr(struct map_struct *map,OFF_T offset,int len)
+{
+	int nread;
+	OFF_T window_start, read_start;
+	int window_size, read_size, read_offset;
+
+	if (len == 0) {
+		return NULL;
+	}
+
+	/* can't go beyond the end of file */
+	if (len > (map->file_size - offset)) {
+		len = map->file_size - offset;
+	}
+
+	/* in most cases the region will already be available */
+	if (offset >= map->p_offset && 
+	    offset+len <= map->p_offset+map->p_len) {
+		return (map->p + (offset - map->p_offset));
+	}
+
+
+	/* nope, we are going to have to do a read. Work out our desired window */
+	if (offset > 2*CHUNK_SIZE) {
+		window_start = offset - 2*CHUNK_SIZE;
+		window_start &= ~((OFF_T)(CHUNK_SIZE-1)); /* assumes power of 2 */
+	} else {
+		window_start = 0;
+	}
+	window_size = MAX_MAP_SIZE;
+	if (window_start + window_size > map->file_size) {
+		window_size = map->file_size - window_start;
+	}
+	if (offset + len > window_start + window_size) {
+		window_size = (offset+len) - window_start;
+	}
+
+	/* make sure we have allocated enough memory for the window */
+	if (window_size > map->p_size) {
+		map->p = (char *)Realloc(map->p, window_size);
+		if (!map->p) out_of_memory("map_ptr");
+		map->p_size = window_size;
+	}
+
+	/* now try to avoid re-reading any bytes by reusing any bytes from the previous
+	   buffer. */
+	if (window_start >= map->p_offset &&
+	    window_start < map->p_offset + map->p_len &&
+	    window_start + window_size >= map->p_offset + map->p_len) {
+		read_start = map->p_offset + map->p_len;
+		read_offset = read_start - window_start;
+		read_size = window_size - read_offset;
+		memmove(map->p, map->p + (map->p_len - read_offset), read_offset);
+	} else {
+		read_start = window_start;
+		read_size = window_size;
+		read_offset = 0;
+	}
+
+	if (read_size <= 0) {
+		rprintf(FINFO,"Warning: unexpected read size of %d in map_ptr\n", read_size);
+	} else {
+		if (map->p_fd_offset != read_start) {
+			if (do_lseek(map->fd,read_start,SEEK_SET) != read_start) {
+				rprintf(FERROR,"lseek failed in map_ptr\n");
+				exit_cleanup(RERR_FILEIO);
+			}
+			map->p_fd_offset = read_start;
+		}
+
+		if ((nread=read(map->fd,map->p + read_offset,read_size)) != read_size) {
+			if (nread < 0) nread = 0;
+			/* the best we can do is zero the buffer - the file
+			   has changed mid transfer! */
+			memset(map->p+read_offset+nread, 0, read_size - nread);
+		}
+		map->p_fd_offset += nread;
+	}
+
+	map->p_offset = window_start;
+	map->p_len = window_size;
+  
+	return map->p + (offset - map->p_offset); 
+}
+
+
+void unmap_file(struct map_struct *map)
+{
+	if (map->p) {
+		free(map->p);
+		map->p = NULL;
+	}
+	memset(map, 0, sizeof(*map));
+	free(map);
+}
+

generator.c

@@ -0,0 +1,461 @@
+/* 
+   Copyright (C) Andrew Tridgell 1996
+   Copyright (C) Paul Mackerras 1996
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "rsync.h"
+
+extern int verbose;
+extern int dry_run;
+extern int relative_paths;
+extern int preserve_links;
+extern int am_root;
+extern int preserve_devices;
+extern int preserve_hard_links;
+extern int update_only;
+extern int whole_file;
+extern int block_size;
+extern int csum_length;
+extern int ignore_times;
+extern int size_only;
+extern int io_timeout;
+extern int remote_version;
+extern int always_checksum;
+extern char *compare_dest;
+
+
+/* choose whether to skip a particular file */
+static int skip_file(char *fname,
+		     struct file_struct *file, STRUCT_STAT *st)
+{
+	if (st->st_size != file->length) {
+		return 0;
+	}
+	
+	/* if always checksum is set then we use the checksum instead 
+	   of the file time to determine whether to sync */
+	if (always_checksum && S_ISREG(st->st_mode)) {
+		char sum[MD4_SUM_LENGTH];
+		char fnamecmpdest[MAXPATHLEN];
+
+		if (compare_dest != NULL) {
+			if (access(fname, 0) != 0) {
+				slprintf(fnamecmpdest,MAXPATHLEN,"%s/%s",
+						    compare_dest,fname);
+				fname = fnamecmpdest;
+			}
+		}
+		file_checksum(fname,sum,st->st_size);
+		if (remote_version < 21) {
+			return (memcmp(sum,file->sum,2) == 0);
+		} else {
+			return (memcmp(sum,file->sum,MD4_SUM_LENGTH) == 0);
+		}
+	}
+
+	if (size_only) {
+		return 1;
+	}
+
+	if (ignore_times) {
+		return 0;
+	}
+
+	return (st->st_mtime == file->modtime);
+}
+
+
+/* use a larger block size for really big files */
+static int adapt_block_size(struct file_struct *file, int bsize)
+{
+	int ret;
+
+	if (bsize != BLOCK_SIZE) return bsize;
+
+	ret = file->length / (10000); /* rough heuristic */
+	ret = ret & ~15; /* multiple of 16 */
+	if (ret < bsize) ret = bsize;
+	if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
+	return ret;
+}
+
+
+/*
+  send a sums struct down a fd
+  */
+static void send_sums(struct sum_struct *s,int f_out)
+{
+	int i;
+	
+	/* tell the other guy how many we are going to be doing and how many
+	   bytes there are in the last chunk */
+	write_int(f_out,s?s->count:0);
+	write_int(f_out,s?s->n:block_size);
+	write_int(f_out,s?s->remainder:0);
+
+	if (!s) return;
+
+	for (i=0;i<s->count;i++) {
+		write_int(f_out,s->sums[i].sum1);
+		write_buf(f_out,s->sums[i].sum2,csum_length);
+	}
+}
+
+
+/*
+  generate a stream of signatures/checksums that describe a buffer
+
+  generate approximately one checksum every n bytes
+  */
+static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
+{
+	int i;
+	struct sum_struct *s;
+	int count;
+	int block_len = n;
+	int remainder = (len%block_len);
+	OFF_T offset = 0;
+
+	count = (len+(block_len-1))/block_len;
+
+	s = (struct sum_struct *)malloc(sizeof(*s));
+	if (!s) out_of_memory("generate_sums");
+
+	s->count = count;
+	s->remainder = remainder;
+	s->n = n;
+	s->flength = len;
+
+	if (count==0) {
+		s->sums = NULL;
+		return s;
+	}
+
+	if (verbose > 3)
+		rprintf(FINFO,"count=%d rem=%d n=%d flength=%.0f\n",
+			s->count,s->remainder,s->n,(double)s->flength);
+
+	s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
+	if (!s->sums) out_of_memory("generate_sums");
+  
+	for (i=0;i<count;i++) {
+		int n1 = MIN(len,n);
+		char *map = map_ptr(buf,offset,n1);
+
+		s->sums[i].sum1 = get_checksum1(map,n1);
+		get_checksum2(map,n1,s->sums[i].sum2);
+
+		s->sums[i].offset = offset;
+		s->sums[i].len = n1;
+		s->sums[i].i = i;
+
+		if (verbose > 3)
+			rprintf(FINFO,"chunk[%d] offset=%.0f len=%d sum1=%08x\n",
+				i,(double)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
+
+		len -= n1;
+		offset += n1;
+	}
+
+	return s;
+}
+
+
+void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
+{  
+	int fd;
+	STRUCT_STAT st;
+	struct map_struct *buf;
+	struct sum_struct *s;
+	int statret;
+	struct file_struct *file = flist->files[i];
+	char *fnamecmp;
+	char fnamecmpbuf[MAXPATHLEN];
+	extern char *compare_dest;
+	extern int list_only;
+	extern int preserve_perms;
+	extern int only_existing;
+
+	if (list_only) return;
+
+	if (verbose > 2)
+		rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
+
+	statret = link_stat(fname,&st);
+
+	if (only_existing && statret == -1 && errno == ENOENT) {
+		/* we only want to update existing files */
+		if (verbose > 1) rprintf(FINFO,"not creating %s\n",fname);
+		return;
+	}
+
+	if (statret == 0 && 
+	    !preserve_perms && 
+	    (S_ISDIR(st.st_mode) == S_ISDIR(file->mode))) {
+		/* if the file exists already and we aren't perserving
+                   presmissions then act as though the remote end sent
+                   us the file permissions we already have */
+		file->mode = (file->mode & _S_IFMT) | (st.st_mode & ~_S_IFMT);
+	}
+
+	if (S_ISDIR(file->mode)) {
+		if (dry_run) return;
+		if (statret == 0 && !S_ISDIR(st.st_mode)) {
+			if (robust_unlink(fname) != 0) {
+				rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
+				return;
+			}
+			statret = -1;
+		}
+		if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
+			if (!(relative_paths && errno==ENOENT && 
+			      create_directory_path(fname)==0 && 
+			      do_mkdir(fname,file->mode)==0)) {
+				rprintf(FERROR,"mkdir %s : %s (2)\n",
+					fname,strerror(errno));
+			}
+		}
+		if (set_perms(fname,file,NULL,0) && verbose) 
+			rprintf(FINFO,"%s/\n",fname);
+		return;
+	}
+
+	if (preserve_links && S_ISLNK(file->mode)) {
+#if SUPPORT_LINKS
+		char lnk[MAXPATHLEN];
+		int l;
+		extern int safe_symlinks;
+
+		if (safe_symlinks && unsafe_symlink(file->link, fname)) {
+			if (verbose) {
+				rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n",
+					fname,file->link);
+			}
+			return;
+		}
+		if (statret == 0) {
+			l = readlink(fname,lnk,MAXPATHLEN-1);
+			if (l > 0) {
+				lnk[l] = 0;
+				if (strcmp(lnk,file->link) == 0) {
+					set_perms(fname,file,&st,1);
+					return;
+				}
+			}
+			delete_file(fname);
+		}
+		if (do_symlink(file->link,fname) != 0) {
+			rprintf(FERROR,"symlink %s -> %s : %s\n",
+				fname,file->link,strerror(errno));
+		} else {
+			set_perms(fname,file,NULL,0);
+			if (verbose) {
+				rprintf(FINFO,"%s -> %s\n",
+					fname,file->link);
+			}
+		}
+#endif
+		return;
+	}
+
+#ifdef HAVE_MKNOD
+	if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
+		if (statret != 0 || 
+		    st.st_mode != file->mode ||
+		    st.st_rdev != file->rdev) {	
+			delete_file(fname);
+			if (verbose > 2)
+				rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
+					fname,(int)file->mode,(int)file->rdev);
+			if (do_mknod(fname,file->mode,file->rdev) != 0) {
+				rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
+			} else {
+				set_perms(fname,file,NULL,0);
+				if (verbose)
+					rprintf(FINFO,"%s\n",fname);
+			}
+		} else {
+			set_perms(fname,file,&st,1);
+		}
+		return;
+	}
+#endif
+
+	if (preserve_hard_links && check_hard_link(file)) {
+		if (verbose > 1)
+			rprintf(FINFO,"%s is a hard link\n",f_name(file));
+		return;
+	}
+
+	if (!S_ISREG(file->mode)) {
+		rprintf(FINFO,"skipping non-regular file %s\n",fname);
+		return;
+	}
+
+	fnamecmp = fname;
+
+	if ((statret == -1) && (compare_dest != NULL)) {
+		/* try the file at compare_dest instead */
+		int saveerrno = errno;
+		slprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname);
+		statret = link_stat(fnamecmpbuf,&st);
+		if (!S_ISREG(st.st_mode))
+			statret = -1;
+		if (statret == -1)
+			errno = saveerrno;
+		else
+			fnamecmp = fnamecmpbuf;
+	}
+
+	if (statret == -1) {
+		if (errno == ENOENT) {
+			write_int(f_out,i);
+			if (!dry_run) send_sums(NULL,f_out);
+		} else {
+			if (verbose > 1)
+				rprintf(FERROR,"recv_generator failed to open %s\n",fname);
+		}
+		return;
+	}
+
+	if (!S_ISREG(st.st_mode)) {
+		if (delete_file(fname) != 0) {
+			return;
+		}
+
+		/* now pretend the file didn't exist */
+		write_int(f_out,i);
+		if (!dry_run) send_sums(NULL,f_out);    
+		return;
+	}
+
+	if (update_only && st.st_mtime > file->modtime && fnamecmp == fname) {
+		if (verbose > 1)
+			rprintf(FINFO,"%s is newer\n",fname);
+		return;
+	}
+
+	if (skip_file(fname, file, &st)) {
+		if (fnamecmp == fname)
+			set_perms(fname,file,&st,1);
+		return;
+	}
+
+	if (dry_run) {
+		write_int(f_out,i);
+		return;
+	}
+
+	if (whole_file) {
+		write_int(f_out,i);
+		send_sums(NULL,f_out);    
+		return;
+	}
+
+	/* open the file */  
+	fd = do_open(fnamecmp, O_RDONLY, 0);
+
+	if (fd == -1) {
+		rprintf(FERROR,"failed to open %s, continuing : %s\n",fnamecmp,strerror(errno));
+		/* pretend the file didn't exist */
+		write_int(f_out,i);
+		send_sums(NULL,f_out);
+		return;
+	}
+
+	if (st.st_size > 0) {
+		buf = map_file(fd,st.st_size);
+	} else {
+		buf = NULL;
+	}
+
+	if (verbose > 3)
+		rprintf(FINFO,"gen mapped %s of size %.0f\n",fnamecmp,(double)st.st_size);
+
+	s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
+
+	if (verbose > 2)
+		rprintf(FINFO,"sending sums for %d\n",i);
+
+	write_int(f_out,i);
+	send_sums(s,f_out);
+
+	close(fd);
+	if (buf) unmap_file(buf);
+
+	free_sums(s);
+}
+
+
+
+void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
+{
+	int i;
+	int phase=0;
+
+	if (verbose > 2)
+		rprintf(FINFO,"generator starting pid=%d count=%d\n",
+			(int)getpid(),flist->count);
+
+	for (i = 0; i < flist->count; i++) {
+		struct file_struct *file = flist->files[i];
+		mode_t saved_mode = file->mode;
+		if (!file->basename) continue;
+
+		/* we need to ensure that any directories we create have writeable
+		   permissions initially so that we can create the files within
+		   them. This is then fixed after the files are transferred */
+		if (!am_root && S_ISDIR(file->mode)) {
+			file->mode |= S_IWUSR; /* user write */
+		}
+
+		recv_generator(local_name?local_name:f_name(file),
+			       flist,i,f);
+
+		file->mode = saved_mode;
+	}
+
+	phase++;
+	csum_length = SUM_LENGTH;
+	ignore_times=1;
+
+	if (verbose > 2)
+		rprintf(FINFO,"generate_files phase=%d\n",phase);
+
+	write_int(f,-1);
+
+	/* we expect to just sit around now, so don't exit on a
+	   timeout. If we really get a timeout then the other process should
+	   exit */
+	io_timeout = 0;
+
+	if (remote_version >= 13) {
+		/* in newer versions of the protocol the files can cycle through
+		   the system more than once to catch initial checksum errors */
+		for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
+			struct file_struct *file = flist->files[i];
+			recv_generator(local_name?local_name:f_name(file),
+				       flist,i,f);    
+		}
+
+		phase++;
+		if (verbose > 2)
+			rprintf(FINFO,"generate_files phase=%d\n",phase);
+
+		write_int(f,-1);
+	}
+}

hlink.c

@@ -56,7 +56,7 @@ void init_hard_links(struct file_list *flist)
 		out_of_memory("init_hard_links");
 
 	for (i = 0; i < flist->count; i++)
-		bcopy(flist->files[i], &hlink_list[i], sizeof(hlink_list[0]));
+		memcpy(&hlink_list[i], flist->files[i], sizeof(hlink_list[0]));
 
 	qsort(hlink_list,flist->count,
 	      sizeof(hlink_list[0]),
@@ -120,7 +120,7 @@ static void hard_link_one(int i)
 	} else {
 		if (st2.st_dev == st1.st_dev && st2.st_ino == st1.st_ino) return;
 		
-		if (do_unlink(f_name(&hlink_list[i])) != 0 ||
+		if (robust_unlink(f_name(&hlink_list[i])) != 0 ||
 		    do_link(f_name(&hlink_list[i-1]),f_name(&hlink_list[i])) != 0) {
 			if (verbose > 0)
 				rprintf(FINFO,"link %s => %s : %s\n",

io.c

@@ -18,89 +18,40 @@
 */
 
 /*
-  Utilities used in rsync 
+  socket and pipe IO utilities used in rsync 
 
   tridge, June 1996
   */
 #include "rsync.h"
 
-static int64 total_written;
-static int64 total_read;
+/* if no timeout is specified then use a 60 second select timeout */
+#define SELECT_TIMEOUT 60
 
+extern int bwlimit;
+
+static int io_multiplexing_out;
+static int io_multiplexing_in;
+static int multiplex_in_fd;
+static int multiplex_out_fd;
+static time_t last_io;
+static int eof_error=1;
 extern int verbose;
-extern int sparse_files;
 extern int io_timeout;
-
-int64 write_total(void)
-{
-  return total_written;
-}
-
-int64 read_total(void)
-{
-  return total_read;
-}
+extern struct stats stats;
 
 static int buffer_f_in = -1;
+static int io_error_fd = -1;
 
-void setup_nonblocking(int f_in,int f_out)
+static void read_loop(int fd, char *buf, int len);
+
+void setup_readbuffer(int f_in)
 {
-  set_blocking(f_out,0);
-  buffer_f_in = f_in;
+	buffer_f_in = f_in;
 }
 
-
-static char *read_buffer;
-static char *read_buffer_p;
-static int read_buffer_len;
-static int read_buffer_size;
-
-
-/* This function was added to overcome a deadlock problem when using
- * ssh.  It looks like we can't allow our receive queue to get full or
- * ssh will clag up. Uggh.  */
-static void read_check(int f)
-{
-  int n;
-
-  if (f == -1) return;
-
-  if (read_buffer_len == 0) {
-    read_buffer_p = read_buffer;
-  }
-
-  if ((n=num_waiting(f)) <= 0)
-    return;
-
-  /* things could deteriorate if we read in really small chunks */
-  if (n < 10) n = 1024;
-
-  if (read_buffer_p != read_buffer) {
-    memmove(read_buffer,read_buffer_p,read_buffer_len);
-    read_buffer_p = read_buffer;
-  }
-
-  if (n > (read_buffer_size - read_buffer_len)) {
-    read_buffer_size += n;
-    if (!read_buffer)
-      read_buffer = (char *)malloc(read_buffer_size);
-    else
-      read_buffer = (char *)realloc(read_buffer,read_buffer_size);
-    if (!read_buffer) out_of_memory("read check");      
-    read_buffer_p = read_buffer;      
-  }
-
-  n = read(f,read_buffer+read_buffer_len,n);
-  if (n > 0) {
-    read_buffer_len += n;
-  }
-}
-
-static time_t last_io;
-
-
 static void check_timeout(void)
 {
+	extern int am_server, am_daemon;
 	time_t t;
 	
 	if (!io_timeout) return;
@@ -112,71 +63,222 @@ static void check_timeout(void)
 
 	t = time(NULL);
 
-	if (last_io && io_timeout && (t-last_io)>io_timeout) {
-		rprintf(FERROR,"read timeout after %d second - exiting\n", 
-			(int)(t-last_io));
-		exit_cleanup(1);
+	if (last_io && io_timeout && (t-last_io) >= io_timeout) {
+		if (!am_server && !am_daemon) {
+			rprintf(FERROR,"io timeout after %d second - exiting\n", 
+				(int)(t-last_io));
+		}
+		exit_cleanup(RERR_TIMEOUT);
 	}
 }
 
-static int readfd(int fd,char *buffer,int N)
+/* setup the fd used to propogate errors */
+void io_set_error_fd(int fd)
+{
+	io_error_fd = fd;
+}
+
+/* read some data from the error fd and write it to the write log code */
+static void read_error_fd(void)
+{
+	char buf[200];
+	int n;
+	int fd = io_error_fd;
+	int tag, len;
+
+	io_error_fd = -1;
+
+	read_loop(fd, buf, 4);
+	tag = IVAL(buf, 0);
+
+	len = tag & 0xFFFFFF;
+	tag = tag >> 24;
+	tag -= MPLEX_BASE;
+
+	while (len) {
+		n = len;
+		if (n > (sizeof(buf)-1)) n = sizeof(buf)-1;
+		read_loop(fd, buf, n);
+		rwrite((enum logcode)tag, buf, n);
+		len -= n;
+	}
+
+	io_error_fd = fd;
+}
+
+
+static int no_flush;
+
+/* read from a socket with IO timeout. return the number of
+   bytes read. If no bytes can be read then exit, never return
+   a number <= 0 */
+static int read_timeout(int fd, char *buf, int len)
+{
+	int n, ret=0;
+
+	io_flush();
+
+	while (ret == 0) {
+		fd_set fds;
+		struct timeval tv;
+		int fd_count = fd+1;
+
+		FD_ZERO(&fds);
+		FD_SET(fd, &fds);
+		if (io_error_fd != -1) {
+			FD_SET(io_error_fd, &fds);
+			if (io_error_fd > fd) fd_count = io_error_fd+1;
+		}
+
+		tv.tv_sec = io_timeout?io_timeout:SELECT_TIMEOUT;
+		tv.tv_usec = 0;
+
+		errno = 0;
+
+		if (select(fd_count, &fds, NULL, NULL, &tv) < 1) {
+			if (errno == EBADF) {
+				exit_cleanup(RERR_SOCKETIO);
+			}
+			check_timeout();
+			continue;
+		}
+
+		if (io_error_fd != -1 && FD_ISSET(io_error_fd, &fds)) {
+			read_error_fd();
+		}
+
+		if (!FD_ISSET(fd, &fds)) continue;
+
+		n = read(fd, buf, len);
+
+		if (n > 0) {
+			buf += n;
+			len -= n;
+			ret += n;
+			if (io_timeout)
+				last_io = time(NULL);
+			continue;
+		}
+
+		if (n == -1 && errno == EINTR) {
+			continue;
+		}
+
+		if (n == -1 && 
+		    (errno == EWOULDBLOCK || errno == EAGAIN)) {
+			continue;
+		}
+
+
+		if (n == 0) {
+			if (eof_error) {
+				rprintf(FERROR,"unexpected EOF in read_timeout\n");
+			}
+			exit_cleanup(RERR_STREAMIO);
+		}
+
+		/* this prevents us trying to write errors on a dead socket */
+		io_multiplexing_close();
+
+		rprintf(FERROR,"read error: %s\n", strerror(errno));
+		exit_cleanup(RERR_STREAMIO);
+	}
+
+	return ret;
+}
+
+/* continue trying to read len bytes - don't return until len
+   has been read */
+static void read_loop(int fd, char *buf, int len)
+{
+	while (len) {
+		int n = read_timeout(fd, buf, len);
+
+		buf += n;
+		len -= n;
+	}
+}
+
+/* read from the file descriptor handling multiplexing - 
+   return number of bytes read
+   never return <= 0 */
+static int read_unbuffered(int fd, char *buf, int len)
+{
+	static int remaining;
+	int tag, ret=0;
+	char line[1024];
+
+	if (!io_multiplexing_in || fd != multiplex_in_fd) 
+		return read_timeout(fd, buf, len);
+
+	while (ret == 0) {
+		if (remaining) {
+			len = MIN(len, remaining);
+			read_loop(fd, buf, len);
+			remaining -= len;
+			ret = len;
+			continue;
+		}
+
+		read_loop(fd, line, 4);
+		tag = IVAL(line, 0);
+
+		remaining = tag & 0xFFFFFF;
+		tag = tag >> 24;
+
+		if (tag == MPLEX_BASE) continue;
+
+		tag -= MPLEX_BASE;
+
+		if (tag != FERROR && tag != FINFO) {
+			rprintf(FERROR,"unexpected tag %d\n", tag);
+			exit_cleanup(RERR_STREAMIO);
+		}
+
+		if (remaining > sizeof(line)-1) {
+			rprintf(FERROR,"multiplexing overflow %d\n\n", 
+				remaining);
+			exit_cleanup(RERR_STREAMIO);
+		}
+
+		read_loop(fd, line, remaining);
+		line[remaining] = 0;
+
+		rprintf((enum logcode)tag,"%s", line);
+		remaining = 0;
+	}
+
+	return ret;
+}
+
+
+/* do a buffered read from fd. don't return until all N bytes
+   have been read. If all N can't be read then exit with an error */
+static void readfd(int fd,char *buffer,int N)
 {
 	int  ret;
 	int total=0;  
-	struct timeval tv;
-	
-	if (read_buffer_len < N)
-		read_check(buffer_f_in);
 	
 	while (total < N) {
-		if (read_buffer_len > 0 && buffer_f_in == fd) {
-			ret = MIN(read_buffer_len,N-total);
-			memcpy(buffer+total,read_buffer_p,ret);
-			read_buffer_p += ret;
-			read_buffer_len -= ret;
-			total += ret;
-			continue;
-		} 
+		io_flush();
 
-		while ((ret = read(fd,buffer + total,N-total)) == -1) {
-			fd_set fds;
-
-			if (errno != EAGAIN && errno != EWOULDBLOCK)
-				return -1;
-			FD_ZERO(&fds);
-			FD_SET(fd, &fds);
-			tv.tv_sec = io_timeout;
-			tv.tv_usec = 0;
-
-			if (select(fd+1, &fds, NULL, NULL, 
-				   io_timeout?&tv:NULL) != 1) {
-				check_timeout();
-			}
-		}
-
-		if (ret <= 0)
-			return total;
+		ret = read_unbuffered(fd,buffer + total,N-total);
 		total += ret;
 	}
 
-	if (io_timeout)
-		last_io = time(NULL);
-	return total;
+	stats.total_read += total;
 }
 
 
 int32 read_int(int f)
 {
-  int ret;
-  char b[4];
-  if ((ret=readfd(f,b,4)) != 4) {
-    if (verbose > 1) 
-      rprintf(FERROR,"(%d) Error reading %d bytes : %s\n",
-	      getpid(),4,ret==-1?strerror(errno):"EOF");
-    exit_cleanup(1);
-  }
-  total_read += 4;
-  return IVAL(b,0);
+	char b[4];
+	int32 ret;
+
+	readfd(f,b,4);
+	ret = IVAL(b,0);
+	if (ret == (int32)0xffffffff) return -1;
+	return ret;
 }
 
 int64 read_longint(int f)
@@ -186,20 +288,16 @@ int64 read_longint(int f)
 	char b[8];
 	ret = read_int(f);
 
-	if ((int32)ret != (int32)0xffffffff) return ret;
+	if ((int32)ret != (int32)0xffffffff) {
+		return ret;
+	}
 
 #ifdef NO_INT64
 	rprintf(FERROR,"Integer overflow - attempted 64 bit offset\n");
-	exit_cleanup(1);
+	exit_cleanup(RERR_UNSUPPORTED);
 #else
 	if (remote_version >= 16) {
-		if ((ret=readfd(f,b,8)) != 8) {
-			if (verbose > 1) 
-				rprintf(FERROR,"(%d) Error reading %d bytes : %s\n",
-					getpid(),8,ret==-1?strerror(errno):"EOF");
-			exit_cleanup(1);
-		}
-		total_read += 8;
+		readfd(f,b,8);
 		ret = IVAL(b,0) | (((int64)IVAL(b,4))<<32);
 	}
 #endif
@@ -209,14 +307,7 @@ int64 read_longint(int f)
 
 void read_buf(int f,char *buf,int len)
 {
-  int ret;
-  if ((ret=readfd(f,buf,len)) != len) {
-    if (verbose > 1) 
-      rprintf(FERROR,"(%d) Error reading %d bytes : %s\n",
-	      getpid(),len,ret==-1?strerror(errno):"EOF");
-    exit_cleanup(1);
-  }
-  total_read += len;
+	readfd(f,buf,len);
 }
 
 void read_sbuf(int f,char *buf,int len)
@@ -227,184 +318,169 @@ void read_sbuf(int f,char *buf,int len)
 
 unsigned char read_byte(int f)
 {
-  unsigned char c;
-  read_buf(f,(char *)&c,1);
-  return c;
-}
-
-
-static char last_byte;
-static int last_sparse;
-
-int sparse_end(int f)
-{
-	if (last_sparse) {
-		do_lseek(f,-1,SEEK_CUR);
-		return (write(f,&last_byte,1) == 1 ? 0 : -1);
-	}
-	last_sparse = 0;
-	return 0;
-}
-
-
-static int write_sparse(int f,char *buf,int len)
-{
-	int l1=0,l2=0;
-	int ret;
-
-	for (l1=0;l1<len && buf[l1]==0;l1++) ;
-	for (l2=0;l2<(len-l1) && buf[len-(l2+1)]==0;l2++) ;
-
-	last_byte = buf[len-1];
-
-	if (l1 == len || l2 > 0)
-		last_sparse=1;
-
-	if (l1 > 0)
-		do_lseek(f,l1,SEEK_CUR);  
-
-	if (l1 == len) 
-		return len;
-
-	if ((ret=write(f,buf+l1,len-(l1+l2))) != len-(l1+l2)) {
-		if (ret == -1 || ret == 0) return ret;
-		return (l1+ret);
-	}
-
-	if (l2 > 0)
-		do_lseek(f,l2,SEEK_CUR);
-	
-	return len;
+	unsigned char c;
+	read_buf(f,(char *)&c,1);
+	return c;
 }
 
 
 
-int write_file(int f,char *buf,int len)
+/* write len bytes to fd, possibly reading from buffer_f_in if set
+   in order to unclog the pipe. don't return until all len
+   bytes have been written */
+static void writefd_unbuffered(int fd,char *buf,int len)
 {
-	int ret = 0;
+	int total = 0;
+	fd_set w_fds, r_fds;
+	int fd_count, count;
+	struct timeval tv;
 
-	if (!sparse_files) 
-		return write(f,buf,len);
+	no_flush++;
 
-	while (len>0) {
-		int len1 = MIN(len, SPARSE_WRITE_SIZE);
-		int r1 = write_sparse(f, buf, len1);
-		if (r1 <= 0) {
-			if (ret > 0) return ret;
-			return r1;
+	while (total < len) {
+		FD_ZERO(&w_fds);
+		FD_ZERO(&r_fds);
+		FD_SET(fd,&w_fds);
+		fd_count = fd;
+
+		if (io_error_fd != -1) {
+			FD_SET(io_error_fd,&r_fds);
+			if (io_error_fd > fd_count) 
+				fd_count = io_error_fd;
+		}
+
+		tv.tv_sec = io_timeout?io_timeout:SELECT_TIMEOUT;
+		tv.tv_usec = 0;
+
+		errno = 0;
+
+		count = select(fd_count+1,
+			       io_error_fd != -1?&r_fds:NULL,
+			       &w_fds,NULL,
+			       &tv);
+
+		if (count <= 0) {
+			if (errno == EBADF) {
+				exit_cleanup(RERR_SOCKETIO);
+			}
+			check_timeout();
+			continue;
+		}
+
+		if (io_error_fd != -1 && FD_ISSET(io_error_fd, &r_fds)) {
+			read_error_fd();
+		}
+
+		if (FD_ISSET(fd, &w_fds)) {
+			int ret, n = len-total;
+			
+			ret = write(fd,buf+total,n);
+
+			if (ret == -1 && errno == EINTR) {
+				continue;
+			}
+
+			if (ret == -1 && 
+			    (errno == EWOULDBLOCK || errno == EAGAIN)) {
+				continue;
+			}
+
+			if (ret <= 0) {
+				rprintf(FERROR,"erroring writing %d bytes - exiting\n", len);
+				exit_cleanup(RERR_STREAMIO);
+			}
+
+			/* Sleep after writing to limit I/O bandwidth */
+			if (bwlimit)
+			{
+			    tv.tv_sec = 0;
+			    tv.tv_usec = ret * 1000 / bwlimit;
+			    while (tv.tv_usec > 1000000)
+			    {
+				tv.tv_sec++;
+				tv.tv_usec -= 1000000;
+			    }
+			    select(0, NULL, NULL, NULL, &tv);
+ 			}
+ 
+			total += ret;
+
+			if (io_timeout)
+				last_io = time(NULL);
 		}
-		len -= r1;
-		buf += r1;
-		ret += r1;
 	}
-	return ret;
+
+	no_flush--;
 }
 
 
-static int writefd_unbuffered(int fd,char *buf,int len)
-{
-  int total = 0;
-  fd_set w_fds, r_fds;
-  int fd_count, count, got_select=0;
-  struct timeval tv;
-
-  if (buffer_f_in == -1) 
-    return write(fd,buf,len);
-
-  while (total < len) {
-    int ret = write(fd,buf+total,len-total);
-
-    if (ret == 0) return total;
-
-    if (ret == -1 && !(errno == EWOULDBLOCK || errno == EAGAIN)) 
-      return -1;
-
-    if (ret == -1 && got_select) {
-	    /* hmmm, we got a write select on the fd and then failed to write.
-	       Why doesn't that mean that the fd is dead? It doesn't on some
-	       systems it seems (eg. IRIX) */
-	    u_sleep(1000);
-#if 0
-	    rprintf(FERROR,"write exception\n");
-	    exit_cleanup(1);
-#endif
-    }
-
-    got_select = 0;
-
-
-    if (ret == -1) {
-      read_check(buffer_f_in);
-
-      fd_count = fd+1;
-      FD_ZERO(&w_fds);
-      FD_ZERO(&r_fds);
-      FD_SET(fd,&w_fds);
-      if (buffer_f_in != -1) {
-	      FD_SET(buffer_f_in,&r_fds);
-	      if (buffer_f_in > fd) 
-		      fd_count = buffer_f_in+1;
-      }
-
-      tv.tv_sec = BLOCKING_TIMEOUT;
-      tv.tv_usec = 0;
-      count = select(fd_count,buffer_f_in == -1? NULL: &r_fds,
-		     &w_fds,NULL,&tv);
-      if (count == -1 && errno != EINTR) {
-	      if (verbose > 1) 
-		      rprintf(FERROR,"select error: %s\n", strerror(errno));
-	      exit_cleanup(1);
-      }
-
-      if (count == 0) {
-	      check_timeout();
-	      continue;
-      }
-      
-      if (FD_ISSET(fd, &w_fds)) {
-	      got_select = 1;
-      }
-    } else {
-      total += ret;
-    }
-  }
-
-  if (io_timeout)
-	  last_io = time(NULL);
-
-  return total;
-}
-
 static char *io_buffer;
 static int io_buffer_count;
 
 void io_start_buffering(int fd)
 {
+	if (io_buffer) return;
+	multiplex_out_fd = fd;
 	io_buffer = (char *)malloc(IO_BUFFER_SIZE);
 	if (!io_buffer) out_of_memory("writefd");
 	io_buffer_count = 0;
 }
 
-void io_end_buffering(int fd)
+/* write an message to a multiplexed stream. If this fails then rsync
+   exits */
+static void mplex_write(int fd, enum logcode code, char *buf, int len)
 {
-	if (io_buffer_count) {
-		if (writefd_unbuffered(fd, io_buffer, 
-				       io_buffer_count) != 
-		    io_buffer_count) {
-			rprintf(FERROR,"write failed\n");
-			exit_cleanup(1);
-		}
-		io_buffer_count = 0;
+	char buffer[4096];
+	int n = len;
+
+	SIVAL(buffer, 0, ((MPLEX_BASE + (int)code)<<24) + len);
+
+	if (n > (sizeof(buffer)-4)) {
+		n = sizeof(buffer)-4;
+	}
+
+	memcpy(&buffer[4], buf, n);
+	writefd_unbuffered(fd, buffer, n+4);
+
+	len -= n;
+	buf += n;
+
+	if (len) {
+		writefd_unbuffered(fd, buf, len);
 	}
-	free(io_buffer);
-	io_buffer = NULL;
 }
 
-static int writefd(int fd,char *buf,int len1)
-{
-	int len = len1;
 
-	if (!io_buffer) return writefd_unbuffered(fd, buf, len);
+void io_flush(void)
+{
+	int fd = multiplex_out_fd;
+	if (!io_buffer_count || no_flush) return;
+
+	if (io_multiplexing_out) {
+		mplex_write(fd, FNONE, io_buffer, io_buffer_count);
+	} else {
+		writefd_unbuffered(fd, io_buffer, io_buffer_count);
+	}
+	io_buffer_count = 0;
+}
+
+void io_end_buffering(int fd)
+{
+	io_flush();
+	if (!io_multiplexing_out) {
+		free(io_buffer);
+		io_buffer = NULL;
+	}
+}
+
+static void writefd(int fd,char *buf,int len)
+{
+	stats.total_written += len;
+
+	if (!io_buffer || fd != multiplex_out_fd) {
+		writefd_unbuffered(fd, buf, len);
+		return;
+	}
 
 	while (len) {
 		int n = MIN(len, IO_BUFFER_SIZE-io_buffer_count);
@@ -415,69 +491,42 @@ static int writefd(int fd,char *buf,int len1)
 			io_buffer_count += n;
 		}
 		
-		if (io_buffer_count == IO_BUFFER_SIZE) {
-			if (writefd_unbuffered(fd, io_buffer, 
-					       io_buffer_count) != 
-			    io_buffer_count) {
-				return -1;
-			}
-			io_buffer_count = 0;
-		}
+		if (io_buffer_count == IO_BUFFER_SIZE) io_flush();
 	}
-
-	return len1;
 }
 
 
 void write_int(int f,int32 x)
 {
-  int ret;
-  char b[4];
-  SIVAL(b,0,x);
-  if ((ret=writefd(f,b,4)) != 4) {
-    rprintf(FERROR,"write_int failed : %s\n",
-	    ret==-1?strerror(errno):"EOF");
-    exit_cleanup(1);
-  }
-  total_written += 4;
+	char b[4];
+	SIVAL(b,0,x);
+	writefd(f,b,4);
 }
 
 void write_longint(int f, int64 x)
 {
 	extern int remote_version;
 	char b[8];
-	int ret;
 
 	if (remote_version < 16 || x <= 0x7FFFFFFF) {
 		write_int(f, (int)x);
 		return;
 	}
 
-	write_int(f, -1);
+	write_int(f, (int32)0xFFFFFFFF);
 	SIVAL(b,0,(x&0xFFFFFFFF));
 	SIVAL(b,4,((x>>32)&0xFFFFFFFF));
 
-	if ((ret=writefd(f,b,8)) != 8) {
-		rprintf(FERROR,"write_longint failed : %s\n",
-			ret==-1?strerror(errno):"EOF");
-		exit_cleanup(1);
-	}
-	total_written += 8;
+	writefd(f,b,8);
 }
 
 void write_buf(int f,char *buf,int len)
 {
-  int ret;
-  if ((ret=writefd(f,buf,len)) != len) {
-    rprintf(FERROR,"write_buf failed : %s\n",
-	    ret==-1?strerror(errno):"EOF");
-    exit_cleanup(1);
-  }
-  total_written += len;
+	writefd(f,buf,len);
 }
 
 /* write a string to the connection */
-void write_sbuf(int f,char *buf)
+static void write_sbuf(int f,char *buf)
 {
 	write_buf(f, buf, strlen(buf));
 }
@@ -488,15 +537,14 @@ void write_byte(int f,unsigned char c)
 	write_buf(f,(char *)&c,1);
 }
 
-void write_flush(int f)
-{
-}
-
-
 int read_line(int f, char *buf, int maxlen)
 {
+	eof_error = 0;
+
 	while (maxlen) {
+		buf[0] = 0;
 		read_buf(f, buf, 1);
+		if (buf[0] == 0) return 0;
 		if (buf[0] == '\n') {
 			buf[0] = 0;
 			break;
@@ -510,6 +558,9 @@ int read_line(int f, char *buf, int maxlen)
 		*buf = 0;
 		return 0;
 	}
+
+	eof_error = 1;
+
 	return 1;
 }
 
@@ -521,10 +572,59 @@ void io_printf(int fd, const char *format, ...)
 	int len;
 	
 	va_start(ap, format);
-	len = vslprintf(buf, sizeof(buf)-1, format, ap);
+	len = vslprintf(buf, sizeof(buf), format, ap);
 	va_end(ap);
 
-	if (len < 0) exit_cleanup(1);
+	if (len < 0) exit_cleanup(RERR_STREAMIO);
 
 	write_sbuf(fd, buf);
 }
+
+
+/* setup for multiplexing an error stream with the data stream */
+void io_start_multiplex_out(int fd)
+{
+	multiplex_out_fd = fd;
+	io_flush();
+	io_start_buffering(fd);
+	io_multiplexing_out = 1;
+}
+
+/* setup for multiplexing an error stream with the data stream */
+void io_start_multiplex_in(int fd)
+{
+	multiplex_in_fd = fd;
+	io_flush();
+	io_multiplexing_in = 1;
+}
+
+/* write an message to the multiplexed error stream */
+int io_multiplex_write(enum logcode code, char *buf, int len)
+{
+	if (!io_multiplexing_out) return 0;
+
+	io_flush();
+	stats.total_written += (len+4);
+	mplex_write(multiplex_out_fd, code, buf, len);
+	return 1;
+}
+
+/* write a message to the special error fd */
+int io_error_write(int f, enum logcode code, char *buf, int len)
+{
+	if (f == -1) return 0;
+	mplex_write(f, code, buf, len);
+	return 1;
+}
+
+/* stop output multiplexing */
+void io_multiplexing_close(void)
+{
+	io_multiplexing_out = 0;
+}
+
+void io_close_input(int fd)
+{
+	buffer_f_in = -1;
+}
+

lib/compat.c

@@ -36,7 +36,7 @@
 #endif
 
 #ifndef HAVE_GETCWD
-char *getcwd(char *buf, int size)
+ char *getcwd(char *buf, int size)
 {
 	return getwd(buf);
 }
@@ -44,17 +44,142 @@ char *getcwd(char *buf, int size)
 
 
 #ifndef HAVE_WAITPID
-pid_t waitpid(pid_t pid, int *statptr, int options)
+ pid_t waitpid(pid_t pid, int *statptr, int options)
 {
+#ifdef HAVE_WAIT4
 	return wait4(pid, statptr, options, NULL);
+#else
+	/* If wait4 is also not available, try wait3 for SVR3 variants */
+	/* Less ideal because can't actually request a specific pid */
+	/* At least the WNOHANG option is supported */
+	/* Code borrowed from apache fragment written by dwd@bell-labs.com */
+	int tmp_pid, dummystat;;
+	if (kill(pid, 0) == -1) {
+		errno = ECHILD;
+		return -1;
+	}
+	if (statptr == NULL)
+		statptr = &dummystat;
+	while (((tmp_pid = wait3(statptr, options, 0)) != pid) &&
+		    (tmp_pid != -1) && (tmp_pid != 0) && (pid != -1))
+	    ;
+	return tmp_pid;
+#endif
 }
 #endif
 
 
 #ifndef HAVE_MEMMOVE
-void *memmove(void *dest, const void *src, size_t n)
+ void *memmove(void *dest, const void *src, size_t n)
 {
-	bcopy(src, dest, n);
+	bcopy((char *) src, (char *) dest, n);
 	return dest;
 }
 #endif
+
+#ifndef HAVE_STRPBRK
+/* Find the first ocurrence in S of any character in ACCEPT.  
+   derived from glibc 
+*/
+ char *strpbrk(const char *s, const char *accept)
+{
+	while (*s != '\0')  {
+		const char *a = accept;
+		while (*a != '\0') {
+			if (*a++ == *s)	return (char *)s;
+		}
+		++s;
+	}
+
+	return NULL;
+}
+#endif
+
+
+#ifndef HAVE_STRLCPY
+/* like strncpy but does not 0 fill the buffer and always null 
+   terminates. bufsize is the size of the destination buffer */
+ size_t strlcpy(char *d, const char *s, size_t bufsize)
+{
+	size_t len = strlen(s);
+	size_t ret = len;
+	if (len >= bufsize) len = bufsize-1;
+	memcpy(d, s, len);
+	d[len] = 0;
+	return ret;
+}
+#endif
+
+#ifndef HAVE_STRLCAT
+/* like strncat but does not 0 fill the buffer and always null 
+   terminates. bufsize is the length of the buffer, which should
+   be one more than the maximum resulting string length */
+ size_t strlcat(char *d, const char *s, size_t bufsize)
+{
+	size_t len1 = strlen(d);
+	size_t len2 = strlen(s);
+	size_t ret = len1 + len2;
+
+	if (len1+len2 >= bufsize) {
+		len2 = bufsize - (len1+1);
+	}
+	if (len2 > 0) {
+		memcpy(d+len1, s, len2);
+		d[len1+len2] = 0;
+	}
+	return ret;
+}
+#endif
+
+#ifdef REPLACE_INET_NTOA
+ char *rep_inet_ntoa(struct in_addr ip)
+{
+	unsigned char *p = (unsigned char *)&ip.s_addr;
+	static char buf[18];
+#if WORDS_BIGENDIAN
+	slprintf(buf, 18, "%d.%d.%d.%d", 
+		 (int)p[0], (int)p[1], (int)p[2], (int)p[3]);
+#else
+	slprintf(buf, 18, "%d.%d.%d.%d", 
+		 (int)p[3], (int)p[2], (int)p[1], (int)p[0]);
+#endif
+	return buf;
+}
+#endif
+
+#ifdef REPLACE_INET_ATON
+ int inet_aton(const char *cp, struct in_addr *inp)
+{
+	unsigned int a1, a2, a3, a4;
+	unsigned long ret;
+
+	if (strcmp(cp, "255.255.255.255") == 0) {
+		inp->s_addr = (unsigned) -1;
+		return 0;
+	}
+
+	if (sscanf(cp, "%u.%u.%u.%u", &a1, &a2, &a3, &a4) != 4 ||
+	    a1 > 255 || a2 > 255 || a3 > 255 || a4 > 255) {
+		return 0;
+	}
+
+	ret = (a1 << 24) | (a2 << 16) | (a3 << 8) | a4;
+
+	inp->s_addr = htonl(ret);
+	
+	if (inp->s_addr == (unsigned) -1) {
+		return 0;
+	}
+	return 1;
+}
+#endif
+
+/* some systems don't take the 2nd argument */
+int sys_gettimeofday(struct timeval *tv)
+{
+#if HAVE_GETTIMEOFDAY_TZ
+	return gettimeofday(tv, NULL);
+#else
+	return gettimeofday(tv);
+#endif
+}

lib/fnmatch.c

@@ -1,33 +1,60 @@
 #include "../rsync.h"
 #ifndef HAVE_FNMATCH
 
-/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
+/* ----- THE FOLLOWING UP TO 'END' is glibc-2.1.2 posix/fnmatch.c
+     except for the parts with '#if 0' */
 
-NOTE: The canonical source of this file is maintained with the GNU C Library.
-Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+/* Copyright (C) 1991, 92, 93, 96, 97, 98, 99 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
 
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU Library General Public
+   License along with this library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
-#if defined (STDC_HEADERS) || !defined (isascii)
-#define ISASCII(c) 1
-#else
-#define ISASCII(c) isascii(c)
+#if 0	/* header files included better by ../rsync.h */
+
+#if HAVE_CONFIG_H
+# include <config.h>
 #endif
 
-#define ISUPPER(c) (ISASCII (c) && isupper (c))
+/* Enable GNU extensions in fnmatch.h.  */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE	1
+#endif
 
+#include <errno.h>
+#include <fnmatch.h>
+#include <ctype.h>
+
+#if HAVE_STRING_H || defined _LIBC
+# include <string.h>
+#else
+# include <strings.h>
+#endif
+
+#if defined STDC_HEADERS || defined _LIBC
+# include <stdlib.h>
+#endif
+
+#endif /* 0 */
+/* For platform which support the ISO C amendement 1 functionality we
+   support user defined character classes.  */
+#if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
+/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>.  */
+# include <wchar.h>
+# include <wctype.h>
+#endif
 
 /* Comment out all this code if we are using the GNU C Library, and are not
    actually compiling the library itself.  This code is part of the GNU C
@@ -37,23 +64,95 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
    program understand `configure --with-gnu-libc' and omit the object files,
    it is simpler to just do this in the source for each such file.  */
 
-#if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS)
-extern int errno;
+#if 1
+
+# if defined STDC_HEADERS || !defined isascii
+#  define ISASCII(c) 1
+# else
+#  define ISASCII(c) isascii(c)
+# endif
+
+#ifdef isblank
+# define ISBLANK(c) (ISASCII (c) && isblank (c))
+#else
+# define ISBLANK(c) ((c) == ' ' || (c) == '\t')
 #endif
+#ifdef isgraph
+# define ISGRAPH(c) (ISASCII (c) && isgraph (c))
+#else
+# define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))
+#endif
+
+#define ISPRINT(c) (ISASCII (c) && isprint (c))
+#define ISDIGIT(c) (ISASCII (c) && isdigit (c))
+#define ISALNUM(c) (ISASCII (c) && isalnum (c))
+#define ISALPHA(c) (ISASCII (c) && isalpha (c))
+#define ISCNTRL(c) (ISASCII (c) && iscntrl (c))
+#define ISLOWER(c) (ISASCII (c) && islower (c))
+#define ISPUNCT(c) (ISASCII (c) && ispunct (c))
+#define ISSPACE(c) (ISASCII (c) && isspace (c))
+#define ISUPPER(c) (ISASCII (c) && isupper (c))
+#define ISXDIGIT(c) (ISASCII (c) && isxdigit (c))
+
+# define STREQ(s1, s2) ((strcmp (s1, s2) == 0))
+
+# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
+/* The GNU C library provides support for user-defined character classes
+   and the functions from ISO C amendement 1.  */
+#  ifdef CHARCLASS_NAME_MAX
+#   define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX
+#  else
+/* This shouldn't happen but some implementation might still have this
+   problem.  Use a reasonable default value.  */
+#   define CHAR_CLASS_MAX_LENGTH 256
+#  endif
+
+#  ifdef _LIBC
+#   define IS_CHAR_CLASS(string) __wctype (string)
+#  else
+#   define IS_CHAR_CLASS(string) wctype (string)
+#  endif
+# else
+#  define CHAR_CLASS_MAX_LENGTH  6 /* Namely, `xdigit'.  */
+
+#  define IS_CHAR_CLASS(string)						      \
+   (STREQ (string, "alpha") || STREQ (string, "upper")			      \
+    || STREQ (string, "lower") || STREQ (string, "digit")		      \
+    || STREQ (string, "alnum") || STREQ (string, "xdigit")		      \
+    || STREQ (string, "space") || STREQ (string, "print")		      \
+    || STREQ (string, "punct") || STREQ (string, "graph")		      \
+    || STREQ (string, "cntrl") || STREQ (string, "blank"))
+# endif
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+# if !defined _LIBC && !defined getenv
+extern char *getenv ();
+# endif
+
+# ifndef errno
+extern int errno;
+# endif
 
 /* Match STRING against the filename pattern PATTERN, returning zero if
    it matches, nonzero if not.  */
-int
-fnmatch (pattern, string, flags)
-     const char *pattern;
-     const char *string;
-     int flags;
+static int
+#ifdef _LIBC
+internal_function
+#endif
+internal_fnmatch (const char *pattern, const char *string,
+		  int no_leading_period, int flags)
 {
   register const char *p = pattern, *n = string;
-  register char c;
+  register unsigned char c;
 
-/* Note that this evalutes C many times.  */
-#define FOLD(c)	((flags & FNM_CASEFOLD) && ISUPPER (c) ? tolower (c) : (c))
+/* Note that this evaluates C many times.  */
+# ifdef _LIBC
+#  define FOLD(c) ((flags & FNM_CASEFOLD) ? tolower (c) : (c))
+# else
+#  define FOLD(c) ((flags & FNM_CASEFOLD) && ISUPPER (c) ? tolower (c) : (c))
+# endif
 
   while ((c = *p++) != '\0')
     {
@@ -64,10 +163,11 @@ fnmatch (pattern, string, flags)
 	case '?':
 	  if (*n == '\0')
 	    return FNM_NOMATCH;
-	  else if ((flags & FNM_FILE_NAME) && *n == '/')
+	  else if (*n == '/' && (flags & FNM_FILE_NAME))
 	    return FNM_NOMATCH;
-	  else if ((flags & FNM_PERIOD) && *n == '.' &&
-		   (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
+	  else if (*n == '.' && no_leading_period
+		   && (n == string
+		       || (n[-1] == '/' && (flags & FNM_FILE_NAME))))
 	    return FNM_NOMATCH;
 	  break;
 
@@ -75,95 +175,245 @@ fnmatch (pattern, string, flags)
 	  if (!(flags & FNM_NOESCAPE))
 	    {
 	      c = *p++;
+	      if (c == '\0')
+		/* Trailing \ loses.  */
+		return FNM_NOMATCH;
 	      c = FOLD (c);
 	    }
-	  if (FOLD (*n) != c)
+	  if (FOLD ((unsigned char) *n) != c)
 	    return FNM_NOMATCH;
 	  break;
 
 	case '*':
-	  if ((flags & FNM_PERIOD) && *n == '.' &&
-	      (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
+	  if (*n == '.' && no_leading_period
+	      && (n == string
+		  || (n[-1] == '/' && (flags & FNM_FILE_NAME))))
 	    return FNM_NOMATCH;
 
-	  for (c = *p++; c == '?' || c == '*'; c = *p++, ++n)
-	    if (((flags & FNM_FILE_NAME) && *n == '/') ||
-		(c == '?' && *n == '\0'))
-	      return FNM_NOMATCH;
+	  for (c = *p++; c == '?' || c == '*'; c = *p++)
+	    {
+	      if (*n == '/' && (flags & FNM_FILE_NAME))
+		/* A slash does not match a wildcard under FNM_FILE_NAME.  */
+		return FNM_NOMATCH;
+	      else if (c == '?')
+		{
+		  /* A ? needs to match one character.  */
+		  if (*n == '\0')
+		    /* There isn't another character; no match.  */
+		    return FNM_NOMATCH;
+		  else
+		    /* One character of the string is consumed in matching
+		       this ? wildcard, so *??? won't match if there are
+		       less than three characters.  */
+		    ++n;
+		}
+	    }
 
 	  if (c == '\0')
-	    return 0;
+	    /* The wildcard(s) is/are the last element of the pattern.
+	       If the name is a file name and contains another slash
+	       this does mean it cannot match.  */
+	    return ((flags & FNM_FILE_NAME) && strchr (n, '/') != NULL
+		    ? FNM_NOMATCH : 0);
+	  else
+	    {
+	      const char *endp;
 
-	  {
-	    char c1 = (!(flags & FNM_NOESCAPE) && c == '\\') ? *p : c;
-	    c1 = FOLD (c1);
-	    for (--p; *n != '\0'; ++n)
-	      if ((c == '[' || FOLD (*n) == c1) &&
-		  fnmatch (p, n, flags & ~FNM_PERIOD) == 0)
-		return 0;
-	    return FNM_NOMATCH;
-	  }
+#if 0
+	      endp = __strchrnul (n, (flags & FNM_FILE_NAME) ? '/' : '\0');
+#else
+/* replace call to internal glibc function with equivalent */
+	      if (!(flags & FNM_FILE_NAME) || ((endp = strchr(n, '/')) == NULL))
+		endp = n + strlen(n);
+#endif
+
+	      if (c == '[')
+		{
+		  int flags2 = ((flags & FNM_FILE_NAME)
+				? flags : (flags & ~FNM_PERIOD));
+
+		  for (--p; n < endp; ++n)
+		    if (internal_fnmatch (p, n,
+					  (no_leading_period
+					   && (n == string
+					       || (n[-1] == '/'
+						   && (flags
+						       & FNM_FILE_NAME)))),
+					  flags2)
+			== 0)
+		      return 0;
+		}
+	      else if (c == '/' && (flags & FNM_FILE_NAME))
+		{
+		  while (*n != '\0' && *n != '/')
+		    ++n;
+		  if (*n == '/'
+		      && (internal_fnmatch (p, n + 1, flags & FNM_PERIOD,
+					    flags) == 0))
+		    return 0;
+		}
+	      else
+		{
+		  int flags2 = ((flags & FNM_FILE_NAME)
+				? flags : (flags & ~FNM_PERIOD));
+
+		  if (c == '\\' && !(flags & FNM_NOESCAPE))
+		    c = *p;
+		  c = FOLD (c);
+		  for (--p; n < endp; ++n)
+		    if (FOLD ((unsigned char) *n) == c
+			&& (internal_fnmatch (p, n,
+					      (no_leading_period
+					       && (n == string
+						   || (n[-1] == '/'
+						       && (flags
+							   & FNM_FILE_NAME)))),
+					      flags2) == 0))
+		      return 0;
+		}
+	    }
+
+	  /* If we come here no match is possible with the wildcard.  */
+	  return FNM_NOMATCH;
 
 	case '[':
 	  {
 	    /* Nonzero if the sense of the character class is inverted.  */
+	    static int posixly_correct;
 	    register int not;
+	    char cold;
+
+	    if (posixly_correct == 0)
+	      posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;
 
 	    if (*n == '\0')
 	      return FNM_NOMATCH;
 
-	    if ((flags & FNM_PERIOD) && *n == '.' &&
-		(n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
+	    if (*n == '.' && no_leading_period && (n == string
+						   || (n[-1] == '/'
+						       && (flags
+							   & FNM_FILE_NAME))))
 	      return FNM_NOMATCH;
 
-	    not = (*p == '!' || *p == '^');
+	    if (*n == '/' && (flags & FNM_FILE_NAME))
+	      /* `/' cannot be matched.  */
+	      return FNM_NOMATCH;
+
+	    not = (*p == '!' || (posixly_correct < 0 && *p == '^'));
 	    if (not)
 	      ++p;
 
 	    c = *p++;
 	    for (;;)
 	      {
-		register char cstart = c, cend = c;
+		unsigned char fn = FOLD ((unsigned char) *n);
 
 		if (!(flags & FNM_NOESCAPE) && c == '\\')
-		  cstart = cend = *p++;
+		  {
+		    if (*p == '\0')
+		      return FNM_NOMATCH;
+		    c = FOLD ((unsigned char) *p);
+		    ++p;
 
-		cstart = cend = FOLD (cstart);
+		    if (c == fn)
+		      goto matched;
+		  }
+		else if (c == '[' && *p == ':')
+		  {
+		    /* Leave room for the null.  */
+		    char str[CHAR_CLASS_MAX_LENGTH + 1];
+		    size_t c1 = 0;
+# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
+		    wctype_t wt;
+# endif
+		    const char *startp = p;
 
-		if (c == '\0')
+		    for (;;)
+		      {
+			if (c1 == CHAR_CLASS_MAX_LENGTH)
+			  /* The name is too long and therefore the pattern
+			     is ill-formed.  */
+			  return FNM_NOMATCH;
+
+			c = *++p;
+			if (c == ':' && p[1] == ']')
+			  {
+			    p += 2;
+			    break;
+			  }
+			if (c < 'a' || c >= 'z')
+			  {
+			    /* This cannot possibly be a character class name.
+			       Match it as a normal range.  */
+			    p = startp;
+			    c = '[';
+			    goto normal_bracket;
+			  }
+			str[c1++] = c;
+		      }
+		    str[c1] = '\0';
+
+# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
+		    wt = IS_CHAR_CLASS (str);
+		    if (wt == 0)
+		      /* Invalid character class name.  */
+		      return FNM_NOMATCH;
+
+		    if (__iswctype (__btowc ((unsigned char) *n), wt))
+		      goto matched;
+# else
+		    if ((STREQ (str, "alnum") && ISALNUM ((unsigned char) *n))
+			|| (STREQ (str, "alpha") && ISALPHA ((unsigned char) *n))
+			|| (STREQ (str, "blank") && ISBLANK ((unsigned char) *n))
+			|| (STREQ (str, "cntrl") && ISCNTRL ((unsigned char) *n))
+			|| (STREQ (str, "digit") && ISDIGIT ((unsigned char) *n))
+			|| (STREQ (str, "graph") && ISGRAPH ((unsigned char) *n))
+			|| (STREQ (str, "lower") && ISLOWER ((unsigned char) *n))
+			|| (STREQ (str, "print") && ISPRINT ((unsigned char) *n))
+			|| (STREQ (str, "punct") && ISPUNCT ((unsigned char) *n))
+			|| (STREQ (str, "space") && ISSPACE ((unsigned char) *n))
+			|| (STREQ (str, "upper") && ISUPPER ((unsigned char) *n))
+			|| (STREQ (str, "xdigit") && ISXDIGIT ((unsigned char) *n)))
+		      goto matched;
+# endif
+		  }
+		else if (c == '\0')
 		  /* [ (unterminated) loses.  */
 		  return FNM_NOMATCH;
-
-		c = *p++;
-		c = FOLD (c);
-
-		if ((flags & FNM_FILE_NAME) && c == '/')
-		  /* [/] can never match.  */
-		  return FNM_NOMATCH;
-
-		if (c == '-' && *p != ']')
+		else
 		  {
-		    cend = *p++;
-		    if (!(flags & FNM_NOESCAPE) && cend == '\\')
-		      cend = *p++;
-		    if (cend == '\0')
-		      return FNM_NOMATCH;
-		    cend = FOLD (cend);
+		  normal_bracket:
+		    if (FOLD (c) == fn)
+		      goto matched;
 
+		    cold = c;
 		    c = *p++;
-		  }
 
-		if (FOLD (*n) >= cstart && FOLD (*n) <= cend)
-		  goto matched;
+		    if (c == '-' && *p != ']')
+		      {
+			/* It is a range.  */
+			unsigned char cend = *p++;
+			if (!(flags & FNM_NOESCAPE) && cend == '\\')
+			  cend = *p++;
+			if (cend == '\0')
+			  return FNM_NOMATCH;
+
+			if (cold <= fn && fn <= FOLD (cend))
+			  goto matched;
+
+			c = *p++;
+		      }
+		  }
 
 		if (c == ']')
 		  break;
 	      }
+
 	    if (!not)
 	      return FNM_NOMATCH;
 	    break;
 
-	  matched:;
+	  matched:
 	    /* Skip the rest of the [...] that already matched.  */
 	    while (c != ']')
 	      {
@@ -173,8 +423,21 @@ fnmatch (pattern, string, flags)
 
 		c = *p++;
 		if (!(flags & FNM_NOESCAPE) && c == '\\')
-		  /* XXX 1003.2d11 is unclear if this is right.  */
-		  ++p;
+		  {
+		    if (*p == '\0')
+		      return FNM_NOMATCH;
+		    /* XXX 1003.2d11 is unclear if this is right.  */
+		    ++p;
+		  }
+		else if (c == '[' && *p == ':')
+		  {
+		    do
+		      if (*++p == '\0')
+			return FNM_NOMATCH;
+		    while (*p != ':' || p[1] == ']');
+		    p += 2;
+		    c = *p;
+		  }
 	      }
 	    if (not)
 	      return FNM_NOMATCH;
@@ -182,7 +445,7 @@ fnmatch (pattern, string, flags)
 	  break;
 
 	default:
-	  if (c != FOLD (*n))
+	  if (c != FOLD ((unsigned char) *n))
 	    return FNM_NOMATCH;
 	}
 
@@ -197,8 +460,23 @@ fnmatch (pattern, string, flags)
     return 0;
 
   return FNM_NOMATCH;
+
+# undef FOLD
 }
 
+
+int
+fnmatch (pattern, string, flags)
+     const char *pattern;
+     const char *string;
+     int flags;
+{
+  return internal_fnmatch (pattern, string, flags & FNM_PERIOD, flags);
+}
+
+#endif	/* _LIBC or not __GNU_LIBRARY__.  */
+/* ----- END glibc-2.1.2 posix/fnmatch.c */
+
 #else	/* HAVE_FNMATCH */
 void fnmatch_dummy(void) {}
 #endif

lib/fnmatch.h

@@ -1,41 +1,48 @@
-/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 93, 96, 97, 98 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
 
-NOTE: The canonical source of this file is maintained with the GNU C Library.
-Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
 
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
 #ifndef	_FNMATCH_H
-
 #define	_FNMATCH_H	1
 
 #ifdef	__cplusplus
 extern "C" {
 #endif
 
-#if defined (__cplusplus) || (defined (__STDC__) && __STDC__)
-#undef	__P
-#define	__P(protos)	protos
+#if defined __cplusplus || (defined __STDC__ && __STDC__) || defined WINDOWS32
+# if !defined __GLIBC__ || !defined __P
+#  undef	__P
+#  define __P(protos)	protos
+# endif
 #else /* Not C++ or ANSI C.  */
-#undef	__P
-#define	__P(protos)	()
+# undef	__P
+# define __P(protos)	()
 /* We can get away without defining `const' here only because in this file
    it is used only inside the prototype for `fnmatch', which is elided in
    non-ANSI C where `const' is problematical.  */
 #endif /* C++ or ANSI C.  */
 
+#ifndef const
+# if (defined __STDC__ && __STDC__) || defined __cplusplus
+#  define __const	const
+# else
+#  define __const
+# endif
+#endif
 
 /* We #undef these before defining them because some losing systems
    (HP-UX A.08.07 for example) define these in <unistd.h>.  */
@@ -48,18 +55,30 @@ extern "C" {
 #define	FNM_NOESCAPE	(1 << 1) /* Backslashes don't quote special chars.  */
 #define	FNM_PERIOD	(1 << 2) /* Leading `.' is matched only explicitly.  */
 
-#if !defined (_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 2 || defined (_GNU_SOURCE)
-#define	FNM_FILE_NAME	FNM_PATHNAME /* Preferred GNU name.  */
-#define	FNM_LEADING_DIR	(1 << 3) /* Ignore `/...' after a match.  */
-#define	FNM_CASEFOLD	(1 << 4) /* Compare without regard to case.  */
+#ifndef FNM_FILE_NAME
+# define FNM_FILE_NAME	 FNM_PATHNAME	/* Preferred GNU name.  */
+#endif
+#ifndef FNM_LEADING_DIR
+# define FNM_LEADING_DIR (1 << 3)	/* Ignore `/...' after a match.  */
+#endif
+#ifndef FNM_CASEFOLD
+# define FNM_CASEFOLD	 (1 << 4)	/* Compare without regard to case.  */
 #endif
 
 /* Value returned by `fnmatch' if STRING does not match PATTERN.  */
 #define	FNM_NOMATCH	1
 
+/* This value is returned if the implementation does not support
+   `fnmatch'.  Since this is not the case here it will never be
+   returned but the conformance test suites still require the symbol
+   to be defined.  */
+#ifdef _XOPEN_SOURCE
+# define FNM_NOSYS	(-1)
+#endif
+
 /* Match STRING against the filename pattern PATTERN,
    returning zero if it matches, FNM_NOMATCH if not.  */
-extern int fnmatch __P ((const char *__pattern, const char *__string,
+extern int fnmatch __P ((__const char *__pattern, __const char *__string,
 			 int __flags));
 
 #ifdef	__cplusplus

lib/mdfour.c

@@ -0,0 +1,266 @@
+/* 
+   Unix SMB/Netbios implementation.
+   Version 1.9.
+   a implementation of MD4 designed for use in the SMB authentication protocol
+   Copyright (C) Andrew Tridgell 1997-1998.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "rsync.h"
+
+/* NOTE: This code makes no attempt to be fast! 
+
+   It assumes that a int is at least 32 bits long
+*/
+
+static struct mdfour *m;
+
+#define F(X,Y,Z) (((X)&(Y)) | ((~(X))&(Z)))
+#define G(X,Y,Z) (((X)&(Y)) | ((X)&(Z)) | ((Y)&(Z)))
+#define H(X,Y,Z) ((X)^(Y)^(Z))
+#ifdef LARGE_INT32
+#define lshift(x,s) ((((x)<<(s))&0xFFFFFFFF) | (((x)>>(32-(s)))&0xFFFFFFFF))
+#else
+#define lshift(x,s) (((x)<<(s)) | ((x)>>(32-(s))))
+#endif
+
+#define ROUND1(a,b,c,d,k,s) a = lshift((uint32)(a + F(b,c,d) + X[k]), s)
+#define ROUND2(a,b,c,d,k,s) a = lshift((uint32)(a + G(b,c,d) + X[k] + 0x5A827999),s)
+#define ROUND3(a,b,c,d,k,s) a = lshift((uint32)(a + H(b,c,d) + X[k] + 0x6ED9EBA1),s)
+
+/* this applies md4 to 64 byte chunks */
+static void mdfour64(uint32 *M)
+{
+	int j;
+	uint32 AA, BB, CC, DD;
+	uint32 X[16];
+	uint32 A,B,C,D;
+
+	for (j=0;j<16;j++)
+		X[j] = M[j];
+
+	A = m->A; B = m->B; C = m->C; D = m->D; 
+	AA = A; BB = B; CC = C; DD = D;
+
+        ROUND1(A,B,C,D,  0,  3);  ROUND1(D,A,B,C,  1,  7);  
+	ROUND1(C,D,A,B,  2, 11);  ROUND1(B,C,D,A,  3, 19);
+        ROUND1(A,B,C,D,  4,  3);  ROUND1(D,A,B,C,  5,  7);  
+	ROUND1(C,D,A,B,  6, 11);  ROUND1(B,C,D,A,  7, 19);
+        ROUND1(A,B,C,D,  8,  3);  ROUND1(D,A,B,C,  9,  7);  
+	ROUND1(C,D,A,B, 10, 11);  ROUND1(B,C,D,A, 11, 19);
+        ROUND1(A,B,C,D, 12,  3);  ROUND1(D,A,B,C, 13,  7);  
+	ROUND1(C,D,A,B, 14, 11);  ROUND1(B,C,D,A, 15, 19);	
+
+        ROUND2(A,B,C,D,  0,  3);  ROUND2(D,A,B,C,  4,  5);  
+	ROUND2(C,D,A,B,  8,  9);  ROUND2(B,C,D,A, 12, 13);
+        ROUND2(A,B,C,D,  1,  3);  ROUND2(D,A,B,C,  5,  5);  
+	ROUND2(C,D,A,B,  9,  9);  ROUND2(B,C,D,A, 13, 13);
+        ROUND2(A,B,C,D,  2,  3);  ROUND2(D,A,B,C,  6,  5);  
+	ROUND2(C,D,A,B, 10,  9);  ROUND2(B,C,D,A, 14, 13);
+        ROUND2(A,B,C,D,  3,  3);  ROUND2(D,A,B,C,  7,  5);  
+	ROUND2(C,D,A,B, 11,  9);  ROUND2(B,C,D,A, 15, 13);
+
+	ROUND3(A,B,C,D,  0,  3);  ROUND3(D,A,B,C,  8,  9);  
+	ROUND3(C,D,A,B,  4, 11);  ROUND3(B,C,D,A, 12, 15);
+        ROUND3(A,B,C,D,  2,  3);  ROUND3(D,A,B,C, 10,  9);  
+	ROUND3(C,D,A,B,  6, 11);  ROUND3(B,C,D,A, 14, 15);
+        ROUND3(A,B,C,D,  1,  3);  ROUND3(D,A,B,C,  9,  9);  
+	ROUND3(C,D,A,B,  5, 11);  ROUND3(B,C,D,A, 13, 15);
+        ROUND3(A,B,C,D,  3,  3);  ROUND3(D,A,B,C, 11,  9);  
+	ROUND3(C,D,A,B,  7, 11);  ROUND3(B,C,D,A, 15, 15);
+
+	A += AA; B += BB; C += CC; D += DD;
+	
+#ifdef LARGE_INT32
+	A &= 0xFFFFFFFF; B &= 0xFFFFFFFF;
+	C &= 0xFFFFFFFF; D &= 0xFFFFFFFF;
+#endif
+
+	for (j=0;j<16;j++)
+		X[j] = 0;
+
+	m->A = A; m->B = B; m->C = C; m->D = D;
+}
+
+static void copy64(uint32 *M, unsigned char *in)
+{
+	int i;
+
+	for (i=0;i<16;i++)
+		M[i] = (in[i*4+3]<<24) | (in[i*4+2]<<16) |
+			(in[i*4+1]<<8) | (in[i*4+0]<<0);
+}
+
+static void copy4(unsigned char *out,uint32 x)
+{
+	out[0] = x&0xFF;
+	out[1] = (x>>8)&0xFF;
+	out[2] = (x>>16)&0xFF;
+	out[3] = (x>>24)&0xFF;
+}
+
+void mdfour_begin(struct mdfour *md)
+{
+	md->A = 0x67452301;
+	md->B = 0xefcdab89;
+	md->C = 0x98badcfe;
+	md->D = 0x10325476;
+	md->totalN = 0;
+}
+
+
+static void mdfour_tail(unsigned char *in, int n)
+{
+	unsigned char buf[128];
+	uint32 M[16];
+	uint32 b;
+
+	m->totalN += n;
+
+	b = m->totalN * 8;
+
+	memset(buf, 0, 128);
+	if (n) memcpy(buf, in, n);
+	buf[n] = 0x80;
+
+	if (n <= 55) {
+		copy4(buf+56, b);
+		copy64(M, buf);
+		mdfour64(M);
+	} else {
+		copy4(buf+120, b); 
+		copy64(M, buf);
+		mdfour64(M);
+		copy64(M, buf+64);
+		mdfour64(M);
+	}
+}
+
+void mdfour_update(struct mdfour *md, unsigned char *in, int n)
+{
+	uint32 M[16];
+
+	if (n == 0) mdfour_tail(in, n);
+
+	m = md;
+
+	while (n >= 64) {
+		copy64(M, in);
+		mdfour64(M);
+		in += 64;
+		n -= 64;
+		m->totalN += 64;
+	}
+
+	if (n) mdfour_tail(in, n);
+}
+
+
+void mdfour_result(struct mdfour *md, unsigned char *out)
+{
+	m = md;
+
+	copy4(out, m->A);
+	copy4(out+4, m->B);
+	copy4(out+8, m->C);
+	copy4(out+12, m->D);
+}
+
+
+void mdfour(unsigned char *out, unsigned char *in, int n)
+{
+	struct mdfour md;
+	mdfour_begin(&md);
+	mdfour_update(&md, in, n);
+	mdfour_result(&md, out);
+}
+
+#ifdef TEST_MDFOUR
+static void file_checksum1(char *fname)
+{
+	int fd, i;
+	struct mdfour md;
+	unsigned char buf[64*1024], sum[16];
+	
+	fd = open(fname,O_RDONLY);
+	if (fd == -1) {
+		perror("fname");
+		exit(1);
+	}
+	
+	mdfour_begin(&md);
+
+	while (1) {
+		int n = read(fd, buf, sizeof(buf));
+		if (n <= 0) break;
+		mdfour_update(&md, buf, n);
+	}
+
+	close(fd);
+
+	mdfour_result(&md, sum);
+
+	for (i=0;i<16;i++)
+		printf("%02X", sum[i]);
+	printf("\n");
+}
+
+#if 0
+#include "../md4.h"
+
+static void file_checksum2(char *fname)
+{
+	int fd, i;
+	MDstruct md;
+	unsigned char buf[64], sum[16];
+
+	fd = open(fname,O_RDONLY);
+	if (fd == -1) {
+		perror("fname");
+		exit(1);
+	}
+	
+	MDbegin(&md);
+
+	while (1) {
+		int n = read(fd, buf, sizeof(buf));
+		if (n <= 0) break;
+		MDupdate(&md, buf, n*8);
+	}
+
+	if (!md.done) {
+		MDupdate(&md, buf, 0);
+	}
+
+	close(fd);
+
+	memcpy(sum, md.buffer, 16);
+
+	for (i=0;i<16;i++)
+		printf("%02X", sum[i]);
+	printf("\n");
+}
+#endif
+
+ int main(int argc, char *argv[])
+{
+	file_checksum1(argv[1]);
+#if 0
+	file_checksum2(argv[1]);
+#endif
+	return 0;
+}
+#endif

lib/mdfour.h

@@ -0,0 +1,34 @@
+/* 
+   Unix SMB/Netbios implementation.
+   Version 1.9.
+   a implementation of MD4 designed for use in the SMB authentication protocol
+   Copyright (C) Andrew Tridgell 1997-1998.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+struct mdfour {
+	uint32 A, B, C, D;
+	uint32 totalN;
+};
+
+void mdfour_begin(struct mdfour *md);
+void mdfour_update(struct mdfour *md, unsigned char *in, int n);
+void mdfour_result(struct mdfour *md, unsigned char *out);
+void mdfour(unsigned char *out, unsigned char *in, int n);
+
+
+
+

lib/snprintf.c

@@ -0,0 +1,820 @@
+/*
+ * Copyright Patrick Powell 1995
+ * This code is based on code written by Patrick Powell (papowell@astart.com)
+ * It may be used for any purpose as long as this notice remains intact
+ * on all source code distributions
+ */
+
+/**************************************************************
+ * Original:
+ * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
+ * A bombproof version of doprnt (dopr) included.
+ * Sigh.  This sort of thing is always nasty do deal with.  Note that
+ * the version here does not include floating point...
+ *
+ * snprintf() is used instead of sprintf() as it does limit checks
+ * for string length.  This covers a nasty loophole.
+ *
+ * The other functions are there to prevent NULL pointers from
+ * causing nast effects.
+ *
+ * More Recently:
+ *  Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
+ *  This was ugly.  It is still ugly.  I opted out of floating point
+ *  numbers, but the formatter understands just about everything
+ *  from the normal C string format, at least as far as I can tell from
+ *  the Solaris 2.5 printf(3S) man page.
+ *
+ *  Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
+ *    Ok, added some minimal floating point support, which means this
+ *    probably requires libm on most operating systems.  Don't yet
+ *    support the exponent (e,E) and sigfig (g,G).  Also, fmtint()
+ *    was pretty badly broken, it just wasn't being exercised in ways
+ *    which showed it, so that's been fixed.  Also, formated the code
+ *    to mutt conventions, and removed dead code left over from the
+ *    original.  Also, there is now a builtin-test, just compile with:
+ *           gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
+ *    and run snprintf for results.
+ * 
+ *  Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
+ *    The PGP code was using unsigned hexadecimal formats. 
+ *    Unfortunately, unsigned formats simply didn't work.
+ *
+ *  Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
+ *    The original code assumed that both snprintf() and vsnprintf() were
+ *    missing.  Some systems only have snprintf() but not vsnprintf(), so
+ *    the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
+ *
+ *  Andrew Tridgell (tridge@samba.org) Oct 1998
+ *    fixed handling of %.0f
+ *    added test for HAVE_LONG_DOUBLE
+ *
+ **************************************************************/
+
+#include "config.h"
+
+#include <string.h>
+# include <ctype.h>
+#include <sys/types.h>
+
+#if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF)
+
+/* Define this as a fall through, HAVE_STDARG_H is probably already set */
+
+#define HAVE_VARARGS_H
+
+/* varargs declarations: */
+
+#if defined(HAVE_STDARG_H)
+# include <stdarg.h>
+# define HAVE_STDARGS    /* let's hope that works everywhere (mj) */
+# define VA_LOCAL_DECL   va_list ap
+# define VA_START(f)     va_start(ap, f)
+# define VA_SHIFT(v,t)  ;   /* no-op for ANSI */
+# define VA_END          va_end(ap)
+#else
+# if defined(HAVE_VARARGS_H)
+#  include <varargs.h>
+#  undef HAVE_STDARGS
+#  define VA_LOCAL_DECL   va_list ap
+#  define VA_START(f)     va_start(ap)      /* f is ignored! */
+#  define VA_SHIFT(v,t) v = va_arg(ap,t)
+#  define VA_END        va_end(ap)
+# else
+/*XX ** NO VARARGS ** XX*/
+# endif
+#endif
+
+#ifdef HAVE_LONG_DOUBLE
+#define LDOUBLE long double
+#else
+#define LDOUBLE double
+#endif
+
+/*int snprintf (char *str, size_t count, const char *fmt, ...);*/
+/*int vsnprintf (char *str, size_t count, const char *fmt, va_list arg);*/
+
+static void dopr (char *buffer, size_t maxlen, const char *format, 
+                  va_list args);
+static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
+		    char *value, int flags, int min, int max);
+static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
+		    long value, int base, int min, int max, int flags);
+static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
+		   LDOUBLE fvalue, int min, int max, int flags);
+static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c );
+
+/*
+ * dopr(): poor man's version of doprintf
+ */
+
+/* format read states */
+#define DP_S_DEFAULT 0
+#define DP_S_FLAGS   1
+#define DP_S_MIN     2
+#define DP_S_DOT     3
+#define DP_S_MAX     4
+#define DP_S_MOD     5
+#define DP_S_CONV    6
+#define DP_S_DONE    7
+
+/* format flags - Bits */
+#define DP_F_MINUS 	(1 << 0)
+#define DP_F_PLUS  	(1 << 1)
+#define DP_F_SPACE 	(1 << 2)
+#define DP_F_NUM   	(1 << 3)
+#define DP_F_ZERO  	(1 << 4)
+#define DP_F_UP    	(1 << 5)
+#define DP_F_UNSIGNED 	(1 << 6)
+
+/* Conversion Flags */
+#define DP_C_SHORT   1
+#define DP_C_LONG    2
+#define DP_C_LDOUBLE 3
+
+#define char_to_int(p) (p - '0')
+#define MAX(p,q) ((p >= q) ? p : q)
+
+static void dopr (char *buffer, size_t maxlen, const char *format, va_list args)
+{
+  char ch;
+  long value;
+  LDOUBLE fvalue;
+  char *strvalue;
+  int min;
+  int max;
+  int state;
+  int flags;
+  int cflags;
+  size_t currlen;
+  
+  state = DP_S_DEFAULT;
+  currlen = flags = cflags = min = 0;
+  max = -1;
+  ch = *format++;
+
+  while (state != DP_S_DONE)
+  {
+    if ((ch == '\0') || (currlen >= maxlen)) 
+      state = DP_S_DONE;
+
+    switch(state) 
+    {
+    case DP_S_DEFAULT:
+      if (ch == '%') 
+	state = DP_S_FLAGS;
+      else 
+	dopr_outch (buffer, &currlen, maxlen, ch);
+      ch = *format++;
+      break;
+    case DP_S_FLAGS:
+      switch (ch) 
+      {
+      case '-':
+	flags |= DP_F_MINUS;
+        ch = *format++;
+	break;
+      case '+':
+	flags |= DP_F_PLUS;
+        ch = *format++;
+	break;
+      case ' ':
+	flags |= DP_F_SPACE;
+        ch = *format++;
+	break;
+      case '#':
+	flags |= DP_F_NUM;
+        ch = *format++;
+	break;
+      case '0':
+	flags |= DP_F_ZERO;
+        ch = *format++;
+	break;
+      default:
+	state = DP_S_MIN;
+	break;
+      }
+      break;
+    case DP_S_MIN:
+      if (isdigit((unsigned char)ch)) 
+      {
+	min = 10*min + char_to_int (ch);
+	ch = *format++;
+      } 
+      else if (ch == '*') 
+      {
+	min = va_arg (args, int);
+	ch = *format++;
+	state = DP_S_DOT;
+      } 
+      else 
+	state = DP_S_DOT;
+      break;
+    case DP_S_DOT:
+      if (ch == '.') 
+      {
+	state = DP_S_MAX;
+	ch = *format++;
+      } 
+      else 
+	state = DP_S_MOD;
+      break;
+    case DP_S_MAX:
+      if (isdigit((unsigned char)ch)) 
+      {
+	if (max < 0)
+	  max = 0;
+	max = 10*max + char_to_int (ch);
+	ch = *format++;
+      } 
+      else if (ch == '*') 
+      {
+	max = va_arg (args, int);
+	ch = *format++;
+	state = DP_S_MOD;
+      } 
+      else 
+	state = DP_S_MOD;
+      break;
+    case DP_S_MOD:
+      /* Currently, we don't support Long Long, bummer */
+      switch (ch) 
+      {
+      case 'h':
+	cflags = DP_C_SHORT;
+	ch = *format++;
+	break;
+      case 'l':
+	cflags = DP_C_LONG;
+	ch = *format++;
+	break;
+      case 'L':
+	cflags = DP_C_LDOUBLE;
+	ch = *format++;
+	break;
+      default:
+	break;
+      }
+      state = DP_S_CONV;
+      break;
+    case DP_S_CONV:
+      switch (ch) 
+      {
+      case 'd':
+      case 'i':
+	if (cflags == DP_C_SHORT) 
+	  value = va_arg (args, short int);
+	else if (cflags == DP_C_LONG)
+	  value = va_arg (args, long int);
+	else
+	  value = va_arg (args, int);
+	fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
+	break;
+      case 'o':
+	flags |= DP_F_UNSIGNED;
+	if (cflags == DP_C_SHORT)
+	  value = va_arg (args, unsigned short int);
+	else if (cflags == DP_C_LONG)
+	  value = (long)va_arg (args, unsigned long int);
+	else
+	  value = (long)va_arg (args, unsigned int);
+	fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
+	break;
+      case 'u':
+	flags |= DP_F_UNSIGNED;
+	if (cflags == DP_C_SHORT)
+	  value = va_arg (args, unsigned short int);
+	else if (cflags == DP_C_LONG)
+	  value = (long)va_arg (args, unsigned long int);
+	else
+	  value = (long)va_arg (args, unsigned int);
+	fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
+	break;
+      case 'X':
+	flags |= DP_F_UP;
+      case 'x':
+	flags |= DP_F_UNSIGNED;
+	if (cflags == DP_C_SHORT)
+	  value = va_arg (args, unsigned short int);
+	else if (cflags == DP_C_LONG)
+	  value = (long)va_arg (args, unsigned long int);
+	else
+	  value = (long)va_arg (args, unsigned int);
+	fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
+	break;
+      case 'f':
+	if (cflags == DP_C_LDOUBLE)
+	  fvalue = va_arg (args, LDOUBLE);
+	else
+	  fvalue = va_arg (args, double);
+	/* um, floating point? */
+	fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
+	break;
+      case 'E':
+	flags |= DP_F_UP;
+      case 'e':
+	if (cflags == DP_C_LDOUBLE)
+	  fvalue = va_arg (args, LDOUBLE);
+	else
+	  fvalue = va_arg (args, double);
+	break;
+      case 'G':
+	flags |= DP_F_UP;
+      case 'g':
+	if (cflags == DP_C_LDOUBLE)
+	  fvalue = va_arg (args, LDOUBLE);
+	else
+	  fvalue = va_arg (args, double);
+	break;
+      case 'c':
+	dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
+	break;
+      case 's':
+	strvalue = va_arg (args, char *);
+	if (max < 0) 
+	  max = maxlen; /* ie, no max */
+	fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
+	break;
+      case 'p':
+	strvalue = va_arg (args, void *);
+	fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
+	break;
+      case 'n':
+	if (cflags == DP_C_SHORT) 
+	{
+	  short int *num;
+	  num = va_arg (args, short int *);
+	  *num = currlen;
+        } 
+	else if (cflags == DP_C_LONG) 
+	{
+	  long int *num;
+	  num = va_arg (args, long int *);
+	  *num = (long int)currlen;
+        } 
+	else 
+	{
+	  int *num;
+	  num = va_arg (args, int *);
+	  *num = currlen;
+        }
+	break;
+      case '%':
+	dopr_outch (buffer, &currlen, maxlen, ch);
+	break;
+      case 'w':
+	/* not supported yet, treat as next char */
+	ch = *format++;
+	break;
+      default:
+	/* Unknown, skip */
+	break;
+      }
+      ch = *format++;
+      state = DP_S_DEFAULT;
+      flags = cflags = min = 0;
+      max = -1;
+      break;
+    case DP_S_DONE:
+      break;
+    default:
+      /* hmm? */
+      break; /* some picky compilers need this */
+    }
+  }
+  if (currlen < maxlen - 1) 
+    buffer[currlen] = '\0';
+  else 
+    buffer[maxlen - 1] = '\0';
+}
+
+static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
+		    char *value, int flags, int min, int max)
+{
+  int padlen, strln;     /* amount to pad */
+  int cnt = 0;
+  
+  if (value == 0)
+  {
+    value = "<NULL>";
+  }
+
+  for (strln = 0; value[strln]; ++strln); /* strlen */
+  padlen = min - strln;
+  if (padlen < 0) 
+    padlen = 0;
+  if (flags & DP_F_MINUS) 
+    padlen = -padlen; /* Left Justify */
+
+  while ((padlen > 0) && (cnt < max)) 
+  {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    --padlen;
+    ++cnt;
+  }
+  while (*value && (cnt < max)) 
+  {
+    dopr_outch (buffer, currlen, maxlen, *value++);
+    ++cnt;
+  }
+  while ((padlen < 0) && (cnt < max)) 
+  {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    ++padlen;
+    ++cnt;
+  }
+}
+
+/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
+
+static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
+		    long value, int base, int min, int max, int flags)
+{
+  int signvalue = 0;
+  unsigned long uvalue;
+  char convert[20];
+  int place = 0;
+  int spadlen = 0; /* amount to space pad */
+  int zpadlen = 0; /* amount to zero pad */
+  int caps = 0;
+  
+  if (max < 0)
+    max = 0;
+
+  uvalue = value;
+
+  if(!(flags & DP_F_UNSIGNED))
+  {
+    if( value < 0 ) {
+      signvalue = '-';
+      uvalue = -value;
+    }
+    else
+      if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
+	signvalue = '+';
+    else
+      if (flags & DP_F_SPACE)
+	signvalue = ' ';
+  }
+  
+  if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
+
+  do {
+    convert[place++] =
+      (caps? "0123456789ABCDEF":"0123456789abcdef")
+      [uvalue % (unsigned)base  ];
+    uvalue = (uvalue / (unsigned)base );
+  } while(uvalue && (place < 20));
+  if (place == 20) place--;
+  convert[place] = 0;
+
+  zpadlen = max - place;
+  spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
+  if (zpadlen < 0) zpadlen = 0;
+  if (spadlen < 0) spadlen = 0;
+  if (flags & DP_F_ZERO)
+  {
+    zpadlen = MAX(zpadlen, spadlen);
+    spadlen = 0;
+  }
+  if (flags & DP_F_MINUS) 
+    spadlen = -spadlen; /* Left Justifty */
+
+#ifdef DEBUG_SNPRINTF
+  printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
+	 zpadlen, spadlen, min, max, place);
+#endif
+
+  /* Spaces */
+  while (spadlen > 0) 
+  {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    --spadlen;
+  }
+
+  /* Sign */
+  if (signvalue) 
+    dopr_outch (buffer, currlen, maxlen, signvalue);
+
+  /* Zeros */
+  if (zpadlen > 0) 
+  {
+    while (zpadlen > 0)
+    {
+      dopr_outch (buffer, currlen, maxlen, '0');
+      --zpadlen;
+    }
+  }
+
+  /* Digits */
+  while (place > 0) 
+    dopr_outch (buffer, currlen, maxlen, convert[--place]);
+  
+  /* Left Justified spaces */
+  while (spadlen < 0) {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    ++spadlen;
+  }
+}
+
+static LDOUBLE abs_val (LDOUBLE value)
+{
+  LDOUBLE result = value;
+
+  if (value < 0)
+    result = -value;
+
+  return result;
+}
+
+static LDOUBLE pow10 (int exp)
+{
+  LDOUBLE result = 1;
+
+  while (exp)
+  {
+    result *= 10;
+    exp--;
+  }
+  
+  return result;
+}
+
+static long round (LDOUBLE value)
+{
+  long intpart;
+
+  intpart = (long)value;
+  value = value - intpart;
+  if (value >= 0.5)
+    intpart++;
+
+  return intpart;
+}
+
+static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
+		   LDOUBLE fvalue, int min, int max, int flags)
+{
+  int signvalue = 0;
+  LDOUBLE ufvalue;
+  char iconvert[20];
+  char fconvert[20];
+  int iplace = 0;
+  int fplace = 0;
+  int padlen = 0; /* amount to pad */
+  int zpadlen = 0; 
+  int caps = 0;
+  long intpart;
+  long fracpart;
+  
+  /* 
+   * AIX manpage says the default is 0, but Solaris says the default
+   * is 6, and sprintf on AIX defaults to 6
+   */
+  if (max < 0)
+    max = 6;
+
+  ufvalue = abs_val (fvalue);
+
+  if (fvalue < 0)
+    signvalue = '-';
+  else
+    if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
+      signvalue = '+';
+    else
+      if (flags & DP_F_SPACE)
+	signvalue = ' ';
+
+#if 0
+  if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
+#endif
+
+  intpart = (long)ufvalue;
+
+  /* 
+   * Sorry, we only support 9 digits past the decimal because of our 
+   * conversion method
+   */
+  if (max > 9)
+    max = 9;
+
+  /* We "cheat" by converting the fractional part to integer by
+   * multiplying by a factor of 10
+   */
+  fracpart = round ((pow10 (max)) * (ufvalue - intpart));
+
+  if (fracpart >= pow10 (max))
+  {
+    intpart++;
+    fracpart -= pow10 (max);
+  }
+
+#ifdef DEBUG_SNPRINTF
+  printf("fmtfp: %g %d.%d min=%d max=%d\n", 
+	 (double)fvalue, intpart, fracpart, min, max);
+#endif
+
+  /* Convert integer part */
+  do {
+    iconvert[iplace++] =
+      (caps? "0123456789ABCDEF":"0123456789abcdef")[intpart % 10];
+    intpart = (intpart / 10);
+  } while(intpart && (iplace < 20));
+  if (iplace == 20) iplace--;
+  iconvert[iplace] = 0;
+
+  /* Convert fractional part */
+  do {
+    fconvert[fplace++] =
+      (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10];
+    fracpart = (fracpart / 10);
+  } while(fracpart && (fplace < 20));
+  if (fplace == 20) fplace--;
+  fconvert[fplace] = 0;
+
+  /* -1 for decimal point, another -1 if we are printing a sign */
+  padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 
+  zpadlen = max - fplace;
+  if (zpadlen < 0)
+    zpadlen = 0;
+  if (padlen < 0) 
+    padlen = 0;
+  if (flags & DP_F_MINUS) 
+    padlen = -padlen; /* Left Justifty */
+
+  if ((flags & DP_F_ZERO) && (padlen > 0)) 
+  {
+    if (signvalue) 
+    {
+      dopr_outch (buffer, currlen, maxlen, signvalue);
+      --padlen;
+      signvalue = 0;
+    }
+    while (padlen > 0)
+    {
+      dopr_outch (buffer, currlen, maxlen, '0');
+      --padlen;
+    }
+  }
+  while (padlen > 0)
+  {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    --padlen;
+  }
+  if (signvalue) 
+    dopr_outch (buffer, currlen, maxlen, signvalue);
+
+  while (iplace > 0) 
+    dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
+
+
+#ifdef DEBUG_SNPRINTF
+  printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
+#endif
+
+  /*
+   * Decimal point.  This should probably use locale to find the correct
+   * char to print out.
+   */
+  if (max > 0) {
+	  dopr_outch (buffer, currlen, maxlen, '.');
+
+	  while (fplace > 0) 
+		  dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
+  }
+
+  while (zpadlen > 0)
+  {
+    dopr_outch (buffer, currlen, maxlen, '0');
+    --zpadlen;
+  }
+
+  while (padlen < 0) 
+  {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    ++padlen;
+  }
+}
+
+static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c)
+{
+  if (*currlen < maxlen)
+    buffer[(*currlen)++] = c;
+}
+#endif /* !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) */
+
+#ifndef HAVE_VSNPRINTF
+ int vsnprintf (char *str, size_t count, const char *fmt, va_list args)
+{
+  str[0] = 0;
+  dopr(str, count, fmt, args);
+  return(strlen(str));
+}
+#endif /* !HAVE_VSNPRINTF */
+
+#ifndef HAVE_SNPRINTF
+/* VARARGS3 */
+#ifdef HAVE_STDARGS
+ int snprintf (char *str,size_t count,const char *fmt,...)
+#else
+ int snprintf (va_alist) va_dcl
+#endif
+{
+#ifndef HAVE_STDARGS
+  char *str;
+  size_t count;
+  char *fmt;
+#endif
+  VA_LOCAL_DECL;
+    
+  VA_START (fmt);
+  VA_SHIFT (str, char *);
+  VA_SHIFT (count, size_t );
+  VA_SHIFT (fmt, char *);
+  (void) vsnprintf(str, count, fmt, ap);
+  VA_END;
+  return(strlen(str));
+}
+
+
+#else
+ /* keep compilers happy about empty files */
+ void dummy_snprintf(void) {}
+#endif /* !HAVE_SNPRINTF */
+
+#ifdef TEST_SNPRINTF
+#ifndef LONG_STRING
+#define LONG_STRING 1024
+#endif
+ int main (void)
+{
+  char buf1[LONG_STRING];
+  char buf2[LONG_STRING];
+  char *fp_fmt[] = {
+    "%-1.5f",
+    "%1.5f",
+    "%123.9f",
+    "%10.5f",
+    "% 10.5f",
+    "%+22.9f",
+    "%+4.9f",
+    "%01.3f",
+    "%4f",
+    "%3.1f",
+    "%3.2f",
+    "%.0f",
+    "%.1f",
+    NULL
+  };
+  double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, 
+    0.9996, 1.996, 4.136, 0};
+  char *int_fmt[] = {
+    "%-1.5d",
+    "%1.5d",
+    "%123.9d",
+    "%5.5d",
+    "%10.5d",
+    "% 10.5d",
+    "%+22.33d",
+    "%01.3d",
+    "%4d",
+    NULL
+  };
+  long int_nums[] = { -1, 134, 91340, 341, 0203, 0};
+  int x, y;
+  int fail = 0;
+  int num = 0;
+
+  printf ("Testing snprintf format codes against system sprintf...\n");
+
+  for (x = 0; fp_fmt[x] != NULL ; x++)
+    for (y = 0; fp_nums[y] != 0 ; y++)
+    {
+      snprintf (buf1, sizeof (buf1), fp_fmt[x], fp_nums[y]);
+      sprintf (buf2, fp_fmt[x], fp_nums[y]);
+      if (strcmp (buf1, buf2))
+      {
+	printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf  = %s\n", 
+	    fp_fmt[x], buf1, buf2);
+	fail++;
+      }
+      num++;
+    }
+
+  for (x = 0; int_fmt[x] != NULL ; x++)
+    for (y = 0; int_nums[y] != 0 ; y++)
+    {
+      snprintf (buf1, sizeof (buf1), int_fmt[x], int_nums[y]);
+      sprintf (buf2, int_fmt[x], int_nums[y]);
+      if (strcmp (buf1, buf2))
+      {
+	printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf  = %s\n", 
+	    int_fmt[x], buf1, buf2);
+	fail++;
+      }
+      num++;
+    }
+  printf ("%d tests failed out of %d.\n", fail, num);
+}
+#endif /* SNPRINTF_TEST */
+

lib/zlib.h

@@ -1,632 +0,0 @@
-/*	$Id$	*/
-
-/*
- * This file is derived from zlib.h and zconf.h from the zlib-0.95
- * distribution by Jean-loup Gailly and Mark Adler, with some additions
- * by Paul Mackerras to aid in implementing Deflate compression and
- * decompression for PPP packets.
- */
-
-/* zlib.h -- interface of the 'zlib' general purpose compression library
-  version 0.95, Aug 16th, 1995.
-
-  Copyright (C) 1995 Jean-loup Gailly and Mark Adler
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  Jean-loup Gailly        Mark Adler
-  gzip@prep.ai.mit.edu    madler@alumni.caltech.edu
- */
-
-#ifndef _ZLIB_H
-#define _ZLIB_H
-
-/* #include "zconf.h" */	/* included directly here */
-
-/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h 
- */
-
-/* From: zconf.h,v 1.12 1995/05/03 17:27:12 jloup Exp */
-
-/*
-     The library does not install any signal handler. It is recommended to
-  add at least a handler for SIGSEGV when decompressing; the library checks
-  the consistency of the input data whenever possible but may go nuts
-  for some forms of corrupted input.
- */
-
-/*
- * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
- * than 64k bytes at a time (needed on systems with 16-bit int).
- * Compile with -DUNALIGNED_OK if it is OK to access shorts or ints
- * at addresses which are not a multiple of their size.
- * Under DOS, -DFAR=far or -DFAR=__far may be needed.
- */
-
-#ifndef STDC
-#  if defined(MSDOS) || defined(__STDC__) || defined(__cplusplus)
-#    define STDC
-#  endif
-#endif
-
-#ifdef	__MWERKS__ /* Metrowerks CodeWarrior declares fileno() in unix.h */
-#  include <unix.h>
-#endif
-
-/* Maximum value for memLevel in deflateInit2 */
-#ifndef MAX_MEM_LEVEL
-#  ifdef MAXSEG_64K
-#    define MAX_MEM_LEVEL 8
-#  else
-#    define MAX_MEM_LEVEL 9
-#  endif
-#endif
-
-#ifndef FAR
-#  define FAR
-#endif
-
-/* Maximum value for windowBits in deflateInit2 and inflateInit2 */
-#ifndef MAX_WBITS
-#  define MAX_WBITS   15 /* 32K LZ77 window */
-#endif
-
-/* The memory requirements for deflate are (in bytes):
-            1 << (windowBits+2)   +  1 << (memLevel+9)
- that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
- plus a few kilobytes for small objects. For example, if you want to reduce
- the default memory requirements from 256K to 128K, compile with
-     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
- Of course this will generally degrade compression (there's no free lunch).
-
-   The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
- for small objects.
-*/
-
-                        /* Type declarations */
-
-#ifndef OF /* function prototypes */
-#  ifdef STDC
-#    define OF(args)  args
-#  else
-#    define OF(args)  ()
-#  endif
-#endif
-
-typedef unsigned char  Byte;  /* 8 bits */
-typedef unsigned int   uInt;  /* 16 bits or more */
-typedef int32 Long; /* 32 bits or more */
-typedef uint32 uLong; /* 32 bits or more */
-
-typedef Byte FAR Bytef;
-typedef char FAR charf;
-typedef int FAR intf;
-typedef uInt FAR uIntf;
-typedef uLong FAR uLongf;
-
-#ifdef STDC
-   typedef void FAR *voidpf;
-   typedef void     *voidp;
-#else
-   typedef Byte FAR *voidpf;
-   typedef Byte     *voidp;
-#endif
-
-/* end of original zconf.h */
-
-#define ZLIB_VERSION "0.95P"
-
-/* 
-     The 'zlib' compression library provides in-memory compression and
-  decompression functions, including integrity checks of the uncompressed
-  data.  This version of the library supports only one compression method
-  (deflation) but other algorithms may be added later and will have the same
-  stream interface.
-
-     For compression the application must provide the output buffer and
-  may optionally provide the input buffer for optimization. For decompression,
-  the application must provide the input buffer and may optionally provide
-  the output buffer for optimization.
-
-     Compression can be done in a single step if the buffers are large
-  enough (for example if an input file is mmap'ed), or can be done by
-  repeated calls of the compression function.  In the latter case, the
-  application must provide more input and/or consume the output
-  (providing more output space) before each call.
-*/
-
-typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
-typedef void   (*free_func)  OF((voidpf opaque, voidpf address, uInt nbytes));
-
-struct internal_state;
-
-typedef struct z_stream_s {
-    Bytef    *next_in;  /* next input byte */
-    uInt     avail_in;  /* number of bytes available at next_in */
-    uLong    total_in;  /* total nb of input bytes read so far */
-
-    Bytef    *next_out; /* next output byte should be put there */
-    uInt     avail_out; /* remaining free space at next_out */
-    uLong    total_out; /* total nb of bytes output so far */
-
-    char     *msg;      /* last error message, NULL if no error */
-    struct internal_state FAR *state; /* not visible by applications */
-
-    alloc_func zalloc;  /* used to allocate the internal state */
-    free_func  zfree;   /* used to free the internal state */
-    voidp      opaque;  /* private data object passed to zalloc and zfree */
-
-    Byte     data_type; /* best guess about the data type: ascii or binary */
-
-} z_stream;
-
-/*
-   The application must update next_in and avail_in when avail_in has
-   dropped to zero. It must update next_out and avail_out when avail_out
-   has dropped to zero. The application must initialize zalloc, zfree and
-   opaque before calling the init function. All other fields are set by the
-   compression library and must not be updated by the application.
-
-   The opaque value provided by the application will be passed as the first
-   parameter for calls of zalloc and zfree. This can be useful for custom
-   memory management. The compression library attaches no meaning to the
-   opaque value.
-
-   zalloc must return Z_NULL if there is not enough memory for the object.
-   On 16-bit systems, the functions zalloc and zfree must be able to allocate
-   exactly 65536 bytes, but will not be required to allocate more than this
-   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
-   pointers returned by zalloc for objects of exactly 65536 bytes *must*
-   have their offset normalized to zero. The default allocation function
-   provided by this library ensures this (see zutil.c). To reduce memory
-   requirements and avoid any allocation of 64K objects, at the expense of
-   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
-
-   The fields total_in and total_out can be used for statistics or
-   progress reports. After compression, total_in holds the total size of
-   the uncompressed data and may be saved for use in the decompressor
-   (particularly if the decompressor wants to decompress everything in
-   a single step).
-*/
-
-                        /* constants */
-
-#define Z_NO_FLUSH      0
-#define Z_PARTIAL_FLUSH 1
-#define Z_FULL_FLUSH    2
-#define Z_SYNC_FLUSH    3 /* experimental: partial_flush + byte align */
-#define Z_FINISH        4
-#define Z_PACKET_FLUSH	5
-#define Z_INSERT_ONLY	6 /* update hash table etc., produce no output */
-/* See deflate() below for the usage of these constants */
-
-#define Z_OK            0
-#define Z_STREAM_END    1
-#define Z_ERRNO        (-1)
-#define Z_STREAM_ERROR (-2)
-#define Z_DATA_ERROR   (-3)
-#define Z_MEM_ERROR    (-4)
-#define Z_BUF_ERROR    (-5)
-/* error codes for the compression/decompression functions */
-
-#define Z_BEST_SPEED             1
-#define Z_BEST_COMPRESSION       9
-#define Z_DEFAULT_COMPRESSION  (-1)
-/* compression levels */
-
-#define Z_FILTERED            1
-#define Z_HUFFMAN_ONLY        2
-#define Z_DEFAULT_STRATEGY    0
-
-#define Z_BINARY   0
-#define Z_ASCII    1
-#define Z_UNKNOWN  2
-/* Used to set the data_type field */
-
-#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
-
-extern char *zlib_version;
-/* The application can compare zlib_version and ZLIB_VERSION for consistency.
-   If the first character differs, the library code actually used is
-   not compatible with the zlib.h header file used by the application.
- */
-
-                        /* basic functions */
-
-extern int deflateInit OF((z_stream *strm, int level));
-/* 
-     Initializes the internal stream state for compression. The fields
-   zalloc, zfree and opaque must be initialized before by the caller.
-   If zalloc and zfree are set to Z_NULL, deflateInit updates them to
-   use default allocation functions.
-
-     The compression level must be Z_DEFAULT_COMPRESSION, or between 1 and 9:
-   1 gives best speed, 9 gives best compression. Z_DEFAULT_COMPRESSION requests
-   a default compromise between speed and compression (currently equivalent
-   to level 6).
-
-     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_STREAM_ERROR if level is not a valid compression level.
-   msg is set to null if there is no error message.  deflateInit does not
-   perform any compression: this will be done by deflate().
-*/
-
-
-extern int deflate OF((z_stream *strm, int flush));
-/*
-  Performs one or both of the following actions:
-
-  - Compress more input starting at next_in and update next_in and avail_in
-    accordingly. If not all input can be processed (because there is not
-    enough room in the output buffer), next_in and avail_in are updated and
-    processing will resume at this point for the next call of deflate().
-
-  - Provide more output starting at next_out and update next_out and avail_out
-    accordingly. This action is forced if the parameter flush is non zero.
-    Forcing flush frequently degrades the compression ratio, so this parameter
-    should be set only when necessary (in interactive applications).
-    Some output may be provided even if flush is not set.
-
-  Before the call of deflate(), the application should ensure that at least
-  one of the actions is possible, by providing more input and/or consuming
-  more output, and updating avail_in or avail_out accordingly; avail_out
-  should never be zero before the call. The application can consume the
-  compressed output when it wants, for example when the output buffer is full
-  (avail_out == 0), or after each call of deflate().
-
-    If the parameter flush is set to Z_PARTIAL_FLUSH, the current compression
-  block is terminated and flushed to the output buffer so that the
-  decompressor can get all input data available so far. For method 9, a future
-  variant on method 8, the current block will be flushed but not terminated.
-  If flush is set to Z_FULL_FLUSH, the compression block is terminated, a
-  special marker is output and the compression dictionary is discarded; this
-  is useful to allow the decompressor to synchronize if one compressed block
-  has been damaged (see inflateSync below).  Flushing degrades compression and
-  so should be used only when necessary.  Using Z_FULL_FLUSH too often can
-  seriously degrade the compression. If deflate returns with avail_out == 0,
-  this function must be called again with the same value of the flush
-  parameter and more output space (updated avail_out), until the flush is
-  complete (deflate returns with non-zero avail_out).
-
-    If the parameter flush is set to Z_PACKET_FLUSH, the compression
-  block is terminated, and a zero-length stored block is output,
-  omitting the length bytes (the effect of this is that the 3-bit type
-  code 000 for a stored block is output, and the output is then
-  byte-aligned).  This is designed for use at the end of a PPP packet.
-  In addition, if the current compression block contains all the data
-  since the last Z_PACKET_FLUSH, it is never output as a stored block.
-  If the current compression block output as a static or dynamic block
-  would not be at least `minCompression' bytes smaller than the
-  original data, then nothing is output for that block.  (The type
-  code for the zero-length stored block is still output, resulting in
-  a single zero byte being output for the whole packet.)
-  `MinCompression' is a parameter to deflateInit2, or 0 if deflateInit
-  is used.
-
-    If the parameter flush is set to Z_FINISH, all pending input is processed,
-  all pending output is flushed and deflate returns with Z_STREAM_END if there
-  was enough output space; if deflate returns with Z_OK, this function must be
-  called again with Z_FINISH and more output space (updated avail_out) but no
-  more input data, until it returns with Z_STREAM_END or an error. After
-  deflate has returned Z_STREAM_END, the only possible operations on the
-  stream are deflateReset or deflateEnd.
-  
-    Z_FINISH can be used immediately after deflateInit if all the compression
-  is to be done in a single step. In this case, avail_out must be at least
-  0.1% larger than avail_in plus 12 bytes.  If deflate does not return
-  Z_STREAM_END, then it must be called again as described above.
-
-    deflate() may update data_type if it can make a good guess about
-  the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
-  binary. This field is only for information purposes and does not affect
-  the compression algorithm in any manner.
-
-    deflate() returns Z_OK if some progress has been made (more input
-  processed or more output produced), Z_STREAM_END if all input has been
-  consumed and all output has been produced (only when flush is set to
-  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
-  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible.
-*/
-
-
-extern int deflateEnd OF((z_stream *strm));
-/*
-     All dynamically allocated data structures for this stream are freed.
-   This function discards any unprocessed input and does not flush any
-   pending output.
-
-     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
-   stream state was inconsistent. In the error case, msg may be set
-   but then points to a static string (which must not be deallocated).
-*/
-
-
-extern int inflateInit OF((z_stream *strm));
-/* 
-     Initializes the internal stream state for decompression. The fields
-   zalloc and zfree must be initialized before by the caller.  If zalloc and
-   zfree are set to Z_NULL, inflateInit updates them to use default allocation
-   functions.
-
-     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory.  msg is set to null if there is no error message.
-   inflateInit does not perform any decompression: this will be done by
-   inflate().
-*/
-
-
-extern int inflate OF((z_stream *strm, int flush));
-/*
-  Performs one or both of the following actions:
-
-  - Decompress more input starting at next_in and update next_in and avail_in
-    accordingly. If not all input can be processed (because there is not
-    enough room in the output buffer), next_in is updated and processing
-    will resume at this point for the next call of inflate().
-
-  - Provide more output starting at next_out and update next_out and avail_out
-    accordingly.  inflate() always provides as much output as possible
-    (until there is no more input data or no more space in the output buffer).
-
-  Before the call of inflate(), the application should ensure that at least
-  one of the actions is possible, by providing more input and/or consuming
-  more output, and updating the next_* and avail_* values accordingly.
-  The application can consume the uncompressed output when it wants, for
-  example when the output buffer is full (avail_out == 0), or after each
-  call of inflate().
-
-    If the parameter flush is set to Z_PARTIAL_FLUSH or Z_PACKET_FLUSH,
-  inflate flushes as much output as possible to the output buffer. The
-  flushing behavior of inflate is not specified for values of the flush
-  parameter other than Z_PARTIAL_FLUSH, Z_PACKET_FLUSH or Z_FINISH, but the
-  current implementation actually flushes as much output as possible
-  anyway.  For Z_PACKET_FLUSH, inflate checks that once all the input data
-  has been consumed, it is expecting to see the length field of a stored
-  block; if not, it returns Z_DATA_ERROR.
-
-    inflate() should normally be called until it returns Z_STREAM_END or an
-  error. However if all decompression is to be performed in a single step
-  (a single call of inflate), the parameter flush should be set to
-  Z_FINISH. In this case all pending input is processed and all pending
-  output is flushed; avail_out must be large enough to hold all the
-  uncompressed data. (The size of the uncompressed data may have been saved
-  by the compressor for this purpose.) The next operation on this stream must
-  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
-  is never required, but can be used to inform inflate that a faster routine
-  may be used for the single inflate() call.
-
-    inflate() returns Z_OK if some progress has been made (more input
-  processed or more output produced), Z_STREAM_END if the end of the
-  compressed data has been reached and all uncompressed output has been
-  produced, Z_DATA_ERROR if the input data was corrupted, Z_STREAM_ERROR if
-  the stream structure was inconsistent (for example if next_in or next_out
-  was NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no
-  progress is possible or if there was not enough room in the output buffer
-  when Z_FINISH is used. In the Z_DATA_ERROR case, the application may then
-  call inflateSync to look for a good compression block.  */
-
-
-extern int inflateEnd OF((z_stream *strm));
-/*
-     All dynamically allocated data structures for this stream are freed.
-   This function discards any unprocessed input and does not flush any
-   pending output.
-
-     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
-   was inconsistent. In the error case, msg may be set but then points to a
-   static string (which must not be deallocated).
-*/
-
-                        /* advanced functions */
-
-/*
-    The following functions are needed only in some special applications.
-*/
-
-extern int deflateInit2 OF((z_stream *strm,
-                            int  level,
-                            int  method,
-                            int  windowBits,
-                            int  memLevel,
-                            int  strategy));
-/*   
-     This is another version of deflateInit with more compression options. The
-   fields next_in, zalloc and zfree must be initialized before by the caller.
-
-     The method parameter is the compression method. It must be 8 in this
-   version of the library. (Method 9 will allow a 64K history buffer and
-   partial block flushes.)
-
-     The windowBits parameter is the base two logarithm of the window size
-   (the size of the history buffer).  It should be in the range 8..15 for this
-   version of the library (the value 16 will be allowed for method 9). Larger
-   values of this parameter result in better compression at the expense of
-   memory usage. The default value is 15 if deflateInit is used instead.
-
-    The memLevel parameter specifies how much memory should be allocated
-   for the internal compression state. memLevel=1 uses minimum memory but
-   is slow and reduces compression ratio; memLevel=9 uses maximum memory
-   for optimal speed. The default value is 8. See zconf.h for total memory
-   usage as a function of windowBits and memLevel.
-
-     The strategy parameter is used to tune the compression algorithm. Use
-   the value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data
-   produced by a filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman
-   encoding only (no string match).  Filtered data consists mostly of small
-   values with a somewhat random distribution. In this case, the
-   compression algorithm is tuned to compress them better. The strategy
-   parameter only affects the compression ratio but not the correctness of
-   the compressed output even if it is not set appropriately.
-
-     The minCompression parameter specifies the minimum reduction in size
-   required for a compressed block to be output when Z_PACKET_FLUSH is
-   used (see the description of deflate above).
-
-     If next_in is not null, the library will use this buffer to hold also
-   some history information; the buffer must either hold the entire input
-   data, or have at least 1<<(windowBits+1) bytes and be writable. If next_in
-   is null, the library will allocate its own history buffer (and leave next_in
-   null). next_out need not be provided here but must be provided by the
-   application for the next call of deflate().
-
-     If the history buffer is provided by the application, next_in must
-   must never be changed by the application since the compressor maintains
-   information inside this buffer from call to call; the application
-   must provide more input only by increasing avail_in. next_in is always
-   reset by the library in this case.
-
-      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
-   not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
-   an invalid method). msg is set to null if there is no error message.
-   deflateInit2 does not perform any compression: this will be done by
-   deflate().
-*/
-                            
-extern int deflateCopy OF((z_stream *dest,
-                           z_stream *source));
-/*
-     Sets the destination stream as a complete copy of the source stream.  If
-   the source stream is using an application-supplied history buffer, a new
-   buffer is allocated for the destination stream.  The compressed output
-   buffer is always application-supplied. It's the responsibility of the
-   application to provide the correct values of next_out and avail_out for the
-   next call of deflate.
-
-     This function is useful when several compression strategies will be
-   tried, for example when there are several ways of pre-processing the input
-   data with a filter. The streams that will be discarded should then be freed
-   by calling deflateEnd.  Note that deflateCopy duplicates the internal
-   compression state which can be quite large, so this strategy is slow and
-   can consume lots of memory.
-
-      deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
-   (such as zalloc being NULL). msg is left unchanged in both source and
-   destination.
-*/
-
-extern int deflateReset OF((z_stream *strm));
-/*
-     This function is equivalent to deflateEnd followed by deflateInit,
-   but does not free and reallocate all the internal compression state.
-   The stream will keep the same compression level and any other attributes
-   that may have been set by deflateInit2.
-
-      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent (such as zalloc or state being NULL).
-*/
-
-extern int inflateInit2 OF((z_stream *strm,
-                            int  windowBits));
-/*   
-     This is another version of inflateInit with more compression options. The
-   fields next_out, zalloc and zfree must be initialized before by the caller.
-
-     The windowBits parameter is the base two logarithm of the maximum window
-   size (the size of the history buffer).  It should be in the range 8..15 for
-   this version of the library (the value 16 will be allowed soon). The
-   default value is 15 if inflateInit is used instead. If a compressed stream
-   with a larger window size is given as input, inflate() will return with
-   the error code Z_DATA_ERROR instead of trying to allocate a larger window.
-
-     If next_out is not null, the library will use this buffer for the history
-   buffer; the buffer must either be large enough to hold the entire output
-   data, or have at least 1<<windowBits bytes.  If next_out is null, the
-   library will allocate its own buffer (and leave next_out null). next_in
-   need not be provided here but must be provided by the application for the
-   next call of inflate().
-
-     If the history buffer is provided by the application, next_out must
-   never be changed by the application since the decompressor maintains
-   history information inside this buffer from call to call; the application
-   can only reset next_out to the beginning of the history buffer when
-   avail_out is zero and all output has been consumed.
-
-      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
-   not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
-   windowBits < 8). msg is set to null if there is no error message.
-   inflateInit2 does not perform any decompression: this will be done by
-   inflate().
-*/
-
-extern int inflateSync OF((z_stream *strm));
-/* 
-    Skips invalid compressed data until the special marker (see deflate()
-  above) can be found, or until all available input is skipped. No output
-  is provided.
-
-    inflateSync returns Z_OK if the special marker has been found, Z_BUF_ERROR
-  if no more input was provided, Z_DATA_ERROR if no marker has been found,
-  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
-  case, the application may save the current current value of total_in which
-  indicates where valid compressed data was found. In the error case, the
-  application may repeatedly call inflateSync, providing more input each time,
-  until success or end of the input data.
-*/
-
-extern int inflateReset OF((z_stream *strm));
-/*
-     This function is equivalent to inflateEnd followed by inflateInit,
-   but does not free and reallocate all the internal decompression state.
-   The stream will keep attributes that may have been set by inflateInit2.
-
-      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent (such as zalloc or state being NULL).
-*/
-
-extern int inflateIncomp OF((z_stream *strm));
-/*
-     This function adds the data at next_in (avail_in bytes) to the output
-   history without performing any output.  There must be no pending output,
-   and the decompressor must be expecting to see the start of a block.
-   Calling this function is equivalent to decompressing a stored block
-   containing the data at next_in (except that the data is not output).
-*/
-
-                        /* checksum functions */
-
-/*
-     This function is not related to compression but is exported
-   anyway because it might be useful in applications using the
-   compression library.
-*/
-
-extern uLong adler32 OF((uLong adler, Bytef *buf, uInt len));
-
-/*
-     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
-   return the updated checksum. If buf is NULL, this function returns
-   the required initial value for the checksum.
-   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
-   much faster. Usage example:
-
-     uLong adler = adler32(0L, Z_NULL, 0);
-
-     while (read_buffer(buffer, length) != EOF) {
-       adler = adler32(adler, buffer, length);
-     }
-     if (adler != original_adler) error();
-*/
-
-#ifndef _Z_UTIL_H
-    struct internal_state {int dummy;}; /* hack for buggy compilers */
-#endif
-
-#endif /* _ZLIB_H */

loadparm.c

@@ -44,15 +44,11 @@
  */
 
 #include "rsync.h"
-#define BOOL int
-#define False 0
-#define True 1
-#define Realloc realloc
 #define PTR_DIFF(p1,p2) ((ptrdiff_t)(((char *)(p1)) - (char *)(p2)))
 #define strequal(a,b) (strcasecmp(a,b)==0)
 #define BOOLSTR(b) ((b) ? "Yes" : "No")
 typedef char pstring[1024];
-#define pstrcpy(a,b) strlcpy(a,b,sizeof(pstring)-1)
+#define pstrcpy(a,b) strlcpy(a,b,sizeof(pstring))
 
 /* the following are used by loadparm for option lists */
 typedef enum
@@ -98,9 +94,9 @@ static BOOL bLoaded = False;
 typedef struct
 {
 	char *motd_file;
-	char *lock_file;
+	char *log_file;
+	char *pid_file;
 	int syslog_facility;
-	int max_connections;
 	char *socket_options;
 } global;
 
@@ -116,16 +112,29 @@ typedef struct
 	char *name;
 	char *path;
 	char *comment;
+	char *lock_file;
 	BOOL read_only;
 	BOOL list;
+	BOOL use_chroot;
+	BOOL transfer_logging;
+	BOOL ignore_errors;
 	char *uid;
 	char *gid;
 	char *hosts_allow;
 	char *hosts_deny;
 	char *auth_users;
 	char *secrets_file;
+	BOOL strict_modes;
 	char *exclude;
 	char *exclude_from;
+	char *include;
+	char *include_from;
+	char *log_format;
+	char *refuse_options;
+	char *dont_compress;
+	int timeout;
+	int max_connections;
+	BOOL ignore_nonreadable;
 } service;
 
 
@@ -135,16 +144,29 @@ static service sDefault =
 	NULL,    /* name */
 	NULL,    /* path */
 	NULL,    /* comment */
+	DEFAULT_LOCK_FILE,    /* lock file */
 	True,    /* read only */
 	True,    /* list */
+	True,    /* use chroot */
+	False,   /* transfer logging */
+	False,   /* ignore errors */
 	"nobody",/* uid */
 	"nobody",/* gid */
 	NULL,    /* hosts allow */
 	NULL,    /* hosts deny */
 	NULL,    /* auth users */
 	NULL,    /* secrets file */
+	True,   /* strict modes */
 	NULL,    /* exclude */
 	NULL,    /* exclude from */
+	NULL,    /* include */
+	NULL,    /* include from */
+	"%o %h [%a] %m (%u) %f %l",    /* log format */
+	NULL,    /* refuse options */
+	"*.gz *.tgz *.zip *.z *.rpm *.deb *.iso *.bz2 *.tbz",    /* dont compress */
+	0,        /* timeout */
+	0,        /* max connections */
+	False     /* ignore nonreadable */
 };
 
 
@@ -227,25 +249,38 @@ static struct enum_list enum_facilities[] = {
 /* note that we do not initialise the defaults union - it is not allowed in ANSI C */
 static struct parm_struct parm_table[] =
 {
-  {"max connections",  P_INTEGER, P_GLOBAL, &Globals.max_connections,NULL, 0},
   {"motd file",        P_STRING,  P_GLOBAL, &Globals.motd_file,    NULL,   0},
-  {"lock file",        P_STRING,  P_GLOBAL, &Globals.lock_file,    NULL,   0},
   {"syslog facility",  P_ENUM,    P_GLOBAL, &Globals.syslog_facility, enum_facilities,0},
   {"socket options",   P_STRING,  P_GLOBAL, &Globals.socket_options,NULL,  0},
+  {"log file",         P_STRING,  P_GLOBAL, &Globals.log_file,      NULL,  0},
+  {"pid file",         P_STRING,  P_GLOBAL, &Globals.pid_file,      NULL,  0},
 
+  {"timeout",          P_INTEGER, P_LOCAL,  &sDefault.timeout,     NULL,  0},
+  {"max connections",  P_INTEGER, P_LOCAL,  &sDefault.max_connections,NULL, 0},
   {"name",             P_STRING,  P_LOCAL,  &sDefault.name,        NULL,   0},
   {"comment",          P_STRING,  P_LOCAL,  &sDefault.comment,     NULL,   0},
+  {"lock file",        P_STRING,  P_LOCAL,  &sDefault.lock_file,   NULL,   0},
   {"path",             P_STRING,  P_LOCAL,  &sDefault.path,        NULL,   0},
   {"read only",        P_BOOL,    P_LOCAL,  &sDefault.read_only,   NULL,   0},
   {"list",             P_BOOL,    P_LOCAL,  &sDefault.list,        NULL,   0},
+  {"use chroot",       P_BOOL,    P_LOCAL,  &sDefault.use_chroot,  NULL,   0},
+  {"ignore nonreadable",P_BOOL,   P_LOCAL,  &sDefault.ignore_nonreadable,  NULL,   0},
   {"uid",              P_STRING,  P_LOCAL,  &sDefault.uid,         NULL,   0},
   {"gid",              P_STRING,  P_LOCAL,  &sDefault.gid,         NULL,   0},
   {"hosts allow",      P_STRING,  P_LOCAL,  &sDefault.hosts_allow, NULL,   0},
   {"hosts deny",       P_STRING,  P_LOCAL,  &sDefault.hosts_deny,  NULL,   0},
   {"auth users",       P_STRING,  P_LOCAL,  &sDefault.auth_users,  NULL,   0},
   {"secrets file",     P_STRING,  P_LOCAL,  &sDefault.secrets_file,NULL,   0},
+  {"strict modes",     P_BOOL,    P_LOCAL,  &sDefault.strict_modes,NULL,   0},
   {"exclude",          P_STRING,  P_LOCAL,  &sDefault.exclude,     NULL,   0},
   {"exclude from",     P_STRING,  P_LOCAL,  &sDefault.exclude_from,NULL,   0},
+  {"include",          P_STRING,  P_LOCAL,  &sDefault.include,     NULL,   0},
+  {"include from",     P_STRING,  P_LOCAL,  &sDefault.include_from,NULL,   0},
+  {"transfer logging", P_BOOL,    P_LOCAL,  &sDefault.transfer_logging,NULL,0},
+  {"ignore errors",    P_BOOL,    P_LOCAL,  &sDefault.ignore_errors,NULL,0},
+  {"log format",       P_STRING,  P_LOCAL,  &sDefault.log_format,  NULL,   0},
+  {"refuse options",   P_STRING,  P_LOCAL,  &sDefault.refuse_options,NULL, 0},
+  {"dont compress",    P_STRING,  P_LOCAL,  &sDefault.dont_compress,NULL,  0},
   {NULL,               P_BOOL,    P_NONE,   NULL,                  NULL,   0}
 };
 
@@ -259,7 +294,6 @@ static void init_globals(void)
 #ifdef LOG_DAEMON
 	Globals.syslog_facility = LOG_DAEMON;
 #endif
-	Globals.lock_file = "/var/run/rsyncd.lock";
 }
 
 /***************************************************************************
@@ -295,24 +329,37 @@ static void init_locals(void)
 
 
 FN_GLOBAL_STRING(lp_motd_file, &Globals.motd_file)
-FN_GLOBAL_STRING(lp_lock_file, &Globals.lock_file)
+FN_GLOBAL_STRING(lp_log_file, &Globals.log_file)
+FN_GLOBAL_STRING(lp_pid_file, &Globals.pid_file)
 FN_GLOBAL_STRING(lp_socket_options, &Globals.socket_options)
-FN_GLOBAL_INTEGER(lp_max_connections, &Globals.max_connections)
 FN_GLOBAL_INTEGER(lp_syslog_facility, &Globals.syslog_facility)
 
 FN_LOCAL_STRING(lp_name, name)
 FN_LOCAL_STRING(lp_comment, comment)
 FN_LOCAL_STRING(lp_path, path)
+FN_LOCAL_STRING(lp_lock_file, lock_file)
 FN_LOCAL_BOOL(lp_read_only, read_only)
 FN_LOCAL_BOOL(lp_list, list)
+FN_LOCAL_BOOL(lp_use_chroot, use_chroot)
+FN_LOCAL_BOOL(lp_transfer_logging, transfer_logging)
+FN_LOCAL_BOOL(lp_ignore_errors, ignore_errors)
+FN_LOCAL_BOOL(lp_ignore_nonreadable, ignore_nonreadable)
 FN_LOCAL_STRING(lp_uid, uid)
 FN_LOCAL_STRING(lp_gid, gid)
 FN_LOCAL_STRING(lp_hosts_allow, hosts_allow)
 FN_LOCAL_STRING(lp_hosts_deny, hosts_deny)
 FN_LOCAL_STRING(lp_auth_users, auth_users)
 FN_LOCAL_STRING(lp_secrets_file, secrets_file)
+FN_LOCAL_BOOL(lp_strict_modes, strict_modes)
 FN_LOCAL_STRING(lp_exclude, exclude)
 FN_LOCAL_STRING(lp_exclude_from, exclude_from)
+FN_LOCAL_STRING(lp_include, include)
+FN_LOCAL_STRING(lp_include_from, include_from)
+FN_LOCAL_STRING(lp_log_format, log_format)
+FN_LOCAL_STRING(lp_refuse_options, refuse_options)
+FN_LOCAL_STRING(lp_dont_compress, dont_compress)
+FN_LOCAL_INTEGER(lp_timeout, timeout)
+FN_LOCAL_INTEGER(lp_max_connections, max_connections)
 
 /* local prototypes */
 static int    strwicmp( char *psz1, char *psz2 );
@@ -330,7 +377,7 @@ initialise a service to the defaults
 ***************************************************************************/
 static void init_service(service *pservice)
 {
-	bzero((char *)pservice,sizeof(service));
+	memset((char *)pservice,0,sizeof(service));
 	copy_service(pservice,&sDefault);
 }
 
@@ -341,7 +388,7 @@ static void string_set(char **s, char *v)
 		return;
 	}
 	*s = strdup(v);
-	if (!*s) exit_cleanup(1);
+	if (!*s) exit_cleanup(RERR_MALLOC);
 }
 
 
@@ -368,6 +415,7 @@ static int add_a_service(service *pservice, char *name)
   i = iNumServices;
 
   ServicePtrs = (service **)Realloc(ServicePtrs,sizeof(service *)*num_to_alloc);
+
   if (ServicePtrs)
 	  pSERVICE(iNumServices) = (service *)malloc(sizeof(service));
 
@@ -430,7 +478,7 @@ static int map_parameter(char *parmname)
       if (strwicmp(parm_table[iIndex].label, parmname) == 0)
          return(iIndex);
 
-   rprintf(FERROR, "Unknown parameter encountered: \"%s\"\n", parmname);
+   rprintf(FERROR, "Unknown Parameter encountered: \"%s\"\n", parmname);
    return(-1);
 }
 
@@ -542,7 +590,7 @@ static BOOL lp_do_parameter(int snum, char *parmname, char *parmvalue)
 
    if (parmnum < 0)
      {
-       rprintf(FERROR, "Ignoring unknown parameter \"%s\"\n", parmname);
+       rprintf(FERROR, "IGNORING unknown parameter \"%s\"\n", parmname);
        return(True);
      }
 
@@ -588,7 +636,7 @@ static BOOL lp_do_parameter(int snum, char *parmname, char *parmvalue)
        break;
 
      case P_GSTRING:
-       strlcpy((char *)parm_ptr,parmvalue,sizeof(pstring)-1);
+       strlcpy((char *)parm_ptr,parmvalue,sizeof(pstring));
        break;
 
      case P_ENUM:

log.c

@@ -23,15 +23,46 @@
   */
 #include "rsync.h"
 
+static FILE *logfile;
+static int log_error_fd = -1;
+
+static void logit(int priority, char *buf)
+{
+	if (logfile) {
+		fprintf(logfile,"%s [%d] %s", 
+			timestring(time(NULL)), (int)getpid(), buf);
+		fflush(logfile);
+	} else {
+		syslog(priority, "%s", buf);
+	}
+}
 
 void log_open(void)
 {
 	static int initialised;
 	int options = LOG_PID;
+	time_t t;
+	char *logf;
 
 	if (initialised) return;
 	initialised = 1;
 
+	/* this looks pointless, but it is needed in order for the
+	   C library on some systems to fetch the timezone info
+	   before the chroot */
+	t = time(NULL);
+	localtime(&t);
+
+	/* optionally use a log file instead of syslog */
+	logf = lp_log_file();
+	if (logf && *logf) {
+		extern int orig_umask;
+		int old_umask = umask(022 | orig_umask);
+		logfile = fopen(logf, "a");
+		umask(old_umask);
+		return;
+	}
+
 #ifdef LOG_NDELAY
 	options |= LOG_NDELAY;
 #endif
@@ -43,57 +74,100 @@ void log_open(void)
 #endif
 
 #ifndef LOG_NDELAY
-	syslog(LOG_INFO,"rsyncd started\n");
+	logit(LOG_INFO,"rsyncd started\n");
 #endif
 }
-		
 
-/* this is the rsync debugging function. Call it with FINFO or FERROR */
-void rprintf(int fd, const char *format, ...)
+/* setup the error file descriptor - used when we are a server
+   that is receiving files */
+void set_error_fd(int fd)
+{
+	log_error_fd = fd;
+}
+
+/* this is the underlying (unformatted) rsync debugging function. Call
+   it with FINFO, FERROR or FLOG */
+void rwrite(enum logcode code, char *buf, int len)
 {
-	va_list ap;  
-	char buf[1024];
-	int len;
 	FILE *f=NULL;
 	extern int am_daemon;
+	extern int am_server;
+	extern int quiet;
+	/* recursion can happen with certain fatal conditions */
 
-	va_start(ap, format);
-	len = vslprintf(buf, sizeof(buf)-1, format, ap);
-	va_end(ap);
+	if (quiet && code == FINFO) return;
 
-	if (len < 0) exit_cleanup(1);
-
-	if (len > sizeof(buf)-1) exit_cleanup(1);
+	if (len < 0) exit_cleanup(RERR_MESSAGEIO);
 
 	buf[len] = 0;
 
-	if (am_daemon) {
-		int priority = LOG_INFO;
-		if (fd == FERROR) priority = LOG_WARNING;
-
-		log_open();
-		syslog(priority, "%s", buf);
+	if (code == FLOG) {
+		if (am_daemon) logit(LOG_INFO, buf);
 		return;
 	}
 
-	if (fd == FERROR) {
+	/* first try to pass it off the our sibling */
+	if (am_server && io_error_write(log_error_fd, code, buf, len)) {
+		return;
+	}
+
+	/* then try to pass it to the other end */
+	if (am_server && io_multiplex_write(code, buf, len)) {
+		return;
+	}
+
+	if (am_daemon) {
+		static int depth;
+		int priority = LOG_INFO;
+		if (code == FERROR) priority = LOG_WARNING;
+
+		if (depth) return;
+
+		depth++;
+
+		log_open();
+		logit(priority, buf);
+
+		depth--;
+		return;
+	}
+
+	if (code == FERROR) {
 		f = stderr;
 	} 
 
-	if (fd == FINFO) {
-		extern int am_server;
+	if (code == FINFO) {
 		if (am_server) 
 			f = stderr;
 		else
 			f = stdout;
 	} 
 
-	if (!f) exit_cleanup(1);
+	if (!f) exit_cleanup(RERR_MESSAGEIO);
 
-	if (fwrite(buf, len, 1, f) != 1) exit_cleanup(1);
+	if (fwrite(buf, len, 1, f) != 1) exit_cleanup(RERR_MESSAGEIO);
+
+	if (buf[len-1] == '\r' || buf[len-1] == '\n') fflush(f);
+}
+		
+
+/* this is the rsync debugging function. Call it with FINFO, FERROR or FLOG */
+ void rprintf(enum logcode code, const char *format, ...)
+{
+	va_list ap;  
+	char buf[1024];
+	int len;
+
+	va_start(ap, format);
+	len = vslprintf(buf, sizeof(buf), format, ap);
+	va_end(ap);
+
+	if (len > sizeof(buf)-1) exit_cleanup(RERR_MESSAGEIO);
+
+	rwrite(code, buf, len);
 }
 
-void rflush(int fd)
+void rflush(enum logcode code)
 {
 	FILE *f = NULL;
 	extern int am_daemon;
@@ -102,11 +176,15 @@ void rflush(int fd)
 		return;
 	}
 
-	if (fd == FERROR) {
+	if (code == FLOG) {
+		return;
+	} 
+
+	if (code == FERROR) {
 		f = stderr;
 	} 
 
-	if (fd == FINFO) {
+	if (code == FINFO) {
 		extern int am_server;
 		if (am_server) 
 			f = stderr;
@@ -114,7 +192,161 @@ void rflush(int fd)
 			f = stdout;
 	} 
 
-	if (!f) exit_cleanup(1);
+	if (!f) exit_cleanup(RERR_MESSAGEIO);
 	fflush(f);
 }
 
+
+
+/* a generic logging routine for send/recv, with parameter
+   substitiution */
+static void log_formatted(enum logcode code,
+			  char *format, char *op, struct file_struct *file,
+			  struct stats *initial_stats)
+{
+	extern int module_id;
+	extern char *auth_user;
+	char buf[1024];
+	char buf2[1024];
+	char *p, *s, *n;
+	int l;
+	extern struct stats stats;		
+	extern int am_sender;
+	extern int am_daemon;
+	int64 b;
+
+	strlcpy(buf, format, sizeof(buf));
+	
+	for (s=&buf[0]; 
+	     s && (p=strchr(s,'%')); ) {
+		n = NULL;
+		s = p + 1;
+
+		switch (p[1]) {
+		case 'h': if (am_daemon) n = client_name(0); break;
+		case 'a': if (am_daemon) n = client_addr(0); break;
+		case 'l': 
+			slprintf(buf2,sizeof(buf2),"%.0f", 
+				 (double)file->length); 
+			n = buf2;
+			break;
+		case 'p': 
+			slprintf(buf2,sizeof(buf2),"%d", 
+				 (int)getpid()); 
+			n = buf2;
+			break;
+		case 'o': n = op; break;
+		case 'f': 
+			slprintf(buf2, sizeof(buf2), "%s/%s", 
+				 file->basedir?file->basedir:"", 
+				 f_name(file));
+			clean_fname(buf2);
+			n = buf2; 
+			if (*n == '/') n++;
+			break;
+		case 'm': n = lp_name(module_id); break;
+		case 't': n = timestring(time(NULL)); break;
+		case 'P': n = lp_path(module_id); break;
+		case 'u': n = auth_user; break;
+		case 'b': 
+			if (am_sender) {
+				b = stats.total_written - 
+					initial_stats->total_written;
+			} else {
+				b = stats.total_read - 
+					initial_stats->total_read;
+			}
+			slprintf(buf2,sizeof(buf2),"%.0f", (double)b); 
+			n = buf2;
+			break;
+		case 'c': 
+			if (!am_sender) {
+				b = stats.total_written - 
+					initial_stats->total_written;
+			} else {
+				b = stats.total_read - 
+					initial_stats->total_read;
+			}
+			slprintf(buf2,sizeof(buf2),"%.0f", (double)b); 
+			n = buf2;
+			break;
+		}
+
+		if (!n) continue;
+
+		l = strlen(n);
+
+		if ((l-1) + ((int)(s - &buf[0])) > sizeof(buf)) {
+			rprintf(FERROR,"buffer overflow expanding %%%c - exiting\n",
+				p[0]);
+			exit_cleanup(RERR_MESSAGEIO);
+		}
+
+		if (l != 2) {
+			memmove(s+(l-1), s+1, strlen(s+1)+1);
+		}
+		memcpy(p, n, l);
+
+		s = p+l;
+	}
+
+	rprintf(code,"%s\n", buf);
+}
+
+/* log the outgoing transfer of a file */
+void log_send(struct file_struct *file, struct stats *initial_stats)
+{
+	extern int module_id;
+	extern int am_server;
+	extern char *log_format;
+
+	if (lp_transfer_logging(module_id)) {
+		log_formatted(FLOG, lp_log_format(module_id), "send", file, initial_stats);
+	} else if (log_format && !am_server) {
+		log_formatted(FINFO, log_format, "send", file, initial_stats);
+	}
+}
+
+/* log the incoming transfer of a file */
+void log_recv(struct file_struct *file, struct stats *initial_stats)
+{
+	extern int module_id;
+	extern int am_server;
+	extern char *log_format;
+
+	if (lp_transfer_logging(module_id)) {
+		log_formatted(FLOG, lp_log_format(module_id), "recv", file, initial_stats);
+	} else if (log_format && !am_server) {
+		log_formatted(FINFO, log_format, "recv", file, initial_stats);
+	}
+}
+
+/* called when the transfer is interrupted for some reason */
+void log_exit(int code, const char *file, int line)
+{
+	if (code == 0) {
+		extern struct stats stats;		
+		rprintf(FLOG,"wrote %.0f bytes  read %.0f bytes  total size %.0f\n",
+			(double)stats.total_written,
+			(double)stats.total_read,
+			(double)stats.total_size);
+	} else {
+		rprintf(FLOG,"transfer interrupted (code %d) at %s(%d)\n", 
+			code, file, line);
+	}
+}
+
+/* log the incoming transfer of a file for interactive use, this
+   will be called at the end where the client was run 
+   
+   it i called when a file starts to be transferred
+*/
+void log_transfer(struct file_struct *file, const char *fname)
+{
+	extern int verbose;
+
+	if (!verbose) return;
+
+	rprintf(FINFO,"%s\n", fname);
+}
+

main.c

@@ -20,50 +20,101 @@
 #include "rsync.h"
 
 time_t starttime = 0;
-int64 total_size = 0;
 
-extern int csum_length;
+struct stats stats;
 
 extern int verbose;
 
+
+/****************************************************************************
+wait for a process to exit, calling io_flush while waiting
+****************************************************************************/
+void wait_process(pid_t pid, int *status)
+{
+	while (waitpid(pid, status, WNOHANG) == 0) {
+		msleep(20);
+		io_flush();
+	}
+	*status = WEXITSTATUS(*status);
+}
+
 static void report(int f)
 {
-	int64 in,out,tsize;
 	time_t t = time(NULL);
 	extern int am_server;
 	extern int am_sender;
 	extern int am_daemon;
-
-	if (!verbose) return;
+	extern int do_stats;
+	extern int remote_version;
+	int send_stats;
 
 	if (am_daemon) {
-		rprintf(FINFO, "wrote %.0f bytes  read %.0f bytes  total size %.0f\n",
-			(double)write_total(),(double)read_total(),
-			(double)total_size);
+		log_exit(0, __FILE__, __LINE__);
+		if (f == -1 || !am_sender) return;
 	}
 
-	if (am_server && am_sender) {
-		write_longint(f,read_total());
-		write_longint(f,write_total());
-		write_longint(f,total_size);
-		write_flush(f);
+	send_stats = verbose || (remote_version >= 20);
+	if (am_server) {
+		if (am_sender && send_stats) {
+			int64 w;
+			/* store total_written in a temporary
+			    because write_longint changes it */
+			w = stats.total_written;
+			write_longint(f,stats.total_read);
+			write_longint(f,w);
+			write_longint(f,stats.total_size);
+		}
 		return;
 	}
-    
-	if (am_sender) {
-		in = read_total();
-		out = write_total();
-		tsize = total_size;
-	} else {
-		out = read_longint(f);
-		in = read_longint(f);
-		tsize = read_longint(f);
+
+	/* this is the client */
+	    
+	if (!am_sender && send_stats) {
+		int64 r;
+		stats.total_written = read_longint(f);
+		/* store total_read in a temporary, read_longint changes it */
+		r = read_longint(f);
+		stats.total_size = read_longint(f);
+		stats.total_read = r;
+	}
+
+	if (do_stats) {
+		if (!am_sender && !send_stats) {
+		    /* missing the bytes written by the generator */
+		    rprintf(FINFO, "\nCannot show stats as receiver because remote protocol version is less than 20\n");
+		    rprintf(FINFO, "Use --stats -v to show stats\n");
+		    return;
+		}
+		rprintf(FINFO,"\nNumber of files: %d\n", stats.num_files);
+		rprintf(FINFO,"Number of files transferred: %d\n", 
+		       stats.num_transferred_files);
+		rprintf(FINFO,"Total file size: %.0f bytes\n", 
+		       (double)stats.total_size);
+		rprintf(FINFO,"Total transferred file size: %.0f bytes\n", 
+		       (double)stats.total_transferred_size);
+		rprintf(FINFO,"Literal data: %.0f bytes\n", 
+		       (double)stats.literal_data);
+		rprintf(FINFO,"Matched data: %.0f bytes\n", 
+		       (double)stats.matched_data);
+		rprintf(FINFO,"File list size: %d\n", stats.flist_size);
+		rprintf(FINFO,"Total bytes written: %.0f\n", 
+		       (double)stats.total_written);
+		rprintf(FINFO,"Total bytes read: %.0f\n\n", 
+		       (double)stats.total_read);
 	}
 	
-	printf("wrote %.0f bytes  read %.0f bytes  %.2f bytes/sec\n",
-	       (double)out,(double)in,(in+out)/(0.5 + (t-starttime)));
-	printf("total size is %.0f  speedup is %.2f\n",
-	       (double)tsize,(1.0*tsize)/(in+out));
+	if (verbose || do_stats) {
+		rprintf(FINFO,"wrote %.0f bytes  read %.0f bytes  %.2f bytes/sec\n",
+		       (double)stats.total_written,
+		       (double)stats.total_read,
+		       (stats.total_written+stats.total_read)/(0.5 + (t-starttime)));
+		rprintf(FINFO,"total size is %.0f  speedup is %.2f\n",
+		       (double)stats.total_size,
+		       (1.0*stats.total_size)/(stats.total_written+stats.total_read));
+	}
+
+	fflush(stdout);
+	fflush(stderr);
 }
 
 
@@ -74,6 +125,7 @@ static int do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int *f
 	char *tok,*dir=NULL;
 	extern int local_server;
 	extern char *rsync_path;
+	extern int blocking_io;
 
 	if (!local_server) {
 		if (!cmd)
@@ -106,6 +158,9 @@ static int do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int *f
 		args[argc++] = rsync_path;
 
 		server_options(args,&argc);
+
+
+		if (strcmp(cmd, RSYNC_RSH) == 0) blocking_io = 1;
 	}
 
 	args[argc++] = ".";
@@ -145,40 +200,47 @@ static char *get_local_name(struct file_list *flist,char *name)
 	STRUCT_STAT st;
 	extern int orig_umask;
 
-  if (do_stat(name,&st) == 0) {
-    if (S_ISDIR(st.st_mode)) {
-      if (chdir(name) != 0) {
-	rprintf(FERROR,"chdir %s : %s (1)\n",name,strerror(errno));
-	exit_cleanup(1);
-      }
-      return NULL;
-    }
-    if (flist->count > 1) {
-      rprintf(FERROR,"ERROR: destination must be a directory when copying more than 1 file\n");
-      exit_cleanup(1);
-    }
-    return name;
-  }
+	if (verbose > 2)
+		rprintf(FINFO,"get_local_name count=%d %s\n", 
+			flist->count, NS(name));
 
-  if (flist->count == 1)
-    return name;
+	if (!name) 
+		return NULL;
 
-  if (!name) 
-    return NULL;
+	if (do_stat(name,&st) == 0) {
+		if (S_ISDIR(st.st_mode)) {
+			if (!push_dir(name, 0)) {
+				rprintf(FERROR,"push_dir %s : %s (1)\n",
+					name,strerror(errno));
+				exit_cleanup(RERR_FILESELECT);
+			}
+			return NULL;
+		}
+		if (flist->count > 1) {
+			rprintf(FERROR,"ERROR: destination must be a directory when copying more than 1 file\n");
+			exit_cleanup(RERR_FILESELECT);
+		}
+		return name;
+	}
 
-  if (do_mkdir(name,0777 & ~orig_umask) != 0) {
-    rprintf(FERROR,"mkdir %s : %s (1)\n",name,strerror(errno));
-    exit_cleanup(1);
-  } else {
-    rprintf(FINFO,"created directory %s\n",name);
-  }
+	if (flist->count <= 1)
+		return name;
 
-  if (chdir(name) != 0) {
-    rprintf(FERROR,"chdir %s : %s (2)\n",name,strerror(errno));
-    exit_cleanup(1);
-  }
+	if (do_mkdir(name,0777 & ~orig_umask) != 0) {
+		rprintf(FERROR,"mkdir %s : %s (1)\n",name,strerror(errno));
+		exit_cleanup(RERR_FILEIO);
+	} else {
+		if (verbose > 0)
+			rprintf(FINFO,"created directory %s\n",name);
+	}
 
-  return NULL;
+	if (!push_dir(name, 0)) {
+		rprintf(FERROR,"push_dir %s : %s (2)\n",
+			name,strerror(errno));
+		exit_cleanup(RERR_FILESELECT);
+	}
+
+	return NULL;
 }
 
 
@@ -191,13 +253,14 @@ static void do_server_sender(int f_in, int f_out, int argc,char *argv[])
 	char *dir = argv[0];
 	extern int relative_paths;
 	extern int recurse;
+	extern int remote_version;
 
 	if (verbose > 2)
 		rprintf(FINFO,"server_sender starting pid=%d\n",(int)getpid());
   
-	if (!relative_paths && chdir(dir) != 0) {
-		rprintf(FERROR,"chdir %s: %s (3)\n",dir,strerror(errno));
-		exit_cleanup(1);
+	if (!relative_paths && !push_dir(dir, 0)) {
+		rprintf(FERROR,"push_dir %s: %s (3)\n",dir,strerror(errno));
+		exit_cleanup(RERR_FILESELECT);
 	}
 	argc--;
 	argv++;
@@ -217,40 +280,102 @@ static void do_server_sender(int f_in, int f_out, int argc,char *argv[])
 	}
 	
 	flist = send_file_list(f_out,argc,argv);
+	if (!flist || flist->count == 0) {
+		exit_cleanup(0);
+	}
+
 	send_files(flist,f_out,f_in);
+	io_flush();
 	report(f_out);
+	if (remote_version >= 24) {
+		/* final goodbye message */		
+ 		read_int(f_in);
+ 	}
+	io_flush();
 	exit_cleanup(0);
 }
 
 
 static int do_recv(int f_in,int f_out,struct file_list *flist,char *local_name)
 {
-  int pid;
-  int status=0;
-  int recv_pipe[2];
-  extern int preserve_hard_links;
+	int pid;
+	int status=0;
+	int recv_pipe[2];
+	int error_pipe[2];
+	extern int preserve_hard_links;
+	extern int delete_after;
+	extern int recurse;
+	extern int delete_mode;
+	extern int remote_version;
 
-  if (preserve_hard_links)
-    init_hard_links(flist);
+	if (preserve_hard_links)
+		init_hard_links(flist);
 
-  if (pipe(recv_pipe) < 0) {
-    rprintf(FERROR,"pipe failed in do_recv\n");
-    exit(1);
-  }
+	if (!delete_after) {
+		/* I moved this here from recv_files() to prevent a race condition */
+		if (recurse && delete_mode && !local_name && flist->count>0) {
+			delete_files(flist);
+		}
+	}
+
+	if (fd_pair(recv_pipe) < 0) {
+		rprintf(FERROR,"pipe failed in do_recv\n");
+		exit_cleanup(RERR_SOCKETIO);
+	}
+
+	if (fd_pair(error_pipe) < 0) {
+		rprintf(FERROR,"error pipe failed in do_recv\n");
+		exit_cleanup(RERR_SOCKETIO);
+	}
   
+	io_flush();
 
-  if ((pid=do_fork()) == 0) {
-    recv_files(f_in,flist,local_name,recv_pipe[1]);
-    if (verbose > 2)
-      rprintf(FINFO,"receiver read %ld\n",(long)read_total());
-    exit_cleanup(0);
-  }
+	if ((pid=do_fork()) == 0) {
+		close(recv_pipe[0]);
+		close(error_pipe[0]);
+		if (f_in != f_out) close(f_out);
 
-  generate_files(f_out,flist,local_name,recv_pipe[0]);
+		/* we can't let two processes write to the socket at one time */
+		io_multiplexing_close();
 
-  waitpid(pid, &status, 0);
+		/* set place to send errors */
+		set_error_fd(error_pipe[1]);
 
-  return status;
+		recv_files(f_in,flist,local_name,recv_pipe[1]);
+		io_flush();
+		report(f_in);
+
+		write_int(recv_pipe[1],1);
+		close(recv_pipe[1]);
+		io_flush();
+		/* finally we go to sleep until our parent kills us
+		   with a USR2 signal. We sleepp for a short time as on
+		   some OSes a signal won't interrupt a sleep! */
+		while (1) sleep(1);
+	}
+
+	close(recv_pipe[1]);
+	close(error_pipe[1]);
+	io_close_input(f_in);
+	if (f_in != f_out) close(f_in);
+
+	io_start_buffering(f_out);
+
+	io_set_error_fd(error_pipe[0]);
+
+	generate_files(f_out,flist,local_name,recv_pipe[0]);
+
+	read_int(recv_pipe[0]);
+	close(recv_pipe[0]);
+	if (remote_version >= 24) {
+		/* send a final goodbye message */
+		write_int(f_out, -1);
+	}
+	io_flush();
+
+	kill(pid, SIGUSR2);
+	wait_process(pid, &status);
+	return status;
 }
 
 
@@ -261,29 +386,39 @@ static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
 	char *local_name=NULL;
 	char *dir = NULL;
 	extern int delete_mode;
+	extern int delete_excluded;
 	extern int am_daemon;
+	extern int module_id;
+	extern int am_sender;
 
 	if (verbose > 2)
 		rprintf(FINFO,"server_recv(%d) starting pid=%d\n",argc,(int)getpid());
+
+	if (am_daemon && lp_read_only(module_id) && !am_sender) {
+		rprintf(FERROR,"ERROR: module is read only\n");
+		exit_cleanup(RERR_SYNTAX);
+		return;
+	}
+
 	
 	if (argc > 0) {
 		dir = argv[0];
 		argc--;
 		argv++;
-		if (!am_daemon && chdir(dir) != 0) {
-			rprintf(FERROR,"chdir %s : %s (4)\n",
+		if (!am_daemon && !push_dir(dir, 0)) {
+			rprintf(FERROR,"push_dir %s : %s (4)\n",
 				dir,strerror(errno));
-			exit_cleanup(1);
+			exit_cleanup(RERR_FILESELECT);
 		}    
 	}
 
-	if (delete_mode)
+	if (delete_mode && !delete_excluded)
 		recv_exclude_list(f_in);
 
 	flist = recv_file_list(f_in);
-	if (!flist || flist->count == 0) {
-		rprintf(FERROR,"nothing to do\n");
-		exit_cleanup(1);
+	if (!flist) {
+		rprintf(FERROR,"server_recv: recv_file_list error\n");
+		exit_cleanup(RERR_FILESELECT);
 	}
 	
 	if (argc > 0) {    
@@ -303,9 +438,16 @@ void start_server(int f_in, int f_out, int argc, char *argv[])
 {
 	extern int cvs_exclude;
 	extern int am_sender;
+	extern int remote_version;
 
 	setup_protocol(f_out, f_in);
-	
+
+	set_nonblocking(f_in);
+	set_nonblocking(f_out);
+
+	if (remote_version >= 23)
+		io_start_multiplex_out(f_out);
+
 	if (am_sender) {
 		recv_exclude_list(f_in);
 		if (cvs_exclude)
@@ -323,34 +465,51 @@ int client_run(int f_in, int f_out, int pid, int argc, char *argv[])
 	int status = 0, status2 = 0;
 	char *local_name = NULL;
 	extern int am_sender;
+	extern int list_only;
+	extern int remote_version;
+
+	set_nonblocking(f_in);
+	set_nonblocking(f_out);
 
 	setup_protocol(f_out,f_in);
+
+	if (remote_version >= 23)
+		io_start_multiplex_in(f_in);
 	
 	if (am_sender) {
 		extern int cvs_exclude;
 		extern int delete_mode;
+		extern int delete_excluded;
 		if (cvs_exclude)
 			add_cvs_excludes();
-		if (delete_mode) 
+		if (delete_mode && !delete_excluded) 
 			send_exclude_list(f_out);
 		flist = send_file_list(f_out,argc,argv);
 		if (verbose > 3) 
 			rprintf(FINFO,"file list sent\n");
+
 		send_files(flist,f_out,f_in);
 		if (pid != -1) {
 			if (verbose > 3)
-				rprintf(FINFO,"waiting on %d\n",pid);
-			waitpid(pid, &status, 0);
+				rprintf(FINFO,"client_run waiting on %d\n",pid);
+			io_flush();
+			wait_process(pid, &status);
+		}
+		if (remote_version >= 24) {
+			/* final goodbye message */		
+			read_int(f_in);
 		}
 		report(-1);
 		exit_cleanup(status);
 	}
+
+	if (argc == 0) list_only = 1;
 	
 	send_exclude_list(f_out);
 	
 	flist = recv_file_list(f_in);
 	if (!flist || flist->count == 0) {
-		rprintf(FINFO,"nothing to do\n");
+		rprintf(FINFO,"client: nothing to do\n");
 		exit_cleanup(0);
 	}
 	
@@ -358,29 +517,64 @@ int client_run(int f_in, int f_out, int pid, int argc, char *argv[])
 	
 	status2 = do_recv(f_in,f_out,flist,local_name);
 	
-	report(f_in);
-	
 	if (pid != -1) {
-		waitpid(pid, &status, 0);
+		if (verbose > 3)
+			rprintf(FINFO,"client_run2 waiting on %d\n",pid);
+		io_flush();
+		wait_process(pid, &status);
 	}
 	
 	return status | status2;
 }
 
+static char *find_colon(char *s)
+{
+	char *p, *p2;
 
-int start_client(int argc, char *argv[])
+	p = strchr(s,':');
+	if (!p) return NULL;
+	
+	/* now check to see if there is a / in the string before the : - if there is then
+	   discard the colon on the assumption that the : is part of a filename */
+	p2 = strchr(s,'/');
+	if (p2 && p2 < p) return NULL;
+
+	return p;
+}
+
+static int start_client(int argc, char *argv[])
 {
 	char *p;
 	char *shell_machine = NULL;
 	char *shell_path = NULL;
 	char *shell_user = NULL;
-	int pid;
+	int pid, ret;
 	int f_in,f_out;
 	extern int local_server;
 	extern int am_sender;
 	extern char *shell_cmd;
+	extern int rsync_port;
 
-	p = strchr(argv[0],':');
+	if (strncasecmp(URL_PREFIX, argv[0], strlen(URL_PREFIX)) == 0) {
+		char *host, *path;
+
+		host = argv[0] + strlen(URL_PREFIX);
+		p = strchr(host,'/');
+		if (p) {
+			*p = 0;
+			path = p+1;
+		} else {
+			path="";
+		}
+		p = strchr(host,':');
+		if (p) {
+			rsync_port = atoi(p+1);
+			*p = 0;
+		}
+		return start_socket_client(host, path, argc-1, argv+1);
+	}
+
+	p = find_colon(argv[0]);
 
 	if (p) {
 		if (p[1] == ':') {
@@ -388,9 +582,9 @@ int start_client(int argc, char *argv[])
 			return start_socket_client(argv[0], p+2, argc-1, argv+1);
 		}
 
-		if (argc < 2) {
+		if (argc < 1) {
 			usage(FERROR);
-			exit_cleanup(1);
+			exit_cleanup(RERR_SYNTAX);
 		}
 
 		am_sender = 0;
@@ -402,7 +596,7 @@ int start_client(int argc, char *argv[])
 	} else {
 		am_sender = 1;
 
-		p = strchr(argv[argc-1],':');
+		p = find_colon(argv[argc-1]);
 		if (!p) {
 			local_server = 1;
 		} else if (p[1] == ':') {
@@ -412,7 +606,7 @@ int start_client(int argc, char *argv[])
 
 		if (argc < 2) {
 			usage(FERROR);
-			exit_cleanup(1);
+			exit_cleanup(RERR_SYNTAX);
 		}
 		
 		if (local_server) {
@@ -443,24 +637,28 @@ int start_client(int argc, char *argv[])
 			shell_path?shell_path:"");
 	}
 	
-	if (!am_sender && argc != 1) {
+	if (!am_sender && argc > 1) {
 		usage(FERROR);
-		exit_cleanup(1);
+		exit_cleanup(RERR_SYNTAX);
 	}
 	
 	pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,&f_in,&f_out);
 	
-#if HAVE_SETLINEBUF
-	setlinebuf(stdout);
-	setlinebuf(stderr);
-#endif
+	ret = client_run(f_in, f_out, pid, argc, argv);
 
-	return client_run(f_in, f_out, pid, argc, argv);
+	fflush(stdout);
+	fflush(stderr);
+
+	return ret;
 }
 
 
-RETSIGTYPE sigusr1_handler(int val) {
-	exit_cleanup(1);
+static RETSIGTYPE sigusr1_handler(int val) {
+	exit_cleanup(RERR_SIGNAL);
+}
+
+static RETSIGTYPE sigusr2_handler(int val) {
+	_exit(0);
 }
 
 int main(int argc,char *argv[])
@@ -472,20 +670,25 @@ int main(int argc,char *argv[])
 	extern int am_server;
 
 	signal(SIGUSR1, sigusr1_handler);
+	signal(SIGUSR2, sigusr2_handler);
 
 	starttime = time(NULL);
 	am_root = (getuid() == 0);
 
+	memset(&stats, 0, sizeof(stats));
+
 	if (argc < 2) {
 		usage(FERROR);
-		exit(1);
+		exit_cleanup(RERR_SYNTAX);
 	}
 
 	/* we set a 0 umask so that correct file permissions can be
 	   carried across */
 	orig_umask = (int)umask(0);
 
-	parse_arguments(argc, argv);
+	if (!parse_arguments(argc, argv, 1)) {
+		exit_cleanup(RERR_SYNTAX);
+	}
 
 	argc -= optind;
 	argv += optind;
@@ -495,22 +698,36 @@ int main(int argc,char *argv[])
 	signal(SIGINT,SIGNAL_CAST sig_int);
 	signal(SIGPIPE,SIGNAL_CAST sig_int);
 	signal(SIGHUP,SIGNAL_CAST sig_int);
+	signal(SIGTERM,SIGNAL_CAST sig_int);
+
+	/* Initialize push_dir here because on some old systems getcwd
+	   (implemented by forking "pwd" and reading its output) doesn't
+	   work when there are other child processes.  Also, on all systems
+	   that implement getcwd that way "pwd" can't be found after chroot. */
+	push_dir(NULL,0);
 
 	if (am_daemon) {
 		return daemon_main();
 	}
 
+	if (argc < 1) {
+		usage(FERROR);
+		exit_cleanup(RERR_SYNTAX);
+	}
+
 	if (dry_run)
 		verbose = MAX(verbose,1);
 
 #ifndef SUPPORT_LINKS
 	if (!am_server && preserve_links) {
 		rprintf(FERROR,"ERROR: symbolic links not supported\n");
-		exit_cleanup(1);
+		exit_cleanup(RERR_UNSUPPORTED);
 	}
 #endif
 
 	if (am_server) {
+		set_nonblocking(STDIN_FILENO);
+		set_nonblocking(STDOUT_FILENO);
 		start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
 	}
 

match.c

@@ -29,18 +29,18 @@ extern int remote_version;
 typedef unsigned short tag;
 
 #define TABLESIZE (1<<16)
-#define NULL_TAG ((tag)-1)
+#define NULL_TAG (-1)
 
 static int false_alarms;
 static int tag_hits;
 static int matches;
-static int data_transfer;
+static int64 data_transfer;
 
 static int total_false_alarms;
 static int total_tag_hits;
 static int total_matches;
-static int64 total_data_transfer;
 
+extern struct stats stats;
 
 struct target {
   tag t;
@@ -49,7 +49,7 @@ struct target {
 
 static struct target *targets;
 
-static tag *tag_table;
+static int *tag_table;
 
 #define gettag2(s1,s2) (((s1) + (s2)) & 0xFFFF)
 #define gettag(sum) gettag2((sum)&0xFFFF,(sum)>>16)
@@ -65,7 +65,7 @@ static void build_hash_table(struct sum_struct *s)
   int i;
 
   if (!tag_table)
-    tag_table = (tag *)malloc(sizeof(tag)*TABLESIZE);
+    tag_table = (int *)malloc(sizeof(tag_table[0])*TABLESIZE);
 
   targets = (struct target *)malloc(sizeof(targets[0])*s->count);
   if (!tag_table || !targets) 
@@ -94,20 +94,19 @@ static void matched(int f,struct sum_struct *s,struct map_struct *buf,
 		    OFF_T offset,int i)
 {
 	OFF_T n = offset - last_match;
-	int j;
+	OFF_T j;
 
 	if (verbose > 2 && i >= 0)
-		rprintf(FINFO,"match at %d last_match=%d j=%d len=%d n=%d\n",
-			(int)offset,(int)last_match,i,(int)s->sums[i].len,(int)n);
+		rprintf(FINFO,"match at %.0f last_match=%.0f j=%d len=%d n=%.0f\n",
+			(double)offset,(double)last_match,i,s->sums[i].len,(double)n);
 
-	send_token(f,i,buf,last_match,n,i==-1?0:s->sums[i].len);
+	send_token(f,i,buf,last_match,n,i<0?0:s->sums[i].len);
 	data_transfer += n;
 
-	if (n > 0)
-		write_flush(f);
-
-	if (i >= 0)
+	if (i >= 0) {
+		stats.matched_data += s->sums[i].len;
 		n += s->sums[i].len;
+	}
   
 	for (j=0;j<n;j+=CHUNK_SIZE) {
 		int n1 = MIN(CHUNK_SIZE,n-j);
@@ -119,21 +118,30 @@ static void matched(int f,struct sum_struct *s,struct map_struct *buf,
 		last_match = offset + s->sums[i].len;
 	else
 		last_match = offset;
+
+	if (buf) {
+		show_progress(last_match, buf->file_size);
+
+		if (i == -1) end_progress(buf->file_size);
+	}
 }
 
 
 static void hash_search(int f,struct sum_struct *s,
 			struct map_struct *buf,OFF_T len)
 {
-	OFF_T offset;
-	int j,k;
-	int end;
+	OFF_T offset, end;
+	int j,k, last_i;
 	char sum2[SUM_LENGTH];
 	uint32 s1, s2, sum; 
 	schar *map;
 
+	/* last_i is used to encourage adjacent matches, allowing the RLL coding of the
+	   output to work more efficiently */
+	last_i = -1;
+
 	if (verbose > 2)
-		rprintf(FINFO,"hash search b=%d len=%d\n",s->n,(int)len);
+		rprintf(FINFO,"hash search b=%d len=%.0f\n",s->n,(double)len);
 
 	k = MIN(len, s->n);
 	
@@ -150,8 +158,8 @@ static void hash_search(int f,struct sum_struct *s,
 	end = len + 1 - s->sums[s->count-1].len;
 	
 	if (verbose > 3)
-		rprintf(FINFO,"hash search s->n=%d len=%d count=%d\n",
-			s->n,(int)len,s->count);
+		rprintf(FINFO,"hash search s->n=%d len=%.0f count=%d\n",
+			s->n,(double)len,s->count);
 	
 	do {
 		tag t = gettag2(s1,s2);
@@ -159,7 +167,7 @@ static void hash_search(int f,struct sum_struct *s,
 			
 		j = tag_table[t];
 		if (verbose > 4)
-			rprintf(FINFO,"offset=%d sum=%08x\n",(int)offset,sum);
+			rprintf(FINFO,"offset=%.0f sum=%08x\n",(double)offset,sum);
 		
 		if (j == NULL_TAG) {
 			goto null_tag;
@@ -168,16 +176,19 @@ static void hash_search(int f,struct sum_struct *s,
 		sum = (s1 & 0xffff) | (s2 << 16);
 		tag_hits++;
 		for (; j<s->count && targets[j].t == t; j++) {
-			int i = targets[j].i;
+			int l, i = targets[j].i;
 			
 			if (sum != s->sums[i].sum1) continue;
 			
+			/* also make sure the two blocks are the same length */
+			l = MIN(s->n,len-offset);
+			if (l != s->sums[i].len) continue;			
+
 			if (verbose > 3)
-				rprintf(FINFO,"potential match at %d target=%d %d sum=%08x\n",
-					(int)offset,j,i,sum);
+				rprintf(FINFO,"potential match at %.0f target=%d %d sum=%08x\n",
+					(double)offset,j,i,sum);
 			
 			if (!done_csum2) {
-				int l = MIN(s->n,len-offset);
 				map = (schar *)map_ptr(buf,offset,l);
 				get_checksum2((char *)map,l,sum2);
 				done_csum2 = 1;
@@ -187,6 +198,22 @@ static void hash_search(int f,struct sum_struct *s,
 				false_alarms++;
 				continue;
 			}
+
+			/* we've found a match, but now check to see
+                           if last_i can hint at a better match */
+			for (j++; j<s->count && targets[j].t == t; j++) {
+				int i2 = targets[j].i;
+				if (i2 == last_i + 1) {
+					if (sum != s->sums[i2].sum1) break;
+					if (memcmp(sum2,s->sums[i2].sum2,csum_length) != 0) break;
+					/* we've found an adjacent match - the RLL coder 
+					   will be happy */
+					i = i2;
+					break;
+				}
+			}
+
+			last_i = i;
 			
 			matched(f,s,buf,offset,i);
 			offset += s->sums[i].len - 1;
@@ -212,7 +239,17 @@ static void hash_search(int f,struct sum_struct *s,
 		} else {
 			--k;
 		}
-		
+
+		/* By matching early we avoid re-reading the
+		   data 3 times in the case where a token
+		   match comes a long way after last
+		   match. The 3 reads are caused by the
+		   running match, the checksum update and the
+		   literal send. */
+		if (offset-last_match >= CHUNK_SIZE+s->n && 
+		    (end-offset > CHUNK_SIZE)) {
+			matched(f,s,buf,offset - s->n, -2);
+		}
 	} while (++offset < end);
 	
 	matched(f,s,buf,len,-1);
@@ -243,6 +280,12 @@ void match_sums(int f,struct sum_struct *s,struct map_struct *buf,OFF_T len)
 		if (verbose > 2) 
 			rprintf(FINFO,"done hash search\n");
 	} else {
+		OFF_T j;
+		/* by doing this in pieces we avoid too many seeks */
+		for (j=0;j<(len-CHUNK_SIZE);j+=CHUNK_SIZE) {
+			int n1 = MIN(CHUNK_SIZE,(len-CHUNK_SIZE)-j);
+			matched(f,s,buf,j+n1,-2);
+		}
 		matched(f,s,buf,len,-1);
 	}
 
@@ -266,7 +309,7 @@ void match_sums(int f,struct sum_struct *s,struct map_struct *buf,OFF_T len)
 	total_tag_hits += tag_hits;
 	total_false_alarms += false_alarms;
 	total_matches += matches;
-	total_data_transfer += data_transfer;
+	stats.literal_data += data_transfer;
 }
 
 void match_report(void)
@@ -275,7 +318,8 @@ void match_report(void)
 		return;
 
 	rprintf(FINFO,
-		"total: matches=%d  tag_hits=%d  false_alarms=%d  data=%ld\n",
+		"total: matches=%d  tag_hits=%d  false_alarms=%d data=%.0f\n",
 		total_matches,total_tag_hits,
-		total_false_alarms,(long)total_data_transfer);
+		total_false_alarms,
+		(double)stats.literal_data);
 }

md4.c

@@ -1,263 +0,0 @@
-/*
-   This code is from rfc1186. 
-
-   It has been modified to use the SIVAL() macro to make it
-   byte order and length independent, so we don't need the LOWBYTEFIRST define
-*/
-
- /*
- ** ********************************************************************
- ** md4.c -- Implementation of MD4 Message Digest Algorithm           **
- ** Updated: 2/16/90 by Ronald L. Rivest                              **
- ** (C) 1990 RSA Data Security, Inc.                                  **
- ** ********************************************************************
- */
-
- /*
- ** To use MD4:
- **   -- Include md4.h in your program
- **   -- Declare an MDstruct MD to hold the state of the digest
- **          computation.
- **   -- Initialize MD using MDbegin(&MD)
- **   -- For each full block (64 bytes) X you wish to process, call
- **          MDupdate(&MD,X,512)
- **      (512 is the number of bits in a full block.)
- **   -- For the last block (less than 64 bytes) you wish to process,
- **          MDupdate(&MD,X,n)
- **      where n is the number of bits in the partial block. A partial
- **      block terminates the computation, so every MD computation
- **      should terminate by processing a partial block, even if it
- **      has n = 0.
- **   -- The message digest is available in MD.buffer[0] ...
- **      MD.buffer[3].  (Least-significant byte of each word
- **      should be output first.)
- **   -- You can print out the digest using MDprint(&MD)
- */
-
-#define TRUE  1
-#define FALSE 0
-
- /* Compile-time includes
- */
-
-#include "rsync.h"
-
- /* Compile-time declarations of MD4 "magic constants".
- */
-#define I0  0x67452301       /* Initial values for MD buffer */
-#define I1  0xefcdab89
-#define I2  0x98badcfe
-#define I3  0x10325476
-#define C2  013240474631     /* round 2 constant = sqrt(2) in octal */
-#define C3  015666365641     /* round 3 constant = sqrt(3) in octal */
- /* C2 and C3 are from Knuth, The Art of Programming, Volume 2
- ** (Seminumerical Algorithms), Second Edition (1981), Addison-Wesley.
- ** Table 2, page 660.
- */
-
-#define fs1  3               /* round 1 shift amounts */
-#define fs2  7
-#define fs3 11
-#define fs4 19
-#define gs1  3               /* round 2 shift amounts */
-#define gs2  5
-#define gs3  9
-#define gs4 13
-#define hs1  3               /* round 3 shift amounts */
-#define hs2  9
-#define hs3 11
-#define hs4 15
-
- /* Compile-time macro declarations for MD4.
- ** Note: The "rot" operator uses the variable "tmp".
- ** It assumes tmp is declared as unsigned int, so that the >>
- ** operator will shift in zeros rather than extending the sign bit.
- */
-#define f(X,Y,Z)             ((X&Y) | ((~X)&Z))
-#define g(X,Y,Z)             ((X&Y) | (X&Z) | (Y&Z))
-#define h(X,Y,Z)             (X^Y^Z)
-#define rot(X,S)             (tmp=X,(tmp<<S) | (tmp>>(32-S)))
-#define ff(A,B,C,D,i,s)      A = rot((A + f(B,C,D) + X[i]),s)
-#define gg(A,B,C,D,i,s)      A = rot((A + g(B,C,D) + X[i] + C2),s)
-#define hh(A,B,C,D,i,s)      A = rot((A + h(B,C,D) + X[i] + C3),s)
-
- /* MDbegin(MDp)
- ** Initialize message digest buffer MDp.
- ** This is a user-callable routine.
- */
- void
- MDbegin(MDp)
- MDptr MDp;
- { int i;
-   MDp->buffer[0] = I0;
-   MDp->buffer[1] = I1;
-   MDp->buffer[2] = I2;
-   MDp->buffer[3] = I3;
-   for (i=0;i<8;i++) MDp->count[i] = 0;
-   MDp->done = 0;
- }
-
- /* MDreverse(X)
- ** Reverse the byte-ordering of every int in X.
- ** Assumes X is an array of 16 ints.
- ** The macro revx reverses the byte-ordering of the next word of X.
- */
- void MDreverse(X)
- unsigned int32 *X;
- { register unsigned int32 t;
-   register unsigned int i;
-
-   for(i = 0; i < 16; i++) {
-	  t = X[i];
-	  SIVAL(X,i*4,t);
-	}
- }
-
- /* MDblock(MDp,X)
- ** Update message digest buffer MDp->buffer using 16-word data block X.
- ** Assumes all 16 words of X are full of data.
- ** Does not update MDp->count.
- ** This routine is not user-callable.
- */
- static void
- MDblock(MDp,X)
- MDptr MDp;
- unsigned int32 *X;
- {
-   register unsigned int32 tmp, A, B, C, D;
-   MDreverse(X);
-   A = MDp->buffer[0];
-   B = MDp->buffer[1];
-   C = MDp->buffer[2];
-   D = MDp->buffer[3];
-   /* Update the message digest buffer */
-   ff(A , B , C , D ,  0 , fs1); /* Round 1 */
-   ff(D , A , B , C ,  1 , fs2);
-   ff(C , D , A , B ,  2 , fs3);
-   ff(B , C , D , A ,  3 , fs4);
-   ff(A , B , C , D ,  4 , fs1);
-   ff(D , A , B , C ,  5 , fs2);
-   ff(C , D , A , B ,  6 , fs3);
-   ff(B , C , D , A ,  7 , fs4);
-   ff(A , B , C , D ,  8 , fs1);
-   ff(D , A , B , C ,  9 , fs2);
-   ff(C , D , A , B , 10 , fs3);
-   ff(B , C , D , A , 11 , fs4);
-   ff(A , B , C , D , 12 , fs1);
-   ff(D , A , B , C , 13 , fs2);
-   ff(C , D , A , B , 14 , fs3);
-   ff(B , C , D , A , 15 , fs4);
-   gg(A , B , C , D ,  0 , gs1); /* Round 2 */
-   gg(D , A , B , C ,  4 , gs2);
-   gg(C , D , A , B ,  8 , gs3);
-   gg(B , C , D , A , 12 , gs4);
-   gg(A , B , C , D ,  1 , gs1);
-   gg(D , A , B , C ,  5 , gs2);
-   gg(C , D , A , B ,  9 , gs3);
-   gg(B , C , D , A , 13 , gs4);
-   gg(A , B , C , D ,  2 , gs1);
-   gg(D , A , B , C ,  6 , gs2);
-   gg(C , D , A , B , 10 , gs3);
-   gg(B , C , D , A , 14 , gs4);
-   gg(A , B , C , D ,  3 , gs1);
-   gg(D , A , B , C ,  7 , gs2);
-   gg(C , D , A , B , 11 , gs3);
-   gg(B , C , D , A , 15 , gs4);
-   hh(A , B , C , D ,  0 , hs1); /* Round 3 */
-   hh(D , A , B , C ,  8 , hs2);
-   hh(C , D , A , B ,  4 , hs3);
-   hh(B , C , D , A , 12 , hs4);
-   hh(A , B , C , D ,  2 , hs1);
-   hh(D , A , B , C , 10 , hs2);
-   hh(C , D , A , B ,  6 , hs3);
-   hh(B , C , D , A , 14 , hs4);
-   hh(A , B , C , D ,  1 , hs1);
-   hh(D , A , B , C ,  9 , hs2);
-   hh(C , D , A , B ,  5 , hs3);
-   hh(B , C , D , A , 13 , hs4);
-   hh(A , B , C , D ,  3 , hs1);
-   hh(D , A , B , C , 11 , hs2);
-   hh(C , D , A , B ,  7 , hs3);
-   hh(B , C , D , A , 15 , hs4);
-   MDp->buffer[0] += A;
-   MDp->buffer[1] += B;
-   MDp->buffer[2] += C;
-   MDp->buffer[3] += D;
- }
-
- /* MDupdate(MDp,X,count)
- ** Input: MDp -- an MDptr
- **        X -- a pointer to an array of unsigned characters.
- **        count -- the number of bits of X to use.
- **          (if not a multiple of 8, uses high bits of last byte.)
- ** Update MDp using the number of bits of X given by count.
- ** This is the basic input routine for an MD4 user.
- ** The routine completes the MD computation when count < 512, so
- ** every MD computation should end with one call to MDupdate with a
- ** count less than 512.  A call with count 0 will be ignored if the
- ** MD has already been terminated (done != 0), so an extra call with
- ** count 0 can be given as a "courtesy close" to force termination
- ** if desired.
- */
- void
- MDupdate(MDp,X,count)
- MDptr MDp;
- unsigned char *X;
- unsigned int count;
- { unsigned int32 i, tmp, bit, byte, mask;
-   unsigned char XX[64];
-   unsigned char *p;
-   /* return with no error if this is a courtesy close with count
-   ** zero and MDp->done is true.
-   */
-   if (count == 0 && MDp->done) return;
-   /* check to see if MD is already done and report error */
-   if (MDp->done)
-          { rprintf(FERROR,"\nError: MDupdate MD already done."); return; }
-   /* Add count to MDp->count */
-   tmp = count;
-   p = MDp->count;
-   while (tmp)
-     { tmp += *p;
-       *p++ = tmp;
-       tmp = tmp >> 8;
-     }
-   /* Process data */
-   if (count == 512)
-     { /* Full block of data to handle */
-       MDblock(MDp,(unsigned int *)X);
-     }
-   else if (count > 512) /* Check for count too large */
-     { rprintf(FERROR,"\nError: MDupdate called with illegal count value %d."
-              ,count);
-       return;
-     }
-   else /* partial block -- must be last block so finish up */
-     { /* Find out how many bytes and residual bits there are */
-       byte = count >> 3;
-       bit =  count & 7;
-       /* Copy X into XX since we need to modify it */
-       for (i=0;i<=byte;i++)   XX[i] = X[i];
-       for (i=byte+1;i<64;i++) XX[i] = 0;
-       /* Add padding '1' bit and low-order zeros in last byte */
-       mask = 1 << (7 - bit);
-       XX[byte] = (XX[byte] | mask) & ~( mask - 1);
-       /* If room for bit count, finish up with this block */
-       if (byte <= 55)
-         { for (i=0;i<8;i++) XX[56+i] = MDp->count[i];
-           MDblock(MDp,(unsigned int32 *)XX);
-         }
-       else /* need to do two blocks to finish up */
-         { MDblock(MDp,(unsigned int32 *)XX);
-           for (i=0;i<56;i++) XX[i] = 0;
-           for (i=0;i<8;i++)  XX[56+i] = MDp->count[i];
-           MDblock(MDp,(unsigned int32 *)XX);
-         }
-       /* Set flag saying we're done with MD computation */
-       MDp->done = 1;
-     }
- }
-
- /*
- ** End of md4.c
- */

md4.h

@@ -1,49 +0,0 @@
-/*
-   This code is from rfc1186. 
-*/
-
- /*
- ** ********************************************************************
- ** md4.h -- Header file for implementation of                        **
- ** MD4 Message Digest Algorithm                                      **
- ** Updated: 2/13/90 by Ronald L. Rivest                              **
- ** (C) 1990 RSA Data Security, Inc.                                  **
- ** ********************************************************************
- */
-
- /* MDstruct is the data structure for a message digest computation.
- */
- typedef struct {
-   unsigned int32 buffer[4]; /* Holds 4-word result of MD computation */
-   unsigned char count[8]; /* Number of bits processed so far */
-   unsigned int done;      /* Nonzero means MD computation finished */
- } MDstruct, *MDptr;
-
- /* MDbegin(MD)
-
-
-
- ** Input: MD -- an MDptr
- ** Initialize the MDstruct prepatory to doing a message digest
- ** computation.
- */
- extern void MDbegin();
-
- /* MDupdate(MD,X,count)
- ** Input: MD -- an MDptr
- **        X -- a pointer to an array of unsigned characters.
- **        count -- the number of bits of X to use (an unsigned int).
- ** Updates MD using the first "count" bits of X.
- ** The array pointed to by X is not modified.
- ** If count is not a multiple of 8, MDupdate uses high bits of
- ** last byte.
- ** This is the basic input routine for a user.
- ** The routine terminates the MD computation when count < 512, so
- ** every MD computation should end with one call to MDupdate with a
- ** count less than 512.  Zero is OK for a count.
- */
- extern void MDupdate();
-
- /*
- ** End of md4.h
- */

mkproto.awk

@@ -58,7 +58,7 @@ BEGIN {
   next;
 }
 
-!/^OFF_T|^off_t|^pid_t|^unsigned|^mode_t|^DIR|^user|^int|^char|^uint|^struct|^BOOL|^void|^time/ {
+!/^OFF_T|^size_t|^off_t|^pid_t|^unsigned|^mode_t|^DIR|^user|^int|^char|^uint|^struct|^BOOL|^void|^time/ {
   next;
 }
 

packaging/redhat/5.0/rsync.spec

@@ -0,0 +1,81 @@
+Summary: Program for efficient remote updates of files.
+Name: rsync
+Version: 2.4.5
+Release: 1
+Copyright: GPL
+Group: Applications/Networking
+Source:	ftp://samba.anu.edu.au/pub/rsync/rsync-2.4.5.tar.gz
+URL: http://samba.anu.edu.au/rsync/
+Packager: Andrew Tridgell <tridge@samba.anu.edu.au>
+BuildRoot: /tmp/rsync
+
+%description
+rsync is a replacement for rcp that has many more features.
+
+rsync uses the "rsync algorithm" which provides a very fast method for
+bringing remote files into sync. It does this by sending just the
+differences in the files across the link, without requiring that both
+sets of files are present at one of the ends of the link beforehand.
+
+A technical report describing the rsync algorithm is included with
+this package. 
+
+%changelog
+* Mon Jan 25 1999 Stefan Hornburg <racke@linuxia.de>
+  quoted RPM_OPT_FLAGS for the sake of robustness  
+* Mon May 18 1998 Andrew Tridgell <tridge@samba.anu.edu.au>
+  reworked for auto-building when I release rsync (tridge@samba.anu.edu.au)
+
+* Sat May 16 1998 John H Terpstra <jht@aquasoft.com.au>
+  Upgraded to Rsync 2.0.6
+    -new feature anonymous rsync
+
+* Mon Apr  6 1998 Douglas N. Arnold <dna@math.psu.edu>
+
+Upgrade to rsync version 1.7.2.
+
+* Sun Mar  1 1998 Douglas N. Arnold <dna@math.psu.edu>
+
+Built 1.6.9-1 based on the 1.6.3-2 spec file of John A. Martin.
+Changes from 1.6.3-2 packaging: added latex and dvips commands
+to create tech_report.ps.
+
+* Mon Aug 25 1997 John A. Martin <jam@jamux.com>
+
+Built 1.6.3-2 after finding no rsync-1.6.3-1.src.rpm although there
+was an ftp://ftp.redhat.com/pub/contrib/alpha/rsync-1.6.3-1.alpha.rpm
+showing no packager nor signature but giving 
+"Source RPM: rsync-1.6.3-1.src.rpm".
+
+Changes from 1.6.2-1 packaging: added '$RPM_OPT_FLAGS' to make, strip
+to '%build', removed '%prefix'.
+
+* Thu Apr 10 1997 Michael De La Rue <miked@ed.ac.uk>
+
+rsync-1.6.2-1 packaged.  (This entry by jam to credit Michael for the
+previous package(s).)
+
+%prep
+%setup
+
+%build
+./configure --prefix=/usr
+make CFLAGS="$RPM_OPT_FLAGS"
+strip rsync
+
+%install
+mkdir -p $RPM_BUILD_ROOT/usr/{bin,man/{man1,man5}}
+install -m755 rsync $RPM_BUILD_ROOT/usr/bin
+install -m644 rsync.1 $RPM_BUILD_ROOT/usr/man/man1
+install -m644 rsyncd.conf.5 $RPM_BUILD_ROOT/usr/man/man5
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%files
+%attr(-,root,root) /usr/bin/rsync
+%attr(-,root,root) /usr/man/man1/rsync.1
+%attr(-,root,root) /usr/man/man5/rsyncd.conf.5
+%attr(-,root,root) %doc tech_report.tex
+%attr(-,root,root) %doc README
+%attr(-,root,root) %doc COPYING

packaging/redhat/5.0/rsync.spec.tmpl

@@ -0,0 +1,81 @@
+Summary: Program for efficient remote updates of files.
+Name: rsync
+Version: PVERSION
+Release: PRELEASE
+Copyright: GPL
+Group: Applications/Networking
+Source:	ftp://samba.anu.edu.au/pub/rsync/rsync-PVERSION.tar.gz
+URL: http://samba.anu.edu.au/rsync/
+Packager: Andrew Tridgell <tridge@samba.anu.edu.au>
+BuildRoot: /tmp/rsync
+
+%description
+rsync is a replacement for rcp that has many more features.
+
+rsync uses the "rsync algorithm" which provides a very fast method for
+bringing remote files into sync. It does this by sending just the
+differences in the files across the link, without requiring that both
+sets of files are present at one of the ends of the link beforehand.
+
+A technical report describing the rsync algorithm is included with
+this package. 
+
+%changelog
+* Mon Jan 25 1999 Stefan Hornburg <racke@linuxia.de>
+  quoted RPM_OPT_FLAGS for the sake of robustness  
+* Mon May 18 1998 Andrew Tridgell <tridge@samba.anu.edu.au>
+  reworked for auto-building when I release rsync (tridge@samba.anu.edu.au)
+
+* Sat May 16 1998 John H Terpstra <jht@aquasoft.com.au>
+  Upgraded to Rsync 2.0.6
+    -new feature anonymous rsync
+
+* Mon Apr  6 1998 Douglas N. Arnold <dna@math.psu.edu>
+
+Upgrade to rsync version 1.7.2.
+
+* Sun Mar  1 1998 Douglas N. Arnold <dna@math.psu.edu>
+
+Built 1.6.9-1 based on the 1.6.3-2 spec file of John A. Martin.
+Changes from 1.6.3-2 packaging: added latex and dvips commands
+to create tech_report.ps.
+
+* Mon Aug 25 1997 John A. Martin <jam@jamux.com>
+
+Built 1.6.3-2 after finding no rsync-1.6.3-1.src.rpm although there
+was an ftp://ftp.redhat.com/pub/contrib/alpha/rsync-1.6.3-1.alpha.rpm
+showing no packager nor signature but giving 
+"Source RPM: rsync-1.6.3-1.src.rpm".
+
+Changes from 1.6.2-1 packaging: added '$RPM_OPT_FLAGS' to make, strip
+to '%build', removed '%prefix'.
+
+* Thu Apr 10 1997 Michael De La Rue <miked@ed.ac.uk>
+
+rsync-1.6.2-1 packaged.  (This entry by jam to credit Michael for the
+previous package(s).)
+
+%prep
+%setup
+
+%build
+./configure --prefix=/usr
+make CFLAGS="$RPM_OPT_FLAGS"
+strip rsync
+
+%install
+mkdir -p $RPM_BUILD_ROOT/usr/{bin,man/{man1,man5}}
+install -m755 rsync $RPM_BUILD_ROOT/usr/bin
+install -m644 rsync.1 $RPM_BUILD_ROOT/usr/man/man1
+install -m644 rsyncd.conf.5 $RPM_BUILD_ROOT/usr/man/man5
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%files
+%attr(-,root,root) /usr/bin/rsync
+%attr(-,root,root) /usr/man/man1/rsync.1
+%attr(-,root,root) /usr/man/man5/rsyncd.conf.5
+%attr(-,root,root) %doc tech_report.tex
+%attr(-,root,root) %doc README
+%attr(-,root,root) %doc COPYING

params.c

@@ -74,10 +74,6 @@
  */
 
 #include "rsync.h"
-#define BOOL int
-#define False 0
-#define True 1
-#define Realloc realloc
 
 /* -------------------------------------------------------------------------- **
  * Constants...

receiver.c

@@ -0,0 +1,508 @@
+/* 
+   Copyright (C) Andrew Tridgell 1996
+   Copyright (C) Paul Mackerras 1996
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "rsync.h"
+
+extern int verbose;
+extern int recurse;
+extern int delete_mode;
+extern int remote_version;
+extern int csum_length;
+extern struct stats stats;
+extern int dry_run;
+extern int am_server;
+extern int relative_paths;
+extern int preserve_hard_links;
+extern int cvs_exclude;
+extern int io_error;
+extern char *tmpdir;
+extern char *compare_dest;
+extern int make_backups;
+extern char *backup_suffix;
+
+static struct delete_list {
+	dev_t dev;
+	INO_T inode;
+} *delete_list;
+static int dlist_len, dlist_alloc_len;
+
+/* yuck! This function wouldn't have been necessary if I had the sorting
+   algorithm right. Unfortunately fixing the sorting algorithm would introduce
+   a backward incompatibility as file list indexes are sent over the link.
+*/
+static int delete_already_done(struct file_list *flist,int j)
+{
+	int i;
+	STRUCT_STAT st;
+
+	if (link_stat(f_name(flist->files[j]), &st)) return 1;
+
+	for (i=0;i<dlist_len;i++) {
+		if (st.st_ino == delete_list[i].inode &&
+		    st.st_dev == delete_list[i].dev)
+			return 1;
+	}
+
+	return 0;
+}
+
+static void add_delete_entry(struct file_struct *file)
+{
+	if (dlist_len == dlist_alloc_len) {
+		dlist_alloc_len += 1024;
+		delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
+		if (!delete_list) out_of_memory("add_delete_entry");
+	}
+
+	delete_list[dlist_len].dev = file->dev;
+	delete_list[dlist_len].inode = file->inode;
+	dlist_len++;
+
+	if (verbose > 3)
+		rprintf(FINFO,"added %s to delete list\n", f_name(file));
+}
+
+static void delete_one(struct file_struct *f)
+{
+	if (!S_ISDIR(f->mode)) {
+		if (robust_unlink(f_name(f)) != 0) {
+			rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
+		} else if (verbose) {
+			rprintf(FINFO,"deleting %s\n",f_name(f));
+		}
+	} else {    
+		if (do_rmdir(f_name(f)) != 0) {
+			if (errno != ENOTEMPTY && errno != EEXIST)
+				rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
+		} else if (verbose) {
+			rprintf(FINFO,"deleting directory %s\n",f_name(f));      
+		}
+	}
+}
+
+
+
+
+/* this deletes any files on the receiving side that are not present
+   on the sending side. For version 1.6.4 I have changed the behaviour
+   to match more closely what most people seem to expect of this option */
+void delete_files(struct file_list *flist)
+{
+	struct file_list *local_file_list;
+	int i, j;
+	char *name;
+	extern int module_id;
+	extern int ignore_errors;
+	extern int max_delete;
+	static int deletion_count;
+
+	if (cvs_exclude)
+		add_cvs_excludes();
+
+	if (io_error && !(lp_ignore_errors(module_id) || ignore_errors)) {
+		rprintf(FINFO,"IO error encountered - skipping file deletion\n");
+		return;
+	}
+
+	for (j=0;j<flist->count;j++) {
+		if (!S_ISDIR(flist->files[j]->mode) || 
+		    !(flist->files[j]->flags & FLAG_DELETE)) continue;
+
+		if (remote_version < 19 &&
+		    delete_already_done(flist, j)) continue;
+
+		name = strdup(f_name(flist->files[j]));
+
+		if (!(local_file_list = send_file_list(-1,1,&name))) {
+			free(name);
+			continue;
+		}
+
+		if (verbose > 1)
+			rprintf(FINFO,"deleting in %s\n", name);
+
+		for (i=local_file_list->count-1;i>=0;i--) {
+			if (max_delete && deletion_count > max_delete) break;
+			if (!local_file_list->files[i]->basename) continue;
+			if (remote_version < 19 &&
+			    S_ISDIR(local_file_list->files[i]->mode))
+				add_delete_entry(local_file_list->files[i]);
+			if (-1 == flist_find(flist,local_file_list->files[i])) {
+				char *f = f_name(local_file_list->files[i]);
+				int k = strlen(f) - strlen(backup_suffix);
+/* Hi Andrew, do we really need to play with backup_suffix here? */
+				if (make_backups && ((k <= 0) ||
+					    (strcmp(f+k,backup_suffix) != 0))) {
+					(void) make_backup(f);
+				} else {
+					deletion_count++;
+					delete_one(local_file_list->files[i]);
+				}
+			}
+		}
+		flist_free(local_file_list);
+		free(name);
+	}
+}
+
+
+static int get_tmpname(char *fnametmp, char *fname)
+{
+	char *f;
+
+	/* open tmp file */
+	if (tmpdir) {
+		f = strrchr(fname,'/');
+		if (f == NULL) 
+			f = fname;
+		else 
+			f++;
+		if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
+			rprintf(FERROR,"filename too long\n");
+			return 0;
+		}
+		slprintf(fnametmp,MAXPATHLEN, "%s/.%s.XXXXXX",tmpdir,f);
+		return 1;
+	} 
+
+	f = strrchr(fname,'/');
+
+	if (strlen(fname)+9 > MAXPATHLEN) {
+		rprintf(FERROR,"filename too long\n");
+		return 0;
+	}
+
+	if (f) {
+		*f = 0;
+		slprintf(fnametmp,MAXPATHLEN,"%s/.%s.XXXXXX",
+			 fname,f+1);
+		*f = '/';
+	} else {
+		slprintf(fnametmp,MAXPATHLEN,".%s.XXXXXX",fname);
+	}
+
+	return 1;
+}
+
+
+static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname,
+			OFF_T total_size)
+{
+	int i,n,remainder,len,count;
+	OFF_T offset = 0;
+	OFF_T offset2;
+	char *data;
+	static char file_sum1[MD4_SUM_LENGTH];
+	static char file_sum2[MD4_SUM_LENGTH];
+	char *map=NULL;
+	
+	count = read_int(f_in);
+	n = read_int(f_in);
+	remainder = read_int(f_in);
+	
+	sum_init();
+	
+	for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
+
+		show_progress(offset, total_size);
+
+		if (i > 0) {
+			extern int cleanup_got_literal;
+
+			if (verbose > 3) {
+				rprintf(FINFO,"data recv %d at %.0f\n",
+					i,(double)offset);
+			}
+
+			stats.literal_data += i;
+			cleanup_got_literal = 1;
+      
+			sum_update(data,i);
+
+			if (fd != -1 && write_file(fd,data,i) != i) {
+				rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
+				exit_cleanup(RERR_FILEIO);
+			}
+			offset += i;
+			continue;
+		} 
+
+		i = -(i+1);
+		offset2 = i*(OFF_T)n;
+		len = n;
+		if (i == count-1 && remainder != 0)
+			len = remainder;
+		
+		stats.matched_data += len;
+		
+		if (verbose > 3)
+			rprintf(FINFO,"chunk[%d] of size %d at %.0f offset=%.0f\n",
+				i,len,(double)offset2,(double)offset);
+		
+		if (buf) {
+			map = map_ptr(buf,offset2,len);
+		
+			see_token(map, len);
+			sum_update(map,len);
+		}
+		
+		if (fd != -1 && write_file(fd,map,len) != len) {
+			rprintf(FERROR,"write failed on %s : %s\n",
+				fname,strerror(errno));
+			exit_cleanup(RERR_FILEIO);
+		}
+		offset += len;
+	}
+
+	end_progress(total_size);
+
+	if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
+		rprintf(FERROR,"write failed on %s : %s\n",
+			fname,strerror(errno));
+		exit_cleanup(RERR_FILEIO);
+	}
+
+	sum_end(file_sum1);
+
+	if (remote_version >= 14) {
+		read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
+		if (verbose > 2) {
+			rprintf(FINFO,"got file_sum\n");
+		}
+		if (fd != -1 && 
+		    memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0) {
+			return 0;
+		}
+	}
+	return 1;
+}
+
+
+/* main routine for receiver process. Receiver process runs on the
+	same host as the generator process. */
+
+int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
+{  
+	int fd1,fd2;
+	STRUCT_STAT st;
+	char *fname;
+	char fnametmp[MAXPATHLEN];
+	char *fnamecmp;
+	char fnamecmpbuf[MAXPATHLEN];
+	struct map_struct *buf;
+	int i;
+	struct file_struct *file;
+	int phase=0;
+	int recv_ok;
+	extern struct stats stats;		
+	extern int preserve_perms;
+	extern int delete_after;
+	struct stats initial_stats;
+
+	if (verbose > 2) {
+		rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
+	}
+
+	while (1) {      
+		cleanup_disable();
+
+		i = read_int(f_in);
+		if (i == -1) {
+			if (phase==0 && remote_version >= 13) {
+				phase++;
+				csum_length = SUM_LENGTH;
+				if (verbose > 2)
+					rprintf(FINFO,"recv_files phase=%d\n",phase);
+				write_int(f_gen,-1);
+				continue;
+			}
+			break;
+		}
+
+		if (i < 0 || i >= flist->count) {
+			rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n", 
+				i, flist->count);
+			exit_cleanup(RERR_PROTOCOL);
+		}
+
+		file = flist->files[i];
+		fname = f_name(file);
+
+		stats.num_transferred_files++;
+		stats.total_transferred_size += file->length;
+
+		if (local_name)
+			fname = local_name;
+
+		if (dry_run) {
+			if (!am_server) {
+				log_transfer(file, fname);
+			}
+			continue;
+		}
+
+		initial_stats = stats;
+
+		if (verbose > 2)
+			rprintf(FINFO,"recv_files(%s)\n",fname);
+
+		fnamecmp = fname;
+
+		/* open the file */  
+		fd1 = do_open(fnamecmp, O_RDONLY, 0);
+
+		if ((fd1 == -1) && (compare_dest != NULL)) {
+			/* try the file at compare_dest instead */
+			slprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",
+						compare_dest,fname);
+			fnamecmp = fnamecmpbuf;
+			fd1 = do_open(fnamecmp, O_RDONLY, 0);
+		}
+
+		if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
+			rprintf(FERROR,"fstat %s : %s\n",fnamecmp,strerror(errno));
+			receive_data(f_in,NULL,-1,NULL,file->length);
+			close(fd1);
+			continue;
+		}
+
+		if (fd1 != -1 && !S_ISREG(st.st_mode)) {
+			rprintf(FERROR,"%s : not a regular file (recv_files)\n",fnamecmp);
+			receive_data(f_in,NULL,-1,NULL,file->length);
+			close(fd1);
+			continue;
+		}
+
+		if (fd1 != -1 && !preserve_perms) {
+			/* if the file exists already and we aren't perserving
+			   presmissions then act as though the remote end sent
+			   us the file permissions we already have */
+			file->mode = st.st_mode;
+		}
+
+		if (fd1 != -1 && st.st_size > 0) {
+			buf = map_file(fd1,st.st_size);
+			if (verbose > 2)
+				rprintf(FINFO,"recv mapped %s of size %.0f\n",fnamecmp,(double)st.st_size);
+		} else {
+			buf = NULL;
+		}
+
+		if (!get_tmpname(fnametmp,fname)) {
+			if (buf) unmap_file(buf);
+			if (fd1 != -1) close(fd1);
+			continue;
+		}
+
+		/* mktemp is deliberately used here instead of mkstemp.
+		   because O_EXCL is used on the open, the race condition
+		   is not a problem or a security hole, and we want to
+		   control the access permissions on the created file. */
+		if (NULL == do_mktemp(fnametmp)) {
+			rprintf(FERROR,"mktemp %s failed\n",fnametmp);
+			receive_data(f_in,buf,-1,NULL,file->length);
+			if (buf) unmap_file(buf);
+			if (fd1 != -1) close(fd1);
+			continue;
+		}
+
+		/* we initially set the perms without the
+		   setuid/setgid bits to ensure that there is no race
+		   condition. They are then correctly updated after
+		   the lchown. Thanks to snabb@epipe.fi for pointing
+		   this out.  We also set it initially without group
+		   access because of a similar race condition. */
+		fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,
+			      file->mode & INITACCESSPERMS);
+
+		/* in most cases parent directories will already exist
+		   because their information should have been previously
+		   transferred, but that may not be the case with -R */
+		if (fd2 == -1 && relative_paths && errno == ENOENT && 
+		    create_directory_path(fnametmp) == 0) {
+			fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,
+				      file->mode & INITACCESSPERMS);
+		}
+		if (fd2 == -1) {
+			rprintf(FERROR,"cannot create %s : %s\n",fnametmp,strerror(errno));
+			receive_data(f_in,buf,-1,NULL,file->length);
+			if (buf) unmap_file(buf);
+			if (fd1 != -1) close(fd1);
+			continue;
+		}
+      
+		cleanup_set(fnametmp, fname, file, buf, fd1, fd2);
+
+		if (!am_server) {
+			log_transfer(file, fname);
+		}
+
+		/* recv file data */
+		recv_ok = receive_data(f_in,buf,fd2,fname,file->length);
+
+		log_recv(file, &initial_stats);
+		
+		if (buf) unmap_file(buf);
+		if (fd1 != -1) {
+			close(fd1);
+		}
+		close(fd2);
+		
+		if (verbose > 2)
+			rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
+
+		finish_transfer(fname, fnametmp, file);
+
+		cleanup_disable();
+
+		if (!recv_ok) {
+			if (csum_length == SUM_LENGTH) {
+				rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
+					fname);
+			} else {
+				if (verbose > 1)
+					rprintf(FINFO,"redoing %s(%d)\n",fname,i);
+				write_int(f_gen,i);
+			}
+		}
+	}
+
+	if (delete_after) {
+		if (recurse && delete_mode && !local_name && flist->count>0) {
+			delete_files(flist);
+		}
+	}
+
+	if (preserve_hard_links)
+		do_hard_links(flist);
+
+	/* now we need to fix any directory permissions that were 
+	   modified during the transfer */
+	for (i = 0; i < flist->count; i++) {
+		file = flist->files[i];
+		if (!file->basename || !S_ISDIR(file->mode)) continue;
+		recv_generator(local_name?local_name:f_name(file),flist,i,-1);
+	}
+
+	if (verbose > 2)
+		rprintf(FINFO,"recv_files finished\n");
+	
+	return 0;
+}
+

rsync.h

@@ -17,16 +17,22 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
+#define False 0
+#define True 1
+
 #define BLOCK_SIZE 700
 #define RSYNC_RSH_ENV "RSYNC_RSH"
 
 #define RSYNC_NAME "rsync"
 #define RSYNCD_CONF "/etc/rsyncd.conf"
 
+#define DEFAULT_LOCK_FILE "/var/run/rsyncd.lock"
+#define URL_PREFIX "rsync://"
+
 #define BACKUP_SUFFIX "~"
 
 /* a non-zero CHAR_OFFSET makes the rolling sum stronger, but is
-   imcompatible with older versions :-( */
+   incompatible with older versions :-( */
 #define CHAR_OFFSET 0
 
 
@@ -41,8 +47,8 @@
 #define SAME_TIME (1<<7)
 
 /* update this if you make incompatible changes */
-#define PROTOCOL_VERSION 17
-#define MIN_PROTOCOL_VERSION 11
+#define PROTOCOL_VERSION 24
+#define MIN_PROTOCOL_VERSION 15
 #define MAX_PROTOCOL_VERSION 30
 
 #define RSYNC_PORT 873
@@ -50,15 +56,16 @@
 #define SPARSE_WRITE_SIZE (1024)
 #define WRITE_SIZE (32*1024)
 #define CHUNK_SIZE (32*1024)
-#define MAX_MAP_SIZE (4*1024*1024)
-#define IO_BUFFER_SIZE (4096)
+#define MAX_MAP_SIZE (256*1024)
+#define IO_BUFFER_SIZE (4092)
 
 #define MAX_ARGS 1000
 
-#define BLOCKING_TIMEOUT 10
+#define MPLEX_BASE 7
 
-#define FERROR 1
-#define FINFO 2
+enum logcode {FNONE=0, FERROR=1, FINFO=2, FLOG=3};
+
+#include "errcode.h"
 
 #include "config.h"
 
@@ -69,6 +76,13 @@
 #endif
 
 #include <sys/types.h>
+
+#ifdef HAVE_GETOPT_LONG
+#include <getopt.h>
+#else
+#include "lib/getopt.h"
+#endif
+
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
@@ -91,10 +105,6 @@
 #include <string.h>
 #endif
 
-#ifdef HAVE_COMPAT_H
-#include <compat.h>
-#endif
-
 #ifdef HAVE_MALLOC_H
 #include <malloc.h>
 #endif
@@ -140,10 +150,6 @@
 #endif
 #include <errno.h>
 
-#ifdef HAVE_MMAP
-#include <sys/mman.h>
-#endif
-
 #ifdef HAVE_UTIME_H
 #include <utime.h>
 #endif
@@ -165,13 +171,7 @@
 #include "lib/fnmatch.h"
 #endif
 
-#ifdef HAVE_GETOPT_LONG
-#include <getopt.h>
-#else
-#include "lib/getopt.h"
-#endif
-
-#ifdef HAVE_GLOB
+#ifdef HAVE_GLOB_H
 #include <glob.h>
 #endif
 
@@ -186,14 +186,26 @@
 #include <syslog.h>
 #include <sys/file.h>
 
-#ifndef S_IFLNK
-#define S_IFLNK  0120000
+#if HAVE_DIRENT_H
+# include <dirent.h>
+#else
+# define dirent direct
+# if HAVE_SYS_NDIR_H
+#  include <sys/ndir.h>
+# endif
+# if HAVE_SYS_DIR_H
+#  include <sys/dir.h>
+# endif
+# if HAVE_NDIR_H
+#  include <ndir.h>
+# endif
 #endif
 
-#ifndef S_ISLNK
-#define S_ISLNK(mode) (((mode) & S_IFLNK) == S_IFLNK)
+#ifdef HAVE_COMPAT_H
+#include <compat.h>
 #endif
 
+
 #define BOOL int
 
 #ifndef uchar
@@ -213,6 +225,10 @@
 #define int32 long
 #elif (SIZEOF_SHORT == 4)
 #define int32 short
+#else
+/* I hope this works */
+#define int32 int
+#define LARGE_INT32
 #endif
 #endif
 
@@ -241,6 +257,12 @@
 #define NO_INT64
 #endif
 
+#if HAVE_SHORT_INO_T
+#define INO_T uint32
+#else
+#define INO_T ino_t
+#endif
+
 #ifndef MIN
 #define MIN(a,b) ((a)<(b)?(a):(b))
 #endif
@@ -249,6 +271,10 @@
 #define MAX(a,b) ((a)>(b)?(a):(b))
 #endif
 
+#ifndef MAXHOSTNAMELEN
+#define MAXHOSTNAMELEN 256
+#endif
+
 /* the length of the md4 checksum */
 #define MD4_SUM_LENGTH 16
 #define SUM_LENGTH 16
@@ -266,7 +292,7 @@ struct file_struct {
 	time_t modtime;
 	OFF_T length;
 	mode_t mode;
-	ino_t inode;
+	INO_T inode;
 	dev_t dev;
 	dev_t rdev;
 	uid_t uid;
@@ -278,18 +304,29 @@ struct file_struct {
 	char *sum;
 };
 
+
+#define ARENA_SIZE	(32 * 1024)
+
+struct string_area {
+	char *base;
+	char *end;
+	char *current;
+	struct string_area *next;
+};
+
 struct file_list {
-  int count;
-  int malloced;
-  struct file_struct **files;
+	int count;
+	int malloced;
+	struct file_struct **files;
+	struct string_area *string_area;
 };
 
 struct sum_buf {
-  OFF_T offset;			/* offset in file of this chunk */
-  int len;			/* length of chunk of file */
-  int i;			/* index of this chunk */
-  uint32 sum1;	                /* simple checksum */
-  char sum2[SUM_LENGTH];	/* checksum  */
+	OFF_T offset;		/* offset in file of this chunk */
+	int len;		/* length of chunk of file */
+	int i;			/* index of this chunk */
+	uint32 sum1;	        /* simple checksum */
+	char sum2[SUM_LENGTH];	/* checksum  */
 };
 
 struct sum_struct {
@@ -301,11 +338,34 @@ struct sum_struct {
 };
 
 struct map_struct {
-	char *map,*p;
+	char *p;
 	int fd,p_size,p_len;
-	OFF_T size, p_offset;
+	OFF_T file_size, p_offset, p_fd_offset;
 };
 
+struct exclude_struct {
+	char *orig;
+	char *pattern;
+	int regular_exp;
+	int fnmatch_flags;
+	int include;
+	int directory;
+	int local;
+};
+
+struct stats {
+	int64 total_size;
+	int64 total_transferred_size;
+	int64 total_written;
+	int64 total_read;
+	int64 literal_data;
+	int64 matched_data;
+	int flist_size;
+	int num_files;
+	int num_transferred_files;
+};
+
+
 /* we need this function because of the silly way in which duplicate
    entries are handled in the file lists - we can't change this
    without breaking existing versions */
@@ -315,25 +375,10 @@ static inline int flist_up(struct file_list *flist, int i)
 	return i;
 }
 
-#if HAVE_DIRENT_H
-# include <dirent.h>
-#else
-# define dirent direct
-# if HAVE_SYS_NDIR_H
-#  include <sys/ndir.h>
-# endif
-# if HAVE_SYS_DIR_H
-#  include <sys/dir.h>
-# endif
-# if HAVE_NDIR_H
-#  include <ndir.h>
-# endif
-#endif
-
 #include "byteorder.h"
 #include "version.h"
 #include "proto.h"
-#include "md4.h"
+#include "lib/mdfour.h"
 
 #if !HAVE_STRERROR
 extern char *sys_errlist[];
@@ -349,14 +394,6 @@ extern char *sys_errlist[];
 extern int errno;
 #endif
 
-#ifndef HAVE_BCOPY
-#define bcopy(src,dest,n) memcpy(dest,src,n)
-#endif
-
-#ifndef HAVE_BZERO
-#define bzero(buf,n) memset(buf,0,n)
-#endif
-
 #define SUPPORT_LINKS HAVE_READLINK
 #define SUPPORT_HARD_LINKS HAVE_LINK
 
@@ -386,6 +423,18 @@ extern int errno;
 #define S_IWUSR 0200
 #endif
 
+#ifndef _S_IFMT
+#define _S_IFMT        0170000
+#endif
+
+#ifndef _S_IFLNK
+#define _S_IFLNK  0120000
+#endif
+
+#ifndef S_ISLNK
+#define S_ISLNK(mode) (((mode) & (_S_IFMT)) == (_S_IFLNK))
+#endif
+
 #ifndef S_ISBLK
 #define S_ISBLK(mode) (((mode) & (_S_IFMT)) == (_S_IFBLK))
 #endif
@@ -418,6 +467,51 @@ extern int errno;
 #define S_ISREG(mode) (((mode) & (_S_IFMT)) == (_S_IFREG))
 #endif
 
+/* work out what fcntl flag to use for non-blocking */
+#ifdef O_NONBLOCK
+# define NONBLOCK_FLAG O_NONBLOCK
+#elif defined(SYSV)
+# define NONBLOCK_FLAG O_NDELAY
+#else 
+# define NONBLOCK_FLAG FNDELAY
+#endif
+
 
 #define IS_DEVICE(mode) (S_ISCHR(mode) || S_ISBLK(mode) || S_ISSOCK(mode) || S_ISFIFO(mode))
 
+#ifndef ACCESSPERMS
+#define ACCESSPERMS 0777
+#endif
+/* Initial mask on permissions given to temporary files.  Mask off setuid
+     bits and group access because of potential race-condition security
+     holes, and mask other access because mode 707 is bizarre */
+#define INITACCESSPERMS 0700
+
+/* handler for null strings in printf format */
+#define NS(s) ((s)?(s):"<NULL>")
+
+/* use magic gcc attributes to catch format errors */
+ void rprintf(enum logcode , const char *, ...)
+#ifdef __GNUC__
+     __attribute__ ((format (printf, 2, 3)))
+#endif
+;
+
+#ifdef REPLACE_INET_NTOA
+#define inet_ntoa rep_inet_ntoa
+#endif
+
+
+#ifndef HAVE_STRLCPY
+size_t strlcpy(char *d, const char *s, size_t bufsize);
+#endif
+
+#ifndef HAVE_STRLCAT
+size_t strlcat(char *d, const char *s, size_t bufsize);
+#endif
+
+#ifndef WEXITSTATUS
+#define	WEXITSTATUS(stat)	((int)(((stat)>>8)&0xFF))
+#endif
+
+#define exit_cleanup(code) _exit_cleanup(code, __FILE__, __LINE__)

rsync.yo

@@ -1,17 +1,19 @@
-mailto(rsync-bugs@samba.anu.edu.au)
-manpage(rsync)(1)(13 May 1998)()()
+mailto(rsync-bugs@samba.org)
+manpage(rsync)(1)(1 Mar 1999)()()
 manpagename(rsync)(faster, flexible replacement for rcp)
 manpagesynopsis()
 
-rsync [options] [user@]host:path path
+rsync [OPTION]... SRC [SRC]... [USER@]HOST:DEST
 
-rsync [options] path [user@]host:path
+rsync [OPTION]... [USER@]HOST:SRC DEST
 
-rsync [options] path path
+rsync [OPTION]... SRC [SRC]... DEST
 
-rsync [options] [user@]host::path path
+rsync [OPTION]... [USER@]HOST::SRC [DEST]
 
-rsync [options] path [user@]host::path
+rsync [OPTION]... SRC [SRC]... [USER@]HOST::DEST
+
+rsync [OPTION]... rsync://[USER@]HOST[:PORT]/SRC [DEST]
 
 manpagedescription()
 
@@ -40,7 +42,7 @@ itemize(
 
 manpagesection(GENERAL)
 
-There are five different ways of using rsync. They are:
+There are six different ways of using rsync. They are:
 
 itemize(
 	it() for copying local files. This is invoked when neither
@@ -52,20 +54,24 @@ itemize(
 	single : separator.
 
 	it() for copying from a remote machine to the local machine
-	using a remote shell program. This is invoked when the local path
+	using a remote shell program. This is invoked when the source
 	contains a : separator.
 
 	it() for copying from a remote rsync server to the local
 	machine. This is invoked when the source path contains a ::
-	separator. 
+	separator or a rsync:// URL.
 
 	it() for copying from the local machine to a remote rsync
 	server. This is invoked when the destination path contains a ::
 	separator. 
+
+	it() for listing files on a remote machine. This is done the
+	same way as rsync transfers except that you leave off the
+	local destination.  
 )
 
-Note that in all cases at least one of the source and destination
-paths must be local.
+Note that in all cases (other than listing) at least one of the source
+and destination paths must be local.
 
 manpagesection(SETUP)
 
@@ -75,12 +81,15 @@ Once installed you can use rsync to any machine that you can use rsh
 to.  rsync uses rsh for its communications, unless both the source and
 destination are local.
 
-You can also specify a alternative to rsh, by either using the -e
+You can also specify an alternative to rsh, by either using the -e
 command line option, or by setting the RSYNC_RSH environment variable.
 
 One common substitute is to use ssh, which offers a high degree of
 security.
 
+Note that rsync must be installed on both the source and destination
+machines. 
+
 manpagesection(USAGE)
 
 You use rsync in the same way you use rcp. You must specify a source
@@ -98,18 +107,18 @@ differences. See the tech report for details.
 
 quote(rsync -avz foo:src/bar /data/tmp)
 
-recursively transfer all files from the directory src/bar on the
+this would recursively transfer all files from the directory src/bar on the
 machine foo into the /data/tmp/bar directory on the local machine. The
 files are transferred in "archive" mode, which ensures that symbolic
 links, devices, attributes, permissions, ownerships etc are preserved
-in the transfer.  Additionally compression will be used to reduce the
+in the transfer.  Additionally, compression will be used to reduce the
 size of data portions of the transfer.
 
 quote(rsync -avz foo:src/bar/ /data/tmp)
 
-With a trailing slash on the source this behavior changes to transfer
+a trailing slash on the source changes this behavior to transfer
 all files from the directory src/bar on the machine foo into the
-/data/tmp/.  With a trailing / on a source name it means "copy the
+/data/tmp/.  A trailing / on a source name means "copy the
 contents of this directory".  Without a trailing slash it means "copy
 the directory". This difference becomes particularly important when
 using the --delete option.
@@ -118,6 +127,11 @@ You can also use rsync in local-only mode, where both the source and
 destination don't have a ':' in the name. In this case it behaves like
 an improved copy command.
 
+quote(rsync somehost.mydomain.com::)
+
+this would list all the anonymous rsync modules available on the host
+somehost.mydomain.com.  (See the following section for more details.)
+
 
 manpagesection(CONNECTING TO AN RSYNC SERVER)
 
@@ -125,7 +139,12 @@ It is also possible to use rsync without using rsh or ssh as the
 transport. In this case you will connect to a remote rsync server
 running on TCP port 873. 
 
-Using rsync in this was is the same as using it with rsh or ssh except
+You may establish the connetcion via a web proxy by setting the
+environment variable RSYNC_PROXY to a hostname:port pair pointing to
+your web proxy. Note that your web proxy must allow proxying to port
+873, this must be configured in your proxy servers ruleset.
+
+Using rsync in this way is the same as using it with rsh or ssh except
 that:
 
 itemize(
@@ -133,16 +152,23 @@ itemize(
 	separate the hostname from the path. 
 
 	it() the remote server may print a message of the day when you
-	connect
+	connect.
 
 	it() if you specify no path name on the remote server then the
 	list of accessible paths on the server will be shown.
+
+	it() if you specify no local destination then a listing of the
+	specified files on the remote server is provided.
 )
 
 Some paths on the remote server may require authentication. If so then
 you will receive a password prompt when you connect. You can avoid the
 password prompt by setting the environment variable RSYNC_PASSWORD to
-the password you want to use. This may be useful when scripting rsync.
+the password you want to use or using the --password-file option. This
+may be useful when scripting rsync.
+
+WARNING: On some systems environment variables are visible to all
+users. On those systems using --password-file is recommended.
 
 manpagesection(RUNNING AN RSYNC SERVER)
 
@@ -154,8 +180,8 @@ manpagesection(EXAMPLES)
 
 Here are some examples of how I use rsync.
 
-To backup my wife's home directory, which consists of large MS word
-files and mail folders I use a cron job that runs
+To backup my wife's home directory, which consists of large MS Word
+files and mail folders, I use a cron job that runs
 
 quote(rsync -Cavz . arvidsjaur:backup)
 
@@ -184,11 +210,81 @@ quote(rsync -az -e ssh --delete ~ftp/pub/samba/ nimbus:"~ftp/pub/tridge/samba")
 
 this is launched from cron every few hours.
 
+manpagesection(OPTIONS SUMMARY)
+
+Here is a short summary of the options available in rsync. Please refer
+to the detailed description below for a complete description.
+
+verb(
+ -v, --verbose               increase verbosity
+ -q, --quiet                 decrease verbosity
+ -c, --checksum              always checksum
+ -a, --archive               archive mode
+ -r, --recursive             recurse into directories
+ -R, --relative              use relative path names
+ -b, --backup                make backups (default ~ suffix)
+     --backup-dir=DIR        put backups in the specified directory
+     --suffix=SUFFIX         override backup suffix
+ -u, --update                update only (don't overwrite newer files)
+ -l, --links                 preserve soft links
+ -L, --copy-links            treat soft links like regular files
+     --copy-unsafe-links     copy links outside the source tree
+     --safe-links            ignore links outside the destination tree
+ -H, --hard-links            preserve hard links
+ -p, --perms                 preserve permissions
+ -o, --owner                 preserve owner (root only)
+ -g, --group                 preserve group
+ -D, --devices               preserve devices (root only)
+ -t, --times                 preserve times
+ -S, --sparse                handle sparse files efficiently
+ -n, --dry-run               show what would have been transferred
+ -W, --whole-file            copy whole files, no incremental checks
+ -x, --one-file-system       don't cross filesystem boundaries
+ -B, --block-size=SIZE       checksum blocking size (default 700)
+ -e, --rsh=COMMAND           specify rsh replacement
+     --rsync-path=PATH       specify path to rsync on the remote machine
+ -C, --cvs-exclude           auto ignore files in the same way CVS does
+     --existing              only update files that already exist
+     --delete                delete files that don't exist on the sending side
+     --delete-excluded       also delete excluded files on the receiving side
+     --delete-after          delete after transferring, not before
+     --ignore-errors         delete even if there are IO errors
+     --max-delete=NUM        don't delete more than NUM files
+     --partial               keep partially transferred files
+     --force                 force deletion of directories even if not empty
+     --numeric-ids           don't map uid/gid values by user/group name
+     --timeout=TIME          set IO timeout in seconds
+ -I, --ignore-times          don't exclude files that match length and time
+     --size-only             only use file size when determining if a file should be transferred
+ -T  --temp-dir=DIR          create temporary files in directory DIR
+     --compare-dest=DIR      also compare destination files relative to DIR
+ -P                          equivalent to --partial --progress
+ -z, --compress              compress file data
+     --exclude=PATTERN       exclude files matching PATTERN
+     --exclude-from=FILE     exclude patterns listed in FILE
+     --include=PATTERN       don't exclude files matching PATTERN
+     --include-from=FILE     don't exclude patterns listed in FILE
+     --version               print version number
+     --daemon                run as a rsync daemon
+     --address               bind to the specified address
+     --config=FILE           specify alternate rsyncd.conf file
+     --port=PORT             specify alternate rsyncd port number
+     --blocking-io           use blocking IO for the remote shell
+     --stats                 give some file transfer stats
+     --progress              show progress during transfer
+     --log-format=FORMAT     log file transfers using specified format
+     --password-file=FILE    get password from FILE
+     --bwlimit=KBPS          limit I/O bandwidth, KBytes per second
+ -h, --help                  show this help screen
+)
+
 manpageoptions()
 
 rsync uses the GNU long options package. Many of the command line
 options have two variants, one short and one long.  These are shown
-below separated by commas. Some options only have a long variant.
+below, separated by commas. Some options only have a long variant.
+The '=' for options that take a parameter is optional; whitespace
+can be used instead.
 
 startdit()
 dit(bf(-h, --help)) Print a short help page describing the options
@@ -197,33 +293,47 @@ available in rsync
 dit(bf(--version)) print the rsync version number and exit
 
 dit(bf(-v, --verbose)) This option increases the amount of information you
-are given during the transfer.  By default rsync works silently. A
+are given during the transfer.  By default, rsync works silently. A
 single -v will give you information about what files are being
 transferred and a brief summary at the end. Two -v flags will give you
 information on what files are being skipped and slightly more
 information at the end. More than two -v flags should only be used if
-you are debugging rsync
+you are debugging rsync.
+
+dit(bf(-q, --quiet)) This option decreases the amount of information you
+are given during the transfer, notably suppressing information messages
+from the remote server. This flag is useful when invoking rsync from
+cron.
 
 dit(bf(-I, --ignore-times)) Normally rsync will skip any files that are
 already the same length and have the same time-stamp. This option turns
 off this behavior.
 
+dit(bf(--size-only)) Normally rsync will skip any files that are
+already the same length and have the same time-stamp. With the
+--size-only option files will be skipped if they have the same size,
+regardless of timestamp. This is useful when starting to use rsync
+after using another mirroring system which may not preserve timestamps
+exactly.
+
 dit(bf(-c, --checksum)) This forces the sender to checksum all files using
 a 128-bit MD4 checksum before transfer. The checksum is then
 explicitly checked on the receiver and any files of the same name
 which already exist and have the same checksum and size on the
 receiver are skipped.  This option can be quite slow.
 
-dit(bf(-a, --archive)) This is equivalent to -rlptDog. It is a quick way
-of saying I want recursion and want to preserve everything.
+dit(bf(-a, --archive)) This is equivalent to -rlptgoD. It is a quick way
+of saying you want recursion and want to preserve everything.
 
-dit(bf(-r, --recursive)) This tells rsync to copy directories recursively
+dit(bf(-r, --recursive)) This tells rsync to copy directories
+recursively. If you don't specify this then rsync won't copy
+directories at all.
 
 dit(bf(-R, --relative)) Use relative paths. This means that the full path
 names specified on the command line are sent to the server rather than
 just the last parts of the filenames. This is particularly useful when
-you want to sent several different directories at the same time. For
-example if you used the command
+you want to send several different directories at the same time. For
+example, if you used the command
 
 verb(rsync foo/bar/foo.c remote:/tmp/)
 
@@ -239,16 +349,33 @@ dit(bf(-b, --backup)) With this option preexisting destination files are
 renamed with a ~ extension as each file is transferred.  You can
 control the backup suffix using the --suffix option.
 
+dit(bf(--backup-dir=DIR)) In combination with the --backup option, this
+tells rsync to store all backups in the specified directory. This is
+very useful for incremental backups.
+
+dit(bf(--suffix=SUFFIX)) This option allows you to override the default
+backup suffix used with the -b option. The default is a ~.
+
 dit(bf(-u, --update)) This forces rsync to skip any files for which the
 destination file already exists and has a date later than the source
 file.
 
 dit(bf(-l, --links)) This tells rsync to recreate symbolic links on the
 remote system  to  be the same as the local system. Without this
-option all symbolic links are skipped.
+option, all symbolic links are skipped.
 
 dit(bf(-L, --copy-links)) This tells rsync to treat symbolic links just
-like  ordinary files.
+like ordinary files.
+
+dit(bf(--copy-unsafe-links)) This tells rsync to treat symbolic links that
+point outside the source tree like ordinary files.  Absolute symlinks are
+also treated like ordinary files, and so are any symlinks in the source
+path itself when --relative is used.
+
+dit(bf(--safe-links)) This tells rsync to ignore any symbolic links
+which point outside the destination tree. All absolute symlinks are
+also ignored. Using this option in conjunction with --relative may
+give unexpected results. 
 
 dit(bf(-H, --hard-links)) This tells rsync to recreate hard  links  on
 the  remote system  to  be the same as the local system. Without this
@@ -268,17 +395,26 @@ permissions to be the same as the local permissions.
 
 dit(bf(-o, --owner)) This option causes rsync to update the  remote  owner
 of the  file to be the same as the local owner. This is only available
-to the super-user.
+to the super-user.  Note that if the source system is a daemon using chroot,
+the --numeric-ids option is implied because the source system cannot get
+access to the usernames.
 
 dit(bf(-g, --group)) This option causes rsync to update the  remote  group
-of the file to be the same as the local group.
+of the file to be the same as the local group.  If the receving system is
+not running as the super-user, only groups that the receiver is a member of
+will be preserved (by group name, not group id number).
 
 dit(bf(-D, --devices)) This option causes rsync to transfer character and
 block device information to the remote system to recreate these
 devices. This option is only available to the super-user.
 
 dit(bf(-t, --times)) This tells rsync to transfer modification times along
-with the files and update them on the remote system
+with the files and update them on the remote system.  Note that if this
+option is not used, the optimization that excludes files that have not been
+modified cannot be effective; in other words, a missing -t or -a will
+cause the next transfer to behave as if it used -I, and all files will have
+their checksums compared and show up in log messages even if they haven't
+changed.
 
 dit(bf(-n, --dry-run)) This tells rsync to not do any file transfers,
 instead it will just report the actions it would have taken.
@@ -286,70 +422,94 @@ instead it will just report the actions it would have taken.
 dit(bf(-S, --sparse)) Try to handle sparse files efficiently so they take
 up less space on the destination.
 
+NOTE: Don't use this option when the destination is a Solaris "tmpfs"
+filesystem. It doesn't seem to handle seeks over null regions
+correctly and ends up corrupting the files.
+
 dit(bf(-x, --one-file-system)) This tells rsync not to cross filesystem
 boundaries  when recursing.  This  is useful for transferring the
 contents of only one filesystem.
 
+dit(bf(--existing)) This tells rsync not to create any new files -
+only update files that already exist on the destination.
+
+dit(bf(--max-delete=NUM)) This tells rsync not to delete more than NUM
+files or directories. This is useful when mirroring very large trees
+to prevent disasters.
+
 dit(bf(--delete)) This tells rsync to delete any files on the receiving
-side that aren't on the sending side. This option can be dangerous if
-used incorrectly!
+side that aren't on the sending side.   Files that are excluded from
+transfer are excluded from being deleted unless you use --delete-excluded.
 
-It is a very good idea to run first using the dry run option (-n) to
-see what files would be deleted to make sure important files aren't
-listed.
+This option has no effect if directory recursion is not selected.
 
-rsync 1.6.4 changed the behavior of --delete to make it less
-dangerous.  rsync now only scans directories on the receiving side
-that are explicitly transferred from the sending side.  Only files in
-these directories are deleted.
+This option can be dangerous if used incorrectly!  It is a very good idea
+to run first using the dry run option (-n) to see what files would be
+deleted to make sure important files aren't listed.
 
-Still, it is probably easy to get burnt with this option.  The moral
-of the story is to use the -n option until you get used to the
-behavior of --delete.
+If the sending side detects any IO errors then the deletion of any
+files at the destination will be automatically disabled. This is to
+prevent temporary filesystem failures (such as NFS errors) on the
+sending side causing a massive deletion of files on the
+destination. 
 
-NOTE: It also may delete files on the destination if the sending side
-can't open them or stat them. This is a bug that hopefully will be
-fixed in a future release.
+dit(bf(--delete-excluded)) In addition to deleting the files on the
+receiving side that are not on the sending side, this tells rsync to also
+delete any files on the receiving side that are excluded (see --exclude).
+
+dit(bf(--delete-after)) By default rsync does file deletions before
+transferring files to try to ensure that there is sufficient space on
+the receiving filesystem. If you want to delete after transferring
+then use the --delete-after switch.
 
 dit(bf(--force)) This options tells rsync to delete directories even if
 they are not empty.  This applies to both the --delete option and to
 cases where rsync tries to copy a normal file but the destination
-contains a directory of the same name. Normally rsync will refuse to
-do a recursive directory deletion in such cases, by using --force
-the recursive deletion will be done.
+contains a directory of the same name. 
 
-Use this option with caution!
+Since this option was added, deletions were reordered to be done depth-first
+so it is hardly ever needed anymore except in very obscure cases.
 
-dit(bf(-B , --block_size BLOCKSIZE)) This controls the block size used in
+dit(bf(-B , --block_size=BLOCKSIZE)) This controls the block size used in
 the rsync algorithm. See the technical report for details.
 
-dit(bf(-e, --rsh COMMAND)) This option allows you to choose an alternative
+dit(bf(-e, --rsh=COMMAND)) This option allows you to choose an alternative
 remote shell program to use for communication between the local and
-remote copies of rsync. By default rsync will use rsh, but you may
+remote copies of rsync. By default, rsync will use rsh, but you may
 like to instead use ssh because of its high security.
 
 You can also choose the remote shell program using the RSYNC_RSH
 environment variable.
 
-dit(bf(--rsync-path PATH)) Use this to specify the path to the copy of
-rsync on the remote machine. Useful when its not in your path.
+dit(bf(--rsync-path=PATH)) Use this to specify the path to the copy of
+rsync on the remote machine. Useful when it's not in your path. Note
+that this is the full path to the binary, not just the directory that
+the binary is in.
 
-dit(bf(--exclude FILE)) This option allows you to selectively exclude
+dit(bf(--exclude=PATTERN)) This option allows you to selectively exclude
 certain files from the list of files to be transferred. This is most
 useful in combination with a recursive transfer.
 
-The option FILE can either be a file name or a shell wildcard
-expression. If it is a directory name then rsync will not recurse into
-directories of that name.
-
 You may use as many --exclude options on the command line as you like
 to build up the list of files to exclude.
 
-If the filename is a single ! then the exclude list is reset.
+See the section on exclude patterns for information on the syntax of 
+this option.
 
-dit(bf(--exclude-from FILE)) This option is similar to the --exclude
+dit(bf(--exclude-from=FILE)) This option is similar to the --exclude
 option, but instead it adds all filenames listed in the file FILE to
-the exclude list.
+the exclude list.  Blank lines in FILE and lines starting with ';' or '#'
+are ignored.
+
+dit(bf(--include=PATTERN)) This option tells rsync to not exclude the
+specified pattern of filenames. This is useful as it allows you to
+build up quite complex exclude/include rules.
+
+See the section of exclude patterns for information on the syntax of 
+this option.
+
+dit(bf(--include-from=FILE)) This specifies a list of include patterns
+from a file.
 
 dit(bf(-C, --cvs-exclude)) This is a useful shorthand for excluding a
 broad range of files that you often don't want to transfer between
@@ -368,14 +528,11 @@ files listed in the CVSIGNORE environment variable (space delimited).
 Finally in each directory any files listed in the .cvsignore file in
 that directory are added to the list.
 
-dit(bf(--suffix SUFFIX)) This option allows you to override the default
-backup suffix used with the -b option. The default is a ~.
-
-dit(bf(--csum-length LENGTH)) By default the primary checksum used in
+dit(bf(--csum-length=LENGTH)) By default the primary checksum used in
 rsync is a very strong 16 byte MD4 checksum. In most cases you will
 find that a truncated version of this checksum is quite efficient, and
 this will decrease the size of the checksum data sent over the link,
-making things faster.
+making things faster. 
 
 You can choose the number of bytes in the truncated checksum using the
 --csum-length option. Any value less than or equal to 16 is valid.
@@ -385,11 +542,28 @@ with an incorrect target file. The risk with a value of 16 is
 microscopic and can be safely ignored (the universe will probably end
 before it fails) but with smaller values the risk is higher.
 
-dit(bf(-T, --temp-dir DIR)) This options instructs rsync to use DIR as a
-scratch directory when creating a temporary copies of the files
+Current versions of rsync actually use an adaptive algorithm for the
+checksum length by default, using a 16 byte file checksum to determine
+if a 2nd pass is required with a longer block checksum. Only use this
+option if you have read the source code and know what you are doing.
+
+dit(bf(-T, --temp-dir=DIR)) This option instructs rsync to use DIR as a
+scratch directory when creating temporary copies of the files
 transferred on the receiving side.  The default behavior is to create
 the temporary files in the receiving directory.
 
+dit(bf(--compare-dest=DIR)) This option instructs rsync to use DIR as an
+additional directory to compare destination files against when doing
+transfers.  This is useful for doing transfers to a new destination while
+leaving existing files intact, and then doing a flash-cutover when all
+files have been successfully transferred (for example by moving directories
+around and removing the old directory, although this requires also doing
+the transfer with -I to avoid skipping files that haven't changed).  This
+option increases the usefulness of --partial because partially transferred
+files will remain in the new temporary destination until they have a chance
+to be completed.  If DIR is a relative path, it is relative to the
+destination directory.
+
 dit(bf(-z, --compress)) With this option, rsync compresses any data from
 the source file(s) which it sends to the destination machine.  This
 option is useful on slow links.  The compression method used is the
@@ -406,15 +580,16 @@ at both ends.
 
 By default rsync will use the user name and group name to determine
 what ownership to give files. The special uid 0 and the special group
-0 and never mapped via user/group names even if the --numeric-ids
+0 are never mapped via user/group names even if the --numeric-ids
 option is not specified.
 
-If a user or group name does not exist on the destination system then
-the numeric id from the source system is used instead.
+If the source system is a daemon using chroot, or if a user or group name
+does not exist on the destination system, then the numeric id from the
+source system is used instead.
 
-dit(bf(--timeout)) This option allows you to set a maximum IO timeout in
-seconds. If no data is transferred for the specified time then rsync
-will exit. The default is 0, which means no timeout.
+dit(bf(--timeout=TIMEOUT)) This option allows you to set a maximum IO
+timeout in seconds. If no data is transferred for the specified time
+then rsync will exit. The default is 0, which means no timeout.
 
 dit(bf(--daemon)) This tells rsync that it is to run as a rsync
 daemon. If standard input is a socket then rsync will assume that it
@@ -424,12 +599,204 @@ config file (/etc/rsyncd.conf) on each connect made by a client and
 respond to requests accordingly. See the rsyncd.conf(5) man page for more
 details. 
 
-dit(bf(--config FILE)) This specifies an alternate config file than
+dit(bf(--address)) By default rsync will bind to the wildcard address
+when run as a daemon with the --daemon option or when connecting to a
+rsync server. The --address option allows you to specify a specific IP
+address (or hostname) to bind to. This makes virtual hosting possible
+in conjunction with the --config option.
+
+dit(bf(--config=FILE)) This specifies an alternate config file than
 the default /etc/rsyncd.conf. This is only relevant when --daemon is
 specified. 
 
-dit(bf(--port PORT)) This specifies an alternate TCP port number to use
-rather than the default port 873. 
+dit(bf(--port=PORT)) This specifies an alternate TCP port number to use
+rather than the default port 873.
+
+dit(bf(--blocking-io)) This specifies whether rsync will use blocking
+IO when launching a remote shell transport. You may find this is
+needed for some remote shells that can't handle the default
+non-blocking IO.
+
+dit(bf(--log-format=FORMAT)) This allows you to specify exactly what the
+rsync client logs to stdout on a per-file basis. The log format is
+specified using the same format conventions as the log format option in
+rsyncd.conf.
+
+dit(bf(--stats)) This tells rsync to print a verbose set of statistics
+on the file transfer, allowing you to tell how effective the rsync
+algorithm is for your data.
+
+dit(bf(--partial)) By default, rsync will delete any partially
+transferred file if the transfer is interrupted. In some circumstances
+it is more desirable to keep partially transferred files. Using the
+--partial option tells rsync to keep the partial file which should
+make a subsequent transfer of the rest of the file much faster.
+
+dit(bf(--progress)) This option tells rsync to print information
+showing the progress of the transfer. This gives a bored user
+something to watch.
+
+This option is normally combined with -v. Using this option without
+the -v option will produce weird results on your display.
+
+dit(bf(-P)) The -P option is equivalent to --partial --progress. I
+found myself typing that combination quite often so I created an
+option to make it easier.
+
+dit(bf(--password-file)) This option allows you to provide a password
+in a file for accessing a remote rsync server. Note that this option
+is only useful when accessing a rsync server using the built in
+transport, not when using a remote shell as the transport. The file
+must not be world readable. It should contain just the password as a
+single line.
+
+dit(bf(--bwlimit=KBPS)) This option allows you to specify a maximum
+transfer rate in kilobytes per second. This option is most effective when
+using rsync with large files (several megabytes and up). Due to the nature
+of rsync transfers, blocks of data are sent, then if rsync determines the
+transfer was too fast, it will wait before sending the next data block. The
+result is an average transfer rate equalling the specified limit. A value
+of zero specifies no limit.
+
+enddit()
+
+manpagesection(EXCLUDE PATTERNS)
+
+The exclude and include patterns specified to rsync allow for flexible
+selection of which files to transfer and which files to skip.
+
+rsync builds a ordered list of include/exclude options as specified on
+the command line. When a filename is encountered, rsync checks the
+name against each exclude/include pattern in turn. The first matching
+pattern is acted on. If it is an exclude pattern than that file is
+skipped. If it is an include pattern then that filename is not
+skipped. If no matching include/exclude pattern is found then the
+filename is not skipped.
+
+Note that when used with -r (which is implied by -a), every subcomponent of
+every path is visited from top down, so include/exclude patterns get
+applied recursively to each subcomponent.
+
+Note also that the --include and --exclude options take one pattern
+each. To add multiple patterns use the --include-from and
+--exclude-from options or multiple --include and --exclude options. 
+
+The patterns can take several forms. The rules are:
+
+itemize(
+  it() if the pattern starts with a / then it is matched against the
+  start of the filename, otherwise it is matched against the end of
+  the filename.  Thus "/foo" would match a file called "foo" at the base of
+  the tree.  On the other hand, "foo" would match any file called "foo"
+  anywhere in the tree because the algorithm is applied recursively from
+  top down; it behaves as if each path component gets a turn at being the
+  end of the file name.
+
+  it() if the pattern ends with a / then it will only match a
+  directory, not a file, link or device.
+
+  it() if the pattern contains a wildcard character from the set
+  *?[ then expression matching is applied using the shell filename
+  matching rules. Otherwise a simple string match is used.
+
+  it() if the pattern includes a double asterisk "**" then all wildcards in
+  the pattern will match slashes, otherwise they will stop at slashes.
+
+  it() if the pattern contains a / (not counting a trailing /) then it
+  is matched against the full filename, including any leading
+  directory. If the pattern doesn't contain a / then it is matched
+  only against the final component of the filename.  Again, remember
+  that the algorithm is applied recursively so "full filename" can 
+  actually be any portion of a path.
+
+  it() if the pattern starts with "+ " (a plus followed by a space)
+  then it is always considered an include pattern, even if specified as
+  part of an exclude option. The "+ " part is discarded before matching.
+
+  it() if the pattern starts with "- " (a minus followed by a space)
+  then it is always considered an exclude pattern, even if specified as
+  part of an include option. The "- " part is discarded before matching.
+
+  it() if the pattern is a single exclamation mark ! then the current
+  exclude list is reset, removing all previous exclude patterns.
+)
+
+The +/- rules are most useful in exclude lists, allowing you to have a
+single exclude list that contains both include and exclude options.
+
+If you end an exclude list with --exclude '*', note that since the
+algorithm is applied recursively that unless you explicitly include
+parent directories of files you want to include then the algorithm
+will stop at the parent directories and never see the files below
+them.  To include all directories, use --include '*/' before the
+--exclude '*'.
+
+Here are some exclude/include examples:
+
+itemize(
+  it() --exclude "*.o" would exclude all filenames matching *.o
+  it() --exclude "/foo" would exclude a file in the base directory called foo
+  it() --exclude "foo/" would exclude any directory called foo
+  it() --exclude "/foo/*/bar" would exclude any file called bar two
+  levels below a base directory called foo
+  it() --exclude "/foo/**/bar" would exclude any file called bar two
+  or more levels below a base directory called foo
+  it() --include "*/" --include "*.c" --exclude "*" would include all 
+  directories and C source files
+  it() --include "foo/" --include "foo/bar.c" --exclude "*" would include
+  only foo/bar.c (the foo/ directory must be explicitly included or
+  it would be excluded by the "*")
+)
+
+manpagesection(DIAGNOSTICS)
+
+rsync occasionally produces error messages that may seem a little
+cryptic. The one that seems to cause the most confusion is "protocol
+version mismatch - is your shell clean?".
+
+This message is usually caused by your startup scripts or remote shell
+facility producing unwanted garbage on the stream that rsync is using
+for its transport. The way to diagnose this problem is to run your
+remote shell like this:
+
+verb(
+   rsh remotehost /bin/true > out.dat
+)
+       
+then look at out.dat. If everything is working correctly then out.dat
+should be a zero length file. If you are getting the above error from
+rsync then you will probably find that out.dat contains some text or
+data. Look at the contents and try to work out what is producing
+it. The most common cause is incorrectly configured shell startup
+scripts (such as .cshrc or .profile) that contain output statements
+for non-interactive logins.
+
+manpagesection(ENVIRONMENT VARIABLES)
+
+startdit()
+
+dit(bf(CVSIGNORE)) The CVSIGNORE environment variable supplements any
+ignore patterns in .cvsignore files. See the --cvs-exclude option for
+more details.
+
+dit(bf(RSYNC_RSH)) The RSYNC_RSH environment variable allows you to
+override the default shell used as the transport for rsync. This can
+be used instead of the -e option.
+
+dit(bf(RSYNC_PROXY)) The RSYNC_PROXY environment variable allows you to
+redirect your rsync client to use a web proxy when connecting to a
+rsync daemon. You should set RSYNC_PROXY to a hostname:port pair.
+
+dit(bf(RSYNC_PASSWORD)) Setting RSYNC_PASSWORD to the required
+password allows you to run authenticated rsync connections to a rsync
+daemon without user intervention. Note that this does not supply a
+password to a shell transport such as ssh.
+
+dit(bf(USER) or bf(LOGNAME)) The USER or LOGNAME environment variables
+are used to determine the default username sent to a rsync server.
+
+dit(bf(HOME)) The HOME environment variable is used to find the user's
+default .cvsignore file.
 
 enddit()
 
@@ -453,7 +820,7 @@ values
 see also the comments on the --delete option
 
 Please report bugs! The rsync bug tracking system is online at
-url(http://samba.anu.edu.au/rsync/)(http://samba.anu.edu.au/rsync/)
+url(http://rsync.samba.org/rsync/)(http://rsync.samba.org/rsync/)
 
 manpagesection(VERSION)
 This man page is current for version 2.0 of rsync
@@ -463,16 +830,16 @@ manpagesection(CREDITS)
 rsync is distributed under the GNU public license.  See the file
 COPYING for details.
 
-The primary ftp site for rsync is
-url(ftp://samba.anu.edu.au/pub/rsync)(ftp://samba.anu.edu.au/pub/rsync).
-
 A WEB site is available at
-url(http://samba.anu.edu.au/rsync/)(http://samba.anu.edu.au/rsync/)
+url(http://rsync.samba.org/)(http://rsync.samba.org/)
+
+The primary ftp site for rsync is
+url(ftp://rsync.samba.org/pub/rsync)(ftp://rsync.samba.org/pub/rsync).
 
 We would be delighted to hear from you if you like this program.
 
-This program uses the zlib compression library written by Jean-loup
-Gailly and Mark Adler.
+This program uses the excellent zlib compression library written by
+Jean-loup Gailly and Mark Adler.
 
 manpagesection(THANKS)
 
@@ -484,6 +851,6 @@ probably missed some people, my apologies if I have.
 manpageauthor()
 
 rsync was written by Andrew Tridgell and Paul Mackerras.  They may be
-contacted via email at tridge@samba.anu.edu.au and
+contacted via email at tridge@samba.org and
 Paul.Mackerras@cs.anu.edu.au
 

rsyncd.conf.yo

@@ -1,5 +1,5 @@
-mailto(rsync-bugs@samba.anu.edu.au)
-manpage(rsyncd.conf)(5)(13 May 1998)()()
+mailto(rsync-bugs@samba.org)
+manpage(rsyncd.conf)(5)(12 Feb 1999)()()
 manpagename(rsyncd.conf)(configuration file for rsync server)
 manpagesynopsis()
 
@@ -46,7 +46,7 @@ manpagesection(LAUNCHING THE RSYNC DAEMON)
 The rsync daemon is launched by specifying the --daemon option to
 rsync. The daemon must run with root privileges.
 
-You can launch it either via inetd or as a standalone daemon. If run
+You can launch it either via inetd or as a stand-alone daemon. If run
 as a daemon then just run the command "rsync --daemon" from a suitable
 startup script.
 
@@ -58,8 +58,9 @@ and a single line something like this to /etc/inetd.conf:
     
 quote(rsync   stream  tcp     nowait  root   /usr/bin/rsync rsyncd --daemon)
 
-You will then need to send inetd a HUP signal to tell it to reread its
-config file.
+Replace "/usr/bin/rsync" with the path to where you have rsync installed on
+your system.  You will then need to send inetd a HUP signal to tell it to
+reread its config file.
 
 Note that you should not send the rsync server a HUP signal to force
 it to reread the tt(/etc/rsyncd.conf). The file is re-read on each client
@@ -80,16 +81,13 @@ dit(bf(motd file)) The "motd file" option allows you to specify a
 usually contains site information and any legal notices. The default
 is no motd file.
 
-dit(bf(max connections)) The "max connections" option allows you to
-specify the maximum number of simultaneous connections you will allow
-to your rsync server. Any clients connecting when the maximum has
-been reached will receive a message telling them to try later. 
-The default is 0 which means no limit.
+dit(bf(log file)) The "log file" option tells the rsync daemon to log
+messages to that file rather than using syslog. This is particularly
+useful on systems (such as AIX) where syslog() doesn't work for
+chrooted programs.
 
-dit(bf(lock file)) The "lock file" option specifies the file to use to
-support the "max connections" option. The rsync server uses record
-locking on this file to ensure that the max connections limit is not
-exceeded. The default is tt(/var/run/rsyncd.lock).
+dit(bf(pid file)) The "pid file" option tells the rsync daemon to write
+its process id to that file.
 
 dit(bf(syslog facility)) The "syslog facility" option allows you to
 specify the syslog facility name to use when logging messages from the
@@ -123,9 +121,29 @@ that is displayed next to the module name when clients obtain a list
 of available modules. The default is no comment.
 
 dit(bf(path)) The "path" option specifies the directory in the servers
-filesystem to make available in this module. The rsync server will
-chroot to this path before starting the file transfer with the
-client. You must specify this option for each module in tt(/etc/rsyncd.conf).
+filesystem to make available in this module.  You must specify this option
+for each module in tt(/etc/rsyncd.conf).
+
+dit(bf(use chroot)) If "use chroot" is true, the rsync server will chroot
+to the "path" before starting the file transfer with the client.  This has
+the advantage of extra protection against possible implementation security
+holes, but it has the disadvantages of requiring super-user privileges and
+of not being able to follow symbolic links outside of the new root path
+when reading.  For writing when "use chroot" is false, for security reasons
+symlinks may only be relative paths pointing to other files within the
+root path, and leading slashes are removed from absolute paths.  The
+default for "use chroot" is true.
+
+dit(bf(max connections)) The "max connections" option allows you to
+specify the maximum number of simultaneous connections you will allow
+to this module of your rsync server. Any clients connecting when the
+maximum has been reached will receive a message telling them to try
+later.  The default is 0 which means no limit.
+
+dit(bf(lock file)) The "lock file" option specifies the file to use to
+support the "max connections" option. The rsync server uses record
+locking on this file to ensure that the max connections limit is not
+exceeded. The default is tt(/var/run/rsyncd.lock).
 
 dit(bf(read only)) The "read only" option determines whether clients
 will be able to upload files or not. If "read only" is true then any
@@ -139,18 +157,24 @@ setting this to false you can create hidden modules. The default is
 for modules to be listable.
 
 dit(bf(uid)) The "uid" option specifies the user name or user id that
-file transfers to and from that module should take place as. In
-combination with the "gid" option this determines what file
-permissions are available. The default is the user "nobody".
+file transfers to and from that module should take place as when the daemon
+was run as root. In combination with the "gid" option this determines what
+file permissions are available. The default is the user "nobody".
 
 dit(bf(gid)) The "gid" option specifies the group name or group id that
-file transfers to and from that module should take place as. This
-complements the "uid" option. The default is the group "nobody".
+file transfers to and from that module should take place as when the daemon
+was run as root. This complements the "uid" option. The default is the
+group "nobody".
 
 dit(bf(exclude)) The "exclude" option allows you to specify a space
 separated list of patterns to add to the exclude list. This is
 equivalent to the client specifying these patterns with the --exclude
-option. Note that this option is not designed with strong security in
+option except that the exclude list is not passed to the client and
+thus only apply on the server.  Only one "exclude" option may be
+specified, but you can use "-" and "+" before patterns to specify
+exclude/include.
+
+Note that this option is not designed with strong security in
 mind, it is quite possible that a client may find a way to bypass this
 exclude list. If you want to absolutely ensure that certain files
 cannot be accessed then use the uid/gid options in combination with
@@ -159,8 +183,24 @@ file permissions.
 dit(bf(exclude from)) The "exclude from" option specifies a filename
 on the server that contains exclude patterns, one per line. This is
 equivalent to the client specifying the --exclude-from option with a
-equivalent file. See also the note about security for the exclude
-option above.
+equivalent file except that the resulting exclude patterns are not
+passed to the client and thus only apply on the server. See also the
+note about security for the exclude option above.
+
+dit(bf(include)) The "include" option allows you to specify a space
+separated list of patterns which rsync should not exclude. This is
+equivalent to the client specifying these patterns with the --include
+option.  This is useful as it allows you to build up quite complex
+exclude/include rules.  Only one "include" option may be specified, but you
+can use "+" and "-" before patterns to switch include/exclude.
+
+See the section of exclude patterns in the rsync man page for information
+on the syntax of this option.
+
+dit(bf(include from)) The "include from" option specifies a filename
+on the server that contains include patterns, one per line. This is
+equivalent to the client specifying the --include-from option with a
+equivalent file.
 
 dit(bf(auth users)) The "auth users" option specifies a comma
 and space separated list of usernames that will be allowed to connect
@@ -182,10 +222,15 @@ can contain any characters but be warned that many operating systems
 limit the length of passwords that can be typed at the client end, so
 you may find that passwords longer than 8 characters don't work. 
 
-bf(You should make sure that the secrets file is not readable by anyone
-other than the system administrator.) There is no default for the
-"secrets file" option, you must choose a name (such as
-tt(/etc/rsyncd.secrets)).
+There is no default for the "secrets file" option, you must choose a name
+(such as tt(/etc/rsyncd.secrets)).
+
+dit(bf(strict modes)) The "strict modes" option determines whether or not 
+the permissions on the secrets file will be checked.  If "strict modes" is
+true, then the secrets file must not be readable by any user id other
+than the one that the rsync daemon is running under.  If "strict modes" is
+false, the check is not performed.  The default is true.  This option
+was added to accommodate rsync running on the Windows operating system.
 
 dit(bf(hosts allow)) The "hosts allow" option allows you to specify a
 list of patterns that are matched against a connecting clients
@@ -225,13 +270,88 @@ connect.
 
 The default is no "hosts allow" option, which means all hosts can connect.
 
-dit(bf(hosts allow)) The "hosts deny" option allows you to specify a
+dit(bf(hosts deny)) The "hosts deny" option allows you to specify a
 list of patterns that are matched against a connecting clients
 hostname and IP address. If the pattern matches then the connection is
 rejected. See the "hosts allow" option for more information.
 
 The default is no "hosts deny" option, which means all hosts can connect.
 
+dit(bf(ignore errors)) The "ignore errors" option tells rsyncd to
+ignore IO errors on the server when deciding whether to run the delete
+phase of the transfer. Normally rsync skips the --delete step if any
+IO errors have occurred in order to prevent disasterous deletion due
+to a temporary resource shortage or other IO error. In some cases this
+test is counter productive so you can use this option to turn off this
+behaviour. 
+
+dit(bf(ignore nonreadable)) This tells the rsync server to completely
+ignore files that are not readable by the user. This is useful for
+public archives that may have some non-readable files among the
+directories, and the sysadmin doesn't want those files to be seen at all.
+
+dit(bf(transfer logging)) The "transfer logging" option enables per-file 
+logging of downloads and uploads in a format somewhat similar to that
+used by ftp daemons. If you want to customize the log formats look at
+the log format option.
+
+dit(bf(log format)) The "log format" option allows you to specify the
+format used for logging file transfers when transfer logging is
+enabled. The format is a text string containing embedded single
+character escape sequences prefixed with a percent (%) character.
+
+The prefixes that are understood are:
+
+itemize(
+  it() %h for the remote host name
+  it() %a for the remote IP address
+  it() %l for the length of the file in bytes
+  it() %p for the process id of this rsync session
+  it() %o for the operation, which is either "send" or "recv"
+  it() %f for the filename
+  it() %P for the module path
+  it() %m for the module name
+  it() %t for the current date time
+  it() %u for the authenticated username (or the null string)
+  it() %b for the number of bytes actually transferred 
+  it() %c when sending files this gives the number of checksum bytes
+    received for this file
+)
+
+The default log format is "%o %h [%a] %m (%u) %f %l", and a "%t [%p] "
+is always added to the beginning when using the "log file" option.
+
+A perl script called rsyncstats to summarize this format is included
+in the rsync source code distribution.
+
+dit(bf(timeout)) The "timeout" option allows you to override the
+clients choice for IO timeout for this module. Using this option you
+can ensure that rsync won't wait on a dead client forever. The timeout
+is specified in seconds. A value of zero means no timeout and is the
+default. A good choice for anonymous rsync servers may be 600 (giving
+a 10 minute timeout).
+
+dit(bf(refuse options)) The "refuse options" option allows you to
+specify a space separated list of rsync command line options that will
+be refused by your rsync server.  The full names of the options must be
+used (i.e., you must use "checksum" not "c" to disable checksumming).  
+When an option is refused, the server prints an error message and exits.
+To prevent all compression, you can use "dont compress = *" (see below)
+instead of "refuse options = compress" to avoid returning an error to a
+client that requests compression.
+
+dit(bf(dont compress)) The "dont compress" option allows you to select
+filenames based on wildcard patterns that should not be compressed
+during transfer. Compression is expensive in terms of CPU usage so it
+is usually good to not try to compress files that won't compress well,
+such as already compressed files. 
+
+The "dont compress" option takes a space separated list of
+case-insensitive wildcard patterns. Any source filename matching one
+of the patterns will not be compressed during transfer.
+
+The default setting is verb(*.gz *.tgz *.zip *.z *.rpm *.deb *.iso *.bz2 *.tbz)
+
 enddit()
 
 manpagesection(AUTHENTICATION STRENGTH)
@@ -239,7 +359,7 @@ manpagesection(AUTHENTICATION STRENGTH)
 The authentication protocol used in rsync is a 128 bit MD4 based
 challenge response system. Although I believe that no one has ever
 demonstrated a brute-force break of this sort of system you should
-realise that this is not a "military strength" authentication system.
+realize that this is not a "military strength" authentication system.
 It should be good enough for most purposes but if you want really top
 quality security then I recommend that you run rsync over ssh.
 
@@ -267,8 +387,10 @@ A more sophisticated example would be:
 
 uid = nobody nl()
 gid = nobody nl()
+use chroot = no nl()
 max connections = 4 nl()
 syslog facility = local5 nl()
+pid file = /etc/rsyncd.pid
 
 verb([ftp]
         path = /var/ftp/pub
@@ -315,7 +437,7 @@ client. this means a client may be mystified as to why a transfer
 failed. The error will have been logged by syslog on the server.
 
 Please report bugs! The rsync bug tracking system is online at
-url(http://samba.anu.edu.au/rsync/)(http://samba.anu.edu.au/rsync/)
+url(http://rsync.samba.org/)(http://rsync.samba.org/)
 
 manpagesection(VERSION)
 This man page is current for version 2.0 of rsync
@@ -326,10 +448,10 @@ rsync is distributed under the GNU public license.  See the file
 COPYING for details.
 
 The primary ftp site for rsync is
-url(ftp://samba.anu.edu.au/pub/rsync)(ftp://samba.anu.edu.au/pub/rsync).
+url(ftp://rsync.samba.org/pub/rsync)(ftp://rsync.samba.org/pub/rsync).
 
 A WEB site is available at
-url(http://samba.anu.edu.au/rsync/)(http://samba.anu.edu.au/rsync/)
+url(http://rsync.samba.org/)(http://rsync.samba.org/)
 
 We would be delighted to hear from you if you like this program.
 
@@ -345,6 +467,6 @@ documentation!
 manpageauthor()
 
 rsync was written by Andrew Tridgell and Paul Mackerras.  They may be
-contacted via email at tridge@samba.anu.edu.au and
+contacted via email at tridge@samba.org and
 Paul.Mackerras@cs.anu.edu.au
 

sender.c

@@ -0,0 +1,230 @@
+/* 
+   Copyright (C) Andrew Tridgell 1996
+   Copyright (C) Paul Mackerras 1996
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "rsync.h"
+
+extern int verbose;
+extern int remote_version;
+extern int csum_length;
+extern struct stats stats;
+extern int io_error;
+extern int dry_run;
+extern int am_server;
+
+
+/*
+  receive the checksums for a buffer
+  */
+static struct sum_struct *receive_sums(int f)
+{
+	struct sum_struct *s;
+	int i;
+	OFF_T offset = 0;
+
+	s = (struct sum_struct *)malloc(sizeof(*s));
+	if (!s) out_of_memory("receive_sums");
+
+	s->count = read_int(f);
+	s->n = read_int(f);
+	s->remainder = read_int(f);  
+	s->sums = NULL;
+
+	if (verbose > 3)
+		rprintf(FINFO,"count=%d n=%d rem=%d\n",
+			s->count,s->n,s->remainder);
+
+	if (s->count == 0) 
+		return(s);
+
+	s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
+	if (!s->sums) out_of_memory("receive_sums");
+
+	for (i=0;i<s->count;i++) {
+		s->sums[i].sum1 = read_int(f);
+		read_buf(f,s->sums[i].sum2,csum_length);
+
+		s->sums[i].offset = offset;
+		s->sums[i].i = i;
+
+		if (i == s->count-1 && s->remainder != 0) {
+			s->sums[i].len = s->remainder;
+		} else {
+			s->sums[i].len = s->n;
+		}
+		offset += s->sums[i].len;
+
+		if (verbose > 3)
+			rprintf(FINFO,"chunk[%d] len=%d offset=%.0f sum1=%08x\n",
+				i,s->sums[i].len,(double)s->sums[i].offset,s->sums[i].sum1);
+	}
+
+	s->flength = offset;
+
+	return s;
+}
+
+
+
+void send_files(struct file_list *flist,int f_out,int f_in)
+{ 
+	int fd;
+	struct sum_struct *s;
+	struct map_struct *buf;
+	STRUCT_STAT st;
+	char fname[MAXPATHLEN];  
+	int i;
+	struct file_struct *file;
+	int phase = 0;
+	extern struct stats stats;		
+	struct stats initial_stats;
+
+	if (verbose > 2)
+		rprintf(FINFO,"send_files starting\n");
+
+	setup_readbuffer(f_in);
+
+	while (1) {
+		int offset=0;
+
+		i = read_int(f_in);
+		if (i == -1) {
+			if (phase==0 && remote_version >= 13) {
+				phase++;
+				csum_length = SUM_LENGTH;
+				write_int(f_out,-1);
+				if (verbose > 2)
+					rprintf(FINFO,"send_files phase=%d\n",phase);
+				continue;
+			}
+			break;
+		}
+
+		if (i < 0 || i >= flist->count) {
+			rprintf(FERROR,"Invalid file index %d (count=%d)\n", 
+				i, flist->count);
+			exit_cleanup(RERR_PROTOCOL);
+		}
+
+		file = flist->files[i];
+
+		stats.num_transferred_files++;
+		stats.total_transferred_size += file->length;
+
+		fname[0] = 0;
+		if (file->basedir) {
+			strlcpy(fname,file->basedir,MAXPATHLEN);
+			if (strlen(fname) == MAXPATHLEN-1) {
+				io_error = 1;
+				rprintf(FERROR, "send_files failed on long-named directory %s\n",
+					fname);
+				return;
+			}
+			strlcat(fname,"/",MAXPATHLEN);
+			offset = strlen(file->basedir)+1;
+		}
+		strlcat(fname,f_name(file),MAXPATHLEN);
+	  
+		if (verbose > 2) 
+			rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
+	  
+		if (dry_run) {	
+			if (!am_server) {
+				log_transfer(file, fname+offset);
+			}
+			write_int(f_out,i);
+			continue;
+		}
+
+		initial_stats = stats;
+
+		s = receive_sums(f_in);
+		if (!s) {
+			io_error = 1;
+			rprintf(FERROR,"receive_sums failed\n");
+			return;
+		}
+	  
+		fd = do_open(fname, O_RDONLY, 0);
+		if (fd == -1) {
+			io_error = 1;
+			rprintf(FERROR,"send_files failed to open %s: %s\n",
+				fname,strerror(errno));
+			free_sums(s);
+			continue;
+		}
+	  
+		/* map the local file */
+		if (do_fstat(fd,&st) != 0) {
+			io_error = 1;
+			rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
+			free_sums(s);
+			close(fd);
+			return;
+		}
+	  
+		if (st.st_size > 0) {
+			buf = map_file(fd,st.st_size);
+		} else {
+			buf = NULL;
+		}
+	  
+		if (verbose > 2)
+			rprintf(FINFO,"send_files mapped %s of size %.0f\n",
+				fname,(double)st.st_size);
+
+		write_int(f_out,i);
+	  
+		write_int(f_out,s->count);
+		write_int(f_out,s->n);
+		write_int(f_out,s->remainder);
+	  
+		if (verbose > 2)
+			rprintf(FINFO,"calling match_sums %s\n",fname);
+	  
+		if (!am_server) {
+			log_transfer(file, fname+offset);
+		}
+
+		set_compression(fname);
+	  
+		match_sums(f_out,s,buf,st.st_size);
+
+		log_send(file, &initial_stats);
+	  	  
+		if (buf) unmap_file(buf);
+		close(fd);
+	  
+		free_sums(s);
+	  
+		if (verbose > 2)
+			rprintf(FINFO,"sender finished %s\n",fname);
+	}
+
+	if (verbose > 2)
+		rprintf(FINFO,"send files finished\n");
+
+	match_report();
+
+	write_int(f_out,-1);
+}
+
+
+
+
+

socket.c

@@ -23,34 +23,136 @@
 
 #include "rsync.h"
 
+
+/* establish a proxy connection on an open socket to a web roxy by using the CONNECT
+   method */
+static int establish_proxy_connection(int fd, char *host, int port)
+{
+	char buffer[1024];
+	char *cp;
+
+	slprintf(buffer, sizeof(buffer), "CONNECT %s:%d HTTP/1.0\r\n\r\n", host, port);
+	if (write(fd, buffer, strlen(buffer)) != strlen(buffer)) {
+		rprintf(FERROR, "failed to write to proxy - %s\n",
+			strerror(errno));
+		return -1;
+	}
+
+	for (cp = buffer; cp < &buffer[sizeof(buffer) - 1]; cp++) {
+		if (read(fd, cp, 1) != 1) {
+			rprintf(FERROR, "failed to read from proxy\n");
+			return -1;
+		}
+		if (*cp == '\n')
+			break;
+	}
+
+	if (*cp != '\n')
+		cp++;
+	*cp-- = '\0';
+	if (*cp == '\r')
+		*cp = '\0';
+	if (strncmp(buffer, "HTTP/", 5) != 0) {
+		rprintf(FERROR, "bad response from proxy - %s\n",
+			buffer);
+		return -1;
+	}
+	for (cp = &buffer[5]; isdigit(*cp) || (*cp == '.'); cp++)
+		;
+	while (*cp == ' ')
+		cp++;
+	if (*cp != '2') {
+		rprintf(FERROR, "bad response from proxy - %s\n",
+			buffer);
+		return -1;
+	}
+	/* throw away the rest of the HTTP header */
+	while (1) {
+		for (cp = buffer; cp < &buffer[sizeof(buffer) - 1];
+		     cp++) {
+			if (read(fd, cp, 1) != 1) {
+				rprintf(FERROR, "failed to read from proxy\n");
+				return -1;
+			}
+			if (*cp == '\n')
+				break;
+		}
+		if ((cp > buffer) && (*cp == '\n'))
+			cp--;
+		if ((cp == buffer) && ((*cp == '\n') || (*cp == '\r')))
+			break;
+	}
+	return 0;
+}
+
+
 /* open a socket to a tcp remote host with the specified port 
-   based on code from Warren */
-int open_socket_out(char *host, int port)
+   based on code from Warren
+   proxy support by Stephen Rothwell */
+int open_socket_out(char *host, int port, struct in_addr *address)
 {
 	int type = SOCK_STREAM;
 	struct sockaddr_in sock_out;
+	struct sockaddr_in sock;
 	int res;
 	struct hostent *hp;
-  
+	char *h;
+	unsigned p;
+	int proxied = 0;
+	char buffer[1024];
+	char *cp;
+
+	/* if we have a RSYNC_PROXY env variable then redirect our connetcion via a web proxy
+	   at the given address. The format is hostname:port */
+	h = getenv("RSYNC_PROXY");
+	proxied = (h != NULL) && (*h != '\0');
+
+	if (proxied) {
+		strlcpy(buffer, h, sizeof(buffer));
+		cp = strchr(buffer, ':');
+		if (cp == NULL) {
+			rprintf(FERROR, "invalid proxy specification\n");
+			return -1;
+		}
+		*cp++ = '\0';
+		p = atoi(cp);
+		h = buffer;
+	} else {
+		h = host;
+		p = port;
+	}
 
 	res = socket(PF_INET, type, 0);
 	if (res == -1) {
 		return -1;
 	}
 
-	hp = gethostbyname(host);
+	hp = gethostbyname(h);
 	if (!hp) {
-		rprintf(FERROR,"unknown host: %s\n", host);
+		rprintf(FERROR,"unknown host: %s\n", h);
+		close(res);
 		return -1;
 	}
 
 	memcpy(&sock_out.sin_addr, hp->h_addr, hp->h_length);
-	sock_out.sin_port = htons(port);
+	sock_out.sin_port = htons(p);
 	sock_out.sin_family = PF_INET;
 
+	if (address) {
+		sock.sin_addr = *address;
+		sock.sin_port = 0;
+		sock.sin_family = hp->h_addrtype;
+		bind(res, (struct sockaddr * ) &sock,sizeof(sock));
+	}
+
 	if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
+		rprintf(FERROR,"failed to connect to %s - %s\n", h, strerror(errno));
+		close(res);
+		return -1;
+	}
+
+	if (proxied && establish_proxy_connection(res, host, port) != 0) {
 		close(res);
-		rprintf(FERROR,"failed to connect to %s - %s\n", host, strerror(errno));
 		return -1;
 	}
 
@@ -61,11 +163,11 @@ int open_socket_out(char *host, int port)
 /****************************************************************************
 open a socket of the specified type, port and address for incoming data
 ****************************************************************************/
-static int open_socket_in(int type, int port)
+static int open_socket_in(int type, int port, struct in_addr *address)
 {
 	struct hostent *hp;
 	struct sockaddr_in sock;
-	char host_name[200];
+	char host_name[MAXHOSTNAMELEN];
 	int res;
 	int one=1;
 
@@ -81,11 +183,15 @@ static int open_socket_in(int type, int port)
 		return -1;
 	}
   
-	bzero((char *)&sock,sizeof(sock));
+	memset((char *)&sock,0,sizeof(sock));
 	memcpy((char *)&sock.sin_addr,(char *)hp->h_addr, hp->h_length);
 	sock.sin_port = htons(port);
 	sock.sin_family = hp->h_addrtype;
-	sock.sin_addr.s_addr = INADDR_ANY;
+	if (address) {
+		sock.sin_addr = *address;
+	} else {
+		sock.sin_addr.s_addr = INADDR_ANY;
+	}
 	res = socket(hp->h_addrtype, type, 0);
 	if (res == -1) { 
 		rprintf(FERROR,"socket failed\n"); 
@@ -110,27 +216,26 @@ determine if a file descriptor is in fact a socket
 ****************************************************************************/
 int is_a_socket(int fd)
 {
-  int v,l;
-  l = sizeof(int);
-  return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
+	int v,l;
+	l = sizeof(int);
+	return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
 }
 
 
 void start_accept_loop(int port, int (*fn)(int ))
 {
 	int s;
-
-	signal(SIGCHLD, SIG_IGN);
+	extern struct in_addr socket_address;
 
 	/* open an incoming socket */
-	s = open_socket_in(SOCK_STREAM, port);
+	s = open_socket_in(SOCK_STREAM, port, &socket_address);
 	if (s == -1)
-		exit(1);
+		exit_cleanup(RERR_SOCKETIO);
 
 	/* ready to listen */
 	if (listen(s, 5) == -1) {
 		close(s);
-		exit(1);
+		exit_cleanup(RERR_SOCKETIO);
 	}
 
 
@@ -155,6 +260,15 @@ void start_accept_loop(int port, int (*fn)(int ))
 
 		if (fd == -1) continue;
 
+		signal(SIGCHLD, SIG_IGN);
+
+		/* we shouldn't have any children left hanging around
+		   but I have had reports that on Digital Unix zombies
+		   are produced, so this ensures that they are reaped */
+#ifdef WNOHANG
+                while (waitpid(-1, NULL, WNOHANG) > 0);
+#endif
+
 		if (fork()==0) {
 			close(s);
 
@@ -274,27 +388,30 @@ become a daemon, discarding the controlling terminal
 ****************************************************************************/
 void become_daemon(void)
 {
-	if (fork())
+	int i;
+
+	if (fork()) {
 		_exit(0);
+	}
 
 	/* detach from the terminal */
 #ifdef HAVE_SETSID
 	setsid();
 #else
 #ifdef TIOCNOTTY
-	{
-		int i = open("/dev/tty", O_RDWR);
-		if (i >= 0) 
-			{
-				ioctl(i, (int) TIOCNOTTY, (char *)0);      
-				close(i);
-			}
+	i = open("/dev/tty", O_RDWR);
+	if (i >= 0) {
+		ioctl(i, (int) TIOCNOTTY, (char *)0);      
+		close(i);
 	}
 #endif /* TIOCNOTTY */
 #endif
-	close(0);
-	close(1);
-	close(2);
+	/* make sure that stdin, stdout an stderr don't stuff things
+           up (library functions, for example) */
+	for (i=0;i<3;i++) {
+		close(i); 
+		open("/dev/null", O_RDWR);
+	}
 }
 
 /*******************************************************************
@@ -306,13 +423,17 @@ char *client_addr(int fd)
 	struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
 	int     length = sizeof(sa);
 	static char addr_buf[100];
+	static int initialised;
+
+	if (initialised) return addr_buf;
+
+	initialised = 1;
 
 	if (getpeername(fd, &sa, &length)) {
-		exit(1);
+		exit_cleanup(RERR_SOCKETIO);
 	}
-
-	strlcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr), sizeof(addr_buf)-1);
-
+	
+	strlcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr), sizeof(addr_buf));
 	return addr_buf;
 }
 
@@ -327,19 +448,80 @@ char *client_name(int fd)
 	int     length = sizeof(sa);
 	static char name_buf[100];
 	struct hostent *hp;
+	char **p;
+	char *def = "UNKNOWN";
+	static int initialised;
 
-	strcpy(name_buf,"UNKNOWN");
+	if (initialised) return name_buf;
+
+	initialised = 1;
+
+	strcpy(name_buf,def);
 
 	if (getpeername(fd, &sa, &length)) {
-		exit(1);
+		exit_cleanup(RERR_SOCKETIO);
 	}
 
 	/* Look up the remote host name. */
 	if ((hp = gethostbyaddr((char *) &sockin->sin_addr,
 				sizeof(sockin->sin_addr),
 				AF_INET))) {
-		strlcpy(name_buf,(char *)hp->h_name,sizeof(name_buf) - 1);
+		strlcpy(name_buf,(char *)hp->h_name,sizeof(name_buf));
+	}
+
+
+	/* do a forward lookup as well to prevent spoofing */
+	hp = gethostbyname(name_buf);
+	if (!hp) {
+		strcpy(name_buf,def);
+		rprintf(FERROR,"reverse name lookup failed\n");
+	} else {
+		for (p=hp->h_addr_list;*p;p++) {
+			if (memcmp(*p, &sockin->sin_addr, hp->h_length) == 0) {
+				break;
+			}
+		}
+		if (!*p) {
+			strcpy(name_buf,def);
+			rprintf(FERROR,"reverse name lookup mismatch - spoofed address?\n");
+		} 
 	}
 
 	return name_buf;
 }
+
+/*******************************************************************
+convert a string to an IP address. The string can be a name or
+dotted decimal number
+  ******************************************************************/
+struct in_addr *ip_address(const char *str)
+{
+	static struct in_addr ret;
+	struct hostent *hp;
+
+	/* try as an IP address */
+	if (inet_aton(str, &ret) != 0) {
+		return &ret;
+	}
+
+	/* otherwise assume it's a network name of some sort and use 
+	   gethostbyname */
+	if ((hp = gethostbyname(str)) == 0) {
+		rprintf(FERROR, "gethostbyname: Unknown host. %s\n",str);
+		return NULL;
+	}
+
+	if (hp->h_addr == NULL) {
+		rprintf(FERROR, "gethostbyname: host address is invalid for host %s\n",str);
+		return NULL;
+	}
+
+	if (hp->h_length > sizeof(ret)) {
+		rprintf(FERROR, "gethostbyname: host address is too large\n");
+		return NULL;
+	}
+
+	memcpy(&ret.s_addr, hp->h_addr, hp->h_length);
+
+	return(&ret);
+}

support/rsyncstats

@@ -0,0 +1,286 @@
+#! /usr/bin/perl
+# ---------------------------------------------------------------------------
+#
+# USAGE: rsyncstats <options>
+#
+# OPTIONS:
+#       -f <filename>   Use <filename> for the log file
+#       -h		include report on hourly traffic
+#       -d		include report on domain traffic
+#       -t		report on total traffic by section
+#       -D <domain>     report only on traffic from <domain>
+#       -l <depth>      Depth of path detail for sections
+#       -s <section>    Section to report on, For example: -s /pub will report
+#				only on paths under /pub
+#
+# This script parses the default logfile format produced by rsync when running
+# as a daemon with transfer logging enabled. It is derived from the xferstats
+# script that comes with wuftpd
+#
+# Andrew Tridgell, October 1998
+# rsync-bugs@samba.org
+#
+# ---------------------------------------------------------------------------
+
+# edit the next line to customize for your default log file
+$usage_file = "/var/adm/rsyncd.log";
+
+# Edit the following lines for default report settings.
+# Entries defined here will be over-ridden by the command line.
+
+$opt_h = 1; 
+$opt_d = 0;
+$opt_t = 1;
+$opt_l = 2;
+
+require 'getopts.pl';
+&Getopts('f:rahdD:l:s:');
+
+if ($opt_r) { $real = 1;}
+if ($opt_a) { $anon = 1;}
+if ($real == 0 && $anon == 0) { $anon = 1; }
+if ($opt_f) {$usage_file = $opt_f;}
+
+open (LOG,$usage_file) || die "Error opening usage log file: $usage_file\n";
+
+if ($opt_D) {print "Transfer Totals include the '$opt_D' domain only.\n";
+	     print "All other domains are filtered out for this report.\n\n";}
+
+if ($opt_s) {print "Transfer Totals include the '$opt_s' section only.\n";
+	     print "All other sections are filtered out for this report.\n\n";}
+
+line: while (<LOG>) {
+
+   @line = split;
+
+   $day = $line[0];
+   $time = $line[1];
+   $pid = $line[2];
+   $op = $line[3];
+   $host = $line[4];
+   $ip = $line[5];
+   $module = $line[6];
+   $user = $line[7];
+   $file = $line[8];
+   $bytes = $line[9];
+
+   next if ($#line != 9);
+
+   next if ($op != "send" && $op != "recv");
+
+   $daytime = $day;
+   $hour = substr($time,0,2); 
+
+   $file = $module . "/" . $file;
+
+   $file =~ s|//|/|mg;
+
+   @path = split(/\//, $file);
+
+   $pathkey = "";
+   for ($i=0; $i <= $#path && $i <= $opt_l;$i++) {
+	$pathkey = $pathkey . "/" . $path[$i];
+   }
+
+   next if (substr($pathkey,0,length("$opt_s")) ne "$opt_s");
+
+   $host =~ tr/A-Z/a-z/;
+
+   @address = split(/\./, $host);
+
+   $domain = $address[$#address];
+   if ( int($address[0]) > 0 || $#address < 2 )
+      { $domain = "unresolved"; }
+
+   if ($opt_D) {
+       next unless (substr($domain,0,length("$opt_D")) eq "$opt_D");
+   }
+
+
+#   printf ("c=%d day=%s bytes=%d file=%s path=%s\n", 
+#	   $#line, $daytime, $bytes, $file, $pathkey);
+
+   $xferfiles++;                                # total files sent
+   $xfertfiles++;                               # total files sent
+   $xferfiles{$daytime}++;                      # files per day
+   $groupfiles{$pathkey}++;                     # per-group accesses
+   $domainfiles{$domain}++;
+
+   $xferbytes{$daytime}   += $bytes;          # bytes per day
+   $domainbytes{$domain}  += $bytes;		# xmit bytes to domain
+   $xferbytes             += $bytes;          # total bytes sent
+   $groupbytes{$pathkey}  += $bytes;          # per-group bytes sent
+
+   $xfertfiles{$hour}++;                        # files per hour
+   $xfertbytes{$hour}     += $bytes;          # bytes per hour
+   $xfertbytes            += $bytes;          # total bytes sent
+}
+close LOG;
+
+@syslist = keys(systemfiles);
+@dates = sort datecompare keys(xferbytes);
+
+if ($xferfiles == 0) {die "There was no data to process.\n";}
+
+
+print "TOTALS FOR SUMMARY PERIOD ", $dates[0], " TO ", $dates[$#dates], "\n\n";
+printf ("Files Transmitted During Summary Period  %12.0f\n", $xferfiles);
+printf ("Bytes Transmitted During Summary Period  %12.0f\n", $xferbytes); 
+printf ("Systems Using Archives                   %12.0f\n\n", $#syslist+1);
+
+printf ("Average Files Transmitted Daily          %12.0f\n",
+   $xferfiles / ($#dates + 1));
+printf ("Average Bytes Transmitted Daily          %12.0f\n",
+   $xferbytes / ($#dates + 1));
+
+format top1 =
+
+Daily Transmission Statistics
+
+                 Number Of    Number of   Percent Of  Percent Of
+     Date        Files Sent   MB  Sent    Files Sent  Bytes Sent
+---------------  ----------  -----------  ----------  ----------
+.
+
+format line1 =
+@<<<<<<<<<<<<<<  @>>>>>>>>>  @>>>>>>>>>>  @>>>>>>>    @>>>>>>>  
+$date,           $nfiles,    $nbytes/(1024*1024), $pctfiles,  $pctbytes
+.
+
+$^ = top1;
+$~ = line1;
+
+foreach $date ( sort datecompare keys(xferbytes) ) {
+
+   $nfiles   = $xferfiles{$date};
+   $nbytes   = $xferbytes{$date};
+   $pctfiles = sprintf("%8.2f", 100*$xferfiles{$date} / $xferfiles);
+   $pctbytes = sprintf("%8.2f", 100*$xferbytes{$date} / $xferbytes);
+   write;
+}
+
+if ($opt_t) {
+format top2 =
+
+Total Transfers from each Archive Section (By bytes)
+
+                                                           - Percent -
+     Archive Section                   NFiles     MB      Files   Bytes
+------------------------------------- ------- ----------- ----- -------
+.
+
+format line2 =
+@<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< @>>>>>> @>>>>>>>>>> @>>>>   @>>>>
+$section,                 $files,    $bytes/(1024*1024),     $pctfiles, $pctbytes
+.
+
+$| = 1;
+$- = 0;
+$^ = top2;
+$~ = line2;
+
+foreach $section ( sort bytecompare keys(groupfiles) ) {
+
+   $files = $groupfiles{$section};
+   $bytes = $groupbytes{$section};
+   $pctbytes = sprintf("%8.2f", 100 * $groupbytes{$section} / $xferbytes);
+   $pctfiles = sprintf("%8.2f", 100 * $groupfiles{$section} / $xferfiles);
+   write;
+
+}
+
+if ( $xferfiles < 1 ) { $xferfiles = 1; }
+if ( $xferbytes < 1 ) { $xferbytes = 1; }
+}
+
+if ($opt_d) {
+format top3 =
+
+Total Transfer Amount By Domain
+
+             Number Of    Number of    Percent Of  Percent Of
+Domain Name  Files Sent    MB Sent     Files Sent  Bytes Sent
+-----------  ----------  ------------  ----------  ----------
+.
+
+format line3 =
+@<<<<<<<<<<  @>>>>>>>>>  @>>>>>>>>>>>  @>>>>>>>    @>>>>>>>  
+$domain,     $files,     $bytes/(1024*1024), $pctfiles,  $pctbytes
+.
+
+$- = 0;
+$^ = top3;
+$~ = line3;
+
+foreach $domain ( sort domnamcompare keys(domainfiles) ) {
+
+   if ( $domainsecs{$domain} < 1 ) { $domainsecs{$domain} = 1; }
+
+   $files = $domainfiles{$domain};
+   $bytes = $domainbytes{$domain};
+   $pctfiles = sprintf("%8.2f", 100 * $domainfiles{$domain} / $xferfiles);
+   $pctbytes = sprintf("%8.2f", 100 * $domainbytes{$domain} / $xferbytes);
+   write;
+
+}
+
+}
+
+if ($opt_h) {
+
+format top8 =
+
+Hourly Transmission Statistics
+
+                 Number Of    Number of   Percent Of  Percent Of
+     Time        Files Sent    MB  Sent   Files Sent  Bytes Sent
+---------------  ----------  -----------  ----------  ----------
+.
+
+format line8 =
+@<<<<<<<<<<<<<<  @>>>>>>>>>  @>>>>>>>>>>  @>>>>>>>    @>>>>>>>  
+$hour,           $nfiles,    $nbytes/(1024*1024), $pctfiles,  $pctbytes
+.
+
+
+$| = 1;
+$- = 0;
+$^ = top8;
+$~ = line8;
+
+foreach $hour ( sort keys(xfertbytes) ) {
+
+   $nfiles   = $xfertfiles{$hour};
+   $nbytes   = $xfertbytes{$hour};
+   $pctfiles = sprintf("%8.2f", 100*$xfertfiles{$hour} / $xferfiles);
+   $pctbytes = sprintf("%8.2f", 100*$xfertbytes{$hour} / $xferbytes);
+   write;
+}
+}
+exit(0);
+
+sub datecompare {
+    $a gt $b;
+}
+
+sub domnamcompare {
+
+   $sdiff = length($a) - length($b);
+   ($sdiff < 0) ? -1 : ($sdiff > 0) ? 1 : ($a lt $b) ? -1 : ($a gt $b) ? 1 : 0;
+
+}
+
+sub bytecompare {
+
+   $bdiff = $groupbytes{$b} - $groupbytes{$a};
+   ($bdiff < 0) ? -1 : ($bdiff > 0) ? 1 : ($a lt $b) ? -1 : ($a gt $b) ? 1 : 0;
+
+}
+
+sub faccompare {
+
+   $fdiff = $fac{$b} - $fac{$a};
+   ($fdiff < 0) ? -1 : ($fdiff > 0) ? 1 : ($a lt $b) ? -1 : ($a gt $b) ? 1 : 0;
+
+}
+

syscall.c

@@ -24,8 +24,9 @@
 
 extern int dry_run;
 extern int read_only;
+extern int list_only;
 
-#define CHECK_RO if (read_only) {errno = EROFS; return -1;}
+#define CHECK_RO if (read_only || list_only) {errno = EROFS; return -1;}
 
 int do_unlink(char *fname)
 {
@@ -75,8 +76,17 @@ int do_rmdir(char *pathname)
 
 int do_open(char *pathname, int flags, mode_t mode)
 {
-	if (dry_run) return -1;
-	CHECK_RO
+	if (flags != O_RDONLY) {
+	    if (dry_run) return -1;
+	    CHECK_RO
+	}
+#ifdef O_BINARY
+	/* for Windows */
+	flags |= O_BINARY;
+#endif
+	/* some systems can't handle a double / */
+	if (pathname[0] == '/' && pathname[1] == '/') pathname++;
+
 	return open(pathname, flags, mode);
 }
 
@@ -149,6 +159,17 @@ OFF_T do_lseek(int fd, OFF_T offset, int whence)
 #endif
 }
 
+#ifdef USE_MMAP
+void *do_mmap(void *start, int len, int prot, int flags, int fd, OFF_T offset)
+{
+#if HAVE_OFF64_T
+	return mmap64(start, len, prot, flags, fd, offset);
+#else
+	return mmap(start, len, prot, flags, fd, offset);
+#endif
+}
+#endif
+
 char *d_name(struct dirent *di)
 {
 #if HAVE_BROKEN_READDIR

tech_report.tex

@@ -31,7 +31,7 @@ Imagine you have two files, $A$ and $B$, and you wish to update $B$ to be
 the same as $A$. The obvious method is to copy $A$ onto $B$.
 
 Now imagine that the two files are on machines connected by a slow
-communications link, for example a dial up IP link.  If $A$ is large,
+communications link, for example a dialup IP link.  If $A$ is large,
 copying $A$ onto $B$ will be slow.  To make it faster you could
 compress $A$ before sending it, but that will usually only gain a
 factor of 2 to 4.
@@ -133,7 +133,7 @@ possible offsets within a file in a ``rolling'' fashion, with very
 little computation at each point.
 
 Despite its simplicity, this checksum was found to be quite adequate as
-a first level check for a match of two file blocks.  We have found in
+a first-level check for a match of two file blocks.  We have found in
 practice that the probability of this checksum matching when the
 blocks are not equal is quite low.  This is important because the much
 more expensive strong checksum must be calculated for each block where
@@ -158,16 +158,16 @@ contains a null value if no element of the list has that hash value.
 
 At each offset in the file the 32-bit rolling checksum and its 16-bit
 hash are calculated.  If the hash table entry for that hash value is
-not a null value, the second level check is invoked.
+not a null value, the second-level check is invoked.
 
-The second level check involves scanning the sorted checksum list
+The second-level check involves scanning the sorted checksum list
 starting with the entry pointed to by the hash table entry, looking
 for an entry whose 32-bit rolling checksum matches the current value.
 The scan terminates when it reaches an entry whose 16-bit hash
-differs.  If this search finds a match, the third level check is
+differs.  If this search finds a match, the third-level check is
 invoked.
 
-The third level check involves calculating the strong checksum for the
+The third-level check involves calculating the strong checksum for the
 current offset in the file and comparing it with the strong checksum
 value in the current list entry.  If the two strong checksums match,
 we assume that we have found a block of $A$ which matches a block of
@@ -246,14 +246,14 @@ The columns in the table are as follows:
 \begin{description}
 \item [block size] The size in bytes of the checksummed blocks.
 \item [matches] The number of times a block of $B$ was found in $A$.
-\item [tag hits] The number of times the 16 bit hash of the rolling
+\item [tag hits] The number of times the 16-bit hash of the rolling
   checksum matched a hash of one of the checksums from $B$.
-\item [false alarms] The number of times the 32 bit rolling checksum
+\item [false alarms] The number of times the 32-bit rolling checksum
   matched but the strong checksum didn't.
 \item [data] The amount of file data transferred verbatim, in bytes.
-\item [written] The total number of bytes written by $\alpha$
+\item [written] The total number of bytes written by $\alpha$,
   including protocol overheads. This is almost all file data.
-\item [read] The total number of bytes read by $\alpha$ including
+\item [read] The total number of bytes read by $\alpha$, including
   protocol overheads. This is almost all checksum information.
 \end{description}
 
@@ -269,7 +269,7 @@ case. Each pair of checksums consumes 20 bytes: 4 bytes for the
 rolling checksum plus 16 bytes for the 128-bit MD4 checksum.
 
 The number of false alarms was less than $1/1000$ of the number of
-true matches, indicating that the 32 bit rolling checksum is quite
+true matches, indicating that the 32-bit rolling checksum is quite
 good at screening out false matches. 
 
 The number of tag hits indicates that the second level of the
@@ -305,6 +305,6 @@ diff between the two releases is 4155 lines long totalling 120 kB.
 
 An implementation of rsync which provides a convenient interface
 similar to the common UNIX command rcp has been written and is
-available for download from ftp://samba.anu.edu.au/pub/rsync.
+available for download from http://rsync.samba.org/
 
 \end{document}

test.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
-#
-# Copyright (C) 1998 Philip Hands <http://www.hands.com/~phil/>
+# Copyright (C) 1998,1999 Philip Hands <phil@hands.com>
 #
 # This program is distributable under the terms of the GNU GPL (see COPYING)
 #
@@ -10,7 +9,35 @@
 #
 #
 
-export PATH=.:$PATH
+# check if we are running under debian-test, and change behaviour to suit
+if test -n "${DEBIANTEST_LIB}" ; then
+  # make sure rsync is installed
+  test -e /usr/bin/rsync || exit 0
+  
+  . ${DEBIANTEST_LIB}/functions.sh
+  Debian=1
+else
+  cat <<EOF
+
+This set of tests is not completely portable. It is intended for developers
+not for end users. You may experience failures on some platforms that
+do not indicate a problem with rsync.
+
+EOF
+
+RSYNC=`pwd`/rsync
+
+  runtest() {
+    echo -n "Test $1: "
+    eval "$2"
+  }
+  printmsg() {
+    echo ""
+    echo "**** ${1}^G ****"
+    echo ""  
+  }
+fi
+
 TMP=/tmp/rsync-test.$$
 FROM=${TMP}/from
 TO=${TMP}/to
@@ -30,34 +57,53 @@ ln -s nolf ${FROM}/nolf-symlink
 cat /etc/inittab /etc/services /etc/resolv.conf > ${FROM}/${F1}
 mkdir ${FROM}/dir
 cp ${FROM}/${F1} ${FROM}/dir
+mkdir ${FROM}/dir/subdir
+mkdir ${FROM}/dir/subdir/subsubdir
+ls -ltr /etc > ${FROM}/dir/subdir/subsubdir/etc-ltr-list
+mkdir ${FROM}/dir/subdir/subsubdir2
+ls -lt /bin > ${FROM}/dir/subdir/subsubdir2/bin-lt-list
 
 checkit() {
-  echo -n "Test $4: $5:"
-  log=${LOG}.$4
+  testnum=`expr 0${testnum} + 1`
+  log=${LOG}.${testnum}
   failed=
   echo "Running: \"$1\""  >${log}
   echo "">>${log}
-  eval "$1 || failed=YES"  >>${log} 2>&1
-
+  eval "$1"  >>${log} 2>&1
+  status=$?
+  if [ $status != 0 ]; then
+    failed="YES";
+  fi
   echo "-------------">>${log}
   echo "check how the files compare with diff:">>${log}
   echo "">>${log}
-  diff -ur $2 $3 >>${log} || failed=YES
+  diff -ur $2 $3 >>${log} 2>&1 || failed=YES
   echo "-------------">>${log}
   echo "check how the directory listings compare with diff:">>${log}
   echo "">>${log}
-  ls -la $2 > ${TMP}/ls-from
-  ls -la $3 > ${TMP}/ls-to
-  diff -u ${TMP}/ls-from ${TMP}/ls-to >>${log} || failed=YES
+  ( cd $2 ; ls -laR ) > ${TMP}/ls-from 2>>${log}
+  ( cd $3 ; ls -laR ) > ${TMP}/ls-to  2>>${log}
+  diff -u ${TMP}/ls-from ${TMP}/ls-to >>${log} 2>&1 || failed=YES
   if [ -z "${failed}" ] ; then
-    echo "	done."
+    test -z "${Debian}" && echo "	done."
     rm $log
+    return 0
   else
-    echo "	FAILED."
+    if test -n "${Debian}" ; then
+      cat ${log}
+      rm ${log}
+    else
+      echo "	FAILED (test # ${testnum} status=$status)."
+    fi
+    return 1
   fi
 }
 
+
 checkforlogs() {
+  # skip it if we're under debian-test
+  if test -n "${Debian}" ; then return 0 ; fi
+
   if [ -f $1 ] ; then
     cat <<EOF
 
@@ -79,38 +125,45 @@ EOF
 
 # Main script starts here
 
-checkit "rsync -av ${FROM}/ ${TO}" ${FROM}/ ${TO} \
-  1 "basic operation"
+runtest "basic operation" 'checkit "$RSYNC -av ${FROM}/ ${TO}" ${FROM}/ ${TO}'
 
 ln ${FROM}/pslist ${FROM}/dir
-checkit "rsync -avH ${FROM}/ ${TO}" ${FROM}/ ${TO} \
-  2 "hard links"
+runtest "hard links" 'checkit "$RSYNC -avH ${FROM}/ ${TO}" ${FROM}/ ${TO}'
 
 rm ${TO}/${F1}
-checkit "rsync -avH ${FROM}/ ${TO}" ${FROM}/ ${TO} \
-  3 "one file"
+runtest "one file" 'checkit "$RSYNC -avH ${FROM}/ ${TO}" ${FROM}/ ${TO}'
 
 echo "extra line" >> ${TO}/${F1}
-checkit "rsync -avH ${FROM}/ ${TO}" ${FROM}/ ${TO} \
-  4 "extra data"
+runtest "extra data" 'checkit "$RSYNC -avH ${FROM}/ ${TO}" ${FROM}/ ${TO}'
 
 cp ${FROM}/${F1} ${TO}/ThisShouldGo
-checkit "rsync --delete -avH ${FROM}/ ${TO}" ${FROM}/ ${TO} \
-  5 " --delete"
+runtest " --delete" 'checkit "$RSYNC --delete -avH ${FROM}/ ${TO}" ${FROM}/ ${TO}'
 
-if type ssh >/dev/null ; then
-rm -rf ${TO}
-  checkit "rsync -avH -e ssh ${FROM}/ localhost:${TO}" ${FROM}/ ${TO} \
-    6 "ssh: basic test"
+LONGDIR=${FROM}/This-is-a-directory-with-a-stupidly-long-name-created-in-an-attempt-to-provoke-an-error-found-in-2.0.11-that-should-hopefully-never-appear-again-if-this-test-does-its-job/This-is-a-directory-with-a-stupidly-long-name-created-in-an-attempt-to-provoke-an-error-found-in-2.0.11-that-should-hopefully-never-appear-again-if-this-test-does-its-job/This-is-a-directory-with-a-stupidly-long-name-created-in-an-attempt-to-provoke-an-error-found-in-2.0.11-that-should-hopefully-never-appear-again-if-this-test-does-its-job
+mkdir -p ${LONGDIR}
+date > ${LONGDIR}/1
+ls -la / > ${LONGDIR}/2
+runtest "long paths" 'checkit "$RSYNC --delete -avH ${FROM}/ ${TO}" ${FROM}/ ${TO}'
 
-  mv ${TO}/${F1} ${TO}/ThisShouldGo
-  checkit "rsync --delete -avH -e ssh ${FROM}/ localhost:${TO}" ${FROM}/ ${TO}\
-    7 "ssh: renamed file"
+if type ssh >/dev/null 2>&1; then
+  if [ "`ssh -o'BatchMode yes' localhost echo yes 2>/dev/null`" = "yes" ]; then
+  rm -rf ${TO}
+    runtest "ssh: basic test" 'checkit "$RSYNC -avH -e ssh --rsync-path=$RSYNC ${FROM}/ localhost:${TO}" ${FROM}/ ${TO}'
+
+    mv ${TO}/${F1} ${TO}/ThisShouldGo
+    runtest "ssh: renamed file" 'checkit "$RSYNC --delete -avH -e ssh --rsync-path=$RSYNC ${FROM}/ localhost:${TO}" ${FROM}/ ${TO}'
+  else
+  printmsg "Skipping SSH tests because ssh conection to localhost not authorised"
+  fi
 else
-  echo ""
-  echo "**** Skipping SSH tests because ssh is not in the path ****"
-  echo ""
+  printmsg "Skipping SSH tests because ssh is not in the path"
 fi
 
-checkforlogs ${LOG}.?
+rm -rf ${TO}
+mkdir -p ${FROM}2/dir/subdir
+cp -a ${FROM}/dir/subdir/subsubdir ${FROM}2/dir/subdir
+cp ${FROM}/dir/* ${FROM}2/dir 2>/dev/null
+runtest "excludes" 'checkit "$RSYNC -vv -Hlrt --delete --include /dir/ --include /dir/\* --include /dir/\*/subsubdir  --include /dir/\*/subsubdir/\*\* --exclude \*\* ${FROM}/dir ${TO}" ${FROM}2/ ${TO}'
+rm -r ${FROM}2
 
+checkforlogs ${LOG}.?

token.c

@@ -18,68 +18,94 @@
 */
 
 #include "rsync.h"
-#include "lib/zlib.h"
+#include "zlib/zlib.h"
 
 extern int do_compression;
+static int compression_level = Z_DEFAULT_COMPRESSION;
 
+/* determine the compression level based on a wildcard filename list */
+void set_compression(char *fname)
+{
+	extern int module_id;
+	char *dont;
+	char *tok;
+
+	if (!do_compression) return;
+
+	compression_level = Z_DEFAULT_COMPRESSION;
+	dont = lp_dont_compress(module_id);
+
+	if (!dont || !*dont) return;
+
+	if ((dont[0] == '*') && (!dont[1])) {
+		/* an optimization to skip the rest of this routine */
+		compression_level = 0;
+		return;
+	}
+
+	dont = strdup(dont);
+	fname = strdup(fname);
+	if (!dont || !fname) return;
+
+	strlower(dont);
+	strlower(fname);
+
+	for (tok=strtok(dont," ");tok;tok=strtok(NULL," ")) {
+		if (fnmatch(tok, fname, 0) == 0) {
+			compression_level = 0;
+			break;
+		}
+	}
+	free(dont);
+	free(fname);
+}
 
 /* non-compressing recv token */
 static int simple_recv_token(int f,char **data)
 {
-  static int residue;
-  static char *buf;
-  int n;
+	static int residue;
+	static char *buf;
+	int n;
 
-  if (!buf) {
-    buf = (char *)malloc(CHUNK_SIZE);
-    if (!buf) out_of_memory("simple_recv_token");
-  }
+	if (!buf) {
+		buf = (char *)malloc(CHUNK_SIZE);
+		if (!buf) out_of_memory("simple_recv_token");
+	}
 
+	if (residue == 0) {
+		int i = read_int(f);
+		if (i <= 0) return i;
+		residue = i;
+	}
 
-  if (residue == 0) {
-    int i = read_int(f);
-    if (i <= 0) return i;
-    residue = i;
-  }
-
-  *data = buf;
-  n = MIN(CHUNK_SIZE,residue);
-  residue -= n;
-  read_buf(f,buf,n);
-  return n;
+	*data = buf;
+	n = MIN(CHUNK_SIZE,residue);
+	residue -= n;
+	read_buf(f,buf,n);
+	return n;
 }
 
 
 /* non-compressing send token */
 static void simple_send_token(int f,int token,
-			      struct map_struct *buf,int offset,int n)
+			      struct map_struct *buf,OFF_T offset,int n)
 {
-  if (n > 0) {
-    int l = 0;
-    while (l < n) {
-      int n1 = MIN(CHUNK_SIZE,n-l);
-      write_int(f,n1);
-      write_buf(f,map_ptr(buf,offset+l,n1),n1);
-      l += n1;
-    }
-  }
-  write_int(f,-(token+1));
+	if (n > 0) {
+		int l = 0;
+		while (l < n) {
+			int n1 = MIN(CHUNK_SIZE,n-l);
+			write_int(f,n1);
+			write_buf(f,map_ptr(buf,offset+l,n1),n1);
+			l += n1;
+		}
+	}
+	/* a -2 token means to send data only and no token */
+	if (token != -2) {
+		write_int(f,-(token+1));
+	}
 }
 
 
-/* Memory allocation/freeing routines, called by zlib stuff. */
-static void *
-z_alloc(void *opaque, uInt items, uInt size)
-{
-    return malloc(items * size);
-}
-
-static void
-z_free(void *opaque, void *adrs, uInt nbytes)
-{
-    free(adrs);
-}
-
 /* Flag bytes in compressed stream are encoded as follows: */
 #define END_FLAG	0	/* that's all folks */
 #define TOKEN_LONG	0x20	/* followed by 32-bit token number */
@@ -104,102 +130,131 @@ static char *obuf;
 /* Send a deflated token */
 static void
 send_deflated_token(int f, int token,
-		    struct map_struct *buf, int offset, int nb, int toklen)
+		    struct map_struct *buf, OFF_T offset, int nb, int toklen)
 {
-    int n, r;
-    static int init_done;
+	int n, r;
+	static int init_done, flush_pending;
 
-    if (last_token == -1) {
-	/* initialization */
-	if (!init_done) {
-	    tx_strm.next_in = NULL;
-	    tx_strm.zalloc = z_alloc;
-	    tx_strm.zfree = z_free;
-	    if (deflateInit2(&tx_strm, Z_DEFAULT_COMPRESSION, 8,
-			     -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
-		rprintf(FERROR, "compression init failed\n");
-		exit_cleanup(1);
-	    }
-	    if ((obuf = malloc(MAX_DATA_COUNT+2)) == NULL)
-		out_of_memory("send_deflated_token");
-	    init_done = 1;
-	} else
-	    deflateReset(&tx_strm);
-	run_start = token;
-	last_run_end = 0;
+	if (last_token == -1) {
+		/* initialization */
+		if (!init_done) {
+			tx_strm.next_in = NULL;
+			tx_strm.zalloc = NULL;
+			tx_strm.zfree = NULL;
+			if (deflateInit2(&tx_strm, compression_level,
+					 Z_DEFLATED, -15, 8,
+					 Z_DEFAULT_STRATEGY) != Z_OK) {
+				rprintf(FERROR, "compression init failed\n");
+				exit_cleanup(RERR_STREAMIO);
+			}
+			if ((obuf = malloc(MAX_DATA_COUNT+2)) == NULL)
+				out_of_memory("send_deflated_token");
+			init_done = 1;
+		} else
+			deflateReset(&tx_strm);
+		last_run_end = 0;
+		run_start = token;
+		flush_pending = 0;
 
-    } else if (nb != 0 || token != last_token + 1
-	       || token >= run_start + 65536) {
-	/* output previous run */
-	r = run_start - last_run_end;
-	n = last_token - run_start;
-	if (r >= 0 && r <= 63) {
-	    write_byte(f, (n==0? TOKEN_REL: TOKENRUN_REL) + r);
-	} else {
-	    write_byte(f, (n==0? TOKEN_LONG: TOKENRUN_LONG));
-	    write_int(f, run_start);
-	}
-	if (n != 0) {
-	    write_byte(f, n);
-	    write_byte(f, n >> 8);
-	}
-	last_run_end = last_token;
-	run_start = token;
-    }
+	} else if (last_token == -2) {
+		run_start = token;
 
-    last_token = token;
-
-    if (nb != 0) {
-	/* deflate the data starting at offset */
-	tx_strm.avail_in = 0;
-	tx_strm.avail_out = 0;
-	do {
-	    if (tx_strm.avail_in == 0 && nb != 0) {
-		/* give it some more input */
-		n = MIN(nb, CHUNK_SIZE);
-		tx_strm.next_in = (Bytef *)map_ptr(buf, offset, n);
-		tx_strm.avail_in = n;
-		nb -= n;
-		offset += n;
-	    }
-	    if (tx_strm.avail_out == 0) {
-		tx_strm.next_out = (Bytef *)(obuf + 2);
-		tx_strm.avail_out = MAX_DATA_COUNT;
-	    }
-	    r = deflate(&tx_strm, nb? Z_NO_FLUSH: Z_PACKET_FLUSH);
-	    if (r != Z_OK) {
-		rprintf(FERROR, "deflate returned %d\n", r);
-		exit_cleanup(1);
-	    }
-	    if (nb == 0 || tx_strm.avail_out == 0) {
-		n = MAX_DATA_COUNT - tx_strm.avail_out;
-		if (n > 0) {
-		    obuf[0] = DEFLATED_DATA + (n >> 8);
-		    obuf[1] = n;
-		    write_buf(f, obuf, n+2);
+	} else if (nb != 0 || token != last_token + 1
+		   || token >= run_start + 65536) {
+		/* output previous run */
+		r = run_start - last_run_end;
+		n = last_token - run_start;
+		if (r >= 0 && r <= 63) {
+			write_byte(f, (n==0? TOKEN_REL: TOKENRUN_REL) + r);
+		} else {
+			write_byte(f, (n==0? TOKEN_LONG: TOKENRUN_LONG));
+			write_int(f, run_start);
 		}
-	    }
-	} while (nb != 0 || tx_strm.avail_out == 0);
-    }
-
-    if (token != -1) {
-	/* add the data in the current block to the compressor's
-	   history and hash table */
-	tx_strm.next_in = (Bytef *)map_ptr(buf, offset, toklen);
-	tx_strm.avail_in = toklen;
-	tx_strm.next_out = NULL;
-	tx_strm.avail_out = 2 * toklen;
-	r = deflate(&tx_strm, Z_INSERT_ONLY);
-	if (r != Z_OK || tx_strm.avail_in != 0) {
-	    rprintf(FERROR, "deflate on token returned %d (%d bytes left)\n",
-		    r, tx_strm.avail_in);
-	    exit_cleanup(1);
+		if (n != 0) {
+			write_byte(f, n);
+			write_byte(f, n >> 8);
+		}
+		last_run_end = last_token;
+		run_start = token;
 	}
 
-    } else {
-	/* end of file - clean up */
-	write_byte(f, END_FLAG);
-    }
+	last_token = token;
+
+	if (nb != 0 || flush_pending) {
+		/* deflate the data starting at offset */
+		int flush = Z_NO_FLUSH;
+		tx_strm.avail_in = 0;
+		tx_strm.avail_out = 0;
+		do {
+			if (tx_strm.avail_in == 0 && nb != 0) {
+				/* give it some more input */
+				n = MIN(nb, CHUNK_SIZE);
+				tx_strm.next_in = (Bytef *)
+					map_ptr(buf, offset, n);
+				tx_strm.avail_in = n;
+				nb -= n;
+				offset += n;
+			}
+			if (tx_strm.avail_out == 0) {
+				tx_strm.next_out = (Bytef *)(obuf + 2);
+				tx_strm.avail_out = MAX_DATA_COUNT;
+				if (flush != Z_NO_FLUSH) {
+					/*
+					 * We left the last 4 bytes in the
+					 * buffer, in case they are the
+					 * last 4.  Move them to the front.
+					 */
+					memcpy(tx_strm.next_out,
+					       obuf+MAX_DATA_COUNT-2, 4);
+					tx_strm.next_out += 4;
+					tx_strm.avail_out -= 4;
+				}
+			}
+			if (nb == 0 && token != -2)
+				flush = Z_SYNC_FLUSH;
+			r = deflate(&tx_strm, flush);
+			if (r != Z_OK) {
+				rprintf(FERROR, "deflate returned %d\n", r);
+				exit_cleanup(RERR_STREAMIO);
+			}
+			if (nb == 0 || tx_strm.avail_out == 0) {
+				n = MAX_DATA_COUNT - tx_strm.avail_out;
+				if (flush != Z_NO_FLUSH) {
+					/*
+					 * We have to trim off the last 4
+					 * bytes of output when flushing
+					 * (they are just 0, 0, ff, ff).
+					 */
+					n -= 4;
+				}
+				if (n > 0) {
+					obuf[0] = DEFLATED_DATA + (n >> 8);
+					obuf[1] = n;
+					write_buf(f, obuf, n+2);
+				}
+			}
+		} while (nb != 0 || tx_strm.avail_out == 0);
+		flush_pending = token == -2;
+	}
+
+	if (token == -1) {
+		/* end of file - clean up */
+		write_byte(f, END_FLAG);
+
+	} else if (token != -2) {
+		/* add the data in the current block to the compressor's
+		   history and hash table */
+		tx_strm.next_in = (Bytef *) map_ptr(buf, offset, toklen);
+		tx_strm.avail_in = toklen;
+		tx_strm.next_out = (Bytef *) obuf;
+		tx_strm.avail_out = MAX_DATA_COUNT;
+		r = deflate(&tx_strm, Z_INSERT_ONLY);
+		if (r != Z_OK || tx_strm.avail_in != 0) {
+			rprintf(FERROR, "deflate on token returned %d (%d bytes left)\n",
+				r, tx_strm.avail_in);
+			exit_cleanup(RERR_STREAMIO);
+		}
+	}
 }
 
 
@@ -219,131 +274,171 @@ static int rx_run;
 static int
 recv_deflated_token(int f, char **data)
 {
-    int n, r, flag;
-    static int init_done;
-    static int saved_flag;
+	int n, r, flag;
+	static int init_done;
+	static int saved_flag;
 
-    for (;;) {
-	switch (recv_state) {
-	case r_init:
-	    if (!init_done) {
-		rx_strm.next_out = NULL;
-		rx_strm.zalloc = z_alloc;
-		rx_strm.zfree = z_free;
-		if (inflateInit2(&rx_strm, -15) != Z_OK) {
-		    rprintf(FERROR, "inflate init failed\n");
-		    exit_cleanup(1);
-		}
-		if ((cbuf = malloc(MAX_DATA_COUNT)) == NULL
-		    || (dbuf = malloc(CHUNK_SIZE)) == NULL)
-		    out_of_memory("recv_deflated_token");
-		init_done = 1;
-	    } else {
-		inflateReset(&rx_strm);
-	    }
-	    recv_state = r_idle;
-	    rx_token = 0;
-	    break;
-	    
-	case r_idle:
-	case r_inflated:
-	    if (saved_flag) {
-		flag = saved_flag & 0xff;
-		saved_flag = 0;
-	    } else
-		flag = read_byte(f);
-	    if ((flag & 0xC0) == DEFLATED_DATA) {
-		n = ((flag & 0x3f) << 8) + read_byte(f);
-		read_buf(f, cbuf, n);
-		rx_strm.next_in = (Bytef *)cbuf;
-		rx_strm.avail_in = n;
-		recv_state = r_inflating;
-		break;
-	    }
-	    if (recv_state == r_inflated) {
-		/* check previous inflated stuff ended correctly */
-		rx_strm.avail_in = 0;
-		rx_strm.next_out = (Bytef *)dbuf;
-		rx_strm.avail_out = CHUNK_SIZE;
-		r = inflate(&rx_strm, Z_PACKET_FLUSH);
-		n = CHUNK_SIZE - rx_strm.avail_out;
-		if (r != Z_OK) {
-		    rprintf(FERROR, "inflate flush returned %d (%d bytes)\n",
-			    r, n);
-		    exit_cleanup(1);
-		}
-		if (n != 0) {
-		    /* have to return some more data and
-		       save the flag for later. */
-		    saved_flag = flag + 0x10000;
-		    if (rx_strm.avail_out != 0)
+	for (;;) {
+		switch (recv_state) {
+		case r_init:
+			if (!init_done) {
+				rx_strm.next_out = NULL;
+				rx_strm.zalloc = NULL;
+				rx_strm.zfree = NULL;
+				if (inflateInit2(&rx_strm, -15) != Z_OK) {
+					rprintf(FERROR, "inflate init failed\n");
+					exit_cleanup(RERR_STREAMIO);
+				}
+				if ((cbuf = malloc(MAX_DATA_COUNT)) == NULL
+				    || (dbuf = malloc(CHUNK_SIZE)) == NULL)
+					out_of_memory("recv_deflated_token");
+				init_done = 1;
+			} else {
+				inflateReset(&rx_strm);
+			}
 			recv_state = r_idle;
-		    *data = dbuf;
-		    return n;
+			rx_token = 0;
+			break;
+
+		case r_idle:
+		case r_inflated:
+			if (saved_flag) {
+				flag = saved_flag & 0xff;
+				saved_flag = 0;
+			} else
+				flag = read_byte(f);
+			if ((flag & 0xC0) == DEFLATED_DATA) {
+				n = ((flag & 0x3f) << 8) + read_byte(f);
+				read_buf(f, cbuf, n);
+				rx_strm.next_in = (Bytef *)cbuf;
+				rx_strm.avail_in = n;
+				recv_state = r_inflating;
+				break;
+			}
+			if (recv_state == r_inflated) {
+				/* check previous inflated stuff ended correctly */
+				rx_strm.avail_in = 0;
+				rx_strm.next_out = (Bytef *)dbuf;
+				rx_strm.avail_out = CHUNK_SIZE;
+				r = inflate(&rx_strm, Z_SYNC_FLUSH);
+				n = CHUNK_SIZE - rx_strm.avail_out;
+				/*
+				 * Z_BUF_ERROR just means no progress was
+				 * made, i.e. the decompressor didn't have
+				 * any pending output for us.
+				 */
+				if (r != Z_OK && r != Z_BUF_ERROR) {
+					rprintf(FERROR, "inflate flush returned %d (%d bytes)\n",
+						r, n);
+					exit_cleanup(RERR_STREAMIO);
+				}
+				if (n != 0 && r != Z_BUF_ERROR) {
+					/* have to return some more data and
+					   save the flag for later. */
+					saved_flag = flag + 0x10000;
+					*data = dbuf;
+					return n;
+				}
+				/*
+				 * At this point the decompressor should
+				 * be expecting to see the 0, 0, ff, ff bytes.
+				 */
+				if (!inflateSyncPoint(&rx_strm)) {
+					rprintf(FERROR, "decompressor lost sync!\n");
+					exit_cleanup(RERR_STREAMIO);
+				}
+				rx_strm.avail_in = 4;
+				rx_strm.next_in = (Bytef *)cbuf;
+				cbuf[0] = cbuf[1] = 0;
+				cbuf[2] = cbuf[3] = 0xff;
+				inflate(&rx_strm, Z_SYNC_FLUSH);
+				recv_state = r_idle;
+			}
+			if (flag == END_FLAG) {
+				/* that's all folks */
+				recv_state = r_init;
+				return 0;
+			}
+
+			/* here we have a token of some kind */
+			if (flag & TOKEN_REL) {
+				rx_token += flag & 0x3f;
+				flag >>= 6;
+			} else
+				rx_token = read_int(f);
+			if (flag & 1) {
+				rx_run = read_byte(f);
+				rx_run += read_byte(f) << 8;
+				recv_state = r_running;
+			}
+			return -1 - rx_token;
+
+		case r_inflating:
+			rx_strm.next_out = (Bytef *)dbuf;
+			rx_strm.avail_out = CHUNK_SIZE;
+			r = inflate(&rx_strm, Z_NO_FLUSH);
+			n = CHUNK_SIZE - rx_strm.avail_out;
+			if (r != Z_OK) {
+				rprintf(FERROR, "inflate returned %d (%d bytes)\n", r, n);
+				exit_cleanup(RERR_STREAMIO);
+			}
+			if (rx_strm.avail_in == 0)
+				recv_state = r_inflated;
+			if (n != 0) {
+				*data = dbuf;
+				return n;
+			}
+			break;
+
+		case r_running:
+			++rx_token;
+			if (--rx_run == 0)
+				recv_state = r_idle;
+			return -1 - rx_token;
 		}
-		recv_state = r_idle;
-	    }
-	    if (flag == END_FLAG) {
-		/* that's all folks */
-		recv_state = r_init;
-		return 0;
-	    }
-
-	    /* here we have a token of some kind */
-	    if (flag & TOKEN_REL) {
-		rx_token += flag & 0x3f;
-		flag >>= 6;
-	    } else
-		rx_token = read_int(f);
-	    if (flag & 1) {
-		rx_run = read_byte(f);
-		rx_run += read_byte(f) << 8;
-		recv_state = r_running;
-	    }
-	    return -1 - rx_token;
-
-	case r_inflating:
-	    rx_strm.next_out = (Bytef *)dbuf;
-	    rx_strm.avail_out = CHUNK_SIZE;
-	    r = inflate(&rx_strm, Z_NO_FLUSH);
-	    n = CHUNK_SIZE - rx_strm.avail_out;
-	    if (r != Z_OK) {
-		rprintf(FERROR, "inflate returned %d (%d bytes)\n", r, n);
-		exit_cleanup(1);
-	    }
-	    if (rx_strm.avail_in == 0)
-		recv_state = r_inflated;
-	    if (n != 0) {
-		*data = dbuf;
-		return n;
-	    }
-	    break;
-
-	case r_running:
-	    ++rx_token;
-	    if (--rx_run == 0)
-		recv_state = r_idle;
-	    return -1 - rx_token;
 	}
-    }
 }
 
 /*
  * put the data corresponding to a token that we've just returned
  * from recv_deflated_token into the decompressor's history buffer.
  */
-void
-see_deflate_token(char *buf, int len)
+static void see_deflate_token(char *buf, int len)
 {
-    int r;
+	int r, blklen;
+	unsigned char hdr[5];
 
-    rx_strm.next_in = (Bytef *)buf;
-    rx_strm.avail_in = len;
-    r = inflateIncomp(&rx_strm);
-    if (r != Z_OK) {
-	rprintf(FERROR, "inflateIncomp returned %d\n", r);
-	exit_cleanup(1);
-    }
+	rx_strm.avail_in = 0;
+	blklen = 0;
+	hdr[0] = 0;
+	do {
+		if (rx_strm.avail_in == 0 && len != 0) {
+			if (blklen == 0) {
+				/* Give it a fake stored-block header. */
+				rx_strm.next_in = (Bytef *)hdr;
+				rx_strm.avail_in = 5;
+				blklen = len;
+				if (blklen > 0xffff)
+					blklen = 0xffff;
+				hdr[1] = blklen;
+				hdr[2] = blklen >> 8;
+				hdr[3] = ~hdr[1];
+				hdr[4] = ~hdr[2];
+			} else {
+				rx_strm.next_in = (Bytef *)buf;
+				rx_strm.avail_in = blklen;
+				len -= blklen;
+				blklen = 0;
+			}
+		}
+		rx_strm.next_out = (Bytef *)dbuf;
+		rx_strm.avail_out = CHUNK_SIZE;
+		r = inflate(&rx_strm, Z_SYNC_FLUSH);
+		if (r != Z_OK) {
+			rprintf(FERROR, "inflate (token) returned %d\n", r);
+			exit_cleanup(RERR_STREAMIO);
+		}
+	} while (len || rx_strm.avail_out == 0);
 }
 
 /*
@@ -351,14 +446,14 @@ see_deflate_token(char *buf, int len)
  * If token == -1 then we have reached EOF 
  * If n == 0 then don't send a buffer
  */
-void send_token(int f,int token,struct map_struct *buf,int offset,
+void send_token(int f,int token,struct map_struct *buf,OFF_T offset,
 		int n,int toklen)
 {
-  if (!do_compression) {
-    simple_send_token(f,token,buf,offset,n);
-  } else {
-    send_deflated_token(f, token, buf, offset, n, toklen);
-  }
+	if (!do_compression) {
+		simple_send_token(f,token,buf,offset,n);
+	} else {
+		send_deflated_token(f, token, buf, offset, n, toklen);
+	}
 }
 
 
@@ -370,14 +465,14 @@ void send_token(int f,int token,struct map_struct *buf,int offset,
  */
 int recv_token(int f,char **data)
 {
-  int tok;
+	int tok;
 
-  if (!do_compression) {
-    tok = simple_recv_token(f,data);
-  } else {
-    tok = recv_deflated_token(f, data);
-  }
-  return tok;
+	if (!do_compression) {
+		tok = simple_recv_token(f,data);
+	} else {
+		tok = recv_deflated_token(f, data);
+	}
+	return tok;
 }
 
 /*
@@ -385,6 +480,6 @@ int recv_token(int f,char **data)
  */
 void see_token(char *data, int toklen)
 {
-    if (do_compression)
-	see_deflate_token(data, toklen);
+	if (do_compression)
+		see_deflate_token(data, toklen);
 }

uidlist.c

@@ -28,6 +28,7 @@
 extern int preserve_uid;
 extern int preserve_gid;
 extern int numeric_ids;
+extern int am_root;
 
 struct idlist {
 	struct idlist *next;
@@ -122,7 +123,10 @@ static gid_t match_gid(gid_t gid)
 		list = list->next;
 	}
 	
-	last_out = gid;
+	if (am_root)
+		last_out = gid;
+	else
+		last_out = (gid_t) -1;
 	return last_out;
 }
 
@@ -276,12 +280,12 @@ void recv_uid_list(int f, struct file_list *flist)
 		}
 	}
 
-	if (!uidlist && !gidlist) return;
+	if (!(am_root && preserve_uid) && !preserve_gid) return;
 
 	/* now convert the uid/gid of all files in the list to the mapped
 	   uid/gid */
 	for (i=0;i<flist->count;i++) {
-		if (preserve_uid && flist->files[i]->uid != 0) {
+		if (am_root && preserve_uid && flist->files[i]->uid != 0) {
 			flist->files[i]->uid = match_uid(flist->files[i]->uid);
 		}
 		if (preserve_gid && flist->files[i]->gid != 0) {

util.c

@@ -24,117 +24,92 @@
   */
 #include "rsync.h"
 
-int num_waiting(int fd)
+extern int verbose;
+
+
+/****************************************************************************
+Set a fd into nonblocking mode
+****************************************************************************/
+void set_nonblocking(int fd)
 {
-  int len=0;
-  ioctl(fd,FIONREAD,&len);
-  return(len);
+	int val;
+
+	if((val = fcntl(fd, F_GETFL, 0)) == -1)
+		return;
+	if (!(val & NONBLOCK_FLAG)) {
+		val |= NONBLOCK_FLAG;
+		fcntl(fd, F_SETFL, val);
+	}
+}
+
+/****************************************************************************
+Set a fd into blocking mode
+****************************************************************************/
+void set_blocking(int fd)
+{
+	int val;
+
+	if((val = fcntl(fd, F_GETFL, 0)) == -1)
+		return;
+	if (val & NONBLOCK_FLAG) {
+		val &= ~NONBLOCK_FLAG;
+		fcntl(fd, F_SETFL, val);
+	}
 }
 
 
-struct map_struct *map_file(int fd,OFF_T len)
+/* create a file descriptor pair - like pipe() but use socketpair if
+   possible (because of blocking issues on pipes)
+
+   always set non-blocking
+ */
+int fd_pair(int fd[2])
 {
-  struct map_struct *ret;
-  ret = (struct map_struct *)malloc(sizeof(*ret));
-  if (!ret) out_of_memory("map_file");
+	int ret;
 
-  ret->map = NULL;
-  ret->fd = fd;
-  ret->size = len;
-  ret->p = NULL;
-  ret->p_size = 0;
-  ret->p_offset = 0;
-  ret->p_len = 0;
-
-#ifdef HAVE_MMAP
-  if (len < MAX_MAP_SIZE) {
-	  ret->map = (char *)mmap(NULL,len,PROT_READ,MAP_SHARED,fd,0);
-	  if (ret->map == (char *)-1) {
-		  ret->map = NULL;
-	  }
-  }
+#if HAVE_SOCKETPAIR
+	ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
+#else
+	ret = pipe(fd);
 #endif
-  return ret;
+
+	if (ret == 0) {
+		set_nonblocking(fd[0]);
+		set_nonblocking(fd[1]);
+	}
+	
+	return ret;
 }
 
 
-char *map_ptr(struct map_struct *map,OFF_T offset,int len)
-{
-	int nread;
+/* this is derived from CVS code 
 
-	if (map->map)
-		return map->map+offset;
+   note that in the child STDIN is set to blocking and STDOUT
+   is set to non-blocking. This is necessary as rsh relies on stdin being blocking
+   and ssh relies on stdout being non-blocking
 
-	if (len == 0) 
-		return NULL;
-
-	if (len > (map->size-offset))
-		len = map->size-offset;
-
-	if (offset >= map->p_offset && 
-	    offset+len <= map->p_offset+map->p_len) {
-		return (map->p + (offset - map->p_offset));
-	}
-
-	len = MAX(len,CHUNK_SIZE);
-	if (len > (map->size-offset))
-		len = map->size-offset;
-
-	if (len > map->p_size) {
-		if (map->p) free(map->p);
-		map->p = (char *)malloc(len);
-		if (!map->p) out_of_memory("map_ptr");
-		map->p_size = len;
-	}
-
-	map->p_offset = offset;
-	map->p_len = len;
-
-	if (do_lseek(map->fd,offset,SEEK_SET) != offset) {
-		rprintf(FERROR,"lseek failed in map_ptr\n");
-		exit_cleanup(1);
-	}
-
-	if ((nread=read(map->fd,map->p,len)) != len) {		
-		if (nread < 0) nread = 0;
-		/* the best we can do is zero the buffer - the file
-                   has changed mid transfer! */
-		memset(map->p+nread, 0, len - nread);
-	}
-  
-	return map->p; 
-}
-
-
-void unmap_file(struct map_struct *map)
-{
-#ifdef HAVE_MMAP
-  if (map->map)
-    munmap(map->map,map->size);
-#endif
-  if (map->p) free(map->p);
-  free(map);
-}
-
-
-/* this is taken from CVS */
+   if blocking_io is set then use blocking io on both fds. That can be
+   used to cope with badly broken rsh implementations like the one on
+   solaris.
+ */
 int piped_child(char **command,int *f_in,int *f_out)
 {
   int pid;
   int to_child_pipe[2];
   int from_child_pipe[2];
+  extern int blocking_io;
 
-  if (pipe(to_child_pipe) < 0 ||
-      pipe(from_child_pipe) < 0) {
+  if (fd_pair(to_child_pipe) < 0 ||
+      fd_pair(from_child_pipe) < 0) {
     rprintf(FERROR,"pipe: %s\n",strerror(errno));
-    exit_cleanup(1);
+    exit_cleanup(RERR_IPC);
   }
 
 
   pid = do_fork();
   if (pid < 0) {
     rprintf(FERROR,"fork: %s\n",strerror(errno));
-    exit_cleanup(1);
+    exit_cleanup(RERR_IPC);
   }
 
   if (pid == 0)
@@ -145,26 +120,30 @@ int piped_child(char **command,int *f_in,int *f_out)
 	  close(from_child_pipe[0]) < 0 ||
 	  dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
 	rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
-	exit_cleanup(1);
+	exit_cleanup(RERR_IPC);
       }
       if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
       if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
       umask(orig_umask);
+      set_blocking(STDIN_FILENO);
+      if (blocking_io) {
+	set_blocking(STDOUT_FILENO);
+      }
       execvp(command[0], command);
       rprintf(FERROR,"Failed to exec %s : %s\n",
 	      command[0],strerror(errno));
-      exit_cleanup(1);
+      exit_cleanup(RERR_IPC);
     }
 
   if (close(from_child_pipe[1]) < 0 ||
       close(to_child_pipe[0]) < 0) {
     rprintf(FERROR,"Failed to close : %s\n",strerror(errno));   
-    exit_cleanup(1);
+    exit_cleanup(RERR_IPC);
   }
 
   *f_in = from_child_pipe[0];
   *f_out = to_child_pipe[1];
-  
+
   return pid;
 }
 
@@ -174,17 +153,17 @@ int local_child(int argc, char **argv,int *f_in,int *f_out)
 	int to_child_pipe[2];
 	int from_child_pipe[2];
 
-	if (pipe(to_child_pipe) < 0 ||
-	    pipe(from_child_pipe) < 0) {
+	if (fd_pair(to_child_pipe) < 0 ||
+	    fd_pair(from_child_pipe) < 0) {
 		rprintf(FERROR,"pipe: %s\n",strerror(errno));
-		exit_cleanup(1);
+		exit_cleanup(RERR_IPC);
 	}
 
 
 	pid = do_fork();
 	if (pid < 0) {
 		rprintf(FERROR,"fork: %s\n",strerror(errno));
-		exit_cleanup(1);
+		exit_cleanup(RERR_IPC);
 	}
 
 	if (pid == 0) {
@@ -199,7 +178,7 @@ int local_child(int argc, char **argv,int *f_in,int *f_out)
 		    close(from_child_pipe[0]) < 0 ||
 		    dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
 			rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
-			exit_cleanup(1);
+			exit_cleanup(RERR_IPC);
 		}
 		if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
 		if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
@@ -209,7 +188,7 @@ int local_child(int argc, char **argv,int *f_in,int *f_out)
 	if (close(from_child_pipe[1]) < 0 ||
 	    close(to_child_pipe[0]) < 0) {
 		rprintf(FERROR,"Failed to close : %s\n",strerror(errno));   
-		exit_cleanup(1);
+		exit_cleanup(RERR_IPC);
 	}
 
 	*f_in = from_child_pipe[0];
@@ -223,13 +202,13 @@ int local_child(int argc, char **argv,int *f_in,int *f_out)
 void out_of_memory(char *str)
 {
   rprintf(FERROR,"ERROR: out of memory in %s\n",str);
-  exit_cleanup(1);
+  exit_cleanup(RERR_MALLOC);
 }
 
 void overflow(char *str)
 {
   rprintf(FERROR,"ERROR: buffer overflow in %s\n",str);
-  exit_cleanup(1);
+  exit_cleanup(RERR_MALLOC);
 }
 
 
@@ -261,36 +240,6 @@ int set_modtime(char *fname,time_t modtime)
 }
 
 
-
-/****************************************************************************
-Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
-else
-if SYSV use O_NDELAY
-if BSD use FNDELAY
-****************************************************************************/
-int set_blocking(int fd, int set)
-{
-  int val;
-#ifdef O_NONBLOCK
-#define FLAG_TO_SET O_NONBLOCK
-#else
-#ifdef SYSV
-#define FLAG_TO_SET O_NDELAY
-#else /* BSD */
-#define FLAG_TO_SET FNDELAY
-#endif
-#endif
-
-  if((val = fcntl(fd, F_GETFL, 0)) == -1)
-	return -1;
-  if(set) /* Turn blocking on - ie. clear nonblock flag */
-	val &= ~FLAG_TO_SET;
-  else
-    val |= FLAG_TO_SET;
-  return fcntl( fd, F_SETFL, val);
-#undef FLAG_TO_SET
-}
-
 /****************************************************************************
 create any necessary directories in fname. Unfortunately we don't know
 what perms to give the directory when this is called so we need to rely
@@ -320,7 +269,7 @@ int create_directory_path(char *fname)
 
    derived from GNU C's cccp.c.
 */
-int full_write(int desc, char *ptr, int len)
+static int full_write(int desc, char *ptr, int len)
 {
 	int total_written;
 	
@@ -346,7 +295,7 @@ int full_write(int desc, char *ptr, int len)
    for an error.  
 
    derived from GNU C's cccp.c. */
-int safe_read(int desc, char *ptr, int len)
+static int safe_read(int desc, char *ptr, int len)
 {
 	int n_chars;
  
@@ -373,21 +322,21 @@ int copy_file(char *source, char *dest, mode_t mode)
 	char buf[1024 * 8];
 	int len;   /* Number of bytes read into `buf'. */
 
-	ifd = open(source, O_RDONLY);
+	ifd = do_open(source, O_RDONLY, 0);
 	if (ifd == -1) {
 		rprintf(FERROR,"open %s: %s\n",
 			source,strerror(errno));
 		return -1;
 	}
 
-	if (do_unlink(dest) && errno != ENOENT) {
+	if (robust_unlink(dest) && errno != ENOENT) {
 		rprintf(FERROR,"unlink %s: %s\n",
 			dest,strerror(errno));
 		return -1;
 	}
 
 	ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
-	if (ofd < 0) {
+	if (ofd == -1) {
 		rprintf(FERROR,"open %s: %s\n",
 			dest,strerror(errno));
 		close(ifd);
@@ -416,14 +365,78 @@ int copy_file(char *source, char *dest, mode_t mode)
 	return 0;
 }
 
-/* sleep for a while via select */
-void u_sleep(int usec)
-{
-	struct timeval tv;
+/*
+  Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
+  rename to <path>/.rsyncNNN instead. Note that successive rsync runs
+  will shuffle the filenames around a bit as long as the file is still
+  busy; this is because this function does not know if the unlink call
+  is due to a new file coming in, or --delete trying to remove old
+  .rsyncNNN files, hence it renames it each time.
+*/
+/* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
+#define MAX_RENAMES_DIGITS 3
+#define MAX_RENAMES 1000
 
-	tv.tv_sec = 0;
-	tv.tv_usec = usec;
-	select(0, NULL, NULL, NULL, &tv);
+int robust_unlink(char *fname)
+{
+#ifndef ETXTBSY
+	return do_unlink(fname);
+#else
+	static int counter = 1;
+	int rc, pos, start;
+	char path[MAXPATHLEN];
+
+	rc = do_unlink(fname);
+	if ((rc == 0) || (errno != ETXTBSY))
+		return rc;
+
+	strlcpy(path, fname, MAXPATHLEN);
+
+	pos = strlen(path);
+	while((path[--pos] != '/') && (pos >= 0))
+		;
+	++pos;
+	strlcpy(&path[pos], ".rsync", MAXPATHLEN-pos);
+	pos += sizeof(".rsync")-1;
+
+	if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
+		errno = ETXTBSY;
+		return -1;
+	}
+
+	/* start where the last one left off to reduce chance of clashes */
+	start = counter;
+	do {
+		sprintf(&path[pos], "%03d", counter);
+		if (++counter >= MAX_RENAMES)
+			counter = 1;
+	} while (((rc = access(path, 0)) == 0) && (counter != start));
+
+	if (verbose > 0)
+		rprintf(FINFO,"renaming %s to %s because of text busy\n",
+					    fname, path);
+
+	/* maybe we should return rename()'s exit status? Nah. */
+	if (do_rename(fname, path) != 0) {
+		errno = ETXTBSY;
+		return -1;
+	}
+	return 0;
+#endif
+}
+
+int robust_rename(char *from, char *to)
+{
+#ifndef ETXTBSY
+	return do_rename(from, to);
+#else
+	int rc = do_rename(from, to);
+	if ((rc == 0) || (errno != ETXTBSY))
+		return rc;
+	if (robust_unlink(to) != 0)
+		return -1;
+	return do_rename(from, to);
+#endif
 }
 
 
@@ -451,31 +464,6 @@ void kill_all(int sig)
 	}
 }
 
-/* like strncpy but does not 0 fill the buffer and always null 
-   terminates (thus it can use maxlen+1 space in d) */
-void strlcpy(char *d, char *s, int maxlen)
-{
-	int len = strlen(s);
-	if (len > maxlen) len = maxlen;
-	memcpy(d, s, len);
-	d[len] = 0;
-}
-
-/* like strncat but does not 0 fill the buffer and always null 
-   terminates (thus it can use maxlen+1 space in d) */
-void strlcat(char *d, char *s, int maxlen)
-{
-	int len1 = strlen(d);
-	int len2 = strlen(s);
-	if (len1+len2 > maxlen) {
-		len2 = maxlen-len1;
-	}
-	if (len2 > 0) {
-		memcpy(d+len1, s, len2);
-		d[len1+len2] = 0;
-	}
-}
-
 /* turn a user name into a uid */
 int name_to_uid(char *name, uid_t *uid)
 {
@@ -503,14 +491,6 @@ int name_to_gid(char *name, gid_t *gid)
 }
 
 
-/****************************************************************************
-check if a process exists. 
-****************************************************************************/
-int process_exists(int pid)
-{
-	return(kill(pid,0) == 0 || errno != ESRCH);
-}
-
 /* lock a byte range in a open file */
 int lock_range(int fd, int offset, int len)
 {
@@ -528,18 +508,22 @@ int lock_range(int fd, int offset, int len)
 
 static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
 {
-#ifndef HAVE_GLOB
+#if !(defined(HAVE_GLOB) && defined(HAVE_GLOB_H))
 	if (!*s) s = ".";
 	argv[*argc] = strdup(s);
 	(*argc)++;
 	return;
 #else
+	extern int sanitize_paths;
 	glob_t globbuf;
 	int i;
 
 	if (!*s) s = ".";
 
 	argv[*argc] = strdup(s);
+	if (sanitize_paths) {
+		sanitize_path(argv[*argc], NULL);
+	}
 
 	memset(&globbuf, 0, sizeof(globbuf));
 	glob(argv[*argc], 0, NULL, &globbuf);
@@ -558,10 +542,11 @@ static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
 #endif
 }
 
-void glob_expand(char *base, char **argv, int *argc, int maxargs)
+void glob_expand(char *base1, char **argv, int *argc, int maxargs)
 {
 	char *s = argv[*argc];
 	char *p, *q;
+	char *base = base1;
 
 	if (!s || !*s) return;
 
@@ -572,21 +557,23 @@ void glob_expand(char *base, char **argv, int *argc, int maxargs)
 	s = strdup(s);
 	if (!s) out_of_memory("glob_expand");
 
+	base = (char *)malloc(strlen(base1)+3);
+	if (!base) out_of_memory("glob_expand");
+
+	sprintf(base," %s/", base1);
+
 	q = s;
 	while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
-		if (p != q && *(p-1) == ' ' && p[strlen(base)] == '/') {
-			/* split it at this point */
-			*(p-1) = 0;
-			glob_expand_one(q, argv, argc, maxargs);
-			q = p+strlen(base)+1;
-		} else {
-			q++;
-		}
+		/* split it at this point */
+		*p = 0;
+		glob_expand_one(q, argv, argc, maxargs);
+		q = p+strlen(base);
 	}
 
 	if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
 
 	free(s);
+	free(base);
 }
 
 /*******************************************************************
@@ -600,62 +587,17 @@ void strlower(char *s)
 	}
 }
 
-/* this is like vsnprintf but the 'n' limit does not include
-   the terminating null. So if you have a 1024 byte buffer then
-   pass 1023 for n */
+/* this is like vsnprintf but it always null terminates, so you
+   can fit at most n-1 chars in */
 int vslprintf(char *str, int n, const char *format, va_list ap)
 {
-#ifdef HAVE_VSNPRINTF
 	int ret = vsnprintf(str, n, format, ap);
-	if (ret > n || ret < 0) {
-		str[n] = 0;
+	if (ret >= n || ret < 0) {
+		str[n-1] = 0;
 		return -1;
 	}
 	str[ret] = 0;
 	return ret;
-#else
-	static char *buf;
-	static int len=MAXPATHLEN*8;
-	int ret;
-
-	/* this code is NOT a proper vsnprintf() implementation. It
-	   relies on the fact that all calls to slprintf() in rsync
-	   pass strings which have already been checked to be less
-	   than MAXPATHLEN in length and never more than 2 strings are
-	   concatenated. This means the above buffer is absolutely
-	   ample and can never be overflowed.
-
-	   In the future we would like to replace this with a proper
-	   vsnprintf() implementation but right now we need a solution
-	   that is secure and portable. This is it.  */
-
-	if (!buf) {
-		buf = malloc(len);
-		if (!buf) {
-			/* can't call debug or we would recurse */
-			exit(1);
-		}
-	}
-
-	ret = vsprintf(buf, format, ap);
-
-	if (ret < 0) {
-		str[0] = 0;
-		return -1;
-	}
-
-	if (ret < n) {
-		n = ret;
-	} else if (ret > n) {
-		ret = -1;
-	}
-
-	buf[n] = 0;
-	
-	memcpy(str, buf, n+1);
-
-	return ret;
-#endif
 }
 
 
@@ -670,3 +612,376 @@ int slprintf(char *str, int n, char *format, ...)
 	va_end(ap);
 	return ret;
 }
+
+
+void *Realloc(void *p, int size)
+{
+	if (!p) return (void *)malloc(size);
+	return (void *)realloc(p, size);
+}
+
+
+void clean_fname(char *name)
+{
+	char *p;
+	int l;
+	int modified = 1;
+
+	if (!name) return;
+
+	while (modified) {
+		modified = 0;
+
+		if ((p=strstr(name,"/./"))) {
+			modified = 1;
+			while (*p) {
+				p[0] = p[2];
+				p++;
+			}
+		}
+
+		if ((p=strstr(name,"//"))) {
+			modified = 1;
+			while (*p) {
+				p[0] = p[1];
+				p++;
+			}
+		}
+
+		if (strncmp(p=name,"./",2) == 0) {      
+			modified = 1;
+			do {
+				p[0] = p[2];
+			} while (*p++);
+		}
+
+		l = strlen(p=name);
+		if (l > 1 && p[l-1] == '/') {
+			modified = 1;
+			p[l-1] = 0;
+		}
+	}
+}
+
+/*
+ * Make path appear as if a chroot had occurred:
+ *    1. remove leading "/" (or replace with "." if at end)
+ *    2. remove leading ".." components (except those allowed by "reldir")
+ *    3. delete any other "<dir>/.." (recursively)
+ * Can only shrink paths, so sanitizes in place.
+ * While we're at it, remove double slashes and "." components like
+ *   clean_fname does(), but DON'T remove a trailing slash because that
+ *   is sometimes significant on command line arguments.
+ * If "reldir" is non-null, it is a sanitized directory that the path will be
+ *    relative to, so allow as many ".." at the beginning of the path as
+ *    there are components in reldir.  This is used for symbolic link targets.
+ *    If reldir is non-null and the path began with "/", to be completely like
+ *    a chroot we should add in depth levels of ".." at the beginning of the
+ *    path, but that would blow the assumption that the path doesn't grow and
+ *    it is not likely to end up being a valid symlink anyway, so just do
+ *    the normal removal of the leading "/" instead.
+ * Contributed by Dave Dykstra <dwd@bell-labs.com>
+ */
+
+void sanitize_path(char *p, char *reldir)
+{
+	char *start, *sanp;
+	int depth = 0;
+	int allowdotdot = 0;
+
+	if (reldir) {
+		depth++;
+		while (*reldir) {
+			if (*reldir++ == '/') {
+				depth++;
+			}
+		}
+	}
+	start = p;
+	sanp = p;
+	while (*p == '/') {
+		/* remove leading slashes */
+		p++;
+	}
+	while (*p != '\0') {
+		/* this loop iterates once per filename component in p.
+		 * both p (and sanp if the original had a slash) should
+		 * always be left pointing after a slash
+		 */
+		if ((*p == '.') && ((*(p+1) == '/') || (*(p+1) == '\0'))) {
+			/* skip "." component */
+			while (*++p == '/') {
+				/* skip following slashes */
+				;
+			}
+			continue;
+		}
+		allowdotdot = 0;
+		if ((*p == '.') && (*(p+1) == '.') &&
+			    ((*(p+2) == '/') || (*(p+2) == '\0'))) {
+			/* ".." component followed by slash or end */
+			if ((depth > 0) && (sanp == start)) {
+				/* allow depth levels of .. at the beginning */
+				--depth;
+				allowdotdot = 1;
+			} else {
+				p += 2;
+				if (*p == '/')
+					p++;
+				if (sanp != start) {
+					/* back up sanp one level */
+					--sanp; /* now pointing at slash */
+					while ((sanp > start) && (*(sanp - 1) != '/')) {
+						/* skip back up to slash */
+						sanp--;
+					}
+				}
+				continue;
+			}
+		}
+		while (1) {
+			/* copy one component through next slash */
+			*sanp++ = *p++;
+			if ((*p == '\0') || (*(p-1) == '/')) {
+				while (*p == '/') {
+					/* skip multiple slashes */
+					p++;
+				}
+				break;
+			}
+		}
+		if (allowdotdot) {
+			/* move the virtual beginning to leave the .. alone */
+			start = sanp;
+		}
+	}
+	if ((sanp == start) && !allowdotdot) {
+		/* ended up with nothing, so put in "." component */
+		/*
+		 * note that the !allowdotdot doesn't prevent this from
+		 *  happening in all allowed ".." situations, but I didn't
+		 *  think it was worth putting in an extra variable to ensure
+		 *  it since an extra "." won't hurt in those situations.
+		 */
+		*sanp++ = '.';
+	}
+	*sanp = '\0';
+}
+
+
+static char curr_dir[MAXPATHLEN];
+
+/* like chdir() but can be reversed with pop_dir() if save is set. It
+   is also much faster as it remembers where we have been */
+char *push_dir(char *dir, int save)
+{
+	char *ret = curr_dir;
+	static int initialised;
+
+	if (!initialised) {
+		initialised = 1;
+		getcwd(curr_dir, sizeof(curr_dir)-1);
+	}
+
+	if (!dir) return NULL; /* this call was probably just to initialize */
+
+	if (chdir(dir)) return NULL;
+
+	if (save) {
+		ret = strdup(curr_dir);
+	}
+
+	if (*dir == '/') {
+		strlcpy(curr_dir, dir, sizeof(curr_dir));
+	} else {
+		strlcat(curr_dir,"/", sizeof(curr_dir));
+		strlcat(curr_dir,dir, sizeof(curr_dir));
+	}
+
+	clean_fname(curr_dir);
+
+	return ret;
+}
+
+/* reverse a push_dir call */
+int pop_dir(char *dir)
+{
+	int ret;
+
+	ret = chdir(dir);
+	if (ret) {
+		free(dir);
+		return ret;
+	}
+
+	strlcpy(curr_dir, dir, sizeof(curr_dir));
+
+	free(dir);
+
+	return 0;
+}
+
+/* we need to supply our own strcmp function for file list comparisons
+   to ensure that signed/unsigned usage is consistent between machines. */
+int u_strcmp(const char *cs1, const char *cs2)
+{
+	const uchar *s1 = (const uchar *)cs1;
+	const uchar *s2 = (const uchar *)cs2;
+
+	while (*s1 && *s2 && (*s1 == *s2)) {
+		s1++; s2++;
+	}
+	
+	return (int)*s1 - (int)*s2;
+}
+
+static OFF_T last_ofs;
+
+void end_progress(OFF_T size)
+{
+	extern int do_progress, am_server;
+
+	if (do_progress && !am_server) {
+		rprintf(FINFO,"%.0f (100%%)\n", (double)size);
+	}
+	last_ofs = 0;
+}
+
+void show_progress(OFF_T ofs, OFF_T size)
+{
+	extern int do_progress, am_server;
+
+	if (do_progress && !am_server) {
+		if (ofs > last_ofs + 1000) {
+			int pct = (int)((100.0*ofs)/size);
+			rprintf(FINFO,"%.0f (%d%%)\r", (double)ofs, pct);
+			last_ofs = ofs;
+		}
+	}
+}
+
+/* determine if a symlink points outside the current directory tree */
+int unsafe_symlink(char *dest, char *src)
+{
+	char *tok;
+	int depth = 0;
+
+	/* all absolute and null symlinks are unsafe */
+	if (!dest || !(*dest) || (*dest == '/')) return 1;
+
+	src = strdup(src);
+	if (!src) out_of_memory("unsafe_symlink");
+
+	/* find out what our safety margin is */
+	for (tok=strtok(src,"/"); tok; tok=strtok(NULL,"/")) {
+		if (strcmp(tok,"..") == 0) {
+			depth=0;
+		} else if (strcmp(tok,".") == 0) {
+			/* nothing */
+		} else {
+			depth++;
+		}
+	}
+	free(src);
+
+	/* drop by one to account for the filename portion */
+	depth--;
+
+	dest = strdup(dest);
+	if (!dest) out_of_memory("unsafe_symlink");
+
+	for (tok=strtok(dest,"/"); tok; tok=strtok(NULL,"/")) {
+		if (strcmp(tok,"..") == 0) {
+			depth--;
+		} else if (strcmp(tok,".") == 0) {
+			/* nothing */
+		} else {
+			depth++;
+		}
+		/* if at any point we go outside the current directory then
+		   stop - it is unsafe */
+		if (depth < 0) break;
+	}
+
+	free(dest);
+	return (depth < 0);
+}
+
+
+/****************************************************************************
+  return the date and time as a string
+****************************************************************************/
+char *timestring(time_t t)
+{
+	static char TimeBuf[200];
+	struct tm *tm = localtime(&t);
+
+#ifdef HAVE_STRFTIME
+	strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %T",tm);
+#else
+	strlcpy(TimeBuf, asctime(tm), sizeof(TimeBuf));
+#endif
+
+	if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
+		TimeBuf[strlen(TimeBuf)-1] = 0;
+	}
+
+	return(TimeBuf);
+}
+
+
+/*******************************************************************
+sleep for a specified number of milliseconds
+********************************************************************/
+void msleep(int t)
+{
+	int tdiff=0;
+	struct timeval tval,t1,t2;  
+
+	gettimeofday(&t1, NULL);
+	gettimeofday(&t2, NULL);
+  
+	while (tdiff < t) {
+		tval.tv_sec = (t-tdiff)/1000;
+		tval.tv_usec = 1000*((t-tdiff)%1000);
+ 
+		errno = 0;
+		select(0,NULL,NULL, NULL, &tval);
+
+		gettimeofday(&t2, NULL);
+		tdiff = (t2.tv_sec - t1.tv_sec)*1000 + 
+			(t2.tv_usec - t1.tv_usec)/1000;
+	}
+}
+
+
+#ifdef __INSURE__
+#include <dlfcn.h>
+
+/*******************************************************************
+This routine is a trick to immediately catch errors when debugging
+with insure. A xterm with a gdb is popped up when insure catches
+a error. It is Linux specific.
+********************************************************************/
+int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
+{
+	static int (*fn)();
+	int ret;
+	char cmd[1024];
+
+	sprintf(cmd, "/usr/X11R6/bin/xterm -display :0 -T Panic -n Panic -e /bin/sh -c 'cat /tmp/ierrs.*.%d ; gdb /proc/%d/exe %d'", 
+		getpid(), getpid(), getpid());
+
+	if (!fn) {
+		static void *h;
+		h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
+		fn = dlsym(h, "_Insure_trap_error");
+	}
+
+	ret = fn(a1, a2, a3, a4, a5, a6);
+
+	system(cmd);
+
+	return ret;
+}
+#endif

version.h

@@ -1 +1 @@
-#define VERSION "2.0.5"
+#define VERSION "2.4.5"

zlib/README.rsync

@@ -0,0 +1,19 @@
+zlib has been adapted slightly for use in rsync. Please don't bother
+the zlib authors with problems related to the use of zlib in rsync as
+any bugs are likely to be our fault and not theirs.
+
+Specific changes that have been made to zlib for rsync include:
+
+- add Z_INSERT_ONLY to allow for efficient history updating without
+  actually emitting any data. This is used to compress the matched
+  blocks that don't cross the wire, which gives better compression
+  ratios on the literal data.
+
+- fixed a number of minor compilation issues. (redefinition of MAX and
+  other such trivial things)
+
+- include rsync.h to ensure that we get a consistent set of includes
+  for all C code in rsync and to take advantage of autoconf
+
+--
+Paul Mackerras and Andrew Tridgell

zlib/deflate.c

@@ -80,7 +80,7 @@ local block_state deflate_slow   OF((deflate_state *s, int flush));
 local void lm_init        OF((deflate_state *s));
 local void putShortMSB    OF((deflate_state *s, uInt b));
 local void flush_pending  OF((z_streamp strm));
-local int read_buf        OF((z_streamp strm, Bytef *buf, unsigned size));
+local int dread_buf        OF((z_streamp strm, Bytef *buf, unsigned size));
 #ifdef ASMV
       void match_init OF((void)); /* asm code initialization */
       uInt longest_match  OF((deflate_state *s, IPos cur_match));
@@ -411,7 +411,7 @@ local void putShortMSB (s, b)
  * Flush as much pending output as possible. All deflate() output goes
  * through this function so some applications may wish to modify it
  * to avoid allocating a large strm->next_out buffer and copying into it.
- * (See also read_buf()).
+ * (See also dread_buf()).
  */
 local void flush_pending(strm)
     z_streamp strm;
@@ -441,7 +441,7 @@ int ZEXPORT deflate (strm, flush)
     deflate_state *s;
 
     if (strm == Z_NULL || strm->state == Z_NULL ||
-	flush > Z_FINISH || flush < 0) {
+	flush > Z_INSERT_ONLY || flush < 0) {
         return Z_STREAM_ERROR;
     }
     s = strm->state;
@@ -657,7 +657,7 @@ int ZEXPORT deflateCopy (dest, source)
  * allocating a large strm->next_in buffer and copying from it.
  * (See also flush_pending()).
  */
-local int read_buf(strm, buf, size)
+local int dread_buf(strm, buf, size)
     z_streamp strm;
     Bytef *buf;
     unsigned size;
@@ -1028,7 +1028,7 @@ local void fill_window(s)
          */
         Assert(more >= 2, "more < 2");
 
-        n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
+        n = dread_buf(s->strm, s->window + s->strstart + s->lookahead, more);
         s->lookahead += n;
 
         /* Initialize the hash value now that we have some input: */
@@ -1162,6 +1162,12 @@ local block_state deflate_fast(s, flush)
             INSERT_STRING(s, s->strstart, hash_head);
         }
 
+	if (flush == Z_INSERT_ONLY) {
+	    s->strstart++;
+	    s->lookahead--;
+	    continue;
+	}
+
         /* Find the longest match, discarding those <= prev_length.
          * At this point we have always match_length < MIN_MATCH
          */
@@ -1221,6 +1227,10 @@ local block_state deflate_fast(s, flush)
         }
         if (bflush) FLUSH_BLOCK(s, 0);
     }
+    if (flush == Z_INSERT_ONLY) {
+	s->block_start = s->strstart;
+	return need_more;
+    }
     FLUSH_BLOCK(s, flush == Z_FINISH);
     return flush == Z_FINISH ? finish_done : block_done;
 }
@@ -1259,6 +1269,12 @@ local block_state deflate_slow(s, flush)
             INSERT_STRING(s, s->strstart, hash_head);
         }
 
+	if (flush == Z_INSERT_ONLY) {
+	    s->strstart++;
+	    s->lookahead--;
+	    continue;
+	}
+
         /* Find the longest match, discarding those <= prev_length.
          */
         s->prev_length = s->match_length, s->prev_match = s->match_start;
@@ -1337,6 +1353,10 @@ local block_state deflate_slow(s, flush)
             s->lookahead--;
         }
     }
+    if (flush == Z_INSERT_ONLY) {
+	s->block_start = s->strstart;
+	return need_more;
+    }
     Assert (flush != Z_NO_FLUSH, "no flush?");
     if (s->match_available) {
         Tracevv((stderr,"%c", s->window[s->strstart-1]));

zlib/infblock.c

@@ -176,7 +176,7 @@ int r;
           break;
         case 3:                         /* illegal */
           DUMPBITS(3)
-          s->mode = BAD;
+          s->mode = zBAD;
           z->msg = (char*)"invalid block type";
           r = Z_DATA_ERROR;
           LEAVE
@@ -186,7 +186,7 @@ int r;
       NEEDBITS(32)
       if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
       {
-        s->mode = BAD;
+        s->mode = zBAD;
         z->msg = (char*)"invalid stored block lengths";
         r = Z_DATA_ERROR;
         LEAVE
@@ -219,7 +219,7 @@ int r;
 #ifndef PKZIP_BUG_WORKAROUND
       if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
       {
-        s->mode = BAD;
+        s->mode = zBAD;
         z->msg = (char*)"too many length or distance symbols";
         r = Z_DATA_ERROR;
         LEAVE
@@ -252,7 +252,7 @@ int r;
         ZFREE(z, s->sub.trees.blens);
         r = t;
         if (r == Z_DATA_ERROR)
-          s->mode = BAD;
+          s->mode = zBAD;
         LEAVE
       }
       s->sub.trees.index = 0;
@@ -289,7 +289,7 @@ int r;
               (c == 16 && i < 1))
           {
             ZFREE(z, s->sub.trees.blens);
-            s->mode = BAD;
+            s->mode = zBAD;
             z->msg = (char*)"invalid bit length repeat";
             r = Z_DATA_ERROR;
             LEAVE
@@ -317,7 +317,7 @@ int r;
         if (t != Z_OK)
         {
           if (t == (uInt)Z_DATA_ERROR)
-            s->mode = BAD;
+            s->mode = zBAD;
           r = t;
           LEAVE
         }
@@ -361,7 +361,7 @@ int r;
     case DONE:
       r = Z_STREAM_END;
       LEAVE
-    case BAD:
+    case zBAD:
       r = Z_DATA_ERROR;
       LEAVE
     default:

zlib/inflate.c

@@ -22,7 +22,7 @@ typedef enum {
       CHECK2,   /* two check bytes to go */
       CHECK1,   /* one check byte to go */
       DONE,     /* finished check, done */
-      BAD}      /* got an error--stay here */
+      zBAD}      /* got an error--stay here */
 inflate_mode;
 
 /* inflate private state */
@@ -38,7 +38,7 @@ struct internal_state {
       uLong was;                /* computed check value */
       uLong need;               /* stream check value */
     } check;            /* if CHECK, check values to compare */
-    uInt marker;        /* if BAD, inflateSync's marker bytes count */
+    uInt marker;        /* if zBAD, inflateSync's marker bytes count */
   } sub;        /* submode */
 
   /* mode independent information */
@@ -164,14 +164,14 @@ int f;
       NEEDBYTE
       if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED)
       {
-        z->state->mode = BAD;
+        z->state->mode = zBAD;
         z->msg = (char*)"unknown compression method";
         z->state->sub.marker = 5;       /* can't try inflateSync */
         break;
       }
       if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
       {
-        z->state->mode = BAD;
+        z->state->mode = zBAD;
         z->msg = (char*)"invalid window size";
         z->state->sub.marker = 5;       /* can't try inflateSync */
         break;
@@ -182,7 +182,7 @@ int f;
       b = NEXTBYTE;
       if (((z->state->sub.method << 8) + b) % 31)
       {
-        z->state->mode = BAD;
+        z->state->mode = zBAD;
         z->msg = (char*)"incorrect header check";
         z->state->sub.marker = 5;       /* can't try inflateSync */
         break;
@@ -213,7 +213,7 @@ int f;
       z->state->mode = DICT0;
       return Z_NEED_DICT;
     case DICT0:
-      z->state->mode = BAD;
+      z->state->mode = zBAD;
       z->msg = (char*)"need dictionary";
       z->state->sub.marker = 0;       /* can try inflateSync */
       return Z_STREAM_ERROR;
@@ -221,7 +221,7 @@ int f;
       r = inflate_blocks(z->state->blocks, z, r);
       if (r == Z_DATA_ERROR)
       {
-        z->state->mode = BAD;
+        z->state->mode = zBAD;
         z->state->sub.marker = 0;       /* can try inflateSync */
         break;
       }
@@ -255,7 +255,7 @@ int f;
 
       if (z->state->sub.check.was != z->state->sub.check.need)
       {
-        z->state->mode = BAD;
+        z->state->mode = zBAD;
         z->msg = (char*)"incorrect data check";
         z->state->sub.marker = 5;       /* can't try inflateSync */
         break;
@@ -264,7 +264,7 @@ int f;
       z->state->mode = DONE;
     case DONE:
       return Z_STREAM_END;
-    case BAD:
+    case zBAD:
       return Z_DATA_ERROR;
     default:
       return Z_STREAM_ERROR;
@@ -310,9 +310,9 @@ z_streamp z;
   /* set up */
   if (z == Z_NULL || z->state == Z_NULL)
     return Z_STREAM_ERROR;
-  if (z->state->mode != BAD)
+  if (z->state->mode != zBAD)
   {
-    z->state->mode = BAD;
+    z->state->mode = zBAD;
     z->state->sub.marker = 0;
   }
   if ((n = z->avail_in) == 0)

zlib/infutil.h

@@ -21,7 +21,7 @@ typedef enum {
       CODES,    /* processing fixed or dynamic block */
       DRY,      /* output remaining window bytes */
       DONE,     /* finished last block, done */
-      BAD}      /* got a data error--stuck here */
+      zBAD}      /* got a data error--stuck here */
 inflate_block_mode;
 
 /* inflate blocks semi-private state */
@@ -77,9 +77,9 @@ struct inflate_blocks_state {
 /*   output bytes */
 #define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q)
 #define LOADOUT {q=s->write;m=(uInt)WAVAIL;}
-#define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}}
+#define ZWRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}}
 #define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT}
-#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;}
+#define NEEDOUT {if(m==0){ZWRAP if(m==0){FLUSH ZWRAP if(m==0) LEAVE}}r=Z_OK;}
 #define OUTBYTE(a) {*q++=(Byte)(a);m--;}
 /*   load local pointers */
 #define LOAD {LOADIN LOADOUT}

zlib/trees.c

@@ -230,7 +230,9 @@ local void send_bits(s, value, length)
 #endif /* DEBUG */
 
 
-#define MAX(a,b) (a >= b ? a : b)
+#ifndef MAX
+#define MAX(a,b) ((a) >= (b) ? (a) : (b))
+#endif
 /* the arguments must not have side effects */
 
 /* ===========================================================================
@@ -497,7 +499,7 @@ local void gen_bitlen(s, desc)
     int bits;           /* bit length */
     int xbits;          /* extra bits */
     ush f;              /* frequency */
-    int overflow = 0;   /* number of elements with bit length too large */
+    int Overflow = 0;   /* number of elements with bit length too large */
 
     for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
 
@@ -509,7 +511,7 @@ local void gen_bitlen(s, desc)
     for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
         n = s->heap[h];
         bits = tree[tree[n].Dad].Len + 1;
-        if (bits > max_length) bits = max_length, overflow++;
+        if (bits > max_length) bits = max_length, Overflow++;
         tree[n].Len = (ush)bits;
         /* We overwrite tree[n].Dad which is no longer needed */
 
@@ -522,7 +524,7 @@ local void gen_bitlen(s, desc)
         s->opt_len += (ulg)f * (bits + xbits);
         if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
     }
-    if (overflow == 0) return;
+    if (Overflow == 0) return;
 
     Trace((stderr,"\nbit length overflow\n"));
     /* This happens for example on obj2 and pic of the Calgary corpus */
@@ -537,8 +539,8 @@ local void gen_bitlen(s, desc)
         /* The brother of the overflow item also moves one step up,
          * but this does not affect bl_count[max_length]
          */
-        overflow -= 2;
-    } while (overflow > 0);
+        Overflow -= 2;
+    } while (Overflow > 0);
 
     /* Now recompute all bit lengths, scanning in increasing frequency.
      * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all

zlib/zlib.h

@@ -127,6 +127,7 @@ typedef z_stream FAR *z_streamp;
 #define Z_SYNC_FLUSH    2
 #define Z_FULL_FLUSH    3
 #define Z_FINISH        4
+#define Z_INSERT_ONLY	5
 /* Allowed flush values; see deflate() below for details */
 
 #define Z_OK            0

zlib/zutil.c

@@ -200,11 +200,6 @@ void  zcfree (voidpf opaque, voidpf ptr)
 
 #ifndef MY_ZCALLOC /* Any system without a special alloc function */
 
-#ifndef STDC
-extern voidp  calloc OF((uInt items, uInt size));
-extern void   free   OF((voidpf ptr));
-#endif
-
 voidpf zcalloc (opaque, items, size)
     voidpf opaque;
     unsigned items;

zlib/zutil.h

@@ -13,8 +13,10 @@
 #ifndef _Z_UTIL_H
 #define _Z_UTIL_H
 
+#include "../rsync.h"
 #include "zlib.h"
 
+#if 0
 #ifdef STDC
 #  include <stddef.h>
 #  include <string.h>
@@ -25,6 +27,7 @@
 #else
 #   include <errno.h>
 #endif
+#endif
 
 #ifndef local
 #  define local static