A Non-Networked File System

This page gives a short overview of a non-networked file system, which I have implemented to transfer files from my Sparc station in my office and my Linux Box at home, using a MS-DOS based file system as intermediate. The idea is syncronize two file systems with are on machines with no network connection.

It is based on time-stamps, and compares the modification times of files on the two machines. It also keeps a list of files (directories) that need to be ignored (e.g., it's no use to copy executables, between the two systems). The system consists of two scripts and one C program.

The implementation that I use is rather primitive, and also contains some unwanted features, but although I have often thought about improving it, I have never come to do it, as it does work fine for the purpose I am using it.

Compare program

The core of the system is based on the dcompare.c program. This program basically compares two directory listings (produced by ls), and makes asks the user about how the differences should be dealt with.

The program expects that the file .dt.in contains the directory listing of the other system, and that the file .dt.new the current directory listing of the you are exporting from. All files that are newer in .dt.new than in .dt.in, are candidates for being exported to the other machine. For each of this file the users can give the following replies:

y : Export the file. (The usual reply.)
n : Don't export the file, but ask again the next time.
i : Ignore the file, and do not ask for it again. (To be used for executables files, for example.)
d : Delete the file. (The reason can be that you have just deleted the file on the other machine, or that it is a temporary file like core.)

To keep track of which files (or directories) that should be ignored the file .dt.ignore is read and modified. This file can be added by hand.

At the end the program writes the following files:

.dt.make: containing the tar command to put all the selected files into a single archive.
.dt.del: containing a delete command (with "-i" switch) for deleting files, that have been marked as such.
.dt.out: which is going to replace the current version of .dt.in at the other machine.

(Of course, the .dt.ignore is also written.)

Export script

The script starts with:

#!/bin/csh

Then I have a line to also save a copy of by incoming mail box:

cp /usr/spool/mail/faase ~/inbox

Then I have to collect all the files.

set dtz = $1
echo $dtz
ls -dalg * */* */*/* >.dt.new

Actually, I am using something like the following, because the argument list gets to long. (Not so, nice, but it works.)

ls -dalg * >.dt.tmp
ls -dalg Calendar/* >>.dt.tmp
ls -dalg News/* News/*/*  >>.dt.tmp
ls -dalg Mail/* Mail/*/* >>.dt.tmp
....
sort +0.54 <.dt.tmp | uniq >.dt.new
rm .dt.tmp

Then I call the compare program, which compares .dt.new with .dt.out, and generates .dt.make, .dt.out and .dt.del. It also read and writes .dt.ignore.

dcompare

And now to the real job:

chmod +x .dt.make .dt.del
echo do:
more ./.dt.make
./.dt.make
echo zipping: 
gzip .dt.disk

And copy everything to disk:

echo copy to a:
mdel a:$dtz.DTZ
mdel a:$dtz.LS
echo mcopy .dt.disk.gz a:$dtz.DTZ
mcopy .dt.disk.gz a:$dtz.DTZ
echo mcopy .dt.out a:$dtz.LS
mcopy .dt.out a:$dtz.LS

Clean-up, and deleting old stuff. (Somehow this is nice. I do find all core-file that are generated, and can clean them up immediately.)

rm -i .dt.disk.gz
echo deleting:
./.dt.del
rm .dt.out .dt.new .dt.make .dt.del

Import script

#!/bin/csh
echo copy $1.DTZ to .dt.disk.gz
mcopy a:$1.DTZ .dt.disk.gz
echo copy $1.LS to .dt.in
mcopy a:$1.LS .dt.in
if ( -f .dt.disk.gz ) then
   echo unzip .dt.disk.gz to .dt.disk
   gzip -d .dt.disk.gz
else
   echo .dt.disk.gz not found
endif
if ( -f .dt.disk ) then
   echo untar .dt.disk
   tar -xwf .dt.disk
   rm -i .dt.disk
else
   echo .dt.disk not found
endif