use Route::Node;
use strict;
-use vars qw($me $pc11_max_age $pc23_max_age
+
+use vars qw($VERSION $BRANCH);
+$VERSION = sprintf( "%d.%03d", q$Revision$ =~ /(\d+)\.(\d+)/ );
+$BRANCH = sprintf( "%d.%03d", q$Revision$ =~ /\d+\.\d+\.(\d+)\.(\d+)/ ) || 0;
+$main::build += $VERSION;
+$main::branch += $BRANCH;
+
+use vars qw($me $pc11_max_age $pc23_max_age $last_pc50
$last_hour $last10 %eph %pings %rcmds
%nodehops $baddx $badspotter $badnode $censorpc
$allowzero $decode_dk0wcy $send_opernam @checklist);
$baddx = new DXHash "baddx";
$badspotter = new DXHash "badspotter";
$badnode = new DXHash "badnode";
-$last10 = time;
+$last10 = $last_pc50 = time;
@checklist =
(
# remember type of connection
$self->{consort} = $line;
$self->{outbound} = $sort eq 'O';
- $self->{priv} = $user->priv || 1; # other clusters can always be 'normal' users
+ my $priv = $user->priv;
+ $priv = $user->priv(1) unless $priv;
+ $self->{priv} = $priv; # other clusters can always be 'normal' users
$self->{lang} = $user->lang || 'en';
$self->{isolate} = $user->{isolate};
$self->{consort} = $line; # save the connection type
$self->{here} = 1;
+ $self->{width} = 80;
# get the output filters
$self->{spotsfilter} = Filter::read_in('spots', $call, 0) || Filter::read_in('spots', 'node_default', 0);
$self->{wwvfilter} = Filter::read_in('wwv', $call, 0) || Filter::read_in('wwv', 'node_default', 0);
$self->{wcyfilter} = Filter::read_in('wcy', $call, 0) || Filter::read_in('wcy', 'node_default', 0);
$self->{annfilter} = Filter::read_in('ann', $call, 0) || Filter::read_in('ann', 'node_default', 0) ;
- $self->{routefilter} = Filter::read_in('route', $call, 0) || Filter::read_in('route', 'node_default', 0) ;
+ $self->{routefilter} = Filter::read_in('route', $call, 0) || Filter::read_in('route', 'node_default', 0) unless $self->{isolate} ;
# get the INPUT filters (these only pertain to Clusters)
$self->{inwwvfilter} = Filter::read_in('wwv', $call, 1) || Filter::read_in('wwv', 'node_default', 1);
$self->{inwcyfilter} = Filter::read_in('wcy', $call, 1) || Filter::read_in('wcy', 'node_default', 1);
$self->{inannfilter} = Filter::read_in('ann', $call, 1) || Filter::read_in('ann', 'node_default', 1);
- $self->{inroutefilter} = Filter::read_in('route', $call, 1) || Filter::read_in('route', 'node_default', 1);
+ $self->{inroutefilter} = Filter::read_in('route', $call, 1) || Filter::read_in('route', 'node_default', 1) unless $self->{isolate};
# set unbuffered and no echo
$self->send_now('B',"0");
my $user = DXUser->get_current($spot[4]);
if ($user) {
my $qra = $user->qra;
- unless ($qra && DXBearing::is_qra($qra)) {
+ unless ($qra && is_qra($qra)) {
my $lat = $user->lat;
my $long = $user->long;
if (defined $lat && defined $long) {
my $node;
my $to = $user->homenode;
my $last = $user->lastoper || 0;
- if ($to ne $main::mycall && $send_opernam && $main::systime > $last + $DXUser::lastoperinterval && $to && ($node = Route::Node::get($to)) ) {
+ if ($send_opernam && $to && $to ne $main::mycall && $main::systime > $last + $DXUser::lastoperinterval && ($node = Route::Node::get($to)) ) {
my $cmd = "forward/opernam $spot[4]";
# send the rcmd but we aren't interested in the replies...
my $dxchan = $node->dxchan;
my ($call, $conf, $here) = $field[$i] =~ /^(\S+) (\S) (\d)/o;
next unless $call && $conf && defined $here && is_callsign($call);
next if $call eq $main::mycall;
+
+ eph_del_regex("^PC17\^$call\^$ncall");
$conf = $conf eq '*';
$r->flags($flags);
push @rout, $r;
}
- $r->addparent($ncall);
+ $r->addparent($parent);
} else {
push @rout, $parent->add_user($call, $flags);
}
$user->put;
}
+ if (eph_dup($line)) {
+ dbg("PCPROT: dup PC16 detected") if isdbg('chanerr');
+ return;
+ }
# queue up any messages (look for privates only)
DXMsg::queue_msg(1) if $self->state eq 'normal';
my $dxchan;
my $ncall = $field[2];
my $ucall = $field[1];
+
+ eph_del_regex("^PC16.*$ncall.*$ucall");
+
if ($ncall eq $main::mycall) {
dbg("PCPROT: trying to alter config on this node from outside!") if isdbg('chanerr');
return;
dbg("PCPROT: Route::Node $ncall not in config") if isdbg('chanerr');
return;
}
+ my $uref = Route::User::get($ucall);
+ unless ($uref) {
+ dbg("PCPROT: Route::User $ucall not in config") if isdbg('chanerr');
+ return;
+ }
+
# input filter if required
return unless $self->in_filter_route($parent);
+
+ my @rout = $parent->del_user($uref);
+
+ if (eph_dup($line)) {
+ dbg("PCPROT: dup PC17 detected") if isdbg('chanerr');
+ return;
+ }
- my @rout = $parent->del_user($ucall);
$self->route_pc17($parent, @rout) if @rout;
return;
}
# first clear out any nodes on this dxchannel
my $parent = Route::Node::get($self->{call});
my @rout = $parent->del_nodes;
- $self->route_pc21(@rout, $parent);
+ $self->route_pc21(@rout, $parent) if @rout;
$self->send_local_config();
$self->send(pc20());
return; # we don't pass these on
my $conf = $field[$i+2];
my $ver = $field[$i+3];
next unless defined $here && defined $conf && is_callsign($call);
+
+ eph_del_regex("^PC(?:21\^$call|17\^[^\^]+\^$call)");
+
# check for sane parameters
$ver = 5000 if $ver eq '0000';
next if $ver < 5000; # only works with version 5 software
$user = DXUser->new($call);
$user->sort('A');
$user->priv(1); # I have relented and defaulted nodes
- $self->{priv} = 1; # to user RCMDs allowed
+ $user->lockout(1);
$user->homenode($call);
$user->node($call);
}
$user->put;
}
+ if (eph_dup($line)) {
+ dbg("PCPROT: dup PC19 detected") if isdbg('chanerr');
+ return;
+ }
+
$self->route_pc19(@rout) if @rout;
return;
}
if ($pcno == 21) { # delete a cluster from the list
my $call = uc $field[1];
+
+ eph_del_regex("^PC1[79].*$call");
+
my @rout;
my $parent = Route::Node::get($self->{call});
unless ($parent) {
dbg("PCPROT: I WILL _NOT_ be disconnected!") if isdbg('chanerr');
return;
}
+
+ if (eph_dup($line)) {
+ dbg("PCPROT: dup PC21 detected") if isdbg('chanerr');
+ return;
+ }
+
$self->route_pc21(@rout) if @rout;
return;
}
return;
}
- Log('DXProt', "Merge request for $field[3] spots and $field[4] WWV from $field[1]");
+ Log('DXProt', "Merge request for $field[3] spots and $field[4] WWV from $field[2]");
# spots
if ($field[3] > 0) {
if ($pcno == 39) { # incoming disconnect
if ($field[1] eq $self->{call}) {
$self->disconnect(1);
+ eph_del_regex("^PC(?:1[679]|21).*$field[1]");
} else {
dbg("PCPROT: came in on wrong channel") if isdbg('chanerr');
}
my $call = $field[1];
# input filter if required
- my $ref = Route::get($call) || Route->new($call);
- return unless $self->in_filter_route($ref);
+# my $ref = Route::get($call) || Route->new($call);
+# return unless $self->in_filter_route($ref);
- # dup check it
- if (eph_dup($line)) {
- dbg("PCPROT: ephemeral PC41 dup dropped") if isdbg('chanerr');
+ if ($field[3] eq $field[2]) {
+ dbg('PCPROT: invalid value') if isdbg('chanerr');
return;
}
} elsif ($field[2] == 2) {
$user->qth($field[3]);
} elsif ($field[2] == 3) {
- my ($lat, $long) = DXBearing::stoll($field[3]);
- $user->lat($lat);
- $user->long($long);
- $user->qra(DXBearing::lltoqra($lat, $long)) unless $user->qra && DXBearing::is_qra($user->qra);
+ if (is_latlong($field[3])) {
+ my ($lat, $long) = DXBearing::stoll($field[3]);
+ $user->lat($lat);
+ $user->long($long);
+ $user->qra(DXBearing::lltoqra($lat, $long));
+ } else {
+ dbg('PCPROT: not a valid lat/long') if isdbg('chanerr');
+ return;
+ }
} elsif ($field[2] == 4) {
$user->homenode($field[3]);
+ } elsif ($field[2] == 5) {
+ if (is_qra($field[3])) {
+ my ($lat, $long) = DXBearing::qratoll($field[3]);
+ $user->lat($lat);
+ $user->long($long);
+ $user->qra($field[3]);
+ } else {
+ dbg('PCPROT: not a valid QRA locator') if isdbg('chanerr');
+ return;
+ }
}
$user->lastoper($main::systime); # to cut down on excessive for/opers being generated
$user->put;
my $to = $field[1];
my $from = $field[2];
my $flag = $field[3];
+
# is it for us?
if ($to eq $main::mycall) {
}
}
} else {
+ if (eph_dup($line)) {
+ dbg("PCPROT: dup PC51 detected") if isdbg('chanerr');
+ return;
+ }
# route down an appropriate thingy
$self->route($to, $line);
}
my $t = time;
my @dxchan = DXChannel->get_all();
my $dxchan;
+ my $pc50s;
+ # send out a pc50 on EVERY channel all at once
+ if ($t >= $last_pc50 + $DXProt::pc50_interval) {
+ $pc50s = pc50($me, scalar DXChannel::get_all_users);
+ eph_dup($pc50s);
+ $last_pc50 = $t;
+ }
+
foreach $dxchan (@dxchan) {
next unless $dxchan->is_node();
next if $dxchan == $me;
-
- # send a pc50 out on this channel
- $dxchan->{pc50_t} = $main::systime unless exists $dxchan->{pc50_t};
- if ($t >= $dxchan->{pc50_t} + $DXProt::pc50_interval) {
- my $s = pc50($me, scalar DXChannel::get_all_users);
- eph_dup($s);
- $dxchan->send($s);
- $dxchan->{pc50_t} = $t;
- }
+ # send the pc50
+ $dxchan->send($pc50s) if $pc50s;
+
# send a ping out on this channel
if ($dxchan->{pingint} && $t >= $dxchan->{pingint} + $dxchan->{lastping}) {
if ($dxchan->{nopings} <= 0) {
($filter, $hops) = $self->{spotsfilter}->it(@_);
return unless $filter;
}
- send_prot_line($self, $filter, $hops, $isolate, $line)
+ send_prot_line($self, $filter, $hops, $isolate, $line);
}
sub send_prot_line
return unless $routeit;
}
if ($filter) {
- $self->send($routeit) if $routeit;
+ $self->send($routeit);
} else {
$self->send($routeit) unless $self->{isolate} || $isolate;
}
foreach $dxchan (@dxchan) {
next if $dxchan == $me;
next if $dxchan == $self && $self->is_node;
- my $routeit;
- my ($filter, $hops);
-
- $dxchan->announce($line, $self->{isolate}, $to, $target, $text, @_, $self->{call}, $ann_dxcc, $ann_itu, $ann_cq, $org_dxcc, $org_itu, $org_cq)
+ $dxchan->announce($line, $self->{isolate}, $to, $target, $text, @_, $self->{call}, $ann_dxcc, $ann_itu, $ann_cq, $org_dxcc, $org_itu, $org_cq);
}
}
my $isolate = shift;
my $to = shift;
my $target = shift;
+ my $text = shift;
my ($filter, $hops);
if ($self->{annfilter}) {
# create a list of all the nodes that are not connected to this connection
# and are not themselves isolated, this to make sure that isolated nodes
# don't appear outside of this node
- my @dxchan = grep { $_->call ne $main::mycall && $_->call ne $self->{call} } DXChannel::get_all_nodes();
+ my @dxchan = grep { $_->call ne $main::mycall && $_ != $self && !$_->{isolate} } DXChannel::get_all_nodes();
@localnodes = map { my $r = Route::Node::get($_->{call}); $r ? $r : () } @dxchan if @dxchan;
my @intcalls = map { $_->nodes } @localnodes if @localnodes;
my $ref = Route::Node::get($self->{call});
my $s = $rcmds{$fromnode};
if ($s) {
my $dxchan = DXChannel->get($s->{call});
- my $ref = DXChannel->get($user) || $dxchan;
+ my $ref = $user eq $tonode ? $dxchan : (DXChannel->get($user) || $dxchan);
$ref->send($line) if $ref;
delete $rcmds{$fromnode} if !$dxchan;
} else {
my $node = Route::Node::get($call);
my @rout;
if ($node) {
- @rout = $node->del_nodes; # at the next level
@rout = $node->del($main::routeroot);
}
$routeit = adjust_hops($self, $line); # adjust its hop count by node name
next unless $routeit;
}
- $self->send($routeit) if $self->{routefilter} || !$self->{isolate};
+ $self->send($routeit);
}
}
}
foreach $dxchan (@dxchan) {
next if $dxchan == $self;
next if $dxchan == $me;
- if ($dxchan->{routefilter} || !$self->{isolate}) {
- $dxchan->send_route($generate, @_)
+ if ($dxchan->{routefilter}) {
+ $dxchan->send_route($generate, @_);
} else {
- dbg('DXPROT: isolated') if isdbg('chanerr');
+ $dxchan->send_route($generate, @_) unless $self->{isolate} || $dxchan->{isolate};
}
}
}
my $s = shift;
# chop the end off
- $s =~ s/\^H\d\d?\^?~?$//;
+ $s =~ s/\^H\d\d?\^?\~?$//;
return 1 if exists $eph{$s};
$eph{$s} = $main::systime;
return undef;
}
+sub eph_del_regex
+{
+ my $regex = shift;
+ my ($key, $val);
+ while (($key, $val) = each %eph) {
+ if ($key =~ m{$regex}) {
+ delete $eph{$key};
+ }
+ }
+}
+
sub eph_clean
{
my ($key, $val);