s3-printing: Fix vlp testprinter application.
[ira/wip.git] / selftest / selftest.pl
1 #!/usr/bin/perl
2 # Bootstrap Samba and run a number of tests against it.
3 # Copyright (C) 2005-2008 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] [--immediate] [--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<--immediate>
60
61 Show errors as soon as they happen rather than at the end of the test run.
62                 
63 =item I<--target samba4|samba3|win|kvm>
64
65 Specify test target against which to run. Default is 'samba4'.
66
67 =item I<--quick>
68
69 Run only a limited number of tests. Intended to run in about 30 seconds on 
70 moderately recent systems.
71                 
72 =item I<--socket-wrapper>
73
74 Use socket wrapper library for communication with server. Only works 
75 when the server is running locally.
76
77 Will prevent TCP and UDP ports being opened on the local host but 
78 (transparently) redirects these calls to use unix domain sockets.
79
80 =item I<--expected-failures>
81
82 Specify a file containing a list of tests that are expected to fail. Failures for 
83 these tests will be counted as successes, successes will be counted as failures.
84
85 The format for the file is, one entry per line:
86
87 TESTSUITE-NAME.TEST-NAME
88
89 The reason for a test can also be specified, by adding a hash sign (#) and the reason 
90 after the test name.
91
92 =item I<--exclude>
93
94 Specify a file containing a list of tests that should be skipped. Possible 
95 candidates are tests that segfault the server, flip or don't end. The format of this file is the same as 
96 for the --expected-failures flag.
97
98 =item I<--include>
99
100 Specify a file containing a list of tests that should be run. Same format 
101 as the --exclude flag.
102
103 Not includes specified means all tests will be run.
104
105 =item I<--one>
106
107 Abort as soon as one test fails.
108
109 =item I<--testlist>
110
111 Load a list of tests from the specified location.
112
113 =back
114
115 =head1 ENVIRONMENT
116
117 =over 4
118
119 =item I<SMBD_VALGRIND>
120
121 =item I<TORTURE_MAXTIME>
122
123 =item I<VALGRIND>
124
125 =item I<TLS_ENABLED>
126
127 =item I<srcdir>
128
129 =back
130
131 =head1 LICENSE
132
133 selftest is licensed under the GNU General Public License L<http://www.gnu.org/licenses/gpl.html>.
134
135 =head1 AUTHOR
136
137 Jelmer Vernooij
138
139 =cut
140
141 use strict;
142
143 use FindBin qw($RealBin $Script);
144 use File::Spec;
145 use Getopt::Long;
146 use POSIX;
147 use Cwd qw(abs_path);
148 use lib "$RealBin";
149 use Subunit qw(parse_results);
150 use SocketWrapper;
151
152 my $opt_help = 0;
153 my $opt_target = "samba4";
154 my $opt_quick = 0;
155 my $opt_socket_wrapper = 0;
156 my $opt_socket_wrapper_pcap = undef;
157 my $opt_socket_wrapper_keep_pcap = undef;
158 my $opt_one = 0;
159 my $opt_immediate = 0;
160 my $opt_expected_failures = undef;
161 my @opt_exclude = ();
162 my @opt_include = ();
163 my $opt_verbose = 0;
164 my $opt_image = undef;
165 my $opt_testenv = 0;
166 my $ldap = undef;
167 my $opt_analyse_cmd = undef;
168 my $opt_resetup_env = undef;
169 my $opt_bindir = undef;
170 my $opt_no_lazy_setup = undef;
171 my $opt_format = "plain";
172 my @testlists = ();
173
174 my $srcdir = ".";
175 my $builddir = ".";
176 my $exeext = "";
177 my $prefix = "./st";
178
179 my @expected_failures = ();
180 my @includes = ();
181 my @excludes = ();
182
183 my $statistics = {
184         SUITES_FAIL => 0,
185
186         TESTS_UNEXPECTED_OK => 0,
187         TESTS_EXPECTED_OK => 0,
188         TESTS_UNEXPECTED_FAIL => 0,
189         TESTS_EXPECTED_FAIL => 0,
190         TESTS_ERROR => 0,
191         TESTS_SKIP => 0,
192 };
193
194 sub find_in_list($$)
195 {
196         my ($list, $fullname) = @_;
197
198         foreach (@$list) {
199                 if ($fullname =~ /$$_[0]/) {
200                          return ($$_[1]) if ($$_[1]);
201                          return "NO REASON SPECIFIED";
202                 }
203         }
204
205         return undef;
206 }
207
208 sub expecting_failure($)
209 {
210         my ($name) = @_;
211         return find_in_list(\@expected_failures, $name);
212 }
213
214 sub skip($)
215 {
216         my ($name) = @_;
217
218         return find_in_list(\@excludes, $name);
219 }
220
221 sub getlog_env($);
222
223 sub setup_pcap($)
224 {
225         my ($name) = @_;
226
227         return unless ($opt_socket_wrapper_pcap);
228         return unless defined($ENV{SOCKET_WRAPPER_PCAP_DIR});
229
230         my $fname = $name;
231         $fname =~ s%[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\-]%_%g;
232
233         my $pcap_file = "$ENV{SOCKET_WRAPPER_PCAP_DIR}/$fname.pcap";
234
235         SocketWrapper::setup_pcap($pcap_file);
236
237         return $pcap_file;
238 }
239
240 sub cleanup_pcap($$$)
241 {
242         my ($pcap_file, $expected_ret, $ret) = @_;
243
244         return unless ($opt_socket_wrapper_pcap);
245         return if ($opt_socket_wrapper_keep_pcap);
246         return unless ($expected_ret == $ret);
247         return unless defined($pcap_file);
248
249         unlink($pcap_file);
250 }
251
252 sub run_testsuite($$$$$$)
253 {
254         my ($envname, $name, $cmd, $i, $totalsuites, $msg_ops) = @_;
255         my $pcap_file = setup_pcap($name);
256
257         $msg_ops->start_test([], $name);
258
259         unless (open(RESULT, "$cmd 2>&1|")) {
260                 $statistics->{TESTS_ERROR}++;
261                 $msg_ops->end_test([], $name, "error", 1, "Unable to run $cmd: $!");
262                 $statistics->{SUITES_FAIL}++;
263                 return 0;
264         }
265
266         my $expected_ret = parse_results(
267                 $msg_ops, $statistics, *RESULT, \&expecting_failure, [$name]);
268
269         my $envlog = getlog_env($envname);
270         $msg_ops->output_msg("ENVLOG: $envlog\n") if ($envlog ne "");
271
272         $msg_ops->output_msg("CMD: $cmd\n");
273
274         my $ret = close(RESULT);
275         $ret = 0 unless $ret == 1;
276
277         my $exitcode = $? >> 8;
278
279         if ($ret == 1) {
280                 $msg_ops->end_test([], $name, "success", $expected_ret != $ret, undef); 
281         } else {
282                 $msg_ops->end_test([], $name, "failure", $expected_ret != $ret, "Exit code was $exitcode");
283         }
284
285         cleanup_pcap($pcap_file, $expected_ret, $ret);
286
287         if (not $opt_socket_wrapper_keep_pcap and defined($pcap_file)) {
288                 $msg_ops->output_msg("PCAP FILE: $pcap_file\n");
289         }
290
291         if ($ret != $expected_ret) {
292                 $statistics->{SUITES_FAIL}++;
293                 exit(1) if ($opt_one);
294         }
295
296         return ($ret == $expected_ret);
297 }
298
299 sub ShowHelp()
300 {
301         print "Samba test runner
302 Copyright (C) Jelmer Vernooij <jelmer\@samba.org>
303 Copyright (C) Stefan Metzmacher <metze\@samba.org>
304
305 Usage: $Script [OPTIONS] TESTNAME-REGEX
306
307 Generic options:
308  --help                     this help page
309  --target=samba[34]|win|kvm Samba version to target
310  --testlist=FILE            file to read available tests from
311
312 Paths:
313  --prefix=DIR               prefix to run tests in [st]
314  --srcdir=DIR               source directory [.]
315  --builddir=DIR             output directory [.]
316  --exeext=EXT               executable extention []
317
318 Target Specific:
319  --socket-wrapper-pcap      save traffic to pcap directories
320  --socket-wrapper-keep-pcap keep all pcap files, not just those for tests that 
321                             failed
322  --socket-wrapper           enable socket wrapper
323  --bindir=PATH              path to target binaries
324  --expected-failures=FILE   specify list of tests that is guaranteed to fail
325
326 Samba4 Specific:
327  --ldap=openldap|fedora-ds  back samba onto specified ldap server
328
329 Kvm Specific:
330  --image=PATH               path to KVM image
331
332 Behaviour:
333  --quick                    run quick overall test
334  --one                      abort when the first test fails
335  --immediate                print test output for failed tests during run
336  --verbose                  be verbose
337  --analyse-cmd CMD          command to run after each test
338 ";
339         exit(0);
340 }
341
342 my $result = GetOptions (
343                 'help|h|?' => \$opt_help,
344                 'target=s' => \$opt_target,
345                 'prefix=s' => \$prefix,
346                 'socket-wrapper' => \$opt_socket_wrapper,
347                 'socket-wrapper-pcap' => \$opt_socket_wrapper_pcap,
348                 'socket-wrapper-keep-pcap' => \$opt_socket_wrapper_keep_pcap,
349                 'quick' => \$opt_quick,
350                 'one' => \$opt_one,
351                 'immediate' => \$opt_immediate,
352                 'expected-failures=s' => \$opt_expected_failures,
353                 'exclude=s' => \@opt_exclude,
354                 'include=s' => \@opt_include,
355                 'srcdir=s' => \$srcdir,
356                 'builddir=s' => \$builddir,
357                 'exeext=s' => \$exeext,
358                 'verbose' => \$opt_verbose,
359                 'testenv' => \$opt_testenv,
360                 'ldap:s' => \$ldap,
361                 'analyse-cmd=s' => \$opt_analyse_cmd,
362                 'no-lazy-setup' => \$opt_no_lazy_setup,
363                 'resetup-environment' => \$opt_resetup_env,
364                 'bindir:s' => \$opt_bindir,
365                 'format=s' => \$opt_format,
366                 'image=s' => \$opt_image,
367                 'testlist=s' => \@testlists
368             );
369
370 exit(1) if (not $result);
371
372 ShowHelp() if ($opt_help);
373
374 my $tests = shift;
375
376 # quick hack to disable rpc validation when using valgrind - its way too slow
377 unless (defined($ENV{VALGRIND})) {
378         $ENV{VALIDATE} = "validate";
379         $ENV{MALLOC_CHECK_} = 2;
380 }
381
382 my $bindir = ($opt_bindir or "$builddir/bin");
383 my $bindir_abs = abs_path($bindir);
384
385 # Backwards compatibility:
386 if (defined($ENV{TEST_LDAP}) and $ENV{TEST_LDAP} eq "yes") {
387         if (defined($ENV{FEDORA_DS_ROOT})) {
388                 $ldap = "fedora-ds";
389         } else {
390                 $ldap = "openldap";
391         }
392 }
393
394 my $torture_maxtime = ($ENV{TORTURE_MAXTIME} or 1200);
395 if ($ldap) {
396         # LDAP is slow
397         $torture_maxtime *= 2;
398 }
399
400 $prefix =~ s+//+/+;
401 $prefix =~ s+/./+/+;
402 $prefix =~ s+/$++;
403
404 die("using an empty prefix isn't allowed") unless $prefix ne "";
405
406 #Ensure we have the test prefix around
407 mkdir($prefix, 0777) unless -d $prefix;
408
409 my $prefix_abs = abs_path($prefix);
410 my $srcdir_abs = abs_path($srcdir);
411 my $builddir_abs = abs_path($builddir);
412
413 die("using an empty absolute prefix isn't allowed") unless $prefix_abs ne "";
414 die("using '/' as absolute prefix isn't allowed") unless $prefix_abs ne "/";
415
416 $ENV{PREFIX} = $prefix;
417 $ENV{KRB5CCNAME} = "$prefix/krb5ticket";
418 $ENV{PREFIX_ABS} = $prefix_abs;
419 $ENV{SRCDIR} = $srcdir;
420 $ENV{SRCDIR_ABS} = $srcdir_abs;
421 $ENV{BUILDDIR} = $builddir;
422 $ENV{BUILDDIR_ABS} = $builddir_abs;
423 $ENV{EXEEXT} = $exeext;
424
425 if (defined($ENV{RUN_FROM_BUILD_FARM}) and 
426         ($ENV{RUN_FROM_BUILD_FARM} eq "yes")) {
427         $opt_format = "buildfarm";
428 }
429
430 my $tls_enabled = not $opt_quick;
431 $ENV{TLS_ENABLED} = ($tls_enabled?"yes":"no");
432 $ENV{LDB_MODULES_PATH} = "$bindir_abs/modules/ldb";
433 $ENV{LD_SAMBA_MODULE_PATH} = "$bindir_abs/modules";
434 sub prefix_pathvar($$)
435 {
436         my ($name, $newpath) = @_;
437         if (defined($ENV{$name})) {
438                 $ENV{$name} = "$newpath:$ENV{$name}";
439         } else {
440                 $ENV{$name} = $newpath;
441         }
442 }
443 prefix_pathvar("PKG_CONFIG_PATH", "$bindir_abs/pkgconfig");
444 prefix_pathvar("PYTHONPATH", "$bindir_abs/python");
445
446 if ($opt_socket_wrapper_keep_pcap) {
447         # Socket wrapper keep pcap implies socket wrapper pcap
448         $opt_socket_wrapper_pcap = 1;
449 }
450
451 if ($opt_socket_wrapper_pcap) {
452         # Socket wrapper pcap implies socket wrapper
453         $opt_socket_wrapper = 1;
454 }
455
456 my $socket_wrapper_dir;
457 if ($opt_socket_wrapper) {
458         $socket_wrapper_dir = SocketWrapper::setup_dir("$prefix/w", $opt_socket_wrapper_pcap);
459         print "SOCKET_WRAPPER_DIR=$socket_wrapper_dir\n";
460 } else {
461          unless ($< == 0) { 
462                  print "WARNING: Not using socket wrapper, but also not running as root. Will not be able to listen on proper ports\n";
463          }
464 }
465
466 my $target;
467 my $testenv_default = "none";
468
469 if ($opt_target eq "samba4") {
470         $testenv_default = "member";
471         require target::Samba4;
472         $target = new Samba4($bindir, $ldap, "$srcdir/setup", $exeext);
473 } elsif ($opt_target eq "samba3") {
474         if ($opt_socket_wrapper and `$bindir/smbd -b | grep SOCKET_WRAPPER` eq "") {
475                 die("You must include --enable-socket-wrapper when compiling Samba in order to execute 'make test'.  Exiting....");
476         }
477         $testenv_default = "member";
478         require target::Samba3;
479         $target = new Samba3($bindir);
480 } elsif ($opt_target eq "win") {
481         die("Windows tests will not run with socket wrapper enabled.") 
482                 if ($opt_socket_wrapper);
483         $testenv_default = "dc";
484         require target::Windows;
485         $target = new Windows();
486 } elsif ($opt_target eq "kvm") {
487         die("Kvm tests will not run with socket wrapper enabled.") 
488                 if ($opt_socket_wrapper);
489         require target::Kvm;
490         die("No image specified") unless ($opt_image);
491         $target = new Kvm($opt_image, undef);
492 }
493
494 #
495 # Start a Virtual Distributed Ethernet Switch
496 # Returns the pid of the switch.
497 #
498 sub start_vde_switch($)
499 {
500         my ($path) = @_;
501
502         system("vde_switch --pidfile $path/vde.pid --sock $path/vde.sock --daemon");
503
504         open(PID, "$path/vde.pid");
505         <PID> =~ /([0-9]+)/;
506         my $pid = $1;
507         close(PID);
508
509         return $pid;
510 }
511
512 # Stop a Virtual Distributed Ethernet Switch
513 sub stop_vde_switch($)
514 {
515         my ($pid) = @_;
516         kill 9, $pid;
517 }
518
519 sub read_test_regexes($)
520 {
521         my ($name) = @_;
522         my @ret = ();
523         open(LF, "<$name") or die("unable to read $name: $!");
524         while (<LF>) { 
525                 chomp; 
526                 next if (/^#/);
527                 if (/^(.*?)([ \t]+)\#([\t ]*)(.*?)$/) {
528                         push (@ret, [$1, $4]);
529                 } else {
530                         s/^(.*?)([ \t]+)\#([\t ]*)(.*?)$//;
531                         push (@ret, [$_, undef]); 
532                 }
533         }
534         close(LF);
535         return @ret;
536 }
537
538 if (defined($opt_expected_failures)) {
539         @expected_failures = read_test_regexes($opt_expected_failures);
540 }
541
542 foreach (@opt_exclude) {
543         push (@excludes, read_test_regexes($_));
544 }
545
546 foreach (@opt_include) {
547         push (@includes, read_test_regexes($_));
548 }
549
550 my $interfaces = join(',', ("127.0.0.6/8", 
551                             "127.0.0.7/8",
552                             "127.0.0.8/8",
553                             "127.0.0.9/8",
554                             "127.0.0.10/8",
555                             "127.0.0.11/8"));
556
557 my $conffile = "$prefix_abs/client/client.conf";
558 $ENV{SMB_CONF_PATH} = $conffile;
559
560 sub write_clientconf($$)
561 {
562         my ($conffile, $vars) = @_;
563
564         mkdir("$prefix/client", 0777) unless -d "$prefix/client";
565         
566         if ( -d "$prefix/client/private" ) {
567                 unlink <$prefix/client/private/*>;
568         } else {
569                 mkdir("$prefix/client/private", 0777);
570         }
571
572         if ( -d "$prefix/client/lock" ) {
573                 unlink <$prefix/client/lockdir/*>;
574         } else {
575                 mkdir("$prefix/client/lockdir", 0777);
576         }
577
578         open(CF, ">$conffile");
579         print CF "[global]\n";
580         if (defined($ENV{VALGRIND})) {
581                 print CF "\ticonv:native = true\n";
582         } else {
583                 print CF "\ticonv:native = false\n";
584         }
585         print CF "\tnetbios name = client\n";
586         if (defined($vars->{DOMAIN})) {
587                 print CF "\tworkgroup = $vars->{DOMAIN}\n";
588         }
589         if (defined($vars->{REALM})) {
590                 print CF "\trealm = $vars->{REALM}\n";
591         }
592         if ($opt_socket_wrapper) {
593                 print CF "\tinterfaces = $interfaces\n";
594         }
595         print CF "
596         private dir = $prefix_abs/client/private
597         lock dir = $prefix_abs/client/lockdir
598         name resolve order = bcast
599         panic action = $RealBin/gdb_backtrace \%PID\% \%PROG\%
600         max xmit = 32K
601         notify:inotify = false
602         ldb:nosync = true
603         system:anonymous = true
604         client lanman auth = Yes
605         torture:basedir = $prefix_abs/client
606 #We don't want to pass our self-tests if the PAC code is wrong
607         gensec:require_pac = true
608         modules dir = $ENV{LD_SAMBA_MODULE_PATH}
609 ";
610         close(CF);
611 }
612
613 my @todo = ();
614
615 my $testsdir = "$srcdir/selftest";
616
617 my %required_envs = ();
618
619 sub read_testlist($)
620 {
621         my ($filename) = @_;
622
623         my @ret = ();
624         open(IN, $filename) or die("Unable to open $filename: $!");
625
626         while (<IN>) {
627                 if ($_ eq "-- TEST --\n") {
628                         my $name = <IN>;
629                         $name =~ s/\n//g;
630                         my $env = <IN>;
631                         $env =~ s/\n//g;
632                         my $cmdline = <IN>;
633                         $cmdline =~ s/\n//g;
634                         if (not defined($tests) or $name =~ /$tests/) {
635                                 $required_envs{$env} = 1;
636                                 push (@ret, [$name, $env, $cmdline]);
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 find_in_list(\@includes, $name));
674                 push (@available, $_);
675         }
676 }
677
678 my $msg_ops;
679 if ($opt_format eq "buildfarm") {
680         require output::buildfarm;
681         $msg_ops = new output::buildfarm($statistics);
682 } elsif ($opt_format eq "plain") {
683         require output::plain;
684         $msg_ops = new output::plain("$prefix/summary", $opt_verbose, $opt_immediate, $statistics, $#available+1);
685 } elsif ($opt_format eq "html") {
686         require output::html;
687         mkdir("test-results", 0777);
688         $msg_ops = new output::html("test-results", $statistics);
689 } else {
690         die("Invalid output format '$opt_format'");
691 }
692
693
694 foreach (@available) {
695         my $name = $$_[0];
696         my $skipreason = skip($name);
697         if ($skipreason) {
698                 $msg_ops->skip_testsuite($name, $skipreason);
699         } else {
700                 push(@todo, $_); 
701         }
702 }
703
704 if ($#todo == -1) {
705         print STDERR "No tests to run\n";
706         exit(1);
707         }
708
709 my $suitestotal = $#todo + 1;
710 my $i = 0;
711 $| = 1;
712
713 my %running_envs = ();
714
715 sub get_running_env($)
716 {
717         my ($name) = @_;
718
719         my $envname = $name;
720
721         $envname =~ s/:.*//;
722
723         return $running_envs{$envname};
724 }
725
726 my @exported_envvars = (
727         # domain stuff
728         "DOMAIN",
729         "REALM",
730
731         # domain controller stuff
732         "DC_SERVER",
733         "DC_SERVER_IP",
734         "DC_NETBIOSNAME",
735         "DC_NETBIOSALIAS",
736
737         # server stuff
738         "SERVER",
739         "SERVER_IP",
740         "NETBIOSNAME",
741         "NETBIOSALIAS",
742
743         # user stuff
744         "USERNAME",
745         "PASSWORD",
746         "DC_USERNAME",
747         "DC_PASSWORD",
748
749         # misc stuff
750         "KRB5_CONFIG",
751         "WINBINDD_SOCKET_DIR",
752         "WINBINDD_PRIV_PIPE_DIR"
753 );
754
755 $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub { 
756         my $signame = shift;
757         teardown_env($_) foreach(keys %running_envs);
758         die("Received signal $signame");
759 };
760
761 sub setup_env($)
762 {
763         my ($name) = @_;
764
765         my $testenv_vars = undef;
766
767         my $envname = $name;
768         my $option = $name;
769
770         $envname =~ s/:.*//;
771         $option =~ s/^[^:]*//;
772         $option =~ s/^://;
773
774         $option = "client" if $option eq "";
775
776         if ($envname eq "none") {
777                 $testenv_vars = {};
778         } elsif (defined(get_running_env($envname))) {
779                 $testenv_vars = get_running_env($envname);
780                 if (not $target->check_env($testenv_vars)) {
781                         $testenv_vars = undef;
782                 }
783         } else {
784                 $testenv_vars = $target->setup_env($envname, $prefix);
785         }
786
787         return undef unless defined($testenv_vars);
788
789         $running_envs{$envname} = $testenv_vars;
790
791         if ($option eq "local") {
792                 SocketWrapper::set_default_iface($testenv_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
793                 $ENV{SMB_CONF_PATH} = $testenv_vars->{SERVERCONFFILE};
794         } elsif ($option eq "client") {
795                 SocketWrapper::set_default_iface(6);
796                 write_clientconf($conffile, $testenv_vars);
797                 $ENV{SMB_CONF_PATH} = $conffile;
798         } else {
799                 die("Unknown option[$option] for envname[$envname]");
800         }
801
802         foreach (@exported_envvars) {
803                 if (defined($testenv_vars->{$_})) {
804                         $ENV{$_} = $testenv_vars->{$_};
805                 } else {
806                         delete $ENV{$_};
807                 }
808         }
809
810         return $testenv_vars;
811 }
812
813 sub exported_envvars_str($)
814 {
815         my ($testenv_vars) = @_;
816         my $out = "";
817
818         foreach (@exported_envvars) {
819                 next unless defined($testenv_vars->{$_});
820                 $out .= $_."=".$testenv_vars->{$_}."\n";
821         }
822
823         return $out;
824 }
825
826 sub getlog_env($)
827 {
828         my ($envname) = @_;
829         return "" if ($envname eq "none");
830         return $target->getlog_env(get_running_env($envname));
831 }
832
833 sub check_env($)
834 {
835         my ($envname) = @_;
836         return 1 if ($envname eq "none");
837         return $target->check_env(get_running_env($envname));
838 }
839
840 sub teardown_env($)
841 {
842         my ($envname) = @_;
843         return if ($envname eq "none");
844         $target->teardown_env(get_running_env($envname));
845         delete $running_envs{$envname};
846 }
847
848 if ($opt_no_lazy_setup) {
849         setup_env($_) foreach (keys %required_envs);
850 }
851
852 if ($opt_testenv) {
853         my $testenv_name = $ENV{SELFTEST_TESTENV};
854         $testenv_name = $testenv_default unless defined($testenv_name);
855
856         my $testenv_vars = setup_env($testenv_name);
857
858         $ENV{PIDDIR} = $testenv_vars->{PIDDIR};
859
860         my $envvarstr = exported_envvars_str($testenv_vars);
861
862         my $term = ($ENV{TERM} or "xterm");
863         system("$term -e 'echo -e \"
864 Welcome to the Samba4 Test environment '$testenv_name'
865
866 This matches the client environment used in make test
867 server is pid `cat \$PIDDIR/samba.pid`
868
869 Some useful environment variables:
870 TORTURE_OPTIONS=\$TORTURE_OPTIONS
871 SMB_CONF_PATH=\$SMB_CONF_PATH
872
873 $envvarstr
874 \" && LD_LIBRARY_PATH=$ENV{LD_LIBRARY_PATH} bash'");
875         teardown_env($testenv_name);
876 } else {
877         foreach (@todo) {
878                 $i++;
879                 my $cmd = $$_[2];
880                 $cmd =~ s/([\(\)])/\\$1/g;
881                 my $name = $$_[0];
882                 my $envname = $$_[1];
883                 
884                 my $envvars = setup_env($envname);
885                 if (not defined($envvars)) {
886                         $msg_ops->skip_testsuite($name, "unable to set up environment $envname");
887                         next;
888                 }
889
890                 run_testsuite($envname, $name, $cmd, $i, $suitestotal, 
891                               $msg_ops);
892
893                 if (defined($opt_analyse_cmd)) {
894                         system("$opt_analyse_cmd \"$name\"");
895                 }
896
897                 teardown_env($envname) if ($opt_resetup_env);
898         }
899 }
900
901 print "\n";
902
903 teardown_env($_) foreach (keys %running_envs);
904
905 $target->stop();
906
907 $msg_ops->summary();
908
909 my $failed = 0;
910
911 # if there were any valgrind failures, show them
912 foreach (<$prefix/valgrind.log*>) {
913         next unless (-s $_);
914         system("grep DWARF2.CFI.reader $_ > /dev/null");
915         if ($? >> 8 == 0) {
916             print "VALGRIND FAILURE\n";
917             $failed++;
918             system("cat $_");
919         }
920 }
921
922 if ($opt_format eq "buildfarm") {
923         print "TEST STATUS: $statistics->{SUITES_FAIL}\n";
924 }
925
926 exit $statistics->{SUITES_FAIL};