X-Git-Url: http://gb7djk.dxcluster.net/gitweb/gitweb.cgi?a=blobdiff_plain;f=perl%2FDXMsg.pm;h=b2665df8f0a6cf5786782e1f85035e93b3d91723;hb=e76e5e7e943c5af1d984ec60ad80524424420fa2;hp=80895a55fbfc0ae82966bdb91ffa26214b539d92;hpb=9a55af9586711ecdea8dc9b0da38509119fa8090;p=spider.git

diff --git a/perl/DXMsg.pm b/perl/DXMsg.pm
index 80895a55..b2665df8 100644
--- a/perl/DXMsg.pm
+++ b/perl/DXMsg.pm
@@ -11,6 +11,7 @@
 #
 # PC28 field 11 is the RR required flag
 # PC28 field 12 is a VIA routing (ie it is a node call) 
+#
 
 package DXMsg;
 
@@ -25,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
@@ -37,30 +41,48 @@ 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 = 2*60;          # run the queue every 2 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',
-		  tonode => '9,To Node',
+		  fromnode => '5,From Node',
+		  tonode => '5,To Node',
 		  to => '0,To',
 		  from => '0,From',
 		  t => '0,Msg Time,cldatetime',
-		  private => '9,Private',
+		  private => '5,Private',
 		  subject => '0,Subject',
 		  linesreq => '0,Lines per Gob',
-		  rrreq => '9,Read Confirm',
+		  rrreq => '5,Read Confirm',
 		  origin => '0,Origin',
 		  lines => '5,Data',
 		  stream => '9,Stream No',
-		  count => '9,Gob Linecnt',
-		  file => '9,File?,yesno',
-		  gotit => '9,Got it Nodes,parray',
-		  lines => '9,Lines,parray',
-		  'read' => '9,Times read',
+		  count => '5,Gob Linecnt',
+		  file => '5,File?,yesno',
+		  gotit => '5,Got it Nodes,parray',
+		  lines => '5,Lines,parray',
+		  'read' => '5,Times read',
 		  size => '0,Size',
 		  msgno => '0,Msgno',
 		  keep => '0,Keep this?,yesno',
+		  lastt => '5,Last processed,cldatetime',
+		  waitt => '5,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                  
@@ -70,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;
@@ -81,6 +103,7 @@ sub alloc
 	$self->{'read'} = shift;
 	$self->{rrreq} = shift;
 	$self->{gotit} = [];
+	$self->{lastt} = $main::systime;
     
 	return $self;
 }
@@ -96,16 +119,57 @@ 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) {
+				dbg('msg', "Timeout, stopping msgno: $ref->{msgno} -> $node");
+				$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};
+				dbg('msg', "Busy, stopping msgno: $ref->{msgno} -> $f[2]");
+				$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]);
@@ -121,6 +185,14 @@ 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;
+
+			# look to see whether this is a non private message sent to a known callsign
+			my $uref = DXUser->get_current($ref->{to});
+			if (iscallsign($ref->{to}) && !$ref->{private} && $uref && $uref->homenode) {
+				$ref->{private} = 1;
+				dbg('msg', "set bull to $ref->{to} to private");
+			}
 			last SWITCH;
 		}
 		
@@ -134,6 +206,10 @@ sub process
 					dbg('msg', "stream $f[3]: $ref->{count} lines received\n");
 					$ref->{count} = 0;
 				}
+				$ref->{lastt} = $main::systime;
+			} else {
+				dbg('msg', "PC29 from unknown stream $f[3] from $f[2]" );
+				$self->send(DXProt::pc42($f[2], $f[1], $f[3]));	# unknown stream
 			}
 			last SWITCH;
 		}
@@ -151,7 +227,9 @@ sub process
 				$ref->{lines} = [];
 				push @{$ref->{lines}}, ($ref->read_msg_body);
 				$ref->send_tranche($self);
+				$ref->{lastt} = $main::systime;
 			} else {
+				dbg('msg', "PC30 from unknown stream $f[3] from $f[2]" );
 				$self->send(DXProt::pc42($f[2], $f[1], $f[3]));	# unknown stream
 			} 
 			last SWITCH;
@@ -162,7 +240,9 @@ sub process
 			if ($ref) {
 				dbg('msg', "tranche ack stream $f[3]\n");
 				$ref->send_tranche($self);
+				$ref->{lastt} = $main::systime;
 			} else {
+				dbg('msg', "PC31 from unknown stream $f[3] from $f[2]" );
 				$self->send(DXProt::pc42($f[2], $f[1], $f[3]));	# unknown stream
 			} 
 			last SWITCH;
@@ -187,30 +267,38 @@ sub process
 						# 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);
+							if ($ref->{subject} eq $m->{subject} && $ref->{t} == $m->{t} && $ref->{from} eq $m->{from} && $ref->{to} eq $m->{to}) {
+								$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 && $dxchan->is_user;
 						Log('msg', "Message $ref->{msgno} from $ref->{from} received from $f[2] for $ref->{to}");
 					}
 				}
-				$ref->stop_msg($self);
-				queue_msg(0);
+				$ref->stop_msg($self->call);
 			} else {
+				dbg('msg', "PC32 from unknown stream $f[3] from $f[2]" );
 				$self->send(DXProt::pc42($f[2], $f[1], $f[3]));	# unknown stream
 			}
-			queue_msg(0);
+			# queue_msg(0);
 			last SWITCH;
 		}
 		
@@ -225,10 +313,13 @@ 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 {
+				dbg('msg', "PC33 from unknown stream $f[3] from $f[2]" );
 				$self->send(DXProt::pc42($f[2], $f[1], $f[3]));	# unknown stream
 			} 
+
+			# send next one if present
 			queue_msg(0);
 			last SWITCH;
 		}
@@ -239,7 +330,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];
@@ -262,6 +353,7 @@ sub process
 			$ref->{stream} = $stream;
 			$ref->{count} = 0;	# no of lines between PC31s
 			$ref->{file} = 1;
+			$ref->{lastt} = $main::systime;
 			$work{"$f[2]$stream"} = $ref; # store in work
 			$self->send(DXProt::pc30($f[2], $f[1], $stream)); # send ack 
 			
@@ -272,7 +364,7 @@ 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;
 			}
 			
@@ -281,15 +373,14 @@ sub process
 
 		if ($pcno == 49) {      # global delete on subject
 			for (@msg) {
-				if ($_->{subject} eq $f[2]) {
+				if ($_->{from} eq $f[1] && $_->{subject} eq $f[2]) {
 					$_->del_msg();
-					Log('msg', "Message $_->{msgno} fully deleted by $f[1]");
+					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
 }
 
 
@@ -302,14 +393,14 @@ sub store
 	my $lines = shift;
 	
 	# we only proceed if there are actually any lines in the file
-	if (!$lines || @{$lines} == 0) {
-		return;
-	}
+#	if (!$lines || @{$lines} == 0) {
+#		return;
+#	}
 	
 	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}) {
@@ -329,7 +420,7 @@ sub store
 		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';
@@ -398,7 +489,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;
@@ -443,7 +534,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;
@@ -484,7 +575,6 @@ sub queue_msg
 	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
@@ -494,36 +584,64 @@ sub queue_msg
 	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};
+		} 
+
+		# deal with routed private messages
+		my $noderef;
 		if ($ref->{private}) {
-			if ($ref->{'read'} == 0) {
-				$clref = DXCluster->get_exact($ref->{to});
-				if ($clref && !grep { $clref->{dxchan} == $_ } DXCommandmode::get_all) {
-					$dxchan = $clref->{dxchan};
-					$ref->start_msg($dxchan) if $clref && !get_busy($dxchan->call) && $dxchan->state eq 'normal';
-				}
+			$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;
 			}
-		} 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
-			# guess, use (to, from, time, subject) tuple?
-			my $noderef;
-			foreach $noderef (@nodelist) {
-				next if $noderef->call eq $main::mycall;
-				next if $noderef->isolate;               # maybe add code for stuff originated here?
-				next if grep { $_ eq $noderef->call } @{$ref->{gotit}};
-				
-				# if we are here we have a node that doesn't have this message
+			if ($clref && !grep { $clref->{dxchan} == $_ } DXCommandmode::get_all) {
+				next if $clref->call eq $main::mycall;  # i.e. it lives here
+				$noderef = $clref->{dxchan};
 				$ref->start_msg($noderef) if !get_busy($noderef->call)  && $noderef->state eq 'normal';
-				last;
 			}
 		}
 		
+		# otherwise we are dealing with a bulletin or forwarded private message
+		# 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
+		# guess, use (to, from, time, subject) tuple?
+		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
+
+			# if we are here we have a node that doesn't have this message
+			$ref->start_msg($noderef) if !get_busy($noderef->call)  && $noderef->state eq 'normal';
+			last;
+		}
+
 		# if all the available nodes are busy then stop
 		last if @nodelist == scalar grep { get_busy($_->call) } @nodelist;
 	}
 }
 
+# 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
 {
@@ -534,8 +652,9 @@ 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;
+	$self->{lastt} = $main::systime;
 	$dxchan->send(DXProt::pc28($self->{tonode}, $self->{fromnode}, $self->{to}, $self->{from}, $self->{t}, $self->{private}, $self->{subject}, $self->{origin}, $self->{rrreq}));
 }
 
@@ -561,12 +680,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};
 }
@@ -579,7 +700,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;
@@ -598,25 +719,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); 
-		
 	}
 }
 
@@ -686,7 +820,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};
@@ -709,12 +843,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'));
 						}
 					}
 				}
@@ -722,12 +856,12 @@ sub do_send_stuff
 			delete $loc->{lines};
 			delete $loc->{to};
 			delete $self->{loc};
-			$self->state('prompt');
 			$self->func(undef);
-			DXMsg::queue_msg(0);
+			
+			$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};
@@ -751,6 +885,59 @@ 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?
+		next if $ref->{private} && $sort ne 'P';
+		next if !$ref->{private} && $sort ne 'B';
+		
+		# select field
+		$tested = $ref->{to} if $field eq 'T';
+		my $at = $ref->{to} =~ /\@\s*(\S+)/;
+		$tested = $at if $field eq '\@';
+		$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
 {