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 SocketWrapper;
 134
 135 my $opt_help = 0;
 136 my $opt_target = "samba4";
 137 my $opt_quick = 0;
 138 my $opt_socket_wrapper = 0;
 139 my $opt_socket_wrapper_pcap = undef;
 140 my $opt_socket_wrapper_keep_pcap = undef;
 141 my $opt_one = 0;
 142 my @opt_exclude = ();
 143 my @opt_include = ();
 144 my $opt_verbose = 0;
 145 my $opt_image = undef;
 146 my $opt_testenv = 0;
 147 my $ldap = undef;
 148 my $opt_analyse_cmd = undef;
 149 my $opt_resetup_env = undef;
 150 my $opt_bindir = undef;
 151 my $opt_no_lazy_setup = undef;
 152 my @testlists = ();
 153
 154 my $srcdir = ".";
 155 my $builddir = ".";
 156 my $exeext = "";
 157 my $prefix = "./st";
 158
 159 my @includes = ();
 160 my @excludes = ();
 161
 162 sub find_in_list($$)
 163 {
 164         my ($list, $fullname) = @_;
 165
 166         foreach (@$list) {
 167                 if ($fullname =~ /$$_[0]/) {
 168                          return ($$_[1]) if ($$_[1]);
 169                          return "NO REASON SPECIFIED";
 170                 }
 171         }
 172
 173         return undef;
 174 }
 175
 176 sub skip($)
 177 {
 178         my ($name) = @_;
 179
 180         return find_in_list(\@excludes, $name);
 181 }
 182
 183 sub getlog_env($);
 184
 185 sub setup_pcap($)
 186 {
 187         my ($name) = @_;
 188
 189         return unless ($opt_socket_wrapper_pcap);
 190         return unless defined($ENV{SOCKET_WRAPPER_PCAP_DIR});
 191
 192         my $fname = $name;
 193         $fname =~ s%[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\-]%_%g;
 194
 195         my $pcap_file = "$ENV{SOCKET_WRAPPER_PCAP_DIR}/$fname.pcap";
 196
 197         SocketWrapper::setup_pcap($pcap_file);
 198
 199         return $pcap_file;
 200 }
 201
 202 sub cleanup_pcap($$)
 203 {
 204         my ($pcap_file, $exitcode) = @_;
 205
 206         return unless ($opt_socket_wrapper_pcap);
 207         return if ($opt_socket_wrapper_keep_pcap);
 208         return unless ($exitcode == 0);
 209         return unless defined($pcap_file);
 210
 211         unlink($pcap_file);
 212 }
 213
 214 sub run_testsuite($$$$$)
 215 {
 216         my ($envname, $name, $cmd, $i, $totalsuites) = @_;
 217         my $pcap_file = setup_pcap($name);
 218
 219         Subunit::report_time(time());
 220         Subunit::start_test($name);
 221
 222         my $ret = system("$cmd 2>&1");
 223         if ($ret == -1) {
 224                 Subunit::end_test($name, "error", "Unable to run $cmd: $!");
 225                 return 0;
 226         }
 227         my $envlog = getlog_env($envname);
 228         if ($envlog ne "") {
 229                 print "ENVLOG: $envlog\n";
 230         }
 231
 232         print "CMD: $cmd\n";
 233
 234         my $exitcode = $ret >> 8;
 235
 236         Subunit::report_time(time());
 237         my $reason = "Exit code was $exitcode";
 238         my $result;
 239         if ($exitcode == 0) {
 240                 $result = "success";
 241         } else {
 242                 $result = "failure";
 243         }
 244         Subunit::end_test($name, $result, $reason);
 245
 246         cleanup_pcap($pcap_file, $exitcode);
 247
 248         if (not $opt_socket_wrapper_keep_pcap and defined($pcap_file)) {
 249                 print "PCAP FILE: $pcap_file\n";
 250         }
 251
 252         if ($exitcode != 0) {
 253                 exit(1) if ($opt_one);
 254         }
 255
 256         return $exitcode;
 257 }
 258
 259 sub ShowHelp()
 260 {
 261         print "Samba test runner
 262 Copyright (C) Jelmer Vernooij <jelmer\@samba.org>
 263 Copyright (C) Stefan Metzmacher <metze\@samba.org>
 264
 265 Usage: $Script [OPTIONS] TESTNAME-REGEX
 266
 267 Generic options:
 268  --help                     this help page
 269  --target=samba[34]|win|kvm Samba version to target
 270  --testlist=FILE            file to read available tests from
 271
 272 Paths:
 273  --prefix=DIR               prefix to run tests in [st]
 274  --srcdir=DIR               source directory [.]
 275  --builddir=DIR             output directory [.]
 276  --exeext=EXT               executable extention []
 277
 278 Target Specific:
 279  --socket-wrapper-pcap      save traffic to pcap directories
 280  --socket-wrapper-keep-pcap keep all pcap files, not just those for tests that
 281                             failed
 282  --socket-wrapper           enable socket wrapper
 283  --bindir=PATH              path to target binaries
 284
 285 Samba4 Specific:
 286  --ldap=openldap|fedora-ds  back samba onto specified ldap server
 287
 288 Kvm Specific:
 289  --image=PATH               path to KVM image
 290
 291 Behaviour:
 292  --quick                    run quick overall test
 293  --one                      abort when the first test fails
 294  --verbose                  be verbose
 295  --analyse-cmd CMD          command to run after each test
 296 ";
 297         exit(0);
 298 }
 299
 300 my $result = GetOptions (
 301                 'help|h|?' => \$opt_help,
 302                 'target=s' => \$opt_target,
 303                 'prefix=s' => \$prefix,
 304                 'socket-wrapper' => \$opt_socket_wrapper,
 305                 'socket-wrapper-pcap' => \$opt_socket_wrapper_pcap,
 306                 'socket-wrapper-keep-pcap' => \$opt_socket_wrapper_keep_pcap,
 307                 'quick' => \$opt_quick,
 308                 'one' => \$opt_one,
 309                 'exclude=s' => \@opt_exclude,
 310                 'include=s' => \@opt_include,
 311                 'srcdir=s' => \$srcdir,
 312                 'builddir=s' => \$builddir,
 313                 'exeext=s' => \$exeext,
 314                 'verbose' => \$opt_verbose,
 315                 'testenv' => \$opt_testenv,
 316                 'ldap:s' => \$ldap,
 317                 'analyse-cmd=s' => \$opt_analyse_cmd,
 318                 'no-lazy-setup' => \$opt_no_lazy_setup,
 319                 'resetup-environment' => \$opt_resetup_env,
 320                 'bindir:s' => \$opt_bindir,
 321                 'image=s' => \$opt_image,
 322                 'testlist=s' => \@testlists
 323             );
 324
 325 exit(1) if (not $result);
 326
 327 ShowHelp() if ($opt_help);
 328
 329 my $tests = shift;
 330
 331 # quick hack to disable rpc validation when using valgrind - its way too slow
 332 unless (defined($ENV{VALGRIND})) {
 333         $ENV{VALIDATE} = "validate";
 334         $ENV{MALLOC_CHECK_} = 2;
 335 }
 336
 337 my $bindir = ($opt_bindir or "$builddir/bin");
 338 my $bindir_abs = abs_path($bindir);
 339
 340 # Backwards compatibility:
 341 if (defined($ENV{TEST_LDAP}) and $ENV{TEST_LDAP} eq "yes") {
 342         if (defined($ENV{FEDORA_DS_ROOT})) {
 343                 $ldap = "fedora-ds";
 344         } else {
 345                 $ldap = "openldap";
 346         }
 347 }
 348
 349 my $torture_maxtime = ($ENV{TORTURE_MAXTIME} or 1200);
 350 if ($ldap) {
 351         # LDAP is slow
 352         $torture_maxtime *= 2;
 353 }
 354
 355 $prefix =~ s+//+/+;
 356 $prefix =~ s+/./+/+;
 357 $prefix =~ s+/$++;
 358
 359 die("using an empty prefix isn't allowed") unless $prefix ne "";
 360
 361 #Ensure we have the test prefix around
 362 mkdir($prefix, 0777) unless -d $prefix;
 363
 364 my $prefix_abs = abs_path($prefix);
 365 my $srcdir_abs = abs_path($srcdir);
 366 my $builddir_abs = abs_path($builddir);
 367
 368 die("using an empty absolute prefix isn't allowed") unless $prefix_abs ne "";
 369 die("using '/' as absolute prefix isn't allowed") unless $prefix_abs ne "/";
 370
 371 $ENV{PREFIX} = $prefix;
 372 $ENV{KRB5CCNAME} = "$prefix/krb5ticket";
 373 $ENV{PREFIX_ABS} = $prefix_abs;
 374 $ENV{SRCDIR} = $srcdir;
 375 $ENV{SRCDIR_ABS} = $srcdir_abs;
 376 $ENV{BUILDDIR} = $builddir;
 377 $ENV{BUILDDIR_ABS} = $builddir_abs;
 378 $ENV{EXEEXT} = $exeext;
 379
 380 my $tls_enabled = not $opt_quick;
 381 $ENV{TLS_ENABLED} = ($tls_enabled?"yes":"no");
 382 $ENV{LDB_MODULES_PATH} = "$bindir_abs/modules/ldb";
 383 $ENV{LD_SAMBA_MODULE_PATH} = "$bindir_abs/modules";
 384 sub prefix_pathvar($$)
 385 {
 386         my ($name, $newpath) = @_;
 387         if (defined($ENV{$name})) {
 388                 $ENV{$name} = "$newpath:$ENV{$name}";
 389         } else {
 390                 $ENV{$name} = $newpath;
 391         }
 392 }
 393 prefix_pathvar("PKG_CONFIG_PATH", "$bindir_abs/pkgconfig");
 394 prefix_pathvar("PYTHONPATH", "$bindir_abs/python");
 395
 396 if ($opt_socket_wrapper_keep_pcap) {
 397         # Socket wrapper keep pcap implies socket wrapper pcap
 398         $opt_socket_wrapper_pcap = 1;
 399 }
 400
 401 if ($opt_socket_wrapper_pcap) {
 402         # Socket wrapper pcap implies socket wrapper
 403         $opt_socket_wrapper = 1;
 404 }
 405
 406 my $socket_wrapper_dir;
 407 if ($opt_socket_wrapper) {
 408         $socket_wrapper_dir = SocketWrapper::setup_dir("$prefix/w", $opt_socket_wrapper_pcap);
 409         print "SOCKET_WRAPPER_DIR=$socket_wrapper_dir\n";
 410 } else {
 411          unless ($< == 0) {
 412                  print "WARNING: Not using socket wrapper, but also not running as root. Will not be able to listen on proper ports\n";
 413          }
 414 }
 415
 416 my $target;
 417 my $testenv_default = "none";
 418
 419 if ($opt_target eq "samba4") {
 420         $testenv_default = "member";
 421         require target::Samba4;
 422         $target = new Samba4($bindir, $ldap, "$srcdir/setup", $exeext);
 423 } elsif ($opt_target eq "samba3") {
 424         if ($opt_socket_wrapper and `$bindir/smbd -b | grep SOCKET_WRAPPER` eq "") {
 425                 die("You must include --enable-socket-wrapper when compiling Samba in order to execute 'make test'.  Exiting....");
 426         }
 427         $testenv_default = "member";
 428         require target::Samba3;
 429         $target = new Samba3($bindir);
 430 } elsif ($opt_target eq "win") {
 431         die("Windows tests will not run with socket wrapper enabled.")
 432                 if ($opt_socket_wrapper);
 433         $testenv_default = "dc";
 434         require target::Windows;
 435         $target = new Windows();
 436 } elsif ($opt_target eq "kvm") {
 437         die("Kvm tests will not run with socket wrapper enabled.")
 438                 if ($opt_socket_wrapper);
 439         require target::Kvm;
 440         die("No image specified") unless ($opt_image);
 441         $target = new Kvm($opt_image, undef);
 442 }
 443
 444 #
 445 # Start a Virtual Distributed Ethernet Switch
 446 # Returns the pid of the switch.
 447 #
 448 sub start_vde_switch($)
 449 {
 450         my ($path) = @_;
 451
 452         system("vde_switch --pidfile $path/vde.pid --sock $path/vde.sock --daemon");
 453
 454         open(PID, "$path/vde.pid");
 455         <PID> =~ /([0-9]+)/;
 456         my $pid = $1;
 457         close(PID);
 458
 459         return $pid;
 460 }
 461
 462 # Stop a Virtual Distributed Ethernet Switch
 463 sub stop_vde_switch($)
 464 {
 465         my ($pid) = @_;
 466         kill 9, $pid;
 467 }
 468
 469 sub read_test_regexes($)
 470 {
 471         my ($name) = @_;
 472         my @ret = ();
 473         open(LF, "<$name") or die("unable to read $name: $!");
 474         while (<LF>) {
 475                 chomp;
 476                 next if (/^#/);
 477                 if (/^(.*?)([ \t]+)\#([\t ]*)(.*?)$/) {
 478                         push (@ret, [$1, $4]);
 479                 } else {
 480                         s/^(.*?)([ \t]+)\#([\t ]*)(.*?)$//;
 481                         push (@ret, [$_, undef]);
 482                 }
 483         }
 484         close(LF);
 485         return @ret;
 486 }
 487
 488 foreach (@opt_exclude) {
 489         push (@excludes, read_test_regexes($_));
 490 }
 491
 492 foreach (@opt_include) {
 493         push (@includes, read_test_regexes($_));
 494 }
 495
 496 my $interfaces = join(',', ("127.0.0.6/8",
 497                             "127.0.0.7/8",
 498                             "127.0.0.8/8",
 499                             "127.0.0.9/8",
 500                             "127.0.0.10/8",
 501                             "127.0.0.11/8"));
 502
 503 my $conffile = "$prefix_abs/client/client.conf";
 504 $ENV{SMB_CONF_PATH} = $conffile;
 505
 506 sub write_clientconf($$)
 507 {
 508         my ($conffile, $vars) = @_;
 509
 510         mkdir("$prefix/client", 0777) unless -d "$prefix/client";
 511
 512         if ( -d "$prefix/client/private" ) {
 513                 unlink <$prefix/client/private/*>;
 514         } else {
 515                 mkdir("$prefix/client/private", 0777);
 516         }
 517
 518         if ( -d "$prefix/client/lock" ) {
 519                 unlink <$prefix/client/lockdir/*>;
 520         } else {
 521                 mkdir("$prefix/client/lockdir", 0777);
 522         }
 523
 524         open(CF, ">$conffile");
 525         print CF "[global]\n";
 526         if (defined($ENV{VALGRIND})) {
 527                 print CF "\ticonv:native = true\n";
 528         } else {
 529                 print CF "\ticonv:native = false\n";
 530         }
 531         print CF "\tnetbios name = client\n";
 532         if (defined($vars->{DOMAIN})) {
 533                 print CF "\tworkgroup = $vars->{DOMAIN}\n";
 534         }
 535         if (defined($vars->{REALM})) {
 536                 print CF "\trealm = $vars->{REALM}\n";
 537         }
 538         if ($opt_socket_wrapper) {
 539                 print CF "\tinterfaces = $interfaces\n";
 540         }
 541         print CF "
 542         private dir = $prefix_abs/client/private
 543         lock dir = $prefix_abs/client/lockdir
 544         name resolve order = bcast
 545         panic action = $RealBin/gdb_backtrace \%PID\% \%PROG\%
 546         max xmit = 32K
 547         notify:inotify = false
 548         ldb:nosync = true
 549         system:anonymous = true
 550         client lanman auth = Yes
 551         torture:basedir = $prefix_abs/client
 552 #We don't want to pass our self-tests if the PAC code is wrong
 553         gensec:require_pac = true
 554         modules dir = $ENV{LD_SAMBA_MODULE_PATH}
 555 ";
 556         close(CF);
 557 }
 558
 559 my @todo = ();
 560
 561 my $testsdir = "$srcdir/selftest";
 562
 563 my %required_envs = ();
 564
 565 sub read_testlist($)
 566 {
 567         my ($filename) = @_;
 568
 569         my @ret = ();
 570         open(IN, $filename) or die("Unable to open $filename: $!");
 571
 572         while (<IN>) {
 573                 if ($_ eq "-- TEST --\n") {
 574                         my $name = <IN>;
 575                         $name =~ s/\n//g;
 576                         my $env = <IN>;
 577                         $env =~ s/\n//g;
 578                         my $cmdline = <IN>;
 579                         $cmdline =~ s/\n//g;
 580                         if (not defined($tests) or $name =~ /$tests/) {
 581                                 $required_envs{$env} = 1;
 582                                 push (@ret, [$name, $env, $cmdline]);
 583                         }
 584                 } else {
 585                         print;
 586                 }
 587         }
 588         close(IN) or die("Error creating recipe");
 589         return @ret;
 590 }
 591
 592 if ($#testlists == -1) {
 593         die("No testlists specified");
 594 }
 595
 596 $ENV{SELFTEST_PREFIX} = "$prefix_abs";
 597 if ($opt_socket_wrapper) {
 598         $ENV{SELFTEST_INTERFACES} = $interfaces;
 599 } else {
 600         $ENV{SELFTEST_INTERFACES} = "";
 601 }
 602 if ($opt_verbose) {
 603         $ENV{SELFTEST_VERBOSE} = "1";
 604 } else {
 605         $ENV{SELFTEST_VERBOSE} = "";
 606 }
 607 if ($opt_quick) {
 608         $ENV{SELFTEST_QUICK} = "1";
 609 } else {
 610         $ENV{SELFTEST_QUICK} = "";
 611 }
 612 $ENV{SELFTEST_TARGET} = $opt_target;
 613 $ENV{SELFTEST_MAXTIME} = $torture_maxtime;
 614
 615 my @available = ();
 616 foreach my $fn (@testlists) {
 617         foreach (read_testlist($fn)) {
 618                 my $name = $$_[0];
 619                 next if (@includes and not find_in_list(\@includes, $name));
 620                 push (@available, $_);
 621         }
 622 }
 623
 624 Subunit::report_time(time());
 625
 626 foreach (@available) {
 627         my $name = $$_[0];
 628         my $skipreason = skip($name);
 629         if ($skipreason) {
 630                 Subunit::end_test($name, "skip", $skipreason);
 631         } else {
 632                 push(@todo, $_);
 633         }
 634 }
 635
 636 if ($#todo == -1) {
 637         print STDERR "No tests to run\n";
 638         exit(1);
 639         }
 640
 641 my $suitestotal = $#todo + 1;
 642 my $i = 0;
 643 $| = 1;
 644
 645 my %running_envs = ();
 646
 647 sub get_running_env($)
 648 {
 649         my ($name) = @_;
 650
 651         my $envname = $name;
 652
 653         $envname =~ s/:.*//;
 654
 655         return $running_envs{$envname};
 656 }
 657
 658 my @exported_envvars = (
 659         # domain stuff
 660         "DOMAIN",
 661         "REALM",
 662
 663         # domain controller stuff
 664         "DC_SERVER",
 665         "DC_SERVER_IP",
 666         "DC_NETBIOSNAME",
 667         "DC_NETBIOSALIAS",
 668
 669         # server stuff
 670         "SERVER",
 671         "SERVER_IP",
 672         "NETBIOSNAME",
 673         "NETBIOSALIAS",
 674
 675         # user stuff
 676         "USERNAME",
 677         "PASSWORD",
 678         "DC_USERNAME",
 679         "DC_PASSWORD",
 680
 681         # misc stuff
 682         "KRB5_CONFIG",
 683         "WINBINDD_SOCKET_DIR",
 684         "WINBINDD_PRIV_PIPE_DIR"
 685 );
 686
 687 $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
 688         my $signame = shift;
 689         teardown_env($_) foreach(keys %running_envs);
 690         die("Received signal $signame");
 691 };
 692
 693 sub setup_env($)
 694 {
 695         my ($name) = @_;
 696
 697         my $testenv_vars = undef;
 698
 699         my $envname = $name;
 700         my $option = $name;
 701
 702         $envname =~ s/:.*//;
 703         $option =~ s/^[^:]*//;
 704         $option =~ s/^://;
 705
 706         $option = "client" if $option eq "";
 707
 708         if ($envname eq "none") {
 709                 $testenv_vars = {};
 710         } elsif (defined(get_running_env($envname))) {
 711                 $testenv_vars = get_running_env($envname);
 712                 if (not $target->check_env($testenv_vars)) {
 713                         $testenv_vars = undef;
 714                 }
 715         } else {
 716                 $testenv_vars = $target->setup_env($envname, $prefix);
 717         }
 718
 719         return undef unless defined($testenv_vars);
 720
 721         $running_envs{$envname} = $testenv_vars;
 722
 723         if ($option eq "local") {
 724                 SocketWrapper::set_default_iface($testenv_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
 725                 $ENV{SMB_CONF_PATH} = $testenv_vars->{SERVERCONFFILE};
 726         } elsif ($option eq "client") {
 727                 SocketWrapper::set_default_iface(6);
 728                 write_clientconf($conffile, $testenv_vars);
 729                 $ENV{SMB_CONF_PATH} = $conffile;
 730         } else {
 731                 die("Unknown option[$option] for envname[$envname]");
 732         }
 733
 734         foreach (@exported_envvars) {
 735                 if (defined($testenv_vars->{$_})) {
 736                         $ENV{$_} = $testenv_vars->{$_};
 737                 } else {
 738                         delete $ENV{$_};
 739                 }
 740         }
 741
 742         return $testenv_vars;
 743 }
 744
 745 sub exported_envvars_str($)
 746 {
 747         my ($testenv_vars) = @_;
 748         my $out = "";
 749
 750         foreach (@exported_envvars) {
 751                 next unless defined($testenv_vars->{$_});
 752                 $out .= $_."=".$testenv_vars->{$_}."\n";
 753         }
 754
 755         return $out;
 756 }
 757
 758 sub getlog_env($)
 759 {
 760         my ($envname) = @_;
 761         return "" if ($envname eq "none");
 762         return $target->getlog_env(get_running_env($envname));
 763 }
 764
 765 sub check_env($)
 766 {
 767         my ($envname) = @_;
 768         return 1 if ($envname eq "none");
 769         return $target->check_env(get_running_env($envname));
 770 }
 771
 772 sub teardown_env($)
 773 {
 774         my ($envname) = @_;
 775         return if ($envname eq "none");
 776         $target->teardown_env(get_running_env($envname));
 777         delete $running_envs{$envname};
 778 }
 779
 780 if ($opt_no_lazy_setup) {
 781         setup_env($_) foreach (keys %required_envs);
 782 }
 783
 784 if ($opt_testenv) {
 785         my $testenv_name = $ENV{SELFTEST_TESTENV};
 786         $testenv_name = $testenv_default unless defined($testenv_name);
 787
 788         my $testenv_vars = setup_env($testenv_name);
 789
 790         $ENV{PIDDIR} = $testenv_vars->{PIDDIR};
 791
 792         my $envvarstr = exported_envvars_str($testenv_vars);
 793
 794         my $term = ($ENV{TERM} or "xterm");
 795         system("$term -e 'echo -e \"
 796 Welcome to the Samba4 Test environment '$testenv_name'
 797
 798 This matches the client environment used in make test
 799 server is pid `cat \$PIDDIR/samba.pid`
 800
 801 Some useful environment variables:
 802 TORTURE_OPTIONS=\$TORTURE_OPTIONS
 803 SMB_CONF_PATH=\$SMB_CONF_PATH
 804
 805 $envvarstr
 806 \" && LD_LIBRARY_PATH=$ENV{LD_LIBRARY_PATH} bash'");
 807         teardown_env($testenv_name);
 808 } else {
 809         foreach (@todo) {
 810                 $i++;
 811                 my $cmd = $$_[2];
 812                 $cmd =~ s/([\(\)])/\\$1/g;
 813                 my $name = $$_[0];
 814                 my $envname = $$_[1];
 815
 816                 my $envvars = setup_env($envname);
 817                 if (not defined($envvars)) {
 818                         Subunit::end_test($name, "skip",
 819                                 "unable to set up environment $envname");
 820                         next;
 821                 }
 822
 823                 run_testsuite($envname, $name, $cmd, $i, $suitestotal);
 824
 825                 if (defined($opt_analyse_cmd)) {
 826                         system("$opt_analyse_cmd \"$name\"");
 827                 }
 828
 829                 teardown_env($envname) if ($opt_resetup_env);
 830         }
 831 }
 832
 833 print "\n";
 834
 835 teardown_env($_) foreach (keys %running_envs);
 836
 837 $target->stop();
 838
 839 my $failed = 0;
 840
 841 # if there were any valgrind failures, show them
 842 foreach (<$prefix/valgrind.log*>) {
 843         next unless (-s $_);
 844         system("grep DWARF2.CFI.reader $_ > /dev/null");
 845         if ($? >> 8 == 0) {
 846             print "VALGRIND FAILURE\n";
 847             $failed++;
 848             system("cat $_");
 849         }
 850 }
 851 exit 0;