Ignore:
Timestamp:
Nov 14, 2012, 12:59:34 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to 3.6.0

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r414 r740  
    1010use FindBin qw($RealBin);
    1111use POSIX;
     12use SocketWrapper;
    1213
    1314sub new($$$$$) {
    14         my ($classname, $bindir, $ldap, $setupdir, $exeext) = @_;
     15        my ($classname, $bindir, $ldap, $srcdir, $exeext) = @_;
    1516        $exeext = "" unless defined($exeext);
    16         my $self = { 
    17                 vars => {}, 
    18                 ldap => $ldap, 
    19                 bindir => $bindir, 
    20                 setupdir => $setupdir,
     17        my $self = {
     18                vars => {},
     19                ldap => $ldap,
     20                bindir => $bindir,
     21                srcdir => $srcdir,
    2122                exeext => $exeext
    2223        };
    … …  
    2829        my ($self, $path) = @_;
    2930
    30         return "$self->{bindir}/$path$self->{exeext}";
     31        my $valpath = "$self->{bindir}/$path$self->{exeext}";
     32
     33        return $valpath if (-f $valpath);
     34        return $path;
     35}
     36
     37sub scriptdir_path($$) {
     38        my ($self, $path) = @_;
     39        return "$self->{srcdir}/source4/scripting/$path";
    3140}
    3241
    … …  
    5463        }
    5564        while (system("$ldbsearch -H $uri -s base -b \"\" supportedLDAPVersion > /dev/null") != 0) {
    56                 $count++;
     65                $count++;
    5766                if ($count > 40) {
    58                     $self->slapd_stop($env_vars);
    59                     return 0;
     67                        $self->slapd_stop($env_vars);
     68                        return 0;
    6069                }
    6170                sleep(1);
    … …  
    6877        my ($self, $envvars) = @_;
    6978        if ($self->{ldap} eq "fedora-ds") {
    70                 system("$envvars->{LDAPDIR}/slapd-samba4/stop-slapd");
     79                system("$envvars->{LDAPDIR}/slapd-$envvars->{LDAP_INSTANCE}/stop-slapd");
    7180        } elsif ($self->{ldap} eq "openldap") {
    72                 open(IN, "<$envvars->{OPENLDAP_PIDFILE}") or
    73                         die("unable to open slapd pid file: $envvars->{OPENLDAP_PIDFILE}");
     81                unless (open(IN, "<$envvars->{OPENLDAP_PIDFILE}")) {
     82                        warn("unable to open slapd pid file: $envvars->{OPENLDAP_PIDFILE}");
     83                        return 0;
     84                }
    7485                kill 9, <IN>;
    7586                close(IN);
    … …  
    7889}
    7990
    80 sub check_or_start($$$) 
     91sub check_or_start($$$)
    8192{
    8293        my ($self, $env_vars, $max_time) = @_;
    … …  
    8798        unlink($env_vars->{SAMBA_TEST_LOG});
    8899       
    89         print "STARTING SAMBA... ";
     100        my $pwd = `pwd`;
     101        print "STARTING SAMBA for $ENV{ENVNAME}\n";
    90102        my $pid = fork();
    91103        if ($pid == 0) {
    … …  
    102114                if (defined($ENV{SAMBA_VALGRIND})) {
    103115                    $valgrind = $ENV{SAMBA_VALGRIND};
    104                 } 
    105 
    106                 $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG}; 
     116                }
     117
     118                $ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
    107119                $ENV{WINBINDD_SOCKET_DIR} = $env_vars->{WINBINDD_SOCKET_DIR};
    108120
    … …  
    114126                # Start slapd before samba, but with the fifo on stdin
    115127                if (defined($self->{ldap})) {
    116                     $self->slapd_start($env_vars) or
    117                         die("couldn't start slapd (main run)");
     128                        unless($self->slapd_start($env_vars)) {
     129                                warn("couldn't start slapd (main run)");
     130                                return undef;
     131                        }
    118132                }
    119133
    … …  
    129143                # allow selection of the process model using
    130144                # the environment varibale SAMBA_PROCESS_MODEL
    131                 # that allows us to change the process model for 
     145                # that allows us to change the process model for
    132146                # individual machines in the build farm
    133147                my $model = "single";
    … …  
    135149                        $model = $ENV{SAMBA_PROCESS_MODEL};
    136150                }
    137                 my $ret = system("$valgrind $samba $optarg $env_vars->{CONFIGURATION} -M $model -i");
    138                 if ($? == -1) {
    139                         print "Unable to start $samba: $ret: $!\n";
     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";
    140156                        exit 1;
    141157                }
     158                my $exit = ($ret >> 8);
    142159                unlink($env_vars->{SAMBA_TEST_FIFO});
    143                 my $exit = $? >> 8;
    144                 if ( $ret == 0 ) {
    145                         print "$samba exits with status $exit\n";
     160                if ($ret == 0) {
     161                        print "$samba exited with no error\n";
     162                        exit 0;
    146163                } elsif ( $ret & 127 ) {
    147164                        print "$samba got signal ".($ret & 127)." and exits with $exit!\n";
    148165                } else {
    149                         $ret = $? >> 8;
    150166                        print "$samba failed with status $exit!\n";
     167                }
     168                if ($exit == 0) {
     169                        $exit = -1;
    151170                }
    152171                exit $exit;
    … …  
    166185        sleep 2;
    167186
    168         # This will return quickly when things are up, but be slow if we 
    169         # need to wait for (eg) SSL init 
     187        # This will return quickly when things are up, but be slow if we
     188        # need to wait for (eg) SSL init
    170189        my $nmblookup = $self->bindir_path("nmblookup");
    171190        system("$nmblookup $testenv_vars->{CONFIGURATION} $testenv_vars->{SERVER}");
    … …  
    192211        open(LDIF, "|$ldbadd -H $file >/dev/null");
    193212        print LDIF $ldif;
    194         return close(LDIF);
     213        return(close(LDIF));
    195214}
    196215
    … …  
    200219
    201220        return $self->write_ldb_file("$privatedir/wins_config.ldb", "
    202 dn: name=TORTURE_6,CN=PARTNERS
     221dn: name=TORTURE_11,CN=PARTNERS
    203222objectClass: wreplPartner
    204 name: TORTURE_6
    205 address: 127.0.0.6
     223name: TORTURE_11
     224address: 127.0.0.11
    206225pullInterval: 0
    207226pushChangeCount: 0
    … …  
    212231sub mk_fedora_ds($$)
    213232{
    214         my ($self, $ldapdir) = @_;
     233        my ($self, $ctx) = @_;
    215234
    216235        #Make the subdirectory be as fedora DS would expect
    217         my $fedora_ds_dir = "$ldapdir/slapd-samba4";
    218 
    219         my $pidfile = "$fedora_ds_dir/logs/slapd-samba4.pid";
     236        my $fedora_ds_dir = "$ctx->{ldapdir}/slapd-$ctx->{ldap_instance}";
     237
     238        my $pidfile = "$fedora_ds_dir/logs/slapd-$ctx->{ldap_instance}.pid";
    220239
    221240        return ($fedora_ds_dir, $pidfile);
    … …  
    224243sub mk_openldap($$)
    225244{
    226         my ($self, $ldapdir) = @_;
    227 
    228         my $slapd_conf_d = "$ldapdir/slapd.d";
    229         my $pidfile = "$ldapdir/slapd.pid";
     245        my ($self, $ctx) = @_;
     246
     247        my $slapd_conf_d = "$ctx->{ldapdir}/slapd.d";
     248        my $pidfile = "$ctx->{ldapdir}/slapd.pid";
    230249
    231250        return ($slapd_conf_d, $pidfile);
    … …  
    261280        close(DHFILE);
    262281
    263         #Likewise, we pregenerate the key material.  This allows the 
     282        #Likewise, we pregenerate the key material.  This allows the
    264283        #other certificates to be pre-generated
    265284        open(KEYFILE, ">$keyfile");
    … …  
    303322EOF
    304323
    305         #generated with 
     324        #generated with
    306325        # hxtool issue-certificate --self-signed --issue-ca \
    307326        # --ca-private-key="FILE:$KEYFILE" \
    … …  
    327346EOF
    328347
    329         #generated with GNUTLS internally in Samba. 
     348        #generated with GNUTLS internally in Samba.
    330349
    331350        open(CERTFILE, ">$certfile");
    … …  
    441460}
    442461
    443 #
    444 # provision_raw_prepare() is also used by Samba34.pm!
    445 #
    446 sub provision_raw_prepare($$$$$$$)
    447 {
    448         my ($self, $prefix, $server_role, $netbiosname, $netbiosalias, $swiface, $password, $kdc_ipv4) = @_;
    449         my $ctx;
    450 
    451         -d $prefix or mkdir($prefix, 0777) or die("Unable to create $prefix");
    452         my $prefix_abs = abs_path($prefix);
    453 
    454         die ("prefix=''") if $prefix_abs eq "";
    455         die ("prefix='/'") if $prefix_abs eq "/";
    456 
    457         (system("rm -rf $prefix_abs/*") == 0) or die("Unable to clean up");
    458 
    459         $ctx->{prefix} = $prefix;
    460         $ctx->{prefix_abs} = $prefix_abs;
    461         $ctx->{server_role} = $server_role;
    462         $ctx->{netbiosname} = $netbiosname;
    463         $ctx->{netbiosalias} = $netbiosalias;
    464         $ctx->{swiface} = $swiface;
    465         $ctx->{password} = $password;
    466         $ctx->{kdc_ipv4} = $kdc_ipv4;
    467 
    468         $ctx->{server_loglevel} = 1;
    469         $ctx->{username} = "Administrator";
    470         $ctx->{domain} = "SAMBADOMAIN";
    471         $ctx->{realm} = "SAMBA.EXAMPLE.COM";
    472         $ctx->{dnsname} = "samba.example.com";
    473         $ctx->{basedn} = "dc=samba,dc=example,dc=com";
    474 
    475         my $unix_name = ($ENV{USER} or $ENV{LOGNAME} or `whoami`);
    476         chomp $unix_name;
    477         $ctx->{unix_name} = $unix_name;
    478         $ctx->{unix_uid} = $>;
    479         $ctx->{unix_gids_str} = $);
    480         @{$ctx->{unix_gids}} = split(" ", $ctx->{unix_gids_str});
    481 
    482         $ctx->{etcdir} = "$prefix_abs/etc";
    483         $ctx->{piddir} = "$prefix_abs/pid";
    484         $ctx->{smb_conf} = "$ctx->{etcdir}/smb.conf";
    485         $ctx->{krb5_conf} = "$ctx->{etcdir}/krb5.conf";
    486         $ctx->{privatedir} = "$prefix_abs/private";
    487         $ctx->{ncalrpcdir} = "$prefix_abs/ncalrpc";
    488         $ctx->{lockdir} = "$prefix_abs/lockdir";
    489         $ctx->{winbindd_socket_dir} = "$prefix_abs/winbindd_socket";
    490         $ctx->{winbindd_privileged_socket_dir} = "$prefix_abs/winbindd_privileged_socket";
    491         $ctx->{ntp_signd_socket_dir} = "$prefix_abs/ntp_signd_socket";
    492         $ctx->{nsswrap_passwd} = "$ctx->{etcdir}/passwd";
    493         $ctx->{nsswrap_group} = "$ctx->{etcdir}/group";
    494 
    495         $ctx->{tlsdir} = "$ctx->{privatedir}/tls";
    496 
    497         $ctx->{ipv4} = "127.0.0.$swiface";
    498         $ctx->{interfaces} = "$ctx->{ipv4}/8";
    499 
    500         $ctx->{localbasedn} = $ctx->{basedn};
    501         $ctx->{localbasedn} = "CN=$netbiosname" if $server_role eq "member server";
    502 
    503         push(@{$ctx->{directories}}, $ctx->{privatedir});
    504         push(@{$ctx->{directories}}, $ctx->{etcdir});
    505         push(@{$ctx->{directories}}, $ctx->{piddir});
    506         push(@{$ctx->{directories}}, $ctx->{ncalrpcdir});
    507         push(@{$ctx->{directories}}, $ctx->{lockdir});
    508 
    509         $ctx->{smb_conf_extra_options} = "";
    510 
    511         my @provision_options = ();
    512         push (@provision_options, "NSS_WRAPPER_PASSWD=\"$ctx->{nsswrap_passwd}\"");
    513         push (@provision_options, "NSS_WRAPPER_GROUP=\"$ctx->{nsswrap_group}\"");
    514         if (defined($ENV{GDB_PROVISION})) {
    515                 push (@provision_options, "gdb --args");
    516         }
    517         if (defined($ENV{VALGRIND_PROVISION})) {
    518                 push (@provision_options, "valgrind");
    519         }
    520         if (defined($ENV{PYTHON})) {
    521                 push (@provision_options, $ENV{PYTHON});
    522         }
    523         push (@provision_options, "$self->{setupdir}/provision");
    524         push (@provision_options, "--configfile=$ctx->{smb_conf}");
    525         push (@provision_options, "--host-name=$ctx->{netbiosname}");
    526         push (@provision_options, "--host-ip=$ctx->{ipv4}");
    527         push (@provision_options, "--quiet");
    528         push (@provision_options, "--domain=$ctx->{domain}");
    529         push (@provision_options, "--realm=$ctx->{realm}");
    530         push (@provision_options, "--adminpass=$ctx->{password}");
    531         push (@provision_options, "--krbtgtpass=krbtgt$ctx->{password}");
    532         push (@provision_options, "--machinepass=machine$ctx->{password}");
    533         push (@provision_options, "--root=$ctx->{unix_name}");
    534         push (@provision_options, "--server-role=\"$ctx->{server_role}\"");
    535 
    536         @{$ctx->{provision_options}} = @provision_options;
    537 
    538         return $ctx;
    539 }
    540 
    541 #
    542 # provision_raw_step1() is also used by Samba34.pm!
    543 #
    544 # Step1 creates the basic configuration
    545 #
    546 sub provision_raw_step1($$)
     462sub mk_krb5_conf($$)
    547463{
    548464        my ($self, $ctx) = @_;
    549465
    550         mkdir($_, 0777) foreach (@{$ctx->{directories}});
    551 
    552         open(CONFFILE, ">$ctx->{smb_conf}")
    553                 or die("can't open $ctx->{smb_conf}$?");
    554         print CONFFILE "
    555 [global]
    556         netbios name = $ctx->{netbiosname}
    557         netbios aliases = $ctx->{netbiosalias}
    558         workgroup = $ctx->{domain}
    559         realm = $ctx->{realm}
    560         private dir = $ctx->{privatedir}
    561         pid directory = $ctx->{piddir}
    562         ncalrpc dir = $ctx->{ncalrpcdir}
    563         lock dir = $ctx->{lockdir}
    564         setup directory = $self->{setupdir}
    565         modules dir = $self->{bindir}/modules
    566         winbindd socket directory = $ctx->{winbindd_socket_dir}
    567         winbindd privileged socket directory = $ctx->{winbindd_privileged_socket_dir}
    568         ntp signd socket directory = $ctx->{ntp_signd_socket_dir}
    569         winbind separator = /
    570         name resolve order = bcast
    571         interfaces = $ctx->{interfaces}
    572         tls dh params file = $ctx->{tlsdir}/dhparms.pem
    573         panic action = $RealBin/gdb_backtrace \%PID% \%PROG%
    574         wins support = yes
    575         server role = $ctx->{server_role}
    576         notify:inotify = false
    577         ldb:nosync = true
    578 #We don't want to pass our self-tests if the PAC code is wrong
    579         gensec:require_pac = true
    580         log level = $ctx->{server_loglevel}
    581         lanman auth = Yes
    582 
    583         # Begin extra options
    584         $ctx->{smb_conf_extra_options}
    585         # End extra options
    586 ";
    587         close(CONFFILE);
    588 
    589         $self->mk_keyblobs($ctx->{tlsdir});
    590 
    591         open(KRB5CONF, ">$ctx->{krb5_conf}")
    592                 or die("can't open $ctx->{krb5_conf}$?");
     466        unless (open(KRB5CONF, ">$ctx->{krb5_conf}")) {
     467                warn("can't open $ctx->{krb5_conf}$?");
     468                return undef;
     469        }
    593470        print KRB5CONF "
    594471#Generated krb5.conf for $ctx->{realm}
    … …  
    600477 ticket_lifetime = 24h
    601478 forwardable = yes
     479 allow_weak_crypto = yes
    602480
    603481[realms]
    … …  
    630508";
    631509        close(KRB5CONF);
     510}
     511
     512sub provision_raw_prepare($$$$$$$$$$)
     513{
     514        my ($self, $prefix, $server_role, $netbiosname, $netbiosalias,
     515            $domain, $realm, $functional_level,
     516            $swiface, $password, $kdc_ipv4) = @_;
     517        my $ctx;
     518
     519        unless(-d $prefix or mkdir($prefix, 0777)) {
     520                warn("Unable to create $prefix");
     521                return undef;
     522        }
     523        my $prefix_abs = abs_path($prefix);
     524
     525        die ("prefix=''") if $prefix_abs eq "";
     526        die ("prefix='/'") if $prefix_abs eq "/";
     527
     528        unless (system("rm -rf $prefix_abs/*") == 0) {
     529                warn("Unable to clean up");
     530        }
     531
     532        $ctx->{prefix} = $prefix;
     533        $ctx->{prefix_abs} = $prefix_abs;
     534       
     535        $ctx->{dns_host_file} = "$ENV{SELFTEST_PREFIX}/dns_host_file";
     536
     537        $ctx->{server_role} = $server_role;
     538        $ctx->{netbiosname} = $netbiosname;
     539        $ctx->{netbiosalias} = $netbiosalias;
     540        $ctx->{swiface} = $swiface;
     541        $ctx->{password} = $password;
     542        $ctx->{kdc_ipv4} = $kdc_ipv4;
     543
     544        $ctx->{server_loglevel} =$ENV{SERVER_LOG_LEVEL} || 1;
     545        $ctx->{username} = "Administrator";
     546        $ctx->{domain} = $domain;
     547        $ctx->{realm} = uc($realm);
     548        $ctx->{dnsname} = lc($realm);
     549        $ctx->{sid_generator} = "internal";
     550
     551        $ctx->{functional_level} = $functional_level;
     552
     553        my $unix_name = ($ENV{USER} or $ENV{LOGNAME} or `whoami`);
     554        chomp $unix_name;
     555        $ctx->{unix_name} = $unix_name;
     556        $ctx->{unix_uid} = $>;
     557        $ctx->{unix_gids_str} = $);
     558        @{$ctx->{unix_gids}} = split(" ", $ctx->{unix_gids_str});
     559
     560        $ctx->{etcdir} = "$prefix_abs/etc";
     561        $ctx->{piddir} = "$prefix_abs/pid";
     562        $ctx->{smb_conf} = "$ctx->{etcdir}/smb.conf";
     563        $ctx->{krb5_conf} = "$ctx->{etcdir}/krb5.conf";
     564        $ctx->{privatedir} = "$prefix_abs/private";
     565        $ctx->{ncalrpcdir} = "$prefix_abs/ncalrpc";
     566        $ctx->{lockdir} = "$prefix_abs/lockdir";
     567        $ctx->{winbindd_socket_dir} = "$prefix_abs/winbindd_socket";
     568        $ctx->{winbindd_privileged_socket_dir} = "$prefix_abs/winbindd_privileged_socket";
     569        $ctx->{ntp_signd_socket_dir} = "$prefix_abs/ntp_signd_socket";
     570        $ctx->{nsswrap_passwd} = "$ctx->{etcdir}/passwd";
     571        $ctx->{nsswrap_group} = "$ctx->{etcdir}/group";
     572
     573        $ctx->{tlsdir} = "$ctx->{privatedir}/tls";
     574
     575        $ctx->{ipv4} = "127.0.0.$swiface";
     576        $ctx->{interfaces} = "$ctx->{ipv4}/8";
     577
     578        push(@{$ctx->{directories}}, $ctx->{privatedir});
     579        push(@{$ctx->{directories}}, $ctx->{etcdir});
     580        push(@{$ctx->{directories}}, $ctx->{piddir});
     581        push(@{$ctx->{directories}}, $ctx->{ncalrpcdir});
     582        push(@{$ctx->{directories}}, $ctx->{lockdir});
     583
     584        $ctx->{smb_conf_extra_options} = "";
     585
     586        my @provision_options = ();
     587        push (@provision_options, "NSS_WRAPPER_PASSWD=\"$ctx->{nsswrap_passwd}\"");
     588        push (@provision_options, "NSS_WRAPPER_GROUP=\"$ctx->{nsswrap_group}\"");
     589        if (defined($ENV{GDB_PROVISION})) {
     590                push (@provision_options, "gdb --args");
     591                if (!defined($ENV{PYTHON})) {
     592                    push (@provision_options, "env");
     593                    push (@provision_options, "python");
     594                }
     595        }
     596        if (defined($ENV{VALGRIND_PROVISION})) {
     597                push (@provision_options, "valgrind");
     598                if (!defined($ENV{PYTHON})) {
     599                    push (@provision_options, "env");
     600                    push (@provision_options, "python");
     601                }
     602        }
     603        if (defined($ENV{PYTHON})) {
     604                push (@provision_options, $ENV{PYTHON});
     605        }
     606        push (@provision_options, "$self->{srcdir}/source4/setup/provision");
     607        push (@provision_options, "--configfile=$ctx->{smb_conf}");
     608        push (@provision_options, "--host-name=$ctx->{netbiosname}");
     609        push (@provision_options, "--host-ip=$ctx->{ipv4}");
     610        push (@provision_options, "--quiet");
     611        push (@provision_options, "--domain=$ctx->{domain}");
     612        push (@provision_options, "--realm=$ctx->{realm}");
     613        push (@provision_options, "--adminpass=$ctx->{password}");
     614        push (@provision_options, "--krbtgtpass=krbtgt$ctx->{password}");
     615        push (@provision_options, "--machinepass=machine$ctx->{password}");
     616        push (@provision_options, "--root=$ctx->{unix_name}");
     617        push (@provision_options, "--server-role=\"$ctx->{server_role}\"");
     618        push (@provision_options, "--function-level=\"$ctx->{functional_level}\"");
     619
     620        @{$ctx->{provision_options}} = @provision_options;
     621
     622        return $ctx;
     623}
     624
     625#
     626# Step1 creates the basic configuration
     627#
     628sub provision_raw_step1($$)
     629{
     630        my ($self, $ctx) = @_;
     631
     632        mkdir($_, 0777) foreach (@{$ctx->{directories}});
     633
     634        unless (open(CONFFILE, ">$ctx->{smb_conf}")) {
     635                warn("can't open $ctx->{smb_conf}$?");
     636                return undef;
     637        }
     638        print CONFFILE "
     639[global]
     640        netbios name = $ctx->{netbiosname}
     641        netbios aliases = $ctx->{netbiosalias}
     642        posix:eadb = $ctx->{lockdir}/eadb.tdb
     643        workgroup = $ctx->{domain}
     644        realm = $ctx->{realm}
     645        private dir = $ctx->{privatedir}
     646        pid directory = $ctx->{piddir}
     647        ncalrpc dir = $ctx->{ncalrpcdir}
     648        lock dir = $ctx->{lockdir}
     649        winbindd socket directory = $ctx->{winbindd_socket_dir}
     650        winbindd privileged socket directory = $ctx->{winbindd_privileged_socket_dir}
     651        ntp signd socket directory = $ctx->{ntp_signd_socket_dir}
     652        winbind separator = /
     653        name resolve order = file bcast
     654        interfaces = $ctx->{interfaces}
     655        tls dh params file = $ctx->{tlsdir}/dhparms.pem
     656        panic action = $RealBin/gdb_backtrace \%PID% \%PROG%
     657        wins support = yes
     658        server role = $ctx->{server_role}
     659        server services = +echo
     660        notify:inotify = false
     661        ldb:nosync = true
     662#We don't want to pass our self-tests if the PAC code is wrong
     663        gensec:require_pac = true
     664        log level = $ctx->{server_loglevel}
     665        lanman auth = Yes
     666        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}
     670        dreplsrv:periodic_startup_interval = 0
     671";
     672
     673        if (defined($ctx->{sid_generator}) && $ctx->{sid_generator} ne "internal") {
     674                print CONFFILE "
     675        sid generator = $ctx->{sid_generator}";
     676        }
     677
     678        print CONFFILE "
     679
     680        # Begin extra options
     681        $ctx->{smb_conf_extra_options}
     682        # End extra options
     683";
     684        close(CONFFILE);
     685
     686        $self->mk_keyblobs($ctx->{tlsdir});
     687
     688        $self->mk_krb5_conf($ctx);
    632689
    633690        open(PWD, ">$ctx->{nsswrap_passwd}");
    … …  
    652709
    653710#Ensure the config file is valid before we start
    654         my $testparm = $self->bindir_path("testparm");
     711        my $testparm = $self->scriptdir_path("bin/testparm");
    655712        if (system("$testparm $configuration -v --suppress-prompt >/dev/null 2>&1") != 0) {
    656713                system("$testparm -v --suppress-prompt $configuration >&2");
    657                 die("Failed to create a valid smb.conf configuration $testparm!");
    658         }
    659 
    660         (system("($testparm $configuration -v --suppress-prompt --parameter-name=\"netbios name\" --section-name=global 2> /dev/null | grep -i \"^$ctx->{netbiosname}\" ) >/dev/null 2>&1") == 0) or die("Failed to create a valid smb.conf configuration! $self->{bindir}/testparm $configuration -v --suppress-prompt --parameter-name=\"netbios name\" --section-name=global");
     714                warn("Failed to create a valid smb.conf configuration $testparm!");
     715                return undef;
     716        }
     717        unless (system("($testparm $configuration -v --suppress-prompt --parameter-name=\"netbios name\" --section-name=global 2> /dev/null | grep -i \"^$ctx->{netbiosname}\" ) >/dev/null 2>&1") == 0) {
     718                warn("Failed to create a valid smb.conf configuration! $testparm $configuration -v --suppress-prompt --parameter-name=\"netbios name\" --section-name=global");
     719                return undef;
     720        }
    661721
    662722        my $ret = {
    … …  
    672732                PASSWORD => $ctx->{password},
    673733                LDAPDIR => $ctx->{ldapdir},
     734                LDAP_INSTANCE => $ctx->{ldap_instance},
    674735                WINBINDD_SOCKET_DIR => $ctx->{winbindd_socket_dir},
    675736                NCALRPCDIR => $ctx->{ncalrpcdir},
    … …  
    689750
    690751#
    691 # provision_raw_step2() is also used by Samba34.pm!
    692 #
    693752# Step2 runs the provision script
    694753#
    … …  
    698757
    699758        my $provision_cmd = join(" ", @{$ctx->{provision_options}});
    700         (system($provision_cmd) == 0) or die("Unable to provision: \n$provision_cmd\n");
     759        unless (system($provision_cmd) == 0) {
     760                warn("Unable to provision: \n$provision_cmd\n");
     761                return undef;
     762        }
    701763
    702764        return $ret;
    703765}
    704766
    705 sub provision($$$$$$$)
    706 {
    707         my ($self, $prefix, $server_role, $netbiosname, $netbiosalias, $swiface, $password, $kdc_ipv4) = @_;
     767sub provision($$$$$$$$$)
     768{
     769        my ($self, $prefix, $server_role, $netbiosname, $netbiosalias,
     770            $domain, $realm, $functional_level,
     771            $swiface, $password, $kdc_ipv4, $extra_smbconf_options) = @_;
    708772
    709773        my $ctx = $self->provision_raw_prepare($prefix, $server_role,
    710774                                               $netbiosname, $netbiosalias,
     775                                               $domain, $realm, $functional_level,
    711776                                               $swiface, $password, $kdc_ipv4);
    712777
    … …  
    715780        push(@{$ctx->{directories}}, "$ctx->{tmpdir}/test1");
    716781        push(@{$ctx->{directories}}, "$ctx->{tmpdir}/test2");
    717 
     782        my $msdfs = "no";
     783        $msdfs = "yes" if ($server_role eq "domain controller");
    718784        $ctx->{smb_conf_extra_options} = "
    719785
    720786        max xmit = 32K
    721787        server max protocol = SMB2
     788        $extra_smbconf_options
     789        host msdfs = $msdfs
     790        lanman auth = yes
    722791
    723792[tmp]
    724793        path = $ctx->{tmpdir}
    725794        read only = no
    726         posix:sharedelay = 100000
    727         posix:eadb = $ctx->{lockdir}/eadb.tdb
     795        posix:sharedelay = 10000
    728796        posix:oplocktimeout = 3
    729797        posix:writetimeupdatedelay = 500000
    … …  
    732800        path = $ctx->{tmpdir}/test1
    733801        read only = no
    734         posix:sharedelay = 100000
    735         posix:eadb = $ctx->{lockdir}/eadb.tdb
     802        posix:sharedelay = 10000
    736803        posix:oplocktimeout = 3
    737         posix:writetimeupdatedelay = 500000
     804        posix:writetimeupdatedelay = 50000
    738805
    739806[test2]
    740807        path = $ctx->{tmpdir}/test2
    741808        read only = no
    742         posix:sharedelay = 100000
    743         posix:eadb = $ctx->{lockdir}/eadb.tdb
     809        posix:sharedelay = 10000
    744810        posix:oplocktimeout = 3
    745         posix:writetimeupdatedelay = 500000
     811        posix:writetimeupdatedelay = 50000
    746812
    747813[cifs]
    … …  
    779845                $ldap_uri = "ldapi://$ldap_uri";
    780846                $ctx->{ldap_uri} = $ldap_uri;
     847                if ($self->{ldap} eq "fedora-ds") {
     848                        $ctx->{sid_generator} = "backend";
     849                }
     850
     851                $ctx->{ldap_instance} = lc($ctx->{netbiosname});
    781852        }
    782853
    783854        my $ret = $self->provision_raw_step1($ctx);
     855        unless (defined $ret) {
     856                return undef;
     857        }
    784858
    785859        if (defined($self->{ldap})) {
    786                 $ret->{LDAP_URI} = $ctx->{ldap_uri};
     860                $ret->{LDAP_URI} = $ctx->{ldap_uri};
    787861                push (@{$ctx->{provision_options}}, "--ldap-backend-type=" . $self->{ldap});
     862                push (@{$ctx->{provision_options}}, "--ldap-backend-nosync");
    788863                if ($self->{ldap} eq "openldap") {
    789                         push (@{$ctx->{provision_options}}, "--slapd-path=" . $ENV{OPENLDAP_SLAPD});
    790                         ($ret->{SLAPD_CONF_D}, $ret->{OPENLDAP_PIDFILE}) = $self->mk_openldap($ctx->{ldapdir}) or die("Unable to create openldap directories");
     864                        push (@{$ctx->{provision_options}}, "--slapd-path=" . $ENV{OPENLDAP_SLAPD});
     865                        ($ret->{SLAPD_CONF_D}, $ret->{OPENLDAP_PIDFILE}) = $self->mk_openldap($ctx) or die("Unable to create openldap directories");
    791866
    792867                } elsif ($self->{ldap} eq "fedora-ds") {
    793868                        push (@{$ctx->{provision_options}}, "--slapd-path=" . "$ENV{FEDORA_DS_ROOT}/sbin/ns-slapd");
    794869                        push (@{$ctx->{provision_options}}, "--setup-ds-path=" . "$ENV{FEDORA_DS_ROOT}/sbin/setup-ds.pl");
    795                         ($ret->{FEDORA_DS_DIR}, $ret->{FEDORA_DS_PIDFILE}) = $self->mk_fedora_ds($ctx->{ldapdir}) or die("Unable to create fedora ds directories");
    796                 }
    797 
    798         }
    799 
    800         $ret = $self->provision_raw_step2($ctx, $ret);
    801 
    802         return $ret;
     870                        ($ret->{FEDORA_DS_DIR}, $ret->{FEDORA_DS_PIDFILE}) = $self->mk_fedora_ds($ctx) or die("Unable to create fedora ds directories");
     871                }
     872
     873        }
     874
     875        return $self->provision_raw_step2($ctx, $ret);
    803876}
    804877
    … …  
    810883        my $ret = $self->provision($prefix,
    811884                                   "member server",
    812                                    "localmember3",
    813885                                   "localmember",
     886                                   "member3",
     887                                   "SAMBADOMAIN",
     888                                   "samba.example.com",
     889                                   "2008",
    814890                                   3,
    815                                    "localmemberpass",
    816                                    $dcvars->{SERVER_IP});
    817 
    818         $ret or die("Unable to provision");
    819 
    820         my $net = $self->bindir_path("net");
     891                                   "locMEMpass3",
     892                                   $dcvars->{SERVER_IP},
     893                                   "");
     894        unless ($ret) {
     895                return undef;
     896        }
     897
     898        my $samba_tool = $self->bindir_path("samba-tool");
    821899        my $cmd = "";
    822900        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
    823901        $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
    824         $cmd .= "$net join $ret->{CONFIGURATION} $dcvars->{DOMAIN} member";
    825         $cmd .= " -U$dcvars->{USERNAME}\%$dcvars->{PASSWORD}";
    826 
    827         system($cmd) == 0 or die("Join failed\n$cmd");
    828 
    829         $ret->{DC_SERVER} = $dcvars->{SERVER};
    830         $ret->{DC_SERVER_IP} = $dcvars->{SERVER_IP};
    831         $ret->{DC_NETBIOSNAME} = $dcvars->{NETBIOSNAME};
    832         $ret->{DC_NETBIOSALIAS} = $dcvars->{NETBIOSALIAS};
    833         $ret->{DC_USERNAME} = $dcvars->{USERNAME};
    834         $ret->{DC_PASSWORD} = $dcvars->{PASSWORD};
     902        $cmd .= "$samba_tool join $ret->{CONFIGURATION} $dcvars->{REALM} member";
     903        $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
     904
     905        unless (system($cmd) == 0) {
     906                warn("Join failed\n$cmd");
     907                return undef;
     908        }
     909
     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};
     916
     917        $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
     918        $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
     919        $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
     920        $ret->{DC_NETBIOSALIAS} = $dcvars->{DC_NETBIOSALIAS};
     921        $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
     922        $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
     923
     924        return $ret;
     925}
     926
     927sub provision_rpc_proxy($$$)
     928{
     929        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
     935";
     936
     937        my $ret = $self->provision($prefix,
     938                                   "member server",
     939                                   "localrpcproxy",
     940                                   "rpcproxy4",
     941                                   "SAMBADOMAIN",
     942                                   "samba.example.com",
     943                                   "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};
     971
     972        return $ret;
     973}
     974
     975sub provision_vampire_dc($$$)
     976{
     977        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'.
     981        my $ctx = $self->provision_raw_prepare($prefix, "domain controller",
     982                                               "localvampiredc",
     983                                               "dc2",
     984                                               "SAMBADOMAIN",
     985                                               "samba.example.com",
     986                                               "2008",
     987                                               2, $dcvars->{PASSWORD},
     988                                               $dcvars->{SERVER_IP});
     989
     990        $ctx->{smb_conf_extra_options} = "
     991        max xmit = 32K
     992        server max protocol = SMB2
     993
     994[sysvol]
     995        path = $ctx->{lockdir}/sysvol
     996        read only = yes
     997
     998[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};
    8351032
    8361033        return $ret;
    … …  
    8441041        my $ret = $self->provision($prefix,
    8451042                                   "domain controller",
    846                                    "localdc1",
    8471043                                   "localdc",
     1044                                   "dc1",
     1045                                   "SAMBADOMAIN",
     1046                                   "samba.example.com",
     1047                                   "2008",
    8481048                                   1,
    849                                    "localdcpass",
    850                                    "127.0.0.1");
    851 
    852         $self->add_wins_config("$prefix/private") or
    853                 die("Unable to add wins configuration");
     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
     1068sub 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
     1092sub 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
     1116sub 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
     1141sub 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
     1168        read only = yes
     1169
     1170[netlogon]
     1171        path = $ctx->{lockdir}/sysvol/$ctx->{dnsname}/scripts
     1172        read only = yes
     1173
     1174[tmp]
     1175        path = $ctx->{tmpdir}
     1176        read only = no
     1177        posix:sharedelay = 10000
     1178        posix:oplocktimeout = 3
     1179        posix:writetimeupdatedelay = 500000
     1180
     1181";
     1182
     1183        my $ret = $self->provision_raw_step1($ctx);
     1184        unless ($ret) {
     1185                return undef;
     1186        }
     1187
     1188        my $samba_tool = $self->bindir_path("samba-tool");
     1189        my $cmd = "";
     1190        $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$ret->{SOCKET_WRAPPER_DEFAULT_IFACE}\" ";
     1191        $cmd .= "KRB5_CONFIG=\"$ret->{KRB5_CONFIG}\" ";
     1192        $cmd .= "$samba_tool join $ret->{CONFIGURATION} $dcvars->{REALM} RODC";
     1193        $cmd .= " -U$dcvars->{DC_USERNAME}\%$dcvars->{DC_PASSWORD}";
     1194        $cmd .= " --server=$dcvars->{DC_SERVER}";
     1195
     1196        unless (system($cmd) == 0) {
     1197                warn("RODC join failed\n$cmd");
     1198                return undef;
     1199        }
     1200
     1201        # we overwrite the kdc after the RODC join
     1202        # so that use the RODC as kdc and test
     1203        # the proxy code
     1204        $ctx->{kdc_ipv4} = $ret->{SERVER_IP};
     1205        $self->mk_krb5_conf($ctx);
     1206
     1207        $ret->{RODC_DC_SERVER} = $ret->{SERVER};
     1208        $ret->{RODC_DC_SERVER_IP} = $ret->{SERVER_IP};
     1209        $ret->{RODC_DC_NETBIOSNAME} = $ret->{NETBIOSNAME};
     1210        $ret->{RODC_DC_NETBIOSALIAS} = $ret->{NETBIOSALIAS};
     1211
     1212        $ret->{DC_SERVER} = $dcvars->{DC_SERVER};
     1213        $ret->{DC_SERVER_IP} = $dcvars->{DC_SERVER_IP};
     1214        $ret->{DC_NETBIOSNAME} = $dcvars->{DC_NETBIOSNAME};
     1215        $ret->{DC_NETBIOSALIAS} = $dcvars->{DC_NETBIOSALIAS};
     1216        $ret->{DC_USERNAME} = $dcvars->{DC_USERNAME};
     1217        $ret->{DC_PASSWORD} = $dcvars->{DC_PASSWORD};
    8541218
    8551219        return $ret;
    … …  
    8631227        close(DATA);
    8641228
    865         if (-f "$envvars->{PIDDIR}/samba.pid" ) {
    866                 open(IN, "<$envvars->{PIDDIR}/samba.pid") or die("unable to open server pid file");
     1229        if (open(IN, "<$envvars->{PIDDIR}/samba.pid")) {
    8671230                $pid = <IN>;
    8681231                close(IN);
    … …  
    8721235                my $count = 0;
    8731236                until (kill(0, $pid) == 0) {
    874                     # if no process sucessfully signalled, then we are done
    875                     sleep(1);
    876                     $count++;
    877                     last if $count > 20;
    878                 }
    879                
     1237                        # if no process sucessfully signalled, then we are done
     1238                        sleep(1);
     1239                        $count++;
     1240                        last if $count > 20;
     1241                }
     1242
    8801243                # If it is still around, kill it
    8811244                if ($count > 20) {
    882                     print "server process $pid took more than $count seconds to exit, killing\n";
    883                     kill 9, $pid;
     1245                        print "server process $pid took more than $count seconds to exit, killing\n";
     1246                        kill 9, $pid;
    8841247                }
    8851248        }
    … …  
    9101273
    9111274        return "" if $out eq $title;
    912  
     1275
    9131276        return $out;
    9141277}
    … …  
    9181281        my ($self, $envvars) = @_;
    9191282
    920         return 1 if (-p $envvars->{SAMBA_TEST_FIFO});
    921 
    922         print $self->getlog_env($envvars);
    923 
    924         return 0;
     1283        return (-p $envvars->{SAMBA_TEST_FIFO});
    9251284}
    9261285
    … …  
    9281287{
    9291288        my ($self, $envname, $path) = @_;
     1289
     1290        $ENV{ENVNAME} = $envname;
    9301291
    9311292        if ($envname eq "dc") {
    9321293                return $self->setup_dc("$path/dc");
     1294        } elsif ($envname eq "fl2000dc") {
     1295                return $self->setup_fl2000dc("$path/fl2000dc");
     1296        } elsif ($envname eq "fl2003dc") {
     1297                return $self->setup_fl2003dc("$path/fl2003dc");
     1298        } elsif ($envname eq "fl2008r2dc") {
     1299                return $self->setup_fl2008r2dc("$path/fl2008r2dc");
     1300        } 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});
     1305        } 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});
    9331310        } elsif ($envname eq "member") {
    9341311                if (not defined($self->{vars}->{dc})) {
    … …  
    9361313                }
    9371314                return $self->setup_member("$path/member", $self->{vars}->{dc});
     1315        } 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;
    9381371        } else {
    939                 die("Samba4 can't provide environment '$envname'");
    940         }
    941 }
    942 
    943 sub setup_member($$$$)
     1372                warn("Samba4 can't provide environment '$envname'");
     1373                return undef;
     1374        }
     1375}
     1376
     1377sub setup_member($$$)
    9441378{
    9451379        my ($self, $path, $dc_vars) = @_;
    … …  
    9471381        my $env = $self->provision_member($path, $dc_vars);
    9481382
    949         $self->check_or_start($env, ($ENV{SMBD_MAXTIME} or 7500));
     1383        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;
     1389        }
     1390
     1391        return $env;
     1392}
     1393
     1394sub setup_rpc_proxy($$$)
     1395{
     1396        my ($self, $path, $dc_vars) = @_;
     1397
     1398        my $env = $self->provision_rpc_proxy($path, $dc_vars);
     1399
     1400        if (defined $env) {
     1401                $self->check_or_start($env, ($ENV{SMBD_MAXTIME} or 7500));
     1402
     1403                $self->wait_for_start($env);
     1404
     1405                $self->{vars}->{rpc_proxy} = $env;
     1406        }
     1407        return $env;
     1408}
     1409
     1410sub setup_dc($$)
     1411{
     1412        my ($self, $path) = @_;
     1413
     1414        my $env = $self->provision_dc($path);
     1415        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;
     1422        }
     1423        return $env;
     1424}
     1425
     1426sub setup_fl2000dc($$)
     1427{
     1428        my ($self, $path) = @_;
     1429
     1430        my $env = $self->provision_fl2000dc($path);
     1431        if (defined $env) {
     1432                $self->check_or_start($env,
     1433                        ($ENV{SMBD_MAXTIME} or 7500));
     1434
     1435                $self->wait_for_start($env);
     1436
     1437                $self->{vars}->{fl2000dc} = $env;
     1438        }
     1439
     1440        return $env;
     1441}
     1442
     1443sub setup_fl2003dc($$)
     1444{
     1445        my ($self, $path) = @_;
     1446
     1447        my $env = $self->provision_fl2003dc($path);
     1448
     1449        if (defined $env) {
     1450                $self->check_or_start($env,
     1451                        ($ENV{SMBD_MAXTIME} or 7500));
     1452
     1453                $self->wait_for_start($env);
     1454
     1455                $self->{vars}->{fl2003dc} = $env;
     1456        }
     1457        return $env;
     1458}
     1459
     1460sub setup_fl2008r2dc($$)
     1461{
     1462        my ($self, $path) = @_;
     1463
     1464        my $env = $self->provision_fl2008r2dc($path);
     1465
     1466        if (defined $env) {
     1467                $self->check_or_start($env,
     1468                        ($ENV{SMBD_MAXTIME} or 7500));
     1469
     1470                $self->wait_for_start($env);
     1471
     1472                $self->{vars}->{fl2008r2dc} = $env;
     1473        }
     1474
     1475        return $env;
     1476}
     1477
     1478sub setup_vampire_dc($$$)
     1479{
     1480        my ($self, $path, $dc_vars) = @_;
     1481
     1482        my $env = $self->provision_vampire_dc($path, $dc_vars);
     1483
     1484        if (defined $env) {
     1485                $self->check_or_start($env,
     1486                        ($ENV{SMBD_MAXTIME} or 7500));
     1487
     1488                $self->wait_for_start($env);
     1489
     1490                $self->{vars}->{vampire_dc} = $env;
     1491
     1492                # force replicated DC to update repsTo/repsFrom
     1493                # for vampired partitions
     1494                my $samba_tool = $self->bindir_path("samba-tool");
     1495                my $cmd = "";
     1496                $cmd .= "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     1497                $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
     1498                $cmd .= " $samba_tool drs kcc $env->{DC_SERVER}";
     1499                $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
     1500                unless (system($cmd) == 0) {
     1501                        warn("Failed to exec kcc\n$cmd");
     1502                        return undef;
     1503                }
     1504
     1505                # as 'vampired' dc may add data in its local replica
     1506                # we need to synchronize data between DCs
     1507                my $base_dn = "DC=".join(",DC=", split(/\./, $dc_vars->{REALM}));
     1508                $cmd = "SOCKET_WRAPPER_DEFAULT_IFACE=\"$env->{SOCKET_WRAPPER_DEFAULT_IFACE}\"";
     1509                $cmd .= " KRB5_CONFIG=\"$env->{KRB5_CONFIG}\"";
     1510                $cmd .= " $samba_tool drs replicate $env->{DC_SERVER} $env->{VAMPIRE_DC_SERVER}";
     1511                $cmd .= " -U$dc_vars->{DC_USERNAME}\%$dc_vars->{DC_PASSWORD}";
     1512                # replicate Configuration NC
     1513                my $cmd_repl = "$cmd \"CN=Configuration,$base_dn\"";
     1514                unless(system($cmd_repl) == 0) {
     1515                        warn("Failed to replicate\n$cmd_repl");
     1516                        return undef;
     1517                }
     1518                # replicate Default NC
     1519                $cmd_repl = "$cmd \"$base_dn\"";
     1520                unless(system($cmd_repl) == 0) {
     1521                        warn("Failed to replicate\n$cmd_repl");
     1522                        return undef;
     1523                }
     1524        }
     1525
     1526        return $env;
     1527}
     1528
     1529sub setup_rodc($$$)
     1530{
     1531        my ($self, $path, $dc_vars) = @_;
     1532
     1533        my $env = $self->provision_rodc($path, $dc_vars);
     1534
     1535        unless ($env) {
     1536                return undef;
     1537        }
     1538
     1539        $self->check_or_start($env,
     1540                ($ENV{SMBD_MAXTIME} or 7500));
    9501541
    9511542        $self->wait_for_start($env);
    9521543
     1544        $self->{vars}->{rodc} = $env;
     1545
    9531546        return $env;
    9541547}
    9551548
    956 sub setup_dc($$)
    957 {
    958         my ($self, $path) = @_;
    959 
    960         my $env = $self->provision_dc($path);
    961 
    962         $self->check_or_start($env,
    963                 ($ENV{SMBD_MAXTIME} or 7500));
    964 
    965         $self->wait_for_start($env);
    966 
    967         $self->{vars}->{dc} = $env;
    968 
    969         return $env;
    970 }
    971 
    972 sub stop($)
    973 {
    974         my ($self) = @_;
    975 }
    976 
    97715491;
Note: See TracChangeset for help on using the changeset viewer.