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