X-Git-Url: http://dxcluster.org/gitweb/gitweb.cgi?a=blobdiff_plain;f=perl%2FDXMsg.pm;h=bcb4dc006fc1482f7f2929f35c69f37be55a318a;hb=813a3e444bc223a8c1032348a40948c91b9cb257;hp=eacbf6fe5984bc5cbfafae12fe9370de1b06ef70;hpb=4cc67094baaf97c4d3d47aca73e2585c36a866eb;p=spider.git

diff --git a/perl/DXMsg.pm b/perl/DXMsg.pm
index eacbf6fe..bcb4dc00 100644
--- a/perl/DXMsg.pm
+++ b/perl/DXMsg.pm
@@ -5,7 +5,13 @@
 # Copyright (c) 1998 Dirk Koopman G1TLH
 #
 # $Id$
-# 
+#
+#
+# Notes for implementors:-
+#
+# PC28 field 11 is the RR required flag
+# PC28 field 12 is a VIA routing (ie it is a node call) 
+#
 
 package DXMsg;
 
@@ -20,11 +26,14 @@ use DXProtVars;
 use DXProtout;
 use DXDebug;
 use DXLog;
-use FileHandle;
+use IO::File;
+use Fcntl;
 use Carp;
 
 use strict;
-use vars qw(%work @msg $msgdir %valid %busy $maxage $last_clean);
+use vars qw(%work @msg $msgdir %valid %busy $maxage $last_clean
+			@badmsg $badmsgfn $forwardfn @forward $timeout $waittime
+		    $queueinterval $lastq);
 
 %work = ();						# outstanding jobs
 @msg = ();						# messages we have
@@ -32,6 +41,15 @@ use vars qw(%work @msg $msgdir %valid %busy $maxage $last_clean);
 $msgdir = "$main::root/msg";	# directory contain the msgs
 $maxage = 30 * 86400;			# the maximum age that a message shall live for if not marked 
 $last_clean = 0;				# last time we did a clean
+@forward = ();                  # msg forward table
+$timeout = 30*60;               # forwarding timeout
+$waittime = 60*60;              # time an aborted outgoing message waits before trying again
+$queueinterval = 5*60;          # run the queue every 5 minutes
+$lastq = 0;
+
+
+$badmsgfn = "$msgdir/badmsg.pl";  # list of TO address we wont store
+$forwardfn = "$msgdir/forward.pl";  # the forwarding table
 
 %valid = (
 		  fromnode => '9,From Node',
@@ -50,12 +68,21 @@ $last_clean = 0;				# last time we did a clean
 		  file => '9,File?,yesno',
 		  gotit => '9,Got it Nodes,parray',
 		  lines => '9,Lines,parray',
-		  read => '9,Times read',
+		  'read' => '9,Times read',
 		  size => '0,Size',
 		  msgno => '0,Msgno',
 		  keep => '0,Keep this?,yesno',
+		  lastt => '9,Last processed,cldatetime',
+		  waitt => '9,Wait until,cldatetime',
 		 );
 
+sub DESTROY
+{
+	my $self = shift;
+	undef $self->{lines};
+	undef $self->{gotit};
+}
+
 # allocate a new object
 # called fromnode, tonode, from, to, datetime, private?, subject, nolinesper  
 sub alloc                  
@@ -65,7 +92,7 @@ sub alloc
 	$self->{msgno} = shift;
 	my $to = shift;
 	#  $to =~ s/-\d+$//o;
-	$self->{to} = $to;
+	$self->{to} = ($to eq $main::mycall) ? $main::myalias : $to;
 	my $from = shift;
 	$from =~ s/-\d+$//o;
 	$self->{from} = uc $from;
@@ -73,9 +100,10 @@ sub alloc
 	$self->{private} = shift;
 	$self->{subject} = shift;
 	$self->{origin} = shift;
-	$self->{read} = shift;
+	$self->{'read'} = shift;
 	$self->{rrreq} = shift;
 	$self->{gotit} = [];
+	$self->{lastt} = $main::systime;
     
 	return $self;
 }
@@ -91,16 +119,55 @@ sub workclean
 	delete $ref->{lines};
 	delete $ref->{file};
 	delete $ref->{count};
+	delete $ref->{lastt} if exists $ref->{lastt};
+	delete $ref->{waitt} if exists $ref->{waitt};
 }
 
 sub process
 {
 	my ($self, $line) = @_;
-	my @f = split /[\^\~]/, $line;
+
+	# this is periodic processing
+	if (!$self || !$line) {
+
+		# wander down the work queue stopping any messages that have timed out
+		for (keys %busy) {
+			my $node = $_;
+			my $ref = $busy{$_};
+			if (exists $ref->{lastt} && $main::systime > $ref->{lastt} + $timeout) {
+				$ref->stop_msg($node);
+
+				# delay any outgoing messages that fail
+				$ref->{waitt} = $main::systime + $waittime + rand(120) if $node ne $main::mycall;
+			}
+		}
+
+		# queue some message if the interval timer has gone off
+		if ($main::systime > $lastq + $queueinterval) {
+			queue_msg(0);
+			$lastq = $main::systime;
+		}
+
+		# clean the message queue
+		clean_old() if $main::systime - $last_clean > 3600 ;
+		return;
+	}
+
+	my @f = split /\^/, $line;
 	my ($pcno) = $f[0] =~ /^PC(\d\d)/; # just get the number
-	
+
  SWITCH: {
 		if ($pcno == 28) {		# incoming message
+
+			# first look for any messages in the busy queue 
+			# and cancel them this should both resolve timed out incoming messages
+			# and crossing of message between nodes, incoming messages have priority
+			if (exists $busy{$f[2]}) {
+				my $ref = $busy{$f[2]};
+				my $tonode = $ref->{tonode};
+				$ref->stop_msg($self->call);
+			}
+
 			my $t = cltounix($f[5], $f[6]);
 			my $stream = next_transno($f[2]);
 			my $ref = DXMsg->alloc($stream, uc $f[3], $f[4], $t, $f[7], $f[8], $f[13], '0', $f[11]);
@@ -116,6 +183,7 @@ sub process
 			$work{"$f[2]$stream"} = $ref; # store in work
 			$busy{$f[2]} = $ref; # set interlock
 			$self->send(DXProt::pc30($f[2], $f[1], $stream)); # send ack
+			$ref->{lastt} = $main::systime;
 			last SWITCH;
 		}
 		
@@ -129,22 +197,28 @@ sub process
 					dbg('msg', "stream $f[3]: $ref->{count} lines received\n");
 					$ref->{count} = 0;
 				}
+				$ref->{lastt} = $main::systime;
 			}
 			last SWITCH;
 		}
 		
 		if ($pcno == 30) {		# this is a incoming subject ack
 			my $ref = $work{$f[2]};	# note no stream at this stage
-			delete $work{$f[2]};
-			$ref->{stream} = $f[3];
-			$ref->{count} = 0;
-			$ref->{linesreq} = 5;
-			$work{"$f[2]$f[3]"} = $ref;	# new ref
-			dbg('msg', "incoming subject ack stream $f[3]\n");
-			$busy{$f[2]} = $ref; # interlock
-			$ref->{lines} = [];
-			push @{$ref->{lines}}, ($ref->read_msg_body);
-			$ref->send_tranche($self);
+			if ($ref) {
+				delete $work{$f[2]};
+				$ref->{stream} = $f[3];
+				$ref->{count} = 0;
+				$ref->{linesreq} = 5;
+				$work{"$f[2]$f[3]"} = $ref;	# new ref
+				dbg('msg', "incoming subject ack stream $f[3]\n");
+				$busy{$f[2]} = $ref; # interlock
+				$ref->{lines} = [];
+				push @{$ref->{lines}}, ($ref->read_msg_body);
+				$ref->send_tranche($self);
+				$ref->{lastt} = $main::systime;
+			} else {
+				$self->send(DXProt::pc42($f[2], $f[1], $f[3]));	# unknown stream
+			} 
 			last SWITCH;
 		}
 		
@@ -153,6 +227,7 @@ sub process
 			if ($ref) {
 				dbg('msg', "tranche ack stream $f[3]\n");
 				$ref->send_tranche($self);
+				$ref->{lastt} = $main::systime;
 			} else {
 				$self->send(DXProt::pc42($f[2], $f[1], $f[3]));	# unknown stream
 			} 
@@ -174,21 +249,41 @@ sub process
 					if ($ref->{file}) {
 						$ref->store($ref->{lines});
 					} else {
+
+						# does an identical message already exist?
+						my $m;
+						for $m (@msg) {
+							if ($ref->{subject} eq $m->{subject} && $ref->{t} == $m->{t} && $ref->{from} eq $m->{from}) {
+								$ref->stop_msg($self->call);
+								my $msgno = $m->{msgno};
+								dbg('msg', "duplicate message to $msgno\n");
+								Log('msg', "duplicate message to $msgno");
+								return;
+							}
+						}
+							
+						# look for 'bad' to addresses 
+						if (grep $ref->{to} eq $_, @badmsg) {
+							$ref->stop_msg($self->call);
+							dbg('msg', "'Bad' TO address $ref->{to}");
+							Log('msg', "'Bad' TO address $ref->{to}");
+							return;
+						}
+
 						$ref->{msgno} = next_transno("Msgno");
 						push @{$ref->{gotit}}, $f[2]; # mark this up as being received
 						$ref->store($ref->{lines});
 						add_dir($ref);
 						my $dxchan = DXChannel->get($ref->{to});
-						$dxchan->send("New mail has arrived for you") if $dxchan;
+						$dxchan->send($dxchan->msg('m9')) if $dxchan;
 						Log('msg', "Message $ref->{msgno} from $ref->{from} received from $f[2] for $ref->{to}");
 					}
 				}
-				$ref->stop_msg($self);
-				queue_msg();
+				$ref->stop_msg($self->call);
 			} else {
 				$self->send(DXProt::pc42($f[2], $f[1], $f[3]));	# unknown stream
 			}
-			queue_msg();
+			# queue_msg(0);
 			last SWITCH;
 		}
 		
@@ -203,11 +298,10 @@ sub process
 					push @{$ref->{gotit}}, $f[2]; # mark this up as being received
 					$ref->store($ref->{lines});	# re- store the file
 				}
-				$ref->stop_msg($self);
+				$ref->stop_msg($self->call);
 			} else {
 				$self->send(DXProt::pc42($f[2], $f[1], $f[3]));	# unknown stream
 			} 
-			queue_msg();
 			last SWITCH;
 		}
 		
@@ -217,7 +311,7 @@ sub process
 			$f[3] =~ s/^\///o;   # remove the leading /
 			$f[3] = lc $f[3];	# to lower case;
 			dbg('msg', "incoming file $f[3]\n");
-			last SWITCH if $f[3] =~ /^(perl|cmd|local|src|lib|include|sys|msg|connect)/; # prevent access to executables
+			$f[3] = 'packclus/' . $f[3] unless $f[3] =~ /^packclus\//o;
 			
 			# create any directories
 			my @part = split /\//, $f[3];
@@ -250,15 +344,23 @@ sub process
 			dbg('msg', "stream $f[3]: abort received\n");
 			my $ref = $work{"$f[2]$f[3]"};
 			if ($ref) {
-				$ref->stop_msg($self);
+				$ref->stop_msg($self->call);
 				$ref = undef;
 			}
 			
 			last SWITCH;
 		}
+
+		if ($pcno == 49) {      # global delete on subject
+			for (@msg) {
+				if ($_->{from} eq $f[1] && $_->{subject} eq $f[2]) {
+					$_->del_msg();
+					Log('msg', "Message $_->{msgno} from $_->{from} ($_->{subject}) fully deleted");
+					DXProt::broadcast_ak1a($line, $self);
+				}
+			}
+		}
 	}
-	 
-	 clean_old() if $main::systime - $last_clean > 3600 ; # clean the message queue
 }
 
 
@@ -278,7 +380,7 @@ sub store
 	if ($ref->{file}) {			# a file
 		dbg('msg', "To be stored in $ref->{to}\n");
 		
-		my $fh = new FileHandle "$ref->{to}", "w";
+		my $fh = new IO::File "$ref->{to}", "w";
 		if (defined $fh) {
 			my $line;
 			foreach $line (@{$lines}) {
@@ -291,18 +393,18 @@ sub store
 			confess "can't open file $ref->{to} $!";  
 		}
 	} else {					# a normal message
-		
+
 		# attempt to open the message file
 		my $fn = filename($ref->{msgno});
 		
 		dbg('msg', "To be stored in $fn\n");
 		
 		# now save the file, overwriting what's there, YES I KNOW OK! (I will change it if it's a problem)
-		my $fh = new FileHandle "$fn", "w";
+		my $fh = new IO::File "$fn", "w";
 		if (defined $fh) {
 			my $rr = $ref->{rrreq} ? '1' : '0';
 			my $priv = $ref->{private} ? '1': '0';
-			print $fh "=== $ref->{msgno}^$ref->{to}^$ref->{from}^$ref->{t}^$priv^$ref->{subject}^$ref->{origin}^$ref->{read}^$rr\n";
+			print $fh "=== $ref->{msgno}^$ref->{to}^$ref->{from}^$ref->{t}^$priv^$ref->{subject}^$ref->{origin}^$ref->{'read'}^$rr\n";
 			print $fh "=== ", join('^', @{$ref->{gotit}}), "\n";
 			my $line;
 			$ref->{size} = 0;
@@ -367,7 +469,7 @@ sub read_msg_header
 	my @f;
 	my $size;
 	
-	$file = new FileHandle;
+	$file = new IO::File;
 	if (!open($file, $fn)) {
 		print "Error reading $fn $!\n";
 		return undef;
@@ -412,7 +514,7 @@ sub read_msg_body
 	my $fn = filename($msgno);
 	my @out;
 	
-	$file = new FileHandle;
+	$file = new IO::File;
 	if (!open($file, $fn)) {
 		print "Error reading $fn $!\n";
 		return undef;
@@ -433,41 +535,57 @@ sub send_tranche
 	my $to = $self->{tonode};
 	my $from = $self->{fromnode};
 	my $stream = $self->{stream};
-	my $i;
+	my $lines = $self->{lines};
+	my ($c, $i);
 	
-	for ($i = 0; $i < $self->{linesreq} && $self->{count} < @{$self->{lines}}; $i++, $self->{count}++) {
-		push @out, DXProt::pc29($to, $from, $stream, ${$self->{lines}}[$self->{count}]);
-}
-push @out, DXProt::pc32($to, $from, $stream) if $i < $self->{linesreq};
-$dxchan->send(@out);
+	for ($i = 0, $c = $self->{count}; $i < $self->{linesreq} && $c < @$lines; $i++, $c++) {
+		push @out, DXProt::pc29($to, $from, $stream, $lines->[$c]);
+    }
+    $self->{count} = $c;
+
+    push @out, DXProt::pc32($to, $from, $stream) if $i < $self->{linesreq};
+	$dxchan->send(@out);
 }
 
 	
-	# find a message to send out and start the ball rolling
-	sub queue_msg
+# find a message to send out and start the ball rolling
+sub queue_msg
 {
 	my $sort = shift;
-	my @nodelist = DXProt::get_all_ak1a();
+	my $call = shift;
 	my $ref;
 	my $clref;
 	my $dxchan;
+	my @nodelist = DXProt::get_all_ak1a();
 	
 	# bat down the message list looking for one that needs to go off site and whose
 	# nearest node is not busy.
-	
+
 	dbg('msg', "queue msg ($sort)\n");
 	foreach $ref (@msg) {
 		# firstly, is it private and unread? if so can I find the recipient
 		# in my cluster node list offsite?
+
+		# ignore 'delayed' messages until their waiting time has expired
+		if (exists $ref->{waitt}) {
+			next if $ref->{waitt} < $main::systime;
+			delete $ref->{waitt};
+		} 
+		
 		if ($ref->{private}) {
-			if ($ref->{read} == 0) {
-				$clref = DXCluster->get($ref->{to});
+			if ($ref->{'read'} == 0) {
+				$clref = DXCluster->get_exact($ref->{to});
+				unless ($clref) {             # otherwise look for a homenode
+					my $uref = DXUser->get($ref->{to});
+					my $hnode =  $uref->homenode if $uref;
+					$clref = DXCluster->get_exact($hnode) if $hnode;
+				}
 				if ($clref && !grep { $clref->{dxchan} == $_ } DXCommandmode::get_all) {
 					$dxchan = $clref->{dxchan};
-					$ref->start_msg($dxchan) if $clref && !get_busy($dxchan->call);
+					$ref->start_msg($dxchan) if $dxchan && $clref && !get_busy($dxchan->call) && $dxchan->state eq 'normal';
 				}
 			}
-		} elsif ($sort == undef) {
+		} elsif (!$sort) {
 			# otherwise we are dealing with a bulletin, compare the gotit list with
 			# the nodelist up above, if there are sites that haven't got it yet
 			# then start sending it - what happens when we get loops is anyone's
@@ -476,11 +594,14 @@ $dxchan->send(@out);
 			foreach $noderef (@nodelist) {
 				next if $noderef->call eq $main::mycall;
 				next if grep { $_ eq $noderef->call } @{$ref->{gotit}};
+				next unless $ref->forward_it($noderef->call);           # check the forwarding file
+				# next if $noderef->isolate;               # maybe add code for stuff originated here?
+				# next if DXUser->get( ${$ref->{gotit}}[0] )->isolate;  # is the origin isolated?
 				
 				# if we are here we have a node that doesn't have this message
-				$ref->start_msg($noderef) if !get_busy($noderef->call);
+				$ref->start_msg($noderef) if !get_busy($noderef->call)  && $noderef->state eq 'normal';
 				last;
-			} 
+			}
 		}
 		
 		# if all the available nodes are busy then stop
@@ -488,6 +609,21 @@ $dxchan->send(@out);
 	}
 }
 
+# is there a message for me?
+sub for_me
+{
+	my $call = uc shift;
+	my $ref;
+	
+	foreach $ref (@msg) {
+		# is it for me, private and unread? 
+		if ($ref->{to} eq $call && $ref->{private}) {
+			return 1 if !$ref->{'read'};
+		}
+	}
+	return 0;
+}
+
 # start the message off on its travels with a PC28
 sub start_msg
 {
@@ -498,8 +634,8 @@ sub start_msg
 	$self->{count} = 0;
 	$self->{tonode} = $dxchan->call;
 	$self->{fromnode} = $main::mycall;
-	$busy{$dxchan->call} = $self;
-	$work{"$self->{tonode}"} = $self;
+	$busy{$self->{tonode}} = $self;
+	$work{$self->{tonode}} = $self;
 	$dxchan->send(DXProt::pc28($self->{tonode}, $self->{fromnode}, $self->{to}, $self->{from}, $self->{t}, $self->{private}, $self->{subject}, $self->{origin}, $self->{rrreq}));
 }
 
@@ -525,12 +661,14 @@ sub get_fwq
 # stop a message from continuing, clean it out, unlock interlocks etc
 sub stop_msg
 {
-	my ($self, $dxchan) = @_;
-	my $node = $dxchan->call;
+	my $self = shift;
+	my $node = shift;
+	my $stream = $self->{stream} if exists $self->{stream};
+	
 	
-	dbg('msg', "stop msg $self->{msgno} stream $self->{stream}\n");
+	dbg('msg', "stop msg $self->{msgno} -> node $node\n");
 	delete $work{$node};
-	delete $work{"$node$self->{stream}"};
+	delete $work{"$node$stream"} if $stream;
 	$self->workclean;
 	delete $busy{$node};
 }
@@ -543,7 +681,7 @@ sub next_transno
 	my $fn = "$msgdir/$name";
 	my $msgno;
 	
-	my $fh = new FileHandle;
+	my $fh = new IO::File;
 	if (sysopen($fh, $fn, O_RDWR|O_CREAT, 0666)) {
 		$fh->autoflush(1);
 		$msgno = $fh->getline;
@@ -562,25 +700,38 @@ sub next_transno
 # initialise the message 'system', read in all the message headers
 sub init
 {
-	my $dir = new FileHandle;
+	my $dir = new IO::File;
 	my @dir;
 	my $ref;
-	
+
+	# load various control files
+	my @in = load_badmsg();
+	print "@in\n" if @in;
+	@in = load_forward();
+	print "@in\n" if @in;
+
 	# read in the directory
 	opendir($dir, $msgdir) or confess "can't open $msgdir $!";
 	@dir = readdir($dir);
 	closedir($dir);
-	
+
+	@msg = ();
 	for (sort @dir) {
-		next if /^\./o;
-		next if ! /^m\d+/o;
+		next unless /^m\d+$/o;
 		
 		$ref = read_msg_header("$msgdir/$_");
-		next if !$ref;
+		next unless $ref;
 		
+		# delete any messages to 'badmsg.pl' places
+		if (grep $ref->{to} eq $_, @badmsg) {
+			dbg('msg', "'Bad' TO address $ref->{to}");
+			Log('msg', "'Bad' TO address $ref->{to}");
+			$ref->del_msg;
+			next;
+		}
+
 		# add the message to the available queue
 		add_dir($ref); 
-		
 	}
 }
 
@@ -650,7 +801,7 @@ sub do_send_stuff
 		$loc->{lines} = [];
 		$self->state('sendbody');
 		#push @out, $self->msg('sendbody');
-		push @out, "Enter Message /EX (^Z) to send or /ABORT (^Y) to exit";
+		push @out, $self->msg('m8');
 	} elsif ($self->state eq 'sendbody') {
 		confess "local var gone missing" if !ref $self->{loc};
 		my $loc = $self->{loc};
@@ -673,12 +824,12 @@ sub do_send_stuff
 										$loc->{rrreq});
 					$ref->store($loc->{lines});
 					$ref->add_dir();
-					#push @out, $self->msg('sendsent', $to);
-					push @out, "msgno $ref->{msgno} sent to $to";
+					push @out, $self->msg('m11', $ref->{msgno}, $to);
+					#push @out, "msgno $ref->{msgno} sent to $to";
 					my $dxchan = DXChannel->get(uc $to);
 					if ($dxchan) {
 						if ($dxchan->is_user()) {
-							$dxchan->send("New mail has arrived for you");
+							$dxchan->send($dxchan->msg('m9'));
 						}
 					}
 				}
@@ -686,12 +837,12 @@ sub do_send_stuff
 			delete $loc->{lines};
 			delete $loc->{to};
 			delete $self->{loc};
-			$self->state('prompt');
 			$self->func(undef);
-			DXMsg::queue_msg();
+			
+			$self->state('prompt');
 		} elsif ($line eq "\031" || uc $line eq "/ABORT" || uc $line eq "/QUIT") {
 			#push @out, $self->msg('sendabort');
-			push @out, "aborted";
+			push @out, $self->msg('m10');
 			delete $loc->{lines};
 			delete $loc->{to};
 			delete $self->{loc};
@@ -700,7 +851,7 @@ sub do_send_stuff
 		} else {
 			
 			# i.e. it ain't and end or abort, therefore store the line
-			push @{$loc->{lines}}, $line;
+			push @{$loc->{lines}}, length($line) > 0 ? $line : " ";
 		}
 	}
 	return (1, @out);
@@ -715,6 +866,57 @@ sub dir
 			$ref->to, $ref->from, cldate($ref->t), ztime($ref->t), $ref->subject;
 }
 
+# load the forward table
+sub load_forward
+{
+	my @out;
+	do "$forwardfn" if -e "$forwardfn";
+	push @out, $@ if $@;
+	return @out;
+}
+
+# load the bad message table
+sub load_badmsg
+{
+	my @out;
+	do "$badmsgfn" if -e "$badmsgfn";
+	push @out, $@ if $@;
+	return @out;
+}
+
+#
+# forward that message or not according to the forwarding table
+# returns 1 for forward, 0 - to ignore
+#
+
+sub forward_it
+{
+	my $ref = shift;
+	my $call = shift;
+	my $i;
+	
+	for ($i = 0; $i < @forward; $i += 5) {
+		my ($sort, $field, $pattern, $action, $bbs) = @forward[$i..($i+4)]; 
+		my $tested;
+		
+		# are we interested?
+		last if $ref->{private} && $sort ne 'P';
+		last if !$ref->{private} && $sort ne 'B';
+		
+		# select field
+		$tested = $ref->{to} if $field eq 'T';
+		$tested = $ref->{from} if $field eq 'F';
+		$tested = $ref->{origin} if $field eq 'O';
+		$tested = $ref->{subject} if $field eq 'S';
+
+		if (!$pattern || $tested =~ m{$pattern}i) {
+			return 0 if $action eq 'I';
+			return 1 if !$bbs || grep $_ eq $call, @{$bbs};
+		}
+	}
+	return 0;
+}
+
 no strict;
 sub AUTOLOAD
 {