]> dxcluster.net Git - spider.git/blob - perl/Thingy/Rt.pm
f7c503acfa019af5335fb333bb62e12cc9ef4a54
[spider.git] / perl / Thingy / Rt.pm
1 #
2 # Route Thingy handling
3 #
4 # $Id$
5 #
6 # Copyright (c) 2005 Dirk Koopman G1TLH
7 #
8
9 use strict;
10
11 package Thingy::Rt;
12
13 use vars qw($VERSION $BRANCH);
14
15 main::mkver($VERSION = q$Revision$);
16
17 use DXChannel;
18 use DXDebug;
19 use DXUtil;
20 use Thingy;
21 use Spot;
22
23 use vars qw(@ISA);
24 @ISA = qw(Thingy);
25
26 sub gen_Aranea
27 {
28         my $thing = shift;
29         unless ($thing->{Aranea}) {
30                 my @items;
31                 push @items, 's', $thing->{'s'} if $thing->{'s'};
32                 push @items, 'n', $thing->{n} if $thing->{n};
33                 push @items, 'v', $thing->{v} if $thing->{v};
34                 push @items, 'u', $thing->{u} if $thing->{u};
35                 $thing->{Aranea} = Aranea::genmsg($thing, 'RT', @items) if @items;
36         }
37         return $thing->{Aranea};
38 }
39
40 sub from_Aranea
41 {
42         my $thing = shift;
43         return unless $thing;
44         return $thing;
45 }
46
47 sub gen_DXProt
48 {
49         my $thing = shift;
50         my $dxchan = shift;
51         my $s = $thing->{'s'};
52         if ($s eq 'au') {
53                 my $n = $thing->{n} || $thing->{user};
54                 my @out;
55                 if ($n && (my $u = $thing->{u})) {
56                         my $s = '';
57                         for (split /:/, $u) {
58                                 my ($here, $call) = unpack "A1 A*", $_;
59                                 my $str = sprintf "^%s * %d", $call, $here;
60                                 if (length($s) + length($str) > $DXProt::sentencelth) {
61                                         push @out, "PC16^$n" . $s . sprintf "^%s^", DXProt::get_hops(16);
62                                         $s = '';
63                                 }
64                                 $s .= $str;
65                         }
66                         push @out, "PC16^$n" . $s . sprintf "^%s^", DXProt::get_hops(16);
67                         $thing->{DXProt} = @out > 1 ? \@out : $out[0];
68                 }
69         } elsif ($s eq 'du') {
70                 my $n = $thing->{n} || $thing->{user};
71                 my $hops = DXProt::get_hops(17);
72                 if ($n && (my $u = $thing->{u})) {
73                         $thing->{DXProt} = "PC17^$u^$n^$hops^"; 
74                 }
75         } elsif ($s eq 'an') {
76         } elsif ($s eq 'dn') {
77         }
78         return $thing->{DXProt};
79 }
80
81 #sub gen_DXCommandmode
82 #{
83 #       my $thing = shift;
84 #       my $dxchan = shift;
85 #       my $buf;
86 #
87 #       return $buf;
88 #}
89
90 sub from_DXProt
91 {
92         my $thing = shift;
93         while (@_) {
94                 my $k = shift;
95                 $thing->{$k} = shift;
96         }
97         ($thing->{hops}) = $thing->{DXProt} =~ /\^H(\d+)\^?~?$/ if exists $thing->{DXProt};
98         return $thing;
99 }
100
101 sub handle
102 {
103         my $thing = shift;
104         my $dxchan = shift;
105
106         if ($thing->{t}) {
107                 my $sub = "handle_$thing->{t}";
108                 if ($thing->can($sub)) {
109                         no strict 'refs';
110                         $thing = $thing->$sub($dxchan);
111                 }
112
113                 $thing->broadcast($dxchan) if $thing;
114         }
115 }
116
117 # these contain users and either a node (for externals) or the from address 
118 sub handle_au
119 {
120         my $thing = shift;
121         my $dxchan = shift;
122
123         my $node = $thing->{n} || $thing->{user};
124         my $nref = Route::Node::get($node);
125
126         if ($nref) {
127                 if (my $u = $thing->{u}) {
128                         for (split /:/, $u) {
129                                 my ($here, $call) = unpack "A1 A*", $_;
130                                 add_user($nref, $call, $here);
131                                 my $h = $dxchan->{call} eq $nref->{call} ? 3 : ($thing->{hops} || 99);
132                                 RouteDB::update($call, $dxchan->{call}, $h);
133                         }
134                 }
135         } else {
136                 dbg("Thingy::Rt::au: $node not found") if isdbg('chanerr');
137                 return;
138         }
139         return $thing;
140 }
141
142 sub handle_du
143 {
144         my $thing = shift;
145         my $dxchan = shift;
146
147         my $node = $thing->{n} || $thing->{user};
148         my $nref = Route::Node::get($node);
149
150         if ($nref) {
151                 if (my $u = $thing->{u}) {
152                         for (split /:/, $u) {
153                                 my ($here, $call) = unpack "A1 A*", $_;
154                                 my $uref = Route::User::get($call);
155                                 unless ($uref) {
156                                         dbg("Thingy::Rt::du $call not a user") if isdbg('chanerr');
157                                         next;
158                                 }
159                                 $nref->del_user($uref);
160                                 RouteDB::delete($call, $dxchan->{call});
161                         }
162                         RouteDB::update($nref->{call}, $dxchan->{call}, $dxchan->{call} eq $nref->{call} ? 2 : ($thing->{hops} || 99));
163                 }
164         } else {
165                 dbg("Thingy::Rt::du: $node not found") if isdbg('chanerr');
166                 return;
167         }
168
169         return $thing;
170 }
171
172 sub in_filter
173 {
174         my $thing = shift;
175         my $dxchan = shift;
176         
177         # global route filtering on INPUT
178         if ($dxchan->{inroutefilter}) {
179                 my $r = Route::Node::get($thing->{origin});
180                 my ($filter, $hops) = $dxchan->{inroutefilter}->it($dxchan->{call}, $dxchan->{dxcc}, $dxchan->{itu}, $dxchan->{cq}, $r->{call}, $r->{dxcc}, $r->{itu}, $r->{cq}, $dxchan->{state}, $r->{state});
181                 unless ($filter) {
182                         dbg("PCPROT: Rejected by input route filter") if isdbg('chanerr');
183                         return;
184                 }
185         }
186         return 1;
187 }
188
189 sub out_filter
190 {
191         my $thing = shift;
192         my $dxchan = shift;
193         
194         # global route filtering on OUTPUT
195         if ($dxchan->{routefilter}) {
196                 my $r = Route::Node::get($thing->{origin});
197                 my ($filter, $hops) = $dxchan->{routefilter}->it($dxchan->{call}, $dxchan->{dxcc}, $dxchan->{itu}, $dxchan->{cq}, $r->{call}, $r->{dxcc}, $r->{itu}, $r->{cq}, $dxchan->{state}, $r->{state});          
198                 unless ($filter) {
199                         dbg("PCPROT: Rejected by output route filter") if isdbg('chanerr');
200                         return;
201                 }
202                 $thing->{hops} = $hops if $hops;
203         } elsif ($dxchan->{isolate}) {
204                 return;
205         }
206         return 1;
207 }
208
209 sub add_user
210 {
211         my $node = shift;
212         my $user = shift;
213         my $flag = shift;
214         
215         $node->add_user($user, $flag);
216         my $ur = upd_user_rec($user, $node);
217         $ur->put;
218 }
219
220 sub upd_user_rec
221 {
222         my $call = shift;
223         my $parentcall = shift;
224         
225         # add this station to the user database, if required
226         $call =~ s/-\d+$//o;    # remove ssid for users
227         my $user = DXUser->get_current($call);
228         $user = DXUser->new($call) if !$user;
229         $user->homenode($parentcall) if !$user->homenode;
230         $user->node($parentcall);
231         $user->lastin($main::systime) unless DXChannel->get($call);
232         return $user;
233 }
234 1;