Get ready for new release.

server.  This ought to exercise (exorcise? :-) a bug in 2.5.3.  It
ought to fail there and pass with later versions.

.cvsignore

@@ -4,10 +4,15 @@ config.cache
 config.h
 config.log
 config.status
+gmon.out
 rsync
 shconfig
 testdir
 tests-dont-exist
 testtmp
+testtmp.*
 tls
 zlib/dummy
+confdefs.h
+conftest.c
+conftest.log

INSTALL

@@ -28,3 +28,15 @@ fails:
 Install gcc or HP's "ANSI/C Compiler".
 
 
+
+MAC OSX NOTES
+-------------
+
+Mac OS X (Darwin) seems to have an IPv6 stack, but it does not
+completely implement the "New Sockets" API.  
+
+<http://www.ipv6.org/impl/mac.html> says that Apple do not support
+IPv6 yet.  If your build fails, try again with --disable-ipv6.
+
+
+

Makefile.in

@@ -29,13 +29,14 @@ 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 batch.o
+OBJS2=options.o flist.o io.o compat.o hlink.o token.o uidlist.o socket.o fileio.o batch.o \
+	clientname.o
 DAEMON_OBJ = params.o loadparm.o clientserver.o access.o connection.o authenticate.o
 popt_OBJS=popt/findme.o  popt/popt.o  popt/poptconfig.o \
 	popt/popthelp.o popt/poptparse.o
 OBJS=$(OBJS1) $(OBJS2) $(DAEMON_OBJ) $(LIBOBJ) $(ZLIBOBJ) @BUILD_POPT@
 
-tls_OBJ = tls.o syscall.o lib/permstring.o 
+TLS_OBJ = tls.o syscall.o lib/permstring.o 
 
 # Programs we must have to run the test cases
 CHECK_PROGS = rsync tls
@@ -62,10 +63,13 @@ install-strip:
 	$(MAKE) INSTALLCMD='$(INSTALLCMD) -s' install
 
 rsync: $(OBJS)
+	@echo "Please ignore warnings below about mktemp -- it is used in a safe way"
 	$(CC) $(CFLAGS) $(LDFLAGS) -o rsync $(OBJS) $(LIBS)
 
-tls: $(tls_OBJ)
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(tls_OBJ) $(LIBS)
+$(OBJS): config.h
+
+tls: $(TLS_OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(TLS_OBJ) $(LIBS)
 
 Makefile: Makefile.in configure config.status
 	echo "WARNING: You need to run ./config.status --recheck"
@@ -81,7 +85,7 @@ rsyncd.conf.5: rsyncd.conf.yo
 	yodl2man -o rsyncd.conf.5 rsyncd.conf.yo
 
 proto:
-	cat *.c lib/compat.c | awk -f mkproto.awk > proto.h
+	cat $(srcdir)/*.c $(srcdir)/lib/compat.c | awk -f $(srcdir)/mkproto.awk > $(srcdir)/proto.h
 
 clean:
 	rm -f *~ $(OBJS) rsync $(TLS_OBJ) tls
@@ -129,3 +133,12 @@ installcheck: $(CHECK_PROGS)
 	POSIXLY_CORRECT=1 TLS=`pwd`/tls rsync_bin="$(bindir)/rsync" srcdir="$(srcdir)" $(srcdir)/runtests.sh
 
 # TODO: Add 'dist' target; need to know which files will be included
+
+rsync.dvi: doc/rsync.texinfo
+	texi2dvi -o $@ $<
+
+rsync.ps: rsync.dvi	
+	dvips -ta4 -o $@ $<
+
+rsync.pdf: doc/rsync.texinfo
+	texi2dvi -o $@ --pdf $<

NEWS

@@ -1,81 +1,16 @@
-rsync 2.4.7 (sometime in 2001, maybe :)		-*- indented-text -*- 
+rsync 2.5.4 (12 March 2002)
 
-  ANNOUNCEMENTS
-
-    * Martin Pool <mbp@samba.org> is now a co-maintainer.
-
-  NEW FEATURES
-
-    * Support for LSB-compliant packaging <http://www.linuxbase.org/>
-
-    * Shell wildcards are allowed in "auth users" lines.
-
-    * Merged UNC rsync+ patch to support creation of standalone patch
-      sets.  By Bert J. Dempsey and Debra Weiss, updated by Jos
-      Backus.  <http://www.ils.unc.edu/i2dsi/unc_rsync+.html>
-
-    * IPv6 support based on a patch from KAME.net, on systems
-      including modern versions of Linux, Solaris, and HP-UX.  Also
-      includes IPv6 compatibility functions for old OSs by the
-      Internet Software Consortium, Paul Vixie, the OpenSSH
-      portability project, and OpenBSD.
-
-  ENHANCEMENTS
-
-    * Include/exclude cluestick: with -vv, print out whether files are
-      included or excluded and why.
-
-    * Many error messages have more friendly explanations and more
-      details.
-
-    * Manual page improvements plus scanty protocol documentation.
-
-    * When running as --daemon in the background and using a "log
-      file" rsyncd.conf directive, close the log file every time it is
-      open when going to sleep on the socket.  This allows the log
-      file to get cleaned out by another process.
-
-    * Change to using libpopt rather than getopt for processing
-      options.  This makes the code cleaner and the behaviour more
-      consistent across platforms.  popt is included and built if not
-      installed on the platform.
-
-    * More details in --version, including note about whether 64-bit
-      files, symlinks and hardlinks are supported.
-
-    * MD4 code may use less CPU cycles.
-
-    * Use mkstemp on systems where it is secure.  If we use mktemp,
-      explain that we do it in a secure way.
-
-    * --whole-file is the default when source and target are on the
-        local machine.
+  "Imitation lizard skin"
 
   BUG FIXES:
 
-    * Fix for various bugs causing rsync to hang.
+    * Additional fix for zlib double-free bug.  (Martin Pool, Andrew
+      Tridgell) (CVE CAN-2002-0059)
+ 
+  ENHANCEMENTS:
 
-    * Attempt to fix Large File Summit support on AIX.
-
-    * Attempt to fix error handling lockup bug.
-
-    * Give a non-0 exit code if *any* of the files we have been asked
-      to transfer fail to transfer 
-
-    * For log messages containing ridiculously long strings that might
-      overflow a buffer rsync no longer aborts, but rather prints an
-      ellipsis at the end of the string.  (Patch from Ed Santiago.)
-
-  PLATFORMS:
-
-    * Improved support for UNICOS (tested on Cray T3E and Cray SV1)
-
-    * autoconf2.52 (or later) is now required to rebuild the autoconf
-      scripts.  It is not required to simply build rsync.
-
-  TESTING:
-
-    * The existing test.sh script by Phil Hands has been merged into a
-      test framework that works from both "make check" and the Samba
-      build farm.
+    * Merge in changes from zlib 1.1.3 to zlib 1.1.4.  (Jos Backus)
+      (Note that rsync still uses a custom version of zlib; you can
+      not just link against a system library.  See zlib/README.rsync)
 
+    * Additional test cases for --compress.  (Martin Pool)

OLDNEWS

@@ -0,0 +1,238 @@
+rsync 2.5.3 (11 March 2002)
+
+  "Happy 26"
+
+  SECURITY FIXES:
+
+    * Make sure that supplementary groups are removed from a server
+      process after changing uid and gid. (Ethan Benson) (Debian bug
+      #132272, CVE CAN-2002-0080)
+
+  BUG FIXES:
+
+    * Fix zlib double-free bug.  (Owen Taylor, Mark J Cox) (CVE
+      CAN-2002-0059)
+
+    * Fixed problem that in many cases caused the error message 
+	unexpected read size of 0 in map_ptr
+      and resulted in the wrong data being copied.
+
+    * Fixed compilation errors on some systems caused by the use of
+      "unsigned int64" in rsync.h.
+
+    * Fixed problem on systems such as Sunos4 that do not support realloc
+      on a NULL pointer; error was "out of memory in flist_expand".
+
+    * Fix for rsync server processes hanging around after the client
+      unexpectedly disconnects.  (Colin Walters) (Debian bug #128632)
+
+    * Cope with BSD systems on which mkdir() will not accept a trailing
+      slash.
+
+  ENHANCEMENTS:
+
+    * Merge in changes from zlib 1.1.2 to zlib 1.1.3.  (Note that
+      rsync still uses a custom version of zlib; you can not just link
+      against a system library.  See zlib/README.rsync)
+ 
+    * Command to initiate connections is only shown with -vv, rather
+      than -v as in 2.5.2.  Output from plain -v is more similar to
+      what was historically used so as not to break scripts that try
+      to parse the output.
+
+    * Added --no-whole-file and --no-blocking-io options (Dave Dykstra)
+
+    * Made the --write-batch and --read-batch options actually work
+      and added documentation in the man page (Jos Backus)
+
+    * If the daemon is unable to fork a child to accept a connection,
+      print an error message.  (Colin Walters)
+
+rsync 2.5.2 (26 Jan 2002)
+
+  SECURITY FIXES:
+
+    * Signedness security patch from Sebastian Krahmer
+      <krahmer@suse.de> -- in some cases we were not sufficiently
+      careful about reading integers from the network.
+
+  BUG FIXES:
+
+    * Fix possible string mangling in log files.
+
+    * Fix for setting local address of outgoing sockets.
+
+    * Better handling of hardlinks and devices on platforms with
+      64-bit dev_t or ino_t.
+
+    * Name resolution on machines supporting IPv6 is improved.
+
+    * Fix for device nodes.  (dann frazier)   (Debian #129135)
+
+  ENHANCEMENTS:
+
+    * With -v, rsync now shows the command used to initiate an ssh/rsh
+      connection.
+
+    * --statistics now shows memory heap usage on platforms that
+        support mallinfo().
+
+    * "The Ted T'so school of program optimization": make progress
+      visible and people will think it's faster.  (With --progress,
+      rsync will show you how many files it has seen as it builds the
+      file_list, giving some indication that it has not hung.)
+
+    * Improvements to batch mode support.  This is still experimental
+      but testing would be welcome.   (Jos Backus)
+ 
+    * New --ignore-existing option, patch previously distributed with
+      Vipul's Razor.  (Debian #124286)
+
+rsync 2.5.1 (2002-01-03)
+
+  BUG FIXES: 
+   
+    * Fix for segfault in --daemon mode configuration parser.  (Paul
+      Mackerras)
+
+    * Correct string<->address parsing for both IPv4 and 6.
+      (YOSHIFUJI Hideaki, SUMIKAWA Munechika and Jun-ichiro "itojun"
+      Hagino)
+
+    * Various fixes for IPv6 support.  (Dave Dykstra)
+
+    * rsync.1 typo fix.  (Matt Kraai)
+
+    * Test suite typo fixes.  (Tom Schmidt)
+
+    * rsync.1 grammar and clarity improvements.  (Edward
+      Welbourne)
+
+    * Correction to ./configure tests for inet_ntop.  (Jeff Garzik)
+
+  ENHANCEMENTS:
+
+    * --progress and -P now show estimated data transfer rate (in a
+        multiple of bytes/s) and estimated time to completion.  (Rik
+        Faith)
+   
+    * --no-detach option, required to run as a W32 service and also
+        useful when running on Unix under daemontools, AIX's SRC, or a
+        debugger.  (Max Bowsher, Jos Backus)
+
+    * Clearer error messages for some conditions.
+
+rsync 2.5.0 (2001-11-30)
+
+  ANNOUNCEMENTS
+
+    * Martin Pool <mbp@samba.org> is now a co-maintainer.
+
+  NEW FEATURES
+
+    * Support for LSB-compliant packaging <http://www.linuxbase.org/>
+
+    * Shell wildcards are allowed in "auth users" lines.
+
+    * Merged UNC rsync+ patch to support creation of standalone patch
+      sets.  By Bert J. Dempsey and Debra Weiss, updated by Jos
+      Backus.  <http://www.ils.unc.edu/i2dsi/unc_rsync+.html>
+
+    * IPv6 support based on a patch from KAME.net, on systems
+      including modern versions of Linux, Solaris, and HP-UX.  Also
+      includes IPv6 compatibility functions for old OSs by the
+      Internet Software Consortium, Paul Vixie, the OpenSSH
+      portability project, and OpenBSD.
+
+  ENHANCEMENTS
+
+    * Include/exclude cluestick: with -vv, print out whether files are
+      included or excluded and why.
+
+    * Many error messages have more friendly explanations and more
+      details.
+
+    * Manual page improvements plus scanty protocol documentation.
+
+    * When running as --daemon in the background and using a "log
+      file" rsyncd.conf directive, close the log file every time it is
+      open when going to sleep on the socket.  This allows the log
+      file to get cleaned out by another process.
+
+    * Change to using libpopt rather than getopt for processing
+      options.	This makes the code cleaner and the behaviour more
+      consistent across platforms.  popt is included and built if not
+      installed on the platform.
+
+    * More details in --version, including note about whether 64-bit
+      files, symlinks and hardlinks are supported.
+
+    * MD4 code may use less CPU cycles.
+
+    * Use mkstemp on systems where it is secure.  If we use mktemp,
+      explain that we do it in a secure way.
+
+    * --whole-file is the default when source and target are on the
+	local machine.
+
+  BUG FIXES:
+
+    * Fix for various bugs causing rsync to hang.
+
+    * Attempt to fix Large File Summit support on AIX.
+
+    * Attempt to fix error handling lockup bug.
+
+    * Give a non-0 exit code if *any* of the files we have been asked
+      to transfer fail to transfer 
+
+    * For log messages containing ridiculously long strings that might
+      overflow a buffer rsync no longer aborts, but rather prints an
+      ellipsis at the end of the string.  (Patch from Ed Santiago.)
+
+  PLATFORMS:
+
+    * Improved support for UNICOS (tested on Cray T3E and Cray SV1)
+
+    * autoconf2.52 (or later) is now required to rebuild the autoconf
+      scripts.	It is not required to simply build rsync.
+
+    * Platforms thought to work in this release:
+
+		Cray SV1 UNICOS 10.0.0.8 cc
+		Debian Linux 2.2 UltraSparc gcc
+		Debian Linux testing/unstable ARM gcc
+		FreeBSD 3.3-RELEASE i386 cc
+		FreeBSD 4.1.1-RELEASE i386 cc
+		FreeBSD 4.3-STABLE i386 cc
+		HP PA-RISC HP-UX 10.20 gcc
+		HP PA-RISC HP-UX 11.11 cc
+		IRIX 6.5 MIPS cc
+		IRIX 6.5 MIPS gcc
+		Mac OS X PPC (--disable-ipv6) cc
+		NetBSD 1.5 i386 gcc
+		NetBSD Current i386 cc
+		OpenBSD 2.5 Sparc gcc
+		OpenBSD 2.9 i386 cc
+		OpenBSD Current i386 cc
+		RedHat 6.2 i386 gcc
+		RedHat 6.2 i386 insure++
+		RedHat 7.0 i386 gcc
+		RedHat 7.1 i386 (Kernel 2.4.10) gcc
+		Slackware 8.0 i686 (Kernel 2.4.10)
+		Solaris 8 UltraSparc cc
+		Solaris 8 UltraSparc gcc
+		Solaris 8 i386 gcc
+		SuSE 7.1 i386 gcc2.95.2
+		SuSE 7.1 ppc gcc2.95.2
+		i386-pc-sco3.2v5.0.5 cc
+		i386-pc-sco3.2v5.0.5 gcc
+		powerpc-ibm-aix4.3.3.0 cc
+		i686-unknown-sysv5UnixWare7.1.0 gcc
+		i686-unknown-sysv5UnixWare7.1.0 cc
+
+  TESTING:
+
+    * The existing test.sh script by Phil Hands has been merged into a
+      test framework that works from both "make check" and the Samba
+      build farm.

README

@@ -143,9 +143,7 @@ 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.org or (if you think it will be of interest to lots
-of people) send it to rsync@samba.org
+If you don't have web access then mail bug reports to rsync@samba.org.
 
 
 CVS TREE
@@ -167,11 +165,12 @@ details.
 COPYRIGHT
 ---------
 
-Rsync was written by Andrew Tridgell and Paul Mackerras, and is
-available under the GNU General Public License.
+rsync was originally written by Andrew Tridgell and has been improved
+by many developers around the world.  rsync may be used, modified and
+redistributed only under the terms of the GNU General Public License,
+found in the file COPYING in this distribution, or at 
 
-tridge@samba.org
-paulus@cs.anu.edu.au
+  http://www.fsf.org/licenses/gpl.html
 
 
 AVAILABILITY

TODO

@@ -16,21 +16,330 @@ Cross-test versions
   some testing and also be the most common case for having different
   versions and not being able to upgrade.
 
+use chroot
+
+  If the platform doesn't support it, then don't even try.
+
+  If running as non-root, then don't fail, just give a warning.
+  (There was a thread about this a while ago?)
+
+    http://lists.samba.org/pipermail/rsync/2001-August/thread.html
+    http://lists.samba.org/pipermail/rsync/2001-September/thread.html
+
+--files-from
+
+  Avoids traversal.  Better option than a pile of --include statements
+  for people who want to generate the file list using a find(1)
+  command or a script.
+
+File list structure in memory
+
+  Rather than one big array, perhaps have a tree in memory mirroring
+  the directory tree.  
+
+  This might make sorting much faster!  (I'm not sure it's a big CPU
+  problem, mind you.)  
+
+  It might also reduce memory use in storing repeated directory names
+  -- again I'm not sure this is a problem.
+
+Performance
+
+  Traverse just one directory at a time.  Tridge says it's possible.
+
+  At the moment rsync reads the whole file list into memory at the
+  start, which makes us use a lot of memory and also not pipeline
+  network access as much as we could.
+
+
+Handling duplicate names
+
+  We need to be careful of duplicate names getting into the file list.
+  See clean_flist().  This could happen if multiple arguments include
+  the same file.  Bad.
+
+  I think duplicates are only a problem if they're both flowing
+  through the pipeline at the same time.  For example we might have
+  updated the first occurrence after reading the checksums for the
+  second.  So possibly we just need to make sure that we don't have
+  both in the pipeline at the same time.  
+
+  Possibly if we did one directory at a time that would be sufficient.
+
+  Alternatively we could pre-process the arguments to make sure no
+  duplicates will ever be inserted.  There could be some bad cases
+  when we're collapsing symlinks.
+
+  We could have a hash table.
+
+  The root of the problem is that we do not want more than one file
+  list entry referring to the same file.  At first glance there are
+  several ways this could happen: symlinks, hardlinks, and repeated
+  names on the command line.
+
+  If names are repeated on the command line, they may be present in
+  different forms, perhaps by traversing directory paths in different
+  ways, traversing paths including symlinks.  Also we need to allow
+  for expansion of globs by rsync.
+
+  At the moment, clean_flist() requires having the entire file list in
+  memory.  Duplicate names are detected just by a string comparison.
+
+  We don't need to worry about hard links causing duplicates because
+  files are never updated in place.  Similarly for symlinks.
+
+  I think even if we're using a different symlink mode we don't need
+  to worry.
+
+  Unless we're really clever this will introduce a protocol
+  incompatibility, so we need to be able to accept the old format as
+  well.
+
+
+Memory accounting
+
+  At exit, show how much memory was used for the file list, etc.
+
+  Also we do a wierd exponential-growth allocation in flist.c.  I'm
+  not sure this makes sense with modern mallocs.  At any rate it will
+  make us allocate a huge amount of memory for large file lists.
+
+
+Hard-link handling
+
+  At the moment hardlink handling is very expensive, so it's off by
+  default.  It does not need to be so.  
+
+  Since most of the solutions are rather intertwined with the file
+  list it is probably better to fix that first, although fixing
+  hardlinks is possibly simpler.
+
+  We can rule out hardlinked directories since they will probably
+  screw us up in all kinds of ways.  They simply should not be used.
+
+  At the moment rsync only cares about hardlinks to regular files.  I
+  guess you could also use them for sockets, devices and other beasts,
+  but I have not seen them.
+
+  When trying to reproduce hard links, we only need to worry about
+  files that have more than one name (nlinks>1 && !S_ISDIR). 
+
+  The basic point of this is to discover alternate names that refer to
+  the same file.  All operations, including creating the file and
+  writing modifications to it need only to be done for the first name.
+  For all later names, we just create the link and then leave it
+  alone.
+
+  If hard links are to be preserved:
+
+    Before the generator/receiver fork, the list of files is received
+    from the sender (recv_file_list), and a table for detecting hard
+    links is built.
+
+    The generator looks for hard links within the file list and does
+    not send checksums for them, though it does send other metadata.
+
+    The sender sends the device number and inode with file entries, so
+    that files are uniquely identified.
+
+    The receiver goes through and creates hard links (do_hard_links)
+    after all data has been written, but before directory permissions
+    are set.
+
+  At the moment device and inum are sent as 4-byte integers, which
+  will probably cause problems on large filesystems.  On Linux the
+  kernel uses 64-bit ino_t's internally, and people will soon have
+  filesystems big enough to use them.  We ought to follow NFS4 in
+  using 64-bit device and inode identification, perhaps with a
+  protocol version bump.
+
+  Once we've seen all the names for a particular file, we no longer
+  need to think about it and we can deallocate the memory.
+
+  We can also have the case where there are links to a file that are
+  not in the tree being transferred.  There's nothing we can do about
+  that.  Because we rename the destination into place after writing,
+  any hardlinks to the old file are always going to be orphaned.  In
+  fact that is almost necessary because otherwise we'd get really
+  confused if we were generating checksums for one name of a file and
+  modifying another.
+
+  At the moment the code seems to make a whole second copy of the file
+  list, which seems unnecessary.
+
+  We should have a test case that exercises hard links.  Since it
+  might be hard to compare ./tls output where the inodes change we
+  might need a little program to check whether several names refer to
+  the same file.
+
+IPv6
+
+  Implement suggestions from http://www.kame.net/newsletter/19980604/
+  and ftp://ftp.iij.ad.jp/pub/RFC/rfc2553.txt
+
+  If a host has multiple addresses, then listen try to connect to all
+  in order until we get through.  (getaddrinfo may return multiple
+  addresses.)  This is kind of implemented already.
+
+  Possibly also when starting as a server we may need to listen on
+  multiple passive addresses.  This might be a bit harder, because we
+  may need to select on all of them.  Hm.
+
+  Define a syntax for IPv6 literal addresses.  Since they include
+  colons, they tend to break most naming systems, including ours.
+  Based on the HTTP IPv6 syntax, I think we should use
+ 
+     rsync://[::1]/foo/bar
+     [::1]::bar
+
+  which should just take a small change to the parser code.
+
+Errors
+
+  If we hang or get SIGINT, then explain where we were up to.  Perhaps
+  have a static buffer that contains the current function name, or
+  some kind of description of what we were trying to do.  This is a
+  little easier on people than needing to run strace/truss.
+
+  "The dungeon collapses!  You are killed."  Rather than "unexpected
+  eof" give a message that is more detailed if possible and also more
+  helpful.  
+
+File attributes
+
+  Device major/minor numbers should be at least 32 bits each.  See
+  http://lists.samba.org/pipermail/rsync/2001-November/005357.html
+
+  Transfer ACLs.  Need to think of a standard representation.
+  Probably better not to even try to convert between NT and POSIX.
+  Possibly can share some code with Samba.
+
+Empty directories
+
+  With the current common --include '*/' --exclude '*' pattern, people
+  can end up with many empty directories.  We might avoid this by
+  lazily creating such directories.
+
+
+zlib
+
+  Perhaps don't use our own zlib.  
+
+  Advantages:
+   
+    - will automatically be up to date with bugfixes in zlib
+
+    - can leave it out for small rsync on e.g. recovery disks
+
+    - can use a shared library
+
+    - avoids people breaking rsync by trying to do this themselves and
+      messing up
+
+  Should we ship zlib for systems that don't have it, or require
+  people to install it separately?
+
+  Apparently this will make us incompatible with versions of rsync
+  that use the patched version of rsync.  Probably the simplest way to
+  do this is to just disable gzip (with a warning) when talking to old
+  versions.
+
+
+logging
+
+  Perhaps flush stdout after each filename, so that people trying to
+  monitor progress in a log file can do so more easily.  See
+  http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=48108
+
+  At the connections that just get a list of modules are not logged,
+  but they should be.
+
+rsyncd over ssh
+
+  There are already some patches to do this.
+
+proxy authentication
+
+  Allow RSYNC_PROXY to be http://user:pass@proxy.foo:3128/, and do
+  HTTP Basic Proxy-Authentication.  
+
+  Multiple schemes are possible, up to and including the insanity that
+  is NTLM, but Basic probably covers most cases.
+
+SOCKS
+
+  Add --with-socks, and then perhaps a command-line option to put them
+  on or off.  This might be more reliable than LD_PRELOAD hacks.
+
+Better statistics:
+
+  <Rasmus> mbp: hey, how about an rsync option that just gives you the
+  summary without the list of files?  And perhaps gives more
+  information like the number of new files, number of changed,
+  deleted, etc. ?
+  <mbp> Rasmus: nice idea
+  <mbp> there is --stats
+  <mbp> but at the moment it's very tridge-oriented
+  <mbp> rather than user-friendly
+  <mbp> it would be nice to improve it
+  <mbp> that would also work well with --dryrun
+
+PLATFORMS ------------------------------------------------------------
+
+Win32
+
+  Don't detach, because this messes up --srvany.
+
+  http://sources.redhat.com/ml/cygwin/2001-08/msg00234.html
+
+  According to "Effective TCP/IP Programming" (??) close() on a socket
+  has incorrect behaviour on Windows -- it sends a RST packet to the
+  other side, which gives a "connection reset by peer" error.  On that
+  platform we should probably do shutdown() instead.  However, on Unix
+  we are correct to call close(), because shutdown() discards
+  untransmitted data.
+
+DOCUMENTATION --------------------------------------------------------
+
+Update README
+
+BUILD FARM -----------------------------------------------------------
+
+Add machines
+
+  AMDAHL UTS (Dave Dykstra)
+
+  Cygwin (on different versions of Win32?)
+
+  HP-UX variants (via HP?)
+
+  SCO
 
 NICE -----------------------------------------------------------------
 
-Merge IPv6 support ***
+--no-detach and --no-fork options
 
-A patch is available at
+  Very useful for debugging.  Also good when running under a
+  daemon-monitoring process that tries to restart the service when the
+  parent exits.
 
-        ftp://ftp.kame.net/pub/kame/misc/rsync-244-v6-20000802.diff.gz
+hang/timeout friendliness
 
-but tridge reckons it needs to be cleaned up before it can be
-accepted.
+verbose output
+  
+  Indicate whether files are new, updated, or deleted
 
-This is now on the track-kameipv6 branch and can be moved across any
-time.  The KAME people say that it should work on machines without
-IPv6 stacks.
+  At end of transfer, show how many files were or were not transferred
+  correctly.
+
+internationalization
+
+  Change to using gettext().  Probably need to ship this for platforms
+  that don't have it.  
+
+  Solicit translations.
+
+  Does anyone care?
 
 rsyncsh 
 
@@ -39,4 +348,3 @@ rsyncsh
    fairly directly into rsync commands: it just needs to remember the
    current host, directory and so on.  We can probably even do
    completion of remote filenames.
-

authenticate.c

@@ -105,8 +105,8 @@ static int get_secret(int module, char *user, char *secret, int len)
 
 	while (!found) {
 		int i = 0;
-		memset(line, 0, sizeof(line));
-		while (i<(sizeof(line)-1)) {
+		memset(line, 0, sizeof line);
+		while ((size_t) i < (sizeof(line)-1)) {
 			if (read(fd, &line[i], 1) != 1) {
 				memset(line, 0, sizeof(line));
 				close(fd);

clientname.c

@@ -0,0 +1,282 @@
+/* -*- c-file-style: "linux" -*-
+   
+   rsync -- fast file replication program
+   
+   Copyright (C) 1992-2001 by Andrew Tridgell <tridge@samba.org>
+   Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
+   
+   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 clientname.c
+ * 
+ * Functions for looking up the remote name or addr of a socket.
+ *
+ * This file is now converted to use the new-style getaddrinfo()
+ * interface, which supports IPv6 but is also supported on recent
+ * IPv4-only machines.  On systems that don't have that interface, we
+ * emulate it using the KAME implementation.
+ **/
+
+#include "rsync.h"
+
+static const char default_name[] = "UNKNOWN";
+
+
+/**
+ * Return the IP addr of the client as a string 
+ **/
+char *client_addr(int fd)
+{
+	struct sockaddr_storage ss;
+	socklen_t length = sizeof ss;
+	static char addr_buf[100];
+	static int initialised;
+
+	if (initialised) return addr_buf;
+
+	initialised = 1;
+
+	client_sockaddr(fd, &ss, &length);
+
+	getnameinfo((struct sockaddr *)&ss, length,
+		    addr_buf, sizeof(addr_buf), NULL, 0, NI_NUMERICHOST);
+	
+	return addr_buf;
+}
+
+
+static int get_sockaddr_family(const struct sockaddr_storage *ss)
+{
+	return ((struct sockaddr *) ss)->sa_family;
+}
+
+
+/**
+ * Return the DNS name of the client.
+ *
+ * The name is statically cached so that repeated lookups are quick,
+ * so there is a limit of one lookup per customer.
+ *
+ * If anything goes wrong, including the name->addr->name check, then
+ * we just use "UNKNOWN", so you can use that value in hosts allow
+ * lines.
+ **/
+char *client_name(int fd)
+{
+	struct sockaddr_storage ss;
+	socklen_t ss_len = sizeof ss;
+	static char name_buf[100];
+	static char port_buf[100];
+	static int initialised;
+
+	if (initialised) return name_buf;
+
+	strcpy(name_buf, default_name);
+	initialised = 1;
+
+	client_sockaddr(fd, &ss, &ss_len);
+
+	if (!lookup_name(fd, &ss, ss_len, name_buf, sizeof name_buf, port_buf, sizeof port_buf))
+		check_name(fd, &ss, name_buf, port_buf);
+
+	return name_buf;
+}
+
+
+
+/**
+ * Get the sockaddr for the client.
+ *
+ * If it comes in as an ipv4 address mapped into IPv6 format then we
+ * convert it back to a regular IPv4.
+ **/
+void client_sockaddr(int fd,
+		     struct sockaddr_storage *ss,
+		     socklen_t *ss_len)
+{
+	if (getpeername(fd, (struct sockaddr *) ss, ss_len)) {
+		/* FIXME: Can we really not continue? */
+		rprintf(FERROR, RSYNC_NAME ": getpeername on fd%d failed: %s\n",
+			fd, strerror(errno));
+		exit_cleanup(RERR_SOCKETIO);
+	}
+
+#ifdef INET6
+        if (get_sockaddr_family(ss) == AF_INET6 && 
+	    IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)ss)->sin6_addr)) {
+		/* OK, so ss is in the IPv6 family, but it is really
+		 * an IPv4 address: something like
+		 * "::ffff:10.130.1.2".  If we use it as-is, then the
+		 * reverse lookup might fail or perhaps something else
+		 * bad might happen.  So instead we convert it to an
+		 * equivalent address in the IPv4 address family.  */
+		struct sockaddr_in6 sin6;
+		struct sockaddr_in *sin;
+
+		memcpy(&sin6, ss, sizeof(sin6));
+		sin = (struct sockaddr_in *)ss;
+		memset(sin, 0, sizeof(*sin));
+		sin->sin_family = AF_INET;
+		*ss_len = sizeof(struct sockaddr_in);
+#ifdef HAVE_SOCKADDR_LEN
+		sin->sin_len = *ss_len;
+#endif
+		sin->sin_port = sin6.sin6_port;
+
+		/* There is a macro to extract the mapped part
+		 * (IN6_V4MAPPED_TO_SINADDR ?), but it does not seem
+		 * to be present in the Linux headers. */
+		memcpy(&sin->sin_addr, &sin6.sin6_addr.s6_addr[12],
+			sizeof(sin->sin_addr));
+        }
+#endif
+}
+
+
+/**
+ * Look up a name from @p ss into @p name_buf.
+ **/
+int lookup_name(int fd, const struct sockaddr_storage *ss,
+		socklen_t ss_len,
+		char *name_buf, size_t name_buf_len,
+		char *port_buf, size_t port_buf_len)
+{
+	int name_err;
+	
+	/* reverse lookup */
+	name_err = getnameinfo((struct sockaddr *) ss, ss_len,
+			       name_buf, name_buf_len,
+			       port_buf, port_buf_len,
+			       NI_NAMEREQD | NI_NUMERICSERV);
+	if (name_err != 0) {
+		strcpy(name_buf, default_name);
+		rprintf(FERROR, RSYNC_NAME ": name lookup failed for %s: %s\n",
+			client_addr(fd),
+			gai_strerror(name_err));
+		return name_err;
+	}
+
+	return 0;
+}
+
+
+
+/**
+ * Compare an addrinfo from the resolver to a sockinfo.
+ *
+ * Like strcmp, returns 0 for identical.
+ **/
+int compare_addrinfo_sockaddr(const struct addrinfo *ai,
+			      const struct sockaddr_storage *ss)
+{
+	int ss_family = get_sockaddr_family(ss);
+	const char fn[] = "compare_addrinfo_sockaddr";
+		      
+	if (ai->ai_family != ss_family) {
+		rprintf(FERROR,
+			"%s: response family %d != %d\n",
+			fn, ai->ai_family, ss_family);
+		return 1;
+	}
+
+	/* The comparison method depends on the particular AF. */
+	if (ss_family == AF_INET) {
+		const struct sockaddr_in *sin1, *sin2;
+
+		sin1 = (const struct sockaddr_in *) ss;
+		sin2 = (const struct sockaddr_in *) ai->ai_addr;
+		
+		return memcmp(&sin1->sin_addr, &sin2->sin_addr,
+			      sizeof sin1->sin_addr);
+	}
+#ifdef INET6
+	else if (ss_family == AF_INET6) {
+		const struct sockaddr_in6 *sin1, *sin2;
+
+		sin1 = (const struct sockaddr_in6 *) ss;
+		sin2 = (const struct sockaddr_in6 *) ai->ai_addr;
+		
+		return memcmp(&sin1->sin6_addr, &sin2->sin6_addr,
+			      sizeof sin1->sin6_addr);
+	}
+#endif /* INET6 */
+	else {
+		/* don't know */
+		return 1;
+	}
+}
+
+
+/**
+ * Do a forward lookup on @p name_buf and make sure it corresponds to
+ * @p ss -- otherwise we may be being spoofed.  If we suspect we are,
+ * then we don't abort the connection but just emit a warning, and
+ * change @p name_buf to be "UNKNOWN".
+ **/
+int check_name(int fd,
+	       const struct sockaddr_storage *ss,
+	       char *name_buf,
+	       const char *port_buf)
+{
+	struct addrinfo hints, *res, *res0;
+	int error;
+	int ss_family = get_sockaddr_family(ss);
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = ss_family;
+	hints.ai_flags = AI_CANONNAME;
+	hints.ai_socktype = SOCK_STREAM;
+	error = getaddrinfo(name_buf, port_buf, &hints, &res0);
+	if (error) {
+		rprintf(FERROR,
+			RSYNC_NAME ": forward name lookup for %s failed: %s\n",
+			name_buf, gai_strerror(error));
+		strcpy(name_buf, default_name);
+		return error;
+	}
+
+
+	/* Given all these results, we expect that one of them will be
+	 * the same as ss.  The comparison is a bit complicated. */
+	for (res = res0; res; res = res->ai_next) {
+		if (!compare_addrinfo_sockaddr(res, ss))
+			break;	/* OK, identical */
+	}
+
+	if (!res0) {
+		/* We hit the end of the list without finding an
+		 * address that was the same as ss. */
+		rprintf(FERROR, RSYNC_NAME
+			": no known address for \"%s\": "
+			"spoofed address?\n",
+			name_buf);
+		strcpy(name_buf, default_name);
+	} else if (res == NULL) {
+		/* We hit the end of the list without finding an
+		 * address that was the same as ss. */
+		rprintf(FERROR, RSYNC_NAME
+			": %s is not a known address for \"%s\": "
+			"spoofed address?\n",
+			client_addr(fd),
+			name_buf);
+		strcpy(name_buf, default_name);
+	}
+
+	freeaddrinfo(res0);
+	return 0;
+}
+

clientserver.c

@@ -45,6 +45,7 @@ int start_socket_client(char *host, char *path, int argc, char *argv[])
 	extern char *shell_cmd;
 	extern int kludge_around_eof;
 	extern char *bind_address;
+	extern int default_af_hint;
        
 	if (argc == 0 && !am_sender) {
 		extern int list_only;
@@ -78,8 +79,12 @@ int start_socket_client(char *host, char *path, int argc, char *argv[])
 	if (!user) user = getenv("USER");
 	if (!user) user = getenv("LOGNAME");
 
+	if (verbose >= 2) {
+		rprintf(FINFO, "opening tcp connection to %s port %d\n",
+			host, rsync_port);
+	}
 	fd = open_socket_out_wrapped (host, rsync_port, bind_address,
-				      global_opts.af_hint);
+				      default_af_hint);
 	if (fd == -1) {
 		exit_cleanup(RERR_SOCKETIO);
 	}
@@ -126,7 +131,10 @@ int start_socket_client(char *host, char *path, int argc, char *argv[])
 
 		if (strcmp(line,"@RSYNCD: EXIT") == 0) exit(0);
 
-		rprintf(FINFO,"%s\n", line);
+		if (strncmp(line, "@ERROR", 6) == 0)
+			rprintf(FERROR,"%s\n", line);
+		else
+			rprintf(FINFO,"%s\n", line);
 	}
 	kludge_around_eof = False;
 
@@ -167,9 +175,9 @@ static int rsync_module(int fd, int i)
 
 	if (!allow_access(addr, host, lp_hosts_allow(i), lp_hosts_deny(i))) {
 		rprintf(FERROR,"rsync denied on module %s from %s (%s)\n",
-			name, client_name(fd), client_addr(fd));
+			name, host, addr);
 		io_printf(fd,"@ERROR: access denied to %s from %s (%s)\n",
-			  name, client_name(fd), client_addr(fd));
+			  name, host, addr);
 		return -1;
 	}
 
@@ -279,6 +287,26 @@ static int rsync_module(int fd, int i)
 	}
 
 	if (am_root) {
+#ifdef HAVE_SETGROUPS
+		/* Get rid of any supplementary groups this process
+		 * might have inheristed. */
+		if (setgroups(0, NULL)) {
+			rsyserr(FERROR, errno, "setgroups failed");
+			io_printf(fd, "@ERROR: setgroups failed\n");
+			return -1;
+		}
+#endif
+
+		/* XXXX: You could argue that if the daemon is started
+		 * by a non-root user and they explicitly specify a
+		 * gid, then we should try to change to that gid --
+		 * this could be possible if it's already in their
+		 * supplementary groups. */
+
+		/* TODO: Perhaps we need to document that if rsyncd is
+		 * started by somebody other than root it will inherit
+		 * all their supplementary groups. */
+
 		if (setgid(gid)) {
 			rsyserr(FERROR, errno, "setgid %d failed", (int) gid);
 			io_printf(fd,"@ERROR: setgid failed\n");
@@ -486,6 +514,7 @@ int daemon_main(void)
 	extern char *config_file;
 	extern int orig_umask;
 	char *pid_file;
+	extern int no_detach;
 
 	if (is_a_socket(STDIN_FILENO)) {
 		int i;
@@ -501,7 +530,8 @@ int daemon_main(void)
 		return start_daemon(STDIN_FILENO);
 	}
 
-	become_daemon();
+	if (!no_detach)
+	    become_daemon();
 
 	if (!lp_load(config_file, 1)) {
 		exit_cleanup(RERR_SYNTAX);
@@ -513,7 +543,8 @@ int daemon_main(void)
 		RSYNC_VERSION,
                 rsync_port);
         /* TODO: If listening on a particular address, then show that
-         * address too. */
+         * address too.  In fact, why not just do inet_ntop on the
+         * local address??? */
 
 	if (((pid_file = lp_pid_file()) != NULL) && (*pid_file != '\0')) {
 		char pidbuf[16];

configure.in

@@ -5,6 +5,12 @@ AC_CONFIG_SRCDIR([byteorder.h])
 AC_CONFIG_HEADER(config.h)
 AC_PREREQ(2.52)
 
+RSYNC_VERSION=2.5.4pre1
+AC_SUBST(RSYNC_VERSION)
+AC_MSG_NOTICE([Configuring rsync $RSYNC_VERSION])
+
+AC_DEFINE_UNQUOTED(RSYNC_VERSION, ["$RSYNC_VERSION"], [rsync release version])
+
 LDFLAGS=${LDFLAGS-""}
 
 AC_CANONICAL_TARGET([])
@@ -13,14 +19,21 @@ dnl Checks for programs.
 AC_PROG_CC
 AC_PROG_CPP
 AC_PROG_INSTALL
+AC_PROG_CC_STDC
 AC_SUBST(SHELL)
 
-RSYNC_VERSION=2.4.7pre4
-AC_SUBST(RSYNC_VERSION)
-AC_DEFINE_UNQUOTED(RSYNC_VERSION, ["$RSYNC_VERSION"], [rsync release version])
+AC_DEFINE([_GNU_SOURCE], 1,
+          [Define _GNU_SOURCE so that we get all necessary prototypes])
 
-# compile with optimisation and without debugging by default, unless
-# --debug is given.  We must decide this before testing the compiler.
+if test "$xac_cv_prog_cc_stdc" = xno
+then
+	AC_MSG_WARN([rsync requires an ANSI C compiler and you don't seem to have one])
+fi
+
+# We must decide this before testing the compiler.
+
+# Please allow this to default to yes, so that your users have more
+# chance of getting a useful stack trace if problems occur.
 
 AC_MSG_CHECKING([whether to include debugging symbols])
 AC_ARG_ENABLE(debug,
@@ -35,12 +48,33 @@ then
 else
     AC_MSG_RESULT([yes])
     # leave CFLAGS alone; AC_PROG_CC will try to include -g if it can
-    AC_DEFINE(DEBUG, 1, [Define to turn on debugging code that may slow normal operation])
+    dnl AC_DEFINE(DEBUG, 1, [Define to turn on debugging code that may slow normal operation])
     dnl CFLAGS=${CFLAGS-"-g"}
 fi
 
+
+
+
+AC_ARG_ENABLE(profile,
+	AC_HELP_STRING([--enable-profile],	
+		[turn on CPU profiling (default no)],
+		[], []))
+if test x"$enable_profile" = xyes
+then
+	CFLAGS="$CFLAGS -pg"
+fi
+
+
+# This is needed for our included version of popt.  Kind of silly, but
+# I don't want our version too far out of sync.
 CFLAGS="$CFLAGS -DHAVE_CONFIG_H"
 
+# If GCC, turn on warnings.
+if test "x$GCC" = "xyes"
+then
+	CFLAGS="$CFLAGS -Wall -W"
+fi
+
 AC_ARG_WITH(included-popt,
         [  --with-included-popt    use bundled popt library, not from system])
 
@@ -48,11 +82,26 @@ AC_ARG_WITH(rsync-path,
 	[  --with-rsync-path=PATH  set default --rsync-path to PATH (default: \"rsync\")],
 	[ RSYNC_PATH="$with_rsync_path" ],
 	[ RSYNC_PATH="rsync" ])
-AC_DEFINE_UNQUOTED(RSYNC_PATH, "$RSYNC_PATH", [ ])
+
+AC_DEFINE_UNQUOTED(RSYNC_PATH, "$RSYNC_PATH", [location of rsync on remote machine])
+
+AC_ARG_WITH(rsh,
+	AC_HELP_STRING([--with-rsh=CMD], [set rsh command to CMD (default: \"remsh\" or \"rsh\")]))
 
 AC_CHECK_PROG(HAVE_REMSH, remsh, 1, 0)
-AC_DEFINE_UNQUOTED(HAVE_REMSH, $HAVE_REMSH, [ ])
+AC_DEFINE_UNQUOTED(HAVE_REMSH, $HAVE_REMSH, [remote shell is remsh not rsh])
 
+if test x"$with_rsh" != x
+then
+	RSYNC_RSH="$with_rsh"
+elif test x"$HAVE_REMSH" = x1
+then 
+	RSYNC_RSH="remsh"
+else
+	RSYNC_RSH="rsh"
+fi
+
+AC_DEFINE_UNQUOTED(RSYNC_RSH, "$RSYNC_RSH", [default -e command])
 
 # arrgh. libc in the current debian stable screws up the largefile
 # stuff, getting byte range locking wrong
@@ -94,6 +143,11 @@ ipv6type=unknown
 ipv6lib=none
 ipv6trylibc=yes
 
+AC_ARG_ENABLE(ipv6, 
+	AC_HELP_STRING([--disable-ipv6], [don't even try to use IPv6]))
+
+if test "x$enable_ipv6" != xno
+then
 	AC_MSG_CHECKING([ipv6 stack type])
 	for i in inria kame linux-glibc linux-inet6 toshiba v6d zeta; do
 		case $i in
@@ -179,7 +233,8 @@ yes
 	done
 	AC_MSG_RESULT($ipv6type)
 
-AC_SEARCH_LIBS(getaddrinfo, inet6)
+	AC_SEARCH_LIBS(getaddrinfo, inet6)
+fi
 
 AC_C_BIGENDIAN
 AC_HEADER_DIRENT
@@ -190,6 +245,7 @@ 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 alloca.h mcheck.h sys/sysctl.h arpa/inet.h arpa/nameser.h)
 AC_CHECK_HEADERS(netdb.h)
+AC_CHECK_HEADERS(malloc.h)
 
 AC_CHECK_SIZEOF(int)
 AC_CHECK_SIZEOF(long)
@@ -254,13 +310,13 @@ fi
 
 AC_CHECK_LIB(resolv, inet_ntop)
 
-AC_MSG_NOTICE([Looking in libraries: $LIBS])
+dnl AC_MSG_NOTICE([Looking in libraries: $LIBS])
 
-AC_CHECK_FUNC(inet_ntop, , AC_LIBOBJ(lib/inet_ntop)) 
-AC_CHECK_FUNC(inet_pton, , AC_LIBOBJ(lib/inet_pton))
+AC_CHECK_FUNCS(inet_ntop, , AC_LIBOBJ(lib/inet_ntop)) 
+AC_CHECK_FUNCS(inet_pton, , AC_LIBOBJ(lib/inet_pton))
 
-AC_CHECK_FUNC(getaddrinfo, , AC_LIBOBJ(lib/getaddrinfo)) 
-AC_CHECK_FUNC(getnameinfo, , AC_LIBOBJ(lib/getnameinfo))
+AC_CHECK_FUNCS(getaddrinfo, , AC_LIBOBJ(lib/getaddrinfo))
+AC_CHECK_FUNCS(getnameinfo, , AC_LIBOBJ(lib/getnameinfo))
 
 AC_CHECK_MEMBER([struct sockaddr.sa_len], 
 		[ AC_DEFINE(HAVE_SOCKADDR_LEN) ],
@@ -270,6 +326,15 @@ AC_CHECK_MEMBER([struct sockaddr.sa_len],
 #include <sys/socket.h>
 ])
 
+AC_MSG_CHECKING(struct sockaddr_storage)
+AC_TRY_COMPILE([#include <sys/types.h>
+#include <sys/socket.h>],
+[struct sockaddr_storage x;],
+	AC_MSG_RESULT(yes)
+	AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, 
+		[Define if you have strct sockaddr_storage.] ),
+	AC_MSG_RESULT(no))
+
 # if we can't find strcasecmp, look in -lresolv (for Unixware at least)
 #
 AC_CHECK_FUNCS(strcasecmp)
@@ -277,12 +342,16 @@ if test x"$ac_cv_func_strcasecmp" = x"no"; then
     AC_CHECK_LIB(resolv, strcasecmp)
 fi
 
-AC_FUNC_MEMCMP
+dnl At the moment we don't test for a broken memcmp(), because all we
+dnl need to do is test for equality, not comparison, and it seems that
+dnl every platform has a memcmp that can do at least that.  
+dnl 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 asprintf setsid glob strpbrk)
-AC_CHECK_FUNCS(strlcat strlcpy mtrace)
+AC_CHECK_FUNCS(strlcat strlcpy mtrace mallinfo setgroups)
 
 AC_CACHE_CHECK([for working socketpair],rsync_cv_HAVE_SOCKETPAIR,[
 AC_TRY_RUN([
@@ -498,3 +567,7 @@ AC_SUBST(BUILD_POPT)
 
 AC_CONFIG_FILES([Makefile lib/dummy zlib/dummy popt/dummy shconfig])
 AC_OUTPUT
+
+AC_MSG_RESULT()
+AC_MSG_RESULT([    rsync ${RSYNC_VERSION} configuration successful])
+AC_MSG_RESULT()

doc/README-SGML

@@ -0,0 +1,20 @@
+Handling the rsync SGML documentation
+
+rsync documentation is now primarily in Docbook format.  Docbook is an
+SGML/XML documentation format that is becoming standard on free
+operating systems.  It's also used for Samba documentation.
+
+The SGML files are source code that can be translated into various
+useful output formats, primarily PDF, HTML, Postscript and plain text.  
+
+To do this transformation on Debian, you should install the
+docbook-utils package.  Having done that, you can say 
+
+  docbook2pdf rsync.sgml
+
+and so on.
+
+On other systems you probably need James Clark's "sp" and "JadeTeX"
+packages.  Work it out for yourself and send a note to the mailing
+list.
+

doc/profile.txt

@@ -0,0 +1,42 @@
+Notes on rsync profiling
+
+strlcpy is hot:
+
+                0.00    0.00       1/7735635     push_dir [68]
+                0.00    0.00       1/7735635     pop_dir [71]
+                0.00    0.00       1/7735635     send_file_list [15]
+                0.01    0.00   18857/7735635     send_files [4]
+                0.04    0.00  129260/7735635     send_file_entry [18]
+                0.04    0.00  129260/7735635     make_file [20]
+                0.04    0.00  141666/7735635     send_directory <cycle 1> [36]
+                2.29    0.00 7316589/7735635     f_name [13]
+[14]    11.7    2.42    0.00 7735635         strlcpy [14]
+
+
+Here's the top few functions:
+
+ 46.23      9.57     9.57 13160929     0.00     0.00  mdfour64
+ 14.78     12.63     3.06 13160929     0.00     0.00  copy64
+ 11.69     15.05     2.42  7735635     0.00     0.00  strlcpy
+ 10.05     17.13     2.08    41438     0.05     0.38  sum_update
+  4.11     17.98     0.85 13159996     0.00     0.00  mdfour_update
+  1.50     18.29     0.31                             file_compare
+  1.45     18.59     0.30   129261     0.00     0.01  send_file_entry
+  1.23     18.84     0.26  2557585     0.00     0.00  f_name
+  1.11     19.07     0.23  1483750     0.00     0.00  u_strcmp
+  1.11     19.30     0.23   118129     0.00     0.00  writefd_unbuffered
+  0.92     19.50     0.19  1085011     0.00     0.00  writefd
+  0.43     19.59     0.09   156987     0.00     0.00  read_timeout
+  0.43     19.68     0.09   129261     0.00     0.00  clean_fname
+  0.39     19.75     0.08    32887     0.00     0.38  matched
+  0.34     19.82     0.07        1    70.00 16293.92  send_files
+  0.29     19.89     0.06   129260     0.00     0.00  make_file
+  0.29     19.95     0.06    75430     0.00     0.00  read_unbuffered
+
+
+
+mdfour could perhaps be made faster:
+
+/* NOTE: This code makes no attempt to be fast!  */
+
+There might be an optimized version somewhere that we can borrow.

doc/rsync.sgml

@@ -0,0 +1,330 @@
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook V4.1//EN">
+<book id="rsync">
+  <bookinfo>
+    <title>rsync</title>
+    <copyright>
+      <year>1996 -- 2002</year>
+      <holder>Martin Pool</holder>
+      <holder>Andrew Tridgell</holder>
+    </copyright>
+    <author>
+      <firstname>Martin</firstname>
+      <surname>Pool</surname>
+    </author>
+  </bookinfo>
+
+  <chapter>
+    <title>Introduction</title>
+
+    <para>rsync is a flexible program for efficiently copying files or
+      directory trees.
+
+    <para>rsync has many options to select which files will be copied
+      and how they are to be transferred.  It may be used as an
+      alternative to ftp, http, scp or rcp.
+
+    <para>The rsync remote-update protocol allows rsync to transfer just
+      the differences between two sets of files across the network link,
+      using an efficient checksum-search algorithm described in the
+      technical report that accompanies this package.</para>
+
+    <para>Some of the additional features of rsync are:</para>
+
+    <itemizedlist>
+      
+      <listitem>
+	<para>support for copying links, devices, owners, groups and
+	  permissions
+	</para>
+      </listitem>
+      
+      <listitem>
+	<para>
+	  exclude and exclude-from options similar to GNU tar
+	</para>
+      </listitem>
+
+      <listitem>
+	<para>
+	  a CVS exclude mode for ignoring the same files that CVS would ignore
+      </listitem>
+
+      <listitem>
+	<para>
+	  can use any transparent remote shell, including rsh or ssh
+      </listitem>
+
+      <listitem>
+	<para>
+	  does not require root privileges
+      </listitem>
+
+      <listitem>
+	<para>
+	  pipelining of file transfers to minimize latency costs
+      </listitem>
+		
+      <listitem>
+	<para>
+	  support for anonymous or authenticated rsync servers (ideal for
+	  mirroring)
+	</para>
+      </listitem>
+    </itemizedlist>
+  </chapter>
+
+
+
+  <chapter>
+    <title>Using rsync</title>
+    <section>
+      <title>
+	Introductory example
+      </title>
+      
+      <para>
+	Probably the most common case of rsync usage is to copy files
+	to or from a remote machine using
+	<application>ssh</application> as a network transport.  In
+	this situation rsync is a good alternative to
+	<application>scp</application>.
+      </para>
+
+      <para>
+	The most commonly used arguments for rsync are
+      </para>
+
+      <variablelist>
+	<varlistentry>
+	  <term><option>-v</option></term>
+	  <listitem>
+	    <para>Be verbose.  Primarily, display the name of each file as it is copied.</para>
+	  </listitem>
+	</varlistentry>
+
+
+	<varlistentry>
+	  <term><option>-a</option></term>
+	  <listitem>
+	    <para>
+	      Reproduce the structure and attributes of the origin files as exactly
+	      as possible: this includes copying subdirectories, symlinks, special
+	      files, ownership and permissions.  (@xref{Attributes to
+	      copy}.)
+	    </para>
+	  </listitem>
+	</varlistentry>
+      </variablelist>
+
+
+	
+      <para><option>-v </option>
+      
+      <para><option>-z</option>
+	Compress network traffic, using a modified version of the
+	@command{zlib} library.</para>
+      
+      <para><option>-P</option>
+	Display a progress indicator while files are transferred.  This should
+	normally be ommitted if rsync is not run on a terminal.
+      </para>
+    </section>
+
+
+
+
+    <section>
+      <title>Local and remote</title>
+      
+      <para>There are six different ways of using rsync. They
+      are:</para>
+
+      
+
+      <!-- one of (CALLOUTLIST GLOSSLIST ITEMIZEDLIST ORDEREDLIST SEGMENTEDLIST SIMPLELIST VARIABLELIST CAUTION IMPORTANT NOTE TIP WARNING LITERALLAYOUT PROGRAMLISTING PROGRAMLISTINGCO SCREEN SCREENCO SCREENSHOT SYNOPSIS CMDSYNOPSIS FUNCSYNOPSIS CLASSSYNOPSIS FIELDSYNOPSIS CONSTRUCTORSYNOPSIS DESTRUCTORSYNOPSIS METHODSYNOPSIS FORMALPARA PARA SIMPARA ADDRESS BLOCKQUOTE GRAPHIC GRAPHICCO MEDIAOBJECT MEDIAOBJECTCO INFORMALEQUATION INFORMALEXAMPLE INFORMALFIGURE INFORMALTABLE EQUATION EXAMPLE FIGURE TABLE MSGSET PROCEDURE SIDEBAR QANDASET ANCHOR BRIDGEHEAD REMARK HIGHLIGHTS ABSTRACT AUTHORBLURB EPIGRAPH INDEXTERM REFENTRY SECTION) -->
+      <orderedlist>
+	<listitem>
+	  <para>
+	    for copying local files. This is invoked when neither
+	    source nor destination path contains a @code{:} separator
+
+	<listitem>
+	  <para>
+	    for copying from the local machine to a remote machine using
+	    a remote shell program as the transport (such as rsh or
+	    ssh). This is invoked when the destination path contains a
+	    single @code{:} separator.
+
+	<listitem>
+	  <para>
+	    for copying from a remote machine to the local machine
+	    using a remote shell program. This is invoked when the source
+	    contains a @code{:} separator.
+
+	<listitem>
+	  <para>
+	    for copying from a remote rsync server to the local
+	    machine. This is invoked when the source path contains a @code{::}
+	    separator or a @code{rsync://} URL.
+
+	<listitem>
+	  <para>
+	    for copying from the local machine to a remote rsync
+	    server. This is invoked when the destination path contains a @code{::}
+	    separator.
+
+	<listitem>
+	  <para>
+	    for listing files on a remote machine. This is done the
+	    same way as rsync transfers except that you leave off the
+	    local destination.  
+
+	</listitem>
+      </orderedlist>
+	  <para>
+Note that in all cases (other than listing) at least one of the source
+and destination paths must be local.
+
+	  <para>
+Any one invocation of rsync makes a copy in a single direction.  rsync
+currently has no equivalent of @command{ftp}'s interactive mode.
+
+@cindex @sc{nfs}
+@cindex network filesystems
+@cindex remote filesystems
+
+	  <para>
+rsync's network protocol is generally faster at copying files than
+network filesystems such as @sc{nfs} or @sc{cifs}.  It is better to
+run rsync on the file server either as a daemon or over ssh than
+running rsync giving the network directory.
+      </para>
+    </section>
+  </chapter>
+
+
+
+  <chapter>
+    <title>Frequently asked questions</title>
+
+    
+    <!-- one of (CALLOUTLIST GLOSSLIST ITEMIZEDLIST ORDEREDLIST SEGMENTEDLIST SIMPLELIST VARIABLELIST CAUTION IMPORTANT NOTE TIP WARNING LITERALLAYOUT PROGRAMLISTING PROGRAMLISTINGCO SCREEN SCREENCO SCREENSHOT SYNOPSIS CMDSYNOPSIS FUNCSYNOPSIS CLASSSYNOPSIS FIELDSYNOPSIS CONSTRUCTORSYNOPSIS DESTRUCTORSYNOPSIS METHODSYNOPSIS FORMALPARA PARA SIMPARA ADDRESS BLOCKQUOTE GRAPHIC GRAPHICCO MEDIAOBJECT MEDIAOBJECTCO INFORMALEQUATION INFORMALEXAMPLE INFORMALFIGURE INFORMALTABLE EQUATION EXAMPLE FIGURE TABLE MSGSET PROCEDURE SIDEBAR QANDASET ANCHOR BRIDGEHEAD REMARK HIGHLIGHTS ABSTRACT AUTHORBLURB EPIGRAPH INDEXTERM SECTION SIMPLESECT REFENTRY SECT1) -->
+    <qandaset>
+      <!-- one of (QANDADIV QANDAENTRY) -->
+
+      <qandaentry>
+	<question>
+	  <!-- one of (CALLOUTLIST GLOSSLIST ITEMIZEDLIST ORDEREDLIST
+	  SEGMENTEDLIST SIMPLELIST VARIABLELIST CAUTION IMPORTANT NOTE
+	  TIP WARNING LITERALLAYOUT PROGRAMLISTING PROGRAMLISTINGCO
+	  SCREEN SCREENCO SCREENSHOT SYNOPSIS CMDSYNOPSIS FUNCSYNOPSIS
+	  CLASSSYNOPSIS FIELDSYNOPSIS CONSTRUCTORSYNOPSIS
+	  DESTRUCTORSYNOPSIS METHODSYNOPSIS FORMALPARA PARA SIMPARA
+	  ADDRESS BLOCKQUOTE GRAPHIC GRAPHICCO MEDIAOBJECT
+	  MEDIAOBJECTCO INFORMALEQUATION INFORMALEXAMPLE
+	  INFORMALFIGURE INFORMALTABLE EQUATION EXAMPLE FIGURE TABLE
+	  PROCEDURE ANCHOR BRIDGEHEAD REMARK HIGHLIGHTS INDEXTERM) -->
+	  <para>Are there mailing lists for rsync?
+	</question>
+
+	<answer>
+	  <para>Yes, and you can subscribe and unsubscribe through a
+	  web interface at
+	    <ulink
+	      url="http://lists.samba.org/">http://lists.samba.org/</ulink>
+	  </para>
+
+	  <para>
+	    If you are having trouble with the mailing list, please
+	    send mail to the administrator
+	    
+	    <email>rsync-admin@lists.samba.org</email>
+
+	    not to the list itself.
+	  </para>
+
+	  <para>
+	    The mailing list archives are searchable.  Use 
+	    <ulink url="http://google.com/">Google</ulink> and prepend
+	    the search with <userinput>site:lists.samba.org
+	    rsync</userinput>, plus relevant keywords.
+	  </para>
+	</answer>
+      </qandaentry>
+
+
+      
+      <qandaentry>
+	<question>
+	  Is rsync useful for a single large file like an ISO image?
+	</question>
+	<answer>
+	  <para>
+	    Yes, but note the following:
+
+	  <para>
+   Background: A common use of rsync is to update a file (or set of files) in one location from a more
+   correct or up-to-date copy in another location, taking advantage of portions of the files that are
+   identical to speed up the process. (Note that rsync will transfer a file in its entirety if no copy
+   exists at the destination.)
+
+	  <para>
+   (This discussion is written in terms of updating a local copy of a file from a correct file in a
+   remote location, although rsync can work in either direction.)
+
+	  <para>
+   The file to be updated (the local file) must be in a destination directory that has enough space for
+   two copies of the file. (In addition, keep an extra copy of the file to be updated in a different
+   location for safety -- see the discussion (below) about rsync's behavior when the rsync process is
+   interrupted before completion.)
+
+	  <para>
+   The local file must have the same name as the remote file being sync'd to (I think?). If you are
+   trying to upgrade an iso from, for example, beta1 to beta2, rename the local file to the same name
+   as the beta2 file. *(This is a useful thing to do -- only the changed portions will be
+   transmitted.)*
+
+	  <para>
+   The extra copy of the local file kept in a different location is because of rsync's behavior if
+   interrupted before completion:
+
+	  <para>
+   * If you specify the --partial option and rsync is interrupted, rsync will save the partially
+   rsync'd file and throw away the original local copy. (The partially rsync'd file is correct but
+   truncated.) If rsync is restarted, it will not have a local copy of the file to check for duplicate
+   blocks beyond the section of the file that has already been rsync'd, thus the remainder of the rsync
+   process will be a "pure transfer" of the file rather than taking advantage of the rsync algorithm.
+
+	  <para>
+   * If you don't specify the --partial option and rsync is interrupted, rsync will throw away the
+   partially rsync'd file, and, when rsync is restarted starts the rsync process over from the
+   beginning.
+
+	  <para>
+   Which of these is most desirable depends on the degree of commonality between the local and remote
+   copies of the file *and how much progress was made before the interruption*.
+
+	  <para>
+   The ideal approach after an interruption would be to create a new file by taking the original file
+   and deleting a portion equal in size to the portion already rsync'd and then appending *the
+   remaining* portion to the portion of the file that has already been rsync'd. (There has been some
+   discussion about creating an option to do this automatically.)
+
+   The --compare-dest option is useful when transferring multiple files, but is of no benefit in
+   transferring a single file. (AFAIK)
+
+   *Other potentially useful information can be found at:
+   -[3]http://twiki.org/cgi-bin/view/Wikilearn/RsyncingALargeFile
+
+   This answer, formatted with "real" bullets, can be found at:
+   -[4]http://twiki.org/cgi-bin/view/Wikilearn/RsyncingALargeFileFAQ*
+
+   Note: I modified this on Oct. 9. 2001 -- I marked the changes with asterisks. The only deletion
+   without a corresponding correction was the deletion of an "(IIRC)".
+   2001-Oct-09 7:47am rhkramerATfastDOTnet
+	  </para>
+	</answer>
+      </qandaentry>
+    </qandaset>
+  </chapter>
+</book>

errcode.h

@@ -26,6 +26,7 @@
 #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_STARTCLIENT 5      /* error starting client-server protocol */
 
 #define RERR_SOCKETIO   10      /* error in socket IO */
 #define RERR_FILEIO     11      /* error in file IO */

exclude.c

@@ -201,9 +201,11 @@ void add_exclude_list(const char *pattern, struct exclude_struct ***list, int in
 	if (!*list || !((*list)[len] = make_exclude(pattern, include)))
 		out_of_memory("add_exclude");
 	
-	if (verbose > 2)
-		rprintf(FINFO,"add_exclude(%s)\n",pattern);
-	
+	if (verbose > 2) {
+		rprintf(FINFO,"add_exclude(%s,%s)\n",pattern,
+			      include ? "include" : "exclude");
+	}
+
 	(*list)[len+1] = NULL;
 }
 
@@ -260,7 +262,10 @@ void send_exclude_list(int f)
 	extern int remote_version;
 	extern int list_only, recurse;
 
-	/* this is a complete hack - blame Rusty */
+	/* This is a complete hack - blame Rusty.
+	 *
+	 * FIXME: This pattern shows up in the output of
+	 * report_exclude_result(), which is not ideal. */
 	if (list_only && !recurse) {
 		add_exclude("/*/*", 0);
 	}
@@ -299,7 +304,8 @@ void send_exclude_list(int f)
 void recv_exclude_list(int f)
 {
 	char line[MAXPATHLEN];
-	int l;
+	unsigned int l;
+
 	while ((l=read_int(f))) {
 		if (l >= MAXPATHLEN) overflow("recv_exclude_list");
 		read_sbuf(f,line,l);

fileio.c

@@ -1,5 +1,6 @@
 /* 
    Copyright (C) Andrew Tridgell 1998
+   Copyright (C) 2002 by Martin Pool
    
    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
@@ -36,9 +37,9 @@ int sparse_end(int f)
 }
 
 
-static int write_sparse(int f,char *buf,int len)
+static int write_sparse(int f,char *buf,size_t len)
 {
-	int l1=0,l2=0;
+	size_t l1=0, l2=0;
 	int ret;
 
 	for (l1=0;l1<len && buf[l1]==0;l1++) ;
@@ -56,10 +57,11 @@ static int write_sparse(int f,char *buf,int len)
 	if (l1 == len) 
 		return len;
 
-	if ((ret=write(f,buf+l1,len-(l1+l2))) != len-(l1+l2)) {
-		if (ret == -1 || ret == 0) return ret;
+	ret = write(f, buf + l1, len - (l1+l2));
+	if (ret == -1 || ret == 0)
+		return ret;
+	else if (ret != (int) (len - (l1+l2))) 
 		return (l1+ret);
-	}
 
 	if (l2 > 0)
 		do_lseek(f,l2,SEEK_CUR);
@@ -69,7 +71,7 @@ static int write_sparse(int f,char *buf,int len)
 
 
 
-int write_file(int f,char *buf,int len)
+int write_file(int f,char *buf,size_t len)
 {
 	int ret = 0;
 

generator.c

@@ -1,7 +1,10 @@
 /* -*- c-file-style: "linux" -*-
+
+   rsync -- fast file replication program
    
    Copyright (C) 1996-2000 by Andrew Tridgell 
    Copyright (C) Paul Mackerras 1996
+   Copyright (C) 2002 by Martin Pool <mbp@samba.org>
    
    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
@@ -28,6 +31,7 @@ extern int am_root;
 extern int preserve_devices;
 extern int preserve_hard_links;
 extern int update_only;
+extern int opt_ignore_existing;
 extern int whole_file;
 extern int block_size;
 extern int csum_length;
@@ -99,25 +103,30 @@ static int adapt_block_size(struct file_struct *file, int bsize)
 /*
   send a sums struct down a fd
   */
-static void send_sums(struct sum_struct *s,int f_out)
+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) {
+		size_t i;
 
-	if (!s) return;
+		/* 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->count);
+		write_int(f_out, s->n);
+		write_int(f_out, s->remainder);
 
-	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);
+		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);
+		}
+	} else {
+		/* we don't have checksums */
+		write_int(f_out, 0);
+		write_int(f_out, block_size);
+		write_int(f_out, 0);
 	}
 }
 
-
 /*
   generate a stream of signatures/checksums that describe a buffer
 
@@ -210,7 +219,7 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 
 	if (only_existing && statret == -1 && errno == ENOENT) {
 		/* we only want to update existing files */
-		if (verbose > 1) rprintf(FINFO,"not creating %s\n",fname);
+		if (verbose > 1) rprintf(FINFO, "not creating new file \"%s\"\n",fname);
 		return;
 	}
 
@@ -230,10 +239,11 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
                  * we need to delete it.  If it doesn't exist, then
                  * recursively create it. */
           
-		if (dry_run) return;
+		if (dry_run) return; /* XXXX -- might cause inaccuracies?? -- mbp */
 		if (statret == 0 && !S_ISDIR(st.st_mode)) {
 			if (robust_unlink(fname) != 0) {
-				rprintf(FERROR,"recv_generator: unlink %s: %s\n",
+				rprintf(FERROR, RSYNC_NAME
+					": recv_generator: unlink \"%s\" to make room for directory: %s\n",
                                         fname,strerror(errno));
 				return;
 			}
@@ -243,11 +253,13 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 			if (!(relative_paths && errno==ENOENT && 
 			      create_directory_path(fname)==0 && 
 			      do_mkdir(fname,file->mode)==0)) {
-				rprintf(FERROR,"recv_generator: mkdir %s: %s (2)\n",
+				rprintf(FERROR, RSYNC_NAME ": recv_generator: mkdir \"%s\": %s (2)\n",
 					fname,strerror(errno));
 			}
 		}
-		if (set_perms(fname,file,NULL,0) && verbose) 
+		/* f_out is set to -1 when doing final directory 
+		   permission and modification time repair */
+		if (set_perms(fname,file,NULL,0) && verbose && (f_out != -1)) 
 			rprintf(FINFO,"%s/\n",fname);
 		return;
 	}
@@ -260,7 +272,7 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 
 		if (safe_symlinks && unsafe_symlink(file->link, fname)) {
 			if (verbose) {
-				rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n",
+				rprintf(FINFO,"ignoring unsafe symlink \"%s\" -> \"%s\"\n",
 					fname,file->link);
 			}
 			return;
@@ -269,21 +281,26 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 			l = readlink(fname,lnk,MAXPATHLEN-1);
 			if (l > 0) {
 				lnk[l] = 0;
+				/* A link already pointing to the
+				 * right place -- no further action
+				 * required. */
 				if (strcmp(lnk,file->link) == 0) {
 					set_perms(fname,file,&st,1);
 					return;
 				}
-			}
+			}  
+			/* Not a symlink, so delete whatever's
+			 * already there and put a new symlink
+			 * in place. */			   
 			delete_file(fname);
 		}
 		if (do_symlink(file->link,fname) != 0) {
-			rprintf(FERROR,"symlink %s -> %s : %s\n",
+			rprintf(FERROR,RSYNC_NAME": 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);
+				rprintf(FINFO,"%s -> %s\n", fname,file->link);
 			}
 		}
 #endif
@@ -315,12 +332,12 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 
 	if (preserve_hard_links && check_hard_link(file)) {
 		if (verbose > 1)
-			rprintf(FINFO,"%s is a hard link\n",f_name(file));
+			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);
+		rprintf(FINFO, "skipping non-regular file \"%s\"\n",fname);
 		return;
 	}
 
@@ -345,7 +362,9 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 			if (!dry_run) send_sums(NULL,f_out);
 		} else {
 			if (verbose > 1)
-				rprintf(FERROR,"recv_generator failed to open %s\n",fname);
+				rprintf(FERROR, RSYNC_NAME
+					": recv_generator failed to open \"%s\": %s\n",
+					fname, strerror(errno));
 		}
 		return;
 	}
@@ -361,6 +380,12 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 		return;
 	}
 
+	if (opt_ignore_existing && fnamecmp == fname) { 
+		if (verbose > 1)
+			rprintf(FINFO,"%s exists\n",fname);
+		return;
+	} 
+
 	if (update_only && cmp_modtime(st.st_mtime,file->modtime)>0 && fnamecmp == fname) {
 		if (verbose > 1)
 			rprintf(FINFO,"%s is newer\n",fname);
@@ -388,7 +413,7 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 	fd = do_open(fnamecmp, O_RDONLY, 0);
 
 	if (fd == -1) {
-		rprintf(FERROR,"failed to open %s, continuing : %s\n",fnamecmp,strerror(errno));
+		rprintf(FERROR,RSYNC_NAME": 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);

hlink.c

@@ -1,6 +1,7 @@
 /* 
    Copyright (C) Andrew Tridgell 1996
    Copyright (C) Paul Mackerras 1996
+   Copyright (C) 2002 by Martin Pool <mbp@samba.org>
    
    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
@@ -23,19 +24,22 @@ extern int dry_run;
 extern int verbose;
 
 #if SUPPORT_HARD_LINKS
-static int hlink_compare(struct file_struct *f1,struct file_struct *f2)
+static int hlink_compare(struct file_struct *f1, struct file_struct *f2)
 {
-  if (!S_ISREG(f1->mode) && !S_ISREG(f2->mode)) return 0;
-  if (!S_ISREG(f1->mode)) return -1;
-  if (!S_ISREG(f2->mode)) return 1;
+	if (!S_ISREG(f1->mode) && !S_ISREG(f2->mode))
+		return 0;
+	if (!S_ISREG(f1->mode))
+		return -1;
+	if (!S_ISREG(f2->mode))
+		return 1;
 
-  if (f1->dev != f2->dev) 
-    return (int)(f1->dev>f2->dev?1:-1);
+	if (f1->dev != f2->dev)
+		return (int) (f1->dev > f2->dev ? 1 : -1);
 
-  if (f1->inode != f2->inode) 
-    return (int)(f1->inode>f2->inode?1:-1);
+	if (f1->inode != f2->inode)
+		return (int) (f1->inode > f2->inode ? 1 : -1);
 
-  return file_compare(&f1,&f2);
+	return file_compare(&f1, &f2);
 }
 
 
@@ -47,22 +51,25 @@ void init_hard_links(struct file_list *flist)
 {
 #if SUPPORT_HARD_LINKS
 	int i;
-	if (flist->count < 2) return;
+	if (flist->count < 2)
+		return;
 
-	if (hlink_list) free(hlink_list);
-    
-	if (!(hlink_list = 
-	      (struct file_struct *)malloc(sizeof(hlink_list[0])*flist->count)))
+	if (hlink_list)
+		free(hlink_list);
+
+	if (!(hlink_list =
+	      (struct file_struct *) malloc(sizeof(hlink_list[0]) *
+					    flist->count)))
 		out_of_memory("init_hard_links");
 
 	for (i = 0; i < flist->count; i++)
-		memcpy(&hlink_list[i], flist->files[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]),
-	      (int (*)())hlink_compare);
+	qsort(hlink_list, flist->count,
+	      sizeof(hlink_list[0]), (int (*)()) hlink_compare);
 
-	hlink_count=flist->count;
+	hlink_count = flist->count;
 #endif
 }
 
@@ -71,86 +78,102 @@ void init_hard_links(struct file_list *flist)
 int check_hard_link(struct file_struct *file)
 {
 #if SUPPORT_HARD_LINKS
-  int low=0,high=hlink_count-1;
-  int ret=0;
+	int low = 0, high = hlink_count - 1;
+	int ret = 0;
 
-  if (!hlink_list || !S_ISREG(file->mode)) return 0;
+	if (!hlink_list || !S_ISREG(file->mode))
+		return 0;
 
-  while (low != high) {
-    int mid = (low+high)/2;
-    ret = hlink_compare(&hlink_list[mid],file);
-    if (ret == 0) {
-	    low = mid;
-	    break;
-    }
-    if (ret > 0) 
-      high=mid;
-    else
-      low=mid+1;
-  }
+	while (low != high) {
+		int mid = (low + high) / 2;
+		ret = hlink_compare(&hlink_list[mid], file);
+		if (ret == 0) {
+			low = mid;
+			break;
+		}
+		if (ret > 0)
+			high = mid;
+		else
+			low = mid + 1;
+	}
 
-  if (hlink_compare(&hlink_list[low],file) != 0) return 0;
+	if (hlink_compare(&hlink_list[low], file) != 0)
+		return 0;
 
-  if (low > 0 &&
-      S_ISREG(hlink_list[low-1].mode) &&
-      file->dev == hlink_list[low-1].dev &&
-      file->inode == hlink_list[low-1].inode)
-    return 1;
+	if (low > 0 &&
+	    S_ISREG(hlink_list[low - 1].mode) &&
+	    file->dev == hlink_list[low - 1].dev &&
+	    file->inode == hlink_list[low - 1].inode)
+		return 1;
 #endif
 
-  return 0;
+	return 0;
 }
 
 
 #if SUPPORT_HARD_LINKS
 static void hard_link_one(int i)
 {
-	STRUCT_STAT st1,st2;
+	STRUCT_STAT st1, st2;
 
-	if (link_stat(f_name(&hlink_list[i-1]),&st1) != 0) return;
+	if (link_stat(f_name(&hlink_list[i - 1]), &st1) != 0)
+		return;
 
-	if (link_stat(f_name(&hlink_list[i]),&st2) != 0) {
-		if (do_link(f_name(&hlink_list[i-1]),f_name(&hlink_list[i])) != 0) {
+	if (link_stat(f_name(&hlink_list[i]), &st2) != 0) {
+		if (do_link
+		    (f_name(&hlink_list[i - 1]),
+		     f_name(&hlink_list[i])) != 0) {
 			if (verbose > 0)
-				rprintf(FINFO,"link %s => %s : %s\n",
+				rprintf(FINFO, "link %s => %s : %s\n",
 					f_name(&hlink_list[i]),
-					f_name(&hlink_list[i-1]),strerror(errno));
+					f_name(&hlink_list[i - 1]),
+					strerror(errno));
 			return;
 		}
 	} else {
-		if (st2.st_dev == st1.st_dev && st2.st_ino == st1.st_ino) return;
-		
+		if (st2.st_dev == st1.st_dev && st2.st_ino == st1.st_ino)
+			return;
+
 		if (robust_unlink(f_name(&hlink_list[i])) != 0 ||
-		    do_link(f_name(&hlink_list[i-1]),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",
+				rprintf(FINFO, "link %s => %s : %s\n",
 					f_name(&hlink_list[i]),
-					f_name(&hlink_list[i-1]),strerror(errno));
+					f_name(&hlink_list[i - 1]),
+					strerror(errno));
 			return;
 		}
 	}
 	if (verbose > 0)
-		rprintf(FINFO,"%s => %s\n",
-			f_name(&hlink_list[i]),f_name(&hlink_list[i-1]));
+		rprintf(FINFO, "%s => %s\n",
+			f_name(&hlink_list[i]),
+			f_name(&hlink_list[i - 1]));
 }
 #endif
 
-/* create any hard links in the flist */
-void do_hard_links(struct file_list *flist)
+
+
+/**
+ * Create any hard links in the global hlink_list.  They were put
+ * there by running init_hard_links on the filelist.
+ **/
+void do_hard_links(void)
 {
 #if SUPPORT_HARD_LINKS
 	int i;
-  
-	if (!hlink_list) return;
 
-	for (i=1;i<hlink_count;i++) {
+	if (!hlink_list)
+		return;
+
+	for (i = 1; i < hlink_count; i++) {
 		if (S_ISREG(hlink_list[i].mode) &&
-		    S_ISREG(hlink_list[i-1].mode) &&
-		    hlink_list[i].basename && hlink_list[i-1].basename &&
-		    hlink_list[i].dev == hlink_list[i-1].dev &&
-		    hlink_list[i].inode == hlink_list[i-1].inode) {
+		    S_ISREG(hlink_list[i - 1].mode) &&
+		    hlink_list[i].basename && hlink_list[i - 1].basename &&
+		    hlink_list[i].dev == hlink_list[i - 1].dev &&
+		    hlink_list[i].inode == hlink_list[i - 1].inode) {
 			hard_link_one(i);
-		}	
+		}
 	}
 #endif
 }

io.c

@@ -19,11 +19,22 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-/*
-  socket and pipe IO utilities used in rsync 
+/**
+ *
+ * @file io.c
+ *
+ * Socket and pipe IO utilities used in rsync.
+ *
+ * rsync provides its own multiplexing system, which is used to send
+ * stderr and stdout over a single socket.  We need this because
+ * stdout normally carries the binary data stream, and stderr all our
+ * error messages.
+ *
+ * For historical reasons this is off during the start of the
+ * connection, but it's switched on quite early using
+ * io_start_multiplex_out() and io_start_multiplex_in().
+ **/
 
-  tridge, June 1996
-  */
 #include "rsync.h"
 
 /* if no timeout is specified then use a 60 second select timeout */
@@ -49,7 +60,7 @@ int kludge_around_eof = False;
 
 static int io_error_fd = -1;
 
-static void read_loop(int fd, char *buf, int len);
+static void read_loop(int fd, char *buf, size_t len);
 
 static void check_timeout(void)
 {
@@ -86,7 +97,7 @@ void io_set_error_fd(int fd)
 static void read_error_fd(void)
 {
 	char buf[200];
-	int n;
+	size_t n;
 	int fd = io_error_fd;
 	int tag, len;
 
@@ -103,7 +114,8 @@ static void read_error_fd(void)
 
 	while (len) {
 		n = len;
-		if (n > (sizeof(buf)-1)) n = sizeof(buf)-1;
+		if (n > (sizeof(buf)-1))
+			n = sizeof(buf)-1;
 		read_loop(fd, buf, n);
 		rwrite((enum logcode)tag, buf, n);
 		len -= n;
@@ -163,7 +175,7 @@ static void die_from_readerr (int err)
  * give a better explanation.  We can tell whether the connection has
  * started by looking e.g. at whether the remote version is known yet.
  */
-static int read_timeout (int fd, char *buf, int len)
+static int read_timeout (int fd, char *buf, size_t len)
 {
 	int n, ret=0;
 
@@ -236,7 +248,7 @@ static int read_timeout (int fd, char *buf, int len)
 
 /*! Continue trying to read len bytes - don't return until len has
   been read.   */
-static void read_loop (int fd, char *buf, int len)
+static void read_loop (int fd, char *buf, size_t len)
 {
 	while (len) {
 		int n = read_timeout(fd, buf, len);
@@ -253,10 +265,10 @@ static void read_loop (int fd, char *buf, int len)
  * 
  * Never returns <= 0. 
  */
-static int read_unbuffered(int fd, char *buf, int len)
+static int read_unbuffered(int fd, char *buf, size_t len)
 {
-	static int remaining;
-	int tag, ret=0;
+	static size_t remaining;
+	int tag, ret = 0;
 	char line[1024];
 
 	if (!io_multiplexing_in || fd != multiplex_in_fd)
@@ -271,23 +283,24 @@ static int read_unbuffered(int fd, char *buf, int len)
 			continue;
 		}
 
-		read_loop (fd, line, 4);
+		read_loop(fd, line, 4);
 		tag = IVAL(line, 0);
 
 		remaining = tag & 0xFFFFFF;
 		tag = tag >> 24;
 
-		if (tag == MPLEX_BASE) continue;
+		if (tag == MPLEX_BASE)
+			continue;
 
 		tag -= MPLEX_BASE;
 
 		if (tag != FERROR && tag != FINFO) {
-			rprintf(FERROR,"unexpected tag %d\n", tag);
+			rprintf(FERROR, "unexpected tag %d\n", tag);
 			exit_cleanup(RERR_STREAMIO);
 		}
 
-		if (remaining > sizeof(line)-1) {
-			rprintf(FERROR,"multiplexing overflow %d\n\n", 
+		if (remaining > sizeof(line) - 1) {
+			rprintf(FERROR, "multiplexing overflow %d\n\n",
 				remaining);
 			exit_cleanup(RERR_STREAMIO);
 		}
@@ -295,7 +308,7 @@ static int read_unbuffered(int fd, char *buf, int len)
 		read_loop(fd, line, remaining);
 		line[remaining] = 0;
 
-		rprintf((enum logcode)tag,"%s", line);
+		rprintf((enum logcode) tag, "%s", line);
 		remaining = 0;
 	}
 
@@ -303,12 +316,13 @@ static int read_unbuffered(int fd, char *buf, int len)
 }
 
 
+
 /* 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)
+static void readfd (int fd, char *buffer, size_t N)
 {
 	int  ret;
-	int total=0;  
+	size_t total=0;  
 	
 	while (total < N) {
 		io_flush();
@@ -356,12 +370,12 @@ int64 read_longint(int f)
 	return ret;
 }
 
-void read_buf(int f,char *buf,int len)
+void read_buf(int f,char *buf,size_t len)
 {
 	readfd(f,buf,len);
 }
 
-void read_sbuf(int f,char *buf,int len)
+void read_sbuf(int f,char *buf,size_t len)
 {
 	read_buf (f,buf,len);
 	buf[len] = 0;
@@ -374,10 +388,11 @@ unsigned char read_byte(int f)
 	return c;
 }
 
-/* write len bytes to fd */
-static void writefd_unbuffered(int fd,char *buf,int len)
+/* Write len bytes to fd.  This underlies the multiplexing system,
+ * which is always called by application code.  */
+static void writefd_unbuffered(int fd,char *buf,size_t len)
 {
-	int total = 0;
+	size_t total = 0;
 	fd_set w_fds, r_fds;
 	int fd_count, count;
 	struct timeval tv;
@@ -424,7 +439,8 @@ static void writefd_unbuffered(int fd,char *buf,int len)
 		}
 
 		if (FD_ISSET(fd, &w_fds)) {
-			int ret, n = len-total;
+			int ret;
+			size_t n = len-total;
 			ret = write(fd,buf+total,n);
 
 			if (ret == -1 && errno == EINTR) {
@@ -438,8 +454,11 @@ static void writefd_unbuffered(int fd,char *buf,int len)
 			}
 
 			if (ret <= 0) {
-				rprintf(FERROR,
-					"error writing %d unbuffered bytes"
+				/* Don't try to write errors back
+				 * across the stream */
+				io_multiplexing_close();
+				rprintf(FERROR, RSYNC_NAME
+					": error writing %d unbuffered bytes"
 					" - exiting: %s\n", len,
 					strerror(errno));
 				exit_cleanup(RERR_STREAMIO);
@@ -483,10 +502,10 @@ void io_start_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)
+static void mplex_write(int fd, enum logcode code, char *buf, size_t len)
 {
 	char buffer[4096];
-	int n = len;
+	size_t n = len;
 
 	SIVAL(buffer, 0, ((MPLEX_BASE + (int)code)<<24) + len);
 
@@ -523,8 +542,7 @@ void io_flush(void)
 }
 
 
-/* XXX: fd is ignored, which seems a little strange. */
-void io_end_buffering(int fd)
+void io_end_buffering(void)
 {
 	io_flush();
 	if (!io_multiplexing_out) {
@@ -533,7 +551,7 @@ void io_end_buffering(int fd)
 	}
 }
 
-static void writefd(int fd,char *buf,int len)
+static void writefd(int fd,char *buf,size_t len)
 {
 	stats.total_written += len;
 
@@ -545,7 +563,7 @@ static void writefd(int fd,char *buf,int len)
 	}
 
 	while (len) {
-		int n = MIN(len, IO_BUFFER_SIZE-io_buffer_count);
+		int n = MIN((int) len, IO_BUFFER_SIZE-io_buffer_count);
 		if (n > 0) {
 			memcpy(io_buffer+io_buffer_count, buf, n);
 			buf += n;
@@ -587,7 +605,7 @@ void write_longint(int f, int64 x)
 	writefd(f,b,8);
 }
 
-void write_buf(int f,char *buf,int len)
+void write_buf(int f,char *buf,size_t len)
 {
 	writefd(f,buf,len);
 }
@@ -606,7 +624,7 @@ void write_byte(int f,unsigned char c)
 
 
 
-int read_line(int f, char *buf, int maxlen)
+int read_line(int f, char *buf, size_t maxlen)
 {
 	while (maxlen) {
 		buf[0] = 0;
@@ -664,7 +682,7 @@ void io_start_multiplex_in(int fd)
 }
 
 /* write an message to the multiplexed error stream */
-int io_multiplex_write(enum logcode code, char *buf, int len)
+int io_multiplex_write(enum logcode code, char *buf, size_t len)
 {
 	if (!io_multiplexing_out) return 0;
 

lib/compat.c

@@ -97,8 +97,10 @@
 
 
 #ifndef HAVE_STRLCPY
-/* like strncpy but does not 0 fill the buffer and always null 
-   terminates. bufsize is the size of the destination buffer */
+/* Like strncpy but does not 0 fill the buffer and always null 
+ * terminates. bufsize is the size of the destination buffer.
+ *
+ * Returns the index of the terminating byte. */
  size_t strlcpy(char *d, const char *s, size_t bufsize)
 {
 	size_t len = strlen(s);

lib/permstring.c

@@ -18,7 +18,7 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-#include <sys/stat.h>
+#include "rsync.h"
 
 /**
  * Produce a string representation of Unix mode bits like that used by

loadparm.c

@@ -386,9 +386,16 @@ static void init_service(service *pservice)
 
 
 /**
- * Assign a copy of @p v to @p *s, freeing any existing values and
- * handling NULL strings.  @p *v must be initialized when this is
- * called, either to NULL or a malloc'd string.
+ * Assign a copy of @p v to @p *s.  Handles NULL strings.  @p *v must
+ * be initialized when this is called, either to NULL or a malloc'd
+ * string.
+ *
+ * @fixme There is a small leak here in that sometimes the existing
+ * value will be dynamically allocated, and the old copy is lost.
+ * However, we can't always deallocate the old value, because in the
+ * case of sDefault, it points to a static string.  It would be nice
+ * to have either all-strdup'd values, or to never need to free
+ * memory.
  **/
 static void string_set(char **s, const char *v)
 {
@@ -396,8 +403,6 @@ static void string_set(char **s, const char *v)
 		*s = NULL;
 		return;
 	}
-	if (*s)
-		free(*s);
 	*s = strdup(v);
 	if (!*s)
 		exit_cleanup(RERR_MALLOC);

log.c

@@ -41,6 +41,7 @@ struct {
 	{ RERR_PROTOCOL   , "protocol incompatibility" }, 
 	{ RERR_FILESELECT , "errors selecting input/output files, dirs" }, 
 	{ RERR_UNSUPPORTED, "requested action not supported" }, 
+	{ RERR_STARTCLIENT, "error starting client-server protocol" }, 
 	{ RERR_SOCKETIO   , "error in socket IO" }, 
 	{ RERR_FILEIO     , "error in file IO" }, 
 	{ RERR_STREAMIO   , "error in rsync protocol data stream" }, 
@@ -236,7 +237,11 @@ void rwrite(enum logcode code, char *buf, int len)
 		return;
 	}
 
-	/* if that fails, try to pass it to the other end */
+	/* If that fails, try to pass it to the other end.
+	 *
+	 * io_multiplex_write can fail if we do not have a multiplexed
+	 * connection at the moment, in which case we fall through and
+	 * log locally instead. */
 	if (am_server && io_multiplex_write(code, buf, len)) {
 		return;
 	}
@@ -286,13 +291,14 @@ void rprintf(enum logcode code, const char *format, ...)
 	int len;
 
 	va_start(ap, format);
+	/* Note: might return -1 */
 	len = vsnprintf(buf, sizeof(buf), format, ap);
 	va_end(ap);
 
 	/* Deal with buffer overruns.  Instead of panicking, just
 	 * truncate the resulting string.  Note that some vsnprintf()s
 	 * return -1 on truncation, e.g., glibc 2.0.6 and earlier. */
-	if (len > sizeof(buf)-1  ||  len < 0) {
+	if ((size_t) len > sizeof(buf)-1  ||  len < 0) {
 		const char ellipsis[] = "[...]";
 
 		/* Reset length, and zero-terminate the end of our buffer */
@@ -331,18 +337,23 @@ void rsyserr(enum logcode code, int errcode, const char *format, ...)
 {
 	va_list ap;  
 	char buf[1024];
-	int len, sys_len;
+	int len;
+	size_t sys_len;
         char *sysmsg;
 
 	va_start(ap, format);
+	/* Note: might return <0 */
 	len = vsnprintf(buf, sizeof(buf), format, ap);
 	va_end(ap);
 
-	if (len > sizeof(buf)-1) exit_cleanup(RERR_MESSAGEIO);
+	/* TODO: Put in RSYNC_NAME at the start. */
+
+	if ((size_t) len > sizeof(buf)-1)
+		exit_cleanup(RERR_MESSAGEIO);
 
         sysmsg = strerror(errcode);
         sys_len = strlen(sysmsg);
-        if (len + 3 + sys_len > sizeof(buf) - 1)
+        if ((size_t) len + 3 + sys_len > sizeof(buf) - 1)
                 exit_cleanup(RERR_MESSAGEIO);
 
         strcpy(buf + len, ": ");
@@ -399,12 +410,18 @@ static void log_formatted(enum logcode code,
 	char buf[1024];
 	char buf2[1024];
 	char *p, *s, *n;
-	int l;
+	size_t l;
 	extern struct stats stats;		
 	extern int am_sender;
 	extern int am_daemon;
 	int64 b;
 
+	/* We expand % codes one by one in place in buf.  We don't
+	 * copy in the terminating nul of the inserted strings, but
+	 * rather keep going until we reach the nul of the format.
+	 * Just to make sure we don't clobber that nul and therefore
+	 * accidentally keep going, we zero the buffer now. */
+	memset(buf, 0, sizeof buf);
 	strlcpy(buf, format, sizeof(buf));
 	
 	for (s=&buf[0]; 
@@ -462,21 +479,30 @@ static void log_formatted(enum logcode code,
 			break;
 		}
 
-		if (!n) continue;
+		/* n is the string to be inserted in place of this %
+		 * code; l is its length not including the trailing
+		 * NUL */
+		if (!n)
+			continue;
 
 		l = strlen(n);
 
-		if ((l-1) + ((int)(s - &buf[0])) > sizeof(buf)) {
+		if (l + ((int)(s - &buf[0])) >= sizeof(buf)) {
 			rprintf(FERROR,"buffer overflow expanding %%%c - exiting\n",
 				p[0]);
 			exit_cleanup(RERR_MESSAGEIO);
 		}
 
+		/* Shuffle the rest of the string along to make space for n */
 		if (l != 2) {
 			memmove(s+(l-1), s+1, strlen(s+1)+1);
 		}
+
+		/* Copy in n but NOT its nul, because the format sting
+		 * probably continues after this. */
 		memcpy(p, n, l);
 
+		/* Skip over inserted string; continue looking */
 		s = p+l;
 	}
 
@@ -540,20 +566,16 @@ void log_exit(int code, const char *file, int 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
-*/
+/*
+ * Log the incoming transfer of a file for interactive use,
+ * this will be called at the end where the client was run.
+ * 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);
+	rprintf(FINFO, "%s\n", fname);
 }
-

main.c

@@ -2,7 +2,7 @@
    
    Copyright (C) 1996-2001 by Andrew Tridgell <tridge@samba.org>
    Copyright (C) Paul Mackerras 1996
-   Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+   Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
    
    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
@@ -27,6 +27,7 @@ struct stats stats;
 
 extern int verbose;
 
+static void show_malloc_stats(void);
 
 /****************************************************************************
 wait for a process to exit, calling io_flush while waiting
@@ -56,6 +57,12 @@ static void report(int f)
 	extern int remote_version;
 	int send_stats;
 
+	if (do_stats) {
+		/* These come out from every process */
+		show_malloc_stats();
+		show_flist_stats();
+	}
+
 	if (am_daemon) {
 		log_exit(0, __FILE__, __LINE__);
 		if (f == -1 || !am_sender) return;
@@ -126,6 +133,38 @@ static void report(int f)
 }
 
 
+/**
+ * If our C library can get malloc statistics, then show them to FINFO
+ **/
+static void show_malloc_stats(void)
+{
+#ifdef HAVE_MALLINFO
+	struct mallinfo mi;
+	extern int am_server;
+	extern int am_sender;
+	extern int am_daemon;
+
+	mi = mallinfo();
+
+	rprintf(FINFO, RSYNC_NAME "[%d] (%s%s%s) heap statistics:\n",
+		getpid(),
+		am_server ? "server " : "",
+		am_daemon ? "daemon " : "",
+		am_sender ? "sender" : "receiver");
+	rprintf(FINFO, "  arena:     %10d   (bytes from sbrk)\n", mi.arena);
+	rprintf(FINFO, "  ordblks:   %10d   (chunks not in use)\n", mi.ordblks);
+	rprintf(FINFO, "  smblks:    %10d\n", mi.smblks);
+	rprintf(FINFO, "  hblks:     %10d   (chunks from mmap)\n", mi.hblks);
+	rprintf(FINFO, "  hblkhd:    %10d   (bytes from mmap)\n", mi.hblkhd);
+	rprintf(FINFO, "  usmblks:   %10d\n", mi.usmblks);
+	rprintf(FINFO, "  fsmblks:   %10d\n", mi.fsmblks);
+	rprintf(FINFO, "  uordblks:  %10d   (bytes used)\n", mi.uordblks);
+	rprintf(FINFO, "  fordblks:  %10d   (bytes free)\n", mi.fordblks);
+	rprintf(FINFO, "  keepcost:  %10d   (bytes in releasable chunk)\n", mi.keepcost);
+#endif /* HAVE_MALLINFO */
+}
+
+
 /* Start the remote shell.   cmd may be NULL to use the default. */
 static pid_t do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int *f_out)
 {
@@ -138,7 +177,7 @@ static pid_t do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int
 	extern int blocking_io;
 	extern int read_batch;
 
-	if (!read_batch && !local_server) { /* dw -- added read_batch */
+	if (!read_batch && !local_server) {
 		if (!cmd)
 			cmd = getenv(RSYNC_RSH_ENV);
 		if (!cmd)
@@ -168,10 +207,11 @@ static pid_t do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int
 
 		args[argc++] = rsync_path;
 
+		if ((blocking_io == -1) && (strcmp(cmd, RSYNC_RSH) == 0))
+			blocking_io = 1;
+
 		server_options(args,&argc);
 
-
-		if (strcmp(cmd, RSYNC_RSH) == 0) blocking_io = 1;
 	}
 
 	args[argc++] = ".";
@@ -190,7 +230,7 @@ static pid_t do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int
 
 	if (local_server) {
 		if (read_batch)
-		    create_flist_from_batch();
+		    create_flist_from_batch(); /* sets batch_flist */
 		ret = local_child(argc, args, f_in, f_out);
 	} else {
 		ret = piped_child(args,f_in,f_out);
@@ -240,7 +280,8 @@ static char *get_local_name(struct file_list *flist,char *name)
 		return name;
 
 	if (do_mkdir(name,0777 & ~orig_umask) != 0) {
-		rprintf(FERROR,"mkdir %s : %s (1)\n",name,strerror(errno));
+		rprintf(FERROR, RSYNC_NAME ": mkdir %s: %s\n",
+			name, strerror(errno));
 		exit_cleanup(RERR_FILEIO);
 	} else {
 		if (verbose > 0)
@@ -248,8 +289,8 @@ static char *get_local_name(struct file_list *flist,char *name)
 	}
 
 	if (!push_dir(name, 0)) {
-		rprintf(FERROR,"push_dir %s : %s (2)\n",
-			name,strerror(errno));
+		rprintf(FERROR, RSYNC_NAME ": push_dir %s: %s\n",
+			name, strerror(errno));
 		exit_cleanup(RERR_FILESELECT);
 	}
 
@@ -403,8 +444,8 @@ static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
 	extern int am_daemon;
 	extern int module_id;
 	extern int am_sender;
-	extern int read_batch;   /* dw */
-	extern struct file_list *batch_flist;  /* dw */
+	extern int read_batch;
+	extern struct file_list *batch_flist;
 
 	if (verbose > 2)
 		rprintf(FINFO,"server_recv(%d) starting pid=%d\n",argc,(int)getpid());
@@ -430,7 +471,7 @@ static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
 	if (delete_mode && !delete_excluded)
 		recv_exclude_list(f_in);
 
-	if (read_batch) /*  dw  */
+	if (read_batch)
 	    flist = batch_flist;
 	else
 	    flist = recv_file_list(f_in);
@@ -457,7 +498,7 @@ 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;
-	extern int read_batch; /* dw */
+	extern int read_batch;
 
 	setup_protocol(f_out, f_in);
 
@@ -468,7 +509,7 @@ void start_server(int f_in, int f_out, int argc, char *argv[])
 		io_start_multiplex_out(f_out);
 
 	if (am_sender) {
-		if (!read_batch) { /* dw */
+		if (!read_batch) {
 		    recv_exclude_list(f_in);
 		    if (cvs_exclude)
 			add_cvs_excludes();
@@ -487,19 +528,19 @@ void start_server(int f_in, int f_out, int argc, char *argv[])
  */
 int client_run(int f_in, int f_out, pid_t pid, int argc, char *argv[])
 {
-	struct file_list *flist;
+	struct file_list *flist = NULL;
 	int status = 0, status2 = 0;
 	char *local_name = NULL;
 	extern int am_sender;
 	extern int remote_version;
 	extern pid_t cleanup_child_pid;
-	extern int write_batch; /* dw */
-	extern int read_batch; /* dw */
-	extern struct file_list *batch_flist; /*  dw */
+	extern int write_batch;
+	extern int read_batch;
+	extern struct file_list *batch_flist;
 
 	cleanup_child_pid = pid;
 	if (read_batch)
-	    flist = batch_flist;  /* dw */
+	    flist = batch_flist;
 
 	set_nonblocking(f_in);
 	set_nonblocking(f_out);
@@ -542,7 +583,7 @@ int client_run(int f_in, int f_out, pid_t pid, int argc, char *argv[])
 		list_only = 1;
 	}
 	
-	if (!write_batch) /* dw */
+	if (!write_batch)
 	    send_exclude_list(f_out);
 	
 	flist = recv_file_list(f_in);
@@ -603,6 +644,9 @@ static int copy_argv (char *argv[])
  * Start a client for either type of remote connection.  Work out
  * whether the arguments request a remote shell or rsyncd connection,
  * and call the appropriate connection function, then run_client.
+ *
+ * Calls either start_socket_client (for sockets) or do_cmd and
+ * client_run (for ssh).
  */
 static int start_client(int argc, char *argv[])
 {
@@ -618,6 +662,7 @@ static int start_client(int argc, char *argv[])
 	extern char *shell_cmd;
 	extern int rsync_port;
 	extern int whole_file;
+	extern int write_batch;
 	extern int read_batch;
 	int rc;
 
@@ -645,7 +690,7 @@ static int start_client(int argc, char *argv[])
 		return start_socket_client(host, path, argc-1, argv+1);
 	}
 
-	if (!read_batch) { /* dw */
+	if (!read_batch) {
 	    p = find_colon(argv[0]);
 
 	if (p) {
@@ -671,8 +716,12 @@ static int start_client(int argc, char *argv[])
 		p = find_colon(argv[argc-1]);
 		if (!p) {
 			local_server = 1;
-			/* disable "rsync algorithm" when both sides local */
-			whole_file = 1;
+			/*
+			 * disable "rsync algorithm" when both sides local,
+			 * except when creating a batch update
+			 */
+			if (!write_batch && whole_file == -1)
+				whole_file = 1;
 		} else if (p[1] == ':') {
 			*p = 0;
 			return start_socket_client(argv[argc-1], p+2, argc-1, argv);
@@ -694,9 +743,9 @@ static int start_client(int argc, char *argv[])
 		argc--;
 	}
 	} else {
-	    am_sender = 1;  /*  dw */
-	    local_server = 1;  /* dw */
-	    shell_path = argv[argc-1];  /* dw */
+	    am_sender = 1;
+	    local_server = 1;
+	    shell_path = argv[argc-1];
 	}
 
 	if (shell_machine) {
@@ -737,17 +786,17 @@ static int start_client(int argc, char *argv[])
 }
 
 
-static RETSIGTYPE sigusr1_handler(int val) {
+static RETSIGTYPE sigusr1_handler(int UNUSED(val)) {
 	exit_cleanup(RERR_SIGNAL);
 }
 
-static RETSIGTYPE sigusr2_handler(int val) {
+static RETSIGTYPE sigusr2_handler(int UNUSED(val)) {
 	extern int log_got_error;
 	if (log_got_error) _exit(RERR_PARTIAL);
 	_exit(0);
 }
 
-static RETSIGTYPE sigchld_handler(int val) {
+static RETSIGTYPE sigchld_handler(int UNUSED(val)) {
 #ifdef WNOHANG
 	while (waitpid(-1, NULL, WNOHANG) > 0) ;
 #endif
@@ -761,12 +810,12 @@ int main(int argc,char *argv[])
 	extern int am_daemon;
 	extern int am_server;
 	int ret;
-	extern int read_batch;   /*  dw */
-	extern int write_batch;  /*  dw */
-	extern char *batch_ext;   /*  dw */
-	int orig_argc;  /* dw */
+	extern int write_batch;
+	int orig_argc;
+	char **orig_argv;
 
-	orig_argc = argc;   /* dw */
+	orig_argc = argc;
+	orig_argv = argv;
 
 	signal(SIGUSR1, sigusr1_handler);
 	signal(SIGUSR2, sigusr2_handler);
@@ -794,23 +843,21 @@ 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);
 
+	/* Ignore SIGPIPE; we consistently check error codes and will
+	 * see the EPIPE. */
+	signal(SIGPIPE, SIG_IGN);
+
 	/* 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 (write_batch) { /* dw */
-	    create_batch_file_ext();
-	    write_batch_argvs_file(orig_argc, argc, argv);
-	}
-
-	if (read_batch) { /* dw */
-	    set_batch_file_ext(batch_ext);
+	if (write_batch && !am_server) {
+	    write_batch_argvs_file(orig_argc, orig_argv);
 	}
 
 	if (am_daemon) {
@@ -839,7 +886,9 @@ int main(int argc,char *argv[])
 	}
 
 	ret = start_client(argc, argv);
-	exit_cleanup(ret);
+	if (ret == -1) 
+	    exit_cleanup(RERR_STARTCLIENT);
+	else
+	    exit_cleanup(ret);
 	return ret;
 }
-

match.c

@@ -71,7 +71,7 @@ static void build_hash_table(struct sum_struct *s)
   if (!tag_table || !targets) 
     out_of_memory("build_hash_table");
 
-  for (i=0;i<s->count;i++) {
+  for (i=0;i<(int) s->count;i++) {
     targets[i].i = i;
     targets[i].t = gettag(s->sums[i].sum1);
   }
@@ -175,7 +175,7 @@ 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++) {
+		for (; j < (int) s->count && targets[j].t == t; j++) {
 			int l, i = targets[j].i;
 			
 			if (sum != s->sums[i].sum1) continue;
@@ -201,7 +201,7 @@ static void hash_search(int f,struct sum_struct *s,
 
 			/* 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++) {
+			for (j++; j < (int) s->count && targets[j].t == t; j++) {
 				int i2 = targets[j].i;
 				if (i2 == last_i + 1) {
 					if (sum != s->sums[i2].sum1) break;
@@ -246,7 +246,8 @@ static void hash_search(int f,struct sum_struct *s,
 		   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 && 
+		if (offset > last_match &&
+		    offset-last_match >= CHUNK_SIZE+s->n && 
 		    (end-offset > CHUNK_SIZE)) {
 			matched(f,s,buf,offset - s->n, -2);
 		}

options.c

@@ -1,7 +1,7 @@
 /*  -*- c-file-style: "linux" -*-
     
     Copyright (C) 1998-2001 by Andrew Tridgell <tridge@samba.org>
-    Copyright (C) 2000-2001 by Martin Pool <mbp@samba.org>
+    Copyright (C) 2000, 2001, 2002 by Martin Pool <mbp@samba.org>
    
    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
@@ -22,7 +22,7 @@
 #include "popt.h"
 
 int make_backups = 0;
-int whole_file = 0;
+int whole_file = -1;
 int copy_links = 0;
 int preserve_links = 0;
 int preserve_hard_links = 0;
@@ -65,6 +65,7 @@ int size_only=0;
 int bwlimit=0;
 int delete_after=0;
 int only_existing=0;
+int opt_ignore_existing=0;
 int max_delete=0;
 int ignore_errors=0;
 #ifdef _WIN32
@@ -72,13 +73,22 @@ int modify_window=2;
 #else
 int modify_window=0;
 #endif
-int blocking_io=0;
+int blocking_io=-1;
 
-/** Global options set from command line. **/
-struct global_opts global_opts;
+/** Network address family. **/
+#ifdef INET6
+int default_af_hint = 0;	/* Any protocol */
+#else
+int default_af_hint = AF_INET;	/* Must use IPv4 */
+#endif
 
-int read_batch=0;  /* dw */
-int write_batch=0; /* dw */
+/** Do not go into the background when run as --daemon.  Good
+ * for debugging and required for running as a service on W32,
+ * or under Unix process-monitors. **/
+int no_detach = 0;
+
+int write_batch = 0;
+int read_batch = 0;
 
 char *backup_suffix = BACKUP_SUFFIX;
 char *tmpdir = NULL;
@@ -96,7 +106,7 @@ int quiet = 0;
 int always_checksum = 0;
 int list_only = 0;
 
-char *batch_ext = NULL;
+char *batch_prefix = NULL;
 
 static int modify_window_set;
 
@@ -106,12 +116,13 @@ static int modify_window_set;
 char *bind_address;
 
 
-static void print_rsync_version(int f)
+static void print_rsync_version(enum logcode f)
 {
         char const *got_socketpair = "no ";
         char const *hardlinks = "no ";
         char const *links = "no ";
 	char const *ipv6 = "no ";
+	STRUCT_STAT *dumstat;
 
 #ifdef HAVE_SOCKETPAIR
         got_socketpair = "";
@@ -132,13 +143,20 @@ static void print_rsync_version(int f)
         rprintf(f, "%s  version %s  protocol version %d\n",
                 RSYNC_NAME, RSYNC_VERSION, PROTOCOL_VERSION);
         rprintf(f,
-                "Copyright (C) 1996-2001 by Andrew Tridgell and others\n");
+                "Copyright (C) 1996-2002 by Andrew Tridgell and others\n");
 	rprintf(f, "<http://rsync.samba.org/>\n");
         rprintf(f, "Capabilities: %d-bit files, %ssocketpairs, "
-                "%shard links, %ssymlinks, batchfiles, %sIPv6\n\n",
+                "%shard links, %ssymlinks, batchfiles, %sIPv6,\n",
                 (int) (sizeof(OFF_T) * 8),
                 got_socketpair, hardlinks, links, ipv6);
 
+	/* Note that this field may not have type ino_t.  It depends
+	 * on the complicated interaction between largefile feature
+	 * macros. */
+	rprintf(f, "              %d-bit system inums, %d-bit internal inums\n",
+		(int) (sizeof(dumstat->st_ino) * 8),
+		(int) (sizeof(INO64_T) * 8));
+
 #ifdef NO_INT64
         rprintf(f, "WARNING: no 64-bit integers on this platform!\n");
 #endif
@@ -171,8 +189,8 @@ void usage(enum logcode F)
   rprintf(F,"     --backup-dir            make backups into this directory\n");
   rprintf(F,"     --suffix=SUFFIX         override backup suffix\n");  
   rprintf(F," -u, --update                update only (don't overwrite newer files)\n");
-  rprintf(F," -l, --links                 preserve soft links\n");
-  rprintf(F," -L, --copy-links            treat soft links like regular files\n");
+  rprintf(F," -l, --links                 copy symlinks as symlinks\n");
+  rprintf(F," -L, --copy-links            copy the referent of symlinks\n");
   rprintf(F,"     --copy-unsafe-links     copy links outside the source tree\n");
   rprintf(F,"     --safe-links            ignore links outside the destination tree\n");
   rprintf(F," -H, --hard-links            preserve hard links\n");
@@ -184,12 +202,14 @@ void usage(enum logcode F)
   rprintf(F," -S, --sparse                handle sparse files efficiently\n");
   rprintf(F," -n, --dry-run               show what would have been transferred\n");
   rprintf(F," -W, --whole-file            copy whole files, no incremental checks\n");
+  rprintf(F,"     --no-whole-file         turn off --whole-file\n");
   rprintf(F," -x, --one-file-system       don't cross filesystem boundaries\n");
   rprintf(F," -B, --block-size=SIZE       checksum blocking size (default %d)\n",BLOCK_SIZE);  
   rprintf(F," -e, --rsh=COMMAND           specify rsh replacement\n");
   rprintf(F,"     --rsync-path=PATH       specify path to rsync on the remote machine\n");
   rprintf(F," -C, --cvs-exclude           auto ignore files in the same way CVS does\n");
   rprintf(F,"     --existing              only update files that already exist\n");
+  rprintf(F,"     --ignore-existing       ignore files that already exist on the receiving side\n");
   rprintf(F,"     --delete                delete files that don't exist on the sending side\n");
   rprintf(F,"     --delete-excluded       also delete excluded files on the receiving side\n");
   rprintf(F,"     --delete-after          delete after transferring, not before\n");
@@ -212,17 +232,19 @@ void usage(enum logcode F)
   rprintf(F,"     --include-from=FILE     don't exclude patterns listed in FILE\n");
   rprintf(F,"     --version               print version number\n");  
   rprintf(F,"     --daemon                run as a rsync daemon\n");  
-  rprintf(F,"     --address               bind to the specified address\n");  
+  rprintf(F,"     --no-detach             do not detach from the parent\n");  
+  rprintf(F,"     --address=ADDRESS       bind to the specified address\n");  
   rprintf(F,"     --config=FILE           specify alternate rsyncd.conf file\n");  
   rprintf(F,"     --port=PORT             specify alternate rsyncd port number\n");
   rprintf(F,"     --blocking-io           use blocking IO for the remote shell\n");  
+  rprintf(F,"     --no-blocking-io        turn off --blocking-io\n");  
   rprintf(F,"     --stats                 give some file transfer stats\n");  
   rprintf(F,"     --progress              show progress during transfer\n");  
   rprintf(F,"     --log-format=FORMAT     log file transfers using specified format\n");  
   rprintf(F,"     --password-file=FILE    get password from FILE\n");
   rprintf(F,"     --bwlimit=KBPS          limit I/O bandwidth, KBytes per second\n");
-  rprintf(F," -f  --read-batch=EXT        read batch file\n");
-  rprintf(F," -F  --write-batch           write batch file\n");
+  rprintf(F,"     --write-batch=PREFIX    write batch fileset starting with PREFIX\n");
+  rprintf(F,"     --read-batch=PREFIX     read batch fileset starting with PREFIX\n");
   rprintf(F," -h, --help                  show this help screen\n");
 #ifdef INET6
   rprintf(F," -4                          prefer IPv4\n");
@@ -243,7 +265,8 @@ enum {OPT_VERSION = 1000, OPT_SUFFIX, OPT_SENDER, OPT_SERVER, OPT_EXCLUDE,
       OPT_LOG_FORMAT, OPT_PASSWORD_FILE, OPT_SIZE_ONLY, OPT_ADDRESS,
       OPT_DELETE_AFTER, OPT_EXISTING, OPT_MAX_DELETE, OPT_BACKUP_DIR, 
       OPT_IGNORE_ERRORS, OPT_BWLIMIT, OPT_BLOCKING_IO,
-      OPT_MODIFY_WINDOW};
+      OPT_NO_BLOCKING_IO, OPT_NO_WHOLE_FILE,
+      OPT_MODIFY_WINDOW, OPT_READ_BATCH, OPT_WRITE_BATCH, OPT_IGNORE_EXISTING};
 
 static struct poptOption long_options[] = {
   /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
@@ -257,6 +280,7 @@ static struct poptOption long_options[] = {
   {"one-file-system", 'x', POPT_ARG_NONE,   &one_file_system},
   {"delete",           0,  POPT_ARG_NONE,   &delete_mode},
   {"existing",         0,  POPT_ARG_NONE,   &only_existing},
+  {"ignore-existing",  0,  POPT_ARG_NONE,   &opt_ignore_existing},
   {"delete-after",     0,  POPT_ARG_NONE,   &delete_after},
   {"delete-excluded",  0,  POPT_ARG_NONE,   0,              OPT_DELETE_EXCLUDED},
   {"force",            0,  POPT_ARG_NONE,   &force_delete},
@@ -274,7 +298,8 @@ static struct poptOption long_options[] = {
   {"update",          'u', POPT_ARG_NONE,   &update_only},
   {"links",           'l', POPT_ARG_NONE,   &preserve_links},
   {"copy-links",      'L', POPT_ARG_NONE,   &copy_links},
-  {"whole",           'W', POPT_ARG_NONE,   &whole_file},
+  {"whole-file",      'W', POPT_ARG_NONE,   &whole_file},
+  {"no-whole-file",    0,  POPT_ARG_NONE,   0, 		     OPT_NO_WHOLE_FILE},
   {"copy-unsafe-links", 0, POPT_ARG_NONE,   &copy_unsafe_links},
   {"perms",           'p', POPT_ARG_NONE,   &preserve_perms},
   {"owner",           'o', POPT_ARG_NONE,   &preserve_uid},
@@ -298,11 +323,13 @@ static struct poptOption long_options[] = {
   /* TODO: Should this take an optional int giving the compression level? */
   {"compress",        'z', POPT_ARG_NONE,   &do_compression},
   {"daemon",           0,  POPT_ARG_NONE,   &am_daemon},
+  {"no-detach",        0,  POPT_ARG_NONE,   &no_detach},
   {"stats",            0,  POPT_ARG_NONE,   &do_stats},
   {"progress",         0,  POPT_ARG_NONE,   &do_progress},
   {"partial",          0,  POPT_ARG_NONE,   &keep_partial},
   {"ignore-errors",    0,  POPT_ARG_NONE,   &ignore_errors},
   {"blocking-io",      0,  POPT_ARG_NONE,   &blocking_io},
+  {"no-blocking-io",   0,  POPT_ARG_NONE,   0, 		     OPT_NO_BLOCKING_IO},
   {0,                 'P', POPT_ARG_NONE,   0,               'P'},
   {"config",           0,  POPT_ARG_STRING, &config_file},
   {"port",             0,  POPT_ARG_INT,    &rsync_port},
@@ -311,11 +338,11 @@ static struct poptOption long_options[] = {
   {"address",          0,  POPT_ARG_STRING, &bind_address, 0},
   {"backup-dir",       0,  POPT_ARG_STRING, &backup_dir},
   {"hard-links",      'H', POPT_ARG_NONE,   &preserve_hard_links},
-  {"read-batch",      'f', POPT_ARG_STRING, &batch_ext, 'f'},
-  {"write-batch",     'F', POPT_ARG_NONE,   &write_batch, 0},
+  {"read-batch",       0,  POPT_ARG_STRING, &batch_prefix, OPT_READ_BATCH},
+  {"write-batch",      0,  POPT_ARG_STRING, &batch_prefix, OPT_WRITE_BATCH},
 #ifdef INET6
-  {0,		      '4', POPT_ARG_VAL,    &global_opts.af_hint,   AF_INET },
-  {0,		      '6', POPT_ARG_VAL,    &global_opts.af_hint,   AF_INET6 },
+  {0,		      '4', POPT_ARG_VAL,    &default_af_hint,   AF_INET },
+  {0,		      '6', POPT_ARG_VAL,    &default_af_hint,   AF_INET6 },
 #endif
   {0,0,0,0}
 };
@@ -436,6 +463,14 @@ int parse_arguments(int *argc, const char ***argv, int frommain)
 			add_exclude_file(poptGetOptArg(pc), 1, 1);
 			break;
 
+		case OPT_NO_WHOLE_FILE:
+			whole_file = 0;
+			break;
+
+		case OPT_NO_BLOCKING_IO:
+			blocking_io = 0;
+			break;
+
 		case 'h':
 			usage(FINFO);
 			exit_cleanup(0);
@@ -491,9 +526,13 @@ int parse_arguments(int *argc, const char ***argv, int frommain)
 			keep_partial = 1;
 			break;
 
+		case OPT_WRITE_BATCH:
+			/* popt stores the filename in batch_prefix for us */
+			write_batch = 1;
+			break;
 
-		case 'f':
-			/* The filename is stored for us by popt */
+		case OPT_READ_BATCH:
+			/* popt stores the filename in batch_prefix for us */
 			read_batch = 1;
 			break;
 
@@ -509,6 +548,22 @@ int parse_arguments(int *argc, const char ***argv, int frommain)
 		}
 	}
 
+	if (write_batch && read_batch) {
+	    snprintf(err_buf,sizeof(err_buf),
+		"write-batch and read-batch can not be used together\n");
+	    rprintf(FERROR,"ERROR: write-batch and read-batch"
+		" can not be used together\n");
+	    return 0;
+	}
+
+	if (do_compression && (write_batch || read_batch)) {
+	    snprintf(err_buf,sizeof(err_buf),
+		"compress can not be used with write-batch or read-batch\n");
+	    rprintf(FERROR,"ERROR: compress can not be used with"
+		"  write-batch or read-batch\n");
+	    return 0;
+	}
+
         *argv = poptGetArgs(pc);
         if (*argv)
                 *argc = count_args(*argv);
@@ -530,10 +585,16 @@ void server_options(char **args,int *argc)
 	static char mdelete[30];
 	static char mwindow[30];
 	static char bw[50];
-	static char fext[20]; /* dw */
+	/* Leave room for ``--(write|read)-batch='' */
+	static char fext[MAXPATHLEN + 15];
 
 	int i, x;
 
+	if (whole_file == -1)
+		whole_file = 0;
+	if (blocking_io == -1)
+		blocking_io = 0;
+
 	args[ac++] = "--server";
 
 	if (!am_sender)
@@ -585,8 +646,6 @@ void server_options(char **args,int *argc)
 		argstr[x++] = 'S';
 	if (do_compression)
 		argstr[x++] = 'z';
-	if (write_batch)
-	    argstr[x++] = 'F'; /* dw */
 
 	/* this is a complete hack - blame Rusty 
 
@@ -609,8 +668,14 @@ void server_options(char **args,int *argc)
 		args[ac++] = mdelete;
 	}    
 	
-	if (batch_ext != NULL) {
-		sprintf(fext,"-f%s",batch_ext);
+	if (batch_prefix != NULL) {
+		char *fmt = "";
+		if (write_batch)
+		    fmt = "--write-batch=%s";
+		else
+		if (read_batch)
+		    fmt = "--read-batch=%s";
+		snprintf(fext,sizeof(fext),fmt,batch_prefix);
 		args[ac++] = fext;
 	}
 
@@ -668,6 +733,9 @@ void server_options(char **args,int *argc)
 	if (only_existing && am_sender)
 		args[ac++] = "--existing";
 
+	if (opt_ignore_existing && am_sender) 
+		args[ac++] = "--ignore-existing";
+
 	if (tmpdir) {
 		args[ac++] = "--temp-dir";
 		args[ac++] = tmpdir;

packaging/lsb/rsync.spec

@@ -0,0 +1,84 @@
+Summary: Program for efficient remote updates of files.
+Name: rsync
+Version: 2.5.1
+Release: 1
+Copyright: GPL
+Group: Applications/Networking
+Source:	ftp://samba.anu.edu.au/pub/rsync/rsync-2.5.1.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 Sept 11 2000 John H Terpstra <jht@turbolinux.com>
+  Changed target paths to be Linux Standards Base compliant
+
+* 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 --mandir=/usr/share/man
+make CFLAGS="$RPM_OPT_FLAGS"
+strip rsync
+
+%install
+mkdir -p $RPM_BUILD_ROOT/usr/{bin,share/man/{man1,man5}}
+install -m755 rsync $RPM_BUILD_ROOT/usr/bin
+install -m644 rsync.1 $RPM_BUILD_ROOT/usr/share/man/man1
+install -m644 rsyncd.conf.5 $RPM_BUILD_ROOT/usr/share/man/man5
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%files
+%attr(-,root,root) /usr/bin/rsync
+%attr(-,root,root) /usr/share/man/man1/rsync.1
+%attr(-,root,root) /usr/share/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

@@ -1,10 +1,10 @@
 Summary: Program for efficient remote updates of files.
 Name: rsync
-Version: 2.4.6
+Version: 2.5.1
 Release: 1
 Copyright: GPL
 Group: Applications/Networking
-Source:	ftp://samba.anu.edu.au/pub/rsync/rsync-2.4.6.tar.gz
+Source:	ftp://samba.anu.edu.au/pub/rsync/rsync-2.5.1.tar.gz
 URL: http://samba.anu.edu.au/rsync/
 Packager: Andrew Tridgell <tridge@samba.anu.edu.au>
 BuildRoot: /tmp/rsync

packaging/redhat/7.1/rsync.spec

@@ -1,10 +1,10 @@
 Summary: Program for efficient remote updates of files.
 Name: rsync
-Version: 2.4.7pre1
+Version: 2.5.1
 Release: 1
 Copyright: GPL
 Group: Applications/Networking
-Source:	ftp://samba.anu.edu.au/pub/rsync/rsync-2.4.7pre1.tar.bz2
+Source:	ftp://samba.anu.edu.au/pub/rsync/rsync-2.5.1.tar.gz
 URL: http://samba.anu.edu.au/rsync/
 Packager: Andrew Tridgell <tridge@samba.anu.edu.au>
 BuildRoot: /tmp/rsync

packaging/redhat/7.1/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

receiver.c

@@ -38,8 +38,8 @@ extern int make_backups;
 extern char *backup_suffix;
 
 static struct delete_list {
-	dev_t dev;
-	INO_T inode;
+	DEV64_T dev;
+	INO64_T inode;
 } *delete_list;
 static int dlist_len, dlist_alloc_len;
 
@@ -206,7 +206,8 @@ static int get_tmpname(char *fnametmp, char *fname)
 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;
+	int i;
+	unsigned int n,remainder,len,count;
 	OFF_T offset = 0;
 	OFF_T offset2;
 	char *data;
@@ -248,7 +249,7 @@ static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname,
 		i = -(i+1);
 		offset2 = i*(OFF_T)n;
 		len = n;
-		if (i == count-1 && remainder != 0)
+		if (i == (int) count-1 && remainder != 0)
 			len = remainder;
 		
 		stats.matched_data += len;
@@ -264,7 +265,7 @@ static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname,
 			sum_update(map,len);
 		}
 		
-		if (fd != -1 && write_file(fd,map,len) != len) {
+		if (fd != -1 && write_file(fd,map,len) != (int) len) {
 			rprintf(FERROR,"write failed on %s : %s\n",
 				fname,strerror(errno));
 			exit_cleanup(RERR_FILEIO);
@@ -423,7 +424,7 @@ int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
 		   access because of a similar race condition. */
 		fd2 = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS);
 		if (fd2 == -1) {
-			rprintf(FERROR,"mkstemp %s failed\n",fnametmp);
+			rprintf(FERROR,"mkstemp %s failed: %s\n",fnametmp,strerror(errno));
 			receive_data(f_in,buf,-1,NULL,file->length);
 			if (buf) unmap_file(buf);
 			continue;
@@ -488,7 +489,7 @@ int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
 	}
 
 	if (preserve_hard_links)
-		do_hard_links(flist);
+		do_hard_links();
 
 	/* now we need to fix any directory permissions that were 
 	   modified during the transfer */

rsync.c

@@ -226,7 +226,6 @@ int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
 
 void sig_int(void)
 {
-	rprintf(FINFO,"\nrsync.c:sig_int() called.\n");
 	exit_cleanup(RERR_SIGNAL);
 }
 

rsync.h

@@ -1,7 +1,7 @@
 /* 
    Copyright (C) by Andrew Tridgell 1996, 2000
    Copyright (C) Paul Mackerras 1996
-   Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+   Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
    
    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
@@ -49,7 +49,7 @@
 #define SAME_TIME (1<<7)
 
 /* update this if you make incompatible changes */
-#define PROTOCOL_VERSION 25
+#define PROTOCOL_VERSION 26
 
 /* We refuse to interoperate with versions that are not in this range.
  * Note that we assume we'll work with later versions: the onus is on
@@ -85,11 +85,9 @@ enum logcode {FNONE=0, FERROR=1, FINFO=2, FLOG=3 };
 
 #include "config.h"
 
-#if HAVE_REMSH
-#define RSYNC_RSH "remsh"
-#else
-#define RSYNC_RSH "rsh"
-#endif
+/* The default RSYNC_RSH is always set in config.h, either to "remsh",
+ * "rsh", or otherwise something specified by the user.  HAVE_REMSH
+ * controls parameter munging for HP/UX, etc. */
 
 #include <sys/types.h>
 
@@ -185,6 +183,10 @@ enum logcode {FNONE=0, FERROR=1, FINFO=2, FLOG=3 };
 #include <glob.h>
 #endif
 
+#ifdef HAVE_MALLOC_H
+#  include <malloc.h>
+#endif
+
 /* these are needed for the uid/gid mapping code */
 #include <pwd.h>
 #include <grp.h>
@@ -263,17 +265,44 @@ enum logcode {FNONE=0, FERROR=1, FINFO=2, FLOG=3 };
 #elif HAVE_LONGLONG
 #define int64 long long
 #else
+/* As long as it gets... */
 #define int64 off_t
 #define NO_INT64
 #endif
 
-#if HAVE_SHORT_INO_T
-#  define INO_T uint32
-#elif HAVE_INO_T
-#  define INO_T ino_t
-#else
-#  define INO_T unsigned
-#endif
+/* Starting from protocol version 26, we always use 64-bit
+ * ino_t and dev_t internally, even if this platform does not
+ * allow files to have 64-bit inums.  That's because the
+ * receiver needs to find duplicate (dev,ino) tuples to detect
+ * hardlinks, and it might have files coming from a platform
+ * that has 64-bit inums.
+ *
+ * The only exception is if we're on a platform with no 64-bit type at
+ * all.
+ *
+ * Because we use read_longint() to get these off the wire, if you
+ * transfer devices or hardlinks with dev or inum > 2**32 to a machine
+ * with no 64-bit types then you will get an overflow error.  Probably
+ * not many people have that combination of machines, and you can
+ * avoid it by not preserving hardlinks or not transferring device
+ * nodes.  It's not clear that any other behaviour is better.
+ *
+ * Note that if you transfer devices from a 64-bit-devt machine (say,
+ * Solaris) to a 32-bit-devt machine (say, Linux-2.2/x86) then the
+ * device numbers will be truncated.  But it's a kind of silly thing
+ * to do anyhow.
+ *
+ * FIXME: In future, we should probable split the device number into
+ * major/minor, and transfer the two parts as 32-bit ints.  That gives
+ * you somewhat more of a chance that they'll come from a big machine
+ * to a little one in a useful way.
+ *
+ * FIXME: Really we need an unsigned type, and we perhaps ought to
+ * cope with platforms on which this is an unsigned int or even a
+ * struct.  Later.
+ */ 
+#define INO64_T int64
+#define DEV64_T int64
 
 #ifndef MIN
 #define MIN(a,b) ((a)<(b)?(a):(b))
@@ -304,9 +333,13 @@ struct file_struct {
 	time_t modtime;
 	OFF_T length;
 	mode_t mode;
-	INO_T inode;
-	dev_t dev;
-	dev_t rdev;
+
+	INO64_T inode;
+	/** Device this file lives upon */
+	DEV64_T dev;
+
+	/** If this is a device node, the device number. */
+	DEV64_T rdev;
 	uid_t uid;
 	gid_t gid;
 	char *basename;
@@ -342,11 +375,11 @@ struct sum_buf {
 };
 
 struct sum_struct {
-  OFF_T flength;		/* total file length */
-  int count;			/* how many chunks */
-  int remainder;		/* flength % block_length */
-  int n;			/* block_length */
-  struct sum_buf *sums;		/* points to info for each chunk */
+	OFF_T flength;		/* total file length */
+	size_t count;		/* how many chunks */
+	size_t remainder;	/* flength % block_length */
+	size_t n;		/* block_length */
+	struct sum_buf *sums;	/* points to info for each chunk */
 };
 
 struct map_struct {
@@ -387,9 +420,11 @@ static inline int flist_up(struct file_list *flist, int i)
 }
 
 #include "byteorder.h"
-#include "proto.h"
 #include "lib/mdfour.h"
 #include "lib/permstring.h"
+#include "lib/addrinfo.h"
+
+#include "proto.h"
 
 /* We have replacement versions of these if they're missing. */
 #ifndef HAVE_ASPRINTF
@@ -426,6 +461,9 @@ extern int errno;
 #define SUPPORT_LINKS HAVE_READLINK
 #define SUPPORT_HARD_LINKS HAVE_LINK
 
+/* This could be bad on systems which have no lchown and where chown
+ * follows symbollic links.  On such systems it might be better not to
+ * try to chown symlinks at all. */
 #ifndef HAVE_LCHOWN
 #define lchown chown
 #endif
@@ -563,12 +601,6 @@ size_t strlcat(char *d, const char *s, size_t bufsize);
 
 extern int verbose;
 
-extern struct global_opts {
-	/** Network address family. **/
-	int af_hint;
-} global_opts;
-
-
 #ifndef HAVE_INET_NTOP
 const char *                 
 inet_ntop(int af, const void *src, char *dst, size_t size);
@@ -577,3 +609,9 @@ inet_ntop(int af, const void *src, char *dst, size_t size);
 #ifndef HAVE_INET_PTON
 int isc_net_pton(int af, const char *src, void *dst);
 #endif
+
+#ifdef __GNUC__
+#  define UNUSED(x) x __attribute__((__unused__))
+#else
+#  define UNUSED(x) x
+#endif /* ndef __GNUC__ */

rsync.yo

@@ -1,5 +1,5 @@
 mailto(rsync-bugs@samba.org)
-manpage(rsync)(1)(29 May 2001)()()
+manpage(rsync)(1)(25 Jan 2002)()()
 manpagename(rsync)(faster, flexible replacement for rcp)
 manpagesynopsis()
 
@@ -19,7 +19,7 @@ manpagedescription()
 
 rsync is a program that behaves in much the same way that rcp does,
 but has many more options and uses the rsync remote-update protocol to
-greatly speedup file transfers when the destination file already
+greatly speed up file transfers when the destination file already
 exists.
 
 The rsync remote-update protocol allows rsync to transfer just the
@@ -81,7 +81,7 @@ 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 an alternative to rsh, by either using the -e
+You can also specify an alternative to rsh, either by 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
@@ -139,10 +139,10 @@ 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. 
 
-You may establish the connetcion via a web proxy by setting the
+You may establish the connection 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.
+your web proxy.  Note that your web proxy's configuration must allow
+proxying to port 873.
 
 Using rsync in this way is the same as using it with rsh or ssh except
 that:
@@ -226,8 +226,8 @@ verb(
      --backup-dir            make backups into this 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
+ -l, --links                 copy symlinks as symlinks
+ -L, --copy-links            copy the referent of symlinks
      --copy-unsafe-links     copy links outside the source tree
      --safe-links            ignore links outside the destination tree
  -H, --hard-links            preserve hard links
@@ -239,12 +239,14 @@ verb(
  -S, --sparse                handle sparse files efficiently
  -n, --dry-run               show what would have been transferred
  -W, --whole-file            copy whole files, no incremental checks
+     --no-whole-file         turn off --whole-file
  -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
+     --ignore-existing       ignore files that already exist on the receiving side
      --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
@@ -267,17 +269,19 @@ verb(
      --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
+     --no-detach             do not detach from the parent
+     --address=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
+     --no-blocking-io        turn off --blocking-io
      --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
- -f, --read-batch=FILE       read batch file
- -F, --write-batch           write batch file
+     --read-batch=PREFIX     read batch fileset starting with PREFIX
+     --write-batch=PREFIX    write batch fileset starting with PREFIX
  -h, --help                  show this help screen
 
 
@@ -334,8 +338,13 @@ 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 -rlptgoD. It is a quick way
-of saying you 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 almost
+everything.  
+
+Note however that bf(-a) bf(does not preserve hardlinks), because
+finding multiply-linked files is expensive.  You must separately
+specify bf(-H).
 
 dit(bf(-r, --recursive)) This tells rsync to copy directories
 recursively. If you don't specify this then rsync won't copy
@@ -372,17 +381,16 @@ 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.
+dit(bf(-l, --links)) When symlinks are encountered, recreate the
+symlink on the destination.
 
-dit(bf(-L, --copy-links)) This tells rsync to treat symbolic links just
-like ordinary files.
+dit(bf(-L, --copy-links)) When symlinks are encountered, the file that
+they point to is copied, rather than the symlink.
 
-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(--copy-unsafe-links)) This tells rsync to copy the referent of
+symbolic links that point outside the source tree.  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
@@ -405,19 +413,21 @@ target machines is higher than the bandwidth to disk (especially when the
 "disk" is actually a networked file system).  This is the default when both
 the source and target are on the local machine.
 
+dit(bf(--no-whole-file)) Turn off --whole-file, for use when it is the
+default.
+
 dit(bf(-p, --perms)) This option causes rsync to update the remote
 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.  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(-o, --owner)) This option causes rsync to set the owner of the
+destination file to be the same as the source file.  On most systems,
+only the super-user can set file ownership.  
 
-dit(bf(-g, --group)) This option causes rsync to update the  remote  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(-g, --group)) This option causes rsync to set the group of the
+destination file to be the same as the source file.  If the receiving
+program 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
@@ -448,6 +458,10 @@ 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(--ignore-existing))
+This tells rsync not to 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.
@@ -481,14 +495,11 @@ dit(bf(--ignore-errors)) Tells --delete to go ahead and delete files
 even when there are IO errors.
 
 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. 
+they are not empty when they are to be replaced by non-directories.  This
+is only relevant without --delete because deletions are now done depth-first.
+Requires the --recursive option (which is implied by -a) to have any effect.
 
-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
@@ -545,8 +556,9 @@ quote(RCS SCCS CVS CVS.adm RCSLOG cvslog.* tags TAGS .make.state
 then files listed in a $HOME/.cvsignore are added to the list and any
 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.
+Finally, any file is ignored if it is in the same directory as a
+.cvsignore file and matches one of the patterns listed therein.  See
+the bf(cvs(1)) manual for more information.
 
 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
@@ -603,21 +615,33 @@ what ownership to give files. The special uid 0 and the special group
 0 are never mapped via user/group names even if the --numeric-ids
 option is not specified.
 
-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.
+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=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
-is being run via inetd, otherwise it will detach from the current
-terminal and become a background daemon. The daemon will read the
-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(--daemon)) This tells rsync that it is to run as a daemon.  The
+daemon may be accessed using the bf(host::module) or
+bf(rsync://host/module/) syntax.
+
+If standard input is a socket then rsync will assume that it is being
+run via inetd, otherwise it will detach from the current terminal and
+become a background daemon.  The daemon will read the 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(--no-detach)) When running as a daemon, this option instructs
+rsync to not detach itself and become a background process.  This
+option is required when running as a service on Cygwin, and may also
+be useful when rsync is supervised by a program such as
+bf(daemontools) or AIX's bf(System Resource Controller).
+bf(--no-detach) is also recommended when rsync is run under a
+debugger.  This option has no effect if rsync is run from inetd or
+sshd.
 
 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
@@ -638,6 +662,9 @@ the default "rsh", this defaults to blocking IO, otherwise it defaults to
 non-blocking IO.  You may find the --blocking-io option is needed for some
 remote shells that can't handle non-blocking IO.  Ssh prefers blocking IO.
 
+dit(bf(--no-blocking-io)) Turn off --blocking-io, for use when it is the
+default.
+
 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
@@ -679,10 +706,13 @@ 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.
 
-dit(bf(--read-batch)) Apply a previously generated change batch.
+dit(bf(--write-batch=PREFIX)) Generate a set of files that can be
+transferred as a batch update. Each filename in the set starts with
+PREFIX. See the "BATCH MODE" section for details.
 
-dit(bf(--write-batch)) Generate a set of files that can be transferred
-as a batch update.
+dit(bf(--read-batch=PREFIX)) Apply a previously generated change batch,
+using the fileset whose filenames start with PREFIX. See the "BATCH
+MODE" section for details.
 
 enddit()
 
@@ -691,7 +721,7 @@ 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
+rsync builds an 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, then that file is
@@ -744,7 +774,7 @@ itemize(
   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.
+  include/exclude list is reset, removing all previously defined patterns.
 )
 
 The +/- rules are most useful in exclude lists, allowing you to have a
@@ -776,27 +806,110 @@ itemize(
 
 manpagesection(BATCH MODE)
 
-The following call generates 4 files that encapsulate the information
-for synchronizing the contents of bf(target_dir) with the updates found in
-bf(src_dir)
+bf(Note:) Batch mode should be considered experimental in this version
+of rsync. The interface or behaviour may change before it stabilizes.
 
-quote(
-$ rsync -F [other rsync options here] \nl()
-           /somewhere/src_dir /somewhere/target_dir
-)
+Batch mode can be used to apply the same set of updates to many
+identical systems. Suppose one has a tree which is replicated on a
+number of hosts.  Now suppose some changes have been made to this
+source tree and those changes need to be propagated to the other
+hosts. In order to do this using batch mode, rsync is run with the
+write-batch option to apply the changes made to the source tree to one
+of the destination trees.  The write-batch option causes the rsync
+client to store the information needed to repeat this operation against
+other destination trees in a batch update fileset (see below).  The
+filename of each file in the fileset starts with a prefix specified by
+the user as an argument to the write-batch option.  This fileset is
+then copied to each remote host, where rsync is run with the read-batch
+option, again specifying the same prefix, and the destination tree.
+Rsync updates the destination tree using the information stored in the
+batch update fileset.
 
-The generated files are labeled with a common timestamp:
+The fileset consists of 4 files:
 
 itemize(
-it() bf(rsync_argvs.<timestamp>) command-line arguments
-it() bf(rsync_flist.<timestamp>) rsync internal file metadata
-it() bf(rsync_csums.<timestamp>) rsync checksums
-it() bf(rsync_delta.<timestamp>) data blocks for file update & change
+it() bf(<prefix>.rsync_argvs) command-line arguments
+it() bf(<prefix>.rsync_flist) rsync internal file metadata
+it() bf(<prefix>.rsync_csums) rsync checksums
+it() bf(<prefix>.rsync_delta) data blocks for file update & change
 )
 
+The .rsync_argvs file contains a command-line suitable for updating a
+destination tree using that batch update fileset. It can be executed
+using a Bourne(-like) shell, optionally passing in an alternate
+destination tree pathname which is then used instead of the original
+path. This is useful when the destination tree path differs from the
+original destination tree path.
+
+Generating the batch update fileset once saves having to perform the
+file status, checksum and data block generation more than once when
+updating multiple destination trees. Multicast transport protocols can
+be used to transfer the batch update files in parallel to many hosts at
+once, instead of sending the same data to every host individually.
+
+Example:
+
+verb(
+$ rsync --write_batch=pfx -a /source/dir/ /adest/dir/
+$ rcp pfx.rsync_* remote:
+$ rsh remote rsync --read_batch=pfx -a /bdest/dir/
+# or alternatively
+$ rsh remote ./pfx.rsync_argvs /bdest/dir/
+)
+
+In this example, rsync is used to update /adest/dir/ with /source/dir/
+and the information to repeat this operation is stored in the files
+pfx.rsync_*. These files are then copied to the machine named "remote".
+Rsync is then invoked on "remote" to update /bdest/dir/ the same way as
+/adest/dir/. The last line shows the rsync_argvs file being used to
+invoke rsync.
+
+Caveats:
+
+The read-batch option expects the destination tree it is meant to update
+to be identical to the destination tree that was used to create the
+batch update fileset.  When a difference between the destination trees
+is encountered the update will fail at that point, leaving the
+destination tree in a partially updated state. In that case, rsync can
+be used in its regular (non-batch) mode of operation to fix up the
+destination tree.
+
+The rsync version used on all destinations should be identical to the
+one used on the original destination.
+
+The -z/--compress option does not work in batch mode and yields a usage
+error. A separate compression tool can be used instead to reduce the
+size of the batch update files for transport to the destination.
+
+The -n/--dryrun option does not work in batch mode and yields a runtime
+error.
+
 See bf(http://www.ils.unc.edu/i2dsi/unc_rsync+.html) for papers and technical
 reports.
 
+manpagesection(SYMBOLIC LINKS)
+
+Three basic behaviours are possible when rsync encounters a symbolic
+link in the source directory.
+
+By default, symbolic links are not transferred at all.  A message
+"skipping non-regular" file is emitted for any symlinks that exist.
+
+If bf(--links) is specified, then symlinks are recreated with the same
+target on the destination.  Note that bf(--archive) implies
+bf(--links).
+
+If bf(--copy-links) is specified, then symlinks are "collapsed" by
+copying their referent, rather than the symlink.
+
+rsync also distinguishes "safe" and "unsafe" symbolic links.  An
+example where this might be used is a web site mirror that wishes
+ensure the rsync module they copy does not include symbolic links to
+bf(/etc/passwd) in the public section of the site.  Using
+bf(--copy-unsafe-links) will cause any links to be copied as the file
+they point to on the destination.  Using bf(--safe-links) will cause
+unsafe links to be ommitted altogether.
+
 manpagesection(DIAGNOSTICS)
 
 rsync occasionally produces error messages that may seem a little
@@ -922,16 +1035,22 @@ Jean-loup Gailly and Mark Adler.
 manpagesection(THANKS)
 
 Thanks to Richard Brent, Brendan Mackay, Bill Waite, Stephen Rothwell
-and David Bell for helpful suggestions and testing of rsync. I've
-probably missed some people, my apologies if I have.
+and David Bell for helpful suggestions, patches and testing of rsync.
+I've probably missed some people, my apologies if I have.
+
+Especial thanks also to: David Dykstra, Jos Backus, Sebastian Krahmer.
 
 
 manpageauthor()
 
-rsync was written by Andrew Tridgell and Paul Mackerras.  They may be
-contacted via email at tridge@samba.org and
-Paul.Mackerras@cs.anu.edu.au
+rsync was written by Andrew Tridgell <tridge@samba.org> and Paul
+Mackerras.
 
-rsync is now also maintained by Martin Pool <mbp@samba.org>
+rsync is now maintained by Martin Pool <mbp@samba.org>.  
 
+Mailing lists for support and development are available at
+url(http://lists.samba.org)(lists.samba.org) 
 
+If you suspect you have found a security vulnerability in rsync,
+please send it directly to Martin Pool and Andrew Tridgell.  For other
+enquiries, please use the mailing list.

runtests.sh

@@ -1,6 +1,6 @@
 #! /bin/sh
 
-# Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+# Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version
@@ -160,16 +160,27 @@ missing=0
 passed=0
 failed=0
 
-scratchdir=./testtmp
-[ -d "$scratchdir" ] && rm -r "$scratchdir"
-mkdir "$scratchdir"
-scratchdir=`cd $scratchdir && pwd`
-echo "    scratchdir=$scratchdir"
+# Prefix for scratch directory.  We create separate directories for
+# each test case, so that they can be left behind in case of failure
+# to aid investigation.
+scratchbase="`pwd`"/testtmp
+echo "    scratchbase=$scratchbase"
 
 suitedir="$srcdir/testsuite"
 
 export scratchdir suitedir
 
+prep_scratch() {
+    [ -d "$scratchdir" ] && rm -rf "$scratchdir"
+    mkdir "$scratchdir"
+    return 0
+}
+
+maybe_discard_scratch() {
+    [ x"$preserve_scratch" != xyes ] && [ -d "$scratchdir" ] && rm -rf "$scratchdir"
+    return 0
+}
+
 if [ "x$whichtests" = x ]
 then
     whichtests="*.test"
@@ -177,29 +188,49 @@ fi
 
 for testscript in $suitedir/$whichtests
 do
-    testbase=`echo $testscript | sed 's!.*/!!'`
+    testbase=`echo $testscript | sed 's!.*/!!' | sed -e 's/.test\$//'`
+    scratchdir="$scratchbase.$testbase"
 
-    echo "----- $testbase starting"
+    prep_scratch
 
-    if sh $RUNSHFLAGS "$testscript"
+    set +e
+    sh $RUNSHFLAGS "$testscript" >"$scratchdir/test.log" 2>&1
+    result=$?
+    set -e
+
+    if [ "x$always_log" = xyes -o \( $result != 0 -a $result != 77 -a $result != 78 \) ]
     then
-	echo "----- $testbase completed succesfully"
-	passed=`expr $passed + 1`
-    else 
-	case $? in
-	77)
-	    echo "----- $testbase skipped"
-	    skipped=`expr $skipped + 1`
-	    ;;
-	*)
-	    echo "----- $testbase failed!"
-	    failed=`expr $failed + 1`
-	    if [ "x$nopersist" = "xyes" ]
-	    then
-		exit 1
-	    fi
-	esac
+	echo "----- $testbase log follows"
+	cat "$scratchdir/test.log"
+	echo "----- $testbase log ends"
     fi
+
+    case $result in
+    0)
+	echo "PASS    $testbase"
+	passed=`expr $passed + 1`
+	maybe_discard_scratch
+	;;
+    77)
+	echo "SKIP    $testbase"
+	skipped=`expr $skipped + 1`
+	maybe_discard_scratch
+	;;
+    78)
+        # It failed, but we expected that.  don't dump out error logs, 
+	# because most users won't want to see them.  But do leave
+	# the working directory around.
+	echo "XFAIL   $testbase"
+	failed=`expr $failed + 1`
+	;;
+    *)
+	echo "FAIL    $testbase"
+	failed=`expr $failed + 1`
+	if [ "x$nopersist" = "xyes" ]
+	then
+	    exit 1
+	fi
+    esac
 done
 
 echo '------------------------------------------------------------'

sender.c

@@ -55,14 +55,14 @@ static struct sum_struct *receive_sums(int f)
 	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++) {
+	for (i=0; i < (int) 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) {
+		if (i == (int) s->count-1 && s->remainder != 0) {
 			s->sums[i].len = s->remainder;
 		} else {
 			s->sums[i].len = s->n;
@@ -159,13 +159,14 @@ void send_files(struct file_list *flist,int f_out,int f_in)
 		initial_stats = stats;
 
 		s = receive_sums(f_in);
-		if (write_batch) /* dw */
-		    write_batch_csum_info(&i,flist->count,s);
 		if (!s) {
 			io_error = 1;
 			rprintf(FERROR,"receive_sums failed\n");
 			return;
 		}
+
+		if (write_batch)
+		    write_batch_csum_info(&i,flist->count,s);
 	  
 		if (!read_batch) {
 			fd = do_open(fname, O_RDONLY, 0);

socket.c

@@ -1,7 +1,9 @@
 /* -*- c-file-style: "linux" -*-
    
+   rsync -- fast file replication program
+   
    Copyright (C) 1992-2001 by Andrew Tridgell <tridge@samba.org>
-   Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+   Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
    
    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
@@ -22,13 +24,15 @@
  * @file socket.c
  * 
  * Socket functions used in rsync.
+ *
+ * This file is now converted to use the new-style getaddrinfo()
+ * interface, which supports IPv6 but is also supported on recent
+ * IPv4-only machines.  On systems that don't have that interface, we
+ * emulate it using the KAME implementation.
  **/
 
 #include "rsync.h"
 
-#ifndef HAVE_GETADDRINFO
-#include "lib/addrinfo.h"
-#endif
 
 /* Establish a proxy connection on an open socket to a web roxy by
  * using the CONNECT method. */
@@ -38,7 +42,7 @@ static int establish_proxy_connection(int fd, char *host, int port)
 	char *cp;
 
 	snprintf(buffer, sizeof(buffer), "CONNECT %s:%d HTTP/1.0\r\n\r\n", host, port);
-	if (write(fd, buffer, strlen(buffer)) != strlen(buffer)) {
+	if (write(fd, buffer, strlen(buffer)) != (int) strlen(buffer)) {
 		rprintf(FERROR, "failed to write to proxy: %s\n",
 			strerror(errno));
 		return -1;
@@ -94,6 +98,39 @@ static int establish_proxy_connection(int fd, char *host, int port)
 }
 
 
+/**
+ * Try to set the local address for a newly-created socket.  Return -1
+ * if this fails.
+ **/
+int try_bind_local(int s,
+		   int ai_family, int ai_socktype,
+		   const char *bind_address)
+{
+	int error;
+	struct addrinfo bhints, *bres_all, *r;
+
+	memset(&bhints, 0, sizeof(bhints));
+	bhints.ai_family = ai_family;
+	bhints.ai_socktype = ai_socktype;
+	bhints.ai_flags = AI_PASSIVE;
+	if ((error = getaddrinfo(bind_address, NULL, &bhints, &bres_all))) {
+		rprintf(FERROR, RSYNC_NAME ": getaddrinfo %s: %s\n",
+			bind_address, gai_strerror(error));
+		return -1;
+	}
+
+	for (r = bres_all; r; r = r->ai_next) {
+		if (bind(s, r->ai_addr, r->ai_addrlen) == -1)
+			continue;
+		return s;
+	}
+
+	/* no error message; there might be some problem that allows
+	 * creation of the socket but not binding, perhaps if the
+	 * machine has no ipv6 address of this name. */
+	return -1;
+}
+
 
 /**
  * Open a socket to a tcp remote host with the specified port .
@@ -121,7 +158,6 @@ int open_socket_out(char *host, int port, const char *bind_address,
 	int type = SOCK_STREAM;
 	int error;
 	int s;
-	int result;
 	struct addrinfo hints, *res0, *res;
 	char portbuf[10];
 	char *h;
@@ -146,6 +182,10 @@ int open_socket_out(char *host, int port, const char *bind_address,
 		*cp++ = '\0';
 		strcpy(portbuf, cp);
 		h = buffer;
+		if (verbose >= 2) {
+			rprintf(FINFO, "connection via http proxy %s port %s\n",
+				h, portbuf);
+		}
 	} else {
 		snprintf(portbuf, sizeof(portbuf), "%d", port);
 		h = host;
@@ -162,32 +202,22 @@ int open_socket_out(char *host, int port, const char *bind_address,
 	}
 
 	s = -1;
+	/* Try to connect to all addresses for this machine until we get
+	 * through.  It might e.g. be multi-homed, or have both IPv4 and IPv6
+	 * addresses.  We need to create a socket for each record, since the
+	 * address record tells us what protocol to use to try to connect. */
 	for (res = res0; res; res = res->ai_next) {
 		s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
 		if (s < 0)
 			continue;
 
-		if (bind_address) {
-			struct addrinfo bhints, *bres;
-
-			memset(&bhints, 0, sizeof(bhints));
-			bhints.ai_family = res->ai_family;
-			bhints.ai_socktype = type;
-			bhints.ai_flags = AI_PASSIVE;
-			error = getaddrinfo(bind_address, NULL, &bhints, &bres);
-			if (error) {
-				rprintf(FERROR, RSYNC_NAME ": getaddrinfo: bind address %s <noport>: %s\n",
-					bind_address, gai_strerror(error));
+		if (bind_address)
+			if (try_bind_local(s, res->ai_family, type,
+					   bind_address) == -1) {
+				close(s);
+				s = -1;
 				continue;
 			}
-			if (bres->ai_next) {
-				rprintf(FERROR, RSYNC_NAME ": getaddrinfo: bind address %s resolved to multiple hosts\n",
-					bind_address);
-				freeaddrinfo(bres);
-				continue;
-			}
-			bind(s, bres->ai_addr, bres->ai_addrlen);
-		}
 
 		if (connect(s, res->ai_addr, res->ai_addrlen) < 0) {
 			close(s);
@@ -263,7 +293,7 @@ static int open_socket_in(int type, int port, const char *bind_address,
 {
 	int one=1;
 	int s;
-	struct addrinfo hints, *res, *resp;
+	struct addrinfo hints, *all_ai, *resp;
 	char portbuf[10];
 	int error;
 
@@ -272,53 +302,43 @@ static int open_socket_in(int type, int port, const char *bind_address,
 	hints.ai_socktype = type;
 	hints.ai_flags = AI_PASSIVE;
 	snprintf(portbuf, sizeof(portbuf), "%d", port);
-	error = getaddrinfo(bind_address, portbuf, &hints, &res);
+	error = getaddrinfo(bind_address, portbuf, &hints, &all_ai);
 	if (error) {
 		rprintf(FERROR, RSYNC_NAME ": getaddrinfo: bind address %s: %s\n",
 			bind_address, gai_strerror(error));
 		return -1;
 	}
-	/* XXX: Do we need to care about getting multiple results
-	 * back?  I think probably not; if the user passed
-	 * bind_address == NULL and we set AI_PASSIVE then we ought to
-	 * get a wildcard result. */
 
-	resp = res;
-	while (1) {
-		s = socket(resp->ai_family, resp->ai_socktype, resp->ai_protocol);
+	/* We may not be able to create the socket, if for example the
+	 * machine knows about IPv6 in the C library, but not in the
+	 * kernel. */
+	for (resp = all_ai; resp; resp = resp->ai_next) {
+		s = socket(resp->ai_family, resp->ai_socktype,
+			   resp->ai_protocol);
 
-		if (s >= 0) {
-			break;	/* got a socket */
-		} else if ((resp = resp->ai_next)) {
-			switch (errno) {
-			case EPROTONOSUPPORT:
-			case EAFNOSUPPORT:
-			case EPFNOSUPPORT:
-				/* See if there's another address that will work... */
-				continue;
-			}
+		if (s == -1) 
+			/* See if there's another address that will work... */
+			continue;
+		
+		setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
+			   (char *)&one, sizeof one);
+		
+		/* now we've got a socket - we need to bind it */
+		if (bind(s, all_ai->ai_addr, all_ai->ai_addrlen) < 0) {
+			/* Nope, try another */
+			close(s);
+			continue;
 		}
 		
-		rprintf(FERROR, RSYNC_NAME ": open inbound socket"
-			"(dom=%d, type=%d, proto=%d) failed: %s\n",
-			resp->ai_family, resp->ai_socktype, resp->ai_protocol,
-			strerror(errno));
-			goto fail;
+		return s;
 	}
 
-	setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&one,sizeof(one));
+	rprintf(FERROR, RSYNC_NAME ": open inbound socket on port %d failed: "
+		"%s\n",
+		port, 
+		strerror(errno));
 
-	/* now we've got a socket - we need to bind it */
-	if (bind(s, res->ai_addr, res->ai_addrlen) < 0) { 
-		rprintf(FERROR, RSYNC_NAME ": bind failed on port %d\n", port);
-		close(s);
-		goto fail;
-	}
-
-	return s;
-
-fail:
-	freeaddrinfo(res);
+	freeaddrinfo(all_ai);
 	return -1; 
 }
 
@@ -353,10 +373,10 @@ void start_accept_loop(int port, int (*fn)(int ))
 {
 	int s;
 	extern char *bind_address;
+	extern int default_af_hint;
 
 	/* open an incoming socket */
-	s = open_socket_in(SOCK_STREAM, port, bind_address,
-			   global_opts.af_hint);
+	s = open_socket_in(SOCK_STREAM, port, bind_address, default_af_hint);
 	if (s == -1)
 		exit_cleanup(RERR_SOCKETIO);
 
@@ -371,9 +391,10 @@ void start_accept_loop(int port, int (*fn)(int ))
 	   for each incoming connection */
 	while (1) {
 		fd_set fds;
+		pid_t pid;
 		int fd;
-		struct sockaddr addr;
-		int in_addrlen = sizeof(addr);
+		struct sockaddr_storage addr;
+		socklen_t addrlen = sizeof addr;
 
 		/* close log file before the potentially very long select so
 		   file can be trimmed by another process instead of growing
@@ -389,7 +410,7 @@ void start_accept_loop(int port, int (*fn)(int ))
 
 		if(!FD_ISSET(s, &fds)) continue;
 
-		fd = accept(s,(struct sockaddr *)&addr,&in_addrlen);
+		fd = accept(s,(struct sockaddr *)&addr,&addrlen);
 
 		if (fd == -1) continue;
 
@@ -402,15 +423,26 @@ void start_accept_loop(int port, int (*fn)(int ))
                 while (waitpid(-1, NULL, WNOHANG) > 0);
 #endif
 
-		if (fork()==0) {
+		if ((pid = fork()) == 0) {
 			close(s);
 			/* open log file in child before possibly giving
 			   up privileges  */
 			log_open();
 			_exit(fn(fd));
+		} else if (pid < 0) {
+			rprintf(FERROR,
+				RSYNC_NAME
+				": could not create child server process: %s\n",
+				strerror(errno));
+			close(fd);
+			/* This might have happened because we're
+			 * overloaded.  Sleep briefly before trying to
+			 * accept again. */
+			sleep(2);
+		} else {
+			/* Parent doesn't need this fd anymore. */
+			close(fd);
 		}
-
-		close(fd);
 	}
 }
 
@@ -550,123 +582,6 @@ void become_daemon(void)
 	}
 }
 
-/**
- * Return the IP addr of the client as a string 
- **/
-char *client_addr(int fd)
-{
-	struct sockaddr ss;
-	int     length = sizeof(ss);
-	static char addr_buf[100];
-	static int initialised;
-
-	if (initialised) return addr_buf;
-
-	initialised = 1;
-
-	if (getpeername(fd, &ss, &length)) {
-		exit_cleanup(RERR_SOCKETIO);
-	}
-
-	getnameinfo(&ss, length,
-		addr_buf, sizeof(addr_buf), NULL, 0, NI_NUMERICHOST);
-	return addr_buf;
-}
-
-
-/**
- * Return the DNS name of the client 
- **/
-char *client_name(int fd)
-{
-	struct sockaddr ss;
-	int     length = sizeof(ss);
-	static char name_buf[100];
-	static char port_buf[100];
-	char *def = "UNKNOWN";
-	static int initialised;
-	struct addrinfo hints, *res, *res0;
-	int error;
-
-	if (initialised) return name_buf;
-
-	initialised = 1;
-
-	strcpy(name_buf,def);
-
-	if (getpeername(fd, (struct sockaddr *)&ss, &length)) {
-		/* FIXME: Can we really not continue? */
-		rprintf(FERROR, RSYNC_NAME ": getpeername on fd%d failed: %s\n",
-			fd, strerror(errno));
-		exit_cleanup(RERR_SOCKETIO);
-	}
-
-#ifdef INET6
-        if (ss.sa_family == AF_INET6 && 
-	    IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)&ss)->sin6_addr)) {
-		struct sockaddr_in6 sin6;
-		struct sockaddr_in *sin;
-
-		memcpy(&sin6, &ss, sizeof(sin6));
-		sin = (struct sockaddr_in *)&ss;
-		memset(sin, 0, sizeof(*sin));
-		sin->sin_family = AF_INET;
-		length = sizeof(struct sockaddr_in);
-#ifdef HAVE_SOCKADDR_LEN
-		sin->sin_len = length;
-#endif
-		sin->sin_port = sin6.sin6_port;
-		memcpy(&sin->sin_addr, &sin6.sin6_addr.s6_addr[12],
-			sizeof(sin->sin_addr));
-        }
-#endif
-
-	/* reverse lookup */
-	if (getnameinfo((struct sockaddr *)&ss, length,
-			name_buf, sizeof(name_buf), port_buf, sizeof(port_buf),
-			NI_NAMEREQD | NI_NUMERICSERV) != 0) {
-		strcpy(name_buf, def);
-		rprintf(FERROR, "reverse name lookup failed\n");
-	}
-
-	/* forward lookup */
-	memset(&hints, 0, sizeof(hints));
-	hints.ai_family = PF_UNSPEC;
-	hints.ai_flags = AI_CANONNAME;
-	hints.ai_socktype = SOCK_STREAM;
-	error = getaddrinfo(name_buf, port_buf, &hints, &res0);
-	if (error) {
-		strcpy(name_buf, def);
-		rprintf(FERROR,
-			RSYNC_NAME ": forward name lookup for %s failed: %s\n",
-			port_buf,
-			gai_strerror(error));
-		return name_buf;
-	}
-
-	/* XXX sin6_flowinfo and other fields */
-	for (res = res0; res; res = res->ai_next) {
-		if (res->ai_family != ss.sa_family)
-			continue;
-		if (res->ai_addrlen != length)
-			continue;
-		if (memcmp(res->ai_addr, &ss, res->ai_addrlen) == 0)
-			break;
-	}
-
-	/* TODO: Do a  forward lookup as well to prevent spoofing */
-
-	if (res == NULL) {
-		strcpy(name_buf, def);
-		rprintf(FERROR, RSYNC_NAME ": "
-			"reverse name lookup mismatch on fd%d - spoofed address?\n",
-			fd);
-	}
-
-	freeaddrinfo(res0);
-	return name_buf;
-}
-
 
 /*******************************************************************
 this is like socketpair but uses tcp. It is used by the Samba
@@ -691,7 +606,7 @@ static int socketpair_tcp(int fd[2])
 	if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
 
         memset(&sock2, 0, sizeof(sock2));
-#ifdef HAVE_SOCK_SIN_LEN
+#ifdef HAVE_SOCKADDR_LEN
         sock2.sin_len = sizeof(sock2);
 #endif
         sock2.sin_family = PF_INET;
@@ -735,16 +650,20 @@ static int socketpair_tcp(int fd[2])
 }
 
 
-/*******************************************************************
-run a program on a local tcp socket, this is used to launch smbd
-when regression testing
-the return value is a socket which is attached to a subprocess
-running "prog". stdin and stdout are attached. stderr is left
-attached to the original stderr
- ******************************************************************/
+
+/**
+ * Run a program on a local tcp socket, so that we can talk to it's
+ * stdin and stdout.  This is used to fake a connection to a daemon
+ * for testing -- not for the normal case of running SSH.
+ *
+ * @return a socket which is attached to a subprocess running
+ * "prog". stdin and stdout are attached. stderr is left attached to
+ * the original stderr
+ **/
 int sock_exec(const char *prog)
 {
 	int fd[2];
+	
 	if (socketpair_tcp(fd) != 0) {
 		rprintf (FERROR, RSYNC_NAME
 			 ": socketpair_tcp failed (%s)\n",
@@ -757,10 +676,12 @@ int sock_exec(const char *prog)
 		close(1);
 		dup(fd[1]);
 		dup(fd[1]);
-		if (verbose > 3)
+		if (verbose > 3) {
+			/* Can't use rprintf because we've forked. */
 			fprintf (stderr,
 				 RSYNC_NAME ": execute socket program \"%s\"\n",
 				 prog);
+		}
 		exit (system (prog));
 	}
 	close (fd[1]);

syscall.c

@@ -1,5 +1,6 @@
 /* 
    Copyright (C) Andrew Tridgell 1998
+   Copyright (C) 2002 by Martin Pool
    
    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
@@ -16,9 +17,12 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-/*
-  syscall wrappers to ensure that nothing gets done in dry_run mode
-  */
+/**
+ * @file syscall.c
+ *
+ * Syscall wrappers to ensure that nothing gets done in dry_run mode
+ * and to handle system peculiarities.
+ **/
 
 #include "rsync.h"
 
@@ -106,13 +110,24 @@ int do_rename(char *fname1, char *fname2)
 	return rename(fname1, fname2);
 }
 
+
 int do_mkdir(char *fname, mode_t mode)
 {
-	if (dry_run) return 0;
-	CHECK_RO
+	int l;
+	if (dry_run)
+		return 0;
+	CHECK_RO;
+	
+	/* Some BSD systems cannot make a directory if the name
+	 * contains a trailing slash.
+	 * <http://www.opensource.apple.com/bugs/X/BSD%20Kernel/2734739.html> */
+	if ((l = strlen(fname))  &&  (fname[l-1] == '/'))
+		fname[l-1] = '/';
+	
 	return mkdir(fname, mode);
 }
 
+
 /* like mkstemp but forces permissions */
 int do_mkstemp(char *template, mode_t perms)
 {
@@ -132,7 +147,7 @@ int do_mkstemp(char *template, mode_t perms)
 	}
 #else
 	if (!mktemp(template)) return -1;
-	return open(template, O_RDWR|O_EXCL|O_CREAT, perms);
+	return do_open(template, O_RDWR|O_EXCL|O_CREAT, perms);
 #endif
 }
 

testhelp/maketree.py

@@ -0,0 +1,133 @@
+#! /usr/bin/python2.2
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version
+# 2 as published by the Free Software Foundation.
+#
+# 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
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+# Populate a tree with pseudo-randomly distributed files to test
+# rsync.
+
+from __future__ import generators
+import random, string, os, os.path
+
+nfiles = 10000
+depth = 5
+n_children = 20
+n_files = 20
+n_symlinks = 10
+
+name_chars = string.digits + string.letters
+
+abuffer = 'a' * 1024
+
+def random_name_chars():
+    a = ""
+    for i in range(10):
+        a = a + random.choice(name_chars)
+    return a
+
+    
+def generate_names():
+    n = 0
+    while 1:
+        yield "%05d_%s" % (n, random_name_chars())
+        n += 1
+
+
+class TreeBuilder:
+    def __init__(self):
+        self.n_children = 20
+        self.n_files = 100
+        self.total_entries = 100000 # long(1e8)
+        self.actual_size = 0
+        self.name_gen = generate_names()
+        self.all_files = []
+        self.all_dirs = []
+        self.all_symlinks = []
+
+
+    def random_size(self):
+        return random.lognormvariate(4, 4)
+
+
+    def random_symlink_target(self):
+        what = random.choice(['directory', 'file', 'symlink', 'none'])
+        try:
+            if what == 'directory':
+                return random.choice(self.all_dirs)
+            elif what == 'file':
+                return random.choice(self.all_files)
+            elif what == 'symlink':
+                return random.choice(self.all_symlinks)
+            elif what == 'none':
+                return self.name_gen.next()
+        except IndexError:
+            return self.name_gen.next()
+
+
+    def can_continue(self):
+        self.total_entries -= 1
+        return self.total_entries > 0
+
+        
+    def build_tree(self, prefix, depth):
+        """Generate a breadth-first tree"""
+        for count, function in [[n_files, self.make_file],
+                                [n_children, self.make_child_recurse],
+                                [n_symlinks, self.make_symlink]]:
+            for i in range(count):
+                if not self.can_continue():
+                    return
+                name = os.path.join(prefix, self.name_gen.next())
+                function(name, depth)
+
+
+    def print_summary(self):
+        print "total bytes: %d" % self.actual_size
+
+
+    def make_child_recurse(self, dname, depth):
+        if depth > 1:
+            self.make_dir(dname)
+            self.build_tree(dname, depth-1)
+
+
+    def make_dir(self, dname, depth='ignore'):
+        print "%s/" % (dname)
+        os.mkdir(dname)
+        self.all_dirs.append(dname)
+
+
+    def make_symlink(self, lname, depth='ignore'):
+        print "%s -> %s" % (lname, self.random_symlink_target())
+
+
+    def make_file(self, fname, depth='ignore'):
+        size = long(self.random_size())
+        print "%-70s %d" % (fname, size)
+        f = open(fname, 'w')
+        f.truncate(size)
+        self.fill_file(f, size)
+        self.all_files.append(fname)
+        self.actual_size += size
+
+    def fill_file(self, f, size):
+        while size > 0:
+            f.write(abuffer[:size])
+            size -= len(abuffer)
+
+    
+tb = TreeBuilder()
+tb.build_tree('/tmp/foo', 3)
+tb.print_summary()

testsuite/README

@@ -1,7 +0,0 @@
-This directory contains automatic test cases for rsync.  You can run
-them yourself if you want, preferably by doing "make check" in the
-top-level source directory.  (Not implemented yet.)
-
-They also run automatically on the build farm, and you can see the
-results on http://build.samba.org/.  That's controlled by the file
-./runlist.

testsuite/README.testsuite

@@ -0,0 +1,30 @@
+automatic testsuite for rsync			-*- text -*-
+
+We're trying to develop some more substantial tests to prevent rsync
+regressions.  Ideally, all code changes or bug reports would come with
+an appropriate test suite.
+
+You can run these tests by typing "make check" in the build directory.
+The tests will run using the rsync binary in the build directory, so
+you do not need to do "make install" first.  Indeed, you probably
+should not install rsync before running the tests.
+
+If you instead type "make installcheck" then the suite will test the
+rsync binary from its installed location (e.g. /usr/local/bin/rsync).
+You can use this to test a distribution build, or perhaps to run a new
+test suite against an old version of rsync.  Note that in accordance
+with the GNU Standards, installcheck does not look for rsync on the
+path.
+
+If the tests pass, you should see a report to that effect.  Some tests
+require being root or some other precondition, and so will normally be
+checked -- look at the test scripts for more information.
+
+If the tests fail, you will see rather more output.  The scratch
+directory will remain in the build directory.  It would be useful if
+you could include the log messages when reporting a failure.
+
+These tests also run automatically on the build farm, and you can see
+the results on http://build.samba.org/.
+
+

testsuite/chgrp.test

@@ -0,0 +1,36 @@
+#! /bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that rsync with -gr will preserve groups when the user running
+# the test is a member of them.  Hopefully they're in at least one
+# test.
+
+. $srcdir/testsuite/rsync.fns
+
+set -x
+
+# Build some hardlinks
+
+fromdir="$scratchdir/from"
+todir="$scratchdir/to"
+
+mygrps="`groups`" || fail "Can't get groups"
+mkdir "$fromdir"
+
+for g in $mygrps
+do
+    name="$fromdir/foo-$g"
+    date > "$name"
+    chgrp "$g" "$name" || fail "Can't chgrp"
+done
+sleep 2
+
+checkit "rsync -rtgvvv \"$fromdir/\" \"$todir/\"" "$fromdir" "$todir"
+
+exit 0
+# last [] may have failed but if we get here then we've won
+

testsuite/chown.test

@@ -0,0 +1,38 @@
+#! /bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that when rsync is running as root and has -a it correctly sets
+# the ownership of the destination.
+
+# We don't know what users will be present on this system, so we just
+# use random numeric uids and gids.
+
+. $srcdir/testsuite/rsync.fns
+
+set -x
+
+# Build some hardlinks
+
+fromdir="$scratchdir/from"
+todir="$scratchdir/to"
+
+mkdir "$fromdir"
+name1="$fromdir/name1"
+name2="$fromdir/name2"
+echo "This is the file" > "$name1"
+echo "This is the other file" > "$name2"
+
+chown 5000 "$name1" || test_skipped "Can't chown"
+chown 5001 "$name2" || test_skipped "Can't chown"
+chgrp 5002 "$name1" || test_skipped "Can't chgrp"
+chgrp 5003 "$name2" || test_skipped "Can't chgrp"
+
+checkit "rsync -aHvv \"$fromdir/\" \"$todir/\"" "$fromdir" "$todir"
+
+exit 0
+# last [] may have failed but if we get here then we've won
+

testsuite/daemon-gzip-download.test

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+# Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
+
+#    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.
+
+# This test tries to download a tree over a compressed connection from
+# the server.  This ought to exercise (exorcise?) a bug in 2.5.3.
+
+. "$suitedir/rsync.fns"
+
+build_rsyncd_conf
+
+RSYNC_CONNECT_PROG="$rsync_bin --config=$conf --daemon"
+export RSYNC_CONNECT_PROG
+
+hands_setup
+checkit "$rsync_bin -avvz localhost::test-from/ \"$TO/\"" "$FROM" "$TO"
+

testsuite/daemon-gzip-upload.test

@@ -0,0 +1,25 @@
+#!/bin/sh
+
+# Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING)
+
+# We don't really want to start the server listening, because that
+# might interfere with the security or operation of the test machine.
+# Instead we use the fake-connect feature to dynamically assign a pair
+# of ports.
+
+# This test tries to upload a file over a compressed connection to the
+# server.  This ought to exercise (exorcise?) a bug in 2.5.3.
+
+. "$suitedir/rsync.fns"
+
+build_rsyncd_conf
+
+RSYNC_CONNECT_PROG="$rsync_bin --config=$conf --daemon"
+export RSYNC_CONNECT_PROG
+
+hands_setup
+checkit "$rsync_bin -avvz \"$FROM/\" localhost::test-to/" "$FROM" "$TO"
+

testsuite/devices.test

@@ -0,0 +1,29 @@
+#! /bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync handling of devices.  This can only run if you're root.
+
+. $srcdir/testsuite/rsync.fns
+
+set -x
+
+# Build some hardlinks
+
+fromdir="$scratchdir/from"
+todir="$scratchdir/to"
+
+# TODO: Need to test whether hardlinks are possible on this OS/filesystem
+
+mkdir "$fromdir"
+mknod "$fromdir/char" c 42 69  || test_skipped "Can't create char device node?"
+mknod "$fromdir/block" b 42 69 || test_skipped "Can't create block device node?"
+
+checkit "rsync -aHvv \"$fromdir/\" \"$todir/\"" "$fromdir" "$todir"
+
+exit 0
+# last [] may have failed but if we get here then we've won
+

testsuite/duplicates.test

@@ -0,0 +1,57 @@
+#! /bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL see
+# COPYING).
+
+# Test rsync handling of duplicate filenames.  
+
+# It's quite possible that the user might specify the same source file
+# more than once on the command line, perhaps through shell variables
+# or wildcard expansions.  It might cause problems for rsync if the
+# same name occurred more than once in the file list, because we might
+# be trying to update the first copy and generate checksums for the
+# second copy at the same time.  See clean_flist() for the implementation.
+
+# We don't need to worry about hardlinks or symlinks.  Because we
+# always rename-and-replace the new copy, they can't affect us.
+
+# This test is not great, because it is a timing-dependent bug.
+
+. $srcdir/testsuite/rsync.fns
+
+echo "SKIP THIS FOR NOW; It's a known bug"
+exit 77
+
+set -x
+
+# Build some hardlinks
+
+fromdir="$scratchdir/from"
+todir="$scratchdir/to"
+
+mkdir "$fromdir"
+name1="$fromdir/name1"
+name2="$fromdir/name2"
+echo "This is the file" > "$name1"
+ln -s "$name1" "$name2" || fail "can't create symlink"
+
+outfile="$scratchdir/rsync.out"
+
+checkit "rsync -avv \"$fromdir/\" \"$fromdir/\" \"$fromdir/\" \"$fromdir/\" \"$fromdir/\" \"$fromdir/\" \"$fromdir/\" \"$fromdir/\" \"$fromdir/\" \"$fromdir/\" \"$todir/\"" "$fromdir" "$todir" \
+    | tee "$outfile"
+
+# Make sure each file was only copied once...
+if [ `grep -c '^name1$' "$outfile"` != 1 ]
+then
+    test_xfail "name1 was not copied exactly once"
+fi
+if [ `grep -c '^name2$' "$outfile"` != 1 ]
+then
+    test_xfail "name2 was not copied exactly once"
+fi
+
+exit 0
+# last [] may have failed but if we get here then we've won
+

testsuite/hands.test

@@ -26,3 +26,5 @@ cp ${FROM}/text ${TO}/ThisShouldGo
 runtest " --delete" 'checkit "$RSYNC --delete -avH ${FROM}/ ${TO}" ${FROM}/ ${TO}'
 
 checkforlogs ${LOG}.?
+
+hands_cleanup

testsuite/hardlinks.test

@@ -0,0 +1,38 @@
+#! /bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync handling of hardlinks.  By default (in 2.5.1) rsync does
+# not detect symlinks and they get split into different files.  If you
+# specify -H, then hard links are detected and recreated as hardlinks
+# on the other end.
+
+. $srcdir/testsuite/rsync.fns
+
+set -x
+
+# Build some hardlinks
+
+fromdir="$scratchdir/from"
+todir="$scratchdir/to"
+
+# TODO: Need to test whether hardlinks are possible on this OS/filesystem
+
+mkdir "$fromdir"
+name1="$fromdir/name1"
+name2="$fromdir/name2"
+name3="$fromdir/name3"
+name4="$fromdir/name4"
+echo "This is the file" > "$name1"
+ln "$name1" "$name2" || fail "Can't create hardlink"
+ln "$name2" "$name3" || fail "Can't create hardlink"
+cp "$name2" "$name4" || fail "Can't copy file"
+
+checkit "rsync -aHvv \"$fromdir/\" \"$todir/\"" "$fromdir" "$todir"
+
+exit 0
+# last [] may have failed but if we get here then we've won
+

testsuite/longdir.test

@@ -7,7 +7,7 @@
 
 . "$suitedir/rsync.fns"
 
-set -x
+# set -x
 
 hands_setup
 

testsuite/rsync.fns

@@ -53,7 +53,8 @@ hands_setup() {
     # Clean before creation
     rm -rf $FROM
     rm -rf $TO
-    
+
+    [ -d $TMP ] || mkdir $TMP
     [ -d $FROM ] || mkdir $FROM
     [ -d $TO ] || mkdir $TO
 
@@ -72,7 +73,7 @@ hands_setup() {
     mkdir ${FROM}/emptydir
 
     # a hundred lines of text or so
-    rsync_ls_lR ${srcdir} > ${FROM}/filelist
+    rsync_ls_lR "${srcdir}" > ${FROM}/filelist
 
     # This might fail on systems that don't have -n
     echo $ECHO_N "This file has no trailing lf$ECHO_C" > ${FROM}/nolf
@@ -94,6 +95,11 @@ hands_setup() {
 }
 
 
+hands_cleanup() {
+    rm -r "$TMP"
+}
+
+
 
 
 ####################
@@ -129,35 +135,35 @@ makepath () {
 # there are any difference.  If there are, explain them.
 
 checkit() {
-    log=${LOG}
     failed=
-    # the log accumulates all output; we only display it if there 
-    # is a problem.
 
-    echo "Running: \"$1\""  >${log}
-    echo "">>${log}
-    eval "$1"  >>${log} 2>&1
+    # We can just write everything to stdout/stderr, because the
+    # wrapper hides it unless there is a problem.
+
+    echo "Running: \"$1\""  
+    eval "$1" 
     status=$?
     if [ $status != 0 ]; then
 	failed="YES";
     fi
 
-    echo "-------------">>${log}
-    echo "check how the files compare with diff:">>${log}
-    echo "">>${log}
-    diff -cr $2 $3 >>${log} 2>&1 || failed=YES
-    echo "-------------">>${log}
-    echo "check how the directory listings compare with diff:">>${log}
-    echo "">>${log}
-    ( cd "$2" && rsync_ls_lR ) > ${TMP}/ls-from 2>>${log}
-    ( cd "$3" && rsync_ls_lR ) > ${TMP}/ls-to  2>>${log}
-    diff -c ${TMP}/ls-from ${TMP}/ls-to >>${log} 2>&1 || failed=YES
+    echo "-------------"
+    echo "check how the files compare with diff:"
+    echo ""
+    for f in `cd "$2"; find . -type f -print `
+    do 
+        diff -c "$2"/"$f" "$3"/"$f" || failed=YES
+    done
+
+    echo "-------------"
+    echo "check how the directory listings compare with diff:"
+    echo ""
+    ( cd "$2" && rsync_ls_lR . ) > ${TMP}/ls-from 
+    ( cd "$3" && rsync_ls_lR . ) > ${TMP}/ls-to 
+    diff -c ${TMP}/ls-from ${TMP}/ls-to || failed=YES
     if [ -z "${failed}" ] ; then
-	rm $log
 	return 0
     else
-	cat ${log}
-	rm ${log}
 	return 1
     fi
 }
@@ -195,12 +201,45 @@ use chroot = no
 hosts allow = localhost, 127.0.0.1
 log file = $logfile
 
-[test-from] = $scratchdir/daemon-from/
+[test-from]
+	path = $FROM
 	read only = yes
 
-[test-to] = $scratchdir/daemon-to/
+[test-to]
+	path = $TO
 	read only = no
 EOF
 }
 
 
+build_symlinks() {
+    fromdir="$scratchdir/from"
+    todir="$scratchdir/to"
+    mkdir "$fromdir"
+    date >"$fromdir/referent"
+    ln -s referent "$fromdir/relative"
+    ln -s "$fromdir/referent" "$fromdir/absolute"
+    ln -s nonexistent "$fromdir/dangling"
+    ln -s "$srcdir/rsync.c" "$fromdir/unsafe"
+}
+
+test_fail() {
+    echo "$@" >&2
+    exit 1
+}
+
+test_skipped() {
+    echo "$@" >&2
+    exit 77
+}
+
+# It failed, but we expected that.  don't dump out error logs, 
+# because most users won't want to see them.  But do leave
+# the working directory around.
+test_xfail() {
+    echo "$@" >&2
+    exit 78
+}
+
+# be reproducible
+umask 077

testsuite/symlink-ignore.test

@@ -0,0 +1,40 @@
+#! /bin/sh
+
+# Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync's somewhat over-featured symlink control: the default
+# behaviour is that symlinks should not be copied at all.
+
+. $srcdir/testsuite/rsync.fns
+
+set -x
+
+build_symlinks || test_fail "failed to build symlinks"
+
+# Copy recursively, but without -l or -L or -a, and all the symlinks
+# should be missing.
+"$rsync_bin" -r "$fromdir/" "$todir" || test_fail "rsync returned $?"
+
+[ -f "${todir}/referent" ] || test_fail "referent was not copied"
+[ -d "${todir}/from" ] && test_fail "extra level of directories"
+if [ -L "${todir}/dangling" ] 
+then 
+    test_fail "dangling symlink was copied"
+fi
+
+if [ -L "${todir}/relative" ] 
+then
+    test_fail "relative symlink was copied" 
+fi
+
+if [ -L "${todir}/absolute" ]
+then
+    test_fail "absolute symlink was copied"
+fi
+
+exit 0
+# last [] may have failed but if we get here then we've one
+

tls.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "linux" -*-
  *
- * Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+ * Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version
@@ -62,7 +62,7 @@ static void failed (char const *what,
 
 static void list_file (const char *fname)
 {
-	struct stat buf;
+	STRUCT_STAT buf;
 	char permbuf[PERMSTRING_SIZE];
 	struct tm *mt;
 	char datebuf[50];
@@ -80,11 +80,18 @@ static void list_file (const char *fname)
 	 * undefined.  Also it tends not to be possible to reset a
 	 * symlink's mtime, so we have to ignore it too. */
 	if (S_ISLNK(buf.st_mode)) {
+		int len;
 		buf.st_mode &= ~0777;
 		buf.st_mtime = (time_t)0;
 		buf.st_uid = buf.st_gid = 0;
 		strcpy(linkbuf, " -> ");
-		readlink(fname, linkbuf+4, sizeof(linkbuf) - 4);
+		/* const-cast required for silly UNICOS headers */
+		len = readlink((char *) fname, linkbuf+4, sizeof(linkbuf) - 4);
+		if (len == -1) 
+			failed("readlink", fname);
+		else
+			/* it's not nul-terminated */
+			linkbuf[4+len] = 0;
 	} else {
 		linkbuf[0] = 0;
 	}
@@ -110,9 +117,10 @@ static void list_file (const char *fname)
 	
 	/* NB: need to pass size as a double because it might be be
 	 * too large for a long. */
-	printf("%s %12.0f %6d.%-6d %s %s%s\n",
+	printf("%s %12.0f %6d.%-6d %6d %s %s%s\n",
 	       permbuf, (double) buf.st_size,
 	       buf.st_uid, buf.st_gid,
+	       buf.st_nlink,
 	       datebuf, fname, linkbuf);
 }
 

util.c

@@ -2,7 +2,7 @@
     
     Copyright (C) 1996-2000 by Andrew Tridgell 
     Copyright (C) Paul Mackerras 1996
-    Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+    Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
    
    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
@@ -84,6 +84,26 @@ int fd_pair(int fd[2])
 }
 
 
+static void print_child_argv(char **cmd)
+{
+	rprintf(FINFO, "opening connection using ");
+	for (; *cmd; cmd++) {
+		/* Look for characters that ought to be quoted.  This
+		* is not a great quoting algorithm, but it's
+		* sufficient for a log message. */
+		if (strspn(*cmd, "abcdefghijklmnopqrstuvwxyz"
+			   "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+			   "0123456789"
+			   ",.-_=+@/") != strlen(*cmd)) {
+			rprintf(FINFO, "\"%s\" ", *cmd);
+		} else {
+			rprintf(FINFO, "%s ", *cmd);
+		}
+	}
+	rprintf(FINFO, "\n");
+}
+
+
 /* this is derived from CVS code 
 
    note that in the child STDIN is set to blocking and STDOUT
@@ -94,59 +114,63 @@ int fd_pair(int fd[2])
    used to cope with badly broken rsh implementations like the one on
    solaris.
  */
-pid_t piped_child(char **command,int *f_in,int *f_out)
+pid_t piped_child(char **command, int *f_in, int *f_out)
 {
-  pid_t pid;
-  int to_child_pipe[2];
-  int from_child_pipe[2];
-  extern int blocking_io;
+	pid_t pid;
+	int to_child_pipe[2];
+	int from_child_pipe[2];
+	extern int blocking_io;
+	
+	if (verbose >= 2) {
+		print_child_argv(command);
+	}
 
-  if (fd_pair(to_child_pipe) < 0 ||
-      fd_pair(from_child_pipe) < 0) {
-    rprintf(FERROR,"pipe: %s\n",strerror(errno));
-    exit_cleanup(RERR_IPC);
-  }
+	if (fd_pair(to_child_pipe) < 0 || fd_pair(from_child_pipe) < 0) {
+		rprintf(FERROR, "pipe: %s\n", strerror(errno));
+		exit_cleanup(RERR_IPC);
+	}
 
 
-  pid = do_fork();
-  if (pid == -1) {
-    rprintf(FERROR,"fork: %s\n",strerror(errno));
-    exit_cleanup(RERR_IPC);
-  }
+	pid = do_fork();
+	if (pid == -1) {
+		rprintf(FERROR, "fork: %s\n", strerror(errno));
+		exit_cleanup(RERR_IPC);
+	}
 
-  if (pid == 0)
-    {
-      extern int orig_umask;
-      if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
-	  close(to_child_pipe[1]) < 0 ||
-	  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(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(RERR_IPC);
-    }
+	if (pid == 0) {
+		extern int orig_umask;
+		if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
+		    close(to_child_pipe[1]) < 0 ||
+		    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(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(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(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(RERR_IPC);
+	}
 
-  *f_in = from_child_pipe[0];
-  *f_out = to_child_pipe[1];
+	*f_in = from_child_pipe[0];
+	*f_out = to_child_pipe[1];
 
-  return pid;
+	return pid;
 }
 
 pid_t local_child(int argc, char **argv,int *f_in,int *f_out)
@@ -173,10 +197,7 @@ pid_t local_child(int argc, char **argv,int *f_in,int *f_out)
 		extern int am_sender;
 		extern int am_server;
 
-		if (read_batch)
-		    am_sender = 0;
-		else
-		    am_sender = !am_sender;
+		am_sender = read_batch ? 0 : !am_sender;
 		am_server = 1;		
 
 		if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
@@ -219,10 +240,18 @@ void overflow(char *str)
 
 
 
-int set_modtime(char *fname,time_t modtime)
+int set_modtime(char *fname, time_t modtime)
 {
 	extern int dry_run;
-	if (dry_run) return 0;
+	if (dry_run)
+		return 0;
+
+	if (verbose > 2) {
+		rprintf(FINFO, "set modtime of %s to (%ld) %s",
+			fname, (long) modtime,
+			asctime(localtime(&modtime)));
+	}
+	
 	{
 #ifdef HAVE_UTIMBUF
 		struct utimbuf tbuf;  
@@ -275,7 +304,7 @@ int create_directory_path(char *fname)
 
    derived from GNU C's cccp.c.
 */
-static int full_write(int desc, char *ptr, int len)
+static int full_write(int desc, char *ptr, size_t len)
 {
 	int total_written;
 	
@@ -301,11 +330,11 @@ static int full_write(int desc, char *ptr, int len)
    for an error.  
 
    derived from GNU C's cccp.c. */
-static int safe_read(int desc, char *ptr, int len)
+static int safe_read(int desc, char *ptr, size_t len)
 {
 	int n_chars;
  
-	if (len <= 0)
+	if (len == 0)
 		return len;
  
 #ifdef EINTR
@@ -538,7 +567,7 @@ static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
 		globfree(&globbuf);
 		return;
 	}
-	for (i=0; i<(maxargs - (*argc)) && i<globbuf.gl_pathc;i++) {
+	for (i=0; i<(maxargs - (*argc)) && i < (int) globbuf.gl_pathc;i++) {
 		if (i == 0) free(argv[*argc]);
 		argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
 		if (!argv[(*argc) + i]) out_of_memory("glob_expand");
@@ -811,28 +840,91 @@ int u_strcmp(const char *cs1, const char *cs2)
 	return (int)*s1 - (int)*s2;
 }
 
-static OFF_T last_ofs;
+static OFF_T  last_ofs;
+static struct timeval print_time;
+static struct timeval start_time;
+static OFF_T  start_ofs;
+
+static unsigned long msdiff(struct timeval *t1, struct timeval *t2)
+{
+    return (t2->tv_sec - t1->tv_sec) * 1000
+        + (t2->tv_usec - t1->tv_usec) / 1000;
+}
+
+
+/**
+ * @param ofs Current position in file
+ * @param size Total size of file
+ * @param is_last True if this is the last time progress will be
+ * printed for this file, so we should output a newline.  (Not
+ * necessarily the same as all bytes being received.)
+ **/
+static void rprint_progress(OFF_T ofs, OFF_T size, struct timeval *now,
+			    int is_last)
+{
+    int           pct  = (ofs == size) ? 100 : (int)((100.0*ofs)/size);
+    unsigned long diff = msdiff(&start_time, now);
+    double        rate = diff ? (double) (ofs-start_ofs) * 1000.0 / diff / 1024.0 : 0;
+    const char    *units;
+    double        remain = rate ? (double) (size-ofs) / rate / 1000.0: 0.0;
+    int 	  remain_h, remain_m, remain_s;
+
+    if (rate > 1024*1024) {
+	    rate /= 1024.0 * 1024.0;
+	    units = "GB/s";
+    } else if (rate > 1024) {
+	    rate /= 1024.0;
+	    units = "MB/s";
+    } else {
+	    units = "kB/s";
+    }
+
+    remain_s = (int) remain % 60;
+    remain_m = (int) (remain / 60.0) % 60;
+    remain_h = (int) (remain / 3600.0);
+    
+    rprintf(FINFO, "%12.0f %3d%% %7.2f%s %4d:%02d:%02d%s",
+	    (double) ofs, pct, rate, units,
+	    remain_h, remain_m, remain_s,
+	    is_last ? "\n" : "\r");
+}
 
 void end_progress(OFF_T size)
 {
 	extern int do_progress, am_server;
 
 	if (do_progress && !am_server) {
-		rprintf(FINFO,"%.0f (100%%)\n", (double)size);
+        	struct timeval now;
+                gettimeofday(&now, NULL);
+                rprint_progress(size, size, &now, True);
 	}
-	last_ofs = 0;
+	last_ofs   = 0;
+        start_ofs  = 0;
+        print_time.tv_sec  = print_time.tv_usec  = 0;
+        start_time.tv_sec  = start_time.tv_usec  = 0;
 }
 
 void show_progress(OFF_T ofs, OFF_T size)
 {
 	extern int do_progress, am_server;
+        struct timeval now;
 
-	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;
-		}
+        gettimeofday(&now, NULL);
+
+        if (!start_time.tv_sec && !start_time.tv_usec) {
+        	start_time.tv_sec  = now.tv_sec;
+                start_time.tv_usec = now.tv_usec;
+                start_ofs          = ofs;
+        }
+
+	if (do_progress
+            && !am_server
+            && ofs > last_ofs + 1000
+            && msdiff(&print_time, &now) > 250) {
+        	rprint_progress(ofs, size, &now, False);
+                last_ofs = ofs;
+                print_time.tv_sec  = now.tv_sec;
+                print_time.tv_usec = now.tv_usec;
 	}
 }
 

zlib/ChangeLog

@@ -1,6 +1,64 @@
 
 		ChangeLog file for zlib
 
+Changes in 1.1.4 (11 March 2002)
+- ZFREE was repeated on same allocation on some error conditions.
+  This creates a security problem described in
+  http://www.zlib.org/advisory-2002-03-11.txt
+- Returned incorrect error (Z_MEM_ERROR) on some invalid data
+- Avoid accesses before window for invalid distances with inflate window
+  less than 32K.
+- force windowBits > 8 to avoid a bug in the encoder for a window size
+  of 256 bytes. (A complete fix will be available in 1.1.5).
+	
+Changes in 1.1.3 (9 July 1998)
+- fix "an inflate input buffer bug that shows up on rare but persistent
+  occasions" (Mark)
+- fix gzread and gztell for concatenated .gz files (Didier Le Botlan)
+- fix gzseek(..., SEEK_SET) in write mode
+- fix crc check after a gzeek (Frank Faubert)
+- fix miniunzip when the last entry in a zip file is itself a zip file
+  (J Lillge)
+- add contrib/asm586 and contrib/asm686 (Brian Raiter)
+  See http://www.muppetlabs.com/~breadbox/software/assembly.html
+- add support for Delphi 3 in contrib/delphi (Bob Dellaca)
+- add support for C++Builder 3 and Delphi 3 in contrib/delphi2 (Davide Moretti)
+- do not exit prematurely in untgz if 0 at start of block (Magnus Holmgren)
+- use macro EXTERN instead of extern to support DLL for BeOS (Sander Stoks)
+- added a FAQ file
+
+- Support gzdopen on Mac with Metrowerks (Jason Linhart)
+- Do not redefine Byte on Mac (Brad Pettit & Jason Linhart)
+- define SEEK_END too if SEEK_SET is not defined (Albert Chin-A-Young)
+- avoid some warnings with Borland C (Tom Tanner)
+- fix a problem in contrib/minizip/zip.c for 16-bit MSDOS (Gilles Vollant)
+- emulate utime() for WIN32 in contrib/untgz  (Gilles Vollant)
+- allow several arguments to configure (Tim Mooney, Frodo Looijaard)
+- use libdir and includedir in Makefile.in (Tim Mooney)
+- support shared libraries on OSF1 V4 (Tim Mooney)
+- remove so_locations in "make clean"  (Tim Mooney)
+- fix maketree.c compilation error (Glenn, Mark)
+- Python interface to zlib now in Python 1.5 (Jeremy Hylton)
+- new Makefile.riscos (Rich Walker)
+- initialize static descriptors in trees.c for embedded targets (Nick Smith)
+- use "foo-gz" in example.c for RISCOS and VMS (Nick Smith)
+- add the OS/2 files in Makefile.in too (Andrew Zabolotny)
+- fix fdopen and halloc macros for Microsoft C 6.0 (Tom Lane)
+- fix maketree.c to allow clean compilation of inffixed.h (Mark)
+- fix parameter check in deflateCopy (Gunther Nikl)
+- cleanup trees.c, use compressed_len only in debug mode (Christian Spieler)
+- Many portability patches by Christian Spieler:
+  . zutil.c, zutil.h: added "const" for zmem*
+  . Make_vms.com: fixed some typos
+  . Make_vms.com: msdos/Makefile.*: removed zutil.h from some dependency lists
+  . msdos/Makefile.msc: remove "default rtl link library" info from obj files
+  . msdos/Makefile.*: use model-dependent name for the built zlib library
+  . msdos/Makefile.emx, nt/Makefile.emx, nt/Makefile.gcc:
+     new makefiles, for emx (DOS/OS2), emx&rsxnt and mingw32 (Windows 9x / NT)
+- use define instead of typedef for Bytef also for MSC small/medium (Tom Lane)
+- replace __far with _far for better portability (Christian Spieler, Tom Lane)
+- fix test for errno.h in configure (Tim Newsham)
+
 Changes in 1.1.2 (19 March 98)
 - added contrib/minzip, mini zip and unzip based on zlib (Gilles Vollant)
   See http://www.winimage.com/zLibDll/unzip.html

zlib/Makefile

@@ -1,5 +1,5 @@
 # Makefile for zlib
-# Copyright (C) 1995-1998 Jean-loup Gailly.
+# Copyright (C) 1995-2002 Jean-loup Gailly.
 # For conditions of distribution and use, see copyright notice in zlib.h 
 
 # To compile and test, type:
@@ -22,8 +22,9 @@ CFLAGS=-O
 
 LDFLAGS=-L. -lz
 LDSHARED=$(CC)
+CPP=$(CC) -E
 
-VER=1.1.2
+VER=1.1.4
 LIBS=libz.a
 SHAREDLIB=libz.so
 
@@ -34,21 +35,28 @@ SHELL=/bin/sh
 
 prefix = /usr/local
 exec_prefix = ${prefix}
+libdir = ${exec_prefix}/lib
+includedir = ${prefix}/include
 
 OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \
        zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o inffast.o
 
+OBJA =
+# to use the asm code: make OBJA=match.o
+
 TEST_OBJS = example.o minigzip.o
 
-DISTFILES = README INDEX ChangeLog configure Make*[a-z0-9] *.[ch] descrip.mms \
-  algorithm.txt zlib.3 msdos/Make*[a-z0-9] msdos/zlib.def msdos/zlib.rc \
-  nt/Makefile.nt nt/zlib.dnt amiga/Make*.??? contrib/README.contrib \
-  contrib/*.txt contrib/asm386/*.asm contrib/asm386/*.c \
-  contrib/asm386/*.bat contrib/asm386/zlibvc.d?? contrib/iostream/*.cpp \
+DISTFILES = README FAQ INDEX ChangeLog configure Make*[a-z0-9] *.[ch] *.mms \
+  algorithm.txt zlib.3 zlib.html \
+  msdos/Make*[a-z0-9] msdos/zlib.def msdos/zlib.rc \
+  nt/Make*[a-z0-9] nt/zlib.dnt amiga/Make*.??? os2/M*.os2 os2/zlib.def \
+  contrib/RE*.contrib contrib/*.txt contrib/asm386/*.asm contrib/asm386/*.c \
+  contrib/asm386/*.bat contrib/asm386/zlibvc.d?? contrib/asm[56]86/*.?86 \
+  contrib/asm[56]86/*.S contrib/iostream/*.cpp \
   contrib/iostream/*.h  contrib/iostream2/*.h contrib/iostream2/*.cpp \
   contrib/untgz/Makefile contrib/untgz/*.c contrib/untgz/*.w32 \
-  contrib/minizip/[CM]*[pe] contrib/minizip/*.[ch] contrib/minizip/*.[td]??
-
+  contrib/minizip/[CM]*[pe] contrib/minizip/*.[ch] contrib/minizip/*.[td]?? \
+  contrib/delphi*/*.???
 
 all: example minigzip
 
@@ -62,10 +70,16 @@ test: all
 	  echo '		*** zlib test FAILED ***'; \
 	fi
 
-libz.a: $(OBJS)
-	$(AR) $@ $(OBJS)
+libz.a: $(OBJS) $(OBJA)
+	$(AR) $@ $(OBJS) $(OBJA)
 	-@ ($(RANLIB) $@ || true) >/dev/null 2>&1
 
+match.o: match.S
+	$(CPP) match.S > _match.s
+	$(CC) -c _match.s
+	mv _match.o match.o
+	rm -f _match.s
+
 $(SHAREDLIB).$(VER): $(OBJS)
 	$(LDSHARED) -o $@ $(OBJS)
 	rm -f $(SHAREDLIB) $(SHAREDLIB).1
@@ -79,14 +93,14 @@ minigzip: minigzip.o $(LIBS)
 	$(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS)
 
 install: $(LIBS)
-	-@if [ ! -d $(prefix)/include  ]; then mkdir $(prefix)/include; fi
-	-@if [ ! -d $(exec_prefix)/lib ]; then mkdir $(exec_prefix)/lib; fi
-	cp zlib.h zconf.h $(prefix)/include
-	chmod 644 $(prefix)/include/zlib.h $(prefix)/include/zconf.h
-	cp $(LIBS) $(exec_prefix)/lib
-	cd $(exec_prefix)/lib; chmod 755 $(LIBS)
-	-@(cd $(exec_prefix)/lib; $(RANLIB) libz.a || true) >/dev/null 2>&1
-	cd $(exec_prefix)/lib; if test -f $(SHAREDLIB).$(VER); then \
+	-@if [ ! -d $(includedir)  ]; then mkdir $(includedir); fi
+	-@if [ ! -d $(libdir) ]; then mkdir $(libdir); fi
+	cp zlib.h zconf.h $(includedir)
+	chmod 644 $(includedir)/zlib.h $(includedir)/zconf.h
+	cp $(LIBS) $(libdir)
+	cd $(libdir); chmod 755 $(LIBS)
+	-@(cd $(libdir); $(RANLIB) libz.a || true) >/dev/null 2>&1
+	cd $(libdir); if test -f $(SHAREDLIB).$(VER); then \
 	  rm -f $(SHAREDLIB) $(SHAREDLIB).1; \
 	  ln -s $(SHAREDLIB).$(VER) $(SHAREDLIB); \
 	  ln -s $(SHAREDLIB).$(VER) $(SHAREDLIB).1; \
@@ -96,19 +110,20 @@ install: $(LIBS)
 # ldconfig is for Linux
 
 uninstall:
-	cd $(prefix)/include; \
+	cd $(includedir); \
 	v=$(VER); \
 	if test -f zlib.h; then \
 	  v=`sed -n '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`; \
           rm -f zlib.h zconf.h; \
 	fi; \
-	cd $(exec_prefix)/lib; rm -f libz.a; \
+	cd $(libdir); rm -f libz.a; \
 	if test -f $(SHAREDLIB).$$v; then \
 	  rm -f $(SHAREDLIB).$$v $(SHAREDLIB) $(SHAREDLIB).1; \
 	fi
 
 clean:
-	rm -f *.o *~ example minigzip libz.a libz.so* foo.gz
+	rm -f *.o *~ example minigzip libz.a libz.so* foo.gz so_locations \
+	   _match.s maketree
 
 distclean:	clean
 

zlib/README

@@ -1,7 +1,7 @@
-zlib 1.1.2 is a general purpose data compression library.  All the code
+zlib 1.1.4 is a general purpose data compression library.  All the code
 is thread safe.  The data format used by the zlib library
 is described by RFCs (Request for Comments) 1950 to 1952 in the files 
-ftp://ds.internic.net/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate
+http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate
 format) and rfc1952.txt (gzip format). These documents are also available in
 other formats from ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html
 
@@ -14,49 +14,54 @@ except example.c and minigzip.c.
 
 To compile all files and run the test program, follow the instructions
 given at the top of Makefile. In short "make test; make install"
-should work for most machines.  For MSDOS, use one of the special
-makefiles such as Makefile.msc; for VMS, use Make_vms.com or descrip.mms.
+should work for most machines. For Unix: "./configure; make test; make install"
+For MSDOS, use one of the special makefiles such as Makefile.msc.
+For VMS, use Make_vms.com or descrip.mms.
 
-Questions about zlib should be sent to <zlib@quest.jpl.nasa.gov> or,
-if this fails, to the addresses given below in the Copyright section.
-The zlib home page is http://www.cdrom.com/pub/infozip/zlib/
-The official zlib ftp site is ftp://ftp.cdrom.com/pub/infozip/zlib/
-Mark Nelson <markn@tiny.com> wrote an article about zlib for the Jan. 1997
+Questions about zlib should be sent to <zlib@gzip.org>, or to
+Gilles Vollant <info@winimage.com> for the Windows DLL version.
+The zlib home page is http://www.zlib.org or http://www.gzip.org/zlib/
+Before reporting a problem, please check this site to verify that
+you have the latest version of zlib; otherwise get the latest version and
+check whether the problem still exists or not.
+
+PLEASE read the zlib FAQ http://www.gzip.org/zlib/zlib_faq.html
+before asking for help.
+
+Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan. 1997
 issue of  Dr. Dobb's Journal; a copy of the article is available in
-http://web2.airmail.net/markn/articles/zlibtool/zlibtool.htm
+http://dogma.net/markn/articles/zlibtool/zlibtool.htm
 
-The changes made in version 1.1.2 are documented in the file ChangeLog.
-The main changes since 1.1.1 are:
+The changes made in version 1.1.4 are documented in the file ChangeLog.
+The only changes made since 1.1.3 are bug corrections:
 
-- added contrib/minzip, mini zip and unzip based on zlib (Gilles Vollant)
-  See http://www.winimage.com/zLibDll/unzip.html
-- preinitialize the inflate tables for fixed codes, to make the code
-  completely thread safe (Mark)
-- some simplifications and slight speed-up to the inflate code (Mark)
-- fix gzeof on non-compressed files (Allan Schrum)
-- add -std1 option in configure for OSF1 to fix gzprintf (Martin Mokrejs)
-- use default value of 4K for Z_BUFSIZE for 16-bit MSDOS (Tim Wegner + Glenn)
-- added os2/Makefile.def and os2/zlib.def (Andrew Zabolotny)
-- add shared lib support for UNIX_SV4.2MP (MATSUURA Takanori)
-- do not wrap extern "C" around system includes (Tom Lane)
-- added amiga/Makefile.pup for Amiga powerUP SAS/C PPC (Andreas Kleinert)
-- allow "make install prefix=..." even after configure (Glenn Randers-Pehrson)
-- allow "configure --prefix $HOME" (Tim Mooney)
+- ZFREE was repeated on same allocation on some error conditions.
+  This creates a security problem described in
+  http://www.zlib.org/advisory-2002-03-11.txt
+- Returned incorrect error (Z_MEM_ERROR) on some invalid data
+- Avoid accesses before window for invalid distances with inflate window
+  less than 32K.
+- force windowBits > 8 to avoid a bug in the encoder for a window size
+  of 256 bytes. (A complete fix will be available in 1.1.5).
+
+The beta version 1.1.5beta includes many more changes. A new official
+version 1.1.5 will be released as soon as extensive testing has been
+completed on it.
 
 
 Unsupported third party contributions are provided in directory "contrib".
 
-A Java implementation of zlib is available in the Java Development Kit 1.1
+A Java implementation of zlib is available in the Java Development Kit
 http://www.javasoft.com/products/JDK/1.1/docs/api/Package-java.util.zip.html
-See the zlib home page http://www.cdrom.com/pub/infozip/zlib/ for details.
+See the zlib home page http://www.zlib.org for details.
 
 A Perl interface to zlib written by Paul Marquess <pmarquess@bfsec.bt.co.uk>
-is in the CPAN (Comprehensive Perl Archive Network) sites, such as:
-ftp://ftp.cis.ufl.edu/pub/perl/CPAN/modules/by-module/Compress/Compress-Zlib*
+is in the CPAN (Comprehensive Perl Archive Network) sites
+http://www.cpan.org/modules/by-module/Compress/
 
 A Python interface to zlib written by A.M. Kuchling <amk@magnet.com>
-is available from the Python Software Association sites, such as:
-ftp://ftp.python.org/pub/python/contrib/Encoding/zlib*.tar.gz
+is available in Python 1.5 and later versions, see
+http://www.python.org/doc/lib/module-zlib.html
 
 A zlib binding for TCL written by Andreas Kupries <a.kupries@westend.com>
 is availlable at http://www.westend.com/~kupries/doc/trf/man/man.html
@@ -77,8 +82,8 @@ Notes for some targets:
 
   From Visual Basic, you can call the DLL functions which do not take
   a structure as argument: compress, uncompress and all gz* functions.
-  See contrib/visual-basic.txt for more information.
-  I don't know how to handle structures in Visual Basic, sorry.
+  See contrib/visual-basic.txt for more information, or get
+  http://www.tcfb.com/dowseware/cmp-z-it.zip
 
 - For 64-bit Irix, deflate.c must be compiled without any optimization.
   With -O, one libpng test fails. The test works in 32 bit mode (with
@@ -93,15 +98,14 @@ Notes for some targets:
 - zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works
   with other compilers. Use "make test" to check your compiler.
 
-- For shared memory multiprocessors, the decompression code assumes that
-  writes to pointers are atomic. Also the functions zalloc and zfree passed
-  to deflateInit must be multi-threaded in this case.
-
 - gzdopen is not supported on RISCOS, BEOS and by some Mac compilers.
 
 - For Turbo C the small model is supported only with reduced performance to
   avoid any far allocation; it was tested with -DMAX_WBITS=11 -DMAX_MEM_LEVEL=3
 
+- For PalmOs, see http://www.cs.uit.no/~perm/PASTA/pilot/software.html
+  Per Harald Myrvang <perm@stud.cs.uit.no>
+
 
 Acknowledgments:
 
@@ -112,7 +116,7 @@ Acknowledgments:
 
 Copyright notice:
 
- (C) 1995-1998 Jean-loup Gailly and Mark Adler
+ (C) 1995-2002 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

zlib/adler32.c

@@ -1,5 +1,5 @@
 /* adler32.c -- compute the Adler-32 checksum of a data stream
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 

zlib/crc32.c

@@ -1,5 +1,5 @@
 /* crc32.c -- compute the CRC-32 of a data stream
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 

zlib/deflate.c

@@ -1,5 +1,5 @@
 /* deflate.c -- compress data using the deflation algorithm
- * Copyright (C) 1995-1998 Jean-loup Gailly.
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
@@ -52,7 +52,7 @@
 #include "deflate.h"
 
 const char deflate_copyright[] =
-   " deflate 1.1.2 Copyright 1995-1998 Jean-loup Gailly ";
+   " deflate 1.1.4 Copyright 1995-2002 Jean-loup Gailly ";
 /*
   If you use the zlib library in a product, an acknowledgment is welcome
   in the documentation of your product. If for some reason you cannot
@@ -242,7 +242,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
         windowBits = -windowBits;
     }
     if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
-        windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
+        windowBits < 9 || windowBits > 15 || level < 0 || level > 9 ||
 	strategy < 0 || strategy > Z_HUFFMAN_ONLY) {
         return Z_STREAM_ERROR;
     }
@@ -608,11 +608,13 @@ int ZEXPORT deflateCopy (dest, source)
     deflate_state *ss;
     ushf *overlay;
 
-    ss = source->state;
 
-    if (source == Z_NULL || dest == Z_NULL || ss == Z_NULL) {
+    if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
         return Z_STREAM_ERROR;
     }
+
+    ss = source->state;
+
     *dest = *source;
 
     ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));

zlib/deflate.h

@@ -1,5 +1,5 @@
 /* deflate.h -- internal compression state
- * Copyright (C) 1995-1998 Jean-loup Gailly
+ * Copyright (C) 1995-2002 Jean-loup Gailly
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
@@ -230,12 +230,12 @@ typedef struct internal_state {
 
     ulg opt_len;        /* bit length of current block with optimal trees */
     ulg static_len;     /* bit length of current block with static trees */
-    ulg compressed_len; /* total bit length of compressed file */
     uInt matches;       /* number of string matches in current block */
     int last_eob_len;   /* bit length of EOB code for last block */
 
 #ifdef DEBUG
-    ulg bits_sent;      /* bit length of the compressed data */
+    ulg compressed_len; /* total bit length of compressed file mod 2^32 */
+    ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
 #endif
 
     ush bi_buf;
@@ -268,7 +268,7 @@ typedef struct internal_state {
         /* in trees.c */
 void _tr_init         OF((deflate_state *s));
 int  _tr_tally        OF((deflate_state *s, unsigned dist, unsigned lc));
-ulg  _tr_flush_block  OF((deflate_state *s, charf *buf, ulg stored_len,
+void _tr_flush_block  OF((deflate_state *s, charf *buf, ulg stored_len,
 			  int eof));
 void _tr_align        OF((deflate_state *s));
 void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,

zlib/infblock.c

@@ -249,10 +249,12 @@ int r;
                              &s->sub.trees.tb, s->hufts, z);
       if (t != Z_OK)
       {
-        ZFREE(z, s->sub.trees.blens);
         r = t;
         if (r == Z_DATA_ERROR)
-          s->mode = zBAD;
+	  {
+	    ZFREE(z, s->sub.trees.blens);
+	    s->mode = zBAD;
+	  }
         LEAVE
       }
       s->sub.trees.index = 0;
@@ -313,14 +315,17 @@ int r;
         t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
                                   s->sub.trees.blens, &bl, &bd, &tl, &td,
                                   s->hufts, z);
-        ZFREE(z, s->sub.trees.blens);
         if (t != Z_OK)
         {
           if (t == (uInt)Z_DATA_ERROR)
-            s->mode = zBAD;
+	    {
+	      ZFREE(z, s->sub.trees.blens);
+	      s->mode = zBAD;
+	    }
           r = t;
           LEAVE
         }
+	ZFREE(z, s->sub.trees.blens);
         Tracev((stderr, "inflate:       trees ok\n"));
         if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
         {
@@ -345,13 +350,6 @@ int r;
         s->mode = TYPE;
         break;
       }
-      if (k > 7)              /* return unused byte, if any */
-      {
-        Assert(k < 16, "inflate_codes grabbed too many bytes")
-        k -= 8;
-        n++;
-        p--;                    /* can always return one */
-      }
       s->mode = DRY;
     case DRY:
       FLUSH

zlib/infblock.h

@@ -1,5 +1,5 @@
 /* infblock.h -- header to use infblock.c
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 

zlib/infcodes.c

@@ -1,5 +1,5 @@
 /* infcodes.c -- process literals and length/distance pairs
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
@@ -196,15 +196,9 @@ int r;
       Tracevv((stderr, "inflate:         distance %u\n", c->sub.copy.dist));
       c->mode = COPY;
     case COPY:          /* o: copying bytes in window, waiting for space */
-#ifndef __TURBOC__ /* Turbo C bug for following expression */
-      f = (uInt)(q - s->window) < c->sub.copy.dist ?
-          s->end - (c->sub.copy.dist - (q - s->window)) :
-          q - c->sub.copy.dist;
-#else
       f = q - c->sub.copy.dist;
-      if ((uInt)(q - s->window) < c->sub.copy.dist)
-        f = s->end - (c->sub.copy.dist - (uInt)(q - s->window));
-#endif
+      while (f < s->window)             /* modulo window size-"while" instead */
+        f += s->end - s->window;        /* of "if" handles invalid distances */
       while (c->len)
       {
         NEEDOUT
@@ -221,6 +215,13 @@ int r;
       c->mode = START;
       break;
     case WASH:          /* o: got eob, possibly more output */
+      if (k > 7)        /* return unused byte, if any */
+      {
+        Assert(k < 16, "inflate_codes grabbed too many bytes")
+        k -= 8;
+        n++;
+        p--;            /* can always return one */
+      }
       FLUSH
       if (s->read != s->write)
         LEAVE

zlib/infcodes.h

@@ -1,5 +1,5 @@
 /* infcodes.h -- header to use infcodes.c
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 

zlib/inffast.c

@@ -1,5 +1,5 @@
 /* inffast.c -- process literals and length/distance pairs fast
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
@@ -93,28 +93,41 @@ z_streamp z;
 
             /* do the copy */
             m -= c;
-            if ((uInt)(q - s->window) >= d)     /* offset before dest */
-            {                                   /*  just copy */
-              r = q - d;
-              *q++ = *r++;  c--;        /* minimum count is three, */
-              *q++ = *r++;  c--;        /*  so unroll loop a little */
-            }
-            else                        /* else offset after destination */
+            r = q - d;
+            if (r < s->window)                  /* wrap if needed */
             {
-              e = d - (uInt)(q - s->window); /* bytes from offset to end */
-              r = s->end - e;           /* pointer to offset */
-              if (c > e)                /* if source crosses, */
+              do {
+                r += s->end - s->window;        /* force pointer in window */
+              } while (r < s->window);          /* covers invalid distances */
+              e = s->end - r;
+              if (c > e)
               {
-                c -= e;                 /* copy to end of window */
+                c -= e;                         /* wrapped copy */
                 do {
-                  *q++ = *r++;
+                    *q++ = *r++;
                 } while (--e);
-                r = s->window;          /* copy rest from start of window */
+                r = s->window;
+                do {
+                    *q++ = *r++;
+                } while (--c);
+              }
+              else                              /* normal copy */
+              {
+                *q++ = *r++;  c--;
+                *q++ = *r++;  c--;
+                do {
+                    *q++ = *r++;
+                } while (--c);
               }
             }
-            do {                        /* copy all or what's left */
-              *q++ = *r++;
-            } while (--c);
+            else                                /* normal copy */
+            {
+              *q++ = *r++;  c--;
+              *q++ = *r++;  c--;
+              do {
+                *q++ = *r++;
+              } while (--c);
+            }
             break;
           }
           else if ((e & 64) == 0)

zlib/inffast.h

@@ -1,5 +1,5 @@
 /* inffast.h -- header to use inffast.c
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 

zlib/inffixed.h

@@ -10,116 +10,142 @@
 local uInt fixed_bl = 9;
 local uInt fixed_bd = 5;
 local inflate_huft fixed_tl[] = {
-    {{96,7},256}, {{0,8},80}, {{0,8},16}, {{84,8},115}, {{82,7},31},
-    {{0,8},112}, {{0,8},48}, {{0,9},192}, {{80,7},10}, {{0,8},96},
-    {{0,8},32}, {{0,9},160}, {{0,8},0}, {{0,8},128}, {{0,8},64},
-    {{0,9},224}, {{80,7},6}, {{0,8},88}, {{0,8},24}, {{0,9},144},
-    {{83,7},59}, {{0,8},120}, {{0,8},56}, {{0,9},208}, {{81,7},17},
-    {{0,8},104}, {{0,8},40}, {{0,9},176}, {{0,8},8}, {{0,8},136},
-    {{0,8},72}, {{0,9},240}, {{80,7},4}, {{0,8},84}, {{0,8},20},
-    {{85,8},227}, {{83,7},43}, {{0,8},116}, {{0,8},52}, {{0,9},200},
-    {{81,7},13}, {{0,8},100}, {{0,8},36}, {{0,9},168}, {{0,8},4},
-    {{0,8},132}, {{0,8},68}, {{0,9},232}, {{80,7},8}, {{0,8},92},
-    {{0,8},28}, {{0,9},152}, {{84,7},83}, {{0,8},124}, {{0,8},60},
-    {{0,9},216}, {{82,7},23}, {{0,8},108}, {{0,8},44}, {{0,9},184},
-    {{0,8},12}, {{0,8},140}, {{0,8},76}, {{0,9},248}, {{80,7},3},
-    {{0,8},82}, {{0,8},18}, {{85,8},163}, {{83,7},35}, {{0,8},114},
-    {{0,8},50}, {{0,9},196}, {{81,7},11}, {{0,8},98}, {{0,8},34},
-    {{0,9},164}, {{0,8},2}, {{0,8},130}, {{0,8},66}, {{0,9},228},
-    {{80,7},7}, {{0,8},90}, {{0,8},26}, {{0,9},148}, {{84,7},67},
-    {{0,8},122}, {{0,8},58}, {{0,9},212}, {{82,7},19}, {{0,8},106},
-    {{0,8},42}, {{0,9},180}, {{0,8},10}, {{0,8},138}, {{0,8},74},
-    {{0,9},244}, {{80,7},5}, {{0,8},86}, {{0,8},22}, {{192,8},0},
-    {{83,7},51}, {{0,8},118}, {{0,8},54}, {{0,9},204}, {{81,7},15},
-    {{0,8},102}, {{0,8},38}, {{0,9},172}, {{0,8},6}, {{0,8},134},
-    {{0,8},70}, {{0,9},236}, {{80,7},9}, {{0,8},94}, {{0,8},30},
-    {{0,9},156}, {{84,7},99}, {{0,8},126}, {{0,8},62}, {{0,9},220},
-    {{82,7},27}, {{0,8},110}, {{0,8},46}, {{0,9},188}, {{0,8},14},
-    {{0,8},142}, {{0,8},78}, {{0,9},252}, {{96,7},256}, {{0,8},81},
-    {{0,8},17}, {{85,8},131}, {{82,7},31}, {{0,8},113}, {{0,8},49},
-    {{0,9},194}, {{80,7},10}, {{0,8},97}, {{0,8},33}, {{0,9},162},
-    {{0,8},1}, {{0,8},129}, {{0,8},65}, {{0,9},226}, {{80,7},6},
-    {{0,8},89}, {{0,8},25}, {{0,9},146}, {{83,7},59}, {{0,8},121},
-    {{0,8},57}, {{0,9},210}, {{81,7},17}, {{0,8},105}, {{0,8},41},
-    {{0,9},178}, {{0,8},9}, {{0,8},137}, {{0,8},73}, {{0,9},242},
-    {{80,7},4}, {{0,8},85}, {{0,8},21}, {{80,8},258}, {{83,7},43},
-    {{0,8},117}, {{0,8},53}, {{0,9},202}, {{81,7},13}, {{0,8},101},
-    {{0,8},37}, {{0,9},170}, {{0,8},5}, {{0,8},133}, {{0,8},69},
-    {{0,9},234}, {{80,7},8}, {{0,8},93}, {{0,8},29}, {{0,9},154},
-    {{84,7},83}, {{0,8},125}, {{0,8},61}, {{0,9},218}, {{82,7},23},
-    {{0,8},109}, {{0,8},45}, {{0,9},186}, {{0,8},13}, {{0,8},141},
-    {{0,8},77}, {{0,9},250}, {{80,7},3}, {{0,8},83}, {{0,8},19},
-    {{85,8},195}, {{83,7},35}, {{0,8},115}, {{0,8},51}, {{0,9},198},
-    {{81,7},11}, {{0,8},99}, {{0,8},35}, {{0,9},166}, {{0,8},3},
-    {{0,8},131}, {{0,8},67}, {{0,9},230}, {{80,7},7}, {{0,8},91},
-    {{0,8},27}, {{0,9},150}, {{84,7},67}, {{0,8},123}, {{0,8},59},
-    {{0,9},214}, {{82,7},19}, {{0,8},107}, {{0,8},43}, {{0,9},182},
-    {{0,8},11}, {{0,8},139}, {{0,8},75}, {{0,9},246}, {{80,7},5},
-    {{0,8},87}, {{0,8},23}, {{192,8},0}, {{83,7},51}, {{0,8},119},
-    {{0,8},55}, {{0,9},206}, {{81,7},15}, {{0,8},103}, {{0,8},39},
-    {{0,9},174}, {{0,8},7}, {{0,8},135}, {{0,8},71}, {{0,9},238},
-    {{80,7},9}, {{0,8},95}, {{0,8},31}, {{0,9},158}, {{84,7},99},
-    {{0,8},127}, {{0,8},63}, {{0,9},222}, {{82,7},27}, {{0,8},111},
-    {{0,8},47}, {{0,9},190}, {{0,8},15}, {{0,8},143}, {{0,8},79},
-    {{0,9},254}, {{96,7},256}, {{0,8},80}, {{0,8},16}, {{84,8},115},
-    {{82,7},31}, {{0,8},112}, {{0,8},48}, {{0,9},193}, {{80,7},10},
-    {{0,8},96}, {{0,8},32}, {{0,9},161}, {{0,8},0}, {{0,8},128},
-    {{0,8},64}, {{0,9},225}, {{80,7},6}, {{0,8},88}, {{0,8},24},
-    {{0,9},145}, {{83,7},59}, {{0,8},120}, {{0,8},56}, {{0,9},209},
-    {{81,7},17}, {{0,8},104}, {{0,8},40}, {{0,9},177}, {{0,8},8},
-    {{0,8},136}, {{0,8},72}, {{0,9},241}, {{80,7},4}, {{0,8},84},
-    {{0,8},20}, {{85,8},227}, {{83,7},43}, {{0,8},116}, {{0,8},52},
-    {{0,9},201}, {{81,7},13}, {{0,8},100}, {{0,8},36}, {{0,9},169},
-    {{0,8},4}, {{0,8},132}, {{0,8},68}, {{0,9},233}, {{80,7},8},
-    {{0,8},92}, {{0,8},28}, {{0,9},153}, {{84,7},83}, {{0,8},124},
-    {{0,8},60}, {{0,9},217}, {{82,7},23}, {{0,8},108}, {{0,8},44},
-    {{0,9},185}, {{0,8},12}, {{0,8},140}, {{0,8},76}, {{0,9},249},
-    {{80,7},3}, {{0,8},82}, {{0,8},18}, {{85,8},163}, {{83,7},35},
-    {{0,8},114}, {{0,8},50}, {{0,9},197}, {{81,7},11}, {{0,8},98},
-    {{0,8},34}, {{0,9},165}, {{0,8},2}, {{0,8},130}, {{0,8},66},
-    {{0,9},229}, {{80,7},7}, {{0,8},90}, {{0,8},26}, {{0,9},149},
-    {{84,7},67}, {{0,8},122}, {{0,8},58}, {{0,9},213}, {{82,7},19},
-    {{0,8},106}, {{0,8},42}, {{0,9},181}, {{0,8},10}, {{0,8},138},
-    {{0,8},74}, {{0,9},245}, {{80,7},5}, {{0,8},86}, {{0,8},22},
-    {{192,8},0}, {{83,7},51}, {{0,8},118}, {{0,8},54}, {{0,9},205},
-    {{81,7},15}, {{0,8},102}, {{0,8},38}, {{0,9},173}, {{0,8},6},
-    {{0,8},134}, {{0,8},70}, {{0,9},237}, {{80,7},9}, {{0,8},94},
-    {{0,8},30}, {{0,9},157}, {{84,7},99}, {{0,8},126}, {{0,8},62},
-    {{0,9},221}, {{82,7},27}, {{0,8},110}, {{0,8},46}, {{0,9},189},
-    {{0,8},14}, {{0,8},142}, {{0,8},78}, {{0,9},253}, {{96,7},256},
-    {{0,8},81}, {{0,8},17}, {{85,8},131}, {{82,7},31}, {{0,8},113},
-    {{0,8},49}, {{0,9},195}, {{80,7},10}, {{0,8},97}, {{0,8},33},
-    {{0,9},163}, {{0,8},1}, {{0,8},129}, {{0,8},65}, {{0,9},227},
-    {{80,7},6}, {{0,8},89}, {{0,8},25}, {{0,9},147}, {{83,7},59},
-    {{0,8},121}, {{0,8},57}, {{0,9},211}, {{81,7},17}, {{0,8},105},
-    {{0,8},41}, {{0,9},179}, {{0,8},9}, {{0,8},137}, {{0,8},73},
-    {{0,9},243}, {{80,7},4}, {{0,8},85}, {{0,8},21}, {{80,8},258},
-    {{83,7},43}, {{0,8},117}, {{0,8},53}, {{0,9},203}, {{81,7},13},
-    {{0,8},101}, {{0,8},37}, {{0,9},171}, {{0,8},5}, {{0,8},133},
-    {{0,8},69}, {{0,9},235}, {{80,7},8}, {{0,8},93}, {{0,8},29},
-    {{0,9},155}, {{84,7},83}, {{0,8},125}, {{0,8},61}, {{0,9},219},
-    {{82,7},23}, {{0,8},109}, {{0,8},45}, {{0,9},187}, {{0,8},13},
-    {{0,8},141}, {{0,8},77}, {{0,9},251}, {{80,7},3}, {{0,8},83},
-    {{0,8},19}, {{85,8},195}, {{83,7},35}, {{0,8},115}, {{0,8},51},
-    {{0,9},199}, {{81,7},11}, {{0,8},99}, {{0,8},35}, {{0,9},167},
-    {{0,8},3}, {{0,8},131}, {{0,8},67}, {{0,9},231}, {{80,7},7},
-    {{0,8},91}, {{0,8},27}, {{0,9},151}, {{84,7},67}, {{0,8},123},
-    {{0,8},59}, {{0,9},215}, {{82,7},19}, {{0,8},107}, {{0,8},43},
-    {{0,9},183}, {{0,8},11}, {{0,8},139}, {{0,8},75}, {{0,9},247},
-    {{80,7},5}, {{0,8},87}, {{0,8},23}, {{192,8},0}, {{83,7},51},
-    {{0,8},119}, {{0,8},55}, {{0,9},207}, {{81,7},15}, {{0,8},103},
-    {{0,8},39}, {{0,9},175}, {{0,8},7}, {{0,8},135}, {{0,8},71},
-    {{0,9},239}, {{80,7},9}, {{0,8},95}, {{0,8},31}, {{0,9},159},
-    {{84,7},99}, {{0,8},127}, {{0,8},63}, {{0,9},223}, {{82,7},27},
-    {{0,8},111}, {{0,8},47}, {{0,9},191}, {{0,8},15}, {{0,8},143},
-    {{0,8},79}, {{0,9},255}
+    {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},
+    {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},192},
+    {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},160},
+    {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},224},
+    {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},144},
+    {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},208},
+    {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},176},
+    {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},240},
+    {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},
+    {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},200},
+    {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},168},
+    {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},232},
+    {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},152},
+    {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},216},
+    {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},184},
+    {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},248},
+    {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},
+    {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},196},
+    {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},164},
+    {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},228},
+    {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},148},
+    {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},212},
+    {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},180},
+    {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},244},
+    {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},204},
+    {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},172},
+    {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},236},
+    {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},156},
+    {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},220},
+    {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},188},
+    {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},252},
+    {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},
+    {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},194},
+    {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},162},
+    {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},226},
+    {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},146},
+    {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},210},
+    {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},178},
+    {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},242},
+    {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},
+    {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},202},
+    {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},170},
+    {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},234},
+    {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},154},
+    {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},218},
+    {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},186},
+    {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},250},
+    {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},
+    {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},198},
+    {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},166},
+    {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},230},
+    {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},150},
+    {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},214},
+    {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},182},
+    {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},246},
+    {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},206},
+    {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},174},
+    {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},238},
+    {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},158},
+    {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},222},
+    {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},190},
+    {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},254},
+    {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},
+    {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},193},
+    {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},161},
+    {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},225},
+    {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},145},
+    {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},209},
+    {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},177},
+    {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},241},
+    {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},
+    {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},201},
+    {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},169},
+    {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},233},
+    {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},153},
+    {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},217},
+    {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},185},
+    {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},249},
+    {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},
+    {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},197},
+    {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},165},
+    {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},229},
+    {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},149},
+    {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},213},
+    {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},181},
+    {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},245},
+    {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},205},
+    {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},173},
+    {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},237},
+    {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},157},
+    {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},221},
+    {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},189},
+    {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},253},
+    {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},
+    {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},195},
+    {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},163},
+    {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},227},
+    {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},147},
+    {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},211},
+    {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},179},
+    {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},243},
+    {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},
+    {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},203},
+    {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},171},
+    {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},235},
+    {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},155},
+    {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},219},
+    {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},187},
+    {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},251},
+    {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},
+    {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},199},
+    {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},167},
+    {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},231},
+    {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},151},
+    {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},215},
+    {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},183},
+    {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},247},
+    {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},207},
+    {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},175},
+    {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},239},
+    {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},159},
+    {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},223},
+    {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},191},
+    {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},255}
   };
 local inflate_huft fixed_td[] = {
-    {{80,5},1}, {{87,5},257}, {{83,5},17}, {{91,5},4097}, {{81,5},5},
-    {{89,5},1025}, {{85,5},65}, {{93,5},16385}, {{80,5},3}, {{88,5},513},
-    {{84,5},33}, {{92,5},8193}, {{82,5},9}, {{90,5},2049}, {{86,5},129},
-    {{192,5},24577}, {{80,5},2}, {{87,5},385}, {{83,5},25}, {{91,5},6145},
-    {{81,5},7}, {{89,5},1537}, {{85,5},97}, {{93,5},24577}, {{80,5},4},
-    {{88,5},769}, {{84,5},49}, {{92,5},12289}, {{82,5},13}, {{90,5},3073},
-    {{86,5},193}, {{192,5},24577}
+    {{{80,5}},1}, {{{87,5}},257}, {{{83,5}},17}, {{{91,5}},4097},
+    {{{81,5}},5}, {{{89,5}},1025}, {{{85,5}},65}, {{{93,5}},16385},
+    {{{80,5}},3}, {{{88,5}},513}, {{{84,5}},33}, {{{92,5}},8193},
+    {{{82,5}},9}, {{{90,5}},2049}, {{{86,5}},129}, {{{192,5}},24577},
+    {{{80,5}},2}, {{{87,5}},385}, {{{83,5}},25}, {{{91,5}},6145},
+    {{{81,5}},7}, {{{89,5}},1537}, {{{85,5}},97}, {{{93,5}},24577},
+    {{{80,5}},4}, {{{88,5}},769}, {{{84,5}},49}, {{{92,5}},12289},
+    {{{82,5}},13}, {{{90,5}},3073}, {{{86,5}},193}, {{{192,5}},24577}
   };

zlib/inflate.c

@@ -1,5 +1,5 @@
 /* inflate.c -- zlib interface to inflate modules
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 

zlib/inftrees.c

@@ -1,5 +1,5 @@
 /* inftrees.c -- generate Huffman trees for efficient decoding
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
@@ -11,7 +11,7 @@
 #endif
 
 const char inflate_copyright[] =
-   " inflate 1.1.2 Copyright 1995-1998 Mark Adler ";
+   " inflate 1.1.4 Copyright 1995-2002 Mark Adler ";
 /*
   If you use the zlib library in a product, an acknowledgment is welcome
   in the documentation of your product. If for some reason you cannot
@@ -104,8 +104,7 @@ uIntf *v;               /* working area: values in order of bit length */
 /* Given a list of code lengths and a maximum table size, make a set of
    tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
    if the given code set is incomplete (the tables are still built in this
-   case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
-   lengths), or Z_MEM_ERROR if not enough memory. */
+   case), or Z_DATA_ERROR if the input is invalid. */
 {
 
   uInt a;                       /* counter for codes of length k */
@@ -231,7 +230,7 @@ uIntf *v;               /* working area: values in order of bit length */
 
         /* allocate new table */
         if (*hn + z > MANY)     /* (note: doesn't matter for fixed) */
-          return Z_MEM_ERROR;   /* not enough memory */
+          return Z_DATA_ERROR;  /* overflow of MANY */
         u[h] = q = hp + *hn;
         *hn += z;
 

zlib/inftrees.h

@@ -1,5 +1,5 @@
 /* inftrees.h -- header to use inftrees.c
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 

zlib/infutil.c

@@ -1,5 +1,5 @@
 /* inflate_util.c -- data and routines common to blocks and codes
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 

zlib/infutil.h

@@ -1,5 +1,5 @@
 /* infutil.h -- types and macros common to blocks and codes
- * Copyright (C) 1995-1998 Mark Adler
+ * Copyright (C) 1995-2002 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 

zlib/trees.c

@@ -1,5 +1,5 @@
 /* trees.c -- output deflated data using Huffman coding
- * Copyright (C) 1995-1998 Jean-loup Gailly
+ * Copyright (C) 1995-2002 Jean-loup Gailly
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
@@ -252,6 +252,13 @@ local void tr_static_init()
 
     if (static_init_done) return;
 
+    /* For some embedded targets, global variables are not initialized: */
+    static_l_desc.static_tree = static_ltree;
+    static_l_desc.extra_bits = extra_lbits;
+    static_d_desc.static_tree = static_dtree;
+    static_d_desc.extra_bits = extra_dbits;
+    static_bl_desc.extra_bits = extra_blbits;
+
     /* Initialize the mapping length (0..255) -> length code (0..28) */
     length = 0;
     for (code = 0; code < LENGTH_CODES-1; code++) {
@@ -380,8 +387,6 @@ void _tr_init(s)
 {
     tr_static_init();
 
-    s->compressed_len = 0L;
-
     s->l_desc.dyn_tree = s->dyn_ltree;
     s->l_desc.stat_desc = &static_l_desc;
 
@@ -395,6 +400,7 @@ void _tr_init(s)
     s->bi_valid = 0;
     s->last_eob_len = 8; /* enough lookahead for inflate */
 #ifdef DEBUG
+    s->compressed_len = 0L;
     s->bits_sent = 0L;
 #endif
 
@@ -867,9 +873,10 @@ void _tr_stored_block(s, buf, stored_len, eof)
     int eof;          /* true if this is the last block for a file */
 {
     send_bits(s, (STORED_BLOCK<<1)+eof, 3);  /* send block type */
+#ifdef DEBUG
     s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
     s->compressed_len += (stored_len + 4) << 3;
-
+#endif
     copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
 }
 
@@ -889,7 +896,9 @@ void _tr_align(s)
 {
     send_bits(s, STATIC_TREES<<1, 3);
     send_code(s, END_BLOCK, static_ltree);
+#ifdef DEBUG
     s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
+#endif
     bi_flush(s);
     /* Of the 10 bits for the empty block, we have already sent
      * (10 - bi_valid) bits. The lookahead for the last real code (before
@@ -899,7 +908,9 @@ void _tr_align(s)
     if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {
         send_bits(s, STATIC_TREES<<1, 3);
         send_code(s, END_BLOCK, static_ltree);
+#ifdef DEBUG
         s->compressed_len += 10L;
+#endif
         bi_flush(s);
     }
     s->last_eob_len = 7;
@@ -907,10 +918,9 @@ void _tr_align(s)
 
 /* ===========================================================================
  * Determine the best encoding for the current block: dynamic trees, static
- * trees or store, and output the encoded block to the zip file. This function
- * returns the total compressed length for the file so far.
+ * trees or store, and output the encoded block to the zip file.
  */
-ulg _tr_flush_block(s, buf, stored_len, eof)
+void _tr_flush_block(s, buf, stored_len, eof)
     deflate_state *s;
     charf *buf;       /* input block, or NULL if too old */
     ulg stored_len;   /* length of input block */
@@ -957,25 +967,6 @@ ulg _tr_flush_block(s, buf, stored_len, eof)
 	opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
     }
 
-    /* If compression failed and this is the first and last block,
-     * and if the .zip file can be seeked (to rewrite the local header),
-     * the whole file is transformed into a stored file:
-     */
-#ifdef STORED_FILE_OK
-#  ifdef FORCE_STORED_FILE
-    if (eof && s->compressed_len == 0L) { /* force stored file */
-#  else
-    if (stored_len <= opt_lenb && eof && s->compressed_len==0L && seekable()) {
-#  endif
-        /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */
-        if (buf == (charf*)0) error ("block vanished");
-
-        copy_block(buf, (unsigned)stored_len, 0); /* without header */
-        s->compressed_len = stored_len << 3;
-        s->method = STORED;
-    } else
-#endif /* STORED_FILE_OK */
-
 #ifdef FORCE_STORED
     if (buf != (char*)0) { /* force stored block */
 #else
@@ -997,25 +988,32 @@ ulg _tr_flush_block(s, buf, stored_len, eof)
 #endif
         send_bits(s, (STATIC_TREES<<1)+eof, 3);
         compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);
+#ifdef DEBUG
         s->compressed_len += 3 + s->static_len;
+#endif
     } else {
         send_bits(s, (DYN_TREES<<1)+eof, 3);
         send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
                        max_blindex+1);
         compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
+#ifdef DEBUG
         s->compressed_len += 3 + s->opt_len;
+#endif
     }
     Assert (s->compressed_len == s->bits_sent, "bad compressed size");
+    /* The above check is made mod 2^32, for files larger than 512 MB
+     * and uLong implemented on 32 bits.
+     */
     init_block(s);
 
     if (eof) {
         bi_windup(s);
+#ifdef DEBUG
         s->compressed_len += 7;  /* align on byte boundary */
+#endif
     }
     Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
            s->compressed_len-7*eof));
-
-    return s->compressed_len >> 3;
 }
 
 /* ===========================================================================

zlib/zconf.h

@@ -1,5 +1,5 @@
 /* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-1998 Jean-loup Gailly.
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
@@ -91,8 +91,8 @@
 #  define NO_DUMMY_DECL
 #endif
 
-/* Borland C incorrectly complains about missing returns: */
-#if defined(__BORLANDC__)
+/* Old Borland C incorrectly complains about missing returns: */
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500)
 #  define NEED_DUMMY_RETURN
 #endif
 
@@ -148,7 +148,7 @@
    /* MSC small or medium model */
 #  define SMALL_MEDIUM
 #  ifdef _MSC_VER
-#    define FAR __far
+#    define FAR _far
 #  else
 #    define FAR far
 #  endif
@@ -156,42 +156,68 @@
 #if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
 #  ifndef __32BIT__
 #    define SMALL_MEDIUM
-#    define FAR __far
+#    define FAR _far
 #  endif
 #endif
 
 /* Compile with -DZLIB_DLL for Windows DLL support */
-#if (defined(_WINDOWS) || defined(WINDOWS)) && defined(ZLIB_DLL)
-#  ifdef FAR
-#    undef FAR
+#if defined(ZLIB_DLL)
+#  if defined(_WINDOWS) || defined(WINDOWS)
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+#    define ZEXPORT  WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA  WINAPIV
+#    else
+#      define ZEXPORTVA  FAR _cdecl _export
+#    endif
 #  endif
-#  include <windows.h>
-#  define ZEXPORT  WINAPI
-#  ifdef WIN32
-#    define ZEXPORTVA  WINAPIV
+#  if defined (__BORLANDC__)
+#    if (__BORLANDC__ >= 0x0500) && defined (WIN32)
+#      include <windows.h>
+#      define ZEXPORT __declspec(dllexport) WINAPI
+#      define ZEXPORTRVA __declspec(dllexport) WINAPIV
+#    else
+#      if defined (_Windows) && defined (__DLL__)
+#        define ZEXPORT _export
+#        define ZEXPORTVA _export
+#      endif
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  if defined (ZLIB_DLL)
+#    define ZEXTERN extern __declspec(dllexport)
 #  else
-#    define ZEXPORTVA  FAR _cdecl _export
+#    define ZEXTERN extern __declspec(dllimport)
 #  endif
-#else
-#   if defined (__BORLANDC__) && defined (_Windows) && defined (__DLL__)
-#       define ZEXPORT _export
-#       define ZEXPORTVA _export
-#   else
-#       define ZEXPORT
-#       define ZEXPORTVA
-#   endif
+#endif
+
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+#ifndef ZEXTERN
+#  define ZEXTERN extern
 #endif
 
 #ifndef FAR
 #   define FAR
 #endif
 
+#if !defined(MACOS) && !defined(TARGET_OS_MAC)
 typedef unsigned char  Byte;  /* 8 bits */
+#endif
 typedef unsigned int   uInt;  /* 16 bits or more */
 typedef unsigned long  uLong; /* 32 bits or more */
 
-#if defined(__BORLANDC__) && defined(SMALL_MEDIUM)
-   /* Borland C/C++ ignores FAR inside typedef */
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
 #  define Bytef Byte FAR
 #else
    typedef Byte  FAR Bytef;
@@ -217,6 +243,7 @@ typedef uLong FAR uLongf;
 #ifndef SEEK_SET
 #  define SEEK_SET        0       /* Seek from beginning of file.  */
 #  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
 #endif
 #ifndef z_off_t
 #  define  z_off_t long

zlib/zlib.h

@@ -1,7 +1,7 @@
 /* zlib.h -- interface of the 'zlib' general purpose compression library
-  version 1.1.2, March 19th, 1998
+  version 1.1.4, March 11th, 2002
 
-  Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
+  Copyright (C) 1995-2002 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
@@ -37,7 +37,7 @@
 extern "C" {
 #endif
 
-#define ZLIB_VERSION "1.1.2"
+#define ZLIB_VERSION "1.1.4"
 
 /* 
      The 'zlib' compression library provides in-memory compression and
@@ -169,7 +169,7 @@ typedef z_stream FAR *z_streamp;
 
                         /* basic functions */
 
-extern const char * ZEXPORT zlibVersion OF((void));
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
 /* The application can compare zlibVersion 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.
@@ -177,7 +177,7 @@ extern const char * ZEXPORT zlibVersion OF((void));
  */
 
 /* 
-extern int ZEXPORT deflateInit OF((z_streamp strm, int level));
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
 
      Initializes the internal stream state for compression. The fields
    zalloc, zfree and opaque must be initialized before by the caller.
@@ -199,7 +199,7 @@ extern int ZEXPORT deflateInit OF((z_streamp strm, int level));
 */
 
 
-extern int ZEXPORT deflate OF((z_streamp strm, int flush));
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
 /*
     deflate compresses as much data as possible, and stops when the input
   buffer becomes empty or the output buffer becomes full. It may introduce some
@@ -272,11 +272,12 @@ extern int ZEXPORT deflate OF((z_streamp strm, int flush));
   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.
+  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero).
 */
 
 
-extern int ZEXPORT deflateEnd OF((z_streamp strm));
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
 /*
      All dynamically allocated data structures for this stream are freed.
    This function discards any unprocessed input and does not flush any
@@ -291,7 +292,7 @@ extern int ZEXPORT deflateEnd OF((z_streamp strm));
 
 
 /* 
-extern int ZEXPORT inflateInit OF((z_streamp strm));
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
 
      Initializes the internal stream state for decompression. The fields
    next_in, avail_in, zalloc, zfree and opaque must be initialized before by
@@ -311,7 +312,7 @@ extern int ZEXPORT inflateInit OF((z_streamp strm));
 */
 
 
-extern int ZEXPORT inflate OF((z_streamp strm, int flush));
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
 /*
     inflate decompresses as much data as possible, and stops when the input
   buffer becomes empty or the output buffer becomes full. It may some
@@ -380,7 +381,7 @@ extern int ZEXPORT inflate OF((z_streamp strm, int flush));
 */
 
 
-extern int ZEXPORT inflateEnd OF((z_streamp strm));
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
 /*
      All dynamically allocated data structures for this stream are freed.
    This function discards any unprocessed input and does not flush any
@@ -398,12 +399,12 @@ extern int ZEXPORT inflateEnd OF((z_streamp strm));
 */
 
 /*   
-extern int ZEXPORT deflateInit2 OF((z_streamp strm,
-                                    int  level,
-                                    int  method,
-                                    int  windowBits,
-                                    int  memLevel,
-                                    int  strategy));
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp 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, zfree and opaque must be initialized before by
@@ -441,14 +442,14 @@ extern int ZEXPORT deflateInit2 OF((z_streamp strm,
    not perform any compression: this will be done by deflate().
 */
                             
-extern int ZEXPORT deflateSetDictionary OF((z_streamp strm,
-                                            const Bytef *dictionary,
-                                            uInt  dictLength));
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
 /*
      Initializes the compression dictionary from the given byte sequence
    without producing any compressed output. This function must be called
-   immediately after deflateInit or deflateInit2, before any call of
-   deflate. The compressor and decompressor must use exactly the same
+   immediately after deflateInit, deflateInit2 or deflateReset, before any
+   call of deflate. The compressor and decompressor must use exactly the same
    dictionary (see inflateSetDictionary).
 
      The dictionary should consist of strings (byte sequences) that are likely
@@ -477,8 +478,8 @@ extern int ZEXPORT deflateSetDictionary OF((z_streamp strm,
    perform any compression: this will be done by deflate().
 */
 
-extern int ZEXPORT deflateCopy OF((z_streamp dest,
-                                   z_streamp source));
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
 /*
      Sets the destination stream as a complete copy of the source stream.
 
@@ -495,7 +496,7 @@ extern int ZEXPORT deflateCopy OF((z_streamp dest,
    destination.
 */
 
-extern int ZEXPORT deflateReset OF((z_streamp strm));
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
 /*
      This function is equivalent to deflateEnd followed by deflateInit,
    but does not free and reallocate all the internal compression state.
@@ -506,7 +507,9 @@ extern int ZEXPORT deflateReset OF((z_streamp strm));
    stream state was inconsistent (such as zalloc or state being NULL).
 */
 
-extern int ZEXPORT deflateParams OF((z_streamp strm, int level, int strategy));
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+				      int level,
+				      int strategy));
 /*
      Dynamically update the compression level and compression strategy.  The
    interpretation of level and strategy is as in deflateInit2.  This can be
@@ -526,8 +529,8 @@ extern int ZEXPORT deflateParams OF((z_streamp strm, int level, int strategy));
 */
 
 /*   
-extern int ZEXPORT inflateInit2 OF((z_streamp strm,
-                                    int  windowBits));
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
 
      This is another version of inflateInit with an extra parameter. The
    fields next_in, avail_in, zalloc, zfree and opaque must be initialized
@@ -548,9 +551,9 @@ extern int ZEXPORT inflateInit2 OF((z_streamp strm,
    modified, but next_out and avail_out are unchanged.)
 */
 
-extern int ZEXPORT inflateSetDictionary OF((z_streamp strm,
-                                            const Bytef *dictionary,
-                                            uInt  dictLength));
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
 /*
      Initializes the decompression dictionary from the given uncompressed byte
    sequence. This function must be called immediately after a call of inflate
@@ -567,7 +570,7 @@ extern int ZEXPORT inflateSetDictionary OF((z_streamp strm,
    inflate().
 */
 
-extern int ZEXPORT inflateSync OF((z_streamp strm));
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
 /* 
     Skips invalid compressed data until a full flush point (see above the
   description of deflate with Z_FULL_FLUSH) can be found, or until all
@@ -582,7 +585,7 @@ extern int ZEXPORT inflateSync OF((z_streamp strm));
   until success or end of the input data.
 */
 
-extern int ZEXPORT inflateReset OF((z_streamp strm));
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
 /*
      This function is equivalent to inflateEnd followed by inflateInit,
    but does not free and reallocate all the internal decompression state.
@@ -603,8 +606,8 @@ extern int ZEXPORT inflateReset OF((z_streamp strm));
    utility functions can easily be modified if you need special options.
 */
 
-extern int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
-                                const Bytef *source, uLong sourceLen));
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
 /*
      Compresses the source buffer into the destination buffer.  sourceLen is
    the byte length of the source buffer. Upon entry, destLen is the total
@@ -618,9 +621,9 @@ extern int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
    buffer.
 */
 
-extern int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
-                                 const Bytef *source, uLong sourceLen,
-                                 int level));
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
 /*
      Compresses the source buffer into the destination buffer. The level
    parameter has the same meaning as in deflateInit.  sourceLen is the byte
@@ -633,8 +636,8 @@ extern int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
    Z_STREAM_ERROR if the level parameter is invalid.
 */
 
-extern int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
-                                  const Bytef *source, uLong sourceLen));
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
 /*
      Decompresses the source buffer into the destination buffer.  sourceLen is
    the byte length of the source buffer. Upon entry, destLen is the total
@@ -654,7 +657,7 @@ extern int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
 
 typedef voidp gzFile;
 
-extern gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
+ZEXTERN gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
 /*
      Opens a gzip (.gz) file for reading or writing. The mode parameter
    is as in fopen ("rb" or "wb") but can also include a compression level
@@ -670,7 +673,7 @@ extern gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
    can be checked to distinguish the two cases (if errno is zero, the
    zlib error is Z_MEM_ERROR).  */
 
-extern gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
+ZEXTERN gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
 /*
      gzdopen() associates a gzFile with the file descriptor fd.  File
    descriptors are obtained from calls like open, dup, creat, pipe or
@@ -683,7 +686,7 @@ extern gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
    the (de)compression state.
 */
 
-extern int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
 /*
      Dynamically update the compression level or strategy. See the description
    of deflateInit2 for the meaning of these parameters.
@@ -691,7 +694,7 @@ extern int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
    opened for writing.
 */
 
-extern int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
+ZEXTERN int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
 /*
      Reads the given number of uncompressed bytes from the compressed file.
    If the input file was not in gzip format, gzread copies the given number
@@ -699,28 +702,29 @@ extern int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
      gzread returns the number of uncompressed bytes actually read (0 for
    end of file, -1 for error). */
 
-extern int ZEXPORT    gzwrite OF((gzFile file, const voidp buf, unsigned len));
+ZEXTERN int ZEXPORT    gzwrite OF((gzFile file, 
+				   const voidp buf, unsigned len));
 /*
      Writes the given number of uncompressed bytes into the compressed file.
    gzwrite returns the number of uncompressed bytes actually written
    (0 in case of error).
 */
 
-extern int ZEXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
+ZEXTERN int ZEXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
 /*
      Converts, formats, and writes the args to the compressed file under
    control of the format string, as in fprintf. gzprintf returns the number of
    uncompressed bytes actually written (0 in case of error).
 */
 
-extern int ZEXPORT gzputs OF((gzFile file, const char *s));
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
 /*
       Writes the given null-terminated string to the compressed file, excluding
    the terminating null character.
       gzputs returns the number of characters written, or -1 in case of error.
 */
 
-extern char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
 /*
       Reads bytes from the compressed file until len-1 characters are read, or
    a newline character is read and transferred to buf, or an end-of-file
@@ -729,19 +733,19 @@ extern char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
       gzgets returns buf, or Z_NULL in case of error.
 */
 
-extern int ZEXPORT    gzputc OF((gzFile file, int c));
+ZEXTERN int ZEXPORT    gzputc OF((gzFile file, int c));
 /*
       Writes c, converted to an unsigned char, into the compressed file.
    gzputc returns the value that was written, or -1 in case of error.
 */
 
-extern int ZEXPORT    gzgetc OF((gzFile file));
+ZEXTERN int ZEXPORT    gzgetc OF((gzFile file));
 /*
       Reads one byte from the compressed file. gzgetc returns this byte
    or -1 in case of end of file or error.
 */
 
-extern int ZEXPORT    gzflush OF((gzFile file, int flush));
+ZEXTERN int ZEXPORT    gzflush OF((gzFile file, int flush));
 /*
      Flushes all pending output into the compressed file. The parameter
    flush is as in the deflate() function. The return value is the zlib
@@ -751,10 +755,11 @@ extern int ZEXPORT    gzflush OF((gzFile file, int flush));
    degrade compression.
 */
 
-extern z_off_t ZEXPORT    gzseek OF((gzFile file, z_off_t offset, int whence));
+ZEXTERN z_off_t ZEXPORT    gzseek OF((gzFile file,
+				      z_off_t offset, int whence));
 /* 
-      Sets the starting position for the next gzread or gzwrite on the given
-   compressed file. The offset represents a number of bytes in the
+      Sets the starting position for the next gzread or gzwrite on the
+   given compressed file. The offset represents a number of bytes in the
    uncompressed data stream. The whence parameter is defined as in lseek(2);
    the value SEEK_END is not supported.
      If the file is opened for reading, this function is emulated but can be
@@ -768,14 +773,14 @@ extern z_off_t ZEXPORT    gzseek OF((gzFile file, z_off_t offset, int whence));
    would be before the current position.
 */
 
-extern int ZEXPORT    gzrewind OF((gzFile file));
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
 /*
      Rewinds the given file. This function is supported only for reading.
 
    gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
 */
 
-extern z_off_t ZEXPORT    gztell OF((gzFile file));
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
 /*
      Returns the starting position for the next gzread or gzwrite on the
    given compressed file. This position represents a number of bytes in the
@@ -784,20 +789,20 @@ extern z_off_t ZEXPORT    gztell OF((gzFile file));
    gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
 */
 
-extern int ZEXPORT gzeof OF((gzFile file));
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
 /*
      Returns 1 when EOF has previously been detected reading the given
    input stream, otherwise zero.
 */
 
-extern int ZEXPORT    gzclose OF((gzFile file));
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
 /*
      Flushes all pending output if necessary, closes the compressed file
    and deallocates all the (de)compression state. The return value is the zlib
    error number (see function gzerror below).
 */
 
-extern const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
 /*
      Returns the error message for the last error which occurred on the
    given compressed file. errnum is set to zlib error number. If an
@@ -814,7 +819,7 @@ extern const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
    compression library.
 */
 
-extern uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
 
 /*
      Update a running Adler-32 checksum with the bytes buf[0..len-1] and
@@ -831,7 +836,7 @@ extern uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
      if (adler != original_adler) error();
 */
 
-extern uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
 /*
      Update a running crc with the bytes buf[0..len-1] and return the updated
    crc. If buf is NULL, this function returns the required initial value
@@ -853,16 +858,16 @@ extern uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
 /* deflateInit and inflateInit are macros to allow checking the zlib version
  * and the compiler's view of z_stream:
  */
-extern int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
-                                    const char *version, int stream_size));
-extern int ZEXPORT inflateInit_ OF((z_streamp strm,
-                                    const char *version, int stream_size));
-extern int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
-                                     int windowBits, int memLevel,
-                                     int strategy, const char *version,
-                                     int stream_size));
-extern int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
                                      const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
 #define deflateInit(strm, level) \
         deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
 #define inflateInit(strm) \
@@ -878,9 +883,9 @@ extern int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
     struct internal_state {int dummy;}; /* hack for buggy compilers */
 #endif
 
-extern const char   * ZEXPORT zError           OF((int err));
-extern int            ZEXPORT inflateSyncPoint OF((z_streamp z));
-extern const uLongf * ZEXPORT get_crc_table    OF((void));
+ZEXTERN const char   * ZEXPORT zError           OF((int err));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp z));
+ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
 
 #ifdef __cplusplus
 }

zlib/zutil.c

@@ -1,5 +1,5 @@
 /* zutil.c -- target dependent utility functions for the compression library
- * Copyright (C) 1995-1998 Jean-loup Gailly.
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
@@ -60,7 +60,7 @@ const char * ZEXPORT zError(err)
 
 void zmemcpy(dest, source, len)
     Bytef* dest;
-    Bytef* source;
+    const Bytef* source;
     uInt  len;
 {
     if (len == 0) return;
@@ -70,8 +70,8 @@ void zmemcpy(dest, source, len)
 }
 
 int zmemcmp(s1, s2, len)
-    Bytef* s1;
-    Bytef* s2;
+    const Bytef* s1;
+    const Bytef* s2;
     uInt  len;
 {
     uInt j;
@@ -178,7 +178,7 @@ void  zcfree (voidpf opaque, voidpf ptr)
 
 #  define MY_ZCALLOC
 
-#if (!defined(_MSC_VER) || (_MSC_VER < 600))
+#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
 #  define _halloc  halloc
 #  define _hfree   hfree
 #endif

zlib/zutil.h

@@ -1,5 +1,5 @@
 /* zutil.h -- internal interface and configuration of the compression library
- * Copyright (C) 1995-1998 Jean-loup Gailly.
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
  * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
@@ -78,7 +78,7 @@ extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
 
 #ifdef MSDOS
 #  define OS_CODE  0x00
-#  ifdef __TURBOC__
+#  if defined(__TURBOC__) || defined(__BORLANDC__)
 #    if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
        /* Allow compilation with ANSI keywords only enabled */
        void _Cdecl farfree( void *block );
@@ -115,13 +115,12 @@ extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
 
 #if defined(MACOS) || defined(TARGET_OS_MAC)
 #  define OS_CODE  0x07
-#  ifndef fdopen
-#    define fdopen(fd,mode) NULL /* No fdopen() */
-#  endif
-#endif
-#if defined(__MWERKS__) && !defined(fdopen)
-#  if __dest_os != __be_os && __dest_os != __win32_os
-#    define fdopen(fd,mode) NULL
+#  if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#    include <unix.h> /* for fdopen */
+#  else
+#    ifndef fdopen
+#      define fdopen(fd,mode) NULL /* No fdopen() */
+#    endif
 #  endif
 #endif
 
@@ -137,7 +136,7 @@ extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
 #  define fdopen(fd,mode) NULL /* No fdopen() */
 #endif
 
-#if (defined(_MSC_VER) && (_MSC_VER >= 600))
+#if (defined(_MSC_VER) && (_MSC_VER > 600))
 #  define fdopen(fd,type)  _fdopen(fd,type)
 #endif
 
@@ -185,8 +184,8 @@ extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
 #    define zmemzero(dest, len) memset(dest, 0, len)
 #  endif
 #else
-   extern void zmemcpy  OF((Bytef* dest, Bytef* source, uInt len));
-   extern int  zmemcmp  OF((Bytef* s1,   Bytef* s2, uInt len));
+   extern void zmemcpy  OF((Bytef* dest, const Bytef* source, uInt len));
+   extern int  zmemcmp  OF((const Bytef* s1, const Bytef* s2, uInt len));
    extern void zmemzero OF((Bytef* dest, uInt len));
 #endif