Debian Codegraph @

selftest/target/Samba3.pm

raw
1 #!/usr/bin/perl
2 # Bootstrap Samba and run a number of tests against it.
3 # Copyright (C) 2005-2007 Jelmer Vernooij <[email protected]>
4 # Published under the GNU GPL, v3 or later.
5
6 # NOTE: Refer to the README for more details about the various testenvs,
7 # and tips about adding new testenvs.
8
9 package Samba3;
10
11 use strict;
12 use warnings;
13 use Cwd qw(abs_path);
14 use FindBin qw($RealBin);
15 use POSIX;
16 use target::Samba;
17 use File::Path 'remove_tree';
18
19 sub return_alias_env
20 {
21 my ($self, $path, $env) = @_;
22
23 # just an alias
24 return $env;
25 }
26
27 sub have_ads($) {
28 my ($self) = @_;
29 my $found_ads = 0;
30 my $smbd_build_options = Samba::bindir_path($self, "smbd") . " --configfile=/dev/null -b|";
31 open(IN, $smbd_build_options) or die("Unable to run $smbd_build_options: $!");
32
33 while (<IN>) {
34 if (/HAVE_ADS/) {
35 $found_ads = 1;
36 }
37 }
38 close IN;
39
40 # If we were not built with ADS support, pretend we were never even available
41 print "smbd does not have ADS support\n" unless $found_ads;
42 return $found_ads;
43 }
44
45 # return smb.conf parameters applicable to @path, based on the underlying
46 # filesystem type
47 sub get_fs_specific_conf($$)
48 {
49 my ($self, $path) = @_;
50 my $mods = "";
51 my $stat_out = `stat --file-system $path` or return "";
52
53 if ($stat_out =~ m/Type:\s+btrfs/) {
54 $mods .= "streams_xattr btrfs";
55 }
56
57 if ($mods) {
58 return "vfs objects = $mods";
59 }
60
61 return '';
62 }
63
64 sub new($$) {
65 my ($classname, $SambaCtx, $bindir, $srcdir, $server_maxtime) = @_;
66 my $self = { vars => {},
67 SambaCtx => $SambaCtx,
68 bindir => $bindir,
69 srcdir => $srcdir,
70 server_maxtime => $server_maxtime
71 };
72 bless $self;
73 return $self;
74 }
75
76 sub teardown_env($$)
77 {
78 my ($self, $envvars) = @_;
79
80 if (defined($envvars->{CTDB_PREFIX})) {
81 $self->teardown_env_ctdb($envvars);
82 } else {
83 $self->teardown_env_samba($envvars);
84 }
85
86 return;
87 }
88
89 sub teardown_env_samba($$)
90 {
91 my ($self, $envvars) = @_;
92 my $count = 0;
93
94 # This should cause smbd to terminate gracefully
95 close($envvars->{STDIN_PIPE});
96
97 my $smbdpid = $envvars->{SMBD_TL_PID};
98 my $nmbdpid = $envvars->{NMBD_TL_PID};
99 my $winbinddpid = $envvars->{WINBINDD_TL_PID};
100 my $samba_dcerpcdpid = $envvars->{SAMBA_DCERPCD_TL_PID};
101
102 # This should give it time to write out the gcov data
103 until ($count > 20) {
104 my $smbdchild = Samba::cleanup_child($smbdpid, "smbd");
105 my $nmbdchild = Samba::cleanup_child($nmbdpid, "nmbd");
106 my $winbinddchild = Samba::cleanup_child($winbinddpid, "winbindd");
107 my $samba_dcerpcdchild = Samba::cleanup_child(
108 $samba_dcerpcdpid, "samba-dcerpcd");
109 if ($smbdchild == -1
110 && $nmbdchild == -1
111 && $winbinddchild == -1
112 && $samba_dcerpcdpid == -1) {
113 last;
114 }
115 sleep(1);
116 $count++;
117 }
118
119 if ($count <= 20 &&
120 kill(0, $smbdpid, $nmbdpid, $winbinddpid, $samba_dcerpcdpid) == 0) {
121 return;
122 }
123
124 $self->stop_sig_term($smbdpid);
125 $self->stop_sig_term($nmbdpid);
126 $self->stop_sig_term($winbinddpid);
127 $self->stop_sig_term($samba_dcerpcdpid);
128
129 $count = 0;
130 until ($count > 10) {
131 my $smbdchild = Samba::cleanup_child($smbdpid, "smbd");
132 my $nmbdchild = Samba::cleanup_child($nmbdpid, "nmbd");
133 my $winbinddchild = Samba::cleanup_child($winbinddpid, "winbindd");
134 my $samba_dcerpcdpid = Samba::cleanup_child(
135 $samba_dcerpcdpid, "samba-dcerpcd");
136 if ($smbdchild == -1
137 && $nmbdchild == -1
138 && $winbinddchild == -1
139 && $samba_dcerpcdpid == -1) {
140 last;
141 }
142 sleep(1);
143 $count++;
144 }
145
146 if ($count <= 10 &&
147 kill(0, $smbdpid, $nmbdpid, $winbinddpid, $samba_dcerpcdpid) == 0) {
148 return;
149 }
150
151 warn("timelimit process did not quit on SIGTERM, sending SIGKILL");
152 $self->stop_sig_kill($smbdpid);
153 $self->stop_sig_kill($nmbdpid);
154 $self->stop_sig_kill($winbinddpid);
155 $self->stop_sig_kill($samba_dcerpcdpid);
156
157 return 0;
158 }
159
160 sub teardown_env_ctdb($$)
161 {
162 my ($self, $data) = @_;
163
164 if (defined($data->{SAMBA_NODES})) {
165 my $num_nodes = $data->{NUM_NODES};
166 my $nodes = $data->{SAMBA_NODES};
167
168 for (my $i = 0; $i < $num_nodes; $i++) {
169 if (defined($nodes->[$i])) {
170 $self->teardown_env_samba($nodes->[$i]);
171 }
172 }
173 }
174
175 close($data->{CTDB_STDIN_PIPE});
176
177 if (not defined($data->{SAMBA_NODES})) {
178 # Give waiting children time to exit
179 sleep(5);
180 }
181
182 return 0;
183 }
184
185 sub getlog_env_app($$$)
186 {
187 my ($self, $envvars, $name) = @_;
188
189 my $title = "$name LOG of: $envvars->{NETBIOSNAME}\n";
190 my $out = $title;
191
192 open(LOG, "<".$envvars->{$name."_TEST_LOG"});
193
194 seek(LOG, $envvars->{$name."_TEST_LOG_POS"}, SEEK_SET);
195 while (<LOG>) {
196 $out .= $_;
197 }
198 $envvars->{$name."_TEST_LOG_POS"} = tell(LOG);
199 close(LOG);
200
201 return "" if $out eq $title;
202
203 return $out;
204 }
205
206 sub getlog_env($$)
207 {
208 my ($self, $envvars) = @_;
209 my $ret = "";
210
211 $ret .= $self->getlog_env_app($envvars, "SMBD");
212 $ret .= $self->getlog_env_app($envvars, "NMBD");
213 $ret .= $self->getlog_env_app($envvars, "WINBINDD");
214
215 return $ret;
216 }
217
218 sub check_env($$)
219 {
220 my ($self, $envvars) = @_;
221
222 my $childpid = waitpid(-1, WNOHANG);
223
224 # TODO ...
225 return 1;
226 }
227
228 # Declare the environments Samba3 makes available.
229 # To be set up, they will be called as
230 # samba3->setup_$envname($self, $path, $dep_1_vars, $dep_2_vars, ...)
231 %Samba3::ENV_DEPS = (
232 # name => [dep_1, dep_2, ...],
233 nt4_dc => [],
234 nt4_dc_smb1 => [],
235 nt4_dc_smb1_done => ["nt4_dc_smb1"],
236 nt4_dc_schannel => [],
237
238 simpleserver => [],
239 fileserver => [],
240 fileserver_smb1 => [],
241 fileserver_smb1_done => ["fileserver_smb1"],
242 maptoguest => [],
243 ktest => [],
244
245 nt4_member => ["nt4_dc"],
246
247 ad_member => ["ad_dc", "fl2008r2dc", "fl2003dc"],
248 ad_member_rfc2307 => ["ad_dc_ntvfs"],
249 ad_member_idmap_rid => ["ad_dc"],
250 admem_idmap_autorid => ["ad_dc"],
251 ad_member_idmap_ad => ["fl2008r2dc"],
252 ad_member_fips => ["ad_dc_fips"],
253 ad_member_offlogon => ["ad_dc"],
254 ad_member_oneway => ["fl2000dc"],
255 ad_member_idmap_nss => ["ad_dc"],
256 ad_member_s3_join => ["vampire_dc"],
257
258 clusteredmember => ["ad_dc"],
259 );
260
261 %Samba3::ENV_DEPS_POST = ();
262
263 sub setup_nt4_dc
264 {
265 my ($self, $path, $more_conf, $domain, $server) = @_;
266
267 print "PROVISIONING NT4 DC...";
268
269 my $nt4_dc_options = "
270 domain master = yes
271 domain logons = yes
272 lanman auth = yes
273 ntlm auth = yes
274 raw NTLMv2 auth = yes
275 rpc start on demand helpers = false
276
277 CVE_2020_1472:warn_about_unused_debug_level = 3
278 server require schannel:schannel0\$ = no
279 server require schannel:schannel1\$ = no
280 server require schannel:schannel2\$ = no
281 server require schannel:schannel3\$ = no
282 server require schannel:schannel4\$ = no
283 server require schannel:schannel5\$ = no
284 server require schannel:schannel6\$ = no
285 server require schannel:schannel7\$ = no
286 server require schannel:schannel8\$ = no
287 server require schannel:schannel9\$ = no
288 server require schannel:schannel10\$ = no
289 server require schannel:schannel11\$ = no
290 server require schannel:torturetest\$ = no
291
292 server schannel require seal:schannel0\$ = no
293 server schannel require seal:schannel1\$ = no
294 server schannel require seal:schannel2\$ = no
295 server schannel require seal:schannel3\$ = no
296 server schannel require seal:schannel4\$ = no
297 server schannel require seal:schannel5\$ = no
298 server schannel require seal:schannel6\$ = no
299 server schannel require seal:schannel7\$ = no
300 server schannel require seal:schannel8\$ = no
301 server schannel require seal:schannel9\$ = no
302 server schannel require seal:schannel10\$ = no
303 server schannel require seal:schannel11\$ = no
304 server schannel require seal:torturetest\$ = no
305
306 vfs_default:VFS_OPEN_HOW_RESOLVE_NO_SYMLINKS = no
307 vfs_default:VFS_OPEN_HOW_RESOLVE_NO_XDEV = no
308
309 fss: sequence timeout = 1
310 check parent directory delete on close = yes
311 ";
312
313 if (defined($more_conf)) {
314 $nt4_dc_options = $nt4_dc_options . $more_conf;
315 }
316 if (!defined($domain)) {
317 $domain = "SAMBA-TEST";
318 }
319 if (!defined($server)) {
320 $server = "LOCALNT4DC2";
321 }
322 my $vars = $self->provision(
323 prefix => $path,
324 domain => $domain,
325 server => $server,
326 password => "localntdc2pass",
327 extra_options => $nt4_dc_options);
328
329 $vars or return undef;
330
331 if (not $self->check_or_start(
332 env_vars => $vars,
333 samba_dcerpcd => "yes",
334 nmbd => "yes",
335 winbindd => "yes",
336 smbd => "yes")) {
337 return undef;
338 }
339
340 $vars->{DOMSID} = $vars->{SAMSID};
341 $vars->{DC_SERVER} = $vars->{SERVER};
342 $vars->{DC_SERVER_IP} = $vars->{SERVER_IP};
343 $vars->{DC_SERVER_IPV6} = $vars->{SERVER_IPV6};
344 $vars->{DC_NETBIOSNAME} = $vars->{NETBIOSNAME};
345 $vars->{DC_USERNAME} = $vars->{USERNAME};
346 $vars->{DC_PASSWORD} = $vars->{PASSWORD};
347
348 return $vars;
349 }
350
351 sub setup_nt4_dc_smb1
352 {
353 my ($self, $path) = @_;
354 my $conf = "
355 [global]
356 client min protocol = CORE
357 server min protocol = LANMAN1
358 ";
359 return $self->setup_nt4_dc($path, $conf, "NT4SMB1", "LCLNT4DC2SMB1");
360 }
361
362 sub setup_nt4_dc_smb1_done
363 {
364 my ($self, $path, $dep_env) = @_;
365 return $self->return_alias_env($path, $dep_env);
366 }
367
368 sub setup_nt4_dc_schannel
369 {
370 my ($self, $path) = @_;
371
372 print "PROVISIONING NT4 DC WITH SERVER SCHANNEL ...";
373
374 my $pdc_options = "
375 domain master = yes
376 domain logons = yes
377 lanman auth = yes
378
379 server schannel = yes
380 # used to reproduce bug #12772
381 server max protocol = SMB2_02
382 ";
383
384 my $vars = $self->provision(
385 prefix => $path,
386 domain => "NT4SCHANNEL",
387 server => "LOCALNT4DC9",
388 password => "localntdc9pass",
389 extra_options => $pdc_options);
390
391 $vars or return undef;
392
393 if (not $self->check_or_start(
394 env_vars => $vars,
395 nmbd => "yes",
396 winbindd => "yes",
397 smbd => "yes")) {
398 return undef;
399 }
400
401 $vars->{DOMSID} = $vars->{SAMSID};
402 $vars->{DC_SERVER} = $vars->{SERVER};
403 $vars->{DC_SERVER_IP} = $vars->{SERVER_IP};
404 $vars->{DC_SERVER_IPV6} = $vars->{SERVER_IPV6};
405 $vars->{DC_NETBIOSNAME} = $vars->{NETBIOSNAME};
406 $vars->{DC_USERNAME} = $vars->{USERNAME};
407 $vars->{DC_PASSWORD} = $vars->{PASSWORD};
408
409 return $vars;
410 }
411
412 sub setup_nt4_member
413 {
414 my ($self, $prefix, $nt4_dc_vars) = @_;
415 my $count = 0;
416 my $rc;
417
418 print "PROVISIONING MEMBER...";
419
420 my $require_mutexes = "dbwrap_tdb_require_mutexes:* = yes";
421 if ($ENV{SELFTEST_DONT_REQUIRE_TDB_MUTEX_SUPPORT} // '' eq "1") {
422 $require_mutexes = "";
423 }
424
425 my $member_options = "
426 security = domain
427 lanman auth = yes
428 ntlm auth = yes
429 dbwrap_tdb_mutexes:* = yes
430 ${require_mutexes}
431 ";
432 my $ret = $self->provision(
433 prefix => $prefix,
434 domain => $nt4_dc_vars->{DOMAIN},
435 server => "LOCALNT4MEMBER3",
436 password => "Lnt4member3p14",
437 extra_options_before_inject => $member_options);
438
439 $ret or return undef;
440
441 my $nmblookup = Samba::bindir_path($self, "nmblookup");
442 do {
443 print "Waiting for the LOGON SERVER registration ...\n";
444 $rc = system("$nmblookup $ret->{CONFIGURATION} $ret->{DOMAIN}\#1c");
445 if ($rc != 0) {
446 sleep(1);
447 }
448 $count++;
449 } while ($rc != 0 && $count < 10);
450 if ($count == 10) {
451 print "NMBD not reachable after 10 retries\n";
452 teardown_env($self, $ret);
453 return 0;
454 }
455
456 my $net = Samba::bindir_path($self, "net");
457 # Add hosts file for name lookups
458 my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
459 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
460 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
461 $cmd .= "$net rpc join $ret->{CONFIGURATION} $nt4_dc_vars->{DOMAIN} member";
462 $cmd .= " -U$nt4_dc_vars->{USERNAME}\%$nt4_dc_vars->{PASSWORD}";
463
464 if (system($cmd) != 0) {
465 warn("Join failed\n$cmd");
466 return undef;
467 }
468
469 # Add hosts file for name lookups
470 $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
471 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
472 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
473 $cmd .= "$net $ret->{CONFIGURATION} primarytrust dumpinfo | grep -q 'REDACTED SECRET VALUES'";
474
475 if (system($cmd) != 0) {
476 warn("check failed\n$cmd");
477 return undef;
478 }
479
480 if (not $self->check_or_start(
481 env_vars => $ret,
482 nmbd => "yes",
483 winbindd => "yes",
484 smbd => "yes")) {
485 return undef;
486 }
487
488 $ret->{DOMSID} = $nt4_dc_vars->{DOMSID};
489 $ret->{DC_SERVER} = $nt4_dc_vars->{SERVER};
490 $ret->{DC_SERVER_IP} = $nt4_dc_vars->{SERVER_IP};
491 $ret->{DC_SERVER_IPV6} = $nt4_dc_vars->{SERVER_IPV6};
492 $ret->{DC_NETBIOSNAME} = $nt4_dc_vars->{NETBIOSNAME};
493 $ret->{DC_USERNAME} = $nt4_dc_vars->{USERNAME};
494 $ret->{DC_PASSWORD} = $nt4_dc_vars->{PASSWORD};
495
496 return $ret;
497 }
498
499 sub setup_clusteredmember
500 {
501 my ($self, $prefix, $dcvars) = @_;
502 my $count = 0;
503 my $rc;
504 my @retvals = ();
505 my $ret;
506
507 print "PROVISIONING CLUSTEREDMEMBER...\n";
508
509 mkdir($prefix, 0777);
510
511 my $ctdb_data = $self->setup_ctdb($prefix);
512
513 if (not $ctdb_data) {
514 print "No ctdb data\n";
515 return undef;
516 }
517
518 print "PROVISIONING CLUSTERED SAMBA...\n";
519
520 my $num_nodes = $ctdb_data->{NUM_NODES};
521 my $nodes = $ctdb_data->{CTDB_NODES};
522
523 # Enable cleanup of earlier nodes if a later node fails
524 $ctdb_data->{SAMBA_NODES} = \@retvals;
525
526 for (my $i = 0; $i < $num_nodes; $i++) {
527 my $node = $nodes->[$i];
528 my $socket = $node->{SOCKET_FILE};
529 my $server_name = $node->{SERVER_NAME};
530 my $pub_iface = $node->{SOCKET_WRAPPER_DEFAULT_IFACE};
531 my $node_prefix = $node->{NODE_PREFIX};
532
533 print "CTDB_BASE=${node_prefix}\n";
534 print "CTDB_SOCKET=${socket}\n";
535
536 my $require_mutexes = "dbwrap_tdb_require_mutexes:* = yes";
537 if ($ENV{SELFTEST_DONT_REQUIRE_TDB_MUTEX_SUPPORT} // '' eq "1") {
538 $require_mutexes = "" ;
539 }
540
541 my $member_options = "
542 security = ADS
543 workgroup = $dcvars->{DOMAIN}
544 realm = $dcvars->{REALM}
545 password server = $dcvars->{SERVER}
546 server signing = on
547 clustering = yes
548 rpc start on demand helpers = false
549 rpcd witness:include node ips = yes
550 ctdbd socket = ${socket}
551 include = registry
552 dbwrap_tdb_mutexes:* = yes
553 ${require_mutexes}
554 sync machine password to keytab = $node_prefix/keytab0:account_name:machine_password:sync_kvno
555 ";
556
557 my $node_ret = $self->provision(
558 prefix => "$node_prefix",
559 domain => $dcvars->{DOMAIN},
560 server => "$server_name",
561 password => "clustermember8pass",
562 netbios_name => "CLUSTEREDMEMBER",
563 share_dir => "${prefix}/shared",
564 extra_options => $member_options,
565 no_delete_prefix => 1);
566 if (not $node_ret) {
567 print "Provision node $i failed\n";
568 teardown_env($self, $ctdb_data);
569 return undef;
570 }
571
572 my $registry_share_template = "$node_ret->{SERVERCONFFILE}.registry_share_template";
573 unless (open(REGISTRYCONF, ">$registry_share_template")) {
574 warn("Unable to open $registry_share_template");
575 teardown_env($self, $node_ret);
576 teardown_env($self, $ctdb_data);
577 return undef;
578 }
579
580 print REGISTRYCONF "
581 [registry_share]
582 copy = tmp
583 comment = smb username is [%U]
584 ";
585
586 close(REGISTRYCONF);
587
588 my $net = Samba::bindir_path($self, "net");
589 my $cmd = "";
590
591 $cmd .= "UID_WRAPPER_ROOT=1 ";
592 $cmd .= "$net conf import $node_ret->{CONFIGURATION} ${registry_share_template}";
593
594 my $net_ret = system($cmd);
595 if ($net_ret != 0) {
596 warn("net conf import failed: $net_ret\n$cmd");
597 teardown_env($self, $node_ret);
598 teardown_env($self, $ctdb_data);
599 return undef;
600 }
601
602 my $nmblookup = Samba::bindir_path($self, "nmblookup");
603 do {
604 print "Waiting for the LOGON SERVER registration ...\n";
605 $rc = system("$nmblookup $node_ret->{CONFIGURATION} " .
606 "$node_ret->{DOMAIN}\#1c");
607 if ($rc != 0) {
608 sleep(1);
609 }
610 $count++;
611 } while ($rc != 0 && $count < 10);
612
613 if ($count == 10) {
614 print "NMBD not reachable after 10 retries\n";
615 teardown_env($self, $node_ret);
616 teardown_env($self, $ctdb_data);
617 return undef;
618 }
619
620 push(@retvals, $node_ret);
621 }
622
623 $ret = {%$ctdb_data, %{$retvals[0]}};
624
625 my $ctx;
626 $ctx = {};
627 $ctx->{krb5_conf} = "$prefix/lib/krb5.conf";
628 $ctx->{domain} = $dcvars->{DOMAIN};
629 $ctx->{realm} = $dcvars->{REALM};
630 $ctx->{dnsname} = lc($dcvars->{REALM});
631 $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
632 $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
633 $ctx->{krb5_ccname} = "$prefix/krb5cc_%{uid}";
634
635 # Create lib directory for krb5.conf
636 mkdir("$prefix/lib", 0755);
637
638 Samba::mk_krb5_conf($ctx, "");
639
640 $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
641
642 my $net = Samba::bindir_path($self, "net");
643 my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
644 $cmd .= "UID_WRAPPER_ROOT=1 ";
645 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
646 $cmd .= "RESOLV_CONF=\"$ret->{RESOLV_CONF}\" ";
647 $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
648 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
649 $cmd .= "$net join $ret->{CONFIGURATION} $dcvars->{DOMAIN} member";
650 $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
651
652 if (system($cmd) != 0) {
653 warn("Join failed\n$cmd");
654 teardown_env($self, $ret);
655 return undef;
656 }
657
658 for (my $i=0; $i<@retvals; $i++) {
659 my $node_provision = $retvals[$i];
660 my $ok;
661 $ok = $self->check_or_start(
662 env_vars => $node_provision,
663 samba_dcerpcd => "yes",
664 winbindd => "yes",
665 smbd => "yes",
666 child_cleanup => sub {
667 map {
668 my $fh = $_->{STDIN_PIPE};
669 close($fh) if defined($fh);
670 } @retvals });
671 if (not $ok) {
672 teardown_env($self, $ret);
673 return undef;
674 }
675 }
676
677 #
678 # Build a unclist for every share
679 #
680 unless (open(NODES, "<$ret->{CTDB_NODES_FILE}")) {
681 warn("Unable to open CTDB nodes file");
682 teardown_env($self, $ret);
683 return undef;
684 }
685 my @nodes = <NODES>;
686 close(NODES);
687 chomp @nodes;
688
689 my $conffile = $ret->{SERVERCONFFILE};
690 $cmd = "";
691 $cmd .= 'sed -n -e \'s|^\[\(.*\)\]$|\1|p\'';
692 $cmd .= " \"$conffile\"";
693 $cmd .= " | grep -vx 'global'";
694
695 my @shares = `$cmd`;
696 $rc = $?;
697 if ($rc != 0) {
698 warn("Listing shares failed\n$cmd");
699 teardown_env($self, $ret);
700 return undef;
701 }
702 chomp @shares;
703
704 my $unclistdir = "${prefix}/unclists";
705 mkdir($unclistdir, 0777);
706 foreach my $share (@shares) {
707 my $l = "${unclistdir}/${share}.txt";
708 unless (open(UNCLIST, ">${l}")) {
709 warn("Unable to open UNC list ${l}");
710 teardown_env($self, $ret);
711 return undef;
712 }
713 foreach my $node (@nodes) {
714 print UNCLIST "//${node}/${share}\n";
715 }
716 close(UNCLIST);
717 }
718
719 $ret->{DOMSID} = $dcvars->{DOMSID};
720 $ret->{DC_SERVER} = $dcvars->{SERVER};
721 $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
722 $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
723 $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
724 $ret->{DC_USERNAME} = $dcvars->{USERNAME};
725 $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
726 $ret->{REALM} = $dcvars->{REALM};
727 $ret->{DOMAIN} = $dcvars->{DOMAIN};
728
729 return $ret;
730 }
731
732 sub provision_ad_member
733 {
734 my ($self,
735 $prefix,
736 $machine_account,
737 $dcvars,
738 $trustvars_f,
739 $trustvars_e,
740 $extra_member_options,
741 $force_fips_mode,
742 $offline_logon,
743 $no_nss_winbind,
744 $sync_pw2keytab) = @_;
745
746 if (defined($offline_logon) && defined($no_nss_winbind)) {
747 warn ("Offline logon incompatible with no nss winbind\n");
748 return undef;
749 }
750
751 my @dirs = ();
752
753 mkdir($prefix, 0777);
754
755 my $share_dir="$prefix/share";
756 push(@dirs, $share_dir);
757
758 my $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}";
759 push(@dirs, $substitution_path);
760
761 $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/U_alice";
762 push(@dirs, $substitution_path);
763
764 $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/U_alice/G_domain users";
765 push(@dirs, $substitution_path);
766
767 # Using '/' as the winbind separator is a bad idea ...
768 $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/u_$dcvars->{DOMAIN}";
769 push(@dirs, $substitution_path);
770
771 $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/u_$dcvars->{DOMAIN}/alice";
772 push(@dirs, $substitution_path);
773
774 $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/u_$dcvars->{DOMAIN}/alice/g_$dcvars->{DOMAIN}";
775 push(@dirs, $substitution_path);
776
777 $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/u_$dcvars->{DOMAIN}/alice/g_$dcvars->{DOMAIN}/domain users";
778 push(@dirs, $substitution_path);
779
780 my $smbcacls_sharedir="$share_dir/smbcacls";
781 push(@dirs,$smbcacls_sharedir);
782
783 my $option_offline_logon = "no";
784 if (defined($offline_logon)) {
785 $option_offline_logon = "yes";
786 }
787
788 my $netbios_aliases = "";
789 if ($machine_account eq "LOCALADMEMBER") {
790 $netbios_aliases = "netbios aliases = foo bar";
791 }
792
793 unless (defined($extra_member_options)) {
794 $extra_member_options = "";
795 }
796
797 my $dns_and_netbios = "";
798 my $keytab = "";
799 if (defined($sync_pw2keytab)) {
800 $dns_and_netbios = "
801 additional dns hostnames = host1.example.com host2.other.com
802 netbios aliases = NETBIOS1 NETBIOS2 NETBIOS3
803 ";
804 $keytab = "
805 sync machine password to keytab = \\
806 \"$prefix/keytab0:account_name:machine_password\", \\
807 \"$prefix/keytab0k:account_name:sync_kvno:machine_password:sync_etypes\", \\
808 \"$prefix/keytab1:sync_spns:machine_password:sync_etypes\", \\
809 \"$prefix/keytab1k:sync_spns:sync_kvno:machine_password:sync_etypes\", \\
810 \"$prefix/keytab2:spn_prefixes=host,imap,smtp:additional_dns_hostnames:netbios_aliases:machine_password:sync_etypes\", \\
811 \"$prefix/keytab2k:spn_prefixes=host,imap,smtp:additional_dns_hostnames:sync_kvno:machine_password:sync_etypes\", \\
812 \"$prefix/keytab3:spns=wurst/brot\@$dcvars->{REALM}:machine_password:sync_etypes\", \\
813 \"$prefix/keytab3k:spns=wurst/brot\@$dcvars->{REALM},wurst1/brot\@$dcvars->{REALM},wurst2/brot\@$dcvars->{REALM}:sync_kvno:machine_password:sync_etypes\", \\
814 \"$prefix/keytab4k:account_name:sync_account_name:spn_prefixes=host,imap,smtp:additional_dns_hostnames:netbios_aliases:spns=wurst/brot\@$dcvars->{REALM},wurst1/brot\@$dcvars->{REALM},wurst2/brot\@$dcvars->{REALM}:sync_kvno:machine_password:sync_etypes\"
815 ";
816 }
817
818 my $member_options = "
819 security = ads
820 workgroup = $dcvars->{DOMAIN}
821 realm = $dcvars->{REALM}
822 $netbios_aliases
823 template homedir = /home/%D/%G/%U
824 auth event notification = true
825 password server = $dcvars->{SERVER}
826 winbind scan trusted domains = no
827 winbind offline logon = $option_offline_logon
828
829 allow dcerpc auth level connect:lsarpc = yes
830 dcesrv:max auth states = 8
831 rpc start on demand helpers = false
832
833 # Begin extra member options
834 $extra_member_options
835 # End extra member options
836 $dns_and_netbios
837 $keytab
838
839 [sub_dug]
840 path = $share_dir/D_%D/U_%U/G_%G
841 writeable = yes
842
843 [sub_dug2]
844 path = $share_dir/D_%D/u_%u/g_%g
845 writeable = yes
846
847 [sub_valid_users]
848 path = $share_dir
849 valid users = ADDOMAIN/%U
850
851 [sub_valid_users_domain]
852 path = $share_dir
853 valid users = %D/%U
854
855 [sub_valid_users_group]
856 path = $share_dir
857 valid users = \@$dcvars->{DOMAIN}/%G
858
859 [valid_users]
860 path = $share_dir
861 valid users = $dcvars->{DOMAIN}/$dcvars->{DC_USERNAME}
862
863 [valid_users_group]
864 path = $share_dir
865 valid users = \"\@$dcvars->{DOMAIN}/domain users\"
866
867 [valid_users_unix_group]
868 path = $share_dir
869 valid users = \"+$dcvars->{DOMAIN}/domain users\"
870
871 [valid_users_nis_group]
872 path = $share_dir
873 valid users = \"&$dcvars->{DOMAIN}/domain users\"
874
875 [valid_users_unix_nis_group]
876 path = $share_dir
877 valid users = \"+&$dcvars->{DOMAIN}/domain users\"
878
879 [valid_users_nis_unix_group]
880 path = $share_dir
881 valid users = \"&+$dcvars->{DOMAIN}/domain users\"
882
883 [invalid_users]
884 path = $share_dir
885 invalid users = $dcvars->{DOMAIN}/$dcvars->{DC_USERNAME}
886
887 [valid_and_invalid_users]
888 path = $share_dir
889 valid users = $dcvars->{DOMAIN}/$dcvars->{DC_USERNAME} $dcvars->{DOMAIN}/alice
890 invalid users = $dcvars->{DOMAIN}/$dcvars->{DC_USERNAME}
891 ";
892
893 my $ret = $self->provision(
894 prefix => $prefix,
895 domain => $dcvars->{DOMAIN},
896 realm => $dcvars->{REALM},
897 server => $machine_account,
898 password => "loCalMemberPass",
899 extra_options => $member_options,
900 resolv_conf => $dcvars->{RESOLV_CONF});
901
902 $ret or return undef;
903
904 mkdir($_, 0777) foreach(@dirs);
905
906 $ret->{DOMAIN} = $dcvars->{DOMAIN};
907 $ret->{REALM} = $dcvars->{REALM};
908 $ret->{DOMSID} = $dcvars->{DOMSID};
909
910 my $ctx;
911 $ctx = {};
912 $ctx->{krb5_conf} = "$prefix/lib/krb5.conf";
913 $ctx->{domain} = $dcvars->{DOMAIN};
914 $ctx->{realm} = $dcvars->{REALM};
915 $ctx->{dnsname} = lc($dcvars->{REALM});
916 $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
917 $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
918 $ctx->{krb5_ccname} = "$prefix/krb5cc_%{uid}";
919 Samba::mk_krb5_conf($ctx, "");
920
921 $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
922
923 if (defined($force_fips_mode)) {
924 $ret->{GNUTLS_FORCE_FIPS_MODE} = "1";
925 $ret->{OPENSSL_FORCE_FIPS_MODE} = "1";
926 }
927
928 my $net = Samba::bindir_path($self, "net");
929 # Add hosts file for name lookups
930 my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
931 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
932 if (defined($ret->{RESOLV_WRAPPER_CONF})) {
933 $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
934 } else {
935 $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
936 }
937 if (defined($force_fips_mode)) {
938 $cmd .= "GNUTLS_FORCE_FIPS_MODE=1 ";
939 $cmd .= "OPENSSL_FORCE_FIPS_MODE=1 ";
940 }
941 $cmd .= "RESOLV_CONF=\"$ret->{RESOLV_CONF}\" ";
942 $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
943 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
944 $cmd .= "$net join $ret->{CONFIGURATION}";
945 $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD} --use-kerberos=required";
946
947 if (system($cmd) != 0) {
948 warn("Join failed\n$cmd");
949 return undef;
950 }
951
952 # We need world access to this share, as otherwise the domain
953 # administrator from the AD domain provided by Samba4 can't
954 # access the share for tests.
955 chmod 0777, "$prefix/share";
956
957 if (defined($offline_logon)) {
958 my $wbinfo = Samba::bindir_path($self, "wbinfo");
959
960 if (not $self->check_or_start(
961 env_vars => $ret,
962 winbindd => "yes")) {
963 return undef;
964 }
965
966 # Fill samlogoncache for alice
967 $cmd = "NSS_WRAPPER_PASSWD='$ret->{NSS_WRAPPER_PASSWD}' ";
968 $cmd .= "NSS_WRAPPER_GROUP='$ret->{NSS_WRAPPER_GROUP}' ";
969 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
970 $cmd .= "$wbinfo --pam-logon=ADDOMAIN/alice%Secret007";
971 if (system($cmd) != 0) {
972 warn("Filling the cache failed\n$cmd");
973 return undef;
974 }
975
976 $cmd = "NSS_WRAPPER_PASSWD='$ret->{NSS_WRAPPER_PASSWD}' ";
977 $cmd .= "NSS_WRAPPER_GROUP='$ret->{NSS_WRAPPER_GROUP}' ";
978 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
979 $cmd .= "$wbinfo --ccache-save=ADDOMAIN/alice%Secret007";
980 if (system($cmd) != 0) {
981 warn("Filling the cache failed\n$cmd");
982 return undef;
983 }
984
985 # Fill samlogoncache for bob
986 $cmd = "NSS_WRAPPER_PASSWD='$ret->{NSS_WRAPPER_PASSWD}' ";
987 $cmd .= "NSS_WRAPPER_GROUP='$ret->{NSS_WRAPPER_GROUP}' ";
988 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
989 $cmd .= "$wbinfo --pam-logon=ADDOMAIN/bob%Secret007";
990 if (system($cmd) != 0) {
991 warn("Filling the cache failed\n$cmd");
992 return undef;
993 }
994
995 $cmd = "NSS_WRAPPER_PASSWD='$ret->{NSS_WRAPPER_PASSWD}' ";
996 $cmd .= "NSS_WRAPPER_GROUP='$ret->{NSS_WRAPPER_GROUP}' ";
997 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
998 $cmd .= "$wbinfo --ccache-save=ADDOMAIN/bob%Secret007";
999 if (system($cmd) != 0) {
1000 warn("Filling the cache failed\n$cmd");
1001 return undef;
1002 }
1003
1004 # Set windindd offline
1005 my $smbcontrol = Samba::bindir_path($self, "smbcontrol");
1006 $cmd = "NSS_WRAPPER_PASSWD='$ret->{NSS_WRAPPER_PASSWD}' ";
1007 $cmd .= "NSS_WRAPPER_GROUP='$ret->{NSS_WRAPPER_GROUP}' ";
1008 $cmd .= "UID_WRAPPER_ROOT='1' ";
1009 $cmd .= "$smbcontrol $ret->{CONFIGURATION} winbindd offline";
1010 if (system($cmd) != 0) {
1011 warn("Setting winbindd offline failed\n$cmd");
1012 return undef;
1013 }
1014
1015 # Validate the offline cache
1016 $cmd = "NSS_WRAPPER_PASSWD='$ret->{NSS_WRAPPER_PASSWD}' ";
1017 $cmd .= "NSS_WRAPPER_GROUP='$ret->{NSS_WRAPPER_GROUP}' ";
1018 $cmd .= "UID_WRAPPER_ROOT='1' ";
1019 $cmd .= "$smbcontrol $ret->{CONFIGURATION} winbindd validate-cache";
1020 if (system($cmd) != 0) {
1021 warn("Validation of winbind credential cache failed\n$cmd");
1022 teardown_env($self, $ret);
1023 return undef;
1024 }
1025
1026 # Shut down winbindd
1027 teardown_env($self, $ret);
1028
1029 ### Change SOCKET_WRAPPER_DIR so it can't connect to AD
1030 my $swrap_env = $ENV{SOCKET_WRAPPER_DIR};
1031 $ENV{SOCKET_WRAPPER_DIR} = "$prefix";
1032
1033 # Start winbindd in offline mode
1034 if (not $self->check_or_start(
1035 env_vars => $ret,
1036 winbindd => "offline")) {
1037 return undef;
1038 }
1039
1040 # Set socket dir again
1041 $ENV{SOCKET_WRAPPER_DIR} = $swrap_env;
1042
1043 } else {
1044 if (defined($no_nss_winbind)) {
1045 $ret->{NSS_WRAPPER_MODULE_SO_PATH} = "";
1046 $ret->{NSS_WRAPPER_MODULE_FN_PREFIX} = "";
1047 }
1048
1049 if (not $self->check_or_start(
1050 env_vars => $ret,
1051 samba_dcerpcd => "yes",
1052 nmbd => "yes",
1053 winbindd => "yes",
1054 smbd => "yes")) {
1055 return undef;
1056 }
1057 }
1058
1059 $ret->{DC_SERVER} = $dcvars->{SERVER};
1060 $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
1061 $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
1062 $ret->{DC_SERVERCONFFILE} = $dcvars->{SERVERCONFFILE};
1063 $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
1064 $ret->{DC_USERNAME} = $dcvars->{USERNAME};
1065 $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
1066 $ret->{DOMAIN_ADMIN} = $dcvars->{DOMAIN_ADMIN};
1067 $ret->{DOMAIN_ADMIN_PASSWORD} = $dcvars->{DOMAIN_ADMIN_PASSWORD};
1068 $ret->{DOMAIN_USER} = $dcvars->{DOMAIN_USER};
1069 $ret->{DOMAIN_USER_PASSWORD} = $dcvars->{DOMAIN_USER_PASSWORD};
1070
1071 # forest trust
1072 $ret->{TRUST_F_BOTH_SERVER} = $trustvars_f->{SERVER};
1073 $ret->{TRUST_F_BOTH_SERVER_IP} = $trustvars_f->{SERVER_IP};
1074 $ret->{TRUST_F_BOTH_SERVER_IPV6} = $trustvars_f->{SERVER_IPV6};
1075 $ret->{TRUST_F_BOTH_NETBIOSNAME} = $trustvars_f->{NETBIOSNAME};
1076 $ret->{TRUST_F_BOTH_USERNAME} = $trustvars_f->{USERNAME};
1077 $ret->{TRUST_F_BOTH_PASSWORD} = $trustvars_f->{PASSWORD};
1078 $ret->{TRUST_F_BOTH_DOMAIN} = $trustvars_f->{DOMAIN};
1079 $ret->{TRUST_F_BOTH_REALM} = $trustvars_f->{REALM};
1080
1081 # external trust
1082 $ret->{TRUST_E_BOTH_SERVER} = $trustvars_e->{SERVER};
1083 $ret->{TRUST_E_BOTH_SERVER_IP} = $trustvars_e->{SERVER_IP};
1084 $ret->{TRUST_E_BOTH_SERVER_IPV6} = $trustvars_e->{SERVER_IPV6};
1085 $ret->{TRUST_E_BOTH_NETBIOSNAME} = $trustvars_e->{NETBIOSNAME};
1086 $ret->{TRUST_E_BOTH_USERNAME} = $trustvars_e->{USERNAME};
1087 $ret->{TRUST_E_BOTH_PASSWORD} = $trustvars_e->{PASSWORD};
1088 $ret->{TRUST_E_BOTH_DOMAIN} = $trustvars_e->{DOMAIN};
1089 $ret->{TRUST_E_BOTH_REALM} = $trustvars_e->{REALM};
1090
1091 return $ret;
1092 }
1093
1094 sub setup_ad_member
1095 {
1096 my ($self,
1097 $prefix,
1098 $dcvars,
1099 $trustvars_f,
1100 $trustvars_e) = @_;
1101
1102 # If we didn't build with ADS, pretend this env was never available
1103 if (not $self->have_ads()) {
1104 return "UNKNOWN";
1105 }
1106
1107 print "PROVISIONING AD MEMBER...";
1108
1109 return $self->provision_ad_member($prefix,
1110 "LOCALADMEMBER",
1111 $dcvars,
1112 $trustvars_f,
1113 $trustvars_e);
1114 }
1115
1116 sub setup_ad_member_s3_join
1117 {
1118 my ($self,
1119 $prefix,
1120 $dcvars,
1121 $trustvars_f,
1122 $trustvars_e) = @_;
1123
1124 # If we didn't build with ADS, pretend this env was never available
1125 if (not $self->have_ads()) {
1126 return "UNKNOWN";
1127 }
1128
1129 print "PROVISIONING AD MEMBER...";
1130
1131 return $self->provision_ad_member($prefix,
1132 "LOCALADMEMBER2",
1133 $dcvars,
1134 $trustvars_f,
1135 $trustvars_e);
1136 }
1137
1138 sub setup_ad_member_rfc2307
1139 {
1140 my ($self, $prefix, $dcvars) = @_;
1141
1142 # If we didn't build with ADS, pretend this env was never available
1143 if (not $self->have_ads()) {
1144 return "UNKNOWN";
1145 }
1146
1147 print "PROVISIONING S3 AD MEMBER WITH idmap_rfc2307 config...";
1148
1149 my $member_options = "
1150 security = ads
1151 workgroup = $dcvars->{DOMAIN}
1152 realm = $dcvars->{REALM}
1153 idmap cache time = 0
1154 idmap negative cache time = 0
1155 idmap config * : backend = autorid
1156 idmap config * : range = 1000000-1999999
1157 idmap config * : rangesize = 100000
1158 idmap config $dcvars->{DOMAIN} : backend = rfc2307
1159 idmap config $dcvars->{DOMAIN} : range = 2000000-2999999
1160 idmap config $dcvars->{DOMAIN} : ldap_server = ad
1161 idmap config $dcvars->{DOMAIN} : bind_path_user = ou=idmap,dc=samba,dc=example,dc=com
1162 idmap config $dcvars->{DOMAIN} : bind_path_group = ou=idmap,dc=samba,dc=example,dc=com
1163
1164 password server = $dcvars->{SERVER}
1165 client netlogon ping protocol = starttls
1166 ";
1167
1168 my $ret = $self->provision(
1169 prefix => $prefix,
1170 domain => $dcvars->{DOMAIN},
1171 realm => $dcvars->{REALM},
1172 server => "RFC2307MEMBER",
1173 password => "loCalMemberPass",
1174 extra_options => $member_options,
1175 resolv_conf => $dcvars->{RESOLV_CONF});
1176
1177 $ret or return undef;
1178
1179 $ret->{DOMAIN} = $dcvars->{DOMAIN};
1180 $ret->{REALM} = $dcvars->{REALM};
1181 $ret->{DOMSID} = $dcvars->{DOMSID};
1182
1183 my $ctx;
1184 $ctx = {};
1185 $ctx->{krb5_conf} = "$prefix/lib/krb5.conf";
1186 $ctx->{domain} = $dcvars->{DOMAIN};
1187 $ctx->{realm} = $dcvars->{REALM};
1188 $ctx->{dnsname} = lc($dcvars->{REALM});
1189 $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
1190 $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
1191 $ctx->{krb5_ccname} = "$prefix/krb5cc_%{uid}";
1192 Samba::mk_krb5_conf($ctx, "");
1193
1194 $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
1195
1196 my $net = Samba::bindir_path($self, "net");
1197 # Add hosts file for name lookups
1198 my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
1199 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
1200 if (defined($ret->{RESOLV_WRAPPER_CONF})) {
1201 $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
1202 } else {
1203 $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
1204 }
1205 $cmd .= "RESOLV_CONF=\"$ret->{RESOLV_CONF}\" ";
1206 $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
1207 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
1208 $cmd .= "$net join $ret->{CONFIGURATION}";
1209 $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
1210
1211 if (system($cmd) != 0) {
1212 warn("Join failed\n$cmd");
1213 return undef;
1214 }
1215
1216 # We need world access to this share, as otherwise the domain
1217 # administrator from the AD domain provided by Samba4 can't
1218 # access the share for tests.
1219 chmod 0777, "$prefix/share";
1220
1221 if (not $self->check_or_start(
1222 env_vars => $ret,
1223 nmbd => "yes",
1224 winbindd => "yes",
1225 smbd => "yes")) {
1226 return undef;
1227 }
1228
1229 $ret->{DC_SERVER} = $dcvars->{SERVER};
1230 $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
1231 $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
1232 $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
1233 $ret->{DC_USERNAME} = $dcvars->{USERNAME};
1234 $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
1235 $ret->{DOMAIN_ADMIN} = $dcvars->{DOMAIN_ADMIN};
1236 $ret->{DOMAIN_ADMIN_PASSWORD} = $dcvars->{DOMAIN_ADMIN_PASSWORD};
1237 $ret->{DOMAIN_USER} = $dcvars->{DOMAIN_USER};
1238 $ret->{DOMAIN_USER_PASSWORD} = $dcvars->{DOMAIN_USER_PASSWORD};
1239
1240 return $ret;
1241 }
1242
1243 sub setup_admem_idmap_autorid
1244 {
1245 my ($self, $prefix, $dcvars) = @_;
1246
1247 # If we didn't build with ADS, pretend this env was never available
1248 if (not $self->have_ads()) {
1249 return "UNKNOWN";
1250 }
1251
1252 print "PROVISIONING S3 AD MEMBER WITH idmap_autorid config...";
1253
1254 my $member_options = "
1255 security = ads
1256 workgroup = $dcvars->{DOMAIN}
1257 realm = $dcvars->{REALM}
1258 idmap config * : backend = autorid
1259 idmap config * : range = 1000000-19999999
1260 idmap config * : rangesize = 1000000
1261
1262 # Prevent overriding the provisioned lib/krb5.conf which sets certain
1263 # values required for tests to succeed
1264 create krb5 conf = no
1265
1266 client use krb5 netlogon = yes
1267 reject aes netlogon servers = yes
1268 ";
1269
1270 my $ret = $self->provision(
1271 prefix => $prefix,
1272 domain => $dcvars->{DOMAIN},
1273 realm => $dcvars->{REALM},
1274 server => "ADMEMAUTORID",
1275 password => "loCalMemberPass",
1276 extra_options => $member_options,
1277 resolv_conf => $dcvars->{RESOLV_CONF});
1278
1279 $ret or return undef;
1280
1281 $ret->{DOMAIN} = $dcvars->{DOMAIN};
1282 $ret->{REALM} = $dcvars->{REALM};
1283 $ret->{DOMSID} = $dcvars->{DOMSID};
1284
1285 my $ctx;
1286 $ctx = {};
1287 $ctx->{krb5_conf} = "$prefix/lib/krb5.conf";
1288 $ctx->{domain} = $dcvars->{DOMAIN};
1289 $ctx->{realm} = $dcvars->{REALM};
1290 $ctx->{dnsname} = lc($dcvars->{REALM});
1291 $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
1292 $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
1293 $ctx->{krb5_ccname} = "$prefix/krb5cc_%{uid}";
1294 Samba::mk_krb5_conf($ctx, "");
1295
1296 $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
1297
1298 my $net = Samba::bindir_path($self, "net");
1299 # Add hosts file for name lookups
1300 my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
1301 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
1302 if (defined($ret->{RESOLV_WRAPPER_CONF})) {
1303 $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
1304 } else {
1305 $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
1306 }
1307 $cmd .= "RESOLV_CONF=\"$ret->{RESOLV_CONF}\" ";
1308 $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
1309 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
1310 $cmd .= "$net join $ret->{CONFIGURATION}";
1311 $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
1312
1313 if (system($cmd) != 0) {
1314 warn("Join failed\n$cmd");
1315 return undef;
1316 }
1317
1318 # We need world access to this share, as otherwise the domain
1319 # administrator from the AD domain provided by Samba4 can't
1320 # access the share for tests.
1321 chmod 0777, "$prefix/share";
1322
1323 if (not $self->check_or_start(
1324 env_vars => $ret,
1325 nmbd => "yes",
1326 winbindd => "yes",
1327 smbd => "yes")) {
1328 return undef;
1329 }
1330
1331 $ret->{DC_SERVER} = $dcvars->{SERVER};
1332 $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
1333 $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
1334 $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
1335 $ret->{DC_USERNAME} = $dcvars->{USERNAME};
1336 $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
1337 $ret->{DOMAIN_ADMIN} = $dcvars->{DOMAIN_ADMIN};
1338 $ret->{DOMAIN_ADMIN_PASSWORD} = $dcvars->{DOMAIN_ADMIN_PASSWORD};
1339 $ret->{DOMAIN_USER} = $dcvars->{DOMAIN_USER};
1340 $ret->{DOMAIN_USER_PASSWORD} = $dcvars->{DOMAIN_USER_PASSWORD};
1341
1342 return $ret;
1343 }
1344
1345 sub setup_ad_member_idmap_rid
1346 {
1347 my ($self, $prefix, $dcvars) = @_;
1348
1349 # If we didn't build with ADS, pretend this env was never available
1350 if (not $self->have_ads()) {
1351 return "UNKNOWN";
1352 }
1353
1354 print "PROVISIONING S3 AD MEMBER WITH idmap_rid config...";
1355
1356 my $member_options = "
1357 security = ads
1358 workgroup = $dcvars->{DOMAIN}
1359 realm = $dcvars->{REALM}
1360 idmap config * : backend = tdb
1361 idmap config * : range = 1000000-1999999
1362 idmap config $dcvars->{DOMAIN} : backend = rid
1363 idmap config $dcvars->{DOMAIN} : range = 2000000-2999999
1364 # Prevent overriding the provisioned lib/krb5.conf which sets certain
1365 # values required for tests to succeed
1366 create krb5 conf = no
1367 map to guest = bad user
1368 winbind expand groups = 10
1369 server signing = required
1370 ";
1371
1372 my $ret = $self->provision(
1373 prefix => $prefix,
1374 domain => $dcvars->{DOMAIN},
1375 realm => $dcvars->{REALM},
1376 server => "IDMAPRIDMEMBER",
1377 password => "loCalMemberPass",
1378 extra_options => $member_options,
1379 resolv_conf => $dcvars->{RESOLV_CONF});
1380
1381 $ret or return undef;
1382
1383 $ret->{DOMAIN} = $dcvars->{DOMAIN};
1384 $ret->{REALM} = $dcvars->{REALM};
1385 $ret->{DOMSID} = $dcvars->{DOMSID};
1386
1387 my $ctx;
1388 $ctx = {};
1389 $ctx->{krb5_conf} = "$prefix/lib/krb5.conf";
1390 $ctx->{domain} = $dcvars->{DOMAIN};
1391 $ctx->{realm} = $dcvars->{REALM};
1392 $ctx->{dnsname} = lc($dcvars->{REALM});
1393 $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
1394 $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
1395 $ctx->{krb5_ccname} = "$prefix/krb5cc_%{uid}";
1396 Samba::mk_krb5_conf($ctx, "");
1397
1398 $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
1399
1400 my $net = Samba::bindir_path($self, "net");
1401 # Add hosts file for name lookups
1402 my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
1403 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
1404 if (defined($ret->{RESOLV_WRAPPER_CONF})) {
1405 $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
1406 } else {
1407 $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
1408 }
1409 $cmd .= "RESOLV_CONF=\"$ret->{RESOLV_CONF}\" ";
1410 $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
1411 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
1412 $cmd .= "$net join $ret->{CONFIGURATION}";
1413 $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
1414
1415 if (system($cmd) != 0) {
1416 warn("Join failed\n$cmd");
1417 return undef;
1418 }
1419
1420 # We need world access to this share, as otherwise the domain
1421 # administrator from the AD domain provided by Samba4 can't
1422 # access the share for tests.
1423 chmod 0777, "$prefix/share";
1424
1425 if (not $self->check_or_start(
1426 env_vars => $ret,
1427 nmbd => "yes",
1428 winbindd => "yes",
1429 smbd => "yes")) {
1430 return undef;
1431 }
1432
1433 $ret->{DC_SERVER} = $dcvars->{SERVER};
1434 $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
1435 $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
1436 $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
1437 $ret->{DC_USERNAME} = $dcvars->{USERNAME};
1438 $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
1439 $ret->{DOMAIN_ADMIN} = $dcvars->{DOMAIN_ADMIN};
1440 $ret->{DOMAIN_ADMIN_PASSWORD} = $dcvars->{DOMAIN_ADMIN_PASSWORD};
1441 $ret->{DOMAIN_USER} = $dcvars->{DOMAIN_USER};
1442 $ret->{DOMAIN_USER_PASSWORD} = $dcvars->{DOMAIN_USER_PASSWORD};
1443
1444 return $ret;
1445 }
1446
1447 sub setup_ad_member_idmap_ad
1448 {
1449 my ($self, $prefix, $dcvars) = @_;
1450
1451 # If we didn't build with ADS, pretend this env was never available
1452 if (not $self->have_ads()) {
1453 return "UNKNOWN";
1454 }
1455
1456 print "PROVISIONING S3 AD MEMBER WITH idmap_ad config...";
1457
1458 my $member_options = "
1459 security = ads
1460 workgroup = $dcvars->{DOMAIN}
1461 realm = $dcvars->{REALM}
1462 password server = $dcvars->{SERVER}
1463 idmap config * : backend = tdb
1464 idmap config * : range = 1000000-1999999
1465 idmap config $dcvars->{DOMAIN} : backend = ad
1466 idmap config $dcvars->{DOMAIN} : range = 2000000-2999999
1467 idmap config $dcvars->{DOMAIN} : unix_primary_group = yes
1468 idmap config $dcvars->{DOMAIN} : unix_nss_info = yes
1469 idmap config $dcvars->{DOMAIN} : deny ous = \"ou=sub,DC=samba2008r2,DC=example,DC=com\"
1470 idmap config $dcvars->{TRUST_DOMAIN} : backend = ad
1471 idmap config $dcvars->{TRUST_DOMAIN} : range = 2000000-2999999
1472 gensec_gssapi:requested_life_time = 5
1473 winbind scan trusted domains = yes
1474 winbind expand groups = 1
1475 client netlogon ping protocol = ldaps
1476 ";
1477
1478 my $ret = $self->provision(
1479 prefix => $prefix,
1480 domain => $dcvars->{DOMAIN},
1481 realm => $dcvars->{REALM},
1482 server => "IDMAPADMEMBER",
1483 password => "loCalMemberPass",
1484 extra_options => $member_options,
1485 resolv_conf => $dcvars->{RESOLV_CONF});
1486
1487 $ret or return undef;
1488
1489 $ret->{DOMAIN} = $dcvars->{DOMAIN};
1490 $ret->{REALM} = $dcvars->{REALM};
1491 $ret->{DOMSID} = $dcvars->{DOMSID};
1492
1493 my $ctx;
1494 $ctx = {};
1495 $ctx->{krb5_conf} = "$prefix/lib/krb5.conf";
1496 $ctx->{domain} = $dcvars->{DOMAIN};
1497 $ctx->{realm} = $dcvars->{REALM};
1498 $ctx->{dnsname} = lc($dcvars->{REALM});
1499 $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
1500 $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
1501 $ctx->{krb5_ccname} = "$prefix/krb5cc_%{uid}";
1502 Samba::mk_krb5_conf($ctx, "");
1503
1504 $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
1505
1506 my $net = Samba::bindir_path($self, "net");
1507 # Add hosts file for name lookups
1508 my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
1509 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
1510 if (defined($ret->{RESOLV_WRAPPER_CONF})) {
1511 $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
1512 } else {
1513 $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
1514 }
1515 $cmd .= "RESOLV_CONF=\"$ret->{RESOLV_CONF}\" ";
1516 $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
1517 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
1518 $cmd .= "$net join $ret->{CONFIGURATION}";
1519 $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
1520
1521 if (system($cmd) != 0) {
1522 warn("Join failed\n$cmd");
1523 return undef;
1524 }
1525
1526 # We need world access to this share, as otherwise the domain
1527 # administrator from the AD domain provided by Samba4 can't
1528 # access the share for tests.
1529 chmod 0777, "$prefix/share";
1530
1531 if (not $self->check_or_start(
1532 env_vars => $ret,
1533 nmbd => "yes",
1534 winbindd => "yes",
1535 smbd => "yes")) {
1536 return undef;
1537 }
1538
1539 $ret->{DC_SERVER} = $dcvars->{SERVER};
1540 $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
1541 $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
1542 $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
1543 $ret->{DC_USERNAME} = $dcvars->{USERNAME};
1544 $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
1545 $ret->{DOMAIN_ADMIN} = $dcvars->{DOMAIN_ADMIN};
1546 $ret->{DOMAIN_ADMIN_PASSWORD} = $dcvars->{DOMAIN_ADMIN_PASSWORD};
1547 $ret->{DOMAIN_USER} = $dcvars->{DOMAIN_USER};
1548 $ret->{DOMAIN_USER_PASSWORD} = $dcvars->{DOMAIN_USER_PASSWORD};
1549
1550 $ret->{TRUST_SERVER} = $dcvars->{TRUST_SERVER};
1551 $ret->{TRUST_USERNAME} = $dcvars->{TRUST_USERNAME};
1552 $ret->{TRUST_PASSWORD} = $dcvars->{TRUST_PASSWORD};
1553 $ret->{TRUST_DOMAIN} = $dcvars->{TRUST_DOMAIN};
1554 $ret->{TRUST_REALM} = $dcvars->{TRUST_REALM};
1555 $ret->{TRUST_DOMSID} = $dcvars->{TRUST_DOMSID};
1556
1557 return $ret;
1558 }
1559
1560 sub setup_ad_member_oneway
1561 {
1562 my ($self, $prefix, $dcvars) = @_;
1563
1564 # If we didn't build with ADS, pretend this env was never available
1565 if (not $self->have_ads()) {
1566 return "UNKNOWN";
1567 }
1568
1569 print "PROVISIONING S3 AD MEMBER WITH one-way trust...";
1570
1571 my $member_options = "
1572 security = ads
1573 workgroup = $dcvars->{DOMAIN}
1574 realm = $dcvars->{REALM}
1575 password server = $dcvars->{SERVER}
1576 idmap config * : backend = tdb
1577 idmap config * : range = 1000000-1999999
1578 gensec_gssapi:requested_life_time = 5
1579 client netlogon ping protocol = ldap
1580 ";
1581
1582 my $ret = $self->provision(
1583 prefix => $prefix,
1584 domain => $dcvars->{DOMAIN},
1585 server => "S2KMEMBER",
1586 password => "loCalS2KMemberPass",
1587 extra_options => $member_options,
1588 resolv_conf => $dcvars->{RESOLV_CONF});
1589
1590 $ret or return undef;
1591
1592 $ret->{DOMAIN} = $dcvars->{DOMAIN};
1593 $ret->{REALM} = $dcvars->{REALM};
1594 $ret->{DOMSID} = $dcvars->{DOMSID};
1595
1596 my $ctx;
1597 $ctx = {};
1598 $ctx->{krb5_conf} = "$prefix/lib/krb5.conf";
1599 $ctx->{domain} = $dcvars->{DOMAIN};
1600 $ctx->{realm} = $dcvars->{REALM};
1601 $ctx->{dnsname} = lc($dcvars->{REALM});
1602 $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
1603 $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
1604 $ctx->{krb5_ccname} = "$prefix/krb5cc_%{uid}";
1605 Samba::mk_krb5_conf($ctx, "");
1606
1607 $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
1608
1609 my $net = Samba::bindir_path($self, "net");
1610 # Add hosts file for name lookups
1611 my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
1612 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
1613 if (defined($ret->{RESOLV_WRAPPER_CONF})) {
1614 $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
1615 } else {
1616 $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
1617 }
1618 $cmd .= "RESOLV_CONF=\"$ret->{RESOLV_CONF}\" ";
1619 $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
1620 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
1621 $cmd .= "$net join $ret->{CONFIGURATION}";
1622 $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
1623
1624 if (system($cmd) != 0) {
1625 warn("Join failed\n$cmd");
1626 return undef;
1627 }
1628
1629 if (not $self->check_or_start(
1630 env_vars => $ret,
1631 winbindd => "yes")) {
1632 return undef;
1633 }
1634
1635 $ret->{DC_SERVER} = $dcvars->{SERVER};
1636 $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
1637 $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
1638 $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
1639 $ret->{DC_USERNAME} = $dcvars->{USERNAME};
1640 $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
1641 $ret->{DOMAIN_ADMIN} = $dcvars->{DOMAIN_ADMIN};
1642 $ret->{DOMAIN_ADMIN_PASSWORD} = $dcvars->{DOMAIN_ADMIN_PASSWORD};
1643 $ret->{DOMAIN_USER} = $dcvars->{DOMAIN_USER};
1644 $ret->{DOMAIN_USER_PASSWORD} = $dcvars->{DOMAIN_USER_PASSWORD};
1645
1646 $ret->{TRUST_SERVER} = $dcvars->{TRUST_SERVER};
1647 $ret->{TRUST_USERNAME} = $dcvars->{TRUST_USERNAME};
1648 $ret->{TRUST_PASSWORD} = $dcvars->{TRUST_PASSWORD};
1649 $ret->{TRUST_DOMAIN} = $dcvars->{TRUST_DOMAIN};
1650 $ret->{TRUST_REALM} = $dcvars->{TRUST_REALM};
1651 $ret->{TRUST_DOMSID} = $dcvars->{TRUST_DOMSID};
1652
1653 return $ret;
1654 }
1655
1656 sub setup_ad_member_fips
1657 {
1658 my ($self,
1659 $prefix,
1660 $dcvars,
1661 $trustvars_f,
1662 $trustvars_e) = @_;
1663
1664 # If we didn't build with ADS, pretend this env was never available
1665 if (not $self->have_ads()) {
1666 return "UNKNOWN";
1667 }
1668
1669 print "PROVISIONING AD FIPS MEMBER...";
1670
1671 return $self->provision_ad_member($prefix,
1672 "FIPSADMEMBER",
1673 $dcvars,
1674 $trustvars_f,
1675 $trustvars_e,
1676 undef,
1677 1);
1678 }
1679
1680 sub setup_ad_member_offlogon
1681 {
1682 my ($self,
1683 $prefix,
1684 $dcvars,
1685 $trustvars_f,
1686 $trustvars_e) = @_;
1687
1688 # If we didn't build with ADS, pretend this env was never available
1689 if (not $self->have_ads()) {
1690 return "UNKNOWN";
1691 }
1692
1693 print "PROVISIONING AD MEMBER OFFLINE LOGON...";
1694
1695 return $self->provision_ad_member($prefix,
1696 "OFFLINEADMEM",
1697 $dcvars,
1698 $trustvars_f,
1699 $trustvars_e,
1700 undef,
1701 undef,
1702 1);
1703 }
1704
1705 sub setup_ad_member_idmap_nss
1706 {
1707 my ($self,
1708 $prefix,
1709 $dcvars,
1710 $trustvars_f,
1711 $trustvars_e) = @_;
1712
1713 # If we didn't build with ADS, pretend this env was never available
1714 if (not $self->have_ads()) {
1715 return "UNKNOWN";
1716 }
1717
1718 print "PROVISIONING AD MEMBER WITHOUT NSS WINBIND WITH idmap_nss config...";
1719
1720 my $extra_member_options = "
1721 # bob:x:65521:65531:localbob gecos:/:/bin/false
1722 # jane:x:65520:65531:localjane gecos:/:/bin/false
1723 # jackthemapper:x:65519:65531:localjackthemaper gecos:/:/bin/false
1724 # jacknomapper:x:65518:65531:localjacknomaper gecos:/:/bin/false
1725 idmap config $dcvars->{DOMAIN} : backend = nss
1726 idmap config $dcvars->{DOMAIN} : range = 65518-65521
1727
1728 # Support SMB1 so that we can use posix_whoami().
1729 client min protocol = CORE
1730 server min protocol = LANMAN1
1731
1732 username map = $prefix/lib/username.map
1733 ";
1734
1735 my $ret = $self->provision_ad_member($prefix,
1736 "ADMEMIDMAPNSS",
1737 $dcvars,
1738 $trustvars_f,
1739 $trustvars_e,
1740 $extra_member_options,
1741 undef,
1742 undef,
1743 1,
1744 1);
1745
1746 open(USERMAP, ">$prefix/lib/username.map") or die("Unable to open $prefix/lib/username.map");
1747 print USERMAP "
1748 !jacknomapper = \@jackthemappergroup
1749 !root = jacknomappergroup
1750 root = $dcvars->{DOMAIN}/root
1751 bob = $dcvars->{DOMAIN}/bob
1752 ";
1753 close(USERMAP);
1754
1755 return $ret;
1756 }
1757
1758 sub setup_simpleserver
1759 {
1760 my ($self, $path) = @_;
1761
1762 print "PROVISIONING simple server...";
1763
1764 my $prefix = abs_path($path);
1765
1766 my $external_streams_depot="$prefix/external_streams_depot";
1767
1768 my $simpleserver_options_globals = "
1769 lanman auth = yes
1770 ntlm auth = yes
1771 vfs objects = xattr_tdb streams_depot
1772 change notify = no
1773 server smb encrypt = off
1774 allow trusted domains = no
1775 ";
1776
1777 my $simpleserver_options = "
1778 [vfs_aio_pthread]
1779 path = $prefix/share
1780 read only = no
1781 vfs objects = aio_pthread
1782 aio_pthread:aio open = yes
1783 smbd async dosmode = no
1784
1785 [vfs_aio_pthread_async_dosmode_default1]
1786 path = $prefix/share
1787 read only = no
1788 vfs objects = aio_pthread
1789 store dos attributes = yes
1790 aio_pthread:aio open = yes
1791 smbd async dosmode = yes
1792
1793 [vfs_aio_pthread_async_dosmode_default2]
1794 path = $prefix/share
1795 read only = no
1796 vfs objects = aio_pthread xattr_tdb
1797 store dos attributes = yes
1798 aio_pthread:aio open = yes
1799 smbd async dosmode = yes
1800
1801 [async_dosmode_shadow_copy2]
1802 path = $prefix/share
1803 read only = no
1804 vfs objects = shadow_copy2 xattr_tdb
1805 smbd async dosmode = yes
1806
1807 [vfs_aio_fork]
1808 path = $prefix/share
1809 vfs objects = aio_fork
1810 read only = no
1811 vfs_aio_fork:erratic_testing_mode=yes
1812
1813 [dosmode]
1814 path = $prefix/share
1815 vfs objects =
1816 store dos attributes = yes
1817 hide files = /hidefile/
1818 hide dot files = yes
1819
1820 [hidenewfiles]
1821 path = $prefix/share
1822 hide new files timeout = 5
1823
1824 [external_streams_depot]
1825 path = $prefix/share
1826 read only = no
1827 streams_depot:directory = $external_streams_depot
1828 ";
1829
1830 my $vars = $self->provision(
1831 prefix => $path,
1832 domain => "WORKGROUP",
1833 server => "LOCALSHARE4",
1834 password => "local4pass",
1835 extra_options_before_inject => $simpleserver_options_globals,
1836 extra_options => $simpleserver_options);
1837
1838 $vars or return undef;
1839
1840 remove_tree($external_streams_depot);
1841 mkdir($external_streams_depot, 0777);
1842
1843 my $pam_service_dir = "$prefix/pam_services";
1844 remove_tree($pam_service_dir);
1845 mkdir($pam_service_dir, 0777);
1846 my $pam_service_file = "$pam_service_dir/samba";
1847 my $pam_matrix_passdb = "$pam_service_dir/samba_pam_matrix_passdb";
1848 my $pam_matrix_so_path = Samba::pam_matrix_so_path($self);
1849
1850 open(FILE, "> $pam_service_file");
1851 print FILE "auth required ${pam_matrix_so_path} passdb=${pam_matrix_passdb} verbose\n";
1852 print FILE "account required ${pam_matrix_so_path} passdb=${pam_matrix_passdb} verbose\n";
1853 close(FILE);
1854
1855 my $tmpusername = $vars->{USERNAME};
1856 my $tmppassword = $vars->{PASSWORD};
1857 open(FILE, "> $pam_matrix_passdb");
1858 print FILE "$tmpusername:$tmppassword:samba";
1859 close(FILE);
1860
1861 $vars->{PAM_WRAPPER} = "1";
1862 $vars->{PAM_WRAPPER_SERVICE_DIR} = $pam_service_dir;
1863 #$vars->{PAM_WRAPPER_DEBUGLEVEL} = "3";
1864
1865 if (not $self->check_or_start(
1866 env_vars => $vars,
1867 nmbd => "yes",
1868 smbd => "yes")) {
1869 return undef;
1870 }
1871
1872 return $vars;
1873 }
1874
1875 sub create_file_chmod($$)
1876 {
1877 my ($name, $mode) = @_;
1878 my $fh;
1879
1880 unless (open($fh, '>', $name)) {
1881 warn("Unable to open $name");
1882 return undef;
1883 }
1884 chmod($mode, $fh);
1885 }
1886
1887 sub setup_fileserver
1888 {
1889 my ($self, $path, $more_conf, $server) = @_;
1890 my $prefix = abs_path($path);
1891 my $srcdir_abs = abs_path($self->{srcdir});
1892
1893 print "PROVISIONING file server ...\n";
1894
1895 my @dirs = ();
1896
1897 mkdir($prefix, 0777);
1898
1899 my $usershare_dir="$prefix/lib/usershare";
1900
1901 my $share_dir="$prefix/share";
1902
1903 # Create share directory structure
1904 my $lower_case_share_dir="$share_dir/lower-case";
1905 push(@dirs, $lower_case_share_dir);
1906
1907 my $lower_case_share_dir_30000="$share_dir/lower-case-30000";
1908 push(@dirs, $lower_case_share_dir_30000);
1909
1910 my $dfree_share_dir="$share_dir/dfree";
1911 push(@dirs, $dfree_share_dir);
1912 push(@dirs, "$dfree_share_dir/subdir1");
1913 push(@dirs, "$dfree_share_dir/subdir2");
1914 push(@dirs, "$dfree_share_dir/subdir3");
1915
1916 my $quotadir_dir="$share_dir/quota";
1917 push(@dirs, $quotadir_dir);
1918
1919 my $valid_users_sharedir="$share_dir/valid_users";
1920 push(@dirs,$valid_users_sharedir);
1921
1922 my $offline_sharedir="$share_dir/offline";
1923 push(@dirs,$offline_sharedir);
1924
1925 my $force_user_valid_users_dir = "$share_dir/force_user_valid_users";
1926 push(@dirs, $force_user_valid_users_dir);
1927
1928 my $tarmode_sharedir="$share_dir/tarmode";
1929 push(@dirs,$tarmode_sharedir);
1930
1931 my $tarmode2_sharedir="$share_dir/tarmode2";
1932 push(@dirs,$tarmode2_sharedir);
1933
1934 my $smbcacls_sharedir="$share_dir/smbcacls";
1935 push(@dirs,$smbcacls_sharedir);
1936
1937 my $usershare_sharedir="$share_dir/usershares";
1938 push(@dirs,$usershare_sharedir);
1939
1940 my $dropbox_sharedir="$share_dir/dropbox";
1941 push(@dirs,$dropbox_sharedir);
1942
1943 my $bad_iconv_sharedir="$share_dir/bad_iconv";
1944 push(@dirs, $bad_iconv_sharedir);
1945
1946 my $veto_sharedir="$share_dir/veto";
1947 push(@dirs,$veto_sharedir);
1948
1949 my $virusfilter_sharedir="$share_dir/virusfilter";
1950 push(@dirs,$virusfilter_sharedir);
1951
1952 my $delete_unwrite_sharedir="$share_dir/delete_unwrite";
1953 push(@dirs,$delete_unwrite_sharedir);
1954 push(@dirs, "$delete_unwrite_sharedir/delete_veto_yes");
1955 push(@dirs, "$delete_unwrite_sharedir/delete_veto_no");
1956
1957 my $volume_serial_number_sharedir="$share_dir/volume_serial_number";
1958 push(@dirs, $volume_serial_number_sharedir);
1959
1960 my $ip4 = Samba::get_ipv4_addr("FILESERVER");
1961 my $fileserver_options = "
1962 server smb transports = +quic
1963
1964 smb3 unix extensions = yes
1965 kernel change notify = yes
1966 spotlight backend = elasticsearch
1967 elasticsearch:address = $ip4
1968 elasticsearch:port = 8080
1969 elasticsearch:mappings = $srcdir_abs/source3/rpc_server/mdssvc/elasticsearch_mappings.json
1970
1971 usershare path = $usershare_dir
1972 usershare max shares = 10
1973 usershare allow guests = yes
1974 usershare prefix allow list = $usershare_sharedir
1975
1976 get quota command = $prefix/getset_quota.py
1977 set quota command = $prefix/getset_quota.py
1978 veto files : user1 = /user1file/
1979 veto files : +group1 = /group1file/
1980 [tarmode]
1981 path = $tarmode_sharedir
1982 comment = tar test share
1983 xattr_tdb:file = $prefix/tarmode-xattr.tdb
1984 [tarmode2]
1985 path = $tarmode2_sharedir
1986 comment = tar test share
1987 xattr_tdb:file = $prefix/tarmode2-xattr.tdb
1988 [spotlight]
1989 path = $share_dir
1990 spotlight = yes
1991 read only = no
1992 [no_spotlight]
1993 path = $share_dir
1994 spotlight = no
1995 read only = no
1996 [lowercase]
1997 path = $lower_case_share_dir
1998 comment = smb username is [%U]
1999 case sensitive = True
2000 default case = lower
2001 preserve case = no
2002 short preserve case = no
2003 [lowercase-30000]
2004 path = $lower_case_share_dir_30000
2005 comment = smb username is [%U]
2006 case sensitive = True
2007 default case = lower
2008 preserve case = no
2009 short preserve case = no
2010 [dfree]
2011 path = $dfree_share_dir
2012 comment = smb username is [%U]
2013 dfree command = $srcdir_abs/testprogs/blackbox/dfree.sh
2014 [valid-users-access]
2015 path = $valid_users_sharedir
2016 valid users = +userdup
2017 [offline]
2018 path = $offline_sharedir
2019 vfs objects = offline
2020
2021 # BUG: https://bugzilla.samba.org/show_bug.cgi?id=9878
2022 # RH BUG: https://bugzilla.redhat.com/show_bug.cgi?id=1077651
2023 [force_user_valid_users]
2024 path = $force_user_valid_users_dir
2025 comment = force user with valid users combination test share
2026 valid users = +force_user
2027 force user = force_user
2028 force group = everyone
2029 write list = force_user
2030
2031 [ign_sysacls]
2032 path = $share_dir
2033 comment = ignore system acls
2034 acl_xattr:ignore system acls = yes
2035 [inherit_owner]
2036 path = $share_dir
2037 comment = inherit owner
2038 inherit owner = yes
2039 [inherit_owner_u]
2040 path = $share_dir
2041 comment = inherit only unix owner
2042 inherit owner = unix only
2043 acl_xattr:ignore system acls = yes
2044 # BUG: https://bugzilla.samba.org/show_bug.cgi?id=13690
2045 [force_group_test]
2046 path = $share_dir
2047 comment = force group test
2048 # force group = everyone
2049
2050 [create_mode_664]
2051 path = $share_dir
2052 comment = smb username is [%U]
2053 create mask = 0644
2054 force create mode = 0664
2055 vfs objects = dirsort
2056
2057 [dropbox]
2058 path = $dropbox_sharedir
2059 comment = smb username is [%U]
2060 writeable = yes
2061 vfs objects =
2062
2063 [bad_iconv]
2064 path = $bad_iconv_sharedir
2065 comment = smb username is [%U]
2066 vfs objects =
2067
2068 [veto_files_nodelete]
2069 path = $veto_sharedir
2070 read only = no
2071 msdfs root = yes
2072 veto files = /veto_name*/
2073 delete veto files = no
2074
2075 [veto_files_delete]
2076 path = $veto_sharedir
2077 msdfs root = yes
2078 veto files = /veto_name*/
2079 delete veto files = yes
2080
2081 [delete_veto_files_only]
2082 path = $veto_sharedir
2083 delete veto files = yes
2084
2085 [veto_files_nohidden]
2086 path = $veto_sharedir
2087 veto files = /.*/
2088
2089 [veto_files]
2090 path = $veto_sharedir
2091 veto files = /veto_name*/
2092 veto files : user2 = /user2file/
2093 veto files : +group2 = /group2file/
2094
2095 [delete_yes_unwrite]
2096 read only = no
2097 path = $delete_unwrite_sharedir
2098 hide unwriteable files = yes
2099 delete veto files = yes
2100
2101 [delete_no_unwrite]
2102 read only = no
2103 path = $delete_unwrite_sharedir
2104 hide unwriteable files = yes
2105 delete veto files = no
2106
2107 [virusfilter]
2108 path = $virusfilter_sharedir
2109 vfs objects = acl_xattr virusfilter
2110 virusfilter:scanner = dummy
2111 virusfilter:min file size = 0
2112 virusfilter:infected files = *infected*
2113 virusfilter:infected file action = rename
2114 virusfilter:scan on close = yes
2115 vfs_default:VFS_OPEN_HOW_RESOLVE_NO_SYMLINKS = no
2116
2117 [volumeserialnumber]
2118 path = $volume_serial_number_sharedir
2119 volume serial number = 0xdeadbeef
2120
2121 [ea_acl_xattr]
2122 path = $share_dir
2123 vfs objects = acl_xattr
2124 acl_xattr:security_acl_name = user.hackme
2125 read only = no
2126
2127 [io_uring]
2128 path = $share_dir
2129 vfs objects = acl_xattr fake_acls xattr_tdb streams_depot time_audit full_audit io_uring
2130 read only = no
2131
2132 [homes]
2133 comment = Home directories
2134 browseable = No
2135 read only = No
2136
2137 [inherit_perms]
2138 path = $share_dir
2139 vfs objects = streams_depot
2140 inherit permissions = yes
2141 ";
2142
2143 if (defined($more_conf)) {
2144 $fileserver_options = $fileserver_options . $more_conf;
2145 }
2146 if (!defined($server)) {
2147 $server = "FILESERVER";
2148 }
2149
2150 my $vars = $self->provision(
2151 prefix => $path,
2152 domain => "WORKGROUP",
2153 server => $server,
2154 password => "fileserver",
2155 extra_options => $fileserver_options);
2156
2157 $vars or return undef;
2158
2159 mkdir("$prefix/lib", 0755);
2160 remove_tree($usershare_dir);
2161 mkdir($usershare_dir, 01770);
2162
2163 if (not $self->check_or_start(
2164 env_vars => $vars,
2165 nmbd => "yes",
2166 smbd => "yes")) {
2167 return undef;
2168 }
2169
2170
2171 mkdir($_, 0777) foreach(@dirs);
2172
2173 ## Create case sensitive lower case share dir
2174 foreach my $file ('a'..'z') {
2175 my $full_path = $lower_case_share_dir . '/' . $file;
2176 open my $fh, '>', $full_path;
2177 # Add some content to file
2178 print $fh $full_path;
2179 close $fh;
2180 }
2181
2182 for (my $file = 1; $file < 51; ++$file) {
2183 my $full_path = $lower_case_share_dir . '/' . $file;
2184 open my $fh, '>', $full_path;
2185 # Add some content to file
2186 print $fh $full_path;
2187 close $fh;
2188 }
2189
2190 # Create content for 30000 share
2191 foreach my $file ('a'..'z') {
2192 my $full_path = $lower_case_share_dir_30000 . '/' . $file;
2193 open my $fh, '>', $full_path;
2194 # Add some content to file
2195 print $fh $full_path;
2196 close $fh;
2197 }
2198
2199 for (my $file = 1; $file < 30001; ++$file) {
2200 my $full_path = $lower_case_share_dir_30000 . '/' . $file;
2201 open my $fh, '>', $full_path;
2202 # Add some content to file
2203 print $fh $full_path;
2204 close $fh;
2205 }
2206
2207 ##
2208 ## create a listable file in valid_users_share
2209 ##
2210 create_file_chmod("$valid_users_sharedir/foo", 0644) or return undef;
2211
2212 ##
2213 ## create a valid utf8 filename which is invalid as a CP850 conversion
2214 ##
2215 create_file_chmod("$bad_iconv_sharedir/\xED\x9F\xBF", 0644) or return undef;
2216
2217 ##
2218 ## create unwritable files inside inside the delete unwrite veto share dirs.
2219 ##
2220 unlink("$delete_unwrite_sharedir/delete_veto_yes/file_444");
2221 create_file_chmod("$delete_unwrite_sharedir/delete_veto_yes/file_444", 0444) or return undef;
2222 unlink("$delete_unwrite_sharedir/delete_veto_no/file_444");
2223 create_file_chmod("$delete_unwrite_sharedir/delete_veto_no/file_444", 0444) or return undef;
2224
2225 return $vars;
2226 }
2227
2228 sub setup_fileserver_smb1
2229 {
2230 my ($self, $path) = @_;
2231 my $prefix = abs_path($path);
2232 my $conf = "
2233 [global]
2234 client min protocol = CORE
2235 server min protocol = LANMAN1
2236 check parent directory delete on close = yes
2237
2238 [hidenewfiles]
2239 path = $prefix/share
2240 hide new files timeout = 5
2241 [vfs_aio_pthread]
2242 path = $prefix/share
2243 read only = no
2244 vfs objects = aio_pthread
2245 aio_pthread:aio open = yes
2246 smbd async dosmode = no
2247
2248 [vfs_aio_pthread_async_dosmode_default1]
2249 path = $prefix/share
2250 read only = no
2251 vfs objects = aio_pthread
2252 store dos attributes = yes
2253 aio_pthread:aio open = yes
2254 smbd async dosmode = yes
2255
2256 [vfs_aio_pthread_async_dosmode_default2]
2257 path = $prefix/share
2258 read only = no
2259 vfs objects = aio_pthread xattr_tdb
2260 store dos attributes = yes
2261 aio_pthread:aio open = yes
2262 smbd async dosmode = yes
2263
2264 [vfs_aio_fork]
2265 path = $prefix/share
2266 vfs objects = aio_fork
2267 read only = no
2268 vfs_aio_fork:erratic_testing_mode=yes
2269 ";
2270 return $self->setup_fileserver($path, $conf, "FILESERVERSMB1");
2271 }
2272
2273 sub setup_fileserver_smb1_done
2274 {
2275 my ($self, $path, $dep_env) = @_;
2276 return $self->return_alias_env($path, $dep_env);
2277 }
2278
2279 sub setup_ktest
2280 {
2281 my ($self, $prefix) = @_;
2282
2283 # If we didn't build with ADS, pretend this env was never available
2284 if (not $self->have_ads()) {
2285 return "UNKNOWN";
2286 }
2287
2288 print "PROVISIONING server with security=ads...";
2289
2290 my $ktest_options = "
2291 workgroup = KTEST
2292 realm = ktest.samba.example.com
2293 security = ads
2294 server signing = required
2295 server min protocol = SMB3_00
2296 client max protocol = SMB3
2297
2298 # This disables NTLM auth against the local SAM, which
2299 # we use can then test this setting by.
2300 ntlm auth = disabled
2301
2302 idmap config * : backend = autorid
2303 idmap config * : range = 1000000-1999999
2304 idmap config * : rangesize = 100000
2305 ";
2306
2307 my $ret = $self->provision(
2308 prefix => $prefix,
2309 domain => "KTEST",
2310 server => "LOCALKTEST6",
2311 password => "localktest6pass",
2312 extra_options => $ktest_options);
2313
2314 $ret or return undef;
2315
2316 my $ctx;
2317 $ctx = {};
2318 $ctx->{krb5_conf} = "$prefix/lib/krb5.conf";
2319 $ctx->{domain} = "KTEST";
2320 $ctx->{realm} = "KTEST.SAMBA.EXAMPLE.COM";
2321 $ctx->{dnsname} = lc($ctx->{realm});
2322 $ctx->{kdc_ipv4} = "0.0.0.0";
2323 $ctx->{kdc_ipv6} = "::";
2324 $ctx->{krb5_ccname} = "$prefix/krb5cc_%{uid}";
2325 Samba::mk_krb5_conf($ctx, "");
2326
2327 $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
2328
2329 #This is the secrets.tdb created by 'net ads join' from Samba3 to a
2330 #Samba4 DC with the same parameters as are being used here. The
2331 #domain SID is S-1-5-21-1071277805-689288055-3486227160
2332 $ret->{SAMSID} = "S-1-5-21-1911091480-1468226576-2729736297";
2333 $ret->{DOMSID} = "S-1-5-21-1071277805-689288055-3486227160";
2334
2335 system("cp $self->{srcdir}/source3/selftest/ktest-secrets.tdb $prefix/private/secrets.tdb");
2336 chmod 0600, "$prefix/private/secrets.tdb";
2337
2338 #Make sure there's no old ntdb file.
2339 system("rm -f $prefix/private/secrets.ntdb");
2340
2341 #This uses a pre-calculated krb5 credentials cache, obtained by running Samba4 with:
2342 # "--option=kdc:service ticket lifetime=239232" "--option=kdc:user ticket lifetime=239232" "--option=kdc:renewal lifetime=239232"
2343 #
2344 #and having in krb5.conf:
2345 # ticket_lifetime = 799718400
2346 # renew_lifetime = 799718400
2347 #
2348 # The commands for the -2 keytab where were:
2349 # kinit [email protected]
2350 # kvno host/[email protected]
2351 # kvno cifs/[email protected]
2352 # kvno host/[email protected]
2353 # kvno cifs/[email protected]
2354 #
2355 # and then for the -3 keytab, I did
2356 #
2357 # net changetrustpw; kdestroy and the same again.
2358 #
2359 # This creates a credential cache with a very long lifetime (2036 at
2360 # at 2011-04), and shows that running 'net changetrustpw' does not
2361 # break existing logins (for the secrets.tdb method at least).
2362 #
2363
2364 $ret->{KRB5_CCACHE}="FILE:$prefix/krb5_ccache";
2365
2366 system("cp $self->{srcdir}/source3/selftest/ktest-krb5_ccache-2 $prefix/krb5_ccache-2");
2367 chmod 0600, "$prefix/krb5_ccache-2";
2368
2369 system("cp $self->{srcdir}/source3/selftest/ktest-krb5_ccache-3 $prefix/krb5_ccache-3");
2370 chmod 0600, "$prefix/krb5_ccache-3";
2371
2372 # We need world access to this share, as otherwise the domain
2373 # administrator from the AD domain provided by ktest can't
2374 # access the share for tests.
2375 chmod 0777, "$prefix/share";
2376
2377 if (not $self->check_or_start(
2378 env_vars => $ret,
2379 nmbd => "yes",
2380 winbindd => "offline",
2381 smbd => "yes")) {
2382 return undef;
2383 }
2384 return $ret;
2385 }
2386
2387 sub setup_maptoguest
2388 {
2389 my ($self, $path) = @_;
2390 my $prefix = abs_path($path);
2391 my $libdir="$prefix/lib";
2392 my $share_dir="$prefix/share";
2393 my $errorinjectconf="$libdir/error_inject.conf";
2394
2395 print "PROVISIONING maptoguest...";
2396
2397 my $options = "
2398 domain logons = yes
2399 map to guest = bad user
2400 ntlm auth = yes
2401 server min protocol = LANMAN1
2402
2403 [force_user_error_inject]
2404 path = $share_dir
2405 vfs objects = acl_xattr fake_acls xattr_tdb error_inject
2406 force user = user1
2407 include = $errorinjectconf
2408 ";
2409
2410 my $vars = $self->provision(
2411 prefix => $path,
2412 domain => "WORKGROUP",
2413 server => "maptoguest",
2414 password => "maptoguestpass",
2415 extra_options => $options);
2416
2417 $vars or return undef;
2418
2419 if (not $self->check_or_start(
2420 env_vars => $vars,
2421 nmbd => "yes",
2422 winbindd => "yes",
2423 smbd => "yes")) {
2424 return undef;
2425 }
2426
2427 return $vars;
2428 }
2429
2430 sub stop_sig_term($$) {
2431 my ($self, $pid) = @_;
2432 kill("USR1", $pid) or kill("ALRM", $pid) or warn("Unable to kill $pid: $!");
2433 }
2434
2435 sub stop_sig_kill($$) {
2436 my ($self, $pid) = @_;
2437 kill("ALRM", $pid) or warn("Unable to kill $pid: $!");
2438 }
2439
2440 sub write_pid($$$)
2441 {
2442 my ($env_vars, $app, $pid) = @_;
2443
2444 open(PID, ">$env_vars->{PIDDIR}/timelimit.$app.pid");
2445 print PID $pid;
2446 close(PID);
2447 }
2448
2449 sub read_pid($$)
2450 {
2451 my ($env_vars, $app) = @_;
2452
2453 open(PID, "<$env_vars->{PIDDIR}/timelimit.$app.pid");
2454 my $pid = <PID>;
2455 close(PID);
2456 return $pid;
2457 }
2458
2459 # builds up the cmd args to run an s3 binary (i.e. smbd, nmbd, etc)
2460 sub make_bin_cmd
2461 {
2462 my ($self, $binary, $env_vars, $options, $valgrind, $dont_log_stdout) = @_;
2463
2464 my @optargs = ();
2465 if (defined($options)) {
2466 @optargs = split(/ /, $options);
2467 }
2468 my @preargs = (Samba::bindir_path($self, "timelimit"), $self->{server_maxtime});
2469
2470 if (defined($valgrind)) {
2471 @preargs = split(/ /, $valgrind);
2472 }
2473 my @args = ("-F", "--no-process-group",
2474 "--configfile=$env_vars->{SERVERCONFFILE}",
2475 "-l", $env_vars->{LOGDIR});
2476
2477 if (not defined($dont_log_stdout)) {
2478 push(@args, "--debug-stdout");
2479 }
2480 return (@preargs, $binary, @args, @optargs);
2481 }
2482
2483 sub check_or_start($$) {
2484 my ($self, %args) = @_;
2485 my $env_vars = $args{env_vars};
2486 my $nmbd = $args{nmbd} // "no";
2487 my $winbindd = $args{winbindd} // "no";
2488 my $smbd = $args{smbd} // "no";
2489 my $samba_dcerpcd = $args{samba_dcerpcd} // "no";
2490 my $child_cleanup = $args{child_cleanup};
2491
2492 my $STDIN_READER;
2493
2494 # use a pipe for stdin in the child processes. This allows
2495 # those processes to monitor the pipe for EOF to ensure they
2496 # exit when the test script exits
2497 pipe($STDIN_READER, $env_vars->{STDIN_PIPE});
2498
2499 my $binary = Samba::bindir_path($self, "samba-dcerpcd");
2500 my @full_cmd = $self->make_bin_cmd(
2501 $binary,
2502 $env_vars,
2503 $ENV{SAMBA_DCERPCD_OPTIONS},
2504 $ENV{SAMBA_DCERPCD_VALGRIND},
2505 $ENV{SAMBA_DCERPCD_DONT_LOG_STDOUT});
2506 push(@full_cmd, '--libexec-rpcds');
2507
2508 my $samba_dcerpcd_envs = Samba::get_env_for_process(
2509 "samba_dcerpcd", $env_vars);
2510
2511 # fork and exec() samba_dcerpcd in the child process
2512 my $daemon_ctx = {
2513 NAME => "samba_dcerpcd",
2514 BINARY_PATH => $binary,
2515 FULL_CMD => [ @full_cmd ],
2516 LOG_FILE => $env_vars->{SAMBA_DCERPCD_TEST_LOG},
2517 PCAP_FILE => "env-$ENV{ENVNAME}-samba_dcerpcd",
2518 ENV_VARS => $samba_dcerpcd_envs,
2519 };
2520 if ($samba_dcerpcd ne "yes") {
2521 $daemon_ctx->{SKIP_DAEMON} = 1;
2522 }
2523
2524 my $pid = Samba::fork_and_exec(
2525 $self, $env_vars, $daemon_ctx, $STDIN_READER, $child_cleanup);
2526
2527 $env_vars->{SAMBA_DCERPCD_TL_PID} = $pid;
2528 write_pid($env_vars, "samba_dcerpcd", $pid);
2529
2530 $binary = Samba::bindir_path($self, "nmbd");
2531 @full_cmd = $self->make_bin_cmd($binary, $env_vars,
2532 $ENV{NMBD_OPTIONS}, $ENV{NMBD_VALGRIND},
2533 $ENV{NMBD_DONT_LOG_STDOUT});
2534 my $nmbd_envs = Samba::get_env_for_process("nmbd", $env_vars);
2535 delete $nmbd_envs->{RESOLV_WRAPPER_CONF};
2536 delete $nmbd_envs->{RESOLV_WRAPPER_HOSTS};
2537
2538 # fork and exec() nmbd in the child process
2539 $daemon_ctx = {
2540 NAME => "nmbd",
2541 BINARY_PATH => $binary,
2542 FULL_CMD => [ @full_cmd ],
2543 LOG_FILE => $env_vars->{NMBD_TEST_LOG},
2544 PCAP_FILE => "env-$ENV{ENVNAME}-nmbd",
2545 ENV_VARS => $nmbd_envs,
2546 };
2547 if ($nmbd ne "yes") {
2548 $daemon_ctx->{SKIP_DAEMON} = 1;
2549 }
2550 $pid = Samba::fork_and_exec(
2551 $self, $env_vars, $daemon_ctx, $STDIN_READER, $child_cleanup);
2552
2553 $env_vars->{NMBD_TL_PID} = $pid;
2554 write_pid($env_vars, "nmbd", $pid);
2555
2556 $binary = Samba::bindir_path($self, "winbindd");
2557 @full_cmd = $self->make_bin_cmd($binary, $env_vars,
2558 $ENV{WINBINDD_OPTIONS},
2559 $ENV{WINBINDD_VALGRIND},
2560 $ENV{WINBINDD_DONT_LOG_STDOUT});
2561
2562 # fork and exec() winbindd in the child process
2563 $daemon_ctx = {
2564 NAME => "winbindd",
2565 BINARY_PATH => $binary,
2566 FULL_CMD => [ @full_cmd ],
2567 LOG_FILE => $env_vars->{WINBINDD_TEST_LOG},
2568 PCAP_FILE => "env-$ENV{ENVNAME}-winbindd",
2569 };
2570 if ($winbindd ne "yes" and $winbindd ne "offline") {
2571 $daemon_ctx->{SKIP_DAEMON} = 1;
2572 }
2573
2574 $pid = Samba::fork_and_exec(
2575 $self, $env_vars, $daemon_ctx, $STDIN_READER, $child_cleanup);
2576
2577 $env_vars->{WINBINDD_TL_PID} = $pid;
2578 write_pid($env_vars, "winbindd", $pid);
2579
2580 $binary = Samba::bindir_path($self, "smbd");
2581 @full_cmd = $self->make_bin_cmd($binary, $env_vars,
2582 $ENV{SMBD_OPTIONS}, $ENV{SMBD_VALGRIND},
2583 $ENV{SMBD_DONT_LOG_STDOUT});
2584
2585 # fork and exec() smbd in the child process
2586 $daemon_ctx = {
2587 NAME => "smbd",
2588 BINARY_PATH => $binary,
2589 FULL_CMD => [ @full_cmd ],
2590 LOG_FILE => $env_vars->{SMBD_TEST_LOG},
2591 PCAP_FILE => "env-$ENV{ENVNAME}-smbd",
2592 };
2593 if ($smbd ne "yes") {
2594 $daemon_ctx->{SKIP_DAEMON} = 1;
2595 }
2596
2597 $pid = Samba::fork_and_exec(
2598 $self, $env_vars, $daemon_ctx, $STDIN_READER, $child_cleanup);
2599
2600 $env_vars->{SMBD_TL_PID} = $pid;
2601 write_pid($env_vars, "smbd", $pid);
2602
2603 # close the parent's read-end of the pipe
2604 close($STDIN_READER);
2605
2606 return $self->wait_for_start($env_vars,
2607 $nmbd,
2608 $winbindd,
2609 $smbd,
2610 $samba_dcerpcd);
2611 }
2612
2613 sub createuser($$$$$)
2614 {
2615 my ($self, $username, $password, $conffile, $env) = @_;
2616 my $cmd = "UID_WRAPPER_ROOT=1 " . Samba::bindir_path($self, "smbpasswd")." -c $conffile -L -s -a $username > /dev/null";
2617
2618 keys %$env;
2619 while(my($var, $val) = each %$env) {
2620 $cmd = "$var=\"$val\" $cmd";
2621 }
2622
2623 unless (open(PWD, "|$cmd")) {
2624 warn("Unable to set password for $username account\n$cmd");
2625 return undef;
2626 }
2627 print PWD "$password\n$password\n";
2628 unless (close(PWD)) {
2629 warn("Unable to set password for $username account\n$cmd");
2630 return undef;
2631 }
2632 }
2633
2634 sub provision($$)
2635 {
2636 my ($self, %args) = @_;
2637
2638 my $prefix = $args{prefix};
2639 my $domain = $args{domain};
2640 my $realm = $args{realm};
2641 my $server = $args{server};
2642 my $password = $args{password};
2643 my $extra_options_before_inject = $args{extra_options_before_inject} // "";
2644 my $extra_options = $args{extra_options} // "";
2645 my $resolv_conf = $args{resolv_conf};
2646 my $no_delete_prefix= $args{no_delete_prefix};
2647 my $netbios_name = $args{netbios_name} // $server;
2648 my $server_log_level = $ENV{SERVER_LOG_LEVEL} || 1;
2649
2650 ##
2651 ## setup the various environment variables we need
2652 ##
2653
2654 my $samsid = Samba::random_domain_sid();
2655 my $swiface = Samba::get_interface($server);
2656 my %ret = ();
2657 my %createuser_env = ();
2658 my $server_ip = Samba::get_ipv4_addr($server);
2659 my $server_ipv6 = Samba::get_ipv6_addr($server);
2660 my $dns_domain;
2661 if (defined($realm)) {
2662 $dns_domain = lc($realm);
2663 } else {
2664 $dns_domain = "samba.example.com";
2665 }
2666
2667 my $unix_name = ($ENV{USER} or $ENV{LOGNAME} or `PATH=/usr/ucb:$ENV{PATH} whoami`);
2668 chomp $unix_name;
2669 my $unix_uid = $>;
2670 my $unix_gids_str = $);
2671 my @unix_gids = split(" ", $unix_gids_str);
2672
2673 my $bindir_abs = abs_path($self->{bindir});
2674
2675 my @dirs = ();
2676
2677 my $shrdir=$args{share_dir} // "$prefix/share";
2678 push(@dirs,$shrdir);
2679
2680 my $libdir="$prefix/lib";
2681 push(@dirs,$libdir);
2682
2683 my $piddir="$prefix/pid";
2684 push(@dirs,$piddir);
2685
2686 my $privatedir="$prefix/private";
2687 push(@dirs,$privatedir);
2688
2689 my $tlsdir="$privatedir/tls";
2690 push(@dirs, $tlsdir);
2691
2692 my $cachedir = "$prefix/cachedir";
2693 push(@dirs, $cachedir);
2694
2695 my $binddnsdir = "$prefix/bind-dns";
2696 push(@dirs, $binddnsdir);
2697
2698 my $lockdir="$prefix/lockdir";
2699 push(@dirs,$lockdir);
2700
2701 my $eventlogdir="$prefix/lockdir/eventlog";
2702 push(@dirs,$eventlogdir);
2703
2704 my $logdir="$prefix/logs";
2705 push(@dirs,$logdir);
2706
2707 my $driver32dir="$shrdir/W32X86";
2708 push(@dirs,$driver32dir);
2709
2710 my $driver64dir="$shrdir/x64";
2711 push(@dirs,$driver64dir);
2712
2713 my $driver40dir="$shrdir/WIN40";
2714 push(@dirs,$driver40dir);
2715
2716 my $ro_shrdir="$shrdir/root-tmp";
2717 push(@dirs,$ro_shrdir);
2718
2719 my $noperm_shrdir="$shrdir/noperm-tmp";
2720 push(@dirs,$noperm_shrdir);
2721
2722 my $msdfs_shrdir="$shrdir/msdfsshare";
2723 push(@dirs,$msdfs_shrdir);
2724
2725 my $msdfs_shrdir2="$shrdir/msdfsshare2";
2726 push(@dirs,$msdfs_shrdir2);
2727
2728 my $msdfs_pathname_share="$shrdir/msdfs_pathname_share";
2729 push(@dirs,$msdfs_pathname_share);
2730
2731 my $non_msdfs_pathname_share="$shrdir/non_msdfs_pathname_share";
2732 push(@dirs,$non_msdfs_pathname_share);
2733
2734 my $msdfs_deeppath="$msdfs_shrdir/deeppath";
2735 push(@dirs,$msdfs_deeppath);
2736
2737 my $smbcacls_sharedir_dfs="$shrdir/smbcacls_sharedir_dfs";
2738 push(@dirs,$smbcacls_sharedir_dfs);
2739
2740 my $smbcacls_share="$shrdir/smbcacls_share";
2741 push(@dirs,$smbcacls_share);
2742
2743 my $smbcacls_share_testdir="$shrdir/smbcacls_share/smbcacls";
2744 push(@dirs,$smbcacls_share_testdir);
2745
2746 my $badnames_shrdir="$shrdir/badnames";
2747 push(@dirs,$badnames_shrdir);
2748
2749 my $lease1_shrdir="$shrdir/dynamic";
2750 push(@dirs,$lease1_shrdir);
2751
2752 my $manglenames_shrdir="$shrdir/manglenames";
2753 push(@dirs,$manglenames_shrdir);
2754
2755 my $widelinks_shrdir="$shrdir/widelinks";
2756 push(@dirs,$widelinks_shrdir);
2757
2758 my $widelinks_linkdir="$shrdir/widelinks_foo";
2759 push(@dirs,$widelinks_linkdir);
2760
2761 my $fsrvp_shrdir="$shrdir/fsrvp";
2762 push(@dirs,$fsrvp_shrdir);
2763
2764 my $shadow_tstdir="$shrdir/shadow";
2765 push(@dirs,$shadow_tstdir);
2766 my $shadow_mntdir="$shadow_tstdir/mount";
2767 push(@dirs,$shadow_mntdir);
2768 my $shadow_basedir="$shadow_mntdir/base";
2769 push(@dirs,$shadow_basedir);
2770 my $shadow_shrdir="$shadow_basedir/share";
2771 push(@dirs,$shadow_shrdir);
2772
2773 my $nosymlinks_shrdir="$shrdir/nosymlinks";
2774 push(@dirs,$nosymlinks_shrdir);
2775
2776 my $local_symlinks_shrdir="$shrdir/local_symlinks";
2777 push(@dirs,$local_symlinks_shrdir);
2778
2779 my $worm_shrdir="$shrdir/worm";
2780 push(@dirs,$worm_shrdir);
2781
2782 my $fruit_resource_stream_shrdir="$shrdir/fruit_resource_stream";
2783 push(@dirs,$fruit_resource_stream_shrdir);
2784
2785 my $smbget_sharedir="$shrdir/smbget";
2786 push(@dirs, $smbget_sharedir);
2787
2788 my $recycle_shrdir="$shrdir/recycle";
2789 push(@dirs,$recycle_shrdir);
2790
2791 my $recycle_shrdir2="$shrdir/recycle2";
2792 push(@dirs,$recycle_shrdir2);
2793
2794 my $fakedircreatetimes_shrdir="$shrdir/fakedircreatetimes";
2795 push(@dirs,$fakedircreatetimes_shrdir);
2796
2797 # this gets autocreated by winbindd
2798 my $wbsockdir="$prefix/wbsock";
2799
2800 my $nmbdsockdir="$prefix/nmbd";
2801 unlink($nmbdsockdir);
2802
2803 ##
2804 ## create the test directory layout
2805 ##
2806 die ("prefix = ''") if $prefix eq "";
2807 die ("prefix = '/'") if $prefix eq "/";
2808
2809 mkdir($prefix, 0777);
2810 print "CREATE TEST ENVIRONMENT IN '$prefix'...";
2811 if (not defined($no_delete_prefix) or not $no_delete_prefix) {
2812 system("rm -rf $prefix/*");
2813 }
2814 mkdir($_, 0777) foreach(@dirs);
2815
2816 my $fs_specific_conf = $self->get_fs_specific_conf($shrdir);
2817
2818 ##
2819 ## lockdir and piddir must be 0755
2820 ##
2821 chmod 0755, $lockdir;
2822 chmod 0755, $piddir;
2823
2824
2825 ##
2826 ## Create a directory without permissions to enter
2827 ##
2828 chmod 0000, $noperm_shrdir;
2829
2830 ##
2831 ## create ro and msdfs share layout
2832 ##
2833
2834 chmod 0755, $ro_shrdir;
2835
2836 create_file_chmod("$ro_shrdir/readable_file", 0644) or return undef;
2837 create_file_chmod("$ro_shrdir/unreadable_file", 0600) or return undef;
2838
2839 create_file_chmod("$ro_shrdir/msdfs-target", 0600) or return undef;
2840 symlink "msdfs:$server_ip\\ro-tmp,$server_ipv6\\ro-tmp",
2841 "$msdfs_shrdir/msdfs-src1";
2842 symlink "msdfs:$server_ipv6\\ro-tmp", "$msdfs_shrdir/deeppath/msdfs-src2";
2843 symlink "msdfs:$server_ip\\smbcacls_sharedir_dfs,$server_ipv6\\smbcacls_sharedir_dfs",
2844 "$msdfs_shrdir/smbcacls_sharedir_dfs";
2845
2846 symlink "msdfs:$server_ip\\msdfs-share2,$server_ipv6\\msdfs-share2", "$msdfs_shrdir/dfshop1";
2847 symlink "msdfs:$server_ip\\tmp,$server_ipv6\\tmp", "$msdfs_shrdir2/dfshop2";
2848 ##
2849 ## create bad names in $badnames_shrdir
2850 ##
2851 ## (An invalid name, would be mangled to 8.3).
2852 create_file_chmod("$badnames_shrdir/\340|\231\216\377\177",
2853 0600) or return undef;
2854
2855 ## (A bad name, would not be mangled to 8.3).
2856 create_file_chmod("$badnames_shrdir/\240\276\346\327\377\177",
2857 0666) or return undef;
2858
2859 ## (A bad good name).
2860 create_file_chmod("$badnames_shrdir/blank.txt",
2861 0666) or return undef;
2862
2863 ##
2864 ## create mangleable directory names in $manglenames_shrdir
2865 ##
2866 my $manglename_target = "$manglenames_shrdir/foo:bar";
2867 mkdir($manglename_target, 0777);
2868
2869 ##
2870 ## create symlinks for widelinks tests.
2871 ##
2872 my $widelinks_target = "$widelinks_linkdir/target";
2873 create_file_chmod("$widelinks_target", 0666) or return undef;
2874
2875 ##
2876 ## This link should get an error
2877 ##
2878 symlink "$widelinks_target", "$widelinks_shrdir/source";
2879 ##
2880 ## This link should be allowed
2881 ##
2882 symlink "$widelinks_shrdir", "$widelinks_shrdir/dot";
2883
2884 ##
2885 ## Create test file with hardlinks for posix extensions testing with
2886 ## [smb3_posix_share]
2887 ##
2888 create_file_chmod("$shrdir/posix_test_original.txt", 0644) or return undef;
2889 link "$shrdir/posix_test_original.txt", "$shrdir/posix_test_hardlink1.txt";
2890 link "$shrdir/posix_test_original.txt", "$shrdir/posix_test_hardlink2.txt";
2891
2892 my $conffile="$libdir/server.conf";
2893 my $dfqconffile="$libdir/dfq.conf";
2894 my $errorinjectconf="$libdir/error_inject.conf";
2895 my $delayinjectconf="$libdir/delay_inject.conf";
2896 my $globalinjectconf="$libdir/global_inject.conf";
2897 my $aliceconfdir="$libdir";
2898 my $aliceconffile="$libdir/alice.conf";
2899
2900 my $nss_wrapper_pl = "$ENV{PERL} $self->{srcdir}/third_party/nss_wrapper/nss_wrapper.pl";
2901 my $nss_wrapper_passwd = "$privatedir/passwd";
2902 my $nss_wrapper_group = "$privatedir/group";
2903 my $nss_wrapper_hosts = "$ENV{SELFTEST_PREFIX}/hosts";
2904 my $dns_host_file = "$ENV{SELFTEST_PREFIX}/dns_host_file";
2905
2906 my $mod_printer_pl = "$ENV{PERL} $self->{srcdir}/source3/script/tests/printing/modprinter.pl";
2907
2908 my $fake_snap_pl = "$ENV{PERL} $self->{srcdir}/source3/script/tests/fake_snap.pl";
2909
2910 my @eventlog_list = ("dns server", "application");
2911
2912 ##
2913 ## calculate uids and gids
2914 ##
2915
2916 my ($max_uid, $max_gid);
2917 my ($uid_nobody, $uid_root, $uid_pdbtest, $uid_pdbtest2, $uid_userdup);
2918 my ($uid_pdbtest_wkn);
2919 my ($uid_smbget);
2920 my ($uid_force_user);
2921 my ($gid_nobody, $gid_nogroup, $gid_root, $gid_domusers, $gid_domadmins);
2922 my ($gid_userdup, $gid_everyone);
2923 my ($gid_force_user);
2924 my ($gid_jackthemapper);
2925 my ($gid_jacknomapper);
2926 my ($gid_group1);
2927 my ($gid_group2);
2928 my ($uid_user1);
2929 my ($uid_user2);
2930 my ($uid_gooduser);
2931 my ($uid_eviluser);
2932 my ($uid_slashuser);
2933 my ($uid_localbob);
2934 my ($uid_localjane);
2935 my ($uid_localjackthemapper);
2936 my ($uid_localjacknomapper);
2937
2938 if ($unix_uid < 0xffff - 13) {
2939 $max_uid = 0xffff;
2940 } else {
2941 $max_uid = $unix_uid;
2942 }
2943
2944 $uid_root = $max_uid - 1;
2945 $uid_nobody = $max_uid - 2;
2946 $uid_pdbtest = $max_uid - 3;
2947 $uid_pdbtest2 = $max_uid - 4;
2948 $uid_userdup = $max_uid - 5;
2949 $uid_pdbtest_wkn = $max_uid - 6;
2950 $uid_force_user = $max_uid - 7;
2951 $uid_smbget = $max_uid - 8;
2952 $uid_user1 = $max_uid - 9;
2953 $uid_user2 = $max_uid - 10;
2954 $uid_gooduser = $max_uid - 11;
2955 $uid_eviluser = $max_uid - 12;
2956 $uid_slashuser = $max_uid - 13;
2957 $uid_localbob = $max_uid - 14;
2958 $uid_localjane = $max_uid - 15;
2959 $uid_localjackthemapper = $max_uid - 16;
2960 $uid_localjacknomapper = $max_uid - 17;
2961
2962 if ($unix_gids[0] < 0xffff - 8) {
2963 $max_gid = 0xffff;
2964 } else {
2965 $max_gid = $unix_gids[0];
2966 }
2967
2968 $gid_nobody = $max_gid - 1;
2969 $gid_nogroup = $max_gid - 2;
2970 $gid_root = $max_gid - 3;
2971 $gid_domusers = $max_gid - 4;
2972 $gid_domadmins = $max_gid - 5;
2973 $gid_userdup = $max_gid - 6;
2974 $gid_everyone = $max_gid - 7;
2975 $gid_force_user = $max_gid - 8;
2976 $gid_jackthemapper = $max_gid - 9;
2977 $gid_jacknomapper = $max_gid - 10;
2978 $gid_group1 = $max_gid - 11;
2979 $gid_group2 = $max_gid - 12;
2980
2981 ##
2982 ## create conffile
2983 ##
2984
2985 unless (open(CONF, ">$conffile")) {
2986 warn("Unable to open $conffile");
2987 return undef;
2988 }
2989
2990 my $interfaces = Samba::get_interfaces_config($server);
2991
2992 print CONF "
2993 [global]
2994 dcesrv:fuzz directory = $cachedir/fuzz
2995 netbios name = $netbios_name
2996 interfaces = $interfaces
2997 bind interfaces only = yes
2998 panic action = cd $self->{srcdir} && $self->{srcdir}/selftest/gdb_backtrace %d %\$(MAKE_TEST_BINARY)
2999 smbd:suicide mode = yes
3000 smbd:FSCTL_SMBTORTURE = yes
3001 smbd:validate_oplock_types = yes
3002
3003 client min protocol = SMB2_02
3004 server min protocol = SMB2_02
3005
3006 server multi channel support = yes
3007
3008 workgroup = $domain
3009
3010 private dir = $privatedir
3011 binddns dir = $binddnsdir
3012 pid directory = $piddir
3013 lock directory = $lockdir
3014 log file = $logdir/log.\%m
3015 log level = $server_log_level
3016 winbind debug traceid = yes
3017 debug pid = yes
3018 max log size = 0
3019
3020 debug syslog format = always
3021 debug hires timestamp = yes
3022
3023 state directory = $lockdir
3024 cache directory = $lockdir
3025
3026 passdb backend = tdbsam
3027
3028 time server = yes
3029
3030 add user script = $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action add --name %u --gid $gid_nogroup
3031 add group script = $nss_wrapper_pl --group_path $nss_wrapper_group --type group --action add --name %g
3032 add machine script = $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action add --name %u --gid $gid_nogroup
3033 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
3034 delete user script = $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action delete --name %u
3035 delete group script = $nss_wrapper_pl --group_path $nss_wrapper_group --type group --action delete --name %g
3036 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
3037
3038 addprinter command = $mod_printer_pl -a -s $conffile --
3039 deleteprinter command = $mod_printer_pl -d -s $conffile --
3040
3041 eventlog list = application \"dns server\"
3042
3043 kernel oplocks = no
3044 kernel change notify = no
3045
3046 logging = file
3047 printing = bsd
3048 printcap name = /dev/null
3049
3050 winbindd socket directory = $wbsockdir
3051 nmbd:socket dir = $nmbdsockdir
3052 idmap config * : range = 100000-200000
3053 winbind enum users = yes
3054 winbind enum groups = yes
3055 winbind separator = /
3056 include system krb5 conf = no
3057
3058 # min receivefile size = 4000
3059
3060 read only = no
3061
3062 smbd:sharedelay = 100000
3063 smbd:writetimeupdatedelay = 500000
3064 map hidden = no
3065 map system = no
3066 map readonly = no
3067 store dos attributes = yes
3068 create mask = 755
3069 dos filemode = yes
3070 strict rename = yes
3071 strict sync = yes
3072 mangled names = yes
3073 vfs objects = acl_xattr fake_acls xattr_tdb streams_depot time_audit full_audit
3074
3075 full_audit:syslog = no
3076 full_audit:success = none
3077 full_audit:failure = none
3078
3079 printing = vlp
3080 print command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb print %p %s
3081 lpq command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpq %p
3082 lp rm command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lprm %p %j
3083 lp pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lppause %p %j
3084 lp resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpresume %p %j
3085 queue pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queuepause %p
3086 queue resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queueresume %p
3087 lpq cache time = 0
3088 print notify backchannel = yes
3089
3090 ncalrpc dir = $prefix/ncalrpc
3091
3092 # The samba3.blackbox.smbclient_s3 test uses this to test that
3093 # sending messages works, and that the %m sub works.
3094 message command = mv %s $shrdir/message.%m
3095
3096 # fsrvp server requires registry shares
3097 registry shares = yes
3098
3099 # Used by RPC SRVSVC tests
3100 add share command = $bindir_abs/smbaddshare
3101 change share command = $bindir_abs/smbchangeshare
3102 delete share command = $bindir_abs/smbdeleteshare
3103
3104 # fruit:copyfile is a global option
3105 fruit:copyfile = yes
3106
3107 #this does not mean that we use non-secure test env,
3108 #it just means we ALLOW one to be configured.
3109 allow insecure wide links = yes
3110
3111 # Begin extra options before global inject
3112 $extra_options_before_inject
3113 # End extra options befoore global inject
3114
3115 include = $globalinjectconf
3116
3117 # Begin extra options
3118 $extra_options
3119 # End extra options
3120
3121 #Include user defined custom parameters if set
3122 ";
3123
3124 if (defined($ENV{INCLUDE_CUSTOM_CONF})) {
3125 print CONF "\t$ENV{INCLUDE_CUSTOM_CONF}\n";
3126 }
3127
3128 print CONF "
3129 [smbcacls_share]
3130 path = $smbcacls_share
3131 comment = smb username is [%U]
3132 msdfs root = yes
3133
3134 [smbcacls_sharedir_dfs]
3135 path = $smbcacls_sharedir_dfs
3136 comment = smb username is [%U]
3137 [tmp]
3138 path = $shrdir
3139 comment = smb username is [%U]
3140 [tmpsort]
3141 path = $shrdir
3142 comment = Load dirsort module
3143 vfs objects = dirsort acl_xattr fake_acls xattr_tdb streams_depot
3144 [tmpenc]
3145 path = $shrdir
3146 comment = encrypt smb username is [%U]
3147 server smb encrypt = required
3148 vfs objects = dirsort
3149 [tmpguest]
3150 path = $shrdir
3151 guest ok = yes
3152 [guestonly]
3153 path = $shrdir
3154 guest only = yes
3155 guest ok = yes
3156 [forceuser]
3157 path = $shrdir
3158 force user = $unix_name
3159 guest ok = yes
3160 [forceuser_unixonly]
3161 comment = force a user with unix user SID and group SID
3162 path = $shrdir
3163 force user = pdbtest
3164 guest ok = yes
3165 [forceuser_wkngroup]
3166 comment = force a user with well-known group SID
3167 path = $shrdir
3168 force user = pdbtest_wkn
3169 guest ok = yes
3170 [forcegroup]
3171 path = $shrdir
3172 force group = nogroup
3173 guest ok = yes
3174 [ro-tmp]
3175 path = $ro_shrdir
3176 guest ok = yes
3177 [noperm]
3178 path = $noperm_shrdir
3179 wide links = yes
3180 guest ok = yes
3181 [write-list-tmp]
3182 path = $shrdir
3183 read only = yes
3184 write list = $unix_name
3185 [valid-users-tmp]
3186 path = $shrdir
3187 valid users = $unix_name
3188 access based share enum = yes
3189 [msdfs-share]
3190 path = $msdfs_shrdir
3191 msdfs root = yes
3192 msdfs shuffle referrals = yes
3193 guest ok = yes
3194 [msdfs-share-wl]
3195 path = $msdfs_shrdir
3196 msdfs root = yes
3197 wide links = yes
3198 guest ok = yes
3199 [msdfs-share2]
3200 path = $msdfs_shrdir2
3201 msdfs root = yes
3202 guest ok = yes
3203 [msdfs-pathname-share]
3204 path = $msdfs_pathname_share
3205 msdfs root = yes
3206 guest ok = yes
3207 [non-msdfs-pathname-share]
3208 path = $non_msdfs_pathname_share
3209 msdfs root = no
3210 guest ok = yes
3211 [hideunread]
3212 copy = tmp
3213 hide unreadable = yes
3214 [tmpcase]
3215 copy = tmp
3216 case sensitive = yes
3217 [hideunwrite]
3218 copy = tmp
3219 hide unwriteable files = yes
3220 [durable]
3221 copy = tmp
3222 kernel share modes = no
3223 kernel oplocks = no
3224 posix locking = no
3225 [fs_specific]
3226 copy = tmp
3227 $fs_specific_conf
3228 [print1]
3229 copy = tmp
3230 printable = yes
3231
3232 [print2]
3233 copy = print1
3234 [print3]
3235 copy = print1
3236 default devmode = no
3237
3238 [print_var_exp]
3239 copy = print1
3240 print command = $self->{srcdir}/source3/script/tests/printing/printing_var_exp_lpr_cmd.sh \"Windows user: %U\" \"UNIX user: %u\" \"Domain: %D\"
3241
3242 [lp]
3243 copy = print1
3244
3245 [nfs4acl_simple_40]
3246 path = $shrdir
3247 comment = smb username is [%U]
3248 nfs4:mode = simple
3249 nfs4acl_xattr:version = 40
3250 vfs objects = nfs4acl_xattr xattr_tdb
3251
3252 [nfs4acl_special_40]
3253 path = $shrdir
3254 comment = smb username is [%U]
3255 nfs4:mode = special
3256 nfs4acl_xattr:version = 40
3257 vfs objects = nfs4acl_xattr xattr_tdb
3258
3259 [nfs4acl_simple_41]
3260 path = $shrdir
3261 comment = smb username is [%U]
3262 nfs4:mode = simple
3263 vfs objects = nfs4acl_xattr xattr_tdb
3264
3265 [nfs4acl_xdr_40]
3266 path = $shrdir
3267 comment = smb username is [%U]
3268 vfs objects = nfs4acl_xattr xattr_tdb
3269 nfs4:mode = simple
3270 nfs4acl_xattr:encoding = xdr
3271 nfs4acl_xattr:version = 40
3272
3273 [nfs4acl_xdr_41]
3274 path = $shrdir
3275 comment = smb username is [%U]
3276 vfs objects = nfs4acl_xattr xattr_tdb
3277 nfs4:mode = simple
3278 nfs4acl_xattr:encoding = xdr
3279 nfs4acl_xattr:version = 41
3280
3281 [nfs4acl_nfs_40]
3282 path = $shrdir
3283 comment = smb username is [%U]
3284 vfs objects = nfs4acl_xattr xattr_tdb
3285 nfs4:mode = simple
3286 nfs4acl_xattr:encoding = nfs
3287 nfs4acl_xattr:version = 40
3288 nfs4acl_xattr:xattr_name = security.nfs4acl_xdr
3289
3290 [nfs4acl_nfs_41]
3291 path = $shrdir
3292 comment = smb username is [%U]
3293 vfs objects = nfs4acl_xattr xattr_tdb
3294 nfs4:mode = simple
3295 nfs4acl_xattr:encoding = nfs
3296 nfs4acl_xattr:version = 41
3297 nfs4acl_xattr:xattr_name = security.nfs4acl_xdr
3298
3299 [xcopy_share]
3300 path = $shrdir
3301 comment = smb username is [%U]
3302 create mask = 777
3303 force create mode = 777
3304 [posix_share]
3305 path = $shrdir
3306 comment = smb username is [%U]
3307 create mask = 0777
3308 force create mode = 0
3309 directory mask = 0777
3310 force directory mode = 0
3311 vfs objects = xattr_tdb streams_depot
3312 [smb3_posix_share]
3313 vfs objects = fake_acls xattr_tdb streams_depot time_audit full_audit
3314 create mask = 07777
3315 directory mask = 07777
3316 mangled names = no
3317 path = $shrdir
3318 read only = no
3319 guest ok = yes
3320 [aio]
3321 copy = durable
3322 aio read size = 1
3323 aio write size = 1
3324
3325 [print\$]
3326 copy = tmp
3327
3328 [vfs_fruit]
3329 path = $shrdir
3330 vfs objects = catia fruit streams_xattr acl_xattr xattr_tdb
3331 fruit:resource = file
3332 fruit:metadata = netatalk
3333 fruit:locking = netatalk
3334 fruit:encoding = native
3335 fruit:veto_appledouble = no
3336
3337 [vfs_fruit_xattr]
3338 path = $shrdir
3339 # This is used by vfs.fruit tests that require real fs xattr
3340 vfs objects = catia fruit streams_xattr acl_xattr
3341 fruit:resource = file
3342 fruit:metadata = netatalk
3343 fruit:locking = netatalk
3344 fruit:encoding = native
3345 fruit:veto_appledouble = no
3346
3347 [vfs_fruit_metadata_stream]
3348 path = $shrdir
3349 vfs objects = fruit streams_xattr acl_xattr xattr_tdb
3350 fruit:resource = file
3351 fruit:metadata = stream
3352 fruit:veto_appledouble = no
3353
3354 [vfs_fruit_stream_depot]
3355 path = $shrdir
3356 vfs objects = fruit streams_depot acl_xattr xattr_tdb
3357 fruit:resource = stream
3358 fruit:metadata = stream
3359 fruit:veto_appledouble = no
3360
3361 [vfs_wo_fruit]
3362 path = $shrdir
3363 vfs objects = streams_xattr acl_xattr xattr_tdb
3364
3365 [vfs_wo_fruit_stream_depot]
3366 path = $shrdir
3367 vfs objects = streams_depot acl_xattr xattr_tdb
3368
3369 [vfs_fruit_timemachine]
3370 path = $shrdir
3371 vfs objects = fruit streams_xattr acl_xattr xattr_tdb
3372 fruit:resource = file
3373 fruit:metadata = stream
3374 fruit:time machine = yes
3375 fruit:time machine max size = 32K
3376
3377 [vfs_fruit_wipe_intentionally_left_blank_rfork]
3378 path = $shrdir
3379 vfs objects = fruit streams_xattr acl_xattr xattr_tdb
3380 fruit:resource = file
3381 fruit:metadata = stream
3382 fruit:wipe_intentionally_left_blank_rfork = true
3383 fruit:delete_empty_adfiles = false
3384 fruit:veto_appledouble = no
3385
3386 [vfs_fruit_delete_empty_adfiles]
3387 path = $shrdir
3388 vfs objects = fruit streams_xattr acl_xattr xattr_tdb
3389 fruit:resource = file
3390 fruit:metadata = stream
3391 fruit:wipe_intentionally_left_blank_rfork = true
3392 fruit:delete_empty_adfiles = true
3393 fruit:veto_appledouble = no
3394
3395 [vfs_fruit_zero_fileid]
3396 path = $shrdir
3397 vfs objects = fruit streams_xattr acl_xattr xattr_tdb
3398 fruit:resource = file
3399 fruit:metadata = stream
3400 fruit:zero_file_id=yes
3401 fruit:validate_afpinfo = no
3402
3403 [fruit_resource_stream]
3404 path = $fruit_resource_stream_shrdir
3405 vfs objects = fruit streams_xattr acl_xattr xattr_tdb
3406 fruit:resource = stream
3407 fruit:metadata = stream
3408
3409 [badname-tmp]
3410 path = $badnames_shrdir
3411 guest ok = yes
3412
3413 [manglenames_share]
3414 path = $manglenames_shrdir
3415 guest ok = yes
3416
3417 [dynamic_share]
3418 path = $shrdir/dynamic/%t
3419 guest ok = yes
3420 root preexec = mkdir %P
3421
3422 [widelinks_share]
3423 path = $widelinks_shrdir
3424 wide links = no
3425 guest ok = yes
3426
3427 [fsrvp_share]
3428 path = $fsrvp_shrdir
3429 comment = fake snapshots using rsync
3430 vfs objects = shell_snap shadow_copy2
3431 shell_snap:check path command = $fake_snap_pl --check
3432 shell_snap:create command = $fake_snap_pl --create
3433 shell_snap:delete command = $fake_snap_pl --delete
3434 # a relative path here fails, the snapshot dir is no longer found
3435 shadow:snapdir = $fsrvp_shrdir/.snapshots
3436
3437 [shadow1]
3438 path = $shadow_shrdir
3439 comment = previous versions snapshots under mount point
3440 vfs objects = shadow_copy2
3441 shadow:mountpoint = $shadow_mntdir
3442
3443 [shadow2]
3444 path = $shadow_shrdir
3445 comment = previous versions snapshots outside mount point
3446 vfs objects = shadow_copy2
3447 shadow:mountpoint = $shadow_mntdir
3448 shadow:snapdir = $shadow_tstdir/.snapshots
3449
3450 [shadow3]
3451 path = $shadow_shrdir
3452 comment = previous versions with subvolume snapshots, snapshots under base dir
3453 vfs objects = shadow_copy2
3454 shadow:mountpoint = $shadow_mntdir
3455 shadow:basedir = $shadow_basedir
3456 shadow:snapdir = $shadow_basedir/.snapshots
3457
3458 [shadow4]
3459 path = $shadow_shrdir
3460 comment = previous versions with subvolume snapshots, snapshots outside mount point
3461 vfs objects = shadow_copy2
3462 shadow:mountpoint = $shadow_mntdir
3463 shadow:basedir = $shadow_basedir
3464 shadow:snapdir = $shadow_tstdir/.snapshots
3465
3466 [shadow5]
3467 path = $shadow_shrdir
3468 comment = previous versions at volume root snapshots under mount point
3469 vfs objects = shadow_copy2
3470 shadow:mountpoint = $shadow_shrdir
3471
3472 [shadow6]
3473 path = $shadow_shrdir
3474 comment = previous versions at volume root snapshots outside mount point
3475 vfs objects = shadow_copy2
3476 shadow:mountpoint = $shadow_shrdir
3477 shadow:snapdir = $shadow_tstdir/.snapshots
3478
3479 [shadow7]
3480 path = $shadow_shrdir
3481 comment = previous versions snapshots everywhere
3482 vfs objects = shadow_copy2
3483 shadow:mountpoint = $shadow_mntdir
3484 shadow:snapdirseverywhere = yes
3485
3486 [shadow8]
3487 path = $shadow_shrdir
3488 comment = previous versions using snapsharepath
3489 vfs objects = shadow_copy2
3490 shadow:mountpoint = $shadow_mntdir
3491 shadow:snapdir = $shadow_tstdir/.snapshots
3492 shadow:snapsharepath = share
3493
3494 [shadow_fmt0]
3495 comment = Testing shadow:format with default option
3496 vfs object = shadow_copy2
3497 path = $shadow_shrdir
3498 read only = no
3499 guest ok = yes
3500 shadow:mountpoint = $shadow_mntdir
3501 shadow:basedir = $shadow_basedir
3502 shadow:snapdir = $shadow_basedir/.snapshots
3503 shadow:format = \@GMT-%Y.%m.%d-%H.%M.%S
3504
3505 [shadow_fmt1]
3506 comment = Testing shadow:format with only date component
3507 vfs object = shadow_copy2
3508 path = $shadow_shrdir
3509 read only = no
3510 guest ok = yes
3511 shadow:mountpoint = $shadow_mntdir
3512 shadow:basedir = $shadow_basedir
3513 shadow:snapdir = $shadow_basedir/.snapshots
3514 shadow:format = \@GMT-%Y-%m-%d
3515
3516 [shadow_fmt2]
3517 comment = Testing shadow:format with some hardcoded prefix
3518 vfs object = shadow_copy2
3519 path = $shadow_shrdir
3520 read only = no
3521 guest ok = yes
3522 shadow:mountpoint = $shadow_mntdir
3523 shadow:basedir = $shadow_basedir
3524 shadow:snapdir = $shadow_basedir/.snapshots
3525 shadow:format = snap\@GMT-%Y.%m.%d-%H.%M.%S
3526
3527 [shadow_fmt3]
3528 comment = Testing shadow:format with modified format
3529 vfs object = shadow_copy2
3530 path = $shadow_shrdir
3531 read only = no
3532 guest ok = yes
3533 shadow:mountpoint = $shadow_mntdir
3534 shadow:basedir = $shadow_basedir
3535 shadow:snapdir = $shadow_basedir/.snapshots
3536 shadow:format = \@GMT-%Y.%m.%d-%H_%M_%S-snap
3537
3538 [shadow_fmt4]
3539 comment = Testing shadow:snapprefix regex
3540 vfs object = shadow_copy2
3541 path = $shadow_shrdir
3542 read only = no
3543 guest ok = yes
3544 shadow:mountpoint = $shadow_mntdir
3545 shadow:basedir = $shadow_basedir
3546 shadow:snapdir = $shadow_basedir/.snapshots
3547 shadow:snapprefix = \^s[a-z]*p\$
3548 shadow:format = _GMT-%Y.%m.%d-%H.%M.%S
3549
3550 [shadow_fmt5]
3551 comment = Testing shadow:snapprefix with delim regex
3552 vfs object = shadow_copy2
3553 path = $shadow_shrdir
3554 read only = no
3555 guest ok = yes
3556 shadow:mountpoint = $shadow_mntdir
3557 shadow:basedir = $shadow_basedir
3558 shadow:snapdir = $shadow_basedir/.snapshots
3559 shadow:delimiter = \@GMT
3560 shadow:snapprefix = [a-z]*
3561 shadow:format = \@GMT-%Y.%m.%d-%H.%M.%S
3562
3563 [shadow_wl]
3564 path = $shadow_shrdir
3565 comment = previous versions with wide links allowed
3566 vfs objects = shadow_copy2
3567 shadow:mountpoint = $shadow_mntdir
3568 wide links = yes
3569
3570 [shadow_write]
3571 path = $shadow_tstdir
3572 comment = previous versions snapshots under mount point
3573 vfs objects = shadow_copy2 streams_xattr
3574 shadow:mountpoint = $shadow_tstdir
3575 shadow:fixinodes = yes
3576 smbd async dosmode = yes
3577
3578 [shadow_depot]
3579 path = $shadow_shrdir
3580 comment = previous versions with streams_depot
3581 vfs objects = streams_depot shadow_copy2
3582
3583 [dfq]
3584 path = $shrdir/dfree
3585 vfs objects = acl_xattr fake_acls xattr_tdb fake_dfq
3586 admin users = $unix_name
3587 include = $dfqconffile
3588 [dfq_cache]
3589 path = $shrdir/dfree
3590 vfs objects = acl_xattr fake_acls xattr_tdb fake_dfq
3591 admin users = $unix_name
3592 include = $dfqconffile
3593 dfree cache time = 60
3594 [dfq_owner]
3595 path = $shrdir/dfree
3596 vfs objects = acl_xattr fake_acls xattr_tdb fake_dfq
3597 inherit owner = yes
3598 include = $dfqconffile
3599 [quotadir]
3600 path = $shrdir/quota
3601 admin users = $unix_name
3602
3603 [acl_xattr_ign_sysacl_posix]
3604 copy = tmp
3605 acl_xattr:ignore system acls = yes
3606 acl_xattr:default acl style = posix
3607 [acl_xattr_ign_sysacl_windows]
3608 copy = tmp
3609 acl_xattr:ignore system acls = yes
3610 acl_xattr:default acl style = windows
3611
3612 [mangle_illegal]
3613 copy = tmp
3614 mangled names = illegal
3615
3616 [nosymlinks]
3617 copy = tmp
3618 path = $nosymlinks_shrdir
3619 follow symlinks = no
3620 [nosymlinks_smb1allow]
3621 copy=nosymlinks
3622 follow symlinks = yes
3623
3624 [local_symlinks]
3625 copy = tmp
3626 path = $local_symlinks_shrdir
3627 follow symlinks = yes
3628
3629 [worm]
3630 copy = tmp
3631 path = $worm_shrdir
3632 vfs objects = worm
3633 worm:grace_period = 1
3634 comment = vfs_worm with 1s grace_period
3635
3636 [kernel_oplocks]
3637 copy = tmp
3638 kernel oplocks = yes
3639 vfs objects = streams_xattr xattr_tdb
3640
3641 [streams_xattr]
3642 copy = tmp
3643 vfs objects = streams_xattr xattr_tdb
3644
3645 [streams_xattr_nostrict]
3646 copy = tmp
3647 strict rename = no
3648 vfs objects = streams_xattr xattr_tdb
3649
3650 [acl_streams_xattr]
3651 copy = tmp
3652 vfs objects = acl_xattr streams_xattr fake_acls xattr_tdb
3653 acl_xattr:ignore system acls = yes
3654 acl_xattr:security_acl_name = user.acl
3655 xattr_tdb:ignore_user_xattr = yes
3656
3657 [compound_find]
3658 copy = tmp
3659 smbd:find async delay usec = 10000
3660 [error_inject]
3661 copy = tmp
3662 vfs objects = error_inject
3663 include = $errorinjectconf
3664
3665 [delay_inject]
3666 copy = tmp
3667 vfs objects = delay_inject
3668 kernel share modes = no
3669 kernel oplocks = no
3670 posix locking = no
3671 include = $delayinjectconf
3672
3673 [aio_delay_inject]
3674 copy = tmp
3675 vfs objects = delay_inject
3676 delay_inject:pread_send = 2000
3677 delay_inject:pwrite_send = 2000
3678
3679 [brl_delay_inject1]
3680 copy = tmp
3681 vfs objects = delay_inject
3682 delay_inject:brl_lock_windows = 90
3683 delay_inject:brl_lock_windows_use_timer = yes
3684
3685 [brl_delay_inject2]
3686 copy = tmp
3687 vfs objects = delay_inject
3688 delay_inject:brl_lock_windows = 90
3689 delay_inject:brl_lock_windows_use_timer = no
3690
3691 [delete_readonly]
3692 path = $prefix/share
3693 delete readonly = yes
3694
3695 [enc_desired]
3696 path = $prefix/share
3697 vfs objects =
3698 server smb encrypt = desired
3699
3700 [enc_off]
3701 path = $prefix/share
3702 vfs objects =
3703 server smb encrypt = off
3704
3705 [notify_priv]
3706 copy = tmp
3707 honor change notify privilege = yes
3708
3709 [acls_non_canonical]
3710 copy = tmp
3711 acl flag inherited canonicalization = no
3712
3713 [full_audit_success_bad_name]
3714 copy = tmp
3715 full_audit:success = badname
3716
3717 [full_audit_fail_bad_name]
3718 copy = tmp
3719 full_audit:failure = badname
3720
3721 [only_ipv6]
3722 copy = tmpguest
3723 server addresses = $server_ipv6
3724
3725 [smbget]
3726 path = $smbget_sharedir
3727 comment = smb username is [%U]
3728
3729 [recycle]
3730 copy = tmp
3731 path = $recycle_shrdir
3732 vfs objects = recycle
3733 recycle : repository = .trash
3734 recycle : keeptree = yes
3735 recycle : touch = yes
3736 recycle : touch_mtime = yes
3737 recycle : exclude = *.tmp
3738 recycle : directory_mode = 755
3739
3740 [recycle2]
3741 copy = tmp
3742 path = $recycle_shrdir2
3743 vfs objects = recycle crossrename
3744 recycle : repository = .trash
3745 recycle : exclude = *.tmp
3746 recycle : directory_mode = 755
3747 wide links = yes
3748
3749 [fakedircreatetimes]
3750 copy = tmp
3751 path = $fakedircreatetimes_shrdir
3752 fake directory create times = yes
3753
3754 [smbget_guest]
3755 path = $smbget_sharedir
3756 comment = smb username is [%U]
3757 guest ok = yes
3758
3759 [aio_ratelimit]
3760 comment = Testing aio_ratelimit
3761 path = $shrdir
3762 vfs objects = aio_ratelimit
3763 aio_ratelimit: read_iops_limit = 10
3764 aio_ratelimit: read_bw_limit = 100K
3765 aio_ratelimit: read_burst_mult = 15
3766 aio_ratelimit: write_iops_limit = 100
3767 aio_ratelimit: write_bw_limit = 100K
3768 aio_ratelimit: write_burst_mult = 15
3769
3770 include = $aliceconfdir/%U.conf
3771 ";
3772
3773 close(CONF);
3774
3775 my $net = Samba::bindir_path($self, "net");
3776 my $cmd = "";
3777 $cmd .= "UID_WRAPPER_ROOT=1 ";
3778 $cmd .= "SMB_CONF_PATH=\"$conffile\" ";
3779 $cmd .= "$net setlocalsid $samsid";
3780
3781 my $net_ret = system($cmd);
3782 if ($net_ret != 0) {
3783 warn("net setlocalsid failed: $net_ret\n$cmd");
3784 return undef;
3785 }
3786
3787 unless (open(ERRORCONF, ">$errorinjectconf")) {
3788 warn("Unable to open $errorinjectconf");
3789 return undef;
3790 }
3791 close(ERRORCONF);
3792
3793 unless (open(DELAYCONF, ">$delayinjectconf")) {
3794 warn("Unable to open $delayinjectconf");
3795 return undef;
3796 }
3797 close(DELAYCONF);
3798
3799 unless (open(DFQCONF, ">$dfqconffile")) {
3800 warn("Unable to open $dfqconffile");
3801 return undef;
3802 }
3803 close(DFQCONF);
3804
3805 unless (open(DELAYCONF, ">$globalinjectconf")) {
3806 warn("Unable to open $globalinjectconf");
3807 return undef;
3808 }
3809 close(DELAYCONF);
3810
3811 unless (open(ALICECONF, ">$aliceconffile")) {
3812 warn("Unable to open $aliceconffile");
3813 return undef;
3814 }
3815
3816 print ALICECONF "
3817 [alice_share]
3818 path = $shrdir
3819 comment = smb username is [%U]
3820 ";
3821
3822 close(ALICECONF);
3823
3824 ##
3825 ## create a test account
3826 ##
3827
3828 unless (open(PASSWD, ">$nss_wrapper_passwd")) {
3829 warn("Unable to open $nss_wrapper_passwd");
3830 return undef;
3831 }
3832 print PASSWD "nobody:x:$uid_nobody:$gid_nobody:nobody gecos:$prefix:/bin/false
3833 $unix_name:x:$unix_uid:$unix_gids[0]:$unix_name gecos:$prefix:/bin/false
3834 pdbtest:x:$uid_pdbtest:$gid_nogroup:pdbtest gecos:$prefix:/bin/false
3835 pdbtest2:x:$uid_pdbtest2:$gid_nogroup:pdbtest gecos:$prefix:/bin/false
3836 userdup:x:$uid_userdup:$gid_userdup:userdup gecos:$prefix:/bin/false
3837 pdbtest_wkn:x:$uid_pdbtest_wkn:$gid_everyone:pdbtest_wkn gecos:$prefix:/bin/false
3838 force_user:x:$uid_force_user:$gid_force_user:force user gecos:$prefix:/bin/false
3839 smbget_user:x:$uid_smbget:$gid_domusers:smbget_user gecos:$prefix:/bin/false
3840 user1:x:$uid_user1:$gid_nogroup:user1 gecos:$prefix:/bin/false
3841 user2:x:$uid_user2:$gid_nogroup:user2 gecos:$prefix:/bin/false
3842 gooduser:x:$uid_gooduser:$gid_domusers:gooduser gecos:$prefix:/bin/false
3843 eviluser:x:$uid_eviluser:$gid_domusers:eviluser gecos::/bin/false
3844 slashuser:x:$uid_slashuser:$gid_domusers:slashuser gecos:/:/bin/false
3845 bob:x:$uid_localbob:$gid_domusers:localbob gecos:/:/bin/false
3846 jane:x:$uid_localjane:$gid_domusers:localjane gecos:/:/bin/false
3847 jackthemapper:x:$uid_localjackthemapper:$gid_domusers:localjackthemaper gecos:/:/bin/false
3848 jacknomapper:x:$uid_localjacknomapper:$gid_domusers:localjacknomaper gecos:/:/bin/false
3849 ";
3850 if ($unix_uid != 0) {
3851 print PASSWD "root:x:$uid_root:$gid_root:root gecos:$prefix:/bin/false
3852 ";
3853 }
3854 close(PASSWD);
3855
3856 unless (open(GROUP, ">$nss_wrapper_group")) {
3857 warn("Unable to open $nss_wrapper_group");
3858 return undef;
3859 }
3860 print GROUP "nobody:x:$gid_nobody:
3861 nogroup:x:$gid_nogroup:nobody
3862 $unix_name-group:x:$unix_gids[0]:
3863 domusers:X:$gid_domusers:
3864 domadmins:X:$gid_domadmins:
3865 userdup:x:$gid_userdup:$unix_name
3866 everyone:x:$gid_everyone:
3867 force_user:x:$gid_force_user:
3868 jackthemappergroup:x:$gid_jackthemapper:jackthemapper
3869 jacknomappergroup:x:$gid_jacknomapper:jacknomapper
3870 group1:x:$gid_group1:user1
3871 group2:x:$gid_group2:user2
3872 ";
3873 if ($unix_gids[0] != 0) {
3874 print GROUP "root:x:$gid_root:
3875 ";
3876 }
3877
3878 close(GROUP);
3879
3880 ## hosts
3881 my $hostname = lc($server);
3882 unless (open(HOSTS, ">>$nss_wrapper_hosts")) {
3883 warn("Unable to open $nss_wrapper_hosts");
3884 return undef;
3885 }
3886 print HOSTS "${server_ip} ${hostname}.${dns_domain} ${hostname}\n";
3887 print HOSTS "${server_ipv6} ${hostname}.${dns_domain} ${hostname}\n";
3888 close(HOSTS);
3889
3890 $resolv_conf = "$privatedir/no_resolv.conf" unless defined($resolv_conf);
3891
3892 foreach my $evlog (@eventlog_list) {
3893 my $evlogtdb = "$eventlogdir/$evlog.tdb";
3894 open(EVENTLOG, ">$evlogtdb") or die("Unable to open $evlogtdb");
3895 close(EVENTLOG);
3896 }
3897
3898 $createuser_env{NSS_WRAPPER_PASSWD} = $nss_wrapper_passwd;
3899 $createuser_env{NSS_WRAPPER_GROUP} = $nss_wrapper_group;
3900 $createuser_env{NSS_WRAPPER_HOSTS} = $nss_wrapper_hosts;
3901 $createuser_env{NSS_WRAPPER_HOSTNAME} = "${hostname}.${dns_domain}";
3902 if ($ENV{SAMBA_DNS_FAKING}) {
3903 $createuser_env{RESOLV_WRAPPER_HOSTS} = $dns_host_file;
3904 } else {
3905 $createuser_env{RESOLV_WRAPPER_CONF} = $resolv_conf;
3906 }
3907 $createuser_env{RESOLV_CONF} = $resolv_conf;
3908
3909 createuser($self, $unix_name, $password, $conffile, \%createuser_env) || die("Unable to create user");
3910 createuser($self, "force_user", $password, $conffile, \%createuser_env) || die("Unable to create force_user");
3911 createuser($self, "smbget_user", $password, $conffile, \%createuser_env) || die("Unable to create smbget_user");
3912 createuser($self, "user1", $password, $conffile, \%createuser_env) || die("Unable to create user1");
3913 createuser($self, "user2", $password, $conffile, \%createuser_env) || die("Unable to create user2");
3914 createuser($self, "gooduser", $password, $conffile, \%createuser_env) || die("Unable to create gooduser");
3915 createuser($self, "eviluser", $password, $conffile, \%createuser_env) || die("Unable to create eviluser");
3916 createuser($self, "slashuser", $password, $conffile, \%createuser_env) || die("Unable to create slashuser");
3917 createuser($self, "jackthemapper", "mApsEcrEt", $conffile, \%createuser_env) || die("Unable to create jackthemapper");
3918 createuser($self, "jacknomapper", "nOmApsEcrEt", $conffile, \%createuser_env) || die("Unable to create jacknomapper");
3919
3920 open(DNS_UPDATE_LIST, ">$prefix/dns_update_list") or die("Unable to open $$prefix/dns_update_list");
3921 print DNS_UPDATE_LIST "A $server. $server_ip\n";
3922 print DNS_UPDATE_LIST "AAAA $server. $server_ipv6\n";
3923 close(DNS_UPDATE_LIST);
3924
3925 print "DONE\n";
3926
3927 $ret{SERVER_IP} = $server_ip;
3928 $ret{SERVER_IPV6} = $server_ipv6;
3929 $ret{SAMBA_DCERPCD_TEST_LOG} = "$prefix/samba_dcerpcd_test.log";
3930 $ret{SAMBA_DCERPCD_LOG_POS} = 0;
3931 $ret{NMBD_TEST_LOG} = "$prefix/nmbd_test.log";
3932 $ret{NMBD_TEST_LOG_POS} = 0;
3933 $ret{WINBINDD_TEST_LOG} = "$prefix/winbindd_test.log";
3934 $ret{WINBINDD_TEST_LOG_POS} = 0;
3935 $ret{SMBD_TEST_LOG} = "$prefix/smbd_test.log";
3936 $ret{SMBD_TEST_LOG_POS} = 0;
3937 $ret{SERVERCONFFILE} = $conffile;
3938 $ret{TESTENV_DIR} = $prefix;
3939 $ret{CONFIGURATION} ="--configfile=$conffile";
3940 $ret{LOCK_DIR} = $lockdir;
3941 $ret{SERVER} = $server;
3942 $ret{USERNAME} = $unix_name;
3943 $ret{USERID} = $unix_uid;
3944 $ret{DOMAIN} = $domain;
3945 $ret{SAMSID} = $samsid;
3946 $ret{NETBIOSNAME} = $netbios_name;
3947 $ret{PASSWORD} = $password;
3948 $ret{PIDDIR} = $piddir;
3949 $ret{SELFTEST_WINBINDD_SOCKET_DIR} = $wbsockdir;
3950 $ret{NMBD_SOCKET_DIR} = $nmbdsockdir;
3951 $ret{SOCKET_WRAPPER_DEFAULT_IFACE} = $swiface;
3952 $ret{NSS_WRAPPER_PASSWD} = $nss_wrapper_passwd;
3953 $ret{NSS_WRAPPER_GROUP} = $nss_wrapper_group;
3954 $ret{NSS_WRAPPER_HOSTS} = $nss_wrapper_hosts;
3955 $ret{NSS_WRAPPER_HOSTNAME} = "${hostname}.${dns_domain}";
3956 $ret{NSS_WRAPPER_MODULE_SO_PATH} = Samba::nss_wrapper_winbind_so_path($self);
3957 $ret{NSS_WRAPPER_MODULE_FN_PREFIX} = "winbind";
3958 if ($ENV{SAMBA_DNS_FAKING}) {
3959 $ret{RESOLV_WRAPPER_HOSTS} = $dns_host_file;
3960 } else {
3961 $ret{RESOLV_WRAPPER_CONF} = $resolv_conf;
3962 }
3963 $ret{RESOLV_CONF} = $resolv_conf;
3964 $ret{LOCAL_PATH} = "$shrdir";
3965 $ret{LOGDIR} = $logdir;
3966
3967 #
3968 # Avoid hitting system krb5.conf -
3969 # An env that needs Kerberos will reset this to the real
3970 # value.
3971 #
3972 $ret{KRB5_CONFIG} = abs_path($prefix) . "/no_krb5.conf";
3973
3974 # Define KRB5CCNAME for each environment we set up
3975 $ret{KRB5_CCACHE} = abs_path($prefix) . "/krb5ccache";
3976 $ENV{KRB5CCNAME} = $ret{KRB5_CCACHE};
3977
3978 return \%ret;
3979 }
3980
3981 sub wait_for_start($$$$$)
3982 {
3983 my ($self, $envvars, $nmbd, $winbindd, $smbd, $samba_dcerpcd) = @_;
3984 my $cmd;
3985 my $netcmd;
3986 my $ret;
3987
3988 if ($samba_dcerpcd eq "yes") {
3989 my $count = 0;
3990 my $rpcclient = Samba::bindir_path($self, "rpcclient");
3991
3992 print "checking for samba_dcerpcd\n";
3993
3994 do {
3995 $ret = system("UID_WRAPPER_ROOT=1 $rpcclient $envvars->{CONFIGURATION} ncalrpc: -c epmmap");
3996
3997 if ($ret != 0) {
3998 sleep(1);
3999 }
4000 $count++
4001 } while ($ret != 0 && $count < 10);
4002
4003 if ($count == 10) {
4004 print "samba_dcerpcd not reachable after 10 retries\n";
4005 teardown_env($self, $envvars);
4006 return 0;
4007 }
4008 }
4009
4010 if ($nmbd eq "yes") {
4011 my $count = 0;
4012
4013 # give time for nbt server to register its names
4014 print "checking for nmbd\n";
4015
4016 # This will return quickly when things are up, but be slow if we need to wait for (eg) SSL init
4017 my $nmblookup = Samba::bindir_path($self, "nmblookup");
4018
4019 do {
4020 $ret = system("$nmblookup $envvars->{CONFIGURATION} $envvars->{SERVER}");
4021 if ($ret != 0) {
4022 sleep(1);
4023 } else {
4024 system("$nmblookup $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} __SAMBA__");
4025 system("$nmblookup $envvars->{CONFIGURATION} __SAMBA__");
4026 system("$nmblookup $envvars->{CONFIGURATION} -U 10.255.255.255 __SAMBA__");
4027 system("$nmblookup $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} $envvars->{SERVER}");
4028 }
4029 $count++;
4030 } while ($ret != 0 && $count < 10);
4031 if ($count == 10) {
4032 print "NMBD not reachable after 10 retries\n";
4033 teardown_env($self, $envvars);
4034 return 0;
4035 }
4036 }
4037
4038 if ($winbindd eq "yes" or $winbindd eq "offline") {
4039 print "checking for winbindd\n";
4040 my $count = 0;
4041 $cmd = "SELFTEST_WINBINDD_SOCKET_DIR='$envvars->{SELFTEST_WINBINDD_SOCKET_DIR}' ";
4042 $cmd .= "NSS_WRAPPER_PASSWD='$envvars->{NSS_WRAPPER_PASSWD}' ";
4043 $cmd .= "NSS_WRAPPER_GROUP='$envvars->{NSS_WRAPPER_GROUP}' ";
4044 if ($winbindd eq "yes") {
4045 $cmd .= Samba::bindir_path($self, "wbinfo") . " --ping-dc";
4046 } elsif ($winbindd eq "offline") {
4047 $cmd .= Samba::bindir_path($self, "wbinfo") . " --ping";
4048 }
4049
4050 do {
4051 $ret = system($cmd);
4052 if ($ret != 0) {
4053 sleep(1);
4054 }
4055 $count++;
4056 } while ($ret != 0 && $count < 20);
4057 if ($count == 20) {
4058 print "WINBINDD not reachable after 20 seconds\n";
4059 teardown_env($self, $envvars);
4060 return 0;
4061 }
4062 }
4063
4064 if ($smbd eq "yes") {
4065 # make sure smbd is also up set
4066 print "wait for smbd\n";
4067
4068 my $count = 0;
4069
4070 if (defined($envvars->{GNUTLS_FORCE_FIPS_MODE})) {
4071 # We don't have NTLM in FIPS mode, so lets use
4072 # smbcontrol instead of smbclient.
4073 $cmd = Samba::bindir_path($self, "smbcontrol");
4074 $cmd .= " $envvars->{CONFIGURATION}";
4075 $cmd .= " smbd ping";
4076 } else {
4077 # This uses NTLM which is not available in FIPS
4078 $cmd = "NSS_WRAPPER_HOSTS='$envvars->{NSS_WRAPPER_HOSTS}' ";
4079 $cmd .= Samba::bindir_path($self, "smbclient");
4080 $cmd .= " $envvars->{CONFIGURATION}";
4081 $cmd .= " -L $envvars->{SERVER}";
4082 $cmd .= " -U%";
4083 $cmd .= " -I $envvars->{SERVER_IP}";
4084 $cmd .= " -p 139";
4085 }
4086
4087 do {
4088 $ret = system($cmd);
4089 if ($ret != 0) {
4090 sleep(1);
4091 }
4092 $count++
4093 } while ($ret != 0 && $count < 20);
4094 if ($count == 20) {
4095 print "SMBD failed to start up in a reasonable time (20sec)\n";
4096 teardown_env($self, $envvars);
4097 return 0;
4098 }
4099 }
4100
4101 # Ensure we have domain users mapped.
4102 $netcmd = "NSS_WRAPPER_PASSWD='$envvars->{NSS_WRAPPER_PASSWD}' ";
4103 $netcmd .= "NSS_WRAPPER_GROUP='$envvars->{NSS_WRAPPER_GROUP}' ";
4104 $netcmd .= "UID_WRAPPER_ROOT='1' ";
4105 $netcmd .= Samba::bindir_path($self, "net") ." $envvars->{CONFIGURATION} ";
4106
4107 $cmd = $netcmd . "groupmap add rid=513 unixgroup=domusers type=domain";
4108 $ret = system($cmd);
4109 if ($ret != 0) {
4110 print("\"$cmd\" failed\n");
4111 return 1;
4112 }
4113
4114 $cmd = $netcmd . "groupmap add rid=512 unixgroup=domadmins type=domain";
4115 $ret = system($cmd);
4116 if ($ret != 0) {
4117 print("\"$cmd\" failed\n");
4118 return 1;
4119 }
4120
4121 $cmd = $netcmd . "groupmap add sid=S-1-1-0 unixgroup=everyone type=builtin";
4122 $ret = system($cmd);
4123 if ($ret != 0) {
4124 print("\"$cmd\" failed\n");
4125 return 1;
4126 }
4127
4128 $cmd = $netcmd . "groupmap add unixgroup=group1 type=domain";
4129 $ret = system($cmd);
4130 if ($ret != 0) {
4131 print("\"$cmd\" failed\n");
4132 return 1;
4133 }
4134
4135 $cmd = $netcmd . "groupmap add unixgroup=group2 type=domain";
4136 $ret = system($cmd);
4137 if ($ret != 0) {
4138 print("\"$cmd\" failed\n");
4139 return 1;
4140 }
4141
4142 # note: creating builtin groups requires winbindd for the
4143 # unix id allocator
4144 my $create_builtin_users = "no";
4145 if ($winbindd eq "yes") {
4146 $cmd = "SELFTEST_WINBINDD_SOCKET_DIR='$envvars->{SELFTEST_WINBINDD_SOCKET_DIR}' ";
4147 $cmd .= "NSS_WRAPPER_PASSWD='$envvars->{NSS_WRAPPER_PASSWD}' ";
4148 $cmd .= "NSS_WRAPPER_GROUP='$envvars->{NSS_WRAPPER_GROUP}' ";
4149 $cmd .= Samba::bindir_path($self, "wbinfo") . " --sid-to-gid=S-1-5-32-545";
4150 my $wbinfo_out = qx($cmd 2>&1);
4151 if ($? != 0) {
4152 # wbinfo doesn't give us a better error code then
4153 # WBC_ERR_DOMAIN_NOT_FOUND, but at least that's
4154 # different then WBC_ERR_WINBIND_NOT_AVAILABLE
4155 if ($wbinfo_out !~ /WBC_ERR_DOMAIN_NOT_FOUND/) {
4156 print("Failed to run \"wbinfo --sid-to-gid=S-1-5-32-545\": $wbinfo_out");
4157 teardown_env($self, $envvars);
4158 return 0;
4159 }
4160 $create_builtin_users = "yes";
4161 }
4162 }
4163 if ($create_builtin_users eq "yes") {
4164 $cmd = "SELFTEST_WINBINDD_SOCKET_DIR='$envvars->{SELFTEST_WINBINDD_SOCKET_DIR}' ";
4165 $cmd .= "NSS_WRAPPER_PASSWD='$envvars->{NSS_WRAPPER_PASSWD}' ";
4166 $cmd .= "NSS_WRAPPER_GROUP='$envvars->{NSS_WRAPPER_GROUP}' ";
4167 $cmd .= Samba::bindir_path($self, "net") . " $envvars->{CONFIGURATION} ";
4168 $cmd .= "sam createbuiltingroup Users";
4169 $ret = system($cmd);
4170 if ($ret != 0) {
4171 print "Failed to create BUILTIN\\Users group\n";
4172 teardown_env($self, $envvars);
4173 return 0;
4174 }
4175
4176 $cmd = Samba::bindir_path($self, "net") . " $envvars->{CONFIGURATION} ";
4177 $cmd .= "cache del IDMAP/SID2XID/S-1-5-32-545";
4178 system($cmd);
4179
4180 $cmd = "SELFTEST_WINBINDD_SOCKET_DIR='$envvars->{SELFTEST_WINBINDD_SOCKET_DIR}' ";
4181 $cmd .= "NSS_WRAPPER_PASSWD='$envvars->{NSS_WRAPPER_PASSWD}' ";
4182 $cmd .= "NSS_WRAPPER_GROUP='$envvars->{NSS_WRAPPER_GROUP}' ";
4183 $cmd .= Samba::bindir_path($self, "wbinfo") . " --sid-to-gid=S-1-5-32-545";
4184 $ret = system($cmd);
4185 if ($ret != 0) {
4186 print "Missing \"BUILTIN\\Users\", did net sam createbuiltingroup Users fail?\n";
4187 teardown_env($self, $envvars);
4188 return 0;
4189 }
4190 }
4191
4192 print $self->getlog_env($envvars);
4193
4194 return 1;
4195 }
4196
4197 ##
4198 ## provision and start of ctdb
4199 ##
4200 sub setup_ctdb($$)
4201 {
4202 my ($self, $prefix) = @_;
4203 my $num_nodes = 3;
4204
4205 my $data = $self->provision_ctdb($prefix, $num_nodes);
4206 $data or return undef;
4207
4208 my $rc = $self->check_or_start_ctdb($data);
4209 if (not $rc) {
4210 print("check_or_start_ctdb() failed\n");
4211 return undef;
4212 }
4213
4214 $rc = $self->wait_for_start_ctdb($data);
4215 if (not $rc) {
4216 print "Cluster startup failed\n";
4217 return undef;
4218 }
4219
4220 return $data;
4221 }
4222
4223 sub provision_ctdb($$$$)
4224 {
4225 my ($self, $prefix, $num_nodes) = @_;
4226 my $rc;
4227
4228 print "PROVISIONING CTDB...\n";
4229
4230 #
4231 # check / create directories:
4232 #
4233 die ("prefix = ''") if $prefix eq "";
4234 die ("prefix = '/'") if $prefix eq "/";
4235
4236 mkdir ($prefix, 0777);
4237
4238 print "CREATE CTDB TEST ENVIRONMENT in '$prefix'...\n";
4239 system("rm -rf $prefix/*");
4240
4241 #
4242 # Per-node data
4243 #
4244 my @nodes = ();
4245 for (my $i = 0; $i < $num_nodes; $i++) {
4246 my %node = ();
4247 my $server_name = "ctdb${i}";
4248 my $pub_iface = Samba::get_interface($server_name);
4249 my $ip = Samba::get_ipv4_addr($server_name);
4250
4251 $node{NODE_NUMBER} = "$i";
4252 $node{SERVER_NAME} = "$server_name";
4253 $node{SOCKET_WRAPPER_DEFAULT_IFACE} = "$pub_iface";
4254 $node{IP} = "$ip";
4255
4256 push(@nodes, \%node);
4257 }
4258
4259 #
4260 # nodes
4261 #
4262 my $nodes_file = "$prefix/nodes.in";
4263 unless (open(NODES, ">$nodes_file")) {
4264 warn("Unable to open nodesfile '$nodes_file'");
4265 return undef;
4266 }
4267 for (my $i = 0; $i < $num_nodes; $i++) {
4268 my $ip = $nodes[$i]->{IP};
4269 print NODES "${ip}\n";
4270 }
4271 close(NODES);
4272
4273 #
4274 # local_daemons.sh setup
4275 #
4276 # Socket wrapper setup is done by selftest.pl, so don't use
4277 # the CTDB-specific setup
4278 #
4279 my $cmd;
4280 $cmd .= "ctdb/tests/local_daemons.sh " . $prefix . " setup";
4281 $cmd .= " -n " . $num_nodes;
4282 $cmd .= " -N " . $nodes_file;
4283 # CTDB should not attempt to manage public addresses -
4284 # clients should just connect to CTDB private addresses
4285 $cmd .= " -P " . "/dev/null";
4286
4287 my $ret = system($cmd);
4288 if ($ret != 0) {
4289 print("\"$cmd\" failed\n");
4290 return undef;
4291 }
4292
4293 #
4294 # Unix domain socket and node directory for each daemon
4295 #
4296 for (my $i = 0; $i < $num_nodes; $i++) {
4297 my ($cmd, $ret, $out);
4298
4299 my $cmd_prefix = "ctdb/tests/local_daemons.sh ${prefix}";
4300
4301 #
4302 # socket
4303 #
4304
4305 $cmd = "${cmd_prefix} print-socket ${i}";
4306
4307 $out = `$cmd`;
4308 $ret = $?;
4309 if ($ret != 0) {
4310 print("\"$cmd\" failed\n");
4311 return undef;
4312 }
4313 chomp $out;
4314 $nodes[$i]->{SOCKET_FILE} = "$out";
4315
4316 #
4317 # node directory
4318 #
4319
4320 $cmd = "${cmd_prefix} onnode ${i} 'echo \$CTDB_BASE'";
4321
4322 $out = `$cmd`;
4323 $ret = $?;
4324 if ($ret != 0) {
4325 print("\"$cmd\" failed\n");
4326 return undef;
4327 }
4328 chomp $out;
4329 $nodes[$i]->{NODE_PREFIX} = "$out";
4330 }
4331
4332 my %ret = ();
4333
4334 $ret{CTDB_PREFIX} = "$prefix";
4335 $ret{NUM_NODES} = $num_nodes;
4336 $ret{CTDB_NODES} = \@nodes;
4337 $ret{CTDB_NODES_FILE} = $nodes_file;
4338
4339 for (my $i = 0; $i < $num_nodes; $i++) {
4340 my $node = $nodes[$i];
4341 my $socket = $node->{SOCKET_FILE};
4342 my $server_name = $node->{SERVER_NAME};
4343 my $node_prefix = $node->{NODE_PREFIX};
4344 my $ip = $node->{IP};
4345
4346 $ret{"CTDB_BASE_NODE${i}"} = $node_prefix;
4347 $ret{"CTDB_SOCKET_NODE${i}"} = $socket;
4348 $ret{"CTDB_SERVER_NAME_NODE${i}"} = $server_name;
4349 $ret{"CTDB_IFACE_IP_NODE${i}"} = $ip;
4350 }
4351
4352 $ret{CTDB_TEST_MODE} = "yes";
4353 $ret{CTDB_BASE} = $ret{CTDB_BASE_NODE0};
4354 $ret{CTDB_SOCKET} = $ret{CTDB_SOCKET_NODE0};
4355 $ret{CTDB_SERVER_NAME} = $ret{CTDB_SERVER_NAME_NODE0};
4356 $ret{CTDB_IFACE_IP} = $ret{CTDB_IFACE_IP_NODE0};
4357
4358 return \%ret;
4359 }
4360
4361 sub check_or_start_ctdb($$) {
4362 my ($self, $data) = @_;
4363
4364 my $prefix = $data->{CTDB_PREFIX};
4365 my $num_nodes = $data->{NUM_NODES};
4366 my $nodes = $data->{CTDB_NODES};
4367 my $STDIN_READER;
4368
4369 # Share a single stdin pipe for all nodes
4370 pipe($STDIN_READER, $data->{CTDB_STDIN_PIPE});
4371
4372 for (my $i = 0; $i < $num_nodes; $i++) {
4373 my $node = $nodes->[$i];
4374
4375 $node->{STDIN_PIPE} = $data->{CTDB_STDIN_PIPE};
4376
4377 my $cmd = "ctdb/tests/local_daemons.sh";
4378 my @full_cmd = ("$cmd", "$prefix", "start", "$i");
4379 my $daemon_ctx = {
4380 NAME => "ctdbd",
4381 BINARY_PATH => $cmd,
4382 FULL_CMD => [ @full_cmd ],
4383 TEE_STDOUT => 1,
4384 LOG_FILE => "/dev/null",
4385 ENV_VARS => {},
4386 };
4387
4388 print "STARTING CTDBD (node ${i})\n";
4389
4390 # This does magic with $STDIN_READER, so use it
4391 my $ret = Samba::fork_and_exec($self,
4392 $node,
4393 $daemon_ctx,
4394 $STDIN_READER);
4395
4396 if ($ret == 0) {
4397 print("\"$cmd\" failed\n");
4398 teardown_env_ctdb($self, $data);
4399 return 0;
4400 }
4401 }
4402
4403 close($STDIN_READER);
4404
4405 return 1;
4406 }
4407
4408 sub wait_for_start_ctdb($$)
4409 {
4410 my ($self, $data) = @_;
4411
4412 my $prefix = $data->{CTDB_PREFIX};
4413
4414 print "Wait for ctdbd...\n";
4415
4416 my $ctdb = Samba::bindir_path($self, "ctdb");
4417 my $cmd;
4418 $cmd .= "ctdb/tests/local_daemons.sh ${prefix} onnode all";
4419 $cmd .= " ${ctdb} nodestatus all 2>&1";
4420
4421 my $count = 0;
4422 my $wait_seconds = 60;
4423 my $out;
4424
4425 until ($count > $wait_seconds) {
4426 $out = `$cmd`;
4427 my $ret = $?;
4428 if ($ret == 0) {
4429 print "\ncluster became healthy\n";
4430 last;
4431 }
4432 print "Waiting for CTDB...\n";
4433 sleep(1);
4434 $count++;
4435 }
4436
4437 if ($count > $wait_seconds) {
4438 print "\nGiving up to wait for CTDB...\n";
4439 print "${out}\n\n";
4440 print "CTDB log:\n";
4441 $cmd = "ctdb/tests/local_daemons.sh ${prefix} print-log all >&2";
4442 system($cmd);
4443 teardown_env_ctdb($self, $data);
4444 return 0;
4445 }
4446
4447 print "\nCTDB initialized\n";
4448
4449 return 1;
4450 }
4451
4452 1;