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::prefix($name);
 221         Subunit::start_test($name);
 222
 223         my $ret = system("$cmd | $RealBin/filter-subunit.pl --prefix \"$name.\" 2>&1");
 224         if ($ret == -1) {
 225                 Subunit::end_test($name, "error", "Unable to run $cmd: $!");
 226                 return 0;
 227         }
 228         my $envlog = getlog_env($envname);
 229         if ($envlog ne "") {
 230                 print "envlog: $envlog\n";
 231         }
 232
 233         print "command: $cmd\n";
 234
 235         my $exitcode = $ret >> 8;
 236
 237         Subunit::report_time(time());
 238         my $reason = "Exit code was $exitcode";
 239         my $result;
 240         if ($exitcode == 0) {
 241                 $result = "success";
 242         } else {
 243                 $result = "failure";
 244         }
 245         Subunit::end_test($name, $result, $reason);
 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 find_in_list(\@includes, $name));
 621                 push (@available, $_);
 622         }
 623 }
 624
 625 Subunit::report_time(time());
 626
 627 foreach (@available) {
 628         my $name = $$_[0];
 629         my $skipreason = skip($name);
 630         if ($skipreason) {
 631                 Subunit::end_test($name, "skip", $skipreason);
 632         } else {
 633                 push(@todo, $_);
 634         }
 635 }
 636
 637 if ($#todo == -1) {
 638         print STDERR "No tests to run\n";
 639         exit(1);
 640         }
 641
 642 my $suitestotal = $#todo + 1;
 643 my $i = 0;
 644 $| = 1;
 645
 646 my %running_envs = ();
 647
 648 sub get_running_env($)
 649 {
 650         my ($name) = @_;
 651
 652         my $envname = $name;
 653
 654         $envname =~ s/:.*//;
 655
 656         return $running_envs{$envname};
 657 }
 658
 659 my @exported_envvars = (
 660         # domain stuff
 661         "DOMAIN",
 662         "REALM",
 663
 664         # domain controller stuff
 665         "DC_SERVER",
 666         "DC_SERVER_IP",
 667         "DC_NETBIOSNAME",
 668         "DC_NETBIOSALIAS",
 669
 670         # server stuff
 671         "SERVER",
 672         "SERVER_IP",
 673         "NETBIOSNAME",
 674         "NETBIOSALIAS",
 675
 676         # user stuff
 677         "USERNAME",
 678         "PASSWORD",
 679         "DC_USERNAME",
 680         "DC_PASSWORD",
 681
 682         # misc stuff
 683         "KRB5_CONFIG",
 684         "WINBINDD_SOCKET_DIR",
 685         "WINBINDD_PRIV_PIPE_DIR"
 686 );
 687
 688 $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
 689         my $signame = shift;
 690         teardown_env($_) foreach(keys %running_envs);
 691         die("Received signal $signame");
 692 };
 693
 694 sub setup_env($)
 695 {
 696         my ($name) = @_;
 697
 698         my $testenv_vars = undef;
 699
 700         my $envname = $name;
 701         my $option = $name;
 702
 703         $envname =~ s/:.*//;
 704         $option =~ s/^[^:]*//;
 705         $option =~ s/^://;
 706
 707         $option = "client" if $option eq "";
 708
 709         if ($envname eq "none") {
 710                 $testenv_vars = {};
 711         } elsif (defined(get_running_env($envname))) {
 712                 $testenv_vars = get_running_env($envname);
 713                 if (not $target->check_env($testenv_vars)) {
 714                         $testenv_vars = undef;
 715                 }
 716         } else {
 717                 $testenv_vars = $target->setup_env($envname, $prefix);
 718         }
 719
 720         return undef unless defined($testenv_vars);
 721
 722         $running_envs{$envname} = $testenv_vars;
 723
 724         if ($option eq "local") {
 725                 SocketWrapper::set_default_iface($testenv_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
 726                 $ENV{SMB_CONF_PATH} = $testenv_vars->{SERVERCONFFILE};
 727         } elsif ($option eq "client") {
 728                 SocketWrapper::set_default_iface(6);
 729                 write_clientconf($conffile, $testenv_vars);
 730                 $ENV{SMB_CONF_PATH} = $conffile;
 731         } else {
 732                 die("Unknown option[$option] for envname[$envname]");
 733         }
 734
 735         foreach (@exported_envvars) {
 736                 if (defined($testenv_vars->{$_})) {
 737                         $ENV{$_} = $testenv_vars->{$_};
 738                 } else {
 739                         delete $ENV{$_};
 740                 }
 741         }
 742
 743         return $testenv_vars;
 744 }
 745
 746 sub exported_envvars_str($)
 747 {
 748         my ($testenv_vars) = @_;
 749         my $out = "";
 750
 751         foreach (@exported_envvars) {
 752                 next unless defined($testenv_vars->{$_});
 753                 $out .= $_."=".$testenv_vars->{$_}."\n";
 754         }
 755
 756         return $out;
 757 }
 758
 759 sub getlog_env($)
 760 {
 761         my ($envname) = @_;
 762         return "" if ($envname eq "none");
 763         return $target->getlog_env(get_running_env($envname));
 764 }
 765
 766 sub check_env($)
 767 {
 768         my ($envname) = @_;
 769         return 1 if ($envname eq "none");
 770         return $target->check_env(get_running_env($envname));
 771 }
 772
 773 sub teardown_env($)
 774 {
 775         my ($envname) = @_;
 776         return if ($envname eq "none");
 777         $target->teardown_env(get_running_env($envname));
 778         delete $running_envs{$envname};
 779 }
 780
 781 if ($opt_no_lazy_setup) {
 782         setup_env($_) foreach (keys %required_envs);
 783 }
 784
 785 if ($opt_testenv) {
 786         my $testenv_name = $ENV{SELFTEST_TESTENV};
 787         $testenv_name = $testenv_default unless defined($testenv_name);
 788
 789         my $testenv_vars = setup_env($testenv_name);
 790
 791         $ENV{PIDDIR} = $testenv_vars->{PIDDIR};
 792
 793         my $envvarstr = exported_envvars_str($testenv_vars);
 794
 795         my $term = ($ENV{TERM} or "xterm");
 796         system("$term -e 'echo -e \"
 797 Welcome to the Samba4 Test environment '$testenv_name'
 798
 799 This matches the client environment used in make test
 800 server is pid `cat \$PIDDIR/samba.pid`
 801
 802 Some useful environment variables:
 803 TORTURE_OPTIONS=\$TORTURE_OPTIONS
 804 SMB_CONF_PATH=\$SMB_CONF_PATH
 805
 806 $envvarstr
 807 \" && LD_LIBRARY_PATH=$ENV{LD_LIBRARY_PATH} bash'");
 808         teardown_env($testenv_name);
 809 } else {
 810         foreach (@todo) {
 811                 $i++;
 812                 my $cmd = $$_[2];
 813                 $cmd =~ s/([\(\)])/\\$1/g;
 814                 my $name = $$_[0];
 815                 my $envname = $$_[1];
 816
 817                 my $envvars = setup_env($envname);
 818                 if (not defined($envvars)) {
 819                         Subunit::end_test($name, "skip",
 820                                 "unable to set up environment $envname");
 821                         next;
 822                 }
 823
 824                 run_testsuite($envname, $name, $cmd, $i, $suitestotal);
 825
 826                 if (defined($opt_analyse_cmd)) {
 827                         system("$opt_analyse_cmd \"$name\"");
 828                 }
 829
 830                 teardown_env($envname) if ($opt_resetup_env);
 831         }
 832 }
 833
 834 print "\n";
 835
 836 teardown_env($_) foreach (keys %running_envs);
 837
 838 $target->stop();
 839
 840 my $failed = 0;
 841
 842 # if there were any valgrind failures, show them
 843 foreach (<$prefix/valgrind.log*>) {
 844         next unless (-s $_);
 845         system("grep DWARF2.CFI.reader $_ > /dev/null");
 846         if ($? >> 8 == 0) {
 847             print "VALGRIND FAILURE\n";
 848             $failed++;
 849             system("cat $_");
 850         }
 851 }
 852 exit 0;