2002-02-25 15:08:51 +01:00
|
|
|
#!/usr/bin/env perl
|
2000-11-14 11:28:25 +01:00
|
|
|
# $Id$
|
2000-11-13 17:06:16 +01:00
|
|
|
#
|
|
|
|
# Main curl test script, in perl to run on more platforms
|
|
|
|
#
|
|
|
|
#######################################################################
|
|
|
|
# These should be the only variables that might be needed to get edited:
|
|
|
|
|
2002-05-22 00:39:09 +02:00
|
|
|
use strict;
|
2002-05-22 00:20:52 +02:00
|
|
|
#use warnings;
|
2000-11-15 08:09:37 +01:00
|
|
|
|
2001-05-14 14:09:47 +02:00
|
|
|
@INC=(@INC, $ENV{'srcdir'}, ".");
|
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
require "stunnel.pm"; # stunnel functions
|
|
|
|
require "getpart.pm"; # array functions
|
2001-04-24 23:09:53 +02:00
|
|
|
|
2001-01-08 23:18:30 +01:00
|
|
|
my $srcdir = $ENV{'srcdir'} || '.';
|
2000-11-15 08:09:37 +01:00
|
|
|
my $HOSTIP="127.0.0.1";
|
2000-11-21 16:48:40 +01:00
|
|
|
my $HOSTPORT=8999; # bad name, but this is the HTTP server port
|
2001-04-24 23:09:53 +02:00
|
|
|
my $HTTPSPORT=8433; # this is the HTTPS server port
|
2000-11-21 16:48:40 +01:00
|
|
|
my $FTPPORT=8921; # this is the FTP server port
|
2001-04-24 23:09:53 +02:00
|
|
|
my $FTPSPORT=8821; # this is the FTPS server port
|
2000-11-21 18:07:16 +01:00
|
|
|
my $CURL="../src/curl"; # what curl executable to run on the tests
|
2002-05-22 00:20:52 +02:00
|
|
|
my $DBGCURL=$CURL; #"../src/.libs/curl"; # alternative for debugging
|
2000-11-15 08:09:37 +01:00
|
|
|
my $LOGDIR="log";
|
|
|
|
my $TESTDIR="data";
|
2002-12-12 13:20:06 +01:00
|
|
|
my $LIBDIR="./libtest";
|
2002-02-25 13:14:24 +01:00
|
|
|
my $SERVERIN="$LOGDIR/server.input"; # what curl sent the server
|
2000-11-21 18:07:16 +01:00
|
|
|
my $CURLLOG="$LOGDIR/curl.log"; # all command lines run
|
2000-11-27 13:53:50 +01:00
|
|
|
my $FTPDCMD="$LOGDIR/ftpserver.cmd"; # copy ftp server instructions here
|
2000-11-13 17:06:16 +01:00
|
|
|
|
|
|
|
# Normally, all test cases should be run, but at times it is handy to
|
|
|
|
# simply run a particular one:
|
2000-11-15 08:09:37 +01:00
|
|
|
my $TESTCASES="all";
|
2000-11-13 17:06:16 +01:00
|
|
|
|
|
|
|
# To run specific test cases, set them like:
|
|
|
|
# $TESTCASES="1 2 3 7 8";
|
|
|
|
|
|
|
|
#######################################################################
|
|
|
|
# No variables below this point should need to be modified
|
|
|
|
#
|
|
|
|
|
2001-05-14 14:09:47 +02:00
|
|
|
my $HTTPPIDFILE=".http.pid";
|
2001-04-24 23:09:53 +02:00
|
|
|
my $HTTPSPIDFILE=".https.pid";
|
2001-05-14 14:09:47 +02:00
|
|
|
my $FTPPIDFILE=".ftp.pid";
|
|
|
|
my $FTPSPIDFILE=".ftps.pid";
|
2000-11-15 08:09:37 +01:00
|
|
|
|
2001-05-28 17:26:15 +02:00
|
|
|
# invoke perl like this:
|
|
|
|
my $perl="perl -I$srcdir";
|
|
|
|
|
2000-11-17 16:07:29 +01:00
|
|
|
# this gets set if curl is compiled with memory debugging:
|
|
|
|
my $memory_debug=0;
|
|
|
|
|
2002-05-22 00:20:52 +02:00
|
|
|
# this gets set if curl is compiled with netrc debugging:
|
|
|
|
# It has to be in the global symbol table because of the way 'requires' works
|
|
|
|
$main::netrc_debug=0;
|
|
|
|
my $netrc_debug = \$main::netrc_debug;
|
|
|
|
|
2000-11-17 16:07:29 +01:00
|
|
|
# name of the file that the memory debugging creates:
|
|
|
|
my $memdump="memdump";
|
|
|
|
|
|
|
|
# the path to the script that analyzes the memory debug output file:
|
2002-03-01 10:20:03 +01:00
|
|
|
my $memanalyze="./memanalyze.pl";
|
2000-11-17 16:07:29 +01:00
|
|
|
|
2001-04-24 23:09:53 +02:00
|
|
|
my $checkstunnel = &checkstunnel;
|
|
|
|
|
2001-05-21 15:38:38 +02:00
|
|
|
my $ssl_version; # set if libcurl is built with SSL support
|
|
|
|
|
2003-03-15 17:43:58 +01:00
|
|
|
my $skipped=0; # number of tests skipped; reported in main loop
|
|
|
|
my $problems=0; # number of tests that didn't run due to run-time problems
|
2002-05-22 00:20:52 +02:00
|
|
|
|
2000-11-15 08:09:37 +01:00
|
|
|
#######################################################################
|
|
|
|
# variables the command line options may set
|
|
|
|
#
|
|
|
|
|
|
|
|
my $short;
|
|
|
|
my $verbose;
|
2001-01-27 19:50:54 +01:00
|
|
|
my $debugprotocol;
|
2000-11-17 16:15:48 +01:00
|
|
|
my $anyway;
|
2001-05-04 09:47:11 +02:00
|
|
|
my $gdbthis; # run test case with gdb debugger
|
|
|
|
my $keepoutfiles; # keep stdout and stderr files after tests
|
2002-01-04 14:20:17 +01:00
|
|
|
my $listonly; # only list the tests
|
|
|
|
|
2001-08-06 14:10:00 +02:00
|
|
|
my $pwd; # current working directory
|
|
|
|
|
2003-04-01 10:41:49 +02:00
|
|
|
my %run; # running server
|
|
|
|
|
2001-08-06 14:10:00 +02:00
|
|
|
chomp($pwd = `pwd`);
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2002-02-28 13:36:25 +01:00
|
|
|
# enable memory debugging if curl is compiled with it
|
|
|
|
$ENV{'CURL_MEMDEBUG'} = 1;
|
2002-04-09 16:28:16 +02:00
|
|
|
$ENV{'HOME'}=$pwd;
|
2002-02-28 13:36:25 +01:00
|
|
|
|
2000-11-14 11:18:44 +01:00
|
|
|
#######################################################################
|
2000-11-21 16:48:40 +01:00
|
|
|
# Return the pid of the server as found in the given pid file
|
2000-11-14 11:18:44 +01:00
|
|
|
#
|
|
|
|
sub serverpid {
|
2000-11-21 16:48:40 +01:00
|
|
|
my $PIDFILE = $_[0];
|
2000-11-14 11:18:44 +01:00
|
|
|
open(PFILE, "<$PIDFILE");
|
2003-03-15 17:43:58 +01:00
|
|
|
my $PID=0+<PFILE>;
|
2000-11-14 11:18:44 +01:00
|
|
|
close(PFILE);
|
|
|
|
return $PID;
|
|
|
|
}
|
|
|
|
|
|
|
|
#######################################################################
|
2000-11-21 16:48:40 +01:00
|
|
|
# stop the given test server
|
2000-11-14 11:18:44 +01:00
|
|
|
#
|
2000-11-13 17:06:16 +01:00
|
|
|
sub stopserver {
|
2000-11-21 16:48:40 +01:00
|
|
|
my $PIDFILE = $_[0];
|
2000-11-13 17:06:16 +01:00
|
|
|
# check for pidfile
|
|
|
|
if ( -f $PIDFILE ) {
|
2000-11-21 16:48:40 +01:00
|
|
|
my $PID = serverpid($PIDFILE);
|
|
|
|
|
2000-11-15 08:09:37 +01:00
|
|
|
my $res = kill (9, $PID); # die!
|
2000-11-13 17:06:16 +01:00
|
|
|
unlink $PIDFILE; # server is killed
|
2000-11-14 11:18:44 +01:00
|
|
|
|
2000-11-17 16:15:48 +01:00
|
|
|
if($res && $verbose) {
|
2003-03-15 17:43:58 +01:00
|
|
|
print "RUN: Test server pid $PID signalled to die\n";
|
2000-11-21 16:48:40 +01:00
|
|
|
}
|
|
|
|
elsif($verbose) {
|
2003-03-15 17:43:58 +01:00
|
|
|
print "RUN: Test server pid $PID didn't exist\n";
|
2000-11-14 11:18:44 +01:00
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-11-14 11:18:44 +01:00
|
|
|
#######################################################################
|
2001-04-24 23:09:53 +02:00
|
|
|
# check the given test server if it is still alive
|
2000-11-14 11:18:44 +01:00
|
|
|
#
|
2001-04-24 23:09:53 +02:00
|
|
|
sub checkserver {
|
|
|
|
my ($pidfile)=@_;
|
|
|
|
my $RUNNING=0;
|
|
|
|
my $PID=0;
|
|
|
|
|
2000-11-13 17:06:16 +01:00
|
|
|
# check for pidfile
|
2001-04-24 23:09:53 +02:00
|
|
|
if ( -f $pidfile ) {
|
2001-10-11 00:04:42 +02:00
|
|
|
$PID=serverpid($pidfile);
|
2000-11-13 17:06:16 +01:00
|
|
|
if ($PID ne "" && kill(0, $PID)) {
|
|
|
|
$RUNNING=1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$RUNNING=0;
|
2001-04-24 23:09:53 +02:00
|
|
|
$PID = -$PID; # negative means dead process
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$RUNNING=0;
|
|
|
|
}
|
2001-04-24 23:09:53 +02:00
|
|
|
return $PID
|
|
|
|
}
|
|
|
|
|
|
|
|
#######################################################################
|
|
|
|
# start the http server, or if it already runs, verify that it is our
|
|
|
|
# test server on the test-port!
|
|
|
|
#
|
|
|
|
sub runhttpserver {
|
|
|
|
my $verbose = $_[0];
|
|
|
|
my $RUNNING;
|
2001-10-17 13:51:02 +02:00
|
|
|
my $pid;
|
2001-04-24 23:09:53 +02:00
|
|
|
|
2002-02-25 13:45:20 +01:00
|
|
|
$pid = checkserver ($HTTPPIDFILE);
|
|
|
|
|
2001-10-17 13:51:02 +02:00
|
|
|
# verify if our/any server is running on this port
|
2003-03-15 17:43:58 +01:00
|
|
|
my $cmd = "$CURL -o log/verifiedserver --silent -i $HOSTIP:$HOSTPORT/verifiedserver 2>/dev/null";
|
2003-03-15 18:26:59 +01:00
|
|
|
print "CMD; $cmd\n" if ($verbose);
|
2003-03-15 17:43:58 +01:00
|
|
|
my $res = system($cmd);
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2003-03-15 17:43:58 +01:00
|
|
|
$res >>= 8; # rotate the result
|
|
|
|
my $data;
|
2002-02-22 16:40:17 +01:00
|
|
|
|
2003-03-15 17:43:58 +01:00
|
|
|
print "RUN: curl command returned $res\n" if ($verbose);
|
2002-02-22 16:40:17 +01:00
|
|
|
|
2003-03-15 17:43:58 +01:00
|
|
|
open(FILE, "<log/verifiedserver");
|
|
|
|
my @file=<FILE>;
|
|
|
|
close(FILE);
|
|
|
|
$data=$file[0]; # first line
|
|
|
|
|
|
|
|
if ( $data =~ /WE ROOLZ: (\d+)/ ) {
|
|
|
|
$pid = 0+$1;
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
2003-03-15 17:43:58 +01:00
|
|
|
elsif($data) {
|
|
|
|
print "RUN: Unknown HTTP server is running on port $HOSTPORT\n";
|
|
|
|
return 2;
|
2001-10-17 13:51:02 +02:00
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2002-02-28 13:36:25 +01:00
|
|
|
if($pid > 0) {
|
2001-10-17 13:51:02 +02:00
|
|
|
my $res = kill (9, $pid); # die!
|
|
|
|
if(!$res) {
|
2003-03-15 17:43:58 +01:00
|
|
|
print "RUN: Failed to kill test HTTP server, do it manually and",
|
2001-10-17 13:51:02 +02:00
|
|
|
" restart the tests.\n";
|
2000-11-13 17:06:16 +01:00
|
|
|
exit;
|
|
|
|
}
|
2003-03-15 17:43:58 +01:00
|
|
|
sleep(1);
|
2001-10-17 13:51:02 +02:00
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2001-10-17 13:51:02 +02:00
|
|
|
my $flag=$debugprotocol?"-v ":"";
|
|
|
|
my $cmd="$perl $srcdir/httpserver.pl $flag $HOSTPORT &";
|
|
|
|
system($cmd);
|
|
|
|
if($verbose) {
|
|
|
|
print "CMD: $cmd\n";
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
2001-10-17 13:51:02 +02:00
|
|
|
|
2003-03-15 17:43:58 +01:00
|
|
|
my $verified;
|
|
|
|
for(1 .. 5) {
|
|
|
|
# verify that our server is up and running:
|
|
|
|
my $data=`$CURL --silent -i $HOSTIP:$HOSTPORT/verifiedserver 2>/dev/null`;
|
|
|
|
|
2003-04-01 10:41:49 +02:00
|
|
|
if ( $data !~ /WE ROOLZ: (\d+)/ ) {
|
2003-03-15 17:43:58 +01:00
|
|
|
sleep(1);
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$verified = 1;
|
|
|
|
last;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(!$verified) {
|
|
|
|
print STDERR "RUN: failed to start our HTTP server\n";
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if($verbose) {
|
|
|
|
print "RUN: HTTP server is now verified to be our server\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
|
|
|
|
2001-04-24 23:09:53 +02:00
|
|
|
#######################################################################
|
|
|
|
# start the https server (or rather, tunnel) if needed
|
|
|
|
#
|
|
|
|
sub runhttpsserver {
|
2000-11-21 16:48:40 +01:00
|
|
|
my $verbose = $_[0];
|
|
|
|
my $STATUS;
|
|
|
|
my $RUNNING;
|
2001-04-24 23:09:53 +02:00
|
|
|
my $PID=checkserver($HTTPSPIDFILE );
|
|
|
|
|
|
|
|
if($PID > 0) {
|
|
|
|
# kill previous stunnel!
|
|
|
|
if($verbose) {
|
2003-03-15 17:43:58 +01:00
|
|
|
print "RUN: kills off running stunnel at $PID\n";
|
2000-11-21 16:48:40 +01:00
|
|
|
}
|
2001-04-24 23:09:53 +02:00
|
|
|
stopserver($HTTPSPIDFILE);
|
2000-11-21 16:48:40 +01:00
|
|
|
}
|
2001-04-24 23:09:53 +02:00
|
|
|
|
|
|
|
my $flag=$debugprotocol?"-v ":"";
|
2003-01-21 11:14:25 +01:00
|
|
|
my $cmd="$perl $srcdir/httpsserver.pl $flag -d $srcdir -r $HOSTPORT $HTTPSPORT &";
|
2001-05-28 17:26:15 +02:00
|
|
|
system($cmd);
|
2001-04-24 23:09:53 +02:00
|
|
|
if($verbose) {
|
2001-05-28 17:26:15 +02:00
|
|
|
print "CMD: $cmd\n";
|
2000-11-21 16:48:40 +01:00
|
|
|
}
|
2003-03-15 17:43:58 +01:00
|
|
|
sleep(1);
|
2001-04-24 23:09:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#######################################################################
|
|
|
|
# start the ftp server if needed
|
|
|
|
#
|
|
|
|
sub runftpserver {
|
|
|
|
my $verbose = $_[0];
|
|
|
|
my $STATUS;
|
|
|
|
my $RUNNING;
|
|
|
|
# check for pidfile
|
|
|
|
my $pid = checkserver ($FTPPIDFILE );
|
2000-11-21 16:48:40 +01:00
|
|
|
|
2001-04-24 23:09:53 +02:00
|
|
|
if ($pid <= 0) {
|
2003-03-15 17:43:58 +01:00
|
|
|
print "RUN: Check port $FTPPORT for our own FTP server\n"
|
|
|
|
if ($verbose);
|
2001-05-14 14:09:47 +02:00
|
|
|
|
|
|
|
|
2003-03-15 17:43:58 +01:00
|
|
|
my $time=time();
|
|
|
|
# check if this is our server running on this port:
|
|
|
|
my $data=`$CURL -m4 --silent -i ftp://$HOSTIP:$FTPPORT/verifiedserver 2>/dev/null`;
|
2001-05-14 14:09:47 +02:00
|
|
|
|
2003-03-15 17:43:58 +01:00
|
|
|
# if this took more than 2 secs, we assume it "hung" on a weird server
|
|
|
|
my $took = time()-$time;
|
|
|
|
|
|
|
|
if ( $data =~ /WE ROOLZ: (\d+)/ ) {
|
|
|
|
# this is our test server with a known pid!
|
|
|
|
$pid = $1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if($data || ($took > 2)) {
|
|
|
|
# this is not a known server
|
|
|
|
print "RUN: Unknown server on our favourite port: $FTPPORT\n";
|
|
|
|
return 1;
|
|
|
|
}
|
2001-04-24 23:09:53 +02:00
|
|
|
}
|
2000-11-21 16:48:40 +01:00
|
|
|
}
|
2003-03-15 17:43:58 +01:00
|
|
|
|
|
|
|
if($pid > 0) {
|
|
|
|
print "RUN: Killing a previous server using pid $pid\n" if($verbose);
|
|
|
|
my $res = kill (9, $pid); # die!
|
|
|
|
if(!$res) {
|
|
|
|
print "RUN: Failed to kill our FTP test server, do it manually and",
|
|
|
|
" restart the tests.\n";
|
|
|
|
exit;
|
2001-04-24 23:09:53 +02:00
|
|
|
}
|
2003-03-15 17:43:58 +01:00
|
|
|
sleep(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
# now (re-)start our server:
|
|
|
|
my $flag=$debugprotocol?"-v ":"";
|
|
|
|
my $cmd="$perl $srcdir/ftpserver.pl $flag $FTPPORT &";
|
|
|
|
if($verbose) {
|
|
|
|
print "CMD: $cmd\n";
|
|
|
|
}
|
|
|
|
system($cmd);
|
2000-11-21 16:48:40 +01:00
|
|
|
|
2003-03-15 17:43:58 +01:00
|
|
|
my $verified;
|
|
|
|
for(1 .. 5) {
|
|
|
|
# verify that our server is up and running:
|
2002-08-12 11:41:56 +02:00
|
|
|
my $data=`$CURL --silent -i ftp://$HOSTIP:$FTPPORT/verifiedserver 2>/dev/null`;
|
2000-11-21 16:48:40 +01:00
|
|
|
|
2003-04-01 10:41:49 +02:00
|
|
|
if ( $data !~ /WE ROOLZ: (\d+)/ ) {
|
|
|
|
if($verbose) {
|
|
|
|
print STDERR "RUN: Retrying FTP server existance in 1 sec\n";
|
|
|
|
}
|
2003-03-15 17:43:58 +01:00
|
|
|
sleep(1);
|
|
|
|
next;
|
2000-11-21 16:48:40 +01:00
|
|
|
}
|
2003-03-15 17:43:58 +01:00
|
|
|
else {
|
|
|
|
$verified = 1;
|
|
|
|
last;
|
2001-04-24 23:09:53 +02:00
|
|
|
}
|
|
|
|
}
|
2003-03-15 17:43:58 +01:00
|
|
|
if(!$verified) {
|
|
|
|
die "RUN: failed to start our FTP server\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
if($verbose) {
|
|
|
|
print "RUN: FTP server is now verified to be our server\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2001-04-24 23:09:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#######################################################################
|
|
|
|
# start the ftps server (or rather, tunnel) if needed
|
|
|
|
#
|
|
|
|
sub runftpsserver {
|
|
|
|
my $verbose = $_[0];
|
|
|
|
my $STATUS;
|
|
|
|
my $RUNNING;
|
|
|
|
my $PID=checkserver($FTPSPIDFILE );
|
|
|
|
|
|
|
|
if($PID > 0) {
|
|
|
|
# kill previous stunnel!
|
|
|
|
if($verbose) {
|
|
|
|
print "kills off running stunnel at $PID\n";
|
|
|
|
}
|
|
|
|
stopserver($FTPSPIDFILE);
|
|
|
|
}
|
|
|
|
|
|
|
|
my $flag=$debugprotocol?"-v ":"";
|
2003-01-21 11:29:06 +01:00
|
|
|
my $cmd="$perl $srcdir/ftpsserver.pl $flag -d $srcdir -r $FTPPORT $FTPSPORT &";
|
2001-04-24 23:09:53 +02:00
|
|
|
system($cmd);
|
|
|
|
if($verbose) {
|
2001-05-28 17:26:15 +02:00
|
|
|
print "CMD: $cmd\n";
|
2000-11-21 16:48:40 +01:00
|
|
|
}
|
2003-03-15 17:43:58 +01:00
|
|
|
sleep(1);
|
2000-11-21 16:48:40 +01:00
|
|
|
}
|
|
|
|
|
2000-11-14 11:18:44 +01:00
|
|
|
#######################################################################
|
|
|
|
# Remove all files in the specified directory
|
|
|
|
#
|
|
|
|
sub cleardir {
|
|
|
|
my $dir = $_[0];
|
|
|
|
my $count;
|
2000-11-15 08:09:37 +01:00
|
|
|
my $file;
|
2000-11-14 11:18:44 +01:00
|
|
|
|
|
|
|
# Get all files
|
|
|
|
opendir(DIR, $dir) ||
|
|
|
|
return 0; # can't open dir
|
|
|
|
while($file = readdir(DIR)) {
|
|
|
|
if($file !~ /^\./) {
|
|
|
|
unlink("$dir/$file");
|
|
|
|
$count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
closedir DIR;
|
|
|
|
return $count;
|
|
|
|
}
|
|
|
|
|
|
|
|
#######################################################################
|
|
|
|
# filter out the specified pattern from the given input file and store the
|
|
|
|
# results in the given output file
|
|
|
|
#
|
2000-11-13 17:06:16 +01:00
|
|
|
sub filteroff {
|
|
|
|
my $infile=$_[0];
|
|
|
|
my $filter=$_[1];
|
|
|
|
my $ofile=$_[2];
|
|
|
|
|
|
|
|
open(IN, "<$infile")
|
|
|
|
|| return 1;
|
|
|
|
|
|
|
|
open(OUT, ">$ofile")
|
|
|
|
|| return 1;
|
|
|
|
|
|
|
|
# print "FILTER: off $filter from $infile to $ofile\n";
|
|
|
|
|
|
|
|
while(<IN>) {
|
|
|
|
$_ =~ s/$filter//;
|
|
|
|
print OUT $_;
|
|
|
|
}
|
|
|
|
close(IN);
|
|
|
|
close(OUT);
|
|
|
|
return 0;
|
|
|
|
}
|
2000-11-14 11:18:44 +01:00
|
|
|
|
|
|
|
#######################################################################
|
|
|
|
# compare test results with the expected output, we might filter off
|
|
|
|
# some pattern that is allowed to differ, output test results
|
|
|
|
#
|
|
|
|
|
2000-11-13 17:06:16 +01:00
|
|
|
sub compare {
|
2001-05-28 17:26:15 +02:00
|
|
|
# filter off patterns _before_ this comparison!
|
2003-04-30 19:15:38 +02:00
|
|
|
my ($subject, $firstref, $secondref)=@_;
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
my $result = compareparts($firstref, $secondref);
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2003-04-30 19:15:38 +02:00
|
|
|
if($result) {
|
|
|
|
if(!$short) {
|
|
|
|
print "\n $subject FAILED:\n";
|
|
|
|
print showdiff($firstref, $secondref);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
print "FAILED\n";
|
|
|
|
}
|
2000-11-17 16:15:48 +01:00
|
|
|
}
|
2001-05-23 17:02:58 +02:00
|
|
|
return $result;
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
|
|
|
|
2000-11-14 11:18:44 +01:00
|
|
|
#######################################################################
|
|
|
|
# display information about curl and the host the test suite runs on
|
|
|
|
#
|
2000-11-13 17:06:16 +01:00
|
|
|
sub displaydata {
|
2000-11-17 16:07:29 +01:00
|
|
|
|
|
|
|
unlink($memdump); # remove this if there was one left
|
|
|
|
|
2000-11-13 17:06:16 +01:00
|
|
|
my $version=`$CURL -V`;
|
2001-04-26 10:32:12 +02:00
|
|
|
chomp $version;
|
|
|
|
|
|
|
|
my $curl = $version;
|
|
|
|
|
|
|
|
$curl =~ s/^(.*)(libcurl.*)/$1/g;
|
|
|
|
my $libcurl = $2;
|
|
|
|
|
2000-11-13 17:06:16 +01:00
|
|
|
my $hostname=`hostname`;
|
|
|
|
my $hosttype=`uname -a`;
|
|
|
|
|
2001-04-24 23:09:53 +02:00
|
|
|
print "********* System characteristics ******** \n",
|
2001-04-26 10:32:12 +02:00
|
|
|
"* $curl\n",
|
|
|
|
"* $libcurl\n",
|
2000-11-17 16:15:48 +01:00
|
|
|
"* Host: $hostname",
|
|
|
|
"* System: $hosttype";
|
2000-11-17 16:07:29 +01:00
|
|
|
|
2001-05-21 15:38:38 +02:00
|
|
|
if($libcurl =~ /SSL/i) {
|
|
|
|
$ssl_version=1;
|
|
|
|
}
|
|
|
|
|
2000-11-17 16:07:29 +01:00
|
|
|
if( -r $memdump) {
|
|
|
|
# if this exists, curl was compiled with memory debugging
|
|
|
|
# enabled and we shall verify that no memory leaks exist
|
|
|
|
# after each and every test!
|
|
|
|
$memory_debug=1;
|
2002-05-22 00:20:52 +02:00
|
|
|
|
|
|
|
# there's only one debug control in the configure script
|
|
|
|
# so hope netrc debugging is enabled and set it up
|
|
|
|
$$netrc_debug = 1;
|
|
|
|
$ENV{'CURL_DEBUG_NETRC'} = 'log/netrc';
|
2000-11-17 16:07:29 +01:00
|
|
|
}
|
2000-11-17 16:15:48 +01:00
|
|
|
printf("* Memory debugging: %s\n", $memory_debug?"ON":"OFF");
|
2002-05-22 00:20:52 +02:00
|
|
|
printf("* Netrc debugging: %s\n", $$netrc_debug?"ON":"OFF");
|
2001-04-24 23:09:53 +02:00
|
|
|
printf("* HTTPS server: %s\n", $checkstunnel?"ON":"OFF");
|
|
|
|
printf("* FTPS server: %s\n", $checkstunnel?"ON":"OFF");
|
2001-05-21 15:38:38 +02:00
|
|
|
printf("* libcurl SSL: %s\n", $ssl_version?"ON":"OFF");
|
2001-04-24 23:09:53 +02:00
|
|
|
print "***************************************** \n";
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
|
|
|
|
2002-05-22 00:20:52 +02:00
|
|
|
#######################################################################
|
|
|
|
# substitute the variable stuff into either a joined up file or
|
|
|
|
# a command, in either case passed by reference
|
|
|
|
#
|
|
|
|
sub subVariables {
|
|
|
|
my ($thing) = @_;
|
|
|
|
$$thing =~ s/%HOSTIP/$HOSTIP/g;
|
|
|
|
$$thing =~ s/%HOSTPORT/$HOSTPORT/g;
|
|
|
|
$$thing =~ s/%HTTPSPORT/$HTTPSPORT/g;
|
|
|
|
$$thing =~ s/%FTPPORT/$FTPPORT/g;
|
|
|
|
$$thing =~ s/%FTPSPORT/$FTPSPORT/g;
|
|
|
|
$$thing =~ s/%SRCDIR/$srcdir/g;
|
|
|
|
$$thing =~ s/%PWD/$pwd/g;
|
|
|
|
}
|
|
|
|
|
2000-11-14 11:18:44 +01:00
|
|
|
#######################################################################
|
|
|
|
# Run a single specified test case
|
|
|
|
#
|
|
|
|
|
2000-11-13 17:06:16 +01:00
|
|
|
sub singletest {
|
2001-05-23 17:02:58 +02:00
|
|
|
my $testnum=$_[0];
|
|
|
|
|
|
|
|
# load the test case file definition
|
|
|
|
if(loadtest("${TESTDIR}/test${testnum}")) {
|
|
|
|
if($verbose) {
|
|
|
|
# this is not a test
|
2003-03-15 17:43:58 +01:00
|
|
|
print "RUN: $testnum doesn't look like a test case!\n";
|
2001-05-23 17:02:58 +02:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2003-01-27 14:51:35 +01:00
|
|
|
my $serverproblem = serverfortest($testnum);
|
|
|
|
|
|
|
|
if($serverproblem) {
|
|
|
|
# there's a problem with the server, don't run
|
|
|
|
# this particular server, but count it as "skipped"
|
2003-03-15 17:43:58 +01:00
|
|
|
if($serverproblem> 1) {
|
|
|
|
print "RUN: test case $testnum couldn't run!\n";
|
|
|
|
$problems++;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$skipped++;
|
|
|
|
}
|
2003-01-27 14:51:35 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2002-05-22 00:20:52 +02:00
|
|
|
{
|
|
|
|
my %hash = getpartattr("client");
|
|
|
|
my $requires = $hash{'requires'};
|
|
|
|
|
|
|
|
if (defined($requires)) {
|
2002-05-22 00:39:09 +02:00
|
|
|
no strict "refs";
|
2002-05-22 00:20:52 +02:00
|
|
|
my $value=${$requires};
|
|
|
|
# print "This test requires '$requires' with value '$value' \n";
|
|
|
|
|
|
|
|
if (${$requires}) {
|
|
|
|
# this test is OK
|
|
|
|
;
|
|
|
|
}else {
|
|
|
|
print "$testnum requires $requires, which is not set; skipping\n";
|
|
|
|
$skipped++;
|
2003-01-27 14:51:35 +01:00
|
|
|
return -1; # return test-not-run
|
2002-05-22 00:20:52 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
# extract the reply data
|
|
|
|
my @reply = getpart("reply", "data");
|
|
|
|
my @replycheck = getpart("reply", "datacheck");
|
|
|
|
|
|
|
|
if (@replycheck) {
|
2000-11-13 17:06:16 +01:00
|
|
|
# we use this file instead to check the final output against
|
2002-06-11 17:11:41 +02:00
|
|
|
|
|
|
|
my %hash = getpartattr("reply", "datacheck");
|
|
|
|
if($hash{'nonewline'}) {
|
|
|
|
# Yes, we must cut off the final newline from the final line
|
|
|
|
# of the datacheck
|
|
|
|
chomp($replycheck[$#replycheck]);
|
|
|
|
}
|
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
@reply=@replycheck;
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
# curl command to run
|
2001-05-23 17:02:58 +02:00
|
|
|
my @curlcmd= getpart("client", "command");
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
# this is the valid protocol blurb curl should generate
|
|
|
|
my @protocol= getpart("verify", "protocol");
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
# redirected stdout/stderr to these files
|
|
|
|
$STDOUT="$LOGDIR/stdout$testnum";
|
|
|
|
$STDERR="$LOGDIR/stderr$testnum";
|
2000-11-21 20:28:11 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
# if this section exists, we verify that the stdout contained this:
|
|
|
|
my @validstdout = getpart("verify", "stdout");
|
2000-11-21 20:28:11 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
# if this section exists, we verify upload
|
|
|
|
my @upload = getpart("verify", "upload");
|
2000-11-21 20:28:11 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
# if this section exists, it is FTP server instructions:
|
|
|
|
my @ftpservercmd = getpart("server", "instruction");
|
2000-11-27 13:53:50 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
my $CURLOUT="$LOGDIR/curl$testnum.out"; # curl output if not stdout
|
2000-11-21 20:28:11 +01:00
|
|
|
|
2000-11-13 17:06:16 +01:00
|
|
|
# name of the test
|
2001-05-23 17:02:58 +02:00
|
|
|
my @testname= getpart("client", "name");
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2002-11-06 09:29:48 +01:00
|
|
|
printf("test %03d...", $testnum);
|
2000-11-14 11:18:44 +01:00
|
|
|
if(!$short) {
|
2001-05-23 17:02:58 +02:00
|
|
|
my $name = $testname[0];
|
|
|
|
$name =~ s/\n//g;
|
|
|
|
print "[$name]\n";
|
2000-11-14 11:18:44 +01:00
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2002-01-04 14:20:17 +01:00
|
|
|
if($listonly) {
|
|
|
|
return 0; # look successful
|
|
|
|
}
|
|
|
|
|
2002-12-12 13:20:06 +01:00
|
|
|
my @codepieces = getpart("client", "tool");
|
|
|
|
|
|
|
|
my $tool="";
|
|
|
|
if(@codepieces) {
|
|
|
|
$tool = $codepieces[0];
|
|
|
|
chomp $tool;
|
|
|
|
}
|
|
|
|
|
2002-01-04 14:20:17 +01:00
|
|
|
# remove previous server output logfile
|
|
|
|
unlink($SERVERIN);
|
|
|
|
|
|
|
|
if(@ftpservercmd) {
|
|
|
|
# write the instructions to file
|
|
|
|
writearray($FTPDCMD, \@ftpservercmd);
|
|
|
|
}
|
|
|
|
|
2000-11-13 17:06:16 +01:00
|
|
|
# get the command line options to use
|
2001-05-23 17:02:58 +02:00
|
|
|
my ($cmd, @blaha)= getpart("client", "command");
|
2000-11-13 17:06:16 +01:00
|
|
|
|
|
|
|
# make some nice replace operations
|
2001-05-23 17:02:58 +02:00
|
|
|
$cmd =~ s/\n//g; # no newlines please
|
2002-05-22 00:20:52 +02:00
|
|
|
|
|
|
|
subVariables \$cmd;
|
|
|
|
|
|
|
|
# $cmd =~ s/%HOSTIP/$HOSTIP/g;
|
|
|
|
# $cmd =~ s/%HOSTPORT/$HOSTPORT/g;
|
|
|
|
# $cmd =~ s/%HTTPSPORT/$HTTPSPORT/g;
|
|
|
|
# $cmd =~ s/%FTPPORT/$FTPPORT/g;
|
|
|
|
# $cmd =~ s/%FTPSPORT/$FTPSPORT/g;
|
|
|
|
# $cmd =~ s/%SRCDIR/$srcdir/g;
|
|
|
|
# $cmd =~ s/%PWD/$pwd/g;
|
2001-08-06 14:10:00 +02:00
|
|
|
|
2000-11-15 08:09:37 +01:00
|
|
|
#$cmd =~ s/%HOSTNAME/$HOSTNAME/g;
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2000-11-17 16:07:29 +01:00
|
|
|
if($memory_debug) {
|
|
|
|
unlink($memdump);
|
|
|
|
}
|
|
|
|
|
2001-05-28 17:26:15 +02:00
|
|
|
my @inputfile=getpart("client", "file");
|
|
|
|
if(@inputfile) {
|
|
|
|
# we need to generate a file before this test is invoked
|
|
|
|
my %hash = getpartattr("client", "file");
|
|
|
|
|
|
|
|
my $filename=$hash{'name'};
|
2002-05-22 00:20:52 +02:00
|
|
|
|
2001-05-28 17:26:15 +02:00
|
|
|
if(!$filename) {
|
|
|
|
print "ERROR: section client=>file has no name attribute!\n";
|
|
|
|
exit;
|
|
|
|
}
|
2002-05-22 00:20:52 +02:00
|
|
|
my $fileContent = join('', @inputfile);
|
|
|
|
subVariables \$fileContent;
|
|
|
|
# print "DEBUG: writing file " . $filename . "\n";
|
|
|
|
open OUTFILE, ">$filename";
|
2003-03-19 10:26:29 +01:00
|
|
|
binmode OUTFILE; # for crapage systems, use binary
|
|
|
|
print OUTFILE $fileContent;
|
2002-05-22 00:20:52 +02:00
|
|
|
close OUTFILE;
|
2001-05-28 17:26:15 +02:00
|
|
|
}
|
|
|
|
|
2002-01-08 10:32:41 +01:00
|
|
|
my %cmdhash = getpartattr("client", "command");
|
|
|
|
|
2000-11-17 16:07:29 +01:00
|
|
|
my $out="";
|
2002-01-08 10:32:41 +01:00
|
|
|
|
|
|
|
if($cmdhash{'option'} eq "no-output") {
|
|
|
|
#print "*** We don't slap on --output\n";
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (!@validstdout) {
|
2002-12-12 17:46:45 +01:00
|
|
|
$out=" --output $CURLOUT ";
|
2002-01-08 10:32:41 +01:00
|
|
|
}
|
2000-11-17 16:07:29 +01:00
|
|
|
}
|
|
|
|
|
2002-12-12 13:20:06 +01:00
|
|
|
my $cmdargs;
|
|
|
|
if(!$tool) {
|
|
|
|
# run curl, add -v for debug information output
|
2002-12-13 17:24:57 +01:00
|
|
|
$cmdargs ="$out --include -v $cmd";
|
2002-12-12 13:20:06 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
$cmdargs = " $cmd"; # $cmd is the command line for the test file
|
|
|
|
$CURLOUT = $STDOUT; # sends received data to stdout
|
|
|
|
}
|
2000-11-17 16:07:29 +01:00
|
|
|
|
2001-06-14 14:16:07 +02:00
|
|
|
my @stdintest = getpart("client", "stdin");
|
2001-05-23 17:02:58 +02:00
|
|
|
|
|
|
|
if(@stdintest) {
|
|
|
|
my $stdinfile="$LOGDIR/stdin-for-$testnum";
|
|
|
|
writearray($stdinfile, \@stdintest);
|
|
|
|
|
|
|
|
$cmdargs .= " <$stdinfile";
|
2000-11-17 16:07:29 +01:00
|
|
|
}
|
2002-12-12 13:20:06 +01:00
|
|
|
my $CMDLINE;
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2002-12-12 13:20:06 +01:00
|
|
|
if(!$tool) {
|
|
|
|
$CMDLINE="$CURL";
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
2002-12-12 13:20:06 +01:00
|
|
|
else {
|
|
|
|
$CMDLINE="$LIBDIR/$tool";
|
2002-12-12 14:42:21 +01:00
|
|
|
$DBGCURL=$CMDLINE;
|
2002-12-12 13:20:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
$CMDLINE .= "$cmdargs >$STDOUT 2>$STDERR";
|
|
|
|
|
|
|
|
if($verbose) {
|
|
|
|
print "$CMDLINE\n";
|
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2000-11-21 18:07:16 +01:00
|
|
|
print CMDLOG "$CMDLINE\n";
|
|
|
|
|
2001-02-20 14:58:39 +01:00
|
|
|
my $res;
|
2000-11-13 17:06:16 +01:00
|
|
|
# run the command line we built
|
2001-02-20 14:58:39 +01:00
|
|
|
if($gdbthis) {
|
|
|
|
open(GDBCMD, ">log/gdbcmd");
|
|
|
|
print GDBCMD "set args $cmdargs\n";
|
|
|
|
print GDBCMD "show args\n";
|
|
|
|
close(GDBCMD);
|
2002-05-22 00:20:52 +02:00
|
|
|
system("gdb $DBGCURL -x log/gdbcmd");
|
2001-02-20 14:58:39 +01:00
|
|
|
$res =0; # makes it always continue after a debugged run
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$res = system("$CMDLINE");
|
|
|
|
$res /= 256;
|
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2001-11-29 21:15:59 +01:00
|
|
|
# remove the special FTP command file after each test!
|
|
|
|
unlink($FTPDCMD);
|
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
my @err = getpart("verify", "errorcode");
|
|
|
|
my $errorcode = $err[0];
|
2000-11-17 16:58:25 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
if($errorcode || $res) {
|
|
|
|
if($errorcode == $res) {
|
2002-08-30 12:50:22 +02:00
|
|
|
$errorcode =~ s/\n//;
|
|
|
|
if($verbose) {
|
|
|
|
print " received errorcode $errorcode OK";
|
|
|
|
}
|
|
|
|
elsif(!$short) {
|
2001-05-23 17:02:58 +02:00
|
|
|
print " error OK";
|
|
|
|
}
|
2000-11-17 16:58:25 +01:00
|
|
|
}
|
2001-05-23 17:02:58 +02:00
|
|
|
else {
|
|
|
|
if(!$short) {
|
2001-08-08 09:51:00 +02:00
|
|
|
print "curl returned $res, ".(0+$errorcode)." was expected\n";
|
2001-05-23 17:02:58 +02:00
|
|
|
}
|
2001-08-06 10:43:37 +02:00
|
|
|
print " error FAILED\n";
|
2001-05-23 17:02:58 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2000-11-17 16:58:25 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
if (@validstdout) {
|
|
|
|
# verify redirected stdout
|
|
|
|
my @actual = loadarray($STDOUT);
|
2000-11-17 16:58:25 +01:00
|
|
|
|
2003-04-30 19:15:38 +02:00
|
|
|
$res = compare("stdout", \@actual, \@validstdout);
|
2001-05-23 17:02:58 +02:00
|
|
|
if($res) {
|
2000-11-17 16:58:25 +01:00
|
|
|
return 1;
|
|
|
|
}
|
2001-05-23 17:02:58 +02:00
|
|
|
if(!$short) {
|
|
|
|
print " stdout OK";
|
2000-11-17 16:58:25 +01:00
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
2001-05-23 17:02:58 +02:00
|
|
|
|
2001-06-14 14:16:07 +02:00
|
|
|
my %replyattr = getpartattr("reply", "data");
|
2002-12-12 13:20:06 +01:00
|
|
|
if(!$replyattr{'nocheck'} && @reply) {
|
2001-05-23 17:02:58 +02:00
|
|
|
# verify the received data
|
|
|
|
my @out = loadarray($CURLOUT);
|
2003-04-30 19:15:38 +02:00
|
|
|
$res = compare("data", \@out, \@reply);
|
2001-05-23 17:02:58 +02:00
|
|
|
if ($res) {
|
2000-11-17 16:58:25 +01:00
|
|
|
return 1;
|
|
|
|
}
|
2001-05-23 17:02:58 +02:00
|
|
|
if(!$short) {
|
|
|
|
print " data OK";
|
2000-11-17 16:07:29 +01:00
|
|
|
}
|
2001-05-23 17:02:58 +02:00
|
|
|
}
|
2000-11-17 16:07:29 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
if(@upload) {
|
|
|
|
# verify uploaded data
|
|
|
|
my @out = loadarray("$LOGDIR/upload.$testnum");
|
2003-04-30 19:15:38 +02:00
|
|
|
$res = compare("upload", \@out, \@upload);
|
2001-05-23 17:02:58 +02:00
|
|
|
if ($res) {
|
|
|
|
return 1;
|
2000-11-21 20:28:11 +01:00
|
|
|
}
|
2001-05-23 17:02:58 +02:00
|
|
|
if(!$short) {
|
|
|
|
print " upload OK";
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
2001-05-23 17:02:58 +02:00
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
if(@protocol) {
|
|
|
|
# verify the sent request
|
|
|
|
my @out = loadarray($SERVERIN);
|
2000-11-21 20:28:11 +01:00
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
# what to cut off from the live protocol sent by curl
|
|
|
|
my @strip = getpart("verify", "strip");
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2001-06-28 00:01:08 +02:00
|
|
|
my @protstrip=@protocol;
|
|
|
|
|
2002-02-22 11:50:36 +01:00
|
|
|
# check if there's any attributes on the verify/protocol section
|
|
|
|
my %hash = getpartattr("verify", "protocol");
|
|
|
|
|
|
|
|
if($hash{'nonewline'}) {
|
|
|
|
# Yes, we must cut off the final newline from the final line
|
|
|
|
# of the protocol data
|
|
|
|
chomp($protstrip[$#protstrip]);
|
|
|
|
}
|
|
|
|
|
2001-06-28 00:01:08 +02:00
|
|
|
for(@strip) {
|
|
|
|
# strip all patterns from both arrays
|
|
|
|
@out = striparray( $_, \@out);
|
|
|
|
@protstrip= striparray( $_, \@protstrip);
|
|
|
|
}
|
2001-05-28 17:26:15 +02:00
|
|
|
|
2003-04-30 19:15:38 +02:00
|
|
|
$res = compare("protocol", \@out, \@protstrip);
|
2001-05-23 17:02:58 +02:00
|
|
|
if($res) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if(!$short) {
|
|
|
|
print " protocol OK";
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
2000-11-17 16:58:25 +01:00
|
|
|
}
|
2000-11-27 13:53:50 +01:00
|
|
|
|
2001-05-28 17:26:15 +02:00
|
|
|
my @outfile=getpart("verify", "file");
|
|
|
|
if(@outfile) {
|
|
|
|
# we're supposed to verify a dynamicly generated file!
|
|
|
|
my %hash = getpartattr("verify", "file");
|
|
|
|
|
|
|
|
my $filename=$hash{'name'};
|
|
|
|
if(!$filename) {
|
|
|
|
print "ERROR: section verify=>file has no name attribute!\n";
|
|
|
|
exit;
|
|
|
|
}
|
|
|
|
my @generated=loadarray($filename);
|
|
|
|
|
2003-04-30 19:15:38 +02:00
|
|
|
$res = compare("output", \@generated, \@outfile);
|
2001-05-28 17:26:15 +02:00
|
|
|
if($res) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if(!$short) {
|
|
|
|
print " output OK";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-05-04 09:47:11 +02:00
|
|
|
if(!$keepoutfiles) {
|
|
|
|
# remove the stdout and stderr files
|
|
|
|
unlink($STDOUT);
|
|
|
|
unlink($STDERR);
|
|
|
|
unlink($CURLOUT); # remove the downloaded results
|
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
unlink("$LOGDIR/upload.$testnum"); # remove upload leftovers
|
2001-05-04 09:47:11 +02:00
|
|
|
}
|
2000-11-27 13:53:50 +01:00
|
|
|
|
|
|
|
unlink($FTPDCMD); # remove the instructions for this test
|
|
|
|
|
2003-04-01 10:41:49 +02:00
|
|
|
my @what = getpart("client", "killserver");
|
|
|
|
for(@what) {
|
|
|
|
my $serv = $_;
|
|
|
|
chomp $serv;
|
|
|
|
if($run{$serv}) {
|
|
|
|
stopserver($run{$serv}); # the pid file is in the hash table
|
|
|
|
$run{$serv}=""; # clear it
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
print STDERR "RUN: The $serv server is not running\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-11-17 16:58:25 +01:00
|
|
|
if($memory_debug) {
|
|
|
|
if(! -f $memdump) {
|
|
|
|
print "\n** ALERT! memory debuggin without any output file?\n";
|
|
|
|
}
|
|
|
|
else {
|
2003-01-09 12:26:57 +01:00
|
|
|
my @memdata=`$memanalyze $memdump`;
|
2000-11-17 16:58:25 +01:00
|
|
|
my $leak=0;
|
|
|
|
for(@memdata) {
|
2000-11-21 16:48:40 +01:00
|
|
|
if($_ ne "") {
|
|
|
|
# well it could be other memory problems as well, but
|
|
|
|
# we call it leak for short here
|
2000-11-17 16:58:25 +01:00
|
|
|
$leak=1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if($leak) {
|
2000-11-21 16:48:40 +01:00
|
|
|
print "\n** MEMORY FAILURE\n";
|
2000-11-17 16:58:25 +01:00
|
|
|
print @memdata;
|
|
|
|
return 1;
|
2000-11-17 16:07:29 +01:00
|
|
|
}
|
|
|
|
else {
|
2000-11-17 16:58:25 +01:00
|
|
|
if(!$short) {
|
|
|
|
print " memory OK";
|
2000-11-17 16:07:29 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
2000-11-17 16:15:48 +01:00
|
|
|
if($short) {
|
|
|
|
print "OK";
|
|
|
|
}
|
2000-11-14 11:18:44 +01:00
|
|
|
print "\n";
|
2000-11-13 17:06:16 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-05-23 17:02:58 +02:00
|
|
|
##############################################################################
|
|
|
|
# This function makes sure the right set of server is running for the
|
|
|
|
# specified test case. This is a useful design when we run single tests as not
|
|
|
|
# all servers need to run then!
|
|
|
|
|
2001-04-24 23:09:53 +02:00
|
|
|
sub serverfortest {
|
|
|
|
my ($testnum)=@_;
|
|
|
|
|
2003-04-30 22:28:49 +02:00
|
|
|
# load the test case file definition
|
|
|
|
if(loadtest("${TESTDIR}/test${testnum}")) {
|
|
|
|
if($verbose) {
|
|
|
|
# this is not a test
|
|
|
|
print "$testnum doesn't look like a test case!\n";
|
2001-04-24 23:09:53 +02:00
|
|
|
}
|
2003-04-30 22:28:49 +02:00
|
|
|
return 100;
|
|
|
|
}
|
|
|
|
my @what = getpart("client", "server");
|
2001-04-24 23:09:53 +02:00
|
|
|
|
2003-04-30 22:28:49 +02:00
|
|
|
if(!$what[0]) {
|
|
|
|
warn "Test case $testnum has no server(s) specified!";
|
|
|
|
return 100;
|
2001-04-24 23:09:53 +02:00
|
|
|
}
|
2003-04-30 22:28:49 +02:00
|
|
|
|
2002-12-12 13:20:06 +01:00
|
|
|
for(@what) {
|
|
|
|
my $what = lc($_);
|
|
|
|
$what =~ s/[^a-z]//g;
|
|
|
|
if($what eq "ftp") {
|
|
|
|
if(!$run{'ftp'}) {
|
2003-03-15 17:43:58 +01:00
|
|
|
if(runftpserver($verbose)) {
|
|
|
|
return 2; # error starting it
|
|
|
|
}
|
2002-12-12 13:20:06 +01:00
|
|
|
$run{'ftp'}=$FTPPIDFILE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
elsif($what eq "http") {
|
|
|
|
if(!$run{'http'}) {
|
2003-03-15 17:43:58 +01:00
|
|
|
if(runhttpserver($verbose)) {
|
|
|
|
return 2; # error starting
|
|
|
|
}
|
2002-12-12 13:20:06 +01:00
|
|
|
$run{'http'}=$HTTPPIDFILE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
elsif($what eq "ftps") {
|
|
|
|
if(!$checkstunnel || !$ssl_version) {
|
|
|
|
# we can't run https tests without stunnel
|
|
|
|
# or if libcurl is SSL-less
|
|
|
|
return 1;
|
|
|
|
}
|
2002-12-12 14:42:21 +01:00
|
|
|
if(!$run{'ftp'}) {
|
2003-03-15 17:43:58 +01:00
|
|
|
if(runftpserver($verbose)) {
|
|
|
|
return 2; # error starting it
|
|
|
|
}
|
2002-12-12 14:42:21 +01:00
|
|
|
$run{'ftp'}=$FTPPIDFILE;
|
|
|
|
}
|
2002-12-12 13:20:06 +01:00
|
|
|
if(!$run{'ftps'}) {
|
|
|
|
runftpsserver($verbose);
|
|
|
|
$run{'ftps'}=$FTPSPIDFILE;
|
|
|
|
}
|
2001-04-24 23:09:53 +02:00
|
|
|
}
|
2002-12-12 13:20:06 +01:00
|
|
|
elsif($what eq "file") {
|
|
|
|
# we support it but have no server!
|
|
|
|
}
|
|
|
|
elsif($what eq "https") {
|
|
|
|
if(!$checkstunnel || !$ssl_version) {
|
|
|
|
# we can't run https tests without stunnel
|
|
|
|
# or if libcurl is SSL-less
|
|
|
|
return 1;
|
|
|
|
}
|
2002-12-12 14:42:21 +01:00
|
|
|
if(!$run{'http'}) {
|
2003-03-15 17:43:58 +01:00
|
|
|
if(runhttpserver($verbose)) {
|
|
|
|
return 2; # problems starting server
|
|
|
|
}
|
2002-12-12 14:42:21 +01:00
|
|
|
$run{'http'}=$HTTPPIDFILE;
|
|
|
|
}
|
2002-12-12 13:20:06 +01:00
|
|
|
if(!$run{'https'}) {
|
|
|
|
runhttpsserver($verbose);
|
|
|
|
$run{'https'}=$HTTPSPIDFILE;
|
|
|
|
}
|
2001-04-24 23:09:53 +02:00
|
|
|
}
|
2003-03-15 18:11:13 +01:00
|
|
|
elsif($what eq "none") {
|
|
|
|
}
|
2002-12-12 13:20:06 +01:00
|
|
|
else {
|
|
|
|
warn "we don't support a server for $what";
|
2001-04-24 23:09:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0; # ok
|
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
|
|
|
|
#######################################################################
|
|
|
|
# Check options to this test program
|
|
|
|
#
|
|
|
|
|
2001-03-12 13:58:30 +01:00
|
|
|
my $number=0;
|
|
|
|
my $fromnum=-1;
|
2000-11-21 20:28:11 +01:00
|
|
|
my @testthis;
|
2000-11-14 11:18:44 +01:00
|
|
|
do {
|
|
|
|
if ($ARGV[0] eq "-v") {
|
|
|
|
# verbose output
|
|
|
|
$verbose=1;
|
|
|
|
}
|
2001-08-21 15:18:07 +02:00
|
|
|
elsif ($ARGV[0] eq "-c") {
|
|
|
|
# use this path to curl instead of default
|
|
|
|
$CURL=$ARGV[1];
|
|
|
|
shift @ARGV;
|
|
|
|
}
|
2001-01-27 19:50:54 +01:00
|
|
|
elsif ($ARGV[0] eq "-d") {
|
|
|
|
# have the servers display protocol output
|
|
|
|
$debugprotocol=1;
|
|
|
|
}
|
2001-02-20 14:58:39 +01:00
|
|
|
elsif ($ARGV[0] eq "-g") {
|
|
|
|
# run this test with gdb
|
|
|
|
$gdbthis=1;
|
|
|
|
}
|
2000-11-14 11:18:44 +01:00
|
|
|
elsif($ARGV[0] eq "-s") {
|
|
|
|
# short output
|
|
|
|
$short=1;
|
|
|
|
}
|
2000-11-17 16:15:48 +01:00
|
|
|
elsif($ARGV[0] eq "-a") {
|
|
|
|
# continue anyway, even if a test fail
|
|
|
|
$anyway=1;
|
|
|
|
}
|
2002-01-04 14:20:17 +01:00
|
|
|
elsif($ARGV[0] eq "-l") {
|
|
|
|
# lists the test case names only
|
|
|
|
$listonly=1;
|
|
|
|
}
|
2001-05-04 09:47:11 +02:00
|
|
|
elsif($ARGV[0] eq "-k") {
|
|
|
|
# keep stdout and stderr files after tests
|
|
|
|
$keepoutfiles=1;
|
|
|
|
}
|
2000-11-14 11:28:25 +01:00
|
|
|
elsif($ARGV[0] eq "-h") {
|
|
|
|
# show help text
|
|
|
|
print <<EOHELP
|
2001-04-24 23:09:53 +02:00
|
|
|
Usage: runtests.pl [options]
|
2000-11-17 16:15:48 +01:00
|
|
|
-a continue even if a test fails
|
2001-01-27 19:50:54 +01:00
|
|
|
-d display server debug info
|
2001-02-20 14:58:39 +01:00
|
|
|
-g run the test case with gdb
|
2000-11-14 11:28:25 +01:00
|
|
|
-h this help text
|
2001-05-04 09:47:11 +02:00
|
|
|
-k keep stdout and stderr files present after tests
|
2002-01-04 14:20:17 +01:00
|
|
|
-l list all test case names/descriptions
|
2000-11-14 11:28:25 +01:00
|
|
|
-s short output
|
|
|
|
-v verbose output
|
2001-04-24 23:09:53 +02:00
|
|
|
[num] like "5 6 9" or " 5 to 22 " to run those tests only
|
2000-11-14 11:28:25 +01:00
|
|
|
EOHELP
|
|
|
|
;
|
|
|
|
exit;
|
|
|
|
}
|
2000-11-14 11:18:44 +01:00
|
|
|
elsif($ARGV[0] =~ /^(\d+)/) {
|
2001-03-12 13:58:30 +01:00
|
|
|
$number = $1;
|
|
|
|
if($fromnum >= 0) {
|
|
|
|
for($fromnum .. $number) {
|
|
|
|
push @testthis, $_;
|
|
|
|
}
|
|
|
|
$fromnum = -1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
push @testthis, $1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
elsif($ARGV[0] =~ /^to$/i) {
|
2001-03-13 23:14:53 +01:00
|
|
|
$fromnum = $number+1;
|
2000-11-14 11:18:44 +01:00
|
|
|
}
|
|
|
|
} while(shift @ARGV);
|
2000-11-13 17:06:16 +01:00
|
|
|
|
2000-11-21 20:28:11 +01:00
|
|
|
if($testthis[0] ne "") {
|
|
|
|
$TESTCASES=join(" ", @testthis);
|
|
|
|
}
|
|
|
|
|
2000-11-13 17:06:16 +01:00
|
|
|
#######################################################################
|
|
|
|
# Output curl version and host info being tested
|
|
|
|
#
|
|
|
|
|
2002-01-08 10:32:41 +01:00
|
|
|
if(!$listonly) {
|
|
|
|
displaydata();
|
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
|
|
|
|
#######################################################################
|
2000-11-14 11:18:44 +01:00
|
|
|
# clear and create logging directory:
|
2000-11-13 17:06:16 +01:00
|
|
|
#
|
2000-11-14 11:18:44 +01:00
|
|
|
cleardir($LOGDIR);
|
|
|
|
mkdir($LOGDIR, 0777);
|
2000-11-13 17:06:16 +01:00
|
|
|
|
|
|
|
#######################################################################
|
2000-11-14 11:18:44 +01:00
|
|
|
# If 'all' tests are requested, find out all test numbers
|
2000-11-13 17:06:16 +01:00
|
|
|
#
|
|
|
|
|
|
|
|
if ( $TESTCASES eq "all") {
|
2000-11-14 11:18:44 +01:00
|
|
|
# Get all commands and find out their test numbers
|
|
|
|
opendir(DIR, $TESTDIR) || die "can't opendir $TESTDIR: $!";
|
2001-05-23 17:02:58 +02:00
|
|
|
my @cmds = grep { /^test([0-9]+)$/ && -f "$TESTDIR/$_" } readdir(DIR);
|
2000-11-14 11:18:44 +01:00
|
|
|
closedir DIR;
|
|
|
|
|
2000-11-15 09:21:14 +01:00
|
|
|
$TESTCASES=""; # start with no test cases
|
|
|
|
|
|
|
|
# cut off everything but the digits
|
2000-11-14 11:18:44 +01:00
|
|
|
for(@cmds) {
|
|
|
|
$_ =~ s/[a-z\/\.]*//g;
|
2000-11-15 09:21:14 +01:00
|
|
|
}
|
|
|
|
# the the numbers from low to high
|
|
|
|
for(sort { $a <=> $b } @cmds) {
|
2000-11-14 11:18:44 +01:00
|
|
|
$TESTCASES .= " $_";
|
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
}
|
|
|
|
|
2000-11-21 18:07:16 +01:00
|
|
|
#######################################################################
|
|
|
|
# Start the command line log
|
|
|
|
#
|
|
|
|
open(CMDLOG, ">$CURLLOG") ||
|
|
|
|
print "can't log command lines to $CURLLOG\n";
|
|
|
|
|
2000-11-14 11:18:44 +01:00
|
|
|
#######################################################################
|
|
|
|
# The main test-loop
|
|
|
|
#
|
|
|
|
|
2001-03-12 14:46:23 +01:00
|
|
|
my $failed;
|
2000-11-15 08:09:37 +01:00
|
|
|
my $testnum;
|
2000-11-28 13:49:39 +01:00
|
|
|
my $ok=0;
|
|
|
|
my $total=0;
|
2001-04-24 23:09:53 +02:00
|
|
|
|
2000-11-13 17:06:16 +01:00
|
|
|
foreach $testnum (split(" ", $TESTCASES)) {
|
|
|
|
|
2003-01-27 14:51:35 +01:00
|
|
|
my $error = singletest($testnum);
|
|
|
|
if(-1 == $error) {
|
|
|
|
# not a test we can run
|
2001-04-24 23:09:53 +02:00
|
|
|
next;
|
|
|
|
}
|
|
|
|
|
2003-01-27 14:51:35 +01:00
|
|
|
$total++; # number of tests we've run
|
|
|
|
|
2001-03-12 14:46:23 +01:00
|
|
|
if($error>0) {
|
2001-05-23 17:02:58 +02:00
|
|
|
$failed.= "$testnum ";
|
2001-03-12 14:46:23 +01:00
|
|
|
if(!$anyway) {
|
|
|
|
# a test failed, abort
|
|
|
|
print "\n - abort tests\n";
|
|
|
|
last;
|
|
|
|
}
|
2000-11-17 16:07:29 +01:00
|
|
|
}
|
2000-11-28 13:49:39 +01:00
|
|
|
elsif(!$error) {
|
2003-01-27 14:51:35 +01:00
|
|
|
$ok++; # successful test counter
|
2000-11-28 13:49:39 +01:00
|
|
|
}
|
2000-11-13 17:06:16 +01:00
|
|
|
|
|
|
|
# loop for next test
|
|
|
|
}
|
|
|
|
|
2000-11-21 18:07:16 +01:00
|
|
|
#######################################################################
|
|
|
|
# Close command log
|
|
|
|
#
|
|
|
|
close(CMDLOG);
|
|
|
|
|
2000-11-13 17:06:16 +01:00
|
|
|
#######################################################################
|
2000-11-21 16:48:40 +01:00
|
|
|
# Tests done, stop the servers
|
2000-11-13 17:06:16 +01:00
|
|
|
#
|
|
|
|
|
2001-04-24 23:09:53 +02:00
|
|
|
for(keys %run) {
|
|
|
|
stopserver($run{$_}); # the pid file is in the hash table
|
|
|
|
}
|
2000-11-21 16:48:40 +01:00
|
|
|
|
2001-03-12 13:58:30 +01:00
|
|
|
if($total) {
|
2003-01-20 16:43:50 +01:00
|
|
|
printf("TESTDONE: $ok tests out of $total reported OK: %d%%\n",
|
2002-01-03 09:22:05 +01:00
|
|
|
$ok/$total*100);
|
2001-03-12 14:46:23 +01:00
|
|
|
|
|
|
|
if($ok != $total) {
|
2003-01-20 16:43:50 +01:00
|
|
|
print "TESTFAIL: These test cases failed: $failed\n";
|
2001-03-12 14:46:23 +01:00
|
|
|
}
|
2001-03-12 13:58:30 +01:00
|
|
|
}
|
|
|
|
else {
|
2003-01-20 16:43:50 +01:00
|
|
|
print "TESTFAIL: No tests were performed!\n";
|
2001-03-12 13:58:30 +01:00
|
|
|
}
|
2001-04-24 23:09:53 +02:00
|
|
|
if($skipped) {
|
2003-01-20 16:43:50 +01:00
|
|
|
print "TESTINFO: $skipped tests were skipped due to restraints\n";
|
2001-04-24 23:09:53 +02:00
|
|
|
}
|
2003-03-15 17:43:58 +01:00
|
|
|
if($problems) {
|
|
|
|
print "TESTINFO: $problems tests didn't run due to run-time problems\n";
|
|
|
|
}
|
2001-05-28 17:26:15 +02:00
|
|
|
if($total && ($ok != $total)) {
|
|
|
|
exit 1;
|
|
|
|
}
|