Initial revision

.cvsignore

+Makefile
+a
+b
+config.cache
+config.h
+config.log
+config.status
+dist.tar.gz
+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-0.8.tar.gz
+rsync-0.9
+rsync-0.9.tar.gz
+rsync-ERSION
+rsync.aux
+rsync.dvi
+rsync.log
+tech_report.aux
+tech_report.dvi
+tech_report.log
+tech_report.ps
+test

.ignore

+.#*
+*.log
+Makefile
+config.h
+*.o
+CVS
+.ignore
+.cvsignore
+*~
+rsync
+config.status
+config.cache
+TAGS
+config.log
+test
+*.gz
+rsync-*
+*.dvi
+*.aux

Makefile.in

+# Makefile for rsync. This is processed by configure to produce the final
+# Makefile
+
+INSTALL_BIN=@prefix@/bin
+INSTALL_MAN=@prefix@/man
+
+CCOPTFLAGS =      -O 
+
+LIBS=@LIBS@
+CC=@CC@ $(CCOPTFLAGS)
+
+INSTALLCMD=@INSTALL@
+
+
+SRC=@srcdir@
+SHELL=/bin/sh
+
+
+.SUFFIXES:
+.SUFFIXES: .c .o
+
+LIBOBJ=lib/getopt.o lib/fnmatch.o 
+OBJS=rsync.o exclude.o util.o md4.o main.o checksum.o match.o flist.o $(LIBOBJ)
+
+.c.o:
+	$(CC) $(CFLAGS) -c $*.c -o $*.o
+
+all: rsync
+
+install: all
+	${INSTALLCMD} -m 755 rsync ${INSTALL_BIN}
+	${INSTALLCMD} -m 644 rsync.1 ${INSTALL_MAN}/man1
+
+rsync: $(OBJS) 
+	$(CC) $(CFLAGS) -o rsync $(OBJS) $(LIBS)
+
+proto:
+	cat *.c | awk -f mkproto.awk > proto.h
+
+clean:
+	rm -f *~ $(OBJS) rsync config.cache config.log config.status
+
+dist: 
+	tar --exclude-from .ignore -czf dist.tar.gz .
+	-mkdir rsync-$(VERSION)
+	(cd rsync-$(VERSION) ; tar xzf ../dist.tar.gz)
+	tar -czf rsync-$(VERSION).tar.gz rsync-$(VERSION)
+	rm -f dist.tar.gz
+	echo rsync-$(VERSION) >> .cvsignore

README

+WHAT IS RSYNC?
+--------------
+
+rsync is a replacement for rcp that has many more features.
+
+rsyns 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.
+At first glance this may seem impossible because the calculation of
+diffs between two files normally requires local access to both
+files. 
+
+A technical report describing the rsync algorithm is included with
+this package.
+
+
+USAGE
+-----
+
+Basically you use rsync just like rcp, but rsync has many additional options.
+
+Here is a brief description of available options:
+
+-v, --verbose            increase verbosity
+-c, --checksum           always checksum
+-a, --archive            archive mode (same as -rlptDog)
+-r, --recursive          recurse into directories
+-b, --backup             make backups (default ~ extension)
+-u, --update             update only (don't overwrite newer files)
+-l, --links              preserve soft 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
+-n, --dry-run            show what would have been transferred
+-x, --one-file-system    don't cross filesystem boundaries
+-B, --block-size SIZE    checksum blocking size
+-e, --rsh COMMAND        specify rsh replacement
+    --rsync-path PATH    specify path to rsync on the remote machine
+-C, --cvs-exclude        auto ignore files in the same way CVS does
+    --delete             delete files that don't exist on the sending side
+-I, --ignore-times       don't exclude files that match length and time
+    --exclude FILE       exclude file FILE
+    --exclude-from FILE  exclude files listed in FILE
+    --suffix SUFFIX      override backup suffix
+    --version            print version number
+
+
+
+SETUP
+-----
+
+Rsync uses rsh or ssh for communication. It does not need to be setuid
+and requires no special privilages for installation. It does not
+require a inetd entry or a daemon. You must, however, have a working
+rsh or ssh system. Using ssh is recommended for its security and
+compression features.
+
+To install rsync, first run the "configure" script. This will create a
+Makefile and config.h appropriate for your system. Then type
+"make". 
+
+Once built put a copy of rsync in your search path on the local and
+remote systems (or use "make install"). That's it!
+
+
+COPYRIGHT
+---------
+
+Rsync was written by Andrew Tridgell and Paul Mackerras, and is
+available under the GPL.
+
+Andrew.Tridgell@anu.edu.au
+paulus@cs.anu.edu.au
+
+
+AVAILABILITY
+------------
+
+The main ftp site for rsync is ftp://samba.anu.edu.au/pub/rsync

byteorder.h

+/* 
+   simple byteorder handling
+   Copyright (C) Andrew Tridgell 1992-1995
+   
+   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.
+*/
+
+#undef CAREFUL_ALIGNMENT
+
+/* we know that the x86 can handle misalignment and has the "right" 
+   byteorder */
+#ifdef __i386__
+#define CAREFUL_ALIGNMENT 0
+#endif
+
+#ifndef CAREFUL_ALIGNMENT
+#define CAREFUL_ALIGNMENT 1
+#endif
+
+#define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
+#define PVAL(buf,pos) ((unsigned)CVAL(buf,pos))
+#define SCVAL(buf,pos,val) (CVAL(buf,pos) = (val))
+
+
+#if CAREFUL_ALIGNMENT
+#define SVAL(buf,pos) (PVAL(buf,pos)|PVAL(buf,(pos)+1)<<8)
+#define IVAL(buf,pos) (SVAL(buf,pos)|SVAL(buf,(pos)+2)<<16)
+#define SSVALX(buf,pos,val) (CVAL(buf,pos)=(val)&0xFF,CVAL(buf,pos+1)=(val)>>8)
+#define SIVALX(buf,pos,val) (SSVALX(buf,pos,val&0xFFFF),SSVALX(buf,pos+2,val>>16))
+#define SIVAL(buf,pos,val) SIVALX((buf),(pos),((uint32)(val)))
+#else
+/* this handles things for architectures like the 386 that can handle
+   alignment errors */
+/*
+   WARNING: This section is dependent on the length of int32
+   being correct. set CAREFUL_ALIGNMENT if it is not.
+*/
+#define IVAL(buf,pos) (*(uint32 *)((char *)(buf) + (pos)))
+#define SIVAL(buf,pos,val) IVAL(buf,pos)=((uint32)(val))
+#endif
+
+

checksum.c

+/* 
+   Copyright (C) Andrew Tridgell 1996
+   Copyright (C) Paul Mackerras 1996
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "rsync.h"
+
+
+/*
+  a simple 32 bit checksum that can be upadted from either end
+  (inspired by Mark Adler's Adler-32 checksum)
+  */
+uint32 get_checksum1(char *buf,int len)
+{
+    int i;
+    uint32 s1, s2;
+
+    s1 = s2 = 0;
+    for (i = 0; i < len; i++) {
+	s1 += buf[i];
+	s2 += s1;
+    }
+    return (s1 & 0xffff) + (s2 << 16);
+}
+
+
+void get_checksum2(char *buf,int len,char *sum)
+{
+  char buf2[64];
+  int i;
+  MDstruct MD;
+
+  MDbegin(&MD);
+  for(i = 0; i + 64 <= len; i += 64) {
+    bcopy(buf+i,buf2,64);
+    MDupdate(&MD, buf2, 512);
+  }
+  bcopy(buf+i,buf2,len-i);
+  MDupdate(&MD, buf2, (len-i)*8);
+  SIVAL(sum,0,MD.buffer[0]);
+  SIVAL(sum,4,MD.buffer[1]);
+  SIVAL(sum,8,MD.buffer[2]);
+  SIVAL(sum,12,MD.buffer[3]);
+}
+
+void file_checksum(char *fname,char *sum,off_t size)
+{
+  char *buf;
+  int fd;
+  bzero(sum,SUM_LENGTH);
+
+  fd = open(fname,O_RDONLY);
+  if (fd == -1) return;
+
+  buf = map_file(fd,size);
+  if (!buf) {
+    close(fd);
+    return;
+  }
+
+  get_checksum2(buf,size,sum);
+  close(fd);
+  unmap_file(buf,size);
+}

configure.in

+dnl Process this file with autoconf to produce a configure script.
+AC_INIT(byteorder.h)
+AC_CONFIG_HEADER(config.h)
+
+dnl Checks for programs.
+AC_PROG_CC
+AC_PROG_INSTALL
+AC_SUBST(SHELL)
+
+AC_HEADER_DIRENT
+AC_HEADER_STDC
+AC_HEADER_TIME
+AC_HEADER_SYS_WAIT
+AC_CHECK_HEADERS(sys/fcntl.h fcntl.h sys/time.h unistd.h utime.h grp.h)
+AC_CHECK_HEADERS(compat.h sys/param.h ctype.h sys/wait.h)
+
+AC_CHECK_SIZEOF(int)
+AC_CHECK_SIZEOF(long)
+AC_CHECK_SIZEOF(short)
+
+AC_C_INLINE
+
+AC_TYPE_SIGNAL
+AC_TYPE_UID_T
+AC_TYPE_MODE_T
+AC_TYPE_OFF_T
+AC_TYPE_SIZE_T
+AC_TYPE_PID_T
+AC_STRUCT_ST_RDEV
+
+echo -n "checking for errno in errno.h... "
+AC_TRY_COMPILE([#include <errno.h>],[int i = errno],
+echo yes; AC_DEFINE(HAVE_ERRNO_DECL),
+echo no)
+
+AC_FUNC_MEMCMP
+AC_FUNC_MMAP
+AC_FUNC_UTIME_NULL
+AC_CHECK_FUNCS(waitpid strtok pipe getcwd mkdir strdup strerror chown chmod mknod)
+AC_CHECK_FUNCS(fchmod fstat strchr bcopy bzero readlink utime utimes getopt_long)
+
+echo -n "checking for working fnmatch... "
+AC_TRY_RUN([#include <fnmatch.h>
+main() { exit(fnmatch("*.o", "x.o", 0) == 0? 0: 1); }],
+echo yes;AC_DEFINE(HAVE_FNMATCH), 
+echo no)
+
+AC_OUTPUT(Makefile)

exclude.c

+/* 
+   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.
+*/
+
+/*
+  a lot of this stuff was derived from GNU tar
+  */
+
+#include "rsync.h"
+
+extern int verbose;
+
+static char **exclude_list = NULL;
+
+static int is_regex(char *str)
+{
+  return strchr(str, '*') || strchr(str, '[') || strchr(str, '?');
+}
+
+
+static int check_one_exclude(char *name,char *pattern)
+{
+  char *str;
+  char *p;
+
+  if (!strchr(pattern,'/') && (p=strrchr(name,'/')))
+    name = p+1;
+
+  if (!name[0]) return 0;
+
+  if (is_regex(pattern)) {
+    if (fnmatch(pattern, name, 0) == 0)
+      return 1;
+  } else {
+    int l1 = strlen(name);
+    int l2 = strlen(pattern);
+    if (l2 <= l1 && 
+	strcmp(name+(l1-l2),pattern) == 0 &&
+	(l1==l2 || name[l1-(l2+1)] == '/'))
+      return 1;
+  }
+
+  return 0;
+}
+
+
+int check_exclude(char *name,char **local_exclude_list)
+{
+  int n;
+
+  if (exclude_list) {
+    for (n=0; exclude_list[n]; n++)
+      if (check_one_exclude(name,exclude_list[n]))
+	return 1;
+  }
+
+  if (local_exclude_list) {
+    for (n=0; local_exclude_list[n]; n++)
+      if (check_one_exclude(name,local_exclude_list[n]))
+	return 1;      
+  }
+
+  return 0;
+}
+
+
+void add_exclude_list(char *pattern,char ***list)
+{
+  int len=0;
+  if (list && *list)
+    for (; (*list)[len]; len++) ;
+
+  if (strcmp(pattern,"!") == 0) {
+    if (verbose > 2)
+      fprintf(stderr,"clearing exclude list\n");
+    while ((len)--) 
+      free((*list)[len]);
+    free((*list));
+    *list = NULL;
+    return;
+  }
+
+  if (!*list) {
+    *list = (char **)malloc(sizeof(char *)*2);
+  } else {
+    *list = (char **)realloc(*list,sizeof(char *)*(len+2));
+  }
+
+  if (!*list || !((*list)[len] = strdup(pattern)))
+    out_of_memory("add_exclude");
+
+  if (verbose > 2)
+    fprintf(stderr,"add_exclude(%s)\n",pattern);
+  
+  (*list)[len+1] = NULL;
+}
+
+void add_exclude(char *pattern)
+{
+  add_exclude_list(pattern,&exclude_list);
+}
+
+char **make_exclude_list(char *fname,char **list1,int fatal)
+{
+  char **list=list1;
+  FILE *f = fopen(fname,"r");
+  char line[MAXPATHLEN];
+  if (!f) {
+    if (fatal) {
+      fprintf(stderr,"%s : %s\n",fname,strerror(errno));
+      exit(1);
+    }
+    return list;
+  }
+
+  while (fgets(line,MAXPATHLEN,f)) {
+    int l = strlen(line);
+    if (l && line[l-1] == '\n') l--;
+    line[l] = 0;
+    if (line[0]) add_exclude_list(line,&list);
+  }
+  fclose(f);
+  return list;
+}
+
+
+void add_exclude_file(char *fname,int fatal)
+{
+  exclude_list = make_exclude_list(fname,exclude_list,fatal);
+}
+
+
+void send_exclude_list(int f)
+{
+  int i;
+  if (exclude_list) 
+    for (i=0;exclude_list[i];i++) {
+      int l = strlen(exclude_list[i]);
+      if (l == 0) continue;
+      write_int(f,l);
+      write_buf(f,exclude_list[i],l);
+    }    
+  write_int(f,0);
+}
+
+
+void recv_exclude_list(int f)
+{
+  char line[MAXPATHLEN];
+  int l;
+  while ((l=read_int(f))) {
+    read_buf(f,line,l);
+    line[l] = 0;
+    add_exclude(line);
+  }
+}
+
+
+static char *cvs_ignore_list[] = {
+  "RCS","SCCS","CVS","CVS.adm","RCSLOG","cvslog.*",
+  "tags","TAGS",".make.state",".nse_depinfo",
+  "*~", "#*", ".#*", ",*", "*.old", "*.bak", "*.BAK", "*.orig",
+  "*.rej", ".del-*", "*.a", "*.o", "*.obj", "*.so", "*.Z", "*.elc", "*.ln",
+  "core",NULL};
+
+
+
+void add_cvs_excludes(void)
+{
+  char fname[MAXPATHLEN];
+  char *p;
+  int i;
+  
+  for (i=0; cvs_ignore_list[i]; i++)
+    add_exclude(cvs_ignore_list[i]);
+
+  if ((p=getenv("HOME"))) {
+    sprintf(fname,"%s/.cvsignore",p);
+    add_exclude_file(fname,0);
+  }
+
+  if ((p=getenv("CVSIGNORE"))) {
+    char *tok;
+    for (tok=strtok(p," "); tok; tok=strtok(NULL," "))
+      add_exclude(tok);
+  }
+}

install-sh

+#! /bin/sh
+#
+# install - install a program, script, or datafile
+# This comes from X11R5.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+#
+
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit="${DOITPROG-}"
+
+
+# put in absolute paths if you don't have them in your path; or use env. vars.
+
+mvprog="${MVPROG-mv}"
+cpprog="${CPPROG-cp}"
+chmodprog="${CHMODPROG-chmod}"
+chownprog="${CHOWNPROG-chown}"
+chgrpprog="${CHGRPPROG-chgrp}"
+stripprog="${STRIPPROG-strip}"
+rmprog="${RMPROG-rm}"
+mkdirprog="${MKDIRPROG-mkdir}"
+
+transformbasename=""
+transform_arg=""
+instcmd="$mvprog"
+chmodcmd="$chmodprog 0755"
+chowncmd=""
+chgrpcmd=""
+stripcmd=""
+rmcmd="$rmprog -f"
+mvcmd="$mvprog"
+src=""
+dst=""
+dir_arg=""
+
+while [ x"$1" != x ]; do
+    case $1 in
+	-c) instcmd="$cpprog"
+	    shift
+	    continue;;
+
+	-d) dir_arg=true
+	    shift
+	    continue;;
+
+	-m) chmodcmd="$chmodprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-o) chowncmd="$chownprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-g) chgrpcmd="$chgrpprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-s) stripcmd="$stripprog"
+	    shift
+	    continue;;
+
+	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
+	    shift
+	    continue;;
+
+	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
+	    shift
+	    continue;;
+
+	*)  if [ x"$src" = x ]
+	    then
+		src=$1
+	    else
+		# this colon is to work around a 386BSD /bin/sh bug
+		:
+		dst=$1
+	    fi
+	    shift
+	    continue;;
+    esac
+done
+
+if [ x"$src" = x ]
+then
+	echo "install:	no input file specified"
+	exit 1
+else
+	true
+fi
+
+if [ x"$dir_arg" != x ]; then
+	dst=$src
+	src=""
+	
+	if [ -d $dst ]; then
+		instcmd=:
+	else
+		instcmd=mkdir
+	fi
+else
+
+# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
+# might cause directories to be created, which would be especially bad 
+# if $src (and thus $dsttmp) contains '*'.
+
+	if [ -f $src -o -d $src ]
+	then
+		true
+	else
+		echo "install:  $src does not exist"
+		exit 1
+	fi
+	
+	if [ x"$dst" = x ]
+	then
+		echo "install:	no destination specified"
+		exit 1
+	else
+		true
+	fi
+
+# If destination is a directory, append the input filename; if your system
+# does not like double slashes in filenames, you may need to add some logic
+
+	if [ -d $dst ]
+	then
+		dst="$dst"/`basename $src`
+	else
+		true
+	fi
+fi
+
+## this sed command emulates the dirname command
+dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
+
+# Make sure that the destination directory exists.
+#  this part is taken from Noah Friedman's mkinstalldirs script
+
+# Skip lots of stat calls in the usual case.
+if [ ! -d "$dstdir" ]; then
+defaultIFS='	
+'
+IFS="${IFS-${defaultIFS}}"
+
+oIFS="${IFS}"
+# Some sh's can't handle IFS=/ for some reason.
+IFS='%'
+set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
+IFS="${oIFS}"
+
+pathcomp=''
+
+while [ $# -ne 0 ] ; do
+	pathcomp="${pathcomp}${1}"
+	shift
+
+	if [ ! -d "${pathcomp}" ] ;
+        then
+		$mkdirprog "${pathcomp}"
+	else
+		true
+	fi
+
+	pathcomp="${pathcomp}/"
+done
+fi
+
+if [ x"$dir_arg" != x ]
+then
+	$doit $instcmd $dst &&
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
+else
+
+# If we're going to rename the final executable, determine the name now.
+
+	if [ x"$transformarg" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		dstfile=`basename $dst $transformbasename | 
+			sed $transformarg`$transformbasename
+	fi
+
+# don't allow the sed command to completely eliminate the filename
+
+	if [ x"$dstfile" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		true
+	fi
+
+# Make a temp file name in the proper directory.
+
+	dsttmp=$dstdir/#inst.$$#
+
+# Move or copy the file name to the temp name
+
+	$doit $instcmd $src $dsttmp &&
+
+	trap "rm -f ${dsttmp}" 0 &&
+
+# and set any options; do chmod last to preserve setuid bits
+
+# If any of these fail, we abort the whole thing.  If we want to
+# ignore errors from any of these, just make sure not to ignore
+# errors from the above "$doit $instcmd $src $dsttmp" command.
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
+
+# Now rename the file to the real destination.
+
+	$doit $rmcmd -f $dstdir/$dstfile &&
+	$doit $mvcmd $dsttmp $dstdir/$dstfile 
+
+fi &&
+
+
+exit 0

lib/.cvsignore

+Makefile
+a
+b
+config.cache
+config.h
+config.log
+config.status
+dist.tar.gz
+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-ERSION
+rsync.aux
+rsync.dvi
+rsync.log
+tech_report.aux
+tech_report.dvi
+tech_report.log
+tech_report.ps
+test
+rsync-0.6
+rsync-0.7
+rsync-0.7
+rsync-0.8
+rsync-0.8
+rsync-0.8
+rsync-0.8

lib/fnmatch.c

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

lib/fnmatch.h

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

lib/getopt.h

+/* 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 */

match.c

+/* 
+   Copyright (C) Andrew Tridgell 1996
+   Copyright (C) Paul Mackerras 1996
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "rsync.h"
+
+extern int verbose;
+extern int am_server;
+
+typedef unsigned short tag;
+
+#define TABLESIZE (1<<16)
+#define NULL_TAG ((tag)-1)
+
+static int false_alarms;
+static int tag_hits;
+static int matches;
+static int data_transfer;
+
+static int total_false_alarms=0;
+static int total_tag_hits=0;
+static int total_matches=0;
+static int total_data_transfer=0;
+
+
+struct target {
+  tag t;
+  int i;
+};
+
+static struct target *targets=NULL;
+
+static tag *tag_table = NULL;
+
+#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(t1->t - t2->t);
+}
+
+
+static void build_hash_table(struct sum_struct *s)
+{
+  int i;
+
+  if (!tag_table)
+    tag_table = (tag *)malloc(sizeof(tag)*TABLESIZE);
+
+  targets = (struct target *)malloc(sizeof(targets[0])*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);
+  }
+
+  qsort(targets,s->count,sizeof(targets[0]),(int (*)())compare_targets);
+
+  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;
+  }
+}
+
+
+
+static off_t last_match;
+
+
+static void matched(int f,struct sum_struct *s,char *buf,off_t len,int offset,int i)
+{
+  int n = offset - last_match;
+  
+  if (verbose > 2)
+    if (i != -1)
+      fprintf(stderr,"match at %d last_match=%d j=%d len=%d n=%d\n",
+	      (int)offset,(int)last_match,i,(int)s->sums[i].len,n);
+
+  if (n > 0) {
+    write_int(f,n);
+    write_buf(f,buf+last_match,n);
+    data_transfer += n;
+  }
+  write_int(f,-(i+1));
+  if (i != -1)
+    last_match = offset + s->sums[i].len;
+  if (n > 0)
+    write_flush(f);
+}
+
+
+static void hash_search(int f,struct sum_struct *s,char *buf,off_t len)
+{
+  int offset,j,k;
+  int end;
+  char sum2[SUM_LENGTH];
+  uint32 s1, s2, sum;
+
+  if (verbose > 2)
+    fprintf(stderr,"hash search b=%d len=%d\n",s->n,(int)len);
+
+  k = MIN(len, s->n);
+  sum = get_checksum1(buf, k);
+  s1 = sum & 0xFFFF;
+  s2 = sum >> 16;
+  if (verbose > 3)
+    fprintf(stderr, "sum=%.8x k=%d\n", sum, k);
+
+  offset = 0;
+
+  end = len + 1 - s->sums[s->count-1].len;
+
+  if (verbose > 3)
+    fprintf(stderr,"hash search s->n=%d len=%d count=%d\n",
+	    s->n,(int)len,s->count);
+
+  do {
+    tag t = gettag2(s1,s2);
+    j = tag_table[t];
+    if (verbose > 4)
+      fprintf(stderr,"offset=%d sum=%08x\n",
+	      offset,sum);
+
+    if (j != NULL_TAG) {
+      int done_csum2 = 0;
+
+      sum = (s1 & 0xffff) | (s2 << 16);
+      tag_hits++;
+      do {
+	int i = targets[j].i;
+
+	if (sum == s->sums[i].sum1) {
+	  if (verbose > 3)
+	    fprintf(stderr,"potential match at %d target=%d %d sum=%08x\n",
+		    offset,j,i,sum);
+
+	  if (!done_csum2) {
+	    get_checksum2(buf+offset,MIN(s->n,len-offset),sum2);
+	    done_csum2 = 1;
+	  }
+	  if (memcmp(sum2,s->sums[i].sum2,SUM_LENGTH) == 0) {
+	    matched(f,s,buf,len,offset,i);
+	    offset += s->sums[i].len - 1;
+	    k = MIN((len-offset), s->n);
+	    sum = get_checksum1(buf+offset, k);
+	    s1 = sum & 0xFFFF;
+	    s2 = sum >> 16;
+	    ++matches;
+	    break;
+	  } else {
+	    false_alarms++;
+	  }
+	}
+	j++;
+      } while (j<s->count && targets[j].t == t);
+    }
+
+    /* Trim off the first byte from the checksum */
+    s1 -= buf[offset];
+    s2 -= k * buf[offset];
+
+    /* Add on the next byte (if there is one) to the checksum */
+    if (k < (len-offset)) {
+      s1 += buf[offset+k];
+      s2 += s1;
+    } else {
+      --k;
+    }
+
+    if (verbose > 3) 
+      fprintf(stderr,"s2:s1 = %.4x%.4x sum=%.8x k=%d offset=%d took %x added %x\n",
+	      s2&0xffff, s1&0xffff, get_checksum1(buf+offset+1,k),
+	      k, (int)offset, buf[offset], buf[offset+k]);
+  } while (++offset < end);
+
+  matched(f,s,buf,len,len,-1);
+}
+
+
+void match_sums(int f,struct sum_struct *s,char *buf,off_t len)
+{
+  last_match = 0;
+  false_alarms = 0;
+  tag_hits = 0;
+  matches=0;
+  data_transfer=0;
+
+  if (len > 0 && s->count>0) {
+    build_hash_table(s);
+
+    if (verbose > 2) 
+      fprintf(stderr,"built hash table\n");
+
+    hash_search(f,s,buf,len);
+
+    if (verbose > 2) 
+      fprintf(stderr,"done hash search\n");
+  } else {
+    matched(f,s,buf,len,len,-1);
+  }
+
+  if (targets) {
+    free(targets);
+    targets=NULL;
+  }
+
+  if (verbose > 2)
+    fprintf(stderr, "false_alarms=%d tag_hits=%d matches=%d\n",
+	    false_alarms, tag_hits, matches);
+
+  total_tag_hits += tag_hits;
+  total_false_alarms += false_alarms;
+  total_matches += matches;
+  total_data_transfer += data_transfer;
+}
+
+void match_report(void)
+{
+  if (verbose <= 1)
+    return;
+
+  fprintf(am_server?stderr:stdout,
+	  "total: matches=%d  tag_hits=%d  false_alarms=%d  data=%d\n",
+	  total_matches,total_tag_hits,
+	  total_false_alarms,total_data_transfer);
+}

md4.c

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

md4.h

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

mkproto.awk

+# generate prototypes for Samba C code
+# tridge, June 1996
+
+BEGIN {
+  inheader=0;
+  print "/* This file is automatically generated with \"make proto\". DO NOT EDIT */"
+  print ""
+}
+
+{
+  if (inheader) {
+    if (match($0,"[)][ \t]*$")) {
+      inheader = 0;
+      printf "%s;\n",$0;
+    } else {
+      printf "%s\n",$0;
+    }
+    next;
+  }
+}
+
+/^static|^extern/ || !/^[a-zA-Z]/ || /[;]/ {
+  next;
+}
+
+!/^off_t|^unsigned|^mode_t|^DIR|^user|^int|^char|^uint|^struct|^BOOL|^void|^time/ {
+  next;
+}
+
+
+/[(].*[)][ \t]*$/ {
+    printf "%s;\n",$0;
+    next;
+}
+
+/[(]/ {
+  inheader=1;
+  printf "%s\n",$0;
+  next;
+}
+

version.h

+#define VERSION "0.9"