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