Ignore:
Timestamp:
Nov 24, 2016, 1:14:11 PM (9 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to version 4.4.3

Location:
vendor/current/selftest
Files:
90 added
6 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/selftest/README

    r740 r988  
    22
    33This directory contains test scripts that are useful for running a
    4 bunch of tests all at once. 
     4bunch of tests all at once.
    55
    6 There are two parts to this: 
     6There are two parts to this:
    77
    88 * The test runner (selftest/selftest.pl)
    99 * The test formatter
    1010
    11 selftest.pl simply outputs subunit, which can then be formatted or analyzed 
    12 by tools that understand the subunit protocol. One of these tools is 
     11selftest.pl simply outputs subunit, which can then be formatted or analyzed
     12by tools that understand the subunit protocol. One of these tools is
    1313format-subunit, which is used by default as part of "make test".
    1414
    1515Available testsuites
    1616====================
    17 The available testsuites are obtained from a script, usually 
    18 source{3,4}/selftest/tests.sh. This script should for each testsuite output
    19 the name of the test, the command to run and the environment that should be 
     17The available testsuites are obtained from a script, usually
     18source{3,4}/selftest/tests.py. This script should for each testsuite output
     19the name of the test, the command to run and the environment that should be
    2020provided. Use the included "plantest" function to generate the required output.
    2121
    … …  
    2525Exit code
    2626------------
    27 The testsuites should exit with a non-zero exit code if at least one 
     27The testsuites should exit with a non-zero exit code if at least one
    2828test failed. Skipped tests should not influence the exit code.
    2929
    3030Output format
    3131-------------
    32 Testsuites can simply use the exit code to indicate whether all of their 
    33 tests have succeeded or one or more have failed. It is also possible to 
    34 provide more granular information using the Subunit protocol. 
     32Testsuites can simply use the exit code to indicate whether all of their
     33tests have succeeded or one or more have failed. It is also possible to
     34provide more granular information using the Subunit protocol.
    3535
    36 This protocol works by writing simple messages to standard output. Any 
    37 messages that can not be interpreted by this protocol are considered comments 
     36This protocol works by writing simple messages to standard output. Any
     37messages that can not be interpreted by this protocol are considered comments
    3838for the last announced test.
    3939
    40 For a full description of the subunit protocol, see ../lib/subunit/README.
     40For a full description of the subunit protocol, see the README file in the subunit
     41repository at http://github.com/testing-cabal/subunit.
    4142
    4243The following commands are Samba extensions to Subunit:
    43 
    44 testsuite-count
    45 ~~~~~~~~~~~~~~~
    46 testsuite-count: number
    47 
    48 Announce the number of tests that is going to be run.
    4944
    5045start-testsuite
    … …  
    7469Environments
    7570============
    76 Tests often need to run against a server with particular things set up, 
    77 a "environment". This environment is provided by the test "target": Samba 3, 
     71Tests often need to run against a server with particular things set up,
     72a "environment". This environment is provided by the test "target": Samba 3,
    7873Samba 4 or Windows.
    7974
    80 The following environments are currently available:
     75The environments are currently available include
    8176
    8277 - none: No server set up, no variables set.
    83  - dc: Domain controller set up. The following environment variables will
     78 - dc,s3dc: Domain controller set up. The following environment variables will
    8479   be set:
    8580
    8681     * USERNAME: Administrator user name
    87          * PASSWORD: Administrator password
    88          * DOMAIN: Domain name
    89          * REALM: Realm name
    90          * SERVER: DC host name
    91          * SERVER_IP: DC IPv4 address
    92          * NETBIOSNAME: DC NetBIOS name
    93          * NETIOSALIAS: DC NetBIOS alias
     82     * PASSWORD: Administrator password
     83     * DOMAIN: Domain name
     84     * REALM: Realm name
     85     * SERVER: DC host name
     86     * SERVER_IP: DC IPv4 address
     87     * SERVER_IPV6: DC IPv6 address
     88     * NETBIOSNAME: DC NetBIOS name
     89     * NETIOSALIAS: DC NetBIOS alias
    9490
    95  - member: Domain controller and member server that is joined to it set up. The
     91 - member,s4member,s3member: Domain controller and member server that is joined to it set up. The
    9692   following environment variables will be set:
    9793
    9894     * USERNAME: Domain administrator user name
    99         * PASSWORD: Domain administrator password
    100         * DOMAIN: Domain name
    101         * REALM: Realm name
    102         * SERVER: Name of the member server
     95    * PASSWORD: Domain administrator password
     96    * DOMAIN: Domain name
     97    * REALM: Realm name
     98    * SERVER: Name of the member server
    10399
     100See Samba.pm, Samba3.pm and Samba4.pm for the full list.
    104101
    105102Running tests
    … …  
    110107   make test
    111108
    112 To run a quick subset (aiming for about 1 minute of testing) run::
     109To run a quicker subset run::
    113110
    114111   make quicktest

  • vendor/current/selftest/filter-subunit

    r740 r988  
    11#!/usr/bin/env python
    22# Filter a subunit stream
    3 # Copyright (C) Jelmer Vernooij <jelmer@samba.org>
    4 # Published under the GNU GPL, v3 or later
     3# Copyright (C) 2009-2011 Jelmer Vernooij <jelmer@samba.org>
     4
     5# This program is free software; you can redistribute it and/or modify
     6# it under the terms of the GNU General Public License as published by
     7# the Free Software Foundation; either version 3 of the License, or
     8# (at your option) any later version.
     9
     10# This program is distributed in the hope that it will be useful,
     11# but WITHOUT ANY WARRANTY; without even the implied warranty of
     12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     13# GNU General Public License for more details.
     14
     15# You should have received a copy of the GNU General Public License
     16# along with this program.  If not, see <http://www.gnu.org/licenses/>.
     17
     18# NOTE: This script is a hack, meant as a placeholder until we can migrate
     19# to upstream subunit's filtering tools.
    520
    621import optparse
    7 import os
    822import sys
    923import signal
    1024
    11 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../lib/subunit/python"))
    12 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../lib/testtools"))
     25sys.path.insert(0, "bin/python")
    1326
    1427import subunithelper
    1528
    1629parser = optparse.OptionParser("filter-subunit [options] < instream > outstream")
    17 parser.add_option("--expected-failures", type="string",
    18         help="File containing list of regexes matching tests to consider known "
    19              "failures")
    20 parser.add_option("--strip-passed-output", action="store_true",
     30parser.add_option("--expected-failures", type="string",
     31    help="File containing list of regexes matching tests to consider known "
     32         "failures")
     33parser.add_option("--flapping", type="string",
     34    help="File containing list of flapping tests, of which to ignore results.")
     35parser.add_option("--strip-passed-output", action="store_true",
    2136    help="Whether to strip output from tests that passed")
    22 parser.add_option("--fail-immediately", action="store_true", 
     37parser.add_option("--fail-immediately", action="store_true",
    2338    help="Whether to stop on the first error", default=False)
    2439parser.add_option("--prefix", type="string",
    25         help="Add prefix to all test names")
     40    help="Add prefix to all test names")
     41parser.add_option("--suffix", type="string",
     42    help="Add suffix to all test names")
    2643parser.add_option("--fail-on-empty", default=False,
    27         action="store_true", help="Fail if there was no subunit output")
     44    action="store_true", help="Fail if there was no subunit output")
    2845parser.add_option("--list", default=False,
    29         action="store_true", help="Operate in list mode")
     46    action="store_true", help="Operate in list mode")
    3047opts, args = parser.parse_args()
    3148
    3249if opts.list:
    33         prefix = opts.prefix
    34         if not prefix:
    35                 prefix = ""
    36         for l in sys.stdin:
    37                 sys.stdout.write("%s%s\n" % (prefix, l.rstrip()))
    38         sys.exit(0)
     50    prefix = opts.prefix
     51    suffix = opts.suffix
     52    if not prefix:
     53        prefix = ""
     54    if not suffix:
     55        suffix = ""
     56    for l in sys.stdin:
     57         sys.stdout.write("%s%s%s\n" % (prefix, l.rstrip(), suffix))
     58    sys.exit(0)
    3959
    4060if opts.expected_failures:
    41         expected_failures = subunithelper.read_test_regexes(opts.expected_failures)
     61    expected_failures = subunithelper.read_test_regexes(opts.expected_failures)
    4262else:
    43         expected_failures = {}
     63    expected_failures = {}
     64
     65
     66if opts.flapping:
     67    flapping = subunithelper.read_test_regexes(opts.flapping)
     68else:
     69    flapping = {}
    4470
    4571statistics = {
    46         'TESTS_UNEXPECTED_OK': 0,
    47         'TESTS_EXPECTED_OK': 0,
    48         'TESTS_UNEXPECTED_FAIL': 0,
    49         'TESTS_EXPECTED_FAIL': 0,
    50         'TESTS_ERROR': 0,
    51         'TESTS_SKIP': 0,
     72    'TESTS_UNEXPECTED_OK': 0,
     73    'TESTS_EXPECTED_OK': 0,
     74    'TESTS_UNEXPECTED_FAIL': 0,
     75    'TESTS_EXPECTED_FAIL': 0,
     76    'TESTS_ERROR': 0,
     77    'TESTS_SKIP': 0,
    5278}
    5379
    5480def handle_sigint(sig, stack):
    55         sys.exit(0)
     81    sys.exit(0)
    5682signal.signal(signal.SIGINT, handle_sigint)
    5783
    5884out = subunithelper.SubunitOps(sys.stdout)
    59 msg_ops = subunithelper.FilterOps(out, opts.prefix, expected_failures,
    60                                   opts.strip_passed_output,
    61                                   fail_immediately=opts.fail_immediately)
     85msg_ops = subunithelper.FilterOps(out, opts.prefix, opts.suffix, expected_failures,
     86    opts.strip_passed_output,
     87    fail_immediately=opts.fail_immediately,
     88    flapping=flapping)
    6289
    6390try:
    64         ret = subunithelper.parse_results(msg_ops, statistics, sys.stdin)
     91    ret = subunithelper.parse_results(msg_ops, statistics, sys.stdin)
    6592except subunithelper.ImmediateFail:
    66         sys.stdout.flush()
    67         sys.exit(1)
     93    sys.stdout.flush()
     94    sys.exit(1)
    6895
    6996if opts.fail_on_empty and not msg_ops.seen_output:
    70         sys.exit(1)
     97    sys.exit(1)
    7198else:
    72         sys.exit(ret)
     99    sys.exit(ret)

  • vendor/current/selftest/format-subunit

    r740 r988  
    1010import sys
    1111
    12 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../lib/subunit/python"))
    13 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../lib/testtools"))
     12sys.path.insert(0, "bin/python")
    1413
    1514import subunithelper
    … …  
    1817parser.add_option("--verbose", action="store_true",
    1918    help="Be verbose")
    20 parser.add_option("--immediate", action="store_true", 
     19parser.add_option("--immediate", action="store_true",
    2120    help="Show failures immediately, don't wait until test run has finished")
    2221parser.add_option("--prefix", type="string", default=".",
    … …  
    2625
    2726def handle_sigint(sig, stack):
    28         sys.exit(0)
     27    sys.exit(0)
     28
    2929signal.signal(signal.SIGINT, handle_sigint)
    3030

  • vendor/current/selftest/gdb_backtrace

    r740 r988  
    5959}
    6060
    61 #
     61need_binary="no"
     62case "${DB}" in
     63# These debuggers need the process binary specified:
     64        ladebug)
     65        need_binary="yes"
     66        ;;
     67        gdb66)
     68        need_binary="yes"
     69        ;;
     70        dbx)
     71        need_binary="yes"
     72        ;;
     73esac
     74
     75test x"${need_binary}" = x"yes" && {
     76
    6277# we first try to use /proc/${PID}/exe or /proc/{$PID}/path for solaris
    6378# then fallback to the binary from the commandline
    … …  
    6580# 'which'
    6681#
    67 test -f "/proc/${PID}/exe" && BINARY="/proc/${PID}/exe"
    68 test -f "/proc/${PID}/path/a.out" && BINARY=`ls -l /proc/${PID}/path/a.out |sed 's/.*-> //'`
    69 test x"${BINARY}" = x"" && BINARY="/proc/${PID}/exe"
    70 test -f "${BINARY}" || BINARY=`which ${BINARY}`
    71 
    72 test -f "${BINARY}" || {
    73         echo "${BASENAME}: ERROR: Cannot find binary '${BINARY}'."
    74         exit 1
     82        test -f "/proc/${PID}/exe" && BINARY="/proc/${PID}/exe"
     83        test -f "/proc/${PID}/path/a.out" && BINARY=`ls -l /proc/${PID}/path/a.out |sed 's/.*-> //'`
     84        test x"${BINARY}" = x"" && BINARY="/proc/${PID}/exe"
     85        test -f "${BINARY}" || BINARY=`which ${BINARY}`
     86       
     87        test -f "${BINARY}" || {
     88            echo "${BASENAME}: ERROR: Cannot find binary '${BINARY}'."
     89            exit 1
     90        }
    7591}
    76 
    77 echo "${BASENAME}: Trying to use ${DB_BIN} on ${BINARY} on PID ${PID}"
    7892
    7993BATCHFILE_PRE=/tmp/gdb_backtrace_pre.$$

  • vendor/current/selftest/in_screen

    r740 r988  
    7070echo $$ > $basedir/$SERVERNAME.parent.pid
    7171trap cleanup SIGINT SIGTERM SIGPIPE
    72 screen -r -X screen -t test:$SERVERNAME bash $basedir/$SERVERNAME.launch
     72
     73if [[ "$TMUX" ]]; then
     74    TMUX_CMD=tmux
     75    if [[ $TMUX = *tmate* ]]; then
     76        TMUX_CMD=tmate
     77    fi
     78
     79    $TMUX_CMD new-window -n test:$SERVERNAME "bash $basedir/$SERVERNAME.launch"
     80else
     81    screen -r -X screen -t test:$SERVERNAME bash $basedir/$SERVERNAME.launch
     82fi
    7383echo "$(date) waiting in $$" >> $basedir/$SERVERNAME.log
    7484read stdin_var

  • vendor/current/selftest/selftest.pl

    r740 r988  
    1616# You should have received a copy of the GNU General Public License
    1717# along with this program.  If not, see <http://www.gnu.org/licenses/>.
    18 
    19 =pod
    20 
    21 =head1 NAME
    22 
    23 selftest - Samba test runner
    24 
    25 =head1 SYNOPSIS
    26 
    27 selftest --help
    28 
    29 selftest [--srcdir=DIR] [--builddir=DIR] [--exeext=EXT][--target=samba4|samba3|win|kvm] [--socket-wrapper] [--quick] [--exclude=FILE] [--include=FILE] [--one] [--prefix=prefix] [--testlist=FILE] [TESTS]
    30 
    31 =head1 DESCRIPTION
    32 
    33 A simple test runner. TESTS is a regular expression with tests to run.
    34 
    35 =head1 OPTIONS
    36 
    37 =over 4
    38 
    39 =item I<--help>
    40 
    41 Show list of available options.
    42 
    43 =item I<--srcdir=DIR>
    44 
    45 Source directory.
    46 
    47 =item I<--builddir=DIR>
    48 
    49 Build directory.
    50 
    51 =item I<--exeext=EXT>
    52 
    53 Executable extention
    54 
    55 =item I<--prefix=DIR>
    56 
    57 Change directory to run tests in. Default is 'st'.
    58 
    59 =item I<--target samba4|samba3|win|kvm>
    60 
    61 Specify test target against which to run. Default is 'samba4'.
    62 
    63 =item I<--quick>
    64 
    65 Run only a limited number of tests. Intended to run in about 30 seconds on
    66 moderately recent systems.
    67                
    68 =item I<--socket-wrapper>
    69 
    70 Use socket wrapper library for communication with server. Only works
    71 when the server is running locally.
    72 
    73 Will prevent TCP and UDP ports being opened on the local host but
    74 (transparently) redirects these calls to use unix domain sockets.
    75 
    76 =item I<--exclude>
    77 
    78 Specify a file containing a list of tests that should be skipped. Possible
    79 candidates are tests that segfault the server, flip or don't end.
    80 
    81 =item I<--include>
    82 
    83 Specify a file containing a list of tests that should be run. Same format
    84 as the --exclude flag.
    85 
    86 Not includes specified means all tests will be run.
    87 
    88 =item I<--one>
    89 
    90 Abort as soon as one test fails.
    91 
    92 =item I<--testlist>
    93 
    94 Load a list of tests from the specified location.
    95 
    96 =back
    97 
    98 =head1 ENVIRONMENT
    99 
    100 =over 4
    101 
    102 =item I<SMBD_VALGRIND>
    103 
    104 =item I<TORTURE_MAXTIME>
    105 
    106 =item I<VALGRIND>
    107 
    108 =item I<TLS_ENABLED>
    109 
    110 =item I<srcdir>
    111 
    112 =back
    113 
    114 =head1 LICENSE
    115 
    116 selftest is licensed under the GNU General Public License L<http://www.gnu.org/licenses/gpl.html>.
    117 
    118 =head1 AUTHOR
    119 
    120 Jelmer Vernooij
    121 
    122 =cut
    12318
    12419use strict;
    … …  
    13328use Subunit;
    13429use SocketWrapper;
     30use target::Samba;
    13531
    13632eval {
    … …  
    14339
    14440my $opt_help = 0;
    145 my $opt_target = "samba4";
     41my $opt_target = "samba";
    14642my $opt_quick = 0;
    14743my $opt_socket_wrapper = 0;
    14844my $opt_socket_wrapper_pcap = undef;
    14945my $opt_socket_wrapper_keep_pcap = undef;
     46my $opt_random_order = 0;
    15047my $opt_one = 0;
    15148my @opt_exclude = ();
    15249my @opt_include = ();
    153 my $opt_verbose = 0;
    154 my $opt_image = undef;
    15550my $opt_testenv = 0;
    15651my $opt_list = 0;
    15752my $ldap = undef;
    15853my $opt_resetup_env = undef;
    159 my $opt_bindir = undef;
    16054my $opt_load_list = undef;
     55my $opt_libnss_wrapper_so_path = "";
     56my $opt_libresolv_wrapper_so_path = "";
     57my $opt_libsocket_wrapper_so_path = "";
     58my $opt_libuid_wrapper_so_path = "";
     59my $opt_use_dns_faking = 0;
    16160my @testlists = ();
    16261
    16362my $srcdir = ".";
    164 my $builddir = ".";
    165 my $exeext = "";
     63my $bindir = "./bin";
    16664my $prefix = "./st";
    16765
    16866my @includes = ();
    16967my @excludes = ();
    170 
    171 sub pipe_handler {
    172         my $sig = shift @_;
    173         print STDERR "Exiting early because of SIGPIPE.\n";
    174         exit(1);
    175 }
    176 
    177 $SIG{PIPE} = \&pipe_handler;
    17868
    17969sub find_in_list($$)
    … …  
    301191Generic options:
    302192 --help                     this help page
    303  --target=samba[34]|win|kvm Samba version to target
    304  --testlist=FILE            file to read available tests from
     193 --target=samba[3]|win      Samba version to target
     194 --testlist=FILE            file to read available tests from
     195 --exclude=FILE             Exclude tests listed in the file
     196 --include=FILE             Include tests listed in the file
    305197
    306198Paths:
    307199 --prefix=DIR               prefix to run tests in [st]
    308200 --srcdir=DIR               source directory [.]
    309  --builddir=DIR             output directory [.]
    310  --exeext=EXT               executable extention []
     201 --bindir=DIR               binaries directory [./bin]
     202
     203Preload cwrap:
     204 --nss_wrapper_so_path=FILE the nss_wrapper library to preload
     205 --resolv_wrapper_so_path=FILE the resolv_wrapper library to preload
     206 --socket_wrapper_so_path=FILE the socket_wrapper library to preload
     207 --uid_wrapper_so_path=FILE the uid_wrapper library to preload
     208
     209DNS:
     210  --use-dns-faking          Fake DNS entries rather than talking to our
     211                            DNS implementation.
    311212
    312213Target Specific:
    313  --socket-wrapper-pcap      save traffic to pcap directories
     214 --socket-wrapper-pcap      save traffic to pcap directories
    314215 --socket-wrapper-keep-pcap keep all pcap files, not just those for tests that
    315216                            failed
    316217 --socket-wrapper           enable socket wrapper
    317  --bindir=PATH              path to target binaries
    318218
    319219Samba4 Specific:
    320220 --ldap=openldap|fedora-ds  back samba onto specified ldap server
    321 
    322 Kvm Specific:
    323  --image=PATH               path to KVM image
    324221
    325222Behaviour:
    326223 --quick                    run quick overall test
    327224 --one                      abort when the first test fails
    328  --verbose                  be verbose
    329225 --testenv                  run a shell in the requested test environment
    330226 --list                     list available tests
    … …  
    345241                'include=s' => \@opt_include,
    346242                'srcdir=s' => \$srcdir,
    347                 'builddir=s' => \$builddir,
    348                 'exeext=s' => \$exeext,
    349                 'verbose' => \$opt_verbose,
     243                'bindir=s' => \$bindir,
    350244                'testenv' => \$opt_testenv,
    351245                'list' => \$opt_list,
    352246                'ldap:s' => \$ldap,
    353247                'resetup-environment' => \$opt_resetup_env,
    354                 'bindir:s' => \$opt_bindir,
    355                 'image=s' => \$opt_image,
    356248                'testlist=s' => \@testlists,
     249                'random-order' => \$opt_random_order,
    357250                'load-list=s' => \$opt_load_list,
     251                'nss_wrapper_so_path=s' => \$opt_libnss_wrapper_so_path,
     252                'resolv_wrapper_so_path=s' => \$opt_libresolv_wrapper_so_path,
     253                'socket_wrapper_so_path=s' => \$opt_libsocket_wrapper_so_path,
     254                'uid_wrapper_so_path=s' => \$opt_libuid_wrapper_so_path,
     255                'use-dns-faking' => \$opt_use_dns_faking
    358256            );
    359257
    … …  
    372270unless (defined($ENV{VALGRIND})) {
    373271        $ENV{VALIDATE} = "validate";
    374         $ENV{MALLOC_CHECK_} = 2;
     272        $ENV{MALLOC_CHECK_} = 3;
    375273}
    376274
    … …  
    378276$ENV{PYTHONUNBUFFERED} = 1;
    379277
    380 my $bindir = ($opt_bindir or "$builddir/bin");
    381278my $bindir_abs = abs_path($bindir);
    382279
    … …  
    402299die("using an empty prefix isn't allowed") unless $prefix ne "";
    403300
    404 #Ensure we have the test prefix around
    405 mkdir($prefix, 0777) unless -d $prefix;
     301# Ensure we have the test prefix around.
     302#
     303# We need restrictive
     304# permissions on this as some subdirectories in this tree will have
     305# wider permissions (ie 0777) and this would allow other users on the
     306# host to subvert the test process.
     307mkdir($prefix, 0700) unless -d $prefix;
     308chmod 0700, $prefix;
    406309
    407310my $prefix_abs = abs_path($prefix);
    … …  
    410313
    411314my $srcdir_abs = abs_path($srcdir);
    412 my $builddir_abs = abs_path($builddir);
    413315
    414316die("using an empty absolute prefix isn't allowed") unless $prefix_abs ne "";
    … …  
    420322$ENV{SRCDIR} = $srcdir;
    421323$ENV{SRCDIR_ABS} = $srcdir_abs;
    422 $ENV{BUILDDIR} = $builddir;
    423 $ENV{BUILDDIR_ABS} = $builddir_abs;
    424324$ENV{BINDIR} = $bindir_abs;
    425 $ENV{EXEEXT} = $exeext;
    426325
    427326my $tls_enabled = not $opt_quick;
    … …  
    449348        $opt_socket_wrapper = 1;
    450349}
     350
     351my $ld_preload = $ENV{LD_PRELOAD};
     352
     353if ($opt_libnss_wrapper_so_path) {
     354        if ($ld_preload) {
     355                $ld_preload = "$ld_preload:$opt_libnss_wrapper_so_path";
     356        } else {
     357                $ld_preload = "$opt_libnss_wrapper_so_path";
     358        }
     359}
     360
     361if ($opt_libresolv_wrapper_so_path) {
     362        if ($ld_preload) {
     363                $ld_preload = "$ld_preload:$opt_libresolv_wrapper_so_path";
     364        } else {
     365                $ld_preload = "$opt_libresolv_wrapper_so_path";
     366        }
     367}
     368
     369if ($opt_libsocket_wrapper_so_path) {
     370        if ($ld_preload) {
     371                $ld_preload = "$ld_preload:$opt_libsocket_wrapper_so_path";
     372        } else {
     373                $ld_preload = "$opt_libsocket_wrapper_so_path";
     374        }
     375}
     376
     377if ($opt_libuid_wrapper_so_path) {
     378        if ($ld_preload) {
     379                $ld_preload = "$ld_preload:$opt_libuid_wrapper_so_path";
     380        } else {
     381                $ld_preload = "$opt_libuid_wrapper_so_path";
     382        }
     383}
     384
     385$ENV{LD_PRELOAD} = $ld_preload;
     386print "LD_PRELOAD=$ENV{LD_PRELOAD}\n";
     387
     388# Enable uid_wrapper globally
     389$ENV{UID_WRAPPER} = 1;
     390
     391# Disable RTLD_DEEPBIND hack for Samba bind dlz module
     392#
     393# This is needed in order to allow the ldb_*ldap module
     394# to work with a preloaded socket wrapper.
     395$ENV{LDB_MODULES_DISABLE_DEEPBIND} = 1;
    451396
    452397my $socket_wrapper_dir;
    … …  
    454399        $socket_wrapper_dir = SocketWrapper::setup_dir("$prefix_abs/w", $opt_socket_wrapper_pcap);
    455400        print "SOCKET_WRAPPER_DIR=$socket_wrapper_dir\n";
    456 } else {
    457          unless ($< == 0) { 
    458                  print "WARNING: Not using socket wrapper, but also not running as root. Will not be able to listen on proper ports\n";
     401} elsif (not $opt_list) {
     402         unless ($< == 0) {
     403                 warn("not using socket wrapper, but also not running as root. Will not be able to listen on proper ports");
    459404         }
     405}
     406
     407if ($opt_use_dns_faking) {
     408        print "DNS: Faking nameserver\n";
     409        $ENV{SAMBA_DNS_FAKING} = 1;
    460410}
    461411
    … …  
    463413my $testenv_default = "none";
    464414
    465 if ($opt_target eq "samba4") {
    466         $testenv_default = "all";
    467         require target::Samba4;
    468         $target = new Samba4($bindir, $ldap, $srcdir, $exeext);
    469 } elsif ($opt_target eq "samba3") {
    470         if ($opt_socket_wrapper and `$bindir/smbd -b | grep SOCKET_WRAPPER` eq "") {
    471                 die("You must include --enable-socket-wrapper when compiling Samba in order to execute 'make test'.  Exiting....");
    472         }
    473         $testenv_default = "member";
    474         require target::Samba3;
    475         $target = new Samba3($bindir, $srcdir_abs);
    476 } elsif ($opt_target eq "win") {
    477         die("Windows tests will not run with socket wrapper enabled.")
    478                 if ($opt_socket_wrapper);
    479         $testenv_default = "dc";
    480         require target::Windows;
    481         $target = new Windows();
    482 } elsif ($opt_target eq "kvm") {
    483         die("Kvm tests will not run with socket wrapper enabled.")
    484                 if ($opt_socket_wrapper);
    485         require target::Kvm;
    486         die("No image specified") unless ($opt_image);
    487         $target = new Kvm($opt_image, undef);
    488 }
    489 
    490 #
    491 # Start a Virtual Distributed Ethernet Switch
    492 # Returns the pid of the switch.
    493 #
    494 sub start_vde_switch($)
    495 {
    496         my ($path) = @_;
    497 
    498         system("vde_switch --pidfile $path/vde.pid --sock $path/vde.sock --daemon");
    499 
    500         open(PID, "$path/vde.pid");
    501         <PID> =~ /([0-9]+)/;
    502         my $pid = $1;
    503         close(PID);
    504 
    505         return $pid;
    506 }
    507 
    508 # Stop a Virtual Distributed Ethernet Switch
    509 sub stop_vde_switch($)
    510 {
    511         my ($pid) = @_;
    512         kill 9, $pid;
     415# After this many seconds, the server will self-terminate.  All tests
     416# must terminate in this time, and testenv will only stay alive this
     417# long
     418
     419my $server_maxtime;
     420if ($opt_testenv) {
     421    # 1 year should be enough :-)
     422    $server_maxtime = 365 * 24 * 60 * 60;
     423} else {
     424    # make test should run under 4 hours
     425    $server_maxtime = 4 * 60 * 60;
     426}
     427
     428if (defined($ENV{SMBD_MAXTIME}) and $ENV{SMBD_MAXTIME} ne "") {
     429    $server_maxtime = $ENV{SMBD_MAXTIME};
     430}
     431
     432unless ($opt_list) {
     433        if ($opt_target eq "samba") {
     434                $testenv_default = "ad_dc_ntvfs";
     435                require target::Samba;
     436                $target = new Samba($bindir, $ldap, $srcdir, $server_maxtime);
     437        } elsif ($opt_target eq "samba3") {
     438                $testenv_default = "nt4_member";
     439                require target::Samba3;
     440                $target = new Samba3($bindir, $srcdir_abs, $server_maxtime);
     441        }
    513442}
    514443
    … …  
    570499        }
    571500
     501        if ( -d "$clientdir/statedir" ) {
     502                unlink <$clientdir/statedir/*>;
     503        } else {
     504                mkdir("$clientdir/statedir", 0777);
     505        }
     506
     507        if ( -d "$clientdir/cachedir" ) {
     508                unlink <$clientdir/cachedir/*>;
     509        } else {
     510                mkdir("$clientdir/cachedir", 0777);
     511        }
     512
     513        # this is ugly, but the ncalrpcdir needs exactly 0755
     514        # otherwise tests fail.
     515        my $mask = umask;
     516        umask 0022;
     517        if ( -d "$clientdir/ncalrpcdir/np" ) {
     518                unlink <$clientdir/ncalrpcdir/np/*>;
     519                rmdir "$clientdir/ncalrpcdir/np";
     520        }
    572521        if ( -d "$clientdir/ncalrpcdir" ) {
    573522                unlink <$clientdir/ncalrpcdir/*>;
    574         } else {
    575                 mkdir("$clientdir/ncalrpcdir", 0777);
    576         }
     523                rmdir "$clientdir/ncalrpcdir";
     524        }
     525        mkdir("$clientdir/ncalrpcdir", 0755);
     526        umask $mask;
     527
     528        my $cadir = "$ENV{SRCDIR_ABS}/selftest/manage-ca/CA-samba.example.com";
     529        my $cacert = "$cadir/Public/CA-samba.example.com-cert.pem";
     530        my $cacrl_pem = "$cadir/Public/CA-samba.example.com-crl.pem";
     531        my $ca_users_dir = "$cadir/Users";
     532
     533        if ( -d "$clientdir/pkinit" ) {
     534                unlink <$clientdir/pkinit/*>;
     535        } else {
     536                mkdir("$clientdir/pkinit", 0700);
     537        }
     538
     539        # each user has a USER-${USER_PRINCIPAL_NAME}-cert.pem and
     540        # USER-${USER_PRINCIPAL_NAME}-private-key.pem symlink
     541        # We make a copy here and make the certificated easily
     542        # accessable in the client environment.
     543        my $mask = umask;
     544        umask 0077;
     545        opendir USERS, "${ca_users_dir}" or die "Could not open dir '${ca_users_dir}': $!";
     546        for my $d (readdir USERS) {
     547                my $user_dir = "${ca_users_dir}/${d}";
     548                next if ${d} =~ /^\./;
     549                next if (! -d "${user_dir}");
     550                opendir USER, "${user_dir}" or die "Could not open dir '${user_dir}': $!";
     551                for my $l (readdir USER) {
     552                        my $user_link = "${user_dir}/${l}";
     553                        next if ${l} =~ /^\./;
     554                        next if (! -l "${user_link}");
     555
     556                        my $dest = "${clientdir}/pkinit/${l}";
     557                        Samba::copy_file_content(${user_link}, ${dest});
     558                }
     559                closedir USER;
     560        }
     561        closedir USERS;
     562        umask $mask;
    577563
    578564        open(CF, ">$conffile");
    579565        print CF "[global]\n";
    580         if (defined($ENV{VALGRIND})) {
    581                 print CF "\ticonv:native = true\n";
    582         } else {
    583                 print CF "\ticonv:native = false\n";
    584         }
    585566        print CF "\tnetbios name = client\n";
    586567        if (defined($vars->{DOMAIN})) {
    … …  
    596577        private dir = $clientdir/private
    597578        lock dir = $clientdir/lockdir
     579        state directory = $clientdir/statedir
     580        cache directory = $clientdir/cachedir
    598581        ncalrpc dir = $clientdir/ncalrpcdir
    599         name resolve order = bcast file
    600         panic action = $RealBin/gdb_backtrace \%PID\% \%PROG\%
     582        panic action = $RealBin/gdb_backtrace \%d
    601583        max xmit = 32K
    602584        notify:inotify = false
    … …  
    608590#We don't want to pass our self-tests if the PAC code is wrong
    609591        gensec:require_pac = true
    610         resolv:host file = $prefix_abs/dns_host_file
    611592#We don't want to run 'speed' tests for very long
    612593        torture:timelimit = 1
     594        winbind separator = /
     595        tls cafile = ${cacert}
     596        tls crlfile = ${cacrl_pem}
     597        tls verify peer = no_check
    613598";
    614599        close(CF);
    … …  
    639624
    640625        while (<IN>) {
    641                 if (/-- TEST(-LOADLIST|-IDLIST|) --\n/) {
     626                if (/-- TEST(-LOADLIST|) --\n/) {
    642627                        my $supports_loadlist = (defined($1) and $1 eq "-LOADLIST");
    643                         my $supports_idlist = (defined($1) and $1 eq "-IDLIST");
    644628                        my $name = <IN>;
    645629                        $name =~ s/\n//g;
    646630                        my $env = <IN>;
    647631                        $env =~ s/\n//g;
     632                        my $loadlist;
     633                        if ($supports_loadlist) {
     634                                $loadlist = <IN>;
     635                                $loadlist =~ s/\n//g;
     636                        }
    648637                        my $cmdline = <IN>;
    649638                        $cmdline =~ s/\n//g;
    650639                        if (should_run_test($name) == 1) {
    651                                 push (@ret, [$name, $env, $cmdline, $supports_loadlist, $supports_idlist]);
     640                                push (@ret, [$name, $env, $cmdline, $loadlist]);
    652641                        }
    653642                } else {
    … …  
    655644                }
    656645        }
    657         close(IN) or die("Error creating recipe");
     646        close(IN) or die("Error creating recipe from $filename");
    658647        return @ret;
    659648}
    … …  
    671660        $ENV{SELFTEST_INTERFACES} = "";
    672661}
    673 if ($opt_verbose) {
    674         $ENV{SELFTEST_VERBOSE} = "1";
    675 } else {
    676         $ENV{SELFTEST_VERBOSE} = "";
    677 }
    678662if ($opt_quick) {
    679663        $ENV{SELFTEST_QUICK} = "1";
    … …  
    681665        $ENV{SELFTEST_QUICK} = "";
    682666}
    683 $ENV{SELFTEST_TARGET} = $opt_target;
    684667$ENV{SELFTEST_MAXTIME} = $torture_maxtime;
    685668
    … …  
    728711                if ($match) {
    729712                        if (defined($skipreason)) {
     713                                if (not $opt_list) {
    730714                                        Subunit::skip_testsuite($name, $skipreason);
     715                                }
    731716                        } else {
    732717                                push(@todo, $testsuite);
    … …  
    734719                }
    735720        } elsif (defined($skipreason)) {
    736                 Subunit::skip_testsuite($name, $skipreason);
     721                if (not $opt_list) {
     722                        Subunit::skip_testsuite($name, $skipreason);
     723                }
    737724        } else {
    738725                push(@todo, $testsuite);
    … …  
    753740my $suitestotal = $#todo + 1;
    754741
    755 Subunit::progress($suitestotal);
    756 Subunit::report_time(time());
     742unless ($opt_list) {
     743        Subunit::progress($suitestotal);
     744        Subunit::report_time(time());
     745}
    757746
    758747my $i = 0;
    … …  
    777766        "REALM",
    778767
     768        # stuff related to a trusted domain
     769        "TRUST_SERVER",
     770        "TRUST_SERVER_IP",
     771        "TRUST_SERVER_IPV6",
     772        "TRUST_NETBIOSNAME",
     773        "TRUST_USERNAME",
     774        "TRUST_PASSWORD",
     775        "TRUST_DOMAIN",
     776        "TRUST_REALM",
     777
    779778        # domain controller stuff
    780779        "DC_SERVER",
    781780        "DC_SERVER_IP",
     781        "DC_SERVER_IPV6",
    782782        "DC_NETBIOSNAME",
    783783        "DC_NETBIOSALIAS",
    … …  
    786786        "MEMBER_SERVER",
    787787        "MEMBER_SERVER_IP",
     788        "MEMBER_SERVER_IPV6",
    788789        "MEMBER_NETBIOSNAME",
    789790        "MEMBER_NETBIOSALIAS",
    … …  
    792793        "RPC_PROXY_SERVER",
    793794        "RPC_PROXY_SERVER_IP",
     795        "RPC_PROXY_SERVER_IPV6",
    794796        "RPC_PROXY_NETBIOSNAME",
    795797        "RPC_PROXY_NETBIOSALIAS",
    … …  
    798800        "VAMPIRE_DC_SERVER",
    799801        "VAMPIRE_DC_SERVER_IP",
     802        "VAMPIRE_DC_SERVER_IPV6",
    800803        "VAMPIRE_DC_NETBIOSNAME",
    801804        "VAMPIRE_DC_NETBIOSALIAS",
     805
     806        "PROMOTED_DC_SERVER",
     807        "PROMOTED_DC_SERVER_IP",
     808        "PROMOTED_DC_SERVER_IPV6",
     809        "PROMOTED_DC_NETBIOSNAME",
     810        "PROMOTED_DC_NETBIOSALIAS",
    802811
    803812        # server stuff
    804813        "SERVER",
    805814        "SERVER_IP",
     815        "SERVER_IPV6",
    806816        "NETBIOSNAME",
    807817        "NETBIOSALIAS",
    … …  
    814824        "DC_PASSWORD",
    815825
     826        # UID/GID for rfc2307 mapping tests
     827        "UID_RFC2307TEST",
     828        "GID_RFC2307TEST",
     829
    816830        # misc stuff
    817831        "KRB5_CONFIG",
    818         "WINBINDD_SOCKET_DIR",
     832        "SELFTEST_WINBINDD_SOCKET_DIR",
    819833        "WINBINDD_PRIV_PIPE_DIR",
    820834        "NMBD_SOCKET_DIR",
    821         "LOCAL_PATH"
     835        "LOCAL_PATH",
     836
     837        # nss_wrapper
     838        "NSS_WRAPPER_PASSWD",
     839        "NSS_WRAPPER_GROUP",
     840        "NSS_WRAPPER_HOSTS",
     841        "NSS_WRAPPER_MODULE_SO_PATH",
     842        "NSS_WRAPPER_MODULE_FN_PREFIX",
     843
     844        # resolv_wrapper
     845        "RESOLV_WRAPPER_CONF",
     846        "RESOLV_WRAPPER_HOSTS",
    822847);
    823848
    824 $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
     849sub sighandler($)
     850{
    825851        my $signame = shift;
     852
     853        $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = 'DEFAULT';
     854        $SIG{PIPE} = 'IGNORE';
     855
     856        open(STDOUT, ">&STDERR") or die "can't dup STDOUT to STDERR: $!";
     857
     858        print "$0: PID[$$]: Got SIG${signame} teardown environments.\n";
    826859        teardown_env($_) foreach(keys %running_envs);
    827         die("Received signal $signame");
     860        system("pstree -p $$");
     861        print "$0: PID[$$]: Exiting...\n";
     862        exit(1);
    828863};
     864
     865$SIG{INT} = $SIG{QUIT} = $SIG{TERM} = $SIG{PIPE} = \&sighandler;
    829866
    830867sub setup_env($$)
    … …  
    843880        $option = "client" if $option eq "";
    844881
    845         if ($envname eq "none") {
    846                 $testenv_vars = {};
    847         } elsif (defined(get_running_env($envname))) {
     882        if (defined(get_running_env($envname))) {
    848883                $testenv_vars = get_running_env($envname);
    849884                if (not $testenv_vars->{target}->check_env($testenv_vars)) {
    … …  
    853888        } else {
    854889                $testenv_vars = $target->setup_env($envname, $prefix);
    855                 if (defined($testenv_vars) && not defined($testenv_vars->{target})) {
    856                        $testenv_vars->{target} = $target;
     890                if (defined($testenv_vars) and $testenv_vars eq "UNKNOWN") {
     891                    return $testenv_vars;
     892                } elsif (defined($testenv_vars) && not defined($testenv_vars->{target})) {
     893                        $testenv_vars->{target} = $target;
     894                }
     895                if (not defined($testenv_vars)) {
     896                        warn("$opt_target can't start up known environment '$envname'");
    857897                }
    858898        }
    … …  
    908948{
    909949        my ($envname) = @_;
    910         return 1 if ($envname eq "none");
    911950        my $env = get_running_env($envname);
    912951        return $env->{target}->check_env($env);
    … …  
    917956        my ($envname) = @_;
    918957        return if ($envname eq "none");
     958        print STDERR "teardown_env($envname)\n";
    919959        my $env = get_running_env($envname);
    920960        $env->{target}->teardown_env($env);
    … …  
    924964# This 'global' file needs to be empty when we start
    925965unlink("$prefix_abs/dns_host_file");
     966unlink("$prefix_abs/hosts");
     967
     968if ($opt_random_order) {
     969        require List::Util;
     970        my @newtodo = List::Util::shuffle(@todo);
     971        @todo = @newtodo;
     972}
    926973
    927974if ($opt_testenv) {
    … …  
    931978        my $testenv_vars = setup_env($testenv_name, $prefix);
    932979
    933         die("Unable to setup environment $testenv_name") unless ($testenv_vars);
     980        if (not $testenv_vars or $testenv_vars eq "UNKNOWN") {
     981                die("Unable to setup environment $testenv_name");
     982        }
    934983
    935984        $ENV{PIDDIR} = $testenv_vars->{PIDDIR};
    … …  
    938987        my $envvarstr = exported_envvars_str($testenv_vars);
    939988
    940         my $term = ($ENV{TERMINAL} or "xterm -e");
    941         system("$term 'echo -e \"
     989        my @term_args = ("echo -e \"
    942990Welcome to the Samba4 Test environment '$testenv_name'
    943991
    … …  
    950998
    951999$envvarstr
    952 \" && LD_LIBRARY_PATH=$ENV{LD_LIBRARY_PATH} bash'");
     1000\" && LD_LIBRARY_PATH=$ENV{LD_LIBRARY_PATH} bash");
     1001        my @term = ();
     1002        if ($ENV{TERMINAL}) {
     1003            @term = ($ENV{TERMINAL});
     1004        } else {
     1005            @term = ("xterm", "-e");
     1006            unshift(@term_args, ("bash", "-c"));
     1007        }
     1008
     1009        system(@term, @term_args);
     1010
    9531011        teardown_env($testenv_name);
    9541012} elsif ($opt_list) {
    9551013        foreach (@todo) {
    956                 my $cmd = $$_[2];
    9571014                my $name = $$_[0];
    9581015                my $envname = $$_[1];
    959 
    960                 unless($cmd =~ /\$LISTOPT/) {
     1016                my $cmd = $$_[2];
     1017                my $listcmd = $$_[3];
     1018
     1019                unless (defined($listcmd)) {
    9611020                        warn("Unable to list tests in $name");
     1021                        # Rather than ignoring this testsuite altogether, just pretend the entire testsuite is
     1022                        # a single "test".
     1023                        print "$name\n";
    9621024                        next;
    9631025                }
    9641026
    965                 $cmd =~ s/\$LISTOPT/--list/g;
    966 
    967                 system($cmd);
     1027                system($listcmd);
    9681028
    9691029                if ($? == -1) {
    970                         die("Unable to run $cmd: $!");
     1030                        die("Unable to run $listcmd: $!");
    9711031                } elsif ($? & 127) {
    972                         die(snprintf("%s died with signal %d, %s coredump\n", $cmd, ($? & 127),  ($? & 128) ? 'with' : 'without'));
     1032                        die(sprintf("%s died with signal %d, %s coredump\n", $listcmd, ($? & 127),  ($? & 128) ? 'with' : 'without'));
    9731033                }
    9741034
    … …  
    9901050                        Subunit::end_testsuite($name, "error",
    9911051                                "unable to set up environment $envname - exiting");
     1052                        next;
     1053                } elsif ($envvars eq "UNKNOWN") {
     1054                        Subunit::start_testsuite($name);
     1055                        Subunit::end_testsuite($name, "skip",
     1056                                "environment $envname is unknown in this test backend - skipping");
    9921057                        next;
    9931058                }
    … …  
    10021067                                }
    10031068                                $cmd =~ s/\$LOADLIST/--load-list=$listid_file/g;
    1004                         } elsif ($$_[4]) {
    1005                                 $cmd =~ s/\s+[^\s]+\s*$//;
    1006                                 $cmd .= " " . join(' ', @{$individual_tests->{$name}});
     1069                        } else {
     1070                                warn("Unable to run individual tests in $name, it does not support --loadlist.");
    10071071                        }
    10081072                }

  • vendor/current/selftest/selftesthelpers.py

    r740 r988  
    2121import os
    2222import subprocess
     23import sys
    2324
    2425def srcdir():
    25     return os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
     26    return os.path.normpath(os.getenv("SRCDIR", os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")))
    2627
    2728def source4dir():
    28     return os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../source4"))
     29    return os.path.normpath(os.path.join(srcdir(), "source4"))
     30
     31def source3dir():
     32    return os.path.normpath(os.path.join(srcdir(), "source3"))
    2933
    3034def bindir():
    31     return os.path.normpath(os.path.join(os.getenv("BUILDDIR", "."), "bin"))
     35    return os.path.normpath(os.getenv("BINDIR", "./bin"))
    3236
    3337def binpath(name):
    34     return os.path.join(bindir(), "%s%s" % (name, os.getenv("EXEEXT", "")))
     38    return os.path.join(bindir(), name)
    3539
    36 perl = os.getenv("PERL", "perl")
    37 perl = perl.split()
     40# Split perl variable to allow $PERL to be set to e.g. "perl -W"
     41perl = os.getenv("PERL", "perl").split()
    3842
    3943if subprocess.call(perl + ["-e", "eval require Test::More;"]) == 0:
    … …  
    4246    has_perl_test_more = False
    4347
    44 try:
    45     from subunit.run import TestProgram
    46 except ImportError:
    47     has_system_subunit_run = False
    48 else:
    49     has_system_subunit_run = True
    50 
    5148python = os.getenv("PYTHON", "python")
    5249
    53 #Set a default value, overridden if we find a working one on the system
    54 tap2subunit = "PYTHONPATH=%s/lib/subunit/python:%s/lib/testtools %s %s/lib/subunit/filters/tap2subunit" % (srcdir(), srcdir(), python, srcdir())
     50tap2subunit = python + " " + os.path.join(srcdir(), "selftest", "tap2subunit")
    5551
    56 sub = subprocess.Popen("tap2subunit 2> /dev/null", stdout=subprocess.PIPE, stdin=subprocess.PIPE, shell=True)
    57 sub.communicate("")
    58 
    59 if sub.returncode == 0:
    60     cmd = "echo -ne \"1..1\nok 1 # skip doesn't seem to work yet\n\" | tap2subunit 2> /dev/null | grep skip"
    61     sub = subprocess.Popen(cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
    62     if sub.returncode == 0:
    63         tap2subunit = "tap2subunit"
    6452
    6553def valgrindify(cmdline):
    … …  
    7159
    7260
    73 def plantestsuite(name, env, cmdline, allow_empty_output=False):
     61def plantestsuite(name, env, cmdline):
    7462    """Plan a test suite.
    7563
    … …  
    8371    if isinstance(cmdline, list):
    8472        cmdline = " ".join(cmdline)
    85     filter_subunit_args = []
    86     if not allow_empty_output:
    87         filter_subunit_args.append("--fail-on-empty")
    8873    if "$LISTOPT" in cmdline:
    89         filter_subunit_args.append("$LISTOPT")
    90     print "%s 2>&1 | %s/selftest/filter-subunit %s --prefix=\"%s.\"" % (cmdline,
    91                                                                         srcdir(),
    92                                                                         " ".join(filter_subunit_args),
    93                                                                         name)
    94     if allow_empty_output:
    95         print "WARNING: allowing empty subunit output from %s" % name
     74        raise AssertionError("test %s supports --list, but not --load-list" % name)
     75    print cmdline + " 2>&1 " + " | " + add_prefix(name, env)
    9676
    9777
    98 def add_prefix(prefix, support_list=False):
     78def add_prefix(prefix, env, support_list=False):
    9979    if support_list:
    10080        listopt = "$LISTOPT "
    10181    else:
    10282        listopt = ""
    103     return "%s/selftest/filter-subunit %s--fail-on-empty --prefix=\"%s.\"" % (srcdir(), listopt, prefix)
     83    return "%s/selftest/filter-subunit %s--fail-on-empty --prefix=\"%s.\" --suffix=\"(%s)\"" % (srcdir(), listopt, prefix, env)
    10484
    10585
    … …  
    11595        cmdline = " ".join(cmdline)
    11696    support_list = ("$LISTOPT" in cmdline)
    117     print "%s $LOADLIST 2>&1 | %s" % (cmdline, add_prefix(name, support_list))
    118 
    119 
    120 def plantestsuite_idlist(name, env, cmdline):
    121     print "-- TEST-IDLIST --"
    122     print name
    123     print env
    124     if isinstance(cmdline, list):
    125         cmdline = " ".join(cmdline)
    126     print cmdline
     97    if not "$LISTOPT" in cmdline:
     98        raise AssertionError("loadlist test %s does not support not --list" % name)
     99    if not "$LOADLIST" in cmdline:
     100        raise AssertionError("loadlist test %s does not support --load-list" % name)
     101    print ("%s | %s" % (cmdline.replace("$LOADLIST", ""), add_prefix(name, env, support_list))).replace("$LISTOPT", "--list")
     102    print cmdline.replace("$LISTOPT", "") + " 2>&1 " + " | " + add_prefix(name, env, False)
    127103
    128104
    … …  
    134110    """
    135111    # FIXME: Report this using subunit, but re-adjust the testsuite count somehow
    136     print "skipping %s (%s)" % (name, reason)
     112    print >>sys.stderr, "skipping %s (%s)" % (name, reason)
    137113
    138114
    … …  
    149125
    150126
    151 def planpythontestsuite(env, module):
    152     if has_system_subunit_run:
    153         plantestsuite_idlist(module, env, [python, "-m", "subunit.run", "$LISTOPT", module])
    154     else:
    155         plantestsuite_idlist(module, env, "PYTHONPATH=$PYTHONPATH:%s/lib/subunit/python:%s/lib/testtools %s -m subunit.run $LISTOPT %s" % (srcdir(), srcdir(), python, module))
     127def planpythontestsuite(env, module, name=None, extra_path=[]):
     128    if name is None:
     129        name = module
     130    pypath = list(extra_path)
     131    args = [python, "-m", "samba.subunit.run", "$LISTOPT", "$LOADLIST", module]
     132    if pypath:
     133        args.insert(0, "PYTHONPATH=%s" % ":".join(["$PYTHONPATH"] + pypath))
     134    plantestsuite_loadlist(name, env, args)
    156135
    157136
     137def get_env_torture_options():
     138    ret = []
     139    if not os.getenv("SELFTEST_VERBOSE"):
     140        ret.append("--option=torture:progress=no")
     141    if os.getenv("SELFTEST_QUICK"):
     142        ret.append("--option=torture:quick=yes")
     143    return ret
     144
     145
     146samba4srcdir = source4dir()
     147samba3srcdir = source3dir()
     148bbdir = os.path.join(srcdir(), "testprogs/blackbox")
     149configuration = "--configfile=$SMB_CONF_PATH"
     150
     151smbtorture4 = binpath("smbtorture")
     152smbtorture4_testsuite_list = subprocess.Popen([smbtorture4, "--list-suites"], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate("")[0].splitlines()
     153
     154smbtorture4_options = [
     155    configuration,
     156    "--option=\'fss:sequence timeout=1\'",
     157    "--maximum-runtime=$SELFTEST_MAXTIME",
     158    "--basedir=$SELFTEST_TMPDIR",
     159    "--format=subunit"
     160    ] + get_env_torture_options()
     161
     162
     163def plansmbtorture4testsuite(name, env, options, target, modname=None):
     164    if modname is None:
     165        modname = "samba4.%s" % name
     166    if isinstance(options, list):
     167        options = " ".join(options)
     168    options = " ".join(smbtorture4_options + ["--target=%s" % target]) + " " + options
     169    cmdline = "%s $LISTOPT $LOADLIST %s %s" % (valgrindify(smbtorture4), options, name)
     170    plantestsuite_loadlist(modname, env, cmdline)
     171
     172
     173def smbtorture4_testsuites(prefix):
     174    return filter(lambda x: x.startswith(prefix), smbtorture4_testsuite_list)
     175
     176
     177smbclient3 = binpath('smbclient')
     178smbtorture3 = binpath('smbtorture3')
     179ntlm_auth3 = binpath('ntlm_auth')
     180net = binpath('net')
     181scriptdir = os.path.join(srcdir(), "script/tests")
     182
     183wbinfo = binpath('wbinfo')
     184dbwrap_tool = binpath('dbwrap_tool')
     185vfstest = binpath('vfstest')
     186smbcquotas = binpath('smbcquotas')
     187smbget = binpath('smbget')

  • vendor/current/selftest/subunithelper.py

    r740 r988  
    2020import re
    2121import sys
    22 import subunit
    23 import subunit.iso8601
    24 import testtools
    25 
    26 VALID_RESULTS = ['success', 'successful', 'failure', 'fail', 'skip', 'knownfail', 'error', 'xfail', 'skip-testsuite', 'testsuite-failure', 'testsuite-xfail', 'testsuite-success', 'testsuite-error']
    27 
    28 class TestsuiteEnabledTestResult(testtools.testresult.TestResult):
     22from samba import subunit
     23from samba.subunit.run import TestProtocolClient
     24from samba.subunit import iso8601
     25import unittest
     26
     27VALID_RESULTS = ['success', 'successful', 'failure', 'fail', 'skip', 'knownfail', 'error', 'xfail', 'skip-testsuite', 'testsuite-failure', 'testsuite-xfail', 'testsuite-success', 'testsuite-error', 'uxsuccess', 'testsuite-uxsuccess']
     28
     29class TestsuiteEnabledTestResult(unittest.TestResult):
    2930
    3031    def start_testsuite(self, name):
    … …  
    3435def parse_results(msg_ops, statistics, fh):
    3536    exitcode = 0
    36     expected_fail = 0
    3737    open_tests = {}
    3838
    … …  
    5858            msg_ops.control_msg(l)
    5959            try:
    60                 dt = subunit.iso8601.parse_date(arg.rstrip("\n"))
     60                dt = iso8601.parse_date(arg.rstrip("\n"))
    6161            except TypeError, e:
    6262                print "Unable to parse time line: %s" % arg.rstrip("\n")
    … …  
    112112                    statistics['TESTS_EXPECTED_FAIL']+=1
    113113                    msg_ops.addExpectedFailure(test, remote_error)
    114                     expected_fail+=1
     114            elif result in ("uxsuccess", ):
     115                try:
     116                    test = open_tests.pop(testname)
     117                except KeyError:
     118                    statistics['TESTS_ERROR']+=1
     119                    exitcode = 1
     120                    msg_ops.addError(subunit.RemotedTestCase(testname), subunit.RemoteError(u"Test was never started"))
     121                else:
     122                    statistics['TESTS_UNEXPECTED_OK']+=1
     123                    msg_ops.addUnexpectedSuccess(test)
     124                    exitcode = 1
    115125            elif result in ("failure", "fail"):
    116126                try:
    … …  
    149159            elif result == "testsuite-xfail":
    150160                msg_ops.end_testsuite(testname, "xfail", reason)
     161            elif result == "testsuite-uxsuccess":
     162                msg_ops.end_testsuite(testname, "uxsuccess", reason)
     163                exitcode = 1
    151164            elif result == "testsuite-error":
    152165                msg_ops.end_testsuite(testname, "error", reason)
    … …  
    179192
    180193
    181 class SubunitOps(subunit.TestProtocolClient,TestsuiteEnabledTestResult):
     194class SubunitOps(TestProtocolClient,TestsuiteEnabledTestResult):
     195
     196    def progress(self, count, whence):
     197        if whence == subunit.PROGRESS_POP:
     198            self._stream.write("progress: pop\n")
     199        elif whence == subunit.PROGRESS_PUSH:
     200            self._stream.write("progress: push\n")
     201        elif whence == subunit.PROGRESS_SET:
     202            self._stream.write("progress: %d\n" % count)
     203        elif whence == subunit.PROGRESS_CUR:
     204            raise NotImplementedError
    182205
    183206    # The following are Samba extensions:
    … …  
    235258
    236259
    237 class FilterOps(testtools.testresult.TestResult):
     260class FilterOps(unittest.TestResult):
    238261
    239262    def control_msg(self, msg):
    … …  
    261284
    262285    def _add_prefix(self, test):
     286        prefix = ""
     287        suffix = ""
    263288        if self.prefix is not None:
    264             return subunit.RemotedTestCase(self.prefix + test.id())
    265         else:
    266             return test
    267 
    268     def addError(self, test, details=None):
     289            prefix = self.prefix
     290        if self.suffix is not None:
     291            suffix = self.suffix
     292
     293        return subunit.RemotedTestCase(prefix + test.id() + suffix)
     294
     295    def addError(self, test, err=None):
    269296        test = self._add_prefix(test)
    270297        self.error_added+=1
    271298        self.total_error+=1
    272         self._ops.addError(test, details)
     299        self._ops.addError(test, err)
    273300        self.output = None
    274301        if self.fail_immediately:
    275302            raise ImmediateFail()
    276303
    277     def addSkip(self, test, details=None):
     304    def addSkip(self, test, reason=None):
    278305        self.seen_output = True
    279306        test = self._add_prefix(test)
    280         self._ops.addSkip(test, details)
    281         self.output = None
    282 
    283     def addExpectedFailure(self, test, details=None):
     307        self._ops.addSkip(test, reason)
     308        self.output = None
     309
     310    def addExpectedFailure(self, test, err=None):
    284311        test = self._add_prefix(test)
    285         self._ops.addExpectedFailure(test, details)
    286         self.output = None
    287 
    288     def addFailure(self, test, details=None):
     312        self._ops.addExpectedFailure(test, err)
     313        self.output = None
     314
     315    def addUnexpectedSuccess(self, test):
     316        test = self._add_prefix(test)
     317        self.uxsuccess_added+=1
     318        self.total_uxsuccess+=1
     319        self._ops.addUnexpectedSuccess(test)
     320        if self.output:
     321            self._ops.output_msg(self.output)
     322        self.output = None
     323        if self.fail_immediately:
     324            raise ImmediateFail()
     325
     326    def addFailure(self, test, err=None):
    289327        test = self._add_prefix(test)
    290328        xfail_reason = find_in_list(self.expected_failures, test.id())
     329        if xfail_reason is None:
     330            xfail_reason = find_in_list(self.flapping, test.id())
    291331        if xfail_reason is not None:
    292332            self.xfail_added+=1
    293333            self.total_xfail+=1
    294             if details is not None:
    295                 details = subunit.RemoteError(unicode(details[1]) + xfail_reason.decode("utf-8"))
    296             else:
    297                 details = subunit.RemoteError(xfail_reason.decode("utf-8"))
    298             self._ops.addExpectedFailure(test, details)
     334            self._ops.addExpectedFailure(test, err)
    299335        else:
    300336            self.fail_added+=1
    301337            self.total_fail+=1
    302             self._ops.addFailure(test, details)
     338            self._ops.addFailure(test, err)
    303339            if self.output:
    304340                self._ops.output_msg(self.output)
    … …  
    307343        self.output = None
    308344
    309     def addSuccess(self, test, details=None):
     345    def addSuccess(self, test):
    310346        test = self._add_prefix(test)
    311         self._ops.addSuccess(test, details)
     347        xfail_reason = find_in_list(self.expected_failures, test.id())
     348        if xfail_reason is not None:
     349            self.uxsuccess_added += 1
     350            self.total_uxsuccess += 1
     351            self._ops.addUnexpectedSuccess(test)
     352            if self.output:
     353                self._ops.output_msg(self.output)
     354            if self.fail_immediately:
     355                raise ImmediateFail()
     356        else:
     357            self._ops.addSuccess(test)
    312358        self.output = None
    313359
    … …  
    320366        self.fail_added = 0
    321367        self.xfail_added = 0
     368        self.uxsuccess_added = 0
    322369
    323370    def end_testsuite(self, name, result, reason=None):
    … …  
    326373        if self.xfail_added > 0:
    327374            xfail = True
    328         if self.fail_added > 0 or self.error_added > 0:
     375        if self.fail_added > 0 or self.error_added > 0 or self.uxsuccess_added > 0:
    329376            xfail = False
    330377
    331378        if xfail and result in ("fail", "failure"):
    332379            result = "xfail"
     380
     381        if self.uxsuccess_added > 0 and result != "uxsuccess":
     382            result = "uxsuccess"
     383            if reason is None:
     384                reason = "Subunit/Filter Reason"
     385            reason += "\n uxsuccess[%d]" % self.uxsuccess_added
    333386
    334387        if self.fail_added > 0 and result != "failure":
    … …  
    345398
    346399        self._ops.end_testsuite(name, result, reason)
    347 
    348     def __init__(self, out, prefix=None, expected_failures=None,
    349                  strip_ok_output=False, fail_immediately=False):
     400        if result not in ("success", "xfail"):
     401            if self.output:
     402                self._ops.output_msg(self.output)
     403            if self.fail_immediately:
     404                raise ImmediateFail()
     405        self.output = None
     406
     407    def __init__(self, out, prefix=None, suffix=None, expected_failures=None,
     408                 strip_ok_output=False, fail_immediately=False,
     409                 flapping=None):
    350410        self._ops = out
    351411        self.seen_output = False
    352412        self.output = None
    353413        self.prefix = prefix
     414        self.suffix = suffix
    354415        if expected_failures is not None:
    355416            self.expected_failures = expected_failures
    356417        else:
    357418            self.expected_failures = {}
     419        if flapping is not None:
     420            self.flapping = flapping
     421        else:
     422            self.flapping = {}
    358423        self.strip_ok_output = strip_ok_output
    359424        self.xfail_added = 0
    360425        self.fail_added = 0
     426        self.uxsuccess_added = 0
    361427        self.total_xfail = 0
    362428        self.total_error = 0
    363429        self.total_fail = 0
     430        self.total_uxsuccess = 0
    364431        self.error_added = 0
    365432        self.fail_immediately = fail_immediately
    … …  
    420487            self.test_output[name] = ""
    421488
    422         out = "[%d" % self.index
     489        total_tests = (self.statistics['TESTS_EXPECTED_OK'] +
     490                       self.statistics['TESTS_EXPECTED_FAIL'] +
     491                       self.statistics['TESTS_ERROR'] +
     492                       self.statistics['TESTS_UNEXPECTED_FAIL'] +
     493                       self.statistics['TESTS_UNEXPECTED_OK'])
     494
     495        out = "[%d(%d)" % (self.index, total_tests)
    423496        if self.totalsuites is not None:
    424497            out += "/%d" % self.totalsuites
    425498        if self.start_time is not None:
    426             out += " in " + self._format_time(self.last_time - self.start_time)
     499            out += " at " + self._format_time(self.last_time - self.start_time)
    427500        if self.suitesfailed:
    428501            out += ", %d errors" % (len(self.suitesfailed),)
    … …  
    476549        self.end_test(test.id(), "success", False)
    477550
    478     def addError(self, test, details=None):
    479         self.end_test(test.id(), "error", True, details)
    480 
    481     def addFailure(self, test, details=None):
    482         self.end_test(test.id(), "failure", True, details)
    483 
    484     def addSkip(self, test, details=None):
    485         self.end_test(test.id(), "skip", False, details)
    486 
    487     def addExpectedFail(self, test, details=None):
    488         self.end_test(test.id(), "xfail", False, details)
    489 
    490     def end_test(self, testname, result, unexpected, reason=None):
     551    def addError(self, test, err=None):
     552        self.end_test(test.id(), "error", True, err)
     553
     554    def addFailure(self, test, err=None):
     555        self.end_test(test.id(), "failure", True, err)
     556
     557    def addSkip(self, test, reason=None):
     558        self.end_test(test.id(), "skip", False, reason)
     559
     560    def addExpectedFailure(self, test, err=None):
     561        self.end_test(test.id(), "xfail", False, err)
     562
     563    def addUnexpectedSuccess(self, test):
     564        self.end_test(test.id(), "uxsuccess", True)
     565
     566    def end_test(self, testname, result, unexpected, err=None):
    491567        if not unexpected:
    492568            self.test_output[self.name] = ""
    … …  
    503579
    504580        self.test_output[self.name] += "UNEXPECTED(%s): %s\n" % (result, testname)
    505         if reason is not None:
    506             self.test_output[self.name] += "REASON: %s\n" % (unicode(reason[1]).encode("utf-8").strip(),)
     581        if err is not None:
     582            self.test_output[self.name] += "REASON: %s\n" % str(err[1]).strip()
    507583
    508584        if self.immediate and not self.verbose:
    509             print self.test_output[self.name]
     585            sys.stdout.write(self.test_output[self.name])
    510586            self.test_output[self.name] = ""
    511587
    … …  
    514590               'error': 'E',
    515591               'failure': 'F',
     592               'uxsuccess': 'U',
    516593               'success': 'S'}.get(result, "?"))
    517594
    … …  
    547624        if (not self.suitesfailed and
    548625            not self.statistics['TESTS_UNEXPECTED_FAIL'] and
     626            not self.statistics['TESTS_UNEXPECTED_OK'] and
    549627            not self.statistics['TESTS_ERROR']):
    550628            ok = (self.statistics['TESTS_EXPECTED_OK'] +
    … …  
    552630            print "\nALL OK (%d tests in %d testsuites)" % (ok, self.suites_ok)
    553631        else:
    554             print "\nFAILED (%d failures and %d errors in %d testsuites)" % (
     632            print "\nFAILED (%d failures, %d errors and %d unexpected successes in %d testsuites)" % (
    555633                self.statistics['TESTS_UNEXPECTED_FAIL'],
    556634                self.statistics['TESTS_ERROR'],
     635                self.statistics['TESTS_UNEXPECTED_OK'],
    557636                len(self.suitesfailed))
    558637

  • vendor/current/selftest/target/Samba3.pm

    r919 r988  
    1010use FindBin qw($RealBin);
    1111use POSIX;
    12 
    13 sub binpath($$)
     12use target::Samba;
     13
     14sub have_ads($) {
     15        my ($self) = @_;
     16        my $found_ads = 0;
     17        my $smbd_build_options = Samba::bindir_path($self, "smbd") . " -b|";
     18        open(IN, $smbd_build_options) or die("Unable to run $smbd_build_options: $!");
     19
     20        while (<IN>) {
     21                if (/WITH_ADS/) {
     22                       $found_ads = 1;
     23                }
     24        }
     25        close IN;
     26
     27        # If we were not built with ADS support, pretend we were never even available
     28        print "smbd does not have ADS support\n" unless $found_ads;
     29        return $found_ads;
     30}
     31
     32# return smb.conf parameters applicable to @path, based on the underlying
     33# filesystem type
     34sub get_fs_specific_conf($$)
    1435{
    15         my ($self, $binary) = @_;
    16 
    17         if (defined($self->{bindir})) {
    18                 my $path = "$self->{bindir}/$binary";
    19                 -f $path or die("File $path doesn't exist");
    20                 return $path;
    21         }
    22 
    23         return $binary;
     36        my ($self, $path) = @_;
     37        my $mods = "";
     38        my $stat_out = `stat --file-system $path` or return "";
     39
     40        if ($stat_out =~ m/Type:\s+btrfs/) {
     41                $mods .= "btrfs ";
     42        }
     43
     44        if ($mods) {
     45                return "vfs objects = $mods";
     46        }
     47
     48        return undef;
    2449}
    2550
    2651sub new($$) {
    27         my ($classname, $bindir, $srcdir) = @_;
    28         my $self = { bindir => $bindir,
    29                      srcdir => $srcdir
     52        my ($classname, $bindir, $srcdir, $server_maxtime) = @_;
     53        my $self = { vars => {},
     54                     bindir => $bindir,
     55                     srcdir => $srcdir,
     56                     server_maxtime => $server_maxtime
    3057        };
    3158        bless $self;
    … …  
    3663{
    3764        my ($self, $envvars) = @_;
    38 
    39         my $smbdpid = read_pid($envvars, "smbd");
    40         my $nmbdpid = read_pid($envvars, "nmbd");
    41         my $winbinddpid = read_pid($envvars, "winbindd");
     65        my $count = 0;
     66
     67        # This should cause smbd to terminate gracefully
     68        close($envvars->{STDIN_PIPE});
     69
     70        my $smbdpid = $envvars->{SMBD_TL_PID};
     71        my $nmbdpid = $envvars->{NMBD_TL_PID};
     72        my $winbinddpid = $envvars->{WINBINDD_TL_PID};
     73
     74        # This should give it time to write out the gcov data
     75        until ($count > 20) {
     76            my $smbdchild = Samba::cleanup_child($smbdpid, "smbd");
     77            my $nmbdchild = Samba::cleanup_child($nmbdpid, "nmbd");
     78            my $winbinddchild = Samba::cleanup_child($winbinddpid, "winbindd");
     79            if ($smbdchild == -1
     80                && $nmbdchild == -1
     81                && $winbinddchild == -1) {
     82                last;
     83            }
     84            sleep(1);
     85            $count++;
     86        }
     87
     88        if ($count <= 20 && kill(0, $smbdpid, $nmbdpid, $winbinddpid) == 0) {
     89            return;
     90        }
    4291
    4392        $self->stop_sig_term($smbdpid);
    … …  
    4594        $self->stop_sig_term($winbinddpid);
    4695
    47         sleep(2);
    48 
     96        $count = 0;
     97        until ($count > 10) {
     98            my $smbdchild = Samba::cleanup_child($smbdpid, "smbd");
     99            my $nmbdchild = Samba::cleanup_child($nmbdpid, "nmbd");
     100            my $winbinddchild = Samba::cleanup_child($winbinddpid, "winbindd");
     101            if ($smbdchild == -1
     102                && $nmbdchild == -1
     103                && $winbinddchild == -1) {
     104                last;
     105            }
     106            sleep(1);
     107            $count++;
     108        }
     109
     110        if ($count <= 10 && kill(0, $smbdpid, $nmbdpid, $winbinddpid) == 0) {
     111            return;
     112        }
     113
     114        warn("timelimit process did not quit on SIGTERM, sending SIGKILL");
    49115        $self->stop_sig_kill($smbdpid);
    50116        $self->stop_sig_kill($nmbdpid);
    … …  
    91157        my ($self, $envvars) = @_;
    92158
     159        my $childpid = waitpid(-1, WNOHANG);
     160
    93161        # TODO ...
    94162        return 1;
    … …  
    98166{
    99167        my ($self, $envname, $path) = @_;
    100        
    101         if ($envname eq "s3dc") {
    102                 return $self->setup_dc("$path/s3dc");
    103         } elsif ($envname eq "secshare") {
    104                 return $self->setup_secshare("$path/secshare");
    105         } elsif ($envname eq "secserver") {
    106                 if (not defined($self->{vars}->{s3dc})) {
    107                         $self->setup_dc("$path/s3dc");
    108                 }
    109                 return $self->setup_secserver("$path/secserver", $self->{vars}->{s3dc});
    110         } elsif ($envname eq "member") {
    111                 if (not defined($self->{vars}->{s3dc})) {
    112                         $self->setup_dc("$path/s3dc");
    113                 }
    114                 return $self->setup_member("$path/member", $self->{vars}->{s3dc});
     168
     169        $ENV{ENVNAME} = $envname;
     170
     171        if (defined($self->{vars}->{$envname})) {
     172                return $self->{vars}->{$envname};
     173        }
     174
     175        #
     176        # Avoid hitting system krb5.conf -
     177        # An env that needs Kerberos will reset this to the real
     178        # value.
     179        #
     180        $ENV{KRB5_CONFIG} = "$path/no_krb5.conf";
     181
     182        if ($envname eq "nt4_dc") {
     183                return $self->setup_nt4_dc("$path/nt4_dc");
     184        } elsif ($envname eq "nt4_dc_schannel") {
     185                return $self->setup_nt4_dc_schannel("$path/nt4_dc_schannel");
     186        } elsif ($envname eq "simpleserver") {
     187                return $self->setup_simpleserver("$path/simpleserver");
     188        } elsif ($envname eq "fileserver") {
     189                return $self->setup_fileserver("$path/fileserver");
     190        } elsif ($envname eq "maptoguest") {
     191                return $self->setup_maptoguest("$path/maptoguest");
     192        } elsif ($envname eq "ktest") {
     193                return $self->setup_ktest("$path/ktest");
     194        } elsif ($envname eq "nt4_member") {
     195                if (not defined($self->{vars}->{nt4_dc})) {
     196                        if (not defined($self->setup_nt4_dc("$path/nt4_dc"))) {
     197                                return undef;
     198                        }
     199                }
     200                return $self->setup_nt4_member("$path/nt4_member", $self->{vars}->{nt4_dc});
    115201        } else {
    116                 return undef;
    117         }
    118 }
    119 
    120 sub setup_dc($$)
     202                return "UNKNOWN";
     203        }
     204}
     205
     206sub setup_nt4_dc($$)
    121207{
    122208        my ($self, $path) = @_;
    123209
    124         print "PROVISIONING S3DC...";
    125 
    126         my $s3dc_options = "
     210        print "PROVISIONING NT4 DC...";
     211
     212        my $nt4_dc_options = "
    127213        domain master = yes
    128214        domain logons = yes
    129215        lanman auth = yes
    130216        raw NTLMv2 auth = yes
     217
     218        rpc_server:epmapper = external
     219        rpc_server:spoolss = external
     220        rpc_server:lsarpc = external
     221        rpc_server:samr = external
     222        rpc_server:netlogon = external
     223        rpc_server:register_embedded_np = yes
     224        rpc_server:FssagentRpc = external
     225
     226        rpc_daemon:epmd = fork
     227        rpc_daemon:spoolssd = fork
     228        rpc_daemon:lsasd = fork
     229        rpc_daemon:fssd = fork
     230        fss: sequence timeout = 1
    131231";
    132232
    133233        my $vars = $self->provision($path,
    134                                     "LOCALS3DC2",
    135                                     2,
    136                                     "locals3dc2pass",
    137                                     $s3dc_options);
    138 
    139         $self->check_or_start($vars,
    140                               ($ENV{SMBD_MAXTIME} or 2700),
    141                                "yes", "yes", "yes");
    142 
    143         $self->wait_for_start($vars);
     234                                    "LOCALNT4DC2",
     235                                    "localntdc2pass",
     236                                    $nt4_dc_options);
     237
     238        $vars or return undef;
     239
     240        if (not $self->check_or_start($vars, "yes", "yes", "yes")) {
     241               return undef;
     242        }
    144243
    145244        $vars->{DC_SERVER} = $vars->{SERVER};
    146245        $vars->{DC_SERVER_IP} = $vars->{SERVER_IP};
     246        $vars->{DC_SERVER_IPV6} = $vars->{SERVER_IPV6};
    147247        $vars->{DC_NETBIOSNAME} = $vars->{NETBIOSNAME};
    148248        $vars->{DC_USERNAME} = $vars->{USERNAME};
    149249        $vars->{DC_PASSWORD} = $vars->{PASSWORD};
    150250
    151         $self->{vars}->{s3dc} = $vars;
     251        $self->{vars}->{nt4_dc} = $vars;
    152252
    153253        return $vars;
    154254}
    155255
    156 sub setup_member($$$)
     256sub setup_nt4_dc_schannel($$)
    157257{
    158         my ($self, $prefix, $s3dcvars) = @_;
     258        my ($self, $path) = @_;
     259
     260        print "PROVISIONING NT4 DC WITH SERVER SCHANNEL ...";
     261
     262        my $pdc_options = "
     263        domain master = yes
     264        domain logons = yes
     265        lanman auth = yes
     266
     267        rpc_server:epmapper = external
     268        rpc_server:spoolss = external
     269        rpc_server:lsarpc = external
     270        rpc_server:samr = external
     271        rpc_server:netlogon = external
     272        rpc_server:register_embedded_np = yes
     273
     274        rpc_daemon:epmd = fork
     275        rpc_daemon:spoolssd = fork
     276        rpc_daemon:lsasd = fork
     277
     278        server schannel = yes
     279";
     280
     281        my $vars = $self->provision($path,
     282                                    "LOCALNT4DC9",
     283                                    "localntdc9pass",
     284                                    $pdc_options);
     285
     286        $vars or return undef;
     287
     288        if (not $self->check_or_start($vars, "yes", "yes", "yes")) {
     289               return undef;
     290        }
     291
     292        $vars->{DC_SERVER} = $vars->{SERVER};
     293        $vars->{DC_SERVER_IP} = $vars->{SERVER_IP};
     294        $vars->{DC_SERVER_IPV6} = $vars->{SERVER_IPV6};
     295        $vars->{DC_NETBIOSNAME} = $vars->{NETBIOSNAME};
     296        $vars->{DC_USERNAME} = $vars->{USERNAME};
     297        $vars->{DC_PASSWORD} = $vars->{PASSWORD};
     298
     299        $self->{vars}->{nt4_dc_schannel} = $vars;
     300
     301        return $vars;
     302}
     303
     304sub setup_nt4_member($$$)
     305{
     306        my ($self, $prefix, $nt4_dc_vars) = @_;
     307        my $count = 0;
     308        my $rc;
    159309
    160310        print "PROVISIONING MEMBER...";
    … …  
    163313        security = domain
    164314        server signing = on
     315        dbwrap_tdb_mutexes:* = yes
    165316";
    166317        my $ret = $self->provision($prefix,
    167                                    "LOCALMEMBER3",
    168                                    3,
    169                                    "localmember3pass",
     318                                   "LOCALNT4MEMBER3",
     319                                   "localnt4member3pass",
    170320                                   $member_options);
    171321
    172         $ret or die("Unable to provision");
    173 
    174         my $net = $self->binpath("net");
     322        $ret or return undef;
     323
     324        my $nmblookup = Samba::bindir_path($self, "nmblookup");
     325        do {
     326                print "Waiting for the LOGON SERVER registration ...\n";
     327                $rc = system("$nmblookup $ret->{CONFIGURATION} $ret->{DOMAIN}\#1c");
     328                if ($rc != 0) {
     329                        sleep(1);
     330                }
     331                $count++;
     332        } while ($rc != 0 && $count < 10);
     333        if ($count == 10) {
     334                print "NMBD not reachable after 10 retries\n";
     335                teardown_env($self, $ret);
     336                return 0;
     337        }
     338
     339        my $net = Samba::bindir_path($self, "net");
    175340        my $cmd = "";
    176341        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
    177         $cmd .= "$net join $ret->{CONFIGURATION} $s3dcvars->{DOMAIN} member";
    178         $cmd .= " -U$s3dcvars->{USERNAME}\%$s3dcvars->{PASSWORD}";
    179 
    180         system($cmd) == 0 or die("Join failed\n$cmd");
    181 
    182         $self->check_or_start($ret,
    183                               ($ENV{SMBD_MAXTIME} or 2700),
    184                                "yes", "yes", "yes");
    185 
    186         $self->wait_for_start($ret);
    187 
    188         $ret->{DC_SERVER} = $s3dcvars->{SERVER};
    189         $ret->{DC_SERVER_IP} = $s3dcvars->{SERVER_IP};
    190         $ret->{DC_NETBIOSNAME} = $s3dcvars->{NETBIOSNAME};
    191         $ret->{DC_USERNAME} = $s3dcvars->{USERNAME};
    192         $ret->{DC_PASSWORD} = $s3dcvars->{PASSWORD};
     342        $cmd .= "$net join $ret->{CONFIGURATION} $nt4_dc_vars->{DOMAIN} member";
     343        $cmd .= " -U$nt4_dc_vars->{USERNAME}\%$nt4_dc_vars->{PASSWORD}";
     344
     345        if (system($cmd) != 0) {
     346            warn("Join failed\n$cmd");
     347            return undef;
     348        }
     349
     350        if (not $self->check_or_start($ret, "yes", "yes", "yes")) {
     351               return undef;
     352        }
     353
     354        $ret->{DC_SERVER} = $nt4_dc_vars->{SERVER};
     355        $ret->{DC_SERVER_IP} = $nt4_dc_vars->{SERVER_IP};
     356        $ret->{DC_SERVER_IPV6} = $nt4_dc_vars->{SERVER_IPV6};
     357        $ret->{DC_NETBIOSNAME} = $nt4_dc_vars->{NETBIOSNAME};
     358        $ret->{DC_USERNAME} = $nt4_dc_vars->{USERNAME};
     359        $ret->{DC_PASSWORD} = $nt4_dc_vars->{PASSWORD};
    193360
    194361        return $ret;
    195362}
    196363
    197 sub setup_secshare($$)
     364sub setup_admember($$$$)
     365{
     366        my ($self, $prefix, $dcvars) = @_;
     367
     368        # If we didn't build with ADS, pretend this env was never available
     369        if (not $self->have_ads()) {
     370                return "UNKNOWN";
     371        }
     372
     373        print "PROVISIONING S3 AD MEMBER...";
     374
     375        my $member_options = "
     376        security = ads
     377        server signing = on
     378        workgroup = $dcvars->{DOMAIN}
     379        realm = $dcvars->{REALM}
     380";
     381
     382        my $ret = $self->provision($prefix,
     383                                   "LOCALADMEMBER",
     384                                   "loCalMemberPass",
     385                                   $member_options,
     386                                   $dcvars->{SERVER_IP},
     387                                   $dcvars->{SERVER_IPV6});
     388
     389        $ret or return undef;
     390
     391        close(USERMAP);
     392        $ret->{DOMAIN} = $dcvars->{DOMAIN};
     393        $ret->{REALM} = $dcvars->{REALM};
     394
     395        my $ctx;
     396        my $prefix_abs = abs_path($prefix);
     397        $ctx = {};
     398        $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
     399        $ctx->{domain} = $dcvars->{DOMAIN};
     400        $ctx->{realm} = $dcvars->{REALM};
     401        $ctx->{dnsname} = lc($dcvars->{REALM});
     402        $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
     403        $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
     404        Samba::mk_krb5_conf($ctx, "");
     405
     406        $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
     407
     408        my $net = Samba::bindir_path($self, "net");
     409        my $cmd = "";
     410        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     411        if (defined($ret->{RESOLV_WRAPPER_CONF})) {
     412                $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
     413        } else {
     414                $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
     415        }
     416        $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     417        $cmd .= "$net join $ret->{CONFIGURATION}";
     418        $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
     419
     420        if (system($cmd) != 0) {
     421            warn("Join failed\n$cmd");
     422            return undef;
     423        }
     424
     425        # We need world access to this share, as otherwise the domain
     426        # administrator from the AD domain provided by Samba4 can't
     427        # access the share for tests.
     428        chmod 0777, "$prefix/share";
     429
     430        if (not $self->check_or_start($ret, "yes", "yes", "yes")) {
     431                return undef;
     432        }
     433
     434        $ret->{DC_SERVER} = $dcvars->{SERVER};
     435        $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
     436        $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
     437        $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
     438        $ret->{DC_USERNAME} = $dcvars->{USERNAME};
     439        $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
     440
     441        # Special case, this is called from Samba4.pm but needs to use the Samba3 check_env and get_log_env
     442        $ret->{target} = $self;
     443
     444        return $ret;
     445}
     446
     447sub setup_admember_rfc2307($$$$)
     448{
     449        my ($self, $prefix, $dcvars) = @_;
     450
     451        # If we didn't build with ADS, pretend this env was never available
     452        if (not $self->have_ads()) {
     453                return "UNKNOWN";
     454        }
     455
     456        print "PROVISIONING S3 AD MEMBER WITH idmap_rfc2307 config...";
     457
     458        my $member_options = "
     459        security = ads
     460        server signing = on
     461        workgroup = $dcvars->{DOMAIN}
     462        realm = $dcvars->{REALM}
     463        idmap config $dcvars->{DOMAIN} : backend = rfc2307
     464        idmap config $dcvars->{DOMAIN} : range = 2000000-2999999
     465        idmap config $dcvars->{DOMAIN} : ldap_server = ad
     466        idmap config $dcvars->{DOMAIN} : bind_path_user = ou=idmap,dc=samba,dc=example,dc=com
     467        idmap config $dcvars->{DOMAIN} : bind_path_group = ou=idmap,dc=samba,dc=example,dc=com
     468";
     469
     470        my $ret = $self->provision($prefix,
     471                                   "RFC2307MEMBER",
     472                                   "loCalMemberPass",
     473                                   $member_options,
     474                                   $dcvars->{SERVER_IP},
     475                                   $dcvars->{SERVER_IPV6});
     476
     477        $ret or return undef;
     478
     479        close(USERMAP);
     480        $ret->{DOMAIN} = $dcvars->{DOMAIN};
     481        $ret->{REALM} = $dcvars->{REALM};
     482
     483        my $ctx;
     484        my $prefix_abs = abs_path($prefix);
     485        $ctx = {};
     486        $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
     487        $ctx->{domain} = $dcvars->{DOMAIN};
     488        $ctx->{realm} = $dcvars->{REALM};
     489        $ctx->{dnsname} = lc($dcvars->{REALM});
     490        $ctx->{kdc_ipv4} = $dcvars->{SERVER_IP};
     491        $ctx->{kdc_ipv6} = $dcvars->{SERVER_IPV6};
     492        Samba::mk_krb5_conf($ctx, "");
     493
     494        $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
     495
     496        my $net = Samba::bindir_path($self, "net");
     497        my $cmd = "";
     498        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     499        if (defined($ret->{RESOLV_WRAPPER_CONF})) {
     500                $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
     501        } else {
     502                $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
     503        }
     504        $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     505        $cmd .= "$net join $ret->{CONFIGURATION}";
     506        $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
     507
     508        if (system($cmd) != 0) {
     509            warn("Join failed\n$cmd");
     510            return undef;
     511        }
     512
     513        # We need world access to this share, as otherwise the domain
     514        # administrator from the AD domain provided by Samba4 can't
     515        # access the share for tests.
     516        chmod 0777, "$prefix/share";
     517
     518        if (not $self->check_or_start($ret, "yes", "yes", "yes")) {
     519                return undef;
     520        }
     521
     522        $ret->{DC_SERVER} = $dcvars->{SERVER};
     523        $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
     524        $ret->{DC_SERVER_IPV6} = $dcvars->{SERVER_IPV6};
     525        $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
     526        $ret->{DC_USERNAME} = $dcvars->{USERNAME};
     527        $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
     528
     529        # Special case, this is called from Samba4.pm but needs to use the Samba3 check_env and get_log_env
     530        $ret->{target} = $self;
     531
     532        return $ret;
     533}
     534
     535sub setup_simpleserver($$)
    198536{
    199537        my ($self, $path) = @_;
    200538
    201         print "PROVISIONING server with security=share...";
    202 
    203         my $secshare_options = "
    204         security = share
     539        print "PROVISIONING simple server...";
     540
     541        my $prefix_abs = abs_path($path);
     542
     543        my $simpleserver_options = "
    205544        lanman auth = yes
     545        vfs objects = xattr_tdb streams_depot
     546        change notify = no
     547
     548[vfs_aio_fork]
     549        path = $prefix_abs/share
     550        vfs objects = aio_fork
     551        read only = no
     552        vfs_aio_fork:erratic_testing_mode=yes
    206553";
    207554
    208555        my $vars = $self->provision($path,
    209556                                    "LOCALSHARE4",
    210                                     4,
    211557                                    "local4pass",
    212                                     $secshare_options);
    213 
    214         $self->check_or_start($vars,
    215                               ($ENV{SMBD_MAXTIME} or 2700),
    216                                "yes", "no", "yes");
    217 
    218         $self->wait_for_start($vars);
    219 
    220         $self->{vars}->{secshare} = $vars;
     558                                    $simpleserver_options);
     559
     560        $vars or return undef;
     561
     562        if (not $self->check_or_start($vars, "yes", "no", "yes")) {
     563               return undef;
     564        }
     565
     566        $self->{vars}->{simpleserver} = $vars;
    221567
    222568        return $vars;
    223569}
    224570
    225 sub setup_secserver($$$)
     571sub setup_fileserver($$)
    226572{
    227         my ($self, $prefix, $s3dcvars) = @_;
    228 
    229         print "PROVISIONING server with security=server...";
    230 
    231         my $secserver_options = "
    232         security = server
    233         password server = $s3dcvars->{SERVER_IP}
    234         client ntlmv2 auth = no
     573        my ($self, $path) = @_;
     574        my $prefix_abs = abs_path($path);
     575        my $srcdir_abs = abs_path($self->{srcdir});
     576
     577        print "PROVISIONING file server ...\n";
     578
     579        my @dirs = ();
     580
     581        mkdir($prefix_abs, 0777);
     582
     583        my $share_dir="$prefix_abs/share";
     584
     585        # Create share directory structure
     586        my $lower_case_share_dir="$share_dir/lower-case";
     587        push(@dirs, $lower_case_share_dir);
     588
     589        my $lower_case_share_dir_30000="$share_dir/lower-case-30000";
     590        push(@dirs, $lower_case_share_dir_30000);
     591
     592        my $dfree_share_dir="$share_dir/dfree";
     593        push(@dirs, $dfree_share_dir);
     594        push(@dirs, "$dfree_share_dir/subdir1");
     595        push(@dirs, "$dfree_share_dir/subdir2");
     596
     597        my $valid_users_sharedir="$share_dir/valid_users";
     598        push(@dirs,$valid_users_sharedir);
     599
     600        my $offline_sharedir="$share_dir/offline";
     601        push(@dirs,$offline_sharedir);
     602
     603        my $force_user_valid_users_dir = "$share_dir/force_user_valid_users";
     604        push(@dirs, $force_user_valid_users_dir);
     605
     606        my $smbget_sharedir="$share_dir/smbget";
     607        push(@dirs,$smbget_sharedir);
     608
     609        my $fileserver_options = "
     610[lowercase]
     611        path = $lower_case_share_dir
     612        comment = smb username is [%U]
     613        case sensitive = True
     614        default case = lower
     615        preserve case = no
     616        short preserve case = no
     617[lowercase-30000]
     618        path = $lower_case_share_dir_30000
     619        comment = smb username is [%U]
     620        case sensitive = True
     621        default case = lower
     622        preserve case = no
     623        short preserve case = no
     624[dfree]
     625        path = $dfree_share_dir
     626        comment = smb username is [%U]
     627        dfree command = $srcdir_abs/testprogs/blackbox/dfree.sh
     628[valid-users-access]
     629        path = $valid_users_sharedir
     630        valid users = +userdup
     631[offline]
     632        path = $offline_sharedir
     633        vfs objects = offline
     634
     635# BUG: https://bugzilla.samba.org/show_bug.cgi?id=9878
     636# RH BUG: https://bugzilla.redhat.com/show_bug.cgi?id=1077651
     637[force_user_valid_users]
     638        path = $force_user_valid_users_dir
     639        comment = force user with valid users combination test share
     640        valid users = +force_user
     641        force user = force_user
     642        force group = everyone
     643        write list = force_user
     644
     645[smbget]
     646        path = $smbget_sharedir
     647        comment = smb username is [%U]
     648        guest ok = yes
    235649";
    236650
     651        my $vars = $self->provision($path,
     652                                    "FILESERVER",
     653                                    "fileserver",
     654                                    $fileserver_options,
     655                                    undef,
     656                                    undef,
     657                                    1);
     658
     659        $vars or return undef;
     660
     661        if (not $self->check_or_start($vars, "yes", "no", "yes")) {
     662               return undef;
     663        }
     664
     665        $self->{vars}->{fileserver} = $vars;
     666
     667        mkdir($_, 0777) foreach(@dirs);
     668
     669        ## Create case sensitive lower case share dir
     670        foreach my $file ('a'..'z') {
     671                my $full_path = $lower_case_share_dir . '/' . $file;
     672                open my $fh, '>', $full_path;
     673                # Add some content to file
     674                print $fh $full_path;
     675                close $fh;
     676        }
     677
     678        for (my $file = 1; $file < 51; ++$file) {
     679                my $full_path = $lower_case_share_dir . '/' . $file;
     680                open my $fh, '>', $full_path;
     681                # Add some content to file
     682                print $fh $full_path;
     683                close $fh;
     684        }
     685
     686        # Create content for 30000 share
     687        foreach my $file ('a'..'z') {
     688                my $full_path = $lower_case_share_dir_30000 . '/' . $file;
     689                open my $fh, '>', $full_path;
     690                # Add some content to file
     691                print $fh $full_path;
     692                close $fh;
     693        }
     694
     695        for (my $file = 1; $file < 30001; ++$file) {
     696                my $full_path = $lower_case_share_dir_30000 . '/' . $file;
     697                open my $fh, '>', $full_path;
     698                # Add some content to file
     699                print $fh $full_path;
     700                close $fh;
     701        }
     702
     703        ##
     704        ## create a listable file in valid_users_share
     705        ##
     706        my $valid_users_target = "$valid_users_sharedir/foo";
     707        unless (open(VALID_USERS_TARGET, ">$valid_users_target")) {
     708                warn("Unable to open $valid_users_target");
     709                return undef;
     710        }
     711        close(VALID_USERS_TARGET);
     712        chmod 0644, $valid_users_target;
     713
     714        return $vars;
     715}
     716
     717sub setup_ktest($$$)
     718{
     719        my ($self, $prefix) = @_;
     720
     721        # If we didn't build with ADS, pretend this env was never available
     722        if (not $self->have_ads()) {
     723                return "UNKNOWN";
     724        }
     725
     726        print "PROVISIONING server with security=ads...";
     727
     728        my $ktest_options = "
     729        workgroup = KTEST
     730        realm = ktest.samba.example.com
     731        security = ads
     732        username map = $prefix/lib/username.map
     733        server signing = required
     734";
     735
    237736        my $ret = $self->provision($prefix,
    238                                    "LOCALSERVER5",
    239                                    5,
    240                                    "localserver5pass",
    241                                    $secserver_options);
    242 
    243         $ret or die("Unable to provision");
    244 
    245         $self->check_or_start($ret,
    246                               ($ENV{SMBD_MAXTIME} or 2700),
    247                                "yes", "no", "yes");
    248 
    249         $self->wait_for_start($ret);
    250 
    251         $ret->{DC_SERVER} = $s3dcvars->{SERVER};
    252         $ret->{DC_SERVER_IP} = $s3dcvars->{SERVER_IP};
    253         $ret->{DC_NETBIOSNAME} = $s3dcvars->{NETBIOSNAME};
    254         $ret->{DC_USERNAME} = $s3dcvars->{USERNAME};
    255         $ret->{DC_PASSWORD} = $s3dcvars->{PASSWORD};
    256 
     737                                   "LOCALKTEST6",
     738                                   "localktest6pass",
     739                                   $ktest_options);
     740
     741        $ret or return undef;
     742
     743        my $ctx;
     744        my $prefix_abs = abs_path($prefix);
     745        $ctx = {};
     746        $ctx->{krb5_conf} = "$prefix_abs/lib/krb5.conf";
     747        $ctx->{domain} = "KTEST";
     748        $ctx->{realm} = "KTEST.SAMBA.EXAMPLE.COM";
     749        $ctx->{dnsname} = lc($ctx->{realm});
     750        $ctx->{kdc_ipv4} = "0.0.0.0";
     751        $ctx->{kdc_ipv6} = "::";
     752        Samba::mk_krb5_conf($ctx, "");
     753
     754        $ret->{KRB5_CONFIG} = $ctx->{krb5_conf};
     755
     756        open(USERMAP, ">$prefix/lib/username.map") or die("Unable to open $prefix/lib/username.map");
     757        print USERMAP "
     758$ret->{USERNAME} = KTEST\\Administrator
     759";
     760        close(USERMAP);
     761
     762#This is the secrets.tdb created by 'net ads join' from Samba3 to a
     763#Samba4 DC with the same parameters as are being used here.  The
     764#domain SID is S-1-5-21-1071277805-689288055-3486227160
     765
     766        system("cp $self->{srcdir}/source3/selftest/ktest-secrets.tdb $prefix/private/secrets.tdb");
     767        chmod 0600, "$prefix/private/secrets.tdb";
     768
     769#Make sure there's no old ntdb file.
     770        system("rm -f $prefix/private/secrets.ntdb");
     771
     772#This uses a pre-calculated krb5 credentials cache, obtained by running Samba4 with:
     773# "--option=kdc:service ticket lifetime=239232" "--option=kdc:user ticket lifetime=239232" "--option=kdc:renewal lifetime=239232"
     774#
     775#and having in krb5.conf:
     776# ticket_lifetime = 799718400
     777# renew_lifetime = 799718400
     778#
     779# The commands for the -2 keytab where were:
     780# kinit administrator@KTEST.SAMBA.EXAMPLE.COM
     781# kvno host/localktest6@KTEST.SAMBA.EXAMPLE.COM
     782# kvno cifs/localktest6@KTEST.SAMBA.EXAMPLE.COM
     783# kvno host/LOCALKTEST6@KTEST.SAMBA.EXAMPLE.COM
     784# kvno cifs/LOCALKTEST6@KTEST.SAMBA.EXAMPLE.COM
     785#
     786# and then for the -3 keytab, I did
     787#
     788# net changetrustpw; kdestroy and the same again.
     789#
     790# This creates a credential cache with a very long lifetime (2036 at
     791# at 2011-04), and shows that running 'net changetrustpw' does not
     792# break existing logins (for the secrets.tdb method at least).
     793#
     794
     795        $ret->{KRB5_CCACHE}="FILE:$prefix/krb5_ccache";
     796
     797        system("cp $self->{srcdir}/source3/selftest/ktest-krb5_ccache-2 $prefix/krb5_ccache-2");
     798        chmod 0600, "$prefix/krb5_ccache-2";
     799
     800        system("cp $self->{srcdir}/source3/selftest/ktest-krb5_ccache-3 $prefix/krb5_ccache-3");
     801        chmod 0600, "$prefix/krb5_ccache-3";
     802
     803        # We need world access to this share, as otherwise the domain
     804        # administrator from the AD domain provided by ktest can't
     805        # access the share for tests.
     806        chmod 0777, "$prefix/share";
     807
     808        if (not $self->check_or_start($ret, "yes", "no", "yes")) {
     809               return undef;
     810        }
    257811        return $ret;
     812}
     813
     814sub setup_maptoguest($$)
     815{
     816        my ($self, $path) = @_;
     817
     818        print "PROVISIONING maptoguest...";
     819
     820        my $options = "
     821map to guest = bad user
     822";
     823
     824        my $vars = $self->provision($path,
     825                                    "maptoguest",
     826                                    "maptoguestpass",
     827                                    $options);
     828
     829        $vars or return undef;
     830
     831        if (not $self->check_or_start($vars, "yes", "no", "yes")) {
     832               return undef;
     833        }
     834
     835        $self->{vars}->{s3maptoguest} = $vars;
     836
     837        return $vars;
    258838}
    259839
    … …  
    288868
    289869sub check_or_start($$$$$) {
    290         my ($self, $env_vars, $maxtime, $nmbd, $winbindd, $smbd) = @_;
     870        my ($self, $env_vars, $nmbd, $winbindd, $smbd) = @_;
     871
     872        # use a pipe for stdin in the child processes. This allows
     873        # those processes to monitor the pipe for EOF to ensure they
     874        # exit when the test script exits
     875        pipe(STDIN_READER, $env_vars->{STDIN_PIPE});
    291876
    292877        unlink($env_vars->{NMBD_TEST_LOG});
    … …  
    299884                SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
    300885
    301                 $ENV{WINBINDD_SOCKET_DIR} = $env_vars->{WINBINDD_SOCKET_DIR};
     886                $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
     887                $ENV{SELFTEST_WINBINDD_SOCKET_DIR} = $env_vars->{SELFTEST_WINBINDD_SOCKET_DIR};
    302888                $ENV{NMBD_SOCKET_DIR} = $env_vars->{NMBD_SOCKET_DIR};
    303889
    304890                $ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
    305891                $ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
    306                 $ENV{NSS_WRAPPER_WINBIND_SO_PATH} = $env_vars->{NSS_WRAPPER_WINBIND_SO_PATH};
     892                $ENV{NSS_WRAPPER_HOSTS} = $env_vars->{NSS_WRAPPER_HOSTS};
     893                $ENV{NSS_WRAPPER_HOSTNAME} = $env_vars->{NSS_WRAPPER_HOSTNAME};
     894                $ENV{NSS_WRAPPER_MODULE_SO_PATH} = $env_vars->{NSS_WRAPPER_MODULE_SO_PATH};
     895                $ENV{NSS_WRAPPER_MODULE_FN_PREFIX} = $env_vars->{NSS_WRAPPER_MODULE_FN_PREFIX};
     896                $ENV{UID_WRAPPER_ROOT} = "1";
     897
     898                $ENV{ENVNAME} = "$ENV{ENVNAME}.nmbd";
    307899
    308900                if ($nmbd ne "yes") {
    … …  
    312904                                exit 0;
    313905                        };
    314                         sleep($maxtime);
     906                        sleep($self->{server_maxtime});
    315907                        exit 0;
    316908                }
    317909
     910                $ENV{MAKE_TEST_BINARY} = Samba::bindir_path($self, "nmbd");
    318911                my @optargs = ("-d0");
    319912                if (defined($ENV{NMBD_OPTIONS})) {
    320913                        @optargs = split(/ /, $ENV{NMBD_OPTIONS});
    321914                }
    322 
    323                 $ENV{MAKE_TEST_BINARY} = $self->binpath("nmbd");
    324 
    325                 my @preargs = ($self->binpath("timelimit"), $maxtime);
     915                my @preargs = (Samba::bindir_path($self, "timelimit"), $self->{server_maxtime});
    326916                if(defined($ENV{NMBD_VALGRIND})) {
    327917                        @preargs = split(/ /, $ENV{NMBD_VALGRIND});
    328918                }
    329 
    330                 exec(@preargs, $self->binpath("nmbd"), "-F", "--no-process-group", "-S", "-s", $env_vars->{SERVERCONFFILE}, @optargs) or die("Unable to start nmbd: $!");
    331         }
     919                my @args = ("-F", "--no-process-group",
     920                            "-s", $env_vars->{SERVERCONFFILE},
     921                            "-l", $env_vars->{LOGDIR});
     922                if (not defined($ENV{NMBD_DONT_LOG_STDOUT})) {
     923                        push(@args, "--log-stdout");
     924                }
     925
     926                close($env_vars->{STDIN_PIPE});
     927                open STDIN, ">&", \*STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
     928
     929                exec(@preargs, $ENV{MAKE_TEST_BINARY}, @args, @optargs)
     930                        or die("Unable to start $ENV{MAKE_TEST_BINARY}: $!");
     931        }
     932        $env_vars->{NMBD_TL_PID} = $pid;
    332933        write_pid($env_vars, "nmbd", $pid);
    333934        print "DONE\n";
    … …  
    342943                SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
    343944
    344                 $ENV{WINBINDD_SOCKET_DIR} = $env_vars->{WINBINDD_SOCKET_DIR};
     945                $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
     946                $ENV{SELFTEST_WINBINDD_SOCKET_DIR} = $env_vars->{SELFTEST_WINBINDD_SOCKET_DIR};
    345947                $ENV{NMBD_SOCKET_DIR} = $env_vars->{NMBD_SOCKET_DIR};
    346948
    347949                $ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
    348950                $ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
    349                 $ENV{NSS_WRAPPER_WINBIND_SO_PATH} = $env_vars->{NSS_WRAPPER_WINBIND_SO_PATH};
     951                $ENV{NSS_WRAPPER_HOSTS} = $env_vars->{NSS_WRAPPER_HOSTS};
     952                $ENV{NSS_WRAPPER_HOSTNAME} = $env_vars->{NSS_WRAPPER_HOSTNAME};
     953                $ENV{NSS_WRAPPER_MODULE_SO_PATH} = $env_vars->{NSS_WRAPPER_MODULE_SO_PATH};
     954                $ENV{NSS_WRAPPER_MODULE_FN_PREFIX} = $env_vars->{NSS_WRAPPER_MODULE_FN_PREFIX};
     955                if (defined($env_vars->{RESOLV_WRAPPER_CONF})) {
     956                        $ENV{RESOLV_WRAPPER_CONF} = $env_vars->{RESOLV_WRAPPER_CONF};
     957                } else {
     958                        $ENV{RESOLV_WRAPPER_HOSTS} = $env_vars->{RESOLV_WRAPPER_HOSTS};
     959                }
     960                $ENV{UID_WRAPPER_ROOT} = "1";
     961
     962                $ENV{ENVNAME} = "$ENV{ENVNAME}.winbindd";
    350963
    351964                if ($winbindd ne "yes") {
    … …  
    355968                                exit 0;
    356969                        };
    357                         sleep($maxtime);
     970                        sleep($self->{server_maxtime});
    358971                        exit 0;
    359972                }
    360973
     974                $ENV{MAKE_TEST_BINARY} = Samba::bindir_path($self, "winbindd");
    361975                my @optargs = ("-d0");
    362976                if (defined($ENV{WINBINDD_OPTIONS})) {
    363977                        @optargs = split(/ /, $ENV{WINBINDD_OPTIONS});
    364978                }
    365 
    366                 $ENV{MAKE_TEST_BINARY} = $self->binpath("winbindd");
    367 
    368                 my @preargs = ($self->binpath("timelimit"), $maxtime);
     979                my @preargs = (Samba::bindir_path($self, "timelimit"), $self->{server_maxtime});
    369980                if(defined($ENV{WINBINDD_VALGRIND})) {
    370981                        @preargs = split(/ /, $ENV{WINBINDD_VALGRIND});
    371982                }
    372 
    373                 exec(@preargs, $self->binpath("winbindd"), "-F", "--no-process-group", "-s", $env_vars->{SERVERCONFFILE}, @optargs) or die("Unable to start winbindd: $!");
    374         }
     983                my @args = ("-F", "--no-process-group",
     984                            "-s", $env_vars->{SERVERCONFFILE},
     985                            "-l", $env_vars->{LOGDIR});
     986                if (not defined($ENV{WINBINDD_DONT_LOG_STDOUT})) {
     987                        push(@args, "--stdout");
     988                }
     989
     990                close($env_vars->{STDIN_PIPE});
     991                open STDIN, ">&", \*STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
     992
     993                exec(@preargs, $ENV{MAKE_TEST_BINARY}, @args, @optargs)
     994                        or die("Unable to start $ENV{MAKE_TEST_BINARY}: $!");
     995        }
     996        $env_vars->{WINBINDD_TL_PID} = $pid;
    375997        write_pid($env_vars, "winbindd", $pid);
    376998        print "DONE\n";
    … …  
    3851007                SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
    3861008
    387                 $ENV{WINBINDD_SOCKET_DIR} = $env_vars->{WINBINDD_SOCKET_DIR};
     1009                $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
     1010                $ENV{SELFTEST_WINBINDD_SOCKET_DIR} = $env_vars->{SELFTEST_WINBINDD_SOCKET_DIR};
    3881011                $ENV{NMBD_SOCKET_DIR} = $env_vars->{NMBD_SOCKET_DIR};
    3891012
    3901013                $ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
    3911014                $ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
    392                 $ENV{NSS_WRAPPER_WINBIND_SO_PATH} = $env_vars->{NSS_WRAPPER_WINBIND_SO_PATH};
     1015                $ENV{NSS_WRAPPER_HOSTS} = $env_vars->{NSS_WRAPPER_HOSTS};
     1016                $ENV{NSS_WRAPPER_HOSTNAME} = $env_vars->{NSS_WRAPPER_HOSTNAME};
     1017                $ENV{NSS_WRAPPER_MODULE_SO_PATH} = $env_vars->{NSS_WRAPPER_MODULE_SO_PATH};
     1018                $ENV{NSS_WRAPPER_MODULE_FN_PREFIX} = $env_vars->{NSS_WRAPPER_MODULE_FN_PREFIX};
     1019                if (defined($env_vars->{RESOLV_WRAPPER_CONF})) {
     1020                        $ENV{RESOLV_WRAPPER_CONF} = $env_vars->{RESOLV_WRAPPER_CONF};
     1021                } else {
     1022                        $ENV{RESOLV_WRAPPER_HOSTS} = $env_vars->{RESOLV_WRAPPER_HOSTS};
     1023                }
     1024                $ENV{UID_WRAPPER_ROOT} = "1";
     1025
     1026                $ENV{ENVNAME} = "$ENV{ENVNAME}.smbd";
    3931027
    3941028                if ($smbd ne "yes") {
    … …  
    3981032                                exit 0;
    3991033                        };
    400                         sleep($maxtime);
     1034                        sleep($self->{server_maxtime});
    4011035                        exit 0;
    4021036                }
    4031037
    404                 $ENV{MAKE_TEST_BINARY} = $self->binpath("smbd");
     1038                $ENV{MAKE_TEST_BINARY} = Samba::bindir_path($self, "smbd");
    4051039                my @optargs = ("-d0");
    4061040                if (defined($ENV{SMBD_OPTIONS})) {
    4071041                        @optargs = split(/ /, $ENV{SMBD_OPTIONS});
    4081042                }
    409                 my @preargs = ($self->binpath("timelimit"), $maxtime);
     1043                my @preargs = (Samba::bindir_path($self, "timelimit"), $self->{server_maxtime});
    4101044                if(defined($ENV{SMBD_VALGRIND})) {
    4111045                        @preargs = split(/ /,$ENV{SMBD_VALGRIND});
    4121046                }
    413                 exec(@preargs, $self->binpath("smbd"), "-F", "--no-process-group", "-s", $env_vars->{SERVERCONFFILE}, @optargs) or die("Unable to start smbd: $!");
    414         }
     1047                my @args = ("-F", "--no-process-group",
     1048                            "-s", $env_vars->{SERVERCONFFILE},
     1049                            "-l", $env_vars->{LOGDIR});
     1050                if (not defined($ENV{SMBD_DONT_LOG_STDOUT})) {
     1051                        push(@args, "--log-stdout");
     1052                }
     1053
     1054                close($env_vars->{STDIN_PIPE});
     1055                open STDIN, ">&", \*STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
     1056
     1057                exec(@preargs, $ENV{MAKE_TEST_BINARY}, @args, @optargs)
     1058                        or die("Unable to start $ENV{MAKE_TEST_BINARY}: $!");
     1059        }
     1060        $env_vars->{SMBD_TL_PID} = $pid;
    4151061        write_pid($env_vars, "smbd", $pid);
    4161062        print "DONE\n";
    4171063
    418         return 0;
    419 }
    420 
    421 sub provision($$$$$$)
     1064        close(STDIN_READER);
     1065
     1066        return $self->wait_for_start($env_vars, $nmbd, $winbindd, $smbd);
     1067}
     1068
     1069sub createuser($$$$)
    4221070{
    423         my ($self, $prefix, $server, $swiface, $password, $extra_options) = @_;
     1071        my ($self, $username, $password, $conffile) = @_;
     1072        my $cmd = "UID_WRAPPER_ROOT=1 " . Samba::bindir_path($self, "smbpasswd")." -c $conffile -L -s -a $username > /dev/null";
     1073        unless (open(PWD, "|$cmd")) {
     1074            warn("Unable to set password for $username account\n$cmd");
     1075            return undef;
     1076        }
     1077        print PWD "$password\n$password\n";
     1078        unless (close(PWD)) {
     1079            warn("Unable to set password for $username account\n$cmd");
     1080            return undef;
     1081        }
     1082        print "DONE\n";
     1083}
     1084
     1085sub provision($$$$$$$$)
     1086{
     1087        my ($self, $prefix, $server, $password, $extra_options, $dc_server_ip, $dc_server_ipv6, $no_delete_prefix) = @_;
    4241088
    4251089        ##
    … …  
    4271091        ##
    4281092
     1093        my $swiface = Samba::get_interface($server);
    4291094        my %ret = ();
    4301095        my $server_ip = "127.0.0.$swiface";
     1096        my $server_ipv6 = sprintf("fd00:0000:0000:0000:0000:0000:5357:5f%02x", $swiface);
    4311097        my $domain = "SAMBA-TEST";
    4321098
    … …  
    4391105        my $prefix_abs = abs_path($prefix);
    4401106        my $bindir_abs = abs_path($self->{bindir});
    441         my $vfs_modulesdir_abs = ($ENV{VFSLIBDIR} or $bindir_abs);
    4421107
    4431108        my @dirs = ();
    … …  
    4811146        my $msdfs_deeppath="$msdfs_shrdir/deeppath";
    4821147        push(@dirs,$msdfs_deeppath);
     1148
     1149        my $badnames_shrdir="$shrdir/badnames";
     1150        push(@dirs,$badnames_shrdir);
     1151
     1152        my $lease1_shrdir="$shrdir/SMB2_10";
     1153        push(@dirs,$lease1_shrdir);
     1154
     1155        my $lease2_shrdir="$shrdir/SMB3_00";
     1156        push(@dirs,$lease2_shrdir);
     1157
     1158        my $manglenames_shrdir="$shrdir/manglenames";
     1159        push(@dirs,$manglenames_shrdir);
     1160
     1161        my $widelinks_shrdir="$shrdir/widelinks";
     1162        push(@dirs,$widelinks_shrdir);
     1163
     1164        my $widelinks_linkdir="$shrdir/widelinks_foo";
     1165        push(@dirs,$widelinks_linkdir);
     1166
     1167        my $shadow_tstdir="$shrdir/shadow";
     1168        push(@dirs,$shadow_tstdir);
     1169        my $shadow_mntdir="$shadow_tstdir/mount";
     1170        push(@dirs,$shadow_mntdir);
     1171        my $shadow_basedir="$shadow_mntdir/base";
     1172        push(@dirs,$shadow_basedir);
     1173        my $shadow_shrdir="$shadow_basedir/share";
     1174        push(@dirs,$shadow_shrdir);
    4831175
    4841176        # this gets autocreated by winbindd
    … …  
    4971189        mkdir($prefix_abs, 0777);
    4981190        print "CREATE TEST ENVIRONMENT IN '$prefix'...";
    499         system("rm -rf $prefix_abs/*");
     1191        if (not defined($no_delete_prefix) or not $no_delete_prefix) {
     1192            system("rm -rf $prefix_abs/*");
     1193        }
    5001194        mkdir($_, 0777) foreach(@dirs);
     1195
     1196        my $fs_specific_conf = $self->get_fs_specific_conf($shrdir);
     1197
     1198        ##
     1199        ## lockdir and piddir must be 0755
     1200        ##
     1201        chmod 0755, $lockdir;
     1202        chmod 0755, $piddir;
     1203
    5011204
    5021205        ##
    … …  
    5061209        chmod 0755, $ro_shrdir;
    5071210        my $unreadable_file = "$ro_shrdir/unreadable_file";
    508         open(UNREADABLE_FILE, ">$unreadable_file") or die("Unable to open $unreadable_file");
     1211        unless (open(UNREADABLE_FILE, ">$unreadable_file")) {
     1212                warn("Unable to open $unreadable_file");
     1213                return undef;
     1214        }
    5091215        close(UNREADABLE_FILE);
    5101216        chmod 0600, $unreadable_file;
    5111217
    5121218        my $msdfs_target = "$ro_shrdir/msdfs-target";
    513         open(MSDFS_TARGET, ">$msdfs_target") or die("Unable to open $msdfs_target");
     1219        unless (open(MSDFS_TARGET, ">$msdfs_target")) {
     1220                warn("Unable to open $msdfs_target");
     1221                return undef;
     1222        }
    5141223        close(MSDFS_TARGET);
    5151224        chmod 0666, $msdfs_target;
    516         symlink "msdfs:$server_ip\\ro-tmp", "$msdfs_shrdir/msdfs-src1";
    517         symlink "msdfs:$server_ip\\ro-tmp", "$msdfs_shrdir/deeppath/msdfs-src2";
     1225        symlink "msdfs:$server_ip\\ro-tmp,$server_ipv6\\ro-tmp",
     1226                "$msdfs_shrdir/msdfs-src1";
     1227        symlink "msdfs:$server_ipv6\\ro-tmp", "$msdfs_shrdir/deeppath/msdfs-src2";
     1228
     1229        ##
     1230        ## create bad names in $badnames_shrdir
     1231        ##
     1232        ## (An invalid name, would be mangled to 8.3).
     1233        my $badname_target = "$badnames_shrdir/\340|\231\216\377\177";
     1234        unless (open(BADNAME_TARGET, ">$badname_target")) {
     1235                warn("Unable to open $badname_target");
     1236                return undef;
     1237        }
     1238        close(BADNAME_TARGET);
     1239        chmod 0666, $badname_target;
     1240
     1241        ## (A bad name, would not be mangled to 8.3).
     1242        my $badname_target = "$badnames_shrdir/\240\276\346\327\377\177";
     1243        unless (open(BADNAME_TARGET, ">$badname_target")) {
     1244                warn("Unable to open $badname_target");
     1245                return undef;
     1246        }
     1247        close(BADNAME_TARGET);
     1248        chmod 0666, $badname_target;
     1249
     1250        ## (A bad good name).
     1251        my $badname_target = "$badnames_shrdir/blank.txt";
     1252        unless (open(BADNAME_TARGET, ">$badname_target")) {
     1253                warn("Unable to open $badname_target");
     1254                return undef;
     1255        }
     1256        close(BADNAME_TARGET);
     1257        chmod 0666, $badname_target;
     1258
     1259        ##
     1260        ## create mangleable directory names in $manglenames_shrdir
     1261        ##
     1262        my $manglename_target = "$manglenames_shrdir/foo:bar";
     1263        mkdir($manglename_target, 0777);
     1264
     1265        ##
     1266        ## create symlinks for widelinks tests.
     1267        ##
     1268        my $widelinks_target = "$widelinks_linkdir/target";
     1269        unless (open(WIDELINKS_TARGET, ">$widelinks_target")) {
     1270                warn("Unable to open $widelinks_target");
     1271                return undef;
     1272        }
     1273        close(WIDELINKS_TARGET);
     1274        chmod 0666, $widelinks_target;
     1275        ##
     1276        ## This link should get ACCESS_DENIED
     1277        ##
     1278        symlink "$widelinks_target", "$widelinks_shrdir/source";
     1279        ##
     1280        ## This link should be allowed
     1281        ##
     1282        symlink "$widelinks_shrdir", "$widelinks_shrdir/dot";
    5181283
    5191284        my $conffile="$libdir/server.conf";
     1285        my $dfqconffile="$libdir/dfq.conf";
    5201286
    5211287        my $nss_wrapper_pl = "$ENV{PERL} $self->{srcdir}/lib/nss_wrapper/nss_wrapper.pl";
    5221288        my $nss_wrapper_passwd = "$privatedir/passwd";
    5231289        my $nss_wrapper_group = "$privatedir/group";
     1290        my $nss_wrapper_hosts = "$ENV{SELFTEST_PREFIX}/hosts";
     1291        my $resolv_conf = "$privatedir/resolv.conf";
     1292        my $dns_host_file = "$ENV{SELFTEST_PREFIX}/dns_host_file";
    5241293
    5251294        my $mod_printer_pl = "$ENV{PERL} $self->{srcdir}/source3/script/tests/printing/modprinter.pl";
    5261295
     1296        my $fake_snap_pl = "$ENV{PERL} $self->{srcdir}/source3/script/tests/fake_snap.pl";
     1297
    5271298        my @eventlog_list = ("dns server", "application");
    5281299
    … …  
    5321303
    5331304        my ($max_uid, $max_gid);
    534         my ($uid_nobody, $uid_root);
    535         my ($gid_nobody, $gid_nogroup, $gid_root, $gid_domusers);
    536 
    537         if ($unix_uid < 0xffff - 2) {
     1305        my ($uid_nobody, $uid_root, $uid_pdbtest, $uid_pdbtest2, $uid_userdup);
     1306        my ($uid_pdbtest_wkn);
     1307        my ($uid_smbget);
     1308        my ($uid_force_user);
     1309        my ($gid_nobody, $gid_nogroup, $gid_root, $gid_domusers, $gid_domadmins);
     1310        my ($gid_userdup, $gid_everyone);
     1311        my ($gid_force_user);
     1312
     1313        if ($unix_uid < 0xffff - 7) {
    5381314                $max_uid = 0xffff;
    5391315        } else {
    … …  
    5431319        $uid_root = $max_uid - 1;
    5441320        $uid_nobody = $max_uid - 2;
    545 
    546         if ($unix_gids[0] < 0xffff - 3) {
     1321        $uid_pdbtest = $max_uid - 3;
     1322        $uid_pdbtest2 = $max_uid - 4;
     1323        $uid_userdup = $max_uid - 5;
     1324        $uid_pdbtest_wkn = $max_uid - 6;
     1325        $uid_force_user = $max_uid - 7;
     1326        $uid_smbget = $max_uid - 8;
     1327
     1328        if ($unix_gids[0] < 0xffff - 8) {
    5471329                $max_gid = 0xffff;
    5481330        } else {
    … …  
    5541336        $gid_root = $max_gid - 3;
    5551337        $gid_domusers = $max_gid - 4;
     1338        $gid_domadmins = $max_gid - 5;
     1339        $gid_userdup = $max_gid - 6;
     1340        $gid_everyone = $max_gid - 7;
     1341        $gid_force_user = $max_gid - 8;
    5561342
    5571343        ##
    … …  
    5591345        ##
    5601346
    561         open(CONF, ">$conffile") or die("Unable to open $conffile");
     1347        unless (open(CONF, ">$conffile")) {
     1348                warn("Unable to open $conffile");
     1349                return undef;
     1350        }
    5621351        print CONF "
    5631352[global]
    5641353        netbios name = $server
    565         interfaces = $server_ip/8
     1354        interfaces = $server_ip/8 $server_ipv6/64
    5661355        bind interfaces only = yes
    567         panic action = $self->{srcdir}/selftest/gdb_backtrace %d %\$(MAKE_TEST_BINARY)
     1356        panic action = cd $self->{srcdir} && $self->{srcdir}/selftest/gdb_backtrace %d %\$(MAKE_TEST_BINARY)
     1357        smbd:suicide mode = yes
    5681358
    5691359        workgroup = $domain
    … …  
    5731363        lock directory = $lockdir
    5741364        log file = $logdir/log.\%m
    575         log level = 0
     1365        log level = 1
    5761366        debug pid = yes
    577 
    578         name resolve order = bcast
     1367        max log size = 0
    5791368
    5801369        state directory = $lockdir
    … …  
    6001389        kernel oplocks = no
    6011390        kernel change notify = no
    602 
    603         syslog = no
     1391        smb2 leases = yes
     1392
     1393        logging = file
    6041394        printing = bsd
    6051395        printcap name = /dev/null
    6061396
    607         winbindd:socket dir = $wbsockdir
     1397        winbindd socket directory = $wbsockdir
    6081398        nmbd:socket dir = $nmbdsockdir
    6091399        idmap config * : range = 100000-200000
    6101400        winbind enum users = yes
    6111401        winbind enum groups = yes
     1402        winbind separator = /
    6121403
    6131404#       min receivefile size = 4000
    6141405
    615         max protocol = SMB2
    6161406        read only = no
    6171407        server signing = auto
    6181408
    6191409        smbd:sharedelay = 100000
    620 #       smbd:writetimeupdatedelay = 500000
     1410        smbd:writetimeupdatedelay = 500000
    6211411        map hidden = no
    6221412        map system = no
    … …  
    6241414        store dos attributes = yes
    6251415        create mask = 755
    626         vfs objects = $vfs_modulesdir_abs/xattr_tdb.so $vfs_modulesdir_abs/streams_depot.so
     1416        dos filemode = yes
     1417        strict rename = yes
     1418        strict sync = yes
     1419        vfs objects = acl_xattr fake_acls xattr_tdb streams_depot
    6271420
    6281421        printing = vlp
    … …  
    6351428        queue resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queueresume %p
    6361429        lpq cache time = 0
    637 
    638         ncalrpc dir = $lockdir/ncalrpc
    639         rpc_server:epmapper = embedded
     1430        print notify backchannel = yes
     1431
     1432        ncalrpc dir = $prefix_abs/ncalrpc
     1433
     1434        # The samba3.blackbox.smbclient_s3 test uses this to test that
     1435        # sending messages works, and that the %m sub works.
     1436        message command = mv %s $shrdir/message.%m
     1437
     1438        # fsrvp server requires registry shares
     1439        registry shares = yes
     1440
     1441        # Used by RPC SRVSVC tests
     1442        add share command = $bindir_abs/smbaddshare
     1443        change share command = $bindir_abs/smbchangeshare
     1444        delete share command = $bindir_abs/smbdeleteshare
     1445
     1446        # fruit:copyfile is a global option
     1447        fruit:copyfile = yes
     1448
     1449        #this does not mean that we use non-secure test env,
     1450        #it just means we ALLOW one to be configured.
     1451        allow insecure wide links = yes
    6401452
    6411453        # Begin extra options
    … …  
    6531465[tmp]
    6541466        path = $shrdir
    655         comment = smb username is [%U]
    656         vfs objects = $vfs_modulesdir_abs/dirsort.so
     1467        comment = smb username is [%U]
     1468[tmpsort]
     1469        path = $shrdir
     1470        comment = Load dirsort module
     1471        vfs objects = dirsort acl_xattr fake_acls xattr_tdb streams_depot
     1472[tmpenc]
     1473        path = $shrdir
     1474        comment = encrypt smb username is [%U]
     1475        smb encrypt = required
     1476        vfs objects = dirsort
    6571477[tmpguest]
    6581478        path = $shrdir
    … …  
    6661486        force user = $unix_name
    6671487        guest ok = yes
     1488[forceuser_unixonly]
     1489        comment = force a user with unix user SID and group SID
     1490        path = $shrdir
     1491        force user = pdbtest
     1492        guest ok = yes
     1493[forceuser_wkngroup]
     1494        comment = force a user with well-known group SID
     1495        path = $shrdir
     1496        force user = pdbtest_wkn
     1497        guest ok = yes
    6681498[forcegroup]
    6691499        path = $shrdir
    … …  
    6731503        path = $ro_shrdir
    6741504        guest ok = yes
     1505[write-list-tmp]
     1506        path = $shrdir
     1507        read only = yes
     1508        write list = $unix_name
     1509[valid-users-tmp]
     1510        path = $shrdir
     1511        valid users = $unix_name
    6751512[msdfs-share]
    6761513        path = $msdfs_shrdir
    6771514        msdfs root = yes
     1515        msdfs shuffle referrals = yes
    6781516        guest ok = yes
    6791517[hideunread]
    … …  
    6861524        copy = tmp
    6871525        hide unwriteable files = yes
     1526[durable]
     1527        copy = tmp
     1528        kernel share modes = no
     1529        kernel oplocks = no
     1530        posix locking = no
     1531[fs_specific]
     1532        copy = tmp
     1533        $fs_specific_conf
    6881534[print1]
    6891535        copy = tmp
    … …  
    6941540[print3]
    6951541        copy = print1
     1542        default devmode = no
    6961543[lp]
    6971544        copy = print1
     1545
     1546[nfs4acl_simple]
     1547        path = $shrdir
     1548        comment = smb username is [%U]
     1549        nfs4:mode = simple
     1550        vfs objects = nfs4acl_xattr xattr_tdb
     1551
     1552[nfs4acl_special]
     1553        path = $shrdir
     1554        comment = smb username is [%U]
     1555        nfs4:mode = special
     1556        vfs objects = nfs4acl_xattr xattr_tdb
     1557
     1558[xcopy_share]
     1559        path = $shrdir
     1560        comment = smb username is [%U]
     1561        create mask = 777
     1562        force create mode = 777
     1563[posix_share]
     1564        path = $shrdir
     1565        comment = smb username is [%U]
     1566        create mask = 0777
     1567        force create mode = 0
     1568        directory mask = 0777
     1569        force directory mode = 0
     1570        vfs objects = xattr_tdb
     1571[aio]
     1572        copy = tmp
     1573        aio read size = 1
     1574        aio write size = 1
     1575
    6981576[print\$]
    6991577        copy = tmp
     1578
     1579[vfs_fruit]
     1580        path = $shrdir
     1581        vfs objects = catia fruit streams_xattr acl_xattr
     1582        ea support = yes
     1583        fruit:ressource = file
     1584        fruit:metadata = netatalk
     1585        fruit:locking = netatalk
     1586        fruit:encoding = native
     1587
     1588[badname-tmp]
     1589        path = $badnames_shrdir
     1590        guest ok = yes
     1591
     1592[manglenames_share]
     1593        path = $manglenames_shrdir
     1594        guest ok = yes
     1595
     1596[dynamic_share]
     1597        path = $shrdir/%R
     1598        guest ok = yes
     1599
     1600[widelinks_share]
     1601        path = $widelinks_shrdir
     1602        wide links = no
     1603        guest ok = yes
     1604
     1605[fsrvp_share]
     1606        path = $shrdir
     1607        comment = fake shapshots using rsync
     1608        vfs objects = shell_snap shadow_copy2
     1609        shell_snap:check path command = $fake_snap_pl --check
     1610        shell_snap:create command = $fake_snap_pl --create
     1611        shell_snap:delete command = $fake_snap_pl --delete
     1612        # a relative path here fails, the snapshot dir is no longer found
     1613        shadow:snapdir = $shrdir/.snapshots
     1614
     1615[shadow1]
     1616        path = $shadow_shrdir
     1617        comment = previous versions snapshots under mount point
     1618        vfs objects = shadow_copy2
     1619        shadow:mountpoint = $shadow_mntdir
     1620
     1621[shadow2]
     1622        path = $shadow_shrdir
     1623        comment = previous versions snapshots outside mount point
     1624        vfs objects = shadow_copy2
     1625        shadow:mountpoint = $shadow_mntdir
     1626        shadow:snapdir = $shadow_tstdir/.snapshots
     1627
     1628[shadow3]
     1629        path = $shadow_shrdir
     1630        comment = previous versions with subvolume snapshots, snapshots under base dir
     1631        vfs objects = shadow_copy2
     1632        shadow:mountpoint = $shadow_mntdir
     1633        shadow:basedir = $shadow_basedir
     1634        shadow:snapdir = $shadow_basedir/.snapshots
     1635
     1636[shadow4]
     1637        path = $shadow_shrdir
     1638        comment = previous versions with subvolume snapshots, snapshots outside mount point
     1639        vfs objects = shadow_copy2
     1640        shadow:mountpoint = $shadow_mntdir
     1641        shadow:basedir = $shadow_basedir
     1642        shadow:snapdir = $shadow_tstdir/.snapshots
     1643
     1644[shadow5]
     1645        path = $shadow_shrdir
     1646        comment = previous versions at volume root snapshots under mount point
     1647        vfs objects = shadow_copy2
     1648        shadow:mountpoint = $shadow_shrdir
     1649
     1650[shadow6]
     1651        path = $shadow_shrdir
     1652        comment = previous versions at volume root snapshots outside mount point
     1653        vfs objects = shadow_copy2
     1654        shadow:mountpoint = $shadow_shrdir
     1655        shadow:snapdir = $shadow_tstdir/.snapshots
     1656
     1657[shadow7]
     1658        path = $shadow_shrdir
     1659        comment = previous versions snapshots everywhere
     1660        vfs objects = shadow_copy2
     1661        shadow:mountpoint = $shadow_mntdir
     1662        shadow:snapdirseverywhere = yes
     1663
     1664[shadow8]
     1665        path = $shadow_shrdir
     1666        comment = previous versions using snapsharepath
     1667        vfs objects = shadow_copy2
     1668        shadow:mountpoint = $shadow_mntdir
     1669        shadow:snapdir = $shadow_tstdir/.snapshots
     1670        shadow:snapsharepath = share
     1671
     1672[shadow_wl]
     1673        path = $shadow_shrdir
     1674        comment = previous versions with wide links allowed
     1675        vfs objects = shadow_copy2
     1676        shadow:mountpoint = $shadow_mntdir
     1677        wide links = yes
     1678[dfq]
     1679        path = $shrdir/dfree
     1680        vfs objects = fake_dfq
     1681        admin users = $unix_name
     1682        include = $dfqconffile
    7001683        ";
    7011684        close(CONF);
    7021685
     1686        unless (open(DFQCONF, ">$dfqconffile")) {
     1687                warn("Unable to open $dfqconffile");
     1688                return undef;
     1689        }
     1690        close(DFQCONF);
     1691
    7031692        ##
    7041693        ## create a test account
    7051694        ##
    7061695
    707         open(PASSWD, ">$nss_wrapper_passwd") or die("Unable to open $nss_wrapper_passwd");
     1696        unless (open(PASSWD, ">$nss_wrapper_passwd")) {
     1697           warn("Unable to open $nss_wrapper_passwd");
     1698           return undef;
     1699        }
    7081700        print PASSWD "nobody:x:$uid_nobody:$gid_nobody:nobody gecos:$prefix_abs:/bin/false
    7091701$unix_name:x:$unix_uid:$unix_gids[0]:$unix_name gecos:$prefix_abs:/bin/false
     1702pdbtest:x:$uid_pdbtest:$gid_nogroup:pdbtest gecos:$prefix_abs:/bin/false
     1703pdbtest2:x:$uid_pdbtest2:$gid_nogroup:pdbtest gecos:$prefix_abs:/bin/false
     1704userdup:x:$uid_userdup:$gid_userdup:userdup gecos:$prefix_abs:/bin/false
     1705pdbtest_wkn:x:$uid_pdbtest_wkn:$gid_everyone:pdbtest_wkn gecos:$prefix_abs:/bin/false
     1706force_user:x:$uid_force_user:$gid_force_user:force user gecos:$prefix_abs:/bin/false
     1707smbget_user:x:$uid_smbget:$gid_domusers:smbget_user gecos:$prefix_abs:/bin/false
    7101708";
    7111709        if ($unix_uid != 0) {
    712                 print PASSWD "root:x:$uid_root:$gid_root:root gecos:$prefix_abs:/bin/false";
     1710                print PASSWD "root:x:$uid_root:$gid_root:root gecos:$prefix_abs:/bin/false
     1711";
    7131712        }
    7141713        close(PASSWD);
    7151714
    716         open(GROUP, ">$nss_wrapper_group") or die("Unable to open $nss_wrapper_group");
     1715        unless (open(GROUP, ">$nss_wrapper_group")) {
     1716             warn("Unable to open $nss_wrapper_group");
     1717             return undef;
     1718        }
    7171719        print GROUP "nobody:x:$gid_nobody:
    7181720nogroup:x:$gid_nogroup:nobody
    7191721$unix_name-group:x:$unix_gids[0]:
    7201722domusers:X:$gid_domusers:
     1723domadmins:X:$gid_domadmins:
     1724userdup:x:$gid_userdup:$unix_name
     1725everyone:x:$gid_everyone:
     1726force_user:x:$gid_force_user:
    7211727";
    7221728        if ($unix_gids[0] != 0) {
    723                 print GROUP "root:x:$gid_root:";
     1729                print GROUP "root:x:$gid_root:
     1730";
    7241731        }
    7251732
    7261733        close(GROUP);
     1734
     1735        ## hosts
     1736        my $hostname = lc($server);
     1737        unless (open(HOSTS, ">>$nss_wrapper_hosts")) {
     1738                warn("Unable to open $nss_wrapper_hosts");
     1739                return undef;
     1740        }
     1741        print HOSTS "${server_ip} ${hostname}.samba.example.com ${hostname}\n";
     1742        print HOSTS "${server_ipv6} ${hostname}.samba.example.com ${hostname}\n";
     1743        close(HOSTS);
     1744
     1745        ## hosts
     1746        unless (open(RESOLV_CONF, ">$resolv_conf")) {
     1747                warn("Unable to open $resolv_conf");
     1748                return undef;
     1749        }
     1750        if (defined($dc_server_ip) or defined($dc_server_ipv6)) {
     1751                if (defined($dc_server_ip)) {
     1752                        print RESOLV_CONF "nameserver $dc_server_ip\n";
     1753                }
     1754                if (defined($dc_server_ipv6)) {
     1755                        print RESOLV_CONF "nameserver $dc_server_ipv6\n";
     1756                }
     1757        } else {
     1758                print RESOLV_CONF "nameserver ${server_ip}\n";
     1759                print RESOLV_CONF "nameserver ${server_ipv6}\n";
     1760        }
     1761        close(RESOLV_CONF);
    7271762
    7281763        foreach my $evlog (@eventlog_list) {
    … …  
    7341769        $ENV{NSS_WRAPPER_PASSWD} = $nss_wrapper_passwd;
    7351770        $ENV{NSS_WRAPPER_GROUP} = $nss_wrapper_group;
    736 
    737         open(PWD, "|".$self->binpath("smbpasswd")." -c $conffile -L -s -a $unix_name >/dev/null");
    738         print PWD "$password\n$password\n";
    739         close(PWD) or die("Unable to set password for test account");
    740 
    741         print "DONE\n";
     1771        $ENV{NSS_WRAPPER_HOSTS} = $nss_wrapper_hosts;
     1772        $ENV{NSS_WRAPPER_HOSTNAME} = "${hostname}.samba.example.com";
     1773        if ($ENV{SAMBA_DNS_FAKING}) {
     1774                $ENV{RESOLV_WRAPPER_CONF} = $resolv_conf;
     1775        } else {
     1776                $ENV{RESOLV_WRAPPER_HOSTS} = $dns_host_file;
     1777        }
     1778
     1779        createuser($self, $unix_name, $password, $conffile) || die("Unable to create user");
     1780        createuser($self, "force_user", $password, $conffile) || die("Unable to create force_user");
     1781        createuser($self, "smbget_user", $password, $conffile) || die("Unable to create smbget_user");
     1782
     1783        open(DNS_UPDATE_LIST, ">$prefix/dns_update_list") or die("Unable to open $$prefix/dns_update_list");
     1784        print DNS_UPDATE_LIST "A $server. $server_ip\n";
     1785        print DNS_UPDATE_LIST "AAAA $server. $server_ipv6\n";
     1786        close(DNS_UPDATE_LIST);
    7421787
    7431788        $ret{SERVER_IP} = $server_ip;
     1789        $ret{SERVER_IPV6} = $server_ipv6;
    7441790        $ret{NMBD_TEST_LOG} = "$prefix/nmbd_test.log";
    7451791        $ret{NMBD_TEST_LOG_POS} = 0;
    … …  
    7571803        $ret{PASSWORD} = $password;
    7581804        $ret{PIDDIR} = $piddir;
    759         $ret{WINBINDD_SOCKET_DIR} = $wbsockdir;
     1805        $ret{SELFTEST_WINBINDD_SOCKET_DIR} = $wbsockdir;
    7601806        $ret{WINBINDD_PRIV_PIPE_DIR} = $wbsockprivdir;
    7611807        $ret{NMBD_SOCKET_DIR} = $nmbdsockdir;
    … …  
    7631809        $ret{NSS_WRAPPER_PASSWD} = $nss_wrapper_passwd;
    7641810        $ret{NSS_WRAPPER_GROUP} = $nss_wrapper_group;
    765         $ret{NSS_WRAPPER_WINBIND_SO_PATH} = $ENV{NSS_WRAPPER_WINBIND_SO_PATH};
     1811        $ret{NSS_WRAPPER_HOSTS} = $nss_wrapper_hosts;
     1812        $ret{NSS_WRAPPER_HOSTNAME} = "${hostname}.samba.example.com";
     1813        $ret{NSS_WRAPPER_MODULE_SO_PATH} = Samba::nss_wrapper_winbind_so_path($self);
     1814        $ret{NSS_WRAPPER_MODULE_FN_PREFIX} = "winbind";
     1815        if ($ENV{SAMBA_DNS_FAKING}) {
     1816                $ret{RESOLV_WRAPPER_HOSTS} = $dns_host_file;
     1817        } else {
     1818                $ret{RESOLV_WRAPPER_CONF} = $resolv_conf;
     1819        }
    7661820        $ret{LOCAL_PATH} = "$shrdir";
     1821        $ret{LOGDIR} = $logdir;
     1822
     1823        #
     1824        # Avoid hitting system krb5.conf -
     1825        # An env that needs Kerberos will reset this to the real
     1826        # value.
     1827        #
     1828        $ret{KRB5_CONFIG} = abs_path($prefix) . "/no_krb5.conf";
    7671829
    7681830        return \%ret;
    7691831}
    7701832
    771 sub wait_for_start($$)
     1833sub wait_for_start($$$$$)
    7721834{
    773         my ($self, $envvars) = @_;
    774 
    775         # give time for nbt server to register its names
    776         print "delaying for nbt name registration\n";
    777         sleep(10);
    778         # This will return quickly when things are up, but be slow if we need to wait for (eg) SSL init
    779         system($self->binpath("nmblookup") ." $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} __SAMBA__");
    780         system($self->binpath("nmblookup") ." $envvars->{CONFIGURATION} __SAMBA__");
    781         system($self->binpath("nmblookup") ." $envvars->{CONFIGURATION} -U 127.255.255.255 __SAMBA__");
    782         system($self->binpath("nmblookup") ." $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} $envvars->{SERVER}");
    783         system($self->binpath("nmblookup") ." $envvars->{CONFIGURATION} $envvars->{SERVER}");
    784         # make sure smbd is also up set
    785         print "wait for smbd\n";
    786         system($self->binpath("smbclient") ." $envvars->{CONFIGURATION} -L $envvars->{SERVER_IP} -U% -p 139 | head -2");
    787         system($self->binpath("smbclient") ." $envvars->{CONFIGURATION} -L $envvars->{SERVER_IP} -U% -p 139 | head -2");
     1835        my ($self, $envvars, $nmbd, $winbindd, $smbd) = @_;
     1836        my $ret;
     1837
     1838        if ($nmbd eq "yes") {
     1839                my $count = 0;
     1840
     1841                # give time for nbt server to register its names
     1842                print "checking for nmbd\n";
     1843
     1844                # This will return quickly when things are up, but be slow if we need to wait for (eg) SSL init
     1845                my $nmblookup = Samba::bindir_path($self, "nmblookup");
     1846
     1847                do {
     1848                        $ret = system("$nmblookup $envvars->{CONFIGURATION} $envvars->{SERVER}");
     1849                        if ($ret != 0) {
     1850                                sleep(1);
     1851                        } else {
     1852                                system("$nmblookup $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} __SAMBA__");
     1853                                system("$nmblookup $envvars->{CONFIGURATION} __SAMBA__");
     1854                                system("$nmblookup $envvars->{CONFIGURATION} -U 127.255.255.255 __SAMBA__");
     1855                                system("$nmblookup $envvars->{CONFIGURATION} -U $envvars->{SERVER_IP} $envvars->{SERVER}");
     1856                        }
     1857                        $count++;
     1858                } while ($ret != 0 && $count < 10);
     1859                if ($count == 10) {
     1860                        print "NMBD not reachable after 10 retries\n";
     1861                        teardown_env($self, $envvars);
     1862                        return 0;
     1863                }
     1864        }
     1865
     1866        if ($winbindd eq "yes") {
     1867            print "checking for winbindd\n";
     1868            my $count = 0;
     1869            do {
     1870                $ret = system("SELFTEST_WINBINDD_SOCKET_DIR=" . $envvars->{SELFTEST_WINBINDD_SOCKET_DIR} . " " . Samba::bindir_path($self, "wbinfo") . " --ping-dc");
     1871                if ($ret != 0) {
     1872                    sleep(2);
     1873                }
     1874                $count++;
     1875            } while ($ret != 0 && $count < 10);
     1876            if ($count == 10) {
     1877                print "WINBINDD not reachable after 20 seconds\n";
     1878                teardown_env($self, $envvars);
     1879                return 0;
     1880            }
     1881        }
     1882
     1883        if ($smbd eq "yes") {
     1884            # make sure smbd is also up set
     1885            print "wait for smbd\n";
     1886
     1887            my $count = 0;
     1888            do {
     1889                $ret = system(Samba::bindir_path($self, "smbclient") ." $envvars->{CONFIGURATION} -L $envvars->{SERVER} -U% -p 139");
     1890                if ($ret != 0) {
     1891                    sleep(2);
     1892                }
     1893                $count++
     1894            } while ($ret != 0 && $count < 10);
     1895            if ($count == 10) {
     1896                print "SMBD failed to start up in a reasonable time (20sec)\n";
     1897                teardown_env($self, $envvars);
     1898                return 0;
     1899            }
     1900        }
    7881901
    7891902        # Ensure we have domain users mapped.
    790         system($self->binpath("net") ." $envvars->{CONFIGURATION} groupmap add rid=513 unixgroup=domusers type=domain");
     1903        $ret = system(Samba::bindir_path($self, "net") ." $envvars->{CONFIGURATION} groupmap add rid=513 unixgroup=domusers type=domain");
     1904        if ($ret != 0) {
     1905            return 1;
     1906        }
     1907        $ret = system(Samba::bindir_path($self, "net") ." $envvars->{CONFIGURATION} groupmap add rid=512 unixgroup=domadmins type=domain");
     1908        if ($ret != 0) {
     1909            return 1;
     1910        }
     1911        $ret = system(Samba::bindir_path($self, "net") ." $envvars->{CONFIGURATION} groupmap add sid=S-1-1-0 unixgroup=everyone type=builtin");
     1912        if ($ret != 0) {
     1913            return 1;
     1914        }
     1915
     1916        if ($winbindd eq "yes") {
     1917            # note: creating builtin groups requires winbindd for the
     1918            # unix id allocator
     1919            $ret = system("SELFTEST_WINBINDD_SOCKET_DIR=" . $envvars->{SELFTEST_WINBINDD_SOCKET_DIR} . " " . Samba::bindir_path($self, "net") ." $envvars->{CONFIGURATION} sam createbuiltingroup Users");
     1920            if ($ret != 0) {
     1921                print "Failed to create BUILTIN\\Users group\n";
     1922                return 0;
     1923            }
     1924            my $count = 0;
     1925            do {
     1926                system(Samba::bindir_path($self, "net") . " $envvars->{CONFIGURATION} cache flush");
     1927                $ret = system("SELFTEST_WINBINDD_SOCKET_DIR=" . $envvars->{SELFTEST_WINBINDD_SOCKET_DIR} . " " . Samba::bindir_path($self, "wbinfo") . " --sid-to-gid=S-1-5-32-545");
     1928                if ($ret != 0) {
     1929                    sleep(2);
     1930                }
     1931                $count++;
     1932            } while ($ret != 0 && $count < 10);
     1933            if ($count == 10) {
     1934                print "WINBINDD not reachable after 20 seconds\n";
     1935                teardown_env($self, $envvars);
     1936                return 0;
     1937            }
     1938        }
    7911939
    7921940        print $self->getlog_env($envvars);
     1941
     1942        return 1;
    7931943}
    7941944

  • vendor/current/selftest/target/Samba4.pm

    r740 r988  
    1111use POSIX;
    1212use SocketWrapper;
     13use target::Samba;
     14use target::Samba3;
    1315
    1416sub new($$$$$) {
    15         my ($classname, $bindir, $ldap, $srcdir, $exeext) = @_;
    16         $exeext = "" unless defined($exeext);
     17        my ($classname, $bindir, $ldap, $srcdir, $server_maxtime) = @_;
     18
    1719        my $self = {
    1820                vars => {},
    … …  
    2022                bindir => $bindir,
    2123                srcdir => $srcdir,
    22                 exeext => $exeext
     24                server_maxtime => $server_maxtime,
     25                target3 => new Samba3($bindir, $srcdir, $server_maxtime)
    2326        };
    2427        bless $self;
    … …  
    2629}
    2730
    28 sub bindir_path($$) {
    29         my ($self, $path) = @_;
    30 
    31         my $valpath = "$self->{bindir}/$path$self->{exeext}";
    32 
    33         return $valpath if (-f $valpath);
    34         return $path;
    35 }
    36 
    3731sub scriptdir_path($$) {
    3832        my ($self, $path) = @_;
    … …  
    4640{
    4741        my $count = 0;
    48         my ($self, $env_vars) = @_;
    49         my $ldbsearch = $self->bindir_path("ldbsearch");
     42        my ($self, $env_vars, $STDIN_READER) = @_;
     43        my $ldbsearch = Samba::bindir_path($self, "ldbsearch");
    5044
    5145        my $uri = $env_vars->{LDAP_URI};
    … …  
    5751        # running slapd in the background means it stays in the same process group, so it can be
    5852        # killed by timelimit
    59         if ($self->{ldap} eq "fedora-ds") {
    60                 system("$ENV{FEDORA_DS_ROOT}/sbin/ns-slapd -D $env_vars->{FEDORA_DS_DIR} -d0 -i $env_vars->{FEDORA_DS_PIDFILE}> $env_vars->{LDAPDIR}/logs 2>&1 &");
    61         } elsif ($self->{ldap} eq "openldap") {
    62                 system("$ENV{OPENLDAP_SLAPD} -d0 -F $env_vars->{SLAPD_CONF_D} -h $uri > $env_vars->{LDAPDIR}/logs 2>&1 &");
    63         }
     53        my $pid = fork();
     54        if ($pid == 0) {
     55                open STDOUT, ">$env_vars->{LDAPDIR}/logs";
     56                open STDERR, '>&STDOUT';
     57                close($env_vars->{STDIN_PIPE});
     58                open STDIN, ">&", $STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
     59
     60                if ($self->{ldap} eq "fedora-ds") {
     61                        exec("$ENV{FEDORA_DS_ROOT}/sbin/ns-slapd", "-D", $env_vars->{FEDORA_DS_DIR}, "-d0", "-i", $env_vars->{FEDORA_DS_PIDFILE});
     62                } elsif ($self->{ldap} eq "openldap") {
     63                        exec($ENV{OPENLDAP_SLAPD}, "-dnone", "-F", $env_vars->{SLAPD_CONF_D}, "-h", $uri);
     64                }
     65                die("Unable to start slapd: $!");
     66        }
     67        $env_vars->{SLAPD_PID} = $pid;
     68        sleep(1);
    6469        while (system("$ldbsearch -H $uri -s base -b \"\" supportedLDAPVersion > /dev/null") != 0) {
    6570                $count++;
    … …  
    7681{
    7782        my ($self, $envvars) = @_;
    78         if ($self->{ldap} eq "fedora-ds") {
    79                 system("$envvars->{LDAPDIR}/slapd-$envvars->{LDAP_INSTANCE}/stop-slapd");
    80         } elsif ($self->{ldap} eq "openldap") {
    81                 unless (open(IN, "<$envvars->{OPENLDAP_PIDFILE}")) {
    82                         warn("unable to open slapd pid file: $envvars->{OPENLDAP_PIDFILE}");
    83                         return 0;
    84                 }
    85                 kill 9, <IN>;
    86                 close(IN);
    87         }
     83        kill 9, $envvars->{SLAPD_PID};
    8884        return 1;
    8985}
    … …  
    9187sub check_or_start($$$)
    9288{
    93         my ($self, $env_vars, $max_time) = @_;
    94         return 0 if ( -p $env_vars->{SAMBA_TEST_FIFO});
    95 
    96         unlink($env_vars->{SAMBA_TEST_FIFO});
    97         POSIX::mkfifo($env_vars->{SAMBA_TEST_FIFO}, 0700);
    98         unlink($env_vars->{SAMBA_TEST_LOG});
    99        
    100         my $pwd = `pwd`;
    101         print "STARTING SAMBA for $ENV{ENVNAME}\n";
     89        my ($self, $env_vars, $process_model) = @_;
     90        my $STDIN_READER;
     91
     92        my $env_ok = $self->check_env($env_vars);
     93        if ($env_ok) {
     94            return $env_vars->{SAMBA_PID};
     95        }
     96
     97        # use a pipe for stdin in the child processes. This allows
     98        # those processes to monitor the pipe for EOF to ensure they
     99        # exit when the test script exits
     100        pipe($STDIN_READER, $env_vars->{STDIN_PIPE});
     101
     102        # Start slapd before samba, but with the fifo on stdin
     103        if (defined($self->{ldap})) {
     104                unless($self->slapd_start($env_vars, $STDIN_READER)) {
     105                        warn("couldn't start slapd (main run)");
     106                        return undef;
     107                }
     108        }
     109
     110        print "STARTING SAMBA...";
    102111        my $pid = fork();
    103112        if ($pid == 0) {
    104                 open STDIN, $env_vars->{SAMBA_TEST_FIFO};
    105113                # we want out from samba to go to the log file, but also
    106114                # to the users terminal when running 'make test' on the command
    … …  
    111119                SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
    112120
    113                 my $valgrind = "";
    114                 if (defined($ENV{SAMBA_VALGRIND})) {
    115                     $valgrind = $ENV{SAMBA_VALGRIND};
    116                 }
    117 
    118121                $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
    119                 $ENV{WINBINDD_SOCKET_DIR} = $env_vars->{WINBINDD_SOCKET_DIR};
     122                $ENV{SELFTEST_WINBINDD_SOCKET_DIR} = $env_vars->{SELFTEST_WINBINDD_SOCKET_DIR};
     123                $ENV{NMBD_SOCKET_DIR} = $env_vars->{NMBD_SOCKET_DIR};
    120124
    121125                $ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
    122126                $ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
     127                $ENV{NSS_WRAPPER_HOSTS} = $env_vars->{NSS_WRAPPER_HOSTS};
     128                $ENV{NSS_WRAPPER_MODULE_SO_PATH} = $env_vars->{NSS_WRAPPER_MODULE_SO_PATH};
     129                $ENV{NSS_WRAPPER_MODULE_FN_PREFIX} = $env_vars->{NSS_WRAPPER_MODULE_FN_PREFIX};
     130
     131                if (defined($env_vars->{RESOLV_WRAPPER_CONF})) {
     132                        $ENV{RESOLV_WRAPPER_CONF} = $env_vars->{RESOLV_WRAPPER_CONF};
     133                } else {
     134                        $ENV{RESOLV_WRAPPER_HOSTS} = $env_vars->{RESOLV_WRAPPER_HOSTS};
     135                }
    123136
    124137                $ENV{UID_WRAPPER} = "1";
    125 
    126                 # Start slapd before samba, but with the fifo on stdin
    127                 if (defined($self->{ldap})) {
    128                         unless($self->slapd_start($env_vars)) {
    129                                 warn("couldn't start slapd (main run)");
    130                                 return undef;
    131                         }
    132                 }
    133 
    134                 my $optarg = "";
    135                 if (defined($max_time)) {
    136                         $optarg = "--maximum-runtime=$max_time ";
    137                 }
     138                $ENV{UID_WRAPPER_ROOT} = "1";
     139
     140                $ENV{MAKE_TEST_BINARY} = Samba::bindir_path($self, "samba");
     141                my @preargs = ();
     142                my @optargs = ();
    138143                if (defined($ENV{SAMBA_OPTIONS})) {
    139                         $optarg.= " $ENV{SAMBA_OPTIONS}";
    140                 }
    141                 my $samba = $self->bindir_path("samba");
    142 
    143                 # allow selection of the process model using
    144                 # the environment varibale SAMBA_PROCESS_MODEL
    145                 # that allows us to change the process model for
    146                 # individual machines in the build farm
    147                 my $model = "single";
    148                 if (defined($ENV{SAMBA_PROCESS_MODEL})) {
    149                         $model = $ENV{SAMBA_PROCESS_MODEL};
    150                 }
    151                 chomp($pwd);
    152                 my $cmdline = "$valgrind ${pwd}/$samba $optarg $env_vars->{CONFIGURATION} -M $model -i";
    153                 my $ret = system("$cmdline");
    154                 if ($ret == -1) {
    155                         print "Unable to start $cmdline: $ret: $!\n";
    156                         exit 1;
    157                 }
    158                 my $exit = ($ret >> 8);
    159                 unlink($env_vars->{SAMBA_TEST_FIFO});
    160                 if ($ret == 0) {
    161                         print "$samba exited with no error\n";
    162                         exit 0;
    163                 } elsif ( $ret & 127 ) {
    164                         print "$samba got signal ".($ret & 127)." and exits with $exit!\n";
    165                 } else {
    166                         print "$samba failed with status $exit!\n";
    167                 }
    168                 if ($exit == 0) {
    169                         $exit = -1;
    170                 }
    171                 exit $exit;
    172         }
    173         print "DONE\n";
    174 
    175         open(DATA, ">$env_vars->{SAMBA_TEST_FIFO}");
     144                        @optargs = split(/ /, $ENV{SAMBA_OPTIONS});
     145                }
     146                if(defined($ENV{SAMBA_VALGRIND})) {
     147                        @preargs = split(/ /,$ENV{SAMBA_VALGRIND});
     148                }
     149
     150                close($env_vars->{STDIN_PIPE});
     151                open STDIN, ">&", $STDIN_READER or die "can't dup STDIN_READER to STDIN: $!";
     152
     153                exec(@preargs, Samba::bindir_path($self, "samba"), "-M", $process_model, "-i", "--maximum-runtime=$self->{server_maxtime}", $env_vars->{CONFIGURATION}, @optargs) or die("Unable to start samba: $!");
     154        }
     155        $env_vars->{SAMBA_PID} = $pid;
     156        print "DONE ($pid)\n";
     157
     158        close($STDIN_READER);
     159
     160        if ($self->wait_for_start($env_vars) != 0) {
     161            warn("Samba $pid failed to start up");
     162            return undef;
     163        }
    176164
    177165        return $pid;
    … …  
    181169{
    182170        my ($self, $testenv_vars) = @_;
     171        my $ret = 0;
     172
     173        if (not $self->check_env($testenv_vars)) {
     174            warn("unable to confirm Samba $testenv_vars->{SAMBA_PID} is running");
     175            return -1;
     176        }
     177
    183178        # give time for nbt server to register its names
    184179        print "delaying for nbt name registration\n";
    … …  
    187182        # This will return quickly when things are up, but be slow if we
    188183        # need to wait for (eg) SSL init
    189         my $nmblookup = $self->bindir_path("nmblookup");
     184        my $nmblookup =  Samba::bindir_path($self, "nmblookup4");
    190185        system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{SERVER}");
    191186        system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{SERVER}");
    192187        system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
    193188        system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
    194         system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSALIAS}");
    195         system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSALIAS}");
     189        system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
     190        system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
    196191        system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{SERVER}");
    197192        system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{SERVER}");
    198193        system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
    199194        system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
    200         system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSALIAS}");
    201         system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSALIAS}");
    202 
     195        system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{NETBIOSNAME}");
     196        system("$nmblookup $testenv_vars->{CONFIGURATION} -U $testenv_vars->{SERVER_IP} $testenv_vars->{NETBIOSNAME}");
     197
     198        # Ensure we have the first RID Set before we start tests.  This makes the tests more reliable.
     199        if ($testenv_vars->{SERVER_ROLE} eq "domain controller" and not ($testenv_vars->{NETBIOSNAME} eq "RODC")) {
     200            # Add hosts file for name lookups
     201            $ENV{NSS_WRAPPER_HOSTS} = $testenv_vars->{NSS_WRAPPER_HOSTS};
     202                if (defined($testenv_vars->{RESOLV_WRAPPER_CONF})) {
     203                        $ENV{RESOLV_WRAPPER_CONF} = $testenv_vars->{RESOLV_WRAPPER_CONF};
     204                } else {
     205                        $ENV{RESOLV_WRAPPER_HOSTS} = $testenv_vars->{RESOLV_WRAPPER_HOSTS};
     206                }
     207
     208            print "waiting for working LDAP and a RID Set to be allocated\n";
     209            my $ldbsearch = Samba::bindir_path($self, "ldbsearch");
     210            my $count = 0;
     211            my $base_dn = "DC=".join(",DC=", split(/\./, $testenv_vars->{REALM}));
     212            my $rid_set_dn = "cn=RID Set,cn=$testenv_vars->{NETBIOSNAME},ou=domain controllers,$base_dn";
     213            sleep(1);
     214            while (system("$ldbsearch -H ldap://$testenv_vars->{SERVER} -U$testenv_vars->{USERNAME}%$testenv_vars->{PASSWORD} -s base -b \"$rid_set_dn\" rIDAllocationPool > /dev/null") != 0) {
     215                $count++;
     216                if ($count > 40) {
     217                    $ret = -1;
     218                    last;
     219                }
     220                sleep(1);
     221            }
     222        }
    203223        print $self->getlog_env($testenv_vars);
     224
     225        return $ret
    204226}
    205227
    … …  
    208230        my ($self, $file, $ldif) = @_;
    209231
    210         my $ldbadd = $self->bindir_path("ldbadd");
     232        my $ldbadd =  Samba::bindir_path($self, "ldbadd");
    211233        open(LDIF, "|$ldbadd -H $file >/dev/null");
    212234        print LDIF $ldif;
    … …  
    251273}
    252274
    253 sub mk_keyblobs($$)
    254 {
    255         my ($self, $tlsdir) = @_;
    256 
    257         #TLS and PKINIT crypto blobs
    258         my $dhfile = "$tlsdir/dhparms.pem";
    259         my $cafile = "$tlsdir/ca.pem";
    260         my $certfile = "$tlsdir/cert.pem";
    261         my $reqkdc = "$tlsdir/req-kdc.der";
    262         my $kdccertfile = "$tlsdir/kdc.pem";
    263         my $keyfile = "$tlsdir/key.pem";
    264         my $adminkeyfile = "$tlsdir/adminkey.pem";
    265         my $reqadmin = "$tlsdir/req-admin.der";
    266         my $admincertfile = "$tlsdir/admincert.pem";
    267         my $admincertupnfile = "$tlsdir/admincertupn.pem";
    268 
    269         mkdir($tlsdir, 0777);
    270 
    271         #This is specified here to avoid draining entropy on every run
    272         open(DHFILE, ">$dhfile");
    273         print DHFILE <<EOF;
    274 -----BEGIN DH PARAMETERS-----
    275 MGYCYQC/eWD2xkb7uELmqLi+ygPMKyVcpHUo2yCluwnbPutEueuxrG/Cys8j8wLO
    276 svCN/jYNyR2NszOmg7ZWcOC/4z/4pWDVPUZr8qrkhj5MRKJc52MncfaDglvEdJrv
    277 YX70obsCAQI=
    278 -----END DH PARAMETERS-----
    279 EOF
    280         close(DHFILE);
    281 
    282         #Likewise, we pregenerate the key material.  This allows the
    283         #other certificates to be pre-generated
    284         open(KEYFILE, ">$keyfile");
    285         print KEYFILE <<EOF;
    286 -----BEGIN RSA PRIVATE KEY-----
    287 MIICXQIBAAKBgQDKg6pAwCHUMA1DfHDmWhZfd+F0C+9Jxcqvpw9ii9En3E1uflpc
    288 ol3+S9/6I/uaTmJHZre+DF3dTzb/UOZo0Zem8N+IzzkgoGkFafjXuT3BL5UPY2/H
    289 6H+pPqVIRLOmrWImai359YyoKhFyo37Y6HPeU8QcZ+u2rS9geapIWfeuowIDAQAB
    290 AoGAAqDLzFRR/BF1kpsiUfL4WFvTarCe9duhwj7ORc6fs785qAXuwUYAJ0Uvzmy6
    291 HqoGv3t3RfmeHDmjcpPHsbOKnsOQn2MgmthidQlPBMWtQMff5zdoYNUFiPS0XQBq
    292 szNW4PRjaA9KkLQVTwnzdXGkBSkn/nGxkaVu7OR3vJOBoo0CQQDO4upypesnbe6p
    293 9/xqfZ2uim8IwV1fLlFClV7WlCaER8tsQF4lEi0XSzRdXGUD/dilpY88Nb+xok/X
    294 8Z8OvgAXAkEA+pcLsx1gN7kxnARxv54jdzQjC31uesJgMKQXjJ0h75aUZwTNHmZQ
    295 vPxi6u62YiObrN5oivkixwFNncT9MxTxVQJBAMaWUm2SjlLe10UX4Zdm1MEB6OsC
    296 kVoX37CGKO7YbtBzCfTzJGt5Mwc1DSLA2cYnGJqIfSFShptALlwedot0HikCQAJu
    297 jNKEKnbf+TdGY8Q0SKvTebOW2Aeg80YFkaTvsXCdyXrmdQcifw4WdO9KucJiDhSz
    298 Y9hVapz7ykEJtFtWjLECQQDIlfc63I5ZpXfg4/nN4IJXUW6AmPVOYIA5215itgki
    299 cSlMYli1H9MEXH0pQMGv5Qyd0OYIx2DDg96mZ+aFvqSG
    300 -----END RSA PRIVATE KEY-----
    301 EOF
    302         close(KEYFILE);
    303 
    304         open(ADMINKEYFILE, ">$adminkeyfile");
    305 
    306         print ADMINKEYFILE <<EOF;
    307 -----BEGIN RSA PRIVATE KEY-----
    308 MIICXQIBAAKBgQD0+OL7TQBj0RejbIH1+g5GeRaWaM9xF43uE5y7jUHEsi5owhZF
    309 5iIoHZeeL6cpDF5y1BZRs0JlA1VqMry1jjKlzFYVEMMFxB6esnXhl0Jpip1JkUMM
    310 XLOP1m/0dqayuHBWozj9f/cdyCJr0wJIX1Z8Pr+EjYRGPn/MF0xdl3JRlwIDAQAB
    311 AoGAP8mjCP628Ebc2eACQzOWjgEvwYCPK4qPmYOf1zJkArzG2t5XAGJ5WGrENRuB
    312 cm3XFh1lpmaADl982UdW3gul4gXUy6w4XjKK4vVfhyHj0kZ/LgaXUK9BAGhroJ2L
    313 osIOUsaC6jdx9EwSRctwdlF3wWJ8NK0g28AkvIk+FlolW4ECQQD7w5ouCDnf58CN
    314 u4nARx4xv5XJXekBvOomkCQAmuOsdOb6b9wn3mm2E3au9fueITjb3soMR31AF6O4
    315 eAY126rXAkEA+RgHzybzZEP8jCuznMqoN2fq/Vrs6+W3M8/G9mzGEMgLLpaf2Jiz
    316 I9tLZ0+OFk9tkRaoCHPfUOCrVWJZ7Y53QQJBAMhoA6rw0WDyUcyApD5yXg6rusf4
    317 ASpo/tqDkqUIpoL464Qe1tjFqtBM3gSXuhs9xsz+o0bzATirmJ+WqxrkKTECQHt2
    318 OLCpKqwAspU7N+w32kaUADoRLisCEdrhWklbwpQgwsIVsCaoEOpt0CLloJRYTANE
    319 yoZeAErTALjyZYZEPcECQQDlUi0N8DFxQ/lOwWyR3Hailft+mPqoPCa8QHlQZnlG
    320 +cfgNl57YHMTZFwgUVFRdJNpjH/WdZ5QxDcIVli0q+Ko
    321 -----END RSA PRIVATE KEY-----
    322 EOF
    323 
    324         #generated with
    325         # hxtool issue-certificate --self-signed --issue-ca \
    326         # --ca-private-key="FILE:$KEYFILE" \
    327         # --subject="CN=CA,DC=samba,DC=example,DC=com" \
    328         # --certificate="FILE:$CAFILE" --lifetime="25 years"
    329 
    330         open(CAFILE, ">$cafile");
    331         print CAFILE <<EOF;
    332 -----BEGIN CERTIFICATE-----
    333 MIICcTCCAdqgAwIBAgIUaBPmjnPVqyFqR5foICmLmikJTzgwCwYJKoZIhvcNAQEFMFIxEzAR
    334 BgoJkiaJk/IsZAEZDANjb20xFzAVBgoJkiaJk/IsZAEZDAdleGFtcGxlMRUwEwYKCZImiZPy
    335 LGQBGQwFc2FtYmExCzAJBgNVBAMMAkNBMCIYDzIwMDgwMzAxMTIyMzEyWhgPMjAzMzAyMjQx
    336 MjIzMTJaMFIxEzARBgoJkiaJk/IsZAEZDANjb20xFzAVBgoJkiaJk/IsZAEZDAdleGFtcGxl
    337 MRUwEwYKCZImiZPyLGQBGQwFc2FtYmExCzAJBgNVBAMMAkNBMIGfMA0GCSqGSIb3DQEBAQUA
    338 A4GNADCBiQKBgQDKg6pAwCHUMA1DfHDmWhZfd+F0C+9Jxcqvpw9ii9En3E1uflpcol3+S9/6
    339 I/uaTmJHZre+DF3dTzb/UOZo0Zem8N+IzzkgoGkFafjXuT3BL5UPY2/H6H+pPqVIRLOmrWIm
    340 ai359YyoKhFyo37Y6HPeU8QcZ+u2rS9geapIWfeuowIDAQABo0IwQDAOBgNVHQ8BAf8EBAMC
    341 AaYwHQYDVR0OBBYEFMLZufegDKLZs0VOyFXYK1L6M8oyMA8GA1UdEwEB/wQFMAMBAf8wDQYJ
    342 KoZIhvcNAQEFBQADgYEAAZJbCAAkaqgFJ0xgNovn8Ydd0KswQPjicwiODPgw9ZPoD2HiOUVO
    343 yYDRg/dhFF9y656OpcHk4N7qZ2sl3RlHkzDu+dseETW+CnKvQIoXNyeARRJSsSlwrwcoD4JR
    344 HTLk2sGigsWwrJ2N99sG/cqSJLJ1MFwLrs6koweBnYU0f/g=
    345 -----END CERTIFICATE-----
    346 EOF
    347 
    348         #generated with GNUTLS internally in Samba.
    349 
    350         open(CERTFILE, ">$certfile");
    351         print CERTFILE <<EOF;
    352 -----BEGIN CERTIFICATE-----
    353 MIICYTCCAcygAwIBAgIE5M7SRDALBgkqhkiG9w0BAQUwZTEdMBsGA1UEChMUU2Ft
    354 YmEgQWRtaW5pc3RyYXRpb24xNDAyBgNVBAsTK1NhbWJhIC0gdGVtcG9yYXJ5IGF1
    355 dG9nZW5lcmF0ZWQgY2VydGlmaWNhdGUxDjAMBgNVBAMTBVNhbWJhMB4XDTA2MDgw
    356 NDA0MzY1MloXDTA4MDcwNDA0MzY1MlowZTEdMBsGA1UEChMUU2FtYmEgQWRtaW5p
    357 c3RyYXRpb24xNDAyBgNVBAsTK1NhbWJhIC0gdGVtcG9yYXJ5IGF1dG9nZW5lcmF0
    358 ZWQgY2VydGlmaWNhdGUxDjAMBgNVBAMTBVNhbWJhMIGcMAsGCSqGSIb3DQEBAQOB
    359 jAAwgYgCgYDKg6pAwCHUMA1DfHDmWhZfd+F0C+9Jxcqvpw9ii9En3E1uflpcol3+
    360 S9/6I/uaTmJHZre+DF3dTzb/UOZo0Zem8N+IzzkgoGkFafjXuT3BL5UPY2/H6H+p
    361 PqVIRLOmrWImai359YyoKhFyo37Y6HPeU8QcZ+u2rS9geapIWfeuowIDAQABoyUw
    362 IzAMBgNVHRMBAf8EAjAAMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAsGCSqGSIb3DQEB
    363 BQOBgQAmkN6XxvDnoMkGcWLCTwzxGfNNSVcYr7TtL2aJh285Xw9zaxcm/SAZBFyG
    364 LYOChvh6hPU7joMdDwGfbiLrBnMag+BtGlmPLWwp/Kt1wNmrRhduyTQFhN3PP6fz
    365 nBr9vVny2FewB2gHmelaPS//tXdxivSXKz3NFqqXLDJjq7P8wA==
    366 -----END CERTIFICATE-----
    367 EOF
    368         close(CERTFILE);
    369 
    370         #KDC certificate
    371         # hxtool request-create \
    372         # --subject="CN=krbtgt,CN=users,DC=samba,DC=example,DC=com" \
    373         # --key="FILE:$KEYFILE" $KDCREQ
    374 
    375         # hxtool issue-certificate --ca-certificate=FILE:$CAFILE,$KEYFILE \
    376         # --type="pkinit-kdc" \
    377         # --pk-init-principal="krbtgt/SAMBA.EXAMPLE.COM@SAMBA.EXAMPLE.COM" \
    378         # --req="PKCS10:$KDCREQ" --certificate="FILE:$KDCCERTFILE" \
    379         # --lifetime="25 years"
    380 
    381         open(KDCCERTFILE, ">$kdccertfile");
    382         print KDCCERTFILE <<EOF;
    383 -----BEGIN CERTIFICATE-----
    384 MIIDDDCCAnWgAwIBAgIUI2Tzj+JnMzMcdeabcNo30rovzFAwCwYJKoZIhvcNAQEFMFIxEzAR
    385 BgoJkiaJk/IsZAEZDANjb20xFzAVBgoJkiaJk/IsZAEZDAdleGFtcGxlMRUwEwYKCZImiZPy
    386 LGQBGQwFc2FtYmExCzAJBgNVBAMMAkNBMCIYDzIwMDgwMzAxMTMxOTIzWhgPMjAzMzAyMjQx
    387 MzE5MjNaMGYxEzARBgoJkiaJk/IsZAEZDANjb20xFzAVBgoJkiaJk/IsZAEZDAdleGFtcGxl
    388 MRUwEwYKCZImiZPyLGQBGQwFc2FtYmExDjAMBgNVBAMMBXVzZXJzMQ8wDQYDVQQDDAZrcmJ0
    389 Z3QwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMqDqkDAIdQwDUN8cOZaFl934XQL70nF
    390 yq+nD2KL0SfcTW5+WlyiXf5L3/oj+5pOYkdmt74MXd1PNv9Q5mjRl6bw34jPOSCgaQVp+Ne5
    391 PcEvlQ9jb8fof6k+pUhEs6atYiZqLfn1jKgqEXKjftjoc95TxBxn67atL2B5qkhZ966jAgMB
    392 AAGjgcgwgcUwDgYDVR0PAQH/BAQDAgWgMBIGA1UdJQQLMAkGBysGAQUCAwUwVAYDVR0RBE0w
    393 S6BJBgYrBgEFAgKgPzA9oBMbEVNBTUJBLkVYQU1QTEUuQ09NoSYwJKADAgEBoR0wGxsGa3Ji
    394 dGd0GxFTQU1CQS5FWEFNUExFLkNPTTAfBgNVHSMEGDAWgBTC2bn3oAyi2bNFTshV2CtS+jPK
    395 MjAdBgNVHQ4EFgQUwtm596AMotmzRU7IVdgrUvozyjIwCQYDVR0TBAIwADANBgkqhkiG9w0B
    396 AQUFAAOBgQBmrVD5MCmZjfHp1nEnHqTIh8r7lSmVtDx4s9MMjxm9oNrzbKXynvdhwQYFVarc
    397 ge4yRRDXtSebErOl71zVJI9CVeQQpwcH+tA85oGA7oeFtO/S7ls581RUU6tGgyxV4veD+lJv
    398 KPH5LevUtgD+q9H4LU4Sq5N3iFwBaeryB0g2wg==
    399 -----END CERTIFICATE-----
    400 EOF
    401 
    402         # hxtool request-create \
    403         # --subject="CN=Administrator,CN=users,DC=samba,DC=example,DC=com" \
    404         # --key="FILE:$ADMINKEYFILE" $ADMINREQFILE
    405 
    406         # hxtool issue-certificate --ca-certificate=FILE:$CAFILE,$KEYFILE \
    407         # --type="pkinit-client" \
    408         # --pk-init-principal="administrator@SAMBA.EXAMPLE.COM" \
    409         # --req="PKCS10:$ADMINREQFILE" --certificate="FILE:$ADMINCERTFILE" \
    410         # --lifetime="25 years"
    411        
    412         open(ADMINCERTFILE, ">$admincertfile");
    413         print ADMINCERTFILE <<EOF;
    414 -----BEGIN CERTIFICATE-----
    415 MIIDHTCCAoagAwIBAgIUUggzW4lLRkMKe1DAR2NKatkMDYwwCwYJKoZIhvcNAQELMFIxEzAR
    416 BgoJkiaJk/IsZAEZDANjb20xFzAVBgoJkiaJk/IsZAEZDAdleGFtcGxlMRUwEwYKCZImiZPy
    417 LGQBGQwFc2FtYmExCzAJBgNVBAMMAkNBMCIYDzIwMDkwNzI3MDMzMjE1WhgPMjAzNDA3MjIw
    418 MzMyMTVaMG0xEzARBgoJkiaJk/IsZAEZDANjb20xFzAVBgoJkiaJk/IsZAEZDAdleGFtcGxl
    419 MRUwEwYKCZImiZPyLGQBGQwFc2FtYmExDjAMBgNVBAMMBXVzZXJzMRYwFAYDVQQDDA1BZG1p
    420 bmlzdHJhdG9yMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQD0+OL7TQBj0RejbIH1+g5G
    421 eRaWaM9xF43uE5y7jUHEsi5owhZF5iIoHZeeL6cpDF5y1BZRs0JlA1VqMry1jjKlzFYVEMMF
    422 xB6esnXhl0Jpip1JkUMMXLOP1m/0dqayuHBWozj9f/cdyCJr0wJIX1Z8Pr+EjYRGPn/MF0xd
    423 l3JRlwIDAQABo4HSMIHPMA4GA1UdDwEB/wQEAwIFoDAoBgNVHSUEITAfBgcrBgEFAgMEBggr
    424 BgEFBQcDAgYKKwYBBAGCNxQCAjBIBgNVHREEQTA/oD0GBisGAQUCAqAzMDGgExsRU0FNQkEu
    425 RVhBTVBMRS5DT02hGjAYoAMCAQGhETAPGw1BZG1pbmlzdHJhdG9yMB8GA1UdIwQYMBaAFMLZ
    426 ufegDKLZs0VOyFXYK1L6M8oyMB0GA1UdDgQWBBQg81bLyfCA88C2B/BDjXlGuaFaxjAJBgNV
    427 HRMEAjAAMA0GCSqGSIb3DQEBCwUAA4GBAEf/OSHUDJaGdtWGNuJeqcVYVMwrfBAc0OSwVhz1
    428 7/xqKHWo8wIMPkYRtaRHKLNDsF8GkhQPCpVsa6mX/Nt7YQnNvwd+1SBP5E8GvwWw9ZzLJvma
    429 nk2n89emuayLpVtp00PymrDLRBcNaRjFReQU8f0o509kiVPHduAp3jOiy13l
    430 -----END CERTIFICATE-----
    431 EOF
    432         close(ADMINCERTFILE);
    433 
    434         # hxtool issue-certificate --ca-certificate=FILE:$CAFILE,$KEYFILE \
    435         # --type="pkinit-client" \
    436         # --ms-upn="administrator@samba.example.com" \
    437         # --req="PKCS10:$ADMINREQFILE" --certificate="FILE:$ADMINCERTUPNFILE" \
    438         # --lifetime="25 years"
    439        
    440         open(ADMINCERTUPNFILE, ">$admincertupnfile");
    441         print ADMINCERTUPNFILE <<EOF;
    442 -----BEGIN CERTIFICATE-----
    443 MIIDDzCCAnigAwIBAgIUUp3CJMuNaEaAdPKp3QdNIwG7a4wwCwYJKoZIhvcNAQELMFIxEzAR
    444 BgoJkiaJk/IsZAEZDANjb20xFzAVBgoJkiaJk/IsZAEZDAdleGFtcGxlMRUwEwYKCZImiZPy
    445 LGQBGQwFc2FtYmExCzAJBgNVBAMMAkNBMCIYDzIwMDkwNzI3MDMzMzA1WhgPMjAzNDA3MjIw
    446 MzMzMDVaMG0xEzARBgoJkiaJk/IsZAEZDANjb20xFzAVBgoJkiaJk/IsZAEZDAdleGFtcGxl
    447 MRUwEwYKCZImiZPyLGQBGQwFc2FtYmExDjAMBgNVBAMMBXVzZXJzMRYwFAYDVQQDDA1BZG1p
    448 bmlzdHJhdG9yMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQD0+OL7TQBj0RejbIH1+g5G
    449 eRaWaM9xF43uE5y7jUHEsi5owhZF5iIoHZeeL6cpDF5y1BZRs0JlA1VqMry1jjKlzFYVEMMF
    450 xB6esnXhl0Jpip1JkUMMXLOP1m/0dqayuHBWozj9f/cdyCJr0wJIX1Z8Pr+EjYRGPn/MF0xd
    451 l3JRlwIDAQABo4HEMIHBMA4GA1UdDwEB/wQEAwIFoDAoBgNVHSUEITAfBgcrBgEFAgMEBggr
    452 BgEFBQcDAgYKKwYBBAGCNxQCAjA6BgNVHREEMzAxoC8GCisGAQQBgjcUAgOgIQwfYWRtaW5p
    453 c3RyYXRvckBzYW1iYS5leGFtcGxlLmNvbTAfBgNVHSMEGDAWgBTC2bn3oAyi2bNFTshV2CtS
    454 +jPKMjAdBgNVHQ4EFgQUIPNWy8nwgPPAtgfwQ415RrmhWsYwCQYDVR0TBAIwADANBgkqhkiG
    455 9w0BAQsFAAOBgQBk42+egeUB3Ji2PC55fbt3FNKxvmm2xUUFkV9POK/YR9rajKOwk5jtYSeS
    456 Zd7J9s//rNFNa7waklFkDaY56+QWTFtdvxfE+KoHaqt6X8u6pqi7p3M4wDKQox+9Dx8yWFyq
    457 Wfz/8alZ5aMezCQzXJyIaJsCLeKABosSwHcpAFmxlQ==
    458 -----END CERTIFICATE-----
    459 EOF
    460 }
    461 
    462 sub mk_krb5_conf($$)
    463 {
    464         my ($self, $ctx) = @_;
    465 
    466         unless (open(KRB5CONF, ">$ctx->{krb5_conf}")) {
    467                 warn("can't open $ctx->{krb5_conf}$?");
    468                 return undef;
    469         }
    470         print KRB5CONF "
    471 #Generated krb5.conf for $ctx->{realm}
    472 
    473 [libdefaults]
    474  default_realm = $ctx->{realm}
    475  dns_lookup_realm = false
    476  dns_lookup_kdc = false
    477  ticket_lifetime = 24h
    478  forwardable = yes
    479  allow_weak_crypto = yes
    480 
    481 [realms]
    482  $ctx->{realm} = {
    483   kdc = $ctx->{kdc_ipv4}:88
    484   admin_server = $ctx->{kdc_ipv4}:88
    485   default_domain = $ctx->{dnsname}
    486  }
    487  $ctx->{dnsname} = {
    488   kdc = $ctx->{kdc_ipv4}:88
    489   admin_server = $ctx->{kdc_ipv4}:88
    490   default_domain = $ctx->{dnsname}
    491  }
    492  $ctx->{domain} = {
    493   kdc = $ctx->{kdc_ipv4}:88
    494   admin_server = $ctx->{kdc_ipv4}:88
    495   default_domain = $ctx->{dnsname}
    496  }
    497 
    498 [appdefaults]
    499         pkinit_anchors = FILE:$ctx->{tlsdir}/ca.pem
    500 
    501 [kdc]
    502         enable-pkinit = true
    503         pkinit_identity = FILE:$ctx->{tlsdir}/kdc.pem,$ctx->{tlsdir}/key.pem
    504         pkinit_anchors = FILE:$ctx->{tlsdir}/ca.pem
    505 
    506 [domain_realm]
    507  .$ctx->{dnsname} = $ctx->{realm}
    508 ";
    509         close(KRB5CONF);
    510 }
    511 
    512 sub provision_raw_prepare($$$$$$$$$$)
    513 {
    514         my ($self, $prefix, $server_role, $netbiosname, $netbiosalias,
     275sub setup_namespaces($$:$$)
     276{
     277        my ($self, $localenv, $upn_array, $spn_array) = @_;
     278
     279        @{$upn_array} = [] unless defined($upn_array);
     280        my $upn_args = "";
     281        foreach my $upn (@{$upn_array}) {
     282                $upn_args .= " --add-upn-suffix=$upn";
     283        }
     284
     285        @{$spn_array} = [] unless defined($spn_array);
     286        my $spn_args = "";
     287        foreach my $spn (@{$spn_array}) {
     288                $spn_args .= " --add-spn-suffix=$spn";
     289        }
     290
     291        my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     292
     293        my $cmd_env = "";
     294        $cmd_env .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$localenv->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     295        if (defined($localenv->{RESOLV_WRAPPER_CONF})) {
     296                $cmd_env .= "RESOLV_WRAPPER_CONF=\"$localenv->{RESOLV_WRAPPER_CONF}\" ";
     297        } else {
     298                $cmd_env .= "RESOLV_WRAPPER_HOSTS=\"$localenv->{RESOLV_WRAPPER_HOSTS}\" ";
     299        }
     300        $cmd_env .= " KRB5_CONFIG=\"$localenv->{KRB5_CONFIG}\"";
     301
     302        my $cmd_config = " $localenv->{CONFIGURATION}";
     303
     304        my $namespaces = $cmd_env;
     305        $namespaces .= " $samba_tool domain trust namespaces $upn_args $spn_args";
     306        $namespaces .= $cmd_config;
     307        unless (system($namespaces) == 0) {
     308                warn("Failed to add namespaces \n$namespaces");
     309                return;
     310        }
     311
     312        return;
     313}
     314
     315sub setup_trust($$$$$)
     316{
     317        my ($self, $localenv, $remoteenv, $type, $extra_args) = @_;
     318
     319        $localenv->{TRUST_SERVER} = $remoteenv->{SERVER};
     320        $localenv->{TRUST_SERVER_IP} = $remoteenv->{SERVER_IP};
     321        $localenv->{TRUST_SERVER_IPV6} = $remoteenv->{SERVER_IPV6};
     322        $localenv->{TRUST_NETBIOSNAME} = $remoteenv->{NETBIOSNAME};
     323        $localenv->{TRUST_USERNAME} = $remoteenv->{USERNAME};
     324        $localenv->{TRUST_PASSWORD} = $remoteenv->{PASSWORD};
     325        $localenv->{TRUST_DOMAIN} = $remoteenv->{DOMAIN};
     326        $localenv->{TRUST_REALM} = $remoteenv->{REALM};
     327
     328        my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     329        # setup the trust
     330        my $cmd_env = "";
     331        $cmd_env .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$localenv->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     332        if (defined($localenv->{RESOLV_WRAPPER_CONF})) {
     333                $cmd_env .= "RESOLV_WRAPPER_CONF=\"$localenv->{RESOLV_WRAPPER_CONF}\" ";
     334        } else {
     335                $cmd_env .= "RESOLV_WRAPPER_HOSTS=\"$localenv->{RESOLV_WRAPPER_HOSTS}\" ";
     336        }
     337        $cmd_env .= " KRB5_CONFIG=\"$localenv->{KRB5_CONFIG}\"";
     338
     339        my $cmd_config = " $localenv->{CONFIGURATION}";
     340        my $cmd_creds = $cmd_config;
     341        $cmd_creds .= " -U$localenv->{TRUST_DOMAIN}\\\\$localenv->{TRUST_USERNAME}\%$localenv->{TRUST_PASSWORD}";
     342
     343        my $create = $cmd_env;
     344        $create .= " $samba_tool domain trust create --type=${type} $localenv->{TRUST_REALM}";
     345        $create .= " $extra_args";
     346        $create .= $cmd_creds;
     347        unless (system($create) == 0) {
     348                warn("Failed to create trust \n$create");
     349                return undef;
     350        }
     351
     352        return $localenv
     353}
     354
     355sub provision_raw_prepare($$$$$$$$$$$)
     356{
     357        my ($self, $prefix, $server_role, $hostname,
    515358            $domain, $realm, $functional_level,
    516             $swiface, $password, $kdc_ipv4) = @_;
     359            $password, $kdc_ipv4, $kdc_ipv6) = @_;
    517360        my $ctx;
     361        my $netbiosname = uc($hostname);
    518362
    519363        unless(-d $prefix or mkdir($prefix, 0777)) {
    … …  
    530374        }
    531375
     376       
     377        my $swiface = Samba::get_interface($hostname);
     378
    532379        $ctx->{prefix} = $prefix;
    533380        $ctx->{prefix_abs} = $prefix_abs;
    534        
    535         $ctx->{dns_host_file} = "$ENV{SELFTEST_PREFIX}/dns_host_file";
    536381
    537382        $ctx->{server_role} = $server_role;
     383        $ctx->{hostname} = $hostname;
    538384        $ctx->{netbiosname} = $netbiosname;
    539         $ctx->{netbiosalias} = $netbiosalias;
    540385        $ctx->{swiface} = $swiface;
    541386        $ctx->{password} = $password;
    542387        $ctx->{kdc_ipv4} = $kdc_ipv4;
    543 
     388        $ctx->{kdc_ipv6} = $kdc_ipv6;
     389        if ($functional_level eq "2000") {
     390                $ctx->{supported_enctypes} = "arcfour-hmac-md5 des-cbc-md5 des-cbc-crc"
     391        }
     392
     393#
     394# Set smbd log level here.
     395#
    544396        $ctx->{server_loglevel} =$ENV{SERVER_LOG_LEVEL} || 1;
    545397        $ctx->{username} = "Administrator";
    … …  
    547399        $ctx->{realm} = uc($realm);
    548400        $ctx->{dnsname} = lc($realm);
    549         $ctx->{sid_generator} = "internal";
    550401
    551402        $ctx->{functional_level} = $functional_level;
    … …  
    555406        $ctx->{unix_name} = $unix_name;
    556407        $ctx->{unix_uid} = $>;
     408        my @mygid = split(" ", $();
     409        $ctx->{unix_gid} = $mygid[0];
    557410        $ctx->{unix_gids_str} = $);
    558411        @{$ctx->{unix_gids}} = split(" ", $ctx->{unix_gids_str});
    … …  
    565418        $ctx->{ncalrpcdir} = "$prefix_abs/ncalrpc";
    566419        $ctx->{lockdir} = "$prefix_abs/lockdir";
     420        $ctx->{logdir} = "$prefix_abs/logs";
     421        $ctx->{statedir} = "$prefix_abs/statedir";
     422        $ctx->{cachedir} = "$prefix_abs/cachedir";
    567423        $ctx->{winbindd_socket_dir} = "$prefix_abs/winbindd_socket";
    568424        $ctx->{winbindd_privileged_socket_dir} = "$prefix_abs/winbindd_privileged_socket";
    … …  
    570426        $ctx->{nsswrap_passwd} = "$ctx->{etcdir}/passwd";
    571427        $ctx->{nsswrap_group} = "$ctx->{etcdir}/group";
     428        $ctx->{nsswrap_hosts} = "$ENV{SELFTEST_PREFIX}/hosts";
     429        if ($ENV{SAMBA_DNS_FAKING}) {
     430                $ctx->{dns_host_file} = "$ENV{SELFTEST_PREFIX}/dns_host_file";
     431                $ctx->{samba_dnsupdate} = "$ENV{SRCDIR_ABS}/source4/scripting/bin/samba_dnsupdate -s $ctx->{smb_conf} --all-interfaces --use-file=$ctx->{dns_host_file}";
     432        } else {
     433                $ctx->{resolv_conf} = "$ctx->{etcdir}/resolv.conf";
     434                $ctx->{samba_dnsupdate} = "$ENV{SRCDIR_ABS}/source4/scripting/bin/samba_dnsupdate -s $ctx->{smb_conf}";
     435        }
    572436
    573437        $ctx->{tlsdir} = "$ctx->{privatedir}/tls";
    574438
    575439        $ctx->{ipv4} = "127.0.0.$swiface";
    576         $ctx->{interfaces} = "$ctx->{ipv4}/8";
     440        $ctx->{ipv6} = sprintf("fd00:0000:0000:0000:0000:0000:5357:5f%02x", $swiface);
     441        $ctx->{interfaces} = "$ctx->{ipv4}/8 $ctx->{ipv6}/64";
    577442
    578443        push(@{$ctx->{directories}}, $ctx->{privatedir});
    579444        push(@{$ctx->{directories}}, $ctx->{etcdir});
    580445        push(@{$ctx->{directories}}, $ctx->{piddir});
    581         push(@{$ctx->{directories}}, $ctx->{ncalrpcdir});
    582446        push(@{$ctx->{directories}}, $ctx->{lockdir});
     447        push(@{$ctx->{directories}}, $ctx->{logdir});
     448        push(@{$ctx->{directories}}, $ctx->{statedir});
     449        push(@{$ctx->{directories}}, $ctx->{cachedir});
    583450
    584451        $ctx->{smb_conf_extra_options} = "";
    585452
    586453        my @provision_options = ();
     454        push (@provision_options, "KRB5_CONFIG=\"$ctx->{krb5_config}\"");
    587455        push (@provision_options, "NSS_WRAPPER_PASSWD=\"$ctx->{nsswrap_passwd}\"");
    588456        push (@provision_options, "NSS_WRAPPER_GROUP=\"$ctx->{nsswrap_group}\"");
     457        push (@provision_options, "NSS_WRAPPER_HOSTS=\"$ctx->{nsswrap_hosts}\"");
     458        if (defined($ctx->{resolv_conf})) {
     459                push (@provision_options, "RESOLV_WRAPPER_CONF=\"$ctx->{resolv_conf}\"");
     460        } else {
     461                push (@provision_options, "RESOLV_WRAPPER_HOSTS=\"$ctx->{dns_host_file}\"");
     462        }
    589463        if (defined($ENV{GDB_PROVISION})) {
    590464                push (@provision_options, "gdb --args");
    … …  
    604478                push (@provision_options, $ENV{PYTHON});
    605479        }
    606         push (@provision_options, "$self->{srcdir}/source4/setup/provision");
     480        push (@provision_options, Samba::bindir_path($self, "samba-tool"));
     481        push (@provision_options, "domain");
     482        push (@provision_options, "provision");
    607483        push (@provision_options, "--configfile=$ctx->{smb_conf}");
    608         push (@provision_options, "--host-name=$ctx->{netbiosname}");
     484        push (@provision_options, "--host-name=$ctx->{hostname}");
    609485        push (@provision_options, "--host-ip=$ctx->{ipv4}");
    610486        push (@provision_options, "--quiet");
    … …  
    632508        mkdir($_, 0777) foreach (@{$ctx->{directories}});
    633509
     510        ##
     511        ## lockdir and piddir must be 0755
     512        ##
     513        chmod 0755, $ctx->{lockdir};
     514        chmod 0755, $ctx->{piddir};
     515
    634516        unless (open(CONFFILE, ">$ctx->{smb_conf}")) {
    635517                warn("can't open $ctx->{smb_conf}$?");
    636518                return undef;
    637519        }
     520
     521        Samba::prepare_keyblobs($ctx);
     522        my $crlfile = "$ctx->{tlsdir}/crl.pem";
     523        $crlfile = "" unless -e ${crlfile};
     524
    638525        print CONFFILE "
    639526[global]
    640527        netbios name = $ctx->{netbiosname}
    641         netbios aliases = $ctx->{netbiosalias}
    642         posix:eadb = $ctx->{lockdir}/eadb.tdb
     528        posix:eadb = $ctx->{statedir}/eadb.tdb
    643529        workgroup = $ctx->{domain}
    644530        realm = $ctx->{realm}
    … …  
    647533        ncalrpc dir = $ctx->{ncalrpcdir}
    648534        lock dir = $ctx->{lockdir}
     535        state directory = $ctx->{statedir}
     536        cache directory = $ctx->{cachedir}
    649537        winbindd socket directory = $ctx->{winbindd_socket_dir}
    650538        winbindd privileged socket directory = $ctx->{winbindd_privileged_socket_dir}
    651539        ntp signd socket directory = $ctx->{ntp_signd_socket_dir}
    652540        winbind separator = /
    653         name resolve order = file bcast
    654541        interfaces = $ctx->{interfaces}
    655542        tls dh params file = $ctx->{tlsdir}/dhparms.pem
    656         panic action = $RealBin/gdb_backtrace \%PID% \%PROG%
     543        tls crlfile = ${crlfile}
     544        tls verify peer = no_check
     545        panic action = $RealBin/gdb_backtrace \%d
    657546        wins support = yes
    658547        server role = $ctx->{server_role}
    659         server services = +echo
     548        server services = +echo +smb -s3fs
     549        dcerpc endpoint servers = +winreg +srvsvc
    660550        notify:inotify = false
    661551        ldb:nosync = true
     552        ldap server require strong auth = yes
    662553#We don't want to pass our self-tests if the PAC code is wrong
    663554        gensec:require_pac = true
     555        log file = $ctx->{logdir}/log.\%m
    664556        log level = $ctx->{server_loglevel}
    665557        lanman auth = Yes
    666558        rndc command = true
    667         dns update command = $ENV{SRCDIR_ABS}/source4/scripting/bin/samba_dnsupdate --all-interfaces --use-file=$ctx->{dns_host_file}
    668         spn update command = $ENV{SRCDIR_ABS}/source4/scripting/bin/samba_spnupdate
    669         resolv:host file = $ctx->{dns_host_file}
     559        dns update command = $ctx->{samba_dnsupdate}
     560        spn update command = $ENV{SRCDIR_ABS}/source4/scripting/bin/samba_spnupdate -s $ctx->{smb_conf}
    670561        dreplsrv:periodic_startup_interval = 0
     562        dsdb:schema update allowed = yes
     563
     564        vfs objects = dfs_samba4 acl_xattr fake_acls xattr_tdb streams_depot
     565
     566        # remove this again, when our smb2 client library
     567        # supports signin on compound related requests
     568        server signing = on
     569
     570        idmap_ldb:use rfc2307=yes
     571        winbind enum users = yes
     572        winbind enum groups = yes
    671573";
    672 
    673         if (defined($ctx->{sid_generator}) && $ctx->{sid_generator} ne "internal") {
    674                 print CONFFILE "
    675         sid generator = $ctx->{sid_generator}";
    676         }
    677574
    678575        print CONFFILE "
    … …  
    684581        close(CONFFILE);
    685582
    686         $self->mk_keyblobs($ctx->{tlsdir});
    687 
    688         $self->mk_krb5_conf($ctx);
     583        #Default the KDC IP to the server's IP
     584        if (not defined($ctx->{kdc_ipv4})) {
     585                $ctx->{kdc_ipv4} = $ctx->{ipv4};
     586        }
     587        if (not defined($ctx->{kdc_ipv6})) {
     588                $ctx->{kdc_ipv6} = $ctx->{ipv6};
     589        }
     590
     591        Samba::mk_krb5_conf($ctx);
    689592
    690593        open(PWD, ">$ctx->{nsswrap_passwd}");
    691         print PWD "
    692 root:x:0:0:root gecos:$ctx->{prefix_abs}:/bin/false
    693 $ctx->{unix_name}:x:$ctx->{unix_uid}:@{$ctx->{unix_gids}}[0]:$ctx->{unix_name} gecos:$ctx->{prefix_abs}:/bin/false
    694 nobody:x:65534:65533:nobody gecos:$ctx->{prefix_abs}:/bin/false
     594        if ($ctx->{unix_uid} != 0) {
     595                print PWD "root:x:0:0:root gecos:$ctx->{prefix_abs}:/bin/false\n";
     596        }
     597        print PWD "$ctx->{unix_name}:x:$ctx->{unix_uid}:65531:$ctx->{unix_name} gecos:$ctx->{prefix_abs}:/bin/false\n";
     598        print PWD "nobody:x:65534:65533:nobody gecos:$ctx->{prefix_abs}:/bin/false
     599pdbtest:x:65533:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
     600pdbtest2:x:65532:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
     601pdbtest3:x:65531:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
     602pdbtest4:x:65530:65533:pdbtest gecos:$ctx->{prefix_abs}:/bin/false
    695603";
    696604        close(PWD);
     605        my $uid_rfc2307test = 65533;
    697606
    698607        open(GRP, ">$ctx->{nsswrap_group}");
    699         print GRP "
    700 root:x:0:
    701 wheel:x:10:
    702 users:x:100:
     608        if ($ctx->{unix_gid} != 0) {
     609                print GRP "root:x:0:\n";
     610        }
     611        print GRP "$ctx->{unix_name}:x:$ctx->{unix_gid}:\n";
     612        print GRP "wheel:x:10:
     613users:x:65531:
    703614nobody:x:65533:
    704615nogroup:x:65534:nobody
    705616";
    706617        close(GRP);
     618        my $gid_rfc2307test = 65532;
     619
     620        my $hostname = lc($ctx->{hostname});
     621        open(HOSTS, ">>$ctx->{nsswrap_hosts}");
     622        if ($hostname eq "localdc") {
     623                print HOSTS "$ctx->{ipv4} ${hostname}.$ctx->{dnsname} $ctx->{dnsname} ${hostname}\n";
     624                print HOSTS "$ctx->{ipv6} ${hostname}.$ctx->{dnsname} $ctx->{dnsname} ${hostname}\n";
     625        } else {
     626                print HOSTS "$ctx->{ipv4} ${hostname}.$ctx->{dnsname} ${hostname}\n";
     627                print HOSTS "$ctx->{ipv6} ${hostname}.$ctx->{dnsname} ${hostname}\n";
     628        }
     629        close(HOSTS);
     630
     631        if (defined($ctx->{resolv_conf})) {
     632                open(RESOLV_CONF, ">$ctx->{resolv_conf}");
     633                print RESOLV_CONF "nameserver $ctx->{kdc_ipv4}\n";
     634                print RESOLV_CONF "nameserver $ctx->{kdc_ipv6}\n";
     635                close(RESOLV_CONF);
     636        }
    707637
    708638        my $configuration = "--configfile=$ctx->{smb_conf}";
    709639
    710640#Ensure the config file is valid before we start
    711         my $testparm = $self->scriptdir_path("bin/testparm");
     641        my $testparm = Samba::bindir_path($self, "samba-tool") . " testparm";
    712642        if (system("$testparm $configuration -v --suppress-prompt >/dev/null 2>&1") != 0) {
    713643                system("$testparm -v --suppress-prompt $configuration >&2");
    … …  
    723653                KRB5_CONFIG => $ctx->{krb5_conf},
    724654                PIDDIR => $ctx->{piddir},
    725                 SERVER => $ctx->{netbiosname},
     655                SERVER => $ctx->{hostname},
    726656                SERVER_IP => $ctx->{ipv4},
     657                SERVER_IPV6 => $ctx->{ipv6},
    727658                NETBIOSNAME => $ctx->{netbiosname},
    728                 NETBIOSALIAS => $ctx->{netbiosalias},
    729659                DOMAIN => $ctx->{domain},
    730660                USERNAME => $ctx->{username},
    … …  
    733663                LDAPDIR => $ctx->{ldapdir},
    734664                LDAP_INSTANCE => $ctx->{ldap_instance},
    735                 WINBINDD_SOCKET_DIR => $ctx->{winbindd_socket_dir},
     665                SELFTEST_WINBINDD_SOCKET_DIR => $ctx->{winbindd_socket_dir},
    736666                NCALRPCDIR => $ctx->{ncalrpcdir},
    737667                LOCKDIR => $ctx->{lockdir},
     668                STATEDIR => $ctx->{statedir},
     669                CACHEDIR => $ctx->{cachedir},
     670                PRIVATEDIR => $ctx->{privatedir},
    738671                SERVERCONFFILE => $ctx->{smb_conf},
    739672                CONFIGURATION => $configuration,
    … …  
    741674                NSS_WRAPPER_PASSWD => $ctx->{nsswrap_passwd},
    742675                NSS_WRAPPER_GROUP => $ctx->{nsswrap_group},
     676                NSS_WRAPPER_HOSTS => $ctx->{nsswrap_hosts},
    743677                SAMBA_TEST_FIFO => "$ctx->{prefix}/samba_test.fifo",
    744678                SAMBA_TEST_LOG => "$ctx->{prefix}/samba_test.log",
    745679                SAMBA_TEST_LOG_POS => 0,
     680                NSS_WRAPPER_MODULE_SO_PATH => Samba::nss_wrapper_winbind_so_path($self),
     681                NSS_WRAPPER_MODULE_FN_PREFIX => "winbind",
     682                LOCAL_PATH => $ctx->{share},
     683                UID_RFC2307TEST => $uid_rfc2307test,
     684                GID_RFC2307TEST => $gid_rfc2307test,
     685                SERVER_ROLE => $ctx->{server_role}
    746686        };
     687
     688        if (defined($ctx->{resolv_conf})) {
     689                $ret->{RESOLV_WRAPPER_CONF} = $ctx->{resolv_conf};
     690        } else {
     691                $ret->{RESOLV_WRAPPER_HOSTS} = $ctx->{dns_host_file};
     692        }
    747693
    748694        return $ret;
    … …  
    762708        }
    763709
     710        my $testallowed_account = "testallowed";
     711        my $samba_tool_cmd = "";
     712        $samba_tool_cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     713        $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
     714            . " user add --configfile=$ctx->{smb_conf} $testallowed_account $ctx->{password}";
     715        unless (system($samba_tool_cmd) == 0) {
     716                warn("Unable to add testallowed user: \n$samba_tool_cmd\n");
     717                return undef;
     718        }
     719
     720        my $ldbmodify = "";
     721        $ldbmodify .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     722        $ldbmodify .= Samba::bindir_path($self, "ldbmodify");
     723        my $base_dn = "DC=".join(",DC=", split(/\./, $ctx->{realm}));
     724
     725        if ($ctx->{server_role} ne "domain controller") {
     726                $base_dn = "DC=$ctx->{netbiosname}";
     727        }
     728
     729        my $user_dn = "cn=$testallowed_account,cn=users,$base_dn";
     730        $testallowed_account = "testallowed account";
     731        open(LDIF, "|$ldbmodify -H $ctx->{privatedir}/sam.ldb");
     732        print LDIF "dn: $user_dn
     733changetype: modify
     734replace: samAccountName
     735samAccountName: $testallowed_account
     736-
     737";
     738        close(LDIF);
     739
     740        open(LDIF, "|$ldbmodify -H $ctx->{privatedir}/sam.ldb");
     741        print LDIF "dn: $user_dn
     742changetype: modify
     743replace: userPrincipalName
     744userPrincipalName: testallowed upn\@$ctx->{realm}
     745replace: servicePrincipalName
     746servicePrincipalName: host/testallowed
     747-           
     748";
     749        close(LDIF);
     750
     751        $samba_tool_cmd = "";
     752        $samba_tool_cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     753        $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
     754            . " user add --configfile=$ctx->{smb_conf} testdenied $ctx->{password}";
     755        unless (system($samba_tool_cmd) == 0) {
     756                warn("Unable to add testdenied user: \n$samba_tool_cmd\n");
     757                return undef;
     758        }
     759
     760        my $user_dn = "cn=testdenied,cn=users,$base_dn";
     761        open(LDIF, "|$ldbmodify -H $ctx->{privatedir}/sam.ldb");
     762        print LDIF "dn: $user_dn
     763changetype: modify
     764replace: userPrincipalName
     765userPrincipalName: testdenied_upn\@$ctx->{realm}.upn
     766-           
     767";
     768        close(LDIF);
     769
     770        $samba_tool_cmd = "";
     771        $samba_tool_cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     772        $samba_tool_cmd .= Samba::bindir_path($self, "samba-tool")
     773            . " group addmembers --configfile=$ctx->{smb_conf} 'Allowed RODC Password Replication Group' '$testallowed_account'";
     774        unless (system($samba_tool_cmd) == 0) {
     775                warn("Unable to add '$testallowed_account' user to 'Allowed RODC Password Replication Group': \n$samba_tool_cmd\n");
     776                return undef;
     777        }
     778
    764779        return $ret;
    765780}
    766781
    767 sub provision($$$$$$$$$)
    768 {
    769         my ($self, $prefix, $server_role, $netbiosname, $netbiosalias,
     782sub provision($$$$$$$$$$)
     783{
     784        my ($self, $prefix, $server_role, $hostname,
    770785            $domain, $realm, $functional_level,
    771             $swiface, $password, $kdc_ipv4, $extra_smbconf_options) = @_;
     786            $password, $kdc_ipv4, $kdc_ipv6, $extra_smbconf_options, $extra_smbconf_shares,
     787            $extra_provision_options) = @_;
    772788
    773789        my $ctx = $self->provision_raw_prepare($prefix, $server_role,
    774                                                $netbiosname, $netbiosalias,
     790                                               $hostname,
    775791                                               $domain, $realm, $functional_level,
    776                                                $swiface, $password, $kdc_ipv4);
    777 
    778         $ctx->{tmpdir} = "$ctx->{prefix_abs}/tmp";
    779         push(@{$ctx->{directories}}, "$ctx->{tmpdir}");
    780         push(@{$ctx->{directories}}, "$ctx->{tmpdir}/test1");
    781         push(@{$ctx->{directories}}, "$ctx->{tmpdir}/test2");
     792                                               $password, $kdc_ipv4, $kdc_ipv6);
     793
     794        if (defined($extra_provision_options)) {
     795                push (@{$ctx->{provision_options}}, @{$extra_provision_options});
     796        } else {
     797                push (@{$ctx->{provision_options}}, "--use-ntvfs");
     798        }
     799
     800        $ctx->{share} = "$ctx->{prefix_abs}/share";
     801        push(@{$ctx->{directories}}, "$ctx->{share}");
     802        push(@{$ctx->{directories}}, "$ctx->{share}/test1");
     803        push(@{$ctx->{directories}}, "$ctx->{share}/test2");
     804
     805        # precreate directories for printer drivers
     806        push(@{$ctx->{directories}}, "$ctx->{share}/W32X86");
     807        push(@{$ctx->{directories}}, "$ctx->{share}/x64");
     808        push(@{$ctx->{directories}}, "$ctx->{share}/WIN40");
     809
    782810        my $msdfs = "no";
    783811        $msdfs = "yes" if ($server_role eq "domain controller");
    … …  
    786814        max xmit = 32K
    787815        server max protocol = SMB2
    788         $extra_smbconf_options
    789816        host msdfs = $msdfs
    790817        lanman auth = yes
     818        allow nt4 crypto = yes
     819
     820        # fruit:copyfile is a global option
     821        fruit:copyfile = yes
     822
     823        $extra_smbconf_options
    791824
    792825[tmp]
    793         path = $ctx->{tmpdir}
     826        path = $ctx->{share}
    794827        read only = no
    795         posix:sharedelay = 10000
     828        posix:sharedelay = 100000
    796829        posix:oplocktimeout = 3
    797830        posix:writetimeupdatedelay = 500000
    798831
     832[xcopy_share]
     833        path = $ctx->{share}
     834        read only = no
     835        posix:sharedelay = 100000
     836        posix:oplocktimeout = 3
     837        posix:writetimeupdatedelay = 500000
     838        create mask = 777
     839        force create mode = 777
     840
     841[posix_share]
     842        path = $ctx->{share}
     843        read only = no
     844        create mask = 0777
     845        force create mode = 0
     846        directory mask = 0777
     847        force directory mode = 0
     848
    799849[test1]
    800         path = $ctx->{tmpdir}/test1
     850        path = $ctx->{share}/test1
    801851        read only = no
    802         posix:sharedelay = 10000
     852        posix:sharedelay = 100000
    803853        posix:oplocktimeout = 3
    804         posix:writetimeupdatedelay = 50000
     854        posix:writetimeupdatedelay = 500000
    805855
    806856[test2]
    807         path = $ctx->{tmpdir}/test2
     857        path = $ctx->{share}/test2
    808858        read only = no
    809         posix:sharedelay = 10000
     859        posix:sharedelay = 100000
    810860        posix:oplocktimeout = 3
    811         posix:writetimeupdatedelay = 50000
     861        posix:writetimeupdatedelay = 500000
    812862
    813863[cifs]
     864        path = $ctx->{share}/_ignore_cifs_
    814865        read only = no
    815866        ntvfs handler = cifs
    816867        cifs:server = $ctx->{netbiosname}
    817868        cifs:share = tmp
    818 #There is no username specified here, instead the client is expected
    819 #to log in with kerberos, and the serverwill use delegated credentials.
     869        cifs:use-s4u2proxy = yes
     870        # There is no username specified here, instead the client is expected
     871        # to log in with kerberos, and the serverwill use delegated credentials.
     872        # Or the server tries s4u2self/s4u2proxy to impersonate the client
    820873
    821874[simple]
    822         path = $ctx->{tmpdir}
     875        path = $ctx->{share}
    823876        read only = no
    824877        ntvfs handler = simple
    825878
    826879[sysvol]
    827         path = $ctx->{lockdir}/sysvol
    828         read only = yes
     880        path = $ctx->{statedir}/sysvol
     881        read only = no
    829882
    830883[netlogon]
    831         path = $ctx->{lockdir}/sysvol/$ctx->{dnsname}/scripts
     884        path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
    832885        read only = no
    833886
    … …  
    835888        copy = simple
    836889        ntvfs handler = cifsposix
     890
     891[vfs_fruit]
     892        path = $ctx->{share}
     893        vfs objects = catia fruit streams_xattr acl_xattr
     894        ea support = yes
     895        fruit:ressource = file
     896        fruit:metadata = netatalk
     897        fruit:locking = netatalk
     898        fruit:encoding = native
     899
     900$extra_smbconf_shares
    837901";
    838902
    … …  
    845909                $ldap_uri = "ldapi://$ldap_uri";
    846910                $ctx->{ldap_uri} = $ldap_uri;
    847                 if ($self->{ldap} eq "fedora-ds") {
    848                         $ctx->{sid_generator} = "backend";
    849                 }
    850911
    851912                $ctx->{ldap_instance} = lc($ctx->{netbiosname});
    … …  
    876937}
    877938
    878 sub provision_member($$$)
     939sub provision_s4member($$$)
    879940{
    880941        my ($self, $prefix, $dcvars) = @_;
    881942        print "PROVISIONING MEMBER...";
    882 
     943        my $extra_smb_conf = "
     944        passdb backend = samba_dsdb
     945winbindd:use external pipes = true
     946
     947rpc_server:default = external
     948rpc_server:svcctl = embedded
     949rpc_server:srvsvc = embedded
     950rpc_server:eventlog = embedded
     951rpc_server:ntsvcs = embedded
     952rpc_server:winreg = embedded
     953rpc_server:spoolss = embedded
     954rpc_daemon:spoolssd = embedded
     955rpc_server:tcpip = no
     956";
    883957        my $ret = $self->provision($prefix,
    884958                                   "member server",
    885                                    "localmember",
    886                                    "member3",
     959                                   "s4member",
    887960                                   "SAMBADOMAIN",
    888961                                   "samba.example.com",
    889962                                   "2008",
    890                                    3,
    891963                                   "locMEMpass3",
    892964                                   $dcvars->{SERVER_IP},
    893                                    "");
     965                                   $dcvars->{SERVER_IPV6},
     966                                   $extra_smb_conf, "", undef);
    894967        unless ($ret) {
    895968                return undef;
    896969        }
    897970
    898         my $samba_tool = $self->bindir_path("samba-tool");
     971        my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     972        my $cmd = "";
     973        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     974        if (defined($ret->{RESOLV_WRAPPER_CONF})) {
     975                $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
     976        } else {
     977                $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
     978        }
     979        $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     980        $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} member";
     981        $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
     982        $cmd .= " --machinepass=machine$ret->{PASSWORD}";
     983
     984        unless (system($cmd) == 0) {
     985                warn("Join failed\n$cmd");
     986                return undef;
     987        }
     988
     989        $ret->{MEMBER_SERVER} = $ret->{SERVER};
     990        $ret->{MEMBER_SERVER_IP} = $ret->{SERVER_IP};
     991        $ret->{MEMBER_SERVER_IPV6} = $ret->{SERVER_IPV6};
     992        $ret->{MEMBER_NETBIOSNAME} = $ret->{NETBIOSNAME};
     993        $ret->{MEMBER_USERNAME} = $ret->{USERNAME};
     994        $ret->{MEMBER_PASSWORD} = $ret->{PASSWORD};
     995
     996        $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
     997        $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
     998        $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
     999        $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
     1000        $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
     1001        $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
     1002
     1003        return $ret;
     1004}
     1005
     1006sub provision_rpc_proxy($$$)
     1007{
     1008        my ($self, $prefix, $dcvars) = @_;
     1009        print "PROVISIONING RPC PROXY...";
     1010
     1011        my $extra_smbconf_options = "
     1012        passdb backend = samba_dsdb
     1013
     1014        # rpc_proxy
     1015        dcerpc_remote:binding = ncacn_ip_tcp:$dcvars->{SERVER}
     1016        dcerpc endpoint servers = epmapper, remote
     1017        dcerpc_remote:interfaces = rpcecho
     1018
     1019[cifs_to_dc]
     1020        path = /tmp/_ignore_cifs_to_dc_/_none_
     1021        read only = no
     1022        ntvfs handler = cifs
     1023        cifs:server = $dcvars->{SERVER}
     1024        cifs:share = cifs
     1025        cifs:use-s4u2proxy = yes
     1026        # There is no username specified here, instead the client is expected
     1027        # to log in with kerberos, and the serverwill use delegated credentials.
     1028        # Or the server tries s4u2self/s4u2proxy to impersonate the client
     1029
     1030";
     1031
     1032        my $ret = $self->provision($prefix,
     1033                                   "member server",
     1034                                   "localrpcproxy",
     1035                                   "SAMBADOMAIN",
     1036                                   "samba.example.com",
     1037                                   "2008",
     1038                                   "locRPCproxypass4",
     1039                                   $dcvars->{SERVER_IP},
     1040                                   $dcvars->{SERVER_IPV6},
     1041                                   $extra_smbconf_options, "", undef);
     1042
     1043        unless ($ret) {
     1044                return undef;
     1045        }
     1046
     1047        my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     1048
     1049        # The joind runs in the context of the rpc_proxy/member for now
     1050        my $cmd = "";
     1051        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     1052        if (defined($ret->{RESOLV_WRAPPER_CONF})) {
     1053                $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
     1054        } else {
     1055                $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
     1056        }
     1057        $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     1058        $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} member";
     1059        $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
     1060        $cmd .= " --machinepass=machine$ret->{PASSWORD}";
     1061
     1062        unless (system($cmd) == 0) {
     1063                warn("Join failed\n$cmd");
     1064                return undef;
     1065        }
     1066
     1067        # Setting up delegation runs in the context of the DC for now
     1068        $cmd = "";
     1069        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$dcvars->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     1070        $cmd .= "KRB5_CONFIG=\"$dcvars->{KRB5_CONFIG}\" ";
     1071        $cmd .= "$samba_tool delegation for-any-protocol '$ret->{NETBIOSNAME}\$' on";
     1072        $cmd .= " $dcvars->{CONFIGURATION}";
     1073        print $cmd;
     1074
     1075        unless (system($cmd) == 0) {
     1076                warn("Delegation failed\n$cmd");
     1077                return undef;
     1078        }
     1079
     1080        # Setting up delegation runs in the context of the DC for now
     1081        $cmd = "";
     1082        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$dcvars->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     1083        $cmd .= "KRB5_CONFIG=\"$dcvars->{KRB5_CONFIG}\" ";
     1084        $cmd .= "$samba_tool delegation add-service '$ret->{NETBIOSNAME}\$' cifs/$dcvars->{SERVER}";
     1085        $cmd .= " $dcvars->{CONFIGURATION}";
     1086
     1087        unless (system($cmd) == 0) {
     1088                warn("Delegation failed\n$cmd");
     1089                return undef;
     1090        }
     1091
     1092        $ret->{RPC_PROXY_SERVER} = $ret->{SERVER};
     1093        $ret->{RPC_PROXY_SERVER_IP} = $ret->{SERVER_IP};
     1094        $ret->{RPC_PROXY_SERVER_IPV6} = $ret->{SERVER_IPV6};
     1095        $ret->{RPC_PROXY_NETBIOSNAME} = $ret->{NETBIOSNAME};
     1096        $ret->{RPC_PROXY_USERNAME} = $ret->{USERNAME};
     1097        $ret->{RPC_PROXY_PASSWORD} = $ret->{PASSWORD};
     1098
     1099        $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
     1100        $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
     1101        $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
     1102        $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
     1103        $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
     1104        $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
     1105
     1106        return $ret;
     1107}
     1108
     1109sub provision_promoted_dc($$$)
     1110{
     1111        my ($self, $prefix, $dcvars) = @_;
     1112        print "PROVISIONING PROMOTED DC...";
     1113
     1114        # We do this so that we don't run the provision.  That's the job of 'samba-tool domain dcpromo'.
     1115        my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
     1116                                               "promotedvdc",
     1117                                               "SAMBADOMAIN",
     1118                                               "samba.example.com",
     1119                                               "2008",
     1120                                               $dcvars->{PASSWORD},
     1121                                               $dcvars->{SERVER_IP},
     1122                                               $dcvars->{SERVER_IPV6});
     1123
     1124        push (@{$ctx->{provision_options}}, "--use-ntvfs");
     1125
     1126        $ctx->{smb_conf_extra_options} = "
     1127        max xmit = 32K
     1128        server max protocol = SMB2
     1129
     1130[sysvol]
     1131        path = $ctx->{statedir}/sysvol
     1132        read only = yes
     1133
     1134[netlogon]
     1135        path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
     1136        read only = no
     1137
     1138";
     1139
     1140        my $ret = $self->provision_raw_step1($ctx);
     1141        unless ($ret) {
     1142                return undef;
     1143        }
     1144
     1145        my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     1146        my $cmd = "";
     1147        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     1148        if (defined($ret->{RESOLV_WRAPPER_CONF})) {
     1149                $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
     1150        } else {
     1151                $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
     1152        }
     1153        $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     1154        $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} MEMBER --realm=$dcvars->{REALM}";
     1155        $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
     1156        $cmd .= " --machinepass=machine$ret->{PASSWORD}";
     1157
     1158        unless (system($cmd) == 0) {
     1159                warn("Join failed\n$cmd");
     1160                return undef;
     1161        }
     1162
     1163        my $samba_tool =  Samba::bindir_path($self, "samba-tool");
    8991164        my $cmd = "";
    9001165        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
    9011166        $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
    902         $cmd .= "$samba_tool join $ret->{CONFIGURATION} $dcvars->{REALM} member";
     1167        $cmd .= "$samba_tool domain dcpromo $ret->{CONFIGURATION} $dcvars->{REALM} DC --realm=$dcvars->{REALM}";
    9031168        $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
     1169        $cmd .= " --machinepass=machine$ret->{PASSWORD} --use-ntvfs --dns-backend=BIND9_DLZ";
    9041170
    9051171        unless (system($cmd) == 0) {
    … …  
    9081174        }
    9091175
    910         $ret->{MEMBER_SERVER} = $ret->{SERVER};
    911         $ret->{MEMBER_SERVER_IP} = $ret->{SERVER_IP};
    912         $ret->{MEMBER_NETBIOSNAME} = $ret->{NETBIOSNAME};
    913         $ret->{MEMBER_NETBIOSALIAS} = $ret->{NETBIOSALIAS};
    914         $ret->{MEMBER_USERNAME} = $ret->{USERNAME};
    915         $ret->{MEMBER_PASSWORD} = $ret->{PASSWORD};
     1176        $ret->{PROMOTED_DC_SERVER} = $ret->{SERVER};
     1177        $ret->{PROMOTED_DC_SERVER_IP} = $ret->{SERVER_IP};
     1178        $ret->{PROMOTED_DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
     1179        $ret->{PROMOTED_DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
    9161180
    9171181        $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
    9181182        $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
     1183        $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
    9191184        $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
    920         $ret->{DC_NETBIOSALIAS} = $dcvars->{DC_NETBIOSALIAS};
    9211185        $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
    9221186        $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
    … …  
    9251189}
    9261190
    927 sub provision_rpc_proxy($$$)
     1191sub provision_vampire_dc($$$)
    9281192{
    9291193        my ($self, $prefix, $dcvars) = @_;
    930         print "PROVISIONING RPC PROXY...";
    931 
    932         my $extra_smbconf_options = "dcerpc_remote:binding = ncacn_ip_tcp:localdc
    933        dcerpc endpoint servers = epmapper, remote
    934        dcerpc_remote:interfaces = rpcecho
     1194        print "PROVISIONING VAMPIRE DC...";
     1195
     1196        # We do this so that we don't run the provision.  That's the job of 'net vampire'.
     1197        my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
     1198                                               "localvampiredc",
     1199                                               "SAMBADOMAIN",
     1200                                               "samba.example.com",
     1201                                               "2008",
     1202                                               $dcvars->{PASSWORD},
     1203                                               $dcvars->{SERVER_IP},
     1204                                               $dcvars->{SERVER_IPV6});
     1205
     1206        push (@{$ctx->{provision_options}}, "--use-ntvfs");
     1207
     1208        $ctx->{smb_conf_extra_options} = "
     1209        max xmit = 32K
     1210        server max protocol = SMB2
     1211
     1212[sysvol]
     1213        path = $ctx->{statedir}/sysvol
     1214        read only = yes
     1215
     1216[netlogon]
     1217        path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
     1218        read only = no
     1219
    9351220";
    9361221
     1222        my $ret = $self->provision_raw_step1($ctx);
     1223        unless ($ret) {
     1224                return undef;
     1225        }
     1226
     1227        my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     1228        my $cmd = "";
     1229        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     1230        if (defined($ret->{RESOLV_WRAPPER_CONF})) {
     1231                $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
     1232        } else {
     1233                $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
     1234        }
     1235        $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     1236        $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} DC --realm=$dcvars->{REALM}";
     1237        $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD} --domain-critical-only";
     1238        $cmd .= " --machinepass=machine$ret->{PASSWORD} --use-ntvfs";
     1239
     1240        unless (system($cmd) == 0) {
     1241                warn("Join failed\n$cmd");
     1242                return undef;
     1243        }
     1244
     1245        $ret->{VAMPIRE_DC_SERVER} = $ret->{SERVER};
     1246        $ret->{VAMPIRE_DC_SERVER_IP} = $ret->{SERVER_IP};
     1247        $ret->{VAMPIRE_DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
     1248        $ret->{VAMPIRE_DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
     1249
     1250        $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
     1251        $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
     1252        $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
     1253        $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
     1254        $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
     1255        $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
     1256        $ret->{DC_REALM} = $dcvars->{DC_REALM};
     1257
     1258        return $ret;
     1259}
     1260
     1261sub provision_subdom_dc($$$)
     1262{
     1263        my ($self, $prefix, $dcvars) = @_;
     1264        print "PROVISIONING SUBDOMAIN DC...";
     1265
     1266        # We do this so that we don't run the provision.  That's the job of 'net vampire'.
     1267        my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
     1268                                               "localsubdc",
     1269                                               "SAMBASUBDOM",
     1270                                               "sub.samba.example.com",
     1271                                               "2008",
     1272                                               $dcvars->{PASSWORD},
     1273                                               undef);
     1274
     1275        push (@{$ctx->{provision_options}}, "--use-ntvfs");
     1276
     1277        $ctx->{smb_conf_extra_options} = "
     1278        max xmit = 32K
     1279        server max protocol = SMB2
     1280
     1281[sysvol]
     1282        path = $ctx->{statedir}/sysvol
     1283        read only = yes
     1284
     1285[netlogon]
     1286        path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
     1287        read only = no
     1288
     1289";
     1290
     1291        my $ret = $self->provision_raw_step1($ctx);
     1292        unless ($ret) {
     1293                return undef;
     1294        }
     1295
     1296        Samba::mk_krb5_conf($ctx);
     1297
     1298        my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     1299        my $cmd = "";
     1300        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     1301        if (defined($ret->{RESOLV_WRAPPER_CONF})) {
     1302                $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
     1303        } else {
     1304                $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
     1305        }
     1306        $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     1307        $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $ctx->{dnsname} subdomain ";
     1308        $cmd .= "--parent-domain=$dcvars->{REALM} -U$dcvars->{DC_USERNAME}\@$dcvars->{REALM}\%$dcvars->{DC_PASSWORD}";
     1309        $cmd .= " --machinepass=machine$ret->{PASSWORD} --use-ntvfs";
     1310        $cmd .= " --adminpass=$ret->{PASSWORD}";
     1311
     1312        unless (system($cmd) == 0) {
     1313                warn("Join failed\n$cmd");
     1314                return undef;
     1315        }
     1316
     1317        $ret->{SUBDOM_DC_SERVER} = $ret->{SERVER};
     1318        $ret->{SUBDOM_DC_SERVER_IP} = $ret->{SERVER_IP};
     1319        $ret->{SUBDOM_DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
     1320        $ret->{SUBDOM_DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
     1321
     1322        $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
     1323        $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
     1324        $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
     1325        $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
     1326        $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
     1327        $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
     1328
     1329        return $ret;
     1330}
     1331
     1332sub provision_ad_dc_ntvfs($$)
     1333{
     1334        my ($self, $prefix) = @_;
     1335
     1336        # We keep the old 'winbind' name here in server services to
     1337        # ensure upgrades which used that name still work with the now
     1338        # alias.
     1339
     1340        print "PROVISIONING AD DC (NTVFS)...";
     1341        my $extra_conf_options = "netbios aliases = localDC1-a
     1342        server services = +winbind -winbindd
     1343        ldap server require strong auth = allow_sasl_over_tls
     1344        ";
    9371345        my $ret = $self->provision($prefix,
    938                                    "member server",
    939                                    "localrpcproxy",
    940                                    "rpcproxy4",
     1346                                   "domain controller",
     1347                                   "localdc",
    9411348                                   "SAMBADOMAIN",
    9421349                                   "samba.example.com",
    9431350                                   "2008",
    944                                    4,
    945                                    "locRPCproxypass4",
    946                                    $dcvars->{SERVER_IP},
    947                                    $extra_smbconf_options);
    948 
    949         unless ($ret) {
    950                 return undef;
    951         }
    952 
    953         my $samba_tool = $self->bindir_path("samba-tool");
    954         my $cmd = "";
    955         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
    956         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
    957         $cmd .= "$samba_tool join $ret->{CONFIGURATION} $dcvars->{REALM} member";
    958         $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
    959 
    960         unless (system($cmd) == 0) {
    961                 warn("Join failed\n$cmd");
    962                 return undef;
    963         }
    964 
    965         $ret->{RPC_PROXY_SERVER} = $ret->{SERVER};
    966         $ret->{RPC_PROXY_SERVER_IP} = $ret->{SERVER_IP};
    967         $ret->{RPC_PROXY_NETBIOSNAME} = $ret->{NETBIOSNAME};
    968         $ret->{RPC_PROXY_NETBIOSALIAS} = $ret->{NETBIOSALIAS};
    969         $ret->{RPC_PROXY_USERNAME} = $ret->{USERNAME};
    970         $ret->{RPC_PROXY_PASSWORD} = $ret->{PASSWORD};
     1351                                   "locDCpass1",
     1352                                   undef,
     1353                                   undef,
     1354                                   $extra_conf_options,
     1355                                   "",
     1356                                   undef);
     1357
     1358        return undef unless(defined $ret);
     1359        unless($self->add_wins_config("$prefix/private")) {
     1360                warn("Unable to add wins configuration");
     1361                return undef;
     1362        }
     1363        $ret->{NETBIOSALIAS} = "localdc1-a";
     1364        $ret->{DC_SERVER} = $ret->{SERVER};
     1365        $ret->{DC_SERVER_IP} = $ret->{SERVER_IP};
     1366        $ret->{DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
     1367        $ret->{DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
     1368        $ret->{DC_USERNAME} = $ret->{USERNAME};
     1369        $ret->{DC_PASSWORD} = $ret->{PASSWORD};
     1370        $ret->{DC_REALM} = $ret->{REALM};
    9711371
    9721372        return $ret;
    9731373}
    9741374
    975 sub provision_vampire_dc($$$)
     1375sub provision_fl2000dc($$)
     1376{
     1377        my ($self, $prefix) = @_;
     1378
     1379        print "PROVISIONING DC WITH FOREST LEVEL 2000...";
     1380        my $extra_conf_options = "
     1381        spnego:simulate_w2k=yes
     1382        ntlmssp_server:force_old_spnego=yes
     1383";
     1384        my $ret = $self->provision($prefix,
     1385                                   "domain controller",
     1386                                   "dc5",
     1387                                   "SAMBA2000",
     1388                                   "samba2000.example.com",
     1389                                   "2000",
     1390                                   "locDCpass5",
     1391                                   undef,
     1392                                   undef,
     1393                                   $extra_conf_options,
     1394                                   "",
     1395                                   undef);
     1396
     1397        unless($self->add_wins_config("$prefix/private")) {
     1398                warn("Unable to add wins configuration");
     1399                return undef;
     1400        }
     1401        $ret->{DC_SERVER} = $ret->{SERVER};
     1402        $ret->{DC_SERVER_IP} = $ret->{SERVER_IP};
     1403        $ret->{DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
     1404        $ret->{DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
     1405        $ret->{DC_USERNAME} = $ret->{USERNAME};
     1406        $ret->{DC_PASSWORD} = $ret->{PASSWORD};
     1407        $ret->{DC_REALM} = $ret->{REALM};
     1408
     1409        return $ret;
     1410}
     1411
     1412sub provision_fl2003dc($$$)
    9761413{
    9771414        my ($self, $prefix, $dcvars) = @_;
    978         print "PROVISIONING VAMPIRE DC...";
    979 
    980         # We do this so that we don't run the provision.  That's the job of 'net vampire'.
     1415
     1416        print "PROVISIONING DC WITH FOREST LEVEL 2003...";
     1417        my $extra_conf_options = "allow dns updates = nonsecure and secure";
     1418        my $ret = $self->provision($prefix,
     1419                                   "domain controller",
     1420                                   "dc6",
     1421                                   "SAMBA2003",
     1422                                   "samba2003.example.com",
     1423                                   "2003",
     1424                                   "locDCpass6",
     1425                                   undef,
     1426                                   undef,
     1427                                   $extra_conf_options,
     1428                                   "",
     1429                                   undef);
     1430
     1431        unless (defined $ret) {
     1432                return undef;
     1433        }
     1434
     1435        $ret->{DC_SERVER} = $ret->{SERVER};
     1436        $ret->{DC_SERVER_IP} = $ret->{SERVER_IP};
     1437        $ret->{DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
     1438        $ret->{DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
     1439        $ret->{DC_USERNAME} = $ret->{USERNAME};
     1440        $ret->{DC_PASSWORD} = $ret->{PASSWORD};
     1441
     1442        my @samba_tool_options;
     1443        push (@samba_tool_options, Samba::bindir_path($self, "samba-tool"));
     1444        push (@samba_tool_options, "domain");
     1445        push (@samba_tool_options, "passwordsettings");
     1446        push (@samba_tool_options, "set");
     1447        push (@samba_tool_options, "--configfile=$ret->{SERVERCONFFILE}");
     1448        push (@samba_tool_options, "--min-pwd-age=0");
     1449        push (@samba_tool_options, "--history-length=1");
     1450
     1451        my $samba_tool_cmd = join(" ", @samba_tool_options);
     1452
     1453        unless (system($samba_tool_cmd) == 0) {
     1454                warn("Unable to set min password age to 0: \n$samba_tool_cmd\n");
     1455                return undef;
     1456        }
     1457
     1458        return $ret;
     1459
     1460        unless($self->add_wins_config("$prefix/private")) {
     1461                warn("Unable to add wins configuration");
     1462                return undef;
     1463        }
     1464
     1465        return $ret;
     1466}
     1467
     1468sub provision_fl2008r2dc($$$)
     1469{
     1470        my ($self, $prefix, $dcvars) = @_;
     1471
     1472        print "PROVISIONING DC WITH FOREST LEVEL 2008r2...";
     1473        my $extra_conf_options = "ldap server require strong auth = no";
     1474        my $ret = $self->provision($prefix,
     1475                                   "domain controller",
     1476                                   "dc7",
     1477                                   "SAMBA2008R2",
     1478                                   "samba2008R2.example.com",
     1479                                   "2008_R2",
     1480                                   "locDCpass7",
     1481                                   undef,
     1482                                   undef,
     1483                                   $extra_conf_options,
     1484                                   "",
     1485                                   undef);
     1486
     1487        unless ($self->add_wins_config("$prefix/private")) {
     1488                warn("Unable to add wins configuration");
     1489                return undef;
     1490        }
     1491        $ret->{DC_SERVER} = $ret->{SERVER};
     1492        $ret->{DC_SERVER_IP} = $ret->{SERVER_IP};
     1493        $ret->{DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
     1494        $ret->{DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
     1495        $ret->{DC_USERNAME} = $ret->{USERNAME};
     1496        $ret->{DC_PASSWORD} = $ret->{PASSWORD};
     1497        $ret->{DC_REALM} = $ret->{REALM};
     1498
     1499        return $ret;
     1500}
     1501
     1502
     1503sub provision_rodc($$$)
     1504{
     1505        my ($self, $prefix, $dcvars) = @_;
     1506        print "PROVISIONING RODC...";
     1507
     1508        # We do this so that we don't run the provision.  That's the job of 'net join RODC'.
    9811509        my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
    982                                                "localvampiredc",
    983                                                "dc2",
     1510                                               "rodc",
    9841511                                               "SAMBADOMAIN",
    9851512                                               "samba.example.com",
    9861513                                               "2008",
    987                                                2, $dcvars->{PASSWORD},
    988                                                $dcvars->{SERVER_IP});
     1514                                               $dcvars->{PASSWORD},
     1515                                               $dcvars->{SERVER_IP},
     1516                                               $dcvars->{SERVER_IPV6});
     1517        unless ($ctx) {
     1518                return undef;
     1519        }
     1520
     1521        push (@{$ctx->{provision_options}}, "--use-ntvfs");
     1522
     1523        $ctx->{share} = "$ctx->{prefix_abs}/share";
     1524        push(@{$ctx->{directories}}, "$ctx->{share}");
    9891525
    9901526        $ctx->{smb_conf_extra_options} = "
    … …  
    9931529
    9941530[sysvol]
    995         path = $ctx->{lockdir}/sysvol
     1531        path = $ctx->{statedir}/sysvol
    9961532        read only = yes
    9971533
    9981534[netlogon]
    999         path = $ctx->{lockdir}/sysvol/$ctx->{dnsname}/scripts
    1000         read only = no
    1001 
    1002 ";
    1003 
    1004         my $ret = $self->provision_raw_step1($ctx);
    1005         unless ($ret) {
    1006                 return undef;
    1007         }
    1008 
    1009         my $samba_tool = $self->bindir_path("samba-tool");
    1010         my $cmd = "";
    1011         $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
    1012         $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
    1013         $cmd .= "$samba_tool join $ret->{CONFIGURATION} $dcvars->{REALM} DC --realm=$dcvars->{REALM}";
    1014         $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
    1015 
    1016         unless (system($cmd) == 0) {
    1017                 warn("Join failed\n$cmd");
    1018                 return undef;
    1019         }
    1020 
    1021         $ret->{VAMPIRE_DC_SERVER} = $ret->{SERVER};
    1022         $ret->{VAMPIRE_DC_SERVER_IP} = $ret->{SERVER_IP};
    1023         $ret->{VAMPIRE_DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
    1024         $ret->{VAMPIRE_DC_NETBIOSALIAS} = $ret->{NETBIOSALIAS};
    1025 
    1026         $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
    1027         $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
    1028         $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
    1029         $ret->{DC_NETBIOSALIAS} = $dcvars->{DC_NETBIOSALIAS};
    1030         $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
    1031         $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
    1032 
    1033         return $ret;
    1034 }
    1035 
    1036 sub provision_dc($$)
    1037 {
    1038         my ($self, $prefix) = @_;
    1039 
    1040         print "PROVISIONING DC...";
    1041         my $ret = $self->provision($prefix,
    1042                                    "domain controller",
    1043                                    "localdc",
    1044                                    "dc1",
    1045                                    "SAMBADOMAIN",
    1046                                    "samba.example.com",
    1047                                    "2008",
    1048                                    1,
    1049                                    "locDCpass1",
    1050                                    "127.0.0.1", "");
    1051 
    1052         return undef unless(defined $ret);
    1053         unless($self->add_wins_config("$prefix/private")) {
    1054                 warn("Unable to add wins configuration");
    1055                 return undef;
    1056         }
    1057 
    1058         $ret->{DC_SERVER} = $ret->{SERVER};
    1059         $ret->{DC_SERVER_IP} = $ret->{SERVER_IP};
    1060         $ret->{DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
    1061         $ret->{DC_NETBIOSALIAS} = $ret->{NETBIOSALIAS};
    1062         $ret->{DC_USERNAME} = $ret->{USERNAME};
    1063         $ret->{DC_PASSWORD} = $ret->{PASSWORD};
    1064 
    1065         return $ret;
    1066 }
    1067 
    1068 sub provision_fl2000dc($$)
    1069 {
    1070         my ($self, $prefix) = @_;
    1071 
    1072         print "PROVISIONING DC...";
    1073         my $ret = $self->provision($prefix,
    1074                                    "domain controller",
    1075                                    "dc5",
    1076                                    "localfl2000dc",
    1077                                    "SAMBA2000",
    1078                                    "samba2000.example.com",
    1079                                    "2000",
    1080                                    5,
    1081                                    "locDCpass5",
    1082                                    "127.0.0.5", "");
    1083 
    1084         unless($self->add_wins_config("$prefix/private")) {
    1085                 warn("Unable to add wins configuration");
    1086                 return undef;
    1087         }
    1088 
    1089         return $ret;
    1090 }
    1091 
    1092 sub provision_fl2003dc($$)
    1093 {
    1094         my ($self, $prefix) = @_;
    1095 
    1096         print "PROVISIONING DC...";
    1097         my $ret = $self->provision($prefix,
    1098                                    "domain controller",
    1099                                    "dc6",
    1100                                    "localfl2003dc",
    1101                                    "SAMBA2003",
    1102                                    "samba2003.example.com",
    1103                                    "2003",
    1104                                    6,
    1105                                    "locDCpass6",
    1106                                    "127.0.0.6", "");
    1107 
    1108         unless($self->add_wins_config("$prefix/private")) {
    1109                 warn("Unable to add wins configuration");
    1110                 return undef;
    1111         }
    1112 
    1113         return $ret;
    1114 }
    1115 
    1116 sub provision_fl2008r2dc($$)
    1117 {
    1118         my ($self, $prefix) = @_;
    1119 
    1120         print "PROVISIONING DC...";
    1121         my $ret = $self->provision($prefix,
    1122                                    "domain controller",
    1123                                    "dc7",
    1124                                    "localfl2000r2dc",
    1125                                    "SAMBA2008R2",
    1126                                    "samba2008R2.example.com",
    1127                                    "2008_R2",
    1128                                    7,
    1129                                    "locDCpass7",
    1130                                    "127.0.0.7", "");
    1131 
    1132         unless ($self->add_wins_config("$prefix/private")) {
    1133                 warn("Unable to add wins configuration");
    1134                 return undef;
    1135         }
    1136 
    1137         return $ret;
    1138 }
    1139 
    1140 
    1141 sub provision_rodc($$$)
    1142 {
    1143         my ($self, $prefix, $dcvars) = @_;
    1144         print "PROVISIONING RODC...";
    1145 
    1146         # We do this so that we don't run the provision.  That's the job of 'net join RODC'.
    1147         my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
    1148                                                "rodc",
    1149                                                "dc8",
    1150                                                "SAMBADOMAIN",
    1151                                                "samba.example.com",
    1152                                                "2008",
    1153                                                8, $dcvars->{PASSWORD},
    1154                                                $dcvars->{SERVER_IP});
    1155         unless ($ctx) {
    1156                 return undef;
    1157         }
    1158 
    1159         $ctx->{tmpdir} = "$ctx->{prefix_abs}/tmp";
    1160         push(@{$ctx->{directories}}, "$ctx->{tmpdir}");
    1161 
    1162         $ctx->{smb_conf_extra_options} = "
    1163         max xmit = 32K
    1164         server max protocol = SMB2
    1165 
    1166 [sysvol]
    1167         path = $ctx->{lockdir}/sysvol
     1535        path = $ctx->{statedir}/sysvol/$ctx->{dnsname}/scripts
    11681536        read only = yes
    11691537
    1170 [netlogon]
    1171         path = $ctx->{lockdir}/sysvol/$ctx->{dnsname}/scripts
    1172         read only = yes
    1173 
    11741538[tmp]
    1175         path = $ctx->{tmpdir}
     1539        path = $ctx->{share}
    11761540        read only = no
    11771541        posix:sharedelay = 10000
    11781542        posix:oplocktimeout = 3
    1179         posix:writetimeupdatedelay = 500000
     1543        posix:writetimeupdatedelay = 50000
    11801544
    11811545";
    … …  
    11861550        }
    11871551
    1188         my $samba_tool = $self->bindir_path("samba-tool");
     1552        my $samba_tool =  Samba::bindir_path($self, "samba-tool");
    11891553        my $cmd = "";
    11901554        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     1555        if (defined($ret->{RESOLV_WRAPPER_CONF})) {
     1556                $cmd .= "RESOLV_WRAPPER_CONF=\"$ret->{RESOLV_WRAPPER_CONF}\" ";
     1557        } else {
     1558                $cmd .= "RESOLV_WRAPPER_HOSTS=\"$ret->{RESOLV_WRAPPER_HOSTS}\" ";
     1559        }
    11911560        $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
    1192         $cmd .= "$samba_tool join $ret->{CONFIGURATION} $dcvars->{REALM} RODC";
     1561        $cmd .= "$samba_tool domain join $ret->{CONFIGURATION} $dcvars->{REALM} RODC";
    11931562        $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
     1563        $cmd .= " --server=$dcvars->{DC_SERVER} --use-ntvfs";
     1564
     1565        unless (system($cmd) == 0) {
     1566                warn("RODC join failed\n$cmd");
     1567                return undef;
     1568        }
     1569
     1570        # This ensures deterministic behaviour for tests that want to have the 'testallowed account'
     1571        # user password verified on the RODC
     1572        my $testallowed_account = "testallowed account";
     1573        $cmd = "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     1574        $cmd .= "$samba_tool rodc preload '$testallowed_account' $ret->{CONFIGURATION}";
    11941575        $cmd .= " --server=$dcvars->{DC_SERVER}";
    11951576
    … …  
    12031584        # the proxy code
    12041585        $ctx->{kdc_ipv4} = $ret->{SERVER_IP};
    1205         $self->mk_krb5_conf($ctx);
     1586        $ctx->{kdc_ipv6} = $ret->{SERVER_IPV6};
     1587        Samba::mk_krb5_conf($ctx);
    12061588
    12071589        $ret->{RODC_DC_SERVER} = $ret->{SERVER};
    12081590        $ret->{RODC_DC_SERVER_IP} = $ret->{SERVER_IP};
     1591        $ret->{RODC_DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
    12091592        $ret->{RODC_DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
    1210         $ret->{RODC_DC_NETBIOSALIAS} = $ret->{NETBIOSALIAS};
    12111593
    12121594        $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
    12131595        $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
     1596        $ret->{DC_SERVER_IPV6} = $dcvars->{DC_SERVER_IPV6};
    12141597        $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
    1215         $ret->{DC_NETBIOSALIAS} = $dcvars->{DC_NETBIOSALIAS};
    12161598        $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
    12171599        $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
    … …  
    12201602}
    12211603
     1604sub provision_ad_dc($$)
     1605{
     1606        my ($self, $prefix) = @_;
     1607
     1608        my $prefix_abs = abs_path($prefix);
     1609
     1610        my $bindir_abs = abs_path($self->{bindir});
     1611        my $lockdir="$prefix_abs/lockdir";
     1612        my $conffile="$prefix_abs/etc/smb.conf";
     1613
     1614        my $extra_smbconf_options = "
     1615        server services = -smb +s3fs
     1616        xattr_tdb:file = $prefix_abs/statedir/xattr.tdb
     1617
     1618        dbwrap_tdb_mutexes:* = yes
     1619
     1620        kernel oplocks = no
     1621        kernel change notify = no
     1622
     1623        logging = file
     1624        printing = bsd
     1625        printcap name = /dev/null
     1626
     1627        max protocol = SMB3
     1628        read only = no
     1629        server signing = auto
     1630
     1631        smbd:sharedelay = 100000
     1632        smbd:writetimeupdatedelay = 500000
     1633        create mask = 755
     1634        dos filemode = yes
     1635
     1636        dcerpc endpoint servers = -winreg -srvsvc
     1637
     1638        printcap name = /dev/null
     1639
     1640        addprinter command = $ENV{SRCDIR_ABS}/source3/script/tests/printing/modprinter.pl -a -s $conffile --
     1641        deleteprinter command = $ENV{SRCDIR_ABS}/source3/script/tests/printing/modprinter.pl -d -s $conffile --
     1642
     1643        printing = vlp
     1644        print command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb print %p %s
     1645        lpq command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpq %p
     1646        lp rm command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lprm %p %j
     1647        lp pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lppause %p %j
     1648        lp resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb lpresume %p %j
     1649        queue pause command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queuepause %p
     1650        queue resume command = $bindir_abs/vlp tdbfile=$lockdir/vlp.tdb queueresume %p
     1651        lpq cache time = 0
     1652        print notify backchannel = yes
     1653";
     1654
     1655        my $extra_smbconf_shares = "
     1656
     1657[tmpenc]
     1658        copy = tmp
     1659        smb encrypt = required
     1660
     1661[tmpcase]
     1662        copy = tmp
     1663        case sensitive = yes
     1664
     1665[tmpguest]
     1666        copy = tmp
     1667        guest ok = yes
     1668
     1669[hideunread]
     1670        copy = tmp
     1671        hide unreadable = yes
     1672
     1673[durable]
     1674        copy = tmp
     1675        kernel share modes = no
     1676        kernel oplocks = no
     1677        posix locking = no
     1678
     1679[print\$]
     1680        copy = tmp
     1681
     1682[print1]
     1683        copy = tmp
     1684        printable = yes
     1685
     1686[print2]
     1687        copy = print1
     1688[print3]
     1689        copy = print1
     1690[lp]
     1691        copy = print1
     1692";
     1693
     1694        print "PROVISIONING AD DC...";
     1695        my $ret = $self->provision($prefix,
     1696                                   "domain controller",
     1697                                   "addc",
     1698                                   "ADDOMAIN",
     1699                                   "addom.samba.example.com",
     1700                                   "2008",
     1701                                   "locDCpass1",
     1702                                   undef,
     1703                                   undef,
     1704                                   $extra_smbconf_options,
     1705                                   $extra_smbconf_shares,
     1706                                   undef);
     1707
     1708        return undef unless(defined $ret);
     1709        unless($self->add_wins_config("$prefix/private")) {
     1710                warn("Unable to add wins configuration");
     1711                return undef;
     1712        }
     1713
     1714        $ret->{DC_SERVER} = $ret->{SERVER};
     1715        $ret->{DC_SERVER_IP} = $ret->{SERVER_IP};
     1716        $ret->{DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
     1717        $ret->{DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
     1718        $ret->{DC_USERNAME} = $ret->{USERNAME};
     1719        $ret->{DC_PASSWORD} = $ret->{PASSWORD};
     1720
     1721        return $ret;
     1722}
     1723
     1724sub provision_chgdcpass($$)
     1725{
     1726        my ($self, $prefix) = @_;
     1727
     1728        print "PROVISIONING CHGDCPASS...";
     1729        my $extra_provision_options = undef;
     1730        push (@{$extra_provision_options}, "--dns-backend=BIND9_DLZ");
     1731        my $ret = $self->provision($prefix,
     1732                                   "domain controller",
     1733                                   "chgdcpass",
     1734                                   "CHDCDOMAIN",
     1735                                   "chgdcpassword.samba.example.com",
     1736                                   "2008",
     1737                                   "chgDCpass1",
     1738                                   undef,
     1739                                   undef,
     1740                                   "",
     1741                                   "",
     1742                                   $extra_provision_options);
     1743
     1744        return undef unless(defined $ret);
     1745        unless($self->add_wins_config("$prefix/private")) {
     1746                warn("Unable to add wins configuration");
     1747                return undef;
     1748        }
     1749       
     1750        # Remove secrets.tdb from this environment to test that we
     1751        # still start up on systems without the new matching
     1752        # secrets.tdb records.
     1753        unless (unlink("$ret->{PRIVATEDIR}/secrets.tdb") || unlink("$ret->{PRIVATEDIR}/secrets.ntdb")) {
     1754                warn("Unable to remove $ret->{PRIVATEDIR}/secrets.tdb added during provision");
     1755                return undef;
     1756        }
     1757           
     1758        $ret->{DC_SERVER} = $ret->{SERVER};
     1759        $ret->{DC_SERVER_IP} = $ret->{SERVER_IP};
     1760        $ret->{DC_SERVER_IPV6} = $ret->{SERVER_IPV6};
     1761        $ret->{DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
     1762        $ret->{DC_USERNAME} = $ret->{USERNAME};
     1763        $ret->{DC_PASSWORD} = $ret->{PASSWORD};
     1764
     1765        return $ret;
     1766}
     1767
    12221768sub teardown_env($$)
    12231769{
    … …  
    12251771        my $pid;
    12261772
    1227         close(DATA);
    1228 
    1229         if (open(IN, "<$envvars->{PIDDIR}/samba.pid")) {
    1230                 $pid = <IN>;
    1231                 close(IN);
    1232 
    1233                 # Give the process 20 seconds to exit.  gcov needs
    1234                 # this time to write out the covarge data
    1235                 my $count = 0;
    1236                 until (kill(0, $pid) == 0) {
    1237                         # if no process sucessfully signalled, then we are done
    1238                         sleep(1);
    1239                         $count++;
    1240                         last if $count > 20;
    1241                 }
    1242 
    1243                 # If it is still around, kill it
    1244                 if ($count > 20) {
    1245                         print "server process $pid took more than $count seconds to exit, killing\n";
    1246                         kill 9, $pid;
    1247                 }
    1248         }
    1249 
    1250         my $failed = $? >> 8;
     1773        # This should cause samba to terminate gracefully
     1774        close($envvars->{STDIN_PIPE});
     1775
     1776        $pid = $envvars->{SAMBA_PID};
     1777        my $count = 0;
     1778        my $childpid;
     1779
     1780        # This should give it time to write out the gcov data
     1781        until ($count > 30) {
     1782            if (Samba::cleanup_child($pid, "samba") == -1) {
     1783                last;
     1784            }
     1785            sleep(1);
     1786            $count++;
     1787        }
     1788
     1789        if ($count > 30 || kill(0, $pid)) {
     1790            kill "TERM", $pid;
     1791
     1792            until ($count > 40) {
     1793                if (Samba::cleanup_child($pid, "samba") == -1) {
     1794                    last;
     1795                }
     1796                sleep(1);
     1797                $count++;
     1798            }
     1799            # If it is still around, kill it
     1800            warn "server process $pid took more than $count seconds to exit, killing\n";
     1801            kill 9, $pid;
     1802        }
    12511803
    12521804        $self->slapd_stop($envvars) if ($self->{ldap});
    … …  
    12541806        print $self->getlog_env($envvars);
    12551807
    1256         return $failed;
     1808        return;
    12571809}
    12581810
    … …  
    12801832{
    12811833        my ($self, $envvars) = @_;
    1282 
    1283         return (-p $envvars->{SAMBA_TEST_FIFO});
     1834        my $samba_pid = $envvars->{SAMBA_PID};
     1835
     1836        if (not defined($samba_pid)) {
     1837            return 0;
     1838        } elsif ($samba_pid > 0) {
     1839            my $childpid = Samba::cleanup_child($samba_pid, "samba");
     1840
     1841            if ($childpid == 0) {
     1842                return 1;
     1843            }
     1844            return 0;
     1845        } else {
     1846            return 1;
     1847        }
     1848
    12841849}
    12851850
    … …  
    12871852{
    12881853        my ($self, $envname, $path) = @_;
     1854        my $target3 = $self->{target3};
    12891855
    12901856        $ENV{ENVNAME} = $envname;
    12911857
    1292         if ($envname eq "dc") {
    1293                 return $self->setup_dc("$path/dc");
     1858        if (defined($self->{vars}->{$envname})) {
     1859                return $self->{vars}->{$envname};
     1860        }
     1861
     1862        if ($envname eq "ad_dc_ntvfs") {
     1863                return $self->setup_ad_dc_ntvfs("$path/ad_dc_ntvfs");
    12941864        } elsif ($envname eq "fl2000dc") {
    12951865                return $self->setup_fl2000dc("$path/fl2000dc");
    12961866        } elsif ($envname eq "fl2003dc") {
    1297                 return $self->setup_fl2003dc("$path/fl2003dc");
     1867                if (not defined($self->{vars}->{ad_dc})) {
     1868                        $self->setup_ad_dc("$path/ad_dc");
     1869                }
     1870                return $self->setup_fl2003dc("$path/fl2003dc", $self->{vars}->{ad_dc});
    12981871        } elsif ($envname eq "fl2008r2dc") {
    1299                 return $self->setup_fl2008r2dc("$path/fl2008r2dc");
     1872                if (not defined($self->{vars}->{ad_dc})) {
     1873                        $self->setup_ad_dc("$path/ad_dc");
     1874                }
     1875                return $self->setup_fl2008r2dc("$path/fl2008r2dc", $self->{vars}->{ad_dc});
    13001876        } elsif ($envname eq "rpc_proxy") {
    1301                 if (not defined($self->{vars}->{dc})) {
    1302                         $self->setup_dc("$path/dc");
    1303                 }
    1304                 return $self->setup_rpc_proxy("$path/rpc_proxy", $self->{vars}->{dc});
     1877                if (not defined($self->{vars}->{ad_dc_ntvfs})) {
     1878                        $self->setup_ad_dc_ntvfs("$path/ad_dc_ntvfs");
     1879                }
     1880                return $self->setup_rpc_proxy("$path/rpc_proxy", $self->{vars}->{ad_dc_ntvfs});
    13051881        } elsif ($envname eq "vampire_dc") {
    1306                 if (not defined($self->{vars}->{dc})) {
    1307                         $self->setup_dc("$path/dc");
    1308                 }
    1309                 return $self->setup_vampire_dc("$path/vampire_dc", $self->{vars}->{dc});
    1310         } elsif ($envname eq "member") {
    1311                 if (not defined($self->{vars}->{dc})) {
    1312                         $self->setup_dc("$path/dc");
    1313                 }
    1314                 return $self->setup_member("$path/member", $self->{vars}->{dc});
     1882                if (not defined($self->{vars}->{ad_dc_ntvfs})) {
     1883                        $self->setup_ad_dc_ntvfs("$path/ad_dc_ntvfs");
     1884                }
     1885                return $self->setup_vampire_dc("$path/vampire_dc", $self->{vars}->{ad_dc_ntvfs});
     1886        } elsif ($envname eq "promoted_dc") {
     1887                if (not defined($self->{vars}->{ad_dc_ntvfs})) {
     1888                        $self->setup_ad_dc_ntvfs("$path/ad_dc_ntvfs");
     1889                }
     1890                return $self->setup_promoted_dc("$path/promoted_dc", $self->{vars}->{ad_dc_ntvfs});
     1891        } elsif ($envname eq "subdom_dc") {
     1892                if (not defined($self->{vars}->{ad_dc_ntvfs})) {
     1893                        $self->setup_ad_dc_ntvfs("$path/ad_dc_ntvfs");
     1894                }
     1895                return $self->setup_subdom_dc("$path/subdom_dc", $self->{vars}->{ad_dc_ntvfs});
     1896        } elsif ($envname eq "s4member") {
     1897                if (not defined($self->{vars}->{ad_dc_ntvfs})) {
     1898                        $self->setup_ad_dc_ntvfs("$path/ad_dc_ntvfs");
     1899                }
     1900                return $self->setup_s4member("$path/s4member", $self->{vars}->{ad_dc_ntvfs});
    13151901        } elsif ($envname eq "rodc") {
    1316                 if (not defined($self->{vars}->{dc})) {
    1317                         $self->setup_dc("$path/dc");
    1318                 }
    1319                 return $self->setup_rodc("$path/rodc", $self->{vars}->{dc});
    1320         } elsif ($envname eq "all") {
    1321                 if (not defined($self->{vars}->{dc})) {
    1322                         $ENV{ENVNAME} = "dc";
    1323                         $self->setup_dc("$path/dc");
    1324                 }
    1325                 my $ret = $self->setup_member("$path/member", $self->{vars}->{dc});
    1326                 if (not defined($self->{vars}->{rpc_proxy})) {
    1327                         $ENV{ENVNAME} = "rpc_proxy";
    1328                         my $rpc_proxy_ret = $self->setup_rpc_proxy("$path/rpc_proxy", $self->{vars}->{dc});
    1329                        
    1330                         $ret->{RPC_PROXY_SERVER} = $rpc_proxy_ret->{SERVER};
    1331                         $ret->{RPC_PROXY_SERVER_IP} = $rpc_proxy_ret->{SERVER_IP};
    1332                         $ret->{RPC_PROXY_NETBIOSNAME} = $rpc_proxy_ret->{NETBIOSNAME};
    1333                         $ret->{RPC_PROXY_NETBIOSALIAS} = $rpc_proxy_ret->{NETBIOSALIAS};
    1334                         $ret->{RPC_PROXY_USERNAME} = $rpc_proxy_ret->{USERNAME};
    1335                         $ret->{RPC_PROXY_PASSWORD} = $rpc_proxy_ret->{PASSWORD};
    1336                 }
    1337                 if (not defined($self->{vars}->{fl2000dc})) {
    1338                         $ENV{ENVNAME} = "fl2000dc";
    1339                         my $fl2000dc_ret = $self->setup_fl2000dc("$path/fl2000dc", $self->{vars}->{dc});
    1340                        
    1341                         $ret->{FL2000DC_SERVER} = $fl2000dc_ret->{SERVER};
    1342                         $ret->{FL2000DC_SERVER_IP} = $fl2000dc_ret->{SERVER_IP};
    1343                         $ret->{FL2000DC_NETBIOSNAME} = $fl2000dc_ret->{NETBIOSNAME};
    1344                         $ret->{FL2000DC_NETBIOSALIAS} = $fl2000dc_ret->{NETBIOSALIAS};
    1345                         $ret->{FL2000DC_USERNAME} = $fl2000dc_ret->{USERNAME};
    1346                         $ret->{FL2000DC_PASSWORD} = $fl2000dc_ret->{PASSWORD};
    1347                 }
    1348                 if (not defined($self->{vars}->{fl2003dc})) {
    1349                         $ENV{ENVNAME} = "fl2003dc";
    1350                         my $fl2003dc_ret = $self->setup_fl2003dc("$path/fl2003dc", $self->{vars}->{dc});
    1351 
    1352                         $ret->{FL2003DC_SERVER} = $fl2003dc_ret->{SERVER};
    1353                         $ret->{FL2003DC_SERVER_IP} = $fl2003dc_ret->{SERVER_IP};
    1354                         $ret->{FL2003DC_NETBIOSNAME} = $fl2003dc_ret->{NETBIOSNAME};
    1355                         $ret->{FL2003DC_NETBIOSALIAS} = $fl2003dc_ret->{NETBIOSALIAS};
    1356                         $ret->{FL2003DC_USERNAME} = $fl2003dc_ret->{USERNAME};
    1357                         $ret->{FL2003DC_PASSWORD} = $fl2003dc_ret->{PASSWORD};
    1358                 }
    1359                 if (not defined($self->{vars}->{fl2008r2dc})) {
    1360                         $ENV{ENVNAME} = "fl2008r2dc";
    1361                         my $fl2008r2dc_ret = $self->setup_fl2008r2dc("$path/fl2008r2dc", $self->{vars}->{dc});
    1362 
    1363                         $ret->{FL2008R2DC_SERVER} = $fl2008r2dc_ret->{SERVER};
    1364                         $ret->{FL2008R2DC_SERVER_IP} = $fl2008r2dc_ret->{SERVER_IP};
    1365                         $ret->{FL2008R2DC_NETBIOSNAME} = $fl2008r2dc_ret->{NETBIOSNAME};
    1366                         $ret->{FL2008R2DC_NETBIOSALIAS} = $fl2008r2dc_ret->{NETBIOSALIAS};
    1367                         $ret->{FL2008R2DC_USERNAME} = $fl2008r2dc_ret->{USERNAME};
    1368                         $ret->{FL2008R2DC_PASSWORD} = $fl2008r2dc_ret->{PASSWORD};
    1369                 }
    1370                 return $ret;
     1902                if (not defined($self->{vars}->{ad_dc_ntvfs})) {
     1903                        $self->setup_ad_dc_ntvfs("$path/ad_dc_ntvfs");
     1904                }
     1905                return $self->setup_rodc("$path/rodc", $self->{vars}->{ad_dc_ntvfs});
     1906        } elsif ($envname eq "chgdcpass") {
     1907                return $self->setup_chgdcpass("$path/chgdcpass", $self->{vars}->{chgdcpass});
     1908        } elsif ($envname eq "ad_member") {
     1909                if (not defined($self->{vars}->{ad_dc_ntvfs})) {
     1910                        $self->setup_ad_dc_ntvfs("$path/ad_dc_ntvfs");
     1911                }
     1912                return $target3->setup_admember("$path/ad_member", $self->{vars}->{ad_dc_ntvfs}, 29);
     1913        } elsif ($envname eq "ad_dc") {
     1914                return $self->setup_ad_dc("$path/ad_dc");
     1915        } elsif ($envname eq "ad_dc_no_nss") {
     1916                return $self->setup_ad_dc("$path/ad_dc_no_nss", "no_nss");
     1917        } elsif ($envname eq "ad_member_rfc2307") {
     1918                if (not defined($self->{vars}->{ad_dc_ntvfs})) {
     1919                        $self->setup_ad_dc_ntvfs("$path/ad_dc_ntvfs");
     1920                }
     1921                return $target3->setup_admember_rfc2307("$path/ad_member_rfc2307",
     1922                                                        $self->{vars}->{ad_dc_ntvfs}, 34);
     1923        } elsif ($envname eq "none") {
     1924                return $self->setup_none("$path/none");
    13711925        } else {
    1372                 warn("Samba4 can't provide environment '$envname'");
    1373                 return undef;
    1374         }
    1375 }
    1376 
    1377 sub setup_member($$$)
     1926                return "UNKNOWN";
     1927        }
     1928}
     1929
     1930sub setup_s4member($$$)
    13781931{
    13791932        my ($self, $path, $dc_vars) = @_;
    13801933
    1381         my $env = $self->provision_member($path, $dc_vars);
     1934        my $env = $self->provision_s4member($path, $dc_vars);
    13821935
    13831936        if (defined $env) {
    1384                 $self->check_or_start($env, ($ENV{SMBD_MAXTIME} or 7500));
    1385 
    1386                 $self->wait_for_start($env);
    1387 
    1388                 $self->{vars}->{member} = $env;
     1937                if (not defined($self->check_or_start($env, "single"))) {
     1938                        return undef;
     1939                }
     1940
     1941                $self->{vars}->{s4member} = $env;
    13891942        }
    13901943
    … …  
    13991952
    14001953        if (defined $env) {
    1401                 $self->check_or_start($env, ($ENV{SMBD_MAXTIME} or 7500));
    1402 
    1403                 $self->wait_for_start($env);
     1954                if (not defined($self->check_or_start($env, "single"))) {
     1955                        return undef;
     1956                }
    14041957
    14051958                $self->{vars}->{rpc_proxy} = $env;
    … …  
    14081961}
    14091962
    1410 sub setup_dc($$)
     1963sub setup_ad_dc_ntvfs($$)
    14111964{
    14121965        my ($self, $path) = @_;
    14131966
    1414         my $env = $self->provision_dc($path);
     1967        my $env = $self->provision_ad_dc_ntvfs($path);
    14151968        if (defined $env) {
    1416                 $self->check_or_start($env,
    1417                         ($ENV{SMBD_MAXTIME} or 7500));
    1418 
    1419                 $self->wait_for_start($env);
    1420 
    1421                 $self->{vars}->{dc} = $env;
     1969                if (not defined($self->check_or_start($env, "standard"))) {
     1970                    warn("Failed to start ad_dc_ntvfs");
     1971                        return undef;
     1972                }
     1973
     1974                $self->{vars}->{ad_dc_ntvfs} = $env;
     1975        }
     1976        return $env;
     1977}
     1978
     1979sub setup_chgdcpass($$)
     1980{
     1981        my ($self, $path) = @_;
     1982
     1983        my $env = $self->provision_chgdcpass($path);
     1984        if (defined $env) {
     1985                if (not defined($self->check_or_start($env, "single"))) {
     1986                        return undef;
     1987                }
     1988
     1989                $self->{vars}->{chgdcpass} = $env;
    14221990        }
    14231991        return $env;
    … …  
    14301998        my $env = $self->provision_fl2000dc($path);
    14311999        if (defined $env) {
    1432                 $self->check_or_start($env,
    1433                         ($ENV{SMBD_MAXTIME} or 7500));
    1434 
    1435                 $self->wait_for_start($env);
     2000                if (not defined($self->check_or_start($env, "single"))) {
     2001                        return undef;
     2002                }
    14362003
    14372004                $self->{vars}->{fl2000dc} = $env;
    … …  
    14412008}
    14422009
    1443 sub setup_fl2003dc($$)
    1444 {
    1445         my ($self, $path) = @_;
     2010sub setup_fl2003dc($$$)
     2011{
     2012        my ($self, $path, $dc_vars) = @_;
    14462013
    14472014        my $env = $self->provision_fl2003dc($path);
    14482015
    14492016        if (defined $env) {
    1450                 $self->check_or_start($env,
    1451                         ($ENV{SMBD_MAXTIME} or 7500));
    1452 
    1453                 $self->wait_for_start($env);
     2017                if (not defined($self->check_or_start($env, "single"))) {
     2018                        return undef;
     2019                }
     2020
     2021                $env = $self->setup_trust($env, $dc_vars, "external", "--no-aes-keys");
    14542022
    14552023                $self->{vars}->{fl2003dc} = $env;
    … …  
    14582026}
    14592027
    1460 sub setup_fl2008r2dc($$)
    1461 {
    1462         my ($self, $path) = @_;
     2028sub setup_fl2008r2dc($$$)
     2029{
     2030        my ($self, $path, $dc_vars) = @_;
    14632031
    14642032        my $env = $self->provision_fl2008r2dc($path);
    14652033
    14662034        if (defined $env) {
    1467                 $self->check_or_start($env,
    1468                         ($ENV{SMBD_MAXTIME} or 7500));
    1469 
    1470                 $self->wait_for_start($env);
     2035                if (not defined($self->check_or_start($env, "single"))) {
     2036                        return undef;
     2037                }
     2038
     2039                my $upn_array = ["$env->{REALM}.upn"];
     2040                my $spn_array = ["$env->{REALM}.spn"];
     2041
     2042                $self->setup_namespaces($env, $upn_array, $spn_array);
     2043
     2044                $env = $self->setup_trust($env, $dc_vars, "forest", "");
    14712045
    14722046                $self->{vars}->{fl2008r2dc} = $env;
    … …  
    14832057
    14842058        if (defined $env) {
    1485                 $self->check_or_start($env,
    1486                         ($ENV{SMBD_MAXTIME} or 7500));
    1487 
    1488                 $self->wait_for_start($env);
     2059                if (not defined($self->check_or_start($env, "single"))) {
     2060                        return undef;
     2061                }
    14892062
    14902063                $self->{vars}->{vampire_dc} = $env;
    … …  
    14922065                # force replicated DC to update repsTo/repsFrom
    14932066                # for vampired partitions
    1494                 my $samba_tool = $self->bindir_path("samba-tool");
     2067                my $samba_tool =  Samba::bindir_path($self, "samba-tool");
    14952068                my $cmd = "";
    1496                 $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     2069                $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     2070                if (defined($env->{RESOLV_WRAPPER_CONF})) {
     2071                        $cmd .= "RESOLV_WRAPPER_CONF=\"$env->{RESOLV_WRAPPER_CONF}\" ";
     2072                } else {
     2073                        $cmd .= "RESOLV_WRAPPER_HOSTS=\"$env->{RESOLV_WRAPPER_HOSTS}\" ";
     2074                }
    14972075                $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
    1498                 $cmd .= " $samba_tool drs kcc $env->{DC_SERVER}";
     2076                $cmd .= " $samba_tool drs kcc -k no $env->{DC_SERVER}";
     2077                $cmd .= " $env->{CONFIGURATION}";
    14992078                $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
    15002079                unless (system($cmd) == 0) {
    … …  
    15062085                # we need to synchronize data between DCs
    15072086                my $base_dn = "DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
    1508                 $cmd = "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     2087                $cmd = "";
     2088                $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     2089                if (defined($env->{RESOLV_WRAPPER_CONF})) {
     2090                        $cmd .= "RESOLV_WRAPPER_CONF=\"$env->{RESOLV_WRAPPER_CONF}\" ";
     2091                } else {
     2092                        $cmd .= "RESOLV_WRAPPER_HOSTS=\"$env->{RESOLV_WRAPPER_HOSTS}\" ";
     2093                }
    15092094                $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
    1510                 $cmd .= " $samba_tool drs replicate $env->{DC_SERVER} $env->{VAMPIRE_DC_SERVER}";
     2095                $cmd .= " $samba_tool drs replicate $env->{DC_SERVER} $env->{SERVER}";
     2096                $cmd .= " $dc_vars->{CONFIGURATION}";
    15112097                $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
    15122098                # replicate Configuration NC
    … …  
    15272113}
    15282114
     2115sub setup_promoted_dc($$$)
     2116{
     2117        my ($self, $path, $dc_vars) = @_;
     2118
     2119        my $env = $self->provision_promoted_dc($path, $dc_vars);
     2120
     2121        if (defined $env) {
     2122                if (not defined($self->check_or_start($env, "single"))) {
     2123                        return undef;
     2124                }
     2125
     2126                $self->{vars}->{promoted_dc} = $env;
     2127
     2128                # force source and replicated DC to update repsTo/repsFrom
     2129                # for vampired partitions
     2130                my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     2131                my $cmd = "";
     2132                $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     2133                $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
     2134                $cmd .= " $samba_tool drs kcc $env->{DC_SERVER}";
     2135                $cmd .= " $env->{CONFIGURATION}";
     2136                $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
     2137                unless (system($cmd) == 0) {
     2138                        warn("Failed to exec kcc\n$cmd");
     2139                        return undef;
     2140                }
     2141
     2142                my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     2143                my $cmd = "";
     2144                $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     2145                $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
     2146                $cmd .= " $samba_tool drs kcc $env->{SERVER}";
     2147                $cmd .= " $env->{CONFIGURATION}";
     2148                $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
     2149                unless (system($cmd) == 0) {
     2150                        warn("Failed to exec kcc\n$cmd");
     2151                        return undef;
     2152                }
     2153
     2154                # as 'vampired' dc may add data in its local replica
     2155                # we need to synchronize data between DCs
     2156                my $base_dn = "DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
     2157                $cmd = "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     2158                $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
     2159                $cmd .= " $samba_tool drs replicate $env->{DC_SERVER} $env->{SERVER}";
     2160                $cmd .= " $dc_vars->{CONFIGURATION}";
     2161                $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
     2162                # replicate Configuration NC
     2163                my $cmd_repl = "$cmd \"CN=Configuration,$base_dn\"";
     2164                unless(system($cmd_repl) == 0) {
     2165                        warn("Failed to replicate\n$cmd_repl");
     2166                        return undef;
     2167                }
     2168                # replicate Default NC
     2169                $cmd_repl = "$cmd \"$base_dn\"";
     2170                unless(system($cmd_repl) == 0) {
     2171                        warn("Failed to replicate\n$cmd_repl");
     2172                        return undef;
     2173                }
     2174        }
     2175
     2176        return $env;
     2177}
     2178
     2179sub setup_subdom_dc($$$)
     2180{
     2181        my ($self, $path, $dc_vars) = @_;
     2182
     2183        my $env = $self->provision_subdom_dc($path, $dc_vars);
     2184
     2185        if (defined $env) {
     2186                if (not defined($self->check_or_start($env, "single"))) {
     2187                        return undef;
     2188                }
     2189
     2190                $self->{vars}->{subdom_dc} = $env;
     2191
     2192                # force replicated DC to update repsTo/repsFrom
     2193                # for primary domain partitions
     2194                my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     2195                my $cmd = "";
     2196                $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     2197                $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
     2198                $cmd .= " $samba_tool drs kcc $env->{DC_SERVER}";
     2199                $cmd .= " $env->{CONFIGURATION}";
     2200                $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD} --realm=$dc_vars->{DC_REALM}";
     2201                unless (system($cmd) == 0) {
     2202                        warn("Failed to exec kcc\n$cmd");
     2203                        return undef;
     2204                }
     2205
     2206                # as 'subdomain' dc may add data in its local replica
     2207                # we need to synchronize data between DCs
     2208                my $base_dn = "DC=".join(",DC=", split(/\./, $env->{REALM}));
     2209                my $config_dn = "CN=Configuration,DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
     2210                $cmd = "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     2211                $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
     2212                $cmd .= " $samba_tool drs replicate $env->{DC_SERVER} $env->{SUBDOM_DC_SERVER}";
     2213                $cmd .= " $dc_vars->{CONFIGURATION}";
     2214                $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD} --realm=$dc_vars->{DC_REALM}";
     2215                # replicate Configuration NC
     2216                my $cmd_repl = "$cmd \"$config_dn\"";
     2217                unless(system($cmd_repl) == 0) {
     2218                        warn("Failed to replicate\n$cmd_repl");
     2219                        return undef;
     2220                }
     2221                # replicate Default NC
     2222                $cmd_repl = "$cmd \"$base_dn\"";
     2223                unless(system($cmd_repl) == 0) {
     2224                        warn("Failed to replicate\n$cmd_repl");
     2225                        return undef;
     2226                }
     2227        }
     2228
     2229        return $env;
     2230}
     2231
    15292232sub setup_rodc($$$)
    15302233{
    … …  
    15372240        }
    15382241
    1539         $self->check_or_start($env,
    1540                 ($ENV{SMBD_MAXTIME} or 7500));
    1541 
    1542         $self->wait_for_start($env);
     2242        if (not defined($self->check_or_start($env, "single"))) {
     2243            return undef;
     2244        }
     2245
     2246        # force source and replicated DC to update repsTo/repsFrom
     2247        # for vampired partitions
     2248        my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     2249        my $cmd = "";
     2250        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     2251        $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
     2252        $cmd .= " $samba_tool drs kcc -k no $env->{DC_SERVER}";
     2253        $cmd .= " $env->{CONFIGURATION}";
     2254        $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
     2255        unless (system($cmd) == 0) {
     2256            warn("Failed to exec kcc\n$cmd");
     2257            return undef;
     2258        }
     2259
     2260        my $samba_tool =  Samba::bindir_path($self, "samba-tool");
     2261        my $cmd = "";
     2262        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     2263        $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
     2264        $cmd .= " $samba_tool drs kcc -k no $env->{SERVER}";
     2265        $cmd .= " $env->{CONFIGURATION}";
     2266        $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
     2267        unless (system($cmd) == 0) {
     2268            warn("Failed to exec kcc\n$cmd");
     2269            return undef;
     2270        }
     2271
     2272        my $base_dn = "DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
     2273        $cmd = "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     2274        $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
     2275        $cmd .= " $samba_tool drs replicate $env->{SERVER} $env->{DC_SERVER}";
     2276        $cmd .= " $dc_vars->{CONFIGURATION}";
     2277        $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
     2278        # replicate Configuration NC
     2279        my $cmd_repl = "$cmd \"CN=Configuration,$base_dn\"";
     2280        unless(system($cmd_repl) == 0) {
     2281            warn("Failed to replicate\n$cmd_repl");
     2282            return undef;
     2283        }
     2284        # replicate Default NC
     2285        $cmd_repl = "$cmd \"$base_dn\"";
     2286        unless(system($cmd_repl) == 0) {
     2287            warn("Failed to replicate\n$cmd_repl");
     2288            return undef;
     2289        }
    15432290
    15442291        $self->{vars}->{rodc} = $env;
    … …  
    15472294}
    15482295
     2296sub setup_ad_dc($$)
     2297{
     2298        my ($self, $path, $no_nss) = @_;
     2299
     2300        # If we didn't build with ADS, pretend this env was never available
     2301        if (not $self->{target3}->have_ads()) {
     2302               return "UNKNOWN";
     2303        }
     2304
     2305        my $env = $self->provision_ad_dc($path);
     2306        unless ($env) {
     2307                return undef;
     2308        }
     2309
     2310        if (defined($no_nss) and $no_nss) {
     2311                $env->{NSS_WRAPPER_MODULE_SO_PATH} = undef;
     2312                $env->{NSS_WRAPPER_MODULE_FN_PREFIX} = undef;
     2313        }
     2314
     2315        if (not defined($self->check_or_start($env, "single"))) {
     2316            return undef;
     2317        }
     2318
     2319        my $upn_array = ["$env->{REALM}.upn"];
     2320        my $spn_array = ["$env->{REALM}.spn"];
     2321
     2322        $self->setup_namespaces($env, $upn_array, $spn_array);
     2323
     2324        $self->{vars}->{ad_dc} = $env;
     2325        return $env;
     2326}
     2327
     2328sub setup_none($$)
     2329{
     2330        my ($self, $path) = @_;
     2331
     2332        my $ret = {
     2333                KRB5_CONFIG => abs_path($path) . "/no_krb5.conf",
     2334                SAMBA_PID => -1,
     2335        }
     2336}
     2337
    154923381;

  • vendor/current/selftest/valgrind_run

    r414 r988  
    55shift 1
    66
    7 CMD="$ENV valgrind -q --db-attach=yes --num-callers=30 $@"
     7CMD="$ENV valgrind --num-callers=30
     8--trace-children=yes --log-file=valgrind.%p.log
     9${VALGRIND_OPT- --time-stamp=yes --track-fds=yes --read-var-info=yes --track-origins=yes --leak-check=yes}
     10$@"
     11
    812echo $CMD
    913eval $CMD
Note: See TracChangeset for help on using the changeset viewer.