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