xNightR00T File Manager

#! /usr/bin/perl

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# This is a (wrapper) script to update the bootloader config.
#
# It checks /etc/sysconfig/bootloader for the bootloader type.
#
# If there's no bootloader configured, it does nothing.
#
# If the directory /usr/lib/bootloader/$LOADER exists, runs the scripts from
# that directory.
#
# For any other bootloader it runs the old bootloader_entry and
# update-bootloader scripts (renamed to *.old).
#

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
use strict;
use POSIX qw ( strftime uname );

use File::Temp;
use Getopt::Long;
use Data::Dumper;
$Data::Dumper::Sortkeys = 1;
$Data::Dumper::Terse = 1;
$Data::Dumper::Indent = 1;

my $VERSION = "0.923";

my $pbl_dir = "/usr/lib/bootloader";

sub pbl_usage;
sub new;
sub log_msg;
sub run_command;
sub read_sysconfig;

my $program;
my $log;
my $loader;
my $exit_code = 0;
my @todo;

my $opt_logfile = "/var/log/pbl.log";


# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# pbl_usage($exit_code)
#
# Print help text and exit.
#
sub pbl_usage
{
  print <<"= = = = = = = =";
Usage: pbl [OPTIONS]
Configure/install boot loader.

Options:
    --install               Install boot loader.
    --config                Create boot loader config.
    --show                  Print current boot loader name.
    --default ENTRY         Set default boot entry to ENTRY.
    --add-option OPTION     Add OPTION to default boot options.
    --del-option OPTION     Delete OPTION from default boot options.
    --get-option OPTION     Get OPTION from default boot options.
    --log LOGFILE           Log messages to LOGFILE (default: /var/log/pbl.log)
    --version               Show pbl version.
    --help                  Write this help text.

= = = = = = = =

  exit shift;
}


# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
sub new
{
  $log->{session_id} = $program . sprintf("-%04d", int rand 10000);

  # log to logfile if we can

  if(open my $f, ">>$opt_logfile") {
    my $tmp = select $f;
    $| = 1;
    select $tmp;
    binmode $f, ':utf8';
    $log->{log_fh} = $f;
    $log->{log_is_tty} = 1 if $opt_logfile eq '-';
  }

  # find root device & detect if we are chroot-ed
  my $r = "?";
  my @r0 = stat "/";
  my @r1 = stat "/proc/1/root";
  if(@r0 && @r1) {
    my $r0 = ($r0[0] >> 8) . ":" . ($r0[0] & 0xff);
    $r = readlink "/dev/block/$r0";
    $r =~ s#^..#/dev# if defined $r;
    $r = $r0 unless defined $r;
    if($r0[0] != $r1[0] || $r0[1] != $r1[1]) {
      $r .= " (chroot)";
    }
  }

  log_msg(1, "$log->{session_id} = $0, version = $VERSION, root = $r");
}


# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# log_msg(level, message, var, depth)
#
# level: 0 .. 3 (debug, log_msg, warning, error)
# message: log message (single line string)
# var (optional): either a SCALAR or a REF
#   - SCALAR (may be multiline) will be logged in a block delimited
#     by '<<<<<<<<<<<<<<<<' and '>>>>>>>>>>>>>>>>'
#   - REF will be logged using Data::Dumper
# depth (optional): maximum depth when logging a REF
#
sub log_msg
{
  my $level = shift;
  my $message = shift;

  new if !$log;

  my $line = (caller(1))[2];
  my $func = (caller(1))[3];
  $func =~ s/^main:://;

  $func = 'main', $line = (caller(0))[2] if $func eq '';

  my $id = $log->{session_id} || "???-0000.0";

  # we split the log line a bit into prefix & message

  my $prefix = strftime("%Y-%m-%d %H:%M:%S", localtime) . " <$level>";

  $message = "$id $func.$line: $message";

  if($_[0]) {
    my $x = $_[0];
    my $m = $_[1];
    if(ref $x) {
      $Data::Dumper::Maxdepth = $m if $m;
      chomp($x = Dumper $x);
      $Data::Dumper::Maxdepth = 0 if $m;
    }
    else {
      chomp $x;
      $x = "<<<<<<<<<<<<<<<<\n$x\n>>>>>>>>>>>>>>>>";
    }

    $message .= "\n$x";
  }

  if($log->{log_fh}) {
    print { $log->{log_fh} } "$prefix $message\n";
  }

  # log error messages to console unless we already did

  if(!$log->{log_is_tty} && $level > 2) {
    print STDERR "$program: $prefix $message\n";
  }
}


# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# exit_code = run_command(args)
#
# Run external command. All output is logged.
#
# The external command may put anything into the (temporary) file passed via
# 'PBL_RESULT' environment variable. The content of that file is read and
# printed to STDOUT.
#
sub run_command
{
  my $ret;
  my $output;

  my $command = join " ", @_;

  my $result_fh = File::Temp->new(TEMPLATE => 'pbl.XXXXXX', TMPDIR => 1);
  $ENV{PBL_RESULT} = $result_fh->filename;

  if(open my $f, "-|") {
    binmode $f, ':utf8';
    local $/;
    $output = <$f>;
    close $f;
    $ret = $? >> 8;
  }
  else {
    open STDERR, ">&STDOUT";
    exec @_;
    print "$command: " . ($! == 13 ? $! : "command not found") . " \n";
    exit 127;
  }

  if(!$ret) {
    log_msg(1, "'$command' = $ret, output:", $output);
    local $/;
    my $result = <$result_fh>;
    if($result ne "") {
      print "$result\n";
      log_msg(1, "result: $result");
    }
  }
  else {
    log_msg(3, "'$command' failed with exit code $ret, output:", $output);
  }

  return $ret;
}


# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# read_sysconfig(FILENAME)
#
# Read sysconfig settings and convert them into environment vars of the form:
#
# SYS__FILENAME__KEY=value
#
sub read_sysconfig
{
  my $file = $_[0];

  if(open my $f, "/etc/sysconfig/$file") {
    while(<$f>) {
      if(/^([A-Z_]+)=(.*?)\s*$/) {
        my $key = $1;
        my $val = $2;
        $val =~ s/^(["'])(.*)\1$/$2/g;
        $ENV{"SYS__\U$file\E__$key"} = $val;
      }
    }
    close $f;
  }
}


# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
($program = $0) =~ s#^.*/##;

# get settings relevant for us
read_sysconfig "bootloader";
read_sysconfig "language";

$loader = $ENV{SYS__BOOTLOADER__LOADER_TYPE};

if($program eq 'pbl') {
  GetOptions(
    'log=s'        => \$opt_logfile,
    'install'      => sub { push @todo, [ 'install' ] },
    'config'       => sub { push @todo, [ 'config' ] },
    'show'         => sub { print "$loader\n"; exit 0 },
    'default=s'    => sub { push @todo, [ 'default', $_[1] ] },
    'add-option=s' => sub { push @todo, [ 'add-option', $_[1] ] },
    'del-option=s' => sub { push @todo, [ 'del-option', $_[1] ] },
    'get-option=s' => sub { push @todo, [ 'get-option', $_[1] ] },
    'version'      => sub { print "$VERSION\n"; exit 0 },
    'help'         => sub { pbl_usage 0 },
  ) || pbl_usage 1;
}

log_msg(1, join(' ', ($0, @ARGV)));

log_msg(1, "bootloader = $loader");

exit 0 if !$loader;

my $lang = $ENV{SYS__LANGUAGE__RC_LANG};
if(defined $lang) {
  log_msg(1, "locale = $lang");
  delete $ENV{LC_MESSAGES};
  delete $ENV{LC_ALL};
  $ENV{LANG} = $lang;
}

if($program ne 'pbl') {
  # compat: update-bootloader or bootloader_entry
  push @todo, [ 'config' ];
  unshift @todo, [ 'install' ] if grep { /^--reinit$/ } @ARGV;
}

if(-d "$pbl_dir/$loader") {
  for (@todo) {
    my @cmd = @{$_};
    $cmd[0] = "$pbl_dir/$loader/$cmd[0]";
    if(-x $cmd[0]) {
      $exit_code = run_command(@cmd) || $exit_code;
    }
    else {
      log_msg(1, "$cmd[0] skipped");
    }
  }
}
else {
  exec "/usr/lib/bootloader/$program.old", @ARGV;
  log_msg(3, "/usr/lib/bootloader/$program.old: command not found");
  $exit_code = 1;
}

exit $exit_code;