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