package install::install2; # $Id: install2.pm 255825 2009-04-08 11:54:23Z tv $

use diagnostics;
use strict;
use vars qw($o);

BEGIN { $::isInstall = 1 }

#-######################################################################################
#- misc imports
#-######################################################################################
use install::steps_list;
use common;
use install::any 'addToBeDone';
use install::steps;
use install::any;
use lang;
use keyboard;
use mouse;
use devices;
use partition_table;
use modules;
use detect_devices;
use run_program;
use any;
use log;
use fs;
use fs::any;
use fs::mount;
use messages;

#-#######################################################################################
#-$O
#-the big struct which contain, well everything (globals + the interactive methods ...)
#-if you want to do a kickstart file, you just have to add all the required fields (see for example
#-the variable $default)
#-#######################################################################################
$o = $::o = {
#    bootloader => { linear => 0, message => 1, timeout => 5, restricted => 0 },
#-    packages   => [ qw() ],
    partitioning => { clearall => 0, eraseBadPartitions => 0, auto_allocate => 0 }, #-, readonly => 0 },
    authentication => { blowfish => 1, shadow => 1 },
    locale         => { lang => 'en_US' },
#-    isUpgrade    => 0,
    toRemove     => [],
    toSave       => [],
#-    simple_themes => 1,

    timezone => {
#-                   timezone => "Europe/Paris",
#-                   UTC      => 1,
                },
#-    superuser => { password => 'a', shell => '/bin/bash', realname => 'God' },
#-    user => { name => 'foo', password => 'bar', home => '/home/foo', shell => '/bin/bash', realname => 'really, it is foo' },

#-    keyboard => 'de',
#-    display => "192.168.1.19:1",
    steps        => \%install::steps_list::installSteps,
    orderedSteps => \@install::steps_list::orderedInstallSteps,

    #- for the list of fields available, see network/network.pm
    net => {
	    #- network => { HOSTNAME => 'abcd' },
	    #- resolv => { DOMAINNAME => 'foo.xyz' },
	    #- ifcfg => {
	    #-   eth0 => { DEVICE => "eth0", IPADDR => '1.2.3.4', NETMASK => '255.255.255.128' }
	    #- },
	    },
    untranslated_license => messages::main_license_raw(),
#-step : the current one
#-prefix
#-mouse
#-keyboard
#-netc
#-methods
#-packages compss

};


sub installStepsCall {
    my ($o, $auto, $fun, @args) = @_;
    $fun = "install::steps::$fun" if $auto;
    $o->$fun(@args);
}
sub getNextStep {
    my ($o) = @_;
    find { !$o->{steps}{$_}{done} && $o->{steps}{$_}{reachable} } @{$o->{orderedSteps}};
}

#-######################################################################################
#- Steps Functions
#- each step function are called with two arguments : clicked(because if you are a
#- beginner you can force the the step) and the entered number
#-######################################################################################

#------------------------------------------------------------------------------
sub selectLanguage {
    my ($auto) = @_;
    installStepsCall($o, $auto, 'selectLanguage');
}

sub acceptLicense {
    my ($auto) = @_;
    installStepsCall($o, $auto, 'acceptLicense');
}

#------------------------------------------------------------------------------
sub selectMouse {
    my ($auto) = @_;
    installStepsCall($o, $auto, 'selectMouse');

    addToBeDone { mouse::write($o->do_pkgs, $o->{mouse}) if !$o->{isUpgrade} } 'installPackages';
}

#------------------------------------------------------------------------------
sub setupSCSI {
    my ($auto) = @_;

    installStepsCall($o, $auto, 'setupSCSI');
}

#------------------------------------------------------------------------------
sub selectKeyboard {
    my ($auto) = @_;

    my $force;
    if (my $keyboard = keyboard::read()) {
	$o->{keyboard} = $keyboard; #- for uprade
    } elsif ($o->{isUpgrade}) {
	#- oops, the keyboard config is wrong, forcing prompt and writing
	$force = 1;
    }

    installStepsCall($o, $auto, 'selectKeyboard', $force);
}

#------------------------------------------------------------------------------
sub selectInstallClass {
    my ($auto) = @_;

    installStepsCall($o, $auto, 'selectInstallClass');

    if ($o->{isUpgrade}) {
	@{$o->{orderedSteps}} = uniq(map {
	    $_ eq 'selectInstallClass' ? ($_, 'doPartitionDisks', 'formatPartitions') : $_;
	} @{$o->{orderedSteps}});
    }
}

#------------------------------------------------------------------------------
sub doPartitionDisks {
    my ($auto) = @_;
    $o->{steps}{formatPartitions}{done} = 0;
    installStepsCall($o, $auto, 'doPartitionDisksBefore');
    installStepsCall($o, $auto, 'doPartitionDisks');
    installStepsCall($o, $auto, 'doPartitionDisksAfter');
}

sub formatPartitions {
    my ($auto) = @_;

    $o->{steps}{choosePackages}{done} = 0;
    installStepsCall($o, $auto, 'choosePartitionsToFormat') if !$o->{isUpgrade} && !$::local_install;
    my $want_root_formated = fs::get::root($o->{fstab})->{toFormat};
    if ($want_root_formated) {
	foreach ('/usr') {
	    my $part = fs::get::mntpoint2part($_, $o->{fstab}) or next;
	    $part->{toFormat} or die N("You must also format %s", $_);
	}
    }
    installStepsCall($o, $auto, 'formatMountPartitions') if !$::testing;

    if ($want_root_formated) {
	#- we formatted /, ensure /var/lib/rpm is cleaned otherwise bad things can happen
	#- (especially when /var is *not* formatted)
	eval { rm_rf("$::prefix/var/lib/rpm") };
    }

    fs::any::prepare_minimal_root();

    install::any::screenshot_dir__and_move();
    install::any::move_compressed_image_to_disk($o);

    any::rotate_logs($::prefix);

    require raid;
    raid::write_conf($o->{all_hds}{raids});
}

#------------------------------------------------------------------------------
sub choosePackages {
    my ($auto) = @_;
    require install::pkgs;

    #- always setPackages as it may have to copy hdlist and synthesis files.
    installStepsCall($o, $auto, 'setPackages');
    installStepsCall($o, $auto, 'choosePackages');
    my @flags = map_each { if_($::b, $::a) } %{$o->{rpmsrate_flags_chosen}};
    log::l("rpmsrate_flags_chosen's: ", join(' ', sort @flags));

    #- check pre-condition that basesystem package must be selected.
    install::pkgs::packageByName($o->{packages}, 'basesystem')->flag_available or die "basesystem package not selected";

    #- check if there are packages that need installation.
    $o->{steps}{installPackages}{done} = 0 if $o->{steps}{installPackages}{done} && install::pkgs::packagesToInstall($o->{packages}) > 0;
}

#------------------------------------------------------------------------------
sub installPackages {
    my ($auto) = @_;

    installStepsCall($o, $auto, 'beforeInstallPackages');
    installStepsCall($o, $auto, 'installPackages');
    installStepsCall($o, $auto, 'afterInstallPackages');
}
#------------------------------------------------------------------------------
sub miscellaneous {
    my ($auto) = @_;

    installStepsCall($o, $auto, 'miscellaneousBefore');
    installStepsCall($o, $auto, 'miscellaneous');
    installStepsCall($o, $auto, 'miscellaneousAfter');
}

#------------------------------------------------------------------------------
sub summary {
    my ($auto) = @_;
    installStepsCall($o, $auto, 'summaryBefore') if $o->{steps}{summary}{entered} == 1;
    installStepsCall($o, $auto, 'summary');
    installStepsCall($o, $auto, 'summaryAfter');
}
#------------------------------------------------------------------------------
sub configureNetwork {
    my ($auto) = @_;
    #- get current configuration of network device.
    require network::network;
    eval { network::network::read_net_conf($o->{net}) };
    modules::load_category($o->{modules_conf}, list_modules::ethernet_categories());
    require network::connection::ethernet;
    if (!$o->{isUpgrade}) {
        installStepsCall($o, $auto, 'configureNetwork');
    } else {
        network::connection::ethernet::configure_eth_aliases($o->{modules_conf});
    }
}
#------------------------------------------------------------------------------
sub installUpdates {
    my ($auto) = @_;
    installStepsCall($o, $auto, 'installUpdates');
}
#------------------------------------------------------------------------------
sub configureServices {
    my ($auto) = @_;
    installStepsCall($o, $auto, 'configureServices');
}
#------------------------------------------------------------------------------
sub setRootPassword_addUser {
    my ($auto) = @_;

    installStepsCall($o, $auto, 'setRootPassword_addUser') if !$o->{isUpgrade};
}

#------------------------------------------------------------------------------
sub setupBootloader {
    my ($auto) = @_;
    return if $::local_install;

    $o->{modules_conf}->write;

    installStepsCall($o, $auto, 'setupBootloaderBefore');
    installStepsCall($o, $auto, 'setupBootloader');
}
#------------------------------------------------------------------------------
sub configureX {
    my ($auto) = @_;

    #- done here and also at the end of install2.pm, just in case...
    install::any::write_fstab($o);
    $o->{modules_conf}->write;

    require install::pkgs;
    installStepsCall($o, $auto, 'configureX') if !$::testing && eval { install::pkgs::packageByName($o->{packages}, 'task-x11')->flag_installed } && !$o->{X}{disabled};
}
#------------------------------------------------------------------------------
sub exitInstall {
    my ($auto) = @_;
    installStepsCall($o, $auto, 'exitInstall', getNextStep($::o) eq 'exitInstall');
}

#-######################################################################################
#- Udev Functions
#-######################################################################################

sub start_udev() {
    return if fuzzy_pidofs('udevd');

    # Ensure /run is mounted
    mkdir("/run", 0755);
    run_program::run("mount -t tmpfs -o mode=0755,nosuid,nodev tmpfs /run");

    # Fake dracut boot (due to checks employed when running dracut during install)
    # as we know that we'll have the needed metadata in udevadm db due to us
    # starting udev nice and early here.
    mkdir_p("/run/initramfs");

    # Start up udev:
    mkdir_p("/run/udev/rules.d");
    $ENV{UDEVRULESD} = "/run/udev/rules.d";
    run_program::run("/usr/lib/systemd/systemd-udevd", "--daemon", "--resolve-names=never");
    # Coldplug all devices:
    run_program::run("udevadm", "trigger", "--type=subsystems", "--action=add");
    run_program::run("udevadm", "trigger", "--type=devices", "--action=add");
}

sub stop_udev() {
    kill 15, fuzzy_pidofs('udevd');
    sleep(2);
    fs::mount::umount($_) foreach '/dev/pts', '/dev/shm', '/run';
}

#-######################################################################################
#- Other Functions
#-######################################################################################

sub init_local_install {
    my ($o) = @_;
    push @::auto_steps, 
#      'selectLanguage', 'selectKeyboard', 'miscellaneous', 'selectInstallClass',
      'doPartitionDisks', 'formatPartitions';
	fs::mount::sys_kernel_debug('');  #- do it now so that when_load doesn't do it
	$o->{nomouseprobe} = 1;
	$o->{mouse} = mouse::fullname2mouse('Universal|Any PS/2 & USB mice');
}

sub pre_init_brltty() {
    if (my ($s) = cat_("/proc/cmdline") =~ /brltty=(\S*)/) {
	my ($driver, $device, $table) = split(',', $s);
	$table = "text.$table.tbl" if $table !~ /\.tbl$/;
	log::l("brltty option $driver $device $table");
	$o->{brltty} = { driver => $driver, device => $device, table => $table };
	$o->{interactive} = 'curses';
	$o->{nomouseprobe} = 1;
    }
}

sub init_brltty() {
    symlink "/tmp/stage2/$_", $_ foreach "/etc/brltty";
    devices::make($_) foreach $o->{brltty}{device};
    run_program::run("brltty");
}

sub init_auto_install() {
    if ($::auto_install =~ /-IP(\.pl)?$/) {
        my ($ip) = cat_('/tmp/stage1.log') =~ /configuring device (?!lo)\S+ ip: (\S+)/;
        my $normalized_ip = join('', map { sprintf "%02X", $_ } split('\.', $ip)); 
        $::auto_install =~ s/-IP(\.pl)?$/-$normalized_ip$1/;
    }
    require install::steps_auto_install;
    eval { $o = $::o = install::any::loadO($o, $::auto_install) };
    if ($@) {
        if ($o->{useless_thing_accepted}) { #- Pixel's hack to be able to fail through
            log::l("error using auto_install, continuing");
            undef $::auto_install;
        } else {
            install::steps_auto_install_non_interactive::errorInStep($o, "Error using auto_install\n" . formatError($@));
        }
    } else {
        log::l("auto install config file loaded successfully");

        #- normalize for people not using our special scheme
        foreach (@{$o->{manualFstab} || []}) {
            $_->{device} =~ s!^/dev/!!;
        }
    }
}

sub step_init {
  my ($o) = @_;
  my $o_;
  while (1) {
      $o_ = $::auto_install ?
    	  install::steps_auto_install->new($o) :
    	    $o->{interactive} eq "stdio" ?
    	  install::steps_stdio->new($o) :
    	    $o->{interactive} eq "curses" ?
    	  install::steps_curses->new($o) :
    	    $o->{interactive} eq "gtk" ?
    	  install::steps_gtk->new($o) :
    	    die "unknown install type";
      $o_ and last;

      log::l("$o->{interactive} failed, trying again with curses");
      $o->{interactive} = "curses";
      require install::steps_curses;
  }
  $o;
}

sub read_product_id() {
    my $product_id = cat__(install::any::getFile_($o->{stage2_phys_medium}, "product.id"));
    log::l('product_id: ' . chomp_($product_id));
    $o->{product_id} = common::parse_LDAP_namespace_structure($product_id);
 
    $o->{meta_class} ||= {
        One          => 'desktop',
        Free         => 'download',
        Powerpack    => 'powerpack',
    }->{$o->{product_id}{product}} || 'download';
}

sub sig_segv_handler() {
    my $msg = "segmentation fault: install crashed (maybe memory is missing?)\n" . backtrace();
    log::l("$msg\n");
    # perl_checker: require UNIVERSAL
    UNIVERSAL::can($o, 'ask_warn') and $o->ask_warn('', $msg);
    setVirtual(1);
    require install::steps_auto_install;
    install::steps_auto_install_non_interactive::errorInStep($o, $msg);
}

sub read_stage1_net_conf() {
    require network::network;
    #- get stage1 network configuration if any.
    log::l('found /tmp/network');
    add2hash($o->{net}{network} ||= {}, network::network::read_conf('/tmp/network'));
    if (my ($file) = glob_('/tmp/ifcfg-*')) {
        log::l("found network config file $file");
        my $l = network::network::read_interface_conf($file);
        $o->{net}{ifcfg}{$l->{DEVICE}} ||= $l;
    }
    my $dsl_device = find { $_->{BOOTPROTO} eq 'adsl_pppoe' } values %{$o->{net}{ifcfg}};
    if ($dsl_device) {
        $o->{net}{type} = 'adsl';
        $o->{net}{net_interface} = $dsl_device->{DEVICE};
        $o->{net}{adsl} = {
            method => 'pppoe',
            device => $dsl_device->{DEVICE},
            ethernet_device => $dsl_device->{DEVICE},
            login => $dsl_device->{USER},
            password => $dsl_device->{PASS},
        };
        %$dsl_device = ();
    } else {
        $o->{net}{type} = 'lan';
        $o->{net}{net_interface} = first(values %{$o->{net}{ifcfg}});
    }
}

sub parse_args {
    my ($cfg, $patch);
    my %cmdline = map { 
	my ($n, $v) = split /=/;
	$n => defined($v) ? $v : 1;
    } split ' ', cat_("/proc/cmdline");

    my $opt; foreach (@_) {
	if (/^--?(.*)/) {
	    $cmdline{$opt} = 1 if $opt;
	    $opt = $1;
	} else {
	    $cmdline{$opt} = $_ if $opt;
	    $opt = '';
	}
    } $cmdline{$opt} = 1 if $opt;

    #- from stage1
    put_in_hash(\%ENV, { getVarsFromSh('/tmp/env') });
    exists $ENV{$_} and $cmdline{lc($_)} = $ENV{$_} foreach qw(METHOD PCMCIA KICKSTART);

    map_each {
	my ($n, $v) = @_;
	my $f = ${{
	    keyboard  => sub { $o->{keyboard} = $v; push @::auto_steps, 'selectKeyboard' },
	    lang      => sub { $o->{lang} = $v },
	    flang     => sub { $o->{lang} = $v; push @::auto_steps, 'selectLanguage' },
	    langs     => sub { $o->{locale}{langs} = +{ map { $_ => 1 } split(':', $v) } },
	    method    => sub { $o->{method} = $v },
	    pcmcia    => sub { $o->{pcmcia} = $v },
	    step      => sub { $o->{steps}{first} = $v },
	    meta_class => sub { $o->{meta_class} = $v },
	    freedriver => sub { $o->{freedriver} = $v },

	    # fs/block options:
	    no_bad_drives => sub { $o->{partitioning}{no_bad_drives} = 1 },
	    nodmraid  => sub { $o->{partitioning}{nodmraid} = 1 },
	    readonly  => sub { $o->{partitioning}{readonly} = $v ne "0" },
	    use_uuid  => sub { $::no_uuid_by_default = !$v },

	    # urpmi options:
	    debug_urpmi  => sub { $o->{debug_urpmi} = 1 },
	    justdb    => sub { $o->{justdb} = 1 },
	    'tune-rpm' => sub { $o->{'tune-rpm'} = 'all' },

	    # GUI options:
	    vga16     => sub { $o->{vga16} = $v },
	    vga       => sub { $o->{vga} = $v =~ /0x/ ? hex($v) : $v },
	    display   => sub { $o->{display} = $v },
	    askdisplay => sub { print "Please enter the X11 display to perform the install on ? "; $o->{display} = chomp_(scalar(<STDIN>)) },
	    text      => sub { $o->{interactive} = "curses" },
	    stdio     => sub { $o->{interactive} = "stdio" },
	    newt      => sub { $o->{interactive} = "curses" },
	    simple_themes => sub { $o->{simple_themes} = 1 },
	    theme     => sub { $o->{theme} = $v },
	    doc       => sub { $o->{doc} = 1 },  #- will be used to know that we're running for the doc team,
	                                         #- e.g. we want screenshots with a good B&W contrast

	    security  => sub { $o->{security} = $v },

	    # auto install options:
	    noauto    => sub { $::noauto = 1 },
	    testing   => sub { $::testing = 1 },
	    patch     => sub { $patch = 1 },
	    defcfg    => sub { $cfg = $v },
	    kickstart => sub { $::auto_install = $v },

	    local_install => sub { $::local_install = 1 },
	    uml_install => sub { $::uml_install = $::local_install = 1 },
	    auto_install => sub { $::auto_install = $v },

	    # debugging options:
	    useless_thing_accepted => sub { $o->{useless_thing_accepted} = 1 },
	    alawindows => sub { $o->{security} = 0; $o->{partitioning}{clearall} = 1; $o->{bootloader}{crushMbr} = 1 },
	    fdisk => sub { $o->{partitioning}{fdisk} = 1 },
	    nomouseprobe => sub { $o->{nomouseprobe} = $v },
	    updatemodules => sub { $o->{updatemodules} = 1 },

	    suppl => sub { $o->{supplmedia} = $v },
	    askmedia => sub { $o->{askmedia} = 1 },
	    restore => sub { $::isRestore = 1 },
	    compsslistlevel => sub { $o->{compssListLevel} = $v },
	}}{lc $n}; &$f if $f;
    } %cmdline;

    ($cfg, $patch);
}

sub init_env_share() {
    if ($::testing) {
	$ENV{SHARE_PATH} ||= "/export/install/stage2/live/usr/share";
	$ENV{SHARE_PATH} = "/usr/share" if !-e $ENV{SHARE_PATH};
    } else {
	$ENV{SHARE_PATH} ||= "/usr/share";
    }
}

sub init_path() {
    #-  make sure we do not pick up any gunk from the outside world
    my $remote_path = "$::prefix/sbin:$::prefix/bin:$::prefix/usr/sbin:$::prefix/usr/bin";
    $ENV{PATH} = "/usr/bin:/bin:/sbin:/usr/sbin:$remote_path";
}

sub init_mouse() {
    eval { $o->{mouse} = mouse::detect($o->{modules_conf}) } if !$o->{mouse} && !$o->{nomouseprobe};
    mouse::load_modules($o->{mouse});
}

sub init_modules_conf() {
    list_modules::load_default_moddeps();
    require modules::any_conf;
    require modules::modules_conf;
    # read back config from stage1:
    $o->{modules_conf} = modules::modules_conf::read(modules::any_conf::vnew(), '/tmp/modules.conf');
    modules::read_already_loaded($o->{modules_conf});
}

sub process_auto_steps() {
    foreach (@::auto_steps) {
	if (my $s = $o->{steps}{/::(.*)/ ? $1 : $_}) {
	    $s->{auto} = $s->{hidden} = 1;
	} else {
	    log::l("ERROR: unknown step $_ in auto_steps");
	}
    }
}

sub process_patch {
    my ($cfg, $patch) = @_;
    #- oem patch should be read before to still allow patch or defcfg.
    eval { $o = $::o = install::any::loadO($o, "install/patch-oem.pl"); log::l("successfully read oem patch") };
    #- patch should be read after defcfg in order to take precedance.
    eval { $o = $::o = install::any::loadO($o, $cfg); log::l("successfully read default configuration: $cfg") } if $cfg;
    eval { $o = $::o = install::any::loadO($o, "patch"); log::l("successfully read patch") } if $patch;
}

#-######################################################################################
#- MAIN
#-######################################################################################
sub main {
    $SIG{SEGV} = \&sig_segv_handler;
    $ENV{PERL_BADLANG} = 1;
    delete $ENV{TERMINFO};
    umask 022;

    $::isWizard = 1;
    $::no_ugtk_init = 1;

    push @::textdomains, 'DrakX', 'drakx-net', 'drakx-kbd-mouse-x11';

    my ($cfg, $patch) = parse_args(@_);

    init_env_share();

    undef $::auto_install if $cfg;

    $o->{stage2_phys_medium} = install::media::stage2_phys_medium($o->{method});

    log::l("second stage install running (", install::any::drakx_version($o), ")");

    eval { touch('/root/non-chrooted-marker.DrakX') }; #- helps distinguishing /root and /mnt/root when we don't know if we are chrooted

    if ($::local_install) {
        init_local_install($o);
    } else {
        start_udev();
        # load some modules early but asynchronously:
        run_program::raw({ detach => 1 }, 'modprobe', 'microcode');
    }

    $o->{prefix} = $::prefix = $::testing ? "/tmp/test-perl-install" : "/mnt";
    mkdir $::prefix, 0755;

    init_path();

    eval { install::any::spawnShell() };

    init_modules_conf();

    #- done before auto_install is called to allow the -IP feature on auto_install file name
    read_stage1_net_conf() if -e '/tmp/network';

    #- done after module dependencies are loaded for "vfat depends on fat"
    if ($::auto_install) {
        init_auto_install();
    } else {
        $o->{interactive} ||= 'gtk';
    }
 
    if ($o->{interactive} eq "gtk" && availableMemory() < 22 * 1024) {
 	log::l("switching to curses install cuz not enough memory");
 	$o->{interactive} = "curses";
    }

    pre_init_brltty();

    # perl_checker: require install::steps_gtk
    # perl_checker: require install::steps_curses
    # perl_checker: require install::steps_stdio
    require "install/steps_$o->{interactive}.pm" if $o->{interactive};

    #- needed before accessing floppy (in case of usb floppy)
    modules::load_category($o->{modules_conf}, 'bus/usb'); 

    process_patch($cfg, $patch);

    eval { modules::load("af_packet") };

    require harddrake::sound;
    harddrake::sound::configure_sound_slots($o->{modules_conf});

    #- need to be after oo-izing $o
    init_brltty() if $o->{brltty};

    #- needed very early for install::steps_gtk
    init_mouse() if !$::testing;

    #- for auto_install compatibility with old $o->{lang},
    #- and also for --lang and --flang
    if ($o->{lang}) {
	put_in_hash($o->{locale}, lang::lang_to_ourlocale($o->{lang}));
    }
    lang::set($o->{locale});

    # keep the result otherwise monitor-edid does not return good results afterwards
    eval { any::monitor_full_edid() };

    $o->{allowFB} = listlength(cat_("/proc/fb"));

    read_product_id() if !$::testing;

    log::l("META_CLASS=$o->{meta_class}");

    process_auto_steps();

    $ENV{COLUMNS} ||= 80;
    $ENV{LINES}   ||= 25;
    $::o = $o = step_init($o);

    eval { output('/proc/splash', "verbose\n") };
  
    real_main();
    finish_install();
}

sub real_main() {
    #-the main cycle
    MAIN: for ($o->{step} = $o->{steps}{first};; $o->{step} = getNextStep($o)) {
	$o->{steps}{$o->{step}}{entered}++;
	$o->enteringStep($o->{step});
	my $time = time();
	eval {
	    &{$install::install2::{$o->{step}}}($o->{steps}{$o->{step}}{auto});
	};
	my $err = $@;
	log::l("step \"$o->{step}\" took: ", formatTimeRaw(time() - $time));
	$o->kill_action;
	if ($err) {
	    local $_ = $err;
	    $o->kill_action;
	    if (!/^already displayed/) {
		eval { $o->errorInStep($_) };
		$o->{steps}{$o->{step}}{auto} = 0;
		$err = $@;
		$err and next;
	    }
	    $o->{step} = $o->{steps}{$o->{step}}{onError};
	    next MAIN unless $o->{steps}{$o->{step}}{reachable}; #- sanity check: avoid a step not reachable on error.
	    redo MAIN;
	}
	$o->{steps}{$o->{step}}{done} = 1;
	$o->leavingStep($o->{step});

	last if $o->{step} eq 'exitInstall';
    }
}

sub finish_install() {
    unlink $install::any::compressed_image_on_disk;
    install::media::clean_postinstall_rpms();
    install::media::log_sizes();
    install::any::remove_advertising();
    install::any::write_fstab($o);
    $o->{modules_conf}->write;
    detect_devices::install_addons($::prefix);

    install::any::adjust_files_mtime_to_timezone();

    #- make sure failed upgrade will not hurt too much.
    install::steps::cleanIfFailedUpgrade($o);

    #- drop urpmi DB if urpmi is not installed:
    -e "$::prefix/usr/sbin/urpmi" or eval { rm_rf("$::prefix/var/lib/urpmi") };

    system("chroot", $::prefix, "bash", "-c", $o->{postInstallBeforeReboot}) if $o->{postInstallBeforeReboot};

    #- copy latest log files
    eval { cp_af("/tmp/$_", "$::prefix/root/drakx") foreach qw(ddebug.log stage1.log) };

    #- ala pixel? :-) [fpons]
    common::sync(); common::sync();

    stop_udev() if !$::local_install;
    log::l("installation complete, leaving");
    log::l("files still open by install2: ", readlink($_)) foreach glob_("/proc/self/fd/*");
    print "\n" x 80 if !$::local_install;
}

1;