Annotation of embedaddon/curl/tests/runtests.pl, revision 1.1
1.1 ! misho 1: #!/usr/bin/env perl
! 2: #***************************************************************************
! 3: # _ _ ____ _
! 4: # Project ___| | | | _ \| |
! 5: # / __| | | | |_) | |
! 6: # | (__| |_| | _ <| |___
! 7: # \___|\___/|_| \_\_____|
! 8: #
! 9: # Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
! 10: #
! 11: # This software is licensed as described in the file COPYING, which
! 12: # you should have received as part of this distribution. The terms
! 13: # are also available at https://curl.haxx.se/docs/copyright.html.
! 14: #
! 15: # You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 16: # copies of the Software, and permit persons to whom the Software is
! 17: # furnished to do so, under the terms of the COPYING file.
! 18: #
! 19: # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 20: # KIND, either express or implied.
! 21: #
! 22: ###########################################################################
! 23:
! 24: # Experimental hooks are available to run tests remotely on machines that
! 25: # are able to run curl but are unable to run the test harness.
! 26: # The following sections need to be modified:
! 27: #
! 28: # $HOSTIP, $HOST6IP - Set to the address of the host running the test suite
! 29: # $CLIENTIP, $CLIENT6IP - Set to the address of the host running curl
! 30: # runclient, runclientoutput - Modify to copy all the files in the log/
! 31: # directory to the system running curl, run the given command remotely
! 32: # and save the return code or returned stdout (respectively), then
! 33: # copy all the files from the remote system's log/ directory back to
! 34: # the host running the test suite. This can be done a few ways, such
! 35: # as using scp & ssh, rsync & telnet, or using a NFS shared directory
! 36: # and ssh.
! 37: #
! 38: # 'make && make test' needs to be done on both machines before making the
! 39: # above changes and running runtests.pl manually. In the shared NFS case,
! 40: # the contents of the tests/server/ directory must be from the host
! 41: # running the test suite, while the rest must be from the host running curl.
! 42: #
! 43: # Note that even with these changes a number of tests will still fail (mainly
! 44: # to do with cookies, those that set environment variables, or those that
! 45: # do more than touch the file system in a <precheck> or <postcheck>
! 46: # section). These can be added to the $TESTCASES line below,
! 47: # e.g. $TESTCASES="!8 !31 !63 !cookies..."
! 48: #
! 49: # Finally, to properly support -g and -n, checktestcmd needs to change
! 50: # to check the remote system's PATH, and the places in the code where
! 51: # the curl binary is read directly to determine its type also need to be
! 52: # fixed. As long as the -g option is never given, and the -n is always
! 53: # given, this won't be a problem.
! 54:
! 55:
! 56: # These should be the only variables that might be needed to get edited:
! 57:
! 58: BEGIN {
! 59: push(@INC, $ENV{'srcdir'}) if(defined $ENV{'srcdir'});
! 60: push(@INC, ".");
! 61: # run time statistics needs Time::HiRes
! 62: eval {
! 63: no warnings "all";
! 64: require Time::HiRes;
! 65: import Time::HiRes qw( time );
! 66: }
! 67: }
! 68:
! 69: use strict;
! 70: use warnings;
! 71: use Cwd;
! 72: use Digest::MD5 qw(md5);
! 73:
! 74: # Subs imported from serverhelp module
! 75: use serverhelp qw(
! 76: serverfactors
! 77: servername_id
! 78: servername_str
! 79: servername_canon
! 80: server_pidfilename
! 81: server_portfilename
! 82: server_logfilename
! 83: );
! 84:
! 85: # Variables and subs imported from sshhelp module
! 86: use sshhelp qw(
! 87: $sshdexe
! 88: $sshexe
! 89: $sftpexe
! 90: $sshconfig
! 91: $sftpconfig
! 92: $sshdlog
! 93: $sshlog
! 94: $sftplog
! 95: $sftpcmds
! 96: display_sshdconfig
! 97: display_sshconfig
! 98: display_sftpconfig
! 99: display_sshdlog
! 100: display_sshlog
! 101: display_sftplog
! 102: exe_ext
! 103: find_sshd
! 104: find_ssh
! 105: find_sftp
! 106: find_httptlssrv
! 107: sshversioninfo
! 108: );
! 109:
! 110: use pathhelp;
! 111:
! 112: require "getpart.pm"; # array functions
! 113: require "valgrind.pm"; # valgrind report parser
! 114: require "ftp.pm";
! 115: require "azure.pm";
! 116: require "appveyor.pm";
! 117:
! 118: my $HOSTIP="127.0.0.1"; # address on which the test server listens
! 119: my $HOST6IP="[::1]"; # address on which the test server listens
! 120: my $CLIENTIP="127.0.0.1"; # address which curl uses for incoming connections
! 121: my $CLIENT6IP="[::1]"; # address which curl uses for incoming connections
! 122:
! 123: my $base = 8990; # base port number
! 124: my $minport; # minimum used port number
! 125: my $maxport; # maximum used port number
! 126:
! 127: my $noport="[not running]";
! 128:
! 129: my $NOLISTENPORT=47; # port number we use for a local non-listening service
! 130: my $MQTTPORT=$noport; # MQTT server port
! 131: my $HTTPPORT=$noport; # HTTP server port
! 132: my $HTTP6PORT=$noport; # HTTP IPv6 server port
! 133: my $HTTPSPORT=$noport; # HTTPS (stunnel) server port
! 134: my $FTPPORT=$noport; # FTP server port
! 135: my $FTP2PORT=$noport; # FTP server 2 port
! 136: my $FTPSPORT=$noport; # FTPS (stunnel) server port
! 137: my $FTP6PORT=$noport; # FTP IPv6 server port
! 138: my $TFTPPORT=$noport; # TFTP
! 139: my $TFTP6PORT=$noport; # TFTP
! 140: my $SSHPORT=$noport; # SCP/SFTP
! 141: my $SOCKSPORT=$noport; # SOCKS4/5 port
! 142: my $POP3PORT=$noport; # POP3
! 143: my $POP36PORT=$noport; # POP3 IPv6 server port
! 144: my $IMAPPORT=$noport; # IMAP
! 145: my $IMAP6PORT=$noport; # IMAP IPv6 server port
! 146: my $SMTPPORT=$noport; # SMTP
! 147: my $SMTP6PORT=$noport; # SMTP IPv6 server port
! 148: my $RTSPPORT=$noport; # RTSP
! 149: my $RTSP6PORT=$noport; # RTSP IPv6 server port
! 150: my $GOPHERPORT=$noport; # Gopher
! 151: my $GOPHER6PORT=$noport; # Gopher IPv6 server port
! 152: my $HTTPTLSPORT=$noport; # HTTP TLS (non-stunnel) server port
! 153: my $HTTPTLS6PORT=$noport; # HTTP TLS (non-stunnel) IPv6 server port
! 154: my $HTTPPROXYPORT=$noport; # HTTP proxy port, when using CONNECT
! 155: my $HTTP2PORT=$noport; # HTTP/2 server port
! 156: my $DICTPORT=$noport; # DICT server port
! 157: my $SMBPORT=$noport; # SMB server port
! 158: my $SMBSPORT=$noport; # SMBS server port
! 159: my $NEGTELNETPORT=$noport; # TELNET server port with negotiation
! 160: my $HTTPUNIXPATH; # HTTP server Unix domain socket path
! 161:
! 162: my $SSHSRVMD5 = "[uninitialized]"; # MD5 of ssh server public key
! 163:
! 164: my $srcdir = $ENV{'srcdir'} || '.';
! 165: my $CURL="../src/curl".exe_ext('TOOL'); # what curl executable to run on the tests
! 166: my $VCURL=$CURL; # what curl binary to use to verify the servers with
! 167: # VCURL is handy to set to the system one when the one you
! 168: # just built hangs or crashes and thus prevent verification
! 169: my $DBGCURL=$CURL; #"../src/.libs/curl"; # alternative for debugging
! 170: my $LOGDIR="log";
! 171: my $TESTDIR="$srcdir/data";
! 172: my $LIBDIR="./libtest";
! 173: my $UNITDIR="./unit";
! 174: # TODO: change this to use server_inputfilename()
! 175: my $SERVERIN="$LOGDIR/server.input"; # what curl sent the server
! 176: my $SERVER2IN="$LOGDIR/server2.input"; # what curl sent the second server
! 177: my $PROXYIN="$LOGDIR/proxy.input"; # what curl sent the proxy
! 178: my $CURLLOG="commands.log"; # all command lines run
! 179: my $FTPDCMD="$LOGDIR/ftpserver.cmd"; # copy server instructions here
! 180: my $SERVERLOGS_LOCK="$LOGDIR/serverlogs.lock"; # server logs advisor read lock
! 181: my $CURLCONFIG="../curl-config"; # curl-config from current build
! 182:
! 183: # Normally, all test cases should be run, but at times it is handy to
! 184: # simply run a particular one:
! 185: my $TESTCASES="all";
! 186:
! 187: # To run specific test cases, set them like:
! 188: # $TESTCASES="1 2 3 7 8";
! 189:
! 190: #######################################################################
! 191: # No variables below this point should need to be modified
! 192: #
! 193:
! 194: # invoke perl like this:
! 195: my $perl="perl -I$srcdir";
! 196: my $server_response_maxtime=13;
! 197:
! 198: my $debug_build=0; # built debug enabled (--enable-debug)
! 199: my $has_memory_tracking=0; # built with memory tracking (--enable-curldebug)
! 200: my $libtool;
! 201: my $repeat = 0;
! 202:
! 203: # name of the file that the memory debugging creates:
! 204: my $memdump="$LOGDIR/memdump";
! 205:
! 206: # the path to the script that analyzes the memory debug output file:
! 207: my $memanalyze="$perl $srcdir/memanalyze.pl";
! 208:
! 209: my $pwd = getcwd(); # current working directory
! 210: my $posix_pwd = $pwd;
! 211:
! 212: my $start;
! 213: my $ftpchecktime=1; # time it took to verify our test FTP server
! 214: my $scrambleorder;
! 215: my $stunnel = checkcmd("stunnel4") || checkcmd("tstunnel") || checkcmd("stunnel");
! 216: my $valgrind = checktestcmd("valgrind");
! 217: my $valgrind_logfile="--logfile";
! 218: my $valgrind_tool;
! 219: my $gdb = checktestcmd("gdb");
! 220: my $httptlssrv = find_httptlssrv();
! 221:
! 222: my $uname_release = `uname -r`;
! 223: my $is_wsl = $uname_release =~ /Microsoft$/;
! 224:
! 225: my $has_ssl; # set if libcurl is built with SSL support
! 226: my $has_largefile; # set if libcurl is built with large file support
! 227: my $has_idn; # set if libcurl is built with IDN support
! 228: my $http_ipv6; # set if HTTP server has IPv6 support
! 229: my $http_unix; # set if HTTP server has Unix sockets support
! 230: my $ftp_ipv6; # set if FTP server has IPv6 support
! 231: my $tftp_ipv6; # set if TFTP server has IPv6 support
! 232: my $gopher_ipv6; # set if Gopher server has IPv6 support
! 233: my $has_ipv6; # set if libcurl is built with IPv6 support
! 234: my $has_unix; # set if libcurl is built with Unix sockets support
! 235: my $has_libz; # set if libcurl is built with libz support
! 236: my $has_brotli; # set if libcurl is built with brotli support
! 237: my $has_getrlimit; # set if system has getrlimit()
! 238: my $has_ntlm; # set if libcurl is built with NTLM support
! 239: my $has_ntlm_wb; # set if libcurl is built with NTLM delegation to winbind
! 240: my $has_sspi; # set if libcurl is built with Windows SSPI
! 241: my $has_gssapi; # set if libcurl is built with a GSS-API library
! 242: my $has_kerberos; # set if libcurl is built with Kerberos support
! 243: my $has_spnego; # set if libcurl is built with SPNEGO support
! 244: my $has_charconv; # set if libcurl is built with CharConv support
! 245: my $has_tls_srp; # set if libcurl is built with TLS-SRP support
! 246: my $has_metalink; # set if curl is built with Metalink support
! 247: my $has_http2; # set if libcurl is built with HTTP2 support
! 248: my $has_crypto; # set if libcurl is built with cryptographic support
! 249: my $has_cares; # set if built with c-ares
! 250: my $has_threadedres;# set if built with threaded resolver
! 251: my $has_psl; # set if libcurl is built with PSL support
! 252: my $has_altsvc; # set if libcurl is built with alt-svc support
! 253: my $has_ldpreload; # set if curl is built for systems supporting LD_PRELOAD
! 254: my $has_multissl; # set if curl is build with MultiSSL support
! 255: my $has_manual; # set if curl is built with built-in manual
! 256: my $has_win32; # set if curl is built for Windows
! 257: my $has_mingw; # set if curl is built with MinGW (as opposed to MinGW-w64)
! 258:
! 259: # this version is decided by the particular nghttp2 library that is being used
! 260: my $h2cver = "h2c";
! 261:
! 262: my $has_openssl; # built with a lib using an OpenSSL-like API
! 263: my $has_gnutls; # built with GnuTLS
! 264: my $has_nss; # built with NSS
! 265: my $has_wolfssl; # built with wolfSSL
! 266: my $has_winssl; # built with WinSSL (Secure Channel aka Schannel)
! 267: my $has_darwinssl; # built with DarwinSSL (Secure Transport)
! 268: my $has_boringssl; # built with BoringSSL
! 269: my $has_libressl; # built with libressl
! 270: my $has_mbedtls; # built with mbedTLS
! 271: my $has_mesalink; # built with MesaLink
! 272:
! 273: my $has_sslpinning; # built with a TLS backend that supports pinning
! 274:
! 275: my $has_shared = "unknown"; # built shared
! 276:
! 277: my $resolver; # name of the resolver backend (for human presentation)
! 278:
! 279: my $has_textaware; # set if running on a system that has a text mode concept
! 280: # on files. Windows for example
! 281: my @protocols; # array of lowercase supported protocol servers
! 282:
! 283: my $skipped=0; # number of tests skipped; reported in main loop
! 284: my %skipped; # skipped{reason}=counter, reasons for skip
! 285: my @teststat; # teststat[testnum]=reason, reasons for skip
! 286: my %disabled_keywords; # key words of tests to skip
! 287: my %ignored_keywords; # key words of tests to ignore results
! 288: my %enabled_keywords; # key words of tests to run
! 289: my %disabled; # disabled test cases
! 290: my %ignored; # ignored results of test cases
! 291:
! 292: my $sshdid; # for socks server, ssh daemon version id
! 293: my $sshdvernum; # for socks server, ssh daemon version number
! 294: my $sshdverstr; # for socks server, ssh daemon version string
! 295: my $sshderror; # for socks server, ssh daemon version error
! 296:
! 297: my $defserverlogslocktimeout = 2; # timeout to await server logs lock removal
! 298: my $defpostcommanddelay = 0; # delay between command and postcheck sections
! 299:
! 300: my $timestats; # time stamping and stats generation
! 301: my $fullstats; # show time stats for every single test
! 302: my %timeprepini; # timestamp for each test preparation start
! 303: my %timesrvrini; # timestamp for each test required servers verification start
! 304: my %timesrvrend; # timestamp for each test required servers verification end
! 305: my %timetoolini; # timestamp for each test command run starting
! 306: my %timetoolend; # timestamp for each test command run stopping
! 307: my %timesrvrlog; # timestamp for each test server logs lock removal
! 308: my %timevrfyend; # timestamp for each test result verification end
! 309:
! 310: my $testnumcheck; # test number, set in singletest sub.
! 311: my %oldenv;
! 312: my %feature; # array of enabled features
! 313: my %keywords; # array of keywords from the test spec
! 314:
! 315: #######################################################################
! 316: # variables that command line options may set
! 317: #
! 318:
! 319: my $short;
! 320: my $automakestyle;
! 321: my $verbose;
! 322: my $debugprotocol;
! 323: my $anyway;
! 324: my $gdbthis; # run test case with gdb debugger
! 325: my $gdbxwin; # use windowed gdb when using gdb
! 326: my $keepoutfiles; # keep stdout and stderr files after tests
! 327: my $listonly; # only list the tests
! 328: my $postmortem; # display detailed info about failed tests
! 329: my $run_event_based; # run curl with --test-event to test the event API
! 330:
! 331: my %run; # running server
! 332: my %doesntrun; # servers that don't work, identified by pidfile
! 333: my %serverpidfile;# all server pid file names, identified by server id
! 334: my %serverportfile;# all server port file names, identified by server id
! 335: my %runcert; # cert file currently in use by an ssl running server
! 336:
! 337: # torture test variables
! 338: my $torture;
! 339: my $tortnum;
! 340: my $tortalloc;
! 341: my $shallow;
! 342: my $randseed = 0;
! 343:
! 344: # Azure Pipelines specific variables
! 345: my $AZURE_RUN_ID = 0;
! 346: my $AZURE_RESULT_ID = 0;
! 347:
! 348: #######################################################################
! 349: # logmsg is our general message logging subroutine.
! 350: #
! 351: sub logmsg {
! 352: for(@_) {
! 353: my $line = $_;
! 354: if ($is_wsl) {
! 355: # use \r\n for WSL shell
! 356: $line =~ s/\r?\n$/\r\n/g;
! 357: }
! 358: print "$line";
! 359: }
! 360: }
! 361:
! 362: # get the name of the current user
! 363: my $USER = $ENV{USER}; # Linux
! 364: if (!$USER) {
! 365: $USER = $ENV{USERNAME}; # Windows
! 366: if (!$USER) {
! 367: $USER = $ENV{LOGNAME}; # Some Unix (I think)
! 368: }
! 369: }
! 370:
! 371: # enable memory debugging if curl is compiled with it
! 372: $ENV{'CURL_MEMDEBUG'} = $memdump;
! 373: $ENV{'CURL_ENTROPY'}="12345678";
! 374: $ENV{'CURL_FORCETIME'}=1; # for debug NTLM magic
! 375: $ENV{'HOME'}=$pwd;
! 376: $ENV{'COLUMNS'}=79; # screen width!
! 377:
! 378: sub catch_zap {
! 379: my $signame = shift;
! 380: logmsg "runtests.pl received SIG$signame, exiting\n";
! 381: stopservers($verbose);
! 382: die "Somebody sent me a SIG$signame";
! 383: }
! 384: $SIG{INT} = \&catch_zap;
! 385: $SIG{TERM} = \&catch_zap;
! 386:
! 387: ##########################################################################
! 388: # Clear all possible '*_proxy' environment variables for various protocols
! 389: # to prevent them to interfere with our testing!
! 390:
! 391: my $protocol;
! 392: foreach $protocol (('ftp', 'http', 'ftps', 'https', 'no', 'all')) {
! 393: my $proxy = "${protocol}_proxy";
! 394: # clear lowercase version
! 395: delete $ENV{$proxy} if($ENV{$proxy});
! 396: # clear uppercase version
! 397: delete $ENV{uc($proxy)} if($ENV{uc($proxy)});
! 398: }
! 399:
! 400: # make sure we don't get affected by other variables that control our
! 401: # behaviour
! 402:
! 403: delete $ENV{'SSL_CERT_DIR'} if($ENV{'SSL_CERT_DIR'});
! 404: delete $ENV{'SSL_CERT_PATH'} if($ENV{'SSL_CERT_PATH'});
! 405: delete $ENV{'CURL_CA_BUNDLE'} if($ENV{'CURL_CA_BUNDLE'});
! 406:
! 407: #######################################################################
! 408: # Load serverpidfile and serverportfile hashes with file names for all
! 409: # possible servers.
! 410: #
! 411: sub init_serverpidfile_hash {
! 412: for my $proto (('ftp', 'http', 'imap', 'pop3', 'smtp', 'http/2')) {
! 413: for my $ssl (('', 's')) {
! 414: for my $ipvnum ((4, 6)) {
! 415: for my $idnum ((1, 2, 3)) {
! 416: my $serv = servername_id("$proto$ssl", $ipvnum, $idnum);
! 417: my $pidf = server_pidfilename("$proto$ssl", $ipvnum, $idnum);
! 418: $serverpidfile{$serv} = $pidf;
! 419: my $portf = server_portfilename("$proto$ssl", $ipvnum, $idnum);
! 420: $serverportfile{$serv} = $portf;
! 421: }
! 422: }
! 423: }
! 424: }
! 425: for my $proto (('tftp', 'sftp', 'socks', 'ssh', 'rtsp', 'gopher', 'httptls',
! 426: 'dict', 'smb', 'smbs', 'telnet', 'mqtt')) {
! 427: for my $ipvnum ((4, 6)) {
! 428: for my $idnum ((1, 2)) {
! 429: my $serv = servername_id($proto, $ipvnum, $idnum);
! 430: my $pidf = server_pidfilename($proto, $ipvnum, $idnum);
! 431: $serverpidfile{$serv} = $pidf;
! 432: my $portf = server_portfilename($proto, $ipvnum, $idnum);
! 433: $serverportfile{$serv} = $portf;
! 434: }
! 435: }
! 436: }
! 437: for my $proto (('http', 'imap', 'pop3', 'smtp', 'http/2')) {
! 438: for my $ssl (('', 's')) {
! 439: my $serv = servername_id("$proto$ssl", "unix", 1);
! 440: my $pidf = server_pidfilename("$proto$ssl", "unix", 1);
! 441: $serverpidfile{$serv} = $pidf;
! 442: my $portf = server_portfilename("$proto$ssl", "unix", 1);
! 443: $serverportfile{$serv} = $portf;
! 444: }
! 445: }
! 446: }
! 447:
! 448: #######################################################################
! 449: # Check if a given child process has just died. Reaps it if so.
! 450: #
! 451: sub checkdied {
! 452: use POSIX ":sys_wait_h";
! 453: my $pid = $_[0];
! 454: if((not defined $pid) || $pid <= 0) {
! 455: return 0;
! 456: }
! 457: my $rc = pidwait($pid, &WNOHANG);
! 458: return ($rc == $pid)?1:0;
! 459: }
! 460:
! 461: #######################################################################
! 462: # Start a new thread/process and run the given command line in there.
! 463: # Return the pids (yes plural) of the new child process to the parent.
! 464: #
! 465: sub startnew {
! 466: my ($cmd, $pidfile, $timeout, $fake)=@_;
! 467:
! 468: logmsg "startnew: $cmd\n" if ($verbose);
! 469:
! 470: my $child = fork();
! 471: my $pid2 = 0;
! 472:
! 473: if(not defined $child) {
! 474: logmsg "startnew: fork() failure detected\n";
! 475: return (-1,-1);
! 476: }
! 477:
! 478: if(0 == $child) {
! 479: # Here we are the child. Run the given command.
! 480:
! 481: # Put an "exec" in front of the command so that the child process
! 482: # keeps this child's process ID.
! 483: exec("exec $cmd") || die "Can't exec() $cmd: $!";
! 484:
! 485: # exec() should never return back here to this process. We protect
! 486: # ourselves by calling die() just in case something goes really bad.
! 487: die "error: exec() has returned";
! 488: }
! 489:
! 490: # Ugly hack but ssh client and gnutls-serv don't support pid files
! 491: if ($fake) {
! 492: if(open(OUT, ">$pidfile")) {
! 493: print OUT $child . "\n";
! 494: close(OUT);
! 495: logmsg "startnew: $pidfile faked with pid=$child\n" if($verbose);
! 496: }
! 497: else {
! 498: logmsg "startnew: failed to write fake $pidfile with pid=$child\n";
! 499: }
! 500: # could/should do a while connect fails sleep a bit and loop
! 501: portable_sleep($timeout);
! 502: if (checkdied($child)) {
! 503: logmsg "startnew: child process has failed to start\n" if($verbose);
! 504: return (-1,-1);
! 505: }
! 506: }
! 507:
! 508: my $count = $timeout;
! 509: while($count--) {
! 510: if(-f $pidfile && -s $pidfile && open(PID, "<$pidfile")) {
! 511: $pid2 = 0 + <PID>;
! 512: close(PID);
! 513: if(($pid2 > 0) && pidexists($pid2)) {
! 514: # if $pid2 is valid, then make sure this pid is alive, as
! 515: # otherwise it is just likely to be the _previous_ pidfile or
! 516: # similar!
! 517: last;
! 518: }
! 519: # invalidate $pid2 if not actually alive
! 520: $pid2 = 0;
! 521: }
! 522: if (checkdied($child)) {
! 523: logmsg "startnew: child process has died, server might start up\n"
! 524: if($verbose);
! 525: # We can't just abort waiting for the server with a
! 526: # return (-1,-1);
! 527: # because the server might have forked and could still start
! 528: # up normally. Instead, just reduce the amount of time we remain
! 529: # waiting.
! 530: $count >>= 2;
! 531: }
! 532: sleep(1);
! 533: }
! 534:
! 535: # Return two PIDs, the one for the child process we spawned and the one
! 536: # reported by the server itself (in case it forked again on its own).
! 537: # Both (potentially) need to be killed at the end of the test.
! 538: return ($child, $pid2);
! 539: }
! 540:
! 541:
! 542: #######################################################################
! 543: # Check for a command in the PATH of the test server.
! 544: #
! 545: sub checkcmd {
! 546: my ($cmd)=@_;
! 547: my @paths=(split(":", $ENV{'PATH'}), "/usr/sbin", "/usr/local/sbin",
! 548: "/sbin", "/usr/bin", "/usr/local/bin",
! 549: "./libtest/.libs", "./libtest");
! 550: for(@paths) {
! 551: if( -x "$_/$cmd" && ! -d "$_/$cmd") {
! 552: # executable bit but not a directory!
! 553: return "$_/$cmd";
! 554: }
! 555: }
! 556: }
! 557:
! 558: #######################################################################
! 559: # Get the list of tests that the tests/data/Makefile.am knows about!
! 560: #
! 561: my $disttests;
! 562: sub get_disttests {
! 563: my @dist = `cd data && make show`;
! 564: $disttests = join("", @dist);
! 565: }
! 566:
! 567: #######################################################################
! 568: # Check for a command in the PATH of the machine running curl.
! 569: #
! 570: sub checktestcmd {
! 571: my ($cmd)=@_;
! 572: return checkcmd($cmd);
! 573: }
! 574:
! 575: #######################################################################
! 576: # Run the application under test and return its return code
! 577: #
! 578: sub runclient {
! 579: my ($cmd)=@_;
! 580: my $ret = system($cmd);
! 581: print "CMD ($ret): $cmd\n" if($verbose && !$torture);
! 582: return $ret;
! 583:
! 584: # This is one way to test curl on a remote machine
! 585: # my $out = system("ssh $CLIENTIP cd \'$pwd\' \\; \'$cmd\'");
! 586: # sleep 2; # time to allow the NFS server to be updated
! 587: # return $out;
! 588: }
! 589:
! 590: #######################################################################
! 591: # Run the application under test and return its stdout
! 592: #
! 593: sub runclientoutput {
! 594: my ($cmd)=@_;
! 595: return `$cmd`;
! 596:
! 597: # This is one way to test curl on a remote machine
! 598: # my @out = `ssh $CLIENTIP cd \'$pwd\' \\; \'$cmd\'`;
! 599: # sleep 2; # time to allow the NFS server to be updated
! 600: # return @out;
! 601: }
! 602:
! 603: #######################################################################
! 604: # Memory allocation test and failure torture testing.
! 605: #
! 606: sub torture {
! 607: my ($testcmd, $testnum, $gdbline) = @_;
! 608:
! 609: # remove memdump first to be sure we get a new nice and clean one
! 610: unlink($memdump);
! 611:
! 612: # First get URL from test server, ignore the output/result
! 613: runclient($testcmd);
! 614:
! 615: logmsg " CMD: $testcmd\n" if($verbose);
! 616:
! 617: # memanalyze -v is our friend, get the number of allocations made
! 618: my $count=0;
! 619: my @out = `$memanalyze -v $memdump`;
! 620: for(@out) {
! 621: if(/^Operations: (\d+)/) {
! 622: $count = $1;
! 623: last;
! 624: }
! 625: }
! 626: if(!$count) {
! 627: logmsg " found no functions to make fail\n";
! 628: return 0;
! 629: }
! 630:
! 631: my @ttests = (1 .. $count);
! 632: if($shallow && ($shallow < $count)) {
! 633: my $discard = scalar(@ttests) - $shallow;
! 634: my $percent = sprintf("%.2f%%", $shallow * 100 / scalar(@ttests));;
! 635: logmsg " $count functions found, but only fail $shallow ($percent)\n";
! 636: while($discard) {
! 637: my $rm;
! 638: do {
! 639: # find a test to discard
! 640: $rm = rand(scalar(@ttests));
! 641: } while(!$ttests[$rm]);
! 642: $ttests[$rm] = undef;
! 643: $discard--;
! 644: }
! 645: }
! 646: else {
! 647: logmsg " $count functions to make fail\n";
! 648: }
! 649:
! 650: for (@ttests) {
! 651: my $limit = $_;
! 652: my $fail;
! 653: my $dumped_core;
! 654:
! 655: if(!defined($limit)) {
! 656: # --shallow can undefine them
! 657: next;
! 658: }
! 659: if($tortalloc && ($tortalloc != $limit)) {
! 660: next;
! 661: }
! 662:
! 663: if($verbose) {
! 664: my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
! 665: localtime(time());
! 666: my $now = sprintf("%02d:%02d:%02d ", $hour, $min, $sec);
! 667: logmsg "Fail function no: $limit at $now\r";
! 668: }
! 669:
! 670: # make the memory allocation function number $limit return failure
! 671: $ENV{'CURL_MEMLIMIT'} = $limit;
! 672:
! 673: # remove memdump first to be sure we get a new nice and clean one
! 674: unlink($memdump);
! 675:
! 676: my $cmd = $testcmd;
! 677: if($valgrind && !$gdbthis) {
! 678: my @valgrindoption = getpart("verify", "valgrind");
! 679: if((!@valgrindoption) || ($valgrindoption[0] !~ /disable/)) {
! 680: my $valgrindcmd = "$valgrind ";
! 681: $valgrindcmd .= "$valgrind_tool " if($valgrind_tool);
! 682: $valgrindcmd .= "--quiet --leak-check=yes ";
! 683: $valgrindcmd .= "--suppressions=$srcdir/valgrind.supp ";
! 684: # $valgrindcmd .= "--gen-suppressions=all ";
! 685: $valgrindcmd .= "--num-callers=16 ";
! 686: $valgrindcmd .= "${valgrind_logfile}=$LOGDIR/valgrind$testnum";
! 687: $cmd = "$valgrindcmd $testcmd";
! 688: }
! 689: }
! 690: logmsg "*** Function number $limit is now set to fail ***\n" if($gdbthis);
! 691:
! 692: my $ret = 0;
! 693: if($gdbthis) {
! 694: runclient($gdbline);
! 695: }
! 696: else {
! 697: $ret = runclient($cmd);
! 698: }
! 699: #logmsg "$_ Returned " . ($ret >> 8) . "\n";
! 700:
! 701: # Now clear the variable again
! 702: delete $ENV{'CURL_MEMLIMIT'} if($ENV{'CURL_MEMLIMIT'});
! 703:
! 704: if(-r "core") {
! 705: # there's core file present now!
! 706: logmsg " core dumped\n";
! 707: $dumped_core = 1;
! 708: $fail = 2;
! 709: }
! 710:
! 711: if($valgrind) {
! 712: my @e = valgrindparse("$LOGDIR/valgrind$testnum");
! 713: if(@e && $e[0]) {
! 714: if($automakestyle) {
! 715: logmsg "FAIL: torture $testnum - valgrind\n";
! 716: }
! 717: else {
! 718: logmsg " valgrind ERROR ";
! 719: logmsg @e;
! 720: }
! 721: $fail = 1;
! 722: }
! 723: }
! 724:
! 725: # verify that it returns a proper error code, doesn't leak memory
! 726: # and doesn't core dump
! 727: if(($ret & 255) || ($ret >> 8) >= 128) {
! 728: logmsg " system() returned $ret\n";
! 729: $fail=1;
! 730: }
! 731: else {
! 732: my @memdata=`$memanalyze $memdump`;
! 733: my $leak=0;
! 734: for(@memdata) {
! 735: if($_ ne "") {
! 736: # well it could be other memory problems as well, but
! 737: # we call it leak for short here
! 738: $leak=1;
! 739: }
! 740: }
! 741: if($leak) {
! 742: logmsg "** MEMORY FAILURE\n";
! 743: logmsg @memdata;
! 744: logmsg `$memanalyze -l $memdump`;
! 745: $fail = 1;
! 746: }
! 747: }
! 748: if($fail) {
! 749: logmsg " Failed on function number $limit in test.\n",
! 750: " invoke with \"-t$limit\" to repeat this single case.\n";
! 751: stopservers($verbose);
! 752: return 1;
! 753: }
! 754: }
! 755:
! 756: logmsg "torture OK\n";
! 757: return 0;
! 758: }
! 759:
! 760: #######################################################################
! 761: # Stop a test server along with pids which aren't in the %run hash yet.
! 762: # This also stops all servers which are relative to the given one.
! 763: #
! 764: sub stopserver {
! 765: my ($server, $pidlist) = @_;
! 766:
! 767: #
! 768: # kill sockfilter processes for pingpong relative server
! 769: #
! 770: if($server =~ /^(ftp|imap|pop3|smtp)s?(\d*)(-ipv6|)$/) {
! 771: my $proto = $1;
! 772: my $idnum = ($2 && ($2 > 1)) ? $2 : 1;
! 773: my $ipvnum = ($3 && ($3 =~ /6$/)) ? 6 : 4;
! 774: killsockfilters($proto, $ipvnum, $idnum, $verbose);
! 775: }
! 776: #
! 777: # All servers relative to the given one must be stopped also
! 778: #
! 779: my @killservers;
! 780: if($server =~ /^(ftp|http|imap|pop3|smtp)s((\d*)(-ipv6|-unix|))$/) {
! 781: # given a stunnel based ssl server, also kill non-ssl underlying one
! 782: push @killservers, "${1}${2}";
! 783: }
! 784: elsif($server =~ /^(ftp|http|imap|pop3|smtp)((\d*)(-ipv6|-unix|))$/) {
! 785: # given a non-ssl server, also kill stunnel based ssl piggybacking one
! 786: push @killservers, "${1}s${2}";
! 787: }
! 788: elsif($server =~ /^(socks)((\d*)(-ipv6|))$/) {
! 789: # given a socks server, also kill ssh underlying one
! 790: push @killservers, "ssh${2}";
! 791: }
! 792: elsif($server =~ /^(ssh)((\d*)(-ipv6|))$/) {
! 793: # given a ssh server, also kill socks piggybacking one
! 794: push @killservers, "socks${2}";
! 795: }
! 796: if($server eq "http") {
! 797: # since the http2 server is a proxy that needs to know about the
! 798: # dynamic http port it too needs to get restarted when the http server
! 799: # is killed
! 800: push @killservers, "http/2";
! 801: }
! 802: push @killservers, $server;
! 803: #
! 804: # kill given pids and server relative ones clearing them in %run hash
! 805: #
! 806: foreach my $server (@killservers) {
! 807: if($run{$server}) {
! 808: # we must prepend a space since $pidlist may already contain a pid
! 809: $pidlist .= " $run{$server}";
! 810: $run{$server} = 0;
! 811: }
! 812: $runcert{$server} = 0 if($runcert{$server});
! 813: }
! 814: killpid($verbose, $pidlist);
! 815: #
! 816: # cleanup server pid files
! 817: #
! 818: foreach my $server (@killservers) {
! 819: my $pidfile = $serverpidfile{$server};
! 820: my $pid = processexists($pidfile);
! 821: if($pid > 0) {
! 822: logmsg "Warning: $server server unexpectedly alive\n";
! 823: killpid($verbose, $pid);
! 824: }
! 825: unlink($pidfile) if(-f $pidfile);
! 826: }
! 827: }
! 828:
! 829: #######################################################################
! 830: # Verify that the server that runs on $ip, $port is our server. This also
! 831: # implies that we can speak with it, as there might be occasions when the
! 832: # server runs fine but we cannot talk to it ("Failed to connect to ::1: Can't
! 833: # assign requested address")
! 834: #
! 835: sub verifyhttp {
! 836: my ($proto, $ipvnum, $idnum, $ip, $port_or_path) = @_;
! 837: my $server = servername_id($proto, $ipvnum, $idnum);
! 838: my $pid = 0;
! 839: my $bonus="";
! 840: # $port_or_path contains a path for Unix sockets, sws ignores the port
! 841: my $port = ($ipvnum eq "unix") ? 80 : $port_or_path;
! 842:
! 843: my $verifyout = "$LOGDIR/".
! 844: servername_canon($proto, $ipvnum, $idnum) .'_verify.out';
! 845: unlink($verifyout) if(-f $verifyout);
! 846:
! 847: my $verifylog = "$LOGDIR/".
! 848: servername_canon($proto, $ipvnum, $idnum) .'_verify.log';
! 849: unlink($verifylog) if(-f $verifylog);
! 850:
! 851: if($proto eq "gopher") {
! 852: # gopher is funny
! 853: $bonus="1/";
! 854: }
! 855:
! 856: my $flags = "--max-time $server_response_maxtime ";
! 857: $flags .= "--output $verifyout ";
! 858: $flags .= "--silent ";
! 859: $flags .= "--verbose ";
! 860: $flags .= "--globoff ";
! 861: $flags .= "--unix-socket '$port_or_path' " if $ipvnum eq "unix";
! 862: $flags .= "--insecure " if($proto eq 'https');
! 863: $flags .= "\"$proto://$ip:$port/${bonus}verifiedserver\"";
! 864:
! 865: my $cmd = "$VCURL $flags 2>$verifylog";
! 866:
! 867: # verify if our/any server is running on this port
! 868: logmsg "RUN: $cmd\n" if($verbose);
! 869: my $res = runclient($cmd);
! 870:
! 871: $res >>= 8; # rotate the result
! 872: if($res & 128) {
! 873: logmsg "RUN: curl command died with a coredump\n";
! 874: return -1;
! 875: }
! 876:
! 877: if($res && $verbose) {
! 878: logmsg "RUN: curl command returned $res\n";
! 879: if(open(FILE, "<$verifylog")) {
! 880: while(my $string = <FILE>) {
! 881: logmsg "RUN: $string" if($string !~ /^([ \t]*)$/);
! 882: }
! 883: close(FILE);
! 884: }
! 885: }
! 886:
! 887: my $data;
! 888: if(open(FILE, "<$verifyout")) {
! 889: while(my $string = <FILE>) {
! 890: $data = $string;
! 891: last; # only want first line
! 892: }
! 893: close(FILE);
! 894: }
! 895:
! 896: if($data && ($data =~ /WE ROOLZ: (\d+)/)) {
! 897: $pid = 0+$1;
! 898: }
! 899: elsif($res == 6) {
! 900: # curl: (6) Couldn't resolve host '::1'
! 901: logmsg "RUN: failed to resolve host ($proto://$ip:$port/verifiedserver)\n";
! 902: return -1;
! 903: }
! 904: elsif($data || ($res && ($res != 7))) {
! 905: logmsg "RUN: Unknown server on our $server port: $port ($res)\n";
! 906: return -1;
! 907: }
! 908: return $pid;
! 909: }
! 910:
! 911: #######################################################################
! 912: # Verify that the server that runs on $ip, $port is our server. This also
! 913: # implies that we can speak with it, as there might be occasions when the
! 914: # server runs fine but we cannot talk to it ("Failed to connect to ::1: Can't
! 915: # assign requested address")
! 916: #
! 917: sub verifyftp {
! 918: my ($proto, $ipvnum, $idnum, $ip, $port) = @_;
! 919: my $server = servername_id($proto, $ipvnum, $idnum);
! 920: my $pid = 0;
! 921: my $time=time();
! 922: my $extra="";
! 923:
! 924: my $verifylog = "$LOGDIR/".
! 925: servername_canon($proto, $ipvnum, $idnum) .'_verify.log';
! 926: unlink($verifylog) if(-f $verifylog);
! 927:
! 928: if($proto eq "ftps") {
! 929: $extra .= "--insecure --ftp-ssl-control ";
! 930: }
! 931:
! 932: my $flags = "--max-time $server_response_maxtime ";
! 933: $flags .= "--silent ";
! 934: $flags .= "--verbose ";
! 935: $flags .= "--globoff ";
! 936: $flags .= $extra;
! 937: $flags .= "\"$proto://$ip:$port/verifiedserver\"";
! 938:
! 939: my $cmd = "$VCURL $flags 2>$verifylog";
! 940:
! 941: # check if this is our server running on this port:
! 942: logmsg "RUN: $cmd\n" if($verbose);
! 943: my @data = runclientoutput($cmd);
! 944:
! 945: my $res = $? >> 8; # rotate the result
! 946: if($res & 128) {
! 947: logmsg "RUN: curl command died with a coredump\n";
! 948: return -1;
! 949: }
! 950:
! 951: foreach my $line (@data) {
! 952: if($line =~ /WE ROOLZ: (\d+)/) {
! 953: # this is our test server with a known pid!
! 954: $pid = 0+$1;
! 955: last;
! 956: }
! 957: }
! 958: if($pid <= 0 && @data && $data[0]) {
! 959: # this is not a known server
! 960: logmsg "RUN: Unknown server on our $server port: $port\n";
! 961: return 0;
! 962: }
! 963: # we can/should use the time it took to verify the FTP server as a measure
! 964: # on how fast/slow this host/FTP is.
! 965: my $took = int(0.5+time()-$time);
! 966:
! 967: if($verbose) {
! 968: logmsg "RUN: Verifying our test $server server took $took seconds\n";
! 969: }
! 970: $ftpchecktime = $took>=1?$took:1; # make sure it never is below 1
! 971:
! 972: return $pid;
! 973: }
! 974:
! 975: #######################################################################
! 976: # Verify that the server that runs on $ip, $port is our server. This also
! 977: # implies that we can speak with it, as there might be occasions when the
! 978: # server runs fine but we cannot talk to it ("Failed to connect to ::1: Can't
! 979: # assign requested address")
! 980: #
! 981: sub verifyrtsp {
! 982: my ($proto, $ipvnum, $idnum, $ip, $port) = @_;
! 983: my $server = servername_id($proto, $ipvnum, $idnum);
! 984: my $pid = 0;
! 985:
! 986: my $verifyout = "$LOGDIR/".
! 987: servername_canon($proto, $ipvnum, $idnum) .'_verify.out';
! 988: unlink($verifyout) if(-f $verifyout);
! 989:
! 990: my $verifylog = "$LOGDIR/".
! 991: servername_canon($proto, $ipvnum, $idnum) .'_verify.log';
! 992: unlink($verifylog) if(-f $verifylog);
! 993:
! 994: my $flags = "--max-time $server_response_maxtime ";
! 995: $flags .= "--output $verifyout ";
! 996: $flags .= "--silent ";
! 997: $flags .= "--verbose ";
! 998: $flags .= "--globoff ";
! 999: # currently verification is done using http
! 1000: $flags .= "\"http://$ip:$port/verifiedserver\"";
! 1001:
! 1002: my $cmd = "$VCURL $flags 2>$verifylog";
! 1003:
! 1004: # verify if our/any server is running on this port
! 1005: logmsg "RUN: $cmd\n" if($verbose);
! 1006: my $res = runclient($cmd);
! 1007:
! 1008: $res >>= 8; # rotate the result
! 1009: if($res & 128) {
! 1010: logmsg "RUN: curl command died with a coredump\n";
! 1011: return -1;
! 1012: }
! 1013:
! 1014: if($res && $verbose) {
! 1015: logmsg "RUN: curl command returned $res\n";
! 1016: if(open(FILE, "<$verifylog")) {
! 1017: while(my $string = <FILE>) {
! 1018: logmsg "RUN: $string" if($string !~ /^([ \t]*)$/);
! 1019: }
! 1020: close(FILE);
! 1021: }
! 1022: }
! 1023:
! 1024: my $data;
! 1025: if(open(FILE, "<$verifyout")) {
! 1026: while(my $string = <FILE>) {
! 1027: $data = $string;
! 1028: last; # only want first line
! 1029: }
! 1030: close(FILE);
! 1031: }
! 1032:
! 1033: if($data && ($data =~ /RTSP_SERVER WE ROOLZ: (\d+)/)) {
! 1034: $pid = 0+$1;
! 1035: }
! 1036: elsif($res == 6) {
! 1037: # curl: (6) Couldn't resolve host '::1'
! 1038: logmsg "RUN: failed to resolve host ($proto://$ip:$port/verifiedserver)\n";
! 1039: return -1;
! 1040: }
! 1041: elsif($data || ($res != 7)) {
! 1042: logmsg "RUN: Unknown server on our $server port: $port\n";
! 1043: return -1;
! 1044: }
! 1045: return $pid;
! 1046: }
! 1047:
! 1048: #######################################################################
! 1049: # Verify that the ssh server has written out its pidfile, recovering
! 1050: # the pid from the file and returning it if a process with that pid is
! 1051: # actually alive.
! 1052: #
! 1053: sub verifyssh {
! 1054: my ($proto, $ipvnum, $idnum, $ip, $port) = @_;
! 1055: my $server = servername_id($proto, $ipvnum, $idnum);
! 1056: my $pidfile = server_pidfilename($proto, $ipvnum, $idnum);
! 1057: my $pid = 0;
! 1058: if(open(FILE, "<$pidfile")) {
! 1059: $pid=0+<FILE>;
! 1060: close(FILE);
! 1061: }
! 1062: if($pid > 0) {
! 1063: # if we have a pid it is actually our ssh server,
! 1064: # since runsshserver() unlinks previous pidfile
! 1065: if(!pidexists($pid)) {
! 1066: logmsg "RUN: SSH server has died after starting up\n";
! 1067: checkdied($pid);
! 1068: unlink($pidfile);
! 1069: $pid = -1;
! 1070: }
! 1071: }
! 1072: return $pid;
! 1073: }
! 1074:
! 1075: #######################################################################
! 1076: # Verify that we can connect to the sftp server, properly authenticate
! 1077: # with generated config and key files and run a simple remote pwd.
! 1078: #
! 1079: sub verifysftp {
! 1080: my ($proto, $ipvnum, $idnum, $ip, $port) = @_;
! 1081: my $server = servername_id($proto, $ipvnum, $idnum);
! 1082: my $verified = 0;
! 1083: # Find out sftp client canonical file name
! 1084: my $sftp = find_sftp();
! 1085: if(!$sftp) {
! 1086: logmsg "RUN: SFTP server cannot find $sftpexe\n";
! 1087: return -1;
! 1088: }
! 1089: # Find out ssh client canonical file name
! 1090: my $ssh = find_ssh();
! 1091: if(!$ssh) {
! 1092: logmsg "RUN: SFTP server cannot find $sshexe\n";
! 1093: return -1;
! 1094: }
! 1095: # Connect to sftp server, authenticate and run a remote pwd
! 1096: # command using our generated configuration and key files
! 1097: my $cmd = "\"$sftp\" -b $sftpcmds -F $sftpconfig -S \"$ssh\" $ip > $sftplog 2>&1";
! 1098: my $res = runclient($cmd);
! 1099: # Search for pwd command response in log file
! 1100: if(open(SFTPLOGFILE, "<$sftplog")) {
! 1101: while(<SFTPLOGFILE>) {
! 1102: if(/^Remote working directory: /) {
! 1103: $verified = 1;
! 1104: last;
! 1105: }
! 1106: }
! 1107: close(SFTPLOGFILE);
! 1108: }
! 1109: return $verified;
! 1110: }
! 1111:
! 1112: #######################################################################
! 1113: # Verify that the non-stunnel HTTP TLS extensions capable server that runs
! 1114: # on $ip, $port is our server. This also implies that we can speak with it,
! 1115: # as there might be occasions when the server runs fine but we cannot talk
! 1116: # to it ("Failed to connect to ::1: Can't assign requested address")
! 1117: #
! 1118: sub verifyhttptls {
! 1119: my ($proto, $ipvnum, $idnum, $ip, $port) = @_;
! 1120: my $server = servername_id($proto, $ipvnum, $idnum);
! 1121: my $pidfile = server_pidfilename($proto, $ipvnum, $idnum);
! 1122: my $pid = 0;
! 1123:
! 1124: my $verifyout = "$LOGDIR/".
! 1125: servername_canon($proto, $ipvnum, $idnum) .'_verify.out';
! 1126: unlink($verifyout) if(-f $verifyout);
! 1127:
! 1128: my $verifylog = "$LOGDIR/".
! 1129: servername_canon($proto, $ipvnum, $idnum) .'_verify.log';
! 1130: unlink($verifylog) if(-f $verifylog);
! 1131:
! 1132: my $flags = "--max-time $server_response_maxtime ";
! 1133: $flags .= "--output $verifyout ";
! 1134: $flags .= "--verbose ";
! 1135: $flags .= "--globoff ";
! 1136: $flags .= "--insecure ";
! 1137: $flags .= "--tlsauthtype SRP ";
! 1138: $flags .= "--tlsuser jsmith ";
! 1139: $flags .= "--tlspassword abc ";
! 1140: $flags .= "\"https://$ip:$port/verifiedserver\"";
! 1141:
! 1142: my $cmd = "$VCURL $flags 2>$verifylog";
! 1143:
! 1144: # verify if our/any server is running on this port
! 1145: logmsg "RUN: $cmd\n" if($verbose);
! 1146: my $res = runclient($cmd);
! 1147:
! 1148: $res >>= 8; # rotate the result
! 1149: if($res & 128) {
! 1150: logmsg "RUN: curl command died with a coredump\n";
! 1151: return -1;
! 1152: }
! 1153:
! 1154: if($res && $verbose) {
! 1155: logmsg "RUN: curl command returned $res\n";
! 1156: if(open(FILE, "<$verifylog")) {
! 1157: while(my $string = <FILE>) {
! 1158: logmsg "RUN: $string" if($string !~ /^([ \t]*)$/);
! 1159: }
! 1160: close(FILE);
! 1161: }
! 1162: }
! 1163:
! 1164: my $data;
! 1165: if(open(FILE, "<$verifyout")) {
! 1166: while(my $string = <FILE>) {
! 1167: $data .= $string;
! 1168: }
! 1169: close(FILE);
! 1170: }
! 1171:
! 1172: if($data && ($data =~ /(GNUTLS|GnuTLS)/) && open(FILE, "<$pidfile")) {
! 1173: $pid=0+<FILE>;
! 1174: close(FILE);
! 1175: if($pid > 0) {
! 1176: # if we have a pid it is actually our httptls server,
! 1177: # since runhttptlsserver() unlinks previous pidfile
! 1178: if(!pidexists($pid)) {
! 1179: logmsg "RUN: $server server has died after starting up\n";
! 1180: checkdied($pid);
! 1181: unlink($pidfile);
! 1182: $pid = -1;
! 1183: }
! 1184: }
! 1185: return $pid;
! 1186: }
! 1187: elsif($res == 6) {
! 1188: # curl: (6) Couldn't resolve host '::1'
! 1189: logmsg "RUN: failed to resolve host (https://$ip:$port/verifiedserver)\n";
! 1190: return -1;
! 1191: }
! 1192: elsif($data || ($res && ($res != 7))) {
! 1193: logmsg "RUN: Unknown server on our $server port: $port ($res)\n";
! 1194: return -1;
! 1195: }
! 1196: return $pid;
! 1197: }
! 1198:
! 1199: #######################################################################
! 1200: # STUB for verifying socks
! 1201: #
! 1202: sub verifysocks {
! 1203: my ($proto, $ipvnum, $idnum, $ip, $port) = @_;
! 1204: my $server = servername_id($proto, $ipvnum, $idnum);
! 1205: my $pidfile = server_pidfilename($proto, $ipvnum, $idnum);
! 1206: my $pid = 0;
! 1207: if(open(FILE, "<$pidfile")) {
! 1208: $pid=0+<FILE>;
! 1209: close(FILE);
! 1210: }
! 1211: if($pid > 0) {
! 1212: # if we have a pid it is actually our socks server,
! 1213: # since runsocksserver() unlinks previous pidfile
! 1214: if(!pidexists($pid)) {
! 1215: logmsg "RUN: SOCKS server has died after starting up\n";
! 1216: checkdied($pid);
! 1217: unlink($pidfile);
! 1218: $pid = -1;
! 1219: }
! 1220: }
! 1221: return $pid;
! 1222: }
! 1223:
! 1224: #######################################################################
! 1225: # Verify that the server that runs on $ip, $port is our server. This also
! 1226: # implies that we can speak with it, as there might be occasions when the
! 1227: # server runs fine but we cannot talk to it ("Failed to connect to ::1: Can't
! 1228: # assign requested address")
! 1229: #
! 1230: sub verifysmb {
! 1231: my ($proto, $ipvnum, $idnum, $ip, $port) = @_;
! 1232: my $server = servername_id($proto, $ipvnum, $idnum);
! 1233: my $pid = 0;
! 1234: my $time=time();
! 1235: my $extra="";
! 1236:
! 1237: my $verifylog = "$LOGDIR/".
! 1238: servername_canon($proto, $ipvnum, $idnum) .'_verify.log';
! 1239: unlink($verifylog) if(-f $verifylog);
! 1240:
! 1241: my $flags = "--max-time $server_response_maxtime ";
! 1242: $flags .= "--silent ";
! 1243: $flags .= "--verbose ";
! 1244: $flags .= "--globoff ";
! 1245: $flags .= "-u 'curltest:curltest' ";
! 1246: $flags .= $extra;
! 1247: $flags .= "\"$proto://$ip:$port/SERVER/verifiedserver\"";
! 1248:
! 1249: my $cmd = "$VCURL $flags 2>$verifylog";
! 1250:
! 1251: # check if this is our server running on this port:
! 1252: logmsg "RUN: $cmd\n" if($verbose);
! 1253: my @data = runclientoutput($cmd);
! 1254:
! 1255: my $res = $? >> 8; # rotate the result
! 1256: if($res & 128) {
! 1257: logmsg "RUN: curl command died with a coredump\n";
! 1258: return -1;
! 1259: }
! 1260:
! 1261: foreach my $line (@data) {
! 1262: if($line =~ /WE ROOLZ: (\d+)/) {
! 1263: # this is our test server with a known pid!
! 1264: $pid = 0+$1;
! 1265: last;
! 1266: }
! 1267: }
! 1268: if($pid <= 0 && @data && $data[0]) {
! 1269: # this is not a known server
! 1270: logmsg "RUN: Unknown server on our $server port: $port\n";
! 1271: return 0;
! 1272: }
! 1273: # we can/should use the time it took to verify the server as a measure
! 1274: # on how fast/slow this host is.
! 1275: my $took = int(0.5+time()-$time);
! 1276:
! 1277: if($verbose) {
! 1278: logmsg "RUN: Verifying our test $server server took $took seconds\n";
! 1279: }
! 1280: $ftpchecktime = $took>=1?$took:1; # make sure it never is below 1
! 1281:
! 1282: return $pid;
! 1283: }
! 1284:
! 1285: #######################################################################
! 1286: # Verify that the server that runs on $ip, $port is our server. This also
! 1287: # implies that we can speak with it, as there might be occasions when the
! 1288: # server runs fine but we cannot talk to it ("Failed to connect to ::1: Can't
! 1289: # assign requested address")
! 1290: #
! 1291: sub verifytelnet {
! 1292: my ($proto, $ipvnum, $idnum, $ip, $port) = @_;
! 1293: my $server = servername_id($proto, $ipvnum, $idnum);
! 1294: my $pid = 0;
! 1295: my $time=time();
! 1296: my $extra="";
! 1297:
! 1298: my $verifylog = "$LOGDIR/".
! 1299: servername_canon($proto, $ipvnum, $idnum) .'_verify.log';
! 1300: unlink($verifylog) if(-f $verifylog);
! 1301:
! 1302: my $flags = "--max-time $server_response_maxtime ";
! 1303: $flags .= "--silent ";
! 1304: $flags .= "--verbose ";
! 1305: $flags .= "--globoff ";
! 1306: $flags .= "--upload-file - ";
! 1307: $flags .= $extra;
! 1308: $flags .= "\"$proto://$ip:$port\"";
! 1309:
! 1310: my $cmd = "echo 'verifiedserver' | $VCURL $flags 2>$verifylog";
! 1311:
! 1312: # check if this is our server running on this port:
! 1313: logmsg "RUN: $cmd\n" if($verbose);
! 1314: my @data = runclientoutput($cmd);
! 1315:
! 1316: my $res = $? >> 8; # rotate the result
! 1317: if($res & 128) {
! 1318: logmsg "RUN: curl command died with a coredump\n";
! 1319: return -1;
! 1320: }
! 1321:
! 1322: foreach my $line (@data) {
! 1323: if($line =~ /WE ROOLZ: (\d+)/) {
! 1324: # this is our test server with a known pid!
! 1325: $pid = 0+$1;
! 1326: last;
! 1327: }
! 1328: }
! 1329: if($pid <= 0 && @data && $data[0]) {
! 1330: # this is not a known server
! 1331: logmsg "RUN: Unknown server on our $server port: $port\n";
! 1332: return 0;
! 1333: }
! 1334: # we can/should use the time it took to verify the server as a measure
! 1335: # on how fast/slow this host is.
! 1336: my $took = int(0.5+time()-$time);
! 1337:
! 1338: if($verbose) {
! 1339: logmsg "RUN: Verifying our test $server server took $took seconds\n";
! 1340: }
! 1341:
! 1342: return $pid;
! 1343: }
! 1344:
! 1345:
! 1346: #######################################################################
! 1347: # Verify that the server that runs on $ip, $port is our server.
! 1348: # Retry over several seconds before giving up. The ssh server in
! 1349: # particular can take a long time to start if it needs to generate
! 1350: # keys on a slow or loaded host.
! 1351: #
! 1352: # Just for convenience, test harness uses 'https' and 'httptls' literals
! 1353: # as values for 'proto' variable in order to differentiate different
! 1354: # servers. 'https' literal is used for stunnel based https test servers,
! 1355: # and 'httptls' is used for non-stunnel https test servers.
! 1356: #
! 1357:
! 1358: my %protofunc = ('http' => \&verifyhttp,
! 1359: 'https' => \&verifyhttp,
! 1360: 'rtsp' => \&verifyrtsp,
! 1361: 'ftp' => \&verifyftp,
! 1362: 'pop3' => \&verifyftp,
! 1363: 'imap' => \&verifyftp,
! 1364: 'smtp' => \&verifyftp,
! 1365: 'ftps' => \&verifyftp,
! 1366: 'tftp' => \&verifyftp,
! 1367: 'ssh' => \&verifyssh,
! 1368: 'socks' => \&verifysocks,
! 1369: 'gopher' => \&verifyhttp,
! 1370: 'httptls' => \&verifyhttptls,
! 1371: 'dict' => \&verifyftp,
! 1372: 'smb' => \&verifysmb,
! 1373: 'telnet' => \&verifytelnet);
! 1374:
! 1375: sub verifyserver {
! 1376: my ($proto, $ipvnum, $idnum, $ip, $port) = @_;
! 1377:
! 1378: my $count = 30; # try for this many seconds
! 1379: my $pid;
! 1380:
! 1381: while($count--) {
! 1382: my $fun = $protofunc{$proto};
! 1383:
! 1384: $pid = &$fun($proto, $ipvnum, $idnum, $ip, $port);
! 1385:
! 1386: if($pid > 0) {
! 1387: last;
! 1388: }
! 1389: elsif($pid < 0) {
! 1390: # a real failure, stop trying and bail out
! 1391: return 0;
! 1392: }
! 1393: sleep(1);
! 1394: }
! 1395: return $pid;
! 1396: }
! 1397:
! 1398: #######################################################################
! 1399: # Single shot server responsiveness test. This should only be used
! 1400: # to verify that a server present in %run hash is still functional
! 1401: #
! 1402: sub responsiveserver {
! 1403: my ($proto, $ipvnum, $idnum, $ip, $port) = @_;
! 1404: my $prev_verbose = $verbose;
! 1405:
! 1406: $verbose = 0;
! 1407: my $fun = $protofunc{$proto};
! 1408: my $pid = &$fun($proto, $ipvnum, $idnum, $ip, $port);
! 1409: $verbose = $prev_verbose;
! 1410:
! 1411: if($pid > 0) {
! 1412: return 1; # responsive
! 1413: }
! 1414:
! 1415: my $srvrname = servername_str($proto, $ipvnum, $idnum);
! 1416: logmsg " server precheck FAILED (unresponsive $srvrname server)\n";
! 1417: return 0;
! 1418: }
! 1419:
! 1420: #######################################################################
! 1421: # start the http2 server
! 1422: #
! 1423: sub runhttp2server {
! 1424: my ($verbose, $port) = @_;
! 1425: my $server;
! 1426: my $srvrname;
! 1427: my $pidfile;
! 1428: my $logfile;
! 1429: my $flags = "";
! 1430: my $proto="http/2";
! 1431: my $ipvnum = 4;
! 1432: my $idnum = 0;
! 1433: my $exe = "$perl $srcdir/http2-server.pl";
! 1434: my $verbose_flag = "--verbose ";
! 1435:
! 1436: $server = servername_id($proto, $ipvnum, $idnum);
! 1437:
! 1438: $pidfile = $serverpidfile{$server};
! 1439:
! 1440: # don't retry if the server doesn't work
! 1441: if ($doesntrun{$pidfile}) {
! 1442: return (0,0);
! 1443: }
! 1444:
! 1445: my $pid = processexists($pidfile);
! 1446: if($pid > 0) {
! 1447: stopserver($server, "$pid");
! 1448: }
! 1449: unlink($pidfile) if(-f $pidfile);
! 1450:
! 1451: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 1452:
! 1453: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 1454:
! 1455: $flags .= "--pidfile \"$pidfile\" --logfile \"$logfile\" ";
! 1456: $flags .= "--port $HTTP2PORT ";
! 1457: $flags .= "--connect $HOSTIP:$HTTPPORT ";
! 1458: $flags .= $verbose_flag if($debugprotocol);
! 1459:
! 1460: my $cmd = "$exe $flags";
! 1461: my ($http2pid, $pid2) = startnew($cmd, $pidfile, 15, 0);
! 1462:
! 1463: if($http2pid <= 0 || !pidexists($http2pid)) {
! 1464: # it is NOT alive
! 1465: logmsg "RUN: failed to start the $srvrname server\n";
! 1466: stopserver($server, "$pid2");
! 1467: $doesntrun{$pidfile} = 1;
! 1468: return (0,0);
! 1469: }
! 1470:
! 1471: if($verbose) {
! 1472: logmsg "RUN: $srvrname server is now running PID $http2pid\n";
! 1473: }
! 1474:
! 1475: return ($http2pid, $pid2);
! 1476: }
! 1477:
! 1478: #######################################################################
! 1479: # start the http server
! 1480: #
! 1481: sub runhttpserver {
! 1482: my ($proto, $verbose, $alt, $port_or_path) = @_;
! 1483: my $ip = $HOSTIP;
! 1484: my $ipvnum = 4;
! 1485: my $idnum = 1;
! 1486: my $server;
! 1487: my $srvrname;
! 1488: my $pidfile;
! 1489: my $logfile;
! 1490: my $flags = "";
! 1491: my $exe = "$perl $srcdir/httpserver.pl";
! 1492: my $verbose_flag = "--verbose ";
! 1493:
! 1494: if($alt eq "ipv6") {
! 1495: # if IPv6, use a different setup
! 1496: $ipvnum = 6;
! 1497: $ip = $HOST6IP;
! 1498: }
! 1499: elsif($alt eq "proxy") {
! 1500: # basically the same, but another ID
! 1501: $idnum = 2;
! 1502: }
! 1503: elsif($alt eq "unix") {
! 1504: # IP (protocol) is mutually exclusive with Unix sockets
! 1505: $ipvnum = "unix";
! 1506: }
! 1507:
! 1508: $server = servername_id($proto, $ipvnum, $idnum);
! 1509:
! 1510: $pidfile = $serverpidfile{$server};
! 1511: my $portfile = $serverportfile{$server};
! 1512:
! 1513: # don't retry if the server doesn't work
! 1514: if ($doesntrun{$pidfile}) {
! 1515: return (0,0);
! 1516: }
! 1517:
! 1518: my $pid = processexists($pidfile);
! 1519: if($pid > 0) {
! 1520: stopserver($server, "$pid");
! 1521: }
! 1522: unlink($pidfile) if(-f $pidfile);
! 1523:
! 1524: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 1525:
! 1526: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 1527:
! 1528: $flags .= "--gopher " if($proto eq "gopher");
! 1529: $flags .= "--connect $HOSTIP " if($alt eq "proxy");
! 1530: $flags .= $verbose_flag if($debugprotocol);
! 1531: $flags .= "--pidfile \"$pidfile\" --logfile \"$logfile\" ";
! 1532: $flags .= "--portfile $portfile ";
! 1533: $flags .= "--id $idnum " if($idnum > 1);
! 1534: if($ipvnum eq "unix") {
! 1535: $flags .= "--unix-socket '$port_or_path' ";
! 1536: } else {
! 1537: $flags .= "--ipv$ipvnum --port 0 ";
! 1538: }
! 1539: $flags .= "--srcdir \"$srcdir\"";
! 1540:
! 1541: my $cmd = "$exe $flags";
! 1542: my ($httppid, $pid2) = startnew($cmd, $pidfile, 15, 0);
! 1543:
! 1544: if($httppid <= 0 || !pidexists($httppid)) {
! 1545: # it is NOT alive
! 1546: logmsg "RUN: failed to start the $srvrname server\n";
! 1547: stopserver($server, "$pid2");
! 1548: displaylogs($testnumcheck);
! 1549: $doesntrun{$pidfile} = 1;
! 1550: return (0,0);
! 1551: }
! 1552:
! 1553: # where is it?
! 1554: my $port;
! 1555: if(!$port_or_path) {
! 1556: $port = $port_or_path = pidfromfile($portfile);
! 1557: }
! 1558:
! 1559: # Server is up. Verify that we can speak to it.
! 1560: my $pid3 = verifyserver($proto, $ipvnum, $idnum, $ip, $port_or_path);
! 1561: if(!$pid3) {
! 1562: logmsg "RUN: $srvrname server failed verification\n";
! 1563: # failed to talk to it properly. Kill the server and return failure
! 1564: stopserver($server, "$httppid $pid2");
! 1565: displaylogs($testnumcheck);
! 1566: $doesntrun{$pidfile} = 1;
! 1567: return (0,0);
! 1568: }
! 1569: $pid2 = $pid3;
! 1570:
! 1571: if($verbose) {
! 1572: logmsg "RUN: $srvrname server is on PID $httppid port $port\n";
! 1573: }
! 1574:
! 1575: sleep(1);
! 1576:
! 1577: return ($httppid, $pid2, $port);
! 1578: }
! 1579:
! 1580: #######################################################################
! 1581: # start the https stunnel based server
! 1582: #
! 1583: sub runhttpsserver {
! 1584: my ($verbose, $ipv6, $certfile) = @_;
! 1585: my $proto = 'https';
! 1586: my $ip = ($ipv6 && ($ipv6 =~ /6$/)) ? "$HOST6IP" : "$HOSTIP";
! 1587: my $ipvnum = ($ipv6 && ($ipv6 =~ /6$/)) ? 6 : 4;
! 1588: my $idnum = 1;
! 1589: my $server;
! 1590: my $srvrname;
! 1591: my $pidfile;
! 1592: my $logfile;
! 1593: my $flags = "";
! 1594:
! 1595: if(!$stunnel) {
! 1596: return (0,0);
! 1597: }
! 1598:
! 1599: $server = servername_id($proto, $ipvnum, $idnum);
! 1600:
! 1601: $pidfile = $serverpidfile{$server};
! 1602:
! 1603: # don't retry if the server doesn't work
! 1604: if ($doesntrun{$pidfile}) {
! 1605: return (0,0);
! 1606: }
! 1607:
! 1608: my $pid = processexists($pidfile);
! 1609: if($pid > 0) {
! 1610: stopserver($server, "$pid");
! 1611: }
! 1612: unlink($pidfile) if(-f $pidfile);
! 1613:
! 1614: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 1615:
! 1616: $certfile = 'stunnel.pem' unless($certfile);
! 1617:
! 1618: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 1619:
! 1620: $flags .= "--verbose " if($debugprotocol);
! 1621: $flags .= "--pidfile \"$pidfile\" --logfile \"$logfile\" ";
! 1622: $flags .= "--id $idnum " if($idnum > 1);
! 1623: $flags .= "--ipv$ipvnum --proto $proto ";
! 1624: $flags .= "--certfile \"$certfile\" " if($certfile ne 'stunnel.pem');
! 1625: $flags .= "--stunnel \"$stunnel\" --srcdir \"$srcdir\" ";
! 1626: $flags .= "--connect $HTTPPORT --accept $HTTPSPORT";
! 1627:
! 1628: my $cmd = "$perl $srcdir/secureserver.pl $flags";
! 1629: my ($httpspid, $pid2) = startnew($cmd, $pidfile, 15, 0);
! 1630:
! 1631: if($httpspid <= 0 || !pidexists($httpspid)) {
! 1632: # it is NOT alive
! 1633: logmsg "RUN: failed to start the $srvrname server\n";
! 1634: stopserver($server, "$pid2");
! 1635: displaylogs($testnumcheck);
! 1636: $doesntrun{$pidfile} = 1;
! 1637: return(0,0);
! 1638: }
! 1639:
! 1640: # Server is up. Verify that we can speak to it.
! 1641: my $pid3 = verifyserver($proto, $ipvnum, $idnum, $ip, $HTTPSPORT);
! 1642: if(!$pid3) {
! 1643: logmsg "RUN: $srvrname server failed verification\n";
! 1644: # failed to talk to it properly. Kill the server and return failure
! 1645: stopserver($server, "$httpspid $pid2");
! 1646: displaylogs($testnumcheck);
! 1647: $doesntrun{$pidfile} = 1;
! 1648: return (0,0);
! 1649: }
! 1650: # Here pid3 is actually the pid returned by the unsecure-http server.
! 1651:
! 1652: $runcert{$server} = $certfile;
! 1653:
! 1654: if($verbose) {
! 1655: logmsg "RUN: $srvrname server is now running PID $httpspid\n";
! 1656: }
! 1657:
! 1658: sleep(1);
! 1659:
! 1660: return ($httpspid, $pid2);
! 1661: }
! 1662:
! 1663: #######################################################################
! 1664: # start the non-stunnel HTTP TLS extensions capable server
! 1665: #
! 1666: sub runhttptlsserver {
! 1667: my ($verbose, $ipv6) = @_;
! 1668: my $proto = "httptls";
! 1669: my $port = ($ipv6 && ($ipv6 =~ /6$/)) ? $HTTPTLS6PORT : $HTTPTLSPORT;
! 1670: my $ip = ($ipv6 && ($ipv6 =~ /6$/)) ? "$HOST6IP" : "$HOSTIP";
! 1671: my $ipvnum = ($ipv6 && ($ipv6 =~ /6$/)) ? 6 : 4;
! 1672: my $idnum = 1;
! 1673: my $server;
! 1674: my $srvrname;
! 1675: my $pidfile;
! 1676: my $logfile;
! 1677: my $flags = "";
! 1678:
! 1679: if(!$httptlssrv) {
! 1680: return (0,0);
! 1681: }
! 1682:
! 1683: $server = servername_id($proto, $ipvnum, $idnum);
! 1684:
! 1685: $pidfile = $serverpidfile{$server};
! 1686:
! 1687: # don't retry if the server doesn't work
! 1688: if ($doesntrun{$pidfile}) {
! 1689: return (0,0);
! 1690: }
! 1691:
! 1692: my $pid = processexists($pidfile);
! 1693: if($pid > 0) {
! 1694: stopserver($server, "$pid");
! 1695: }
! 1696: unlink($pidfile) if(-f $pidfile);
! 1697:
! 1698: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 1699:
! 1700: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 1701:
! 1702: $flags .= "--http ";
! 1703: $flags .= "--debug 1 " if($debugprotocol);
! 1704: $flags .= "--port $port ";
! 1705: $flags .= "--priority NORMAL:+SRP ";
! 1706: $flags .= "--srppasswd $srcdir/certs/srp-verifier-db ";
! 1707: $flags .= "--srppasswdconf $srcdir/certs/srp-verifier-conf";
! 1708:
! 1709: my $cmd = "$httptlssrv $flags > $logfile 2>&1";
! 1710: my ($httptlspid, $pid2) = startnew($cmd, $pidfile, 10, 1); # fake pidfile
! 1711:
! 1712: if($httptlspid <= 0 || !pidexists($httptlspid)) {
! 1713: # it is NOT alive
! 1714: logmsg "RUN: failed to start the $srvrname server\n";
! 1715: stopserver($server, "$pid2");
! 1716: displaylogs($testnumcheck);
! 1717: $doesntrun{$pidfile} = 1;
! 1718: return (0,0);
! 1719: }
! 1720:
! 1721: # Server is up. Verify that we can speak to it. PID is from fake pidfile
! 1722: my $pid3 = verifyserver($proto, $ipvnum, $idnum, $ip, $port);
! 1723: if(!$pid3) {
! 1724: logmsg "RUN: $srvrname server failed verification\n";
! 1725: # failed to talk to it properly. Kill the server and return failure
! 1726: stopserver($server, "$httptlspid $pid2");
! 1727: displaylogs($testnumcheck);
! 1728: $doesntrun{$pidfile} = 1;
! 1729: return (0,0);
! 1730: }
! 1731: $pid2 = $pid3;
! 1732:
! 1733: if($verbose) {
! 1734: logmsg "RUN: $srvrname server is now running PID $httptlspid\n";
! 1735: }
! 1736:
! 1737: sleep(1);
! 1738:
! 1739: return ($httptlspid, $pid2);
! 1740: }
! 1741:
! 1742: #######################################################################
! 1743: # start the pingpong server (FTP, POP3, IMAP, SMTP)
! 1744: #
! 1745: sub runpingpongserver {
! 1746: my ($proto, $id, $verbose, $ipv6) = @_;
! 1747: my $port;
! 1748: my $ip = ($ipv6 && ($ipv6 =~ /6$/)) ? "$HOST6IP" : "$HOSTIP";
! 1749: my $ipvnum = ($ipv6 && ($ipv6 =~ /6$/)) ? 6 : 4;
! 1750: my $idnum = ($id && ($id =~ /^(\d+)$/) && ($id > 1)) ? $id : 1;
! 1751: my $server;
! 1752: my $srvrname;
! 1753: my $pidfile;
! 1754: my $logfile;
! 1755: my $flags = "";
! 1756:
! 1757: $server = servername_id($proto, $ipvnum, $idnum);
! 1758:
! 1759: $pidfile = $serverpidfile{$server};
! 1760: my $portfile = $serverportfile{$server};
! 1761:
! 1762: # don't retry if the server doesn't work
! 1763: if ($doesntrun{$pidfile}) {
! 1764: return (0,0);
! 1765: }
! 1766:
! 1767: my $pid = processexists($pidfile);
! 1768: if($pid > 0) {
! 1769: stopserver($server, "$pid");
! 1770: }
! 1771: unlink($pidfile) if(-f $pidfile);
! 1772:
! 1773: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 1774:
! 1775: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 1776:
! 1777: $flags .= "--verbose " if($debugprotocol);
! 1778: $flags .= "--pidfile \"$pidfile\" --logfile \"$logfile\" ";
! 1779: $flags .= "--portfile \"$portfile\" ";
! 1780: $flags .= "--srcdir \"$srcdir\" --proto $proto ";
! 1781: $flags .= "--id $idnum " if($idnum > 1);
! 1782: $flags .= "--ipv$ipvnum --port 0 --addr \"$ip\"";
! 1783:
! 1784: my $cmd = "$perl $srcdir/ftpserver.pl $flags";
! 1785: my ($ftppid, $pid2) = startnew($cmd, $pidfile, 15, 0);
! 1786:
! 1787: if($ftppid <= 0 || !pidexists($ftppid)) {
! 1788: # it is NOT alive
! 1789: logmsg "RUN: failed to start the $srvrname server\n";
! 1790: stopserver($server, "$pid2");
! 1791: displaylogs($testnumcheck);
! 1792: $doesntrun{$pidfile} = 1;
! 1793: return (0,0);
! 1794: }
! 1795:
! 1796: # where is it?
! 1797: $port = pidfromfile($portfile);
! 1798:
! 1799: logmsg "PINGPONG runs on port $port ($portfile)\n" if($verbose);
! 1800:
! 1801: # Server is up. Verify that we can speak to it.
! 1802: my $pid3 = verifyserver($proto, $ipvnum, $idnum, $ip, $port);
! 1803: if(!$pid3) {
! 1804: logmsg "RUN: $srvrname server failed verification\n";
! 1805: # failed to talk to it properly. Kill the server and return failure
! 1806: stopserver($server, "$ftppid $pid2");
! 1807: displaylogs($testnumcheck);
! 1808: $doesntrun{$pidfile} = 1;
! 1809: return (0,0);
! 1810: }
! 1811:
! 1812: $pid2 = $pid3;
! 1813:
! 1814: logmsg "RUN: $srvrname server is PID $ftppid port $port\n" if($verbose);
! 1815:
! 1816: # Assign the correct port variable!
! 1817: if($proto eq "ftp") {
! 1818: if($ipvnum == 6) {
! 1819: # if IPv6, use a different setup
! 1820: $FTP6PORT = $port;
! 1821: }
! 1822: elsif($idnum>1) {
! 1823: $FTP2PORT = $port;
! 1824: }
! 1825: else {
! 1826: $FTPPORT = $port;
! 1827: }
! 1828: }
! 1829: elsif($proto eq "pop3") {
! 1830: if($ipvnum == 6) {
! 1831: $POP36PORT = $port;
! 1832: }
! 1833: else {
! 1834: $POP3PORT = $port;
! 1835: }
! 1836: }
! 1837: elsif($proto eq "imap") {
! 1838: if($ipvnum == 6) {
! 1839: $IMAP6PORT = $port;
! 1840: }
! 1841: else {
! 1842: $IMAPPORT = $port;
! 1843: }
! 1844: }
! 1845: elsif($proto eq "smtp") {
! 1846: if($ipvnum == 6) {
! 1847: $SMTP6PORT = $port;
! 1848: }
! 1849: else {
! 1850: $SMTPPORT = $port;
! 1851: }
! 1852: }
! 1853: else {
! 1854: print STDERR "Unsupported protocol $proto!!\n";
! 1855: return 0;
! 1856: }
! 1857:
! 1858: sleep(1);
! 1859:
! 1860: return ($pid2, $ftppid);
! 1861: }
! 1862:
! 1863: #######################################################################
! 1864: # start the ftps server (or rather, tunnel)
! 1865: #
! 1866: sub runftpsserver {
! 1867: my ($verbose, $ipv6, $certfile) = @_;
! 1868: my $proto = 'ftps';
! 1869: my $ip = ($ipv6 && ($ipv6 =~ /6$/)) ? "$HOST6IP" : "$HOSTIP";
! 1870: my $ipvnum = ($ipv6 && ($ipv6 =~ /6$/)) ? 6 : 4;
! 1871: my $idnum = 1;
! 1872: my $server;
! 1873: my $srvrname;
! 1874: my $pidfile;
! 1875: my $logfile;
! 1876: my $flags = "";
! 1877:
! 1878: if(!$stunnel) {
! 1879: return (0,0);
! 1880: }
! 1881:
! 1882: $server = servername_id($proto, $ipvnum, $idnum);
! 1883:
! 1884: $pidfile = $serverpidfile{$server};
! 1885:
! 1886: # don't retry if the server doesn't work
! 1887: if ($doesntrun{$pidfile}) {
! 1888: return (0,0);
! 1889: }
! 1890:
! 1891: my $pid = processexists($pidfile);
! 1892: if($pid > 0) {
! 1893: stopserver($server, "$pid");
! 1894: }
! 1895: unlink($pidfile) if(-f $pidfile);
! 1896:
! 1897: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 1898:
! 1899: $certfile = 'stunnel.pem' unless($certfile);
! 1900:
! 1901: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 1902:
! 1903: $flags .= "--verbose " if($debugprotocol);
! 1904: $flags .= "--pidfile \"$pidfile\" --logfile \"$logfile\" ";
! 1905: $flags .= "--id $idnum " if($idnum > 1);
! 1906: $flags .= "--ipv$ipvnum --proto $proto ";
! 1907: $flags .= "--certfile \"$certfile\" " if($certfile ne 'stunnel.pem');
! 1908: $flags .= "--stunnel \"$stunnel\" --srcdir \"$srcdir\" ";
! 1909: $flags .= "--connect $FTPPORT --accept $FTPSPORT";
! 1910:
! 1911: my $cmd = "$perl $srcdir/secureserver.pl $flags";
! 1912: my ($ftpspid, $pid2) = startnew($cmd, $pidfile, 15, 0);
! 1913:
! 1914: if($ftpspid <= 0 || !pidexists($ftpspid)) {
! 1915: # it is NOT alive
! 1916: logmsg "RUN: failed to start the $srvrname server\n";
! 1917: stopserver($server, "$pid2");
! 1918: displaylogs($testnumcheck);
! 1919: $doesntrun{$pidfile} = 1;
! 1920: return(0,0);
! 1921: }
! 1922:
! 1923: # Server is up. Verify that we can speak to it.
! 1924: my $pid3 = verifyserver($proto, $ipvnum, $idnum, $ip, $FTPSPORT);
! 1925: if(!$pid3) {
! 1926: logmsg "RUN: $srvrname server failed verification\n";
! 1927: # failed to talk to it properly. Kill the server and return failure
! 1928: stopserver($server, "$ftpspid $pid2");
! 1929: displaylogs($testnumcheck);
! 1930: $doesntrun{$pidfile} = 1;
! 1931: return (0,0);
! 1932: }
! 1933: # Here pid3 is actually the pid returned by the unsecure-ftp server.
! 1934:
! 1935: $runcert{$server} = $certfile;
! 1936:
! 1937: if($verbose) {
! 1938: logmsg "RUN: $srvrname server is now running PID $ftpspid\n";
! 1939: }
! 1940:
! 1941: sleep(1);
! 1942:
! 1943: return ($ftpspid, $pid2);
! 1944: }
! 1945:
! 1946: #######################################################################
! 1947: # start the tftp server
! 1948: #
! 1949: sub runtftpserver {
! 1950: my ($id, $verbose, $ipv6) = @_;
! 1951: my $ip = $HOSTIP;
! 1952: my $proto = 'tftp';
! 1953: my $ipvnum = 4;
! 1954: my $idnum = ($id && ($id =~ /^(\d+)$/) && ($id > 1)) ? $id : 1;
! 1955: my $server;
! 1956: my $srvrname;
! 1957: my $pidfile;
! 1958: my $logfile;
! 1959: my $flags = "";
! 1960:
! 1961: if($ipv6) {
! 1962: # if IPv6, use a different setup
! 1963: $ipvnum = 6;
! 1964: $ip = $HOST6IP;
! 1965: }
! 1966:
! 1967: $server = servername_id($proto, $ipvnum, $idnum);
! 1968:
! 1969: $pidfile = $serverpidfile{$server};
! 1970: my $portfile = $serverportfile{$server};
! 1971:
! 1972: # don't retry if the server doesn't work
! 1973: if ($doesntrun{$pidfile}) {
! 1974: return (0,0);
! 1975: }
! 1976:
! 1977: my $pid = processexists($pidfile);
! 1978: if($pid > 0) {
! 1979: stopserver($server, "$pid");
! 1980: }
! 1981: unlink($pidfile) if(-f $pidfile);
! 1982:
! 1983: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 1984:
! 1985: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 1986:
! 1987: $flags .= "--verbose " if($debugprotocol);
! 1988: $flags .= "--pidfile \"$pidfile\" ".
! 1989: "--portfile \"$portfile\" ".
! 1990: "--logfile \"$logfile\" ";
! 1991: $flags .= "--id $idnum " if($idnum > 1);
! 1992: $flags .= "--ipv$ipvnum --port 0 --srcdir \"$srcdir\"";
! 1993:
! 1994: my $cmd = "$perl $srcdir/tftpserver.pl $flags";
! 1995: my ($tftppid, $pid2) = startnew($cmd, $pidfile, 15, 0);
! 1996:
! 1997: if($tftppid <= 0 || !pidexists($tftppid)) {
! 1998: # it is NOT alive
! 1999: logmsg "RUN: failed to start the $srvrname server\n";
! 2000: stopserver($server, "$pid2");
! 2001: displaylogs($testnumcheck);
! 2002: $doesntrun{$pidfile} = 1;
! 2003: return (0,0);
! 2004: }
! 2005:
! 2006: my $port = pidfromfile($portfile);
! 2007:
! 2008: # Server is up. Verify that we can speak to it.
! 2009: my $pid3 = verifyserver($proto, $ipvnum, $idnum, $ip, $port);
! 2010: if(!$pid3) {
! 2011: logmsg "RUN: $srvrname server failed verification\n";
! 2012: # failed to talk to it properly. Kill the server and return failure
! 2013: stopserver($server, "$tftppid $pid2");
! 2014: displaylogs($testnumcheck);
! 2015: $doesntrun{$pidfile} = 1;
! 2016: return (0,0);
! 2017: }
! 2018: $pid2 = $pid3;
! 2019:
! 2020: if($verbose) {
! 2021: logmsg "RUN: $srvrname server on PID $tftppid port $port\n";
! 2022: }
! 2023:
! 2024: sleep(1);
! 2025:
! 2026: return ($pid2, $tftppid, $port);
! 2027: }
! 2028:
! 2029:
! 2030: #######################################################################
! 2031: # start the rtsp server
! 2032: #
! 2033: sub runrtspserver {
! 2034: my ($verbose, $ipv6) = @_;
! 2035: my $ip = $HOSTIP;
! 2036: my $proto = 'rtsp';
! 2037: my $ipvnum = 4;
! 2038: my $idnum = 1;
! 2039: my $server;
! 2040: my $srvrname;
! 2041: my $pidfile;
! 2042: my $logfile;
! 2043: my $flags = "";
! 2044:
! 2045: if($ipv6) {
! 2046: # if IPv6, use a different setup
! 2047: $ipvnum = 6;
! 2048: $ip = $HOST6IP;
! 2049: }
! 2050:
! 2051: $server = servername_id($proto, $ipvnum, $idnum);
! 2052:
! 2053: $pidfile = $serverpidfile{$server};
! 2054: my $portfile = $serverportfile{$server};
! 2055:
! 2056: # don't retry if the server doesn't work
! 2057: if ($doesntrun{$pidfile}) {
! 2058: return (0,0);
! 2059: }
! 2060:
! 2061: my $pid = processexists($pidfile);
! 2062: if($pid > 0) {
! 2063: stopserver($server, "$pid");
! 2064: }
! 2065: unlink($pidfile) if(-f $pidfile);
! 2066:
! 2067: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 2068:
! 2069: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 2070:
! 2071: $flags .= "--verbose " if($debugprotocol);
! 2072: $flags .= "--pidfile \"$pidfile\" ".
! 2073: "--portfile \"$portfile\" ".
! 2074: "--logfile \"$logfile\" ";
! 2075: $flags .= "--id $idnum " if($idnum > 1);
! 2076: $flags .= "--ipv$ipvnum --port 0 --srcdir \"$srcdir\"";
! 2077:
! 2078: my $cmd = "$perl $srcdir/rtspserver.pl $flags";
! 2079: my ($rtsppid, $pid2) = startnew($cmd, $pidfile, 15, 0);
! 2080:
! 2081: if($rtsppid <= 0 || !pidexists($rtsppid)) {
! 2082: # it is NOT alive
! 2083: logmsg "RUN: failed to start the $srvrname server\n";
! 2084: stopserver($server, "$pid2");
! 2085: displaylogs($testnumcheck);
! 2086: $doesntrun{$pidfile} = 1;
! 2087: return (0,0);
! 2088: }
! 2089:
! 2090: my $port = pidfromfile($portfile);
! 2091:
! 2092: # Server is up. Verify that we can speak to it.
! 2093: my $pid3 = verifyserver($proto, $ipvnum, $idnum, $ip, $port);
! 2094: if(!$pid3) {
! 2095: logmsg "RUN: $srvrname server failed verification\n";
! 2096: # failed to talk to it properly. Kill the server and return failure
! 2097: stopserver($server, "$rtsppid $pid2");
! 2098: displaylogs($testnumcheck);
! 2099: $doesntrun{$pidfile} = 1;
! 2100: return (0,0);
! 2101: }
! 2102: $pid2 = $pid3;
! 2103:
! 2104: if($verbose) {
! 2105: logmsg "RUN: $srvrname server PID $rtsppid port $port\n";
! 2106: }
! 2107:
! 2108: sleep(1);
! 2109:
! 2110: return ($rtsppid, $pid2, $port);
! 2111: }
! 2112:
! 2113:
! 2114: #######################################################################
! 2115: # Start the ssh (scp/sftp) server
! 2116: #
! 2117: sub runsshserver {
! 2118: my ($id, $verbose, $ipv6) = @_;
! 2119: my $ip=$HOSTIP;
! 2120: my $port = $SSHPORT;
! 2121: my $proto = 'ssh';
! 2122: my $ipvnum = 4;
! 2123: my $idnum = ($id && ($id =~ /^(\d+)$/) && ($id > 1)) ? $id : 1;
! 2124: my $server;
! 2125: my $srvrname;
! 2126: my $pidfile;
! 2127: my $logfile;
! 2128: my $flags = "";
! 2129:
! 2130: $server = servername_id($proto, $ipvnum, $idnum);
! 2131:
! 2132: $pidfile = $serverpidfile{$server};
! 2133:
! 2134: # don't retry if the server doesn't work
! 2135: if ($doesntrun{$pidfile}) {
! 2136: return (0,0);
! 2137: }
! 2138:
! 2139: my $pid = processexists($pidfile);
! 2140: if($pid > 0) {
! 2141: stopserver($server, "$pid");
! 2142: }
! 2143: unlink($pidfile) if(-f $pidfile);
! 2144:
! 2145: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 2146:
! 2147: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 2148:
! 2149: $flags .= "--verbose " if($verbose);
! 2150: $flags .= "--debugprotocol " if($debugprotocol);
! 2151: $flags .= "--pidfile \"$pidfile\" ";
! 2152: $flags .= "--id $idnum " if($idnum > 1);
! 2153: $flags .= "--ipv$ipvnum --addr \"$ip\" ";
! 2154: $flags .= "--sshport $port ";
! 2155: $flags .= "--user \"$USER\"";
! 2156:
! 2157: my $cmd = "$perl $srcdir/sshserver.pl $flags";
! 2158: my ($sshpid, $pid2) = startnew($cmd, $pidfile, 60, 0);
! 2159:
! 2160: # on loaded systems sshserver start up can take longer than the timeout
! 2161: # passed to startnew, when this happens startnew completes without being
! 2162: # able to read the pidfile and consequently returns a zero pid2 above.
! 2163:
! 2164: if($sshpid <= 0 || !pidexists($sshpid)) {
! 2165: # it is NOT alive
! 2166: logmsg "RUN: failed to start the $srvrname server\n";
! 2167: stopserver($server, "$pid2");
! 2168: $doesntrun{$pidfile} = 1;
! 2169: return (0,0);
! 2170: }
! 2171:
! 2172: # ssh server verification allows some extra time for the server to start up
! 2173: # and gives us the opportunity of recovering the pid from the pidfile, when
! 2174: # this verification succeeds the recovered pid is assigned to pid2.
! 2175:
! 2176: my $pid3 = verifyserver($proto, $ipvnum, $idnum, $ip, $port);
! 2177: if(!$pid3) {
! 2178: logmsg "RUN: $srvrname server failed verification\n";
! 2179: # failed to fetch server pid. Kill the server and return failure
! 2180: stopserver($server, "$sshpid $pid2");
! 2181: $doesntrun{$pidfile} = 1;
! 2182: return (0,0);
! 2183: }
! 2184: $pid2 = $pid3;
! 2185:
! 2186: # once it is known that the ssh server is alive, sftp server verification
! 2187: # is performed actually connecting to it, authenticating and performing a
! 2188: # very simple remote command. This verification is tried only one time.
! 2189:
! 2190: $sshdlog = server_logfilename($LOGDIR, 'ssh', $ipvnum, $idnum);
! 2191: $sftplog = server_logfilename($LOGDIR, 'sftp', $ipvnum, $idnum);
! 2192:
! 2193: if(verifysftp('sftp', $ipvnum, $idnum, $ip, $port) < 1) {
! 2194: logmsg "RUN: SFTP server failed verification\n";
! 2195: # failed to talk to it properly. Kill the server and return failure
! 2196: display_sftplog();
! 2197: display_sftpconfig();
! 2198: display_sshdlog();
! 2199: display_sshdconfig();
! 2200: stopserver($server, "$sshpid $pid2");
! 2201: $doesntrun{$pidfile} = 1;
! 2202: return (0,0);
! 2203: }
! 2204:
! 2205: my $hstpubmd5f = "curl_host_rsa_key.pub_md5";
! 2206: if(!open(PUBMD5FILE, "<", $hstpubmd5f) ||
! 2207: (read(PUBMD5FILE, $SSHSRVMD5, 32) != 32) ||
! 2208: !close(PUBMD5FILE) ||
! 2209: ($SSHSRVMD5 !~ /^[a-f0-9]{32}$/i))
! 2210: {
! 2211: my $msg = "Fatal: $srvrname pubkey md5 missing : \"$hstpubmd5f\" : $!";
! 2212: logmsg "$msg\n";
! 2213: stopservers($verbose);
! 2214: die $msg;
! 2215: }
! 2216:
! 2217: if($verbose) {
! 2218: logmsg "RUN: $srvrname server is now running PID $pid2\n";
! 2219: }
! 2220:
! 2221: return ($pid2, $sshpid);
! 2222: }
! 2223:
! 2224: #######################################################################
! 2225: # Start the socks server
! 2226: #
! 2227: sub runmqttserver {
! 2228: my ($id, $verbose, $ipv6) = @_;
! 2229: my $ip=$HOSTIP;
! 2230: my $port = $MQTTPORT;
! 2231: my $proto = 'mqtt';
! 2232: my $ipvnum = 4;
! 2233: my $idnum = ($id && ($id =~ /^(\d+)$/) && ($id > 1)) ? $id : 1;
! 2234: my $server;
! 2235: my $srvrname;
! 2236: my $pidfile;
! 2237: my $portfile;
! 2238: my $logfile;
! 2239: my $flags = "";
! 2240:
! 2241: $server = servername_id($proto, $ipvnum, $idnum);
! 2242: $pidfile = $serverpidfile{$server};
! 2243: $portfile = $serverportfile{$server};
! 2244:
! 2245: # don't retry if the server doesn't work
! 2246: if ($doesntrun{$pidfile}) {
! 2247: return (0,0);
! 2248: }
! 2249:
! 2250: my $pid = processexists($pidfile);
! 2251: if($pid > 0) {
! 2252: stopserver($server, "$pid");
! 2253: }
! 2254: unlink($pidfile) if(-f $pidfile);
! 2255:
! 2256: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 2257:
! 2258: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 2259:
! 2260: # start our MQTT server - on a random port!
! 2261: my $cmd="server/mqttd".exe_ext('SRV').
! 2262: " --port 0 ".
! 2263: " --pidfile $pidfile".
! 2264: " --portfile $portfile".
! 2265: " --config $FTPDCMD";
! 2266: my ($sockspid, $pid2) = startnew($cmd, $pidfile, 30, 0);
! 2267:
! 2268: if($sockspid <= 0 || !pidexists($sockspid)) {
! 2269: # it is NOT alive
! 2270: logmsg "RUN: failed to start the $srvrname server\n";
! 2271: stopserver($server, "$pid2");
! 2272: $doesntrun{$pidfile} = 1;
! 2273: return (0,0);
! 2274: }
! 2275:
! 2276: $MQTTPORT = pidfromfile($portfile);
! 2277:
! 2278: if($verbose) {
! 2279: logmsg "RUN: $srvrname server is now running PID $pid2 on PORT $MQTTPORT\n";
! 2280: }
! 2281:
! 2282: return ($pid2, $sockspid);
! 2283: }
! 2284:
! 2285: #######################################################################
! 2286: # Start the socks server
! 2287: #
! 2288: sub runsocksserver {
! 2289: my ($id, $verbose, $ipv6) = @_;
! 2290: my $ip=$HOSTIP;
! 2291: my $proto = 'socks';
! 2292: my $ipvnum = 4;
! 2293: my $idnum = ($id && ($id =~ /^(\d+)$/) && ($id > 1)) ? $id : 1;
! 2294: my $server;
! 2295: my $srvrname;
! 2296: my $pidfile;
! 2297: my $logfile;
! 2298: my $flags = "";
! 2299:
! 2300: $server = servername_id($proto, $ipvnum, $idnum);
! 2301:
! 2302: $pidfile = $serverpidfile{$server};
! 2303: my $portfile = $serverportfile{$server};
! 2304:
! 2305: # don't retry if the server doesn't work
! 2306: if ($doesntrun{$pidfile}) {
! 2307: return (0,0);
! 2308: }
! 2309:
! 2310: my $pid = processexists($pidfile);
! 2311: if($pid > 0) {
! 2312: stopserver($server, "$pid");
! 2313: }
! 2314: unlink($pidfile) if(-f $pidfile);
! 2315:
! 2316: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 2317:
! 2318: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 2319:
! 2320: # start our socks server, get commands from the FTP cmd file
! 2321: my $cmd="server/socksd".exe_ext('SRV').
! 2322: " --port 0 ".
! 2323: " --pidfile $pidfile".
! 2324: " --portfile $portfile".
! 2325: " --backend $HOSTIP".
! 2326: " --config $FTPDCMD";
! 2327: my ($sockspid, $pid2) = startnew($cmd, $pidfile, 30, 0);
! 2328:
! 2329: if($sockspid <= 0 || !pidexists($sockspid)) {
! 2330: # it is NOT alive
! 2331: logmsg "RUN: failed to start the $srvrname server\n";
! 2332: stopserver($server, "$pid2");
! 2333: $doesntrun{$pidfile} = 1;
! 2334: return (0,0);
! 2335: }
! 2336:
! 2337: my $port = pidfromfile($portfile);
! 2338:
! 2339: if($verbose) {
! 2340: logmsg "RUN: $srvrname server is now running PID $pid2\n";
! 2341: }
! 2342:
! 2343: return ($pid2, $sockspid, $port);
! 2344: }
! 2345:
! 2346: #######################################################################
! 2347: # start the dict server
! 2348: #
! 2349: sub rundictserver {
! 2350: my ($verbose, $alt, $port) = @_;
! 2351: my $proto = "dict";
! 2352: my $ip = $HOSTIP;
! 2353: my $ipvnum = 4;
! 2354: my $idnum = 1;
! 2355: my $server;
! 2356: my $srvrname;
! 2357: my $pidfile;
! 2358: my $logfile;
! 2359: my $flags = "";
! 2360:
! 2361: if($alt eq "ipv6") {
! 2362: # No IPv6
! 2363: }
! 2364:
! 2365: $server = servername_id($proto, $ipvnum, $idnum);
! 2366:
! 2367: $pidfile = $serverpidfile{$server};
! 2368:
! 2369: # don't retry if the server doesn't work
! 2370: if ($doesntrun{$pidfile}) {
! 2371: return (0,0);
! 2372: }
! 2373:
! 2374: my $pid = processexists($pidfile);
! 2375: if($pid > 0) {
! 2376: stopserver($server, "$pid");
! 2377: }
! 2378: unlink($pidfile) if(-f $pidfile);
! 2379:
! 2380: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 2381:
! 2382: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 2383:
! 2384: $flags .= "--verbose 1 " if($debugprotocol);
! 2385: $flags .= "--pidfile \"$pidfile\" --logfile \"$logfile\" ";
! 2386: $flags .= "--id $idnum " if($idnum > 1);
! 2387: $flags .= "--port $port --srcdir \"$srcdir\" ";
! 2388: $flags .= "--host $HOSTIP";
! 2389:
! 2390: my $cmd = "$srcdir/dictserver.py $flags";
! 2391: my ($dictpid, $pid2) = startnew($cmd, $pidfile, 15, 0);
! 2392:
! 2393: if($dictpid <= 0 || !pidexists($dictpid)) {
! 2394: # it is NOT alive
! 2395: logmsg "RUN: failed to start the $srvrname server\n";
! 2396: stopserver($server, "$pid2");
! 2397: displaylogs($testnumcheck);
! 2398: $doesntrun{$pidfile} = 1;
! 2399: return (0,0);
! 2400: }
! 2401:
! 2402: # Server is up. Verify that we can speak to it.
! 2403: my $pid3 = verifyserver($proto, $ipvnum, $idnum, $ip, $port);
! 2404: if(!$pid3) {
! 2405: logmsg "RUN: $srvrname server failed verification\n";
! 2406: # failed to talk to it properly. Kill the server and return failure
! 2407: stopserver($server, "$dictpid $pid2");
! 2408: displaylogs($testnumcheck);
! 2409: $doesntrun{$pidfile} = 1;
! 2410: return (0,0);
! 2411: }
! 2412: $pid2 = $pid3;
! 2413:
! 2414: if($verbose) {
! 2415: logmsg "RUN: $srvrname server is now running PID $dictpid\n";
! 2416: }
! 2417:
! 2418: sleep(1);
! 2419:
! 2420: return ($dictpid, $pid2);
! 2421: }
! 2422:
! 2423: #######################################################################
! 2424: # start the SMB server
! 2425: #
! 2426: sub runsmbserver {
! 2427: my ($verbose, $alt, $port) = @_;
! 2428: my $proto = "smb";
! 2429: my $ip = $HOSTIP;
! 2430: my $ipvnum = 4;
! 2431: my $idnum = 1;
! 2432: my $server;
! 2433: my $srvrname;
! 2434: my $pidfile;
! 2435: my $logfile;
! 2436: my $flags = "";
! 2437:
! 2438: if($alt eq "ipv6") {
! 2439: # No IPv6
! 2440: }
! 2441:
! 2442: $server = servername_id($proto, $ipvnum, $idnum);
! 2443:
! 2444: $pidfile = $serverpidfile{$server};
! 2445:
! 2446: # don't retry if the server doesn't work
! 2447: if ($doesntrun{$pidfile}) {
! 2448: return (0,0);
! 2449: }
! 2450:
! 2451: my $pid = processexists($pidfile);
! 2452: if($pid > 0) {
! 2453: stopserver($server, "$pid");
! 2454: }
! 2455: unlink($pidfile) if(-f $pidfile);
! 2456:
! 2457: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 2458:
! 2459: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 2460:
! 2461: $flags .= "--verbose 1 " if($debugprotocol);
! 2462: $flags .= "--pidfile \"$pidfile\" --logfile \"$logfile\" ";
! 2463: $flags .= "--id $idnum " if($idnum > 1);
! 2464: $flags .= "--port $port --srcdir \"$srcdir\" ";
! 2465: $flags .= "--host $HOSTIP";
! 2466:
! 2467: my $cmd = "$srcdir/smbserver.py $flags";
! 2468: my ($smbpid, $pid2) = startnew($cmd, $pidfile, 15, 0);
! 2469:
! 2470: if($smbpid <= 0 || !pidexists($smbpid)) {
! 2471: # it is NOT alive
! 2472: logmsg "RUN: failed to start the $srvrname server\n";
! 2473: stopserver($server, "$pid2");
! 2474: displaylogs($testnumcheck);
! 2475: $doesntrun{$pidfile} = 1;
! 2476: return (0,0);
! 2477: }
! 2478:
! 2479: # Server is up. Verify that we can speak to it.
! 2480: my $pid3 = verifyserver($proto, $ipvnum, $idnum, $ip, $port);
! 2481: if(!$pid3) {
! 2482: logmsg "RUN: $srvrname server failed verification\n";
! 2483: # failed to talk to it properly. Kill the server and return failure
! 2484: stopserver($server, "$smbpid $pid2");
! 2485: displaylogs($testnumcheck);
! 2486: $doesntrun{$pidfile} = 1;
! 2487: return (0,0);
! 2488: }
! 2489: $pid2 = $pid3;
! 2490:
! 2491: if($verbose) {
! 2492: logmsg "RUN: $srvrname server is now running PID $smbpid\n";
! 2493: }
! 2494:
! 2495: sleep(1);
! 2496:
! 2497: return ($smbpid, $pid2);
! 2498: }
! 2499:
! 2500: #######################################################################
! 2501: # start the telnet server
! 2502: #
! 2503: sub runnegtelnetserver {
! 2504: my ($verbose, $alt, $port) = @_;
! 2505: my $proto = "telnet";
! 2506: my $ip = $HOSTIP;
! 2507: my $ipvnum = 4;
! 2508: my $idnum = 1;
! 2509: my $server;
! 2510: my $srvrname;
! 2511: my $pidfile;
! 2512: my $logfile;
! 2513: my $flags = "";
! 2514:
! 2515: if($alt eq "ipv6") {
! 2516: # No IPv6
! 2517: }
! 2518:
! 2519: $server = servername_id($proto, $ipvnum, $idnum);
! 2520:
! 2521: $pidfile = $serverpidfile{$server};
! 2522:
! 2523: # don't retry if the server doesn't work
! 2524: if ($doesntrun{$pidfile}) {
! 2525: return (0,0);
! 2526: }
! 2527:
! 2528: my $pid = processexists($pidfile);
! 2529: if($pid > 0) {
! 2530: stopserver($server, "$pid");
! 2531: }
! 2532: unlink($pidfile) if(-f $pidfile);
! 2533:
! 2534: $srvrname = servername_str($proto, $ipvnum, $idnum);
! 2535:
! 2536: $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
! 2537:
! 2538: $flags .= "--verbose 1 " if($debugprotocol);
! 2539: $flags .= "--pidfile \"$pidfile\" --logfile \"$logfile\" ";
! 2540: $flags .= "--id $idnum " if($idnum > 1);
! 2541: $flags .= "--port $port --srcdir \"$srcdir\"";
! 2542:
! 2543: my $cmd = "$srcdir/negtelnetserver.py $flags";
! 2544: my ($ntelpid, $pid2) = startnew($cmd, $pidfile, 15, 0);
! 2545:
! 2546: if($ntelpid <= 0 || !pidexists($ntelpid)) {
! 2547: # it is NOT alive
! 2548: logmsg "RUN: failed to start the $srvrname server\n";
! 2549: stopserver($server, "$pid2");
! 2550: displaylogs($testnumcheck);
! 2551: $doesntrun{$pidfile} = 1;
! 2552: return (0,0);
! 2553: }
! 2554:
! 2555: # Server is up. Verify that we can speak to it.
! 2556: my $pid3 = verifyserver($proto, $ipvnum, $idnum, $ip, $port);
! 2557: if(!$pid3) {
! 2558: logmsg "RUN: $srvrname server failed verification\n";
! 2559: # failed to talk to it properly. Kill the server and return failure
! 2560: stopserver($server, "$ntelpid $pid2");
! 2561: displaylogs($testnumcheck);
! 2562: $doesntrun{$pidfile} = 1;
! 2563: return (0,0);
! 2564: }
! 2565: $pid2 = $pid3;
! 2566:
! 2567: if($verbose) {
! 2568: logmsg "RUN: $srvrname server is now running PID $ntelpid\n";
! 2569: }
! 2570:
! 2571: sleep(1);
! 2572:
! 2573: return ($ntelpid, $pid2);
! 2574: }
! 2575:
! 2576:
! 2577: #######################################################################
! 2578: # Single shot http and gopher server responsiveness test. This should only
! 2579: # be used to verify that a server present in %run hash is still functional
! 2580: #
! 2581: sub responsive_http_server {
! 2582: my ($proto, $verbose, $alt, $port_or_path) = @_;
! 2583: my $ip = $HOSTIP;
! 2584: my $ipvnum = 4;
! 2585: my $idnum = 1;
! 2586:
! 2587: if($alt eq "ipv6") {
! 2588: # if IPv6, use a different setup
! 2589: $ipvnum = 6;
! 2590: $ip = $HOST6IP;
! 2591: }
! 2592: elsif($alt eq "proxy") {
! 2593: $idnum = 2;
! 2594: }
! 2595: elsif($alt eq "unix") {
! 2596: # IP (protocol) is mutually exclusive with Unix sockets
! 2597: $ipvnum = "unix";
! 2598: }
! 2599:
! 2600: return &responsiveserver($proto, $ipvnum, $idnum, $ip, $port_or_path);
! 2601: }
! 2602:
! 2603: #######################################################################
! 2604: # Single shot pingpong server responsiveness test. This should only be
! 2605: # used to verify that a server present in %run hash is still functional
! 2606: #
! 2607: sub responsive_pingpong_server {
! 2608: my ($proto, $id, $verbose, $ipv6) = @_;
! 2609: my $port;
! 2610: my $ip = ($ipv6 && ($ipv6 =~ /6$/)) ? "$HOST6IP" : "$HOSTIP";
! 2611: my $ipvnum = ($ipv6 && ($ipv6 =~ /6$/)) ? 6 : 4;
! 2612: my $idnum = ($id && ($id =~ /^(\d+)$/) && ($id > 1)) ? $id : 1;
! 2613:
! 2614: if($proto eq "ftp") {
! 2615: $port = ($idnum>1)?$FTP2PORT:$FTPPORT;
! 2616:
! 2617: if($ipvnum==6) {
! 2618: # if IPv6, use a different setup
! 2619: $port = $FTP6PORT;
! 2620: }
! 2621: }
! 2622: elsif($proto eq "pop3") {
! 2623: $port = ($ipvnum==6) ? $POP36PORT : $POP3PORT;
! 2624: }
! 2625: elsif($proto eq "imap") {
! 2626: $port = ($ipvnum==6) ? $IMAP6PORT : $IMAPPORT;
! 2627: }
! 2628: elsif($proto eq "smtp") {
! 2629: $port = ($ipvnum==6) ? $SMTP6PORT : $SMTPPORT;
! 2630: }
! 2631: else {
! 2632: print STDERR "Unsupported protocol $proto!!\n";
! 2633: return 0;
! 2634: }
! 2635:
! 2636: return &responsiveserver($proto, $ipvnum, $idnum, $ip, $port);
! 2637: }
! 2638:
! 2639: #######################################################################
! 2640: # Single shot rtsp server responsiveness test. This should only be
! 2641: # used to verify that a server present in %run hash is still functional
! 2642: #
! 2643: sub responsive_rtsp_server {
! 2644: my ($verbose, $ipv6) = @_;
! 2645: my $port = $RTSPPORT;
! 2646: my $ip = $HOSTIP;
! 2647: my $proto = 'rtsp';
! 2648: my $ipvnum = 4;
! 2649: my $idnum = 1;
! 2650:
! 2651: if($ipv6) {
! 2652: # if IPv6, use a different setup
! 2653: $ipvnum = 6;
! 2654: $port = $RTSP6PORT;
! 2655: $ip = $HOST6IP;
! 2656: }
! 2657:
! 2658: return &responsiveserver($proto, $ipvnum, $idnum, $ip, $port);
! 2659: }
! 2660:
! 2661: #######################################################################
! 2662: # Single shot tftp server responsiveness test. This should only be
! 2663: # used to verify that a server present in %run hash is still functional
! 2664: #
! 2665: sub responsive_tftp_server {
! 2666: my ($id, $verbose, $ipv6) = @_;
! 2667: my $port = $TFTPPORT;
! 2668: my $ip = $HOSTIP;
! 2669: my $proto = 'tftp';
! 2670: my $ipvnum = 4;
! 2671: my $idnum = ($id && ($id =~ /^(\d+)$/) && ($id > 1)) ? $id : 1;
! 2672:
! 2673: if($ipv6) {
! 2674: # if IPv6, use a different setup
! 2675: $ipvnum = 6;
! 2676: $port = $TFTP6PORT;
! 2677: $ip = $HOST6IP;
! 2678: }
! 2679:
! 2680: return &responsiveserver($proto, $ipvnum, $idnum, $ip, $port);
! 2681: }
! 2682:
! 2683: #######################################################################
! 2684: # Single shot non-stunnel HTTP TLS extensions capable server
! 2685: # responsiveness test. This should only be used to verify that a
! 2686: # server present in %run hash is still functional
! 2687: #
! 2688: sub responsive_httptls_server {
! 2689: my ($verbose, $ipv6) = @_;
! 2690: my $proto = "httptls";
! 2691: my $port = ($ipv6 && ($ipv6 =~ /6$/)) ? $HTTPTLS6PORT : $HTTPTLSPORT;
! 2692: my $ip = ($ipv6 && ($ipv6 =~ /6$/)) ? "$HOST6IP" : "$HOSTIP";
! 2693: my $ipvnum = ($ipv6 && ($ipv6 =~ /6$/)) ? 6 : 4;
! 2694: my $idnum = 1;
! 2695:
! 2696: return &responsiveserver($proto, $ipvnum, $idnum, $ip, $port);
! 2697: }
! 2698:
! 2699: #######################################################################
! 2700: # Remove all files in the specified directory
! 2701: #
! 2702: sub cleardir {
! 2703: my $dir = $_[0];
! 2704: my $count;
! 2705: my $file;
! 2706:
! 2707: # Get all files
! 2708: opendir(DIR, $dir) ||
! 2709: return 0; # can't open dir
! 2710: while($file = readdir(DIR)) {
! 2711: if(($file !~ /^\./)) {
! 2712: unlink("$dir/$file");
! 2713: $count++;
! 2714: }
! 2715: }
! 2716: closedir DIR;
! 2717: return $count;
! 2718: }
! 2719:
! 2720: #######################################################################
! 2721: # compare test results with the expected output, we might filter off
! 2722: # some pattern that is allowed to differ, output test results
! 2723: #
! 2724: sub compare {
! 2725: my ($testnum, $testname, $subject, $firstref, $secondref)=@_;
! 2726:
! 2727: my $result = compareparts($firstref, $secondref);
! 2728:
! 2729: if($result) {
! 2730: # timestamp test result verification end
! 2731: $timevrfyend{$testnum} = Time::HiRes::time();
! 2732:
! 2733: if(!$short) {
! 2734: logmsg "\n $testnum: $subject FAILED:\n";
! 2735: logmsg showdiff($LOGDIR, $firstref, $secondref);
! 2736: }
! 2737: elsif(!$automakestyle) {
! 2738: logmsg "FAILED\n";
! 2739: }
! 2740: else {
! 2741: # automakestyle
! 2742: logmsg "FAIL: $testnum - $testname - $subject\n";
! 2743: }
! 2744: }
! 2745: return $result;
! 2746: }
! 2747:
! 2748: sub setupfeatures {
! 2749: $feature{"SSL"} = $has_ssl;
! 2750: $feature{"MultiSSL"} = $has_multissl;
! 2751: $feature{"SSLpinning"} = $has_sslpinning;
! 2752: $feature{"OpenSSL"} = $has_openssl;
! 2753: $feature{"GnuTLS"} = $has_gnutls;
! 2754: $feature{"NSS"} = $has_nss;
! 2755: $feature{"WinSSL"} = $has_winssl;
! 2756: $feature{"Schannel"} = $has_winssl; # alias
! 2757: $feature{"sectransp"} = $has_darwinssl;
! 2758: $feature{"DarwinSSL"} = $has_darwinssl; # alias
! 2759: $feature{"ld_preload"} = ($has_ldpreload && !$debug_build);
! 2760: $feature{"unittest"} = $debug_build;
! 2761: $feature{"debug"} = $debug_build;
! 2762: $feature{"TrackMemory"} = $has_memory_tracking;
! 2763: $feature{"large_file"} = $has_largefile;
! 2764: $feature{"idn"} = $has_idn;
! 2765: $feature{"ipv6"} = $has_ipv6;
! 2766: $feature{"libz"} = $has_libz;
! 2767: $feature{"brotli"} = $has_brotli;
! 2768: $feature{"NTLM"} = $has_ntlm;
! 2769: $feature{"NTLM_WB"} = $has_ntlm_wb;
! 2770: $feature{"SSPI"} = $has_sspi;
! 2771: $feature{"GSS-API"} = $has_gssapi;
! 2772: $feature{"Kerberos"} = $has_kerberos;
! 2773: $feature{"SPNEGO"} = $has_spnego;
! 2774: $feature{"getrlimit"} = $has_getrlimit;
! 2775: $feature{"crypto"} = $has_crypto;
! 2776: $feature{"TLS-SRP"} = $has_tls_srp;
! 2777: $feature{"Metalink"} = $has_metalink;
! 2778: $feature{"http/2"} = $has_http2;
! 2779: $feature{"threaded-resolver"} = $has_threadedres;
! 2780: $feature{"PSL"} = $has_psl;
! 2781: $feature{"alt-svc"} = $has_altsvc;
! 2782: $feature{"manual"} = $has_manual;
! 2783: $feature{"unix-sockets"} = $has_unix;
! 2784: $feature{"win32"} = $has_win32;
! 2785: $feature{"MinGW"} = $has_mingw;
! 2786:
! 2787: # make each protocol an enabled "feature"
! 2788: for my $p (@protocols) {
! 2789: $feature{$p} = 1;
! 2790: }
! 2791: # 'socks' was once here but is now removed
! 2792:
! 2793: #
! 2794: # strings that must match the names used in server/disabled.c
! 2795: #
! 2796: $feature{"cookies"} = 1;
! 2797: $feature{"DoH"} = 1;
! 2798: $feature{"HTTP-auth"} = 1;
! 2799: $feature{"Mime"} = 1;
! 2800: $feature{"netrc"} = 1;
! 2801: $feature{"parsedate"} = 1;
! 2802: $feature{"proxy"} = 1;
! 2803: $feature{"shuffle-dns"} = 1;
! 2804: $feature{"typecheck"} = 1;
! 2805: $feature{"verbose-strings"} = 1;
! 2806:
! 2807: }
! 2808:
! 2809: #######################################################################
! 2810: # display information about curl and the host the test suite runs on
! 2811: #
! 2812: sub checksystem {
! 2813:
! 2814: unlink($memdump); # remove this if there was one left
! 2815:
! 2816: my $feat;
! 2817: my $curl;
! 2818: my $libcurl;
! 2819: my $versretval;
! 2820: my $versnoexec;
! 2821: my @version=();
! 2822: my @disabled;
! 2823: my $dis = "";
! 2824:
! 2825: my $curlverout="$LOGDIR/curlverout.log";
! 2826: my $curlvererr="$LOGDIR/curlvererr.log";
! 2827: my $versioncmd="$CURL --version 1>$curlverout 2>$curlvererr";
! 2828:
! 2829: unlink($curlverout);
! 2830: unlink($curlvererr);
! 2831:
! 2832: $versretval = runclient($versioncmd);
! 2833: $versnoexec = $!;
! 2834:
! 2835: open(VERSOUT, "<$curlverout");
! 2836: @version = <VERSOUT>;
! 2837: close(VERSOUT);
! 2838:
! 2839: open(DISABLED, "server/disabled".exe_ext('TOOL')."|");
! 2840: @disabled = <DISABLED>;
! 2841: close(DISABLED);
! 2842:
! 2843: if($disabled[0]) {
! 2844: map s/[\r\n]//g, @disabled;
! 2845: $dis = join(", ", @disabled);
! 2846: }
! 2847:
! 2848: $resolver="stock";
! 2849: for(@version) {
! 2850: chomp;
! 2851:
! 2852: if($_ =~ /^curl/) {
! 2853: $curl = $_;
! 2854: $curl =~ s/^(.*)(libcurl.*)/$1/g;
! 2855:
! 2856: $libcurl = $2;
! 2857: if($curl =~ /linux|bsd|solaris/) {
! 2858: $has_ldpreload = 1;
! 2859: }
! 2860: if($curl =~ /win32|Windows|mingw(32|64)/) {
! 2861: # This is a Windows MinGW build or native build, we need to use
! 2862: # Win32-style path.
! 2863: $pwd = pathhelp::sys_native_current_path();
! 2864: $has_textaware = 1;
! 2865: $has_win32 = 1;
! 2866: $has_mingw = 1 if ($curl =~ /-pc-mingw32/);
! 2867: }
! 2868: if ($libcurl =~ /(winssl|schannel)/i) {
! 2869: $has_winssl=1;
! 2870: $has_sslpinning=1;
! 2871: }
! 2872: elsif ($libcurl =~ /openssl/i) {
! 2873: $has_openssl=1;
! 2874: $has_sslpinning=1;
! 2875: }
! 2876: elsif ($libcurl =~ /gnutls/i) {
! 2877: $has_gnutls=1;
! 2878: $has_sslpinning=1;
! 2879: }
! 2880: elsif ($libcurl =~ /nss/i) {
! 2881: $has_nss=1;
! 2882: $has_sslpinning=1;
! 2883: }
! 2884: elsif ($libcurl =~ /wolfssl/i) {
! 2885: $has_wolfssl=1;
! 2886: $has_sslpinning=1;
! 2887: }
! 2888: elsif ($libcurl =~ /securetransport/i) {
! 2889: $has_darwinssl=1;
! 2890: $has_sslpinning=1;
! 2891: }
! 2892: elsif ($libcurl =~ /BoringSSL/i) {
! 2893: $has_boringssl=1;
! 2894: $has_sslpinning=1;
! 2895: }
! 2896: elsif ($libcurl =~ /libressl/i) {
! 2897: $has_libressl=1;
! 2898: $has_sslpinning=1;
! 2899: }
! 2900: elsif ($libcurl =~ /mbedTLS/i) {
! 2901: $has_mbedtls=1;
! 2902: $has_sslpinning=1;
! 2903: }
! 2904: if ($libcurl =~ /ares/i) {
! 2905: $has_cares=1;
! 2906: $resolver="c-ares";
! 2907: }
! 2908: if ($libcurl =~ /mesalink/i) {
! 2909: $has_mesalink=1;
! 2910: }
! 2911: }
! 2912: elsif($_ =~ /^Protocols: (.*)/i) {
! 2913: # these are the protocols compiled in to this libcurl
! 2914: @protocols = split(' ', lc($1));
! 2915:
! 2916: # Generate a "proto-ipv6" version of each protocol to match the
! 2917: # IPv6 <server> name and a "proto-unix" to match the variant which
! 2918: # uses Unix domain sockets. This works even if support isn't
! 2919: # compiled in because the <features> test will fail.
! 2920: push @protocols, map(("$_-ipv6", "$_-unix"), @protocols);
! 2921:
! 2922: # 'http-proxy' is used in test cases to do CONNECT through
! 2923: push @protocols, 'http-proxy';
! 2924:
! 2925: # 'none' is used in test cases to mean no server
! 2926: push @protocols, 'none';
! 2927: }
! 2928: elsif($_ =~ /^Features: (.*)/i) {
! 2929: $feat = $1;
! 2930: if($feat =~ /TrackMemory/i) {
! 2931: # built with memory tracking support (--enable-curldebug)
! 2932: $has_memory_tracking = 1;
! 2933: }
! 2934: if($feat =~ /debug/i) {
! 2935: # curl was built with --enable-debug
! 2936: $debug_build = 1;
! 2937: }
! 2938: if($feat =~ /SSL/i) {
! 2939: # ssl enabled
! 2940: $has_ssl=1;
! 2941: }
! 2942: if($feat =~ /MultiSSL/i) {
! 2943: # multiple ssl backends available.
! 2944: $has_multissl=1;
! 2945: }
! 2946: if($feat =~ /Largefile/i) {
! 2947: # large file support
! 2948: $has_largefile=1;
! 2949: }
! 2950: if($feat =~ /IDN/i) {
! 2951: # IDN support
! 2952: $has_idn=1;
! 2953: }
! 2954: if($feat =~ /IPv6/i) {
! 2955: $has_ipv6 = 1;
! 2956: }
! 2957: if($feat =~ /UnixSockets/i) {
! 2958: $has_unix = 1;
! 2959: }
! 2960: if($feat =~ /libz/i) {
! 2961: $has_libz = 1;
! 2962: }
! 2963: if($feat =~ /brotli/i) {
! 2964: $has_brotli = 1;
! 2965: }
! 2966: if($feat =~ /NTLM/i) {
! 2967: # NTLM enabled
! 2968: $has_ntlm=1;
! 2969:
! 2970: # Use this as a proxy for any cryptographic authentication
! 2971: $has_crypto=1;
! 2972: }
! 2973: if($feat =~ /NTLM_WB/i) {
! 2974: # NTLM delegation to winbind daemon ntlm_auth helper enabled
! 2975: $has_ntlm_wb=1;
! 2976: }
! 2977: if($feat =~ /SSPI/i) {
! 2978: # SSPI enabled
! 2979: $has_sspi=1;
! 2980: }
! 2981: if($feat =~ /GSS-API/i) {
! 2982: # GSS-API enabled
! 2983: $has_gssapi=1;
! 2984: }
! 2985: if($feat =~ /Kerberos/i) {
! 2986: # Kerberos enabled
! 2987: $has_kerberos=1;
! 2988:
! 2989: # Use this as a proxy for any cryptographic authentication
! 2990: $has_crypto=1;
! 2991: }
! 2992: if($feat =~ /SPNEGO/i) {
! 2993: # SPNEGO enabled
! 2994: $has_spnego=1;
! 2995:
! 2996: # Use this as a proxy for any cryptographic authentication
! 2997: $has_crypto=1;
! 2998: }
! 2999: if($feat =~ /CharConv/i) {
! 3000: # CharConv enabled
! 3001: $has_charconv=1;
! 3002: }
! 3003: if($feat =~ /TLS-SRP/i) {
! 3004: # TLS-SRP enabled
! 3005: $has_tls_srp=1;
! 3006: }
! 3007: if($feat =~ /Metalink/i) {
! 3008: # Metalink enabled
! 3009: $has_metalink=1;
! 3010: }
! 3011: if($feat =~ /PSL/i) {
! 3012: # PSL enabled
! 3013: $has_psl=1;
! 3014: }
! 3015: if($feat =~ /alt-svc/i) {
! 3016: # alt-svc enabled
! 3017: $has_altsvc=1;
! 3018: }
! 3019: if($feat =~ /AsynchDNS/i) {
! 3020: if(!$has_cares) {
! 3021: # this means threaded resolver
! 3022: $has_threadedres=1;
! 3023: $resolver="threaded";
! 3024: }
! 3025: }
! 3026: if($feat =~ /HTTP2/) {
! 3027: # http2 enabled
! 3028: $has_http2=1;
! 3029:
! 3030: push @protocols, 'http/2';
! 3031: }
! 3032: }
! 3033: #
! 3034: # Test harness currently uses a non-stunnel server in order to
! 3035: # run HTTP TLS-SRP tests required when curl is built with https
! 3036: # protocol support and TLS-SRP feature enabled. For convenience
! 3037: # 'httptls' may be included in the test harness protocols array
! 3038: # to differentiate this from classic stunnel based 'https' test
! 3039: # harness server.
! 3040: #
! 3041: if($has_tls_srp) {
! 3042: my $add_httptls;
! 3043: for(@protocols) {
! 3044: if($_ =~ /^https(-ipv6|)$/) {
! 3045: $add_httptls=1;
! 3046: last;
! 3047: }
! 3048: }
! 3049: if($add_httptls && (! grep /^httptls$/, @protocols)) {
! 3050: push @protocols, 'httptls';
! 3051: push @protocols, 'httptls-ipv6';
! 3052: }
! 3053: }
! 3054: }
! 3055: if(!$curl) {
! 3056: logmsg "unable to get curl's version, further details are:\n";
! 3057: logmsg "issued command: \n";
! 3058: logmsg "$versioncmd \n";
! 3059: if ($versretval == -1) {
! 3060: logmsg "command failed with: \n";
! 3061: logmsg "$versnoexec \n";
! 3062: }
! 3063: elsif ($versretval & 127) {
! 3064: logmsg sprintf("command died with signal %d, and %s coredump.\n",
! 3065: ($versretval & 127), ($versretval & 128)?"a":"no");
! 3066: }
! 3067: else {
! 3068: logmsg sprintf("command exited with value %d \n", $versretval >> 8);
! 3069: }
! 3070: logmsg "contents of $curlverout: \n";
! 3071: displaylogcontent("$curlverout");
! 3072: logmsg "contents of $curlvererr: \n";
! 3073: displaylogcontent("$curlvererr");
! 3074: die "couldn't get curl's version";
! 3075: }
! 3076:
! 3077: if(-r "../lib/curl_config.h") {
! 3078: open(CONF, "<../lib/curl_config.h");
! 3079: while(<CONF>) {
! 3080: if($_ =~ /^\#define HAVE_GETRLIMIT/) {
! 3081: $has_getrlimit = 1;
! 3082: }
! 3083: }
! 3084: close(CONF);
! 3085: }
! 3086:
! 3087: if($has_ipv6) {
! 3088: # client has IPv6 support
! 3089:
! 3090: # check if the HTTP server has it!
! 3091: my $cmd = "server/sws".exe_ext('SRV')." --version";
! 3092: my @sws = `$cmd`;
! 3093: if($sws[0] =~ /IPv6/) {
! 3094: # HTTP server has IPv6 support!
! 3095: $http_ipv6 = 1;
! 3096: $gopher_ipv6 = 1;
! 3097: }
! 3098:
! 3099: # check if the FTP server has it!
! 3100: $cmd = "server/sockfilt".exe_ext('SRV')." --version";
! 3101: @sws = `$cmd`;
! 3102: if($sws[0] =~ /IPv6/) {
! 3103: # FTP server has IPv6 support!
! 3104: $ftp_ipv6 = 1;
! 3105: }
! 3106: }
! 3107:
! 3108: if($has_unix) {
! 3109: # client has Unix sockets support, check whether the HTTP server has it
! 3110: my $cmd = "server/sws".exe_ext('SRV')." --version";
! 3111: my @sws = `$cmd`;
! 3112: $http_unix = 1 if($sws[0] =~ /unix/);
! 3113: }
! 3114:
! 3115: if(!$has_memory_tracking && $torture) {
! 3116: die "can't run torture tests since curl was built without ".
! 3117: "TrackMemory feature (--enable-curldebug)";
! 3118: }
! 3119:
! 3120: open(M, "$CURL -M 2>&1|");
! 3121: while(my $s = <M>) {
! 3122: if($s =~ /built-in manual was disabled at build-time/) {
! 3123: $has_manual = 0;
! 3124: last;
! 3125: }
! 3126: $has_manual = 1;
! 3127: last;
! 3128: }
! 3129: close(M);
! 3130:
! 3131: $has_shared = `sh $CURLCONFIG --built-shared`;
! 3132: chomp $has_shared;
! 3133:
! 3134: my $hostname=join(' ', runclientoutput("hostname"));
! 3135: my $hosttype=join(' ', runclientoutput("uname -a"));
! 3136: my $hostos=$^O;
! 3137:
! 3138: logmsg ("********* System characteristics ******** \n",
! 3139: "* $curl\n",
! 3140: "* $libcurl\n",
! 3141: "* Features: $feat\n",
! 3142: "* Disabled: $dis\n",
! 3143: "* Host: $hostname",
! 3144: "* System: $hosttype",
! 3145: "* OS: $hostos\n");
! 3146:
! 3147: if($has_memory_tracking && $has_threadedres) {
! 3148: $has_memory_tracking = 0;
! 3149: logmsg("*\n",
! 3150: "*** DISABLES memory tracking when using threaded resolver\n",
! 3151: "*\n");
! 3152: }
! 3153:
! 3154: logmsg sprintf("* Servers: %s", $stunnel?"SSL ":"");
! 3155: logmsg sprintf("%s", $http_ipv6?"HTTP-IPv6 ":"");
! 3156: logmsg sprintf("%s", $http_unix?"HTTP-unix ":"");
! 3157: logmsg sprintf("%s\n", $ftp_ipv6?"FTP-IPv6 ":"");
! 3158:
! 3159: logmsg sprintf("* Env: %s%s", $valgrind?"Valgrind ":"",
! 3160: $run_event_based?"event-based ":"");
! 3161: logmsg sprintf("%s\n", $libtool?"Libtool ":"");
! 3162: logmsg ("* Seed: $randseed\n");
! 3163: logmsg ("* Port range: $minport-$maxport\n");
! 3164:
! 3165: if($verbose) {
! 3166: logmsg "* Ports: ";
! 3167: if($stunnel) {
! 3168: logmsg sprintf("FTPS/%d ", $FTPSPORT);
! 3169: logmsg sprintf("HTTPS/%d ", $HTTPSPORT);
! 3170: }
! 3171: logmsg sprintf("\n* SSH/%d ", $SSHPORT);
! 3172: if($httptlssrv) {
! 3173: logmsg sprintf("HTTPTLS/%d ", $HTTPTLSPORT);
! 3174: if($has_ipv6) {
! 3175: logmsg sprintf("HTTPTLS-IPv6/%d ", $HTTPTLS6PORT);
! 3176: }
! 3177: logmsg "\n";
! 3178: }
! 3179:
! 3180: if($has_unix) {
! 3181: logmsg "* Unix socket paths:\n";
! 3182: if($http_unix) {
! 3183: logmsg sprintf("* HTTP-Unix:%s\n", $HTTPUNIXPATH);
! 3184: }
! 3185: }
! 3186: }
! 3187:
! 3188: logmsg "***************************************** \n";
! 3189:
! 3190: setupfeatures();
! 3191: # toggle off the features that were disabled in the build
! 3192: for my $d(@disabled) {
! 3193: $feature{$d} = 0;
! 3194: }
! 3195: }
! 3196:
! 3197: #######################################################################
! 3198: # substitute the variable stuff into either a joined up file or
! 3199: # a command, in either case passed by reference
! 3200: #
! 3201: sub subVariables {
! 3202: my ($thing, $prefix) = @_;
! 3203:
! 3204: if(!$prefix) {
! 3205: $prefix = "%";
! 3206: }
! 3207:
! 3208: # test server ports
! 3209: $$thing =~ s/${prefix}FTP6PORT/$FTP6PORT/g;
! 3210: $$thing =~ s/${prefix}FTP2PORT/$FTP2PORT/g;
! 3211: $$thing =~ s/${prefix}FTPSPORT/$FTPSPORT/g;
! 3212: $$thing =~ s/${prefix}FTPPORT/$FTPPORT/g;
! 3213: $$thing =~ s/${prefix}GOPHER6PORT/$GOPHER6PORT/g;
! 3214: $$thing =~ s/${prefix}GOPHERPORT/$GOPHERPORT/g;
! 3215: $$thing =~ s/${prefix}HTTPTLS6PORT/$HTTPTLS6PORT/g;
! 3216: $$thing =~ s/${prefix}HTTPTLSPORT/$HTTPTLSPORT/g;
! 3217: $$thing =~ s/${prefix}HTTP6PORT/$HTTP6PORT/g;
! 3218: $$thing =~ s/${prefix}HTTPSPORT/$HTTPSPORT/g;
! 3219: $$thing =~ s/${prefix}HTTP2PORT/$HTTP2PORT/g;
! 3220: $$thing =~ s/${prefix}HTTPPORT/$HTTPPORT/g;
! 3221: $$thing =~ s/${prefix}PROXYPORT/$HTTPPROXYPORT/g;
! 3222: $$thing =~ s/${prefix}MQTTPORT/$MQTTPORT/g;
! 3223: $$thing =~ s/${prefix}IMAP6PORT/$IMAP6PORT/g;
! 3224: $$thing =~ s/${prefix}IMAPPORT/$IMAPPORT/g;
! 3225: $$thing =~ s/${prefix}POP36PORT/$POP36PORT/g;
! 3226: $$thing =~ s/${prefix}POP3PORT/$POP3PORT/g;
! 3227: $$thing =~ s/${prefix}RTSP6PORT/$RTSP6PORT/g;
! 3228: $$thing =~ s/${prefix}RTSPPORT/$RTSPPORT/g;
! 3229: $$thing =~ s/${prefix}SMTP6PORT/$SMTP6PORT/g;
! 3230: $$thing =~ s/${prefix}SMTPPORT/$SMTPPORT/g;
! 3231: $$thing =~ s/${prefix}SOCKSPORT/$SOCKSPORT/g;
! 3232: $$thing =~ s/${prefix}SSHPORT/$SSHPORT/g;
! 3233: $$thing =~ s/${prefix}TFTP6PORT/$TFTP6PORT/g;
! 3234: $$thing =~ s/${prefix}TFTPPORT/$TFTPPORT/g;
! 3235: $$thing =~ s/${prefix}DICTPORT/$DICTPORT/g;
! 3236: $$thing =~ s/${prefix}SMBPORT/$SMBPORT/g;
! 3237: $$thing =~ s/${prefix}SMBSPORT/$SMBSPORT/g;
! 3238: $$thing =~ s/${prefix}NEGTELNETPORT/$NEGTELNETPORT/g;
! 3239: $$thing =~ s/${prefix}NOLISTENPORT/$NOLISTENPORT/g;
! 3240:
! 3241: # server Unix domain socket paths
! 3242: $$thing =~ s/${prefix}HTTPUNIXPATH/$HTTPUNIXPATH/g;
! 3243:
! 3244: # client IP addresses
! 3245: $$thing =~ s/${prefix}CLIENT6IP/$CLIENT6IP/g;
! 3246: $$thing =~ s/${prefix}CLIENTIP/$CLIENTIP/g;
! 3247:
! 3248: # server IP addresses
! 3249: $$thing =~ s/${prefix}HOST6IP/$HOST6IP/g;
! 3250: $$thing =~ s/${prefix}HOSTIP/$HOSTIP/g;
! 3251:
! 3252: # misc
! 3253: $$thing =~ s/${prefix}CURL/$CURL/g;
! 3254: $$thing =~ s/${prefix}PWD/$pwd/g;
! 3255: $$thing =~ s/${prefix}POSIX_PWD/$posix_pwd/g;
! 3256:
! 3257: my $file_pwd = $pwd;
! 3258: if($file_pwd !~ /^\//) {
! 3259: $file_pwd = "/$file_pwd";
! 3260: }
! 3261:
! 3262: $$thing =~ s/${prefix}FILE_PWD/$file_pwd/g;
! 3263: $$thing =~ s/${prefix}SRCDIR/$srcdir/g;
! 3264: $$thing =~ s/${prefix}USER/$USER/g;
! 3265:
! 3266: $$thing =~ s/${prefix}SSHSRVMD5/$SSHSRVMD5/g;
! 3267:
! 3268: # The purpose of FTPTIME2 and FTPTIME3 is to provide times that can be
! 3269: # used for time-out tests and that would work on most hosts as these
! 3270: # adjust for the startup/check time for this particular host. We needed to
! 3271: # do this to make the test suite run better on very slow hosts.
! 3272: my $ftp2 = $ftpchecktime * 2;
! 3273: my $ftp3 = $ftpchecktime * 3;
! 3274:
! 3275: $$thing =~ s/${prefix}FTPTIME2/$ftp2/g;
! 3276: $$thing =~ s/${prefix}FTPTIME3/$ftp3/g;
! 3277:
! 3278: # HTTP2
! 3279: $$thing =~ s/${prefix}H2CVER/$h2cver/g;
! 3280: }
! 3281:
! 3282: sub fixarray {
! 3283: my @in = @_;
! 3284:
! 3285: for(@in) {
! 3286: subVariables(\$_);
! 3287: }
! 3288: return @in;
! 3289: }
! 3290:
! 3291: #######################################################################
! 3292: # Provide time stamps for single test skipped events
! 3293: #
! 3294: sub timestampskippedevents {
! 3295: my $testnum = $_[0];
! 3296:
! 3297: return if((not defined($testnum)) || ($testnum < 1));
! 3298:
! 3299: if($timestats) {
! 3300:
! 3301: if($timevrfyend{$testnum}) {
! 3302: return;
! 3303: }
! 3304: elsif($timesrvrlog{$testnum}) {
! 3305: $timevrfyend{$testnum} = $timesrvrlog{$testnum};
! 3306: return;
! 3307: }
! 3308: elsif($timetoolend{$testnum}) {
! 3309: $timevrfyend{$testnum} = $timetoolend{$testnum};
! 3310: $timesrvrlog{$testnum} = $timetoolend{$testnum};
! 3311: }
! 3312: elsif($timetoolini{$testnum}) {
! 3313: $timevrfyend{$testnum} = $timetoolini{$testnum};
! 3314: $timesrvrlog{$testnum} = $timetoolini{$testnum};
! 3315: $timetoolend{$testnum} = $timetoolini{$testnum};
! 3316: }
! 3317: elsif($timesrvrend{$testnum}) {
! 3318: $timevrfyend{$testnum} = $timesrvrend{$testnum};
! 3319: $timesrvrlog{$testnum} = $timesrvrend{$testnum};
! 3320: $timetoolend{$testnum} = $timesrvrend{$testnum};
! 3321: $timetoolini{$testnum} = $timesrvrend{$testnum};
! 3322: }
! 3323: elsif($timesrvrini{$testnum}) {
! 3324: $timevrfyend{$testnum} = $timesrvrini{$testnum};
! 3325: $timesrvrlog{$testnum} = $timesrvrini{$testnum};
! 3326: $timetoolend{$testnum} = $timesrvrini{$testnum};
! 3327: $timetoolini{$testnum} = $timesrvrini{$testnum};
! 3328: $timesrvrend{$testnum} = $timesrvrini{$testnum};
! 3329: }
! 3330: elsif($timeprepini{$testnum}) {
! 3331: $timevrfyend{$testnum} = $timeprepini{$testnum};
! 3332: $timesrvrlog{$testnum} = $timeprepini{$testnum};
! 3333: $timetoolend{$testnum} = $timeprepini{$testnum};
! 3334: $timetoolini{$testnum} = $timeprepini{$testnum};
! 3335: $timesrvrend{$testnum} = $timeprepini{$testnum};
! 3336: $timesrvrini{$testnum} = $timeprepini{$testnum};
! 3337: }
! 3338: }
! 3339: }
! 3340:
! 3341: #######################################################################
! 3342: # Run a single specified test case
! 3343: #
! 3344: sub singletest {
! 3345: my ($evbased, # 1 means switch on if possible (and "curl" is tested)
! 3346: # returns "not a test" if it can't be used for this test
! 3347: $testnum,
! 3348: $count,
! 3349: $total)=@_;
! 3350:
! 3351: my @what;
! 3352: my $why;
! 3353: my $cmd;
! 3354: my $disablevalgrind;
! 3355: my $errorreturncode = 1; # 1 means normal error, 2 means ignored error
! 3356:
! 3357: # fist, remove all lingering log files
! 3358: cleardir($LOGDIR);
! 3359:
! 3360: # copy test number to a global scope var, this allows
! 3361: # testnum checking when starting test harness servers.
! 3362: $testnumcheck = $testnum;
! 3363:
! 3364: # timestamp test preparation start
! 3365: $timeprepini{$testnum} = Time::HiRes::time();
! 3366:
! 3367: if($disttests !~ /test$testnum\W/ ) {
! 3368: logmsg "Warning: test$testnum not present in tests/data/Makefile.inc\n";
! 3369: }
! 3370: if($disabled{$testnum}) {
! 3371: logmsg "Warning: test$testnum is explicitly disabled\n";
! 3372: }
! 3373: if($ignored{$testnum}) {
! 3374: logmsg "Warning: test$testnum result is ignored\n";
! 3375: $errorreturncode = 2;
! 3376: }
! 3377:
! 3378: # load the test case file definition
! 3379: if(loadtest("${TESTDIR}/test${testnum}")) {
! 3380: if($verbose) {
! 3381: # this is not a test
! 3382: logmsg "RUN: $testnum doesn't look like a test case\n";
! 3383: }
! 3384: $why = "no test";
! 3385: }
! 3386: else {
! 3387: @what = getpart("client", "features");
! 3388: }
! 3389:
! 3390: # We require a feature to be present
! 3391: for(@what) {
! 3392: my $f = $_;
! 3393: $f =~ s/\s//g;
! 3394:
! 3395: if($f =~ /^([^!].*)$/) {
! 3396: if($feature{$1}) {
! 3397: next;
! 3398: }
! 3399:
! 3400: $why = "curl lacks $1 support";
! 3401: last;
! 3402: }
! 3403: }
! 3404:
! 3405: # We require a feature to not be present
! 3406: if(!$why) {
! 3407: for(@what) {
! 3408: my $f = $_;
! 3409: $f =~ s/\s//g;
! 3410:
! 3411: if($f =~ /^!(.*)$/) {
! 3412: if(!$feature{$1}) {
! 3413: next;
! 3414: }
! 3415: }
! 3416: else {
! 3417: next;
! 3418: }
! 3419:
! 3420: $why = "curl has $1 support";
! 3421: last;
! 3422: }
! 3423: }
! 3424:
! 3425: if(!$why) {
! 3426: my @info_keywords = getpart("info", "keywords");
! 3427: my $match;
! 3428: my $k;
! 3429:
! 3430: # Clear the list of keywords from the last test
! 3431: %keywords = ();
! 3432:
! 3433: if(!$info_keywords[0]) {
! 3434: $why = "missing the <keywords> section!";
! 3435: }
! 3436:
! 3437: for $k (@info_keywords) {
! 3438: chomp $k;
! 3439: if ($disabled_keywords{lc($k)}) {
! 3440: $why = "disabled by keyword";
! 3441: } elsif ($enabled_keywords{lc($k)}) {
! 3442: $match = 1;
! 3443: }
! 3444: if ($ignored_keywords{lc($k)}) {
! 3445: logmsg "Warning: test$testnum result is ignored due to $k\n";
! 3446: $errorreturncode = 2;
! 3447: }
! 3448:
! 3449: $keywords{$k} = 1;
! 3450: }
! 3451:
! 3452: if(!$why && !$match && %enabled_keywords) {
! 3453: $why = "disabled by missing keyword";
! 3454: }
! 3455: }
! 3456:
! 3457: # test definition may instruct to (un)set environment vars
! 3458: # this is done this early, so that the precheck can use environment
! 3459: # variables and still bail out fine on errors
! 3460:
! 3461: # restore environment variables that were modified in a previous run
! 3462: foreach my $var (keys %oldenv) {
! 3463: if($oldenv{$var} eq 'notset') {
! 3464: delete $ENV{$var} if($ENV{$var});
! 3465: }
! 3466: else {
! 3467: $ENV{$var} = $oldenv{$var};
! 3468: }
! 3469: delete $oldenv{$var};
! 3470: }
! 3471:
! 3472: # get the name of the test early
! 3473: my @testname= getpart("client", "name");
! 3474: my $testname = $testname[0];
! 3475: $testname =~ s/\n//g;
! 3476:
! 3477: # create test result in CI services
! 3478: if(azure_check_environment() && $AZURE_RUN_ID) {
! 3479: $AZURE_RESULT_ID = azure_create_test_result($AZURE_RUN_ID, $testnum, $testname);
! 3480: }
! 3481: elsif(appveyor_check_environment()) {
! 3482: appveyor_create_test_result($testnum, $testname);
! 3483: }
! 3484:
! 3485: # remove test server commands file before servers are started/verified
! 3486: unlink($FTPDCMD) if(-f $FTPDCMD);
! 3487:
! 3488: # timestamp required servers verification start
! 3489: $timesrvrini{$testnum} = Time::HiRes::time();
! 3490:
! 3491: if(!$why) {
! 3492: $why = serverfortest($testnum);
! 3493: }
! 3494:
! 3495: # Save a preprocessed version of the entire test file. This allows more
! 3496: # "basic" test case readers to enjoy variable replacements.
! 3497: my @entiretest = fulltest();
! 3498: my $otest = "log/test$testnum";
! 3499: open(D, ">$otest");
! 3500: my $diff;
! 3501: for my $s (@entiretest) {
! 3502: my $f = $s;
! 3503: subVariables(\$s, "%");
! 3504: if($f ne $s) {
! 3505: $diff++;
! 3506: }
! 3507: print D $s;
! 3508: }
! 3509: close(D);
! 3510: # remove the separate test file again if nothing was updated to keep
! 3511: # things simpler
! 3512: unlink($otest) if(!$diff);
! 3513:
! 3514: # timestamp required servers verification end
! 3515: $timesrvrend{$testnum} = Time::HiRes::time();
! 3516:
! 3517: my @setenv = getpart("client", "setenv");
! 3518: if(@setenv) {
! 3519: foreach my $s (@setenv) {
! 3520: chomp $s;
! 3521: subVariables(\$s);
! 3522: if($s =~ /([^=]*)=(.*)/) {
! 3523: my ($var, $content) = ($1, $2);
! 3524: # remember current setting, to restore it once test runs
! 3525: $oldenv{$var} = ($ENV{$var})?"$ENV{$var}":'notset';
! 3526: # set new value
! 3527: if(!$content) {
! 3528: delete $ENV{$var} if($ENV{$var});
! 3529: }
! 3530: else {
! 3531: if($var =~ /^LD_PRELOAD/) {
! 3532: if(exe_ext('TOOL') && (exe_ext('TOOL') eq '.exe')) {
! 3533: # print "Skipping LD_PRELOAD due to lack of OS support\n";
! 3534: next;
! 3535: }
! 3536: if($debug_build || ($has_shared ne "yes")) {
! 3537: # print "Skipping LD_PRELOAD due to no release shared build\n";
! 3538: next;
! 3539: }
! 3540: }
! 3541: $ENV{$var} = "$content";
! 3542: print "setenv $var = $content\n" if($verbose);
! 3543: }
! 3544: }
! 3545: }
! 3546: }
! 3547:
! 3548: if(!$why) {
! 3549: my @precheck = getpart("client", "precheck");
! 3550: if(@precheck) {
! 3551: $cmd = $precheck[0];
! 3552: chomp $cmd;
! 3553: subVariables(\$cmd);
! 3554: if($cmd) {
! 3555: my @p = split(/ /, $cmd);
! 3556: if($p[0] !~ /\//) {
! 3557: # the first word, the command, does not contain a slash so
! 3558: # we will scan the "improved" PATH to find the command to
! 3559: # be able to run it
! 3560: my $fullp = checktestcmd($p[0]);
! 3561:
! 3562: if($fullp) {
! 3563: $p[0] = $fullp;
! 3564: }
! 3565: $cmd = join(" ", @p);
! 3566: }
! 3567:
! 3568: my @o = `$cmd 2>/dev/null`;
! 3569: if($o[0]) {
! 3570: $why = $o[0];
! 3571: chomp $why;
! 3572: } elsif($?) {
! 3573: $why = "precheck command error";
! 3574: }
! 3575: logmsg "prechecked $cmd\n" if($verbose);
! 3576: }
! 3577: }
! 3578: }
! 3579:
! 3580: if($why && !$listonly) {
! 3581: # there's a problem, count it as "skipped"
! 3582: $skipped++;
! 3583: $skipped{$why}++;
! 3584: $teststat[$testnum]=$why; # store reason for this test case
! 3585:
! 3586: if(!$short) {
! 3587: if($skipped{$why} <= 3) {
! 3588: # show only the first three skips for each reason
! 3589: logmsg sprintf("test %04d SKIPPED: $why\n", $testnum);
! 3590: }
! 3591: }
! 3592:
! 3593: timestampskippedevents($testnum);
! 3594: return -1;
! 3595: }
! 3596: logmsg sprintf("test %04d...", $testnum) if(!$automakestyle);
! 3597:
! 3598: my %replyattr = getpartattr("reply", "data");
! 3599: my @reply;
! 3600: if (partexists("reply", "datacheck")) {
! 3601: for my $partsuffix (('', '1', '2', '3', '4')) {
! 3602: my @replycheckpart = getpart("reply", "datacheck".$partsuffix);
! 3603: if(@replycheckpart) {
! 3604: my %replycheckpartattr = getpartattr("reply", "datacheck".$partsuffix);
! 3605: # get the mode attribute
! 3606: my $filemode=$replycheckpartattr{'mode'};
! 3607: if($filemode && ($filemode eq "text") && $has_textaware) {
! 3608: # text mode when running on windows: fix line endings
! 3609: map s/\r\n/\n/g, @replycheckpart;
! 3610: map s/\n/\r\n/g, @replycheckpart;
! 3611: }
! 3612: if($replycheckpartattr{'nonewline'}) {
! 3613: # Yes, we must cut off the final newline from the final line
! 3614: # of the datacheck
! 3615: chomp($replycheckpart[$#replycheckpart]);
! 3616: }
! 3617: push(@reply, @replycheckpart);
! 3618: }
! 3619: }
! 3620: }
! 3621: else {
! 3622: # check against the data section
! 3623: @reply = getpart("reply", "data");
! 3624: # get the mode attribute
! 3625: my $filemode=$replyattr{'mode'};
! 3626: if($filemode && ($filemode eq "text") && $has_textaware) {
! 3627: # text mode when running on windows: fix line endings
! 3628: map s/\r\n/\n/g, @reply;
! 3629: map s/\n/\r\n/g, @reply;
! 3630: }
! 3631: }
! 3632: for my $r (@reply) {
! 3633: subVariables(\$r);
! 3634: }
! 3635:
! 3636: # this is the valid protocol blurb curl should generate
! 3637: my @protocol= fixarray ( getpart("verify", "protocol") );
! 3638:
! 3639: # this is the valid protocol blurb curl should generate to a proxy
! 3640: my @proxyprot = fixarray ( getpart("verify", "proxy") );
! 3641:
! 3642: # redirected stdout/stderr to these files
! 3643: $STDOUT="$LOGDIR/stdout$testnum";
! 3644: $STDERR="$LOGDIR/stderr$testnum";
! 3645:
! 3646: # if this section exists, we verify that the stdout contained this:
! 3647: my @validstdout = fixarray ( getpart("verify", "stdout") );
! 3648: my @validstderr = fixarray ( getpart("verify", "stderr") );
! 3649:
! 3650: # if this section exists, we verify upload
! 3651: my @upload = getpart("verify", "upload");
! 3652: if(@upload) {
! 3653: my %hash = getpartattr("verify", "upload");
! 3654: if($hash{'nonewline'}) {
! 3655: # cut off the final newline from the final line of the upload data
! 3656: chomp($upload[$#upload]);
! 3657: }
! 3658: }
! 3659:
! 3660: # if this section exists, it might be FTP server instructions:
! 3661: my @ftpservercmd = fixarray ( getpart("reply", "servercmd") );
! 3662:
! 3663: my $CURLOUT="$LOGDIR/curl$testnum.out"; # curl output if not stdout
! 3664:
! 3665: # name of the test
! 3666: logmsg "[$testname]\n" if(!$short);
! 3667:
! 3668: if($listonly) {
! 3669: timestampskippedevents($testnum);
! 3670: return 0; # look successful
! 3671: }
! 3672:
! 3673: my @codepieces = getpart("client", "tool");
! 3674:
! 3675: my $tool="";
! 3676: if(@codepieces) {
! 3677: $tool = $codepieces[0];
! 3678: chomp $tool;
! 3679: $tool .= exe_ext('TOOL');
! 3680: }
! 3681:
! 3682: # remove server output logfile
! 3683: unlink($SERVERIN);
! 3684: unlink($SERVER2IN);
! 3685: unlink($PROXYIN);
! 3686:
! 3687: push @ftpservercmd, "Testnum $testnum\n";
! 3688: # write the instructions to file
! 3689: writearray($FTPDCMD, \@ftpservercmd);
! 3690:
! 3691: # get the command line options to use
! 3692: my @blaha;
! 3693: ($cmd, @blaha)= getpart("client", "command");
! 3694:
! 3695: if($cmd) {
! 3696: # make some nice replace operations
! 3697: $cmd =~ s/\n//g; # no newlines please
! 3698: # substitute variables in the command line
! 3699: subVariables(\$cmd);
! 3700: }
! 3701: else {
! 3702: # there was no command given, use something silly
! 3703: $cmd="-";
! 3704: }
! 3705: if($has_memory_tracking) {
! 3706: unlink($memdump);
! 3707: }
! 3708:
! 3709: # create (possibly-empty) files before starting the test
! 3710: for my $partsuffix (('', '1', '2', '3', '4')) {
! 3711: my @inputfile=getpart("client", "file".$partsuffix);
! 3712: my %fileattr = getpartattr("client", "file".$partsuffix);
! 3713: my $filename=$fileattr{'name'};
! 3714: if(@inputfile || $filename) {
! 3715: if(!$filename) {
! 3716: logmsg "ERROR: section client=>file has no name attribute\n";
! 3717: timestampskippedevents($testnum);
! 3718: return -1;
! 3719: }
! 3720: my $fileContent = join('', @inputfile);
! 3721: subVariables \$fileContent;
! 3722: # logmsg "DEBUG: writing file " . $filename . "\n";
! 3723: open(OUTFILE, ">$filename");
! 3724: binmode OUTFILE; # for crapage systems, use binary
! 3725: print OUTFILE $fileContent;
! 3726: close(OUTFILE);
! 3727: }
! 3728: }
! 3729:
! 3730: my %cmdhash = getpartattr("client", "command");
! 3731:
! 3732: my $out="";
! 3733:
! 3734: if((!$cmdhash{'option'}) || ($cmdhash{'option'} !~ /no-output/)) {
! 3735: #We may slap on --output!
! 3736: if (!@validstdout ||
! 3737: ($cmdhash{'option'} && $cmdhash{'option'} =~ /force-output/)) {
! 3738: $out=" --output $CURLOUT ";
! 3739: }
! 3740: }
! 3741:
! 3742: my $serverlogslocktimeout = $defserverlogslocktimeout;
! 3743: if($cmdhash{'timeout'}) {
! 3744: # test is allowed to override default server logs lock timeout
! 3745: if($cmdhash{'timeout'} =~ /(\d+)/) {
! 3746: $serverlogslocktimeout = $1 if($1 >= 0);
! 3747: }
! 3748: }
! 3749:
! 3750: my $postcommanddelay = $defpostcommanddelay;
! 3751: if($cmdhash{'delay'}) {
! 3752: # test is allowed to specify a delay after command is executed
! 3753: if($cmdhash{'delay'} =~ /(\d+)/) {
! 3754: $postcommanddelay = $1 if($1 > 0);
! 3755: }
! 3756: }
! 3757:
! 3758: my $CMDLINE;
! 3759: my $cmdargs;
! 3760: my $cmdtype = $cmdhash{'type'} || "default";
! 3761: my $fail_due_event_based = $evbased;
! 3762: if($cmdtype eq "perl") {
! 3763: # run the command line prepended with "perl"
! 3764: $cmdargs ="$cmd";
! 3765: $CMDLINE = "$perl ";
! 3766: $tool=$CMDLINE;
! 3767: $disablevalgrind=1;
! 3768: }
! 3769: elsif($cmdtype eq "shell") {
! 3770: # run the command line prepended with "/bin/sh"
! 3771: $cmdargs ="$cmd";
! 3772: $CMDLINE = "/bin/sh ";
! 3773: $tool=$CMDLINE;
! 3774: $disablevalgrind=1;
! 3775: }
! 3776: elsif(!$tool && !$keywords{"unittest"}) {
! 3777: # run curl, add suitable command line options
! 3778: my $inc="";
! 3779: if((!$cmdhash{'option'}) || ($cmdhash{'option'} !~ /no-include/)) {
! 3780: $inc = " --include";
! 3781: }
! 3782: $cmdargs = "$out$inc ";
! 3783:
! 3784: if($cmdhash{'option'} && ($cmdhash{'option'} =~ /binary-trace/)) {
! 3785: $cmdargs .= "--trace log/trace$testnum ";
! 3786: }
! 3787: else {
! 3788: $cmdargs .= "--trace-ascii log/trace$testnum ";
! 3789: }
! 3790: $cmdargs .= "--trace-time ";
! 3791: if($evbased) {
! 3792: $cmdargs .= "--test-event ";
! 3793: $fail_due_event_based--;
! 3794: }
! 3795: $cmdargs .= $cmd;
! 3796: }
! 3797: else {
! 3798: $cmdargs = " $cmd"; # $cmd is the command line for the test file
! 3799: $CURLOUT = $STDOUT; # sends received data to stdout
! 3800:
! 3801: # Default the tool to a unit test with the same name as the test spec
! 3802: if($keywords{"unittest"} && !$tool) {
! 3803: $tool="unit$testnum";
! 3804: }
! 3805:
! 3806: if($tool =~ /^lib/) {
! 3807: $CMDLINE="$LIBDIR/$tool";
! 3808: }
! 3809: elsif($tool =~ /^unit/) {
! 3810: $CMDLINE="$UNITDIR/$tool";
! 3811: }
! 3812:
! 3813: if(! -f $CMDLINE) {
! 3814: logmsg "The tool set in the test case for this: '$tool' does not exist\n";
! 3815: timestampskippedevents($testnum);
! 3816: return -1;
! 3817: }
! 3818: $DBGCURL=$CMDLINE;
! 3819: }
! 3820:
! 3821: if($gdbthis) {
! 3822: # gdb is incompatible with valgrind, so disable it when debugging
! 3823: # Perhaps a better approach would be to run it under valgrind anyway
! 3824: # with --db-attach=yes or --vgdb=yes.
! 3825: $disablevalgrind=1;
! 3826: }
! 3827:
! 3828: if($fail_due_event_based) {
! 3829: logmsg "This test cannot run event based\n";
! 3830: return -1;
! 3831: }
! 3832:
! 3833: my @stdintest = getpart("client", "stdin");
! 3834:
! 3835: if(@stdintest) {
! 3836: my $stdinfile="$LOGDIR/stdin-for-$testnum";
! 3837:
! 3838: my %hash = getpartattr("client", "stdin");
! 3839: if($hash{'nonewline'}) {
! 3840: # cut off the final newline from the final line of the stdin data
! 3841: chomp($stdintest[$#stdintest]);
! 3842: }
! 3843:
! 3844: writearray($stdinfile, \@stdintest);
! 3845:
! 3846: $cmdargs .= " <$stdinfile";
! 3847: }
! 3848:
! 3849: if(!$tool) {
! 3850: $CMDLINE="$CURL";
! 3851: }
! 3852:
! 3853: my $usevalgrind;
! 3854: if($valgrind && !$disablevalgrind) {
! 3855: my @valgrindoption = getpart("verify", "valgrind");
! 3856: if((!@valgrindoption) || ($valgrindoption[0] !~ /disable/)) {
! 3857: $usevalgrind = 1;
! 3858: my $valgrindcmd = "$valgrind ";
! 3859: $valgrindcmd .= "$valgrind_tool " if($valgrind_tool);
! 3860: $valgrindcmd .= "--quiet --leak-check=yes ";
! 3861: $valgrindcmd .= "--suppressions=$srcdir/valgrind.supp ";
! 3862: # $valgrindcmd .= "--gen-suppressions=all ";
! 3863: $valgrindcmd .= "--num-callers=16 ";
! 3864: $valgrindcmd .= "${valgrind_logfile}=$LOGDIR/valgrind$testnum";
! 3865: $CMDLINE = "$valgrindcmd $CMDLINE";
! 3866: }
! 3867: }
! 3868:
! 3869: $CMDLINE .= "$cmdargs >$STDOUT 2>$STDERR";
! 3870:
! 3871: if($verbose) {
! 3872: logmsg "$CMDLINE\n";
! 3873: }
! 3874:
! 3875: open(CMDLOG, ">", "$LOGDIR/$CURLLOG");
! 3876: print CMDLOG "$CMDLINE\n";
! 3877: close(CMDLOG);
! 3878:
! 3879: unlink("core");
! 3880:
! 3881: my $dumped_core;
! 3882: my $cmdres;
! 3883:
! 3884: if($gdbthis) {
! 3885: my $gdbinit = "$TESTDIR/gdbinit$testnum";
! 3886: open(GDBCMD, ">$LOGDIR/gdbcmd");
! 3887: print GDBCMD "set args $cmdargs\n";
! 3888: print GDBCMD "show args\n";
! 3889: print GDBCMD "source $gdbinit\n" if -e $gdbinit;
! 3890: close(GDBCMD);
! 3891: }
! 3892:
! 3893: # timestamp starting of test command
! 3894: $timetoolini{$testnum} = Time::HiRes::time();
! 3895:
! 3896: # run the command line we built
! 3897: if ($torture) {
! 3898: $cmdres = torture($CMDLINE,
! 3899: $testnum,
! 3900: "$gdb --directory libtest $DBGCURL -x $LOGDIR/gdbcmd");
! 3901: }
! 3902: elsif($gdbthis) {
! 3903: my $GDBW = ($gdbxwin) ? "-w" : "";
! 3904: runclient("$gdb --directory libtest $DBGCURL $GDBW -x $LOGDIR/gdbcmd");
! 3905: $cmdres=0; # makes it always continue after a debugged run
! 3906: }
! 3907: else {
! 3908: $cmdres = runclient("$CMDLINE");
! 3909: my $signal_num = $cmdres & 127;
! 3910: $dumped_core = $cmdres & 128;
! 3911:
! 3912: if(!$anyway && ($signal_num || $dumped_core)) {
! 3913: $cmdres = 1000;
! 3914: }
! 3915: else {
! 3916: $cmdres >>= 8;
! 3917: $cmdres = (2000 + $signal_num) if($signal_num && !$cmdres);
! 3918: }
! 3919: }
! 3920:
! 3921: # timestamp finishing of test command
! 3922: $timetoolend{$testnum} = Time::HiRes::time();
! 3923:
! 3924: if(!$dumped_core) {
! 3925: if(-r "core") {
! 3926: # there's core file present now!
! 3927: $dumped_core = 1;
! 3928: }
! 3929: }
! 3930:
! 3931: if($dumped_core) {
! 3932: logmsg "core dumped\n";
! 3933: if(0 && $gdb) {
! 3934: logmsg "running gdb for post-mortem analysis:\n";
! 3935: open(GDBCMD, ">$LOGDIR/gdbcmd2");
! 3936: print GDBCMD "bt\n";
! 3937: close(GDBCMD);
! 3938: runclient("$gdb --directory libtest -x $LOGDIR/gdbcmd2 -batch $DBGCURL core ");
! 3939: # unlink("$LOGDIR/gdbcmd2");
! 3940: }
! 3941: }
! 3942:
! 3943: # If a server logs advisor read lock file exists, it is an indication
! 3944: # that the server has not yet finished writing out all its log files,
! 3945: # including server request log files used for protocol verification.
! 3946: # So, if the lock file exists the script waits here a certain amount
! 3947: # of time until the server removes it, or the given time expires.
! 3948:
! 3949: if($serverlogslocktimeout) {
! 3950: my $lockretry = $serverlogslocktimeout * 20;
! 3951: while((-f $SERVERLOGS_LOCK) && $lockretry--) {
! 3952: portable_sleep(0.05);
! 3953: }
! 3954: if(($lockretry < 0) &&
! 3955: ($serverlogslocktimeout >= $defserverlogslocktimeout)) {
! 3956: logmsg "Warning: server logs lock timeout ",
! 3957: "($serverlogslocktimeout seconds) expired\n";
! 3958: }
! 3959: }
! 3960:
! 3961: # Test harness ssh server does not have this synchronization mechanism,
! 3962: # this implies that some ssh server based tests might need a small delay
! 3963: # once that the client command has run to avoid false test failures.
! 3964: #
! 3965: # gnutls-serv also lacks this synchronization mechanism, so gnutls-serv
! 3966: # based tests might need a small delay once that the client command has
! 3967: # run to avoid false test failures.
! 3968:
! 3969: portable_sleep($postcommanddelay) if($postcommanddelay);
! 3970:
! 3971: # timestamp removal of server logs advisor read lock
! 3972: $timesrvrlog{$testnum} = Time::HiRes::time();
! 3973:
! 3974: # test definition might instruct to stop some servers
! 3975: # stop also all servers relative to the given one
! 3976:
! 3977: my @killtestservers = getpart("client", "killserver");
! 3978: if(@killtestservers) {
! 3979: foreach my $server (@killtestservers) {
! 3980: chomp $server;
! 3981: stopserver($server);
! 3982: }
! 3983: }
! 3984:
! 3985: # run the postcheck command
! 3986: my @postcheck= getpart("client", "postcheck");
! 3987: if(@postcheck) {
! 3988: $cmd = join("", @postcheck);
! 3989: chomp $cmd;
! 3990: subVariables \$cmd;
! 3991: if($cmd) {
! 3992: logmsg "postcheck $cmd\n" if($verbose);
! 3993: my $rc = runclient("$cmd");
! 3994: # Must run the postcheck command in torture mode in order
! 3995: # to clean up, but the result can't be relied upon.
! 3996: if($rc != 0 && !$torture) {
! 3997: logmsg " postcheck FAILED\n";
! 3998: # timestamp test result verification end
! 3999: $timevrfyend{$testnum} = Time::HiRes::time();
! 4000: return $errorreturncode;
! 4001: }
! 4002: }
! 4003: }
! 4004:
! 4005: # restore environment variables that were modified
! 4006: if(%oldenv) {
! 4007: foreach my $var (keys %oldenv) {
! 4008: if($oldenv{$var} eq 'notset') {
! 4009: delete $ENV{$var} if($ENV{$var});
! 4010: }
! 4011: else {
! 4012: $ENV{$var} = "$oldenv{$var}";
! 4013: }
! 4014: }
! 4015: }
! 4016:
! 4017: # Skip all the verification on torture tests
! 4018: if ($torture) {
! 4019: # timestamp test result verification end
! 4020: $timevrfyend{$testnum} = Time::HiRes::time();
! 4021: return $cmdres;
! 4022: }
! 4023:
! 4024: my @err = getpart("verify", "errorcode");
! 4025: my $errorcode = $err[0] || "0";
! 4026: my $ok="";
! 4027: my $res;
! 4028: chomp $errorcode;
! 4029: if (@validstdout) {
! 4030: # verify redirected stdout
! 4031: my @actual = loadarray($STDOUT);
! 4032:
! 4033: # what parts to cut off from stdout
! 4034: my @stripfile = getpart("verify", "stripfile");
! 4035:
! 4036: foreach my $strip (@stripfile) {
! 4037: chomp $strip;
! 4038: my @newgen;
! 4039: for(@actual) {
! 4040: eval $strip;
! 4041: if($_) {
! 4042: push @newgen, $_;
! 4043: }
! 4044: }
! 4045: # this is to get rid of array entries that vanished (zero
! 4046: # length) because of replacements
! 4047: @actual = @newgen;
! 4048: }
! 4049:
! 4050: # variable-replace in the stdout we have from the test case file
! 4051: @validstdout = fixarray(@validstdout);
! 4052:
! 4053: # get all attributes
! 4054: my %hash = getpartattr("verify", "stdout");
! 4055:
! 4056: # get the mode attribute
! 4057: my $filemode=$hash{'mode'};
! 4058: if($filemode && ($filemode eq "text") && $has_textaware) {
! 4059: # text mode when running on windows: fix line endings
! 4060: map s/\r\n/\n/g, @validstdout;
! 4061: map s/\n/\r\n/g, @validstdout;
! 4062: }
! 4063:
! 4064: if($hash{'nonewline'}) {
! 4065: # Yes, we must cut off the final newline from the final line
! 4066: # of the protocol data
! 4067: chomp($validstdout[$#validstdout]);
! 4068: }
! 4069:
! 4070: $res = compare($testnum, $testname, "stdout", \@actual, \@validstdout);
! 4071: if($res) {
! 4072: return $errorreturncode;
! 4073: }
! 4074: $ok .= "s";
! 4075: }
! 4076: else {
! 4077: $ok .= "-"; # stdout not checked
! 4078: }
! 4079:
! 4080: if (@validstderr) {
! 4081: # verify redirected stderr
! 4082: my @actual = loadarray($STDERR);
! 4083:
! 4084: # what parts to cut off from stderr
! 4085: my @stripfile = getpart("verify", "stripfile");
! 4086:
! 4087: foreach my $strip (@stripfile) {
! 4088: chomp $strip;
! 4089: my @newgen;
! 4090: for(@actual) {
! 4091: eval $strip;
! 4092: if($_) {
! 4093: push @newgen, $_;
! 4094: }
! 4095: }
! 4096: # this is to get rid of array entries that vanished (zero
! 4097: # length) because of replacements
! 4098: @actual = @newgen;
! 4099: }
! 4100:
! 4101: # variable-replace in the stderr we have from the test case file
! 4102: @validstderr = fixarray(@validstderr);
! 4103:
! 4104: # get all attributes
! 4105: my %hash = getpartattr("verify", "stderr");
! 4106:
! 4107: # get the mode attribute
! 4108: my $filemode=$hash{'mode'};
! 4109: if($filemode && ($filemode eq "text") && $has_textaware) {
! 4110: # text mode when running on windows: fix line endings
! 4111: map s/\r\n/\n/g, @validstderr;
! 4112: map s/\n/\r\n/g, @validstderr;
! 4113: }
! 4114:
! 4115: if($hash{'nonewline'}) {
! 4116: # Yes, we must cut off the final newline from the final line
! 4117: # of the protocol data
! 4118: chomp($validstderr[$#validstderr]);
! 4119: }
! 4120:
! 4121: $res = compare($testnum, $testname, "stderr", \@actual, \@validstderr);
! 4122: if($res) {
! 4123: return $errorreturncode;
! 4124: }
! 4125: $ok .= "r";
! 4126: }
! 4127: else {
! 4128: $ok .= "-"; # stderr not checked
! 4129: }
! 4130:
! 4131: if(@protocol) {
! 4132: # Verify the sent request
! 4133: my @out = loadarray($SERVERIN);
! 4134:
! 4135: # what to cut off from the live protocol sent by curl
! 4136: my @strip = getpart("verify", "strip");
! 4137:
! 4138: my @protstrip=@protocol;
! 4139:
! 4140: # check if there's any attributes on the verify/protocol section
! 4141: my %hash = getpartattr("verify", "protocol");
! 4142:
! 4143: if($hash{'nonewline'}) {
! 4144: # Yes, we must cut off the final newline from the final line
! 4145: # of the protocol data
! 4146: chomp($protstrip[$#protstrip]);
! 4147: }
! 4148:
! 4149: for(@strip) {
! 4150: # strip off all lines that match the patterns from both arrays
! 4151: chomp $_;
! 4152: @out = striparray( $_, \@out);
! 4153: @protstrip= striparray( $_, \@protstrip);
! 4154: }
! 4155:
! 4156: # what parts to cut off from the protocol
! 4157: my @strippart = getpart("verify", "strippart");
! 4158: my $strip;
! 4159: @strippart = fixarray(@strippart);
! 4160: for $strip (@strippart) {
! 4161: chomp $strip;
! 4162: for(@out) {
! 4163: eval $strip;
! 4164: }
! 4165: }
! 4166:
! 4167: if((!$out[0] || ($out[0] eq "")) && $protstrip[0]) {
! 4168: logmsg "\n $testnum: protocol FAILED!\n".
! 4169: " There was no content at all in the file $SERVERIN.\n".
! 4170: " Server glitch? Total curl failure? Returned: $cmdres\n";
! 4171: return $errorreturncode;
! 4172: }
! 4173:
! 4174: $res = compare($testnum, $testname, "protocol", \@out, \@protstrip);
! 4175: if($res) {
! 4176: return $errorreturncode;
! 4177: }
! 4178:
! 4179: $ok .= "p";
! 4180:
! 4181: }
! 4182: else {
! 4183: $ok .= "-"; # protocol not checked
! 4184: }
! 4185:
! 4186: if(!$replyattr{'nocheck'} && (@reply || $replyattr{'sendzero'})) {
! 4187: # verify the received data
! 4188: my @out = loadarray($CURLOUT);
! 4189: $res = compare($testnum, $testname, "data", \@out, \@reply);
! 4190: if ($res) {
! 4191: return $errorreturncode;
! 4192: }
! 4193: $ok .= "d";
! 4194: }
! 4195: else {
! 4196: $ok .= "-"; # data not checked
! 4197: }
! 4198:
! 4199: if(@upload) {
! 4200: # verify uploaded data
! 4201: my @out = loadarray("$LOGDIR/upload.$testnum");
! 4202:
! 4203: # what parts to cut off from the upload
! 4204: my @strippart = getpart("verify", "strippart");
! 4205: my $strip;
! 4206: for $strip (@strippart) {
! 4207: chomp $strip;
! 4208: for(@out) {
! 4209: eval $strip;
! 4210: }
! 4211: }
! 4212:
! 4213: $res = compare($testnum, $testname, "upload", \@out, \@upload);
! 4214: if ($res) {
! 4215: return $errorreturncode;
! 4216: }
! 4217: $ok .= "u";
! 4218: }
! 4219: else {
! 4220: $ok .= "-"; # upload not checked
! 4221: }
! 4222:
! 4223: if(@proxyprot) {
! 4224: # Verify the sent proxy request
! 4225: my @out = loadarray($PROXYIN);
! 4226:
! 4227: # what to cut off from the live protocol sent by curl, we use the
! 4228: # same rules as for <protocol>
! 4229: my @strip = getpart("verify", "strip");
! 4230:
! 4231: my @protstrip=@proxyprot;
! 4232:
! 4233: # check if there's any attributes on the verify/protocol section
! 4234: my %hash = getpartattr("verify", "proxy");
! 4235:
! 4236: if($hash{'nonewline'}) {
! 4237: # Yes, we must cut off the final newline from the final line
! 4238: # of the protocol data
! 4239: chomp($protstrip[$#protstrip]);
! 4240: }
! 4241:
! 4242: for(@strip) {
! 4243: # strip off all lines that match the patterns from both arrays
! 4244: chomp $_;
! 4245: @out = striparray( $_, \@out);
! 4246: @protstrip= striparray( $_, \@protstrip);
! 4247: }
! 4248:
! 4249: # what parts to cut off from the protocol
! 4250: my @strippart = getpart("verify", "strippart");
! 4251: my $strip;
! 4252: for $strip (@strippart) {
! 4253: chomp $strip;
! 4254: for(@out) {
! 4255: eval $strip;
! 4256: }
! 4257: }
! 4258:
! 4259: $res = compare($testnum, $testname, "proxy", \@out, \@protstrip);
! 4260: if($res) {
! 4261: return $errorreturncode;
! 4262: }
! 4263:
! 4264: $ok .= "P";
! 4265:
! 4266: }
! 4267: else {
! 4268: $ok .= "-"; # protocol not checked
! 4269: }
! 4270:
! 4271: my $outputok;
! 4272: for my $partsuffix (('', '1', '2', '3', '4')) {
! 4273: my @outfile=getpart("verify", "file".$partsuffix);
! 4274: if(@outfile || partexists("verify", "file".$partsuffix) ) {
! 4275: # we're supposed to verify a dynamically generated file!
! 4276: my %hash = getpartattr("verify", "file".$partsuffix);
! 4277:
! 4278: my $filename=$hash{'name'};
! 4279: if(!$filename) {
! 4280: logmsg "ERROR: section verify=>file$partsuffix ".
! 4281: "has no name attribute\n";
! 4282: stopservers($verbose);
! 4283: # timestamp test result verification end
! 4284: $timevrfyend{$testnum} = Time::HiRes::time();
! 4285: return -1;
! 4286: }
! 4287: my @generated=loadarray($filename);
! 4288:
! 4289: # what parts to cut off from the file
! 4290: my @stripfile = getpart("verify", "stripfile".$partsuffix);
! 4291:
! 4292: my $filemode=$hash{'mode'};
! 4293: if($filemode && ($filemode eq "text") && $has_textaware) {
! 4294: # text mode when running on windows: fix line endings
! 4295: map s/\r\n/\n/g, @outfile;
! 4296: map s/\n/\r\n/g, @outfile;
! 4297: }
! 4298:
! 4299: my $strip;
! 4300: for $strip (@stripfile) {
! 4301: chomp $strip;
! 4302: my @newgen;
! 4303: for(@generated) {
! 4304: eval $strip;
! 4305: if($_) {
! 4306: push @newgen, $_;
! 4307: }
! 4308: }
! 4309: # this is to get rid of array entries that vanished (zero
! 4310: # length) because of replacements
! 4311: @generated = @newgen;
! 4312: }
! 4313:
! 4314: @outfile = fixarray(@outfile);
! 4315:
! 4316: $res = compare($testnum, $testname, "output ($filename)",
! 4317: \@generated, \@outfile);
! 4318: if($res) {
! 4319: return $errorreturncode;
! 4320: }
! 4321:
! 4322: $outputok = 1; # output checked
! 4323: }
! 4324: }
! 4325: $ok .= ($outputok) ? "o" : "-"; # output checked or not
! 4326:
! 4327: # accept multiple comma-separated error codes
! 4328: my @splerr = split(/ *, */, $errorcode);
! 4329: my $errok;
! 4330: foreach my $e (@splerr) {
! 4331: if($e == $cmdres) {
! 4332: # a fine error code
! 4333: $errok = 1;
! 4334: last;
! 4335: }
! 4336: }
! 4337:
! 4338: if($errok) {
! 4339: $ok .= "e";
! 4340: }
! 4341: else {
! 4342: if(!$short) {
! 4343: logmsg sprintf("\n%s returned $cmdres, when expecting %s\n",
! 4344: (!$tool)?"curl":$tool, $errorcode);
! 4345: }
! 4346: logmsg " exit FAILED\n";
! 4347: # timestamp test result verification end
! 4348: $timevrfyend{$testnum} = Time::HiRes::time();
! 4349: return $errorreturncode;
! 4350: }
! 4351:
! 4352: if($has_memory_tracking) {
! 4353: if(! -f $memdump) {
! 4354: logmsg "\n** ALERT! memory tracking with no output file?\n"
! 4355: if(!$cmdtype eq "perl");
! 4356: }
! 4357: else {
! 4358: my @memdata=`$memanalyze $memdump`;
! 4359: my $leak=0;
! 4360: for(@memdata) {
! 4361: if($_ ne "") {
! 4362: # well it could be other memory problems as well, but
! 4363: # we call it leak for short here
! 4364: $leak=1;
! 4365: }
! 4366: }
! 4367: if($leak) {
! 4368: logmsg "\n** MEMORY FAILURE\n";
! 4369: logmsg @memdata;
! 4370: # timestamp test result verification end
! 4371: $timevrfyend{$testnum} = Time::HiRes::time();
! 4372: return $errorreturncode;
! 4373: }
! 4374: else {
! 4375: $ok .= "m";
! 4376: }
! 4377: }
! 4378: }
! 4379: else {
! 4380: $ok .= "-"; # memory not checked
! 4381: }
! 4382:
! 4383: if($valgrind) {
! 4384: if($usevalgrind) {
! 4385: unless(opendir(DIR, "$LOGDIR")) {
! 4386: logmsg "ERROR: unable to read $LOGDIR\n";
! 4387: # timestamp test result verification end
! 4388: $timevrfyend{$testnum} = Time::HiRes::time();
! 4389: return $errorreturncode;
! 4390: }
! 4391: my @files = readdir(DIR);
! 4392: closedir(DIR);
! 4393: my $vgfile;
! 4394: foreach my $file (@files) {
! 4395: if($file =~ /^valgrind$testnum(\..*|)$/) {
! 4396: $vgfile = $file;
! 4397: last;
! 4398: }
! 4399: }
! 4400: if(!$vgfile) {
! 4401: logmsg "ERROR: valgrind log file missing for test $testnum\n";
! 4402: # timestamp test result verification end
! 4403: $timevrfyend{$testnum} = Time::HiRes::time();
! 4404: return $errorreturncode;
! 4405: }
! 4406: my @e = valgrindparse("$LOGDIR/$vgfile");
! 4407: if(@e && $e[0]) {
! 4408: if($automakestyle) {
! 4409: logmsg "FAIL: $testnum - $testname - valgrind\n";
! 4410: }
! 4411: else {
! 4412: logmsg " valgrind ERROR ";
! 4413: logmsg @e;
! 4414: }
! 4415: # timestamp test result verification end
! 4416: $timevrfyend{$testnum} = Time::HiRes::time();
! 4417: return $errorreturncode;
! 4418: }
! 4419: $ok .= "v";
! 4420: }
! 4421: else {
! 4422: if($verbose && !$disablevalgrind) {
! 4423: logmsg " valgrind SKIPPED\n";
! 4424: }
! 4425: $ok .= "-"; # skipped
! 4426: }
! 4427: }
! 4428: else {
! 4429: $ok .= "-"; # valgrind not checked
! 4430: }
! 4431: # add 'E' for event-based
! 4432: $ok .= $evbased ? "E" : "-";
! 4433:
! 4434: logmsg "$ok " if(!$short);
! 4435:
! 4436: # timestamp test result verification end
! 4437: $timevrfyend{$testnum} = Time::HiRes::time();
! 4438:
! 4439: my $sofar= time()-$start;
! 4440: my $esttotal = $sofar/$count * $total;
! 4441: my $estleft = $esttotal - $sofar;
! 4442: my $left=sprintf("remaining: %02d:%02d",
! 4443: $estleft/60,
! 4444: $estleft%60);
! 4445: my $took = $timevrfyend{$testnum} - $timeprepini{$testnum};
! 4446: my $duration = sprintf("duration: %02d:%02d",
! 4447: $sofar/60, $sofar%60);
! 4448: if(!$automakestyle) {
! 4449: logmsg sprintf("OK (%-3d out of %-3d, %s, took %.1fs, %s)\n",
! 4450: $count, $total, $left, $took, $duration);
! 4451: }
! 4452: else {
! 4453: logmsg "PASS: $testnum - $testname\n";
! 4454: }
! 4455:
! 4456: if($errorreturncode==2) {
! 4457: logmsg "Warning: test$testnum result is ignored, but passed!\n";
! 4458: }
! 4459:
! 4460: return 0;
! 4461: }
! 4462:
! 4463: #######################################################################
! 4464: # Stop all running test servers
! 4465: #
! 4466: sub stopservers {
! 4467: my $verbose = $_[0];
! 4468: #
! 4469: # kill sockfilter processes for all pingpong servers
! 4470: #
! 4471: killallsockfilters($verbose);
! 4472: #
! 4473: # kill all server pids from %run hash clearing them
! 4474: #
! 4475: my $pidlist;
! 4476: foreach my $server (keys %run) {
! 4477: if($run{$server}) {
! 4478: if($verbose) {
! 4479: my $prev = 0;
! 4480: my $pids = $run{$server};
! 4481: foreach my $pid (split(' ', $pids)) {
! 4482: if($pid != $prev) {
! 4483: logmsg sprintf("* kill pid for %s => %d\n",
! 4484: $server, $pid);
! 4485: $prev = $pid;
! 4486: }
! 4487: }
! 4488: }
! 4489: $pidlist .= "$run{$server} ";
! 4490: $run{$server} = 0;
! 4491: }
! 4492: $runcert{$server} = 0 if($runcert{$server});
! 4493: }
! 4494: killpid($verbose, $pidlist);
! 4495: #
! 4496: # cleanup all server pid files
! 4497: #
! 4498: foreach my $server (keys %serverpidfile) {
! 4499: my $pidfile = $serverpidfile{$server};
! 4500: my $pid = processexists($pidfile);
! 4501: if($pid > 0) {
! 4502: logmsg "Warning: $server server unexpectedly alive\n";
! 4503: killpid($verbose, $pid);
! 4504: }
! 4505: unlink($pidfile) if(-f $pidfile);
! 4506: }
! 4507: }
! 4508:
! 4509: #######################################################################
! 4510: # startservers() starts all the named servers
! 4511: #
! 4512: # Returns: string with error reason or blank for success
! 4513: #
! 4514: sub startservers {
! 4515: my @what = @_;
! 4516: my ($pid, $pid2);
! 4517: for(@what) {
! 4518: my (@whatlist) = split(/\s+/,$_);
! 4519: my $what = lc($whatlist[0]);
! 4520: $what =~ s/[^a-z0-9\/-]//g;
! 4521:
! 4522: my $certfile;
! 4523: if($what =~ /^(ftp|http|imap|pop3|smtp)s((\d*)(-ipv6|-unix|))$/) {
! 4524: $certfile = ($whatlist[1]) ? $whatlist[1] : 'stunnel.pem';
! 4525: }
! 4526:
! 4527: if(($what eq "pop3") ||
! 4528: ($what eq "ftp") ||
! 4529: ($what eq "imap") ||
! 4530: ($what eq "smtp")) {
! 4531: if($torture && $run{$what} &&
! 4532: !responsive_pingpong_server($what, "", $verbose)) {
! 4533: stopserver($what);
! 4534: }
! 4535: if(!$run{$what}) {
! 4536: ($pid, $pid2) = runpingpongserver($what, "", $verbose);
! 4537: if($pid <= 0) {
! 4538: return "failed starting ". uc($what) ." server";
! 4539: }
! 4540: printf ("* pid $what => %d %d\n", $pid, $pid2) if($verbose);
! 4541: $run{$what}="$pid $pid2";
! 4542: }
! 4543: }
! 4544: elsif($what eq "ftp2") {
! 4545: if($torture && $run{'ftp2'} &&
! 4546: !responsive_pingpong_server("ftp", "2", $verbose)) {
! 4547: stopserver('ftp2');
! 4548: }
! 4549: if(!$run{'ftp2'}) {
! 4550: ($pid, $pid2) = runpingpongserver("ftp", "2", $verbose);
! 4551: if($pid <= 0) {
! 4552: return "failed starting FTP2 server";
! 4553: }
! 4554: printf ("* pid ftp2 => %d %d\n", $pid, $pid2) if($verbose);
! 4555: $run{'ftp2'}="$pid $pid2";
! 4556: }
! 4557: }
! 4558: elsif($what eq "ftp-ipv6") {
! 4559: if($torture && $run{'ftp-ipv6'} &&
! 4560: !responsive_pingpong_server("ftp", "", $verbose, "ipv6")) {
! 4561: stopserver('ftp-ipv6');
! 4562: }
! 4563: if(!$run{'ftp-ipv6'}) {
! 4564: ($pid, $pid2) = runpingpongserver("ftp", "", $verbose, "ipv6");
! 4565: if($pid <= 0) {
! 4566: return "failed starting FTP-IPv6 server";
! 4567: }
! 4568: logmsg sprintf("* pid ftp-ipv6 => %d %d\n", $pid,
! 4569: $pid2) if($verbose);
! 4570: $run{'ftp-ipv6'}="$pid $pid2";
! 4571: }
! 4572: }
! 4573: elsif($what eq "gopher") {
! 4574: if($torture && $run{'gopher'} &&
! 4575: !responsive_http_server("gopher", $verbose, 0, $GOPHERPORT)) {
! 4576: stopserver('gopher');
! 4577: }
! 4578: if(!$run{'gopher'}) {
! 4579: ($pid, $pid2, $GOPHERPORT) =
! 4580: runhttpserver("gopher", $verbose, 0);
! 4581: if($pid <= 0) {
! 4582: return "failed starting GOPHER server";
! 4583: }
! 4584: logmsg sprintf ("* pid gopher => %d %d\n", $pid, $pid2)
! 4585: if($verbose);
! 4586: $run{'gopher'}="$pid $pid2";
! 4587: }
! 4588: }
! 4589: elsif($what eq "gopher-ipv6") {
! 4590: if($torture && $run{'gopher-ipv6'} &&
! 4591: !responsive_http_server("gopher", $verbose, "ipv6",
! 4592: $GOPHER6PORT)) {
! 4593: stopserver('gopher-ipv6');
! 4594: }
! 4595: if(!$run{'gopher-ipv6'}) {
! 4596: ($pid, $pid2, $GOPHER6PORT) =
! 4597: runhttpserver("gopher", $verbose, "ipv6");
! 4598: if($pid <= 0) {
! 4599: return "failed starting GOPHER-IPv6 server";
! 4600: }
! 4601: logmsg sprintf("* pid gopher-ipv6 => %d %d\n", $pid,
! 4602: $pid2) if($verbose);
! 4603: $run{'gopher-ipv6'}="$pid $pid2";
! 4604: }
! 4605: }
! 4606: elsif($what eq "http/2") {
! 4607: if(!$run{'http/2'}) {
! 4608: ($pid, $pid2) = runhttp2server($verbose, $HTTP2PORT);
! 4609: if($pid <= 0) {
! 4610: return "failed starting HTTP/2 server";
! 4611: }
! 4612: logmsg sprintf ("* pid http/2 => %d %d\n", $pid, $pid2)
! 4613: if($verbose);
! 4614: $run{'http/2'}="$pid $pid2";
! 4615: }
! 4616: }
! 4617: elsif($what eq "http") {
! 4618: if($torture && $run{'http'} &&
! 4619: !responsive_http_server("http", $verbose, 0, $HTTPPORT)) {
! 4620: stopserver('http');
! 4621: }
! 4622: if(!$run{'http'}) {
! 4623: ($pid, $pid2, $HTTPPORT) =
! 4624: runhttpserver("http", $verbose, 0);
! 4625: if($pid <= 0) {
! 4626: return "failed starting HTTP server";
! 4627: }
! 4628: logmsg sprintf ("* pid http => %d %d\n", $pid, $pid2)
! 4629: if($verbose);
! 4630: $run{'http'}="$pid $pid2";
! 4631: }
! 4632: }
! 4633: elsif($what eq "http-proxy") {
! 4634: if($torture && $run{'http-proxy'} &&
! 4635: !responsive_http_server("http", $verbose, "proxy",
! 4636: $HTTPPROXYPORT)) {
! 4637: stopserver('http-proxy');
! 4638: }
! 4639: if(!$run{'http-proxy'}) {
! 4640: ($pid, $pid2, $HTTPPROXYPORT) =
! 4641: runhttpserver("http", $verbose, "proxy");
! 4642: if($pid <= 0) {
! 4643: return "failed starting HTTP-proxy server";
! 4644: }
! 4645: logmsg sprintf ("* pid http-proxy => %d %d\n", $pid, $pid2)
! 4646: if($verbose);
! 4647: $run{'http-proxy'}="$pid $pid2";
! 4648: }
! 4649: }
! 4650: elsif($what eq "http-ipv6") {
! 4651: if($torture && $run{'http-ipv6'} &&
! 4652: !responsive_http_server("http", $verbose, "ipv6", $HTTP6PORT)) {
! 4653: stopserver('http-ipv6');
! 4654: }
! 4655: if(!$run{'http-ipv6'}) {
! 4656: ($pid, $pid2, $HTTP6PORT) =
! 4657: runhttpserver("http", $verbose, "ipv6");
! 4658: if($pid <= 0) {
! 4659: return "failed starting HTTP-IPv6 server";
! 4660: }
! 4661: logmsg sprintf("* pid http-ipv6 => %d %d\n", $pid, $pid2)
! 4662: if($verbose);
! 4663: $run{'http-ipv6'}="$pid $pid2";
! 4664: }
! 4665: }
! 4666: elsif($what eq "rtsp") {
! 4667: if($torture && $run{'rtsp'} &&
! 4668: !responsive_rtsp_server($verbose)) {
! 4669: stopserver('rtsp');
! 4670: }
! 4671: if(!$run{'rtsp'}) {
! 4672: ($pid, $pid2, $RTSPPORT) = runrtspserver($verbose);
! 4673: if($pid <= 0) {
! 4674: return "failed starting RTSP server";
! 4675: }
! 4676: printf ("* pid rtsp => %d %d\n", $pid, $pid2) if($verbose);
! 4677: $run{'rtsp'}="$pid $pid2";
! 4678: }
! 4679: }
! 4680: elsif($what eq "rtsp-ipv6") {
! 4681: if($torture && $run{'rtsp-ipv6'} &&
! 4682: !responsive_rtsp_server($verbose, "ipv6")) {
! 4683: stopserver('rtsp-ipv6');
! 4684: }
! 4685: if(!$run{'rtsp-ipv6'}) {
! 4686: ($pid, $pid2, $RTSP6PORT) = runrtspserver($verbose, "ipv6");
! 4687: if($pid <= 0) {
! 4688: return "failed starting RTSP-IPv6 server";
! 4689: }
! 4690: logmsg sprintf("* pid rtsp-ipv6 => %d %d\n", $pid, $pid2)
! 4691: if($verbose);
! 4692: $run{'rtsp-ipv6'}="$pid $pid2";
! 4693: }
! 4694: }
! 4695: elsif($what eq "ftps") {
! 4696: if(!$stunnel) {
! 4697: # we can't run ftps tests without stunnel
! 4698: return "no stunnel";
! 4699: }
! 4700: if($runcert{'ftps'} && ($runcert{'ftps'} ne $certfile)) {
! 4701: # stop server when running and using a different cert
! 4702: stopserver('ftps');
! 4703: }
! 4704: if($torture && $run{'ftp'} &&
! 4705: !responsive_pingpong_server("ftp", "", $verbose)) {
! 4706: stopserver('ftp');
! 4707: }
! 4708: if(!$run{'ftp'}) {
! 4709: ($pid, $pid2) = runpingpongserver("ftp", "", $verbose);
! 4710: if($pid <= 0) {
! 4711: return "failed starting FTP server";
! 4712: }
! 4713: printf ("* pid ftp => %d %d\n", $pid, $pid2) if($verbose);
! 4714: $run{'ftp'}="$pid $pid2";
! 4715: }
! 4716: if(!$run{'ftps'}) {
! 4717: ($pid, $pid2) = runftpsserver($verbose, "", $certfile);
! 4718: if($pid <= 0) {
! 4719: return "failed starting FTPS server (stunnel)";
! 4720: }
! 4721: logmsg sprintf("* pid ftps => %d %d\n", $pid, $pid2)
! 4722: if($verbose);
! 4723: $run{'ftps'}="$pid $pid2";
! 4724: }
! 4725: }
! 4726: elsif($what eq "file") {
! 4727: # we support it but have no server!
! 4728: }
! 4729: elsif($what eq "https") {
! 4730: if(!$stunnel) {
! 4731: # we can't run https tests without stunnel
! 4732: return "no stunnel";
! 4733: }
! 4734: if($runcert{'https'} && ($runcert{'https'} ne $certfile)) {
! 4735: # stop server when running and using a different cert
! 4736: stopserver('https');
! 4737: }
! 4738: if($torture && $run{'http'} &&
! 4739: !responsive_http_server("http", $verbose, 0, $HTTPPORT)) {
! 4740: stopserver('http');
! 4741: }
! 4742: if(!$run{'http'}) {
! 4743: ($pid, $pid2, $HTTPPORT) =
! 4744: runhttpserver("http", $verbose, 0);
! 4745: if($pid <= 0) {
! 4746: return "failed starting HTTP server";
! 4747: }
! 4748: printf ("* pid http => %d %d\n", $pid, $pid2) if($verbose);
! 4749: $run{'http'}="$pid $pid2";
! 4750: }
! 4751: if(!$run{'https'}) {
! 4752: ($pid, $pid2) = runhttpsserver($verbose, "", $certfile);
! 4753: if($pid <= 0) {
! 4754: return "failed starting HTTPS server (stunnel)";
! 4755: }
! 4756: logmsg sprintf("* pid https => %d %d\n", $pid, $pid2)
! 4757: if($verbose);
! 4758: $run{'https'}="$pid $pid2";
! 4759: }
! 4760: }
! 4761: elsif($what eq "httptls") {
! 4762: if(!$httptlssrv) {
! 4763: # for now, we can't run http TLS-EXT tests without gnutls-serv
! 4764: return "no gnutls-serv";
! 4765: }
! 4766: if($torture && $run{'httptls'} &&
! 4767: !responsive_httptls_server($verbose, "IPv4")) {
! 4768: stopserver('httptls');
! 4769: }
! 4770: if(!$run{'httptls'}) {
! 4771: ($pid, $pid2) = runhttptlsserver($verbose, "IPv4");
! 4772: if($pid <= 0) {
! 4773: return "failed starting HTTPTLS server (gnutls-serv)";
! 4774: }
! 4775: logmsg sprintf("* pid httptls => %d %d\n", $pid, $pid2)
! 4776: if($verbose);
! 4777: $run{'httptls'}="$pid $pid2";
! 4778: }
! 4779: }
! 4780: elsif($what eq "httptls-ipv6") {
! 4781: if(!$httptlssrv) {
! 4782: # for now, we can't run http TLS-EXT tests without gnutls-serv
! 4783: return "no gnutls-serv";
! 4784: }
! 4785: if($torture && $run{'httptls-ipv6'} &&
! 4786: !responsive_httptls_server($verbose, "ipv6")) {
! 4787: stopserver('httptls-ipv6');
! 4788: }
! 4789: if(!$run{'httptls-ipv6'}) {
! 4790: ($pid, $pid2) = runhttptlsserver($verbose, "ipv6");
! 4791: if($pid <= 0) {
! 4792: return "failed starting HTTPTLS-IPv6 server (gnutls-serv)";
! 4793: }
! 4794: logmsg sprintf("* pid httptls-ipv6 => %d %d\n", $pid, $pid2)
! 4795: if($verbose);
! 4796: $run{'httptls-ipv6'}="$pid $pid2";
! 4797: }
! 4798: }
! 4799: elsif($what eq "tftp") {
! 4800: if($torture && $run{'tftp'} &&
! 4801: !responsive_tftp_server("", $verbose)) {
! 4802: stopserver('tftp');
! 4803: }
! 4804: if(!$run{'tftp'}) {
! 4805: ($pid, $pid2, $TFTPPORT) =
! 4806: runtftpserver("", $verbose);
! 4807: if($pid <= 0) {
! 4808: return "failed starting TFTP server";
! 4809: }
! 4810: printf ("* pid tftp => %d %d\n", $pid, $pid2) if($verbose);
! 4811: $run{'tftp'}="$pid $pid2";
! 4812: }
! 4813: }
! 4814: elsif($what eq "tftp-ipv6") {
! 4815: if($torture && $run{'tftp-ipv6'} &&
! 4816: !responsive_tftp_server("", $verbose, "ipv6")) {
! 4817: stopserver('tftp-ipv6');
! 4818: }
! 4819: if(!$run{'tftp-ipv6'}) {
! 4820: ($pid, $pid2, $TFTP6PORT) =
! 4821: runtftpserver("", $verbose, "ipv6");
! 4822: if($pid <= 0) {
! 4823: return "failed starting TFTP-IPv6 server";
! 4824: }
! 4825: printf("* pid tftp-ipv6 => %d %d\n", $pid, $pid2) if($verbose);
! 4826: $run{'tftp-ipv6'}="$pid $pid2";
! 4827: }
! 4828: }
! 4829: elsif($what eq "sftp" || $what eq "scp") {
! 4830: if(!$run{'ssh'}) {
! 4831: ($pid, $pid2) = runsshserver("", $verbose);
! 4832: if($pid <= 0) {
! 4833: return "failed starting SSH server";
! 4834: }
! 4835: printf ("* pid ssh => %d %d\n", $pid, $pid2) if($verbose);
! 4836: $run{'ssh'}="$pid $pid2";
! 4837: }
! 4838: }
! 4839: elsif($what eq "socks4" || $what eq "socks5" ) {
! 4840: if(!$run{'socks'}) {
! 4841: ($pid, $pid2, $SOCKSPORT) = runsocksserver("", $verbose);
! 4842: if($pid <= 0) {
! 4843: return "failed starting socks server";
! 4844: }
! 4845: printf ("* pid socks => %d %d\n", $pid, $pid2) if($verbose);
! 4846: $run{'socks'}="$pid $pid2";
! 4847: }
! 4848: }
! 4849: elsif($what eq "mqtt" ) {
! 4850: if(!$run{'mqtt'}) {
! 4851: ($pid, $pid2) = runmqttserver("", $verbose);
! 4852: if($pid <= 0) {
! 4853: return "failed starting mqtt server";
! 4854: }
! 4855: printf ("* pid mqtt => %d %d\n", $pid, $pid2) if($verbose);
! 4856: $run{'mqtt'}="$pid $pid2";
! 4857: }
! 4858: }
! 4859: elsif($what eq "http-unix") {
! 4860: if($torture && $run{'http-unix'} &&
! 4861: !responsive_http_server("http", $verbose, "unix", $HTTPUNIXPATH)) {
! 4862: stopserver('http-unix');
! 4863: }
! 4864: if(!$run{'http-unix'}) {
! 4865: my $unused;
! 4866: ($pid, $pid2, $unused) =
! 4867: runhttpserver("http", $verbose, "unix", $HTTPUNIXPATH);
! 4868: if($pid <= 0) {
! 4869: return "failed starting HTTP-unix server";
! 4870: }
! 4871: logmsg sprintf("* pid http-unix => %d %d\n", $pid, $pid2)
! 4872: if($verbose);
! 4873: $run{'http-unix'}="$pid $pid2";
! 4874: }
! 4875: }
! 4876: elsif($what eq "dict") {
! 4877: if(!$run{'dict'}) {
! 4878: ($pid, $pid2) = rundictserver($verbose, "", $DICTPORT);
! 4879: if($pid <= 0) {
! 4880: return "failed starting DICT server";
! 4881: }
! 4882: logmsg sprintf ("* pid DICT => %d %d\n", $pid, $pid2)
! 4883: if($verbose);
! 4884: $run{'dict'}="$pid $pid2";
! 4885: }
! 4886: }
! 4887: elsif($what eq "smb") {
! 4888: if(!$run{'smb'}) {
! 4889: ($pid, $pid2) = runsmbserver($verbose, "", $SMBPORT);
! 4890: if($pid <= 0) {
! 4891: return "failed starting SMB server";
! 4892: }
! 4893: logmsg sprintf ("* pid SMB => %d %d\n", $pid, $pid2)
! 4894: if($verbose);
! 4895: $run{'dict'}="$pid $pid2";
! 4896: }
! 4897: }
! 4898: elsif($what eq "telnet") {
! 4899: if(!$run{'telnet'}) {
! 4900: ($pid, $pid2) = runnegtelnetserver($verbose,
! 4901: "",
! 4902: $NEGTELNETPORT);
! 4903: if($pid <= 0) {
! 4904: return "failed starting neg TELNET server";
! 4905: }
! 4906: logmsg sprintf ("* pid neg TELNET => %d %d\n", $pid, $pid2)
! 4907: if($verbose);
! 4908: $run{'dict'}="$pid $pid2";
! 4909: }
! 4910: }
! 4911: elsif($what eq "none") {
! 4912: logmsg "* starts no server\n" if ($verbose);
! 4913: }
! 4914: else {
! 4915: warn "we don't support a server for $what";
! 4916: return "no server for $what";
! 4917: }
! 4918: }
! 4919: return 0;
! 4920: }
! 4921:
! 4922: ##############################################################################
! 4923: # This function makes sure the right set of server is running for the
! 4924: # specified test case. This is a useful design when we run single tests as not
! 4925: # all servers need to run then!
! 4926: #
! 4927: # Returns: a string, blank if everything is fine or a reason why it failed
! 4928: #
! 4929: sub serverfortest {
! 4930: my ($testnum)=@_;
! 4931:
! 4932: my @what = getpart("client", "server");
! 4933:
! 4934: if(!$what[0]) {
! 4935: warn "Test case $testnum has no server(s) specified";
! 4936: return "no server specified";
! 4937: }
! 4938:
! 4939: for(my $i = scalar(@what) - 1; $i >= 0; $i--) {
! 4940: my $srvrline = $what[$i];
! 4941: chomp $srvrline if($srvrline);
! 4942: if($srvrline =~ /^(\S+)((\s*)(.*))/) {
! 4943: my $server = "${1}";
! 4944: my $lnrest = "${2}";
! 4945: my $tlsext;
! 4946: if($server =~ /^(httptls)(\+)(ext|srp)(\d*)(-ipv6|)$/) {
! 4947: $server = "${1}${4}${5}";
! 4948: $tlsext = uc("TLS-${3}");
! 4949: }
! 4950: if(! grep /^\Q$server\E$/, @protocols) {
! 4951: if(substr($server,0,5) ne "socks") {
! 4952: if($tlsext) {
! 4953: return "curl lacks $tlsext support";
! 4954: }
! 4955: else {
! 4956: return "curl lacks $server server support";
! 4957: }
! 4958: }
! 4959: }
! 4960: $what[$i] = "$server$lnrest" if($tlsext);
! 4961: }
! 4962: }
! 4963:
! 4964: return &startservers(@what);
! 4965: }
! 4966:
! 4967: #######################################################################
! 4968: # runtimestats displays test-suite run time statistics
! 4969: #
! 4970: sub runtimestats {
! 4971: my $lasttest = $_[0];
! 4972:
! 4973: return if(not $timestats);
! 4974:
! 4975: logmsg "\nTest suite total running time breakdown per task...\n\n";
! 4976:
! 4977: my @timesrvr;
! 4978: my @timeprep;
! 4979: my @timetool;
! 4980: my @timelock;
! 4981: my @timevrfy;
! 4982: my @timetest;
! 4983: my $timesrvrtot = 0.0;
! 4984: my $timepreptot = 0.0;
! 4985: my $timetooltot = 0.0;
! 4986: my $timelocktot = 0.0;
! 4987: my $timevrfytot = 0.0;
! 4988: my $timetesttot = 0.0;
! 4989: my $counter;
! 4990:
! 4991: for my $testnum (1 .. $lasttest) {
! 4992: if($timesrvrini{$testnum}) {
! 4993: $timesrvrtot += $timesrvrend{$testnum} - $timesrvrini{$testnum};
! 4994: $timepreptot +=
! 4995: (($timetoolini{$testnum} - $timeprepini{$testnum}) -
! 4996: ($timesrvrend{$testnum} - $timesrvrini{$testnum}));
! 4997: $timetooltot += $timetoolend{$testnum} - $timetoolini{$testnum};
! 4998: $timelocktot += $timesrvrlog{$testnum} - $timetoolend{$testnum};
! 4999: $timevrfytot += $timevrfyend{$testnum} - $timesrvrlog{$testnum};
! 5000: $timetesttot += $timevrfyend{$testnum} - $timeprepini{$testnum};
! 5001: push @timesrvr, sprintf("%06.3f %04d",
! 5002: $timesrvrend{$testnum} - $timesrvrini{$testnum}, $testnum);
! 5003: push @timeprep, sprintf("%06.3f %04d",
! 5004: ($timetoolini{$testnum} - $timeprepini{$testnum}) -
! 5005: ($timesrvrend{$testnum} - $timesrvrini{$testnum}), $testnum);
! 5006: push @timetool, sprintf("%06.3f %04d",
! 5007: $timetoolend{$testnum} - $timetoolini{$testnum}, $testnum);
! 5008: push @timelock, sprintf("%06.3f %04d",
! 5009: $timesrvrlog{$testnum} - $timetoolend{$testnum}, $testnum);
! 5010: push @timevrfy, sprintf("%06.3f %04d",
! 5011: $timevrfyend{$testnum} - $timesrvrlog{$testnum}, $testnum);
! 5012: push @timetest, sprintf("%06.3f %04d",
! 5013: $timevrfyend{$testnum} - $timeprepini{$testnum}, $testnum);
! 5014: }
! 5015: }
! 5016:
! 5017: {
! 5018: no warnings 'numeric';
! 5019: @timesrvr = sort { $b <=> $a } @timesrvr;
! 5020: @timeprep = sort { $b <=> $a } @timeprep;
! 5021: @timetool = sort { $b <=> $a } @timetool;
! 5022: @timelock = sort { $b <=> $a } @timelock;
! 5023: @timevrfy = sort { $b <=> $a } @timevrfy;
! 5024: @timetest = sort { $b <=> $a } @timetest;
! 5025: }
! 5026:
! 5027: logmsg "Spent ". sprintf("%08.3f ", $timesrvrtot) .
! 5028: "seconds starting and verifying test harness servers.\n";
! 5029: logmsg "Spent ". sprintf("%08.3f ", $timepreptot) .
! 5030: "seconds reading definitions and doing test preparations.\n";
! 5031: logmsg "Spent ". sprintf("%08.3f ", $timetooltot) .
! 5032: "seconds actually running test tools.\n";
! 5033: logmsg "Spent ". sprintf("%08.3f ", $timelocktot) .
! 5034: "seconds awaiting server logs lock removal.\n";
! 5035: logmsg "Spent ". sprintf("%08.3f ", $timevrfytot) .
! 5036: "seconds verifying test results.\n";
! 5037: logmsg "Spent ". sprintf("%08.3f ", $timetesttot) .
! 5038: "seconds doing all of the above.\n";
! 5039:
! 5040: $counter = 25;
! 5041: logmsg "\nTest server starting and verification time per test ".
! 5042: sprintf("(%s)...\n\n", (not $fullstats)?"top $counter":"full");
! 5043: logmsg "-time- test\n";
! 5044: logmsg "------ ----\n";
! 5045: foreach my $txt (@timesrvr) {
! 5046: last if((not $fullstats) && (not $counter--));
! 5047: logmsg "$txt\n";
! 5048: }
! 5049:
! 5050: $counter = 10;
! 5051: logmsg "\nTest definition reading and preparation time per test ".
! 5052: sprintf("(%s)...\n\n", (not $fullstats)?"top $counter":"full");
! 5053: logmsg "-time- test\n";
! 5054: logmsg "------ ----\n";
! 5055: foreach my $txt (@timeprep) {
! 5056: last if((not $fullstats) && (not $counter--));
! 5057: logmsg "$txt\n";
! 5058: }
! 5059:
! 5060: $counter = 25;
! 5061: logmsg "\nTest tool execution time per test ".
! 5062: sprintf("(%s)...\n\n", (not $fullstats)?"top $counter":"full");
! 5063: logmsg "-time- test\n";
! 5064: logmsg "------ ----\n";
! 5065: foreach my $txt (@timetool) {
! 5066: last if((not $fullstats) && (not $counter--));
! 5067: logmsg "$txt\n";
! 5068: }
! 5069:
! 5070: $counter = 15;
! 5071: logmsg "\nTest server logs lock removal time per test ".
! 5072: sprintf("(%s)...\n\n", (not $fullstats)?"top $counter":"full");
! 5073: logmsg "-time- test\n";
! 5074: logmsg "------ ----\n";
! 5075: foreach my $txt (@timelock) {
! 5076: last if((not $fullstats) && (not $counter--));
! 5077: logmsg "$txt\n";
! 5078: }
! 5079:
! 5080: $counter = 10;
! 5081: logmsg "\nTest results verification time per test ".
! 5082: sprintf("(%s)...\n\n", (not $fullstats)?"top $counter":"full");
! 5083: logmsg "-time- test\n";
! 5084: logmsg "------ ----\n";
! 5085: foreach my $txt (@timevrfy) {
! 5086: last if((not $fullstats) && (not $counter--));
! 5087: logmsg "$txt\n";
! 5088: }
! 5089:
! 5090: $counter = 50;
! 5091: logmsg "\nTotal time per test ".
! 5092: sprintf("(%s)...\n\n", (not $fullstats)?"top $counter":"full");
! 5093: logmsg "-time- test\n";
! 5094: logmsg "------ ----\n";
! 5095: foreach my $txt (@timetest) {
! 5096: last if((not $fullstats) && (not $counter--));
! 5097: logmsg "$txt\n";
! 5098: }
! 5099:
! 5100: logmsg "\n";
! 5101: }
! 5102:
! 5103: # globally disabled tests
! 5104: disabledtests("$TESTDIR/DISABLED");
! 5105:
! 5106: # locally disabled tests, ignored by git etc
! 5107: disabledtests("$TESTDIR/DISABLED.local");
! 5108:
! 5109: #######################################################################
! 5110: # Check options to this test program
! 5111: #
! 5112:
! 5113: my $number=0;
! 5114: my $fromnum=-1;
! 5115: my @testthis;
! 5116: while(@ARGV) {
! 5117: if ($ARGV[0] eq "-v") {
! 5118: # verbose output
! 5119: $verbose=1;
! 5120: }
! 5121: elsif($ARGV[0] =~ /^-b(.*)/) {
! 5122: my $portno=$1;
! 5123: if($portno =~ s/(\d+)$//) {
! 5124: $base = int $1;
! 5125: }
! 5126: }
! 5127: elsif ($ARGV[0] eq "-c") {
! 5128: # use this path to curl instead of default
! 5129: $DBGCURL=$CURL="\"$ARGV[1]\"";
! 5130: shift @ARGV;
! 5131: }
! 5132: elsif ($ARGV[0] eq "-vc") {
! 5133: # use this path to a curl used to verify servers
! 5134:
! 5135: # Particularly useful when you introduce a crashing bug somewhere in
! 5136: # the development version as then it won't be able to run any tests
! 5137: # since it can't verify the servers!
! 5138:
! 5139: $VCURL="\"$ARGV[1]\"";
! 5140: shift @ARGV;
! 5141: }
! 5142: elsif ($ARGV[0] eq "-d") {
! 5143: # have the servers display protocol output
! 5144: $debugprotocol=1;
! 5145: }
! 5146: elsif($ARGV[0] eq "-e") {
! 5147: # run the tests cases event based if possible
! 5148: $run_event_based=1;
! 5149: }
! 5150: elsif ($ARGV[0] eq "-g") {
! 5151: # run this test with gdb
! 5152: $gdbthis=1;
! 5153: }
! 5154: elsif ($ARGV[0] eq "-gw") {
! 5155: # run this test with windowed gdb
! 5156: $gdbthis=1;
! 5157: $gdbxwin=1;
! 5158: }
! 5159: elsif($ARGV[0] eq "-s") {
! 5160: # short output
! 5161: $short=1;
! 5162: }
! 5163: elsif($ARGV[0] eq "-am") {
! 5164: # automake-style output
! 5165: $short=1;
! 5166: $automakestyle=1;
! 5167: }
! 5168: elsif($ARGV[0] eq "-n") {
! 5169: # no valgrind
! 5170: undef $valgrind;
! 5171: }
! 5172: elsif ($ARGV[0] eq "-R") {
! 5173: # execute in scrambled order
! 5174: $scrambleorder=1;
! 5175: }
! 5176: elsif($ARGV[0] =~ /^-t(.*)/) {
! 5177: # torture
! 5178: $torture=1;
! 5179: my $xtra = $1;
! 5180:
! 5181: if($xtra =~ s/(\d+)$//) {
! 5182: $tortalloc = $1;
! 5183: }
! 5184: }
! 5185: elsif($ARGV[0] =~ /--shallow=(\d+)/) {
! 5186: # Fail no more than this amount per tests when running
! 5187: # torture.
! 5188: my ($num)=($1);
! 5189: $shallow=$num;
! 5190: }
! 5191: elsif($ARGV[0] =~ /--repeat=(\d+)/) {
! 5192: # Repeat-run the given tests this many times
! 5193: $repeat = $1;
! 5194: }
! 5195: elsif($ARGV[0] =~ /--seed=(\d+)/) {
! 5196: # Set a fixed random seed (used for -R and --shallow)
! 5197: $randseed = $1;
! 5198: }
! 5199: elsif($ARGV[0] eq "-a") {
! 5200: # continue anyway, even if a test fail
! 5201: $anyway=1;
! 5202: }
! 5203: elsif($ARGV[0] eq "-p") {
! 5204: $postmortem=1;
! 5205: }
! 5206: elsif($ARGV[0] eq "-l") {
! 5207: # lists the test case names only
! 5208: $listonly=1;
! 5209: }
! 5210: elsif($ARGV[0] eq "-k") {
! 5211: # keep stdout and stderr files after tests
! 5212: $keepoutfiles=1;
! 5213: }
! 5214: elsif($ARGV[0] eq "-r") {
! 5215: # run time statistics needs Time::HiRes
! 5216: if($Time::HiRes::VERSION) {
! 5217: keys(%timeprepini) = 1000;
! 5218: keys(%timesrvrini) = 1000;
! 5219: keys(%timesrvrend) = 1000;
! 5220: keys(%timetoolini) = 1000;
! 5221: keys(%timetoolend) = 1000;
! 5222: keys(%timesrvrlog) = 1000;
! 5223: keys(%timevrfyend) = 1000;
! 5224: $timestats=1;
! 5225: $fullstats=0;
! 5226: }
! 5227: }
! 5228: elsif($ARGV[0] eq "-rf") {
! 5229: # run time statistics needs Time::HiRes
! 5230: if($Time::HiRes::VERSION) {
! 5231: keys(%timeprepini) = 1000;
! 5232: keys(%timesrvrini) = 1000;
! 5233: keys(%timesrvrend) = 1000;
! 5234: keys(%timetoolini) = 1000;
! 5235: keys(%timetoolend) = 1000;
! 5236: keys(%timesrvrlog) = 1000;
! 5237: keys(%timevrfyend) = 1000;
! 5238: $timestats=1;
! 5239: $fullstats=1;
! 5240: }
! 5241: }
! 5242: elsif(($ARGV[0] eq "-h") || ($ARGV[0] eq "--help")) {
! 5243: # show help text
! 5244: print <<EOHELP
! 5245: Usage: runtests.pl [options] [test selection(s)]
! 5246: -a continue even if a test fails
! 5247: -am automake style output PASS/FAIL: [number] [name]
! 5248: -bN use base port number N for test servers (default $base)
! 5249: -c path use this curl executable
! 5250: -d display server debug info
! 5251: -e event-based execution
! 5252: -g run the test case with gdb
! 5253: -gw run the test case with gdb as a windowed application
! 5254: -h this help text
! 5255: -k keep stdout and stderr files present after tests
! 5256: -l list all test case names/descriptions
! 5257: -n no valgrind
! 5258: -p print log file contents when a test fails
! 5259: -R scrambled order (uses the random seed, see --seed)
! 5260: -r run time statistics
! 5261: -rf full run time statistics
! 5262: -s short output
! 5263: --seed=[num] set the random seed to a fixed number
! 5264: --shallow=[num] randomly makes the torture tests "thinner"
! 5265: -t[N] torture (simulate function failures); N means fail Nth function
! 5266: -v verbose output
! 5267: -vc path use this curl only to verify the existing servers
! 5268: [num] like "5 6 9" or " 5 to 22 " to run those tests only
! 5269: [!num] like "!5 !6 !9" to disable those tests
! 5270: [~num] like "~5 ~6 ~9" to ignore the result of those tests
! 5271: [keyword] like "IPv6" to select only tests containing the key word
! 5272: [!keyword] like "!cookies" to disable any tests containing the key word
! 5273: [~keyword] like "~cookies" to ignore results of tests containing key word
! 5274: EOHELP
! 5275: ;
! 5276: exit;
! 5277: }
! 5278: elsif($ARGV[0] =~ /^(\d+)/) {
! 5279: $number = $1;
! 5280: if($fromnum >= 0) {
! 5281: for my $n ($fromnum .. $number) {
! 5282: if($disabled{$n}) {
! 5283: # skip disabled test cases
! 5284: my $why = "configured as DISABLED";
! 5285: $skipped++;
! 5286: $skipped{$why}++;
! 5287: $teststat[$n]=$why; # store reason for this test case
! 5288: }
! 5289: else {
! 5290: push @testthis, $n;
! 5291: }
! 5292: }
! 5293: $fromnum = -1;
! 5294: }
! 5295: else {
! 5296: push @testthis, $1;
! 5297: }
! 5298: }
! 5299: elsif($ARGV[0] =~ /^to$/i) {
! 5300: $fromnum = $number+1;
! 5301: }
! 5302: elsif($ARGV[0] =~ /^!(\d+)/) {
! 5303: $fromnum = -1;
! 5304: $disabled{$1}=$1;
! 5305: }
! 5306: elsif($ARGV[0] =~ /^~(\d+)/) {
! 5307: $fromnum = -1;
! 5308: $ignored{$1}=$1;
! 5309: }
! 5310: elsif($ARGV[0] =~ /^!(.+)/) {
! 5311: $disabled_keywords{lc($1)}=$1;
! 5312: }
! 5313: elsif($ARGV[0] =~ /^~(.+)/) {
! 5314: $ignored_keywords{lc($1)}=$1;
! 5315: }
! 5316: elsif($ARGV[0] =~ /^([-[{a-zA-Z].*)/) {
! 5317: $enabled_keywords{lc($1)}=$1;
! 5318: }
! 5319: else {
! 5320: print "Unknown option: $ARGV[0]\n";
! 5321: exit;
! 5322: }
! 5323: shift @ARGV;
! 5324: }
! 5325:
! 5326: if(!$randseed) {
! 5327: my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
! 5328: localtime(time);
! 5329: # seed of the month. December 2019 becomes 201912
! 5330: $randseed = ($year+1900)*100 + $mon+1;
! 5331: open(C, "$CURL --version 2>/dev/null|");
! 5332: my @c = <C>;
! 5333: close(C);
! 5334: # use the first line of output and get the md5 out of it
! 5335: my $str = md5($c[0]);
! 5336: $randseed += unpack('S', $str); # unsigned 16 bit value
! 5337: }
! 5338: srand $randseed;
! 5339:
! 5340: if(@testthis && ($testthis[0] ne "")) {
! 5341: $TESTCASES=join(" ", @testthis);
! 5342: }
! 5343:
! 5344: if($valgrind) {
! 5345: # we have found valgrind on the host, use it
! 5346:
! 5347: # verify that we can invoke it fine
! 5348: my $code = runclient("valgrind >/dev/null 2>&1");
! 5349:
! 5350: if(($code>>8) != 1) {
! 5351: #logmsg "Valgrind failure, disable it\n";
! 5352: undef $valgrind;
! 5353: } else {
! 5354:
! 5355: # since valgrind 2.1.x, '--tool' option is mandatory
! 5356: # use it, if it is supported by the version installed on the system
! 5357: runclient("valgrind --help 2>&1 | grep -- --tool > /dev/null 2>&1");
! 5358: if (($? >> 8)==0) {
! 5359: $valgrind_tool="--tool=memcheck";
! 5360: }
! 5361: open(C, "<$CURL");
! 5362: my $l = <C>;
! 5363: if($l =~ /^\#\!/) {
! 5364: # A shell script. This is typically when built with libtool,
! 5365: $valgrind="../libtool --mode=execute $valgrind";
! 5366: }
! 5367: close(C);
! 5368:
! 5369: # valgrind 3 renamed the --logfile option to --log-file!!!
! 5370: my $ver=join(' ', runclientoutput("valgrind --version"));
! 5371: # cut off all but digits and dots
! 5372: $ver =~ s/[^0-9.]//g;
! 5373:
! 5374: if($ver =~ /^(\d+)/) {
! 5375: $ver = $1;
! 5376: if($ver >= 3) {
! 5377: $valgrind_logfile="--log-file";
! 5378: }
! 5379: }
! 5380: }
! 5381: }
! 5382:
! 5383: if ($gdbthis) {
! 5384: # open the executable curl and read the first 4 bytes of it
! 5385: open(CHECK, "<$CURL");
! 5386: my $c;
! 5387: sysread CHECK, $c, 4;
! 5388: close(CHECK);
! 5389: if($c eq "#! /") {
! 5390: # A shell script. This is typically when built with libtool,
! 5391: $libtool = 1;
! 5392: $gdb = "../libtool --mode=execute gdb";
! 5393: }
! 5394: }
! 5395:
! 5396: $minport = $base; # original base port number
! 5397: $HTTPSPORT = $base++; # HTTPS (stunnel) server port
! 5398: $FTPSPORT = $base++; # FTPS (stunnel) server port
! 5399: $SSHPORT = $base++; # SSH (SCP/SFTP) port
! 5400: $HTTPTLSPORT = $base++; # HTTP TLS (non-stunnel) server port
! 5401: $HTTPTLS6PORT = $base++; # HTTP TLS (non-stunnel) IPv6 server port
! 5402: $HTTP2PORT = $base++; # HTTP/2 port
! 5403: $DICTPORT = $base++; # DICT port
! 5404: $SMBPORT = $base++; # SMB port
! 5405: $SMBSPORT = $base++; # SMBS port
! 5406: $NEGTELNETPORT = $base++; # TELNET port with negotiation
! 5407: $HTTPUNIXPATH = "http$$.sock"; # HTTP server Unix domain socket path
! 5408:
! 5409: $maxport = $base-1; # updated base port number
! 5410:
! 5411: #######################################################################
! 5412: # clear and create logging directory:
! 5413: #
! 5414:
! 5415: cleardir($LOGDIR);
! 5416: mkdir($LOGDIR, 0777);
! 5417:
! 5418: #######################################################################
! 5419: # initialize some variables
! 5420: #
! 5421:
! 5422: get_disttests();
! 5423: init_serverpidfile_hash();
! 5424:
! 5425: #######################################################################
! 5426: # Output curl version and host info being tested
! 5427: #
! 5428:
! 5429: if(!$listonly) {
! 5430: checksystem();
! 5431: }
! 5432:
! 5433: #######################################################################
! 5434: # Fetch all disabled tests, if there are any
! 5435: #
! 5436:
! 5437: sub disabledtests {
! 5438: my ($file) = @_;
! 5439:
! 5440: if(open(D, "<$file")) {
! 5441: while(<D>) {
! 5442: if(/^ *\#/) {
! 5443: # allow comments
! 5444: next;
! 5445: }
! 5446: if($_ =~ /(\d+)/) {
! 5447: my ($n) = $1;
! 5448: $disabled{$n}=$n; # disable this test number
! 5449: if(! -f "$srcdir/data/test$n") {
! 5450: print STDERR "WARNING! Non-exiting test $n in DISABLED!\n";
! 5451: # fail hard to make user notice
! 5452: exit 1;
! 5453: }
! 5454: }
! 5455: }
! 5456: close(D);
! 5457: }
! 5458: }
! 5459:
! 5460: #######################################################################
! 5461: # If 'all' tests are requested, find out all test numbers
! 5462: #
! 5463:
! 5464: if ( $TESTCASES eq "all") {
! 5465: # Get all commands and find out their test numbers
! 5466: opendir(DIR, $TESTDIR) || die "can't opendir $TESTDIR: $!";
! 5467: my @cmds = grep { /^test([0-9]+)$/ && -f "$TESTDIR/$_" } readdir(DIR);
! 5468: closedir(DIR);
! 5469:
! 5470: $TESTCASES=""; # start with no test cases
! 5471:
! 5472: # cut off everything but the digits
! 5473: for(@cmds) {
! 5474: $_ =~ s/[a-z\/\.]*//g;
! 5475: }
! 5476: # sort the numbers from low to high
! 5477: foreach my $n (sort { $a <=> $b } @cmds) {
! 5478: if($disabled{$n}) {
! 5479: # skip disabled test cases
! 5480: my $why = "configured as DISABLED";
! 5481: $skipped++;
! 5482: $skipped{$why}++;
! 5483: $teststat[$n]=$why; # store reason for this test case
! 5484: next;
! 5485: }
! 5486: $TESTCASES .= " $n";
! 5487: }
! 5488: }
! 5489: else {
! 5490: my $verified="";
! 5491: map {
! 5492: if (-e "$TESTDIR/test$_") {
! 5493: $verified.="$_ ";
! 5494: }
! 5495: } split(" ", $TESTCASES);
! 5496: if($verified eq "") {
! 5497: print "No existing test cases were specified\n";
! 5498: exit;
! 5499: }
! 5500: $TESTCASES = $verified;
! 5501: }
! 5502: if($repeat) {
! 5503: my $s;
! 5504: for(1 .. $repeat) {
! 5505: $s .= $TESTCASES;
! 5506: }
! 5507: $TESTCASES = $s;
! 5508: }
! 5509:
! 5510: if($scrambleorder) {
! 5511: # scramble the order of the test cases
! 5512: my @rand;
! 5513: while($TESTCASES) {
! 5514: my @all = split(/ +/, $TESTCASES);
! 5515: if(!$all[0]) {
! 5516: # if the first is blank, shift away it
! 5517: shift @all;
! 5518: }
! 5519: my $r = rand @all;
! 5520: push @rand, $all[$r];
! 5521: $all[$r]="";
! 5522: $TESTCASES = join(" ", @all);
! 5523: }
! 5524: $TESTCASES = join(" ", @rand);
! 5525: }
! 5526:
! 5527: # Display the contents of the given file. Line endings are canonicalized
! 5528: # and excessively long files are elided
! 5529: sub displaylogcontent {
! 5530: my ($file)=@_;
! 5531: if(open(SINGLE, "<$file")) {
! 5532: my $linecount = 0;
! 5533: my $truncate;
! 5534: my @tail;
! 5535: while(my $string = <SINGLE>) {
! 5536: $string =~ s/\r\n/\n/g;
! 5537: $string =~ s/[\r\f\032]/\n/g;
! 5538: $string .= "\n" unless ($string =~ /\n$/);
! 5539: $string =~ tr/\n//;
! 5540: for my $line (split("\n", $string)) {
! 5541: $line =~ s/\s*\!$//;
! 5542: if ($truncate) {
! 5543: push @tail, " $line\n";
! 5544: } else {
! 5545: logmsg " $line\n";
! 5546: }
! 5547: $linecount++;
! 5548: $truncate = $linecount > 1000;
! 5549: }
! 5550: }
! 5551: if(@tail) {
! 5552: my $tailshow = 200;
! 5553: my $tailskip = 0;
! 5554: my $tailtotal = scalar @tail;
! 5555: if($tailtotal > $tailshow) {
! 5556: $tailskip = $tailtotal - $tailshow;
! 5557: logmsg "=== File too long: $tailskip lines omitted here\n";
! 5558: }
! 5559: for($tailskip .. $tailtotal-1) {
! 5560: logmsg "$tail[$_]";
! 5561: }
! 5562: }
! 5563: close(SINGLE);
! 5564: }
! 5565: }
! 5566:
! 5567: sub displaylogs {
! 5568: my ($testnum)=@_;
! 5569: opendir(DIR, "$LOGDIR") ||
! 5570: die "can't open dir: $!";
! 5571: my @logs = readdir(DIR);
! 5572: closedir(DIR);
! 5573:
! 5574: logmsg "== Contents of files in the $LOGDIR/ dir after test $testnum\n";
! 5575: foreach my $log (sort @logs) {
! 5576: if($log =~ /\.(\.|)$/) {
! 5577: next; # skip "." and ".."
! 5578: }
! 5579: if($log =~ /^\.nfs/) {
! 5580: next; # skip ".nfs"
! 5581: }
! 5582: if(($log eq "memdump") || ($log eq "core")) {
! 5583: next; # skip "memdump" and "core"
! 5584: }
! 5585: if((-d "$LOGDIR/$log") || (! -s "$LOGDIR/$log")) {
! 5586: next; # skip directory and empty files
! 5587: }
! 5588: if(($log =~ /^stdout\d+/) && ($log !~ /^stdout$testnum/)) {
! 5589: next; # skip stdoutNnn of other tests
! 5590: }
! 5591: if(($log =~ /^stderr\d+/) && ($log !~ /^stderr$testnum/)) {
! 5592: next; # skip stderrNnn of other tests
! 5593: }
! 5594: if(($log =~ /^upload\d+/) && ($log !~ /^upload$testnum/)) {
! 5595: next; # skip uploadNnn of other tests
! 5596: }
! 5597: if(($log =~ /^curl\d+\.out/) && ($log !~ /^curl$testnum\.out/)) {
! 5598: next; # skip curlNnn.out of other tests
! 5599: }
! 5600: if(($log =~ /^test\d+\.txt/) && ($log !~ /^test$testnum\.txt/)) {
! 5601: next; # skip testNnn.txt of other tests
! 5602: }
! 5603: if(($log =~ /^file\d+\.txt/) && ($log !~ /^file$testnum\.txt/)) {
! 5604: next; # skip fileNnn.txt of other tests
! 5605: }
! 5606: if(($log =~ /^netrc\d+/) && ($log !~ /^netrc$testnum/)) {
! 5607: next; # skip netrcNnn of other tests
! 5608: }
! 5609: if(($log =~ /^trace\d+/) && ($log !~ /^trace$testnum/)) {
! 5610: next; # skip traceNnn of other tests
! 5611: }
! 5612: if(($log =~ /^valgrind\d+/) && ($log !~ /^valgrind$testnum(\..*|)$/)) {
! 5613: next; # skip valgrindNnn of other tests
! 5614: }
! 5615: if(($log =~ /^test$testnum$/)) {
! 5616: next; # skip test$testnum since it can be very big
! 5617: }
! 5618: logmsg "=== Start of file $log\n";
! 5619: displaylogcontent("$LOGDIR/$log");
! 5620: logmsg "=== End of file $log\n";
! 5621: }
! 5622: }
! 5623:
! 5624: #######################################################################
! 5625: # Setup Azure Pipelines Test Run (if running in Azure DevOps)
! 5626: #
! 5627:
! 5628: if(azure_check_environment()) {
! 5629: $AZURE_RUN_ID = azure_create_test_run();
! 5630: logmsg "Azure Run ID: $AZURE_RUN_ID\n" if ($verbose);
! 5631: }
! 5632:
! 5633: #######################################################################
! 5634: # The main test-loop
! 5635: #
! 5636:
! 5637: my $failed;
! 5638: my $testnum;
! 5639: my $ok=0;
! 5640: my $ign=0;
! 5641: my $total=0;
! 5642: my $lasttest=0;
! 5643: my @at = split(" ", $TESTCASES);
! 5644: my $count=0;
! 5645:
! 5646: $start = time();
! 5647:
! 5648: foreach $testnum (@at) {
! 5649:
! 5650: $lasttest = $testnum if($testnum > $lasttest);
! 5651: $count++;
! 5652:
! 5653: my $error = singletest($run_event_based, $testnum, $count, scalar(@at));
! 5654:
! 5655: # update test result in CI services
! 5656: if(azure_check_environment() && $AZURE_RUN_ID && $AZURE_RESULT_ID) {
! 5657: $AZURE_RESULT_ID = azure_update_test_result($AZURE_RUN_ID, $AZURE_RESULT_ID, $testnum, $error,
! 5658: $timeprepini{$testnum}, $timevrfyend{$testnum});
! 5659: }
! 5660: elsif(appveyor_check_environment()) {
! 5661: appveyor_update_test_result($testnum, $error, $timeprepini{$testnum}, $timevrfyend{$testnum});
! 5662: }
! 5663:
! 5664: if($error < 0) {
! 5665: # not a test we can run
! 5666: next;
! 5667: }
! 5668:
! 5669: $total++; # number of tests we've run
! 5670:
! 5671: if($error>0) {
! 5672: if($error==2) {
! 5673: # ignored test failures are wrapped in ()
! 5674: $failed.= "($testnum) ";
! 5675: }
! 5676: else {
! 5677: $failed.= "$testnum ";
! 5678: }
! 5679: if($postmortem) {
! 5680: # display all files in log/ in a nice way
! 5681: displaylogs($testnum);
! 5682: }
! 5683: if($error==2) {
! 5684: $ign++; # ignored test result counter
! 5685: }
! 5686: elsif(!$anyway) {
! 5687: # a test failed, abort
! 5688: logmsg "\n - abort tests\n";
! 5689: last;
! 5690: }
! 5691: }
! 5692: elsif(!$error) {
! 5693: $ok++; # successful test counter
! 5694: }
! 5695:
! 5696: # loop for next test
! 5697: }
! 5698:
! 5699: my $sofar = time() - $start;
! 5700:
! 5701: #######################################################################
! 5702: # Finish Azure Pipelines Test Run (if running in Azure DevOps)
! 5703: #
! 5704:
! 5705: if(azure_check_environment() && $AZURE_RUN_ID) {
! 5706: $AZURE_RUN_ID = azure_update_test_run($AZURE_RUN_ID);
! 5707: }
! 5708:
! 5709: # Tests done, stop the servers
! 5710: stopservers($verbose);
! 5711:
! 5712: my $all = $total + $skipped;
! 5713:
! 5714: runtimestats($lasttest);
! 5715:
! 5716: if($total) {
! 5717: logmsg sprintf("TESTDONE: $ok tests out of $total reported OK: %d%%\n",
! 5718: $ok/$total*100);
! 5719:
! 5720: if($ok != $total) {
! 5721: logmsg "TESTFAIL: These test cases failed: $failed\n";
! 5722: }
! 5723: }
! 5724: else {
! 5725: logmsg "TESTFAIL: No tests were performed\n";
! 5726: }
! 5727:
! 5728: if($all) {
! 5729: logmsg "TESTDONE: $all tests were considered during ".
! 5730: sprintf("%.0f", $sofar) ." seconds.\n";
! 5731: }
! 5732:
! 5733: if($skipped && !$short) {
! 5734: my $s=0;
! 5735: logmsg "TESTINFO: $skipped tests were skipped due to these restraints:\n";
! 5736:
! 5737: for(keys %skipped) {
! 5738: my $r = $_;
! 5739: printf "TESTINFO: \"%s\" %d times (", $r, $skipped{$_};
! 5740:
! 5741: # now show all test case numbers that had this reason for being
! 5742: # skipped
! 5743: my $c=0;
! 5744: my $max = 9;
! 5745: for(0 .. scalar @teststat) {
! 5746: my $t = $_;
! 5747: if($teststat[$_] && ($teststat[$_] eq $r)) {
! 5748: if($c < $max) {
! 5749: logmsg ", " if($c);
! 5750: logmsg $_;
! 5751: }
! 5752: $c++;
! 5753: }
! 5754: }
! 5755: if($c > $max) {
! 5756: logmsg " and ".($c-$max)." more";
! 5757: }
! 5758: logmsg ")\n";
! 5759: }
! 5760: }
! 5761:
! 5762: if($total && (($ok+$ign) != $total)) {
! 5763: exit 1;
! 5764: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to runtests.pl CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / tests