viewvc.cgi/mdap/mdap-server.pl

#!/usr/bin/perl

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

use lib './lib';
use MDAP;

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

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

my $plugins = 1;

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

my $flashed_cmd = 'system config led=flash';

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

$quiet = 0 if $verbose;
$credentials = 1 if $debug;

# 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+\s+\S+$/) {
                        push @try_accounts, $_;
                } else {
                        warn "invalid $passwd_path entry: $_\n";
                }
        }
        print "found ", $#try_accounts + 1, " accounts to try on password protected ants",
                $credentials ? " and display credentials" : "", "\n";
}

warn "search for ants every ${resend_search_delay}s\ntftp server path: $tftp_path\nflashed to current version: $flashed_cmd\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 ">> ${GROUP}:${PORT} >> ", dump( $data ), $/;
        } elsif( ! $quiet ) {
                $data =~ s/\s+/ /gi;
                warn ">> ", substr($data,0,70), $/;
        }
}

my $ant_passwd;
my $ant_unknown_password;
my $ant_ok_password;
my $ant_flashing;

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);
}

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 );
        return 0 if $ant_ok_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);
}

my $status = '';

sub status {
        my $m = join('', @_);
        if ($m ne $status) {
                print $m;
                $status = $m;
        }
}

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( $data, $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 = $1 if (defined $h->{'SEQ-NR'} && $h->{'SEQ-NR'} =~ m/^-*(\d)+/);
                #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}++;
                                print "$ant credentials $user_id $user_pwd\n" if ( $credentials && $ant_ok_password->{$ant} == 1 ) || $debug;
                        }

                        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");
                                        $ant_flashing->{$ant}++;
                                } else {
                                        once "$ant OK version $build",
                                                $ant_unknown_password->{$ant} ? ' with unknown password' :
                                                $ant_passwd->{$ant} ? ' password protected' :
                                                '',
                                                "\n";

                                        $ant_flashing->{$ant} = 0;
                                        # green|red|orange|flash|off
                                        mdap_send("EXEC-CLI MDAP/$mdap_ver\r\nCLI-CMD:$flashed_cmd\r\nSEQ-NR:1\r\nTO-ANT:$ant\r\nUSER-ID:$user_id\r\nUSER-PWD:$user_pwd\r\n");
                                        my $waiting = 0;
                                        my $count = 0;
                                        map {
                                                $waiting++ if ($ant_flashing->{$_});
                                                $count++;
                                        } keys %$ant_flashing;
                                        if ($waiting == 0) {
                                                status "ALL $count ANTS FLASHED to $build\n";
                                                $ant_flashing = undef;
                                        } else {
                                                status "$waiting of $count ants still flasing upto $build\n";
                                        }
                                }
                        } else {
                                once "!! NO FIRMWARE for $board in $tftp_path for ant $ant, skipping update\n";
                        }

                        if ( $plugins ) {
                                foreach my $plugin ( MDAP->plugins ) {
                                        warn "## calling $plugin\n" if $debug;
                                        if ( my $command = $plugin->check( $h ) ) {
                                                warn "## plugin $plugin sending $command to $ant\n";
                                                mdap_send("EXEC-CLI MDAP/$mdap_ver\r\nCLI-CMD:$command\r\nSEQ-NR:1\r\nTO-ANT:$ant\r\nUSER-ID:$user_id\r\nUSER-PWD:$user_pwd\r\n");              }
                                }
                        }

                } elsif ( $type eq 'REPLY-EXEC-CLI' ) {
                        print "+ $type\n$data\n" if ($verbose);
                        if ( $seq_nr == 1 ) {
                                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 ) if ( $ant_flashing->{$ant} );
                        } elsif ( $seq_nr < 0 ) {
                                warn "EXEC-CLI failed\n";
                        }

                } else {
                        print "!! reply $type ignored ", dump( $h ), $/;
                }

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