This commit was manufactured by cvs2svn to create tag 'r0-11-5'.

git-svn-id: http://svn.savannah.nongnu.org/svn/rdiff-backup@323 2b77aa54-bcbc-44c9-a7ec-4f6cf2b41109

tags/r0-11-5/rdiff-backup/CVS-README

+CVS README - Notes for people checking out of CVS
+-------------------------------------------------
+
+Getting rdiff-backup to run:
+----------------------------
+
+If you want to run a version of rdiff-backup checked out of CVS into
+your $RDB_CVS directory, change to $RDB_CVS/rdiff_backup and run the
+./compilec.py file:
+
+    cd $RDB_CVS/rdiff_backup; python compilec.py
+
+With any luck, _librsync.so and C.so libraries will appear in that
+directory.  Then run rdiff-backup, making sure that all the files are
+in your PYTHONPATH:
+
+    PYTHONPATH=$RDB_CVS $RDB_CVS/rdiff-backup <arguments>
+
+
+Running the unit tests:
+-----------------------
+
+If you want to try some of tests, you first have to get the
+testfiles.tar.gz tarball.  It is available at
+
+http://rdiff-backup.stanford.edu/testfiles.tar.gz
+
+To untar it, root is required because the tarball contains device
+files, files with various uid/gid, etc.  If you don't have root, it's
+ok, all the tests except for roottest.py may still work.
+
+So, three steps:
+
+1) Make sure the the C modules are compiled as explained above:
+
+    cd $RDB_CVS/rdiff_backup; python compilec.py
+
+2) Untar the testfiles tarball, as root if you have it:
+
+    cd $RDB_CVS/testing; tar -xvzf testfiles.tar.gz
+
+3) In the testing directory, run each of the *test.py files as
+   desired.  For instance,
+
+    cd $RDB_CVS/testing; python rpathtest.py
+
+   If python restoretest.py doesn't work, try running
+   ./makerestoretest3
+

tags/r0-11-5/rdiff-backup/README

+INSTALLATION:
+
+Thank you for trying rdiff-backup.  To install, run:
+
+	python setup.py install
+
+The build process can be also be run separately:
+
+	python setup.py build
+
+The default prefix is /usr, so files are put in /usr/bin,
+/usr/share/man/, etc.  An alternate prefix can be specified using the
+--prefix=<prefix> option.  For example:
+
+	python setup.py install --prefix=/usr/local
+
+A few special build arguments can be specified such as --librsync-dir,
+--lflags, and --libs, and the LIBRSYNC_DIR, LFLAGS, and LIBS
+environment variables will also be used.  Running setup.py with no
+arguments will also display some help.
+
+
+REQUIREMENTS:
+
+Remember that you must have Python 2.2 or later and librsync 0.9.5.1
+or later installed.  For Python, see http://www.python.org.  The
+rdiff-backup homepage at http://rdiff-backup.stanford.edu/ should have
+a recent version of librsync; otherwise see the librsync homepage at
+http://sourceforge.net/projects/librsync/.
+
+For remote operation, rdiff-backup should be in installed and in the
+PATH on remote system(s) (see man page for more information).
+
+
+TROUBLESHOOTING:
+
+If you have everything installed properly, and it still doesn't work,
+see the enclosed FAQ.html, the web page at
+http://rdiff-backup.stanford.edu, and/or the mailing list.
+

tags/r0-11-5/rdiff-backup/TODO

+Make restores tolerant of missing files
+
+Added --include/--exclude options for restoring
+
+---------[ Medium term ]---------------------------------------
+
+Look into security.py code, do some sort of security audit.
+
+Don't require increments.<date>.dir files to be setuid/setgid, or
+don't even have the backup files. (Andrew Bressen)
+
+Examine default settings with --windows-mode
+
+Look at Kent Borg's suggestion for restore options and digests.
+
+Add --list-files-changed-between or similar option, to list files that
+have changed between two times
+
+Add ACL support
+
+Add --dry-run option (target for v1.1.x)
+
+Add # of increments option to --remove-older-than
+
+Make argument shortcut for cstream
+
+Write configuration file, to make sure settings like --quoting-char,
+--windows-time-format, etc., don't change between sessions,
+backup/restoring, etc.
+
+---------[ Long term ]---------------------------------------
+
+Think about adding Gaudet's idea for keeping track of renamed files.
+
+Look into different inode generation techniques (see treescan, Dean
+Gaudet's other post).
+
+

tags/r0-11-5/rdiff-backup/dist/makedist

+#!/usr/bin/env python
+
+import os, re, shutil, time, sys, getopt
+
+SourceDir = "rdiff_backup"
+DistDir = "dist"
+
+# Various details about the files must also be specified by the rpm
+# spec template.
+spec_template = "dist/rdiff-backup.spec"
+#redhat_spec_template = "dist/rdiff-backup.rh7x.spec"
+
+def CopyMan(destination, version):
+	"""Create updated man page at the specified location"""
+	fp = open(destination, "w")
+	date = time.strftime("%B %Y", time.localtime(time.time()))
+	version = "Version "+version
+	firstline = ('.TH RDIFF-BACKUP 1 "%s" "%s" "User Manuals"\n' %
+				 (date, version))
+	fp.write(firstline)
+	infp = open("rdiff-backup.1", "r")
+	infp.readline()
+	fp.write(infp.read())
+	fp.close()
+	infp.close()
+
+def MakeFAQ():
+	"""Create FAQ.html and FAQ.wml files from FAQ-body.html"""
+	faqbody_fp = open("FAQ-body.html", "r")
+	faqbody_string = faqbody_fp.read()
+	faqbody_fp.close()
+
+	wml_fp = open("FAQ.wml", "w")
+	wml_fp.write(
+"""#include 'template.wml' home=. curpage=faq title="rdiff-backup: FAQ"
+
+<divert body>
+<p><h2>FAQ:</h2>
+
+""")
+	wml_fp.write(faqbody_string)
+	wml_fp.write("\n</divert>\n")
+	wml_fp.close()
+
+	html_fp = open("FAQ.html", "w")
+	html_fp.write(
+"""<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html>
+  <head>
+    <title>rdiff-backup FAQ</title>
+  </head>
+
+  <body>
+  <h1>rdiff-backup FAQ</h1>
+""")
+	html_fp.write(faqbody_string)
+	html_fp.write("\n</body></html>")
+	html_fp.close()
+
+def VersionedCopy(source, dest):
+	"""Copy source to dest, substituting $version with version"""
+	fin = open(source, "rb")
+	inbuf = fin.read()
+	assert not fin.close()
+
+	outbuf = re.sub("\$version", Version, inbuf, 1)
+	if outbuf == inbuf: assert 0, "No $version string replaced"
+	assert not re.search("\$version", outbuf), \
+		   "Two $version strings found in the same file %s" % (source,)
+
+	fout = open(dest, "wb")
+	fout.write(outbuf)
+	assert not fout.close()
+
+def MakeTar():
+	"""Create rdiff-backup tar file"""
+	tardir = "rdiff-backup-%s" % Version
+	tarfile = "rdiff-backup-%s.tar.gz" % Version
+	try:
+		os.lstat(tardir)
+		os.system("rm -rf " + tardir)
+	except OSError: pass
+	os.mkdir(tardir)
+	for filename in ["CHANGELOG", "COPYING", "README", "FAQ.html",
+					 SourceDir + "/cmodule.c",
+					 SourceDir + "/_librsyncmodule.c",
+					 DistDir + "/setup.py"]:
+		assert not os.system("cp %s %s" % (filename, tardir)), filename
+
+	os.mkdir(tardir+"/rdiff_backup")
+	for filename in ["backup.py", "connection.py",
+					 "FilenameMapping.py", "Hardlink.py",
+					 "increment.py", "__init__.py", "iterfile.py",
+					 "lazy.py", "librsync.py", "log.py", "Main.py",
+					 "manage.py", "metadata.py", "Rdiff.py",
+					 "regress.py", "restore.py", "robust.py",
+					 "rorpiter.py", "rpath.py", "Security.py",
+					 "selection.py", "SetConnections.py", "static.py",
+					 "statistics.py", "TempFile.py", "Time.py"]:
+		assert not os.system("cp %s/%s %s/rdiff_backup" %
+							 (SourceDir, filename, tardir)), filename
+
+	VersionedCopy("%s/Globals.py" % (SourceDir,),
+				  "%s/rdiff_backup/Globals.py" % (tardir,))
+	VersionedCopy("rdiff-backup", "%s/rdiff-backup" % (tardir,))
+	VersionedCopy(DistDir + "/setup.py", "%s/setup.py" % (tardir,))
+
+	os.chmod(os.path.join(tardir, "setup.py"), 0755)
+	os.chmod(os.path.join(tardir, "rdiff-backup"), 0644)
+	CopyMan(os.path.join(tardir, "rdiff-backup.1"), Version)
+	os.system("tar -cvzf %s %s" % (tarfile, tardir))
+	shutil.rmtree(tardir)
+	return tarfile
+
+def MakeSpecFile():
+	"""Create spec file using spec template"""
+	specfile = "rdiff-backup-%s-2.spec" % Version
+	VersionedCopy(spec_template, specfile)
+	return specfile
+
+def parse_cmdline(arglist):
+	"""Returns action"""
+	global Version
+	def error():
+		print "Syntax: makedist [--faq-only] [version_number]"
+		sys.exit(1)		
+
+	optlist, args = getopt.getopt(arglist, "", ["faq-only"])
+	if len(args) != 1: error()
+	else: Version = args[0]
+
+	for opt, arg in optlist:
+		if opt == "--faq-only": return "FAQ"
+		else: assert 0, "Bad argument"
+	return "All"
+
+def Main():
+	action = parse_cmdline(sys.argv[1:])
+	print "Making FAQ"
+	MakeFAQ()
+
+	if action != "FAQ":
+		assert action == "All"
+		print "Processing version " + Version
+		tarfile = MakeTar()
+		print "Made tar file " + tarfile
+		specfile = MakeSpecFile()
+		print "Made specfile ", specfile
+
+
+if __name__ == "__main__" and not globals().has_key('__no_execute__'):
+	Main()
+

tags/r0-11-5/rdiff-backup/dist/makerpm

+#!/usr/bin/env python
+
+import os, sys, re
+
+rpmroot = "/home/ben/rpm"
+
+if len(sys.argv) == 2:
+	version = sys.argv[1]
+	specfile = "rdiff-backup-%s-2.spec" % version
+	print "Using specfile %s" % specfile
+else:
+	print "Syntax:  %s version_number" % sys.argv[0]
+	sys.exit(1)
+
+base = ".".join(specfile.split(".")[:-1])
+srcrpm = base+".src.rpm"
+i386rpm = base+".i386.rpm"
+source_rpm = base+".src.rpm"
+tarfile = "-".join(base.split("-")[:-1]) + ".tar.gz"
+
+# These assume the rpm root directory $HOME/rpm.  The
+# nonstandard location allows for building by non-root user.
+assert not os.system("cp %s %s/SOURCES" % (tarfile, rpmroot))
+#assert not os.system("rpm -ba --sign -vv --target i386 " + specfile)
+assert not os.system("rpmbuild -ba -v --sign " + specfile)
+assert not os.system("mv %s/RPMS/i386/%s ." % (rpmroot, i386rpm))
+assert not os.system("mv %s/SRPMS/%s ." % (rpmroot, source_rpm))
+

tags/r0-11-5/rdiff-backup/dist/makeweb

+#!/usr/bin/env python
+
+import sys, os
+
+def RunCommand(cmd):
+	print cmd
+	os.system(cmd)
+
+webprefix = "/home/ben/misc/html/mirror/rdiff-backup/"
+
+if not sys.argv[1:]:
+	print 'Call with version number, as in "./makeweb 0.3.1"'
+	print "to move new rpms and tarballs.  Now just remaking FAQ and man page."
+	print
+else:
+	version = sys.argv[1]
+	RunCommand("cp *%s* %s" % (version, webprefix))
+
+RunCommand("rman -f html -r '' rdiff-backup.1 > %srdiff-backup.1.html"
+		   % webprefix)
+RunCommand("cp FAQ.wml CHANGELOG %s" % webprefix)
+
+
+os.chdir(webprefix)
+print "cd ", webprefix
+if sys.argv[1:]:
+	RunCommand("rm latest latest.rpm latest.tar.gz")
+	RunCommand("ln -s *%s*rpm latest.rpm" % (version,))
+	RunCommand("ln -s *%s*tar.gz latest.tar.gz" % (version,))
+RunCommand("./Make")

tags/r0-11-5/rdiff-backup/dist/rdiff-backup-rh7x.patch

+--- rdiff-backup.old	Sat Apr  6 10:05:18 2002
++++ rdiff-backup	Sat Apr  6 10:05:25 2002
+@@ -1,4 +1,4 @@
+-#!/usr/bin/env python
++#!/usr/bin/env python2
+ #
+ # rdiff-backup -- Mirror files while keeping incremental changes
+ # Version 0.7.1 released March 25, 2002

tags/r0-11-5/rdiff-backup/dist/rdiff-backup.rh7x.spec

+Summary: Convenient and transparent local/remote incremental mirror/backup
+Name: rdiff-backup
+Release: 1
+URL: http://www.stanford.edu/~bescoto/rdiff-backup/
+Source: %{name}-%{version}.tar.gz
+Copyright: GPL
+Group: Applications/Archiving
+BuildRoot: %{_tmppath}/%{name}-root
+requires: librsync, python2 >= 2.2
+Patch: rdiff-backup-rh7x.patch
+
+%description
+rdiff-backup is a script, written in Python, that backs up one
+directory to another and is intended to be run periodically (nightly
+from cron for instance). The target directory ends up a copy of the
+source directory, but extra reverse diffs are stored in the target
+directory, so you can still recover files lost some time ago. The idea
+is to combine the best features of a mirror and an incremental
+backup. rdiff-backup can also operate in a bandwidth efficient manner
+over a pipe, like rsync. Thus you can use rdiff-backup and ssh to
+securely back a hard drive up to a remote location, and only the
+differences from the previous backup will be transmitted.
+
+%prep
+%setup
+%patch
+%build
+
+%install
+rm -rf $RPM_BUILD_ROOT
+mkdir -p $RPM_BUILD_ROOT/usr/bin
+mkdir -p $RPM_BUILD_ROOT/usr/share/man/man1
+
+install -m 755 rdiff-backup $RPM_BUILD_ROOT/usr/bin/rdiff-backup
+install -m 644 rdiff-backup.1 $RPM_BUILD_ROOT/usr/share/man/man1/rdiff-backup.1
+%clean
+
+%files
+%defattr(-,root,root)
+
+/usr/bin/rdiff-backup
+/usr/share/man/man1/rdiff-backup.1.gz
+%doc CHANGELOG COPYING README FAQ.html
+
+%changelog
+* Sat Apr 6 2002 Ben Escoto <bescoto@stanford.edu>
+- Made new version for Redhat 7.x series
+* Sun Nov 4 2001 Ben Escoto <bescoto@stanford.edu>
+- Initial RPM
+

tags/r0-11-5/rdiff-backup/dist/rdiff-backup.spec

+%define PYTHON_NAME %((rpm -q --quiet python2 && echo python2) || echo python)
+
+Version: $version
+Summary: Convenient and transparent local/remote incremental mirror/backup
+Name: rdiff-backup
+Release: 2
+URL: http://www.stanford.edu/~bescoto/rdiff-backup/
+Source: %{name}-%{version}.tar.gz
+Copyright: GPL
+Group: Applications/Archiving
+BuildRoot: %{_tmppath}/%{name}-root
+requires: librsync >= 0.9.5.1, %{PYTHON_NAME} >= 2.2
+BuildPrereq: %{PYTHON_NAME}-devel >= 2.2, librsync-devel >= 0.9.5.1
+
+%description
+rdiff-backup is a script, written in Python, that backs up one
+directory to another and is intended to be run periodically (nightly
+from cron for instance). The target directory ends up a copy of the
+source directory, but extra reverse diffs are stored in the target
+directory, so you can still recover files lost some time ago. The idea
+is to combine the best features of a mirror and an incremental
+backup. rdiff-backup can also operate in a bandwidth efficient manner
+over a pipe, like rsync. Thus you can use rdiff-backup and ssh to
+securely back a hard drive up to a remote location, and only the
+differences from the previous backup will be transmitted.
+
+%prep
+%setup -q
+
+%build
+%{PYTHON_NAME} setup.py build
+
+%install
+%{PYTHON_NAME} setup.py install --prefix=$RPM_BUILD_ROOT/usr
+
+%clean
+[ "$RPM_BUILD_ROOT" != "/" ] && rm -rf $RPM_BUILD_ROOT
+
+%files
+%defattr(-,root,root)
+/usr/bin/rdiff-backup
+/usr/share/man/man1
+/usr/lib
+%doc CHANGELOG COPYING FAQ.html README
+
+%changelog
+* Sun Jan 19 2002 Troels Arvin <troels@arvin.dk>
+- Builds, no matter if Python 2.2 is called python2-2.2 or python-2.2.
+
+* Sun Nov 4 2001 Ben Escoto <bescoto@stanford.edu>
+- Initial RPM

tags/r0-11-5/rdiff-backup/dist/setup.py

+#!/usr/bin/env python
+
+import sys, os, getopt
+from distutils.core import setup, Extension
+
+version_string = "$version"
+
+if sys.version_info[:2] < (2,2):
+	print "Sorry, rdiff-backup requires version 2.2 or later of python"
+	sys.exit(1)
+
+# Defaults
+lflags_arg = []
+libname = ['rsync']
+incdir_list = libdir_list = None
+
+if os.name == 'posix':
+	LIBRSYNC_DIR = os.environ.get('LIBRSYNC_DIR', '')
+	LFLAGS = os.environ.get('LFLAGS', [])
+	LIBS = os.environ.get('LIBS', [])
+
+	# Handle --librsync-dir=[PATH] and --lflags=[FLAGS]
+	args = sys.argv[:]
+	for arg in args:
+		if arg.startswith('--librsync-dir='):
+			LIBRSYNC_DIR = arg.split('=')[1]
+			sys.argv.remove(arg)
+		elif arg.startswith('--lflags='):
+			LFLAGS = arg.split('=')[1].split()
+			sys.argv.remove(arg)
+		elif arg.startswith('--libs='):
+			LIBS = arg.split('=')[1].split()
+			sys.argv.remove(arg)
+
+		if LFLAGS or LIBS:
+			lflags_arg = LFLAGS + LIBS
+
+		if LIBRSYNC_DIR:
+			incdir_list = [os.path.join(LIBRSYNC_DIR, 'include')]
+			libdir_list = [os.path.join(LIBRSYNC_DIR, 'lib')]
+		if '-lrsync' in LIBS:
+			libname = []
+
+setup(name="rdiff-backup",
+	  version=version_string,
+	  description="Local/remote mirroring+incremental backup",
+	  author="Ben Escoto",
+	  author_email="bescoto@stanford.edu",
+	  url="http://rdiff-backup.stanford.edu",
+	  packages = ['rdiff_backup'],
+	  ext_modules = [Extension("rdiff_backup.C", ["cmodule.c"]),
+					 Extension("rdiff_backup._librsync",
+							   ["_librsyncmodule.c"],
+							   include_dirs=incdir_list,
+							   library_dirs=libdir_list,
+							   libraries=libname,
+							   extra_link_args=lflags_arg)],
+	  scripts = ['rdiff-backup'],
+	  data_files = [('share/man/man1', ['rdiff-backup.1']),
+					('share/doc/rdiff-backup-%s' % (version_string,),
+					 ['CHANGELOG', 'COPYING', 'README', 'FAQ.html'])])
+

tags/r0-11-5/rdiff-backup/misc/compress-rdiff-backup-increments

+#!/usr/bin/env python
+#
+# Compresses old rdiff-backup increments.  See
+# http://www.stanford.edu/~bescoto/rdiff-backup for information on
+# rdiff-backup.
+
+from __future__ import nested_scopes, generators
+import os, sys, getopt
+
+rdiff_backup_location = "/usr/bin/rdiff-backup"
+no_compression_regexp_string = None
+__no_execute__ = 1
+
+def print_help():
+	"""Print usage, exit"""
+	print """
+Usage: compress-rdiff-backup-increments [options] mirror_directory
+
+This script will compress the old rdiff-backup increments under
+mirror_directory, in a format compatible with rdiff-backup version
+0.7.1 and later.  So for instance if you were using an old version
+of rdiff-backup like this:
+
+rdiff-backup /foo /backup
+
+and now you want to take advantage of v0.7.1's space saving
+compression, you can run:
+
+compress-rdiff-backup-increments /backup
+
+
+Options:
+
+--rdiff-backup-location location
+    This script reads your rdiff-backup executable.  The default
+    is "/usr/bin/rdiff-backup", so if your rdiff-backup is in a
+    different location, you must use this switch.
+
+--no-compression-regexp regexp
+    Any increments whose base name match this regular expression
+    won't be compressed.  This is generally used to avoid
+    compressing already compressed files.  See the rdiff-backup
+    man page for the default.
+"""
+	sys.exit(1)
+	
+def parse_args(arglist):
+	"""Check and evaluate command line arguments, return dirname"""
+	global rdiff_backup_location
+	global no_compression_regexp_string
+	try: optlist, args = getopt.getopt(arglist, "v:",
+									   ["rdiff-backup-location=",
+										"no-compression-regexp="])
+	except getopt.error: print_help()
+
+	for opt, arg in optlist:
+		if opt == "--no-compression-regexp":
+			no_compression_regexp_string = arg
+		elif opt == "--rdiff-backup-location": rdiff_backup_location = arg
+		else:
+			print "Bad option: ", opt
+			print_help()
+
+	if len(args) != 1:
+		print "Wrong number of arguments"
+		print_help()
+	return args[0]
+
+def exec_rdiff_backup():
+	"""Execs rdiff-backup"""
+	try: execfile(rdiff_backup_location, globals())
+	except IOError:
+		print "Unable to read", rdiff_backup_location
+		print "You may need to use the --rdiff-backup-location argument"
+		sys.exit(1)
+
+	if not map(int, Globals.version.split(".")) >= [0, 7, 1]:
+		print "This script requires rdiff-backup version 0.7.1 or later,",
+		print "found version", Globals.version
+		sys.exit(1)
+
+def gzip_file(rp):
+	"""gzip rp, adding .gz to path and deleting original"""
+	newrp = RPath(rp.conn, rp.base, rp.index[:-1] + (rp.index[-1]+".gz",))
+	if newrp.lstat():
+		print "Warning: %s already exists, skipping" % newrp.path
+		return
+
+	print "gzipping ", rp.path
+	newrp.write_from_fileobj(rp.open("rb"), compress = 1)
+	RPath.copy_attribs(rp, newrp)
+	rp.delete()
+
+def Main():
+	dirname = parse_args(sys.argv[1:])
+	exec_rdiff_backup()
+	if no_compression_regexp_string is not None:
+		no_compression_regexp = re.compile(no_compression_regexp_string, re.I)
+	else: no_compression_regexp = \
+		  re.compile(Globals.no_compression_regexp_string, re.I)
+	Globals.change_source_perms = 1
+	Globals.change_ownership = (os.getuid() == 0)
+
+	# Check to make sure rbdir exists
+	root_rp = RPath(Globals.local_connection, dirname)
+	rbdir = root_rp.append("rdiff-backup-data")
+	if not rbdir.lstat():
+		print "Cannot find %s, exiting" % rbdir.path
+		sys.exit(1)
+
+	for dsrp in DestructiveStepping.Iterate_with_Finalizer(rbdir, 1):
+		if (dsrp.isincfile() and dsrp.isreg() and
+			not dsrp.isinccompressed() and
+			(dsrp.getinctype() == "diff" or dsrp.getinctype() == "snapshot")
+			and dsrp.getsize() != 0 and
+			not no_compression_regexp.match(dsrp.getincbase_str())):
+			gzip_file(dsrp)
+
+Main()
+

tags/r0-11-5/rdiff-backup/misc/find2dirs

+#!/usr/bin/env python
+
+from __future__ import generators
+import sys, os, stat
+
+def usage():
+	print "Usage: find2dirs dir1 dir2"
+	print
+	print "Given the name of two directories, list all the files in both, one"
+	print "per line, but don't repeat a file even if it is in both directories"
+	sys.exit(1)
+
+def getlist(base, ext = ""):
+	"""Return iterator yielding filenames from directory"""
+	if ext: yield ext
+	else: yield "."
+
+	fullname = os.path.join(base, ext)
+	if stat.S_ISDIR(stat.S_IFMT(os.lstat(fullname)[stat.ST_MODE])):
+		for subfile in os.listdir(fullname):
+			for fn in getlist(base, os.path.join(ext, subfile)): yield fn
+
+def main(dir1, dir2):
+	d = {}
+	for fn in getlist(dir1): d[fn] = 1
+	for fn in getlist(dir2): d[fn] = 1
+	for fn in d.keys(): print fn
+
+if not len(sys.argv) == 3: usage()
+else: main(sys.argv[1], sys.argv[2])

tags/r0-11-5/rdiff-backup/misc/init_files.py

+#!/usr/bin/env python
+
+"""init_smallfiles.py
+
+This program makes a number of files of the given size in the
+specified directory.
+
+"""
+
+import os, stat, sys, math
+
+if len(sys.argv) > 5 or len(sys.argv) < 4:
+	print "Usage: init_files [directory name] [file size] [file count] [base]"
+	print
+	print "Creates file_count files in directory_name of size file_size."
+	print "The created directory has a tree type structure where each level"
+	print "has at most base files or directories in it.  Default is 50."
+	sys.exit(1)
+
+dirname = sys.argv[1]
+filesize = int(sys.argv[2])
+filecount = int(sys.argv[3])
+block_size = 16384
+block = "." * block_size
+block_change = "." * (filesize % block_size)
+if len(sys.argv) == 4: base = 50
+else: base = int(sys.argv[4])
+
+def make_file(path):
+	"""Make the file at path"""
+	fp = open(path, "w")
+	for i in xrange(int(math.floor(filesize/block_size))): fp.write(block)
+	fp.write(block_change)
+	fp.close()
+
+def find_sublevels(count):
+	"""Return number of sublevels required for count files"""
+	return int(math.ceil(math.log(count)/math.log(base)))
+
+def make_dir(dir, count):
+	"""Make count files in the directory, making subdirectories if necessary"""
+	print "Making directory %s with %d files" % (dir, count)
+	os.mkdir(dir)
+	level = find_sublevels(count)
+	assert count <= pow(base, level)
+	if level == 1:
+		for i in range(count): make_file(os.path.join(dir, "file%d" %i))
+	else:
+		files_per_subdir = pow(base, level-1)
+		full_dirs = int(count/files_per_subdir)
+		assert full_dirs <= base
+		for i in range(full_dirs):
+			make_dir(os.path.join(dir, "subdir%d" % i), files_per_subdir)
+
+		change = count - full_dirs*files_per_subdir
+		assert change >= 0
+		if change > 0:
+			make_dir(os.path.join(dir, "subdir%d" % full_dirs), change)
+
+def start(dir):
+	try: os.stat(dir)
+	except os.error: pass
+	else:
+		print "Directory %s already exists, exiting." % dir
+		sys.exit(1)
+
+	make_dir(dirname, filecount)
+
+start(dirname)

tags/r0-11-5/rdiff-backup/misc/librsync-many-files.py

+#!/usr/bin/env python
+
+"""Use librsync to transform everything in one dir to another"""
+
+import sys, os, librsync
+
+dir1, dir2 = sys.argv[1:3]
+for i in xrange(1000):
+	dir1fn = "%s/%s" % (dir1, i)
+	dir2fn = "%s/%s" % (dir2, i)
+
+	# Write signature file
+	f1 = open(dir1fn, "rb")
+	sigfile = open("sig", "wb")
+	librsync.filesig(f1, sigfile, 2048)
+	f1.close()
+	sigfile.close()
+
+	# Write delta file
+	f2 = open(dir2fn, "r")
+	sigfile = open("sig", "rb")
+	deltafile = open("delta", "wb")
+	librsync.filerdelta(sigfile, f2, deltafile)
+	f2.close()
+	sigfile.close()
+	deltafile.close()
+
+	# Write patched file
+	f1 = open(dir1fn, "rb")
+	newfile = open("%s/%s.out" % (dir1, i), "wb")
+	deltafile = open("delta", "rb")
+	librsync.filepatch(f1, deltafile, newfile)
+	f1.close()
+	deltafile.close()
+	newfile.close()
+
+	

tags/r0-11-5/rdiff-backup/misc/make-many-data-files.py

+#!/usr/bin/env python
+
+"""Make 10000 files consisting of data
+
+Syntax:  test.py directory_name number_of_files character filelength"""
+
+import sys, os
+
+dirname = sys.argv[1]
+num_files = int(sys.argv[2])
+character = sys.argv[3]
+filelength = int(sys.argv[4])
+
+os.mkdir(dirname)
+for i in xrange(num_files):
+	fp = open("%s/%s" % (dirname, i), "w")
+	fp.write(character * filelength)
+	fp.close()
+
+fp = open("%s.big" % dirname, "w")
+fp.write(character * (filelength*num_files))
+fp.close()

tags/r0-11-5/rdiff-backup/misc/myrm

+#!/usr/bin/python
+
+import sys, os
+#sys.path.insert(0, "../src")
+from rdiff_backup.rpath import *
+from rdiff_backup.connection import *
+from rdiff_backup import Globals
+
+lc = Globals.local_connection
+
+for filename in sys.argv[1:]:
+	#print "Deleting %s" % filename
+	rp = RPath(lc, filename)
+	if rp.lstat(): rp.delete()
+	#os.system("rm -rf " + rp.path)

tags/r0-11-5/rdiff-backup/misc/rdiff-many-files.py

+#!/usr/bin/env python
+
+"""Run rdiff to transform everything in one dir to another"""
+
+import sys, os
+
+dir1, dir2 = sys.argv[1:3]
+for i in xrange(1000):
+	assert not os.system("rdiff signature %s/%s sig" % (dir1, i))
+	assert not os.system("rdiff delta sig %s/%s diff" % (dir2, i))
+	assert not os.system("rdiff patch %s/%s diff %s/%s.out" %
+						 (dir1, i, dir1, i))
+
+	

tags/r0-11-5/rdiff-backup/misc/remove-comments.py

+#!/usr/bin/env python
+
+"""remove-comments.py
+
+Given a python program on standard input, spit one out on stdout that
+should work the same, but has blank and comment lines removed.
+
+"""
+
+import sys, re
+
+triple_regex = re.compile('"""')
+
+def eattriple(initial_line_stripped):
+	"""Keep reading until end of doc string"""
+	assert initial_line_stripped.startswith('"""')
+	if triple_regex.search(initial_line_stripped[3:]): return
+	while 1:
+		line = sys.stdin.readline()
+		if not line or triple_regex.search(line): break		
+
+while 1:
+	line = sys.stdin.readline()
+	if not line: break
+	stripped = line.strip()
+	if not stripped: continue
+	if stripped[0] == "#": continue
+	if stripped.startswith('"""'):
+		eattriple(stripped)
+		continue
+	sys.stdout.write(line)
+	

tags/r0-11-5/rdiff-backup/rdiff-backup

+#!/usr/bin/env python
+# rdiff-backup -- Mirror files while keeping incremental changes
+# Version $version released October 5, 2002
+# Copyright (C) 2001, 2002 Ben Escoto <bescoto@stanford.edu>
+#
+# This program is licensed under the GNU General Public License (GPL).
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA; either
+# version 2 of the License, or (at your option) any later version.
+# Distributions of rdiff-backup should include a copy of the GPL in a
+# file called COPYING.  The GPL is also available online at
+# http://www.gnu.org/copyleft/gpl.html.
+#
+# See http://rdiff-backup.stanford.edu/ for more information.  Please
+# send mail to me or the mailing list if you find bugs or have any
+# suggestions.
+
+import sys
+import rdiff_backup.Main
+
+if __name__ == "__main__" and not globals().has_key('__no_execute__'):
+	rdiff_backup.Main.Main(sys.argv[1:])
+
+

tags/r0-11-5/rdiff-backup/rdiff_backup/FilenameMapping.py

+# Copyright 2002 Ben Escoto
+#
+# This file is part of rdiff-backup.
+#
+# rdiff-backup is free software; you can redistribute it and/or modify
+# 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.
+#
+# rdiff-backup 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 rdiff-backup; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+# USA
+
+"""Coordinate corresponding files with different names
+
+For instance, some source filenames may contain characters not allowed
+on the mirror end.  These files must be called something different on
+the mirror end, so we escape the offending characters with semicolons.
+
+One problem/complication is that all this escaping may put files over
+the 256 or whatever limit on the length of file names.  (We just don't
+handle that error.)
+
+"""
+
+import re
+import Globals, log, rpath
+
+max_filename_length = 255
+
+# If true, enable character quoting, and set characters making
+# regex-style range.
+chars_to_quote = None
+
+# These compiled regular expressions are used in quoting and unquoting
+chars_to_quote_regexp = None
+unquoting_regexp = None
+
+# Use given char to quote.  Default is set in Globals.
+quoting_char = None
+
+
+class QuotingException(Exception): pass
+
+def set_init_quote_vals():
+	"""Set quoting value from Globals on all conns"""
+	for conn in Globals.connections:
+		conn.FilenameMapping.set_init_quote_vals_local()
+
+def set_init_quote_vals_local():
+	"""Set value on local connection, initialize regexps"""
+	global chars_to_quote, quoting_char
+	chars_to_quote = Globals.chars_to_quote
+	if len(Globals.quoting_char) != 1:
+		log.Log.FatalError("Expected single character for quoting char,"
+						   "got '%s' instead" % (Globals.quoting_char,))
+	quoting_char = Globals.quoting_char
+	init_quoting_regexps()
+
+def init_quoting_regexps():
+	"""Compile quoting regular expressions"""
+	global chars_to_quote_regexp, unquoting_regexp
+	try:
+		chars_to_quote_regexp = \
+				 re.compile("[%s]|%s" % (chars_to_quote, quoting_char), re.S)
+		unquoting_regexp = re.compile("%s[0-9]{3}" % quoting_char, re.S)
+	except re.error:
+		log.Log.FatalError("Error '%s' when processing char quote list %s" %
+						   (re.error, chars_to_quote))
+
+def quote(path):
+	"""Return quoted version of given path
+
+	Any characters quoted will be replaced by the quoting char and
+	the ascii number of the character.  For instance, "10:11:12"
+	would go to "10;05811;05812" if ":" were quoted and ";" were
+	the quoting character.
+
+	"""
+	return chars_to_quote_regexp.sub(quote_single, path)
+
+def quote_single(match):
+	"""Return replacement for a single character"""
+	return "%s%03d" % (quoting_char, ord(match.group()))
+
+def unquote(path):
+	"""Return original version of quoted filename"""
+	return unquoting_regexp.sub(unquote_single, path)
+
+def unquote_single(match):
+	"""Unquote a single quoted character"""
+	if not len(match.group()) == 4:
+		raise QuotingException("Quoted group wrong size: " + match.group())
+	try: return chr(int(match.group()[1:]))
+	except ValueError:
+		raise QuotingException("Quoted out of range: " + match.group())
+
+
+class QuotedRPath(rpath.RPath):
+	"""RPath where the filename is quoted version of index
+
+	We use QuotedRPaths so we don't need to remember to quote RPaths
+	derived from this one (via append or new_index).  Note that only
+	the index is quoted, not the base.
+
+	"""
+	def __init__(self, connection, base, index = (), data = None):
+		"""Make new QuotedRPath"""
+		quoted_index = tuple(map(quote, index))
+		rpath.RPath.__init__(self, connection, base, quoted_index, data)
+		self.index = index
+
+	def listdir(self):
+		"""Return list of unquoted filenames in current directory
+
+		We want them unquoted so that the results can be sorted
+		correctly and append()ed to the currect QuotedRPath.
+
+		"""
+		return map(unquote, self.conn.os.listdir(self.path))
+
+	def __str__(self):
+		return "QuotedPath: %s\nIndex: %s\nData: %s" % \
+			   (self.path, self.index, self.data)
+
+	def isincfile(self):
+		"""Return true if path indicates increment, sets various variables"""
+		result = rpath.RPath.isincfile(self)
+		if result: self.inc_basestr = unquote(self.inc_basestr)
+		return result
+		
+def get_quotedrpath(rp, separate_basename = 0):
+	"""Return quoted version of rpath rp"""
+	assert not rp.index # Why would we starting quoting "in the middle"?
+	if separate_basename:
+		dirname, basename = rp.dirsplit()
+		return QuotedRPath(rp.conn, dirname, (unquote(basename),), rp.data)
+	else: return QuotedRPath(rp.conn, rp.base, (), rp.data)
+
+def get_quoted_sep_base(filename):
+	"""Get QuotedRPath from filename assuming last bit is quoted"""
+	return get_quotedrpath(rpath.RPath(Globals.local_connection, filename), 1)

tags/r0-11-5/rdiff-backup/rdiff_backup/Globals.py

+# Copyright 2002 Ben Escoto
+#
+# This file is part of rdiff-backup.
+#
+# rdiff-backup is free software; you can redistribute it and/or modify
+# 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.
+#
+# rdiff-backup 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 rdiff-backup; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+# USA
+
+"""Hold a variety of constants usually set at initialization."""
+
+import re, os
+
+
+# The current version of rdiff-backup
+version = "$version"
+
+# If this is set, use this value in seconds as the current time
+# instead of reading it from the clock.
+current_time = None
+
+# This determines how many bytes to read at a time when copying
+blocksize = 32768
+
+# This is used by the BufferedRead class to determine how many
+# bytes to request from the underlying file per read().  Larger
+# values may save on connection overhead and latency.
+conn_bufsize = 98304
+
+# This is used in rorpiter.CacheIndexable.  The number represents the
+# number of rpaths which may be stuck in buffers when moving over a
+# remote connection.
+pipeline_max_length = 500
+
+# True if script is running as a server
+server = None
+
+# uid and gid of the owner of the rdiff-backup process.  This can
+# vary depending on the connection.
+process_uid = os.getuid()
+process_gid = os.getgid()
+
+# If true, when copying attributes, also change target's uid/gid
+change_ownership = None
+
+# If true, when copying attributes, also change target's permission.
+change_permissions = 1
+
+# If true, change the permissions of unwriteable mirror files
+# (such as directories) so that they can be written, and then
+# change them back.  This defaults to 1 just in case the process
+# is not running as root (root doesn't need to change
+# permissions).
+change_mirror_perms = (process_uid != 0)
+
+# If true, try to reset the atimes of the source partition.
+preserve_atime = None
+
+# This will be set as soon as the LocalConnection class loads
+local_connection = None
+
+# All connections should be added to the following list, so
+# further global changes can be propagated to the remote systems.
+# The first element should be Globals.local_connection.  For a
+# server, the second is the connection to the client.
+connections = []
+
+# Each process should have a connection number unique to the
+# session.  The client has connection number 0.
+connection_number = 0
+
+# Dictionary pairing connection numbers with connections.  Set in
+# SetConnections for all connections.
+connection_dict = {}
+
+# True if the script is the end that reads the source directory
+# for backups.  It is true for purely local sessions.
+isbackup_reader = None
+
+# Connection of the real backup reader (for which isbackup_reader
+# is true)
+backup_reader = None
+
+# True if the script is the end that writes to the increment and
+# mirror directories.  True for purely local sessions.
+isbackup_writer = None
+
+# Connection of the backup writer
+backup_writer = None
+
+# Connection of the client
+client_conn = None
+
+# This list is used by the set function below.  When a new
+# connection is created with init_connection, its Globals class
+# will match this one for all the variables mentioned in this
+# list.
+changed_settings = []
+
+# The RPath or QuotedRPath of the rdiff-backup-data directory.
+rbdir = None
+
+# quoting_enabled is true if we should quote certain characters in
+# filenames on the source side (see FilenameMapping for more
+# info).  chars_to_quote is a string whose characters should be
+# quoted, and quoting_char is the character to quote with.
+quoting_enabled = None
+chars_to_quote = "A-Z:"
+quoting_char = ';'
+
+# If true, emit output intended to be easily readable by a
+# computer.  False means output is intended for humans.
+parsable_output = None
+
+# If true, then hardlinks will be preserved to mirror and recorded
+# in the increments directory.  There is also a difference here
+# between None and 0.  When restoring, None or 1 means to preserve
+# hardlinks iff can find a hardlink dictionary.  0 means ignore
+# hardlink information regardless.
+preserve_hardlinks = 1
+
+# If this is false, then rdiff-backup will not compress any
+# increments.  Default is to compress based on regexp below.
+compression = 1
+
+# Increments based on files whose names match this
+# case-insensitive regular expression won't be compressed (applies
+# to .snapshots and .diffs).  The second below will be the
+# compiled version of the first.
+no_compression_regexp_string = "(?i).*\\.(gz|z|bz|bz2|tgz|zip|rpm|deb|" \
+						"jpg|gif|png|jp2|mp3|ogg|avi|wmv|mpeg|mpg|rm|mov)$"
+no_compression_regexp = None
+
+# If true, filelists and directory statistics will be split on
+# nulls instead of newlines.
+null_separator = None
+
+# Determines whether or not ssh will be run with the -C switch
+ssh_compression = 1
+
+# If true, print statistics after successful backup
+print_statistics = None
+
+# Controls whether file_statistics file is written in
+# rdiff-backup-data dir.  These can sometimes take up a lot of space.
+file_statistics = 1
+
+# On the writer connection, the following will be set to the mirror
+# Select iterator.
+select_mirror = None
+
+# On the backup writer connection, holds the root incrementing branch
+# object.  Access is provided to increment error counts.
+ITRB = None
+
+# security_level has 4 values and controls which requests from remote
+# systems will be honored.  "all" means anything goes. "read-only"
+# means that the requests must not write to disk.  "update-only" means
+# that requests shouldn't destructively update the disk (but normal
+# incremental updates are OK).  "minimal" means only listen to a few
+# basic requests.
+security_level = "all"
+
+# If this is set, it indicates that the remote connection should only
+# deal with paths inside of restrict_path.
+restrict_path = None
+
+# If set, a file will be marked as changed if its inode changes.  See
+# the man page under --no-compare-inode for more information.
+compare_inode = 1
+
+# If set, directories can be fsync'd just like normal files, to
+# guarantee that any changes have been committed to disk.
+fsync_directories = 1
+
+
+def get(name):
+	"""Return the value of something in this module"""
+	return globals()[name]
+
+def is_not_None(name):
+	"""Returns true if value is not None"""
+	return globals()[name] is not None
+
+def set(name, val):
+	"""Set the value of something in this module
+
+	Use this instead of writing the values directly if the setting
+	matters to remote sides.  This function updates the
+	changed_settings list, so other connections know to copy the
+	changes.
+
+	"""
+	changed_settings.append(name)
+	globals()[name] = val
+
+def set_integer(name, val):
+	"""Like set, but make sure val is an integer"""
+	try: intval = int(val)
+	except ValueError:
+		Log.FatalError("Variable %s must be set to an integer -\n"
+					   "received %s instead." % (name, val))
+	set(name, intval)
+
+def set_float(name, val, min = None, max = None, inclusive = 1):
+	"""Like set, but make sure val is float within given bounds"""
+	def error():
+		s = "Variable %s must be set to a float" % (name,)
+		if min is not None and max is not None:
+			s += " between %s and %s " % (min, max)
+			if inclusive: s += "inclusive"
+			else: s += "not inclusive"
+		elif min is not None or max is not None:
+			if inclusive: inclusive_string = "or equal to "
+			else: inclusive_string = ""
+			if min is not None:
+				s += " greater than %s%s" % (inclusive_string, min)
+			else: s+= " less than %s%s" % (inclusive_string, max)
+		Log.FatalError(s)
+
+	try: f = float(val)
+	except ValueError: error()
+	if min is not None:
+		if inclusive and f < min: error()
+		elif not inclusive and f <= min: error()
+	if max is not None:
+		if inclusive and f > max: error()
+		elif not inclusive and f >= max: error()
+	set(name, f)
+
+def get_dict_val(name, key):
+	"""Return val from dictionary in this class"""
+	return globals()[name][key]
+
+def set_dict_val(name, key, val):
+	"""Set value for dictionary in this class"""
+	globals()[name][key] = val
+
+def postset_regexp(name, re_string, flags = None):
+	"""Compile re_string on all existing connections, set to name"""
+	for conn in connections:
+		conn.Globals.postset_regexp_local(name, re_string, flags)
+
+def postset_regexp_local(name, re_string, flags):
+	"""Set name to compiled re_string locally"""
+	if flags: globals()[name] = re.compile(re_string, flags)
+	else: globals()[name] = re.compile(re_string)
+
+

tags/r0-11-5/rdiff-backup/rdiff_backup/Hardlink.py

+# Copyright 2002 Ben Escoto
+#
+# This file is part of rdiff-backup.
+#
+# rdiff-backup is free software; you can redistribute it and/or modify
+# 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.
+#
+# rdiff-backup 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 rdiff-backup; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+# USA
+
+"""Preserve and restore hard links
+
+If the preserve_hardlinks option is selected, linked files in the
+source directory will be linked in the mirror directory.  Linked files
+are treated like any other with respect to incrementing, but their
+link status can be retrieved because their device location and inode #
+is written in the metadata file.
+
+All these functions are meant to be executed on the mirror side.  The
+source side should only transmit inode information.
+
+"""
+
+from __future__ import generators
+import cPickle
+import Globals, Time, rpath, log, robust
+
+# In all of these lists of indicies are the values.  The keys in
+# _inode_ ones are (inode, devloc) pairs.
+_src_inode_indicies = None
+_dest_inode_indicies = None
+
+# The keys for these two are just indicies.  They share values
+# with the earlier dictionaries.
+_src_index_indicies = None
+_dest_index_indicies = None
+
+# When a linked file is restored, its path is added to this dict,
+# so it can be found when later paths being restored are linked to
+# it.
+_restore_index_path = None
+
+def initialize_dictionaries():
+	"""Set all the hard link dictionaries to empty"""
+	global _src_inode_indicies, _dest_inode_indicies
+	global _src_index_indicies, _dest_index_indicies, _restore_index_path
+	_src_inode_indicies = {}
+	_dest_inode_indicies = {}
+	_src_index_indicies = {}
+	_dest_index_indicies = {}
+	_restore_index_path = {}
+
+def clear_dictionaries():
+	"""Delete all dictionaries"""
+	global _src_inode_indicies, _dest_inode_indicies
+	global _src_index_indicies, _dest_index_indicies, _restore_index_path
+	_src_inode_indicies = _dest_inode_indicies = None
+	_src_index_indicies = _dest_index_indicies = _restore_index_path = None
+
+
+def get_inode_key(rorp):
+	"""Return rorp's key for _inode_ dictionaries"""
+	return (rorp.getinode(), rorp.getdevloc())
+
+def get_indicies(rorp, source):
+	"""Return a list of similarly linked indicies, using rorp's index"""
+	if source: dict = _src_index_indicies
+	else: dict = _dest_index_indicies
+	try: return dict[rorp.index]
+	except KeyError: return []
+
+def add_rorp(rorp, source):
+	"""Process new rorp and update hard link dictionaries
+
+	First enter it into src_inode_indicies.  If we have already
+	seen all the hard links, then we can delete the entry.
+	Everything must stay recorded in src_index_indicies though.
+
+	"""
+	if not rorp.isreg() or rorp.getnumlinks() < 2: return
+
+	if source:
+		inode_dict, index_dict = _src_inode_indicies, _src_index_indicies
+	else: inode_dict, index_dict = _dest_inode_indicies, _dest_index_indicies
+
+	rp_inode_key = get_inode_key(rorp)
+	if inode_dict.has_key(rp_inode_key):
+		index_list = inode_dict[rp_inode_key]
+		index_list.append(rorp.index)
+		if len(index_list) == rorp.getnumlinks():
+			del inode_dict[rp_inode_key]
+	else: # make new entry in both src dicts
+		index_list = [rorp.index]
+		inode_dict[rp_inode_key] = index_list
+	index_dict[rorp.index] = index_list
+
+def add_rorp_iter(iter, source):
+	"""Return new rorp iterator like iter that add_rorp's first"""
+	for rorp in iter:
+		add_rorp(rorp, source)
+		yield rorp
+
+def rorp_eq(src_rorp, dest_rorp):
+	"""Compare hardlinked for equality
+
+	Two files may otherwise seem equal but be hardlinked in
+	different ways.  This function considers them equal enough if
+	they have been hardlinked correctly to the previously seen
+	indicies.
+
+	"""
+	if (not src_rorp.isreg() or not dest_rorp.isreg() or
+		src_rorp.getnumlinks() == dest_rorp.getnumlinks() == 1):
+		return 1 # Hard links don't apply
+
+	src_index_list = get_indicies(src_rorp, 1)
+	dest_index_list = get_indicies(dest_rorp, None)
+
+	# If a list only has one element, then it is only hardlinked
+	# to itself so far, so that is not a genuine difference yet.
+	if not src_index_list or len(src_index_list) == 1:
+		return not dest_index_list or len(dest_index_list) == 1
+	if not dest_index_list or len(dest_index_list) == 1: return None
+
+	# Both index lists exist and are non-empty
+	return src_index_list == dest_index_list # they are always sorted
+
+def islinked(rorp):
+	"""True if rorp's index is already linked to something on src side"""
+	return len(get_indicies(rorp, 1)) >= 2
+
+def get_link_index(rorp):
+	"""Return first index on target side rorp is already linked to"""
+	return get_indicies(rorp, 1)[0]
+
+def restore_link(index, rpath):
+	"""Restores a linked file by linking it
+
+	When restoring, all the hardlink data is already present, and
+	we can only link to something already written.  In either
+	case, add to the _restore_index_path dict, so we know later
+	that the file is available for hard
+	linking.
+
+	Returns true if succeeded in creating rpath, false if must
+	restore rpath normally.
+
+	"""
+	if index not in _src_index_indicies: return None
+	for linked_index in _src_index_indicies[index]:
+		if linked_index in _restore_index_path:
+			srcpath = _restore_index_path[linked_index]
+			log.Log("Restoring %s by hard linking to %s" %
+					(rpath.path, srcpath), 6)
+			rpath.hardlink(srcpath)
+			return 1
+	_restore_index_path[index] = rpath.path
+	return None
+
+def link_rp(diff_rorp, dest_rpath, dest_root = None):
+	"""Make dest_rpath into a link using link flag in diff_rorp"""
+	if not dest_root: dest_root = dest_rpath # use base of dest_rpath
+	dest_link_rpath = dest_root.new_index(diff_rorp.get_link_flag())
+	dest_rpath.hardlink(dest_link_rpath.path)
+
+
+
+

tags/r0-11-5/rdiff-backup/rdiff_backup/Rdiff.py

+# Copyright 2002 Ben Escoto
+#
+# This file is part of rdiff-backup.
+#
+# rdiff-backup is free software; you can redistribute it and/or modify
+# 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.
+#
+# rdiff-backup 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 rdiff-backup; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+# USA
+
+"""Invoke rdiff utility to make signatures, deltas, or patch"""
+
+import os, librsync
+import Globals, log, static, TempFile, rpath
+
+
+def get_signature(rp):
+	"""Take signature of rpin file and return in file object"""
+	log.Log("Getting signature of %s" % rp.get_indexpath(), 7)
+	return librsync.SigFile(rp.open("rb"))
+
+def get_delta_sigfileobj(sig_fileobj, rp_new):
+	"""Like get_delta but signature is in a file object"""
+	log.Log("Getting delta of %s with signature stream" % (rp_new.path,), 7)
+	return librsync.DeltaFile(sig_fileobj, rp_new.open("rb"))
+
+def get_delta_sigrp(rp_signature, rp_new):
+	"""Take signature rp and new rp, return delta file object"""
+	log.Log("Getting delta of %s with signature %s" %
+			(rp_new.path, rp_signature.get_indexpath()), 7)
+	return librsync.DeltaFile(rp_signature.open("rb"), rp_new.open("rb"))
+
+def write_delta(basis, new, delta, compress = None):
+	"""Write rdiff delta which brings basis to new"""
+	log.Log("Writing delta %s from %s -> %s" %
+			(basis.path, new.path, delta.path), 7)
+	sigfile = librsync.SigFile(basis.open("rb"))
+	deltafile = librsync.DeltaFile(sigfile, new.open("rb"))
+	delta.write_from_fileobj(deltafile, compress)
+
+def write_patched_fp(basis_fp, delta_fp, out_fp):
+	"""Write patched file to out_fp given input fps.  Closes input files"""
+	rpath.copyfileobj(librsync.PatchedFile(basis_fp, delta_fp), out_fp)
+	assert not basis_fp.close() and not delta_fp.close()
+
+def write_via_tempfile(fp, rp):
+	"""Write fileobj fp to rp by writing to tempfile and renaming"""
+	tf = TempFile.new(rp)
+	tf.write_from_fileobj(fp)
+	rpath.rename(tf, rp)
+
+def patch_local(rp_basis, rp_delta, outrp = None, delta_compressed = None):
+	"""Patch routine that must be run locally, writes to outrp
+
+	This should be run local to rp_basis because it needs to be a real
+	file (librsync may need to seek around in it).  If outrp is None,
+	patch rp_basis instead.
+
+	"""
+	assert rp_basis.conn is Globals.local_connection
+	if delta_compressed: deltafile = rp_delta.open("rb", 1)
+	else: deltafile = rp_delta.open("rb")
+
+	sigfile = librsync.SigFile(rp_basis.open("rb"))
+	patchfile = librsync.PatchedFile(rp_basis.open("rb"), deltafile)
+
+	if outrp: outrp.write_from_fileobj(patchfile)
+	else: write_via_tempfile(patchfile, rp_basis)
+
+def copy_local(rpin, rpout, rpnew = None):
+	"""Write rpnew == rpin using rpout as basis.  rpout and rpnew local"""
+	assert rpout.conn is Globals.local_connection
+	sigfile = librsync.SigFile(rpout.open("rb"))
+	deltafile = rpin.conn.librsync.DeltaFile(sigfile, rpin.open("rb"))
+	patched_file = librsync.PatchedFile(rpout.open("rb"), deltafile)
+
+	if rpnew: rpnew.write_from_fileobj(patched_file)
+	else: write_via_tempfile(patched_file, rpout)
+	
+
+

tags/r0-11-5/rdiff-backup/rdiff_backup/Security.py

+# Copyright 2002 Ben Escoto
+#
+# This file is part of rdiff-backup.
+#
+# rdiff-backup is free software; you can redistribute it and/or modify
+# 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.
+#
+# rdiff-backup 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 rdiff-backup; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+# USA
+
+"""Functions to make sure remote requests are kosher"""
+
+import sys, tempfile
+import Globals, Main, rpath
+
+class Violation(Exception):
+	"""Exception that indicates an improper request has been received"""
+	pass
+
+
+# This will store the list of functions that will be honored from
+# remote connections.
+allowed_requests = None
+
+# This stores the list of global variables that the client can not
+# set on the server.
+disallowed_server_globals = ["server", "security_level", "restrict_path"]
+
+def initialize(action, cmdpairs):
+	"""Initialize allowable request list and chroot"""
+	global allowed_requests
+	set_security_level(action, cmdpairs)
+	set_allowed_requests(Globals.security_level)
+
+def set_security_level(action, cmdpairs):
+	"""If running client, set security level and restrict_path
+
+	To find these settings, we must look at the action to see what is
+	supposed to happen, and then look at the cmdpairs to see what end
+	the client is on.
+
+	"""
+	def islocal(cmdpair): return not cmdpair[0]
+	def bothlocal(cp1, cp2): return islocal(cp1) and islocal(cp2)
+	def bothremote(cp1, cp2): return not islocal(cp1) and not islocal(cp2)
+	def getpath(cmdpair): return cmdpair[1]
+
+	if Globals.server: return
+	cp1 = cmdpairs[0]
+	if len(cmdpairs) > 1: cp2 = cmdpairs[1]
+	else: cp2 = cp1
+
+	if action == "backup" or action == "check-destination-dir":
+		if bothlocal(cp1, cp2) or bothremote(cp1, cp2):
+			sec_level = "minimal"
+			rdir = tempfile.gettempdir()
+		elif islocal(cp1):
+			sec_level = "read-only"
+			rdir = getpath(cp1)
+		else:
+			assert islocal(cp2)
+			sec_level = "update-only"
+			rdir = getpath(cp2)
+	elif action == "restore" or action == "restore-as-of":
+		if len(cmdpairs) == 1 or bothlocal(cp1, cp2) or bothremote(cp1, cp2):
+			sec_level = "minimal"
+			rdir = tempfile.gettempdir()
+		elif islocal(cp1):
+			sec_level = "read-only"
+			rdir = Main.restore_get_root(rpath.RPath(Globals.local_connection,
+													 getpath(cp1)))[0].path
+		else:
+			assert islocal(cp2)
+			sec_level = "all"
+			rdir = getpath(cp2)
+	elif action == "mirror":
+		if bothlocal(cp1, cp2) or bothremote(cp1, cp2):
+			sec_level = "minimal"
+			rdir = tempfile.gettempdir()
+		elif islocal(cp1):
+			sec_level = "read-only"
+			rdir = getpath(cp1)
+		else:
+			assert islocal(cp2)
+			sec_level = "all"
+			rdir = getpath(cp2)
+	elif (action == "test-server" or action == "list-increments" or
+		  action == "list-at-time" or action == "list-changed-since"
+		  or action == "calculate-average" or action == "remove-older-than"):
+		sec_level = "minimal"
+		rdir = tempfile.gettempdir()
+	else: assert 0, "Unknown action %s" % action
+
+	Globals.security_level = sec_level
+	Globals.restrict_path = rpath.RPath(Globals.local_connection,
+										rdir).normalize().path
+
+def set_allowed_requests(sec_level):
+	"""Set the allowed requests list using the security level"""
+	global allowed_requests
+	if sec_level == "all": return
+	allowed_requests = ["VirtualFile.readfromid", "VirtualFile.closebyid",
+						"Globals.get", "Globals.is_not_None",
+						"Globals.get_dict_val",
+						"log.Log.open_logfile_allconn",
+						"log.Log.close_logfile_allconn",
+						"Log.log_to_file",
+						"SetConnections.add_redirected_conn",
+						"RedirectedRun",
+						"sys.stdout.write"]
+	if sec_level == "minimal": pass
+	elif sec_level == "read-only" or sec_level == "update-only":
+		allowed_requests.extend(
+			["C.make_file_dict",
+			 "log.Log.log_to_file",
+			 "os.getuid",
+			 "os.listdir",
+			 "Time.setcurtime_local",
+			 "robust.Resume.ResumeCheck",
+			 "backup.SourceStruct.split_initial_dsiter",
+			 "backup.SourceStruct.get_diffs_and_finalize",
+			 "rpath.gzip_open_local_read",
+			 "rpath.open_local_read"])
+		if sec_level == "update-only":
+			allowed_requests.extend(
+				["Log.open_logfile_local", "Log.close_logfile_local",
+				 "Log.close_logfile_allconn", "Log.log_to_file",
+				 "log.Log.log_to_file",
+				 "robust.SaveState.init_filenames",
+				 "robust.SaveState.touch_last_file",
+				 "backup.DestinationStruct.get_sigs",
+				 "backup.DestinationStruct.patch_w_datadir_writes",
+				 "backup.DestinationStruct.patch_and_finalize",
+				 "backup.DestinationStruct.patch_increment_and_finalize",
+				 "Main.backup_touch_curmirror_local",
+				 "Globals.ITRB.increment_stat",
+				 "statistics.record_error",
+				 "log.ErrorLog.write_if_open"])
+	if Globals.server:
+		allowed_requests.extend(
+			["SetConnections.init_connection_remote",
+			 "Log.setverbosity",
+			 "Log.setterm_verbosity",
+			 "Time.setprevtime_local",
+			 "FilenameMapping.set_init_quote_vals_local",
+			 "Globals.postset_regexp_local",
+			 "Globals.set_select",
+			 "backup.SourceStruct.set_session_info",
+			 "backup.DestinationStruct.set_session_info"])
+
+def vet_request(request, arglist):
+	"""Examine request for security violations"""
+	#if Globals.server: sys.stderr.write(str(request) + "\n")
+	security_level = Globals.security_level
+	if Globals.restrict_path:
+		for arg in arglist:
+			if isinstance(arg, rpath.RPath): vet_rpath(arg)
+	if security_level == "all": return
+	if request.function_string in allowed_requests: return
+	if request.function_string == "Globals.set":
+		if Globals.server and arglist[0] not in disallowed_server_globals:
+			return
+	raise Violation("\nWarning Security Violation!\n"
+					"Bad request for function: %s\n"
+					"with arguments: %s\n" % (request.function_string,
+											  arglist))
+
+def vet_rpath(rpath):
+	"""Require rpath not to step outside retricted directory"""
+	if Globals.restrict_path and rpath.conn is Globals.local_connection:
+		normalized, restrict = rpath.normalize().path, Globals.restrict_path
+		components = normalized.split("/")
+		# 3 cases for restricted dir /usr/foo:  /var, /usr/foobar, /usr/foo/..
+		if (not normalized.startswith(restrict) or
+			(len(normalized) > len(restrict) and
+			 normalized[len(restrict)] != "/") or
+			".." in components):
+			raise Violation("\nWarning Security Violation!\n"
+							"Request to handle path %s\n"
+							"which doesn't appear to be within "
+							"restrict path %s.\n" % (normalized, restrict))
+
+			 
+		   
+			

tags/r0-11-5/rdiff-backup/rdiff_backup/compilec.py

+#!/usr/bin/env python
+
+import sys, os
+from distutils.core import setup, Extension
+
+assert len(sys.argv) == 1
+sys.argv.append("build")
+
+setup(name="CModule",
+	  version="0.9.0",
+	  description="rdiff-backup's C component",
+	  ext_modules=[Extension("C", ["cmodule.c"]),
+				   Extension("_librsync", ["_librsyncmodule.c"],
+							 libraries=["rsync"])])
+
+def get_libraries():
+	"""Return filename of C.so and _librsync.so files"""
+	build_files = os.listdir("build")
+	lib_dirs = filter(lambda x: x.startswith("lib"), build_files)
+	assert len(lib_dirs) == 1, "No library directory or too many"
+	libdir = lib_dirs[0]
+	clib = os.path.join("build", libdir, "C.so")
+	rsynclib = os.path.join("build", libdir, "_librsync.so")
+	try:
+		os.lstat(clib)
+		os.lstat(rsynclib)
+	except os.error:
+		print "Library file missing"
+		sys.exit(1)
+	return clib, rsynclib
+	
+for filename in get_libraries():
+	assert not os.system("mv %s ." % (filename,))
+assert not os.system("rm -rf build")

tags/r0-11-5/rdiff-backup/rdiff_backup/memoryleak.c

+#include <stdio.h>
+#include <rsync.h>
+
+main()
+{
+  FILE *basis_file, *sig_file;
+  char filename[50];
+  rs_stats_t stats;
+  rs_result result;
+  long i;
+
+  for(i=0; i<=100000; i++) {
+	basis_file = fopen("a", "r");
+	sig_file = fopen("sig", "w");
+  
+	result = rs_sig_file(basis_file, sig_file,
+						 RS_DEFAULT_BLOCK_LEN, RS_DEFAULT_STRONG_LEN,
+						 &stats);
+	if (result != RS_DONE) exit(result);
+	fclose(basis_file);
+	fclose(sig_file);
+  }
+}