Preparing for release of 2.6.4

did in older versions.
- Added a comment for log_format_has().

.cvsignore

@@ -1,21 +1,25 @@
-.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
+getfsdev
+.rsync-filter

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,58 @@
+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.
+
+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

@@ -9,69 +9,129 @@ mandir=@mandir@
 LIBS=@LIBS@
 CC=@CC@
 CFLAGS=@CFLAGS@
+CPPFLAGS=@CPPFLAGS@
+EXEEXT=@EXEEXT@
+LDFLAGS=@LDFLAGS@
 
 INSTALLCMD=@INSTALL@
+INSTALLMAN=@INSTALL@
 
 srcdir=@srcdir@
 VPATH=$(srcdir)
 SHELL=/bin/sh
 
+VERSION=@VERSION@
 
 .SUFFIXES:
 .SUFFIXES: .c .o
 
-HEADS=byteorder.h config.h errcode.h proto.h rsync.h version.h \
-	lib/fnmatch.h lib/getopt.h lib/mdfour.h
-LIBOBJ=lib/getopt.o lib/fnmatch.o lib/compat.o lib/snprintf.o lib/mdfour.o
+HEADERS=byteorder.h config.h errcode.h proto.h rsync.h lib/pool_alloc.h
+LIBOBJ=lib/wildmatch.o lib/compat.o lib/snprintf.o lib/mdfour.o \
+	lib/permstring.o lib/pool_alloc.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
+	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
-OBJS=$(OBJS1) $(OBJS2) $(DAEMON_OBJ) $(LIBOBJ) $(ZLIBOBJ)
+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/compat.o lib/snprintf.o lib/permstring.o
+
+# Programs we must have to run the test cases
+CHECK_PROGS = rsync$(EXEEXT) tls$(EXEEXT) getgroups$(EXEEXT) getfsdev$(EXEEXT) \
+	trimslash$(EXEEXT) t_unsafe$(EXEEXT) wildtest$(EXEEXT)
+
+# Objects for CHECK_PROGS to clean
+CHECK_OBJS=getgroups.o getfsdev.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:
 @OBJ_SAVE@
-	$(CC) -I. -I$(srcdir) $(CFLAGS) -c $< @CC_SHOBJ_FLAG@
+	$(CC) -I. -I$(srcdir) $(CFLAGS) $(CPPFLAGS) -c $< @CC_SHOBJ_FLAG@
 @OBJ_RESTORE@
 
-all: rsync
-
-man: rsync.1 rsyncd.conf.5
+all: rsync$(EXEEXT)
 
 install: all
-	-mkdir -p ${bindir}
-	${INSTALLCMD} -m 755 rsync ${bindir}
-	-mkdir -p ${mandir}/man1
-	-mkdir -p ${mandir}/man5
-	${INSTALLCMD} -m 644 $(srcdir)/rsync.1 ${mandir}/man1
-	${INSTALLCMD} -m 644 $(srcdir)/rsyncd.conf.5 ${mandir}/man5
+	-mkdir -p ${DESTDIR}${bindir}
+	${INSTALLCMD} ${INSTALL_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
 
 install-strip:
-	$(MAKE) INSTALLCMD='$(INSTALLCMD) -s' install
+	$(MAKE) INSTALL_STRIP='-s' install
 
-rsync: $(OBJS)
-	$(CC) $(CFLAGS) $(LDFLAGS) -o rsync $(OBJS) $(LIBS)
+rsync$(EXEEXT): $(OBJS)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
 
-$(OBJS): $(HEADS)
+$(OBJS): $(HEADERS)
 
-rsync.1: rsync.yo
-	yodl2man -o rsync.1 rsync.yo
+tls$(EXEEXT): $(TLS_OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(TLS_OBJ) $(LIBS)
 
-rsyncd.conf.5: rsyncd.conf.yo
-	yodl2man -o rsyncd.conf.5 rsyncd.conf.yo
+getgroups$(EXEEXT): getgroups.o
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ getgroups.o $(LIBS)
+
+getfsdev$(EXEEXT): getfsdev.o
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ getfsdev.o $(LIBS)
+
+TRIMSLASH_OBJ = trimslash.o syscall.o lib/compat.o lib/snprintf.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)
+
+gen: $(srcdir)/configure $(srcdir)/config.h.in proto man
+
+man: $(srcdir)/rsync.1 $(srcdir)/rsyncd.conf.5
+
+$(srcdir)/configure: $(srcdir)/configure.in $(srcdir)/aclocal.m4
+	cd $(srcdir); autoconf
+
+$(srcdir)/config.h.in: $(srcdir)/configure.in $(srcdir)/aclocal.m4
+	cd $(srcdir); autoheader
+
+$(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 lib/compat.c | awk -f mkproto.awk > proto.h
+	cat $(srcdir)/*.c $(srcdir)/lib/compat.c | awk -f $(srcdir)/mkproto.awk >$(srcdir)/proto.h.new
+	if diff $(srcdir)/proto.h $(srcdir)/proto.h.new >/dev/null; then \
+	  rm $(srcdir)/proto.h.new; \
+	else \
+	  mv $(srcdir)/proto.h.new $(srcdir)/proto.h; \
+	fi
 
-clean:
-	rm -f *~ $(OBJS) rsync 
+clean: cleantests
+	rm -f *~ $(OBJS) $(TLS_OBJ) $(CHECK_PROGS) $(CHECK_OBJS)
 
+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 config.h config.cache config.status Makefile
+	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
@@ -79,4 +139,60 @@ distclean: clean
 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 
+	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.
+
+# 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,384 @@
+NEWS for rsync 2.6.4 (30 March 2005)
+Protocol: 29 (changed)
+Changes since 2.6.3:
+
+  OUTPUT CHANGES:
+
+    - When rsync deletes a directory and outputs a verbose message about
+      it, it now appends a trailing slash to the name instead of (only
+      sometimes) outputting a preceding "directory " string.
+
+    - The --stats output will contain file-list time-statistics if both
+      sides are 2.6.4, or if the local side is 2.6.4 and the files are
+      being pushed (since the stats come from the sending side).
+      (Requires protocol 29 for a pull.)
+
+    - The "%o" (operation) log-format escape now has a third value (besides
+      "send" and "recv"):  "del." (with trailing dot to make it 4 chars).
+      This changes the way deletions are logged in the daemon's log file.
+
+    - When the --log-format option is combined with --verbose, rsync now
+      avoids outputting the name of the file twice in most circumstances.
+      As long as the --log-format item does not refer to any post-transfer
+      items (such as %b or %c), the --log-format message is output prior to
+      the transfer, so --verbose is now the equivalent of a --log-format of
+      '%n%L' (which outputs the name and any link info).  If the log output
+      must occur after the transfer to be complete, the only time the name
+      is also output prior to the transfer is when --progress was specified
+      (so that the name will precede the progress stats, and the full
+      --log-format output will come after).
+  
+  BUG FIXES:
+
+    - Restore the list-clearing behavior of "!" in a .cvsignore file (2.6.3
+      was only treating it as a special token in an rsync include/exclude
+      file).
+
+    - The combination of --verbose and --dry-run now mentions the full list
+      of changes that would be output without --dry-run.
+
+    - Avoid a mkdir warning when removing a directory in the destination
+      that already exists in the --backup-dir.
+
+    - An OS that has a binary mode for its files (such as cygwin) needed
+      setmode(fd, O_BINARY) called on the temp-file we opened with
+      mkstemp().  (Fix derived from the cygwin's 2.6.3 rsync package.)
+
+    - Fixed a potential hang when verbosity is high, the client side is
+      the sender, and the file-list is large.
+
+    - Fixed a potential protocol-corrupting bug where the generator could
+      merge a message from the receiver into the middle of a multiplexed
+      packet of data if only part of that data had been written out to the
+      socket when the message from the generator arrived.
+
+    - We now check if the OS doesn't support using mknod() for creating
+      FIFOs and sockets, and compile-in some compatibility code using
+      mkfifo() and socket() when necessary.
+
+    - Fixed an off-by-one error in the handling of --max-delete=N.  Also,
+      if the --max-delete limit is exceeded during a run, we now output a
+      warning about this at the end of the run and exit with a new error
+      code (25).
+
+    - One place in the code wasn't checking if fork() failed.
+
+    - The "ignore nonreadable" daemon parameter used to erroneously affect
+      readable symlinks that pointed to a non-existent file.
+
+    - If the OS does not have lchown() and a chown() of a symlink will
+      affect the referent of a symlink (as it should), we no longer try
+      to set the user and group of a symlink.
+
+    - The generator now properly runs the hard-link loop and the dir-time
+      rewriting loop after we're sure that the redo phase is complete.
+
+    - When --backup was specified with --partial-dir=DIR, where DIR is a
+      relative path, the backup code was erroneously trying to backup a
+      file that was put into the partial-dir.
+
+    - If a file gets resent in a single transfer and the --backup option is
+      enabled along with --inplace, rsync no longer performs a duplicate
+      backup (it used to overwrite the first backup with the failed file).
+
+    - One call to flush_write_file() was not being checked for an error.
+
+    - The --no-relative option was not being sent from the client to a
+      server sender.
+
+    - If an rsync daemon specified "dont compress = ..." for a file and the
+      client tried to specify --compress, the libz code was not handling a
+      compression level of 0 properly.  This could cause a transfer failure
+      if the block-size for a file was large enough (e.g. rsync might have
+      exited with an error for large files).
+
+    - Fixed a bug that would sometimes surface when using --compress and
+      sending a file with a block-size larger than 64K (either manually
+      specified, or computed due to the file being really large).  Prior
+      versions of rsync would sometimes fail to decompress the data
+      properly, and thus the transferred file would fail its verification.
+
+    - If a daemon can't open the specified log file (i.e. syslog is not
+      being used), die without crashing.  We also output an error about
+      the failure on stderr (which will only be seen if --no-detach was
+      specified) and exit with a new error code (6).
+
+    - A local transfer no longer duplicates all its include/exclude options
+      (since the forked process already has a copy of the exclude list,
+      there's no need to send them a set of duplicates).
+
+    - When --progress is specified, the output of items that the generator
+      is creating (e.g. dirs, symlinks) is now integrated into the progress
+      output without overlapping it.  (Requires protocol 29.)
+
+    - When --timeout is specified, lulls that occur in the transfer while
+      the generator is doing work that does not generate socket traffic
+      (looking for changed files, deleting files, doing directory-time
+      touch-ups, etc.) will cause a new keep-alive packet to be sent that
+      should keep the transfer going as long as the generator continues to
+      make progress.  (Requires protocol 29.)
+
+    - The stat size of a device is not added to the total file size of the
+      items in the transfer (the size might be undefined on some OSes).
+
+    - Fixed a problem with refused-option messages sometimes not making it
+      back to the client side when a remote --files-from was in effect and
+      the daemon was the receiver.
+
+    - The --compare-dest option was not updating a file that differred in
+      (the preserved) attributes from the version in the compare-dest DIR.
+
+    - When rsync is copying files into a write-protected directory, fixed
+      the change-report output for the directory so that we don't report
+      an identical directory as changed.
+
+  ENHANCEMENTS:
+
+    - Rsync now supports popt's option aliases, which means that you can
+      use /etc/popt and/or ~/.popt to create your own option aliases.
+
+    - Added the --delete-during (--del) option which will delete files
+      from the receiving side incrementally as each directory in the
+      transfer is being processed.  This makes it more efficient than the
+      default, before-the-transfer behavior, which is now also available as
+      --delete-before (and is still the default --delete-WHEN option that
+      will be chosen if --delete or --delete-excluded is specified without
+      a --delete-WHEN choice).  All the --del* options infer --delete, so
+      an rsync daemon that refuses "delete" will still refuse to allow any
+      file-deleting options (including the new --remove-sent-files option).
+
+    - All the --delete-WHEN options are now more memory efficient:
+      Previously an duplicate set of file-list objects was created on the
+      receiving side for the entire destination hierarchy.  The new
+      algorithm only creates one directory of objects at a time (for files
+      inside the transfer).
+
+    - Added the --copy-dest option, which works like --link-dest except
+      that it locally copies identical files instead of hard-linking them.
+
+    - Added support for specifying multiple --compare-dest, --copy-dest, or
+      --link-dest options, but only of a single type. (Promoted from the
+      patches dir and enhanced.) (Requires protocol 29.)
+
+    - Added the --max-size option. (Promoted from the patches dir.)
+
+    - The daemon-mode options are now separated from the normal rsync
+      options so that they can't be mixed together.  This makes it
+      impossible to start a daemon that has improper default option values
+      (which could cause problems when a client connects, such as hanging
+      or crashing).
+
+    - The --bwlimit option may now be used in combination with --daemon
+      to specify both a default value for the daemon side and a value
+      that cannot be exceeded by a user-specified --bwlimit option.
+
+    - Added the "port" parameter to the rsyncd.conf file. (Promoted from
+      the patches dir.)  Also added "address".  The command-line options
+      take precedence over a config-file option, as expected.
+
+    - In _exit_cleanup(): when we are exiting with a partially-received
+      file, we now flush any data in the write-cache before closing the
+      partial file.
+
+    - The --inplace support was enhanced to work with --compare-dest,
+      --link-dest, and (the new) --copy-dest options. (Requires protocol
+      29.)
+
+    - Added the --dirs (-d) option for an easier way to copy directories
+      without recursion.
+
+    - Added the --list-only option, which is mainly a way for the client to
+      put the server into listing mode without needing to resort to any
+      internal option kluges (e.g. the age-old use of "-r --exclude="/*/*"
+      for a non-recursive listing).  This option is used automatically
+      (behind the scenes) when a modern rsync speaks to a modern daemon,
+      but may also be specified manually if you want to force the use of
+      the --list-only option over a remote-shell connection.
+
+    - Added the --omit-dir-times (-O) option, which will avoid updating
+      the modified time for directories when --times was specified.  This
+      option will avoid an extra pass through the file-list at the end of
+      the transfer (to tweak all the directory times), which may provide
+      an appreciable speedup for a really large transfer. (Promoted from
+      the patches dir.)
+
+    - Added the --filter (-f) option and its helper option, -F.  Filter
+      rules are an extension to the existing include/exclude handling
+      that also supports nested filter files as well as per-directory
+      filter files (like .cvsignore, but with full filter-rule parsing).
+      This new option was chosen in order to ensure that all existing
+      include/exclude processing remained 100% compatible with older
+      versions.  Protocol 29 is needed for full filter-rule support, but
+      backward-compatible rules work with earlier protocol versions.
+      (Promoted from the patches dir and enhanced.)
+
+    - Added the --delay-updates option that puts all updated files into
+      a temporary directory (by default ".~tmp~", but settable via the
+      --partial-dir=DIR option) until the end of the transfer.  This
+      makes the updates a little more atomic for a large transfer.
+
+    - If rsync is put into the background, any output from --progress is
+      reduced.
+
+    - Documented the "max verbosity" setting for rsyncd.conf.  (This
+      setting was added a couple releases ago, but left undocumented.)
+
+    - The sender and the generator now double-check the file-list index
+      they are given, and refuse to try to do a file transfer on a
+      non-file index (since that would indicate that something had gone
+      very wrong).
+
+    - Added the --itemize-changes (-i) option, which is a way to output a
+      more detailed list of what files changed and in what way.  The effect
+      is the same as specifying a --log-format of "%i %n%L" (see both the
+      rsync and rsyncd.conf manpages).  Works with --dry-run too.
+
+    - Added the --fuzzy (-y) option, which attempts to find a basis file
+      for a file that is being created from scratch.  The current algorithm
+      only looks in the destination directory for the created file, but it
+      does attempt to find a match based on size/mod-time (in case the file
+      was renamed with no other changes) as well as based on a fuzzy
+      name-matching algorithm.  This option requires protocol 29 because it
+      needs the new file-sorting order.  (Promoted from patches dir and
+      enhanced.) (Requires protocol 29.)
+
+    - Added the --remove-sent-files option, which lets you move files
+      between systems.
+
+    - The hostname in HOST:PATH or HOST::PATH may now be an IPv6 literal
+      enclosed in '[' and ']' (e.g. "[::1]").  (We already allowed IPv6
+      literals in the rsync://HOST:PORT/PATH format.)
+
+    - When rsync recurses to build the file list, it no longer keeps open
+      one or more directory handles from the dir's parent dirs.
+
+    - When building under windows, the default for --daemon is now to
+      avoid detaching, requiring the new --detach option to force rsync
+      to detach.
+
+    - The --dry-run option can now be combined with either --write-batch or
+      --read-batch, allowing you to run a do-nothing test command to see
+      what would happen without --dry-run.
+
+    - The daemon's "read only" config item now sets an internal read_only
+      variable that makes extra sure that no write/delete calls on the
+      read-only side can succeed.
+
+    - The log-format % escapes can now have a numeric field width in
+      between the % and the escape letter (e.g. "%-40n %08p").
+
+    - Improved the option descriptions in the --help text.
+
+  SUPPORT FILES:
+
+    - Added atomic-rsync to the support dir: a perl script that will
+      transfer some files using rsync, and then move the updated files into
+      place all at once at the end of the transfer.  Only works when
+      pulling, and uses --link-dest and a parallel hierarchy of files to
+      effect its update.
+
+    - Added mnt-excl to the support dir: a perl script that takes the
+      /proc/mounts file and translates it into a set of excludes that will
+      exclude all mount points (even mapped mounts to the same disk).  The
+      excludes are made relative to the specified source dir and properly
+      anchored.
+
+    - Added savetransfer.c to the support dir: a C program that can make
+      a copy of all the data that flows over the wire.  This lets you test
+      for data corruption (by saving the data on both the sending side and
+      the receiving side) and provides one way to debug a protocol error.
+
+    - Added rrsync to the support dir: this is an updated version of Joe
+      Smith's restricted rsync perl script.  This helps to ensure that only
+      certain rsync commands can be run by an ssh invocation.
+
+  INTERNAL:
+
+    - Added better checking of the checksum-header values that come over
+      the socket.
+
+    - Merged a variety of file-deleting functions into a single function so
+      that it is easier to maintain.
+
+    - Improved the type of some variables (particularly blocksize vars) for
+      consistency and proper size.
+
+    - Got rid of the uint64 type (which we didn't need).
+
+    - Use a slightly more compatible set of core #include directives.
+
+    - Defined int32 in a way that ensures that the build dies if we can't
+      find a variable with at least 32 bits.
+
+  PROTOCOL DIFFERENCES FOR VERSION 29:
+
+    - A 16-bit flag-word is transmitted after every file-list index.  This
+      indicates what is changing between the sender and the receiver.  The
+      generator now transmits an index and a flag-word to indicate when
+      dirs and symlinks have changed (instead of producing a message),
+      which makes the outputting of the information more consistent and
+      less prone to screen corruption (because the local receiver/sender is
+      now outputting all the file-change info messages).
+
+    - If a file is being hard-linked, the ITEM_XNAME_FOLLOWS bit is enabled
+      in the flag-word and the name of the file that was linked immediately
+      follows in vstring format (see below).
+
+    - If a file is being transferred with an alternate-basis file, the
+      ITEM_BASIS_TYPE_FOLLOWS bit is enabled in the flag-word and a single
+      byte follows, indicating what type of basis file was chosen.  If that
+      indicates that a fuzzy-match was selected, the ITEM_XNAME_FOLLOWS bit
+      is set in the flag-word and the name of the match in vstring format
+      follows the basis byte.  A vstring is a variable length string that
+      has its size written prior to the string, and no terminating null.
+      If the string is from 1-127 bytes, the length is a single byte.  If
+      it is from 128-32767 bytes, the length is written as ((len >> 8) |
+      0x80) followed by (len % 0x100).
+
+    - The sending of exclude names is done using filter-rule syntax.  This
+      means that all names have a prefixed rule indicator, even excludes
+      (which used to be sent as a bare pattern, when possible).  The -C
+      option will include the per-dir .cvsignore merge file in the list of
+      filter rules so it is positioned correctly (unlike in some older
+      transfer scenarios).
+
+    - Rsync sorts the filename list in a different way: it sorts the subdir
+      names after the non-subdir names for each dir's contents, and it
+      always puts a dir's contents immediately after the dir's name in the
+      list.  (Previously an item named "foo.txt" would sort in between
+      directory "foo/" and "foo/bar".)
+
+    - When talking to a protocol 29 rsync daemon, a list-only request
+      is able to note this before the options are sent over the wire and
+      the new --list-only option is included in the options.
+
+    - When the --stats bytes are sent over the wire (or stored in a batch),
+      they now include two elapsed-time values: one for how long it took to
+      build the file-list, and one for how long it took to send it over the
+      wire (each expressed in thousandths of a second).
+
+    - When --delete-excluded is specified with some filter rules (AKA
+      excludes), a client sender will now initiate a send of the rules to
+      the receiver (older protocols used to omit the sending of excludes in
+      this situation since there were no receiver-specific rules that
+      survived --delete-excluded back then).  Note that, as with all the
+      filter-list sending, only items that are significant to the other
+      side will actually be sent over the wire, so the filter-rule list
+      that is sent in this scenario is often empty.
+
+    - An index equal to the file-list count is sent as a keep-alive packet
+      from the generator to the sender, which then forwards it on to the
+      receiver.  This normally invalid index is only a valid keep-alive
+      packet if the 16-bit flag-word that follows it contains a single bit
+      (ITEM_IS_NEW, which is normally an illegal flag to appear alone).
+
+    - A protocol-29 batch file includes a bit for the setting of the --dirs
+      option and for the setting of the --compress option.  Also, the shell
+      script created by --write-batch will use the --filter option instead
+      of --exclude-from to capture any filter rules.
+
+  BUILD CHANGES:
+
+    - Handle an operating system that use mkdev() in place of makedev().
+
+    - Improved configure to better handle cross-compiling.

README

@@ -1,7 +1,7 @@
 WHAT IS RSYNC?
 --------------
 
-rsync is a replacement for rcp that has many more features.
+rsync is a replacement for scp/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
@@ -18,83 +18,25 @@ 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 rsync usage:
-
-Usage: rsync [OPTION]... SRC [SRC]... [USER@]HOST:DEST
-  or   rsync [OPTION]... [USER@]HOST:SRC DEST
-  or   rsync [OPTION]... SRC [SRC]... DEST
-  or   rsync [OPTION]... [USER@]HOST::SRC [DEST]
-  or   rsync [OPTION]... SRC [SRC]... [USER@]HOST::DEST
-  or   rsync [OPTION]... rsync://[USER@]HOST[:PORT]/SRC [DEST]
-SRC on single-colon remote HOST will be expanded by remote shell
-SRC on server remote HOST may contain shell wildcards or multiple
-  sources separated by space as long as they have same top-level
-
-Options
- -v, --verbose               increase verbosity
- -q, --quiet                 decrease verbosity
- -c, --checksum              always checksum
- -a, --archive               archive mode
- -r, --recursive             recurse into directories
- -R, --relative              use relative path names
- -b, --backup                make backups (default ~ suffix)
-     --suffix=SUFFIX         override backup suffix
- -u, --update                update only (don't overwrite newer files)
- -l, --links                 preserve soft links
- -L, --copy-links            treat soft links like regular files
-     --copy-unsafe-links     copy links outside the source tree
-     --safe-links            ignore links outside the destination tree
- -H, --hard-links            preserve hard links
- -p, --perms                 preserve permissions
- -o, --owner                 preserve owner (root only)
- -g, --group                 preserve group
- -D, --devices               preserve devices (root only)
- -t, --times                 preserve times
- -S, --sparse                handle sparse files efficiently
- -n, --dry-run               show what would have been transferred
- -W, --whole-file            copy whole files, no incremental checks
- -x, --one-file-system       don't cross filesystem boundaries
- -B, --block-size=SIZE       checksum blocking size (default 700)
- -e, --rsh=COMMAND           specify rsh replacement
-     --rsync-path=PATH       specify path to rsync on the remote machine
- -C, --cvs-exclude           auto ignore files in the same way CVS does
-     --delete                delete files that don't exist on the sending side
-     --delete-excluded       also delete excluded files on the receiving side
-     --partial               keep partially transferred files
-     --force                 force deletion of directories even if not empty
-     --numeric-ids           don't map uid/gid values by user/group name
-     --timeout=TIME          set IO timeout in seconds
- -I, --ignore-times          don't exclude files that match length and time
-     --size-only             only use file size when determining if a file should be transferred
- -T  --temp-dir=DIR          create temporary files in directory DIR
-     --compare-dest=DIR      also compare destination files relative to DIR
- -z, --compress              compress file data
-     --exclude=PATTERN       exclude files matching PATTERN
-     --exclude-from=FILE     exclude patterns listed in FILE
-     --include=PATTERN       don't exclude files matching PATTERN
-     --include-from=FILE     don't exclude patterns listed in FILE
-     --version               print version number
-     --daemon                run as a rsync daemon
-     --config=FILE           specify alternate rsyncd.conf file
-     --port=PORT             specify alternate rsyncd port number
-     --stats                 give some file transfer stats
-     --progress              show progress during transfer
-     --log-format=FORMAT     log file transfers using specified format
-     --password-file=FILE    get password from FILE
- -h, --help                  show this help screen
+  rsync --help
 
+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 privileges for installation. It does not
-require a inetd entry or a daemon. You must, however, have a working
-rsh or ssh system. Using ssh is recommended for its security
-features. 
+Rsync normally uses ssh or rsh for communication.  It does not need to
+be setuid and requires no special privileges for installation.  You
+must, however, have a working ssh or rsh 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
@@ -125,8 +67,7 @@ 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.org 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.org
 
@@ -135,15 +76,18 @@ BUG REPORTS
 -----------
 
 If you have web access then please look at
-http://rsync.samba.org/rsync/ 
 
-This will give you access to the bug tracking system used by the
-developers of rsync and will allow you to look at other bug reports or
-submit a new bug report.
+  http://rsync.samba.org/
 
-If you don't have web access then mail bug reports to
-rsync-bugs@samba.org or (if you think it will be of interest to lots
-of people) send it to rsync@samba.org
+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/
+
+To send a bug report, follow the instructions on the bug-tracking
+page of the web site.
 
 
 CVS TREE
@@ -153,10 +97,10 @@ If you want to get the very latest version of rsync direct from the
 source code repository then you can use anonymous cvs. You will need a
 recent version of cvs then use the following commands:
 
-	cvs -d :pserver:cvs@cvs.samba.org:/cvsroot login
+	cvs -d :pserver:cvs@pserver.samba.org:/cvsroot login
 	Password: cvs
 
-	cvs -d :pserver:cvs@cvs.samba.org:/cvsroot co rsync
+	cvs -d :pserver:cvs@pserver.samba.org:/cvsroot co rsync
 
 Look at the cvs documentation for more details.
 
@@ -164,11 +108,12 @@ Look at the cvs documentation 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.org
-paulus@cs.anu.edu.au
+  http://www.fsf.org/licenses/gpl.html
 
 
 AVAILABILITY

TODO

@@ -0,0 +1,658 @@
+-*- indented-text -*-
+
+BUGS ---------------------------------------------------------------
+Do not rely on having a group called "nobody"
+
+FEATURES ------------------------------------------------------------
+Use chroot only if supported
+Allow supplementary groups in rsyncd.conf			2002/04/09
+Handling IPv6 on old machines
+Other IPv6 stuff:
+Add ACL support							2001/12/02
+Lazy directory creation
+proxy authentication						2002/01/23
+SOCKS								2002/01/23
+FAT support
+Allow forcing arbitrary permissions				2002/03/12
+--diff						david.e.sewell	2002/03/15
+Add daemon --no-fork option
+Create more granular verbosity				jw	2003/05/15
+
+DOCUMENTATION --------------------------------------------------------
+Keep list of open issues and todos on the web site
+Perhaps redo manual as SGML
+
+LOGGING --------------------------------------------------------------
+Memory accounting
+Improve error messages
+Better statistics:					Rasmus	2002/03/08
+Perhaps flush stdout like syslog
+Log deamon sessions that just list modules
+Log child death on signal
+Log errors with function that reports process of origin
+verbose output					David Stein	2001/12/20
+internationalization
+
+DEVELOPMENT --------------------------------------------------------
+Handling duplicate names
+Use generic zlib						2002/02/25
+TDB:								2002/03/12
+Splint								2002/03/12
+
+PERFORMANCE ----------------------------------------------------------
+File list structure in memory
+Traverse just one directory at a time
+Allow skipping MD4 file_sum					2002/04/08
+Accelerate MD4
+
+TESTING --------------------------------------------------------------
+Torture test
+Cross-test versions						2001/08/22
+Test on kernel source
+Test large files
+Create mutator program for testing
+Create configure option to enable dangerous tests
+If tests are skipped, say why.
+Test daemon feature to disallow particular options.
+Create pipe program for testing
+Create test makefile target for some tests
+
+RELATED PROJECTS -----------------------------------------------------
+rsyncsh
+http://rsync.samba.org/rsync-and-debian/
+rsyncable gzip patch
+rsyncsplit as alternative to real integration with gzip?
+reverse rsync over HTTP Range
+
+
+
+BUGS ---------------------------------------------------------------
+
+
+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"
+
+                      --          --
+
+FEATURES ------------------------------------------------------------
+
+
+Use chroot only if supported
+
+  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
+
+                      --          --
+
+
+Allow supplementary groups in rsyncd.conf			2002/04/09
+
+  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.
+
+                      --          --
+
+
+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.
+
+                      --          --
+
+
+Add ACL support							2001/12/02
+
+  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.
+  NOTE: there is a patch that implements this in the "patches" subdir.
+
+                      --          --
+
+
+Lazy directory creation
+
+  With the current common --include '*/' --exclude '*' pattern, people
+  can end up with many empty directories.  We might avoid this by
+  lazily creating such directories.
+
+                      --          --
+
+
+proxy authentication						2002/01/23
+
+  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								2002/01/23
+
+  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.
+
+                      --          --
+
+
+Allow forcing arbitrary permissions				2002/03/12
+
+  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)
+
+  NOTE: there is a patch that implements this in the "patches" subdir.
+
+                      --          --
+
+
+--diff						david.e.sewell	2002/03/15
+
+  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?
+
+                      --          --
+
+
+Add daemon --no-fork option
+
+  Very useful for debugging.  Also good when running under a
+  daemon-monitoring process that tries to restart the service when the
+  parent exits.
+
+                      --          --
+
+
+Create more granular verbosity				jw	2003/05/15
+
+  Control output with the --report option.
+
+  The option takes as a single argument (no whitespace) a
+  comma delimited lists of keywords.
+
+  This would separate debugging from "logging" as well as
+  fine grained selection of statistical reporting and what
+  actions are logged.
+
+  http://lists.samba.org/archive/rsync/2003-May/006059.html
+
+                      --          --
+
+DOCUMENTATION --------------------------------------------------------
+
+
+Keep list of open issues and todos on the web site
+
+                      --          --
+
+
+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.
+
+                      --          --
+
+LOGGING --------------------------------------------------------------
+
+
+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.
+
+                      --          --
+
+
+Improve error messages
+
+  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.
+
+  When running as a daemon, some errors should both be returned to the
+  user and logged.  This will make interacting with a daemon less
+  cryptic.
+
+                      --          --
+
+
+Better statistics:					Rasmus	2002/03/08
+
+  <Rasmus>
+      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>
+      nice idea there is --stats but at the moment it's very
+      tridge-oriented rather than user-friendly it would be
+      nice to improve it that would also work well with
+      --dryrun
+
+                      --          --
+
+
+Perhaps flush stdout like syslog
+
+  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
+
+                      --          --
+
+
+Log deamon sessions that just list modules
+
+  At the connections that just get a list of modules are not logged,
+  but they should be.
+
+                      --          --
+
+
+Log child death on signal
+
+  If a child of the rsync daemon dies with a signal, we should notice
+  that when we reap it and log a message.
+
+                      --          --
+
+
+Log errors with function that reports process of origin
+
+  Use a separate function for reporting errors; prefix it with
+  "rsync:" or "rsync(remote)", or perhaps even "rsync(local
+  generator): ".
+
+                      --          --
+
+
+verbose output					David Stein	2001/12/20
+  
+  At end of transfer, show how many files were or were not transferred
+  correctly.
+
+                      --          --
+
+
+internationalization
+
+  Change to using gettext().  Probably need to ship this for platforms
+  that don't have it.
+
+  Solicit translations.
+
+  Does anyone care?  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.
+
+                      --          --
+
+DEVELOPMENT --------------------------------------------------------
+
+Handling duplicate names
+
+  Some folks would like rsync to be deterministic in how it handles
+  duplicate names that come from mering multiple source directories
+  into a single destination directory; e.g. the last name wins.  We
+  could do this by switching our sort algorithm to one that will
+  guarantee that the names won't be reordered.  Alternately, we could
+  assign an ever-increasing number to each item as we insert it into
+  the list and then make sure that we leave the largest number when
+  cleaning the file list (see clean_flist()).  Another solution would
+  be to add a hash table, and thus never put any duplicate names into
+  the file list (and bump the protocol to handle this).
+
+                      --          --
+
+
+Use generic zlib						2002/02/25
+
+  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.
+
+                      --          --
+
+
+TDB:								2002/03/12
+
+  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.
+
+                      --          --
+
+
+Splint								2002/03/12
+
+  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.
+
+                      --          --
+
+PERFORMANCE ----------------------------------------------------------
+
+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.
+
+                      --          --
+
+
+Traverse just one directory at a time
+
+  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.
+
+                      --          --
+
+
+Allow skipping MD4 file_sum					2002/04/08
+
+  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.
+
+  We should not allow it to be disabled separately from -W, though
+  as it is the only thing that lets us know when the rsync algorithm
+  got out of sync and messed the file up (i.e. if the basis file
+  changed between checksum generation and reception).
+
+                      --          --
+
+
+Accelerate 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?
+
+                      --          --
+
+TESTING --------------------------------------------------------------
+
+Torture test
+
+  Something that just keeps running rsync continuously over a data set
+  likely to generate problems.
+
+                      --          --
+
+
+Cross-test versions						2001/08/22
+
+  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.
+
+  Run current rsync versions against significant past releases.
+
+  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.
+
+  The new --protocol option may help in this.
+
+                      --          --
+
+
+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
+
+                      --          --
+
+
+Create mutator program for testing
+
+  Insert bytes, delete bytes, swap blocks, ...
+
+                      --          --
+
+
+Create configure option to enable dangerous tests
+
+                      --          --
+
+
+If tests are skipped, say why.
+
+                      --          --
+
+
+Test daemon feature to disallow particular options.
+
+                      --          --
+
+
+Create pipe program for testing
+
+  Create pipe program that makes slow/jerky connections for
+  testing Versions of read() and write() that corrupt the
+  stream, or abruptly fail
+
+                      --          --
+
+
+Create test makefile target for some tests
+
+  Separate makefile target to run rough tests -- or perhaps
+  just run them every time?
+
+                      --          --
+
+RELATED PROJECTS -----------------------------------------------------
+
+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.
+
+                      --          --
+
+
+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.
+
+  Addendum:  It looks like someone is working on a version of this:
+
+    http://zsync.moria.org.uk/
+
+                      --          --
+

access.c

@@ -26,57 +26,192 @@
 
 static int match_hostname(char *host, char *tok)
 {
-	if (!host || !*host) return 0;
-	return (fnmatch(tok, host, 0) == 0);
+	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;
-	unsigned long a, t, mask = (unsigned long)~0;
+	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;
-
-	if (!isdigit(tok[0])) return 0;
+	if (!addr || !*addr)
+		return 0;
 
 	p = strchr(tok,'/');
-	if (p) *p = 0;
-
-	a = inet_addr(addr);
-	t = inet_addr(tok);
-
 	if (p) {
-		*p = '/';
-	}
+		*p = '\0';
+		len = p - tok;
+	} else
+		len = strlen(tok);
 
-	if (t == INADDR_NONE) {
-		rprintf(FERROR,"malformed address %s\n", tok);
+	/* Fail quietly if tok is a hostname (not an address) */
+	if (strspn(tok, ".0123456789") != len
+#ifdef INET6
+	    && strchr(tok, ':') == NULL
+#endif
+	) {
+		if (p)
+			*p = '/';
 		return 0;
 	}
 
-	a = ntohl(a);
-	t = ntohl(t);
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = PF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+#ifdef AI_NUMERICHOST
+	hints.ai_flags = AI_NUMERICHOST;
+#endif
 
-	if (p) {
-		if (strchr(p+1,'.')) {
-			mask = inet_addr(p+1);
-			if (mask == INADDR_NONE) {
-				rprintf(FERROR,"malformed mask in %s\n", tok);
-				return 0;
-			}
-			mask = ntohl(mask);
-		} else {
-			int bits = atoi(p+1);
-			if (bits <= 0 || bits > 32) {
-				rprintf(FERROR,"malformed mask in %s\n", tok);
-				return 0;
-			}
-			mask &= (mask << (32-bits));
-		}
+	if (getaddrinfo(addr, NULL, &hints, &resa) != 0) {
+		if (p)
+			*p = '/';
+		return 0;
 	}
 
-	return ((a&mask) == (t&mask));
+	gai = getaddrinfo(tok, NULL, &hints, &rest);
+	if (p)
+		*p++ = '/';
+	if (gai != 0) {
+		rprintf(FLOG, "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(FLOG, "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(FLOG, "malformed mask in %s\n", tok);
+				ret = 0;
+				goto out;
+			}
+#else
+			for (pp = (unsigned char *)p; *pp; pp++) {
+				if (!isascii(*pp) || !isdigit(*pp)) {
+					rprintf(FLOG, "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(FLOG, "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)
@@ -84,12 +219,14 @@ static int access_match(char *list, char *addr, char *host)
 	char *tok;
 	char *list2 = strdup(list);
 
-	if (!list2) out_of_memory("access_match");
+	if (!list2)
+		out_of_memory("access_match");
 
 	strlower(list2);
-	if (host) strlower(host);
+	if (host)
+		strlower(host);
 
-	for (tok=strtok(list2," ,\t"); tok; tok=strtok(NULL," ,\t")) {
+	for (tok = strtok(list2, " ,\t"); tok; tok = strtok(NULL, " ,\t")) {
 		if (match_hostname(host, tok) || match_address(addr, tok)) {
 			free(list2);
 			return 1;
@@ -102,29 +239,25 @@ static int access_match(char *list, char *addr, char *host)
 
 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 (allow_list && !*allow_list)
+		allow_list = NULL;
+	if (deny_list && !*deny_list)
+		deny_list = NULL;
 
-	/* 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 we match an allow-list item, we always allow access. */
+	if (allow_list) {
+		if (access_match(allow_list, addr, host))
+			return 1;
+		/* For an allow-list w/o a deny-list, disallow non-matches. */
+		if (!deny_list)
+			return 0;
+	}
 
-	/* 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))
+	/* If we match a deny-list item (and got past any allow-list
+	 * items), we always disallow access. */
+	if (deny_list && access_match(deny_list, addr, host))
 		return 0;
 
+	/* Allow all other access. */
 	return 1;
 }

acconfig.h

@@ -1,14 +0,0 @@
-#undef HAVE_BROKEN_READDIR
-#undef HAVE_ERRNO_DECL
-#undef HAVE_LONGLONG
-#undef HAVE_OFF64_T
-#undef HAVE_REMSH
-#undef HAVE_UNSIGNED_CHAR
-#undef HAVE_UTIMBUF
-#undef ino_t
-#undef HAVE_CONNECT
-#undef HAVE_SHORT_INO_T
-#undef HAVE_GETOPT_LONG
-#undef REPLACE_INET_NTOA
-#undef HAVE_GETTIMEOFDAY_TZ
-#undef HAVE_SOCKETPAIR

aclocal.m4

@@ -21,3 +21,51 @@ AC_DEFUN(AC_VALIDATE_CACHE_SYSTEM_TYPE, [
     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

@@ -1,16 +1,17 @@
-/* 
-   Copyright (C) Andrew Tridgell 1998
-   
+/* -*- 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.
@@ -19,11 +20,14 @@
 /* support rsync authentication */
 #include "rsync.h"
 
+extern char *password_file;
+extern int am_root;
+
 /***************************************************************************
 encode a buffer using base64 - simple and slow algorithm. null terminates
 the result.
   ***************************************************************************/
-static void base64_encode(char *buf, int len, char *out)
+void base64_encode(char *buf, int len, char *out)
 {
 	char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 	int bit_offset, byte_offset, idx, i;
@@ -32,7 +36,7 @@ static void base64_encode(char *buf, int len, char *out)
 
 	memset(out, 0, bytes+1);
 
-	for (i=0;i<bytes;i++) {
+	for (i = 0; i < bytes; i++) {
 		byte_offset = (i*6)/8;
 		bit_offset = (i*6)%8;
 		if (bit_offset < 3) {
@@ -53,7 +57,7 @@ static void gen_challenge(char *addr, char *challenge)
 	char input[32];
 	struct timeval tv;
 
-	memset(input, 0, sizeof(input));
+	memset(input, 0, sizeof input);
 
 	strlcpy((char *)input, addr, 17);
 	sys_gettimeofday(&tv);
@@ -61,122 +65,132 @@ static void gen_challenge(char *addr, char *challenge)
 	SIVAL(input, 20, tv.tv_usec);
 	SIVAL(input, 24, getpid());
 
-	sum_init();
-	sum_update(input, sizeof(input));
+	sum_init(0);
+	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 */
+/* Return the secret for a user from the secret file, null terminated.
+ * Maximum length is len (not counting the null). */
 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;
+	int fd, ok = 1;
+	char ch, *p;
 
-	if (!fname || !*fname) return 0;
+	if (!fname || !*fname)
+		return 0;
 
-	fd = open(fname,O_RDONLY);
-	if (fd == -1) return 0;
+	if ((fd = open(fname, O_RDONLY)) < 0)
+		return 0;
 
 	if (do_stat(fname, &st) == -1) {
-		rprintf(FERROR,"stat(%s) : %s\n", fname, strerror(errno));
+		rsyserr(FLOG, errno, "stat(%s)", safe_fname(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");
+			rprintf(FLOG, "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");
+			rprintf(FLOG, "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");
+		rprintf(FLOG, "continuing without secrets file\n");
 		close(fd);
 		return 0;
 	}
 
-	while (!found) {
-		int i = 0;
-		memset(line, 0, sizeof(line));
-		while (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;
+	if (*user == '#') {
+		/* Reject attempt to match a comment. */
+		close(fd);
+		return 0;
 	}
 
-	close(fd);
-	if (!found) return 0;
+	/* Try to find a line that starts with the user name and a ':'. */
+	p = user;
+	while (1) {
+		if (read(fd, &ch, 1) != 1) {
+			close(fd);
+			return 0;
+		}
+		if (ch == '\n')
+			p = user;
+		else if (p) {
+			if (*p == ch)
+				p++;
+			else if (!*p && ch == ':')
+				break;
+			else
+				p = NULL;
+		}
+	}
+
+	/* Slurp the secret into the "secret" buffer. */
+	p = secret;
+	while (len > 0) {
+		if (read(fd, p, 1) != 1 || *p == '\n')
+			break;
+		if (*p == '\r')
+			continue;
+		p++;
+		len--;
+	}
+	*p = '\0';
+	close(fd);
 
-	strlcpy(secret, pass, len);
 	return 1;
 }
 
 static char *getpassf(char *filename)
 {
-	char buffer[100];
-	int len=0;
-	int fd=0;
 	STRUCT_STAT st;
-	int ok = 1;
-	extern int am_root;
-	char *envpw=getenv("RSYNC_PASSWORD");
+	char buffer[512], *p;
+	int fd, n, ok = 1;
+	char *envpw = getenv("RSYNC_PASSWORD");
 
-	if (!filename) return NULL;
+	if (!filename)
+		return NULL;
 
-	if ( (fd=open(filename,O_RDONLY)) == -1) {
-		rprintf(FERROR,"could not open password file \"%s\"\n",filename);
-		if (envpw) rprintf(FERROR,"falling back to RSYNC_PASSWORD environment variable.\n");	
+	if ((fd = open(filename,O_RDONLY)) < 0) {
+		rsyserr(FERROR, errno, "could not open password file \"%s\"",
+			safe_fname(filename));
+		if (envpw)
+			rprintf(FERROR, "falling back to RSYNC_PASSWORD environment variable.\n");
 		return NULL;
 	}
-	
+
 	if (do_stat(filename, &st) == -1) {
-		rprintf(FERROR,"stat(%s) : %s\n", filename, strerror(errno));
+		rsyserr(FERROR, errno, "stat(%s)", safe_fname(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)) {
+	} 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");
+		if (envpw)
+			rprintf(FERROR, "using RSYNC_PASSWORD environment variable.\n");
 		close(fd);
 		return NULL;
 	}
 
-	if (envpw) rprintf(FERROR,"RSYNC_PASSWORD environment variable ignored\n");
+	if (envpw)
+		rprintf(FERROR, "RSYNC_PASSWORD environment variable ignored\n");
 
-	buffer[sizeof(buffer)-1]='\0';
-	if ( (len=read(fd,buffer,sizeof(buffer)-1)) > 0)
-	{
-		char *p = strtok(buffer,"\n\r");
-		close(fd);
-		if (p) p = strdup(p);
-		return p;
-	}	
+	n = read(fd, buffer, sizeof buffer - 1);
+	close(fd);
+	if (n > 0) {
+		buffer[n] = '\0';
+		if ((p = strtok(buffer, "\n\r")) != NULL)
+			return strdup(p);
+	}
 
 	return NULL;
 }
@@ -186,7 +200,7 @@ static void generate_hash(char *in, char *challenge, char *out)
 {
 	char buf[16];
 
-	sum_init();
+	sum_init(0);
 	sum_update(in, strlen(in));
 	sum_update(challenge, strlen(challenge));
 	sum_end(buf);
@@ -194,16 +208,13 @@ static void generate_hash(char *in, char *challenge, char *out)
 	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 fd, int module, char *addr, char *leader)
+/* Possibly 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];
@@ -216,46 +227,46 @@ char *auth_server(int fd, int module, char *addr, char *leader)
 	char *tok;
 
 	/* if no auth list then allow anyone in! */
-	if (!users || !*users) return "";
+	if (!users || !*users)
+		return "";
 
 	gen_challenge(addr, challenge);
-	
+
 	base64_encode(challenge, 16, b64_challenge);
 
-	io_printf(fd,"%s%s\n", leader, b64_challenge);
+	io_printf(f_out, "%s%s\n", leader, b64_challenge);
 
-	if (!read_line(fd, line, sizeof(line)-1)) {
+	if (!read_line(f_in, line, sizeof line - 1))
 		return NULL;
-	}
 
-	memset(user, 0, sizeof(user));
-	memset(pass, 0, sizeof(pass));
+	memset(user, 0, sizeof user);
+	memset(pass, 0, sizeof pass);
 
-	if (sscanf(line,"%99s %29s", user, pass) != 2) {
+	if (sscanf(line,"%99s %29s", user, pass) != 2)
 		return NULL;
-	}
 
 	users = strdup(users);
-	if (!users) return NULL;
+	if (!users)
+		return NULL;
 
 	for (tok=strtok(users," ,\t"); tok; tok = strtok(NULL," ,\t")) {
-		if (strcmp(tok, user) == 0) break;
+		if (wildmatch(tok, user))
+			break;
 	}
 	free(users);
 
-	if (!tok) {
+	if (!tok)
 		return NULL;
-	}
-	
-	memset(secret, 0, sizeof(secret));
-	if (!get_secret(module, user, secret, sizeof(secret)-1)) {
-		memset(secret, 0, sizeof(secret));
+
+	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));
-	
+	memset(secret, 0, sizeof secret);
+
 	if (strcmp(pass, pass2) == 0)
 		return user;
 
@@ -267,17 +278,26 @@ void auth_client(int fd, char *user, char *challenge)
 {
 	char *pass;
 	char pass2[30];
-	extern char *password_file;
 
-	if (!user || !*user) return;
+	if (!user || !*user)
+		user = "nobody";
 
-	if (!(pass=getpassf(password_file)) && !(pass=getenv("RSYNC_PASSWORD"))) {
+	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) {
+	if (!pass)
 		pass = "";
-	}
 
 	generate_hash(pass, challenge, pass2);
 	io_printf(fd, "%s %s\n", user, pass2);

backup.c

@@ -1,16 +1,16 @@
-/* 
+/*
    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.
@@ -21,268 +21,259 @@
 #include "rsync.h"
 
 extern int verbose;
+extern int backup_suffix_len;
+extern int backup_dir_len;
+extern unsigned int backup_dir_remainder;
+extern char backup_dir_buf[MAXPATHLEN];
 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;
+extern int orig_umask;
+extern int safe_symlinks;
+
+/* make a complete pathname for backup file */
+char *get_backup_name(char *fname)
+{
+	if (backup_dir) {
+		if (stringjoin(backup_dir_buf + backup_dir_len, backup_dir_remainder,
+			       fname, backup_suffix, NULL) < backup_dir_remainder)
+			return backup_dir_buf;
+	} else {
+		if (stringjoin(backup_dir_buf, MAXPATHLEN,
+			       fname, backup_suffix, NULL) < MAXPATHLEN)
+			return backup_dir_buf;
+	}
+
+	rprintf(FERROR, "backup filename too long\n");
+	return NULL;
+}
 
 /* simple backup creates a backup with a suffix in the same directory */
 static int make_simple_backup(char *fname)
 {
-	char fnamebak[MAXPATHLEN];
-	if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
-		rprintf(FERROR,"backup filename too long\n");
+	int rename_errno;
+	char *fnamebak = get_backup_name(fname);
+
+	if (!fnamebak)
+		return 0;
+
+	while (1) {
+		if (do_rename(fname, fnamebak) == 0) {
+			if (verbose > 1) {
+				rprintf(FINFO, "backed up %s to %s\n",
+					safe_fname(fname),
+					safe_fname(fnamebak));
+			}
+			break;
+		}
+		/* cygwin (at least version b19) reports EINVAL */
+		if (errno == ENOENT || errno == EINVAL)
+			break;
+
+		rename_errno = errno;
+		if (errno == EISDIR && do_rmdir(fnamebak) == 0)
+			continue;
+		if (errno == ENOTDIR && do_unlink(fnamebak) == 0)
+			continue;
+
+		rsyserr(FERROR, rename_errno, "rename %s to backup %s",
+			safe_fname(fname), safe_fname(fnamebak));
+		errno = rename_errno;
 		return 0;
 	}
 
-	slprintf(fnamebak,sizeof(fnamebak),"%s%s",fname,backup_suffix);
-	if (do_rename(fname,fnamebak) != 0) {
-		/* cygwin (at least version b19) reports EINVAL */
-		if (errno != ENOENT && errno != EINVAL) {
-			rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
-			return 0;
-		}
-	} else if (verbose > 1) {
-		rprintf(FINFO,"backed up %s to %s\n",fname,fnamebak);
-	}
 	return 1;
 }
 
 
-/* recursively make a directory path */
-static int make_dir(char *name, int mask)
-{
-	char newdir [MAXPATHLEN];
-	char *p, *d;
-
-	/* copy pathname over, look for last '/' */
-	for (p = d = newdir; *name; *d++ = *name++)
-		if (*name == '/')
-			p = d;
-	if (p == newdir)
-		return 0;
-	*p = 0;
-
-	/* make the new directory, if that fails then make its parent */
-	while (do_mkdir (newdir, mask) != 0)
-		if ((errno != ENOENT) || !make_dir (newdir, mask))
-			return 0;
-
-	return 1;
-} /* make_dir */
-
-
 /****************************************************************************
 Create a directory given an absolute path, perms based upon another directory
 path
 ****************************************************************************/
-static int make_bak_dir(char *fname,char *bak_path)
+static int make_bak_dir(char *fullpath)
 {
-        STRUCT_STAT st;
-        STRUCT_STAT *st2;
-        char fullpath[MAXPATHLEN];
-        extern int orig_umask;
-        char *p;
-        char *q;
+	STRUCT_STAT st;
+	char *rel = fullpath + backup_dir_len;
+	char *end = rel + strlen(rel);
+	char *p = end;
 
-        while(strncmp(bak_path,"./",2)==0) bak_path += 2;
+	while (strncmp(fullpath, "./", 2) == 0)
+		fullpath += 2;
 
-        if(bak_path[strlen(bak_path)-1]!='/') {
-                slprintf(fullpath,sizeof(fullpath),"%s/",bak_path);
-        } else {
-                slprintf(fullpath,sizeof(fullpath),"%s",bak_path);
-        }
-        p=fullpath;
-        q=&fullpath[strlen(fullpath)];  /* End of bak_path string */
-        strcat(fullpath,fname);
+	/* Try to find an existing dir, starting from the deepest dir. */
+	while (1) {
+		if (--p == fullpath) {
+			p += strlen(p);
+			goto failure;
+		}
+		if (*p == '/') {
+			*p = '\0';
+			if (do_mkdir(fullpath, 0777 & ~orig_umask) == 0)
+				break;
+			if (errno != ENOENT) {
+				rsyserr(FERROR, errno,
+					"make_bak_dir mkdir %s failed",
+					full_fname(fullpath));
+				goto failure;
+			}
+		}
+	}
 
-        /* Make the directories */
-        while ((p=strchr(p,'/'))) {
-                *p = 0;
-                if(do_lstat(fullpath,&st)!=0) {
-                        do_mkdir(fullpath,0777 & ~orig_umask);
-                        if(p>q) {
-                                if(do_lstat(q,&st)!=0) {
-                                        rprintf(FERROR,"make_bak_dir stat %s : %s\n",fullpath,strerror(errno));
-                                } else {
-                                        st2=&st;
-                                        set_modtime(fullpath,st2->st_mtime);
-                                        if(do_lchown(fullpath,st2->st_uid,st2->st_gid)!=0) {
-                                                rprintf(FERROR,"make_bak_dir chown %s : %s\n",fullpath,strerror(errno));
-                                        };
-                                        if(do_chmod(fullpath,st2->st_mode)!=0) {
-                                                rprintf(FERROR,"make_bak_dir failed to set permissions on %s : %s\n",fullpath,strerror(errno));
-                                        };
-                                };
-                        }
-                };
-                *p = '/';
-                p++;
-        }
-        return 0;
+	/* Make all the dirs that we didn't find on the way here. */
+	while (1) {
+		if (p >= rel) {
+			/* Try to transfer the directory settings of the
+			 * actual dir that the files are coming from. */
+			if (do_stat(rel, &st) < 0) {
+				rsyserr(FERROR, errno,
+					"make_bak_dir stat %s failed",
+					full_fname(rel));
+			} else {
+				do_lchown(fullpath, st.st_uid, st.st_gid);
+				do_chmod(fullpath, st.st_mode);
+			}
+		}
+		*p = '/';
+		p += strlen(p);
+		if (p == end)
+			break;
+		if (do_mkdir(fullpath, 0777 & ~orig_umask) < 0) {
+			rsyserr(FERROR, errno, "make_bak_dir mkdir %s failed",
+				full_fname(fullpath));
+			goto failure;
+		}
+	}
+	return 0;
+
+failure:
+	while (p != end) {
+		*p = '/';
+		p += strlen(p);
+	}
+	return -1;
 }
 
 /* robustly move a file, creating new directory structures if necessary */
 static int robust_move(char *src, char *dst)
 {
-	int keep_trying = 4;
-	int keep_path_extfs = 0;
-	int failed;
-
-	while (keep_trying) {
-		if (keep_path_extfs) {
-			failed = copy_file(src, dst, 0755);
-			if (!failed) {
-				do_unlink(src);
-			}
-		} else {
-			failed = robust_rename (src, dst);
-		}
-
-		if (failed) {
-			if (verbose > 2)
-				rprintf (FERROR, "robust_move failed: %s(%d)\n",
-					strerror (errno), errno);
-			switch (errno) {
-				/* external filesystem */
-				case EXDEV:
-					keep_path_extfs = 1;
-					keep_trying--;
-					break;
-				/* no directory to write to */
-				case ENOENT:
-					make_dir (dst, 0755);
-					keep_trying--;
-					break;
-				default:
-					keep_trying = 0;
-			} /* switch */
-		} else
-			keep_trying = 0;
-	} /* while */
-	return (!failed);
-} /* robust_move */
+	if (robust_rename(src, dst, 0755) < 0 && (errno != ENOENT
+	    || make_bak_dir(dst) < 0 || robust_rename(src, dst, 0755) < 0))
+		return -1;
+	return 0;
+}
 
 
-/* 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 */
+/* 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;
+	char *buf;
+	int kept = 0;
 	int ret_code;
 
-	if (!initialised) {
-		if (backup_dir[strlen(backup_dir) - 1] == '/')
-			backup_dir[strlen(backup_dir) - 1] = 0;
-		if (verbose > 0)
-			rprintf (FINFO, "backup_dir is %s\n", backup_dir);
-		initialised = 1;
+	/* return if no file to keep */
+	if (do_lstat(fname, &st) < 0)
+		return 1;
+
+	if (!(file = make_file(fname, NULL, NO_FILTERS)))
+		return 1; /* the file could have disappeared */
+
+	if (!(buf = get_backup_name(fname)))
+		return 0;
+
+	/* Check to see if this is a device file, or link */
+	if (IS_DEVICE(file->mode)) {
+		if (am_root && preserve_devices) {
+			if (do_mknod(buf, file->mode, file->u.rdev) < 0
+			    && (errno != ENOENT || make_bak_dir(buf) < 0
+			     || do_mknod(buf, file->mode, file->u.rdev) < 0)) {
+				rsyserr(FERROR, errno, "mknod %s failed",
+					full_fname(buf));
+			} else if (verbose > 2) {
+				rprintf(FINFO,
+					"make_backup: DEVICE %s successful.\n",
+					safe_fname(fname));
+			}
+		}
+		kept = 1;
+		do_unlink(fname);
 	}
 
-	/* 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 (0, fname);
-
-        /* make a complete pathname for backup file */
-        if (strlen(backup_dir) + strlen(fname) > (MAXPATHLEN - 1)) {
-                rprintf (FERROR, "keep_backup filename too long\n");
-                return 0;
-        }
-
-        slprintf(keep_name, sizeof (keep_name), "%s/%s", backup_dir, fname);
-
-
-#ifdef HAVE_MKNOD
-	/* Check to see if this is a device file, or link */
-        if(IS_DEVICE(file->mode)) {
-                if(am_root && preserve_devices) {
-                        make_bak_dir(fname,backup_dir);
-                        if(do_mknod(keep_name,file->mode,file->rdev)!=0) {
-                                rprintf(FERROR,"mknod %s : %s\n",keep_name,strerror(errno));
-                        } else {
-                                if(verbose>2)
-                                        rprintf(FINFO,"make_backup : DEVICE %s successful.\n",fname);
-                        };
-                };
-		kept=1;
-                do_unlink(fname);
-        };
-#endif
-
-	if(!kept && S_ISDIR(file->mode)) {
+	if (!kept && S_ISDIR(file->mode)) {
 		/* make an empty directory */
-                make_bak_dir(fname,backup_dir);
-                do_mkdir(keep_name,file->mode);
-                ret_code=do_rmdir(fname);
-                if(verbose>2)
-                        rprintf(FINFO,"make_backup : RMDIR %s returns %i\n",fname,ret_code);
-		kept=1;
-        };
+		if (do_mkdir(buf, file->mode) < 0
+		    && (errno != ENOENT || make_bak_dir(buf) < 0
+		     || do_mkdir(buf, file->mode) < 0)) {
+			rsyserr(FINFO, errno, "mkdir %s failed",
+				full_fname(buf));
+		}
 
-#if SUPPORT_LINKS
-        if(!kept && preserve_links && S_ISLNK(file->mode)) {
-                extern int safe_symlinks;
-                if (safe_symlinks && unsafe_symlink(file->link, keep_name)) {
-                        if (verbose) {
-                                rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n",
-                                        keep_name,file->link);
-                        }
-			kept=1;
-                }
-                make_bak_dir(fname,backup_dir);
-                if(do_symlink(file->link,keep_name) != 0) {
-                        rprintf(FERROR,"link %s -> %s : %s\n",keep_name,file->link,strerror(errno));
-                };
-                do_unlink(fname);
-		kept=1;
-        };
+		ret_code = do_rmdir(fname);
+		if (verbose > 2) {
+			rprintf(FINFO, "make_backup: RMDIR %s returns %i\n",
+				full_fname(fname), ret_code);
+		}
+		kept = 1;
+	}
+
+#ifdef SUPPORT_LINKS
+	if (!kept && preserve_links && S_ISLNK(file->mode)) {
+		if (safe_symlinks && unsafe_symlink(file->u.link, buf)) {
+			if (verbose) {
+				rprintf(FINFO, "ignoring unsafe symlink %s -> %s\n",
+					full_fname(buf), file->u.link);
+			}
+			kept = 1;
+		}
+		if (do_symlink(file->u.link, buf) < 0
+		    && (errno != ENOENT || make_bak_dir(buf) < 0
+		     || do_symlink(file->u.link, buf) < 0)) {
+			rsyserr(FERROR, errno, "link %s -> \"%s\"",
+				full_fname(buf), safe_fname(file->u.link));
+		}
+		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);
-        }
+	if (!kept && !S_ISREG(file->mode)) {
+		rprintf(FINFO, "make_bak: skipping non-regular file %s\n",
+			safe_fname(fname));
+		return 1;
+	}
 
 	/* move to keep tree if a file */
-	if(!kept) {
-		if (!robust_move (fname, keep_name))
-			rprintf(FERROR, "keep_backup failed %s -> %s : %s\n",
-				fname, keep_name, strerror(errno));
-	};
-	set_perms (keep_name, file, NULL, 0);
-	free_file (file);
-	free (file);
+	if (!kept) {
+		if (robust_move(fname, buf) != 0) {
+			rsyserr(FERROR, errno, "keep_backup failed: %s -> \"%s\"",
+				full_fname(fname), safe_fname(buf));
+		} else if (st.st_nlink > 1) {
+			/* If someone has hard-linked the file into the backup
+			 * dir, rename() might return success but do nothing! */
+			robust_unlink(fname); /* Just in case... */
+		}
+	}
+	set_perms(buf, file, NULL, 0);
+	free(file);
 
-	if (verbose > 1)
-		rprintf (FINFO, "keep_backup %s -> %s\n", fname, keep_name);
+	if (verbose > 1) {
+		rprintf(FINFO, "backed up %s to %s\n",
+			safe_fname(fname), safe_fname(buf));
+	}
 	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));
+		return keep_backup(fname);
+	return make_simple_backup(fname);
 }
-

batch.c

@@ -0,0 +1,234 @@
+/* -*- c-file-style: "linux" -*-
+
+   Weiss 1/1999
+   Batch utilities for rsync.
+
+*/
+
+#include "rsync.h"
+#include <time.h>
+
+extern int am_sender;
+extern int eol_nulls;
+extern int recurse;
+extern int xfer_dirs;
+extern int preserve_links;
+extern int preserve_hard_links;
+extern int preserve_devices;
+extern int preserve_uid;
+extern int preserve_gid;
+extern int always_checksum;
+extern int do_compression;
+extern int protocol_version;
+extern char *batch_name;
+
+extern struct filter_list_struct filter_list;
+
+static int *flag_ptr[] = {
+	&recurse,		/* 0 */
+	&preserve_uid,		/* 1 */
+	&preserve_gid,		/* 2 */
+	&preserve_links,	/* 3 */
+	&preserve_devices,	/* 4 */
+	&preserve_hard_links,	/* 5 */
+	&always_checksum,	/* 6 */
+	&xfer_dirs,		/* 7 (protocol 29) */
+	&do_compression,	/* 8 (protocol 29) */
+	NULL
+};
+
+static char *flag_name[] = {
+	"--recurse (-r)",
+	"--owner (-o)",
+	"--group (-g)",
+	"--links (-l)",
+	"--devices (-D)",
+	"--hard-links (-H)",
+	"--checksum (-c)",
+	"--dirs (-d)",
+	"--compress (-z)",
+	NULL
+};
+
+void write_stream_flags(int fd)
+{
+	int i, flags;
+
+	/* Start the batch file with a bitmap of data-stream-affecting
+	 * flags. */
+	if (protocol_version < 29)
+		flag_ptr[7] = NULL;
+	for (i = 0, flags = 0; flag_ptr[i]; i++) {
+		if (*flag_ptr[i])
+			flags |= 1 << i;
+	}
+	write_int(fd, flags);
+}
+
+void read_stream_flags(int fd)
+{
+	int i, flags;
+
+	if (protocol_version < 29)
+		flag_ptr[7] = NULL;
+	for (i = 0, flags = read_int(fd); flag_ptr[i]; i++) {
+		int set = flags & (1 << i) ? 1 : 0;
+		if (*flag_ptr[i] != set) {
+			if (verbose) {
+				rprintf(FINFO,
+					"%sing the %s option to match the batchfile.\n",
+					set ? "Sett" : "Clear", flag_name[i]);
+			}
+			*flag_ptr[i] = set;
+		}
+	}
+	if (protocol_version < 29) {
+		if (recurse)
+			xfer_dirs |= 1;
+		else if (xfer_dirs < 2)
+			xfer_dirs = 0;
+	}
+}
+
+static void write_arg(int fd, char *arg)
+{
+	char *x, *s;
+
+	if (*arg == '-' && (x = strchr(arg, '=')) != NULL) {
+		write(fd, arg, x - arg + 1);
+		arg += x - arg + 1;
+	}
+
+	if (strpbrk(arg, " \"'&;|[]()$#!*?^\\") != NULL) {
+		write(fd, "'", 1);
+		for (s = arg; (x = strchr(s, '\'')) != NULL; s = x + 1) {
+			write(fd, s, x - s + 1);
+			write(fd, "'", 1);
+		}
+		write(fd, s, strlen(s));
+		write(fd, "'", 1);
+		return;
+	}
+
+	write(fd, arg, strlen(arg));
+}
+
+static void write_filter_rules(int fd)
+{
+	struct filter_struct *ent;
+
+	write_sbuf(fd, " <<'#E#'\n");
+	for (ent = filter_list.head; ent; ent = ent->next) {
+		unsigned int plen;
+		char *p = get_rule_prefix(ent->match_flags, "- ", 0, &plen);
+		write_buf(fd, p, plen);
+		write_sbuf(fd, ent->pattern);
+		if (ent->match_flags & MATCHFLG_DIRECTORY)
+			write_byte(fd, '/');
+		write_byte(fd, eol_nulls ? 0 : '\n');
+	}
+	if (eol_nulls)
+		write_sbuf(fd, ";\n");
+	write_sbuf(fd, "#E#");
+}
+
+/* This routine tries to write out an equivalent --read-batch command
+ * given the user's --write-batch args.  However, it doesn't really
+ * understand most of the options, so it uses some overly simple
+ * heuristics to munge the command line into something that will
+ * (hopefully) work. */
+void write_batch_shell_file(int argc, char *argv[], int file_arg_cnt)
+{
+	int fd, i;
+	char *p, filename[MAXPATHLEN];
+
+	stringjoin(filename, sizeof filename,
+		   batch_name, ".sh", NULL);
+	fd = do_open(filename, O_WRONLY | O_CREAT | O_TRUNC,
+		     S_IRUSR | S_IWUSR | S_IEXEC);
+	if (fd < 0) {
+		rsyserr(FERROR, errno, "Batch file %s open error",
+			safe_fname(filename));
+		exit_cleanup(1);
+	}
+
+	/* Write argvs info to BATCH.sh file */
+	write_arg(fd, argv[0]);
+	if (filter_list.head) {
+		if (protocol_version >= 29)
+			write_sbuf(fd, " --filter=._-");
+		else
+			write_sbuf(fd, " --exclude-from=-");
+	}
+	for (i = 1; i < argc - file_arg_cnt; i++) {
+		p = argv[i];
+		if (strncmp(p, "--files-from", 12) == 0
+		    || strncmp(p, "--filter", 8) == 0
+		    || strncmp(p, "--include", 9) == 0
+		    || strncmp(p, "--exclude", 9) == 0) {
+			if (strchr(p, '=') == NULL)
+				i++;
+			continue;
+		}
+		if (strcmp(p, "-f") == 0) {
+			i++;
+			continue;
+		}
+		write(fd, " ", 1);
+		if (strncmp(p, "--write-batch", 13) == 0) {
+			write(fd, "--read-batch", 12);
+			if (p[13] == '=') {
+				write(fd, "=", 1);
+				write_arg(fd, p + 14);
+			}
+		} else
+			write_arg(fd, p);
+	}
+	if (!(p = check_for_hostspec(argv[argc - 1], &p, &i)))
+		p = argv[argc - 1];
+	write(fd, " ${1:-", 6);
+	write_arg(fd, p);
+	write_byte(fd, '}');
+	if (filter_list.head)
+		write_filter_rules(fd);
+	if (write(fd, "\n", 1) != 1 || close(fd) < 0) {
+		rsyserr(FERROR, errno, "Batch file %s write error",
+			safe_fname(filename));
+		exit_cleanup(1);
+	}
+}
+
+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",
+			safe_fname(fptr[i]->basename));
+		if (fptr[i]->dirname) {
+			rprintf(FINFO, "flist->dirname=%s\n",
+				safe_fname(fptr[i]->dirname));
+		}
+		if (am_sender && fptr[i]->dir.root) {
+			rprintf(FINFO, "flist->dir.root=%s\n",
+				safe_fname(fptr[i]->dir.root));
+		}
+	}
+}
+
+/* for debugging */
+void show_argvs(int argc, char *argv[])
+{
+	int i;
+
+	rprintf(FINFO, "BATCH.C:show_argvs,argc=%d\n", argc);
+	for (i = 0; i < argc; i++)
+		rprintf(FINFO, "i=%d,argv[i]=%s\n", i, safe_fname(argv[i]));
+}

checksum.c

@@ -1,17 +1,17 @@
-/* 
+/*
    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.
@@ -23,24 +23,24 @@ int csum_length=2; /* initial value */
 
 #define CSUM_CHUNK 64
 
-int checksum_seed = 0;
-extern int remote_version;
+extern int checksum_seed;
+extern int protocol_version;
 
 /*
   a simple 32 bit checksum that can be upadted from either end
   (inspired by Mark Adler's Adler-32 checksum)
   */
-uint32 get_checksum1(char *buf1,int len)
+uint32 get_checksum1(char *buf1, int32 len)
 {
-    int i;
+    int32 i;
     uint32 s1, s2;
     schar *buf = (schar *)buf1;
 
     s1 = s2 = 0;
     for (i = 0; i < (len-4); i+=4) {
-	s2 += 4*(s1 + buf[i]) + 3*buf[i+1] + 2*buf[i+2] + buf[i+3] + 
+	s2 += 4*(s1 + buf[i]) + 3*buf[i+1] + 2*buf[i+2] + buf[i+3] +
 	  10*CHAR_OFFSET;
-	s1 += (buf[i+0] + buf[i+1] + buf[i+2] + buf[i+3] + 4*CHAR_OFFSET); 
+	s1 += (buf[i+0] + buf[i+1] + buf[i+2] + buf[i+3] + 4*CHAR_OFFSET);
     }
     for (; i < len; i++) {
 	s1 += (buf[i]+CHAR_OFFSET); s2 += s1;
@@ -49,35 +49,43 @@ uint32 get_checksum1(char *buf1,int len)
 }
 
 
-void get_checksum2(char *buf,int len,char *sum)
+void get_checksum2(char *buf, int32 len, char *sum)
 {
-	int i;
+	int32 i;
 	static char *buf1;
-	static int len1;
+	static int32 len1;
 	struct mdfour m;
 
 	if (len > len1) {
-		if (buf1) free(buf1);
-		buf1 = (char *)malloc(len+4);
+		if (buf1)
+			free(buf1);
+		buf1 = new_array(char, len+4);
 		len1 = len;
-		if (!buf1) out_of_memory("get_checksum2");
+		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) {
+	/*
+	 * Prior to version 27 an incorrect MD4 checksum was computed
+	 * by failing to call mdfour_tail() for block sizes that
+	 * are multiples of 64.  This is fixed by calling mdfour_update()
+	 * even when there are no more bytes.
+	 */
+	if (len - i > 0 || protocol_version >= 27) {
 		mdfour_update(&m, (uchar *)(buf1+i), (len-i));
 	}
-	
+
 	mdfour_result(&m, (uchar *)sum);
 }
 
@@ -88,27 +96,29 @@ void file_checksum(char *fname,char *sum,OFF_T size)
 	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);
-	
+	if (fd == -1)
+		return;
+
+	buf = map_file(fd, size, MAX_MAP_SIZE, CSUM_CHUNK);
+
 	mdfour_begin(&m);
 
 	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);
+		mdfour_update(&m, (uchar *)map_ptr(buf, i, CSUM_CHUNK),
+			      CSUM_CHUNK);
 	}
 
-	if (len - i > 0) {
-		memcpy(tmpchunk, map_ptr(buf,i,len-i), len-i);
-		mdfour_update(&m, (uchar *)tmpchunk, (len-i));
-	}
+	/* Prior to version 27 an incorrect MD4 checksum was computed
+	 * by failing to call mdfour_tail() for block sizes that
+	 * are multiples of 64.  This is fixed by calling mdfour_update()
+	 * even when there are no more bytes. */
+	if (len - i > 0 || protocol_version >= 27)
+		mdfour_update(&m, (uchar *)map_ptr(buf, i, len-i), len-i);
 
 	mdfour_result(&m, (uchar *)sum);
 
@@ -117,64 +127,58 @@ void file_checksum(char *fname,char *sum,OFF_T size)
 }
 
 
-void checksum_init(void)
-{
-  if (remote_version >= 14)
-    csum_length = 2; /* adaptive */
-  else
-    csum_length = SUM_LENGTH;
-}
-
-
-
-static int sumresidue;
+static int32 sumresidue;
 static char sumrbuf[CSUM_CHUNK];
 static struct mdfour md;
 
-void sum_init(void)
+void sum_init(int seed)
 {
 	char s[4];
 	mdfour_begin(&md);
-	sumresidue=0;
-	SIVAL(s,0,checksum_seed);
-	sum_update(s,4);
+	sumresidue = 0;
+	SIVAL(s, 0, 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, int32 len)
 {
-	int i;
 	if (len + sumresidue < CSUM_CHUNK) {
-		memcpy(sumrbuf+sumresidue, p, len);
+		memcpy(sumrbuf + sumresidue, p, len);
 		sumresidue += len;
 		return;
 	}
 
 	if (sumresidue) {
-		i = MIN(CSUM_CHUNK-sumresidue,len);
-		memcpy(sumrbuf+sumresidue,p,i);
-		mdfour_update(&md, (uchar *)sumrbuf, (i+sumresidue));
+		int32 i = CSUM_CHUNK - sumresidue;
+		memcpy(sumrbuf + sumresidue, p, i);
+		mdfour_update(&md, (uchar *)sumrbuf, CSUM_CHUNK);
 		len -= i;
 		p += i;
 	}
 
-	for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
-		memcpy(sumrbuf,p+i,CSUM_CHUNK);
-		mdfour_update(&md, (uchar *)sumrbuf, CSUM_CHUNK);
+	while (len >= CSUM_CHUNK) {
+		mdfour_update(&md, (uchar *)p, CSUM_CHUNK);
+		len -= CSUM_CHUNK;
+		p += CSUM_CHUNK;
 	}
 
-	if (len - i > 0) {
-		sumresidue = len-i;
-		memcpy(sumrbuf,p+i,sumresidue);
-	} else {
-		sumresidue = 0;    
-	}
+	sumresidue = len;
+	if (sumresidue)
+		memcpy(sumrbuf, p, sumresidue);
 }
 
 void sum_end(char *sum)
 {
-	if (sumresidue) {
+	if (sumresidue || protocol_version >= 27)
 		mdfour_update(&md, (uchar *)sumrbuf, sumresidue);
-	}
 
 	mdfour_result(&md, (uchar *)sum);
 }

cleanup.c

@@ -1,17 +1,19 @@
-/* 
-   Copyright (C) Andrew Tridgell 1996
+/* -*- 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.
@@ -19,51 +21,138 @@
 
 #include "rsync.h"
 
-/* handling the cleanup when a transfer is interrupted is tricky when
-   --partial is selected. We need to ensure that the partial file is
-   kept if any real data has been transferred */
-int cleanup_got_literal=0;
+extern int io_error;
+extern int keep_partial;
+extern int log_got_error;
+extern char *partial_dir;
+
+/**
+ * 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--) {
+		if ((ret = do_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;
+static int cleanup_fd_r, cleanup_fd_w;
+static pid_t cleanup_pid = 0;
 
+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)
 {
-	extern int keep_partial;
+	int ocode = code;
+	static int inside_cleanup = 0;
 
-	if (code == 0 && io_error) code = RERR_FILEIO;
+	if (inside_cleanup > 10) {
+		/* prevent the occasional infinite recursion */
+		return;
+	}
+	inside_cleanup++;
 
 	signal(SIGUSR1, SIG_IGN);
 	signal(SIGUSR2, SIG_IGN);
 
-	if (cleanup_got_literal && cleanup_fname && keep_partial) {
-		char *fname = cleanup_fname;
-		cleanup_fname = NULL;
-		if (cleanup_buf) unmap_file(cleanup_buf);
-		if (cleanup_fd1 != -1) close(cleanup_fd1);
-		if (cleanup_fd2 != -1) close(cleanup_fd2);
-		finish_transfer(cleanup_new_fname, fname, cleanup_file);
+	if (verbose > 3) {
+		rprintf(FINFO,"_exit_cleanup(code=%d, file=%s, line=%d): entered\n",
+			code, safe_fname(file), line);
 	}
-	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 (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 (code) log_exit(code, file, line);
+	if (cleanup_got_literal && cleanup_fname && keep_partial
+	    && handle_partial_dir(cleanup_new_fname, PDIR_CREATE)) {
+		char *fname = cleanup_fname;
+		cleanup_fname = NULL;
+		if (cleanup_fd_r != -1)
+			close(cleanup_fd_r);
+		if (cleanup_fd_w != -1) {
+			flush_write_file(cleanup_fd_w);
+			close(cleanup_fd_w);
+		}
+		finish_transfer(cleanup_new_fname, fname, cleanup_file, 0,
+				!partial_dir);
+	}
+	io_flush(FULL_FLUSH);
+	if (cleanup_fname)
+		do_unlink(cleanup_fname);
+	if (code)
+		kill_all(SIGUSR1);
+	if (cleanup_pid && cleanup_pid == getpid()) {
+		char *pidf = lp_pid_file();
+		if (pidf && *pidf)
+			unlink(lp_pid_file());
+	}
 
+	if (code == 0) {
+		if (io_error & IOERR_DEL_LIMIT)
+			code = RERR_DEL_LIMIT;
+		if (io_error & IOERR_VANISHED)
+			code = RERR_VANISHED;
+		if (io_error & IOERR_GENERAL || 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, safe_fname(file), line, code);
+	}
+
+	close_all();
 	exit(code);
 }
 
@@ -75,17 +164,16 @@ void cleanup_disable(void)
 
 
 void cleanup_set(char *fnametmp, char *fname, struct file_struct *file,
-		 struct map_struct *buf, int fd1, int fd2)
+		 int fd_r, int fd_w)
 {
 	cleanup_fname = fnametmp;
 	cleanup_new_fname = fname;
 	cleanup_file = file;
-	cleanup_buf = buf;
-	cleanup_fd1 = fd1;
-	cleanup_fd2 = fd2;
+	cleanup_fd_r = fd_r;
+	cleanup_fd_w = fd_w;
 }
 
-void cleanup_set_pid(int pid)
+void cleanup_set_pid(pid_t pid)
 {
 	cleanup_pid = pid;
 }

clientname.c

@@ -0,0 +1,348 @@
+/* -*- 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)
+{
+	static char addr_buf[100];
+	static int initialised;
+	struct sockaddr_storage ss;
+	socklen_t length = sizeof ss;
+	char *ssh_info, *p;
+
+	if (initialised)
+		return addr_buf;
+
+	initialised = 1;
+
+	if (am_server) {	/* daemon over --rsh mode */
+		strcpy(addr_buf, "0.0.0.0");
+		if ((ssh_info = getenv("SSH_CONNECTION")) != NULL
+		    || (ssh_info = getenv("SSH_CLIENT")) != NULL
+		    || (ssh_info = getenv("SSH2_CLIENT")) != NULL) {
+			strlcpy(addr_buf, ssh_info, sizeof addr_buf);
+			/* Truncate the value to just the IP address. */
+			if ((p = strchr(addr_buf, ' ')) != NULL)
+				*p = '\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;
+	socklen_t ss_len;
+
+	if (initialised)
+		return name_buf;
+
+	strcpy(name_buf, default_name);
+	initialised = 1;
+
+	memset(&ss, 0, sizeof ss);
+
+	if (am_server) {	/* daemon over --rsh mode */
+		char *addr = client_addr(fd);
+		struct addrinfo hint, *answer;
+		int err;
+
+		memset(&hint, 0, sizeof hint);
+
+#ifdef AI_NUMERICHOST
+		hint.ai_flags = AI_NUMERICHOST;
+#endif
+		hint.ai_socktype = SOCK_STREAM;
+
+		if ((err = getaddrinfo(addr, NULL, &hint, &answer)) != 0) {
+			rprintf(FLOG, "malformed address %s: %s\n",
+			        addr, gai_strerror(err));
+			return name_buf;
+		}
+
+		switch (answer->ai_family) {
+		case AF_INET:
+			ss_len = sizeof (struct sockaddr_in);
+			memcpy(&ss, answer->ai_addr, ss_len);
+			break;
+#ifdef INET6
+		case AF_INET6:
+			ss_len = sizeof (struct sockaddr_in6);
+			memcpy(&ss, answer->ai_addr, ss_len);
+			break;
+#endif
+		}
+		freeaddrinfo(answer);
+	} else {
+		ss_len = sizeof ss;
+		client_sockaddr(fd, &ss, &ss_len);
+	}
+
+	if (lookup_name(fd, &ss, ss_len, name_buf, sizeof name_buf,
+			port_buf, sizeof port_buf) == 0)
+		check_name(fd, &ss, 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? */
+		rsyserr(FLOG, errno, "getpeername on fd%d failed", fd);
+		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_IN_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(FLOG, "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(FLOG, "%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
+	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(FLOG, "%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 */
+
+	/* 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(FLOG, "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(FLOG, "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(FLOG, "%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

@@ -1,335 +1,534 @@
-/* 
-   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.
-*/
+/* -*- 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.
+ */
 
-/* the socket based protocol for setting up a connection wit rsyncd */
+/**
+ * @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 list_only;
+extern int am_sender;
+extern int am_server;
+extern int am_daemon;
+extern int am_root;
 extern int rsync_port;
-char *auth_user;
-int sanitize_paths = 0;
+extern int kluge_around_eof;
+extern int daemon_over_rsh;
+extern int sanitize_paths;
+extern int filesfrom_fd;
+extern int remote_protocol;
+extern int protocol_version;
+extern int io_timeout;
+extern int select_timeout;
+extern int orig_umask;
+extern int no_detach;
+extern int default_af_hint;
+extern char *bind_address;
+extern struct filter_list_struct server_filter_list;
+extern char *config_file;
+extern char *files_from;
 
+char *auth_user;
+int read_only = 0;
+int daemon_log_format_has_i = 0;
+int daemon_log_format_has_o_or_i = 0;
+int module_id = -1;
+
+/* Length of lp_path() string when in daemon mode & not chrooted, else 0. */
+unsigned int module_dirlen = 0;
+
+/**
+ * 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, i;
-	char *sargs[MAX_ARGS];
-	int sargc=0;
-	char line[MAXPATHLEN];
-	char *p, *user=NULL;
-	extern int remote_version;
-	extern int am_sender;
-	extern struct in_addr socket_address;
+	int fd, ret;
+	char *p, *user = NULL;
 
+	/* This is redundant with code in start_inband_exchange(), but this
+	 * short-circuits a problem in the client 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\n");
+		rprintf(FERROR,
+			"ERROR: The remote path must start with a module name not a /\n");
 		return -1;
 	}
 
-	p = strchr(host, '@');
-	if (p) {
+	if ((p = strrchr(host, '@')) != NULL) {
 		user = host;
 		host = p+1;
-		*p = 0;
+		*p = '\0';
 	}
 
-	if (!user) user = getenv("USER");
-	if (!user) user = getenv("LOGNAME");
-
-	fd = open_socket_out(host, rsync_port, &socket_address);
-	if (fd == -1) {
+	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;
+
+	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;
 	}
-	
-	server_options(sargs,&sargc);
+
+	if (!user)
+		user = getenv("USER");
+	if (!user)
+		user = getenv("LOGNAME");
+
+	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;
+
+	if (list_only && protocol_version >= 29)
+		list_only |= 2;
+
+	/* 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) 
+	if (path && *path)
 		sargs[sargc++] = path;
 
 	sargs[sargc] = NULL;
 
-	io_printf(fd,"@RSYNCD: %d\n", PROTOCOL_VERSION);
-
-	if (!read_line(fd, line, sizeof(line)-1)) {
-		return -1;
-	}
-
-	if (sscanf(line,"@RSYNCD: %d", &remote_version) != 1) {
-		return -1;
-	}
+	if (verbose > 1)
+		print_child_argv(sargs);
 
 	p = strchr(path,'/');
 	if (p) *p = 0;
-	io_printf(fd,"%s\n",path);
+	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. */
+	kluge_around_eof = list_only && protocol_version < 25 ? 1 : 0;
+
 	while (1) {
-		if (!read_line(fd, line, sizeof(line)-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(fd, user, line+18);
+			auth_client(f_out, user, line+18);
 			continue;
 		}
 
-		if (strcmp(line,"@RSYNCD: OK") == 0) break;
-		rprintf(FINFO,"%s\n", line);
+		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);
+		}
+	}
+	kluge_around_eof = 0;
+
+	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 || !am_sender)
+			io_start_multiplex_in();
 	}
 
-	for (i=0;i<sargc;i++) {
-		io_printf(fd,"%s\n", sargs[i]);
-	}
-	io_printf(fd,"\n");
-
-	if (remote_version < 23) {
-		if (remote_version == 22 || (remote_version > 17 && !am_sender))
-			io_start_multiplex_in(fd);
-	}
-
-	return client_run(fd, fd, -1, argc, argv);
+	return 0;
 }
 
 
 
-static int rsync_module(int fd, int i)
+static int rsync_module(int f_in, int f_out, int i)
 {
-	int argc=0;
-	char *argv[MAX_ARGS];
+	int argc = 0;
+	int maxargs;
+	char **argv;
 	char **argp;
 	char line[MAXPATHLEN];
-	uid_t uid = (uid_t)-2;
+	uid_t uid = (uid_t)-2;  /* canonically "nobody" */
 	gid_t gid = (gid_t)-2;
 	char *p;
-	char *addr = client_addr(fd);
-	char *host = client_name(fd);
+	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 start_glob = 0;
 	int ret;
-	char *request=NULL;
-	extern int am_sender;
-	extern int remote_version;
-	extern int am_root;
+	char *request = NULL;
 
 	if (!allow_access(addr, host, lp_hosts_allow(i), lp_hosts_deny(i))) {
-		rprintf(FERROR,"rsync denied on module %s from %s (%s)\n",
-			name, client_name(fd), client_addr(fd));
-		io_printf(fd,"@ERROR: access denied to %s from %s (%s)\n",
-			  name, client_name(fd), client_addr(fd));
-		return -1;
-	}
-
-	if (!claim_connection(lp_lock_file(i), lp_max_connections(i))) {
-		if (errno) {
-			rprintf(FERROR,"failed to open lock file %s : %s\n",
-				lp_lock_file(i), strerror(errno));
-			io_printf(fd,"@ERROR: failed to open lock file %s : %s\n",
-				  lp_lock_file(i), strerror(errno));
-		} else {
-			rprintf(FERROR,"max connections (%d) reached\n",
-				lp_max_connections(i));
-			io_printf(fd,"@ERROR: max connections (%d) reached - try again later\n", lp_max_connections(i));
+		rprintf(FLOG, "rsync denied on module %s from %s (%s)\n",
+			name, host, addr);
+		if (!lp_list(i))
+			io_printf(f_out, "@ERROR: Unknown module '%s'\n", name);
+		else {
+			io_printf(f_out,
+				  "@ERROR: access denied to %s from %s (%s)\n",
+				  name, host, addr);
 		}
 		return -1;
 	}
 
-	
-	auth_user = auth_server(fd, i, addr, "@RSYNCD: AUTHREQD ");
+	if (am_daemon && am_server) {
+		rprintf(FLOG, "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) {
+			rsyserr(FLOG, errno, "failed to open lock file %s",
+				safe_fname(lp_lock_file(i)));
+			io_printf(f_out, "@ERROR: failed to open lock file\n");
+		} else {
+			rprintf(FLOG, "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, client_name(fd), client_addr(fd));
-		io_printf(fd,"@ERROR: auth failed on module %s\n",name);
-		return -1;		
+		rprintf(FLOG, "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 (lp_read_only(i))
+		read_only = 1;
+
+	if (lp_transfer_logging(i)) {
+		if (log_format_has(lp_log_format(i), 'i'))
+			daemon_log_format_has_i = 1;
+		if (daemon_log_format_has_i
+		    || log_format_has(lp_log_format(i), 'o'))
+			daemon_log_format_has_o_or_i = 1;
+	}
+
+	am_root = (MY_UID() == 0);
 
 	if (am_root) {
 		p = lp_uid(i);
 		if (!name_to_uid(p, &uid)) {
-			if (!isdigit(*p)) {
-				rprintf(FERROR,"Invalid uid %s\n", p);
-				io_printf(fd,"@ERROR: invalid uid\n");
+			if (!isdigit(*(unsigned char *)p)) {
+				rprintf(FLOG, "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(*p)) {
-				rprintf(FERROR,"Invalid gid %s\n", p);
-				io_printf(fd,"@ERROR: invalid gid\n");
+			if (!isdigit(*(unsigned char *)p)) {
+				rprintf(FLOG, "Invalid gid %s\n", p);
+				io_printf(f_out, "@ERROR: invalid gid %s\n", p);
 				return -1;
-			} 
+			}
 			gid = atoi(p);
 		}
 	}
 
-	p = lp_include_from(i);
-	add_exclude_file(p, 1, 1);
+	/* 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. */
 
-	p = lp_include(i);
-	add_include_line(p);
-
-	p = lp_exclude_from(i);
-	add_exclude_file(p, 1, 0);
-
-	p = lp_exclude(i);
-	add_exclude_line(p);
-
-	log_open();
+	/* TODO: Perhaps take a list of gids, and make them into the
+	 * supplementary groups. */
 
 	if (use_chroot) {
+		module_dirlen = 0;
+		set_filter_dir("/", 1);
+	} else {
+		module_dirlen = strlen(lp_path(i));
+		set_filter_dir(lp_path(i), module_dirlen);
+	}
+
+	p = lp_filter(i);
+	parse_rule(&server_filter_list, p, MATCHFLG_WORD_SPLIT,
+		   XFLG_ANCHORED2ABS);
+
+	p = lp_include_from(i);
+	parse_filter_file(&server_filter_list, p, MATCHFLG_INCLUDE,
+	    XFLG_ANCHORED2ABS | XFLG_OLD_PREFIXES | XFLG_FATAL_ERRORS);
+
+	p = lp_include(i);
+	parse_rule(&server_filter_list, p,
+		   MATCHFLG_INCLUDE | MATCHFLG_WORD_SPLIT,
+		   XFLG_ANCHORED2ABS | XFLG_OLD_PREFIXES);
+
+	p = lp_exclude_from(i);
+	parse_filter_file(&server_filter_list, p, 0,
+	    XFLG_ANCHORED2ABS | XFLG_OLD_PREFIXES | XFLG_FATAL_ERRORS);
+
+	p = lp_exclude(i);
+	parse_rule(&server_filter_list, p, MATCHFLG_WORD_SPLIT,
+		   XFLG_ANCHORED2ABS | XFLG_OLD_PREFIXES);
+
+	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))) {
-			rprintf(FERROR,"chroot %s failed\n", lp_path(i));
-			io_printf(fd,"@ERROR: chroot failed\n");
+			rsyserr(FLOG, errno, "chroot %s failed",
+				safe_fname(lp_path(i)));
+			io_printf(f_out, "@ERROR: chroot failed\n");
 			return -1;
 		}
 
-		if (!push_dir("/", 0)) {
-			rprintf(FERROR,"chdir %s failed\n", lp_path(i));
-			io_printf(fd,"@ERROR: chdir failed\n");
+		if (!push_dir("/")) {
+			rsyserr(FLOG, errno, "chdir %s failed\n",
+				safe_fname(lp_path(i)));
+			io_printf(f_out, "@ERROR: chdir failed\n");
 			return -1;
 		}
 
 	} else {
-		if (!push_dir(lp_path(i), 0)) {
-			rprintf(FERROR,"chdir %s failed\n", lp_path(i));
-			io_printf(fd,"@ERROR: chdir failed\n");
+		if (!push_dir(lp_path(i))) {
+			rsyserr(FLOG, errno, "chdir %s failed\n",
+				safe_fname(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)) {
-			rprintf(FERROR,"setgid %d failed\n", gid);
-			io_printf(fd,"@ERROR: setgid failed\n");
+			rsyserr(FLOG, 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(FLOG, errno, "setgroups failed");
+			io_printf(f_out, "@ERROR: setgroups failed\n");
+			return -1;
+		}
+#endif
 
 		if (setuid(uid)) {
-			rprintf(FERROR,"setuid %d failed\n", uid);
-			io_printf(fd,"@ERROR: setuid failed\n");
+			rsyserr(FLOG, errno, "setuid %d failed", (int)uid);
+			io_printf(f_out, "@ERROR: setuid failed\n");
 			return -1;
 		}
 
-		am_root = (getuid() == 0);
+		am_root = (MY_UID() == 0);
 	}
 
-	io_printf(fd,"@RSYNCD: OK\n");
+	io_printf(f_out, "@RSYNCD: OK\n");
 
+	maxargs = MAX_ARGS;
+	if (!(argv = new_array(char *, maxargs)))
+		out_of_memory("rsync_module");
 	argv[argc++] = "rsyncd";
 
 	while (1) {
-		if (!read_line(fd, line, sizeof(line)-1)) {
+		if (!read_line(f_in, line, sizeof line - 1))
 			return -1;
-		}
 
-		if (!*line) break;
+		if (!*line)
+			break;
 
 		p = line;
 
-		argv[argc] = strdup(p);
-		if (!argv[argc]) {
-			return -1;
+		if (argc == maxargs) {
+			maxargs += MAX_ARGS;
+			if (!(argv = realloc_array(argv, char *, maxargs)))
+				out_of_memory("rsync_module");
 		}
+		if (!(argv[argc] = strdup(p)))
+			out_of_memory("rsync_module");
 
 		if (start_glob) {
 			if (start_glob == 1) {
 				request = strdup(p);
 				start_glob++;
 			}
-			glob_expand(name, argv, &argc, MAX_ARGS);
-		} else {
+			glob_expand(name, &argv, &argc, &maxargs);
+		} else
 			argc++;
-		}
 
-		if (strcmp(line,".") == 0) {
+		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);
-		}
-	}
+	verbose = 0; /* future verbosity is controlled by client options */
+	argp = argv;
+	ret = parse_arguments(&argc, (const char ***) &argp, 0);
 
-	ret = parse_arguments(argc, argv, 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",
+			rprintf(FLOG, "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",
+			rprintf(FLOG, "rsync %s %s from %s (%s)\n",
+				am_sender ? "on" : "to",
 				request, host, addr);
 		}
 		free(request);
 	}
 
-#if !TRIDGE
+#ifndef DEBUG
 	/* don't allow the logs to be flooded too fast */
-	if (verbose > 1) verbose = 1;
+	if (verbose > lp_max_verbosity())
+		verbose = lp_max_verbosity();
 #endif
 
-	argc -= optind;
-	argp = argv + optind;
-	optind = 0;
-
-	if (remote_version < 23) {
-		if (remote_version == 22 || (remote_version > 17 && am_sender))
-			io_start_multiplex_out(fd);
+	if (protocol_version < 23
+	    && (protocol_version == 22 || am_sender))
+		io_start_multiplex_out();
+	else if (!ret) {
+		/* We have to get I/O multiplexing started so that we can
+		 * get the error back to the client.  This means getting
+		 * the protocol setup finished first in later versions. */
+		setup_protocol(f_out, f_in);
+		if (!am_sender) {
+			/* Since we failed in our option parsing, we may not
+			 * have finished parsing that the client sent us a
+			 * --files-from option, so look for it manually.
+			 * Without this, the socket would be in the wrong
+			 * state for the upcoming error message. */
+			if (!files_from) {
+				int i;
+				for (i = 0; i < argc; i++) {
+					if (strncmp(argv[i], "--files-from", 12) == 0) {
+						files_from = "";
+						break;
+					}
+				}
+			}
+			if (files_from)
+				write_byte(f_out, 0);
+		}
+		io_start_multiplex_out();
 	}
 
 	if (!ret) {
 		option_error();
+		msleep(400);
+		exit_cleanup(RERR_UNSUPPORTED);
 	}
 
 	if (lp_timeout(i)) {
-		extern int io_timeout;
 		io_timeout = lp_timeout(i);
+		if (io_timeout < select_timeout)
+			select_timeout = io_timeout;
 	}
 
-	start_server(fd, fd, argc, argp);
+	start_server(f_in, f_out, argc, argp);
 
 	return 0;
 }
@@ -340,126 +539,143 @@ static void send_listing(int fd)
 {
 	int n = lp_numservices();
 	int i;
-	
-	for (i=0;i<n;i++)
+
+	for (i = 0; i < n; i++) {
 		if (lp_list(i))
-		    io_printf(fd, "%-15s\t%s\n", lp_name(i), lp_comment(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 socket connection is established to a client
+/* 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 */
-static int start_daemon(int fd)
+int start_daemon(int f_in, int f_out)
 {
 	char line[200];
 	char *motd;
-	int i = -1;
-	extern char *config_file;
-	extern int remote_version;
+	int i;
 
-	if (!lp_load(config_file, 0)) {
+	io_set_sock_fds(f_in, f_out);
+
+	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);
 	}
 
-	set_socket_options(fd,"SO_KEEPALIVE");
-	set_socket_options(fd,lp_socket_options());
-	set_nonblocking(fd);
-
-	io_printf(fd,"@RSYNCD: %d\n", PROTOCOL_VERSION);
+	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);
+			int len = fread(line, 1, sizeof line - 1, f);
 			if (len > 0) {
 				line[len] = 0;
-				io_printf(fd,"%s", line);
+				io_printf(f_out, "%s", line);
 			}
 		}
-		if (f) fclose(f);
-		io_printf(fd,"\n");
+		if (f)
+			fclose(f);
+		io_printf(f_out, "\n");
 	}
 
-	if (!read_line(fd, line, sizeof(line)-1)) {
+	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;
+
+	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 (sscanf(line,"@RSYNCD: %d", &remote_version) != 1) {
-		io_printf(fd,"@ERROR: protocol startup error\n");
+	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;
-	}	
-
-	while (i == -1) {
-		line[0] = 0;
-		if (!read_line(fd, line, sizeof(line)-1)) {
-			return -1;
-		}
-
-		if (!*line || strcmp(line,"#list")==0) {
-			send_listing(fd);
-			return -1;
-		} 
-
-		if (*line == '#') {
-			/* it's some sort of command that I don't understand */
-			io_printf(fd,"@ERROR: Unknown command '%s'\n", line);
-			return -1;
-		}
-
-		i = lp_number(line);
-		if (i == -1) {
-			io_printf(fd,"@ERROR: Unknown module '%s'\n", line);
-			return -1;
-		}
 	}
 
-	return rsync_module(fd, i);
+	if ((i = lp_number(line)) < 0) {
+		char *addr = client_addr(f_in);
+		char *host = client_name(f_in);
+		rprintf(FLOG, "unknown module '%s' tried from %s (%s)\n",
+			line, host, addr);
+		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;
 
 	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); 
+		 * 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);
+		return start_daemon(STDIN_FILENO, STDIN_FILENO);
 	}
 
-	become_daemon();
+	if (!no_detach)
+		become_daemon();
 
-	if (!lp_load(config_file, 1)) {
+	if (!lp_load(config_file, 1))
 		exit_cleanup(RERR_SYNTAX);
-	}
 
-	log_open();
+	if (rsync_port == 0 && (rsync_port = lp_rsync_port()) == 0)
+		rsync_port = RSYNC_PORT;
+	if (bind_address == NULL && *lp_bind_address())
+		bind_address = lp_bind_address();
 
-	rprintf(FINFO,"rsyncd version %s starting\n",VERSION);
+	log_init();
+
+	rprintf(FLOG, "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();
+		pid_t pid = getpid();
 		cleanup_set_pid(pid);
 		if ((fd = do_open(lp_pid_file(), O_WRONLY|O_CREAT|O_TRUNC,
 					0666 & ~orig_umask)) == -1) {
-		    cleanup_set_pid(0);
-		    rprintf(FLOG,"failed to create pid file %s\n", pid_file);
-		    exit_cleanup(RERR_FILEIO);
+			cleanup_set_pid(0);
+			rsyserr(FLOG, errno, "failed to create pid file %s",
+				safe_fname(pid_file));
+			exit_cleanup(RERR_FILEIO);
 		}
-		slprintf(pidbuf, sizeof(pidbuf), "%d\n", pid);
+		snprintf(pidbuf, sizeof pidbuf, "%ld\n", (long)pid);
 		write(fd, pidbuf, strlen(pidbuf));
 		close(fd);
 	}
@@ -467,4 +683,3 @@ int daemon_main(void)
 	start_accept_loop(rsync_port, start_daemon);
 	return -1;
 }
-

compat.c

@@ -17,57 +17,93 @@
    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 preserve_links;
-extern int preserve_perms;
-extern int preserve_devices;
-extern int preserve_uid;
-extern int preserve_gid;
-extern int preserve_times;
-extern int always_checksum;
-extern int checksum_seed;
-
-
-extern int remote_version;
 extern int verbose;
+extern int am_server;
+extern int am_sender;
+extern int inplace;
+extern int fuzzy_basis;
+extern int read_batch;
+extern int checksum_seed;
+extern int basis_dir_cnt;
+extern int protocol_version;
+extern char *dest_option;
 
 void setup_protocol(int f_out,int f_in)
 {
-	if (remote_version == 0) {
-		if (am_server) {
-			remote_version = read_int(f_in);
-			write_int(f_out,PROTOCOL_VERSION);
-		} else {
-			write_int(f_out,PROTOCOL_VERSION);
-			remote_version = read_int(f_in);
-		}
+	if (remote_protocol == 0) {
+		if (!read_batch)
+			write_int(f_out, protocol_version);
+		remote_protocol = read_int(f_in);
+		if (protocol_version > remote_protocol)
+			protocol_version = remote_protocol;
+	}
+	if (read_batch && remote_protocol > protocol_version) {
+	        rprintf(FERROR, "The protocol version in the batch file is too new (%d > %d).\n",
+			remote_protocol, protocol_version);
+		exit_cleanup(RERR_PROTOCOL);
 	}
 
-	if (remote_version < MIN_PROTOCOL_VERSION ||
-	    remote_version > MAX_PROTOCOL_VERSION) {
-		rprintf(FERROR,"protocol version mismatch - is your shell clean?\n");
+	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 (verbose > 2)
-		rprintf(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 (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 (fuzzy_basis && protocol_version < 29) {
+		rprintf(FERROR,
+			"--fuzzy requires protocol 29 or higher (negotiated %d).\n",
+			protocol_version);
+		exit_cleanup(RERR_PROTOCOL);
+	}
+
+	if (basis_dir_cnt && inplace && protocol_version < 29) {
+		rprintf(FERROR,
+			"%s with --inplace requires protocol 29 or higher (negotiated %d).\n",
+			dest_option, protocol_version);
+		exit_cleanup(RERR_PROTOCOL);
+	}
+
+	if (basis_dir_cnt > 1 && protocol_version < 29) {
+		rprintf(FERROR,
+			"Multiple %s options requires protocol 29 or higher (negotiated %d).\n",
+			dest_option, protocol_version);
+		exit_cleanup(RERR_PROTOCOL);
+	}
+
+	if (am_server) {
+		if (!checksum_seed)
+			checksum_seed = time(NULL);
+		write_int(f_out, checksum_seed);
+	} else {
+		checksum_seed = read_int(f_in);
+	}
+}

configure.in

@@ -1,35 +1,305 @@
 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.59)
 
-# compile with optimisation and without debugging by default
-CFLAGS=${CFLAGS-"-O"}
+RSYNC_VERSION=2.6.4
+AC_SUBST(RSYNC_VERSION)
+AC_MSG_NOTICE([Configuring rsync $RSYNC_VERSION])
 
-AC_CANONICAL_SYSTEM
-AC_VALIDATE_CACHE_SYSTEM_TYPE
+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_EGREP
 AC_PROG_INSTALL
+AC_PROG_CC_STDC
 AC_SUBST(SHELL)
 
+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" = x"yes"
+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(rsyncd-conf,
+	AC_HELP_STRING([--with-rsyncd-conf=PATH], [set configuration file for rsync server to PATH (default: /etc/rsyncd.conf)]),
+	[ if test ! -z "$with_rsyncd_conf" ; then
+		case $with_rsyncd_conf in
+			yes|no)
+				RSYNCD_SYSCONF="/etc/rsyncd.conf"
+				;;
+			/*)
+				RSYNCD_SYSCONF="$with_rsyncd_conf"
+				;;
+			*)
+                                AC_MSG_ERROR(You must specify an absolute path to --with-rsyncd-conf=PATH)
+				;;
+		esac
+	else
+		RSYNCD_SYSCONF="/etc/rsyncd.conf"
+	fi ],
+	[ RSYNCD_SYSCONF="/etc/rsyncd.conf" ])
+
+AC_DEFINE_UNQUOTED(RSYNCD_SYSCONF, "$RSYNCD_SYSCONF", [location of configuration file for rsync server])
+
+AC_ARG_WITH(rsh,
+	AC_HELP_STRING([--with-rsh=CMD], [set remote shell command to CMD (default: ssh)]))
+
 AC_CHECK_PROG(HAVE_REMSH, remsh, 1, 0)
-AC_DEFINE_UNQUOTED(HAVE_REMSH, $HAVE_REMSH)
+AC_DEFINE_UNQUOTED(HAVE_REMSH, $HAVE_REMSH, [remote shell is remsh not rsh])
+
+if test x"$with_rsh" != x
+then
+	RSYNC_RSH="$with_rsh"
+else
+	RSYNC_RSH="ssh"
+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;
+	char tpl[32] = "/tmp/locktest.XXXXXX";
+	int fd = mkstemp(tpl);
+	if (fd < 0) {
+		strcpy(tpl, "conftest.dat");
+		fd = open(tpl, 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(tpl);
+	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 to 1 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(glob.h)
+AC_CHECK_HEADERS(sys/fcntl.h sys/select.h fcntl.h sys/time.h sys/unistd.h \
+    unistd.h utime.h grp.h compat.h sys/param.h ctype.h sys/wait.h \
+    sys/ioctl.h sys/filio.h string.h stdlib.h sys/socket.h sys/mode.h \
+    sys/un.h glob.h mcheck.h arpa/inet.h arpa/nameser.h \
+    netdb.h malloc.h float.h)
+AC_HEADER_MAJOR
 
 AC_CHECK_SIZEOF(int)
 AC_CHECK_SIZEOF(long)
+AC_CHECK_SIZEOF(long long)
 AC_CHECK_SIZEOF(short)
+AC_CHECK_SIZEOF(off_t)
+AC_CHECK_SIZEOF(off64_t)
 
 AC_C_INLINE
+AC_C_LONG_DOUBLE
 
 AC_TYPE_SIGNAL
 AC_TYPE_UID_T
@@ -38,14 +308,15 @@ AC_TYPE_OFF_T
 AC_TYPE_SIZE_T
 AC_TYPE_PID_T
 AC_TYPE_GETGROUPS
-AC_STRUCT_ST_RDEV
-AC_CHECK_TYPE(ino_t,unsigned)
+AC_CHECK_MEMBERS([struct stat.st_rdev])
+
+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)
+   AC_DEFINE(HAVE_ERRNO_DECL, 1, [Define to 1 if errno is declared in errno.h])
 fi
 
 # The following test taken from the cvs sources
@@ -76,15 +347,119 @@ if test x"$ac_cv_func_connect" = x"no"; then
     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" || 
+    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)
+        AC_DEFINE(HAVE_CONNECT, 1, [Define to 1 if you have the "connect" function])
     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 to 1 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, 1, [Do we have sockaddr.sa_len?]) ],
+		[],
+		[
+#include <sys/types.h>
+#include <sys/socket.h>
+])
+
+AC_CHECK_MEMBER([struct sockaddr_in.sin_len],
+		[ AC_DEFINE(HAVE_SOCKADDR_IN_LEN, 1, [Do we have sockaddr_in.sin_len?]) ],
+		[],
+		[
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+])
+
+AC_CHECK_MEMBER([struct sockaddr_un.sun_len],
+		[ AC_DEFINE(HAVE_SOCKADDR_UN_LEN, 1, [Do we have sockaddr_un.sun_len?]) ],
+		[],
+		[
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.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 to 1 if you have struct sockaddr_storage.] ),
+	AC_MSG_RESULT(no))
+
+AC_CHECK_MEMBER([struct sockaddr_in6.sin6_scope_id],
+		[ AC_DEFINE(HAVE_SOCKADDR_IN6_SCOPE_ID, 1, [Do we have sockaddr_in6.sin6_scope_id?]) ],
+		[],
+		[
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+])
+
+AC_MSG_CHECKING(struct stat64)
+AC_TRY_COMPILE([#include <stdio.h>
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#if STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# if HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+],[struct stat64 st;],
+    AC_MSG_RESULT(yes)
+	AC_DEFINE(HAVE_STRUCT_STAT64,1,[Define to 1 if you have struct stat64.]),
+    AC_MSG_RESULT(no))
+
 # if we can't find strcasecmp, look in -lresolv (for Unixware at least)
 #
 AC_CHECK_FUNCS(strcasecmp)
@@ -92,83 +467,84 @@ if test x"$ac_cv_func_strcasecmp" = x"no"; then
     AC_CHECK_LIB(resolv, strcasecmp)
 fi
 
-AC_FUNC_MEMCMP
+dnl At the moment we don't test for a broken memcmp(), because all we
+dnl need to do is test for equality, not comparison, and it seems that
+dnl every platform has a memcmp that can do at least that.
+dnl AC_FUNC_MEMCMP
+
 AC_FUNC_UTIME_NULL
-AC_CHECK_FUNCS(waitpid wait4 getcwd strdup strerror chown chmod mknod)
-AC_CHECK_FUNCS(fchmod fstat strchr readlink link utime utimes strftime)
-AC_CHECK_FUNCS(memmove lchown vsnprintf snprintf setsid glob strpbrk)
-AC_CHECK_FUNCS(strlcat strlcpy inet_aton)
+AC_FUNC_ALLOCA
+AC_CHECK_FUNCS(waitpid wait4 getcwd strdup strerror chown chmod mknod mkfifo \
+    fchmod fstat strchr readlink link utime utimes strftime mtrace ftruncate \
+    memmove lchown vsnprintf snprintf vasprintf asprintf setsid glob strpbrk \
+    strlcat strlcpy strtol mallinfo getgroups setgroups geteuid getegid \
+    setmode open64 mkstemp64 va_copy __va_copy)
+
+AC_CHECK_FUNCS(getpgrp tcgetpgrp)
+if test $ac_cv_func_getpgrp = yes; then
+    AC_FUNC_GETPGRP
+fi
+
+# Determine whether chown follows symlinks (it should).
+AC_CACHE_CHECK([whether chown() dereferences symlinks],rsync_cv_chown_follows_symlink,[
+  AC_TRY_RUN([
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#include <stdlib.h>
+#include <errno.h>
+    main() {
+	char const *dangling_symlink = "conftest.dangle";
+	unlink(dangling_symlink);
+	if (symlink("conftest.no-such", dangling_symlink) < 0) abort();
+	if (chown(dangling_symlink, getuid(), getgid()) < 0 && errno == ENOENT) exit(0);
+	exit(1);
+    }],
+  rsync_cv_chown_follows_symlink=yes,rsync_cv_chown_follows_symlink=no,rsync_cv_chown_follows_symlink=yes)])
+if test $rsync_cv_chown_follows_symlink = no; then
+  AC_DEFINE(CHOWN_MODIFIES_SYMLINK, 1, [Define to 1 if chown modifies symlinks.])
+fi
 
 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);
-	    }],
+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)
+    AC_DEFINE(HAVE_SOCKETPAIR, 1, [Define to 1 if you have the "socketpair" function])
 fi
 
-AC_CACHE_CHECK([for working fnmatch],rsync_cv_HAVE_FNMATCH,[
-AC_TRY_RUN([#include <fnmatch.h>
-main() { exit((fnmatch("*.o", "x.o", FNM_PATHNAME) == 0 &&
-               fnmatch("a/b/*", "a/b/c/d", FNM_PATHNAME) != 0) ? 0: 1); }],
-rsync_cv_HAVE_FNMATCH=yes,rsync_cv_HAVE_FNMATCH=no,rsync_cv_HAVE_FNMATCH=cross)])
-if test x"$rsync_cv_HAVE_FNMATCH" = x"yes"; then
-    AC_DEFINE(HAVE_FNMATCH)
+if test x"$with_included_popt" != x"yes"
+then
+    AC_CHECK_LIB(popt, poptGetContext, , [with_included_popt=yes])
 fi
 
-# sometimes getopt_long cannot parse same arguments twice
-# e.g. on certain versions of CygWin32
-AC_CACHE_CHECK([for working getopt_long],rsync_cv_HAVE_GETOPT_LONG,[
-AC_TRY_RUN([#include <getopt.h>
-main() {
-    int i, x = 0; char *argv[] = { "x", "--xx" };
-    struct option o[] = {{"xx", 0, 0, 1}, {0,0,0,0}};
-    getopt_long(2, argv, "x", o, &i) == 1 ? x++ : 0; optind = 0;
-    getopt_long(2, argv, "x", o, &i) == 1 ? x++ : 0;
-    exit(x == 2 ? 0 : 1);
-}], rsync_cv_HAVE_GETOPT_LONG=yes,rsync_cv_HAVE_GETOPT_LONG=no,
-    rsync_cv_HAVE_GETOPT_LONG=cross)])
-if test x"$rsync_cv_HAVE_GETOPT_LONG" = x"yes"; then
-    AC_DEFINE(HAVE_GETOPT_LONG)
+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 = 1000000; x *= x; exit(((x/1000000) == 1000000)? 0: 1); }],
-rsync_cv_HAVE_LONGLONG=yes,rsync_cv_HAVE_LONGLONG=no,rsync_cv_HAVE_LONGLONG=cross)])
-if test x"$rsync_cv_HAVE_LONGLONG" = x"yes"; then
-    AC_DEFINE(HAVE_LONGLONG)
-fi
-
-AC_CACHE_CHECK([for off64_t],rsync_cv_HAVE_OFF64_T,[
-AC_TRY_RUN([#include <stdio.h>
-#include <sys/stat.h>
-main() { struct stat64 st; off64_t s; if (sizeof(off_t) == sizeof(off64_t)) exit(1); exit((lstat64("/dev/null", &st)==0)?0:1); }],
-rsync_cv_HAVE_OFF64_T=yes,rsync_cv_HAVE_OFF64_T=no,rsync_cv_HAVE_OFF64_T=cross)])
-if test x"$rsync_cv_HAVE_OFF64_T" = x"yes"; then
-    AC_DEFINE(HAVE_OFF64_T)
-fi
-
-AC_CACHE_CHECK([for short ino_t],rsync_cv_HAVE_SHORT_INO_T,[
-AC_TRY_RUN([#include <stdio.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-main() { if (sizeof(ino_t) < sizeof(unsigned int)) return 0; return 1; }],
-rsync_cv_HAVE_SHORT_INO_T=yes,rsync_cv_HAVE_SHORT_INO_T=no,rsync_cv_HAVE_SHORT_INO_T=cross)])
-if test x"$rsync_cv_HAVE_SHORT_INO_T" = x"yes"; then
-    AC_DEFINE(HAVE_SHORT_INO_T)
-fi
-
-AC_CACHE_CHECK([for unsigned char],rsync_cv_HAVE_UNSIGNED_CHAR,[
-AC_TRY_RUN([#include <stdio.h>
-main() { char c; c=250; exit((c > 0)?0:1); }],
-rsync_cv_HAVE_UNSIGNED_CHAR=yes,rsync_cv_HAVE_UNSIGNED_CHAR=no,rsync_cv_HAVE_UNSIGNED_CHAR=cross)])
-if test x"$rsync_cv_HAVE_UNSIGNED_CHAR" = x"yes"; then
-    AC_DEFINE(HAVE_UNSIGNED_CHAR)
+AC_CACHE_CHECK([for unsigned char],rsync_cv_SIGNED_CHAR_OK,[
+AC_TRY_COMPILE([],[signed char *s = ""],
+rsync_cv_SIGNED_CHAR_OK=yes,rsync_cv_SIGNED_CHAR_OK=no)])
+if test x"$rsync_cv_SIGNED_CHAR_OK" = x"yes"; then
+    AC_DEFINE(SIGNED_CHAR_OK, 1, [Define to 1 if "signed char" is a valid type])
 fi
 
 AC_CACHE_CHECK([for broken readdir],rsync_cv_HAVE_BROKEN_READDIR,[
@@ -179,26 +555,73 @@ 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)
+    AC_DEFINE(HAVE_BROKEN_READDIR, 1, [Define to 1 if readdir() is broken])
 fi
 
 AC_CACHE_CHECK([for utimbuf],rsync_cv_HAVE_UTIMBUF,[
 AC_TRY_COMPILE([#include <sys/types.h>
 #include <utime.h>],
 [struct utimbuf tbuf;  tbuf.actime = 0; tbuf.modtime = 1; exit(utime("foo.c",&tbuf));],
-rsync_cv_HAVE_UTIMBUF=yes,rsync_cv_HAVE_UTIMBUF=no,rsync_cv_HAVE_UTIMBUF=cross)])
+rsync_cv_HAVE_UTIMBUF=yes,rsync_cv_HAVE_UTIMBUF=no)])
 if test x"$rsync_cv_HAVE_UTIMBUF" = x"yes"; then
-    AC_DEFINE(HAVE_UTIMBUF)
+    AC_DEFINE(HAVE_UTIMBUF, 1, [Define to 1 if you have the "struct utimbuf" type])
 fi
 
 AC_CACHE_CHECK([if gettimeofday takes tz argument],rsync_cv_HAVE_GETTIMEOFDAY_TZ,[
+AC_TRY_COMPILE([#include <sys/time.h>
+#include <unistd.h>],
+[struct timeval tv; exit(gettimeofday(&tv, NULL));],
+rsync_cv_HAVE_GETTIMEOFDAY_TZ=yes,rsync_cv_HAVE_GETTIMEOFDAY_TZ=no)])
+if test x"$rsync_cv_HAVE_GETTIMEOFDAY_TZ" != x"no"; then
+    AC_DEFINE(HAVE_GETTIMEOFDAY_TZ, 1, [Define to 1 if gettimeofday() takes a time-zone arg])
+fi
+
+AC_CACHE_CHECK([for C99 vsnprintf],rsync_cv_HAVE_C99_VSNPRINTF,[
 AC_TRY_RUN([
-#include <sys/time.h>
+#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, [Define to 1 if vsprintf has a C99-compatible return value])
+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 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)
+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, [Define to 1 if mkstemp() is available and works right])
 fi
 
 
@@ -210,11 +633,53 @@ AC_TRY_RUN([
 #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(0); } 
-exit(1);}],
-           rsync_cv_REPLACE_INET_NTOA=yes,rsync_cv_REPLACE_INET_NTOA=no,rsync_cv_REPLACE_INET_NTOA=cross)])
+    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)
+    AC_DEFINE(REPLACE_INET_NTOA, 1, [Define to 1 if inet_ntoa() needs to be replaced])
+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, [Define to 1 if inet_aton() needs to be replaced])
+fi
+
+AC_CACHE_CHECK([if mknod creates FIFOs],rsync_cv_MKNOD_CREATES_FIFOS,[
+AC_TRY_RUN([
+#include <stdio.h>
+#include <sys/stat.h>
+#include <errno.h>
+main() { int rc, ec; char *fn = "fifo-test";
+unlink(fn); rc = mknod(fn,S_IFIFO,0600); ec = errno; unlink(fn);
+if (rc) {printf("%d %d\n",rc,ec); return ec;}
+return 0;}],
+           rsync_cv_MKNOD_CREATES_FIFOS=yes,rsync_cv_MKNOD_CREATES_FIFOS=no,rsync_cv_MKNOD_CREATES_FIFOS=cross)])
+if test x"$rsync_cv_MKNOD_CREATES_FIFOS" = x"yes"; then
+    AC_DEFINE(MKNOD_CREATES_FIFOS, 1, [Define to 1 if mknod() can create FIFOs.])
+fi
+
+AC_CACHE_CHECK([if mknod creates sockets],rsync_cv_MKNOD_CREATES_SOCKETS,[
+AC_TRY_RUN([
+#include <stdio.h>
+#include <sys/stat.h>
+#include <errno.h>
+main() { int rc, ec; char *fn = "sock-test";
+unlink(fn); rc = mknod(fn,S_IFSOCK,0600); ec = errno; unlink(fn);
+if (rc) {printf("%d %d\n",rc,ec); return ec;}
+return 0;}],
+           rsync_cv_MKNOD_CREATES_SOCKETS=yes,rsync_cv_MKNOD_CREATES_SOCKETS=no,rsync_cv_MKNOD_CREATES_SOCKETS=cross)])
+if test x"$rsync_cv_MKNOD_CREATES_SOCKETS" = x"yes"; then
+    AC_DEFINE(MKNOD_CREATES_SOCKETS, 1, [Define to 1 if mknod() can create sockets.])
 fi
 
 #
@@ -246,6 +711,26 @@ 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_OUTPUT(Makefile lib/dummy zlib/dummy)
+if test x"$with_rsh" = x; then
+	if test x"$HAVE_REMSH" = x1; then
+		rmsh1='remsh:'
+		rmsh2='=remsh'
+	else
+		rmsh1='rsh:  '
+		rmsh2='=rsh  '
+	fi
+	AC_MSG_RESULT()
+	AC_MSG_RESULT([    **********************************************************************])
+	AC_MSG_RESULT([    *   As of v2.6.0, the default remote shell is ssh instead of rsh!!   *])
+	AC_MSG_RESULT([    *   To use previous default of $rmsh1 ./configure --with-rsh$rmsh2   *])
+	AC_MSG_RESULT([    **********************************************************************])
+fi
+
+AC_MSG_RESULT()
+AC_MSG_RESULT([    rsync ${RSYNC_VERSION} configuration successful])
+AC_MSG_RESULT()

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

@@ -1,9 +1,34 @@
-/* error codes returned by rsync */
+/* -*- 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_UNSUPPORTED 4      /* requested action not supported */
+#define RERR_STARTCLIENT 5      /* error starting client-server protocol */
+#define RERR_LOG_FAILURE 6      /* daemon unable to append to log-file */
 
 #define RERR_SOCKETIO   10      /* error in socket IO */
 #define RERR_FILEIO     11      /* error in file IO */
@@ -14,5 +39,24 @@
 #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_VANISHED   24      /* file(s) vanished on sender side */
+#define RERR_DEL_LIMIT  25      /* skipped some deletes due to --max-delete */
 
 #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

fileio.c

@@ -1,29 +1,31 @@
-/* 
+/*
    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 
+  File IO utilities used in rsync
   */
 #include "rsync.h"
 
+extern int sparse_files;
+
 static char last_byte;
 static int last_sparse;
-extern int sparse_files;
 
 int sparse_end(int f)
 {
@@ -36,13 +38,13 @@ int sparse_end(int f)
 }
 
 
-static int write_sparse(int f,char *buf,int len)
+static int write_sparse(int f,char *buf,size_t len)
 {
-	int l1=0,l2=0;
+	size_t l1=0, l2=0;
 	int ret;
 
-	for (l1=0;l1<len && buf[l1]==0;l1++) ;
-	for (l2=0;l2<(len-l1) && buf[len-(l2+1)]==0;l2++) ;
+	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];
 
@@ -50,38 +52,83 @@ static int write_sparse(int f,char *buf,int len)
 		last_sparse=1;
 
 	if (l1 > 0) {
-		do_lseek(f,l1,SEEK_CUR);  
+		do_lseek(f,l1,SEEK_CUR);
 	}
 
-	if (l1 == len) 
+	if (l1 == len)
 		return len;
 
-	if ((ret=write(f,buf+l1,len-(l1+l2))) != len-(l1+l2)) {
-		if (ret == -1 || ret == 0) return ret;
+	ret = write(f, buf + l1, len - (l1+l2));
+	if (ret == -1 || ret == 0)
+		return ret;
+	else if (ret != (int) (len - (l1+l2)))
 		return (l1+ret);
-	}
 
 	if (l2 > 0)
 		do_lseek(f,l2,SEEK_CUR);
-	
+
 	return len;
 }
 
 
+static char *wf_writeBuf;
+static size_t wf_writeBufSize;
+static size_t wf_writeBufCnt;
 
-int write_file(int f,char *buf,int len)
+int flush_write_file(int f)
+{
+	int ret = 0;
+	char *bp = wf_writeBuf;
+
+	while (wf_writeBufCnt > 0) {
+		if ((ret = write(f, bp, wf_writeBufCnt)) < 0) {
+			if (errno == EINTR)
+				continue;
+			return ret;
+		}
+		wf_writeBufCnt -= ret;
+		bp += ret;
+	}
+	return ret;
+}
+
+
+/*
+ * write_file does not allow incomplete writes.  It loops internally
+ * until len bytes are written or errno is set.
+ */
+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);
+	while (len > 0) {
+		int r1;
+		if (sparse_files) {
+			int len1 = MIN(len, SPARSE_WRITE_SIZE);
+			r1 = write_sparse(f, buf, len1);
+		} else {
+			if (!wf_writeBuf) {
+				wf_writeBufSize = WRITE_SIZE * 8;
+				wf_writeBufCnt  = 0;
+				wf_writeBuf = new_array(char, wf_writeBufSize);
+				if (!wf_writeBuf)
+					out_of_memory("write_file");
+			}
+			r1 = MIN(len, wf_writeBufSize - wf_writeBufCnt);
+			if (r1) {
+				memcpy(wf_writeBuf + wf_writeBufCnt, buf, r1);
+				wf_writeBufCnt += r1;
+			}
+			if (wf_writeBufCnt == wf_writeBufSize) {
+				if (flush_write_file(f) < 0)
+					return -1;
+				if (!r1 && len)
+					continue;
+			}
+		}
 		if (r1 <= 0) {
-			if (ret > 0) return ret;
+			if (ret > 0)
+				return ret;
 			return r1;
 		}
 		len -= r1;
@@ -92,75 +139,67 @@ int write_file(int f,char *buf,int len)
 }
 
 
-
-/* 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)
+/* 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, int32 read_size,
+			    int32 blk_size)
 {
 	struct map_struct *map;
-	map = (struct map_struct *)malloc(sizeof(*map));
-	if (!map) out_of_memory("map_file");
 
+	if (!(map = new(struct map_struct)))
+		out_of_memory("map_file");
+
+	if (blk_size && (read_size % blk_size))
+		read_size += blk_size - (read_size % blk_size);
+
+	memset(map, 0, sizeof map[0]);
 	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;
+	map->def_window_size = read_size;
 
 	return map;
 }
 
+
 /* slide the read window in the file */
-char *map_ptr(struct map_struct *map,OFF_T offset,int len)
+char *map_ptr(struct map_struct *map, OFF_T offset, int32 len)
 {
-	int nread;
+	int32 nread;
 	OFF_T window_start, read_start;
-	int window_size, read_size, read_offset;
+	int32 window_size, read_size, read_offset;
 
-	if (len == 0) {
+	if (len == 0)
 		return NULL;
-	}
-
-	/* can't go beyond the end of file */
-	if (len > (map->file_size - offset)) {
-		len = map->file_size - offset;
+	if (len < 0) {
+		rprintf(FERROR, "invalid len passed to map_ptr: %ld\n",
+			(long)len);
+		exit_cleanup(RERR_FILEIO);
 	}
 
 	/* 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));
-	}
-
+	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_start = offset;
+	window_size = map->def_window_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;
-	}
+	if (len > window_size)
+		window_size = len;
 
 	/* make sure we have allocated enough memory for the window */
 	if (window_size > map->p_size) {
-		map->p = (char *)Realloc(map->p, window_size);
-		if (!map->p) out_of_memory("map_ptr");
+		map->p = 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. */
+	/* 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) {
@@ -175,18 +214,27 @@ char *map_ptr(struct map_struct *map,OFF_T offset,int len)
 	}
 
 	if (read_size <= 0) {
-		rprintf(FINFO,"Warning: unexpected read size of %d in map_ptr\n", read_size);
+		rprintf(FERROR, "invalid read_size of %ld in map_ptr\n",
+			(long)read_size);
+		exit_cleanup(RERR_FILEIO);
 	} 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");
+			OFF_T ret = do_lseek(map->fd, read_start, SEEK_SET);
+			if (ret != read_start) {
+				rsyserr(FERROR, errno,
+					"lseek returned %.0f, not %.0f",
+					(double)ret, (double)read_start);
 				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;
+			if (nread < 0) {
+				nread = 0;
+				if (!map->status)
+					map->status = errno;
+			}
 			/* 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);
@@ -196,18 +244,22 @@ char *map_ptr(struct map_struct *map,OFF_T offset,int len)
 
 	map->p_offset = window_start;
 	map->p_len = window_size;
-  
-	return map->p + (offset - map->p_offset); 
+
+	return map->p;
 }
 
 
-void unmap_file(struct map_struct *map)
+int unmap_file(struct map_struct *map)
 {
+	int	ret;
+
 	if (map->p) {
 		free(map->p);
 		map->p = NULL;
 	}
-	memset(map, 0, sizeof(*map));
+	ret = map->status;
+	memset(map, 0, sizeof map[0]);
 	free(map);
-}
 
+	return ret;
+}

getfsdev.c

@@ -0,0 +1,23 @@
+#include "rsync.h"
+
+ int main(int argc, char *argv[])
+{
+	STRUCT_STAT st;
+	int ret;
+
+	while (--argc > 0) {
+#ifdef USE_STAT64_FUNCS
+		ret = stat64(*++argv, &st);
+#else
+		ret = stat(*++argv, &st);
+#endif
+		if (ret < 0) {
+			fprintf(stderr, "Unable to stat `%s'\n", *argv);
+			exit(1);
+		}
+		printf("%ld/%ld\n", (long)major(st.st_dev),
+				    (long)minor(st.st_dev));
+	}
+
+	return 0;
+}

getgroups.c

@@ -0,0 +1,68 @@
+/*
+ * 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"
+
+int
+main(UNUSED(int argc), UNUSED(char *argv[]))
+{
+	int n, i;
+	gid_t *list;
+	gid_t gid = MY_GID();
+	int gid_in_list = 0;
+
+#ifdef HAVE_GETGROUPS
+	if ((n = getgroups(0, NULL)) < 0) {
+		perror("getgroups");
+		return 1;
+	}
+#else
+	n = 0;
+#endif
+
+	list = (gid_t*)malloc(sizeof (gid_t) * (n + 1));
+	if (!list) {
+		fprintf(stderr, "out of memory!\n");
+		exit(1);
+	}
+
+#ifdef HAVE_GETGROUPS
+	if (n > 0)
+		n = getgroups(n, list);
+#endif
+
+	for (i = 0; i < n; i++)  {
+		printf("%lu ", (unsigned long)list[i]);
+		if (list[i] == gid)
+			gid_in_list = 1;
+	}
+	/* The default gid might not be in the list on some systems. */
+	if (!gid_in_list)
+		printf("%lu", (unsigned long)gid);
+	printf("\n");
+		
+	return 0;
+}

hlink.c

@@ -1,17 +1,18 @@
-/* 
+/*
    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
    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.
@@ -21,136 +22,212 @@
 
 extern int dry_run;
 extern int verbose;
+extern int make_backups;
+extern struct file_list *the_file_list;
 
-#if SUPPORT_HARD_LINKS
-static int hlink_compare(struct file_struct *f1,struct file_struct *f2)
+#ifdef SUPPORT_HARD_LINKS
+
+#define FPTR(i) (the_file_list->files[i])
+#define LINKED(p1,p2) (FPTR(p1)->F_DEV == FPTR(p2)->F_DEV \
+		    && FPTR(p1)->F_INODE == FPTR(p2)->F_INODE)
+
+static int hlink_compare(int *int1, int *int2)
 {
-  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;
+	struct file_struct *f1 = FPTR(*int1);
+	struct file_struct *f2 = FPTR(*int2);
 
-  if (f1->dev != f2->dev) 
-    return (int)(f1->dev>f2->dev?1:-1);
+	if (f1->F_DEV != f2->F_DEV)
+		return (int) (f1->F_DEV > f2->F_DEV ? 1 : -1);
 
-  if (f1->inode != f2->inode) 
-    return (int)(f1->inode>f2->inode?1:-1);
+	if (f1->F_INODE != f2->F_INODE)
+		return (int) (f1->F_INODE > f2->F_INODE ? 1 : -1);
 
-  return file_compare(&f1,&f2);
+	return f_name_cmp(f1, f2);
 }
 
-
-static struct file_struct *hlink_list;
+static int *hlink_list;
 static int hlink_count;
+
+/* Analyze the data in the hlink_list[], remove items that aren't multiply
+ * linked, and replace the dev+inode data with the hlindex+next linked list. */
+static void link_idev_data(void)
+{
+	int head, from, to, start;
+
+	alloc_pool_t hlink_pool;
+	alloc_pool_t idev_pool = the_file_list->hlink_pool;
+
+	hlink_pool = pool_create(128 * 1024, sizeof (struct hlink),
+	    out_of_memory, POOL_INTERN);
+
+	for (from = to = 0; from < hlink_count; from++) {
+		start = from;
+		head = hlink_list[start];
+		while (from < hlink_count-1
+		    && LINKED(hlink_list[from], hlink_list[from+1])) {
+			pool_free(idev_pool, 0, FPTR(hlink_list[from])->link_u.idev);
+			FPTR(hlink_list[from])->link_u.links = pool_talloc(hlink_pool,
+			    struct hlink, 1, "hlink_list");
+
+			FPTR(hlink_list[from])->F_HLINDEX = to;
+			FPTR(hlink_list[from])->F_NEXT = hlink_list[from+1];
+			from++;
+		}
+		if (from > start) {
+			pool_free(idev_pool, 0, FPTR(hlink_list[from])->link_u.idev);
+			FPTR(hlink_list[from])->link_u.links = pool_talloc(hlink_pool,
+			    struct hlink, 1, "hlink_list");
+
+			FPTR(head)->flags |= FLAG_HLINK_TOL;
+			FPTR(hlink_list[from])->F_HLINDEX = to;
+			FPTR(hlink_list[from])->F_NEXT = head;
+			FPTR(hlink_list[from])->flags |= FLAG_HLINK_EOL;
+			hlink_list[to++] = head;
+		} else {
+			pool_free(idev_pool, 0, FPTR(head)->link_u.idev);
+			FPTR(head)->link_u.idev = NULL;
+		}
+	}
+
+	if (!to) {
+		free(hlink_list);
+		hlink_list = NULL;
+		pool_destroy(hlink_pool);
+		hlink_pool = NULL;
+	} else {
+		hlink_count = to;
+		hlink_list = realloc_array(hlink_list, int, hlink_count);
+		if (!hlink_list)
+			out_of_memory("init_hard_links");
+	}
+	the_file_list->hlink_pool = hlink_pool;
+	pool_destroy(idev_pool);
+}
 #endif
 
-void init_hard_links(struct file_list *flist)
+void init_hard_links(void)
 {
-#if SUPPORT_HARD_LINKS
+#ifdef SUPPORT_HARD_LINKS
 	int i;
-	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 (the_file_list->count < 2)
+		return;
+
+	if (hlink_list)
+		free(hlink_list);
+
+	if (!(hlink_list = new_array(int, the_file_list->count)))
 		out_of_memory("init_hard_links");
 
-	for (i = 0; i < flist->count; i++)
-		memcpy(&hlink_list[i], flist->files[i], sizeof(hlink_list[0]));
-
-	qsort(hlink_list,flist->count,
-	      sizeof(hlink_list[0]),
-	      (int (*)())hlink_compare);
-
-	hlink_count=flist->count;
-#endif
-}
-
-/* check if a file should be skipped because it is the same as an
-   earlier hard link */
-int check_hard_link(struct file_struct *file)
-{
-#if SUPPORT_HARD_LINKS
-  int low=0,high=hlink_count-1;
-  int ret=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;
-  }
-
-  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;
-#endif
-
-  return 0;
-}
-
-
-#if SUPPORT_HARD_LINKS
-static void hard_link_one(int i)
-{
-	STRUCT_STAT st1,st2;
-
-	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 (verbose > 0)
-				rprintf(FINFO,"link %s => %s : %s\n",
-					f_name(&hlink_list[i]),
-					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 (robust_unlink(f_name(&hlink_list[i])) != 0 ||
-		    do_link(f_name(&hlink_list[i-1]),f_name(&hlink_list[i])) != 0) {
-			if (verbose > 0)
-				rprintf(FINFO,"link %s => %s : %s\n",
-					f_name(&hlink_list[i]),
-					f_name(&hlink_list[i-1]),strerror(errno));
-			return;
-		}
+	hlink_count = 0;
+	for (i = 0; i < the_file_list->count; i++) {
+		if (FPTR(i)->link_u.idev)
+			hlink_list[hlink_count++] = i;
 	}
-	if (verbose > 0)
-		rprintf(FINFO,"%s => %s\n",
-			f_name(&hlink_list[i]),f_name(&hlink_list[i-1]));
-}
+
+	qsort(hlink_list, hlink_count,
+	    sizeof hlink_list[0], (int (*)()) hlink_compare);
+
+	if (!hlink_count) {
+		free(hlink_list);
+		hlink_list = NULL;
+	} else
+		link_idev_data();
 #endif
+}
 
-/* create any hard links in the flist */
-void do_hard_links(struct file_list *flist)
+int hard_link_check(struct file_struct *file, int ndx, int skip)
 {
-#if SUPPORT_HARD_LINKS
-	int 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) {
-			hard_link_one(i);
-		}	
+#ifdef SUPPORT_HARD_LINKS
+	if (!hlink_list || !file->link_u.links)
+		return 0;
+	if (skip && !(file->flags & FLAG_HLINK_EOL))
+		hlink_list[file->F_HLINDEX] = file->F_NEXT;
+	if (hlink_list[file->F_HLINDEX] != ndx) {
+		if (verbose > 2) {
+			rprintf(FINFO, "\"%s\" is a hard link\n",
+				safe_fname(f_name(file)));
+		}
+		return 1;
 	}
+#endif
+	return 0;
+}
+
+#ifdef SUPPORT_HARD_LINKS
+int hard_link_one(struct file_struct *file, int ndx, char *fname,
+		  int statret, STRUCT_STAT *st, char *toname, int terse,
+		  int itemizing, enum logcode code)
+{
+	if (do_link(toname, fname)) {
+		if (verbose) {
+			rsyserr(FERROR, errno, "link %s => %s failed",
+				full_fname(fname), safe_fname(toname));
+		}
+		return -1;
+	}
+
+	if (itemizing) {
+		itemize(file, ndx, statret, st,
+			ITEM_LOCAL_CHANGE | ITEM_XNAME_FOLLOWS, 0,
+			terse ? "" : toname);
+	}
+	if (code && verbose && !terse) {
+		rprintf(code, "%s => %s\n",
+			safe_fname(fname), safe_fname(toname));
+	}
+	return 0;
+}
+#endif
+
+
+void hard_link_cluster(struct file_struct *file, int master, int itemizing,
+		       enum logcode code)
+{
+#ifdef SUPPORT_HARD_LINKS
+	char hlink1[MAXPATHLEN];
+	char *hlink2;
+	STRUCT_STAT st1, st2;
+	int statret, ndx = master;
+
+	if (link_stat(f_name_to(file, hlink1), &st1, 0) < 0)
+		return;
+	if (!(file->flags & FLAG_HLINK_TOL)) {
+		while (!(file->flags & FLAG_HLINK_EOL)) {
+			ndx = file->F_NEXT;
+			file = FPTR(ndx);
+		}
+	}
+	do {
+		ndx = file->F_NEXT;
+		file = FPTR(ndx);
+		if (ndx == master)
+			continue;
+		hlink2 = f_name(file);
+		if ((statret = link_stat(hlink2, &st2, 0)) == 0) {
+			if (st2.st_dev == st1.st_dev
+			    && st2.st_ino == st1.st_ino) {
+				if (itemizing) {
+					itemize(file, ndx, statret, &st2,
+						ITEM_LOCAL_CHANGE | ITEM_XNAME_FOLLOWS,
+						0, "");
+				}
+				continue;
+			}
+			if (make_backups) {
+				if (!make_backup(hlink2))
+					continue;
+			} else if (robust_unlink(hlink2)) {
+				if (verbose > 0) {
+					rsyserr(FINFO, errno,
+						"unlink %s failed",
+						full_fname(hlink2));
+				}
+				continue;
+			}
+		}
+		hard_link_one(file, ndx, hlink2, statret,
+			      &st2, hlink1, 0, itemizing, code);
+	} while (!(file->flags & FLAG_HLINK_EOL));
 #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/.cvsignore

@@ -1,49 +1 @@
-.cvsignore
-Makefile
-a
-b
-config.cache
-config.h
-config.log
-config.status
-dist.tar.gz
 dummy
-rsync
-rsync-0.1
-rsync-0.1
-rsync-0.1
-rsync-0.1.tar.gz
-rsync-0.2
-rsync-0.2
-rsync-0.2.tar.gz
-rsync-0.3
-rsync-0.3
-rsync-0.3.tar.gz
-rsync-0.4
-rsync-0.4
-rsync-0.4.tar.gz
-rsync-0.5
-rsync-0.5
-rsync-0.5
-rsync-0.5
-rsync-0.5
-rsync-0.5
-rsync-0.5
-rsync-0.5
-rsync-0.5.tar.gz
-rsync-0.6
-rsync-0.7
-rsync-0.7
-rsync-0.8
-rsync-0.8
-rsync-0.8
-rsync-0.8
-rsync-ERSION
-rsync.aux
-rsync.dvi
-rsync.log
-tech_report.aux
-tech_report.dvi
-tech_report.log
-tech_report.ps
-test

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"
 
 
@@ -78,9 +83,11 @@
 #endif
 
 #ifndef HAVE_STRPBRK
-/* Find the first ocurrence in S of any character in ACCEPT.  
-   derived from glibc 
-*/
+/**
+ * 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')  {
@@ -95,50 +102,47 @@
 }
 #endif
 
-#ifdef REPLACE_INET_NTOA
- char *rep_inet_ntoa(struct in_addr ip)
-{
-	unsigned char *p = (unsigned char *)&ip.s_addr;
-	static char buf[18];
-#if WORDS_BIGENDIAN
-	slprintf(buf, 18, "%d.%d.%d.%d", 
-		 (int)p[0], (int)p[1], (int)p[2], (int)p[3]);
-#else
-	slprintf(buf, 18, "%d.%d.%d.%d", 
-		 (int)p[3], (int)p[2], (int)p[1], (int)p[0]);
-#endif
-	return buf;
-}
-#endif
 
 #ifndef HAVE_STRLCPY
-/* like strncpy but does not 0 fill the buffer and always null 
-   terminates. bufsize is the size of the destination buffer */
+/**
+ * Like strncpy but does not 0 fill the buffer and always null 
+ * terminates.
+ *
+ * @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 (len >= bufsize) len = bufsize-1;
-	memcpy(d, s, len);
-	d[len] = 0;
+	if (bufsize > 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. bufsize is the length of the buffer, which should
-   be one more than the maximum resulting string length */
+/**
+ * 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) {
+	if (len1 < bufsize - 1) {
+		if (len2 >= bufsize - len1)
+			len2 = bufsize - len1 - 1;
 		memcpy(d+len1, s, len2);
 		d[len1+len2] = 0;
 	}
@@ -146,7 +150,23 @@
 }
 #endif
 
-#ifndef HAVE_INET_ATON
+#ifdef REPLACE_INET_NTOA
+ char *rep_inet_ntoa(struct in_addr ip)
+{
+	unsigned char *p = (unsigned char *)&ip.s_addr;
+	static char buf[18];
+#ifdef 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;
@@ -154,12 +174,12 @@
 
 	if (strcmp(cp, "255.255.255.255") == 0) {
 		inp->s_addr = (unsigned) -1;
-		return 1;
+		return 0;
 	}
 
 	if (sscanf(cp, "%u.%u.%u.%u", &a1, &a2, &a3, &a4) != 4 ||
 	    a1 > 255 || a2 > 255 || a3 > 255 || a4 > 255) {
-		return 1;
+		return 0;
 	}
 
 	ret = (a1 << 24) | (a2 << 16) | (a3 << 8) | a4;
@@ -176,7 +196,7 @@
 /* some systems don't take the 2nd argument */
 int sys_gettimeofday(struct timeval *tv)
 {
-#if HAVE_GETTIMEOFDAY_TZ
+#ifdef HAVE_GETTIMEOFDAY_TZ
 	return gettimeofday(tv, NULL);
 #else
 	return gettimeofday(tv);

lib/fnmatch.c

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

lib/fnmatch.h

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

@@ -28,30 +28,23 @@
 
 static struct mdfour *m;
 
-#define F(X,Y,Z) (((X)&(Y)) | ((~(X))&(Z)))
-#define G(X,Y,Z) (((X)&(Y)) | ((X)&(Z)) | ((Y)&(Z)))
-#define H(X,Y,Z) ((X)^(Y)^(Z))
-#ifdef LARGE_INT32
-#define lshift(x,s) ((((x)<<(s))&0xFFFFFFFF) | (((x)>>(32-(s)))&0xFFFFFFFF))
-#else
-#define lshift(x,s) (((x)<<(s)) | ((x)>>(32-(s))))
-#endif
+#define MASK32 (0xffffffff)
 
-#define ROUND1(a,b,c,d,k,s) a = lshift((uint32)(a + F(b,c,d) + X[k]), s)
-#define ROUND2(a,b,c,d,k,s) a = lshift((uint32)(a + G(b,c,d) + X[k] + 0x5A827999),s)
-#define ROUND3(a,b,c,d,k,s) a = lshift((uint32)(a + H(b,c,d) + X[k] + 0x6ED9EBA1),s)
+#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)
 {
-	int j;
 	uint32 AA, BB, CC, DD;
-	uint32 X[16];
 	uint32 A,B,C,D;
 
-	for (j=0;j<16;j++)
-		X[j] = M[j];
-
 	A = m->A; B = m->B; C = m->C; D = m->D; 
 	AA = A; BB = B; CC = C; DD = D;
 
@@ -64,6 +57,7 @@ static void mdfour64(uint32 *M)
         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);  
@@ -82,15 +76,11 @@ static void mdfour64(uint32 *M)
         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 += AA; B += BB; 
+	C += CC; D += DD;
 	
-#ifdef LARGE_INT32
-	A &= 0xFFFFFFFF; B &= 0xFFFFFFFF;
-	C &= 0xFFFFFFFF; D &= 0xFFFFFFFF;
-#endif
-
-	for (j=0;j<16;j++)
-		X[j] = 0;
+	A &= MASK32; B &= MASK32; 
+	C &= MASK32; D &= MASK32;
 
 	m->A = A; m->B = B; m->C = C; m->D = D;
 }
@@ -119,29 +109,53 @@ void mdfour_begin(struct mdfour *md)
 	md->C = 0x98badcfe;
 	md->D = 0x10325476;
 	md->totalN = 0;
+	md->totalN2 = 0;
 }
 
 
-static void mdfour_tail(unsigned char *in, int n)
+static void mdfour_tail(unsigned char *in, uint32 n)
 {
 	unsigned char buf[128];
 	uint32 M[16];
-	uint32 b;
+	extern int protocol_version;
 
-	m->totalN += n;
-
-	b = m->totalN * 8;
+	/*
+	 * 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, b);
+		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, b); 
+		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);
@@ -149,20 +163,23 @@ static void mdfour_tail(unsigned char *in, int n)
 	}
 }
 
-void mdfour_update(struct mdfour *md, unsigned char *in, int n)
+void mdfour_update(struct mdfour *md, unsigned char *in, uint32 n)
 {
 	uint32 M[16];
 
-	if (n == 0) mdfour_tail(in, n);
-
 	m = md;
 
+	if (n == 0) mdfour_tail(in, n);
+
 	while (n >= 64) {
 		copy64(M, in);
 		mdfour64(M);
 		in += 64;
 		n -= 64;
-		m->totalN += 64;
+		m->totalN += 64 << 3;
+		if (m->totalN < 64 << 3) {
+			m->totalN2++;
+		}
 	}
 
 	if (n) mdfour_tail(in, n);
@@ -189,9 +206,11 @@ void mdfour(unsigned char *out, unsigned char *in, int n)
 }
 
 #ifdef TEST_MDFOUR
+int protocol_version = 28;
+
 static void file_checksum1(char *fname)
 {
-	int fd, i;
+	int fd, i, was_multiple_of_64 = 1;
 	struct mdfour md;
 	unsigned char buf[64*1024], sum[16];
 	
@@ -205,9 +224,13 @@ static void file_checksum1(char *fname)
 
 	while (1) {
 		int n = read(fd, buf, sizeof(buf));
-		if (n <= 0) break;
+		if (n <= 0)
+			break;
+		was_multiple_of_64 = !(n % 64);
 		mdfour_update(&md, buf, n);
 	}
+	if (was_multiple_of_64 && protocol_version >= 27)
+		mdfour_update(&md, buf, 0);
 
 	close(fd);
 

lib/mdfour.h

@@ -21,11 +21,12 @@
 
 struct mdfour {
 	uint32 A, B, C, D;
-	uint32 totalN;
+	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, int n);
+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/pool_alloc.3

@@ -0,0 +1,199 @@
+.ds d \-\^\-
+.ds o \fR[\fP
+.ds c \fR]\fP
+.ds | \fR|\fP
+.de D
+\\.B \*d\\$1
+..
+.de DI
+\\.BI \*d\\$1 \\$2
+..
+.de DR
+\\.BR \*d\\$1 \\$2
+..
+.de Di
+\\.BI \*d\\$1 " \\$2"
+..
+.de Db
+\\.B \*d\\$1 " \\$2"
+..
+.de Df
+\\.B \*d\*ono\*c\\$1
+..
+.de See
+See \fB\\$1\fP for details.
+..
+.de SeeIn
+See \fB\\$1\fP in \fB\\$2\fP for details.
+..
+.TH POOL_ALLOC 3
+.SH NAME
+pool_alloc, pool_free, pool_talloc, pool_tfree, pool_create, pool_destroy
+\- Allocate and free memory in managed allocation pools.
+.SH SYNOPSIS
+.B #include "pool_alloc.h"
+
+\fBstruct alloc_pool *pool_create(size_t \fIsize\fB, size_t \fIquantum\fB, void (*\fIbomb\fB)(char *), int \fIflags\fB);
+
+\fBvoid pool_destroy(struct alloc_pool *\fIpool\fB);
+
+\fBvoid *pool_alloc(struct alloc_pool *\fIpool\fB, size_t \fIsize\fB, char *\fImsg\fB);
+
+\fBvoid pool_free(struct alloc_pool *\fIpool\fB, sise_t \fIsize\fB, void *\fIaddr\fB);
+
+\fBvoid *pool_talloc(struct alloc_pool *\fIpool\fB, \fItype\fB), int \fIcount\fB, char *\fImsg\fB);
+
+\fBvoid pool_tfree(struct alloc_pool *\fIpool\fB, \fItype\fB, int \fIcount\fB, void *\fIaddr\fB);
+.SH DESCRIPTION
+.P
+The pool allocation routines use
+.B malloc()
+for underlying memory management.
+What allocation pools do is cause
+memory within a given pool to be in large contigious blocks
+(called extents) that when freed will be reusable.  Unlike
+.B malloc()
+the allocations are not managed individually.
+Instead each extent tracks the total free memory within the
+extent.  Each extent can either be used to allocate memory
+or to manage the freeing of memory within that extent.
+When an extent has less free memory than a given
+allocation request or when the first request to free
+memory within that extent is received the extent ceases to
+be used for allocation.
+.P
+This form of memory management is suited to large numbers of small
+related allocations that are held for a while
+and then freed as a group.
+Because the
+underlying allocations are done in large contigious extents
+when an extent is freed it releases a large enough
+contigious block of memory to be useful to subsequent
+.B malloc()
+and
+.B pool_alloc()
+calls even if allocations from other pools or from
+.B malloc()
+are made between allocations from a given pool.
+.P
+.B pool_create()
+Creates an allocation pool for subsequent calls to the pool
+allocation functions.
+When an extent is created for allocations it will be
+.I size 
+bytes.
+Allocations from the pool have their sizes rounded up to a
+multiple of
+.I quantum
+bytes in length.
+Specifying
+.B 0
+for
+.I quantum
+Will produce a quantum that should meet maximal allignment
+on most platforms.
+If the
+.B POOL_QALIGN
+.I flag
+is set allocations will be aligned to addresses that are a
+multiple of
+.IR quantum .
+If the
+.B POOL_CLEAR
+.I flag
+is set all allocations from the pool will be zero filled.
+.P
+.B pool_destroy()
+destroys an allocation pool and frees all memory allocated
+in that pool.
+.P
+.B pool_alloc()
+allocates
+.I size
+bytes from the specified
+.IR pool .
+If
+.I size
+is
+.B 0
+.I quantum
+bytes will be freed.
+If the requested memory cannot be allocated
+.B pool_alloc()
+will call
+.I bomb()
+function, if defined, with
+.I msg
+as it's sole argument and
+.B NULL
+will be returned.
+.P
+.B pool_free()
+frees
+.I size
+bytes pointed to by
+.I addr
+previously allocated in the specified
+.IR pool .
+The memory freed within an extent will not be reusable until
+all of the memory in that extent has been freed but 
+depending on the order in which the
+allocations are freed some extents may be released for reuse
+while others are still in use.
+If
+.I size
+is
+.B 0
+.I quantum
+bytes will be freed.
+If
+.I addr
+is
+.B 0
+no memory will be freed but subsequent allocations will come
+from a new extent.
+.P
+.B pool_talloc()
+is a macro that take a
+.I type
+and
+.I count
+instead of
+.I size
+and will cast the return value to the correct type.
+.P
+.B pool_tfree
+is a macro to free memory previously allocated in the
+specified
+.IR pool .
+.SH RETURN VALUE
+.B pool_create()
+returns a pointer to
+.BR "struct alloc_pool" .
+.P
+.B pool_alloc()
+and
+.B pool_talloc()
+return pointers to the allocated memory,
+or NULL if the request fails.
+For each extent so long as no allocations are smaller than varaible
+allignment requirements this pointer will be suitably
+alligned for any kind of variable.
+The return type of
+.B pool_alloc()
+will normally require casting to the desired type but
+.B pool_talloc()
+will returns a pointer of the requested
+.IR type .
+.P
+.BR pool_free() ,
+.B pool_tfree()
+and
+.B pool_destroy()
+return no value.
+.SH SEE ALSO
+.nf
+malloc(3)
+.SH AUTHOR
+pool_alloc was created by J.W. Schultz of Pegasystems Technologies.
+.SH BUGS AND ISSUES

lib/pool_alloc.c

@@ -0,0 +1,304 @@
+#include "rsync.h"
+
+#define POOL_DEF_EXTENT	(32 * 1024)
+
+struct alloc_pool
+{
+	size_t			size;		/* extent size		*/
+	size_t			quantum;	/* allocation quantum	*/
+	struct pool_extent	*live;		/* current extent for
+						 * allocations		*/
+	struct pool_extent	*free;		/* unfreed extent list	*/
+	void			(*bomb)();
+						/* function to call if
+						 * malloc fails		*/
+	int			flags;
+
+	/* statistical data */
+	unsigned long		e_created;	/* extents created	*/
+	unsigned long		e_freed;	/* extents detroyed	*/
+	int64			n_allocated;	/* calls to alloc	*/
+	int64			n_freed;	/* calls to free	*/
+	int64			b_allocated;	/* cum. bytes allocated	*/
+	int64			b_freed;	/* cum. bytes freed	*/
+};
+
+struct pool_extent
+{
+	void			*start;		/* starting address	*/
+	size_t			free;		/* free bytecount	*/
+	size_t			bound;		/* bytes bound by padding,
+						 * overhead and freed	*/
+	struct pool_extent	*next;
+};
+
+struct align_test {
+    void *foo;
+    int64 bar;
+};
+
+#define MINALIGN	offsetof(struct align_test, bar)
+
+/* Temporarily cast a void* var into a char* var when adding an offset (to
+ * keep some compilers from complaining about the pointer arithmetic). */
+#define PTR_ADD(b,o)	( (void*) ((char*)(b) + (o)) )
+
+alloc_pool_t
+pool_create(size_t size, size_t quantum,
+    void (*bomb)(char *), int flags)
+{
+	struct alloc_pool	*pool;
+
+	if (!(pool = (struct alloc_pool*) malloc(sizeof (struct alloc_pool))))
+		return pool;
+	memset(pool, 0, sizeof (struct alloc_pool));
+
+	pool->size = size	/* round extent size to min alignment reqs */
+	    ? (size + MINALIGN - 1) & ~(MINALIGN - 1)
+	    : POOL_DEF_EXTENT;
+	if (pool->flags & POOL_INTERN)
+	{
+		pool->size -= sizeof (struct pool_extent);
+		flags |= POOL_APPEND;
+	}
+	pool->quantum = quantum ? quantum : MINALIGN;
+	pool->bomb = bomb;
+	pool->flags = flags;
+
+	return pool;
+}
+
+void
+pool_destroy(alloc_pool_t p)
+{
+	struct alloc_pool *pool = (struct alloc_pool *) p;
+	struct pool_extent	*cur, *next;
+
+	if (!pool)
+		return;
+
+	if (pool->live)
+	{
+		cur = pool->live;
+		free(cur->start);
+		if (!(pool->flags & POOL_APPEND))
+			free(cur);
+	}
+	for (cur = pool->free; cur; cur = next)
+	{
+		next = cur->next;
+		free(cur->start);
+		if (!(pool->flags & POOL_APPEND))
+			free(cur);
+	}
+	free(pool);
+}
+
+void *
+pool_alloc(alloc_pool_t p, size_t len, char *bomb)
+{
+	struct alloc_pool *pool = (struct alloc_pool *) p;
+	if (!pool)
+		return NULL;
+
+	if (!len)
+		len = pool->quantum;
+	else if (pool->quantum > 1 && len % pool->quantum)
+		len += pool->quantum - len % pool->quantum;
+
+	if (len > pool->size)
+		goto bomb;
+
+	if (!pool->live || len > pool->live->free)
+	{
+		void	*start;
+		size_t	free;
+		size_t	bound;
+		size_t	sqew;
+		size_t	asize;
+
+		if (pool->live)
+		{
+			pool->live->next = pool->free;
+			pool->free = pool->live;
+		}
+
+		free = pool->size;
+		bound = 0;
+
+		asize = pool->size;
+		if (pool->flags & POOL_APPEND)
+			asize += sizeof (struct pool_extent);
+
+		if (!(start = (void *) malloc(asize)))
+			goto bomb;
+
+		if (pool->flags & POOL_CLEAR)
+			memset(start, 0, pool->size);
+
+		if (pool->flags & POOL_APPEND)
+		{
+			pool->live = PTR_ADD(start, free);
+		}
+		else if (!(pool->live = (struct pool_extent *) malloc(sizeof (struct pool_extent))))
+		{
+			goto bomb;
+		}
+		if (pool->flags & POOL_QALIGN && pool->quantum > 1
+		    && (sqew = (size_t)PTR_ADD(start, free) % pool->quantum))
+		{
+			bound  += sqew;
+			free -= sqew;
+		}
+		pool->live->start = start;
+		pool->live->free = free;
+		pool->live->bound = bound;
+		pool->live->next = NULL;
+
+		pool->e_created++;
+	}
+
+	pool->n_allocated++;
+	pool->b_allocated += len;
+
+	pool->live->free -= len;
+
+	return PTR_ADD(pool->live->start, pool->live->free);
+
+bomb:
+	if (pool->bomb)
+		(*pool->bomb)(bomb);
+	return NULL;
+}
+
+void
+pool_free(alloc_pool_t p, size_t len, void *addr)
+{
+	struct alloc_pool *pool = (struct alloc_pool *) p;
+	struct pool_extent	*cur;
+	struct pool_extent	*prev;
+
+	if (!pool)
+		return;
+
+	if (!len)
+		len = pool->quantum;
+	else if (pool->quantum > 1 && len % pool->quantum)
+		len += pool->quantum - len % pool->quantum;
+
+	if (!addr && pool->live)
+	{
+		pool->live->next = pool->free;
+		pool->free = pool->live;
+		pool->live = NULL;
+		return;
+	}
+	pool->n_freed++;
+	pool->b_freed += len;
+
+	cur = pool->live;
+	if (cur
+	    && addr >= cur->start
+	    && addr < PTR_ADD(cur->start, pool->size))
+	{
+		if (addr == PTR_ADD(cur->start, cur->free))
+		{
+			if (pool->flags & POOL_CLEAR)
+				memset(addr, 0, len);
+			pool->b_freed += len;
+		} else {
+			cur->bound += len;
+		}
+		if (cur->free + cur->bound >= pool->size)
+		{
+			size_t sqew;
+
+			cur->free = pool->size;
+			cur->bound = 0;
+			if (pool->flags & POOL_QALIGN && pool->quantum > 1
+			    && (sqew = (size_t)PTR_ADD(cur->start, cur->free) % pool->quantum))
+			{
+				cur->bound += sqew;
+				cur->free -= sqew;
+			}
+		}
+		return;
+	}
+	for (prev = NULL, cur = pool->free; cur; prev = cur, cur = cur->next)
+	{
+		if (addr >= cur->start
+		    && addr < PTR_ADD(cur->start, pool->size))
+			break;
+	}
+	if (!cur)
+		return;
+
+	if (prev)
+	{
+		prev->next = cur->next;
+		cur->next = pool->free;
+		pool->free = cur;
+	}
+	cur->bound += len;
+
+	if (cur->free + cur->bound >= pool->size)
+	{
+		pool->free = cur->next;
+
+		free(cur->start);
+		if (!(pool->flags & POOL_APPEND))
+			free(cur);
+		pool->e_freed++;
+	}
+	return;
+}
+
+#define FDPRINT(label, value) \
+	snprintf(buf, BUFSIZ, label, value), \
+	write(fd, buf, strlen(buf));
+
+#define FDEXTSTAT(ext) \
+	snprintf(buf, BUFSIZ, "  %12ld  %5ld\n", \
+		(long) ext->free, \
+		(long) ext->bound), \
+	write(fd, buf, strlen(buf))
+
+void
+pool_stats(alloc_pool_t p, int fd, int summarize)
+{
+	struct alloc_pool *pool = (struct alloc_pool *) p;
+	struct pool_extent	*cur;
+	char buf[BUFSIZ];
+
+	if (!pool)
+		return;
+
+	FDPRINT("  Extent size:       %12ld\n",	(long)	pool->size);
+	FDPRINT("  Alloc quantum:     %12ld\n",	(long)	pool->quantum);
+	FDPRINT("  Extents created:   %12ld\n",		pool->e_created);
+	FDPRINT("  Extents freed:     %12ld\n",		pool->e_freed);
+	FDPRINT("  Alloc count:       %12.0f\n", (double) pool->n_allocated);
+	FDPRINT("  Free Count:        %12.0f\n", (double) pool->n_freed);
+	FDPRINT("  Alloc bytes:       %12.0f\n", (double) pool->b_allocated);
+	FDPRINT("  Free bytes:        %12.0f\n", (double) pool->b_freed);
+
+	if (summarize)
+		return;
+
+	if (!pool->live && !pool->free)
+		return;
+
+	write(fd, "\n", 1);
+
+	if (pool->live)
+	{
+		FDEXTSTAT(pool->live);
+	}
+	strcpy(buf, "   FREE    BOUND\n");
+	write(fd, buf, strlen(buf));
+
+	for (cur = pool->free; cur; cur = cur->next)
+	{
+		FDEXTSTAT(cur);
+	}
+}

lib/pool_alloc.h

@@ -0,0 +1,20 @@
+#include <stddef.h>
+
+#define POOL_CLEAR	(1<<0)		/* zero fill allocations	*/
+#define POOL_QALIGN	(1<<1)		/* align data to quanta		*/
+#define POOL_INTERN	(1<<2)		/* Allocate extent structures	*/
+#define POOL_APPEND	(1<<3)		/*   or appended to extent data	*/
+
+typedef void *alloc_pool_t;
+
+alloc_pool_t pool_create(size_t size, size_t quantum, void (*bomb)(char *), int flags);
+void pool_destroy(alloc_pool_t pool);
+void *pool_alloc(alloc_pool_t pool, size_t size, char *bomb);
+void pool_free(alloc_pool_t pool, size_t size, void *addr);
+
+#define pool_talloc(pool, type, count, bomb) \
+	((type *)pool_alloc(pool, sizeof(type) * count, bomb))
+
+#define pool_tfree(pool, type, count, addr) \
+	(pool_free(pool, sizeof(type) * count, addr))
+

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 uchar *p, const uchar *text)
+{
+    int matched, special;
+    uchar 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 uchar *s;
+		    int i;
+		    for (s = p += 2; (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 uchar*)p, (const uchar*)t) == TRUE;
+}

lib/wildmatch.h

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

loadparm.c

@@ -1,17 +1,22 @@
 /* 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.
@@ -31,7 +36,7 @@
  * 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
@@ -43,6 +48,8 @@
  *
  */
 
+/* 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)
@@ -54,7 +61,7 @@ typedef char pstring[1024];
 typedef enum
 {
 	P_BOOL,P_BOOLREV,P_CHAR,P_INTEGER,P_OCTAL,
-	P_STRING,P_GSTRING,P_ENUM,P_SEP
+	P_PATH,P_STRING,P_GSTRING,P_ENUM,P_SEP
 } parm_type;
 
 typedef enum
@@ -77,8 +84,6 @@ struct parm_struct
 	unsigned flags;
 };
 
-static BOOL bLoaded = False;
-
 #ifndef GLOBAL_NAME
 #define GLOBAL_NAME "global"
 #endif
@@ -88,7 +93,7 @@ static BOOL bLoaded = False;
 #define iSERVICE(i) (*pSERVICE(i))
 #define LP_SNUM_OK(iService) (((iService) >= 0) && ((iService) < iNumServices))
 
-/* 
+/*
  * This structure describes global (ie., server-wide) parameters.
  */
 typedef struct
@@ -96,16 +101,18 @@ typedef struct
 	char *motd_file;
 	char *log_file;
 	char *pid_file;
-	int syslog_facility;
 	char *socket_options;
+	char *bind_address;
+	int syslog_facility;
+	int max_verbosity;
+	int rsync_port;
 } global;
 
 static global Globals;
 
 
-
-/* 
- * This structure describes a single service. 
+/*
+ * This structure describes a single service.
  */
 typedef struct
 {
@@ -114,6 +121,7 @@ typedef struct
 	char *comment;
 	char *lock_file;
 	BOOL read_only;
+	BOOL write_only;
 	BOOL list;
 	BOOL use_chroot;
 	BOOL transfer_logging;
@@ -125,6 +133,7 @@ typedef struct
 	char *auth_users;
 	char *secrets_file;
 	BOOL strict_modes;
+	char *filter;
 	char *exclude;
 	char *exclude_from;
 	char *include;
@@ -134,37 +143,50 @@ typedef struct
 	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 = 
+static service sDefault =
 {
 	NULL,    /* name */
 	NULL,    /* path */
 	NULL,    /* comment */
 	DEFAULT_LOCK_FILE,    /* lock file */
 	True,    /* read only */
+	False,   /* write 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,    /* filter */
 	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",    /* dont compress */
+	"*.gz *.tgz *.zip *.z *.rpm *.deb *.iso *.bz2 *.tbz",    /* dont compress */
 	0,        /* timeout */
-	0        /* max connections */
+	0,        /* max connections */
+	False     /* ignore nonreadable */
 };
 
 
@@ -206,7 +228,7 @@ static struct enum_list enum_facilities[] = {
 	{ LOG_NEWS, "news" },
 #endif
 #ifdef LOG_AUTH
-	{ LOG_AUTH, "security" },		
+	{ LOG_AUTH, "security" },
 #endif
 #ifdef LOG_SYSLOG
 	{ LOG_SYSLOG, "syslog" },
@@ -252,16 +274,21 @@ static struct parm_struct parm_table[] =
   {"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},
+  {"max verbosity",    P_INTEGER, P_GLOBAL, &Globals.max_verbosity, NULL,  0},
+  {"port",             P_INTEGER, P_GLOBAL, &Globals.rsync_port,    NULL,  0},
+  {"address",          P_STRING,  P_GLOBAL, &Globals.bind_address,  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},
+  {"path",             P_PATH,    P_LOCAL,  &sDefault.path,        NULL,   0},
   {"read only",        P_BOOL,    P_LOCAL,  &sDefault.read_only,   NULL,   0},
+  {"write only",       P_BOOL,    P_LOCAL,  &sDefault.write_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},
@@ -269,6 +296,7 @@ static struct parm_struct parm_table[] =
   {"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},
+  {"filter",           P_STRING,  P_LOCAL,  &sDefault.filter,      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},
@@ -287,10 +315,11 @@ Initialise the global parameter structure.
 ***************************************************************************/
 static void init_globals(void)
 {
-	memset(&Globals, 0, sizeof(Globals));
+	memset(&Globals, 0, sizeof Globals);
 #ifdef LOG_DAEMON
 	Globals.syslog_facility = LOG_DAEMON;
 #endif
+	Globals.max_verbosity = 1;
 }
 
 /***************************************************************************
@@ -302,8 +331,8 @@ 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 
+   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) \
@@ -330,16 +359,21 @@ 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_GLOBAL_INTEGER(lp_max_verbosity, &Globals.max_verbosity)
+FN_GLOBAL_INTEGER(lp_rsync_port, &Globals.rsync_port)
+FN_GLOBAL_STRING(lp_bind_address, &Globals.bind_address)
 
 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_write_only, write_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)
@@ -347,6 +381,7 @@ 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_filter, filter)
 FN_LOCAL_STRING(lp_exclude, exclude)
 FN_LOCAL_STRING(lp_exclude_from, exclude_from)
 FN_LOCAL_STRING(lp_include, include)
@@ -358,12 +393,11 @@ 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    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 void   copy_service(service *pserviceDest, service *pserviceSource);
 static BOOL   do_parameter(char *parmname, char *parmvalue);
 static BOOL   do_section(char *sectionname);
 
@@ -377,19 +411,33 @@ static void init_service(service *pservice)
 	copy_service(pservice,&sDefault);
 }
 
-static void string_set(char **s, char *v)
+
+/**
+ * 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);
+	if (!*s)
+		exit_cleanup(RERR_MALLOC);
 }
 
 
 /***************************************************************************
-add a new service to the services array initialising it with the given 
+add a new service to the services array initialising it with the given
 service
 ***************************************************************************/
 static int add_a_service(service *pservice, char *name)
@@ -401,7 +449,7 @@ static int add_a_service(service *pservice, char *name)
   tservice = *pservice;
 
   /* it might already exist */
-  if (name) 
+  if (name)
     {
       i = getservicebyname(name,NULL);
       if (i >= 0)
@@ -410,10 +458,10 @@ static int add_a_service(service *pservice, char *name)
 
   i = iNumServices;
 
-  ServicePtrs = (service **)Realloc(ServicePtrs,sizeof(service *)*num_to_alloc);
+  ServicePtrs = realloc_array(ServicePtrs, service *, num_to_alloc);
 
   if (ServicePtrs)
-	  pSERVICE(iNumServices) = (service *)malloc(sizeof(service));
+	  pSERVICE(iNumServices) = new(service);
 
   if (!ServicePtrs || !pSERVICE(iNumServices))
 	  return(-1);
@@ -423,7 +471,7 @@ static int add_a_service(service *pservice, char *name)
   init_service(pSERVICE(i));
   copy_service(pSERVICE(i),&tservice);
   if (name)
-    string_set(&iSERVICE(i).name,name);  
+    string_set(&iSERVICE(i).name,name);
 
   return(i);
 }
@@ -447,11 +495,12 @@ static int strwicmp(char *psz1, char *psz2)
    /* sync the strings on first non-whitespace */
    while (1)
    {
-      while (isspace(*psz1))
+      while (isspace(* (unsigned char *) psz1))
          psz1++;
-      while (isspace(*psz2))
+      while (isspace(* (unsigned char *) psz2))
          psz2++;
-      if (toupper(*psz1) != toupper(*psz2) || *psz1 == '\0' || *psz2 == '\0')
+      if (toupper(* (unsigned char *) psz1) != toupper(* (unsigned char *) psz2)
+	  || *psz1 == '\0' || *psz2 == '\0')
          break;
       psz1++;
       psz2++;
@@ -460,7 +509,7 @@ static int strwicmp(char *psz1, char *psz2)
 }
 
 /***************************************************************************
-Map a parameter's string representation to something we can use. 
+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)
@@ -470,7 +519,7 @@ static int map_parameter(char *parmname)
    if (*parmname == '-')
      return(-1);
 
-   for (iIndex = 0; parm_table[iIndex].label; iIndex++) 
+   for (iIndex = 0; parm_table[iIndex].label; iIndex++)
       if (strwicmp(parm_table[iIndex].label, parmname) == 0)
          return(iIndex);
 
@@ -481,7 +530,7 @@ static int map_parameter(char *parmname)
 
 /***************************************************************************
 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 
+Returns True in success, False if the passed string does not correctly
 represent a boolean.
 ***************************************************************************/
 static BOOL set_boolean(BOOL *pb, char *parmvalue)
@@ -515,7 +564,7 @@ static int getservicebyname(char *name, service *pserviceDest)
    int iService;
 
    for (iService = iNumServices - 1; iService >= 0; iService--)
-      if (strwicmp(iSERVICE(iService).name, name) == 0) 
+      if (strwicmp(iSERVICE(iService).name, name) == 0)
       {
          if (pserviceDest != NULL)
 	   copy_service(pserviceDest, pSERVICE(iService));
@@ -531,7 +580,7 @@ static int getservicebyname(char *name, service *pserviceDest)
 Copy a service structure to another
 
 ***************************************************************************/
-static void copy_service(service *pserviceDest, 
+static void copy_service(service *pserviceDest,
                          service *pserviceSource)
 {
   int i;
@@ -539,9 +588,9 @@ static void copy_service(service *pserviceDest,
   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 = 
+	void *src_ptr =
 	  ((char *)pserviceSource) + PTR_DIFF(def_ptr,&sDefault);
-	void *dest_ptr = 
+	void *dest_ptr =
 	  ((char *)pserviceDest) + PTR_DIFF(def_ptr,&sDefault);
 
 	switch (parm_table[i].type)
@@ -561,6 +610,7 @@ static void copy_service(service *pserviceDest,
 	    *(char *)dest_ptr = *(char *)src_ptr;
 	    break;
 
+	  case P_PATH:
 	  case P_STRING:
 	    string_set(dest_ptr,*(char **)src_ptr);
 	    break;
@@ -581,6 +631,7 @@ 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;
+   char *cp;
 
    parmnum = map_parameter(parmname);
 
@@ -627,6 +678,15 @@ static BOOL lp_do_parameter(int snum, char *parmname, char *parmvalue)
        sscanf(parmvalue,"%o",(int *)parm_ptr);
        break;
 
+     case P_PATH:
+       string_set(parm_ptr,parmvalue);
+       if ((cp = *(char**)parm_ptr) != NULL) {
+	   int len = strlen(cp);
+	   while (len > 1 && cp[len-1] == '/') len--;
+	   cp[len] = '\0';
+       }
+       break;
+
      case P_STRING:
        string_set(parm_ptr,parmvalue);
        break;
@@ -678,7 +738,7 @@ static BOOL do_section(char *sectionname)
      init_locals();
 
    /* if we've just struck a global section, note the fact. */
-   bInGlobalSection = isglobal;   
+   bInGlobalSection = isglobal;
 
    /* check for multiple global sections */
    if (bInGlobalSection)
@@ -710,27 +770,33 @@ static BOOL do_section(char *sectionname)
 
 
 /***************************************************************************
-Load the services array from the services file. Return True on success, 
+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();
 
-	pstrcpy(n2,pszFname);
+	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);
-  
-	bLoaded = True;
 
 	return (bRetval);
 }
@@ -755,7 +821,7 @@ int lp_number(char *name)
    int iService;
 
    for (iService = iNumServices - 1; iService >= 0; iService--)
-      if (strequal(lp_name(iService), name)) 
+      if (strcmp(lp_name(iService), name) == 0)
          break;
 
    return (iService);

log.c

@@ -1,35 +1,106 @@
-/* 
-   Copyright (C) Andrew Tridgell 1998
-   
+/* -*- 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
-
+  Logging and utility functions.
   tridge, May 1998
+
+  Mapping to human-readable messages added by Martin Pool
+  <mbp@samba.org>, Oct 2000.
   */
 #include "rsync.h"
 
+extern int verbose;
+extern int dry_run;
+extern int am_daemon;
+extern int am_server;
+extern int am_sender;
+extern int local_server;
+extern int quiet;
+extern int module_id;
+extern int msg_fd_out;
+extern int protocol_version;
+extern int preserve_times;
+extern int log_format_has_o_or_i;
+extern int daemon_log_format_has_o_or_i;
+extern char *auth_user;
+extern char *log_format;
+
+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_LOG_FAILURE, "daemon unable to append to log-file" },
+	{ 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_VANISHED   , "some files vanished before they could 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" },
+	{ RERR_DEL_LIMIT  , "the --max-delete limit stopped deletions" },
+	{ 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;
+}
+
 
 static void logit(int priority, char *buf)
 {
-	if (logfile) {
-		fprintf(logfile,"%s [%d] %s", 
+	if (logfname) {
+		if (!logfile)
+			log_open();
+		fprintf(logfile,"%s [%d] %s",
 			timestring(time(NULL)), (int)getpid(), buf);
 		fflush(logfile);
 	} else {
@@ -37,30 +108,29 @@ static void logit(int priority, char *buf)
 	}
 }
 
-void log_open(void)
+void log_init(void)
 {
-	static int initialised;
 	int options = LOG_PID;
 	time_t t;
-	char *logf;
 
-	if (initialised) return;
-	initialised = 1;
+	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 */
+	 * C library on some systems to fetch the timezone info
+	 * before the chroot */
 	t = time(NULL);
 	localtime(&t);
 
 	/* optionally use a log file instead of syslog */
-	logf = lp_log_file();
-	if (logf && *logf) {
-		extern int orig_umask;
-		int old_umask = umask(022 | orig_umask);
-		logfile = fopen(logf, "a");
-		umask(old_umask);
-		return;
+	logfname = lp_log_file();
+	if (logfname) {
+		if (*logfname) {
+			log_open();
+			return;
+		}
+		logfname = NULL;
 	}
 
 #ifdef LOG_NDELAY
@@ -78,119 +148,197 @@ void log_open(void)
 #endif
 }
 
-/* setup the error file descriptor - used when we are a server
-   that is receiving files */
-void set_error_fd(int fd)
+void log_open(void)
 {
-	log_error_fd = fd;
+	if (logfname && !logfile) {
+		extern int orig_umask;
+		int old_umask = umask(022 | orig_umask);
+		logfile = fopen(logfname, "a");
+		umask(old_umask);
+		if (!logfile) {
+			am_daemon = 0; /* avoid trying to log again */
+			rsyserr(FERROR, errno, "fopen() of log-file failed");
+			exit_cleanup(RERR_LOG_FAILURE);
+		}
+	}
+}
+
+void log_close(void)
+{
+	if (logfile) {
+		fclose(logfile);
+		logfile = NULL;
+	}
 }
 
 /* this is the underlying (unformatted) rsync debugging function. Call
-   it with FINFO, FERROR or FLOG */
+ * 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;
+	FILE *f = NULL;
 	/* recursion can happen with certain fatal conditions */
 
-	if (quiet && code == FINFO) return;
+	if (quiet && code == FINFO)
+		return;
 
-	if (len < 0) exit_cleanup(RERR_MESSAGEIO);
+	if (len < 0)
+		exit_cleanup(RERR_MESSAGEIO);
 
 	buf[len] = 0;
 
-	if (code == FLOG) {
-		if (am_daemon) logit(LOG_INFO, buf);
+	if (am_server && msg_fd_out >= 0) {
+		/* Pass the message to our sibling. */
+		send_msg((enum msgcode)code, buf, len);
 		return;
 	}
 
-	/* first try to pass it off the our sibling */
-	if (am_server && io_error_write(log_error_fd, code, buf, len)) {
+	if (code == FCLIENT)
+		code = FINFO;
+	else if (am_daemon) {
+		static int in_block;
+		char msg[2048];
+		int priority = code == FERROR ? LOG_WARNING : LOG_INFO;
+
+		if (in_block)
+			return;
+		in_block = 1;
+		if (!log_initialised)
+			log_init();
+		strlcpy(msg, buf, MIN((int)sizeof msg, len + 1));
+		logit(priority, msg);
+		in_block = 0;
+
+		if (code == FLOG || !am_server)
+			return;
+	} else if (code == FLOG)
 		return;
-	}
 
-	/* then try to pass it to the other end */
-	if (am_server && io_multiplex_write(code, buf, len)) {
-		return;
-	}
-
-	if (am_daemon) {
-		static int depth;
-		int priority = LOG_INFO;
-		if (code == FERROR) priority = LOG_WARNING;
-
-		if (depth) return;
-
-		depth++;
-
-		log_open();
-		logit(priority, buf);
-
-		depth--;
-		return;
+	if (am_server) {
+		/* Pass the message to the non-server side. */
+		if (io_multiplex_write((enum msgcode)code, buf, len))
+			return;
+		if (am_daemon) {
+			/* TODO: can we send the error to the user somehow? */
+			return;
+		}
 	}
 
 	if (code == FERROR) {
+		log_got_error = 1;
 		f = stderr;
-	} 
+	}
 
-	if (code == FINFO) {
-		if (am_server) 
-			f = stderr;
-		else
-			f = stdout;
-	} 
+	if (code == FINFO)
+		f = am_server ? stderr : stdout;
 
-	if (!f) exit_cleanup(RERR_MESSAGEIO);
+	if (!f)
+		exit_cleanup(RERR_MESSAGEIO);
 
-	if (fwrite(buf, len, 1, f) != 1) 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);
+	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, ...)
+
+/* 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_list ap;
+	char buf[MAXPATHLEN+512];
+	size_t len;
 
 	va_start(ap, format);
-	len = vslprintf(buf, sizeof(buf), format, ap);
+	len = vsnprintf(buf, sizeof buf, format, ap);
 	va_end(ap);
 
-	if (len > sizeof(buf)-1) exit_cleanup(RERR_MESSAGEIO);
+	/* Deal with buffer overruns.  Instead of panicking, just
+	 * truncate the resulting string.  (Note that configure ensures
+	 * that we have a vsnprintf() that doesn't ever return -1.) */
+	if (len > sizeof buf - 1) {
+		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[MAXPATHLEN+512];
+	size_t len;
+
+	strcpy(buf, RSYNC_NAME ": ");
+	len = (sizeof RSYNC_NAME ": ") - 1;
+
+	va_start(ap, format);
+	len += vsnprintf(buf + len, sizeof buf - len, format, ap);
+	va_end(ap);
+
+	if (len < sizeof buf) {
+		len += snprintf(buf + len, sizeof buf - len,
+				": %s (%d)\n", strerror(errcode), errcode);
+	}
+	if (len >= sizeof buf)
+		exit_cleanup(RERR_MESSAGEIO);
+
+	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) 
+		if (am_server)
 			f = stderr;
 		else
 			f = stdout;
-	} 
+	}
 
 	if (!f) exit_cleanup(RERR_MESSAGEIO);
 	fflush(f);
@@ -199,154 +347,310 @@ void rflush(enum logcode code)
 
 
 /* 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)
+ * substitiution */
+static void log_formatted(enum logcode code, char *format, char *op,
+			  struct file_struct *file, struct stats *initial_stats,
+			  int iflags, char *hlink)
 {
-	extern int module_id;
-	extern char *auth_user;
-	char buf[1024];
-	char buf2[1024];
+	char buf[MAXPATHLEN+1024], buf2[MAXPATHLEN], fmt[32];
 	char *p, *s, *n;
-	int l;
-	extern struct stats stats;		
-	extern int am_sender;
-	extern int am_daemon;
+	size_t len, total;
 	int64 b;
 
-	strlcpy(buf, format, sizeof(buf));
-	
-	for (s=&buf[0]; 
-	     s && (p=strchr(s,'%')); ) {
-		n = NULL;
-		s = p + 1;
+	*fmt = '%';
 
-		switch (p[1]) {
+	/* We expand % codes one by one in place in buf.  We don't
+	 * copy in the terminating null of the inserted strings, but
+	 * rather keep going until we reach the null of the format. */
+	total = strlcpy(buf, format, sizeof buf);
+	if (total > MAXPATHLEN) {
+		rprintf(FERROR, "log-format string is WAY too long!\n");
+		exit_cleanup(RERR_MESSAGEIO);
+	}
+	buf[total++] = '\n';
+	buf[total] = '\0';
+
+	for (p = buf; (p = strchr(p, '%')) != NULL; ) {
+		s = p++;
+		n = fmt + 1;
+		if (*p == '-')
+			*n++ = *p++;
+		while (isdigit(*(uchar*)p) && n - fmt < (int)(sizeof fmt) - 8)
+			*n++ = *p++;
+		if (!*p)
+			break;
+		*n = '\0';
+		n = NULL;
+
+		switch (*p) {
 		case 'h': if (am_daemon) n = client_name(0); break;
 		case 'a': if (am_daemon) n = client_addr(0); break;
-		case 'l': 
-			slprintf(buf2,sizeof(buf2),"%.0f", 
-				 (double)file->length); 
+		case 'l':
+			strlcat(fmt, ".0f", sizeof fmt);
+			snprintf(buf2, sizeof buf2, fmt,
+				 (double)file->length);
 			n = buf2;
 			break;
-		case 'p': 
-			slprintf(buf2,sizeof(buf2),"%d", 
-				 (int)getpid()); 
+		case 'p':
+			strlcat(fmt, "ld", sizeof fmt);
+			snprintf(buf2, sizeof buf2, fmt,
+				 (long)getpid());
 			n = buf2;
 			break;
 		case 'o': n = op; break;
-		case 'f': 
-			slprintf(buf2, sizeof(buf2), "%s/%s", 
-				 file->basedir?file->basedir:"", 
-				 f_name(file));
-			clean_fname(buf2);
-			n = buf2; 
-			if (*n == '/') n++;
+		case 'f':
+			n = safe_fname(f_name(file));
+			if (am_sender && file->dir.root) {
+				pathjoin(buf2, sizeof buf2,
+					 file->dir.root, n);
+				/* The buffer from safe_fname() has more
+				 * room than MAXPATHLEN, so this is safe. */
+				if (fmt[1])
+					strcpy(n, buf2);
+				else
+					n = buf2;
+			}
+			clean_fname(n, 0);
+			if (*n == '/')
+				n++;
+			break;
+		case 'n':
+			n = safe_fname(f_name(file));
+			if (S_ISDIR(file->mode)) {
+				/* The buffer from safe_fname() has more
+				 * room than MAXPATHLEN, so this is safe. */
+				strcat(n, "/");
+			}
+			break;
+		case 'L':
+			if (hlink && *hlink) {
+				n = safe_fname(hlink);
+				strcpy(buf2, " => ");
+			} else if (S_ISLNK(file->mode) && file->u.link) {
+				n = safe_fname(file->u.link);
+				strcpy(buf2, " -> ");
+			} else {
+				n = "";
+				if (!fmt[1])
+					break;
+				strcpy(buf2, "    ");
+			}
+			strlcat(fmt, "s", sizeof fmt);
+			snprintf(buf2 + 4, sizeof buf2 - 4, fmt, n);
+			n = buf2;
 			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': 
+		case 'b':
 			if (am_sender) {
-				b = stats.total_written - 
+				b = stats.total_written -
 					initial_stats->total_written;
 			} else {
-				b = stats.total_read - 
+				b = stats.total_read -
 					initial_stats->total_read;
 			}
-			slprintf(buf2,sizeof(buf2),"%.0f", (double)b); 
+			strlcat(fmt, ".0f", sizeof fmt);
+			snprintf(buf2, sizeof buf2, fmt, (double)b);
 			n = buf2;
 			break;
-		case 'c': 
+		case 'c':
 			if (!am_sender) {
-				b = stats.total_written - 
+				b = stats.total_written -
 					initial_stats->total_written;
 			} else {
-				b = stats.total_read - 
+				b = stats.total_read -
 					initial_stats->total_read;
 			}
-			slprintf(buf2,sizeof(buf2),"%.0f", (double)b); 
+			strlcat(fmt, ".0f", sizeof fmt);
+			snprintf(buf2, sizeof buf2, fmt, (double)b);
 			n = buf2;
 			break;
+		case 'i':
+			if (iflags & ITEM_DELETED) {
+				n = "*deleting";
+				break;
+			}
+			n = buf2 + MAXPATHLEN - 32;
+			n[0] = iflags & ITEM_LOCAL_CHANGE
+			      ? iflags & ITEM_XNAME_FOLLOWS ? 'h' : 'c'
+			     : !(iflags & ITEM_TRANSFER) ? '.'
+			     : !local_server && *op == 's' ? '<' : '>';
+			n[1] = S_ISDIR(file->mode) ? 'd'
+			     : IS_DEVICE(file->mode) ? 'D'
+			     : S_ISLNK(file->mode) ? 'L' : 'f';
+			n[2] = !(iflags & ITEM_REPORT_CHECKSUM) ? '.' : 'c';
+			n[3] = !(iflags & ITEM_REPORT_SIZE) ? '.' : 's';
+			n[4] = !(iflags & ITEM_REPORT_TIME) ? '.'
+			     : !preserve_times || IS_DEVICE(file->mode)
+					       || S_ISLNK(file->mode) ? 'T' : 't';
+			n[5] = !(iflags & ITEM_REPORT_PERMS) ? '.' : 'p';
+			n[6] = !(iflags & ITEM_REPORT_OWNER) ? '.' : 'o';
+			n[7] = !(iflags & ITEM_REPORT_GROUP) ? '.' : 'g';
+			n[8] = !(iflags & ITEM_REPORT_XATTRS) ? '.' : 'a';
+			n[9] = '\0';
+
+			if (iflags & (ITEM_IS_NEW|ITEM_MISSING_DATA)) {
+				char ch = iflags & ITEM_IS_NEW ? '+' : '?';
+				int i;
+				for (i = 2; n[i]; i++)
+					n[i] = ch;
+			} else if (!(iflags & (ITEM_TRANSFER|ITEM_LOCAL_CHANGE))) {
+				int i;
+				for (i = 2; n[i]; i++) {
+					if (n[i] != '.')
+						break;
+				}
+				if (!n[i]) {
+					for (i = 2; n[i]; i++)
+						n[i] = ' ';
+				}
+			}
+			break;
 		}
 
-		if (!n) continue;
+		/* "n" is the string to be inserted in place of this % code. */
+		if (!n)
+			continue;
+		if (n != buf2 && fmt[1]) {
+			strlcat(fmt, "s", sizeof fmt);
+			snprintf(buf2, sizeof buf2, fmt, n);
+			n = buf2;
+		}
+		len = strlen(n);
 
-		l = strlen(n);
+		/* Subtract the length of the escape from the string's size. */
+		total -= p - s + 1;
 
-		if ((l-1) + ((int)(s - &buf[0])) > sizeof(buf)) {
-			rprintf(FERROR,"buffer overflow expanding %%%c - exiting\n",
+		if (len + total >= (size_t)sizeof buf) {
+			rprintf(FERROR,
+				"buffer overflow expanding %%%c -- exiting\n",
 				p[0]);
 			exit_cleanup(RERR_MESSAGEIO);
 		}
 
-		if (l != 2) {
-			memmove(s+(l-1), s+1, strlen(s+1)+1);
-		}
-		memcpy(p, n, l);
+		/* Shuffle the rest of the string along to make space for n */
+		if (len != (size_t)(p - s + 1))
+			memmove(s + len, p + 1, total - (s - buf) + 1);
+		total += len;
 
-		s = p+l;
+		/* Insert the contents of string "n", but NOT its null. */
+		if (len)
+			memcpy(s, n, len);
+
+		/* Skip over inserted string; continue looking */
+		p = s + len;
 	}
 
-	rprintf(code,"%s\n", buf);
+	rwrite(code, buf, total);
 }
 
-/* log the outgoing transfer of a file */
-void log_send(struct file_struct *file, struct stats *initial_stats)
+/* Return 1 if the format escape is in the log-format string (e.g. look for
+ * the 'b' in the "%9b" format escape). */
+int log_format_has(const char *format, char esc)
 {
-	extern int module_id;
-	extern int am_server;
-	extern char *log_format;
+	const char *p;
+
+	if (!format)
+		return 0;
+
+	for (p = format; (p = strchr(p, '%')) != NULL; ) {
+		if (*++p == '-')
+			p++;
+		while (isdigit(*(uchar*)p))
+			p++;
+		if (!*p)
+			break;
+		if (*p == esc)
+			return 1;
+	}
+	return 0;
+}
+
+/* log the transfer of a file */
+void log_item(struct file_struct *file, struct stats *initial_stats,
+	      int iflags, char *hlink)
+{
+	char *s_or_r = am_sender ? "send" : "recv";
 
 	if (lp_transfer_logging(module_id)) {
-		log_formatted(FLOG, lp_log_format(module_id), "send", file, initial_stats);
+		log_formatted(FLOG, lp_log_format(module_id), s_or_r,
+			      file, initial_stats, iflags, hlink);
 	} else if (log_format && !am_server) {
-		log_formatted(FINFO, log_format, "send", file, initial_stats);
+		log_formatted(FINFO, log_format, s_or_r,
+			      file, initial_stats, iflags, hlink);
 	}
 }
 
-/* log the incoming transfer of a file */
-void log_recv(struct file_struct *file, struct stats *initial_stats)
+void maybe_log_item(struct file_struct *file, int iflags, int itemizing,
+		    char *buf)
 {
-	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);
-	}
+	int see_item = itemizing && (iflags || verbose > 1);
+	if (am_server) {
+		if (am_daemon && !dry_run && see_item)
+			log_item(file, &stats, iflags, buf);
+	} else if (see_item || iflags & ITEM_LOCAL_CHANGE || *buf
+	    || (S_ISDIR(file->mode) && iflags & SIGNIFICANT_ITEM_FLAGS))
+		log_item(file, &stats, iflags, buf);
 }
 
-/* called when the transfer is interrupted for some reason */
+void log_delete(char *fname, int mode)
+{
+	static struct file_struct file;
+	int len = strlen(fname);
+	char *fmt;
+
+	file.mode = mode;
+	file.basename = fname;
+
+	if (!verbose && !log_format)
+		;
+	else if (am_server && protocol_version >= 29 && len < MAXPATHLEN) {
+		if (S_ISDIR(mode))
+			len++; /* directories include trailing null */
+		send_msg(MSG_DELETED, fname, len);
+	} else {
+		fmt = log_format_has_o_or_i ? log_format : "deleting %n";
+		log_formatted(FCLIENT, fmt, "del.", &file, &stats,
+			      ITEM_DELETED, NULL);
+	}
+
+	if (!am_daemon || dry_run || !lp_transfer_logging(module_id))
+		return;
+
+	fmt = daemon_log_format_has_o_or_i ? lp_log_format(module_id) : "deleting %n";
+	log_formatted(FLOG, fmt, "del.", &file, &stats, ITEM_DELETED, NULL);
+}
+
+
+/*
+ * 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",
+		rprintf(FLOG,"sent %.0f bytes  received %.0f bytes  total size %.0f\n",
 			(double)stats.total_written,
 			(double)stats.total_read,
 			(double)stats.total_size);
 	} else {
-		rprintf(FLOG,"transfer interrupted (code %d) at %s(%d)\n", 
-			code, file, line);
+		const char *name;
+
+		name = rerr_name(code);
+		if (!name)
+			name = "unexplained error";
+
+		/* VANISHED is not an error, only a warning */
+		if (code == RERR_VANISHED) {
+			rprintf(FINFO, "rsync warning: %s (code %d) at %s(%d)\n", 
+				name, code, file, line);
+		} else {
+			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 
-   
-   it i called when a file starts to be transferred
-*/
-void log_transfer(struct file_struct *file, const char *fname)
-{
-	extern int verbose;
-
-	if (!verbose) return;
-
-	rprintf(FINFO,"%s\n", fname);
-}
-

match.c

@@ -1,17 +1,17 @@
-/* 
+/*
    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.
@@ -19,12 +19,12 @@
 
 #include "rsync.h"
 
-extern int csum_length;
-
 extern int verbose;
 extern int am_server;
+extern int do_progress;
+extern int checksum_seed;
 
-extern int remote_version;
+int updating_basis_file;
 
 typedef unsigned short tag;
 
@@ -43,74 +43,88 @@ static int total_matches;
 extern struct stats stats;
 
 struct target {
-  tag t;
-  int i;
+	tag t;
+	int32 i;
 };
 
 static struct target *targets;
 
-static int *tag_table;
+static int32 *tag_table;
 
 #define gettag2(s1,s2) (((s1) + (s2)) & 0xFFFF)
 #define gettag(sum) gettag2((sum)&0xFFFF,(sum)>>16)
 
 static int compare_targets(struct target *t1,struct target *t2)
 {
-  return((int)t1->t - (int)t2->t);
+	return (int)t1->t - (int)t2->t;
 }
 
 
 static void build_hash_table(struct sum_struct *s)
 {
-  int i;
+	int32 i;
 
-  if (!tag_table)
-    tag_table = (int *)malloc(sizeof(tag_table[0])*TABLESIZE);
+	if (!tag_table)
+		tag_table = new_array(int32, TABLESIZE);
 
-  targets = (struct target *)malloc(sizeof(targets[0])*s->count);
-  if (!tag_table || !targets) 
-    out_of_memory("build_hash_table");
+	targets = new_array(struct target, s->count);
+	if (!tag_table || !targets)
+		out_of_memory("build_hash_table");
 
-  for (i=0;i<s->count;i++) {
-    targets[i].i = i;
-    targets[i].t = gettag(s->sums[i].sum1);
-  }
+	for (i = 0; i < s->count; i++) {
+		targets[i].i = i;
+		targets[i].t = gettag(s->sums[i].sum1);
+	}
 
-  qsort(targets,s->count,sizeof(targets[0]),(int (*)())compare_targets);
+	qsort(targets,s->count,sizeof(targets[0]),(int (*)())compare_targets);
 
-  for (i=0;i<TABLESIZE;i++)
-    tag_table[i] = NULL_TAG;
+	for (i = 0; i < TABLESIZE; i++)
+		tag_table[i] = NULL_TAG;
 
-  for (i=s->count-1;i>=0;i--) {    
-    tag_table[targets[i].t] = i;
-  }
+	for (i = s->count; i-- > 0; )
+		tag_table[targets[i].t] = i;
 }
 
 
 static OFF_T last_match;
 
 
-static void matched(int f,struct sum_struct *s,struct map_struct *buf,
-		    OFF_T offset,int i)
+/**
+ * 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, int32 i)
 {
-	OFF_T n = offset - last_match;
-	OFF_T j;
+	int32 n = offset - last_match; /* max value: block_size (int32) */
+	int32 j;
 
-	if (verbose > 2 && i >= 0)
-		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);
+	if (verbose > 2 && i >= 0) {
+		rprintf(FINFO,
+			"match at %.0f last_match=%.0f j=%d len=%ld n=%ld\n",
+			(double)offset, (double)last_match, i,
+			(long)s->sums[i].len, (long)n);
+	}
 
-	send_token(f,i,buf,last_match,n,i<0?0:s->sums[i].len);
+	send_token(f, i, buf, last_match, n, i < 0 ? 0 : s->sums[i].len);
 	data_transfer += n;
 
 	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);
-		sum_update(map_ptr(buf,last_match+j,n1),n1);
+
+	for (j = 0; j < n; j += CHUNK_SIZE) {
+		int32 n1 = MIN(CHUNK_SIZE, n - j);
+		sum_update(map_ptr(buf, last_match + j, n1), n1);
 	}
 
 
@@ -119,126 +133,161 @@ static void matched(int f,struct sum_struct *s,struct map_struct *buf,
 	else
 		last_match = offset;
 
-	if (buf) {
+	if (buf && do_progress)
 		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, end;
-	int j,k, last_i;
+	OFF_T offset, end, backup;
+	int32 k, want_i;
 	char sum2[SUM_LENGTH];
-	uint32 s1, s2, sum; 
+	uint32 s1, s2, sum;
+	int more;
 	schar *map;
 
-	/* last_i is used to encourage adjacent matches, allowing the RLL coding of the
-	   output to work more efficiently */
-	last_i = -1;
+	/* want_i is used to encourage adjacent matches, allowing the RLL
+	 * coding of the output to work more efficiently. */
+	want_i = 0;
 
-	if (verbose > 2)
-		rprintf(FINFO,"hash search b=%d len=%.0f\n",s->n,(double)len);
+	if (verbose > 2) {
+		rprintf(FINFO, "hash search b=%ld len=%.0f\n",
+			(long)s->blength, (double)len);
+	}
+
+	k = (int32)MIN(len, (OFF_T)s->blength);
+
+	map = (schar *)map_ptr(buf, 0, k);
 
-	k = MIN(len, s->n);
-	
-	map = (schar *)map_ptr(buf,0,k);
-	
 	sum = get_checksum1((char *)map, k);
 	s1 = sum & 0xFFFF;
 	s2 = sum >> 16;
 	if (verbose > 3)
-		rprintf(FINFO, "sum=%.8x k=%d\n", sum, k);
-	
+		rprintf(FINFO, "sum=%.8x k=%ld\n", sum, (long)k);
+
 	offset = 0;
-	
+
 	end = len + 1 - s->sums[s->count-1].len;
-	
-	if (verbose > 3)
-		rprintf(FINFO,"hash search s->n=%d len=%.0f count=%d\n",
-			s->n,(double)len,s->count);
-	
+
+	if (verbose > 3) {
+		rprintf(FINFO, "hash search s->blength=%ld len=%.0f count=%.0f\n",
+			(long)s->blength, (double)len, (double)s->count);
+	}
+
 	do {
 		tag t = gettag2(s1,s2);
 		int done_csum2 = 0;
-			
-		j = tag_table[t];
+		int32 j = tag_table[t];
+
 		if (verbose > 4)
 			rprintf(FINFO,"offset=%.0f sum=%08x\n",(double)offset,sum);
-		
-		if (j == NULL_TAG) {
+
+		if (j == NULL_TAG)
 			goto null_tag;
-		}
 
 		sum = (s1 & 0xffff) | (s2 << 16);
 		tag_hits++;
-		for (; j<s->count && targets[j].t == t; j++) {
-			int l, i = targets[j].i;
-			
-			if (sum != s->sums[i].sum1) continue;
-			
+		do {
+			int32 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;			
+			l = (int32)MIN((OFF_T)s->blength, len-offset);
+			if (l != s->sums[i].len)
+				continue;
+
+			/* in-place: ensure chunk's offset is either >= our
+			 * offset or that the data didn't move. */
+			if (updating_basis_file && s->sums[i].offset < offset
+			    && !(s->sums[i].flags & SUMFLG_SAME_OFFSET))
+				continue;
 
 			if (verbose > 3)
-				rprintf(FINFO,"potential match at %.0f target=%d %d sum=%08x\n",
-					(double)offset,j,i,sum);
-			
+				rprintf(FINFO,"potential match at %.0f target=%.0f %.0f sum=%08x\n",
+					(double)offset,(double)j,(double)i,sum);
+
 			if (!done_csum2) {
 				map = (schar *)map_ptr(buf,offset,l);
 				get_checksum2((char *)map,l,sum2);
 				done_csum2 = 1;
 			}
-			
-			if (memcmp(sum2,s->sums[i].sum2,csum_length) != 0) {
+
+			if (memcmp(sum2,s->sums[i].sum2,s->s2length) != 0) {
 				false_alarms++;
 				continue;
 			}
 
-			/* we've found a match, but now check to see
-                           if last_i can hint at a better match */
-			for (j++; j<s->count && targets[j].t == t; j++) {
-				int i2 = targets[j].i;
-				if (i2 == last_i + 1) {
-					if (sum != s->sums[i2].sum1) break;
-					if (memcmp(sum2,s->sums[i2].sum2,csum_length) != 0) break;
-					/* we've found an adjacent match - the RLL coder 
-					   will be happy */
-					i = i2;
-					break;
-				}
+			/* When updating in-place, the best possible match is
+			 * one with an identical offset, so we prefer that over
+			 * the following want_i optimization. */
+			if (updating_basis_file) {
+				do {
+					int32 i2 = targets[j].i;
+					if (s->sums[i2].offset != offset)
+						continue;
+					if (i2 != i) {
+						if (sum != s->sums[i2].sum1)
+							break;
+						if (memcmp(sum2, s->sums[i2].sum2,
+							   s->s2length) != 0)
+							break;
+						i = i2;
+					}
+					/* This chunk was at the same offset on
+					 * both the sender and the receiver. */
+					s->sums[i].flags |= SUMFLG_SAME_OFFSET;
+					goto set_want_i;
+				} while (++j < s->count && targets[j].t == t);
 			}
 
-			last_i = i;
-			
+			/* we've found a match, but now check to see
+			 * if want_i can hint at a better match. */
+			if (i != want_i && want_i < s->count
+			    && (!updating_basis_file || s->sums[want_i].offset >= offset
+			     || s->sums[want_i].flags & SUMFLG_SAME_OFFSET)
+			    && sum == s->sums[want_i].sum1
+			    && memcmp(sum2, s->sums[want_i].sum2, s->s2length) == 0) {
+				/* we've found an adjacent match - the RLL coder
+				 * will be happy */
+				i = want_i;
+			}
+		    set_want_i:
+			want_i = i + 1;
+
 			matched(f,s,buf,offset,i);
 			offset += s->sums[i].len - 1;
-			k = MIN((len-offset), s->n);
-			map = (schar *)map_ptr(buf,offset,k);
+			k = (int32)MIN((OFF_T)s->blength, len-offset);
+			map = (schar *)map_ptr(buf, offset, k);
 			sum = get_checksum1((char *)map, k);
 			s1 = sum & 0xFFFF;
 			s2 = sum >> 16;
 			matches++;
 			break;
-		}
-		
+		} while (++j < s->count && targets[j].t == t);
+
 	null_tag:
+		backup = offset - last_match;
+		/* We sometimes read 1 byte prior to last_match... */
+		if (backup < 0)
+			backup = 0;
+
 		/* Trim off the first byte from the checksum */
-		map = (schar *)map_ptr(buf,offset,k+1);
+		more = offset + k < len;
+		map = (schar *)map_ptr(buf, offset - backup, k + more + backup)
+		    + backup;
 		s1 -= map[0] + CHAR_OFFSET;
 		s2 -= k * (map[0]+CHAR_OFFSET);
-		
+
 		/* Add on the next byte (if there is one) to the checksum */
-		if (k < (len-offset)) {
-			s1 += (map[k]+CHAR_OFFSET);
+		if (more) {
+			s1 += map[k] + CHAR_OFFSET;
 			s2 += s1;
-		} else {
+		} else
 			--k;
-		}
 
 		/* By matching early we avoid re-reading the
 		   data 3 times in the case where a token
@@ -246,66 +295,77 @@ static void hash_search(int f,struct sum_struct *s,
 		   match. The 3 reads are caused by the
 		   running match, the checksum update and the
 		   literal send. */
-		if (offset-last_match >= CHUNK_SIZE+s->n && 
-		    (end-offset > CHUNK_SIZE)) {
-			matched(f,s,buf,offset - s->n, -2);
-		}
+		if (backup >= s->blength+CHUNK_SIZE && end-offset > CHUNK_SIZE)
+			matched(f, s, buf, offset - s->blength, -2);
 	} while (++offset < end);
-	
-	matched(f,s,buf,len,-1);
-	map_ptr(buf,len-1,1);
+
+	matched(f, s, buf, len, -1);
+	map_ptr(buf, len-1, 1);
 }
 
 
-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];
 
 	last_match = 0;
 	false_alarms = 0;
 	tag_hits = 0;
-	matches=0;
-	data_transfer=0;
+	matches = 0;
+	data_transfer = 0;
 
-	sum_init();
+	sum_init(checksum_seed);
 
-	if (len > 0 && s->count>0) {
+	if (len > 0 && s->count > 0) {
 		build_hash_table(s);
-		
-		if (verbose > 2) 
+
+		if (verbose > 2)
 			rprintf(FINFO,"built hash table\n");
-		
+
 		hash_search(f,s,buf,len);
-		
-		if (verbose > 2) 
+
+		if (verbose > 2)
 			rprintf(FINFO,"done hash search\n");
 	} else {
 		OFF_T j;
 		/* by doing this in pieces we avoid too many seeks */
-		for (j=0;j<(len-CHUNK_SIZE);j+=CHUNK_SIZE) {
-			int n1 = MIN(CHUNK_SIZE,(len-CHUNK_SIZE)-j);
-			matched(f,s,buf,j+n1,-2);
-		}
-		matched(f,s,buf,len,-1);
+		for (j = CHUNK_SIZE; j < len; j += CHUNK_SIZE)
+			matched(f, s, buf, j, -2);
+		matched(f, s, buf, len, -1);
 	}
 
 	sum_end(file_sum);
+	/* If we had a read error, send a bad checksum. */
+	if (buf && buf->status != 0)
+		file_sum[0]++;
 
-	if (remote_version >= 14) {
-		if (verbose > 2)
-			rprintf(FINFO,"sending file_sum\n");
-		write_buf(f,file_sum,MD4_SUM_LENGTH);
-	}
+	if (verbose > 2)
+		rprintf(FINFO,"sending file_sum\n");
+	write_buf(f,file_sum,MD4_SUM_LENGTH);
 
 	if (targets) {
 		free(targets);
 		targets=NULL;
 	}
-	
+
 	if (verbose > 2)
 		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;

mkproto.awk

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

packaging/lsb/rsync.spec

@@ -0,0 +1,88 @@
+Summary: A program for synchronizing files over a network.
+Name: rsync
+Version: 2.6.4
+Release: 1
+Group: Applications/Internet
+Source:	ftp://rsync.samba.org/pub/rsync/rsync-%{version}.tar.gz
+URL: http://rsync.samba.org/
+
+Prefix: %{_prefix}
+BuildRoot: /var/tmp/%{name}-root
+License: GPL
+
+%description
+Rsync uses a reliable algorithm to bring remote and host files into
+sync very quickly. Rsync is fast because it just sends the differences
+in the files over the network instead of sending the complete
+files. Rsync is often used as a very powerful mirroring process or
+just as a more capable replacement for the rcp command. A technical
+report which describes the rsync algorithm is included in this
+package.
+
+%prep
+%setup -q
+
+%build
+%configure
+
+make
+
+%install
+rm -rf $RPM_BUILD_ROOT
+
+%makeinstall
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%files
+%defattr(-,root,root)
+%doc COPYING README tech_report.tex
+%{_prefix}/bin/rsync
+%{_mandir}/man1/rsync.1*
+%{_mandir}/man5/rsyncd.conf.5*
+
+%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).)

packaging/redhat/5.0/rsync.spec

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

packaging/redhat/5.0/rsync.spec.tmpl

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

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

@@ -164,7 +164,7 @@ static int Continuation( char *line, int pos )
    */
   {
   pos--;
-  while( (pos >= 0) && isspace(line[pos]) )
+  while( (pos >= 0) && isspace(((unsigned char *)line)[pos]) )
      pos--;
 
   return( ((pos >= 0) && ('\\' == line[pos])) ? pos : -1 );
@@ -207,7 +207,7 @@ static BOOL Section( FILE *InFile, BOOL (*sfunc)(char *) )
     if( i > (bSize - 2) )
       {
       bSize += BUFR_INC;
-      bufr   = Realloc( bufr, bSize );
+      bufr   = realloc_array( bufr, char, bSize );
       if( NULL == bufr )
         {
         rprintf(FERROR, "%s Memory re-allocation failure.", func);
@@ -301,7 +301,7 @@ static BOOL Parameter( FILE *InFile, BOOL (*pfunc)(char *, char *), int c )
     if( i > (bSize - 2) )       /* Ensure there's space for next char.    */
       {
       bSize += BUFR_INC;
-      bufr   = Realloc( bufr, bSize );
+      bufr   = realloc_array( bufr, char, bSize );
       if( NULL == bufr )
         {
         rprintf(FERROR, "%s Memory re-allocation failure.", func) ;
@@ -366,7 +366,7 @@ static BOOL Parameter( FILE *InFile, BOOL (*pfunc)(char *, char *), int c )
     if( i > (bSize - 2) )       /* Make sure there's enough room. */
       {
       bSize += BUFR_INC;
-      bufr   = Realloc( bufr, bSize );
+      bufr   = realloc_array( bufr, char, bSize );
       if( NULL == bufr )
         {
         rprintf(FERROR, "%s Memory re-allocation failure.", func) ;
@@ -386,7 +386,7 @@ static BOOL Parameter( FILE *InFile, BOOL (*pfunc)(char *, char *), int c )
           c = 0;
         else
           {
-          for( end = i; (end >= 0) && isspace(bufr[end]); end-- )
+          for( end = i; (end >= 0) && isspace(((unsigned char *) bufr)[end]); end-- )
             ;
           c = getc( InFile );
           }
@@ -491,8 +491,8 @@ static FILE *OpenConfFile( char *FileName )
   OpenedFile = fopen( FileName, "r" );
   if( NULL == OpenedFile )
     {
-    rprintf(FERROR,"%s Unable to open configuration file \"%s\":\n\t%s\n",
-	    func, FileName, strerror(errno));
+    rsyserr(FERROR, errno, "rsync: unable to open configuration file \"%s\"",
+	    safe_fname(FileName));
     }
 
   return( OpenedFile );
@@ -530,7 +530,7 @@ BOOL pm_process( char *FileName,
   else                                        /* If we don't have a buffer   */
     {                                         /* allocate one, then parse,   */
     bSize = BUFR_INC;                         /* then free.                  */
-    bufr = (char *)malloc( bSize );
+    bufr = new_array( char, bSize );
     if( NULL == bufr )
       {
       rprintf(FERROR,"%s memory allocation failure.\n", func);

pipe.c

@@ -0,0 +1,165 @@
+/*  -*- 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"
+
+extern int am_sender;
+extern int am_server;
+extern int blocking_io;
+extern int orig_umask;
+extern int write_batch;
+extern int filesfrom_fd;
+
+/**
+ * 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];
+
+	if (verbose >= 2) {
+		print_child_argv(command);
+	}
+
+	if (fd_pair(to_child_pipe) < 0 || fd_pair(from_child_pipe) < 0) {
+		rsyserr(FERROR, errno, "pipe");
+		exit_cleanup(RERR_IPC);
+	}
+
+	pid = do_fork();
+	if (pid == -1) {
+		rsyserr(FERROR, errno, "fork");
+		exit_cleanup(RERR_IPC);
+	}
+
+	if (pid == 0) {
+		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) {
+			rsyserr(FERROR, errno, "Failed to dup/close");
+			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 > 0)
+			set_blocking(STDOUT_FILENO);
+		execvp(command[0], command);
+		rsyserr(FERROR, errno, "Failed to exec %s",
+			safe_fname(command[0]));
+		exit_cleanup(RERR_IPC);
+	}
+
+	if (close(from_child_pipe[1]) < 0 || close(to_child_pipe[0]) < 0) {
+		rsyserr(FERROR, errno, "Failed to close");
+		exit_cleanup(RERR_IPC);
+	}
+
+	*f_in = from_child_pipe[0];
+	*f_out = to_child_pipe[1];
+
+	return pid;
+}
+
+/* This function forks a child which calls child_main().  First,
+ * however, it has to establish communication paths to and from the
+ * newborn child.  It creates two socket pairs -- one for writing to
+ * the child (from the parent) and one for reading from the child
+ * (writing to the parent).  Since that's four socket ends, each
+ * process has to close the two ends it doesn't need.  The remaining
+ * two socket ends are retained for reading and writing.  In the
+ * child, the STDIN and STDOUT file descriptors refer to these
+ * sockets.  In the parent, the function arguments f_in and f_out are
+ * set to refer to these sockets. */
+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];
+
+	if (fd_pair(to_child_pipe) < 0 ||
+	    fd_pair(from_child_pipe) < 0) {
+		rsyserr(FERROR, errno, "pipe");
+		exit_cleanup(RERR_IPC);
+	}
+
+	pid = do_fork();
+	if (pid == -1) {
+		rsyserr(FERROR, errno, "fork");
+		exit_cleanup(RERR_IPC);
+	}
+
+	if (pid == 0) {
+		am_sender = !am_sender;
+		am_server = 1;
+
+		/* The server side never writes the batch, even if it
+		 * is local (it makes the logic easier elsewhere). */
+		write_batch = 0;
+
+		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) {
+			rsyserr(FERROR, errno, "Failed to dup/close");
+			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) {
+		rsyserr(FERROR, errno, "Failed to close");
+		exit_cleanup(RERR_IPC);
+	}
+
+	*f_in = from_child_pipe[0];
+	*f_out = to_child_pipe[1];
+
+	return pid;
+}

popt/.cvsignore

@@ -0,0 +1,7 @@
+ID
+Makefile
+config.cache
+config.h
+config.log
+config.status
+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 unsigned 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 * 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,184 @@
+/** \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, unsigned 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 unsigned char * file, * chptr, * end;
+    unsigned char * buf;
+/*@dependent@*/ unsigned 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@*/ 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@*/ UNUSED(enum poptCallbackReason foo),
+		struct poptOption * key, 
+		/*@unused@*/ UNUSED(const char * arg), /*@unused@*/ 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 *
+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 *
+getArgDescrip(const struct poptOption * opt,
+		/*@-paramuse@*/		/* FIX: wazzup? */
+		/*@null@*/ UNUSED(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@*/ UNUSED(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 unsigned char * help = D_(translation_domain, opt->descrip);
+    const char * argDescrip = getArgDescrip(opt, translation_domain);
+    int helpLength;
+    unsigned char * defs = NULL;
+    unsigned 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 unsigned 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@*/ 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@*/ 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 unsigned char * s, int * argcPtr, const char *** argvPtr)
+{
+    const unsigned char * src;
+    unsigned 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,82 @@
+#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
+
+#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
+
+#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__) */
+
+#define UNUSED(x) x __attribute__((__unused__))
+
+#include "popt.h"

progress.c

@@ -0,0 +1,176 @@
+/*  -*- 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"
+
+extern struct stats stats;
+extern int am_server;
+
+#define PROGRESS_HISTORY_SECS 5
+
+#ifdef GETPGRP_VOID
+#define GETPGRP_ARG
+#else
+#define GETPGRP_ARG 0
+#endif
+
+struct progress_history {
+	struct timeval time;
+	OFF_T ofs;
+};
+
+static struct progress_history ph_start;
+static struct progress_history ph_list[PROGRESS_HISTORY_SECS];
+static int newest_hpos, oldest_hpos;
+
+static unsigned long msdiff(struct timeval *t1, struct timeval *t2)
+{
+	return (t2->tv_sec - t1->tv_sec) * 1000L
+	     + (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)
+{
+	char eol[256];
+	const char *units;
+	int pct = ofs == size ? 100 : (int) (100.0 * ofs / size);
+	unsigned long diff;
+	double rate, remain;
+	int remain_h, remain_m, remain_s;
+
+	if (is_last) {
+		/* Compute stats based on the starting info. */
+		if (!ph_start.time.tv_sec
+		    || !(diff = msdiff(&ph_start.time, now)))
+			diff = 1;
+		rate = (double) (ofs - ph_start.ofs) * 1000.0 / diff / 1024.0;
+		/* Switch to total time taken for our last update. */
+		remain = (double) diff / 1000.0;
+	} else {
+		/* Compute stats based on recent progress. */
+		if (!(diff = msdiff(&ph_list[oldest_hpos].time, now)))
+			diff = 1;
+		rate = (double) (ofs - ph_list[oldest_hpos].ofs) * 1000.0
+		     / diff / 1024.0;
+		remain = rate ? (double) (size - ofs) / rate / 1000.0 : 0.0;
+	}
+
+	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);
+
+	if (is_last) {
+		snprintf(eol, sizeof eol, "  (%d, %.1f%% of %d)\n",
+			stats.num_transferred_files,
+			(float)((stats.current_file_index+1) * 100)
+				/ stats.num_files,
+			stats.num_files);
+	} else
+		strcpy(eol, "\r");
+	rprintf(FINFO, "%12.0f %3d%% %7.2f%s %4d:%02d:%02d%s",
+		(double) ofs, pct, rate, units,
+		remain_h, remain_m, remain_s, eol);
+}
+
+void end_progress(OFF_T size)
+{
+	if (!am_server) {
+		struct timeval now;
+		gettimeofday(&now, NULL);
+		rprint_progress(size, size, &now, True);
+	}
+	memset(&ph_start, 0, sizeof ph_start);
+}
+
+void show_progress(OFF_T ofs, OFF_T size)
+{
+	struct timeval now;
+#if defined HAVE_GETPGRP && defined HAVE_TCGETPGRP
+	static pid_t pgrp = -1;
+	pid_t tc_pgrp;
+#endif
+
+	if (am_server)
+		return;
+
+#if defined HAVE_GETPGRP && defined HAVE_TCGETPGRP
+	if (pgrp == -1)
+		pgrp = getpgrp(GETPGRP_ARG);
+#endif
+
+	gettimeofday(&now, NULL);
+
+	if (!ph_start.time.tv_sec) {
+		int i;
+
+		/* Try to guess the real starting time when the sender started
+		 * to send us data by using the time we last received some data
+		 * in the last file (if it was recent enough). */
+		if (msdiff(&ph_list[newest_hpos].time, &now) <= 1500) {
+			ph_start.time = ph_list[newest_hpos].time;
+			ph_start.ofs = 0;
+		} else {
+			ph_start.time.tv_sec = now.tv_sec;
+			ph_start.time.tv_usec = now.tv_usec;
+			ph_start.ofs = ofs;
+		}
+
+		for (i = 0; i < PROGRESS_HISTORY_SECS; i++)
+			ph_list[i] = ph_start;
+	}
+	else {
+		if (msdiff(&ph_list[newest_hpos].time, &now) < 1000)
+			return;
+
+		newest_hpos = oldest_hpos;
+		oldest_hpos = (oldest_hpos + 1) % PROGRESS_HISTORY_SECS;
+		ph_list[newest_hpos].time.tv_sec = now.tv_sec;
+		ph_list[newest_hpos].time.tv_usec = now.tv_usec;
+		ph_list[newest_hpos].ofs = ofs;
+	}
+
+#if defined HAVE_GETPGRP && defined HAVE_TCGETPGRP
+	tc_pgrp = tcgetpgrp(STDOUT_FILENO);
+	if (tc_pgrp != pgrp && tc_pgrp != -1)
+		return;
+#endif
+
+	rprint_progress(ofs, size, &now, False);
+}

rsync.c

@@ -1,17 +1,17 @@
-/* 
+/*
    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.
@@ -24,12 +24,20 @@
 
 extern int verbose;
 extern int dry_run;
+extern int daemon_log_format_has_i;
 extern int preserve_times;
+extern int omit_dir_times;
 extern int am_root;
+extern int am_server;
+extern int am_sender;
+extern int am_generator;
+extern int am_starting_up;
 extern int preserve_uid;
 extern int preserve_gid;
-extern int preserve_perms;
+extern int inplace;
+extern int keep_dirlinks;
 extern int make_backups;
+extern struct stats stats;
 
 
 /*
@@ -42,184 +50,100 @@ void free_sums(struct sum_struct *s)
 }
 
 
-/*
- * delete a file or directory. If force_delet is set then delete 
- * recursively 
- */
-int delete_file(char *fname)
-{
-	DIR *d;
-	struct dirent *di;
-	char buf[MAXPATHLEN];
-	extern int force_delete;
-	STRUCT_STAT st;
-	int ret;
-	extern int recurse;
-
-#if SUPPORT_LINKS
-	ret = do_lstat(fname, &st);
-#else
-	ret = do_stat(fname, &st);
-#endif
-	if (ret) {
-		rprintf(FERROR,"stat(%s) : %s\n", fname, strerror(errno));
-		return -1;
-	}
-
-	if (!S_ISDIR(st.st_mode)) {
-		if (robust_unlink(fname) == 0 || errno == ENOENT) return 0;
-		rprintf(FERROR,"unlink(%s) : %s\n", fname, strerror(errno));
-		return -1;
-	}
-
-	if (do_rmdir(fname) == 0 || errno == ENOENT) return 0;
-	if (!force_delete || !recurse || 
-	    (errno != ENOTEMPTY && errno != EEXIST)) {
-		rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
-		return -1;
-	}
-
-	/* now we do a recsursive delete on the directory ... */
-	d = opendir(fname);
-	if (!d) {
-		rprintf(FERROR,"opendir(%s): %s\n",
-			fname,strerror(errno));
-		return -1;
-	}
-
-	for (di=readdir(d); di; di=readdir(d)) {
-		char *dname = d_name(di);
-		if (strcmp(dname,".")==0 ||
-		    strcmp(dname,"..")==0)
-			continue;
-		slprintf(buf, sizeof(buf), "%s/%s", fname, dname);
-		if (verbose > 0)
-			rprintf(FINFO,"deleting %s\n", buf);
-		if (delete_file(buf) != 0) {
-			closedir(d);
-			return -1;
-		}
-	}	
-
-	closedir(d);
-	
-	if (do_rmdir(fname) != 0) {
-		rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
-		return -1;
-	}
-
-	return 0;
-}
-
-static int is_in_group(gid_t gid)
-{
-#ifdef GETGROUPS_T
-	static gid_t last_in = (gid_t) -2, last_out;
-	static int ngroups = -2;
-	static GETGROUPS_T *gidset;
-	int n;
-
-	if (gid == last_in)
-		return last_out;
-	if (ngroups < -1) {
-		/* treat failure (-1) as if not member of any group */
-		ngroups = getgroups(0, 0);
-		if (ngroups > 0) {
-			gidset = (GETGROUPS_T *) malloc(ngroups * sizeof(GETGROUPS_T));
-			ngroups = getgroups(ngroups, gidset);
-		}
-	}
-
-	last_in = gid;
-	last_out = 0;
-	for (n = 0; n < ngroups; n++) {
-		if (gidset[n] == gid) {
-			last_out = 1;
-			break;
-		}
-	}
-	return last_out;
-
-#else
-	return 0;
-#endif
-}
-
 int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
-	      int report)
+	      int flags)
 {
 	int updated = 0;
 	STRUCT_STAT st2;
 	int change_uid, change_gid;
 
-	if (dry_run) return 0;
-
 	if (!st) {
-		if (link_stat(fname,&st2) != 0) {
-			rprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
+		if (dry_run)
+			return 1;
+		if (link_stat(fname, &st2, 0) < 0) {
+			rsyserr(FERROR, errno, "stat %s failed",
+				full_fname(fname));
 			return 0;
 		}
 		st = &st2;
 	}
 
-	if (preserve_times && !S_ISLNK(st->st_mode) &&
-	    st->st_mtime != file->modtime) {
-		/* don't complain about not setting times on directories
-		   because some filesystems can't do it */
-		if (set_modtime(fname,file->modtime) != 0 &&
-		    !S_ISDIR(st->st_mode)) {
-			rprintf(FERROR,"failed to set times on %s : %s\n",
-				fname,strerror(errno));
+	if (!preserve_times || S_ISLNK(st->st_mode)
+	 || (S_ISDIR(st->st_mode) && omit_dir_times))
+		flags |= PERMS_SKIP_MTIME;
+	if (!(flags & PERMS_SKIP_MTIME)
+	    && cmp_modtime(st->st_mtime, file->modtime) != 0) {
+		if (set_modtime(fname,file->modtime) != 0) {
+			rsyserr(FERROR, errno, "failed to set times on %s",
+				full_fname(fname));
 			return 0;
-		} else {
-			updated = 1;
 		}
+		updated = 1;
 	}
 
 	change_uid = am_root && preserve_uid && st->st_uid != file->uid;
-	change_gid = preserve_gid && file->gid != (gid_t) -1 && \
-				st->st_gid != file->gid;
-	if (change_gid && !am_root) {
-		/* enforce bsd-style group semantics: non-root can only
-		    change to groups that the user is a member of */
-		change_gid = is_in_group(file->gid);
-	}
+	change_gid = preserve_gid && file->gid != GID_NONE
+		&& st->st_gid != file->gid;
+#if !defined HAVE_LCHOWN && !defined CHOWN_MODIFIES_SYMLINK
+	if (S_ISLNK(st->st_mode))
+		;
+	else
+#endif
 	if (change_uid || change_gid) {
+		if (verbose > 2) {
+			if (change_uid) {
+				rprintf(FINFO,
+					"set uid of %s from %ld to %ld\n",
+					safe_fname(fname),
+					(long)st->st_uid, (long)file->uid);
+			}
+			if (change_gid) {
+				rprintf(FINFO,
+					"set gid of %s from %ld to %ld\n",
+					safe_fname(fname),
+					(long)st->st_gid, (long)file->gid);
+			}
+		}
 		if (do_lchown(fname,
-			      change_uid?file->uid:st->st_uid,
-			      change_gid?file->gid:st->st_gid) != 0) {
+		    change_uid ? file->uid : st->st_uid,
+		    change_gid ? file->gid : st->st_gid) != 0) {
 			/* shouldn't have attempted to change uid or gid
-			     unless have the privilege */
-			rprintf(FERROR,"chown %s : %s\n", fname,strerror(errno));
+			 * unless have the privilege */
+			rsyserr(FERROR, errno, "%s %s failed",
+			    change_uid ? "chown" : "chgrp",
+			    full_fname(fname));
 			return 0;
 		}
 		/* a lchown had been done - we have to re-stat if the
-                   destination had the setuid or setgid bits set due
-                   to the side effect of the chown call */
+		 * destination had the setuid or setgid bits set due
+		 * to the side effect of the chown call */
 		if (st->st_mode & (S_ISUID | S_ISGID)) {
-			link_stat(fname, st);
+			link_stat(fname, st,
+				  keep_dirlinks && S_ISDIR(st->st_mode));
 		}
 		updated = 1;
 	}
 
 #ifdef HAVE_CHMOD
 	if (!S_ISLNK(st->st_mode)) {
-		if (st->st_mode != file->mode) {
+		if ((st->st_mode & CHMOD_BITS) != (file->mode & CHMOD_BITS)) {
 			updated = 1;
-			if (do_chmod(fname,file->mode) != 0) {
-				rprintf(FERROR,"failed to set permissions on %s : %s\n",
-					fname,strerror(errno));
+			if (do_chmod(fname,(file->mode & CHMOD_BITS)) != 0) {
+				rsyserr(FERROR, errno, "failed to set permissions on %s",
+					full_fname(fname));
 				return 0;
 			}
 		}
 	}
 #endif
-    
-	if (verbose > 1 && report) {
+
+	if (verbose > 1 && flags & PERMS_REPORT) {
+		enum logcode code = daemon_log_format_has_i || dry_run
+				  ? FCLIENT : FINFO;
 		if (updated)
-			rprintf(FINFO,"%s\n",fname);
+			rprintf(code, "%s\n", safe_fname(fname));
 		else
-			rprintf(FINFO,"%s is uptodate\n",fname);
+			rprintf(code, "%s is uptodate\n", safe_fname(fname));
 	}
 	return updated;
 }
@@ -227,34 +151,62 @@ int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
 
 void sig_int(void)
 {
+	/* KLUGE: if the user hits Ctrl-C while ssh is prompting
+	 * for a password, then our cleanup's sending of a SIGUSR1
+	 * signal to all our children may kill ssh before it has a
+	 * chance to restore the tty settings (i.e. turn echo back
+	 * on).  By sleeping for a short time, ssh gets a bigger
+	 * chance to do the right thing.  If child processes are
+	 * not ssh waiting for a password, then this tiny delay
+	 * shouldn't hurt anything. */
+	msleep(400);
 	exit_cleanup(RERR_SIGNAL);
 }
 
 
 /* finish off a file transfer, renaming the file and setting the permissions
    and ownership */
-void finish_transfer(char *fname, char *fnametmp, struct file_struct *file)
+void finish_transfer(char *fname, char *fnametmp, struct file_struct *file,
+		     int ok_to_set_time, int overwriting_basis)
 {
-	if (make_backups && !make_backup(fname))
+	int ret;
+
+	if (inplace) {
+		if (verbose > 2)
+			rprintf(FINFO, "finishing %s\n", safe_fname(fname));
+		goto do_set_perms;
+	}
+
+	if (make_backups && overwriting_basis && !make_backup(fname))
 		return;
 
+	/* Change permissions before putting the file into place. */
+	set_perms(fnametmp, file, NULL, ok_to_set_time ? 0 : PERMS_SKIP_MTIME);
+
 	/* move tmp file over real file */
-	if (robust_rename(fnametmp,fname) != 0) {
-		if (errno == EXDEV) {
-			/* rename failed on cross-filesystem link.  
-			   Copy the file instead. */
-			if (copy_file(fnametmp,fname, file->mode & INITACCESSPERMS)) {
-				rprintf(FERROR,"copy %s -> %s : %s\n",
-					fnametmp,fname,strerror(errno));
-			} else {
-				set_perms(fname,file,NULL,0);
-			}
-		} else {
-			rprintf(FERROR,"rename %s -> %s : %s\n",
-				fnametmp,fname,strerror(errno));
-		}
-		do_unlink(fnametmp);
-	} else {
-		set_perms(fname,file,NULL,0);
+	if (verbose > 2) {
+		rprintf(FINFO, "renaming %s to %s\n",
+			safe_fname(fnametmp), safe_fname(fname));
 	}
+	ret = robust_rename(fnametmp, fname, file->mode & INITACCESSPERMS);
+	if (ret < 0) {
+		rsyserr(FERROR, errno, "%s %s -> \"%s\"",
+		    ret == -2 ? "copy" : "rename",
+		    full_fname(fnametmp), safe_fname(fname));
+		do_unlink(fnametmp);
+		return;
+	}
+	if (ret == 0) {
+		/* The file was moved into place (not copied), so it's done. */
+		return;
+	}
+    do_set_perms:
+	set_perms(fname, file, NULL, ok_to_set_time ? 0 : PERMS_SKIP_MTIME);
+}
+
+const char *who_am_i(void)
+{
+	if (am_starting_up)
+		return am_server ? "server" : "client";
+	return am_sender ? "sender" : am_generator ? "generator" : "receiver";
 }

rsync.h

@@ -1,30 +1,34 @@
-/* 
-   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
    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.
 */
 
+
 #define False 0
 #define True 1
 
 #define BLOCK_SIZE 700
 #define RSYNC_RSH_ENV "RSYNC_RSH"
+#define RSYNC_RSH_IO_ENV "RSYNC_RSH_IO"
 
 #define RSYNC_NAME "rsync"
-#define RSYNCD_CONF "/etc/rsyncd.conf"
+/* RSYNCD_SYSCONF is now set in config.h */
+#define RSYNCD_USERCONF "rsyncd.conf"
 
 #define DEFAULT_LOCK_FILE "/var/run/rsyncd.lock"
 #define URL_PREFIX "rsync://"
@@ -35,21 +39,55 @@
    incompatible with older versions :-( */
 #define CHAR_OFFSET 0
 
+/* These flags are only used during the flist transfer. */
 
-#define FLAG_DELETE (1<<0)
-#define SAME_MODE (1<<1)
-#define SAME_RDEV (1<<2)
-#define SAME_UID (1<<3)
-#define SAME_GID (1<<4)
-#define SAME_DIR (1<<5)
-#define SAME_NAME SAME_DIR
-#define LONG_NAME (1<<6)
-#define SAME_TIME (1<<7)
+#define XMIT_TOP_DIR (1<<0)
+#define XMIT_SAME_MODE (1<<1)
+#define XMIT_EXTENDED_FLAGS (1<<2)
+#define XMIT_SAME_RDEV_pre28 XMIT_EXTENDED_FLAGS /* Only in protocols < 28 */
+#define XMIT_SAME_UID (1<<3)
+#define XMIT_SAME_GID (1<<4)
+#define XMIT_SAME_NAME (1<<5)
+#define XMIT_LONG_NAME (1<<6)
+#define XMIT_SAME_TIME (1<<7)
+#define XMIT_SAME_RDEV_MAJOR (1<<8)
+#define XMIT_HAS_IDEV_DATA (1<<9)
+#define XMIT_SAME_DEV (1<<10)
+#define XMIT_RDEV_MINOR_IS_SMALL (1<<11)
+
+/* These flags are used in the live flist data. */
+
+#define FLAG_TOP_DIR (1<<0)
+#define FLAG_HLINK_EOL (1<<1)	/* receiver/generator */
+#define FLAG_MOUNT_POINT (1<<2)	/* sender */
+#define FLAG_NO_FUZZY (1<<2)	/* generator */
+#define FLAG_DEL_HERE (1<<3)	/* receiver/generator */
+#define FLAG_SENT (1<<3)	/* sender */
+#define FLAG_HLINK_TOL (1<<4)	/* receiver/generator */
 
 /* update this if you make incompatible changes */
-#define PROTOCOL_VERSION 24
-#define MIN_PROTOCOL_VERSION 15
-#define MAX_PROTOCOL_VERSION 30
+#define PROTOCOL_VERSION 29
+
+/* 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.
+ *
+ * Interoperation with old but supported protocol versions
+ * should cause a warning to be printed.  At a future date
+ * the old protocol will become the minimum and
+ * compatibility code removed.
+ *
+ * There are two possible explanations for the limit at
+ * MAX_PROTOCOL_VERSION: 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 MIN_PROTOCL_VERSION and
+ * MAX_PROTOCOL_VERSION. */
+
+#define MIN_PROTOCOL_VERSION 20
+#define OLD_PROTOCOL_VERSION 25
+#define MAX_PROTOCOL_VERSION 40
 
 #define RSYNC_PORT 873
 
@@ -58,57 +96,133 @@
 #define CHUNK_SIZE (32*1024)
 #define MAX_MAP_SIZE (256*1024)
 #define IO_BUFFER_SIZE (4092)
+#define MAX_BLOCK_SIZE ((int32)1 << 29)
+
+#define IOERR_GENERAL	(1<<0) /* For backward compatibility, this must == 1 */
+#define IOERR_VANISHED	(1<<1)
+#define IOERR_DEL_LIMIT (1<<2)
 
 #define MAX_ARGS 1000
 
+#define MAX_BASIS_DIRS 20
+
 #define MPLEX_BASE 7
 
-enum logcode {FNONE=0, FERROR=1, FINFO=2, FLOG=3};
+#define NO_FILTERS	0
+#define SERVER_FILTERS	1
+#define ALL_FILTERS	2
+
+#define XFLG_FATAL_ERRORS	(1<<0)
+#define XFLG_OLD_PREFIXES	(1<<1)
+#define XFLG_ANCHORED2ABS	(1<<2)
+
+#define PERMS_REPORT		(1<<0)
+#define PERMS_SKIP_MTIME	(1<<1)
+
+#define FULL_FLUSH	1
+#define NORMAL_FLUSH	0
+
+#define PDIR_CREATE	1
+#define PDIR_DELETE	0
+
+/* Note: 0x00 - 0x7F are used for basis_dir[] indexes! */
+#define FNAMECMP_BASIS_DIR_LOW	0x00 /* Must remain 0! */
+#define FNAMECMP_BASIS_DIR_HIGH 0x7F
+#define FNAMECMP_FNAME		0x80
+#define FNAMECMP_PARTIAL_DIR	0x81
+#define FNAMECMP_BACKUP 	0x82
+#define FNAMECMP_FUZZY		0x83
+
+/* For calling delete_file() */
+#define DEL_NO_RECURSE		(1<<1)
+#define DEL_FORCE_RECURSE	(1<<2) /* recurse even w/o --force */
+#define DEL_TERSE		(1<<3)
+
+/* For use by the itemize_changes code */
+#define ITEM_DUMMY_BIT (1<<0)
+#define ITEM_REPORT_CHECKSUM (1<<1)
+#define ITEM_REPORT_SIZE (1<<2)
+#define ITEM_REPORT_TIME (1<<3)
+#define ITEM_REPORT_PERMS (1<<4)
+#define ITEM_REPORT_OWNER (1<<5)
+#define ITEM_REPORT_GROUP (1<<6)
+#define ITEM_REPORT_XATTRS (1<<7)
+#define ITEM_BASIS_TYPE_FOLLOWS (1<<11)
+#define ITEM_XNAME_FOLLOWS (1<<12)
+#define ITEM_IS_NEW (1<<13)
+#define ITEM_LOCAL_CHANGE (1<<14)
+#define ITEM_TRANSFER (1<<15)
+/* These are outside the range of the transmitted flags. */
+#define ITEM_NO_DEST_AND_NO_UPDATE (1<<16) /* used by itemize() */
+#define ITEM_MISSING_DATA (1<<16)	   /* used by log_formatted() */
+#define ITEM_DELETED (1<<17)		   /* used by log_formatted() */
+
+#define SIGNIFICANT_ITEM_FLAGS (~(\
+	ITEM_BASIS_TYPE_FOLLOWS | ITEM_XNAME_FOLLOWS | ITEM_LOCAL_CHANGE))
+
+
+/* Log-message categories.  FLOG and FCLIENT are only used on the daemon
+ * side for custom logging -- they don't get sent over the socket. */
+enum logcode { FERROR=1, FINFO=2, FLOG=3, FCLIENT=4 };
+
+/* Messages types that are sent over the message channel.  The logcode
+ * values must all be present here with identical numbers. */
+enum msgcode {
+	MSG_DATA=0,	/* raw data on the multiplexed stream */
+	MSG_ERROR=FERROR, MSG_INFO=FINFO, /* remote logging */
+	MSG_LOG=FLOG, MSG_FCLIENT=FCLIENT, /* sibling logging */
+	MSG_REDO=9,	/* reprocess indicated flist index */
+	MSG_SUCCESS=100,/* successfully updated indicated flist index */
+	MSG_DELETED=101,/* successfully deleted a file on receiving side */
+	MSG_DONE=86	/* current phase is done */
+};
 
 #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. */
 
-#include <sys/types.h>
-
-#ifdef HAVE_GETOPT_LONG
-#include <getopt.h>
-#else
-#include "lib/getopt.h"
-#endif
-
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
 #include <stdio.h>
-#include <stddef.h>
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
 
 #ifdef HAVE_SYS_PARAM_H
 #include <sys/param.h>
 #endif
 
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
+#if defined HAVE_MALLOC_H && (defined HAVE_MALLINFO || !defined HAVE_STDLIB_H)
+#include <malloc.h>
 #endif
 
 #ifdef HAVE_SYS_SOCKET_H
 #include <sys/socket.h>
 #endif
 
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-
-#ifdef HAVE_MALLOC_H
-#include <malloc.h>
-#endif
-
 #ifdef TIME_WITH_SYS_TIME
 #include <sys/time.h>
 #include <time.h>
@@ -128,8 +242,6 @@ enum logcode {FNONE=0, FERROR=1, FINFO=2, FLOG=3};
 #endif
 #endif
 
-#include <sys/stat.h>
-
 #ifdef HAVE_SYS_IOCTL_H
 #include <sys/ioctl.h>
 #endif
@@ -165,12 +277,6 @@ enum logcode {FNONE=0, FERROR=1, FINFO=2, FLOG=3};
 #endif
 #endif
 
-#ifdef HAVE_FNMATCH
-#include <fnmatch.h>
-#else
-#include "lib/fnmatch.h"
-#endif
-
 #ifdef HAVE_GLOB_H
 #include <glob.h>
 #endif
@@ -186,25 +292,37 @@ enum logcode {FNONE=0, FERROR=1, FINFO=2, FLOG=3};
 #include <syslog.h>
 #include <sys/file.h>
 
-#if HAVE_DIRENT_H
+#ifdef HAVE_DIRENT_H
 # include <dirent.h>
 #else
 # define dirent direct
-# if HAVE_SYS_NDIR_H
+# ifdef HAVE_SYS_NDIR_H
 #  include <sys/ndir.h>
 # endif
-# if HAVE_SYS_DIR_H
+# ifdef HAVE_SYS_DIR_H
 #  include <sys/dir.h>
 # endif
-# if HAVE_NDIR_H
+# ifdef HAVE_NDIR_H
 #  include <ndir.h>
 # endif
 #endif
 
+#ifdef MAJOR_IN_MKDEV
+#include <sys/mkdev.h>
+# if !defined makedev && (defined mkdev || defined _WIN32 || defined __WIN32__)
+#  define makedev mkdev
+# endif
+#elif defined MAJOR_IN_SYSMACROS
+#include <sys/sysmacros.h>
+#endif
+
 #ifdef HAVE_COMPAT_H
 #include <compat.h>
 #endif
 
+#include <assert.h>
+
+#include "lib/pool_alloc.h"
 
 #define BOOL int
 
@@ -212,56 +330,117 @@ enum logcode {FNONE=0, FERROR=1, FINFO=2, FLOG=3};
 #define uchar unsigned char
 #endif
 
-#if HAVE_UNSIGNED_CHAR
+#ifdef SIGNED_CHAR_OK
 #define schar signed char
 #else
 #define schar char
 #endif
 
+/* Find a variable that is either exactly 32-bits or longer.
+ * If some code depends on 32-bit truncation, it will need to
+ * take special action in a "#if SIZEOF_INT32 > 4" section. */
 #ifndef int32
-#if (SIZEOF_INT == 4)
-#define int32 int
-#elif (SIZEOF_LONG == 4)
-#define int32 long
-#elif (SIZEOF_SHORT == 4)
-#define int32 short
+#if SIZEOF_INT == 4
+# define int32 int
+# define SIZEOF_INT32 4
+#elif SIZEOF_LONG == 4
+# define int32 long
+# define SIZEOF_INT32 4
+#elif SIZEOF_SHORT == 4
+# define int32 short
+# define SIZEOF_INT32 4
+#elif SIZEOF_INT > 4
+# define int32 int
+# define SIZEOF_INT32 SIZEOF_INT
+#elif SIZEOF_LONG > 4
+# define int32 long
+# define SIZEOF_INT32 SIZEOF_LONG
 #else
-/* I hope this works */
-#define int32 int
-#define LARGE_INT32
+# error Could not find a 32-bit integer variable
 #endif
+#else
+# define SIZEOF_INT32 4
 #endif
 
 #ifndef uint32
 #define uint32 unsigned int32
 #endif
 
-#if HAVE_OFF64_T
-#define OFF_T off64_t
-#define STRUCT_STAT struct stat64
-#else
+#if SIZEOF_OFF_T == 8 || !SIZEOF_OFF64_T || !defined HAVE_STRUCT_STAT64
 #define OFF_T off_t
 #define STRUCT_STAT struct stat
+#else
+#define OFF_T off64_t
+#define STRUCT_STAT struct stat64
+#define USE_STAT64_FUNCS 1
 #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
+/* CAVEAT: on some systems, int64 will really be a 32-bit integer IFF
+ * that's the maximum size the file system can handle and there is no
+ * 64-bit type available.  The rsync source must therefore take steps
+ * to ensure that any code that really requires a 64-bit integer has
+ * it (e.g. the checksum code uses two 32-bit integers for its 64-bit
+ * counter). */
+#if SIZEOF_OFF64_T == 8
+# define int64 off64_t
+# define SIZEOF_INT64 8
+#elif SIZEOF_LONG == 8
+# define int64 long
+# define SIZEOF_INT64 8
+#elif SIZEOF_INT == 8
+# define int64 int
+# define SIZEOF_INT64 8
+#elif SIZEOF_LONG_LONG == 8
+# define int64 long long
+# define SIZEOF_INT64 8
+#elif SIZEOF_OFF_T == 8
+# define int64 off_t
+# define SIZEOF_INT64 8
+#elif SIZEOF_INT > 8
+# define int64 int
+# define SIZEOF_INT64 SIZEOF_INT
+#elif SIZEOF_LONG > 8
+# define int64 long
+# define SIZEOF_INT64 SIZEOF_LONG
+#elif SIZEOF_LONG_LONG > 8
+# define int64 long long
+# define SIZEOF_INT64 SIZEOF_LONG_LONG
 #else
-#define int64 off_t
-#define NO_INT64
+/* As long as it gets... */
+# define int64 off_t
+# define SIZEOF_INT64 SIZEOF_OFF_T
 #endif
 
-#if HAVE_SHORT_INO_T
-#define INO_T uint32
-#else
-#define INO_T ino_t
-#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: I don't think the code in flist.c has ever worked on a system
+ * where dev_t is a struct.
+ */
+
+struct idev {
+	int64 inode;
+	int64 dev;
+};
 
 #ifndef MIN
 #define MIN(a,b) ((a)<(b)?(a):(b))
@@ -278,69 +457,164 @@ enum logcode {FNONE=0, FERROR=1, FINFO=2, FLOG=3};
 /* the length of the md4 checksum */
 #define MD4_SUM_LENGTH 16
 #define SUM_LENGTH 16
+#define SHORT_SUM_LENGTH 2
+#define BLOCKSUM_BIAS 10
 
 #ifndef MAXPATHLEN
 #define MAXPATHLEN 1024
 #endif
 
+#ifndef NAME_MAX
+#define NAME_MAX 255
+#endif
+
 #ifndef INADDR_NONE
 #define INADDR_NONE 0xffffffff
 #endif
 
+#ifndef IN_LOOPBACKNET
+#define IN_LOOPBACKNET 127
+#endif
+
+#define GID_NONE ((gid_t)-1)
+
+#define HL_CHECK_MASTER	0
+#define HL_SKIP		1
+
+struct hlink {
+	int next;
+	int hlindex;
+};
+
+#define F_DEV	link_u.idev->dev
+#define F_INODE	link_u.idev->inode
+
+#define F_HLINDEX link_u.links->hlindex
+#define F_NEXT	link_u.links->next
+
 struct file_struct {
-	unsigned flags;
-	time_t modtime;
+	union {
+		dev_t rdev;	/* The device number, if this is a device */
+		char *sum;	/* Only a normal file can have a checksum */
+		char *link;	/* Points to symlink string, if a symlink */
+	} u;
 	OFF_T length;
-	mode_t mode;
-	INO_T inode;
-	dev_t dev;
-	dev_t rdev;
+	char *basename;		/* The current item's name (AKA filename) */
+	char *dirname;		/* The directory info inside the transfer */
+	union {
+		char *root;	/* Sender-side dir info outside transfer */
+		int depth;	/* Receiver-side directory depth info */
+	} dir;
+	union {
+		struct idev *idev;
+		struct hlink *links;
+	} link_u;
+	time_t modtime;
 	uid_t uid;
 	gid_t gid;
-	char *basename;
-	char *dirname;
-	char *basedir;
-	char *link;
-	char *sum;
+	mode_t mode;
+	uchar flags;	/* this item MUST remain last */
 };
 
+/*
+ * Start the flist array at FLIST_START entries and grow it
+ * by doubling until FLIST_LINEAR then grow by FLIST_LINEAR
+ */
+#define FLIST_START	(32 * 1024)
+#define FLIST_LINEAR	(FLIST_START * 512)
+
+/*
+ * Extent size for allocation pools A minimum size of 128KB
+ * is needed to mmap them so that freeing will release the
+ * space to the OS.
+ *
+ * Larger sizes reduce leftover fragments and speed free calls
+ * (when they happen) Smaller sizes increase the chance of
+ * freed allocations freeing whole extents.
+ */
+#define FILE_EXTENT	(256 * 1024)
+#define HLINK_EXTENT	(128 * 1024)
+
+#define WITH_HLINK	1
+#define WITHOUT_HLINK	0
 
 struct file_list {
+	struct file_struct **files;
+	alloc_pool_t file_pool;
+	alloc_pool_t hlink_pool;
 	int count;
 	int malloced;
-	struct file_struct **files;
+	int low, high;
 };
 
+#define SUMFLG_SAME_OFFSET	(1<<0)
+
 struct sum_buf {
-	OFF_T offset;		/* offset in file of this chunk */
-	int len;		/* length of chunk of file */
-	int i;			/* index of this chunk */
-	uint32 sum1;	        /* simple checksum */
-	char sum2[SUM_LENGTH];	/* checksum  */
+	OFF_T offset;		/**< offset in file of this chunk */
+	int32 len;		/**< length of chunk of file */
+	uint32 sum1;	        /**< simple checksum */
+	short flags;		/**< flag bits */
+	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 */
+	OFF_T flength;		/**< total file length */
+	struct sum_buf *sums;	/**< points to info for each chunk */
+	int32 count;		/**< how many chunks */
+	int32 blength;		/**< block_length */
+	int32 remainder;	/**< flength % block_length */
+	int s2length;		/**< sum2_length */
 };
 
 struct map_struct {
-	char *p;
-	int fd,p_size,p_len;
-	OFF_T file_size, p_offset, p_fd_offset;
+	OFF_T file_size;	/* File size (from stat)		*/
+	OFF_T p_offset;		/* Window start				*/
+	OFF_T p_fd_offset;	/* offset of cursor in fd ala lseek	*/
+	char *p;		/* Window pointer			*/
+	int32 p_size;		/* Largest window size we allocated	*/
+	int32 p_len;		/* Latest (rounded) window size		*/
+	int32 def_window_size;	/* Default window size			*/
+	int fd;			/* File Descriptor			*/
+	int status;		/* first errno from read errors		*/
 };
 
-struct exclude_struct {
-	char *orig;
+#define MATCHFLG_WILD		(1<<0) /* pattern has '*', '[', and/or '?' */
+#define MATCHFLG_WILD2		(1<<1) /* pattern has '**' */
+#define MATCHFLG_WILD2_PREFIX	(1<<2) /* pattern starts with '**' */
+#define MATCHFLG_ABS_PATH	(1<<3) /* path-match on absolute path */
+#define MATCHFLG_INCLUDE	(1<<4) /* this is an include, not an exclude */
+#define MATCHFLG_DIRECTORY	(1<<5) /* this matches only directories */
+#define MATCHFLG_CLEAR_LIST 	(1<<6) /* this item is the "!" token */
+#define MATCHFLG_WORD_SPLIT	(1<<7) /* split rules on whitespace */
+#define MATCHFLG_NO_INHERIT	(1<<8) /* don't inherit these rules */
+#define MATCHFLG_NO_PREFIXES	(1<<9) /* parse no prefixes from patterns */
+#define MATCHFLG_MERGE_FILE	(1<<10)/* specifies a file to merge */
+#define MATCHFLG_PERDIR_MERGE	(1<<11)/* merge-file is searched per-dir */
+#define MATCHFLG_EXCLUDE_SELF	(1<<12)/* merge-file name should be excluded */
+#define MATCHFLG_FINISH_SETUP	(1<<13)/* per-dir merge file needs setup */
+#define MATCHFLG_NEGATE 	(1<<14)/* rule matches when pattern does not */
+#define MATCHFLG_CVS_IGNORE	(1<<15)/* rule was -C or :C */
+#define MATCHFLG_SENDER_SIDE	(1<<16)/* rule applies to the sending side */
+#define MATCHFLG_RECEIVER_SIDE	(1<<17)/* rule applies to the receiving side */
+
+#define MATCHFLGS_FROM_CONTAINER (MATCHFLG_ABS_PATH | MATCHFLG_INCLUDE \
+				| MATCHFLG_DIRECTORY | MATCHFLG_SENDER_SIDE \
+				| MATCHFLG_NEGATE | MATCHFLG_RECEIVER_SIDE)
+
+struct filter_struct {
+	struct filter_struct *next;
 	char *pattern;
-	int regular_exp;
-	int fnmatch_flags;
-	int include;
-	int directory;
-	int local;
+	uint32 match_flags;
+	union {
+		int slash_cnt;
+		struct filter_list_struct *mergelist;
+	} u;
+};
+
+struct filter_list_struct {
+	struct filter_struct *head;
+	struct filter_struct *tail;
+	char *debug_type;
 };
 
 struct stats {
@@ -350,27 +624,44 @@ struct stats {
 	int64 total_read;
 	int64 literal_data;
 	int64 matched_data;
+	int64 flist_buildtime;
+	int64 flist_xfertime;
 	int flist_size;
 	int num_files;
 	int num_transferred_files;
+	int current_file_index;
 };
 
 
-/* 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 "lib/mdfour.h"
+#include "lib/wildmatch.h"
+#include "lib/permstring.h"
+#include "lib/addrinfo.h"
 
-#if !HAVE_STRERROR
+#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
+#define vsnprintf rsync_vsnprintf
+int vsnprintf(char *str, size_t count, const char *fmt, va_list args);
+#endif
+
+#if !defined HAVE_SNPRINTF || !defined HAVE_C99_VSNPRINTF
+#define snprintf rsync_snprintf
+int snprintf(char *str,size_t count,const char *fmt,...);
+#endif
+
+
+#ifndef HAVE_STRERROR
 extern char *sys_errlist[];
 #define strerror(i) sys_errlist[i]
 #endif
@@ -387,10 +678,6 @@ extern int errno;
 #define SUPPORT_LINKS HAVE_READLINK
 #define SUPPORT_HARD_LINKS HAVE_LINK
 
-#ifndef HAVE_LCHOWN
-#define lchown chown
-#endif
-
 #define SIGNAL_CAST (RETSIGTYPE (*)())
 
 #ifndef EWOULDBLOCK
@@ -409,10 +696,24 @@ extern int errno;
 #define STDERR_FILENO 2
 #endif
 
+#ifndef S_IRUSR
+#define S_IRUSR 0400
+#endif
+
 #ifndef S_IWUSR
 #define S_IWUSR 0200
 #endif
 
+#ifndef ACCESSPERMS
+#define ACCESSPERMS 0777
+#endif
+
+#ifndef S_ISVTX
+#define S_ISVTX 0
+#endif
+
+#define CHMOD_BITS (S_ISUID | S_ISGID | S_ISVTX | ACCESSPERMS)
+
 #ifndef _S_IFMT
 #define _S_IFMT        0170000
 #endif
@@ -460,37 +761,62 @@ extern int errno;
 /* work out what fcntl flag to use for non-blocking */
 #ifdef O_NONBLOCK
 # define NONBLOCK_FLAG O_NONBLOCK
-#elif defined(SYSV)
+#elif defined SYSV
 # define NONBLOCK_FLAG O_NDELAY
-#else 
+#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>")
+#define NS(s) ((s)?safe_fname(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 *, ...)
-#ifdef __GNUC__
-     __attribute__ ((format (printf, 2, 3)))
-#endif
+     __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
 
+/* Make sure that the O_BINARY flag is defined. */
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
 
 #ifndef HAVE_STRLCPY
 size_t strlcpy(char *d, const char *s, size_t bufsize);
@@ -500,4 +826,38 @@ size_t strlcpy(char *d, const char *s, size_t bufsize);
 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__)
+
+#ifdef HAVE_GETEUID
+#define MY_UID() geteuid()
+#else
+#define MY_UID() getuid()
+#endif
+
+#ifdef HAVE_GETEGID
+#define MY_GID() getegid()
+#else
+#define MY_GID() getgid()
+#endif
+
+extern int verbose;
+
+#ifndef HAVE_INET_NTOP
+const char *inet_ntop(int af, const void *src, char *dst, size_t size);
+#endif
+
+#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

@@ -1,5 +1,5 @@
 mailto(rsync-bugs@samba.org)
-manpage(rsyncd.conf)(5)(12 Feb 1999)()()
+manpage(rsyncd.conf)(5)(30 Mar 2005)()()
 manpagename(rsyncd.conf)(configuration file for rsync server)
 manpagesynopsis()
 
@@ -8,9 +8,7 @@ rsyncd.conf
 manpagedescription()
 
 The rsyncd.conf file is the runtime configuration file for rsync when
-run with the --daemon option. When run in this way rsync becomes a
-rsync server listening on TCP port 873. Connections from rsync clients
-are accepted for either anonymous or authenticated rsync sessions. 
+run as an rsync server. 
 
 The rsyncd.conf file controls authentication, access, logging and
 available modules.
@@ -21,7 +19,7 @@ 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
+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 
@@ -43,27 +41,35 @@ 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.
+The rsync daemon is launched by specifying the bf(--daemon) option to
+rsync. 
 
-You can launch it either via inetd or as a stand-alone daemon. If run
-as a daemon then just run the command "rsync --daemon" from a suitable
-startup script.
+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 "bf(rsync --daemon)" from a suitable startup script.
+If run from an rsync client via a remote shell (by specifying both the
+bf(--rsh) (bf(-e)) option and server mode with "::" or "rsync://"), the bf(--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)
+verb(  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)
+verb(  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(/etc/rsyncd.conf). The file is re-read on each client
+it to reread the tt(rsyncd.conf) file. The file is re-read on each client
 connection. 
 
 manpagesection(GLOBAL OPTIONS)
@@ -87,7 +93,7 @@ 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.
+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
@@ -122,28 +128,67 @@ 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(/etc/rsyncd.conf).
+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 and
-of not being able to follow symbolic links outside of the new root path
-when reading.  For writing when "use chroot" is false, for security reasons
-symlinks may only be relative paths pointing to other files within the
-root path, and leading slashes are removed from absolute paths.  The
-default for "use chroot" is true.
+holes, but it has the disadvantages of requiring super-user privileges, 
+of not being able to follow symbolic links that are either absolute or outside
+of the new root path, and of complicating the preservation of usernames and groups
+(see below).  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 most absolute paths (options
+such as bf(--backup-dir), bf(--compare-dest), etc. interpret an absolute path as
+rooted in the module's "path" dir, just as if chroot was specified).
+The default for "use chroot" is true.
+
+In order to preserve usernames and groupnames, rsync needs to be able to
+use the standard library functions for looking up names and IDs (i.e.
+getpwuid(), getgrgid(), getpwname(), and getgrnam()).  This means a
+process in the chroot namespace will need to have access to the resources
+used by these library functions (traditionally /etc/passwd and
+/etc/group).  If these resources are not available, rsync will only be
+able to copy the IDs, just as if the bf(--numeric-ids) option had been
+specified.
+
+Note that you are free to setup user/group information in the chroot area
+differently from your normal system.  For example, you could abbreviate
+the list of users and groups.  Also, you can protect this information from
+being downloaded/uploaded by adding an exclude rule to the rsync.conf file
+(e.g. "exclude = /etc/**").  Note that having the exclusion affect uploads
+is a relatively new feature in rsync, so make sure your server is running
+at least 2.6.3 to effect this.  Also note that it is safest to exclude a
+directory and all its contents combining the rule "/some/dir/" with the
+rule "/some/dir/**" just to be sure that rsync will not allow deeper
+access to some of the excluded files inside the directory (rsync tries to
+do this automatically, but you might as well specify both to be extra
+sure).
+
+dit(bf(port)) You can override the default port the daemon will listen on
+by specifying this value (defaults to 873).  This is ignored if the daemon
+is being run by inetd, and is superseded by the bf(--port) command-line option.
+
+dit(bf(address)) You can override the default IP address the daemon
+will listen on by specifying this value.  This is ignored if the daemon is
+being run by inetd, and is superseded by the bf(--address) command-line option.
 
 dit(bf(max connections)) The "max connections" option allows you to
-specify the maximum number of simultaneous connections you will allow
-to this module of your rsync server. Any clients connecting when the
-maximum has been reached will receive a message telling them to try
-later.  The default is 0 which means no limit.
+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(max verbosity)) The "max verbosity" option allows you to control
+the maximum amount of verbose information that you'll allow the daemon to
+generate (since the information goes into the log file). The default is 1,
+which allows the client to request one level of verbosity.
 
 dit(bf(lock file)) The "lock file" option specifies the file to use to
 support the "max connections" option. The rsync server uses record
 locking on this file to ensure that the max connections limit is not
-exceeded. The default is tt(/var/run/rsyncd.lock).
+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
@@ -151,67 +196,88 @@ 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(write only)) The "write only" option determines whether clients
+will be able to download files or not. If "write only" is true then any
+attempted downloads will fail. If "write only" is false then downloads
+will be possible if file permissions on the server allow them.  The
+default is for this option to be disabled.
+
 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
+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 the user "nobody".
+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
+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 the
-group "nobody".
+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
-equivalent to the client specifying these patterns with the --exclude
-option except that the exclude list is not passed to the client and
-thus only apply on the server.  Only one "exclude" option may be
-specified, but you can use "-" and "+" before patterns to specify
-exclude/include.
+dit(bf(filter)) The "filter" option allows you to specify a space-separated
+list of filter rules that the server will not allow to be read or written.
+This is only superficially equivalent to the client specifying these
+patterns with the bf(--filter) option.  Only one "filter" option may be
+specified, but it may contain as many rules as you like, including
+merge-file rules.  Note that per-directory merge-file rules do not provide
+as much protection as global rules, but they can be used to make bf(--delete)
+work better when a client downloads the server's files (if the per-dir
+merge files are included in the transfer).
 
-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)) The "exclude" option allows you to specify a
+space-separated list of patterns that the server will not allow to be read
+or written.  This is only superficially equivalent to the client
+specifying these patterns with the bf(--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 from being deleted on a client when receiving
+from a server.  
 
 dit(bf(exclude from)) The "exclude from" option specifies a filename
-on the server that contains exclude patterns, one per line. This is
-equivalent to the client specifying the --exclude-from option with a
-equivalent file except that the resulting exclude patterns are not
-passed to the client and thus only apply on the server. See also the
-note about security for the exclude option above.
+on the server that contains exclude patterns, one per line.
+This is only superficially equivalent
+to the client specifying the bf(--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
-equivalent to the client specifying these patterns with the --include
-option.  This is useful as it allows you to build up quite complex
-exclude/include rules.  Only one "include" option may be specified, but you
-can use "+" and "-" before patterns to switch include/exclude.
-
-See the section of exclude patterns in the rsync man page for information
-on the syntax of this option.
+dit(bf(include)) 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 bf(--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
-equivalent to the client specifying the --include-from option with a
-equivalent file.
+only superficially equivalent to the client specifying the
+bf(--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. 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
+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 an 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
@@ -223,11 +289,12 @@ 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)).
+(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
+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.
@@ -239,25 +306,31 @@ connection is rejected.
 
 Each pattern can be in one of five forms:
 
-itemize(
-  it() a dotted decimal IP address. In this case the incoming machines
-  IP address must match exactly.
-
-  it() a address/mask in the form a.b.c.d/n were n is the number of
-  one bits in in the netmask. All IP addresses which match the masked
-  IP address will be allowed in.
-
-  it() a address/mask in the form a.b.c.d/e.f.g.h where e.f.g.h is a
-  netmask in dotted decimal notation. All IP addresses which match the masked
-  IP address will be allowed in.
-
+quote(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(
+tt(    fe80::1%link1)nl()
+tt(    fe80::%link1/64)nl()
+tt(    fe80::%link1/ffff:ffff:ffff:ffff::)nl()
 )
 
 You can also combine "hosts allow" with a separate "hosts deny"
@@ -278,32 +351,51 @@ 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
+ignore I/O errors on the server when deciding whether to run the delete
+phase of the transfer. Normally rsync skips the bf(--delete) step if any
+I/O errors have occurred in order to prevent disastrous deletion due
+to a temporary resource shortage or other I/O error. In some cases this
 test is counter productive so you can use this option to turn off this
-behaviour. 
+behavior. 
+
+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.
+used by ftp daemons.  The server always logs the transfer at the end, so
+if a transfer is aborted, no mention will be made in the log file.
+
+If you want to customize the log lines, see 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.
+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.  An optional numeric
+field width may also be specified between the percent and the escape
+letter (e.g. "%-50n %8l %07p").
 
-The prefixes that are understood are:
+The default log format is "%o %h [%a] %m (%u) %f %l", and a "%t [%p] "
+is always prefixed when using the "log file" option.
+(A perl script that will summarize this default log format is included
+in the rsync source code distribution in the "support" subdirectory:
+rsyncstats.)
 
-itemize(
+The single-character escapes that are understood are as follows:
+
+quote(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 process ID of this rsync session
+  it() %o for the operation, which is "send", "recv", or "del."
+  (the latter includes the trailing period)
+  it() %f for the filename (long form on sender; no trailing "/")
+  it() %n for the filename (short form; trailing "/" on dir)
+  it() %L either the string " -> SYMLINK", or " => HARDLINK" or an
+  empty string (where bf(SYMLINK) or bf(HARDLINK) is a filename)
   it() %P for the module path
   it() %m for the module name
   it() %t for the current date time
@@ -311,25 +403,40 @@ itemize(
   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
-)
+  it() %i an itemized list of what is being updated
+))
 
-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.
+For a list of what the characters mean that are output by "%i", see the
+bf(--itemize-changes) option in the rsync manpage.
 
-A perl script called rsyncstats to summarize this format is included
-in the rsync source code distribution.
+Note that some of the logged output changes when talking with older
+rsync versions.  For instance, deleted files were only output as verbose
+messages prior to rsync 2.6.4.
 
 dit(bf(timeout)) The "timeout" option allows you to override the
-clients choice for IO timeout for this module. Using this option you
+clients choice for I/O 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).  
+specify a space-separated list of rsync command line options that will
+be refused by your rsync server.
+You may specify the full option name, its one-letter abbreviation, or a
+wild-card string that matches multiple options.
+For example, this would refuse bf(--checksum) (bf(-c)) and all the various
+delete options:
+
+quote(tt(    refuse options = c delete))
+
+The reason the above refuses all delete options is that the options imply
+bf(--delete), and implied options are refused just like explicit options.
+As an additional safety feature, the refusal of "delete" also refuses
+bf(remove-sent-files) when the daemon is the sender; if you want the latter
+without the former, instead refuse "delete-*" -- that refuses all the
+delete modes without affecting bf(--remove-sent-files).
+
 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
@@ -341,11 +448,11 @@ 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
+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)
+The default setting is tt(*.gz *.tgz *.zip *.z *.rpm *.deb *.iso *.bz2 *.tbz)
 
 enddit()
 
@@ -359,13 +466,39 @@ 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 link. Only
+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(RUNNING AN RSYNC SERVER OVER A REMOTE SHELL PROGRAM)
+
+If rsync is run with both the bf(--daemon) and bf(--rsh) (bf(-e)) options, it will
+spawn an rsync daemon using a remote shell connection.  Several
+configuration options will not be available unless the remote user is
+root (e.g. chroot, setuid/setgid, etc.).  There is no need to configure
+inetd or the services map to include the rsync server port if you run an
+rsync server only via a remote shell program.
+
+ADVANCED: To run an rsync server out of a single-use ssh key, use the
+"command=em(COMMAND)" syntax in the remote user's authorized_keys entry,
+where command would be
+
+quote(tt(rsync --server --daemon .))
+
+NOTE: rsync's argument parsing expects the trailing ".", so make sure
+that it's there.  If you want to use an rsyncd.conf(5)-style
+configuration file other than the default, you can added a
+bf(--config) option to the em(command):
+
+quote(tt(rsync --server --daemon --config=em(file) .))
+
+Note that the "--server" here is the internal option that rsync uses to
+run the remote version of rsync that it communicates with, and thus you
+should not be using the bf(--server) option under normal circumstances.
+
 manpagesection(EXAMPLES)
 
 A simple rsyncd.conf file that allow anonymous rsync to a ftp area at
@@ -377,17 +510,17 @@ verb(
         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 = /etc/rsyncd.pid
+verb(
+uid = nobody
+gid = nobody
+use chroot = no
+max connections = 4
+syslog facility = local5
+pid file = /var/run/rsyncd.pid
 
-verb([ftp]
+[ftp]
         path = /var/ftp/pub
         comment = whole ftp area (approx 6.1 GB)
 
@@ -412,12 +545,14 @@ verb([ftp]
 
 The /etc/rsyncd.secrets file would look something like this:
 
-tridge:mypass nl()
-susan:herpass
+quote(
+tt(tridge:mypass)nl()
+tt(susan:herpass)nl()
+)
 
 manpagefiles()
 
-/etc/rsyncd.conf
+/etc/rsyncd.conf or rsyncd.conf
 
 manpageseealso()
 
@@ -435,7 +570,7 @@ 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
+This man page is current for version 2.x of rsync.
 
 manpagesection(CREDITS)
 
@@ -461,7 +596,8 @@ 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
+rsync was written by Andrew Tridgell and Paul Mackerras.
+Many people have later contributed to it.
 
+Mailing lists for support and development are available at
+url(http://lists.samba.org)(lists.samba.org) 

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,277 @@
+#! /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
+[ -d /usr/xpg4/bin ] && PATH="/usr/xpg4/bin/:$PATH"
+
+if [ "x$loglevel" != x ] && [ "$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"
+
+if [ -f /usr/bin/whoami ]; then
+    testuser=`/usr/bin/whoami`
+elif [ -f /usr/ucb/whoami ]; then
+    testuser=`/usr/ucb/whoami`
+elif [ -f /bin/whoami ]; then
+    testuser=`/bin/whoami`
+else
+    testuser=`id -un 2>/dev/null || echo ${LOGNAME:-${USERNAME:-${USER:-'UNKNOWN'}}}`
+fi
+
+echo "    testuser=$testuser"
+echo "    os=`uname -a`"
+
+# It must be "yes", not just nonnull
+if [ "x$preserve_scratch" = xyes ]; then
+    echo "    preserve_scratch=yes"
+else
+    echo "    preserve_scratch=no"
+fi    
+
+
+if [ ! -f "$rsync_bin" ]; then
+    echo "rsync_bin $rsync_bin is not a file" >&2
+    exit 2
+fi
+
+if [ ! -d "$srcdir" ]; then
+    echo "srcdir $srcdir is not a directory" >&2
+    exit 2
+fi
+
+RSYNC="$rsync_bin"
+#RSYNC="valgrind --tool=addrcheck $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 -e 's!.*/!!' -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"
+	if [ -f "$scratchdir/rsyncd.log" ]; then
+	    echo "----- $testbase rsyncd.log follows"
+	    cat "$scratchdir/rsyncd.log"
+	    echo "----- $testbase rsyncd.log ends"
+	fi
+    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

@@ -1,17 +1,17 @@
-/* 
+/*
    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.
@@ -20,58 +20,79 @@
 #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;
+extern int am_daemon;
+extern int log_before_transfer;
+extern int log_format_has_i;
+extern int daemon_log_format_has_i;
+extern int csum_length;
+extern int io_error;
+extern int protocol_version;
+extern int remove_sent_files;
+extern int updating_basis_file;
+extern int make_backups;
+extern int do_progress;
+extern int inplace;
+extern struct stats stats;
+extern struct file_list *the_file_list;
+extern char *log_format;
 
 
-/*
-  receive the checksums for a buffer
-  */
+/**
+ * @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;
+	int32 i;
 	OFF_T offset = 0;
 
-	s = (struct sum_struct *)malloc(sizeof(*s));
-	if (!s) out_of_memory("receive_sums");
+	if (!(s = new(struct sum_struct)))
+		out_of_memory("receive_sums");
+
+	read_sum_head(f, s);
 
-	s->count = read_int(f);
-	s->n = read_int(f);
-	s->remainder = read_int(f);  
 	s->sums = NULL;
 
-	if (verbose > 3)
-		rprintf(FINFO,"count=%d n=%d rem=%d\n",
-			s->count,s->n,s->remainder);
+	if (verbose > 3) {
+		rprintf(FINFO, "count=%.0f n=%ld rem=%ld\n",
+			(double)s->count, (long)s->blength, (long)s->remainder);
+	}
 
-	if (s->count == 0) 
+	if (s->count == 0)
 		return(s);
 
-	s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
-	if (!s->sums) out_of_memory("receive_sums");
+	if (!(s->sums = new_array(struct sum_buf, s->count)))
+		out_of_memory("receive_sums");
 
-	for (i=0;i<s->count;i++) {
+	for (i = 0; i < s->count; i++) {
 		s->sums[i].sum1 = read_int(f);
-		read_buf(f,s->sums[i].sum2,csum_length);
+		read_buf(f, s->sums[i].sum2, s->s2length);
 
 		s->sums[i].offset = offset;
-		s->sums[i].i = i;
+		s->sums[i].flags = 0;
 
-		if (i == s->count-1 && s->remainder != 0) {
+		if (i == s->count-1 && s->remainder != 0)
 			s->sums[i].len = s->remainder;
-		} else {
-			s->sums[i].len = s->n;
-		}
+		else
+			s->sums[i].len = s->blength;
 		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);
+		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;
@@ -79,152 +100,277 @@ static struct sum_struct *receive_sums(int f)
 	return s;
 }
 
-
-
-void send_files(struct file_list *flist,int f_out,int f_in)
-{ 
-	int fd;
-	struct sum_struct *s;
-	struct map_struct *buf;
-	STRUCT_STAT st;
-	char fname[MAXPATHLEN];  
-	int i;
+void successful_send(int ndx)
+{
+	char fname[MAXPATHLEN];
 	struct file_struct *file;
-	int phase = 0;
-	extern struct stats stats;		
+	unsigned int offset;
+
+	if (ndx < 0 || ndx >= the_file_list->count)
+		return;
+
+	file = the_file_list->files[ndx];
+	/* The generator might tell us about symlinks we didn't send. */
+	if (!(file->flags & FLAG_SENT) && !S_ISLNK(file->mode))
+		return;
+	if (file->dir.root) {
+		offset = stringjoin(fname, sizeof fname,
+				    file->dir.root, "/", NULL);
+	} else
+		offset = 0;
+	f_name_to(file, fname + offset);
+	if (remove_sent_files && do_unlink(fname) == 0 && verbose > 1) {
+		rprintf(FINFO, "sender removed %s\n",
+			safe_fname(fname + offset));
+	}
+}
+
+static void write_ndx_and_attrs(int f_out, int ndx, int iflags,
+				uchar fnamecmp_type, char *buf, int len)
+{
+	write_int(f_out, ndx);
+	if (protocol_version < 29)
+		return;
+	write_shortint(f_out, iflags);
+	if (iflags & ITEM_BASIS_TYPE_FOLLOWS)
+		write_byte(f_out, fnamecmp_type);
+	if (iflags & ITEM_XNAME_FOLLOWS)
+		write_vstring(f_out, buf, len);
+}
+
+/* This is also used by receive.c with f_out = -1. */
+int read_item_attrs(int f_in, int f_out, int ndx, uchar *type_ptr,
+		    char *buf, int *len_ptr)
+{
+	int len;
+	uchar fnamecmp_type = FNAMECMP_FNAME;
+	int iflags = protocol_version >= 29 ? read_shortint(f_in)
+		   : ITEM_TRANSFER | ITEM_MISSING_DATA;
+
+	/* Handle the new keep-alive (no-op) packet. */
+	if (ndx == the_file_list->count && iflags == ITEM_IS_NEW)
+		;
+	else if (ndx < 0 || ndx >= the_file_list->count) {
+		rprintf(FERROR, "Invalid file index: %d (count=%d) [%s]\n",
+			ndx, the_file_list->count, who_am_i());
+		exit_cleanup(RERR_PROTOCOL);
+	} else if (iflags == ITEM_IS_NEW) {
+		rprintf(FERROR, "Invalid itemized flag word: %x [%s]\n",
+			iflags, who_am_i());
+		exit_cleanup(RERR_PROTOCOL);
+	}
+
+	if (iflags & ITEM_BASIS_TYPE_FOLLOWS)
+		fnamecmp_type = read_byte(f_in);
+	*type_ptr = fnamecmp_type;
+
+	if (iflags & ITEM_XNAME_FOLLOWS) {
+		if ((len = read_vstring(f_in, buf, MAXPATHLEN)) < 0)
+			exit_cleanup(RERR_PROTOCOL);
+	} else {
+		*buf = '\0';
+		len = -1;
+	}
+	*len_ptr = len;
+
+	/* Temporary handling of 2.6.4pre3 */
+	if (iflags & ITEM_DUMMY_BIT && iflags & (ITEM_LOCAL_CHANGE|ITEM_TRANSFER))
+		iflags &= ~ITEM_DUMMY_BIT;
+
+	if (iflags & ITEM_TRANSFER) {
+		if (!S_ISREG(the_file_list->files[ndx]->mode)) {
+			rprintf(FERROR,
+				"received request to transfer non-regular file: %d [%s]\n",
+				ndx, who_am_i());
+			exit_cleanup(RERR_PROTOCOL);
+		}
+	} else if (f_out >= 0) {
+		write_ndx_and_attrs(f_out, ndx, iflags,
+				    fnamecmp_type, buf, len);
+	}
+
+	return iflags;
+}
+
+void send_files(struct file_list *flist, int f_out, int f_in)
+{
+	int fd = -1;
+	struct sum_struct *s;
+	struct map_struct *mbuf = NULL;
+	STRUCT_STAT st;
+	char *fname2, fname[MAXPATHLEN];
+	char xname[MAXPATHLEN];
+	uchar fnamecmp_type;
+	int iflags, xlen;
+	struct file_struct *file;
+	int phase = 0, max_phase = protocol_version >= 29 ? 2 : 1;
 	struct stats initial_stats;
+	int save_make_backups = make_backups;
+	int itemizing = am_daemon ? daemon_log_format_has_i
+		      : !am_server && log_format_has_i;
+	int i, j;
 
 	if (verbose > 2)
-		rprintf(FINFO,"send_files starting\n");
-
-	setup_readbuffer(f_in);
+		rprintf(FINFO, "send_files starting\n");
 
 	while (1) {
-		int offset=0;
+		unsigned int offset;
 
 		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 (++phase > max_phase)
+				break;
+			csum_length = SUM_LENGTH;
+			if (verbose > 2)
+				rprintf(FINFO, "send_files phase=%d\n", phase);
+			write_int(f_out, -1);
+			/* For inplace: redo phase turns off the backup
+			 * flag so that we do a regular inplace send. */
+			make_backups = 0;
+			continue;
 		}
 
-		if (i < 0 || i >= flist->count) {
-			rprintf(FERROR,"Invalid file index %d (count=%d)\n", 
-				i, flist->count);
+		iflags = read_item_attrs(f_in, f_out, i, &fnamecmp_type,
+					 xname, &xlen);
+		if (iflags == ITEM_IS_NEW) /* no-op packet */
+			continue;
+
+		file = flist->files[i];
+		if (file->dir.root) {
+			/* N.B. We're sure that this fits, so offset is OK. */
+			offset = strlcpy(fname, file->dir.root, sizeof fname);
+			if (!offset || fname[offset-1] != '/')
+				fname[offset++] = '/';
+		} else
+			offset = 0;
+		fname2 = f_name_to(file, fname + offset);
+
+		if (verbose > 2)
+			rprintf(FINFO, "send_files(%d, %s)\n", i, fname);
+
+		if (!(iflags & ITEM_TRANSFER)) {
+			maybe_log_item(file, iflags, itemizing, xname);
+			continue;
+		}
+		if (phase == 2) {
+			rprintf(FERROR,
+				"got transfer request in phase 2 [%s]\n",
+				who_am_i());
 			exit_cleanup(RERR_PROTOCOL);
 		}
 
-		file = flist->files[i];
+		updating_basis_file = inplace && (protocol_version >= 29
+			? fnamecmp_type == FNAMECMP_FNAME : !make_backups);
 
+		stats.current_file_index = 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);
+		if (dry_run) { /* log the transfer */
+			if (!am_server && log_format)
+				log_item(file, &stats, iflags, NULL);
+			write_ndx_and_attrs(f_out, i, iflags, fnamecmp_type,
+					    xname, xlen);
 			continue;
 		}
 
 		initial_stats = stats;
 
-		s = receive_sums(f_in);
-		if (!s) {
-			io_error = 1;
-			rprintf(FERROR,"receive_sums failed\n");
+		if (!(s = receive_sums(f_in))) {
+			io_error |= IOERR_GENERAL;
+			rprintf(FERROR, "receive_sums failed\n");
 			return;
 		}
-	  
+
 		fd = do_open(fname, O_RDONLY, 0);
 		if (fd == -1) {
-			io_error = 1;
-			rprintf(FERROR,"send_files failed to open %s: %s\n",
-				fname,strerror(errno));
+			if (errno == ENOENT) {
+				enum logcode c = am_daemon
+				    && protocol_version < 28 ? FERROR
+							     : FINFO;
+				io_error |= IOERR_VANISHED;
+				rprintf(c, "file has vanished: %s\n",
+					full_fname(fname));
+			} else {
+				io_error |= IOERR_GENERAL;
+				rsyserr(FERROR, errno,
+					"send_files failed to open %s",
+					full_fname(fname));
+			}
 			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));
+		if (do_fstat(fd, &st) != 0) {
+			io_error |= IOERR_GENERAL;
+			rsyserr(FERROR, errno, "fstat failed");
 			free_sums(s);
 			close(fd);
 			return;
 		}
-	  
-		if (st.st_size > 0) {
-			buf = map_file(fd,st.st_size);
-		} else {
-			buf = NULL;
-		}
-	  
-		if (verbose > 2)
-			rprintf(FINFO,"send_files mapped %s of size %.0f\n",
-				fname,(double)st.st_size);
 
-		write_int(f_out,i);
-	  
-		write_int(f_out,s->count);
-		write_int(f_out,s->n);
-		write_int(f_out,s->remainder);
-	  
-		if (verbose > 2)
-			rprintf(FINFO,"calling match_sums %s\n",fname);
-	  
-		if (!am_server) {
-			log_transfer(file, fname+offset);
+		if (st.st_size) {
+			int32 read_size = MAX(s->blength * 3, MAX_MAP_SIZE);
+			mbuf = map_file(fd, st.st_size, read_size, s->blength);
+		} else
+			mbuf = NULL;
+
+		if (verbose > 2) {
+			rprintf(FINFO, "send_files mapped %s of size %.0f\n",
+				safe_fname(fname), (double)st.st_size);
 		}
 
+		write_ndx_and_attrs(f_out, i, iflags, fnamecmp_type,
+				    xname, xlen);
+		write_sum_head(f_out, s);
+
+		if (verbose > 2) {
+			rprintf(FINFO, "calling match_sums %s\n",
+				safe_fname(fname));
+		}
+
+		if (log_before_transfer)
+			log_item(file, &initial_stats, iflags, NULL);
+		else if (!am_server && verbose && do_progress)
+			rprintf(FINFO, "%s\n", safe_fname(fname2));
+
 		set_compression(fname);
-	  
-		match_sums(f_out,s,buf,st.st_size);
 
-		log_send(file, &initial_stats);
-	  	  
-		if (buf) unmap_file(buf);
+		match_sums(f_out, s, mbuf, st.st_size);
+		if (do_progress)
+			end_progress(st.st_size);
+
+		if (!log_before_transfer)
+			log_item(file, &initial_stats, iflags, NULL);
+
+		if (mbuf) {
+			j = unmap_file(mbuf);
+			if (j) {
+				io_error |= IOERR_GENERAL;
+				rsyserr(FERROR, j,
+					"read errors mapping %s",
+					full_fname(fname));
+			}
+		}
 		close(fd);
-	  
+
 		free_sums(s);
-	  
-		if (verbose > 2)
-			rprintf(FINFO,"sender finished %s\n",fname);
+
+		if (verbose > 2) {
+			rprintf(FINFO, "sender finished %s\n",
+				safe_fname(fname));
+		}
+
+		/* Flag that we actually sent this entry. */
+		file->flags |= FLAG_SENT;
 	}
+	make_backups = save_make_backups;
 
 	if (verbose > 2)
-		rprintf(FINFO,"send files finished\n");
+		rprintf(FINFO, "send files finished\n");
 
 	match_report();
 
-	write_int(f_out,-1);
+	write_int(f_out, -1);
 }
-
-
-
-
-

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

support/Makefile

@@ -0,0 +1,6 @@
+all: savetransfer
+
+savetransfer: savetransfer.o
+
+clean:
+	rm -f *.o savetransfer

support/atomic-rsync

@@ -0,0 +1,90 @@
+#!/usr/bin/perl
+#
+# This script lets you update a hierarchy of files in an atomic way by
+# first creating a new hierarchy using --link-dest to rsync, and then
+# swapping the hierarchy into place.  See the usage message for more
+# details and some important caveats!
+
+use strict;
+use Cwd 'abs_path';
+
+my $RSYNC_PROG = '/usr/bin/rsync';
+my $RM_PROG = '/bin/rm';
+
+my $dest_dir = $ARGV[-1];
+usage(1) if $dest_dir eq '' || $dest_dir =~ /^--/;
+
+if (!-d $dest_dir) {
+    print STDERR "$dest_dir is not a directory.\n\n";
+    usage(1);
+}
+
+if (@_ = grep(/^--(link|compare)-dest/, @ARGV)) {
+    $_ = join(' or ', @_);
+    print STDERR "You may not use $_ as an rsync option.\n\n";
+    usage(1);
+}
+
+$dest_dir = abs_path($dest_dir);
+if ($dest_dir eq '/') {
+    print STDERR 'You must not use "/" as the destination directory.', "\n\n";
+    usage(1);
+}
+
+my $old_dir = "$dest_dir~old~";
+my $new_dir = $ARGV[-1] = "$dest_dir~new~";
+
+system($RM_PROG, '-rf', $old_dir) if -d $old_dir;
+
+if (system($RSYNC_PROG, "--link-dest=$dest_dir", @ARGV)) {
+    if ($? == -1) {
+	print "failed to execute $RSYNC_PROG: $!\n";
+    } elsif ($? & 127) {
+	printf "child died with signal %d, %s coredump\n",
+	    ($? & 127),  ($? & 128) ? 'with' : 'without';
+    } else {
+	printf "child exited with value %d\n", $? >> 8;
+    }
+    exit $?;
+}
+
+rename($dest_dir, $old_dir) or die "Unable to rename $new_dir to $old_dir: $!";
+rename($new_dir, $dest_dir) or die "Unable to rename $new_dir to $dest_dir: $!";
+
+exit;
+
+
+sub usage
+{
+    my($ret) = @_;
+    my $fh = $ret ? *STDERR : *STDOUT;
+    print $fh <<EOT;
+Usage: atomic-rsync [RSYNC-OPTIONS] HOST:/SOURCE/DIR/ /DEST/DIR/
+       atomic-rsync [RSYNC-OPTIONS] HOST::MOD/DIR/ /DEST/DIR/
+
+This script lets you update a hierarchy of files in an atomic way by first
+creating a new hierarchy (using hard-links to leverage the existing files),
+and then swapping the new hierarchy into place.  You must be pulling files
+to a local directory, and that directory must already exist.  For example:
+
+    atomic-rsync -av host:/remote/files/ /local/files/
+
+This would make the transfer to the directory /local/files~new~ and then
+swap out /local/files at the end of the transfer by renaming it to
+/local/files~old~ and putting the new directory into its place.  The
+/local/files~old~ directory will be preserved until the next update, at
+which point it will be deleted.
+
+Do NOT specify this command:
+
+    atomic-rsync -av host:/remote/files /local/
+
+... UNLESS you want the entire /local dir to be swapped out!
+
+See the "rsync" command for its list of options.  You may not use the
+--link-dest or --compare-dest options (since this script uses --link-dest
+to make the transfer efficient).  Also, the destination directory cannot
+be "/".
+EOT
+    exit $ret;
+}

support/mnt-excl

@@ -0,0 +1,44 @@
+#!/usr/bin/perl -w
+# This script takes a command-line arg of a source directory
+# that will be passed to rsync, and generates a set of excludes
+# that will exclude all mount points from the list.  This is
+# useful if you have "bind" mounts since the --one-file-system
+# option won't notice the transition to a different spot on
+# the same disk.  For example:
+#
+# mnt-excl /dir | rsync --exclude-from=- ... /dir /dest/
+# mnt-excl /dir/ | rsync --exclude-from=- ... /dir/ /dest/
+# ssh host mnt-excl /dir | rsync --exclude-from=- ... host:/dir /dest/
+#
+# Imagine that /dir/foo is a mount point: the first invocation of
+# mnt-excl would have output /dir/foo, while the second would have
+# output /foo (which are the properly anchored excludes).
+#
+# NOTE:  This script expects /proc/mounts to exist, but could be
+# easily adapted to read /etc/mtab or similar.
+#
+# ADDENDUM:  The addition of the --filter option (which has support for
+# absolute-anchored excludes) has made this script less useful than it
+# was.  Beginning with 2.6.4, you can achieve the effect of this script
+# though this command:
+#
+# awk '{print $2}' /proc/mounts | rsync -f 'merge,/- -' host:/dir /dest/
+
+use strict;
+use Cwd 'abs_path';
+
+my $file = '/proc/mounts';
+my $dir = shift || '/';
+$dir = abs_path($dir);
+$dir =~ s#([^/]*)$##;
+my $trailing = $1;
+$trailing = '' if $trailing eq '.' || !-d "$dir$trailing";
+$trailing .= '/' if $trailing ne '';
+
+open(IN, $file) or die "Unable to open $file: $!\n";
+while (<IN>) {
+    $_ = (split)[1];
+    next unless s#^\Q$dir$trailing\E##o && $_ ne '';
+    print "- /$trailing$_\n";
+}
+close IN;

support/rrsync

@@ -0,0 +1,74 @@
+#!/usr/bin/perl
+# Name: /usr/local/bin/rrsync (should also have a symlink in /usr/bin)
+# Purpose: Restricts rsync to subdirectory declared in .ssh/authorized_keys
+# Author: Joe Smith <js-cgi@inwap.com> 30-Sep-2004
+# Modified by Wayne Davison <wayned@samba.org> 12-Jan-2005
+
+use Socket;
+use constant LOGFILE => 'rrsync.log';
+my $Usage = <<EOM;
+Use 'command="$0 [-ro] SUBDIR"'
+	in front of lines in $ENV{HOME}/.ssh/authorized_keys
+EOM
+
+my $ro = (@ARGV and $ARGV[0] eq '-ro') ? shift : '';	# -ro = Read-Only
+my $subdir = shift;
+die "No subdirectory specified\n$Usage" unless defined $subdir;
+
+# The client uses "rsync -av -e ssh src/ server:dir/", and sshd on the server
+# executes this program when .ssh/authorized_keys has 'command="..."'.
+# For example:
+# command="rrsync logs/client" ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEAzGhEeNlPr...
+# command="rrsync -ro results" ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEAmkHG1WCjC...
+#
+# Format of the envrionment variables set by sshd:
+# SSH_ORIGINAL_COMMAND=rsync --server          -vlogDtpr --partial . dir # push
+# SSH_ORIGINAL_COMMAND=rsync --server --sender -vlogDtpr --partial . dir # pull
+# SSH_CONNECTION=client_addr client_port server_port
+
+my $command = $ENV{SSH_ORIGINAL_COMMAND};
+die "Not invoked via sshd\n$Usage"	unless defined $command;
+die "SSH_ORIGINAL_COMMAND='$command' is not rsync\n" unless $command =~ /^rsync\s/;
+die "$0 -ro: sending to read-only server not allowed\n"
+	if $ro and $command !~ /^rsync --server --sender /;
+die "$0 -ro: use of --remove-sent-files with read-only server not allowed\n"
+	if $ro and $command =~ /\s--remove-sent-files/;
+
+my ($cmd,$dir) = $command =~ /^(rsync\s+(?:-[-a-zA-Z]+\s+)+\.) ?("[^"]*"|[^\s"]*)$/;
+die "$0: invalid rsync-command syntax or options\n" if !defined $cmd;
+
+# Enforce default of $subdir instead of the normal $HOME default.
+my $orig = $dir;
+my @dirs;
+$dir =~ s/^"(.*?)"$/$1/;
+$dir =~ s/^\s+//;
+$dir =~ s/\s+$//;
+foreach (split(/(?<!\\)\s+/, $dir)) {
+  s/\\(\s)/$1/g;			# Unescape any escaped whitespace
+  if ($subdir eq '/') {			# Less checking for '/' access
+    $dir = '/' if $dir eq '';
+  } else {
+    s#^/##;				# Don't allow absolute paths
+    $_ = "$subdir/$_" unless m#^\Q$subdir\E(/|$)#;
+    1 while s#/\.\.(/|$)#/__/#g;	# Don't allow foo/../../etc
+  }
+  tr#-_/a-zA-Z0-9.,+@^%: #_#c;		# Don't allow '"&;|!=()[]{}<>*?#\$
+  s/(\s)/\\$1/g;			# Re-escape whitespace
+  push(@dirs, $_);
+}
+push(@dirs, $subdir) unless @dirs;
+$dir = join(' ', @dirs);
+
+if (-f LOGFILE and open LOG,'>>',LOGFILE) {
+  my ($mm,$hh) = (localtime)[1,2];
+  my $host = $ENV{SSH_CONNECTION} || 'unknown';
+  $host =~ s/ .*//;			# Keep only the client's IP addr
+  $host =~ s/^::ffff://;
+  $host = gethostbyaddr(inet_aton($host),AF_INET) || $host;
+  my $dir_result = $dir eq $orig ? " OK" : "> \"$dir\"";
+  printf LOG "%02d:%02d %-13s [%s] =%s\n", $hh, $mm, $host, $command, $dir_result;
+  close LOG;
+}
+
+exec "$cmd \"$dir\"" or die "exec($cmd \"$dir\") failed: $? $!";
+# Note: This assumes that the rsync protocol will not be maliciously hijacked.

support/rsyncstats

@@ -1,72 +1,67 @@
-#! /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
+#!/usr/bin/perl
 #
 # 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
+# as a daemon with transfer logging enabled.  It also parses a slightly tweaked
+# version of the default format where %o has been replaced with %i.
+#
+# This script is derived from the xferstats script that comes with wuftpd.  See
+# the usage message at the bottom for the options it takes.
 #
 # Andrew Tridgell, October 1998
-# rsync-bugs@samba.org
-#
-# ---------------------------------------------------------------------------
 
-# edit the next line to customize for your default log file
+use Getopt::Long;
+
+# You may wish to 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;
+$hourly_report = 0; 
+$domain_report = 0;
+$total_report = 0;
+$depth_limit = 9999;
+$only_section = '';
 
-require 'getopts.pl';
-&Getopts('f:rahdD:l:s:');
+&Getopt::Long::Configure('bundling');
+&usage if !&GetOptions(
+    'hourly-report|h' => \$hourly_report,
+    'domain-report|d' => \$domain_report,
+    'domain|D:s' => \$only_domain,
+    'total-report|t' => \$total_report,
+    'depth-limit|l:i' => \$depth_limit,
+    'real|r' => \$real,
+    'anon|a' => \$anon,
+    'section|s:s' => \$only_section,
+    'file|f:s' => \$usage_file,
+);
 
-if ($opt_r) { $real = 1;}
-if ($opt_a) { $anon = 1;}
-if ($real == 0 && $anon == 0) { $anon = 1; }
-if ($opt_f) {$usage_file = $opt_f;}
+$anon = 1 if !$real && !$anon;
 
-open (LOG,$usage_file) || die "Error opening usage log file: $usage_file\n";
+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 ($only_domain) {
+    print "Transfer Totals include the '$only_domain' 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";}
+if ($only_section) {
+    print "Transfer Totals include the '$only_section' section only.\n";
+    print "All other sections are filtered out for this report.\n\n";
+}
 
 line: while (<LOG>) {
 
-   @line = split;
+   next unless ($day,$time,$op,$host,$module,$file,$bytes)
+      = m#^ (\d+/\d\d/\d\d)\s+(\d\d:\d\d:\d\d)\s+\[\d+\]\s+(send|recv|[<>]f\S+)\s+
+          (\S+)\s+\[\d+\.\d+\.\d+\.\d+\]\s+(\S+)\s+\(\S*\)\s+(.*)\s+(\d+) $ #x;
 
-   $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");
+   # TODO actually divide the data by into send/recv categories
+   if ($op =~ /^>/) {
+      $op = 'send';
+   } elsif ($op =~ /^</) {
+      $op = 'recv';
+   }
 
    $daytime = $day;
    $hour = substr($time,0,2); 
@@ -78,11 +73,13 @@ line: while (<LOG>) {
    @path = split(/\//, $file);
 
    $pathkey = "";
-   for ($i=0; $i <= $#path && $i <= $opt_l;$i++) {
+   for ($i=0; $i <= $#path && $i <= $depth_limit; $i++) {
 	$pathkey = $pathkey . "/" . $path[$i];
    }
 
-   next if (substr($pathkey,0,length("$opt_s")) ne "$opt_s");
+   if ($only_section ne '') {
+       next unless (substr($pathkey,0,length($only_section)) eq $only_section);
+   }
 
    $host =~ tr/A-Z/a-z/;
 
@@ -92,12 +89,12 @@ line: while (<LOG>) {
    if ( int($address[0]) > 0 || $#address < 2 )
       { $domain = "unresolved"; }
 
-   if ($opt_D) {
-       next unless (substr($domain,0,length("$opt_D")) eq "$opt_D");
+   if ($only_domain ne '') {
+       next unless (substr($domain,0,length($only_domain)) eq $only_domain);
    }
 
 
-#   printf ("c=%d day=%s bytes=%d file=%s path=%s\n", 
+#   printf("c=%d day=%s bytes=%d file=%s path=%s\n", 
 #	   $#line, $daytime, $bytes, $file, $pathkey);
 
    $xferfiles++;                                # total files sent
@@ -117,20 +114,20 @@ line: while (<LOG>) {
 }
 close LOG;
 
-@syslist = keys(systemfiles);
-@dates = sort datecompare keys(xferbytes);
+#@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("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",
+printf("Average Files Transmitted Daily          %12.0f\n",
    $xferfiles / ($#dates + 1));
-printf ("Average Bytes Transmitted Daily          %12.0f\n",
+printf("Average Bytes Transmitted Daily          %12.0f\n",
    $xferbytes / ($#dates + 1));
 
 format top1 =
@@ -150,7 +147,7 @@ $date,           $nfiles,    $nbytes/(1024*1024), $pctfiles,  $pctbytes
 $^ = top1;
 $~ = line1;
 
-foreach $date ( sort datecompare keys(xferbytes) ) {
+foreach $date (sort datecompare keys %xferbytes) {
 
    $nfiles   = $xferfiles{$date};
    $nbytes   = $xferbytes{$date};
@@ -159,7 +156,7 @@ foreach $date ( sort datecompare keys(xferbytes) ) {
    write;
 }
 
-if ($opt_t) {
+if ($total_report) {
 format top2 =
 
 Total Transfers from each Archive Section (By bytes)
@@ -179,7 +176,7 @@ $- = 0;
 $^ = top2;
 $~ = line2;
 
-foreach $section ( sort bytecompare keys(groupfiles) ) {
+foreach $section (sort bytecompare keys %groupfiles) {
 
    $files = $groupfiles{$section};
    $bytes = $groupbytes{$section};
@@ -193,7 +190,7 @@ if ( $xferfiles < 1 ) { $xferfiles = 1; }
 if ( $xferbytes < 1 ) { $xferbytes = 1; }
 }
 
-if ($opt_d) {
+if ($domain_report) {
 format top3 =
 
 Total Transfer Amount By Domain
@@ -212,7 +209,7 @@ $- = 0;
 $^ = top3;
 $~ = line3;
 
-foreach $domain ( sort domnamcompare keys(domainfiles) ) {
+foreach $domain (sort domnamcompare keys %domainfiles) {
 
    if ( $domainsecs{$domain} < 1 ) { $domainsecs{$domain} = 1; }
 
@@ -226,7 +223,7 @@ foreach $domain ( sort domnamcompare keys(domainfiles) ) {
 
 }
 
-if ($opt_h) {
+if ($hourly_report) {
 
 format top8 =
 
@@ -248,7 +245,7 @@ $- = 0;
 $^ = top8;
 $~ = line8;
 
-foreach $hour ( sort keys(xfertbytes) ) {
+foreach $hour (sort keys %xfertbytes) {
 
    $nfiles   = $xfertfiles{$hour};
    $nbytes   = $xfertbytes{$hour};
@@ -284,3 +281,19 @@ sub faccompare {
 
 }
 
+sub usage
+{
+    die <<EOT;
+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      Set DEPTH of path detail for sections.
+  -s SECTION    Set SECTION to report on. For example, "-s /pub"
+                will report only on paths under "/pub".
+EOT
+}

support/savetransfer.c

@@ -0,0 +1,178 @@
+/* This program can record the stream of data flowing to or from a program.
+ * This allows it to be used to check that rsync's data that is flowing
+ * through a remote shell is not being corrupted (for example).
+ *
+ * Usage: savetransfer [-i|-o] OUTPUT_FILE PROGRAM [ARGS...]
+ * -i  Save the input going to PROGRAM to the OUTPUT_FILE
+ * -o  Save the output coming from PROGRAM to the OUTPUT_FILE
+ *
+ * If you want to capture the flow of data for an rsync command, use one of
+ * the following commands (the first two are push commands, the last two are
+ * pull commands):
+ *
+ * rsync -av --rsh="savetransfer -i /tmp/from.sender ssh"
+ *   --rsync-path="savetransfer -i /tmp/to.receiver rsync" FILES HOST:DEST
+ *
+ * rsync -av --rsh="savetransfer -o /tmp/to.sender ssh"
+ *   --rsync-path="savetransfer -o /tmp/from.generator rsync" FILES HOST:DEST
+ *
+ * rsync -av --rsh="savetransfer -i /tmp/from.generator ssh"
+ *   --rsync-path="savetransfer -i /tmp/to.sender rsync" HOST:FILES DEST
+ *
+ * rsync -av --rsh="savetransfer -o /tmp/to.receiver ssh"
+ *   --rsync-path="savetransfer -o /tmp/from.sender rsync" HOST:FILES DEST
+ *
+ * Note that this program aborts after 30 seconds of inactivity, so you'll need
+ * to change it if that is not enough dead time for your transfer.  Also, some
+ * of the above commands will not notice that the transfer is done (if we're
+ * saving the input to a PROGRAM and the PROGRAM goes away:  we won't notice
+ * that it's gone unless more data comes in) -- when this happens it will delay
+ * at the end of the transfer until the timeout period expires.
+ */
+
+#include "../rsync.h"
+
+#define TIMEOUT_SECONDS 30
+
+void run_program(char **command);
+
+char buf[4096];
+int save_data_from_program = 0;
+
+int
+main(int argc, char *argv[])
+{
+    int fd_file, len;
+    struct timeval tv;
+    fd_set fds;
+
+    argv++;
+    if (--argc && argv[0][0] == '-') {
+	if (argv[0][1] == 'o')
+	    save_data_from_program = 1;
+	else if (argv[0][1] == 'i')
+	    save_data_from_program = 0;
+	else {
+	    fprintf(stderr, "Unknown option: %s\n", argv[0]);
+	    exit(1);
+	}
+	argv++;
+	argc--;
+    }
+    if (argc < 2) {
+	fprintf(stderr, "Usage: savetransfer [-i|-o] OUTPUT_FILE PROGRAM [ARGS...]\n");
+	fprintf(stderr, "-i  Save the input going to PROGRAM to the OUTPUT_FILE\n");
+	fprintf(stderr, "-o  Save the output coming from PROGRAM to the OUTPUT_FILE\n");
+	exit(1);
+    }
+    if ((fd_file = open(*argv, O_WRONLY|O_TRUNC|O_CREAT|O_BINARY, 0644)) < 0) {
+	fprintf(stderr, "Unable to write to `%s': %s\n", *argv, strerror(errno));
+	exit(1);
+    }
+    set_blocking(fd_file);
+
+    signal(SIGPIPE, SIG_IGN);
+
+    run_program(argv + 1);
+
+#if defined HAVE_SETMODE && O_BINARY
+    setmode(STDIN_FILENO, O_BINARY);
+    setmode(STDOUT_FILENO, O_BINARY);
+#endif
+    set_nonblocking(STDIN_FILENO);
+    set_blocking(STDOUT_FILENO);
+
+    while (1) {
+	FD_ZERO(&fds);
+	FD_SET(STDIN_FILENO, &fds);
+	tv.tv_sec = TIMEOUT_SECONDS;
+	tv.tv_usec = 0;
+	if (!select(STDIN_FILENO+1, &fds, NULL, NULL, &tv))
+	    break;
+	if (!FD_ISSET(STDIN_FILENO, &fds))
+	    break;
+	if ((len = read(STDIN_FILENO, buf, sizeof buf)) <= 0)
+	    break;
+	if (write(STDOUT_FILENO, buf, len) != len) {
+	    fprintf(stderr, "Failed to write data to stdout: %s\n", strerror(errno));
+	    exit(1);
+	}
+	if (write(fd_file, buf, len) != len) {
+	    fprintf(stderr, "Failed to write data to fd_file: %s\n", strerror(errno));
+	    exit(1);
+	}
+    }
+    return 0;
+}
+
+void
+run_program(char **command)
+{
+    int pipe_fds[2], ret;
+    pid_t pid;
+
+    if (pipe(pipe_fds) < 0) {
+	fprintf(stderr, "pipe failed: %s\n", strerror(errno));
+	exit(1);
+    }
+
+    if ((pid = fork()) < 0) {
+	fprintf(stderr, "fork failed: %s\n", strerror(errno));
+	exit(1);
+    }
+
+    if (pid == 0) {
+	if (save_data_from_program)
+	    ret = dup2(pipe_fds[1], STDOUT_FILENO);
+	else
+	    ret = dup2(pipe_fds[0], STDIN_FILENO);
+	if (ret < 0) {
+	    fprintf(stderr, "Failed to dup (in child): %s\n", strerror(errno));
+	    exit(1);
+	}
+	close(pipe_fds[0]);
+	close(pipe_fds[1]);
+	set_blocking(STDIN_FILENO);
+	set_blocking(STDOUT_FILENO);
+	execvp(command[0], command);
+	fprintf(stderr, "Failed to exec %s: %s\n", command[0], strerror(errno));
+	exit(1);
+    }
+
+    if (save_data_from_program)
+	ret = dup2(pipe_fds[0], STDIN_FILENO);
+    else
+	ret = dup2(pipe_fds[1], STDOUT_FILENO);
+    if (ret < 0) {
+	fprintf(stderr, "Failed to dup (in parent): %s\n", strerror(errno));
+	exit(1);
+    }
+    close(pipe_fds[0]);
+    close(pipe_fds[1]);
+}
+
+void
+set_nonblocking(int fd)
+{
+    int val;
+
+    if ((val = fcntl(fd, F_GETFL, 0)) == -1)
+	return;
+    if (!(val & NONBLOCK_FLAG)) {
+	val |= NONBLOCK_FLAG;
+	fcntl(fd, F_SETFL, val);
+    }
+}
+
+void
+set_blocking(int fd)
+{
+    int val;
+
+    if ((val = fcntl(fd, F_GETFL, 0)) < 0)
+	return;
+    if (val & NONBLOCK_FLAG) {
+	val &= ~NONBLOCK_FLAG;
+	fcntl(fd, F_SETFL, val);
+    }
+}