path: root/po/fi.po

# translation of urpmi-fi.po to Finnish
# urpmi-fi - Finnish Translation
#
# Copyright (C) 2002,2003, 2004 Free Software Foundation, Inc.
# Copyright (C) 2002 Mandrakesoft
# Kim Enkovaara <kim.enkovaara@iki.fi>, 2000.
# Matias Griese <mahagr@utu.fi>, 2001, 2002.
# Taisto Kuikka <69319@batman.jypoly.fi>, 2003, 2004.
# Thomas Backlund <tmb@mandrake.org>, 2002, 2003, 2004.
#
#
msgid ""
msgstr ""
"Project-Id-Version: urpmi-fi - MDK 10.1 Release\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2004-09-06 21:56+0200\n"
"PO-Revision-Date: 2004-09-05 18:25+0300\n"
"Last-Translator: Thomas Backlund <tmb@mandrake.org>\n"
"Language-Team: Finnish <cooker-i18n@mandrakelinux.com>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.3\n"

#. This is a list of chars acceptable as a 'yes' answer to a Yes/No question;
#. you can put here the letters for 'yes' for your language, so people
#. can hit those keys in their keyboard to reply.
#. please keep the 'Yy' for compatibility reasons
#.
#: placeholder.h:11
msgid "Yy"
msgstr "KkYy"

#. This is a list of chars acceptable as a 'no' answer to a Yes/No question;
#. you can put here the letters for 'no' for your language, so people
#. can hit those keys in their keyboard to reply.
#. please keep the 'Nn' for compatibility reasons
#.
#: placeholder.h:17
msgid "Nn"
msgstr "EeNn"

#: ../_irpm:23
#, c-format
msgid "installing %s\n"
msgstr "asennetaan %s\n"

#: ../_irpm:33
#, c-format
msgid ""
"Automatic installation of packages...\n"
"You requested installation of package %s\n"
msgstr ""
"Pakettien automaattinen asennus...\n"
"Lähetit pyynnön paketin %s asennuksesta\n"

#: ../_irpm:33 ../urpme:29 ../urpmi:529
#, c-format
msgid "Is this OK?"
msgstr "Sopiiko tämä?"

#: ../_irpm:35 ../urpm/msg.pm:41
#, c-format
msgid "Ok"
msgstr "Ok"

#: ../_irpm:36 ../urpm/msg.pm:42
#, c-format
msgid "Cancel"
msgstr "Peruuta"

#: ../_irpm:44 ../urpmi:457 ../urpmi:537
#, c-format
msgid " (Y/n) "
msgstr " (K/e) "

#: ../_irpm:63
#, c-format
msgid "%s: command not found\n"
msgstr "%s: komentoa ei löytynyt\n"

#: ../rpm-find-leaves:12
#, c-format
msgid ""
"usage: %s [options]\n"
"where [options] are from\n"
msgstr ""
"käyttö: %s [valitsimet]\n"
"jossa [valitsimet] ovat:\n"

#: ../rpm-find-leaves:14
#, c-format
msgid "   -h|--help      - print this help message.\n"
msgstr "  -h|--help        - tulosta tämä viesti\n"

#: ../rpm-find-leaves:15
#, c-format
msgid "   --root <path>  - use the given root instead of /\n"
msgstr "  --root <polku>   - käytä annettua polku / sijasta\n"

#: ../rpm-find-leaves:16
#, c-format
msgid "   -g [group]     - restrict results to given group.\n"
msgstr "  --[group]        - rajoita tulokset annettuun ryhmään\n"

#: ../rpm-find-leaves:17
#, c-format
msgid "                    defaults is %s.\n"
msgstr "                   - oletus on %s\n"

#: ../urpm.pm:67
#, c-format
msgid "unknown protocol defined for %s"
msgstr "tuntematon protokolla määrätty kohteelle %s"

#: ../urpm.pm:100
#, c-format
msgid "no webfetch found, supported webfetch are: %s\n"
msgstr "yhtään webfetch-ohjelmaa ei löytynyt, tuetut ovat: %s\n"

#: ../urpm.pm:116
#, c-format
msgid "unable to handle protocol: %s"
msgstr "ei voida käsitellä protokollaa: %s"

#: ../urpm.pm:190
#, c-format
msgid "medium \"%s\" trying to use an already used hdlist, medium ignored"
msgstr ""
"media \"%s\" yrittää käyttää jo käytettyä hdlist-tiedostoa, media ohitettu"

#: ../urpm.pm:191
#, c-format
msgid "medium \"%s\" trying to use an already used list, medium ignored"
msgstr ""
"media \"%s\" yrittää käyttää jo käytettyä list-tiedostoa, media ohitettu"

#: ../urpm.pm:205
#, c-format
msgid "unable to access hdlist file of \"%s\", medium ignored"
msgstr "median \"%s\" hdlist-tiedostoa ei voida käyttää, media ohitettu"

#: ../urpm.pm:208 ../urpm.pm:2347
#, c-format
msgid "unable to access list file of \"%s\", medium ignored"
msgstr "median \"%s\" list-tiedostoa ei voida käyttää, media ohitettu"

#: ../urpm.pm:236
#, c-format
msgid "trying to bypass existing medium \"%s\", avoiding"
msgstr "yritetään ohittaa olemassa olevaa mediaa \"%s\", vältetään"

#: ../urpm.pm:244
#, c-format
msgid ""
"virtual medium \"%s\" should not have defined hdlist or list file, medium "
"ignored"
msgstr ""
"virtuaalisella medialla \"%s\" ei pitäisi olla määriteltynä hdlist- tai list-"
"tiedostoa, media ohitettu"

#: ../urpm.pm:249
#, c-format
msgid "virtual medium \"%s\" should have a clear url, medium ignored"
msgstr ""
"virtuaalisella medialla \"%s\" pitäisi olla kunnollinen url, media ohitettu"

#: ../urpm.pm:258
#, c-format
msgid "unable to find hdlist file for \"%s\", medium ignored"
msgstr "kohteelle \"%s\" ei löytynyt hdlist-tiedostoa, media ohitettu"

#: ../urpm.pm:265
#, c-format
msgid "unable to find list file for \"%s\", medium ignored"
msgstr "kohteelle \"%s\" ei löytynyt list-tiedostoa, media ohitettu"

#: ../urpm.pm:287
#, c-format
msgid "incoherent list file for \"%s\", medium ignored"
msgstr "hajanainen list-tiedosto kohteelle \"%s\", media ohitettu"

#: ../urpm.pm:295
#, c-format
msgid "unable to inspect list file for \"%s\", medium ignored"
msgstr "kohteen \"%s\" list-tiedostoa ei voitu tarkistaa, media ohitettu"

#: ../urpm.pm:328
#, c-format
msgid "too many mount points for removable medium \"%s\""
msgstr "liian monta liitospistettä siirrettävälle medialle \"%s\""

#: ../urpm.pm:329
#, c-format
msgid "taking removable device as \"%s\""
msgstr "käytetään siirrettävää laitetta kohteena 
sub is_one_big_fat_or_NT {
    my ($hds) = @_;
    @$hds == 1 or return;

    my @l = get_fstab(@$hds);
    @l == 1 && isFat_or_NTFS($l[0]) && free_space(@$hds) < 10 << 11;
}

sub file2part {
    my ($fstab, $file, $keep_simple_symlinks) = @_;    
    my $part;

    $file = $keep_simple_symlinks ? common::expand_symlinks_but_simple("$::prefix$file") : expand_symlinks("$::prefix$file");
    unless ($file =~ s/^$::prefix//) {
	my $part = find { loopback::carryRootLoopback($_) } @$fstab or die;
	log::l("found $part->{mntpoint}");
	$file =~ s|/initrd/loopfs|$part->{mntpoint}|;
    }
    foreach (@$fstab) {
	my $m = $_->{mntpoint};
	$part = $_ if 
	  $file =~ /^\Q$m/ && 
	    (!$part || length $part->{mntpoint} < length $m);
    }
    $part or die "file2part: not found $file";
    $file =~ s|$part->{mntpoint}/?|/|;
    ($part, $file);
}


sub computeSize {
    my ($part, $best, $all_hds, $suggestions) = @_;
    my $max = $part->{maxsize} || $part->{size};
    return min($max, $best->{size}) unless $best->{ratio};

    my $free_space = all_free_space($all_hds);
    my @l = my @L = grep { 
	if (!has_mntpoint($_->{mntpoint}, $all_hds) && $free_space >= $_->{size}) {
	    $free_space -= $_->{size};
	    1;
	} else { 0 } } @$suggestions;

    my $tot_ratios = 0;
    while (1) {
	my $old_free_space = $free_space;
	my $old_tot_ratios = $tot_ratios;

	$tot_ratios = sum(map { $_->{ratio} } @l);
	last if $tot_ratios == $old_tot_ratios;

	@l = grep { 
	    if ($_->{ratio} && $_->{maxsize} && $tot_ratios &&
		$_->{size} + $_->{ratio} / $tot_ratios * $old_free_space >= $_->{maxsize}) {
		return min($max, $best->{maxsize}) if $best->{mntpoint} eq $_->{mntpoint};
		$free_space -= $_msgstr "suoritetaan toinen kierros riippuvuuksien laskemiseksi\n"

#: ../urpm.pm:552
#, c-format
msgid "skipping package %s"
msgstr "ohitetaan paketti %s"

#: ../urpm.pm:565
#, c-format
msgid "would install instead of upgrade package %s"
msgstr "paketti %s asennettaisiin päivittämisen sijaan"

#: ../urpm.pm:576 ../urpm.pm:2161 ../urpm.pm:2224 ../urpm.pm:2789
#: ../urpm.pm:2906
#, c-format
msgid "
    (any { $_->{size} < $max - $size } @L) ? $size : $max;
}

sub suggest_part {
    my ($part, $all_hds, $suggestions) = @_;
    $suggestions ||= $suggestions{server} || $suggestions{simple};

    my $has_swap = any { isSwap($_) } get_all_fstab($all_hds);

    my ($best) =
      grep { !$_->{maxsize} || $part->{size} <= $_->{maxsize} }
      grep { $_->{size} <= ($part->{maxsize} || $part->{size}) }
      grep { !has_mntpoint($_->{mntpoint}, $all_hds) || isSwap($_) && !$has_swap }
      grep { !$_->{hd} || $_->{hd} eq $part->{rootDevice} }
      grep { !$part->{type} || $part->{type} == $_->{type} || isTrueFS($part) && isTrueFS($_) }
	@$suggestions or return;

    defined $best or return; #- sorry no suggestion :(

    $part->{mntpoint} = $best->{mntpoint};
    $part->{type} = $best->{type} if !(isTrueFS($best) && isTrueFS($part));
    $part->{size} = computeSize($part, $best, $all_hds, $suggestions);
    $part->{options} = $best->{options} if $best->{options};
    1;
}

sub suggestions_mntpoint {
    my ($all_hds) = @_;
    sort grep { !/swap/ && !has_mntpoint($_, $all_hds) }
      (@suggestions_mntpoints, map { $_->{mntpoint} } @{$suggestions{server} || $suggestions{simple}});
}

sub mntpoint2part {
    my ($mntpoint, $fstab) = @_;
    find { $mntpoint eq $_->{mntpoint} } @$fstab;
}
sub has_mntpoint {
    my ($mntpoint, $all_hds) = @_;
    mntpoint2part($mntpoint, [ get_really_all_fstab($all_hds) ]);
}
sub get_root_ {
    my ($fstab, $boot) = @_;
    $boot && mntpoint2part("/boot", $fstab) || mntpoint2part("/", $fstab);
}
sub get_root { &get_root_ || {} }

#- do this before modifying $part->{type}
sub check_type {
    my ($type, $_hd, $part) = @_;
    isThisFs("jfs", { type => $type }) && $part->{size} < 16 << 11 and die \N("You can't use JFS for partitions smaller than 16MB");
    isThisFs("reiserfs", { type => $type }) && $part->{size} < 32 << 11 and die \N("You can't use ReiserFS for partitions smaller than 32MB");
}

sub package_needed_for_partition_type {
    my ($part) = @_;
    my %l = (
	reiserfs => 'reiserfsprogs',
	xfs => 'xfsprogs',
        jfs => 'jfsprogs',
    );
    $l{type2fs($part)};
}

#- do this before modifying $part->{mntpoint}
#- $part->{mntpoint} should not be used here, use $mntpoint instead
sub check_mntpoint {
    my ($mntpoint, $hd, $part, $all_hds) = @_;

    $mntpoint eq '' || isSwap($part) || isNonMountable($part) and return;
    $mntpoint =~ m|^/| or die \N("Mount points must begin with a leading /");
    $mntpoint =~ m|[\x7f-\xff]| and cdie \N("Mount points should contain only alphanumerical characters");
    $mntpoint ne $part->{mntpoint} && has_mntpoint($mntpoint, $all_hds) and die \N("There is already a partition with mount point %s\n", $mntpoint);

    cdie \N("You've selected a software RAID partition as root (/).
No bootloader is able to handle this without a /boot partition.
Please be sure to add a /boot partition") if $mntpoint eq "/" && isRAID($part) && !has_mntpoint("/boot", $all_hds);
    die \N("You can't use a LVM Logical Volume for mount point %s", $mntpoint)
      if $mntpoint eq '/boot' && isLVM($hd);
    die \N("This directory should remain within the root filesystem")
      if member($mntpoint, qw(/bin /dev /etc /lib /sbin /root /mnt));
    die \N("You need a true filesystem (ext2/ext3, reiserfs, xfs, or jfs) for this mount point\n")
      if !isTrueFS($part) && member($mntpoint, qw(/ /home /tmp /usr /var));
    die \N("You can't use an encrypted file system for mount point %s", $mntpoint)
      if $part->{options} =~ /encrypted/ && member($mntpoint, qw(/ /usr /var /boot));

    local $part->{mntpoint} = $mntpoint;
    loopback::check_circular_mounts($hd, $part, $all_hds);
}

sub add {
    my ($hd, $part, $all_hds, $options) = @_;

    isSwap($part) ?
      ($part->{mntpoint} = 'swap') :
      $options->{force} || check_mntpoint($part->{mntpoint}, $hd, $part, $all_hds);

    delete $part->{maxsize};

    if (isLVM($hd)) {
	lvm::lv_create($hd, $part);
    } else {
	partition_table::add($hd, $part, $options->{primaryOrExtended});
    }
}

sub allocatePartitions {
    my ($all_hds, $to_add) = @_;

    foreach my $part_ (get_all_holes($all_hds)) {
	my ($start, $size, $dev) = @$part_{"start", "size", "rootDevice"};
	my $part;
	while (suggest_part($part = { start => $start, size => 0, maxsize => $size, rootDevice => $dev }, 
			    $all_hds, $to_add)) {
	    my $hd = fsedit::part2hd($part, $all_hds);
	    add($hd, $part, $all_hds);
	    $size -= $part->{size} + $part->{start} - $start;
	    $start = $part->{start} + $part->{size};
	}
    }
}

sub auto_allocate {
    my ($all_hds, $suggestions) = @_;
    my $before = listlength(fsedit::get_all_fstab($all_hds));

    my $suggestions_ = $suggestions || $suggestions{simple};
    allocatePartitions($all_hds, $suggestions_);

    if ($suggestions) {
	auto_allocate_raids($all_hds, $suggestions);
	if (auto_allocate_vgs($all_hds, $suggestions)) {
	    #- allocatePartitions needs to be called twice, once for allocating PVs, once for allocating LVs
	    my @vgs = map { $_->{VG_name} } @{$all_hds->{lvms}};
	    my @suggested_lvs = grep { member($_->{hd}, @vgs) } @$suggestions;
	    allocatePartitions($all_hds, \@suggested_lvs);
	}
    }

    partition_table::assign_device_numbers($_) foreach @{$all_hds->{hds}};

    if ($before == listlength(fsedit::get_all_fstab($all_hds))) {
	# find out why auto_allocate failed
	if (any { !has_mntpoint($_->{mntpoint}, $all_hds) } @$suggestions_) {
	    die \N("Not enough free space for auto-allocating");
	} else {
	    die \N("Nothing to do");
	}
    }
}

sub auto_allocate_raids {
    my ($all_hds, $suggestions) = @_;

    my @raids = grep { isRawRAID($_) } get_all_fstab($all_hds) or return;

    require raid;
    my @mds = grep { $_->{hd} =~ /md/ } @$suggestions;
    foreach my $md (@mds) {
	my @raids_ = grep { !$md->{parts} || $md->{parts} =~ /\Q$_->{mntpoint}/ } @raids;
	@raids = difference2(\@raids, \@raids_);
	my $nb = raid::new($all_hds->{raids}, @raids_);
	my $part = $all_hds->{raids}[$nb];

	my %h = %$md;
	delete @h{'hd', 'parts'};
	put_in_hash($part, \%h); # mntpoint, level, chunk-size, type
	raid::updateSize($part);
    }
}

sub auto_allocate_vgs {
    my ($all_hds, $suggestions) = @_;

    my @pvs = grep { isRawLVM($_) } get_all_fstab($all_hds) or return;

    my @vgs = grep { $_->{VG_name} } @$suggestions or return;

    partition_table::write(@{$all_hds->{hds}});

    require lvm;

    foreach my $vg (@vgs) {
	my $lvm = new lvm($vg->{VG_name});
	push @{$all_hds->{lvms}}, $lvm;
	
	my @pvs_ = grep { !$vg->{parts} || $vg->{parts} =~ /\Q$_->{mntpoint}/ } @pvs;
	@pvs = difference2(\@pvs, \@pvs_);

	foreach my $part (@pvs_) {
	    raid::make($all_hds->{raids}, $part) if isRAID($part);
	    $part->{lvm} = $lvm->{VG_name};
	    delete $part->{mntpoint};
	    lvm::vg_add($part);
	    push @{$lvm->{disks}}, $part;
	}
	lvm::update_size($lvm);
    }
    1;
}

sub undo_prepare {
    my ($all_hds) = @_;
    require Data::Dumper;
    $Data::Dumper::Purity = 1;
    foreach (@{$all_hds->{hds}}) {
	my @h = @{$_}{@partition_table::fields2save};
	push @{$_->{undo}}, Data::Dumper->Dump([\@h], ['$h']);
    }
}
sub undo {
    my ($all_hds) = @_;
    foreach (@{$all_hds->{hds}}) {
	my $h; eval pop @{$_->{undo}} || next;
	@{$_}{@partition_table::fields2save} = @$h;

	$_->{isDirty} = $_->{needKernelReread} = 1 if $_->{hasBeenDirty};
    }
    
}

sub move {
    my ($hd, $part, $hd2, $sector2) = @_;

    die 'TODO'; # doesn't work for the moment
    my $part1 = { %$part };
    my $part2 = { %$part };
    $part2->{start} = $sector2;
    $part2->{size} += $hd2->cylinder_size() - 1;
    partition_table::remove($hd, $part);
    {
	local ($part2->{notFormatted}, $part2->{isFormatted}); #- do not allow partition::add to change this
	partition_table::add($hd2, $part2);
    }

    return if $part2->{notFormatted} && !$part2->{isFormatted} || $::testing;

    local (*F, *G);
    sysopen F, $hd->{file}, 0 or die '';
    sysopen G, $hd2->{file}, 2 or die \N("Error opening %s for writing: %s", $hd2->{file}, $!);

    my $base = $part1->{start};
    my $base2 = $part2->{start};
    my $step = 10;
    if ($hd eq $hd2) {
	$base == $base2 and return;
	$step = min($step, abs($base2 - $base));

	if ($base < $base2) {
	    $base  += $part1->{size} - $step;
	    $base2 += $part1->{size} - $step;
	    $step = -$step;
	}
    }

    my $f = sub {
	$base  < 0 and $base2 += -$base,  $base  = 0;
	$base2 < 0 and $base  += -$base2, $base2 = 0;
	c::lseek_sector(fileno(F), $base,  0) or die "seeking to sector $base failed on drive $hd->{device}";
	c::lseek_sector(fileno(G), $base2, 0) or die "seeking to sector $base2 failed on drive $hd2->{device}";

	my $buf;
	sysread F, $buf, $SECTORSIZE * abs($_[0]) or die '';
	syswrite G, $buf;
    };

    for (my $i = 0; $i < $part1->{size} / abs($step); $i++, $base += $step, $base2 += $step) {
	print "$base $base2\n";
	&$f($step);
    }
    if (my $v = ($part1->{size} % abs($step)) * sign($step)) {
	$base += $v;
	$base2 += $v;
	&$f($v);
    }
}

sub change_type {
    my ($type, $hd, $part) = @_;
    $type != $part->{type} or return;
    check_type($type, $hd, $part);
    $hd->{isDirty} = 1;
    $part->{mntpoint} = '' if isSwap($part) && $part->{mntpoint} eq "swap";
    $part->{mntpoint} = '' if isRawLVM({ type => $type }) || isRawRAID({ type => $type });
    $part->{type} = $type;
    $part->{notFormatted} = 1;
    $part->{isFormatted} = 0;    
}

sub rescuept($) {
    my ($hd) = @_;
    my ($ext, @hd);

    my $dev = devices::make($hd->{device});
    open(my $F, "rescuept $dev|");
    local $_;
    while (<$F>) {
	my ($st, $si, $id) = /start=\s*(\d+),\s*size=\s*(\d+),\s*Id=\s*(\d+)/ or next;
	my $part = { start => $st, size => $si, type => hex($id) };
	if (isExtended($part)) {
	    $ext = $part;
	} else {
	    push @hd, $part;
	}
    }
    close $F or die "rescuept failed";

    partition_table::raw::zero_MBR($hd);
    foreach (@hd) {
	my $b = partition_table::verifyInside($_, $ext);
	if ($b) {
	    $_->{start}--;
	    $_->{size}++;
	}
	local $_->{notFormatted};

	partition_table::add($hd, $_, ($b ? 'Extended' : 'Primary'), 1);
    }
}

sub compare_with_proc_partitions {
    my ($hd) = @_;

    my @l1 = partition_table::get_normal_parts($hd);
    my @l2 = grep { $_->{rootDevice} eq $hd->{device} } read_proc_partitions([$hd]);

    #- /proc/partitions includes partition with type "empty" and a non-null size
    #- so add them for comparison
    my ($len1, $len2) = (int(@l1) + $hd->{primary}{nb_special_empty}, int(@l2));

    if ($len1 != $len2 && arch() ne 'ppc') {
	die sprintf(
		    "/proc/partitions doesn't agree with drakx %d != %d:\n%s\n", $len1, $len2,
		    "/proc/partitions: " . join(", ", map { "$_->{device} ($_->{rootDevice})" } @l2));
    }
    $len2;
}

sub use_proc_partitions {
    my ($hd) = @_;

    log::l("using /proc/partitions since diskdrake failed :(");
    partition_table::raw::zero_MBR($hd);
    $hd->{readonly} = 1;
    $hd->{getting_rid_of_readonly_allowed} = 1;
    $hd->{primary} = { normal => [ grep { $_->{rootDevice} eq $hd->{device} } read_proc_partitions([$hd]) ] };
}

1;