1322 lines
29 KiB
Perl
1322 lines
29 KiB
Perl
use strict;
|
|
|
|
# todo: make sure and create the target directory if it doesn't exist.
|
|
# todo: make this work either direction
|
|
# todo: fix any case problems
|
|
|
|
my $g_protocol_version = "mccopy1\n";
|
|
my $g_opt_port = 7070;
|
|
my $g_server_md5 = 0;
|
|
|
|
use IO::Socket;
|
|
|
|
sub GetMD5
|
|
{
|
|
my $filename = shift;
|
|
$filename =~ s,/,\\,g;
|
|
# print "$filename\n";
|
|
print ".";
|
|
my( $cmd ) = "md5.exe < \"$filename\"";
|
|
# print $cmd . "\n";
|
|
open MD5, "$cmd|";
|
|
my $out = <MD5>;
|
|
close MD5;
|
|
$out =~ s/^.*\=\s+//;
|
|
$out =~ s/\n//g;
|
|
# print "'" . $out . "'" . "\n";
|
|
return $out;
|
|
}
|
|
|
|
################################################################################################
|
|
# SERVER CODE
|
|
################################################################################################
|
|
sub SendFileName
|
|
{
|
|
my( $sock ) = shift;
|
|
my( $file ) = shift;
|
|
my( $isdir ) = -d $file;
|
|
|
|
if( $isdir )
|
|
{
|
|
if( $file =~ m/\/\.$/ || # "."
|
|
$file =~ m/\/\.\.$/ ) # ".."
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
my( @statinfo ) = stat $file;
|
|
if( @statinfo )
|
|
{
|
|
my( $mtime ) = $statinfo[9];
|
|
my( $mode ) = $statinfo[2];
|
|
# my( $mtimestr ) = scalar( localtime( $mtime ) );
|
|
my( $size ) = $statinfo[7];
|
|
if( $isdir )
|
|
{
|
|
print $sock "d\n";
|
|
}
|
|
else
|
|
{
|
|
print $sock "f\n";
|
|
}
|
|
print $sock &RemoveBaseDir( $file ) . "\n";
|
|
print $sock $mtime . "\n";
|
|
printf $sock "%o\n", $mode;
|
|
print $sock $size . "\n";
|
|
if( !$isdir && $g_server_md5 )
|
|
{
|
|
print $sock &GetMD5( $file ) . "\n";
|
|
}
|
|
# print $file . "\n";
|
|
# print $mtime . "\n";
|
|
# print $mode . "\n";
|
|
# print $md5 . "\n";
|
|
}
|
|
else
|
|
{
|
|
print "CAN'T STAT $file\n";
|
|
}
|
|
|
|
if( $isdir )
|
|
{
|
|
SendDirName( $sock, $file );
|
|
}
|
|
}
|
|
|
|
|
|
sub SendDirName
|
|
{
|
|
my( $sock ) = shift;
|
|
my( $dirname ) = shift;
|
|
if( $dirname =~ m/\/\.$/ || # "."
|
|
$dirname =~ m/\/\.\.$/ ) # ".."
|
|
{
|
|
return;
|
|
}
|
|
|
|
local( *SRCDIR );
|
|
opendir SRCDIR, $dirname;
|
|
my( @dir ) = readdir SRCDIR;
|
|
closedir SRCDIR;
|
|
|
|
my( $item );
|
|
while( $item = shift @dir )
|
|
{
|
|
&SendFileName( $sock, $dirname . "/" . $item );
|
|
}
|
|
}
|
|
|
|
sub GetFile
|
|
{
|
|
my( $sock ) = shift;
|
|
my( $filename ) = shift;
|
|
my( $localfilename ) = &AddBaseDir( $filename );
|
|
print "GetFile: $filename ($localfilename)\n";
|
|
local( *FILE );
|
|
open FILE, "<$localfilename";
|
|
binmode( FILE );
|
|
my( $filebits );
|
|
seek FILE, 0, 2;
|
|
my( $size ) = tell FILE;
|
|
if( $size < 0 )
|
|
{
|
|
die "$filename \$size == $size\n";
|
|
}
|
|
seek FILE, 0, 0;
|
|
read FILE, $filebits, $size;
|
|
close FILE;
|
|
# print "sending $filename: $size\n";
|
|
print $sock $filebits;
|
|
# print "finished sending $filename\n";
|
|
}
|
|
|
|
sub HandleCommand
|
|
{
|
|
my( $sock ) = shift;
|
|
my( $cmd ) = shift;
|
|
|
|
if( $cmd =~ m/dirlistmd5\s+(.*)$/ )
|
|
{
|
|
$g_server_md5 = 1;
|
|
&SetBaseDir( $1 );
|
|
&SendDirName( $sock, $1 );
|
|
print $sock "\n"; # terminating newline to end reply
|
|
}
|
|
elsif( $cmd =~ m/dirlist\s+(.*)$/ )
|
|
{
|
|
$g_server_md5 = 0;
|
|
&SetBaseDir( $1 );
|
|
&SendDirName( $sock, $1 );
|
|
print $sock "\n"; # terminating newline to end reply
|
|
}
|
|
elsif( $cmd =~ m/getfile\s+(.*)$/ )
|
|
{
|
|
&GetFile( $sock, $1 );
|
|
}
|
|
}
|
|
|
|
sub RunServer
|
|
{
|
|
my( $hostname ) = `hostname`;
|
|
# my( $hostname ) = "localhost";
|
|
$hostname =~ s/\n//; # remove newlines
|
|
|
|
my $sock = new IO::Socket::INET (
|
|
LocalHost => $hostname,
|
|
LocalPort => $g_opt_port,
|
|
Proto => 'tcp',
|
|
Listen => 1,
|
|
Reuse => 1,
|
|
);
|
|
die "Could not create socket: $!\n" unless $sock;
|
|
|
|
my( $clientnum ) = 0;
|
|
while( 1 )
|
|
{
|
|
my $new_sock = $sock->accept();
|
|
print "accept!\n";
|
|
if( fork() == 0 )
|
|
{
|
|
print "$clientnum: opening connection...\n";
|
|
my $version = <$new_sock>;
|
|
if( $version ne $g_protocol_version )
|
|
{
|
|
die "wrong protocol version: server: $g_protocol_version client: %version\n";
|
|
}
|
|
my $command;
|
|
while(defined($command = <$new_sock>))
|
|
{
|
|
print "$clientnum: command: $command";
|
|
&HandleCommand( $new_sock, $command );
|
|
print "$clientnum: done with $command";
|
|
}
|
|
print "$clientnum: closing connection...\n";
|
|
close( $new_sock );
|
|
exit;
|
|
}
|
|
$clientnum++;
|
|
}
|
|
|
|
close($sock); # never get here.
|
|
}
|
|
|
|
################################################################################################
|
|
# CLIENT CODE
|
|
################################################################################################
|
|
|
|
|
|
# all options that we might care about from rsync:
|
|
# -v, --verbose increase verbosity
|
|
# -q, --quiet decrease verbosity
|
|
# -c, --checksum always checksum
|
|
# -a, --archive archive mode
|
|
# -r, --recursive recurse into directories
|
|
# -R, --relative use relative path names
|
|
# -b, --backup make backups (default ~ suffix)
|
|
# --backup-dir=DIR put backups in the specified directory
|
|
# --suffix=SUFFIX override backup suffix
|
|
# -u, --update update only (don't overwrite newer files)
|
|
# -p, --perms preserve permissions
|
|
# -t, --times preserve times
|
|
# -n, --dry-run show what would have been transferred
|
|
# --existing only update files that already exist
|
|
# --delete delete files that don't exist on the sending side
|
|
# --delete-excluded also delete excluded files on the receiving side
|
|
# --delete-after delete after transferring, not before
|
|
# --max-delete=NUM don't delete more than NUM files
|
|
# --force force deletion of directories even if not empty
|
|
# --timeout=TIME set IO timeout in seconds
|
|
# -I, --ignore-times don't exclude files that match length and time
|
|
# --size-only only use file size when determining if a file should be transferred
|
|
# -T --temp-dir=DIR create temporary files in directory DIR
|
|
# --compare-dest=DIR also compare destination files relative to DIR
|
|
# -P equivalent to --partial --progress
|
|
# -z, --compress compress file data
|
|
# --exclude=PATTERN exclude files matching PATTERN
|
|
# --exclude-from=FILE exclude patterns listed in FILE
|
|
# --include=PATTERN don't exclude files matching PATTERN
|
|
# --include-from=FILE don't exclude patterns listed in FILE
|
|
# --version print version number
|
|
# --daemon run as a rsync daemon
|
|
# --address bind to the specified address
|
|
# --stats give some file transfer stats
|
|
# --progress show progress during transfer
|
|
# -h, --help show this help screen
|
|
|
|
# options that are actually implemented:
|
|
#
|
|
sub Usage
|
|
{
|
|
print "\n";
|
|
print "Usage:\n";
|
|
print "perl McCopy.pl --server\n";
|
|
print "or\n";
|
|
print "perl McCopy.pl [options] srcdir dstdir\n";
|
|
print "\n";
|
|
print "ie:\n";
|
|
print "perl McCopy.pl --verbose --recursive remotemachine:u:/hl u:/hl.work\n";
|
|
print "\n";
|
|
print "where \"remotemachine\" is running a McCopy server\n";
|
|
print "\n";
|
|
print "options are:\n";
|
|
print "--server run as server (ignores other options)\n";
|
|
print "--port N (default 7070)\n";
|
|
print "--verbose\n";
|
|
print "--test don't actually copy or delete any files\n";
|
|
print "--ignore-time don't use file mtimes as a criterion for file that need\n";
|
|
print " to be copied.\n";
|
|
print "--ignore-permissions don't use file permissions as a criterion for file that\n";
|
|
print " need to be copied.\n";
|
|
print "--ignore-size don't use file size as a criterion for file that need\n";
|
|
print " to be copied.\n";
|
|
print "--md5 Use md5 checksums\n";
|
|
print "--recursive\n";
|
|
print "--delete-readonly delete readonly files in dst\n";
|
|
print " that don't exist in src\n";
|
|
print "--delete-writable delete writable files in dst\n";
|
|
print "--delete-dirs delete directories in dst that don't exist in src\n";
|
|
print "--clobber-writable-newer\n";
|
|
print " write over upon copy files that have been modified locally\n";
|
|
print "--delete-excluded delete files on dst that are excluded using --exclude\n";
|
|
print "--exclude exclude files containing perl regular expression, ie:\n";
|
|
print " --exclude /.*release.*/i\n";
|
|
print "--include override --exclude for files containing perl regular expression, ie:\n";
|
|
print " --include /.*debughlp.*/i\n";
|
|
print "--mirror same as --recursive --delete-readonly --delete-writable\n";
|
|
print " --clobber-writable-newer --delete-excluded --delete-dirs\n";
|
|
print "--mirror-safe same as --recursive --delete-readonly --delete-dirs\n";
|
|
exit;
|
|
}
|
|
|
|
# default command line options
|
|
my $g_opt_server = 0;
|
|
my $g_opt_test = 0;
|
|
my $g_opt_verbose = 0;
|
|
my $g_opt_recursive = 0;
|
|
my $g_opt_deletereadonly = 0;
|
|
my $g_opt_deletewritable = 0;
|
|
my $g_opt_clobberwritablenewer = 0;
|
|
my $g_opt_deleteexcluded = 0;
|
|
my $g_opt_deletedirs = 0;
|
|
my $g_opt_ignoretime = 0;
|
|
my $g_opt_ignoreperms = 0;
|
|
my $g_opt_ignoresize = 0;
|
|
my @g_opt_exclude;
|
|
my @g_opt_include;
|
|
my $g_opt_src;
|
|
my $g_opt_dst;
|
|
my $g_opt_md5;
|
|
|
|
my $g_src_is_local;
|
|
my $g_src_machine = "";
|
|
my $g_src_path;
|
|
|
|
my $g_dst_is_local;
|
|
my $g_dst_machine = "";
|
|
my $g_dst_path;
|
|
|
|
# indexed by $filename
|
|
my %g_remote_mtime;
|
|
my %g_remote_mode;
|
|
my %g_remote_isdir;
|
|
my %g_remote_size;
|
|
my %g_remote_md5;
|
|
|
|
my %g_local_mtime;
|
|
my %g_local_mode;
|
|
my %g_local_isdir;
|
|
my %g_local_size;
|
|
my %g_local_md5;
|
|
|
|
my %g_alreadycomparedtime;
|
|
my %g_alreadycomparedpermissions;
|
|
my %g_alreadycomparedsize;
|
|
my %g_alreadycomparedmd5;
|
|
|
|
my %g_files_to_delete;
|
|
my %g_dirs_to_delete;
|
|
my %g_files_to_copy;
|
|
my %g_dirs_to_create;
|
|
|
|
my $g_max_time_delta = 2; # in seconds
|
|
|
|
my $g_basedir;
|
|
|
|
sub BackToForwardSlash
|
|
{
|
|
my( $path ) = shift;
|
|
$path =~ s,\\,/,g;
|
|
return $path;
|
|
}
|
|
|
|
sub ForwardToBackSlash
|
|
{
|
|
my( $path ) = shift;
|
|
$path =~ s,/,\\,g;
|
|
return $path;
|
|
}
|
|
|
|
sub SetBaseDir
|
|
{
|
|
$g_basedir = shift;
|
|
# print "\$g_basedir: $g_basedir\n";
|
|
}
|
|
|
|
sub RemoveFileName
|
|
{
|
|
my( $in ) = shift;
|
|
$in = &BackToForwardSlash( $in );
|
|
$in =~ s,/[^/]*$,,;
|
|
return $in;
|
|
}
|
|
|
|
sub RemovePath
|
|
{
|
|
my( $in ) = shift;
|
|
$in = &BackToForwardSlash( $in );
|
|
$in =~ s,^(.*)/([^/]*)$,$2,;
|
|
return $in;
|
|
}
|
|
|
|
|
|
sub MakeDirHier
|
|
{
|
|
my( $in ) = shift;
|
|
# print "MakeDirHier( $in )\n";
|
|
$in = &BackToForwardSlash( $in );
|
|
my( @path );
|
|
while( $in =~ m,/, ) # while $in still has a slash
|
|
{
|
|
my( $end ) = &RemovePath( $in );
|
|
push @path, $end;
|
|
# print $in . "\n";
|
|
$in = &RemoveFileName( $in );
|
|
}
|
|
my( $i );
|
|
my( $numelems ) = scalar( @path );
|
|
my( $curpath );
|
|
for( $i = $numelems - 1; $i >= 0; $i-- )
|
|
{
|
|
$curpath .= "/" . $path[$i];
|
|
my( $dir ) = $in . $curpath;
|
|
if( !stat $dir )
|
|
{
|
|
print "mkdir $dir\n";
|
|
mkdir $dir, 0777;
|
|
}
|
|
}
|
|
}
|
|
|
|
sub RemoveBaseDir
|
|
{
|
|
my( $path ) = shift;
|
|
# print "removebasedir: $path ";
|
|
$path =~ s,^$g_basedir/,,;
|
|
# print "$path\n";
|
|
return $path;
|
|
}
|
|
|
|
sub AddBaseDir
|
|
{
|
|
my( $path ) = shift;
|
|
return $g_basedir . "/" . $path;
|
|
}
|
|
|
|
sub FixPath
|
|
{
|
|
my( $path ) = shift;
|
|
# backslash to forward slash
|
|
$path =~ s,\\,/,g;
|
|
# remove trailing slash
|
|
$path =~ s,/$,,;
|
|
return $path;
|
|
}
|
|
|
|
sub ProcessLongCommand
|
|
{
|
|
my( $cmd ) = shift;
|
|
if( $cmd =~ m/--verbose/ )
|
|
{
|
|
$g_opt_verbose = 1;
|
|
}
|
|
elsif( $cmd =~ m/--server/ )
|
|
{
|
|
$g_opt_server = 1;
|
|
}
|
|
elsif( $cmd =~ m/--test/ )
|
|
{
|
|
$g_opt_test = 1;
|
|
}
|
|
elsif( $cmd =~ m/--ignore-time/ )
|
|
{
|
|
$g_opt_ignoretime = 1;
|
|
}
|
|
elsif( $cmd =~ m/--ignore-permissions/ )
|
|
{
|
|
$g_opt_ignoreperms = 1;
|
|
}
|
|
elsif( $cmd =~ m/--ignore-size/ )
|
|
{
|
|
$g_opt_ignoresize = 1;
|
|
}
|
|
elsif( $cmd =~ m/--md5/ )
|
|
{
|
|
$g_opt_md5 = 1;
|
|
}
|
|
elsif( $cmd =~ m/--recursive/ )
|
|
{
|
|
$g_opt_recursive = 1;
|
|
}
|
|
elsif( $cmd =~ m/--mirror-safe/ )
|
|
{
|
|
$g_opt_recursive = 1;
|
|
$g_opt_deletereadonly = 1;
|
|
$g_opt_deletewritable = 0;
|
|
$g_opt_clobberwritablenewer = 0;
|
|
$g_opt_deleteexcluded = 0;
|
|
$g_opt_deletedirs = 1;
|
|
}
|
|
elsif( $cmd =~ m/--mirror/ )
|
|
{
|
|
$g_opt_recursive = 1;
|
|
$g_opt_deletereadonly = 1;
|
|
$g_opt_deletewritable = 1;
|
|
$g_opt_clobberwritablenewer = 1;
|
|
$g_opt_deleteexcluded = 1;
|
|
$g_opt_deletedirs = 1;
|
|
}
|
|
elsif( $cmd =~ m/--delete-readonly/ )
|
|
{
|
|
$g_opt_deletereadonly = 1;
|
|
}
|
|
elsif( $cmd =~ m/--delete-writable/ )
|
|
{
|
|
$g_opt_deletewritable = 1;
|
|
}
|
|
elsif( $cmd =~ m/--clobber-writable-newer/ )
|
|
{
|
|
$g_opt_clobberwritablenewer = 1;
|
|
}
|
|
elsif( $cmd =~ m/--delete-excluded/ )
|
|
{
|
|
$g_opt_deleteexcluded = 1;
|
|
}
|
|
elsif( $cmd =~ m/--delete-dirs/ )
|
|
{
|
|
$g_opt_deletedirs = 1;
|
|
}
|
|
}
|
|
|
|
sub ProcessCommandLine
|
|
{
|
|
my( $cmd );
|
|
while( $cmd = shift )
|
|
{
|
|
# hack - special case for exclude since it has an argument
|
|
if( $cmd =~ m/^--exclude/ )
|
|
{
|
|
push @g_opt_exclude, shift;
|
|
}
|
|
elsif( $cmd =~ m/^--include/ )
|
|
{
|
|
push @g_opt_include, shift;
|
|
}
|
|
elsif( $cmd =~ m/^--port/ )
|
|
{
|
|
$g_opt_port = shift;
|
|
}
|
|
elsif( $cmd =~ m/^--/ )
|
|
{
|
|
&ProcessLongCommand( $cmd );
|
|
}
|
|
elsif( $cmd =~ m/^-/ )
|
|
{
|
|
print "short command $cmd\n";
|
|
}
|
|
else
|
|
{
|
|
if( !defined( $g_opt_src ) )
|
|
{
|
|
$g_opt_src = &FixPath( $cmd );
|
|
}
|
|
elsif( !defined( $g_opt_dst ) )
|
|
{
|
|
$g_opt_dst = &FixPath( $cmd );
|
|
}
|
|
else
|
|
{
|
|
print "Don't understand $cmd\n";
|
|
&Usage();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sub PrintOptions
|
|
{
|
|
if( $g_opt_verbose )
|
|
{
|
|
print "\n";
|
|
print "Options:\n";
|
|
print "\$g_opt_src = $g_opt_src\n";
|
|
print "\$g_opt_dst = $g_opt_dst\n";
|
|
print "\$g_opt_test = $g_opt_test\n";
|
|
print "\$g_opt_ignoretime = $g_opt_ignoretime\n";
|
|
print "\$g_opt_ignoreperms = $g_opt_ignoreperms\n";
|
|
print "\$g_opt_ignoresize = $g_opt_ignoresize\n";
|
|
print "\$g_opt_verbose = $g_opt_verbose\n";
|
|
print "\$g_opt_recursive = $g_opt_recursive\n";
|
|
print "\$g_opt_deletereadonly = $g_opt_deletereadonly\n";
|
|
print "\$g_opt_deletewritable = $g_opt_deletewritable\n";
|
|
print "\$g_opt_clobberwritablenewer = $g_opt_clobberwritablenewer\n";
|
|
print "\$g_opt_deleteexcluded = $g_opt_deleteexcluded\n";
|
|
print "\@g_opt_exclude = @g_opt_exclude\n";
|
|
print "\n";
|
|
}
|
|
}
|
|
|
|
sub ValidateOptions
|
|
{
|
|
if( $g_opt_server )
|
|
{
|
|
return;
|
|
}
|
|
if( !defined( $g_opt_src ) )
|
|
{
|
|
print "src not defined\n";
|
|
Usage();
|
|
}
|
|
if( !defined( $g_opt_dst ) )
|
|
{
|
|
print "dst not defined\n";
|
|
Usage();
|
|
}
|
|
if( !$g_opt_recursive )
|
|
{
|
|
print "--recursive must be used. . non-recursive operation not supported\n";
|
|
Usage();
|
|
}
|
|
}
|
|
|
|
# src/dst looks like:
|
|
# gary:u:/hl2/hl2
|
|
# u:/hl2/hl2
|
|
# /hl2/hl2
|
|
|
|
sub ParseSrcDstPaths
|
|
{
|
|
# print $g_opt_src . "\n";
|
|
if( $g_opt_src =~ m/(\S+)\:(\S\:\S*)/ )
|
|
{
|
|
$g_src_is_local = 0;
|
|
$g_src_machine = $1;
|
|
$g_src_path = $2;
|
|
}
|
|
elsif( $g_opt_src =~ m/(\S+)\:(\/\/.*)/ )
|
|
{
|
|
# //gary://maxwell/common/
|
|
$g_src_is_local = 0;
|
|
$g_src_machine = $1;
|
|
$g_src_path = $2;
|
|
}
|
|
elsif( $g_opt_src =~ m/^(\S:.*)/ )
|
|
{
|
|
$g_src_is_local = 1;
|
|
$g_src_path = $1;
|
|
}
|
|
else
|
|
{
|
|
$g_src_is_local = 1;
|
|
$g_src_path = $1;
|
|
}
|
|
|
|
if( $g_opt_dst =~ m/(\S+):(\S:\S+)/ )
|
|
{
|
|
$g_dst_is_local = 0;
|
|
$g_dst_machine = $1;
|
|
$g_dst_path = $2;
|
|
}
|
|
elsif( $g_opt_dst =~ m/^(\S:\S+)/ )
|
|
{
|
|
$g_dst_is_local = 1;
|
|
$g_dst_path = $1;
|
|
}
|
|
else
|
|
{
|
|
$g_dst_is_local = 1;
|
|
$g_dst_path = $1;
|
|
}
|
|
|
|
if( $g_src_is_local )
|
|
{
|
|
die "my src directories not supported yet. . run the server on the other end.\n";
|
|
}
|
|
if( !$g_dst_is_local )
|
|
{
|
|
die "remote dst directories not supported yet. . run the server on the other end.\n";
|
|
}
|
|
if( $g_src_is_local == $g_dst_is_local )
|
|
{
|
|
die "src and dst on the same machine not supported. . use robocopy\n";
|
|
}
|
|
|
|
&MakeDirHier( $g_dst_path );
|
|
|
|
&SetBaseDir( $g_dst_path );
|
|
|
|
if( $g_opt_verbose )
|
|
{
|
|
print "\n\$g_src_is_local = $g_src_is_local\n";
|
|
print "\$g_src_machine = $g_src_machine\n";
|
|
print "\$g_src_path = $g_src_path\n";
|
|
print "\$g_dst_is_local = $g_dst_is_local\n";
|
|
print "\$g_dst_machine = $g_dst_machine\n";
|
|
print "\$g_dst_path = $g_dst_path\n\n";
|
|
}
|
|
}
|
|
|
|
&ProcessCommandLine( @ARGV );
|
|
&ValidateOptions();
|
|
&PrintOptions();
|
|
|
|
if( $g_opt_server )
|
|
{
|
|
&RunServer();
|
|
exit;
|
|
}
|
|
|
|
&ParseSrcDstPaths();
|
|
|
|
sub GetRemoteDirList
|
|
{
|
|
my( $sock ) = shift;
|
|
my( $remotedirname ) = shift;
|
|
if( $g_opt_md5 )
|
|
{
|
|
print $sock "dirlistmd5 $remotedirname\n";
|
|
}
|
|
else
|
|
{
|
|
print $sock "dirlist $remotedirname\n";
|
|
}
|
|
my( $filename, $mtime, $mode, $size );
|
|
my $fileordir;
|
|
# while( defined( $fileordir = <$sock> ) )
|
|
while( 1 )
|
|
{
|
|
$fileordir = <$sock>;
|
|
die "Lost connection!!!" if !defined( $fileordir );
|
|
last if $fileordir=~ m/^\n$/;
|
|
|
|
$filename = <$sock>;
|
|
$mtime = <$sock>;
|
|
$mode = <$sock>;
|
|
$size = <$sock>;
|
|
my $md5 = "";
|
|
if( ( $fileordir =~ /f/i ) && $g_opt_md5 )
|
|
{
|
|
$md5 = <$sock>;
|
|
}
|
|
if( 0 )
|
|
{
|
|
print "file: $filename";
|
|
print "fileordir: $fileordir";
|
|
print "mtime: $mtime";
|
|
print "mode: $mode";
|
|
print "size: $size\n";
|
|
}
|
|
$filename =~ s/\n//;
|
|
$mtime =~ s/\n//;
|
|
$mode =~ s/\n//;
|
|
$size =~ s/\n//;
|
|
$md5 =~ s/\n//;
|
|
if( $fileordir =~ m/d/ )
|
|
{
|
|
# print $filename . " is a dir\n";
|
|
$g_remote_isdir{$filename} = 1;
|
|
}
|
|
else
|
|
{
|
|
$g_remote_isdir{$filename} = 0;
|
|
}
|
|
$g_remote_mtime{$filename} = $mtime;
|
|
# print $g_remote_mtime{$filename};
|
|
$g_remote_mode{$filename} = $mode;
|
|
$g_remote_size{$filename} = $size;
|
|
if( $g_opt_md5 )
|
|
{
|
|
$g_remote_md5{$filename} = $md5;
|
|
}
|
|
}
|
|
}
|
|
|
|
sub GetLocalDirList_File
|
|
{
|
|
my( $filename ) = shift;
|
|
my( $isdir ) = -d $filename;
|
|
if( $isdir )
|
|
{
|
|
if( $filename =~ m/\/\.$/ || # "."
|
|
$filename =~ m/\/\.\.$/ ) # ".."
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
if( $isdir )
|
|
{
|
|
GetLocalDirList_Dir( $filename );
|
|
}
|
|
my( @statinfo ) = stat $filename;
|
|
if( @statinfo )
|
|
{
|
|
my( $mtime ) = $statinfo[9];
|
|
my( $mode ) = $statinfo[2];
|
|
# my( $mtimestr ) = scalar( localtime( $mtime ) );
|
|
my( $size ) = $statinfo[7];
|
|
my( $filename_nobase ) = &RemoveBaseDir( $filename );
|
|
$g_local_isdir{$filename_nobase} = $isdir;
|
|
$g_local_mtime{$filename_nobase} = $mtime;
|
|
$g_local_mode{$filename_nobase} = sprintf "%o", $mode;
|
|
$g_local_size{$filename_nobase} = $size;
|
|
if( !$isdir && $g_opt_md5 )
|
|
{
|
|
$g_local_md5{$filename_nobase} = &GetMD5( $filename );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
print "CAN'T STAT $filename\n";
|
|
}
|
|
}
|
|
|
|
sub GetLocalDirList_Dir
|
|
{
|
|
my( $dirname ) = shift;
|
|
if( $dirname =~ m/\/\.$/ || # "."
|
|
$dirname =~ m/\/\.\.$/ ) # ".."
|
|
{
|
|
return;
|
|
}
|
|
|
|
local( *SRCDIR );
|
|
opendir SRCDIR, $dirname;
|
|
my( @dir ) = readdir SRCDIR;
|
|
closedir SRCDIR;
|
|
|
|
my( $item );
|
|
while( $item = shift @dir )
|
|
{
|
|
&GetLocalDirList_File( $dirname . "/" . $item );
|
|
}
|
|
}
|
|
|
|
sub IsExcluded
|
|
{
|
|
my( $filename ) = shift;
|
|
my( $regexp );
|
|
foreach $regexp ( @g_opt_include )
|
|
{
|
|
if( eval "\$filename =~ $regexp" )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
foreach $regexp ( @g_opt_exclude )
|
|
{
|
|
if( eval "\$filename =~ $regexp" )
|
|
{
|
|
if( defined( $g_local_mtime{$filename} ) )
|
|
{
|
|
if( $g_opt_deleteexcluded )
|
|
{
|
|
print "excluding and deleting $filename\n" if( $g_opt_verbose );
|
|
if( defined $g_remote_isdir{$filename} )
|
|
{
|
|
if( $g_remote_isdir{$filename} )
|
|
{
|
|
$g_dirs_to_delete{$filename} = 1;
|
|
}
|
|
else
|
|
{
|
|
$g_files_to_delete{$filename} = 1;
|
|
}
|
|
}
|
|
elsif( defined $g_local_isdir{$filename} )
|
|
{
|
|
if( $g_local_isdir{$filename} )
|
|
{
|
|
$g_dirs_to_delete{$filename} = 1;
|
|
}
|
|
else
|
|
{
|
|
$g_files_to_delete{$filename} = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
die;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
print "excluding but keeping my copy of $filename\n" if( $g_opt_verbose );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
print "excluding $filename, which doesn't exist locally\n" if( $g_opt_verbose );
|
|
}
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
sub CompareTime
|
|
{
|
|
if( $g_opt_ignoretime )
|
|
{
|
|
return;
|
|
}
|
|
my( $filename ) = shift;
|
|
# hack! ignore directories. . seems like robocopy does too.
|
|
if( $g_remote_isdir{$filename} || $g_local_isdir{$filename} )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( defined( $g_alreadycomparedtime{$filename} ) )
|
|
{
|
|
return;
|
|
}
|
|
$g_alreadycomparedtime{$filename} = 1;
|
|
|
|
# compare times
|
|
my( $deltatime ) = $g_local_mtime{$filename} - $g_remote_mtime{$filename};
|
|
# print "g_remote_mtime: " . $g_remote_mtime{$filename} . "\n";
|
|
# print "g_local_mtime: " . $g_local_mtime{$filename} . "\n";
|
|
# print "deltatime: $deltatime\n";
|
|
if( !( ( $deltatime >= -$g_max_time_delta && $deltatime <= $g_max_time_delta ) ||
|
|
( $deltatime + 3600 >= -$g_max_time_delta && $deltatime + 3600 <= $g_max_time_delta ) ||
|
|
( $deltatime - 3600 >= -$g_max_time_delta && $deltatime - 3600 <= $g_max_time_delta ) ) )
|
|
{
|
|
$g_files_to_copy{$filename} = 1;
|
|
if( $g_opt_verbose )
|
|
{
|
|
print "timedelta of $deltatime for $filename\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
sub ComparePermissions
|
|
{
|
|
if( $g_opt_ignoreperms )
|
|
{
|
|
return;
|
|
}
|
|
my( $filename ) = shift;
|
|
if( defined( $g_alreadycomparedpermissions{$filename} ) )
|
|
{
|
|
return;
|
|
}
|
|
$g_alreadycomparedpermissions{$filename} = 1;
|
|
|
|
# compare permissions
|
|
if( $g_remote_mode{$filename} != $g_local_mode{$filename} )
|
|
{
|
|
if( !$g_remote_isdir{$filename} )
|
|
{
|
|
$g_files_to_copy{$filename} = 1;
|
|
}
|
|
else
|
|
{
|
|
MakeLocalFileAttribsMatchRemote( $filename );
|
|
}
|
|
if( $g_opt_verbose )
|
|
{
|
|
printf "permissions different for $filename: %s %s\n", $g_remote_mode{$filename}, $g_local_mode{$filename};
|
|
}
|
|
}
|
|
}
|
|
|
|
sub CompareSize
|
|
{
|
|
if( $g_opt_ignoresize )
|
|
{
|
|
return;
|
|
}
|
|
my( $filename ) = shift;
|
|
if( defined( $g_alreadycomparedsize{$filename} ) )
|
|
{
|
|
return;
|
|
}
|
|
$g_alreadycomparedsize{$filename} = 1;
|
|
|
|
# compare permissions
|
|
if( $g_remote_size{$filename} != $g_local_size{$filename} )
|
|
{
|
|
$g_files_to_copy{$filename} = 1;
|
|
if( $g_opt_verbose )
|
|
{
|
|
printf "size different for $filename: %d!=%d\n", $g_remote_size{$filename}, $g_local_size{$filename};
|
|
}
|
|
}
|
|
}
|
|
|
|
sub CompareMD5
|
|
{
|
|
if( !$g_opt_md5 )
|
|
{
|
|
return;
|
|
}
|
|
my( $filename ) = shift;
|
|
if( defined( $g_alreadycomparedmd5{$filename} ) )
|
|
{
|
|
return;
|
|
}
|
|
$g_alreadycomparedmd5{$filename} = 1;
|
|
|
|
# compare md5
|
|
if( $g_remote_md5{$filename} ne $g_local_md5{$filename} )
|
|
{
|
|
$g_files_to_copy{$filename} = 1;
|
|
if( $g_opt_verbose )
|
|
{
|
|
printf "md5 different for $filename: %s!=%s\n", $g_remote_md5{$filename}, $g_local_md5{$filename};
|
|
}
|
|
}
|
|
else
|
|
{
|
|
my( $diff ) = 0;
|
|
my( $deltatime ) = $g_local_mtime{$filename} - $g_remote_mtime{$filename};
|
|
if( $g_remote_size{$filename} != $g_local_size{$filename} )
|
|
{
|
|
$diff = 1;
|
|
print "size different\n";
|
|
}
|
|
if( $g_remote_mode{$filename} != $g_local_mode{$filename} )
|
|
{
|
|
$diff = 1;
|
|
print "mode different\n";
|
|
}
|
|
if( !( ( $deltatime >= -$g_max_time_delta && $deltatime <= $g_max_time_delta ) ||
|
|
( $deltatime + 3600 >= -$g_max_time_delta && $deltatime + 3600 <= $g_max_time_delta ) ||
|
|
( $deltatime - 3600 >= -$g_max_time_delta && $deltatime - 3600 <= $g_max_time_delta ) ) )
|
|
{
|
|
$diff = 1;
|
|
print "time different\n";
|
|
}
|
|
if( $diff )
|
|
{
|
|
print "fixing up file attribs for $filename\n";
|
|
MakeLocalFileAttribsMatchRemote( $filename );
|
|
}
|
|
}
|
|
}
|
|
|
|
#print "socket: PeerAddr: \"$g_src_machine\"\n";
|
|
my $sock = new IO::Socket::INET (
|
|
PeerAddr => $g_src_machine,
|
|
PeerPort => $g_opt_port,
|
|
Proto => 'tcp',
|
|
);
|
|
die "Could not create socket: $!\n" unless $sock;
|
|
|
|
print $sock $g_protocol_version;
|
|
my $remotedirname = $g_src_path;
|
|
print "Getting remote dirlist for $remotedirname\n";
|
|
&GetRemoteDirList( $sock, $remotedirname );
|
|
|
|
my $localdirname = $g_dst_path;
|
|
print "Getting local dirlist for $localdirname\n";
|
|
&GetLocalDirList_Dir( $localdirname );
|
|
|
|
my $remote_filename;
|
|
foreach $remote_filename (keys %g_remote_mtime)
|
|
{
|
|
next if( &IsExcluded( $remote_filename ) );
|
|
if( !defined( $g_local_mtime{$remote_filename} ) )
|
|
{
|
|
if( $g_remote_isdir{$remote_filename} )
|
|
{
|
|
# print "dir ";
|
|
$g_dirs_to_create{$remote_filename} = 1;
|
|
}
|
|
else
|
|
{
|
|
# print "file ";
|
|
$g_files_to_copy{$remote_filename} = 1;
|
|
}
|
|
if( $g_opt_verbose )
|
|
{
|
|
print "doesn't exist locally and will be copied: $remote_filename\n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
&CompareTime( $remote_filename );
|
|
&ComparePermissions( $remote_filename );
|
|
&CompareSize( $remote_filename );
|
|
&CompareMD5( $remote_filename );
|
|
}
|
|
}
|
|
|
|
my $local_filename;
|
|
foreach $local_filename (keys %g_local_mtime)
|
|
{
|
|
next if( &IsExcluded( $local_filename ) );
|
|
if( !defined( $g_remote_mtime{$local_filename} ) )
|
|
{
|
|
if( $g_local_isdir{$local_filename} )
|
|
{
|
|
$g_dirs_to_delete{$local_filename} = 1;
|
|
# print "dir ";
|
|
}
|
|
else
|
|
{
|
|
$g_files_to_delete{$local_filename} = 1;
|
|
# print "file ";
|
|
}
|
|
# print $local_filename . " doesn't exist remotely\n";
|
|
}
|
|
else
|
|
{
|
|
&CompareTime( $local_filename );
|
|
&ComparePermissions( $local_filename );
|
|
&CompareSize( $local_filename );
|
|
}
|
|
}
|
|
|
|
#%g_files_to_delete;
|
|
#%g_dirs_to_delete;
|
|
#%g_files_to_copy;
|
|
#%g_dirs_to_create;
|
|
|
|
sub IsWritable
|
|
{
|
|
my( $file ) = shift;
|
|
my( $perms ) = oct( $g_local_mode{$file} );
|
|
if( $perms & 2 )
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
sub UnlinkFile
|
|
{
|
|
my( $file ) = shift;
|
|
|
|
print "del " . &ForwardToBackSlash( $file ) . "\n";
|
|
if( !$g_opt_test )
|
|
{
|
|
chmod 0666, $file || die;
|
|
unlink $file || die;
|
|
}
|
|
}
|
|
|
|
sub UnlinkDir
|
|
{
|
|
my( $file ) = shift;
|
|
|
|
print "rmdir " . &ForwardToBackSlash( $file ) . "\n";
|
|
if( !$g_opt_test )
|
|
{
|
|
chmod 0777, $file || die;
|
|
if( !( rmdir $file ) )
|
|
{
|
|
print "Couldn't rmdir " . &ForwardToBackSlash( $file ) . "\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
sub DeleteOrphanFile
|
|
{
|
|
my( $file ) = shift;
|
|
# print "\$g_local_isdir{$file} = $g_local_isdir{$file}\n";
|
|
# print "DeleteOrphanFile( $file )\n";
|
|
my( $localfile ) = &AddBaseDir( $file );
|
|
my( $iswritable ) = &IsWritable( $file );
|
|
if( $iswritable )
|
|
{
|
|
if( $g_opt_deletewritable )
|
|
{
|
|
&UnlinkFile( &AddBaseDir( $file ) );
|
|
}
|
|
else
|
|
{
|
|
print "Would have deleted \"$file\" (use --delete-writable to delete)\n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( $g_opt_deletereadonly )
|
|
{
|
|
&UnlinkFile( &AddBaseDir( $file ) );
|
|
}
|
|
else
|
|
{
|
|
print "Would have deleted \"$file\" (use --delete-readonly to delete)\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
sub DeleteOrphanDir
|
|
{
|
|
my $dir = shift;
|
|
my( $localdir ) = &AddBaseDir( $dir );
|
|
if( $g_opt_deletedirs )
|
|
{
|
|
&UnlinkDir( $localdir );
|
|
}
|
|
else
|
|
{
|
|
print "Would have deleted \"$dir\" (use --delete-dirs to delete)\n";
|
|
}
|
|
}
|
|
|
|
sub MakeLocalFileAttribsMatchRemote
|
|
{
|
|
return if( $g_opt_test );
|
|
my( $file ) = shift;
|
|
my( $localfilename ) = &AddBaseDir( $file );
|
|
|
|
# Make it writable so that we can tweak permissions/time.
|
|
chmod 0666, $localfilename || die $!;
|
|
|
|
# Set the time on the file to match the remote
|
|
my( @statresult );
|
|
if( !( @statresult = stat $localfilename ) )
|
|
{
|
|
die "couldn't stat $localfilename locally\n";
|
|
}
|
|
# @statresult[8] == access time. . we don't care to change this.
|
|
utime $statresult[8], $g_remote_mtime{$file}, $localfilename || die $!;
|
|
|
|
# Set the permissions on the file to match the remote
|
|
chmod oct( $g_remote_mode{$file} ), $localfilename || die $!;
|
|
}
|
|
|
|
sub CopyFileFromRemote
|
|
{
|
|
my( $file ) = shift;
|
|
if( &IsWritable( $file ) && !$g_opt_clobberwritablenewer && $g_local_mtime{$file} > $g_remote_mtime{$file} )
|
|
{
|
|
print "Would have copied \"$file\" (use --clobber-writable-newer to copy)\n";
|
|
return;
|
|
}
|
|
print "copy $file from remote ($g_remote_size{$file} bytes)\n";
|
|
if( !$g_opt_test )
|
|
{
|
|
my( $localfilename ) = &AddBaseDir( $file );
|
|
# make the my version writable so that we can write over it, if it exists
|
|
if( $g_local_mtime{$file} )
|
|
{
|
|
chmod 0666, $localfilename || die $!;
|
|
}
|
|
print $sock "getfile $file\n";
|
|
my( $size ) = $g_remote_size{$file};
|
|
my( $filebits );
|
|
# print "reading $file: $size\n";
|
|
my( $readsize ) = read $sock, $filebits, $size;
|
|
if( $readsize != $size )
|
|
{
|
|
die "read size ($readsize) != expected size ($size) for $file\nYou either:\n\t1) lost your connection\n\t2) the remote file has changed since start of mccopy\n";
|
|
}
|
|
|
|
# print "finished with $file\n";
|
|
local( *FILE );
|
|
# print "opening $localfilename\n";
|
|
open FILE, ">$localfilename" || die $!;
|
|
# print "binmode $localfilename";
|
|
binmode( FILE ) || die $!;
|
|
# print "after binmode $localfilename";
|
|
print FILE $filebits;
|
|
close FILE || die $!;
|
|
# print "closed $localfilename\n";
|
|
|
|
MakeLocalFileAttribsMatchRemote( $file );
|
|
}
|
|
}
|
|
|
|
sub PrettifyTime
|
|
{
|
|
my( $inseconds ) = shift;
|
|
my( $hours, $minutes, $seconds );
|
|
my( @blah ) = gmtime( $inseconds );
|
|
$hours = $blah[2];
|
|
$minutes = $blah[1];
|
|
$seconds = $blah[0];
|
|
return sprintf "%02d:%02d:%02d", $hours, $minutes, $seconds;
|
|
}
|
|
|
|
# remove my files that aren't on remote
|
|
my $file;
|
|
foreach $file (keys %g_files_to_delete)
|
|
{
|
|
&DeleteOrphanFile( $file );
|
|
}
|
|
|
|
# remove my dirs that aren't on remote
|
|
my $dir;
|
|
foreach $dir (sort { length $b <=> length $a } keys( %g_dirs_to_delete ) )
|
|
{
|
|
&DeleteOrphanDir( $dir );
|
|
}
|
|
|
|
|
|
# create my dirs that are only on remote
|
|
foreach $dir (sort { length $a <=> length $b } keys( %g_dirs_to_create) )
|
|
{
|
|
my( $localdir ) = &AddBaseDir( $dir );
|
|
print "mkdir $localdir, 0777\n";
|
|
if( !$g_opt_test )
|
|
{
|
|
mkdir $localdir, 0777 || die $!;
|
|
}
|
|
}
|
|
|
|
# calculate the total size of files to transfer
|
|
my $totalbytes = 0;
|
|
foreach $file ( keys %g_files_to_copy )
|
|
{
|
|
$totalbytes += $g_remote_size{$file};
|
|
}
|
|
|
|
print "$totalbytes bytes to copy\n";
|
|
|
|
# copy files from remote that are different
|
|
my $bytescopied = 0;
|
|
my $starttime = time;
|
|
foreach $file (sort( keys %g_files_to_copy ) )
|
|
{
|
|
&CopyFileFromRemote( $file );
|
|
$bytescopied += $g_remote_size{$file};
|
|
my $curtime = time;
|
|
my $deltatime = $curtime - $starttime;
|
|
my $percentdone;
|
|
if( $totalbytes )
|
|
{
|
|
$percentdone = ( $bytescopied * 1.0 ) / $totalbytes;
|
|
}
|
|
if( $totalbytes && $percentdone && $deltatime )
|
|
{
|
|
printf "progress: %.1f%% %s/%s %d bytes/sec\n",
|
|
$percentdone * 100,
|
|
&PrettifyTime( $deltatime ),
|
|
&PrettifyTime( 1.0 / $percentdone * $deltatime ),
|
|
$bytescopied / $deltatime;
|
|
}
|
|
}
|
|
|
|
print "done!\n";
|
|
|
|
close($sock);
|
|
|
|
|