preparing for release of 2.5.7

Prepare for 2.5.7 release.

.cvsignore

@@ -1,21 +1,24 @@
-.ignore
-.cvsignore
+ID
 Makefile
-a
-b
+autom4te.cache
+confdefs.h
 config.cache
 config.h
 config.log
 config.status
-dist.tar.gz
+conftest.c
+conftest.log
+dox
+getgroups
+gmon.out
 rsync
-rsync-*
-rsync.aux
-rsync.dvi
-rsync.log
-tech_report.aux
-tech_report.dvi
-tech_report.log
-tech_report.ps
-test
-
+shconfig
+testdir
+tests-dont-exist
+testtmp
+testtmp.*
+tls
+trimslash
+t_unsafe
+wildtest
+zlib/dummy

Doxyfile

@@ -0,0 +1,187 @@
+# Doxyfile 1.2.15
+
+#---------------------------------------------------------------------------
+# General configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = rsync
+PROJECT_NUMBER         = HEAD
+OUTPUT_DIRECTORY       = dox
+OUTPUT_LANGUAGE        = English
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = YES
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = NO
+STRIP_FROM_PATH        = *source
+INTERNAL_DOCS          = YES
+STRIP_CODE_COMMENTS    = NO
+CASE_SENSE_NAMES       = YES
+SHORT_NAMES            = NO
+HIDE_SCOPE_NAMES       = YES
+VERBATIM_HEADERS       = YES
+SHOW_INCLUDE_FILES     = YES
+JAVADOC_AUTOBRIEF      = YES
+INHERIT_DOCS           = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = NO
+DISTRIBUTE_GROUP_DOC   = NO
+TAB_SIZE               = 8
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+ALIASES                = 
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+OPTIMIZE_OUTPUT_FOR_C  = YES
+OPTIMIZE_OUTPUT_JAVA   = NO
+SHOW_USED_FILES        = YES
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = NO
+WARN_IF_UNDOCUMENTED   = NO
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           = 
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = .
+FILE_PATTERNS          = *.c \
+                         *.h
+RECURSIVE              = YES
+EXCLUDE                = proto.h \
+                         zlib \
+                         popt
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = 
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_SOURCE_FILES    = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = YES
+INLINE_SOURCES         = YES
+REFERENCED_BY_RELATION = YES
+REFERENCES_RELATION    = YES
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 3
+IGNORE_PREFIX          = 
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            = 
+HTML_FOOTER            = 
+HTML_STYLESHEET        = 
+HTML_ALIGN_MEMBERS     = YES
+GENERATE_HTMLHELP      = NO
+GENERATE_CHI           = NO
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 3
+GENERATE_TREEVIEW      = NO
+TREEVIEW_WIDTH         = 250
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = YES
+USE_PDFLATEX           = YES
+LATEX_BATCHMODE        = YES
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = NO
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = 
+INCLUDE_FILE_PATTERNS  = 
+PREDEFINED             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to external references   
+#---------------------------------------------------------------------------
+TAGFILES               = 
+GENERATE_TAGFILE       = 
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+PERL_PATH              = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = YES
+HAVE_DOT               = YES
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+TEMPLATE_RELATIONS     = YES
+HIDE_UNDOC_RELATIONS   = YES
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+GRAPHICAL_HIERARCHY    = YES
+DOT_IMAGE_FORMAT       = png
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1024
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = NO
+CGI_NAME               = search.cgi
+CGI_URL                = 
+DOC_URL                = 
+DOC_ABSPATH            = 
+BIN_ABSPATH            = /usr/local/bin/
+EXT_DOC_PATHS          = 

INSTALL

@@ -0,0 +1,62 @@
+To build and install rsync
+
+  $ ./configure
+  $ make
+  # make install
+
+You may set the installation directory and other parameters by options
+to ./configure.  To see them, use:
+
+  $ ./configure --help
+
+As of 2.4.7, rsync uses Eric Troan's popt option-parsing library.  A
+cut-down copy of release 1.5 is included in the rsync distribution,
+and will be used if there is no popt library on your build host, or if
+the --with-included-popt option is passed to ./configure.
+
+If you configure using --enable-maintainer-mode, then rsync will try
+to pop up an xterm on DISPLAY=:0 if it crashes.  You might find this
+useful, but it should be turned off for production builds.
+
+
+RPM NOTES
+---------
+
+Under packaging you will find .spec files for several distributions.
+The .spec file in packaging/lsb can be used for Linux systems that
+adhere to the Linux Standards Base (e.g., RedHat and others).
+
+HP-UX NOTES
+-----------
+
+The HP-UX 10.10 "bundled" C compiler seems not to be able to cope with
+ANSI C.  You may see this error message in config.log if ./configure
+fails:
+
+  (Bundled) cc: "configure", line 2162: error 1705: Function prototypes are an ANSI feature.
+
+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.
+
+There is an unresolved problem with the OSX implimentation
+of setgroups causing rsyncd to fail.  The workaround is to
+#undef HAVE_SETGROUPS in config.h
+
+IBM AIX NOTES
+-------------
+
+IBM AIX has a largefile problem with mkstemp.  See IBM PR-51921.
+The workaround is to append the below to config.h
+	#ifdef _LARGE_FILES
+	#undef HAVE_SECURE_MKSTEMP
+	#endif

Makefile.in

@@ -3,52 +3,195 @@
 
 prefix=@prefix@
 exec_prefix=@exec_prefix@
-INSTALL_BIN=$(exec_prefix)/bin
-INSTALL_MAN=$(prefix)/man
+bindir=@bindir@
+mandir=@mandir@
 
 LIBS=@LIBS@
 CC=@CC@
 CFLAGS=@CFLAGS@
+CPPFLAGS=@CPPFLAGS@
+EXEEXT=@EXEEXT@
+LDFLAGS=@LDFLAGS@
 
 INSTALLCMD=@INSTALL@
+INSTALLMAN=@INSTALL@
 
-VPATH=@srcdir@
 srcdir=@srcdir@
+VPATH=$(srcdir)
 SHELL=/bin/sh
 
+VERSION=@VERSION@
 
 .SUFFIXES:
 .SUFFIXES: .c .o
 
-LIBOBJ=lib/getopt.o lib/fnmatch.o lib/zlib.o lib/compat.o
-OBJS1=rsync.o exclude.o util.o md4.o main.o checksum.o match.o syscall.o
-OBJS=$(OBJS1) flist.o io.o compat.o hlink.o token.o uidlist.o $(LIBOBJ)
+HEADERS=byteorder.h config.h errcode.h proto.h rsync.h
+LIBOBJ=lib/wildmatch.o lib/compat.o lib/snprintf.o lib/mdfour.o \
+	lib/permstring.o @LIBOBJS@
+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 clientname.o
+OBJS3=progress.o pipe.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) $(OBJS3) $(DAEMON_OBJ) $(LIBOBJ) $(ZLIBOBJ) @BUILD_POPT@
+
+TLS_OBJ = tls.o syscall.o lib/permstring.o
+
+# Programs we must have to run the test cases
+CHECK_PROGS = rsync$(EXEEXT) tls$(EXEEXT) getgroups$(EXEEXT) \
+	trimslash$(EXEEXT) t_unsafe$(EXEEXT) wildtest$(EXEEXT)
+
+# Objects for CHECK_PROGS to clean
+CHECK_OBJS=getgroups.o t_stub.o t_unsafe.o trimslash.o wildtest.o
 
 # note that the -I. is needed to handle config.h when using VPATH
 .c.o:
-	$(CC) -I. -I$(srcdir) $(CFLAGS) -c $< -o $@
+@OBJ_SAVE@
+	$(CC) -I. -I$(srcdir) $(CFLAGS) $(CPPFLAGS) -c $< @CC_SHOBJ_FLAG@
+@OBJ_RESTORE@
 
-all: rsync
+all: rsync$(EXEEXT)
+
+man: rsync.1 rsyncd.conf.5
 
 install: all
-	-mkdir -p ${INSTALL_BIN}
-	${INSTALLCMD} -m 755 rsync ${INSTALL_BIN}
-	-mkdir -p ${INSTALL_MAN}/man1
-	${INSTALLCMD} -m 644 $(srcdir)/rsync.1 ${INSTALL_MAN}/man1
+	-mkdir -p ${DESTDIR}${bindir}
+	${INSTALLCMD} ${STRIP} -m 755 rsync$(EXEEXT) ${DESTDIR}${bindir}
+	-mkdir -p ${DESTDIR}${mandir}/man1
+	-mkdir -p ${DESTDIR}${mandir}/man5
+	${INSTALLMAN} -m 644 $(srcdir)/rsync.1 ${DESTDIR}${mandir}/man1
+	${INSTALLMAN} -m 644 $(srcdir)/rsyncd.conf.5 ${DESTDIR}${mandir}/man5
 
-rsync: $(OBJS)
-	$(CC) $(CFLAGS) -o rsync $(OBJS) $(LIBS)
+install-strip:
+	$(MAKE) STRIP='-s' install
+
+rsync$(EXEEXT): $(OBJS)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
+
+$(OBJS): $(HEADERS)
+
+tls$(EXEEXT): $(TLS_OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(TLS_OBJ) $(LIBS)
+
+getgroups$(EXEEXT): getgroups.o
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ getgroups.o $(LIBS)
+
+TRIMSLASH_OBJ = trimslash.o syscall.o
+trimslash$(EXEEXT): $(TRIMSLASH_OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(TRIMSLASH_OBJ) $(LIBS)
+
+T_UNSAFE_OBJ = t_unsafe.o syscall.o util.o t_stub.o lib/compat.o lib/snprintf.o
+t_unsafe$(EXEEXT): $(T_UNSAFE_OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(T_UNSAFE_OBJ) $(LIBS)
+
+# I don't like these rules because CVS can skew the timestamps and
+# produce spurious warnings, and also make "make install" fail if the
+# source directory can no longer be found.  Since we don't rebuild
+# automatically they're kind of lame anyhow.
+
+#Makefile: Makefile.in configure config.status
+#	echo "WARNING: You need to run ./config.status --recheck"
+
+# don't actually run autoconf, just issue a warning
+#configure: configure.in
+#	echo "WARNING: you need to rerun autoconf"
+
+$(srcdir)/rsync.1: $(srcdir)/rsync.yo
+	yodl2man -o $(srcdir)/rsync.1 $(srcdir)/rsync.yo
+
+$(srcdir)/rsyncd.conf.5: $(srcdir)/rsyncd.conf.yo
+	yodl2man -o $(srcdir)/rsyncd.conf.5 $(srcdir)/rsyncd.conf.yo
 
 proto:
-	cat *.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 config.cache config.log config.status
+clean: cleantests
+	rm -f *~ $(OBJS) $(TLS_OBJ) $(CHECK_PROGS) $(CHECK_OBJS)
 
-dist:
-	tar --exclude-from .ignore -czf dist.tar.gz .
-	-mkdir rsync-$(VERSION)
-	(cd rsync-$(VERSION) ; tar xzf ../dist.tar.gz)
-	tar -czf rsync-$(VERSION).tar.gz rsync-$(VERSION)
-	rm -f dist.tar.gz
-	echo rsync-$(VERSION) >> .cvsignore
+cleantests:
+	rm -rf ./testtmp*
+
+# We try to delete built files from both the source and build
+# directories, just in case somebody previously configured things in
+# the source directory.
+distclean: clean
+	rm -f Makefile config.h config.status
+	rm -f $(srcdir)/Makefile $(srcdir)/config.h $(srcdir)/config.status
+
+	rm -f config.cache config.log
+	rm -f $(srcdir)/config.cache $(srcdir)/config.log
+
+	rm -f shconfig $(srcdir)/shconfig
+
+# this target is really just for my use. It only works on a limited
+# range of machines and is used to produce a list of potentially
+# dead (ie. unused) functions in the code. (tridge)
+finddead:
+	nm *.o */*.o |grep 'U ' | awk '{print $$2}' | sort -u > nmused.txt
+	nm *.o */*.o |grep 'T ' | awk '{print $$3}' | sort -u > nmfns.txt
+	comm -13 nmused.txt nmfns.txt
+
+# 'check' is the GNU name, 'test' is the name for everybody else :-)
+.PHONY: check test
+
+test: check
+
+
+# There seems to be no standard way to specify some variables as
+# exported from a Makefile apart from listing them like this.
+
+# TODO: Tests that depend on built test aide programs like tls need to
+# know where the build directory is.
+
+# This depends on building rsync; if we need any helper programs it
+# should depend on them too.
+
+# We try to run the scripts with POSIX mode on, in the hope that will
+# catch Bash-isms earlier even if we're running on GNU.  Of course, we
+# might lose in the future where POSIX diverges from old sh.
+
+check: all $(CHECK_PROGS)
+	POSIXLY_CORRECT=1 TOOLDIR=`pwd` rsync_bin=`pwd`/rsync$(EXEEXT) srcdir="$(srcdir)" $(srcdir)/runtests.sh
+
+wildtest.o: wildtest.c lib/wildmatch.c rsync.h
+wildtest$(EXEEXT): wildtest.o
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ wildtest.o @BUILD_POPT@ $(LIBS)
+
+# This does *not* depend on building or installing: you can use it to
+# check a version installed from a binary or some other source tree,
+# if you want.
+
+installcheck: $(CHECK_PROGS)
+	POSIXLY_CORRECT=1 TOOLDIR=`pwd` rsync_bin="$(bindir)/rsync$(EXEEXT)" srcdir="$(srcdir)" $(srcdir)/runtests.sh
+
+# TODO: Add 'dist' target; need to know which files will be included
+
+# Run the SPLINT (Secure Programming Lint) tool.  <www.splint.org>
+.PHONY: splint
+splint:
+	splint +unixlib +gnuextensions -weak rsync.c
+
+
+rsync.dvi: doc/rsync.texinfo
+	texi2dvi -o $@ $<
+
+rsync.ps: rsync.dvi
+	dvips -ta4 -o $@ $<
+
+rsync.pdf: doc/rsync.texinfo
+	texi2dvi -o $@ --pdf $<
+
+
+doxygen:
+	cd $(srcdir) && rm dox/html/* && doxygen
+
+# for maintainers only
+doxygen-upload:
+	rsync -avzv $(srcdir)/dox/html/ --delete \
+	samba.org:/home/httpd/html/rsync/doxygen/head/

NEWS

@@ -0,0 +1,99 @@
+NEWS for rsync version 2.5.7:
+
+  SECURITY:
+
+    * Fix buffer handling bugs.  (Andrew Tridgell, Martin Pool, Paul
+      Russell, Andrea Barisani)
+
+
+NEWS for rsync version 2.5.6, aka the dwd-between-jobs release
+Changes since version 2.5.5:
+
+  ENHANCEMENTS:
+
+    * The --delete-after option now implies --delete.  (Wayne Davison)
+
+    * The --suffix option can now be used with --backup-dir.  (Michael
+      Zimmerman)
+
+    * Combining "::" syntax with the -rsh/-e option now uses the
+      specified remote-shell as a transport to talk to a (newly-spawned)
+      server-daemon.  This allows someone to use daemon features, such
+      as modules, over a secure protocol, such as ssh.  (JD Paul)
+
+    * The rsync:// syntax for daemon connections is now accepted in the
+      destination field.
+
+    * If the file name given to --include-from or --exclude-from is "-",
+      rsync will read from standard input.  (J.W. Schultz)
+
+    * New option --link-dest which is like --compare-dest except that
+      unchanged files are hard-linked in to the destination directory.
+      (J.W. Schultz)
+
+    * Don't report an error if an excluded file disappears during an
+      rsync run.  (Eugene Chupriyanov and Bo Kersey)
+
+    * Added .svn to --cvs-exclude list to support subversion.  (Jon
+      Middleton)
+
+    * Properly support IPv6 addresses in the rsyncd.conf "hosts allow"
+      and "hosts deny" fields.  (Hideaki Yoshifuji)
+
+    * Changed exclude file handling to permit DOS or MAC style line
+      terminations.  (J.W. Schultz)
+
+    * Ignore errors from chmod when -p/-a/--preserve-perms is not set.
+      (Dave Dykstra)
+
+  BUG FIXES:
+  
+    * Fix "forward name lookup failed" errors on AIX 4.3.3.  (John
+      L. Allen, Martin Pool)
+
+    * Generate each file's rolling-checksum data as we send it, not
+      in a separate (memory-eating) pass before hand.  This prevents
+      timeout errors on really large files. (Stefan Nehlsen)
+
+    * Fix compilation on Tru64.  (Albert Chin, Zoong Pham)
+
+    * Better handling of some client-server errors.  (Martin Pool)
+
+    * Fixed a crash that would occur when sending a list of files that
+      contains a duplicate name (if it sorts to the end of the file
+      list) and using --delete.  (Wayne Davison)
+
+    * Fixed the file-name duplicate-removal code when dealing with multiple
+      dups in a row. (Wayne Davison)
+
+    * Fixed a bug that caused rsync to lose the exit status of its child
+      processes and sometimes return an exit code of 0 instead of showing
+      an error.  (David R. Staples, Dave Dykstra)
+
+    * Fixed bug in --copy-unsafe-links that caused it to be completely
+      broken.  (Dave Dykstra)
+
+    * Prevent infinite recursion in cleanup code under certain circumstances.
+      (Sviatoslav Sviridov and Marc Espie)
+
+    * Fixed a bug that prevented rsync from creating intervening directories
+      when --relative-paths/-R is set.  (Craig Barratt)
+
+    * Prevent "Connection reset by peer" messages from Cygwin. (Randy O'Meara)
+
+  INTERNAL:
+
+    * Many code cleanups and improved internal documentation.  (Martin 
+      Pool, Nelson Beebe)
+
+    * Portability fixes. (Dave Dykstra and Wayne Davison)
+
+    * More test cases.  (Martin Pool)
+
+    * Some test-case fixes.  (Brian Poole, Wayne Davison)
+
+    * Updated included popt to the latest vendor drop, version 1.6.4.
+      (Jos Backus)
+
+    * Updated config.guess and config.sub to latest versions; this
+      means rsync should build on more platforms.  (Paul Green)

OLDNEWS

@@ -0,0 +1,342 @@
+rsync 2.5.5 "Snowy River" (2 April 2002)
+protocol: 26 (unchanged)
+
+  ENHANCEMENTS:
+
+    * With --progress, when a transfer is complete show the time taken;
+      otherwise show expected time to complete. (Cameron Simpson)
+
+    * Make "make install-strip" works properly, and "make install"
+      accepts a DESTDIR variable for help in building binary packages.
+      (Peter Breitenlohner, Greg Louis)
+
+    * If configured with --enable-maintainer-mode, then on receipt of
+      a fatal signal rsync will try to open an xterm running gdb,
+      similarly to Samba's "panic action" or GNOME's bug-buddy.
+      (Martin Pool)
+
+
+  BUG FIXES:
+
+    * Fix situation where failure to fork (e.g. because out of process
+      slots) would cause rsync to kill all processes owned by the
+      current user.  Yes, really!  (Paul Haas, Martin Pool)
+
+    * Fix test suite on Solaris.  (Jos Backus, Martin Pool)
+
+    * Fix minor memory leak in socket code.  (Dave Dykstra, Martin
+      Pool.)
+
+    * Fix --whole-file problem that caused it to be the default even
+      for remote connections.  (Martin Pool, Frank Schulz)
+
+    * Work around bug in Mac OS X mkdir(2), which cannot handle
+      trailing slashes.
+      <http://www.opensource.apple.com/bugs/X/BSD%20Kernel/2734739.html>
+      (Martin Pool)
+
+    * Improved network error handling.  (Greg A. Woods)
+
+
+rsync 2.5.4 (13 March 2002)
+protocol: 26 (unchanged)
+
+  "Imitation lizard skin"
+
+  BUG FIXES:
+
+    * Additional fix for zlib double-free bug.  (Martin Pool, Andrew
+      Tridgell) (CVE CAN-2002-0059)
+ 
+  ENHANCEMENTS:
+
+    * 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)
+
+
+rsync 2.5.3 (11 March 2002)
+protocol: 26 (unchanged)
+
+  "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)
+protocol: 26 (changed)
+
+  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)
+protocol: 25 (unchanged)
+
+  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)
+protocol: 25 (changed)
+
+  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.
+
+Partial Protocol History
+	DATE			RELEASE		PROTOCOL
+	2003/01/26 20:11:16	release-2-5-6	26	
+	2002/02/23 00:17:50	release-2-5-3	26	
+	2002/01/25 23:00:21	release-2-5-2	26	
+	2001/12/18 06:47:40	release-2-5-1	25	
+				release-2-4-6	24	
+	2000/08/16 08:34:18	release-2-4-5	24	
+	2000/07/29 04:52:05	release-2-4-4	24	
+	2000/03/30 14:15:00	release-2-4-2	24	
+	2000/01/29 23:49:36	release-2-4-1	24	
+	2000/01/29 02:56:37	release-2-4-0	23	
+				release-2-3-3	21	
+	1999/06/26 01:06:38	release-2-3-2	21	
+				release-2-3-1	20	
+	1999/03/15 21:17:59	release-2-3-0	20	
+	1998/11/15 01:21:42	release-2-2-1	19	
+	1998/11/03 07:08:28	release-2-2-0	19	
+	1998/09/09 06:31:14	release-2-1-1	19	
+	1998/07/17 14:43:05	release-2-0-19	19	
+	1998/06/18 12:17:24	release-2-0-18	19	
+	1998/06/18 09:51:56	release-2-0-17	19	
+	1998/06/01 03:42:22	release-2-0-16	19	
+	1998/05/27 13:47:34	release-2-0-13	19	
+	1998/05/26 14:19:00	release-2-0-12	18	
+	1998/05/21 05:55:33	release-2-0-11	18	
+	1998/05/18 08:20:34	release-2-0-9	18	
+	1998/05/17 05:56:33	release-2-0-8	17	
+	1998/05/15 07:34:21	release-2-0-2	17	
+	1998/05/13 15:44:11	release-2-0-0	17	
+	1998/04/17 06:07:26	release-1-7-4	17	
+	1998/04/05 06:43:55	release-1-7-2	17	
+	1998/03/26 04:18:57	release-1-7-0	17 MAX=30
+	1998/01/13 15:57:32	release-1-6-9	15 MAX=20
+	1997/12/17 11:07:30	release-1-6-7	14	
+	1997/12/15 18:36:21	release-1-6-4	14	
+
+* DATE OF COMMIT is the date the protocl change was committed
+  to cvs, not the release date.

README

@@ -18,63 +18,47 @@ this package.
 USAGE
 -----
 
-Basically you use rsync just like rcp, but rsync has many additional options.
+Basically you use rsync just like rcp, but rsync has many additional
+options.  To get a complete list of supported options type
 
-Here is a brief description of available options:
+  rsync --help
 
-Options:
--v, --verbose            increase verbosity
--c, --checksum           always checksum
--a, --archive            archive mode (same as -rlptDog)
--r, --recursive          recurse into directories
--R, --relative           use relative path names
--b, --backup             make backups (default ~ extension)
--u, --update             update only (don't overwrite newer files)
--l, --links              preserve soft links
--L, --copy-links         treat soft links like regular files
--H, --hard-links         preserve hard links
--p, --perms              preserve permissions
--o, --owner              preserve owner (root only)
--g, --group              preserve group
--D, --devices            preserve devices (root only)
--t, --times              preserve times
--S, --sparse             handle sparse files efficiently
--n, --dry-run            show what would have been transferred
--W, --whole-file         copy whole files, no incremental checks
--x, --one-file-system    don't cross filesystem boundaries
--B, --block-size SIZE    checksum blocking size
--e, --rsh COMMAND        specify rsh replacement
-    --rsync-path PATH    specify path to rsync on the remote machine
--C, --cvs-exclude        auto ignore files in the same way CVS does
-    --delete             delete files that don't exist on the sending side
-    --force              force deletion of directories even if not empty
-    --numeric-ids        don't map uid/gid values by user/group name
-    --timeout TIME       set IO timeout in seconds
--I, --ignore-times       don't exclude files that match length and time
--T  --temp-dir DIR       create temporary files in directory DIR
--z, --compress           compress file data
-    --exclude FILE       exclude file FILE
-    --exclude-from FILE  exclude files listed in FILE
-    --suffix SUFFIX      override backup suffix
-    --version            print version number
+and see the manual for more information.
 
 
 SETUP
 -----
 
-Rsync uses rsh or ssh for communication. It does not need to be setuid
-and requires no special privilages for installation. It does not
-require a inetd entry or a daemon. You must, however, have a working
-rsh or ssh system. Using ssh is recommended for its security
-features. 
+Rsync normally uses rsh or ssh for communication.  It does not need to
+be setuid and requires no special privileges for installation.  You
+must, however, have a working rsh or ssh system. Using ssh is
+recommended for its security features.
+
+Alternatively, rsync can run in `daemon' mode, listening on a socket.
+This is generally used for public file distribution, although
+authentication and access control are available.
 
 To install rsync, first run the "configure" script. This will create a
 Makefile and config.h appropriate for your system. Then type
 "make". 
 
+Note that on some systems you will have to force configure not to use
+gcc because gcc may not support some features (such as 64 bit file
+offsets) that your system may support. Set the environment variable CC
+to the name of your native compiler before running configure in this
+case. 
+
 Once built put a copy of rsync in your search path on the local and
 remote systems (or use "make install"). That's it!
 
+RSYNC SERVERS
+-------------
+
+rsync can also talk to "rsync servers" which can provide anonymous or
+authenticated rsync. See the rsyncd.conf(5) man page for details on how
+to setup a rsync server. See the rsync(1) man page for info on how to
+connect to a rsync server.
+
 
 MAILING LIST
 ------------
@@ -83,25 +67,28 @@ There is a mailing list for the discussion of rsync and its
 applications. It is open to anyone to join. I will announce new
 versions on this list. 
 
-To join the mailing list send mail to listproc@samba.anu.edu.au with
-no subject and a body of "subscribe rsync Your Name".
+To join the mailing list see the web page at http://lists.samba.org/
 
-To send mail to everyone on the list send it to rsync@samba.anu.edu.au
+To send mail to everyone on the list send it to rsync@samba.org
 
 
 BUG REPORTS
 -----------
 
 If you have web access then please look at
-http://samba.anu.edu.au/rsync/ 
 
-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.
+  http://rsync.samba.org
 
-If you don't have web access then mail bug reports to
-rsync-bugs@samba.anu.edu.au or (if you think it will be of interest to
-lots of people) send it to rsync@samba.anu.edu.au
+That page contains links to the current bug list, and information on
+how to report a bug well.  You might also like to try searching the
+internet for the error message you've received, or looking in the
+mailing list archives at
+
+  http://mail-archive.com/rsync@lists.samba.org/
+
+Please send bug reports to 
+
+  rsync@lists.samba.org
 
 
 CVS TREE
@@ -111,31 +98,29 @@ If you want to get the very latest version of rsync direct from the
 source code repository then you can use anonymous cvs. You will need a
 recent version of cvs then use the following commands:
 
-	cvs -d :pserver:cvs@samba.anu.edu.au:/cvsroot login
+	cvs -d :pserver:cvs@pserver.samba.org:/cvsroot login
 	Password: cvs
 
-	cvs -d :pserver:cvs@samba.anu.edu.au:/cvsroot co rsync
+	cvs -d :pserver:cvs@pserver.samba.org:/cvsroot co rsync
 
-Look at the cvs documentation for more details.
+Look at the cvs documentation, or http://samba.org/cvs.html, for more
+details.
 
 
 COPYRIGHT
 ---------
 
-Rsync was written by Andrew Tridgell and Paul Mackerras, and is
-available under the Gnu 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.anu.edu.au
-paulus@cs.anu.edu.au
+  http://www.fsf.org/licenses/gpl.html
 
 
 AVAILABILITY
 ------------
 
-The main ftp site for rsync is ftp://samba.anu.edu.au/pub/rsync
-
-Mirrors are available at:
-
-ftp://sunsite.auc.dk/pub/unix/rsync
-ftp://ftp.sunet.se/pub/unix/admin/rsync
-ftp://ftp.fu-berlin.de/pub/unix/network/rsync/
+The main web site for rsync is http://rsync.samba.org/
+The main ftp site is ftp://rsync.samba.org/pub/rsync/
+This is also available as rsync://rsync.samba.org/rsyncftp/

TODO

@@ -0,0 +1,798 @@
+-*- indented-text -*-
+
+BUGS ---------------------------------------------------------------
+
+rsync-url barfs on upload
+
+  rsync foo rsync://localhost/transfer/
+
+  Fix the parser.
+
+
+There seems to be a bug with hardlinks
+
+  mbp/2 build$ ls -l /tmp/a /tmp/b -i
+  /tmp/a:
+  total 32
+  2568307 -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a1
+  2568307 -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a2
+  2568307 -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a3
+  2568310 -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 a4
+  2568310 -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 a5
+  2568310 -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b1
+  2568310 -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b2
+  2568310 -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b3
+
+  /tmp/b:
+  total 32
+  2568309 -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a1
+  2568309 -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a2
+  2568309 -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a3
+  2568311 -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 a4
+  2568311 -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 a5
+  2568311 -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b1
+  2568311 -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b2
+  2568311 -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b3
+  mbp/2 build$ rm -r /tmp/b && ./rsync -avH /tmp/a/ /tmp/b
+  building file list ... done
+  created directory /tmp/b
+  ./
+  a1
+  a4
+  a2 => a1
+  a3 => a2
+  wrote 350 bytes  read 52 bytes  804.00 bytes/sec
+  total size is 232  speedup is 0.58
+  mbp/2 build$ rm -r /tmp/b
+  mbp/2 build$ ls -l /tmp/b
+  ls: /tmp/b: No such file or directory
+  mbp/2 build$ rm -r /tmp/b && ./rsync -avH /tmp/a/ /tmp/b
+  rm: cannot remove `/tmp/b': No such file or directory
+  mbp/2 build$ rm -f -r /tmp/b && ./rsync -avH /tmp/a/ /tmp/b
+  building file list ... done
+  created directory /tmp/b
+  ./
+  a1
+  a4
+  a2 => a1
+  a3 => a2
+  wrote 350 bytes  read 52 bytes  804.00 bytes/sec
+  total size is 232  speedup is 0.58
+  mbp/2 build$ ls -l /tmp/b
+  total 32
+  -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a1
+  -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a2
+  -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a3
+  -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 a4
+  -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 a5
+  -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b1
+  -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b2
+  -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b3
+  mbp/2 build$ ls -l /tmp/a
+  total 32
+  -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a1
+  -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a2
+  -rw-rw-r--    3 mbp      mbp            29 Mar 25 17:30 a3
+  -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 a4
+  -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 a5
+  -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b1
+  -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b2
+  -rw-rw-r--    5 mbp      mbp            29 Mar 25 17:30 b3
+
+
+Progress indicator can produce corrupt output when transferring directories:
+
+  main/binary-arm/
+  main/binary-arm/admin/
+  main/binary-arm/base/
+  main/binary-arm/comm/8.56kB/s    0:00:52
+  main/binary-arm/devel/
+  main/binary-arm/doc/
+  main/binary-arm/editors/
+  main/binary-arm/electronics/s    0:00:53
+  main/binary-arm/games/
+  main/binary-arm/graphics/
+  main/binary-arm/hamradio/
+  main/binary-arm/interpreters/
+  main/binary-arm/libs/6.61kB/s    0:00:54
+  main/binary-arm/mail/
+  main/binary-arm/math/
+  main/binary-arm/misc/
+
+
+lchmod
+  I don't think we handle this properly on systems that don't have the
+  call.  Are there any such?
+
+
+Cross-test versions
+  Part of the regression suite should be making sure that we don't
+  break backwards compatibility: old clients vs new servers and so
+  on.  Ideally we would test the cross product of versions.  
+
+  It might be sufficient to test downloads from well-known public
+  rsync servers running different versions of rsync.  This will give
+  some testing and also be the most common case for having different
+  versions and not being able to upgrade.
+
+--no-blocking-io might be broken
+
+  in the same way as --no-whole-file; somebody needs to check.
+
+Do not rely on having a group called "nobody"
+
+  http://www.linuxbase.org/spec/refspecs/LSB_1.1.0/gLSB/usernames.html
+
+  On Debian it's "nogroup"
+
+DAEMON --------------------------------------------------------------
+
+server-imposed bandwidth limits
+
+rsyncd over ssh
+
+  There are already some patches to do this.
+
+  BitKeeper uses a server whose login shell is set to bkd.  That's
+  probably a reasonable approach.
+
+
+FEATURES ------------------------------------------------------------
+
+
+--dry-run is too dry
+
+  Mark Santcroos points out that -n fails to list files which have
+  only metadata changes, though it probably should.
+
+  There may be a Debian bug about this as well.
+
+
+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
+
+
+supplementary groups
+
+  Perhaps allow supplementary groups to be specified in rsyncd.conf;
+  then make the first one the primary gid and all the rest be
+  supplementary gids.
+
+
+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.
+
+
+
+Handling IPv6 on old machines
+
+  The KAME IPv6 patch is nice in theory but has proved a bit of a
+  nightmare in practice.  The basic idea of their patch is that rsync
+  is rewritten to use the new getaddrinfo()/getnameinfo() interface,
+  rather than gethostbyname()/gethostbyaddr() as in rsync 2.4.6.
+  Systems that don't have the new interface are handled by providing
+  our own implementation in lib/, which is selectively linked in.
+
+  The problem with this is that it is really hard to get right on
+  platforms that have a half-working implementation, so redefining
+  these functions clashes with system headers, and leaving them out
+  breaks.  This affects at least OSF/1, RedHat 5, and Cobalt, which
+  are moderately improtant.
+
+  Perhaps the simplest solution would be to have two different files
+  implementing the same interface, and choose either the new or the
+  old API.  This is probably necessary for systems that e.g. have
+  IPv6, but gethostbyaddr() can't handle it.  The Linux manpage claims
+  this is currently the case.
+
+  In fact, our internal sockets interface (things like
+  open_socket_out(), etc) is much narrower than the getaddrinfo()
+  interface, and so probably simpler to get right.  In addition, the
+  old code is known to work well on old machines.
+
+  We could drop the rather large lib/getaddrinfo files.
+
+
+Other IPv6 stuff:
+  
+  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.
+
+  If we get an error writing to a socket, then we should perhaps
+  continue trying to read to see if an error message comes across
+  explaining why the socket is closed.  I'm not sure if this would
+  work, but it would certainly make our messages more helpful.
+
+  What happens if a directory is missing -x attributes.  Do we lose
+  our load?  (Debian #28416) Probably fixed now, but a test case would
+  be good.
+
+
+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.
+
+  If a child of the rsync daemon dies with a signal, we should notice
+  that when we reap it and log a message.
+
+  Keep stderr and stdout properly separated (Debian #23626)
+
+  After we get the @RSYNCD greeting from the server, we know it's
+  version but we have not yet sent the command line, so we could just
+  remove the -z option if the server is too old.
+
+  For ssh invocation it's not so simple, because we actually use the
+  command line to start the remote process.  However, we only actually
+  do compression in token.c, and we could therefore once we discover
+  the remote version emit an error if it's too old.  I'm not sure if
+  that's a good tradeoff or not.
+
+
+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.
+
+FAT support
+
+  rsync to a FAT partition on a Unix machine doesn't work very well at
+  the moment.  I think we get errors about invalid filenames and
+  perhaps also trying to do atomic renames.
+
+  I guess the code to do this is currently #ifdef'd on Windows;
+  perhaps we ought to intelligently fall back to it on Unix too.
+
+
+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
+
+TDB:
+
+  Rather than storing the file list in memory, store it in a TDB.
+
+  This *might* make memory usage lower while building the file list.
+
+  Hashtable lookup will mean files are not transmitted in order,
+  though... hm.
+
+  This would neatly eliminate one of the major post-fork shared data
+  structures.
+
+
+chmod:
+
+  On 12 Mar 2002, Dave Dykstra <dwd@bell-labs.com> wrote: > If we
+would add an option to do that functionality, I would vote for one >
+that was more general which could mask off any set of permission bits
+and > possibly add any set of bits.  Perhaps a chmod-like syntax if it
+could be > implemented simply.
+
+  I think that would be good too.  For example, people uploading files
+  to a web server might like to say
+
+  rsync -avzP --chmod a+rX ./ sourcefrog.net:/home/www/sourcefrog/
+
+  Ideally the patch would implement as many of the gnu chmod semantics
+  as possible.  I think the mode parser should be a separate function
+  that passes back something like (mask,set) description to the rest
+  of the program.  For bonus points there would be a test case for the
+  parser.
+
+  Possibly also --chown
+
+  (Debian #23628)
+
+
+--diff
+
+  Allow people to specify the diff command.  (Might want to use wdiff,
+  gnudiff, etc.)
+
+  Just diff the temporary file with the destination file, and delete
+  the tmp file rather than moving it into place.
+
+  Interaction with --partial.
+
+  Security interactions with daemon mode?
+
+  (Suggestion from david.e.sewell)
+
+
+Incorrect timestamps (Debian #100295)
+
+  A bit hard to believe, but apparently it happens.
+
+
+Check "refuse options works"
+
+  We need a test case for this...
+
+  Was this broken when we changed to popt?
+
+
+PERFORMANCE ----------------------------------------------------------
+
+MD4 file_sum
+
+  If we're doing a local transfer, or using -W, then perhaps don't
+  send the file checksum.  If we're doing a local transfer, then
+  calculating MD4 checksums uses 90% of CPU and is unlikely to be
+  useful.
+
+  Indeed for transfers over zlib or ssh we can also rely on the
+  transport to have quite strong protection against corruption.
+
+  Perhaps we should have an option to disable this, analogous to
+--whole-file, although it would default to disabled.  The file
+checksum takes up a definite space in the protocol -- we can either
+set it to 0, or perhaps just leave it out.
+
+MD4
+
+  Perhaps borrow an assembler MD4 from someone?
+
+  Make sure we call MD4 with properly-sized blocks whenever possible
+  to avoid copying into the residue region?
+
+String area code
+
+  Test whether this is actually faster than just using malloc().  If
+  it's not (anymore), throw it out.
+	  
+
+PLATFORMS ------------------------------------------------------------
+
+Win32
+
+  Don't detach, because this messes up --srvany.
+
+  http://sources.redhat.com/ml/cygwin/2001-08/msg00234.html
+
+
+DEVELOPMENT ----------------------------------------------------------
+
+Splint
+
+  Build rsync with SPLINT to try to find security holes.  Add
+  annotations as necessary.  Keep track of the number of warnings
+  found initially, and see how many of them are real bugs, or real
+  security bugs.  Knowing the percentage of likely hits would be
+  really interesting for other projects.
+
+Torture test
+
+  Something that just keeps running rsync continuously over a data set
+  likely to generate problems.
+
+Cross-testing
+
+  Run current rsync versions against significant past releases.
+
+Memory debugger
+
+  jra recommends Valgrind:
+
+    http://devel-home.kde.org/~sewardj/
+
+Release script
+  
+  Update spec files
+
+  Build tar file; upload
+
+  Send announcement to mailing list and c.o.l.a.
+  
+  Make freshmeat announcement
+
+  Update web site
+
+
+
+TESTING --------------------------------------------------------------
+
+Cross-test versions
+
+  Part of the regression suite should be making sure that we don't
+  break backwards compatibility: old clients vs new servers and so on.
+  Ideally we would test both up and down from the current release to
+  all old versions.
+
+  We might need to omit broken old versions, or versions in which
+  particular functionality is broken
+
+  It might be sufficient to test downloads from well-known public
+  rsync servers running different versions of rsync.  This will give
+  some testing and also be the most common case for having different
+  versions and not being able to upgrade.
+
+
+Test on kernel source
+
+  Download all versions of kernel; unpack, sync between them.  Also
+  sync between uncompressed tarballs.  Compare directories after
+  transfer.
+
+  Use local mode; ssh; daemon; --whole-file and --no-whole-file.
+
+  Use awk to pull out the 'speedup' number for each transfer.  Make
+  sure it is >= x.
+
+
+Test large files
+
+  Sparse and non-sparse
+
+Mutator program
+
+  Insert bytes, delete bytes, swap blocks, ...
+
+configure option to enable dangerous tests
+
+If tests are skipped, say why.
+
+Test daemon feature to disallow particular options.
+
+Pipe program that makes slow/jerky connections.
+
+Versions of read() and write() that corrupt the stream, or abruptly
+fail
+
+Separate makefile target to run rough tests -- or perhaps just run
+them every time?
+
+Test "refuse options" works
+
+  What about for --recursive?
+
+  If you specify an unrecognized option here, you should get an error.
+
+
+DOCUMENTATION --------------------------------------------------------
+
+Update README
+
+Keep list of open issues and todos on the web site
+
+Update web site from CVS
+
+
+Perhaps redo manual as SGML
+
+  The man page is getting rather large, and there is more information
+  that ought to be added.
+
+  TexInfo source is probably a dying format.
+
+  Linuxdoc looks like the most likely contender.  I know DocBook is
+  favoured by some people, but it's so bloody verbose, even with emacs
+  support.
+
+
+BUILD FARM -----------------------------------------------------------
+
+Add machines
+
+  Cygwin (on different versions of Win32?)
+
+  HP-UX variants (via HP?)
+
+  SCO
+
+
+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.
+
+  If a child of the rsync daemon dies with a signal, we should notice
+  that when we reap it and log a message.
+
+  Keep stderr and stdout properly separated (Debian #23626)
+
+  Use a separate function for reporting errors; prefix it with
+  "rsync:" or "rsync(remote)", or perhaps even "rsync(local
+  generator): ".
+
+verbose output
+  
+  Indicate whether files are new, updated, or deleted
+
+  At end of transfer, show how many files were or were not transferred
+  correctly.
+
+-vv
+
+  Explain *why* every file is transferred or not (e.g. "local mtime
+  123123 newer than 1283198")
+
+
+debugging of daemon
+
+  Add an rsyncd.conf parameter to turn on debugging on the server.
+
+
+
+NICE -----------------------------------------------------------------
+
+--no-detach and --no-fork options
+
+  Very useful for debugging.  Also good when running under a
+  daemon-monitoring process that tries to restart the service when the
+  parent exits.
+
+hang/timeout friendliness
+
+internationalization
+
+  Change to using gettext().  Probably need to ship this for platforms
+  that don't have it.
+
+  Solicit translations.
+
+  Does anyone care?  Before we bother modifying the code, we ought to
+  get the manual translated first, because that's possibly more useful
+  and at any rate demonstrates desire.
+
+rsyncsh
+
+   Write a small emulation of interactive ftp as a Pythonn program
+   that calls rsync.  Commands such as "cd", "ls", "ls *.c" etc map
+   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.
+
+
+RELATED PROJECTS -----------------------------------------------------
+
+http://rsync.samba.org/rsync-and-debian/
+
+rsyncable gzip patch
+
+  Exhaustive, tortuous testing
+
+  Cleanups?
+
+rsyncsplit as alternative to real integration with gzip?
+
+reverse rsync over HTTP Range
+
+  Goswin Brederlow suggested this on Debian; I think tridge and I
+  talked about it previous in relation to rproxy.
+
+

access.c

@@ -0,0 +1,259 @@
+/* 
+   Copyright (C) Andrew Tridgell 1998
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+  hosts allow/deny code for rsync
+
+  */
+
+#include "rsync.h"
+
+
+static int match_hostname(char *host, char *tok)
+{
+	if (!host || !*host) return 0;
+	return wildmatch(tok, host);
+}
+
+static int match_binary(char *b1, char *b2, char *mask, int addrlen)
+{
+	int i;
+
+	for (i=0; i<addrlen; i++) {
+		if ((b1[i]^b2[i])&mask[i]) {
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+static void make_mask(char *mask, int plen, int addrlen) {
+	int w, b;
+
+	w = plen >> 3;
+	b = plen & 0x7;
+
+	if (w)
+		memset(mask, 0xff, w);
+	if (w < addrlen)
+		mask[w] = 0xff & (0xff<<(8-b));
+	if (w+1 < addrlen)
+		memset(mask+w+1, 0, addrlen-w-1);
+
+	return;
+}
+
+static int match_address(char *addr, char *tok)
+{
+	char *p;
+	struct addrinfo hints, *resa, *rest;
+	int gai;
+	int ret = 0;
+	int addrlen = 0;
+#ifdef HAVE_STRTOL
+	long int bits;
+#else
+	int bits;
+#endif
+	char mask[16];
+	char *a = NULL, *t = NULL;
+	unsigned int len;
+
+	if (!addr || !*addr) return 0;
+
+	p = strchr(tok,'/');
+	if (p) {
+		*p = '\0';
+		len = p - tok;
+	}
+	else
+		len = strlen(tok);
+
+	/* Fail quietly if tok is a hostname (not an address) */
+	if (strspn(tok, ".0123456789") != len
+#ifdef INET6
+	 && !strchr(tok, ':')
+#endif
+		) return 0;
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = PF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+#ifdef AI_NUMERICHOST
+	hints.ai_flags = AI_NUMERICHOST;
+#endif
+
+	gai = getaddrinfo(addr, NULL, &hints, &resa);
+	if (gai) return 0;
+
+	gai = getaddrinfo(tok, NULL, &hints, &rest);
+	if (p)
+		*p++ = '/';
+	if (gai) {
+		rprintf(FERROR,
+			"error matching address %s: %s\n",
+			tok,
+			gai_strerror(gai));
+		freeaddrinfo(resa);
+		return 0;
+	}
+
+	if (rest->ai_family != resa->ai_family) {
+		ret = 0;
+		goto out;
+	}
+
+	switch(resa->ai_family) {
+	case PF_INET:
+		a = (char *)&((struct sockaddr_in *)resa->ai_addr)->sin_addr;
+		t = (char *)&((struct sockaddr_in *)rest->ai_addr)->sin_addr;
+		addrlen = 4;
+
+		break;
+
+#ifdef INET6
+	case PF_INET6:
+	    {
+		struct sockaddr_in6 *sin6a, *sin6t;
+
+		sin6a = (struct sockaddr_in6 *)resa->ai_addr;
+		sin6t = (struct sockaddr_in6 *)rest->ai_addr;
+
+		a = (char *)&sin6a->sin6_addr;
+		t = (char *)&sin6t->sin6_addr;
+
+		addrlen = 16;
+
+#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
+		if (sin6t->sin6_scope_id &&
+		    sin6a->sin6_scope_id != sin6t->sin6_scope_id) {
+			ret = 0;
+			goto out;
+		}
+#endif
+
+		break;
+	    }
+#endif
+	default:
+	    rprintf(FERROR,"unknown family %u\n", rest->ai_family);
+	    ret = 0;
+	    goto out;
+	}
+
+	bits = -1;
+	if (p) {
+		if (inet_pton(resa->ai_addr->sa_family, p, mask) <= 0) {
+#ifdef HAVE_STRTOL
+			char *ep = NULL;
+#else
+			unsigned char *pp;
+#endif
+
+#ifdef HAVE_STRTOL
+			bits = strtol(p, &ep, 10);
+			if (!*p || *ep) {
+				rprintf(FERROR,"malformed mask in %s\n", tok);
+				ret = 0;
+				goto out;
+			}
+#else
+			for (pp = (unsigned char *)p; *pp; pp++) {
+				if (!isascii(*pp) || !isdigit(*pp)) {
+					rprintf(FERROR,"malformed mask in %s\n", tok);
+					ret = 0;
+					goto out;
+				}
+			}
+			bits = atoi(p);
+#endif
+			if (bits == 0) {
+				ret = 1;
+				goto out;
+			}
+			if (bits < 0 || bits > (addrlen << 3)) {
+				rprintf(FERROR,"malformed mask in %s\n", tok);
+				ret = 0;
+				goto out;
+			}
+		}
+	} else {
+		bits = 128;
+	}
+
+	if (bits >= 0)
+		make_mask(mask, bits, addrlen);
+
+	ret = match_binary(a, t, mask, addrlen);
+
+out:
+	freeaddrinfo(resa);
+	freeaddrinfo(rest);
+	return ret;
+}
+
+static int access_match(char *list, char *addr, char *host)
+{
+	char *tok;
+	char *list2 = strdup(list);
+
+	if (!list2) out_of_memory("access_match");
+
+	strlower(list2);
+	if (host) strlower(host);
+
+	for (tok=strtok(list2," ,\t"); tok; tok=strtok(NULL," ,\t")) {
+		if (match_hostname(host, tok) || match_address(addr, tok)) {
+			free(list2);
+			return 1;
+		}
+	}
+
+	free(list2);
+	return 0;
+}
+
+int allow_access(char *addr, char *host, char *allow_list, char *deny_list)
+{
+	/* if theres no deny list and no allow list then allow access */
+	if ((!deny_list || !*deny_list) && (!allow_list || !*allow_list))
+		return 1;
+
+	/* if there is an allow list but no deny list then allow only hosts
+	   on the allow list */
+	if (!deny_list || !*deny_list)
+		return(access_match(allow_list, addr, host));
+
+	/* if theres a deny list but no allow list then allow
+	   all hosts not on the deny list */
+	if (!allow_list || !*allow_list)
+		return(!access_match(deny_list,addr,host));
+
+	/* if there are both type of list then allow all hosts on the
+           allow list */
+	if (access_match(allow_list,addr,host))
+		return 1;
+
+	/* if there are both type of list and it's not on the allow then
+	   allow it if its not on the deny */
+	if (access_match(deny_list,addr,host))
+		return 0;
+
+	return 1;
+}

acconfig.h

@@ -0,0 +1,11 @@
+#undef ino_t
+#undef HAVE_CONNECT
+#undef HAVE_SHORT_INO_T
+#undef HAVE_GETOPT_LONG
+#undef REPLACE_INET_NTOA
+#undef REPLACE_INET_ATON
+#undef HAVE_GETTIMEOFDAY_TZ
+#undef ENABLE_IPV6
+#undef HAVE_SOCKADDR_LEN
+#undef HAVE_SOCKADDR_IN6_SCOPE_ID
+#undef HAVE_SOCKETPAIR

aclocal.m4

@@ -0,0 +1,71 @@
+dnl AC_VALIDATE_CACHE_SYSTEM_TYPE[(cmd)]
+dnl if the cache file is inconsistent with the current host,
+dnl target and build system types, execute CMD or print a default
+dnl error message.
+AC_DEFUN(AC_VALIDATE_CACHE_SYSTEM_TYPE, [
+    AC_REQUIRE([AC_CANONICAL_SYSTEM])
+    AC_MSG_CHECKING([config.cache system type])
+    if { test x"${ac_cv_host_system_type+set}" = x"set" &&
+         test x"$ac_cv_host_system_type" != x"$host"; } ||
+       { test x"${ac_cv_build_system_type+set}" = x"set" &&
+         test x"$ac_cv_build_system_type" != x"$build"; } ||
+       { test x"${ac_cv_target_system_type+set}" = x"set" &&
+         test x"$ac_cv_target_system_type" != x"$target"; }; then
+	AC_MSG_RESULT([different])
+	ifelse($#, 1, [$1],
+		[AC_MSG_ERROR(["you must remove config.cache and restart configure"])])
+    else
+	AC_MSG_RESULT([same])
+    fi
+    ac_cv_host_system_type="$host"
+    ac_cv_build_system_type="$build"
+    ac_cv_target_system_type="$target"
+])
+
+dnl Check for socklen_t: historically on BSD it is an int, and in
+dnl POSIX 1g it is a type of its own, but some platforms use different
+dnl types for the argument to getsockopt, getpeername, etc.  So we
+dnl have to test to find something that will work.
+
+dnl This is no good, because passing the wrong pointer on C compilers is
+dnl likely to only generate a warning, not an error.  We don't call this at
+dnl the moment.
+
+AC_DEFUN([TYPE_SOCKLEN_T],
+[
+   AC_CHECK_TYPE([socklen_t], ,[
+      AC_MSG_CHECKING([for socklen_t equivalent])
+      AC_CACHE_VAL([rsync_cv_socklen_t_equiv],
+      [
+         # Systems have either "struct sockaddr *" or
+         # "void *" as the second argument to getpeername
+         rsync_cv_socklen_t_equiv=
+         for arg2 in "struct sockaddr" void; do
+            for t in int size_t unsigned long "unsigned long"; do
+               AC_TRY_COMPILE([
+#include <sys/types.h>
+#include <sys/socket.h>
+
+                  int getpeername (int, $arg2 *, $t *);
+               ],[
+                  $t len;
+                  getpeername(0,0,&len);
+               ],[
+                  rsync_cv_socklen_t_equiv="$t"
+                  break
+               ])
+            done
+         done
+
+         if test "x$rsync_cv_socklen_t_equiv" = x; then
+            AC_MSG_ERROR([Cannot find a type to use in place of socklen_t])
+         fi
+      ])
+      AC_MSG_RESULT($rsync_cv_socklen_t_equiv)
+      AC_DEFINE_UNQUOTED(socklen_t, $rsync_cv_socklen_t_equiv,
+			[type to use in place of socklen_t if not defined])],
+      [#include <sys/types.h>
+#include <sys/socket.h>])
+])
+
+

authenticate.c

@@ -0,0 +1,295 @@
+/* -*- c-file-style: "linux"; -*-
+   
+   Copyright (C) 1998-2000 by Andrew Tridgell 
+   
+   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.
+*/
+
+/* support rsync authentication */
+#include "rsync.h"
+
+/***************************************************************************
+encode a buffer using base64 - simple and slow algorithm. null terminates
+the result.
+  ***************************************************************************/
+static void base64_encode(char *buf, int len, char *out)
+{
+	char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	int bit_offset, byte_offset, idx, i;
+	unsigned char *d = (unsigned char *)buf;
+	int bytes = (len*8 + 5)/6;
+
+	memset(out, 0, bytes+1);
+
+	for (i=0;i<bytes;i++) {
+		byte_offset = (i*6)/8;
+		bit_offset = (i*6)%8;
+		if (bit_offset < 3) {
+			idx = (d[byte_offset] >> (2-bit_offset)) & 0x3F;
+		} else {
+			idx = (d[byte_offset] << (bit_offset-2)) & 0x3F;
+			if (byte_offset+1 < len) {
+				idx |= (d[byte_offset+1] >> (8-(bit_offset-2)));
+			}
+		}
+		out[i] = b64[idx];
+	}
+}
+
+/* create a 16 byte challenge buffer */
+static void gen_challenge(char *addr, char *challenge)
+{
+	char input[32];
+	struct timeval tv;
+
+	memset(input, 0, sizeof(input));
+
+	strlcpy((char *)input, addr, 17);
+	sys_gettimeofday(&tv);
+	SIVAL(input, 16, tv.tv_sec);
+	SIVAL(input, 20, tv.tv_usec);
+	SIVAL(input, 24, getpid());
+
+	sum_init();
+	sum_update(input, sizeof(input));
+	sum_end(challenge);
+}
+
+
+/* return the secret for a user from the sercret file. maximum length
+   is len. null terminate it */
+static int get_secret(int module, char *user, char *secret, int len)
+{
+	char *fname = lp_secrets_file(module);
+	int fd, found=0;
+	char line[MAXPATHLEN];
+	char *p, *pass=NULL;
+	STRUCT_STAT st;
+	int ok = 1;
+	extern int am_root;
+
+	if (!fname || !*fname) return 0;
+
+	fd = open(fname,O_RDONLY);
+	if (fd == -1) return 0;
+
+	if (do_stat(fname, &st) == -1) {
+		rsyserr(FERROR, errno, "stat(%s)", fname);
+		ok = 0;
+	} else if (lp_strict_modes(module)) {
+		if ((st.st_mode & 06) != 0) {
+			rprintf(FERROR,"secrets file must not be other-accessible (see strict modes option)\n");
+			ok = 0;
+		} else if (am_root && (st.st_uid != 0)) {
+			rprintf(FERROR,"secrets file must be owned by root when running as root (see strict modes)\n");
+			ok = 0;
+		}
+	}
+	if (!ok) {
+		rprintf(FERROR,"continuing without secrets file\n");
+		close(fd);
+		return 0;
+	}
+
+	while (!found) {
+		int i = 0;
+		memset(line, 0, sizeof line);
+		while ((size_t) i < (sizeof(line)-1)) {
+			if (read(fd, &line[i], 1) != 1) {
+				memset(line, 0, sizeof(line));
+				close(fd);
+				return 0;
+			}
+			if (line[i] == '\r') continue;
+			if (line[i] == '\n') break;
+			i++;
+		}
+		line[i] = 0;
+		if (line[0] == '#') continue;
+		p = strchr(line,':');
+		if (!p) continue;
+		*p = 0;
+		if (strcmp(user, line)) continue;
+		pass = p+1;
+		found = 1;
+	}
+
+	close(fd);
+	if (!found) return 0;
+
+	strlcpy(secret, pass, len);
+	return 1;
+}
+
+static char *getpassf(char *filename)
+{
+	char buffer[100];
+	int fd=0;
+	STRUCT_STAT st;
+	int ok = 1;
+	extern int am_root;
+	char *envpw=getenv("RSYNC_PASSWORD");
+
+	if (!filename) return NULL;
+
+	if ( (fd=open(filename,O_RDONLY)) == -1) {
+		rsyserr(FERROR, errno, "could not open password file \"%s\"",filename);
+		if (envpw) rprintf(FERROR,"falling back to RSYNC_PASSWORD environment variable.\n");	
+		return NULL;
+	}
+	
+	if (do_stat(filename, &st) == -1) {
+		rsyserr(FERROR, errno, "stat(%s)", filename);
+		ok = 0;
+	} else if ((st.st_mode & 06) != 0) {
+		rprintf(FERROR,"password file must not be other-accessible\n");
+		ok = 0;
+	} else if (am_root && (st.st_uid != 0)) {
+		rprintf(FERROR,"password file must be owned by root when running as root\n");
+		ok = 0;
+	}
+	if (!ok) {
+		rprintf(FERROR,"continuing without password file\n");
+		if (envpw) rprintf(FERROR,"using RSYNC_PASSWORD environment variable.\n");
+		close(fd);
+		return NULL;
+	}
+
+	if (envpw) rprintf(FERROR,"RSYNC_PASSWORD environment variable ignored\n");
+
+	buffer[sizeof(buffer)-1]='\0';
+	if (read(fd,buffer,sizeof(buffer)-1) > 0)
+	{
+		char *p = strtok(buffer,"\n\r");
+		close(fd);
+		if (p) p = strdup(p);
+		return p;
+	}	
+
+	return NULL;
+}
+
+/* generate a 16 byte hash from a password and challenge */
+static void generate_hash(char *in, char *challenge, char *out)
+{
+	char buf[16];
+
+	sum_init();
+	sum_update(in, strlen(in));
+	sum_update(challenge, strlen(challenge));
+	sum_end(buf);
+
+	base64_encode(buf, 16, out);
+}
+
+/* possible negotiate authentication with the client. Use "leader" to
+   start off the auth if necessary 
+
+   return NULL if authentication failed
+
+   return "" if anonymous access
+
+   otherwise return username
+*/
+char *auth_server(int f_in, int f_out, int module, char *addr, char *leader)
+{
+	char *users = lp_auth_users(module);
+	char challenge[16];
+	char b64_challenge[30];
+	char line[MAXPATHLEN];
+	static char user[100];
+	char secret[100];
+	char pass[30];
+	char pass2[30];
+	char *tok;
+
+	/* if no auth list then allow anyone in! */
+	if (!users || !*users) return "";
+
+	gen_challenge(addr, challenge);
+	
+	base64_encode(challenge, 16, b64_challenge);
+
+	io_printf(f_out, "%s%s\n", leader, b64_challenge);
+
+	if (!read_line(f_in, line, sizeof(line)-1)) {
+		return NULL;
+	}
+
+	memset(user, 0, sizeof(user));
+	memset(pass, 0, sizeof(pass));
+
+	if (sscanf(line,"%99s %29s", user, pass) != 2) {
+		return NULL;
+	}
+	
+	users = strdup(users);
+	if (!users) return NULL;
+
+	for (tok=strtok(users," ,\t"); tok; tok = strtok(NULL," ,\t")) {
+		if (wildmatch(tok, user)) break;
+	}
+	free(users);
+
+	if (!tok) {
+		return NULL;
+	}
+	
+	memset(secret, 0, sizeof(secret));
+	if (!get_secret(module, user, secret, sizeof(secret)-1)) {
+		memset(secret, 0, sizeof(secret));
+		return NULL;
+	}
+
+	generate_hash(secret, b64_challenge, pass2);
+	memset(secret, 0, sizeof(secret));
+	
+	if (strcmp(pass, pass2) == 0)
+		return user;
+
+	return NULL;
+}
+
+
+void auth_client(int fd, char *user, char *challenge)
+{
+	char *pass;
+	char pass2[30];
+	extern char *password_file;
+
+	if (!user || !*user) return;
+
+	if (!(pass=getpassf(password_file)) && !(pass=getenv("RSYNC_PASSWORD"))) {
+		/* XXX: cyeoh says that getpass is deprecated, because
+		 * it may return a truncated password on some systems,
+		 * and it is not in the LSB.
+                 *
+                 * Andrew Klein says that getpassphrase() is present
+                 * on Solaris and reads up to 256 characters.
+                 *
+                 * OpenBSD has a readpassphrase() that might be more suitable.
+                 */
+		pass = getpass("Password: ");
+	}
+
+	if (!pass || !*pass) {
+		pass = "";
+	}
+
+	generate_hash(pass, challenge, pass2);
+	io_printf(fd, "%s %s\n", user, pass2);
+}
+
+

backup.c

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

batch.c

@@ -0,0 +1,605 @@
+/* -*- c-file-style: "linux" -*-
+   
+   Weiss 1/1999
+   Batch utilities for rsync.
+
+*/
+
+#include "rsync.h"
+#include <time.h>
+
+extern char *batch_prefix;
+
+struct file_list *batch_flist;
+
+static char rsync_flist_file[] = ".rsync_flist";
+static char rsync_csums_file[] = ".rsync_csums";
+static char rsync_delta_file[] = ".rsync_delta";
+static char rsync_argvs_file[] = ".rsync_argvs";
+
+static int fdb;
+static int fdb_delta;
+static int fdb_open;
+static int fdb_close;
+
+void write_batch_flist_file(char *buff, int bytes_to_write)
+{
+	char filename[MAXPATHLEN];
+
+	if (fdb_open) {
+		/* Set up file extension */
+		strlcpy(filename, batch_prefix, sizeof(filename));
+		strlcat(filename, rsync_flist_file, sizeof(filename));
+
+		/*
+		 * Open batch flist file for writing;
+		 * create it if it doesn't exist
+		 */
+		fdb = do_open(filename, O_WRONLY | O_CREAT | O_TRUNC,
+			    S_IREAD | S_IWRITE);
+		if (fdb == -1) {
+			rprintf(FERROR, "Batch file %s open error: %s\n",
+				filename, strerror(errno));
+			close(fdb);
+			exit_cleanup(1);
+		}
+		fdb_open = 0;
+	}
+
+	/* Write buffer to batch flist file */
+
+	if (write(fdb, buff, bytes_to_write) == -1) {
+		rprintf(FERROR, "Batch file %s write error: %s\n",
+			filename, strerror(errno));
+		close(fdb);
+		exit_cleanup(1);
+	}
+
+	if (fdb_close) {
+		close(fdb);
+	}
+}
+
+void write_batch_flist_info(int flist_count, struct file_struct **fptr)
+{
+	int i;
+	int bytes_to_write;
+
+	/* Write flist info to batch file */
+
+	bytes_to_write =
+	    sizeof(unsigned) +
+	    sizeof(time_t) +
+	    sizeof(OFF_T) +
+	    sizeof(mode_t) +
+	    sizeof(INO64_T) +
+	    sizeof(DEV64_T) +
+	    sizeof(DEV64_T) +
+	    sizeof(uid_t) +
+	    sizeof(gid_t);
+
+	fdb_open = 1;
+	fdb_close = 0;
+
+	for (i = 0; i < flist_count; i++) {
+		write_batch_flist_file((char *) fptr[i], bytes_to_write);
+		write_char_bufs(fptr[i]->basename);
+		write_char_bufs(fptr[i]->dirname);
+		write_char_bufs(fptr[i]->basedir);
+		write_char_bufs(fptr[i]->link);
+		if (i == flist_count - 1) {
+			fdb_close = 1;
+		}
+		write_char_bufs(fptr[i]->sum);
+	}
+}
+
+void write_char_bufs(char *buf)
+{
+	/* Write the size of the string which will follow  */
+
+	char b[4];
+
+	SIVAL(b, 0, buf != NULL ? strlen(buf) : 0);
+
+	write_batch_flist_file(b, sizeof(int));
+
+	/*  Write the string if there is one */
+
+	if (buf != NULL) {
+		write_batch_flist_file(buf, strlen(buf));
+	}
+}
+
+void write_batch_argvs_file(int argc, char *argv[])
+{
+	int fdb;
+	int i;
+	char buff[256]; /* XXX */
+	char buff2[MAXPATHLEN + 6];
+	char filename[MAXPATHLEN];
+
+	/* Set up file extension */
+	strlcpy(filename, batch_prefix, sizeof(filename));
+	strlcat(filename, rsync_argvs_file, sizeof(filename));
+
+	/*
+	 * Open batch argvs file for writing;
+	 * create it if it doesn't exist
+	 */
+	fdb = do_open(filename, O_WRONLY | O_CREAT | O_TRUNC,
+		      S_IREAD | S_IWRITE | S_IEXEC);
+	if (fdb == -1) {
+		rprintf(FERROR, "Batch file %s open error: %s\n",
+			filename, strerror(errno));
+		close(fdb);
+		exit_cleanup(1);
+	}
+	buff[0] = '\0';
+
+	/* Write argvs info to batch file */
+
+	for (i = 0; i < argc; ++i) {
+		if (i == argc - 2) /* Skip source directory on cmdline */
+		    continue;
+		/*
+		 * FIXME:
+		 * I think directly manipulating argv[] is probably bogus
+		 */
+		if (!strncmp(argv[i], "--write-batch",
+			strlen("--write-batch"))) {
+			/* Safer to change it here than script */
+			/*
+			 * Change to --read-batch=prefix
+			 * to get ready for remote
+			 */
+			strlcat(buff, "--read-batch=", sizeof(buff));
+			strlcat(buff, batch_prefix, sizeof(buff));
+		} else
+		if (i == argc - 1) {
+		    snprintf(buff2, sizeof(buff2), "${1:-%s}", argv[i]);
+		    strlcat(buff, buff2, sizeof(buff));
+		}
+		else {
+			strlcat(buff, argv[i], sizeof(buff));
+		}
+
+		if (i < (argc - 1)) {
+			strlcat(buff, " ", sizeof(buff));
+		}
+	}
+	strlcat(buff, "\n", sizeof(buff));
+	if (!write(fdb, buff, strlen(buff))) {
+		rprintf(FERROR, "Batch file %s write error: %s\n",
+			filename, strerror(errno));
+		close(fdb);
+		exit_cleanup(1);
+	}
+	close(fdb);
+}
+
+struct file_list *create_flist_from_batch(void)
+{
+	unsigned char flags;
+
+	fdb_open = 1;
+	fdb_close = 0;
+
+	batch_flist = new(struct file_list);
+	if (!batch_flist) {
+		out_of_memory("create_flist_from_batch");
+	}
+	batch_flist->count = 0;
+	batch_flist->malloced = 1000;
+	batch_flist->files = new_array(struct file_struct *,
+				       batch_flist->malloced);
+	if (!batch_flist->files) {
+		out_of_memory("create_flist_from_batch");
+	}
+
+	for (flags = read_batch_flags(); flags; flags = read_batch_flags()) {
+
+		int i = batch_flist->count;
+
+		if (i >= batch_flist->malloced) {
+			if (batch_flist->malloced < 1000)
+				batch_flist->malloced += 1000;
+			else
+				batch_flist->malloced *= 2;
+			batch_flist->files
+				= realloc_array(batch_flist->files,
+						struct file_struct *,
+						batch_flist->malloced);
+			if (!batch_flist->files)
+				out_of_memory("create_flist_from_batch");
+		}
+		read_batch_flist_info(&batch_flist->files[i]);
+		batch_flist->files[i]->flags = flags;
+
+		batch_flist->count++;
+	}
+
+	return batch_flist;
+}
+
+int read_batch_flist_file(char *buff, int len)
+{
+	int bytes_read;
+	char filename[MAXPATHLEN];
+
+	if (fdb_open) {
+		/* Set up file extension */
+		strlcpy(filename, batch_prefix, sizeof(filename));
+		strlcat(filename, rsync_flist_file, sizeof(filename));
+
+		/* Open batch flist file for reading */
+		fdb = do_open(filename, O_RDONLY, 0);
+		if (fdb == -1) {
+			rprintf(FERROR, "Batch file %s open error: %s\n",
+				filename, strerror(errno));
+			close(fdb);
+			exit_cleanup(1);
+		}
+		fdb_open = 0;
+	}
+
+	/* Read flist batch file */
+
+	switch (bytes_read = read(fdb, buff, len)) {
+	    case -1:
+		rprintf(FERROR, "Batch file %s read error: %s\n",
+			filename, strerror(errno));
+		close(fdb);
+		exit_cleanup(1);
+		break;
+	    case 0:	/* EOF */
+		close(fdb);
+	}
+
+	return bytes_read;
+}
+
+unsigned char read_batch_flags(void)
+{
+	int flags;
+
+	if (read_batch_flist_file((char *) &flags, 4)) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+void read_batch_flist_info(struct file_struct **fptr)
+{
+	int int_str_len;
+	char char_str_len[4];
+	char buff[256];
+	struct file_struct *file;
+
+	file = new(struct file_struct);
+	if (!file)
+		out_of_memory("read_batch_flist_info");
+	memset((char *) file, 0, sizeof(*file));
+
+	*fptr = file;
+
+	/*
+	 * Keep these in sync with bytes_to_write assignment
+	 * in write_batch_flist_info()
+	 */
+	read_batch_flist_file((char *) &file->modtime, sizeof(time_t));
+	read_batch_flist_file((char *) &file->length, sizeof(OFF_T));
+	read_batch_flist_file((char *) &file->mode, sizeof(mode_t));
+	read_batch_flist_file((char *) &file->inode, sizeof(INO64_T));
+	read_batch_flist_file((char *) &file->dev, sizeof(DEV64_T));
+	read_batch_flist_file((char *) &file->rdev, sizeof(DEV64_T));
+	read_batch_flist_file((char *) &file->uid, sizeof(uid_t));
+	read_batch_flist_file((char *) &file->gid, sizeof(gid_t));
+	read_batch_flist_file(char_str_len, sizeof(char_str_len));
+	int_str_len = IVAL(char_str_len, 0);
+	if (int_str_len > 0) {
+		read_batch_flist_file(buff, int_str_len);
+		buff[int_str_len] = '\0';
+		file->basename = strdup(buff);
+	} else {
+		file->basename = NULL;
+	}
+
+	read_batch_flist_file(char_str_len, sizeof(char_str_len));
+	int_str_len = IVAL(char_str_len, 0);
+	if (int_str_len > 0) {
+		read_batch_flist_file(buff, int_str_len);
+		buff[int_str_len] = '\0';
+		file[0].dirname = strdup(buff);
+	} else {
+		file[0].dirname = NULL;
+	}
+
+	read_batch_flist_file(char_str_len, sizeof(char_str_len));
+	int_str_len = IVAL(char_str_len, 0);
+	if (int_str_len > 0) {
+		read_batch_flist_file(buff, int_str_len);
+		buff[int_str_len] = '\0';
+		file[0].basedir = strdup(buff);
+	} else {
+		file[0].basedir = NULL;
+	}
+
+	read_batch_flist_file(char_str_len, sizeof(char_str_len));
+	int_str_len = IVAL(char_str_len, 0);
+	if (int_str_len > 0) {
+		read_batch_flist_file(buff, int_str_len);
+		buff[int_str_len] = '\0';
+		file[0].link = strdup(buff);
+	} else {
+		file[0].link = NULL;
+	}
+
+	read_batch_flist_file(char_str_len, sizeof(char_str_len));
+	int_str_len = IVAL(char_str_len, 0);
+	if (int_str_len > 0) {
+		read_batch_flist_file(buff, int_str_len);
+		buff[int_str_len] = '\0';
+		file[0].sum = strdup(buff);
+	} else {
+		file[0].sum = NULL;
+	}
+}
+
+void write_batch_csums_file(void *buff, int bytes_to_write)
+{
+	static int fdb_open = 1;
+	char filename[MAXPATHLEN];
+
+	if (fdb_open) {
+		/* Set up file extension */
+		strlcpy(filename, batch_prefix, sizeof(filename));
+		strlcat(filename, rsync_csums_file, sizeof(filename));
+
+		/*
+		 * Open batch csums file for writing;
+		 * create it if it doesn't exist
+		 */
+		fdb = do_open(filename, O_WRONLY | O_CREAT | O_TRUNC,
+			    S_IREAD | S_IWRITE);
+		if (fdb == -1) {
+			rprintf(FERROR, "Batch file %s open error: %s\n",
+				filename, strerror(errno));
+			close(fdb);
+			exit_cleanup(1);
+		}
+		fdb_open = 0;
+	}
+
+	/* Write buffer to batch csums file */
+
+	if (write(fdb, buff, bytes_to_write) == -1) {
+		rprintf(FERROR, "Batch file %s write error: %s\n",
+			filename, strerror(errno));
+		close(fdb);
+		exit_cleanup(1);
+	}
+}
+
+void close_batch_csums_file(void)
+{
+	close(fdb);
+}
+
+
+/**
+ * Write csum info to batch file 
+ *
+ * @todo This will break if s->count is ever larger than maxint.  The
+ * batch code should probably be changed to consistently use the
+ * variable-length integer routines, which is probably a compatible
+ * change.
+ **/
+void write_batch_csum_info(int *flist_entry, int flist_count,
+			   struct sum_struct *s)
+{
+	size_t i;
+	int int_count;
+	extern int csum_length;
+
+	fdb_open = 1;
+
+	write_batch_csums_file(flist_entry, sizeof(int));
+	int_count = s ? (int) s->count : 0;
+	write_batch_csums_file(&int_count, sizeof int_count);
+	
+	if (s) {
+		for (i = 0; i < s->count; i++) {
+			write_batch_csums_file(&s->sums[i].sum1, sizeof(uint32));
+			if ((*flist_entry == flist_count - 1)
+			    && (i == s->count - 1)) {
+				fdb_close = 1;
+			}
+			write_batch_csums_file(s->sums[i].sum2, csum_length);
+		}
+	}
+}
+
+int read_batch_csums_file(char *buff, int len)
+{
+	static int fdb_open = 1;
+	int bytes_read;
+	char filename[MAXPATHLEN];
+
+	if (fdb_open) {
+		/* Set up file extension */
+		strlcpy(filename, batch_prefix, sizeof(filename));
+		strlcat(filename, rsync_csums_file, sizeof(filename));
+
+		/* Open batch flist file for reading */
+		fdb = do_open(filename, O_RDONLY, 0);
+		if (fdb == -1) {
+			rprintf(FERROR, "Batch file %s open error: %s\n",
+				filename, strerror(errno));
+			close(fdb);
+			exit_cleanup(1);
+		}
+		fdb_open = 0;
+	}
+
+	/* Read csums batch file */
+
+	bytes_read = read(fdb, buff, len);
+
+	if (bytes_read == -1) {
+		rprintf(FERROR, "Batch file %s read error: %s\n",
+			filename, strerror(errno));
+		close(fdb);
+		exit_cleanup(1);
+	}
+
+	return bytes_read;
+}
+
+void read_batch_csum_info(int flist_entry, struct sum_struct *s,
+			  int *checksums_match)
+{
+	int i;
+	int file_flist_entry;
+	int file_chunk_ct;
+	uint32 file_sum1;
+	char file_sum2[SUM_LENGTH];
+	extern int csum_length;
+
+	read_batch_csums_file((char *) &file_flist_entry, sizeof(int));
+	if (file_flist_entry != flist_entry) {
+		rprintf(FINFO, "file_flist_entry (%d) != flist_entry (%d)\n",
+			file_flist_entry, flist_entry);
+		close(fdb);
+		exit_cleanup(1);
+
+	} else {
+		read_batch_csums_file((char *) &file_chunk_ct,
+				      sizeof(int));
+		*checksums_match = 1;
+		for (i = 0; i < file_chunk_ct; i++) {
+
+			read_batch_csums_file((char *) &file_sum1,
+					      sizeof(uint32));
+			read_batch_csums_file(file_sum2, csum_length);
+
+			if ((s->sums[i].sum1 != file_sum1) ||
+			    (memcmp(s->sums[i].sum2, file_sum2, csum_length)
+				!= 0)) {
+				*checksums_match = 0;
+			}
+		}		/*  end for  */
+	}
+}
+
+void write_batch_delta_file(char *buff, int bytes_to_write)
+{
+	static int fdb_delta_open = 1;
+	char filename[MAXPATHLEN];
+
+	if (fdb_delta_open) {
+		/* Set up file extension */
+		strlcpy(filename, batch_prefix, sizeof(filename));
+		strlcat(filename, rsync_delta_file, sizeof(filename));
+
+		/*
+		 * Open batch delta file for writing;
+		 * create it if it doesn't exist
+		 */
+		fdb_delta = do_open(filename, O_WRONLY | O_CREAT | O_TRUNC,
+			    S_IREAD | S_IWRITE);
+		if (fdb_delta == -1) {
+			rprintf(FERROR, "Batch file %s open error: %s\n",
+				filename, strerror(errno));
+			close(fdb_delta);
+			exit_cleanup(1);
+		}
+		fdb_delta_open = 0;
+	}
+
+	/* Write buffer to batch delta file */
+
+	if (write(fdb_delta, buff, bytes_to_write) == -1) {
+		rprintf(FERROR, "Batch file %s write error: %s\n",
+			filename, strerror(errno));
+		close(fdb_delta);
+		exit_cleanup(1);
+	}
+}
+
+void close_batch_delta_file(void)
+{
+	close(fdb_delta);
+}
+
+int read_batch_delta_file(char *buff, int len)
+{
+	static int fdb_delta_open = 1;
+	int bytes_read;
+	char filename[MAXPATHLEN];
+
+	if (fdb_delta_open) {
+		/* Set up file extension */
+		strlcpy(filename, batch_prefix, sizeof(filename));
+		strlcat(filename, rsync_delta_file, sizeof(filename));
+
+		/* Open batch flist file for reading */
+		fdb_delta = do_open(filename, O_RDONLY, 0);
+		if (fdb_delta == -1) {
+			rprintf(FERROR, "Batch file %s open error: %s\n",
+				filename, strerror(errno));
+			close(fdb_delta);
+			exit_cleanup(1);
+		}
+		fdb_delta_open = 0;
+	}
+
+	/* Read delta batch file */
+
+	bytes_read = read(fdb_delta, buff, len);
+
+	if (bytes_read == -1) {
+		rprintf(FERROR, "Batch file %s read error: %s\n",
+			filename, strerror(errno));
+		close(fdb_delta);
+		exit_cleanup(1);
+	}
+
+	return bytes_read;
+}
+
+void show_flist(int index, struct file_struct **fptr)
+{
+	/*  for debugging    show_flist(flist->count, flist->files * */
+
+	int i;
+	for (i = 0; i < index; i++) {
+		rprintf(FINFO, "flist->flags=%#x\n", fptr[i]->flags);
+		rprintf(FINFO, "flist->modtime=%#lx\n",
+			(long unsigned) fptr[i]->modtime);
+		rprintf(FINFO, "flist->length=%.0f\n",
+			(double) fptr[i]->length);
+		rprintf(FINFO, "flist->mode=%#o\n", (int) fptr[i]->mode);
+		rprintf(FINFO, "flist->basename=%s\n", fptr[i]->basename);
+		if (fptr[i]->dirname)
+			rprintf(FINFO, "flist->dirname=%s\n",
+				fptr[i]->dirname);
+		if (fptr[i]->basedir)
+			rprintf(FINFO, "flist->basedir=%s\n",
+				fptr[i]->basedir);
+	}
+}
+
+void show_argvs(int argc, char *argv[])
+{
+	/*  for debugging  * */
+
+	int i;
+	rprintf(FINFO, "BATCH.C:show_argvs,argc=%d\n", argc);
+	for (i = 0; i < argc; i++) {
+		/*    if (argv[i])   */
+		rprintf(FINFO, "i=%d,argv[i]=%s\n", i, argv[i]);
+
+	}
+}

checksum.c

@@ -34,7 +34,7 @@ uint32 get_checksum1(char *buf1,int len)
 {
     int i;
     uint32 s1, s2;
-    signed char *buf = (signed char *)buf1;
+    schar *buf = (schar *)buf1;
 
     s1 = s2 = 0;
     for (i = 0; i < (len-4); i+=4) {
@@ -49,82 +49,71 @@ uint32 get_checksum1(char *buf1,int len)
 }
 
 
-static void sum_put(MDstruct *md,char *sum)
-{
-  SIVAL(sum,0,md->buffer[0]);
-  if (csum_length <= 4) return;
-  SIVAL(sum,4,md->buffer[1]);
-  if (csum_length <= 8) return;
-  SIVAL(sum,8,md->buffer[2]);
-  if (csum_length <= 12) return;
-  SIVAL(sum,12,md->buffer[3]);
-}
-
-
 void get_checksum2(char *buf,int len,char *sum)
 {
-  int i;
-  MDstruct MD;
-  static char *buf1;
-  static int len1;
+	int i;
+	static char *buf1;
+	static int len1;
+	struct mdfour m;
 
-  if (len > len1) {
-    if (buf1) free(buf1);
-    buf1 = (char *)malloc(len+4);
-    len1 = len;
-    if (!buf1) out_of_memory("get_checksum2");
-  }
-
-  MDbegin(&MD);
-
-  bcopy(buf,buf1,len);
-  if (checksum_seed) {
-    SIVAL(buf1,len,checksum_seed);
-    len += 4;
-  }
-
-  for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
-    MDupdate(&MD, buf1+i, CSUM_CHUNK*8);
-  }
-  if (len - i > 0)
-    MDupdate(&MD, buf1+i, (len-i)*8);
-
-  sum_put(&MD,sum);
+	if (len > len1) {
+		if (buf1) free(buf1);
+		buf1 = new_array(char, len+4);
+		len1 = len;
+		if (!buf1) out_of_memory("get_checksum2");
+	}
+	
+	mdfour_begin(&m);
+	
+	memcpy(buf1,buf,len);
+	if (checksum_seed) {
+		SIVAL(buf1,len,checksum_seed);
+		len += 4;
+	}
+	
+	for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
+		mdfour_update(&m, (uchar *)(buf1+i), CSUM_CHUNK);
+	}
+	if (len - i > 0) {
+		mdfour_update(&m, (uchar *)(buf1+i), (len-i));
+	}
+	
+	mdfour_result(&m, (uchar *)sum);
 }
 
 
-void file_checksum(char *fname,char *sum,off_t size)
+void file_checksum(char *fname,char *sum,OFF_T size)
 {
-  off_t i;
-  MDstruct MD;
-  struct map_struct *buf;
-  int fd;
-  off_t len = size;
-  char tmpchunk[CSUM_CHUNK];
+	OFF_T i;
+	struct map_struct *buf;
+	int fd;
+	OFF_T len = size;
+	char tmpchunk[CSUM_CHUNK];
+	struct mdfour m;
+	
+	memset(sum,0,MD4_SUM_LENGTH);
+	
+	fd = do_open(fname, O_RDONLY, 0);
+	if (fd == -1) return;
+	
+	buf = map_file(fd,size);
+	
+	mdfour_begin(&m);
 
-  bzero(sum,csum_length);
+	for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
+		memcpy(tmpchunk, map_ptr(buf,i,CSUM_CHUNK), CSUM_CHUNK);
+		mdfour_update(&m, (uchar *)tmpchunk, CSUM_CHUNK);
+	}
 
-  fd = open(fname,O_RDONLY);
-  if (fd == -1) return;
+	if (len - i > 0) {
+		memcpy(tmpchunk, map_ptr(buf,i,len-i), len-i);
+		mdfour_update(&m, (uchar *)tmpchunk, (len-i));
+	}
 
-  buf = map_file(fd,size);
+	mdfour_result(&m, (uchar *)sum);
 
-  MDbegin(&MD);
-
-  for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
-    bcopy(map_ptr(buf,i,CSUM_CHUNK),tmpchunk,CSUM_CHUNK);
-    MDupdate(&MD, tmpchunk, CSUM_CHUNK*8);
-  }
-
-  if (len - i > 0) {
-    bcopy(map_ptr(buf,i,len-i),tmpchunk,len-i);
-    MDupdate(&MD, tmpchunk, (len-i)*8);
-  }
-
-  sum_put(&MD,sum);
-
-  close(fd);
-  unmap_file(buf);
+	close(fd);
+	unmap_file(buf);
 }
 
 
@@ -138,58 +127,62 @@ void checksum_init(void)
 
 
 
-static MDstruct sumMD;
 static int sumresidue;
 static char sumrbuf[CSUM_CHUNK];
+static struct mdfour md;
 
 void sum_init(void)
 {
-  char s[4];
-  MDbegin(&sumMD);  
-  sumresidue=0;
-  SIVAL(s,0,checksum_seed);
-  sum_update(s,4);
+	char s[4];
+	mdfour_begin(&md);
+	sumresidue=0;
+	SIVAL(s,0,checksum_seed);
+	sum_update(s,4);
 }
 
-void sum_update(char *p,int len)
+/**
+ * Feed data into an MD4 accumulator, md.  The results may be
+ * retrieved using sum_end().  md is used for different purposes at
+ * different points during execution.
+ *
+ * @todo Perhaps get rid of md and just pass in the address each time.
+ * Very slightly clearer and slower.
+ **/
+void sum_update(char *p, int len)
 {
-  int i;
-  if (len + sumresidue < CSUM_CHUNK) {
-    bcopy(p,sumrbuf+sumresidue,len);
-    sumresidue += len;
-    return;
-  }
+	int i;
+	if (len + sumresidue < CSUM_CHUNK) {
+		memcpy(sumrbuf+sumresidue, p, len);
+		sumresidue += len;
+		return;
+	}
 
-  if (sumresidue) {
-    i = MIN(CSUM_CHUNK-sumresidue,len);
-    bcopy(p,sumrbuf+sumresidue,i);
-    MDupdate(&sumMD, sumrbuf, (i+sumresidue)*8);
-    len -= i;
-    p += i;
-  }
+	if (sumresidue) {
+		i = MIN(CSUM_CHUNK-sumresidue,len);
+		memcpy(sumrbuf+sumresidue,p,i);
+		mdfour_update(&md, (uchar *)sumrbuf, (i+sumresidue));
+		len -= i;
+		p += i;
+	}
 
-  for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
-    bcopy(p+i,sumrbuf,CSUM_CHUNK);
-    MDupdate(&sumMD, sumrbuf, CSUM_CHUNK*8);
-  }
+	for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
+		memcpy(sumrbuf,p+i,CSUM_CHUNK);
+		mdfour_update(&md, (uchar *)sumrbuf, CSUM_CHUNK);
+	}
 
-  if (len - i > 0) {
-    sumresidue = len-i;
-    bcopy(p+i,sumrbuf,sumresidue);
-  } else {
-    sumresidue = 0;    
-  }
+	if (len - i > 0) {
+		sumresidue = len-i;
+		memcpy(sumrbuf,p+i,sumresidue);
+	} else {
+		sumresidue = 0;    
+	}
 }
 
 void sum_end(char *sum)
 {
-  if (sumresidue)
-    MDupdate(&sumMD, sumrbuf, sumresidue*8);
+	if (sumresidue) {
+		mdfour_update(&md, (uchar *)sumrbuf, sumresidue);
+	}
 
-  SIVAL(sum,0,sumMD.buffer[0]);
-  SIVAL(sum,4,sumMD.buffer[1]);
-  SIVAL(sum,8,sumMD.buffer[2]);
-  SIVAL(sum,12,sumMD.buffer[3]);  
+	mdfour_result(&md, (uchar *)sum);
 }
-
-

cleanup.c

@@ -0,0 +1,169 @@
+/* -*- c-file-style: "linux" -*-
+   
+   Copyright (C) 1996-2000 by Andrew Tridgell
+   Copyright (C) Paul Mackerras 1996
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "rsync.h"
+
+/**
+ * Close all open sockets and files, allowing a (somewhat) graceful
+ * shutdown() of socket connections.  This eliminates the abortive
+ * TCP RST sent by a Winsock-based system when the close() occurs.
+ **/
+void close_all(void)
+{
+#ifdef SHUTDOWN_ALL_SOCKETS
+	int max_fd;
+	int fd;
+	int ret;
+	struct stat st;
+
+	max_fd = sysconf(_SC_OPEN_MAX) - 1;
+	for (fd = max_fd; fd >= 0; fd--) {
+		ret = fstat(fd,&st);
+		if (fstat(fd,&st) == 0) {
+			if (is_a_socket(fd)) {
+				ret = shutdown(fd, 2);
+			}
+			ret = close(fd);
+		}
+	}
+#endif
+}
+
+/**
+ * @file cleanup.c
+ *
+ * Code for handling interrupted transfers.  Depending on the @c
+ * --partial option, we may either delete the temporary file, or go
+ * ahead and overwrite the destination.  This second behaviour only
+ * occurs if we've sent literal data and therefore hopefully made
+ * progress on the transfer.
+ **/
+
+/**
+ * Set to True once literal data has been sent across the link for the
+ * current file. (????)
+ *
+ * Handling the cleanup when a transfer is interrupted is tricky when
+ * --partial is selected.  We need to ensure that the partial file is
+ * kept if any real data has been transferred.
+ **/
+int cleanup_got_literal=0;
+
+static char *cleanup_fname;
+static char *cleanup_new_fname;
+static struct file_struct *cleanup_file;
+static int cleanup_fd1, cleanup_fd2;
+static struct map_struct *cleanup_buf;
+static int cleanup_pid = 0;
+extern int io_error;
+
+pid_t cleanup_child_pid = -1;
+
+/**
+ * Eventually calls exit(), passing @p code, therefore does not return.
+ *
+ * @param code one of the RERR_* codes from errcode.h.
+ **/
+void _exit_cleanup(int code, const char *file, int line)
+{
+	int ocode = code;
+	extern int keep_partial;
+	extern int log_got_error;
+	static int inside_cleanup = 0;
+
+	if (inside_cleanup > 10) {
+		/* prevent the occasional infinite recursion */
+		return;
+	}
+	inside_cleanup++;
+
+	signal(SIGUSR1, SIG_IGN);
+	signal(SIGUSR2, SIG_IGN);
+
+	if (verbose > 3)
+		rprintf(FINFO,"_exit_cleanup(code=%d, file=%s, line=%d): entered\n", 
+			code, file, line);
+
+	if (cleanup_child_pid != -1) {
+		int status;
+		if (waitpid(cleanup_child_pid, &status, WNOHANG) == cleanup_child_pid) {
+			status = WEXITSTATUS(status);
+			if (status > code) code = status;
+		}
+	}
+
+	if (cleanup_got_literal && cleanup_fname && keep_partial) {
+		char *fname = cleanup_fname;
+		cleanup_fname = NULL;
+		if (cleanup_buf) unmap_file(cleanup_buf);
+		if (cleanup_fd1 != -1) close(cleanup_fd1);
+		if (cleanup_fd2 != -1) close(cleanup_fd2);
+		finish_transfer(cleanup_new_fname, fname, cleanup_file);
+	}
+	io_flush();
+	if (cleanup_fname)
+		do_unlink(cleanup_fname);
+	if (code) {
+		kill_all(SIGUSR1);
+	}
+	if ((cleanup_pid != 0) && (cleanup_pid == (int) getpid())) {
+		char *pidf = lp_pid_file();
+		if (pidf && *pidf) {
+			unlink(lp_pid_file());
+		}
+	}
+
+	if (code == 0 && (io_error || log_got_error)) {
+		code = RERR_PARTIAL;
+	}
+
+	if (code) log_exit(code, file, line);
+
+	if (verbose > 2)
+		rprintf(FINFO,"_exit_cleanup(code=%d, file=%s, line=%d): about to call exit(%d)\n", 
+			ocode, file, line, code);
+
+	close_all();
+	exit(code);
+}
+
+void cleanup_disable(void)
+{
+	cleanup_fname = NULL;
+	cleanup_got_literal = 0;
+}
+
+
+void cleanup_set(char *fnametmp, char *fname, struct file_struct *file,
+		 struct map_struct *buf, int fd1, int fd2)
+{
+	cleanup_fname = fnametmp;
+	cleanup_new_fname = fname;
+	cleanup_file = file;
+	cleanup_buf = buf;
+	cleanup_fd1 = fd1;
+	cleanup_fd2 = fd2;
+}
+
+void cleanup_set_pid(int pid)
+{
+	cleanup_pid = pid;
+}

clientname.c

@@ -0,0 +1,364 @@
+/* -*- 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";
+extern int am_daemon;
+extern int am_server;
+
+
+/**
+ * Return the IP addr of the client as a string 
+ **/
+char *client_addr(int fd)
+{
+	struct sockaddr_storage ss;
+	socklen_t length = sizeof ss;
+	char *ssh_client, *p;
+	int len;
+	static char addr_buf[100];
+	static int initialised;
+
+	if (initialised) return addr_buf;
+
+	initialised = 1;
+
+	if (am_server) {
+		/* daemon over --rsh mode */
+		strcpy(addr_buf, "0.0.0.0");
+		if ((ssh_client = getenv("SSH_CLIENT")) != NULL) {
+			/* truncate SSH_CLIENT to just IP address */
+			p = strchr(ssh_client, ' ');
+			if (p) {
+				len = MIN((unsigned int) (p - ssh_client), 
+						sizeof(addr_buf) - 1);
+				strncpy(addr_buf, ssh_client, len);
+				*(addr_buf + len) = '\0';
+			}
+		}
+	} else {
+		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.
+ *
+ * After translation from sockaddr to name we do a forward lookup to
+ * make sure nobody is spoofing PTR records.
+ **/
+char *client_name(int fd)
+{
+	static char name_buf[100];
+	static char port_buf[100];
+	static int initialised;
+	struct sockaddr_storage ss, *ssp;
+	struct sockaddr_in sin;
+#ifdef INET6
+	struct sockaddr_in6 sin6;
+#endif
+	socklen_t ss_len;
+
+	if (initialised) return name_buf;
+
+	strcpy(name_buf, default_name);
+	initialised = 1;
+
+	if (am_server) {
+		/* daemon over --rsh mode */
+
+		char *addr = client_addr(fd);
+#ifdef INET6
+		int dots = 0;
+		char *p;
+
+		for (p = addr; *p && (dots <= 3); p++) {
+		    if (*p == '.')
+			dots++;
+		}
+		if (dots > 3) {
+			/* more than 4 parts to IP address, must be ipv6 */
+			ssp = (struct sockaddr_storage *) &sin6;
+			ss_len = sizeof sin6;
+			memset(ssp, 0, ss_len);
+			inet_pton(AF_INET6, addr, &sin6.sin6_addr);
+			sin6.sin6_family = AF_INET6;
+		} else
+#endif
+		{
+			ssp = (struct sockaddr_storage *) &sin;
+			ss_len = sizeof sin;
+			memset(ssp, 0, ss_len);
+			inet_pton(AF_INET, addr, &sin.sin_addr);
+			sin.sin_family = AF_INET;
+		}
+
+	} else {
+		ss_len = sizeof ss;
+		ssp = &ss;
+
+		client_sockaddr(fd, &ss, &ss_len);
+
+	}
+
+	if (!lookup_name(fd, ssp, ss_len, name_buf, sizeof name_buf, 
+			port_buf, sizeof port_buf))
+		check_name(fd, ssp, name_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)
+{
+	memset(ss, 0, sizeof(*ss));
+
+	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.
+ *
+ * @param fd file descriptor for client socket.
+ **/
+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;
+
+		if (ai->ai_addrlen < sizeof(struct sockaddr_in6)) {
+			rprintf(FERROR,
+				"%s: too short sockaddr_in6; length=%d\n",
+				fn, ai->ai_addrlen);
+			return 1;
+		}
+
+		if (memcmp(&sin1->sin6_addr, &sin2->sin6_addr,
+			   sizeof sin1->sin6_addr))
+			return 1;
+
+#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
+		if (sin1->sin6_scope_id != sin2->sin6_scope_id)
+			return 1;
+#endif
+		return 0;
+	}
+#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".
+ *
+ * We don't do anything with the service when checking the name,
+ * because it doesn't seem that it could be spoofed in any way, and
+ * getaddrinfo on random service names seems to cause problems on AIX.
+ **/
+int check_name(int fd,
+	       const struct sockaddr_storage *ss,
+	       char *name_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, NULL, &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

@@ -0,0 +1,634 @@
+/* -*- c-file-style: "linux"; -*-
+ *
+ * Copyright (C) 1998-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
+ *
+ * The socket based protocol for setting up a connection with
+ * rsyncd.
+ **/
+
+#include "rsync.h"
+
+extern int module_id;
+extern int read_only;
+extern int verbose;
+extern int rsync_port;
+char *auth_user;
+extern int sanitize_paths;
+extern int filesfrom_fd;
+extern int remote_protocol;
+extern int protocol_version;
+extern struct exclude_struct **server_exclude_list;
+extern char *exclude_path_prefix;
+
+/**
+ * Run a client connected to an rsyncd.  The alternative to this
+ * function for remote-shell connections is do_cmd().
+ *
+ * After negotiating which module to use and reading the server's
+ * motd, this hands over to client_run().  Telling the server the
+ * module will cause it to chroot/setuid/etc.
+ *
+ * Instead of doing a transfer, the client may at this stage instead
+ * get a listing of remote modules and exit.
+ *
+ * @return -1 for error in startup, or the result of client_run().
+ * Either way, it eventually gets passed to exit_cleanup().
+ **/
+int start_socket_client(char *host, char *path, int argc, char *argv[])
+{
+	int fd, ret;
+	char *p, *user=NULL;
+	extern char *bind_address;
+	extern int default_af_hint;
+
+	/* this is redundant with code in start_inband_exchange(), but
+	 * this short-circuits a problem before we open a socket, and
+	 * the extra check won't hurt */
+	if (*path == '/') {
+		rprintf(FERROR,"ERROR: The remote path must start with a module name not a /\n");
+		return -1;
+	}
+
+	p = strchr(host, '@');
+	if (p) {
+		user = host;
+		host = p+1;
+		*p = 0;
+	}
+
+	if (verbose >= 2) {
+		/* FIXME: If we're going to use a socket program for
+		 * testing, then this message is wrong.  We need to
+		 * say something like "(except really using %s)" */
+		rprintf(FINFO, "opening tcp connection to %s port %d\n",
+			host, rsync_port);
+	}
+	fd = open_socket_out_wrapped(host, rsync_port, bind_address,
+				     default_af_hint);
+	if (fd == -1) {
+		exit_cleanup(RERR_SOCKETIO);
+	}
+
+	ret = start_inband_exchange(user, path, fd, fd, argc);
+
+	return ret < 0? ret : client_run(fd, fd, -1, argc, argv);
+}
+
+int start_inband_exchange(char *user, char *path, int f_in, int f_out, int argc)
+{
+	int i;
+	char *sargs[MAX_ARGS];
+	int sargc = 0;
+	char line[MAXPATHLEN];
+	char *p;
+	extern int kludge_around_eof;
+	extern int am_sender;
+	extern int daemon_over_rsh;
+	extern int list_only;
+
+	if (argc == 0 && !am_sender)
+		list_only = 1;
+
+	if (*path == '/') {
+		rprintf(FERROR, "ERROR: The remote path must start with a module name\n");
+		return -1;
+	}
+
+	if (!user) user = getenv("USER");
+	if (!user) user = getenv("LOGNAME");
+
+	/* set daemon_over_rsh to false since we need to build the
+	 * true set of args passed through the rsh/ssh connection;
+	 * this is a no-op for direct-socket-connection mode */
+	daemon_over_rsh = 0;
+	server_options(sargs, &sargc);
+
+	sargs[sargc++] = ".";
+
+	if (path && *path)
+		sargs[sargc++] = path;
+
+	sargs[sargc] = NULL;
+
+	io_printf(f_out, "@RSYNCD: %d\n", PROTOCOL_VERSION);
+
+	if (!read_line(f_in, line, sizeof(line)-1)) {
+		rprintf(FERROR, "rsync: did not see server greeting\n");
+		return -1;
+	}
+
+	if (sscanf(line,"@RSYNCD: %d", &remote_protocol) != 1) {
+		/* note that read_line strips of \n or \r */
+		rprintf(FERROR, "rsync: server sent \"%s\" rather than greeting\n",
+			line);
+		return -1;
+	}
+	if (protocol_version > remote_protocol)
+		protocol_version = remote_protocol;
+
+	p = strchr(path,'/');
+	if (p) *p = 0;
+	io_printf(f_out, "%s\n", path);
+	if (p) *p = '/';
+
+	/* Old servers may just drop the connection here,
+	 rather than sending a proper EXIT command.  Yuck. */
+	kludge_around_eof = list_only && (protocol_version < 25);
+
+	while (1) {
+		if (!read_line(f_in, line, sizeof(line)-1)) {
+			rprintf(FERROR, "rsync: didn't get server startup line\n");
+			return -1;
+		}
+
+		if (strncmp(line,"@RSYNCD: AUTHREQD ",18) == 0) {
+			auth_client(f_out, user, line+18);
+			continue;
+		}
+
+		if (strcmp(line,"@RSYNCD: OK") == 0) break;
+
+		if (strcmp(line,"@RSYNCD: EXIT") == 0) {
+			/* This is sent by recent versions of the
+			 * server to terminate the listing of modules.
+			 * We don't want to go on and transfer
+			 * anything; just exit. */
+			exit(0);
+		}
+
+		if (strncmp(line, "@ERROR", 6) == 0) {
+			rprintf(FERROR,"%s\n", line);
+			/* This is always fatal; the server will now
+			 * close the socket. */
+			return RERR_STARTCLIENT;
+		} else {
+			rprintf(FINFO,"%s\n", line);
+		}
+	}
+	kludge_around_eof = False;
+
+	for (i = 0; i < sargc; i++) {
+		io_printf(f_out, "%s\n", sargs[i]);
+	}
+	io_printf(f_out, "\n");
+
+	if (protocol_version < 23) {
+		if (protocol_version == 22 || (protocol_version > 17 && !am_sender))
+			io_start_multiplex_in(f_in);
+	}
+
+	return 0;
+}
+
+
+
+static int rsync_module(int f_in, int f_out, int i)
+{
+	int argc=0;
+	char *argv[MAX_ARGS];
+	char **argp;
+	char line[MAXPATHLEN];
+	uid_t uid = (uid_t)-2;  /* canonically "nobody" */
+	gid_t gid = (gid_t)-2;
+	char *p;
+	char *addr = client_addr(f_in);
+	char *host = client_name(f_in);
+	char *name = lp_name(i);
+	int use_chroot = lp_use_chroot(i);
+	int start_glob=0;
+	int ret;
+	char *request=NULL;
+	extern int am_sender;
+	extern int am_server;
+	extern int am_daemon;
+	extern int am_root;
+
+	if (!allow_access(addr, host, lp_hosts_allow(i), lp_hosts_deny(i))) {
+		rprintf(FERROR,"rsync denied on module %s from %s (%s)\n",
+			name, host, addr);
+		io_printf(f_out, "@ERROR: access denied to %s from %s (%s)\n",
+			  name, host, addr);
+		return -1;
+	}
+
+	if (am_daemon && am_server) {
+		rprintf(FINFO, "rsync allowed access on module %s from %s (%s)\n",
+			name, host, addr);
+	}
+
+	if (!claim_connection(lp_lock_file(i), lp_max_connections(i))) {
+		if (errno) {
+			rprintf(FERROR,"failed to open lock file %s : %s\n",
+				lp_lock_file(i), strerror(errno));
+			io_printf(f_out, "@ERROR: failed to open lock file %s : %s\n",
+				  lp_lock_file(i), strerror(errno));
+		} else {
+			rprintf(FERROR,"max connections (%d) reached\n",
+				lp_max_connections(i));
+			io_printf(f_out, "@ERROR: max connections (%d) reached - try again later\n",
+				lp_max_connections(i));
+		}
+		return -1;
+	}
+
+
+	auth_user = auth_server(f_in, f_out, i, addr, "@RSYNCD: AUTHREQD ");
+
+	if (!auth_user) {
+		rprintf(FERROR,"auth failed on module %s from %s (%s)\n",
+			name, host, addr);
+		io_printf(f_out, "@ERROR: auth failed on module %s\n", name);
+		return -1;
+	}
+
+	module_id = i;
+
+	am_root = (getuid() == 0);
+
+	if (am_root) {
+		p = lp_uid(i);
+		if (!name_to_uid(p, &uid)) {
+			if (!isdigit(* (unsigned char *) p)) {
+				rprintf(FERROR,"Invalid uid %s\n", p);
+				io_printf(f_out, "@ERROR: invalid uid %s\n", p);
+				return -1;
+			}
+			uid = atoi(p);
+		}
+
+		p = lp_gid(i);
+		if (!name_to_gid(p, &gid)) {
+			if (!isdigit(* (unsigned char *) p)) {
+				rprintf(FERROR,"Invalid gid %s\n", p);
+				io_printf(f_out, "@ERROR: invalid gid %s\n", p);
+				return -1;
+			}
+			gid = atoi(p);
+		}
+	}
+
+	/* TODO: If we're not root, but the configuration requests
+	 * that we change to some uid other than the current one, then
+	 * log a warning. */
+
+	/* TODO: Perhaps take a list of gids, and make them into the
+	 * supplementary groups. */
+
+	exclude_path_prefix = use_chroot? "" : lp_path(i);
+	if (*exclude_path_prefix == '/' && !exclude_path_prefix[1])
+		exclude_path_prefix = "";
+
+	p = lp_include_from(i);
+	add_exclude_file(&server_exclude_list, p, MISSING_FATAL, ADD_INCLUDE);
+
+	p = lp_include(i);
+	add_exclude_line(&server_exclude_list, p, ADD_INCLUDE);
+
+	p = lp_exclude_from(i);
+	add_exclude_file(&server_exclude_list, p, MISSING_FATAL, ADD_EXCLUDE);
+
+	p = lp_exclude(i);
+	add_exclude_line(&server_exclude_list, p, ADD_EXCLUDE);
+
+	exclude_path_prefix = NULL;
+
+	log_init();
+
+	if (use_chroot) {
+		/*
+		 * XXX: The 'use chroot' flag is a fairly reliable
+		 * source of confusion, because it fails under two
+		 * important circumstances: running as non-root,
+		 * running on Win32 (or possibly others).  On the
+		 * other hand, if you are running as root, then it
+		 * might be better to always use chroot.
+		 *
+		 * So, perhaps if we can't chroot we should just issue
+		 * a warning, unless a "require chroot" flag is set,
+		 * in which case we fail.
+		 */
+		if (chroot(lp_path(i))) {
+			rsyserr(FERROR, errno, "chroot %s failed", lp_path(i));
+			io_printf(f_out, "@ERROR: chroot failed\n");
+			return -1;
+		}
+
+		if (!push_dir("/", 0)) {
+			rsyserr(FERROR, errno, "chdir %s failed\n", lp_path(i));
+			io_printf(f_out, "@ERROR: chdir failed\n");
+			return -1;
+		}
+
+	} else {
+		if (!push_dir(lp_path(i), 0)) {
+			rsyserr(FERROR, errno, "chdir %s failed\n", lp_path(i));
+			io_printf(f_out, "@ERROR: chdir failed\n");
+			return -1;
+		}
+		sanitize_paths = 1;
+	}
+
+	if (am_root) {
+		/* 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(f_out, "@ERROR: setgid failed\n");
+			return -1;
+		}
+#ifdef HAVE_SETGROUPS
+		/* Get rid of any supplementary groups this process
+		 * might have inheristed. */
+		if (setgroups(1, &gid)) {
+			rsyserr(FERROR, errno, "setgroups failed");
+			io_printf(f_out, "@ERROR: setgroups failed\n");
+			return -1;
+		}
+#endif
+
+		if (setuid(uid)) {
+			rsyserr(FERROR, errno, "setuid %d failed", (int) uid);
+			io_printf(f_out, "@ERROR: setuid failed\n");
+			return -1;
+		}
+
+		am_root = (getuid() == 0);
+	}
+
+	io_printf(f_out, "@RSYNCD: OK\n");
+
+	argv[argc++] = "rsyncd";
+
+	while (1) {
+		if (!read_line(f_in, line, sizeof(line)-1)) {
+			return -1;
+		}
+
+		if (!*line) break;
+
+		p = line;
+
+		argv[argc] = strdup(p);
+		if (!argv[argc]) {
+			return -1;
+		}
+
+		if (start_glob) {
+			if (start_glob == 1) {
+				request = strdup(p);
+				start_glob++;
+			}
+			glob_expand(name, argv, &argc, MAX_ARGS);
+		} else {
+			argc++;
+		}
+
+		if (strcmp(line,".") == 0) {
+			start_glob = 1;
+		}
+
+		if (argc == MAX_ARGS) {
+			return -1;
+		}
+	}
+
+	if (sanitize_paths) {
+		/*
+		 * Note that this is applied to all parameters, whether or not
+		 *    they are filenames, but no other legal parameters contain
+		 *    the forms that need to be sanitized so it doesn't hurt;
+		 *    it is not known at this point which parameters are files
+		 *    and which aren't.
+		 */
+		for (i = 1; i < argc; i++) {
+			sanitize_path(argv[i], NULL);
+		}
+	}
+
+	argp = argv;
+	ret = parse_arguments(&argc, (const char ***) &argp, 0);
+
+	if (filesfrom_fd == 0)
+		filesfrom_fd = f_in;
+
+	if (request) {
+		if (*auth_user) {
+			rprintf(FINFO,"rsync %s %s from %s@%s (%s)\n",
+				am_sender?"on":"to",
+				request, auth_user, host, addr);
+		} else {
+			rprintf(FINFO,"rsync %s %s from %s (%s)\n",
+				am_sender?"on":"to",
+				request, host, addr);
+		}
+		free(request);
+	}
+
+#ifndef DEBUG
+	/* don't allow the logs to be flooded too fast */
+	if (verbose > 1) verbose = 1;
+#endif
+
+	if (protocol_version < 23) {
+		if (protocol_version == 22 || (protocol_version > 17 && am_sender))
+			io_start_multiplex_out(f_out);
+	}
+
+	/* For later protocol versions, we don't start multiplexing
+	 * until we've configured nonblocking in start_server.  That
+	 * means we're in a sticky situation now: there's no way to
+	 * convey errors to the client. */
+
+	/* FIXME: Hold off on reporting option processing errors until
+	 * we've set up nonblocking and multiplexed IO and can get the
+	 * message back to them. */
+	if (!ret) {
+		option_error();
+		exit_cleanup(RERR_UNSUPPORTED);
+	}
+
+	if (lp_timeout(i)) {
+		extern int io_timeout;
+		io_timeout = lp_timeout(i);
+	}
+
+	start_server(f_in, f_out, argc, argp);
+
+	return 0;
+}
+
+/* send a list of available modules to the client. Don't list those
+   with "list = False". */
+static void send_listing(int fd)
+{
+	int n = lp_numservices();
+	int i;
+
+	for (i=0;i<n;i++)
+		if (lp_list(i))
+			io_printf(fd, "%-15s\t%s\n", lp_name(i), lp_comment(i));
+
+	if (protocol_version >= 25)
+		io_printf(fd,"@RSYNCD: EXIT\n");
+}
+
+/* this is called when a connection is established to a client
+   and we want to start talking. The setup of the system is done from
+   here */
+int start_daemon(int f_in, int f_out)
+{
+	char line[200];
+	char *motd;
+	int i = -1;
+	extern char *config_file;
+	extern int am_server;
+
+	if (!lp_load(config_file, 0)) {
+		exit_cleanup(RERR_SYNTAX);
+	}
+
+	log_init();
+
+	if (!am_server) {
+		set_socket_options(f_in, "SO_KEEPALIVE");
+		set_socket_options(f_in, lp_socket_options());
+		set_nonblocking(f_in);
+	}
+
+	io_printf(f_out, "@RSYNCD: %d\n", PROTOCOL_VERSION);
+
+	motd = lp_motd_file();
+	if (motd && *motd) {
+		FILE *f = fopen(motd,"r");
+		while (f && !feof(f)) {
+			int len = fread(line, 1, sizeof(line)-1, f);
+			if (len > 0) {
+				line[len] = 0;
+				io_printf(f_out, "%s", line);
+			}
+		}
+		if (f) fclose(f);
+		io_printf(f_out, "\n");
+	}
+
+	if (!read_line(f_in, line, sizeof(line)-1)) {
+		return -1;
+	}
+
+	if (sscanf(line,"@RSYNCD: %d", &remote_protocol) != 1) {
+		io_printf(f_out, "@ERROR: protocol startup error\n");
+		return -1;
+	}
+	if (protocol_version > remote_protocol)
+		protocol_version = remote_protocol;
+
+	while (i == -1) {
+		line[0] = 0;
+		if (!read_line(f_in, line, sizeof(line)-1)) {
+			return -1;
+		}
+
+		if (!*line || strcmp(line,"#list")==0) {
+			send_listing(f_out);
+			return -1;
+		}
+
+		if (*line == '#') {
+			/* it's some sort of command that I don't understand */
+			io_printf(f_out, "@ERROR: Unknown command '%s'\n", line);
+			return -1;
+		}
+
+		i = lp_number(line);
+		if (i == -1) {
+			io_printf(f_out, "@ERROR: Unknown module '%s'\n", line);
+			return -1;
+		}
+	}
+
+	return rsync_module(f_in, f_out, i);
+}
+
+
+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;
+
+		/* we are running via inetd - close off stdout and
+		 * stderr so that library functions (and getopt) don't
+		 * try to use them. Redirect them to /dev/null */
+		for (i=1;i<3;i++) {
+			close(i);
+			open("/dev/null", O_RDWR);
+		}
+
+		return start_daemon(STDIN_FILENO, STDIN_FILENO);
+	}
+
+	if (!no_detach)
+		become_daemon();
+
+	if (!lp_load(config_file, 1)) {
+		exit_cleanup(RERR_SYNTAX);
+	}
+
+	log_init();
+
+	rprintf(FINFO, "rsyncd version %s starting, listening on port %d\n",
+		RSYNC_VERSION, rsync_port);
+	/* TODO: If listening on a particular address, then show that
+	 * 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];
+		int fd;
+		int pid = (int) getpid();
+		cleanup_set_pid(pid);
+		if ((fd = do_open(lp_pid_file(), O_WRONLY|O_CREAT|O_TRUNC,
+					0666 & ~orig_umask)) == -1) {
+			cleanup_set_pid(0);
+			rsyserr(FLOG, errno, "failed to create pid file %s", pid_file);
+			exit_cleanup(RERR_FILEIO);
+		}
+		snprintf(pidbuf, sizeof(pidbuf), "%d\n", pid);
+		write(fd, pidbuf, strlen(pidbuf));
+		close(fd);
+	}
+
+	start_accept_loop(rsync_port, start_daemon);
+	return -1;
+}

compat.c

@@ -17,13 +17,17 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-/* compatability routines for older rsync protocol versions */
+/**
+ * @file compat.c
+ *
+ * Compatibility routines for older rsync protocol versions.
+ **/
 
 #include "rsync.h"
 
-extern int am_server;
+int remote_protocol = 0;
 
-extern int csum_length;
+extern int am_server;
 
 extern int preserve_links;
 extern int preserve_perms;
@@ -35,40 +39,58 @@ extern int always_checksum;
 extern int checksum_seed;
 
 
-extern int remote_version;
+extern int protocol_version;
 extern int verbose;
 
+extern int read_batch;
+extern int write_batch;
+
 void setup_protocol(int f_out,int f_in)
 {
-  if (am_server) {
-    remote_version = read_int(f_in);
-    write_int(f_out,PROTOCOL_VERSION);
-    write_flush(f_out);
-  } else {
-    write_int(f_out,PROTOCOL_VERSION);
-    write_flush(f_out);
-    remote_version = read_int(f_in);
-  }
+	if (remote_protocol == 0) {
+		if (am_server) {
+			remote_protocol = read_int(f_in);
+			write_int(f_out, protocol_version);
+		} else {
+			write_int(f_out, protocol_version);
+			remote_protocol = read_int(f_in);
+		}
+		if (protocol_version > remote_protocol)
+			protocol_version = remote_protocol;
+	}
 
-  if (remote_version < MIN_PROTOCOL_VERSION ||
-      remote_version > MAX_PROTOCOL_VERSION) {
-    fprintf(FERROR,"protocol version mismatch - is your shell clean?\n");
-    exit_cleanup(1);
-  }	
+	if (verbose > 3) {
+		rprintf(FINFO, "(%s) Protocol versions: remote=%d, negotiated=%d\n",
+			am_server? "Server" : "Client", remote_protocol, protocol_version);
+	}
+	if (remote_protocol < MIN_PROTOCOL_VERSION
+	 || remote_protocol > MAX_PROTOCOL_VERSION) {
+		rprintf(FERROR,"protocol version mismatch - is your shell clean?\n");
+		rprintf(FERROR,"(see the rsync man page for an explanation)\n");
+		exit_cleanup(RERR_PROTOCOL);
+	}
+	if (remote_protocol < OLD_PROTOCOL_VERSION) {
+		rprintf(FINFO,"%s is very old version of rsync, upgrade recommended.\n",
+			am_server? "Client" : "Server");
+	}
+	if (protocol_version < MIN_PROTOCOL_VERSION) {
+		rprintf(FERROR, "--protocol must be at least %d on the %s.\n",
+			MIN_PROTOCOL_VERSION, am_server? "Server" : "Client");
+		exit_cleanup(RERR_PROTOCOL);
+	}
+	if (protocol_version > PROTOCOL_VERSION) {
+		rprintf(FERROR, "--protocol must be no more than %d on the %s.\n",
+			PROTOCOL_VERSION, am_server? "Server" : "Client");
+		exit_cleanup(RERR_PROTOCOL);
+	}
 
-  if (verbose > 2)
-	  fprintf(FINFO, "local_version=%d remote_version=%d\n",
-		  PROTOCOL_VERSION, remote_version);
-
-  if (remote_version >= 12) {
-    if (am_server) {
-      checksum_seed = time(NULL);
-      write_int(f_out,checksum_seed);
-    } else {
-      checksum_seed = read_int(f_in);
-    }
-  }
-
-  checksum_init();
+	if (am_server) {
+		if (read_batch || write_batch)
+			checksum_seed = 32761;
+		else
+			checksum_seed = time(NULL);
+		write_int(f_out,checksum_seed);
+	} else {
+		checksum_seed = read_int(f_in);
+	}
 }
-

configure.in

@@ -1,21 +1,272 @@
 dnl Process this file with autoconf to produce a configure script.
-AC_INIT(byteorder.h)
+
+AC_INIT()
+AC_CONFIG_SRCDIR([byteorder.h])
 AC_CONFIG_HEADER(config.h)
+AC_PREREQ(2.52)
+
+RSYNC_VERSION=2.5.7
+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([])
 
 dnl Checks for programs.
 AC_PROG_CC
+AC_PROG_CPP
 AC_PROG_INSTALL
+AC_PROG_CC_STDC
 AC_SUBST(SHELL)
 
-AC_CHECK_PROG(HAVE_REMSH, remsh, 1, 0)
-AC_DEFINE_UNQUOTED(HAVE_REMSH, $HAVE_REMSH)
+AC_DEFINE([_GNU_SOURCE], 1,
+          [Define _GNU_SOURCE so that we get all necessary prototypes])
 
+if test "x$ac_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,
+	AC_HELP_STRING([--enable-debug],
+		[including debugging symbols and features (default yes)]),
+		[], [])
+
+if test x"$enable_debug" = x"no"
+then
+    AC_MSG_RESULT(no)
+    CFLAGS=${CFLAGS-"-O"}
+else
+    AC_MSG_RESULT([yes])
+    # leave CFLAGS alone; AC_PROG_CC will try to include -g if it can
+    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
+
+
+# Specifically, this turns on panic_action handling.
+AC_ARG_ENABLE(maintainer-mode,
+	AC_HELP_STRING([--enable-maintainer-mode],	
+		[turn on extra debug features],
+		[], []))
+if test x"$enable_maintainer_mode" = xyes
+then
+	CFLAGS="$CFLAGS -DMAINTAINER_MODE"
+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])
+
+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", [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, [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
+AC_CACHE_CHECK([for broken largefile support],rsync_cv_HAVE_BROKEN_LARGEFILE,[
+AC_TRY_RUN([
+#define _FILE_OFFSET_BITS 64
+#include <stdio.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+int main(void) 
+{
+	struct flock lock;
+        int status;
+	int fd = open("conftest.dat", O_CREAT|O_RDWR, 0600);
+	lock.l_type = F_WRLCK;
+	lock.l_whence = SEEK_SET;
+	lock.l_start = 0;
+	lock.l_len = 1;
+	lock.l_pid = 0;
+	
+	fcntl(fd,F_SETLK,&lock);
+	if (fork() == 0) {
+		lock.l_start = 1;		
+		exit(fcntl(fd,F_SETLK,&lock) == 0);
+        }
+        wait(&status);
+	unlink("conftest.dat");
+	exit(WEXITSTATUS(status));
+}
+],
+rsync_cv_HAVE_BROKEN_LARGEFILE=yes,rsync_cv_HAVE_BROKEN_LARGEFILE=no,rsync_cv_HAVE_BROKEN_LARGEFILE=cross)])
+if test x"$rsync_cv_HAVE_BROKEN_LARGEFILE" != x"yes"; then
+   AC_SYS_LARGEFILE
+fi
+
+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
+		inria)
+			# http://www.kame.net/
+			AC_EGREP_CPP(yes, [
+#include <netinet/in.h>
+#ifdef IPV6_INRIA_VERSION
+yes
+#endif],
+				[ipv6type=$i;
+				AC_DEFINE(INET6, 1, [true if you have IPv6])
+				])
+			;;
+		kame)
+			# http://www.kame.net/
+			AC_EGREP_CPP(yes, [
+#include <netinet/in.h>
+#ifdef __KAME__
+yes
+#endif],
+				[ipv6type=$i; 
+				AC_DEFINE(INET6, 1, [true if you have IPv6])])
+			;;
+		linux-glibc)
+			# http://www.v6.linux.or.jp/
+			AC_EGREP_CPP(yes, [
+#include <features.h>
+#if defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1
+yes
+#endif],
+				[ipv6type=$i;
+AC_DEFINE(INET6, 1, [true if you have IPv6])])
+			;;
+		linux-inet6)
+			# http://www.v6.linux.or.jp/
+			if test -d /usr/inet6 -o -f /usr/inet6/lib/libinet6.a; then
+				ipv6type=$i
+				ipv6lib=inet6
+				ipv6libdir=/usr/inet6/lib
+				ipv6trylibc=yes;
+				AC_DEFINE(INET6, 1, [true if you have IPv6])
+				CFLAGS="-I/usr/inet6/include $CFLAGS"
+			fi
+			;;
+		toshiba)
+			AC_EGREP_CPP(yes, [
+#include <sys/param.h>
+#ifdef _TOSHIBA_INET6
+yes
+#endif],
+				[ipv6type=$i;
+				ipv6lib=inet6;
+				ipv6libdir=/usr/local/v6/lib;
+				AC_DEFINE(INET6, 1, [true if you have IPv6])])
+			;;
+		v6d)
+			AC_EGREP_CPP(yes, [
+#include </usr/local/v6/include/sys/v6config.h>
+#ifdef __V6D__
+yes
+#endif],
+				[ipv6type=$i;
+				ipv6lib=v6;
+				ipv6libdir=/usr/local/v6/lib;
+				AC_DEFINE(INET6, 1, [true if you have IPv6])])
+			;;
+		zeta)
+			AC_EGREP_CPP(yes, [
+#include <sys/param.h>
+#ifdef _ZETA_MINAMI_INET6
+yes
+#endif],
+				[ipv6type=$i;
+				ipv6lib=inet6;
+				ipv6libdir=/usr/local/v6/lib;
+				AC_DEFINE(INET6, 1, [true if you have IPv6])])
+			;;
+		esac
+		if test "$ipv6type" != "unknown"; then
+			break
+		fi
+	done
+	AC_MSG_RESULT($ipv6type)
+
+	AC_SEARCH_LIBS(getaddrinfo, inet6)
+fi
+
+AC_MSG_CHECKING([whether to call shutdown on all sockets])
+case $host_os in
+	*cygwin* ) AC_MSG_RESULT(yes)
+                   AC_DEFINE(SHUTDOWN_ALL_SOCKETS, 1, 
+			    [Define if sockets need to be shutdown])
+		   ;;
+	       * ) AC_MSG_RESULT(no);;
+esac
+
+AC_C_BIGENDIAN
 AC_HEADER_DIRENT
 AC_HEADER_TIME
 AC_HEADER_SYS_WAIT
 AC_CHECK_HEADERS(sys/fcntl.h sys/select.h fcntl.h sys/time.h sys/unistd.h unistd.h utime.h grp.h)
 AC_CHECK_HEADERS(compat.h sys/param.h ctype.h sys/wait.h sys/ioctl.h)
-AC_CHECK_HEADERS(sys/filio.h string.h stdlib.h sys/socket.h sys/mode.h)
+AC_CHECK_HEADERS(sys/filio.h string.h stdlib.h sys/socket.h sys/mode.h sys/un.h)
+AC_CHECK_HEADERS(glob.h mcheck.h sys/sysctl.h arpa/inet.h arpa/nameser.h)
+AC_CHECK_HEADERS(netdb.h)
+AC_CHECK_HEADERS(malloc.h)
+AC_CHECK_HEADERS(float.h)
 
 AC_CHECK_SIZEOF(int)
 AC_CHECK_SIZEOF(long)
@@ -29,38 +280,362 @@ AC_TYPE_MODE_T
 AC_TYPE_OFF_T
 AC_TYPE_SIZE_T
 AC_TYPE_PID_T
-AC_STRUCT_ST_RDEV
-AC_CHECK_TYPE(ino_t,unsigned)
+AC_TYPE_GETGROUPS
+AC_CHECK_MEMBERS([struct stat.st_rdev])
 
-echo $ac_n "checking for errno in errno.h... $ac_c"
-AC_TRY_COMPILE([#include <errno.h>],[int i = errno],
-echo yes; AC_DEFINE(HAVE_ERRNO_DECL),
-echo no)
+AC_CHECK_TYPE([ino_t], [unsigned])
+TYPE_SOCKLEN_T
+
+AC_CACHE_CHECK([for errno in errno.h],rsync_cv_errno, [
+    AC_TRY_COMPILE([#include <errno.h>],[int i = errno],
+	rsync_cv_errno=yes,rsync_cv_have_errno_decl=no)])
+if test x"$rsync_cv_errno" = x"yes"; then
+   AC_DEFINE(HAVE_ERRNO_DECL, 1, [ ])
+fi
+
+# The following test taken from the cvs sources
+# If we can't find connect, try looking in -lsocket, -lnsl, and -linet.
+# These need checks to be before checks for any other functions that
+#    might be in the same libraries.
+# The Irix 5 libc.so has connect and gethostbyname, but Irix 5 also has
+# libsocket.so which has a bad implementation of gethostbyname (it
+# only looks in /etc/hosts), so we only look for -lsocket if we need
+# it.
+AC_CHECK_FUNCS(connect)
+if test x"$ac_cv_func_connect" = x"no"; then
+    case "$LIBS" in
+    *-lnsl*) ;;
+    *) AC_CHECK_LIB(nsl_s, printf) ;;
+    esac
+    case "$LIBS" in
+    *-lnsl*) ;;
+    *) AC_CHECK_LIB(nsl, printf) ;;
+    esac
+    case "$LIBS" in
+    *-lsocket*) ;;
+    *) AC_CHECK_LIB(socket, connect) ;;
+    esac
+    case "$LIBS" in
+    *-linet*) ;;
+    *) AC_CHECK_LIB(inet, connect) ;;
+    esac
+    dnl We can't just call AC_CHECK_FUNCS(connect) here, because the value
+    dnl has been cached.
+    if test x"$ac_cv_lib_socket_connect" = x"yes" || 
+       test x"$ac_cv_lib_inet_connect" = x"yes"; then
+        # ac_cv_func_connect=yes
+        # don't!  it would cause AC_CHECK_FUNC to succeed next time configure is run
+        AC_DEFINE(HAVE_CONNECT, 1, [ ])
+    fi
+fi
+
+AC_CHECK_LIB(resolv, inet_ntop)
+
+dnl AC_MSG_NOTICE([Looking in libraries: $LIBS])
+
+AC_CHECK_FUNCS(inet_ntop, , AC_LIBOBJ(lib/inet_ntop)) 
+AC_CHECK_FUNCS(inet_pton, , AC_LIBOBJ(lib/inet_pton))
+
+# Irix 6.5 has getaddrinfo but not the corresponding defines, so use
+#   builtin getaddrinfo if one of the defines don't exist
+AC_CACHE_CHECK([whether defines needed by getaddrinfo exist],
+               rsync_cv_HAVE_GETADDR_DEFINES,[
+			AC_EGREP_CPP(yes, [
+			#include <sys/types.h>
+			#include <sys/socket.h>
+			#include <netdb.h>
+			#ifdef AI_PASSIVE
+			yes
+			#endif], 
+			rsync_cv_HAVE_GETADDR_DEFINES=yes,
+			rsync_cv_HAVE_GETADDR_DEFINES=no)])
+if test x"$rsync_cv_HAVE_GETADDR_DEFINES" = x"yes"; then
+	# Tru64 UNIX has getaddrinfo() but has it renamed in libc as
+	# something else so we must include <netdb.h> to get the
+	# redefinition.
+	AC_CHECK_FUNCS(getaddrinfo, ,
+		[AC_MSG_CHECKING([for getaddrinfo by including <netdb.h>])
+		AC_TRY_LINK([#include <sys/types.h>
+		#include <sys/socket.h>
+		#include <netdb.h>],[getaddrinfo(NULL, NULL, NULL, NULL);],
+			[AC_MSG_RESULT([yes])
+			AC_DEFINE(HAVE_GETADDRINFO, 1,
+				[Define if you have the `getaddrinfo' function.])],
+			[AC_MSG_RESULT([no])
+			AC_LIBOBJ(lib/getaddrinfo)])])
+	AC_CHECK_FUNCS(getnameinfo, , AC_LIBOBJ(lib/getnameinfo))
+else
+	AC_LIBOBJ(lib/getaddrinfo)
+	AC_LIBOBJ(lib/getnameinfo)
+fi
+
+
+AC_CHECK_MEMBER([struct sockaddr.sa_len], 
+		[ AC_DEFINE(HAVE_SOCKADDR_LEN) ],
+		[],
+		[
+#include <sys/types.h>
+#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))
+
+AC_CHECK_MEMBER([struct sockaddr_in6.sin6_scope_id],
+		[ AC_DEFINE(HAVE_SOCKADDR_IN6_SCOPE_ID) ],
+		[],
+		[
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+])
+
+# if we can't find strcasecmp, look in -lresolv (for Unixware at least)
+#
+AC_CHECK_FUNCS(strcasecmp)
+if test x"$ac_cv_func_strcasecmp" = x"no"; then
+    AC_CHECK_LIB(resolv, strcasecmp)
+fi
+
+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_MEMCMP
-AC_FUNC_MMAP
 AC_FUNC_UTIME_NULL
-AC_CHECK_FUNCS(waitpid strtok pipe getcwd mkdir strdup strerror chown chmod mknod)
-AC_CHECK_FUNCS(fchmod fstat strchr bcopy bzero readlink link utime utimes)
-AC_CHECK_FUNCS(memmove getopt_long lchown setlinebuf)
+AC_FUNC_ALLOCA
+AC_CHECK_FUNCS(waitpid wait4 getcwd strdup strerror chown chmod mknod mkfifo)
+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 strtol mtrace mallinfo setgroups)
 
-echo $ac_n "checking for working fnmatch... $ac_c"
+AC_CACHE_CHECK([for working socketpair],rsync_cv_HAVE_SOCKETPAIR,[
+AC_TRY_RUN([
+#include <sys/types.h>
+#include <sys/socket.h>
+
+main() {
+       int fd[2];
+       exit((socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != -1) ? 0 : 1);
+}],
+rsync_cv_HAVE_SOCKETPAIR=yes,rsync_cv_HAVE_SOCKETPAIR=no,rsync_cv_HAVE_SOCKETPAIR=cross)])
+if test x"$rsync_cv_HAVE_SOCKETPAIR" = x"yes"; then
+    AC_DEFINE(HAVE_SOCKETPAIR, 1, [ ])
+fi
+
+AC_CACHE_CHECK([for working fnmatch],rsync_cv_HAVE_FNMATCH,[
 AC_TRY_RUN([#include <fnmatch.h>
-main() { exit(fnmatch("*.o", "x.o", 0) == 0? 0: 1); }],
-echo yes;AC_DEFINE(HAVE_FNMATCH), 
-echo no)
+main() { exit((fnmatch("*.o", "x.o", FNM_PATHNAME) == 0 &&
+               fnmatch("a/b/*", "a/b/c/d", FNM_PATHNAME) != 0) ? 0: 1); }],
+rsync_cv_HAVE_FNMATCH=yes,rsync_cv_HAVE_FNMATCH=no,rsync_cv_HAVE_FNMATCH=cross)])
+if test x"$rsync_cv_HAVE_FNMATCH" = x"yes"; then
+    AC_DEFINE(HAVE_FNMATCH, 1, [ ])
+fi
 
-echo $ac_n "checking for long long... $ac_c"
+if test x"$with_included_popt" != x"yes"
+then
+    AC_CHECK_LIB(popt, poptGetContext, , [with_included_popt=yes])
+fi
+
+AC_MSG_CHECKING([whether to use included libpopt])
+if test x"$with_included_popt" = x"yes"
+then
+    AC_MSG_RESULT($srcdir/popt)
+    BUILD_POPT='$(popt_OBJS)'
+    CFLAGS="$CFLAGS -I$srcdir/popt"
+    if test x"$ALLOCA" != x
+    then
+	# this can be removed when/if we add an included alloca.c;
+	#  see autoconf documentation on AC_FUNC_ALLOCA
+	AC_MSG_WARN([included libpopt will use malloc, not alloca (which wastes a small amount of memory)])
+    fi
+else
+    AC_MSG_RESULT(no)
+fi
+
+AC_CACHE_CHECK([for long long],rsync_cv_HAVE_LONGLONG,[
 AC_TRY_RUN([#include <stdio.h>
-main() { long long x = 1000000000000; char b[20]; sprintf(b,"%lld", x); exit(strcmp("1000000000000", b) == 0? 0: 1); }],
-echo yes;AC_DEFINE(HAVE_LONGLONG), 
-echo no)
+main() { long long x = 1000000; x *= x; exit(((x/1000000) == 1000000)? 0: 1); }],
+rsync_cv_HAVE_LONGLONG=yes,rsync_cv_HAVE_LONGLONG=no,rsync_cv_HAVE_LONGLONG=cross)])
+if test x"$rsync_cv_HAVE_LONGLONG" = x"yes"; then
+    AC_DEFINE(HAVE_LONGLONG, 1, [ ])
+fi
 
-echo $ac_n "checking for utimbuf ... $ac_c"
+AC_CACHE_CHECK([for off64_t],rsync_cv_HAVE_OFF64_T,[
+AC_TRY_RUN([#include <stdio.h>
+#include <sys/stat.h>
+main() { struct stat64 st; off64_t s; if (sizeof(off_t) == sizeof(off64_t)) exit(1); exit((lstat64("/dev/null", &st)==0)?0:1); }],
+rsync_cv_HAVE_OFF64_T=yes,rsync_cv_HAVE_OFF64_T=no,rsync_cv_HAVE_OFF64_T=cross)])
+if test x"$rsync_cv_HAVE_OFF64_T" = x"yes"; then
+    AC_DEFINE(HAVE_OFF64_T, 1, [ ])
+fi
+
+AC_CACHE_CHECK([for short ino_t],rsync_cv_HAVE_SHORT_INO_T,[
+AC_TRY_RUN([#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+main() { if (sizeof(ino_t) < sizeof(unsigned int)) return 0; return 1; }],
+rsync_cv_HAVE_SHORT_INO_T=yes,rsync_cv_HAVE_SHORT_INO_T=no,rsync_cv_HAVE_SHORT_INO_T=cross)])
+if test x"$rsync_cv_HAVE_SHORT_INO_T" = x"yes"; then
+    AC_DEFINE(HAVE_SHORT_INO_T, 1, [ ])
+fi
+
+AC_CACHE_CHECK([for unsigned char],rsync_cv_HAVE_UNSIGNED_CHAR,[
+AC_TRY_RUN([#include <stdio.h>
+main() { char c; c=250; exit((c > 0)?0:1); }],
+rsync_cv_HAVE_UNSIGNED_CHAR=yes,rsync_cv_HAVE_UNSIGNED_CHAR=no,rsync_cv_HAVE_UNSIGNED_CHAR=cross)])
+if test x"$rsync_cv_HAVE_UNSIGNED_CHAR" = x"yes"; then
+    AC_DEFINE(HAVE_UNSIGNED_CHAR, 1, [ ])
+fi
+
+AC_CACHE_CHECK([for broken readdir],rsync_cv_HAVE_BROKEN_READDIR,[
+AC_TRY_RUN([#include <sys/types.h>
+#include <dirent.h>
+main() { struct dirent *di; DIR *d = opendir("."); di = readdir(d);
+if (di && di->d_name[-2] == '.' && di->d_name[-1] == 0 &&
+di->d_name[0] == 0) exit(0); exit(1);} ],
+rsync_cv_HAVE_BROKEN_READDIR=yes,rsync_cv_HAVE_BROKEN_READDIR=no,rsync_cv_HAVE_BROKEN_READDIR=cross)])
+if test x"$rsync_cv_HAVE_BROKEN_READDIR" = x"yes"; then
+    AC_DEFINE(HAVE_BROKEN_READDIR, 1, [ ])
+fi
+
+AC_CACHE_CHECK([for utimbuf],rsync_cv_HAVE_UTIMBUF,[
 AC_TRY_COMPILE([#include <sys/types.h>
 #include <utime.h>],
-[struct utimbuf tbuf;  tbuf.actime = 0; tbuf.modtime = 1; return utime("foo.c",&tbuf);],
-echo yes;AC_DEFINE(HAVE_UTIMBUF), 
-echo no)
+[struct utimbuf tbuf;  tbuf.actime = 0; tbuf.modtime = 1; exit(utime("foo.c",&tbuf));],
+rsync_cv_HAVE_UTIMBUF=yes,rsync_cv_HAVE_UTIMBUF=no,rsync_cv_HAVE_UTIMBUF=cross)])
+if test x"$rsync_cv_HAVE_UTIMBUF" = x"yes"; then
+    AC_DEFINE(HAVE_UTIMBUF, 1, [ ])
+fi
 
-AC_OUTPUT(Makefile lib/dummy)
+AC_CACHE_CHECK([if gettimeofday takes tz argument],rsync_cv_HAVE_GETTIMEOFDAY_TZ,[
+AC_TRY_RUN([
+#include <sys/time.h>
+#include <unistd.h>
+main() { struct timeval tv; exit(gettimeofday(&tv, NULL));}],
+           rsync_cv_HAVE_GETTIMEOFDAY_TZ=yes,rsync_cv_HAVE_GETTIMEOFDAY_TZ=no,rsync_cv_HAVE_GETTIMEOFDAY_TZ=cross)])
+if test x"$rsync_cv_HAVE_GETTIMEOFDAY_TZ" = x"yes"; then
+    AC_DEFINE(HAVE_GETTIMEOFDAY_TZ, 1, [ ])
+fi
+
+AC_CACHE_CHECK([for C99 vsnprintf],rsync_cv_HAVE_C99_VSNPRINTF,[
+AC_TRY_RUN([
+#include <sys/types.h>
+#include <stdarg.h>
+void foo(const char *format, ...) { 
+       va_list ap;
+       int len;
+       char buf[5];
+
+       va_start(ap, format);
+       len = vsnprintf(0, 0, format, ap);
+       va_end(ap);
+       if (len != 5) exit(1);
+
+       if (snprintf(buf, 3, "hello") != 5 || strcmp(buf, "he") != 0) exit(1);
+
+       exit(0);
+}
+main() { foo("hello"); }
+],
+rsync_cv_HAVE_C99_VSNPRINTF=yes,rsync_cv_HAVE_C99_VSNPRINTF=no,rsync_cv_HAVE_C99_VSNPRINTF=cross)])
+if test x"$rsync_cv_HAVE_C99_VSNPRINTF" = x"yes"; then
+    AC_DEFINE(HAVE_C99_VSNPRINTF, 1, [ ])
+fi
+
+
+AC_CACHE_CHECK([for secure mkstemp],rsync_cv_HAVE_SECURE_MKSTEMP,[
+AC_TRY_RUN([#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+main() { 
+  struct stat st;
+  char tpl[20]="/tmp/test.XXXXXX"; 
+  int fd = mkstemp(tpl); 
+  if (fd == -1) exit(1);
+  unlink(tpl);
+  if (fstat(fd, &st) != 0) exit(1);
+  if ((st.st_mode & 0777) != 0600) exit(1);
+  exit(0);
+}],
+rsync_cv_HAVE_SECURE_MKSTEMP=yes,
+rsync_cv_HAVE_SECURE_MKSTEMP=no,
+rsync_cv_HAVE_SECURE_MKSTEMP=cross)])
+if test x"$rsync_cv_HAVE_SECURE_MKSTEMP" = x"yes"; then
+    AC_DEFINE(HAVE_SECURE_MKSTEMP, 1, [ ])
+fi
+
+
+AC_CACHE_CHECK([for broken inet_ntoa],rsync_cv_REPLACE_INET_NTOA,[
+AC_TRY_RUN([
+#include <stdio.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+main() { struct in_addr ip; ip.s_addr = 0x12345678;
+if (strcmp(inet_ntoa(ip),"18.52.86.120") &&
+    strcmp(inet_ntoa(ip),"120.86.52.18")) { exit(1); } 
+exit(0);}],
+           rsync_cv_REPLACE_INET_NTOA=no,rsync_cv_REPLACE_INET_NTOA=yes,rsync_cv_REPLACE_INET_NTOA=cross)])
+if test x"$rsync_cv_REPLACE_INET_NTOA" = x"yes"; then
+    AC_DEFINE(REPLACE_INET_NTOA, 1, [ ])
+fi
+
+
+AC_CACHE_CHECK([for broken inet_aton],rsync_cv_REPLACE_INET_ATON,[
+AC_TRY_RUN([
+#include <stdio.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+main() { struct in_addr ip; 
+if (inet_aton("example", &ip) == 0) exit(0); exit(1);}],
+           rsync_cv_REPLACE_INET_ATON=no,rsync_cv_REPLACE_INET_ATON=yes,rsync_cv_REPLACE_INET_ATON=cross)])
+if test x"$rsync_cv_REPLACE_INET_ATON" = x"yes"; then
+    AC_DEFINE(REPLACE_INET_ATON, 1, [ ])
+fi
+
+#
+# The following test was mostly taken from the tcl/tk plus patches
+#
+AC_CACHE_CHECK([whether -c -o works],rsync_cv_DASHC_WORKS_WITH_DASHO,[
+rm -rf conftest*
+cat > conftest.$ac_ext <<EOF
+int main() { return 0; }
+EOF
+${CC-cc} -c -o conftest..o conftest.$ac_ext
+if test -f conftest..o; then
+    rsync_cv_DASHC_WORKS_WITH_DASHO=yes
+else
+    rsync_cv_DASHC_WORKS_WITH_DASHO=no
+fi
+rm -rf conftest*
+])
+if test x"$rsync_cv_DASHC_WORKS_WITH_DASHO" = x"yes"; then
+    OBJ_SAVE="#"
+    OBJ_RESTORE="#"
+    CC_SHOBJ_FLAG='-o $@'
+else
+    OBJ_SAVE='	@b=`basename $@ .o`;rm -f $$b.o.sav;if test -f $$b.o; then mv $$b.o $$b.o.sav;fi;'
+    OBJ_RESTORE='	@b=`basename $@ .o`;if test "$$b.o" != "$@"; then mv $$b.o $@; if test -f $$b.o.sav; then mv $$b.o.sav $$b.o; fi; fi'
+    CC_SHOBJ_FLAG=""
+fi
+
+AC_SUBST(OBJ_SAVE)
+AC_SUBST(OBJ_RESTORE)
+AC_SUBST(CC_SHOBJ_FLAG)
+AC_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()

connection.c

@@ -0,0 +1,49 @@
+/* 
+   Copyright (C) Andrew Tridgell 1998
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* support the max connections option */
+#include "rsync.h"
+
+
+/****************************************************************************
+simple routine to do connection counting
+****************************************************************************/
+int claim_connection(char *fname,int max_connections)
+{
+	int fd, i;
+
+	if (max_connections <= 0)
+		return 1;
+
+	fd = open(fname,O_RDWR|O_CREAT, 0600);
+
+	if (fd == -1) {
+		return 0;
+	}
+
+	/* find a free spot */
+	for (i=0;i<max_connections;i++) {
+		if (lock_range(fd, i*4, 4)) return 1;
+	}		
+
+	/* only interested in open failures */
+	errno = 0;
+
+	close(fd);
+	return 0;
+}

csprotocol.txt

@@ -0,0 +1,82 @@
+This is kind of informal and may be wrong, but it helped me.  It's
+basically a summary of clientserver.c and authenticate.c.
+
+ -- Martin Pool <mbp@samba.org>
+
+$Id$
+
+
+
+
+This is the protocol used for rsync --daemon; i.e. connections to port
+873 rather than invocations over a remote shell.
+
+When the server accepts a connection, it prints a greeting
+
+  @RSYNCD: <version>
+
+where <version> is the numeric version; currently 24.  It follows this
+with a free text message-of-the-day.  It expects to see a similar
+greeting back from the client.
+
+The server is now in the connected state.  The client can either send
+the command
+
+  #list
+
+to get a listing of modules, or the name of a module.  After this, the
+connection is now bound to a particular module.  Access per host for
+this module is now checked, as is per-module connection limits.
+
+If authentication is required to use this module, the server will say
+
+  @RSYNCD: AUTHREQD <challenge>
+
+where <challenge> is a random string of base64 characters.  The client
+must respond with
+
+  <user> <response>
+
+where <user> is the username they claim to be, and <response> is the
+base64 form of the MD4 hash of challenge+password.
+
+At this point the server applies all remaining constraints before
+handing control to the client, including switching uid/gid, setting up
+include and exclude lists, moving to the root of the module, and doing
+chroot.
+
+If the login is acceptable, then the server will respond with
+
+  @RSYNCD: OK
+
+The client now writes some rsync options, as if it were remotely
+executing the command.  The server parses these arguments as if it had
+just been invoked with them, but they're added to the existing state.
+So if the client specifies a list of files to be included or excluded,
+they'll defer to existing limits specified in the server
+configuration.
+
+At this point the client and server both switch to using a
+multiplexing layer across the socket.  The main point of this is to
+allow the server to asynchronously pass errors back, while still
+allowing streamed and pipelined data.
+
+Unfortunately, the multiplex protocol is not used at every stage.  We
+start up in plain socket mode and then change over by calling
+io_start_buffering.  Of course both the client and the server have to
+do this at the same point.
+
+The server then talks to the client as normal across the socket,
+passing checksums, file lists and so on.  For documentation of that,
+stay tuned (or write it yourself!).
+
+
+
+------------
+Protocol version changes
+
+25	 (2001-08-20, 2.4.7pre2) 
+
+	 Send an explicit "@RSYNC EXIT" command at the end of the
+	 module listing.  We never intentionally end the transmission
+	 by just closing the socket anymore.

doc/.cvsignore

@@ -0,0 +1,2 @@
+rsync.pdf
+rsync.ps

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,351 @@
+<!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>
+	  <para>
+	    Why is rsync so much bigger when I build it with
+	    <command>gcc</command>?
+	  </para>
+	</question>
+	<answer>
+	  <para>
+	    On gcc, rsync builds by default with debug symbols
+	    included.  If you strip both executables, they should end
+	    up about the same size.  (Use <command>make
+	    install-strip</command>.)
+	  </para>
+	</answer>
+      </qandaentry>
+
+      
+      <qandaentry>
+	<question>
+	  <para>Is rsync useful for a single large file like an ISO image?</para>
+	</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*
+
+	  </para>
+	</answer>
+      </qandaentry>
+    </qandaset>
+  </chapter>
+
+
+  <appendix>
+    <title>Other Resources</title>
+    
+    <para><ulink url="http://www.ccp14.ac.uk/ccp14admin/rsync/"></ulink></para>
+  </appendix>
+</book>

errcode.h

@@ -0,0 +1,59 @@
+/* -*- c-file-style: "linux"; -*-
+   
+   Copyright (C) 1998-2000 by Andrew Tridgell
+   
+   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.
+*/
+
+/*
+ * error codes returned by rsync.  If you change these, please also update the
+ * string mappings in log.c and the EXIT VALUES in rsync.yo
+ */
+
+#define RERR_OK         0
+#define RERR_SYNTAX     1       /* syntax or usage error */
+#define RERR_PROTOCOL   2       /* protocol incompatibility */
+#define RERR_FILESELECT 3       /* errors selecting input/output files, dirs */
+#define RERR_UNSUPPORTED 4       /* requested action not supported */
+#define RERR_STARTCLIENT 5      /* error starting client-server protocol */
+
+#define RERR_SOCKETIO   10      /* error in socket IO */
+#define RERR_FILEIO     11      /* error in file IO */
+#define RERR_STREAMIO   12      /* error in rsync protocol data stream */
+#define RERR_MESSAGEIO  13      /* errors with program diagnostics */
+#define RERR_IPC        14      /* error in IPC code */
+
+#define RERR_SIGNAL     20      /* status returned when sent SIGUSR1, SIGINT */
+#define RERR_WAITCHILD  21      /* some error returned by waitpid() */
+#define RERR_MALLOC     22      /* error allocating core memory buffers */
+#define RERR_PARTIAL    23      /* partial transfer */
+
+#define RERR_TIMEOUT    30      /* timeout in data send/receive */
+
+/* Although it doesn't seem to be specified anywhere,
+ * ssh and the shell seem to return these values:
+ *
+ * 124 if the command exited with status 255
+ * 125 if the command is killed by a signal
+ * 126 if the command cannot be run
+ * 127 if the command is not found
+ *
+ * and we could use this to give a better explanation if the remote
+ * command is not found.
+ */
+#define RERR_CMD_FAILED 124
+#define RERR_CMD_KILLED 125
+#define RERR_CMD_RUN 126
+#define RERR_CMD_NOTFOUND 127

exclude.c

@@ -1,202 +1,418 @@
-/* 
-   Copyright (C) Andrew Tridgell 1996
-   Copyright (C) Paul Mackerras 1996
-   
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-   
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
+/* -*- c-file-style: "linux" -*-
+ * 
+ * Copyright (C) 1996-2001 by Andrew Tridgell <tridge@samba.org>
+ * Copyright (C) 1996 by Paul Mackerras
+ * 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
+ * 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.
+ */
 
-/*
-  a lot of this stuff was derived from GNU tar
-  */
+/* a lot of this stuff was originally derived from GNU tar, although
+   it has now changed so much that it is hard to tell :) */
+
+/* include/exclude cluestick added by Martin Pool <mbp@samba.org> */
 
 #include "rsync.h"
 
 extern int verbose;
-extern int am_server;
+extern int delete_mode;
 
-static char **exclude_list;
+static struct exclude_struct **exclude_list;
 
-static int is_regex(char *str)
+/** Build an exclude structure given a exclude pattern */
+static struct exclude_struct *make_exclude(const char *pattern, int include)
 {
-  return strchr(str, '*') || strchr(str, '[') || strchr(str, '?');
+	struct exclude_struct *ret;
+
+	ret = new(struct exclude_struct);
+	if (!ret) out_of_memory("make_exclude");
+
+	memset(ret, 0, sizeof(*ret));
+
+	if (strncmp(pattern,"- ",2) == 0) {
+		pattern += 2;
+	} else if (strncmp(pattern,"+ ",2) == 0) {
+		ret->include = 1;
+		pattern += 2;
+	} else {
+		ret->include = include;
+	}
+
+	ret->pattern = strdup(pattern);
+
+	if (!ret->pattern) out_of_memory("make_exclude");
+
+	if (strpbrk(pattern, "*[?")) {
+	    ret->regular_exp = 1;
+	    ret->fnmatch_flags = FNM_PATHNAME;
+	    if (strstr(pattern, "**")) {
+		    static int tested;
+		    if (!tested) {
+			    tested = 1;
+			    if (fnmatch("a/b/*", "a/b/c/d", FNM_PATHNAME)==0) {
+				    rprintf(FERROR,"WARNING: fnmatch FNM_PATHNAME is broken on your system\n");
+			    }
+		    }
+		    ret->fnmatch_flags = 0;
+	    }
+	}
+
+	if (strlen(pattern) > 1 && pattern[strlen(pattern)-1] == '/') {
+		ret->pattern[strlen(pattern)-1] = 0;
+		ret->directory = 1;
+	}
+
+	if (!strchr(ret->pattern,'/')) {
+		ret->local = 1;
+	}
+
+	return ret;
+}
+
+static void free_exclude(struct exclude_struct *ex)
+{
+	free(ex->pattern);
+	memset(ex,0,sizeof(*ex));
+	free(ex);
+}
+
+static int check_one_exclude(char *name, struct exclude_struct *ex,
+                             STRUCT_STAT *st)
+{
+	char *p;
+	int match_start=0;
+	char *pattern = ex->pattern;
+
+	if (ex->local && (p=strrchr(name,'/')))
+		name = p+1;
+
+	if (!name[0]) return 0;
+
+	if (ex->directory && !S_ISDIR(st->st_mode)) return 0;
+
+	if (*pattern == '/' && *name != '/') {
+		match_start = 1;
+		pattern++;
+	}
+
+	if (ex->regular_exp) {
+		if (fnmatch(pattern, name, ex->fnmatch_flags) == 0) {
+			return 1;
+		}
+	} else {
+		int l1 = strlen(name);
+		int l2 = strlen(pattern);
+		if (l2 <= l1 && 
+		    strcmp(name+(l1-l2),pattern) == 0 &&
+		    (l1==l2 || (!match_start && name[l1-(l2+1)] == '/'))) {
+			return 1;
+		}
+	}
+
+	return 0;
 }
 
 
-static int check_one_exclude(char *name,char *pattern)
+static void report_exclude_result(char const *name,
+                                  struct exclude_struct const *ent,
+                                  STRUCT_STAT const *st)
 {
-  char *p;
-
-  if (!strchr(pattern,'/') && (p=strrchr(name,'/')))
-    name = p+1;
-
-  if (!name[0]) return 0;
-
-  if (is_regex(pattern)) {
-    if (fnmatch(pattern, name, 0) == 0)
-      return 1;
-  } else {
-    int l1 = strlen(name);
-    int l2 = strlen(pattern);
-    if (l2 <= l1 && 
-	strcmp(name+(l1-l2),pattern) == 0 &&
-	(l1==l2 || name[l1-(l2+1)] == '/'))
-      return 1;
-  }
-
-  return 0;
+        /* If a trailing slash is present to match only directories,
+         * then it is stripped out by make_exclude.  So as a special
+         * case we add it back in here. */
+        
+        if (verbose >= 2)
+                rprintf(FINFO, "%s %s %s because of pattern %s%s\n",
+                        ent->include ? "including" : "excluding",
+                        S_ISDIR(st->st_mode) ? "directory" : "file",
+                        name, ent->pattern,
+                        ent->directory ? "/" : "");
 }
 
 
-int check_exclude(char *name,char **local_exclude_list)
+/*
+ * Return true if file NAME is defined to be excluded by either
+ * LOCAL_EXCLUDE_LIST or the globals EXCLUDE_LIST.
+ */
+int check_exclude(char *name, struct exclude_struct **local_exclude_list,
+		  STRUCT_STAT *st)
 {
-  int n;
+	int n;
+        struct exclude_struct *ent;
 
-  if (exclude_list) {
-    for (n=0; exclude_list[n]; n++)
-      if (check_one_exclude(name,exclude_list[n]))
-	return 1;
-  }
+	if (name && (name[0] == '.') && !name[1])
+		/* never exclude '.', even if somebody does --exclude '*' */
+		return 0;
 
-  if (local_exclude_list) {
-    for (n=0; local_exclude_list[n]; n++)
-      if (check_one_exclude(name,local_exclude_list[n]))
-	return 1;      
-  }
+	if (exclude_list) {
+		for (n=0; exclude_list[n]; n++) {
+                        ent = exclude_list[n];
+			if (check_one_exclude(name, ent, st)) {
+                                report_exclude_result(name, ent, st);
+				return !ent->include;
+                        }
+                }
+	}
 
-  return 0;
+	if (local_exclude_list) {
+		for (n=0; local_exclude_list[n]; n++) {
+                        ent = local_exclude_list[n];
+			if (check_one_exclude(name, ent, st)) {
+                                report_exclude_result(name, ent, st);
+				return !ent->include;
+                        }
+                }
+	}
+
+	return 0;
 }
 
 
-void add_exclude_list(char *pattern,char ***list)
+void add_exclude_list(const char *pattern, struct exclude_struct ***list, int include)
 {
-  int len=0;
-  if (list && *list)
-    for (; (*list)[len]; len++) ;
+	int len=0;
+	if (list && *list)
+		for (; (*list)[len]; len++) ;
 
-  if (strcmp(pattern,"!") == 0) {
-    if (verbose > 2)
-      fprintf(FINFO,"clearing exclude list\n");
-    while ((len)--) 
-      free((*list)[len]);
-    free((*list));
-    *list = NULL;
-    return;
-  }
+	if (strcmp(pattern,"!") == 0) {
+		if (verbose > 2)
+			rprintf(FINFO,"clearing exclude list\n");
+		while ((len)--) {
+			free_exclude((*list)[len]);
+		}
+		free((*list));
+		*list = NULL;
+		return;
+	}
 
-  if (!*list) {
-    *list = (char **)malloc(sizeof(char *)*2);
-  } else {
-    *list = (char **)realloc(*list,sizeof(char *)*(len+2));
-  }
+	*list = realloc_array(*list, struct exclude_struct *, len+2);
+	
+	if (!*list || !((*list)[len] = make_exclude(pattern, include)))
+		out_of_memory("add_exclude");
+	
+	if (verbose > 2) {
+		rprintf(FINFO,"add_exclude(%s,%s)\n",pattern,
+			      include ? "include" : "exclude");
+	}
 
-  if (!*list || !((*list)[len] = strdup(pattern)))
-    out_of_memory("add_exclude");
-
-  if (verbose > 2)
-    fprintf(FINFO,"add_exclude(%s)\n",pattern);
-  
-  (*list)[len+1] = NULL;
+	(*list)[len+1] = NULL;
 }
 
-void add_exclude(char *pattern)
+void add_exclude(const char *pattern, int include)
 {
-  add_exclude_list(pattern,&exclude_list);
+	add_exclude_list(pattern,&exclude_list, include);
 }
 
-char **make_exclude_list(char *fname,char **list1,int fatal)
+struct exclude_struct **make_exclude_list(const char *fname,
+					  struct exclude_struct **list1,
+					  int fatal, int include)
 {
-  char **list=list1;
-  FILE *f = fopen(fname,"r");
-  char line[MAXPATHLEN];
-  if (!f) {
-    if (fatal) {
-      fprintf(FERROR,"%s : %s\n",fname,strerror(errno));
-      exit_cleanup(1);
-    }
-    return list;
-  }
+	struct exclude_struct **list=list1;
+	FILE *f;
+	char line[MAXPATHLEN];
 
-  while (fgets(line,MAXPATHLEN,f)) {
-    int l = strlen(line);
-    if (l && line[l-1] == '\n') l--;
-    line[l] = 0;
-    if (line[0]) add_exclude_list(line,&list);
-  }
-  fclose(f);
-  return list;
+	if (strcmp(fname, "-")) {
+		f = fopen(fname,"r");
+	} else {
+		f = fdopen(0, "r");
+	}
+	if (!f) {
+		if (fatal) {
+			rsyserr(FERROR, errno,
+                                "failed to open %s file %s",
+                                include ? "include" : "exclude",
+                                fname);
+			exit_cleanup(RERR_FILEIO);
+		}
+		return list;
+	}
+
+	while (fgets(line,MAXPATHLEN,f)) {
+		int l = strlen(line);
+		while (l && (line[l-1] == '\n' || line[l-1] == '\r')) l--;
+		line[l] = 0;
+		if (line[0] && (line[0] != ';') && (line[0] != '#')) {
+			/* Skip lines starting with semicolon or pound.
+			   It probably wouldn't cause any harm to not skip
+			     them but there's no need to save them. */
+			add_exclude_list(line,&list,include);
+		}
+	}
+	fclose(f);
+	return list;
 }
 
 
-void add_exclude_file(char *fname,int fatal)
+void add_exclude_file(const char *fname, int fatal, int include)
 {
-  exclude_list = make_exclude_list(fname,exclude_list,fatal);
+	if (!fname || !*fname) return;
+
+	exclude_list = make_exclude_list(fname,exclude_list,fatal,include);
 }
 
 
 void send_exclude_list(int f)
 {
-  int i;
-  if (exclude_list) 
-    for (i=0;exclude_list[i];i++) {
-      int l = strlen(exclude_list[i]);
-      if (l == 0) continue;
-      write_int(f,l);
-      write_buf(f,exclude_list[i],l);
-    }    
-  write_int(f,0);
+	int i;
+	extern int remote_version;
+	extern int list_only, recurse;
+
+	/* 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);
+	}
+
+	if (!exclude_list) {
+		write_int(f,0);
+		return;
+	}
+
+	for (i=0;exclude_list[i];i++) {
+		int l;
+		char pattern[MAXPATHLEN];
+
+		strlcpy(pattern,exclude_list[i]->pattern,sizeof(pattern)); 
+		if (exclude_list[i]->directory) strlcat(pattern,"/", sizeof(pattern));
+
+		l = strlen(pattern);
+		if (l == 0) continue;
+		if (exclude_list[i]->include) {
+			if (remote_version < 19) {
+				rprintf(FERROR,"remote rsync does not support include syntax - aborting\n");
+				exit_cleanup(RERR_UNSUPPORTED);
+			}
+			write_int(f,l+2);
+			write_buf(f,"+ ",2);
+		} else {
+			write_int(f,l);
+		}
+		write_buf(f,pattern,l);
+	}    
+
+	write_int(f,0);
 }
 
 
 void recv_exclude_list(int f)
 {
-  char line[MAXPATHLEN];
-  int l;
-  while ((l=read_int(f))) {
-	  if (l >= MAXPATHLEN) overflow("recv_exclude_list");
-	  read_sbuf(f,line,l);
-	  add_exclude(line);
-  }
+	char line[MAXPATHLEN];
+	unsigned int l;
+
+	while ((l=read_int(f))) {
+		if (l >= MAXPATHLEN) overflow("recv_exclude_list");
+		read_sbuf(f,line,l);
+		add_exclude(line,0);
+	}
+}
+
+/* Get the next include/exclude arg from the string. It works in a similar way
+** to strtok - initially an arg is sent over, from then on NULL. This
+** routine takes into account any +/- in the strings and does not
+** consider the space following it as a delimeter.
+*/
+char *get_exclude_tok(char *p)
+{
+	static char *s;
+	static int more;
+	char *t;
+
+	if (p) {
+		s=p;
+		if (*p)
+			more=1;
+	}
+
+	if (!more)
+		return(NULL);
+
+	/* Skip over any initial spaces */
+	while (isspace(* (unsigned char *) s))
+		s++;
+
+	/* Are we at the end of the string? */
+	if (*s) {
+		/* remember the beginning of the token */
+		t=s;
+
+		/* Is this a '+' or '-' followed by a space (not whitespace)? */
+		if ((*s=='+' || *s=='-') && *(s+1)==' ')
+			s+=2;
+	
+		/* Skip to the next space or the end of the string */
+		while (!isspace(* (unsigned char *) s) && *s != '\0')
+			s++;
+	} else {
+		t=NULL;
+	}
+
+	/* Have we reached the end of the string? */
+	if (*s)
+		*s++='\0';
+	else
+		more=0;
+	return(t);
+}
+
+	
+void add_exclude_line(char *p)
+{
+	char *tok;
+	if (!p || !*p) return;
+	p = strdup(p);
+	if (!p) out_of_memory("add_exclude_line");
+ 	for (tok=get_exclude_tok(p); tok; tok=get_exclude_tok(NULL))
+		add_exclude(tok, 0);
+	free(p);
+}
+
+void add_include_line(char *p)
+{
+	char *tok;
+	if (!p || !*p) return;
+	p = strdup(p);
+	if (!p) out_of_memory("add_include_line");
+	for (tok=get_exclude_tok(p); tok; tok=get_exclude_tok(NULL))
+		add_exclude(tok, 1);
+	free(p);
 }
 
 
 static char *cvs_ignore_list[] = {
-  "RCS","SCCS","CVS","CVS.adm","RCSLOG","cvslog.*",
-  "tags","TAGS",".make.state",".nse_depinfo",
-  "*~", "#*", ".#*", ",*", "*.old", "*.bak", "*.BAK", "*.orig",
+  "RCS/", "SCCS/", "CVS/", ".svn/", "CVS.adm", "RCSLOG", "cvslog.*",
+  "tags", "TAGS", ".make.state", ".nse_depinfo",
+  "*~", "#*", ".#*", ", *", "*.old", "*.bak", "*.BAK", "*.orig",
   "*.rej", ".del-*", "*.a", "*.o", "*.obj", "*.so", "*.Z", "*.elc", "*.ln",
-  "core",NULL};
-
+  "core", NULL};
 
 
 void add_cvs_excludes(void)
 {
-  char fname[MAXPATHLEN];
-  char *p;
-  int i;
+	char fname[MAXPATHLEN];
+	char *p;
+	int i;
   
-  for (i=0; cvs_ignore_list[i]; i++)
-    add_exclude(cvs_ignore_list[i]);
+	for (i=0; cvs_ignore_list[i]; i++)
+		add_exclude(cvs_ignore_list[i], 0);
 
-  if ((p=getenv("HOME")) && strlen(p) < (MAXPATHLEN-12)) {
-    sprintf(fname,"%s/.cvsignore",p);
-    add_exclude_file(fname,0);
-  }
+	if ((p=getenv("HOME")) && strlen(p) < (MAXPATHLEN-12)) {
+		snprintf(fname,sizeof(fname), "%s/.cvsignore",p);
+		add_exclude_file(fname,0,0);
+	}
 
-  if ((p=getenv("CVSIGNORE"))) {
-    char *tok;
-    for (tok=strtok(p," "); tok; tok=strtok(NULL," "))
-      add_exclude(tok);
-  }
+	add_exclude_line(getenv("CVSIGNORE"));
 }

fileio.c

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

generator.c

@@ -0,0 +1,590 @@
+/* -*- 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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "rsync.h"
+
+extern int verbose;
+extern int dry_run;
+extern int relative_paths;
+extern int preserve_links;
+extern int am_root;
+extern int preserve_devices;
+extern int preserve_hard_links;
+extern int update_only;
+extern int opt_ignore_existing;
+extern int csum_length;
+extern int ignore_times;
+extern int size_only;
+extern int io_timeout;
+extern int protocol_version;
+extern int always_checksum;
+extern int modify_window;
+extern char *compare_dest;
+extern int link_dest;
+
+
+/* choose whether to skip a particular file */
+static int skip_file(char *fname,
+		     struct file_struct *file, STRUCT_STAT *st)
+{
+	if (st->st_size != file->length) {
+		return 0;
+	}
+	if (link_dest) {
+		extern int preserve_perms;
+		extern int preserve_uid;
+		extern int preserve_gid;
+
+		if(preserve_perms
+		    && (st->st_mode & ~_S_IFMT) !=  (file->mode & ~_S_IFMT))
+			return 0;
+
+		if (preserve_uid && st->st_uid != file->uid)
+			return 0;
+
+		if (preserve_gid && st->st_gid != file->gid)
+			return 0;
+	}
+
+	/* if always checksum is set then we use the checksum instead
+	   of the file time to determine whether to sync */
+	if (always_checksum && S_ISREG(st->st_mode)) {
+		char sum[MD4_SUM_LENGTH];
+		char fnamecmpdest[MAXPATHLEN];
+
+		if (compare_dest != NULL) {
+			if (access(fname, 0) != 0) {
+				snprintf(fnamecmpdest,MAXPATHLEN,"%s/%s",
+					 compare_dest,fname);
+				fname = fnamecmpdest;
+			}
+		}
+		file_checksum(fname,sum,st->st_size);
+		if (protocol_version < 21) {
+			return (memcmp(sum,file->sum,2) == 0);
+		} else {
+			return (memcmp(sum,file->sum,MD4_SUM_LENGTH) == 0);
+		}
+	}
+
+	if (size_only) {
+		return 1;
+	}
+
+	if (ignore_times) {
+		return 0;
+	}
+
+	return (cmp_modtime(st->st_mtime,file->modtime) == 0);
+}
+
+
+/*
+ * 	NULL sum_struct means we have no checksums
+ */
+
+void write_sum_head(int f, struct sum_struct *sum)
+{
+	static struct sum_struct null_sum;
+
+	if (sum == (struct sum_struct *)NULL)
+		sum = &null_sum;
+
+	write_int(f, sum->count);
+	write_int(f, sum->blength);
+	if (protocol_version >= 27)
+		write_int(f, sum->s2length);
+	write_int(f, sum->remainder);
+}
+
+/* 
+ * set (initialize) the size entries in the per-file sum_struct
+ * calulating dynamic block ans checksum sizes.
+ *
+ * This is only called from generate_and_send_sums() but is a seperate
+ * function to encapsulate the logic.
+ *
+ * The block size is a rounded square root of file length.
+ *
+ * The checksum size is determined according to:
+ *     blocksum_bits = BLOCKSUM_EXP + 2*log2(file_len) - log2(block_len)
+ * provided by Donovan Baarda which gives a probability of rsync
+ * algorithm corrupting data and falling back using the whole md4
+ * checksums.
+ *
+ * This might be made one of several selectable heuristics.
+ */
+
+static void sum_sizes_sqroot_baarda(struct sum_struct *sum, uint64 len)
+{
+	extern int block_size;
+	int blength, s2length, b;
+	uint32 c;
+	uint64 l;
+
+	if (block_size) {
+		blength = block_size;
+	} else if (len <= BLOCK_SIZE * BLOCK_SIZE) {
+		blength = BLOCK_SIZE;
+	} else {
+		l = len;
+		c = 1;
+		while (l >>= 2) {
+			c <<= 1;
+		}
+		blength = 0;
+		do {
+			blength |= c;
+			if (len < (uint64)blength * blength)
+				blength &= ~c;
+			c >>= 1;
+		} while (c >= 8);	/* round to multiple of 8 */
+		blength = MAX(blength, BLOCK_SIZE);
+	}
+
+	if (protocol_version < 27) {
+		s2length = csum_length;
+	} else if (csum_length == SUM_LENGTH) {
+		s2length = SUM_LENGTH;
+	} else {
+		b = BLOCKSUM_BIAS;
+		l = len;
+		while (l >>= 1) {
+			b += 2;
+		}
+		c = blength;
+		while (c >>= 1 && b) {
+			b--;
+		}
+		s2length = (b + 1 - 32 + 7) / 8; /* add a bit,
+						  * subtract rollsum,
+						  * round up
+						  *    --optimize in compiler--
+						  */
+		s2length = MAX(s2length, csum_length);
+		s2length = MIN(s2length, SUM_LENGTH);
+	}
+
+	sum->flength	= len;
+	sum->blength	= blength;
+	sum->s2length	= s2length;
+	sum->count	= (len + (blength - 1)) / blength;
+	sum->remainder	= (len % blength);
+
+	if (sum->count && verbose > 2) {
+		rprintf(FINFO, "count=%ld rem=%ld blength=%ld s2length=%ld flength=%.0f\n",
+			(long) sum->count, (long) sum->remainder,
+			(long) sum->blength, (long) sum->s2length,
+			(double) sum->flength);
+	}
+}
+
+/**
+ * Perhaps we want to just send an empty checksum set for this file,
+ * which will force the whole thing to be literally transferred.
+ *
+ * When do we do this?  If the user's explicitly said they
+ * want the whole thing, or if { they haven't explicitly
+ * requested a delta, and it's local but not batch mode.}
+ *
+ * Whew. */
+static BOOL disable_deltas_p(void)
+{
+	extern int whole_file;
+	extern int local_server;
+	extern int write_batch;
+
+	if (whole_file > 0)
+		return True;
+	if (whole_file == 0 || write_batch)
+		return False;
+	return local_server;
+}
+
+
+/*
+ * Generate and send a stream of signatures/checksums that describe a buffer
+ *
+ * Generate approximately one checksum every block_len bytes.
+ */
+static void generate_and_send_sums(struct map_struct *buf, OFF_T len, int f_out)
+{
+	size_t i;
+	struct sum_struct sum;
+	OFF_T offset = 0;
+
+	sum_sizes_sqroot_baarda(&sum, len);
+
+	write_sum_head(f_out, &sum);
+
+	for (i = 0; i < sum.count; i++) {
+		int n1 = MIN(len, sum.blength);
+		char *map = map_ptr(buf, offset, n1);
+		uint32 sum1 = get_checksum1(map, n1);
+		char sum2[SUM_LENGTH];
+
+		get_checksum2(map, n1, sum2);
+
+		if (verbose > 3) {
+			rprintf(FINFO,
+				"chunk[%ld] offset=%.0f len=%d sum1=%08lx\n",
+				(long)i,(double)offset,n1,(unsigned long)sum1);
+		}
+		write_int(f_out, sum1);
+		write_buf(f_out, sum2, sum.s2length);
+		len -= n1;
+		offset += n1;
+	}
+}
+
+
+
+/**
+ * Acts on file number @p i from @p flist, whose name is @p fname.
+ *
+ * First fixes up permissions, then generates checksums for the file.
+ *
+ * @note This comment was added later by mbp who was trying to work it
+ * out.  It might be wrong.
+ **/
+void recv_generator(char *fname, struct file_list *flist, int i, int f_out)
+{
+	int fd;
+	STRUCT_STAT st;
+	struct map_struct *buf;
+	int statret;
+	struct file_struct *file = flist->files[i];
+	char *fnamecmp;
+	char fnamecmpbuf[MAXPATHLEN];
+	extern char *compare_dest;
+	extern int list_only;
+	extern int preserve_perms;
+	extern int only_existing;
+	extern int orig_umask;
+
+	if (list_only) return;
+
+	if (verbose > 2)
+		rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
+
+	statret = link_stat(fname,&st);
+
+	if (only_existing && statret == -1 && errno == ENOENT) {
+		/* we only want to update existing files */
+		if (verbose > 1) rprintf(FINFO, "not creating new file \"%s\"\n",fname);
+		return;
+	}
+
+	if (statret == 0 &&
+	    !preserve_perms &&
+	    (S_ISDIR(st.st_mode) == S_ISDIR(file->mode))) {
+		/* if the file exists already and we aren't perserving
+		 * permissions then act as though the remote end sent
+		 * us the file permissions we already have */
+		file->mode = (file->mode & _S_IFMT) | (st.st_mode & ~_S_IFMT);
+	}
+
+	if (S_ISDIR(file->mode)) {
+		/* The file to be received is a directory, so we need
+		 * to prepare appropriately.  If there is already a
+		 * file of that name and it is *not* a directory, then
+		 * we need to delete it.  If it doesn't exist, then
+		 * recursively create it. */
+
+		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 to make room for directory: %s\n",
+					full_fname(fname), strerror(errno));
+				return;
+			}
+			statret = -1;
+		}
+		if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
+			if (!(relative_paths && errno==ENOENT &&
+			      create_directory_path(fname, orig_umask)==0 &&
+			      do_mkdir(fname,file->mode)==0)) {
+				rprintf(FERROR, "recv_generator: mkdir %s failed: %s\n",
+					full_fname(fname), strerror(errno));
+			}
+		}
+		/* 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;
+	}
+
+	if (preserve_links && S_ISLNK(file->mode)) {
+#if SUPPORT_LINKS
+		char lnk[MAXPATHLEN];
+		int l;
+		extern int safe_symlinks;
+
+		if (safe_symlinks && unsafe_symlink(file->link, fname)) {
+			if (verbose) {
+				rprintf(FINFO, "ignoring unsafe symlink %s -> \"%s\"\n",
+					full_fname(fname), file->link);
+			}
+			return;
+		}
+		if (statret == 0) {
+			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\" failed: %s\n",
+				full_fname(fname), file->link, strerror(errno));
+		} else {
+			set_perms(fname,file,NULL,0);
+			if (verbose) {
+				rprintf(FINFO,"%s -> %s\n", fname,file->link);
+			}
+		}
+#endif
+		return;
+	}
+
+#ifdef HAVE_MKNOD
+	if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
+		if (statret != 0 ||
+		    st.st_mode != file->mode ||
+		    (DEV64_T)st.st_rdev != file->rdev) {
+			delete_file(fname);
+			if (verbose > 2)
+				rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
+					fname,(int)file->mode,(int)file->rdev);
+			if (do_mknod(fname,file->mode,file->rdev) != 0) {
+				rprintf(FERROR, "mknod %s failed: %s\n",
+					full_fname(fname), strerror(errno));
+			} else {
+				set_perms(fname,file,NULL,0);
+				if (verbose)
+					rprintf(FINFO,"%s\n",fname);
+			}
+		} else {
+			set_perms(fname,file,&st,1);
+		}
+		return;
+	}
+#endif
+
+	if (preserve_hard_links && check_hard_link(file)) {
+		if (verbose > 1)
+			rprintf(FINFO, "recv_generator: \"%s\" is a hard link\n",f_name(file));
+		return;
+	}
+
+	if (!S_ISREG(file->mode)) {
+		rprintf(FINFO, "skipping non-regular file \"%s\"\n",fname);
+		return;
+	}
+
+	fnamecmp = fname;
+
+	if ((statret == -1) && (compare_dest != NULL)) {
+		/* try the file at compare_dest instead */
+		int saveerrno = errno;
+		snprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname);
+		statret = link_stat(fnamecmpbuf,&st);
+		if (!S_ISREG(st.st_mode))
+			statret = -1;
+		if (statret == -1)
+			errno = saveerrno;
+#if HAVE_LINK
+		else if (link_dest && !dry_run) {
+			if (do_link(fnamecmpbuf, fname) != 0) {
+				if (verbose > 0)
+					rprintf(FINFO,"link %s => %s : %s\n",
+						fnamecmpbuf,
+						fname,
+						strerror(errno));
+			}
+			fnamecmp = fnamecmpbuf;
+		}
+#endif
+		else
+			fnamecmp = fnamecmpbuf;
+	}
+
+	if (statret == -1) {
+		if (errno == ENOENT) {
+			write_int(f_out,i);
+			if (!dry_run) write_sum_head(f_out, NULL);
+		} else if (verbose > 1) {
+			rprintf(FERROR,
+				"recv_generator: failed to open %s: %s\n",
+				full_fname(fname), strerror(errno));
+		}
+		return;
+	}
+
+	if (!S_ISREG(st.st_mode)) {
+		if (delete_file(fname) != 0) {
+			return;
+		}
+
+		/* now pretend the file didn't exist */
+		write_int(f_out,i);
+		if (!dry_run) write_sum_head(f_out, NULL);
+		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);
+		return;
+	}
+
+	if (skip_file(fname, file, &st)) {
+		if (fnamecmp == fname)
+			set_perms(fname,file,&st,1);
+		return;
+	}
+
+	if (dry_run) {
+		write_int(f_out,i);
+		return;
+	}
+
+	if (disable_deltas_p()) {
+		write_int(f_out,i);
+		write_sum_head(f_out, NULL);
+		return;
+	}
+
+	/* open the file */
+	fd = do_open(fnamecmp, O_RDONLY, 0);
+
+	if (fd == -1) {
+		rprintf(FERROR, "failed to open %s, continuing: %s\n",
+			full_fname(fnamecmp), strerror(errno));
+		/* pretend the file didn't exist */
+		write_int(f_out,i);
+		write_sum_head(f_out, NULL);
+		return;
+	}
+
+	if (st.st_size > 0) {
+		buf = map_file(fd,st.st_size);
+	} else {
+		buf = NULL;
+	}
+
+	if (verbose > 3)
+		rprintf(FINFO,"gen mapped %s of size %.0f\n",fnamecmp,(double)st.st_size);
+
+	if (verbose > 2)
+		rprintf(FINFO, "generating and sending sums for %d\n", i);
+
+	write_int(f_out,i);
+	generate_and_send_sums(buf, st.st_size, f_out);
+
+	close(fd);
+	if (buf) unmap_file(buf);
+}
+
+
+
+void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
+{
+	int i;
+	int phase=0;
+
+	if (verbose > 2)
+		rprintf(FINFO,"generator starting pid=%d count=%d\n",
+			(int)getpid(),flist->count);
+
+	if (verbose >= 2) {
+		rprintf(FINFO,
+			disable_deltas_p()
+			? "delta-transmission disabled for local transfer or --whole-file\n"
+			: "delta transmission enabled\n");
+	}
+
+	/* we expect to just sit around now, so don't exit on a
+	   timeout. If we really get a timeout then the other process should
+	   exit */
+	io_timeout = 0;
+
+	for (i = 0; i < flist->count; i++) {
+		struct file_struct *file = flist->files[i];
+		mode_t saved_mode = file->mode;
+		if (!file->basename) continue;
+
+		/* we need to ensure that any directories we create have writeable
+		   permissions initially so that we can create the files within
+		   them. This is then fixed after the files are transferred */
+		if (!am_root && S_ISDIR(file->mode)) {
+			file->mode |= S_IWUSR; /* user write */
+			/* XXX: Could this be causing a problem on SCO?  Perhaps their
+			 * handling of permissions is strange? */
+		}
+
+		recv_generator(local_name?local_name:f_name(file), flist,i,f);
+
+		file->mode = saved_mode;
+	}
+
+	phase++;
+	csum_length = SUM_LENGTH;
+	ignore_times=1;
+
+	if (verbose > 2)
+		rprintf(FINFO,"generate_files phase=%d\n",phase);
+
+	write_int(f,-1);
+
+	/* files can cycle through the system more than once
+	 * to catch initial checksum errors */
+	for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
+		struct file_struct *file = flist->files[i];
+		recv_generator(local_name?local_name:f_name(file), flist,i,f);
+	}
+
+	phase++;
+	if (verbose > 2)
+		rprintf(FINFO,"generate_files phase=%d\n",phase);
+
+	write_int(f,-1);
+}

getgroups.c

@@ -0,0 +1,50 @@
+/*
+ * 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
+ * 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 getgroups.c
+ *
+ * Print out the gids of all groups for the current user.  This is
+ * like `id -G` on Linux, but it's too hard to find a portable
+ * equivalent.
+ **/
+
+#include "rsync.h"
+
+#ifndef NGROUPS
+/* It ought to be defined, but just in case. */
+#  define NGROUPS 32
+#endif
+
+int
+main(UNUSED(int argc), UNUSED(char *argv[]))
+{
+	int n, i;
+	gid_t list[NGROUPS];
+
+	if ((n = getgroups(NGROUPS, list)) == -1) {
+		perror("getgroups");
+		return 1;
+	}
+
+	for (i = 0; i < n; i++) 
+		printf("%u ", list[i]);
+	printf("\n");
+		
+	return 0;
+}

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
@@ -19,24 +20,26 @@
 
 #include "rsync.h"
 
-extern int am_server;
 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);
 }
 
 
@@ -48,22 +51,23 @@ 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 = new_array(struct file_struct, flist->count)))
 		out_of_memory("init_hard_links");
 
 	for (i = 0; i < flist->count; i++)
-		bcopy(flist->files[i], &hlink_list[i], sizeof(hlink_list[0]));
+		memcpy(&hlink_list[i], flist->files[i],
+		       sizeof(hlink_list[0]));
 
-	qsort(hlink_list,flist->count,
-	      sizeof(hlink_list[0]),
-	      (int (*)())hlink_compare);
+	qsort(hlink_list, flist->count,
+	      sizeof(hlink_list[0]), (int (*)()) hlink_compare);
 
-	hlink_count=flist->count;
+	hlink_count = flist->count;
 #endif
 }
 
@@ -72,86 +76,109 @@ 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;
+	/* XXX: To me this looks kind of dodgy -- why do we use [low]
+	 * here and [low-1] below? -- mbp */
+	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) {
+		if (verbose >= 2) {
+			rprintf(FINFO, "check_hard_link: \"%s\" is a hard link to file %d, \"%s\"\n",
+				f_name(file), low-1, f_name(&hlink_list[low-1]));
+		}
+		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)
-				fprintf(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 (do_unlink(f_name(&hlink_list[i])) != 0 ||
-		    do_link(f_name(&hlink_list[i-1]),f_name(&hlink_list[i])) != 0) {
+		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) {
 			if (verbose > 0)
-				fprintf(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)
-		fprintf(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
 }

install-sh

@@ -208,7 +208,7 @@ else
 
 # Make a temp file name in the proper directory.
 
-	dsttmp=$dstdir/#inst.$$#
+	dsttmp=$dstdir/_inst.$$_
 
 # Move or copy the file name to the temp name
 

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

lib/fnmatch.c

@@ -1,204 +0,0 @@
-#include "../rsync.h"
-#ifndef HAVE_FNMATCH
-
-/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
-
-NOTE: The canonical source of this file is maintained with the GNU C Library.
-Bugs can be reported to bug-glibc@prep.ai.mit.edu.
-
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-#if defined (STDC_HEADERS) || !defined (isascii)
-#define ISASCII(c) 1
-#else
-#define ISASCII(c) isascii(c)
-#endif
-
-#define ISUPPER(c) (ISASCII (c) && isupper (c))
-
-
-/* Comment out all this code if we are using the GNU C Library, and are not
-   actually compiling the library itself.  This code is part of the GNU C
-   Library, but also included in many other GNU distributions.  Compiling
-   and linking in this code is a waste when using the GNU C library
-   (especially if it is a shared library).  Rather than having every GNU
-   program understand `configure --with-gnu-libc' and omit the object files,
-   it is simpler to just do this in the source for each such file.  */
-
-#if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS)
-extern int errno;
-#endif
-
-/* Match STRING against the filename pattern PATTERN, returning zero if
-   it matches, nonzero if not.  */
-int
-fnmatch (pattern, string, flags)
-     const char *pattern;
-     const char *string;
-     int flags;
-{
-  register const char *p = pattern, *n = string;
-  register char c;
-
-/* Note that this evalutes C many times.  */
-#define FOLD(c)	((flags & FNM_CASEFOLD) && ISUPPER (c) ? tolower (c) : (c))
-
-  while ((c = *p++) != '\0')
-    {
-      c = FOLD (c);
-
-      switch (c)
-	{
-	case '?':
-	  if (*n == '\0')
-	    return FNM_NOMATCH;
-	  else if ((flags & FNM_FILE_NAME) && *n == '/')
-	    return FNM_NOMATCH;
-	  else if ((flags & FNM_PERIOD) && *n == '.' &&
-		   (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
-	    return FNM_NOMATCH;
-	  break;
-
-	case '\\':
-	  if (!(flags & FNM_NOESCAPE))
-	    {
-	      c = *p++;
-	      c = FOLD (c);
-	    }
-	  if (FOLD (*n) != c)
-	    return FNM_NOMATCH;
-	  break;
-
-	case '*':
-	  if ((flags & FNM_PERIOD) && *n == '.' &&
-	      (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
-	    return FNM_NOMATCH;
-
-	  for (c = *p++; c == '?' || c == '*'; c = *p++, ++n)
-	    if (((flags & FNM_FILE_NAME) && *n == '/') ||
-		(c == '?' && *n == '\0'))
-	      return FNM_NOMATCH;
-
-	  if (c == '\0')
-	    return 0;
-
-	  {
-	    char c1 = (!(flags & FNM_NOESCAPE) && c == '\\') ? *p : c;
-	    c1 = FOLD (c1);
-	    for (--p; *n != '\0'; ++n)
-	      if ((c == '[' || FOLD (*n) == c1) &&
-		  fnmatch (p, n, flags & ~FNM_PERIOD) == 0)
-		return 0;
-	    return FNM_NOMATCH;
-	  }
-
-	case '[':
-	  {
-	    /* Nonzero if the sense of the character class is inverted.  */
-	    register int not;
-
-	    if (*n == '\0')
-	      return FNM_NOMATCH;
-
-	    if ((flags & FNM_PERIOD) && *n == '.' &&
-		(n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
-	      return FNM_NOMATCH;
-
-	    not = (*p == '!' || *p == '^');
-	    if (not)
-	      ++p;
-
-	    c = *p++;
-	    for (;;)
-	      {
-		register char cstart = c, cend = c;
-
-		if (!(flags & FNM_NOESCAPE) && c == '\\')
-		  cstart = cend = *p++;
-
-		cstart = cend = FOLD (cstart);
-
-		if (c == '\0')
-		  /* [ (unterminated) loses.  */
-		  return FNM_NOMATCH;
-
-		c = *p++;
-		c = FOLD (c);
-
-		if ((flags & FNM_FILE_NAME) && c == '/')
-		  /* [/] can never match.  */
-		  return FNM_NOMATCH;
-
-		if (c == '-' && *p != ']')
-		  {
-		    cend = *p++;
-		    if (!(flags & FNM_NOESCAPE) && cend == '\\')
-		      cend = *p++;
-		    if (cend == '\0')
-		      return FNM_NOMATCH;
-		    cend = FOLD (cend);
-
-		    c = *p++;
-		  }
-
-		if (FOLD (*n) >= cstart && FOLD (*n) <= cend)
-		  goto matched;
-
-		if (c == ']')
-		  break;
-	      }
-	    if (!not)
-	      return FNM_NOMATCH;
-	    break;
-
-	  matched:;
-	    /* Skip the rest of the [...] that already matched.  */
-	    while (c != ']')
-	      {
-		if (c == '\0')
-		  /* [... (unterminated) loses.  */
-		  return FNM_NOMATCH;
-
-		c = *p++;
-		if (!(flags & FNM_NOESCAPE) && c == '\\')
-		  /* XXX 1003.2d11 is unclear if this is right.  */
-		  ++p;
-	      }
-	    if (not)
-	      return FNM_NOMATCH;
-	  }
-	  break;
-
-	default:
-	  if (c != FOLD (*n))
-	    return FNM_NOMATCH;
-	}
-
-      ++n;
-    }
-
-  if (*n == '\0')
-    return 0;
-
-  if ((flags & FNM_LEADING_DIR) && *n == '/')
-    /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz".  */
-    return 0;
-
-  return FNM_NOMATCH;
-}
-
-#else	/* HAVE_FNMATCH */
-void fnmatch_dummy(void) {}
-#endif

lib/fnmatch.h

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

lib/getopt.c

@@ -1,751 +0,0 @@
-#include "../rsync.h"
-#ifndef HAVE_GETOPT_LONG
-
-/* Getopt for GNU.
-   NOTE: getopt is now part of the C library, so if you don't know what
-   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
-   before changing it!
-
-   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94
-   	Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify it
-   under the terms of the GNU General Public License as published by the
-   Free Software Foundation; either version 2, or (at your option) any
-   later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
-   Ditto for AIX 3.2 and <stdlib.h>.  */
-#ifndef _NO_PROTO
-#define _NO_PROTO
-#endif
-
-/* Comment out all this code if we are using the GNU C Library, and are not
-   actually compiling the library itself.  This code is part of the GNU C
-   Library, but also included in many other GNU distributions.  Compiling
-   and linking in this code is a waste when using the GNU C library
-   (especially if it is a shared library).  Rather than having every GNU
-   program understand `configure --with-gnu-libc' and omit the object files,
-   it is simpler to just do this in the source for each such file.  */
-
-#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
-
-/* This is for other GNU distributions with internationalized messages.
-   The GNU C Library itself does not yet support such messages.  */
-#if HAVE_LIBINTL_H
-# include <libintl.h>
-#else
-# define gettext(msgid) (msgid)
-#endif
-
-/* This version of `getopt' appears to the caller like standard Unix `getopt'
-   but it behaves differently for the user, since it allows the user
-   to intersperse the options with the other arguments.
-
-   As `getopt' works, it permutes the elements of ARGV so that,
-   when it is done, all the options precede everything else.  Thus
-   all application programs are extended to handle flexible argument order.
-
-   Setting the environment variable POSIXLY_CORRECT disables permutation.
-   Then the behavior is completely standard.
-
-   GNU application programs can use a third alternative mode in which
-   they can distinguish the relative order of options and other arguments.  */
-
-/* For communication from `getopt' to the caller.
-   When `getopt' finds an option that takes an argument,
-   the argument value is returned here.
-   Also, when `ordering' is RETURN_IN_ORDER,
-   each non-option ARGV-element is returned here.  */
-
-char *optarg = NULL;
-
-/* Index in ARGV of the next element to be scanned.
-   This is used for communication to and from the caller
-   and for communication between successive calls to `getopt'.
-
-   On entry to `getopt', zero means this is the first call; initialize.
-
-   When `getopt' returns EOF, this is the index of the first of the
-   non-option elements that the caller should itself scan.
-
-   Otherwise, `optind' communicates from one call to the next
-   how much of ARGV has been scanned so far.  */
-
-/* XXX 1003.2 says this must be 1 before any call.  */
-int optind = 0;
-
-/* The next char to be scanned in the option-element
-   in which the last option character we returned was found.
-   This allows us to pick up the scan where we left off.
-
-   If this is zero, or a null string, it means resume the scan
-   by advancing to the next ARGV-element.  */
-
-static char *nextchar;
-
-/* Callers store zero here to inhibit the error message
-   for unrecognized options.  */
-
-int opterr = 1;
-
-/* Set to an option character which was unrecognized.
-   This must be initialized on some systems to avoid linking in the
-   system's own getopt implementation.  */
-
-int optopt = '?';
-
-/* Describe how to deal with options that follow non-option ARGV-elements.
-
-   If the caller did not specify anything,
-   the default is REQUIRE_ORDER if the environment variable
-   POSIXLY_CORRECT is defined, PERMUTE otherwise.
-
-   REQUIRE_ORDER means don't recognize them as options;
-   stop option processing when the first non-option is seen.
-   This is what Unix does.
-   This mode of operation is selected by either setting the environment
-   variable POSIXLY_CORRECT, or using `+' as the first character
-   of the list of option characters.
-
-   PERMUTE is the default.  We permute the contents of ARGV as we scan,
-   so that eventually all the non-options are at the end.  This allows options
-   to be given in any order, even with programs that were not written to
-   expect this.
-
-   RETURN_IN_ORDER is an option available to programs that were written
-   to expect options and other ARGV-elements in any order and that care about
-   the ordering of the two.  We describe each non-option ARGV-element
-   as if it were the argument of an option with character code 1.
-   Using `-' as the first character of the list of option characters
-   selects this mode of operation.
-
-   The special argument `--' forces an end of option-scanning regardless
-   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
-   `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
-
-static enum
-{
-  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
-} ordering;
-
-/* Value of POSIXLY_CORRECT environment variable.  */
-static char *posixly_correct;
-
-#ifdef	__GNU_LIBRARY__
-/* We want to avoid inclusion of string.h with non-GNU libraries
-   because there are many ways it can cause trouble.
-   On some systems, it contains special magic macros that don't work
-   in GCC.  */
-#include <string.h>
-#define	my_index	strchr
-#else
-
-/* Avoid depending on library functions or files
-   whose names are inconsistent.  */
-
-char *getenv ();
-
-static char *
-my_index (str, chr)
-     const char *str;
-     int chr;
-{
-  while (*str)
-    {
-      if (*str == chr)
-	return (char *) str;
-      str++;
-    }
-  return 0;
-}
-
-/* If using GCC, we can safely declare strlen this way.
-   If not using GCC, it is ok not to declare it.  */
-#ifdef __GNUC__
-/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
-   That was relevant to code that was here before.  */
-#if !defined (__STDC__) || !__STDC__
-/* gcc with -traditional declares the built-in strlen to return int,
-   and has done so at least since version 2.4.5. -- rms.  */
-extern int strlen (const char *);
-#endif /* not __STDC__ */
-#endif /* __GNUC__ */
-
-#endif /* not __GNU_LIBRARY__ */
-
-/* Handle permutation of arguments.  */
-
-/* Describe the part of ARGV that contains non-options that have
-   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
-   `last_nonopt' is the index after the last of them.  */
-
-static int first_nonopt;
-static int last_nonopt;
-
-/* Exchange two adjacent subsequences of ARGV.
-   One subsequence is elements [first_nonopt,last_nonopt)
-   which contains all the non-options that have been skipped so far.
-   The other is elements [last_nonopt,optind), which contains all
-   the options processed since those non-options were skipped.
-
-   `first_nonopt' and `last_nonopt' are relocated so that they describe
-   the new indices of the non-options in ARGV after they are moved.  */
-
-static void
-exchange (argv)
-     char **argv;
-{
-  int bottom = first_nonopt;
-  int middle = last_nonopt;
-  int top = optind;
-  char *tem;
-
-  /* Exchange the shorter segment with the far end of the longer segment.
-     That puts the shorter segment into the right place.
-     It leaves the longer segment in the right place overall,
-     but it consists of two parts that need to be swapped next.  */
-
-  while (top > middle && middle > bottom)
-    {
-      if (top - middle > middle - bottom)
-	{
-	  /* Bottom segment is the short one.  */
-	  int len = middle - bottom;
-	  register int i;
-
-	  /* Swap it with the top part of the top segment.  */
-	  for (i = 0; i < len; i++)
-	    {
-	      tem = argv[bottom + i];
-	      argv[bottom + i] = argv[top - (middle - bottom) + i];
-	      argv[top - (middle - bottom) + i] = tem;
-	    }
-	  /* Exclude the moved bottom segment from further swapping.  */
-	  top -= len;
-	}
-      else
-	{
-	  /* Top segment is the short one.  */
-	  int len = top - middle;
-	  register int i;
-
-	  /* Swap it with the bottom part of the bottom segment.  */
-	  for (i = 0; i < len; i++)
-	    {
-	      tem = argv[bottom + i];
-	      argv[bottom + i] = argv[middle + i];
-	      argv[middle + i] = tem;
-	    }
-	  /* Exclude the moved top segment from further swapping.  */
-	  bottom += len;
-	}
-    }
-
-  /* Update records for the slots the non-options now occupy.  */
-
-  first_nonopt += (optind - last_nonopt);
-  last_nonopt = optind;
-}
-
-/* Initialize the internal data when the first call is made.  */
-
-static const char *
-_getopt_initialize (optstring)
-     const char *optstring;
-{
-  /* Start processing options with ARGV-element 1 (since ARGV-element 0
-     is the program name); the sequence of previously skipped
-     non-option ARGV-elements is empty.  */
-
-  first_nonopt = last_nonopt = optind = 1;
-
-  nextchar = NULL;
-
-  posixly_correct = getenv ("POSIXLY_CORRECT");
-
-  /* Determine how to handle the ordering of options and nonoptions.  */
-
-  if (optstring[0] == '-')
-    {
-      ordering = RETURN_IN_ORDER;
-      ++optstring;
-    }
-  else if (optstring[0] == '+')
-    {
-      ordering = REQUIRE_ORDER;
-      ++optstring;
-    }
-  else if (posixly_correct != NULL)
-    ordering = REQUIRE_ORDER;
-  else
-    ordering = PERMUTE;
-
-  return optstring;
-}
-
-/* Scan elements of ARGV (whose length is ARGC) for option characters
-   given in OPTSTRING.
-
-   If an element of ARGV starts with '-', and is not exactly "-" or "--",
-   then it is an option element.  The characters of this element
-   (aside from the initial '-') are option characters.  If `getopt'
-   is called repeatedly, it returns successively each of the option characters
-   from each of the option elements.
-
-   If `getopt' finds another option character, it returns that character,
-   updating `optind' and `nextchar' so that the next call to `getopt' can
-   resume the scan with the following option character or ARGV-element.
-
-   If there are no more option characters, `getopt' returns `EOF'.
-   Then `optind' is the index in ARGV of the first ARGV-element
-   that is not an option.  (The ARGV-elements have been permuted
-   so that those that are not options now come last.)
-
-   OPTSTRING is a string containing the legitimate option characters.
-   If an option character is seen that is not listed in OPTSTRING,
-   return '?' after printing an error message.  If you set `opterr' to
-   zero, the error message is suppressed but we still return '?'.
-
-   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
-   so the following text in the same ARGV-element, or the text of the following
-   ARGV-element, is returned in `optarg'.  Two colons mean an option that
-   wants an optional arg; if there is text in the current ARGV-element,
-   it is returned in `optarg', otherwise `optarg' is set to zero.
-
-   If OPTSTRING starts with `-' or `+', it requests different methods of
-   handling the non-option ARGV-elements.
-   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
-
-   Long-named options begin with `--' instead of `-'.
-   Their names may be abbreviated as long as the abbreviation is unique
-   or is an exact match for some defined option.  If they have an
-   argument, it follows the option name in the same ARGV-element, separated
-   from the option name by a `=', or else the in next ARGV-element.
-   When `getopt' finds a long-named option, it returns 0 if that option's
-   `flag' field is nonzero, the value of the option's `val' field
-   if the `flag' field is zero.
-
-   The elements of ARGV aren't really const, because we permute them.
-   But we pretend they're const in the prototype to be compatible
-   with other systems.
-
-   LONGOPTS is a vector of `struct option' terminated by an
-   element containing a name which is zero.
-
-   LONGIND returns the index in LONGOPT of the long-named option found.
-   It is only valid when a long-named option has been found by the most
-   recent call.
-
-   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
-   long-named options.  */
-
-int
-_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
-     int argc;
-     char *const *argv;
-     const char *optstring;
-     const struct option *longopts;
-     int *longind;
-     int long_only;
-{
-  optarg = NULL;
-
-  if (optind == 0)
-    optstring = _getopt_initialize (optstring);
-
-  if (nextchar == NULL || *nextchar == '\0')
-    {
-      /* Advance to the next ARGV-element.  */
-
-      if (ordering == PERMUTE)
-	{
-	  /* If we have just processed some options following some non-options,
-	     exchange them so that the options come first.  */
-
-	  if (first_nonopt != last_nonopt && last_nonopt != optind)
-	    exchange ((char **) argv);
-	  else if (last_nonopt != optind)
-	    first_nonopt = optind;
-
-	  /* Skip any additional non-options
-	     and extend the range of non-options previously skipped.  */
-
-	  while (optind < argc
-		 && (argv[optind][0] != '-' || argv[optind][1] == '\0'))
-	    optind++;
-	  last_nonopt = optind;
-	}
-
-      /* The special ARGV-element `--' means premature end of options.
-	 Skip it like a null option,
-	 then exchange with previous non-options as if it were an option,
-	 then skip everything else like a non-option.  */
-
-      if (optind != argc && !strcmp (argv[optind], "--"))
-	{
-	  optind++;
-
-	  if (first_nonopt != last_nonopt && last_nonopt != optind)
-	    exchange ((char **) argv);
-	  else if (first_nonopt == last_nonopt)
-	    first_nonopt = optind;
-	  last_nonopt = argc;
-
-	  optind = argc;
-	}
-
-      /* If we have done all the ARGV-elements, stop the scan
-	 and back over any non-options that we skipped and permuted.  */
-
-      if (optind == argc)
-	{
-	  /* Set the next-arg-index to point at the non-options
-	     that we previously skipped, so the caller will digest them.  */
-	  if (first_nonopt != last_nonopt)
-	    optind = first_nonopt;
-	  return EOF;
-	}
-
-      /* If we have come to a non-option and did not permute it,
-	 either stop the scan or describe it to the caller and pass it by.  */
-
-      if ((argv[optind][0] != '-' || argv[optind][1] == '\0'))
-	{
-	  if (ordering == REQUIRE_ORDER)
-	    return EOF;
-	  optarg = argv[optind++];
-	  return 1;
-	}
-
-      /* We have found another option-ARGV-element.
-	 Skip the initial punctuation.  */
-
-      nextchar = (argv[optind] + 1
-		  + (longopts != NULL && argv[optind][1] == '-'));
-    }
-
-  /* Decode the current option-ARGV-element.  */
-
-  /* Check whether the ARGV-element is a long option.
-
-     If long_only and the ARGV-element has the form "-f", where f is
-     a valid short option, don't consider it an abbreviated form of
-     a long option that starts with f.  Otherwise there would be no
-     way to give the -f short option.
-
-     On the other hand, if there's a long option "fubar" and
-     the ARGV-element is "-fu", do consider that an abbreviation of
-     the long option, just like "--fu", and not "-f" with arg "u".
-
-     This distinction seems to be the most useful approach.  */
-
-  if (longopts != NULL
-      && (argv[optind][1] == '-'
-	  || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
-    {
-      char *nameend;
-      const struct option *p;
-      const struct option *pfound = NULL;
-      int exact = 0;
-      int ambig = 0;
-      int indfound;
-      int option_index;
-
-      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
-	/* Do nothing.  */ ;
-
-      /* Test all long options for either exact match
-	 or abbreviated matches.  */
-      for (p = longopts, option_index = 0; p->name; p++, option_index++)
-	if (!strncmp (p->name, nextchar, nameend - nextchar))
-	  {
-	    if (nameend - nextchar == strlen (p->name))
-	      {
-		/* Exact match found.  */
-		pfound = p;
-		indfound = option_index;
-		exact = 1;
-		break;
-	      }
-	    else if (pfound == NULL)
-	      {
-		/* First nonexact match found.  */
-		pfound = p;
-		indfound = option_index;
-	      }
-	    else
-	      /* Second or later nonexact match found.  */
-	      ambig = 1;
-	  }
-
-      if (ambig && !exact)
-	{
-	  if (opterr)
-	    fprintf (stderr, gettext ("%s: option `%s' is ambiguous\n"),
-		     argv[0], argv[optind]);
-	  nextchar += strlen (nextchar);
-	  optind++;
-	  return '?';
-	}
-
-      if (pfound != NULL)
-	{
-	  option_index = indfound;
-	  optind++;
-	  if (*nameend)
-	    {
-	      /* Don't test has_arg with >, because some C compilers don't
-		 allow it to be used on enums.  */
-	      if (pfound->has_arg)
-		optarg = nameend + 1;
-	      else
-		{
-		  if (opterr)
-		   if (argv[optind - 1][1] == '-')
-		    /* --option */
-		    fprintf (stderr,
-		     gettext ("%s: option `--%s' doesn't allow an argument\n"),
-		     argv[0], pfound->name);
-		   else
-		    /* +option or -option */
-		    fprintf (stderr,
-		     gettext ("%s: option `%c%s' doesn't allow an argument\n"),
-		     argv[0], argv[optind - 1][0], pfound->name);
-
-		  nextchar += strlen (nextchar);
-		  return '?';
-		}
-	    }
-	  else if (pfound->has_arg == 1)
-	    {
-	      if (optind < argc)
-		optarg = argv[optind++];
-	      else
-		{
-		  if (opterr)
-		    fprintf (stderr,
-			   gettext ("%s: option `%s' requires an argument\n"),
-			   argv[0], argv[optind - 1]);
-		  nextchar += strlen (nextchar);
-		  return optstring[0] == ':' ? ':' : '?';
-		}
-	    }
-	  nextchar += strlen (nextchar);
-	  if (longind != NULL)
-	    *longind = option_index;
-	  if (pfound->flag)
-	    {
-	      *(pfound->flag) = pfound->val;
-	      return 0;
-	    }
-	  return pfound->val;
-	}
-
-      /* Can't find it as a long option.  If this is not getopt_long_only,
-	 or the option starts with '--' or is not a valid short
-	 option, then it's an error.
-	 Otherwise interpret it as a short option.  */
-      if (!long_only || argv[optind][1] == '-'
-	  || my_index (optstring, *nextchar) == NULL)
-	{
-	  if (opterr)
-	    {
-	      if (argv[optind][1] == '-')
-		/* --option */
-		fprintf (stderr, gettext ("%s: unrecognized option `--%s'\n"),
-			 argv[0], nextchar);
-	      else
-		/* +option or -option */
-		fprintf (stderr, gettext ("%s: unrecognized option `%c%s'\n"),
-			 argv[0], argv[optind][0], nextchar);
-	    }
-	  nextchar = (char *) "";
-	  optind++;
-	  return '?';
-	}
-    }
-
-  /* Look at and handle the next short option-character.  */
-
-  {
-    char c = *nextchar++;
-    char *temp = my_index (optstring, c);
-
-    /* Increment `optind' when we start to process its last character.  */
-    if (*nextchar == '\0')
-      ++optind;
-
-    if (temp == NULL || c == ':')
-      {
-	if (opterr)
-	  {
-	    if (posixly_correct)
-	      /* 1003.2 specifies the format of this message.  */
-	      fprintf (stderr, gettext ("%s: illegal option -- %c\n"),
-		       argv[0], c);
-	    else
-	      fprintf (stderr, gettext ("%s: invalid option -- %c\n"),
-		       argv[0], c);
-	  }
-	optopt = c;
-	return '?';
-      }
-    if (temp[1] == ':')
-      {
-	if (temp[2] == ':')
-	  {
-	    /* This is an option that accepts an argument optionally.  */
-	    if (*nextchar != '\0')
-	      {
-		optarg = nextchar;
-		optind++;
-	      }
-	    else
-	      optarg = NULL;
-	    nextchar = NULL;
-	  }
-	else
-	  {
-	    /* This is an option that requires an argument.  */
-	    if (*nextchar != '\0')
-	      {
-		optarg = nextchar;
-		/* If we end this ARGV-element by taking the rest as an arg,
-		   we must advance to the next element now.  */
-		optind++;
-	      }
-	    else if (optind == argc)
-	      {
-		if (opterr)
-		  {
-		    /* 1003.2 specifies the format of this message.  */
-		    fprintf (stderr,
-			   gettext ("%s: option requires an argument -- %c\n"),
-			   argv[0], c);
-		  }
-		optopt = c;
-		if (optstring[0] == ':')
-		  c = ':';
-		else
-		  c = '?';
-	      }
-	    else
-	      /* We already incremented `optind' once;
-		 increment it again when taking next ARGV-elt as argument.  */
-	      optarg = argv[optind++];
-	    nextchar = NULL;
-	  }
-      }
-    return c;
-  }
-}
-
-int
-getopt (argc, argv, optstring)
-     int argc;
-     char *const *argv;
-     const char *optstring;
-{
-  return _getopt_internal (argc, argv, optstring,
-			   (const struct option *) 0,
-			   (int *) 0,
-			   0);
-}
-
-int
-getopt_long (argc, argv, options, long_options, opt_index)
-     int argc;
-     char *const *argv;
-     const char *options;
-     const struct option *long_options;
-     int *opt_index;
-{
-  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
-}
-
-#endif	/* _LIBC or not __GNU_LIBRARY__.  */
-
-#ifdef TEST
-
-/* Compile with -DTEST to make an executable for use in testing
-   the above definition of `getopt'.  */
-
-int
-main (argc, argv)
-     int argc;
-     char **argv;
-{
-  int c;
-  int digit_optind = 0;
-
-  while (1)
-    {
-      int this_option_optind = optind ? optind : 1;
-
-      c = getopt (argc, argv, "abc:d:0123456789");
-      if (c == EOF)
-	break;
-
-      switch (c)
-	{
-	case '0':
-	case '1':
-	case '2':
-	case '3':
-	case '4':
-	case '5':
-	case '6':
-	case '7':
-	case '8':
-	case '9':
-	  if (digit_optind != 0 && digit_optind != this_option_optind)
-	    printf ("digits occur in two different argv-elements.\n");
-	  digit_optind = this_option_optind;
-	  printf ("option %c\n", c);
-	  break;
-
-	case 'a':
-	  printf ("option a\n");
-	  break;
-
-	case 'b':
-	  printf ("option b\n");
-	  break;
-
-	case 'c':
-	  printf ("option c with value `%s'\n", optarg);
-	  break;
-
-	case '?':
-	  break;
-
-	default:
-	  printf ("?? getopt returned character code 0%o ??\n", c);
-	}
-    }
-
-  if (optind < argc)
-    {
-      printf ("non-option ARGV-elements: ");
-      while (optind < argc)
-	printf ("%s ", argv[optind++]);
-      printf ("\n");
-    }
-
-  exit (0);
-}
-
-#endif /* TEST */
-#else  /* HAVE_GETOPT_LONG */
-void getopt_dummy(void) {}
-#endif

lib/getopt.h

@@ -1,129 +0,0 @@
-/* Declarations for getopt.
-   Copyright (C) 1989, 90, 91, 92, 93, 94 Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify it
-   under the terms of the GNU General Public License as published by the
-   Free Software Foundation; either version 2, or (at your option) any
-   later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-#ifndef _GETOPT_H
-#define _GETOPT_H 1
-
-#ifdef	__cplusplus
-extern "C" {
-#endif
-
-/* For communication from `getopt' to the caller.
-   When `getopt' finds an option that takes an argument,
-   the argument value is returned here.
-   Also, when `ordering' is RETURN_IN_ORDER,
-   each non-option ARGV-element is returned here.  */
-
-extern char *optarg;
-
-/* Index in ARGV of the next element to be scanned.
-   This is used for communication to and from the caller
-   and for communication between successive calls to `getopt'.
-
-   On entry to `getopt', zero means this is the first call; initialize.
-
-   When `getopt' returns EOF, this is the index of the first of the
-   non-option elements that the caller should itself scan.
-
-   Otherwise, `optind' communicates from one call to the next
-   how much of ARGV has been scanned so far.  */
-
-extern int optind;
-
-/* Callers store zero here to inhibit the error message `getopt' prints
-   for unrecognized options.  */
-
-extern int opterr;
-
-/* Set to an option character which was unrecognized.  */
-
-extern int optopt;
-
-/* Describe the long-named options requested by the application.
-   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
-   of `struct option' terminated by an element containing a name which is
-   zero.
-
-   The field `has_arg' is:
-   no_argument		(or 0) if the option does not take an argument,
-   required_argument	(or 1) if the option requires an argument,
-   optional_argument 	(or 2) if the option takes an optional argument.
-
-   If the field `flag' is not NULL, it points to a variable that is set
-   to the value given in the field `val' when the option is found, but
-   left unchanged if the option is not found.
-
-   To have a long-named option do something other than set an `int' to
-   a compiled-in constant, such as set a value from `optarg', set the
-   option's `flag' field to zero and its `val' field to a nonzero
-   value (the equivalent single-letter option character, if there is
-   one).  For long options that have a zero `flag' field, `getopt'
-   returns the contents of the `val' field.  */
-
-struct option
-{
-#if defined (__STDC__) && __STDC__
-  const char *name;
-#else
-  char *name;
-#endif
-  /* has_arg can't be an enum because some compilers complain about
-     type mismatches in all the code that assumes it is an int.  */
-  int has_arg;
-  int *flag;
-  int val;
-};
-
-/* Names for the values of the `has_arg' field of `struct option'.  */
-
-#define	no_argument		0
-#define required_argument	1
-#define optional_argument	2
-
-#if defined (__STDC__) && __STDC__
-#ifdef __GNU_LIBRARY__
-/* Many other libraries have conflicting prototypes for getopt, with
-   differences in the consts, in stdlib.h.  To avoid compilation
-   errors, only prototype getopt for the GNU C library.  */
-extern int getopt (int argc, char *const *argv, const char *shortopts);
-#else /* not __GNU_LIBRARY__ */
-extern int getopt ();
-#endif /* __GNU_LIBRARY__ */
-extern int getopt_long (int argc, char *const *argv, const char *shortopts,
-		        const struct option *longopts, int *longind);
-extern int getopt_long_only (int argc, char *const *argv,
-			     const char *shortopts,
-		             const struct option *longopts, int *longind);
-
-/* Internal only.  Users should not call this directly.  */
-extern int _getopt_internal (int argc, char *const *argv,
-			     const char *shortopts,
-		             const struct option *longopts, int *longind,
-			     int long_only);
-#else /* not __STDC__ */
-extern int getopt ();
-extern int getopt_long ();
-extern int getopt_long_only ();
-
-extern int _getopt_internal ();
-#endif /* __STDC__ */
-
-#ifdef	__cplusplus
-}
-#endif
-
-#endif /* _GETOPT_H */

lib/inet_ntop.c

@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 1996-2001  Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
+ * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+ * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+#include "rsync.h"
+
+#define NS_INT16SZ	 2
+#define NS_IN6ADDRSZ	16
+
+/*
+ * WARNING: Don't even consider trying to compile this on a system where
+ * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
+ */
+
+static const char *inet_ntop4(const unsigned char *src, char *dst,
+			      size_t size);
+
+#ifdef AF_INET6
+static const char *inet_ntop6(const unsigned char *src, char *dst,
+			      size_t size);
+#endif
+
+/* char *
+ * isc_net_ntop(af, src, dst, size)
+ *	convert a network format address to presentation format.
+ * return:
+ *	pointer to presentation format address (`dst'), or NULL (see errno).
+ * author:
+ *	Paul Vixie, 1996.
+ */
+const char *
+inet_ntop(int af, const void *src, char *dst, size_t size)
+{
+	switch (af) {
+	case AF_INET:
+		return (inet_ntop4(src, dst, size));
+#ifdef AF_INET6
+	case AF_INET6:
+		return (inet_ntop6(src, dst, size));
+#endif
+	default:
+		errno = EAFNOSUPPORT;
+		return (NULL);
+	}
+	/* NOTREACHED */
+}
+
+/* const char *
+ * inet_ntop4(src, dst, size)
+ *	format an IPv4 address
+ * return:
+ *	`dst' (as a const)
+ * notes:
+ *	(1) uses no statics
+ *	(2) takes a unsigned char* not an in_addr as input
+ * author:
+ *	Paul Vixie, 1996.
+ */
+static const char *
+inet_ntop4(const unsigned char *src, char *dst, size_t size)
+{
+	static const char *fmt = "%u.%u.%u.%u";
+	char tmp[sizeof "255.255.255.255"];
+
+	if ((size_t)sprintf(tmp, fmt, src[0], src[1], src[2], src[3]) >= size)
+	{
+		errno = ENOSPC;
+		return (NULL);
+	}
+	strcpy(dst, tmp);
+
+	return (dst);
+}
+
+/* const char *
+ * isc_inet_ntop6(src, dst, size)
+ *	convert IPv6 binary address into presentation (printable) format
+ * author:
+ *	Paul Vixie, 1996.
+ */
+#ifdef AF_INET6
+static const char *
+inet_ntop6(const unsigned char *src, char *dst, size_t size)
+{
+	/*
+	 * Note that int32_t and int16_t need only be "at least" large enough
+	 * to contain a value of the specified size.  On some systems, like
+	 * Crays, there is no such thing as an integer variable with 16 bits.
+	 * Keep this in mind if you think this function should have been coded
+	 * to use pointer overlays.  All the world's not a VAX.
+	 */
+	char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"], *tp;
+	struct { int base, len; } best, cur;
+	unsigned int words[NS_IN6ADDRSZ / NS_INT16SZ];
+	int i;
+
+	/*
+	 * Preprocess:
+	 *	Copy the input (bytewise) array into a wordwise array.
+	 *	Find the longest run of 0x00's in src[] for :: shorthanding.
+	 */
+	memset(words, '\0', sizeof words);
+	for (i = 0; i < NS_IN6ADDRSZ; i++)
+		words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
+	best.base = -1;
+	cur.base = -1;
+	for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
+		if (words[i] == 0) {
+			if (cur.base == -1)
+				cur.base = i, cur.len = 1;
+			else
+				cur.len++;
+		} else {
+			if (cur.base != -1) {
+				if (best.base == -1 || cur.len > best.len)
+					best = cur;
+				cur.base = -1;
+			}
+		}
+	}
+	if (cur.base != -1) {
+		if (best.base == -1 || cur.len > best.len)
+			best = cur;
+	}
+	if (best.base != -1 && best.len < 2)
+		best.base = -1;
+
+	/*
+	 * Format the result.
+	 */
+	tp = tmp;
+	for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
+		/* Are we inside the best run of 0x00's? */
+		if (best.base != -1 && i >= best.base &&
+		    i < (best.base + best.len)) {
+			if (i == best.base)
+				*tp++ = ':';
+			continue;
+		}
+		/* Are we following an initial run of 0x00s or any real hex? */
+		if (i != 0)
+			*tp++ = ':';
+		/* Is this address an encapsulated IPv4? */
+		if (i == 6 && best.base == 0 &&
+		    (best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
+			if (!inet_ntop4(src+12, tp,
+					sizeof tmp - (tp - tmp)))
+				return (NULL);
+			tp += strlen(tp);
+			break;
+		}
+		tp += sprintf(tp, "%x", words[i]);
+	}
+	/* Was it a trailing run of 0x00's? */
+	if (best.base != -1 && (best.base + best.len) ==
+	    (NS_IN6ADDRSZ / NS_INT16SZ))
+		*tp++ = ':';
+	*tp++ = '\0';
+
+	/*
+	 * Check for overflow, copy, and we're done.
+	 */
+	if ((size_t)(tp - tmp) > size) {
+		errno = ENOSPC;
+		return (NULL);
+	}
+	strcpy(dst, tmp);
+	return (dst);
+}
+#endif /* AF_INET6 */

lib/inet_pton.c

@@ -0,0 +1,212 @@
+/*
+ * Copyright (C) 1996-2001  Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
+ * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+ * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "rsync.h"
+
+#define NS_INT16SZ	 2
+#define NS_INADDRSZ	 4
+#define NS_IN6ADDRSZ	16
+
+/*
+ * WARNING: Don't even consider trying to compile this on a system where
+ * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
+ */
+
+static int inet_pton4(const char *src, unsigned char *dst);
+#ifdef INET6
+static int inet_pton6(const char *src, unsigned char *dst);
+#endif
+
+/* int
+ * inet_pton(af, src, dst)
+ *	convert from presentation format (which usually means ASCII printable)
+ *	to network format (which is usually some kind of binary format).
+ * return:
+ *	1 if the address was valid for the specified address family
+ *	0 if the address wasn't valid (`dst' is untouched in this case)
+ *	-1 if some other error occurred (`dst' is untouched in this case, too)
+ * author:
+ *	Paul Vixie, 1996.
+ */
+int
+inet_pton(int af,
+	  const char *src,
+	  void *dst)
+{
+	switch (af) {
+	case AF_INET:
+		return (inet_pton4(src, dst));
+#ifdef INET6
+	case AF_INET6:
+		return (inet_pton6(src, dst));
+#endif
+	default:
+		errno = EAFNOSUPPORT;
+		return (-1);
+	}
+	/* NOTREACHED */
+}
+
+/* int
+ * inet_pton4(src, dst)
+ *	like inet_aton() but without all the hexadecimal and shorthand.
+ * return:
+ *	1 if `src' is a valid dotted quad, else 0.
+ * notice:
+ *	does not touch `dst' unless it's returning 1.
+ * author:
+ *	Paul Vixie, 1996.
+ */
+static int
+inet_pton4(src, dst)
+	const char *src;
+	unsigned char *dst;
+{
+	static const char digits[] = "0123456789";
+	int saw_digit, octets, ch;
+	unsigned char tmp[NS_INADDRSZ], *tp;
+
+	saw_digit = 0;
+	octets = 0;
+	*(tp = tmp) = 0;
+	while ((ch = *src++) != '\0') {
+		const char *pch;
+
+		if ((pch = strchr(digits, ch)) != NULL) {
+			unsigned int new = *tp * 10 + (pch - digits);
+
+			if (new > 255)
+				return (0);
+			*tp = new;
+			if (! saw_digit) {
+				if (++octets > 4)
+					return (0);
+				saw_digit = 1;
+			}
+		} else if (ch == '.' && saw_digit) {
+			if (octets == 4)
+				return (0);
+			*++tp = 0;
+			saw_digit = 0;
+		} else
+			return (0);
+	}
+	if (octets < 4)
+		return (0);
+	memcpy(dst, tmp, NS_INADDRSZ);
+	return (1);
+}
+
+/* int
+ * inet_pton6(src, dst)
+ *	convert presentation level address to network order binary form.
+ * return:
+ *	1 if `src' is a valid [RFC1884 2.2] address, else 0.
+ * notice:
+ *	(1) does not touch `dst' unless it's returning 1.
+ *	(2) :: in a full address is silently ignored.
+ * credit:
+ *	inspired by Mark Andrews.
+ * author:
+ *	Paul Vixie, 1996.
+ */
+#ifdef INET6
+static int
+inet_pton6(src, dst)
+	const char *src;
+	unsigned char *dst;
+{
+	static const char xdigits_l[] = "0123456789abcdef",
+			  xdigits_u[] = "0123456789ABCDEF";
+	unsigned char tmp[NS_IN6ADDRSZ], *tp, *endp, *colonp;
+	const char *xdigits, *curtok;
+	int ch, saw_xdigit;
+	unsigned int val;
+
+	memset((tp = tmp), '\0', NS_IN6ADDRSZ);
+	endp = tp + NS_IN6ADDRSZ;
+	colonp = NULL;
+	/* Leading :: requires some special handling. */
+	if (*src == ':')
+		if (*++src != ':')
+			return (0);
+	curtok = src;
+	saw_xdigit = 0;
+	val = 0;
+	while ((ch = *src++) != '\0') {
+		const char *pch;
+
+		if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
+			pch = strchr((xdigits = xdigits_u), ch);
+		if (pch != NULL) {
+			val <<= 4;
+			val |= (pch - xdigits);
+			if (val > 0xffff)
+				return (0);
+			saw_xdigit = 1;
+			continue;
+		}
+		if (ch == ':') {
+			curtok = src;
+			if (!saw_xdigit) {
+				if (colonp)
+					return (0);
+				colonp = tp;
+				continue;
+			}
+			if (tp + NS_INT16SZ > endp)
+				return (0);
+			*tp++ = (unsigned char) (val >> 8) & 0xff;
+			*tp++ = (unsigned char) val & 0xff;
+			saw_xdigit = 0;
+			val = 0;
+			continue;
+		}
+		if (ch == '.' && ((tp + NS_INADDRSZ) <= endp) &&
+		    inet_pton4(curtok, tp) > 0) {
+			tp += NS_INADDRSZ;
+			saw_xdigit = 0;
+			break;	/* '\0' was seen by inet_pton4(). */
+		}
+		return (0);
+	}
+	if (saw_xdigit) {
+		if (tp + NS_INT16SZ > endp)
+			return (0);
+		*tp++ = (unsigned char) (val >> 8) & 0xff;
+		*tp++ = (unsigned char) val & 0xff;
+	}
+	if (colonp != NULL) {
+		/*
+		 * Since some memmove()'s erroneously fail to handle
+		 * overlapping regions, we'll do the shift by hand.
+		 */
+		const int n = tp - colonp;
+		int i;
+
+		for (i = 1; i <= n; i++) {
+			endp[- i] = colonp[n - i];
+			colonp[n - i] = 0;
+		}
+		tp = endp;
+	}
+	if (tp != endp)
+		return (0);
+	memcpy(dst, tmp, NS_IN6ADDRSZ);
+	return (1);
+}
+#endif

lib/mdfour.c

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

lib/mdfour.h

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

lib/permstring.c

@@ -0,0 +1,63 @@
+/* 
+   Copyright (C) Andrew Tridgell 1996
+   Copyright (C) Paul Mackerras 1996
+   Copyright (C) 2001 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.
+*/
+
+#include "rsync.h"
+
+/**
+ * Produce a string representation of Unix mode bits like that used by
+ * ls(1).
+ *
+ * @param buf buffer of at least 11 characters
+ **/
+void permstring(char *perms,
+		int mode)
+{
+	static const char *perm_map = "rwxrwxrwx";
+	int i;
+
+	strcpy(perms, "----------");
+	
+	for (i=0;i<9;i++) {
+		if (mode & (1<<i)) perms[9-i] = perm_map[8-i];
+	}
+
+	/* Handle setuid/sticky bits.  You might think the indices are
+	 * off by one, but remember there's a type char at the
+	 * start.  */
+	if (mode & S_ISUID)
+		perms[3] = (mode & S_IXUSR) ? 's' : 'S';
+
+	if (mode & S_ISGID)
+		perms[6] = (mode & S_IXGRP) ? 's' : 'S';
+	
+#ifdef S_ISVTX
+	if (mode & S_ISVTX)
+		perms[9] = (mode & S_IXOTH) ? 't' : 'T';
+#endif
+		
+	if (S_ISLNK(mode)) perms[0] = 'l';
+	if (S_ISDIR(mode)) perms[0] = 'd';
+	if (S_ISBLK(mode)) perms[0] = 'b';
+	if (S_ISCHR(mode)) perms[0] = 'c';
+	if (S_ISSOCK(mode)) perms[0] = 's';
+	if (S_ISFIFO(mode)) perms[0] = 'p';
+}
+
+	

lib/permstring.h

@@ -0,0 +1,3 @@
+#define PERMSTRING_SIZE 11
+
+void permstring(char *perms, int mode);

lib/snprintf.c

@@ -0,0 +1,942 @@
+/*
+ * Copyright Patrick Powell 1995
+ * This code is based on code written by Patrick Powell (papowell@astart.com)
+ * It may be used for any purpose as long as this notice remains intact
+ * on all source code distributions
+ */
+
+/**************************************************************
+ * Original:
+ * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
+ * A bombproof version of doprnt (dopr) included.
+ * Sigh.  This sort of thing is always nasty do deal with.  Note that
+ * the version here does not include floating point...
+ *
+ * snprintf() is used instead of sprintf() as it does limit checks
+ * for string length.  This covers a nasty loophole.
+ *
+ * The other functions are there to prevent NULL pointers from
+ * causing nast effects.
+ *
+ * More Recently:
+ *  Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
+ *  This was ugly.  It is still ugly.  I opted out of floating point
+ *  numbers, but the formatter understands just about everything
+ *  from the normal C string format, at least as far as I can tell from
+ *  the Solaris 2.5 printf(3S) man page.
+ *
+ *  Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
+ *    Ok, added some minimal floating point support, which means this
+ *    probably requires libm on most operating systems.  Don't yet
+ *    support the exponent (e,E) and sigfig (g,G).  Also, fmtint()
+ *    was pretty badly broken, it just wasn't being exercised in ways
+ *    which showed it, so that's been fixed.  Also, formated the code
+ *    to mutt conventions, and removed dead code left over from the
+ *    original.  Also, there is now a builtin-test, just compile with:
+ *           gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
+ *    and run snprintf for results.
+ * 
+ *  Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
+ *    The PGP code was using unsigned hexadecimal formats. 
+ *    Unfortunately, unsigned formats simply didn't work.
+ *
+ *  Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
+ *    The original code assumed that both snprintf() and vsnprintf() were
+ *    missing.  Some systems only have snprintf() but not vsnprintf(), so
+ *    the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
+ *
+ *  Andrew Tridgell (tridge@samba.org) Oct 1998
+ *    fixed handling of %.0f
+ *    added test for HAVE_LONG_DOUBLE
+ *
+ * tridge@samba.org, idra@samba.org, April 2001
+ *    got rid of fcvt code (twas buggy and made testing harder)
+ *    added C99 semantics
+ *
+ *  Paul Green (paulg@samba.org) April 9, 2003
+ *    fixed handling of %f when converting fractions with leading zeros.
+ *    (e.g., 0.025).
+ **************************************************************/
+
+#ifndef NO_CONFIG_H /* for some tests */
+#include "config.h"
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#include <sys/types.h>
+#include <stdarg.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#if defined(HAVE_SNPRINTF) && defined(HAVE_VSNPRINTF) && defined(HAVE_C99_VSNPRINTF)
+/* only include stdio.h if we are not re-defining snprintf or vsnprintf */
+#include <stdio.h>
+ /* make the compiler happy with an empty file */
+ void dummy_snprintf(void) {} 
+#else
+
+#ifdef HAVE_LONG_DOUBLE
+#define LDOUBLE long double
+#else
+#define LDOUBLE double
+#endif
+
+#ifdef HAVE_LONG_LONG
+#define LLONG long long
+#else
+#define LLONG long
+#endif
+
+static size_t dopr(char *buffer, size_t maxlen, const char *format, 
+		   va_list args);
+static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
+		    char *value, int flags, int min, int max);
+static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
+		    long value, int base, int min, int max, int flags);
+static void fmtfp(char *buffer, size_t *currlen, size_t maxlen,
+		   LDOUBLE fvalue, int min, int max, int flags);
+static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
+
+/*
+ * dopr(): poor man's version of doprintf
+ */
+
+/* format read states */
+#define DP_S_DEFAULT 0
+#define DP_S_FLAGS   1
+#define DP_S_MIN     2
+#define DP_S_DOT     3
+#define DP_S_MAX     4
+#define DP_S_MOD     5
+#define DP_S_CONV    6
+#define DP_S_DONE    7
+
+/* format flags - Bits */
+#define DP_F_MINUS 	(1 << 0)
+#define DP_F_PLUS  	(1 << 1)
+#define DP_F_SPACE 	(1 << 2)
+#define DP_F_NUM   	(1 << 3)
+#define DP_F_ZERO  	(1 << 4)
+#define DP_F_UP    	(1 << 5)
+#define DP_F_UNSIGNED 	(1 << 6)
+
+/* Conversion Flags */
+#define DP_C_SHORT   1
+#define DP_C_LONG    2
+#define DP_C_LDOUBLE 3
+#define DP_C_LLONG   4
+
+#define char_to_int(p) ((p)- '0')
+#ifndef MAX
+#define MAX(p,q) (((p) >= (q)) ? (p) : (q))
+#endif
+
+static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args)
+{
+	char ch;
+	LLONG value;
+	LDOUBLE fvalue;
+	char *strvalue;
+	int min;
+	int max;
+	int state;
+	int flags;
+	int cflags;
+	size_t currlen;
+	
+	state = DP_S_DEFAULT;
+	currlen = flags = cflags = min = 0;
+	max = -1;
+	ch = *format++;
+	
+	while (state != DP_S_DONE) {
+		if (ch == '\0') 
+			state = DP_S_DONE;
+
+		switch(state) {
+		case DP_S_DEFAULT:
+			if (ch == '%') 
+				state = DP_S_FLAGS;
+			else 
+				dopr_outch (buffer, &currlen, maxlen, ch);
+			ch = *format++;
+			break;
+		case DP_S_FLAGS:
+			switch (ch) {
+			case '-':
+				flags |= DP_F_MINUS;
+				ch = *format++;
+				break;
+			case '+':
+				flags |= DP_F_PLUS;
+				ch = *format++;
+				break;
+			case ' ':
+				flags |= DP_F_SPACE;
+				ch = *format++;
+				break;
+			case '#':
+				flags |= DP_F_NUM;
+				ch = *format++;
+				break;
+			case '0':
+				flags |= DP_F_ZERO;
+				ch = *format++;
+				break;
+			default:
+				state = DP_S_MIN;
+				break;
+			}
+			break;
+		case DP_S_MIN:
+			if (isdigit((unsigned char)ch)) {
+				min = 10*min + char_to_int (ch);
+				ch = *format++;
+			} else if (ch == '*') {
+				min = va_arg (args, int);
+				ch = *format++;
+				state = DP_S_DOT;
+			} else {
+				state = DP_S_DOT;
+			}
+			break;
+		case DP_S_DOT:
+			if (ch == '.') {
+				state = DP_S_MAX;
+				ch = *format++;
+			} else { 
+				state = DP_S_MOD;
+			}
+			break;
+		case DP_S_MAX:
+			if (isdigit((unsigned char)ch)) {
+				if (max < 0)
+					max = 0;
+				max = 10*max + char_to_int (ch);
+				ch = *format++;
+			} else if (ch == '*') {
+				max = va_arg (args, int);
+				ch = *format++;
+				state = DP_S_MOD;
+			} else {
+				state = DP_S_MOD;
+			}
+			break;
+		case DP_S_MOD:
+			switch (ch) {
+			case 'h':
+				cflags = DP_C_SHORT;
+				ch = *format++;
+				break;
+			case 'l':
+				cflags = DP_C_LONG;
+				ch = *format++;
+				if (ch == 'l') {	/* It's a long long */
+					cflags = DP_C_LLONG;
+					ch = *format++;
+				}
+				break;
+			case 'L':
+				cflags = DP_C_LDOUBLE;
+				ch = *format++;
+				break;
+			default:
+				break;
+			}
+			state = DP_S_CONV;
+			break;
+		case DP_S_CONV:
+			switch (ch) {
+			case 'd':
+			case 'i':
+				if (cflags == DP_C_SHORT) 
+					value = va_arg (args, int);
+				else if (cflags == DP_C_LONG)
+					value = va_arg (args, long int);
+				else if (cflags == DP_C_LLONG)
+					value = va_arg (args, LLONG);
+				else
+					value = va_arg (args, int);
+				fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
+				break;
+			case 'o':
+				flags |= DP_F_UNSIGNED;
+				if (cflags == DP_C_SHORT)
+					value = va_arg (args, unsigned int);
+				else if (cflags == DP_C_LONG)
+					value = (long)va_arg (args, unsigned long int);
+				else if (cflags == DP_C_LLONG)
+					value = (long)va_arg (args, unsigned LLONG);
+				else
+					value = (long)va_arg (args, unsigned int);
+				fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
+				break;
+			case 'u':
+				flags |= DP_F_UNSIGNED;
+				if (cflags == DP_C_SHORT)
+					value = va_arg (args, unsigned int);
+				else if (cflags == DP_C_LONG)
+					value = (long)va_arg (args, unsigned long int);
+				else if (cflags == DP_C_LLONG)
+					value = (LLONG)va_arg (args, unsigned LLONG);
+				else
+					value = (long)va_arg (args, unsigned int);
+				fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
+				break;
+			case 'X':
+				flags |= DP_F_UP;
+			case 'x':
+				flags |= DP_F_UNSIGNED;
+				if (cflags == DP_C_SHORT)
+					value = va_arg (args, unsigned int);
+				else if (cflags == DP_C_LONG)
+					value = (long)va_arg (args, unsigned long int);
+				else if (cflags == DP_C_LLONG)
+					value = (LLONG)va_arg (args, unsigned LLONG);
+				else
+					value = (long)va_arg (args, unsigned int);
+				fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
+				break;
+			case 'f':
+				if (cflags == DP_C_LDOUBLE)
+					fvalue = va_arg (args, LDOUBLE);
+				else
+					fvalue = va_arg (args, double);
+				/* um, floating point? */
+				fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
+				break;
+			case 'E':
+				flags |= DP_F_UP;
+			case 'e':
+				if (cflags == DP_C_LDOUBLE)
+					fvalue = va_arg (args, LDOUBLE);
+				else
+					fvalue = va_arg (args, double);
+				break;
+			case 'G':
+				flags |= DP_F_UP;
+			case 'g':
+				if (cflags == DP_C_LDOUBLE)
+					fvalue = va_arg (args, LDOUBLE);
+				else
+					fvalue = va_arg (args, double);
+				break;
+			case 'c':
+				dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
+				break;
+			case 's':
+				strvalue = va_arg (args, char *);
+				if (max == -1) {
+					max = strlen(strvalue);
+				}
+				if (min > 0 && max >= 0 && min > max) max = min;
+				fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
+				break;
+			case 'p':
+				strvalue = va_arg (args, void *);
+				fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
+				break;
+			case 'n':
+				if (cflags == DP_C_SHORT) {
+					short int *num;
+					num = va_arg (args, short int *);
+					*num = currlen;
+				} else if (cflags == DP_C_LONG) {
+					long int *num;
+					num = va_arg (args, long int *);
+					*num = (long int)currlen;
+				} else if (cflags == DP_C_LLONG) {
+					LLONG *num;
+					num = va_arg (args, LLONG *);
+					*num = (LLONG)currlen;
+				} else {
+					int *num;
+					num = va_arg (args, int *);
+					*num = currlen;
+				}
+				break;
+			case '%':
+				dopr_outch (buffer, &currlen, maxlen, ch);
+				break;
+			case 'w':
+				/* not supported yet, treat as next char */
+				ch = *format++;
+				break;
+			default:
+				/* Unknown, skip */
+				break;
+			}
+			ch = *format++;
+			state = DP_S_DEFAULT;
+			flags = cflags = min = 0;
+			max = -1;
+			break;
+		case DP_S_DONE:
+			break;
+		default:
+			/* hmm? */
+			break; /* some picky compilers need this */
+		}
+	}
+	if (maxlen != 0) {
+		if (currlen < maxlen - 1) 
+			buffer[currlen] = '\0';
+		else if (maxlen > 0) 
+			buffer[maxlen - 1] = '\0';
+	}
+	
+	return currlen;
+}
+
+static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
+		    char *value, int flags, int min, int max)
+{
+	int padlen, strln;     /* amount to pad */
+	int cnt = 0;
+
+#ifdef DEBUG_SNPRINTF
+	printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
+#endif
+	if (value == 0) {
+		value = "<NULL>";
+	}
+
+	for (strln = 0; value[strln]; ++strln); /* strlen */
+	padlen = min - strln;
+	if (padlen < 0) 
+		padlen = 0;
+	if (flags & DP_F_MINUS) 
+		padlen = -padlen; /* Left Justify */
+	
+	while ((padlen > 0) && (cnt < max)) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		--padlen;
+		++cnt;
+	}
+	while (*value && (cnt < max)) {
+		dopr_outch (buffer, currlen, maxlen, *value++);
+		++cnt;
+	}
+	while ((padlen < 0) && (cnt < max)) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		++padlen;
+		++cnt;
+	}
+}
+
+/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
+
+static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
+		    long value, int base, int min, int max, int flags)
+{
+	int signvalue = 0;
+	unsigned long uvalue;
+	char convert[20];
+	int place = 0;
+	int spadlen = 0; /* amount to space pad */
+	int zpadlen = 0; /* amount to zero pad */
+	int caps = 0;
+	
+	if (max < 0)
+		max = 0;
+	
+	uvalue = value;
+	
+	if(!(flags & DP_F_UNSIGNED)) {
+		if( value < 0 ) {
+			signvalue = '-';
+			uvalue = -value;
+		} else {
+			if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
+				signvalue = '+';
+			else if (flags & DP_F_SPACE)
+				signvalue = ' ';
+		}
+	}
+  
+	if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
+
+	do {
+		convert[place++] =
+			(caps? "0123456789ABCDEF":"0123456789abcdef")
+			[uvalue % (unsigned)base  ];
+		uvalue = (uvalue / (unsigned)base );
+	} while(uvalue && (place < 20));
+	if (place == 20) place--;
+	convert[place] = 0;
+
+	zpadlen = max - place;
+	spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
+	if (zpadlen < 0) zpadlen = 0;
+	if (spadlen < 0) spadlen = 0;
+	if (flags & DP_F_ZERO) {
+		zpadlen = MAX(zpadlen, spadlen);
+		spadlen = 0;
+	}
+	if (flags & DP_F_MINUS) 
+		spadlen = -spadlen; /* Left Justifty */
+
+#ifdef DEBUG_SNPRINTF
+	printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
+	       zpadlen, spadlen, min, max, place);
+#endif
+
+	/* Spaces */
+	while (spadlen > 0) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		--spadlen;
+	}
+
+	/* Sign */
+	if (signvalue) 
+		dopr_outch (buffer, currlen, maxlen, signvalue);
+
+	/* Zeros */
+	if (zpadlen > 0) {
+		while (zpadlen > 0) {
+			dopr_outch (buffer, currlen, maxlen, '0');
+			--zpadlen;
+		}
+	}
+
+	/* Digits */
+	while (place > 0) 
+		dopr_outch (buffer, currlen, maxlen, convert[--place]);
+  
+	/* Left Justified spaces */
+	while (spadlen < 0) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		++spadlen;
+	}
+}
+
+static LDOUBLE abs_val(LDOUBLE value)
+{
+	LDOUBLE result = value;
+
+	if (value < 0)
+		result = -value;
+	
+	return result;
+}
+
+static LDOUBLE POW10(int exp)
+{
+	LDOUBLE result = 1;
+	
+	while (exp) {
+		result *= 10;
+		exp--;
+	}
+  
+	return result;
+}
+
+static LLONG ROUND(LDOUBLE value)
+{
+	LLONG intpart;
+
+	intpart = (LLONG)value;
+	value = value - intpart;
+	if (value >= 0.5) intpart++;
+	
+	return intpart;
+}
+
+/* a replacement for modf that doesn't need the math library. Should
+   be portable, but slow */
+static double my_modf(double x0, double *iptr)
+{
+	int i;
+	long l;
+	double x = x0;
+	double f = 1.0;
+
+	for (i=0;i<100;i++) {
+		l = (long)x;
+		if (l <= (x+1) && l >= (x-1)) break;
+		x *= 0.1;
+		f *= 10.0;
+	}
+
+	if (i == 100) {
+		/* yikes! the number is beyond what we can handle. What do we do? */
+		(*iptr) = 0;
+		return 0;
+	}
+
+	if (i != 0) {
+		double i2;
+		double ret;
+
+		ret = my_modf(x0-l*f, &i2);
+		(*iptr) = l*f + i2;
+		return ret;
+	} 
+
+	(*iptr) = l;
+	return x - (*iptr);
+}
+
+
+static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
+		   LDOUBLE fvalue, int min, int max, int flags)
+{
+	int signvalue = 0;
+	double ufvalue;
+	char iconvert[311];
+	char fconvert[311];
+	int iplace = 0;
+	int fplace = 0;
+	int padlen = 0; /* amount to pad */
+	int zpadlen = 0; 
+	int caps = 0;
+	int index;
+	double intpart;
+	double fracpart;
+	double temp;
+  
+	/* 
+	 * AIX manpage says the default is 0, but Solaris says the default
+	 * is 6, and sprintf on AIX defaults to 6
+	 */
+	if (max < 0)
+		max = 6;
+
+	ufvalue = abs_val (fvalue);
+
+	if (fvalue < 0) {
+		signvalue = '-';
+	} else {
+		if (flags & DP_F_PLUS) { /* Do a sign (+/i) */
+			signvalue = '+';
+		} else {
+			if (flags & DP_F_SPACE)
+				signvalue = ' ';
+		}
+	}
+
+#if 0
+	if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
+#endif
+
+#if 0
+	 if (max == 0) ufvalue += 0.5; /* if max = 0 we must round */
+#endif
+
+	/* 
+	 * Sorry, we only support 16 digits past the decimal because of our 
+	 * conversion method
+	 */
+	if (max > 16)
+		max = 16;
+
+	/* We "cheat" by converting the fractional part to integer by
+	 * multiplying by a factor of 10
+	 */
+
+	temp = ufvalue;
+	my_modf(temp, &intpart);
+
+	fracpart = ROUND((POW10(max)) * (ufvalue - intpart));
+	
+	if (fracpart >= POW10(max)) {
+		intpart++;
+		fracpart -= POW10(max);
+	}
+
+
+	/* Convert integer part */
+	do {
+		temp = intpart;
+		my_modf(intpart*0.1, &intpart);
+		temp = temp*0.1;
+		index = (int) ((temp -intpart +0.05)* 10.0);
+		/* index = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
+		/* printf ("%llf, %f, %x\n", temp, intpart, index); */
+		iconvert[iplace++] =
+			(caps? "0123456789ABCDEF":"0123456789abcdef")[index];
+	} while (intpart && (iplace < 311));
+	if (iplace == 311) iplace--;
+	iconvert[iplace] = 0;
+
+	/* Convert fractional part */
+	if (fracpart)
+	{
+		do {
+			temp = fracpart;
+			my_modf(fracpart*0.1, &fracpart);
+			temp = temp*0.1;
+			index = (int) ((temp -fracpart +0.05)* 10.0);
+			/* index = (int) ((((temp/10) -fracpart) +0.05) *10); */
+			/* printf ("%lf, %lf, %ld\n", temp, fracpart, index); */
+			fconvert[fplace++] =
+			(caps? "0123456789ABCDEF":"0123456789abcdef")[index];
+		} while(fracpart && (fplace < 311));
+		if (fplace == 311) fplace--;
+	}
+	fconvert[fplace] = 0;
+  
+	/* -1 for decimal point, another -1 if we are printing a sign */
+	padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 
+	zpadlen = max - fplace;
+	if (zpadlen < 0) zpadlen = 0;
+	if (padlen < 0) 
+		padlen = 0;
+	if (flags & DP_F_MINUS) 
+		padlen = -padlen; /* Left Justifty */
+	
+	if ((flags & DP_F_ZERO) && (padlen > 0)) {
+		if (signvalue) {
+			dopr_outch (buffer, currlen, maxlen, signvalue);
+			--padlen;
+			signvalue = 0;
+		}
+		while (padlen > 0) {
+			dopr_outch (buffer, currlen, maxlen, '0');
+			--padlen;
+		}
+	}
+	while (padlen > 0) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		--padlen;
+	}
+	if (signvalue) 
+		dopr_outch (buffer, currlen, maxlen, signvalue);
+	
+	while (iplace > 0) 
+		dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
+
+#ifdef DEBUG_SNPRINTF
+	printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
+#endif
+
+	/*
+	 * Decimal point.  This should probably use locale to find the correct
+	 * char to print out.
+	 */
+	if (max > 0) {
+		dopr_outch (buffer, currlen, maxlen, '.');
+		
+		while (zpadlen > 0) {
+		  dopr_outch (buffer, currlen, maxlen, '0');
+		  --zpadlen;
+		}
+
+		while (fplace > 0) 
+			dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
+	}
+	
+	while (padlen < 0) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		++padlen;
+	}
+}
+
+static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
+{
+	if (*currlen < maxlen) {
+		buffer[(*currlen)] = c;
+	}
+	(*currlen)++;
+}
+
+#if !defined(HAVE_VSNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
+#define vsnprintf rsync_vsnprintf
+ int vsnprintf(char *str, size_t count, const char *fmt, va_list args)
+{
+	return dopr(str, count, fmt, args);
+}
+#endif
+
+#if !defined(HAVE_SNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
+#define snprintf rsync_snprintf
+ int snprintf(char *str,size_t count,const char *fmt,...)
+{
+	size_t ret;
+	va_list ap;
+    
+	va_start(ap, fmt);
+	ret = vsnprintf(str, count, fmt, ap);
+	va_end(ap);
+	return ret;
+}
+#endif
+
+#endif 
+
+#ifndef HAVE_VASPRINTF
+ int vasprintf(char **ptr, const char *format, va_list ap)
+{
+	int ret;
+	
+	ret = vsnprintf(NULL, 0, format, ap);
+	if (ret <= 0) return ret;
+
+	(*ptr) = (char *)malloc(ret+1);
+	if (!*ptr) return -1;
+	ret = vsnprintf(*ptr, ret+1, format, ap);
+
+	return ret;
+}
+#endif
+
+
+#ifndef HAVE_ASPRINTF
+ int asprintf(char **ptr, const char *format, ...)
+{
+	va_list ap;
+	int ret;
+	
+	va_start(ap, format);
+	ret = vasprintf(ptr, format, ap);
+	va_end(ap);
+
+	return ret;
+}
+#endif
+
+#ifdef TEST_SNPRINTF
+
+ int sprintf(char *str,const char *fmt,...);
+
+ int main (void)
+{
+	char buf1[1024];
+	char buf2[1024];
+	char *fp_fmt[] = {
+		"%1.1f",
+		"%-1.5f",
+		"%1.5f",
+		"%123.9f",
+		"%10.5f",
+		"% 10.5f",
+		"%+22.9f",
+		"%+4.9f",
+		"%01.3f",
+		"%4f",
+		"%3.1f",
+		"%3.2f",
+		"%.0f",
+		"%f",
+		"-16.16f",
+		NULL
+	};
+	double fp_nums[] = { 6442452944.1234, -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, 
+			     0.9996, 1.996, 4.136,  0};
+	char *int_fmt[] = {
+		"%-1.5d",
+		"%1.5d",
+		"%123.9d",
+		"%5.5d",
+		"%10.5d",
+		"% 10.5d",
+		"%+22.33d",
+		"%01.3d",
+		"%4d",
+		"%d",
+		NULL
+	};
+	long int_nums[] = { -1, 134, 91340, 341, 0203, 0};
+	char *str_fmt[] = {
+		"10.5s",
+		"5.10s",
+		"10.1s",
+		"0.10s",
+		"10.0s",
+		"1.10s",
+		"%s",
+		"%.1s",
+		"%.10s",
+		"%10s",
+		NULL
+	};
+	char *str_vals[] = {"hello", "a", "", "a longer string", NULL};
+	int x, y;
+	int fail = 0;
+	int num = 0;
+
+	printf ("Testing snprintf format codes against system sprintf...\n");
+
+	for (x = 0; fp_fmt[x] ; x++) {
+		for (y = 0; fp_nums[y] != 0 ; y++) {
+			int l1 = snprintf(NULL, 0, fp_fmt[x], fp_nums[y]);
+			int l2 = snprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
+			sprintf (buf2, fp_fmt[x], fp_nums[y]);
+			if (strcmp (buf1, buf2)) {
+				printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n", 
+				       fp_fmt[x], buf1, buf2);
+				fail++;
+			}
+			if (l1 != l2) {
+				printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, fp_fmt[x]);
+				fail++;
+			}
+			num++;
+		}
+	}
+
+	for (x = 0; int_fmt[x] ; x++) {
+		for (y = 0; int_nums[y] != 0 ; y++) {
+			int l1 = snprintf(NULL, 0, int_fmt[x], int_nums[y]);
+			int l2 = snprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
+			sprintf (buf2, int_fmt[x], int_nums[y]);
+			if (strcmp (buf1, buf2)) {
+				printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n", 
+				       int_fmt[x], buf1, buf2);
+				fail++;
+			}
+			if (l1 != l2) {
+				printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, int_fmt[x]);
+				fail++;
+			}
+			num++;
+		}
+	}
+
+	for (x = 0; str_fmt[x] ; x++) {
+		for (y = 0; str_vals[y] != 0 ; y++) {
+			int l1 = snprintf(NULL, 0, str_fmt[x], str_vals[y]);
+			int l2 = snprintf(buf1, sizeof(buf1), str_fmt[x], str_vals[y]);
+			sprintf (buf2, str_fmt[x], str_vals[y]);
+			if (strcmp (buf1, buf2)) {
+				printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n", 
+				       str_fmt[x], buf1, buf2);
+				fail++;
+			}
+			if (l1 != l2) {
+				printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, str_fmt[x]);
+				fail++;
+			}
+			num++;
+		}
+	}
+
+	printf ("%d tests failed out of %d.\n", fail, num);
+
+	printf("seeing how many digits we support\n");
+	{
+		double v0 = 0.12345678901234567890123456789012345678901;
+		for (x=0; x<100; x++) {
+			snprintf(buf1, sizeof(buf1), "%1.1f", v0*pow(10, x));
+			sprintf(buf2,                "%1.1f", v0*pow(10, x));
+			if (strcmp(buf1, buf2)) {
+				printf("we seem to support %d digits\n", x-1);
+				break;
+			}
+		}
+	}
+
+	return 0;
+}
+#endif /* SNPRINTF_TEST */

lib/wildmatch.c

@@ -0,0 +1,229 @@
+/*
+**  Do shell-style pattern matching for ?, \, [], and * characters.
+**  It is 8bit clean.
+**
+**  Written by Rich $alz, mirror!rs, Wed Nov 26 19:03:17 EST 1986.
+**  Rich $alz is now <rsalz@bbn.com>.
+**
+**  Modified by Wayne Davison to special-case '/' matching, to make '**'
+**  work differently than '*', and to fix the character-class code.
+*/
+
+#include "rsync.h"
+
+/* What character marks an inverted character class? */
+#define NEGATE_CLASS	'!'
+#define NEGATE_CLASS2	'^'
+
+#define FALSE 0
+#define TRUE 1
+#define ABORT_ALL -1
+#define ABORT_TO_STARSTAR -2
+
+#define CC_EQ(class, len, litmatch) ((len) == sizeof (litmatch)-1 \
+				    && *(class) == *(litmatch) \
+				    && strncmp((char*)class, litmatch, len) == 0)
+
+#if defined STDC_HEADERS || !defined isascii
+# define ISASCII(c) 1
+#else
+# define ISASCII(c) isascii(c)
+#endif
+
+#ifdef isblank
+# define ISBLANK(c) (ISASCII(c) && isblank(c))
+#else
+# define ISBLANK(c) ((c) == ' ' || (c) == '\t')
+#endif
+
+#ifdef isgraph
+# define ISGRAPH(c) (ISASCII(c) && isgraph(c))
+#else
+# define ISGRAPH(c) (ISASCII(c) && isprint(c) && !isspace(c))
+#endif
+
+#define ISPRINT(c) (ISASCII(c) && isprint(c))
+#define ISDIGIT(c) (ISASCII(c) && isdigit(c))
+#define ISALNUM(c) (ISASCII(c) && isalnum(c))
+#define ISALPHA(c) (ISASCII(c) && isalpha(c))
+#define ISCNTRL(c) (ISASCII(c) && iscntrl(c))
+#define ISLOWER(c) (ISASCII(c) && islower(c))
+#define ISPUNCT(c) (ISASCII(c) && ispunct(c))
+#define ISSPACE(c) (ISASCII(c) && isspace(c))
+#define ISUPPER(c) (ISASCII(c) && isupper(c))
+#define ISXDIGIT(c) (ISASCII(c) && isxdigit(c))
+
+#ifdef WILD_TEST_ITERATIONS
+int wildmatch_iteration_count;
+#endif
+
+static int domatch(const unsigned char *p, const unsigned char *text)
+{
+    int matched, special;
+    unsigned char ch, prev;
+
+#ifdef WILD_TEST_ITERATIONS
+    wildmatch_iteration_count++;
+#endif
+
+    for ( ; (ch = *p) != '\0'; text++, p++) {
+	if (*text == '\0' && ch != '*')
+	    return FALSE;
+	switch (ch) {
+	  case '\\':
+	    /* Literal match with following character.  Note that the test
+	     * in "default" handles the p[1] == '\0' failure case. */
+	    ch = *++p;
+	    /* FALLTHROUGH */
+	  default:
+	    if (*text != ch)
+		return FALSE;
+	    continue;
+	  case '?':
+	    /* Match anything but '/'. */
+	    if (*text == '/')
+		return FALSE;
+	    continue;
+	  case '*':
+	    if (*++p == '*') {
+		while (*++p == '*') {}
+		special = TRUE;
+	    }
+	    else
+		special = FALSE;
+	    if (*p == '\0') {
+		/* Trailing "**" matches everything.  Trailing "*" matches
+		 * only if there are no more slash characters. */
+		return special? TRUE : strchr((char*)text, '/') == NULL;
+	    }
+	    for ( ; *text; text++) {
+		if ((matched = domatch(p, text)) != FALSE) {
+		    if (!special || matched != ABORT_TO_STARSTAR)
+			return matched;
+		}
+		else if (!special && *text == '/')
+		    return ABORT_TO_STARSTAR;
+	    }
+	    return ABORT_ALL;
+	  case '[':
+	    ch = *++p;
+#ifdef NEGATE_CLASS2
+	    if (ch == NEGATE_CLASS2)
+		ch = NEGATE_CLASS;
+#endif
+	    /* Assign literal TRUE/FALSE because of "matched" comparison. */
+	    special = ch == NEGATE_CLASS? TRUE : FALSE;
+	    if (special) {
+		/* Inverted character class. */
+		ch = *++p;
+	    }
+	    prev = 0;
+	    matched = FALSE;
+	    do {
+		if (!ch)
+		    return ABORT_ALL;
+		if (ch == '\\') {
+		    ch = *++p;
+		    if (!ch)
+			return ABORT_ALL;
+		    if (*text == ch)
+			matched = TRUE;
+		}
+		else if (ch == '-' && prev && p[1] && p[1] != ']') {
+		    ch = *++p;
+		    if (ch == '\\') {
+			ch = *++p;
+			if (!ch)
+			    return ABORT_ALL;
+		    }
+		    if (*text <= ch && *text >= prev)
+			matched = TRUE;
+		    ch = 0; /* This makes "prev" get set to 0. */
+		}
+		else if (ch == '[' && p[1] == ':') {
+		    const unsigned char *s = p += 2;
+		    int i;
+		    while ((ch = *p) && ch != ']') p++;
+		    if (!ch)
+			return ABORT_ALL;
+		    i = p - s - 1;
+		    if (i < 0 || p[-1] != ':') {
+			/* Didn't find ":]", so treat like a normal set. */
+			p = s - 2;
+			ch = '[';
+			if (*text == ch)
+			    matched = TRUE;
+			continue;
+		    }
+		    if (CC_EQ(s,i, "alnum")) {
+			if (ISALNUM(*text))
+			    matched = TRUE;
+		    }
+		    else if (CC_EQ(s,i, "alpha")) {
+			if (ISALPHA(*text))
+			    matched = TRUE;
+		    }
+		    else if (CC_EQ(s,i, "blank")) {
+			if (ISBLANK(*text))
+			    matched = TRUE;
+		    }
+		    else if (CC_EQ(s,i, "cntrl")) {
+			if (ISCNTRL(*text))
+			    matched = TRUE;
+		    }
+		    else if (CC_EQ(s,i, "digit")) {
+			if (ISDIGIT(*text))
+			    matched = TRUE;
+		    }
+		    else if (CC_EQ(s,i, "graph")) {
+			if (ISGRAPH(*text))
+			    matched = TRUE;
+		    }
+		    else if (CC_EQ(s,i, "lower")) {
+			if (ISLOWER(*text))
+			    matched = TRUE;
+		    }
+		    else if (CC_EQ(s,i, "print")) {
+			if (ISPRINT(*text))
+			    matched = TRUE;
+		    }
+		    else if (CC_EQ(s,i, "punct")) {
+			if (ISPUNCT(*text))
+			    matched = TRUE;
+		    }
+		    else if (CC_EQ(s,i, "space")) {
+			if (ISSPACE(*text))
+			    matched = TRUE;
+		    }
+		    else if (CC_EQ(s,i, "upper")) {
+			if (ISUPPER(*text))
+			    matched = TRUE;
+		    }
+		    else if (CC_EQ(s,i, "xdigit")) {
+			if (ISXDIGIT(*text))
+			    matched = TRUE;
+		    }
+		    else /* malformed [:class:] string */
+			return ABORT_ALL;
+		    ch = 0; /* This makes "prev" get set to 0. */
+		}
+		else if (*text == ch)
+		    matched = TRUE;
+	    } while (prev = ch, (ch = *++p) != ']');
+	    if (matched == special || *text == '/')
+		return FALSE;
+	    continue;
+	}
+    }
+
+    return *text == '\0';
+}
+
+/* Find the pattern (p) in the text string (t). */
+int wildmatch(const char *p, const char *t)
+{
+#ifdef WILD_TEST_ITERATIONS
+    wildmatch_iteration_count = 0;
+#endif
+    return domatch((const unsigned char*)p, (const unsigned char*)t) == TRUE;
+}

lib/wildmatch.h

@@ -0,0 +1,3 @@
+/* wildmatch.h */
+
+int wildmatch(const char *p, const char *text);

lib/zlib.h

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

loadparm.c

@@ -0,0 +1,802 @@
+/* This is based on loadparm.c from Samba, written by Andrew Tridgell
+   and Karl Auer */
+
+/* some fixes
+ *
+ * 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.
+*/
+
+/*
+ *  Load parameters.
+ *
+ *  This module provides suitable callback functions for the params
+ *  module. It builds the internal table of service details which is
+ *  then used by the rest of the server.
+ *
+ * To add a parameter:
+ *
+ * 1) add it to the global or service structure definition
+ * 2) add it to the parm_table
+ * 3) add it to the list of available functions (eg: using FN_GLOBAL_STRING())
+ * 4) If it's a global then initialise it in init_globals. If a local
+ *    (ie. service) parameter then initialise it in the sDefault structure
+ *  
+ *
+ * Notes:
+ *   The configuration file is processed sequentially for speed. It is NOT
+ *   accessed randomly as happens in 'real' Windows. For this reason, there
+ *   is a fair bit of sequence-dependent code here - ie., code which assumes
+ *   that certain things happen before others. In particular, the code which
+ *   happens at the boundary between sections is delicately poised, so be
+ *   careful!
+ *
+ */
+
+/* TODO: Parameter to set debug level on server. */
+
+#include "rsync.h"
+#define PTR_DIFF(p1,p2) ((ptrdiff_t)(((char *)(p1)) - (char *)(p2)))
+#define strequal(a,b) (strcasecmp(a,b)==0)
+#define BOOLSTR(b) ((b) ? "Yes" : "No")
+typedef char pstring[1024];
+#define pstrcpy(a,b) strlcpy(a,b,sizeof(pstring))
+
+/* the following are used by loadparm for option lists */
+typedef enum
+{
+	P_BOOL,P_BOOLREV,P_CHAR,P_INTEGER,P_OCTAL,
+	P_STRING,P_GSTRING,P_ENUM,P_SEP
+} parm_type;
+
+typedef enum
+{
+	P_LOCAL,P_GLOBAL,P_SEPARATOR,P_NONE
+} parm_class;
+
+struct enum_list {
+	int value;
+	char *name;
+};
+
+struct parm_struct
+{
+	char *label;
+	parm_type type;
+	parm_class class;
+	void *ptr;
+	struct enum_list *enum_list;
+	unsigned flags;
+};
+
+#ifndef GLOBAL_NAME
+#define GLOBAL_NAME "global"
+#endif
+
+/* some helpful bits */
+#define pSERVICE(i) ServicePtrs[i]
+#define iSERVICE(i) (*pSERVICE(i))
+#define LP_SNUM_OK(iService) (((iService) >= 0) && ((iService) < iNumServices))
+
+/* 
+ * This structure describes global (ie., server-wide) parameters.
+ */
+typedef struct
+{
+	char *motd_file;
+	char *log_file;
+	char *pid_file;
+	int syslog_facility;
+	char *socket_options;
+} global;
+
+static global Globals;
+
+
+
+/* 
+ * This structure describes a single service. 
+ */
+typedef struct
+{
+	char *name;
+	char *path;
+	char *comment;
+	char *lock_file;
+	BOOL read_only;
+	BOOL list;
+	BOOL use_chroot;
+	BOOL transfer_logging;
+	BOOL ignore_errors;
+	char *uid;
+	char *gid;
+	char *hosts_allow;
+	char *hosts_deny;
+	char *auth_users;
+	char *secrets_file;
+	BOOL strict_modes;
+	char *exclude;
+	char *exclude_from;
+	char *include;
+	char *include_from;
+	char *log_format;
+	char *refuse_options;
+	char *dont_compress;
+	int timeout;
+	int max_connections;
+	BOOL ignore_nonreadable;
+} service;
+
+
+/* This is a default service used to prime a services structure */
+static service sDefault = 
+{
+	NULL,    /* name */
+	NULL,    /* path */
+	NULL,    /* comment */
+	DEFAULT_LOCK_FILE,    /* lock file */
+	True,    /* read only */
+	True,    /* list */
+	True,    /* use chroot */
+	False,   /* transfer logging */
+	False,   /* ignore errors */
+	"nobody",/* uid */
+	
+	/* TODO: This causes problems on Debian, where it is called
+	 * "nogroup".  Debian patch this in their version of the
+	 * package, but it would be nice to be consistent.  Possibly
+	 * other systems are different again.
+	 *
+	 * What is the best behaviour?  Perhaps always using (gid_t)
+	 * -2? */
+	"nobody",/* gid */
+	
+	NULL,    /* hosts allow */
+	NULL,    /* hosts deny */
+	NULL,    /* auth users */
+	NULL,    /* secrets file */
+	True,   /* strict modes */
+	NULL,    /* exclude */
+	NULL,    /* exclude from */
+	NULL,    /* include */
+	NULL,    /* include from */
+	"%o %h [%a] %m (%u) %f %l",    /* log format */
+	NULL,    /* refuse options */
+	"*.gz *.tgz *.zip *.z *.rpm *.deb *.iso *.bz2 *.tbz",    /* dont compress */
+	0,        /* timeout */
+	0,        /* max connections */
+	False     /* ignore nonreadable */
+};
+
+
+
+/* local variables */
+static service **ServicePtrs = NULL;
+static int iNumServices = 0;
+static int iServiceIndex = 0;
+static BOOL bInGlobalSection = True;
+
+#define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
+
+static struct enum_list enum_facilities[] = {
+#ifdef LOG_AUTH
+	{ LOG_AUTH, "auth" },
+#endif
+#ifdef LOG_AUTHPRIV
+	{ LOG_AUTHPRIV, "authpriv" },
+#endif
+#ifdef LOG_CRON
+	{ LOG_CRON, "cron" },
+#endif
+#ifdef LOG_DAEMON
+	{ LOG_DAEMON, "daemon" },
+#endif
+#ifdef LOG_FTP
+	{ LOG_FTP, "ftp" },
+#endif
+#ifdef LOG_KERN
+	{ LOG_KERN, "kern" },
+#endif
+#ifdef LOG_LPR
+	{ LOG_LPR, "lpr" },
+#endif
+#ifdef LOG_MAIL
+	{ LOG_MAIL, "mail" },
+#endif
+#ifdef LOG_NEWS
+	{ LOG_NEWS, "news" },
+#endif
+#ifdef LOG_AUTH
+	{ LOG_AUTH, "security" },		
+#endif
+#ifdef LOG_SYSLOG
+	{ LOG_SYSLOG, "syslog" },
+#endif
+#ifdef LOG_USER
+	{ LOG_USER, "user" },
+#endif
+#ifdef LOG_UUCP
+	{ LOG_UUCP, "uucp" },
+#endif
+#ifdef LOG_LOCAL0
+	{ LOG_LOCAL0, "local0" },
+#endif
+#ifdef LOG_LOCAL1
+	{ LOG_LOCAL1, "local1" },
+#endif
+#ifdef LOG_LOCAL2
+	{ LOG_LOCAL2, "local2" },
+#endif
+#ifdef LOG_LOCAL3
+	{ LOG_LOCAL3, "local3" },
+#endif
+#ifdef LOG_LOCAL4
+	{ LOG_LOCAL4, "local4" },
+#endif
+#ifdef LOG_LOCAL5
+	{ LOG_LOCAL5, "local5" },
+#endif
+#ifdef LOG_LOCAL6
+	{ LOG_LOCAL6, "local6" },
+#endif
+#ifdef LOG_LOCAL7
+	{ LOG_LOCAL7, "local7" },
+#endif
+	{ -1, NULL }};
+
+
+/* note that we do not initialise the defaults union - it is not allowed in ANSI C */
+static struct parm_struct parm_table[] =
+{
+  {"motd file",        P_STRING,  P_GLOBAL, &Globals.motd_file,    NULL,   0},
+  {"syslog facility",  P_ENUM,    P_GLOBAL, &Globals.syslog_facility, enum_facilities,0},
+  {"socket options",   P_STRING,  P_GLOBAL, &Globals.socket_options,NULL,  0},
+  {"log file",         P_STRING,  P_GLOBAL, &Globals.log_file,      NULL,  0},
+  {"pid file",         P_STRING,  P_GLOBAL, &Globals.pid_file,      NULL,  0},
+
+  {"timeout",          P_INTEGER, P_LOCAL,  &sDefault.timeout,     NULL,  0},
+  {"max connections",  P_INTEGER, P_LOCAL,  &sDefault.max_connections,NULL, 0},
+  {"name",             P_STRING,  P_LOCAL,  &sDefault.name,        NULL,   0},
+  {"comment",          P_STRING,  P_LOCAL,  &sDefault.comment,     NULL,   0},
+  {"lock file",        P_STRING,  P_LOCAL,  &sDefault.lock_file,   NULL,   0},
+  {"path",             P_STRING,  P_LOCAL,  &sDefault.path,        NULL,   0},
+  {"read only",        P_BOOL,    P_LOCAL,  &sDefault.read_only,   NULL,   0},
+  {"list",             P_BOOL,    P_LOCAL,  &sDefault.list,        NULL,   0},
+  {"use chroot",       P_BOOL,    P_LOCAL,  &sDefault.use_chroot,  NULL,   0},
+  {"ignore nonreadable",P_BOOL,   P_LOCAL,  &sDefault.ignore_nonreadable,  NULL,   0},
+  {"uid",              P_STRING,  P_LOCAL,  &sDefault.uid,         NULL,   0},
+  {"gid",              P_STRING,  P_LOCAL,  &sDefault.gid,         NULL,   0},
+  {"hosts allow",      P_STRING,  P_LOCAL,  &sDefault.hosts_allow, NULL,   0},
+  {"hosts deny",       P_STRING,  P_LOCAL,  &sDefault.hosts_deny,  NULL,   0},
+  {"auth users",       P_STRING,  P_LOCAL,  &sDefault.auth_users,  NULL,   0},
+  {"secrets file",     P_STRING,  P_LOCAL,  &sDefault.secrets_file,NULL,   0},
+  {"strict modes",     P_BOOL,    P_LOCAL,  &sDefault.strict_modes,NULL,   0},
+  {"exclude",          P_STRING,  P_LOCAL,  &sDefault.exclude,     NULL,   0},
+  {"exclude from",     P_STRING,  P_LOCAL,  &sDefault.exclude_from,NULL,   0},
+  {"include",          P_STRING,  P_LOCAL,  &sDefault.include,     NULL,   0},
+  {"include from",     P_STRING,  P_LOCAL,  &sDefault.include_from,NULL,   0},
+  {"transfer logging", P_BOOL,    P_LOCAL,  &sDefault.transfer_logging,NULL,0},
+  {"ignore errors",    P_BOOL,    P_LOCAL,  &sDefault.ignore_errors,NULL,0},
+  {"log format",       P_STRING,  P_LOCAL,  &sDefault.log_format,  NULL,   0},
+  {"refuse options",   P_STRING,  P_LOCAL,  &sDefault.refuse_options,NULL, 0},
+  {"dont compress",    P_STRING,  P_LOCAL,  &sDefault.dont_compress,NULL,  0},
+  {NULL,               P_BOOL,    P_NONE,   NULL,                  NULL,   0}
+};
+
+
+/***************************************************************************
+Initialise the global parameter structure.
+***************************************************************************/
+static void init_globals(void)
+{
+	memset(&Globals, 0, sizeof(Globals));
+#ifdef LOG_DAEMON
+	Globals.syslog_facility = LOG_DAEMON;
+#endif
+}
+
+/***************************************************************************
+Initialise the sDefault parameter structure.
+***************************************************************************/
+static void init_locals(void)
+{
+}
+
+
+/*
+   In this section all the functions that are used to access the 
+   parameters from the rest of the program are defined 
+*/
+
+#define FN_GLOBAL_STRING(fn_name,ptr) \
+ char *fn_name(void) {return(*(char **)(ptr) ? *(char **)(ptr) : "");}
+#define FN_GLOBAL_BOOL(fn_name,ptr) \
+ BOOL fn_name(void) {return(*(BOOL *)(ptr));}
+#define FN_GLOBAL_CHAR(fn_name,ptr) \
+ char fn_name(void) {return(*(char *)(ptr));}
+#define FN_GLOBAL_INTEGER(fn_name,ptr) \
+ int fn_name(void) {return(*(int *)(ptr));}
+
+#define FN_LOCAL_STRING(fn_name,val) \
+ char *fn_name(int i) {return((LP_SNUM_OK(i)&&pSERVICE(i)->val)?pSERVICE(i)->val : (sDefault.val?sDefault.val:""));}
+#define FN_LOCAL_BOOL(fn_name,val) \
+ BOOL fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
+#define FN_LOCAL_CHAR(fn_name,val) \
+ char fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
+#define FN_LOCAL_INTEGER(fn_name,val) \
+ int fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
+
+
+FN_GLOBAL_STRING(lp_motd_file, &Globals.motd_file)
+FN_GLOBAL_STRING(lp_log_file, &Globals.log_file)
+FN_GLOBAL_STRING(lp_pid_file, &Globals.pid_file)
+FN_GLOBAL_STRING(lp_socket_options, &Globals.socket_options)
+FN_GLOBAL_INTEGER(lp_syslog_facility, &Globals.syslog_facility)
+
+FN_LOCAL_STRING(lp_name, name)
+FN_LOCAL_STRING(lp_comment, comment)
+FN_LOCAL_STRING(lp_path, path)
+FN_LOCAL_STRING(lp_lock_file, lock_file)
+FN_LOCAL_BOOL(lp_read_only, read_only)
+FN_LOCAL_BOOL(lp_list, list)
+FN_LOCAL_BOOL(lp_use_chroot, use_chroot)
+FN_LOCAL_BOOL(lp_transfer_logging, transfer_logging)
+FN_LOCAL_BOOL(lp_ignore_errors, ignore_errors)
+FN_LOCAL_BOOL(lp_ignore_nonreadable, ignore_nonreadable)
+FN_LOCAL_STRING(lp_uid, uid)
+FN_LOCAL_STRING(lp_gid, gid)
+FN_LOCAL_STRING(lp_hosts_allow, hosts_allow)
+FN_LOCAL_STRING(lp_hosts_deny, hosts_deny)
+FN_LOCAL_STRING(lp_auth_users, auth_users)
+FN_LOCAL_STRING(lp_secrets_file, secrets_file)
+FN_LOCAL_BOOL(lp_strict_modes, strict_modes)
+FN_LOCAL_STRING(lp_exclude, exclude)
+FN_LOCAL_STRING(lp_exclude_from, exclude_from)
+FN_LOCAL_STRING(lp_include, include)
+FN_LOCAL_STRING(lp_include_from, include_from)
+FN_LOCAL_STRING(lp_log_format, log_format)
+FN_LOCAL_STRING(lp_refuse_options, refuse_options)
+FN_LOCAL_STRING(lp_dont_compress, dont_compress)
+FN_LOCAL_INTEGER(lp_timeout, timeout)
+FN_LOCAL_INTEGER(lp_max_connections, max_connections)
+
+/* local prototypes */
+static int    strwicmp( char *psz1, char *psz2 );
+static int    map_parameter( char *parmname);
+static BOOL   set_boolean( BOOL *pb, char *parmvalue );
+static int    getservicebyname(char *name, service *pserviceDest);
+static void   copy_service( service *pserviceDest, 
+                            service *pserviceSource);
+static BOOL   do_parameter(char *parmname, char *parmvalue);
+static BOOL   do_section(char *sectionname);
+
+
+/***************************************************************************
+initialise a service to the defaults
+***************************************************************************/
+static void init_service(service *pservice)
+{
+	memset((char *)pservice,0,sizeof(service));
+	copy_service(pservice,&sDefault);
+}
+
+
+/**
+ * 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)
+{
+	if (!v) {
+		*s = NULL;
+		return;
+	}
+	*s = strdup(v);
+	if (!*s)
+		exit_cleanup(RERR_MALLOC);
+}
+
+
+/***************************************************************************
+add a new service to the services array initialising it with the given 
+service
+***************************************************************************/
+static int add_a_service(service *pservice, char *name)
+{
+  int i;
+  service tservice;
+  int num_to_alloc = iNumServices+1;
+
+  tservice = *pservice;
+
+  /* it might already exist */
+  if (name) 
+    {
+      i = getservicebyname(name,NULL);
+      if (i >= 0)
+	return(i);
+    }
+
+  i = iNumServices;
+
+  ServicePtrs = realloc_array(ServicePtrs, service *, num_to_alloc);
+
+  if (ServicePtrs)
+	  pSERVICE(iNumServices) = new(service);
+
+  if (!ServicePtrs || !pSERVICE(iNumServices))
+	  return(-1);
+
+  iNumServices++;
+
+  init_service(pSERVICE(i));
+  copy_service(pSERVICE(i),&tservice);
+  if (name)
+    string_set(&iSERVICE(i).name,name);  
+
+  return(i);
+}
+
+/***************************************************************************
+Do a case-insensitive, whitespace-ignoring string compare.
+***************************************************************************/
+static int strwicmp(char *psz1, char *psz2)
+{
+   /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
+   /* appropriate value. */
+   if (psz1 == psz2)
+      return (0);
+   else
+      if (psz1 == NULL)
+         return (-1);
+      else
+          if (psz2 == NULL)
+              return (1);
+
+   /* sync the strings on first non-whitespace */
+   while (1)
+   {
+      while (isspace(* (unsigned char *) psz1))
+         psz1++;
+      while (isspace(* (unsigned char *) psz2))
+         psz2++;
+      if (toupper(* (unsigned char *) psz1) != toupper(* (unsigned char *) psz2)
+	  || *psz1 == '\0' || *psz2 == '\0')
+         break;
+      psz1++;
+      psz2++;
+   }
+   return (*psz1 - *psz2);
+}
+
+/***************************************************************************
+Map a parameter's string representation to something we can use. 
+Returns False if the parameter string is not recognised, else TRUE.
+***************************************************************************/
+static int map_parameter(char *parmname)
+{
+   int iIndex;
+
+   if (*parmname == '-')
+     return(-1);
+
+   for (iIndex = 0; parm_table[iIndex].label; iIndex++) 
+      if (strwicmp(parm_table[iIndex].label, parmname) == 0)
+         return(iIndex);
+
+   rprintf(FERROR, "Unknown Parameter encountered: \"%s\"\n", parmname);
+   return(-1);
+}
+
+
+/***************************************************************************
+Set a boolean variable from the text value stored in the passed string.
+Returns True in success, False if the passed string does not correctly 
+represent a boolean.
+***************************************************************************/
+static BOOL set_boolean(BOOL *pb, char *parmvalue)
+{
+   BOOL bRetval;
+
+   bRetval = True;
+   if (strwicmp(parmvalue, "yes") == 0 ||
+       strwicmp(parmvalue, "true") == 0 ||
+       strwicmp(parmvalue, "1") == 0)
+      *pb = True;
+   else
+      if (strwicmp(parmvalue, "no") == 0 ||
+          strwicmp(parmvalue, "False") == 0 ||
+          strwicmp(parmvalue, "0") == 0)
+         *pb = False;
+      else
+      {
+         rprintf(FERROR, "Badly formed boolean in configuration file: \"%s\".\n",
+               parmvalue);
+         bRetval = False;
+      }
+   return (bRetval);
+}
+
+/***************************************************************************
+Find a service by name. Otherwise works like get_service.
+***************************************************************************/
+static int getservicebyname(char *name, service *pserviceDest)
+{
+   int iService;
+
+   for (iService = iNumServices - 1; iService >= 0; iService--)
+      if (strwicmp(iSERVICE(iService).name, name) == 0) 
+      {
+         if (pserviceDest != NULL)
+	   copy_service(pserviceDest, pSERVICE(iService));
+         break;
+      }
+
+   return (iService);
+}
+
+
+
+/***************************************************************************
+Copy a service structure to another
+
+***************************************************************************/
+static void copy_service(service *pserviceDest, 
+                         service *pserviceSource)
+{
+  int i;
+
+  for (i=0;parm_table[i].label;i++)
+    if (parm_table[i].ptr && parm_table[i].class == P_LOCAL) {
+	void *def_ptr = parm_table[i].ptr;
+	void *src_ptr = 
+	  ((char *)pserviceSource) + PTR_DIFF(def_ptr,&sDefault);
+	void *dest_ptr = 
+	  ((char *)pserviceDest) + PTR_DIFF(def_ptr,&sDefault);
+
+	switch (parm_table[i].type)
+	  {
+	  case P_BOOL:
+	  case P_BOOLREV:
+	    *(BOOL *)dest_ptr = *(BOOL *)src_ptr;
+	    break;
+
+	  case P_INTEGER:
+	  case P_ENUM:
+	  case P_OCTAL:
+	    *(int *)dest_ptr = *(int *)src_ptr;
+	    break;
+
+	  case P_CHAR:
+	    *(char *)dest_ptr = *(char *)src_ptr;
+	    break;
+
+	  case P_STRING:
+	    string_set(dest_ptr,*(char **)src_ptr);
+	    break;
+
+	  default:
+	    break;
+	  }
+      }
+}
+
+
+/***************************************************************************
+Process a parameter for a particular service number. If snum < 0
+then assume we are in the globals
+***************************************************************************/
+static BOOL lp_do_parameter(int snum, char *parmname, char *parmvalue)
+{
+   int parmnum, i;
+   void *parm_ptr=NULL; /* where we are going to store the result */
+   void *def_ptr=NULL;
+
+   parmnum = map_parameter(parmname);
+
+   if (parmnum < 0)
+     {
+       rprintf(FERROR, "IGNORING unknown parameter \"%s\"\n", parmname);
+       return(True);
+     }
+
+   def_ptr = parm_table[parmnum].ptr;
+
+   /* we might point at a service, the default service or a global */
+   if (snum < 0) {
+     parm_ptr = def_ptr;
+   } else {
+       if (parm_table[parmnum].class == P_GLOBAL) {
+	   rprintf(FERROR, "Global parameter %s found in service section!\n",parmname);
+	   return(True);
+	 }
+       parm_ptr = ((char *)pSERVICE(snum)) + PTR_DIFF(def_ptr,&sDefault);
+   }
+
+   /* now switch on the type of variable it is */
+   switch (parm_table[parmnum].type)
+     {
+     case P_BOOL:
+       set_boolean(parm_ptr,parmvalue);
+       break;
+
+     case P_BOOLREV:
+       set_boolean(parm_ptr,parmvalue);
+       *(BOOL *)parm_ptr = ! *(BOOL *)parm_ptr;
+       break;
+
+     case P_INTEGER:
+       *(int *)parm_ptr = atoi(parmvalue);
+       break;
+
+     case P_CHAR:
+       *(char *)parm_ptr = *parmvalue;
+       break;
+
+     case P_OCTAL:
+       sscanf(parmvalue,"%o",(int *)parm_ptr);
+       break;
+
+     case P_STRING:
+       string_set(parm_ptr,parmvalue);
+       break;
+
+     case P_GSTRING:
+       strlcpy((char *)parm_ptr,parmvalue,sizeof(pstring));
+       break;
+
+     case P_ENUM:
+	     for (i=0;parm_table[parmnum].enum_list[i].name;i++) {
+		     if (strequal(parmvalue, parm_table[parmnum].enum_list[i].name)) {
+			     *(int *)parm_ptr = parm_table[parmnum].enum_list[i].value;
+			     break;
+		     }
+	     }
+	     if (!parm_table[parmnum].enum_list[i].name) {
+		     if (atoi(parmvalue) > 0)
+			     *(int *)parm_ptr = atoi(parmvalue);
+	     }
+	     break;
+     case P_SEP:
+	     break;
+     }
+
+   return(True);
+}
+
+/***************************************************************************
+Process a parameter.
+***************************************************************************/
+static BOOL do_parameter(char *parmname, char *parmvalue)
+{
+   return lp_do_parameter(bInGlobalSection?-2:iServiceIndex, parmname, parmvalue);
+}
+
+/***************************************************************************
+Process a new section (service). At this stage all sections are services.
+Later we'll have special sections that permit server parameters to be set.
+Returns True on success, False on failure.
+***************************************************************************/
+static BOOL do_section(char *sectionname)
+{
+   BOOL bRetval;
+   BOOL isglobal = (strwicmp(sectionname, GLOBAL_NAME) == 0);
+   bRetval = False;
+
+   /* if we were in a global section then do the local inits */
+   if (bInGlobalSection && !isglobal)
+     init_locals();
+
+   /* if we've just struck a global section, note the fact. */
+   bInGlobalSection = isglobal;   
+
+   /* check for multiple global sections */
+   if (bInGlobalSection)
+   {
+     return(True);
+   }
+
+   /* if we have a current service, tidy it up before moving on */
+   bRetval = True;
+
+   if (iServiceIndex >= 0)
+     bRetval = True;
+
+   /* if all is still well, move to the next record in the services array */
+   if (bRetval)
+     {
+       /* We put this here to avoid an odd message order if messages are */
+       /* issued by the post-processing of a previous section. */
+
+       if ((iServiceIndex=add_a_service(&sDefault,sectionname)) < 0)
+	 {
+	   rprintf(FERROR,"Failed to add a new service\n");
+	   return(False);
+	 }
+     }
+
+   return (bRetval);
+}
+
+
+/***************************************************************************
+Load the services array from the services file. Return True on success, 
+False on failure.
+***************************************************************************/
+BOOL lp_load(char *pszFname, int globals_only)
+{
+	extern int am_server;
+	extern int am_daemon;
+	extern int am_root;
+	pstring n2;
+	BOOL bRetval;
+ 
+	bRetval = False;
+
+	bInGlobalSection = True;
+  
+	init_globals();
+
+	if (pszFname)
+	    pstrcpy(n2,pszFname);
+	else if (am_server && am_daemon && !am_root)
+	    pstrcpy(n2,RSYNCD_USERCONF);
+	else
+	    pstrcpy(n2,RSYNCD_SYSCONF);
+
+	/* We get sections first, so have to start 'behind' to make up */
+	iServiceIndex = -1;
+	bRetval = pm_process(n2, globals_only?NULL:do_section, do_parameter);
+  
+	return (bRetval);
+}
+
+
+/***************************************************************************
+return the max number of services
+***************************************************************************/
+int lp_numservices(void)
+{
+  return(iNumServices);
+}
+
+/***************************************************************************
+Return the number of the service with the given name, or -1 if it doesn't
+exist. Note that this is a DIFFERENT ANIMAL from the internal function
+getservicebyname()! This works ONLY if all services have been loaded, and
+does not copy the found service.
+***************************************************************************/
+int lp_number(char *name)
+{
+   int iService;
+
+   for (iService = iNumServices - 1; iService >= 0; iService--)
+      if (strequal(lp_name(iService), name)) 
+         break;
+
+   return (iService);
+}
+

log.c

@@ -0,0 +1,586 @@
+/* -*- c-file-style: "linux"; -*-
+   
+   Copyright (C) 1998-2001 by Andrew Tridgell <tridge@samba.org>
+   Copyright (C) 2000-2001 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.
+*/
+
+/*
+  Logging and utility functions.
+  tridge, May 1998
+
+  Mapping to human-readable messages added by Martin Pool
+  <mbp@samba.org>, Oct 2000.
+  */
+#include "rsync.h"
+
+static int log_initialised;
+static char *logfname;
+static FILE *logfile;
+static int log_error_fd = -1;
+struct stats stats;
+
+int log_got_error=0;
+
+struct {
+        int code;
+        char const *name;
+} const rerr_names[] = {
+	{ RERR_SYNTAX     , "syntax or usage error" }, 
+	{ 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" }, 
+	{ RERR_MESSAGEIO  , "errors with program diagnostics" }, 
+	{ RERR_IPC        , "error in IPC code" }, 
+	{ RERR_SIGNAL     , "received SIGUSR1 or SIGINT" }, 
+	{ RERR_WAITCHILD  , "some error returned by waitpid()" }, 
+	{ RERR_MALLOC     , "error allocating core memory buffers" }, 
+	{ RERR_PARTIAL    , "some files could not be transferred" }, 
+	{ RERR_TIMEOUT    , "timeout in data send/receive" }, 
+	{ RERR_CMD_FAILED , "remote shell failed" },
+	{ RERR_CMD_KILLED , "remote shell killed" },
+	{ RERR_CMD_RUN,     "remote command could not be run" },
+        { RERR_CMD_NOTFOUND, "remote command not found" },
+        { 0, NULL }
+};
+
+
+
+/*
+ * Map from rsync error code to name, or return NULL.
+ */
+static char const *rerr_name(int code)
+{
+        int i;
+        for (i = 0; rerr_names[i].name; i++) {
+                if (rerr_names[i].code == code)
+                        return rerr_names[i].name;
+        }
+        return NULL;
+}
+
+struct err_list {
+	struct err_list *next;
+	char *buf;
+	int len;
+	int written; /* how many bytes we have written so far */
+};
+
+static struct err_list *err_list_head;
+static struct err_list *err_list_tail;
+
+/* add an error message to the pending error list */
+static void err_list_add(int code, char *buf, int len)
+{
+	struct err_list *el;
+	el = new(struct err_list);
+	if (!el) exit_cleanup(RERR_MALLOC);
+	el->next = NULL;
+	el->buf = new_array(char, len+4);
+	if (!el->buf) exit_cleanup(RERR_MALLOC);
+	memcpy(el->buf+4, buf, len);
+	SIVAL(el->buf, 0, ((code+MPLEX_BASE)<<24) | len);
+	el->len = len+4;
+	el->written = 0;
+	if (err_list_tail) {
+		err_list_tail->next = el;
+	} else {
+		err_list_head = el;
+	}
+	err_list_tail = el;
+}
+
+
+/* try to push errors off the error list onto the wire */
+void err_list_push(void)
+{
+	if (log_error_fd == -1) return;
+
+	while (err_list_head) {
+		struct err_list *el = err_list_head;
+		int n = write(log_error_fd, el->buf+el->written, el->len - el->written);
+		/* don't check for an error if the best way of handling the error is
+		   to ignore it */
+		if (n == -1) break;
+		if (n > 0) {
+			el->written += n;
+		}
+		if (el->written == el->len) {
+			free(el->buf);
+			err_list_head = el->next;
+			if (!err_list_head) err_list_tail = NULL;
+			free(el);
+		}
+	}
+}
+
+
+static void logit(int priority, char *buf)
+{
+	if (logfname) {
+		if (!logfile)
+			log_open();
+		fprintf(logfile,"%s [%d] %s", 
+			timestring(time(NULL)), (int)getpid(), buf);
+		fflush(logfile);
+	} else {
+		syslog(priority, "%s", buf);
+	}
+}
+
+void log_init(void)
+{
+	int options = LOG_PID;
+	time_t t;
+
+	if (log_initialised) return;
+	log_initialised = 1;
+
+	/* this looks pointless, but it is needed in order for the
+	   C library on some systems to fetch the timezone info
+	   before the chroot */
+	t = time(NULL);
+	localtime(&t);
+
+	/* optionally use a log file instead of syslog */
+	logfname = lp_log_file();
+	if (logfname) {
+		if (*logfname) {
+			log_open();
+			return;
+		}
+		logfname = NULL;
+	}
+
+#ifdef LOG_NDELAY
+	options |= LOG_NDELAY;
+#endif
+
+#ifdef LOG_DAEMON
+	openlog("rsyncd", options, lp_syslog_facility());
+#else
+	openlog("rsyncd", options);
+#endif
+
+#ifndef LOG_NDELAY
+	logit(LOG_INFO,"rsyncd started\n");
+#endif
+}
+
+void log_open(void)
+{
+	if (logfname && !logfile) {
+		extern int orig_umask;
+		int old_umask = umask(022 | orig_umask);
+		logfile = fopen(logfname, "a");
+		umask(old_umask);
+	}
+}
+
+void log_close(void)
+{
+	if (logfile) {
+		fclose(logfile);
+		logfile = NULL;
+	}
+}
+
+/* setup the error file descriptor - used when we are a server
+   that is receiving files */
+void set_error_fd(int fd)
+{
+	log_error_fd = fd;
+	set_nonblocking(log_error_fd);
+}
+
+/* this is the underlying (unformatted) rsync debugging function. Call
+   it with FINFO, FERROR or FLOG */
+void rwrite(enum logcode code, char *buf, int len)
+{
+	FILE *f=NULL;
+	extern int am_daemon;
+	extern int am_server;
+	extern int quiet;
+	/* recursion can happen with certain fatal conditions */
+
+	if (quiet && code == FINFO) return;
+
+	if (len < 0) exit_cleanup(RERR_MESSAGEIO);
+
+	buf[len] = 0;
+
+	if (code == FLOG) {
+		if (am_daemon) logit(LOG_INFO, buf);
+		return;
+	}
+
+	/* first try to pass it off to our sibling */
+	if (am_server && log_error_fd != -1) {
+		err_list_add(code, buf, len);
+		err_list_push();
+		return;
+	}
+
+	/* next, if we are a server but not in daemon mode, and multiplexing
+	 *  is enabled, pass it to the other side.  */
+	if (am_server && !am_daemon && io_multiplex_write(code, buf, len)) {
+		return;
+	}
+
+	/* otherwise, if in daemon mode and either we are not a server
+	 *  (that is, we are not running --daemon over a remote shell) or
+	 *  the log has already been initialised, log the message on this
+	 *  side because we don't want the client to see most errors for
+	 *  security reasons.  We do want early messages when running daemon
+	 *  mode over a remote shell to go to the remote side; those will
+	 *  fall through to the next case. */
+	if (am_daemon && (!am_server || log_initialised)) {
+		static int depth;
+		int priority = LOG_INFO;
+		if (code == FERROR) priority = LOG_WARNING;
+
+		if (depth) return;
+
+		depth++;
+
+		log_init();
+		logit(priority, buf);
+
+		depth--;
+		return;
+	}
+
+	if (code == FERROR) {
+		log_got_error = 1;
+		f = stderr;
+	} 
+
+	if (code == FINFO) {
+		if (am_server) 
+			f = stderr;
+		else
+			f = stdout;
+	} 
+
+	if (!f) exit_cleanup(RERR_MESSAGEIO);
+
+	if (fwrite(buf, len, 1, f) != 1) exit_cleanup(RERR_MESSAGEIO);
+
+	if (buf[len-1] == '\r' || buf[len-1] == '\n') fflush(f);
+}
+		
+
+/* This is the rsync debugging function. Call it with FINFO, FERROR or
+ * FLOG. */
+void rprintf(enum logcode code, const char *format, ...)
+{
+	va_list ap;  
+	char buf[1024];
+	int len;
+
+	va_start(ap, format);
+	/* 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 ((size_t) len > sizeof(buf)-1  ||  len < 0) {
+		const char ellipsis[] = "[...]";
+
+		/* Reset length, and zero-terminate the end of our buffer */
+		len = sizeof(buf)-1;
+		buf[len] = '\0';
+
+		/* Copy the ellipsis to the end of the string, but give
+		 * us one extra character:
+		 *
+		 *                  v--- null byte at buf[sizeof(buf)-1]
+		 *        abcdefghij0
+		 *     -> abcd[...]00  <-- now two null bytes at end
+		 *
+		 * If the input format string has a trailing newline,
+		 * we copy it into that extra null; if it doesn't, well,
+		 * all we lose is one byte.  */
+		strncpy(buf+len-sizeof(ellipsis), ellipsis, sizeof(ellipsis));
+		if (format[strlen(format)-1] == '\n') {
+			buf[len-1] = '\n';
+		}
+	}
+
+	rwrite(code, buf, len);
+}
+
+
+/* This is like rprintf, but it also tries to print some
+ * representation of the error code.  Normally errcode = errno.
+ *
+ * Unlike rprintf, this always adds a newline and there should not be
+ * one in the format string.
+ *
+ * Note that since strerror might involve dynamically loading a
+ * message catalog we need to call it once before chroot-ing. */
+void rsyserr(enum logcode code, int errcode, const char *format, ...)
+{
+	va_list ap;  
+	char buf[1024];
+	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);
+
+	/* 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 ((size_t) len + 3 + sys_len > sizeof(buf) - 1)
+                exit_cleanup(RERR_MESSAGEIO);
+
+        strcpy(buf + len, ": ");
+        len += 2;
+        strcpy(buf + len, sysmsg);
+        len += sys_len;
+        strcpy(buf + len, "\n");
+        len++;
+
+	rwrite(code, buf, len);
+}
+
+
+
+void rflush(enum logcode code)
+{
+	FILE *f = NULL;
+	extern int am_daemon;
+	
+	if (am_daemon) {
+		return;
+	}
+
+	if (code == FLOG) {
+		return;
+	} 
+
+	if (code == FERROR) {
+		f = stderr;
+	} 
+
+	if (code == FINFO) {
+		extern int am_server;
+		if (am_server) 
+			f = stderr;
+		else
+			f = stdout;
+	} 
+
+	if (!f) exit_cleanup(RERR_MESSAGEIO);
+	fflush(f);
+}
+
+
+
+/* a generic logging routine for send/recv, with parameter
+   substitiution */
+static void log_formatted(enum logcode code,
+			  char *format, char *op, struct file_struct *file,
+			  struct stats *initial_stats)
+{
+	extern int module_id;
+	extern char *auth_user;
+	char buf[1024];
+	char buf2[1024];
+	char *p, *s, *n;
+	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]; 
+	     s && (p=strchr(s,'%')); ) {
+		n = NULL;
+		s = p + 1;
+
+		switch (p[1]) {
+		case 'h': if (am_daemon) n = client_name(0); break;
+		case 'a': if (am_daemon) n = client_addr(0); break;
+		case 'l': 
+			snprintf(buf2,sizeof(buf2),"%.0f", 
+				 (double)file->length); 
+			n = buf2;
+			break;
+		case 'p': 
+			snprintf(buf2,sizeof(buf2),"%d", 
+				 (int)getpid()); 
+			n = buf2;
+			break;
+		case 'o': n = op; break;
+		case 'f': 
+			snprintf(buf2, sizeof(buf2), "%s/%s", 
+				 file->basedir?file->basedir:"", 
+				 f_name(file));
+			clean_fname(buf2);
+			n = buf2; 
+			if (*n == '/') n++;
+			break;
+		case 'm': n = lp_name(module_id); break;
+		case 't': n = timestring(time(NULL)); break;
+		case 'P': n = lp_path(module_id); break;
+		case 'u': n = auth_user; break;
+		case 'b': 
+			if (am_sender) {
+				b = stats.total_written - 
+					initial_stats->total_written;
+			} else {
+				b = stats.total_read - 
+					initial_stats->total_read;
+			}
+			snprintf(buf2,sizeof(buf2),"%.0f", (double)b); 
+			n = buf2;
+			break;
+		case 'c': 
+			if (!am_sender) {
+				b = stats.total_written - 
+					initial_stats->total_written;
+			} else {
+				b = stats.total_read - 
+					initial_stats->total_read;
+			}
+			snprintf(buf2,sizeof(buf2),"%.0f", (double)b); 
+			n = buf2;
+			break;
+		}
+
+		/* 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 + ((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;
+	}
+
+	rprintf(code,"%s\n", buf);
+}
+
+/* log the outgoing transfer of a file */
+void log_send(struct file_struct *file, struct stats *initial_stats)
+{
+	extern int module_id;
+	extern int am_server;
+	extern char *log_format;
+
+	if (lp_transfer_logging(module_id)) {
+		log_formatted(FLOG, lp_log_format(module_id), "send", file, initial_stats);
+	} else if (log_format && !am_server) {
+		log_formatted(FINFO, log_format, "send", file, initial_stats);
+	}
+}
+
+/* log the incoming transfer of a file */
+void log_recv(struct file_struct *file, struct stats *initial_stats)
+{
+	extern int module_id;
+	extern int am_server;
+	extern char *log_format;
+
+	if (lp_transfer_logging(module_id)) {
+		log_formatted(FLOG, lp_log_format(module_id), "recv", file, initial_stats);
+	} else if (log_format && !am_server) {
+		log_formatted(FINFO, log_format, "recv", file, initial_stats);
+	}
+}
+
+
+
+
+/*
+ * Called when the transfer is interrupted for some reason.
+ *
+ * Code is one of the RERR_* codes from errcode.h, or terminating
+ * successfully.
+ */
+void log_exit(int code, const char *file, int line)
+{
+	if (code == 0) {
+		extern struct stats stats;		
+		rprintf(FLOG,"wrote %.0f bytes  read %.0f bytes  total size %.0f\n",
+			(double)stats.total_written,
+			(double)stats.total_read,
+			(double)stats.total_size);
+	} else {
+                const char *name;
+
+                name = rerr_name(code);
+                if (!name)
+                        name = "unexplained error";
+                
+		rprintf(FERROR,"rsync error: %s (code %d) at %s(%d)\n", 
+			name, code, file, line);
+	}
+}
+
+/*
+ * Log the incoming transfer of a file for interactive use,
+ * this will be called at the end where the client was run.
+ * 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);
+}

match.c

@@ -29,18 +29,18 @@ extern int remote_version;
 typedef unsigned short tag;
 
 #define TABLESIZE (1<<16)
-#define NULL_TAG ((tag)-1)
+#define NULL_TAG (-1)
 
 static int false_alarms;
 static int tag_hits;
 static int matches;
-static int data_transfer;
+static int64 data_transfer;
 
 static int total_false_alarms;
 static int total_tag_hits;
 static int total_matches;
-static int64 total_data_transfer;
 
+extern struct stats stats;
 
 struct target {
   tag t;
@@ -49,7 +49,7 @@ struct target {
 
 static struct target *targets;
 
-static tag *tag_table;
+static int *tag_table;
 
 #define gettag2(s1,s2) (((s1) + (s2)) & 0xFFFF)
 #define gettag(sum) gettag2((sum)&0xFFFF,(sum)>>16)
@@ -65,13 +65,13 @@ static void build_hash_table(struct sum_struct *s)
   int i;
 
   if (!tag_table)
-    tag_table = (tag *)malloc(sizeof(tag)*TABLESIZE);
+    tag_table = new_array(int, TABLESIZE);
 
-  targets = (struct target *)malloc(sizeof(targets[0])*s->count);
+  targets = new_array(struct target, s->count);
   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);
   }
@@ -87,27 +87,38 @@ static void build_hash_table(struct sum_struct *s)
 }
 
 
-static off_t last_match;
+static OFF_T last_match;
 
 
+/**
+ * Transmit a literal and/or match token.
+ *
+ * This delightfully-named function is called either when we find a
+ * match and need to transmit all the unmatched data leading up to it,
+ * or when we get bored of accumulating literal data and just need to
+ * transmit it.  As a result of this second case, it is called even if
+ * we have not matched at all!
+ *
+ * @param i If >0, the number of a matched token.  If 0, indicates we
+ * have only literal data.
+ **/
 static void matched(int f,struct sum_struct *s,struct map_struct *buf,
-		    off_t offset,int i)
+		    OFF_T offset,int i)
 {
-	off_t n = offset - last_match;
-	int j;
+	OFF_T n = offset - last_match;
+	OFF_T j;
 
 	if (verbose > 2 && i >= 0)
-		fprintf(FINFO,"match at %d last_match=%d j=%d len=%d n=%d\n",
-			(int)offset,(int)last_match,i,(int)s->sums[i].len,(int)n);
+		rprintf(FINFO,"match at %.0f last_match=%.0f j=%d len=%d n=%.0f\n",
+			(double)offset,(double)last_match,i,s->sums[i].len,(double)n);
 
-	send_token(f,i,buf,last_match,n,i==-1?0:s->sums[i].len);
+	send_token(f,i,buf,last_match,n,i<0?0:s->sums[i].len);
 	data_transfer += n;
 
-	if (n > 0)
-		write_flush(f);
-
-	if (i >= 0)
+	if (i >= 0) {
+		stats.matched_data += s->sums[i].len;
 		n += s->sums[i].len;
+	}
   
 	for (j=0;j<n;j+=CHUNK_SIZE) {
 		int n1 = MIN(CHUNK_SIZE,n-j);
@@ -119,39 +130,51 @@ static void matched(int f,struct sum_struct *s,struct map_struct *buf,
 		last_match = offset + s->sums[i].len;
 	else
 		last_match = offset;
+
+	if (buf) {
+		show_progress(last_match, buf->file_size);
+
+		if (i == -1) end_progress(buf->file_size);
+	}
 }
 
 
 static void hash_search(int f,struct sum_struct *s,
-			struct map_struct *buf,off_t len)
+			struct map_struct *buf,OFF_T len)
 {
-	off_t offset;
-	int j,k;
-	int end;
+	OFF_T offset, end;
+	int j,k, last_i;
 	char sum2[SUM_LENGTH];
 	uint32 s1, s2, sum; 
-	signed char *map;
+	schar *map;
+
+	/* last_i is used to encourage adjacent matches, allowing the RLL coding of the
+	   output to work more efficiently */
+	last_i = -1;
 
 	if (verbose > 2)
-		fprintf(FINFO,"hash search b=%d len=%d\n",s->n,(int)len);
+		rprintf(FINFO,"hash search b=%ld len=%.0f\n",
+			(long) s->n, (double)len);
 
-	k = MIN(len, s->n);
+	/* cast is to make s->n signed; it should always be reasonably
+	 * small */
+	k = MIN(len, (OFF_T) s->n);
 	
-	map = (signed char *)map_ptr(buf,0,k);
+	map = (schar *)map_ptr(buf,0,k);
 	
 	sum = get_checksum1((char *)map, k);
 	s1 = sum & 0xFFFF;
 	s2 = sum >> 16;
 	if (verbose > 3)
-		fprintf(FINFO, "sum=%.8x k=%d\n", sum, k);
+		rprintf(FINFO, "sum=%.8x k=%d\n", sum, k);
 	
 	offset = 0;
 	
 	end = len + 1 - s->sums[s->count-1].len;
 	
 	if (verbose > 3)
-		fprintf(FINFO,"hash search s->n=%d len=%d count=%d\n",
-			s->n,(int)len,s->count);
+		rprintf(FINFO, "hash search s->n=%ld len=%.0f count=%ld\n",
+			(long) s->n, (double) len, (long) s->count);
 	
 	do {
 		tag t = gettag2(s1,s2);
@@ -159,7 +182,7 @@ static void hash_search(int f,struct sum_struct *s,
 			
 		j = tag_table[t];
 		if (verbose > 4)
-			fprintf(FINFO,"offset=%d sum=%08x\n",(int)offset,sum);
+			rprintf(FINFO,"offset=%.0f sum=%08x\n",(double)offset,sum);
 		
 		if (j == NULL_TAG) {
 			goto null_tag;
@@ -167,18 +190,21 @@ static void hash_search(int f,struct sum_struct *s,
 
 		sum = (s1 & 0xffff) | (s2 << 16);
 		tag_hits++;
-		for (; j<s->count && targets[j].t == t; j++) {
-			int i = targets[j].i;
+		for (; j < (int) s->count && targets[j].t == t; j++) {
+			int l, i = targets[j].i;
 			
 			if (sum != s->sums[i].sum1) continue;
 			
+			/* also make sure the two blocks are the same length */
+			l = MIN(s->n,len-offset);
+			if (l != s->sums[i].len) continue;			
+
 			if (verbose > 3)
-				fprintf(FINFO,"potential match at %d target=%d %d sum=%08x\n",
-					(int)offset,j,i,sum);
+				rprintf(FINFO,"potential match at %.0f target=%d %d sum=%08x\n",
+					(double)offset,j,i,sum);
 			
 			if (!done_csum2) {
-				int l = MIN(s->n,len-offset);
-				map = (signed char *)map_ptr(buf,offset,l);
+				map = (schar *)map_ptr(buf,offset,l);
 				get_checksum2((char *)map,l,sum2);
 				done_csum2 = 1;
 			}
@@ -187,11 +213,27 @@ static void hash_search(int f,struct sum_struct *s,
 				false_alarms++;
 				continue;
 			}
+
+			/* we've found a match, but now check to see
+                           if last_i can hint at a better match */
+			for (j++; j < (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;
+					if (memcmp(sum2,s->sums[i2].sum2,csum_length) != 0) break;
+					/* we've found an adjacent match - the RLL coder 
+					   will be happy */
+					i = i2;
+					break;
+				}
+			}
+
+			last_i = i;
 			
 			matched(f,s,buf,offset,i);
 			offset += s->sums[i].len - 1;
 			k = MIN((len-offset), s->n);
-			map = (signed char *)map_ptr(buf,offset,k);
+			map = (schar *)map_ptr(buf,offset,k);
 			sum = get_checksum1((char *)map, k);
 			s1 = sum & 0xFFFF;
 			s2 = sum >> 16;
@@ -201,7 +243,7 @@ static void hash_search(int f,struct sum_struct *s,
 		
 	null_tag:
 		/* Trim off the first byte from the checksum */
-		map = (signed char *)map_ptr(buf,offset,k+1);
+		map = (schar *)map_ptr(buf,offset,k+1);
 		s1 -= map[0] + CHAR_OFFSET;
 		s2 -= k * (map[0]+CHAR_OFFSET);
 		
@@ -212,7 +254,18 @@ static void hash_search(int f,struct sum_struct *s,
 		} else {
 			--k;
 		}
-		
+
+		/* By matching early we avoid re-reading the
+		   data 3 times in the case where a token
+		   match comes a long way after last
+		   match. The 3 reads are caused by the
+		   running match, the checksum update and the
+		   literal send. */
+		if (offset > last_match &&
+		    offset-last_match >= CHUNK_SIZE+s->n && 
+		    (end-offset > CHUNK_SIZE)) {
+			matched(f,s,buf,offset - s->n, -2);
+		}
 	} while (++offset < end);
 	
 	matched(f,s,buf,len,-1);
@@ -220,9 +273,24 @@ static void hash_search(int f,struct sum_struct *s,
 }
 
 
-void match_sums(int f,struct sum_struct *s,struct map_struct *buf,off_t len)
+/**
+ * Scan through a origin file, looking for sections that match
+ * checksums from the generator, and transmit either literal or token
+ * data.
+ *
+ * Also calculates the MD4 checksum of the whole file, using the md
+ * accumulator.  This is transmitted with the file as protection
+ * against corruption on the wire.
+ *
+ * @param s Checksums received from the generator.  If <tt>s->count ==
+ * 0</tt>, then there are actually no checksums for this file.
+ *
+ * @param len Length of the file to send.
+ **/
+void match_sums(int f, struct sum_struct *s, struct map_struct *buf, OFF_T len)
 {
 	char file_sum[MD4_SUM_LENGTH];
+	extern int write_batch;  /*  dw */
 
 	last_match = 0;
 	false_alarms = 0;
@@ -236,13 +304,19 @@ void match_sums(int f,struct sum_struct *s,struct map_struct *buf,off_t len)
 		build_hash_table(s);
 		
 		if (verbose > 2) 
-			fprintf(FINFO,"built hash table\n");
+			rprintf(FINFO,"built hash table\n");
 		
 		hash_search(f,s,buf,len);
 		
 		if (verbose > 2) 
-			fprintf(FINFO,"done hash search\n");
+			rprintf(FINFO,"done hash search\n");
 	} else {
+		OFF_T j;
+		/* by doing this in pieces we avoid too many seeks */
+		for (j=0;j<(len-CHUNK_SIZE);j+=CHUNK_SIZE) {
+			int n1 = MIN(CHUNK_SIZE,(len-CHUNK_SIZE)-j);
+			matched(f,s,buf,j+n1,-2);
+		}
 		matched(f,s,buf,len,-1);
 	}
 
@@ -250,8 +324,10 @@ void match_sums(int f,struct sum_struct *s,struct map_struct *buf,off_t len)
 
 	if (remote_version >= 14) {
 		if (verbose > 2)
-			fprintf(FINFO,"sending file_sum\n");
+			rprintf(FINFO,"sending file_sum\n");
 		write_buf(f,file_sum,MD4_SUM_LENGTH);
+		if (write_batch) /* dw */
+		    write_batch_delta_file(file_sum, MD4_SUM_LENGTH);
 	}
 
 	if (targets) {
@@ -260,13 +336,13 @@ void match_sums(int f,struct sum_struct *s,struct map_struct *buf,off_t len)
 	}
 	
 	if (verbose > 2)
-		fprintf(FINFO, "false_alarms=%d tag_hits=%d matches=%d\n",
+		rprintf(FINFO, "false_alarms=%d tag_hits=%d matches=%d\n",
 			false_alarms, tag_hits, matches);
 	
 	total_tag_hits += tag_hits;
 	total_false_alarms += false_alarms;
 	total_matches += matches;
-	total_data_transfer += data_transfer;
+	stats.literal_data += data_transfer;
 }
 
 void match_report(void)
@@ -274,8 +350,9 @@ void match_report(void)
 	if (verbose <= 1)
 		return;
 
-	fprintf(FINFO,
-		"total: matches=%d  tag_hits=%d  false_alarms=%d  data=%ld\n",
+	rprintf(FINFO,
+		"total: matches=%d  tag_hits=%d  false_alarms=%d data=%.0f\n",
 		total_matches,total_tag_hits,
-		total_false_alarms,(long)total_data_transfer);
+		total_false_alarms,
+		(double)stats.literal_data);
 }

md4.c

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

md4.h

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

mkproto.awk

@@ -19,11 +19,46 @@ BEGIN {
   }
 }
 
+/^FN_LOCAL_BOOL/ {
+  split($0,a,"[,()]")
+  printf "BOOL %s(int );\n", a[2]
+}
+
+/^FN_LOCAL_STRING/ {
+  split($0,a,"[,()]")
+  printf "char *%s(int );\n", a[2]
+}
+
+/^FN_LOCAL_INT/ {
+  split($0,a,"[,()]")
+  printf "int %s(int );\n", a[2]
+}
+
+/^FN_LOCAL_CHAR/ {
+  split($0,a,"[,()]")
+  printf "char %s(int );\n", a[2]
+}
+
+/^FN_GLOBAL_BOOL/ {
+  split($0,a,"[,()]")
+  printf "BOOL %s(void);\n", a[2]
+}
+
+/^FN_GLOBAL_STRING/ {
+  split($0,a,"[,()]")
+  printf "char *%s(void);\n", a[2]
+}
+
+/^FN_GLOBAL_INT/ {
+  split($0,a,"[,()]")
+  printf "int %s(void);\n", a[2]
+}
+
 /^static|^extern/ || !/^[a-zA-Z]/ || /[;]/ {
   next;
 }
 
-!/^off_t|^pid_t|^unsigned|^mode_t|^DIR|^user|^int|^char|^uint|^struct|^BOOL|^void|^time/ {
+!/^OFF_T|^size_t|^off_t|^pid_t|^unsigned|^mode_t|^DIR|^user|^int|^char|^uint|^struct|^BOOL|^void|^time/ {
   next;
 }
 

options.c

@@ -0,0 +1,924 @@
+/*  -*- c-file-style: "linux" -*-
+ *
+ * Copyright (C) 1998-2001 by Andrew Tridgell <tridge@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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "rsync.h"
+#include "popt.h"
+
+extern struct exclude_struct **exclude_list;
+
+int make_backups = 0;
+
+/**
+ * If 1, send the whole file as literal data rather than trying to
+ * create an incremental diff.
+ *
+ * If -1, then look at whether we're local or remote and go by that.
+ *
+ * @sa disable_deltas_p()
+ **/
+int whole_file = -1;
+
+int archive_mode = 0;
+int copy_links = 0;
+int preserve_links = 0;
+int preserve_hard_links = 0;
+int preserve_perms = 0;
+int preserve_devices = 0;
+int preserve_uid = 0;
+int preserve_gid = 0;
+int preserve_times = 0;
+int update_only = 0;
+int cvs_exclude = 0;
+int dry_run=0;
+int local_server=0;
+int ignore_times=0;
+int delete_mode=0;
+int delete_excluded=0;
+int one_file_system=0;
+int protocol_version = PROTOCOL_VERSION;
+int sparse_files=0;
+int do_compression=0;
+int am_root=0;
+int orig_umask=0;
+int relative_paths = -1;
+int implied_dirs = 1;
+int numeric_ids = 0;
+int force_delete = 0;
+int io_timeout = 0;
+int io_error = 0;
+int read_only = 0;
+int module_id = -1;
+int am_server = 0;
+int am_sender = 0;
+char *files_from = NULL;
+int filesfrom_fd = -1;
+char *remote_filesfrom_file = NULL;
+int eol_nulls = 0;
+int recurse = 0;
+int am_daemon = 0;
+int daemon_over_rsh = 0;
+int do_stats=0;
+int do_progress=0;
+int keep_partial=0;
+int safe_symlinks=0;
+int copy_unsafe_links=0;
+int block_size=0;
+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;
+int modify_window=0;
+int blocking_io=-1;
+
+
+/** Network address family. **/
+#ifdef INET6
+int default_af_hint = 0;	/* Any protocol */
+#else
+int default_af_hint = AF_INET;	/* Must use IPv4 */
+#endif
+
+/** 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;
+int backup_dir_len = 0;
+int backup_suffix_len;
+
+char *backup_suffix = NULL;
+char *tmpdir = NULL;
+char *compare_dest = NULL;
+char *config_file = NULL;
+char *shell_cmd = NULL;
+char *log_format = NULL;
+char *password_file = NULL;
+char *rsync_path = RSYNC_PATH;
+char *backup_dir = NULL;
+int rsync_port = RSYNC_PORT;
+int link_dest = 0;
+
+int verbose = 0;
+int quiet = 0;
+int always_checksum = 0;
+int list_only = 0;
+
+char *batch_prefix = NULL;
+
+static int modify_window_set;
+
+/** Local address to bind.  As a character string because it's
+ * interpreted by the IPv6 layer: should be a numeric IP4 or ip6
+ * address, or a hostname. **/
+char *bind_address;
+
+
+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 = "";
+#endif
+
+#if SUPPORT_HARD_LINKS
+	hardlinks = "";
+#endif
+
+#if SUPPORT_LINKS
+	links = "";
+#endif
+
+#if INET6
+	ipv6 = "";
+#endif
+
+	rprintf(f, "%s  version %s  protocol version %d\n",
+		RSYNC_NAME, RSYNC_VERSION, PROTOCOL_VERSION);
+	rprintf(f,
+		"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, \n",
+		(int) (sizeof(OFF_T) * 8),
+		got_socketpair, hardlinks, links);
+
+	/* Note that this field may not have type ino_t.  It depends
+	 * on the complicated interaction between largefile feature
+	 * macros. */
+	rprintf(f, "              %sIPv6, %d-bit system inums, %d-bit internal inums\n",
+		ipv6,
+		(int) (sizeof(dumstat->st_ino) * 8),
+		(int) (sizeof(INO64_T) * 8));
+#ifdef MAINTAINER_MODE
+	rprintf(f, "              panic action: \"%s\"\n",
+		get_panic_action());
+#endif
+
+#ifdef NO_INT64
+	rprintf(f, "WARNING: no 64-bit integers on this platform!\n");
+#endif
+
+	rprintf(f,
+"\n"
+"rsync comes with ABSOLUTELY NO WARRANTY.  This is free software, and you\n"
+"are welcome to redistribute it under certain conditions.  See the GNU\n"
+"General Public Licence for details.\n"
+		);
+}
+
+
+void usage(enum logcode F)
+{
+  print_rsync_version(F);
+
+  rprintf(F,"\nrsync is a file transfer program capable of efficient remote update\nvia a fast differencing algorithm.\n\n");
+
+  rprintf(F,"Usage: rsync [OPTION]... SRC [SRC]... [USER@]HOST:DEST\n");
+  rprintf(F,"  or   rsync [OPTION]... [USER@]HOST:SRC DEST\n");
+  rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... DEST\n");
+  rprintf(F,"  or   rsync [OPTION]... [USER@]HOST::SRC [DEST]\n");
+  rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... [USER@]HOST::DEST\n");
+  rprintf(F,"  or   rsync [OPTION]... rsync://[USER@]HOST[:PORT]/SRC [DEST]\n");
+  rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... rsync://[USER@]HOST[:PORT]/DEST\n");
+  rprintf(F,"SRC on single-colon remote HOST will be expanded by remote shell\n");
+  rprintf(F,"SRC on server remote HOST may contain shell wildcards or multiple\n");
+  rprintf(F,"  sources separated by space as long as they have same top-level\n");
+  rprintf(F,"\nOptions\n");
+  rprintf(F," -v, --verbose               increase verbosity\n");
+  rprintf(F," -q, --quiet                 decrease verbosity\n");
+  rprintf(F," -c, --checksum              always checksum\n");
+  rprintf(F," -a, --archive               archive mode, equivalent to -rlptgoD\n");
+  rprintf(F," -r, --recursive             recurse into directories\n");
+  rprintf(F," -R, --relative              use relative path names\n");
+  rprintf(F,"     --no-relative           turn off --relative\n");
+  rprintf(F,"     --no-implied-dirs       don't send implied dirs with -R\n");
+  rprintf(F," -b, --backup                make backups (default %s suffix)\n",BACKUP_SUFFIX);
+  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                 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");
+  rprintf(F," -p, --perms                 preserve permissions\n");
+  rprintf(F," -o, --owner                 preserve owner (root only)\n");
+  rprintf(F," -g, --group                 preserve group\n");
+  rprintf(F," -D, --devices               preserve devices (root only)\n");
+  rprintf(F," -t, --times                 preserve times\n");
+  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 the remote shell\n");
+  rprintf(F,"     --rsync-path=PATH       specify path to rsync on the remote machine\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");
+  rprintf(F,"     --ignore-errors         delete even if there are IO errors\n");
+  rprintf(F,"     --max-delete=NUM        don't delete more than NUM files\n");
+  rprintf(F,"     --partial               keep partially transferred files\n");
+  rprintf(F,"     --force                 force deletion of directories even if not empty\n");
+  rprintf(F,"     --numeric-ids           don't map uid/gid values by user/group name\n");
+  rprintf(F,"     --timeout=TIME          set IO timeout in seconds\n");
+  rprintf(F," -I, --ignore-times          don't exclude files that match length and time\n");
+  rprintf(F,"     --size-only             only use file size when determining if a file should be transferred\n");
+  rprintf(F,"     --modify-window=NUM     Timestamp window (seconds) for file match (default=%d)\n",modify_window);
+  rprintf(F," -T  --temp-dir=DIR          create temporary files in directory DIR\n");
+  rprintf(F,"     --compare-dest=DIR      also compare destination files relative to DIR\n");
+  rprintf(F,"     --link-dest=DIR         create hardlinks to DIR for unchanged files\n");
+  rprintf(F," -P                          equivalent to --partial --progress\n");
+  rprintf(F," -z, --compress              compress file data\n");
+  rprintf(F," -C, --cvs-exclude           auto ignore files in the same way CVS does\n");
+  rprintf(F,"     --exclude=PATTERN       exclude files matching PATTERN\n");
+  rprintf(F,"     --exclude-from=FILE     exclude patterns listed in FILE\n");
+  rprintf(F,"     --include=PATTERN       don't exclude files matching PATTERN\n");
+  rprintf(F,"     --include-from=FILE     don't exclude patterns listed in FILE\n");
+  rprintf(F,"     --files-from=FILE       read FILE for list of source-file names\n");
+  rprintf(F," -0  --from0                 file names we read are separated by nulls, not newlines\n");
+  rprintf(F,"     --version               print version number\n");
+  rprintf(F,"     --daemon                run as a rsync daemon\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,"     --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");
+  rprintf(F," -6                          prefer IPv6\n");
+#endif
+
+  rprintf(F,"\n");
+
+  rprintf(F,"\nPlease see the rsync(1) and rsyncd.conf(5) man pages for full documentation\n");
+  rprintf(F,"See http://rsync.samba.org/ for updates, bug reports, and answers\n");
+}
+
+enum {OPT_VERSION = 1000, OPT_SENDER, OPT_EXCLUDE, OPT_EXCLUDE_FROM,
+      OPT_DELETE_AFTER, OPT_DELETE_EXCLUDED, OPT_LINK_DEST,
+      OPT_INCLUDE, OPT_INCLUDE_FROM, OPT_MODIFY_WINDOW,
+      OPT_READ_BATCH, OPT_WRITE_BATCH};
+
+static struct poptOption long_options[] = {
+  /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
+  {"version",          0,  POPT_ARG_NONE,   0,              OPT_VERSION, 0, 0},
+  {"suffix",           0,  POPT_ARG_STRING, &backup_suffix, 0, 0, 0 },
+  {"rsync-path",       0,  POPT_ARG_STRING, &rsync_path,	0, 0, 0 },
+  {"password-file",    0,  POPT_ARG_STRING, &password_file,	0, 0, 0 },
+  {"ignore-times",    'I', POPT_ARG_NONE,   &ignore_times, 0, 0, 0 },
+  {"size-only",        0,  POPT_ARG_NONE,   &size_only, 0, 0, 0 },
+  {"modify-window",    0,  POPT_ARG_INT,    &modify_window, OPT_MODIFY_WINDOW, 0, 0 },
+  {"one-file-system", 'x', POPT_ARG_NONE,   &one_file_system, 0, 0, 0 },
+  {"delete",           0,  POPT_ARG_NONE,   &delete_mode, 0, 0, 0 },
+  {"existing",         0,  POPT_ARG_NONE,   &only_existing, 0, 0, 0 },
+  {"ignore-existing",  0,  POPT_ARG_NONE,   &opt_ignore_existing, 0, 0, 0 },
+  {"delete-after",     0,  POPT_ARG_NONE,   0,              OPT_DELETE_AFTER, 0, 0 },
+  {"delete-excluded",  0,  POPT_ARG_NONE,   0,              OPT_DELETE_EXCLUDED, 0, 0 },
+  {"force",            0,  POPT_ARG_NONE,   &force_delete, 0, 0, 0 },
+  {"numeric-ids",      0,  POPT_ARG_NONE,   &numeric_ids, 0, 0, 0 },
+  {"exclude",          0,  POPT_ARG_STRING, 0,              OPT_EXCLUDE, 0, 0 },
+  {"include",          0,  POPT_ARG_STRING, 0,              OPT_INCLUDE, 0, 0 },
+  {"exclude-from",     0,  POPT_ARG_STRING, 0,              OPT_EXCLUDE_FROM, 0, 0 },
+  {"include-from",     0,  POPT_ARG_STRING, 0,              OPT_INCLUDE_FROM, 0, 0 },
+  {"safe-links",       0,  POPT_ARG_NONE,   &safe_symlinks, 0, 0, 0 },
+  {"help",            'h', POPT_ARG_NONE,   0,              'h', 0, 0 },
+  {"backup",          'b', POPT_ARG_NONE,   &make_backups, 0, 0, 0 },
+  {"dry-run",         'n', POPT_ARG_NONE,   &dry_run, 0, 0, 0 },
+  {"sparse",          'S', POPT_ARG_NONE,   &sparse_files, 0, 0, 0 },
+  {"cvs-exclude",     'C', POPT_ARG_NONE,   &cvs_exclude, 0, 0, 0 },
+  {"update",          'u', POPT_ARG_NONE,   &update_only, 0, 0, 0 },
+  {"links",           'l', POPT_ARG_NONE,   &preserve_links, 0, 0, 0 },
+  {"copy-links",      'L', POPT_ARG_NONE,   &copy_links, 0, 0, 0 },
+  {"whole-file",      'W', POPT_ARG_VAL,    &whole_file, 1, 0, 0 },
+  {"no-whole-file",    0,  POPT_ARG_VAL,    &whole_file, 0, 0, 0 },
+  {"copy-unsafe-links", 0, POPT_ARG_NONE,   &copy_unsafe_links, 0, 0, 0 },
+  {"perms",           'p', POPT_ARG_NONE,   &preserve_perms, 0, 0, 0 },
+  {"owner",           'o', POPT_ARG_NONE,   &preserve_uid, 0, 0, 0 },
+  {"group",           'g', POPT_ARG_NONE,   &preserve_gid, 0, 0, 0 },
+  {"devices",         'D', POPT_ARG_NONE,   &preserve_devices, 0, 0, 0 },
+  {"times",           't', POPT_ARG_NONE,   &preserve_times, 0, 0, 0 },
+  {"checksum",        'c', POPT_ARG_NONE,   &always_checksum, 0, 0, 0 },
+  {"verbose",         'v', POPT_ARG_NONE,   0,               'v', 0, 0 },
+  {"quiet",           'q', POPT_ARG_NONE,   0,               'q', 0, 0 },
+  {"archive",         'a', POPT_ARG_NONE,   &archive_mode, 0, 0, 0 },
+  {"server",           0,  POPT_ARG_NONE,   &am_server, 0, 0, 0 },
+  {"sender",           0,  POPT_ARG_NONE,   0,              OPT_SENDER, 0, 0 },
+  {"recursive",       'r', POPT_ARG_NONE,   &recurse, 0, 0, 0 },
+  {"relative",        'R', POPT_ARG_VAL,    &relative_paths, 1, 0, 0 },
+  {"no-relative",      0,  POPT_ARG_VAL,    &relative_paths, 0, 0, 0 },
+  {"rsh",             'e', POPT_ARG_STRING, &shell_cmd, 0, 0, 0 },
+  {"block-size",      'B', POPT_ARG_INT,    &block_size, 0, 0, 0 },
+  {"max-delete",       0,  POPT_ARG_INT,    &max_delete, 0, 0, 0 },
+  {"timeout",          0,  POPT_ARG_INT,    &io_timeout, 0, 0, 0 },
+  {"temp-dir",        'T', POPT_ARG_STRING, &tmpdir, 0, 0, 0 },
+  {"compare-dest",     0,  POPT_ARG_STRING, &compare_dest, 0, 0, 0 },
+  {"link-dest",        0,  POPT_ARG_STRING, 0,              OPT_LINK_DEST, 0, 0 },
+  /* TODO: Should this take an optional int giving the compression level? */
+  {"compress",        'z', POPT_ARG_NONE,   &do_compression, 0, 0, 0 },
+  {"daemon",           0,  POPT_ARG_NONE,   &am_daemon, 0, 0, 0 },
+  {"no-detach",        0,  POPT_ARG_NONE,   &no_detach, 0, 0, 0 },
+  {"stats",            0,  POPT_ARG_NONE,   &do_stats, 0, 0, 0 },
+  {"progress",         0,  POPT_ARG_NONE,   &do_progress, 0, 0, 0 },
+  {"partial",          0,  POPT_ARG_NONE,   &keep_partial, 0, 0, 0 },
+  {"ignore-errors",    0,  POPT_ARG_NONE,   &ignore_errors, 0, 0, 0 },
+  {"blocking-io",      0,  POPT_ARG_VAL,    &blocking_io, 1, 0, 0 },
+  {"no-blocking-io",   0,  POPT_ARG_VAL,    &blocking_io, 0, 0, 0 },
+  {0,                 'P', POPT_ARG_NONE,   0,              'P', 0, 0 },
+  {"config",           0,  POPT_ARG_STRING, &config_file, 0, 0, 0 },
+  {"port",             0,  POPT_ARG_INT,    &rsync_port, 0, 0, 0 },
+  {"log-format",       0,  POPT_ARG_STRING, &log_format, 0, 0, 0 },
+  {"bwlimit",          0,  POPT_ARG_INT,    &bwlimit, 0, 0, 0 },
+  {"address",          0,  POPT_ARG_STRING, &bind_address, 0, 0, 0 },
+  {"backup-dir",       0,  POPT_ARG_STRING, &backup_dir, 0, 0, 0 },
+  {"hard-links",      'H', POPT_ARG_NONE,   &preserve_hard_links, 0, 0, 0 },
+  {"read-batch",       0,  POPT_ARG_STRING, &batch_prefix,  OPT_READ_BATCH, 0, 0 },
+  {"write-batch",      0,  POPT_ARG_STRING, &batch_prefix,  OPT_WRITE_BATCH, 0, 0 },
+  {"files-from",       0,  POPT_ARG_STRING, &files_from, 0, 0, 0 },
+  {"from0",           '0', POPT_ARG_NONE,   &eol_nulls, 0, 0, 0},
+  {"no-implied-dirs",  0,  POPT_ARG_VAL,    &implied_dirs, 0, 0, 0 },
+  {"protocol",         0,  POPT_ARG_INT,    &protocol_version, 0, 0, 0 },
+#ifdef INET6
+  {0,		      '4', POPT_ARG_VAL,    &default_af_hint, AF_INET, 0, 0 },
+  {0,		      '6', POPT_ARG_VAL,    &default_af_hint, AF_INET6, 0, 0 },
+#endif
+  {0,0,0,0, 0, 0, 0}
+};
+
+
+static char err_buf[100];
+
+
+/**
+ * Store the option error message, if any, so that we can log the
+ * connection attempt (which requires parsing the options), and then
+ * show the error later on.
+ **/
+void option_error(void)
+{
+	if (err_buf[0]) {
+		rprintf(FLOG, "%s", err_buf);
+		rprintf(FERROR, RSYNC_NAME ": %s", err_buf);
+	} else {
+		rprintf (FERROR, "Error parsing options: "
+			 "option may be supported on client but not on server?\n");
+		rprintf (FERROR, RSYNC_NAME ": Error parsing options: "
+			 "option may be supported on client but not on server?\n");
+	}
+}
+
+
+/**
+ * Check to see if we should refuse this option
+ **/
+static int check_refuse_options(char *ref, int opt)
+{
+	int i, len;
+	char *p;
+	const char *name;
+
+	for (i=0; long_options[i].longName; i++) {
+		if (long_options[i].val == opt) break;
+	}
+
+	if (!long_options[i].longName) return 0;
+
+	name = long_options[i].longName;
+	len = strlen(name);
+
+	while ((p = strstr(ref,name))) {
+		if ((p==ref || p[-1]==' ') &&
+		    (p[len] == ' ' || p[len] == 0)) {
+			snprintf(err_buf,sizeof(err_buf),
+				 "The '%s' option is not supported by this server\n", name);
+			return 1;
+		}
+		ref += len;
+	}
+	return 0;
+}
+
+
+static int count_args(char const **argv)
+{
+	int i = 0;
+
+	while (argv[i] != NULL)
+		i++;
+
+	return i;
+}
+
+
+/**
+ * Process command line arguments.  Called on both local and remote.
+ *
+ * @retval 1 if all options are OK; with globals set to appropriate
+ * values
+ *
+ * @retval 0 on error, with err_buf containing an explanation
+ **/
+int parse_arguments(int *argc, const char ***argv, int frommain)
+{
+	int opt;
+	char *ref = lp_refuse_options(module_id);
+	poptContext pc;
+
+	/* TODO: Call poptReadDefaultConfig; handle errors. */
+
+	/* The context leaks in case of an error, but if there's a
+	 * problem we always exit anyhow. */
+	pc = poptGetContext(RSYNC_NAME, *argc, *argv, long_options, 0);
+
+	while ((opt = poptGetNextOpt(pc)) != -1) {
+		if (ref) {
+			if (check_refuse_options(ref, opt)) return 0;
+		}
+
+		/* most options are handled automatically by popt;
+		 * only special cases are returned and listed here. */
+
+		switch (opt) {
+		case OPT_VERSION:
+			print_rsync_version(FINFO);
+			exit_cleanup(0);
+
+		case OPT_MODIFY_WINDOW:
+			/* The value has already been set by popt, but
+			 * we need to remember that we're using a
+			 * non-default setting. */
+			modify_window_set = 1;
+			break;
+
+		case OPT_DELETE_AFTER:
+			delete_after = 1;
+			delete_mode = 1;
+			break;
+
+		case OPT_DELETE_EXCLUDED:
+			delete_excluded = 1;
+			delete_mode = 1;
+			break;
+
+		case OPT_EXCLUDE:
+			add_exclude(&exclude_list, poptGetOptArg(pc),
+				    ADD_EXCLUDE);
+			break;
+
+		case OPT_INCLUDE:
+			add_exclude(&exclude_list, poptGetOptArg(pc),
+				    ADD_INCLUDE);
+			break;
+
+		case OPT_EXCLUDE_FROM:
+			add_exclude_file(&exclude_list, poptGetOptArg(pc),
+					 MISSING_FATAL, ADD_EXCLUDE);
+			break;
+
+		case OPT_INCLUDE_FROM:
+			add_exclude_file(&exclude_list, poptGetOptArg(pc),
+					 MISSING_FATAL, ADD_INCLUDE);
+			break;
+
+		case 'h':
+			usage(FINFO);
+			exit_cleanup(0);
+
+		case 'H':
+#if SUPPORT_HARD_LINKS
+			preserve_hard_links=1;
+#else
+			/* FIXME: Don't say "server" if this is
+			 * happening on the client. */
+			/* FIXME: Why do we have the duplicated
+			 * rprintf?  Everybody who gets this message
+			 * ought to send it to the client and also to
+			 * the logs. */
+			snprintf(err_buf, sizeof err_buf,
+				 "hard links are not supported on this %s\n",
+				 am_server ? "server" : "client");
+			rprintf(FERROR, "ERROR: %s", err_buf);
+			return 0;
+#endif /* SUPPORT_HARD_LINKS */
+			break;
+
+		case 'v':
+			verbose++;
+			break;
+
+		case 'q':
+			if (frommain) quiet++;
+			break;
+
+		case OPT_SENDER:
+			if (!am_server) {
+				usage(FERROR);
+				exit_cleanup(RERR_SYNTAX);
+			}
+			am_sender = 1;
+			break;
+
+		case 'P':
+			do_progress = 1;
+			keep_partial = 1;
+			break;
+
+		case OPT_WRITE_BATCH:
+			/* popt stores the filename in batch_prefix for us */
+			write_batch = 1;
+			break;
+
+		case OPT_READ_BATCH:
+			/* popt stores the filename in batch_prefix for us */
+			read_batch = 1;
+			break;
+
+		case OPT_LINK_DEST:
+#if HAVE_LINK
+			compare_dest = (char *)poptGetOptArg(pc);
+			link_dest = 1;
+			break;
+#else
+			snprintf(err_buf, sizeof err_buf,
+				 "hard links are not supported on this %s\n",
+				 am_server ? "server" : "client");
+			rprintf(FERROR, "ERROR: %s", err_buf);
+			return 0;
+#endif
+
+
+		default:
+			/* FIXME: If --daemon is specified, then errors for later
+			 * parameters seem to disappear. */
+			snprintf(err_buf, sizeof(err_buf),
+				 "%s%s: %s\n",
+				 am_server ? "on remote machine: " : "",
+				 poptBadOption(pc, POPT_BADOPTION_NOALIAS),
+				 poptStrerror(opt));
+			return 0;
+		}
+	}
+
+	if (write_batch && read_batch) {
+		rprintf(FERROR,
+			"write-batch and read-batch can not be used together\n");
+		exit_cleanup(RERR_SYNTAX);
+	}
+
+	if (do_compression && (write_batch || read_batch)) {
+		rprintf(FERROR,
+			"compress can not be used with write-batch or read-batch\n");
+		exit_cleanup(RERR_SYNTAX);
+	}
+
+	if (archive_mode) {
+		if (!files_from)
+			recurse = 1;
+#if SUPPORT_LINKS
+		preserve_links = 1;
+#endif
+		preserve_perms = 1;
+		preserve_times = 1;
+		preserve_gid = 1;
+		preserve_uid = 1;
+		preserve_devices = 1;
+	}
+
+	if (relative_paths < 0)
+		relative_paths = files_from? 1 : 0;
+
+	if (!backup_suffix)
+		backup_suffix = backup_dir? "" : BACKUP_SUFFIX;
+	backup_suffix_len = strlen(backup_suffix);
+	if (strchr(backup_suffix, '/') != NULL) {
+		rprintf(FERROR, "--suffix cannot contain slashes: %s\n",
+			backup_suffix);
+		exit_cleanup(RERR_SYNTAX);
+	}
+	if (backup_dir)
+		backup_dir_len = strlen(backup_dir);
+	else if (!backup_suffix_len) {
+		rprintf(FERROR,
+			"--suffix cannot be a null string without --backup-dir\n");
+		exit_cleanup(RERR_SYNTAX);
+	}
+
+	if (do_progress && !verbose)
+		verbose = 1;
+
+	*argv = poptGetArgs(pc);
+	if (*argv)
+		*argc = count_args(*argv);
+	else
+		*argc = 0;
+
+	if (files_from) {
+		char *colon;
+		if (*argc != 2) {
+			usage(FERROR);
+			exit_cleanup(RERR_SYNTAX);
+		}
+		if (strcmp(files_from, "-") == 0)
+			filesfrom_fd = 0;
+		else if ((colon = find_colon(files_from)) != 0) {
+			if (am_server) {
+				usage(FERROR);
+				exit_cleanup(RERR_SYNTAX);
+			}
+			remote_filesfrom_file = colon+1 + (colon[1] == ':');
+			if (strcmp(remote_filesfrom_file, "-") == 0) {
+				rprintf(FERROR, "Invalid --files-from remote filename\n");
+				exit_cleanup(RERR_SYNTAX);
+			}
+		} else {
+			extern int sanitize_paths;
+			if (sanitize_paths)
+				sanitize_path(strdup(files_from), NULL);
+			filesfrom_fd = open(files_from, O_RDONLY|O_BINARY);
+			if (filesfrom_fd < 0) {
+				rsyserr(FERROR, errno,
+					"failed to open files-from file %s",
+					files_from);
+				exit_cleanup(RERR_FILEIO);
+			}
+		}
+	}
+
+	return 1;
+}
+
+
+/**
+ * Construct a filtered list of options to pass through from the
+ * client to the server.
+ *
+ * This involves setting options that will tell the server how to
+ * behave, and also filtering out options that are processed only
+ * locally.
+ **/
+void server_options(char **args,int *argc)
+{
+	int ac = *argc;
+	static char argstr[50];
+	static char bsize[30];
+	static char iotime[30];
+	static char mdelete[30];
+	static char mwindow[30];
+	static char bw[50];
+	/* Leave room for ``--(write|read)-batch='' */
+	static char fext[MAXPATHLEN + 15];
+
+	int i, x;
+
+	if (blocking_io == -1)
+		blocking_io = 0;
+
+	args[ac++] = "--server";
+
+	if (daemon_over_rsh) {
+		args[ac++] = "--daemon";
+		*argc = ac;
+		/* if we're passing --daemon, we're done */
+		return;
+	}
+
+	if (!am_sender)
+		args[ac++] = "--sender";
+
+	x = 1;
+	argstr[0] = '-';
+	for (i=0;i<verbose;i++)
+		argstr[x++] = 'v';
+
+	/* the -q option is intentionally left out */
+	if (make_backups)
+		argstr[x++] = 'b';
+	if (update_only)
+		argstr[x++] = 'u';
+	if (dry_run)
+		argstr[x++] = 'n';
+	if (preserve_links)
+		argstr[x++] = 'l';
+	if (copy_links)
+		argstr[x++] = 'L';
+
+	if (whole_file > 0)
+		argstr[x++] = 'W';
+	/* We don't need to send --no-whole-file, because it's the
+	 * default for remote transfers, and in any case old versions
+	 * of rsync will not understand it. */
+
+	if (preserve_hard_links)
+		argstr[x++] = 'H';
+	if (preserve_uid)
+		argstr[x++] = 'o';
+	if (preserve_gid)
+		argstr[x++] = 'g';
+	if (preserve_devices)
+		argstr[x++] = 'D';
+	if (preserve_times)
+		argstr[x++] = 't';
+	if (preserve_perms)
+		argstr[x++] = 'p';
+	if (recurse)
+		argstr[x++] = 'r';
+	if (always_checksum)
+		argstr[x++] = 'c';
+	if (cvs_exclude)
+		argstr[x++] = 'C';
+	if (ignore_times)
+		argstr[x++] = 'I';
+	if (relative_paths)
+		argstr[x++] = 'R';
+	if (one_file_system)
+		argstr[x++] = 'x';
+	if (sparse_files)
+		argstr[x++] = 'S';
+	if (do_compression)
+		argstr[x++] = 'z';
+
+	/* this is a complete hack - blame Rusty
+
+	   this is a hack to make the list_only (remote file list)
+	   more useful */
+	if (list_only && !recurse)
+		argstr[x++] = 'r';
+
+	argstr[x] = 0;
+
+	if (x != 1) args[ac++] = argstr;
+
+	if (block_size) {
+		snprintf(bsize,sizeof(bsize),"-B%d",block_size);
+		args[ac++] = bsize;
+	}
+
+	if (max_delete && am_sender) {
+		snprintf(mdelete,sizeof(mdelete),"--max-delete=%d",max_delete);
+		args[ac++] = mdelete;
+	}
+
+	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;
+	}
+
+	if (io_timeout) {
+		snprintf(iotime,sizeof(iotime),"--timeout=%d",io_timeout);
+		args[ac++] = iotime;
+	}
+
+	if (bwlimit) {
+		snprintf(bw,sizeof(bw),"--bwlimit=%d",bwlimit);
+		args[ac++] = bw;
+	}
+
+	if (backup_dir) {
+		args[ac++] = "--backup-dir";
+		args[ac++] = backup_dir;
+	}
+
+	/* Only send --suffix if it specifies a non-default value. */
+	if (strcmp(backup_suffix, backup_dir? "" : BACKUP_SUFFIX) != 0) {
+		char *s = malloc(9+backup_suffix_len+1);
+		if (!s)
+			out_of_memory("server_options");
+		/* We use the following syntax to avoid weirdness with '~'. */
+		sprintf(s, "--suffix=%s", backup_suffix);
+		args[ac++] = s;
+	}
+
+	if (delete_mode && !delete_excluded)
+		args[ac++] = "--delete";
+
+	if (delete_excluded)
+		args[ac++] = "--delete-excluded";
+
+	if (size_only)
+		args[ac++] = "--size-only";
+
+	if (modify_window_set) {
+		snprintf(mwindow,sizeof(mwindow),"--modify-window=%d",
+			 modify_window);
+		args[ac++] = mwindow;
+	}
+
+	if (keep_partial)
+		args[ac++] = "--partial";
+
+	if (force_delete)
+		args[ac++] = "--force";
+
+	if (delete_after)
+		args[ac++] = "--delete-after";
+
+	if (ignore_errors)
+		args[ac++] = "--ignore-errors";
+
+	if (copy_unsafe_links)
+		args[ac++] = "--copy-unsafe-links";
+
+	if (safe_symlinks)
+		args[ac++] = "--safe-links";
+
+	if (numeric_ids)
+		args[ac++] = "--numeric-ids";
+
+	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;
+	}
+
+	if (compare_dest && am_sender) {
+		/* the server only needs this option if it is not the sender,
+		 *   and it may be an older version that doesn't know this
+		 *   option, so don't send it if client is the sender.
+		 */
+		args[ac++] = link_dest ? "--link-dest" : "--compare-dest";
+		args[ac++] = compare_dest;
+	}
+
+	if (files_from && (!am_sender || remote_filesfrom_file)) {
+		if (remote_filesfrom_file) {
+			args[ac++] = "--files-from";
+			args[ac++] = remote_filesfrom_file;
+			if (eol_nulls)
+				args[ac++] = "--from0";
+		} else {
+			args[ac++] = "--files-from=-";
+			args[ac++] = "--from0";
+		}
+	}
+
+	*argc = ac;
+}
+
+/**
+ * Return the position of a ':' IF it is not part of a filename (i.e. as
+ * long as it doesn't occur after a slash.
+ */
+char *find_colon(char *s)
+{
+	char *p, *p2;
+
+	p = strchr(s,':');
+	if (!p) return NULL;
+
+	/* now check to see if there is a / in the string before the : - if there is then
+	   discard the colon on the assumption that the : is part of a filename */
+	p2 = strchr(s,'/');
+	if (p2 && p2 < p) return NULL;
+
+	return p;
+}

packaging/lsb/rsync.spec

@@ -0,0 +1,84 @@
+Summary: Program for efficient remote updates of files.
+Name: rsync
+Version: 2.5.7
+Release: 1
+Copyright: GPL
+Group: Applications/Networking
+Source:	ftp://samba.anu.edu.au/pub/rsync/rsync-2.5.7.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/lsb/rsync.spec.tmpl

@@ -0,0 +1,93 @@
+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
+* Thu Jan 30 2003 Horst von Brand <vonbrand@inf.utfsm.cl>
+  Fixed "Sept" date in %changelog here
+  Use %{_mandir} to point to manpages
+  Support for compressed manpages (* at end catches them in %files)
+  Add doc/README-SGML and doc/rsync.sgml to %doc
+
+* Mon Sep 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=%{_mandir}
+make CFLAGS="$RPM_OPT_FLAGS"
+strip rsync
+
+%install
+mkdir -p $RPM_BUILD_ROOT/usr/bin
+mkdir -p $RPM_BUILD_ROOT/%{_mandir}/man{1,5}
+install -m755 rsync $RPM_BUILD_ROOT/usr/bin
+install -m644 rsync.1 $RPM_BUILD_ROOT/%{_mandir}/man1
+install -m644 rsyncd.conf.5 $RPM_BUILD_ROOT/%{_mandir}/man5
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%files
+%attr(-,root,root) /usr/bin/rsync
+%attr(-,root,root) %{_mandir}/man1/rsync.1*
+%attr(-,root,root) %{_mandir}/man5/rsyncd.conf.5*
+%attr(-,root,root) %doc tech_report.tex
+%attr(-,root,root) %doc README
+%attr(-,root,root) %doc COPYING
+%attr(-,root,root) %doc doc/README-SGML doc/rsync.sgml

packaging/redhat/5.0/rsync.spec

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

packaging/redhat/7.1/rsync.spec

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

packaging/solaris/build_pkg.sh

@@ -0,0 +1,94 @@
+#!/bin/sh
+# Shell script for building Solaris package of rsync
+# Author: Jens Apel <jens.apel@web.de>
+# License: GPL
+#
+# BASEDIR is /usr/local and should be the same as the
+# --prefix parameter of configure
+#
+# this script should be copied under
+# packaging/solaris/5.8/build_pkg.sh
+
+# Definitions start here
+# you can edit this, if you like
+
+# The Package name under which rsync will b installed
+PKGNAME=SMBrsync
+
+# Extract common info requires for the 'info' part of the package.
+# This should be made generic and generated by the configure script
+# but for now it is hard coded
+BASEDIR=/usr/local
+VERSION="2.5.5"
+ARCH=`uname -p`
+NAME=rsync
+
+# Definitions end here
+# Please do not edit below this line or you know what you do.
+
+## Start by faking root install
+echo "Creating install directory (fake $BASEDIR)..."
+START=`pwd`
+FAKE_ROOT=$START/${PKGNAME}
+mkdir $FAKE_ROOT
+
+# copy the binary and the man page to their places
+mkdir $FAKE_ROOT/bin
+mkdir -p $FAKE_ROOT/doc/rsync
+mkdir -p $FAKE_ROOT/man/man1
+mkdir -p $FAKE_ROOT/man/man5
+
+cp ../../../rsync $FAKE_ROOT/bin/rsync
+cp ../../../rsync.1 $FAKE_ROOT/man/man1/rsync.1
+cp ../../../rsyncd.conf.5 $FAKE_ROOT/man/man5/rsyncd.conf.5
+cp ../../../README $FAKE_ROOT/doc/rsync/README
+cp ../../../COPYING $FAKE_ROOT/doc/rsync/COPYING
+cp ../../../tech_report.pdf $FAKE_ROOT/doc/rsync/tech_report.pdf
+cp ../../../COPYING $FAKE_ROOT/COPYING
+
+## Build info file
+echo "Building pkginfo file..."
+cat > $FAKE_ROOT/pkginfo << EOF_INFO
+PKG=$PKGNAME
+NAME=$NAME
+DESC="Program for efficient remote updates of files."
+VENDOR="Samba Team URL: http://samba.anu.edu.au/rsync/"
+BASEDIR=$BASEDIR
+ARCH=$ARCH
+VERSION=$VERSION
+CATEGORY=application
+CLASSES=none
+EOF_INFO
+
+## Build prototype file
+cat > $FAKE_ROOT/prototype << EOFPROTO
+i copyright=COPYING
+i pkginfo=pkginfo
+d none bin 0755 bin bin
+f none bin/rsync 0755 bin bin
+d none doc 0755 bin bin
+d none doc/$NAME 0755 bin bin
+f none doc/$NAME/README 0644 bin bin
+f none doc/$NAME/COPYING 0644 bin bin
+f none doc/$NAME/tech_report.pdf 0644 bin bin
+d none man 0755 bin bin
+d none man/man1 0755 bin bin
+f none man/man1/rsync.1 0644 bin bin
+d none man/man5 0755 bin bin
+f none man/man5/rsyncd.conf.5 0644 bin bin
+EOFPROTO
+
+## And now build the package.
+OUTPUTFILE=$PKGNAME-$VERSION-sol8-$ARCH-local.pkg
+echo "Building package.."
+echo FAKE_ROOT = $FAKE_ROOT
+cd $FAKE_ROOT
+pkgmk -d . -r . -f ./prototype -o
+pkgtrans -os . $OUTPUTFILE $PKGNAME
+
+mv $OUTPUTFILE ..
+cd ..
+
+# Comment this out if you want to see, which file structure has been created
+rm -rf $FAKE_ROOT
+

params.c

@@ -0,0 +1,558 @@
+/*
+  This modules is based on the params.c module from Samba, written by Karl Auer
+  and much modifed by Christopher Hertel.
+
+ * 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.
+ *
+ * -------------------------------------------------------------------------- **
+ *
+ * Module name: params
+ *
+ * -------------------------------------------------------------------------- **
+ *
+ *  This module performs lexical analysis and initial parsing of a
+ *  Windows-like parameter file.  It recognizes and handles four token
+ *  types:  section-name, parameter-name, parameter-value, and
+ *  end-of-file.  Comments and line continuation are handled
+ *  internally.
+ *
+ *  The entry point to the module is function pm_process().  This
+ *  function opens the source file, calls the Parse() function to parse
+ *  the input, and then closes the file when either the EOF is reached
+ *  or a fatal error is encountered.
+ *
+ *  A sample parameter file might look like this:
+ *
+ *  [section one]
+ *  parameter one = value string
+ *  parameter two = another value
+ *  [section two]
+ *  new parameter = some value or t'other
+ *
+ *  The parameter file is divided into sections by section headers:
+ *  section names enclosed in square brackets (eg. [section one]).
+ *  Each section contains parameter lines, each of which consist of a
+ *  parameter name and value delimited by an equal sign.  Roughly, the
+ *  syntax is:
+ *
+ *    <file>            :==  { <section> } EOF
+ *
+ *    <section>         :==  <section header> { <parameter line> }
+ *
+ *    <section header>  :==  '[' NAME ']'
+ *
+ *    <parameter line>  :==  NAME '=' VALUE '\n'
+ *
+ *  Blank lines and comment lines are ignored.  Comment lines are lines
+ *  beginning with either a semicolon (';') or a pound sign ('#').
+ *
+ *  All whitespace in section names and parameter names is compressed
+ *  to single spaces.  Leading and trailing whitespace is stipped from
+ *  both names and values.
+ *
+ *  Only the first equals sign in a parameter line is significant.
+ *  Parameter values may contain equals signs, square brackets and
+ *  semicolons.  Internal whitespace is retained in parameter values,
+ *  with the exception of the '\r' character, which is stripped for
+ *  historic reasons.  Parameter names may not start with a left square
+ *  bracket, an equal sign, a pound sign, or a semicolon, because these
+ *  are used to identify other tokens.
+ *
+ * -------------------------------------------------------------------------- **
+ */
+
+#include "rsync.h"
+
+/* -------------------------------------------------------------------------- **
+ * Constants...
+ */
+
+#define BUFR_INC 1024
+
+
+/* -------------------------------------------------------------------------- **
+ * Variables...
+ *
+ *  bufr        - pointer to a global buffer.  This is probably a kludge,
+ *                but it was the nicest kludge I could think of (for now).
+ *  bSize       - The size of the global buffer <bufr>.
+ */
+
+static char *bufr  = NULL;
+static int   bSize = 0;
+
+/* -------------------------------------------------------------------------- **
+ * Functions...
+ */
+
+static int EatWhitespace( FILE *InFile )
+  /* ------------------------------------------------------------------------ **
+   * Scan past whitespace (see ctype(3C)) and return the first non-whitespace
+   * character, or newline, or EOF.
+   *
+   *  Input:  InFile  - Input source.
+   *
+   *  Output: The next non-whitespace character in the input stream.
+   *
+   *  Notes:  Because the config files use a line-oriented grammar, we
+   *          explicitly exclude the newline character from the list of
+   *          whitespace characters.
+   *        - Note that both EOF (-1) and the nul character ('\0') are
+   *          considered end-of-file markers.
+   *
+   * ------------------------------------------------------------------------ **
+   */
+  {
+  int c;
+
+  for( c = getc( InFile ); isspace( c ) && ('\n' != c); c = getc( InFile ) )
+    ;
+  return( c );
+  } /* EatWhitespace */
+
+static int EatComment( FILE *InFile )
+  /* ------------------------------------------------------------------------ **
+   * Scan to the end of a comment.
+   *
+   *  Input:  InFile  - Input source.
+   *
+   *  Output: The character that marks the end of the comment.  Normally,
+   *          this will be a newline, but it *might* be an EOF.
+   *
+   *  Notes:  Because the config files use a line-oriented grammar, we
+   *          explicitly exclude the newline character from the list of
+   *          whitespace characters.
+   *        - Note that both EOF (-1) and the nul character ('\0') are
+   *          considered end-of-file markers.
+   *
+   * ------------------------------------------------------------------------ **
+   */
+  {
+  int c;
+
+  for( c = getc( InFile ); ('\n'!=c) && (EOF!=c) && (c>0); c = getc( InFile ) )
+    ;
+  return( c );
+  } /* EatComment */
+
+static int Continuation( char *line, int pos )
+  /* ------------------------------------------------------------------------ **
+   * Scan backards within a string to discover if the last non-whitespace
+   * character is a line-continuation character ('\\').
+   *
+   *  Input:  line  - A pointer to a buffer containing the string to be
+   *                  scanned.
+   *          pos   - This is taken to be the offset of the end of the
+   *                  string.  This position is *not* scanned.
+   *
+   *  Output: The offset of the '\\' character if it was found, or -1 to
+   *          indicate that it was not.
+   *
+   * ------------------------------------------------------------------------ **
+   */
+  {
+  pos--;
+  while( (pos >= 0) && isspace(((unsigned char *)line)[pos]) )
+     pos--;
+
+  return( ((pos >= 0) && ('\\' == line[pos])) ? pos : -1 );
+  } /* Continuation */
+
+
+static BOOL Section( FILE *InFile, BOOL (*sfunc)(char *) )
+  /* ------------------------------------------------------------------------ **
+   * Scan a section name, and pass the name to function sfunc().
+   *
+   *  Input:  InFile  - Input source.
+   *          sfunc   - Pointer to the function to be called if the section
+   *                    name is successfully read.
+   *
+   *  Output: True if the section name was read and True was returned from
+   *          <sfunc>.  False if <sfunc> failed or if a lexical error was
+   *          encountered.
+   *
+   * ------------------------------------------------------------------------ **
+   */
+  {
+  int   c;
+  int   i;
+  int   end;
+  char *func  = "params.c:Section() -";
+
+  i = 0;      /* <i> is the offset of the next free byte in bufr[] and  */
+  end = 0;    /* <end> is the current "end of string" offset.  In most  */
+              /* cases these will be the same, but if the last          */
+              /* character written to bufr[] is a space, then <end>     */
+              /* will be one less than <i>.                             */
+
+  c = EatWhitespace( InFile );    /* We've already got the '['.  Scan */
+                                  /* past initial white space.        */
+
+  while( (EOF != c) && (c > 0) )
+    {
+
+    /* Check that the buffer is big enough for the next character. */
+    if( i > (bSize - 2) )
+      {
+      bSize += BUFR_INC;
+      bufr   = realloc_array( bufr, char, bSize );
+      if( NULL == bufr )
+        {
+        rprintf(FERROR, "%s Memory re-allocation failure.", func);
+        return( False );
+        }
+      }
+
+    /* Handle a single character. */
+    switch( c )
+      {
+      case ']':                       /* Found the closing bracket.         */
+        bufr[end] = '\0';
+        if( 0 == end )                  /* Don't allow an empty name.       */
+          {
+          rprintf(FERROR, "%s Empty section name in configuration file.\n", func );
+          return( False );
+          }
+        if( !sfunc( bufr ) )            /* Got a valid name.  Deal with it. */
+          return( False );
+        (void)EatComment( InFile );     /* Finish off the line.             */
+        return( True );
+
+      case '\n':                      /* Got newline before closing ']'.    */
+        i = Continuation( bufr, i );    /* Check for line continuation.     */
+        if( i < 0 )
+          {
+          bufr[end] = '\0';
+          rprintf(FERROR, "%s Badly formed line in configuration file: %s\n",
+                   func, bufr );
+          return( False );
+          }
+        end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i);
+        c = getc( InFile );             /* Continue with next line.         */
+        break;
+
+      default:                        /* All else are a valid name chars.   */
+        if( isspace( c ) )              /* One space per whitespace region. */
+          {
+          bufr[end] = ' ';
+          i = end + 1;
+          c = EatWhitespace( InFile );
+          }
+        else                            /* All others copy verbatim.        */
+          {
+          bufr[i++] = c;
+          end = i;
+          c = getc( InFile );
+          }
+      }
+    }
+
+  /* We arrive here if we've met the EOF before the closing bracket. */
+  rprintf(FERROR, "%s Unexpected EOF in the configuration file: %s\n", func, bufr );
+  return( False );
+  } /* Section */
+
+static BOOL Parameter( FILE *InFile, BOOL (*pfunc)(char *, char *), int c )
+  /* ------------------------------------------------------------------------ **
+   * Scan a parameter name and value, and pass these two fields to pfunc().
+   *
+   *  Input:  InFile  - The input source.
+   *          pfunc   - A pointer to the function that will be called to
+   *                    process the parameter, once it has been scanned.
+   *          c       - The first character of the parameter name, which
+   *                    would have been read by Parse().  Unlike a comment
+   *                    line or a section header, there is no lead-in
+   *                    character that can be discarded.
+   *
+   *  Output: True if the parameter name and value were scanned and processed
+   *          successfully, else False.
+   *
+   *  Notes:  This function is in two parts.  The first loop scans the
+   *          parameter name.  Internal whitespace is compressed, and an
+   *          equal sign (=) terminates the token.  Leading and trailing
+   *          whitespace is discarded.  The second loop scans the parameter
+   *          value.  When both have been successfully identified, they are
+   *          passed to pfunc() for processing.
+   *
+   * ------------------------------------------------------------------------ **
+   */
+  {
+  int   i       = 0;    /* Position within bufr. */
+  int   end     = 0;    /* bufr[end] is current end-of-string. */
+  int   vstart  = 0;    /* Starting position of the parameter value. */
+  char *func    = "params.c:Parameter() -";
+
+  /* Read the parameter name. */
+  while( 0 == vstart )  /* Loop until we've found the start of the value. */
+    {
+
+    if( i > (bSize - 2) )       /* Ensure there's space for next char.    */
+      {
+      bSize += BUFR_INC;
+      bufr   = realloc_array( bufr, char, bSize );
+      if( NULL == bufr )
+        {
+        rprintf(FERROR, "%s Memory re-allocation failure.", func) ;
+        return( False );
+        }
+      }
+
+    switch( c )
+      {
+      case '=':                 /* Equal sign marks end of param name. */
+        if( 0 == end )              /* Don't allow an empty name.      */
+          {
+          rprintf(FERROR, "%s Invalid parameter name in config. file.\n", func );
+          return( False );
+          }
+        bufr[end++] = '\0';         /* Mark end of string & advance.   */
+        i       = end;              /* New string starts here.         */
+        vstart  = end;              /* New string is parameter value.  */
+        bufr[i] = '\0';             /* New string is nul, for now.     */
+        break;
+
+      case '\n':                /* Find continuation char, else error. */
+        i = Continuation( bufr, i );
+        if( i < 0 )
+          {
+          bufr[end] = '\0';
+          rprintf(FERROR, "%s Ignoring badly formed line in configuration file: %s\n",
+                   func, bufr );
+          return( True );
+          }
+        end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i);
+        c = getc( InFile );       /* Read past eoln.                   */
+        break;
+
+      case '\0':                /* Shouldn't have EOF within param name. */
+      case EOF:
+        bufr[i] = '\0';
+        rprintf(FERROR, "%s Unexpected end-of-file at: %s\n", func, bufr );
+        return( True );
+
+      default:
+        if( isspace( c ) )     /* One ' ' per whitespace region.       */
+          {
+          bufr[end] = ' ';
+          i = end + 1;
+          c = EatWhitespace( InFile );
+          }
+        else                   /* All others verbatim.                 */
+          {
+          bufr[i++] = c;
+          end = i;
+          c = getc( InFile );
+          }
+      }
+    }
+
+  /* Now parse the value. */
+  c = EatWhitespace( InFile );  /* Again, trim leading whitespace. */
+  while( (EOF !=c) && (c > 0) )
+    {
+
+    if( i > (bSize - 2) )       /* Make sure there's enough room. */
+      {
+      bSize += BUFR_INC;
+      bufr   = realloc_array( bufr, char, bSize );
+      if( NULL == bufr )
+        {
+        rprintf(FERROR, "%s Memory re-allocation failure.", func) ;
+        return( False );
+        }
+      }
+
+    switch( c )
+      {
+      case '\r':              /* Explicitly remove '\r' because the older */
+        c = getc( InFile );   /* version called fgets_slash() which also  */
+        break;                /* removes them.                            */
+
+      case '\n':              /* Marks end of value unless there's a '\'. */
+        i = Continuation( bufr, i );
+        if( i < 0 )
+          c = 0;
+        else
+          {
+          for( end = i; (end >= 0) && isspace(((unsigned char *) bufr)[end]); end-- )
+            ;
+          c = getc( InFile );
+          }
+        break;
+
+      default:               /* All others verbatim.  Note that spaces do */
+        bufr[i++] = c;       /* not advance <end>.  This allows trimming  */
+        if( !isspace( c ) )  /* of whitespace at the end of the line.     */
+          end = i;
+        c = getc( InFile );
+        break;
+      }
+    }
+  bufr[end] = '\0';          /* End of value. */
+
+  return( pfunc( bufr, &bufr[vstart] ) );   /* Pass name & value to pfunc().  */
+  } /* Parameter */
+
+static BOOL Parse( FILE *InFile,
+                   BOOL (*sfunc)(char *),
+                   BOOL (*pfunc)(char *, char *) )
+  /* ------------------------------------------------------------------------ **
+   * Scan & parse the input.
+   *
+   *  Input:  InFile  - Input source.
+   *          sfunc   - Function to be called when a section name is scanned.
+   *                    See Section().
+   *          pfunc   - Function to be called when a parameter is scanned.
+   *                    See Parameter().
+   *
+   *  Output: True if the file was successfully scanned, else False.
+   *
+   *  Notes:  The input can be viewed in terms of 'lines'.  There are four
+   *          types of lines:
+   *            Blank      - May contain whitespace, otherwise empty.
+   *            Comment    - First non-whitespace character is a ';' or '#'.
+   *                         The remainder of the line is ignored.
+   *            Section    - First non-whitespace character is a '['.
+   *            Parameter  - The default case.
+   * 
+   * ------------------------------------------------------------------------ **
+   */
+  {
+  int    c;
+
+  c = EatWhitespace( InFile );
+  while( (EOF != c) && (c > 0) )
+    {
+    switch( c )
+      {
+      case '\n':                        /* Blank line. */
+        c = EatWhitespace( InFile );
+        break;
+
+      case ';':                         /* Comment line. */
+      case '#':
+        c = EatComment( InFile );
+        break;
+
+      case '[':                         /* Section Header. */
+	      if (!sfunc) return True;
+	      if( !Section( InFile, sfunc ) )
+		      return( False );
+	      c = EatWhitespace( InFile );
+	      break;
+
+      case '\\':                        /* Bogus backslash. */
+        c = EatWhitespace( InFile );
+        break;
+
+      default:                          /* Parameter line. */
+        if( !Parameter( InFile, pfunc, c ) )
+          return( False );
+        c = EatWhitespace( InFile );
+        break;
+      }
+    }
+  return( True );
+  } /* Parse */
+
+static FILE *OpenConfFile( char *FileName )
+  /* ------------------------------------------------------------------------ **
+   * Open a configuration file.
+   *
+   *  Input:  FileName  - The pathname of the config file to be opened.
+   *
+   *  Output: A pointer of type (FILE *) to the opened file, or NULL if the
+   *          file could not be opened.
+   *
+   * ------------------------------------------------------------------------ **
+   */
+  {
+  FILE *OpenedFile;
+  char *func = "params.c:OpenConfFile() -";
+
+  if( NULL == FileName || 0 == *FileName )
+    {
+    rprintf(FERROR,"%s No configuration filename specified.\n", func);
+    return( NULL );
+    }
+
+  OpenedFile = fopen( FileName, "r" );
+  if( NULL == OpenedFile )
+    {
+    rprintf(FERROR,"rsync: unable to open configuration file \"%s\": %s\n",
+	    FileName, strerror(errno));
+    }
+
+  return( OpenedFile );
+  } /* OpenConfFile */
+
+BOOL pm_process( char *FileName,
+                 BOOL (*sfunc)(char *),
+                 BOOL (*pfunc)(char *, char *) )
+  /* ------------------------------------------------------------------------ **
+   * Process the named parameter file.
+   *
+   *  Input:  FileName  - The pathname of the parameter file to be opened.
+   *          sfunc     - A pointer to a function that will be called when
+   *                      a section name is discovered.
+   *          pfunc     - A pointer to a function that will be called when
+   *                      a parameter name and value are discovered.
+   *
+   *  Output: TRUE if the file was successfully parsed, else FALSE.
+   *
+   * ------------------------------------------------------------------------ **
+   */
+  {
+  int   result;
+  FILE *InFile;
+  char *func = "params.c:pm_process() -";
+
+  InFile = OpenConfFile( FileName );          /* Open the config file. */
+  if( NULL == InFile )
+    return( False );
+
+  if( NULL != bufr )                          /* If we already have a buffer */
+    result = Parse( InFile, sfunc, pfunc );   /* (recursive call), then just */
+                                              /* use it.                     */
+
+  else                                        /* If we don't have a buffer   */
+    {                                         /* allocate one, then parse,   */
+    bSize = BUFR_INC;                         /* then free.                  */
+    bufr = new_array( char, bSize );
+    if( NULL == bufr )
+      {
+      rprintf(FERROR,"%s memory allocation failure.\n", func);
+      fclose(InFile);
+      return( False );
+      }
+    result = Parse( InFile, sfunc, pfunc );
+    free( bufr );
+    bufr  = NULL;
+    bSize = 0;
+    }
+
+  fclose(InFile);
+
+  if( !result )                               /* Generic failure. */
+    {
+    rprintf(FERROR,"%s Failed.  Error returned from params.c:parse().\n", func);
+    return( False );
+    }
+
+  return( True );                             /* Generic success. */
+  } /* pm_process */
+
+/* -------------------------------------------------------------------------- */
+

pipe.c

@@ -0,0 +1,152 @@
+/*  -*- c-file-style: "linux" -*-
+ * 
+ * Copyright (C) 1996-2000 by Andrew Tridgell 
+ * Copyright (C) Paul Mackerras 1996
+ * 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.
+ */
+
+#include "rsync.h"
+
+/**
+ * Create a child connected to use on stdin/stdout.
+ *
+ * This is derived from CVS code 
+ * 
+ * Note that in the child STDIN is set to blocking and STDOUT
+ * is set to non-blocking. This is necessary as rsh relies on stdin being blocking
+ *  and ssh relies on stdout being non-blocking
+ *
+ * If blocking_io is set then use blocking io on both fds. That can be
+ * used to cope with badly broken rsh implementations like the one on
+ * Solaris.
+ **/
+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;
+	
+	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);
+	}
+
+
+	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 (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];
+
+	return pid;
+}
+
+pid_t local_child(int argc, char **argv,int *f_in,int *f_out,
+		  int (*child_main)(int, char*[]))
+{
+	pid_t pid;
+	int to_child_pipe[2];
+	int from_child_pipe[2];
+	extern int read_batch;
+	extern int am_sender;
+	extern int am_server;
+	extern int filesfrom_fd;
+
+	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);
+	}
+
+	if (pid == 0) {
+		am_sender = read_batch ? 0 : !am_sender;
+		am_server = 1;		
+
+		if (!am_sender)
+			filesfrom_fd = -1;
+
+		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]);
+		child_main(argc, argv);
+	}
+
+	if (!am_sender)
+		filesfrom_fd = -1;
+
+	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];
+  
+	return pid;
+}

popt/.cvsignore

@@ -0,0 +1,9 @@
+ID
+Makefile
+config.cache
+config.h
+config.log
+config.status
+dummy
+rsync
+zlib/dummy

popt/CHANGES

@@ -0,0 +1,46 @@
+1.5 -> 1.6
+	- add ability to perform callbacks for every, not just first, match.
+
+1.3 -> 1.5
+	- heavy dose of const's
+	- poptParseArgvString() now NULL terminates the list
+
+1.2.3 -> 1.3
+	- added support for single -
+	- misc bug fixes
+	- portability improvements
+
+1.2.2 -> 1.2.3
+	- fixed memset() in help message generation (Dale Hawkins)
+	- added extern "C" stuff to popt.h for C++ compilers (Dale Hawkins)
+	- const'ified poptParseArgvString (Jeff Garzik)
+
+1.2.1 -> 1.2.2
+	- fixed bug in chaind alias happens which seems to have only
+	  affected --triggers in rpm
+	- added POPT_ARG_VAL
+	- popt.3 installed by default
+
+1.2 -> 1.2.1
+	- added POPT_ARG_INTL_DOMAIN (Elliot Lee)
+	- updated Makefile's to be more GNUish (Elliot Lee)
+
+1.1 -> 1.2
+	- added popt.3 man page (Robert Lynch)
+	- don't use mmap anymore (its lack of portability isn't worth the
+	  trouble)
+	- added test script
+	- added support for exec
+	- removed support for *_POPT_ALIASES env variable -- it was a bad
+	  idea
+	- reorganized into multiple source files
+	- added automatic help generation, POPT_AUTOHELP
+	- added table callbacks
+	- added table inclusion
+	- updated man page for new features
+	- added test scripts
+
+1.0 -> 1.1
+	- moved to autoconf (Fred Fish)
+	- added STRERROR replacement (Norbert Warmuth)
+	- added const keywords (Bruce Perens)

popt/COPYING

@@ -0,0 +1,22 @@
+Copyright (c) 1998  Red Hat Software
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.

popt/README

@@ -0,0 +1,18 @@
+This is the popt command line option parsing library. While it is similiar
+to getopt(3), it contains a number of enhancements, including:
+
+	1) popt is fully reentrant
+	2) popt can parse arbitrary argv[] style arrays while 
+	   getopt(2) makes this quite difficult
+	3) popt allows users to alias command line arguments
+	4) popt provides convience functions for parsing strings
+	   into argv[] style arrays
+
+popt is used by rpm, the Red Hat install program, and many other Red Hat
+utilities, all of which provide excellent examples of how to use popt. 
+Complete documentation on popt is available in popt.ps (included in this
+tarball), which is excerpted with permission from the book "Linux
+Application Development" by Michael K. Johnson and Erik Troan (availble
+from Addison Wesley in May, 1998).
+
+Comments on popt should be addressed to ewt@redhat.com.

popt/README.rsync

@@ -0,0 +1,4 @@
+This is a perfectly ordinary copy of libpopt.  It is only used on platforms
+that do not have a sufficiently up-to-date copy of their own.  If you build
+rsync on a platform which has popt, this directory should not be used.  (You
+can control that using the --with-included-popt configure flag.)

popt/findme.c

@@ -0,0 +1,50 @@
+/** \ingroup popt
+ * \file popt/findme.c
+ */
+
+/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#include "system.h"
+#include "findme.h"
+
+const char * findProgramPath(const char * argv0) {
+    char * path = getenv("PATH");
+    char * pathbuf;
+    char * start, * chptr;
+    char * buf;
+
+    if (argv0 == NULL) return NULL;	/* XXX can't happen */
+    /* If there is a / in the argv[0], it has to be an absolute path */
+    if (strchr(argv0, '/'))
+	return xstrdup(argv0);
+
+    if (path == NULL) return NULL;
+
+    start = pathbuf = alloca(strlen(path) + 1);
+    buf = malloc(strlen(path) + strlen(argv0) + sizeof("/"));
+    if (buf == NULL) return NULL;	/* XXX can't happen */
+    strcpy(pathbuf, path);
+
+    chptr = NULL;
+    /*@-branchstate@*/
+    do {
+	if ((chptr = strchr(start, ':')))
+	    *chptr = '\0';
+	sprintf(buf, "%s/%s", start, argv0);
+
+	if (!access(buf, X_OK))
+	    return buf;
+
+	if (chptr) 
+	    start = chptr + 1;
+	else
+	    start = NULL;
+    } while (start && *start);
+    /*@=branchstate@*/
+
+    free(buf);
+
+    return NULL;
+}

popt/findme.h

@@ -0,0 +1,20 @@
+/** \ingroup popt
+ * \file popt/findme.h
+ */
+
+/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#ifndef H_FINDME
+#define H_FINDME
+
+/**
+ * Return absolute path to executable by searching PATH.
+ * @param argv0		name of executable
+ * @return		(malloc'd) absolute path to executable (or NULL)
+ */
+/*@null@*/ const char * findProgramPath(/*@null@*/ const char * argv0)
+	/*@*/;
+
+#endif

popt/popt.h

@@ -0,0 +1,446 @@
+/** \file popt/popt.h
+ * \ingroup popt
+ */
+
+/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#ifndef H_POPT
+#define H_POPT
+
+#include <stdio.h>			/* for FILE * */
+
+#define POPT_OPTION_DEPTH	10
+
+/** \ingroup popt
+ * \name Arg type identifiers
+ */
+/*@{*/
+#define POPT_ARG_NONE		0	/*!< no arg */
+#define POPT_ARG_STRING		1	/*!< arg will be saved as string */
+#define POPT_ARG_INT		2	/*!< arg will be converted to int */
+#define POPT_ARG_LONG		3	/*!< arg will be converted to long */
+#define POPT_ARG_INCLUDE_TABLE	4	/*!< arg points to table */
+#define POPT_ARG_CALLBACK	5	/*!< table-wide callback... must be
+					   set first in table; arg points 
+					   to callback, descrip points to 
+					   callback data to pass */
+#define POPT_ARG_INTL_DOMAIN    6       /*!< set the translation domain
+					   for this table and any
+					   included tables; arg points
+					   to the domain string */
+#define POPT_ARG_VAL		7	/*!< arg should take value val */
+#define	POPT_ARG_FLOAT		8	/*!< arg will be converted to float */
+#define	POPT_ARG_DOUBLE		9	/*!< arg will be converted to double */
+
+#define POPT_ARG_MASK		0x0000FFFF
+/*@}*/
+
+/** \ingroup popt
+ * \name Arg modifiers
+ */
+/*@{*/
+#define POPT_ARGFLAG_ONEDASH	0x80000000  /*!< allow -longoption */
+#define POPT_ARGFLAG_DOC_HIDDEN 0x40000000  /*!< don't show in help/usage */
+#define POPT_ARGFLAG_STRIP	0x20000000  /*!< strip this arg from argv(only applies to long args) */
+#define	POPT_ARGFLAG_OPTIONAL	0x10000000  /*!< arg may be missing */
+
+#define	POPT_ARGFLAG_OR		0x08000000  /*!< arg will be or'ed */
+#define	POPT_ARGFLAG_NOR	0x09000000  /*!< arg will be nor'ed */
+#define	POPT_ARGFLAG_AND	0x04000000  /*!< arg will be and'ed */
+#define	POPT_ARGFLAG_NAND	0x05000000  /*!< arg will be nand'ed */
+#define	POPT_ARGFLAG_XOR	0x02000000  /*!< arg will be xor'ed */
+#define	POPT_ARGFLAG_NOT	0x01000000  /*!< arg will be negated */
+#define POPT_ARGFLAG_LOGICALOPS \
+        (POPT_ARGFLAG_OR|POPT_ARGFLAG_AND|POPT_ARGFLAG_XOR)
+
+#define	POPT_BIT_SET	(POPT_ARG_VAL|POPT_ARGFLAG_OR)
+					/*!< set arg bit(s) */
+#define	POPT_BIT_CLR	(POPT_ARG_VAL|POPT_ARGFLAG_NAND)
+					/*!< clear arg bit(s) */
+
+#define	POPT_ARGFLAG_SHOW_DEFAULT 0x00800000 /*!< show default value in --help */
+
+/*@}*/
+
+/** \ingroup popt
+ * \name Callback modifiers
+ */
+/*@{*/
+#define POPT_CBFLAG_PRE		0x80000000  /*!< call the callback before parse */
+#define POPT_CBFLAG_POST	0x40000000  /*!< call the callback after parse */
+#define POPT_CBFLAG_INC_DATA	0x20000000  /*!< use data from the include line,
+					       not the subtable */
+#define POPT_CBFLAG_SKIPOPTION	0x10000000  /*!< don't callback with option */
+#define POPT_CBFLAG_CONTINUE	0x08000000  /*!< continue callbacks with option */
+/*@}*/
+
+/** \ingroup popt
+ * \name Error return values
+ */
+/*@{*/
+#define POPT_ERROR_NOARG	-10	/*!< missing argument */
+#define POPT_ERROR_BADOPT	-11	/*!< unknown option */
+#define POPT_ERROR_OPTSTOODEEP	-13	/*!< aliases nested too deeply */
+#define POPT_ERROR_BADQUOTE	-15	/*!< error in paramter quoting */
+#define POPT_ERROR_ERRNO	-16	/*!< errno set, use strerror(errno) */
+#define POPT_ERROR_BADNUMBER	-17	/*!< invalid numeric value */
+#define POPT_ERROR_OVERFLOW	-18	/*!< number too large or too small */
+#define	POPT_ERROR_BADOPERATION	-19	/*!< mutually exclusive logical operations requested */
+#define	POPT_ERROR_NULLARG	-20	/*!< opt->arg should not be NULL */
+#define	POPT_ERROR_MALLOC	-21	/*!< memory allocation failed */
+/*@}*/
+
+/** \ingroup popt
+ * \name poptBadOption() flags
+ */
+/*@{*/
+#define POPT_BADOPTION_NOALIAS  (1 << 0)  /*!< don't go into an alias */
+/*@}*/
+
+/** \ingroup popt
+ * \name poptGetContext() flags
+ */
+/*@{*/
+#define POPT_CONTEXT_NO_EXEC	(1 << 0)  /*!< ignore exec expansions */
+#define POPT_CONTEXT_KEEP_FIRST	(1 << 1)  /*!< pay attention to argv[0] */
+#define POPT_CONTEXT_POSIXMEHARDER (1 << 2) /*!< options can't follow args */
+#define POPT_CONTEXT_ARG_OPTS	(1 << 4) /*!< return args as options with value 0 */
+/*@}*/
+
+/** \ingroup popt
+ */
+struct poptOption {
+/*@observer@*/ /*@null@*/ const char * longName; /*!< may be NULL */
+    char shortName;			/*!< may be '\0' */
+    int argInfo;
+/*@shared@*/ /*@null@*/ void * arg;	/*!< depends on argInfo */
+    int val;			/*!< 0 means don't return, just update flag */
+/*@observer@*/ /*@null@*/ const char * descrip;	/*!< description for autohelp -- may be NULL */
+/*@observer@*/ /*@null@*/ const char * argDescrip; /*!< argument description for autohelp */
+};
+
+/** \ingroup popt
+ * A popt alias argument for poptAddAlias().
+ */
+struct poptAlias {
+/*@owned@*/ /*@null@*/ const char * longName;	/*!< may be NULL */
+    char shortName;		/*!< may be '\0' */
+    int argc;
+/*@owned@*/ const char ** argv;	/*!< must be free()able */
+};
+
+/** \ingroup popt
+ * A popt alias or exec argument for poptAddItem().
+ */
+typedef struct poptItem_s {
+    struct poptOption option;	/*!< alias/exec name(s) and description. */
+    int argc;			/*!< (alias) no. of args. */
+/*@owned@*/ const char ** argv;	/*!< (alias) args, must be free()able. */
+} * poptItem;
+
+/** \ingroup popt
+ * \name Auto-generated help/usage
+ */
+/*@{*/
+
+/**
+ * Empty table marker to enable displaying popt alias/exec options.
+ */
+/*@observer@*/ /*@checked@*/
+extern struct poptOption poptAliasOptions[];
+#define POPT_AUTOALIAS { NULL, '\0', POPT_ARG_INCLUDE_TABLE, poptAliasOptions, \
+			0, "Options implemented via popt alias/exec:", NULL },
+
+/**
+ * Auto help table options.
+ */
+/*@observer@*/ /*@checked@*/
+extern struct poptOption poptHelpOptions[];
+#define POPT_AUTOHELP { NULL, '\0', POPT_ARG_INCLUDE_TABLE, poptHelpOptions, \
+			0, "Help options:", NULL },
+
+#define POPT_TABLEEND { NULL, '\0', 0, 0, 0, NULL, NULL }
+/*@}*/
+
+/** \ingroup popt
+ */
+typedef /*@abstract@*/ struct poptContext_s * poptContext;
+
+/** \ingroup popt
+ */
+#ifndef __cplusplus
+/*@-typeuse@*/
+typedef struct poptOption * poptOption;
+/*@=typeuse@*/
+#endif
+
+enum poptCallbackReason { POPT_CALLBACK_REASON_PRE, 
+			  POPT_CALLBACK_REASON_POST,
+			  POPT_CALLBACK_REASON_OPTION };
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*@-type@*/
+
+/** \ingroup popt
+ * Table callback prototype.
+ * @param con		context
+ * @param reason	reason for callback
+ * @param opt		option that triggered callback
+ * @param arg		@todo Document.
+ * @param data		@todo Document.
+ */
+typedef void (*poptCallbackType) (poptContext con, 
+		enum poptCallbackReason reason,
+		/*@null@*/ const struct poptOption * opt,
+		/*@null@*/ const char * arg,
+		/*@null@*/ const void * data)
+	/*@*/;
+
+/** \ingroup popt
+ * Initialize popt context.
+ * @param name
+ * @param argc		no. of arguments
+ * @param argv		argument array
+ * @param options	address of popt option table
+ * @param flags		or'd POPT_CONTEXT_* bits
+ * @return		initialized popt context
+ */
+/*@only@*/ /*@null@*/ poptContext poptGetContext(
+		/*@dependent@*/ /*@keep@*/ const char * name,
+		int argc, /*@dependent@*/ /*@keep@*/ const char ** argv,
+		/*@dependent@*/ /*@keep@*/ const struct poptOption * options,
+		int flags)
+	/*@*/;
+
+/** \ingroup popt
+ * Reinitialize popt context.
+ * @param con		context
+ */
+void poptResetContext(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Return value of next option found.
+ * @param con		context
+ * @return		next option val, -1 on last item, POPT_ERROR_* on error
+ */
+int poptGetNextOpt(/*@null@*/poptContext con)
+	/*@globals fileSystem@*/
+	/*@modifies con, fileSystem @*/;
+
+/*@-redecl@*/
+/** \ingroup popt
+ * Return next option argument (if any).
+ * @param con		context
+ * @return		option argument, NULL if no more options are available
+ */
+/*@observer@*/ /*@null@*/ const char * poptGetOptArg(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Return current option's argument.
+ * @param con		context
+ * @return		option argument, NULL if no more options are available
+ */
+/*@observer@*/ /*@null@*/ const char * poptGetArg(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Peek at current option's argument.
+ * @param con		context
+ * @return		option argument
+ */
+/*@observer@*/ /*@null@*/ const char * poptPeekArg(/*@null@*/poptContext con)
+	/*@*/;
+
+/** \ingroup popt
+ * Return remaining arguments.
+ * @param con		context
+ * @return		argument array, terminated with NULL
+ */
+/*@observer@*/ /*@null@*/ const char ** poptGetArgs(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Return the option which caused the most recent error.
+ * @param con		context
+ * @return		offending option
+ */
+/*@observer@*/ const char * poptBadOption(/*@null@*/poptContext con, int flags)
+	/*@*/;
+/*@=redecl@*/
+
+/** \ingroup popt
+ * Destroy context.
+ * @param con		context
+ * @return		NULL always
+ */
+/*@null@*/ poptContext poptFreeContext( /*@only@*/ /*@null@*/ poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Add arguments to context.
+ * @param con		context
+ * @param argv		argument array, NULL terminated
+ * @return		0 on success, POPT_ERROR_OPTSTOODEEP on failure
+ */
+int poptStuffArgs(poptContext con, /*@keep@*/ const char ** argv)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Add alias to context.
+ * @todo Pass alias by reference, not value.
+ * @deprecated Use poptAddItem instead.
+ * @param con		context
+ * @param alias		alias to add
+ * @param flags		(unused)
+ * @return		0 on success
+ */
+/*@unused@*/
+int poptAddAlias(poptContext con, struct poptAlias alias, int flags)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Add alias/exec item to context.
+ * @param con		context
+ * @param item		alias/exec item to add
+ * @param flags		0 for alias, 1 for exec
+ * @return		0 on success
+ */
+int poptAddItem(poptContext con, poptItem newItem, int flags)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Read configuration file.
+ * @param con		context
+ * @param fn		file name to read
+ * @return		0 on success, POPT_ERROR_ERRNO on failure
+ */
+int poptReadConfigFile(poptContext con, const char * fn)
+	/*@globals fileSystem@*/
+	/*@modifies fileSystem,
+		con->execs, con->numExecs @*/;
+
+/** \ingroup popt
+ * Read default configuration from /etc/popt and $HOME/.popt.
+ * @param con		context
+ * @param useEnv	(unused)
+ * @return		0 on success, POPT_ERROR_ERRNO on failure
+ */
+int poptReadDefaultConfig(poptContext con, /*@unused@*/ int useEnv)
+	/*@globals fileSystem@*/
+	/*@modifies fileSystem,
+		con->execs, con->numExecs @*/;
+
+/** \ingroup popt
+ * Duplicate an argument array.
+ * @note: The argument array is malloc'd as a single area, so only argv must
+ * be free'd.
+ *
+ * @param argc		no. of arguments
+ * @param argv		argument array
+ * @retval argcPtr	address of returned no. of arguments
+ * @retval argvPtr	address of returned argument array
+ * @return		0 on success, POPT_ERROR_NOARG on failure
+ */
+int poptDupArgv(int argc, /*@null@*/ const char **argv,
+		/*@null@*/ /*@out@*/ int * argcPtr,
+		/*@null@*/ /*@out@*/ const char *** argvPtr)
+	/*@modifies *argcPtr, *argvPtr @*/;
+
+/** \ingroup popt
+ * Parse a string into an argument array.
+ * The parse allows ', ", and \ quoting, but ' is treated the same as " and
+ * both may include \ quotes.
+ * @note: The argument array is malloc'd as a single area, so only argv must
+ * be free'd.
+ *
+ * @param s		string to parse
+ * @retval argcPtr	address of returned no. of arguments
+ * @retval argvPtr	address of returned argument array
+ */
+int poptParseArgvString(const char * s,
+		/*@out@*/ int * argcPtr, /*@out@*/ const char *** argvPtr)
+	/*@modifies *argcPtr, *argvPtr @*/;
+
+/** \ingroup popt
+ * Return formatted error string for popt failure.
+ * @param error		popt error
+ * @return		error string
+ */
+/*@-redecl@*/
+/*@observer@*/ const char *const poptStrerror(const int error)
+	/*@*/;
+/*@=redecl@*/
+
+/** \ingroup popt
+ * Limit search for executables.
+ * @param con		context
+ * @param path		single path to search for executables
+ * @param allowAbsolute	absolute paths only?
+ */
+void poptSetExecPath(poptContext con, const char * path, int allowAbsolute)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Print detailed description of options.
+ * @param con		context
+ * @param fp		ouput file handle
+ * @param flags		(unused)
+ */
+void poptPrintHelp(poptContext con, FILE * fp, /*@unused@*/ int flags)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/;
+
+/** \ingroup popt
+ * Print terse description of options.
+ * @param con		context
+ * @param fp		ouput file handle
+ * @param flags		(unused)
+ */
+void poptPrintUsage(poptContext con, FILE * fp, /*@unused@*/ int flags)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/;
+
+/** \ingroup popt
+ * Provide text to replace default "[OPTION...]" in help/usage output.
+ * @param con		context
+ * @param text		replacement text
+ */
+/*@-fcnuse@*/
+void poptSetOtherOptionHelp(poptContext con, const char * text)
+	/*@modifies con @*/;
+/*@=fcnuse@*/
+
+/** \ingroup popt
+ * Return argv[0] from context.
+ * @param con		context
+ * @return		argv[0]
+ */
+/*@-redecl -fcnuse@*/
+/*@observer@*/ const char * poptGetInvocationName(poptContext con)
+	/*@*/;
+/*@=redecl =fcnuse@*/
+
+/** \ingroup popt
+ * Shuffle argv pointers to remove stripped args, returns new argc.
+ * @param con		context
+ * @param argc		no. of args
+ * @param argv		arg vector
+ * @return		new argc
+ */
+/*@-fcnuse@*/
+int poptStrippedArgv(poptContext con, int argc, char ** argv)
+	/*@modifies *argv @*/;
+/*@=fcnuse@*/
+
+/*@=type@*/
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

popt/poptconfig.c

@@ -0,0 +1,183 @@
+/** \ingroup popt
+ * \file popt/poptconfig.c
+ */
+
+/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#include "system.h"
+#include "poptint.h"
+
+/*@-compmempass@*/	/* FIX: item->option.longName kept, not dependent. */
+static void configLine(poptContext con, char * line)
+	/*@modifies con @*/
+{
+    /*@-type@*/
+    int nameLength = strlen(con->appName);
+    /*@=type@*/
+    const char * entryType;
+    const char * opt;
+    poptItem item = (poptItem) alloca(sizeof(*item));
+    int i, j;
+    
+    memset(item, 0, sizeof(*item));
+
+    /*@-type@*/
+    if (strncmp(line, con->appName, nameLength)) return;
+    /*@=type@*/
+
+    line += nameLength;
+    if (*line == '\0' || !isspace(*line)) return;
+
+    while (*line != '\0' && isspace(*line)) line++;
+    entryType = line;
+    while (*line == '\0' || !isspace(*line)) line++;
+    *line++ = '\0';
+
+    while (*line != '\0' && isspace(*line)) line++;
+    if (*line == '\0') return;
+    opt = line;
+    while (*line == '\0' || !isspace(*line)) line++;
+    *line++ = '\0';
+
+    while (*line != '\0' && isspace(*line)) line++;
+    if (*line == '\0') return;
+
+    /*@-temptrans@*/ /* FIX: line alias is saved */
+    if (opt[0] == '-' && opt[1] == '-')
+	item->option.longName = opt + 2;
+    else if (opt[0] == '-' && opt[2] == '\0')
+	item->option.shortName = opt[1];
+    /*@=temptrans@*/
+
+    if (poptParseArgvString(line, &item->argc, &item->argv)) return;
+
+    /*@-modobserver@*/
+    item->option.argInfo = POPT_ARGFLAG_DOC_HIDDEN;
+    for (i = 0, j = 0; i < item->argc; i++, j++) {
+	const char * f;
+	if (!strncmp(item->argv[i], "--POPTdesc=", sizeof("--POPTdesc=")-1)) {
+	    f = item->argv[i] + sizeof("--POPTdesc=");
+	    if (f[0] == '$' && f[1] == '"') f++;
+	    item->option.descrip = f;
+	    item->option.argInfo &= ~POPT_ARGFLAG_DOC_HIDDEN;
+	    j--;
+	} else
+	if (!strncmp(item->argv[i], "--POPTargs=", sizeof("--POPTargs=")-1)) {
+	    f = item->argv[i] + sizeof("--POPTargs=");
+	    if (f[0] == '$' && f[1] == '"') f++;
+	    item->option.argDescrip = f;
+	    item->option.argInfo &= ~POPT_ARGFLAG_DOC_HIDDEN;
+	    item->option.argInfo |= POPT_ARG_STRING;
+	    j--;
+	} else
+	if (j != i)
+	    item->argv[j] = item->argv[i];
+    }
+    if (j != i) {
+	item->argv[j] = NULL;
+	item->argc = j;
+    }
+    /*@=modobserver@*/
+	
+    /*@-nullstate@*/ /* FIX: item->argv[] may be NULL */
+    if (!strcmp(entryType, "alias"))
+	(void) poptAddItem(con, item, 0);
+    else if (!strcmp(entryType, "exec"))
+	(void) poptAddItem(con, item, 1);
+    /*@=nullstate@*/
+}
+/*@=compmempass@*/
+
+int poptReadConfigFile(poptContext con, const char * fn)
+{
+    const char * file, * chptr, * end;
+    char * buf;
+/*@dependent@*/ char * dst;
+    int fd, rc;
+    off_t fileLength;
+
+    fd = open(fn, O_RDONLY);
+    if (fd < 0)
+	return (errno == ENOENT ? 0 : POPT_ERROR_ERRNO);
+
+    fileLength = lseek(fd, 0, SEEK_END);
+    if (fileLength == -1 || lseek(fd, 0, 0) == -1) {
+	rc = errno;
+	(void) close(fd);
+	/*@-mods@*/
+	errno = rc;
+	/*@=mods@*/
+	return POPT_ERROR_ERRNO;
+    }
+
+    file = alloca(fileLength + 1);
+    if (read(fd, (char *)file, fileLength) != fileLength) {
+	rc = errno;
+	(void) close(fd);
+	/*@-mods@*/
+	errno = rc;
+	/*@=mods@*/
+	return POPT_ERROR_ERRNO;
+    }
+    if (close(fd) == -1)
+	return POPT_ERROR_ERRNO;
+
+    dst = buf = alloca(fileLength + 1);
+
+    chptr = file;
+    end = (file + fileLength);
+    /*@-infloops@*/	/* LCL: can't detect chptr++ */
+    while (chptr < end) {
+	switch (*chptr) {
+	  case '\n':
+	    *dst = '\0';
+	    dst = buf;
+	    while (*dst && isspace(*dst)) dst++;
+	    if (*dst && *dst != '#')
+		configLine(con, dst);
+	    chptr++;
+	    /*@switchbreak@*/ break;
+	  case '\\':
+	    *dst++ = *chptr++;
+	    if (chptr < end) {
+		if (*chptr == '\n') 
+		    dst--, chptr++;	
+		    /* \ at the end of a line does not insert a \n */
+		else
+		    *dst++ = *chptr++;
+	    }
+	    /*@switchbreak@*/ break;
+	  default:
+	    *dst++ = *chptr++;
+	    /*@switchbreak@*/ break;
+	}
+    }
+    /*@=infloops@*/
+
+    return 0;
+}
+
+int poptReadDefaultConfig(poptContext con, /*@unused@*/ int useEnv) {
+    char * fn, * home;
+    int rc;
+
+    /*@-type@*/
+    if (!con->appName) return 0;
+    /*@=type@*/
+
+    rc = poptReadConfigFile(con, "/etc/popt");
+    if (rc) return rc;
+    if (getuid() != geteuid()) return 0;
+
+    if ((home = getenv("HOME"))) {
+	fn = alloca(strlen(home) + 20);
+	strcpy(fn, home);
+	strcat(fn, "/.popt");
+	rc = poptReadConfigFile(con, fn);
+	if (rc) return rc;
+    }
+
+    return 0;
+}

popt/popthelp.c

@@ -0,0 +1,661 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+
+/*@-type@*/
+/** \ingroup popt
+ * \file popt/popthelp.c
+ */
+
+/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#include "system.h"
+#include "poptint.h"
+
+/**
+ * @param con		context
+ * @param key		option(s)
+ */
+static void displayArgs(poptContext con,
+		/*@unused@*/ enum poptCallbackReason foo,
+		struct poptOption * key, 
+		/*@unused@*/ const char * arg, /*@unused@*/ void * data)
+	/*@globals fileSystem@*/
+	/*@modifies fileSystem@*/
+{
+    if (key->shortName == '?')
+	poptPrintHelp(con, stdout, 0);
+    else
+	poptPrintUsage(con, stdout, 0);
+    exit(0);
+}
+
+#ifdef	NOTYET
+/*@unchecked@*/
+static int show_option_defaults = 0;
+#endif
+
+/**
+ * Empty table marker to enable displaying popt alias/exec options.
+ */
+/*@observer@*/ /*@unchecked@*/
+struct poptOption poptAliasOptions[] = {
+    POPT_TABLEEND
+};
+
+/**
+ * Auto help table options.
+ */
+/*@-castfcnptr@*/
+/*@observer@*/ /*@unchecked@*/
+struct poptOption poptHelpOptions[] = {
+  { NULL, '\0', POPT_ARG_CALLBACK, (void *)&displayArgs, '\0', NULL, NULL },
+  { "help", '?', 0, NULL, '?', N_("Show this help message"), NULL },
+  { "usage", '\0', 0, NULL, 'u', N_("Display brief usage message"), NULL },
+#ifdef	NOTYET
+  { "defaults", '\0', POPT_ARG_NONE, &show_option_defaults, 0,
+	N_("Display option defaults in message"), NULL },
+#endif
+    POPT_TABLEEND
+} ;
+/*@=castfcnptr@*/
+
+/**
+ * @param table		option(s)
+ */
+/*@observer@*/ /*@null@*/ static const char *const
+getTableTranslationDomain(/*@null@*/ const struct poptOption *table)
+	/*@*/
+{
+    const struct poptOption *opt;
+
+    if (table != NULL)
+    for (opt = table; opt->longName || opt->shortName || opt->arg; opt++) {
+	if (opt->argInfo == POPT_ARG_INTL_DOMAIN)
+	    return opt->arg;
+    }
+    return NULL;
+}
+
+/**
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ */
+/*@observer@*/ /*@null@*/ static const char *const
+getArgDescrip(const struct poptOption * opt,
+		/*@-paramuse@*/		/* FIX: wazzup? */
+		/*@null@*/ const char * translation_domain)
+		/*@=paramuse@*/
+	/*@*/
+{
+    if (!(opt->argInfo & POPT_ARG_MASK)) return NULL;
+
+    if (opt == (poptHelpOptions + 1) || opt == (poptHelpOptions + 2))
+	if (opt->argDescrip) return POPT_(opt->argDescrip);
+
+    if (opt->argDescrip) return D_(translation_domain, opt->argDescrip);
+
+    switch (opt->argInfo & POPT_ARG_MASK) {
+    case POPT_ARG_NONE:		return POPT_("NONE");
+    case POPT_ARG_VAL:		return POPT_("VAL");
+    case POPT_ARG_INT:		return POPT_("INT");
+    case POPT_ARG_LONG:		return POPT_("LONG");
+    case POPT_ARG_STRING:	return POPT_("STRING");
+    case POPT_ARG_FLOAT:	return POPT_("FLOAT");
+    case POPT_ARG_DOUBLE:	return POPT_("DOUBLE");
+    default:			return POPT_("ARG");
+    }
+}
+
+/**
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ */
+static /*@only@*/ /*@null@*/ char *
+singleOptionDefaultValue(int lineLength,
+		const struct poptOption * opt,
+		/*@-paramuse@*/	/* FIX: i18n macros disable with lclint */
+		/*@null@*/ const char * translation_domain)
+		/*@=paramuse@*/
+	/*@*/
+{
+    const char * defstr = D_(translation_domain, "default");
+    char * le = malloc(4*lineLength + 1);
+    char * l = le;
+
+    if (le == NULL) return NULL;	/* XXX can't happen */
+    *le = '\0';
+    *le++ = '(';
+    strcpy(le, defstr);	le += strlen(le);
+    *le++ = ':';
+    *le++ = ' ';
+    if (opt->arg)	/* XXX programmer error */
+    switch (opt->argInfo & POPT_ARG_MASK) {
+    case POPT_ARG_VAL:
+    case POPT_ARG_INT:
+    {	long aLong = *((int *)opt->arg);
+	sprintf(le, "%ld", aLong);
+	le += strlen(le);
+    }	break;
+    case POPT_ARG_LONG:
+    {	long aLong = *((long *)opt->arg);
+	sprintf(le, "%ld", aLong);
+	le += strlen(le);
+    }	break;
+    case POPT_ARG_FLOAT:
+    {	double aDouble = *((float *)opt->arg);
+	sprintf(le, "%g", aDouble);
+	le += strlen(le);
+    }	break;
+    case POPT_ARG_DOUBLE:
+    {	double aDouble = *((double *)opt->arg);
+	sprintf(le, "%g", aDouble);
+	le += strlen(le);
+    }	break;
+    case POPT_ARG_STRING:
+    {	const char * s = *(const char **)opt->arg;
+	if (s == NULL) {
+	    strcpy(le, "null");	le += strlen(le);
+	} else {
+	    size_t slen = 4*lineLength - (le - l) - sizeof("\"...\")");
+	    *le++ = '"';
+	    strncpy(le, s, slen); le[slen] = '\0'; le += strlen(le);	
+	    if (slen < strlen(s)) {
+		strcpy(le, "...");	le += strlen(le);
+	    }
+	    *le++ = '"';
+	}
+    }	break;
+    case POPT_ARG_NONE:
+    default:
+	l = _free(l);
+	return NULL;
+	/*@notreached@*/ break;
+    }
+    *le++ = ')';
+    *le = '\0';
+
+    return l;
+}
+
+/**
+ * @param fp		output file handle
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ */
+static void singleOptionHelp(FILE * fp, int maxLeftCol, 
+		const struct poptOption * opt,
+		/*@null@*/ const char * translation_domain)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    int indentLength = maxLeftCol + 5;
+    int lineLength = 79 - indentLength;
+    const char * help = D_(translation_domain, opt->descrip);
+    const char * argDescrip = getArgDescrip(opt, translation_domain);
+    int helpLength;
+    char * defs = NULL;
+    char * left;
+    int nb = maxLeftCol + 1;
+
+    /* Make sure there's more than enough room in target buffer. */
+    if (opt->longName)	nb += strlen(opt->longName);
+    if (argDescrip)	nb += strlen(argDescrip);
+
+    left = malloc(nb);
+    if (left == NULL) return;	/* XXX can't happen */
+    left[0] = '\0';
+    left[maxLeftCol] = '\0';
+
+    if (opt->longName && opt->shortName)
+	sprintf(left, "-%c, %s%s", opt->shortName,
+		((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "-" : "--"),
+		opt->longName);
+    else if (opt->shortName != '\0') 
+	sprintf(left, "-%c", opt->shortName);
+    else if (opt->longName)
+	sprintf(left, "%s%s",
+		((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "-" : "--"),
+		opt->longName);
+    if (!*left) goto out;
+    if (argDescrip) {
+	char * le = left + strlen(left);
+
+	if (opt->argInfo & POPT_ARGFLAG_OPTIONAL)
+	    *le++ = '[';
+
+	/* Choose type of output */
+	/*@-branchstate@*/
+	if (opt->argInfo & POPT_ARGFLAG_SHOW_DEFAULT) {
+	    defs = singleOptionDefaultValue(lineLength, opt, translation_domain);
+	    if (defs) {
+		char * t = malloc((help ? strlen(help) : 0) +
+				strlen(defs) + sizeof(" "));
+		if (t) {
+		    char * te = t;
+		    *te = '\0';
+		    if (help) {
+			strcpy(te, help);	te += strlen(te);
+		    }
+		    *te++ = ' ';
+		    strcpy(te, defs);
+		    defs = _free(defs);
+		}
+		defs = t;
+	    }
+	}
+	/*@=branchstate@*/
+
+	if (opt->argDescrip == NULL) {
+	    switch (opt->argInfo & POPT_ARG_MASK) {
+	    case POPT_ARG_NONE:
+		break;
+	    case POPT_ARG_VAL:
+	    {	long aLong = opt->val;
+		int ops = (opt->argInfo & POPT_ARGFLAG_LOGICALOPS);
+		int negate = (opt->argInfo & POPT_ARGFLAG_NOT);
+
+		/* Don't bother displaying typical values */
+		if (!ops && (aLong == 0L || aLong == 1L || aLong == -1L))
+		    break;
+		*le++ = '[';
+		switch (ops) {
+		case POPT_ARGFLAG_OR:
+		    *le++ = '|';
+		    /*@innerbreak@*/ break;
+		case POPT_ARGFLAG_AND:
+		    *le++ = '&';
+		    /*@innerbreak@*/ break;
+		case POPT_ARGFLAG_XOR:
+		    *le++ = '^';
+		    /*@innerbreak@*/ break;
+		default:
+		    /*@innerbreak@*/ break;
+		}
+		*le++ = '=';
+		if (negate) *le++ = '~';
+		/*@-formatconst@*/
+		sprintf(le, (ops ? "0x%lx" : "%ld"), aLong);
+		le += strlen(le);
+		/*@=formatconst@*/
+		*le++ = ']';
+	    }	break;
+	    case POPT_ARG_INT:
+	    case POPT_ARG_LONG:
+	    case POPT_ARG_FLOAT:
+	    case POPT_ARG_DOUBLE:
+	    case POPT_ARG_STRING:
+		*le++ = '=';
+		strcpy(le, argDescrip);		le += strlen(le);
+		break;
+	    default:
+		break;
+	    }
+	} else {
+	    *le++ = '=';
+	    strcpy(le, argDescrip);		le += strlen(le);
+	}
+	if (opt->argInfo & POPT_ARGFLAG_OPTIONAL)
+	    *le++ = ']';
+	*le = '\0';
+    }
+
+    if (help)
+	fprintf(fp,"  %-*s   ", maxLeftCol, left);
+    else {
+	fprintf(fp,"  %s\n", left); 
+	goto out;
+    }
+
+    left = _free(left);
+    if (defs) {
+	help = defs; defs = NULL;
+    }
+
+    helpLength = strlen(help);
+    while (helpLength > lineLength) {
+	const char * ch;
+	char format[10];
+
+	ch = help + lineLength - 1;
+	while (ch > help && !isspace(*ch)) ch--;
+	if (ch == help) break;		/* give up */
+	while (ch > (help + 1) && isspace(*ch)) ch--;
+	ch++;
+
+	sprintf(format, "%%.%ds\n%%%ds", (int) (ch - help), indentLength);
+	/*@-formatconst@*/
+	fprintf(fp, format, help, " ");
+	/*@=formatconst@*/
+	help = ch;
+	while (isspace(*help) && *help) help++;
+	helpLength = strlen(help);
+    }
+
+    if (helpLength) fprintf(fp, "%s\n", help);
+
+out:
+    /*@-dependenttrans@*/
+    defs = _free(defs);
+    /*@=dependenttrans@*/
+    left = _free(left);
+}
+
+/**
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ */
+static int maxArgWidth(const struct poptOption * opt,
+		       /*@null@*/ const char * translation_domain)
+	/*@*/
+{
+    int max = 0;
+    int len = 0;
+    const char * s;
+    
+    if (opt != NULL)
+    while (opt->longName || opt->shortName || opt->arg) {
+	if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
+	    if (opt->arg)	/* XXX program error */
+	    len = maxArgWidth(opt->arg, translation_domain);
+	    if (len > max) max = len;
+	} else if (!(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN)) {
+	    len = sizeof("  ")-1;
+	    if (opt->shortName != '\0') len += sizeof("-X")-1;
+	    if (opt->shortName != '\0' && opt->longName) len += sizeof(", ")-1;
+	    if (opt->longName) {
+		len += ((opt->argInfo & POPT_ARGFLAG_ONEDASH)
+			? sizeof("-")-1 : sizeof("--")-1);
+		len += strlen(opt->longName);
+	    }
+
+	    s = getArgDescrip(opt, translation_domain);
+	    if (s)
+		len += sizeof("=")-1 + strlen(s);
+	    if (opt->argInfo & POPT_ARGFLAG_OPTIONAL) len += sizeof("[]")-1;
+	    if (len > max) max = len;
+	}
+
+	opt++;
+    }
+    
+    return max;
+}
+
+/**
+ * Display popt alias and exec help.
+ * @param fp		output file handle
+ * @param items		alias/exec array
+ * @param nitems	no. of alias/exec entries
+ * @param translation_domain	translation domain
+ */
+static void itemHelp(FILE * fp,
+		/*@null@*/ poptItem items, int nitems, int left,
+		/*@null@*/ const char * translation_domain)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    poptItem item;
+    int i;
+
+    if (items != NULL)
+    for (i = 0, item = items; i < nitems; i++, item++) {
+	const struct poptOption * opt;
+	opt = &item->option;
+	if ((opt->longName || opt->shortName) && 
+	    !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN))
+	    singleOptionHelp(fp, left, opt, translation_domain);
+    }
+}
+
+/**
+ * @param fp		output file handle
+ * @param table		option(s)
+ * @param translation_domain	translation domain
+ */
+static void singleTableHelp(poptContext con, FILE * fp,
+		/*@null@*/ const struct poptOption * table, int left,
+		/*@null@*/ const char * translation_domain)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    const struct poptOption * opt;
+    const char *sub_transdom;
+
+    if (table == poptAliasOptions) {
+	itemHelp(fp, con->aliases, con->numAliases, left, NULL);
+	itemHelp(fp, con->execs, con->numExecs, left, NULL);
+	return;
+    }
+
+    if (table != NULL)
+    for (opt = table; (opt->longName || opt->shortName || opt->arg); opt++) {
+	if ((opt->longName || opt->shortName) && 
+	    !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN))
+	    singleOptionHelp(fp, left, opt, translation_domain);
+    }
+
+    if (table != NULL)
+    for (opt = table; (opt->longName || opt->shortName || opt->arg); opt++) {
+	if ((opt->argInfo & POPT_ARG_MASK) != POPT_ARG_INCLUDE_TABLE)
+	    continue;
+	sub_transdom = getTableTranslationDomain(opt->arg);
+	if (sub_transdom == NULL)
+	    sub_transdom = translation_domain;
+	    
+	if (opt->descrip)
+	    fprintf(fp, "\n%s\n", D_(sub_transdom, opt->descrip));
+
+	singleTableHelp(con, fp, opt->arg, left, sub_transdom);
+    }
+}
+
+/**
+ * @param con		context
+ * @param fp		output file handle
+ */
+static int showHelpIntro(poptContext con, FILE * fp)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    int len = 6;
+    const char * fn;
+
+    fprintf(fp, POPT_("Usage:"));
+    if (!(con->flags & POPT_CONTEXT_KEEP_FIRST)) {
+	/*@-nullderef@*/	/* LCL: wazzup? */
+	fn = con->optionStack->argv[0];
+	/*@=nullderef@*/
+	if (fn == NULL) return len;
+	if (strchr(fn, '/')) fn = strrchr(fn, '/') + 1;
+	fprintf(fp, " %s", fn);
+	len += strlen(fn) + 1;
+    }
+
+    return len;
+}
+
+void poptPrintHelp(poptContext con, FILE * fp, /*@unused@*/ int flags)
+{
+    int leftColWidth;
+
+    (void) showHelpIntro(con, fp);
+    if (con->otherHelp)
+	fprintf(fp, " %s\n", con->otherHelp);
+    else
+	fprintf(fp, " %s\n", POPT_("[OPTION...]"));
+
+    leftColWidth = maxArgWidth(con->options, NULL);
+    singleTableHelp(con, fp, con->options, leftColWidth, NULL);
+}
+
+/**
+ * @param fp		output file handle
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ */
+static int singleOptionUsage(FILE * fp, int cursor, 
+		const struct poptOption * opt,
+		/*@null@*/ const char *translation_domain)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    int len = 3;
+    char shortStr[2] = { '\0', '\0' };
+    const char * item = shortStr;
+    const char * argDescrip = getArgDescrip(opt, translation_domain);
+
+    if (opt->shortName!= '\0' ) {
+	if (!(opt->argInfo & POPT_ARG_MASK)) 
+	    return cursor;	/* we did these already */
+	len++;
+	shortStr[0] = opt->shortName;
+	shortStr[1] = '\0';
+    } else if (opt->longName) {
+	len += 1 + strlen(opt->longName);
+	item = opt->longName;
+    }
+
+    if (len == 3) return cursor;
+
+    if (argDescrip) 
+	len += strlen(argDescrip) + 1;
+
+    if ((cursor + len) > 79) {
+	fprintf(fp, "\n       ");
+	cursor = 7;
+    } 
+
+    fprintf(fp, " [-%s%s%s%s]",
+	((opt->shortName || (opt->argInfo & POPT_ARGFLAG_ONEDASH)) ? "" : "-"),
+	item,
+	(argDescrip ? (opt->shortName != '\0' ? " " : "=") : ""),
+	(argDescrip ? argDescrip : ""));
+
+    return cursor + len + 1;
+}
+
+/**
+ * Display popt alias and exec usage.
+ * @param fp		output file handle
+ * @param item		alias/exec array
+ * @param nitems	no. of ara/exec entries
+ * @param translation_domain	translation domain
+ */
+static int itemUsage(FILE * fp, int cursor, poptItem item, int nitems,
+		/*@null@*/ const char * translation_domain)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    int i;
+
+    /*@-branchstate@*/		/* FIX: W2DO? */
+    if (item != NULL)
+    for (i = 0; i < nitems; i++, item++) {
+	const struct poptOption * opt;
+	opt = &item->option;
+        if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INTL_DOMAIN) {
+	    translation_domain = (const char *)opt->arg;
+	} else if ((opt->longName || opt->shortName) &&
+		 !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN)) {
+	    cursor = singleOptionUsage(fp, cursor, opt, translation_domain);
+	}
+    }
+    /*@=branchstate@*/
+
+    return cursor;
+}
+
+/**
+ * @param fp		output file handle
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ */
+static int singleTableUsage(poptContext con, FILE * fp,
+		int cursor, const struct poptOption * opt,
+		/*@null@*/ const char * translation_domain)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    /*@-branchstate@*/		/* FIX: W2DO? */
+    if (opt != NULL)
+    for (; (opt->longName || opt->shortName || opt->arg) ; opt++) {
+        if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INTL_DOMAIN) {
+	    translation_domain = (const char *)opt->arg;
+	} else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
+	    if (opt->arg)	/* XXX program error */
+	    cursor = singleTableUsage(con, fp, cursor, opt->arg,
+			translation_domain);
+	} else if ((opt->longName || opt->shortName) &&
+		 !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN)) {
+	    cursor = singleOptionUsage(fp, cursor, opt, translation_domain);
+	}
+    }
+    /*@=branchstate@*/
+
+    return cursor;
+}
+
+/**
+ * Return concatenated short options for display.
+ * @param opt		option(s)
+ * @param fp		output file handle
+ * @retval str		concatenation of short options
+ * @return		length of display string
+ */
+static int showShortOptions(const struct poptOption * opt, FILE * fp,
+		/*@null@*/ char * str)
+	/*@globals fileSystem @*/
+	/*@modifies *str, *fp, fileSystem @*/
+{
+    char * s = alloca(300);	/* larger then the ascii set */
+
+    s[0] = '\0';
+    /*@-branchstate@*/		/* FIX: W2DO? */
+    if (str == NULL) {
+	memset(s, 0, sizeof(s));
+	str = s;
+    }
+    /*@=branchstate@*/
+
+    if (opt != NULL)
+    for (; (opt->longName || opt->shortName || opt->arg); opt++) {
+	if (opt->shortName && !(opt->argInfo & POPT_ARG_MASK))
+	    str[strlen(str)] = opt->shortName;
+	else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE)
+	    if (opt->arg)	/* XXX program error */
+		(void) showShortOptions(opt->arg, fp, str);
+    } 
+
+    if (s != str || *s != '\0')
+	return 0;
+
+    fprintf(fp, " [-%s]", s);
+    return strlen(s) + 4;
+}
+
+void poptPrintUsage(poptContext con, FILE * fp, /*@unused@*/ int flags)
+{
+    int cursor;
+
+    cursor = showHelpIntro(con, fp);
+    cursor += showShortOptions(con->options, fp, NULL);
+    (void) singleTableUsage(con, fp, cursor, con->options, NULL);
+    (void) itemUsage(fp, cursor, con->aliases, con->numAliases, NULL);
+    (void) itemUsage(fp, cursor, con->execs, con->numExecs, NULL);
+
+    if (con->otherHelp) {
+	cursor += strlen(con->otherHelp) + 1;
+	if (cursor > 79) fprintf(fp, "\n       ");
+	fprintf(fp, " %s", con->otherHelp);
+    }
+
+    fprintf(fp, "\n");
+}
+
+void poptSetOtherOptionHelp(poptContext con, const char * text)
+{
+    con->otherHelp = _free(con->otherHelp);
+    con->otherHelp = xstrdup(text);
+}
+/*@=type@*/

popt/poptint.h

@@ -0,0 +1,96 @@
+/** \ingroup popt
+ * \file popt/poptint.h
+ */
+
+/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#ifndef H_POPTINT
+#define H_POPTINT
+
+/**
+ * Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
+ * @param p		memory to free
+ * @retval		NULL always
+ */
+/*@unused@*/ static inline /*@null@*/ void *
+_free(/*@only@*/ /*@null@*/ const void * p)
+	/*@modifies p @*/
+{
+    if (p != NULL)	free((void *)p);
+    return NULL;
+}
+
+/* Bit mask macros. */
+typedef	unsigned int __pbm_bits;
+#define	__PBM_NBITS		(8 * sizeof (__pbm_bits))
+#define	__PBM_IX(d)		((d) / __PBM_NBITS)
+#define __PBM_MASK(d)		((__pbm_bits) 1 << (((unsigned)(d)) % __PBM_NBITS))
+typedef struct {
+    __pbm_bits bits[1];
+} pbm_set;
+#define	__PBM_BITS(set)	((set)->bits)
+
+#define	PBM_ALLOC(d)	calloc(__PBM_IX (d) + 1, sizeof(__pbm_bits))
+#define	PBM_FREE(s)	_free(s);
+#define PBM_SET(d, s)   (__PBM_BITS (s)[__PBM_IX (d)] |= __PBM_MASK (d))
+#define PBM_CLR(d, s)   (__PBM_BITS (s)[__PBM_IX (d)] &= ~__PBM_MASK (d))
+#define PBM_ISSET(d, s) ((__PBM_BITS (s)[__PBM_IX (d)] & __PBM_MASK (d)) != 0)
+
+struct optionStackEntry {
+    int argc;
+/*@only@*/ /*@null@*/ const char ** argv;
+/*@only@*/ /*@null@*/ pbm_set * argb;
+    int next;
+/*@only@*/ /*@null@*/ const char * nextArg;
+/*@keep@*/ /*@null@*/ const char * nextCharArg;
+/*@dependent@*/ /*@null@*/ poptItem currAlias;
+    int stuffed;
+};
+
+struct poptContext_s {
+    struct optionStackEntry optionStack[POPT_OPTION_DEPTH];
+/*@dependent@*/ struct optionStackEntry * os;
+/*@owned@*/ /*@null@*/ const char ** leftovers;
+    int numLeftovers;
+    int nextLeftover;
+/*@keep@*/ const struct poptOption * options;
+    int restLeftover;
+/*@only@*/ /*@null@*/ const char * appName;
+/*@only@*/ /*@null@*/ poptItem aliases;
+    int numAliases;
+    int flags;
+/*@owned@*/ /*@null@*/ poptItem execs;
+    int numExecs;
+/*@only@*/ /*@null@*/ const char ** finalArgv;
+    int finalArgvCount;
+    int finalArgvAlloced;
+/*@dependent@*/ /*@null@*/ poptItem doExec;
+/*@only@*/ const char * execPath;
+    int execAbsolute;
+/*@only@*/ const char * otherHelp;
+/*@null@*/ pbm_set * arg_strip;
+};
+
+#ifdef HAVE_LIBINTL_H
+#include <libintl.h>
+#endif
+
+#if defined(HAVE_GETTEXT) && !defined(__LCLINT__)
+#define _(foo) gettext(foo)
+#else
+#define _(foo) foo
+#endif
+
+#if defined(HAVE_DGETTEXT) && !defined(__LCLINT__)
+#define D_(dom, str) dgettext(dom, str)
+#define POPT_(foo) D_("popt", foo)
+#else
+#define D_(dom, str) str
+#define POPT_(foo) foo
+#endif
+
+#define N_(foo) foo
+
+#endif

popt/poptparse.c

@@ -0,0 +1,118 @@
+/** \ingroup popt
+ * \file popt/poptparse.c
+ */
+
+/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#include "system.h"
+
+#define POPT_ARGV_ARRAY_GROW_DELTA 5
+
+int poptDupArgv(int argc, const char **argv,
+		int * argcPtr, const char *** argvPtr)
+{
+    size_t nb = (argc + 1) * sizeof(*argv);
+    const char ** argv2;
+    char * dst;
+    int i;
+
+    if (argc <= 0 || argv == NULL)	/* XXX can't happen */
+	return POPT_ERROR_NOARG;
+    for (i = 0; i < argc; i++) {
+	if (argv[i] == NULL)
+	    return POPT_ERROR_NOARG;
+	nb += strlen(argv[i]) + 1;
+    }
+	
+    dst = malloc(nb);
+    if (dst == NULL)			/* XXX can't happen */
+	return POPT_ERROR_MALLOC;
+    argv2 = (void *) dst;
+    dst += (argc + 1) * sizeof(*argv);
+
+    /*@-branchstate@*/
+    for (i = 0; i < argc; i++) {
+	argv2[i] = dst;
+	dst += strlen(strcpy(dst, argv[i])) + 1;
+    }
+    /*@=branchstate@*/
+    argv2[argc] = NULL;
+
+    if (argvPtr) {
+	*argvPtr = argv2;
+    } else {
+	free(argv2);
+	argv2 = NULL;
+    }
+    if (argcPtr)
+	*argcPtr = argc;
+    return 0;
+}
+
+int poptParseArgvString(const char * s, int * argcPtr, const char *** argvPtr)
+{
+    const char * src;
+    char quote = '\0';
+    int argvAlloced = POPT_ARGV_ARRAY_GROW_DELTA;
+    const char ** argv = malloc(sizeof(*argv) * argvAlloced);
+    int argc = 0;
+    int buflen = strlen(s) + 1;
+    char * buf = memset(alloca(buflen), 0, buflen);
+    int rc = POPT_ERROR_MALLOC;
+
+    if (argv == NULL) return rc;
+    argv[argc] = buf;
+
+    for (src = s; *src != '\0'; src++) {
+	if (quote == *src) {
+	    quote = '\0';
+	} else if (quote != '\0') {
+	    if (*src == '\\') {
+		src++;
+		if (!*src) {
+		    rc = POPT_ERROR_BADQUOTE;
+		    goto exit;
+		}
+		if (*src != quote) *buf++ = '\\';
+	    }
+	    *buf++ = *src;
+	} else if (isspace(*src)) {
+	    if (*argv[argc] != '\0') {
+		buf++, argc++;
+		if (argc == argvAlloced) {
+		    argvAlloced += POPT_ARGV_ARRAY_GROW_DELTA;
+		    argv = realloc(argv, sizeof(*argv) * argvAlloced);
+		    if (argv == NULL) goto exit;
+		}
+		argv[argc] = buf;
+	    }
+	} else switch (*src) {
+	  case '"':
+	  case '\'':
+	    quote = *src;
+	    /*@switchbreak@*/ break;
+	  case '\\':
+	    src++;
+	    if (!*src) {
+		rc = POPT_ERROR_BADQUOTE;
+		goto exit;
+	    }
+	    /*@fallthrough@*/
+	  default:
+	    *buf++ = *src;
+	    /*@switchbreak@*/ break;
+	}
+    }
+
+    if (strlen(argv[argc])) {
+	argc++, buf++;
+    }
+
+    rc = poptDupArgv(argc, argv, argcPtr, argvPtr);
+
+exit:
+    if (argv) free(argv);
+    return rc;
+}

popt/system.h

@@ -0,0 +1,73 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+
+#if HAVE_MCHECK_H 
+#include <mcheck.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef __NeXT
+/* access macros are not declared in non posix mode in unistd.h -
+ don't try to use posix on NeXTstep 3.3 ! */
+#include <libc.h>
+#endif
+
+#if defined(__LCLINT__)
+/*@-declundef -incondefs -redecl@*/ /* LCL: missing annotation */
+/*@only@*/ void * alloca (size_t __size)
+	/*@ensures MaxSet(result) == (__size - 1) @*/
+	/*@*/;
+/*@=declundef =incondefs =redecl@*/
+#endif
+
+/* AIX requires this to be the first thing in the file.  */ 
+#ifndef __GNUC__
+# if HAVE_ALLOCA_H
+#  include <alloca.h>
+# else
+#  ifdef _AIX
+#pragma alloca
+#  else
+#   if HAVE_ALLOCA
+#    ifndef alloca /* predefined by HP cc +Olibcalls */
+char *alloca ();
+#    endif
+#   else
+#    ifdef alloca
+#     undef alloca
+#    endif
+#    define alloca(sz) malloc(sz) /* Kludge this for now */
+#   endif
+#  endif
+# endif
+#elif defined(__GNUC__) && defined(__STRICT_ANSI__)
+#define alloca __builtin_alloca
+#endif
+
+/*@-redecl -redef@*/
+/*@mayexit@*/ /*@only@*/ char * xstrdup (const char *str)
+	/*@*/;
+/*@=redecl =redef@*/
+
+#if HAVE_MCHECK_H && defined(__GNUC__)
+#define	vmefail()	(fprintf(stderr, "virtual memory exhausted.\n"), exit(EXIT_FAILURE), NULL)
+#define xstrdup(_str)   (strcpy((malloc(strlen(_str)+1) ? : vmefail()), (_str)))
+#else
+#define	xstrdup(_str)	strdup(_str)
+#endif  /* HAVE_MCHECK_H && defined(__GNUC__) */
+
+
+#include "popt.h"

progress.c

@@ -0,0 +1,121 @@
+/*  -*- c-file-style: "linux" -*-
+ * 
+ * Copyright (C) 1996-2000 by Andrew Tridgell 
+ * Copyright (C) Paul Mackerras 1996
+ * 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.
+ */
+
+#include "rsync.h"
+
+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;
+    /* If we've finished transferring this file, show the time taken;
+     * otherwise show expected time to complete.  That's kind of
+     * inconsistent, but people can probably cope.  Hopefully we'll
+     * get more consistent and complete progress reporting soon. --
+     * mbp */
+    double        remain = is_last
+                        ? (double) diff / 1000.0
+                        : 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 am_server;
+
+	if (!am_server) {
+		struct timeval now;
+		gettimeofday(&now, NULL);
+		rprint_progress(size, size, &now, True);
+	}
+	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 am_server;
+	struct timeval now;
+
+	if (!start_time.tv_sec) {
+		gettimeofday(&now, NULL);
+		start_time.tv_sec  = now.tv_sec;
+		start_time.tv_usec = now.tv_usec;
+		start_ofs          = ofs;
+		if (am_server)
+			return;
+	}
+	else {
+		if (am_server)
+			return;
+		gettimeofday(&now, NULL);
+	}
+
+	if (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;
+	}
+}

receiver.c

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

rsync.h

@@ -1,6 +1,7 @@
 /* 
-   Copyright (C) Andrew Tridgell 1996
+   Copyright (C) by Andrew Tridgell 1996, 2000
    Copyright (C) Paul Mackerras 1996
+   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
@@ -17,14 +18,24 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
+
+#define False 0
+#define True 1
+
 #define BLOCK_SIZE 700
 #define RSYNC_RSH_ENV "RSYNC_RSH"
 
 #define RSYNC_NAME "rsync"
+#define RSYNCD_SYSCONF "/etc/rsyncd.conf"
+#define RSYNCD_USERCONF "rsyncd.conf"
+
+#define DEFAULT_LOCK_FILE "/var/run/rsyncd.lock"
+#define URL_PREFIX "rsync://"
+
 #define BACKUP_SUFFIX "~"
 
 /* a non-zero CHAR_OFFSET makes the rolling sum stronger, but is
-   imcompatible with older versions :-( */
+   incompatible with older versions :-( */
 #define CHAR_OFFSET 0
 
 
@@ -39,33 +50,53 @@
 #define SAME_TIME (1<<7)
 
 /* update this if you make incompatible changes */
-#define PROTOCOL_VERSION 17
-#define MIN_PROTOCOL_VERSION 11
+#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
+ * people writing them to make sure that they don't send us anything
+ * we won't understand.
+ *
+ * There are two possible explanations for the limit at thirty: either
+ * to allow new major-rev versions that do not interoperate with us,
+ * and (more likely) so that we can detect an attempt to connect rsync
+ * to a non-rsync server, which is unlikely to begin by sending a byte
+ * between 15 and 30. */
+#define MIN_PROTOCOL_VERSION 15
 #define MAX_PROTOCOL_VERSION 30
 
+#define RSYNC_PORT 873
+
 #define SPARSE_WRITE_SIZE (1024)
 #define WRITE_SIZE (32*1024)
 #define CHUNK_SIZE (32*1024)
-#define MAX_MAP_SIZE (4*1024*1024)
+#define MAX_MAP_SIZE (256*1024)
+#define IO_BUFFER_SIZE (4092)
 
-#define BLOCKING_TIMEOUT 10
+#define MAX_ARGS 1000
 
-#define FERROR stderr
-#define FINFO (am_server?stderr:stdout)
+#define MPLEX_BASE 7
+
+/* Log values.  I *think* what these mean is: FLOG goes to the server
+ * logfile; FERROR and FINFO try to end up on the client, with
+ * different levels of filtering. */
+enum logcode {FNONE=0, FERROR=1, FINFO=2, FLOG=3 };
+
+#include "errcode.h"
 
 #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>
+
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #include <stdio.h>
+#include <stddef.h>
 
 #ifdef HAVE_SYS_PARAM_H
 #include <sys/param.h>
@@ -83,10 +114,6 @@
 #include <string.h>
 #endif
 
-#ifdef HAVE_COMPAT_H
-#include <compat.h>
-#endif
-
 #ifdef HAVE_MALLOC_H
 #include <malloc.h>
 #endif
@@ -132,10 +159,6 @@
 #endif
 #include <errno.h>
 
-#ifdef HAVE_MMAP
-#include <sys/mman.h>
-#endif
-
 #ifdef HAVE_UTIME_H
 #include <utime.h>
 #endif
@@ -157,133 +180,24 @@
 #include "lib/fnmatch.h"
 #endif
 
-#ifdef HAVE_GETOPT_LONG
-#include <getopt.h>
-#else
-#include "lib/getopt.h"
+#ifdef HAVE_GLOB_H
+#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>
 
-#ifndef S_IFLNK
-#define S_IFLNK  0120000
-#endif
-
-#ifndef S_ISLNK
-#define S_ISLNK(mode) (((mode) & S_IFLNK) == S_IFLNK)
-#endif
-
-#ifndef uchar
-#define uchar unsigned char
-#endif
-
-#ifndef int32
-#if (SIZEOF_INT == 4)
-#define int32 int
-#elif (SIZEOF_LONG == 4)
-#define int32 long
-#elif (SIZEOF_SHORT == 4)
-#define int32 short
-#endif
-#endif
-
-#ifndef uint32
-#define uint32 unsigned int32
-#endif
-
-#ifdef HAVE_LONGLONG
-#define int64 long long
-#else
-#define int64 off_t
-#endif
-
-#ifndef MIN
-#define MIN(a,b) ((a)<(b)?(a):(b))
-#endif
-
-#ifndef MAX
-#define MAX(a,b) ((a)>(b)?(a):(b))
-#endif
-
-/* the length of the md4 checksum */
-#define MD4_SUM_LENGTH 16
-#define SUM_LENGTH 16
-
-#ifndef MAXPATHLEN
-#define MAXPATHLEN 1024
-#endif
-
-struct file_struct {
-	unsigned flags;
-	time_t modtime;
-	off_t length;
-	mode_t mode;
-	ino_t inode;
-	dev_t dev;
-	dev_t rdev;
-	uid_t uid;
-	gid_t gid;
-	char *basename;
-	char *dirname;
-	char *basedir;
-	char *link;
-	char *sum;
-};
-
-struct file_list {
-  int count;
-  int malloced;
-  struct file_struct **files;
-};
-
-struct sum_buf {
-  off_t offset;			/* offset in file of this chunk */
-  int len;			/* length of chunk of file */
-  int i;			/* index of this chunk */
-  uint32 sum1;	                /* simple checksum */
-  char sum2[SUM_LENGTH];	/* checksum  */
-};
-
-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 */
-};
-
-struct map_struct {
-	char *map,*p;
-	int fd,p_size,p_len;
-	off_t size, p_offset;
-};
-
-/* we need this function because of the silly way in which duplicate
-   entries are handled in the file lists - we can't change this
-   without breaking existing versions */
-static inline int flist_up(struct file_list *flist, int i)
-{
-	while (!flist->files[i]->basename) i++;
-	return i;
-}
-
-
-#include "byteorder.h"
-#include "version.h"
-#include "proto.h"
-#include "md4.h"
-
-#if !HAVE_STRERROR
-extern char *sys_errlist[];
-#define strerror(i) sys_errlist[i]
-#endif
-
-#ifndef HAVE_STRCHR
-# define strchr                 index
-# define strrchr                rindex
-#endif
+#include <stdarg.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <syslog.h>
+#include <sys/file.h>
 
 #if HAVE_DIRENT_H
 # include <dirent.h>
@@ -300,21 +214,263 @@ extern char *sys_errlist[];
 # endif
 #endif
 
+#ifdef HAVE_COMPAT_H
+#include <compat.h>
+#endif
+
+#include <assert.h>
+
+
+#define BOOL int
+
+#ifndef uchar
+#define uchar unsigned char
+#endif
+
+#if HAVE_UNSIGNED_CHAR
+#define schar signed char
+#else
+#define schar char
+#endif
+
+#ifndef int32
+#if (SIZEOF_INT == 4)
+#define int32 int
+#elif (SIZEOF_LONG == 4)
+#define int32 long
+#elif (SIZEOF_SHORT == 4)
+#define int32 short
+#else
+/* I hope this works */
+#define int32 int
+#define LARGE_INT32
+#endif
+#endif
+
+#ifndef uint32
+#define uint32 unsigned int32
+#endif
+
+#if HAVE_OFF64_T
+#define OFF_T off64_t
+#define STRUCT_STAT struct stat64
+#else
+#define OFF_T off_t
+#define STRUCT_STAT struct stat
+#endif
+
+#if HAVE_OFF64_T
+#define int64 off64_t
+#elif (SIZEOF_LONG == 8) 
+#define int64 long
+#elif (SIZEOF_INT == 8) 
+#define int64 int
+#elif HAVE_LONGLONG
+#define int64 long long
+#else
+/* As long as it gets... */
+#define int64 off_t
+#define NO_INT64
+#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))
+#endif
+
+#ifndef MAX
+#define MAX(a,b) ((a)>(b)?(a):(b))
+#endif
+
+#ifndef MAXHOSTNAMELEN
+#define MAXHOSTNAMELEN 256
+#endif
+
+/* the length of the md4 checksum */
+#define MD4_SUM_LENGTH 16
+#define SUM_LENGTH 16
+
+#ifndef MAXPATHLEN
+#define MAXPATHLEN 1024
+#endif
+
+#ifndef INADDR_NONE
+#define INADDR_NONE 0xffffffff
+#endif
+
+#ifndef IN_LOOPBACKNET
+#define IN_LOOPBACKNET 127
+#endif
+
+struct file_struct {
+	unsigned flags;
+	time_t modtime;
+	OFF_T length;
+	mode_t mode;
+
+	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;
+	char *dirname;
+	char *basedir;
+	char *link;
+	char *sum;
+};
+
+
+#define ARENA_SIZE	(32 * 1024)
+
+struct string_area {
+	char *base;
+	char *end;
+	char *current;
+	struct string_area *next;
+};
+
+struct file_list {
+	int count;
+	int malloced;
+	struct file_struct **files;
+	struct string_area *string_area;
+};
+
+struct sum_buf {
+	OFF_T offset;		/**< offset in file of this chunk */
+	int len;		/**< length of chunk of file */
+	int i;			/**< index of this chunk */
+	uint32 sum1;	        /**< simple checksum */
+	char sum2[SUM_LENGTH];	/**< checksum  */
+};
+
+struct sum_struct {
+	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 {
+	char *p;
+	int fd,p_size,p_len;
+	OFF_T file_size, p_offset, p_fd_offset;
+};
+
+struct exclude_struct {
+	char *pattern;
+	int regular_exp;
+	int fnmatch_flags;
+	int include;
+	int directory;
+	int local;
+};
+
+struct stats {
+	int64 total_size;
+	int64 total_transferred_size;
+	int64 total_written;
+	int64 total_read;
+	int64 literal_data;
+	int64 matched_data;
+	int flist_size;
+	int num_files;
+	int num_transferred_files;
+};
+
+
+/* we need this function because of the silly way in which duplicate
+   entries are handled in the file lists - we can't change this
+   without breaking existing versions */
+static inline int flist_up(struct file_list *flist, int i)
+{
+	while (!flist->files[i]->basename) i++;
+	return i;
+}
+
+#include "byteorder.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
+int asprintf(char **ptr, const char *format, ...);
+#endif
+
+#ifndef HAVE_VASPRINTF
+int vasprintf(char **ptr, const char *format, va_list ap);
+#endif
+
+#if !defined(HAVE_VSNPRINTF) && !defined(HAVE_C99_VSNPRINTF)
+int vsnprintf (char *str, size_t count, const char *fmt, va_list args);
+#endif
+
+#if !defined(HAVE_SNPRINTF) && !defined(HAVE_C99_VSNPRINTF)
+int snprintf(char *str,size_t count,const char *fmt,...);
+#endif
+
+
+#if !HAVE_STRERROR
+extern char *sys_errlist[];
+#define strerror(i) sys_errlist[i]
+#endif
+
+#ifndef HAVE_STRCHR
+# define strchr                 index
+# define strrchr                rindex
+#endif
+
 #ifndef HAVE_ERRNO_DECL
 extern int errno;
 #endif
 
-#ifndef HAVE_BCOPY
-#define bcopy(src,dest,n) memcpy(dest,src,n)
-#endif
-
-#ifndef HAVE_BZERO
-#define bzero(buf,n) memset(buf,0,n)
-#endif
-
 #define SUPPORT_LINKS HAVE_READLINK
 #define SUPPORT_HARD_LINKS HAVE_LINK
 
+/* 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
@@ -341,6 +497,18 @@ extern int errno;
 #define S_IWUSR 0200
 #endif
 
+#ifndef _S_IFMT
+#define _S_IFMT        0170000
+#endif
+
+#ifndef _S_IFLNK
+#define _S_IFLNK  0120000
+#endif
+
+#ifndef S_ISLNK
+#define S_ISLNK(mode) (((mode) & (_S_IFMT)) == (_S_IFLNK))
+#endif
+
 #ifndef S_ISBLK
 #define S_ISBLK(mode) (((mode) & (_S_IFMT)) == (_S_IFBLK))
 #endif
@@ -349,6 +517,22 @@ extern int errno;
 #define S_ISCHR(mode) (((mode) & (_S_IFMT)) == (_S_IFCHR))
 #endif
 
+#ifndef S_ISSOCK
+#ifdef _S_IFSOCK
+#define S_ISSOCK(mode) (((mode) & (_S_IFMT)) == (_S_IFSOCK))
+#else
+#define S_ISSOCK(mode) (0)
+#endif
+#endif
+
+#ifndef S_ISFIFO
+#ifdef _S_IFIFO
+#define S_ISFIFO(mode) (((mode) & (_S_IFMT)) == (_S_IFIFO))
+#else
+#define S_ISFIFO(mode) (0)
+#endif
+#endif
+
 #ifndef S_ISDIR
 #define S_ISDIR(mode) (((mode) & (_S_IFMT)) == (_S_IFDIR))
 #endif
@@ -357,5 +541,95 @@ extern int errno;
 #define S_ISREG(mode) (((mode) & (_S_IFMT)) == (_S_IFREG))
 #endif
 
-#define IS_DEVICE(mode) (S_ISCHR(mode) || S_ISBLK(mode))
+/* work out what fcntl flag to use for non-blocking */
+#ifdef O_NONBLOCK
+# define NONBLOCK_FLAG O_NONBLOCK
+#elif defined(SYSV)
+# define NONBLOCK_FLAG O_NDELAY
+#else 
+# define NONBLOCK_FLAG FNDELAY
+#endif
 
+#ifndef INADDR_LOOPBACK
+#define INADDR_LOOPBACK 0x7f000001
+#endif
+
+#ifndef INADDR_NONE
+#define INADDR_NONE 0xffffffff
+#endif
+
+#define IS_DEVICE(mode) (S_ISCHR(mode) || S_ISBLK(mode) || S_ISSOCK(mode) || S_ISFIFO(mode))
+
+#ifndef ACCESSPERMS
+#define ACCESSPERMS 0777
+#endif
+/* Initial mask on permissions given to temporary files.  Mask off setuid
+     bits and group access because of potential race-condition security
+     holes, and mask other access because mode 707 is bizarre */
+#define INITACCESSPERMS 0700
+
+/* handler for null strings in printf format */
+#define NS(s) ((s)?(s):"<NULL>")
+
+#if !defined(__GNUC__) || defined(APPLE)
+/* Apparently the OS X port of gcc gags on __attribute__.
+ *
+ * <http://www.opensource.apple.com/bugs/X/gcc/2512150.html> */
+#define __attribute__(x) 
+
+#endif
+
+/* Convenient wrappers for malloc and realloc.  Use them. */
+#define new(type) ((type *)malloc(sizeof(type)))
+#define new_array(type, num) ((type *)_new_array(sizeof(type), (num)))
+#define realloc_array(ptr, type, num) ((type *)_realloc_array((ptr), sizeof(type), (num)))
+
+/* use magic gcc attributes to catch format errors */
+ void rprintf(enum logcode , const char *, ...)
+     __attribute__((format (printf, 2, 3)))
+;
+
+/* This is just like rprintf, but it also tries to print some
+ * representation of the error code.  Normally errcode = errno. */
+void rsyserr(enum logcode, int, const char *, ...)
+     __attribute__((format (printf, 3, 4)))
+     ;
+
+#ifdef REPLACE_INET_NTOA
+#define inet_ntoa rep_inet_ntoa
+#endif
+
+
+#ifndef HAVE_STRLCPY
+size_t strlcpy(char *d, const char *s, size_t bufsize);
+#endif
+
+#ifndef HAVE_STRLCAT
+size_t strlcat(char *d, const char *s, size_t bufsize);
+#endif
+
+#ifndef WEXITSTATUS
+#define	WEXITSTATUS(stat)	((int)(((stat)>>8)&0xFF))
+#endif
+
+#define exit_cleanup(code) _exit_cleanup(code, __FILE__, __LINE__)
+
+
+extern int verbose;
+
+#ifndef HAVE_INET_NTOP
+const char *                 
+inet_ntop(int af, const void *src, char *dst, size_t size);
+#endif /* !HAVE_INET_NTOP */
+
+#ifndef HAVE_INET_PTON
+int inet_pton(int af, const char *src, void *dst);
+#endif
+
+#ifdef MAINTAINER_MODE
+const char *get_panic_action(void);
+#endif
+
+#define UNUSED(x) x __attribute__((__unused__))
+
+extern const char *io_write_phase, *io_read_phase;

rsync3.txt

@@ -0,0 +1,469 @@
+-*- indented-text -*-
+
+Notes towards a new version of rsync 
+Martin Pool <mbp@samba.org>, September 2001.
+
+
+Good things about the current implementation:
+
+  - Widely known and adopted.
+
+  - Fast/efficient, especially for moderately small sets of files over
+    slow links (transoceanic or modem.)
+
+  - Fairly reliable.
+
+  - The choice of runnning over a plain TCP socket or tunneling over
+    ssh.
+
+  - rsync operations are idempotent: you can always run the same
+    command twice to make sure it worked properly without any fear.
+    (Are there any exceptions?)
+
+  - Small changes to files cause small deltas.
+
+  - There is a way to evolve the protocol to some extent.
+
+  - rdiff and rsync --write-batch allow generation of standalone patch
+    sets.  rsync+ is pretty cheesy, though.  xdelta seems cleaner.
+
+  - Process triangle is creative, but seems to provoke OS bugs.
+
+  - "Morning-after property": you don't need to know anything on the
+    local machine about the state of the remote machine, or about
+    transfers that have been done in the past.
+
+  - You can easily push or pull simply by switching the order of
+    files.
+
+  - The "modules" system has some neat features compared to
+    e.g. Apache's per-directory configuration.  In particular, because
+    you can set a userid and chroot directory, there is strong
+    protection between different modules.  I haven't seen any calls
+    for a more flexible system.
+
+
+Bad things about the current implementation:
+
+  - Persistent and hard-to-diagnose hang bugs remain
+
+  - Protocol is sketchily documented, tied to this implementation, and
+    hard to modify/extend
+
+  - Both the program and the protocol assume a single non-interactive
+    one-way transfer 
+
+  - A list of all files are held in memory for the entire transfer,
+    which cripples scalability to large file trees
+
+  - Opening a new socket for every operation causes problems,
+    especially when running over SSH with password authentication.
+
+  - Renamed files are not handled: the old file is removed, and the
+    new file created from scratch.
+
+  - The versioning approach assumes that future versions of the
+    program know about all previous versions, and will do the right
+    thing.
+
+  - People always get confused about ':' vs '::'
+
+  - Error messages can be cryptic.
+
+  - Default behaviour is not intuitive: in too many cases rsync will
+    happily do nothing.  Perhaps -a should be the default?
+
+  - People get confused by trailing slashes, though it's hard to think
+    of another reasonable way to make this necessary distinction
+    between a directory and its contents.
+
+
+Protocol philosophy:
+
+   *The* big difference between protocols like HTTP, FTP, and NFS is
+    that their fundamental operations are "read this file", "delete
+    this file", and "make this directory", whereas rsync is "make this
+    directory like this one".
+
+
+Questionable features:
+
+  These are neat, but not necessarily clean or worth preserving.  
+
+  - The remote rsync can be wrapped by some other program, such as in
+    tridge's rsync-mail scripts.  The general feature of sending and
+    retrieving mail over rsync is good, but this is perhaps not the
+    right way to implement it.
+
+
+Desirable features:
+
+  These don't really require architectural changes; they're just
+  something to keep in mind.
+ 
+  - Synchronize ACLs and extended attributes
+
+  - Anonymous servers should be efficient
+
+  - Code should be portable to non-UNIX systems
+
+  - Should be possible to document the protocol in RFC form
+
+  - --dry-run option
+
+  - IPv6 support.  Pretty straightforward.
+
+  - Allow the basis and destination files to be different.  For
+    example, you could use this when you have a CD-ROM and want to
+    download an updated image onto a hard drive.
+
+  - Efficiently interrupt and restart a transfer.  We can write a
+    checkpoint file that says where we're up to in the filesystem.
+    Alternatively, as long as transfers are idempotent, we can just
+    restart the whole thing.  [NFSv4]
+
+  - Scripting support.  
+
+  - Propagate atimes and do not modify them.  This is very ugly on
+    Unix.  It might be better to try to add O_NOATIME to kernels, and
+    call that.
+
+  - Unicode.  Probably just use UTF-8 for everything.
+
+  - Open authentication system.  Can we use PAM?  Is SASL an adequate
+    mapping of PAM to the network, or useful in some other way?
+
+  - Resume interrupted transfers without the --partial flag.  We need
+    to leave the temporary file behind, and then know to use it.  This
+    leaves a risk of large temporary files accumulating, which is not
+    good.  Perhaps it should be off by default.
+
+  - tcpwrappers support.  Should be trivial; can already be done
+    through tcpd or inetd.
+
+  - Socks support built in.  It's not clear this is any better than
+    just linking against the socks library, though.
+
+  - When run over SSH, invoke with predictable command-line arguments,
+    so that people can restrict what commands sshd will run.  (Is this
+    really required?)
+
+  - Comparison mode: give a list of which files are new, gone, or
+    different.  Set return code depending on whether anything has
+    changed.
+
+  - Internationalized messages (gettext?)
+
+  - Optionally use real regexps rather than globs?
+
+  - Show overall progress.  Pretty hard to do, especially if we insist
+    on not scanning the directory tree up front.
+
+
+Regression testing:
+
+  - Support automatic testing.
+
+  - Have hard internal timeouts against hangs.
+
+  - Be deterministic.
+
+  - Measure performance.
+
+
+Hard links:
+
+  At the moment, we can recreate hard links, but it's a bit
+  inefficient: it depends on holding a list of all files in the tree.
+  Every time we see a file with a linkcount >1, we need to search for
+  another known name that has the same (fsid,inum) tuple.  We could do
+  that more efficiently by keeping a list of only files with
+  linkcount>1, and removing files from that list as all their names
+  become known.
+
+
+Command-line options:
+
+  We have rather a lot at the moment.  We might get more if the tool
+  becomes more flexible.  Do we need a .rc or configuration file?
+  That wouldn't really fit with its pattern of use: cp and tar don't
+  have them, though ssh does.
+
+
+Scripting issues:
+
+  - Perhaps support multiple scripting languages: candidates include
+    Perl, Python, Tcl, Scheme (guile?), sh, ...
+
+  - Simply running a subprocess and looking at its stdout/exit code
+    might be sufficient, though it could also be pretty slow if it's
+    called often.
+
+  - There are security issues about running remote code, at least if
+    it's not running in the users own account.  So we can either
+    disallow it, or use some kind of sandbox system.
+
+  - Python is a good language, but the syntax is not so good for
+    giving small fragments on the command line.
+
+  - Tcl is broken Lisp.
+
+  - Lots of sysadmins know Perl, though Perl can give some bizarre or
+    confusing errors.  The built in stat operators and regexps might
+    be useful.
+
+  - Sadly probably not enough people know Scheme.
+
+  - sh is hard to embed.
+
+
+Scripting hooks:
+
+  - Whether to transfer a file
+
+  - What basis file to use
+
+  - Logging
+  
+  - Whether to allow transfers (for public servers)
+
+  - Authentication
+
+  - Locking
+
+  - Cache
+
+  - Generating backup path/name.
+
+  - Post-processing of backups, e.g. to do compression.
+
+  - After transfer, before replacement: so that we can spit out a diff
+    of what was changed, or kick off some kind of reconciliation
+    process.
+
+
+VFS:
+
+  Rather than talking straight to the filesystem, rsyncd talks through
+  an internal API.  Samba has one.  Is it useful?
+
+  - Could be a tidy way to implement cached signatures.
+
+  - Keep files compressed on disk?
+
+
+Interactive interface:
+
+  - Something like ncFTP, or integration into GNOME-vfs.  Probably
+    hold a single socket connection open.
+
+  - Can either call us as a separate process, or as a library.
+
+  - The standalone process needs to produce output in a form easily
+    digestible by a calling program, like the --emacs feature some
+    have.  Same goes for output: rpm outputs a series of hash symbols,
+    which are easier for a GUI to handle than "\r30% complete"
+    strings.
+
+  - Yow!  emacs support.  (You could probably build that already, of
+    course.)  I'd like to be able to write a simple script on a remote
+    machine that rsyncs it to my workstation, edits it there, then
+    pushes it back up.
+
+
+Pie-in-the-sky features:
+
+  These might have a severe impact on the protocol, and are not
+  clearly in our core requirements.  It looks like in many of them
+  having scripting hooks will allow us 
+
+  - Transport over UDP multicast.  The hard part is handling multiple
+    destinations which have different basis files.  We can look at
+    multicast-TFTP for inspiration.
+
+  - Conflict resolution.  Possibly general scripting support will be
+    sufficient.
+
+  - Integrate with locking.  It's hard to see a good general solution,
+    because Unix systems have several locking mechanisms, and grabbing
+    the lock from programs that don't expect it could cause deadlocks,
+    timeouts, or other problems.  Scripting support might help.
+
+  - Replicate in place, rather than to a temporary file.  This is
+    dangerous in the case of interruption, and it also means that the
+    delta can't refer to blocks that have already been overwritten.
+    On the other hand we could semi-trivially do this at first by
+    simply generating a delta with no copy instructions.
+
+  - Replicate block devices.  Most of the difficulties here are to do
+    with replication in place, though on some systems we will also
+    have to do I/O on block boundaries.
+
+  - Peer to peer features.  Flavour of the year.  Can we think about
+    ways for clients to smoothly and voluntarily become servers for
+    content they receive?
+
+  - Imagine a situation where the destination has a much faster link
+    to the cloud than the source.  In this case, Mojo Nation downloads
+    interleaved blocks from several slower servers.  The general
+    situation might be a way for a master rsync process to farm out
+    tasks to several subjobs.  In this particular case they'd need
+    different sockets.  This might be related to multicast.
+
+
+Unlikely features:
+
+  - Allow remote source and destination.  If this can be cleanly
+    designed into the protocol, perhaps with the remote machine acting
+    as a kind of echo, then it's good.  It's uncommon enough that we
+    don't want to shape the whole protocol around it, though.
+
+    In fact, in a triangle of machines there are two possibilities:
+    all traffic passes from remote1 to remote2 through local, or local
+    just sets up the transfer and then remote1 talks to remote2.  FTP
+    supports the second but it's not clearly good.  There are some
+    security problems with being able to instruct one machine to open
+    a connection to another.
+
+
+In favour of evolving the protocol:
+
+  - Keeping compatibility with existing rsync servers will help with
+    adoption and testing.
+
+  - We should at the very least be able to fall back to the new
+    protocol.
+
+  - Error handling is not so good.
+
+
+In favour of using a new protocol:
+
+  - Maintaining compatibility might soak up development time that
+    would better go into improving a new protocol.
+
+  - If we start from scratch, it can be documented as we go, and we
+    can avoid design decisions that make the protocol complex or
+    implementation-bound. 
+
+
+Error handling:
+
+  - Errors should come back reliably, and be clearly associated with
+    the particular file that caused the problem.
+
+  - Some errors ought to cause the whole transfer to abort; some are
+    just warnings.  If any errors have occurred, then rsync ought to
+    return an error.
+
+
+Concurrency:
+
+  - We want to keep the CPU, filesystem, and network as full as
+    possible as much of the time as possible.
+
+  - We can do nonblocking network IO, but not so for disk.
+
+  - It makes sense to on the destination be generating signatures and
+    applying patches at the same time. 
+
+  - Can structure this with nonblocking, threads, separate processes,
+    etc.
+
+
+Uses:
+
+  - Mirroring software distributions:
+
+  - Synchronizing laptop and desktop
+
+  - NFS filesystem migration/replication.  See
+    http://www.ietf.org/proceedings/00jul/00july-133.htm#P24510_1276764
+
+  - Sync with PDA
+ 
+  - Network backup systems
+
+  - CVS filemover
+
+
+Conflict resolution:
+
+  - Requires application-specific knowledge.  We want to provide
+    policy, rather than mechanism.
+
+  - Possibly allowing two-way migration across a single connection
+    would be useful.
+
+
+Moved files: <http://rsync.samba.org/cgi-bin/rsync.fom?file=44>
+
+  - There's no trivial way to detect renamed files, especially if they
+    move between directories.
+
+  - If we had a picture of the remote directory from last time on
+    either machine, then the inode numbers might give us a hint about
+    files which may have been renamed.
+
+  - Files that are renamed and not modified can be detected by
+    examining the directory listing, looking for files with the same
+    size/date as the origin.
+
+
+Filesystem migration:
+
+  NFSv4 probably wants to migrate file locks, but that's not really
+  our problem.
+
+
+Atomic updates:
+
+  The NFSv4 working group wants atomic migration.  Most of the
+  responsibility for this lies on the NFS server or OS.  
+
+  If migrating a whole tree, then we could do a nearly-atomic rename
+  at the end.  This ties in to having separate basis and destination
+  files.
+
+  There's no way in Unix to replace a whole set of files atomically.
+  However, if we get them all onto the destination machine and then do
+  the updates quickly it would greatly reduce the window.  
+
+
+Scalability:
+ 
+  We should aim to work well on machines in use in a year or two.
+  That probably means transfers of many millions of files in one
+  batch, and gigabytes or terabytes of data.
+
+  For argument's sake: at the low end, we want to sync ten files for a
+  total of 10kb across a 1kB/s link.  At the high end, we want to sync
+  1e9 files for 1TB of data across a 1GB/s link.
+
+  On the whole CPU usage is not normally a limiting factor, if only
+  because running over SSH burns a lot of cycles on encryption.
+
+  Perhaps have resource throttling without relying on rlimit.
+
+
+Streaming:
+
+  A big attraction of rsync is that there are few round-trip delays:
+  basically only one to get started, and then everything is
+  pipelined.  This is a problem with FTP, and NFS (at least up to
+  v3).  NFSv4 can pipeline operations, but building on that is
+  probably a bit complicated.
+
+
+Related work:
+
+  - mirror.pl http://freshmeat.net/project/mirror/
+
+  - ProFTPd
+
+  - Apache
+
+  - http://freshmeat.net/search/?site=Freshmeat&q=mirror&section=projects
+
+  - BitTorrent -- p2p mirroring
+    http://bitconjurer.org/BitTorrent/ 

rsyncd.conf.yo

@@ -0,0 +1,500 @@
+mailto(rsync-bugs@samba.org)
+manpage(rsyncd.conf)(5)(26 Jan 2003)()()
+manpagename(rsyncd.conf)(configuration file for rsync server)
+manpagesynopsis()
+
+rsyncd.conf
+
+manpagedescription()
+
+The rsyncd.conf file is the runtime configuration file for rsync when
+run as an rsync server. 
+
+The rsyncd.conf file controls authentication, access, logging and
+available modules.
+
+manpagesection(FILE FORMAT)
+
+The file consists of modules and parameters. A module begins with the 
+name of the module in square brackets and continues until the next
+module begins. Modules contain parameters of the form 'name = value'.
+
+The file is line-based - that is, each newline-terminated line represents
+either a comment, a module name or a parameter.
+
+Only the first equals sign in a parameter is significant. Whitespace before 
+or after the first equals sign is discarded. Leading, trailing and internal
+whitespace in module and parameter names is irrelevant. Leading and
+trailing whitespace in a parameter value is discarded. Internal whitespace
+within a parameter value is retained verbatim.
+
+Any line beginning with a hash (#) is ignored, as are lines containing 
+only whitespace.
+
+Any line ending in a \ is "continued" on the next line in the
+customary UNIX fashion.
+
+The values following the equals sign in parameters are all either a string
+(no quotes needed) or a boolean, which may be given as yes/no, 0/1 or
+true/false. Case is not significant in boolean values, but is preserved
+in string values. 
+
+manpagesection(LAUNCHING THE RSYNC DAEMON)
+
+The rsync daemon is launched by specifying the --daemon option to
+rsync. 
+
+The daemon must run with root privileges if you wish to use chroot, to
+bind to a port numbered under 1024 (as is the default 873), or to set
+file ownership.  Otherwise, it must just have permission to read and
+write the appropriate data, log, and lock files.
+
+You can launch it either via inetd, as a stand-alone daemon, or from
+an rsync client via a remote shell.  If run as a stand-alone daemon then
+just run the command "rsync --daemon" from a suitable startup script.
+If run from an rsync client via a remote shell (by specifying both the
+"-e/--rsh" option and server mode with "::" or "rsync://"), the --daemon
+option is automatically passed to the remote side.
+
+When run via inetd you should add a line like this to /etc/services:
+
+quote(rsync           873/tcp)
+
+and a single line something like this to /etc/inetd.conf:
+    
+quote(rsync   stream  tcp     nowait  root   /usr/bin/rsync rsyncd --daemon)
+
+Replace "/usr/bin/rsync" with the path to where you have rsync installed on
+your system.  You will then need to send inetd a HUP signal to tell it to
+reread its config file.
+
+Note that you should not send the rsync server a HUP signal to force
+it to reread the tt(rsyncd.conf) file. The file is re-read on each client
+connection. 
+
+manpagesection(GLOBAL OPTIONS)
+
+The first parameters in the file (before a [module] header) are the
+global parameters. 
+
+You may also include any module parameters in the global part of the
+config file in which case the supplied value will override the
+default for that parameter.
+
+startdit()
+dit(bf(motd file)) The "motd file" option allows you to specify a
+"message of the day" to display to clients on each connect. This
+usually contains site information and any legal notices. The default
+is no motd file.
+
+dit(bf(log file)) The "log file" option tells the rsync daemon to log
+messages to that file rather than using syslog. This is particularly
+useful on systems (such as AIX) where syslog() doesn't work for
+chrooted programs.
+
+dit(bf(pid file)) The "pid file" option tells the rsync daemon to write
+its process id to that file.
+
+dit(bf(syslog facility)) The "syslog facility" option allows you to
+specify the syslog facility name to use when logging messages from the
+rsync server. You may use any standard syslog facility name which is
+defined on your system. Common names are auth, authpriv, cron, daemon,
+ftp, kern, lpr, mail, news, security, syslog, user, uucp, local0,
+local1, local2, local3, local4, local5, local6 and local7. The default
+is daemon. 
+
+dit(bf(socket options)) This option can provide endless fun for people
+who like to tune their systems to the utmost degree. You can set all
+sorts of socket options which may make transfers faster (or
+slower!). Read the man page for the setsockopt() system call for
+details on some of the options you may be able to set. By default no
+special socket options are set.
+
+enddit()
+
+
+manpagesection(MODULE OPTIONS)
+
+After the global options you should define a number of modules, each
+module exports a directory tree as a symbolic name. Modules are
+exported by specifying a module name in square brackets [module]
+followed by the options for that module.
+
+startdit()
+
+dit(bf(comment)) The "comment" option specifies a description string
+that is displayed next to the module name when clients obtain a list
+of available modules. The default is no comment.
+
+dit(bf(path)) The "path" option specifies the directory in the servers
+filesystem to make available in this module.  You must specify this option
+for each module in tt(rsyncd.conf).
+
+dit(bf(use chroot)) If "use chroot" is true, the rsync server will chroot
+to the "path" before starting the file transfer with the client.  This has
+the advantage of extra protection against possible implementation security
+holes, but it has the disadvantages of requiring super-user privileges, 
+of not being able to follow symbolic links outside of the new root path
+when reading, and of implying the --numeric-ids option because /etc/passwd
+becomes inaccessible.  When "use chroot" is false, for security reasons
+symlinks may only be relative paths pointing to other files within the root
+path, and leading slashes are removed from absolute paths.  The default for
+"use chroot" is true.
+
+dit(bf(max connections)) The "max connections" option allows you to
+specify the maximum number of simultaneous connections you will allow.
+Any clients connecting when the maximum has been reached will receive a
+message telling them to try later.  The default is 0 which means no limit.
+See also the "lock file" option.
+
+dit(bf(lock file)) The "lock file" option specifies the file to use to
+support the "max connections" option. The rsync server uses record
+locking on this file to ensure that the max connections limit is not
+exceeded for the modules sharing the lock file. 
+The default is tt(/var/run/rsyncd.lock).
+
+dit(bf(read only)) The "read only" option determines whether clients
+will be able to upload files or not. If "read only" is true then any
+attempted uploads will fail. If "read only" is false then uploads will
+be possible if file permissions on the server allow them. The default
+is for all modules to be read only.
+
+dit(bf(list)) The "list" option determines if this module should be
+listed when the client asks for a listing of available modules. By
+setting this to false you can create hidden modules. The default is
+for modules to be listable.
+
+dit(bf(uid)) The "uid" option specifies the user name or user id that
+file transfers to and from that module should take place as when the daemon
+was run as root. In combination with the "gid" option this determines what
+file permissions are available. The default is uid -2, which is normally
+the user "nobody".
+
+dit(bf(gid)) The "gid" option specifies the group name or group id that
+file transfers to and from that module should take place as when the daemon
+was run as root. This complements the "uid" option. The default is gid -2,
+which is normally the group "nobody".
+
+dit(bf(exclude)) The "exclude" option allows you to specify a space
+separated list of patterns to add to the exclude list.
+This is only superficially equivalent
+to the client specifying these patterns with the --exclude option.
+Only one "exclude" option may be specified, but
+you can use "-" and "+" before patterns to specify exclude/include.
+
+Because this exclude list is not passed to the client it only applies on
+the server: that is, it excludes files received by a client when receiving
+from a server and files deleted on a server when sending to a server, but
+it doesn't exclude files sent from a client when sending to a server or
+files deleted on a client when receiving from a server.  
+
+Note that this option is not designed with strong security in
+mind, it is quite possible that a client may find a way to bypass this
+exclude list. If you want to absolutely ensure that certain files
+cannot be accessed then use the uid/gid options in combination with
+file permissions.
+
+dit(bf(exclude from)) The "exclude from" option specifies a filename
+on the server that contains exclude patterns, one per line.
+This is only superficially equivalent
+to the client specifying the --exclude-from option with an equivalent file.
+See the "exclude" option above.
+
+dit(bf(include)) The "include" option allows you to specify a space
+separated list of patterns which rsync should not exclude. This is
+only superficially equivalent to the client specifying these patterns
+with the --include option because it applies only on the server.
+This is useful as it
+allows you to build up quite complex exclude/include rules.  Only one
+"include" option may be specified, but you can use "+" and "-" before
+patterns to switch include/exclude.  See the "exclude" option above.
+
+dit(bf(include from)) The "include from" option specifies a filename
+on the server that contains include patterns, one per line. This is
+only superficially equivalent to the client specifying the
+--include-from option with a equivalent file.
+See the "exclude" option above.
+
+dit(bf(auth users)) The "auth users" option specifies a comma and
+space separated list of usernames that will be allowed to connect to
+this module. The usernames do not need to exist on the local
+system. The usernames may also contain shell wildcard characters. If
+"auth users" is set then the client will be challenged to supply a
+username and password to connect to the module. A challenge response
+authentication protocol is used for this exchange. The plain text
+usernames are passwords are stored in the file specified by the
+"secrets file" option. The default is for all users to be able to
+connect without a password (this is called "anonymous rsync").
+
+See also the bf(CONNECTING TO AN RSYNC SERVER OVER A REMOTE SHELL
+PROGRAM) section in rsync(1) for information on how handle an
+rsyncd.conf-level username that differs from the remote-shell-level
+username when using a remote shell to connect to a rsync server.
+
+dit(bf(secrets file)) The "secrets file" option specifies the name of
+a file that contains the username:password pairs used for
+authenticating this module. This file is only consulted if the "auth
+users" option is specified. The file is line based and contains
+username:password pairs separated by a single colon. Any line starting
+with a hash (#) is considered a comment and is skipped. The passwords
+can contain any characters but be warned that many operating systems
+limit the length of passwords that can be typed at the client end, so
+you may find that passwords longer than 8 characters don't work. 
+
+There is no default for the "secrets file" option, you must choose a name
+(such as tt(/etc/rsyncd.secrets)).  The file must normally not be readable
+by "other"; see "strict modes".
+
+dit(bf(strict modes)) The "strict modes" option determines whether or not 
+the permissions on the secrets file will be checked.  If "strict modes" is
+true, then the secrets file must not be readable by any user id other
+than the one that the rsync daemon is running under.  If "strict modes" is
+false, the check is not performed.  The default is true.  This option
+was added to accommodate rsync running on the Windows operating system.
+
+dit(bf(hosts allow)) The "hosts allow" option allows you to specify a
+list of patterns that are matched against a connecting clients
+hostname and IP address. If none of the patterns match then the
+connection is rejected.
+
+Each pattern can be in one of five forms:
+
+itemize(
+  it() a dotted decimal IPv4 address of the form a.b.c.d, or an IPv6 address
+  of the form a:b:c::d:e:f. In this case the incoming machine's IP address
+  must match exactly.
+
+  it() an address/mask in the form ipaddr/n where ipaddr is the IP address
+  and n is the number of one bits in the netmask.  All IP addresses which
+  match the masked IP address will be allowed in.
+
+  it() an address/mask in the form ipaddr/maskaddr where ipaddr is the
+  IP address and maskaddr is the netmask in dotted decimal notation for IPv4,
+  or similar for IPv6, e.g. ffff:ffff:ffff:ffff:: instead of /64. All IP
+  addresses which match the masked IP address will be allowed in.
+
+  it() a hostname. The hostname as determined by a reverse lookup will
+  be matched (case insensitive) against the pattern. Only an exact
+  match is allowed in.
+
+  it() a hostname pattern using wildcards. These are matched using the
+  same rules as normal unix filename matching. If the pattern matches
+  then the client is allowed in.
+)
+
+Note IPv6 link-local addresses can have a scope in the address specification:
+
+quote(fe80::1%link1)
+quote(fe80::%link1/64)
+quote(fe80::%link1/ffff:ffff:ffff:ffff::)
+
+You can also combine "hosts allow" with a separate "hosts deny"
+option. If both options are specified then the "hosts allow" option s
+checked first and a match results in the client being able to
+connect. The "hosts deny" option is then checked and a match means
+that the host is rejected. If the host does not match either the 
+"hosts allow" or the "hosts deny" patterns then it is allowed to
+connect.
+
+The default is no "hosts allow" option, which means all hosts can connect.
+
+dit(bf(hosts deny)) The "hosts deny" option allows you to specify a
+list of patterns that are matched against a connecting clients
+hostname and IP address. If the pattern matches then the connection is
+rejected. See the "hosts allow" option for more information.
+
+The default is no "hosts deny" option, which means all hosts can connect.
+
+dit(bf(ignore errors)) The "ignore errors" option tells rsyncd to
+ignore IO errors on the server when deciding whether to run the delete
+phase of the transfer. Normally rsync skips the --delete step if any
+IO errors have occurred in order to prevent disasterous deletion due
+to a temporary resource shortage or other IO error. In some cases this
+test is counter productive so you can use this option to turn off this
+behaviour. 
+
+dit(bf(ignore nonreadable)) This tells the rsync server to completely
+ignore files that are not readable by the user. This is useful for
+public archives that may have some non-readable files among the
+directories, and the sysadmin doesn't want those files to be seen at all.
+
+dit(bf(transfer logging)) The "transfer logging" option enables per-file 
+logging of downloads and uploads in a format somewhat similar to that
+used by ftp daemons. If you want to customize the log formats look at
+the log format option.
+
+dit(bf(log format)) The "log format" option allows you to specify the
+format used for logging file transfers when transfer logging is
+enabled. The format is a text string containing embedded single
+character escape sequences prefixed with a percent (%) character.
+
+The prefixes that are understood are:
+
+itemize(
+  it() %h for the remote host name
+  it() %a for the remote IP address
+  it() %l for the length of the file in bytes
+  it() %p for the process id of this rsync session
+  it() %o for the operation, which is either "send" or "recv"
+  it() %f for the filename
+  it() %P for the module path
+  it() %m for the module name
+  it() %t for the current date time
+  it() %u for the authenticated username (or the null string)
+  it() %b for the number of bytes actually transferred 
+  it() %c when sending files this gives the number of checksum bytes
+    received for this file
+)
+
+The default log format is "%o %h [%a] %m (%u) %f %l", and a "%t [%p] "
+is always added to the beginning when using the "log file" option.
+
+A perl script called rsyncstats to summarize this format is included
+in the rsync source code distribution.
+
+dit(bf(timeout)) The "timeout" option allows you to override the
+clients choice for IO timeout for this module. Using this option you
+can ensure that rsync won't wait on a dead client forever. The timeout
+is specified in seconds. A value of zero means no timeout and is the
+default. A good choice for anonymous rsync servers may be 600 (giving
+a 10 minute timeout).
+
+dit(bf(refuse options)) The "refuse options" option allows you to
+specify a space separated list of rsync command line options that will
+be refused by your rsync server.  The full names of the options must be
+used (i.e., you must use "checksum" not "c" to disable checksumming).  
+When an option is refused, the server prints an error message and exits.
+To prevent all compression, you can use "dont compress = *" (see below)
+instead of "refuse options = compress" to avoid returning an error to a
+client that requests compression.
+
+dit(bf(dont compress)) The "dont compress" option allows you to select
+filenames based on wildcard patterns that should not be compressed
+during transfer. Compression is expensive in terms of CPU usage so it
+is usually good to not try to compress files that won't compress well,
+such as already compressed files. 
+
+The "dont compress" option takes a space separated list of
+case-insensitive wildcard patterns. Any source filename matching one
+of the patterns will not be compressed during transfer.
+
+The default setting is verb(*.gz *.tgz *.zip *.z *.rpm *.deb *.iso *.bz2 *.tbz)
+
+enddit()
+
+manpagesection(AUTHENTICATION STRENGTH)
+
+The authentication protocol used in rsync is a 128 bit MD4 based
+challenge response system. Although I believe that no one has ever
+demonstrated a brute-force break of this sort of system you should
+realize that this is not a "military strength" authentication system.
+It should be good enough for most purposes but if you want really top
+quality security then I recommend that you run rsync over ssh.
+
+Also note that the rsync server protocol does not currently provide any
+encryption of the data that is transferred over the connection. Only
+authentication is provided. Use ssh as the transport if you want
+encryption.
+
+Future versions of rsync may support SSL for better authentication and
+encryption, but that is still being investigated.
+
+manpagesection(EXAMPLES)
+
+A simple rsyncd.conf file that allow anonymous rsync to a ftp area at
+tt(/home/ftp) would be:
+
+verb(
+[ftp]
+        path = /home/ftp
+        comment = ftp export area
+)
+
+
+A more sophisticated example would be:
+
+uid = nobody nl()
+gid = nobody nl()
+use chroot = no nl()
+max connections = 4 nl()
+syslog facility = local5 nl()
+pid file = /var/run/rsyncd.pid
+
+verb([ftp]
+        path = /var/ftp/pub
+        comment = whole ftp area (approx 6.1 GB)
+
+[sambaftp]
+        path = /var/ftp/pub/samba
+        comment = Samba ftp area (approx 300 MB)
+
+[rsyncftp]
+        path = /var/ftp/pub/rsync
+        comment = rsync ftp area (approx 6 MB)
+        
+[sambawww]
+        path = /public_html/samba
+        comment = Samba WWW pages (approx 240 MB)
+
+[cvs]
+        path = /data/cvs
+        comment = CVS repository (requires authentication)
+        auth users = tridge, susan
+        secrets file = /etc/rsyncd.secrets
+)
+
+The /etc/rsyncd.secrets file would look something like this:
+
+tridge:mypass nl()
+susan:herpass
+
+manpagefiles()
+
+/etc/rsyncd.conf or rsyncd.conf
+
+manpageseealso()
+
+rsync(1)
+
+manpagediagnostics()
+
+manpagebugs()
+
+The rsync server does not send all types of error messages to the
+client. this means a client may be mystified as to why a transfer
+failed. The error will have been logged by syslog on the server.
+
+Please report bugs! The rsync bug tracking system is online at
+url(http://rsync.samba.org/)(http://rsync.samba.org/)
+
+manpagesection(VERSION)
+This man page is current for version 2.0 of rsync
+
+manpagesection(CREDITS)
+
+rsync is distributed under the GNU public license.  See the file
+COPYING for details.
+
+The primary ftp site for rsync is
+url(ftp://rsync.samba.org/pub/rsync)(ftp://rsync.samba.org/pub/rsync).
+
+A WEB site is available at
+url(http://rsync.samba.org/)(http://rsync.samba.org/)
+
+We would be delighted to hear from you if you like this program.
+
+This program uses the zlib compression library written by Jean-loup
+Gailly and Mark Adler.
+
+manpagesection(THANKS)
+
+Thanks to Warren Stanley for his original idea and patch for the rsync
+server. Thanks to Karsten Thygesen for his many suggestions and
+documentation! 
+
+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
+

rsyncsh.txt

@@ -0,0 +1,26 @@
+rsyncsh
+Copyright (C) 2001 by Martin Pool
+
+This is a quick hack to build an interactive shell around rsync, the
+same way we have the ftp, lftp and ncftp programs for the FTP
+protocol.  The key application for this is connecting to a public
+rsync server, such as rsync.kernel.org, change down through and list
+directories, and finally pull down the file you want.
+
+rsync is somewhat ill-at-ease as an interactive operation, since every
+network connection is used to carry out exactly one operation.  rsync
+kind of "forks across the network" passing the options and filenames
+to operate upon, and the connection is closed when the transfer is
+complete.  (This might be fixed in the future, either by adapting the
+current protocol to allow chained operations over a single socket, or
+by writing a new protocol that better supports interactive use.)
+
+So, rsyncsh runs a new rsync command and opens a new socket for every
+(network-based) command you type.
+
+This has two consequences.  Firstly, there is more command latency
+than is really desirable.  More seriously, if the connection cannot be
+done automatically, because for example it uses SSH with a password,
+then you will need to enter the password every time.  We might even
+fix this in the future, though, by having a way to automatically feed
+the password to SSH if it's entered once.

runtests.sh

@@ -0,0 +1,270 @@
+#! /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 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.
+
+
+# rsync top-level test script -- this invokes all the other more
+# detailed tests in order.  This script can either be called by `make
+# check' or `make installcheck'.  `check' runs against the copies of
+# the program and other files in the build directory, and
+# `installcheck' against the installed copy of the program.  
+
+# In either case we need to also be able to find the source directory,
+# since we read test scripts and possibly other information from
+# there.
+
+# Whenever possible, informational messages are written to stdout and
+# error messages to stderr.  They're separated out by the build farm
+# display scripts.
+
+# According to the GNU autoconf manual, the only valid place to set up
+# directory locations is through Make, since users are allowed to (try
+# to) change their mind on the Make command line.  So, Make has to
+# pass in all the values we need.
+
+# For other configured settings we read ./config.sh, which tells us
+# about shell commands on this machine and similar things.
+
+# rsync_bin gives the location of the rsync binary.  This is either
+# builddir/rsync if we're testing an uninstalled copy, or
+# install_prefix/bin/rsync if we're testing an installed copy.  On the
+# build farm rsync will be installed, but into a scratch /usr.
+
+# srcdir gives the location of the source tree, which lets us find the
+# build scripts.  At the moment we assume we are invoked from the
+# source directory.
+
+# This script must be invoked from the build directory.  
+
+# A scratch directory, 'testtmp', is created in the build directory to
+# hold working files.
+
+# This script also uses the $loglevel environment variable.  1 is the
+# default value, and 10 the most verbose.  You can set this from the
+# Make command line.  It's also set by the build farm to give more
+# detail for failing builds.
+
+
+# NOTES FOR TEST CASES:
+
+# Each test case runs in its own shell. 
+
+# Exit codes from tests:
+
+#    1  tests failed
+#    2  error in starting tests
+#   77  this test skipped (random value unlikely to happen by chance, same as
+#       automake)
+
+# HOWEVER, the overall exit code to the farm is different: we return
+# the *number of tests that failed*, so that it will show up nicely in
+# the overall summary.
+
+# rsync.fns contains some general setup functions and definitions.
+
+
+# NOTES ON PORTABILITY:
+
+# Both this script and the Makefile have to be pretty conservative
+# about which Unix features they use.
+
+# We cannot count on Make exporting variables to commands, unless
+# they're explicitly given on the command line.
+
+# Also, we can't count on 'cp -a' or 'mkdir -p', although they're
+# pretty handy.
+
+# I think some of the GNU documentation suggests that we shouldn't
+# rely on shell functions.  However, the Bash manual seems to say that
+# they're in POSIX 1003.2, and since the build farm relies on them
+# they're probably working on most machines we really care about.
+
+# You cannot use "function foo {" syntax, but must instead say "foo()
+# {", or it breaks on FreeBSD.
+
+# BSD machines tend not to have "head" or "seq".
+
+# You cannot do "export VAR=VALUE" all on one line; the export must be
+# separate from the assignment.  (SCO SysV)
+
+
+
+# STILL TO DO:
+
+# We need a good protection against tests that hang indefinitely.
+# Perhaps some combination of starting them in the background, wait,
+# and kill?
+
+# Perhaps we need a common way to cleanup tests.  At the moment just
+# clobbering the directory when we're done should be enough.
+
+# If any of the targets fail, then (GNU?) Make returns 2, instead of
+# the return code from the failing command.  This is fine, but it
+# means that the build farm just shows "2" for failed tests, not the
+# number of tests that actually failed.  For more details we might
+# need to grovel through the log files to find a line saying how many
+# failed.
+
+
+set -e
+
+. "./shconfig"
+
+RUNSHFLAGS='-e'
+
+# for Solaris
+PATH="/usr/xpg4/bin/:$PATH"
+
+if [ -n "$loglevel" ] && [ "$loglevel" -gt 8 ]
+then
+    if set -x
+    then
+	# If it doesn't work the first time, don't keep trying.
+	RUNSHFLAGS="$RUNSHFLAGS -x"
+    fi
+fi
+
+echo "============================================================"
+echo "$0 running in `pwd`"
+echo "    rsync_bin=$rsync_bin"
+echo "    srcdir=$srcdir"
+
+testuser=`whoami || echo UNKNOWN`
+
+echo "    testuser=$testuser"
+echo "    os=`uname -a`"
+
+# It must be "yes", not just nonnull
+if test "x$preserve_scratch" = xyes
+then
+    echo "    preserve_scratch=yes"
+else
+    echo "    preserve_scratch=no"
+fi    
+
+
+if test ! -f $rsync_bin
+then
+    echo "rsync_bin $rsync_bin is not a file" >&2
+    exit 2
+fi
+
+if test ! -d $srcdir
+then
+    echo "srcdir $srcdir is not a directory" >&2
+    exit 2
+fi
+
+RSYNC="$rsync_bin"
+
+export rsync_bin RSYNC
+
+skipped=0
+missing=0
+passed=0
+failed=0
+
+# 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"
+fi
+
+for testscript in $suitedir/$whichtests
+do
+    testbase=`echo $testscript | sed 's!.*/!!' | sed -e 's/.test\$//'`
+    scratchdir="$scratchbase.$testbase"
+
+    prep_scratch
+
+    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 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)
+	# backticks will fill the whole file onto one line, which is a feature
+	whyskipped=`cat "$scratchdir/whyskipped"`
+	echo "SKIP    $testbase ($whyskipped)"
+	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 '------------------------------------------------------------'
+echo "----- overall results:"
+echo "      $passed passed"
+[ "$failed" -gt 0 ]  && echo "      $failed failed"
+[ "$skipped" -gt 0 ] && echo "      $skipped skipped"
+[ "$missing" -gt 0 ] && echo "      $missing missing"
+echo '------------------------------------------------------------'
+
+# OK, so expr exits with 0 if the result is neither null nor zero; and
+# 1 if the expression is null or zero.  This is the opposite of what
+# we want, and if we just call expr then this script will always fail,
+# because -e is set.
+
+result=`expr $failed + $missing || true`
+echo "overall result is $result"
+exit $result

sender.c

@@ -0,0 +1,302 @@
+/* 
+   Copyright (C) Andrew Tridgell 1996
+   Copyright (C) Paul Mackerras 1996
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "rsync.h"
+
+extern int verbose;
+extern int remote_version;
+extern int csum_length;
+extern struct stats stats;
+extern int io_error;
+extern int dry_run;
+extern int am_server;
+
+
+/**
+ * @file
+ *
+ * The sender gets checksums from the generator, calculates deltas,
+ * and transmits them to the receiver.  The sender process runs on the
+ * machine holding the source files.
+ **/
+
+
+/**
+ * Receive the checksums for a buffer
+ **/
+static struct sum_struct *receive_sums(int f)
+{
+	struct sum_struct *s;
+	int i;
+	OFF_T offset = 0;
+
+	s = new(struct sum_struct);
+	if (!s) out_of_memory("receive_sums");
+
+	s->count = read_int(f);
+	s->n = read_int(f);
+	s->remainder = read_int(f);  
+	s->sums = NULL;
+
+	if (verbose > 3)
+		rprintf(FINFO,"count=%ld n=%ld rem=%ld\n",
+			(long) s->count, (long) s->n, (long) s->remainder);
+
+	if (s->count == 0) 
+		return(s);
+
+	s->sums = new_array(struct sum_buf, s->count);
+	if (!s->sums) out_of_memory("receive_sums");
+
+	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 == (int) s->count-1 && s->remainder != 0) {
+			s->sums[i].len = s->remainder;
+		} else {
+			s->sums[i].len = s->n;
+		}
+		offset += s->sums[i].len;
+
+		if (verbose > 3)
+			rprintf(FINFO,"chunk[%d] len=%d offset=%.0f sum1=%08x\n",
+				i,s->sums[i].len,(double)s->sums[i].offset,s->sums[i].sum1);
+	}
+
+	s->flength = offset;
+
+	return s;
+}
+
+
+
+void send_files(struct file_list *flist,int f_out,int f_in)
+{ 
+	int fd = -1;
+	struct sum_struct *s;
+	struct map_struct *buf = NULL;
+	STRUCT_STAT st;
+	char fname[MAXPATHLEN];  
+	int i;
+	struct file_struct *file;
+	int phase = 0;
+	extern struct stats stats;		
+	struct stats initial_stats;
+	extern int write_batch;   /* dw */
+	extern int read_batch;    /* dw */
+	int checksums_match;   /* dw */
+	int buff_len;  /* dw */
+	char buff[CHUNK_SIZE];    /* dw */
+	int j;   /* dw */
+	int done;   /* dw */
+
+	if (verbose > 2)
+		rprintf(FINFO,"send_files starting\n");
+
+	while (1) {
+		int offset=0;
+
+		i = read_int(f_in);
+		if (i == -1) {
+			if (phase==0 && remote_version >= 13) {
+				phase++;
+				csum_length = SUM_LENGTH;
+				write_int(f_out,-1);
+				if (verbose > 2)
+					rprintf(FINFO,"send_files phase=%d\n",phase);
+				continue;
+			}
+			break;
+		}
+
+		if (i < 0 || i >= flist->count) {
+			rprintf(FERROR,"Invalid file index %d (count=%d)\n", 
+				i, flist->count);
+			exit_cleanup(RERR_PROTOCOL);
+		}
+
+		file = flist->files[i];
+
+		stats.num_transferred_files++;
+		stats.total_transferred_size += file->length;
+
+		fname[0] = 0;
+		if (file->basedir) {
+			strlcpy(fname,file->basedir,MAXPATHLEN);
+			if (strlen(fname) == MAXPATHLEN-1) {
+				io_error = 1;
+				rprintf(FERROR, "send_files failed on long-named directory %s\n",
+					fname);
+				return;
+			}
+			strlcat(fname,"/",MAXPATHLEN);
+			offset = strlen(file->basedir)+1;
+		}
+		strlcat(fname,f_name(file),MAXPATHLEN);
+	  
+		if (verbose > 2) 
+			rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
+	  
+		if (dry_run) {	
+			if (!am_server) {
+				log_transfer(file, fname+offset);
+			}
+			write_int(f_out,i);
+			continue;
+		}
+
+		initial_stats = stats;
+
+		s = receive_sums(f_in);
+		if (!s) {
+			io_error = 1;
+			rprintf(FERROR,"receive_sums failed\n");
+			return;
+		}
+
+		if (write_batch)
+		    write_batch_csum_info(&i,flist->count,s);
+	  
+		if (!read_batch) {
+			fd = do_open(fname, O_RDONLY, 0);
+			if (fd == -1) {
+				io_error = 1;
+				rprintf(FERROR,"send_files failed to open %s: %s\n",
+					fname,strerror(errno));
+				free_sums(s);
+				continue;
+			}
+	  
+			/* map the local file */
+			if (do_fstat(fd,&st) != 0) {
+				io_error = 1;
+				rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
+				free_sums(s);
+				close(fd);
+				return;
+			}
+	  
+			if (st.st_size > 0) {
+				buf = map_file(fd,st.st_size);
+			} else {
+				buf = NULL;
+			}
+	  
+			if (verbose > 2)
+				rprintf(FINFO,"send_files mapped %s of size %.0f\n",
+					fname,(double)st.st_size);
+
+			write_int(f_out,i);
+	  
+			if (write_batch)
+				write_batch_delta_file((char *)&i,sizeof(i));
+
+			write_int(f_out,s->count);
+			write_int(f_out,s->n);
+			write_int(f_out,s->remainder);
+		}
+	  
+		if (verbose > 2)
+			if (!read_batch)
+			    rprintf(FINFO,"calling match_sums %s\n",fname);
+	  
+		if (!am_server) {
+			log_transfer(file, fname+offset);
+		}
+
+		set_compression(fname);
+
+                if (read_batch) { /* dw */
+                   /* read checksums originally computed on sender side */
+                   read_batch_csum_info(i, s, &checksums_match);
+                   if (checksums_match) {
+                       read_batch_delta_file( (char *) &j, sizeof(int) );
+                       if (j != i) {    /* if flist index entries don't match*/ 
+                          rprintf(FINFO,"index mismatch in send_files\n");
+                          rprintf(FINFO,"read index = %d flist ndx = %d\n",j,i);
+                          close_batch_delta_file();
+                          close_batch_csums_file();
+                          exit_cleanup(1);
+                       }
+                       else {
+                         write_int(f_out,j);
+                         write_int(f_out,s->count);
+                         write_int(f_out,s->n);
+                         write_int(f_out,s->remainder);
+                         done=0;
+                         while (!done) {
+                            read_batch_delta_file( (char *) &buff_len, sizeof(int) );
+                            write_int(f_out,buff_len);
+                            if (buff_len == 0) {
+                               done = 1;
+                            }
+                            else {
+                               if (buff_len > 0) {
+                                  read_batch_delta_file(buff, buff_len);
+                                  write_buf(f_out,buff,buff_len);
+                               }
+                            }
+                         }  /* end while  */
+                         read_batch_delta_file( buff, MD4_SUM_LENGTH);
+                         write_buf(f_out, buff, MD4_SUM_LENGTH);
+
+                       }  /* j=i */
+                   } else {  /* not checksum match */
+                      rprintf (FINFO,"readbatch & checksums don't match\n");
+                      rprintf (FINFO,"filename=%s is being skipped\n",
+			       fname);
+                      continue;
+                   }
+                } else  {
+		    match_sums(f_out,s,buf,st.st_size);
+		    log_send(file, &initial_stats);
+                }
+
+		if (!read_batch) { /* dw */
+		    if (buf) unmap_file(buf);
+		    close(fd);
+		}
+	  
+		free_sums(s);
+	  
+		if (verbose > 2)
+			rprintf(FINFO,"sender finished %s\n",fname);
+	}
+
+	if (verbose > 2)
+		rprintf(FINFO,"send files finished\n");
+
+	match_report();
+
+	write_int(f_out,-1);
+	if (write_batch || read_batch) { /* dw */
+	    close_batch_csums_file();
+	    close_batch_delta_file();
+	}
+
+}
+
+
+
+
+

shconfig.in

@@ -0,0 +1,12 @@
+#! /bin/sh
+
+# config.sh.in 
+
+# This file is processed by config.status to produce config.status,
+# containing autoconf-determined values needed by the test scripts.
+
+ECHO_T="@ECHO_T@"
+ECHO_N="@ECHO_N@"
+ECHO_C="@ECHO_C@"
+
+export ECHO_T ECHO_N ECHO_C

socket.c

@@ -0,0 +1,703 @@
+/* -*- 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 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"
+
+
+/**
+ * Establish a proxy connection on an open socket to a web proxy by
+ * using the HTTP CONNECT method.
+ **/
+static int establish_proxy_connection(int fd, char *host, int port)
+{
+	char buffer[1024];
+	char *cp;
+
+	snprintf(buffer, sizeof(buffer), "CONNECT %s:%d HTTP/1.0\r\n\r\n", host, port);
+	if (write(fd, buffer, strlen(buffer)) != (int) strlen(buffer)) {
+		rprintf(FERROR, "failed to write to proxy: %s\n",
+			strerror(errno));
+		return -1;
+	}
+
+	for (cp = buffer; cp < &buffer[sizeof(buffer) - 1]; cp++) {
+		if (read(fd, cp, 1) != 1) {
+			rprintf(FERROR, "failed to read from proxy: %s\n",
+				strerror(errno));
+			return -1;
+		}
+		if (*cp == '\n')
+			break;
+	}
+
+	if (*cp != '\n')
+		cp++;
+	*cp-- = '\0';
+	if (*cp == '\r')
+		*cp = '\0';
+	if (strncmp(buffer, "HTTP/", 5) != 0) {
+		rprintf(FERROR, "bad response from proxy - %s\n",
+			buffer);
+		return -1;
+	}
+	for (cp = &buffer[5]; isdigit(* (unsigned char *) cp) || (*cp == '.'); cp++)
+		;
+	while (*cp == ' ')
+		cp++;
+	if (*cp != '2') {
+		rprintf(FERROR, "bad response from proxy - %s\n",
+			buffer);
+		return -1;
+	}
+	/* throw away the rest of the HTTP header */
+	while (1) {
+		for (cp = buffer; cp < &buffer[sizeof(buffer) - 1];
+		     cp++) {
+			if (read(fd, cp, 1) != 1) {
+				rprintf(FERROR, "failed to read from proxy: %s\n",
+					strerror(errno));
+				return -1;
+			}
+			if (*cp == '\n')
+				break;
+		}
+		if ((cp > buffer) && (*cp == '\n'))
+			cp--;
+		if ((cp == buffer) && ((*cp == '\n') || (*cp == '\r')))
+			break;
+	}
+	return 0;
+}
+
+
+/**
+ * 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;
+		freeaddrinfo(bres_all);
+		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. */
+	freeaddrinfo(bres_all);
+	return -1;
+}
+
+
+/**
+ * Open a socket to a tcp remote host with the specified port .
+ *
+ * Based on code from Warren.  Proxy support by Stephen Rothwell.
+ * getaddrinfo() rewrite contributed by KAME.net.
+ *
+ * Now that we support IPv6 we need to look up the remote machine's
+ * address first, using @p af_hint to set a preference for the type
+ * of address.  Then depending on whether it has v4 or v6 addresses we
+ * try to open a connection.
+ *
+ * The loop allows for machines with some addresses which may not be
+ * reachable, perhaps because we can't e.g. route ipv6 to that network
+ * but we can get ip4 packets through.
+ *
+ * @param bind_address Local address to use.  Normally NULL to bind
+ * the wildcard address.
+ *
+ * @param af_hint Address family, e.g. AF_INET or AF_INET6.
+ **/
+int open_socket_out(char *host, int port, const char *bind_address,
+		    int af_hint)
+{
+	int type = SOCK_STREAM;
+	int error;
+	int s;
+	struct addrinfo hints, *res0, *res;
+	char portbuf[10];
+	char *h;
+	int proxied = 0;
+	char buffer[1024];
+	char *cp;
+
+	/* if we have a RSYNC_PROXY env variable then redirect our
+	 * connetcion via a web proxy at the given address. The format
+	 * is hostname:port */
+	h = getenv("RSYNC_PROXY");
+	proxied = (h != NULL) && (*h != '\0');
+
+	if (proxied) {
+		strlcpy(buffer, h, sizeof(buffer));
+		cp = strchr(buffer, ':');
+		if (cp == NULL) {
+			rprintf(FERROR,
+				"invalid proxy specification: should be HOST:PORT\n");
+			return -1;
+		}
+		*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;
+	}
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = af_hint;
+	hints.ai_socktype = type;
+	error = getaddrinfo(h, portbuf, &hints, &res0);
+	if (error) {
+		rprintf(FERROR, RSYNC_NAME ": getaddrinfo: %s %s: %s\n",
+			h, portbuf, gai_strerror(error));
+		return -1;
+	}
+
+	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)
+			if (try_bind_local(s, res->ai_family, type,
+					   bind_address) == -1) {
+				close(s);
+				s = -1;
+				continue;
+			}
+
+		if (connect(s, res->ai_addr, res->ai_addrlen) < 0) {
+			close(s);
+			s = -1;
+			continue;
+		}
+		if (proxied &&
+		    establish_proxy_connection(s, host, port) != 0) {
+			close(s);
+			s = -1;
+			continue;
+		} else
+			break;
+	}
+	freeaddrinfo(res0);
+	if (s < 0) {
+		rprintf(FERROR, RSYNC_NAME ": failed to connect to %s: %s\n",
+			h, strerror(errno));
+		return -1;
+	}
+	return s;
+}
+
+
+/**
+ * Open an outgoing socket, but allow for it to be intercepted by
+ * $RSYNC_CONNECT_PROG, which will execute a program across a TCP
+ * socketpair rather than really opening a socket.
+ *
+ * We use this primarily in testing to detect TCP flow bugs, but not
+ * cause security problems by really opening remote connections.
+ *
+ * This is based on the Samba LIBSMB_PROG feature.
+ *
+ * @param bind_address Local address to use.  Normally NULL to get the stack default.
+ **/
+int open_socket_out_wrapped (char *host,
+			     int port,
+			     const char *bind_address,
+			     int af_hint)
+{
+	char *prog;
+
+	if ((prog = getenv ("RSYNC_CONNECT_PROG")) != NULL) 
+		return sock_exec (prog);
+	else 
+		return open_socket_out (host, port, bind_address,
+					af_hint);
+}
+
+
+
+/**
+ * Open a socket of the specified type, port and address for incoming data
+ *
+ * Try to be better about handling the results of getaddrinfo(): when
+ * opening an inbound socket, we might get several address results,
+ * e.g. for the machine's ipv4 and ipv6 name.  
+ * 
+ * If binding a wildcard, then any one of them should do.  If an address
+ * was specified but it's insufficiently specific then that's not our
+ * fault.  
+ * 
+ * However, some of the advertized addresses may not work because e.g. we
+ * don't have IPv6 support in the kernel.  In that case go on and try all
+ * addresses until one succeeds.
+ * 
+ * @param bind_address Local address to bind, or NULL to allow it to
+ * default.
+ **/
+static int open_socket_in(int type, int port, const char *bind_address,
+			  int af_hint)
+{
+	int one=1;
+	int s;
+	struct addrinfo hints, *all_ai, *resp;
+	char portbuf[10];
+	int error;
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = af_hint;
+	hints.ai_socktype = type;
+	hints.ai_flags = AI_PASSIVE;
+	snprintf(portbuf, sizeof(portbuf), "%d", port);
+	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;
+	}
+
+	/* 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 == -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;
+		}
+
+		freeaddrinfo(all_ai);
+		return s;
+	}
+
+	rprintf(FERROR, RSYNC_NAME ": open inbound socket on port %d failed: "
+		"%s\n",
+		port, 
+		strerror(errno));
+
+	freeaddrinfo(all_ai);
+	return -1; 
+}
+
+
+/*
+ * Determine if a file descriptor is in fact a socket
+ */
+int is_a_socket(int fd)
+{
+	int v;
+	socklen_t l;
+	l = sizeof(int);
+
+        /* Parameters to getsockopt, setsockopt etc are very
+         * unstandardized across platforms, so don't be surprised if
+         * there are compiler warnings on e.g. SCO OpenSwerver or AIX.
+         * It seems they all eventually get the right idea.
+         *
+         * Debian says: ``The fifth argument of getsockopt and
+         * setsockopt is in reality an int [*] (and this is what BSD
+         * 4.* and libc4 and libc5 have).  Some POSIX confusion
+         * resulted in the present socklen_t.  The draft standard has
+         * not been adopted yet, but glibc2 already follows it and
+         * also has socklen_t [*]. See also accept(2).''
+         *
+         * We now return to your regularly scheduled programming.  */
+	return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
+}
+
+
+static RETSIGTYPE sigchld_handler(UNUSED(int val))
+{
+	signal(SIGCHLD, sigchld_handler);
+#ifdef WNOHANG
+	while (waitpid(-1, NULL, WNOHANG) > 0) {}
+#endif
+}
+
+
+void start_accept_loop(int port, int (*fn)(int, 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, default_af_hint);
+	if (s == -1)
+		exit_cleanup(RERR_SOCKETIO);
+
+	/* ready to listen */
+	if (listen(s, 5) == -1) {
+		close(s);
+		exit_cleanup(RERR_SOCKETIO);
+	}
+
+
+	/* now accept incoming connections - forking a new process
+	   for each incoming connection */
+	while (1) {
+		fd_set fds;
+		pid_t pid;
+		int fd;
+		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
+		   forever */
+		log_close();
+
+		FD_ZERO(&fds);
+		FD_SET(s, &fds);
+
+		if (select(s+1, &fds, NULL, NULL, NULL) != 1) {
+			continue;
+		}
+
+		if(!FD_ISSET(s, &fds)) continue;
+
+		fd = accept(s,(struct sockaddr *)&addr,&addrlen);
+
+		if (fd == -1) continue;
+
+		signal(SIGCHLD, sigchld_handler);
+
+		if ((pid = fork()) == 0) {
+			int ret;
+			close(s);
+			/* open log file in child before possibly giving
+			   up privileges  */
+			log_open();
+			ret = fn(fd, fd);
+			close_all();
+			_exit(ret);
+		} 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);
+		}
+	}
+}
+
+
+enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
+
+struct
+{
+  char *name;
+  int level;
+  int option;
+  int value;
+  int opttype;
+} socket_options[] = {
+  {"SO_KEEPALIVE",      SOL_SOCKET,    SO_KEEPALIVE,    0,                 OPT_BOOL},
+  {"SO_REUSEADDR",      SOL_SOCKET,    SO_REUSEADDR,    0,                 OPT_BOOL},
+  {"SO_BROADCAST",      SOL_SOCKET,    SO_BROADCAST,    0,                 OPT_BOOL},
+#ifdef TCP_NODELAY
+  {"TCP_NODELAY",       IPPROTO_TCP,   TCP_NODELAY,     0,                 OPT_BOOL},
+#endif
+#ifdef IPTOS_LOWDELAY
+  {"IPTOS_LOWDELAY",    IPPROTO_IP,    IP_TOS,          IPTOS_LOWDELAY,    OPT_ON},
+#endif
+#ifdef IPTOS_THROUGHPUT
+  {"IPTOS_THROUGHPUT",  IPPROTO_IP,    IP_TOS,          IPTOS_THROUGHPUT,  OPT_ON},
+#endif
+#ifdef SO_SNDBUF
+  {"SO_SNDBUF",         SOL_SOCKET,    SO_SNDBUF,       0,                 OPT_INT},
+#endif
+#ifdef SO_RCVBUF
+  {"SO_RCVBUF",         SOL_SOCKET,    SO_RCVBUF,       0,                 OPT_INT},
+#endif
+#ifdef SO_SNDLOWAT
+  {"SO_SNDLOWAT",       SOL_SOCKET,    SO_SNDLOWAT,     0,                 OPT_INT},
+#endif
+#ifdef SO_RCVLOWAT
+  {"SO_RCVLOWAT",       SOL_SOCKET,    SO_RCVLOWAT,     0,                 OPT_INT},
+#endif
+#ifdef SO_SNDTIMEO
+  {"SO_SNDTIMEO",       SOL_SOCKET,    SO_SNDTIMEO,     0,                 OPT_INT},
+#endif
+#ifdef SO_RCVTIMEO
+  {"SO_RCVTIMEO",       SOL_SOCKET,    SO_RCVTIMEO,     0,                 OPT_INT},
+#endif
+  {NULL,0,0,0,0}};
+
+	
+
+/**
+ * Set user socket options
+ **/
+void set_socket_options(int fd, char *options)
+{
+	char *tok;
+	if (!options || !*options) return;
+
+	options = strdup(options);
+	
+	if (!options) out_of_memory("set_socket_options");
+
+	for (tok=strtok(options, " \t,"); tok; tok=strtok(NULL," \t,")) {
+		int ret=0,i;
+		int value = 1;
+		char *p;
+		int got_value = 0;
+
+		if ((p = strchr(tok,'='))) {
+			*p = 0;
+			value = atoi(p+1);
+			got_value = 1;
+		}
+
+		for (i=0;socket_options[i].name;i++)
+			if (strcmp(socket_options[i].name,tok)==0)
+				break;
+
+		if (!socket_options[i].name) {
+			rprintf(FERROR,"Unknown socket option %s\n",tok);
+			continue;
+		}
+
+		switch (socket_options[i].opttype) {
+		case OPT_BOOL:
+		case OPT_INT:
+			ret = setsockopt(fd,socket_options[i].level,
+					 socket_options[i].option,(char *)&value,sizeof(int));
+			break;
+			
+		case OPT_ON:
+			if (got_value)
+				rprintf(FERROR,"syntax error - %s does not take a value\n",tok);
+
+			{
+				int on = socket_options[i].value;
+				ret = setsockopt(fd,socket_options[i].level,
+						 socket_options[i].option,(char *)&on,sizeof(int));
+			}
+			break;	  
+		}
+		
+		if (ret != 0)
+			rprintf(FERROR, "failed to set socket option %s: %s\n", tok,
+				strerror(errno));
+	}
+
+	free(options);
+}
+
+/**
+ * Become a daemon, discarding the controlling terminal
+ **/
+void become_daemon(void)
+{
+	int i;
+
+	if (fork()) {
+		_exit(0);
+	}
+
+	/* detach from the terminal */
+#ifdef HAVE_SETSID
+	setsid();
+#else
+#ifdef TIOCNOTTY
+	i = open("/dev/tty", O_RDWR);
+	if (i >= 0) {
+		ioctl(i, (int) TIOCNOTTY, (char *)0);      
+		close(i);
+	}
+#endif /* TIOCNOTTY */
+#endif
+	/* make sure that stdin, stdout an stderr don't stuff things
+           up (library functions, for example) */
+	for (i=0;i<3;i++) {
+		close(i); 
+		open("/dev/null", O_RDWR);
+	}
+}
+
+
+/**
+ * This is like socketpair but uses tcp. It is used by the Samba
+ * regression test code.
+ * 
+ * The function guarantees that nobody else can attach to the socket,
+ * or if they do that this function fails and the socket gets closed
+ * returns 0 on success, -1 on failure the resulting file descriptors
+ * are symmetrical.
+ **/
+static int socketpair_tcp(int fd[2])
+{
+	int listener;
+	struct sockaddr_in sock;
+	struct sockaddr_in sock2;
+	socklen_t socklen = sizeof(sock);
+	int connect_done = 0;
+	
+	fd[0] = fd[1] = listener = -1;
+
+	memset(&sock, 0, sizeof(sock));
+	
+	if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
+
+        memset(&sock2, 0, sizeof(sock2));
+#ifdef HAVE_SOCKADDR_LEN
+        sock2.sin_len = sizeof(sock2);
+#endif
+        sock2.sin_family = PF_INET;
+
+        bind(listener, (struct sockaddr *)&sock2, sizeof(sock2));
+
+	if (listen(listener, 1) != 0) goto failed;
+
+	if (getsockname(listener, (struct sockaddr *)&sock, &socklen) != 0) goto failed;
+
+	if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
+
+	set_nonblocking(fd[1]);
+
+	sock.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+
+	if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) == -1) {
+		if (errno != EINPROGRESS) goto failed;
+	} else {
+		connect_done = 1;
+	}
+
+	if ((fd[0] = accept(listener, (struct sockaddr *)&sock, &socklen)) == -1) goto failed;
+
+	close(listener);
+	if (connect_done == 0) {
+		if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) != 0
+		    && errno != EISCONN) goto failed;
+	}
+
+	set_blocking (fd[1]);
+
+	/* all OK! */
+	return 0;
+
+ failed:
+	if (fd[0] != -1) close(fd[0]);
+	if (fd[1] != -1) close(fd[1]);
+	if (listener != -1) close(listener);
+	return -1;
+}
+
+
+
+/**
+ * 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",
+			 strerror(errno));
+		return -1;
+	}
+	if (fork() == 0) {
+		close(fd[0]);
+		close(0);
+		close(1);
+		dup(fd[1]);
+		dup(fd[1]);
+		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]);
+	return fd[0];
+}
+
+
+

support/rsyncstats

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

syscall.c

@@ -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,23 +17,33 @@
    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"
 
 extern int dry_run;
+extern int read_only;
+extern int list_only;
+extern int preserve_perms;
+
+#define CHECK_RO if (read_only || list_only) {errno = EROFS; return -1;}
 
 int do_unlink(char *fname)
 {
 	if (dry_run) return 0;
+	CHECK_RO
 	return unlink(fname);
 }
 
 int do_symlink(char *fname1, char *fname2)
 {
 	if (dry_run) return 0;
+	CHECK_RO
 	return symlink(fname1, fname2);
 }
 
@@ -40,6 +51,7 @@ int do_symlink(char *fname1, char *fname2)
 int do_link(char *fname1, char *fname2)
 {
 	if (dry_run) return 0;
+	CHECK_RO
 	return link(fname1, fname2);
 }
 #endif
@@ -47,6 +59,7 @@ int do_link(char *fname1, char *fname2)
 int do_lchown(const char *path, uid_t owner, gid_t group)
 {
 	if (dry_run) return 0;
+	CHECK_RO
 	return lchown(path, owner, group);
 }
 
@@ -54,6 +67,7 @@ int do_lchown(const char *path, uid_t owner, gid_t group)
 int do_mknod(char *pathname, mode_t mode, dev_t dev)
 {
 	if (dry_run) return 0;
+	CHECK_RO
 	return mknod(pathname, mode, dev);
 }
 #endif
@@ -61,37 +75,150 @@ int do_mknod(char *pathname, mode_t mode, dev_t dev)
 int do_rmdir(char *pathname)
 {
 	if (dry_run) return 0;
+	CHECK_RO
 	return rmdir(pathname);
 }
 
 int do_open(char *pathname, int flags, mode_t mode)
 {
-	if (dry_run) return -1;
-	return open(pathname, flags, mode);
+	if (flags != O_RDONLY) {
+	    if (dry_run) return -1;
+	    CHECK_RO
+	}
+	/* some systems can't handle a double / */
+	if (pathname[0] == '/' && pathname[1] == '/') pathname++;
+
+	return open(pathname, flags | O_BINARY, mode);
 }
 
 #if HAVE_CHMOD
 int do_chmod(const char *path, mode_t mode)
 {
+	int code;
 	if (dry_run) return 0;
-	return chmod(path, mode);
+	CHECK_RO
+	code = chmod(path, mode);
+	if ((code != 0) && preserve_perms)
+	    return code;
+	return 0;
 }
 #endif
 
 int do_rename(char *fname1, char *fname2)
 {
 	if (dry_run) return 0;
+	CHECK_RO
 	return rename(fname1, fname2);
 }
 
+
+void trim_trailing_slashes(char *name)
+{
+	int l;
+	/* 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> */
+	
+	/* Don't change empty string; and also we can't improve on
+	 * "/" */
+	
+	l = strlen(name);
+	while (l > 1) {
+		if (name[--l] != '/')
+			break;
+		name[l] = '\0';
+	}
+}
+
+
 int do_mkdir(char *fname, mode_t mode)
 {
-	if (dry_run) return 0;
+	if (dry_run)
+		return 0;
+	CHECK_RO;
+	trim_trailing_slashes(fname);	
 	return mkdir(fname, mode);
 }
 
-char *do_mktemp(char *template)
+
+/* like mkstemp but forces permissions */
+int do_mkstemp(char *template, mode_t perms)
 {
-	if (dry_run) return NULL;
-	return mktemp(template);
+	if (dry_run) return -1;
+	if (read_only) {errno = EROFS; return -1;}
+
+#if defined(HAVE_SECURE_MKSTEMP) && defined(HAVE_FCHMOD)
+	{
+		int fd = mkstemp(template);
+		if (fd == -1) return -1;
+		if ((fchmod(fd, perms) != 0) && preserve_perms) {
+			close(fd);
+			unlink(template);
+			return -1;
+		}
+		return fd;
+	}
+#else
+	if (!mktemp(template)) return -1;
+	return do_open(template, O_RDWR|O_EXCL|O_CREAT, perms);
+#endif
+}
+
+int do_stat(const char *fname, STRUCT_STAT *st)
+{
+#if HAVE_OFF64_T
+	return stat64(fname, st);
+#else
+	return stat(fname, st);
+#endif
+}
+
+#if SUPPORT_LINKS
+int do_lstat(const char *fname, STRUCT_STAT *st)
+{
+#if HAVE_OFF64_T
+	return lstat64(fname, st);
+#else
+	return lstat(fname, st);
+#endif
+}
+#endif
+
+int do_fstat(int fd, STRUCT_STAT *st)
+{
+#if HAVE_OFF64_T
+	return fstat64(fd, st);
+#else
+	return fstat(fd, st);
+#endif
+}
+
+OFF_T do_lseek(int fd, OFF_T offset, int whence)
+{
+#if HAVE_OFF64_T
+	off64_t lseek64();
+	return lseek64(fd, offset, whence);
+#else
+	return lseek(fd, offset, whence);
+#endif
+}
+
+#ifdef USE_MMAP
+void *do_mmap(void *start, int len, int prot, int flags, int fd, OFF_T offset)
+{
+#if HAVE_OFF64_T
+	return mmap64(start, len, prot, flags, fd, offset);
+#else
+	return mmap(start, len, prot, flags, fd, offset);
+#endif
+}
+#endif
+
+char *d_name(struct dirent *di)
+{
+#if HAVE_BROKEN_READDIR
+	return (di->d_name - 2);
+#else
+	return di->d_name;
+#endif
 }

t_stub.c

@@ -0,0 +1,70 @@
+/*  -*- c-file-style: "linux" -*-
+ * 
+ * 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.
+*/
+
+#include "rsync.h"
+
+/**
+ * @file t_stub.c
+ *
+ * This file contains really simple implementations for rsync global
+ * functions, so that module test harnesses can run standalone.
+ **/
+
+int modify_window = 0;
+int module_id = -1;
+struct exclude_struct **server_exclude_list;
+
+ void rprintf(UNUSED(enum logcode code), const char *format, ...)
+{
+	va_list ap;
+	va_start(ap, format);
+	vfprintf(stderr, format, ap);
+	va_end(ap);
+}
+
+ void _exit_cleanup(int code, const char *file, int line)
+{
+	fprintf(stderr, "exit(%d): %s(%d)\n",
+		code, file, line);
+	exit(code);
+}
+
+ int check_exclude(UNUSED(struct exclude_struct **list), UNUSED(char *name),
+		   UNUSED(int name_is_dir))
+{
+	/* This function doesn't really get called in this test context, so
+	 * just return 0. */
+	return 0;
+}
+
+ char *lp_name(UNUSED(int mod))
+{
+    return NULL;
+}
+
+ BOOL lp_use_chroot(UNUSED(int mod))
+{
+    return 0;
+}
+
+ char *lp_path(UNUSED(int mod))
+{
+    return NULL;
+}
+

t_unsafe.c

@@ -0,0 +1,46 @@
+/*
+ * 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
+ * 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 
+ *
+ * Test harness for unsafe_symlink().  Not linked into @c rsync itself.
+ *
+ * Prints either "safe" or "unsafe" depending on the two arguments.
+ * Always returns 0 unless something extraordinary happens.
+ **/
+
+#include "rsync.h"
+
+int dry_run, read_only, list_only, verbose;
+int preserve_perms = 0;
+
+
+int
+main(int argc, char **argv)
+{
+	if (argc != 3) {
+		fprintf(stderr, "usage: t_unsafe LINKDEST SRCDIR\n");
+		return 1;
+	}
+
+	printf("%s\n",
+	       unsafe_symlink(argv[1], argv[2]) ? "unsafe" : "safe");
+	
+	return 0;
+}

tech_report.tex

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