runtests.pl

#!/usr/bin/env perl
#***************************************************************************
#                                  _   _ ____  _
#  Project                     ___| | | |  _ \| |
#                             / __| | | | |_) | |
#                            | (__| |_| |  _ <| |___
#                             \___|\___/|_| \_\_____|
#
# Copyright (C) 1998 - 2006, Daniel Stenberg, <daniel@haxx.se>, et al.
#
# 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.
#
# 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
# furnished to do so, under the terms of the COPYING file.
#
# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
# KIND, either express or implied.
#
# $Id$
###########################################################################
# These should be the only variables that might be needed to get edited:

use strict;
#use Time::HiRes qw( gettimeofday );
#use warnings;

@INC=(@INC, $ENV{'srcdir'}, ".");

require "getpart.pm"; # array functions
require "valgrind.pm"; # valgrind report parser
require "ftp.pm";

my $srcdir = $ENV{'srcdir'} || '.';
my $HOSTIP="127.0.0.1";
my $HOST6IP="[::1]";

my $base = 8990; # base port number

my $HTTPPORT; # HTTP server port
my $HTTP6PORT; # HTTP IPv6 server port
my $HTTPSPORT; # HTTPS server port
my $FTPPORT; # FTP server port
my $FTP2PORT; # FTP server 2 port
my $FTPSPORT; # FTPS server port
my $FTP6PORT; # FTP IPv6 server port
my $TFTPPORT; # TFTP
my $TFTP6PORT; # TFTP

my $CURL="../src/curl"; # what curl executable to run on the tests
my $DBGCURL=$CURL; #"../src/.libs/curl";  # alternative for debugging
my $LOGDIR="log";
my $TESTDIR="$srcdir/data";
my $LIBDIR="./libtest";
my $SERVERIN="$LOGDIR/server.input"; # what curl sent the server
my $SERVER2IN="$LOGDIR/server2.input"; # what curl sent the second server
my $CURLLOG="$LOGDIR/curl.log"; # all command lines run
my $FTPDCMD="$LOGDIR/ftpserver.cmd"; # copy ftp server instructions here

# Normally, all test cases should be run, but at times it is handy to
# simply run a particular one:
my $TESTCASES="all";

# To run specific test cases, set them like:
# $TESTCASES="1 2 3 7 8";

#######################################################################
# No variables below this point should need to be modified
#

my $HTTPPIDFILE=".http.pid";
my $HTTP6PIDFILE=".http6.pid";
my $HTTPSPIDFILE=".https.pid";
my $HTTPS6PIDFILE=".https6.pid";
my $FTPPIDFILE=".ftp.pid";
my $FTP6PIDFILE=".ftp6.pid";
my $FTP2PIDFILE=".ftp2.pid";
my $FTPSPIDFILE=".ftps.pid";
my $TFTPPIDFILE=".tftpd.pid";
my $TFTP6PIDFILE=".tftp6.pid";

# invoke perl like this:
my $perl="perl -I$srcdir";
my $server_response_maxtime=13;

# this gets set if curl is compiled with debugging:
my $curl_debug=0;
my $libtool;

# name of the file that the memory debugging creates:
my $memdump="$LOGDIR/memdump";

# the path to the script that analyzes the memory debug output file:
my $memanalyze="$perl $srcdir/memanalyze.pl";

my $stunnel = checkcmd("stunnel4") || checkcmd("stunnel");
my $valgrind = checkcmd("valgrind");
my $valgrind_logfile="--logfile";
my $start;
my $forkserver=0;
my $ftpchecktime; # time it took to verify our test FTP server

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

    # valgrind 3 renamed the --logfile option to --log-file!!!
    my $ver=`valgrind --version`;
    # cut off all but digits and dots
    $ver =~ s/[^0-9.]//g;

    if($ver >= 3) {
        $valgrind_logfile="--log-file";
    }
}

my $gdb = checkcmd("gdb");

my $ssl_version; # set if libcurl is built with SSL support
my $large_file;  # set if libcurl is built with large file support
my $has_idn;     # set if libcurl is built with IDN support
my $http_ipv6;   # set if HTTP server has IPv6 support
my $ftp_ipv6;    # set if FTP server has IPv6 support
my $tftp_ipv6;   # set if TFTP server has IPv6 support
my $has_ipv6;    # set if libcurl is built with IPv6 support
my $has_libz;    # set if libcurl is built with libz support
my $has_getrlimit;  # set if system has getrlimit()
my $has_ntlm;    # set if libcurl is built with NTLM support
my $has_openssl; # set if libcurl is built with OpenSSL
my $has_gnutls;  # set if libcurl is built with GnuTLS
my $has_textaware; # set if running on a system that has a text mode concept
  # on files. Windows for example

my $skipped=0;  # number of tests skipped; reported in main loop
my %skipped;    # skipped{reason}=counter, reasons for skip
my @teststat;   # teststat[testnum]=reason, reasons for skip

#######################################################################
# variables the command line options may set
#

my $short;
my $verbose;
my $debugprotocol;
my $anyway;
my $gdbthis;      # run test case with gdb debugger
my $keepoutfiles; # keep stdout and stderr files after tests
my $listonly;     # only list the tests
my $postmortem;   # display detailed info about failed tests

my $pwd;          # current working directory

my %run;	  # running server

# torture test variables
my $torture;
my $tortnum;
my $tortalloc;

# open and close each time to allow removal at any time
sub logmsg {
# uncomment the Time::HiRes usage for this
#    my ($seconds, $microseconds) = gettimeofday;
#    my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
#        localtime($seconds);
    my $t;
    if(1) {
#        $t = sprintf ("%02d:%02d:%02d.%06d ", $hour, $min, $sec,
#                      $microseconds);
    }
    for(@_) {
        print "${t}$_";
    }
}

chomp($pwd = `pwd`);

# enable memory debugging if curl is compiled with it
$ENV{'CURL_MEMDEBUG'} = $memdump;
$ENV{'HOME'}=$pwd;

sub catch_zap {
    my $signame = shift;
    logmsg "runtests.pl received SIG$signame, exiting\n";
    stopalltestservers();
    die "Somebody sent me a SIG$signame";
}
$SIG{INT} = \&catch_zap;
$SIG{KILL} = \&catch_zap;

##########################################################################
# 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', 'no')) {
    my $proxy = "${protocol}_proxy";
    # clear lowercase version
    $ENV{$proxy}=undef;
    # clear uppercase version
    $ENV{uc($proxy)}=undef;
}

# 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;

#######################################################################
# Start a new thread/process and run the given command line in there.
# If successfully started an entry is added to the running servers hash.
# On error return 0. On success return 1.
#
sub startnew {
    my ($cmd, $pidfile, $serv)=@_;

    if((not defined $cmd) || (not defined $pidfile) || (not defined $serv)) {
        return 0;
    }

    logmsg "startnew: $cmd\n" if ($verbose);

    my $UCSERV = uc($serv);

    if(stoptestserver($serv) == 0) {
        logmsg "RUN: failed to stop previous $UCSERV server!\n";
        return 0;
    }

    my $child = fork();
    my $pid2;

    if(not defined $child) {
        logmsg "RUN: fork() failure detected for $UCSERV server!\n";
        return 0;
    }

    if(0 == $child) {
        # Here we are the child. Run the given command.

        # Calling exec() within a pseudo-process actually spawns the requested
        # executable in a separate process and waits for it to complete before
        # exiting with the same exit status as that process.  This means that
        # the process ID reported within the running executable will be
        # different from what the earlier Perl fork() might have returned.

        # exec() should never return back here to this process. We protect
        # ourselfs calling die() just in case something goes really bad.

        exec($cmd) || die "Can't exec() cmd: $cmd";

        die "error: exec() has returned";
    }

    my $timeoutstart = 90; # seconds

    $pid2 = waitalivepidfile($pidfile, $timeoutstart);
    if(0 == $pid2) {
        logmsg sprintf("RUN: %s server start-up timed out (%d sec)\n",
                       $UCSERV, $timeoutstart);
        return 0;
    }

    # setup entry in the running servers hash

    $run{$serv}{'pidfile'} = $pidfile; # pidfile for the test server.

    if($child == $pid2) {
        $run{$serv}{'pids'} = "$pid2"; # test server pid.
    }
    else {
        $run{$serv}{'pids'} = "$child $pid2"; # forked pid and test server pid.
    }

    if($serv =~ /^ftp(\d*)(-ipv6|)/) { # ftp servers have slavepidfiles.
        my ($id, $ext) = ($1, $2);
        $ext =~ s/\-//g;
        my $slavepidfiles = ".sockfilt$id$ext.pid .sockdata$id$ext.pid";
        $run{$serv}{'slavepidfiles'} = $slavepidfiles;
    }

    return 1;
}


#######################################################################
# 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";
        }
    }
}

#######################################################################
# Memory allocation test and failure torture testing.
#
sub torture {
    my $testcmd = shift;
    my $gdbline = shift;

    # remove memdump first to be sure we get a new nice and clean one
    unlink($memdump);

    # First get URL from test server, ignore the output/result
    system($testcmd);

    logmsg " CMD: $testcmd\n" if($verbose);

    # memanalyze -v is our friend, get the number of allocations made
    my $count=0;
    my @out = `$memanalyze -v $memdump`;
    for(@out) {
        if(/^Allocations: (\d+)/) {
            $count = $1;
            last;
        }
    }
    if(!$count) {
        logmsg " found no allocs to make fail\n";
        return 0;
    }

    logmsg " $count allocations to make fail\n";

    for ( 1 .. $count ) {
        my $limit = $_;
        my $fail;
        my $dumped_core;

        if($tortalloc && ($tortalloc != $limit)) {
            next;
        }

        logmsg "Fail alloc no: $limit\r" if($verbose);

        # make the memory allocation function number $limit return failure
        $ENV{'CURL_MEMLIMIT'} = $limit;

        # remove memdump first to be sure we get a new nice and clean one
        unlink($memdump);

        logmsg "**> Alloc number $limit is now set to fail <**\n" if($gdbthis);

        my $ret;
        if($gdbthis) {
            system($gdbline)
        }
        else {
            $ret = system($testcmd);
        }

        # Now clear the variable again
        $ENV{'CURL_MEMLIMIT'} = undef;

        if(-r "core") {
            # there's core file present now!
            logmsg " 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) {
            logmsg " 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;
                }
            }
            if($leak) {
                logmsg "** MEMORY FAILURE\n";
                logmsg @memdata;
                logmsg `$memanalyze -l $memdump`;
                $fail = 1;
            }
        }
        if($fail) {
            logmsg " Failed on alloc number $limit in test.\n",
            " invoke with -t$limit to repeat this single case.\n";
            stopalltestservers();
            exit 1;
        }
    }

    logmsg "torture OK\n";
    return 0;
}

#######################################################################
# Stop specific test server processes, including slave processes, of the
# given test server. Wait for them to finish and unlink its pidfiles.
# If they were not running or have been successfully stopped return 1.
# If unable to stop any of them then return 0. The test server is removed
# from the running servers hash in any case.
#
sub stoptestserver {
    my ($serv)=@_;

    if(not defined $serv) {
        return 0;
    }

    my $ret = 1; # assume success stopping them
    my $pid;
    my $pidfile;
    my $pidfiles = "";
    my $pidsrunning = "";

    if($run{$serv}) {
        if($run{$serv}{'slavepidfiles'}) {
            for $pidfile (split(" ", $run{$serv}{'slavepidfiles'})) {
                $pidfiles .= " $pidfile";
                $pid = checkalivepidfile($pidfile);
                if($pid > 0) {
                    $pidsrunning .= " $pid";
                }
            }
            delete $run{$serv}{'slavepidfiles'};
        }
        if($run{$serv}{'pidfile'}) {
            $pidfile = $run{$serv}{'pidfile'};
            $pidfiles .= " $pidfile";
            $pid = checkalivepidfile($pidfile);
            if($pid > 0) {
                $pidsrunning .= " $pid";
            }
            delete $run{$serv}{'pidfile'};
        }
        if($run{$serv}{'pids'}) {
            $pid = $run{$serv}{'pids'};
            $pidsrunning .= " $pid";
            delete $run{$serv}{'pids'};
        }
        if($run{$serv}) {
            delete $run{$serv};
        }
    }
    if($pidsrunning) {
        $ret = stopprocess($pidsrunning);
    }
    if($pidfiles) {
        unlinkpidfiles($pidfiles);
    }
    return $ret;
}

#######################################################################
# Verify that the server that runs on $ip, $port is our server.  This also
# implies that we can speak with it, as there might be occasions when the
# server runs fine but we cannot talk to it ("Failed to connect to ::1: Can't
# assign requested address" #

sub verifyhttp {
    my ($proto, $ip, $port) = @_;
    my $cmd = "$CURL -m$server_response_maxtime -o log/verifiedserver -ksvg \"$proto://$ip:$port/verifiedserver\" 2>log/verifyhttp";
    my $pid;

    # verify if our/any server is running on this port
    logmsg "CMD; $cmd\n" if ($verbose);
    my $res = system($cmd);

    $res >>= 8; # rotate the result
    my $data;

    if($res && $verbose) {
        open(ERR, "<log/verifyhttp");
        my @e = <ERR>;
        close(ERR);
        logmsg "RUN: curl command returned $res\n";
        for(@e) {
            if($_ !~ /^([ \t]*)$/) {
                logmsg "RUN: $_";
            }
        }
    }
    open(FILE, "<log/verifiedserver");
    my @file=<FILE>;
    close(FILE);
    $data=$file[0]; # first line

    if ( $data =~ /WE ROOLZ: (\d+)/ ) {
        $pid = 0+$1;
    }
    elsif($res == 6) {
        # curl: (6) Couldn't resolve host '::1'
        logmsg "RUN: failed to resolve host\n";
        return 0;
    }
    elsif($data || ($res != 7)) {
        logmsg "RUN: Unknown server is running on port $port\n";
        return 0;
    }
    return $pid;
}

#######################################################################
# Verify that the server that runs on $ip, $port is our server.  This also
# implies that we can speak with it, as there might be occasions when the
# server runs fine but we cannot talk to it ("Failed to connect to ::1: Can't
# assign requested address" #

sub verifyftp {
    my ($proto, $ip, $port) = @_;
    my $pid;
    my $time=time();
    my $cmd="$CURL -m$server_response_maxtime --silent -vg \"$proto://$ip:$port/verifiedserver\" 2>log/verifyftp";
    # check if this is our server running on this port:
    my @data=`$cmd`;
    logmsg "RUN: $cmd\n" if($verbose);
    my $line;

    foreach $line (@data) {
        if ( $line =~ /WE ROOLZ: (\d+)/ ) {
            # this is our test server with a known pid!
            $pid = 0+$1;
            last;
        }
    }
    if($pid <= 0 && $data[0]) {
        # this is not a known server
        logmsg "RUN: Unknown server on our FTP port: $port\n";
        return 0;
    }
    # we can/should use the time it took to verify the FTP server as a measure
    # on how fast/slow this host/FTP is.
    my $took = time()-$time;

    if($verbose) {
        logmsg "RUN: Verifying our test FTP server took $took seconds!\n";
    }
    $ftpchecktime = $took?$took:1; # make sure it never is zero

    return $pid;
}

#######################################################################
# Verify that the server that runs on $ip, $port is our server.
# Retry during 5 seconds before giving up.
#

my %protofunc = ('http' => \&verifyhttp,
                 'https' => \&verifyhttp,
                 'ftp' => \&verifyftp,
                 'tftp' => \&verifyftp);

sub verifyserver {
    my ($proto, $ip, $port) = @_;

    my $count = 5; # try for this many seconds
    my $pid;

    while($count--) {
        my $fun = $protofunc{$proto};

        $pid = &$fun($proto, $ip, $port);

        if($pid) {
            last;
        }
        sleep(1);
    }
    return $pid;
}



#######################################################################
# start the http server
# On error return 0. On success return 1.
#
sub runhttpserver {
    my ($verbose, $ipv6) = @_;

    my $pidfile = $HTTPPIDFILE;
    my $port = $HTTPPORT;
    my $ip = $HOSTIP;
    my $nameext;
    my $serv = "http";
    my $fork = $forkserver?"--fork":"";

    if($ipv6) {
        # if IPv6, use a different setup
        $pidfile = $HTTP6PIDFILE;
        $port = $HTTP6PORT;
        $ip = $HOST6IP;
        $nameext="-ipv6";
        $serv = "http-ipv6";
    }

    my $UCSERV = uc($serv);

    my $flag=$debugprotocol?"-v ":"";
    my $dir=$ENV{'srcdir'};
    if($dir) {
        $flag .= "-d \"$dir\" ";
    }

    my $cmd="$perl $srcdir/httpserver.pl -p $pidfile $fork$flag $port $ipv6";

    if (!startnew($cmd, $pidfile, $serv)) {
        # it is NOT alive
        logmsg "RUN: failed to start the $UCSERV server!\n";
        stopalltestservers();
        return 0;
    }

    # Server is up. Verify that we can speak to it.
    if(!verifyserver("http", $ip, $port)) {
        logmsg "RUN: $UCSERV server failed verification\n";
        stopalltestservers();
        return 0;
    }

    if($verbose) {
        logmsg sprintf("RUN: %s server is now running PID(s) %s\n",
                       $UCSERV, $run{$serv}{'pids'});
    }

    sleep(1);

    return 1;
}

#######################################################################
# start the https server (or rather, tunnel)
# On error return 0. On success return 1.
#
sub runhttpsserver {
    my ($verbose, $ipv6) = @_;

    my $pidfile = $HTTPSPIDFILE;
    my $ip = $HOSTIP;
    my $serv = "https";

    if(!$stunnel) {
        return 0;
    }

    if($ipv6) {
        # not complete yet
        $pidfile = $HTTPS6PIDFILE;
        $ip = $HOST6IP;
        $serv = "https-ipv6";
    }

    my $UCSERV = uc($serv);

    my $flag=$debugprotocol?"-v ":"";
    my $cmd="$perl $srcdir/httpsserver.pl $flag -s \"$stunnel\" -d $srcdir -r $HTTPPORT $HTTPSPORT";

    if (!startnew($cmd, $pidfile, $serv)) {
        # it is NOT alive
        logmsg "RUN: failed to start the $UCSERV server!\n";
        stopalltestservers();
        return 0;
    }

    # Server is up. Verify that we can speak to it.
    if(!verifyserver("https", $ip, $HTTPSPORT)) {
        logmsg "RUN: $UCSERV server failed verification\n";
        stopalltestservers();
        return 0;
    }

    if($verbose) {
        logmsg sprintf("RUN: %s server is now running PID(s) %s\n",
                       $UCSERV, $run{$serv}{'pids'});
    }

    sleep(1);

    return 1;
}

#######################################################################
# start the ftp server
# On error return 0. On success return 1.
#
sub runftpserver {
    my ($id, $verbose, $ipv6) = @_;

    my $port = $id?$FTP2PORT:$FTPPORT;
    # check for pidfile
    my $pidfile = $id?$FTP2PIDFILE:$FTPPIDFILE;
    my $ip=$HOSTIP;
    my $nameext;
    my $serv = "ftp$id";
    my $cmd;

    if($ipv6) {
        # if IPv6, use a different setup
        $pidfile = $FTP6PIDFILE;
        $port = $FTP6PORT;
        $ip = $HOST6IP;
        $nameext="-ipv6";
        $serv = "ftp$id-ipv6";
    }

    my $UCSERV = uc($serv);

    # start our server:
    my $flag=$debugprotocol?"-v ":"";
    $flag .= "-s \"$srcdir\" ";
    if($id) {
        $flag .="--id $id ";
    }
    if($ipv6) {
        $flag .="--ipv6 ";
    }
    $cmd="$perl $srcdir/ftpserver.pl --pidfile $pidfile $flag --port $port";

    if (!startnew($cmd, $pidfile, $serv)) {
        # it is NOT alive
        logmsg "RUN: failed to start the $UCSERV server!\n";
        stopalltestservers();
        return 0;
    }

    # Server is up. Verify that we can speak to it.
    if(!verifyserver("ftp", $ip, $port)) {
        logmsg "RUN: $UCSERV server failed verification\n";
        stopalltestservers();
        return 0;
    }

    if($verbose) {
        logmsg sprintf("RUN: %s server is now running PID(s) %s\n",
                       $UCSERV, $run{$serv}{'pids'});
    }

    sleep(1);

    return 1;
}

#######################################################################
# start the tftp server
# On error return 0. On success return 1.
#
sub runtftpserver {
    my ($id, $verbose, $ipv6) = @_;

    my $port = $TFTPPORT;
    # check for pidfile
    my $pidfile = $TFTPPIDFILE;
    my $ip=$HOSTIP;
    my $nameext;
    my $serv = "tftp$id";
    my $cmd;

    if($ipv6) {
        # if IPv6, use a different setup
        $pidfile = $TFTP6PIDFILE;
        $port = $TFTP6PORT;
        $ip = $HOST6IP;
        $nameext="-ipv6";
        $serv = "tftp$id-ipv6";
    }

    my $UCSERV = uc($serv);

    # start our server:
    my $flag=$debugprotocol?"-v ":"";
    $flag .= "-s \"$srcdir\" ";
    if($id) {
        $flag .="--id $id ";
    }
    if($ipv6) {
        $flag .="--ipv6 ";
    }
    $cmd="./server/tftpd --pidfile $pidfile $flag $port";

    if (!startnew($cmd, $pidfile, $serv)) {
        # it is NOT alive
        logmsg "RUN: failed to start the $UCSERV server!\n";
        stopalltestservers();
        return 0;
    }

    # Server is up. Verify that we can speak to it.
    if(!verifyserver("tftp", $ip, $port)) {
        logmsg "RUN: $UCSERV server failed verification\n";
        stopalltestservers();
        return 0;
    }

    if($verbose) {
        logmsg sprintf("RUN: %s server is now running PID(s) %s\n",
                       $UCSERV, $run{$serv}{'pids'});
    }

    sleep(1);

    return 1;
}


#######################################################################
# Remove all files in the specified directory
#
sub cleardir {
    my $dir = $_[0];
    my $count;
    my $file;

    # 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
#
sub filteroff {
    my $infile=$_[0];
    my $filter=$_[1];
    my $ofile=$_[2];

    open(IN, "<$infile")
        || return 1;

    open(OUT, ">$ofile")
        || return 1;

    # logmsg "FILTER: off $filter from $infile to $ofile\n";

    while(<IN>) {
        $_ =~ s/$filter//;
        print OUT $_;
    }
    close(IN);
    close(OUT);
    return 0;
}

#######################################################################
# compare test results with the expected output, we might filter off
# some pattern that is allowed to differ, output test results
#

sub compare {
    # filter off patterns _before_ this comparison!
    my ($subject, $firstref, $secondref)=@_;

    my $result = compareparts($firstref, $secondref);

    if($result) {
        if(!$short) {
            logmsg "\n $subject FAILED:\n";
            logmsg showdiff($LOGDIR, $firstref, $secondref);
        }
        else {
            logmsg "FAILED\n";
        }
    }
    return $result;
}

#######################################################################
# display information about curl and the host the test suite runs on
#
sub checksystem {

    unlink($memdump); # remove this if there was one left

    my $feat;
    my $curl;
    my $libcurl;
    my $versretval;
    my $versnoexec;
    my @version=();

    my $curlverout="$LOGDIR/curlverout.log";
    my $curlvererr="$LOGDIR/curlvererr.log";
    my $versioncmd="$CURL --version 1>$curlverout 2>$curlvererr";

    unlink($curlverout);
    unlink($curlvererr);

    $versretval = system($versioncmd);
    $versnoexec = $!;

    open(VERSOUT, $curlverout);
    @version = <VERSOUT>;
    close(VERSOUT);

    for(@version) {
        chomp;

        if($_ =~ /^curl/) {
            $curl = $_;
            $curl =~ s/^(.*)(libcurl.*)/$1/g;

            $libcurl = $2;
            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) {
                    logmsg "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;
            }
            elsif ($curl =~ /win32/) {
               # 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`);
           }
           elsif ($libcurl =~ /openssl/i) {
               # OpenSSL in use
               $has_openssl=1;
           }
           elsif ($libcurl =~ /gnutls/i) {
               # GnuTLS in use
               $has_gnutls=1;
           }
        }
        elsif($_ =~ /^Protocols: (.*)/i) {