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 # we want unbuffered output
 352 $| = 1;
 353
 354 my @tests = @ARGV;
 355
 356 # quick hack to disable rpc validation when using valgrind - its way too slow
 357 unless (defined($ENV{VALGRIND})) {
 358         $ENV{VALIDATE} = "validate";
 359         $ENV{MALLOC_CHECK_} = 2;
 360 }
 361
 362 # make all our python scripts unbuffered
 363 $ENV{PYTHONUNBUFFERED} = 1;
 364
 365 my $bindir = ($opt_bindir or "$builddir/bin");
 366 my $bindir_abs = abs_path($bindir);
 367
 368 # Backwards compatibility:
 369 if (defined($ENV{TEST_LDAP}) and $ENV{TEST_LDAP} eq "yes") {
 370         if (defined($ENV{FEDORA_DS_ROOT})) {
 371                 $ldap = "fedora-ds";
 372         } else {
 373                 $ldap = "openldap";
 374         }
 375 }
 376
 377 my $torture_maxtime = ($ENV{TORTURE_MAXTIME} or 1200);
 378 if ($ldap) {
 379         # LDAP is slow
 380         $torture_maxtime *= 2;
 381 }
 382
 383 $prefix =~ s+//+/+;
 384 $prefix =~ s+/./+/+;
 385 $prefix =~ s+/$++;
 386
 387 die("using an empty prefix isn't allowed") unless $prefix ne "";
 388
 389 #Ensure we have the test prefix around
 390 mkdir($prefix, 0777) unless -d $prefix;
 391
 392 my $prefix_abs = abs_path($prefix);
 393 my $srcdir_abs = abs_path($srcdir);
 394 my $builddir_abs = abs_path($builddir);
 395
 396 die("using an empty absolute prefix isn't allowed") unless $prefix_abs ne "";
 397 die("using '/' as absolute prefix isn't allowed") unless $prefix_abs ne "/";
 398
 399 $ENV{PREFIX} = $prefix;
 400 $ENV{KRB5CCNAME} = "$prefix/krb5ticket";
 401 $ENV{PREFIX_ABS} = $prefix_abs;
 402 $ENV{SRCDIR} = $srcdir;
 403 $ENV{SRCDIR_ABS} = $srcdir_abs;
 404 $ENV{BUILDDIR} = $builddir;
 405 $ENV{BUILDDIR_ABS} = $builddir_abs;
 406 $ENV{EXEEXT} = $exeext;
 407
 408 my $tls_enabled = not $opt_quick;
 409 $ENV{TLS_ENABLED} = ($tls_enabled?"yes":"no");
 410 $ENV{LDB_MODULES_PATH} = "$bindir_abs/modules/ldb";
 411 $ENV{LD_SAMBA_MODULE_PATH} = "$bindir_abs/modules";
 412 sub prefix_pathvar($$)
 413 {
 414         my ($name, $newpath) = @_;
 415         if (defined($ENV{$name})) {
 416                 $ENV{$name} = "$newpath:$ENV{$name}";
 417         } else {
 418                 $ENV{$name} = $newpath;
 419         }
 420 }
 421 prefix_pathvar("PKG_CONFIG_PATH", "$bindir_abs/pkgconfig");
 422 prefix_pathvar("PYTHONPATH", "$bindir_abs/python");
 423
 424 if ($opt_socket_wrapper_keep_pcap) {
 425         # Socket wrapper keep pcap implies socket wrapper pcap
 426         $opt_socket_wrapper_pcap = 1;
 427 }
 428
 429 if ($opt_socket_wrapper_pcap) {
 430         # Socket wrapper pcap implies socket wrapper
 431         $opt_socket_wrapper = 1;
 432 }
 433
 434 my $socket_wrapper_dir;
 435 if ($opt_socket_wrapper) {
 436         $socket_wrapper_dir = SocketWrapper::setup_dir("$prefix/w", $opt_socket_wrapper_pcap);
 437         print "SOCKET_WRAPPER_DIR=$socket_wrapper_dir\n";
 438 } else {
 439          unless ($< == 0) {
 440                  print "WARNING: Not using socket wrapper, but also not running as root. Will not be able to listen on proper ports\n";
 441          }
 442 }
 443
 444 my $target;
 445 my $testenv_default = "none";
 446
 447 if ($opt_target eq "samba4") {
 448         $testenv_default = "member";
 449         require target::Samba4;
 450         $target = new Samba4($bindir, $ldap, "$srcdir/setup", $exeext);
 451 } elsif ($opt_target eq "samba3") {
 452         if ($opt_socket_wrapper and `$bindir/smbd -b | grep SOCKET_WRAPPER` eq "") {
 453                 die("You must include --enable-socket-wrapper when compiling Samba in order to execute 'make test'.  Exiting....");
 454         }
 455         $testenv_default = "member";
 456         require target::Samba3;
 457         $target = new Samba3($bindir);
 458 } elsif ($opt_target eq "win") {
 459         die("Windows tests will not run with socket wrapper enabled.")
 460                 if ($opt_socket_wrapper);
 461         $testenv_default = "dc";
 462         require target::Windows;
 463         $target = new Windows();
 464 } elsif ($opt_target eq "kvm") {
 465         die("Kvm tests will not run with socket wrapper enabled.")
 466                 if ($opt_socket_wrapper);
 467         require target::Kvm;
 468         die("No image specified") unless ($opt_image);
 469         $target = new Kvm($opt_image, undef);
 470 }
 471
 472 #
 473 # Start a Virtual Distributed Ethernet Switch
 474 # Returns the pid of the switch.
 475 #
 476 sub start_vde_switch($)
 477 {
 478         my ($path) = @_;
 479
 480         system("vde_switch --pidfile $path/vde.pid --sock $path/vde.sock --daemon");
 481
 482         open(PID, "$path/vde.pid");
 483         <PID> =~ /([0-9]+)/;
 484         my $pid = $1;
 485         close(PID);
 486
 487         return $pid;
 488 }
 489
 490 # Stop a Virtual Distributed Ethernet Switch
 491 sub stop_vde_switch($)
 492 {
 493         my ($pid) = @_;
 494         kill 9, $pid;
 495 }
 496
 497 sub read_test_regexes($)
 498 {
 499         my ($name) = @_;
 500         my @ret = ();
 501         open(LF, "<$name") or die("unable to read $name: $!");
 502         while (<LF>) {
 503                 chomp;
 504                 next if (/^#/);
 505                 if (/^(.*?)([ \t]+)\#([\t ]*)(.*?)$/) {
 506                         push (@ret, [$1, $4]);
 507                 } else {
 508                         s/^(.*?)([ \t]+)\#([\t ]*)(.*?)$//;
 509                         push (@ret, [$_, undef]);
 510                 }
 511         }
 512         close(LF);
 513         return @ret;
 514 }
 515
 516 foreach (@opt_exclude) {
 517         push (@excludes, read_test_regexes($_));
 518 }
 519
 520 foreach (@opt_include) {
 521         push (@includes, read_test_regexes($_));
 522 }
 523
 524 my $interfaces = join(',', ("127.0.0.6/8",
 525                             "127.0.0.7/8",
 526                             "127.0.0.8/8",
 527                             "127.0.0.9/8",
 528                             "127.0.0.10/8",
 529                             "127.0.0.11/8"));
 530
 531 my $conffile = "$prefix_abs/client/client.conf";
 532 $ENV{SMB_CONF_PATH} = $conffile;
 533
 534 sub write_clientconf($$)
 535 {
 536         my ($conffile, $vars) = @_;
 537
 538         mkdir("$prefix/client", 0777) unless -d "$prefix/client";
 539
 540         if ( -d "$prefix/client/private" ) {
 541                 unlink <$prefix/client/private/*>;
 542         } else {
 543                 mkdir("$prefix/client/private", 0777);
 544         }
 545
 546         if ( -d "$prefix/client/lockdir" ) {
 547                 unlink <$prefix/client/lockdir/*>;
 548         } else {
 549                 mkdir("$prefix/client/lockdir", 0777);
 550         }
 551
 552         if ( -d "$prefix_abs/client/ncalrpcdir" ) {
 553                 unlink <$prefix/client/ncalrpcdir/*>;
 554         } else {
 555                 mkdir("$prefix/client/ncalrpcdir", 0777);
 556         }
 557
 558         open(CF, ">$conffile");
 559         print CF "[global]\n";
 560         if (defined($ENV{VALGRIND})) {
 561                 print CF "\ticonv:native = true\n";
 562         } else {
 563                 print CF "\ticonv:native = false\n";
 564         }
 565         print CF "\tnetbios name = client\n";
 566         if (defined($vars->{DOMAIN})) {
 567                 print CF "\tworkgroup = $vars->{DOMAIN}\n";
 568         }
 569         if (defined($vars->{REALM})) {
 570                 print CF "\trealm = $vars->{REALM}\n";
 571         }
 572         if ($opt_socket_wrapper) {
 573                 print CF "\tinterfaces = $interfaces\n";
 574         }
 575         print CF "
 576         private dir = $prefix_abs/client/private
 577         lock dir = $prefix_abs/client/lockdir
 578         ncalrpc dir = $prefix_abs/client/ncalrpcdir
 579         name resolve order = bcast
 580         panic action = $RealBin/gdb_backtrace \%PID\% \%PROG\%
 581         max xmit = 32K
 582         notify:inotify = false
 583         ldb:nosync = true
 584         system:anonymous = true
 585         client lanman auth = Yes
 586         torture:basedir = $prefix_abs/client
 587 #We don't want to pass our self-tests if the PAC code is wrong
 588         gensec:require_pac = true
 589         modules dir = $ENV{LD_SAMBA_MODULE_PATH}
 590 ";
 591         close(CF);
 592 }
 593
 594 my @todo = ();
 595
 596 my $testsdir = "$srcdir/selftest";
 597
 598 my %required_envs = ();
 599
 600 sub should_run_test($)
 601 {
 602         my $name = shift;
 603         if ($#tests == -1) {
 604                 return 1;
 605         }
 606         for (my $i=0; $i <= $#tests; $i++) {
 607                 if ($name =~ /$tests[$i]/i) {
 608                         return 1;
 609                 }
 610         }
 611         return 0;
 612 }
 613
 614 sub read_testlist($)
 615 {
 616         my ($filename) = @_;
 617
 618         my @ret = ();
 619         open(IN, $filename) or die("Unable to open $filename: $!");
 620
 621         while (<IN>) {
 622                 if ($_ eq "-- TEST --\n") {
 623                         my $name = <IN>;
 624                         $name =~ s/\n//g;
 625                         my $env = <IN>;
 626                         $env =~ s/\n//g;
 627                         my $cmdline = <IN>;
 628                         $cmdline =~ s/\n//g;
 629                         if (should_run_test($name) == 1) {
 630                                 $required_envs{$env} = 1;
 631                                 push (@ret, [$name, $env, $cmdline]);
 632                         }
 633                 } else {
 634                         print;
 635                 }
 636         }
 637         close(IN) or die("Error creating recipe");
 638         return @ret;
 639 }
 640
 641 if ($#testlists == -1) {
 642         die("No testlists specified");
 643 }
 644
 645 $ENV{SELFTEST_PREFIX} = "$prefix_abs";
 646 if ($opt_socket_wrapper) {
 647         $ENV{SELFTEST_INTERFACES} = $interfaces;
 648 } else {
 649         $ENV{SELFTEST_INTERFACES} = "";
 650 }
 651 if ($opt_verbose) {
 652         $ENV{SELFTEST_VERBOSE} = "1";
 653 } else {
 654         $ENV{SELFTEST_VERBOSE} = "";
 655 }
 656 if ($opt_quick) {
 657         $ENV{SELFTEST_QUICK} = "1";
 658 } else {
 659         $ENV{SELFTEST_QUICK} = "";
 660 }
 661 $ENV{SELFTEST_TARGET} = $opt_target;
 662 $ENV{SELFTEST_MAXTIME} = $torture_maxtime;
 663
 664 my @available = ();
 665 foreach my $fn (@testlists) {
 666         foreach (read_testlist($fn)) {
 667                 my $name = $$_[0];
 668                 next if (@includes and not defined(find_in_list(\@includes, $name)));
 669                 push (@available, $_);
 670         }
 671 }
 672
 673 Subunit::testsuite_count($#available+1);
 674 Subunit::report_time(time());
 675
 676 foreach (@available) {
 677         my $name = $$_[0];
 678         my $skipreason = skip($name);
 679         if (defined($skipreason)) {
 680                 Subunit::skip_testsuite($name, $skipreason);
 681         } else {
 682                 push(@todo, $_);
 683         }
 684 }
 685
 686 if ($#todo == -1) {
 687         print STDERR "No tests to run\n";
 688         exit(1);
 689         }
 690
 691 my $suitestotal = $#todo + 1;
 692 my $i = 0;
 693 $| = 1;
 694
 695 my %running_envs = ();
 696
 697 sub get_running_env($)
 698 {
 699         my ($name) = @_;
 700
 701         my $envname = $name;
 702
 703         $envname =~ s/:.*//;
 704
 705         return $running_envs{$envname};
 706 }
 707
 708 my @exported_envvars = (
 709         # domain stuff
 710         "DOMAIN",
 711         "REALM",
 712
 713         # domain controller stuff
 714         "DC_SERVER",
 715         "DC_SERVER_IP",
 716         "DC_NETBIOSNAME",
 717         "DC_NETBIOSALIAS",
 718
 719         # server stuff
 720         "SERVER",
 721         "SERVER_IP",
 722         "NETBIOSNAME",
 723         "NETBIOSALIAS",
 724
 725         # user stuff
 726         "USERNAME",
 727         "PASSWORD",
 728         "DC_USERNAME",
 729         "DC_PASSWORD",
 730
 731         # misc stuff
 732         "KRB5_CONFIG",
 733         "WINBINDD_SOCKET_DIR",
 734         "WINBINDD_PRIV_PIPE_DIR"
 735 );
 736
 737 $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
 738         my $signame = shift;
 739         teardown_env($_) foreach(keys %running_envs);
 740         die("Received signal $signame");
 741 };
 742
 743 sub setup_env($)
 744 {
 745         my ($name) = @_;
 746
 747         my $testenv_vars = undef;
 748
 749         my $envname = $name;
 750         my $option = $name;
 751
 752         $envname =~ s/:.*//;
 753         $option =~ s/^[^:]*//;
 754         $option =~ s/^://;
 755
 756         $option = "client" if $option eq "";
 757
 758         if ($envname eq "none") {
 759                 $testenv_vars = {};
 760         } elsif (defined(get_running_env($envname))) {
 761                 $testenv_vars = get_running_env($envname);
 762                 if (not $target->check_env($testenv_vars)) {
 763                         $testenv_vars = undef;
 764                 }
 765         } else {
 766                 $testenv_vars = $target->setup_env($envname, $prefix);
 767         }
 768
 769         return undef unless defined($testenv_vars);
 770
 771         $running_envs{$envname} = $testenv_vars;
 772
 773         if ($option eq "local") {
 774                 SocketWrapper::set_default_iface($testenv_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
 775                 $ENV{SMB_CONF_PATH} = $testenv_vars->{SERVERCONFFILE};
 776         } elsif ($option eq "client") {
 777                 SocketWrapper::set_default_iface(6);
 778                 write_clientconf($conffile, $testenv_vars);
 779                 $ENV{SMB_CONF_PATH} = $conffile;
 780         } else {
 781                 die("Unknown option[$option] for envname[$envname]");
 782         }
 783
 784         foreach (@exported_envvars) {
 785                 if (defined($testenv_vars->{$_})) {
 786                         $ENV{$_} = $testenv_vars->{$_};
 787                 } else {
 788                         delete $ENV{$_};
 789                 }
 790         }
 791
 792         return $testenv_vars;
 793 }
 794
 795 sub exported_envvars_str($)
 796 {
 797         my ($testenv_vars) = @_;
 798         my $out = "";
 799
 800         foreach (@exported_envvars) {
 801                 next unless defined($testenv_vars->{$_});
 802                 $out .= $_."=".$testenv_vars->{$_}."\n";
 803         }
 804
 805         return $out;
 806 }
 807
 808 sub getlog_env($)
 809 {
 810         my ($envname) = @_;
 811         return "" if ($envname eq "none");
 812         return $target->getlog_env(get_running_env($envname));
 813 }
 814
 815 sub check_env($)
 816 {
 817         my ($envname) = @_;
 818         return 1 if ($envname eq "none");
 819         return $target->check_env(get_running_env($envname));
 820 }
 821
 822 sub teardown_env($)
 823 {
 824         my ($envname) = @_;
 825         return if ($envname eq "none");
 826         $target->teardown_env(get_running_env($envname));
 827         delete $running_envs{$envname};
 828 }
 829
 830 if ($opt_no_lazy_setup) {
 831         setup_env($_) foreach (keys %required_envs);
 832 }
 833
 834 if ($opt_testenv) {
 835         my $testenv_name = $ENV{SELFTEST_TESTENV};
 836         $testenv_name = $testenv_default unless defined($testenv_name);
 837
 838         my $testenv_vars = setup_env($testenv_name);
 839
 840         $ENV{PIDDIR} = $testenv_vars->{PIDDIR};
 841
 842         my $envvarstr = exported_envvars_str($testenv_vars);
 843
 844         my $term = ($ENV{TERMINAL} or "xterm");
 845         system("$term -e 'echo -e \"
 846 Welcome to the Samba4 Test environment '$testenv_name'
 847
 848 This matches the client environment used in make test
 849 server is pid `cat \$PIDDIR/samba.pid`
 850
 851 Some useful environment variables:
 852 TORTURE_OPTIONS=\$TORTURE_OPTIONS
 853 SMB_CONF_PATH=\$SMB_CONF_PATH
 854
 855 $envvarstr
 856 \" && LD_LIBRARY_PATH=$ENV{LD_LIBRARY_PATH} bash'");
 857         teardown_env($testenv_name);
 858 } else {
 859         foreach (@todo) {
 860                 $i++;
 861                 my $cmd = $$_[2];
 862                 $cmd =~ s/([\(\)])/\\$1/g;
 863                 my $name = $$_[0];
 864                 my $envname = $$_[1];
 865
 866                 my $envvars = setup_env($envname);
 867                 if (not defined($envvars)) {
 868                         Subunit::skip_testsuite($name,
 869                                 "unable to set up environment $envname");
 870                         next;
 871                 }
 872
 873                 run_testsuite($envname, $name, $cmd, $i, $suitestotal);
 874
 875                 if (defined($opt_analyse_cmd)) {
 876                         system("$opt_analyse_cmd \"$name\"");
 877                 }
 878
 879                 teardown_env($envname) if ($opt_resetup_env);
 880         }
 881 }
 882
 883 print "\n";
 884
 885 teardown_env($_) foreach (keys %running_envs);
 886
 887 $target->stop();
 888
 889 my $failed = 0;
 890
 891 # if there were any valgrind failures, show them
 892 foreach (<$prefix/valgrind.log*>) {
 893         next unless (-s $_);
 894         print "VALGRIND FAILURE\n";
 895         $failed++;
 896         system("cat $_");
 897 }
 898 exit 0;