selftest/selftest.pl

   1 #!/usr/bin/perl
   2 # Bootstrap Samba and run a number of tests against it.
   3 # Copyright (C) 2005-2009 Jelmer Vernooij <jelmer@samba.org>
   4 # Copyright (C) 2007-2009 Stefan Metzmacher <metze@samba.org>
   5
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 3 of the License, or
   9 # (at your option) any later version.
  10
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 =pod
  20
  21 =head1 NAME
  22
  23 selftest - Samba test runner
  24
  25 =head1 SYNOPSIS
  26
  27 selftest --help
  28
  29 selftest [--srcdir=DIR] [--builddir=DIR] [--exeext=EXT][--target=samba4|samba3|win|kvm] [--socket-wrapper] [--quick] [--exclude=FILE] [--include=FILE] [--one] [--prefix=prefix] [--testlist=FILE] [TESTS]
  30
  31 =head1 DESCRIPTION
  32
  33 A simple test runner. TESTS is a regular expression with tests to run.
  34
  35 =head1 OPTIONS
  36
  37 =over 4
  38
  39 =item I<--help>
  40
  41 Show list of available options.
  42
  43 =item I<--srcdir=DIR>
  44
  45 Source directory.
  46
  47 =item I<--builddir=DIR>
  48
  49 Build directory.
  50
  51 =item I<--exeext=EXT>
  52
  53 Executable extention
  54
  55 =item I<--prefix=DIR>
  56
  57 Change directory to run tests in. Default is 'st'.
  58
  59 =item I<--target samba4|samba3|win|kvm>
  60
  61 Specify test target against which to run. Default is 'samba4'.
  62
  63 =item I<--quick>
  64
  65 Run only a limited number of tests. Intended to run in about 30 seconds on
  66 moderately recent systems.
  67
  68 =item I<--socket-wrapper>
  69
  70 Use socket wrapper library for communication with server. Only works
  71 when the server is running locally.
  72
  73 Will prevent TCP and UDP ports being opened on the local host but
  74 (transparently) redirects these calls to use unix domain sockets.
  75
  76 =item I<--exclude>
  77
  78 Specify a file containing a list of tests that should be skipped. Possible
  79 candidates are tests that segfault the server, flip or don't end.
  80
  81 =item I<--include>
  82
  83 Specify a file containing a list of tests that should be run. Same format
  84 as the --exclude flag.
  85
  86 Not includes specified means all tests will be run.
  87
  88 =item I<--one>
  89
  90 Abort as soon as one test fails.
  91
  92 =item I<--testlist>
  93
  94 Load a list of tests from the specified location.
  95
  96 =back
  97
  98 =head1 ENVIRONMENT
  99
 100 =over 4
 101
 102 =item I<SMBD_VALGRIND>
 103
 104 =item I<TORTURE_MAXTIME>
 105
 106 =item I<VALGRIND>
 107
 108 =item I<TLS_ENABLED>
 109
 110 =item I<srcdir>
 111
 112 =back
 113
 114 =head1 LICENSE
 115
 116 selftest is licensed under the GNU General Public License L<http://www.gnu.org/licenses/gpl.html>.
 117
 118 =head1 AUTHOR
 119
 120 Jelmer Vernooij
 121
 122 =cut
 123
 124 use strict;
 125
 126 use FindBin qw($RealBin $Script);
 127 use File::Spec;
 128 use Getopt::Long;
 129 use POSIX;
 130 use Cwd qw(abs_path);
 131 use lib "$RealBin";
 132 use Subunit qw(parse_results);
 133 use Subunit::Filter;
 134 use SocketWrapper;
 135
 136 my $opt_help = 0;
 137 my $opt_target = "samba4";
 138 my $opt_quick = 0;
 139 my $opt_socket_wrapper = 0;
 140 my $opt_socket_wrapper_pcap = undef;
 141 my $opt_socket_wrapper_keep_pcap = undef;
 142 my $opt_one = 0;
 143 my @opt_exclude = ();
 144 my @opt_include = ();
 145 my $opt_verbose = 0;
 146 my $opt_image = undef;
 147 my $opt_testenv = 0;
 148 my $ldap = undef;
 149 my $opt_analyse_cmd = undef;
 150 my $opt_resetup_env = undef;
 151 my $opt_bindir = undef;
 152 my $opt_no_lazy_setup = undef;
 153 my @testlists = ();
 154
 155 my $srcdir = ".";
 156 my $builddir = ".";
 157 my $exeext = "";
 158 my $prefix = "./st";
 159
 160 my @includes = ();
 161 my @excludes = ();
 162
 163 sub find_in_list($$)
 164 {
 165         my ($list, $fullname) = @_;
 166
 167         foreach (@$list) {
 168                 if ($fullname =~ /$$_[0]/) {
 169                          return ($$_[1]) if ($$_[1]);
 170                          return "";
 171                 }
 172         }
 173
 174         return undef;
 175 }
 176
 177 sub skip($)
 178 {
 179         my ($name) = @_;
 180
 181         return find_in_list(\@excludes, $name);
 182 }
 183
 184 sub getlog_env($);
 185
 186 sub setup_pcap($)
 187 {
 188         my ($name) = @_;
 189
 190         return unless ($opt_socket_wrapper_pcap);
 191         return unless defined($ENV{SOCKET_WRAPPER_PCAP_DIR});
 192
 193         my $fname = $name;
 194         $fname =~ s%[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\-]%_%g;
 195
 196         my $pcap_file = "$ENV{SOCKET_WRAPPER_PCAP_DIR}/$fname.pcap";
 197
 198         SocketWrapper::setup_pcap($pcap_file);
 199
 200         return $pcap_file;
 201 }
 202
 203 sub cleanup_pcap($$)
 204 {
 205         my ($pcap_file, $exitcode) = @_;
 206
 207         return unless ($opt_socket_wrapper_pcap);
 208         return if ($opt_socket_wrapper_keep_pcap);
 209         return unless ($exitcode == 0);
 210         return unless defined($pcap_file);
 211
 212         unlink($pcap_file);
 213 }
 214
 215 sub run_testsuite($$$$$)
 216 {
 217         my ($envname, $name, $cmd, $i, $totalsuites) = @_;
 218         my $pcap_file = setup_pcap($name);
 219
 220         Subunit::start_testsuite($name);
 221         Subunit::report_time(time());
 222
 223         open(RESULTS, "$cmd 2>&1|");
 224         my $statistics = {
 225                 TESTS_UNEXPECTED_OK => 0,
 226                 TESTS_EXPECTED_OK => 0,
 227                 TESTS_UNEXPECTED_FAIL => 0,
 228                 TESTS_EXPECTED_FAIL => 0,
 229                 TESTS_ERROR => 0,
 230                 TESTS_SKIP => 0,
 231         };
 232
 233         my $msg_ops = new Subunit::Filter("$name\.", []);
 234
 235         parse_results($msg_ops, $statistics, *RESULTS);
 236
 237         my $ret = 0;
 238
 239         unless (close(RESULTS)) {
 240                 if ($!) {
 241                         Subunit::end_testsuite($name, "error", "Unable to run $cmd: $!");
 242                         return 0;
 243                 } else {
 244                         $ret = $?;
 245                 }
 246         }
 247
 248         if ($ret & 127) {
 249                 Subunit::end_testsuite($name, "error", sprintf("Testsuite died with signal %d, %s coredump", ($ret & 127), ($ret & 128) ? "with": "without"));
 250                 return 0;
 251         }
 252         my $envlog = getlog_env($envname);
 253         if ($envlog ne "") {
 254                 print "envlog: $envlog\n";
 255         }
 256
 257         print "command: $cmd\n";
 258
 259         my $exitcode = $ret >> 8;
 260
 261         Subunit::report_time(time());
 262         if ($exitcode == 0) {
 263                 Subunit::end_testsuite($name, "success");
 264         } else {
 265                 Subunit::end_testsuite($name, "failure", "Exit code was $exitcode");
 266         }
 267
 268         cleanup_pcap($pcap_file, $exitcode);
 269
 270         if (not $opt_socket_wrapper_keep_pcap and defined($pcap_file)) {
 271                 print "PCAP FILE: $pcap_file\n";
 272         }
 273
 274         if ($exitcode != 0) {
 275                 exit(1) if ($opt_one);
 276         }
 277
 278         return $exitcode;
 279 }
 280
 281 sub ShowHelp()
 282 {
 283         print "Samba test runner
 284 Copyright (C) Jelmer Vernooij <jelmer\@samba.org>
 285 Copyright (C) Stefan Metzmacher <metze\@samba.org>
 286
 287 Usage: $Script [OPTIONS] TESTNAME-REGEX
 288
 289 Generic options:
 290  --help                     this help page
 291  --target=samba[34]|win|kvm Samba version to target
 292  --testlist=FILE            file to read available tests from
 293
 294 Paths:
 295  --prefix=DIR               prefix to run tests in [st]
 296  --srcdir=DIR               source directory [.]
 297  --builddir=DIR             output directory [.]
 298  --exeext=EXT               executable extention []
 299
 300 Target Specific:
 301  --socket-wrapper-pcap      save traffic to pcap directories
 302  --socket-wrapper-keep-pcap keep all pcap files, not just those for tests that
 303                             failed
 304  --socket-wrapper           enable socket wrapper
 305  --bindir=PATH              path to target binaries
 306
 307 Samba4 Specific:
 308  --ldap=openldap|fedora-ds  back samba onto specified ldap server
 309
 310 Kvm Specific:
 311  --image=PATH               path to KVM image
 312
 313 Behaviour:
 314  --quick                    run quick overall test
 315  --one                      abort when the first test fails
 316  --verbose                  be verbose
 317  --analyse-cmd CMD          command to run after each test
 318 ";
 319         exit(0);
 320 }
 321
 322 my $result = GetOptions (
 323                 'help|h|?' => \$opt_help,
 324                 'target=s' => \$opt_target,
 325                 'prefix=s' => \$prefix,
 326                 'socket-wrapper' => \$opt_socket_wrapper,
 327                 'socket-wrapper-pcap' => \$opt_socket_wrapper_pcap,
 328                 'socket-wrapper-keep-pcap' => \$opt_socket_wrapper_keep_pcap,
 329                 'quick' => \$opt_quick,
 330                 'one' => \$opt_one,
 331                 'exclude=s' => \@opt_exclude,
 332                 'include=s' => \@opt_include,
 333                 'srcdir=s' => \$srcdir,
 334                 'builddir=s' => \$builddir,
 335                 'exeext=s' => \$exeext,
 336                 'verbose' => \$opt_verbose,
 337                 'testenv' => \$opt_testenv,
 338                 'ldap:s' => \$ldap,
 339                 'analyse-cmd=s' => \$opt_analyse_cmd,
 340                 'no-lazy-setup' => \$opt_no_lazy_setup,
 341                 'resetup-environment' => \$opt_resetup_env,
 342                 'bindir:s' => \$opt_bindir,
 343                 'image=s' => \$opt_image,
 344                 'testlist=s' => \@testlists
 345             );
 346
 347 exit(1) if (not $result);
 348
 349 ShowHelp() if ($opt_help);
 350
 351 my @tests = @ARGV;
 352
 353 # quick hack to disable rpc validation when using valgrind - its way too slow
 354 unless (defined($ENV{VALGRIND})) {
 355         $ENV{VALIDATE} = "validate";
 356         $ENV{MALLOC_CHECK_} = 2;
 357 }
 358
 359 # make all our python scripts unbuffered
 360 $ENV{PYTHONUNBUFFERED} = 1;
 361
 362 my $bindir = ($opt_bindir or "$builddir/bin");
 363 my $bindir_abs = abs_path($bindir);
 364
 365 # Backwards compatibility:
 366 if (defined($ENV{TEST_LDAP}) and $ENV{TEST_LDAP} eq "yes") {
 367         if (defined($ENV{FEDORA_DS_ROOT})) {
 368                 $ldap = "fedora-ds";
 369         } else {
 370                 $ldap = "openldap";
 371         }
 372 }
 373
 374 my $torture_maxtime = ($ENV{TORTURE_MAXTIME} or 1200);
 375 if ($ldap) {
 376         # LDAP is slow
 377         $torture_maxtime *= 2;
 378 }
 379
 380 $prefix =~ s+//+/+;
 381 $prefix =~ s+/./+/+;
 382 $prefix =~ s+/$++;
 383
 384 die("using an empty prefix isn't allowed") unless $prefix ne "";
 385
 386 #Ensure we have the test prefix around
 387 mkdir($prefix, 0777) unless -d $prefix;
 388
 389 my $prefix_abs = abs_path($prefix);
 390 my $srcdir_abs = abs_path($srcdir);
 391 my $builddir_abs = abs_path($builddir);
 392
 393 die("using an empty absolute prefix isn't allowed") unless $prefix_abs ne "";
 394 die("using '/' as absolute prefix isn't allowed") unless $prefix_abs ne "/";
 395
 396 $ENV{PREFIX} = $prefix;
 397 $ENV{KRB5CCNAME} = "$prefix/krb5ticket";
 398 $ENV{PREFIX_ABS} = $prefix_abs;
 399 $ENV{SRCDIR} = $srcdir;
 400 $ENV{SRCDIR_ABS} = $srcdir_abs;
 401 $ENV{BUILDDIR} = $builddir;
 402 $ENV{BUILDDIR_ABS} = $builddir_abs;
 403 $ENV{EXEEXT} = $exeext;
 404
 405 my $tls_enabled = not $opt_quick;
 406 $ENV{TLS_ENABLED} = ($tls_enabled?"yes":"no");
 407 $ENV{LDB_MODULES_PATH} = "$bindir_abs/modules/ldb";
 408 $ENV{LD_SAMBA_MODULE_PATH} = "$bindir_abs/modules";
 409 sub prefix_pathvar($$)
 410 {
 411         my ($name, $newpath) = @_;
 412         if (defined($ENV{$name})) {
 413                 $ENV{$name} = "$newpath:$ENV{$name}";
 414         } else {
 415                 $ENV{$name} = $newpath;
 416         }
 417 }
 418 prefix_pathvar("PKG_CONFIG_PATH", "$bindir_abs/pkgconfig");
 419 prefix_pathvar("PYTHONPATH", "$bindir_abs/python");
 420
 421 if ($opt_socket_wrapper_keep_pcap) {
 422         # Socket wrapper keep pcap implies socket wrapper pcap
 423         $opt_socket_wrapper_pcap = 1;
 424 }
 425
 426 if ($opt_socket_wrapper_pcap) {
 427         # Socket wrapper pcap implies socket wrapper
 428         $opt_socket_wrapper = 1;
 429 }
 430
 431 my $socket_wrapper_dir;
 432 if ($opt_socket_wrapper) {
 433         $socket_wrapper_dir = SocketWrapper::setup_dir("$prefix/w", $opt_socket_wrapper_pcap);
 434         print "SOCKET_WRAPPER_DIR=$socket_wrapper_dir\n";
 435 } else {
 436          unless ($< == 0) {
 437                  print "WARNING: Not using socket wrapper, but also not running as root. Will not be able to listen on proper ports\n";
 438          }
 439 }
 440
 441 my $target;
 442 my $testenv_default = "none";
 443
 444 if ($opt_target eq "samba4") {
 445         $testenv_default = "member";
 446         require target::Samba4;
 447         $target = new Samba4($bindir, $ldap, "$srcdir/setup", $exeext);
 448 } elsif ($opt_target eq "samba3") {
 449         if ($opt_socket_wrapper and `$bindir/smbd -b | grep SOCKET_WRAPPER` eq "") {
 450                 die("You must include --enable-socket-wrapper when compiling Samba in order to execute 'make test'.  Exiting....");
 451         }
 452         $testenv_default = "member";
 453         require target::Samba3;
 454         $target = new Samba3($bindir);
 455 } elsif ($opt_target eq "win") {
 456         die("Windows tests will not run with socket wrapper enabled.")
 457                 if ($opt_socket_wrapper);
 458         $testenv_default = "dc";
 459         require target::Windows;
 460         $target = new Windows();
 461 } elsif ($opt_target eq "kvm") {
 462         die("Kvm tests will not run with socket wrapper enabled.")
 463                 if ($opt_socket_wrapper);
 464         require target::Kvm;
 465         die("No image specified") unless ($opt_image);
 466         $target = new Kvm($opt_image, undef);
 467 }
 468
 469 #
 470 # Start a Virtual Distributed Ethernet Switch
 471 # Returns the pid of the switch.
 472 #
 473 sub start_vde_switch($)
 474 {
 475         my ($path) = @_;
 476
 477         system("vde_switch --pidfile $path/vde.pid --sock $path/vde.sock --daemon");
 478
 479         open(PID, "$path/vde.pid");
 480         <PID> =~ /([0-9]+)/;
 481         my $pid = $1;
 482         close(PID);
 483
 484         return $pid;
 485 }
 486
 487 # Stop a Virtual Distributed Ethernet Switch
 488 sub stop_vde_switch($)
 489 {
 490         my ($pid) = @_;
 491         kill 9, $pid;
 492 }
 493
 494 sub read_test_regexes($)
 495 {
 496         my ($name) = @_;
 497         my @ret = ();
 498         open(LF, "<$name") or die("unable to read $name: $!");
 499         while (<LF>) {
 500                 chomp;
 501                 next if (/^#/);
 502                 if (/^(.*?)([ \t]+)\#([\t ]*)(.*?)$/) {
 503                         push (@ret, [$1, $4]);
 504                 } else {
 505                         s/^(.*?)([ \t]+)\#([\t ]*)(.*?)$//;
 506                         push (@ret, [$_, undef]);
 507                 }
 508         }
 509         close(LF);
 510         return @ret;
 511 }
 512
 513 foreach (@opt_exclude) {
 514         push (@excludes, read_test_regexes($_));
 515 }
 516
 517 foreach (@opt_include) {
 518         push (@includes, read_test_regexes($_));
 519 }
 520
 521 my $interfaces = join(',', ("127.0.0.6/8",
 522                             "127.0.0.7/8",
 523                             "127.0.0.8/8",
 524                             "127.0.0.9/8",
 525                             "127.0.0.10/8",
 526                             "127.0.0.11/8"));
 527
 528 my $conffile = "$prefix_abs/client/client.conf";
 529 $ENV{SMB_CONF_PATH} = $conffile;
 530
 531 sub write_clientconf($$)
 532 {
 533         my ($conffile, $vars) = @_;
 534
 535         mkdir("$prefix/client", 0777) unless -d "$prefix/client";
 536
 537         if ( -d "$prefix/client/private" ) {
 538                 unlink <$prefix/client/private/*>;
 539         } else {
 540                 mkdir("$prefix/client/private", 0777);
 541         }
 542
 543         if ( -d "$prefix/client/lockdir" ) {
 544                 unlink <$prefix/client/lockdir/*>;
 545         } else {
 546                 mkdir("$prefix/client/lockdir", 0777);
 547         }
 548
 549         if ( -d "$prefix_abs/client/ncalrpcdir" ) {
 550                 unlink <$prefix/client/ncalrpcdir/*>;
 551         } else {
 552                 mkdir("$prefix/client/ncalrpcdir", 0777);
 553         }
 554
 555         open(CF, ">$conffile");
 556         print CF "[global]\n";
 557         if (defined($ENV{VALGRIND})) {
 558                 print CF "\ticonv:native = true\n";
 559         } else {
 560                 print CF "\ticonv:native = false\n";
 561         }
 562         print CF "\tnetbios name = client\n";
 563         if (defined($vars->{DOMAIN})) {
 564                 print CF "\tworkgroup = $vars->{DOMAIN}\n";
 565         }
 566         if (defined($vars->{REALM})) {
 567                 print CF "\trealm = $vars->{REALM}\n";
 568         }
 569         if ($opt_socket_wrapper) {
 570                 print CF "\tinterfaces = $interfaces\n";
 571         }
 572         print CF "
 573         private dir = $prefix_abs/client/private
 574         lock dir = $prefix_abs/client/lockdir
 575         ncalrpc dir = $prefix_abs/client/ncalrpcdir
 576         name resolve order = bcast
 577         panic action = $RealBin/gdb_backtrace \%PID\% \%PROG\%
 578         max xmit = 32K
 579         notify:inotify = false
 580         ldb:nosync = true
 581         system:anonymous = true
 582         client lanman auth = Yes
 583         torture:basedir = $prefix_abs/client
 584 #We don't want to pass our self-tests if the PAC code is wrong
 585         gensec:require_pac = true
 586         modules dir = $ENV{LD_SAMBA_MODULE_PATH}
 587 ";
 588         close(CF);
 589 }
 590
 591 my @todo = ();
 592
 593 my $testsdir = "$srcdir/selftest";
 594
 595 my %required_envs = ();
 596
 597 sub should_run_test($)
 598 {
 599         my $name = shift;
 600         if ($#tests == -1) {
 601                 return 1;
 602         }
 603         for (my $i=0; $i <= $#tests; $i++) {
 604                 if ($name =~ /$tests[$i]/i) {
 605                         return 1;
 606                 }
 607         }
 608         return 0;
 609 }
 610
 611 sub read_testlist($)
 612 {
 613         my ($filename) = @_;
 614
 615         my @ret = ();
 616         open(IN, $filename) or die("Unable to open $filename: $!");
 617
 618         while (<IN>) {
 619                 if ($_ eq "-- TEST --\n") {
 620                         my $name = <IN>;
 621                         $name =~ s/\n//g;
 622                         my $env = <IN>;
 623                         $env =~ s/\n//g;
 624                         my $cmdline = <IN>;
 625                         $cmdline =~ s/\n//g;
 626                         if (should_run_test($name) == 1) {
 627                                 $required_envs{$env} = 1;
 628                                 push (@ret, [$name, $env, $cmdline]);
 629                         }
 630                 } else {
 631                         print;
 632                 }
 633         }
 634         close(IN) or die("Error creating recipe");
 635         return @ret;
 636 }
 637
 638 if ($#testlists == -1) {
 639         die("No testlists specified");
 640 }
 641
 642 $ENV{SELFTEST_PREFIX} = "$prefix_abs";
 643 if ($opt_socket_wrapper) {
 644         $ENV{SELFTEST_INTERFACES} = $interfaces;
 645 } else {
 646         $ENV{SELFTEST_INTERFACES} = "";
 647 }
 648 if ($opt_verbose) {
 649         $ENV{SELFTEST_VERBOSE} = "1";
 650 } else {
 651         $ENV{SELFTEST_VERBOSE} = "";
 652 }
 653 if ($opt_quick) {
 654         $ENV{SELFTEST_QUICK} = "1";
 655 } else {
 656         $ENV{SELFTEST_QUICK} = "";
 657 }
 658 $ENV{SELFTEST_TARGET} = $opt_target;
 659 $ENV{SELFTEST_MAXTIME} = $torture_maxtime;
 660
 661 my @available = ();
 662 foreach my $fn (@testlists) {
 663         foreach (read_testlist($fn)) {
 664                 my $name = $$_[0];
 665                 next if (@includes and not defined(find_in_list(\@includes, $name)));
 666                 push (@available, $_);
 667         }
 668 }
 669
 670 Subunit::testsuite_count($#available+1);
 671 Subunit::report_time(time());
 672
 673 foreach (@available) {
 674         my $name = $$_[0];
 675         my $skipreason = skip($name);
 676         if (defined($skipreason)) {
 677                 Subunit::skip_testsuite($name, $skipreason);
 678         } else {
 679                 push(@todo, $_);
 680         }
 681 }
 682
 683 if ($#todo == -1) {
 684         print STDERR "No tests to run\n";
 685         exit(1);
 686         }
 687
 688 my $suitestotal = $#todo + 1;
 689 my $i = 0;
 690 $| = 1;
 691
 692 my %running_envs = ();
 693
 694 sub get_running_env($)
 695 {
 696         my ($name) = @_;
 697
 698         my $envname = $name;
 699
 700         $envname =~ s/:.*//;
 701
 702         return $running_envs{$envname};
 703 }
 704
 705 my @exported_envvars = (
 706         # domain stuff
 707         "DOMAIN",
 708         "REALM",
 709
 710         # domain controller stuff
 711         "DC_SERVER",
 712         "DC_SERVER_IP",
 713         "DC_NETBIOSNAME",
 714         "DC_NETBIOSALIAS",
 715
 716         # server stuff
 717         "SERVER",
 718         "SERVER_IP",
 719         "NETBIOSNAME",
 720         "NETBIOSALIAS",
 721
 722         # user stuff
 723         "USERNAME",
 724         "PASSWORD",
 725         "DC_USERNAME",
 726         "DC_PASSWORD",
 727
 728         # misc stuff
 729         "KRB5_CONFIG",
 730         "WINBINDD_SOCKET_DIR",
 731         "WINBINDD_PRIV_PIPE_DIR"
 732 );
 733
 734 $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
 735         my $signame = shift;
 736         teardown_env($_) foreach(keys %running_envs);
 737         die("Received signal $signame");
 738 };
 739
 740 sub setup_env($)
 741 {
 742         my ($name) = @_;
 743
 744         my $testenv_vars = undef;
 745
 746         my $envname = $name;
 747         my $option = $name;
 748
 749         $envname =~ s/:.*//;
 750         $option =~ s/^[^:]*//;
 751         $option =~ s/^://;
 752
 753         $option = "client" if $option eq "";
 754
 755         if ($envname eq "none") {
 756                 $testenv_vars = {};
 757         } elsif (defined(get_running_env($envname))) {
 758                 $testenv_vars = get_running_env($envname);
 759                 if (not $target->check_env($testenv_vars)) {
 760                         $testenv_vars = undef;
 761                 }
 762         } else {
 763                 $testenv_vars = $target->setup_env($envname, $prefix);
 764         }
 765
 766         return undef unless defined($testenv_vars);
 767
 768         $running_envs{$envname} = $testenv_vars;
 769
 770         if ($option eq "local") {
 771                 SocketWrapper::set_default_iface($testenv_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
 772                 $ENV{SMB_CONF_PATH} = $testenv_vars->{SERVERCONFFILE};
 773         } elsif ($option eq "client") {
 774                 SocketWrapper::set_default_iface(6);
 775                 write_clientconf($conffile, $testenv_vars);
 776                 $ENV{SMB_CONF_PATH} = $conffile;
 777         } else {
 778                 die("Unknown option[$option] for envname[$envname]");
 779         }
 780
 781         foreach (@exported_envvars) {
 782                 if (defined($testenv_vars->{$_})) {
 783                         $ENV{$_} = $testenv_vars->{$_};
 784                 } else {
 785                         delete $ENV{$_};
 786                 }
 787         }
 788
 789         return $testenv_vars;
 790 }
 791
 792 sub exported_envvars_str($)
 793 {
 794         my ($testenv_vars) = @_;
 795         my $out = "";
 796
 797         foreach (@exported_envvars) {
 798                 next unless defined($testenv_vars->{$_});
 799                 $out .= $_."=".$testenv_vars->{$_}."\n";
 800         }
 801
 802         return $out;
 803 }
 804
 805 sub getlog_env($)
 806 {
 807         my ($envname) = @_;
 808         return "" if ($envname eq "none");
 809         return $target->getlog_env(get_running_env($envname));
 810 }
 811
 812 sub check_env($)
 813 {
 814         my ($envname) = @_;
 815         return 1 if ($envname eq "none");
 816         return $target->check_env(get_running_env($envname));
 817 }
 818
 819 sub teardown_env($)
 820 {
 821         my ($envname) = @_;
 822         return if ($envname eq "none");
 823         $target->teardown_env(get_running_env($envname));
 824         delete $running_envs{$envname};
 825 }
 826
 827 if ($opt_no_lazy_setup) {
 828         setup_env($_) foreach (keys %required_envs);
 829 }
 830
 831 if ($opt_testenv) {
 832         my $testenv_name = $ENV{SELFTEST_TESTENV};
 833         $testenv_name = $testenv_default unless defined($testenv_name);
 834
 835         my $testenv_vars = setup_env($testenv_name);
 836
 837         $ENV{PIDDIR} = $testenv_vars->{PIDDIR};
 838
 839         my $envvarstr = exported_envvars_str($testenv_vars);
 840
 841         my $term = ($ENV{TERMINAL} or "xterm");
 842         system("$term -e 'echo -e \"
 843 Welcome to the Samba4 Test environment '$testenv_name'
 844
 845 This matches the client environment used in make test
 846 server is pid `cat \$PIDDIR/samba.pid`
 847
 848 Some useful environment variables:
 849 TORTURE_OPTIONS=\$TORTURE_OPTIONS
 850 SMB_CONF_PATH=\$SMB_CONF_PATH
 851
 852 $envvarstr
 853 \" && LD_LIBRARY_PATH=$ENV{LD_LIBRARY_PATH} bash'");
 854         teardown_env($testenv_name);
 855 } else {
 856         foreach (@todo) {
 857                 $i++;
 858                 my $cmd = $$_[2];
 859                 $cmd =~ s/([\(\)])/\\$1/g;
 860                 my $name = $$_[0];
 861                 my $envname = $$_[1];
 862
 863                 my $envvars = setup_env($envname);
 864                 if (not defined($envvars)) {
 865                         Subunit::skip_testsuite($name,
 866                                 "unable to set up environment $envname");
 867                         next;
 868                 }
 869
 870                 run_testsuite($envname, $name, $cmd, $i, $suitestotal);
 871
 872                 if (defined($opt_analyse_cmd)) {
 873                         system("$opt_analyse_cmd \"$name\"");
 874                 }
 875
 876                 teardown_env($envname) if ($opt_resetup_env);
 877         }
 878 }
 879
 880 print "\n";
 881
 882 teardown_env($_) foreach (keys %running_envs);
 883
 884 $target->stop();
 885
 886 my $failed = 0;
 887
 888 # if there were any valgrind failures, show them
 889 foreach (<$prefix/valgrind.log*>) {
 890         next unless (-s $_);
 891         print "VALGRIND FAILURE\n";
 892         $failed++;
 893         system("cat $_");
 894 }
 895 exit 0;