selftest/target/Samba3.pm

   1 #!/usr/bin/perl
   2 # Bootstrap Samba and run a number of tests against it.
   3 # Copyright (C) 2005-2007 Jelmer Vernooij <jelmer@samba.org>
   4 # Published under the GNU GPL, v3 or later.
   5
   6 # NOTE: Refer to the README for more details about the various testenvs,
   7 # and tips about adding new testenvs.
   8
   9 package Samba3;
  10
  11 use strict;
  12 use warnings;
  13 use Cwd qw(abs_path);
  14 use FindBin qw($RealBin);
  15 use POSIX;
  16 use target::Samba;
  17 use File::Path 'remove_tree';
  18
  19 sub have_ads($) {
  20         my ($self) = @_;
  21         my $found_ads = 0;
  22         my $smbd_build_options = Samba::bindir_path($self, "smbd") . " -b|";
  23         open(IN, $smbd_build_options) or die("Unable to run $smbd_build_options: $!");
  24
  25         while (<IN>) {
  26                 if (/WITH_ADS/) {
  27                        $found_ads = 1;
  28                 }
  29         }
  30         close IN;
  31
  32         # If we were not built with ADS support, pretend we were never even available
  33         print "smbd does not have ADS support\n" unless $found_ads;
  34         return $found_ads;
  35 }
  36
  37 # return smb.conf parameters applicable to @path, based on the underlying
  38 # filesystem type
  39 sub get_fs_specific_conf($$)
  40 {
  41         my ($self, $path) = @_;
  42         my $mods = "";
  43         my $stat_out = `stat --file-system $path` or return "";
  44
  45         if ($stat_out =~ m/Type:\s+btrfs/) {
  46                 $mods .= "streams_xattr btrfs";
  47         }
  48
  49         if ($mods) {
  50                 return "vfs objects = $mods";
  51         }
  52
  53         return '';
  54 }
  55
  56 sub new($$) {
  57         my ($classname, $SambaCtx, $bindir, $srcdir, $server_maxtime) = @_;
  58         my $self = { vars => {},
  59                      SambaCtx => $SambaCtx,
  60                      bindir => $bindir,
  61                      srcdir => $srcdir,
  62                      server_maxtime => $server_maxtime
  63         };
  64         bless $self;
  65         return $self;
  66 }
  67
  68 sub teardown_env($$)
  69 {
  70         my ($self, $envvars) = @_;
  71
  72         if (defined($envvars->{CTDB_PREFIX})) {
  73                 $self->teardown_env_ctdb($envvars);
  74         } else {
  75                 $self->teardown_env_samba($envvars);
  76         }
  77
  78         return;
  79 }
  80
  81 sub teardown_env_samba($$)
  82 {
  83         my ($self, $envvars) = @_;
  84         my $count = 0;
  85
  86         # This should cause smbd to terminate gracefully
  87         close($envvars->{STDIN_PIPE});
  88
  89         my $smbdpid = $envvars->{SMBD_TL_PID};
  90         my $nmbdpid = $envvars->{NMBD_TL_PID};
  91         my $winbinddpid = $envvars->{WINBINDD_TL_PID};
  92
  93         # This should give it time to write out the gcov data
  94         until ($count > 20) {
  95             my $smbdchild = Samba::cleanup_child($smbdpid, "smbd");
  96             my $nmbdchild = Samba::cleanup_child($nmbdpid, "nmbd");
  97             my $winbinddchild = Samba::cleanup_child($winbinddpid, "winbindd");
  98             if ($smbdchild == -1
  99                 && $nmbdchild == -1
 100                 && $winbinddchild == -1) {
 101                 last;
 102             }
 103             sleep(1);
 104             $count++;
 105         }
 106
 107         if ($count <= 20 && kill(0, $smbdpid, $nmbdpid, $winbinddpid) == 0) {
 108             return;
 109         }
 110
 111         $self->stop_sig_term($smbdpid);
 112         $self->stop_sig_term($nmbdpid);
 113         $self->stop_sig_term($winbinddpid);
 114
 115         $count = 0;
 116         until ($count > 10) {
 117             my $smbdchild = Samba::cleanup_child($smbdpid, "smbd");
 118             my $nmbdchild = Samba::cleanup_child($nmbdpid, "nmbd");
 119             my $winbinddchild = Samba::cleanup_child($winbinddpid, "winbindd");
 120             if ($smbdchild == -1
 121                 && $nmbdchild == -1
 122                 && $winbinddchild == -1) {
 123                 last;
 124             }
 125             sleep(1);
 126             $count++;
 127         }
 128
 129         if ($count <= 10 && kill(0, $smbdpid, $nmbdpid, $winbinddpid) == 0) {
 130             return;
 131         }
 132
 133         warn("timelimit process did not quit on SIGTERM, sending SIGKILL");
 134         $self->stop_sig_kill($smbdpid);
 135         $self->stop_sig_kill($nmbdpid);
 136         $self->stop_sig_kill($winbinddpid);
 137
 138         return 0;
 139 }
 140
 141 sub teardown_env_ctdb($$)
 142 {
 143         my ($self, $data) = @_;
 144
 145         if (defined($data->{SAMBA_NODES})) {
 146                 my $num_nodes = $data->{NUM_NODES};
 147                 my $nodes = $data->{SAMBA_NODES};
 148
 149                 for (my $i = 0; $i < $num_nodes; $i++) {
 150                         if (defined($nodes->[$i])) {
 151                                 $self->teardown_env_samba($nodes->[$i]);
 152                         }
 153                 }
 154         }
 155
 156         close($data->{CTDB_STDIN_PIPE});
 157
 158         if (not defined($data->{SAMBA_NODES})) {
 159                 # Give waiting children time to exit
 160                 sleep(5);
 161         }
 162
 163         return 0;
 164 }
 165
 166 sub getlog_env_app($$$)
 167 {
 168         my ($self, $envvars, $name) = @_;
 169
 170         my $title = "$name LOG of: $envvars->{NETBIOSNAME}\n";
 171         my $out = $title;
 172
 173         open(LOG, "<".$envvars->{$name."_TEST_LOG"});
 174
 175         seek(LOG, $envvars->{$name."_TEST_LOG_POS"}, SEEK_SET);
 176         while (<LOG>) {
 177                 $out .= $_;
 178         }
 179         $envvars->{$name."_TEST_LOG_POS"} = tell(LOG);
 180         close(LOG);
 181
 182         return "" if $out eq $title;
 183
 184         return $out;
 185 }
 186
 187 sub getlog_env($$)
 188 {
 189         my ($self, $envvars) = @_;
 190         my $ret = "";
 191
 192         $ret .= $self->getlog_env_app($envvars, "SMBD");
 193         $ret .= $self->getlog_env_app($envvars, "NMBD");
 194         $ret .= $self->getlog_env_app($envvars, "WINBINDD");
 195
 196         return $ret;
 197 }
 198
 199 sub check_env($$)
 200 {
 201         my ($self, $envvars) = @_;
 202
 203         my $childpid = waitpid(-1, WNOHANG);
 204
 205         # TODO ...
 206         return 1;
 207 }
 208
 209 # Declare the environments Samba3 makes available.
 210 # To be set up, they will be called as
 211 #   samba3->setup_$envname($self, $path, $dep_1_vars, $dep_2_vars, ...)
 212 %Samba3::ENV_DEPS = (
 213         # name              => [dep_1, dep_2, ...],
 214         nt4_dc              => [],
 215         nt4_dc_schannel     => [],
 216
 217         simpleserver        => [],
 218         fileserver          => [],
 219         maptoguest          => [],
 220         ktest               => [],
 221
 222         nt4_member          => ["nt4_dc"],
 223
 224         ad_member           => ["ad_dc", "fl2008r2dc", "fl2003dc"],
 225         ad_member_rfc2307   => ["ad_dc_ntvfs"],
 226         ad_member_idmap_rid => ["ad_dc"],
 227         ad_member_idmap_ad  => ["fl2008r2dc"],
 228
 229         clusteredmember     => ["nt4_dc"],
 230 );
 231
 232 %Samba3::ENV_DEPS_POST = ();
 233
 234 sub setup_nt4_dc
 235 {
 236         my ($self, $path) = @_;
 237
 238         print "PROVISIONING NT4 DC...";
 239
 240         my $nt4_dc_options = "
 241         domain master = yes
 242         domain logons = yes
 243         lanman auth = yes
 244         ntlm auth = yes
 245         raw NTLMv2 auth = yes
 246         server schannel = auto
 247
 248         rpc_server:epmapper = external
 249         rpc_server:spoolss = external
 250         rpc_server:lsarpc = external
 251         rpc_server:samr = external
 252         rpc_server:netlogon = external
 253         rpc_server:register_embedded_np = yes
 254         rpc_server:FssagentRpc = external
 255
 256         rpc_daemon:epmd = fork
 257         rpc_daemon:spoolssd = fork
 258         rpc_daemon:lsasd = fork
 259         rpc_daemon:fssd = fork
 260         fss: sequence timeout = 1
 261         check parent directory delete on close = yes
 262 ";
 263
 264         my $vars = $self->provision(
 265             prefix => $path,
 266             domain => "SAMBA-TEST",
 267             server => "LOCALNT4DC2",
 268             password => "localntdc2pass",
 269             extra_options => $nt4_dc_options);
 270
 271         $vars or return undef;
 272
 273         if (not $self->check_or_start(
 274                 env_vars => $vars,
 275                 nmbd => "yes",
 276                 winbindd => "yes",
 277                 smbd => "yes")) {
 278                return undef;
 279         }
 280
 281         $vars->{DOMSID} = $vars->{SAMSID};
 282         $vars->{DC_SERVER} = $vars->{SERVER};
 283         $vars->{DC_SERVER_IP} = $vars->{SERVER_IP};
 284         $vars->{DC_SERVER_IPV6} = $vars->{SERVER_IPV6};
 285         $vars->{DC_NETBIOSNAME} = $vars->{NETBIOSNAME};
 286         $vars->{DC_USERNAME} = $vars->{USERNAME};
 287         $vars->{DC_PASSWORD} = $vars->{PASSWORD};
 288
 289         return $vars;
 290 }
 291
 292 sub setup_nt4_dc_schannel
 293 {
 294         my ($self, $path) = @_;
 295
 296         print "PROVISIONING NT4 DC WITH SERVER SCHANNEL ...";
 297
 298         my $pdc_options = "
 299         domain master = yes
 300         domain logons = yes
 301         lanman auth = yes
 302
 303         rpc_server:epmapper = external
 304         rpc_server:spoolss = external
 305         rpc_server:lsarpc = external
 306         rpc_server:samr = external
 307         rpc_server:netlogon = external
 308         rpc_server:register_embedded_np = yes
 309
 310         rpc_daemon:epmd = fork
 311         rpc_daemon:spoolssd = fork
 312         rpc_daemon:lsasd = fork
 313
 314         server schannel = yes
 315         # used to reproduce bug #12772
 316         server max protocol = SMB2_02
 317 ";
 318
 319         my $vars = $self->provision(
 320             prefix => $path,
 321             domain => "NT4SCHANNEL",
 322             server => "LOCALNT4DC9",
 323             password => "localntdc9pass",
 324             extra_options => $pdc_options);
 325
 326         $vars or return undef;
 327
 328         if (not $self->check_or_start(
 329                 env_vars => $vars,
 330                 nmbd => "yes",
 331                 winbindd => "yes",
 332                 smbd => "yes")) {
 333                return undef;
 334         }
 335
 336         $vars->{DOMSID} = $vars->{SAMSID};
 337         $vars->{DC_SERVER} = $vars->{SERVER};
 338         $vars->{DC_SERVER_IP} = $vars->{SERVER_IP};
 339         $vars->{DC_SERVER_IPV6} = $vars->{SERVER_IPV6};
 340         $vars->{DC_NETBIOSNAME} = $vars->{NETBIOSNAME};
 341         $vars->{DC_USERNAME} = $vars->{USERNAME};
 342         $vars->{DC_PASSWORD} = $vars->{PASSWORD};
 343
 344         return $vars;
 345 }
 346
 347 sub setup_nt4_member
 348 {
 349         my ($self, $prefix, $nt4_dc_vars) = @_;
 350         my $count = 0;
 351         my $rc;
 352
 353         print "PROVISIONING MEMBER...";
 354
 355         my $require_mutexes = "dbwrap_tdb_require_mutexes:* = yes";
 356         if ($ENV{SELFTEST_DONT_REQUIRE_TDB_MUTEX_SUPPORT} // '' eq "1") {
 357                 $require_mutexes = "";
 358         }
 359
 360         my $member_options = "
 361         security = domain
 362         dbwrap_tdb_mutexes:* = yes
 363         ${require_mutexes}
 364 ";
 365         my $ret = $self->provision(
 366             prefix => $prefix,
 367             domain => $nt4_dc_vars->{DOMAIN},
 368             server => "LOCALNT4MEMBER3",
 369             password => "localnt4member3pass",
 370             extra_options => $member_options);
 371
 372         $ret or return undef;
 373
 374         my $nmblookup = Samba::bindir_path($self, "nmblookup");
 375         do {
 376                 print "Waiting for the LOGON SERVER registration ...\n";
 377                 $rc = system("$nmblookup $ret->{CONFIGURATION} $ret->{DOMAIN}\#1c");
 378                 if ($rc != 0) {
 379                         sleep(1);
 380                 }
 381                 $count++;
 382         } while ($rc != 0 && $count < 10);
 383         if ($count == 10) {
 384                 print "NMBD not reachable after 10 retries\n";
 385                 teardown_env($self, $ret);
 386                 return 0;
 387         }
 388
 389         my $net = Samba::bindir_path($self, "net");
 390         # Add hosts file for name lookups
 391         my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
 392         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 393         $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
 394         $cmd .= "$net rpc join $ret->{CONFIGURATION} $nt4_dc_vars->{DOMAIN} member";
 395         $cmd .= " -U$nt4_dc_vars->{USERNAME}\%$nt4_dc_vars->{PASSWORD}";
 396
 397         if (system($cmd) != 0) {
 398             warn("Join failed\n$cmd");
 399             return undef;
 400         }
 401
 402         # Add hosts file for name lookups
 403         $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
 404         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 405         $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
 406         $cmd .= "$net $ret->{CONFIGURATION} primarytrust dumpinfo | grep -q 'REDACTED SECRET VALUES'";
 407
 408         if (system($cmd) != 0) {
 409             warn("check failed\n$cmd");
 410             return undef;
 411         }
 412
 413         if (not $self->check_or_start(
 414                 env_vars => $ret,
 415                 nmbd => "yes",
 416                 winbindd => "yes",
 417                 smbd => "yes")) {
 418                return undef;
 419         }
 420
 421         $ret->{DOMSID} = $nt4_dc_vars->{DOMSID};
 422         $ret->{DC_SERVER} = $nt4_dc_vars->{SERVER};
 423         $ret->{DC_SERVER_IP} = $nt4_dc_vars->{SERVER_IP};
 424         $ret->{DC_SERVER_IPV6} = $nt4_dc_vars->{SERVER_IPV6};
 425         $ret->{DC_NETBIOSNAME} = $nt4_dc_vars->{NETBIOSNAME};
 426         $ret->{DC_USERNAME} = $nt4_dc_vars->{USERNAME};
 427         $ret->{DC_PASSWORD} = $nt4_dc_vars->{PASSWORD};
 428
 429         return $ret;
 430 }
 431
 432 sub setup_clusteredmember
 433 {
 434         my ($self, $prefix, $nt4_dc_vars) = @_;
 435         my $count = 0;
 436         my $rc;
 437         my @retvals = ();
 438         my $ret;
 439
 440         print "PROVISIONING CLUSTEREDMEMBER...\n";
 441
 442         my $prefix_abs = abs_path($prefix);
 443         mkdir($prefix_abs, 0777);
 444
 445         my $server_name = "CLUSTEREDMEMBER";
 446
 447         my $ctdb_data = $self->setup_ctdb($prefix);
 448
 449         if (not $ctdb_data) {
 450                 print "No ctdb data\n";
 451                 return undef;
 452         }
 453
 454         print "PROVISIONING CLUSTERED SAMBA...\n";
 455
 456         my $num_nodes = $ctdb_data->{NUM_NODES};
 457         my $nodes = $ctdb_data->{CTDB_NODES};
 458
 459         # Enable cleanup of earlier nodes if a later node fails
 460         $ctdb_data->{SAMBA_NODES} = \@retvals;
 461
 462         for (my $i = 0; $i < $num_nodes; $i++) {
 463                 my $node = $nodes->[$i];
 464                 my $socket = $node->{SOCKET_FILE};
 465                 my $server_name = $node->{SERVER_NAME};
 466                 my $pub_iface = $node->{SOCKET_WRAPPER_DEFAULT_IFACE};
 467                 my $node_prefix = $node->{NODE_PREFIX};
 468
 469                 print "NODE_PREFIX=${node_prefix}\n";
 470                 print "SOCKET=${socket}\n";
 471
 472                 my $require_mutexes = "dbwrap_tdb_require_mutexes:* = yes";
 473                 if ($ENV{SELFTEST_DONT_REQUIRE_TDB_MUTEX_SUPPORT} // '' eq "1") {
 474                         $require_mutexes = "" ;
 475                 }
 476
 477                 my $member_options = "
 478        security = domain
 479        server signing = on
 480        clustering = yes
 481        ctdbd socket = ${socket}
 482        dbwrap_tdb_mutexes:* = yes
 483        ${require_mutexes}
 484 ";
 485
 486                 my $node_ret = $self->provision(
 487                     prefix => "$node_prefix",
 488                     domain => $nt4_dc_vars->{DOMAIN},
 489                     server => "$server_name",
 490                     password => "clustermember8pass",
 491                     netbios_name => "CLUSTEREDMEMBER",
 492                     share_dir => "${prefix_abs}/shared",
 493                     extra_options => $member_options,
 494                     no_delete_prefix => 1);
 495                 if (not $node_ret) {
 496                         print "Provision node $i failed\n";
 497                         teardown_env($self, $ctdb_data);
 498                         return undef;
 499                 }
 500
 501                 my $nmblookup = Samba::bindir_path($self, "nmblookup");
 502                 do {
 503                         print "Waiting for the LOGON SERVER registration ...\n";
 504                         $rc = system("$nmblookup $node_ret->{CONFIGURATION} " .
 505                                      "$node_ret->{DOMAIN}\#1c");
 506                         if ($rc != 0) {
 507                                 sleep(1);
 508                         }
 509                         $count++;
 510                 } while ($rc != 0 && $count < 10);
 511
 512                 if ($count == 10) {
 513                         print "NMBD not reachable after 10 retries\n";
 514                         teardown_env($self, $node_ret);
 515                         teardown_env($self, $ctdb_data);
 516                         return undef;
 517                 }
 518
 519                 push(@retvals, $node_ret);
 520         }
 521
 522         $ret = {%$ctdb_data, %{$retvals[0]}};
 523
 524         my $net = Samba::bindir_path($self, "net");
 525         my $cmd = "";
 526         $cmd .= "UID_WRAPPER_ROOT=1 ";
 527         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 528         $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
 529         $cmd .= "$net join $ret->{CONFIGURATION} $nt4_dc_vars->{DOMAIN} member";
 530         $cmd .= " -U$nt4_dc_vars->{USERNAME}\%$nt4_dc_vars->{PASSWORD}";
 531
 532         if (system($cmd) != 0) {
 533                 warn("Join failed\n$cmd");
 534                 teardown_env($self, $ret);
 535                 return undef;
 536         }
 537
 538         for (my $i=0; $i<@retvals; $i++) {
 539                 my $node_provision = $retvals[$i];
 540                 my $ok;
 541                 $ok = $self->check_or_start(
 542                     env_vars => $node_provision,
 543                     winbindd => "yes",
 544                     smbd => "yes",
 545                     child_cleanup => sub {
 546                         map {
 547                             my $fh = $_->{STDIN_PIPE};
 548                             close($fh) if defined($fh);
 549                         } @retvals });
 550                 if (not $ok) {
 551                         teardown_env($self, $ret);
 552                         return undef;
 553                 }
 554         }
 555
 556         $ret->{DOMSID} = $nt4_dc_vars->{DOMSID};
 557         $ret->{DC_SERVER} = $nt4_dc_vars->{SERVER};
 558         $ret->{DC_SERVER_IP} = $nt4_dc_vars->{SERVER_IP};
 559         $ret->{DC_SERVER_IPV6} = $nt4_dc_vars->{SERVER_IPV6};
 560         $ret->{DC_NETBIOSNAME} = $nt4_dc_vars->{NETBIOSNAME};
 561         $ret->{DC_USERNAME} = $nt4_dc_vars->{USERNAME};
 562         $ret->{DC_PASSWORD} = $nt4_dc_vars->{PASSWORD};
 563
 564         return $ret;
 565 }
 566
 567 sub setup_ad_member
 568 {
 569         my ($self, $prefix, $dcvars, $trustvars_f, $trustvars_e) = @_;
 570
 571         my $prefix_abs = abs_path($prefix);
 572         my @dirs = ();
 573
 574         # If we didn't build with ADS, pretend this env was never available
 575         if (not $self->have_ads()) {
 576                 return "UNKNOWN";
 577         }
 578
 579         print "PROVISIONING S3 AD MEMBER...";
 580
 581         mkdir($prefix_abs, 0777);
 582
 583         my $share_dir="$prefix_abs/share";
 584         push(@dirs, $share_dir);
 585
 586         my $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}";
 587         push(@dirs, $substitution_path);
 588
 589         $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/U_alice";
 590         push(@dirs, $substitution_path);
 591
 592         $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/U_alice/G_domain users";
 593         push(@dirs, $substitution_path);
 594
 595         # Using '/' as the winbind separator is a bad idea ...
 596         $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/u_$dcvars->{DOMAIN}";
 597         push(@dirs, $substitution_path);
 598
 599         $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/u_$dcvars->{DOMAIN}/alice";
 600         push(@dirs, $substitution_path);
 601
 602         $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/u_$dcvars->{DOMAIN}/alice/g_$dcvars->{DOMAIN}";
 603         push(@dirs, $substitution_path);
 604
 605         $substitution_path = "$share_dir/D_$dcvars->{DOMAIN}/u_$dcvars->{DOMAIN}/alice/g_$dcvars->{DOMAIN}/domain users";
 606         push(@dirs, $substitution_path);
 607
 608         my $member_options = "
 609         security = ads
 610         workgroup = $dcvars->{DOMAIN}
 611         realm = $dcvars->{REALM}
 612         netbios aliases = foo bar
 613         template homedir = /home/%D/%G/%U
 614         auth event notification = true
 615         password server = $dcvars->{SERVER}
 616         winbind scan trusted domains = no
 617         winbind use krb5 enterprise principals = yes
 618
 619 [sub_dug]
 620         path = $share_dir/D_%D/U_%U/G_%G
 621         writeable = yes
 622
 623 [sub_dug2]
 624         path = $share_dir/D_%D/u_%u/g_%g
 625         writeable = yes
 626
 627 ";
 628
 629         my $ret = $self->provision(
 630             prefix => $prefix,
 631             domain => $dcvars->{DOMAIN},
 632             server => "LOCALADMEMBER",
 633             password => "loCalMemberPass",
 634             extra_options => $member_options,
 635             dc_server_ip => $dcvars->{SERVER_IP},
 636             dc_server_ipv6 => $dcvars->{SERVER_IPV6});
 637
 638         $ret or return undef;
 639
 640         mkdir($_, 0777) foreach(@dirs);
 641
 642         close(USERMAP);
 643         $ret->{DOMAIN} = $dcvars->{DOMAIN};
 644         $ret->{REALM} = $dcvars->{REALM};
 645         $ret->{DOMSID} = $dcvars->{DOMSID};
 646
 647         my $ctx;
 648         $ctx = {};
 649         $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
 650         $ctx->{domain} = $dcvars->{DOMAIN};
 651         $ctx->{realm} = $dcvars->{REALM};
 652         $ctx->{dnsname} = lc($dcvars->{REALM});
 653         $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
 654         $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
 655         $ctx->{krb5_ccname} = "$prefix_abs/krb5cc_%{uid}";
 656         Samba::mk_krb5_conf($ctx, "");
 657
 658         $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
 659         $ret->{RESOLV_CONF} = $dcvars->{RESOLV_CONF};
 660
 661         my $net = Samba::bindir_path($self, "net");
 662         # Add hosts file for name lookups
 663         my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
 664         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 665         if (defined($ret->{RESOLV_WRAPPER_CONF})) {
 666                 $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
 667         } else {
 668                 $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
 669         }
 670         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
 671         $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
 672         $cmd .= "$net join $ret->{CONFIGURATION}";
 673         $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
 674
 675         if (system($cmd) != 0) {
 676             warn("Join failed\n$cmd");
 677             return undef;
 678         }
 679
 680         # We need world access to this share, as otherwise the domain
 681         # administrator from the AD domain provided by Samba4 can't
 682         # access the share for tests.
 683         chmod 0777, "$prefix/share";
 684
 685         if (not $self->check_or_start(
 686                 env_vars => $ret,
 687                 nmbd => "yes",
 688                 winbindd => "yes",
 689                 smbd => "yes")) {
 690                 return undef;
 691         }
 692
 693         $ret->{DC_SERVER} = $dcvars->{SERVER};
 694         $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
 695         $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
 696         $ret->{DC_SERVERCONFFILE} = $dcvars->{SERVERCONFFILE};
 697         $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
 698         $ret->{DC_USERNAME} = $dcvars->{USERNAME};
 699         $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
 700
 701         # forest trust
 702         $ret->{TRUST_F_BOTH_SERVER} = $trustvars_f->{SERVER};
 703         $ret->{TRUST_F_BOTH_SERVER_IP} = $trustvars_f->{SERVER_IP};
 704         $ret->{TRUST_F_BOTH_SERVER_IPV6} = $trustvars_f->{SERVER_IPV6};
 705         $ret->{TRUST_F_BOTH_NETBIOSNAME} = $trustvars_f->{NETBIOSNAME};
 706         $ret->{TRUST_F_BOTH_USERNAME} = $trustvars_f->{USERNAME};
 707         $ret->{TRUST_F_BOTH_PASSWORD} = $trustvars_f->{PASSWORD};
 708         $ret->{TRUST_F_BOTH_DOMAIN} = $trustvars_f->{DOMAIN};
 709         $ret->{TRUST_F_BOTH_REALM} = $trustvars_f->{REALM};
 710
 711         # external trust
 712         $ret->{TRUST_E_BOTH_SERVER} = $trustvars_e->{SERVER};
 713         $ret->{TRUST_E_BOTH_SERVER_IP} = $trustvars_e->{SERVER_IP};
 714         $ret->{TRUST_E_BOTH_SERVER_IPV6} = $trustvars_e->{SERVER_IPV6};
 715         $ret->{TRUST_E_BOTH_NETBIOSNAME} = $trustvars_e->{NETBIOSNAME};
 716         $ret->{TRUST_E_BOTH_USERNAME} = $trustvars_e->{USERNAME};
 717         $ret->{TRUST_E_BOTH_PASSWORD} = $trustvars_e->{PASSWORD};
 718         $ret->{TRUST_E_BOTH_DOMAIN} = $trustvars_e->{DOMAIN};
 719         $ret->{TRUST_E_BOTH_REALM} = $trustvars_e->{REALM};
 720
 721         return $ret;
 722 }
 723
 724 sub setup_ad_member_rfc2307
 725 {
 726         my ($self, $prefix, $dcvars) = @_;
 727
 728         # If we didn't build with ADS, pretend this env was never available
 729         if (not $self->have_ads()) {
 730                 return "UNKNOWN";
 731         }
 732
 733         print "PROVISIONING S3 AD MEMBER WITH idmap_rfc2307 config...";
 734
 735         my $member_options = "
 736         security = ads
 737         workgroup = $dcvars->{DOMAIN}
 738         realm = $dcvars->{REALM}
 739         idmap cache time = 0
 740         idmap negative cache time = 0
 741         idmap config * : backend = autorid
 742         idmap config * : range = 1000000-1999999
 743         idmap config * : rangesize = 100000
 744         idmap config $dcvars->{DOMAIN} : backend = rfc2307
 745         idmap config $dcvars->{DOMAIN} : range = 2000000-2999999
 746         idmap config $dcvars->{DOMAIN} : ldap_server = ad
 747         idmap config $dcvars->{DOMAIN} : bind_path_user = ou=idmap,dc=samba,dc=example,dc=com
 748         idmap config $dcvars->{DOMAIN} : bind_path_group = ou=idmap,dc=samba,dc=example,dc=com
 749
 750         password server = $dcvars->{SERVER}
 751 ";
 752
 753         my $ret = $self->provision(
 754             prefix => $prefix,
 755             domain => $dcvars->{DOMAIN},
 756             server => "RFC2307MEMBER",
 757             password => "loCalMemberPass",
 758             extra_options => $member_options,
 759             dc_server_ip => $dcvars->{SERVER_IP},
 760             dc_server_ipv6 => $dcvars->{SERVER_IPV6});
 761
 762         $ret or return undef;
 763
 764         close(USERMAP);
 765         $ret->{DOMAIN} = $dcvars->{DOMAIN};
 766         $ret->{REALM} = $dcvars->{REALM};
 767         $ret->{DOMSID} = $dcvars->{DOMSID};
 768
 769         my $ctx;
 770         my $prefix_abs = abs_path($prefix);
 771         $ctx = {};
 772         $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
 773         $ctx->{domain} = $dcvars->{DOMAIN};
 774         $ctx->{realm} = $dcvars->{REALM};
 775         $ctx->{dnsname} = lc($dcvars->{REALM});
 776         $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
 777         $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
 778         $ctx->{krb5_ccname} = "$prefix_abs/krb5cc_%{uid}";
 779         Samba::mk_krb5_conf($ctx, "");
 780
 781         $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
 782         $ret->{RESOLV_CONF} = $dcvars->{RESOLV_CONF};
 783
 784         my $net = Samba::bindir_path($self, "net");
 785         # Add hosts file for name lookups
 786         my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
 787         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 788         if (defined($ret->{RESOLV_WRAPPER_CONF})) {
 789                 $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
 790         } else {
 791                 $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
 792         }
 793         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
 794         $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
 795         $cmd .= "$net join $ret->{CONFIGURATION}";
 796         $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
 797
 798         if (system($cmd) != 0) {
 799             warn("Join failed\n$cmd");
 800             return undef;
 801         }
 802
 803         # We need world access to this share, as otherwise the domain
 804         # administrator from the AD domain provided by Samba4 can't
 805         # access the share for tests.
 806         chmod 0777, "$prefix/share";
 807
 808         if (not $self->check_or_start(
 809                 env_vars => $ret,
 810                 nmbd => "yes",
 811                 winbindd => "yes",
 812                 smbd => "yes")) {
 813                 return undef;
 814         }
 815
 816         $ret->{DC_SERVER} = $dcvars->{SERVER};
 817         $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
 818         $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
 819         $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
 820         $ret->{DC_USERNAME} = $dcvars->{USERNAME};
 821         $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
 822
 823         return $ret;
 824 }
 825
 826 sub setup_ad_member_idmap_rid
 827 {
 828         my ($self, $prefix, $dcvars) = @_;
 829
 830         # If we didn't build with ADS, pretend this env was never available
 831         if (not $self->have_ads()) {
 832                 return "UNKNOWN";
 833         }
 834
 835         print "PROVISIONING S3 AD MEMBER WITH idmap_rid config...";
 836
 837         my $member_options = "
 838         security = ads
 839         workgroup = $dcvars->{DOMAIN}
 840         realm = $dcvars->{REALM}
 841         idmap config * : backend = tdb
 842         idmap config * : range = 1000000-1999999
 843         idmap config $dcvars->{DOMAIN} : backend = rid
 844         idmap config $dcvars->{DOMAIN} : range = 2000000-2999999
 845         # Prevent overridding the provisioned lib/krb5.conf which sets certain
 846         # values required for tests to succeed
 847         create krb5 conf = no
 848         map to guest = bad user
 849 ";
 850
 851         my $ret = $self->provision(
 852             prefix => $prefix,
 853             domain => $dcvars->{DOMAIN},
 854             server => "IDMAPRIDMEMBER",
 855             password => "loCalMemberPass",
 856             extra_options => $member_options,
 857             dc_server_ip => $dcvars->{SERVER_IP},
 858             dc_server_ipv6 => $dcvars->{SERVER_IPV6});
 859
 860         $ret or return undef;
 861
 862         close(USERMAP);
 863         $ret->{DOMAIN} = $dcvars->{DOMAIN};
 864         $ret->{REALM} = $dcvars->{REALM};
 865         $ret->{DOMSID} = $dcvars->{DOMSID};
 866
 867         my $ctx;
 868         my $prefix_abs = abs_path($prefix);
 869         $ctx = {};
 870         $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
 871         $ctx->{domain} = $dcvars->{DOMAIN};
 872         $ctx->{realm} = $dcvars->{REALM};
 873         $ctx->{dnsname} = lc($dcvars->{REALM});
 874         $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
 875         $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
 876         $ctx->{krb5_ccname} = "$prefix_abs/krb5cc_%{uid}";
 877         Samba::mk_krb5_conf($ctx, "");
 878
 879         $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
 880         $ret->{RESOLV_CONF} = $dcvars->{RESOLV_CONF};
 881
 882         my $net = Samba::bindir_path($self, "net");
 883         # Add hosts file for name lookups
 884         my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
 885         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 886         if (defined($ret->{RESOLV_WRAPPER_CONF})) {
 887                 $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
 888         } else {
 889                 $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
 890         }
 891         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
 892         $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
 893         $cmd .= "$net join $ret->{CONFIGURATION}";
 894         $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
 895
 896         if (system($cmd) != 0) {
 897             warn("Join failed\n$cmd");
 898             return undef;
 899         }
 900
 901         # We need world access to this share, as otherwise the domain
 902         # administrator from the AD domain provided by Samba4 can't
 903         # access the share for tests.
 904         chmod 0777, "$prefix/share";
 905
 906         if (not $self->check_or_start(
 907                 env_vars => $ret,
 908                 nmbd => "yes",
 909                 winbindd => "yes",
 910                 smbd => "yes")) {
 911                 return undef;
 912         }
 913
 914         $ret->{DC_SERVER} = $dcvars->{SERVER};
 915         $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
 916         $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
 917         $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
 918         $ret->{DC_USERNAME} = $dcvars->{USERNAME};
 919         $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
 920
 921         return $ret;
 922 }
 923
 924 sub setup_ad_member_idmap_ad
 925 {
 926         my ($self, $prefix, $dcvars) = @_;
 927
 928         # If we didn't build with ADS, pretend this env was never available
 929         if (not $self->have_ads()) {
 930                 return "UNKNOWN";
 931         }
 932
 933         print "PROVISIONING S3 AD MEMBER WITH idmap_ad config...";
 934
 935         my $member_options = "
 936         security = ads
 937         workgroup = $dcvars->{DOMAIN}
 938         realm = $dcvars->{REALM}
 939         password server = $dcvars->{SERVER}
 940         idmap config * : backend = tdb
 941         idmap config * : range = 1000000-1999999
 942         idmap config $dcvars->{DOMAIN} : backend = ad
 943         idmap config $dcvars->{DOMAIN} : range = 2000000-2999999
 944         idmap config $dcvars->{TRUST_DOMAIN} : backend = ad
 945         idmap config $dcvars->{TRUST_DOMAIN} : range = 2000000-2999999
 946 ";
 947
 948         my $ret = $self->provision(
 949             prefix => $prefix,
 950             domain => $dcvars->{DOMAIN},
 951             server => "IDMAPADMEMBER",
 952             password => "loCalMemberPass",
 953             extra_options => $member_options,
 954             dc_server_ip => $dcvars->{SERVER_IP},
 955             dc_server_ipv6 => $dcvars->{SERVER_IPV6});
 956
 957         $ret or return undef;
 958
 959         close(USERMAP);
 960         $ret->{DOMAIN} = $dcvars->{DOMAIN};
 961         $ret->{REALM} = $dcvars->{REALM};
 962         $ret->{DOMSID} = $dcvars->{DOMSID};
 963
 964         my $ctx;
 965         my $prefix_abs = abs_path($prefix);
 966         $ctx = {};
 967         $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
 968         $ctx->{domain} = $dcvars->{DOMAIN};
 969         $ctx->{realm} = $dcvars->{REALM};
 970         $ctx->{dnsname} = lc($dcvars->{REALM});
 971         $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
 972         $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
 973         $ctx->{krb5_ccname} = "$prefix_abs/krb5cc_%{uid}";
 974         Samba::mk_krb5_conf($ctx, "");
 975
 976         $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
 977         $ret->{RESOLV_CONF} = $dcvars->{RESOLV_CONF};
 978
 979         my $net = Samba::bindir_path($self, "net");
 980         # Add hosts file for name lookups
 981         my $cmd = "NSS_WRAPPER_HOSTS='$ret->{NSS_WRAPPER_HOSTS}' ";
 982         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
 983         if (defined($ret->{RESOLV_WRAPPER_CONF})) {
 984                 $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
 985         } else {
 986                 $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
 987         }
 988         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
 989         $cmd .= "SELFTEST_WINBINDD_SOCKET_DIR=\"$ret->{SELFTEST_WINBINDD_SOCKET_DIR}\" ";
 990         $cmd .= "$net join $ret->{CONFIGURATION}";
 991         $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
 992
 993         if (system($cmd) != 0) {
 994             warn("Join failed\n$cmd");
 995             return undef;
 996         }
 997
 998         # We need world access to this share, as otherwise the domain
 999         # administrator from the AD domain provided by Samba4 can't
1000         # access the share for tests.
1001         chmod 0777, "$prefix/share";
1002
1003         if (not $self->check_or_start(
1004                 env_vars => $ret,
1005                 nmbd => "yes",
1006                 winbindd => "yes",
1007                 smbd => "yes")) {
1008                 return undef;
1009         }
1010
1011         $ret->{DC_SERVER} = $dcvars->{SERVER};
1012         $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
1013         $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
1014         $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
1015         $ret->{DC_USERNAME} = $dcvars->{USERNAME};
1016         $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
1017
1018         $ret->{TRUST_SERVER} = $dcvars->{TRUST_SERVER};
1019         $ret->{TRUST_USERNAME} = $dcvars->{TRUST_USERNAME};
1020         $ret->{TRUST_PASSWORD} = $dcvars->{TRUST_PASSWORD};
1021         $ret->{TRUST_DOMAIN} = $dcvars->{TRUST_DOMAIN};
1022         $ret->{TRUST_REALM} = $dcvars->{TRUST_REALM};
1023         $ret->{TRUST_DOMSID} = $dcvars->{TRUST_DOMSID};
1024
1025         return $ret;
1026 }
1027
1028 sub setup_simpleserver
1029 {
1030         my ($self, $path) = @_;
1031
1032         print "PROVISIONING simple server...";
1033
1034         my $prefix_abs = abs_path($path);
1035
1036         my $simpleserver_options = "
1037         lanman auth = yes
1038         ntlm auth = yes
1039         vfs objects = xattr_tdb streams_depot
1040         change notify = no
1041         smb encrypt = off
1042
1043 [vfs_aio_pthread]
1044         path = $prefix_abs/share
1045         read only = no
1046         vfs objects = aio_pthread
1047         aio_pthread:aio open = yes
1048         smbd:async dosmode = no
1049
1050 [vfs_aio_pthread_async_dosmode_default1]
1051         path = $prefix_abs/share
1052         read only = no
1053         vfs objects = aio_pthread
1054         store dos attributes = yes
1055         aio_pthread:aio open = yes
1056         smbd:async dosmode = yes
1057
1058 [vfs_aio_pthread_async_dosmode_default2]
1059         path = $prefix_abs/share
1060         read only = no
1061         vfs objects = aio_pthread xattr_tdb
1062         store dos attributes = yes
1063         aio_pthread:aio open = yes
1064         smbd:async dosmode = yes
1065
1066 [vfs_aio_pthread_async_dosmode_force_sync1]
1067         path = $prefix_abs/share
1068         read only = no
1069         vfs objects = aio_pthread
1070         store dos attributes = yes
1071         aio_pthread:aio open = yes
1072         smbd:async dosmode = yes
1073         # This simulates non linux systems
1074         smbd:force sync user path safe threadpool = yes
1075         smbd:force sync user chdir safe threadpool = yes
1076         smbd:force sync root path safe threadpool = yes
1077         smbd:force sync root chdir safe threadpool = yes
1078
1079 [vfs_aio_pthread_async_dosmode_force_sync2]
1080         path = $prefix_abs/share
1081         read only = no
1082         vfs objects = aio_pthread xattr_tdb
1083         store dos attributes = yes
1084         aio_pthread:aio open = yes
1085         smbd:async dosmode = yes
1086         # This simulates non linux systems
1087         smbd:force sync user path safe threadpool = yes
1088         smbd:force sync user chdir safe threadpool = yes
1089         smbd:force sync root path safe threadpool = yes
1090         smbd:force sync root chdir safe threadpool = yes
1091
1092 [vfs_aio_fork]
1093         path = $prefix_abs/share
1094         vfs objects = aio_fork
1095         read only = no
1096         vfs_aio_fork:erratic_testing_mode=yes
1097
1098 [dosmode]
1099         path = $prefix_abs/share
1100         vfs objects =
1101         store dos attributes = yes
1102         hide files = /hidefile/
1103         hide dot files = yes
1104
1105 [enc_desired]
1106         path = $prefix_abs/share
1107         vfs objects =
1108         smb encrypt = desired
1109
1110 [hidenewfiles]
1111         path = $prefix_abs/share
1112         hide new files timeout = 5
1113 ";
1114
1115         my $vars = $self->provision(
1116             prefix => $path,
1117             domain => "WORKGROUP",
1118             server => "LOCALSHARE4",
1119             password => "local4pass",
1120             extra_options => $simpleserver_options);
1121
1122         $vars or return undef;
1123
1124         if (not $self->check_or_start(
1125                 env_vars => $vars,
1126                 nmbd => "yes",
1127                 smbd => "yes")) {
1128                return undef;
1129         }
1130
1131         return $vars;
1132 }
1133
1134 sub create_file_chmod($$)
1135 {
1136     my ($name, $mode) = @_;
1137     my $fh;
1138
1139     unless (open($fh, '>', $name)) {
1140         warn("Unable to open $name");
1141         return undef;
1142     }
1143     chmod($mode, $fh);
1144 }
1145
1146 sub setup_fileserver
1147 {
1148         my ($self, $path) = @_;
1149         my $prefix_abs = abs_path($path);
1150         my $srcdir_abs = abs_path($self->{srcdir});
1151
1152         print "PROVISIONING file server ...\n";
1153
1154         my @dirs = ();
1155
1156         mkdir($prefix_abs, 0777);
1157
1158         my $usershare_dir="$prefix_abs/lib/usershare";
1159
1160         mkdir("$prefix_abs/lib", 0755);
1161         remove_tree($usershare_dir);
1162         mkdir($usershare_dir, 01770);
1163
1164         my $share_dir="$prefix_abs/share";
1165
1166         # Create share directory structure
1167         my $lower_case_share_dir="$share_dir/lower-case";
1168         push(@dirs, $lower_case_share_dir);
1169
1170         my $lower_case_share_dir_30000="$share_dir/lower-case-30000";
1171         push(@dirs, $lower_case_share_dir_30000);
1172
1173         my $dfree_share_dir="$share_dir/dfree";
1174         push(@dirs, $dfree_share_dir);
1175         push(@dirs, "$dfree_share_dir/subdir1");
1176         push(@dirs, "$dfree_share_dir/subdir2");
1177         push(@dirs, "$dfree_share_dir/subdir3");
1178
1179         my $quotadir_dir="$share_dir/quota";
1180         push(@dirs, $quotadir_dir);
1181
1182         my $valid_users_sharedir="$share_dir/valid_users";
1183         push(@dirs,$valid_users_sharedir);
1184
1185         my $offline_sharedir="$share_dir/offline";
1186         push(@dirs,$offline_sharedir);
1187
1188         my $force_user_valid_users_dir = "$share_dir/force_user_valid_users";
1189         push(@dirs, $force_user_valid_users_dir);
1190
1191         my $smbget_sharedir="$share_dir/smbget";
1192         push(@dirs,$smbget_sharedir);
1193
1194         my $tarmode_sharedir="$share_dir/tarmode";
1195         push(@dirs,$tarmode_sharedir);
1196
1197         my $usershare_sharedir="$share_dir/usershares";
1198         push(@dirs,$usershare_sharedir);
1199
1200         my $dropbox_sharedir="$share_dir/dropbox";
1201         push(@dirs,$dropbox_sharedir);
1202
1203         my $fileserver_options = "
1204         kernel change notify = yes
1205         rpc_server:mdssvc = embedded
1206         spotlight backend = elasticsearch
1207         elasticsearch:address = 127.0.0.35
1208         elasticsearch:port = 8080
1209         elasticsearch:mappings = $srcdir_abs/source3/rpc_server/mdssvc/elasticsearch_mappings.json
1210
1211         usershare path = $usershare_dir
1212         usershare max shares = 10
1213         usershare allow guests = yes
1214         usershare prefix allow list = $usershare_sharedir
1215
1216         get quota command = $prefix_abs/getset_quota.py
1217         set quota command = $prefix_abs/getset_quota.py
1218 [spotlight]
1219         path = $share_dir
1220         spotlight = yes
1221         read only = no
1222 [no_spotlight]
1223         path = $share_dir
1224         spotlight = no
1225         read only = no
1226 [lowercase]
1227         path = $lower_case_share_dir
1228         comment = smb username is [%U]
1229         case sensitive = True
1230         default case = lower
1231         preserve case = no
1232         short preserve case = no
1233 [lowercase-30000]
1234         path = $lower_case_share_dir_30000
1235         comment = smb username is [%U]
1236         case sensitive = True
1237         default case = lower
1238         preserve case = no
1239         short preserve case = no
1240 [dfree]
1241         path = $dfree_share_dir
1242         comment = smb username is [%U]
1243         dfree command = $srcdir_abs/testprogs/blackbox/dfree.sh
1244 [valid-users-access]
1245         path = $valid_users_sharedir
1246         valid users = +userdup
1247 [offline]
1248         path = $offline_sharedir
1249         vfs objects = offline
1250
1251 # BUG: https://bugzilla.samba.org/show_bug.cgi?id=9878
1252 # RH BUG: https://bugzilla.redhat.com/show_bug.cgi?id=1077651
1253 [force_user_valid_users]
1254         path = $force_user_valid_users_dir
1255         comment = force user with valid users combination test share
1256         valid users = +force_user
1257         force user = force_user
1258         force group = everyone
1259         write list = force_user
1260
1261 [smbget]
1262         path = $smbget_sharedir
1263         comment = smb username is [%U]
1264         guest ok = yes
1265 [ign_sysacls]
1266         path = $share_dir
1267         comment = ignore system acls
1268         acl_xattr:ignore system acls = yes
1269 [inherit_owner]
1270         path = $share_dir
1271         comment = inherit owner
1272         inherit owner = yes
1273 [inherit_owner_u]
1274         path = $share_dir
1275         comment = inherit only unix owner
1276         inherit owner = unix only
1277         acl_xattr:ignore system acls = yes
1278 # BUG: https://bugzilla.samba.org/show_bug.cgi?id=13690
1279 [force_group_test]
1280         path = $share_dir
1281         comment = force group test
1282 #       force group = everyone
1283
1284 [create_mode_664]
1285         path = $share_dir
1286         comment = smb username is [%U]
1287         create mask = 0644
1288         force create mode = 0664
1289         vfs objects = dirsort
1290
1291 [dropbox]
1292         path = $dropbox_sharedir
1293         comment = smb username is [%U]
1294         writeable = yes
1295         vfs objects =
1296
1297 [homes]
1298         comment = Home directories
1299         browseable = No
1300         read only = No
1301 ";
1302
1303         my $vars = $self->provision(
1304             prefix => $path,
1305             domain => "WORKGROUP",
1306             server => "FILESERVER",
1307             password => "fileserver",
1308             extra_options => $fileserver_options,
1309             no_delete_prefix => 1);
1310
1311         $vars or return undef;
1312
1313         if (not $self->check_or_start(
1314                 env_vars => $vars,
1315                 nmbd => "yes",
1316                 smbd => "yes")) {
1317                return undef;
1318         }
1319
1320
1321         mkdir($_, 0777) foreach(@dirs);
1322
1323         ## Create case sensitive lower case share dir
1324         foreach my $file ('a'..'z') {
1325                 my $full_path = $lower_case_share_dir . '/' . $file;
1326                 open my $fh, '>', $full_path;
1327                 # Add some content to file
1328                 print $fh $full_path;
1329                 close $fh;
1330         }
1331
1332         for (my $file = 1; $file < 51; ++$file) {
1333                 my $full_path = $lower_case_share_dir . '/' . $file;
1334                 open my $fh, '>', $full_path;
1335                 # Add some content to file
1336                 print $fh $full_path;
1337                 close $fh;
1338         }
1339
1340         # Create content for 30000 share
1341         foreach my $file ('a'..'z') {
1342                 my $full_path = $lower_case_share_dir_30000 . '/' . $file;
1343                 open my $fh, '>', $full_path;
1344                 # Add some content to file
1345                 print $fh $full_path;
1346                 close $fh;
1347         }
1348
1349         for (my $file = 1; $file < 30001; ++$file) {
1350                 my $full_path = $lower_case_share_dir_30000 . '/' . $file;
1351                 open my $fh, '>', $full_path;
1352                 # Add some content to file
1353                 print $fh $full_path;
1354                 close $fh;
1355         }
1356
1357         ##
1358         ## create a listable file in valid_users_share
1359         ##
1360         create_file_chmod("$valid_users_sharedir/foo", 0644) or return undef;
1361
1362         return $vars;
1363 }
1364
1365 sub setup_ktest
1366 {
1367         my ($self, $prefix) = @_;
1368
1369         # If we didn't build with ADS, pretend this env was never available
1370         if (not $self->have_ads()) {
1371                 return "UNKNOWN";
1372         }
1373
1374         print "PROVISIONING server with security=ads...";
1375
1376         my $ktest_options = "
1377         workgroup = KTEST
1378         realm = ktest.samba.example.com
1379         security = ads
1380         username map = $prefix/lib/username.map
1381         server signing = required
1382         server min protocol = SMB3_00
1383         client max protocol = SMB3
1384
1385         # This disables NTLM auth against the local SAM, which
1386         # we use can then test this setting by.
1387         ntlm auth = disabled
1388 ";
1389
1390         my $ret = $self->provision(
1391             prefix => $prefix,
1392             domain => "KTEST",
1393             server => "LOCALKTEST6",
1394             password => "localktest6pass",
1395             extra_options => $ktest_options);
1396
1397         $ret or return undef;
1398
1399         my $ctx;
1400         my $prefix_abs = abs_path($prefix);
1401         $ctx = {};
1402         $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
1403         $ctx->{domain} = "KTEST";
1404         $ctx->{realm} = "KTEST.SAMBA.EXAMPLE.COM";
1405         $ctx->{dnsname} = lc($ctx->{realm});
1406         $ctx->{kdc_ipv4} = "0.0.0.0";
1407         $ctx->{kdc_ipv6} = "::";
1408         $ctx->{krb5_ccname} = "$prefix_abs/krb5cc_%{uid}";
1409         Samba::mk_krb5_conf($ctx, "");
1410
1411         $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
1412
1413         open(USERMAP, ">$prefix/lib/username.map") or die("Unable to open $prefix/lib/username.map");
1414         print USERMAP "
1415 $ret->{USERNAME} = KTEST\\Administrator
1416 ";
1417         close(USERMAP);
1418
1419 #This is the secrets.tdb created by 'net ads join' from Samba3 to a
1420 #Samba4 DC with the same parameters as are being used here.  The
1421 #domain SID is S-1-5-21-1071277805-689288055-3486227160
1422         $ret->{SAMSID} = "S-1-5-21-1911091480-1468226576-2729736297";
1423         $ret->{DOMSID} = "S-1-5-21-1071277805-689288055-3486227160";
1424
1425         system("cp $self->{srcdir}/source3/selftest/ktest-secrets.tdb $prefix/private/secrets.tdb");
1426         chmod 0600, "$prefix/private/secrets.tdb";
1427
1428 #Make sure there's no old ntdb file.
1429         system("rm -f $prefix/private/secrets.ntdb");
1430
1431 #This uses a pre-calculated krb5 credentials cache, obtained by running Samba4 with:
1432 # "--option=kdc:service ticket lifetime=239232" "--option=kdc:user ticket lifetime=239232" "--option=kdc:renewal lifetime=239232"
1433 #
1434 #and having in krb5.conf:
1435 # ticket_lifetime = 799718400
1436 # renew_lifetime = 799718400
1437 #
1438 # The commands for the -2 keytab where were:
1439 # kinit administrator@KTEST.SAMBA.EXAMPLE.COM
1440 # kvno host/localktest6@KTEST.SAMBA.EXAMPLE.COM
1441 # kvno cifs/localktest6@KTEST.SAMBA.EXAMPLE.COM
1442 # kvno host/LOCALKTEST6@KTEST.SAMBA.EXAMPLE.COM
1443 # kvno cifs/LOCALKTEST6@KTEST.SAMBA.EXAMPLE.COM
1444 #
1445 # and then for the -3 keytab, I did
1446 #
1447 # net changetrustpw; kdestroy and the same again.
1448 #
1449 # This creates a credential cache with a very long lifetime (2036 at
1450 # at 2011-04), and shows that running 'net changetrustpw' does not
1451 # break existing logins (for the secrets.tdb method at least).
1452 #
1453
1454         $ret->{KRB5_CCACHE}="FILE:$prefix/krb5_ccache";
1455
1456         system("cp $self->{srcdir}/source3/selftest/ktest-krb5_ccache-2 $prefix/krb5_ccache-2");
1457         chmod 0600, "$prefix/krb5_ccache-2";
1458
1459         system("cp $self->{srcdir}/source3/selftest/ktest-krb5_ccache-3 $prefix/krb5_ccache-3");
1460         chmod 0600, "$prefix/krb5_ccache-3";
1461
1462         # We need world access to this share, as otherwise the domain
1463         # administrator from the AD domain provided by ktest can't
1464         # access the share for tests.
1465         chmod 0777, "$prefix/share";
1466
1467         if (not $self->check_or_start(
1468                 env_vars => $ret,
1469                 nmbd => "yes",
1470                 smbd => "yes")) {
1471                return undef;
1472         }
1473         return $ret;
1474 }
1475
1476 sub setup_maptoguest
1477 {
1478         my ($self, $path) = @_;
1479
1480         print "PROVISIONING maptoguest...";
1481
1482         my $options = "
1483 map to guest = bad user
1484 ntlm auth = yes
1485 ";
1486
1487         my $vars = $self->provision(
1488             prefix => $path,
1489             domain => "WORKGROUP",
1490             server => "maptoguest",
1491             password => "maptoguestpass",
1492             extra_options => $options);
1493
1494         $vars or return undef;
1495
1496         if (not $self->check_or_start(
1497                 env_vars => $vars,
1498                 nmbd => "yes",
1499                 smbd => "yes")) {
1500                return undef;
1501         }
1502
1503         return $vars;
1504 }
1505
1506 sub stop_sig_term($$) {
1507         my ($self, $pid) = @_;
1508         kill("USR1", $pid) or kill("ALRM", $pid) or warn("Unable to kill $pid: $!");
1509 }
1510
1511 sub stop_sig_kill($$) {
1512         my ($self, $pid) = @_;
1513         kill("ALRM", $pid) or warn("Unable to kill $pid: $!");
1514 }
1515
1516 sub write_pid($$$)
1517 {
1518         my ($env_vars, $app, $pid) = @_;
1519
1520         open(PID, ">$env_vars->{PIDDIR}/timelimit.$app.pid");
1521         print PID $pid;
1522         close(PID);
1523 }
1524
1525 sub read_pid($$)
1526 {
1527         my ($env_vars, $app) = @_;
1528
1529         open(PID, "<$env_vars->{PIDDIR}/timelimit.$app.pid");
1530         my $pid = <PID>;
1531         close(PID);
1532         return $pid;
1533 }
1534
1535 # builds up the cmd args to run an s3 binary (i.e. smbd, nmbd, etc)
1536 sub make_bin_cmd
1537 {
1538         my ($self, $binary, $env_vars, $options, $valgrind, $dont_log_stdout) = @_;
1539
1540         my @optargs = ("-d0");
1541         if (defined($options)) {
1542                 @optargs = split(/ /, $options);
1543         }
1544         my @preargs = (Samba::bindir_path($self, "timelimit"), $self->{server_maxtime});
1545
1546         if (defined($valgrind)) {
1547                 @preargs = split(/ /, $valgrind);
1548         }
1549         my @args = ("-F", "--no-process-group",
1550                     "-s", $env_vars->{SERVERCONFFILE},
1551                     "-l", $env_vars->{LOGDIR});
1552
1553         if (not defined($dont_log_stdout)) {
1554                 push(@args, "--log-stdout");
1555         }
1556         return (@preargs, $binary, @args, @optargs);
1557 }
1558
1559 sub check_or_start($$) {
1560         my ($self, %args) = @_;
1561         my $env_vars = $args{env_vars};
1562         my $nmbd = $args{nmbd} // "no";
1563         my $winbindd = $args{winbindd} // "no";
1564         my $smbd = $args{smbd} // "no";
1565         my $child_cleanup = $args{child_cleanup};
1566
1567         my $STDIN_READER;
1568
1569         # use a pipe for stdin in the child processes. This allows
1570         # those processes to monitor the pipe for EOF to ensure they
1571         # exit when the test script exits
1572         pipe($STDIN_READER, $env_vars->{STDIN_PIPE});
1573
1574         my $binary = Samba::bindir_path($self, "nmbd");
1575         my @full_cmd = $self->make_bin_cmd($binary, $env_vars,
1576                                            $ENV{NMBD_OPTIONS}, $ENV{NMBD_VALGRIND},
1577                                            $ENV{NMBD_DONT_LOG_STDOUT});
1578         my $nmbd_envs = Samba::get_env_for_process("nmbd", $env_vars);
1579         delete $nmbd_envs->{RESOLV_WRAPPER_CONF};
1580         delete $nmbd_envs->{RESOLV_WRAPPER_HOSTS};
1581
1582         # fork and exec() nmbd in the child process
1583         my $daemon_ctx = {
1584                 NAME => "nmbd",
1585                 BINARY_PATH => $binary,
1586                 FULL_CMD => [ @full_cmd ],
1587                 LOG_FILE => $env_vars->{NMBD_TEST_LOG},
1588                 PCAP_FILE => "env-$ENV{ENVNAME}-nmbd",
1589                 ENV_VARS => $nmbd_envs,
1590         };
1591         if ($nmbd ne "yes") {
1592                 $daemon_ctx->{SKIP_DAEMON} = 1;
1593         }
1594         my $pid = Samba::fork_and_exec(
1595             $self, $env_vars, $daemon_ctx, $STDIN_READER, $child_cleanup);
1596
1597         $env_vars->{NMBD_TL_PID} = $pid;
1598         write_pid($env_vars, "nmbd", $pid);
1599
1600         $binary = Samba::bindir_path($self, "winbindd");
1601         @full_cmd = $self->make_bin_cmd($binary, $env_vars,
1602                                          $ENV{WINBINDD_OPTIONS}, $ENV{WINBINDD_VALGRIND}, "N/A");
1603
1604         if (not defined($ENV{WINBINDD_DONT_LOG_STDOUT})) {
1605                 push(@full_cmd, "--stdout");
1606         }
1607
1608         # fork and exec() winbindd in the child process
1609         $daemon_ctx = {
1610                 NAME => "winbindd",
1611                 BINARY_PATH => $binary,
1612                 FULL_CMD => [ @full_cmd ],
1613                 LOG_FILE => $env_vars->{WINBINDD_TEST_LOG},
1614                 PCAP_FILE => "env-$ENV{ENVNAME}-winbindd",
1615         };
1616         if ($winbindd ne "yes") {
1617                 $daemon_ctx->{SKIP_DAEMON} = 1;
1618         }
1619
1620         $pid = Samba::fork_and_exec(
1621             $self, $env_vars, $daemon_ctx, $STDIN_READER, $child_cleanup);
1622
1623         $env_vars->{WINBINDD_TL_PID} = $pid;
1624         write_pid($env_vars, "winbindd", $pid);
1625
1626         $binary = Samba::bindir_path($self, "smbd");
1627         @full_cmd = $self->make_bin_cmd($binary, $env_vars,
1628                                          $ENV{SMBD_OPTIONS}, $ENV{SMBD_VALGRIND},
1629                                          $ENV{SMBD_DONT_LOG_STDOUT});
1630
1631         # fork and exec() smbd in the child process
1632         $daemon_ctx = {
1633                 NAME => "smbd",
1634                 BINARY_PATH => $binary,
1635                 FULL_CMD => [ @full_cmd ],
1636                 LOG_FILE => $env_vars->{SMBD_TEST_LOG},
1637                 PCAP_FILE => "env-$ENV{ENVNAME}-smbd",
1638         };
1639         if ($smbd ne "yes") {
1640                 $daemon_ctx->{SKIP_DAEMON} = 1;
1641         }
1642
1643         $pid = Samba::fork_and_exec(
1644             $self, $env_vars, $daemon_ctx, $STDIN_READER, $child_cleanup);
1645
1646         $env_vars->{SMBD_TL_PID} = $pid;
1647         write_pid($env_vars, "smbd", $pid);
1648
1649         # close the parent's read-end of the pipe
1650         close($STDIN_READER);
1651
1652         return $self->wait_for_start($env_vars, $nmbd, $winbindd, $smbd);
1653 }
1654
1655 sub createuser($$$$$)
1656 {
1657         my ($self, $username, $password, $conffile, $env) = @_;
1658         my $cmd = "UID_WRAPPER_ROOT=1 " . Samba::bindir_path($self, "smbpasswd")." -c $conffile -L -s -a $username > /dev/null";
1659
1660         keys %$env;
1661         while(my($var, $val) = each %$env) {
1662                 $cmd = "$var=\"$val\" $cmd";
1663         }
1664
1665         unless (open(PWD, "|$cmd")) {
1666             warn("Unable to set password for $username account\n$cmd");
1667             return undef;
1668         }
1669         print PWD "$password\n$password\n";
1670         unless (close(PWD)) {
1671             warn("Unable to set password for $username account\n$cmd");
1672             return undef;
1673         }
1674 }
1675
1676 sub provision($$)
1677 {
1678         my ($self, %args) = @_;
1679
1680         my $prefix = $args{prefix};
1681         my $domain = $args{domain};
1682         my $server = $args{server};
1683         my $password = $args{password};
1684         my $extra_options = $args{extra_options};
1685         my $dc_server_ip = $args{dc_server_ip};
1686         my $dc_server_ipv6 = $args{dc_server_ipv6};
1687         my $no_delete_prefix= $args{no_delete_prefix};
1688         my $netbios_name = $args{netbios_name} // $server;
1689
1690         ##
1691         ## setup the various environment variables we need
1692         ##
1693
1694         my $samsid = Samba::random_domain_sid();
1695         my $swiface = Samba::get_interface($server);
1696         my %ret = ();
1697         my %createuser_env = ();
1698         my $server_ip = Samba::get_ipv4_addr($server);
1699         my $server_ipv6 = Samba::get_ipv6_addr($server);
1700
1701         my $unix_name = ($ENV{USER} or $ENV{LOGNAME} or `PATH=/usr/ucb:$ENV{PATH} whoami`);
1702         chomp $unix_name;
1703         my $unix_uid = $>;
1704         my $unix_gids_str = $);
1705         my @unix_gids = split(" ", $unix_gids_str);
1706
1707         my $prefix_abs = abs_path($prefix);
1708         my $bindir_abs = abs_path($self->{bindir});
1709
1710         my @dirs = ();
1711
1712         my $shrdir=$args{share_dir} // "$prefix_abs/share";
1713         push(@dirs,$shrdir);
1714
1715         my $libdir="$prefix_abs/lib";
1716         push(@dirs,$libdir);
1717
1718         my $piddir="$prefix_abs/pid";
1719         push(@dirs,$piddir);
1720
1721         my $privatedir="$prefix_abs/private";
1722         push(@dirs,$privatedir);
1723
1724         my $cachedir = "$prefix_abs/cachedir";
1725         push(@dirs, $cachedir);
1726
1727         my $binddnsdir = "$prefix_abs/bind-dns";
1728         push(@dirs, $binddnsdir);
1729
1730         my $lockdir="$prefix_abs/lockdir";
1731         push(@dirs,$lockdir);
1732
1733         my $eventlogdir="$prefix_abs/lockdir/eventlog";
1734         push(@dirs,$eventlogdir);
1735
1736         my $logdir="$prefix_abs/logs";
1737         push(@dirs,$logdir);
1738
1739         my $driver32dir="$shrdir/W32X86";
1740         push(@dirs,$driver32dir);
1741
1742         my $driver64dir="$shrdir/x64";
1743         push(@dirs,$driver64dir);
1744
1745         my $driver40dir="$shrdir/WIN40";
1746         push(@dirs,$driver40dir);
1747
1748         my $ro_shrdir="$shrdir/root-tmp";
1749         push(@dirs,$ro_shrdir);
1750
1751         my $noperm_shrdir="$shrdir/noperm-tmp";
1752         push(@dirs,$noperm_shrdir);
1753
1754         my $msdfs_shrdir="$shrdir/msdfsshare";
1755         push(@dirs,$msdfs_shrdir);
1756
1757         my $msdfs_deeppath="$msdfs_shrdir/deeppath";
1758         push(@dirs,$msdfs_deeppath);
1759
1760         my $badnames_shrdir="$shrdir/badnames";
1761         push(@dirs,$badnames_shrdir);
1762
1763         my $lease1_shrdir="$shrdir/SMB2_10";
1764         push(@dirs,$lease1_shrdir);
1765
1766         my $lease2_shrdir="$shrdir/SMB3_00";
1767         push(@dirs,$lease2_shrdir);
1768
1769         my $manglenames_shrdir="$shrdir/manglenames";
1770         push(@dirs,$manglenames_shrdir);
1771
1772         my $widelinks_shrdir="$shrdir/widelinks";
1773         push(@dirs,$widelinks_shrdir);
1774
1775         my $widelinks_linkdir="$shrdir/widelinks_foo";
1776         push(@dirs,$widelinks_linkdir);
1777
1778         my $fsrvp_shrdir="$shrdir/fsrvp";
1779         push(@dirs,$fsrvp_shrdir);
1780
1781         my $shadow_tstdir="$shrdir/shadow";
1782         push(@dirs,$shadow_tstdir);
1783         my $shadow_mntdir="$shadow_tstdir/mount";
1784         push(@dirs,$shadow_mntdir);
1785         my $shadow_basedir="$shadow_mntdir/base";
1786         push(@dirs,$shadow_basedir);
1787         my $shadow_shrdir="$shadow_basedir/share";
1788         push(@dirs,$shadow_shrdir);
1789
1790         my $nosymlinks_shrdir="$shrdir/nosymlinks";
1791         push(@dirs,$nosymlinks_shrdir);
1792
1793         my $local_symlinks_shrdir="$shrdir/local_symlinks";
1794         push(@dirs,$local_symlinks_shrdir);
1795
1796         # this gets autocreated by winbindd
1797         my $wbsockdir="$prefix_abs/winbindd";
1798
1799         my $nmbdsockdir="$prefix_abs/nmbd";
1800         unlink($nmbdsockdir);
1801
1802         ##
1803         ## create the test directory layout
1804         ##
1805         die ("prefix_abs = ''") if $prefix_abs eq "";
1806         die ("prefix_abs = '/'") if $prefix_abs eq "/";
1807
1808         mkdir($prefix_abs, 0777);
1809         print "CREATE TEST ENVIRONMENT IN '$prefix'...";
1810         if (not defined($no_delete_prefix) or not $no_delete_prefix) {
1811             system("rm -rf $prefix_abs/*");
1812         }
1813         mkdir($_, 0777) foreach(@dirs);
1814
1815         my $fs_specific_conf = $self->get_fs_specific_conf($shrdir);
1816
1817         ##
1818         ## lockdir and piddir must be 0755
1819         ##
1820         chmod 0755, $lockdir;
1821         chmod 0755, $piddir;
1822
1823
1824         ##
1825         ## Create a directory without permissions to enter
1826         ##
1827         chmod 0000, $noperm_shrdir;
1828
1829         ##
1830         ## create ro and msdfs share layout
1831         ##
1832
1833         chmod 0755, $ro_shrdir;
1834
1835         create_file_chmod("$ro_shrdir/unreadable_file", 0600) or return undef;
1836
1837         create_file_chmod("$ro_shrdir/msdfs-target", 0600) or return undef;
1838         symlink "msdfs:$server_ip\\ro-tmp,$server_ipv6\\ro-tmp",
1839                 "$msdfs_shrdir/msdfs-src1";
1840         symlink "msdfs:$server_ipv6\\ro-tmp", "$msdfs_shrdir/deeppath/msdfs-src2";
1841
1842         ##
1843         ## create bad names in $badnames_shrdir
1844         ##
1845         ## (An invalid name, would be mangled to 8.3).
1846         create_file_chmod("$badnames_shrdir/\340|\231\216\377\177",
1847                           0600) or return undef;
1848
1849         ## (A bad name, would not be mangled to 8.3).
1850         create_file_chmod("$badnames_shrdir/\240\276\346\327\377\177",
1851                           0666) or return undef;
1852
1853         ## (A bad good name).
1854         create_file_chmod("$badnames_shrdir/blank.txt",
1855                           0666) or return undef;
1856
1857         ##
1858         ## create mangleable directory names in $manglenames_shrdir
1859         ##
1860         my $manglename_target = "$manglenames_shrdir/foo:bar";
1861         mkdir($manglename_target, 0777);
1862
1863         ##
1864         ## create symlinks for widelinks tests.
1865         ##
1866         my $widelinks_target = "$widelinks_linkdir/target";
1867         create_file_chmod("$widelinks_target", 0666) or return undef;
1868
1869         ##
1870         ## This link should get ACCESS_DENIED
1871         ##
1872         symlink "$widelinks_target", "$widelinks_shrdir/source";
1873         ##
1874         ## This link should be allowed
1875         ##
1876         symlink "$widelinks_shrdir", "$widelinks_shrdir/dot";
1877
1878         my $conffile="$libdir/server.conf";
1879         my $dfqconffile="$libdir/dfq.conf";
1880         my $errorinjectconf="$libdir/error_inject.conf";
1881         my $delayinjectconf="$libdir/delay_inject.conf";
1882         my $globalinjectconf="$libdir/global_inject.conf";
1883
1884         my $nss_wrapper_pl = "$ENV{PERL} $self->{srcdir}/third_party/nss_wrapper/nss_wrapper.pl";
1885         my $nss_wrapper_passwd = "$privatedir/passwd";
1886         my $nss_wrapper_group = "$privatedir/group";
1887         my $nss_wrapper_hosts = "$ENV{SELFTEST_PREFIX}/hosts";
1888         my $resolv_conf = "$privatedir/resolv.conf";
1889         my $dns_host_file = "$ENV{SELFTEST_PREFIX}/dns_host_file";
1890
1891         my $mod_printer_pl = "$ENV{PERL} $self->{srcdir}/source3/script/tests/printing/modprinter.pl";
1892
1893         my $fake_snap_pl = "$ENV{PERL} $self->{srcdir}/source3/script/tests/fake_snap.pl";
1894
1895         my @eventlog_list = ("dns server", "application");
1896
1897         ##
1898         ## calculate uids and gids
1899         ##
1900
1901         my ($max_uid, $max_gid);
1902         my ($uid_nobody, $uid_root, $uid_pdbtest, $uid_pdbtest2, $uid_userdup);
1903         my ($uid_pdbtest_wkn);
1904         my ($uid_smbget);
1905         my ($uid_force_user);
1906         my ($gid_nobody, $gid_nogroup, $gid_root, $gid_domusers, $gid_domadmins);
1907         my ($gid_userdup, $gid_everyone);
1908         my ($gid_force_user);
1909         my ($uid_user1);
1910         my ($uid_user2);
1911         my ($uid_gooduser);
1912         my ($uid_eviluser);
1913         my ($uid_slashuser);
1914
1915         if ($unix_uid < 0xffff - 13) {
1916                 $max_uid = 0xffff;
1917         } else {
1918                 $max_uid = $unix_uid;
1919         }
1920
1921         $uid_root = $max_uid - 1;
1922         $uid_nobody = $max_uid - 2;
1923         $uid_pdbtest = $max_uid - 3;
1924         $uid_pdbtest2 = $max_uid - 4;
1925         $uid_userdup = $max_uid - 5;
1926         $uid_pdbtest_wkn = $max_uid - 6;
1927         $uid_force_user = $max_uid - 7;
1928         $uid_smbget = $max_uid - 8;
1929         $uid_user1 = $max_uid - 9;
1930         $uid_user2 = $max_uid - 10;
1931         $uid_gooduser = $max_uid - 11;
1932         $uid_eviluser = $max_uid - 12;
1933         $uid_slashuser = $max_uid - 13;
1934
1935         if ($unix_gids[0] < 0xffff - 8) {
1936                 $max_gid = 0xffff;
1937         } else {
1938                 $max_gid = $unix_gids[0];
1939         }
1940
1941         $gid_nobody = $max_gid - 1;
1942         $gid_nogroup = $max_gid - 2;
1943         $gid_root = $max_gid - 3;
1944         $gid_domusers = $max_gid - 4;
1945         $gid_domadmins = $max_gid - 5;
1946         $gid_userdup = $max_gid - 6;
1947         $gid_everyone = $max_gid - 7;
1948         $gid_force_user = $max_gid - 8;
1949
1950         ##
1951         ## create conffile
1952         ##
1953
1954         unless (open(CONF, ">$conffile")) {
1955                 warn("Unable to open $conffile");
1956                 return undef;
1957         }
1958
1959         my $interfaces = Samba::get_interfaces_config($server);
1960
1961         print CONF "
1962 [global]
1963         dcesrv:fuzz directory = $cachedir/fuzz
1964         netbios name = $netbios_name
1965         interfaces = $interfaces
1966         bind interfaces only = yes
1967         panic action = cd $self->{srcdir} && $self->{srcdir}/selftest/gdb_backtrace %d %\$(MAKE_TEST_BINARY)
1968         smbd:suicide mode = yes
1969
1970         client min protocol = CORE
1971         server min protocol = LANMAN1
1972
1973         workgroup = $domain
1974
1975         private dir = $privatedir
1976         binddns dir = $binddnsdir
1977         pid directory = $piddir
1978         lock directory = $lockdir
1979         log file = $logdir/log.\%m
1980         log level = 1
1981         debug pid = yes
1982         max log size = 0
1983
1984         state directory = $lockdir
1985         cache directory = $lockdir
1986
1987         passdb backend = tdbsam
1988
1989         time server = yes
1990
1991         add user script =               $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action add --name %u --gid $gid_nogroup
1992         add group script =              $nss_wrapper_pl --group_path  $nss_wrapper_group  --type group  --action add --name %g
1993         add machine script =            $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action add --name %u --gid $gid_nogroup
1994         add user to group script =      $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type member --action add --member %u --name %g --group_path $nss_wrapper_group
1995         delete user script =            $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type passwd --action delete --name %u
1996         delete group script =           $nss_wrapper_pl --group_path  $nss_wrapper_group  --type group  --action delete --name %g
1997         delete user from group script = $nss_wrapper_pl --passwd_path $nss_wrapper_passwd --type member --action delete --member %u --name %g --group_path $nss_wrapper_group
1998
1999         addprinter command =            $mod_printer_pl -a -s $conffile --
2000         deleteprinter command =         $mod_printer_pl -d -s $conffile --
2001
2002         eventlog list = application \"dns server\"
2003
2004         kernel oplocks = no
2005         kernel change notify = no
2006
2007         logging = file
2008         printing = bsd
2009         printcap name = /dev/null
2010
2011         winbindd socket directory = $wbsockdir
2012         nmbd:socket dir = $nmbdsockdir
2013         idmap config * : range = 100000-200000
2014         winbind enum users = yes
2015         winbind enum groups = yes
2016         winbind separator = /
2017         include system krb5 conf = no
2018
2019 #       min receivefile size = 4000
2020
2021         read only = no
2022
2023         smbd:sharedelay = 100000
2024         smbd:writetimeupdatedelay = 500000
2025         map hidden = no
2026         map system = no
2027         map readonly = no
2028         store dos attributes = yes
2029         create mask = 755
2030         dos filemode = yes
2031         strict rename = yes
2032         strict sync = yes
2033         mangled names = yes
2034         vfs objects = acl_xattr fake_acls xattr_tdb streams_depot time_audit full_audit
2035
2036         full_audit:syslog = no
2037         full_audit:success = none
2038         full_audit:failure = none
2039
2040         printing = vlp
2041         print command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb print %p %s
2042         lpq command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpq %p
2043         lp rm command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lprm %p %j
2044         lp pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lppause %p %j
2045         lp resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpresume %p %j
2046         queue pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queuepause %p
2047         queue resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queueresume %p
2048         lpq cache time = 0
2049         print notify backchannel = yes
2050
2051         ncalrpc dir = $prefix_abs/ncalrpc
2052
2053         # The samba3.blackbox.smbclient_s3 test uses this to test that
2054         # sending messages works, and that the %m sub works.
2055         message command = mv %s $shrdir/message.%m
2056
2057         # fsrvp server requires registry shares
2058         registry shares = yes
2059
2060         # Used by RPC SRVSVC tests
2061         add share command = $bindir_abs/smbaddshare
2062         change share command = $bindir_abs/smbchangeshare
2063         delete share command = $bindir_abs/smbdeleteshare
2064
2065         # fruit:copyfile is a global option
2066         fruit:copyfile = yes
2067
2068         #this does not mean that we use non-secure test env,
2069         #it just means we ALLOW one to be configured.
2070         allow insecure wide links = yes
2071
2072         include = $globalinjectconf
2073
2074         # Begin extra options
2075         $extra_options
2076         # End extra options
2077
2078         #Include user defined custom parameters if set
2079 ";
2080
2081         if (defined($ENV{INCLUDE_CUSTOM_CONF})) {
2082                 print CONF "\t$ENV{INCLUDE_CUSTOM_CONF}\n";
2083         }
2084
2085         print CONF "
2086 [tmp]
2087         path = $shrdir
2088         comment = smb username is [%U]
2089 [tmpsort]
2090         path = $shrdir
2091         comment = Load dirsort module
2092         vfs objects = dirsort acl_xattr fake_acls xattr_tdb streams_depot
2093 [tmpenc]
2094         path = $shrdir
2095         comment = encrypt smb username is [%U]
2096         smb encrypt = required
2097         vfs objects = dirsort
2098 [tmpguest]
2099         path = $shrdir
2100         guest ok = yes
2101 [guestonly]
2102         path = $shrdir
2103         guest only = yes
2104         guest ok = yes
2105 [forceuser]
2106         path = $shrdir
2107         force user = $unix_name
2108         guest ok = yes
2109 [forceuser_unixonly]
2110         comment = force a user with unix user SID and group SID
2111         path = $shrdir
2112         force user = pdbtest
2113         guest ok = yes
2114 [forceuser_wkngroup]
2115         comment = force a user with well-known group SID
2116         path = $shrdir
2117         force user = pdbtest_wkn
2118         guest ok = yes
2119 [forcegroup]
2120         path = $shrdir
2121         force group = nogroup
2122         guest ok = yes
2123 [ro-tmp]
2124         path = $ro_shrdir
2125         guest ok = yes
2126 [noperm]
2127         path = $noperm_shrdir
2128         wide links = yes
2129         guest ok = yes
2130 [write-list-tmp]
2131         path = $shrdir
2132         read only = yes
2133         write list = $unix_name
2134 [valid-users-tmp]
2135         path = $shrdir
2136         valid users = $unix_name
2137         access based share enum = yes
2138 [msdfs-share]
2139         path = $msdfs_shrdir
2140         msdfs root = yes
2141         msdfs shuffle referrals = yes
2142         guest ok = yes
2143 [hideunread]
2144         copy = tmp
2145         hide unreadable = yes
2146 [tmpcase]
2147         copy = tmp
2148         case sensitive = yes
2149 [hideunwrite]
2150         copy = tmp
2151         hide unwriteable files = yes
2152 [durable]
2153         copy = tmp
2154         kernel share modes = no
2155         kernel oplocks = no
2156         posix locking = no
2157 [fs_specific]
2158         copy = tmp
2159         $fs_specific_conf
2160 [print1]
2161         copy = tmp
2162         printable = yes
2163
2164 [print2]
2165         copy = print1
2166 [print3]
2167         copy = print1
2168         default devmode = no
2169 [lp]
2170         copy = print1
2171
2172 [nfs4acl_simple_40]
2173         path = $shrdir
2174         comment = smb username is [%U]
2175         nfs4:mode = simple
2176         nfs4acl_xattr:version = 40
2177         vfs objects = nfs4acl_xattr xattr_tdb
2178
2179 [nfs4acl_special_40]
2180         path = $shrdir
2181         comment = smb username is [%U]
2182         nfs4:mode = special
2183         nfs4acl_xattr:version = 40
2184         vfs objects = nfs4acl_xattr xattr_tdb
2185
2186 [nfs4acl_simple_41]
2187         path = $shrdir
2188         comment = smb username is [%U]
2189         nfs4:mode = simple
2190         vfs objects = nfs4acl_xattr xattr_tdb
2191
2192 [nfs4acl_xdr_40]
2193         path = $shrdir
2194         comment = smb username is [%U]
2195         vfs objects = nfs4acl_xattr xattr_tdb
2196         nfs4:mode = simple
2197         nfs4acl_xattr:encoding = xdr
2198         nfs4acl_xattr:version = 40
2199
2200 [nfs4acl_xdr_41]
2201         path = $shrdir
2202         comment = smb username is [%U]
2203         vfs objects = nfs4acl_xattr xattr_tdb
2204         nfs4:mode = simple
2205         nfs4acl_xattr:encoding = xdr
2206         nfs4acl_xattr:version = 41
2207
2208 [nfs4acl_nfs_40]
2209         path = $shrdir
2210         comment = smb username is [%U]
2211         vfs objects = nfs4acl_xattr xattr_tdb
2212         nfs4:mode = simple
2213         nfs4acl_xattr:encoding = nfs
2214         nfs4acl_xattr:version = 40
2215         nfs4acl_xattr:xattr_name = security.nfs4acl_xdr
2216
2217 [nfs4acl_nfs_41]
2218         path = $shrdir
2219         comment = smb username is [%U]
2220         vfs objects = nfs4acl_xattr xattr_tdb
2221         nfs4:mode = simple
2222         nfs4acl_xattr:encoding = nfs
2223         nfs4acl_xattr:version = 41
2224         nfs4acl_xattr:xattr_name = security.nfs4acl_xdr
2225
2226 [xcopy_share]
2227         path = $shrdir
2228         comment = smb username is [%U]
2229         create mask = 777
2230         force create mode = 777
2231 [posix_share]
2232         path = $shrdir
2233         comment = smb username is [%U]
2234         create mask = 0777
2235         force create mode = 0
2236         directory mask = 0777
2237         force directory mode = 0
2238         vfs objects = xattr_tdb streams_depot
2239 [aio]
2240         copy = tmp
2241         aio read size = 1
2242         aio write size = 1
2243
2244 [print\$]
2245         copy = tmp
2246
2247 [vfs_fruit]
2248         path = $shrdir
2249         vfs objects = catia fruit streams_xattr acl_xattr xattr_tdb
2250         fruit:resource = file
2251         fruit:metadata = netatalk
2252         fruit:locking = netatalk
2253         fruit:encoding = native
2254         fruit:veto_appledouble = no
2255
2256 [vfs_fruit_xattr]
2257         path = $shrdir
2258         # This is used by vfs.fruit tests that require real fs xattr
2259         vfs objects = catia fruit streams_xattr acl_xattr
2260         fruit:resource = file
2261         fruit:metadata = netatalk
2262         fruit:locking = netatalk
2263         fruit:encoding = native
2264         fruit:veto_appledouble = no
2265
2266 [vfs_fruit_metadata_stream]
2267         path = $shrdir
2268         vfs objects = fruit streams_xattr acl_xattr xattr_tdb
2269         fruit:resource = file
2270         fruit:metadata = stream
2271         fruit:veto_appledouble = no
2272
2273 [vfs_fruit_stream_depot]
2274         path = $shrdir
2275         vfs objects = fruit streams_depot acl_xattr xattr_tdb
2276         fruit:resource = stream
2277         fruit:metadata = stream
2278         fruit:veto_appledouble = no
2279
2280 [vfs_wo_fruit]
2281         path = $shrdir
2282         vfs objects = streams_xattr acl_xattr xattr_tdb
2283
2284 [vfs_wo_fruit_stream_depot]
2285         path = $shrdir
2286         vfs objects = streams_depot acl_xattr xattr_tdb
2287
2288 [vfs_fruit_timemachine]
2289         path = $shrdir
2290         vfs objects = fruit streams_xattr acl_xattr xattr_tdb
2291         fruit:resource = file
2292         fruit:metadata = stream
2293         fruit:time machine = yes
2294         fruit:time machine max size = 32K
2295
2296 [vfs_fruit_wipe_intentionally_left_blank_rfork]
2297         path = $shrdir
2298         vfs objects = fruit streams_xattr acl_xattr xattr_tdb
2299         fruit:resource = file
2300         fruit:metadata = stream
2301         fruit:wipe_intentionally_left_blank_rfork = true
2302         fruit:delete_empty_adfiles = false
2303         fruit:veto_appledouble = no
2304
2305 [vfs_fruit_delete_empty_adfiles]
2306         path = $shrdir
2307         vfs objects = fruit streams_xattr acl_xattr xattr_tdb
2308         fruit:resource = file
2309         fruit:metadata = stream
2310         fruit:wipe_intentionally_left_blank_rfork = true
2311         fruit:delete_empty_adfiles = true
2312         fruit:veto_appledouble = no
2313
2314 [vfs_fruit_zero_fileid]
2315         path = $shrdir
2316         vfs objects = fruit streams_xattr acl_xattr xattr_tdb
2317         fruit:resource = file
2318         fruit:metadata = stream
2319         fruit:zero_file_id=yes
2320
2321 [badname-tmp]
2322         path = $badnames_shrdir
2323         guest ok = yes
2324
2325 [manglenames_share]
2326         path = $manglenames_shrdir
2327         guest ok = yes
2328
2329 [dynamic_share]
2330         path = $shrdir/%R
2331         guest ok = yes
2332
2333 [widelinks_share]
2334         path = $widelinks_shrdir
2335         wide links = no
2336         guest ok = yes
2337
2338 [fsrvp_share]
2339         path = $fsrvp_shrdir
2340         comment = fake shapshots using rsync
2341         vfs objects = shell_snap shadow_copy2
2342         shell_snap:check path command = $fake_snap_pl --check
2343         shell_snap:create command = $fake_snap_pl --create
2344         shell_snap:delete command = $fake_snap_pl --delete
2345         # a relative path here fails, the snapshot dir is no longer found
2346         shadow:snapdir = $fsrvp_shrdir/.snapshots
2347
2348 [shadow1]
2349         path = $shadow_shrdir
2350         comment = previous versions snapshots under mount point
2351         vfs objects = shadow_copy2
2352         shadow:mountpoint = $shadow_mntdir
2353
2354 [shadow2]
2355         path = $shadow_shrdir
2356         comment = previous versions snapshots outside mount point
2357         vfs objects = shadow_copy2
2358         shadow:mountpoint = $shadow_mntdir
2359         shadow:snapdir = $shadow_tstdir/.snapshots
2360
2361 [shadow3]
2362         path = $shadow_shrdir
2363         comment = previous versions with subvolume snapshots, snapshots under base dir
2364         vfs objects = shadow_copy2
2365         shadow:mountpoint = $shadow_mntdir
2366         shadow:basedir = $shadow_basedir
2367         shadow:snapdir = $shadow_basedir/.snapshots
2368
2369 [shadow4]
2370         path = $shadow_shrdir
2371         comment = previous versions with subvolume snapshots, snapshots outside mount point
2372         vfs objects = shadow_copy2
2373         shadow:mountpoint = $shadow_mntdir
2374         shadow:basedir = $shadow_basedir
2375         shadow:snapdir = $shadow_tstdir/.snapshots
2376
2377 [shadow5]
2378         path = $shadow_shrdir
2379         comment = previous versions at volume root snapshots under mount point
2380         vfs objects = shadow_copy2
2381         shadow:mountpoint = $shadow_shrdir
2382
2383 [shadow6]
2384         path = $shadow_shrdir
2385         comment = previous versions at volume root snapshots outside mount point
2386         vfs objects = shadow_copy2
2387         shadow:mountpoint = $shadow_shrdir
2388         shadow:snapdir = $shadow_tstdir/.snapshots
2389
2390 [shadow7]
2391         path = $shadow_shrdir
2392         comment = previous versions snapshots everywhere
2393         vfs objects = shadow_copy2
2394         shadow:mountpoint = $shadow_mntdir
2395         shadow:snapdirseverywhere = yes
2396
2397 [shadow8]
2398         path = $shadow_shrdir
2399         comment = previous versions using snapsharepath
2400         vfs objects = shadow_copy2
2401         shadow:mountpoint = $shadow_mntdir
2402         shadow:snapdir = $shadow_tstdir/.snapshots
2403         shadow:snapsharepath = share
2404
2405 [shadow_fmt0]
2406         comment = Testing shadow:format with default option
2407         vfs object = shadow_copy2
2408         path = $shadow_shrdir
2409         read only = no
2410         guest ok = yes
2411         shadow:mountpoint = $shadow_mntdir
2412         shadow:basedir = $shadow_basedir
2413         shadow:snapdir = $shadow_basedir/.snapshots
2414         shadow:format = \@GMT-%Y.%m.%d-%H.%M.%S
2415
2416 [shadow_fmt1]
2417         comment = Testing shadow:format with only date component
2418         vfs object = shadow_copy2
2419         path = $shadow_shrdir
2420         read only = no
2421         guest ok = yes
2422         shadow:mountpoint = $shadow_mntdir
2423         shadow:basedir = $shadow_basedir
2424         shadow:snapdir = $shadow_basedir/.snapshots
2425         shadow:format = \@GMT-%Y-%m-%d
2426
2427 [shadow_fmt2]
2428         comment = Testing shadow:format with some hardcoded prefix
2429         vfs object = shadow_copy2
2430         path = $shadow_shrdir
2431         read only = no
2432         guest ok = yes
2433         shadow:mountpoint = $shadow_mntdir
2434         shadow:basedir = $shadow_basedir
2435         shadow:snapdir = $shadow_basedir/.snapshots
2436         shadow:format = snap\@GMT-%Y.%m.%d-%H.%M.%S
2437
2438 [shadow_fmt3]
2439         comment = Testing shadow:format with modified format
2440         vfs object = shadow_copy2
2441         path = $shadow_shrdir
2442         read only = no
2443         guest ok = yes
2444         shadow:mountpoint = $shadow_mntdir
2445         shadow:basedir = $shadow_basedir
2446         shadow:snapdir = $shadow_basedir/.snapshots
2447         shadow:format = \@GMT-%Y.%m.%d-%H_%M_%S-snap
2448
2449 [shadow_fmt4]
2450         comment = Testing shadow:snapprefix regex
2451         vfs object = shadow_copy2
2452         path = $shadow_shrdir
2453         read only = no
2454         guest ok = yes
2455         shadow:mountpoint = $shadow_mntdir
2456         shadow:basedir = $shadow_basedir
2457         shadow:snapdir = $shadow_basedir/.snapshots
2458         shadow:snapprefix = \^s[a-z]*p\$
2459         shadow:format = _GMT-%Y.%m.%d-%H.%M.%S
2460
2461 [shadow_fmt5]
2462         comment = Testing shadow:snapprefix with delim regex
2463         vfs object = shadow_copy2
2464         path = $shadow_shrdir
2465         read only = no
2466         guest ok = yes
2467         shadow:mountpoint = $shadow_mntdir
2468         shadow:basedir = $shadow_basedir
2469         shadow:snapdir = $shadow_basedir/.snapshots
2470         shadow:delimiter = \@GMT
2471         shadow:snapprefix = [a-z]*
2472         shadow:format = \@GMT-%Y.%m.%d-%H.%M.%S
2473
2474 [shadow_wl]
2475         path = $shadow_shrdir
2476         comment = previous versions with wide links allowed
2477         vfs objects = shadow_copy2
2478         shadow:mountpoint = $shadow_mntdir
2479         wide links = yes
2480
2481 [shadow_write]
2482         path = $shadow_tstdir
2483         comment = previous versions snapshots under mount point
2484         vfs objects = shadow_copy2 streams_xattr error_inject
2485         aio write size = 0
2486         error_inject:pwrite = EBADF
2487         shadow:mountpoint = $shadow_tstdir
2488
2489 [dfq]
2490         path = $shrdir/dfree
2491         vfs objects = acl_xattr fake_acls xattr_tdb fake_dfq
2492         admin users = $unix_name
2493         include = $dfqconffile
2494 [dfq_cache]
2495         path = $shrdir/dfree
2496         vfs objects = acl_xattr fake_acls xattr_tdb fake_dfq
2497         admin users = $unix_name
2498         include = $dfqconffile
2499         dfree cache time = 60
2500 [dfq_owner]
2501         path = $shrdir/dfree
2502         vfs objects = acl_xattr fake_acls xattr_tdb fake_dfq
2503         inherit owner = yes
2504         include = $dfqconffile
2505 [quotadir]
2506         path = $shrdir/quota
2507         admin users = $unix_name
2508
2509 [acl_xattr_ign_sysacl_posix]
2510         copy = tmp
2511         acl_xattr:ignore system acls = yes
2512         acl_xattr:default acl style = posix
2513 [acl_xattr_ign_sysacl_windows]
2514         copy = tmp
2515         acl_xattr:ignore system acls = yes
2516         acl_xattr:default acl style = windows
2517
2518 [mangle_illegal]
2519         copy = tmp
2520         mangled names = illegal
2521
2522 [nosymlinks]
2523         copy = tmp
2524         path = $nosymlinks_shrdir
2525         follow symlinks = no
2526
2527 [local_symlinks]
2528         copy = tmp
2529         path = $local_symlinks_shrdir
2530         follow symlinks = yes
2531
2532 [kernel_oplocks]
2533         copy = tmp
2534         kernel oplocks = yes
2535         vfs objects = streams_xattr xattr_tdb
2536
2537 [streams_xattr]
2538         copy = tmp
2539         vfs objects = streams_xattr xattr_tdb
2540
2541 [compound_find]
2542         copy = tmp
2543         smbd:find async delay usec = 10000
2544 [error_inject]
2545         copy = tmp
2546         vfs objects = error_inject
2547         include = $errorinjectconf
2548
2549 [delay_inject]
2550         copy = tmp
2551         vfs objects = delay_inject
2552         kernel share modes = no
2553         kernel oplocks = no
2554         posix locking = no
2555         include = $delayinjectconf
2556
2557 [aio_delay_inject]
2558         copy = tmp
2559         vfs objects = delay_inject
2560         delay_inject:pread_send = 2000
2561         delay_inject:pwrite_send = 2000
2562
2563 [brl_delay_inject1]
2564         copy = tmp
2565         vfs objects = delay_inject
2566         delay_inject:brl_lock_windows = 90
2567         delay_inject:brl_lock_windows_use_timer = yes
2568
2569 [brl_delay_inject2]
2570         copy = tmp
2571         vfs objects = delay_inject
2572         delay_inject:brl_lock_windows = 90
2573         delay_inject:brl_lock_windows_use_timer = no
2574
2575 [delete_readonly]
2576         path = $prefix_abs/share
2577         delete readonly = yes
2578         ";
2579         close(CONF);
2580
2581         my $net = Samba::bindir_path($self, "net");
2582         my $cmd = "";
2583         $cmd .= "UID_WRAPPER_ROOT=1 ";
2584         $cmd .= "SMB_CONF_PATH=\"$conffile\" ";
2585         $cmd .= "$net setlocalsid $samsid";
2586
2587         my $net_ret = system($cmd);
2588         if ($net_ret != 0) {
2589             warn("net setlocalsid failed: $net_ret\n$cmd");
2590             return undef;
2591         }
2592
2593         unless (open(ERRORCONF, ">$errorinjectconf")) {
2594                 warn("Unable to open $errorinjectconf");
2595                 return undef;
2596         }
2597         close(ERRORCONF);
2598
2599         unless (open(DELAYCONF, ">$delayinjectconf")) {
2600                 warn("Unable to open $delayinjectconf");
2601                 return undef;
2602         }
2603         close(DELAYCONF);
2604
2605         unless (open(DFQCONF, ">$dfqconffile")) {
2606                 warn("Unable to open $dfqconffile");
2607                 return undef;
2608         }
2609         close(DFQCONF);
2610
2611         unless (open(DELAYCONF, ">$globalinjectconf")) {
2612                 warn("Unable to open $globalinjectconf");
2613                 return undef;
2614         }
2615         close(DELAYCONF);
2616
2617         ##
2618         ## create a test account
2619         ##
2620
2621         unless (open(PASSWD, ">$nss_wrapper_passwd")) {
2622            warn("Unable to open $nss_wrapper_passwd");
2623            return undef;
2624         }
2625         print PASSWD "nobody:x:$uid_nobody:$gid_nobody:nobody gecos:$prefix_abs:/bin/false
2626 $unix_name:x:$unix_uid:$unix_gids[0]:$unix_name gecos:$prefix_abs:/bin/false
2627 pdbtest:x:$uid_pdbtest:$gid_nogroup:pdbtest gecos:$prefix_abs:/bin/false
2628 pdbtest2:x:$uid_pdbtest2:$gid_nogroup:pdbtest gecos:$prefix_abs:/bin/false
2629 userdup:x:$uid_userdup:$gid_userdup:userdup gecos:$prefix_abs:/bin/false
2630 pdbtest_wkn:x:$uid_pdbtest_wkn:$gid_everyone:pdbtest_wkn gecos:$prefix_abs:/bin/false
2631 force_user:x:$uid_force_user:$gid_force_user:force user gecos:$prefix_abs:/bin/false
2632 smbget_user:x:$uid_smbget:$gid_domusers:smbget_user gecos:$prefix_abs:/bin/false
2633 user1:x:$uid_user1:$gid_nogroup:user1 gecos:$prefix_abs:/bin/false
2634 user2:x:$uid_user2:$gid_nogroup:user2 gecos:$prefix_abs:/bin/false
2635 gooduser:x:$uid_gooduser:$gid_domusers:gooduser gecos:$prefix_abs:/bin/false
2636 eviluser:x:$uid_eviluser:$gid_domusers:eviluser gecos::/bin/false
2637 slashuser:x:$uid_slashuser:$gid_domusers:slashuser gecos:/:/bin/false
2638 ";
2639         if ($unix_uid != 0) {
2640                 print PASSWD "root:x:$uid_root:$gid_root:root gecos:$prefix_abs:/bin/false
2641 ";
2642         }
2643         close(PASSWD);
2644
2645         unless (open(GROUP, ">$nss_wrapper_group")) {
2646              warn("Unable to open $nss_wrapper_group");
2647              return undef;
2648         }
2649         print GROUP "nobody:x:$gid_nobody:
2650 nogroup:x:$gid_nogroup:nobody
2651 $unix_name-group:x:$unix_gids[0]:
2652 domusers:X:$gid_domusers:
2653 domadmins:X:$gid_domadmins:
2654 userdup:x:$gid_userdup:$unix_name
2655 everyone:x:$gid_everyone:
2656 force_user:x:$gid_force_user:
2657 ";
2658         if ($unix_gids[0] != 0) {
2659                 print GROUP "root:x:$gid_root:
2660 ";
2661         }
2662
2663         close(GROUP);
2664
2665         ## hosts
2666         my $hostname = lc($server);
2667         unless (open(HOSTS, ">>$nss_wrapper_hosts")) {
2668                 warn("Unable to open $nss_wrapper_hosts");
2669                 return undef;
2670         }
2671         print HOSTS "${server_ip} ${hostname}.samba.example.com ${hostname}\n";
2672         print HOSTS "${server_ipv6} ${hostname}.samba.example.com ${hostname}\n";
2673         close(HOSTS);
2674
2675         ## hosts
2676         unless (open(RESOLV_CONF, ">$resolv_conf")) {
2677                 warn("Unable to open $resolv_conf");
2678                 return undef;
2679         }
2680         if (defined($dc_server_ip) or defined($dc_server_ipv6)) {
2681                 if (defined($dc_server_ip)) {
2682                         print RESOLV_CONF "nameserver $dc_server_ip\n";
2683                 }
2684                 if (defined($dc_server_ipv6)) {
2685                         print RESOLV_CONF "nameserver $dc_server_ipv6\n";
2686                 }
2687         } else {
2688                 print RESOLV_CONF "nameserver ${server_ip}\n";
2689                 print RESOLV_CONF "nameserver ${server_ipv6}\n";
2690         }
2691         close(RESOLV_CONF);
2692
2693         foreach my $evlog (@eventlog_list) {
2694                 my $evlogtdb = "$eventlogdir/$evlog.tdb";
2695                 open(EVENTLOG, ">$evlogtdb") or die("Unable to open $evlogtdb");
2696                 close(EVENTLOG);
2697         }
2698
2699         $createuser_env{NSS_WRAPPER_PASSWD} = $nss_wrapper_passwd;
2700         $createuser_env{NSS_WRAPPER_GROUP} = $nss_wrapper_group;
2701         $createuser_env{NSS_WRAPPER_HOSTS} = $nss_wrapper_hosts;
2702         $createuser_env{NSS_WRAPPER_HOSTNAME} = "${hostname}.samba.example.com";
2703         if ($ENV{SAMBA_DNS_FAKING}) {
2704                 $createuser_env{RESOLV_WRAPPER_HOSTS} = $dns_host_file;
2705         } else {
2706                 $createuser_env{RESOLV_WRAPPER_CONF} = $resolv_conf;
2707         }
2708
2709         createuser($self, $unix_name, $password, $conffile, \%createuser_env) || die("Unable to create user");
2710         createuser($self, "force_user", $password, $conffile, \%createuser_env) || die("Unable to create force_user");
2711         createuser($self, "smbget_user", $password, $conffile, \%createuser_env) || die("Unable to create smbget_user");
2712         createuser($self, "user1", $password, $conffile, \%createuser_env) || die("Unable to create user1");
2713         createuser($self, "user2", $password, $conffile, \%createuser_env) || die("Unable to create user2");
2714         createuser($self, "gooduser", $password, $conffile, \%createuser_env) || die("Unable to create gooduser");
2715         createuser($self, "eviluser", $password, $conffile, \%createuser_env) || die("Unable to create eviluser");
2716         createuser($self, "slashuser", $password, $conffile, \%createuser_env) || die("Unable to create slashuser");
2717
2718         open(DNS_UPDATE_LIST, ">$prefix/dns_update_list") or die("Unable to open $$prefix/dns_update_list");
2719         print DNS_UPDATE_LIST "A $server. $server_ip\n";
2720         print DNS_UPDATE_LIST "AAAA $server. $server_ipv6\n";
2721         close(DNS_UPDATE_LIST);
2722
2723         print "DONE\n";
2724
2725         $ret{SERVER_IP} = $server_ip;
2726         $ret{SERVER_IPV6} = $server_ipv6;
2727         $ret{NMBD_TEST_LOG} = "$prefix/nmbd_test.log";
2728         $ret{NMBD_TEST_LOG_POS} = 0;
2729         $ret{WINBINDD_TEST_LOG} = "$prefix/winbindd_test.log";
2730         $ret{WINBINDD_TEST_LOG_POS} = 0;
2731         $ret{SMBD_TEST_LOG} = "$prefix/smbd_test.log";
2732         $ret{SMBD_TEST_LOG_POS} = 0;
2733         $ret{SERVERCONFFILE} = $conffile;
2734         $ret{TESTENV_DIR} = $prefix_abs;
2735         $ret{CONFIGURATION} ="-s $conffile";
2736         $ret{LOCK_DIR} = $lockdir;
2737         $ret{SERVER} = $server;
2738         $ret{USERNAME} = $unix_name;
2739         $ret{USERID} = $unix_uid;
2740         $ret{DOMAIN} = $domain;
2741         $ret{SAMSID} = $samsid;
2742         $ret{NETBIOSNAME} = $server;
2743         $ret{PASSWORD} = $password;
2744         $ret{PIDDIR} = $piddir;
2745         $ret{SELFTEST_WINBINDD_SOCKET_DIR} = $wbsockdir;
2746         $ret{NMBD_SOCKET_DIR} = $nmbdsockdir;
2747         $ret{SOCKET_WRAPPER_DEFAULT_IFACE} = $swiface;
2748         $ret{NSS_WRAPPER_PASSWD} = $nss_wrapper_passwd;
2749         $ret{NSS_WRAPPER_GROUP} = $nss_wrapper_group;
2750         $ret{NSS_WRAPPER_HOSTS} = $nss_wrapper_hosts;
2751         $ret{NSS_WRAPPER_HOSTNAME} = "${hostname}.samba.example.com";
2752         $ret{NSS_WRAPPER_MODULE_SO_PATH} = Samba::nss_wrapper_winbind_so_path($self);
2753         $ret{NSS_WRAPPER_MODULE_FN_PREFIX} = "winbind";
2754         if ($ENV{SAMBA_DNS_FAKING}) {
2755                 $ret{RESOLV_WRAPPER_HOSTS} = $dns_host_file;
2756         } else {
2757                 $ret{RESOLV_WRAPPER_CONF} = $resolv_conf;
2758         }
2759         $ret{LOCAL_PATH} = "$shrdir";
2760         $ret{LOGDIR} = $logdir;
2761
2762         #
2763         # Avoid hitting system krb5.conf -
2764         # An env that needs Kerberos will reset this to the real
2765         # value.
2766         #
2767         $ret{KRB5_CONFIG} = abs_path($prefix) . "/no_krb5.conf";
2768
2769         # Define KRB5CCNAME for each environment we set up
2770         $ret{KRB5_CCACHE} = abs_path($prefix) . "/krb5ccache";
2771         $ENV{KRB5CCNAME} = $ret{KRB5_CCACHE};
2772
2773         return \%ret;
2774 }
2775
2776 sub wait_for_start($$$$$)
2777 {
2778         my ($self, $envvars, $nmbd, $winbindd, $smbd) = @_;
2779         my $cmd;
2780         my $netcmd;
2781         my $ret;
2782
2783         if ($nmbd eq "yes") {
2784                 my $count = 0;
2785
2786                 # give time for nbt server to register its names
2787                 print "checking for nmbd\n";
2788
2789                 # This will return quickly when things are up, but be slow if we need to wait for (eg) SSL init
2790                 my $nmblookup = Samba::bindir_path($self, "nmblookup");
2791
2792                 do {
2793                         $ret = system("$nmblookup $envvars->{CONFIGURATION} $envvars->{SERVER}");
2794                         if ($ret != 0) {
2795                                 sleep(1);
2796                         } else {
2797                                 system("$nmblookup $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} __SAMBA__");
2798                                 system("$nmblookup $envvars->{CONFIGURATION} __SAMBA__");
2799                                 system("$nmblookup $envvars->{CONFIGURATION} -U 127.255.255.255 __SAMBA__");
2800                                 system("$nmblookup $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} $envvars->{SERVER}");
2801                         }
2802                         $count++;
2803                 } while ($ret != 0 && $count < 10);
2804                 if ($count == 10) {
2805                         print "NMBD not reachable after 10 retries\n";
2806                         teardown_env($self, $envvars);
2807                         return 0;
2808                 }
2809         }
2810
2811         if ($winbindd eq "yes") {
2812             print "checking for winbindd\n";
2813             my $count = 0;
2814             $cmd = "SELFTEST_WINBINDD_SOCKET_DIR='$envvars->{SELFTEST_WINBINDD_SOCKET_DIR}' ";
2815             $cmd .= "NSS_WRAPPER_PASSWD='$envvars->{NSS_WRAPPER_PASSWD}' ";
2816             $cmd .= "NSS_WRAPPER_GROUP='$envvars->{NSS_WRAPPER_GROUP}' ";
2817             $cmd .= Samba::bindir_path($self, "wbinfo") . " --ping-dc";
2818
2819             do {
2820                 $ret = system($cmd);
2821                 if ($ret != 0) {
2822                     sleep(1);
2823                 }
2824                 $count++;
2825             } while ($ret != 0 && $count < 20);
2826             if ($count == 20) {
2827                 print "WINBINDD not reachable after 20 seconds\n";
2828                 teardown_env($self, $envvars);
2829                 return 0;
2830             }
2831         }
2832
2833         if ($smbd eq "yes") {
2834             # make sure smbd is also up set
2835             print "wait for smbd\n";
2836
2837             my $count = 0;
2838             do {
2839                 $cmd = Samba::bindir_path($self, "smbclient");
2840                 $cmd .= " $envvars->{CONFIGURATION}";
2841                 $cmd .= " -L $envvars->{SERVER}";
2842                 $cmd .= " -U%";
2843                 $cmd .= " -I $envvars->{SERVER_IP}";
2844                 $cmd .= " -p 139";
2845                 $ret = system($cmd);
2846                 if ($ret != 0) {
2847                     sleep(1);
2848                 }
2849                 $count++
2850             } while ($ret != 0 && $count < 20);
2851             if ($count == 20) {
2852                 print "SMBD failed to start up in a reasonable time (20sec)\n";
2853                 teardown_env($self, $envvars);
2854                 return 0;
2855             }
2856         }
2857
2858         # Ensure we have domain users mapped.
2859         $netcmd = "NSS_WRAPPER_PASSWD='$envvars->{NSS_WRAPPER_PASSWD}' ";
2860         $netcmd .= "NSS_WRAPPER_GROUP='$envvars->{NSS_WRAPPER_GROUP}' ";
2861         $netcmd .= "UID_WRAPPER_ROOT='1' ";
2862         $netcmd .= Samba::bindir_path($self, "net") ." $envvars->{CONFIGURATION} ";
2863
2864         $cmd = $netcmd . "groupmap delete ntgroup=domusers";
2865         $ret = system($cmd);
2866
2867         $cmd = $netcmd . "groupmap add rid=513 unixgroup=domusers type=domain";
2868         $ret = system($cmd);
2869         if ($ret != 0) {
2870                 print("\"$cmd\" failed\n");
2871                 return 1;
2872         }
2873
2874         $cmd = $netcmd . "groupmap delete ntgroup=domadmins";
2875         $ret = system($cmd);
2876
2877         $cmd = $netcmd . "groupmap add rid=512 unixgroup=domadmins type=domain";
2878         $ret = system($cmd);
2879         if ($ret != 0) {
2880                 print("\"$cmd\" failed\n");
2881                 return 1;
2882         }
2883
2884         $cmd = $netcmd . "groupmap delete ntgroup=everyone";
2885         $ret = system($cmd);
2886
2887         $cmd = $netcmd . "groupmap add sid=S-1-1-0 unixgroup=everyone type=builtin";
2888         $ret = system($cmd);
2889         if ($ret != 0) {
2890                 print("\"$cmd\" failed\n");
2891                 return 1;
2892         }
2893
2894         # note: creating builtin groups requires winbindd for the
2895         # unix id allocator
2896         my $create_builtin_users = "no";
2897         if ($winbindd eq "yes") {
2898                 $cmd = "SELFTEST_WINBINDD_SOCKET_DIR='$envvars->{SELFTEST_WINBINDD_SOCKET_DIR}' ";
2899                 $cmd .= "NSS_WRAPPER_PASSWD='$envvars->{NSS_WRAPPER_PASSWD}' ";
2900                 $cmd .= "NSS_WRAPPER_GROUP='$envvars->{NSS_WRAPPER_GROUP}' ";
2901                 $cmd .= Samba::bindir_path($self, "wbinfo") . " --sid-to-gid=S-1-5-32-545";
2902                 my $wbinfo_out = qx($cmd 2>&1);
2903                 if ($? != 0) {
2904                         # wbinfo doesn't give us a better error code then
2905                         # WBC_ERR_DOMAIN_NOT_FOUND, but at least that's
2906                         # different then WBC_ERR_WINBIND_NOT_AVAILABLE
2907                         if ($wbinfo_out !~ /WBC_ERR_DOMAIN_NOT_FOUND/) {
2908                                 print("Failed to run \"wbinfo --sid-to-gid=S-1-5-32-545\": $wbinfo_out");
2909                                 teardown_env($self, $envvars);
2910                                 return 0;
2911                         }
2912                         $create_builtin_users = "yes";
2913                 }
2914         }
2915         if ($create_builtin_users eq "yes") {
2916             $cmd = "SELFTEST_WINBINDD_SOCKET_DIR='$envvars->{SELFTEST_WINBINDD_SOCKET_DIR}' ";
2917             $cmd .= "NSS_WRAPPER_PASSWD='$envvars->{NSS_WRAPPER_PASSWD}' ";
2918             $cmd .= "NSS_WRAPPER_GROUP='$envvars->{NSS_WRAPPER_GROUP}' ";
2919             $cmd .= Samba::bindir_path($self, "net") . " $envvars->{CONFIGURATION} ";
2920             $cmd .= "sam createbuiltingroup Users";
2921             $ret = system($cmd);
2922             if ($ret != 0) {
2923                 print "Failed to create BUILTIN\\Users group\n";
2924                 teardown_env($self, $envvars);
2925                 return 0;
2926             }
2927
2928             $cmd = Samba::bindir_path($self, "net") . " $envvars->{CONFIGURATION} ";
2929             $cmd .= "cache del IDMAP/SID2XID/S-1-5-32-545";
2930             system($cmd);
2931
2932             $cmd = "SELFTEST_WINBINDD_SOCKET_DIR='$envvars->{SELFTEST_WINBINDD_SOCKET_DIR}' ";
2933             $cmd .= "NSS_WRAPPER_PASSWD='$envvars->{NSS_WRAPPER_PASSWD}' ";
2934             $cmd .= "NSS_WRAPPER_GROUP='$envvars->{NSS_WRAPPER_GROUP}' ";
2935             $cmd .= Samba::bindir_path($self, "wbinfo") . " --sid-to-gid=S-1-5-32-545";
2936             $ret = system($cmd);
2937             if ($ret != 0) {
2938                 print "Missing \"BUILTIN\\Users\", did net sam createbuiltingroup Users fail?\n";
2939                 teardown_env($self, $envvars);
2940                 return 0;
2941             }
2942         }
2943
2944         print $self->getlog_env($envvars);
2945
2946         return 1;
2947 }
2948
2949 ##
2950 ## provision and start of ctdb
2951 ##
2952 sub setup_ctdb($$)
2953 {
2954         my ($self, $prefix) = @_;
2955         my $num_nodes = 3;
2956
2957         my $data = $self->provision_ctdb($prefix, $num_nodes);
2958         $data or return undef;
2959
2960         my $rc = $self->check_or_start_ctdb($data);
2961         if (not $rc) {
2962                 print("check_or_start_ctdb() failed\n");
2963                 return undef;
2964         }
2965
2966         $rc = $self->wait_for_start_ctdb($data);
2967         if (not $rc) {
2968                 print "Cluster startup failed\n";
2969                 return undef;
2970         }
2971
2972         return $data;
2973 }
2974
2975 sub provision_ctdb($$$$)
2976 {
2977         my ($self, $prefix, $num_nodes, $no_delete_prefix) = @_;
2978         my $rc;
2979
2980         print "PROVISIONING CTDB...\n";
2981
2982         my $prefix_abs = abs_path($prefix);
2983
2984         #
2985         # check / create directories:
2986         #
2987         die ("prefix_abs = ''") if $prefix_abs eq "";
2988         die ("prefix_abs = '/'") if $prefix_abs eq "/";
2989
2990         mkdir ($prefix_abs, 0777);
2991
2992         print "CREATE CTDB TEST ENVIRONMENT in '$prefix_abs'...\n";
2993
2994         if (not defined($no_delete_prefix) or not $no_delete_prefix) {
2995                 system("rm -rf $prefix_abs/*");
2996         }
2997
2998         #
2999         # Per-node data
3000         #
3001         my @nodes = ();
3002         for (my $i = 0; $i < $num_nodes; $i++) {
3003                 my %node = ();
3004                 my $server_name = "ctdb${i}";
3005                 my $pub_iface = Samba::get_interface($server_name);
3006                 my $ip = "127.0.0.${pub_iface}";
3007
3008                 $node{NODE_NUMBER} = "$i";
3009                 $node{SERVER_NAME} = "$server_name";
3010                 $node{SOCKET_WRAPPER_DEFAULT_IFACE} = "$pub_iface";
3011                 $node{IP} = "$ip";
3012
3013                 push(@nodes, \%node);
3014         }
3015
3016         #
3017         # nodes
3018         #
3019         my $nodes_file = "$prefix/nodes.in";
3020         unless (open(NODES, ">$nodes_file")) {
3021                 warn("Unable to open nodesfile '$nodes_file'");
3022                 return undef;
3023         }
3024         for (my $i = 0; $i < $num_nodes; $i++) {
3025                 my $ip = $nodes[$i]->{IP};
3026                 print NODES "${ip}\n";
3027         }
3028         close(NODES);
3029
3030         #
3031         # local_daemons.sh setup
3032         #
3033         # Socket wrapper setup is done by selftest.pl, so don't use
3034         # the CTDB-specific setup
3035         #
3036         my $cmd;
3037         $cmd .= "ctdb/tests/local_daemons.sh " . $prefix_abs . " setup";
3038         $cmd .= " -n " . $num_nodes;
3039         $cmd .= " -N " . $nodes_file;
3040         # CTDB should not attempt to manage public addresses -
3041         # clients should just connect to CTDB private addresses
3042         $cmd .= " -P " . "/dev/null";
3043
3044         my $ret = system($cmd);
3045         if ($ret != 0) {
3046                 print("\"$cmd\" failed\n");
3047                 return undef;
3048         }
3049
3050         #
3051         # Unix domain socket and node directory for each daemon
3052         #
3053         for (my $i = 0; $i < $num_nodes; $i++) {
3054                 my ($cmd, $ret, $out);
3055
3056                 my $cmd_prefix = "ctdb/tests/local_daemons.sh ${prefix_abs}";
3057
3058                 #
3059                 # socket
3060                 #
3061
3062                 $cmd = "${cmd_prefix} print-socket ${i}";
3063
3064                 $out = `$cmd`;
3065                 $ret = $?;
3066                 if ($ret != 0) {
3067                     print("\"$cmd\" failed\n");
3068                     return undef;
3069                 }
3070                 chomp $out;
3071                 $nodes[$i]->{SOCKET_FILE} = "$out";
3072
3073                 #
3074                 # node directory
3075                 #
3076
3077                 $cmd = "${cmd_prefix} onnode ${i} 'echo \$CTDB_BASE'";
3078
3079                 $out = `$cmd`;
3080                 $ret = $?;
3081                 if ($ret != 0) {
3082                     print("\"$cmd\" failed\n");
3083                     return undef;
3084                 }
3085                 chomp $out;
3086                 $nodes[$i]->{NODE_PREFIX} = "$out";
3087         }
3088
3089         my %ret = ();
3090
3091         $ret{CTDB_PREFIX} = "$prefix";
3092         $ret{NUM_NODES} = $num_nodes;
3093         $ret{CTDB_NODES} = \@nodes;
3094
3095         return \%ret;
3096 }
3097
3098 sub check_or_start_ctdb($$) {
3099         my ($self, $data) = @_;
3100
3101         my $prefix = $data->{CTDB_PREFIX};
3102         my $num_nodes = $data->{NUM_NODES};
3103         my $nodes = $data->{CTDB_NODES};
3104         my $STDIN_READER;
3105
3106         # Share a single stdin pipe for all nodes
3107         pipe($STDIN_READER, $data->{CTDB_STDIN_PIPE});
3108
3109         for (my $i = 0; $i < $num_nodes; $i++) {
3110                 my $node = $nodes->[$i];
3111
3112                 $node->{STDIN_PIPE} = $data->{CTDB_STDIN_PIPE};
3113
3114                 my $cmd = "ctdb/tests/local_daemons.sh";
3115                 my @full_cmd = ("$cmd", "$prefix", "start", "$i");
3116                 # Dummy environment variables to avoid
3117                 # Samba3::get_env_for_process() from generating them
3118                 # and including UID_WRAPPER_ROOT=1, which causes
3119                 # "Unable to secure ctdb socket" error.
3120                 my $env_vars = {
3121                         CTDB_DUMMY => "1",
3122                 };
3123                 my $daemon_ctx = {
3124                         NAME => "ctdbd",
3125                         BINARY_PATH => $cmd,
3126                         FULL_CMD => [ @full_cmd ],
3127                         TEE_STDOUT => 1,
3128                         LOG_FILE => "/dev/null",
3129                         ENV_VARS => $env_vars,
3130                 };
3131
3132                 print "STARTING CTDBD (node ${i})\n";
3133
3134                 # This does magic with $STDIN_READER, so use it
3135                 my $ret = Samba::fork_and_exec($self,
3136                                                $node,
3137                                                $daemon_ctx,
3138                                                $STDIN_READER);
3139
3140                 if ($ret == 0) {
3141                         print("\"$cmd\" failed\n");
3142                         teardown_env_ctdb($self, $data);
3143                         return 0;
3144                 }
3145         }
3146
3147         close($STDIN_READER);
3148
3149         return 1;
3150 }
3151
3152 sub wait_for_start_ctdb($$)
3153 {
3154         my ($self, $data) = @_;
3155
3156         my $prefix = $data->{CTDB_PREFIX};
3157
3158         print "Wait for ctdbd...\n";
3159
3160         my $ctdb = Samba::bindir_path($self, "ctdb");
3161         my $cmd;
3162         $cmd .= "ctdb/tests/local_daemons.sh ${prefix} onnode all";
3163         $cmd .= " ${ctdb} nodestatus all 2>&1";
3164
3165         my $count = 0;
3166         my $wait_seconds = 60;
3167         my $out;
3168
3169         until ($count > $wait_seconds) {
3170                 $out = `$cmd`;
3171                 my $ret = $?;
3172                 if ($ret == 0) {
3173                         print "\ncluster became healthy\n";
3174                         last;
3175                 }
3176                 print "Waiting for CTDB...\n";
3177                 sleep(1);
3178                 $count++;
3179         }
3180
3181         if ($count > $wait_seconds) {
3182                 print "\nGiving up to wait for CTDB...\n";
3183                 print "${out}\n\n";
3184                 print "CTDB log:\n";
3185                 $cmd = "ctdb/tests/local_daemons.sh ${prefix} print-log all >&2";
3186                 system($cmd);
3187                 teardown_env_ctdb($self, $data);
3188                 return 0;
3189         }
3190
3191         print "\nCTDB initialized\n";
3192
3193         return 1;
3194 }
3195
3196 1;