Xref: utzoo comp.sys.att:7518 unix-pc.general:3701
Path: utzoo!utgpu!jarvis.csri.toronto.edu!mailrus!ncar!noao!arizona!naucse!jdc
From: jdc@naucse.UUCP (John Campbell)
Newsgroups: comp.sys.att,unix-pc.general
Subject: Re: Incremental backups on 3b1?
Summary: My method, using find -newer
Message-ID: <1692@naucse.UUCP>
Date: 8 Sep 89 12:44:17 GMT
References: <16730@pasteur.Berkeley.EDU>
Organization: Northern Arizona University, Flagstaff, AZ
Lines: 842

In article <16730@pasteur.Berkeley.EDU>, sjohn@cory.Berkeley.EDU (John Sasinowski) writes:
> 
> 	I am looking for a way to do incremental backups on my 3b1.
> I initially thought that the Partial Backup option on the Disk Backup
> submenu of Administration in the ua did this, but the online help states
> that it backs up everything since that last complete backup.
> 	I want to do incremental backups because I have a 67Mb hard disk
> and I KNOW that I won't stay up to date if each backup takes close to
> 100 disks!
> 	Any suggestions on how to do incremental backups or alternate
> methods of backing up the hard disk would be greatly appreciated.
> 	Thank you.
> 
> 
> 	John Sasinowski
> 	sjohn@cory.berkeley.edu

I found I did not like backing up a system that required one huge
cpio save set of over 100 floppies (67 Mb disk) either.  To alleviate
this problem, I broke the task into 5 groups (group1 ... group5).
Immediately this helped, especially since I could selectively
remove some of the files from the backup list (/usr/catman for
instance).

Further I recorded the date that each group was backed up in
order to do a Level 1 (all files since Level 0) and even a
Level 2 backup.  Finally I wrote a command called backup
that can take an argument like "group1".  Hence to initiate
a L0 group1 backup I su to root, move to the L0 directory
and say "./backup group1".

I don't try to backup the foundation set since I would intend to
load that set from the originals (or my copy of the originals).
I do, however, back up everything else newer than the 
/etc/.installdate if I'm doing a Level 0 backup.

I try to make sure that the backup shell program is only
readable by root to avoid starting a backup as a non-privileged
user.  Another trick I often use is to say "sh group1 | cpiosize"
to find out how many floppies my backup will require.

I know there was a comment recently about using -newer (with
find) to control backups, if anyone wants to comment on the
safety of my approach fire away!  Also, I expect no one will
be so fool hardy to use my group files without tuning them to
their own system--especially the exclusion lists.  

Now, for a MAJOR admission/disclaimer!  I HAVE NOT USED ANY OF
MY CPIO SETS TO RESTORE MY HARD DISK!  Look at everything here
*very* critically before choosing to use it.  Post any problems
you think you see--I've hesitated to even mention my scheme except
others have asked for it *and* I might like to hear of any holes
in it :-).

---cut here for my backup system----

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file". e.g..  If this archive is complete, you
# will see the following message at the end:
#               "End of archive."
# Contents:  ./L1/group1 ./L1/group1.L1 ./L1/group1.sed ./L1/group2
#            ./L1/group2.L1 ./L1/group2.sed ./L1/group3 ./L1/group3.L1
#            ./L1/group3.sed ./L1/group4 ./L1/group4.L1 ./L1/group4.sed
#            ./L1/group5 ./L1/group5.L1 ./L1/group5.sed ./L1/backup
#            ./L2/backup ./L2/group1 ./L2/group2.L2 ./L2/group1.sed
#            ./L2/group2 ./L2/group3.2 ./L2/group2.sed ./L2/group3
#            ./L2/group1.L2 ./L2/group3.sed ./L2/group4 ./L2/group4.2
#            ./L2/group4.sed ./L2/group5 ./L2/group5.2 ./L2/group5.sed
#            ./L0/group1 ./L0/group1.L0 ./L0/group1.sed ./L0/group2
#            ./L0/group2.L0 ./L0/group2.sed ./L0/group3 ./L0/group3.L0
#            ./L0/group3.sed ./L0/group4 ./L0/group4.L0 ./L0/group4.sed
#            ./L0/group5 ./L0/group5.L0 ./L0/group5.sed ./L0/000read.me
#            ./L0/backup
# Wrapped by root@thunde on Thu Sep  7 20:38:44 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if `test ! -d .`
then
  mkdir .
  echo "mkdir ."
fi
if `test ! -d ./L1`
then
  mkdir ./L1
  echo "mkdir ./L1"
fi
if test -f ./L1/group1 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group1\"
else
echo shar: Extracting \"./L1/group1\" \(76 characters\)
sed "s/^X//" >./L1/group1 <<'END_OF_group1'
# Group1
X# 
Xfind /u -newer ../L0/group1.L0 -depth -print |sed -f group1.sed
END_OF_group1
chmod 744 ./L1/group1
if test 76 -ne `wc -c < ./L1/group1`; then
	echo shar: \"./L1/group1\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group1.L1 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group1.L1\"
else
echo shar: Extracting \"./L1/group1.L1\" \(29 characters\)
sed "s/^X//" >./L1/group1.L1 <<'END_OF_group1.L1'
Tue Aug 29 19:09:52 MST 1989
END_OF_group1.L1
chmod 644 ./L1/group1.L1
if test 29 -ne `wc -c < ./L1/group1.L1`; then
	echo shar: \"./L1/group1.L1\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group1.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group1.sed\"
else
echo shar: Extracting \"./L1/group1.sed\" \(135 characters\)
sed "s/^X//" >./L1/group1.sed <<'END_OF_group1.sed'
/jdc\/.*\readj/d
X/jdc\/.*\writej/d
X/jdc\/.*\/Int/d
X/jdc\/.*\/Readj/d
X/jdc\/.*\/Readj/d
X/u\/jdc\/Xfer\/Month/d
X/u\/jdc\/Xfer\/Gnuplot/d
END_OF_group1.sed
chmod 644 ./L1/group1.sed
if test 135 -ne `wc -c < ./L1/group1.sed`; then
	echo shar: \"./L1/group1.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group2 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group2\"
else
echo shar: Extracting \"./L1/group2\" \(84 characters\)
sed "s/^X//" >./L1/group2 <<'END_OF_group2'
# Group2
X# 
Xfind /usr/local -newer ../L0/group2.L0 -depth -print |sed -f group2.sed
END_OF_group2
chmod 744 ./L1/group2
if test 84 -ne `wc -c < ./L1/group2`; then
	echo shar: \"./L1/group2\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group2.L1 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group2.L1\"
else
echo shar: Extracting \"./L1/group2.L1\" \(29 characters\)
sed "s/^X//" >./L1/group2.L1 <<'END_OF_group2.L1'
Tue Aug 29 19:13:22 MST 1989
END_OF_group2.L1
chmod 644 ./L1/group2.L1
if test 29 -ne `wc -c < ./L1/group2.L1`; then
	echo shar: \"./L1/group2.L1\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group2.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group2.sed\"
else
echo shar: Extracting \"./L1/group2.sed\" \(25 characters\)
sed "s/^X//" >./L1/group2.sed <<'END_OF_group2.sed'
/src\/ctex/d
X/lib\/tex/d
END_OF_group2.sed
chmod 644 ./L1/group2.sed
if test 25 -ne `wc -c < ./L1/group2.sed`; then
	echo shar: \"./L1/group2.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group3 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group3\"
else
echo shar: Extracting \"./L1/group3\" \(91 characters\)
sed "s/^X//" >./L1/group3 <<'END_OF_group3'
# Group3
X# 
Xfind /usr/bin /usr/lib -newer ../L0/group3.L0 -depth -print |sed -f group3.sed
END_OF_group3
chmod 744 ./L1/group3
if test 91 -ne `wc -c < ./L1/group3`; then
	echo shar: \"./L1/group3\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group3.L1 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group3.L1\"
else
echo shar: Extracting \"./L1/group3.L1\" \(29 characters\)
sed "s/^X//" >./L1/group3.L1 <<'END_OF_group3.L1'
Tue Aug 29 19:18:10 MST 1989
END_OF_group3.L1
chmod 644 ./L1/group3.L1
if test 29 -ne `wc -c < ./L1/group3.L1`; then
	echo shar: \"./L1/group3.L1\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group3.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group3.sed\"
else
echo shar: Extracting \"./L1/group3.sed\" \(32 characters\)
sed "s/^X//" >./L1/group3.sed <<'END_OF_group3.sed'
/^.* *\/usr\/bin\/DOS\/dvd000/d
END_OF_group3.sed
chmod 644 ./L1/group3.sed
if test 32 -ne `wc -c < ./L1/group3.sed`; then
	echo shar: \"./L1/group3.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group4 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group4\"
else
echo shar: Extracting \"./L1/group4\" \(78 characters\)
sed "s/^X//" >./L1/group4 <<'END_OF_group4'
# Group4
X# 
Xfind /usr -newer ../L0/group4.L0 -depth -print |sed -f group4.sed
END_OF_group4
chmod 744 ./L1/group4
if test 78 -ne `wc -c < ./L1/group4`; then
	echo shar: \"./L1/group4\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group4.L1 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group4.L1\"
else
echo shar: Extracting \"./L1/group4.L1\" \(29 characters\)
sed "s/^X//" >./L1/group4.L1 <<'END_OF_group4.L1'
Tue Aug 29 19:20:42 MST 1989
END_OF_group4.L1
chmod 644 ./L1/group4.L1
if test 29 -ne `wc -c < ./L1/group4.L1`; then
	echo shar: \"./L1/group4.L1\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group4.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group4.sed\"
else
echo shar: Extracting \"./L1/group4.sed\" \(102 characters\)
sed "s/^X//" >./L1/group4.sed <<'END_OF_group4.sed'
/^.* *\/usr\/catman/d
X/^.* *\/usr\/bin/d
X/^.* *\/usr\/lib/d
X/^.* *\/usr\/spool/d
X/^.* *\/usr\/local/d
END_OF_group4.sed
chmod 644 ./L1/group4.sed
if test 102 -ne `wc -c < ./L1/group4.sed`; then
	echo shar: \"./L1/group4.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group5 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group5\"
else
echo shar: Extracting \"./L1/group5\" \(83 characters\)
sed "s/^X//" >./L1/group5 <<'END_OF_group5'
# Group5: /(rest)
X#
Xfind / -newer ../L0/group5.L0 -depth -print |sed -f group5.sed
END_OF_group5
chmod 744 ./L1/group5
if test 83 -ne `wc -c < ./L1/group5`; then
	echo shar: \"./L1/group5\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group5.L1 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group5.L1\"
else
echo shar: Extracting \"./L1/group5.L1\" \(29 characters\)
sed "s/^X//" >./L1/group5.L1 <<'END_OF_group5.L1'
Tue Aug 29 19:28:07 MST 1989
END_OF_group5.L1
chmod 644 ./L1/group5.L1
if test 29 -ne `wc -c < ./L1/group5.L1`; then
	echo shar: \"./L1/group5.L1\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/group5.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/group5.sed\"
else
echo shar: Extracting \"./L1/group5.sed\" \(96 characters\)
sed "s/^X//" >./L1/group5.sed <<'END_OF_group5.sed'
/^\/usr\//d
X/^\/u\//d
X/^\/etc\/utmp/d
X/^\/etc\/wtmp/d
X/^\/etc\/drvtab/d
X/^\/dev\//d
X/^\/tmp\//d
END_OF_group5.sed
chmod 644 ./L1/group5.sed
if test 96 -ne `wc -c < ./L1/group5.sed`; then
	echo shar: \"./L1/group5.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L1/backup -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L1/backup\"
else
echo shar: Extracting \"./L1/backup\" \(174 characters\)
sed "s/^X//" >./L1/backup <<'END_OF_backup'
# Backup                      Last Modified                  19-Nov-88/jdc
X#
X# L0 backup--parameter is one of the 5 groups.
X#
X./$1 |cpio -ovB >/dev/rfp021
Xecho `date` >$1.L1
END_OF_backup
chmod 700 ./L1/backup
if test 174 -ne `wc -c < ./L1/backup`; then
	echo shar: \"./L1/backup\" unpacked with wrong size!
fi
# end of overwriting check
fi
if `test ! -d ./L2`
then
  mkdir ./L2
  echo "mkdir ./L2"
fi
if test -f ./L2/backup -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/backup\"
else
echo shar: Extracting \"./L2/backup\" \(172 characters\)
sed "s/^X//" >./L2/backup <<'END_OF_backup'
# Backup                      Last Modified                  2-Feb-89/jdc
X#
X# L2 backup--parameter is one of the 5 groups.
X#
X./$1 |cpio -ovB >/dev/rfp021
Xecho `date` >$1.2
END_OF_backup
chmod 700 ./L2/backup
if test 172 -ne `wc -c < ./L2/backup`; then
	echo shar: \"./L2/backup\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group1 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group1\"
else
echo shar: Extracting \"./L2/group1\" \(76 characters\)
sed "s/^X//" >./L2/group1 <<'END_OF_group1'
# Group1
X# 
Xfind /u -newer ../L1/group1.L1 -depth -print |sed -f group1.sed
END_OF_group1
chmod 744 ./L2/group1
if test 76 -ne `wc -c < ./L2/group1`; then
	echo shar: \"./L2/group1\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group2.L2 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group2.L2\"
else
echo shar: Extracting \"./L2/group2.L2\" \(28 characters\)
sed "s/^X//" >./L2/group2.L2 <<'END_OF_group2.L2'
Thu Feb 2 23:00:29 MST 1989
END_OF_group2.L2
chmod 644 ./L2/group2.L2
if test 28 -ne `wc -c < ./L2/group2.L2`; then
	echo shar: \"./L2/group2.L2\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group1.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group1.sed\"
else
echo shar: Extracting \"./L2/group1.sed\" \(135 characters\)
sed "s/^X//" >./L2/group1.sed <<'END_OF_group1.sed'
/jdc\/.*\readj/d
X/jdc\/.*\writej/d
X/jdc\/.*\/Int/d
X/jdc\/.*\/Readj/d
X/jdc\/.*\/Readj/d
X/u\/jdc\/Xfer\/Month/d
X/u\/jdc\/Xfer\/Gnuplot/d
END_OF_group1.sed
chmod 644 ./L2/group1.sed
if test 135 -ne `wc -c < ./L2/group1.sed`; then
	echo shar: \"./L2/group1.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group2 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group2\"
else
echo shar: Extracting \"./L2/group2\" \(84 characters\)
sed "s/^X//" >./L2/group2 <<'END_OF_group2'
# Group2
X# 
Xfind /usr/local -newer ../L1/group2.L1 -depth -print |sed -f group2.sed
END_OF_group2
chmod 744 ./L2/group2
if test 84 -ne `wc -c < ./L2/group2`; then
	echo shar: \"./L2/group2\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group3.2 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group3.2\"
else
echo shar: Extracting \"./L2/group3.2\" \(28 characters\)
sed "s/^X//" >./L2/group3.2 <<'END_OF_group3.2'
Thu Feb 2 23:04:16 MST 1989
END_OF_group3.2
chmod 644 ./L2/group3.2
if test 28 -ne `wc -c < ./L2/group3.2`; then
	echo shar: \"./L2/group3.2\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group2.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group2.sed\"
else
echo shar: Extracting \"./L2/group2.sed\" \(25 characters\)
sed "s/^X//" >./L2/group2.sed <<'END_OF_group2.sed'
/src\/ctex/d
X/lib\/tex/d
END_OF_group2.sed
chmod 644 ./L2/group2.sed
if test 25 -ne `wc -c < ./L2/group2.sed`; then
	echo shar: \"./L2/group2.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group3 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group3\"
else
echo shar: Extracting \"./L2/group3\" \(91 characters\)
sed "s/^X//" >./L2/group3 <<'END_OF_group3'
# Group3
X# 
Xfind /usr/bin /usr/lib -newer ../L1/group3.L1 -depth -print |sed -f group3.sed
END_OF_group3
chmod 744 ./L2/group3
if test 91 -ne `wc -c < ./L2/group3`; then
	echo shar: \"./L2/group3\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group1.L2 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group1.L2\"
else
echo shar: Extracting \"./L2/group1.L2\" \(28 characters\)
sed "s/^X//" >./L2/group1.L2 <<'END_OF_group1.L2'
Thu Feb 2 22:58:23 MST 1989
END_OF_group1.L2
chmod 644 ./L2/group1.L2
if test 28 -ne `wc -c < ./L2/group1.L2`; then
	echo shar: \"./L2/group1.L2\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group3.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group3.sed\"
else
echo shar: Extracting \"./L2/group3.sed\" \(32 characters\)
sed "s/^X//" >./L2/group3.sed <<'END_OF_group3.sed'
/^.* *\/usr\/bin\/DOS\/dvd000/d
END_OF_group3.sed
chmod 644 ./L2/group3.sed
if test 32 -ne `wc -c < ./L2/group3.sed`; then
	echo shar: \"./L2/group3.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group4 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group4\"
else
echo shar: Extracting \"./L2/group4\" \(78 characters\)
sed "s/^X//" >./L2/group4 <<'END_OF_group4'
# Group4
X# 
Xfind /usr -newer ../L1/group4.L1 -depth -print |sed -f group4.sed
END_OF_group4
chmod 744 ./L2/group4
if test 78 -ne `wc -c < ./L2/group4`; then
	echo shar: \"./L2/group4\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group4.2 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group4.2\"
else
echo shar: Extracting \"./L2/group4.2\" \(28 characters\)
sed "s/^X//" >./L2/group4.2 <<'END_OF_group4.2'
Thu Feb 2 23:07:20 MST 1989
END_OF_group4.2
chmod 644 ./L2/group4.2
if test 28 -ne `wc -c < ./L2/group4.2`; then
	echo shar: \"./L2/group4.2\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group4.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group4.sed\"
else
echo shar: Extracting \"./L2/group4.sed\" \(102 characters\)
sed "s/^X//" >./L2/group4.sed <<'END_OF_group4.sed'
/^.* *\/usr\/catman/d
X/^.* *\/usr\/bin/d
X/^.* *\/usr\/lib/d
X/^.* *\/usr\/spool/d
X/^.* *\/usr\/local/d
END_OF_group4.sed
chmod 644 ./L2/group4.sed
if test 102 -ne `wc -c < ./L2/group4.sed`; then
	echo shar: \"./L2/group4.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group5 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group5\"
else
echo shar: Extracting \"./L2/group5\" \(83 characters\)
sed "s/^X//" >./L2/group5 <<'END_OF_group5'
# Group5: /(rest)
X#
Xfind / -newer ../L1/group5.L1 -depth -print |sed -f group5.sed
END_OF_group5
chmod 744 ./L2/group5
if test 83 -ne `wc -c < ./L2/group5`; then
	echo shar: \"./L2/group5\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group5.2 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group5.2\"
else
echo shar: Extracting \"./L2/group5.2\" \(28 characters\)
sed "s/^X//" >./L2/group5.2 <<'END_OF_group5.2'
Thu Feb 2 23:09:51 MST 1989
END_OF_group5.2
chmod 644 ./L2/group5.2
if test 28 -ne `wc -c < ./L2/group5.2`; then
	echo shar: \"./L2/group5.2\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L2/group5.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L2/group5.sed\"
else
echo shar: Extracting \"./L2/group5.sed\" \(96 characters\)
sed "s/^X//" >./L2/group5.sed <<'END_OF_group5.sed'
/^\/usr\//d
X/^\/u\//d
X/^\/etc\/utmp/d
X/^\/etc\/wtmp/d
X/^\/etc\/drvtab/d
X/^\/dev\//d
X/^\/tmp\//d
END_OF_group5.sed
chmod 644 ./L2/group5.sed
if test 96 -ne `wc -c < ./L2/group5.sed`; then
	echo shar: \"./L2/group5.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if `test ! -d ./L0`
then
  mkdir ./L0
  echo "mkdir ./L0"
fi
if test -f ./L0/group1 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group1\"
else
echo shar: Extracting \"./L0/group1\" \(78 characters\)
sed "s/^X//" >./L0/group1 <<'END_OF_group1'
# Group1
X# 
Xfind /u -newer /etc/.installdate -depth -print |sed -f group1.sed
END_OF_group1
chmod 744 ./L0/group1
if test 78 -ne `wc -c < ./L0/group1`; then
	echo shar: \"./L0/group1\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group1.L0 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group1.L0\"
else
echo shar: Extracting \"./L0/group1.L0\" \(28 characters\)
sed "s/^X//" >./L0/group1.L0 <<'END_OF_group1.L0'
Mon Sep 4 14:58:08 MST 1989
END_OF_group1.L0
chmod 644 ./L0/group1.L0
if test 28 -ne `wc -c < ./L0/group1.L0`; then
	echo shar: \"./L0/group1.L0\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group1.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group1.sed\"
else
echo shar: Extracting \"./L0/group1.sed\" \(135 characters\)
sed "s/^X//" >./L0/group1.sed <<'END_OF_group1.sed'
/jdc\/.*\readj/d
X/jdc\/.*\writej/d
X/jdc\/.*\/Int/d
X/jdc\/.*\/Readj/d
X/jdc\/.*\/Readj/d
X/u\/jdc\/Xfer\/Month/d
X/u\/jdc\/Xfer\/Gnuplot/d
END_OF_group1.sed
chmod 644 ./L0/group1.sed
if test 135 -ne `wc -c < ./L0/group1.sed`; then
	echo shar: \"./L0/group1.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group2 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group2\"
else
echo shar: Extracting \"./L0/group2\" \(61 characters\)
sed "s/^X//" >./L0/group2 <<'END_OF_group2'
# Group2
X# 
Xfind /usr/local -depth -print |sed -f group2.sed
END_OF_group2
chmod 744 ./L0/group2
if test 61 -ne `wc -c < ./L0/group2`; then
	echo shar: \"./L0/group2\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group2.L0 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group2.L0\"
else
echo shar: Extracting \"./L0/group2.L0\" \(28 characters\)
sed "s/^X//" >./L0/group2.L0 <<'END_OF_group2.L0'
Mon Sep 4 15:19:01 MST 1989
END_OF_group2.L0
chmod 644 ./L0/group2.L0
if test 28 -ne `wc -c < ./L0/group2.L0`; then
	echo shar: \"./L0/group2.L0\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group2.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group2.sed\"
else
echo shar: Extracting \"./L0/group2.sed\" \(25 characters\)
sed "s/^X//" >./L0/group2.sed <<'END_OF_group2.sed'
/src\/ctex/d
X/lib\/tex/d
END_OF_group2.sed
chmod 644 ./L0/group2.sed
if test 25 -ne `wc -c < ./L0/group2.sed`; then
	echo shar: \"./L0/group2.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group3 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group3\"
else
echo shar: Extracting \"./L0/group3\" \(93 characters\)
sed "s/^X//" >./L0/group3 <<'END_OF_group3'
# Group3
X# 
Xfind /usr/bin /usr/lib -newer /etc/.installdate -depth -print |sed -f group3.sed
END_OF_group3
chmod 744 ./L0/group3
if test 93 -ne `wc -c < ./L0/group3`; then
	echo shar: \"./L0/group3\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group3.L0 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group3.L0\"
else
echo shar: Extracting \"./L0/group3.L0\" \(28 characters\)
sed "s/^X//" >./L0/group3.L0 <<'END_OF_group3.L0'
Mon Sep 4 15:40:30 MST 1989
END_OF_group3.L0
chmod 644 ./L0/group3.L0
if test 28 -ne `wc -c < ./L0/group3.L0`; then
	echo shar: \"./L0/group3.L0\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group3.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group3.sed\"
else
echo shar: Extracting \"./L0/group3.sed\" \(32 characters\)
sed "s/^X//" >./L0/group3.sed <<'END_OF_group3.sed'
/^.* *\/usr\/bin\/DOS\/dvd000/d
END_OF_group3.sed
chmod 644 ./L0/group3.sed
if test 32 -ne `wc -c < ./L0/group3.sed`; then
	echo shar: \"./L0/group3.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group4 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group4\"
else
echo shar: Extracting \"./L0/group4\" \(80 characters\)
sed "s/^X//" >./L0/group4 <<'END_OF_group4'
# Group4
X# 
Xfind /usr -newer /etc/.installdate -depth -print |sed -f group4.sed
END_OF_group4
chmod 744 ./L0/group4
if test 80 -ne `wc -c < ./L0/group4`; then
	echo shar: \"./L0/group4\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group4.L0 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group4.L0\"
else
echo shar: Extracting \"./L0/group4.L0\" \(28 characters\)
sed "s/^X//" >./L0/group4.L0 <<'END_OF_group4.L0'
Mon Sep 4 15:53:57 MST 1989
END_OF_group4.L0
chmod 644 ./L0/group4.L0
if test 28 -ne `wc -c < ./L0/group4.L0`; then
	echo shar: \"./L0/group4.L0\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group4.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group4.sed\"
else
echo shar: Extracting \"./L0/group4.sed\" \(102 characters\)
sed "s/^X//" >./L0/group4.sed <<'END_OF_group4.sed'
/^.* *\/usr\/catman/d
X/^.* *\/usr\/bin/d
X/^.* *\/usr\/lib/d
X/^.* *\/usr\/spool/d
X/^.* *\/usr\/local/d
END_OF_group4.sed
chmod 644 ./L0/group4.sed
if test 102 -ne `wc -c < ./L0/group4.sed`; then
	echo shar: \"./L0/group4.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group5 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group5\"
else
echo shar: Extracting \"./L0/group5\" \(85 characters\)
sed "s/^X//" >./L0/group5 <<'END_OF_group5'
# Group5: /(rest)
X#
Xfind / -newer /etc/.installdate -depth -print |sed -f group5.sed
END_OF_group5
chmod 744 ./L0/group5
if test 85 -ne `wc -c < ./L0/group5`; then
	echo shar: \"./L0/group5\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group5.L0 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group5.L0\"
else
echo shar: Extracting \"./L0/group5.L0\" \(28 characters\)
sed "s/^X//" >./L0/group5.L0 <<'END_OF_group5.L0'
Mon Sep 4 16:04:22 MST 1989
END_OF_group5.L0
chmod 644 ./L0/group5.L0
if test 28 -ne `wc -c < ./L0/group5.L0`; then
	echo shar: \"./L0/group5.L0\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/group5.sed -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/group5.sed\"
else
echo shar: Extracting \"./L0/group5.sed\" \(96 characters\)
sed "s/^X//" >./L0/group5.sed <<'END_OF_group5.sed'
/^\/usr\//d
X/^\/u\//d
X/^\/etc\/utmp/d
X/^\/etc\/wtmp/d
X/^\/etc\/drvtab/d
X/^\/dev\//d
X/^\/tmp\//d
END_OF_group5.sed
chmod 644 ./L0/group5.sed
if test 96 -ne `wc -c < ./L0/group5.sed`; then
	echo shar: \"./L0/group5.sed\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/000read.me -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/000read.me\"
else
echo shar: Extracting \"./L0/000read.me\" \(180 characters\)
sed "s/^X//" >./L0/000read.me <<'END_OF_000read.me'
L0 backups.  5 groups, all working with /etc/.installdate, when each is done 
Xthen a file like group1.L0 will be created.  This file may be used for L1
Xbackups (-newer group1.L0).
END_OF_000read.me
chmod 644 ./L0/000read.me
if test 180 -ne `wc -c < ./L0/000read.me`; then
	echo shar: \"./L0/000read.me\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ./L0/backup -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"./L0/backup\"
else
echo shar: Extracting \"./L0/backup\" \(174 characters\)
sed "s/^X//" >./L0/backup <<'END_OF_backup'
# Backup                      Last Modified                  19-Nov-88/jdc
X#
X# L0 backup--parameter is one of the 5 groups.
X#
X./$1 |cpio -ovB >/dev/rfp021
Xecho `date` >$1.L0
END_OF_backup
chmod 700 ./L0/backup
if test 174 -ne `wc -c < ./L0/backup`; then
	echo shar: \"./L0/backup\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo "shar: End of archive"
##	End of shell archive
exit 0


-- 
	John Campbell               ...!arizona!naucse!jdc
                                    CAMPBELL@NAUVAX.bitnet
	unix?  Sure send me a dozen, all different colors.