dpkg/scripts/update-alternatives.pl

#!/usr/bin/perl --

BEGIN { # Work-around for bug #479711 in perl
    $ENV{PERL_DL_NONLAZY} = 1;
}

use strict;
use warnings;

use POSIX qw(:errno_h);
use Dpkg;
use Dpkg::Gettext;

textdomain("dpkg");

# Global variables:

my $altdir = '/etc/alternatives';
my $admdir = $admindir . '/alternatives';

my $action = '';      # Action to perform (display / query / install / remove / auto / config)
my $skip_auto = '';   # Skip alternatives properly configured in auto mode (for --config)
my $alternative;      # Alternative worked on
my $inst_alt;         # Alternative to install
my $fileset;          # Set of files to install in the alternative
my $path;             # Path of alternative we are offering
my $verbosemode = 0;

$| = 1;

#
# Main program
#

my @COPY_ARGV = @ARGV;
while (@ARGV) {
    $_ = shift(@ARGV);
    last if m/^--$/;
    if (!m/^--/) {
        quit(_g("unknown argument \`%s'"), $_);
    } elsif (m/^--help$/) {
        usage();
        exit(0);
    } elsif (m/^--version$/) {
        version();
        exit(0);
    } elsif (m/^--verbose$/) {
        $verbosemode= +1;
    } elsif (m/^--quiet$/) {
        $verbosemode= -1;
    } elsif (m/^--install$/) {
	set_action("install");
        @ARGV >= 4 || badusage(_g("--install needs <link> <name> <path> <priority>"));
        my $link = shift @ARGV;
        my $name = shift @ARGV;
        my $path = shift @ARGV;
        my $priority = shift @ARGV;
        $priority =~ m/^[-+]?\d+/ || badusage(_g("priority must be an integer"));
        $alternative = Alternative->new($name);
        $inst_alt = Alternative->new($name);
        $inst_alt->set_status("auto");
        $inst_alt->set_link($link);
        $fileset = FileSet->new($path, $priority);
    } elsif (m/^--(remove|set)$/) {
	set_action($1);
        @ARGV >= 2 || badusage(_g("--%s needs <name> <path>"), $1);
        $alternative = Alternative->new(shift(@ARGV));
        $path = shift @ARGV;
    } elsif (m/^--(display|query|auto|config|list|remove-all)$/) {
	set_action($1);
        @ARGV || badusage(_g("--%s needs <name>"), $1);
        $alternative = Alternative->new(shift(@ARGV));
    } elsif (m/^--all$/) {
	set_action('all');
    } elsif (m/^--slave$/) {
        badusage(_g("--slave only allowed with --install"))
            unless $action eq "install";
        @ARGV >= 3 || badusage(_g("--slave needs <link> <name> <path>"));
        my $slink = shift @ARGV;
        my $sname = shift @ARGV;
        my $spath = shift @ARGV;
        badusage(_g("name %s is both primary and slave"), $inst_alt->name())
            if $sname eq $inst_alt->name();
        if ($inst_alt->has_slave($sname)) {
            badusage(_g("slave name %s duplicated"), $sname);
        }
        foreach my $slave ($inst_alt->slaves()) {
            my $link = $inst_alt->slave_link($slave) || "";
            badusage(_g("slave link %s duplicated"), $slink) if $link eq $slink;
            badusage(_g("link %s is both primary and slave"), $slink)
                if $link eq $inst_alt->link();
        }
        $inst_alt->add_slave($sname, $slink);
        $fileset->add_slave($sname, $spath);
    } elsif (m/^--altdir$/) {
        @ARGV || badusage(_g("--%s needs a <directory> argument"), "altdir");
        $altdir = shift @ARGV;
    } elsif (m/^--admindir$/) {
        @ARGV || badusage(_g("--%s needs a <directory> argument"), "admindir");
        $admdir = shift @ARGV;
    } elsif (m/^--skip-auto$/) {
	$skip_auto = 1;
    } else {
        badusage(_g("unknown option \`%s'"), $_);
    }
}

badusage(_g("need --display, --query, --list, --config, --set, --install," .
            "--remove, --all, --remove-all or --auto")) unless $action;

# Load infos about all alternatives to be able to check for mistakes
my %ALL;
foreach my $alt_name (get_all_alternatives()) {
    my $alt = Alternative->new($alt_name);
    next unless $alt->load("$admdir/$alt_name", 1);
    $ALL{objects}{$alt_name} = $alt;
    $ALL{links}{$alt->link()} = $alt_name;
    $ALL{parent}{$alt_name} = $alt_name;
    foreach my $slave ($alt->slaves()) {
        $ALL{links}{$alt->slave_link($slave)} = $slave;
        $ALL{parent}{$slave} = $alt_name;
    }
}
# Check that caller don't mix links between alternatives and don't mix
# alternatives between slave/master, and that the various parameters
# are fine
if ($action eq "install") {
    my ($name, $link, $file) = ($inst_alt->name(), $inst_alt->link(), $fileset->master());
    if (exists $ALL{parent}{$name} and $ALL{parent}{$name} ne $name) {
        badusage(_g("Alternative %s can't be master: %s"), $name,
                 sprintf(_g("it is a slave of %s"), $ALL{parent}{$name}));
    }
    if (exists $ALL{links}{$link} and $ALL{links}{$link} ne $name) {
        badusage(_g("Alternative link %s is already managed by %s."),
                 $link, $ALL{parent}{$ALL{links}{$link}});
    }
    badusage(_g("Alternative link (%s) is not absolute as it should be."),
             $link) unless $link =~ m|^/|;
    badusage(_g("Alternative path (%s) is not absolute as it should be."),
             $file) unless $file =~ m|^/|;
    badusage(_g("Alternative path (%s) doesn't exist."), $file)
        unless -e $file;
    badusage(_g("Alternative name (%s) is invalid."), $name) if $name =~ m|[/\s]|;
    foreach my $slave ($inst_alt->slaves()) {
        $link = $inst_alt->slave_link($slave);
        $file = $fileset->slave($slave);
        if (exists $ALL{parent}{$slave} and $ALL{parent}{$slave} ne $name) {
            badusage(_g("Alternative %s can't be slave of %s: %s"),
                     $slave, $name, ($ALL{parent}{$slave} eq $slave) ?
                        _g("it is a master alternative.") :
                        sprintf(_g("it is a slave of %s"), $ALL{parent}{$slave})
                     );
        }
        if (exists $ALL{links}{$link} and $ALL{links}{$link} ne $slave) {
            badusage(_g("Alternative link %s is already managed by %s."),
                     $link, $ALL{parent}{$ALL{links}{$link}});
        }
        badusage(_g("Alternative link (%s) is not absolute as it should be."),
                 $link) unless $link =~ m|^/|;
        badusage(_g("Alternative path (%s) is not absolute as it should be."),
                 $file) unless $file =~ m|^/|;
        badusage(_g("Alternative name (%s) is invalid."), $slave)
            if $slave =~ m|[/\s]|;
    }
}

# Handle actions
if ($action eq 'all') {
    config_all();
    exit 0;
}

# Load the alternative info, stop on failure except for --install
if (not $alternative->load("$admdir/" . $alternative->name())
    and $action ne "install")
{
    pr(_g("No alternatives for %s."), $alternative->name());
    # FIXME: Be consistent for now with the case when we try to remove a
    # non-existing path from an existing link group file.
    exit 0 if $action eq "remove";
    exit 1;
}

if ($action eq 'display') {
    $alternative->display_user();
    exit 0;
} elsif ($action eq 'query') {
    $alternative->display_query();
    exit 0;
} elsif ($action eq 'list') {
    $alternative->display_list();
    exit 0;
}

# Actions below might modify the system
log_msg("run with @COPY_ARGV");

my $current_choice = '';
if ($alternative->has_current_link()) {
    $current_choice = $alternative->current();
    # Detect manually modified alternative, switch to manual
    if (not $alternative->has_choice($current_choice)) {
        if ($alternative->status() ne "manual") {
            pr(_g("%s has been changed (manually or by a script).\n" .
                  "Switching to manual updates only."),
                  "$altdir/" . $alternative->name())
                if $verbosemode >= 0;
            $alternative->set_status('manual');
        }
    }
} else {
    # Lack of alternative link => automatic mode
    pr(sprintf(_g("Setting up automatic selection of %s."), $alternative->name()))
      if $verbosemode > 0;
    $alternative->set_status('auto');
}

my $new_choice;
if ($action eq 'set') {
    $alternative->set_status('manual');
    $new_choice = $path;
} elsif ($action eq 'auto') {
    $alternative->set_status('auto');
    $new_choice = $alternative->best();
} elsif ($action eq 'config') {
    if (not scalar($alternative->choices())) {
        printf _g("There is no program which provides %s.\n".
                  "Nothing to configure.\n"), $alternative->name();
    } elsif ($skip_auto && $alternative->status() eq 'auto') {
        $alternative->display_user();
    } elsif (scalar($alternative->choices()) == 1 and
             $alternative->status() eq 'auto' and
             $alternative->has_current_link()) {
        printf _g("There is only 1 program which provides %s properly in auto mode\n".
                  "(%s). Nothing to configure.\n"), $alternative->name(),
                $alternative->current();
    } else {
        $new_choice = $alternative->select_choice();
    }
} elsif ($action eq 'remove') {
    if ($alternative->has_choice($path)) {
        $alternative->remove_choice($path);
    } else {
        pr(_g("Alternative %s for %s not registered, not removing."),
           $path, $alternative->name()) if $verbosemode > 0;
    }
    if ($current_choice eq $path) {
        # Current choice is removed
        if ($alternative->status() eq "manual") {
            # And it was manual, switch to auto
            pr(_g("Removing manually selected alternative - switching to auto mode"))
                if $verbosemode >= 0;
            $alternative->set_status('auto');
        }
        $new_choice = $alternative->best();
    }
} elsif ($action eq 'remove-all') {
    foreach my $choice ($alternative->choices()) {
        $alternative->remove_choice($choice);
    }
} elsif ($action eq 'install') {
    if (defined($alternative->link())) {
        # Alternative already exists, check if anything got updated
        my ($old, $new) = ($alternative->link(), $inst_alt->link());
        $alternative->set_link($new);
        if ($old ne $new and -l $old) {
            pr(_g("Renaming %s link from %s to %s."), $inst_alt->name(),
               $old, $new) if $verbosemode >= 0;
            rename_mv($old, $new, 1) ||
                quit(_g("unable to rename %s to %s: see error above"), $old, $new);
        }
        # Check if new slaves have been added, or existing ones renamed
        foreach my $slave ($inst_alt->slaves()) {
            $new = $inst_alt->slave_link($slave);
            if (not $alternative->has_slave($slave)) {
                $alternative->add_slave($slave, $new);
                next;
            }
            $old = $alternative->slave_link($slave);
            $alternative->add_slave($slave, $new);
            if ($old ne $new and -l $old) {
                pr(_g("Renaming %s slave link from %s to %s."), $slave,
                   $old, $new) if $verbosemode >= 0;
                rename_mv($old, $new, 1) ||
                    quit(_g("unable to rename %s to %s: see error above"), $old, $new);
            }
        }
    } else {
        # Alternative doesn't exist, create from parameters
        $alternative = $inst_alt;
    }
    $alternative->add_choice($fileset);
    if ($alternative->status() eq "auto") {
        # Update automatic choice if needed
        $new_choice = $alternative->best();
    } else {
        pr(_g("Automatic updates of %s are disabled, leaving it alone."),
           "$altdir/" . $alternative->name()) if $verbosemode > 0;
        pr(_g("To return to automatic updates use \`update-alternatives --auto %s'."),
           $alternative->name()) if $verbosemode > 0;
    }
}

# No choice left, remove everything
if (not scalar($alternative->choices())) {
    log_msg("link group " . $alternative->name() . " fully removed");
    $alternative->remove();
    exit 0;
}

# New choice wanted
if (defined($new_choice) and ($current_choice ne $new_choice)) {
    log_msg("link group " . $alternative->name() .
            " updated to point to " . $new_choice);
    printf _g("Using '%s' to provide '%s' in %s.") . "\n", $new_choice,
           $alternative->name(),
           ($alternative->status() eq "auto" ? _g("auto mode") : _g("manual mode"))
        if $verbosemode >= 0;
    $alternative->prepare_install($new_choice);
} elsif ($alternative->is_broken()) {
    # TODO: warn & log
    log_msg("auto-repair link group " . $alternative->name());
    $alternative->prepare_install($current_choice) if $current_choice;
}

# Save administrative file if needed
if ($alternative->is_modified()) {
    $alternative->save("$admdir/" . $alternative->name() . ".dpkg-tmp");
    checked_mv("$admdir/" . $alternative->name() . ".dpkg-tmp",
               "$admdir/" . $alternative->name());
}

# Replace all symlinks in one pass
$alternative->commit();

exit 0;

### FUNCTIONS ####
sub version {
    printf _g("Debian %s version %s.\n"), $progname, $version;

    printf _g("
Copyright © 1995 Ian Jackson.
Copyright © 2000-2002 Wichert Akkerman.
Copyright © 2009 Raphaël Hertzog.");

    printf _g("
This is free software; see the GNU General Public Licence version 2 or
later for copying conditions. There is NO warranty.
");
}

sub usage {
    printf _g(
"Usage: %s [<option> ...] <command>

Commands:
  --install <link> <name> <path> <priority>
    [--slave <link> <name> <path>] ...
                           add a group of alternatives to the system.
  --remove <name> <path>   remove <path> from the <name> group alternative.
  --remove-all <name>      remove <name> group from the alternatives system.
  --auto <name>            switch the master link <name> to automatic mode.
  --display <name>         display information about the <name> group.
  --query <name>           machine parseable version of --display <name>.
  --list <name>            display all targets of the <name> group.
  --config <name>          show alternatives for the <name> group and ask the
                           user to select which one to use.
  --set <name> <path>      set <path> as alternative for <name>.
  --all                    call --config on all alternatives.

<link> is the symlink pointing to %s/<name>.
  (e.g. /usr/bin/pager)
<name> is the master name for this link group.
  (e.g. pager)
<path> is the location of one of the alternative target files.
  (e.g. /usr/bin/less)
<priority> is an integer; options with higher numbers have higher priority in
  automatic mode.

Options:
  --altdir <directory>     change the alternatives directory.
  --admindir <directory>   change the administrative directory.
  --skip-auto              skip prompt for alternatives correctly configured
                           in automatic mode (relevant for --config only)
  --verbose                verbose operation, more output.
  --quiet                  quiet operation, minimal output.
  --help                   show this help message.
  --version                show the version.
"), $progname, $altdir;
}

sub quit {
    my ($format, @params) = @_;
    $! = 2;
    die sprintf("%s: %s\n", $progname, sprintf($format, @params));
}

sub badusage {
    my ($format, @params) = @_;
    printf STDERR "%s: %s\n\n", $progname, sprintf($format, @params);
    usage();
    exit(2);
}

sub set_action {
    my ($value) = @_;
    if ($action) {
        badusage(_g("two commands specified: --%s and --%s"), $value, $action);
    }
    $action = $value;
}

{
    my $fh_log;
    sub log_msg {
        my ($msg) = @_;
        # XXX: the C rewrite must use the std function to get the
        # filename from /etc/dpkg/dpkg.cfg or from command line
        if (!defined($fh_log) and -w "/var/log/dpkg.log") {
            open($fh_log, ">>", "/var/log/dpkg.log") ||
                quit(_g("Can't append to %s"), "/var/log/dpkg.log");
        }
        if (defined($fh_log)) {
            $msg = POSIX::strftime("%Y-%m-%d %H:%M:%S", localtime()) .
                   " $progname: $msg\n";
            print $fh_log $msg;
        }
    }
}

sub get_all_alternatives {
    opendir(ADMINDIR, $admdir)
        or quit(_g("can't readdir %s: %s"), $admdir, $!);
    my @filenames = grep { !/^\.\.?$/ and !/\.dpkg-tmp$/ } (readdir(ADMINDIR));
    close(ADMINDIR);
    return sort @filenames;
}

sub config_all {
    foreach my $name (get_all_alternatives()) {
        system "$0 $skip --config $name";
        exit $? if $?;
        print "\n";
    }
}

sub pr {
    my ($format, @params) = @_;
    print sprintf($format, @params) . "\n";
}

sub rename_mv {
    my ($source, $dest, $ignore_enoent) = @_;
    $ignore_enoent = 0 unless defined($ignore_enoent);
    return 1 if ($ignore_enoent and not -e $source);
    if (not rename($source, $dest)) {
        if (system("mv", $source, $dest) != 0) {
            return $ignore_enoent if $! == ENOENT;
            return 0;
        }
    }
    return 1;
}

sub checked_symlink {
    my ($filename, $linkname) = @_;
    symlink($filename, $linkname) ||
        quit(_g("unable to make %s a symlink to %s: %s"), $linkname, $filename, $!);
}

sub checked_mv {
    my ($source, $dest) = @_;
    rename_mv($source, $dest) ||
        quit(_g("unable to install %s as %s: %s"), $source, $dest, $!);
}

sub checked_rm {
    my ($f) = @_;
    unlink($f) || $! == ENOENT || quit(_g("unable to remove %s: %s"), $f, $!);
}

### OBJECTS ####

package FileSet;

use Dpkg::Gettext;

sub new {
    my ($class, $master_file, $prio) = @_;
    my $self = {
        "master_file" => $master_file,
        "priority" => $prio,
        "slaves" =>
            {
                # "slave_name" => "slave_file"
            },
    };
    return bless $self, $class;
}
sub add_slave {
    my ($self, $name, $file) = @_;
    $self->{slaves}{$name} = $file;
}
sub has_slave {
    my ($self, $slave) = @_;
    return (exists $self->{"slaves"}{$slave} and $self->{"slaves"}{$slave});
}
sub master {
    my ($self, $val) = @_;
    return $self->{"master_file"};
}
sub priority {
    my ($self) = @_;
    return $self->{"priority"};
}
sub slave {
    my ($self, $slave) = @_;
    return $self->{"slaves"}{$slave};
}

package Alternative;

use Dpkg::Gettext;

sub pr { main::pr(@_) }
sub quit { main::quit(@_) }

sub new {
    my ($class, $name) = @_;
    my $self = {};
    bless $self, $class;
    $self->reset($name);
    return $self;
}
sub reset {
    my ($self, $name) = @_;
    my $new = {
        "master_name" => $name,
        "master_link" => undef,
        "status" => undef,
        "slaves" => {
            # "slave_name" => "slave_link"
        },
        "choices" => {
            # "master_file" => $fileset
        },
        "modified" => 0,
        "commit_ops" => [],
    };
    %$self = %$new;
}
sub choices {
    my ($self) = @_;
    my @choices = sort { $a cmp $b } keys %{$self->{choices}};
    return wantarray ? @choices : scalar(@choices);
}
sub slaves {
    my ($self) = @_;
    my @slaves = sort { $a cmp $b } keys %{$self->{slaves}};
    return wantarray ? @slaves : scalar(@slaves);
}
sub name {
    my ($self) = @_;
    return $self->{master_name};
}
sub link {
    my ($self) = @_;
    return $self->{master_link};
}
sub status {
    my ($self) = @_;
    return $self->{status};
}
sub fileset {
    my ($self, $id) = @_;
    return $self->{choices}{$id} if exists $self->{choices}{$id};
    return undef;
}
sub slave_link {
    my ($self, $id) = @_;
    return $self->{slaves}{$id} if exists $self->{slaves}{$id};
    return undef;
}
sub has_slave {
    my ($self, $slave) = @_;
    return (exists $self->{"slaves"}{$slave} and $self->{"slaves"}{$slave});
}
sub is_modified {
    my ($self) = @_;
    return $self->{modified};
}
sub has_choice {
    my ($self, $id) = @_;
    return exists $self->{choices}{$id};
}
sub add_choice {
    my ($self, $fileset) = @_;
    $self->{choices}{$fileset->master()} = $fileset;
    $self->{modified} = 1; # XXX: be smarter in detecting change ?
}
sub add_slave {
    my ($self, $slave, $link) = @_;
    $self->{slaves}{$slave} = $link;
}
sub set_status {
    my ($self, $status) = @_;
    if (!defined($self->status()) or $status ne $self->status()) {
        $self->{modified} = 1;
    }
    main::log_msg("status of link group " . $self->name() . " set to $status");
    $self->{status} = $status;
}
sub set_link {
    my ($self, $link) = @_;
    if (!defined($self->link()) or $link ne $self->link()) {
        $self->{modified} = 1;
    }
    $self->{master_link} = $link;
}
sub remove_choice {
    my ($self, $id) = @_;
    if ($self->has_choice($id)) {
        delete $self->{choices}{$id};
        $self->{modified} = 1;
        return 1;
    }
    return 0;
}

{
    # Helper functions for load() and save()
    my ($fh, $filename);
    sub config_helper {
        ($fh, $filename) = @_;
    }
    sub gl {
        undef $!;
        my $line = <$fh>;
        unless (defined($line)) {
            quit(_g("error while reading %s: %s"), $filename, $!) if $!;
            quit(_g("unexpected end of file in %s while trying to read %s"),
                 $filename, $_[0]);
        }
        chomp($line);
        return $line;
    }
    sub badfmt {
        quit(_g("internal error: %s corrupt: %s"), $filename, sprintf(@_));
    }
    sub paf {
        my $line = shift @_;
        if ($line =~ m/\n/) {
            quit(_g("newlines prohibited in update-alternatives files (%s)"), $line);
        }
        print $fh "$line\n" || quit(_g("error writing %s: %s"), $filename, $!);
    }
}

sub load {
    my ($self, $file, $must_not_die) = @_;
    return 0 unless -s $file;
    eval {
        open(my $fh, "<", $file) || quit(_g(""), $file, $!);
        config_helper($fh, $file);
	my $status = gl(_g("status"));
	badfmt(_g("invalid status")) unless $status =~ /^(?:auto|manual)$/;
	my $link = gl("link");
        my (%slaves, @slaves);
	while ((my $slave_name = gl(_g("slave name"))) ne '') {
	    my $slave_link = gl(_g("slave link"));
	    badfmt(_g("duplicate slave %s"), $slave_name)
                if exists $slaves{$slave_name};
	    badfmt(_g("slave link same as main link %s"), $link)
                if $slave_link eq $link;
            badfmt(_g("duplicate slave link %s"), $slave_link)
                if grep { $_ eq $slave_link } values %slaves;
            $slaves{$slave_name} = $slave_link;
            push @slaves, $slave_name;
	}
        my @filesets;
        my $modified = 0;
	while ((my $main_file = gl(_g("master file"))) ne '') {
	    badfmt(_g("duplicate path %s"), $main_file)
                if grep { $_->{master_file} eq $main_file } @filesets;
	    if (-e $main_file) {
		my $priority = gl(_g("priority"));
                badfmt(_g("priority of %s: %s"), $main_file, $priority)
                    unless $priority =~ m/^[-+]?\d+$/;
                my $group = FileSet->new($main_file, $priority);
                foreach my $slave (@slaves) {
                    $group->add_slave($slave, gl(_g("slave file")));
		}
                push @filesets, $group;
	    } else {
		# File not found - remove
		pr(_g("Alternative for %s points to %s - which wasn't found.  Removing from list of alternatives."),
                   $alternative->name(), $main_file) if $verbosemode > 0;
		gl(_g("priority"));
                foreach my $slave (@slaves) {
		    gl(_g("slave file"));
		}
                $modified = 1;
	    }
	}
        close($fh);
        # We parsed the file without trouble, load data into the object
        $self->{master_link} = $link;
        $self->{slaves} = \%slaves;
        $self->{status} = $status;
        $self->{modified} = $modified;
        $self->{choices} = {};
        foreach my $group (@filesets) {
            $self->{choices}{$group->master()} = $group;
        }
    };
    if ($@) {
        return 0 if $must_not_die;
        die $@;
    }
    return 1;
}

sub save {
    my ($self, $file) = @_;
    # Cleanup unused slaves before writing admin file
    foreach my $slave ($self->slaves()) {
        my $has_slave = 0;
        foreach my $choice ($self->choices()) {
            my $fileset = $self->fileset($choice);
            $has_slave++ if $fileset->has_slave($slave);
        }
        unless ($has_slave) {
            pr(_g("Discarding obsolete slave link %s (%s)."),
               $slave, $self->slave_link($slave))
                if $verbosemode > 0;
            delete $self->{"slaves"}{$slave};
        }
    }
    # Write admin file
    open(my $fh, ">", $file) || quit(_g("unable to write %s: %s"), $file, $!);
    config_helper($fh, $file);
    paf($self->status());
    paf($self->link());
    foreach my $slave ($self->slaves()) {
        paf($slave);
        paf($self->slave_link($slave));
    }
    paf('');
    foreach my $choice ($self->choices()) {
        paf($choice);
        my $fileset = $self->fileset($choice);
        paf($fileset->priority());
        foreach my $slave ($self->slaves()) {
            if ($fileset->has_slave($slave)) {
                paf($fileset->slave($slave));
            } else {
                paf('');
            }
        }
    }
    paf('');
    close($fh) || quit(_g("unable to close %s: %s"), $file, $!);
}

sub display_query {
    my ($self) = @_;
    pr("Link: %s", $self->name());
    pr("Status: %s", $self->status());
    my $best = $self->best();
    if (defined($best)) {
	pr("Best: %s", $best);
    }
    if ($self->has_current_link()) {
	pr("Value: %s", $self->current());
    } else {
	pr("Value: none");
    }

    foreach my $choice ($self->choices()) {
	pr("");
	pr("Alternative: %s", $choice);
        my $fileset = $self->fileset($choice);
	pr("Priority: %s", $fileset->priority());
	next unless scalar($self->slaves());
	pr("Slaves:");
        foreach my $slave ($self->slaves()) {
            if ($fileset->has_slave($slave)) {
	        pr(" %s %s", $slave, $fileset->slave($slave));
            }
        }
    }
}

sub display_user {
    my ($self) = @_;
    pr("%s - %s", $self->name(),
        ($self->status() eq "auto") ? _g("auto mode") : _g("manual mode"));

    if ($self->has_current_link()) {
	pr(_g(" link currently points to %s"), $self->current());
    } else {
	pr(_g(" link currently absent"));
    }
    foreach my $choice ($self->choices()) {
        my $fileset = $self->fileset($choice);
	pr(_g("%s - priority %s"), $choice, $fileset->priority());
        foreach my $slave ($self->slaves()) {
            if ($fileset->has_slave($slave)) {
                pr(_g(" slave %s: %s"), $slave, $fileset->slave($slave));
            }
	}
    }

    my $best = $self->best();
    if (defined($best) && $best) {
	pr(_g("Current \`best' version is %s."), $best);
    } else {
	pr(_g("No versions available."));
    }
}

sub display_list {
    my ($self) = @_;
    pr($_) foreach ($self->choices());
}

sub select_choice {
    my ($self) = @_;
    while (1) {
        my $current = $self->current() || "";
        my $best = $self->best();
        printf _g("There are %s choices for the alternative %s (providing %s).") . "\n\n",
               scalar($self->choices()), $self->name(), $self->link();
        my $length = 15;
        foreach ($self->choices()) {
            $length = (length($_) > $length) ? length($_) + 1 : $length;
        }
        printf "  %-12.12s %-${length}.${length}s %-10.10s %s\n", _g("Selection"),
               _g("Path"), _g("Priority"), _g("Status");
        print "-" x 60 . "\n";
        printf "%s %-12d %-${length}s % -10d %s\n",
               ($self->status() eq "auto" and $current eq $best) ? "*" : " ", 0,
               $best, $self->fileset($best)->priority(), _g("auto mode");
        my $index = 1;
        my %sel = ("0" => $best);
        foreach my $choice ($self->choices()) {
            $sel{$index} = $choice;
            $sel{$choice} = $choice;
            printf "%s %-12d %-${length}.${length}s % -10d %s\n",
                   ($self->status() eq "manual" and $current eq $choice) ?  "*" : " ",
                   $index, $choice, $self->fileset($choice)->priority(),
                   _g("manual mode");
            $index++;
        }
        print "\n";
        printf _g("Press enter to keep the current choice[*], or type selection number: ");
        my $selection = <STDIN>;
        return undef unless defined($selection);
        chomp($selection);
        return $current if $selection eq "";
        if (exists $sel{$selection}) {
            $self->set_status(($selection eq "0") ? "auto" : "manual");
            return $sel{$selection};
        }
    }
}


sub best {
    my ($self) = @_;
    my @choices = sort { $self->fileset($b)->priority() <=>
                         $self->fileset($a)->priority()
                  } ($self->choices());
    if (scalar(@choices)) {
        return $choices[0];
    } else {
        return undef;
    }
}

sub has_current_link {
    my ($self) = @_;
    return -l "$altdir/$self->{master_name}";
}

sub current {
    my ($self) = @_;
    return undef unless $self->has_current_link();
    my $val = readlink("$altdir/$self->{master_name}");
    pr(_g("readlink(%s) failed: %s"), "$altdir/$self->{master_name}", $!)
        unless defined $val;
    return $val;
}

sub add_commit_op {
    my ($self, $sub) = @_;
    push @{$self->{commit_ops}}, $sub;
}
sub prepare_install {
    my ($self, $choice) = @_;
    my ($link, $name) = ($self->link(), $self->name());
    my $fileset = $self->fileset($choice);
    # Setup main link
    main::checked_rm("$link.dpkg-tmp");
    main::checked_symlink("$altdir/$name", "$link.dpkg-tmp");
    # Setup main alternative link
    main::checked_rm("$altdir/$name.dpkg-tmp");
    main::checked_symlink($choice, "$altdir/$name.dpkg-tmp");
    # Add commit operations
    $self->add_commit_op(sub {
        main::checked_mv("$link.dpkg-tmp", $link);
        main::checked_mv("$altdir/$name.dpkg-tmp", "$altdir/$name");
    });
    # Take care of slaves links
    foreach my $slave ($self->slaves()) {
        my ($slink, $spath) = ($self->slave_link($slave), $fileset->slave($slave));
        if ($fileset->has_slave($slave)) {
            # Setup slave link
            main::checked_rm("$slink.dpkg-tmp");
            main::checked_symlink("$altdir/$slave", "$slink.dpkg-tmp");
            # Setup slave alternative link
            main::checked_rm("$altdir/$slave.dpkg-tmp");
            main::checked_symlink($spath, "$altdir/$slave.dpkg-tmp");
            # Add commit operations
            $self->add_commit_op(sub {
                main::checked_mv("$slink.dpkg-tmp", $slink);
                main::checked_mv("$altdir/$slave.dpkg-tmp", "$altdir/$slave");
            });
        } else {
            # Drop unused slave
            $self->add_commit_op(sub {
                main::checked_rm($slink);
                main::checked_rm("$altdir/$slave");
            });
        }
    }
}

sub remove {
    my ($self) = @_;
    my ($link, $name) = ($self->link(), $self->name());
    main::checked_rm("$link.dpkg-tmp");
    main::checked_rm($link);
    main::checked_rm("$altdir/$name.dpkg-tmp");
    main::checked_rm("$altdir/$name");
    foreach my $slave ($self->slaves()) {
        my $slink = $self->slave_link($slave);
        main::checked_rm("$slink.dpkg-tmp");
        main::checked_rm($slink);
        main::checked_rm("$altdir/$slave.dpkg-tmp");
        main::checked_rm("$altdir/$slave");
    }
    # Drop admin file
    main::checked_rm("$admdir/$name");
}

sub commit {
    my ($self) = @_;
    foreach my $sub (@{$self->{commit_ops}}) {
        &$sub();
    }
    $self->{commit_ops} = [];
}

sub is_broken {
    my ($self) = @_;
    my $name = $self->name();
    return 1 if not $self->has_current_link();
    # Check master link
    my $file = readlink($self->link());
    return 1 if not defined($file);
    return 1 if $file ne "$altdir/$name";
    # Stop if we have an unmanaged alternative
    return 0 if not $self->has_choice($self->current());
    # Check slaves
    my $fileset = $self->fileset($self->current());
    foreach my $slave ($self->slaves()) {
        $file = readlink($self->slave_link($slave));
        if ($fileset->has_slave($slave)) {
            return 1 if not defined($file);
            return 1 if $file ne "$altdir/$slave";
            $file = readlink("$altdir/$slave");
            return 1 if not defined($file);
            return 1 if $file ne $fileset->slave($slave);
        } else {
            # Slave link must not exist
            return 1 if defined($file);
            $file = readlink("$altdir/$slave");
            return 1 if defined($file);
        }
    }
    return 0;
}
# vim: nowrap ts=8 sw=4