87763aadec119675ec705e590b9fcc009e4ad97d
[ira/wip.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         return $found_ads;
29 }
30
31 sub new($$) {
32         my ($classname, $bindir, $binary_mapping, $srcdir, $server_maxtime) = @_;
33         my $self = { vars => {},
34                      bindir => $bindir,
35                      binary_mapping => $binary_mapping,
36                      srcdir => $srcdir,
37                      server_maxtime => $server_maxtime
38         };
39         bless $self;
40         return $self;
41 }
42
43 sub teardown_env($$)
44 {
45         my ($self, $envvars) = @_;
46         my $count = 0;
47         
48         # This should cause smbd to terminate gracefully
49         close($envvars->{STDIN_PIPE});
50
51         my $smbdpid = $envvars->{SMBD_TL_PID};
52         my $nmbdpid = $envvars->{NMBD_TL_PID};
53         my $winbinddpid = $envvars->{WINBINDD_TL_PID};
54
55         # This should give it time to write out the gcov data
56         until ($count > 20) {
57             if (Samba::cleanup_child($smbdpid, "smbd") == -1
58                 && Samba::cleanup_child($nmbdpid, "nmbd") == -1
59                 && Samba::cleanup_child($winbinddpid, "winbindd") == -1) {
60                 last;
61             }
62             sleep(1);
63             $count++;
64         }
65
66         if ($count <= 20 && kill(0, $smbdpid, $nmbdpid, $winbinddpid) == 0) {
67             return;
68         }
69
70         $self->stop_sig_term($smbdpid);
71         $self->stop_sig_term($nmbdpid);
72         $self->stop_sig_term($winbinddpid);
73
74         $count = 0;
75         until ($count > 10) {
76             if (Samba::cleanup_child($smbdpid, "smbd") == -1
77                 && Samba::cleanup_child($nmbdpid, "nmbd") == -1
78                 && Samba::cleanup_child($winbinddpid, "winbindd") == -1) {
79                 last;
80             }
81             sleep(1);
82             $count++;
83         }
84
85         if ($count <= 10 && kill(0, $smbdpid, $nmbdpid, $winbinddpid) == 0) {
86             return;
87         }
88
89         warn("timelimit process did not quit on SIGTERM, sending SIGKILL");
90         $self->stop_sig_kill($smbdpid);
91         $self->stop_sig_kill($nmbdpid);
92         $self->stop_sig_kill($winbinddpid);
93
94         return 0;
95 }
96
97 sub getlog_env_app($$$)
98 {
99         my ($self, $envvars, $name) = @_;
100
101         my $title = "$name LOG of: $envvars->{NETBIOSNAME}\n";
102         my $out = $title;
103
104         open(LOG, "<".$envvars->{$name."_TEST_LOG"});
105
106         seek(LOG, $envvars->{$name."_TEST_LOG_POS"}, SEEK_SET);
107         while (<LOG>) {
108                 $out .= $_;
109         }
110         $envvars->{$name."_TEST_LOG_POS"} = tell(LOG);
111         close(LOG);
112
113         return "" if $out eq $title;
114  
115         return $out;
116 }
117
118 sub getlog_env($$)
119 {
120         my ($self, $envvars) = @_;
121         my $ret = "";
122
123         $ret .= $self->getlog_env_app($envvars, "SMBD");
124         $ret .= $self->getlog_env_app($envvars, "NMBD");
125         $ret .= $self->getlog_env_app($envvars, "WINBINDD");
126
127         return $ret;
128 }
129
130 sub check_env($$)
131 {
132         my ($self, $envvars) = @_;
133
134         my $childpid = waitpid(-1, WNOHANG);
135
136         # TODO ...
137         return 1;
138 }
139
140 sub setup_env($$$)
141 {
142         my ($self, $envname, $path) = @_;
143         
144         if (defined($self->{vars}->{$envname})) {
145                 return $self->{vars}->{$envname};
146         }
147
148         if ($envname eq "s3dc") {
149                 return $self->setup_s3dc("$path/s3dc");
150         } elsif ($envname eq "secshare") {
151                 return $self->setup_secshare("$path/secshare");
152         } elsif ($envname eq "maptoguest") {
153                 return $self->setup_maptoguest("$path/maptoguest");
154         } elsif ($envname eq "ktest") {
155                 return $self->setup_ktest("$path/ktest");
156         } elsif ($envname eq "secserver") {
157                 if (not defined($self->{vars}->{s3dc})) {
158                         if (not defined($self->setup_s3dc("$path/s3dc"))) {
159                                 return undef;
160                         }
161                 }
162                 return $self->setup_secserver("$path/secserver", $self->{vars}->{s3dc});
163         } elsif ($envname eq "member") {
164                 if (not defined($self->{vars}->{s3dc})) {
165                         if (not defined($self->setup_s3dc("$path/s3dc"))) {
166                                 return undef;
167                         }
168                 }
169                 return $self->setup_member("$path/member", $self->{vars}->{s3dc});
170         } else {
171                 return "UNKNOWN";
172         }
173 }
174
175 sub setup_s3dc($$)
176 {
177         my ($self, $path) = @_;
178
179         print "PROVISIONING S3DC...";
180
181         my $s3dc_options = "
182         domain master = yes
183         domain logons = yes
184         lanman auth = yes
185 ";
186
187         my $vars = $self->provision($path,
188                                     "LOCALS3DC2",
189                                     "locals3dc2pass",
190                                     $s3dc_options);
191
192         $vars or return undef;
193
194         $self->check_or_start($vars,
195                                "yes", "yes", "yes");
196
197         if (not $self->wait_for_start($vars)) {
198                return undef;
199         }
200
201         $vars->{DC_SERVER} = $vars->{SERVER};
202         $vars->{DC_SERVER_IP} = $vars->{SERVER_IP};
203         $vars->{DC_NETBIOSNAME} = $vars->{NETBIOSNAME};
204         $vars->{DC_USERNAME} = $vars->{USERNAME};
205         $vars->{DC_PASSWORD} = $vars->{PASSWORD};
206
207         $self->{vars}->{s3dc} = $vars;
208
209         return $vars;
210 }
211
212 sub setup_member($$$)
213 {
214         my ($self, $prefix, $s3dcvars) = @_;
215
216         print "PROVISIONING MEMBER...";
217
218         my $member_options = "
219         security = domain
220         server signing = on
221 ";
222         my $ret = $self->provision($prefix,
223                                    "LOCALMEMBER3",
224                                    "localmember3pass",
225                                    $member_options);
226
227         $ret or return undef;
228
229         my $net = Samba::bindir_path($self, "net");
230         my $cmd = "";
231         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
232         $cmd .= "$net join $ret->{CONFIGURATION} $s3dcvars->{DOMAIN} member";
233         $cmd .= " -U$s3dcvars->{USERNAME}\%$s3dcvars->{PASSWORD}";
234
235         if (system($cmd) != 0) {
236             warn("Join failed\n$cmd");
237             return undef;
238         }
239
240         $self->check_or_start($ret, "yes", "yes", "yes");
241
242         if (not $self->wait_for_start($ret)) {
243                return undef;
244         }
245
246         $ret->{DC_SERVER} = $s3dcvars->{SERVER};
247         $ret->{DC_SERVER_IP} = $s3dcvars->{SERVER_IP};
248         $ret->{DC_NETBIOSNAME} = $s3dcvars->{NETBIOSNAME};
249         $ret->{DC_USERNAME} = $s3dcvars->{USERNAME};
250         $ret->{DC_PASSWORD} = $s3dcvars->{PASSWORD};
251
252         return $ret;
253 }
254
255 sub setup_admember($$$$)
256 {
257         my ($self, $prefix, $dcvars) = @_;
258
259         # If we didn't build with ADS, pretend this env was never available
260         if (not $self->have_ads()) {
261                 return "UNKNOWN";
262         }
263
264         print "PROVISIONING S3 AD MEMBER...";
265
266         my $member_options = "
267         security = ads
268         server signing = on
269         workgroup = $dcvars->{DOMAIN}
270         realm = $dcvars->{REALM}
271 ";
272
273         my $ret = $self->provision($prefix,
274                                    "LOCALADMEMBER",
275                                    "loCalMemberPass",
276                                    $member_options);
277
278         $ret or return undef;
279
280         close(USERMAP);
281         $ret->{DOMAIN} = $dcvars->{DOMAIN};
282         $ret->{REALM} = $dcvars->{REALM};
283
284         my $ctx;
285         my $prefix_abs = abs_path($prefix);
286         $ctx = {};
287         $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
288         $ctx->{domain} = $dcvars->{DOMAIN};
289         $ctx->{realm} = $dcvars->{REALM};
290         $ctx->{dnsname} = lc($dcvars->{REALM});
291         $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
292         Samba::mk_krb5_conf($ctx, "");
293
294         $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
295
296         my $net = Samba::bindir_path($self, "net");
297         my $cmd = "";
298         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
299         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
300         $cmd .= "$net join $ret->{CONFIGURATION}";
301         $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
302
303         if (system($cmd) != 0) {
304             warn("Join failed\n$cmd");
305             return undef;
306         }
307
308         # We need world access to this share, as otherwise the domain
309         # administrator from the AD domain provided by Samba4 can't
310         # access the share for tests.
311         chmod 0777, "$prefix/share";
312
313         $self->check_or_start($ret,
314                               "yes", "yes", "yes");
315
316         $self->wait_for_start($ret);
317
318         $ret->{DC_SERVER} = $dcvars->{SERVER};
319         $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
320         $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
321         $ret->{DC_USERNAME} = $dcvars->{USERNAME};
322         $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
323
324         # Special case, this is called from Samba4.pm but needs to use the Samba3 check_env and get_log_env
325         $ret->{target} = $self;
326
327         return $ret;
328 }
329
330 sub setup_secshare($$)
331 {
332         my ($self, $path) = @_;
333
334         print "PROVISIONING server with security=share...";
335
336         my $secshare_options = "
337         security = share
338         lanman auth = yes
339 ";
340
341         my $vars = $self->provision($path,
342                                     "LOCALSHARE4",
343                                     "local4pass",
344                                     $secshare_options);
345
346         $vars or return undef;
347
348         $self->check_or_start($vars, "yes", "no", "yes");
349
350         if (not $self->wait_for_start($vars)) {
351                return undef;
352         }
353
354         $self->{vars}->{secshare} = $vars;
355
356         return $vars;
357 }
358
359 sub setup_secserver($$$)
360 {
361         my ($self, $prefix, $s3dcvars) = @_;
362
363         print "PROVISIONING server with security=server...";
364
365         my $secserver_options = "
366         security = server
367         password server = $s3dcvars->{SERVER_IP}
368 ";
369
370         my $ret = $self->provision($prefix,
371                                    "LOCALSERVER5",
372                                    "localserver5pass",
373                                    $secserver_options);
374
375         $ret or return undef;
376
377         $self->check_or_start($ret, "yes", "no", "yes");
378
379         if (not $self->wait_for_start($ret)) {
380                return undef;
381         }
382
383         $ret->{DC_SERVER} = $s3dcvars->{SERVER};
384         $ret->{DC_SERVER_IP} = $s3dcvars->{SERVER_IP};
385         $ret->{DC_NETBIOSNAME} = $s3dcvars->{NETBIOSNAME};
386         $ret->{DC_USERNAME} = $s3dcvars->{USERNAME};
387         $ret->{DC_PASSWORD} = $s3dcvars->{PASSWORD};
388
389         return $ret;
390 }
391
392 sub setup_ktest($$$)
393 {
394         my ($self, $prefix) = @_;
395
396         # If we didn't build with ADS, pretend this env was never available
397         if (not $self->have_ads()) {
398                 return "UNKNOWN";
399         }
400
401         print "PROVISIONING server with security=ads...";
402
403         my $ktest_options = "
404         workgroup = KTEST
405         realm = ktest.samba.example.com
406         security = ads
407         username map = $prefix/lib/username.map
408         server signing = required
409 ";
410
411         my $ret = $self->provision($prefix,
412                                    "LOCALKTEST6",
413                                    "localktest6pass",
414                                    $ktest_options);
415
416         $ret or return undef;
417
418         my $ctx;
419         my $prefix_abs = abs_path($prefix);
420         $ctx = {};
421         $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
422         $ctx->{domain} = "KTEST";
423         $ctx->{realm} = "KTEST.SAMBA.EXAMPLE.COM";
424         $ctx->{dnsname} = lc($ctx->{realm});
425         $ctx->{kdc_ipv4} = "0.0.0.0";
426         Samba::mk_krb5_conf($ctx, "");
427
428         $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
429
430         open(USERMAP, ">$prefix/lib/username.map") or die("Unable to open $prefix/lib/username.map");
431         print USERMAP "
432 $ret->{USERNAME} = KTEST\\Administrator
433 ";
434         close(USERMAP);
435
436 #This is the secrets.tdb created by 'net ads join' from Samba3 to a
437 #Samba4 DC with the same parameters as are being used here.  The
438 #domain SID is S-1-5-21-1071277805-689288055-3486227160
439
440         system("cp $self->{srcdir}/source3/selftest/ktest-secrets.tdb $prefix/private/secrets.tdb");
441         chmod 0600, "$prefix/private/secrets.tdb";
442
443 #This uses a pre-calculated krb5 credentials cache, obtained by running Samba4 with:
444 # "--option=kdc:service ticket lifetime=239232" "--option=kdc:user ticket lifetime=239232" "--option=kdc:renewal lifetime=239232"
445 #
446 #and having in krb5.conf:
447 # ticket_lifetime = 799718400
448 # renew_lifetime = 799718400
449 #
450 # The commands for the -2 keytab where were:
451 # kinit administrator@KTEST.SAMBA.EXAMPLE.COM
452 # kvno host/localktest6@KTEST.SAMBA.EXAMPLE.COM
453 # kvno cifs/localktest6@KTEST.SAMBA.EXAMPLE.COM
454 # kvno host/LOCALKTEST6@KTEST.SAMBA.EXAMPLE.COM
455 # kvno cifs/LOCALKTEST6@KTEST.SAMBA.EXAMPLE.COM
456 #
457 # and then for the -3 keytab, I did
458 #
459 # net changetrustpw; kdestroy and the same again.
460 #
461 # This creates a credential cache with a very long lifetime (2036 at
462 # at 2011-04), and shows that running 'net changetrustpw' does not
463 # break existing logins (for the secrets.tdb method at least).
464 #
465
466         $ret->{KRB5_CCACHE}="FILE:$prefix/krb5_ccache";
467
468         system("cp $self->{srcdir}/source3/selftest/ktest-krb5_ccache-2 $prefix/krb5_ccache-2");
469         chmod 0600, "$prefix/krb5_ccache-2";
470
471         system("cp $self->{srcdir}/source3/selftest/ktest-krb5_ccache-3 $prefix/krb5_ccache-3");
472         chmod 0600, "$prefix/krb5_ccache-3";
473
474         # We need world access to this share, as otherwise the domain
475         # administrator from the AD domain provided by ktest can't
476         # access the share for tests.
477         chmod 0777, "$prefix/share";
478
479         $self->check_or_start($ret, "yes", "no", "yes");
480
481         if (not $self->wait_for_start($ret)) {
482                return undef;
483         }
484         return $ret;
485 }
486
487 sub setup_maptoguest($$)
488 {
489         my ($self, $path) = @_;
490
491         print "PROVISIONING maptoguest...";
492
493         my $options = "
494 map to guest = bad user
495 ";
496
497         my $vars = $self->provision($path,
498                                     "maptoguest",
499                                     "maptoguestpass",
500                                     $options);
501
502         $vars or return undef;
503
504         $self->check_or_start($vars,
505                                "yes", "no", "yes");
506
507         if (not $self->wait_for_start($vars)) {
508                return undef;
509         }
510
511         $self->{vars}->{s3maptoguest} = $vars;
512
513         return $vars;
514 }
515
516 sub stop_sig_term($$) {
517         my ($self, $pid) = @_;
518         kill("USR1", $pid) or kill("ALRM", $pid) or warn("Unable to kill $pid: $!");
519 }
520
521 sub stop_sig_kill($$) {
522         my ($self, $pid) = @_;
523         kill("ALRM", $pid) or warn("Unable to kill $pid: $!");
524 }
525
526 sub write_pid($$$)
527 {
528         my ($env_vars, $app, $pid) = @_;
529
530         open(PID, ">$env_vars->{PIDDIR}/timelimit.$app.pid");
531         print PID $pid;
532         close(PID);
533 }
534
535 sub read_pid($$)
536 {
537         my ($env_vars, $app) = @_;
538
539         open(PID, "<$env_vars->{PIDDIR}/timelimit.$app.pid");
540         my $pid = <PID>;
541         close(PID);
542         return $pid;
543 }
544
545 sub check_or_start($$$$$) {
546         my ($self, $env_vars, $nmbd, $winbindd, $smbd) = @_;
547
548         # use a pipe for stdin in the child processes. This allows
549         # those processes to monitor the pipe for EOF to ensure they
550         # exit when the test script exits
551         pipe(STDIN_READER, $env_vars->{STDIN_PIPE});
552
553         unlink($env_vars->{NMBD_TEST_LOG});
554         print "STARTING NMBD...";
555         my $pid = fork();
556         if ($pid == 0) {
557                 open STDOUT, ">$env_vars->{NMBD_TEST_LOG}";
558                 open STDERR, '>&STDOUT';
559
560                 SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
561
562                 $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
563                 $ENV{WINBINDD_SOCKET_DIR} = $env_vars->{WINBINDD_SOCKET_DIR};
564                 $ENV{NMBD_SOCKET_DIR} = $env_vars->{NMBD_SOCKET_DIR};
565
566                 $ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
567                 $ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
568                 $ENV{NSS_WRAPPER_WINBIND_SO_PATH} = $env_vars->{NSS_WRAPPER_WINBIND_SO_PATH};
569
570                 $ENV{UID_WRAPPER} = "1";
571
572                 if ($nmbd ne "yes") {
573                         $SIG{USR1} = $SIG{ALRM} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
574                                 my $signame = shift;
575                                 print("Skip nmbd received signal $signame");
576                                 exit 0;
577                         };
578                         sleep($self->{server_maxtime});
579                         exit 0;
580                 }
581
582                 my @optargs = ("-d0");
583                 if (defined($ENV{NMBD_OPTIONS})) {
584                         @optargs = split(/ /, $ENV{NMBD_OPTIONS});
585                 }
586
587                 $ENV{MAKE_TEST_BINARY} = Samba::bindir_path($self, "nmbd");
588
589                 my @preargs = (Samba::bindir_path($self, "timelimit"), $self->{server_maxtime});
590                 if(defined($ENV{NMBD_VALGRIND})) { 
591                         @preargs = split(/ /, $ENV{NMBD_VALGRIND});
592                 }
593
594                 close($env_vars->{STDIN_PIPE});
595                 open STDIN, ">&", \*STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
596
597                 exec(@preargs, Samba::bindir_path($self, "nmbd"), "-F", "--no-process-group", "--log-stdout", "-s", $env_vars->{SERVERCONFFILE}, @optargs) or die("Unable to start nmbd: $!");
598         }
599         $env_vars->{NMBD_TL_PID} = $pid;
600         write_pid($env_vars, "nmbd", $pid);
601         print "DONE\n";
602
603         unlink($env_vars->{WINBINDD_TEST_LOG});
604         print "STARTING WINBINDD...";
605         $pid = fork();
606         if ($pid == 0) {
607                 open STDOUT, ">$env_vars->{WINBINDD_TEST_LOG}";
608                 open STDERR, '>&STDOUT';
609
610                 SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
611
612                 $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
613                 $ENV{WINBINDD_SOCKET_DIR} = $env_vars->{WINBINDD_SOCKET_DIR};
614                 $ENV{NMBD_SOCKET_DIR} = $env_vars->{NMBD_SOCKET_DIR};
615
616                 $ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
617                 $ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
618                 $ENV{NSS_WRAPPER_WINBIND_SO_PATH} = $env_vars->{NSS_WRAPPER_WINBIND_SO_PATH};
619
620                 $ENV{UID_WRAPPER} = "1";
621
622                 if ($winbindd ne "yes") {
623                         $SIG{USR1} = $SIG{ALRM} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
624                                 my $signame = shift;
625                                 print("Skip winbindd received signal $signame");
626                                 exit 0;
627                         };
628                         sleep($self->{server_maxtime});
629                         exit 0;
630                 }
631
632                 my @optargs = ("-d0");
633                 if (defined($ENV{WINBINDD_OPTIONS})) {
634                         @optargs = split(/ /, $ENV{WINBINDD_OPTIONS});
635                 }
636
637                 $ENV{MAKE_TEST_BINARY} = Samba::bindir_path($self, "winbindd");
638
639                 my @preargs = (Samba::bindir_path($self, "timelimit"), $self->{server_maxtime});
640                 if(defined($ENV{WINBINDD_VALGRIND})) {
641                         @preargs = split(/ /, $ENV{WINBINDD_VALGRIND});
642                 }
643
644                 print "Starting winbindd with config $env_vars->{SERVERCONFFILE}\n";
645
646                 close($env_vars->{STDIN_PIPE});
647                 open STDIN, ">&", \*STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
648
649                 exec(@preargs, Samba::bindir_path($self, "winbindd"), "-F", "--no-process-group", "--stdout", "-s", $env_vars->{SERVERCONFFILE}, @optargs) or die("Unable to start winbindd: $!");
650         }
651         $env_vars->{WINBINDD_TL_PID} = $pid;
652         write_pid($env_vars, "winbindd", $pid);
653         print "DONE\n";
654
655         unlink($env_vars->{SMBD_TEST_LOG});
656         print "STARTING SMBD...";
657         $pid = fork();
658         if ($pid == 0) {
659                 open STDOUT, ">$env_vars->{SMBD_TEST_LOG}";
660                 open STDERR, '>&STDOUT';
661
662                 SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
663
664                 $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
665                 $ENV{WINBINDD_SOCKET_DIR} = $env_vars->{WINBINDD_SOCKET_DIR};
666                 $ENV{NMBD_SOCKET_DIR} = $env_vars->{NMBD_SOCKET_DIR};
667
668                 $ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
669                 $ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
670                 $ENV{NSS_WRAPPER_WINBIND_SO_PATH} = $env_vars->{NSS_WRAPPER_WINBIND_SO_PATH};
671
672                 $ENV{UID_WRAPPER} = "1";
673
674                 if ($smbd ne "yes") {
675                         $SIG{USR1} = $SIG{ALRM} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
676                                 my $signame = shift;
677                                 print("Skip smbd received signal $signame");
678                                 exit 0;
679                         };
680                         sleep($self->{server_maxtime});
681                         exit 0;
682                 }
683
684                 $ENV{MAKE_TEST_BINARY} = Samba::bindir_path($self, "smbd");
685                 my @optargs = ("-d0");
686                 if (defined($ENV{SMBD_OPTIONS})) {
687                         @optargs = split(/ /, $ENV{SMBD_OPTIONS});
688                 }
689                 my @preargs = (Samba::bindir_path($self, "timelimit"), $self->{server_maxtime});
690                 if(defined($ENV{SMBD_VALGRIND})) {
691                         @preargs = split(/ /,$ENV{SMBD_VALGRIND});
692                 }
693
694                 close($env_vars->{STDIN_PIPE});
695                 open STDIN, ">&", \*STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
696
697                 exec(@preargs, Samba::bindir_path($self, "smbd"), "-F", "--no-process-group", "--log-stdout", "-s", $env_vars->{SERVERCONFFILE}, @optargs) or die("Unable to start smbd: $!");
698         }
699         $env_vars->{SMBD_TL_PID} = $pid;
700         write_pid($env_vars, "smbd", $pid);
701         print "DONE\n";
702
703         close(STDIN_READER);
704
705         return 0;
706 }
707
708 sub provision($$$$$$)
709 {
710         my ($self, $prefix, $server, $password, $extra_options, $no_delete_prefix) = @_;
711
712         ##
713         ## setup the various environment variables we need
714         ##
715
716         my $swiface = Samba::get_interface($server);
717         my %ret = ();
718         my $server_ip = "127.0.0.$swiface";
719         my $domain = "SAMBA-TEST";
720
721         my $unix_name = ($ENV{USER} or $ENV{LOGNAME} or `PATH=/usr/ucb:$ENV{PATH} whoami`);
722         chomp $unix_name;
723         my $unix_uid = $>;
724         my $unix_gids_str = $);
725         my @unix_gids = split(" ", $unix_gids_str);
726
727         my $prefix_abs = abs_path($prefix);
728         my $bindir_abs = abs_path($self->{bindir});
729         my $vfs_modulesdir_abs = ($ENV{VFSLIBDIR} or $bindir_abs);
730
731         my $dns_host_file = "$ENV{SELFTEST_PREFIX}/dns_host_file";
732
733         my @dirs = ();
734
735         my $shrdir="$prefix_abs/share";
736         push(@dirs,$shrdir);
737
738         my $libdir="$prefix_abs/lib";
739         push(@dirs,$libdir);
740
741         my $piddir="$prefix_abs/pid";
742         push(@dirs,$piddir);
743
744         my $privatedir="$prefix_abs/private";
745         push(@dirs,$privatedir);
746
747         my $lockdir="$prefix_abs/lockdir";
748         push(@dirs,$lockdir);
749
750         my $eventlogdir="$prefix_abs/lockdir/eventlog";
751         push(@dirs,$eventlogdir);
752
753         my $logdir="$prefix_abs/logs";
754         push(@dirs,$logdir);
755
756         my $driver32dir="$shrdir/W32X86";
757         push(@dirs,$driver32dir);
758
759         my $driver64dir="$shrdir/x64";
760         push(@dirs,$driver64dir);
761
762         my $driver40dir="$shrdir/WIN40";
763         push(@dirs,$driver40dir);
764
765         my $ro_shrdir="$shrdir/root-tmp";
766         push(@dirs,$ro_shrdir);
767
768         my $msdfs_shrdir="$shrdir/msdfsshare";
769         push(@dirs,$msdfs_shrdir);
770
771         my $msdfs_deeppath="$msdfs_shrdir/deeppath";
772         push(@dirs,$msdfs_deeppath);
773
774         # this gets autocreated by winbindd
775         my $wbsockdir="$prefix_abs/winbindd";
776         my $wbsockprivdir="$lockdir/winbindd_privileged";
777
778         my $nmbdsockdir="$prefix_abs/nmbd";
779         unlink($nmbdsockdir);
780
781         ## 
782         ## create the test directory layout
783         ##
784         die ("prefix_abs = ''") if $prefix_abs eq "";
785         die ("prefix_abs = '/'") if $prefix_abs eq "/";
786
787         mkdir($prefix_abs, 0777);
788         print "CREATE TEST ENVIRONMENT IN '$prefix'...";
789         if (not defined($no_delete_prefix) or not $no_delete_prefix) {
790             system("rm -rf $prefix_abs/*");
791         }
792         mkdir($_, 0777) foreach(@dirs);
793
794         ##
795         ## create ro and msdfs share layout
796         ##
797
798         chmod 0755, $ro_shrdir;
799         my $unreadable_file = "$ro_shrdir/unreadable_file";
800         unless (open(UNREADABLE_FILE, ">$unreadable_file")) {
801                 warn("Unable to open $unreadable_file");
802                 return undef;
803         }
804         close(UNREADABLE_FILE);
805         chmod 0600, $unreadable_file;
806
807         my $msdfs_target = "$ro_shrdir/msdfs-target";
808         unless (open(MSDFS_TARGET, ">$msdfs_target")) {
809                 warn("Unable to open $msdfs_target");
810                 return undef;
811         }
812         close(MSDFS_TARGET);
813         chmod 0666, $msdfs_target;
814         symlink "msdfs:$server_ip\\ro-tmp", "$msdfs_shrdir/msdfs-src1";
815         symlink "msdfs:$server_ip\\ro-tmp", "$msdfs_shrdir/deeppath/msdfs-src2";
816
817         my $conffile="$libdir/server.conf";
818
819         my $nss_wrapper_pl = "$ENV{PERL} $self->{srcdir}/lib/nss_wrapper/nss_wrapper.pl";
820         my $nss_wrapper_passwd = "$privatedir/passwd";
821         my $nss_wrapper_group = "$privatedir/group";
822
823         my $mod_printer_pl = "$ENV{PERL} $self->{srcdir}/source3/script/tests/printing/modprinter.pl";
824
825         my @eventlog_list = ("dns server", "application");
826
827         ##
828         ## calculate uids and gids
829         ##
830
831         my ($max_uid, $max_gid);
832         my ($uid_nobody, $uid_root);
833         my ($gid_nobody, $gid_nogroup, $gid_root, $gid_domusers);
834
835         if ($unix_uid < 0xffff - 2) {
836                 $max_uid = 0xffff;
837         } else {
838                 $max_uid = $unix_uid;
839         }
840
841         $uid_root = $max_uid - 1;
842         $uid_nobody = $max_uid - 2;
843
844         if ($unix_gids[0] < 0xffff - 3) {
845                 $max_gid = 0xffff;
846         } else {
847                 $max_gid = $unix_gids[0];
848         }
849
850         $gid_nobody = $max_gid - 1;
851         $gid_nogroup = $max_gid - 2;
852         $gid_root = $max_gid - 3;
853         $gid_domusers = $max_gid - 4;
854
855         ##
856         ## create conffile
857         ##
858
859         unless (open(CONF, ">$conffile")) {
860                 warn("Unable to open $conffile");
861                 return undef;
862         }
863         print CONF "
864 [global]
865         netbios name = $server
866         interfaces = $server_ip/8
867         bind interfaces only = yes
868         panic action = $self->{srcdir}/selftest/gdb_backtrace %d %\$(MAKE_TEST_BINARY)
869
870         workgroup = $domain
871
872         private dir = $privatedir
873         pid directory = $piddir
874         lock directory = $lockdir
875         log file = $logdir/log.\%m
876         log level = 1
877         debug pid = yes
878         max log size = 0
879
880         state directory = $lockdir
881         cache directory = $lockdir
882
883         passdb backend = tdbsam
884
885         time server = yes
886
887         add user script =               $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action add --name %u --gid $gid_nogroup
888         add group script =              $nss_wrapper_pl --group_path  $nss_wrapper_group  --type group  --action add --name %g
889         add machine script =            $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action add --name %u --gid $gid_nogroup
890         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
891         delete user script =            $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action delete --name %u
892         delete group script =           $nss_wrapper_pl --group_path  $nss_wrapper_group  --type group  --action delete --name %g
893         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
894
895         addprinter command =            $mod_printer_pl -a -s $conffile --
896         deleteprinter command =         $mod_printer_pl -d -s $conffile --
897
898         eventlog list = application \"dns server\"
899
900         kernel oplocks = no
901         kernel change notify = no
902
903         syslog = no
904         printing = bsd
905         printcap name = /dev/null
906
907         winbindd:socket dir = $wbsockdir
908         nmbd:socket dir = $nmbdsockdir
909         idmap config * : range = 100000-200000
910         winbind enum users = yes
911         winbind enum groups = yes
912
913 #       min receivefile size = 4000
914
915         max protocol = SMB2
916         read only = no
917         server signing = auto
918
919         smbd:sharedelay = 100000
920 #       smbd:writetimeupdatedelay = 500000
921         map hidden = no
922         map system = no
923         map readonly = no
924         store dos attributes = yes
925         create mask = 755
926         dos filemode = yes
927         vfs objects = $vfs_modulesdir_abs/xattr_tdb.so $vfs_modulesdir_abs/streams_depot.so
928
929         printing = vlp
930         print command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb print %p %s
931         lpq command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpq %p
932         lp rm command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lprm %p %j
933         lp pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lppause %p %j
934         lp resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpresume %p %j
935         queue pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queuepause %p
936         queue resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queueresume %p
937         lpq cache time = 0
938
939         ncalrpc dir = $prefix_abs/ncalrpc
940         rpc_server:epmapper = external
941         rpc_server:spoolss = external
942         rpc_server:lsarpc = external
943         rpc_server:samr = external
944         rpc_server:netlogon = external
945         rpc_server:tcpip = yes
946
947         rpc_daemon:epmd = fork
948         rpc_daemon:spoolssd = fork
949         rpc_daemon:lsasd = fork
950
951         resolv:host file = $dns_host_file
952
953         # The samba3.blackbox.smbclient_s3 test uses this to test that
954         # sending messages works, and that the %m sub works.
955         message command = mv %s $shrdir/message.%m
956
957         # Begin extra options
958         $extra_options
959         # End extra options
960
961         #Include user defined custom parameters if set
962 ";
963
964         if (defined($ENV{INCLUDE_CUSTOM_CONF})) {
965                 print CONF "\t$ENV{INCLUDE_CUSTOM_CONF}\n";
966         }
967
968         print CONF "
969 [tmp]
970         path = $shrdir
971         comment = smb username is [%U]
972 [tmpguest]
973         path = $shrdir
974         guest ok = yes
975 [guestonly]
976         path = $shrdir
977         guest only = yes
978         guest ok = yes
979 [forceuser]
980         path = $shrdir
981         force user = $unix_name
982         guest ok = yes
983 [forcegroup]
984         path = $shrdir
985         force group = nogroup
986         guest ok = yes
987 [ro-tmp]
988         path = $ro_shrdir
989         guest ok = yes
990 [msdfs-share]
991         path = $msdfs_shrdir
992         msdfs root = yes
993         guest ok = yes
994 [hideunread]
995         copy = tmp
996         hide unreadable = yes
997 [tmpcase]
998         copy = tmp
999         case sensitive = yes
1000 [hideunwrite]
1001         copy = tmp
1002         hide unwriteable files = yes
1003 [print1]
1004         copy = tmp
1005         printable = yes
1006
1007 [print2]
1008         copy = print1
1009 [print3]
1010         copy = print1
1011 [lp]
1012         copy = print1
1013 [xcopy_share]
1014         path = $shrdir
1015         comment = smb username is [%U]
1016         create mask = 777
1017         force create mode = 777
1018 [print\$]
1019         copy = tmp
1020         ";
1021         close(CONF);
1022
1023         ##
1024         ## create a test account
1025         ##
1026
1027         unless (open(PASSWD, ">$nss_wrapper_passwd")) {
1028            warn("Unable to open $nss_wrapper_passwd");
1029            return undef;
1030         } 
1031         print PASSWD "nobody:x:$uid_nobody:$gid_nobody:nobody gecos:$prefix_abs:/bin/false
1032 $unix_name:x:$unix_uid:$unix_gids[0]:$unix_name gecos:$prefix_abs:/bin/false
1033 ";
1034         if ($unix_uid != 0) {
1035                 print PASSWD "root:x:$uid_root:$gid_root:root gecos:$prefix_abs:/bin/false";
1036         }
1037         close(PASSWD);
1038
1039         unless (open(GROUP, ">$nss_wrapper_group")) {
1040              warn("Unable to open $nss_wrapper_group");
1041              return undef;
1042         }
1043         print GROUP "nobody:x:$gid_nobody:
1044 nogroup:x:$gid_nogroup:nobody
1045 $unix_name-group:x:$unix_gids[0]:
1046 domusers:X:$gid_domusers:
1047 ";
1048         if ($unix_gids[0] != 0) {
1049                 print GROUP "root:x:$gid_root:";
1050         }
1051
1052         close(GROUP);
1053
1054         foreach my $evlog (@eventlog_list) {
1055                 my $evlogtdb = "$eventlogdir/$evlog.tdb";
1056                 open(EVENTLOG, ">$evlogtdb") or die("Unable to open $evlogtdb");
1057                 close(EVENTLOG);
1058         }
1059
1060         $ENV{NSS_WRAPPER_PASSWD} = $nss_wrapper_passwd;
1061         $ENV{NSS_WRAPPER_GROUP} = $nss_wrapper_group;
1062
1063         my $cmd = Samba::bindir_path($self, "smbpasswd")." -c $conffile -L -s -a $unix_name > /dev/null";
1064         unless (open(PWD, "|$cmd")) {
1065              warn("Unable to set password for test account\n$cmd");
1066              return undef;
1067         }
1068         print PWD "$password\n$password\n";
1069         unless (close(PWD)) {
1070              warn("Unable to set password for test account\n$cmd");
1071              return undef; 
1072         }
1073         print "DONE\n";
1074
1075         open(HOSTS, ">>$ENV{SELFTEST_PREFIX}/dns_host_file") or die("Unable to open $ENV{SELFTEST_PREFIX}/dns_host_file");
1076         print HOSTS "A $server. $server_ip
1077 ";
1078         close(HOSTS);
1079
1080         $ret{SERVER_IP} = $server_ip;
1081         $ret{NMBD_TEST_LOG} = "$prefix/nmbd_test.log";
1082         $ret{NMBD_TEST_LOG_POS} = 0;
1083         $ret{WINBINDD_TEST_LOG} = "$prefix/winbindd_test.log";
1084         $ret{WINBINDD_TEST_LOG_POS} = 0;
1085         $ret{SMBD_TEST_LOG} = "$prefix/smbd_test.log";
1086         $ret{SMBD_TEST_LOG_POS} = 0;
1087         $ret{SERVERCONFFILE} = $conffile;
1088         $ret{CONFIGURATION} ="-s $conffile";
1089         $ret{SERVER} = $server;
1090         $ret{USERNAME} = $unix_name;
1091         $ret{USERID} = $unix_uid;
1092         $ret{DOMAIN} = $domain;
1093         $ret{NETBIOSNAME} = $server;
1094         $ret{PASSWORD} = $password;
1095         $ret{PIDDIR} = $piddir;
1096         $ret{WINBINDD_SOCKET_DIR} = $wbsockdir;
1097         $ret{WINBINDD_PRIV_PIPE_DIR} = $wbsockprivdir;
1098         $ret{NMBD_SOCKET_DIR} = $nmbdsockdir;
1099         $ret{SOCKET_WRAPPER_DEFAULT_IFACE} = $swiface;
1100         $ret{NSS_WRAPPER_PASSWD} = $nss_wrapper_passwd;
1101         $ret{NSS_WRAPPER_GROUP} = $nss_wrapper_group;
1102         $ret{NSS_WRAPPER_WINBIND_SO_PATH} = $ENV{NSS_WRAPPER_WINBIND_SO_PATH};
1103         if (not defined($ret{NSS_WRAPPER_WINBIND_SO_PATH})) {
1104                 $ret{NSS_WRAPPER_WINBIND_SO_PATH} = Samba::bindir_path($self, "default/nsswitch/libnss-winbind.so");
1105         }
1106         $ret{LOCAL_PATH} = "$shrdir";
1107
1108         return \%ret;
1109 }
1110
1111 sub wait_for_start($$)
1112 {
1113         my ($self, $envvars) = @_;
1114
1115         # give time for nbt server to register its names
1116         print "delaying for nbt name registration\n";
1117         sleep(10);
1118         # This will return quickly when things are up, but be slow if we need to wait for (eg) SSL init 
1119         system(Samba::bindir_path($self, "nmblookup3") ." $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} __SAMBA__");
1120         system(Samba::bindir_path($self, "nmblookup3") ." $envvars->{CONFIGURATION} __SAMBA__");
1121         system(Samba::bindir_path($self, "nmblookup3") ." $envvars->{CONFIGURATION} -U 127.255.255.255 __SAMBA__");
1122         system(Samba::bindir_path($self, "nmblookup3") ." $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} $envvars->{SERVER}");
1123         system(Samba::bindir_path($self, "nmblookup3") ." $envvars->{CONFIGURATION} $envvars->{SERVER}");
1124
1125         # make sure smbd is also up set
1126         print "wait for smbd\n";
1127
1128         my $count = 0;
1129         my $ret;
1130         do {
1131             $ret = system(Samba::bindir_path($self, "smbclient3") ." $envvars->{CONFIGURATION} -L $envvars->{SERVER} -U% -p 139");
1132             if ($ret != 0) {
1133                 sleep(2);
1134             }
1135             $count++
1136         } while ($ret != 0 && $count < 10);
1137         if ($count == 10) {
1138             print "SMBD failed to start up in a reasonable time (20sec)\n";
1139             teardown_env($self, $envvars);
1140             return 0;
1141         }
1142         # Ensure we have domain users mapped.
1143         $ret = system(Samba::bindir_path($self, "net") ." $envvars->{CONFIGURATION} groupmap add rid=513 unixgroup=domusers type=domain");
1144         if ($ret != 0) {
1145             return 1;
1146         }
1147
1148         print $self->getlog_env($envvars);
1149
1150         return 1;
1151 }
1152
1153 1;