2002-02-25 09:08:51 -05:00
|
|
|
#!/usr/bin/env perl
|
2004-01-13 03:57:01 -05:00
|
|
|
#***************************************************************************
|
|
|
|
# _ _ ____ _
|
|
|
|
# Project ___| | | | _ \| |
|
|
|
|
# / __| | | | |_) | |
|
|
|
|
# | (__| |_| | _ <| |___
|
2004-01-13 02:37:29 -05:00
|
|
|
# \___|\___/|_| \_\_____|
|
|
|
|
#
|
2005-02-10 03:50:33 -05:00
|
|
|
# Copyright (C) 1998 - 2005, Daniel Stenberg, <daniel@haxx.se>, et al.
|
2004-01-13 02:37:29 -05:00
|
|
|
#
|
2004-01-13 03:57:01 -05:00
|
|
|
# This software is licensed as described in the file COPYING, which
|
|
|
|
# you should have received as part of this distribution. The terms
|
|
|
|
# are also available at http://curl.haxx.se/docs/copyright.html.
|
2000-11-13 11:06:16 -05:00
|
|
|
#
|
2004-01-13 02:37:29 -05:00
|
|
|
# You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
|
|
|
# copies of the Software, and permit persons to whom the Software is
|
2004-01-13 03:57:01 -05:00
|
|
|
# furnished to do so, under the terms of the COPYING file.
|
2000-11-13 11:06:16 -05:00
|
|
|
#
|
2004-01-13 02:37:29 -05:00
|
|
|
# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
# KIND, either express or implied.
|
|
|
|
#
|
|
|
|
# $Id$
|
2004-01-13 03:57:01 -05:00
|
|
|
###########################################################################
|
2000-11-13 11:06:16 -05:00
|
|
|
# These should be the only variables that might be needed to get edited:
|
|
|
|
|
2002-05-21 18:39:09 -04:00
|
|
|
use strict;
|
2002-05-21 18:20:52 -04:00
|
|
|
#use warnings;
|
2000-11-15 02:09:37 -05:00
|
|
|
|
2001-05-14 08:09:47 -04:00
|
|
|
@INC=(@INC, $ENV{'srcdir'}, ".");
|
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
require "getpart.pm"; # array functions
|
2005-02-10 03:50:33 -05:00
|
|
|
require "valgrind.pm"; # valgrind report parser
|
2005-04-18 02:57:44 -04:00
|
|
|
require "ftp.pm";
|
2001-04-24 17:09:53 -04:00
|
|
|
|
2001-01-08 17:18:30 -05:00
|
|
|
my $srcdir = $ENV{'srcdir'} || '.';
|
2000-11-15 02:09:37 -05:00
|
|
|
my $HOSTIP="127.0.0.1";
|
2004-12-11 16:41:00 -05:00
|
|
|
my $HOST6IP="[::1]";
|
2004-09-08 04:08:38 -04:00
|
|
|
|
|
|
|
my $base = 8990; # base port number
|
|
|
|
|
|
|
|
my $HTTPPORT; # HTTP server port
|
2004-12-11 16:41:00 -05:00
|
|
|
my $HTTP6PORT; # HTTP IPv6 server port
|
2004-09-08 04:08:38 -04:00
|
|
|
my $HTTPSPORT; # HTTPS server port
|
|
|
|
my $FTPPORT; # FTP server port
|
2005-01-17 15:20:34 -05:00
|
|
|
my $FTP2PORT; # FTP server 2 port
|
2004-09-08 04:08:38 -04:00
|
|
|
my $FTPSPORT; # FTPS server port
|
2005-04-18 02:57:44 -04:00
|
|
|
my $FTP6PORT; # FTP IPv6 server port
|
2004-09-08 04:08:38 -04:00
|
|
|
|
2000-11-21 12:07:16 -05:00
|
|
|
my $CURL="../src/curl"; # what curl executable to run on the tests
|
2002-05-21 18:20:52 -04:00
|
|
|
my $DBGCURL=$CURL; #"../src/.libs/curl"; # alternative for debugging
|
2000-11-15 02:09:37 -05:00
|
|
|
my $LOGDIR="log";
|
2004-02-12 09:40:08 -05:00
|
|
|
my $TESTDIR="$srcdir/data";
|
2002-12-12 07:20:06 -05:00
|
|
|
my $LIBDIR="./libtest";
|
2002-02-25 07:14:24 -05:00
|
|
|
my $SERVERIN="$LOGDIR/server.input"; # what curl sent the server
|
2005-01-20 17:48:43 -05:00
|
|
|
my $SERVER2IN="$LOGDIR/server2.input"; # what curl sent the second server
|
2000-11-21 12:07:16 -05:00
|
|
|
my $CURLLOG="$LOGDIR/curl.log"; # all command lines run
|
2000-11-27 07:53:50 -05:00
|
|
|
my $FTPDCMD="$LOGDIR/ftpserver.cmd"; # copy ftp server instructions here
|
2000-11-13 11:06:16 -05:00
|
|
|
|
|
|
|
# Normally, all test cases should be run, but at times it is handy to
|
|
|
|
# simply run a particular one:
|
2000-11-15 02:09:37 -05:00
|
|
|
my $TESTCASES="all";
|
2000-11-13 11:06:16 -05: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 08:09:47 -04:00
|
|
|
my $HTTPPIDFILE=".http.pid";
|
2004-12-11 16:41:00 -05:00
|
|
|
my $HTTP6PIDFILE=".http6.pid";
|
2001-04-24 17:09:53 -04:00
|
|
|
my $HTTPSPIDFILE=".https.pid";
|
2001-05-14 08:09:47 -04:00
|
|
|
my $FTPPIDFILE=".ftp.pid";
|
2005-04-18 02:57:44 -04:00
|
|
|
my $FTP6PIDFILE=".ftp6.pid";
|
2005-01-17 15:20:34 -05:00
|
|
|
my $FTP2PIDFILE=".ftp2.pid";
|
2001-05-14 08:09:47 -04:00
|
|
|
my $FTPSPIDFILE=".ftps.pid";
|
2000-11-15 02:09:37 -05:00
|
|
|
|
2001-05-28 11:26:15 -04:00
|
|
|
# invoke perl like this:
|
|
|
|
my $perl="perl -I$srcdir";
|
|
|
|
|
2003-06-26 07:44:01 -04:00
|
|
|
# this gets set if curl is compiled with debugging:
|
|
|
|
my $curl_debug=0;
|
2002-05-21 18:20:52 -04:00
|
|
|
|
2000-11-17 10:07:29 -05:00
|
|
|
# name of the file that the memory debugging creates:
|
2005-01-27 10:51:03 -05:00
|
|
|
my $memdump="$LOGDIR/memdump";
|
2000-11-17 10:07:29 -05:00
|
|
|
|
|
|
|
# the path to the script that analyzes the memory debug output file:
|
2002-03-01 04:20:03 -05:00
|
|
|
my $memanalyze="./memanalyze.pl";
|
2000-11-17 10:07:29 -05:00
|
|
|
|
2003-10-29 11:27:43 -05:00
|
|
|
my $stunnel = checkcmd("stunnel");
|
|
|
|
my $valgrind = checkcmd("valgrind");
|
2005-04-22 07:51:06 -04:00
|
|
|
my $start;
|
2004-07-26 11:45:03 -04:00
|
|
|
|
|
|
|
my $valgrind_tool;
|
|
|
|
if($valgrind) {
|
|
|
|
# since valgrind 2.1.x, '--tool' option is mandatory
|
|
|
|
# use it, if it is supported by the version installed on the system
|
|
|
|
system("valgrind --help 2>&1 | grep -- --tool > /dev/null 2>&1");
|
|
|
|
if (($? >> 8)==0) {
|
|
|
|
$valgrind_tool="--tool=memcheck ";
|
|
|
|
}
|
2005-02-10 03:50:33 -05:00
|
|
|
open(C, "<$CURL");
|
|
|
|
my $l = <C>;
|
|
|
|
if($l =~ /^\#\!/) {
|
|
|
|
# The first line starts with "#!" which implies a shell-script.
|
|
|
|
# This means libcurl is built shared and curl is a wrapper-script
|
|
|
|
# Disable valgrind in this setup
|
|
|
|
$valgrind=0;
|
|
|
|
}
|
|
|
|
close(C);
|
2004-07-26 11:45:03 -04:00
|
|
|
}
|
|
|
|
|
2004-04-30 04:03:07 -04:00
|
|
|
my $gdb = checkcmd("gdb");
|
2001-04-24 17:09:53 -04:00
|
|
|
|
2001-05-21 09:38:38 -04:00
|
|
|
my $ssl_version; # set if libcurl is built with SSL support
|
2004-03-01 11:24:54 -05:00
|
|
|
my $large_file; # set if libcurl is built with large file support
|
2004-04-30 04:03:07 -04:00
|
|
|
my $has_idn; # set if libcurl is built with IDN support
|
2004-12-11 16:41:00 -05:00
|
|
|
my $http_ipv6; # set if HTTP server has IPv6 support
|
2005-04-18 02:57:44 -04:00
|
|
|
my $ftp_ipv6; # set if FTP server has IPv6 support
|
2004-11-25 17:21:49 -05:00
|
|
|
my $has_ipv6; # set if libcurl is built with IPv6 support
|
2004-11-29 07:23:02 -05:00
|
|
|
my $has_libz; # set if libcurl is built with libz support
|
2004-11-22 17:26:46 -05:00
|
|
|
my $has_getrlimit; # set if system has getrlimit()
|
2005-03-21 03:14:32 -05:00
|
|
|
my $has_ntlm; # set if libcurl is built with NTLM support
|
2005-04-12 03:18:48 -04:00
|
|
|
my $has_openssl; # set if libcurl is built with OpenSSL
|
|
|
|
my $has_gnutls; # set if libcurl is built with GnuTLS
|
2005-04-28 17:04:58 -04:00
|
|
|
my $has_textaware; # set if running on a system that has a text mode concept
|
|
|
|
# on files. Windows for example
|
2001-05-21 09:38:38 -04:00
|
|
|
|
2003-03-15 11:43:58 -05:00
|
|
|
my $skipped=0; # number of tests skipped; reported in main loop
|
2003-06-26 07:44:01 -04:00
|
|
|
my %skipped; # skipped{reason}=counter, reasons for skip
|
|
|
|
my @teststat; # teststat[testnum]=reason, reasons for skip
|
2002-05-21 18:20:52 -04:00
|
|
|
|
2000-11-15 02:09:37 -05:00
|
|
|
#######################################################################
|
|
|
|
# variables the command line options may set
|
|
|
|
#
|
|
|
|
|
|
|
|
my $short;
|
|
|
|
my $verbose;
|
2001-01-27 13:50:54 -05:00
|
|
|
my $debugprotocol;
|
2000-11-17 10:15:48 -05:00
|
|
|
my $anyway;
|
2001-05-04 03:47:11 -04:00
|
|
|
my $gdbthis; # run test case with gdb debugger
|
|
|
|
my $keepoutfiles; # keep stdout and stderr files after tests
|
2002-01-04 08:20:17 -05:00
|
|
|
my $listonly; # only list the tests
|
2004-04-13 01:57:50 -04:00
|
|
|
my $postmortem; # display detailed info about failed tests
|
2002-01-04 08:20:17 -05:00
|
|
|
|
2001-08-06 08:10:00 -04:00
|
|
|
my $pwd; # current working directory
|
|
|
|
|
2003-04-01 03:41:49 -05:00
|
|
|
my %run; # running server
|
|
|
|
|
2003-10-24 04:53:59 -04:00
|
|
|
# torture test variables
|
|
|
|
my $torture;
|
|
|
|
my $tortnum;
|
|
|
|
my $tortalloc;
|
|
|
|
|
2001-08-06 08:10:00 -04:00
|
|
|
chomp($pwd = `pwd`);
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2002-02-28 07:36:25 -05:00
|
|
|
# enable memory debugging if curl is compiled with it
|
2005-01-27 10:51:03 -05:00
|
|
|
$ENV{'CURL_MEMDEBUG'} = $memdump;
|
2002-04-09 10:28:16 -04:00
|
|
|
$ENV{'HOME'}=$pwd;
|
2002-02-28 07:36:25 -05:00
|
|
|
|
2005-04-28 04:23:25 -04:00
|
|
|
sub catch_zap {
|
|
|
|
my $signame = shift;
|
2005-04-28 17:04:58 -04:00
|
|
|
print STDERR "runtests.pl received SIG$signame, exiting\n";
|
|
|
|
stopservers(1);
|
2005-04-28 04:23:25 -04:00
|
|
|
die "Somebody sent me a SIG$signame";
|
|
|
|
}
|
|
|
|
$SIG{INT} = \&catch_zap;
|
|
|
|
$SIG{KILL} = \&catch_zap;
|
|
|
|
|
2003-09-12 11:41:14 -04:00
|
|
|
##########################################################################
|
|
|
|
# Clear all possible '*_proxy' environment variables for various protocols
|
|
|
|
# to prevent them to interfere with our testing!
|
|
|
|
|
|
|
|
my $protocol;
|
|
|
|
foreach $protocol (('ftp', 'http', 'ftps', 'https', 'gopher', 'no')) {
|
|
|
|
my $proxy = "${protocol}_proxy";
|
|
|
|
# clear lowercase version
|
|
|
|
$ENV{$proxy}=undef;
|
|
|
|
# clear uppercase version
|
|
|
|
$ENV{uc($proxy)}=undef;
|
|
|
|
}
|
|
|
|
|
2005-05-02 03:54:25 -04:00
|
|
|
# make sure we don't get affected by other variables that control our
|
|
|
|
# behaviour
|
|
|
|
|
|
|
|
$ENV{'SSL_CERT_DIR'}=undef;
|
|
|
|
$ENV{'SSL_CERT_PATH'}=undef;
|
|
|
|
$ENV{'CURL_CA_BUNDLE'}=undef;
|
|
|
|
|
2005-05-01 09:20:53 -04:00
|
|
|
#######################################################################
|
|
|
|
# Start a new thread/process and run the given command line in there.
|
|
|
|
# Return the pid of the new child process to the parent.
|
|
|
|
#
|
|
|
|
sub startnew {
|
|
|
|
my ($cmd)=@_;
|
|
|
|
|
|
|
|
print "CMD: $cmd\n" if ($verbose);
|
|
|
|
|
|
|
|
my $child = fork();
|
|
|
|
|
|
|
|
if(0 == $child) {
|
|
|
|
# a child, run the given command instead!
|
|
|
|
exec($cmd);
|
|
|
|
}
|
|
|
|
return $child;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-29 04:12:47 -05:00
|
|
|
#######################################################################
|
|
|
|
# Check for a command in the PATH.
|
|
|
|
#
|
|
|
|
sub checkcmd {
|
|
|
|
my ($cmd)=@_;
|
|
|
|
my @paths=("/usr/sbin", "/usr/local/sbin", "/sbin", "/usr/bin",
|
|
|
|
"/usr/local/bin", split(":", $ENV{'PATH'}));
|
|
|
|
for(@paths) {
|
|
|
|
if( -x "$_/$cmd") {
|
|
|
|
return "$_/$cmd";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-10-24 04:53:59 -04:00
|
|
|
#######################################################################
|
|
|
|
# Memory allocation test and failure torture testing.
|
|
|
|
#
|
|
|
|
sub torture {
|
2004-05-10 05:01:45 -04:00
|
|
|
my $testcmd = shift;
|
|
|
|
my $gdbline = shift;
|
2003-10-24 04:53:59 -04:00
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
# remove memdump first to be sure we get a new nice and clean one
|
|
|
|
unlink($memdump);
|
2003-10-24 04:53:59 -04:00
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
# First get URL from test server, ignore the output/result
|
|
|
|
system($testcmd);
|
2003-10-24 04:53:59 -04:00
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
print " CMD: $testcmd\n" if($verbose);
|
2004-05-17 06:53:34 -04:00
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
# memanalyze -v is our friend, get the number of allocations made
|
2004-05-13 03:52:33 -04:00
|
|
|
my $count=0;
|
2004-05-10 05:01:45 -04:00
|
|
|
my @out = `$memanalyze -v $memdump`;
|
|
|
|
for(@out) {
|
|
|
|
if(/^Allocations: (\d+)/) {
|
|
|
|
$count = $1;
|
|
|
|
last;
|
2003-10-24 04:53:59 -04:00
|
|
|
}
|
2004-05-10 05:01:45 -04:00
|
|
|
}
|
2004-05-13 03:52:33 -04:00
|
|
|
if(!$count) {
|
|
|
|
print " found no allocs to make fail\n";
|
|
|
|
return 0;
|
|
|
|
}
|
2003-10-24 09:00:19 -04:00
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
print " $count allocations to make fail\n";
|
2003-10-24 09:00:19 -04:00
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
for ( 1 .. $count ) {
|
|
|
|
my $limit = $_;
|
|
|
|
my $fail;
|
|
|
|
my $dumped_core;
|
2004-05-17 06:53:34 -04:00
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
if($tortalloc && ($tortalloc != $limit)) {
|
2003-10-24 04:53:59 -04:00
|
|
|
next;
|
|
|
|
}
|
2003-10-24 09:00:19 -04:00
|
|
|
|
2004-05-13 03:52:33 -04:00
|
|
|
print "Fail alloc no: $limit\r" if($verbose);
|
2004-05-17 06:53:34 -04:00
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
# make the memory allocation function number $limit return failure
|
|
|
|
$ENV{'CURL_MEMLIMIT'} = $limit;
|
2003-10-24 04:53:59 -04:00
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
# remove memdump first to be sure we get a new nice and clean one
|
|
|
|
unlink($memdump);
|
2004-05-17 06:53:34 -04:00
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
print "**> Alloc number $limit is now set to fail <**\n" if($gdbthis);
|
2003-10-24 04:53:59 -04:00
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
my $ret;
|
|
|
|
if($gdbthis) {
|
|
|
|
system($gdbline)
|
2004-05-17 06:53:34 -04:00
|
|
|
}
|
2004-05-10 05:01:45 -04:00
|
|
|
else {
|
|
|
|
$ret = system($testcmd);
|
|
|
|
}
|
2003-10-24 04:53:59 -04:00
|
|
|
|
2004-05-13 03:52:33 -04:00
|
|
|
# Now clear the variable again
|
|
|
|
$ENV{'CURL_MEMLIMIT'} = undef;
|
|
|
|
|
2004-05-10 05:01:45 -04:00
|
|
|
if(-r "core") {
|
|
|
|
# there's core file present now!
|
|
|
|
print " core dumped!\n";
|
|
|
|
$dumped_core = 1;
|
|
|
|
$fail = 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
# verify that it returns a proper error code, doesn't leak memory
|
|
|
|
# and doesn't core dump
|
|
|
|
if($ret & 255) {
|
|
|
|
print " system() returned $ret\n";
|
|
|
|
$fail=1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
my @memdata=`$memanalyze $memdump`;
|
|
|
|
my $leak=0;
|
|
|
|
for(@memdata) {
|
|
|
|
if($_ ne "") {
|
|
|
|
# well it could be other memory problems as well, but
|
|
|
|
# we call it leak for short here
|
|
|
|
$leak=1;
|
2003-10-24 04:53:59 -04:00
|
|
|
}
|
|
|
|
}
|
2004-05-10 05:01:45 -04:00
|
|
|
if($leak) {
|
|
|
|
print "** MEMORY FAILURE\n";
|
|
|
|
print @memdata;
|
|
|
|
print `$memanalyze -l $memdump`;
|
|
|
|
$fail = 1;
|
2003-10-24 04:53:59 -04:00
|
|
|
}
|
|
|
|
}
|
2004-05-10 05:01:45 -04:00
|
|
|
if($fail) {
|
|
|
|
print " Failed on alloc number $limit in test.\n",
|
|
|
|
" invoke with -t$limit to repeat this single case.\n";
|
2005-04-28 17:04:58 -04:00
|
|
|
stopservers($verbose);
|
2004-05-10 05:01:45 -04:00
|
|
|
exit 1;
|
|
|
|
}
|
2003-10-24 04:53:59 -04:00
|
|
|
}
|
2004-05-10 05:01:45 -04:00
|
|
|
|
2004-05-13 03:52:33 -04:00
|
|
|
print "torture OK\n";
|
|
|
|
return 0;
|
2003-10-24 04:53:59 -04:00
|
|
|
}
|
|
|
|
|
2000-11-14 05:18:44 -05:00
|
|
|
#######################################################################
|
2005-05-01 09:20:53 -04:00
|
|
|
# stop the given test server (pid)
|
2000-11-14 05:18:44 -05:00
|
|
|
#
|
2000-11-13 11:06:16 -05:00
|
|
|
sub stopserver {
|
2005-05-01 09:20:53 -04:00
|
|
|
my ($pid) = @_;
|
|
|
|
|
|
|
|
if($pid <= 0) {
|
2003-06-13 05:04:08 -04:00
|
|
|
return; # this is not a good pid
|
|
|
|
}
|
2000-11-14 05:18:44 -05:00
|
|
|
|
2003-06-13 05:04:08 -04:00
|
|
|
my $res = kill (9, $pid); # die!
|
|
|
|
|
|
|
|
if($res && $verbose) {
|
|
|
|
print "RUN: Test server pid $pid signalled to die\n";
|
|
|
|
}
|
|
|
|
elsif($verbose) {
|
|
|
|
print "RUN: Test server pid $pid didn't exist\n";
|
2000-11-13 11:06:16 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-04-24 17:09:53 -04:00
|
|
|
#######################################################################
|
2005-05-01 09:20:53 -04:00
|
|
|
# start the http server
|
2001-04-24 17:09:53 -04:00
|
|
|
#
|
|
|
|
sub runhttpserver {
|
2004-12-11 16:41:00 -05:00
|
|
|
my ($verbose, $ipv6) = @_;
|
2001-04-24 17:09:53 -04:00
|
|
|
my $RUNNING;
|
2001-10-17 07:51:02 -04:00
|
|
|
my $pid;
|
2005-04-28 09:54:48 -04:00
|
|
|
my $cmd;
|
2004-12-11 16:41:00 -05:00
|
|
|
my $pidfile = $HTTPPIDFILE;
|
|
|
|
my $port = $HTTPPORT;
|
|
|
|
my $ip = $HOSTIP;
|
|
|
|
my $nameext;
|
|
|
|
|
|
|
|
if($ipv6) {
|
|
|
|
# if IPv6, use a different setup
|
|
|
|
$pidfile = $HTTP6PIDFILE;
|
|
|
|
$port = $HTTP6PORT;
|
|
|
|
$ip = $HOST6IP;
|
|
|
|
$nameext="-ipv6";
|
|
|
|
}
|
|
|
|
|
|
|
|
$pid = checkserver($pidfile);
|
2002-02-25 07:45:20 -05:00
|
|
|
|
2005-04-28 09:54:48 -04:00
|
|
|
if($pid <= 0 ) {
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2005-04-28 09:54:48 -04:00
|
|
|
# verify if our/any server is running on this port
|
|
|
|
$cmd = "$CURL -o log/verifiedserver -g \"http://$ip:$port/verifiedserver\" 2>log/verifyhttp";
|
|
|
|
print "CMD; $cmd\n" if ($verbose);
|
|
|
|
my $res = system($cmd);
|
2002-02-22 10:40:17 -05:00
|
|
|
|
2005-04-28 09:54:48 -04:00
|
|
|
$res >>= 8; # rotate the result
|
|
|
|
my $data;
|
|
|
|
|
|
|
|
if($res && $verbose) {
|
|
|
|
open(ERR, "<log/verifystderr");
|
|
|
|
my @e = <ERR>;
|
|
|
|
close(ERR);
|
|
|
|
print "RUN: curl command returned $res\n";
|
|
|
|
for(@e) {
|
|
|
|
if($_ !~ /^([ \t]*)$/) {
|
|
|
|
print "RUN: $_";
|
|
|
|
}
|
2004-12-16 04:52:36 -05:00
|
|
|
}
|
|
|
|
}
|
2005-04-28 09:54:48 -04:00
|
|
|
open(FILE, "<log/verifiedserver");
|
|
|
|
my @file=<FILE>;
|
|
|
|
close(FILE);
|
|
|
|
$data=$file[0]; # first line
|
2003-03-15 11:43:58 -05:00
|
|
|
|
2005-04-28 09:54:48 -04:00
|
|
|
if ( $data =~ /WE ROOLZ: (\d+)/ ) {
|
|
|
|
$pid = 0+$1;
|
|
|
|
}
|
|
|
|
elsif($res == 6) {
|
|
|
|
# curl: (6) Couldn't resolve host '::1'
|
|
|
|
print "RUN: failed to resolve host\n";
|
|
|
|
return -3;
|
|
|
|
}
|
|
|
|
elsif($data || ($res != 7)) {
|
|
|
|
print "RUN: Unknown server is running on port $port\n";
|
|
|
|
return -2;
|
|
|
|
}
|
2001-10-17 07:51:02 -04:00
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2002-02-28 07:36:25 -05:00
|
|
|
if($pid > 0) {
|
2001-10-17 07:51:02 -04:00
|
|
|
my $res = kill (9, $pid); # die!
|
|
|
|
if(!$res) {
|
2004-12-11 16:41:00 -05:00
|
|
|
print "RUN: Failed to kill test HTTP$nameext server, do it ",
|
|
|
|
"manually and restart the tests.\n";
|
2005-04-28 17:04:58 -04:00
|
|
|
stopservers($verbose);
|
2000-11-13 11:06:16 -05:00
|
|
|
exit;
|
|
|
|
}
|
2003-03-15 11:43:58 -05:00
|
|
|
sleep(1);
|
2001-10-17 07:51:02 -04:00
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2001-10-17 07:51:02 -04:00
|
|
|
my $flag=$debugprotocol?"-v ":"";
|
2004-02-12 09:40:08 -05:00
|
|
|
my $dir=$ENV{'srcdir'};
|
|
|
|
if($dir) {
|
|
|
|
$flag .= "-d \"$dir\" ";
|
|
|
|
}
|
2005-05-01 09:20:53 -04:00
|
|
|
$cmd="$perl $srcdir/httpserver.pl -p $pidfile $flag $port $ipv6";
|
|
|
|
my $httppid = startnew($cmd); # start the server in a new process
|
2005-04-28 09:54:48 -04:00
|
|
|
|
2005-05-01 09:20:53 -04:00
|
|
|
if(!kill(0, $httppid)) {
|
|
|
|
# it is NOT alive
|
|
|
|
print "RUN: failed to start the HTTP server!\n";
|
|
|
|
stopservers($verbose);
|
|
|
|
exit;
|
2003-03-15 11:43:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
if($verbose) {
|
2005-05-01 09:20:53 -04:00
|
|
|
print "RUN: HTTP$nameext server is now running PID $httppid\n";
|
2003-03-15 11:43:58 -05:00
|
|
|
}
|
|
|
|
|
2005-05-01 09:20:53 -04:00
|
|
|
sleep(1);
|
|
|
|
|
|
|
|
return $httppid;
|
2000-11-13 11:06:16 -05:00
|
|
|
}
|
|
|
|
|
2001-04-24 17:09:53 -04:00
|
|
|
#######################################################################
|
2005-05-01 09:20:53 -04:00
|
|
|
# start the https server (or rather, tunnel)
|
2001-04-24 17:09:53 -04:00
|
|
|
#
|
|
|
|
sub runhttpsserver {
|
2000-11-21 10:48:40 -05:00
|
|
|
my $verbose = $_[0];
|
|
|
|
my $STATUS;
|
|
|
|
my $RUNNING;
|
2001-04-24 17:09:53 -04:00
|
|
|
|
2003-10-29 11:27:43 -05:00
|
|
|
if(!$stunnel) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-28 02:50:42 -04:00
|
|
|
my $pid=checkserver($HTTPSPIDFILE);
|
2004-01-12 09:34:48 -05:00
|
|
|
|
2003-06-13 05:04:08 -04:00
|
|
|
if($pid > 0) {
|
2001-04-24 17:09:53 -04:00
|
|
|
# kill previous stunnel!
|
2005-05-01 09:20:53 -04:00
|
|
|
stopserver($pid);
|
2000-11-21 10:48:40 -05:00
|
|
|
}
|
2001-04-24 17:09:53 -04:00
|
|
|
|
|
|
|
my $flag=$debugprotocol?"-v ":"";
|
2005-05-01 09:20:53 -04:00
|
|
|
my $cmd="$perl $srcdir/httpsserver.pl $flag -s \"$stunnel\" -d $srcdir -r $HTTPPORT $HTTPSPORT";
|
2004-01-12 09:34:48 -05:00
|
|
|
|
2005-05-01 09:20:53 -04:00
|
|
|
my $httpspid = startnew($cmd);
|
2005-03-16 17:02:09 -05:00
|
|
|
|
|
|
|
|
2005-05-01 09:20:53 -04:00
|
|
|
if(!kill(0, $httpspid)) {
|
|
|
|
# it is NOT alive
|
|
|
|
print "RUN: failed to start the HTTPS server!\n";
|
|
|
|
stopservers($verbose);
|
|
|
|
exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
if($verbose) {
|
|
|
|
print "RUN: HTTPS server is now running PID $httpspid\n";
|
2004-01-12 09:34:48 -05:00
|
|
|
}
|
2003-06-13 05:04:08 -04:00
|
|
|
|
2005-05-01 09:20:53 -04:00
|
|
|
sleep(1);
|
|
|
|
|
|
|
|
return $httpspid;
|
2001-04-24 17:09:53 -04:00
|
|
|
}
|
|
|
|
|
2005-04-18 02:57:44 -04:00
|
|
|
|
2001-04-24 17:09:53 -04:00
|
|
|
#######################################################################
|
2005-05-01 09:20:53 -04:00
|
|
|
# start the ftp server
|
2001-04-24 17:09:53 -04:00
|
|
|
#
|
|
|
|
sub runftpserver {
|
2005-04-18 02:57:44 -04:00
|
|
|
my ($id, $verbose, $ipv6) = @_;
|
2001-04-24 17:09:53 -04:00
|
|
|
my $STATUS;
|
|
|
|
my $RUNNING;
|
2005-01-17 15:20:34 -05:00
|
|
|
my $port = $id?$FTP2PORT:$FTPPORT;
|
2001-04-24 17:09:53 -04:00
|
|
|
# check for pidfile
|
2005-04-18 02:57:44 -04:00
|
|
|
my $pidfile = $id?$FTP2PIDFILE:$FTPPIDFILE;
|
|
|
|
my $ip=$HOSTIP;
|
|
|
|
my $nameext;
|
|
|
|
|
|
|
|
if($ipv6) {
|
|
|
|
# if IPv6, use a different setup
|
|
|
|
$pidfile = $FTP6PIDFILE;
|
|
|
|
$port = $FTP6PORT;
|
|
|
|
$ip = $HOST6IP;
|
|
|
|
$nameext="-ipv6";
|
|
|
|
}
|
|
|
|
|
2005-04-28 02:50:42 -04:00
|
|
|
my $pid = checkserver($pidfile);
|
2000-11-21 10:48:40 -05:00
|
|
|
|
2001-04-24 17:09:53 -04:00
|
|
|
if ($pid <= 0) {
|
2005-04-18 02:57:44 -04:00
|
|
|
print "RUN: Check port $port for the FTP$id$nameext server\n"
|
2003-03-15 11:43:58 -05:00
|
|
|
if ($verbose);
|
2001-05-14 08:09:47 -04:00
|
|
|
|
2003-03-15 11:43:58 -05:00
|
|
|
my $time=time();
|
2005-05-01 09:20:53 -04:00
|
|
|
my $cmd="$CURL -m4 --silent -vg \"ftp://$ip:$port/verifiedserver\" 2>log/verifyftp";
|
2003-03-15 11:43:58 -05:00
|
|
|
# check if this is our server running on this port:
|
2005-05-01 09:20:53 -04:00
|
|
|
my @data=`$cmd`;
|
|
|
|
print "RUN: $cmd\n" if($verbose);
|
2004-05-17 03:59:10 -04:00
|
|
|
my $line;
|
2001-05-14 08:09:47 -04:00
|
|
|
|
2003-03-15 11:43:58 -05:00
|
|
|
# if this took more than 2 secs, we assume it "hung" on a weird server
|
|
|
|
my $took = time()-$time;
|
2004-05-17 03:59:10 -04:00
|
|
|
|
|
|
|
foreach $line (@data) {
|
|
|
|
if ( $line =~ /WE ROOLZ: (\d+)/ ) {
|
|
|
|
# this is our test server with a known pid!
|
|
|
|
$pid = 0+$1;
|
2003-03-15 11:43:58 -05:00
|
|
|
}
|
2001-04-24 17:09:53 -04:00
|
|
|
}
|
2005-05-01 09:20:53 -04:00
|
|
|
if($pid <= 0 && $data[0]) {
|
2004-05-17 03:59:10 -04:00
|
|
|
# this is not a known server
|
2005-04-18 02:57:44 -04:00
|
|
|
print "RUN: Unknown server on our favourite FTP$nameext port: $port\n";
|
2004-05-17 03:59:10 -04:00
|
|
|
return -1;
|
|
|
|
}
|
2000-11-21 10:48:40 -05:00
|
|
|
}
|
2003-03-15 11:43:58 -05:00
|
|
|
|
|
|
|
if($pid > 0) {
|
|
|
|
print "RUN: Killing a previous server using pid $pid\n" if($verbose);
|
2005-05-01 09:20:53 -04:00
|
|
|
my $res = kill(9, $pid); # die!
|
2003-03-15 11:43:58 -05:00
|
|
|
if(!$res) {
|
2005-04-18 02:57:44 -04:00
|
|
|
print "RUN: Failed to kill FTP$id$nameext test server, do it manually and",
|
2003-03-15 11:43:58 -05:00
|
|
|
" restart the tests.\n";
|
2003-06-13 05:04:08 -04:00
|
|
|
return -1;
|
2001-04-24 17:09:53 -04:00
|
|
|
}
|
2003-03-15 11:43:58 -05:00
|
|
|
}
|
2005-05-01 09:20:53 -04:00
|
|
|
ftpkillslaves($verbose);
|
2004-05-17 06:53:34 -04:00
|
|
|
|
2003-03-15 11:43:58 -05:00
|
|
|
# now (re-)start our server:
|
|
|
|
my $flag=$debugprotocol?"-v ":"";
|
2005-01-17 15:20:34 -05:00
|
|
|
$flag .= "-s \"$srcdir\" ";
|
|
|
|
if($id) {
|
|
|
|
$flag .="--id $id ";
|
|
|
|
}
|
2005-04-18 02:57:44 -04:00
|
|
|
if($ipv6) {
|
|
|
|
$flag .="--ipv6 ";
|
|
|
|
}
|
2005-05-02 06:22:09 -04:00
|
|
|
my $cmd="$perl $srcdir/ftpserver.pl --pidfile $pidfile $flag --port $port";
|
2000-11-21 10:48:40 -05:00
|
|
|
|
2005-05-01 09:20:53 -04:00
|
|
|
my $ftppid = startnew($cmd);
|
|
|
|
|
2005-05-02 05:08:44 -04:00
|
|
|
if(!$ftppid || !kill(0, $ftppid)) {
|
2005-05-01 09:20:53 -04:00
|
|
|
# it is NOT alive
|
|
|
|
print "RUN: failed to start the FTP$id$nameext server!\n";
|
2005-05-02 05:08:44 -04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
# Make sure there is a pidfile present before we proceed. Because if we
|
|
|
|
# don't see one within a few secs, the server doesn't work. This mostly
|
|
|
|
# happens when the server finds out it cannot use the ipv6 protocol.
|
|
|
|
my $count=3;
|
|
|
|
while(! -f $pidfile) {
|
|
|
|
if(!$count--) {
|
|
|
|
print "RUN: failed starting FTP$id$nameext server (no pidfile)!\n";
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
sleep(1);
|
2003-03-15 11:43:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
if($verbose) {
|
2005-05-01 09:20:53 -04:00
|
|
|
print "RUN: FTP$id$nameext server is now running PID $ftppid\n";
|
2003-03-15 11:43:58 -05:00
|
|
|
}
|
|
|
|
|
2005-05-01 09:20:53 -04:00
|
|
|
sleep(1);
|
|
|
|
|
|
|
|
return $ftppid;
|
2001-04-24 17:09:53 -04:00
|
|
|
}
|
|
|
|
|
2000-11-14 05:18:44 -05:00
|
|
|
#######################################################################
|
|
|
|
# Remove all files in the specified directory
|
|
|
|
#
|
|
|
|
sub cleardir {
|
|
|
|
my $dir = $_[0];
|
|
|
|
my $count;
|
2000-11-15 02:09:37 -05:00
|
|
|
my $file;
|
2000-11-14 05:18:44 -05: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 11:06:16 -05: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);
|
2004-05-17 06:53:34 -04:00
|
|
|
close(OUT);
|
2000-11-13 11:06:16 -05:00
|
|
|
return 0;
|
|
|
|
}
|
2000-11-14 05:18:44 -05: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 11:06:16 -05:00
|
|
|
sub compare {
|
2001-05-28 11:26:15 -04:00
|
|
|
# filter off patterns _before_ this comparison!
|
2003-04-30 13:15:38 -04:00
|
|
|
my ($subject, $firstref, $secondref)=@_;
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
my $result = compareparts($firstref, $secondref);
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2003-04-30 13:15:38 -04:00
|
|
|
if($result) {
|
|
|
|
if(!$short) {
|
|
|
|
print "\n $subject FAILED:\n";
|
2004-11-30 04:53:53 -05:00
|
|
|
print showdiff($LOGDIR, $firstref, $secondref);
|
2003-04-30 13:15:38 -04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
print "FAILED\n";
|
|
|
|
}
|
2000-11-17 10:15:48 -05:00
|
|
|
}
|
2001-05-23 11:02:58 -04:00
|
|
|
return $result;
|
2000-11-13 11:06:16 -05:00
|
|
|
}
|
|
|
|
|
2000-11-14 05:18:44 -05:00
|
|
|
#######################################################################
|
|
|
|
# display information about curl and the host the test suite runs on
|
|
|
|
#
|
2005-04-28 17:04:58 -04:00
|
|
|
sub checksystem {
|
2000-11-17 10:07:29 -05:00
|
|
|
|
|
|
|
unlink($memdump); # remove this if there was one left
|
|
|
|
|
2004-11-26 03:41:39 -05:00
|
|
|
my $feat;
|
2003-06-26 07:44:01 -04:00
|
|
|
my $curl;
|
|
|
|
my $libcurl;
|
2004-05-11 14:57:03 -04:00
|
|
|
my @version=`$CURL --version 2>/dev/null`;
|
2003-06-26 07:44:01 -04:00
|
|
|
for(@version) {
|
|
|
|
chomp;
|
2001-04-26 04:32:12 -04:00
|
|
|
|
2003-06-26 07:44:01 -04:00
|
|
|
if($_ =~ /^curl/) {
|
|
|
|
$curl = $_;
|
|
|
|
$curl =~ s/^(.*)(libcurl.*)/$1/g;
|
2005-04-27 05:59:29 -04:00
|
|
|
|
2003-06-26 07:44:01 -04:00
|
|
|
$libcurl = $2;
|
2004-03-29 04:26:31 -05:00
|
|
|
if($curl =~ /mingw32/) {
|
|
|
|
# This is a windows minw32 build, we need to translate the
|
|
|
|
# given path to the "actual" windows path.
|
|
|
|
|
|
|
|
my @m = `mount`;
|
|
|
|
my $matchlen;
|
|
|
|
my $bestmatch;
|
|
|
|
my $mount;
|
|
|
|
|
|
|
|
# example mount output:
|
|
|
|
# C:\DOCUME~1\Temp on /tmp type user (binmode,noumount)
|
|
|
|
# c:\ActiveState\perl on /perl type user (binmode)
|
|
|
|
# C:\msys\1.0\bin on /usr/bin type user (binmode,cygexec,noumount)
|
|
|
|
# C:\msys\1.0\bin on /bin type user (binmode,cygexec,noumount)
|
|
|
|
|
|
|
|
foreach $mount (@m) {
|
|
|
|
if( $mount =~ /(.*) on ([^ ]*) type /) {
|
|
|
|
my ($mingw, $real)=($2, $1);
|
|
|
|
if($pwd =~ /^$mingw/) {
|
|
|
|
# the path we got from pwd starts with the path
|
|
|
|
# we found on this line in the mount output
|
|
|
|
|
|
|
|
my $len = length($real);
|
|
|
|
if($len > $matchlen) {
|
|
|
|
# we remember the match that is the longest
|
|
|
|
$matchlen = $len;
|
|
|
|
$bestmatch = $real;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(!$matchlen) {
|
|
|
|
print "Serious error, can't find our \"real\" path!\n";
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
# now prepend the prefix from the mount command to build
|
|
|
|
# our "actual path"
|
|
|
|
$pwd = "$bestmatch$pwd";
|
|
|
|
}
|
|
|
|
$pwd =~ s#\\#/#g;
|
|
|
|
}
|
2005-04-12 03:18:48 -04:00
|
|
|
elsif ($curl =~ /win32/) {
|
2003-08-12 17:18:39 -04:00
|
|
|
# Native Windows builds don't understand the
|
|
|
|
# output of cygwin's pwd. It will be
|
|
|
|
# something like /cygdrive/c/<some path>.
|
|
|
|
#
|
|
|
|
# Use the cygpath utility to convert the
|
|
|
|
# working directory to a Windows friendly
|
|
|
|
# path. The -m option converts to use drive
|
|
|
|
# letter:, but it uses / instead \. Forward
|
|
|
|
# slashes (/) are easier for us. We don't
|
|
|
|
# have to escape them to get them to curl
|
|
|
|
# through a shell.
|
|
|
|
chomp($pwd = `cygpath -m $pwd`);
|
|
|
|
}
|
2005-04-27 05:59:29 -04:00
|
|
|
elsif ($libcurl =~ /openssl/i) {
|
2005-04-12 03:18:48 -04:00
|
|
|
# OpenSSL in use
|
|
|
|
$has_openssl=1;
|
|
|
|
}
|
2005-04-27 05:59:29 -04:00
|
|
|
elsif ($libcurl =~ /gnutls/i) {
|
2005-04-12 03:18:48 -04:00
|
|
|
# GnuTLS in use
|
|
|
|
$has_gnutls=1;
|
|
|
|
}
|
2003-06-26 07:44:01 -04:00
|
|
|
}
|
|
|
|
elsif($_ =~ /^Protocols: (.*)/i) {
|
|
|
|
# these are the supported protocols, we don't use this knowledge
|
|
|
|
# at this point
|
|
|
|
}
|
|
|
|
elsif($_ =~ /^Features: (.*)/i) {
|
2004-11-26 03:41:39 -05:00
|
|
|
$feat = $1;
|
2003-06-26 07:44:01 -04:00
|
|
|
if($feat =~ /debug/i) {
|
|
|
|
# debug is a listed "feature", use that knowledge
|
|
|
|
$curl_debug = 1;
|
|
|
|
# set the NETRC debug env
|
|
|
|
$ENV{'CURL_DEBUG_NETRC'} = 'log/netrc';
|
|
|
|
}
|
|
|
|
if($feat =~ /SSL/i) {
|
|
|
|
# ssl enabled
|
|
|
|
$ssl_version=1;
|
|
|
|
}
|
2004-03-01 11:24:54 -05:00
|
|
|
if($feat =~ /Largefile/i) {
|
|
|
|
# large file support
|
|
|
|
$large_file=1;
|
|
|
|
}
|
2004-04-30 04:03:07 -04:00
|
|
|
if($feat =~ /IDN/i) {
|
|
|
|
# IDN support
|
|
|
|
$has_idn=1;
|
|
|
|
}
|
2004-11-25 17:21:49 -05:00
|
|
|
if($feat =~ /IPv6/i) {
|
|
|
|
$has_ipv6 = 1;
|
|
|
|
}
|
2004-11-29 07:23:02 -05:00
|
|
|
if($feat =~ /libz/i) {
|
|
|
|
$has_libz = 1;
|
|
|
|
}
|
2005-03-21 03:14:32 -05:00
|
|
|
if($feat =~ /NTLM/i) {
|
|
|
|
# NTLM enabled
|
|
|
|
$has_ntlm=1;
|
|
|
|
}
|
2003-06-26 07:44:01 -04:00
|
|
|
}
|
|
|
|
}
|
2004-02-12 09:40:08 -05:00
|
|
|
if(!$curl) {
|
2004-05-11 07:30:23 -04:00
|
|
|
die "couldn't run '$CURL'"
|
2004-02-12 09:40:08 -05:00
|
|
|
}
|
2001-04-26 04:32:12 -04:00
|
|
|
|
2004-11-22 17:26:46 -05:00
|
|
|
if(-r "../lib/config.h") {
|
|
|
|
open(CONF, "<../lib/config.h");
|
|
|
|
while(<CONF>) {
|
|
|
|
if($_ =~ /^\#define HAVE_GETRLIMIT/) {
|
|
|
|
$has_getrlimit = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
close(CONF);
|
|
|
|
}
|
|
|
|
|
2004-12-11 16:41:00 -05:00
|
|
|
if($has_ipv6) {
|
2005-04-18 02:57:44 -04:00
|
|
|
# client has ipv6 support
|
|
|
|
|
|
|
|
# check if the HTTP server has it!
|
2004-12-11 16:41:00 -05:00
|
|
|
my @sws = `server/sws --version`;
|
|
|
|
if($sws[0] =~ /IPv6/) {
|
|
|
|
# HTTP server has ipv6 support!
|
|
|
|
$http_ipv6 = 1;
|
|
|
|
}
|
2005-04-18 02:57:44 -04:00
|
|
|
|
|
|
|
# check if the FTP server has it!
|
2005-04-28 04:23:25 -04:00
|
|
|
@sws = `server/sockfilt --version`;
|
2005-04-18 02:57:44 -04:00
|
|
|
if($sws[0] =~ /IPv6/) {
|
|
|
|
# FTP server has ipv6 support!
|
|
|
|
$ftp_ipv6 = 1;
|
|
|
|
}
|
2004-12-11 16:41:00 -05:00
|
|
|
}
|
|
|
|
|
2004-06-14 04:25:54 -04:00
|
|
|
if(!$curl_debug && $torture) {
|
|
|
|
die "can't run torture tests since curl was not build with debug";
|
|
|
|
}
|
|
|
|
|
2000-11-13 11:06:16 -05:00
|
|
|
my $hostname=`hostname`;
|
|
|
|
my $hosttype=`uname -a`;
|
|
|
|
|
2001-04-24 17:09:53 -04:00
|
|
|
print "********* System characteristics ******** \n",
|
2001-04-26 04:32:12 -04:00
|
|
|
"* $curl\n",
|
|
|
|
"* $libcurl\n",
|
2004-11-26 03:41:39 -05:00
|
|
|
"* Features: $feat\n",
|
2000-11-17 10:15:48 -05:00
|
|
|
"* Host: $hostname",
|
|
|
|
"* System: $hosttype";
|
2000-11-17 10:07:29 -05:00
|
|
|
|
2004-12-11 16:41:00 -05:00
|
|
|
printf("* Server SSL: %s\n", $stunnel?"ON":"OFF");
|
|
|
|
printf("* libcurl SSL: %s\n", $ssl_version?"ON":"OFF");
|
|
|
|
printf("* libcurl debug: %s\n", $curl_debug?"ON":"OFF");
|
|
|
|
printf("* valgrind: %s\n", $valgrind?"ON":"OFF");
|
|
|
|
printf("* HTTP IPv6 %s\n", $http_ipv6?"ON":"OFF");
|
2005-04-18 02:57:44 -04:00
|
|
|
printf("* FTP IPv6 %s\n", $ftp_ipv6?"ON":"OFF");
|
2004-12-11 16:41:00 -05:00
|
|
|
|
|
|
|
printf("* HTTP port: %d\n", $HTTPPORT);
|
|
|
|
printf("* FTP port: %d\n", $FTPPORT);
|
2005-01-17 15:20:34 -05:00
|
|
|
printf("* FTP port 2: %d\n", $FTP2PORT);
|
2004-09-08 04:08:38 -04:00
|
|
|
if($stunnel) {
|
2005-04-28 04:23:25 -04:00
|
|
|
#printf("* FTPS port: %d\n", $FTPSPORT);
|
2004-12-11 16:41:00 -05:00
|
|
|
printf("* HTTPS port: %d\n", $HTTPSPORT);
|
|
|
|
}
|
|
|
|
if($http_ipv6) {
|
|
|
|
printf("* HTTP IPv6 port: %d\n", $HTTP6PORT);
|
2004-09-08 04:08:38 -04:00
|
|
|
}
|
2005-04-18 02:57:44 -04:00
|
|
|
if($ftp_ipv6) {
|
|
|
|
printf("* FTP IPv6 port: %d\n", $FTP6PORT);
|
|
|
|
}
|
2005-04-27 05:59:29 -04:00
|
|
|
|
|
|
|
if($ssl_version) {
|
|
|
|
printf("* SSL library: %s\n",
|
|
|
|
$has_gnutls?"GnuTLS":($has_openssl?"OpenSSL":"<unknown>"));
|
|
|
|
}
|
|
|
|
|
2005-04-28 17:04:58 -04:00
|
|
|
$has_textaware = ($^O eq 'MSWin32') || ($^O eq 'msys');
|
|
|
|
|
2001-04-24 17:09:53 -04:00
|
|
|
print "***************************************** \n";
|
2000-11-13 11:06:16 -05:00
|
|
|
}
|
|
|
|
|
2002-05-21 18:20:52 -04:00
|
|
|
#######################################################################
|
2004-05-17 06:53:34 -04:00
|
|
|
# substitute the variable stuff into either a joined up file or
|
2002-05-21 18:20:52 -04:00
|
|
|
# a command, in either case passed by reference
|
|
|
|
#
|
|
|
|
sub subVariables {
|
|
|
|
my ($thing) = @_;
|
|
|
|
$$thing =~ s/%HOSTIP/$HOSTIP/g;
|
2004-09-08 04:08:38 -04:00
|
|
|
$$thing =~ s/%HTTPPORT/$HTTPPORT/g;
|
2004-12-11 16:41:00 -05:00
|
|
|
$$thing =~ s/%HOST6IP/$HOST6IP/g;
|
|
|
|
$$thing =~ s/%HTTP6PORT/$HTTP6PORT/g;
|
2002-05-21 18:20:52 -04:00
|
|
|
$$thing =~ s/%HTTPSPORT/$HTTPSPORT/g;
|
|
|
|
$$thing =~ s/%FTPPORT/$FTPPORT/g;
|
2005-04-18 02:57:44 -04:00
|
|
|
$$thing =~ s/%FTP6PORT/$FTP6PORT/g;
|
2005-01-17 15:20:34 -05:00
|
|
|
$$thing =~ s/%FTP2PORT/$FTP2PORT/g;
|
2002-05-21 18:20:52 -04:00
|
|
|
$$thing =~ s/%FTPSPORT/$FTPSPORT/g;
|
|
|
|
$$thing =~ s/%SRCDIR/$srcdir/g;
|
|
|
|
$$thing =~ s/%PWD/$pwd/g;
|
|
|
|
}
|
|
|
|
|
2004-09-08 04:08:38 -04:00
|
|
|
sub fixarray {
|
|
|
|
my @in = @_;
|
|
|
|
|
|
|
|
for(@in) {
|
|
|
|
subVariables \$_;
|
|
|
|
}
|
|
|
|
return @in;
|
|
|
|
}
|
|
|
|
|
2000-11-14 05:18:44 -05:00
|
|
|
#######################################################################
|
|
|
|
# Run a single specified test case
|
|
|
|
#
|
|
|
|
|
2000-11-13 11:06:16 -05:00
|
|
|
sub singletest {
|
2005-04-22 07:51:06 -04:00
|
|
|
my ($testnum, $count, $total)=@_;
|
2001-05-23 11:02:58 -04:00
|
|
|
|
2003-06-26 07:44:01 -04:00
|
|
|
my @what;
|
|
|
|
my $why;
|
2005-01-30 07:56:36 -05:00
|
|
|
my %feature;
|
2003-06-26 07:44:01 -04:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
# load the test case file definition
|
|
|
|
if(loadtest("${TESTDIR}/test${testnum}")) {
|
|
|
|
if($verbose) {
|
|
|
|
# this is not a test
|
2003-03-15 11:43:58 -05:00
|
|
|
print "RUN: $testnum doesn't look like a test case!\n";
|
2001-05-23 11:02:58 -04:00
|
|
|
}
|
2004-12-16 09:18:11 -05:00
|
|
|
$why = "no test";
|
2003-06-26 07:44:01 -04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
@what = getpart("client", "features");
|
2001-05-23 11:02:58 -04:00
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2003-06-12 12:38:14 -04:00
|
|
|
for(@what) {
|
|
|
|
my $f = $_;
|
|
|
|
$f =~ s/\s//g;
|
|
|
|
|
2005-01-30 07:56:36 -05:00
|
|
|
$feature{$f}=$f; # we require this feature
|
|
|
|
|
2003-06-12 12:38:14 -04:00
|
|
|
if($f eq "SSL") {
|
|
|
|
if($ssl_version) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
2005-04-12 03:18:48 -04:00
|
|
|
elsif($f eq "OpenSSL") {
|
|
|
|
if($has_openssl) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
elsif($f eq "GnuTLS") {
|
|
|
|
if($has_gnutls) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
2003-06-12 12:38:14 -04:00
|
|
|
elsif($f eq "netrc_debug") {
|
2003-06-26 07:44:01 -04:00
|
|
|
if($curl_debug) {
|
2003-06-12 12:38:14 -04:00
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
2004-03-01 11:24:54 -05:00
|
|
|
elsif($f eq "large_file") {
|
|
|
|
if($large_file) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
2004-04-30 04:03:07 -04:00
|
|
|
elsif($f eq "idn") {
|
|
|
|
if($has_idn) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
2004-11-25 17:21:49 -05:00
|
|
|
elsif($f eq "ipv6") {
|
|
|
|
if($has_ipv6) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
2004-11-29 07:23:02 -05:00
|
|
|
elsif($f eq "libz") {
|
|
|
|
if($has_libz) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
2005-03-21 03:14:32 -05:00
|
|
|
elsif($f eq "NTLM") {
|
|
|
|
if($has_ntlm) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
2004-11-22 17:26:46 -05:00
|
|
|
elsif($f eq "getrlimit") {
|
|
|
|
if($has_getrlimit) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
2003-06-12 12:38:14 -04:00
|
|
|
|
2004-01-12 09:34:48 -05:00
|
|
|
$why = "curl lacks $f support";
|
2003-06-26 07:44:01 -04:00
|
|
|
last;
|
2003-06-12 12:38:14 -04:00
|
|
|
}
|
|
|
|
|
2004-12-16 09:18:11 -05:00
|
|
|
if(!$why) {
|
|
|
|
$why = serverfortest($testnum);
|
2003-06-26 07:44:01 -04:00
|
|
|
}
|
2003-01-27 08:51:35 -05:00
|
|
|
|
2004-12-16 09:18:11 -05:00
|
|
|
if(!$why) {
|
2004-11-23 04:50:16 -05:00
|
|
|
my @precheck = getpart("client", "precheck");
|
|
|
|
my $cmd = $precheck[0];
|
|
|
|
chomp $cmd;
|
|
|
|
if($cmd) {
|
|
|
|
my @o = `$cmd 2>/dev/null`;
|
|
|
|
if($o[0]) {
|
|
|
|
$why = $o[0];
|
|
|
|
chomp $why;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-12-16 09:18:11 -05:00
|
|
|
if($why) {
|
|
|
|
# there's a problem, count it as "skipped"
|
2003-06-26 07:44:01 -04:00
|
|
|
$skipped++;
|
|
|
|
$skipped{$why}++;
|
|
|
|
$teststat[$testnum]=$why; # store reason for this test case
|
2004-05-17 06:53:34 -04:00
|
|
|
|
2003-06-26 07:44:01 -04:00
|
|
|
if(!$short) {
|
2004-12-16 09:18:11 -05:00
|
|
|
printf "test %03d SKIPPED: $why\n", $testnum;
|
2003-06-26 07:44:01 -04:00
|
|
|
}
|
|
|
|
|
2003-01-27 08:51:35 -05:00
|
|
|
return -1;
|
|
|
|
}
|
2004-12-16 09:18:11 -05:00
|
|
|
printf("test %03d...", $testnum);
|
|
|
|
|
2003-01-27 08:51:35 -05:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
# extract the reply data
|
|
|
|
my @reply = getpart("reply", "data");
|
|
|
|
my @replycheck = getpart("reply", "datacheck");
|
|
|
|
|
|
|
|
if (@replycheck) {
|
2000-11-13 11:06:16 -05:00
|
|
|
# we use this file instead to check the final output against
|
2002-06-11 11:11:41 -04: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]);
|
|
|
|
}
|
2004-05-17 06:53:34 -04:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
@reply=@replycheck;
|
2000-11-13 11:06:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
# curl command to run
|
2004-09-08 04:08:38 -04:00
|
|
|
my @curlcmd= fixarray ( getpart("client", "command") );
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
# this is the valid protocol blurb curl should generate
|
2004-09-08 04:08:38 -04:00
|
|
|
my @protocol= fixarray ( getpart("verify", "protocol") );
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
# redirected stdout/stderr to these files
|
|
|
|
$STDOUT="$LOGDIR/stdout$testnum";
|
|
|
|
$STDERR="$LOGDIR/stderr$testnum";
|
2000-11-21 14:28:11 -05:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
# if this section exists, we verify that the stdout contained this:
|
2004-09-08 04:08:38 -04:00
|
|
|
my @validstdout = fixarray ( getpart("verify", "stdout") );
|
2000-11-21 14:28:11 -05:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
# if this section exists, we verify upload
|
|
|
|
my @upload = getpart("verify", "upload");
|
2000-11-21 14:28:11 -05:00
|
|
|
|
2005-04-14 18:52:08 -04:00
|
|
|
# if this section exists, it might be FTP server instructions:
|
|
|
|
my @ftpservercmd = getpart("reply", "servercmd");
|
2000-11-27 07:53:50 -05:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
my $CURLOUT="$LOGDIR/curl$testnum.out"; # curl output if not stdout
|
2000-11-21 14:28:11 -05:00
|
|
|
|
2000-11-13 11:06:16 -05:00
|
|
|
# name of the test
|
2001-05-23 11:02:58 -04:00
|
|
|
my @testname= getpart("client", "name");
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2000-11-14 05:18:44 -05:00
|
|
|
if(!$short) {
|
2001-05-23 11:02:58 -04:00
|
|
|
my $name = $testname[0];
|
|
|
|
$name =~ s/\n//g;
|
|
|
|
print "[$name]\n";
|
2000-11-14 05:18:44 -05:00
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2002-01-04 08:20:17 -05:00
|
|
|
if($listonly) {
|
|
|
|
return 0; # look successful
|
|
|
|
}
|
|
|
|
|
2002-12-12 07:20:06 -05:00
|
|
|
my @codepieces = getpart("client", "tool");
|
|
|
|
|
|
|
|
my $tool="";
|
|
|
|
if(@codepieces) {
|
|
|
|
$tool = $codepieces[0];
|
|
|
|
chomp $tool;
|
|
|
|
}
|
|
|
|
|
2005-01-20 17:48:43 -05:00
|
|
|
# remove server output logfiles
|
2002-01-04 08:20:17 -05:00
|
|
|
unlink($SERVERIN);
|
2005-01-20 17:48:43 -05:00
|
|
|
unlink($SERVER2IN);
|
2002-01-04 08:20:17 -05:00
|
|
|
|
|
|
|
if(@ftpservercmd) {
|
|
|
|
# write the instructions to file
|
|
|
|
writearray($FTPDCMD, \@ftpservercmd);
|
|
|
|
}
|
|
|
|
|
2003-05-19 09:06:10 -04:00
|
|
|
my (@setenv)= getpart("client", "setenv");
|
|
|
|
my @envs;
|
|
|
|
|
|
|
|
my $s;
|
|
|
|
for $s (@setenv) {
|
|
|
|
chomp $s; # cut off the newline
|
|
|
|
|
|
|
|
subVariables \$s;
|
|
|
|
|
|
|
|
if($s =~ /([^=]*)=(.*)/) {
|
|
|
|
my ($var, $content)=($1, $2);
|
|
|
|
$ENV{$var}=$content;
|
|
|
|
# remember which, so that we can clear them afterwards!
|
|
|
|
push @envs, $var;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-11-13 11:06:16 -05:00
|
|
|
# get the command line options to use
|
2001-05-23 11:02:58 -04:00
|
|
|
my ($cmd, @blaha)= getpart("client", "command");
|
2000-11-13 11:06:16 -05:00
|
|
|
|
|
|
|
# make some nice replace operations
|
2001-05-23 11:02:58 -04:00
|
|
|
$cmd =~ s/\n//g; # no newlines please
|
2002-05-21 18:20:52 -04:00
|
|
|
|
2003-08-06 19:10:36 -04:00
|
|
|
# substitute variables in the command line
|
2002-05-21 18:20:52 -04:00
|
|
|
subVariables \$cmd;
|
|
|
|
|
2003-06-26 07:44:01 -04:00
|
|
|
if($curl_debug) {
|
2000-11-17 10:07:29 -05:00
|
|
|
unlink($memdump);
|
|
|
|
}
|
|
|
|
|
2001-05-28 11:26:15 -04: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-21 18:20:52 -04:00
|
|
|
|
2001-05-28 11:26:15 -04:00
|
|
|
if(!$filename) {
|
|
|
|
print "ERROR: section client=>file has no name attribute!\n";
|
|
|
|
exit;
|
|
|
|
}
|
2002-05-21 18:20:52 -04:00
|
|
|
my $fileContent = join('', @inputfile);
|
|
|
|
subVariables \$fileContent;
|
|
|
|
# print "DEBUG: writing file " . $filename . "\n";
|
|
|
|
open OUTFILE, ">$filename";
|
2004-05-17 06:53:34 -04:00
|
|
|
binmode OUTFILE; # for crapage systems, use binary
|
2003-03-19 04:26:29 -05:00
|
|
|
print OUTFILE $fileContent;
|
2002-05-21 18:20:52 -04:00
|
|
|
close OUTFILE;
|
2001-05-28 11:26:15 -04:00
|
|
|
}
|
|
|
|
|
2002-01-08 04:32:41 -05:00
|
|
|
my %cmdhash = getpartattr("client", "command");
|
|
|
|
|
2000-11-17 10:07:29 -05:00
|
|
|
my $out="";
|
2002-01-08 04:32:41 -05:00
|
|
|
|
2003-08-06 19:10:36 -04:00
|
|
|
if($cmdhash{'option'} !~ /no-output/) {
|
|
|
|
#We may slap on --output!
|
2002-01-08 04:32:41 -05:00
|
|
|
if (!@validstdout) {
|
2002-12-12 11:46:45 -05:00
|
|
|
$out=" --output $CURLOUT ";
|
2002-01-08 04:32:41 -05:00
|
|
|
}
|
2000-11-17 10:07:29 -05:00
|
|
|
}
|
|
|
|
|
2002-12-12 07:20:06 -05:00
|
|
|
my $cmdargs;
|
|
|
|
if(!$tool) {
|
|
|
|
# run curl, add -v for debug information output
|
2002-12-13 11:24:57 -05:00
|
|
|
$cmdargs ="$out --include -v $cmd";
|
2002-12-12 07:20:06 -05:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
$cmdargs = " $cmd"; # $cmd is the command line for the test file
|
|
|
|
$CURLOUT = $STDOUT; # sends received data to stdout
|
|
|
|
}
|
2000-11-17 10:07:29 -05:00
|
|
|
|
2001-06-14 08:16:07 -04:00
|
|
|
my @stdintest = getpart("client", "stdin");
|
2001-05-23 11:02:58 -04:00
|
|
|
|
|
|
|
if(@stdintest) {
|
|
|
|
my $stdinfile="$LOGDIR/stdin-for-$testnum";
|
|
|
|
writearray($stdinfile, \@stdintest);
|
|
|
|
|
|
|
|
$cmdargs .= " <$stdinfile";
|
2000-11-17 10:07:29 -05:00
|
|
|
}
|
2002-12-12 07:20:06 -05:00
|
|
|
my $CMDLINE;
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2002-12-12 07:20:06 -05:00
|
|
|
if(!$tool) {
|
|
|
|
$CMDLINE="$CURL";
|
2000-11-13 11:06:16 -05:00
|
|
|
}
|
2002-12-12 07:20:06 -05:00
|
|
|
else {
|
|
|
|
$CMDLINE="$LIBDIR/$tool";
|
2002-12-12 08:42:21 -05:00
|
|
|
$DBGCURL=$CMDLINE;
|
2002-12-12 07:20:06 -05:00
|
|
|
}
|
|
|
|
|
2004-04-22 06:33:55 -04:00
|
|
|
if($valgrind) {
|
2005-01-29 08:06:31 -05:00
|
|
|
$CMDLINE = "valgrind ".$valgrind_tool."--leak-check=yes --num-callers=16 --logfile=log/valgrind$testnum $CMDLINE";
|
2004-04-22 06:33:55 -04:00
|
|
|
}
|
|
|
|
|
2003-08-06 19:10:36 -04:00
|
|
|
$CMDLINE .= "$cmdargs >>$STDOUT 2>>$STDERR";
|
2002-12-12 07:20:06 -05:00
|
|
|
|
|
|
|
if($verbose) {
|
2004-05-17 06:53:34 -04:00
|
|
|
print "$CMDLINE\n";
|
2004-04-13 01:57:50 -04:00
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2000-11-21 12:07:16 -05:00
|
|
|
print CMDLOG "$CMDLINE\n";
|
|
|
|
|
2004-04-30 04:03:07 -04:00
|
|
|
unlink("core");
|
|
|
|
|
|
|
|
my $dumped_core;
|
2003-12-17 10:33:04 -05:00
|
|
|
my $cmdres;
|
2004-05-10 05:01:45 -04:00
|
|
|
|
2004-06-17 04:06:03 -04:00
|
|
|
my @precommand= getpart("client", "precommand");
|
|
|
|
if($precommand[0]) {
|
|
|
|
# this is pure perl to eval!
|
|
|
|
my $code = join("", @precommand);
|
|
|
|
eval $code;
|
|
|
|
if($@) {
|
|
|
|
print "perl: $code\n";
|
|
|
|
print "precommand: $@";
|
2005-04-28 17:04:58 -04:00
|
|
|
stopservers($verbose);
|
2004-06-17 04:06:03 -04:00
|
|
|
exit;
|
|
|
|
}
|
|
|
|
}
|
2004-05-10 05:01:45 -04:00
|
|
|
|
2001-02-20 08:58:39 -05:00
|
|
|
if($gdbthis) {
|
|
|
|
open(GDBCMD, ">log/gdbcmd");
|
|
|
|
print GDBCMD "set args $cmdargs\n";
|
|
|
|
print GDBCMD "show args\n";
|
|
|
|
close(GDBCMD);
|
2004-05-10 05:01:45 -04:00
|
|
|
}
|
|
|
|
# run the command line we built
|
|
|
|
if ($torture) {
|
2004-05-13 03:52:33 -04:00
|
|
|
return torture($CMDLINE,
|
|
|
|
"gdb --directory libtest $DBGCURL -x log/gdbcmd");
|
2004-05-10 05:01:45 -04:00
|
|
|
}
|
|
|
|
elsif($gdbthis) {
|
2003-10-22 08:46:45 -04:00
|
|
|
system("gdb --directory libtest $DBGCURL -x log/gdbcmd");
|
2003-12-17 10:33:04 -05:00
|
|
|
$cmdres=0; # makes it always continue after a debugged run
|
2001-02-20 08:58:39 -05:00
|
|
|
}
|
|
|
|
else {
|
2003-12-17 10:33:04 -05:00
|
|
|
$cmdres = system("$CMDLINE");
|
|
|
|
my $signal_num = $cmdres & 127;
|
2004-04-30 04:03:07 -04:00
|
|
|
$dumped_core = $cmdres & 128;
|
2003-10-29 11:27:43 -05:00
|
|
|
|
|
|
|
if(!$anyway && ($signal_num || $dumped_core)) {
|
2003-12-17 10:33:04 -05:00
|
|
|
$cmdres = 1000;
|
2003-10-29 11:27:43 -05:00
|
|
|
}
|
|
|
|
else {
|
2003-12-17 10:33:04 -05:00
|
|
|
$cmdres /= 256;
|
2003-10-29 11:27:43 -05:00
|
|
|
}
|
2001-02-20 08:58:39 -05:00
|
|
|
}
|
2004-04-30 04:03:07 -04:00
|
|
|
if(!$dumped_core) {
|
|
|
|
if(-r "core") {
|
|
|
|
# there's core file present now!
|
|
|
|
$dumped_core = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if($dumped_core) {
|
|
|
|
print "core dumped!\n";
|
2004-05-05 16:12:59 -04:00
|
|
|
if(0 && $gdb) {
|
2004-04-30 04:03:07 -04:00
|
|
|
print "running gdb for post-mortem analysis:\n";
|
|
|
|
open(GDBCMD, ">log/gdbcmd2");
|
|
|
|
print GDBCMD "bt\n";
|
|
|
|
close(GDBCMD);
|
|
|
|
system("gdb --directory libtest -x log/gdbcmd2 -batch $DBGCURL core ");
|
|
|
|
# unlink("log/gdbcmd2");
|
|
|
|
}
|
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2001-11-29 15:15:59 -05:00
|
|
|
# remove the special FTP command file after each test!
|
|
|
|
unlink($FTPDCMD);
|
|
|
|
|
2003-05-19 09:06:10 -04:00
|
|
|
my $e;
|
|
|
|
for $e (@envs) {
|
|
|
|
$ENV{$e}=""; # clean up
|
|
|
|
}
|
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
my @err = getpart("verify", "errorcode");
|
2005-03-17 03:17:48 -05:00
|
|
|
my $errorcode = $err[0] || "0";
|
2005-04-22 07:51:06 -04:00
|
|
|
my $ok="";
|
2003-12-17 10:33:04 -05:00
|
|
|
my $res;
|
2001-05-23 11:02:58 -04:00
|
|
|
if (@validstdout) {
|
|
|
|
# verify redirected stdout
|
|
|
|
my @actual = loadarray($STDOUT);
|
2000-11-17 10:58:25 -05:00
|
|
|
|
2003-04-30 13:15:38 -04:00
|
|
|
$res = compare("stdout", \@actual, \@validstdout);
|
2001-05-23 11:02:58 -04:00
|
|
|
if($res) {
|
2000-11-17 10:58:25 -05:00
|
|
|
return 1;
|
|
|
|
}
|
2005-04-22 07:51:06 -04:00
|
|
|
$ok .= "s";
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$ok .= "-"; # stdout not checked
|
2000-11-13 11:06:16 -05:00
|
|
|
}
|
2001-05-23 11:02:58 -04:00
|
|
|
|
2001-06-14 08:16:07 -04:00
|
|
|
my %replyattr = getpartattr("reply", "data");
|
2004-08-23 10:40:43 -04:00
|
|
|
if(!$replyattr{'nocheck'} && (@reply || $replyattr{'sendzero'})) {
|
2001-05-23 11:02:58 -04:00
|
|
|
# verify the received data
|
|
|
|
my @out = loadarray($CURLOUT);
|
2003-04-30 13:15:38 -04:00
|
|
|
$res = compare("data", \@out, \@reply);
|
2001-05-23 11:02:58 -04:00
|
|
|
if ($res) {
|
2000-11-17 10:58:25 -05:00
|
|
|
return 1;
|
|
|
|
}
|
2005-04-22 07:51:06 -04:00
|
|
|
$ok .= "d";
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$ok .= "-"; # data not checked
|
2001-05-23 11:02:58 -04:00
|
|
|
}
|
2000-11-17 10:07:29 -05:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
if(@upload) {
|
|
|
|
# verify uploaded data
|
|
|
|
my @out = loadarray("$LOGDIR/upload.$testnum");
|
2003-04-30 13:15:38 -04:00
|
|
|
$res = compare("upload", \@out, \@upload);
|
2001-05-23 11:02:58 -04:00
|
|
|
if ($res) {
|
|
|
|
return 1;
|
2000-11-21 14:28:11 -05:00
|
|
|
}
|
2005-04-22 07:51:06 -04:00
|
|
|
$ok .= "u";
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$ok .= "-"; # upload not checked
|
2001-05-23 11:02:58 -04:00
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
if(@protocol) {
|
2004-06-22 03:09:47 -04:00
|
|
|
my @out;
|
|
|
|
my $retry = 5;
|
|
|
|
|
|
|
|
# Verify the sent request. Sometimes, like in test 513 on some hosts,
|
|
|
|
# curl will return back faster than the server writes down the request
|
|
|
|
# to its file, so we might need to wait here for a while to see if the
|
|
|
|
# file gets written a bit later.
|
|
|
|
|
|
|
|
while($retry--) {
|
|
|
|
@out = loadarray($SERVERIN);
|
|
|
|
|
|
|
|
if(!$out[0]) {
|
|
|
|
# nothing there yet, wait a while and try again
|
|
|
|
sleep(1);
|
|
|
|
}
|
|
|
|
}
|
2000-11-21 14:28:11 -05:00
|
|
|
|
2001-05-23 11:02:58 -04:00
|
|
|
# what to cut off from the live protocol sent by curl
|
|
|
|
my @strip = getpart("verify", "strip");
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2001-06-27 18:01:08 -04:00
|
|
|
my @protstrip=@protocol;
|
|
|
|
|
2002-02-22 05:50:36 -05: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-27 18:01:08 -04:00
|
|
|
for(@strip) {
|
2004-04-30 04:03:07 -04:00
|
|
|
# strip off all lines that match the patterns from both arrays
|
2004-04-29 09:31:57 -04:00
|
|
|
chomp $_;
|
2001-06-27 18:01:08 -04:00
|
|
|
@out = striparray( $_, \@out);
|
|
|
|
@protstrip= striparray( $_, \@protstrip);
|
|
|
|
}
|
2001-05-28 11:26:15 -04:00
|
|
|
|
2004-11-25 17:21:49 -05:00
|
|
|
# what parts to cut off from the protocol
|
|
|
|
my @strippart = getpart("verify", "strippart");
|
|
|
|
my $strip;
|
|
|
|
for $strip (@strippart) {
|
|
|
|
chomp $strip;
|
|
|
|
for(@out) {
|
|
|
|
eval $strip;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-04-30 13:15:38 -04:00
|
|
|
$res = compare("protocol", \@out, \@protstrip);
|
2001-05-23 11:02:58 -04:00
|
|
|
if($res) {
|
|
|
|
return 1;
|
|
|
|
}
|
2005-04-22 07:51:06 -04:00
|
|
|
|
|
|
|
$ok .= "p";
|
|
|
|
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$ok .= "-"; # protocol not checked
|
2000-11-17 10:58:25 -05:00
|
|
|
}
|
2000-11-27 07:53:50 -05:00
|
|
|
|
2001-05-28 11:26:15 -04: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";
|
2005-04-28 17:04:58 -04:00
|
|
|
stopservers($verbose);
|
2001-05-28 11:26:15 -04:00
|
|
|
exit;
|
|
|
|
}
|
2005-04-28 02:50:42 -04:00
|
|
|
my $filemode=$hash{'mode'};
|
|
|
|
|
2001-05-28 11:26:15 -04:00
|
|
|
my @generated=loadarray($filename);
|
|
|
|
|
2005-01-20 17:48:43 -05:00
|
|
|
# what parts to cut off from the file
|
|
|
|
my @stripfile = getpart("verify", "stripfile");
|
2005-04-28 02:50:42 -04:00
|
|
|
|
2005-04-28 17:04:58 -04:00
|
|
|
if(($filemode eq "text") && $has_textaware) {
|
2005-04-28 02:50:42 -04:00
|
|
|
# text mode when running on windows means adding an extra
|
|
|
|
# strip expression
|
|
|
|
push @stripfile, "s/\r\n/\n/";
|
|
|
|
}
|
|
|
|
|
2005-01-20 17:48:43 -05:00
|
|
|
my $strip;
|
|
|
|
for $strip (@stripfile) {
|
|
|
|
chomp $strip;
|
|
|
|
for(@generated) {
|
|
|
|
eval $strip;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-04-30 13:15:38 -04:00
|
|
|
$res = compare("output", \@generated, \@outfile);
|
2001-05-28 11:26:15 -04:00
|
|
|
if($res) {
|
|
|
|
return 1;
|
|
|
|
}
|
2005-04-22 07:51:06 -04:00
|
|
|
|
|
|
|
$ok .= "o";
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$ok .= "-"; # output not checked
|
2001-05-28 11:26:15 -04:00
|
|
|
}
|
|
|
|
|
2005-03-17 03:17:48 -05:00
|
|
|
# accept multiple comma-separated error codes
|
|
|
|
my @splerr = split(/ *, */, $errorcode);
|
|
|
|
my $errok;
|
|
|
|
foreach $e (@splerr) {
|
|
|
|
if($e == $cmdres) {
|
|
|
|
# a fine error code
|
|
|
|
$errok = 1;
|
|
|
|
last;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if($errok) {
|
2005-04-22 07:51:06 -04:00
|
|
|
$ok .= "e";
|
2004-04-30 06:37:40 -04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
if(!$short) {
|
2005-03-17 03:17:48 -05:00
|
|
|
printf "\ncurl returned $cmdres, %s was expected\n", $errorcode;
|
2003-12-17 10:33:04 -05:00
|
|
|
}
|
2004-04-30 06:37:40 -04:00
|
|
|
print " exit FAILED\n";
|
|
|
|
return 1;
|
2003-12-17 10:33:04 -05:00
|
|
|
}
|
|
|
|
|
2003-06-26 07:44:01 -04:00
|
|
|
@what = getpart("client", "killserver");
|
2003-04-01 03:41:49 -05:00
|
|
|
for(@what) {
|
|
|
|
my $serv = $_;
|
|
|
|
chomp $serv;
|
|
|
|
if($run{$serv}) {
|
|
|
|
stopserver($run{$serv}); # the pid file is in the hash table
|
2003-06-13 05:04:08 -04:00
|
|
|
$run{$serv}=0; # clear pid
|
2003-04-01 03:41:49 -05:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
print STDERR "RUN: The $serv server is not running\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-06-26 07:44:01 -04:00
|
|
|
if($curl_debug) {
|
2000-11-17 10:58:25 -05:00
|
|
|
if(! -f $memdump) {
|
|
|
|
print "\n** ALERT! memory debuggin without any output file?\n";
|
|
|
|
}
|
|
|
|
else {
|
2003-01-09 06:26:57 -05:00
|
|
|
my @memdata=`$memanalyze $memdump`;
|
2000-11-17 10:58:25 -05:00
|
|
|
my $leak=0;
|
|
|
|
for(@memdata) {
|
2000-11-21 10:48:40 -05:00
|
|
|
if($_ ne "") {
|
|
|
|
# well it could be other memory problems as well, but
|
|
|
|
# we call it leak for short here
|
2000-11-17 10:58:25 -05:00
|
|
|
$leak=1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if($leak) {
|
2000-11-21 10:48:40 -05:00
|
|
|
print "\n** MEMORY FAILURE\n";
|
2000-11-17 10:58:25 -05:00
|
|
|
print @memdata;
|
|
|
|
return 1;
|
2000-11-17 10:07:29 -05:00
|
|
|
}
|
|
|
|
else {
|
2005-04-22 07:51:06 -04:00
|
|
|
$ok .= "m";
|
2000-11-17 10:07:29 -05:00
|
|
|
}
|
|
|
|
}
|
2004-04-30 06:37:40 -04:00
|
|
|
}
|
2005-04-22 07:51:06 -04:00
|
|
|
else {
|
|
|
|
$ok .= "-"; # memory not checked
|
|
|
|
}
|
|
|
|
|
2004-04-30 06:37:40 -04:00
|
|
|
if($valgrind) {
|
2005-01-07 16:11:13 -05:00
|
|
|
# this is the valid protocol blurb curl should generate
|
|
|
|
my @disable= getpart("verify", "valgrind");
|
|
|
|
|
|
|
|
if($disable[0] !~ /disable/) {
|
|
|
|
|
|
|
|
opendir(DIR, "log") ||
|
|
|
|
return 0; # can't open log dir
|
|
|
|
my @files = readdir(DIR);
|
|
|
|
closedir DIR;
|
|
|
|
my $f;
|
|
|
|
my $l;
|
|
|
|
foreach $f (@files) {
|
|
|
|
if($f =~ /^valgrind$testnum\.pid/) {
|
|
|
|
$l = $f;
|
|
|
|
last;
|
2005-01-30 07:56:36 -05:00
|
|
|
}
|
2005-01-07 16:11:13 -05:00
|
|
|
}
|
2005-02-10 03:50:33 -05:00
|
|
|
my $src=$ENV{'srcdir'};
|
|
|
|
if(!$src) {
|
|
|
|
$src=".";
|
|
|
|
}
|
|
|
|
my @e = valgrindparse($src, $feature{'SSL'}, "log/$l");
|
|
|
|
if($e[0]) {
|
2005-01-07 16:11:13 -05:00
|
|
|
print " valgrind ERROR ";
|
2005-02-10 03:50:33 -05:00
|
|
|
print @e;
|
2005-01-07 16:11:13 -05:00
|
|
|
return 1;
|
|
|
|
}
|
2005-04-22 07:51:06 -04:00
|
|
|
$ok .= "v";
|
2004-04-30 06:37:40 -04:00
|
|
|
}
|
2005-01-07 16:11:13 -05:00
|
|
|
else {
|
|
|
|
if(!$short) {
|
|
|
|
print " valgrind SKIPPED";
|
|
|
|
}
|
2005-04-22 07:51:06 -04:00
|
|
|
$ok .= "-"; # skipped
|
2004-04-30 06:37:40 -04:00
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
}
|
2005-04-22 07:51:06 -04:00
|
|
|
else {
|
|
|
|
$ok .= "-"; # valgrind not checked
|
2000-11-17 10:15:48 -05:00
|
|
|
}
|
2005-04-22 07:51:06 -04:00
|
|
|
|
|
|
|
print "$ok " if(!$short);
|
|
|
|
|
|
|
|
my $sofar= time()-$start;
|
|
|
|
my $esttotal = $sofar/$count * $total;
|
|
|
|
my $estleft = $esttotal - $sofar;
|
|
|
|
my $left=sprintf("remaining: %dm%ds",
|
|
|
|
$estleft/60,
|
|
|
|
$estleft%60);
|
|
|
|
printf "OK ($count out of $total, %s)\n", $left;
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2005-01-07 16:11:13 -05:00
|
|
|
# the test succeeded, remove all log files
|
|
|
|
if(!$keepoutfiles) {
|
|
|
|
cleardir($LOGDIR);
|
|
|
|
}
|
|
|
|
|
|
|
|
unlink($FTPDCMD); # remove the instructions for this test
|
|
|
|
|
2000-11-13 11:06:16 -05:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2003-10-24 04:53:59 -04:00
|
|
|
#######################################################################
|
|
|
|
# Stop all running test servers
|
|
|
|
sub stopservers {
|
2005-04-28 17:04:58 -04:00
|
|
|
my ($verbose)=@_;
|
2003-10-24 04:53:59 -04:00
|
|
|
for(keys %run) {
|
2005-04-28 10:25:48 -04:00
|
|
|
printf ("* kill pid for %-5s => %-5d\n", $_, $run{$_}) if($verbose);
|
2003-10-24 04:53:59 -04:00
|
|
|
stopserver($run{$_}); # the pid file is in the hash table
|
2001-04-24 17:09:53 -04:00
|
|
|
}
|
2005-04-28 10:25:48 -04:00
|
|
|
ftpkillslaves($verbose);
|
2003-10-24 04:53:59 -04:00
|
|
|
}
|
2003-04-30 16:28:49 -04:00
|
|
|
|
2003-10-24 04:53:59 -04:00
|
|
|
#######################################################################
|
|
|
|
# startservers() starts all the named servers
|
|
|
|
#
|
2004-12-16 09:18:11 -05:00
|
|
|
# Returns: string with error reason or blank for success
|
|
|
|
|
2003-10-24 04:53:59 -04:00
|
|
|
sub startservers {
|
|
|
|
my @what = @_;
|
|
|
|
my $pid;
|
2002-12-12 07:20:06 -05:00
|
|
|
for(@what) {
|
|
|
|
my $what = lc($_);
|
2004-12-11 16:41:00 -05:00
|
|
|
$what =~ s/[^a-z0-9-]//g;
|
2002-12-12 07:20:06 -05:00
|
|
|
if($what eq "ftp") {
|
|
|
|
if(!$run{'ftp'}) {
|
2005-01-17 15:20:34 -05:00
|
|
|
$pid = runftpserver("", $verbose);
|
2003-06-13 05:04:08 -04:00
|
|
|
if($pid <= 0) {
|
2004-12-16 09:18:11 -05:00
|
|
|
return "failed starting FTP server";
|
2003-03-15 11:43:58 -05:00
|
|
|
}
|
2003-10-24 09:00:19 -04:00
|
|
|
printf ("* pid ftp => %-5d\n", $pid) if($verbose);
|
2003-06-13 05:04:08 -04:00
|
|
|
$run{'ftp'}=$pid;
|
2002-12-12 07:20:06 -05:00
|
|
|
}
|
|
|
|
}
|
2005-01-17 15:20:34 -05:00
|
|
|
elsif($what eq "ftp2") {
|
|
|
|
if(!$run{'ftp2'}) {
|
|
|
|
$pid = runftpserver("2", $verbose);
|
|
|
|
if($pid <= 0) {
|
|
|
|
return "failed starting FTP2 server";
|
|
|
|
}
|
|
|
|
printf ("* pid ftp2 => %-5d\n", $pid) if($verbose);
|
|
|
|
$run{'ftp2'}=$pid;
|
|
|
|
}
|
|
|
|
}
|
2005-04-18 02:57:44 -04:00
|
|
|
elsif($what eq "ftp-ipv6") {
|
|
|
|
if(!$run{'ftp-ipv6'}) {
|
|
|
|
$pid = runftpserver("", $verbose, "ipv6");
|
|
|
|
if($pid <= 0) {
|
|
|
|
return "failed starting FTP-ipv6 server";
|
|
|
|
}
|
|
|
|
printf ("* pid ftp-ipv6 => %-5d\n", $pid) if($verbose);
|
|
|
|
$run{'ftp-ipv6'}=$pid;
|
|
|
|
}
|
|
|
|
}
|
2002-12-12 07:20:06 -05:00
|
|
|
elsif($what eq "http") {
|
|
|
|
if(!$run{'http'}) {
|
2003-06-13 05:04:08 -04:00
|
|
|
$pid = runhttpserver($verbose);
|
|
|
|
if($pid <= 0) {
|
2004-12-16 09:18:11 -05:00
|
|
|
return "failed starting HTTP server";
|
2004-05-17 06:53:34 -04:00
|
|
|
}
|
2003-10-24 09:00:19 -04:00
|
|
|
printf ("* pid http => %-5d\n", $pid) if($verbose);
|
2003-06-13 05:04:08 -04:00
|
|
|
$run{'http'}=$pid;
|
2002-12-12 07:20:06 -05:00
|
|
|
}
|
|
|
|
}
|
2004-12-11 16:41:00 -05:00
|
|
|
elsif($what eq "http-ipv6") {
|
|
|
|
if(!$run{'http-ipv6'}) {
|
|
|
|
$pid = runhttpserver($verbose, "IPv6");
|
|
|
|
if($pid <= 0) {
|
2004-12-16 09:18:11 -05:00
|
|
|
return "failed starting IPv6 HTTP server";
|
2004-12-11 16:41:00 -05:00
|
|
|
}
|
|
|
|
printf ("* pid http-ipv6 => %-5d\n", $pid) if($verbose);
|
|
|
|
$run{'http-ipv6'}=$pid;
|
|
|
|
}
|
|
|
|
}
|
2002-12-12 07:20:06 -05:00
|
|
|
elsif($what eq "ftps") {
|
2005-04-28 04:23:25 -04:00
|
|
|
# we can't run ftps tests at all for the moment
|
|
|
|
return "test suite lacks FTPS support";
|
2001-04-24 17:09:53 -04:00
|
|
|
}
|
2002-12-12 07:20:06 -05:00
|
|
|
elsif($what eq "file") {
|
|
|
|
# we support it but have no server!
|
|
|
|
}
|
|
|
|
elsif($what eq "https") {
|
2004-12-16 17:45:06 -05:00
|
|
|
if(!$stunnel) {
|
|
|
|
# we can't run ftps tests without stunnel
|
|
|
|
return "no stunnel";
|
2002-12-12 07:20:06 -05:00
|
|
|
}
|
2004-12-17 05:09:06 -05:00
|
|
|
if(!$ssl_version) {
|
2004-12-16 17:45:06 -05:00
|
|
|
# we can't run ftps tests if libcurl is SSL-less
|
|
|
|
return "curl lacks SSL support";
|
|
|
|
}
|
|
|
|
|
2002-12-12 08:42:21 -05:00
|
|
|
if(!$run{'http'}) {
|
2003-06-13 05:04:08 -04:00
|
|
|
$pid = runhttpserver($verbose);
|
|
|
|
if($pid <= 0) {
|
2004-12-16 09:18:11 -05:00
|
|
|
return "failed starting HTTP server";
|
2003-03-15 11:43:58 -05:00
|
|
|
}
|
2004-05-13 03:52:33 -04:00
|
|
|
printf ("* pid http => %-5d\n", $pid) if($verbose);
|
2003-06-13 05:04:08 -04:00
|
|
|
$run{'http'}=$pid;
|
2002-12-12 08:42:21 -05:00
|
|
|
}
|
2002-12-12 07:20:06 -05:00
|
|
|
if(!$run{'https'}) {
|
2003-06-13 05:04:08 -04:00
|
|
|
$pid = runhttpsserver($verbose);
|
|
|
|
if($pid <= 0) {
|
2004-12-16 09:18:11 -05:00
|
|
|
return "failed starting HTTPS server (stunnel)";
|
2003-06-13 05:04:08 -04:00
|
|
|
}
|
2003-10-24 09:00:19 -04:00
|
|
|
printf ("* pid https => %-5d\n", $pid) if($verbose);
|
2003-06-13 05:04:08 -04:00
|
|
|
$run{'https'}=$pid;
|
2002-12-12 07:20:06 -05:00
|
|
|
}
|
2001-04-24 17:09:53 -04:00
|
|
|
}
|
2003-03-15 12:11:13 -05:00
|
|
|
elsif($what eq "none") {
|
2004-05-13 03:52:33 -04:00
|
|
|
print "* starts no server\n" if ($verbose);
|
2003-03-15 12:11:13 -05:00
|
|
|
}
|
2002-12-12 07:20:06 -05:00
|
|
|
else {
|
|
|
|
warn "we don't support a server for $what";
|
2001-04-24 17:09:53 -04:00
|
|
|
}
|
|
|
|
}
|
2003-10-24 04:53:59 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
##############################################################################
|
|
|
|
# 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!
|
|
|
|
#
|
2004-12-16 09:18:11 -05:00
|
|
|
# Returns: a string, blank if everything is fine or a reason why it failed
|
|
|
|
#
|
2003-10-24 04:53:59 -04:00
|
|
|
|
|
|
|
sub serverfortest {
|
|
|
|
my ($testnum)=@_;
|
|
|
|
|
|
|
|
# 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";
|
|
|
|
}
|
2004-12-16 09:18:11 -05:00
|
|
|
return "no test";
|
2003-10-24 04:53:59 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
my @what = getpart("client", "server");
|
|
|
|
|
|
|
|
if(!$what[0]) {
|
|
|
|
warn "Test case $testnum has no server(s) specified!";
|
2004-12-16 09:18:11 -05:00
|
|
|
return "no server specified";
|
2003-10-24 04:53:59 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return &startservers(@what);
|
2001-04-24 17:09:53 -04:00
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
|
|
|
|
#######################################################################
|
|
|
|
# Check options to this test program
|
|
|
|
#
|
|
|
|
|
2001-03-12 07:58:30 -05:00
|
|
|
my $number=0;
|
|
|
|
my $fromnum=-1;
|
2000-11-21 14:28:11 -05:00
|
|
|
my @testthis;
|
2000-11-14 05:18:44 -05:00
|
|
|
do {
|
|
|
|
if ($ARGV[0] eq "-v") {
|
|
|
|
# verbose output
|
|
|
|
$verbose=1;
|
|
|
|
}
|
2001-08-21 09:18:07 -04:00
|
|
|
elsif ($ARGV[0] eq "-c") {
|
2004-05-17 06:53:34 -04:00
|
|
|
# use this path to curl instead of default
|
2004-12-21 05:10:40 -05:00
|
|
|
$DBGCURL=$CURL=$ARGV[1];
|
2001-08-21 09:18:07 -04:00
|
|
|
shift @ARGV;
|
|
|
|
}
|
2001-01-27 13:50:54 -05:00
|
|
|
elsif ($ARGV[0] eq "-d") {
|
2004-05-17 06:53:34 -04:00
|
|
|
# have the servers display protocol output
|
2001-01-27 13:50:54 -05:00
|
|
|
$debugprotocol=1;
|
|
|
|
}
|
2001-02-20 08:58:39 -05:00
|
|
|
elsif ($ARGV[0] eq "-g") {
|
|
|
|
# run this test with gdb
|
|
|
|
$gdbthis=1;
|
|
|
|
}
|
2000-11-14 05:18:44 -05:00
|
|
|
elsif($ARGV[0] eq "-s") {
|
|
|
|
# short output
|
|
|
|
$short=1;
|
|
|
|
}
|
2003-11-13 05:05:44 -05:00
|
|
|
elsif($ARGV[0] eq "-n") {
|
|
|
|
# no valgrind
|
|
|
|
undef $valgrind;
|
|
|
|
}
|
2003-10-24 04:53:59 -04:00
|
|
|
elsif($ARGV[0] =~ /^-t(.*)/) {
|
|
|
|
# torture
|
|
|
|
$torture=1;
|
|
|
|
my $xtra = $1;
|
2004-05-10 05:01:45 -04:00
|
|
|
|
2003-10-24 09:00:19 -04:00
|
|
|
if($xtra =~ s/(\d+)$//) {
|
|
|
|
$tortalloc = $1;
|
2003-10-24 04:53:59 -04:00
|
|
|
}
|
2004-05-13 03:52:33 -04:00
|
|
|
# we undef valgrind to make this fly in comparison
|
|
|
|
undef $valgrind;
|
2003-10-24 04:53:59 -04:00
|
|
|
}
|
2000-11-17 10:15:48 -05:00
|
|
|
elsif($ARGV[0] eq "-a") {
|
|
|
|
# continue anyway, even if a test fail
|
|
|
|
$anyway=1;
|
|
|
|
}
|
2004-04-13 01:57:50 -04:00
|
|
|
elsif($ARGV[0] eq "-p") {
|
|
|
|
$postmortem=1;
|
|
|
|
}
|
2002-01-04 08:20:17 -05:00
|
|
|
elsif($ARGV[0] eq "-l") {
|
|
|
|
# lists the test case names only
|
|
|
|
$listonly=1;
|
|
|
|
}
|
2001-05-04 03:47:11 -04:00
|
|
|
elsif($ARGV[0] eq "-k") {
|
|
|
|
# keep stdout and stderr files after tests
|
|
|
|
$keepoutfiles=1;
|
|
|
|
}
|
2000-11-14 05:28:25 -05:00
|
|
|
elsif($ARGV[0] eq "-h") {
|
|
|
|
# show help text
|
|
|
|
print <<EOHELP
|
2001-04-24 17:09:53 -04:00
|
|
|
Usage: runtests.pl [options]
|
2000-11-17 10:15:48 -05:00
|
|
|
-a continue even if a test fails
|
2001-01-27 13:50:54 -05:00
|
|
|
-d display server debug info
|
2001-02-20 08:58:39 -05:00
|
|
|
-g run the test case with gdb
|
2000-11-14 05:28:25 -05:00
|
|
|
-h this help text
|
2001-05-04 03:47:11 -04:00
|
|
|
-k keep stdout and stderr files present after tests
|
2002-01-04 08:20:17 -05:00
|
|
|
-l list all test case names/descriptions
|
2003-11-13 05:05:44 -05:00
|
|
|
-n No valgrind
|
2004-04-13 01:57:50 -04:00
|
|
|
-p Print log file contents when a test fails
|
2000-11-14 05:28:25 -05:00
|
|
|
-s short output
|
2003-10-24 04:53:59 -04:00
|
|
|
-t torture
|
2000-11-14 05:28:25 -05:00
|
|
|
-v verbose output
|
2001-04-24 17:09:53 -04:00
|
|
|
[num] like "5 6 9" or " 5 to 22 " to run those tests only
|
2000-11-14 05:28:25 -05:00
|
|
|
EOHELP
|
|
|
|
;
|
|
|
|
exit;
|
|
|
|
}
|
2000-11-14 05:18:44 -05:00
|
|
|
elsif($ARGV[0] =~ /^(\d+)/) {
|
2001-03-12 07:58:30 -05: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 17:14:53 -05:00
|
|
|
$fromnum = $number+1;
|
2000-11-14 05:18:44 -05:00
|
|
|
}
|
|
|
|
} while(shift @ARGV);
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2000-11-21 14:28:11 -05:00
|
|
|
if($testthis[0] ne "") {
|
|
|
|
$TESTCASES=join(" ", @testthis);
|
|
|
|
}
|
|
|
|
|
2003-11-13 05:05:44 -05:00
|
|
|
if($valgrind) {
|
|
|
|
# we have found valgrind on the host, use it
|
|
|
|
|
|
|
|
# verify that we can invoke it fine
|
|
|
|
my $code = system("valgrind >/dev/null 2>&1");
|
|
|
|
|
|
|
|
if(($code>>8) != 1) {
|
|
|
|
#print "Valgrind failure, disable it\n";
|
|
|
|
undef $valgrind;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-09-08 04:08:38 -04:00
|
|
|
$HTTPPORT = $base + 0; # HTTP server port
|
|
|
|
$HTTPSPORT = $base + 1; # HTTPS server port
|
|
|
|
$FTPPORT = $base + 2; # FTP server port
|
|
|
|
$FTPSPORT = $base + 3; # FTPS server port
|
2004-12-11 16:41:00 -05:00
|
|
|
$HTTP6PORT = $base + 4; # HTTP IPv6 server port (different IP protocol
|
|
|
|
# but we follow the same port scheme anyway)
|
2005-01-17 15:20:34 -05:00
|
|
|
$FTP2PORT = $base + 5; # FTP server 2 port
|
2005-04-18 02:57:44 -04:00
|
|
|
$FTP6PORT = $base + 6; # FTP IPv6 port
|
2004-09-08 04:08:38 -04:00
|
|
|
|
2000-11-13 11:06:16 -05:00
|
|
|
#######################################################################
|
|
|
|
# Output curl version and host info being tested
|
|
|
|
#
|
|
|
|
|
2002-01-08 04:32:41 -05:00
|
|
|
if(!$listonly) {
|
2005-04-28 17:04:58 -04:00
|
|
|
checksystem();
|
2002-01-08 04:32:41 -05:00
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
|
|
|
|
#######################################################################
|
2000-11-14 05:18:44 -05:00
|
|
|
# clear and create logging directory:
|
2000-11-13 11:06:16 -05:00
|
|
|
#
|
2000-11-14 05:18:44 -05:00
|
|
|
cleardir($LOGDIR);
|
|
|
|
mkdir($LOGDIR, 0777);
|
2000-11-13 11:06:16 -05:00
|
|
|
|
|
|
|
#######################################################################
|
2000-11-14 05:18:44 -05:00
|
|
|
# If 'all' tests are requested, find out all test numbers
|
2000-11-13 11:06:16 -05:00
|
|
|
#
|
|
|
|
|
|
|
|
if ( $TESTCASES eq "all") {
|
2000-11-14 05:18:44 -05:00
|
|
|
# Get all commands and find out their test numbers
|
|
|
|
opendir(DIR, $TESTDIR) || die "can't opendir $TESTDIR: $!";
|
2001-05-23 11:02:58 -04:00
|
|
|
my @cmds = grep { /^test([0-9]+)$/ && -f "$TESTDIR/$_" } readdir(DIR);
|
2000-11-14 05:18:44 -05:00
|
|
|
closedir DIR;
|
|
|
|
|
2000-11-15 03:21:14 -05:00
|
|
|
$TESTCASES=""; # start with no test cases
|
|
|
|
|
2004-05-17 06:53:34 -04:00
|
|
|
# cut off everything but the digits
|
2000-11-14 05:18:44 -05:00
|
|
|
for(@cmds) {
|
|
|
|
$_ =~ s/[a-z\/\.]*//g;
|
2000-11-15 03:21:14 -05:00
|
|
|
}
|
|
|
|
# the the numbers from low to high
|
|
|
|
for(sort { $a <=> $b } @cmds) {
|
2000-11-14 05:18:44 -05:00
|
|
|
$TESTCASES .= " $_";
|
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
}
|
|
|
|
|
2000-11-21 12:07:16 -05:00
|
|
|
#######################################################################
|
|
|
|
# Start the command line log
|
|
|
|
#
|
|
|
|
open(CMDLOG, ">$CURLLOG") ||
|
|
|
|
print "can't log command lines to $CURLLOG\n";
|
|
|
|
|
2003-10-24 04:53:59 -04:00
|
|
|
#######################################################################
|
2004-04-13 01:57:50 -04:00
|
|
|
|
|
|
|
sub displaylogcontent {
|
|
|
|
my ($file)=@_;
|
|
|
|
open(SINGLE, "<$file");
|
|
|
|
while(<SINGLE>) {
|
|
|
|
print " $_";
|
|
|
|
}
|
|
|
|
close(SINGLE);
|
|
|
|
}
|
|
|
|
|
|
|
|
sub displaylogs {
|
2004-04-14 03:04:45 -04:00
|
|
|
my ($testnum)=@_;
|
2004-04-13 01:57:50 -04:00
|
|
|
opendir(DIR, "$LOGDIR") ||
|
|
|
|
die "can't open dir: $!";
|
|
|
|
my @logs = readdir(DIR);
|
|
|
|
closedir DIR;
|
|
|
|
my $log;
|
2004-04-14 03:04:45 -04:00
|
|
|
|
2004-04-15 09:37:19 -04:00
|
|
|
print "== Contents of files in the log/ dir after test $testnum\n";
|
2004-04-13 01:57:50 -04:00
|
|
|
foreach $log (sort @logs) {
|
2004-04-16 03:02:17 -04:00
|
|
|
# the log file is not "." or ".." and contains more than zero bytes
|
2005-04-22 16:47:35 -04:00
|
|
|
if(($log !~ /\.(\.|)$/) &&
|
|
|
|
($log ne "memdump") && # and not "memdump"
|
|
|
|
-s "$LOGDIR/$log") {
|
2004-08-24 05:23:40 -04:00
|
|
|
if($log =~ /^\.nfs/) {
|
|
|
|
next;
|
|
|
|
}
|
2004-04-13 01:57:50 -04:00
|
|
|
print "== Start of file $log\n";
|
2004-04-14 03:04:45 -04:00
|
|
|
displaylogcontent("$LOGDIR/$log");
|
2004-04-13 01:57:50 -04:00
|
|
|
print "== End of file $log\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-11-14 05:18:44 -05:00
|
|
|
#######################################################################
|
|
|
|
# The main test-loop
|
|
|
|
#
|
|
|
|
|
2001-03-12 08:46:23 -05:00
|
|
|
my $failed;
|
2000-11-15 02:09:37 -05:00
|
|
|
my $testnum;
|
2000-11-28 07:49:39 -05:00
|
|
|
my $ok=0;
|
|
|
|
my $total=0;
|
2003-06-26 07:44:01 -04:00
|
|
|
my $lasttest;
|
2005-04-22 07:51:06 -04:00
|
|
|
my @at = split(" ", $TESTCASES);
|
2005-04-28 04:23:25 -04:00
|
|
|
my $count=0;
|
2005-04-22 07:51:06 -04:00
|
|
|
|
|
|
|
$start = time();
|
2001-04-24 17:09:53 -04:00
|
|
|
|
2005-04-22 07:51:06 -04:00
|
|
|
foreach $testnum (@at) {
|
2000-11-13 11:06:16 -05:00
|
|
|
|
2003-06-26 07:44:01 -04:00
|
|
|
$lasttest = $testnum if($testnum > $lasttest);
|
2005-04-22 07:51:06 -04:00
|
|
|
$count++;
|
2003-06-26 07:44:01 -04:00
|
|
|
|
2005-04-22 07:51:06 -04:00
|
|
|
my $error = singletest($testnum, $count, scalar(@at));
|
2003-06-26 07:44:01 -04:00
|
|
|
if($error < 0) {
|
2003-01-27 08:51:35 -05:00
|
|
|
# not a test we can run
|
2001-04-24 17:09:53 -04:00
|
|
|
next;
|
|
|
|
}
|
|
|
|
|
2003-01-27 08:51:35 -05:00
|
|
|
$total++; # number of tests we've run
|
|
|
|
|
2001-03-12 08:46:23 -05:00
|
|
|
if($error>0) {
|
2001-05-23 11:02:58 -04:00
|
|
|
$failed.= "$testnum ";
|
2004-04-13 01:57:50 -04:00
|
|
|
if($postmortem) {
|
|
|
|
# display all files in log/ in a nice way
|
2004-04-14 03:04:45 -04:00
|
|
|
displaylogs($testnum);
|
2004-04-13 01:57:50 -04:00
|
|
|
}
|
2001-03-12 08:46:23 -05:00
|
|
|
if(!$anyway) {
|
|
|
|
# a test failed, abort
|
|
|
|
print "\n - abort tests\n";
|
|
|
|
last;
|
|
|
|
}
|
2000-11-17 10:07:29 -05:00
|
|
|
}
|
2000-11-28 07:49:39 -05:00
|
|
|
elsif(!$error) {
|
2003-01-27 08:51:35 -05:00
|
|
|
$ok++; # successful test counter
|
2000-11-28 07:49:39 -05:00
|
|
|
}
|
2000-11-13 11:06:16 -05:00
|
|
|
|
|
|
|
# loop for next test
|
|
|
|
}
|
|
|
|
|
2000-11-21 12:07:16 -05:00
|
|
|
#######################################################################
|
|
|
|
# Close command log
|
|
|
|
#
|
|
|
|
close(CMDLOG);
|
|
|
|
|
2003-10-24 04:53:59 -04:00
|
|
|
# Tests done, stop the servers
|
2005-04-28 17:04:58 -04:00
|
|
|
stopservers($verbose);
|
2000-11-21 10:48:40 -05:00
|
|
|
|
2003-08-14 08:59:54 -04:00
|
|
|
my $all = $total + $skipped;
|
|
|
|
|
2001-03-12 07:58:30 -05:00
|
|
|
if($total) {
|
2003-01-20 10:43:50 -05:00
|
|
|
printf("TESTDONE: $ok tests out of $total reported OK: %d%%\n",
|
2002-01-03 03:22:05 -05:00
|
|
|
$ok/$total*100);
|
2001-03-12 08:46:23 -05:00
|
|
|
|
|
|
|
if($ok != $total) {
|
2003-01-20 10:43:50 -05:00
|
|
|
print "TESTFAIL: These test cases failed: $failed\n";
|
2001-03-12 08:46:23 -05:00
|
|
|
}
|
2001-03-12 07:58:30 -05:00
|
|
|
}
|
|
|
|
else {
|
2003-01-20 10:43:50 -05:00
|
|
|
print "TESTFAIL: No tests were performed!\n";
|
2001-03-12 07:58:30 -05:00
|
|
|
}
|
2003-08-14 08:59:54 -04:00
|
|
|
|
|
|
|
if($all) {
|
2005-04-22 07:51:06 -04:00
|
|
|
my $sofar = time()-$start;
|
|
|
|
print "TESTDONE: $all tests were considered during $sofar seconds.\n";
|
2003-08-14 08:59:54 -04:00
|
|
|
}
|
|
|
|
|
2001-04-24 17:09:53 -04:00
|
|
|
if($skipped) {
|
2003-06-26 07:44:01 -04:00
|
|
|
my $s=0;
|
|
|
|
print "TESTINFO: $skipped tests were skipped due to these restraints:\n";
|
|
|
|
|
|
|
|
for(keys %skipped) {
|
|
|
|
my $r = $_;
|
2003-08-14 08:59:54 -04:00
|
|
|
printf "TESTINFO: \"%s\" %d times (", $r, $skipped{$_};
|
2003-06-26 07:44:01 -04:00
|
|
|
|
|
|
|
# now show all test case numbers that had this reason for being
|
|
|
|
# skipped
|
|
|
|
my $c=0;
|
|
|
|
for(0 .. $lasttest) {
|
|
|
|
my $t = $_;
|
|
|
|
if($teststat[$_] eq $r) {
|
|
|
|
print ", " if($c);
|
|
|
|
print $_;
|
|
|
|
$c++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
print ")\n";
|
|
|
|
}
|
2003-03-15 11:43:58 -05:00
|
|
|
}
|
2001-05-28 11:26:15 -04:00
|
|
|
if($total && ($ok != $total)) {
|
|
|
|
exit 1;
|
|
|
|
}
|