selftest/target/Samba4.pm

   1 #!/usr/bin/perl
   2 # Bootstrap Samba and run a number of tests against it.
   3 # Copyright (C) 2005-2007 Jelmer Vernooij <jelmer@samba.org>
   4 # Published under the GNU GPL, v3 or later.
   5
   6 package Samba4;
   7
   8 use strict;
   9 use Cwd qw(abs_path);
  10 use FindBin qw($RealBin);
  11 use POSIX;
  12 use SocketWrapper;
  13 use target::Samba;
  14 use target::Samba3;
  15
  16 sub new($$$$$) {
  17         my ($classname, $bindir, $binary_mapping, $ldap, $srcdir, $server_maxtime) = @_;
  18
  19         my $self = {
  20                 vars => {},
  21                 ldap => $ldap,
  22                 bindir => $bindir,
  23                 binary_mapping => $binary_mapping,
  24                 srcdir => $srcdir,
  25                 server_maxtime => $server_maxtime,
  26                 target3 => new Samba3($bindir, $binary_mapping, $srcdir, $server_maxtime)
  27         };
  28         bless $self;
  29         return $self;
  30 }
  31
  32 sub scriptdir_path($$) {
  33         my ($self, $path) = @_;
  34         return "$self->{srcdir}/source4/scripting/$path";
  35 }
  36
  37 sub openldap_start($$$) {
  38 }
  39
  40 sub slapd_start($$)
  41 {
  42         my $count = 0;
  43         my ($self, $env_vars, $STDIN_READER) = @_;
  44         my $ldbsearch = Samba::bindir_path($self, "ldbsearch");
  45
  46         my $uri = $env_vars->{LDAP_URI};
  47
  48         if (system("$ldbsearch -H $uri -s base -b \"\" supportedLDAPVersion > /dev/null") == 0) {
  49             print "A SLAPD is still listening to $uri before we started the LDAP backend.  Aborting!";
  50             return 1;
  51         }
  52         # running slapd in the background means it stays in the same process group, so it can be
  53         # killed by timelimit
  54         my $pid = fork();
  55         if ($pid == 0) {
  56                 open STDOUT, ">$env_vars->{LDAPDIR}/logs";
  57                 open STDERR, '>&STDOUT';
  58                 close($env_vars->{STDIN_PIPE});
  59                 open STDIN, ">&", $STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
  60
  61                 if ($self->{ldap} eq "fedora-ds") {
  62                         exec("$ENV{FEDORA_DS_ROOT}/sbin/ns-slapd", "-D", $env_vars->{FEDORA_DS_DIR}, "-d0", "-i", $env_vars->{FEDORA_DS_PIDFILE});
  63                 } elsif ($self->{ldap} eq "openldap") {
  64                         exec($ENV{OPENLDAP_SLAPD}, "-dnone", "-F", $env_vars->{SLAPD_CONF_D}, "-h", $uri);
  65                 }
  66                 die("Unable to start slapd: $!");
  67         }
  68         $env_vars->{SLAPD_PID} = $pid;
  69         sleep(1);
  70         while (system("$ldbsearch -H $uri -s base -b \"\" supportedLDAPVersion > /dev/null") != 0) {
  71                 $count++;
  72                 if ($count > 40) {
  73                         $self->slapd_stop($env_vars);
  74                         return 0;
  75                 }
  76                 sleep(1);
  77         }
  78         return 1;
  79 }
  80
  81 sub slapd_stop($$)
  82 {
  83         my ($self, $envvars) = @_;
  84         kill 9, $envvars->{SLAPD_PID};
  85         return 1;
  86 }
  87
  88 sub check_or_start($$$)
  89 {
  90         my ($self, $env_vars, $process_model) = @_;
  91         my $STDIN_READER;
  92
  93         return 0 if $self->check_env($env_vars);
  94
  95         # use a pipe for stdin in the child processes. This allows
  96         # those processes to monitor the pipe for EOF to ensure they
  97         # exit when the test script exits
  98         pipe($STDIN_READER, $env_vars->{STDIN_PIPE});
  99
 100         # Start slapd before samba, but with the fifo on stdin
 101         if (defined($self->{ldap})) {
 102                 unless($self->slapd_start($env_vars, $STDIN_READER)) {
 103                         warn("couldn't start slapd (main run)");
 104                         return undef;
 105                 }
 106         }
 107
 108         print "STARTING SAMBA...";
 109         my $pid = fork();
 110         if ($pid == 0) {
 111                 # we want out from samba to go to the log file, but also
 112                 # to the users terminal when running 'make test' on the command
 113                 # line. This puts it on stderr on the terminal
 114                 open STDOUT, "| tee $env_vars->{SAMBA_TEST_LOG} 1>&2";
 115                 open STDERR, '>&STDOUT';
 116
 117                 SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
 118
 119                 $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
 120                 $ENV{SELFTEST_WINBINDD_SOCKET_DIR} = $env_vars->{SELFTEST_WINBINDD_SOCKET_DIR};
 121                 $ENV{NMBD_SOCKET_DIR} = $env_vars->{NMBD_SOCKET_DIR};
 122
 123                 $ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
 124                 $ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
 125                 $ENV{NSS_WRAPPER_HOSTS} = $env_vars->{NSS_WRAPPER_HOSTS};
 126                 $ENV{NSS_WRAPPER_MODULE_SO_PATH} = $env_vars->{NSS_WRAPPER_MODULE_SO_PATH};
 127                 $ENV{NSS_WRAPPER_MODULE_FN_PREFIX} = $env_vars->{NSS_WRAPPER_MODULE_FN_PREFIX};
 128
 129                 $ENV{UID_WRAPPER} = "1";
 130
 131                 $ENV{MAKE_TEST_BINARY} = Samba::bindir_path($self, "samba");
 132                 my @preargs = ();
 133                 my @optargs = ();
 134                 if (defined($ENV{SAMBA_OPTIONS})) {
 135                         @optargs = split(/ /, $ENV{SAMBA_OPTIONS});
 136                 }
 137                 if(defined($ENV{SAMBA_VALGRIND})) {
 138                         @preargs = split(/ /,$ENV{SAMBA_VALGRIND});
 139                 }
 140
 141                 close($env_vars->{STDIN_PIPE});
 142                 open STDIN, ">&", $STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
 143
 144                 exec(@preargs, Samba::bindir_path($self, "samba"), "-M", $process_model, "-i", "--maximum-runtime=$self->{server_maxtime}", $env_vars->{CONFIGURATION}, @optargs) or die("Unable to start samba: $!");
 145         }
 146         $env_vars->{SAMBA_PID} = $pid;
 147         print "DONE\n";
 148
 149         close($STDIN_READER);
 150
 151         return $pid;
 152 }
 153
 154 sub wait_for_start($$)
 155 {
 156         my ($self, $testenv_vars) = @_;
 157         my $ret;
 158         # give time for nbt server to register its names
 159         print "delaying for nbt name registration\n";
 160         sleep 2;
 161
 162         # This will return quickly when things are up, but be slow if we
 163         # need to wait for (eg) SSL init
 164         my $nmblookup =  Samba::bindir_path($self, "nmblookup4");
 165         system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{SERVER}");
 166         system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{SERVER}");
 167         system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
 168         system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
 169         system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
 170         system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
 171         system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{SERVER}");
 172         system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{SERVER}");
 173         system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
 174         system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
 175         system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
 176         system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
 177
 178         # Ensure we have the first RID Set before we start tests.  This makes the tests more reliable.
 179         if ($testenv_vars->{SERVER_ROLE} eq "domain controller" and not ($testenv_vars->{NETBIOS_NAME} eq "rodc")) {
 180             # Add hosts file for name lookups
 181             $ENV{NSS_WRAPPER_HOSTS} = $testenv_vars->{NSS_WRAPPER_HOSTS};
 182
 183             print "waiting for working LDAP and a RID Set to be allocated\n";
 184             my $ldbsearch = Samba::bindir_path($self, "ldbsearch");
 185             my $count = 0;
 186             my $base_dn = "DC=".join(",DC=", split(/\./, $testenv_vars->{REALM}));
 187             my $rid_set_dn = "cn=RID Set,cn=$testenv_vars->{NETBIOSNAME},ou=domain controllers,$base_dn";
 188             sleep(1);
 189             while (system("$ldbsearch -H ldap://$testenv_vars->{SERVER} -U$testenv_vars->{USERNAME}%$testenv_vars->{PASSWORD} -s base -b \"$rid_set_dn\" rIDAllocationPool > /dev/null") != 0) {
 190                 $count++;
 191                 if ($count > 40) {
 192                     $ret = 1;
 193                     last;
 194                 }
 195                 sleep(1);
 196             }
 197         }
 198         print $self->getlog_env($testenv_vars);
 199
 200         return $ret
 201 }
 202
 203 sub write_ldb_file($$$)
 204 {
 205         my ($self, $file, $ldif) = @_;
 206
 207         my $ldbadd =  Samba::bindir_path($self, "ldbadd");
 208         open(LDIF, "|$ldbadd -H $file >/dev/null");
 209         print LDIF $ldif;
 210         return(close(LDIF));
 211 }
 212
 213 sub add_wins_config($$)
 214 {
 215         my ($self, $privatedir) = @_;
 216
 217         return $self->write_ldb_file("$privatedir/wins_config.ldb", "
 218 dn: name=TORTURE_11,CN=PARTNERS
 219 objectClass: wreplPartner
 220 name: TORTURE_11
 221 address: 127.0.0.11
 222 pullInterval: 0
 223 pushChangeCount: 0
 224 type: 0x3
 225 ");
 226 }
 227
 228 sub mk_fedora_ds($$)
 229 {
 230         my ($self, $ctx) = @_;
 231
 232         #Make the subdirectory be as fedora DS would expect
 233         my $fedora_ds_dir = "$ctx->{ldapdir}/slapd-$ctx->{ldap_instance}";
 234
 235         my $pidfile = "$fedora_ds_dir/logs/slapd-$ctx->{ldap_instance}.pid";
 236
 237         return ($fedora_ds_dir, $pidfile);
 238 }
 239
 240 sub mk_openldap($$)
 241 {
 242         my ($self, $ctx) = @_;
 243
 244         my $slapd_conf_d = "$ctx->{ldapdir}/slapd.d";
 245         my $pidfile = "$ctx->{ldapdir}/slapd.pid";
 246
 247         return ($slapd_conf_d, $pidfile);
 248 }
 249
 250 sub provision_raw_prepare($$$$$$$$$$)
 251 {
 252         my ($self, $prefix, $server_role, $hostname,
 253             $domain, $realm, $functional_level,
 254             $password, $kdc_ipv4) = @_;
 255         my $ctx;
 256         my $netbiosname = uc($hostname);
 257
 258         unless(-d $prefix or mkdir($prefix, 0777)) {
 259                 warn("Unable to create $prefix");
 260                 return undef;
 261         }
 262         my $prefix_abs = abs_path($prefix);
 263
 264         die ("prefix=''") if $prefix_abs eq "";
 265         die ("prefix='/'") if $prefix_abs eq "/";
 266
 267         unless (system("rm -rf $prefix_abs/*") == 0) {
 268                 warn("Unable to clean up");
 269         }
 270
 271
 272         my $swiface = Samba::get_interface($hostname);
 273
 274         $ctx->{prefix} = $prefix;
 275         $ctx->{prefix_abs} = $prefix_abs;
 276
 277         $ctx->{dns_host_file} = "$ENV{SELFTEST_PREFIX}/dns_host_file";
 278
 279         $ctx->{server_role} = $server_role;
 280         $ctx->{hostname} = $hostname;
 281         $ctx->{netbiosname} = $netbiosname;
 282         $ctx->{swiface} = $swiface;
 283         $ctx->{password} = $password;
 284         $ctx->{kdc_ipv4} = $kdc_ipv4;
 285
 286 #
 287 # Set smbd log level here.
 288 #
 289         $ctx->{server_loglevel} =$ENV{SERVER_LOG_LEVEL} || 1;
 290         $ctx->{username} = "Administrator";
 291         $ctx->{domain} = $domain;
 292         $ctx->{realm} = uc($realm);
 293         $ctx->{dnsname} = lc($realm);
 294
 295         $ctx->{functional_level} = $functional_level;
 296
 297         my $unix_name = ($ENV{USER} or $ENV{LOGNAME} or `whoami`);
 298         chomp $unix_name;
 299         $ctx->{unix_name} = $unix_name;
 300         $ctx->{unix_uid} = $>;
 301         my @mygid = split(" ", $();
 302         $ctx->{unix_gid} = $mygid[0];
 303         $ctx->{unix_gids_str} = $);
 304         @{$ctx->{unix_gids}} = split(" ", $ctx->{unix_gids_str});
 305
 306         $ctx->{etcdir} = "$prefix_abs/etc";
 307         $ctx->{piddir} = "$prefix_abs/pid";
 308         $ctx->{smb_conf} = "$ctx->{etcdir}/smb.conf";
 309         $ctx->{krb5_conf} = "$ctx->{etcdir}/krb5.conf";
 310         $ctx->{privatedir} = "$prefix_abs/private";
 311         $ctx->{ncalrpcdir} = "$prefix_abs/ncalrpc";
 312         $ctx->{lockdir} = "$prefix_abs/lockdir";
 313         $ctx->{logdir} = "$prefix_abs/logs";
 314         $ctx->{statedir} = "$prefix_abs/statedir";
 315         $ctx->{cachedir} = "$prefix_abs/cachedir";
 316         $ctx->{winbindd_socket_dir} = "$prefix_abs/winbindd_socket";
 317         $ctx->{winbindd_privileged_socket_dir} = "$prefix_abs/winbindd_privileged_socket";
 318         $ctx->{ntp_signd_socket_dir} = "$prefix_abs/ntp_signd_socket";
 319         $ctx->{nsswrap_passwd} = "$ctx->{etcdir}/passwd";
 320         $ctx->{nsswrap_group} = "$ctx->{etcdir}/group";
 321         $ctx->{nsswrap_hosts} = "$ENV{SELFTEST_PREFIX}/hosts";
 322
 323         $ctx->{tlsdir} = "$ctx->{privatedir}/tls";
 324
 325         $ctx->{ipv4} = "127.0.0.$swiface";
 326         $ctx->{ipv6} = sprintf("fd00:0000:0000:0000:0000:0000:5357:5f%02x", $swiface);
 327         $ctx->{interfaces} = "$ctx->{ipv4}/8 $ctx->{ipv6}/64";
 328
 329         push(@{$ctx->{directories}}, $ctx->{privatedir});
 330         push(@{$ctx->{directories}}, $ctx->{etcdir});
 331         push(@{$ctx->{directories}}, $ctx->{piddir});
 332         push(@{$ctx->{directories}}, $ctx->{lockdir});
 333         push(@{$ctx->{directories}}, $ctx->{logdir});
 334         push(@{$ctx->{directories}}, $ctx->{statedir});
 335         push(@{$ctx->{directories}}, $ctx->{cachedir});
 336
 337         $ctx->{smb_conf_extra_options} = "";
 338
 339         my @provision_options = ();
 340         push (@provision_options, "KRB5_CONFIG=\"$ctx->{krb5_config}\"");
 341         push (@provision_options, "NSS_WRAPPER_PASSWD=\"$ctx->{nsswrap_passwd}\"");
 342         push (@provision_options, "NSS_WRAPPER_GROUP=\"$ctx->{nsswrap_group}\"");
 343         push (@provision_options, "NSS_WRAPPER_HOSTS=\"$ctx->{nsswrap_hosts}\"");
 344         if (defined($ENV{GDB_PROVISION})) {
 345                 push (@provision_options, "gdb --args");
 346                 if (!defined($ENV{PYTHON})) {
 347                     push (@provision_options, "env");
 348                     push (@provision_options, "python");
 349                 }
 350         }
 351         if (defined($ENV{VALGRIND_PROVISION})) {
 352                 push (@provision_options, "valgrind");
 353                 if (!defined($ENV{PYTHON})) {
 354                     push (@provision_options, "env");
 355                     push (@provision_options, "python");
 356                 }
 357         }
 358         if (defined($ENV{PYTHON})) {
 359                 push (@provision_options, $ENV{PYTHON});
 360         }
 361         push (@provision_options, Samba::bindir_path($self, "samba-tool"));
 362         push (@provision_options, "domain");
 363         push (@provision_options, "provision");
 364         push (@provision_options, "--configfile=$ctx->{smb_conf}");
 365         push (@provision_options, "--host-name=$ctx->{hostname}");
 366         push (@provision_options, "--host-ip=$ctx->{ipv4}");
 367         push (@provision_options, "--quiet");
 368         push (@provision_options, "--domain=$ctx->{domain}");
 369         push (@provision_options, "--realm=$ctx->{realm}");
 370         push (@provision_options, "--adminpass=$ctx->{password}");
 371         push (@provision_options, "--krbtgtpass=krbtgt$ctx->{password}");
 372         push (@provision_options, "--machinepass=machine$ctx->{password}");
 373         push (@provision_options, "--root=$ctx->{unix_name}");
 374         push (@provision_options, "--server-role=\"$ctx->{server_role}\"");
 375         push (@provision_options, "--function-level=\"$ctx->{functional_level}\"");
 376
 377         @{$ctx->{provision_options}} = @provision_options;
 378
 379         return $ctx;
 380 }
 381
 382 #
 383 # Step1 creates the basic configuration
 384 #
 385 sub provision_raw_step1($$)
 386 {
 387         my ($self, $ctx) = @_;
 388
 389         mkdir($_, 0777) foreach (@{$ctx->{directories}});
 390
 391         ##
 392         ## lockdir and piddir must be 0755
 393         ##
 394         chmod 0755, $ctx->{lockdir};
 395         chmod 0755, $ctx->{piddir};
 396
 397         unless (open(CONFFILE, ">$ctx->{smb_conf}")) {
 398                 warn("can't open $ctx->{smb_conf}$?");
 399                 return undef;
 400         }
 401
 402         Samba::prepare_keyblobs($ctx);
 403         my $crlfile = "$ctx->{tlsdir}/crl.pem";
 404         $crlfile = "" unless -e ${crlfile};
 405
 406         print CONFFILE "
 407 [global]
 408         netbios name = $ctx->{netbiosname}
 409         posix:eadb = $ctx->{statedir}/eadb.tdb
 410         workgroup = $ctx->{domain}
 411         realm = $ctx->{realm}
 412         private dir = $ctx->{privatedir}
 413         pid directory = $ctx->{piddir}
 414         ncalrpc dir = $ctx->{ncalrpcdir}
 415         lock dir = $ctx->{lockdir}
 416         state directory = $ctx->{statedir}
 417         cache directory = $ctx->{cachedir}
 418         winbindd socket directory = $ctx->{winbindd_socket_dir}
 419         winbindd privileged socket directory = $ctx->{winbindd_privileged_socket_dir}
 420         ntp signd socket directory = $ctx->{ntp_signd_socket_dir}
 421         winbind separator = /
 422         name resolve order = file bcast
 423         interfaces = $ctx->{interfaces}
 424         tls dh params file = $ctx->{tlsdir}/dhparms.pem
 425         tls crlfile = ${crlfile}
 426         panic action = $RealBin/gdb_backtrace \%d
 427         wins support = yes
 428         server role = $ctx->{server_role}
 429         server services = +echo +smb -s3fs
 430         dcerpc endpoint servers = +winreg +srvsvc
 431         notify:inotify = false
 432         ldb:nosync = true
 433         ldap server require strong auth = yes
 434 #We don't want to pass our self-tests if the PAC code is wrong
 435         gensec:require_pac = true
 436         log file = $ctx->{logdir}/log.\%m
 437         log level = $ctx->{server_loglevel}
 438         lanman auth = Yes
 439         rndc command = true
 440         dns update command = $ENV{SRCDIR_ABS}/source4/scripting/bin/samba_dnsupdate --all-interfaces --use-file=$ctx->{dns_host_file} -s $ctx->{smb_conf}
 441         spn update command = $ENV{SRCDIR_ABS}/source4/scripting/bin/samba_spnupdate -s $ctx->{smb_conf}
 442         resolv:host file = $ctx->{dns_host_file}
 443         dreplsrv:periodic_startup_interval = 0
 444         dsdb:schema update allowed = yes
 445
 446         vfs objects = dfs_samba4 acl_xattr fake_acls xattr_tdb streams_depot
 447
 448         # remove this again, when our smb2 client library
 449         # supports signin on compound related requests
 450         server signing = on
 451
 452         idmap_ldb:use rfc2307=yes
 453         winbind enum users = yes
 454         winbind enum groups = yes
 455 ";
 456
 457         print CONFFILE "
 458
 459         # Begin extra options
 460         $ctx->{smb_conf_extra_options}
 461         # End extra options
 462 ";
 463         close(CONFFILE);
 464
 465         #Default the KDC IP to the server's IP
 466         if (not defined($ctx->{kdc_ipv4})) {
 467              $ctx->{kdc_ipv4} = $ctx->{ipv4};
 468         }
 469
 470         Samba::mk_krb5_conf($ctx, "");
 471
 472         open(PWD, ">$ctx->{nsswrap_passwd}");
 473         print PWD "
 474 root:x:0:0:root gecos:$ctx->{prefix_abs}:/bin/false
 475 $ctx->{unix_name}:x:$ctx->{unix_uid}:100:$ctx->{unix_name} gecos:$ctx->{prefix_abs}:/bin/false
 476 nobody:x:65534:65533:nobody gecos:$ctx->{prefix_abs}:/bin/false
 477 pdbtest:x:65533:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
 478 pdbtest2:x:65532:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
 479 pdbtest3:x:65531:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
 480 pdbtest4:x:65530:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
 481 ";
 482         close(PWD);
 483         my $uid_rfc2307test = 65533;
 484
 485         open(GRP, ">$ctx->{nsswrap_group}");
 486         print GRP "
 487 root:x:0:
 488 wheel:x:10:
 489 users:x:100:
 490 nobody:x:65533:
 491 nogroup:x:65534:nobody
 492 $ctx->{unix_name}:x:$ctx->{unix_gid}:
 493 ";
 494         close(GRP);
 495         my $gid_rfc2307test = 65532;
 496
 497         my $hostname = lc($ctx->{hostname});
 498         open(HOSTS, ">>$ctx->{nsswrap_hosts}");
 499         print HOSTS "$ctx->{ipv4} ${hostname}.$ctx->{dnsname} ${hostname}\n";
 500         print HOSTS "$ctx->{ipv6} ${hostname}.$ctx->{dnsname} ${hostname}\n";
 501         close(HOSTS);
 502
 503         my $configuration = "--configfile=$ctx->{smb_conf}";
 504
 505 #Ensure the config file is valid before we start
 506         my $testparm = Samba::bindir_path($self, "samba-tool") . " testparm";
 507         if (system("$testparm $configuration -v --suppress-prompt >/dev/null 2>&1") != 0) {
 508                 system("$testparm -v --suppress-prompt $configuration >&2");
 509                 warn("Failed to create a valid smb.conf configuration $testparm!");
 510                 return undef;
 511         }
 512         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) {
 513                 warn("Failed to create a valid smb.conf configuration! $testparm $configuration -v --suppress-prompt --parameter-name=\"netbios name\" --section-name=global");
 514                 return undef;
 515         }
 516
 517         my $ret = {
 518                 KRB5_CONFIG => $ctx->{krb5_conf},
 519                 PIDDIR => $ctx->{piddir},
 520                 SERVER => $ctx->{hostname},
 521                 SERVER_IP => $ctx->{ipv4},
 522                 SERVER_IPV6 => $ctx->{ipv6},
 523                 NETBIOSNAME => $ctx->{netbiosname},
 524                 DOMAIN => $ctx->{domain},
 525                 USERNAME => $ctx->{username},
 526                 REALM => $ctx->{realm},
 527                 PASSWORD => $ctx->{password},
 528                 LDAPDIR => $ctx->{ldapdir},
 529                 LDAP_INSTANCE => $ctx->{ldap_instance},
 530                 SELFTEST_WINBINDD_SOCKET_DIR => $ctx->{winbindd_socket_dir},
 531                 NCALRPCDIR => $ctx->{ncalrpcdir},
 532                 LOCKDIR => $ctx->{lockdir},
 533                 STATEDIR => $ctx->{statedir},
 534                 CACHEDIR => $ctx->{cachedir},
 535                 PRIVATEDIR => $ctx->{privatedir},
 536                 SERVERCONFFILE => $ctx->{smb_conf},
 537                 CONFIGURATION => $configuration,
 538                 SOCKET_WRAPPER_DEFAULT_IFACE => $ctx->{swiface},
 539                 NSS_WRAPPER_PASSWD => $ctx->{nsswrap_passwd},
 540                 NSS_WRAPPER_GROUP => $ctx->{nsswrap_group},
 541                 NSS_WRAPPER_HOSTS => $ctx->{nsswrap_hosts},
 542                 SAMBA_TEST_FIFO => "$ctx->{prefix}/samba_test.fifo",
 543                 SAMBA_TEST_LOG => "$ctx->{prefix}/samba_test.log",
 544                 SAMBA_TEST_LOG_POS => 0,
 545                 NSS_WRAPPER_MODULE_SO_PATH => Samba::nss_wrapper_winbind_so_path($self),
 546                 NSS_WRAPPER_MODULE_FN_PREFIX => "winbind",
 547                 LOCAL_PATH => $ctx->{share},
 548                 UID_RFC2307TEST => $uid_rfc2307test,
 549                 GID_RFC2307TEST => $gid_rfc2307test,
 550                 SERVER_ROLE => $ctx->{server_role}
 551         };
 552
 553         return $ret;
 554 }
 555
 556 #
 557 # Step2 runs the provision script
 558 #
 559 sub provision_raw_step2($$$)
 560 {
 561         my ($self, $ctx, $ret) = @_;
 562
 563         my $provision_cmd = join(" ", @{$ctx->{provision_options}});
 564         unless (system($provision_cmd) == 0) {
 565                 warn("Unable to provision: \n$provision_cmd\n");
 566                 return undef;
 567         }
 568
 569         return $ret;
 570 }
 571
 572 sub provision($$$$$$$$$)
 573 {
 574         my ($self, $prefix, $server_role, $hostname,
 575             $domain, $realm, $functional_level,
 576             $password, $kdc_ipv4, $extra_smbconf_options, $extra_smbconf_shares,
 577             $extra_provision_options) = @_;
 578
 579         my $ctx = $self->provision_raw_prepare($prefix, $server_role,
 580                                                $hostname,
 581                                                $domain, $realm, $functional_level,
 582                                                $password, $kdc_ipv4);
 583
 584         if (defined($extra_provision_options)) {
 585                 push (@{$ctx->{provision_options}}, @{$extra_provision_options});
 586         } else {
 587                 push (@{$ctx->{provision_options}}, "--use-ntvfs");
 588         }
 589
 590         $ctx->{share} = "$ctx->{prefix_abs}/share";
 591         push(@{$ctx->{directories}}, "$ctx->{share}");
 592         push(@{$ctx->{directories}}, "$ctx->{share}/test1");
 593         push(@{$ctx->{directories}}, "$ctx->{share}/test2");
 594
 595         # precreate directories for printer drivers
 596         push(@{$ctx->{directories}}, "$ctx->{share}/W32X86");
 597         push(@{$ctx->{directories}}, "$ctx->{share}/x64");
 598         push(@{$ctx->{directories}}, "$ctx->{share}/WIN40");
 599
 600         my $msdfs = "no";
 601         $msdfs = "yes" if ($server_role eq "domain controller");
 602         $ctx->{smb_conf_extra_options} = "
 603
 604         max xmit = 32K
 605         server max protocol = SMB2
 606         host msdfs = $msdfs
 607         lanman auth = yes
 608         allow nt4 crypto = yes
 609
 610         # fruit:copyfile is a global option
 611         fruit:copyfile = yes
 612
 613         $extra_smbconf_options
 614
 615 [tmp]
 616         path = $ctx->{share}
 617         read only = no
 618         posix:sharedelay = 10000
 619         posix:oplocktimeout = 3
 620         posix:writetimeupdatedelay = 50000
 621
 622 [xcopy_share]
 623         path = $ctx->{share}
 624         read only = no
 625         posix:sharedelay = 10000
 626         posix:oplocktimeout = 3
 627         posix:writetimeupdatedelay = 50000
 628         create mask = 777
 629         force create mode = 777
 630
 631 [posix_share]
 632         path = $ctx->{share}
 633         read only = no
 634         create mask = 0777
 635         force create mode = 0
 636         directory mask = 0777
 637         force directory mode = 0
 638
 639 [test1]
 640         path = $ctx->{share}/test1
 641         read only = no
 642         posix:sharedelay = 10000
 643         posix:oplocktimeout = 3
 644         posix:writetimeupdatedelay = 50000
 645
 646 [test2]
 647         path = $ctx->{share}/test2
 648         read only = no
 649         posix:sharedelay = 10000
 650         posix:oplocktimeout = 3
 651         posix:writetimeupdatedelay = 50000
 652
 653 [cifs]
 654         path = $ctx->{share}/_ignore_cifs_
 655         read only = no
 656         ntvfs handler = cifs
 657         cifs:server = $ctx->{netbiosname}
 658         cifs:share = tmp
 659         cifs:use-s4u2proxy = yes
 660         # There is no username specified here, instead the client is expected
 661         # to log in with kerberos, and the serverwill use delegated credentials.
 662         # Or the server tries s4u2self/s4u2proxy to impersonate the client
 663
 664 [simple]
 665         path = $ctx->{share}
 666         read only = no
 667         ntvfs handler = simple
 668
 669 [sysvol]
 670         path = $ctx->{statedir}/sysvol
 671         read only = no
 672
 673 [netlogon]
 674         path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
 675         read only = no
 676
 677 [cifsposix]
 678         copy = simple
 679         ntvfs handler = cifsposix
 680
 681 [vfs_fruit]
 682         path = $ctx->{share}
 683         vfs objects = catia fruit streams_xattr acl_xattr
 684         ea support = yes
 685         fruit:ressource = file
 686         fruit:metadata = netatalk
 687         fruit:locking = netatalk
 688         fruit:encoding = native
 689
 690 $extra_smbconf_shares
 691 ";
 692
 693         if (defined($self->{ldap})) {
 694                 $ctx->{ldapdir} = "$ctx->{privatedir}/ldap";
 695                 push(@{$ctx->{directories}}, "$ctx->{ldapdir}");
 696
 697                 my $ldap_uri= "$ctx->{ldapdir}/ldapi";
 698                 $ldap_uri =~ s|/|%2F|g;
 699                 $ldap_uri = "ldapi://$ldap_uri";
 700                 $ctx->{ldap_uri} = $ldap_uri;
 701
 702                 $ctx->{ldap_instance} = lc($ctx->{netbiosname});
 703         }
 704
 705         my $ret = $self->provision_raw_step1($ctx);
 706         unless (defined $ret) {
 707                 return undef;
 708         }
 709
 710         if (defined($self->{ldap})) {
 711                 $ret->{LDAP_URI} = $ctx->{ldap_uri};
 712                 push (@{$ctx->{provision_options}}, "--ldap-backend-type=" . $self->{ldap});
 713                 push (@{$ctx->{provision_options}}, "--ldap-backend-nosync");
 714                 if ($self->{ldap} eq "openldap") {
 715                         push (@{$ctx->{provision_options}}, "--slapd-path=" . $ENV{OPENLDAP_SLAPD});
 716                         ($ret->{SLAPD_CONF_D}, $ret->{OPENLDAP_PIDFILE}) = $self->mk_openldap($ctx) or die("Unable to create openldap directories");
 717
 718                 } elsif ($self->{ldap} eq "fedora-ds") {
 719                         push (@{$ctx->{provision_options}}, "--slapd-path=" . "$ENV{FEDORA_DS_ROOT}/sbin/ns-slapd");
 720                         push (@{$ctx->{provision_options}}, "--setup-ds-path=" . "$ENV{FEDORA_DS_ROOT}/sbin/setup-ds.pl");
 721                         ($ret->{FEDORA_DS_DIR}, $ret->{FEDORA_DS_PIDFILE}) = $self->mk_fedora_ds($ctx) or die("Unable to create fedora ds directories");
 722                 }
 723
 724         }
 725
 726         return $self->provision_raw_step2($ctx, $ret);
 727 }
 728
 729 sub provision_s4member($$$)
 730 {
 731         my ($self, $prefix, $dcvars) = @_;
 732         print "PROVISIONING MEMBER...";
 733         my $extra_smb_conf = "
 734         passdb backend = samba_dsdb
 735 winbindd:use external pipes = true
 736
 737 rpc_server:default = external
 738 rpc_server:svcctl = embedded
 739 rpc_server:srvsvc = embedded
 740 rpc_server:eventlog = embedded
 741 rpc_server:ntsvcs = embedded
 742 rpc_server:winreg = embedded
 743 rpc_server:spoolss = embedded
 744 rpc_daemon:spoolssd = embedded
 745 rpc_server:tcpip = no
 746 ";
 747         my $ret = $self->provision($prefix,
 748                                    "member server",
 749                                    "s4member",
 750                                    "SAMBADOMAIN",
 751                                    "samba.example.com",
 752                                    "2008",
 753                                    "locMEMpass3",
 754                                    $dcvars->{SERVER_IP},
 755                                    $extra_smb_conf, "", undef);
 756         unless ($ret) {
 757                 return undef;
 758         }
 759
 760         my $samba_tool =  Samba::bindir_path($self, "samba-tool");
 761         my $cmd = "";
 762         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 763         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
 764         $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} member";
 765         $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
 766         $cmd .= " --machinepass=machine$ret->{PASSWORD}";
 767
 768         unless (system($cmd) == 0) {
 769                 warn("Join failed\n$cmd");
 770                 return undef;
 771         }
 772
 773         $ret->{MEMBER_SERVER} = $ret->{SERVER};
 774         $ret->{MEMBER_SERVER_IP} = $ret->{SERVER_IP};
 775         $ret->{MEMBER_SERVER_IPV6} = $ret->{SERVER_IPV6};
 776         $ret->{MEMBER_NETBIOSNAME} = $ret->{NETBIOSNAME};
 777         $ret->{MEMBER_USERNAME} = $ret->{USERNAME};
 778         $ret->{MEMBER_PASSWORD} = $ret->{PASSWORD};
 779
 780         $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
 781         $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
 782         $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
 783         $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
 784         $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
 785         $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
 786
 787         return $ret;
 788 }
 789
 790 sub provision_rpc_proxy($$$)
 791 {
 792         my ($self, $prefix, $dcvars) = @_;
 793         print "PROVISIONING RPC PROXY...";
 794
 795         my $extra_smbconf_options = "
 796         passdb backend = samba_dsdb
 797
 798         # rpc_proxy
 799         dcerpc_remote:binding = ncacn_ip_tcp:$dcvars->{SERVER}
 800         dcerpc endpoint servers = epmapper, remote
 801         dcerpc_remote:interfaces = rpcecho
 802
 803 [cifs_to_dc]
 804         path = /tmp/_ignore_cifs_to_dc_/_none_
 805         read only = no
 806         ntvfs handler = cifs
 807         cifs:server = $dcvars->{SERVER}
 808         cifs:share = cifs
 809         cifs:use-s4u2proxy = yes
 810         # There is no username specified here, instead the client is expected
 811         # to log in with kerberos, and the serverwill use delegated credentials.
 812         # Or the server tries s4u2self/s4u2proxy to impersonate the client
 813
 814 ";
 815
 816         my $ret = $self->provision($prefix,
 817                                    "member server",
 818                                    "localrpcproxy",
 819                                    "SAMBADOMAIN",
 820                                    "samba.example.com",
 821                                    "2008",
 822                                    "locRPCproxypass4",
 823                                    $dcvars->{SERVER_IP},
 824                                    $extra_smbconf_options, "", undef);
 825
 826         unless ($ret) {
 827                 return undef;
 828         }
 829
 830         my $samba_tool =  Samba::bindir_path($self, "samba-tool");
 831
 832         # The joind runs in the context of the rpc_proxy/member for now
 833         my $cmd = "";
 834         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 835         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
 836         $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} member";
 837         $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
 838         $cmd .= " --machinepass=machine$ret->{PASSWORD}";
 839
 840         unless (system($cmd) == 0) {
 841                 warn("Join failed\n$cmd");
 842                 return undef;
 843         }
 844
 845         # Setting up delegation runs in the context of the DC for now
 846         $cmd = "";
 847         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$dcvars->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 848         $cmd .= "KRB5_CONFIG=\"$dcvars->{KRB5_CONFIG}\" ";
 849         $cmd .= "$samba_tool delegation for-any-protocol '$ret->{NETBIOSNAME}\$' on";
 850         $cmd .= " $dcvars->{CONFIGURATION}";
 851         print $cmd;
 852
 853         unless (system($cmd) == 0) {
 854                 warn("Delegation failed\n$cmd");
 855                 return undef;
 856         }
 857
 858         # Setting up delegation runs in the context of the DC for now
 859         $cmd = "";
 860         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$dcvars->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 861         $cmd .= "KRB5_CONFIG=\"$dcvars->{KRB5_CONFIG}\" ";
 862         $cmd .= "$samba_tool delegation add-service '$ret->{NETBIOSNAME}\$' cifs/$dcvars->{SERVER}";
 863         $cmd .= " $dcvars->{CONFIGURATION}";
 864
 865         unless (system($cmd) == 0) {
 866                 warn("Delegation failed\n$cmd");
 867                 return undef;
 868         }
 869
 870         $ret->{RPC_PROXY_SERVER} = $ret->{SERVER};
 871         $ret->{RPC_PROXY_SERVER_IP} = $ret->{SERVER_IP};
 872         $ret->{RPC_PROXY_SERVER_IPV6} = $ret->{SERVER_IPV6};
 873         $ret->{RPC_PROXY_NETBIOSNAME} = $ret->{NETBIOSNAME};
 874         $ret->{RPC_PROXY_USERNAME} = $ret->{USERNAME};
 875         $ret->{RPC_PROXY_PASSWORD} = $ret->{PASSWORD};
 876
 877         $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
 878         $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
 879         $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
 880         $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
 881         $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
 882         $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
 883
 884         return $ret;
 885 }
 886
 887 sub provision_promoted_dc($$$)
 888 {
 889         my ($self, $prefix, $dcvars) = @_;
 890         print "PROVISIONING VAMPIRE DC...";
 891
 892         # We do this so that we don't run the provision.  That's the job of 'net vampire'.
 893         my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
 894                                                "promotedvdc",
 895                                                "SAMBADOMAIN",
 896                                                "samba.example.com",
 897                                                "2008",
 898                                                $dcvars->{PASSWORD},
 899                                                $dcvars->{SERVER_IP});
 900
 901         push (@{$ctx->{provision_options}}, "--use-ntvfs");
 902
 903         $ctx->{smb_conf_extra_options} = "
 904         max xmit = 32K
 905         server max protocol = SMB2
 906
 907 [sysvol]
 908         path = $ctx->{statedir}/sysvol
 909         read only = yes
 910
 911 [netlogon]
 912         path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
 913         read only = no
 914
 915 ";
 916
 917         my $ret = $self->provision_raw_step1($ctx);
 918         unless ($ret) {
 919                 return undef;
 920         }
 921
 922         my $samba_tool =  Samba::bindir_path($self, "samba-tool");
 923         my $cmd = "";
 924         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 925         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
 926         $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} MEMBER --realm=$dcvars->{REALM}";
 927         $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
 928         $cmd .= " --machinepass=machine$ret->{PASSWORD}";
 929
 930         unless (system($cmd) == 0) {
 931                 warn("Join failed\n$cmd");
 932                 return undef;
 933         }
 934
 935         my $samba_tool =  Samba::bindir_path($self, "samba-tool");
 936         my $cmd = "";
 937         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 938         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
 939         $cmd .= "$samba_tool domain dcpromo $ret->{CONFIGURATION} $dcvars->{REALM} DC --realm=$dcvars->{REALM}";
 940         $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
 941         $cmd .= " --machinepass=machine$ret->{PASSWORD} --use-ntvfs --dns-backend=BIND9_DLZ";
 942
 943         unless (system($cmd) == 0) {
 944                 warn("Join failed\n$cmd");
 945                 return undef;
 946         }
 947
 948         $ret->{PROMOTED_DC_SERVER} = $ret->{SERVER};
 949         $ret->{PROMOTED_DC_SERVER_IP} = $ret->{SERVER_IP};
 950         $ret->{PROMOTED_DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
 951         $ret->{PROMOTED_DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
 952
 953         $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
 954         $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
 955         $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
 956         $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
 957         $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
 958         $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
 959
 960         return $ret;
 961 }
 962
 963 sub provision_vampire_dc($$$)
 964 {
 965         my ($self, $prefix, $dcvars) = @_;
 966         print "PROVISIONING VAMPIRE DC...";
 967
 968         # We do this so that we don't run the provision.  That's the job of 'net vampire'.
 969         my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
 970                                                "localvampiredc",
 971                                                "SAMBADOMAIN",
 972                                                "samba.example.com",
 973                                                "2008",
 974                                                $dcvars->{PASSWORD},
 975                                                $dcvars->{SERVER_IP});
 976
 977         push (@{$ctx->{provision_options}}, "--use-ntvfs");
 978
 979         $ctx->{smb_conf_extra_options} = "
 980         max xmit = 32K
 981         server max protocol = SMB2
 982
 983 [sysvol]
 984         path = $ctx->{statedir}/sysvol
 985         read only = yes
 986
 987 [netlogon]
 988         path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
 989         read only = no
 990
 991 ";
 992
 993         my $ret = $self->provision_raw_step1($ctx);
 994         unless ($ret) {
 995                 return undef;
 996         }
 997
 998         my $samba_tool =  Samba::bindir_path($self, "samba-tool");
 999         my $cmd = "";
1000         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
1001         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
1002         $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} DC --realm=$dcvars->{REALM}";
1003         $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD} --domain-critical-only";
1004         $cmd .= " --machinepass=machine$ret->{PASSWORD} --use-ntvfs";
1005
1006         unless (system($cmd) == 0) {
1007                 warn("Join failed\n$cmd");
1008                 return undef;
1009         }
1010
1011         $ret->{VAMPIRE_DC_SERVER} = $ret->{SERVER};
1012         $ret->{VAMPIRE_DC_SERVER_IP} = $ret->{SERVER_IP};
1013         $ret->{VAMPIRE_DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
1014         $ret->{VAMPIRE_DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
1015
1016         $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
1017         $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
1018         $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
1019         $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
1020         $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
1021         $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
1022         $ret->{DC_REALM} = $dcvars->{DC_REALM};
1023
1024         return $ret;
1025 }
1026
1027 sub provision_subdom_dc($$$)
1028 {
1029         my ($self, $prefix, $dcvars) = @_;
1030         print "PROVISIONING SUBDOMAIN DC...";
1031
1032         # We do this so that we don't run the provision.  That's the job of 'net vampire'.
1033         my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
1034                                                "localsubdc",
1035                                                "SAMBASUBDOM",
1036                                                "sub.samba.example.com",
1037                                                "2008",
1038                                                $dcvars->{PASSWORD},
1039                                                undef);
1040
1041         push (@{$ctx->{provision_options}}, "--use-ntvfs");
1042
1043         $ctx->{smb_conf_extra_options} = "
1044         max xmit = 32K
1045         server max protocol = SMB2
1046
1047 [sysvol]
1048         path = $ctx->{statedir}/sysvol
1049         read only = yes
1050
1051 [netlogon]
1052         path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
1053         read only = no
1054
1055 ";
1056
1057         my $ret = $self->provision_raw_step1($ctx);
1058         unless ($ret) {
1059                 return undef;
1060         }
1061
1062         # This ensures we share the krb5.conf with the main DC, so
1063         # they can find each other.  Sadly only works between 'dc' and
1064         # 'subdom_dc', the other DCs won't see it
1065
1066         my $dc_realms = Samba::mk_realms_stanza($dcvars->{REALM}, lc($dcvars->{REALM}),
1067                                                 $dcvars->{DOMAIN}, $dcvars->{SERVER_IP});
1068
1069         $ret->{KRB5_CONFIG} = $dcvars->{KRB5_CONFIG};
1070         $ctx->{krb5_conf} = $dcvars->{KRB5_CONFIG};
1071
1072         Samba::mk_krb5_conf($ctx, $dc_realms);
1073
1074         my $samba_tool =  Samba::bindir_path($self, "samba-tool");
1075         my $cmd = "";
1076         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
1077         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
1078         $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $ctx->{dnsname} subdomain ";
1079         $cmd .= "--parent-domain=$dcvars->{REALM} -U$dcvars->{DC_USERNAME}\@$dcvars->{REALM}\%$dcvars->{DC_PASSWORD}";
1080         $cmd .= " --machinepass=machine$ret->{PASSWORD} --use-ntvfs";
1081         $cmd .= " --adminpass=$ret->{PASSWORD}";
1082
1083         unless (system($cmd) == 0) {
1084                 warn("Join failed\n$cmd");
1085                 return undef;
1086         }
1087
1088         $ret->{SUBDOM_DC_SERVER} = $ret->{SERVER};
1089         $ret->{SUBDOM_DC_SERVER_IP} = $ret->{SERVER_IP};
1090         $ret->{SUBDOM_DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
1091         $ret->{SUBDOM_DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
1092
1093         $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
1094         $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
1095         $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
1096         $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
1097         $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
1098         $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
1099
1100         return $ret;
1101 }
1102
1103 sub provision_dc($$)
1104 {
1105         my ($self, $prefix) = @_;
1106
1107         print "PROVISIONING DC...";
1108         my $extra_conf_options = "netbios aliases = localDC1-a
1109         server services = +winbind -winbindd
1110         ldap server require strong auth = allow_sasl_over_tls
1111         ";
1112         my $ret = $self->provision($prefix,
1113                                    "domain controller",
1114                                    "localdc",
1115                                    "SAMBADOMAIN",
1116                                    "samba.example.com",
1117                                    "2008",
1118                                    "locDCpass1",
1119                                    undef, $extra_conf_options, "", undef);
1120
1121         return undef unless(defined $ret);
1122         unless($self->add_wins_config("$prefix/private")) {
1123                 warn("Unable to add wins configuration");
1124                 return undef;
1125         }
1126         $ret->{NETBIOSALIAS} = "localdc1-a";
1127         $ret->{DC_SERVER} = $ret->{SERVER};
1128         $ret->{DC_SERVER_IP} = $ret->{SERVER_IP};
1129         $ret->{DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
1130         $ret->{DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
1131         $ret->{DC_USERNAME} = $ret->{USERNAME};
1132         $ret->{DC_PASSWORD} = $ret->{PASSWORD};
1133         $ret->{DC_REALM} = $ret->{REALM};
1134
1135         return $ret;
1136 }
1137
1138 sub provision_fl2000dc($$)
1139 {
1140         my ($self, $prefix) = @_;
1141
1142         print "PROVISIONING DC...";
1143         my $ret = $self->provision($prefix,
1144                                    "domain controller",
1145                                    "dc5",
1146                                    "SAMBA2000",
1147                                    "samba2000.example.com",
1148                                    "2000",
1149                                    "locDCpass5",
1150                                    undef, "", "", undef);
1151
1152         unless($self->add_wins_config("$prefix/private")) {
1153                 warn("Unable to add wins configuration");
1154                 return undef;
1155         }
1156
1157         return $ret;
1158 }
1159
1160 sub provision_fl2003dc($$)
1161 {
1162         my ($self, $prefix) = @_;
1163
1164         print "PROVISIONING DC...";
1165         my $extra_conf_options = "allow dns updates = nonsecure and secure";
1166         my $ret = $self->provision($prefix,
1167                                    "domain controller",
1168                                    "dc6",
1169                                    "SAMBA2003",
1170                                    "samba2003.example.com",
1171                                    "2003",
1172                                    "locDCpass6",
1173                                    undef, $extra_conf_options, "", undef);
1174
1175         unless (defined $ret) {
1176                 return undef;
1177         }
1178
1179         $ret->{DC_SERVER} = $ret->{SERVER};
1180         $ret->{DC_SERVER_IP} = $ret->{SERVER_IP};
1181         $ret->{DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
1182         $ret->{DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
1183         $ret->{DC_USERNAME} = $ret->{USERNAME};
1184         $ret->{DC_PASSWORD} = $ret->{PASSWORD};
1185
1186         my @samba_tool_options;
1187         push (@samba_tool_options, Samba::bindir_path($self, "samba-tool"));
1188         push (@samba_tool_options, "domain");
1189         push (@samba_tool_options, "passwordsettings");
1190         push (@samba_tool_options, "set");
1191         push (@samba_tool_options, "--configfile=$ret->{SERVERCONFFILE}");
1192         push (@samba_tool_options, "--min-pwd-age=0");
1193         push (@samba_tool_options, "--history-length=1");
1194
1195         my $samba_tool_cmd = join(" ", @samba_tool_options);
1196
1197         unless (system($samba_tool_cmd) == 0) {
1198                 warn("Unable to set min password age to 0: \n$samba_tool_cmd\n");
1199                 return undef;
1200         }
1201
1202         return $ret;
1203
1204         unless($self->add_wins_config("$prefix/private")) {
1205                 warn("Unable to add wins configuration");
1206                 return undef;
1207         }
1208
1209         return $ret;
1210 }
1211
1212 sub provision_fl2008r2dc($$)
1213 {
1214         my ($self, $prefix) = @_;
1215
1216         print "PROVISIONING DC...";
1217         my $extra_conf_options = "ldap server require strong auth = no";
1218         my $ret = $self->provision($prefix,
1219                                    "domain controller",
1220                                    "dc7",
1221                                    "SAMBA2008R2",
1222                                    "samba2008R2.example.com",
1223                                    "2008_R2",
1224                                    "locDCpass7",
1225                                    undef, $extra_conf_options,
1226                                    "", undef);
1227
1228         unless ($self->add_wins_config("$prefix/private")) {
1229                 warn("Unable to add wins configuration");
1230                 return undef;
1231         }
1232
1233         return $ret;
1234 }
1235
1236
1237 sub provision_rodc($$$)
1238 {
1239         my ($self, $prefix, $dcvars) = @_;
1240         print "PROVISIONING RODC...";
1241
1242         # We do this so that we don't run the provision.  That's the job of 'net join RODC'.
1243         my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
1244                                                "rodc",
1245                                                "SAMBADOMAIN",
1246                                                "samba.example.com",
1247                                                "2008",
1248                                                $dcvars->{PASSWORD},
1249                                                $dcvars->{SERVER_IP});
1250         unless ($ctx) {
1251                 return undef;
1252         }
1253
1254         push (@{$ctx->{provision_options}}, "--use-ntvfs");
1255
1256         $ctx->{share} = "$ctx->{prefix_abs}/share";
1257         push(@{$ctx->{directories}}, "$ctx->{share}");
1258
1259         $ctx->{smb_conf_extra_options} = "
1260         max xmit = 32K
1261         server max protocol = SMB2
1262
1263 [sysvol]
1264         path = $ctx->{statedir}/sysvol
1265         read only = yes
1266
1267 [netlogon]
1268         path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
1269         read only = yes
1270
1271 [tmp]
1272         path = $ctx->{share}
1273         read only = no
1274         posix:sharedelay = 10000
1275         posix:oplocktimeout = 3
1276         posix:writetimeupdatedelay = 50000
1277
1278 ";
1279
1280         my $ret = $self->provision_raw_step1($ctx);
1281         unless ($ret) {
1282                 return undef;
1283         }
1284
1285         my $samba_tool =  Samba::bindir_path($self, "samba-tool");
1286         my $cmd = "";
1287         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
1288         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
1289         $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} RODC";
1290         $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
1291         $cmd .= " --server=$dcvars->{DC_SERVER} --use-ntvfs";
1292
1293         unless (system($cmd) == 0) {
1294                 warn("RODC join failed\n$cmd");
1295                 return undef;
1296         }
1297
1298         # we overwrite the kdc after the RODC join
1299         # so that use the RODC as kdc and test
1300         # the proxy code
1301         $ctx->{kdc_ipv4} = $ret->{SERVER_IP};
1302         Samba::mk_krb5_conf($ctx);
1303
1304         $ret->{RODC_DC_SERVER} = $ret->{SERVER};
1305         $ret->{RODC_DC_SERVER_IP} = $ret->{SERVER_IP};
1306         $ret->{RODC_DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
1307         $ret->{RODC_DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
1308
1309         $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
1310         $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
1311         $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
1312         $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
1313         $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
1314         $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
1315
1316         return $ret;
1317 }
1318
1319 sub provision_plugin_s4_dc($$)
1320 {
1321         my ($self, $prefix) = @_;
1322
1323         my $prefix_abs = abs_path($prefix);
1324
1325         my $bindir_abs = abs_path($self->{bindir});
1326         my $lockdir="$prefix_abs/lockdir";
1327         my $conffile="$prefix_abs/etc/smb.conf";
1328
1329         my $extra_smbconf_options = "
1330         server services = -smb +s3fs
1331         xattr_tdb:file = $prefix_abs/statedir/xattr.tdb
1332
1333         dbwrap_tdb_mutexes:* = yes
1334
1335         kernel oplocks = no
1336         kernel change notify = no
1337
1338         syslog = no
1339         printing = bsd
1340         printcap name = /dev/null
1341
1342         max protocol = SMB3
1343         read only = no
1344         server signing = auto
1345
1346         smbd:sharedelay = 100000
1347         smbd:writetimeupdatedelay = 500000
1348         create mask = 755
1349         dos filemode = yes
1350
1351         dcerpc endpoint servers = -winreg -srvsvc
1352
1353         printcap name = /dev/null
1354
1355         addprinter command = $ENV{SRCDIR_ABS}/source3/script/tests/printing/modprinter.pl -a -s $conffile --
1356         deleteprinter command = $ENV{SRCDIR_ABS}/source3/script/tests/printing/modprinter.pl -d -s $conffile --
1357
1358         printing = vlp
1359         print command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb print %p %s
1360         lpq command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpq %p
1361         lp rm command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lprm %p %j
1362         lp pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lppause %p %j
1363         lp resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpresume %p %j
1364         queue pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queuepause %p
1365         queue resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queueresume %p
1366         lpq cache time = 0
1367         print notify backchannel = yes
1368 ";
1369
1370         my $extra_smbconf_shares = "
1371
1372 [tmpenc]
1373         copy = tmp
1374         smb encrypt = required
1375
1376 [tmpcase]
1377         copy = tmp
1378         case sensitive = yes
1379
1380 [tmpguest]
1381         copy = tmp
1382         guest ok = yes
1383
1384 [hideunread]
1385         copy = tmp
1386         hide unreadable = yes
1387
1388 [durable]
1389         copy = tmp
1390         kernel share modes = no
1391         kernel oplocks = no
1392         posix locking = no
1393
1394 [print\$]
1395         copy = tmp
1396
1397 [print1]
1398         copy = tmp
1399         printable = yes
1400
1401 [print2]
1402         copy = print1
1403 [print3]
1404         copy = print1
1405 [lp]
1406         copy = print1
1407 ";
1408
1409         print "PROVISIONING PLUGIN S4 DC...";
1410         my $ret = $self->provision($prefix,
1411                                    "domain controller",
1412                                    "plugindc",
1413                                    "PLUGINDOMAIN",
1414                                    "plugindom.samba.example.com",
1415                                    "2008",
1416                                    "locDCpass1",
1417                                    undef, $extra_smbconf_options,
1418                                    $extra_smbconf_shares, undef);
1419
1420         return undef unless(defined $ret);
1421         unless($self->add_wins_config("$prefix/private")) {
1422                 warn("Unable to add wins configuration");
1423                 return undef;
1424         }
1425
1426         $ret->{DC_SERVER} = $ret->{SERVER};
1427         $ret->{DC_SERVER_IP} = $ret->{SERVER_IP};
1428         $ret->{DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
1429         $ret->{DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
1430         $ret->{DC_USERNAME} = $ret->{USERNAME};
1431         $ret->{DC_PASSWORD} = $ret->{PASSWORD};
1432
1433         return $ret;
1434 }
1435
1436 sub provision_chgdcpass($$)
1437 {
1438         my ($self, $prefix) = @_;
1439
1440         print "PROVISIONING CHGDCPASS...";
1441         my $extra_provision_options = undef;
1442         push (@{$extra_provision_options}, "--dns-backend=BIND9_DLZ");
1443         my $ret = $self->provision($prefix,
1444                                    "domain controller",
1445                                    "chgdcpass",
1446                                    "CHDCDOMAIN",
1447                                    "chgdcpassword.samba.example.com",
1448                                    "2008",
1449                                    "chgDCpass1",
1450                                    undef, "", "", $extra_provision_options);
1451
1452         return undef unless(defined $ret);
1453         unless($self->add_wins_config("$prefix/private")) {
1454                 warn("Unable to add wins configuration");
1455                 return undef;
1456         }
1457
1458         # Remove secrets.tdb from this environment to test that we
1459         # still start up on systems without the new matching
1460         # secrets.tdb records.
1461         unless (unlink("$ret->{PRIVATEDIR}/secrets.tdb") || unlink("$ret->{PRIVATEDIR}/secrets.ntdb")) {
1462                 warn("Unable to remove $ret->{PRIVATEDIR}/secrets.tdb added during provision");
1463                 return undef;
1464         }
1465
1466         $ret->{DC_SERVER} = $ret->{SERVER};
1467         $ret->{DC_SERVER_IP} = $ret->{SERVER_IP};
1468         $ret->{DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
1469         $ret->{DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
1470         $ret->{DC_USERNAME} = $ret->{USERNAME};
1471         $ret->{DC_PASSWORD} = $ret->{PASSWORD};
1472
1473         return $ret;
1474 }
1475
1476 sub teardown_env($$)
1477 {
1478         my ($self, $envvars) = @_;
1479         my $pid;
1480
1481         # This should cause samba to terminate gracefully
1482         close($envvars->{STDIN_PIPE});
1483
1484         $pid = $envvars->{SAMBA_PID};
1485         my $count = 0;
1486         my $childpid;
1487
1488         # This should give it time to write out the gcov data
1489         until ($count > 30) {
1490             if (Samba::cleanup_child($pid, "samba") == -1) {
1491                 last;
1492             }
1493             sleep(1);
1494             $count++;
1495         }
1496
1497         if ($count > 30 || kill(0, $pid)) {
1498             kill "TERM", $pid;
1499
1500             until ($count > 40) {
1501                 if (Samba::cleanup_child($pid, "samba") == -1) {
1502                     last;
1503                 }
1504                 sleep(1);
1505                 $count++;
1506             }
1507             # If it is still around, kill it
1508             warn "server process $pid took more than $count seconds to exit, killing\n";
1509             kill 9, $pid;
1510         }
1511
1512         $self->slapd_stop($envvars) if ($self->{ldap});
1513
1514         print $self->getlog_env($envvars);
1515
1516         return;
1517 }
1518
1519 sub getlog_env($$)
1520 {
1521         my ($self, $envvars) = @_;
1522         my $title = "SAMBA LOG of: $envvars->{NETBIOSNAME}\n";
1523         my $out = $title;
1524
1525         open(LOG, "<$envvars->{SAMBA_TEST_LOG}");
1526
1527         seek(LOG, $envvars->{SAMBA_TEST_LOG_POS}, SEEK_SET);
1528         while (<LOG>) {
1529                 $out .= $_;
1530         }
1531         $envvars->{SAMBA_TEST_LOG_POS} = tell(LOG);
1532         close(LOG);
1533
1534         return "" if $out eq $title;
1535
1536         return $out;
1537 }
1538
1539 sub check_env($$)
1540 {
1541         my ($self, $envvars) = @_;
1542         my $samba_pid = $envvars->{SAMBA_PID};
1543
1544         return 1 if $samba_pid == -1;
1545
1546         my $childpid = Samba::cleanup_child($samba_pid, "samba");
1547
1548         return ($childpid == 0);
1549 }
1550
1551 sub setup_env($$$)
1552 {
1553         my ($self, $envname, $path) = @_;
1554         my $target3 = $self->{target3};
1555
1556         $ENV{ENVNAME} = $envname;
1557
1558         if (defined($self->{vars}->{$envname})) {
1559                 return $self->{vars}->{$envname};
1560         }
1561
1562         if ($envname eq "dc") {
1563                 return $self->setup_dc("$path/dc");
1564         } elsif ($envname eq "fl2000dc") {
1565                 return $self->setup_fl2000dc("$path/fl2000dc");
1566         } elsif ($envname eq "fl2003dc") {
1567                 return $self->setup_fl2003dc("$path/fl2003dc");
1568         } elsif ($envname eq "fl2008r2dc") {
1569                 return $self->setup_fl2008r2dc("$path/fl2008r2dc");
1570         } elsif ($envname eq "rpc_proxy") {
1571                 if (not defined($self->{vars}->{dc})) {
1572                         $self->setup_dc("$path/dc");
1573                 }
1574                 return $self->setup_rpc_proxy("$path/rpc_proxy", $self->{vars}->{dc});
1575         } elsif ($envname eq "vampire_dc") {
1576                 if (not defined($self->{vars}->{dc})) {
1577                         $self->setup_dc("$path/dc");
1578                 }
1579                 return $self->setup_vampire_dc("$path/vampire_dc", $self->{vars}->{dc});
1580         } elsif ($envname eq "promoted_dc") {
1581                 if (not defined($self->{vars}->{dc})) {
1582                         $self->setup_dc("$path/dc");
1583                 }
1584                 return $self->setup_promoted_dc("$path/promoted_dc", $self->{vars}->{dc});
1585         } elsif ($envname eq "subdom_dc") {
1586                 if (not defined($self->{vars}->{dc})) {
1587                         $self->setup_dc("$path/dc");
1588                 }
1589                 return $self->setup_subdom_dc("$path/subdom_dc", $self->{vars}->{dc});
1590         } elsif ($envname eq "s4member") {
1591                 if (not defined($self->{vars}->{dc})) {
1592                         $self->setup_dc("$path/dc");
1593                 }
1594                 return $self->setup_s4member("$path/s4member", $self->{vars}->{dc});
1595         } elsif ($envname eq "rodc") {
1596                 if (not defined($self->{vars}->{dc})) {
1597                         $self->setup_dc("$path/dc");
1598                 }
1599                 return $self->setup_rodc("$path/rodc", $self->{vars}->{dc});
1600         } elsif ($envname eq "chgdcpass") {
1601                 return $self->setup_chgdcpass("$path/chgdcpass", $self->{vars}->{chgdcpass});
1602         } elsif ($envname eq "s3member") {
1603                 if (not defined($self->{vars}->{dc})) {
1604                         $self->setup_dc("$path/dc");
1605                 }
1606                 return $target3->setup_admember("$path/s3member", $self->{vars}->{dc}, 29);
1607         } elsif ($envname eq "plugin_s4_dc") {
1608                 return $self->setup_plugin_s4_dc("$path/plugin_s4_dc");
1609         } elsif ($envname eq "s3member_rfc2307") {
1610                 if (not defined($self->{vars}->{dc})) {
1611                         $self->setup_dc("$path/dc");
1612                 }
1613                 return $target3->setup_admember_rfc2307("$path/s3member_rfc2307",
1614                                                         $self->{vars}->{dc}, 34);
1615         } elsif ($envname eq "none") {
1616                 return $self->setup_none("$path/none");
1617         } else {
1618                 return "UNKNOWN";
1619         }
1620 }
1621
1622 sub setup_s4member($$$)
1623 {
1624         my ($self, $path, $dc_vars) = @_;
1625
1626         my $env = $self->provision_s4member($path, $dc_vars);
1627
1628         if (defined $env) {
1629                 $self->check_or_start($env, "single");
1630
1631                 $self->wait_for_start($env);
1632
1633                 $self->{vars}->{s4member} = $env;
1634         }
1635
1636         return $env;
1637 }
1638
1639 sub setup_rpc_proxy($$$)
1640 {
1641         my ($self, $path, $dc_vars) = @_;
1642
1643         my $env = $self->provision_rpc_proxy($path, $dc_vars);
1644
1645         if (defined $env) {
1646                 $self->check_or_start($env, "single");
1647
1648                 $self->wait_for_start($env);
1649
1650                 $self->{vars}->{rpc_proxy} = $env;
1651         }
1652         return $env;
1653 }
1654
1655 sub setup_dc($$)
1656 {
1657         my ($self, $path) = @_;
1658
1659         my $env = $self->provision_dc($path);
1660         if (defined $env) {
1661                 $self->check_or_start($env, "standard");
1662
1663                 $self->wait_for_start($env);
1664
1665                 $self->{vars}->{dc} = $env;
1666         }
1667         return $env;
1668 }
1669
1670 sub setup_chgdcpass($$)
1671 {
1672         my ($self, $path) = @_;
1673
1674         my $env = $self->provision_chgdcpass($path);
1675         if (defined $env) {
1676                 $self->check_or_start($env, "single");
1677
1678                 $self->wait_for_start($env);
1679
1680                 $self->{vars}->{chgdcpass} = $env;
1681         }
1682         return $env;
1683 }
1684
1685 sub setup_fl2000dc($$)
1686 {
1687         my ($self, $path) = @_;
1688
1689         my $env = $self->provision_fl2000dc($path);
1690         if (defined $env) {
1691                 $self->check_or_start($env, "single");
1692
1693                 $self->wait_for_start($env);
1694
1695                 $self->{vars}->{fl2000dc} = $env;
1696         }
1697
1698         return $env;
1699 }
1700
1701 sub setup_fl2003dc($$)
1702 {
1703         my ($self, $path) = @_;
1704
1705         my $env = $self->provision_fl2003dc($path);
1706
1707         if (defined $env) {
1708                 $self->check_or_start($env, "single");
1709
1710                 $self->wait_for_start($env);
1711
1712                 $self->{vars}->{fl2003dc} = $env;
1713         }
1714         return $env;
1715 }
1716
1717 sub setup_fl2008r2dc($$)
1718 {
1719         my ($self, $path) = @_;
1720
1721         my $env = $self->provision_fl2008r2dc($path);
1722
1723         if (defined $env) {
1724                 $self->check_or_start($env, "single");
1725
1726                 $self->wait_for_start($env);
1727
1728                 $self->{vars}->{fl2008r2dc} = $env;
1729         }
1730
1731         return $env;
1732 }
1733
1734 sub setup_vampire_dc($$$)
1735 {
1736         my ($self, $path, $dc_vars) = @_;
1737
1738         my $env = $self->provision_vampire_dc($path, $dc_vars);
1739
1740         if (defined $env) {
1741                 $self->check_or_start($env, "single");
1742
1743                 $self->wait_for_start($env);
1744
1745                 $self->{vars}->{vampire_dc} = $env;
1746
1747                 # force replicated DC to update repsTo/repsFrom
1748                 # for vampired partitions
1749                 my $samba_tool =  Samba::bindir_path($self, "samba-tool");
1750                 my $cmd = "";
1751                 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
1752                 $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
1753                 $cmd .= " $samba_tool drs kcc $env->{DC_SERVER}";
1754                 $cmd .= " $env->{CONFIGURATION}";
1755                 $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
1756                 unless (system($cmd) == 0) {
1757                         warn("Failed to exec kcc\n$cmd");
1758                         return undef;
1759                 }
1760
1761                 # as 'vampired' dc may add data in its local replica
1762                 # we need to synchronize data between DCs
1763                 my $base_dn = "DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
1764                 $cmd = "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
1765                 $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
1766                 $cmd .= " $samba_tool drs replicate $env->{DC_SERVER} $env->{SERVER}";
1767                 $cmd .= " $dc_vars->{CONFIGURATION}";
1768                 $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
1769                 # replicate Configuration NC
1770                 my $cmd_repl = "$cmd \"CN=Configuration,$base_dn\"";
1771                 unless(system($cmd_repl) == 0) {
1772                         warn("Failed to replicate\n$cmd_repl");
1773                         return undef;
1774                 }
1775                 # replicate Default NC
1776                 $cmd_repl = "$cmd \"$base_dn\"";
1777                 unless(system($cmd_repl) == 0) {
1778                         warn("Failed to replicate\n$cmd_repl");
1779                         return undef;
1780                 }
1781         }
1782
1783         return $env;
1784 }
1785
1786 sub setup_promoted_dc($$$)
1787 {
1788         my ($self, $path, $dc_vars) = @_;
1789
1790         my $env = $self->provision_promoted_dc($path, $dc_vars);
1791
1792         if (defined $env) {
1793                 $self->check_or_start($env, "single");
1794
1795                 $self->wait_for_start($env);
1796
1797                 $self->{vars}->{promoted_dc} = $env;
1798
1799                 # force replicated DC to update repsTo/repsFrom
1800                 # for vampired partitions
1801                 my $samba_tool =  Samba::bindir_path($self, "samba-tool");
1802                 my $cmd = "";
1803                 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
1804                 $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
1805                 $cmd .= " $samba_tool drs kcc $env->{DC_SERVER}";
1806                 $cmd .= " $env->{CONFIGURATION}";
1807                 $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
1808                 unless (system($cmd) == 0) {
1809                         warn("Failed to exec kcc\n$cmd");
1810                         return undef;
1811                 }
1812
1813                 # as 'vampired' dc may add data in its local replica
1814                 # we need to synchronize data between DCs
1815                 my $base_dn = "DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
1816                 $cmd = "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
1817                 $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
1818                 $cmd .= " $samba_tool drs replicate $env->{DC_SERVER} $env->{SERVER}";
1819                 $cmd .= " $dc_vars->{CONFIGURATION}";
1820                 $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
1821                 # replicate Configuration NC
1822                 my $cmd_repl = "$cmd \"CN=Configuration,$base_dn\"";
1823                 unless(system($cmd_repl) == 0) {
1824                         warn("Failed to replicate\n$cmd_repl");
1825                         return undef;
1826                 }
1827                 # replicate Default NC
1828                 $cmd_repl = "$cmd \"$base_dn\"";
1829                 unless(system($cmd_repl) == 0) {
1830                         warn("Failed to replicate\n$cmd_repl");
1831                         return undef;
1832                 }
1833         }
1834
1835         return $env;
1836 }
1837
1838 sub setup_subdom_dc($$$)
1839 {
1840         my ($self, $path, $dc_vars) = @_;
1841
1842         my $env = $self->provision_subdom_dc($path, $dc_vars);
1843
1844         if (defined $env) {
1845                 $self->check_or_start($env, "single");
1846
1847                 $self->wait_for_start($env);
1848
1849                 $self->{vars}->{subdom_dc} = $env;
1850
1851                 # force replicated DC to update repsTo/repsFrom
1852                 # for primary domain partitions
1853                 my $samba_tool =  Samba::bindir_path($self, "samba-tool");
1854                 my $cmd = "";
1855                 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
1856                 $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
1857                 $cmd .= " $samba_tool drs kcc $env->{DC_SERVER}";
1858                 $cmd .= " $env->{CONFIGURATION}";
1859                 $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD} --realm=$dc_vars->{DC_REALM}";
1860                 unless (system($cmd) == 0) {
1861                         warn("Failed to exec kcc\n$cmd");
1862                         return undef;
1863                 }
1864
1865                 # as 'subdomain' dc may add data in its local replica
1866                 # we need to synchronize data between DCs
1867                 my $base_dn = "DC=".join(",DC=", split(/\./, $env->{REALM}));
1868                 my $config_dn = "CN=Configuration,DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
1869                 $cmd = "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
1870                 $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
1871                 $cmd .= " $samba_tool drs replicate $env->{DC_SERVER} $env->{SUBDOM_DC_SERVER}";
1872                 $cmd .= " $dc_vars->{CONFIGURATION}";
1873                 $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD} --realm=$dc_vars->{DC_REALM}";
1874                 # replicate Configuration NC
1875                 my $cmd_repl = "$cmd \"$config_dn\"";
1876                 unless(system($cmd_repl) == 0) {
1877                         warn("Failed to replicate\n$cmd_repl");
1878                         return undef;
1879                 }
1880                 # replicate Default NC
1881                 $cmd_repl = "$cmd \"$base_dn\"";
1882                 unless(system($cmd_repl) == 0) {
1883                         warn("Failed to replicate\n$cmd_repl");
1884                         return undef;
1885                 }
1886         }
1887
1888         return $env;
1889 }
1890
1891 sub setup_rodc($$$)
1892 {
1893         my ($self, $path, $dc_vars) = @_;
1894
1895         my $env = $self->provision_rodc($path, $dc_vars);
1896
1897         unless ($env) {
1898                 return undef;
1899         }
1900
1901         $self->check_or_start($env, "single");
1902
1903         $self->wait_for_start($env);
1904
1905         $self->{vars}->{rodc} = $env;
1906
1907         return $env;
1908 }
1909
1910 sub setup_plugin_s4_dc($$)
1911 {
1912         my ($self, $path) = @_;
1913
1914         # If we didn't build with ADS, pretend this env was never available
1915         if (not $self->{target3}->have_ads()) {
1916                return "UNKNOWN";
1917         }
1918
1919         my $env = $self->provision_plugin_s4_dc($path);
1920         unless ($env) {
1921                 return undef;
1922         }
1923
1924         $self->check_or_start($env, "single");
1925
1926         $self->wait_for_start($env);
1927
1928         $self->{vars}->{plugin_s4_dc} = $env;
1929         return $env;
1930 }
1931
1932 sub setup_none($$)
1933 {
1934         my ($self, $path) = @_;
1935
1936         my $ret = {
1937                 KRB5_CONFIG => abs_path($path) . "/no_krb5.conf",
1938                 SAMBA_PID => -1,
1939         }
1940 }
1941
1942 1;