package install_any; # $Id$
use diagnostics;
use strict;
use vars qw(@ISA %EXPORT_TAGS @EXPORT_OK $boot_medium $current_medium $asked_medium @advertising_images);
@ISA = qw(Exporter);
%EXPORT_TAGS = (
all => [ qw(getNextStep spawnShell addToBeDone) ],
);
@EXPORT_OK = map { @$_ } values %EXPORT_TAGS;
#-######################################################################################
#- misc imports
#-######################################################################################
use MDK::Common::System;
use common;
use run_program;
use partition_table qw(:types);
use partition_table::raw;
use devices;
use fsedit;
use modules;
use detect_devices;
use lang;
use any;
use log;
use fs;
#- boot medium (the first medium to take into account).
$boot_medium = 1;
$current_medium = $boot_medium;
$asked_medium = $boot_medium;
#-######################################################################################
#- Media change variables&functions
#-######################################################################################
my $postinstall_rpms = '';
my $cdrom;
sub useMedium($) {
#- before ejecting the first CD, there are some files to copy!
#- does nothing if the function has already been called.
$_[0] > 1 and $::o->{method} eq 'cdrom' and setup_postinstall_rpms($::prefix, $::o->{packages});
$asked_medium eq $_[0] or log::l("selecting new medium '$_[0]'");
$asked_medium = $_[0];
}
sub changeMedium($$) {
my ($method, $medium) = @_;
log::l("change to medium $medium for method $method (refused by default)");
0;
}
sub relGetFile($) {
local $_ = $_[0];
m|\.rpm$| ? "$::o->{packages}{mediums}{$asked_medium}{rpmsdir}/$_" : $_;
}
sub askChangeMedium($$) {
my ($method, $medium) = @_;
my $allow;
do {
eval { $allow = changeMedium($method, $medium) };
} while $@; #- really it is not allowed to die in changeMedium!!! or install will cores with rpmlib!!!
log::l($allow ? "accepting medium $medium" : "refusing medium $medium");
$allow;
}
sub errorOpeningFile($) {
my ($file) = @_;
$file eq 'XXX' and return; #- special case to force closing file after rpmlib transaction.
$current_medium eq $asked_medium and log::l("errorOpeningFile $file"), return; #- nothing to do in such case.
$::o->{packages}{mediums}{$asked_medium}{selected} or return; #- not selected means no need for worying about.
my $max = 32; #- always refuse after $max tries.
if ($::o->{method} eq "cdrom") {
cat_("/proc/mounts") =~ m,(/(?:dev|tmp)/\S+)\s+(?:/mnt/cdrom|/tmp/image), and $cdrom = $1;
return unless $cdrom;
ejectCdrom($cdrom);
while ($max > 0 && askChangeMedium($::o->{method}, $asked_medium)) {
$current_medium = $asked_medium;
eval { fs::mount($cdrom, "/tmp/image", "iso9660", 'readonly') };
my $getFile = getFile($file);
$getFile && @advertising_images and copy_advertising($::o);
$getFile and return $getFile;
$current_medium = 'unknown'; #- don't know what CD is inserted now.
ejectCdrom($cdrom);
--$max;
}
} else {
while ($max > 0 && askChangeMedium($::o->{method}, $asked_medium)) {
$current_medium = $asked_medium;
my $getFile = getFile($file); $getFile and return $getFile;
$current_medium = 'unknown'; #- don't know what CD image has been copied.
--$max;
}
}
#- keep in mind the asked medium has been refused on this way.
#- this means it is no more selected.
$::o->{packages}{mediums}{$asked_medium}{selected} = undef;
#- on cancel, we can expect the current medium to be undefined too,
#- this enable remounting if selecting a package back.
$current_medium = 'unknown';
return;
}
sub getFile {
my ($f, $method) = @_;
log::l("getFile $f:$method");
my $rel = relGetFile($f);
do {
if ($f =~ m|^http://|) {
require http;
http::getFile($f);
} elsif ($method =~ /crypto|update/i) {
require crypto;
crypto::getFile($f);
} elsif ($::o->{method} eq "ftp") {
require ftp;
ftp::getFile($rel);
} elsif ($::o->{method} eq "http") {
require http;
http::getFile("$ENV{URLPREFIX}/$rel");
} else {
#- try to open the file, but examine if it is present in the repository, this allow
#- handling changing a media when some of the file on the first CD has been copied
#- to other to avoid media change...
my $f2 = "$postinstall_rpms/$f";
$f2 = "/tmp/image/$rel" if !$postinstall_rpms || !-e $f2;
my $F; open $F, $f2 and $F;
}
} || errorOpeningFile($f);
}
sub getAndSaveFile {
my ($file, $local) = @_ == 1 ? ("Mandrake/mdkinst$_[0]", $_[0]) : @_;
local $/ = \ (16 * 1024);
my $f = ref($file) ? $file : getFile($file) or return;
open(my $F, ">$local") or return;
local $_;
while (<$f>) { syswrite($F, $_) or die("getAndSaveFile: $!") }
1;
}
#-######################################################################################
#- Post installation RPMS from cdrom only, functions
#-######################################################################################
sub setup_postinstall_rpms($$) {
my ($prefix, $packages) = @_;
$postinstall_rpms and return;
$postinstall_rpms = "$prefix/usr/postinstall-rpm";
require pkgs;
log::l("postinstall rpms directory set to $postinstall_rpms");
clean_postinstall_rpms(); #- make sure in case of previous upgrade problem.
mkdir_p($postinstall_rpms);
my %toCopy;
#- compute closure of package that may be copied, use INSTALL category
#- in rpmsrate.
$packages->{rpmdb} ||= pkgs::rpmDbOpen($prefix);
foreach (@{$packages->{needToCopy} || []}) {
my $p = pkgs::packageByName($packages, $_) or next;
pkgs::selectPackage($packages, $p, 0, \%toCopy);
}
delete $packages->{rpmdb};
my @toCopy = grep { $_ && !$_->flag_selected } map { $packages->{depslist}[$_] } keys %toCopy;
#- extract headers of package, this is necessary for getting
#- the complete filename of each package.
#- copy the package files in the postinstall RPMS directory.
#- last arg is default medium '' known as the CD#1.
#- cp_af doesn't handle correctly a missing file.
eval { cp_af((grep { -r $_ } map { "/tmp/image/" . relGetFile($_->filename) } @toCopy), $postinstall_rpms) };
log::l("copying Auto Install Floppy");
getAndSaveInstallFloppy($::o, "$postinstall_rpms/auto_install.img");
}
sub clean_postinstall_rpms() {
$postinstall_rpms and -d $postinstall_rpms and rm_rf($postinstall_rpms);
}
#-######################################################################################
#- Specific Hardware to take into account and associated rpms to install
#-######################################################################################
sub allowNVIDIA_rpms {
my ($packages) = @_;
require pkgs;
if (pkgs::packageByName($packages, "NVIDIA_GLX")) {
#- at this point, we can allow using NVIDIA 3D acceleration packages.
my @rpms;
foreach my $p (@{$packages->{depslist}}) {
my ($ext, $version, $release) = $p->name =~ /kernel[^-]*(-smp|-enterprise|-secure)?(?:-(\d.*?)\.(\d+mdk))?$/ or next;
$p->flag_available or next;
$version or ($version, $release) = ($p->version, $p->release);
my $name = "NVIDIA_kernel-$version-$release$ext";
pkgs::packageByName($packages, $name) or next;
push @rpms, $name;
}
@rpms > 0 or return;
return [ @rpms, "NVIDIA_GLX" ];
}
}
#-######################################################################################
#- Functions
#-######################################################################################
sub getNextStep {
my ($s) = $::o->{steps}{first};
$s = $::o->{steps}{$s}{next} while $::o->{steps}{$s}{done} || !$::o->{steps}{$s}{reachable};
$s;
}
sub spawnShell {
return if $::o->{localInstall} || $::testing;
-x "/bin/sh" or die "cannot open shell - /bin/sh doesn't exist";
fork() and return;
$ENV{DISPLAY} ||= ":0"; #- why not :pp
local *F;
sysopen F, "/dev/tty2", 2 or die "cannot open /dev/tty2 -- no shell will be provided";
open STDIN, "<&F" or die '';
open STDOUT, ">&F" or die '';
open STDERR, ">&F" or die '';
close F;
print any::drakx_version(), "\n";
c::setsid();
ioctl(STDIN, c::TIOCSCTTY(), 0) or warn "could not set new controlling tty: $!";
my $busybox = "/usr/bin/busybox";
exec { -e $busybox ? $busybox : "/bin/sh" } "/bin/sh" or log::l("exec of /bin/sh failed: $!");
}
sub getAvailableSpace {
my ($o) = @_;
#- make sure of this place to be available for installation, this could help a lot.
#- currently doing a very small install use 36Mb of postinstall-rpm, but installing
#- these packages may eat up to 90Mb (of course not all the server may be installed!).
#- 65mb may be a good choice to avoid almost all problem of insuficient space left...
my $minAvailableSize = 65 * sqr(1024);
my $n = !$::testing && getAvailableSpace_mounted($o->{prefix}) ||
getAvailableSpace_raw($o->{fstab}) * 512 / 1.07;
$n - max(0.1 * $n, $minAvailableSize);
}
sub getAvailableSpace_mounted {
my ($prefix) = @_;
my $dir = -d "$prefix/usr" ? "$prefix/usr" : $prefix;
my (undef, $free) = MDK::Common::System::df($dir) or return;
log::l("getAvailableSpace_mounted $free KB");
$free * 1024 || 1;
}
sub getAvailableSpace_raw {
my ($fstab) = @_;
do { $_->{mntpoint} eq '/usr' and return $_->{size} } foreach @$fstab;
do { $_->{mntpoint} eq '/' and return $_->{size} } foreach @$fstab;
if ($::testing) {
my $nb = 450;
log::l("taking ${nb}MB for testing");
return $nb << 11;
}
die "missing root partition";
}
sub preConfigureTimezone {
my ($o) = @_;
require timezone;
#- can't be done in install cuz' timeconfig %post creates funny things
add2hash($o->{timezone}, timezone::read()) if $o->{isUpgrade};
$o->{timezone}{timezone} ||= timezone::bestTimezone($o->{locale}{country});
my $utc = every { !isFat_or_NTFS($_) } @{$o->{fstab}};
my $ntp = timezone::ntp_server($o->{prefix});
add2hash_($o->{timezone}, { UTC => $utc, ntp => $ntp });
}
sub setPackages {
my ($o, $rebuild_needed) = @_;
require pkgs;
if (!$o->{packages} || is_empty_array_ref($o->{packages}{depslist})) {
$o->{packages} = pkgs::psUsingHdlists($o->{prefix}, $o->{method});
#- open rpm db according to right mode needed.
$o->{packages}{rpmdb} ||= pkgs::rpmDbOpen($o->{prefix}, $rebuild_needed);
pkgs::getDeps($o->{prefix}, $o->{packages});
pkgs::selectPackage($o->{packages},
pkgs::packageByName($o->{packages}, 'basesystem') || die("missing basesystem package"), 1);
#- always try to select basic kernel (else on upgrade, kernel will never be updated provided a kernel is already
#- installed and provides what is necessary).
pkgs::selectPackage($o->{packages},
pkgs::bestKernelPackage($o->{packages}) || die("missing kernel package"), 1);
#- must be done after selecting base packages (to save memory)
pkgs::getProvides($o->{packages});
#- must be done after getProvides
pkgs::read_rpmsrate($o->{packages}, getFile("Mandrake/base/rpmsrate"));
($o->{compssUsers}, $o->{compssUsersSorted}) = pkgs::readCompssUsers($o->{meta_class});
#- preselect default_packages and compssUsersChoices.
setDefaultPackages($o);
pkgs::selectPackage($o->{packages}, pkgs::packageByName($o->{packages}, $_) || next) foreach @{$o->{default_packages}};
} else {
#- this has to be done to make sure necessary files for urpmi are
#- present.
pkgs::psUpdateHdlistsDeps($o->{prefix}, $o->{method}, $o->{packages});
#- open rpm db (always without rebuilding db, it should be false at this point).
$o->{packages}{rpmdb} ||= pkgs::rpmDbOpen($o->{prefix});
}
}
sub setDefaultPackages {
my ($o, $clean) = @_;
if ($clean) {
delete $o->{$_} foreach qw(default_packages compssUsersChoice); #- clean modified variables.
}
push @{$o->{default_packages}}, "brltty" if cat_("/proc/cmdline") =~ /brltty=/;
push @{$o->{default_packages}}, "nfs-utils-clients" if $o->{method} eq "nfs";
push @{$o->{default_packages}}, "numlock" if $o->{miscellaneous}{numlock};
push @{$o->{default_packages}}, "kernel22" if !$::oem && c::kernel_version() =~ /^\Q2.2/;
push @{$o->{default_packages}}, "raidtools" if !is_empty_array_ref($o->{all_hds}{raids});
push @{$o->{default_packages}}, "lvm" if !is_empty_array_ref($o->{all_hds}{lvms});
push @{$o->{default_packages}}, "alsa", "alsa-utils" if modules::get_alias("sound-slot-0") =~ /^snd-card-/;
push @{$o->{default_packages}}, uniq(grep { $_ } map { fsedit::package_needed_for_partition_type($_) } @{$o->{fstab}});
#- if no cleaning needed, populate by default, clean is used for second or more call to this function.
unless ($clean) {
if ($::auto_install && ($o->{compssUsersChoice} || {})->{ALL}) {
$o->{compssUsersChoice}{$_} = 1 foreach map { @{$o->{compssUsers}{$_}{flags}} } @{$o->{compssUsersSorted}};
}
if (!$o->{compssUsersChoice} && !$o->{isUpgrade}) {
#- by default, choose:
if ($o->{meta_class} eq 'server') {
$o->{compssUsersChoice}{$_} = 1 foreach 'X', 'MONITORING', 'NETWORKING_REMOTE_ACCESS_SERVER';
} else {
$o->{compssUsersChoice}{$_} = 1 foreach 'GNOME', 'KDE', 'CONFIG', 'X';
$o->{compssUsersChoice}{$_} = 1
foreach map { @{$o->{compssUsers}{$_}{flags}} } 'Workstation|Office Workstation', 'Workstation|Internet station';
}
}
}
$o->{compssUsersChoice}{uc($_)} = 1 foreach grep { modules::probe_category("multimedia/$_") } modules::sub_categories('multimedia');
$o->{compssUsersChoice}{uc($_)} = 1 foreach map { $_->{driver} =~ /Flag:(.*)/ } detect_devices::probeall();
$o->{compssUsersChoice}{SYSTEM} = 1;
$o->{compssUsersChoice}{DOCS} = !$o->{excludedocs};
$o->{compssUsersChoice}{BURNER} = 1 if detect_devices::burners();
$o->{compssUsersChoice}{DVD} = 1 if detect_devices::dvdroms();
$o->{compssUsersChoice}{USB} = 1 if modules::get_probeall("usb-interface");
$o->{compssUsersChoice}{PCMCIA} = 1 if detect_devices::hasPCMCIA();
$o->{compssUsersChoice}{HIGH_SECURITY} = 1 if $o->{security} > 3;
$o->{compssUsersChoice}{BIGMEM} = 1 if !$::oem && availableRamMB() > 800 && arch() !~ /ia64/;
$o->{compssUsersChoice}{SMP} = 1 if detect_devices::hasSMP();
$o->{compssUsersChoice}{CDCOM} = 1 if any { $_->{descr} =~ /commercial/i } values %{$o->{packages}{mediums}};
$o->{compssUsersChoice}{'3D'} = 1 if
detect_devices::matching_desc('Matrox.* G[245][05]0') ||
detect_devices::matching_desc('Rage X[CL]') ||
detect_devices::matching_desc('3D Rage (?:LT|Pro)') ||
detect_devices::matching_desc('Voodoo [35]') ||
detect_devices::matching_desc('Voodoo Banshee') ||
detect_devices::matching_desc('8281[05].* CGC') ||
detect_devices::matching_desc('Rage 128') ||
detect_devices::matching_desc('Radeon ') && !detect_devices::matching_desc('Radeon 8500') ||
detect_devices::matching_desc('[nN]Vidia.*T[nN]T2') || #- TNT2 cards
detect_devices::matching_desc('[nN]Vidia.*NV[56]') ||
detect_devices::matching_desc('[nN]Vidia.*Vanta') ||
detect_devices::matching_desc('[nN]Vidia.*GeForce') || #- GeForce cards
detect_devices::matching_desc('[nN]Vidia.*NV1[15]') ||
detect_devices::matching_desc('[nN]Vidia.*Quadro');
foreach (lang::langs($o->{locale}{langs})) {
pkgs::packageByName($o->{packages}, "locales-$_") or next;
push @{$o->{default_packages}}, "locales-$_";
$o->{compssUsersChoice}{qq(LOCALES"$_")} = 1; #- mainly for zh in case of zh_TW.Big5
}
push @{$o->{default_packages}}, 'locales-' . substr(lang::c2locale($o->{locale}{country}), 0, 2);
foreach (lang::langsLANGUAGE($o->{locale}{langs})) {
$o->{compssUsersChoice}{qq(LOCALES"$_")} = 1;
}
$o->{compssUsersChoice}{'CHARSET"' . lang::l2charset($o->{locale}{lang}) . '"'} = 1;
}
sub unselectMostPackages {
my ($o) = @_;
pkgs::unselectAllPackages($o->{packages});
pkgs::selectPackage($o->{packages}, pkgs::packageByName($o->{packages}, $_) || next) foreach @{$o->{default_packages}};
}
sub warnAboutNaughtyServers {
my ($o) = @_;
my @naughtyServers = pkgs::naughtyServers($o->{packages}) or return 1;
my $r = $o->ask_from_list_('',
formatAlaTeX(N("You have selected the following server(s): %s
These servers are activated by default. They don't have any known security
issues, but some new ones could be found. In that case, you must make sure
to upgrade as soon as possible.
Do you really want to install these servers?
", join(", ", @naughtyServers))), [ N_("Yes"), N_("No") ], 'Yes') or return;
if ($r ne 'Yes') {
log::l("unselecting naughty servers");
pkgs::unselectPackage($o->{packages}, pkgs::packageByName($o->{packages}, $_)) foreach @naughtyServers;
}
1;
}
sub warnAboutRemovedPackages {
my ($o, $packages) = @_;
my @removedPackages = keys %{$packages->{state}{ask_remove} || {}} or return;
if (!$o->ask_yesorno('',
formatAlaTeX(N("The following packages will be removed to allow upgrading your system: %s
Do you really want to remove these packages?
", join(", ", @removedPackages))), 1)) {
$packages->{state}{ask_remove} = {};
}
}
sub addToBeDone(&$) {
my ($f, $step) = @_;
return &$f() if $::o->{steps}{$step}{done};
push @{$::o->{steps}{$step}{toBeDone}}, $f;
}
sub setAuthentication {
my ($o) = @_;
my ($shadow, $ldap, $nis, $winbind, $winpass) = @{$o->{authentication} || {}}{qw(shadow LDAP NIS winbind winpass)};
my $p = $o->{prefix};
any::enableShadow($p) if $shadow;
if ($ldap) {
$o->pkg_install(qw(chkauth openldap-clients nss_ldap pam_ldap));
run_program::rooted($o->{prefix}, "/usr/sbin/chkauth", "ldap", "-D", $o->{netc}{LDAPDOMAIN}, "-s", $ldap);
} elsif ($nis) {
#$o->pkg_install(qw(chkauth ypbind yp-tools net-tools));
#run_program::rooted($o->{prefix}, "/usr/sbin/chkauth", "yp", $domain, "-s", $nis);
$o->pkg_install("ypbind");
my $domain = $o->{netc}{NISDOMAIN};
$domain || $nis ne "broadcast" or die N("Can't use broadcast with no NIS domain");
my $t = $domain ? "domain $domain" . ($nis ne "broadcast" && " server") : "ypserver";
substInFile {
$_ = "#~$_" unless /^#/;
$_ .= "$t $nis\n" if eof;
} "$p/etc/yp.conf";
require network;
network::write_conf("$p/etc/sysconfig/network", $o->{netc});
} elsif ($winbind) {
my $domain = $o->{netc}{WINDOMAIN};
$domain =~ tr/a-z/A-Z/;
$o->pkg_install(qw(samba-winbind samba-common));
{ #- setup pam
my $f = "$o->{prefix}/etc/pam.d/system-auth";
cp_af($f, "$f.orig");
cp_af("$f-winbind", $f);
}
write_smb_conf($domain);
run_program::rooted($o->{prefix}, "chkconfig", "--level", "35", "winbind", "on");
mkdir_p("$o->{prefix}/home/$domain");
#- defer running smbpassword - no network yet
$winbind = $winbind . "%" . $winpass;
addToBeDone {
require install_steps;
install_steps::upNetwork($o, 'pppAvoided');
run_program::rooted($o->{prefix}, "/usr/bin/smbpasswd", "-j", $domain, "-U", $winbind);
} 'configureNetwork';
}
}
sub write_smb_conf {
my ($domain) = @_;
#- was going to just have a canned config in samba-winbind
#- and replace the domain, but sylvestre/buchan didn't bless it yet
my $f = "$::prefix/etc/samba/smb.conf";
rename $f, "$f.orig";
output($f, "
[global]
workgroup = $domain
server string = Samba Server %v
security = domain
encrypt passwords = Yes
password server = *
log file = /var/log/samba/log.%m
max log size = 50
socket options = TCP_NODELAY SO_RCVBUF=8192 SO_SNDBUF=8192
character set = ISO8859-15
os level = 18
local master = No
dns proxy = No
winbind uid = 10000-20000
winbind gid = 10000-20000
winbind separator = +
template homedir = /home/%D/%U
template shell = /bin/bash
winbind use default domain = yes
");
}
sub killCardServices {
my $pid = chomp_(cat_("/tmp/cardmgr.pid"));
$pid and kill(15, $pid); #- send SIGTERM
}
sub unlockCdrom(;$) {
my ($cdrom) = @_;
$cdrom or cat_("/proc/mounts") =~ m,(/(?:dev|tmp)/\S+)\s+(?:/mnt/cdrom|/tmp/image), and $cdrom = $1;
eval { $cdrom and ioctl detect_devices::tryOpen($1), c::CDROM_LOCKDOOR(), 0 };
}
sub ejectCdrom(;$) {
my ($cdrom) = @_;
getFile("XXX"); #- close still opened filehandle
$cdrom ||= $1 if cat_("/proc/mounts") =~ m,(/(?:dev|tmp)/\S+)\s+(?:/mnt/cdrom|/tmp/image),;
if ($cdrom) {
#- umount BEFORE opening the cdrom device otherwise the umount will
#- D state if the cdrom is already removed
eval { fs::umount("/tmp/image") };
if ($@) { log::l("files still open: ", readlink($_)) foreach map { glob_("$_/fd/*") } glob_("/proc/*") }
eval {
my $dev = detect_devices::tryOpen($cdrom);
ioctl($dev, c::CDROMEJECT(), 1) if ioctl($dev, c::CDROM_DRIVE_STATUS(), 0) == c::CDS_DISC_OK();
};
}
}
sub setupFB {
my ($o, $vga) = @_;
$vga ||= 785; #- assume at least 640x480x16.
require bootloader;
#- update bootloader entries with vga, all kernel are now framebuffer.
foreach (qw(vmlinuz vmlinuz-secure vmlinuz-smp vmlinuz-hack)) {
if (my $e = bootloader::get("/boot/$_", $o->{bootloader})) {
$e->{vga} = $vga;
}
}
bootloader::install($o->{bootloader}, $o->{fstab}, $o->{all_hds}{hds});
1;
}
sub hdInstallPath() {
my $tail = first(readlink("/tmp/image") =~ m|^/tmp/hdimage/(.*)|);
my $head = first(readlink("/tmp/hdimage") =~ m|$::prefix(.*)|);
$tail && ($head ? "$head/$tail" : "/mnt/hd/$tail");
}
sub install_urpmi {
my ($prefix, $method, $packages, $mediums) = @_;
#- rare case where urpmi cannot be installed (no hd install path).
$method eq 'disk' && !hdInstallPath() and return;
my @cfg;
foreach (sort { $a->{medium} <=> $b->{medium} } values %$mediums) {
my $name = $_->{fakemedium};
if ($_->{ignored} || $_->{selected}) {
my $mask = umask 077;
open(my $LIST, ">$prefix/var/lib/urpmi/list.$name") or log::l("failed to write list.$name");
umask $mask;
my $dir = ($_->{prefix} || ${{ nfs => "file://mnt/nfs",
disk => "file:/" . hdInstallPath(),
ftp => $ENV{URLPREFIX},
http => $ENV{URLPREFIX},
cdrom => "removable://mnt/cdrom" }}{$method} ||
#- for live_update or live_install script.
readlink "/tmp/image/Mandrake" =~ m,^(\/.*)\/Mandrake\/*$, && "removable:/$1") . "/$_->{rpmsdir}";
#- build list file using internal data, synthesis file should exists.
if ($_->{end} > $_->{start}) {
#- WARNING this method of build only works because synthesis (or hdlist)
#- has been read.
foreach (@{$packages->{depslist}}[$_->{start} .. $_->{end}]) {
print $LIST "$dir/".$_->filename."\n";
}
} else {
#- need to use another method here to build synthesis.
open(my $F, "parsehdlist '$prefix/var/lib/urpmi/hdlist.$name.cz' |");
local $_;
while (<$F>) {
print $LIST "$dir/$_";
}
close $F;
}
close $LIST;
#- build synthesis file if there are still not existing (ie not copied from mirror).
if (-s "$prefix/var/lib/urpmi/synthesis.hdlist.$name.cz" <= 32) {
unlink "$prefix/var/lib/urpmi/synthesis.hdlist.$name.cz";
run_program::rooted($prefix, "parsehdlist", ">", "/var/lib/urpmi/synthesis.hdlist.$name",
"--synthesis", "/var/lib/urpmi/hdlist.$name.cz");
run_program::rooted($prefix, "gzip", "-S", ".cz", "/var/lib/urpmi/synthesis.hdlist.$name");
}
my ($qname, $qdir) = ($name, $dir);
$qname =~ s/(\s)/\\$1/g; $qdir =~ s/(\s)/\\$1/g;
#- output new urpmi.cfg format here.
push @cfg, "$qname " . ($dir !~ /^(ftp|http)/ && $qdir) . " {
hdlist: hdlist.$name.cz
with_hdlist: ../base/" . ($_->{update} ? "hdlist.cz" : $_->{hdlist}) . "
list: list.$name" . ($dir =~ /removable:/ && "
removable: /dev/cdrom") . ($_->{update} && "
update") . "
}
";
} else {
#- remove not selected media by removing hdlist and synthesis files copied.
unlink "$prefix/var/lib/urpmi/hdlist.$name.cz";
unlink "$prefix/var/lib/urpmi/synthesis.hdlist.$name.cz";
}
}
eval { output "$prefix/etc/urpmi/urpmi.cfg", @cfg };
}
#-###############################################################################
#- kde stuff
#-###############################################################################
sub kderc_largedisplay {
my ($prefix) = @_;
update_gnomekderc($_, 'KDE',
Contrast => 7,
kfmIconStyle => "Large",
kpanelIconStyle => "Normal", #- to change to Large when icons looks better
KDEIconStyle => "Large") foreach list_skels($prefix, '.kderc');
substInFile {
s/^(GridWidth)=85/$1=100/;
s/^(GridHeight)=70/$1=75/;
} $_ foreach list_skels($prefix, '.kde/share/config/kfmrc');
}
sub kdemove_desktop_file {
my ($prefix) = @_;
my @toMove = qw(doc.kdelnk news.kdelnk updates.kdelnk home.kdelnk printer.kdelnk floppy.kdelnk cdrom.kdelnk FLOPPY.kdelnk CDROM.kdelnk);
#- remove any existing save in Trash of each user and
#- move appropriate file there after an upgrade.
foreach my $dir (grep { -d $_ } list_skels($prefix, 'Desktop')) {
renamef("$dir/$_", "$dir/Trash/$_")
foreach grep { -e "$dir/$_" } @toMove, grep { /\.rpmorig$/ } all($dir)
}
}
#-###############################################################################
#- auto_install stuff
#-###############################################################################
sub auto_inst_file() { ($::g_auto_install ? "/tmp" : "$::prefix/root/drakx") . "/auto_inst.cfg.pl" }
sub report_bug {
my ($prefix) = @_;
any::report_bug($prefix, 'auto_inst' => g_auto_install('', 1));
}
sub g_auto_install {
my ($replay, $respect_privacy) = @_;
my $o = {};
require pkgs;
$o->{default_packages} = pkgs::selected_leaves($::o->{packages});
my @fields = qw(mntpoint type size);
$o->{partitions} = [ map { my %l; @l{@fields} = @$_{@fields}; \%l } grep { $_->{mntpoint} } @{$::o->{fstab}} ];
exists $::o->{$_} and $o->{$_} = $::o->{$_} foreach qw(locale authentication mouse netc timezone superuser intf keyboard users partitioning isUpgrade manualFstab nomouseprobe crypto security security_user libsafe netcnx useSupermount autoExitInstall mkbootdisk X services); #- TODO modules bootloader
if ($::o->{printer}) {
$o->{printer}{$_} = $::o->{printer}{$_} foreach qw(SPOOLER DEFAULT BROWSEPOLLADDR BROWSEPOLLPORT MANUALCUPSCONFIG);
$o->{printer}{configured} = {};
foreach my $queue (keys %{$::o->{printer}{configured}}) {
my $val = $::o->{printer}{configured}{$queue}{queuedata};
exists $val->{$_} and $o->{printer}{configured}{$queue}{queuedata}{$_} = $val->{$_} foreach keys %{$val || {}};
}
}
local $o->{partitioning}{auto_allocate} = !$replay;
$o->{autoExitInstall} = !$replay;
$o->{interactiveSteps} = [ 'doPartitionDisks', 'formatPartitions' ] if $replay;
#- deep copy because we're modifying it below
$o->{users} = [ @{$o->{users} || []} ];
my @user_info_to_remove = (
if_($respect_privacy, qw(name realname home pw)),
qw(oldu oldg password password2),
);
$_ = { %{$_ || {}} }, delete @$_{@user_info_to_remove} foreach $o->{superuser}, @{$o->{users} || []};
if ($respect_privacy && $o->{netcnx}) {
if (my $type = $o->{netcnx}{type}) {
my @netcnx_type_to_remove = qw(passwd passwd2 login phone_in phone_out);
$_ = { %{$_ || {}} }, delete @$_{@netcnx_type_to_remove} foreach $o->{netcnx}{$type};
}
}
require Data::Dumper;
my $str = join('',
"#!/usr/bin/perl -cw
#
# You should check the syntax of this file before using it in an auto-install.
# You can do this with 'perl -cw auto_inst.cfg.pl' or by executing this file
# (note the '#!/usr/bin/perl -cw' on the first line).
", Data::Dumper->Dump([$o], ['$o']), "\0");
$str =~ s/ {8}/\t/g; #- replace all 8 space char by only one tabulation, this reduces file size so much :-)
$str;
}
sub getAndSaveInstallFloppy {
my ($o, $where) = @_;
if ($postinstall_rpms && -d $postinstall_rpms && -r "$postinstall_rpms/auto_install.img") {
log::l("getAndSaveInstallFloppy: using file saved as $postinstall_rpms/auto_install.img");
cp_af("$postinstall_rpms/auto_install.img", $where);
} else {
my $image = cat_("/proc/cmdline") =~ /pcmcia/ ? "pcmcia" :
${{ disk => 'hd', cdrom => 'cdrom', ftp => 'network', nfs => 'network', http => 'network' }}{$o->{method}};
$image .= arch() =~ /sparc64/ && "64"; #- for sparc64 there are a specific set of image.
getAndSaveFile("images/$image.img", $where) or log::l("failed to write Install Floppy ($image.img) to $where"), return;
}
1;
}
sub getAndSaveAutoInstallFloppy {
my ($o, $replay, $where) = @_;
eval { modules::load('loop') };
if (arch() =~ /sparc/) {
my $imagefile = "$o->{prefix}/tmp/autoinst.img";
my $mountdir = "$o->{prefix}/tmp/mount"; mkdir_p($mountdir);
my $workdir = "$o->{prefix}/tmp/work"; -d $workdir or rmdir $workdir;
getAndSaveInstallFloppy($o, $imagefile) or return;
devices::make($_) foreach qw(/dev/loop6 /dev/ram);
run_program::run("losetup", "/dev/loop6", $imagefile);
fs::mount("/dev/loop6", $mountdir, "romfs", 'readonly');
cp_af($mountdir, $workdir);
fs::umount($mountdir);
run_program::run("losetup", "-d", "/dev/loop6");
substInFile { s/timeout.*//; s/^(\s*append\s*=\s*\".*)\"/$1 kickstart=floppy\"/ } "$workdir/silo.conf"; #" for po
#-TODO output "$workdir/ks.cfg", generate_ks_cfg($o);
output "$workdir/boot.msg", "\n7m",
"!! If you press enter, an auto-install is going to start.
ALL data on this computer is going to be lost,
including any Windows partitions !!
", "7m\n";
local $o->{partitioning}{clearall} = 1;
output("$workdir/auto_inst.cfg", g_auto_install());
run_program::run("genromfs", "-d", $workdir, "-f", "/dev/ram", "-A", "2048,/..", "-a", "512", "-V", "DrakX autoinst");
fs::mount("/dev/ram", $mountdir, 'romfs', 0);
run_program::run("silo", "-r", $mountdir, "-F", "-i", "/fd.b", "-b", "/second.b", "-C", "/silo.conf");
fs::umount($mountdir);
require commands;
commands::dd("if=/dev/ram", "of=$where", "bs=1440", "count=1024");
rm_rf($workdir, $mountdir, $imagefile);
} elsif (arch() =~ /ia64/) {
#- nothing yet
} else {
my $imagefile = "$o->{prefix}/root/autoinst.img";
my $mountdir = "$o->{prefix}/root/aif-mount"; -d $mountdir or mkdir $mountdir, 0755;
my $param = 'kickstart=floppy ' . generate_automatic_stage1_params($o);
getAndSaveInstallFloppy($o, $imagefile) or return;
my $dev = devices::set_loop($imagefile) or log::l("couldn't set loopback device"), return;
eval { fs::mount($dev, $mountdir, 'vfat', 0); 1 } or return;
substInFile {
s/timeout.*/$replay ? 'timeout 1' : ''/e;
s/^(\s*append)/$1 $param/
} "$mountdir/syslinux.cfg";
unlink "$mountdir/help.msg";
output "$mountdir/boot.msg", "\n0c",
"!! If you press enter, an auto-install is going to start.
All data on this computer is going to be lost,
including any Windows partitions !!
", "07\n" if !$replay;
local $o->{partitioning}{clearall} = !$replay;
eval { output("$mountdir/auto_inst.cfg", g_auto_install($replay)) };
$@ and log::l("Warning: <$@>");
fs::umount($mountdir);
rmdir $mountdir;
devices::del_loop($dev);
require commands;
commands::dd("if=$imagefile", "of=$where", "bs=1440", "count=1024");
unlink $imagefile;
}
1;
}
sub g_default_packages {
my ($o, $quiet) = @_;
my $floppy = detect_devices::floppy();
while (1) {
$o->ask_okcancel('', N("Insert a FAT formatted floppy in drive %s", $floppy), 1) or return;
eval { fs::mount(devices::make($floppy), "/floppy", "vfat", 0) };
last if !$@;
$o->ask_warn('', N("This floppy is not FAT formatted"));
}
require Data::Dumper;
my $str = Data::Dumper->Dump([ { default_packages => pkgs::selected_leaves($o->{packages}) } ], ['$o']);
$str =~ s/ {8}/\t/g;
output('/floppy/auto_inst.cfg',
"# You should always check the syntax with 'perl -cw auto_inst.cfg.pl'\n",
"# before testing. To use it, boot with ``linux defcfg=floppy''\n",
$str, "\0");
fs::umount("/floppy");
$quiet or $o->ask_warn('', N("To use this saved packages selection, boot installation with ``linux defcfg=floppy''"));
}
sub loadO {
my ($O, $f) = @_; $f ||= auto_inst_file();
my $o;
if ($f =~ /^(floppy|patch)$/) {
my $f = $f eq "floppy" ? 'auto_inst.cfg' : "patch";
unless ($::testing) {
fs::mount(devices::make(detect_devices::floppy()), "/mnt", (arch() =~ /sparc/ ? "romfs" : "vfat"), 'readonly');
$f = "/mnt/$f";
}
-e $f or $f .= '.pl';
my $_b = before_leaving {
fs::umount("/mnt") unless $::testing;
modules::unload(qw(vfat fat));
};
$o = loadO($O, $f);
} else {
-e "$f.pl" and $f .= ".pl" unless -e $f;
my $fh;
if (-e $f) { open $fh, $f } else { $fh = getFile($f) or die N("Error reading file %s", $f) }
{
local $/ = "\0";
no strict;
eval <$fh>;
close $fh;
$@ and die;
}
$O and add2hash_($o ||= {}, $O);
}
$O and bless $o, ref $O;
$o;
}
sub generate_automatic_stage1_params {
my ($o) = @_;
my @ks = "method:$o->{method}";
if ($o->{method} eq 'http') {
$ENV{URLPREFIX} =~ m|http://([^/:]+)/(.*)| or die;
push @ks, "server:$1", "directory:$2";
} elsif ($o->{method} eq 'ftp') {
push @ks, "server:$ENV{HOST}", "directory:$ENV{PREFIX}", "user:$ENV{LOGIN}", "pass:$ENV{PASSWORD}";
} elsif ($o->{method} eq 'nfs') {
cat_("/proc/mounts") =~ m|(\S+):(\S+)\s+/tmp/image nfs| or die;
push @ks, "server:$1", "directory:$2";
}
if (member($o->{method}, qw(http ftp nfs))) {
my ($intf) = values %{$o->{intf}};
push @ks, "interface:$intf->{DEVICE}";
if ($intf->{BOOTPROTO} eq 'dhcp') {
push @ks, "network:dhcp";
} else {
require network;
push @ks, "network:static", "ip:$intf->{IPADDR}", "netmask:$intf->{NETMASK}", "gateway:$o->{netc}{GATEWAY}";
my @dnss = network::dnsServers($o->{netc});
push @ks, "dns:$dnss[0]" if @dnss;
}
}
#- sync it with ../mdk-stage1/automatic.c
my %aliases = (method => 'met', network => 'netw', interface => 'int', gateway => 'gat', netmask => 'netm',
adsluser => 'adslu', adslpass => 'adslp', hostname => 'hos', domain => 'dom', server => 'ser',
directory => 'dir', user => 'use', pass => 'pas', disk => 'dis', partition => 'par');
'automatic='.join(',', map { /^([^:]+)(:.*)/ && $aliases{$1} ? $aliases{$1}.$2 : $_ } @ks);
}
sub guess_mount_point {
my ($part, $prefix, $user) = @_;
my %l = (
'/' => 'etc/fstab',
'/boot' => 'vmlinuz',
'/tmp' => '.X11-unix',
'/usr' => 'X11R6',
'/var' => 'catman',
);
my $handle = any::inspect($part, $prefix) or return;
my $d = $handle->{dir};
my $mnt = find { -e "$d/$l{$_}" } keys %l;
$mnt ||= (stat("$d/.bashrc"))[4] ? '/root' : '/home/user' . ++$$user if -e "$d/.bashrc";
$mnt ||= (any { -d $_ && (stat($_))[4] >= 500 && -e "$_/.bashrc" } glob_($d)) ? '/home' : '';
($mnt, $handle);
}
sub suggest_mount_points {
my ($fstab, $prefix, $uniq) = @_;
my $user;
foreach my $part (grep { isTrueFS($_) } @$fstab) {
$part->{mntpoint} && !$part->{unsafeMntpoint} and next; #- if already found via an fstab
my ($mnt, $handle) = guess_mount_point($part, $prefix, \$user) or next;
next if $uniq && fsedit::mntpoint2part($mnt, $fstab);
$part->{mntpoint} = $mnt; delete $part->{unsafeMntpoint};
#- try to find other mount points via fstab
fs::merge_info_from_fstab($fstab, $handle->{dir}, $uniq, 'loose') if $mnt eq '/';
}
$_->{mntpoint} and log::l("suggest_mount_points: $_->{device} -> $_->{mntpoint}") foreach @$fstab;
}
sub find_root_parts {
my ($fstab, $prefix) = @_;
map {
my $handle = any::inspect($_, $prefix);
my $s = $handle && cat_("$handle->{dir}/etc/mandrake-release");
if ($s) {
chomp($s);
$s =~ s/\s+for\s+\S+//;
log::l("find_root_parts found $_->{device}: $s");
{ release => $s, part => $_ };
} else { () }
} @$fstab;
}
sub use_root_part {
my ($all_hds, $part, $prefix) = @_;
my $fstab = [ fsedit::get_really_all_fstab($all_hds) ];
{
my $handle = any::inspect($part, $prefix) or die;
fs::merge_info_from_fstab($fstab, $handle->{dir}, 'uniq');
}
map { $_->{mntpoint} = 'swap' } grep { isSwap($_) } @$fstab; #- use all available swap.
}
sub getHds {
my ($o, $in) = @_;
getHds:
my $all_hds = fsedit::get_hds($o->{partitioning}, $in);
my $hds = $all_hds->{hds};
if (is_empty_array_ref($hds)) { #- no way
die N("An error occurred - no valid devices were found on which to create new filesystems. Please check your hardware for the cause of this problem");
}
#- try to figure out if the same number of hds is available, use them if ok.
@{$o->{all_hds}{hds} || []} == @$hds and return 1;
fs::get_raw_hds('', $all_hds);
fs::add2all_hds($all_hds, @{$o->{manualFstab}});
$o->{all_hds} = $all_hds;
$o->{fstab} = [ fsedit::get_all_fstab($all_hds) ];
fs::merge_info_from_mtab($o->{fstab});
my @win = grep { isFat_or_NTFS($_) && isFat_or_NTFS({ type => fsedit::typeOfPart($_->{device}) }) } @{$o->{fstab}};
log::l("win parts: ", join ",", map { $_->{device} } @win) if @win;
if (@win == 1) {
#- Suggest /boot/efi on ia64.
$win[0]{mntpoint} = arch() =~ /ia64/ ? "/boot/efi" : "/mnt/windows";
} else {
my %w; foreach (@win) {
my $v = $w{$_->{device_windobe}}++;
$_->{mntpoint} = $_->{unsafeMntpoint} = "/mnt/win_" . lc($_->{device_windobe}) . ($v ? $v+1 : ''); #- lc cuz of StartOffice(!) cf dadou
}
}
my @sunos = grep { isSunOS($_) && type2name($_->{type}) =~ /root/i } @{$o->{fstab}}; #- take only into account root partitions.
if (@sunos) {
my $v = '';
map { $_->{mntpoint} = $_->{unsafeMntpoint} = "/mnt/sunos" . ($v && ++$v) } @sunos;
}
#- a good job is to mount SunOS root partition, and to use mount point described here in /etc/vfstab.
1;
}
sub log_sizes {
my ($o) = @_;
my @df = MDK::Common::System::df($o->{prefix});
log::l(sprintf "Installed: %s(df), %s(rpm)",
formatXiB($df[0] - $df[1], 1024),
formatXiB(sum(run_program::rooted_get_stdout($o->{prefix}, 'rpm', '-qa', '--queryformat', '%{size}\n')))) if -x "$o->{prefix}/bin/rpm";
}
sub copy_advertising {
my ($o) = @_;
return if $::rootwidth < 800;
my $f;
my $source_dir = "Mandrake/share/advertising";
foreach ("." . $o->{locale}{lang}, "." . substr($o->{locale}{lang},0,2), '') {
$f = getFile("$source_dir$_/list") or next;
$source_dir = "$source_dir$_";
}
if (my @files = <$f>) {
my $dir = "$o->{prefix}/tmp/drakx-images";
mkdir $dir;
unlink glob_("$dir/*");
foreach (@files) {
chomp;
getAndSaveFile("$source_dir/$_", "$dir/$_");
s/\.png/\.pl/;
getAndSaveFile("$source_dir/$_", "$dir/$_");
s/\.pl/_icon\.png/;
getAndSaveFile("$source_dir/$_", "$dir/$_");
s/_icon\.png/\.png/;
}
@advertising_images = map { "$dir/$_" } @files;
}
}
sub remove_advertising {
my ($o) = @_;
eval { rm_rf("$o->{prefix}/tmp/drakx-images") };
@advertising_images = ();
}
sub disable_user_view {
my ($prefix) = @_;
substInFile { s/^UserView=.*/UserView=true/ } "$prefix/usr/share/config/kdm/kdmrc";
substInFile { s/^Browser=.*/Browser=0/ } "$prefix/etc/X11/gdm/gdm.conf";
}
sub set_security {
my ($o) = @_;
{
local $ENV{DRAKX_PASSWORD} = $o->{bootloader}{password};
local $ENV{DURING_INSTALL} = 1;
security::level::set($o->{security});
}
require security::various;
security::various::config_libsafe($::prefix, $o->{libsafe});
security::various::config_security_user($::prefix, $o->{security_user});
}
sub write_fstab {
my ($o) = @_;
fs::write_fstab($o->{all_hds}, $o->{prefix}) if !$::live && !$o->{isUpgrade};
}
my @bigseldom_used_groups = (
);
sub check_prog {
my ($f) = @_;
my @l = $f !~ m|^/| ?
map { "$_/$f" } split(":", $ENV{PATH}) :
$f;
return if any { -x $_ } @l;
common::usingRamdisk() or log::l("ERROR: check_prog can't find the program $f and we're not using ramdisk"), return;
my ($f_) = map { m|^/| ? $_ : "/usr/bin/$_" } $f;
remove_bigseldom_used();
foreach (@bigseldom_used_groups) {
my (@l) = map { m|^/| ? $_ : "/usr/bin/$_" } @$_;
if (member($f_, @l)) {
foreach (@l) {
getAndSaveFile($_);
chmod 0755, $_;
}
return;
}
}
getAndSaveFile($f_);
chmod 0755, $f_;
}
sub remove_unused {
$::testing and return;
if (@_ ? $_[0] : $::o->isa('interactive::gtk')) {
unlink glob_("/lib/lib$_*") foreach qw(slang newt);
unlink "/usr/bin/perl-install/auto/Newt/Newt.so";
} else {
unlink glob_("/usr/X11R6/bin/XF*");
}
}
sub remove_bigseldom_used {
log::l("remove_bigseldom_used");
$::testing and return;
remove_unused();
unlink "/usr/X11R6/lib/modules/xf86Wacom.so";
unlink glob_("/usr/share/gtk/themes/$_*") foreach qw(marble3d);
unlink(m|^/| ? $_ : "/usr/bin/$_") foreach
(map { @$_ } @bigseldom_used_groups),
qw(pvcreate pvdisplay vgchange vgcreate vgdisplay vgextend vgremove vgscan lvcreate lvdisplay lvremove /lib/liblvm.so),
qw(mkreiserfs resize_reiserfs mkfs.xfs fsck.jfs);
}
################################################################################
package pkgs_interactive;
use run_program;
use common;
use pkgs;
our @ISA = qw(); #- tell perl_checker this is a class
sub install_steps::do_pkgs {
my ($o) = @_;
bless { o => $o }, 'pkgs_interactive';
}
sub install {
my ($do, @l) = @_;
$do->{o}->pkg_install(@l);
}
sub ensure_is_installed {
my ($do, $pkg, $file, $auto) = @_;
if (! -e "$::prefix$file") {
$do->{o}->ask_okcancel('', N("The package %s needs to be installed. Do you want to install it?", $pkg), 1)
or return if !$auto;
$do->{o}->do_pkgs->install($pkg);
}
if (! -e "$::prefix$file") {
$do->{o}->ask_warn('', N("Mandatory package %s is missing", $pkg));
return;
}
1;
}
sub what_provides {
my ($do, $name) = @_;
map { $do->{o}{packages}{depslist}[$_]->name } keys %{$do->{o}{packages}{provides}{$name} || {}};
}
sub is_installed {
my ($do, @l) = @_;
foreach (@l) {
my $p = pkgs::packageByName($do->{o}{packages}, $_);
$p && $p->flag_available or return;
}
1;
}
sub are_installed {
my ($do, @l) = @_;
grep {
my $p = pkgs::packageByName($do->{o}{packages}, $_);
$p && $p->flag_available;
} @l;
}
sub remove {
my ($do, @l) = @_;
@l = grep {
my $p = pkgs::packageByName($do->{o}{packages}, $_);
pkgs::unselectPackage($do->{o}{packages}, $p) if $p;
$p;
} @l;
run_program::rooted($do->{o}{prefix}, 'rpm', '-e', @l);
}
sub remove_nodeps {
my ($do, @l) = @_;
@l = grep {
my $p = pkgs::packageByName($do->{o}{packages}, $_);
if ($p) {
$p->set_flag_requested(0);
$p->set_flag_required(0);
}
$p;
} @l;
run_program::rooted($do->{o}{prefix}, 'rpm', '-e', '--nodeps', @l);
}
################################################################################
package install_any;
1;
ref='#n1085'>1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
package install_steps_interactive; # $Id$
use diagnostics;
use strict;
use vars qw(@ISA $new_bootstrap);
@ISA = qw(install_steps);
#-######################################################################################
#- misc imports
#-######################################################################################
use common;
use partition_table qw(:types);
use partition_table_raw;
use install_steps;
use install_interactive;
use install_any;
use detect_devices;
use run_program;
use devices;
use fsedit;
use loopback;
use mouse;
use modules;
use lang;
use keyboard;
use any;
use fs;
use log;
#-######################################################################################
#- In/Out Steps Functions
#-######################################################################################
sub errorInStep($$) {
my ($o, $err) = @_;
$o->ask_warn(_("Error"), [ _("An error occurred"), common::formatError($err) ]);
}
sub kill_action {
my ($o) = @_;
$o->kill;
}
sub charsetChanged {}
#-######################################################################################
#- Steps Functions
#-######################################################################################
#------------------------------------------------------------------------------
sub selectLanguage {
my ($o) = @_;
$o->{lang} = any::selectLanguage($o, $o->{lang}, $o->{langs} ||= {});
install_steps::selectLanguage($o);
$o->charsetChanged;
$o->ask_warn('', formatAlaTeX(
"If you see this message it is because you choose a language for
which DrakX does not include a translation yet; however the fact
that it is listed means there is some support for it anyway.
That is, once GNU/Linux will be installed, you will be able to at
least read and write in that language; and possibly more (various
fonts, spell checkers, various programs translated etc. that
varies from language to language).")) if $o->{lang} !~ /^en/ && !lang::load_mo();
unless ($o->{useless_thing_accepted}) {
$o->set_help('license');
$o->{useless_thing_accepted} = $o->ask_from_list_(_("License agreement"), formatAlaTeX(
_("Introduction
The operating system and the different components available in the Mandrake Linux distribution
shall be called the \"Software Products\" hereafter. The Software Products include, but are not
restricted to, the set of programs, methods, rules and documentation related to the operating
system and the different components of the Mandrake Linux distribution.
1. License Agreement
Please read carefully this document. This document is a license agreement between you and
MandrakeSoft S.A. which applies to the Software Products.
By installing, duplicating or using the Software Products in any manner, you explicitly
accept and fully agree to conform to the terms and conditions of this License.
If you disagree with any portion of the License, you are not allowed to install, duplicate or use
the Software Products.
Any attempt to install, duplicate or use the Software Products in a manner which does not comply
with the terms and conditions of this License is void and will terminate your rights under this
License. Upon termination of the License, you must immediately destroy all copies of the
Software Products.
2. Limited Warranty
The Software Products and attached documentation are provided \"as is\", with no warranty, to the
extent permitted by law.
MandrakeSoft S.A. will, in no circumstances and to the extent permitted by law, be liable for any special,
incidental, direct or indirect damages whatsoever (including without limitation damages for loss of
business, interruption of business, financial loss, legal fees and penalties resulting from a court
judgment, or any other consequential loss) arising out of the use or inability to use the Software
Products, even if MandrakeSoft S.A. has been advised of the possibility or occurance of such
damages.
LIMITED LIABILITY LINKED TO POSSESSING OR USING PROHIBITED SOFTWARE IN SOME COUNTRIES
To the extent permitted by law, MandrakeSoft S.A. or its distributors will, in no circumstances, be
liable for any special, incidental, direct or indirect damages whatsoever (including without
limitation damages for loss of business, interruption of business, financial loss, legal fees
and penalties resulting from a court judgment, or any other consequential loss) arising out
of the possession and use of software components or arising out of downloading software components
from one of Mandrake Linux sites which are prohibited or restricted in some countries by local laws.
This limited liability applies to, but is not restricted to, the strong cryptography components
included in the Software Products.
3. The GPL License and Related Licenses
The Software Products consist of components created by different persons or entities. Most
of these components are governed under the terms and conditions of the GNU General Public
Licence, hereafter called \"GPL\", or of similar licenses. Most of these licenses allow you to use,
duplicate, adapt or redistribute the components which they cover. Please read carefully the terms
and conditions of the license agreement for each component before using any component. Any question
on a component license should be addressed to the component author and not to MandrakeSoft.
The programs developed by MandrakeSoft S.A. are governed by the GPL License. Documentation written
by MandrakeSoft S.A. is governed by a specific license. Please refer to the documentation for
further details.
4. Intellectual Property Rights
All rights to the components of the Software Products belong to their respective authors and are
protected by intellectual property and copyright laws applicable to software programs.
MandrakeSoft S.A. reserves its rights to modify or adapt the Software Products, as a whole or in
parts, by all means and for all purposes.
\"Mandrake\", \"Mandrake Linux\" and associated logos are trademarks of MandrakeSoft S.A.
5. Governing Laws
If any portion of this agreement is held void, illegal or inapplicable by a court judgment, this
portion is excluded from this contract. You remain bound by the other applicable sections of the
agreement.
The terms and conditions of this License are governed by the Laws of France.
All disputes on the terms of this license will preferably be settled out of court. As a last
resort, the dispute will be referred to the appropriate Courts of Law of Paris - France.
For any question on this document, please contact MandrakeSoft S.A.
")), [ __("Accept"), __("Refuse") ], "Refuse") eq "Accept" or $o->exit;
}
}
#------------------------------------------------------------------------------
sub selectKeyboard {
my ($o, $clicked) = @_;
my $l = keyboard::lang2keyboards($o->{lang});
#- good guess, don't ask
return if !$::expert && !$clicked && $l->[0][1] > 90;
my @best = map { $_->[0] } @$l;
push @best, 'us_intl' if !member('us_intl', @best);
my $format = sub { translate(keyboard::keyboard2text($_[0])) };
my $other;
my $ext_keyboard = $o->{keyboard};
$o->ask_from_(
{ title => _("Keyboard"),
messages => _("Please, choose your keyboard layout."),
advanced_messages => _("Here is the full list of keyboards available"),
advanced_label => _("More"),
callbacks => { changed => sub { $other = $_[0]==1 } },
},
[ if_(@best > 1, { val => \$o->{keyboard}, type => 'list', format => $format,
list => [ @best ] }),
{ val => \$ext_keyboard, type => 'list', format => $format,
list => [ keyboard::keyboards ], advanced => @best > 1 }
]);
delete $o->{keyboard_unsafe};
$o->{keyboard} = $ext_keyboard if $other;
install_steps::selectKeyboard($o);
}
#------------------------------------------------------------------------------
sub selectInstallClass1 {
my ($o, $verif, $l, $def, $l2, $def2) = @_;
$verif->($o->ask_from_list(_("Install Class"), _("Which installation class do you want?"), $l, $def) || die 'already displayed');
$::live ? 'Update' : $o->ask_from_list_(_("Install/Update"), _("Is this an install or an update?"), $l2, $def2);
}
#------------------------------------------------------------------------------
sub selectInstallClass {
my ($o, $clicked) = @_;
my %c = my @c = (
if_(!$::corporate,
_("Recommended") => "beginner",
),
if_($o->{meta_class} ne 'desktop',
_("Expert") => "expert",
),
);
%c = @c = (_("Expert") => "expert") if $::expert && !$clicked;
$o->set_help('selectInstallClassCorpo') if $::corporate;
my $verifInstallClass = sub { $::expert = $c{$_[0]} eq "expert" };
$o->{isUpgrade} = $o->selectInstallClass1($verifInstallClass,
first(list2kv(@c)), ${{reverse %c}}{$::expert ? "expert" : "beginner"},
[ __("Install"), __("Update") ], $o->{isUpgrade} ? "Update" : "Install") eq "Update";
install_steps::selectInstallClass($o);
}
#------------------------------------------------------------------------------
sub selectMouse {
my ($o, $force) = @_;
$force ||= $o->{mouse}{unsafe} || $::expert;
my $prev = $o->{mouse}{type} . '|' . $o->{mouse}{name};
$o->{mouse} = mouse::fullname2mouse(
$o->ask_from_treelist_('', _("Please, choose the type of your mouse."),
'|', [ mouse::fullnames ], $prev)) if $force;
if ($force && $o->{mouse}{type} eq 'serial') {
$o->set_help('selectSerialPort');
$o->{mouse}{device} =
$o->ask_from_listf(_("Mouse Port"),
_("Please choose on which serial port your mouse is connected to."),
\&mouse::serial_port2text,
[ mouse::serial_ports ]) or return;
}
if (arch() =~ /ppc/ && $o->{mouse}{nbuttons} == 1) {
#- set a sane default F11/F12
$o->{mouse}{button2_key} = 87;
$o->{mouse}{button3_key} = 88;
$o->ask_from('', _("Buttons emulation"),
[
{ label => _("Button 2 Emulation"), val => \$o->{mouse}{button2_key}, list => [ mouse::ppc_one_button_keys() ], format => \&mouse::ppc_one_button_key2text },
{ label => _("Button 3 Emulation"), val => \$o->{mouse}{button3_key}, list => [ mouse::ppc_one_button_keys() ], format => \&mouse::ppc_one_button_key2text },
]) or return;
}
any::setup_thiskind($o, 'usb', !$::expert, 0, $o->{pcmcia}) if $o->{mouse}{device} eq "usbmouse";
eval {
devices::make("usbmouse");
modules::load("usbmouse");
modules::load("mousedev");
} if $o->{mouse}{device} eq "usbmouse";
$o->SUPER::selectMouse;
}
#------------------------------------------------------------------------------
sub setupSCSI {
my ($o, $clicked) = @_;
if (!$::noauto && arch() =~ /i.86/) {
if ($o->{pcmcia} ||= !$::testing && c::pcmcia_probe()) {
my $w = $o->wait_message(_("PCMCIA"), _("Configuring PCMCIA cards..."));
modules::configure_pcmcia($o->{pcmcia});
}
}
{
my $w = $o->wait_message(_("IDE"), _("Configuring IDE"));
modules::load_ide();
}
any::setup_thiskind($o, 'scsi|disk', !$::expert && !$clicked, $clicked, $o->{pcmcia});
install_interactive::tellAboutProprietaryModules($o) if !$clicked;
}
sub ask_mntpoint_s {
my ($o, $fstab) = @_;
$o->set_help('ask_mntpoint_s');
my @fstab = grep { isTrueFS($_) } @$fstab;
@fstab = grep { isSwap($_) } @$fstab if @fstab == 0;
@fstab = @$fstab if @fstab == 0;
die _("no available partitions") if @fstab == 0;
{
my $w = $o->wait_message('', _("Scanning partitions to find mount points"));
install_any::suggest_mount_points($fstab, $o->{prefix}, 'uniq');
log::l("default mntpoint $_->{mntpoint} $_->{device}") foreach @fstab;
}
if (@fstab == 1) {
$fstab[0]{mntpoint} = '/';
} else {
$o->ask_from('',
_("Choose the mount points"),
[ map { { label => partition_table::description($_),
val => \$_->{mntpoint},
not_edit => 0,
list => [ '', fsedit::suggestions_mntpoint(fsedit::empty_all_hds()) ] }
} grep { !$_->{real_mntpoint} || common::usingRamdisk() } @fstab ]) or return;
}
$o->SUPER::ask_mntpoint_s($fstab);
}
#------------------------------------------------------------------------------
sub doPartitionDisks {
my ($o) = @_;
my $warned;
install_any::getHds($o, sub {
my ($err) = @_;
$warned = 1;
if ($o->ask_yesorno(_("Error"),
_("I can't read your partition table, it's too corrupted for me :(
I can try to go on blanking bad partitions (ALL DATA will be lost!).
The other solution is to disallow DrakX to modify the partition table.
(the error is %s)
Do you agree to loose all the partitions?
", $err))) {
0;
} else {
$o->{partitioning}{readonly} = 1;
1;
}
}) or $warned or $o->ask_warn('',
_("DiskDrake failed to read correctly the partition table.
Continue at your own risk!"));
if (arch() =~ /ppc/ && detect_devices::get_mac_generation =~ /NewWorld/) { #- need to make bootstrap part if NewWorld machine - thx Pixel ;^)
if (defined $partition_table_mac::bootstrap_part) {
#- don't do anything if we've got the bootstrap setup
#- otherwise, go ahead and create one somewhere in the drive free space
} else {
if (defined $partition_table_mac::freepart_start && $partition_table_mac::freepart_size >= 1) {
my ($hd) = $partition_table_mac::freepart_device;
log::l("creating bootstrap partition on drive /dev/$hd->{device}, block $partition_table_mac::freepart_start");
$partition_table_mac::bootstrap_part = $partition_table_mac::freepart_part;
log::l("bootstrap now at $partition_table_mac::bootstrap_part");
fsedit::add($hd, { start => $partition_table_mac::freepart_start, size => 1 << 11, type => 0x401, mntpoint => '' }, $o->{all_hds}, { force => 1, primaryOrExtended => 'Primary' });
$new_bootstrap = 1;
} else {
$o->ask_warn('',_("No free space for 1MB bootstrap! Install will continue, but to boot your system, you'll need to create the bootstrap partition in DiskDrake"));
}
}
}
if ($o->{isUpgrade}) {
# either one root is defined (and all is ok), or we take the first one we find
my $p = fsedit::get_root_($o->{fstab});
if (!$p) {
my @l = install_any::find_root_parts($o->{fstab}, $o->{prefix}) or die _("No root partition found to perform an upgrade");
$p = $o->ask_from_listf(_("Root Partition"),
_("What is the root partition (/) of your system?"),
\&partition_table::description, \@l) or die "setstep exitInstall\n";
}
install_any::use_root_part($o->{fstab}, $p, $o->{prefix});
} elsif ($::expert && $o->isa('interactive_gtk')) {
install_interactive::partition_with_diskdrake($o, $o->{all_hds});
} else {
install_interactive::partitionWizard($o);
}
}
#------------------------------------------------------------------------------
sub rebootNeeded {
my ($o) = @_;
$o->ask_warn('', _("You need to reboot for the partition table modifications to take place"));
install_steps::rebootNeeded($o);
}
#------------------------------------------------------------------------------
sub choosePartitionsToFormat {
my ($o, $fstab) = @_;
$o->SUPER::choosePartitionsToFormat($fstab);
my @l = grep { !$_->{isMounted} && $_->{mntpoint} &&
(!isSwap($_) || $::expert) &&
(!isFat($_) || $_->{notFormatted} || $::expert) &&
(!isOtherAvailableFS($_) || $::expert || $_->{toFormat})
} @$fstab;
$_->{toFormat} = 1 foreach grep { isSwap($_) && !$::expert } @$fstab;
return if @l == 0 || !$::expert && 0 == grep { ! $_->{toFormat} } @l;
#- keep it temporary until the guy has accepted
$_->{toFormatTmp} = $_->{toFormat} || $_->{toFormatUnsure} foreach @l;
$o->ask_from_(
{ messages => _("Choose the partitions you want to format"),
advanced_messages => _("Check bad blocks?"),
},
[ map {
my $e = $_;
({
text => partition_table::description($e), type => 'bool',
val => \$e->{toFormatTmp}
}, if_(!isLoopback($_) && !isThisFs("reiserfs", $_), {
text => partition_table::description($e), type => 'bool', advanced => 1,
disabled => sub { !$e->{toFormatTmp} },
val => \$e->{toFormatCheck}
})) } @l ]
) or die 'already displayed';
#- ok now we can really set toFormat
foreach (@l) {
$_->{toFormat} = delete $_->{toFormatTmp};
$_->{isFormatted} = 0;
}
}
sub formatMountPartitions {
my ($o, $fstab) = @_;
my $w;
fs::formatMount_all($o->{all_hds}{raids}, $o->{fstab}, $o->{prefix}, sub {
my ($part) = @_;
$w ||= $o->wait_message('', _("Formatting partitions"));
$w->set(isLoopback($part) ?
_("Creating and formatting file %s", $part->{device}) :
_("Formatting partition %s", $part->{device}));
});
die _("Not enough swap to fulfill installation, please add some") if availableMemory < 40 * 1024;
}
#------------------------------------------------------------------------------
sub setPackages {
my ($o) = @_;
my $w = $o->wait_message('', _("Looking for available packages"));
$o->SUPER::setPackages;
}
#------------------------------------------------------------------------------
sub selectPackagesToUpgrade {
my ($o) = @_;
my $w = $o->wait_message('', _("Finding packages to upgrade"));
$o->SUPER::selectPackagesToUpgrade();
}
#------------------------------------------------------------------------------
sub choosePackages {
my ($o, $packages, $compssUsers, $first_time) = @_;
#- this is done at the very beginning to take into account
#- selection of CD by user if using a cdrom.
$o->chooseCD($packages) if $o->{method} eq 'cdrom';
my $availableC = install_steps::choosePackages(@_);
my $individual = $::expert;
require pkgs;
my $min_size = pkgs::selectedSize($packages);
$min_size < $availableC or die _("Your system has not enough space left for installation or upgrade (%d > %d)", $min_size, $availableC);
my $min_mark = $::expert ? 3 : 4;
my $def_mark = 4; #-TODO: was 59, 59 is for packages that need gl hw acceleration.
my $b = pkgs::saveSelected($packages);
pkgs::setSelectedFromCompssList($packages, $o->{compssUsersChoice}, $def_mark, 0);
my $def_size = pkgs::selectedSize($packages) + 1; #- avoid division by zero.
my $level = pkgs::setSelectedFromCompssList($packages, { map { $_ => 1 } map { @{$compssUsers->{$_}{flags}} } @{$o->{compssUsersSorted}} }, $min_mark, 0);
my $max_size = pkgs::selectedSize($packages) + 1; #- avoid division by zero.
pkgs::restoreSelected($b);
$o->chooseGroups($packages, $compssUsers, $min_mark, \$individual, $max_size) if !$::corporate;
my $size2install = min($availableC, do {
my $max = round_up(min($max_size, $availableC) / sqr(1024), 100);
if (1) {
my (@l);
my @text = (__("Minimum (%dMB)"), __("Recommended (%dMB)"), __("Complete (%dMB)"));
if ($o->{meta_class} eq 'desktop') {
@l = (300, 500, 800, 0);
$max > $l[2] or splice(@l, 2, 1);
$max > $l[1] or splice(@l, 1, 1);
$max > $l[0] or @l = $max;
$text[$#l] = __("Custom");
} else {
@l = (300, 700, $max);
$l[2] > $l[1] + 200 or splice(@l, 1, 1); #- not worth proposing too alike stuff
$l[1] > $l[0] + 100 or splice(@l, 0, 1);
}
$o->set_help('empty');
# $o->ask_from_listf('', _("Select the size you want to install"),
# sub { _ ($text[$_[0]], $_[0]) }, \@l, $l[1]) * sqr(1024);
$max * sqr(1024);
} else {
$o->chooseSizeToInstall($packages, $min_size, $def_size, $max_size, $availableC, $individual) || goto &choosePackages;
}
});
if (!$size2install) { #- special case for desktop
$o->chooseGroups($packages, $compssUsers, $min_mark) or goto &choosePackages;
$size2install = $availableC;
}
($o->{packages_}{ind}) =
pkgs::setSelectedFromCompssList($packages, $o->{compssUsersChoice}, $min_mark, $size2install);
$o->choosePackagesTree($packages) if $individual;
install_any::warnAboutNaughtyServers($o);
}
sub chooseSizeToInstall {
my ($o, $packages, $min, $def, $max, $availableC) = @_;
min($def, $availableC * 0.7);
}
sub choosePackagesTree {
my ($o, $packages) = @_;
$o->ask_many_from_list('', _("Choose the packages you want to install"),
{
list => [ #grep { pkgs::packageMedium($_)->{selected} }
map { pkgs::packageByName($packages, $_) }
keys %{$packages->{names}} ],
value => \&pkgs::packageFlagSelected,
label => \&pkgs::packageName,
sort => 1,
});
}
sub loadSavePackagesOnFloppy {
my ($o, $packages) = @_;
my $choice = $o->ask_from_listf('',
_("Please choose load or save package selection on floppy.
The format is the same as auto_install generated floppies."),
sub { translate($_[0]{text}) },
[ { text => _("Load from floppy"), code => sub {
while (1) {
my $w = $o->wait_message(_("Package selection"), _("Loading from floppy"));
log::l("load package selection from floppy");
my $O = eval { install_any::loadO({}, 'floppy') };
if ($@) {
$w = undef; #- close wait message.
$o->ask_okcancel('', _("Insert a floppy containing package selection"))
or return;
} else {
install_any::unselectMostPackages($o);
foreach (@{$O->{default_packages} || []}) {
my $pkg = pkgs::packageByName($packages, $_);
pkgs::selectPackage($packages, $pkg) if $pkg;
}
return 1;
}
}
} },
{ text => _("Save on floppy"), code => sub {
log::l("save package selection to floppy");
install_any::g_default_packages($o, 'quiet');
} },
]);
$choice->{code} and $choice->{code}();
}
sub chooseGroups {
my ($o, $packages, $compssUsers, $min_level, $individual, $max_size) = @_;
my $b = pkgs::saveSelected($packages);
install_any::unselectMostPackages($o);
pkgs::setSelectedFromCompssList($packages, {}, $min_level, $max_size);
my $system_size = pkgs::selectedSize($packages);
my ($sizes, $pkgs) = pkgs::computeGroupSize($packages, $min_level);
pkgs::restoreSelected($b);
log::l("system_size: $system_size");
my @groups = @{$o->{compssUsersSorted}};
my %stable_flags = grep_each { $::b } %{$o->{compssUsersChoice}};
delete $stable_flags{$_} foreach map { @{$compssUsers->{$_}{flags}} } @groups;
my $compute_size = sub {
my %pkgs;
my %flags = %stable_flags; @flags{@_} = ();
my $total_size;
A: while (my ($k, $size) = each %$sizes) {
Or: foreach (split "\t", $k) {
foreach (split "&&") {
exists $flags{$_} or next Or;
}
$total_size += $size;
$pkgs{$_} = 1 foreach @{$pkgs->{$k}};
next A;
}
}
log::l("computed size $total_size");
log::l("chooseGroups: ", join(" ", sort keys %pkgs));
int $total_size;
};
my %val = map {
$_ => ! grep { ! $o->{compssUsersChoice}{$_} } @{$compssUsers->{$_}{flags}}
} @groups;
# @groups = grep { $size{$_} = round_down($size{$_} / sqr(1024), 10) } @groups; #- don't display the empty or small one (eg: because all packages are below $min_level)
my ($all, $size);
my $available_size = install_any::getAvailableSpace($o) / sqr(1024);
my $size_to_display = sub {
my $lsize = $system_size + $compute_size->(map { @{$compssUsers->{$_}{flags}} } grep { $val{$_} } @groups);
#- if a profile is deselected, deselect everything (easier than deselecting the profile packages)
$size > $lsize and install_any::unselectMostPackages($o);
$size = $lsize;
_("Total size: %d / %d MB", pkgs::correctSize($size / sqr(1024)), $available_size);
};
while (1) {
$o->reallyChooseGroups($size_to_display, $individual, \%val) or return;
last if pkgs::correctSize($size / sqr(1024)) < $available_size;
$o->ask_warn('', _("Selected size is larger than available space"));
}
$o->{compssUsersChoice}{$_} = 0 foreach map { @{$compssUsers->{$_}{flags}} } grep { !$val{$_} } keys %val;
$o->{compssUsersChoice}{$_} = 1 foreach map { @{$compssUsers->{$_}{flags}} } grep { $val{$_} } keys %val;
1;
}
sub reallyChooseGroups {
my ($o, $size_to_display, $individual, $val) = @_;
my $size_text = &$size_to_display;
my ($path, $all);
$o->ask_from('', _("Package Group Selection"), [
{ val => \$size_text, type => 'label' }, {},
(map {;
my $old = $path;
$path = $o->{compssUsers}{$_}{path};
if_($old ne $path, { val => translate($path) }),
{
val => \$val->{$_},
type => 'bool',
disabled => sub { $all },
text => translate($o->{compssUsers}{$_}{label}),
help => translate($o->{compssUsers}{$_}{descr}),
}
} @{$o->{compssUsersSorted}}),
if_($o->{meta_class} eq 'desktop', { text => _("All"), val => \$all, type => 'bool' }),
if_($individual, { text => _("Individual package selection"), val => $individual, advanced => 1, type => 'bool' }),
], changed => sub { $size_text = &$size_to_display }) or return;
if ($all) {
$val->{$_} = 1 foreach keys %$val;
}
1;
}
sub chooseCD {
my ($o, $packages) = @_;
my @mediums = grep { $_ != $install_any::boot_medium } pkgs::allMediums($packages);
my @mediumsDescr = ();
my %mediumsDescr = ();
if (!common::usingRamdisk()) {
#- mono-cd in case of no ramdisk
undef $packages->{mediums}{$_}{selected} foreach @mediums;
log::l("low memory install, using single CD installation (as it is not ejectable)");
return;
}
#- if no other medium available or a poor beginner, we are choosing for him!
#- note first CD is always selected and should not be unselected!
return if @mediums == () || !$::expert;
#- build mediumDescr according to mediums, this avoid asking multiple times
#- all the medium grouped together on only one CD.
foreach (@mediums) {
my $descr = pkgs::mediumDescr($packages, $_);
exists $mediumsDescr{$descr} or push @mediumsDescr, $descr;
$mediumsDescr{$descr} ||= $packages->{mediums}{$_}{selected};
}
$o->set_help('chooseCD');
$o->ask_many_from_list('',
_("If you have all the CDs in the list below, click Ok.
If you have none of those CDs, click Cancel.
If only some CDs are missing, unselect them, then click Ok."),
{
list => \@mediumsDescr,
label => sub { _("Cd-Rom labeled \"%s\"", $_[0]) },
val => sub { \$mediumsDescr{$_[0]} },
}) or do {
$mediumsDescr{$_} = 0 foreach @mediumsDescr; #- force unselection of other CDs.
};
$o->set_help('choosePackages');
#- restore true selection of medium (which may have been grouped together)
foreach (@mediums) {
my $descr = pkgs::mediumDescr($packages, $_);
$packages->{mediums}{$_}{selected} = $mediumsDescr{$descr};
log::l("select status of medium $_ is $packages->{mediums}{$_}{selected}");
}
}
#------------------------------------------------------------------------------
sub installPackages {
my ($o, $packages) = @_;
my ($current, $total) = 0;
my $w = $o->wait_message(_("Installing"), _("Preparing installation"));
my $old = \&pkgs::installCallback;
local *pkgs::installCallback = sub {
my $m = shift;
if ($m =~ /^Starting installation/) {
$total = $_[1];
} elsif ($m =~ /^Starting installing package/) {
my $name = $_[0];
$w->set(_("Installing package %s\n%d%%", $name, $total && 100 * $current / $total));
$current += pkgs::packageSize(pkgs::packageByName($o->{packages}, $name));
} else { unshift @_, $m; goto $old }
};
$o->SUPER::installPackages($packages);
}
sub afterInstallPackages($) {
my ($o) = @_;
my $w = $o->wait_message('', _("Post-install configuration"));
$o->SUPER::afterInstallPackages($o);
}
sub copyKernelFromFloppy {
my ($o) = @_;
$o->ask_okcancel('', _("Please insert the Boot floppy used in drive %s", $o->{blank}), 1) or return;
$o->SUPER::copyKernelFromFloppy();
}
sub updateModulesFromFloppy {
my ($o) = @_;
$o->ask_okcancel('', _("Please insert the Update Modules floppy in drive %s", $o->{updatemodules}), 1) or return;
$o->SUPER::updateModulesFromFloppy();
}
#------------------------------------------------------------------------------
sub configureNetwork {
my ($o, $first_time, $noauto) = @_;
require network::netconnect;
network::netconnect::main($o->{prefix}, $o->{netcnx} ||= {}, $o->{netc}, $o->{mouse}, $o, $o->{intf},
$first_time, $o->{lang} eq "fr_FR" && $o->{keyboard} eq "fr", $noauto);
}
#-configureNetworkIntf moved to network
#-configureNetworkNet moved to network
#------------------------------------------------------------------------------
#-pppConfig moved to any.pm
#------------------------------------------------------------------------------
sub installCrypto {
my ($o) = @_;
my $u = $o->{crypto} ||= {};
$::expert and $o->hasNetwork or return;
is_empty_hash_ref($u) and $o->ask_yesorno('',
_("You have now the possibility to download software aimed for encryption.
WARNING:
Due to different general requirements applicable to these software and imposed
by various jurisdictions, customer and/or end user of theses software should
ensure that the laws of his/their jurisdiction allow him/them to download, stock
and/or use these software.
In addition customer and/or end user shall particularly be aware to not infringe
the laws of his/their jurisdiction. Should customer and/or end user not
respect the provision of these applicable laws, he/they will incure serious
sanctions.
In no event shall Mandrakesoft nor its manufacturers and/or suppliers be liable
for special, indirect or incidental damages whatsoever (including, but not
limited to loss of profits, business interruption, loss of commercial data and
other pecuniary losses, and eventual liabilities and indemnification to be paid
pursuant to a court decision) arising out of use, possession, or the sole
downloading of these software, to which customer and/or end user could
eventually have access after having sign up the present agreement.
For any queries relating to these agreement, please contact
Mandrakesoft, Inc.
2400 N. Lincoln Avenue Suite 243
Altadena California 91001
USA")) || return;
require crypto;
eval {
$u->{mirror} = $o->ask_from_listf('',
_("Choose a mirror from which to get the packages"),
\&crypto::mirror2text,
[ crypto::mirrors() ],
$u->{mirror});
};
return if $@;
#- bring all interface up for installing crypto packages.
install_interactive::upNetwork($o);
my @packages = do {
my $w = $o->wait_message('', _("Contacting the mirror to get the list of available packages"));
crypto::getPackages($o->{prefix}, $o->{packages}, $u->{mirror}); #- make sure $o->{packages} is defined when testing
};
$u->{packages} = $o->ask_many_from_list('', _("Please choose the packages you want to install."), { list => \@packages, values => $u->{packages} }) or return;
$o->pkg_install(@{$u->{packages}});
#- stop interface using ppp only.
install_interactive::downNetwork($o, 'pppOnly');
}
#------------------------------------------------------------------------------
sub configureTimezone {
my ($o, $clicked) = @_;
require timezone;
$o->{timezone}{timezone} = $o->ask_from_treelist('', _("Which is your timezone?"), '/', [ timezone::getTimeZones($::g_auto_install ? '' : $o->{prefix}) ], $o->{timezone}{timezone});
$o->set_help('configureTimezoneGMT');
my $ntp = to_bool($o->{timezone}{ntp});
$o->ask_from('', '', [
{ text => _("Hardware clock set to GMT"), val => \$o->{timezone}{UTC}, type => 'bool' },
{ text => _("Automatic time synchronization (using NTP)"), val => \$ntp, type => 'bool' },
]) or goto &configureTimezone
if $::expert || $clicked;
if ($ntp) {
my @servers = split("\n", $timezone::ntp_servers);
$o->ask_from('', '',
[ { label => _("NTP Server"), val => \$o->{timezone}{ntp}, list => \@servers, not_edit => 0 } ]
) or goto &configureTimezone;
$o->{timezone}{ntp} =~ s/.*\((.+)\)/$1/;
} else {
$o->{timezone}{ntp} = '';
}
install_steps::configureTimezone($o);
}
#------------------------------------------------------------------------------
sub configureServices {
my ($o, $clicked) = @_;
require services;
$o->{services} = services::ask($o, $o->{prefix}) if $::expert || $clicked;
install_steps::configureServices($o);
}
sub summary {
my ($o, $first_time) = @_;
require pkgs;
if ($first_time) {
#- auto-detection
$o->configurePrinter(0) if !$::expert;
install_any::preConfigureTimezone($o);
}
my $mouse_name;
my $format_mouse = sub { $mouse_name = translate($o->{mouse}{type}) . ' ' . translate($o->{mouse}{name}) };
&$format_mouse;
#- format printer description in a better way
my $format_printers = sub {
my ($printer) = @_;
if (is_empty_hash_ref($printer->{configured})) {
pkgs::packageFlagInstalled(pkgs::packageByName($o->{packages}, 'cups')) and return _("Remote CUPS server");
return _("No printer");
}
my $entry = $printer->{configured}{$printer->{QUEUE}} || (values %{$printer->{configured}})[0];
return "$entry->{'make'} $entry->{'model'}";
};
$o->ask_from_({
messages => _("Summary"),
cancel => '',
}, [
{ label => _("Mouse"), val => \$mouse_name, clicked => sub { $o->selectMouse(1); mouse::write($o->{prefix}, $o->{mouse}); &$format_mouse } },
{ label => _("Keyboard"), val => \$o->{keyboard}, clicked => sub { $o->selectKeyboard(1) }, format => sub { translate(keyboard::keyboard2text($_[0])) } },
{ label => _("Timezone"), val => \$o->{timezone}{timezone}, clicked => sub { $o->configureTimezone(1) } },
{ label => _("Printer"), val => \$o->{printer}, clicked => sub { $o->configurePrinter(1) }, format => $format_printers },
(map {
{ label => _("ISDN card"), val => $_->{description}, clicked => sub { $o->configureNetwork } }
} grep { $_->{driver} eq 'hisax' } detect_devices::probeall()),
(map {
{ label => _("Sound card"), val => $_->{description} }
} arch() !~ /ppc/ ? modules::get_that_type('sound') : modules::load_thiskind('sound')),
(map {
{ label => _("TV card"), val => $_->{description} }
} grep { $_->{driver} eq 'bttv' } detect_devices::probeall()),
]);
install_steps::configureTimezone($o); #- do not forget it.
}
#------------------------------------------------------------------------------
sub configurePrinter {
my ($o, $clicked) = @_;
$::corporate && !$clicked and return;
require printer;
require printerdrake;
#- try to determine if a question should be asked to the user or
#- if he is autorized to configure multiple queues.
my $ask_multiple_printer = ($::expert || $clicked) && 2 || scalar(printerdrake::auto_detect($o));
$ask_multiple_printer-- or return;
#- install packages needed for printer::getinfo()
$::testing or $o->do_pkgs->install('foomatic');
#- take default configuration, this include choosing the right system
#- currently used by the system.
my $printer = $o->{printer} ||= {};
eval { add2hash($printer, printer::getinfo($o->{prefix})) };
$printer->{PAPERSIZE} = $o->{lang} eq 'en' ? 'letter' : 'a4';
printerdrake::main($printer, $o, $ask_multiple_printer, sub { install_interactive::upNetwork($o, 'pppAvoided') });
}
#------------------------------------------------------------------------------
sub setRootPassword {
my ($o, $clicked) = @_;
my $sup = $o->{superuser} ||= {};
my $auth = ($o->{authentication}{LDAP} && __("LDAP") ||
$o->{authentication}{NIS} && __("NIS") ||
__("Local files"));
$sup->{password2} ||= $sup->{password} ||= "";
return if $o->{security} < 1 && !$clicked;
$::isInstall and $o->set_help("setRootPassword", if_($::expert, "setRootPasswordAuth"));
$o->ask_from_(
{
title => _("Set root password"),
messages => _("Set root password"),
cancel => ($o->{security} <= 2 && !$::corporate ? _("No password") : ''),
callbacks => {
complete => sub {
$sup->{password} eq $sup->{password2} or $o->ask_warn('', [ _("The passwords do not match"), _("Please try again") ]), return (1,1);
length $sup->{password} < 2 * $o->{security}
and $o->ask_warn('', _("This password is too simple (must be at least %d characters long)", 2 * $o->{security})), return (1,0);
return 0
} } }, [
{ label => _("Password"), val => \$sup->{password}, hidden => 1 },
{ label => _("Password (again)"), val => \$sup->{password2}, hidden => 1 },
if_($::expert,
{ label => _("Authentication"), val => \$auth, list => [ __("Local files"), __("LDAP"), __("NIS") ], format => \&translate },
),
]) or return;
if ($auth eq __("LDAP")) {
$o->{authentication}{LDAP} ||= "localhost"; #- any better solution ?
$o->{netc}{LDAPDOMAIN} ||= join (',', map { "dc=$_" } split /\./, $o->{netc}{DOMAINNAME});
$o->ask_from('',
_("Authentication LDAP"),
[ { label => _("LDAP Base dn"), val => \$o->{netc}{LDAPDOMAIN} },
{ label => _("LDAP Server"), val => \$o->{authentication}{LDAP} },
]);
} else { $o->{authentication}{LDAP} = '' }
if ($auth eq __("NIS")) {
$o->{authentication}{NIS} ||= 'broadcast';
$o->ask_from('',
_("Authentication NIS"),
[ { label => _("NIS Domain"), val => \ ($o->{netc}{NISDOMAIN} ||= $o->{netc}{DOMAINNAME}) },
{ label => _("NIS Server"), val => \$o->{authentication}{NIS}, list => ["broadcast"], not_edit => 0 },
]);
} else { $o->{authentication}{NIS} = '' }
install_steps::setRootPassword($o);
}
#------------------------------------------------------------------------------
#-addUser
#------------------------------------------------------------------------------
sub addUser {
my ($o, $clicked) = @_;
$o->{users} ||= [];
if ($o->{security} < 1) {
push @{$o->{users}}, { password => 'mandrake', realname => 'default', icon => 'automagic' }
if !member('mandrake', map { $_->{name} } @{$o->{users}});
}
if (($o->{security} >= 1 || $clicked)) {
any::ask_users($o->{prefix}, $o, $o->{users}, $o->{security});
}
any::get_autologin($o->{prefix}, $o);
any::autologin($o->{prefix}, $o, $o);
install_steps::addUser($o);
}
#------------------------------------------------------------------------------
sub createBootdisk {
my ($o, $first_time, $noauto) = @_;
return if !$noauto && $first_time && !$::expert;
if (arch() =~ /sparc/) {
#- as probing floppies is a bit more different on sparc, assume always /dev/fd0.
$o->ask_okcancel('',
_("A custom bootdisk provides a way of booting into your Linux system without
depending on the normal bootloader. This is useful if you don't want to install
SILO on your system, or another operating system removes SILO, or SILO doesn't
work with your hardware configuration. A custom bootdisk can also be used with
the Mandrake rescue image, making it much easier to recover from severe system
failures.
If you want to create a bootdisk for your system, insert a floppy in the first
drive and press \"Ok\"."),
$o->{mkbootdisk}) or return $o->{mkbootdisk} = '';
my @l = detect_devices::floppies_dev();
$o->{mkbootdisk} = $l[0] if !$o->{mkbootdisk} || $o->{mkbootdisk} eq "1";
$o->{mkbootdisk} or return;
} else {
my @l = detect_devices::floppies_dev();
my %l = (
'fd0' => _("First floppy drive"),
'fd1' => _("Second floppy drive"),
'Skip' => _("Skip"),
);
if ($first_time || @l == 1) {
$o->ask_yesorno('', formatAlaTeX(
_("A custom bootdisk provides a way of booting into your Linux system without
depending on the normal bootloader. This is useful if you don't want to install
LILO (or grub) on your system, or another operating system removes LILO, or LILO doesn't
work with your hardware configuration. A custom bootdisk can also be used with
the Mandrake rescue image, making it much easier to recover from severe system
failures. Would you like to create a bootdisk for your system?")),
$o->{mkbootdisk}) or return $o->{mkbootdisk} = '';
$o->{mkbootdisk} = $l[0] if !$o->{mkbootdisk} || $o->{mkbootdisk} eq "1";
} else {
@l or die _("Sorry, no floppy drive available");
$o->ask_from_(
{
messages => _("Choose the floppy drive you want to use to make the bootdisk"),
}, [ { val => \$o->{mkbootdisk}, list => \@l, format => sub { $l{$_[0]} || $_[0] } } ]
) or return;
}
$o->ask_warn('', _("Insert a floppy in drive %s", $l{$o->{mkbootdisk}} || $o->{mkbootdisk}));
}
my $w = $o->wait_message('', _("Creating bootdisk"));
install_steps::createBootdisk($o);
}
#------------------------------------------------------------------------------
sub setupBootloaderBefore {
my ($o) = @_;
my $w = $o->wait_message('', _("Preparing bootloader"));
$o->set_help('empty');
$o->SUPER::setupBootloaderBefore($o);
}
#------------------------------------------------------------------------------
sub setupBootloader {
my ($o, $more) = @_;
if (arch() =~ /ppc/) {
my $machtype = detect_devices::get_mac_generation();
if ($machtype !~ /NewWorld/) {
$o->ask_warn('', _("You appear to have an OldWorld or Unknown\n machine, the yaboot bootloader will not work for you.\nThe install will continue, but you'll\n need to use BootX to boot your machine"));
log::l("OldWorld or Unknown Machine - no yaboot setup");
return;
}
} elsif (arch() =~ /^alpha/) {
$o->ask_yesorno('', _("Do you want to use aboot?"), 1) or return;
catch_cdie { $o->SUPER::setupBootloader } sub {
$o->ask_yesorno('',
_("Error installing aboot,
try to force installation even if that destroys the first partition?"));
};
} else {
any::setupBootloader($o, $o->{bootloader}, $o->{all_hds}, $o->{fstab}, $o->{security}, $o->{prefix}, $more) or return;
{
my $w = $o->wait_message('', _("Installing bootloader"));
eval { $o->SUPER::setupBootloader };
}
if ($@) {
$o->ask_warn('',
[ _("Installation of bootloader failed. The following error occured:"),
grep { !/^Warning:/ } cat_("$o->{prefix}/tmp/.error") ]);
unlink "$o->{prefix}/tmp/.error";
die "already displayed";
} elsif (arch() =~ /ppc/) {
my $of_boot = cat_("$o->{prefix}/tmp/of_boot_dev") || die "Can't open $o->{prefix}/tmp/of_boot_dev";
chop($of_boot);
unlink "$o->{prefix}/tmp/.error";
$o->ask_warn('', _("You may need to change your Open Firmware boot-device to\n enable the bootloader. If you don't see the bootloader prompt at\n reboot, hold down Command-Option-O-F at reboot and enter:\n setenv boot-device %s,\\\\:tbxi\n Then type: shut-down\nAt your next boot you should see the bootloader prompt.", $of_boot));
}
}
}
sub miscellaneous {
my ($o, $clicked) = @_;
my %l = (
2 => _("Low"),
3 => _("Medium"),
4 => _("High"),
);
if ($::expert || $clicked) {
$ENV{SECURE_LEVEL} = $o->{security} =
$o->ask_from_listf('', _("Choose security level"), sub { $l{$_[0]} }, [ ikeys %l ], $o->{security})
or return;
}
install_steps::miscellaneous($o);
}
#------------------------------------------------------------------------------
sub configureX {
my ($o, $clicked) = @_;
$o->configureXBefore;
#- strange, xfs must not be started twice...
#- trying to stop and restart it does nothing good too...
my $xfs_started if 0;
run_program::rooted($o->{prefix}, "/etc/rc.d/init.d/xfs", "start") unless $::live || $xfs_started;
$xfs_started = 1;
require Xconfigurator;
{ local $::testing = 0; #- unset testing
local $::auto = !$::expert && !$clicked;
symlink "$o->{prefix}/etc/gtk", "/etc/gtk";
Xconfigurator::main($o->{prefix}, $o->{X}, $o, $o->do_pkgs,
{ allowFB => $o->{allowFB},
allowNVIDIA_rpms => install_any::allowNVIDIA_rpms($o->{packages}),
});
}
$o->configureXAfter;
}
#------------------------------------------------------------------------------
sub generateAutoInstFloppy {
my ($o, $replay) = @_;
my $floppy = detect_devices::floppy();
$o->ask_okcancel('', _("Insert a blank floppy in drive %s", $floppy), 1) or return;
my $dev = devices::make($floppy);
{
my $w = $o->wait_message('', _("Creating auto install floppy"));
install_any::getAndSaveAutoInstallFloppy($o, $replay, $dev) or return;
}
common::sync(); #- if you shall remove the floppy right after the LED switches off
}
#------------------------------------------------------------------------------
sub exitInstall {
my ($o, $alldone) = @_;
return $o->{step} = '' unless $alldone || $o->ask_yesorno('',
_("Some steps are not completed.
Do you really want to quit now?"), 0);
install_steps::exitInstall($o);
$o->exit unless $alldone;
$o->ask_from_no_check(
{
messages =>
_("Congratulations, installation is complete.
Remove the boot media and press return to reboot.
For information on fixes which are available for this release of Mandrake Linux,
consult the Errata available from http://www.mandrakelinux.com/.
Information on configuring your system is available in the post
install chapter of the Official Mandrake Linux User's Guide."),
cancel => '',
},
[
if_($::expert,
{ val => \ (my $t1 = _("Generate auto install floppy")), clicked => sub {
my $t = $o->ask_from_list_('',
_("The auto install can be fully automated if wanted,
in that case it will take over the hard drive!!
(this is meant for installing on another box).
You may prefer to replay the installation.
"), [ __("Replay"), __("Automated") ]);
$t and $o->generateAutoInstFloppy($t eq 'Replay');
}, advanced => 1 },
{ val => \ (my $t2 = _("Save packages selection")), clicked => sub { install_any::g_default_packages($o) }, advanced => 1 },
),
]
) if $alldone && !$::g_auto_install;
}
#-######################################################################################
#- Misc Steps Functions
#-######################################################################################
#-######################################################################################
#- Wonderful perl :(
#-######################################################################################
1;
|