s4:samba_dnsupdate: cache the already registered records
[samba.git] / selftest / target / Samba3.pm
1 #!/usr/bin/perl
2 # Bootstrap Samba and run a number of tests against it.
3 # Copyright (C) 2005-2007 Jelmer Vernooij <jelmer@samba.org>
4 # Published under the GNU GPL, v3 or later.
5
6 package Samba3;
7
8 use strict;
9 use Cwd qw(abs_path);
10 use FindBin qw($RealBin);
11 use POSIX;
12 use target::Samba;
13
14 sub have_ads($) {
15         my ($self) = @_;
16         my $found_ads = 0;
17         my $smbd_build_options = Samba::bindir_path($self, "smbd") . " -b|";
18         open(IN, $smbd_build_options) or die("Unable to run $smbd_build_options: $!");
19
20         while (<IN>) {
21                 if (/WITH_ADS/) {
22                        $found_ads = 1;
23                 }
24         }
25         close IN;
26
27         # If we were not built with ADS support, pretend we were never even available
28         print "smbd does not have ADS support\n" unless $found_ads;
29         return $found_ads;
30 }
31
32 # return smb.conf parameters applicable to @path, based on the underlying
33 # filesystem type
34 sub get_fs_specific_conf($$)
35 {
36         my ($self, $path) = @_;
37         my $mods = "";
38         my $stat_out = `stat --file-system $path` or return "";
39
40         if ($stat_out =~ m/Type:\s+btrfs/) {
41                 $mods .= "btrfs ";
42         }
43
44         if ($mods) {
45                 return "vfs objects = $mods";
46         }
47
48         return undef;
49 }
50
51 sub new($$) {
52         my ($classname, $bindir, $binary_mapping, $srcdir, $server_maxtime) = @_;
53         my $self = { vars => {},
54                      bindir => $bindir,
55                      binary_mapping => $binary_mapping,
56                      srcdir => $srcdir,
57                      server_maxtime => $server_maxtime
58         };
59         bless $self;
60         return $self;
61 }
62
63 sub teardown_env($$)
64 {
65         my ($self, $envvars) = @_;
66         my $count = 0;
67
68         # This should cause smbd to terminate gracefully
69         close($envvars->{STDIN_PIPE});
70
71         my $smbdpid = $envvars->{SMBD_TL_PID};
72         my $nmbdpid = $envvars->{NMBD_TL_PID};
73         my $winbinddpid = $envvars->{WINBINDD_TL_PID};
74
75         # This should give it time to write out the gcov data
76         until ($count > 20) {
77             my $smbdchild = Samba::cleanup_child($smbdpid, "smbd");
78             my $nmbdchild = Samba::cleanup_child($nmbdpid, "nmbd");
79             my $winbinddchild = Samba::cleanup_child($winbinddpid, "winbindd");
80             if ($smbdchild == -1
81                 && $nmbdchild == -1
82                 && $winbinddchild == -1) {
83                 last;
84             }
85             sleep(1);
86             $count++;
87         }
88
89         if ($count <= 20 && kill(0, $smbdpid, $nmbdpid, $winbinddpid) == 0) {
90             return;
91         }
92
93         $self->stop_sig_term($smbdpid);
94         $self->stop_sig_term($nmbdpid);
95         $self->stop_sig_term($winbinddpid);
96
97         $count = 0;
98         until ($count > 10) {
99             my $smbdchild = Samba::cleanup_child($smbdpid, "smbd");
100             my $nmbdchild = Samba::cleanup_child($nmbdpid, "nmbd");
101             my $winbinddchild = Samba::cleanup_child($winbinddpid, "winbindd");
102             if ($smbdchild == -1
103                 && $nmbdchild == -1
104                 && $winbinddchild == -1) {
105                 last;
106             }
107             sleep(1);
108             $count++;
109         }
110
111         if ($count <= 10 && kill(0, $smbdpid, $nmbdpid, $winbinddpid) == 0) {
112             return;
113         }
114
115         warn("timelimit process did not quit on SIGTERM, sending SIGKILL");
116         $self->stop_sig_kill($smbdpid);
117         $self->stop_sig_kill($nmbdpid);
118         $self->stop_sig_kill($winbinddpid);
119
120         return 0;
121 }
122
123 sub getlog_env_app($$$)
124 {
125         my ($self, $envvars, $name) = @_;
126
127         my $title = "$name LOG of: $envvars->{NETBIOSNAME}\n";
128         my $out = $title;
129
130         open(LOG, "<".$envvars->{$name."_TEST_LOG"});
131
132         seek(LOG, $envvars->{$name."_TEST_LOG_POS"}, SEEK_SET);
133         while (<LOG>) {
134                 $out .= $_;
135         }
136         $envvars->{$name."_TEST_LOG_POS"} = tell(LOG);
137         close(LOG);
138
139         return "" if $out eq $title;
140  
141         return $out;
142 }
143
144 sub getlog_env($$)
145 {
146         my ($self, $envvars) = @_;
147         my $ret = "";
148
149         $ret .= $self->getlog_env_app($envvars, "SMBD");
150         $ret .= $self->getlog_env_app($envvars, "NMBD");
151         $ret .= $self->getlog_env_app($envvars, "WINBINDD");
152
153         return $ret;
154 }
155
156 sub check_env($$)
157 {
158         my ($self, $envvars) = @_;
159
160         my $childpid = waitpid(-1, WNOHANG);
161
162         # TODO ...
163         return 1;
164 }
165
166 sub setup_env($$$)
167 {
168         my ($self, $envname, $path) = @_;
169
170         $ENV{ENVNAME} = $envname;
171
172         if (defined($self->{vars}->{$envname})) {
173                 return $self->{vars}->{$envname};
174         }
175
176         if ($envname eq "s3dc") {
177                 return $self->setup_s3dc("$path/s3dc");
178         } elsif ($envname eq "simpleserver") {
179                 return $self->setup_simpleserver("$path/simpleserver");
180         } elsif ($envname eq "maptoguest") {
181                 return $self->setup_maptoguest("$path/maptoguest");
182         } elsif ($envname eq "ktest") {
183                 return $self->setup_ktest("$path/ktest");
184         } elsif ($envname eq "member") {
185                 if (not defined($self->{vars}->{s3dc})) {
186                         if (not defined($self->setup_s3dc("$path/s3dc"))) {
187                                 return undef;
188                         }
189                 }
190                 return $self->setup_member("$path/member", $self->{vars}->{s3dc});
191         } else {
192                 return "UNKNOWN";
193         }
194 }
195
196 sub setup_s3dc($$)
197 {
198         my ($self, $path) = @_;
199
200         print "PROVISIONING S3DC...";
201
202         my $s3dc_options = "
203         domain master = yes
204         domain logons = yes
205         lanman auth = yes
206
207         rpc_server:epmapper = external
208         rpc_server:spoolss = external
209         rpc_server:lsarpc = external
210         rpc_server:samr = external
211         rpc_server:netlogon = external
212         rpc_server:register_embedded_np = yes
213
214         rpc_daemon:epmd = fork
215         rpc_daemon:spoolssd = fork
216         rpc_daemon:lsasd = fork
217 ";
218
219         my $vars = $self->provision($path,
220                                     "LOCALS3DC2",
221                                     "locals3dc2pass",
222                                     $s3dc_options);
223
224         $vars or return undef;
225
226         if (not $self->check_or_start($vars, "yes", "yes", "yes")) {
227                return undef;
228         }
229
230         $vars->{DC_SERVER} = $vars->{SERVER};
231         $vars->{DC_SERVER_IP} = $vars->{SERVER_IP};
232         $vars->{DC_SERVER_IPV6} = $vars->{SERVER_IPV6};
233         $vars->{DC_NETBIOSNAME} = $vars->{NETBIOSNAME};
234         $vars->{DC_USERNAME} = $vars->{USERNAME};
235         $vars->{DC_PASSWORD} = $vars->{PASSWORD};
236
237         $self->{vars}->{s3dc} = $vars;
238
239         return $vars;
240 }
241
242 sub setup_member($$$)
243 {
244         my ($self, $prefix, $s3dcvars) = @_;
245
246         print "PROVISIONING MEMBER...";
247
248         my $member_options = "
249         security = domain
250         server signing = on
251         dbwrap_tdb_mutexes:* = yes
252 ";
253         my $ret = $self->provision($prefix,
254                                    "LOCALMEMBER3",
255                                    "localmember3pass",
256                                    $member_options);
257
258         $ret or return undef;
259
260         my $net = Samba::bindir_path($self, "net");
261         my $cmd = "";
262         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
263         $cmd .= "$net join $ret->{CONFIGURATION} $s3dcvars->{DOMAIN} member";
264         $cmd .= " -U$s3dcvars->{USERNAME}\%$s3dcvars->{PASSWORD}";
265
266         if (system($cmd) != 0) {
267             warn("Join failed\n$cmd");
268             return undef;
269         }
270
271         if (not $self->check_or_start($ret, "yes", "yes", "yes")) {
272                return undef;
273         }
274
275         $ret->{DC_SERVER} = $s3dcvars->{SERVER};
276         $ret->{DC_SERVER_IP} = $s3dcvars->{SERVER_IP};
277         $ret->{DC_SERVER_IPV6} = $s3dcvars->{SERVER_IPV6};
278         $ret->{DC_NETBIOSNAME} = $s3dcvars->{NETBIOSNAME};
279         $ret->{DC_USERNAME} = $s3dcvars->{USERNAME};
280         $ret->{DC_PASSWORD} = $s3dcvars->{PASSWORD};
281
282         return $ret;
283 }
284
285 sub setup_admember($$$$)
286 {
287         my ($self, $prefix, $dcvars) = @_;
288
289         # If we didn't build with ADS, pretend this env was never available
290         if (not $self->have_ads()) {
291                 return "UNKNOWN";
292         }
293
294         print "PROVISIONING S3 AD MEMBER...";
295
296         my $member_options = "
297         security = ads
298         server signing = on
299         workgroup = $dcvars->{DOMAIN}
300         realm = $dcvars->{REALM}
301 ";
302
303         my $ret = $self->provision($prefix,
304                                    "LOCALADMEMBER",
305                                    "loCalMemberPass",
306                                    $member_options);
307
308         $ret or return undef;
309
310         close(USERMAP);
311         $ret->{DOMAIN} = $dcvars->{DOMAIN};
312         $ret->{REALM} = $dcvars->{REALM};
313
314         my $ctx;
315         my $prefix_abs = abs_path($prefix);
316         $ctx = {};
317         $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
318         $ctx->{domain} = $dcvars->{DOMAIN};
319         $ctx->{realm} = $dcvars->{REALM};
320         $ctx->{dnsname} = lc($dcvars->{REALM});
321         $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
322         Samba::mk_krb5_conf($ctx, "");
323
324         $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
325
326         my $net = Samba::bindir_path($self, "net");
327         my $cmd = "";
328         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
329         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
330         $cmd .= "$net join $ret->{CONFIGURATION}";
331         $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
332
333         if (system($cmd) != 0) {
334             warn("Join failed\n$cmd");
335             return undef;
336         }
337
338         # We need world access to this share, as otherwise the domain
339         # administrator from the AD domain provided by Samba4 can't
340         # access the share for tests.
341         chmod 0777, "$prefix/share";
342
343         if (not $self->check_or_start($ret, "yes", "yes", "yes")) {
344                 return undef;
345         }
346
347         $ret->{DC_SERVER} = $dcvars->{SERVER};
348         $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
349         $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
350         $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
351         $ret->{DC_USERNAME} = $dcvars->{USERNAME};
352         $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
353
354         # Special case, this is called from Samba4.pm but needs to use the Samba3 check_env and get_log_env
355         $ret->{target} = $self;
356
357         return $ret;
358 }
359
360 sub setup_admember_rfc2307($$$$)
361 {
362         my ($self, $prefix, $dcvars) = @_;
363
364         # If we didn't build with ADS, pretend this env was never available
365         if (not $self->have_ads()) {
366                 return "UNKNOWN";
367         }
368
369         print "PROVISIONING S3 AD MEMBER WITH idmap_rfc2307 config...";
370
371         my $member_options = "
372         security = ads
373         server signing = on
374         workgroup = $dcvars->{DOMAIN}
375         realm = $dcvars->{REALM}
376         idmap config $dcvars->{DOMAIN} : backend = rfc2307
377         idmap config $dcvars->{DOMAIN} : range = 2000000-2999999
378         idmap config $dcvars->{DOMAIN} : ldap_server = ad
379         idmap config $dcvars->{DOMAIN} : bind_path_user = ou=idmap,dc=samba,dc=example,dc=com
380         idmap config $dcvars->{DOMAIN} : bind_path_group = ou=idmap,dc=samba,dc=example,dc=com
381 ";
382
383         my $ret = $self->provision($prefix,
384                                    "RFC2307MEMBER",
385                                    "loCalMemberPass",
386                                    $member_options);
387
388         $ret or return undef;
389
390         close(USERMAP);
391         $ret->{DOMAIN} = $dcvars->{DOMAIN};
392         $ret->{REALM} = $dcvars->{REALM};
393
394         my $ctx;
395         my $prefix_abs = abs_path($prefix);
396         $ctx = {};
397         $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
398         $ctx->{domain} = $dcvars->{DOMAIN};
399         $ctx->{realm} = $dcvars->{REALM};
400         $ctx->{dnsname} = lc($dcvars->{REALM});
401         $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
402         Samba::mk_krb5_conf($ctx, "");
403
404         $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
405
406         my $net = Samba::bindir_path($self, "net");
407         my $cmd = "";
408         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
409         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
410         $cmd .= "$net join $ret->{CONFIGURATION}";
411         $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
412
413         if (system($cmd) != 0) {
414             warn("Join failed\n$cmd");
415             return undef;
416         }
417
418         # We need world access to this share, as otherwise the domain
419         # administrator from the AD domain provided by Samba4 can't
420         # access the share for tests.
421         chmod 0777, "$prefix/share";
422
423         if (not $self->check_or_start($ret, "yes", "yes", "yes")) {
424                 return undef;
425         }
426
427         $ret->{DC_SERVER} = $dcvars->{SERVER};
428         $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
429         $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
430         $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
431         $ret->{DC_USERNAME} = $dcvars->{USERNAME};
432         $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
433
434         # Special case, this is called from Samba4.pm but needs to use the Samba3 check_env and get_log_env
435         $ret->{target} = $self;
436
437         return $ret;
438 }
439
440 sub setup_simpleserver($$)
441 {
442         my ($self, $path) = @_;
443
444         print "PROVISIONING server with security=share...";
445
446         my $prefix_abs = abs_path($path);
447
448         my $simpleserver_options = "
449         lanman auth = yes
450         vfs objects = xattr_tdb streams_depot
451
452 [vfs_aio_fork]
453         path = $prefix_abs/share
454         vfs objects = aio_fork
455         read only = no
456         vfs_aio_fork:erratic_testing_mode=yes
457 ";
458
459         my $vars = $self->provision($path,
460                                     "LOCALSHARE4",
461                                     "local4pass",
462                                     $simpleserver_options);
463
464         $vars or return undef;
465
466         if (not $self->check_or_start($vars, "yes", "no", "yes")) {
467                return undef;
468         }
469
470         $self->{vars}->{simpleserver} = $vars;
471
472         return $vars;
473 }
474
475 sub setup_ktest($$$)
476 {
477         my ($self, $prefix) = @_;
478
479         # If we didn't build with ADS, pretend this env was never available
480         if (not $self->have_ads()) {
481                 return "UNKNOWN";
482         }
483
484         print "PROVISIONING server with security=ads...";
485
486         my $ktest_options = "
487         workgroup = KTEST
488         realm = ktest.samba.example.com
489         security = ads
490         username map = $prefix/lib/username.map
491         server signing = required
492 ";
493
494         my $ret = $self->provision($prefix,
495                                    "LOCALKTEST6",
496                                    "localktest6pass",
497                                    $ktest_options);
498
499         $ret or return undef;
500
501         my $ctx;
502         my $prefix_abs = abs_path($prefix);
503         $ctx = {};
504         $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
505         $ctx->{domain} = "KTEST";
506         $ctx->{realm} = "KTEST.SAMBA.EXAMPLE.COM";
507         $ctx->{dnsname} = lc($ctx->{realm});
508         $ctx->{kdc_ipv4} = "0.0.0.0";
509         Samba::mk_krb5_conf($ctx, "");
510
511         $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
512
513         open(USERMAP, ">$prefix/lib/username.map") or die("Unable to open $prefix/lib/username.map");
514         print USERMAP "
515 $ret->{USERNAME} = KTEST\\Administrator
516 ";
517         close(USERMAP);
518
519 #This is the secrets.tdb created by 'net ads join' from Samba3 to a
520 #Samba4 DC with the same parameters as are being used here.  The
521 #domain SID is S-1-5-21-1071277805-689288055-3486227160
522
523         system("cp $self->{srcdir}/source3/selftest/ktest-secrets.tdb $prefix/private/secrets.tdb");
524         chmod 0600, "$prefix/private/secrets.tdb";
525
526 #Make sure there's no old ntdb file.
527         system("rm -f $prefix/private/secrets.ntdb");
528
529 #This uses a pre-calculated krb5 credentials cache, obtained by running Samba4 with:
530 # "--option=kdc:service ticket lifetime=239232" "--option=kdc:user ticket lifetime=239232" "--option=kdc:renewal lifetime=239232"
531 #
532 #and having in krb5.conf:
533 # ticket_lifetime = 799718400
534 # renew_lifetime = 799718400
535 #
536 # The commands for the -2 keytab where were:
537 # kinit administrator@KTEST.SAMBA.EXAMPLE.COM
538 # kvno host/localktest6@KTEST.SAMBA.EXAMPLE.COM
539 # kvno cifs/localktest6@KTEST.SAMBA.EXAMPLE.COM
540 # kvno host/LOCALKTEST6@KTEST.SAMBA.EXAMPLE.COM
541 # kvno cifs/LOCALKTEST6@KTEST.SAMBA.EXAMPLE.COM
542 #
543 # and then for the -3 keytab, I did
544 #
545 # net changetrustpw; kdestroy and the same again.
546 #
547 # This creates a credential cache with a very long lifetime (2036 at
548 # at 2011-04), and shows that running 'net changetrustpw' does not
549 # break existing logins (for the secrets.tdb method at least).
550 #
551
552         $ret->{KRB5_CCACHE}="FILE:$prefix/krb5_ccache";
553
554         system("cp $self->{srcdir}/source3/selftest/ktest-krb5_ccache-2 $prefix/krb5_ccache-2");
555         chmod 0600, "$prefix/krb5_ccache-2";
556
557         system("cp $self->{srcdir}/source3/selftest/ktest-krb5_ccache-3 $prefix/krb5_ccache-3");
558         chmod 0600, "$prefix/krb5_ccache-3";
559
560         # We need world access to this share, as otherwise the domain
561         # administrator from the AD domain provided by ktest can't
562         # access the share for tests.
563         chmod 0777, "$prefix/share";
564
565         if (not $self->check_or_start($ret, "yes", "no", "yes")) {
566                return undef;
567         }
568         return $ret;
569 }
570
571 sub setup_maptoguest($$)
572 {
573         my ($self, $path) = @_;
574
575         print "PROVISIONING maptoguest...";
576
577         my $options = "
578 map to guest = bad user
579 ";
580
581         my $vars = $self->provision($path,
582                                     "maptoguest",
583                                     "maptoguestpass",
584                                     $options);
585
586         $vars or return undef;
587
588         if (not $self->check_or_start($vars, "yes", "no", "yes")) {
589                return undef;
590         }
591
592         $self->{vars}->{s3maptoguest} = $vars;
593
594         return $vars;
595 }
596
597 sub stop_sig_term($$) {
598         my ($self, $pid) = @_;
599         kill("USR1", $pid) or kill("ALRM", $pid) or warn("Unable to kill $pid: $!");
600 }
601
602 sub stop_sig_kill($$) {
603         my ($self, $pid) = @_;
604         kill("ALRM", $pid) or warn("Unable to kill $pid: $!");
605 }
606
607 sub write_pid($$$)
608 {
609         my ($env_vars, $app, $pid) = @_;
610
611         open(PID, ">$env_vars->{PIDDIR}/timelimit.$app.pid");
612         print PID $pid;
613         close(PID);
614 }
615
616 sub read_pid($$)
617 {
618         my ($env_vars, $app) = @_;
619
620         open(PID, "<$env_vars->{PIDDIR}/timelimit.$app.pid");
621         my $pid = <PID>;
622         close(PID);
623         return $pid;
624 }
625
626 sub check_or_start($$$$$) {
627         my ($self, $env_vars, $nmbd, $winbindd, $smbd) = @_;
628
629         # use a pipe for stdin in the child processes. This allows
630         # those processes to monitor the pipe for EOF to ensure they
631         # exit when the test script exits
632         pipe(STDIN_READER, $env_vars->{STDIN_PIPE});
633
634         unlink($env_vars->{NMBD_TEST_LOG});
635         print "STARTING NMBD...";
636         my $pid = fork();
637         if ($pid == 0) {
638                 open STDOUT, ">$env_vars->{NMBD_TEST_LOG}";
639                 open STDERR, '>&STDOUT';
640
641                 SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
642
643                 $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
644                 $ENV{SELFTEST_WINBINDD_SOCKET_DIR} = $env_vars->{SELFTEST_WINBINDD_SOCKET_DIR};
645                 $ENV{NMBD_SOCKET_DIR} = $env_vars->{NMBD_SOCKET_DIR};
646
647                 $ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
648                 $ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
649                 $ENV{NSS_WRAPPER_HOSTS} = $env_vars->{NSS_WRAPPER_HOSTS};
650                 $ENV{NSS_WRAPPER_MODULE_SO_PATH} = $env_vars->{NSS_WRAPPER_MODULE_SO_PATH};
651                 $ENV{NSS_WRAPPER_MODULE_FN_PREFIX} = $env_vars->{NSS_WRAPPER_MODULE_FN_PREFIX};
652
653                 $ENV{ENVNAME} = "$ENV{ENVNAME}.nmbd";
654
655                 if ($nmbd ne "yes") {
656                         $SIG{USR1} = $SIG{ALRM} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
657                                 my $signame = shift;
658                                 print("Skip nmbd received signal $signame");
659                                 exit 0;
660                         };
661                         sleep($self->{server_maxtime});
662                         exit 0;
663                 }
664
665                 $ENV{MAKE_TEST_BINARY} = Samba::bindir_path($self, "nmbd");
666                 my @optargs = ("-d0");
667                 if (defined($ENV{NMBD_OPTIONS})) {
668                         @optargs = split(/ /, $ENV{NMBD_OPTIONS});
669                 }
670                 my @preargs = (Samba::bindir_path($self, "timelimit"), $self->{server_maxtime});
671                 if(defined($ENV{NMBD_VALGRIND})) { 
672                         @preargs = split(/ /, $ENV{NMBD_VALGRIND});
673                 }
674                 my @args = ("-F", "--no-process-group",
675                             "-s", $env_vars->{SERVERCONFFILE},
676                             "-l", $env_vars->{LOGDIR});
677                 if (not defined($ENV{NMBD_DONT_LOG_STDOUT})) {
678                         push(@args, "--log-stdout");
679                 }
680
681                 close($env_vars->{STDIN_PIPE});
682                 open STDIN, ">&", \*STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
683
684                 exec(@preargs, $ENV{MAKE_TEST_BINARY}, @args, @optargs)
685                         or die("Unable to start $ENV{MAKE_TEST_BINARY}: $!");
686         }
687         $env_vars->{NMBD_TL_PID} = $pid;
688         write_pid($env_vars, "nmbd", $pid);
689         print "DONE\n";
690
691         unlink($env_vars->{WINBINDD_TEST_LOG});
692         print "STARTING WINBINDD...";
693         $pid = fork();
694         if ($pid == 0) {
695                 open STDOUT, ">$env_vars->{WINBINDD_TEST_LOG}";
696                 open STDERR, '>&STDOUT';
697
698                 SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
699
700                 $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
701                 $ENV{SELFTEST_WINBINDD_SOCKET_DIR} = $env_vars->{SELFTEST_WINBINDD_SOCKET_DIR};
702                 $ENV{NMBD_SOCKET_DIR} = $env_vars->{NMBD_SOCKET_DIR};
703
704                 $ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
705                 $ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
706                 $ENV{NSS_WRAPPER_HOSTS} = $env_vars->{NSS_WRAPPER_HOSTS};
707                 $ENV{NSS_WRAPPER_MODULE_SO_PATH} = $env_vars->{NSS_WRAPPER_MODULE_SO_PATH};
708                 $ENV{NSS_WRAPPER_MODULE_FN_PREFIX} = $env_vars->{NSS_WRAPPER_MODULE_FN_PREFIX};
709
710                 $ENV{ENVNAME} = "$ENV{ENVNAME}.winbindd";
711
712                 if ($winbindd ne "yes") {
713                         $SIG{USR1} = $SIG{ALRM} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
714                                 my $signame = shift;
715                                 print("Skip winbindd received signal $signame");
716                                 exit 0;
717                         };
718                         sleep($self->{server_maxtime});
719                         exit 0;
720                 }
721
722                 $ENV{MAKE_TEST_BINARY} = Samba::bindir_path($self, "winbindd");
723                 my @optargs = ("-d0");
724                 if (defined($ENV{WINBINDD_OPTIONS})) {
725                         @optargs = split(/ /, $ENV{WINBINDD_OPTIONS});
726                 }
727                 my @preargs = (Samba::bindir_path($self, "timelimit"), $self->{server_maxtime});
728                 if(defined($ENV{WINBINDD_VALGRIND})) {
729                         @preargs = split(/ /, $ENV{WINBINDD_VALGRIND});
730                 }
731                 my @args = ("-F", "--no-process-group",
732                             "-s", $env_vars->{SERVERCONFFILE},
733                             "-l", $env_vars->{LOGDIR});
734                 if (not defined($ENV{WINBINDD_DONT_LOG_STDOUT})) {
735                         push(@args, "--stdout");
736                 }
737
738                 close($env_vars->{STDIN_PIPE});
739                 open STDIN, ">&", \*STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
740
741                 exec(@preargs, $ENV{MAKE_TEST_BINARY}, @args, @optargs)
742                         or die("Unable to start $ENV{MAKE_TEST_BINARY}: $!");
743         }
744         $env_vars->{WINBINDD_TL_PID} = $pid;
745         write_pid($env_vars, "winbindd", $pid);
746         print "DONE\n";
747
748         unlink($env_vars->{SMBD_TEST_LOG});
749         print "STARTING SMBD...";
750         $pid = fork();
751         if ($pid == 0) {
752                 open STDOUT, ">$env_vars->{SMBD_TEST_LOG}";
753                 open STDERR, '>&STDOUT';
754
755                 SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
756
757                 $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
758                 $ENV{SELFTEST_WINBINDD_SOCKET_DIR} = $env_vars->{SELFTEST_WINBINDD_SOCKET_DIR};
759                 $ENV{NMBD_SOCKET_DIR} = $env_vars->{NMBD_SOCKET_DIR};
760
761                 $ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
762                 $ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
763                 $ENV{NSS_WRAPPER_HOSTS} = $env_vars->{NSS_WRAPPER_HOSTS};
764                 $ENV{NSS_WRAPPER_MODULE_SO_PATH} = $env_vars->{NSS_WRAPPER_MODULE_SO_PATH};
765                 $ENV{NSS_WRAPPER_MODULE_FN_PREFIX} = $env_vars->{NSS_WRAPPER_MODULE_FN_PREFIX};
766
767                 $ENV{ENVNAME} = "$ENV{ENVNAME}.smbd";
768
769                 if ($smbd ne "yes") {
770                         $SIG{USR1} = $SIG{ALRM} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
771                                 my $signame = shift;
772                                 print("Skip smbd received signal $signame");
773                                 exit 0;
774                         };
775                         sleep($self->{server_maxtime});
776                         exit 0;
777                 }
778
779                 $ENV{MAKE_TEST_BINARY} = Samba::bindir_path($self, "smbd");
780                 my @optargs = ("-d0");
781                 if (defined($ENV{SMBD_OPTIONS})) {
782                         @optargs = split(/ /, $ENV{SMBD_OPTIONS});
783                 }
784                 my @preargs = (Samba::bindir_path($self, "timelimit"), $self->{server_maxtime});
785                 if(defined($ENV{SMBD_VALGRIND})) {
786                         @preargs = split(/ /,$ENV{SMBD_VALGRIND});
787                 }
788                 my @args = ("-F", "--no-process-group",
789                             "-s", $env_vars->{SERVERCONFFILE},
790                             "-l", $env_vars->{LOGDIR});
791                 if (not defined($ENV{SMBD_DONT_LOG_STDOUT})) {
792                         push(@args, "--log-stdout");
793                 }
794
795                 close($env_vars->{STDIN_PIPE});
796                 open STDIN, ">&", \*STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
797
798                 exec(@preargs, $ENV{MAKE_TEST_BINARY}, @args, @optargs)
799                         or die("Unable to start $ENV{MAKE_TEST_BINARY}: $!");
800         }
801         $env_vars->{SMBD_TL_PID} = $pid;
802         write_pid($env_vars, "smbd", $pid);
803         print "DONE\n";
804
805         close(STDIN_READER);
806
807         return $self->wait_for_start($env_vars, $nmbd, $winbindd, $smbd);
808 }
809
810 sub provision($$$$$$)
811 {
812         my ($self, $prefix, $server, $password, $extra_options, $no_delete_prefix) = @_;
813
814         ##
815         ## setup the various environment variables we need
816         ##
817
818         my $swiface = Samba::get_interface($server);
819         my %ret = ();
820         my $server_ip = "127.0.0.$swiface";
821         my $server_ipv6 = sprintf("fd00:0000:0000:0000:0000:0000:5357:5f%02x", $swiface);
822         my $domain = "SAMBA-TEST";
823
824         my $unix_name = ($ENV{USER} or $ENV{LOGNAME} or `PATH=/usr/ucb:$ENV{PATH} whoami`);
825         chomp $unix_name;
826         my $unix_uid = $>;
827         my $unix_gids_str = $);
828         my @unix_gids = split(" ", $unix_gids_str);
829
830         my $prefix_abs = abs_path($prefix);
831         my $bindir_abs = abs_path($self->{bindir});
832
833         my $dns_host_file = "$ENV{SELFTEST_PREFIX}/dns_host_file";
834
835         my @dirs = ();
836
837         my $shrdir="$prefix_abs/share";
838         push(@dirs,$shrdir);
839
840         my $libdir="$prefix_abs/lib";
841         push(@dirs,$libdir);
842
843         my $piddir="$prefix_abs/pid";
844         push(@dirs,$piddir);
845
846         my $privatedir="$prefix_abs/private";
847         push(@dirs,$privatedir);
848
849         my $lockdir="$prefix_abs/lockdir";
850         push(@dirs,$lockdir);
851
852         my $eventlogdir="$prefix_abs/lockdir/eventlog";
853         push(@dirs,$eventlogdir);
854
855         my $logdir="$prefix_abs/logs";
856         push(@dirs,$logdir);
857
858         my $driver32dir="$shrdir/W32X86";
859         push(@dirs,$driver32dir);
860
861         my $driver64dir="$shrdir/x64";
862         push(@dirs,$driver64dir);
863
864         my $driver40dir="$shrdir/WIN40";
865         push(@dirs,$driver40dir);
866
867         my $ro_shrdir="$shrdir/root-tmp";
868         push(@dirs,$ro_shrdir);
869
870         my $msdfs_shrdir="$shrdir/msdfsshare";
871         push(@dirs,$msdfs_shrdir);
872
873         my $msdfs_deeppath="$msdfs_shrdir/deeppath";
874         push(@dirs,$msdfs_deeppath);
875
876         # this gets autocreated by winbindd
877         my $wbsockdir="$prefix_abs/winbindd";
878         my $wbsockprivdir="$lockdir/winbindd_privileged";
879
880         my $nmbdsockdir="$prefix_abs/nmbd";
881         unlink($nmbdsockdir);
882
883         ## 
884         ## create the test directory layout
885         ##
886         die ("prefix_abs = ''") if $prefix_abs eq "";
887         die ("prefix_abs = '/'") if $prefix_abs eq "/";
888
889         mkdir($prefix_abs, 0777);
890         print "CREATE TEST ENVIRONMENT IN '$prefix'...";
891         if (not defined($no_delete_prefix) or not $no_delete_prefix) {
892             system("rm -rf $prefix_abs/*");
893         }
894         mkdir($_, 0777) foreach(@dirs);
895
896         my $fs_specific_conf = $self->get_fs_specific_conf($shrdir);
897
898         ##
899         ## lockdir and piddir must be 0755
900         ##
901         chmod 0755, $lockdir;
902         chmod 0755, $piddir;
903
904
905         ##
906         ## create ro and msdfs share layout
907         ##
908
909         chmod 0755, $ro_shrdir;
910         my $unreadable_file = "$ro_shrdir/unreadable_file";
911         unless (open(UNREADABLE_FILE, ">$unreadable_file")) {
912                 warn("Unable to open $unreadable_file");
913                 return undef;
914         }
915         close(UNREADABLE_FILE);
916         chmod 0600, $unreadable_file;
917
918         my $msdfs_target = "$ro_shrdir/msdfs-target";
919         unless (open(MSDFS_TARGET, ">$msdfs_target")) {
920                 warn("Unable to open $msdfs_target");
921                 return undef;
922         }
923         close(MSDFS_TARGET);
924         chmod 0666, $msdfs_target;
925         symlink "msdfs:$server_ip\\ro-tmp", "$msdfs_shrdir/msdfs-src1";
926         symlink "msdfs:$server_ipv6\\ro-tmp", "$msdfs_shrdir/deeppath/msdfs-src2";
927
928         my $conffile="$libdir/server.conf";
929
930         my $nss_wrapper_pl = "$ENV{PERL} $self->{srcdir}/lib/nss_wrapper/nss_wrapper.pl";
931         my $nss_wrapper_passwd = "$privatedir/passwd";
932         my $nss_wrapper_group = "$privatedir/group";
933         my $nss_wrapper_hosts = "$ENV{SELFTEST_PREFIX}/hosts";
934
935         my $mod_printer_pl = "$ENV{PERL} $self->{srcdir}/source3/script/tests/printing/modprinter.pl";
936
937         my @eventlog_list = ("dns server", "application");
938
939         ##
940         ## calculate uids and gids
941         ##
942
943         my ($max_uid, $max_gid);
944         my ($uid_nobody, $uid_root, $uid_pdbtest, $uid_pdbtest2);
945         my ($gid_nobody, $gid_nogroup, $gid_root, $gid_domusers, $gid_domadmins);
946
947         if ($unix_uid < 0xffff - 4) {
948                 $max_uid = 0xffff;
949         } else {
950                 $max_uid = $unix_uid;
951         }
952
953         $uid_root = $max_uid - 1;
954         $uid_nobody = $max_uid - 2;
955         $uid_pdbtest = $max_uid - 3;
956         $uid_pdbtest2 = $max_uid - 4;
957
958         if ($unix_gids[0] < 0xffff - 5) {
959                 $max_gid = 0xffff;
960         } else {
961                 $max_gid = $unix_gids[0];
962         }
963
964         $gid_nobody = $max_gid - 1;
965         $gid_nogroup = $max_gid - 2;
966         $gid_root = $max_gid - 3;
967         $gid_domusers = $max_gid - 4;
968         $gid_domadmins = $max_gid - 5;
969
970         ##
971         ## create conffile
972         ##
973
974         unless (open(CONF, ">$conffile")) {
975                 warn("Unable to open $conffile");
976                 return undef;
977         }
978         print CONF "
979 [global]
980         netbios name = $server
981         interfaces = $server_ip/8 $server_ipv6/64
982         bind interfaces only = yes
983         panic action = cd $self->{srcdir} && $self->{srcdir}/selftest/gdb_backtrace %d %\$(MAKE_TEST_BINARY)
984         smbd:suicide mode = yes
985
986         workgroup = $domain
987
988         private dir = $privatedir
989         pid directory = $piddir
990         lock directory = $lockdir
991         log file = $logdir/log.\%m
992         log level = 1
993         debug pid = yes
994         max log size = 0
995
996         state directory = $lockdir
997         cache directory = $lockdir
998
999         passdb backend = tdbsam
1000
1001         time server = yes
1002
1003         add user script =               $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action add --name %u --gid $gid_nogroup
1004         add group script =              $nss_wrapper_pl --group_path  $nss_wrapper_group  --type group  --action add --name %g
1005         add machine script =            $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action add --name %u --gid $gid_nogroup
1006         add user to group script =      $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type member --action add --member %u --name %g --group_path $nss_wrapper_group
1007         delete user script =            $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action delete --name %u
1008         delete group script =           $nss_wrapper_pl --group_path  $nss_wrapper_group  --type group  --action delete --name %g
1009         delete user from group script = $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type member --action delete --member %u --name %g --group_path $nss_wrapper_group
1010
1011         addprinter command =            $mod_printer_pl -a -s $conffile --
1012         deleteprinter command =         $mod_printer_pl -d -s $conffile --
1013
1014         eventlog list = application \"dns server\"
1015
1016         kernel oplocks = no
1017         kernel change notify = no
1018
1019         syslog = no
1020         printing = bsd
1021         printcap name = /dev/null
1022
1023         winbindd socket directory = $wbsockdir
1024         nmbd:socket dir = $nmbdsockdir
1025         idmap config * : range = 100000-200000
1026         winbind enum users = yes
1027         winbind enum groups = yes
1028         winbind separator = /
1029
1030 #       min receivefile size = 4000
1031
1032         read only = no
1033         server signing = auto
1034
1035         smbd:sharedelay = 100000
1036         smbd:writetimeupdatedelay = 500000
1037         map hidden = no
1038         map system = no
1039         map readonly = no
1040         store dos attributes = yes
1041         create mask = 755
1042         dos filemode = yes
1043         vfs objects = acl_xattr fake_acls xattr_tdb streams_depot
1044
1045         printing = vlp
1046         print command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb print %p %s
1047         lpq command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpq %p
1048         lp rm command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lprm %p %j
1049         lp pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lppause %p %j
1050         lp resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpresume %p %j
1051         queue pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queuepause %p
1052         queue resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queueresume %p
1053         lpq cache time = 0
1054         print notify backchannel = yes
1055
1056         ncalrpc dir = $prefix_abs/ncalrpc
1057         resolv:host file = $dns_host_file
1058
1059         # The samba3.blackbox.smbclient_s3 test uses this to test that
1060         # sending messages works, and that the %m sub works.
1061         message command = mv %s $shrdir/message.%m
1062
1063         # Begin extra options
1064         $extra_options
1065         # End extra options
1066
1067         #Include user defined custom parameters if set
1068 ";
1069
1070         if (defined($ENV{INCLUDE_CUSTOM_CONF})) {
1071                 print CONF "\t$ENV{INCLUDE_CUSTOM_CONF}\n";
1072         }
1073
1074         print CONF "
1075 [tmp]
1076         path = $shrdir
1077         comment = smb username is [%U]
1078 [tmpsort]
1079         path = $shrdir
1080         comment = Load dirsort module
1081         vfs objects = dirsort acl_xattr fake_acls xattr_tdb streams_depot
1082 [tmpenc]
1083         path = $shrdir
1084         comment = encrypt smb username is [%U]
1085         smb encrypt = required
1086         vfs objects = dirsort
1087 [tmpguest]
1088         path = $shrdir
1089         guest ok = yes
1090 [guestonly]
1091         path = $shrdir
1092         guest only = yes
1093         guest ok = yes
1094 [forceuser]
1095         path = $shrdir
1096         force user = $unix_name
1097         guest ok = yes
1098 [forcegroup]
1099         path = $shrdir
1100         force group = nogroup
1101         guest ok = yes
1102 [ro-tmp]
1103         path = $ro_shrdir
1104         guest ok = yes
1105 [write-list-tmp]
1106         path = $shrdir
1107         read only = yes
1108         write list = $unix_name
1109 [valid-users-tmp]
1110         path = $shrdir
1111         valid users = $unix_name
1112 [msdfs-share]
1113         path = $msdfs_shrdir
1114         msdfs root = yes
1115         guest ok = yes
1116 [hideunread]
1117         copy = tmp
1118         hide unreadable = yes
1119 [tmpcase]
1120         copy = tmp
1121         case sensitive = yes
1122 [hideunwrite]
1123         copy = tmp
1124         hide unwriteable files = yes
1125 [durable]
1126         copy = tmp
1127         kernel share modes = no
1128         kernel oplocks = no
1129         posix locking = no
1130 [fs_specific]
1131         copy = tmp
1132         $fs_specific_conf
1133 [print1]
1134         copy = tmp
1135         printable = yes
1136
1137 [print2]
1138         copy = print1
1139 [print3]
1140         copy = print1
1141         default devmode = no
1142 [lp]
1143         copy = print1
1144
1145 [nfs4acl_simple]
1146         path = $shrdir
1147         comment = smb username is [%U]
1148         nfs4:mode = simple
1149         vfs objects = nfs4acl_xattr xattr_tdb
1150
1151 [nfs4acl_special]
1152         path = $shrdir
1153         comment = smb username is [%U]
1154         nfs4:mode = special
1155         vfs objects = nfs4acl_xattr xattr_tdb
1156
1157 [xcopy_share]
1158         path = $shrdir
1159         comment = smb username is [%U]
1160         create mask = 777
1161         force create mode = 777
1162 [posix_share]
1163         path = $shrdir
1164         comment = smb username is [%U]
1165         create mask = 0777
1166         force create mode = 0
1167         directory mask = 0777
1168         force directory mode = 0
1169         vfs objects = xattr_tdb
1170 [aio]
1171         copy = tmp
1172         aio read size = 1
1173         aio write size = 1
1174
1175 [print\$]
1176         copy = tmp
1177
1178 [vfs_fruit]
1179         path = $shrdir
1180         vfs objects = catia fruit streams_xattr
1181         fruit:ressource = file
1182         fruit:metadata = netatalk
1183         fruit:locking = netatalk
1184         fruit:encoding = native
1185         ";
1186         close(CONF);
1187
1188         ##
1189         ## create a test account
1190         ##
1191
1192         unless (open(PASSWD, ">$nss_wrapper_passwd")) {
1193            warn("Unable to open $nss_wrapper_passwd");
1194            return undef;
1195         } 
1196         print PASSWD "nobody:x:$uid_nobody:$gid_nobody:nobody gecos:$prefix_abs:/bin/false
1197 $unix_name:x:$unix_uid:$unix_gids[0]:$unix_name gecos:$prefix_abs:/bin/false
1198 pdbtest:x:$uid_pdbtest:$gid_nogroup:pdbtest gecos:$prefix_abs:/bin/false
1199 pdbtest2:x:$uid_pdbtest2:$gid_nogroup:pdbtest gecos:$prefix_abs:/bin/false
1200 ";
1201         if ($unix_uid != 0) {
1202                 print PASSWD "root:x:$uid_root:$gid_root:root gecos:$prefix_abs:/bin/false
1203 ";
1204         }
1205         close(PASSWD);
1206
1207         unless (open(GROUP, ">$nss_wrapper_group")) {
1208              warn("Unable to open $nss_wrapper_group");
1209              return undef;
1210         }
1211         print GROUP "nobody:x:$gid_nobody:
1212 nogroup:x:$gid_nogroup:nobody
1213 $unix_name-group:x:$unix_gids[0]:
1214 domusers:X:$gid_domusers:
1215 domadmins:X:$gid_domadmins:
1216 ";
1217         if ($unix_gids[0] != 0) {
1218                 print GROUP "root:x:$gid_root:
1219 ";
1220         }
1221
1222         close(GROUP);
1223
1224         ## hosts
1225         my $hostname = lc($server);
1226         unless (open(HOSTS, ">>$nss_wrapper_hosts")) {
1227                 warn("Unable to open $nss_wrapper_hosts");
1228                 return undef;
1229         }
1230         print HOSTS "${server_ip} ${hostname}.samba.example.com ${hostname}\n";
1231         print HOSTS "${server_ipv6} ${hostname}.samba.example.com ${hostname}\n";
1232         close(HOSTS);
1233
1234
1235         foreach my $evlog (@eventlog_list) {
1236                 my $evlogtdb = "$eventlogdir/$evlog.tdb";
1237                 open(EVENTLOG, ">$evlogtdb") or die("Unable to open $evlogtdb");
1238                 close(EVENTLOG);
1239         }
1240
1241         $ENV{NSS_WRAPPER_PASSWD} = $nss_wrapper_passwd;
1242         $ENV{NSS_WRAPPER_GROUP} = $nss_wrapper_group;
1243         $ENV{NSS_WRAPPER_HOSTS} = $nss_wrapper_hosts;
1244
1245         my $cmd = "UID_WRAPPER_ROOT=1 " . Samba::bindir_path($self, "smbpasswd")." -c $conffile -L -s -a $unix_name > /dev/null";
1246         unless (open(PWD, "|$cmd")) {
1247              warn("Unable to set password for test account\n$cmd");
1248              return undef;
1249         }
1250         print PWD "$password\n$password\n";
1251         unless (close(PWD)) {
1252              warn("Unable to set password for test account\n$cmd");
1253              return undef; 
1254         }
1255         print "DONE\n";
1256
1257         open(DNS_UPDATE_LIST, ">$prefix/dns_update_list") or die("Unable to open $$prefix/dns_update_list");
1258         print DNS_UPDATE_LIST "A $server. $server_ip\n";
1259         print DNS_UPDATE_LIST "AAAA $server. $server_ipv6\n";
1260         close(DNS_UPDATE_LIST);
1261
1262         if (system("$ENV{SRCDIR_ABS}/source4/scripting/bin/samba_dnsupdate --all-interfaces --use-file=$dns_host_file -s $conffile --update-list=$prefix/dns_update_list --update-cache=$prefix/dns_update_cache --no-substiutions --no-credentials") != 0) {
1263                 die "Unable to update hostname into $dns_host_file";
1264         }
1265
1266         $ret{SERVER_IP} = $server_ip;
1267         $ret{SERVER_IPV6} = $server_ipv6;
1268         $ret{NMBD_TEST_LOG} = "$prefix/nmbd_test.log";
1269         $ret{NMBD_TEST_LOG_POS} = 0;
1270         $ret{WINBINDD_TEST_LOG} = "$prefix/winbindd_test.log";
1271         $ret{WINBINDD_TEST_LOG_POS} = 0;
1272         $ret{SMBD_TEST_LOG} = "$prefix/smbd_test.log";
1273         $ret{SMBD_TEST_LOG_POS} = 0;
1274         $ret{SERVERCONFFILE} = $conffile;
1275         $ret{CONFIGURATION} ="-s $conffile";
1276         $ret{SERVER} = $server;
1277         $ret{USERNAME} = $unix_name;
1278         $ret{USERID} = $unix_uid;
1279         $ret{DOMAIN} = $domain;
1280         $ret{NETBIOSNAME} = $server;
1281         $ret{PASSWORD} = $password;
1282         $ret{PIDDIR} = $piddir;
1283         $ret{SELFTEST_WINBINDD_SOCKET_DIR} = $wbsockdir;
1284         $ret{WINBINDD_PRIV_PIPE_DIR} = $wbsockprivdir;
1285         $ret{NMBD_SOCKET_DIR} = $nmbdsockdir;
1286         $ret{SOCKET_WRAPPER_DEFAULT_IFACE} = $swiface;
1287         $ret{NSS_WRAPPER_PASSWD} = $nss_wrapper_passwd;
1288         $ret{NSS_WRAPPER_GROUP} = $nss_wrapper_group;
1289         $ret{NSS_WRAPPER_HOSTS} = $nss_wrapper_hosts;
1290         $ret{NSS_WRAPPER_MODULE_SO_PATH} = Samba::nss_wrapper_winbind_so_path($self);
1291         $ret{NSS_WRAPPER_MODULE_FN_PREFIX} = "winbind";
1292         $ret{LOCAL_PATH} = "$shrdir";
1293         $ret{LOGDIR} = $logdir;
1294
1295         return \%ret;
1296 }
1297
1298 sub wait_for_start($$$$$)
1299 {
1300         my ($self, $envvars, $nmbd, $winbindd, $smbd) = @_;
1301         my $ret;
1302
1303         if ($nmbd eq "yes") {
1304                 my $count = 0;
1305
1306                 # give time for nbt server to register its names
1307                 print "checking for nmbd\n";
1308
1309                 # This will return quickly when things are up, but be slow if we need to wait for (eg) SSL init
1310                 my $nmblookup = Samba::bindir_path($self, "nmblookup");
1311
1312                 do {
1313                         $ret = system("$nmblookup $envvars->{CONFIGURATION} $envvars->{SERVER}");
1314                         if ($ret != 0) {
1315                                 sleep(1);
1316                         } else {
1317                                 system("$nmblookup $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} __SAMBA__");
1318                                 system("$nmblookup $envvars->{CONFIGURATION} __SAMBA__");
1319                                 system("$nmblookup $envvars->{CONFIGURATION} -U 127.255.255.255 __SAMBA__");
1320                                 system("$nmblookup $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} $envvars->{SERVER}");
1321                         }
1322                         $count++;
1323                 } while ($ret != 0 && $count < 10);
1324                 if ($count == 10) {
1325                         print "NMBD not reachable after 10 retries\n";
1326                         teardown_env($self, $envvars);
1327                         return 0;
1328                 }
1329         }
1330
1331         if ($winbindd eq "yes") {
1332             print "checking for winbindd\n";
1333             my $count = 0;
1334             do {
1335                 $ret = system("SELFTEST_WINBINDD_SOCKET_DIR=" . $envvars->{SELFTEST_WINBINDD_SOCKET_DIR} . " " . Samba::bindir_path($self, "wbinfo") . " --ping-dc");
1336                 if ($ret != 0) {
1337                     sleep(2);
1338                 }
1339                 $count++;
1340             } while ($ret != 0 && $count < 10);
1341             if ($count == 10) {
1342                 print "WINBINDD not reachable after 20 seconds\n";
1343                 teardown_env($self, $envvars);
1344                 return 0;
1345             }
1346         }
1347
1348         if ($smbd eq "yes") {
1349             # make sure smbd is also up set
1350             print "wait for smbd\n";
1351
1352             my $count = 0;
1353             do {
1354                 $ret = system(Samba::bindir_path($self, "smbclient3") ." $envvars->{CONFIGURATION} -L $envvars->{SERVER} -U% -p 139");
1355                 if ($ret != 0) {
1356                     sleep(2);
1357                 }
1358                 $count++
1359             } while ($ret != 0 && $count < 10);
1360             if ($count == 10) {
1361                 print "SMBD failed to start up in a reasonable time (20sec)\n";
1362                 teardown_env($self, $envvars);
1363                 return 0;
1364             }
1365         }
1366
1367         # Ensure we have domain users mapped.
1368         $ret = system(Samba::bindir_path($self, "net") ." $envvars->{CONFIGURATION} groupmap add rid=513 unixgroup=domusers type=domain");
1369         if ($ret != 0) {
1370             return 1;
1371         }
1372         $ret = system(Samba::bindir_path($self, "net") ." $envvars->{CONFIGURATION} groupmap add rid=512 unixgroup=domadmins type=domain");
1373         if ($ret != 0) {
1374             return 1;
1375         }
1376
1377         if ($winbindd eq "yes") {
1378             # note: creating builtin groups requires winbindd for the
1379             # unix id allocator
1380             $ret = system("SELFTEST_WINBINDD_SOCKET_DIR=" . $envvars->{SELFTEST_WINBINDD_SOCKET_DIR} . " " . Samba::bindir_path($self, "net") ." $envvars->{CONFIGURATION} sam createbuiltingroup Users");
1381             if ($ret != 0) {
1382                 print "Failed to create BUILTIN\\Users group\n";
1383                 return 0;
1384             }
1385             my $count = 0;
1386             do {
1387                 system(Samba::bindir_path($self, "net") . " $envvars->{CONFIGURATION} cache flush");
1388                 $ret = system("SELFTEST_WINBINDD_SOCKET_DIR=" . $envvars->{SELFTEST_WINBINDD_SOCKET_DIR} . " " . Samba::bindir_path($self, "wbinfo") . " --sid-to-gid=S-1-5-32-545");
1389                 if ($ret != 0) {
1390                     sleep(2);
1391                 }
1392                 $count++;
1393             } while ($ret != 0 && $count < 10);
1394             if ($count == 10) {
1395                 print "WINBINDD not reachable after 20 seconds\n";
1396                 teardown_env($self, $envvars);
1397                 return 0;
1398             }
1399         }
1400
1401         print $self->getlog_env($envvars);
1402
1403         return 1;
1404 }
1405
1406 1;