perl/QXProt.pm

   1 #
   2 # This module impliments the new protocal mode for a dx cluster
   3 #
   4 # Copyright (c) 2001 Dirk Koopman G1TLH
   5 #
   6 # $Id$
   7 #
   8
   9 package QXProt;
  10
  11 @ISA = qw(DXChannel DXProt);
  12
  13 use DXUtil;
  14 use DXChannel;
  15 use DXUser;
  16 use DXM;
  17 use DXLog;
  18 use Spot;
  19 use DXDebug;
  20 use Filter;
  21 use DXDb;
  22 use AnnTalk;
  23 use Geomag;
  24 use WCY;
  25 use Time::HiRes qw(gettimeofday tv_interval);
  26 use BadWords;
  27 use DXHash;
  28 use Route;
  29 use Route::Node;
  30 use Script;
  31 use DXProt;
  32 use Verify;
  33
  34 use strict;
  35
  36 use vars qw($VERSION $BRANCH);
  37 $VERSION = sprintf( "%d.%03d", q$Revision$ =~ /(\d+)\.(\d+)/ );
  38 $BRANCH = sprintf( "%d.%03d", q$Revision$ =~ /\d+\.\d+\.(\d+)\.(\d+)/  || (0,0));
  39 $main::build += $VERSION;
  40 $main::branch += $BRANCH;
  41
  42 sub init
  43 {
  44         my $user = DXUser->get($main::mycall);
  45         $DXProt::myprot_version += $main::version*100;
  46         $main::me = QXProt->new($main::mycall, 0, $user);
  47         $main::me->{here} = 1;
  48         $main::me->{state} = "indifferent";
  49         $main::me->{sort} = 'S';    # S for spider
  50         $main::me->{priv} = 9;
  51         $main::me->{metric} = 0;
  52         $main::me->{pingave} = 0;
  53         $main::me->{registered} = 1;
  54         $main::me->{version} = $main::version;
  55         $main::me->{build} = $main::build;
  56
  57 #       $Route::Node::me->adddxchan($main::me);
  58 }
  59
  60 sub start
  61 {
  62         my $self = shift;
  63         $self->SUPER::start(@_);
  64 }
  65
  66 sub sendinit
  67 {
  68         my $self = shift;
  69
  70         $self->send($self->genI);
  71 }
  72
  73 sub normal
  74 {
  75         my $r;
  76
  77         if  (ref $_[1] && $_->isa('Thingy')) {
  78                 $_[1]->handle($_[0]);
  79         } else {
  80                 if ($_[1] =~ /^PC\d\d\^/) {
  81                         DXProt::normal(@_);
  82                 } elsif ($_[1] =~ /^QX\w\^/){
  83
  84                         my ($sort, $tonode, $fromnode, $msgid, $incs);
  85                         return unless ($sort, $tonode, $fromnode, $msgid, $incs) = $_[1] =~ /^QX([A-Z])\^(\*|[-A-Z0-9]+)\^([-A-Z0-9]+)\^([0-9A-F]{1,4})\^.*\^([0-9A-F]{2})$/;
  86
  87                         $msgid = hex $msgid;
  88                         my $noderef = Route::Node::get($fromnode);
  89                         $noderef = Route::Node::new($fromnode) unless $noderef;
  90
  91                         my $il = length $incs;
  92                         my $cs = sprintf("%02X", unpack("%32C*", substr($_[1], 0, length($_[1]) - ($il+1))) & 255);
  93                         if ($incs ne $cs) {
  94                                 dbg("QXPROT: Checksum fail in: $incs ne calc: $cs" ) if isdbg('chanerr');
  95                                 return;
  96                         }
  97
  98                         unless ($noderef->newid($msgid)) {
  99                                 dbg("QXPROT: Dupe, dropped") if isdbg('chanerr');
 100                                 return;
 101                         }
 102
 103                         no strict 'subs';
 104                         my $sub = "Thingy::QX$sort";
 105                         my $thing = $sub->new(sort => $sort, tonode => $tonode, fromnode => $fromnode, id=> $msgid, line => $line);
 106                         $r = $thing->handle($_[0]);
 107                 } else {
 108                         dbg("QXProt: unrecognised protocol, dropped") if isdbg('chanerr')
 109                 }
 110         }
 111         unless (ref $r) {
 112                 dbg($r) if isdbg("chanerr");
 113         }
 114 }
 115
 116 sub handle
 117 {
 118         no strict 'subs';
 119         my $self = shift;
 120         my $sort = shift;
 121         my $sub = "handle$sort";
 122         $self->$sub(@_) if $self->can($sub);
 123         return;
 124 }
 125
 126 sub gen
 127 {
 128         no strict 'subs';
 129         my $self = shift;
 130         my $sort = shift;
 131         my $sub = "gen$sort";
 132         $self->$sub(@_) if $self->can($sub);
 133         return;
 134 }
 135
 136 my $last_node_update = 0;
 137 my $node_update_interval = 60*15;
 138
 139 sub process
 140 {
 141         if ($main::systime >= $last_node_update+$node_update_interval) {
 142 #               sendallnodes();
 143 #               sendallusers();
 144                 $last_node_update = $main::systime;
 145         }
 146 }
 147
 148 sub disconnect
 149 {
 150         my $self = shift;
 151         $self->DXProt::disconnect(@_);
 152 }
 153
 154 my $msgid = 1;
 155
 156 sub frame
 157 {
 158         my $sort = shift;
 159         my $to = shift || "*";
 160         my $ht;
 161
 162         $ht = sprintf "%X", $msgid;
 163         my $line = join '^', "QX$sort", $to, $main::mycall, $ht, @_;
 164         my $cs = sprintf "%02X", unpack("%32C*", $line) & 255;
 165         $msgid = 1 if ++$msgid > 0xffff;
 166         return "$line^$cs";
 167 }
 168
 169 sub send_frame
 170 {
 171         my $self = shift;
 172         my $origin = shift || $main::me;
 173         for (@_) {
 174                 $self->send(frame('X', undef, $origin == $main::me || $origin->is_user ? '' : $origin->call, $_));
 175         }
 176 }
 177
 178 sub handleI
 179 {
 180         my $self = shift;
 181
 182         my @f = split /\^/, $_[3];
 183         if ($self->user->passphrase && $f[7] && $f[8]) {
 184                 my $inv = Verify->new($f[7]);
 185                 unless ($inv->verify($f[8], $main::me->user->passphrase, $main::mycall, $self->call)) {
 186                         $self->sendnow('D','Sorry...');
 187                         $self->disconnect;
 188                 }
 189                 $self->{verified} = 1;
 190         } else {
 191                 $self->{verified} = 0;
 192         }
 193         if ($self->{outbound}) {
 194                 $self->send($self->genI);
 195         }
 196         if ($self->{sort} ne 'S' && $f[4] eq 'DXSpider') {
 197                 $self->{user}->{sort} = $self->{sort} = 'S';
 198                 $self->{user}->{priv} = $self->{priv} = 1 unless $self->{priv};
 199         }
 200         $self->{version} = $f[5];
 201         $self->{build} = $f[6];
 202         $self->state('init1');
 203         $self->{lastping} = 0;
 204 }
 205
 206 sub genI
 207 {
 208         my $self = shift;
 209         my @out = ('I', $self->call, "DXSpider", ($main::version + 53) * 100, $main::build);
 210         if (my $pass = $self->user->passphrase) {
 211                 my $inp = Verify->new;
 212                 push @out, $inp->challenge, $inp->response($pass, $self->call, $main::mycall);
 213         }
 214         return frame(@out);
 215 }
 216
 217 sub handleR
 218 {
 219
 220 }
 221
 222 sub genR
 223 {
 224
 225 }
 226
 227 sub handleP
 228 {
 229
 230 }
 231
 232 sub genP
 233 {
 234
 235 }
 236
 237 sub handleX
 238 {
 239         my $self = shift;
 240         my ($sort, $to, $from, $msgid, $origin, $line) = split /\^/, $_[3], 6;
 241
 242         my ($pcno) = $line =~ /^PC(\d\d)/;
 243         if ($pcno) {
 244                 $line =~ s/\^[[0-9A-F]+]$//;
 245                 DXProt::normal($self, $line);
 246         }
 247 }
 248
 249
 250 1;