?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vfs_default: also call vfs_offload_token_ctx_init in vfswrap_offload_write_send
[Samba.git] / selftest / target / Samba4.pm
blob4b289fb27aeddf4094d5764c61fa410853bf9585
1 #!/usr/bin/perl
2 # Bootstrap Samba and run a number of tests against it.
3 # Copyright (C) 2005-2007 Jelmer Vernooij <jelmer@samba.org>
4 # Published under the GNU GPL, v3 or later.
5
6 # NOTE: Refer to the README for more details about the various testenvs,
7 # and tips about adding new testenvs.
8
9 package Samba4;
10
11 use strict;
12 use warnings;
13 use Cwd qw(abs_path);
14 use FindBin qw($RealBin);
15 use POSIX;
16 use SocketWrapper;
17 use target::Samba;
18 use target::Samba3;
19 use Archive::Tar;
20
21 sub new($$$$$) {
22 my ($classname, $SambaCtx, $bindir, $srcdir, $server_maxtime, $default_ldb_backend) = @_;
23
24 my $self = {
25 vars => {},
26 SambaCtx => $SambaCtx,
27 bindir => $bindir,
28 srcdir => $srcdir,
29 server_maxtime => $server_maxtime,
30 target3 => new Samba3($SambaCtx, $bindir, $srcdir, $server_maxtime),
31 default_ldb_backend => $default_ldb_backend,
32 };
33 bless $self;
34 return $self;
35 }
36
37 sub scriptdir_path($$) {
38 my ($self, $path) = @_;
39 return "$self->{srcdir}/source4/scripting/$path";
40 }
41
42 sub check_or_start($$$)
43 {
44 my ($self, $env_vars, $process_model) = @_;
45 my $STDIN_READER;
46
47 my $env_ok = $self->check_env($env_vars);
48 if ($env_ok) {
49 return $env_vars->{SAMBA_PID};
50 } elsif (defined($env_vars->{SAMBA_PID})) {
51 warn("SAMBA PID $env_vars->{SAMBA_PID} is not running (died)");
52 return undef;
53 }
54
55 # use a pipe for stdin in the child processes. This allows
56 # those processes to monitor the pipe for EOF to ensure they
57 # exit when the test script exits
58 pipe($STDIN_READER, $env_vars->{STDIN_PIPE});
59
60 # build up the command to run samba
61 my @preargs = ();
62 my @optargs = ();
63 if (defined($ENV{SAMBA_OPTIONS})) {
64 @optargs = split(/ /, $ENV{SAMBA_OPTIONS});
65 }
66 if(defined($ENV{SAMBA_VALGRIND})) {
67 @preargs = split(/ /,$ENV{SAMBA_VALGRIND});
68 }
69
70 if (defined($process_model)) {
71 push @optargs, ("-M", $process_model);
72 }
73 my $binary = Samba::bindir_path($self, "samba");
74 my @full_cmd = (@preargs, $binary, "-i",
75 "--no-process-group", "--maximum-runtime=$self->{server_maxtime}",
76 $env_vars->{CONFIGURATION}, @optargs);
77
78 # the samba process takes some additional env variables (compared to s3)
79 my $samba_envs = Samba::get_env_for_process("samba", $env_vars);
80 if (defined($ENV{MITKRB5})) {
81 $samba_envs->{KRB5_KDC_PROFILE} = $env_vars->{MITKDC_CONFIG};
82 }
83
84 # fork a child process and exec() samba
85 my $daemon_ctx = {
86 NAME => "samba",
87 BINARY_PATH => $binary,
88 FULL_CMD => [ @full_cmd ],
89 LOG_FILE => $env_vars->{SAMBA_TEST_LOG},
90 TEE_STDOUT => 1,
91 PCAP_FILE => "env-$ENV{ENVNAME}-samba",
92 ENV_VARS => $samba_envs,
93 };
94 my $pid = Samba::fork_and_exec($self, $env_vars, $daemon_ctx, $STDIN_READER);
95
96 $env_vars->{SAMBA_PID} = $pid;
97
98 # close the parent's read-end of the pipe
99 close($STDIN_READER);
100
101 if ($self->wait_for_start($env_vars) != 0) {
102 warn("Samba $pid failed to start up");
103 return undef;
104 }
105
106 return $pid;
107 }
108
109 sub wait_for_start($$)
110 {
111 my ($self, $testenv_vars) = @_;
112 my $count = 0;
113 my $ret = 0;
114
115 if (not $self->check_env($testenv_vars)) {
116 warn("unable to confirm Samba $testenv_vars->{SAMBA_PID} is running");
117 return -1;
118 }
119
120 # This will return quickly when things are up, but be slow if we
121 # need to wait for (eg) SSL init
122 my $nmblookup = Samba::bindir_path($self, "nmblookup4");
123
124 do {
125 $ret = system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{SERVER}");
126 if ($ret != 0) {
127 sleep(1);
128 } else {
129 system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{SERVER}");
130 system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
131 system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
132 system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
133 system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
134 system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{SERVER}");
135 system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{SERVER}");
136 system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
137 system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
138 system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
139 system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
140 }
141 $count++;
142 } while ($ret != 0 && $count < 20);
143 if ($count == 20) {
144 teardown_env($self, $testenv_vars);
145 warn("nbt not reachable after 20 retries\n");
146 return -1;
147 }
148
149 # Ensure we have the first RID Set before we start tests. This makes the tests more reliable.
150 if ($testenv_vars->{SERVER_ROLE} eq "domain controller") {
151 print "waiting for working LDAP and a RID Set to be allocated\n";
152 my $ldbsearch = Samba::bindir_path($self, "ldbsearch");
153 my $count = 0;
154 my $base_dn = "DC=".join(",DC=", split(/\./, $testenv_vars->{REALM}));
155
156 my $search_dn = $base_dn;
157 if ($testenv_vars->{NETBIOSNAME} ne "RODC") {
158 # TODO currently no check for actual rIDAllocationPool
159 $search_dn = "cn=RID Set,cn=$testenv_vars->{NETBIOSNAME},ou=domain controllers,$base_dn";
160 }
161 my $max_wait = 60;
162
163 # Add hosts file for name lookups
164 my $cmd = $self->get_cmd_env_vars($testenv_vars);
165
166 $cmd .= "$ldbsearch ";
167 $cmd .= "$testenv_vars->{CONFIGURATION} ";
168 $cmd .= "-H ldap://$testenv_vars->{SERVER} ";
169 $cmd .= "-U$testenv_vars->{USERNAME}%$testenv_vars->{PASSWORD} ";
170 $cmd .= "--scope base ";
171 $cmd .= "-b '$search_dn' ";
172 while (system("$cmd >/dev/null") != 0) {
173 $count++;
174 if ($count > $max_wait) {
175 teardown_env($self, $testenv_vars);
176 warn("Timed out ($max_wait sec) waiting for working LDAP and a RID Set to be allocated by $testenv_vars->{NETBIOSNAME} PID $testenv_vars->{SAMBA_PID}");
177 return -1;
178 }
179 print "Waiting for working LDAP...\n";
180 sleep(1);
181 }
182 }
183
184 my $wbinfo = Samba::bindir_path($self, "wbinfo");
185
186 $count = 0;
187 do {
188 my $cmd = "NSS_WRAPPER_PASSWD=$testenv_vars->{NSS_WRAPPER_PASSWD} ";
189 $cmd .= "NSS_WRAPPER_GROUP=$testenv_vars->{NSS_WRAPPER_GROUP} ";
190 $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=$testenv_vars->{SELFTEST_WINBINDD_SOCKET_DIR} ";
191 $cmd .= "$wbinfo -P";
192 $ret = system($cmd);
193
194 if ($ret != 0) {
195 sleep(1);
196 }
197 $count++;
198 } while ($ret != 0 && $count < 20);
199 if ($count == 20) {
200 teardown_env($self, $testenv_vars);
201 warn("winbind not reachable after 20 retries\n");
202 return -1;
203 }
204
205 # Ensure we registered all our names
206 if ($testenv_vars->{SERVER_ROLE} eq "domain controller") {
207 my $max_wait = 120;
208 my $dns_update_cache = "$testenv_vars->{PRIVATEDIR}/dns_update_cache";
209 print "Waiting for $dns_update_cache to be created.\n";
210 $count = 0;
211 while (not -e $dns_update_cache) {
212 $count++;
213 if ($count > $max_wait) {
214 teardown_env($self, $testenv_vars);
215 warn("Timed out ($max_wait sec) waiting for $dns_update_cache PID $testenv_vars->{SAMBA_PID}");
216 return -1;
217 }
218 print "Waiting for $dns_update_cache to be created...\n";
219 sleep(1);
220 }
221 print "Waiting for $dns_update_cache to be filled.\n";
222 $count = 0;
223 while ((-s "$dns_update_cache") == 0) {
224 $count++;
225 if ($count > $max_wait) {
226 teardown_env($self, $testenv_vars);
227 warn("Timed out ($max_wait sec) waiting for $dns_update_cache PID $testenv_vars->{SAMBA_PID}");
228 return -1;
229 }
230 print "Waiting for $dns_update_cache to be filled...\n";
231 sleep(1);
232 }
233 }
234
235 print $self->getlog_env($testenv_vars);
236
237 print "READY ($testenv_vars->{SAMBA_PID})\n";
238
239 return 0
240 }
241
242 sub write_ldb_file($$$)
243 {
244 my ($self, $file, $ldif_in) = @_;
245
246 my $ldbadd = Samba::bindir_path($self, "ldbadd");
247 open(my $ldif, "|$ldbadd -H $file > /dev/null")
248 or die "Failed to run $ldbadd: $!";
249 print $ldif $ldif_in;
250 close($ldif);
251
252 unless ($? == 0) {
253 warn("$ldbadd failed: $?");
254 return undef;
255 }
256 return 1;
257 }
258
259 sub add_wins_config($$)
260 {
261 my ($self, $privatedir) = @_;
262 my $client_ip = Samba::get_ipv4_addr("client");
263
264 return $self->write_ldb_file("$privatedir/wins_config.ldb", "
265 dn: name=TORTURE_11,CN=PARTNERS
266 objectClass: wreplPartner
267 name: TORTURE_11
268 address: $client_ip
269 pullInterval: 0
270 pushChangeCount: 0
271 type: 0x3
272 ");
273 }
274
275 sub setup_dns_hub_internal($$$)
276 {
277 my ($self, $hostname, $prefix) = @_;
278 my $STDIN_READER;
279
280 unless(-d $prefix or mkdir($prefix, 0777)) {
281 warn("Unable to create $prefix");
282 return undef;
283 }
284 my $prefix_abs = abs_path($prefix);
285
286 die ("prefix=''") if $prefix_abs eq "";
287 die ("prefix='/'") if $prefix_abs eq "/";
288
289 unless (system("rm -rf $prefix_abs/*") == 0) {
290 warn("Unable to clean up");
291 }
292
293 my $env = undef;
294 $env->{NETBIOSNAME} = $hostname;
295
296 $env->{SERVER_IP} = Samba::get_ipv4_addr($hostname);
297 $env->{SERVER_IPV6} = Samba::get_ipv6_addr($hostname);
298 $env->{SOCKET_WRAPPER_DEFAULT_IFACE} = Samba::get_interface($hostname);
299 $env->{DNS_HUB_LOG} = "$prefix_abs/dns_hub.log";
300 $env->{RESOLV_CONF} = "$prefix_abs/resolv.conf";
301 $env->{TESTENV_DIR} = $prefix_abs;
302
303 my $ctx = undef;
304 $ctx->{resolv_conf} = $env->{RESOLV_CONF};
305 $ctx->{dns_ipv4} = $env->{SERVER_IP};
306 $ctx->{dns_ipv6} = $env->{SERVER_IPV6};
307 Samba::mk_resolv_conf($ctx);
308
309 my @preargs = ();
310 my @args = ();
311 if (!defined($ENV{PYTHON})) {
312 push (@preargs, "env");
313 push (@preargs, "python");
314 } else {
315 push (@preargs, $ENV{PYTHON});
316 }
317 my $binary = "$self->{srcdir}/selftest/target/dns_hub.py";
318 push (@args, "$self->{server_maxtime}");
319 push (@args, "$env->{SERVER_IP},$env->{SERVER_IPV6}");
320 push (@args, Samba::realm_to_ip_mappings());
321 my @full_cmd = (@preargs, $binary, @args);
322
323 my $daemon_ctx = {
324 NAME => "dnshub",
325 BINARY_PATH => $binary,
326 FULL_CMD => [ @full_cmd ],
327 LOG_FILE => $env->{DNS_HUB_LOG},
328 TEE_STDOUT => 1,
329 PCAP_FILE => "env-$ENV{ENVNAME}-dns_hub",
330 ENV_VARS => {},
331 };
332
333 # use a pipe for stdin in the child processes. This allows
334 # those processes to monitor the pipe for EOF to ensure they
335 # exit when the test script exits
336 pipe($STDIN_READER, $env->{STDIN_PIPE});
337
338 my $pid = Samba::fork_and_exec($self, $env, $daemon_ctx, $STDIN_READER);
339
340 $env->{SAMBA_PID} = $pid;
341 $env->{KRB5_CONFIG} = "$prefix_abs/no_krb5.conf";
342
343 # close the parent's read-end of the pipe
344 close($STDIN_READER);
345
346 return $env;
347 }
348
349 sub setup_dns_hub
350 {
351 my ($self, $prefix) = @_;
352
353 my $hostname = "rootdnsforwarder";
354
355 unless(-d $prefix or mkdir($prefix, 0777)) {
356 warn("Unable to create $prefix");
357 return undef;
358 }
359 my $env = $self->setup_dns_hub_internal("$hostname", "$prefix/$hostname");
360
361 $self->{dns_hub_env} = $env;
362
363 return $env;
364 }
365
366 sub get_dns_hub_env($)
367 {
368 my ($self, $prefix) = @_;
369
370 if (defined($self->{dns_hub_env})) {
371 return $self->{dns_hub_env};
372 }
373
374 die("get_dns_hub_env() not setup 'dns_hub_env'");
375 return undef;
376 }
377
378 sub return_env_value
379 {
380 my ($env, $overwrite, $key) = @_;
381
382 if (defined($overwrite) and defined($overwrite->{$key})) {
383 return $overwrite->{$key};
384 }
385
386 if (defined($env->{$key})) {
387 return $env->{$key};
388 }
389
390 return undef;
391 }
392
393 # Returns the environmental variables that we pass to samba-tool commands
394 sub get_cmd_env_vars
395 {
396 my ($self, $givenenv, $overwrite) = @_;
397
398 my @keys = (
399 "NSS_WRAPPER_HOSTS",
400 "SOCKET_WRAPPER_DEFAULT_IFACE",
401 "RESOLV_CONF",
402 "RESOLV_WRAPPER_CONF",
403 "RESOLV_WRAPPER_HOSTS",
404 "GNUTLS_FORCE_FIPS_MODE",
405 "OPENSSL_FORCE_FIPS_MODE",
406 "KRB5_CONFIG",
407 "KRB5_CCACHE",
408 "GNUPGHOME",
409 );
410
411 my $localenv = undef;
412 foreach my $key (@keys) {
413 my $v = return_env_value($givenenv, $overwrite, $key);
414 $localenv->{$key} = $v if defined($v);
415 }
416
417 my $cmd_env = "NSS_WRAPPER_HOSTS='$localenv->{NSS_WRAPPER_HOSTS}' ";
418 $cmd_env .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$localenv->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
419 if (defined($localenv->{RESOLV_WRAPPER_CONF})) {
420 $cmd_env .= "RESOLV_WRAPPER_CONF=\"$localenv->{RESOLV_WRAPPER_CONF}\" ";
421 } else {
422 $cmd_env .= "RESOLV_WRAPPER_HOSTS=\"$localenv->{RESOLV_WRAPPER_HOSTS}\" ";
423 }
424 if (defined($localenv->{GNUTLS_FORCE_FIPS_MODE})) {
425 $cmd_env .= "GNUTLS_FORCE_FIPS_MODE=$localenv->{GNUTLS_FORCE_FIPS_MODE} ";
426 }
427 if (defined($localenv->{OPENSSL_FORCE_FIPS_MODE})) {
428 $cmd_env .= "OPENSSL_FORCE_FIPS_MODE=$localenv->{OPENSSL_FORCE_FIPS_MODE} ";
429 }
430 $cmd_env .= "KRB5_CONFIG=\"$localenv->{KRB5_CONFIG}\" ";
431 $cmd_env .= "KRB5CCNAME=\"$localenv->{KRB5_CCACHE}\" ";
432 $cmd_env .= "RESOLV_CONF=\"$localenv->{RESOLV_CONF}\" ";
433 $cmd_env .= "GNUPGHOME=\"$localenv->{GNUPGHOME}\" ";
434
435 return $cmd_env;
436 }
437
438 # Sets up a forest trust namespace.
439 # (Note this is different to kernel namespaces, setup by the
440 # USE_NAMESPACES=1 option)
441 sub setup_namespaces
442 {
443 my ($self, $localenv, $upn_array, $spn_array) = @_;
444
445 @{$upn_array} = [] unless defined($upn_array);
446 my $upn_args = "";
447 foreach my $upn (@{$upn_array}) {
448 $upn_args .= " --add-upn-suffix=$upn";
449 }
450
451 @{$spn_array} = [] unless defined($spn_array);
452 my $spn_args = "";
453 foreach my $spn (@{$spn_array}) {
454 $spn_args .= " --add-spn-suffix=$spn";
455 }
456
457 my $samba_tool = Samba::bindir_path($self, "samba-tool");
458
459 my $cmd_env = $self->get_cmd_env_vars($localenv);
460
461 my $cmd_config = " $localenv->{CONFIGURATION}";
462
463 my $namespaces = $cmd_env;
464 $namespaces .= " $samba_tool domain trust namespaces $upn_args $spn_args";
465 $namespaces .= $cmd_config;
466 unless (system($namespaces) == 0) {
467 warn("Failed to add namespaces \n$namespaces");
468 return -1;
469 }
470
471 return 0;
472 }
473
474 sub setup_trust($$$$$)
475 {
476 my ($self, $localenv, $remoteenv, $type, $extra_args) = @_;
477
478 $localenv->{TRUST_SERVER} = $remoteenv->{SERVER};
479 $localenv->{TRUST_SERVER_IP} = $remoteenv->{SERVER_IP};
480 $localenv->{TRUST_DNSNAME} = $remoteenv->{DNSNAME};
481
482 $localenv->{TRUST_USERNAME} = $remoteenv->{USERNAME};
483 $localenv->{TRUST_PASSWORD} = $remoteenv->{PASSWORD};
484 $localenv->{TRUST_DOMAIN} = $remoteenv->{DOMAIN};
485 $localenv->{TRUST_REALM} = $remoteenv->{REALM};
486 $localenv->{TRUST_DOMSID} = $remoteenv->{DOMSID};
487
488 # Add trusted domain realms to krb5.conf
489 Samba::append_krb5_conf_trust_realms($localenv);
490
491 my $samba_tool = Samba::bindir_path($self, "samba-tool");
492
493 # setup the trust
494 my $cmd_env = $self->get_cmd_env_vars($localenv);
495
496 my $cmd_config = " $localenv->{CONFIGURATION}";
497 my $cmd_creds = $cmd_config;
498 $cmd_creds .= " -U$localenv->{TRUST_DOMAIN}\\\\$localenv->{TRUST_USERNAME}\%$localenv->{TRUST_PASSWORD}";
499
500 my $create = $cmd_env;
501 $create .= " $samba_tool domain trust create --type=${type} $localenv->{TRUST_REALM}";
502 $create .= " $extra_args";
503 $create .= $cmd_creds;
504 unless (system($create) == 0) {
505 warn("Failed to create trust \n$create");
506 return undef;
507 }
508
509 my $groupname = "g_$localenv->{TRUST_DOMAIN}";
510 my $groupadd = $cmd_env;
511 $groupadd .= " $samba_tool group add '$groupname' --group-scope=Domain $cmd_config";
512 unless (system($groupadd) == 0) {
513 warn("Failed to create group \n$groupadd");
514 return undef;
515 }
516 my $groupmem = $cmd_env;
517 $groupmem .= " $samba_tool group addmembers '$groupname' '$localenv->{TRUST_DOMSID}-513' $cmd_config";
518 unless (system($groupmem) == 0) {
519 warn("Failed to add group member \n$groupmem");
520 return undef;
521 }
522
523 return $localenv
524 }
525
526 sub provision_raw_prepare($$$$$$$$$$$$$$)
527 {
528 my ($self,
529 $prefix,
530 $server_role,
531 $hostname,
532 $domain,
533 $realm,
534 $samsid,
535 $functional_level,
536 $password,
537 $kdc_ipv4,
538 $kdc_ipv6,
539 $force_fips_mode,
540 $extra_provision_options) = @_;
541 my $ctx;
542 my $python_cmd = "";
543 if (defined $ENV{PYTHON}) {
544 $python_cmd = $ENV{PYTHON} . " ";
545 }
546 $ctx->{python} = $python_cmd;
547 my $netbiosname = uc($hostname);
548
549 unless(-d $prefix or mkdir($prefix, 0777)) {
550 warn("Unable to create $prefix");
551 return undef;
552 }
553 my $prefix_abs = abs_path($prefix);
554
555 die ("prefix=''") if $prefix_abs eq "";
556 die ("prefix='/'") if $prefix_abs eq "/";
557
558 unless (system("rm -rf $prefix_abs/*") == 0) {
559 warn("Unable to clean up");
560 }
561
562
563 my $swiface = Samba::get_interface($hostname);
564
565 $ctx->{prefix} = $prefix;
566 $ctx->{prefix_abs} = $prefix_abs;
567
568 $ctx->{server_role} = $server_role;
569 $ctx->{hostname} = $hostname;
570 $ctx->{netbiosname} = $netbiosname;
571 $ctx->{swiface} = $swiface;
572 $ctx->{password} = $password;
573 $ctx->{kdc_ipv4} = $kdc_ipv4;
574 $ctx->{kdc_ipv6} = $kdc_ipv6;
575 $ctx->{force_fips_mode} = $force_fips_mode;
576 $ctx->{krb5_ccname} = "$prefix_abs/krb5cc_%{uid}";
577 if ($functional_level eq "2000") {
578 $ctx->{supported_enctypes} = "arcfour-hmac-md5 des-cbc-md5 des-cbc-crc";
579 }
580
581 #
582 # Set smbd log level here.
583 #
584 $ctx->{server_loglevel} =$ENV{SERVER_LOG_LEVEL} || 1;
585 $ctx->{username} = "Administrator";
586 $ctx->{domain} = $domain;
587 $ctx->{realm} = uc($realm);
588 $ctx->{dnsname} = lc($realm);
589 $ctx->{samsid} = $samsid;
590 $ctx->{domain_admin} = "Administrator";
591 $ctx->{domain_admin_password} = $password;
592 $ctx->{domain_user} = "alice";
593 $ctx->{domain_user_password} = "Secret007";
594
595 $ctx->{functional_level} = $functional_level;
596
597 my $unix_name = ($ENV{USER} or $ENV{LOGNAME} or `whoami`);
598 chomp $unix_name;
599 $ctx->{unix_name} = $unix_name;
600 $ctx->{unix_uid} = $>;
601 my @mygid = split(" ", $();
602 $ctx->{unix_gid} = $mygid[0];
603 $ctx->{unix_gids_str} = $);
604 @{$ctx->{unix_gids}} = split(" ", $ctx->{unix_gids_str});
605
606 $ctx->{etcdir} = "$prefix_abs/etc";
607 $ctx->{piddir} = "$prefix_abs/pid";
608 $ctx->{smb_conf} = "$ctx->{etcdir}/smb.conf";
609 $ctx->{krb5_conf} = "$ctx->{etcdir}/krb5.conf";
610 $ctx->{krb5_ccache} = "$prefix_abs/krb5_ccache";
611 $ctx->{mitkdc_conf} = "$ctx->{etcdir}/mitkdc.conf";
612 $ctx->{gnupghome} = "$prefix_abs/gnupg";
613 $ctx->{privatedir} = "$prefix_abs/private";
614 $ctx->{binddnsdir} = "$prefix_abs/bind-dns";
615 $ctx->{ncalrpcdir} = "$prefix_abs/ncalrpc";
616 $ctx->{lockdir} = "$prefix_abs/lockdir";
617 $ctx->{logdir} = "$prefix_abs/logs";
618 $ctx->{statedir} = "$prefix_abs/statedir";
619 $ctx->{cachedir} = "$prefix_abs/cachedir";
620 $ctx->{winbindd_socket_dir} = "$prefix_abs/wbsock";
621 $ctx->{nmbd_socket_dir} = "$prefix_abs/nmbsock";
622 $ctx->{ntp_signd_socket_dir} = "$prefix_abs/ntp_signd_socket";
623 $ctx->{nsswrap_passwd} = "$ctx->{etcdir}/passwd";
624 $ctx->{nsswrap_group} = "$ctx->{etcdir}/group";
625 $ctx->{nsswrap_hosts} = "$ENV{SELFTEST_PREFIX}/hosts";
626 $ctx->{nsswrap_hostname} = "$ctx->{hostname}.$ctx->{dnsname}";
627 if ($ENV{SAMBA_DNS_FAKING}) {
628 $ctx->{dns_host_file} = "$ENV{SELFTEST_PREFIX}/dns_host_file";
629 $ctx->{samba_dnsupdate} = "$ENV{SRCDIR_ABS}/source4/scripting/bin/samba_dnsupdate --configfile=$ctx->{smb_conf} --all-interfaces --use-file=$ctx->{dns_host_file}";
630 $ctx->{samba_dnsupdate} = $python_cmd . $ctx->{samba_dnsupdate};
631 } else {
632 $ctx->{samba_dnsupdate} = "$ENV{SRCDIR_ABS}/source4/scripting/bin/samba_dnsupdate --configfile=$ctx->{smb_conf} --all-interfaces";
633 $ctx->{samba_dnsupdate} = $python_cmd . $ctx->{samba_dnsupdate};
634 $ctx->{use_resolv_wrapper} = 1;
635 }
636
637 my $dns_hub = $self->get_dns_hub_env();
638 $ctx->{resolv_conf} = $dns_hub->{RESOLV_CONF};
639
640 $ctx->{tlsdir} = "$ctx->{privatedir}/tls";
641
642 $ctx->{ipv4} = Samba::get_ipv4_addr($hostname);
643 $ctx->{ipv6} = Samba::get_ipv6_addr($hostname);
644
645 push(@{$ctx->{directories}}, $ctx->{privatedir});
646 push(@{$ctx->{directories}}, $ctx->{binddnsdir});
647 push(@{$ctx->{directories}}, $ctx->{etcdir});
648 push(@{$ctx->{directories}}, $ctx->{piddir});
649 push(@{$ctx->{directories}}, $ctx->{lockdir});
650 push(@{$ctx->{directories}}, $ctx->{logdir});
651 push(@{$ctx->{directories}}, $ctx->{statedir});
652 push(@{$ctx->{directories}}, $ctx->{cachedir});
653
654 $ctx->{smb_conf_extra_options} = "";
655
656 my @provision_options = ();
657 push (@provision_options, "GNUPGHOME=\"$ctx->{gnupghome}\"");
658 push (@provision_options, "KRB5_CONFIG=\"$ctx->{krb5_conf}\"");
659 push (@provision_options, "KRB5CCNAME=\"$ctx->{krb5_ccache}\"");
660 push (@provision_options, "NSS_WRAPPER_PASSWD=\"$ctx->{nsswrap_passwd}\"");
661 push (@provision_options, "NSS_WRAPPER_GROUP=\"$ctx->{nsswrap_group}\"");
662 push (@provision_options, "NSS_WRAPPER_HOSTS=\"$ctx->{nsswrap_hosts}\"");
663 push (@provision_options, "NSS_WRAPPER_HOSTNAME=\"$ctx->{nsswrap_hostname}\"");
664 if (defined($ctx->{use_resolv_wrapper})) {
665 push (@provision_options, "RESOLV_WRAPPER_CONF=\"$ctx->{resolv_conf}\"");
666 push (@provision_options, "RESOLV_CONF=\"$ctx->{resolv_conf}\"");
667 } else {
668 push (@provision_options, "RESOLV_WRAPPER_HOSTS=\"$ctx->{dns_host_file}\"");
669 }
670 if (defined($ctx->{force_fips_mode})) {
671 push (@provision_options, "GNUTLS_FORCE_FIPS_MODE=1");
672 push (@provision_options, "OPENSSL_FORCE_FIPS_MODE=1");
673 }
674
675 if (defined($ENV{GDB_PROVISION})) {
676 push (@provision_options, "gdb --args");
677 if (!defined($ENV{PYTHON})) {
678 push (@provision_options, "env");
679 push (@provision_options, "python");
680 }
681 }
682 if (defined($ENV{VALGRIND_PROVISION})) {
683 push (@provision_options, "valgrind");
684 if (!defined($ENV{PYTHON})) {
685 push (@provision_options, "env");
686 push (@provision_options, "python");
687 }
688 }
689
690 my $samba_tool = Samba::bindir_path($self, "samba-tool");
691
692 push (@provision_options, $samba_tool);
693 push (@provision_options, "domain");
694 push (@provision_options, "provision");
695 push (@provision_options, "--configfile=$ctx->{smb_conf}");
696 push (@provision_options, "--host-name=$ctx->{hostname}");
697 push (@provision_options, "--host-ip=$ctx->{ipv4}");
698 push (@provision_options, "--quiet");
699 push (@provision_options, "--domain=$ctx->{domain}");
700 push (@provision_options, "--realm=$ctx->{realm}");
701 if (defined($ctx->{samsid})) {
702 push (@provision_options, "--domain-sid=$ctx->{samsid}");
703 }
704 push (@provision_options, "--adminpass=$ctx->{password}");
705 push (@provision_options, "--krbtgtpass=krbtgt$ctx->{password}");
706 push (@provision_options, "--machinepass=machine$ctx->{password}");
707 push (@provision_options, "--root=$ctx->{unix_name}");
708 push (@provision_options, "--server-role=\"$ctx->{server_role}\"");
709 push (@provision_options, "--function-level=\"$ctx->{functional_level}\"");
710
711 @{$ctx->{provision_options}} = @provision_options;
712
713 if (defined($extra_provision_options)) {
714 push (@{$ctx->{provision_options}}, @{$extra_provision_options});
715 }
716
717 return $ctx;
718 }
719
720 sub has_option
721 {
722 my ($self, $keyword, @options_list) = @_;
723
724 # convert the options-list to a hash-map for easy keyword lookup
725 my %options_dict = map { $_ => 1 } @options_list;
726
727 return exists $options_dict{$keyword};
728 }
729
730 #
731 # Step1 creates the basic configuration
732 #
733 sub provision_raw_step1($$)
734 {
735 my ($self, $ctx) = @_;
736
737 mkdir($_, 0777) foreach (@{$ctx->{directories}});
738
739 ##
740 ## lockdir and piddir must be 0755
741 ##
742 chmod 0755, $ctx->{lockdir};
743 chmod 0755, $ctx->{piddir};
744
745 unless (open(CONFFILE, ">$ctx->{smb_conf}")) {
746 warn("can't open $ctx->{smb_conf}$?");
747 return undef;
748 }
749
750 Samba::copy_gnupg_home($ctx);
751 Samba::prepare_keyblobs($ctx);
752 my $crlfile = "$ctx->{tlsdir}/crl.pem";
753 $crlfile = "" unless -e ${crlfile};
754
755 # work out which file server to use. Default to source3 smbd (s3fs),
756 # unless the source4 NTVFS (smb) file server has been specified
757 my $services = "-smb +s3fs";
758 if ($self->has_option("--use-ntvfs", @{$ctx->{provision_options}})) {
759 $services = "+smb -s3fs";
760 }
761
762 my $interfaces = Samba::get_interfaces_config($ctx->{netbiosname});
763
764 print CONFFILE "
765 [global]
766 netbios name = $ctx->{netbiosname}
767 posix:eadb = $ctx->{statedir}/eadb.tdb
768 workgroup = $ctx->{domain}
769 realm = $ctx->{realm}
770 private dir = $ctx->{privatedir}
771 binddns dir = $ctx->{binddnsdir}
772 pid directory = $ctx->{piddir}
773 ncalrpc dir = $ctx->{ncalrpcdir}
774 lock dir = $ctx->{lockdir}
775 state directory = $ctx->{statedir}
776 cache directory = $ctx->{cachedir}
777 winbindd socket directory = $ctx->{winbindd_socket_dir}
778 nmbd:socket dir = $ctx->{nmbd_socket_dir}
779 ntp signd socket directory = $ctx->{ntp_signd_socket_dir}
780 winbind separator = /
781 interfaces = $interfaces
782 tls dh params file = $ctx->{tlsdir}/dhparms.pem
783 tls crlfile = ${crlfile}
784 tls verify peer = no_check
785 panic action = $RealBin/gdb_backtrace \%d
786 smbd:suicide mode = yes
787 smbd:FSCTL_SMBTORTURE = yes
788 smbd:validate_oplock_types = yes
789 wins support = yes
790 server role = $ctx->{server_role}
791 server services = +echo $services
792 dcerpc endpoint servers = +winreg +srvsvc +rpcecho
793 notify:inotify = false
794 ldb:nosync = true
795 ldap server require strong auth = yes
796 log file = $ctx->{logdir}/log.\%m
797 log level = $ctx->{server_loglevel}
798 lanman auth = Yes
799 ntlm auth = Yes
800 client min protocol = SMB2_02
801 server min protocol = SMB2_02
802 mangled names = yes
803 dns update command = $ctx->{samba_dnsupdate}
804 spn update command = $ctx->{python} $ENV{SRCDIR_ABS}/source4/scripting/bin/samba_spnupdate --configfile $ctx->{smb_conf}
805 gpo update command = $ctx->{python} $ENV{SRCDIR_ABS}/source4/scripting/bin/samba-gpupdate --configfile $ctx->{smb_conf} --target=Computer
806 samba kcc command = $ctx->{python} $ENV{SRCDIR_ABS}/source4/scripting/bin/samba_kcc
807 dreplsrv:periodic_startup_interval = 0
808 dsdb:schema update allowed = yes
809
810 vfs objects = dfs_samba4 acl_xattr fake_acls xattr_tdb streams_depot
811
812 idmap_ldb:use rfc2307=yes
813 winbind enum users = yes
814 winbind enum groups = yes
815
816 rpc server port:netlogon = 1026
817 include system krb5 conf = no
818
819 debug syslog format = always
820 debug hires timestamp = yes
821
822 ";
823
824 print CONFFILE "
825
826 # Begin extra options
827 $ctx->{smb_conf_extra_options}
828 # End extra options
829 ";
830 close(CONFFILE);
831
832 #Default the KDC IP to the server's IP
833 if (not defined($ctx->{kdc_ipv4})) {
834 $ctx->{kdc_ipv4} = $ctx->{ipv4};
835 }
836 if (not defined($ctx->{kdc_ipv6})) {
837 $ctx->{kdc_ipv6} = $ctx->{ipv6};
838 }
839
840 Samba::mk_krb5_conf($ctx);
841 Samba::mk_mitkdc_conf($ctx, abs_path(Samba::bindir_path($self, "shared")));
842
843 open(PWD, ">$ctx->{nsswrap_passwd}");
844 if ($ctx->{unix_uid} != 0) {
845 print PWD "root:x:0:0:root gecos:$ctx->{prefix_abs}:/bin/false\n";
846 }
847 print PWD "$ctx->{unix_name}:x:$ctx->{unix_uid}:65531:$ctx->{unix_name} gecos:$ctx->{prefix_abs}:/bin/false\n";
848 print PWD "nobody:x:65534:65533:nobody gecos:$ctx->{prefix_abs}:/bin/false
849 pdbtest:x:65533:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
850 pdbtest2:x:65532:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
851 pdbtest3:x:65531:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
852 pdbtest4:x:65530:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
853 ";
854 close(PWD);
855 my $uid_rfc2307test = 65533;
856
857 open(GRP, ">$ctx->{nsswrap_group}");
858 if ($ctx->{unix_gid} != 0) {
859 print GRP "root:x:0:\n";
860 }
861 print GRP "$ctx->{unix_name}:x:$ctx->{unix_gid}:\n";
862 print GRP "wheel:x:10:
863 users:x:65531:
864 nobody:x:65533:
865 nogroup:x:65534:nobody
866 ";
867 close(GRP);
868 my $gid_rfc2307test = 65532;
869
870 my $hostname = lc($ctx->{hostname});
871 open(HOSTS, ">>$ctx->{nsswrap_hosts}");
872 if ($hostname eq "localdc") {
873 print HOSTS "$ctx->{ipv4} ${hostname}.$ctx->{dnsname} $ctx->{dnsname} ${hostname}\n";
874 print HOSTS "$ctx->{ipv6} ${hostname}.$ctx->{dnsname} $ctx->{dnsname} ${hostname}\n";
875 } else {
876 print HOSTS "$ctx->{ipv4} ${hostname}.$ctx->{dnsname} ${hostname}\n";
877 print HOSTS "$ctx->{ipv6} ${hostname}.$ctx->{dnsname} ${hostname}\n";
878 }
879 close(HOSTS);
880
881 my $configuration = "--configfile=$ctx->{smb_conf}";
882
883 #Ensure the config file is valid before we start
884 my $testparm = Samba::bindir_path($self, "samba-tool") . " testparm";
885 if (system("$testparm $configuration -v --suppress-prompt >/dev/null 2>&1") != 0) {
886 system("$testparm -v --suppress-prompt $configuration >&2");
887 warn("Failed to create a valid smb.conf configuration $testparm!");
888 return undef;
889 }
890 unless (system("($testparm $configuration -v --suppress-prompt --parameter-name=\"netbios name\" --section-name=global 2> /dev/null | grep -i \"^$ctx->{netbiosname}\" ) >/dev/null 2>&1") == 0) {
891 warn("Failed to create a valid smb.conf configuration! $testparm $configuration -v --suppress-prompt --parameter-name=\"netbios name\" --section-name=global");
892 return undef;
893 }
894
895 # Return the environment variables for the new testenv DC.
896 # Note that we have SERVER_X and DC_SERVER_X variables (which have the same
897 # value initially). In a 2 DC setup, $DC_SERVER_X will always be the PDC.
898 my $ret = {
899 GNUPGHOME => $ctx->{gnupghome},
900 KRB5_CONFIG => $ctx->{krb5_conf},
901 KRB5_CCACHE => $ctx->{krb5_ccache},
902 MITKDC_CONFIG => $ctx->{mitkdc_conf},
903 PIDDIR => $ctx->{piddir},
904 SERVER => $ctx->{hostname},
905 DC_SERVER => $ctx->{hostname},
906 SERVER_IP => $ctx->{ipv4},
907 DC_SERVER_IP => $ctx->{ipv4},
908 SERVER_IPV6 => $ctx->{ipv6},
909 DC_SERVER_IPV6 => $ctx->{ipv6},
910 NETBIOSNAME => $ctx->{netbiosname},
911 DC_NETBIOSNAME => $ctx->{netbiosname},
912 DOMAIN => $ctx->{domain},
913 USERNAME => $ctx->{username},
914 DC_USERNAME => $ctx->{username},
915 DOMAIN_ADMIN => $ctx->{domain_admin},
916 DOMAIN_ADMIN_PASSWORD => $ctx->{domain_admin_password},
917 DOMAIN_USER => $ctx->{domain_user},
918 DOMAIN_USER_PASSWORD => $ctx->{domain_user_password},
919 REALM => $ctx->{realm},
920 DNSNAME => $ctx->{dnsname},
921 SAMSID => $ctx->{samsid},
922 PASSWORD => $ctx->{password},
923 DC_PASSWORD => $ctx->{password},
924 LDAPDIR => $ctx->{ldapdir},
925 LDAP_INSTANCE => $ctx->{ldap_instance},
926 SELFTEST_WINBINDD_SOCKET_DIR => $ctx->{winbindd_socket_dir},
927 NCALRPCDIR => $ctx->{ncalrpcdir},
928 LOCKDIR => $ctx->{lockdir},
929 STATEDIR => $ctx->{statedir},
930 CACHEDIR => $ctx->{cachedir},
931 PRIVATEDIR => $ctx->{privatedir},
932 BINDDNSDIR => $ctx->{binddnsdir},
933 SERVERCONFFILE => $ctx->{smb_conf},
934 TESTENV_DIR => $ctx->{prefix_abs},
935 CONFIGURATION => $configuration,
936 SOCKET_WRAPPER_DEFAULT_IFACE => $ctx->{swiface},
937 NSS_WRAPPER_PASSWD => $ctx->{nsswrap_passwd},
938 NSS_WRAPPER_GROUP => $ctx->{nsswrap_group},
939 NSS_WRAPPER_HOSTS => $ctx->{nsswrap_hosts},
940 NSS_WRAPPER_HOSTNAME => $ctx->{nsswrap_hostname},
941 SAMBA_TEST_FIFO => "$ctx->{prefix}/samba_test.fifo",
942 SAMBA_TEST_LOG => "$ctx->{prefix}/samba_test.log",
943 SAMBA_TEST_LOG_POS => 0,
944 NSS_WRAPPER_MODULE_SO_PATH => Samba::nss_wrapper_winbind_so_path($self),
945 NSS_WRAPPER_MODULE_FN_PREFIX => "winbind",
946 LOCAL_PATH => $ctx->{share},
947 UID_RFC2307TEST => $uid_rfc2307test,
948 GID_RFC2307TEST => $gid_rfc2307test,
949 SERVER_ROLE => $ctx->{server_role},
950 RESOLV_CONF => $ctx->{resolv_conf},
951 KRB5_CRL_FILE => $crlfile,
952 };
953
954 if (defined($ctx->{use_resolv_wrapper})) {
955 $ret->{RESOLV_WRAPPER_CONF} = $ctx->{resolv_conf};
956 } else {
957 $ret->{RESOLV_WRAPPER_HOSTS} = $ctx->{dns_host_file};
958 }
959 if (defined($ctx->{force_fips_mode})) {
960 $ret->{GNUTLS_FORCE_FIPS_MODE} = "1",
961 $ret->{OPENSSL_FORCE_FIPS_MODE} = "1",
962 }
963
964 if ($ctx->{server_role} eq "domain controller") {
965 $ret->{DOMSID} = $ret->{SAMSID};
966 }
967
968 return $ret;
969 }
970
971 #
972 # Step2 runs the provision script
973 #
974 sub provision_raw_step2($$$)
975 {
976 my ($self, $ctx, $ret) = @_;
977
978 my $ldif;
979
980 my $provision_cmd = join(" ", @{$ctx->{provision_options}});
981 unless (system($provision_cmd) == 0) {
982 warn("Unable to provision: \n$provision_cmd\n");
983 return undef;
984 }
985
986 my $cmd_env = $self->get_cmd_env_vars($ret);
987
988 my $testallowed_account = "testallowed";
989 my $samba_tool_cmd = ${cmd_env};
990 $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
991 . " user create --configfile=$ctx->{smb_conf} $testallowed_account $ctx->{password}";
992 unless (system($samba_tool_cmd) == 0) {
993 warn("Unable to add testallowed user: \n$samba_tool_cmd\n");
994 return undef;
995 }
996
997 my $srv_account = "srv_account";
998 $samba_tool_cmd = ${cmd_env};
999 $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
1000 . " user create --configfile=$ctx->{smb_conf} $srv_account $ctx->{password}";
1001 unless (system($samba_tool_cmd) == 0) {
1002 warn("Unable to add $srv_account user: \n$samba_tool_cmd\n");
1003 return undef;
1004 }
1005
1006 $samba_tool_cmd = ${cmd_env};
1007 $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
1008 . " spn add HOST/$srv_account --configfile=$ctx->{smb_conf} $srv_account";
1009 unless (system($samba_tool_cmd) == 0) {
1010 warn("Unable to add spn for $srv_account: \n$samba_tool_cmd\n");
1011 return undef;
1012 }
1013
1014 my $ldbmodify = ${cmd_env};
1015 $ldbmodify .= Samba::bindir_path($self, "ldbmodify");
1016 $ldbmodify .= " --configfile=$ctx->{smb_conf}";
1017 my $base_dn = "DC=".join(",DC=", split(/\./, $ctx->{realm}));
1018
1019 if ($ctx->{server_role} ne "domain controller") {
1020 $base_dn = "DC=$ctx->{netbiosname}";
1021 }
1022
1023 my $user_dn = "cn=$testallowed_account,cn=users,$base_dn";
1024 $testallowed_account = "testallowed account";
1025 open($ldif, "|$ldbmodify -H $ctx->{privatedir}/sam.ldb")
1026 or die "Failed to run $ldbmodify: $!";
1027 print $ldif "dn: $user_dn
1028 changetype: modify
1029 replace: samAccountName
1030 samAccountName: $testallowed_account
1031 -
1032 ";
1033 close($ldif);
1034 unless ($? == 0) {
1035 warn("$ldbmodify failed: $?");
1036 return undef;
1037 }
1038
1039 open($ldif, "|$ldbmodify -H $ctx->{privatedir}/sam.ldb")
1040 or die "Failed to run $ldbmodify: $!";
1041 print $ldif "dn: $user_dn
1042 changetype: modify
1043 replace: userPrincipalName
1044 userPrincipalName: testallowed upn\@$ctx->{realm}
1045 replace: servicePrincipalName
1046 servicePrincipalName: host/testallowed
1047 -
1048 ";
1049 close($ldif);
1050 unless ($? == 0) {
1051 warn("$ldbmodify failed: $?");
1052 return undef;
1053 }
1054
1055 $samba_tool_cmd = ${cmd_env};
1056 $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
1057 . " user create --configfile=$ctx->{smb_conf} testdenied $ctx->{password}";
1058 unless (system($samba_tool_cmd) == 0) {
1059 warn("Unable to add testdenied user: \n$samba_tool_cmd\n");
1060 return undef;
1061 }
1062
1063 $user_dn = "cn=testdenied,cn=users,$base_dn";
1064 open($ldif, "|$ldbmodify -H $ctx->{privatedir}/sam.ldb")
1065 or die "Failed to run $ldbmodify: $!";
1066 print $ldif "dn: $user_dn
1067 changetype: modify
1068 replace: userPrincipalName
1069 userPrincipalName: testdenied_upn\@$ctx->{realm}.upn
1070 -
1071 ";
1072 close($ldif);
1073 unless ($? == 0) {
1074 warn("$ldbmodify failed: $?");
1075 return undef;
1076 }
1077
1078 $samba_tool_cmd = ${cmd_env};
1079 $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
1080 . " user create --configfile=$ctx->{smb_conf} testupnspn $ctx->{password}";
1081 unless (system($samba_tool_cmd) == 0) {
1082 warn("Unable to add testupnspn user: \n$samba_tool_cmd\n");
1083 return undef;
1084 }
1085
1086 $user_dn = "cn=testupnspn,cn=users,$base_dn";
1087 open($ldif, "|$ldbmodify -H $ctx->{privatedir}/sam.ldb")
1088 or die "Failed to run $ldbmodify: $!";
1089 print $ldif "dn: $user_dn
1090 changetype: modify
1091 replace: userPrincipalName
1092 userPrincipalName: http/testupnspn.$ctx->{dnsname}\@$ctx->{realm}
1093 replace: servicePrincipalName
1094 servicePrincipalName: http/testupnspn.$ctx->{dnsname}
1095 -
1096 ";
1097 close($ldif);
1098 unless ($? == 0) {
1099 warn("$ldbmodify failed: $?");
1100 return undef;
1101 }
1102
1103 $samba_tool_cmd = ${cmd_env};
1104 $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
1105 . " group addmembers --configfile=$ctx->{smb_conf} 'Allowed RODC Password Replication Group' '$testallowed_account'";
1106 unless (system($samba_tool_cmd) == 0) {
1107 warn("Unable to add '$testallowed_account' user to 'Allowed RODC Password Replication Group': \n$samba_tool_cmd\n");
1108 return undef;
1109 }
1110
1111 # Create two users alice and bob!
1112 my $user_account_array = ["alice", "bob", "jane", "joe"];
1113
1114 foreach my $user_account (@{$user_account_array}) {
1115 my $samba_tool_cmd = ${cmd_env};
1116
1117 $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
1118 . " user create --configfile=$ctx->{smb_conf} $user_account Secret007";
1119 unless (system($samba_tool_cmd) == 0) {
1120 warn("Unable to create user: $user_account\n$samba_tool_cmd\n");
1121 return undef;
1122 }
1123 }
1124
1125 my $group_array = ["Samba Users"];
1126
1127 foreach my $group (@{$group_array}) {
1128 my $samba_tool_cmd = ${cmd_env};
1129
1130 $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
1131 . " group add --configfile=$ctx->{smb_conf} \"$group\"";
1132 unless (system($samba_tool_cmd) == 0) {
1133 warn("Unable to create group: $group\n$samba_tool_cmd\n");
1134 return undef;
1135 }
1136 }
1137
1138 # Add user joe to group "Samba Users"
1139 my $group = "Samba Users";
1140 my $user_account = "joe";
1141
1142 $samba_tool_cmd = ${cmd_env};
1143 $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
1144 . " group addmembers --configfile=$ctx->{smb_conf} \"$group\" $user_account";
1145 unless (system($samba_tool_cmd) == 0) {
1146 warn("Unable to add " . $user_account . "to group group : $group\n$samba_tool_cmd\n");
1147 return undef;
1148 }
1149
1150 $group = "Samba Users";
1151 $user_account = "joe";
1152
1153 $samba_tool_cmd = ${cmd_env};
1154 $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
1155 . " user setprimarygroup --configfile=$ctx->{smb_conf} $user_account \"$group\"";
1156 unless (system($samba_tool_cmd) == 0) {
1157 warn("Unable to set primary group of user: $user_account\n$samba_tool_cmd\n");
1158 return undef;
1159 }
1160
1161 # Change the userPrincipalName for jane
1162 $user_dn = "cn=jane,cn=users,$base_dn";
1163
1164 open($ldif, "|$ldbmodify -H $ctx->{privatedir}/sam.ldb")
1165 or die "Failed to run $ldbmodify: $!";
1166 print $ldif "dn: $user_dn
1167 changetype: modify
1168 replace: userPrincipalName
1169 userPrincipalName: jane.doe\@$ctx->{realm}
1170 -
1171 ";
1172 close($ldif);
1173 unless ($? == 0) {
1174 warn("$ldbmodify failed: $?");
1175 return undef;
1176 }
1177
1178 return $ret;
1179 }
1180
1181 sub provision($$$$$$$$$$$)
1182 {
1183 my ($self,
1184 $prefix,
1185 $server_role,
1186 $hostname,
1187 $domain,
1188 $realm,
1189 $functional_level,
1190 $password,
1191 $kdc_ipv4,
1192 $kdc_ipv6,
1193 $force_fips_mode,
1194 $extra_smbconf_options,
1195 $extra_smbconf_shares,
1196 $extra_provision_options) = @_;
1197
1198 my $samsid = Samba::random_domain_sid();
1199
1200 my $ctx = $self->provision_raw_prepare($prefix, $server_role,
1201 $hostname,
1202 $domain, $realm,
1203 $samsid,
1204 $functional_level,
1205 $password,
1206 $kdc_ipv4,
1207 $kdc_ipv6,
1208 $force_fips_mode,
1209 $extra_provision_options);
1210
1211 $ctx->{share} = "$ctx->{prefix_abs}/share";
1212 push(@{$ctx->{directories}}, "$ctx->{share}");
1213 push(@{$ctx->{directories}}, "$ctx->{share}/test1");
1214 push(@{$ctx->{directories}}, "$ctx->{share}/test2");
1215
1216 # precreate directories for printer drivers
1217 push(@{$ctx->{directories}}, "$ctx->{share}/W32X86");
1218 push(@{$ctx->{directories}}, "$ctx->{share}/x64");
1219 push(@{$ctx->{directories}}, "$ctx->{share}/WIN40");
1220
1221 my $msdfs = "no";
1222 $msdfs = "yes" if ($server_role eq "domain controller");
1223 $ctx->{smb_conf_extra_options} = "
1224
1225 max xmit = 32K
1226 server max protocol = SMB2
1227 host msdfs = $msdfs
1228 lanman auth = yes
1229
1230 # fruit:copyfile is a global option
1231 fruit:copyfile = yes
1232
1233 $extra_smbconf_options
1234
1235 [tmp]
1236 path = $ctx->{share}
1237 read only = no
1238 posix:sharedelay = 100000
1239 posix:oplocktimeout = 3
1240 posix:writetimeupdatedelay = 500000
1241
1242 [xcopy_share]
1243 path = $ctx->{share}
1244 read only = no
1245 posix:sharedelay = 100000
1246 posix:oplocktimeout = 3
1247 posix:writetimeupdatedelay = 500000
1248 create mask = 777
1249 force create mode = 777
1250
1251 [posix_share]
1252 path = $ctx->{share}
1253 read only = no
1254 create mask = 0777
1255 force create mode = 0
1256 directory mask = 0777
1257 force directory mode = 0
1258
1259 [test1]
1260 path = $ctx->{share}/test1
1261 read only = no
1262 posix:sharedelay = 100000
1263 posix:oplocktimeout = 3
1264 posix:writetimeupdatedelay = 500000
1265
1266 [test2]
1267 path = $ctx->{share}/test2
1268 read only = no
1269 posix:sharedelay = 100000
1270 posix:oplocktimeout = 3
1271 posix:writetimeupdatedelay = 500000
1272
1273 [cifs]
1274 path = $ctx->{share}/_ignore_cifs_
1275 read only = no
1276 ntvfs handler = cifs
1277 cifs:server = $ctx->{netbiosname}
1278 cifs:share = tmp
1279 cifs:use-s4u2proxy = yes
1280 # There is no username specified here, instead the client is expected
1281 # to log in with kerberos, and the serverwill use delegated credentials.
1282 # Or the server tries s4u2self/s4u2proxy to impersonate the client
1283
1284 [simple]
1285 path = $ctx->{share}
1286 read only = no
1287 ntvfs handler = simple
1288
1289 [sysvol]
1290 path = $ctx->{statedir}/sysvol
1291 read only = no
1292
1293 [netlogon]
1294 path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
1295 read only = no
1296
1297 [cifsposix]
1298 copy = simple
1299 ntvfs handler = cifsposix
1300
1301 [vfs_fruit]
1302 path = $ctx->{share}
1303 vfs objects = catia fruit streams_xattr acl_xattr
1304 ea support = yes
1305 fruit:resource = file
1306 fruit:metadata = netatalk
1307 fruit:locking = netatalk
1308 fruit:encoding = native
1309
1310 [xattr]
1311 path = $ctx->{share}
1312 # This can be used for testing real fs xattr stuff
1313 vfs objects = streams_xattr acl_xattr
1314
1315 $extra_smbconf_shares
1316 ";
1317
1318 my $ret = $self->provision_raw_step1($ctx);
1319 unless (defined $ret) {
1320 return undef;
1321 }
1322
1323 return $self->provision_raw_step2($ctx, $ret);
1324 }
1325
1326 # For multi-DC testenvs, we want $DC_SERVER to always be the PDC (i.e. the
1327 # original DC) in the testenv. $SERVER is always the joined DC that we are
1328 # actually running the test against
1329 sub set_pdc_env_vars
1330 {
1331 my ($self, $env, $dcvars) = @_;
1332
1333 $env->{DC_SERVER} = $dcvars->{DC_SERVER};
1334 $env->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
1335 $env->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
1336 $env->{DC_SERVERCONFFILE} = $dcvars->{SERVERCONFFILE};
1337 $env->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
1338 $env->{DC_USERNAME} = $dcvars->{DC_USERNAME};
1339 $env->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
1340 }
1341
1342 sub provision_s4member($$$$$)
1343 {
1344 my ($self, $prefix, $dcvars, $hostname, $more_conf) = @_;
1345 print "PROVISIONING MEMBER...\n";
1346 my $extra_smb_conf = "
1347 passdb backend = samba_dsdb
1348 winbindd:use external pipes = true
1349
1350 # the source4 smb server doesn't allow signing by default
1351 server signing = enabled
1352 raw NTLMv2 auth = yes
1353
1354 # override the new SMB2 only default
1355 client min protocol = CORE
1356 server min protocol = LANMAN1
1357 ";
1358 if ($more_conf) {
1359 $extra_smb_conf = $extra_smb_conf . $more_conf . "\n";
1360 }
1361 my $extra_provision_options = ["--use-ntvfs"];
1362 my $ret = $self->provision($prefix,
1363 "member server",
1364 $hostname,
1365 $dcvars->{DOMAIN},
1366 $dcvars->{REALM},
1367 "2008",
1368 "locMEMpass3",
1369 $dcvars->{SERVER_IP},
1370 $dcvars->{SERVER_IPV6},
1371 undef,
1372 $extra_smb_conf, "",
1373 $extra_provision_options);
1374 unless ($ret) {
1375 return undef;
1376 }
1377
1378 my $samba_tool = Samba::bindir_path($self, "samba-tool");
1379 my $cmd = $self->get_cmd_env_vars($ret);
1380 $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} --experimental-s4-member member";
1381 $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
1382 $cmd .= " --machinepass=machine$ret->{PASSWORD}";
1383
1384 unless (system($cmd) == 0) {
1385 warn("Join failed\n$cmd");
1386 return undef;
1387 }
1388
1389 $ret->{DOMSID} = $dcvars->{DOMSID};
1390 $self->set_pdc_env_vars($ret, $dcvars);
1391
1392 return $ret;
1393 }
1394
1395 sub provision_rpc_proxy($$$)
1396 {
1397 my ($self, $prefix, $dcvars) = @_;
1398 print "PROVISIONING RPC PROXY...\n";
1399
1400 my $extra_smbconf_options = "
1401 passdb backend = samba_dsdb
1402
1403 # rpc_proxy
1404 dcerpc_remote:binding = ncacn_ip_tcp:$dcvars->{SERVER}
1405 dcerpc endpoint servers = epmapper, remote
1406 dcerpc_remote:interfaces = rpcecho
1407 dcerpc_remote:allow_anonymous_fallback = yes
1408 # override the new SMB2 only default
1409 client min protocol = CORE
1410 server min protocol = LANMAN1
1411 [cifs_to_dc]
1412 path = /tmp/_ignore_cifs_to_dc_/_none_
1413 read only = no
1414 ntvfs handler = cifs
1415 cifs:server = $dcvars->{SERVER}
1416 cifs:share = cifs
1417 cifs:use-s4u2proxy = yes
1418 # There is no username specified here, instead the client is expected
1419 # to log in with kerberos, and the serverwill use delegated credentials.
1420 # Or the server tries s4u2self/s4u2proxy to impersonate the client
1421
1422 ";
1423
1424 my $extra_provision_options = ["--use-ntvfs"];
1425 my $ret = $self->provision($prefix,
1426 "member server",
1427 "localrpcproxy",
1428 $dcvars->{DOMAIN},
1429 $dcvars->{REALM},
1430 "2008",
1431 "locRPCproxypass4",
1432 $dcvars->{SERVER_IP},
1433 $dcvars->{SERVER_IPV6},
1434 undef,
1435 $extra_smbconf_options, "",
1436 $extra_provision_options);
1437 unless ($ret) {
1438 return undef;
1439 }
1440
1441 my $samba_tool = Samba::bindir_path($self, "samba-tool");
1442
1443 # The joind runs in the context of the rpc_proxy/member for now
1444 my $cmd = $self->get_cmd_env_vars($ret);
1445 $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} --experimental-s4-member member";
1446 $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
1447 $cmd .= " --machinepass=machine$ret->{PASSWORD}";
1448
1449 unless (system($cmd) == 0) {
1450 warn("Join failed\n$cmd");
1451 return undef;
1452 }
1453
1454 # Prepare a context of the DC, but using the local CCACHE.
1455 my $overwrite = undef;
1456 $overwrite->{KRB5_CCACHE} = $ret->{KRB5_CCACHE};
1457 my $dc_cmd_env = $self->get_cmd_env_vars($dcvars, $overwrite);
1458
1459 # Setting up delegation runs in the context of the DC for now
1460 $cmd = $dc_cmd_env;
1461 $cmd .= "$samba_tool delegation for-any-protocol '$ret->{NETBIOSNAME}\$' on";
1462 $cmd .= " $dcvars->{CONFIGURATION}";
1463 print $cmd;
1464
1465 unless (system($cmd) == 0) {
1466 warn("Delegation failed\n$cmd");
1467 return undef;
1468 }
1469
1470 # Setting up delegation runs in the context of the DC for now
1471 $cmd = $dc_cmd_env;
1472 $cmd .= "$samba_tool delegation add-service '$ret->{NETBIOSNAME}\$' cifs/$dcvars->{SERVER}";
1473 $cmd .= " $dcvars->{CONFIGURATION}";
1474
1475 unless (system($cmd) == 0) {
1476 warn("Delegation failed\n$cmd");
1477 return undef;
1478 }
1479
1480 $ret->{DOMSID} = $dcvars->{DOMSID};
1481 $self->set_pdc_env_vars($ret, $dcvars);
1482
1483 return $ret;
1484 }
1485
1486 sub provision_promoted_dc($$$)
1487 {
1488 my ($self, $prefix, $dcvars) = @_;
1489 print "PROVISIONING PROMOTED DC...\n";
1490
1491 # We do this so that we don't run the provision. That's the job of 'samba-tool domain dcpromo'.
1492 my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
1493 "promotedvdc",
1494 $dcvars->{DOMAIN},
1495 $dcvars->{REALM},
1496 $dcvars->{SAMSID},
1497 "2008",
1498 $dcvars->{PASSWORD},
1499 $dcvars->{SERVER_IP},
1500 $dcvars->{SERVER_IPV6});
1501
1502 $ctx->{smb_conf_extra_options} = "
1503 max xmit = 32K
1504 server max protocol = SMB2
1505
1506 ntlm auth = ntlmv2-only
1507
1508 kdc force enable rc4 weak session keys = yes
1509
1510 [sysvol]
1511 path = $ctx->{statedir}/sysvol
1512 read only = yes
1513
1514 [netlogon]
1515 path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
1516 read only = no
1517
1518 ";
1519
1520 my $ret = $self->provision_raw_step1($ctx);
1521 unless ($ret) {
1522 return undef;
1523 }
1524
1525 my $samba_tool = Samba::bindir_path($self, "samba-tool");
1526 my $cmd = $self->get_cmd_env_vars($ret);
1527 $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} --experimental-s4-member MEMBER --realm=$dcvars->{REALM}";
1528 $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
1529 $cmd .= " --machinepass=machine$ret->{PASSWORD}";
1530
1531 unless (system($cmd) == 0) {
1532 warn("Join failed\n$cmd");
1533 return undef;
1534 }
1535
1536 $samba_tool = Samba::bindir_path($self, "samba-tool");
1537 $cmd = $self->get_cmd_env_vars($ret);
1538 $cmd .= "$samba_tool domain dcpromo $ret->{CONFIGURATION} $dcvars->{REALM} DC --realm=$dcvars->{REALM}";
1539 $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
1540 $cmd .= " --machinepass=machine$ret->{PASSWORD} --dns-backend=BIND9_DLZ";
1541
1542 unless (system($cmd) == 0) {
1543 warn("Join failed\n$cmd");
1544 return undef;
1545 }
1546
1547 $self->set_pdc_env_vars($ret, $dcvars);
1548
1549 return $ret;
1550 }
1551
1552 sub provision_vampire_dc($$$)
1553 {
1554 my ($self, $prefix, $dcvars, $fl) = @_;
1555 print "PROVISIONING VAMPIRE DC @ FL $fl...\n";
1556 my $name = "localvampiredc";
1557 my $extra_conf = "";
1558
1559 if ($fl == "2000") {
1560 $name = "vampire2000dc";
1561 } else {
1562 $extra_conf = "drs: immediate link sync = yes
1563 drs: max link sync = 250";
1564 }
1565
1566 # We do this so that we don't run the provision. That's the job of 'net vampire'.
1567 my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
1568 $name,
1569 $dcvars->{DOMAIN},
1570 $dcvars->{REALM},
1571 $dcvars->{DOMSID},
1572 $fl,
1573 $dcvars->{PASSWORD},
1574 $dcvars->{SERVER_IP},
1575 $dcvars->{SERVER_IPV6});
1576
1577 $ctx->{smb_conf_extra_options} = "
1578 max xmit = 32K
1579 server max protocol = SMB2
1580
1581 ntlm auth = mschapv2-and-ntlmv2-only
1582 $extra_conf
1583
1584 [sysvol]
1585 path = $ctx->{statedir}/sysvol
1586 read only = yes
1587
1588 [netlogon]
1589 path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
1590 read only = no
1591
1592 ";
1593
1594 my $ret = $self->provision_raw_step1($ctx);
1595 unless ($ret) {
1596 return undef;
1597 }
1598
1599 my $samba_tool = Samba::bindir_path($self, "samba-tool");
1600 my $cmd = $self->get_cmd_env_vars($ret);
1601 $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} DC --realm=$dcvars->{REALM}";
1602 $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD} --domain-critical-only";
1603 $cmd .= " --machinepass=machine$ret->{PASSWORD}";
1604 $cmd .= " --backend-store=$self->{default_ldb_backend}";
1605
1606 unless (system($cmd) == 0) {
1607 warn("Join failed\n$cmd");
1608 return undef;
1609 }
1610
1611 $self->set_pdc_env_vars($ret, $dcvars);
1612 $ret->{DC_REALM} = $dcvars->{DC_REALM};
1613
1614 return $ret;
1615 }
1616
1617 sub provision_ad_dc_ntvfs($$$)
1618 {
1619 my ($self, $prefix, $extra_provision_options) = @_;
1620
1621 # We keep the old 'winbind' name here in server services to
1622 # ensure upgrades which used that name still work with the now
1623 # alias.
1624
1625 print "PROVISIONING AD DC (NTVFS)...\n";
1626 my $extra_conf_options = "netbios aliases = localDC1-a
1627 server services = +winbind -winbindd
1628 ldap server require strong auth = allow_sasl_without_tls_channel_bindings
1629 raw NTLMv2 auth = yes
1630 lsa over netlogon = yes
1631 rpc server port = 1027
1632 auth event notification = true
1633 dsdb event notification = true
1634 dsdb password event notification = true
1635 dsdb group change notification = true
1636 # override the new SMB2 only default
1637 client min protocol = CORE
1638 server min protocol = LANMAN1
1639
1640 CVE_2020_1472:warn_about_unused_debug_level = 3
1641 CVE_2022_38023:warn_about_unused_debug_level = 3
1642 allow nt4 crypto:torturetest\$ = yes
1643 server reject md5 schannel:schannel2\$ = no
1644 server reject md5 schannel:schannel3\$ = no
1645 server reject md5 schannel:schannel8\$ = no
1646 server reject md5 schannel:schannel9\$ = no
1647 server reject md5 schannel:torturetest\$ = no
1648 server reject md5 schannel:tests4u2proxywk\$ = no
1649 server reject md5 schannel:tests4u2selfbdc\$ = no
1650 server reject md5 schannel:tests4u2selfwk\$ = no
1651 server reject md5 schannel:torturepacbdc\$ = no
1652 server reject md5 schannel:torturepacwksta\$ = no
1653 server require schannel:schannel0\$ = no
1654 server require schannel:schannel1\$ = no
1655 server require schannel:schannel2\$ = no
1656 server require schannel:schannel3\$ = no
1657 server require schannel:schannel4\$ = no
1658 server require schannel:schannel5\$ = no
1659 server require schannel:schannel6\$ = no
1660 server require schannel:schannel7\$ = no
1661 server require schannel:schannel8\$ = no
1662 server require schannel:schannel9\$ = no
1663 server require schannel:schannel10\$ = no
1664 server require schannel:schannel11\$ = no
1665 server require schannel:torturetest\$ = no
1666 server schannel require seal:schannel0\$ = no
1667 server schannel require seal:schannel1\$ = no
1668 server schannel require seal:schannel2\$ = no
1669 server schannel require seal:schannel3\$ = no
1670 server schannel require seal:schannel4\$ = no
1671 server schannel require seal:schannel5\$ = no
1672 server schannel require seal:schannel6\$ = no
1673 server schannel require seal:schannel7\$ = no
1674 server schannel require seal:schannel8\$ = no
1675 server schannel require seal:schannel9\$ = no
1676 server schannel require seal:schannel10\$ = no
1677 server schannel require seal:schannel11\$ = no
1678 server schannel require seal:torturetest\$ = no
1679
1680 # needed for 'samba.tests.auth_log' tests
1681 server require schannel:LOCALDC\$ = no
1682 server schannel require seal:LOCALDC\$ = no
1683 ";
1684 push (@{$extra_provision_options},
1685 "--base-schema=2008_R2",
1686 "--use-ntvfs");
1687 my $ret = $self->provision($prefix,
1688 "domain controller",
1689 "localdc",
1690 "SAMBADOMAIN",
1691 "samba.example.com",
1692 "2008",
1693 "locDCpass1",
1694 undef,
1695 undef,
1696 undef,
1697 $extra_conf_options,
1698 "",
1699 $extra_provision_options);
1700 unless ($ret) {
1701 return undef;
1702 }
1703
1704 unless($self->add_wins_config("$prefix/private")) {
1705 warn("Unable to add wins configuration");
1706 return undef;
1707 }
1708 $ret->{NETBIOSALIAS} = "localdc1-a";
1709 $ret->{DC_REALM} = $ret->{REALM};
1710
1711 return $ret;
1712 }
1713
1714 sub provision_fl2000dc($$)
1715 {
1716 my ($self, $prefix) = @_;
1717
1718 print "PROVISIONING DC WITH FOREST LEVEL 2000...\n";
1719 my $extra_conf_options = "
1720 kdc enable fast = no
1721 spnego:simulate_w2k=yes
1722 ntlmssp_server:force_old_spnego=yes
1723
1724 CVE_2022_38023:warn_about_unused_debug_level = 3
1725 server reject md5 schannel:tests4u2proxywk\$ = no
1726 server reject md5 schannel:tests4u2selfbdc\$ = no
1727 server reject md5 schannel:tests4u2selfwk\$ = no
1728 server reject md5 schannel:torturepacbdc\$ = no
1729 server reject md5 schannel:torturepacwksta\$ = no
1730 ";
1731 my $extra_provision_options = ["--base-schema=2008_R2"];
1732 # This environment uses plain text secrets
1733 # i.e. secret attributes are not encrypted on disk.
1734 # This allows testing of the --plaintext-secrets option for
1735 # provision
1736 push (@{$extra_provision_options}, "--plaintext-secrets");
1737 my $ret = $self->provision($prefix,
1738 "domain controller",
1739 "dc5",
1740 "SAMBA2000",
1741 "samba2000.example.com",
1742 "2000",
1743 "locDCpass5",
1744 undef,
1745 undef,
1746 undef,
1747 $extra_conf_options,
1748 "",
1749 $extra_provision_options);
1750 unless ($ret) {
1751 return undef;
1752 }
1753
1754 unless($self->add_wins_config("$prefix/private")) {
1755 warn("Unable to add wins configuration");
1756 return undef;
1757 }
1758 $ret->{DC_REALM} = $ret->{REALM};
1759
1760 return $ret;
1761 }
1762
1763 sub provision_fl2003dc($$$)
1764 {
1765 my ($self, $prefix, $dcvars) = @_;
1766 my $ip_addr1 = Samba::get_ipv4_addr("fakednsforwarder1");
1767 my $ip_addr2 = Samba::get_ipv6_addr("fakednsforwarder2");
1768
1769 print "PROVISIONING DC WITH FOREST LEVEL 2003...\n";
1770 my $extra_conf_options = "
1771 allow dns updates = nonsecure and secure
1772
1773 kdc enable fast = no
1774 dcesrv:header signing = no
1775 dcesrv:max auth states = 0
1776
1777 dns forwarder = $ip_addr1 [$ip_addr2]:54
1778
1779 CVE_2022_38023:warn_about_unused_debug_level = 3
1780 server reject md5 schannel:tests4u2proxywk\$ = no
1781 server reject md5 schannel:tests4u2selfbdc\$ = no
1782 server reject md5 schannel:tests4u2selfwk\$ = no
1783 server reject md5 schannel:torturepacbdc\$ = no
1784 server reject md5 schannel:torturepacwksta\$ = no
1785 ";
1786
1787 my $extra_provision_options = ["--base-schema=2008_R2"];
1788 my $ret = $self->provision($prefix,
1789 "domain controller",
1790 "dc6",
1791 "SAMBA2003",
1792 "samba2003.example.com",
1793 "2003",
1794 "locDCpass6",
1795 undef,
1796 undef,
1797 undef,
1798 $extra_conf_options,
1799 "",
1800 $extra_provision_options);
1801 unless (defined $ret) {
1802 return undef;
1803 }
1804
1805 $ret->{DNS_FORWARDER1} = $ip_addr1;
1806 $ret->{DNS_FORWARDER2} = $ip_addr2;
1807
1808 my @samba_tool_options;
1809 push (@samba_tool_options, Samba::bindir_path($self, "samba-tool"));
1810 push (@samba_tool_options, "domain");
1811 push (@samba_tool_options, "passwordsettings");
1812 push (@samba_tool_options, "set");
1813 push (@samba_tool_options, "--configfile=$ret->{SERVERCONFFILE}");
1814 push (@samba_tool_options, "--min-pwd-age=0");
1815 push (@samba_tool_options, "--history-length=1");
1816
1817 my $samba_tool_cmd = join(" ", @samba_tool_options);
1818
1819 unless (system($samba_tool_cmd) == 0) {
1820 warn("Unable to set min password age to 0: \n$samba_tool_cmd\n");
1821 return undef;
1822 }
1823
1824 unless($self->add_wins_config("$prefix/private")) {
1825 warn("Unable to add wins configuration");
1826 return undef;
1827 }
1828
1829 return $ret;
1830 }
1831
1832 sub provision_fl2008r2dc($$$)
1833 {
1834 my ($self, $prefix, $dcvars) = @_;
1835
1836 print "PROVISIONING DC WITH FOREST LEVEL 2008r2...\n";
1837 my $extra_conf_options = "
1838 ldap server require strong auth = no
1839 # delay by 10 seconds, 10^7 usecs
1840 ldap_server:delay_expire_disconnect = 10000
1841
1842 CVE_2022_38023:warn_about_unused_debug_level = 3
1843 server reject md5 schannel:tests4u2proxywk\$ = no
1844 server reject md5 schannel:tests4u2selfbdc\$ = no
1845 server reject md5 schannel:tests4u2selfwk\$ = no
1846 server reject md5 schannel:torturepacbdc\$ = no
1847 server reject md5 schannel:torturepacwksta\$ = no
1848 ";
1849 my $extra_provision_options = ["--base-schema=2008_R2"];
1850 my $ret = $self->provision($prefix,
1851 "domain controller",
1852 "dc7",
1853 "SAMBA2008R2",
1854 "samba2008R2.example.com",
1855 "2008_R2",
1856 "locDCpass7",
1857 undef,
1858 undef,
1859 undef,
1860 $extra_conf_options,
1861 "",
1862 $extra_provision_options);
1863 unless (defined $ret) {
1864 return undef;
1865 }
1866
1867 unless ($self->add_wins_config("$prefix/private")) {
1868 warn("Unable to add wins configuration");
1869 return undef;
1870 }
1871 $ret->{DC_REALM} = $ret->{REALM};
1872
1873 return $ret;
1874 }
1875
1876
1877 sub provision_rodc($$$)
1878 {
1879 my ($self, $prefix, $dcvars) = @_;
1880 print "PROVISIONING RODC...\n";
1881
1882 # We do this so that we don't run the provision. That's the job of 'net join RODC'.
1883 my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
1884 "rodc",
1885 $dcvars->{DOMAIN},
1886 $dcvars->{REALM},
1887 $dcvars->{DOMSID},
1888 "2008",
1889 $dcvars->{PASSWORD},
1890 $dcvars->{SERVER_IP},
1891 $dcvars->{SERVER_IPV6});
1892 unless ($ctx) {
1893 return undef;
1894 }
1895
1896 $ctx->{share} = "$ctx->{prefix_abs}/share";
1897 push(@{$ctx->{directories}}, "$ctx->{share}");
1898
1899 $ctx->{smb_conf_extra_options} = "
1900 max xmit = 32K
1901 server max protocol = SMB2
1902 password server = $dcvars->{DC_SERVER}
1903
1904 [sysvol]
1905 path = $ctx->{statedir}/sysvol
1906 read only = yes
1907
1908 [netlogon]
1909 path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
1910 read only = yes
1911
1912 [tmp]
1913 path = $ctx->{share}
1914 read only = no
1915 posix:sharedelay = 10000
1916 posix:oplocktimeout = 3
1917 posix:writetimeupdatedelay = 50000
1918
1919 ";
1920
1921 my $ret = $self->provision_raw_step1($ctx);
1922 unless ($ret) {
1923 return undef;
1924 }
1925
1926 my $samba_tool = Samba::bindir_path($self, "samba-tool");
1927 my $cmd = $self->get_cmd_env_vars($ret);
1928 $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} RODC";
1929 $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
1930 $cmd .= " --server=$dcvars->{DC_SERVER}";
1931
1932 unless (system($cmd) == 0) {
1933 warn("RODC join failed\n$cmd");
1934 return undef;
1935 }
1936
1937 # This ensures deterministic behaviour for tests that want to have the 'testallowed account'
1938 # user password verified on the RODC
1939 my $testallowed_account = "testallowed account";
1940 $cmd = $self->get_cmd_env_vars($ret);
1941 $cmd .= "$samba_tool rodc preload '$testallowed_account' $ret->{CONFIGURATION}";
1942 $cmd .= " --server=$dcvars->{DC_SERVER}";
1943
1944 unless (system($cmd) == 0) {
1945 warn("RODC join failed\n$cmd");
1946 return undef;
1947 }
1948
1949 # we overwrite the kdc after the RODC join
1950 # so that use the RODC as kdc and test
1951 # the proxy code
1952 $ctx->{kdc_ipv4} = $ret->{SERVER_IP};
1953 $ctx->{kdc_ipv6} = $ret->{SERVER_IPV6};
1954 Samba::mk_krb5_conf($ctx);
1955 Samba::mk_mitkdc_conf($ctx, abs_path(Samba::bindir_path($self, "shared")));
1956
1957 $self->set_pdc_env_vars($ret, $dcvars);
1958
1959 return $ret;
1960 }
1961
1962 sub read_config_h($)
1963 {
1964 my ($name) = @_;
1965 my %ret;
1966 open(LF, "<$name") or die("unable to read $name: $!");
1967 while (<LF>) {
1968 chomp;
1969 next if not (/^#define /);
1970 if (/^#define (.*?)[ \t]+(.*?)$/) {
1971 $ret{$1} = $2;
1972 next;
1973 }
1974 if (/^#define (.*?)[ \t]+$/) {
1975 $ret{$1} = 1;;
1976 next;
1977 }
1978 }
1979 close(LF);
1980 return \%ret;
1981 }
1982
1983 sub provision_ad_dc()
1984 {
1985 my ($self,
1986 $prefix,
1987 $hostname,
1988 $domain,
1989 $realm,
1990 $force_fips_mode,
1991 $smbconf_args,
1992 $extra_provision_options,
1993 $functional_level) = @_;
1994
1995 my $prefix_abs = abs_path($prefix);
1996
1997 my $bindir_abs = abs_path($self->{bindir});
1998 my $lockdir="$prefix_abs/lockdir";
1999 my $conffile="$prefix_abs/etc/smb.conf";
2000
2001 my $require_mutexes = "dbwrap_tdb_require_mutexes:* = yes";
2002 if ($ENV{SELFTEST_DONT_REQUIRE_TDB_MUTEX_SUPPORT} // '' eq "1") {
2003 $require_mutexes = "";
2004 }
2005
2006 my $config_h = {};
2007
2008 if (!defined($functional_level)) {
2009 $functional_level = "2016";
2010 }
2011
2012 # If we choose to have distinct environments for experimental
2013 # 2012 as well as the experimental 2016 support, we should
2014 # extend what we match here.
2015 if ($functional_level eq "2016") {
2016 $smbconf_args = "$smbconf_args
2017
2018 [global]
2019 ad dc functional level = 2016
2020 ";
2021 }
2022 if (defined($ENV{CONFIG_H})) {
2023 $config_h = read_config_h($ENV{CONFIG_H});
2024 }
2025
2026 my $password_hash_gpg_key_ids = "password hash gpg key ids = 4952E40301FAB41A";
2027 $password_hash_gpg_key_ids = "" unless defined($config_h->{HAVE_GPGME});
2028
2029 my $extra_smbconf_options = "
2030 xattr_tdb:file = $prefix_abs/statedir/xattr.tdb
2031
2032 dbwrap_tdb_mutexes:* = yes
2033 ${require_mutexes}
2034
2035 ${password_hash_gpg_key_ids}
2036
2037 kernel oplocks = no
2038 kernel change notify = no
2039 smb2 leases = no
2040 smb2 disable oplock break retry = yes
2041 server multi channel support = yes
2042
2043 logging = file
2044 printing = bsd
2045 printcap name = /dev/null
2046
2047 max protocol = SMB3
2048 read only = no
2049
2050 smbd:sharedelay = 100000
2051 smbd:writetimeupdatedelay = 500000
2052 create mask = 755
2053 dos filemode = yes
2054 check parent directory delete on close = yes
2055
2056 dcerpc endpoint servers = -winreg -srvsvc
2057
2058 printcap name = /dev/null
2059
2060 addprinter command = $ENV{SRCDIR_ABS}/source3/script/tests/printing/modprinter.pl -a -s $conffile --
2061 deleteprinter command = $ENV{SRCDIR_ABS}/source3/script/tests/printing/modprinter.pl -d -s $conffile --
2062
2063 printing = vlp
2064 print command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb print %p %s
2065 lpq command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpq %p
2066 lp rm command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lprm %p %j
2067 lp pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lppause %p %j
2068 lp resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpresume %p %j
2069 queue pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queuepause %p
2070 queue resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queueresume %p
2071 lpq cache time = 0
2072 print notify backchannel = yes
2073
2074 CVE_2020_1472:warn_about_unused_debug_level = 3
2075 CVE_2022_38023:warn_about_unused_debug_level = 3
2076 CVE_2022_38023:error_debug_level = 2
2077 server reject md5 schannel:schannel2\$ = no
2078 server reject md5 schannel:schannel3\$ = no
2079 server reject md5 schannel:schannel8\$ = no
2080 server reject md5 schannel:schannel9\$ = no
2081 server reject md5 schannel:torturetest\$ = no
2082 server reject md5 schannel:tests4u2proxywk\$ = no
2083 server reject md5 schannel:tests4u2selfbdc\$ = no
2084 server reject md5 schannel:tests4u2selfwk\$ = no
2085 server reject md5 schannel:torturepacbdc\$ = no
2086 server reject md5 schannel:torturepacwksta\$ = no
2087 server reject md5 schannel:samlogontest\$ = no
2088 server require schannel:schannel0\$ = no
2089 server require schannel:schannel1\$ = no
2090 server require schannel:schannel2\$ = no
2091 server require schannel:schannel3\$ = no
2092 server require schannel:schannel4\$ = no
2093 server require schannel:schannel5\$ = no
2094 server require schannel:schannel6\$ = no
2095 server require schannel:schannel7\$ = no
2096 server require schannel:schannel8\$ = no
2097 server require schannel:schannel9\$ = no
2098 server require schannel:schannel10\$ = no
2099 server require schannel:schannel11\$ = no
2100 server require schannel:torturetest\$ = no
2101 server schannel require seal:schannel0\$ = no
2102 server schannel require seal:schannel1\$ = no
2103 server schannel require seal:schannel2\$ = no
2104 server schannel require seal:schannel3\$ = no
2105 server schannel require seal:schannel4\$ = no
2106 server schannel require seal:schannel5\$ = no
2107 server schannel require seal:schannel6\$ = no
2108 server schannel require seal:schannel7\$ = no
2109 server schannel require seal:schannel8\$ = no
2110 server schannel require seal:schannel9\$ = no
2111 server schannel require seal:schannel10\$ = no
2112 server schannel require seal:schannel11\$ = no
2113 server schannel require seal:torturetest\$ = no
2114
2115 auth event notification = true
2116 dsdb event notification = true
2117 dsdb password event notification = true
2118 dsdb group change notification = true
2119 $smbconf_args
2120 ";
2121
2122 my $extra_smbconf_shares = "
2123
2124 [tmpenc]
2125 copy = tmp
2126 smb encrypt = required
2127
2128 [tmpcase]
2129 copy = tmp
2130 case sensitive = yes
2131
2132 [tmpguest]
2133 copy = tmp
2134 guest ok = yes
2135
2136 [hideunread]
2137 copy = tmp
2138 hide unreadable = yes
2139
2140 [durable]
2141 copy = tmp
2142 kernel share modes = no
2143 kernel oplocks = no
2144 posix locking = no
2145
2146 [print\$]
2147 copy = tmp
2148
2149 [print1]
2150 copy = tmp
2151 printable = yes
2152
2153 [print2]
2154 copy = print1
2155 [print3]
2156 copy = print1
2157 [print4]
2158 copy = print1
2159 guest ok = yes
2160 [lp]
2161 copy = print1
2162 ";
2163
2164 push (@{$extra_provision_options}, "--backend-store=$self->{default_ldb_backend}");
2165 print "PROVISIONING AD DC...\n";
2166 my $ret = $self->provision($prefix,
2167 "domain controller",
2168 $hostname,
2169 $domain,
2170 $realm,
2171 $functional_level,
2172 "locDCpass1",
2173 undef,
2174 undef,
2175 $force_fips_mode,
2176 $extra_smbconf_options,
2177 $extra_smbconf_shares,
2178 $extra_provision_options);
2179 unless (defined $ret) {
2180 return undef;
2181 }
2182
2183 unless($self->add_wins_config("$prefix/private")) {
2184 warn("Unable to add wins configuration");
2185 return undef;
2186 }
2187
2188 return $ret;
2189 }
2190
2191 sub provision_chgdcpass($$)
2192 {
2193 my ($self, $prefix) = @_;
2194
2195 print "PROVISIONING CHGDCPASS...\n";
2196 # This environment disallows the use of this password
2197 # (and also removes the default AD complexity checks)
2198 my $unacceptable_password = "Paßßword-widk3Dsle32jxdBdskldsk55klASKQ";
2199
2200 # This environment also sets some settings that are unusual,
2201 # to test specific behaviours. In particular, this
2202 # environment fails to correctly support DRSUAPI_DRS_GET_ANC
2203 # like Samba before 4.5 and DRSUAPI_DRS_GET_TGT before 4.8
2204 #
2205 # Additionally, disabling DRSUAPI_DRS_GET_TGT causes all links
2206 # to be sent last (in the final chunk), which is like Samba
2207 # before 4.8.
2208
2209 my $extra_smb_conf = "
2210 check password script = $self->{srcdir}/selftest/checkpassword_arg1.sh ${unacceptable_password}
2211 allow dcerpc auth level connect:lsarpc = yes
2212 dcesrv:max auth states = 8
2213 drs:broken_samba_4.5_get_anc_emulation = true
2214 drs:get_tgt_support = false
2215 ";
2216 my $extra_provision_options = ["--dns-backend=BIND9_DLZ"];
2217 my $ret = $self->provision($prefix,
2218 "domain controller",
2219 "chgdcpass",
2220 "CHDCDOMAIN",
2221 "chgdcpassword.samba.example.com",
2222 "2008",
2223 "chgDCpass1",
2224 undef,
2225 undef,
2226 undef,
2227 $extra_smb_conf,
2228 "",
2229 $extra_provision_options);
2230 unless (defined $ret) {
2231 return undef;
2232 }
2233
2234 unless($self->add_wins_config("$prefix/private")) {
2235 warn("Unable to add wins configuration");
2236 return undef;
2237 }
2238
2239 # Remove secrets.tdb from this environment to test that we
2240 # still start up on systems without the new matching
2241 # secrets.tdb records.
2242 unless (unlink("$ret->{PRIVATEDIR}/secrets.tdb") || unlink("$ret->{PRIVATEDIR}/secrets.ntdb")) {
2243 warn("Unable to remove $ret->{PRIVATEDIR}/secrets.tdb added during provision");
2244 return undef;
2245 }
2246
2247 $ret->{UNACCEPTABLE_PASSWORD} = $unacceptable_password;
2248
2249 return $ret;
2250 }
2251
2252 sub teardown_env_terminate($$)
2253 {
2254 my ($self, $envvars) = @_;
2255 my $pid;
2256
2257 # This should cause samba to terminate gracefully
2258 my $smbcontrol = Samba::bindir_path($self, "smbcontrol");
2259 my $cmd = "";
2260 $cmd .= "$smbcontrol samba shutdown $envvars->{CONFIGURATION}";
2261 my $ret = system($cmd);
2262 if ($ret != 0) {
2263 warn "'$cmd' failed with '$ret'\n";
2264 }
2265
2266 # This should cause samba to terminate gracefully
2267 close($envvars->{STDIN_PIPE});
2268
2269 $pid = $envvars->{SAMBA_PID};
2270 my $count = 0;
2271 my $childpid;
2272
2273 # This should give it time to write out the gcov data
2274 until ($count > 15) {
2275 if (Samba::cleanup_child($pid, "samba") != 0) {
2276 return;
2277 }
2278 sleep(1);
2279 $count++;
2280 }
2281
2282 # After 15 Seconds, work out why this thing is still alive
2283 warn "server process $pid took more than $count seconds to exit, showing backtrace:\n";
2284 system("$self->{srcdir}/selftest/gdb_backtrace $pid");
2285
2286 until ($count > 30) {
2287 if (Samba::cleanup_child($pid, "samba") != 0) {
2288 return;
2289 }
2290 sleep(1);
2291 $count++;
2292 }
2293
2294 if (kill(0, $pid)) {
2295 warn "server process $pid took more than $count seconds to exit, sending SIGTERM\n";
2296 kill "TERM", $pid;
2297 }
2298
2299 until ($count > 40) {
2300 if (Samba::cleanup_child($pid, "samba") != 0) {
2301 return;
2302 }
2303 sleep(1);
2304 $count++;
2305 }
2306 # If it is still around, kill it
2307 if (kill(0, $pid)) {
2308 warn "server process $pid took more than $count seconds to exit, killing\n with SIGKILL\n";
2309 kill 9, $pid;
2310 }
2311 return;
2312 }
2313
2314 sub teardown_env($$)
2315 {
2316 my ($self, $envvars) = @_;
2317 teardown_env_terminate($self, $envvars);
2318
2319 print $self->getlog_env($envvars);
2320
2321 return;
2322 }
2323
2324 sub getlog_env($$)
2325 {
2326 my ($self, $envvars) = @_;
2327 my $title = "SAMBA LOG of: $envvars->{NETBIOSNAME} pid $envvars->{SAMBA_PID}\n";
2328 my $out = $title;
2329
2330 open(LOG, "<$envvars->{SAMBA_TEST_LOG}");
2331
2332 seek(LOG, $envvars->{SAMBA_TEST_LOG_POS}, SEEK_SET);
2333 while (<LOG>) {
2334 $out .= $_;
2335 }
2336 $envvars->{SAMBA_TEST_LOG_POS} = tell(LOG);
2337 close(LOG);
2338
2339 return "" if $out eq $title;
2340
2341 return $out;
2342 }
2343
2344 sub check_env($$)
2345 {
2346 my ($self, $envvars) = @_;
2347 my $samba_pid = $envvars->{SAMBA_PID};
2348
2349 if (not defined($samba_pid)) {
2350 return 0;
2351 } elsif ($samba_pid > 0) {
2352 my $childpid = Samba::cleanup_child($samba_pid, "samba");
2353
2354 if ($childpid == 0) {
2355 return 1;
2356 }
2357 return 0;
2358 } else {
2359 return 1;
2360 }
2361 }
2362
2363 # Declare the environments Samba4 makes available.
2364 # To be set up, they will be called as
2365 # samba4->setup_$envname($self, $path, $dep_1_vars, $dep_2_vars, ...)
2366 # The interdependencies between the testenvs are declared below. Some testenvs
2367 # are dependent on another testenv running first, e.g. vampire_dc is dependent
2368 # on ad_dc_ntvfs because vampire_dc joins ad_dc_ntvfs's domain. All DCs are
2369 # dependent on dns_hub, which handles resolving DNS queries for the realm.
2370 %Samba4::ENV_DEPS = (
2371 # name => [dep_1, dep_2, ...],
2372 dns_hub => [],
2373 ad_dc_ntvfs => ["dns_hub"],
2374 ad_dc_fips => ["dns_hub"],
2375 ad_dc => ["dns_hub"],
2376 ad_dc_smb1 => ["dns_hub"],
2377 ad_dc_smb1_done => ["ad_dc_smb1"],
2378 ad_dc_no_nss => ["dns_hub"],
2379 ad_dc_no_ntlm => ["dns_hub"],
2380
2381 fl2008r2dc => ["ad_dc", "nt4_dc"],
2382 fl2003dc => ["ad_dc"],
2383 fl2000dc => ["ad_dc"],
2384
2385 vampire_2000_dc => ["fl2000dc"],
2386 vampire_dc => ["ad_dc_ntvfs"],
2387 promoted_dc => ["ad_dc_ntvfs"],
2388
2389 rodc => ["ad_dc_ntvfs"],
2390 rpc_proxy => ["ad_dc_ntvfs"],
2391 chgdcpass => ["dns_hub"],
2392
2393 s4member_dflt_domain => ["ad_dc_ntvfs"],
2394 s4member => ["ad_dc_ntvfs"],
2395
2396 # envs that test the server process model
2397 proclimitdc => ["dns_hub"],
2398 preforkrestartdc => ["dns_hub"],
2399
2400 # backup/restore testenvs
2401 backupfromdc => ["dns_hub"],
2402 customdc => ["dns_hub"],
2403 restoredc => ["backupfromdc"],
2404 renamedc => ["backupfromdc"],
2405 offlinebackupdc => ["backupfromdc"],
2406 labdc => ["backupfromdc"],
2407
2408 # aliases in order to split autobuild tasks
2409 fl2008dc => ["ad_dc_ntvfs"],
2410 ad_dc_default => ["ad_dc"],
2411 ad_dc_default_smb1 => ["ad_dc_smb1"],
2412 ad_dc_default_smb1_done => ["ad_dc_default_smb1"],
2413 ad_dc_slowtests => ["ad_dc"],
2414 ad_dc_backup => ["ad_dc"],
2415
2416 schema_dc => ["dns_hub"],
2417 schema_pair_dc => ["schema_dc"],
2418
2419 none => [],
2420 );
2421
2422 %Samba4::ENV_DEPS_POST = (
2423 schema_dc => ["schema_pair_dc"],
2424 );
2425
2426 sub return_alias_env
2427 {
2428 my ($self, $path, $env) = @_;
2429
2430 # just an alias
2431 return $env;
2432 }
2433
2434 sub setup_fl2008dc
2435 {
2436 my ($self, $path, $dep_env) = @_;
2437 return $self->return_alias_env($path, $dep_env)
2438 }
2439
2440 sub setup_ad_dc_default
2441 {
2442 my ($self, $path, $dep_env) = @_;
2443 return $self->return_alias_env($path, $dep_env)
2444 }
2445
2446 sub setup_ad_dc_default_smb1
2447 {
2448 my ($self, $path, $dep_env) = @_;
2449 return $self->return_alias_env($path, $dep_env)
2450 }
2451
2452 sub setup_ad_dc_default_smb1_done
2453 {
2454 my ($self, $path, $dep_env) = @_;
2455 return $self->return_alias_env($path, $dep_env)
2456 }
2457
2458 sub setup_ad_dc_slowtests
2459 {
2460 my ($self, $path, $dep_env) = @_;
2461 return $self->return_alias_env($path, $dep_env)
2462 }
2463
2464 sub setup_ad_dc_backup
2465 {
2466 my ($self, $path, $dep_env) = @_;
2467 return $self->return_alias_env($path, $dep_env)
2468 }
2469
2470 sub setup_s4member
2471 {
2472 my ($self, $path, $dc_vars) = @_;
2473
2474 my $env = $self->provision_s4member($path, $dc_vars, "s4member");
2475
2476 if (defined $env) {
2477 if (not defined($self->check_or_start($env, "standard"))) {
2478 return undef;
2479 }
2480 }
2481
2482 return $env;
2483 }
2484
2485 sub setup_s4member_dflt_domain
2486 {
2487 my ($self, $path, $dc_vars) = @_;
2488
2489 my $env = $self->provision_s4member($path, $dc_vars, "s4member_dflt",
2490 "winbind use default domain = yes");
2491
2492 if (defined $env) {
2493 if (not defined($self->check_or_start($env, "standard"))) {
2494 return undef;
2495 }
2496 }
2497
2498 return $env;
2499 }
2500
2501 sub setup_rpc_proxy
2502 {
2503 my ($self, $path, $dc_vars) = @_;
2504
2505 my $env = $self->provision_rpc_proxy($path, $dc_vars);
2506
2507 if (defined $env) {
2508 if (not defined($self->check_or_start($env, "standard"))) {
2509 return undef;
2510 }
2511 }
2512 return $env;
2513 }
2514
2515 sub setup_ad_dc_ntvfs
2516 {
2517 my ($self, $path) = @_;
2518
2519 my $env = $self->provision_ad_dc_ntvfs($path, undef);
2520 if (defined $env) {
2521 if (not defined($self->check_or_start($env, "standard"))) {
2522 warn("Failed to start ad_dc_ntvfs");
2523 return undef;
2524 }
2525 }
2526 return $env;
2527 }
2528
2529 sub setup_chgdcpass
2530 {
2531 my ($self, $path) = @_;
2532
2533 my $env = $self->provision_chgdcpass($path);
2534 if (defined $env) {
2535 if (not defined($self->check_or_start($env, "standard"))) {
2536 return undef;
2537 }
2538 }
2539 return $env;
2540 }
2541
2542 sub setup_fl2000dc
2543 {
2544 my ($self, $path, $dc_vars) = @_;
2545
2546 my $env = $self->provision_fl2000dc($path);
2547 if (defined $env) {
2548 if (not defined($self->check_or_start($env, "standard"))) {
2549 return undef;
2550 }
2551
2552 $env = $self->setup_trust($env, $dc_vars, "external", "--no-aes-keys --direction=outgoing");
2553 }
2554
2555 return $env;
2556 }
2557
2558 sub setup_fl2003dc
2559 {
2560 my ($self, $path, $dc_vars) = @_;
2561
2562 my $env = $self->provision_fl2003dc($path);
2563
2564 if (defined $env) {
2565 if (not defined($self->check_or_start($env, "standard"))) {
2566 return undef;
2567 }
2568
2569 $env = $self->setup_trust($env, $dc_vars, "external", "--no-aes-keys");
2570 }
2571 return $env;
2572 }
2573
2574 sub setup_fl2008r2dc
2575 {
2576 my ($self, $path, $ad_dc_vars, $nt4_dc_vars) = @_;
2577
2578 my $env = $self->provision_fl2008r2dc($path);
2579
2580 if (!defined $env) {
2581 return $env;
2582 }
2583
2584 if (not defined($self->check_or_start($env, "standard"))) {
2585 return undef;
2586 }
2587
2588 my $upn_array = ["$env->{REALM}.upn"];
2589 my $spn_array = ["$env->{REALM}.spn"];
2590
2591 if ($self->setup_namespaces($env, $upn_array, $spn_array) != 0) {
2592 return undef;
2593 }
2594
2595 $env = $self->setup_trust($env, $ad_dc_vars, "forest", "");
2596 if (!defined $env) {
2597 return undef;
2598 }
2599
2600 my $net = Samba::bindir_path($self, "net");
2601 my $smbcontrol = Samba::bindir_path($self, "smbcontrol");
2602
2603 my $trustpw = "TrUsTpW";
2604 $trustpw .= "$env->{SOCKET_WRAPPER_DEFAULT_IFACE}";
2605 $trustpw .= "$nt4_dc_vars->{SOCKET_WRAPPER_DEFAULT_IFACE}";
2606
2607 my $cmd_env = $self->get_cmd_env_vars($env);
2608 my $cmd = $cmd_env;
2609 $cmd .= "$net rpc trust create ";
2610 $cmd .= "otherdomainsid=$nt4_dc_vars->{SAMSID} ";
2611 $cmd .= "otherdomain=$nt4_dc_vars->{DOMAIN} ";
2612 $cmd .= "other_netbios_domain=$nt4_dc_vars->{DOMAIN} ";
2613 $cmd .= "trustpw=$trustpw ";
2614 $cmd .= "$env->{CONFIGURATION} ";
2615 $cmd .= "-U $env->{DOMAIN}/$env->{USERNAME}\%$env->{PASSWORD} ";
2616
2617 if (system($cmd) != 0) {
2618 warn("net rpc trust create failed\n$cmd");
2619 return undef;
2620 }
2621
2622 my $nt4_cmd_env = $self->get_cmd_env_vars($nt4_dc_vars);
2623 $cmd = $nt4_cmd_env;
2624 $cmd .= "$net rpc trustdom establish $env->{DOMAIN} -U/%$trustpw $nt4_dc_vars->{CONFIGURATION}";
2625
2626 if (system($cmd) != 0) {
2627 warn("add failed\n$cmd");
2628 return undef;
2629 }
2630
2631 # Reload trusts
2632 $cmd = $nt4_cmd_env;
2633 $cmd .= "$smbcontrol winbindd reload-config $nt4_dc_vars->{CONFIGURATION}";
2634
2635 if (system($cmd) != 0) {
2636 warn("add failed\n$cmd");
2637 return undef;
2638 }
2639
2640 $env->{NT4_TRUST_SERVER} = $nt4_dc_vars->{SERVER};
2641 $env->{NT4_TRUST_SERVER_IP} = $nt4_dc_vars->{SERVER_IP};
2642 $env->{NT4_TRUST_DOMAIN} = $nt4_dc_vars->{DOMAIN};
2643 $env->{NT4_TRUST_DOMSID} = $nt4_dc_vars->{DOMSID};
2644
2645 return $env;
2646 }
2647
2648 sub setup_vampire_dc
2649 {
2650 return setup_generic_vampire_dc(@_, "2008");
2651 }
2652
2653 sub setup_vampire_2000_dc
2654 {
2655 return setup_generic_vampire_dc(@_, "2000");
2656 }
2657
2658 sub setup_generic_vampire_dc
2659 {
2660 my ($self, $path, $dc_vars, $fl) = @_;
2661
2662 my $env = $self->provision_vampire_dc($path, $dc_vars, $fl);
2663
2664 if (defined $env) {
2665 if (not defined($self->check_or_start($env, "single"))) {
2666 return undef;
2667 }
2668
2669 # force replicated DC to update repsTo/repsFrom
2670 # for vampired partitions
2671 my $samba_tool = Samba::bindir_path($self, "samba-tool");
2672
2673 # as 'vampired' dc may add data in its local replica
2674 # we need to synchronize data between DCs
2675 my $base_dn = "DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
2676 my $cmd = $self->get_cmd_env_vars($env);
2677 $cmd .= " $samba_tool drs replicate $env->{DC_SERVER} $env->{SERVER}";
2678 $cmd .= " $dc_vars->{CONFIGURATION}";
2679 $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
2680 # replicate Configuration NC
2681 my $cmd_repl = "$cmd \"CN=Configuration,$base_dn\"";
2682 unless(system($cmd_repl) == 0) {
2683 warn("Failed to replicate\n$cmd_repl");
2684 return undef;
2685 }
2686 # replicate Default NC
2687 $cmd_repl = "$cmd \"$base_dn\"";
2688 unless(system($cmd_repl) == 0) {
2689 warn("Failed to replicate\n$cmd_repl");
2690 return undef;
2691 }
2692
2693 # Pull in a full set of changes from the main DC
2694 $base_dn = "DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
2695 $cmd = $self->get_cmd_env_vars($env);
2696 $cmd .= " $samba_tool drs replicate $env->{SERVER} $env->{DC_SERVER}";
2697 $cmd .= " $dc_vars->{CONFIGURATION}";
2698 $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
2699 # replicate Configuration NC
2700 $cmd_repl = "$cmd \"CN=Configuration,$base_dn\"";
2701 unless(system($cmd_repl) == 0) {
2702 warn("Failed to replicate\n$cmd_repl");
2703 return undef;
2704 }
2705 # replicate Default NC
2706 $cmd_repl = "$cmd \"$base_dn\"";
2707 unless(system($cmd_repl) == 0) {
2708 warn("Failed to replicate\n$cmd_repl");
2709 return undef;
2710 }
2711 }
2712
2713 return $env;
2714 }
2715
2716 sub setup_promoted_dc
2717 {
2718 my ($self, $path, $dc_vars) = @_;
2719
2720 my $env = $self->provision_promoted_dc($path, $dc_vars);
2721
2722 if (defined $env) {
2723 if (not defined($self->check_or_start($env, "single"))) {
2724 return undef;
2725 }
2726
2727 # force source and replicated DC to update repsTo/repsFrom
2728 # for vampired partitions
2729 my $samba_tool = Samba::bindir_path($self, "samba-tool");
2730 my $cmd = $self->get_cmd_env_vars($env);
2731 # as 'vampired' dc may add data in its local replica
2732 # we need to synchronize data between DCs
2733 my $base_dn = "DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
2734 $cmd .= " $samba_tool drs replicate $env->{DC_SERVER} $env->{SERVER}";
2735 $cmd .= " $dc_vars->{CONFIGURATION}";
2736 $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
2737 # replicate Configuration NC
2738 my $cmd_repl = "$cmd \"CN=Configuration,$base_dn\"";
2739 unless(system($cmd_repl) == 0) {
2740 warn("Failed to replicate\n$cmd_repl");
2741 return undef;
2742 }
2743 # replicate Default NC
2744 $cmd_repl = "$cmd \"$base_dn\"";
2745 unless(system($cmd_repl) == 0) {
2746 warn("Failed to replicate\n$cmd_repl");
2747 return undef;
2748 }
2749 }
2750
2751 return $env;
2752 }
2753
2754 sub setup_rodc
2755 {
2756 my ($self, $path, $dc_vars) = @_;
2757
2758 my $env = $self->provision_rodc($path, $dc_vars);
2759
2760 unless ($env) {
2761 return undef;
2762 }
2763
2764 if (not defined($self->check_or_start($env, "standard"))) {
2765 return undef;
2766 }
2767
2768 my $samba_tool = Samba::bindir_path($self, "samba-tool");
2769 my $cmd = $self->get_cmd_env_vars($env);
2770
2771 my $base_dn = "DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
2772 $cmd .= " $samba_tool drs replicate $env->{SERVER} $env->{DC_SERVER}";
2773 $cmd .= " $dc_vars->{CONFIGURATION}";
2774 $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
2775 # replicate Configuration NC
2776 my $cmd_repl = "$cmd \"CN=Configuration,$base_dn\"";
2777 unless(system($cmd_repl) == 0) {
2778 warn("Failed to replicate\n$cmd_repl");
2779 return undef;
2780 }
2781 # replicate Default NC
2782 $cmd_repl = "$cmd \"$base_dn\"";
2783 unless(system($cmd_repl) == 0) {
2784 warn("Failed to replicate\n$cmd_repl");
2785 return undef;
2786 }
2787
2788 return $env;
2789 }
2790
2791 sub _setup_ad_dc
2792 {
2793 my ($self, $path, $conf_opts, $server, $dom, $functional_level) = @_;
2794
2795 # If we didn't build with ADS, pretend this env was never available
2796 if (not $self->{target3}->have_ads()) {
2797 return "UNKNOWN";
2798 }
2799
2800 if (!defined($conf_opts)) {
2801 $conf_opts = "";
2802 }
2803 if (!defined($server)) {
2804 $server = "addc";
2805 }
2806 if (!defined($dom)) {
2807 $dom = "addom.samba.example.com";
2808 }
2809 my $env = $self->provision_ad_dc($path, $server, "ADDOMAIN",
2810 $dom,
2811 undef,
2812 $conf_opts,
2813 undef,
2814 $functional_level);
2815 unless ($env) {
2816 return undef;
2817 }
2818
2819 if (not defined($self->check_or_start($env, "prefork"))) {
2820 return undef;
2821 }
2822
2823 my $upn_array = ["$env->{REALM}.upn"];
2824 my $spn_array = ["$env->{REALM}.spn"];
2825
2826 if ($self->setup_namespaces($env, $upn_array, $spn_array) != 0) {
2827 return undef;
2828 }
2829
2830 return $env;
2831 }
2832
2833 sub setup_ad_dc
2834 {
2835 my ($self, $path) = @_;
2836 return _setup_ad_dc($self, $path, undef, undef, undef);
2837 }
2838
2839 sub setup_ad_dc_smb1
2840 {
2841 my ($self, $path) = @_;
2842 my $conf_opts = "
2843 [global]
2844 client min protocol = CORE
2845 server min protocol = LANMAN1
2846
2847 # needed for 'samba.tests.auth_log' tests
2848 server require schannel:ADDCSMB1\$ = no
2849 server schannel require seal:ADDCSMB1\$ = no
2850 ";
2851 return _setup_ad_dc($self, $path, $conf_opts, "addcsmb1", "addom2.samba.example.com");
2852 }
2853
2854 sub setup_ad_dc_smb1_done
2855 {
2856 my ($self, $path, $dep_env) = @_;
2857 return $self->return_alias_env($path, $dep_env);
2858 }
2859
2860 sub setup_ad_dc_no_nss
2861 {
2862 my ($self, $path) = @_;
2863
2864 # If we didn't build with ADS, pretend this env was never available
2865 if (not $self->{target3}->have_ads()) {
2866 return "UNKNOWN";
2867 }
2868
2869 my $env = $self->provision_ad_dc($path,
2870 "addc_no_nss",
2871 "ADNONSSDOMAIN",
2872 "adnonssdom.samba.example.com",
2873 undef,
2874 "",
2875 undef);
2876 unless ($env) {
2877 return undef;
2878 }
2879
2880 $env->{NSS_WRAPPER_MODULE_SO_PATH} = undef;
2881 $env->{NSS_WRAPPER_MODULE_FN_PREFIX} = undef;
2882
2883 if (not defined($self->check_or_start($env, "single"))) {
2884 return undef;
2885 }
2886
2887 my $upn_array = ["$env->{REALM}.upn"];
2888 my $spn_array = ["$env->{REALM}.spn"];
2889
2890 if ($self->setup_namespaces($env, $upn_array, $spn_array) != 0) {
2891 return undef;
2892 }
2893
2894 return $env;
2895 }
2896
2897 sub setup_ad_dc_no_ntlm
2898 {
2899 my ($self, $path) = @_;
2900
2901 # If we didn't build with ADS, pretend this env was never available
2902 if (not $self->{target3}->have_ads()) {
2903 return "UNKNOWN";
2904 }
2905
2906 my $env = $self->provision_ad_dc($path,
2907 "addc_no_ntlm",
2908 "ADNONTLMDOMAIN",
2909 "adnontlmdom.samba.example.com",
2910 undef,
2911 "ntlm auth = disabled\nnt hash store = never",
2912 undef);
2913 unless ($env) {
2914 return undef;
2915 }
2916
2917 if (not defined($self->check_or_start($env, "prefork"))) {
2918 return undef;
2919 }
2920
2921 my $upn_array = ["$env->{REALM}.upn"];
2922 my $spn_array = ["$env->{REALM}.spn"];
2923
2924 if ($self->setup_namespaces($env, $upn_array, $spn_array) != 0) {
2925 return undef;
2926 }
2927
2928 return $env;
2929 }
2930
2931 sub setup_ad_dc_fips
2932 {
2933 my ($self, $path) = @_;
2934
2935 # If we didn't build with ADS, pretend this env was never available
2936 if (not $self->{target3}->have_ads()) {
2937 return "UNKNOWN";
2938 }
2939
2940 my $env = $self->provision_ad_dc($path,
2941 "fipsdc",
2942 "FIPSDOMAIN",
2943 "fips.samba.example.com",
2944 1,
2945 "",
2946 undef);
2947 unless ($env) {
2948 return undef;
2949 }
2950
2951 if (not defined($self->check_or_start($env, "prefork"))) {
2952 return undef;
2953 }
2954
2955 my $upn_array = ["$env->{REALM}.upn"];
2956 my $spn_array = ["$env->{REALM}.spn"];
2957
2958 if ($self->setup_namespaces($env, $upn_array, $spn_array) != 0) {
2959 return undef;
2960 }
2961
2962 return $env;
2963 }
2964
2965 #
2966 # AD DC test environment used solely to test pre-fork process restarts.
2967 # As processes get killed off and restarted it should not be used for other
2968 sub setup_preforkrestartdc
2969 {
2970 my ($self, $path) = @_;
2971
2972 # If we didn't build with ADS, pretend this env was never available
2973 if (not $self->{target3}->have_ads()) {
2974 return "UNKNOWN";
2975 }
2976
2977 # note DC name must be <= 15 chars so we use 'prockill' instead of
2978 # 'preforkrestart'
2979 my $env = $self->provision_ad_dc($path,
2980 "prockilldc",
2981 "PROCKILLDOMAIN",
2982 "prockilldom.samba.example.com",
2983 undef,
2984 "prefork backoff increment = 5\nprefork maximum backoff=10",
2985 undef);
2986 unless ($env) {
2987 return undef;
2988 }
2989
2990 # We treat processes in this environment cruelly, sometimes
2991 # sending them SIGSEGV signals. We don't need gdb_backtrace
2992 # dissecting these fake crashes in precise detail.
2993 $env->{PLEASE_NO_GDB_BACKTRACE} = '1';
2994
2995 $env->{NSS_WRAPPER_MODULE_SO_PATH} = undef;
2996 $env->{NSS_WRAPPER_MODULE_FN_PREFIX} = undef;
2997
2998 if (not defined($self->check_or_start($env, "prefork"))) {
2999 return undef;
3000 }
3001
3002 my $upn_array = ["$env->{REALM}.upn"];
3003 my $spn_array = ["$env->{REALM}.spn"];
3004
3005 if ($self->setup_namespaces($env, $upn_array, $spn_array) != 0) {
3006 return undef;
3007 }
3008
3009 return $env;
3010 }
3011
3012 #
3013 # ad_dc test environment used solely to test standard process model connection
3014 # process limits. As the limit is set artificially low it should not be used
3015 # for other tests.
3016 sub setup_proclimitdc
3017 {
3018 my ($self, $path) = @_;
3019
3020 # If we didn't build with ADS, pretend this env was never available
3021 if (not $self->{target3}->have_ads()) {
3022 return "UNKNOWN";
3023 }
3024
3025 my $env = $self->provision_ad_dc($path,
3026 "proclimitdc",
3027 "PROCLIMITDOM",
3028 "proclimit.samba.example.com",
3029 undef,
3030 "max smbd processes = 20",
3031 undef);
3032 unless ($env) {
3033 return undef;
3034 }
3035
3036 $env->{NSS_WRAPPER_MODULE_SO_PATH} = undef;
3037 $env->{NSS_WRAPPER_MODULE_FN_PREFIX} = undef;
3038
3039 if (not defined($self->check_or_start($env, "standard"))) {
3040 return undef;
3041 }
3042
3043 my $upn_array = ["$env->{REALM}.upn"];
3044 my $spn_array = ["$env->{REALM}.spn"];
3045
3046 if ($self->setup_namespaces($env, $upn_array, $spn_array) != 0) {
3047 return undef;
3048 }
3049
3050 return $env;
3051 }
3052
3053 # Used to test a live upgrade of the schema on a 2 DC network.
3054 sub setup_schema_dc
3055 {
3056 my ($self, $path) = @_;
3057
3058 # provision the PDC using an older base schema
3059 my $provision_args = ["--base-schema=2008_R2", "--backend-store=$self->{default_ldb_backend}"];
3060
3061 # We set the functional level to 2008_R2 to match the older
3062 # base-schema (to allow schema upgrade to be tested)
3063 my $env = $self->provision_ad_dc($path,
3064 "liveupgrade1dc",
3065 "SCHEMADOMAIN",
3066 "schema.samba.example.com",
3067 undef,
3068 "drs: max link sync = 2",
3069 $provision_args,
3070 "2008_R2");
3071 unless ($env) {
3072 return undef;
3073 }
3074
3075 if (not defined($self->check_or_start($env, "prefork"))) {
3076 return undef;
3077 }
3078
3079 my $upn_array = ["$env->{REALM}.upn"];
3080 my $spn_array = ["$env->{REALM}.spn"];
3081
3082 if ($self->setup_namespaces($env, $upn_array, $spn_array) != 0) {
3083 return undef;
3084 }
3085
3086 return $env;
3087 }
3088
3089 # the second DC in the live schema upgrade pair
3090 sub setup_schema_pair_dc
3091 {
3092 # note: dcvars contains the env info for the dependent testenv ('schema_dc')
3093 my ($self, $prefix, $dcvars) = @_;
3094 print "Preparing SCHEMA UPGRADE PAIR DC...\n";
3095
3096 my ($env, $ctx) = $self->prepare_dc_testenv($prefix, "liveupgrade2dc",
3097 $dcvars->{DOMAIN},
3098 $dcvars->{REALM},
3099 $dcvars->{PASSWORD},
3100 "");
3101
3102 my $samba_tool = Samba::bindir_path($self, "samba-tool");
3103 my $cmd_vars = $self->get_cmd_env_vars($env);
3104
3105 my $join_cmd = $cmd_vars;
3106 $join_cmd .= "$samba_tool domain join $env->{CONFIGURATION} $dcvars->{REALM} DC --realm=$dcvars->{REALM}";
3107 $join_cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD} ";
3108 $join_cmd .= " --backend-store=$self->{default_ldb_backend}";
3109
3110 my $upgrade_cmd = $cmd_vars;
3111 $upgrade_cmd .= "$samba_tool domain schemaupgrade $dcvars->{CONFIGURATION}";
3112 $upgrade_cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
3113
3114 my $repl_cmd = $cmd_vars;
3115 $repl_cmd .= "$samba_tool drs replicate $env->{SERVER} $dcvars->{SERVER}";
3116 $repl_cmd .= " CN=Schema,CN=Configuration,DC=schema,DC=samba,DC=example,DC=com";
3117 $repl_cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
3118
3119 unless (system($join_cmd) == 0) {
3120 warn("Join failed\n$join_cmd");
3121 return undef;
3122 }
3123
3124 $env->{DC_SERVER} = $dcvars->{SERVER};
3125 $env->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
3126 $env->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
3127 $env->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
3128
3129 # start samba for the new DC
3130 if (not defined($self->check_or_start($env, "standard"))) {
3131 return undef;
3132 }
3133
3134 unless (system($upgrade_cmd) == 0) {
3135 warn("Schema upgrade failed\n$upgrade_cmd");
3136 return undef;
3137 }
3138
3139 unless (system($repl_cmd) == 0) {
3140 warn("Post-update schema replication failed\n$repl_cmd");
3141 return undef;
3142 }
3143
3144 return $env;
3145 }
3146
3147 # Sets up a DC that's solely used to do a domain backup from. We then use the
3148 # backupfrom-DC to create the restore-DC - this proves that the backup/restore
3149 # process will create a Samba DC that will actually start up.
3150 # We don't use the backup-DC for anything else because its domain will conflict
3151 # with the restore DC.
3152 sub setup_backupfromdc
3153 {
3154 my ($self, $path) = @_;
3155
3156 # If we didn't build with ADS, pretend this env was never available
3157 if (not $self->{target3}->have_ads()) {
3158 return "UNKNOWN";
3159 }
3160
3161 my $provision_args = ["--site=Backup-Site"];
3162
3163 my $env = $self->provision_ad_dc($path,
3164 "backupfromdc",
3165 "BACKUPDOMAIN",
3166 "backupdom.samba.example.com",
3167 undef,
3168 "samba kcc command = /bin/true",
3169 $provision_args);
3170 unless ($env) {
3171 return undef;
3172 }
3173
3174 if (not defined($self->check_or_start($env))) {
3175 return undef;
3176 }
3177
3178 my $upn_array = ["$env->{REALM}.upn"];
3179 my $spn_array = ["$env->{REALM}.spn"];
3180
3181 if ($self->setup_namespaces($env, $upn_array, $spn_array) != 0) {
3182 return undef;
3183 }
3184
3185 # Set up a dangling forward link to an expunged object
3186 #
3187 # We need this to ensure that the "samba-tool domain backup rename"
3188 # that is part of the creation of the labdc environment can
3189 # cope with this situation on the source DC.
3190
3191 if (not $self->write_ldb_file("$env->{PRIVATEDIR}/sam.ldb", "
3192 dn: ou=linktest,dc=backupdom,dc=samba,dc=example,dc=com
3193 objectclass: organizationalUnit
3194 -
3195
3196 dn: cn=linkto,ou=linktest,dc=backupdom,dc=samba,dc=example,dc=com
3197 objectclass: msExchConfigurationContainer
3198 -
3199
3200 dn: cn=linkfrom,ou=linktest,dc=backupdom,dc=samba,dc=example,dc=com
3201 objectclass: msExchConfigurationContainer
3202 addressBookRoots: cn=linkto,ou=linktest,dc=backupdom,dc=samba,dc=example,dc=com
3203 -
3204
3205 ")) {
3206 return undef;
3207 }
3208 my $ldbdel = Samba::bindir_path($self, "ldbdel");
3209 my $cmd = "$ldbdel -H $env->{PRIVATEDIR}/sam.ldb cn=linkto,ou=linktest,dc=backupdom,dc=samba,dc=example,dc=com";
3210
3211 unless(system($cmd) == 0) {
3212 warn("Failed to delete link target: \n$cmd");
3213 return undef;
3214 }
3215
3216 # Expunge will ensure that linkto is totally wiped from the DB
3217 my $samba_tool = Samba::bindir_path($self, "samba-tool");
3218 $cmd = "$samba_tool domain tombstones expunge --tombstone-lifetime=0 $env->{CONFIGURATION}";
3219
3220 unless(system($cmd) == 0) {
3221 warn("Failed to expunge link target: \n$cmd");
3222 return undef;
3223 }
3224 return $env;
3225 }
3226
3227 # returns the server/user-auth params needed to run an online backup cmd
3228 sub get_backup_server_args
3229 {
3230 # dcvars contains the env info for the backup DC testenv
3231 my ($self, $dcvars) = @_;
3232 my $server = $dcvars->{DC_SERVER_IP};
3233 my $server_args = "--server=$server ";
3234 $server_args .= "-U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
3235 $server_args .= " $dcvars->{CONFIGURATION}";
3236
3237 return $server_args;
3238 }
3239
3240 # Creates a backup of a running testenv DC
3241 sub create_backup
3242 {
3243 # note: dcvars contains the env info for the backup DC testenv
3244 my ($self, $env, $dcvars, $backupdir, $backup_cmd) = @_;
3245
3246 # get all the env variables we pass in with the samba-tool command
3247 # Note: use the backupfrom-DC's krb5.conf to do the backup
3248 my $overwrite = undef;
3249 $overwrite->{KRB5_CONFIG} = $dcvars->{KRB5_CONFIG};
3250 my $cmd_env = $self->get_cmd_env_vars($env, $overwrite);
3251
3252 # use samba-tool to create a backup from the 'backupfromdc' DC
3253 my $cmd = "";
3254 my $samba_tool = Samba::bindir_path($self, "samba-tool");
3255
3256 $cmd .= "$cmd_env $samba_tool domain backup $backup_cmd";
3257 $cmd .= " --targetdir=$backupdir";
3258
3259 print "Executing: $cmd\n";
3260 unless(system($cmd) == 0) {
3261 warn("Failed to create backup using: \n$cmd");
3262 return undef;
3263 }
3264
3265 # get the name of the backup file created
3266 opendir(DIR, $backupdir);
3267 my @files = grep(/\.tar/, readdir(DIR));
3268 closedir(DIR);
3269
3270 if(scalar @files != 1) {
3271 warn("Backup file not found in directory $backupdir\n");
3272 return undef;
3273 }
3274 my $backup_file = "$backupdir/$files[0]";
3275 print "Using backup file $backup_file...\n";
3276
3277 return $backup_file;
3278 }
3279
3280 # Restores a backup-file to populate a testenv for a new DC
3281 sub restore_backup_file
3282 {
3283 my ($self, $backup_file, $restore_opts, $restoredir, $smbconf) = @_;
3284
3285 # pass the restore command the testenv's smb.conf that we've already
3286 # generated. But move it to a temp-dir first, so that the restore doesn't
3287 # overwrite it
3288 my $tmpdir = File::Temp->newdir();
3289 my $tmpconf = "$tmpdir/smb.conf";
3290 my $cmd = "cp $smbconf $tmpconf";
3291 unless(system($cmd) == 0) {
3292 warn("Failed to backup smb.conf using: \n$cmd");
3293 return -1;
3294 }
3295
3296 my $samba_tool = Samba::bindir_path($self, "samba-tool");
3297 $cmd = "$samba_tool domain backup restore --backup-file=$backup_file";
3298 $cmd .= " --targetdir=$restoredir $restore_opts --configfile=$tmpconf";
3299
3300 print "Executing: $cmd\n";
3301 unless(system($cmd) == 0) {
3302 warn("Failed to restore backup using: \n$cmd");
3303 return -1;
3304 }
3305
3306 print "Restore complete\n";
3307 return 0
3308 }
3309
3310 # sets up the initial directory and returns the new testenv's env info
3311 # (without actually doing a 'domain join')
3312 sub prepare_dc_testenv
3313 {
3314 my ($self, $prefix, $dcname, $domain, $realm,
3315 $password, $conf_options, $dnsupdate_options) = @_;
3316
3317 my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
3318 $dcname,
3319 $domain,
3320 $realm,
3321 undef,
3322 "2008",
3323 $password,
3324 undef,
3325 undef);
3326
3327 # the restore uses a slightly different state-dir location to other testenvs
3328 $ctx->{statedir} = "$ctx->{prefix_abs}/state";
3329 push(@{$ctx->{directories}}, "$ctx->{statedir}");
3330
3331 # add support for sysvol/netlogon/tmp shares
3332 $ctx->{share} = "$ctx->{prefix_abs}/share";
3333 push(@{$ctx->{directories}}, "$ctx->{share}");
3334 push(@{$ctx->{directories}}, "$ctx->{share}/test1");
3335
3336 if (defined($dnsupdate_options)) {
3337 $ctx->{samba_dnsupdate} .= $dnsupdate_options;
3338 }
3339
3340 $ctx->{smb_conf_extra_options} = "
3341 $conf_options
3342
3343 # Some of the DCs based on this will be in FL 2016 domains, so
3344 # claim FL 2016 DC capability
3345 ad dc functional level = 2016
3346
3347 max xmit = 32K
3348 server max protocol = SMB2
3349 samba kcc command = /bin/true
3350 xattr_tdb:file = $ctx->{statedir}/xattr.tdb
3351
3352 [sysvol]
3353 path = $ctx->{statedir}/sysvol
3354 read only = no
3355
3356 [netlogon]
3357 path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
3358 read only = no
3359
3360 [tmp]
3361 path = $ctx->{share}
3362 read only = no
3363 posix:sharedelay = 10000
3364 posix:oplocktimeout = 3
3365 posix:writetimeupdatedelay = 50000
3366
3367 [test1]
3368 path = $ctx->{share}/test1
3369 read only = no
3370 posix:sharedelay = 100000
3371 posix:oplocktimeout = 3
3372 posix:writetimeupdatedelay = 500000
3373 ";
3374
3375 my $env = $self->provision_raw_step1($ctx);
3376
3377 return ($env, $ctx);
3378 }
3379
3380
3381 # Set up a DC testenv solely by using the samba-tool domain backup/restore
3382 # commands. This proves that we can backup an online DC ('backupfromdc') and
3383 # use the backup file to create a valid, working samba DC.
3384 sub setup_restoredc
3385 {
3386 # note: dcvars contains the env info for the dependent testenv ('backupfromdc')
3387 my ($self, $prefix, $dcvars) = @_;
3388 print "Preparing RESTORE DC...\n";
3389
3390 # we arbitrarily designate the restored DC as having SMBv1 disabled
3391 my $extra_conf = "
3392 server min protocol = SMB2
3393 client min protocol = SMB2
3394 prefork children = 1";
3395 my $dnsupdate_options = " --use-samba-tool --no-credentials";
3396
3397 my ($env, $ctx) = $self->prepare_dc_testenv($prefix, "restoredc",
3398 $dcvars->{DOMAIN},
3399 $dcvars->{REALM},
3400 $dcvars->{PASSWORD},
3401 $extra_conf,
3402 $dnsupdate_options);
3403
3404 # create a backup of the 'backupfromdc'
3405 my $backupdir = File::Temp->newdir();
3406 my $server_args = $self->get_backup_server_args($dcvars);
3407 my $backup_args = "online $server_args";
3408 my $backup_file = $self->create_backup($env, $dcvars, $backupdir,
3409 $backup_args);
3410 unless($backup_file) {
3411 return undef;
3412 }
3413
3414 # restore the backup file to populate the restore-DC testenv
3415 my $restore_dir = abs_path($prefix);
3416 my $ret = $self->restore_backup_file($backup_file,
3417 "--newservername=$env->{SERVER}",
3418 $restore_dir, $env->{SERVERCONFFILE});
3419 unless ($ret == 0) {
3420 return undef;
3421 }
3422
3423 #
3424 # As we create the same domain as a clone
3425 # we need a separate resolv.conf!
3426 #
3427 $ctx->{resolv_conf} = "$ctx->{etcdir}/resolv.conf";
3428 $ctx->{dns_ipv4} = $ctx->{ipv4};
3429 $ctx->{dns_ipv6} = $ctx->{ipv6};
3430 Samba::mk_resolv_conf($ctx);
3431 $env->{RESOLV_CONF} = $ctx->{resolv_conf};
3432
3433 # start samba for the restored DC
3434 if (not defined($self->check_or_start($env))) {
3435 return undef;
3436 }
3437
3438 return $env;
3439 }
3440
3441 # Set up a DC testenv solely by using the 'samba-tool domain backup rename' and
3442 # restore commands. This proves that we can backup and rename an online DC
3443 # ('backupfromdc') and use the backup file to create a valid, working samba DC.
3444 sub setup_renamedc
3445 {
3446 # note: dcvars contains the env info for the dependent testenv ('backupfromdc')
3447 my ($self, $prefix, $dcvars) = @_;
3448 print "Preparing RENAME DC...\n";
3449 my $extra_conf = "prefork children = 1";
3450
3451 my $realm = "renamedom.samba.example.com";
3452 my ($env, $ctx) = $self->prepare_dc_testenv($prefix, "renamedc",
3453 "RENAMEDOMAIN", $realm,
3454 $dcvars->{PASSWORD}, $extra_conf);
3455
3456 # create a backup of the 'backupfromdc' which renames the domain
3457 my $backupdir = File::Temp->newdir();
3458 my $server_args = $self->get_backup_server_args($dcvars);
3459 my $backup_args = "rename $env->{DOMAIN} $env->{REALM} $server_args";
3460 $backup_args .= " --backend-store=tdb";
3461 my $backup_file = $self->create_backup($env, $dcvars, $backupdir,
3462 $backup_args);
3463 unless($backup_file) {
3464 return undef;
3465 }
3466
3467 # restore the backup file to populate the rename-DC testenv
3468 my $restore_dir = abs_path($prefix);
3469 my $restore_opts = "--newservername=$env->{SERVER} --host-ip=$env->{SERVER_IP}";
3470 my $ret = $self->restore_backup_file($backup_file, $restore_opts,
3471 $restore_dir, $env->{SERVERCONFFILE});
3472 unless ($ret == 0) {
3473 return undef;
3474 }
3475
3476 # start samba for the restored DC
3477 if (not defined($self->check_or_start($env))) {
3478 return undef;
3479 }
3480
3481 my $upn_array = ["$env->{REALM}.upn"];
3482 my $spn_array = ["$env->{REALM}.spn"];
3483
3484 if ($self->setup_namespaces($env, $upn_array, $spn_array) != 0) {
3485 return undef;
3486 }
3487
3488 return $env;
3489 }
3490
3491 # Set up a DC testenv solely by using the 'samba-tool domain backup offline' and
3492 # restore commands. This proves that we do an offline backup of a local DC
3493 # ('backupfromdc') and use the backup file to create a valid, working samba DC.
3494 sub setup_offlinebackupdc
3495 {
3496 # note: dcvars contains the env info for the dependent testenv ('backupfromdc')
3497 my ($self, $prefix, $dcvars) = @_;
3498 print "Preparing OFFLINE BACKUP DC...\n";
3499 my $extra_conf = "prefork children = 1";
3500 my $dnsupdate_options = " --use-samba-tool --no-credentials";
3501
3502 my ($env, $ctx) = $self->prepare_dc_testenv($prefix, "offlinebackupdc",
3503 $dcvars->{DOMAIN},
3504 $dcvars->{REALM},
3505 $dcvars->{PASSWORD},
3506 $extra_conf,
3507 $dnsupdate_options);
3508
3509 # create an offline backup of the 'backupfromdc' target
3510 my $backupdir = File::Temp->newdir();
3511 my $cmd = "offline --configfile $dcvars->{SERVERCONFFILE}";
3512 my $backup_file = $self->create_backup($env, $dcvars,
3513 $backupdir, $cmd);
3514
3515 unless($backup_file) {
3516 return undef;
3517 }
3518
3519 # restore the backup file to populate the rename-DC testenv
3520 my $restore_dir = abs_path($prefix);
3521 my $restore_opts = "--newservername=$env->{SERVER} --host-ip=$env->{SERVER_IP}";
3522 my $ret = $self->restore_backup_file($backup_file, $restore_opts,
3523 $restore_dir, $env->{SERVERCONFFILE});
3524 unless ($ret == 0) {
3525 return undef;
3526 }
3527
3528 #
3529 # As we create the same domain as a clone
3530 # we need a separate resolv.conf!
3531 #
3532 $ctx->{resolv_conf} = "$ctx->{etcdir}/resolv.conf";
3533 $ctx->{dns_ipv4} = $ctx->{ipv4};
3534 $ctx->{dns_ipv6} = $ctx->{ipv6};
3535 Samba::mk_resolv_conf($ctx);
3536 $env->{RESOLV_CONF} = $ctx->{resolv_conf};
3537
3538 # re-create the testenv's krb5.conf (the restore may have overwritten it)
3539 Samba::mk_krb5_conf($ctx);
3540
3541 # start samba for the restored DC
3542 if (not defined($self->check_or_start($env))) {
3543 return undef;
3544 }
3545
3546 return $env;
3547 }
3548
3549 # Set up a DC testenv solely by using the samba-tool 'domain backup rename' and
3550 # restore commands, using the --no-secrets option. This proves that we can
3551 # create a realistic lab environment from an online DC ('backupfromdc').
3552 sub setup_labdc
3553 {
3554 # note: dcvars contains the env info for the dependent testenv ('backupfromdc')
3555 my ($self, $prefix, $dcvars) = @_;
3556 print "Preparing LAB-DOMAIN DC...\n";
3557 my $extra_conf = "prefork children = 1";
3558
3559 my ($env, $ctx) = $self->prepare_dc_testenv($prefix, "labdc",
3560 "LABDOMAIN",
3561 "labdom.samba.example.com",
3562 $dcvars->{PASSWORD}, $extra_conf);
3563
3564 # create a backup of the 'backupfromdc' which renames the domain and uses
3565 # the --no-secrets option to scrub any sensitive info
3566 my $backupdir = File::Temp->newdir();
3567 my $server_args = $self->get_backup_server_args($dcvars);
3568 my $backup_args = "rename $env->{DOMAIN} $env->{REALM} $server_args";
3569 $backup_args .= " --no-secrets --backend-store=$self->{default_ldb_backend}";
3570 my $backup_file = $self->create_backup($env, $dcvars, $backupdir,
3571 $backup_args);
3572 unless($backup_file) {
3573 return undef;
3574 }
3575
3576 # restore the backup file to populate the lab-DC testenv
3577 my $restore_dir = abs_path($prefix);
3578 my $restore_opts = "--newservername=$env->{SERVER} --host-ip=$env->{SERVER_IP}";
3579 my $ret = $self->restore_backup_file($backup_file, $restore_opts,
3580 $restore_dir, $env->{SERVERCONFFILE});
3581 unless ($ret == 0) {
3582 return undef;
3583 }
3584
3585 # because we don't include any secrets in the backup, we need to reset the
3586 # admin user's password back to what the testenv expects
3587 my $samba_tool = Samba::bindir_path($self, "samba-tool");
3588 my $cmd = "$samba_tool user setpassword $env->{USERNAME} ";
3589 $cmd .= "--newpassword=$env->{PASSWORD} -H $restore_dir/private/sam.ldb";
3590 $cmd .= " $env->{CONFIGURATION}";
3591
3592 unless(system($cmd) == 0) {
3593 warn("Failed to reset admin's password: \n$cmd");
3594 return undef;
3595 }
3596
3597 # start samba for the restored DC
3598 if (not defined($self->check_or_start($env))) {
3599 return undef;
3600 }
3601
3602 my $upn_array = ["$env->{REALM}.upn"];
3603 my $spn_array = ["$env->{REALM}.spn"];
3604
3605 if ($self->setup_namespaces($env, $upn_array, $spn_array) != 0) {
3606 return undef;
3607 }
3608
3609 return $env;
3610 }
3611
3612 # Inspects a backup *.tar.bz2 file and determines the realm/domain it contains
3613 sub get_backup_domain_realm
3614 {
3615 my ($self, $backup_file) = @_;
3616
3617 print "Determining REALM/DOMAIN values in backup...\n";
3618
3619 # The backup will have the correct domain/realm values in the smb.conf.
3620 # So we can work out the env variables the testenv should use based on
3621 # that. Let's start by extracting the smb.conf
3622 my $tar = Archive::Tar->new($backup_file);
3623 my $tmpdir = File::Temp->newdir();
3624 my $smbconf = "$tmpdir/smb.conf";
3625
3626 # note that the filepaths within the tar-file differ slightly for online
3627 # and offline backups
3628 if ($tar->contains_file("etc/smb.conf")) {
3629 $tar->extract_file("etc/smb.conf", $smbconf);
3630 } elsif ($tar->contains_file("./etc/smb.conf")) {
3631 $tar->extract_file("./etc/smb.conf", $smbconf);
3632 } else {
3633 warn("Could not find smb.conf in $backup_file");
3634 return undef, undef;
3635 }
3636
3637 # make sure we don't try to create locks/sockets in the default install
3638 # location (i.e. /usr/local/samba/)
3639 my $options = "--option=\"private dir = $tmpdir\"";
3640 $options .= " --option=\"lock dir = $tmpdir\"";
3641
3642 # now use testparm to read the values we're interested in
3643 my $testparm = Samba::bindir_path($self, "testparm");
3644 my $domain = `$testparm $smbconf -sl --parameter-name=WORKGROUP $options`;
3645 my $realm = `$testparm $smbconf -sl --parameter-name=REALM $options`;
3646 chomp $realm;
3647 chomp $domain;
3648 print "Backup-file REALM is $realm, DOMAIN is $domain\n";
3649
3650 return ($domain, $realm);
3651 }
3652
3653 # This spins up a custom testenv that can be based on any backup-file you want.
3654 # This is just intended for manual testing (rather than automated test-cases)
3655 sub setup_customdc
3656 {
3657 my ($self, $prefix) = @_;
3658 print "Preparing CUSTOM RESTORE DC...\n";
3659 my $dc_name = "customdc";
3660 my $password = "locDCpass1";
3661 my $backup_file = $ENV{'BACKUP_FILE'};
3662 my $dnsupdate_options = " --use-samba-tool --no-credentials";
3663
3664 # user must specify a backup file to restore via an ENV variable, i.e.
3665 # BACKUP_FILE=backup-blah.tar.bz2 SELFTEST_TESTENV=customdc make testenv
3666 if (not defined($backup_file)) {
3667 warn("Please specify BACKUP_FILE");
3668 return undef;
3669 }
3670
3671 # work out the correct domain/realm env values from the backup-file
3672 my ($domain, $realm) = $self->get_backup_domain_realm($backup_file);
3673 if ($domain eq '' or $realm eq '') {
3674 warn("Could not determine domain or realm");
3675 return undef;
3676 }
3677
3678 # create a placeholder directory and smb.conf, as well as the env vars.
3679 my ($env, $ctx) = $self->prepare_dc_testenv($prefix, $dc_name,
3680 $domain, $realm, $password, "",
3681 $dnsupdate_options);
3682
3683 # restore the specified backup file to populate the testenv
3684 my $restore_dir = abs_path($prefix);
3685 my $ret = $self->restore_backup_file($backup_file,
3686 "--newservername=$env->{SERVER}",
3687 $restore_dir, $env->{SERVERCONFFILE});
3688 unless ($ret == 0) {
3689 return undef;
3690 }
3691
3692 #
3693 # As we create the same domain as a clone
3694 # we need a separate resolv.conf!
3695 #
3696 $ctx->{resolv_conf} = "$ctx->{etcdir}/resolv.conf";
3697 $ctx->{dns_ipv4} = $ctx->{ipv4};
3698 $ctx->{dns_ipv6} = $ctx->{ipv6};
3699 Samba::mk_resolv_conf($ctx);
3700 $env->{RESOLV_CONF} = $ctx->{resolv_conf};
3701
3702 # Change the admin password to the testenv default, just in case it's
3703 # different, or in case this was a --no-secrets backup
3704 my $samba_tool = Samba::bindir_path($self, "samba-tool");
3705 my $cmd = "$samba_tool user setpassword $env->{USERNAME} ";
3706 $cmd .= "--newpassword=$password -H $restore_dir/private/sam.ldb";
3707 $cmd .= " $env->{CONFIGURATION}";
3708
3709 unless(system($cmd) == 0) {
3710 warn("Failed to reset admin's password: \n$cmd");
3711 return undef;
3712 }
3713
3714 # re-create the testenv's krb5.conf (the restore may have overwritten it,
3715 # if the backup-file was an offline backup)
3716 Samba::mk_krb5_conf($ctx);
3717
3718 # start samba for the restored DC
3719 if (not defined($self->check_or_start($env))) {
3720 return undef;
3721 }
3722
3723 # if this was a backup-rename, then we may need to setup namespaces
3724 my $upn_array = ["$env->{REALM}.upn"];
3725 my $spn_array = ["$env->{REALM}.spn"];
3726
3727 return $env;
3728 }
3729
3730 sub setup_none
3731 {
3732 my ($self, $path) = @_;
3733
3734 my $ret = {
3735 KRB5_CONFIG => abs_path($path) . "/no_krb5.conf",
3736 SAMBA_PID => -1,
3737 }
3738 }
3739
3740 1;
Samba GIT mirror