smeserver-backup/root/etc/e-smith/web/functions/backup

#!/usr/bin/perl -wT
#----------------------------------------------------------------------
# heading     : Administration
# description : Backup or restore
# navigation  : 4000 4200
# Copyright (C) 2002 Mitel Networks Corporation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
#
# Technical support for this program is available from Mitel Networks
# Please visit our web site www.mitel.com/sme/ for details.
#----------------------------------------------------------------------
use strict;
use esmith::FormMagick;
use esmith::ConfigDB;
use esmith::Backup;
use esmith::BackupHistoryDB;
use esmith::BlockDevices;
use esmith::AccountsDB;
use esmith::cgi;
use esmith::util;
use esmith::lockfile;
use File::Find;
use File::Path qw(make_path remove_tree);

$File::Find::dont_use_nlink = 1;  # fix for Windows shares

my $fm = esmith::FormMagick->new();

# These statements _must_ come _after_ the FormMagick constructor. It sets
# POST_MAX and DISABLE_UPLOADS to values that will cause this script to fail
# on restores and verification of files.
$CGI::POST_MAX = -1; # allow any size POST
$CGI::DISABLE_UPLOADS = 0; # need to upload to restore from desktop

$fm->parse_xml();

my $conf = esmith::ConfigDB->open()
	|| die $fm->localise('CANNOT_OPEN').'configuration db';

my $restore = esmith::ConfigDB->open('/etc/e-smith/restore')
	|| die $fm->localise('CANNOT_OPEN').'/etc/e-smith/restore';

my $es_backup = new esmith::Backup or die "Couldn't create Backup object\n";

my @directories = $es_backup->restore_list;
@directories = grep { -e "/$_" } @directories;

my @backup_excludes = $es_backup->excludes;

# Unbuffer standard output so that files and directories are listed as
# they are restored
$| = 1;

# Store away current gid of 'www' group.
my $www_gid = getgrnam("www");

#------------------------------------------------------------
# examine state parameter and display the appropriate form
#------------------------------------------------------------

my $q = $fm->{cgi};

if (! grep (/^state$/, $q->param))
{
    showInitial ($q, '');
}
elsif ($q->param ('state') eq "perform")
{
    performAndShowResult ($q);
}
elsif ($q->param ('state') eq "tape-configure")
{
    updateTapeBackupConfig($q);
}
elsif ($q->param ('state') eq "tape-restore")
{
    performTapeRestore ($q);
}
elsif ($q->param ('state') eq "workstn-configure")
{
    WorkstnBackupConfig1($q);
}
elsif ($q->param ('state') eq "workstn-configure1")
{
    updateWorkstnBackupConfig($q);
}
elsif ($q->param ('state') eq "workstn-verify")
{
    performWorkstnVerify($q);
}
elsif ($q->param ('state') eq "workstn-restore")
{
    performWorkstnRestore ($q);
}
elsif ($q->param ('state') eq "workstn-sel-restore")
{
    performWorkstnSelRestore ($q);
}
elsif ($q->param ('state') eq "workstn-sel-restore2")
{
    performWorkstnSelRestore2 ($q);
}
else
{
    esmith::cgi::genStateError ($q, undef);
}

exit (0);

#------------------------------------------------------------
# subroutine to display initial form
#------------------------------------------------------------

sub showInitial
{
    my ($q, $msg) = @_;

	my $rec = $restore->get('restore');
	if($msg eq '')
	{
		if($rec)
		{
			$msg = $rec->prop('errmsg') || '';
			$rec->delete_prop('errmsg');
		}
	}

    if ($msg eq '')
    {
	esmith::cgi::genHeaderNonCacheable ($q, undef,
		$fm->localise('BACKUP_TITLE'));
    }
    else
    {
	esmith::cgi::genHeaderNonCacheable
	($q, undef, $fm->localise('OPERATION_STATUS_REPORT'));

	print $q->div ({-class => "sme-error"}, $msg);
	print $q->hr;
    }
    print $q->div({-class => 'error'},
	$q->h5('Warning: a reboot is required before proceeding!
	    Failure to reboot now may leave your system in an unknown
	    state!'))
	    if $conf->get_prop('bootstrap-console', 'Run') eq 'yes';

    my ($tarsize, $dumpsize, undef, undef) = &CalculateSizes();

    my $module = $conf->get('backup');
    if ($module)
    {
	$module = $module->prop('Program');
    }

    # The default e-smith backup program is flexbackup.

    unless (defined $module)
    {
	$module = "flexbackup";
    }
    elsif ($module eq '')
    {
	$module = "flexbackup";
    }

    # Hack to evaluate embedded vars
    print eval 'return "'.$fm->localise('BACKUP_DESC_DAR').'\n";';

    if ($tarsize =~ /Tb/ or $tarsize =~ /(\d+)Gb/ and $1 >= 2)
    {
        print $fm->localise("BACKUP_DESKTOP_TOO_BIG"), "\n";
    }

    print $q->h2($fm->localise("BACKUP_CONFIG_STATUS")),"\n";

    my $backup_status = $conf->get('backup');
    if ($backup_status)
    {
	$backup_status = $backup_status->prop('status');
    }

    if (defined $backup_status && $backup_status eq "enabled")
    {
	my $backupTime = $conf->get('backup')->prop('backupTime');
	my $reminderTime = $conf->get('backup')->prop('reminderTime');

	print $q->p ($fm->localise('TAPE_BACKUPS_ENABLED'),
		$fm->localise('BACKUPS_RUN_AT'),$q->b($backupTime),
		$fm->localise('REMINDER_MESSAGE_AT'),$q->b($reminderTime)),
		"\n";
    }
    else
    {
	print $q->p($fm->localise('TAPE_BACKUPS_DISABLED')),"\n";
    }

    my $backupwk_status = $conf->get('backupwk');
    if ($backupwk_status)
    {
	$backupwk_status = $backupwk_status->prop('status');
    }

    if (defined $backupwk_status && $backupwk_status eq "enabled")
    {
	my $backupwkTime = $conf->get('backupwk')->prop('BackupTime');

	print $q->p ($fm->localise('WORKSTN_BACKUPS_ENABLED'),
		$fm->localise('WKBACKUPS_RUN_AT'),$q->b($backupwkTime));
    }
    else
    {
	print $q->p($fm->localise('WORKSTN_BACKUPS_DISABLED'));
    }

    my %labels = (
	    "desktop-backup"    =>  $fm->localise('DESKTOP_BACKUP'),
	    "tape-configure"    =>  $fm->localise('TAPE_CONFIGURE'),
	    "tape-restore"      =>  $fm->localise('TAPE_RESTORE'),
	    "workstn-configure"    =>  $fm->localise('WORKSTN_CONFIGURE'),
	    "workstn-verify"    =>  $fm->localise('WORKSTN_VERIFY'),
	    "workstn-restore"      =>  $fm->localise('WORKSTN_RESTORE'),
	    "workstn-sel-restore"      =>  $fm->localise('WORKSTN_SEL_RESTORE'),
	);

    my @labels = (
	    'desktop-backup',
	    'tape-configure',
	    'tape-restore',
	    'workstn-configure',
	    'workstn-verify',
	    'workstn-restore',
	    'workstn-sel-restore',
	);

    my $default_action = 'desktop-backup';

    my $restore_state;
    if($rec)
    {
	$restore_state = $rec->prop('state');
    }

    unless (defined $restore_state)
    {
	# Undefined, set it to idle
	if ($rec)
	{
	    $rec->reset_props(type=>'status', state=>'idle', finish=>0,
		start=>0);
	}
	else
	{
	    $rec = $restore->new_record('restore',
		{type=>'status', state=>'idle', finish=>0, start=>0});
	}
	$restore_state = 'idle';
    }
    elsif ($restore_state eq 'running')
    {
	my $start = $rec->prop('start');
	$start = scalar localtime($start);

	print $q->p ($fm->localise('RESTORE_IN_PROGRESS_BEGAN_AT')
		. "<b>$start</b>.\n" );

	%labels = (
		"refresh"	=> $fm->localise('REFRESH_THIS_DISPLAY'),
		"tape-configure" => $fm->localise('CONFIGURE_TAPE_BACKUP'),
		"workstn-configure" => $fm->localise('CONFIGURE_WORKSTN_BACKUP'),
	    );

	@labels = (
		'refresh',
		'tape-configure',
		'workstn-configure',
	    );

	$default_action = 'refresh';
    }
    elsif ($restore_state eq 'complete')
    {
        my $start = $rec->prop('start');
        $start = scalar localtime($start);
        my $finish = $rec->prop('finish');
        $finish = scalar localtime($finish);

        print $q->p ($fm->localise('RESTORE_COMPLETED'),$q->br(),
                     $fm->localise('STARTED_AT'),$q->b($start),$q->br(),
                     $fm->localise('FINISHED_AT'),$q->b($finish)),"\n";

        print $q->p (
                     $q->b ($fm->localise('YOU_MUST_REBOOT')
                           )
                    ),"\n";

        $default_action = 'reboot';
    }
    else
    {
	# Unknown state. Reset it to idle

	$rec->set_prop('state', 'idle');
	$restore_state = 'idle';
    }

    print $q->startform(
	    -method => 'POST',
	    -action => $q->url (-absolute => 1)
	),"\n";

    print $q->start_table ({-class => "sme-noborders"}),"\n";

    if ($default_action eq 'reboot')
    {
        print $q->start_table ({width => "100%", -class => "sme-noborders"}),"\n";
        print esmith::cgi::genButtonRow(
                $q,
                $q->submit (-name => 'action', -value =>
                $fm->localise('REBOOT'))
        );
        # Put in a hidden widget to store the reboot value.
        print $q->hidden(
                        -name => 'function',
                        -value => 'reboot'
                        ),"\n";
        print $q->end_table,"\n";
    }
    else
    {
	print $q->Tr(
	    $q->td({-class => "sme-noborders-label"},    
                $fm->localise("SELECT_AN_ACTION")),
	    $q->td({-class => "sme-noborders-content"},    
                $q->popup_menu (
                    -name => 'function',
                    -values => [ @labels ],
                    -default => $default_action,
                    -labels => \%labels
		)
	    )
	),"\n";
	
    }

    print $q->end_table,"\n";

    if ($default_action ne 'reboot')
    {
        print $q->start_table ({width => "100%", -class => "sme-noborders"}),
		"\n";

        print esmith::cgi::genButtonRow(
                $q,
                $q->submit (-name => 'action', -value =>
                $fm->localise('PERFORM'))
        );

	print $q->end_table,"\n";
    }

    print $q->hidden (
	    -name => 'state',
	    -override => 1,
	    -default => 'perform'
	),"\n";

    print $q->endform,"\n";

    esmith::cgi::genFooter($fm);

    return;
}

sub performAndShowResult
{
    my ($q) = @_;

    my $function = $q->param ('function');

    if ($function eq 'refresh')
    {
	showInitial ($q, '');
    }
    elsif ($function eq 'reboot')
    {
	performReboot();
    }
    elsif ($function eq 'desktop-backup')
    {
	desktopBackup();
    }
    elsif ($function eq 'tape-configure')
    {
	TapeBackupConfig ($q);
    }
    elsif ($function eq 'tape-restore')
    {
	tapeRestore();
    }
    elsif ($function eq 'workstn-configure')
    {
	WorkstnBackupConfig ($q);
    }
    elsif ($function eq 'workstn-verify')
    {
	workstnVerify();
    }
    elsif ($function eq 'workstn-restore')
    {
	workstnRestore();
    }
    elsif ($function eq 'workstn-sel-restore')
    {
	workstnSelRestore();
    }
    else
    {
	# Unknown function - refresh the screen anyway
	showInitial ($q, 'unknown');
    }

    return;

    esmith::cgi::genHeaderNonCacheable ($q, undef,
	$fm->localise("X_BACKUP_OR_RESTORE"));
    print $q->p ( $function );
    esmith::cgi::genFooter($fm);
}

sub desktopBackupRecordStatus
{
    my ($backup, $phase, $status) = @_;
    my $now = time();

    warn("Backup terminated: $phase failed - status: $status\n");
    $backup->set_prop('EndEpochTime', "$now");
    $backup->set_prop('Result', "$phase:$status");
}

sub desktopBackup ()
{
    # Generate a header that will trigger a download and send data as
    # an octet stream.

    my $backups = esmith::BackupHistoryDB->open;
    my $now = time();
    my $backup_rec = $backups->new_record($now, {
				type => 'backup_record',
				BackupType => 'desktop',
				StartEpochTime => $now,
			    });
    my $CompressionLevel = $conf->get_prop("backupconsole", "CompressionLevel") || "-6";
    my @exclude = map (" --exclude=$_",@backup_excludes);

    # Dump the current mysql tables so that they are part of the image.
    # The events handle cases where mysqld is not enabled, and/or is
    # not running.

    my $status = system("/sbin/e-smith/signal-event", "pre-backup", "desktop");
    if ($status)
    {
	desktopBackupRecordStatus($backup_rec, 'pre-backup', $status);
	esmith::cgi::genHeaderNonCacheable(
	    $fm->{cgi},
	    undef, $fm->localise('OPERATION_STATUS_REPORT'));
	esmith::cgi::genResult(
	    $fm->{cgi}, $fm->localise('ERR_PRE_BACKUP'));
	return;
    }

    print "Expires: 0\n";
    print "Content-type: application/octet-stream\n";
    print "Content-disposition: attachment; filename=smeserver.tgz\n";
    print "\n";
    setpgrp;
    my $ourpgrp = getpgrp;
    local $SIG{PIPE} = sub
	    {
		local $SIG{HUP} = 'IGNORE';
		warn "Got sigpipe - sending HUP to $ourpgrp\n";
		kill HUP => -$ourpgrp;
		desktopBackupRecordStatus($backup_rec,
		    'send2browser', 'Incomplete');
		exit 1;
	    };

    open(RD,
	    "/bin/tar --directory / --create @directories --file=-"
	    . "@exclude | /usr/bin/gzip $CompressionLevel |"
	);

    while (<RD>)
    {
	print;
    }

    close RD;

    # Remove the dumped tables.

    $status = system("/sbin/e-smith/signal-event", "post-backup", "desktop");
    if ($status)
    {
	desktopBackupRecordStatus($backup_rec, 'post-backup', $status);
	die ($fm->localise('ERR_POST_BACKUP'),"\n");
    }
    $now = time();
    $backup_rec->set_prop('EndEpochTime', "$now");
    $backup_rec->set_prop('Result', "0");
}

sub TapeBackupConfig
{
    my ($q) = @_;
    my $enabledChk = "";
    my $backupAMPM = 'AM';
    my $backupMin;
    my $backupHour;
    my $reminderAMPM = 'AM';
    my $reminderMin;
    my $reminderHour;

    esmith::cgi::genHeaderNonCacheable(
	$q, undef, $fm->localise('ENABLE_DISABLE_TAPE'));

    print $q->p ($fm->localise('TAPE_CONFIG_DESC'));

    # Obtain time for backup from the backup cron template
    my $rec = $conf->get('backup');
    my $backupTime = "2:00";
    if ($rec)
    {
	$backupTime = $rec->prop('backupTime') || "2:00";
    }

    ($backupHour, $backupMin) = split (":", $backupTime, -1);

    if ($backupHour > 11)
    {
	if ($backupHour > 12)
	{
	    $backupHour -= 12;
	}
	$backupAMPM = 'PM';
    }

    # Obtain time for reminder notice from the backup cron template
    my $reminderTime = "14:00";
    if ($rec)
    {
	$reminderTime = $rec->prop('reminderTime') || "14:00";
    }

    ($reminderHour, $reminderMin) = split (":", $reminderTime, -1);

    if ($reminderHour > 12)
    {
	$reminderHour -= 12;
	$reminderAMPM = 'PM';
    }

    print $q->startform(
	    -method => 'POST',
	    -action => $q->url (-absolute => 1)
	);

    print $q->start_table ({-class => "sme-noborders"});

    my $backup_status;
    if ($rec)
    {
	$backup_status = $rec->prop('status');
    }

    if (defined $backup_status && $backup_status eq "enabled")
    {
	$enabledChk = "checked";
    }

    print $q->Tr(
	    $q->td(
		    $fm->localise('ENABLE_TAPE_BACKUP')
		    . " <input type=\"checkbox\""
		    . " name=\"tapebackup\""
		    . " $enabledChk"
		    . " value=\"on\">"
		)
	);

    print $q->Tr(
		    esmith::cgi::genCell(
			    $q,$fm->localise('TAPE_BACKUP_TIME')
			),

	esmith::cgi::genCell ($q, $q->textfield (-name  => 'backupHour',
						-override => 1,
						-default => $backupHour,
						-size => 2)),

	esmith::cgi::genCell ($q, $q->textfield (-name  => 'backupMin',
						-override => 1,
						-default => $backupMin,
						-size => 2)),

	esmith::cgi::genCell ($q, "AM/PM:"),

	esmith::cgi::genCell ($q, $q->popup_menu (-name => 'backupAMPM',
						-values => ['AM', 'PM'],
						-default => $backupAMPM)));

    my %timelabels=('AM' => $fm->localise('AM'),'PM' => $fm->localise('PM'));
    print $q->Tr(
		    esmith::cgi::genCell(
			    $q, $fm->localise('LOAD_TAPE_REMINDER_TIME')
			),

	    esmith::cgi::genCell(
		    $q,
		    $q->textfield(
			    -name  => 'reminderHour',
			    -override => 1,
			    -default => $reminderHour,
			    -size => 2
			)
		),

	    esmith::cgi::genCell(
		    $q,
		    $q->textfield(
			    -name  => 'reminderMin',
			    -override => 1,
			    -default => $reminderMin,
			    -size => 2
			)
		),

	    esmith::cgi::genCell($q, $fm->localise("AM/PM").":"),

	    esmith::cgi::genCell(
		    $q,
		    $q->popup_menu(
			    -name => 'reminderAMPM',
			    -values => ['AM', 'PM'],
			    -labels => \%timelabels,
			    -default => $reminderAMPM
			)
		)
	);

    print "</table>\n";
    print $q->start_table ({width => "100%", -class => "sme-noborders"});
    print $q->Tr($q->th({-class => "sme-layout"},
		    $q->submit(
			    -name => 'action',
			    -value => $fm->localise('UPDATE_CONF')
		    )
		)
	);

    print $q->hidden(
	    -name => 'state',
	    -override => 1,
	    -default => 'tape-configure'
	);

    print $q->endform;
    print '</table>';

    esmith::cgi::genFooter($fm);
    return;
}

sub updateTapeBackupConfig
{
    my ($q) = @_;

    my $status = $q->param ('tapebackup');
    my $ampm;

    esmith::cgi::genHeaderNonCacheable(
	    $q,
	    undef, $fm->localise('UPDATING_TAPE_CONF')
	);

    if (defined $status && $status eq "on")
    {

    #--------------------------------------------------
    # Untaint parameters and check for validity
    #--------------------------------------------------

	my $backupHour = $q->param ('backupHour');
	if ($backupHour =~ /^(.*)$/) {
	    $backupHour = $1;
	} else {
	    $backupHour = "12";
	}
	if (($backupHour < 1) || ($backupHour > 12))
	{
	    esmith::cgi::genResult(
		    $fm->{cgi}, $fm->localise('ERR_INVALID_HOUR').$backupHour.
			$fm->localise('BETWEEN_1_AND_12')
		);

	    return;
	}

	my $backupMin = $q->param ('backupMin');
    	if ($backupMin =~ /^(.*)$/) {
	    $backupMin = $1;
    	} else {
	    $backupMin = "0";
    	}
	if (($backupMin < 0) || ($backupMin > 59))
    	{
	    esmith::cgi::genResult(
		    $fm->{cgi}, $fm->localise('ERR_INVALID_MINUTE').$backupMin.
			$fm->localise('BETWEEN_0_AND_59')
		);

	    return;
    	}

	$backupMin = sprintf("%02d", $backupMin);

	$ampm = $q->param ('backupAMPM');
	if ($ampm =~ /^(.*)$/) {
	    $ampm = $1;
    	} else {
	    $ampm = "AM";
    	}

    	# convert to 24 hour time

    	$backupHour = $backupHour % 12;
    	if ($ampm eq "PM")
    	{
	    $backupHour = $backupHour + 12;
    	}

    	my $reminderHour = $q->param ('reminderHour');
    	if ($reminderHour =~ /^(.*)$/) {
	    $reminderHour = $1;
    	} else {
	    $reminderHour = "12";
    	}
    	if (($reminderHour < 1) || ($reminderHour > 12))
    	{
	    esmith::cgi::genResult(
			$fm->{cgi}, 
			$fm->localise('ERR_INVALID_REMINDER_HOUR').$reminderHour
			.$fm->localise('BETWEEN_1_AND_12')
		);

	    return;
    	}

    	my $reminderMin = $q->param ('reminderMin');
    	if ($reminderMin =~ /^(.*)$/) {
	    $reminderMin = $1;
    	} else {
	    $reminderMin = "0";
    	}
    	if (($reminderMin < 0) || ($reminderMin > 59))
    	{
	    esmith::cgi::genResult(
		    $fm->{cgi}, $fm->localise('ERR_INVALID_REMINDER_MINUTE').
			$reminderMin.$fm->localise('BETWEEN_0_AND_59')
		);
	    return;
    	}

	$reminderMin = sprintf("%02d", $reminderMin);

    	$ampm = $q->param ('reminderAMPM');
    	if ($ampm =~ /^(.*)$/) {
	    $ampm = $1;
    	} else {
	    $ampm = "AM";
    	}

    	# convert to 24 hour time

	$reminderHour = $reminderHour % 12;
    	if ($ampm eq "PM")
    	{
	    $reminderHour = $reminderHour + 12;
    	}

	# variables passed validity checks, set configuration database values
	my $old = $conf->get('UnsavedChanges')->value;

	my $rec = $conf->get('backup');
	unless (defined $rec)
	{
	    $rec = $conf->new_record('backup', {type=>'service'});
	}

	$rec->set_prop('status', 'enabled');

	my $module = $rec->prop('Program');

	# The default e-smith backup program is flexbackup.

	unless (defined $module)
	{
	    $module = "flexbackup";
	}
	elsif ($module eq '')
	{
	    $module = "flexbackup";
	}

	$rec->set_prop('Program', $module);
	$rec->set_prop('backupTime', "$backupHour:$backupMin");
	$rec->set_prop('reminderTime', "$reminderHour:$reminderMin");

	$conf->get('UnsavedChanges')->set_value($old);

	system("/sbin/e-smith/signal-event", "conf-backup") == 0
	    or die($fm->localise('ERR_CONF_BACKUP'),"\n");

	esmith::cgi::genResult(
		$fm->{cgi}, $fm->localise('SUCCESSFULLY_ENABLED_TAPE').$q->br().
		$fm->localise('WITH_BACKUP_TIME')."$backupHour:$backupMin".
		$q->br().$fm->localise('WITH_REMINDER_TIME').
		"$reminderHour:$reminderMin");
    }
    else
    {
	# set service to disabled
	my $old = $conf->get('UnsavedChanges')->value;

	my $rec = $conf->get('backup');
	unless ($rec)
	{
	    $rec = $conf->new_record('backup', {type=>'service'});
	}

	$rec->set_prop('status', 'disabled');
	$conf->get('UnsavedChanges')->set_value($old);

	system("/sbin/e-smith/signal-event", "conf-backup") == 0
	    or die($fm->localise('ERR_CONF_BACKUP')."\n");

	esmith::cgi::genResult(
		$fm->{cgi}, $fm->localise('SUCCESSFULLY_DISABLED')
	    );
    }

    return;
}

sub tapeRestore ()
{
    esmith::cgi::genHeaderNonCacheable(
	$q, undef, $fm->localise('RESTORE_CONF_FROM_TAPE'));

    print $fm->localise('RESTORE_CONF_FROM_TAPE_DESC');

    print $q->start_multipart_form(
	    -method => 'POST',
	    -action => $q->url (-absolute => 1)
	);

    print $q->start_table ({width => "100%", -class => "sme-noborders"});

    print esmith::cgi::genButtonRow(
		    $q,
		    $q->submit (-name => 'action',
                                -value => $fm->localise('RESTORE_FROM_TAPE'))
	);
    print "</table>\n";
	print $q->hidden(
		-name => 'state',
		-override => 1,
		-default => 'tape-restore'
	    );

	print $q->endform;
	esmith::cgi::genFooter($fm);
}

sub performTapeRestore
{
    my ($q) = @_;

    #----------------------------------------
    # restore system from backup tape
    #----------------------------------------

    my $lock_file = "/var/lock/subsys/e-smith-restore";
    my $file_handle = &esmith::lockfile::LockFileOrReturn($lock_file);

    unless ($file_handle)
    {
	esmith::cgi::genHeaderNonCacheable(
		$q,
		undef,
		$fm->localise('UNABLE_TO_RESTORE_CONF')
	    );

	print $q->p (
	    $q->b ($fm->localise('ANOTHER_RESTORE_IN_PROGRESS')
		)
	    );

	esmith::cgi::genFooter($fm);
	return;
    }

    my $rec = $restore->get('restore');
    $rec->set_prop('state', 'running');
    $rec->set_prop('start', time);

	my $sec = 10;
	print "Refresh: $sec; URL=/server-manager/cgi-bin/backup\n";
    esmith::cgi::genHeaderNonCacheable(
	    $q, undef, $fm->localise()
	);

    print $q->p($fm->localise('NOW_RESTORING_FROM_TAPE')
	);

    print $q->p (
	$q->b ($fm->localise('MUST_REBOOT_AFTER_RESTORE'))
	);

	print $q->p($fm->localise('PAGE_REFRESH_IN', {sec=>$sec}));

    my $child;

    if ($child = fork)
    {
	# Parent

	$SIG{'CHLD'} = 'IGNORE';
	&esmith::lockfile::UnlockFile($file_handle);

	esmith::cgi::genFooter($fm);
	return;
    }
    elsif (defined $child)
    {
	# Child

	# Re-establish the lock. Wait till it is relinquished by the parent.

	$file_handle = &esmith::lockfile::LockFileOrWait($lock_file);

	# Close STDOUT so that the web server connection is closed.

	close STDOUT;

	# Now reopen STDOUT for the child. Redirect it to STDERR.

	open(STDOUT, ">&STDERR");

	unless(system("/sbin/e-smith/signal-event", "pre-restore") == 0)
	{
		$rec->set_prop('errmsg', $fm->localise('ERR_PRE_RESTORE'));
		$rec->delete_prop('state');
	    die ($fm->localise('ERR_PRE_RESTORE'),"\n");
	}
	unless(system("/sbin/e-smith/signal-event", "restore-tape") == 0)
	{
		$rec->set_prop('errmsg', $fm->localise('ERR_RESTORING_FROM_TAPE'));
		$rec->delete_prop('state');
	    die ($fm->localise('ERR_RESTORING_FROM_TAPE')."\n");
	}

	#----------------------------------------
	# regenerate configuration files
	#----------------------------------------

	unless(system("/usr/sbin/groupmod", "-g", "$www_gid", "www") == 0)
	{
		$rec->set_prop('errmsg', $rec->prop('errmsg').'<br>'.
		    $fm->localise('ERR_RESTORING_GID'));
	    warn ($fm->localise('ERR_RESTORING_GID')."\n");
	}
	unless(system("/usr/sbin/usermod", "-g", "$www_gid", "www") == 0)
	{
		$rec->set_prop('errmsg', $rec->prop('errmsg').'<br>'.
			$fm->localise('ERR_RESTORING_INITIAL_GRP'));
	    warn ($fm->localise('ERR_RESTORING_INITIAL_GRP')."\n");
	}
	unless(system("/sbin/e-smith/signal-event", "post-upgrade") == 0)
	{
		$rec->set_prop('errmsg', $rec->prop('errmsg').'<br>'.
			$fm->localise('ERR_UPDATING_CONF_AFTER_TAPE_RESTORE'));
		$rec->delete_prop('state');
	    die ($fm->localise('ERR_UPDATING_CONF_AFTER_TAPE_RESTORE'));
	}

	my $finish = time;
	$rec->set_prop('state', 'complete');
	$rec->set_prop('finish', $finish);

	my $start = $rec->prop('start');
	$start = scalar localtime($start);
	$finish = scalar localtime($finish);

	&esmith::lockfile::UnlockFile($file_handle);

	exit;
    }
    else
    {
	# Error

	$rec->delete_prop('state');
	$rec->set_prop('errmsg', $fm->localise('COULD_NOT_FORK'));
	die ($fm->localise("COULD_NOT_FORK")."$!\n");
    }
}

sub WorkstnBackupConfig
{
    my ($q) = @_;
    my $backupwk_status;
    my $enabledIncOnlyTimeout = "";
    my $smbv1 = "";
    my $backupwkLogin = 'backup';
    my $backupwkPassword = 'backup';
    my $backupwkStation = 'host';
    my $backupwkFolder = 'share';
    my $backupwkMount = '/mnt/smb';
    my $setsNumber;
    my $filesinset;
    my $backupwkTime;
    my $backupwkTimeout;
    my $backupwkIncOnlyTimeout;
    my $compression;
    my $VFSType;
    my $dof;
    my @dlabels = split(' ', $fm->localise('DOW'));
    my @VFST = ('cifs', 'nfs', 'usb','mnt');
    my %VFST = ('cifs', $fm->localise('cifs'), 'nfs', $fm->localise('nfs'), 'usb', $fm->localise('local removable disk'), 'mnt', $fm->localise('Mounted disk')); 
        
    # Obtain backup informations from configuration
    my $rec = $conf->get('backupwk');
    if ($rec)
    {
	$backupwkTime = $rec->prop('BackupTime') || '2:00';
	$backupwkLogin = $rec->prop('Login') || 'backup';
	$backupwkPassword = $rec->prop('Password') || 'backup';
	$backupwkStation = $rec->prop('SmbHost') || 'host';
	$backupwkFolder = $rec->prop('SmbShare') || 'share';
	$backupwkMount = $rec->prop('Mount') || '/mnt/smb';
	$setsNumber = $rec->prop('SetsMax') || '1';
	$filesinset = $rec->prop('DaysInSet') || '1';
	$backupwkTimeout = $rec->prop('Timeout') || '12';
	$backupwkIncOnlyTimeout = $rec->prop('IncOnlyTimeout') || 'yes';
	$compression = $rec->prop('Compression') || '0';
	$dof = (defined $rec->prop('FullDay')) ? $rec->prop('FullDay') : '7';
	$smbv1 = ( ($rec->prop('SmbV1') || 'disabled') eq "enabled" ) ? "enabled" : "disabled" ;
	$VFSType = $rec->prop('VFSType') || 'cifs';
	$backupwk_status = $rec->prop('status');
    }

    esmith::cgi::genHeaderNonCacheable($q, undef, $fm->localise('CONFIGURE_WORKSTN_BACKUP'));

    if ($rec) 
    {
        print $fm->localise('WORKSTN_BACKUP_DESC');
        print $fm->localise('WORKSTN_BACKUP_ENABLED'), $q->b(' '.$fm->localise(uc($backupwk_status))), '.<br/>';
        if ($VFSType eq 'usb')
        {
            print $fm->localise('WORKSTN_BACKUP_USB'), ' ', $backupwkFolder, '<br/>';
        }
        elsif ($VFSType eq 'mnt')
        {
            print $fm->localise('WORKSTN_BACKUP_MNT'), ' ', $backupwkMount, '<br/>';
        }
        else
        {
            print $fm->localise('WORKSTN_BACKUP_HOST'), ' ', $backupwkStation;
            print ' ', $fm->localise('WORKSTN_BACKUP_VFSTYPE'), ' ', $VFSType, '<br/>';
            print $fm->localise('WORKSTN_BACKUP_SHARE'), ' ', $backupwkFolder, '<br/>';
        }
        if ($VFSType eq 'cifs')
        {
            print $fm->localise('LOGIN'), ' ', $backupwkLogin, '<br/>';
            print $fm->localise('PASSWORD'), ' ********<br/>';
	    print $fm->localise('SMBV1'), ' ', $smbv1, '<br/>';
        }
        print $fm->localise('WORKSTN_BACKUP_SETSNUM'), ' ', $setsNumber, '<br/>';
        print $fm->localise('WORKSTN_BACKUP_DAYSINSET'), ' ', $filesinset, '<br/>';
        print $fm->localise('WORKSTN_BACKUP_COMPRESSION'), ' ', $compression, '<br/>';
        print $fm->localise('WORKSTN_BACKUP_TOD'), ' ', $backupwkTime, '<br/>';
        print $fm->localise('WORKSTN_BACKUP_TIMEOUT'), ' ', $backupwkTimeout, ' ', $fm->localise('HOURS');
        if ( $backupwkIncOnlyTimeout eq 'yes' ) 
        {
        print $fm->localise('WORKSTN_BACKUP_INCONLY_TIMEOUT')
        }
        print '<br/>';
        if ( $dof eq '7' ) 
        {
            print $fm->localise('WORKSTN_FULL_BACKUP_EVERYDAY', '<br/>');
        }
        else 
        {
            print $fm->localise('WORKSTN_FULL_BACKUP_DAY'), ' ', $dlabels[$dof], '<br/>';
        }
    }
    else { print $fm->localise('WORKSTN_BACKUP_NOT_CONFIGURED'), '<br/>' }

    print $q->startform(
	    -method => 'POST',
	    -action => $q->url (-absolute => 1)
	);

    print $q->start_table ({-class => "sme-noborders"});

    print $q->Tr($q->td($q->h3 ($fm->localise('WORKSTATION_BACKUP_SETCONF'))));


    print $q->Tr(
		    esmith::cgi::genCell(
			    $q,
			    $fm->localise('SELECT_VFS_TYPE')
			),

	esmith::cgi::genCell ($q, $q->popup_menu (-name => 'VFSType',
						-values => [ @VFST ],
						-labels => \%VFST,
						-default => $VFSType)));

    print "</table>\n";

    print $q->start_table ({width => "100%", -class => "sme-noborders"});
    print $q->Tr($q->th({-class => "sme-layout"},
		    $q->submit(
			    -name => 'action',
			    -value => $fm->localise('NEXT')
		    )
		)
	);

    print $q->hidden(
	    -name => 'state',
	    -override => 1,
	    -default => 'workstn-configure'
	);
    print '</table>';

    print $q->endform;

    esmith::cgi::genFooter ($q);
    return;
}

sub WorkstnBackupConfig1
{
    my ($q) = @_;
    my $enabledChk = "";
    my $enabledIncOnlyTimeout = "";
    my $backupwkAMPM = 'AM';
    my $backupwkMin;
    my $backupwkHour;
    my $backupwkLogin = 'backup';
    my $backupwkPassword = 'backup';
    my $backupwkStation = 'host';
    my $backupwkFolder = 'share';
    my $backupwkMount = '';
    my $setsNumber;
    my $filesinset;
    my $backupwkTimeout;
    my $backupwkIncOnlyTimeout;
    my $compression;
    my $VFSType = $q->param ('VFSType');
    my $error="";
    my $dof;
    my $smbv1 = '';
    my @usbdisks;
    my %dlabels = ();
    my @dlabels = split(' ', $fm->localise('DOW'));
    my $i = 0;
    foreach (@dlabels) {
	$dlabels{$i} = $_;
	$i++;
	}
        
    # Obtain backup informations from configuration
    my $rec = $conf->get('backupwk');
    my $backupwkTime = '2:00';
    if ($rec)
    {
	$backupwkTime = $rec->prop('BackupTime') || '2:00';
	$backupwkLogin = $rec->prop('Login') || 'backup';
	$backupwkPassword = $rec->prop('Password') || 'backup';
	$backupwkStation = $rec->prop('SmbHost') || 'host';
	$backupwkFolder = $rec->prop('SmbShare') || 'share';
	$backupwkMount = $rec->prop('Mount') || '';
	$setsNumber = $rec->prop('SetsMax') || '1';
	$filesinset = $rec->prop('DaysInSet') || '1';
	$backupwkTimeout = $rec->prop('Timeout') || '12';
	$backupwkIncOnlyTimeout = $rec->prop('IncOnlyTimeout') || 'yes';
	$compression = $rec->prop('Compression') || '0';
	$dof = (defined $rec->prop('FullDay')) ? $rec->prop('FullDay') : '7';
	$smbv1 = ( ($rec->prop('SmbV1') || 'disabled') eq "enabled" ) ? "checked" : "" ;
    }

    ($backupwkHour, $backupwkMin) = split (':', $backupwkTime, -1);

    if ($backupwkHour > 12)
    {
	$backupwkHour -= 12;
	$backupwkAMPM = 'PM';
    }

    my $backupwk_status;
    if ($rec)
    {
	$backupwk_status = $rec->prop('status');
    }

    if (defined $backupwk_status && $backupwk_status eq 'enabled')
    {
	$enabledChk = 'checked';
    }

    if (defined $backupwkIncOnlyTimeout && $backupwkIncOnlyTimeout eq 'yes')
    {
	$enabledIncOnlyTimeout = 'checked';
    }

    esmith::cgi::genHeaderNonCacheable(
	$q, undef, $fm->localise('CONFIGURE_WORKSTN_BACKUP'));

    if ( $VFSType eq 'usb' ) {
        my $devices = esmith::BlockDevices->new ('allowmount' => 'disabled');
        my ($valid, $invalid) = $devices->checkBackupDrives(0);

        if ( ${$valid}[0] ) {
            foreach ( @{$valid} ) {
                push @usbdisks, $devices->label($_);
            }
        }
        else
        {
            push @usbdisks, $fm->localise('ERR_NO_USB_DISK');
            $error='nousb';
        }
        $devices->destroy;
    }
    if ( $VFSType eq 'mnt' ) 
    {
        @usbdisks = findmnt ();
        unless ($usbdisks[0]){
            push @usbdisks, $fm->localise('ERR_NO_MOUNTED_DISK');
            $error='nomnt';
        }
    }


    print $q->startform(
	    -method => 'POST',
	    -action => $q->url (-absolute => 1)
	);

    print $fm->localise('CONFIGURE_WORKSTN_BACKUP_DESC');

    print $q->start_table ({-class => "sme-noborders"});

    print $q->Tr(
	    $q->td(
		    $fm->localise('ENABLE_WORKSTN_BACKUP')
		    . " <input type=\"checkbox\""
		    . " name=\"workstnbackup\""
		    . " $enabledChk"
		    . " value=\"on\">"
		)
	);

    print $q->Tr($q->td($q->h3 ($fm->localise('WORKSTATION_BACKUP_DEST'))));

    if ( $VFSType =~ m/cifs|nfs/s )
    {
        print $q->Tr(esmith::cgi::genCell($q,$fm->localise('WORKSTN_NAME')),
            esmith::cgi::genCell ($q, $q->textfield (-name  => 'backupwkStation',
            -override => 1,
            -default => $backupwkStation,
            -size => 20)),
        );
    }

    if ( $VFSType eq 'usb' )
    {
        print $q->Tr(esmith::cgi::genCell($q,$fm->localise('local removable disk')),
            esmith::cgi::genCell ($q, $q->popup_menu (-name  => 'backupwkFolder',
            -values => [ @usbdisks ],
            -default => $backupwkFolder,)),
        );
    }
    elsif ($VFSType eq 'mnt')
    {
        print $q->Tr(esmith::cgi::genCell($q,$fm->localise('Mounted disk')),
            esmith::cgi::genCell ($q, $q->popup_menu (-name  => 'backupwkFolder',
            -values => [ @usbdisks ],
            -default => $backupwkMount,)),
        );
    }
    else 
    {
        print $q->Tr(esmith::cgi::genCell($q,$fm->localise('SHARED_FOLDER_NAME')),
            esmith::cgi::genCell ($q, $q->textfield (-name  => 'backupwkFolder',
            -override => 1,
            -default => $backupwkFolder,
            -size => 20)),
        );
    }

    if ( $VFSType eq 'cifs' ) {
	print $q->Tr(
		    esmith::cgi::genCell(
			    $q,
			    $fm->localise('WORKSTN_LOGIN')
			),

	    esmith::cgi::genCell ($q, $q->textfield (-name  => 'backupwkLogin',
						-override => 1,
						-default => $backupwkLogin,
						-size => 12)),
	    );

	print $q->Tr(
		    esmith::cgi::genCell(
			    $q,
			    $fm->localise('PASSWORD')
			),

	    esmith::cgi::genCell ($q, $q->password_field (-name  => 'backupwkPassword',
						-override => 1,
						-default => $backupwkPassword,
						-size => 20)),
	    );
#smbv1
        print $q->Tr(
                    esmith::cgi::genCell(
                            $q,
                            $fm->localise('SMBV1')
                        ),

        	     esmith::cgi::genCell (
                    $q,
                    " <input type=\"checkbox\""
                    . " name=\"smbv1\""
                    . " $smbv1"
                    . " value=\"on\">"
            ),

            );

	}

    print '</table>';

    print $q->table ({border => 0, cellspacing => 1, cellpadding => 4});

    print $q->Tr($q->td({-colspan=>4},$q->h3 ($fm->localise('WORKSTN_BACKUP_SETTINGS'))));

    print $q->Tr(
		    esmith::cgi::genCell(
			    $q,
			    $fm->localise('NUMBER_OF_SETS')
			),

	esmith::cgi::genCell ($q, $q->textfield (-name  => 'setsNumber',
						-override => 1,
						-default => $setsNumber,
						-size => 3)),

	esmith::cgi::genCell ($q, $fm->localise('NUMBER_OF_FILES_IN_SET')),
	esmith::cgi::genCell ($q, $q->textfield (-name  => 'filesinset',
						-override => 1,
						-default => $filesinset,
						-size => 3))
	);

    print $q->Tr(
		    esmith::cgi::genCell(
			    $q,
			    $fm->localise('WORKSTN_BACKUP_TIME')
			),

	esmith::cgi::genCell ($q, $q->textfield (-name  => 'backupwkHour',
						-override => 1,
						-default => $backupwkHour,
						-size => 2)),

	esmith::cgi::genCell ($q, $q->textfield (-name  => 'backupwkMin',
						-override => 1,
						-default => $backupwkMin,
						-size => 2)),

	esmith::cgi::genCell ($q, $q->popup_menu (-name => 'backupwkAMPM',
						-values => ['AM', 'PM'],
						-default => $backupwkAMPM)));

    print $q->Tr(
		    esmith::cgi::genCell(
			    $q,
			    $fm->localise('WORKSTN_TIMEOUT')
			),

	esmith::cgi::genCell ($q, $q->textfield (-name  => 'backupwkTimeout',
						-override => 1,
						-default => $backupwkTimeout,
						-size => 2)),

        esmith::cgi::genCell(
			    $q,
			    $fm->localise('INC_ONLY_TIMEOUT')
			),

	esmith::cgi::genCell (
		    $q,
		    " <input type=\"checkbox\""
		    . " name=\"incOnlyTimeout\""
		    . " $enabledIncOnlyTimeout"
		    . " value=\"on\">"
	    ),
	);

    print $q->Tr(
		    esmith::cgi::genCell(
			    $q,
			    $fm->localise('COMPRESSION_LEVEL')
			),

	esmith::cgi::genCell ($q, $q->textfield (-name  => 'compression',
						-override => 1,
						-default => $compression,
						-size => 1)),

        esmith::cgi::genCell(
			    $q,
			    $fm->localise('FULL_ONLY_ON')
			),

	esmith::cgi::genCell (
		    $q,
	        $q->popup_menu (
		    -name => 'dof',
		    -values => [ '7', '0', '1', '2', '3', '4', '5', '6' ],
		    -labels => \%dlabels,
		    -default => $dof))
	);

    print "</table>\n";

    if ($error =~ m/nousb|nomnt/s) {$VFSType = $error;}
    print $q->start_table ({width => "100%", -class => "sme-noborders"});
    print $q->Tr($q->th({-class => "sme-layout"},
		    $q->submit(
			    -name => 'action',
			    -value => $fm->localise('UPDATE_CONF')
		    )
		)
	);

    print $q->hidden(
	    -name => 'state',
	    -override => 1,
	    -default => 'workstn-configure1'
	);
    print $q->hidden(
	    -name => 'VFSType',
	    -override => 1,
	    -default => $VFSType
	);
    print '</table>';

    print $q->endform;

    esmith::cgi::genFooter ($q);
    return;
}

sub updateWorkstnBackupConfig
{
    my ($q) = @_;

    my $status = $q->param ('workstnbackup') || "";
    my $inconly = $q->param ('incOnlyTimeout');
    my $smbv1 = $q->param ('smbv1');
    my $dof = $q->param('dof');
    my $ampm;
    my $incOnlyTimeout;

    esmith::cgi::genHeaderNonCacheable(
	    $q,
	    undef, $fm->localise('UPDATING_WORKSTN_CONF')
	);
	
    my $rec = $conf->get('backupwk');
    unless (defined $rec)
    {
        $rec = $conf->new_record('backupwk', {type=>'service'});
    }
    my $backupwkMount = $rec->prop('Mount') || '/mnt/smb';

    unless ( $status eq 'on') 
    {
        # set service to disabled
        my $old = $conf->get('UnsavedChanges')->value;

        $rec->set_prop('status', 'disabled');
        $conf->get('UnsavedChanges')->set_value($old);

        system("/sbin/e-smith/signal-event", "conf-backup") == 0
            or die($fm->localise('ERR_CONF_BACKUP')."\n");

        esmith::cgi::genResult($q, $fm->localise('SUCCESSFULLY_DISABLED_WORKSTN'));
        return;
    }
    
    #--------------------------------------------------
    # Untaint parameters and check for validity
    #--------------------------------------------------

    my $VFSType = $q->param ('VFSType');
    if ( $VFSType eq 'nousb') 
    {
        esmith::cgi::genResult($q, $fm->localise('ERR_NO_USB_DISK'));
        return;
    }
    if ( $VFSType eq 'nomnt') 
    {
        esmith::cgi::genResult($q, $fm->localise('ERR_NO_MOUNTED_DISK'));
        return;
    }

    my $backupwkStation = $q->param ('backupwkStation');
    if ( $VFSType =~ m/usb|mnt/s) { $backupwkStation = 'localhost' }
    if ($backupwkStation =~ /^\s*(\S+)\s*$/) {
	$backupwkStation = $1;
    } else {
        $backupwkStation = "";
    }
    if ( $backupwkStation eq "" )
    {
        esmith::cgi::genResult(
	    $q, $fm->localise('ERR_INVALID_WORKSTN')
	);
    return;
    }

    my $backupwkFolder = $q->param ('backupwkFolder');
    if ($backupwkFolder =~ /^(.*)$/)
    {
        $backupwkFolder = $1;
    }
    else 
    {
        $backupwkFolder = '';
    }
    if ( $VFSType eq 'usb' )
    {
        $backupwkFolder = 'media/' . $backupwkFolder;
    }
    if ( $VFSType eq 'mnt' )
    {
        $backupwkMount  = $backupwkFolder;
        if (checkMount ($backupwkMount)){$backupwkFolder = '';}
    }
    else
    {
        $backupwkFolder =~ s/^\///; # remove leading /
    } 
    if ( $backupwkFolder eq '')
    {
        esmith::cgi::genResult($q, $fm->localise('ERR_INVALID_FOLDER'));
        return;
    }

    my $backupwkLogin = $q->param ('backupwkLogin') || '';
    if ($backupwkLogin =~ /^(.*)$/) {
        $backupwkLogin = $1;
    } else {
        $backupwkLogin = "";
    }
    if ( ( $backupwkLogin eq "" ) && ( $VFSType eq 'cifs' ) )
    {
        esmith::cgi::genResult(
    	    $q, $fm->localise('ERR_INVALID_LOGIN')
    	);
        return;
    }

    my $backupwkPassword = $q->param ('backupwkPassword') || '';
    if ($backupwkPassword =~ /^(.*)$/) {
        $backupwkPassword = $1;
    } else {
        $backupwkPassword = "";
    }
    if ( ( $backupwkPassword eq "" ) && ( $VFSType eq 'cifs' ) )
    {
        esmith::cgi::genResult(
    	    $q, $fm->localise('ERR_INVALID_PASSWORD')
    	);
        return;
    }

    my $setsNumber = $q->param ('setsNumber');
    unless ( $setsNumber > 0 )
    {
        esmith::cgi::genResult(
    	    $q, $fm->localise('ERR_INVALID_SETS_NUMBER')
    	);
        return;
    }

    my $filesinset = $q->param ('filesinset');
    unless ( $filesinset > 0 )
    {
        esmith::cgi::genResult(
    	    $q, $fm->localise('ERR_INVALID_FILES_IN_SET_NUMBER')
    	);
        return;
    }

    my $timeout = $q->param ('backupwkTimeout');
    if (( $timeout eq '') || ( $timeout == 0 )) {$timeout = 24 }
    if  (( $timeout < 1 ) || ( $timeout > 24 ))
    {
        esmith::cgi::genResult(
    	    $q, $fm->localise('ERR_INVALID_TIMEOUT')
    	);
        return;
    }

    if (defined $inconly && $inconly eq 'on')
    {
	$incOnlyTimeout = 'yes';
    }
    else
    {
	$incOnlyTimeout = 'no';
    }

    if (defined $smbv1 && $smbv1 eq 'on')
    {
        $smbv1 = 'enabled';
    }
    else
    {
        $smbv1 = 'disabled';
    }

    my $compression = $q->param ('compression');
    if  (( $compression < 0 ) || ( $compression > 9 ))
    {
        esmith::cgi::genResult(
    	    $q, $fm->localise('ERR_INVALID_COMPRESSION')
    	);
        return;
    }

    $rec->set_prop('SmbHost', $backupwkStation);
    $rec->set_prop('SmbShare', $backupwkFolder);
    $rec->set_prop('SmbV1', $smbv1);
    $rec->set_prop('Mount', $backupwkMount);
    $rec->set_prop('Login', $backupwkLogin);
    $rec->set_prop('Password', $backupwkPassword);
    $rec->set_prop('SetsMax', $setsNumber);
    $rec->set_prop('DaysInSet', $filesinset);
    $rec->set_prop('Timeout', $timeout);
    $rec->set_prop('IncOnlyTimeout', $incOnlyTimeout);
    $rec->set_prop('Compression', $compression);
    $rec->set_prop('FullDay', $dof);
    $rec->set_prop('VFSType', $VFSType);
    
    my $module = $rec->prop('Program');

    # The default workstation backup program is dar.

    unless (defined $module)
    {
        $module = 'dar';
    }
    elsif ($module eq '')
    {
        $module = 'dar';
    }

    $rec->set_prop('Program', $module);

	my $backupwkHour = $q->param ('backupwkHour');
	if ($backupwkHour =~ /^(.*)$/) {
	    $backupwkHour = $1;
	} else {
	    $backupwkHour = '12';
	}
	if (($backupwkHour < 0) || ($backupwkHour > 12))
	{
	    esmith::cgi::genResult(
		    $q, $fm->localise('ERR_INVALID_HOUR').$backupwkHour.
			$fm->localise('BETWEEN_0_AND_12')
		);

	    return;
	}

	my $backupwkMin = $q->param ('backupwkMin');
    	if ($backupwkMin =~ /^(.*)$/) {
	    $backupwkMin = $1;
    	} else {
	    $backupwkMin = '0';
    	}
	if (($backupwkMin < 0) || ($backupwkMin > 59))
    	{
	    esmith::cgi::genResult(
		    $q, $fm->localise('ERR_INVALID_MINUTE').$backupwkMin.
			$fm->localise('BETWEEN_0_AND_59')
		);

	    return;
    	}

	$backupwkMin = sprintf("%02d", $backupwkMin);

	$ampm = $q->param ('backupwkAMPM');
	if ($ampm =~ /^(.*)$/) {
	    $ampm = $1;
    	} else {
	    $ampm = 'AM';
    	}

    	# convert to 24 hour time

    	$backupwkHour = $backupwkHour % 12;
    	if ($ampm eq 'PM')
    	{
	    $backupwkHour = $backupwkHour + 12;
    	}


	# variables passed validity checks, set configuration database values
	my $old = $conf->get('UnsavedChanges')->value;

	$rec->set_prop('status', 'enabled');

	$rec->set_prop('BackupTime', "$backupwkHour:$backupwkMin");

	$conf->get('UnsavedChanges')->set_value($old);

	system("/sbin/e-smith/signal-event", "conf-backup") == 0
	    or die($fm->localise('ERR_CONF_BACKUP'),"\n");

    # we test if the remote host is reachable, else we simply display a warning
    if ( $VFSType =~ m/cifs|nfs/s )
    {
    my $error_message = vmount($backupwkStation,$backupwkFolder,$backupwkMount,$VFSType,$smbv1);
    if (! $error_message)
        {
        bunmount($backupwkMount,$VFSType);
        }
    elsif ($error_message)
        {
        esmith::cgi::genResult($q, $fm->localise('ERROR_WHEN_TESTING_REMOTE_SERVER').$q->br() . "$error_message");
        return;
        }
    }

	esmith::cgi::genResult(
		$q, $fm->localise('SUCCESSFULLY_ENABLED_WORKSTN').$q->br().
		$fm->localise('WITH_BACKUP_TIME')."$backupwkHour:$backupwkMin");

    return;
}

sub workstnVerify ()
{

    my $rec = $conf->get('backupwk');
    
    esmith::cgi::genHeaderNonCacheable ($q, undef,
	$fm->localise('VERIFY_WORKSTN_BACKUP_FILE'));

    unless ($rec)
    {
	esmith::cgi::genResult(
	    $q, $fm->localise('CONFIGURATION_TO_BE_DONE'));
	return;
    }

    my %backupfiles = ();
    my $mntdir = $rec->prop('Mount') || '/mnt/smb';
    my $mntbkdir;
    my $key;
    my $id = $rec->prop('Id') || $conf->get('SystemName')->value . "." . $conf->get('DomainName')->value;
    my $smbhost = $rec->prop('SmbHost');
    my $smbshare = $rec->prop('SmbShare');
    my $smbv1 = $rec->prop('SmbV1') || 'disabled';
    my $VFSType = $rec->prop('VFSType') || 'cifs';
    my $err;
    $mntdir = "/$smbshare" if ( $VFSType eq 'usb' );
    
    my $setbackuplist = sub {
	if ( $_ =~ /\.dar/ ) {
	    my $dir = $File::Find::dir;
	    my $backupref;
	    $dir =~ s/$mntbkdir\///;
            $_ =~ s/\..*\.dar//;
	    $backupref = $_;
	    $_ =~ s/.*-//;
    	    @{$backupfiles{$_}}[0] = $dir;
    	    @{$backupfiles{$_}}[1] =  $backupref;	
	}
    };
    
    # Mounting backup shared folder
    my $error_message = bmount($mntdir,$smbhost,$smbshare,$VFSType,$smbv1);
    if ($error_message)
    {
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }
    
    # Test if backup subdirectory for our server
    $mntbkdir = $mntdir . "/$id";
    unless (-d $mntbkdir) 
    {
        $error_message  = $fm->localise('ERR_NO_HOST_DIR')."\n";
        $error_message .= bunmount($mntdir,$VFSType);
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    # Finding existing backups
    
    find { wanted => \&$setbackuplist, untaint => 1, untaint_pattern => qr|^([-+@\w\s./]+)$|}, $mntbkdir ;

    my %blabels = ();
    my @blabels;
    my $backups = 0;
    
    foreach $key (sort keys %backupfiles) {
	my $labkey = $mntbkdir . '/' . $backupfiles{$key}[0] . '/' . $backupfiles{$key}[1];
	$blabels{$labkey} = $backupfiles{$key}[1] . " (" . $backupfiles{$key}[0] . ")";
	$backups = push @blabels, $labkey;
	}

    $error_message = bunmount($mntdir,$VFSType);
    die($error_message) if $error_message;

    # Stops here if no backups 
    
    if ( $backups == 0 ) {
	esmith::cgi::genResult(
	    $q, $fm->localise('NO_BACKUPS_TO_RESTORE'));
	return;
    }

    print $q->p ($fm->localise('VERIFY_WORKSTN_BACKUP_DESC') . ' ' . "$smbhost/$smbshare/$id");
    print $q->p;
    
    print $q->start_multipart_form(
	    -method => 'POST',
	    -action => $q->url (-absolute => 1)
	);

    print $q->table ({border => 0, cellspacing => 0, cellpadding => 4},

	esmith::cgi::genWidgetRow(
		$q,
	        $fm->localise('SELECT_BACKUP_FILE'),
	        $q->popup_menu (
		    -name => 'backupset',
		    -values => [ @blabels ],
		    -labels => \%blabels
		)
	)
    );

    print $q->table ({border => 0, cellspacing => 0, cellpadding => 4},

        esmith::cgi::genWidgetRow(
	    $q,
	    $fm->localise('CHECK_TO_VERIFY_FULL_RESTORE'),
	    $q->checkbox (
		-name => 'verifyall',
		-checked=>0,
		-label=>''
	    )
	), 
	$q->Tr(
            esmith::cgi::genTextRow(
		    $q, 
    	        $fm->localise('CHECK_INTEGRITY_WARNING') 
    	    )
    	)
    ),"\n";
    
    print $q->table ({width => "100%", -class => "sme-noborders"},
	    esmith::cgi::genButtonRow(
		    $q,
		    $q->submit(
			    -name => 'action',
			    -value => $fm->localise('VERIFY')
			)
		)
	),"\n";
    
    print $q->hidden(
	    -name => 'state',
	    -override => 1,
	    -default => 'workstn-verify'
	);

    print $q->endform;

    esmith::cgi::genFooter ($q);
}

sub performWorkstnVerify
{
    my ($q) = @_;

    my $backupwkrec = $conf->get('backupwk');
    my $smbhost = $backupwkrec->prop('SmbHost');
    my $smbshare = $backupwkrec->prop('SmbShare');
    my $smbv1 = $backupwkrec->prop('SmbV1') || 'disabled';
    my $mntdir = $backupwkrec->prop('Mount') || '/mnt/smb';
    my $key;
    my $error_message;
    my $id = $backupwkrec->prop('Id') ||
	$conf->get('SystemName')->value . "." . $conf->get('DomainName')->value;
    my $err;
    my $VFSType = $backupwkrec->prop('VFSType') || 'cifs';
    my $verifyref = $q->param ('backupset');
    $mntdir = "/$smbshare" if ( $VFSType eq 'usb' );

    # Mounting backup shared folder
    $error_message = bmount($mntdir,$smbhost,$smbshare,$VFSType,$smbv1);
    if ($error_message)
    {
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    # Test if backup subdirectory for our server
    my $mntbkdir = $mntdir . "/$id";
    unless (-d $mntbkdir) 
    {
        $error_message  = $fm->localise('ERR_NO_HOST_DIR')."\n";
        $error_message .= bunmount($mntdir,$VFSType);
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    my $fullverify = $q->param('verifyall') || '';

    if ( $fullverify eq "on" ) 
    {
	# Test all backups needed to full restore
    
        my %backupsetfiles = ();
	my @restorefiles;
        my $set = $verifyref;
        $set =~ s/\/[^\/]*$//;
        my $backupsetlist = sub {
		if ( $_ =~ /\.dar/ )
	    {
		my $backupref = $File::Find::name;
        	$backupref =~ s/\.[0-9]+\.dar//;
        	$_ =~ s/\..*\.dar//;
		$_ =~ s/.*-//;
    		$backupsetfiles{$_} = $backupref;
	    }
	};

	# find list of available backups and verify
	# it contains all backups needed for full restore

	find { wanted => \&$backupsetlist, untaint => 1, untaint_pattern => qr|^([-+@\w\s./]+)$| }, $set ;
    
	my $key;
	my $num = 0;
	foreach $key (sort keys %backupsetfiles)
	{
	    push @restorefiles, $backupsetfiles{$key};
	    if ( $num == 0 )
	    {
		unless ( $backupsetfiles{$key} =~ /\/full-/ ) 
		{
		    esmith::cgi::genHeaderNonCacheable(
			$q,
			undef, $fm->localise('VERIFY_WORKSTN_BACKUP_FILE')
		    );
	    	    esmith::cgi::genResult(
			$q, $fm->localise('ERR_NO_FULL_BACKUP')
			);
		    return;
		}
	    }
	    else
	    {
		my $numf = sprintf("%03d", $num);
		unless ( $backupsetfiles{$key} =~ /\/inc-$numf-/ )
		{
	    	    esmith::cgi::genHeaderNonCacheable(
		 	$q,
			undef, $fm->localise('VERIFY_WORKSTN_BACKUP_FILE')
		    );

		    esmith::cgi::genResult(
			$q, $fm->localise('ERR_NO_INC_BACKUP') . " " . $numf
		    );
		    return;
		}

	    }
	    $num++;	
	    last if ( $backupsetfiles{$key} eq $verifyref );
	}
	
	# and test them 
	
        $| = 1;

	if (open(RD, "-|"))
	{
	    esmith::cgi::genHeaderNonCacheable ($q, undef, 
		$fm->localise('VERIFY_WORKSTN_BACKUP_FILE'));

	    print $q->p (
		$q->b ($fm->localise('TESTING_NEEDED_BACKUPS_FOR_RESTORE') )
		);
	    print '<UL>';
	    
	    while (<RD>)
	    {
		print "<li>$_</li>\n";
	    }

	    print '</UL>';
	    my $message;
	    if (!close RD)
	    {
		print $q->p ($q->b ( $fm->localise('RESTORE_VERIFY_FAILED') ));
	    }
	    else
	    {
		print $q->p ($q->b ( $fm->localise('VERIFY_COMPLETE') ));
	    }

	    esmith::cgi::genFooter ($q);
    }
    else
    {
        select(STDOUT);
        $| = 1;

        my $file;
        foreach $file (@restorefiles)
        {
            if ($file =~ /^(.*)$/)
            {
                $file = $1;
            }
            else
            {
                $error_message  = "Unsecure data :  $file\n";
                $error_message .= bunmount($mntdir,$VFSType);
                die ($error_message);
            }
            print $q->p($fm->localise('TESTED_BACKUP') . "  " . $file);
            system ("/usr/bin/dar", "-Q", "--test", "$file", "--noconf");
        }

        $error_message = bunmount($mntdir,$VFSType);
        die($error_message) if $error_message;

        exit(0);
    }
    return;

    }
    else 
    {
        # verify selected backup only
        # and display files saved in the backup

        my $backupkey = $verifyref;
        if ($backupkey =~ /^(.*)$/)
        {
            $backupkey = $1;
        }
        else
        {
            $error_message  = "Unsecure data :  $backupkey\n";
            $error_message .= bunmount($mntdir,$VFSType);
            die ($error_message);
        }

	if (open(RD, "-|"))
	{
	    esmith::cgi::genHeaderNonCacheable ($q,
		undef, $fm->localise('VERIFY_WORKSTN_BACKUP_FILE'));
	    print $q->p($fm->localise('FILES_IN_BACKUP'));
	    
	    print '<UL>';

	    my $complete = 0;
	    while (<RD>)
	    {
		$complete++ if /etc\/samba\/smbpasswd$/;
		print "<li>$_</li>\n";
	    }

	    print '</UL>';
	    my $status = close RD ?
			($complete ?
			    $fm->localise('VERIFY_COMPLETE') :
			    $fm->localise('BACKUP_FILE_INCOMPLETE'))
			: ($fm->localise('ERROR_READING_FILE').' : '.$backupkey);
	    print $q->p ($q->b ($status));

	    esmith::cgi::genFooter ($q);

        }
        else
        {
            select(STDOUT);
            $| = 1;

            system ("/usr/bin/dar", "-Q", "--list", "$backupkey", "--noconf") == 0
                or die ($fm->localise('ERR_EXTRACT')." : ".$!);

            $error_message = bunmount($mntdir,$VFSType);
            die($error_message) if $error_message;
            exit(0);
        }
    }

    return;
}

sub workstnRestore ()
{

    my $rec = $conf->get('backupwk');

    esmith::cgi::genHeaderNonCacheable(
	$q, undef, $fm->localise('RESTORE_CONF_FROM_WORKSTN'));

    unless ($rec)
    {
	esmith::cgi::genResult(
	    $q, $fm->localise('CONFIGURATION_TO_BE_DONE'));
	return;
    }

    my $mntdir = $rec->prop('Mount') || '/mnt/smb';
    my $mntbkdir;
    my %backupfiles = ();
    my $key;
    my $id = $rec->prop('Id') ||
	$conf->get('SystemName')->value . "." . $conf->get('DomainName')->value;
    my $VFSType = $rec->prop('VFSType') || 'cifs';
    my $smbhost = $rec->prop('SmbHost');
    my $smbshare = $rec->prop('SmbShare');
    my $smbv1 = $rec->prop('SmbV1') || 'disabled';
    my $err;
    $mntdir = "/$smbshare" if ( $VFSType eq 'usb' );
        
    my $setbackupflist = sub {
	if ( $_ =~ /\.dar/ )
	{
	    my $dir = $File::Find::dir;
	    my $backupref;
	    $dir =~ s/$mntbkdir\///;
            $_ =~ s/\..*\.dar//;
	    $backupref = $_;
	    $_ =~ s/.*-//;
    	    @{$backupfiles{$_}}[0] = $dir;
    	    @{$backupfiles{$_}}[1] =  $backupref;	
 	}
    };
    
    # Mounting backup shared folder
    my $error_message = bmount($mntdir,$smbhost,$smbshare,$VFSType,$smbv1);
    if ($error_message)
    {
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    # Test if backup subdirectory for our server
    $mntbkdir = $mntdir . "/$id";
    unless (-d $mntbkdir) 
    {
        $error_message  = $fm->localise('ERR_NO_HOST_DIR')."\n";
        $error_message .= bunmount($mntdir,$VFSType);
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    # Finding existing backups
    
    find { wanted => \&$setbackupflist, untaint => 1, untaint_pattern => qr|^([-+@\w\s./]+)$| }, $mntbkdir ;

    my %blabels = ();
    my @blabels;
    my $backups = 0;
    
    foreach $key (sort keys %backupfiles)
    {
	my $labkey = $mntbkdir . '/' . $backupfiles{$key}[0] . '/' . $backupfiles{$key}[1];
	$blabels{$labkey} = $backupfiles{$key}[1] . ' (' . $backupfiles{$key}[0] . ')';
	$backups = push @blabels, $labkey;
    }

    $error_message = bunmount($mntdir,$VFSType);
    die($error_message) if $error_message;

    if ( $backups == 0 )
    {
	esmith::cgi::genResult(
	    $q, $fm->localise('NO_BACKUPS_TO_RESTORE'));
	return;
    }

    print $q->p ($fm->localise('RESTORE_CONF_FROM_WORKSTN_DESC') . ' ' . "$smbhost/$smbshare/$id");
    print $q->p;
    
    print $q->start_multipart_form(
	    -method => 'POST',
	    -action => $q->url (-absolute => 1)
	);

    print $q->table ( {border => 0, cellspacing => 0, cellpadding => 4},
        esmith::cgi::genTextRow(
                $q,
                $q->b($fm->localise('DO_NOT_RESTORE_BIN_SBIN_LIB_LIB64_FROM_SME9')),
                ),

	    esmith::cgi::genWidgetRow(
		    $q,
		    $fm->localise('SELECT_BACKUP_FILE'),
		    $q->popup_menu (
			    -name => 'backuptorestore',
			    -values => [ @blabels ],
			    -labels => \%blabels
			)
		)
	);

    print $q->table ( {width => "100%", -class => "sme-noborders"},
	    esmith::cgi::genButtonRow(
		    $q,
		    $q->submit(
			    -name => 'action',
			    -value => $fm->localise('RESTORE_FROM_WORKSTN')
			)
		)
	);

    print $q->hidden(
    	-name => 'state',
	-override => 1,
	-default => 'workstn-restore'
    );

    print $q->endform;

    esmith::cgi::genFooter ($q);
}

sub performWorkstnRestore
{
    my ($q) = @_;
    my $restoreref = $q->param ('backuptorestore');
    my $set = $restoreref;
    $set =~ s/\/[^\/]*$//;
    my %backupsetfiles = ();
    my @restorefiles;
    
    my $backupsetlist = sub {
	if ( $_ =~ /\.dar/ )
	{
	    my $backupref = $File::Find::name;
            $backupref =~ s/\.[0-9]+\.dar//;
            $_ =~ s/\..*\.dar//;
	    $_ =~ s/.*-//;
    	    $backupsetfiles{$_} = $backupref;
	}
    };
    

    my $lock_file = "/var/lock/subsys/e-smith-restore";
    my $file_handle = &esmith::lockfile::LockFileOrReturn($lock_file);

    unless ($file_handle)
    {
	esmith::cgi::genHeaderNonCacheable(
		$q,
		undef, $fm->localise('RESTORE_CANNOT_PROCEED')
	    );

	print $q->p (
	    $q->b ($fm->localise('ANOTHER_RESTORE_IN_PROGRESS')
		)
	    );

	esmith::cgi::genFooter ($q);
	return;
    }

    my $backupwkrec = $conf->get('backupwk');
    my $id = $backupwkrec->prop('Id')
	|| $conf->get('SystemName')->value . "." . $conf->get('DomainName')->value;
    my $mntdir = $backupwkrec->prop('Mount') || '/mnt/smb';
    my $VFSType = $backupwkrec->prop('VFSType') || 'cifs';
    my $smbhost = $backupwkrec->prop('SmbHost');
    my $smbshare = $backupwkrec->prop('SmbShare');
    my $smbv1 = $backupwkrec->prop('SmbV1') || 'disabled';
    $mntdir = "/$smbshare" if ( $VFSType eq 'usb' );
    my $err;
    my $error_message;

    # Mounting backup shared folder
    $error_message = bmount($mntdir,$smbhost,$smbshare,$VFSType,$smbv1);
    if ($error_message)
    {
        esmith::cgi::genHeaderNonCacheable($q,undef, $fm->localise('RESTORE_CANNOT_PROCEED'));
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    # Test if backup subdirectory for our server
    my $mntbkdir = $mntdir . "/$id";
    unless (-d $mntbkdir) 
    {
        $error_message  = $fm->localise('ERR_NO_HOST_DIR')."\n";
        $error_message .= bunmount($mntdir,$VFSType);
        esmith::cgi::genHeaderNonCacheable($q,undef, $fm->localise('RESTORE_CANNOT_PROCEED'));
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

     # finding list of available backups
    # and verifying all needed backup files are available
    
    find { wanted => \&$backupsetlist, untaint => 1, untaint_pattern => qr|^([-+@\w\s./]+)$| }, $set ;
    
    my $key;
    my $num = 0;
    foreach $key (sort keys %backupsetfiles)
    {
	push @restorefiles, $backupsetfiles{$key};
	if ( $num == 0 )
	{
	    unless ( $backupsetfiles{$key} =~ /\/full-/ ) 
	    {
		esmith::cgi::genHeaderNonCacheable(
			$q,
			undef, $fm->localise('RESTORE_CANNOT_PROCEED')
		);
	        esmith::cgi::genResult(
		    $q, $fm->localise('ERR_NO_FULL_BACKUP')
		    );
		return;
	    }
	}
	else
	{
	    my $numf = sprintf("%03d", $num);
	    unless ( $backupsetfiles{$key} =~ /\/inc-$numf-/ )
	    {
	    	esmith::cgi::genHeaderNonCacheable(
		 	$q,
		    undef, $fm->localise('RESTORE_CANNOT_PROCEED')
		);

		esmith::cgi::genResult(
		    $q, $fm->localise('ERR_NO_INC_BACKUP') . $numf
		);
		return;
	    }

	}
	$num++;	
	last if ( $backupsetfiles{$key} eq $restoreref );
    }

    # backup is online, restoring now

    my $rec = $restore->get('restore');
    $rec->set_prop('state','running');
    $rec->set_prop('start', time);
    $conf->get('bootstrap-console')->set_prop('Run', 'yes');

    unless (system("/sbin/e-smith/signal-event", "pre-restore") == 0)
    {
	esmith::cgi::genHeaderNonCacheable(
	    $fm->{cgi},
	    undef, $fm->localise('OPERATION_STATUS_REPORT'));
	esmith::cgi::genResult(
	    $fm->{cgi}, $fm->localise('ERR_PRE_RESTORE'));
	return;
    }

    $| = 1;

    if (open(RD, "-|"))
    {

	#-----------------------------------------------------
	# restore system from uploaded workstation backup file
	#-----------------------------------------------------

	esmith::cgi::genHeaderNonCacheable ($q, undef, 
	    $fm->localise('RESTORE_IN_PROGRESS'));

	print $q->p (
	    $q->b ($fm->localise('RESTORE_IN_PROGRESS_DESC')
		)
	    );

	print $q->p($fm->localise('FILES_HAVE_BEEN_RESTORED'));

	print '<UL>';
	my $complete = 0;
	while (<RD>)
	{
	    $complete++ if /etc\/samba\/smbpasswd$/;
	    print "<li>$_</li>\n";
	}

	print '</UL>';
	my $message;
	if (!close RD)
	{
	    $message = $fm->localise('RESTORE_FAILED_MSG');
	}
	else
	{
	    #-----------------------------------------------------
	    # if restore completed, regenerate configuration files
	    #-----------------------------------------------------
	    if ($complete)
	    {

		$message = $fm->localise('RESTORE_COMPLETE');
		system("/usr/sbin/groupmod", "-g", "$www_gid", "www") == 0
		    or warn ($fm->localise('ERR_RESTORING_GID')."\n");
		system("/usr/sbin/usermod", "-g", "$www_gid", "www") == 0
		    or warn ($fm->localise('ERR_RESTORING_INITIAL_GRP')."\n");
		system("/sbin/e-smith/signal-event", "post-upgrade") == 0
		    or die ($fm->localise('ERROR_UPDATING_CONFIGURATION')."\n");
	    }
	    else
	    {
		$message = $fm->localise('RESTORE_FAILED');
	    }
	}

	$rec->set_prop('state', 'complete');
	$rec->set_prop('finish', time);

	&esmith::lockfile::UnlockFile($file_handle);

	print $q->p ($q->b ($message));

        print $q->startform(
	    -method => 'POST',
	    -action => $q->url (-absolute => 1)
	);
        print $q->p($q->b ($fm->localise('YOU_MUST_REBOOT'))),"\n";
        print $q->start_table ({width => "100%", -class => "sme-noborders"}),"\n";
        print esmith::cgi::genButtonRow(
                $q,
                $q->submit (-name => 'action', -value =>
                $fm->localise('REBOOT'))
        );
        # Put in a hidden widget to store the reboot value.
        print $q->hidden(
                        -name => 'function',
                        -value => 'reboot'
                        ),"\n";
        print $q->hidden (
	    -name => 'state',
	    -override => 1,
	    -default => 'perform'
	),"\n";
        print $q->end_table,"\n";
	print $q->endform;

	esmith::cgi::genFooter ($q);
    }
    else
    {
	select(STDOUT);
	$| = 1;
	
	my $file;
	foreach $file (@restorefiles)
	{
	    if ($file =~ /^(.*)$/)
	    {
		$file = $1;
	    }
	    else
	    {
            $error_message  = "Unsecure data :  $file\n";
            $error_message .= bunmount($mntdir,$VFSType);
            die ($error_message);
	    }
	    # because CentOS 7/SME 10  has now links in place of folder for bin lib lib64 and sbin, we need to exclude them to avoid to trash the server
	    # if restoring from a previous SME version. An alternative or complement to exclud directories would be to add this rule :  '-/{!T&~D}[Pp];Oo' : do not replace symlink by dir, otherwise replace. 
	    system ("/usr/bin/dar", "-Q", "-x", "$file", "-v", "-N", "-R", "/", "-wa", '-P', 'bin', '-P', 'lib', '-P', 'lib64', '-P', 'sbin', '-P', 'var/run', '-P', 'var/lock');
	    # However if one has added element to backup to this location; we need to resore them to their new location
	    # TODO condition to execute or not the following ....
	    # something like dar -l full-20210309124352 -g bin -g lib -g lib64 -g sbin  -/'{T}[Pp]'|grep -E '(sbin|bin|lib)'|wc -l ; if result > to 4
	    # or with a loop accross the 4 locations
	    system ("/usr/bin/dar", "-Q", "-x", "$file", "-v", "-N", "-R", "/usr/", "-wa", '-g', 'bin', '-g', 'lib', '-g', 'lib64', '-g', 'sbin', '-D');
	}

    $error_message = bunmount($mntdir,$VFSType);
    die($error_message) if $error_message;

	exit(0);
    }
    return;
}

sub workstnSelRestore()
{
    my $rec = $conf->get('backupwk');

    esmith::cgi::genHeaderNonCacheable ($q, undef,
	$fm->localise('WORKSTN_SELECTIVE_RESTORE'));

    unless ($rec)
    {
	esmith::cgi::genResult(
	    $q, $fm->localise('CONFIGURATION_TO_BE_DONE'));
	return;
    }

    my %backupfiles = ();
    my $mntdir = $rec->prop('Mount') || '/mnt/smb';
    my $mntbkdir;
    my $key;
    my $id = $rec->prop('Id') ||
	$conf->get('SystemName')->value . '.' . $conf->get('DomainName')->value;
    my %blabels = ();
    my @blabels;
    my $backups = 0;
    my $filterexp;
    my $VFSType = $rec->prop('VFSType') || 'cifs';
    my $smbhost = $rec->prop('SmbHost');
    my $smbshare = $rec->prop('SmbShare');
    my $smbv1 = $rec->prop('SmbV1') || 'disabled';
    $mntdir = "/$smbshare" if ( $VFSType eq 'usb' );
    my $err;
    my $error_message;

    my $setbackuplist = sub {
	if ( $_ =~ /\.dar/ )
	{
	    my $dir = $File::Find::dir;
	    my $backupref;
	    $dir =~ s/$mntbkdir\///;
            $_ =~ s/\..*\.dar//;
	    $backupref = $_;
	    $_ =~ s/.*-//;
    	    @{$backupfiles{$_}}[0] = $dir;
    	    @{$backupfiles{$_}}[1] =  $backupref;	
	}
    };

    # Mounting backup shared folder
    $error_message = bmount($mntdir,$smbhost,$smbshare,$VFSType,$smbv1);
    if ($error_message)
    {
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    # Test if backup subdirectory for our server
    $mntbkdir = $mntdir . "/$id";
    unless (-d $mntbkdir) 
    {
        $error_message  = $fm->localise('ERR_NO_HOST_DIR')."\n";
        $error_message .= bunmount($mntdir,$VFSType);
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    my $catalog = "$mntbkdir/dar-catalog";
    my $i = 0;
    my $j = 0;
    my @bknum;
    my @setd;
    my @bkname;

        
    # update backups list from current catalog    
    
    open(DAR_LIST, "/usr/bin/dar_manager -B $catalog -l |") ;

    $i = 0;
    while (<DAR_LIST>)
    {
	next unless m/set/;
	chomp;
	($bknum[$i], $setd[$i], $bkname[$i]) = split(' ', $_, 3);
	$i++;
    }
    close (DAR_LIST);

    # set drop down list of backups
    
    push @blabels, "0";
    $blabels{"0"} = $fm->localise('ALL_BACKUPS');
    $j = 0;
    while ($j < $i)
    {
	push @blabels, $bknum[$j];
	$blabels{$bknum[$j]} = $bkname[$j];
	$j++
    }  

    print $q->p ($fm->localise('WORKSTN_SEL_REST_DESC') . " $smbhost/$smbshare/$id");

    print $q->h2 ($fm->localise('BACKUP_CHOICE'));
    
    print $q->start_multipart_form(
	    -method => 'POST',
	    -action => $q->url (-absolute => 1)
	);


    print $q->table ({border => 0, cellspacing => 0, cellpadding => 4},

	esmith::cgi::genWidgetRow(
		$q,
	        $q->b($fm->localise('SELECT_BACKUP_FILE')),
	        $q->popup_menu (
		    -name => 'backupset',
		    -values => [ @blabels ],
		    -labels => \%blabels)
		),

	esmith::cgi::genNameValueRow(
		$q,
		$fm->localise('FILTER_EXPRESSION'),
		'filterexp',
		$filterexp
		)
	);


    print $q->table ({width => "100%", -class => "sme-noborders"},
	    esmith::cgi::genButtonRow(
		    $q,
		    $q->submit(
			    -name => 'action',
			    -value => $fm->localise('PERFORM')
			)
		)
	),"\n";

    print $q->hidden(
	    -name => 'state',
	    -override => 1,
	    -default => 'workstn-sel-restore'
	);

    print $q->endform;


    esmith::cgi::genFooter ($q);

    $error_message = bunmount($mntdir,$VFSType);
    die($error_message) if $error_message;
}

sub performWorkstnSelRestore
{
    my ($q) = @_;

    my $rgfilter;
    my $filterexp = $q->param ('filterexp');
    if ($filterexp =~ /^(.*)$/)
    {
	$filterexp = $1;
	$rgfilter = qr/$filterexp/;
    }
    else
    {
        $filterexp = "";
    }
    my $seldatebf;

    esmith::cgi::genHeaderNonCacheable ($q,
        undef, $fm->localise('WORKSTN_SELECTIVE_RESTORE'));
	
    my $backupwkrec = $conf->get('backupwk');
    my $smbhost = $backupwkrec->prop('SmbHost');
    my $smbshare = $backupwkrec->prop('SmbShare');
    my $smbv1 = $backupwkrec->prop('SmbV1') || 'disabled';
    my $mntdir = $backupwkrec->prop('Mount') || '/mnt/smb';
    my $key;
    my $id = $backupwkrec->prop('Id') ||
	$conf->get('SystemName')->value . "." . $conf->get('DomainName')->value;
    my @flabels;
    my %flabels = ();
    my $VFSType = $backupwkrec->prop('VFSType') || 'cifs';
    my $err;
    my $error_message;
    $mntdir = "/$smbshare" if ( $VFSType eq 'usb' );
    
    my $backupkey = $q->param ('backupset');
    if ($backupkey =~ /^(.*)$/)
    {
	$backupkey = $1;
    }
    else
    {
	die('Unsecure data : ' . $backupkey);
    }

    # Mounting backup shared folder
    $error_message = bmount($mntdir,$smbhost,$smbshare,$VFSType,$smbv1);
    if ($error_message)
    {
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    # Test if backup subdirectory for our server
    my $mntbkdir = $mntdir . "/$id";
    unless (-d $mntbkdir) 
    {
        $error_message  = $fm->localise('ERR_NO_HOST_DIR')."\n";
        $error_message .= bunmount($mntdir,$VFSType);
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    # Read wanted file list from selected backup

    if (open(RD, "-|"))
    {
	my $regex = qr/\[.*\] */;
	while (<RD>)
	{
        chomp;
	    $_ =~ s/$regex//;
	    next if m/^(sbin|bin|lib|lib64|var\/run|var\/lock)$/;
	    if ($filterexp) {next unless m/$rgfilter/};
	    push @flabels, $_;
	}

	my $status = close RD ?
			$fm->localise('READ_COMPLETE')
			: ($fm->localise('ERROR_READING_FILE').' : '.$backupkey);
	print $q->p ($status);

    }
    else
    {
        select(STDOUT);
        $| = 1;

        system ("/usr/bin/dar_manager", "-B", "$mntbkdir/dar-catalog", "-u", "$backupkey") == 0
            or die ($fm->localise('ERR_EXTRACT')." : ".$!);

        $error_message = bunmount($mntdir,$VFSType);
        die($error_message) if $error_message;
        exit(0);
    }

    print $q->start_multipart_form(
	    -method => 'POST',
	    -action => $q->url (-absolute => 1)
	);

    print $q->table ({border => 0, cellspacing => 0, cellpadding => 4},

        esmith::cgi::genTextRow(
                $q,
                $q->b($fm->localise('DO_NOT_RESTORE_BIN_SBIN_LIB_LIB64_FROM_SME9')),
	        ),

	esmith::cgi::genWidgetRow(
		$q,
	        $q->b($fm->localise('SELECT_FILES_TO_RESTORE')),
	        $q->scrolling_list (
		    -name => 'restorefiles',
		    -values => [ @flabels ],
		    -size => 15,
		    -multiple => 'true')
		),

	esmith::cgi::genNameValueRow(
		$q,
		$fm->localise('SELECT_DATE_BEFORE'),
		'seldatebefore',
		$seldatebf
		)
	);

    print $q->table ({width => "100%", -class => "sme-noborders"},
	    esmith::cgi::genButtonRow(
		    $q,
		    $q->submit(
			    -name => 'action',
			    -value => $fm->localise('PERFORM')
			)
		)
	),"\n";

    print $q->hidden(
	    -name => 'state',
	    -override => 1,
	    -default => 'workstn-sel-restore2'
	);

    print $q->hidden(
	    -name => 'when',
	    -override => 1,
	    -value => $seldatebf
	);

    print $q->endform;

    esmith::cgi::genFooter ($q);

}

sub performWorkstnSelRestore2
{
    my ($q) = @_;

    esmith::cgi::genHeaderNonCacheable ($q, undef, 
        $fm->localise('RESTORE_IN_PROGRESS'));

    my @restorelist;
    my $when = $q->param ('seldatebefore');
    if ($when =~ /^(.*)$/)
    {
	$when = $1;
    }
    else
    {
	die('Unsecure data : ' . $when);
    }
    my $tymd =
	qr/((19|20)\d\d\/(?=\d\d\/\d\d-))?((0?[1-9]|1[0-2])\/(?=\d\d-))?((31|[123]0|[012]?[1-9])-)?/;
    my $thms =
	qr/([01]?[0-9]|2[0-3]):([0-5][0-9])(:[0-5][0-9])?/;

    unless (($when =~ m/^$tymd$thms$/) || ($when eq ""))
    {
        esmith::cgi::genResult(
	    $q, "$when : " . $fm->localise('ERR_INVALID_SELDATE')
    	    );
    	return;
    }

    my @restorefiles = $q->param ('restorefiles');
    my $f;
    foreach $f (@restorefiles)
    {
        if ($f =~ /^(.*)$/)
	{
	    push @restorelist, "\"".$1."\"";
	}
    }
	
    my $backupwkrec = $conf->get('backupwk');
    my $id = $backupwkrec->prop('Id') ||
	$conf->get('SystemName')->value . "." . $conf->get('DomainName')->value;
    my $mntdir = $backupwkrec->prop('Mount') || '/mnt/smb';
    my $VFSType = $backupwkrec->prop('VFSType') || 'cifs';
    my $smbhost = $backupwkrec->prop('SmbHost');
    my $smbshare = $backupwkrec->prop('SmbShare');
    my $smbv1 = $backupwkrec->prop('SmbV1') || 'disabled';
    my $err;
    my $error_message;
    $mntdir = "/$smbshare" if ( $VFSType eq 'usb' );    

    # Mounting backup shared folder
    $error_message = bmount($mntdir,$smbhost,$smbshare,$VFSType,$smbv1);
    if ($error_message)
    {
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    # Test if backup subdirectory for our server
    my $mntbkdir = $mntdir . "/$id";
    unless (-d $mntbkdir) 
    {
        $error_message  = $fm->localise('ERR_NO_HOST_DIR')."\n";
        $error_message .= bunmount($mntdir,$VFSType);
        esmith::cgi::genResult($q, $error_message, $id);
        return;
    }

    # backup is online, restoring now

    $| = 1;
    my $restorerr;

    if (open(RD, "-|"))
    {

	#-----------------------------------------------------
	# restore system from uploaded workstation backup file
	#-----------------------------------------------------

	print $q->p($fm->localise('FILES_HAVE_BEEN_RESTORED'));

	print '<UL>';
	while (<RD>)
	{
	    print "<li>$_</li>\n";
	}

	print '</UL>';
	my $message;
	if (!close RD)
	{
	    $message = $fm->localise('RESTORE_FAILED_MSG');
	}
	else
	{
	    if ($restorerr)
	    {
		$message = $fm->localise('RESTORE_FAILED');
	    }
	    else
	    {
		$message = $fm->localise('RESTORE_COMPLETE');
	    }
	}

	print $q->p ($q->b ($message));

	esmith::cgi::genFooter ($q);
    }
    else
    {
	select(STDOUT);
	$| = 1;
	# we could add this filter here -/{!T&~D}[Pp];Oo to prevent symlinks to be transformed as folder, but it would lead to $?=4 or 5 or 1024.... thus marking as failed	
	if ($when) 
	{
	    $restorerr = system ("/usr/bin/dar_manager -B \"$mntbkdir/dar-catalog\" -Q -w $when -e '-v -N -R / -w -P sbin -P bin -P lib64 -P lib -P var/run -P var/lock' -r @restorelist");
	}
	else 
	{
	    $restorerr = system ("/usr/bin/dar_manager -B \"$mntbkdir/dar-catalog\" -Q -k -e '-v -N -R / -w -P sbin -P bin -P lib64 -P lib -P var/run -P var/lock' -r @restorelist");
	}

    $error_message = bunmount($mntdir,$VFSType);
    die($error_message) if $error_message;
    exit(0);
    }
    return;
}

sub performReboot ()
{
    esmith::cgi::genHeaderNonCacheable ($q, undef,
	$fm->localise('SERVER_REBOOT'));

    print $q->p (
	    $q->b ($fm->localise('SERVER_WILL_REBOOT'))
	);

    esmith::cgi::genFooter($fm);

    esmith::util::backgroundCommand(
	    5,
	    "/sbin/e-smith/signal-event",
	    "reboot"
	);
}

sub CalculateSizes ()
{
    #------------------------------------------------------------
    # figure out the size of the tar file.
    #------------------------------------------------------------

    my $tarsize = 0;

    # It takes way too much time to do a du on /home/e-smith. So we'll
    # estimate the current size.
    # We do this by checking the quota used by each user on the system.

    use Quota;
    use esmith::AccountsDB;
    my $accounts = esmith::AccountsDB->open;

    # Get a $dev value appropriate for use in Quota::query call.
    my $dev = Quota::getqcarg("/home/e-smith/files");

    foreach my $user ($accounts->users())
    {
	my $name = $user->key;
	my $uid = getpwnam($name);
	unless ($uid)
	{
	    warn ($fm->localise('NO_UID_FOR_NAME').$name."\n");
	    # We shouldn't ever get here. If we do, we can't get
	    # the quota value for this user, so we just skip to
	    # the next one.
	    next;
	}

	# Get current quota settings.
	my ($blocks) = Quota::query($dev, $uid, 0);
	$tarsize += $blocks;
    }

    # We add to this the size of root owned firectories, estimated using du.
    # If this takes too long, then the admin only has his or
    # herself to blame!

    # Remove /home/e-smith from backup list, and make paths absolute
    my @list = map { "/$_" } grep { !/home\/e-smith/ } @directories;
    open(DU, "-|")
	or exec '/usr/bin/du', '-s', @list;

    while (<DU>)
    {
	my ($du) = split(/\s+/);
	$tarsize += $du;
    }
    close DU;

    $tarsize = &showSize($tarsize);

    #------------------------------------------------------------
    # figure out the size of the dump files
    #------------------------------------------------------------

    my $dumpsize = 0;

    open(DF, "-|")
	or exec '/bin/df', '-P', '-t', 'ext3', '-t', 'ext4', '-t', 'xfs';

    while (<DF>)
    {
	next unless (/^\//);

	(undef, undef, my $s, undef) = split(/\s+/, $_);

	$dumpsize += $s;
    }

    # increase size by 10% to cope with dump overhead.

    $dumpsize *= 1.1;

    close DF;

    $dumpsize = &showSize($dumpsize);

    #------------------------------------------------------------
    # how much free space is in /tmp
    #------------------------------------------------------------

    my $tmpfree = 0;
    my $halffree = 0;

    open(DF, "-|")
	or exec '/bin/df', '-P', '-t', 'ext3', '-t', 'ext4', '-t', 'xfs', '/tmp';

    while (<DF>)
    {
	next unless (/^\//);

	(undef, undef, undef, my $s) = split(/\s+/, $_);

	$tmpfree += $s;
    }

    close DF;

    $halffree = $tmpfree / 2;

    $tmpfree = &showSize($tmpfree);
    $halffree = &showSize($halffree);

    return ($tarsize, $dumpsize, $tmpfree, $halffree);
}

sub showSize
{
    # convert size to Mb or Gb or Tb :) Remember, df reports in kb.

    my $size = shift;

    my $Mb = 1024;
    my $Gb = $Mb * $Mb;
    my $Tb = $Mb * $Mb * $Mb;

    if ($size >= $Tb)
    {
	$size /= $Tb;
	$size = int($size) . "Tb";
    }
    elsif ($size >= $Gb)
    {
	$size /= $Gb;
	$size = int($size) . "Gb";
    }
    elsif ($size >= $Mb)
    {
	$size /= $Mb;
	$size = int($size) . "Mb";
    }
    else
    {
	$size .= "kb";
    }

    return $size;
}

sub dmount
{
    # mount dar unit according to dar-workstation configuration
    # return nothing if mount successfull

    my ($host,$share,$mountdir,$login,$password,$VFSType,$smbv1) = @_;
    
    if ($VFSType eq 'cifs')
    {
	my $opt= ($smbv1 eq "enabled")? ",vers=1.0": "";
	return ( qx(/bin/mount -t cifs "//$host/$share" $mountdir -o credentials=/etc/dar/CIFScredentials,nounix$opt 2>&1) );
    }
    elsif ($VFSType eq 'nfs')
    {
	return ( qx(/bin/mount -t nfs -o nolock "$host:/$share" $mountdir 2>&1) );
    }
    elsif ($VFSType eq 'usb')
    {
        my $device = "";
        my $vollbl = "";

        my $devices = esmith::BlockDevices->new ('allowmount' => 'disabled');
        my ($valid, $invalid) = $devices->checkBackupDrives(0);

        if ( ${$valid}[0] ) {
            foreach ( @{$valid} ) {
                $vollbl = $devices->label($_);
                if ( $share eq "media/$vollbl" ) {
                    $device = "/dev/$_";
                }
            }
        }
        $devices->destroy;
        return ( qx (mount $device /$share 2>&1) );
    }
    else
    {
	return ("Error while mounting $host/$share : $VFSType not supported.\n");
    }
}   

sub checkMount
{
    # check if $mountdir is mounted
    my $mountdir = shift;
    $|=1; # Auto-flush

    my @res = qx( findmnt $mountdir );
    return ( !@res );
}

sub bmount
{
    my ($mntdir,$host,$share,$VFSType,$smbv1) = @_;
    # verify backup directory not already mounted

    if (!checkMount ($mntdir))
    {
        return if ($VFSType eq 'mnt');
        return ($fm->localise('ERR_ALREADY_MOUNTED'));
    }
    else
    {
        if ($VFSType eq 'mnt')
        {
            return ($fm->localise('ERR_NOT_MOUNTED'));
        }
    }

    # create the directory mount point if it does not exist
    my $err = createTree ($mntdir);
    return ($fm->localise('ERR_MOUNTING_SMBSHARE') . "<//$host/$share>\n" . $err) if $err;
    
    # mount the backup directory
    $err = dmount($host,$share,$mntdir,'','',$VFSType,$smbv1);
    return ($fm->localise('ERR_MOUNTING_SMBSHARE') . "<//$host/$share>\n" . $err) if $err;

    # verify $mntdir is mounted
    if (checkMount ($mntdir))
    {
        # The mount should have suceeded, but sometimes it needs more time, 
        # so sleep and then check again.
        sleep 5;
        if (checkMount ($mntdir))
        {
            return ($fm->localise('ERR_NOT_MOUNTED'));
        }
    }
    return;
}

sub bunmount
{
    my ($mount,$type) = @_;
    return if ($type eq 'mnt'); # Don't unmount for type 'mnt'

    if (!checkMount ($mount))
    {
        system('/bin/umount', '-f', $mount) == 0
            or return ($fm->localise('ERR_WHILE_UNMOUNTING'));
    }
    return;
}

sub findmnt
{
    my @mntin  = qx( findmnt -n -l -o TARGET );
    my @mntout;

    foreach my $mount (@mntin)
    {
        next if ($mount =~ m/^\/proc|^\/dev|^\/sys|^\/boot/s);
        chomp $mount;
        next if ($mount eq '/');
        push @mntout, $mount;
    }

    return @mntout;
}

sub createTree
{
    my $tree = shift;
    if (! -d "$tree")
    {
        eval {make_path("$tree")};
        return ("Error while creating $tree : $@. Maybe insufficient rights directory.\n") if $@;
    }
    return;
}

#Used to test if the remote share is mountable when you save settings in database
sub vmount
{
    # mount dar unit according to dar-workstation configuration in order to test the remote host
    # return nothing if mount successfull
    my ($host,$share,$mountdir,$VFSType,$smbv1) = @_;
    if ($VFSType eq 'cifs')
    {
    my $opt= ($smbv1 eq "enabled")? ",vers=1.0": "";
    return ( qx(/bin/mount -t cifs "//$host/$share" $mountdir -o credentials=/etc/dar/CIFScredentials,nounix$opt 2>&1) );
    }
    elsif ($VFSType eq 'nfs')
    {
    return ( qx(/bin/mount -t nfs -o nolock,timeo=30,retrans=1,retry=0 "$host:/$share" $mountdir 2>&1) );
    }

}

__DATA__
<form>
</form>