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