viewvc.cgi/mdap/mdap-server.pl

#!/usr/bin/perl

use strict;
use IO::Socket::Multicast;
use Data::Dump qw/dump/;
use Getopt::Long;

my $GROUP = '224.0.0.103';
my $PORT  = '3235';

my $debug = 0;
my $quiet = 1;
my $verbose = 0;

my $resend_search_delay = 3;
my $tftp_path = '/srv/tftp/';

GetOptions(
        "port=i"        => \$PORT,
        "group=s"       => \$GROUP,
        "debug!"        => \$debug,
        "quiet!"        => \$quiet,
        "verbose!"      => \$verbose,
        "search=i"      => \$resend_search_delay,
        "tftp=s"        => \$tftp_path,
);

$quiet = 0 if $verbose;

# tab-delimited list of user id/passwd to try on ants
my @try_accounts = ( "Administrator\t" );

my $passwd_path = $0;
$passwd_path =~ s/[^\/]+$/passwd/;

if (-e $passwd_path) {
        open(my $fh, $passwd_path) || die "can't open $passwd_path: $!";
        while(<$fh>) {
                chomp;
                next if /^#/ || /^$/ || /^\s+$/;
                if (/^\S+\t\S+$/) {
                        push @try_accounts, $_;
                } else {
                        warn "invalid $passwd_path entry: $_\n";
                }
        }
        print "found ", $#try_accounts + 1, " accounts to try on password protected ants\n";
}

warn "search for ants every ${resend_search_delay}s\ntftp server path: $tftp_path\n";

sub fw {
        my ($board, $offset,$len) = @_;
        open(my $fh, "$tftp_path/$board") || die "Can't open image $tftp_path/$board: $!";
        my $b;
        seek($fh, $offset, 0) || die "can't seek to $offset: $!";
        read($fh, $b, $len) || die "can't read $len bytes from $offset: $!";
        close($fh);
        return $b;
}

sub fw_build {
        my $board_name = shift || return 0;
        my $v = join('.', unpack('CCCC',fw($board_name,0x20,4)) );
        print "# fw_build $board_name $v\n" unless $quiet;
        return $v;
}

sub fw_exists {
        my $board = shift;
        return -e "$tftp_path/$board";
}

my $sock = IO::Socket::Multicast->new(LocalPort=>$PORT,ReuseAddr=>1);
$sock->mcast_add($GROUP) || die "Couldn't set group: $!\n";
$sock->mcast_ttl(1);

sub ant2hash {
        my $data = shift;
        my $hash;
        map {
                if ( m/:/ ) {
                        my ($n,$v) = split(/:/,$_,2);
                        $hash->{$n} = $v;
                }
        } split(/[\n\r]/, $data);
        return $hash;
}

sub mdap_send {
        my $data = shift;

        my $xor = 0;
        map { $xor ^= ord($_) } split(//,$data);
        $data .= sprintf('%02X', $xor);

        $sock->mcast_send( $data, "${GROUP}:${PORT}" );
        if ($debug) {
                warn ">> ", dump( $data ), $/;
        } elsif( ! $quiet ) {
                $data =~ s/\s+/ /gi;
                warn ">> ", substr($data,0,70), $/;
        }
}

my $ant_passwd;

sub ant_credentials {
        my $ant = shift || die "no ant?";
        my $i = $ant_passwd->{$ant} || 0;
        my ($user_id,$user_pwd) = split(/\t/, $try_accounts[$i]);
        #warn "ant $ant as [$i] $user_id / $user_pwd\n";
        return ($user_id,$user_pwd);
}

my $ant_unknown_password;
my $ant_ok_password;

sub ant_unknown_password {
        my $ant = shift || die "no ant?";
        if ( $ant_unknown_password->{$ant} ) {
                $ant_unknown_password->{$ant}--;
        }
        return $ant_unknown_password->{$ant};
}

sub ant_another_passwd {
        my $ant = shift || die "no ant?";

        return 0 if ant_unknown_password( $ant );

        $ant_passwd->{$ant}++;

        if ( $ant_passwd->{$ant} > $#try_accounts ) {
                print "$ant ant with unknown password\n";
                $ant_unknown_password->{$ant} = 10;
                $ant_passwd->{$ant} = 0;
                return 0;
        }
        return 1;
}

sub forget_ant {
        my $ant = shift || die "no ant?";
        delete $ant_unknown_password->{$ant};
        delete $ant_passwd->{$ant};
        delete $ant_ok_password->{$ant};
}

my $once;

sub once {
        my $m = join('', @_);
        $once->{$m}++;
        print $m if ($once->{$m} == 1);
}

local $SIG{ALRM} = sub {
        mdap_send("ANT-SEARCH MDAP/1.1\r\n");
        alarm( $resend_search_delay );
};

alarm( $resend_search_delay );

mdap_send("ANT-SEARCH MDAP/1.1\r\n");

while (1) {
        my $data;
        next unless $sock->recv($data,1024);

        if ( $data =~ m#^(INFO|ANT-SEARCH|EXEC-CLI|REPLY-\S+)\s(MDAP)/(\d+\.\d+)# ) {

                my ($type,$proto,$mdap_ver) = ($1,$2,$3);

                my $h = ant2hash($data);

                my $client_version = $h->{'MDAP-VERSION'};
                $mdap_ver = $client_version if ($client_version);

                print "<< $type $proto/$mdap_ver << ", length($data), " bytes\n" unless $quiet;

                warn dump($h),$/ if ($debug);

                # we are getting our own messages (since our source port
                # is same as destination)
                next if ( $type =~ m#^(INFO|ANT-SEARCH|EXEC-CLI)# );

                my $ant = $h->{'ANT-ID'} || die "no ANT-ID in ", dump( $h );
                my $seq_nr = $h->{'SEQ-NR'};
                #warn "SEQ-NR: $seq_nr ok: ",$ant_ok_password->{$ant},"\n" if ($seq_nr);

                my ($user_id,$user_pwd) = ant_credentials( $ant );

                if ($type eq 'REPLY-ANT-SEARCH') {
                        mdap_send("INFO MDAP/$mdap_ver\r\nSEQ-NR:1\r\nTO-ANT:$ant\r\nUSER-ID:$user_id\r\nUSER-PWD:$user_pwd\r\n") unless ant_unknown_password( $ant );
                } elsif ($type eq 'REPLY-INFO') {

                        if ( $seq_nr < 0 ) {
#                               if ( $ant_ok_password ) {
#                                       $ant_ok_password->{$ant} = 0;
#                               } elsif ( ant_another_passwd( $ant ) ) {
                                if ( ant_another_passwd( $ant ) ) {
                                        ($user_id,$user_pwd) = ant_credentials( $ant );
                                        mdap_send("INFO MDAP/$mdap_ver\r\nSEQ-NR:1\r\nTO-ANT:$ant\r\nUSER-ID:$user_id\r\nUSER-PWD:$user_pwd\r\n");
                                }
                                next;
                        } else {
                                $ant_ok_password->{$ant}++;
                        }

                        my $board = $h->{'_BOARD_NAME'} || die "no _BOARD_NAME?";
                        if ( fw_exists( $board ) ) {
                                my $build = $h->{'_BUILD'} || die "no _BUILD?";
                                my $new_build = fw_build( $board );
                                if ( $build ne $new_build ) {
                                        print "+ $ant version $build -> $new_build\n";
                                        mdap_send("EXEC-CLI MDAP/$mdap_ver\r\nCLI-CMD:software upgrade\r\nSEQ-NR:1\r\nTO-ANT:$ant\r\nUSER-ID:$user_id\r\nUSER-PWD:$user_pwd\r\n");
                                } else {
                                        once "$ant OK version $build",
                                                $ant_unknown_password->{$ant} ? ' with unknown password' :
                                                $ant_ok_password->{$ant} ? ' password protected' :
                                                '',
                                                "\n";
                                }
                        } else {
                                once "!! NO FIRMWARE for $board in $tftp_path for ant $ant, skipping update\n";
                        }
                } elsif ( $type eq 'REPLY-EXEC-CLI' && $h->{'SEQ-NR'} == 1 ) {
                                print "+ $ant bootp mode re-flash started\n";
                                mdap_send("EXEC-CLI MDAP/$mdap_ver\r\nSEQ-NR:2\r\nTO-ANT:$ant\r\nUSER-ID:$user_id\r\nUSER-PWD:$user_pwd\r\n");
                                forget_ant( $ant );
                } else {
                        print "!! reply ignored ", dump( $h ), $/;
                }

        } else {
                warn "<=" x 15, "\n", $data, "\n", "<=" x 15, "\n";
        }
}
1	dpavlin	2	#!/usr/bin/perl
2
3			use strict;
4			use IO::Socket::Multicast;
5			use Data::Dump qw/dump/;
6	dpavlin	19	use Getopt::Long;
7	dpavlin	2
8	dpavlin	19	my $GROUP = '224.0.0.103';
9			my $PORT = '3235';
10	dpavlin	2
11	dpavlin	19	my $debug = 0;
12			my $quiet = 1;
13			my $verbose = 0;
14	dpavlin	8
15	dpavlin	2	my $resend_search_delay = 3;
16	dpavlin	7	my $tftp_path = '/srv/tftp/';
17	dpavlin	2
18	dpavlin	19	GetOptions(
19			"port=i" => \$PORT,
20			"group=s" => \$GROUP,
21			"debug!" => \$debug,
22			"quiet!" => \$quiet,
23			"verbose!" => \$verbose,
24			"search=i" => \$resend_search_delay,
25			"tftp=s" => \$tftp_path,
26			);
27
28			$quiet = 0 if $verbose;
29
30	dpavlin	17	# tab-delimited list of user id/passwd to try on ants
31			my @try_accounts = ( "Administrator\t" );
32	dpavlin	14
33	dpavlin	17	my $passwd_path = $0;
34			$passwd_path =~ s/[^\/]+$/passwd/;
35
36			if (-e $passwd_path) {
37			open(my $fh, $passwd_path) \|\| die "can't open $passwd_path: $!";
38			while(<$fh>) {
39			chomp;
40			next if /^#/ \|\| /^$/ \|\| /^\s+$/;
41			if (/^\S+\t\S+$/) {
42			push @try_accounts, $_;
43			} else {
44			warn "invalid $passwd_path entry: $_\n";
45			}
46			}
47	dpavlin	19	print "found ", $#try_accounts + 1, " accounts to try on password protected ants\n";
48	dpavlin	17	}
49
50	dpavlin	9	warn "search for ants every ${resend_search_delay}s\ntftp server path: $tftp_path\n";
51
52	dpavlin	7	sub fw {
53			my ($board, $offset,$len) = @_;
54			open(my $fh, "$tftp_path/$board") \|\| die "Can't open image $tftp_path/$board: $!";
55			my $b;
56			seek($fh, $offset, 0) \|\| die "can't seek to $offset: $!";
57			read($fh, $b, $len) \|\| die "can't read $len bytes from $offset: $!";
58			close($fh);
59			return $b;
60			}
61
62			sub fw_build {
63			my $board_name = shift \|\| return 0;
64			my $v = join('.', unpack('CCCC',fw($board_name,0x20,4)) );
65	dpavlin	19	print "# fw_build $board_name $v\n" unless $quiet;
66	dpavlin	7	return $v;
67			}
68
69			sub fw_exists {
70			my $board = shift;
71			return -e "$tftp_path/$board";
72			}
73
74	dpavlin	19	my $sock = IO::Socket::Multicast->new(LocalPort=>$PORT,ReuseAddr=>1);
75			$sock->mcast_add($GROUP) \|\| die "Couldn't set group: $!\n";
76	dpavlin	2	$sock->mcast_ttl(1);
77
78			sub ant2hash {
79			my $data = shift;
80			my $hash;
81			map {
82			if ( m/:/ ) {
83			my ($n,$v) = split(/:/,$_,2);
84			$hash->{$n} = $v;
85			}
86			} split(/[\n\r]/, $data);
87			return $hash;
88			}
89
90			sub mdap_send {
91			my $data = shift;
92	dpavlin	14
93			my $xor = 0;
94			map { $xor ^= ord($_) } split(//,$data);
95			$data .= sprintf('%02X', $xor);
96
97	dpavlin	19	$sock->mcast_send( $data, "${GROUP}:${PORT}" );
98	dpavlin	9	if ($debug) {
99			warn ">> ", dump( $data ), $/;
100	dpavlin	19	} elsif( ! $quiet ) {
101	dpavlin	9	$data =~ s/\s+/ /gi;
102			warn ">> ", substr($data,0,70), $/;
103			}
104	dpavlin	2	}
105
106	dpavlin	20	my $ant_passwd;
107	dpavlin	17
108			sub ant_credentials {
109			my $ant = shift \|\| die "no ant?";
110	dpavlin	20	my $i = $ant_passwd->{$ant} \|\| 0;
111	dpavlin	17	my ($user_id,$user_pwd) = split(/\t/, $try_accounts[$i]);
112			#warn "ant $ant as [$i] $user_id / $user_pwd\n";
113			return ($user_id,$user_pwd);
114			}
115
116	dpavlin	24	my $ant_unknown_password;
117			my $ant_ok_password;
118	dpavlin	20
119	dpavlin	25	sub ant_unknown_password {
120			my $ant = shift \|\| die "no ant?";
121			if ( $ant_unknown_password->{$ant} ) {
122			$ant_unknown_password->{$ant}--;
123			}
124			return $ant_unknown_password->{$ant};
125			}
126
127	dpavlin	17	sub ant_another_passwd {
128			my $ant = shift \|\| die "no ant?";
129	dpavlin	20
130	dpavlin	25	return 0 if ant_unknown_password( $ant );
131
132	dpavlin	20	$ant_passwd->{$ant}++;
133
134			if ( $ant_passwd->{$ant} > $#try_accounts ) {
135	dpavlin	23	print "$ant ant with unknown password\n";
136	dpavlin	26	$ant_unknown_password->{$ant} = 10;
137	dpavlin	24	$ant_passwd->{$ant} = 0;
138	dpavlin	20	return 0;
139			}
140			return 1;
141	dpavlin	17	}
142
143	dpavlin	27	sub forget_ant {
144			my $ant = shift \|\| die "no ant?";
145			delete $ant_unknown_password->{$ant};
146			delete $ant_passwd->{$ant};
147			delete $ant_ok_password->{$ant};
148			}
149
150	dpavlin	20	my $once;
151
152			sub once {
153	dpavlin	23	my $m = join('', @_);
154	dpavlin	20	$once->{$m}++;
155			print $m if ($once->{$m} == 1);
156			}
157
158	dpavlin	2	local $SIG{ALRM} = sub {
159	dpavlin	14	mdap_send("ANT-SEARCH MDAP/1.1\r\n");
160	dpavlin	2	alarm( $resend_search_delay );
161			};
162
163			alarm( $resend_search_delay );
164
165	dpavlin	14	mdap_send("ANT-SEARCH MDAP/1.1\r\n");
166	dpavlin	7
167	dpavlin	2	while (1) {
168			my $data;
169			next unless $sock->recv($data,1024);
170
171	dpavlin	9	if ( $data =~ m#^(INFO\|ANT-SEARCH\|EXEC-CLI\|REPLY-\S+)\s(MDAP)/(\d+\.\d+)# ) {
172	dpavlin	2
173	dpavlin	9	my ($type,$proto,$mdap_ver) = ($1,$2,$3);
174	dpavlin	2
175			my $h = ant2hash($data);
176
177	dpavlin	9	my $client_version = $h->{'MDAP-VERSION'};
178			$mdap_ver = $client_version if ($client_version);
179	dpavlin	7
180	dpavlin	19	print "<< $type $proto/$mdap_ver << ", length($data), " bytes\n" unless $quiet;
181	dpavlin	2
182	dpavlin	8	warn dump($h),$/ if ($debug);
183
184	dpavlin	17	# we are getting our own messages (since our source port
185			# is same as destination)
186	dpavlin	9	next if ( $type =~ m#^(INFO\|ANT-SEARCH\|EXEC-CLI)# );
187
188			my $ant = $h->{'ANT-ID'} \|\| die "no ANT-ID in ", dump( $h );
189	dpavlin	24	my $seq_nr = $h->{'SEQ-NR'};
190			#warn "SEQ-NR: $seq_nr ok: ",$ant_ok_password->{$ant},"\n" if ($seq_nr);
191	dpavlin	9
192	dpavlin	17	my ($user_id,$user_pwd) = ant_credentials( $ant );
193
194	dpavlin	2	if ($type eq 'REPLY-ANT-SEARCH') {
195	dpavlin	25	mdap_send("INFO MDAP/$mdap_ver\r\nSEQ-NR:1\r\nTO-ANT:$ant\r\nUSER-ID:$user_id\r\nUSER-PWD:$user_pwd\r\n") unless ant_unknown_password( $ant );
196	dpavlin	2	} elsif ($type eq 'REPLY-INFO') {
197	dpavlin	15
198	dpavlin	24	if ( $seq_nr < 0 ) {
199	dpavlin	27	# if ( $ant_ok_password ) {
200			# $ant_ok_password->{$ant} = 0;
201			# } elsif ( ant_another_passwd( $ant ) ) {
202			if ( ant_another_passwd( $ant ) ) {
203	dpavlin	24	($user_id,$user_pwd) = ant_credentials( $ant );
204	dpavlin	20	mdap_send("INFO MDAP/$mdap_ver\r\nSEQ-NR:1\r\nTO-ANT:$ant\r\nUSER-ID:$user_id\r\nUSER-PWD:$user_pwd\r\n");
205			}
206	dpavlin	15	next;
207	dpavlin	24	} else {
208			$ant_ok_password->{$ant}++;
209	dpavlin	15	}
210
211	dpavlin	7	my $board = $h->{'_BOARD_NAME'} \|\| die "no _BOARD_NAME?";
212			if ( fw_exists( $board ) ) {
213	dpavlin	14	my $build = $h->{'_BUILD'} \|\| die "no _BUILD?";
214			my $new_build = fw_build( $board );
215			if ( $build ne $new_build ) {
216	dpavlin	23	print "+ $ant version $build -> $new_build\n";
217	dpavlin	14	mdap_send("EXEC-CLI MDAP/$mdap_ver\r\nCLI-CMD:software upgrade\r\nSEQ-NR:1\r\nTO-ANT:$ant\r\nUSER-ID:$user_id\r\nUSER-PWD:$user_pwd\r\n");
218	dpavlin	7	} else {
219	dpavlin	23	once "$ant OK version $build",
220	dpavlin	24	$ant_unknown_password->{$ant} ? ' with unknown password' :
221			$ant_ok_password->{$ant} ? ' password protected' :
222			'',
223	dpavlin	23	"\n";
224	dpavlin	7	}
225	dpavlin	2	} else {
226	dpavlin	20	once "!! NO FIRMWARE for $board in $tftp_path for ant $ant, skipping update\n";
227	dpavlin	2	}
228	dpavlin	3	} elsif ( $type eq 'REPLY-EXEC-CLI' && $h->{'SEQ-NR'} == 1 ) {
229	dpavlin	23	print "+ $ant bootp mode re-flash started\n";
230	dpavlin	14	mdap_send("EXEC-CLI MDAP/$mdap_ver\r\nSEQ-NR:2\r\nTO-ANT:$ant\r\nUSER-ID:$user_id\r\nUSER-PWD:$user_pwd\r\n");
231	dpavlin	27	forget_ant( $ant );
232	dpavlin	2	} else {
233	dpavlin	8	print "!! reply ignored ", dump( $h ), $/;
234	dpavlin	2	}
235
236			} else {
237	dpavlin	8	warn "<=" x 15, "\n", $data, "\n", "<=" x 15, "\n";
238	dpavlin	2	}
239			}