perl-install/share/advertising/10.png

#!/usr/bin/perl
#
#  Copyright (C) 2001 by Sebastien DUPONT <sdupont@mandrakesoft.com>
#  Redistribution of this file is permitted under the terms of the GNU
#  Public License (GPL)
#
#  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, 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.
#
#________________________________________________________________
#
#  Description:
#
#   Drakbacup is use to backup your system.
#   During the configuration you can select 
# 	- System files, 
# 	- Users files, 
# 	- Other files.
# 	or All your system ...  and Other (like windows Partitions)
#
#   Drakbacup allow you to backup your system on:
# 	- Harddrive.
# 	- NFS.
# 	- CDROM (CDRW), DVDROM (with autoboot, rescue and autoinstall.).
# 	- FTP.
# 	- Rsync.
# 	- Webdav.
# 	- Tape.
#
#   Drakbacup allow you to Restore your system on
#   choosen directory.
#
#   Per default all backup will be stored on your
#   /var/drakbackup directory
#
#   configuration file:
# 	/etc/drakconf/drakbackup/drakbakup.conf
#
#________________________________________________________________
#
#  backup files formats:
#	
#	no incremental backup:
#			backup_sys_date_hour.tar.*
#			backup_user_toto_date_hour.tar.*
#			backup_other_date_hour.tar.*
#
#	first incremental backup: (if backup_base* does not exist )
#
#			backup_base_sys_date_hour.tar.*
#			backup_base_user_toto_date_hour.tar.*
#			backup_base_other_date_hour.tar.*
#			
#	other incremental backup: (if backup_base* already exist )
#
#			backup_incr_sys_date_hour.tar.*
#			backup_incr_user_toto_date_hour.tar.*
#			backup_incr_other_date_hour.tar.*
#
#________________________________________________________________
# 
# REQUIRE:      cron if daemon
#               cdrecord & mkisofs
#		ftp || perl Net::FTP
#		ssh-askpass
#
# PBS persistants:
#		selection des sources a inclure dans le backup cd. 
#		et dans le restore_step_user
#
#
# WARNING:      ne pas ecraser les fichiers /etc/passwd fstab 
#               after a other install
#
#
# TODO:
#		during restore step catch the most recent date
#		and put in list all backup between the fisrt date 
#		and the select date.
#		1bis - refaire en clist.
#		3 - add port for ftp backup.
#		4 - change NET::FTP to ftp cmds.  
#		5 - add icons (win & lin) on adv_what_all.
#	        6 - calcul disk space.
#		   use quota.
#               7 - ssh & rsync -> expect or .identity.pub/authorized_keys 
#		8 - write on cd
#		9 - cd writer detection  -> cdrw: /sys/dev/cdrom/info  /scsi/host0/bus0/target4/lun0 
#		10- total backup.( all partitions wanted, windows partitions for example!)
#		    dump use for total backup.
#		11- send mail with results.
#		12- custom deamon
#		13- placer README dans $save_path -> prevenir des danger de supprimer la premier version
#		    explain configuration file variables (mainly for non X users)
#		13bis -  option mode update tar u ....
#		14- webdav
#	        15- backend : --resore_all, --restore_sys, --restore_users
#			  --build_cd_autoinst 	
#			  --backup_now --backup_default_now
#		16- tape device support
#		17- cpio use !!
#		18- boot floppy disk (with dialog)
#		19- build autoboot with backup and install cd 
#		20- use .backupignore like on CVS
#
#		               
# DONE TODAY:
#________________________________________________________________


use Gtk;
use lib qw(/usr/lib/libDrakX );
use interactive;
use standalone;
use my_gtk qw(:helpers :wrappers);
use common;
use strict;
use Time::localtime;

my $in = 'interactive'->vnew('', 'default');
$::isEmbedded = ($::XID, $::CCPID) = "@ARGV" =~ /--embedded (\w+) (\w+)/;


if ("@ARGV" =~ /--help|-h/) {
    print q(Backup and monitoring application

--list           : list of files or directories to backup.
--default        : save default directories.
--build_cd       : build restore iso with the currents backups files
                       & rescue options.
--build_floppy   : build restore floppy.
--save_dir       : by default the backup files are saved in 
                       in /var/backup directory so write other directory
	               to change to change it.
--conf_file      : to read other configuration file. 
);
    exit(0);
}

# Backend Options.
my $default = 0;
my $build_cd = 0;
my $build_floppy = 0;
my $mode = 0;
my $conf_file = 0;
my @list_arg = ();
my $central_widget;
my $previous_widget;
my $current_widget;
my $interactive;
my $up_box;
my $advanced_box;
my $box;
my $box2;
my $backup_choice = 0;
my $cfg_file_exist = 0;
my @user_and_path_list;
my @all_user_list;
my $list_other;
my $label_cfg_file;
my $DEBUG = 0;
my $restore_sys = 1; 
my $restore_user = 1; 
my $restore_other = 1; 
my @user_backuped = ();
my $sys_backuped = 0;
my $other_backuped = 0;
my @user_list_to_restore= ();
my $retore_box2;
my $cd_devive_entry;
my $custom_help;
my $button_box;
my $button_box_tmp;
my $next_widget;
my $system_state;
my $restore_state;
my $save_path_entry;
my $restore_find_path_entry;
my $pbar;
my $pbar1;
my $pbar2;
my $pbar3;
my $the_time;
my @user_list_to_restore2 = ();
my @data_backuped = ();
my $box_tail; 
my $label_tail;
my @user_list_to_build_on_cd = (); 
my $restore_path = "/";
my $restore_other_path = 0;
my $restore_other_src;
my $path_to_find_restore;
my $other_media_hd;
my $backup_bef_restore = 0;
my $table;

# config. FILES -> Default PATH  & Global variables.
my @sys_files = ("/etc");
my @user_list;
my @list_other = () ;
my $cfg_file = "/etc/drakxtools/drakbackup/drakbackup.conf";
my $save_path = "/var/drakbackup";
my $restore_path = "/tmp";
my $comp_mode = 0;
my $backup_sys = 1;
my $backup_user = 1;
my $backup_daemon = 1;
my $backup_sys_versions = 0;
my $backup_user_versions = 0;
my $backup_other_versions = 0;
my $what_no_browser = 1;
my $cdrw = 0;
my $net_proto= '';
my $host_path = '';
my $login_user = '';
my $net_daemon = 0;
my $hd_daemon = 0;
my $cd_daemon = 0;
my $hd_quota = 0;
my $where_net_ftp = 0;
my $where_net_ssh = 0;
my $where_net = 0;
my $where_hd = 1;
my $where_cd = 0;
my $where_tape = 0;
my $cd_time = 650;
my $when_space;
my $cd_with_install_boot = 0;
my $cd_devive = '';
my $host_name = '';
my $backupignore = 0; 
my $auth_choice = 0;
my $remember_pass = 0;
my $passwd_user= '';
my $save_device_tape = ();
my $cdrw_erase = 0;
my $no_critical_sys = 1;


foreach (@ARGV) {
    /--default/ and $default = 1, $mode=-1;
    /--build_cd/ and $build_cd = 1, $mode=-1;
    /--build_floppy/ and $build_floppy = 1, $mode=-1;
    /--conf_file/ and $mode = 0, next;
    /--list/ and $mode = 1, next;
    /--debug/ and $DEBUG = 1, next;
    $mode == 1 and push @list_arg, $_;
}

$build_floppy || $build_cd || $default || @list_arg || $conf_file ? backend_mod() : interactive_mode();

sub read_passwd {
    my @tmp1;
    my @tmp2;
    @user_and_path_list = map { (split(':', $_))[0] . ":" . (split(':', $_))[5] } grep {( split(':', $_))[2] > 500} split ('\n', cat_('/etc/passwd'));  
    $DEBUG and print "user_and_path_list: ".$_."\n" foreach (@user_and_path_list);
    @user_list = ();
    @all_user_list = ();
    push @user_and_path_list, 'root:/root';
    push @user_list, (split(':', $_))[0] foreach (@user_and_path_list);
    push @all_user_list, (split(':', $_))[0] foreach (@user_and_path_list);
    @tmp1 = sort @user_list;
    @user_list = @tmp1;
    @tmp2 = sort @all_user_list;
    @all_user_list = @tmp2;
}


sub the_time {
    $the_time = "_";
    $the_time .= localtime->year() + 1900;
    $the_time .= localtime->mon() +1;
    $the_time .= localtime->mday();
    $the_time .= "_";
    if (localtime->hour() <= 10 ) { $the_time .= "0"; }
    $the_time .= localtime->hour();
    if (localtime->min() <= 10 ) { $the_time .= "0"; }
    $the_time .= localtime->min();

    
 }

sub save_conf_file {
    my @cfg_list = ( "SYS_FILES=@sys_files\n",
		     "HOME_FILES=@user_list\n", 
		     "OTHER_FILES=@list_other\n",
		     "PATH_TO_SAVE=$save_path\n",
		     "HOST_PATH=$host_path\n",
		     "NET_PROTO=$net_proto\n",
		     "CD_TIME=$cd_time\n",
		     "DAEMON_TIME_SPACE=$when_space\n",
		     "CDRW_DEVICE=$cd_devive\n",
		     "LOGIN=$login_user\n",
		     "TAPE_DEVICE=$save_device_tape\n",
		     "HOST_NAME=$host_name\n"
		     );
    $no_critical_sys and push @cfg_list, "NO_CRITICAL_SYS\n" ; 
    $no_critical_sys or push @cfg_list, "CRITICAL_SYS\n" ; 
    $backup_sys_versions and push @cfg_list, "SYS_INCREMENTAL_BACKUPS\n" ; 
    $backup_user_versions and push @cfg_list, "USER_INCREMENTAL_BACKUPS\n" ; 
    $backup_other_versions  and push @cfg_list, "OTHER_INCREMENTAL_BACKUPS\n" ; 
    $cdrw_erase and push @cfg_list, "CDRW_ERASE\n" ; 
    $where_net_ftp and push @cfg_list, "USE_NET_FTP\n" ; 
    $where_net_ssh and push @cfg_list, "USE_NET_SSH\n" ; 
    $remember_pass and push @cfg_list, "LOGIN=$login_user\n" ; 
    $remember_pass and push @cfg_list, "PASSWD=$passwd_user\n" ;
    $remember_pass and push @cfg_list, "REMEMBER_PASS\n" ;
    $auth_choice or push @cfg_list, "AUTH_CHOICE=0\n" ;
    if ($auth_choice == 1) { push @cfg_list, "AUTH_CHOICE=1\n" ;}
    if ($auth_choice == 2) { push @cfg_list, "AUTH_CHOICE=2\n" ;}
    $cd_with_install_boot and push @cfg_list, "CD_WITH_INSTALL_BOOT\n" ;
    $net_daemon and push @cfg_list, "NET_DAEMON\n" ;
    $hd_daemon and push @cfg_list, "HD_DAEMON\n" ;
    $cd_daemon and push @cfg_list, "CD_DAEMON\n" ;
    $hd_quota and  push @cfg_list, "HD_QUOTA\n" ;
    $where_hd and  push @cfg_list, "USE_HD\n" ;
    $where_cd and  push @cfg_list, "USE_CD\n" ;
    $where_net and  push @cfg_list, "USE_NET\n" ;
    $cdrw and push @cfg_list, "CDRW\n"; 
    $what_no_browser or push @cfg_list, "BROWSER_CACHE\n" ;
    $backup_sys or push @cfg_list,  "NO_SYS_FILES\n";
    if ($comp_mode) {push @cfg_list, "OPTION_COMP=TAR.BZ2\n"} 
    else { push @cfg_list, "OPTION_COMP=TAR.GZ\n"   }
    output_p($cfg_file, @cfg_list);
    save_cron_files();
}

sub read_cron_files {
    if (-f '/etc/cron.hourly/drakbackup') { $when_space = 'hourly'; }
    elsif (-f '/etc/cron.daily/drakbackup') { $when_space = 'daily'; }
    elsif (-f '/etc/cron.weekly/drakbackup') { $when_space = 'weekly';}
    elsif (-f '/etc/cron.monthly/drakbackup') { $when_space = 'monthly';}
    else {$backup_daemon = 0; }
}

sub save_cron_files {
    my @cron_file = ("#!/bin/sh\n", "\n", "/seb/cvs/gi/perl-install/standalone --default" );

    if ($backup_daemon) {
	foreach ('hourly', 'daily', 'weekly', 'monthly'){
	    -f "/etc/cron.$_/drakbackup" and rm_rf("/etc/cron.$_/drakbackup");
	}
	if ( $when_space eq _("hourly"))     { output_p('/etc/cron.hourly/drakbackup',  @cron_file )}
	elsif ( $when_space eq _("daily"))   { output_p('/etc/cron.daily/drakbackup',   @cron_file )}
	elsif ( $when_space eq _("weekly"))  { output_p('/etc/cron.weekly/drakbackup',  @cron_file )}
	elsif ( $when_space eq _("monthly")) { output_p('/etc/cron.monthly/drakbackup', @cron_file )}
    } else {
	foreach ('hourly', 'daily', 'weekly', 'monthly'){
	    -f "/etc/cron.$_/drakbackup" and rm_rf("/etc/cron.$_/drakbackup");
	}
    }
}

sub read_conf_file {
    read_passwd();
    if (-e $cfg_file) {
        open ( CONF_FILE, "<"."$cfg_file") || die;
        while (<CONF_FILE>) {
	    next unless /\S/;
	    next if /^#/;
	    chomp;
	    if (/^SYS_FILES/)      { s/^SYS_FILES=//gi;    @sys_files = split(' ', $_ );	}
	    if (/^HOME_FILES/)     { s/^HOME_FILES=//gi;   @user_list = split(' ', $_ );	}
	    if (/^OTHER_FILES/)    { s/^OTHER_FILES=//gi;  @list_other = split(' ', $_ );	}
	    if (/^PATH_TO_SAVE/)   { s/^PATH_TO_SAVE=//gi; $save_path = $_;	}
	    if (/^NO_SYS_FILES/)   { $backup_sys = 0;}
	    if (/^NO_USER_FILES/)  { $backup_user = 0;}
	    if (/^OPTION_COMP/)    { s/^OPTION_COMP=//gi; /TAR.GZ/ and  $comp_mode = 0; /TAR.BZ2/ and $comp_mode = 1; }
	    if (/^BROWSER_CACHE/)  { $what_no_browser = 0; }
	    if (/^CDRW/)           { $cdrw = 1; }
	    if (/^NET_PROTO/)      { s/^NET_PROTO=//gi; $net_proto = $_; }
	    if (/^HOST_PATH/)      { s/^HOST_PATH=//gi; $host_path = $_; } 
	    if (/^NET_DAEMON/)	   { $net_daemon = 1; }
	    if (/^HD_DAEMON/)	   { $hd_daemon = 1; }
	    if (/^CD_DAEMON/)	   { $cd_daemon = 1; }
	    if (/^HD_QUOTA/)       { $hd_quota = 1;  }
	    if (/^USE_HD/)         { $where_hd = 1;  }
	    if (/^USE_CD/)         { $where_cd = 1;  }
	    if (/^USE_NET/)        { $where_net = 1; }
	    if (/^USE_TAPE/)       { $where_tape = 1; }
	    if (/^CD_TIME/)        { s/^CD_TIME=//gi; $cd_time = $_; }
	    if (/^DAEMON_TIME_SPACE/) { s/^DAEMON_TIME_SPACE=//gi; $when_space = $_; }
	    if (/^CD_WITH_INSTALL_BOOT/) { $cd_with_install_boot = 1; }
	    if (/^CDRW_DEVICE/)    { s/^CDRW_DEVICE=//gi; $cd_devive = $_;}
	    if (/^HOST_NAME/)      { s/^HOST_NAME=//gi; $host_name = $_;} 
	    if (/^AUTH_CHOICE/)    { s/^AUTH_CHOICE=//gi; $auth_choice = $_; }
	    if (/^REMEMBER_PASS/)  { $remember_pass = 1; }
	    if (/^LOGIN/)          { s/^LOGIN=//gi;  $login_user  = $_; $remember_pass = 1; }
	    if (/^PASSWD/)         { s/^PASSWD=//gi; $passwd_user = $_; $remember_pass = 1; }
	    if (/^USE_NET_FTP/)    { $where_net_ftp = 1;  }
	    if (/^USE_NET_SSH/)    { $where_net_ssh = 1;  }
	    if (/^TAPE_DEVICE/)    { s/TAPE_DEVICE=//gi; $save_device_tape = $_;}
	    if (/^CDRW_ERASE/)     { $cdrw_erase = 1;}
	    if (/^SYS_INCREMENTAL_BACKUPS/)   { $backup_sys_versions = 1;}
	    if (/^USER_INCREMENTAL_BACKUPS/)  { $backup_user_versions = 1;}
	    if (/^OTHER_INCREMENTAL_BACKUPS/) { $backup_other_versions = 1;}
	    if (/^NO_CRITICAL_SYS/)  { $no_critical_sys = 1;}
	    if (/^CRITICAL_SYS/)  { $no_critical_sys = 0;}
	}
	read_cron_files();
	$cfg_file_exist = 1;
    } 
    else { $cfg_file_exist = 0; }
    close CONF_FILE;    
}

sub return_path {
    my $name = $_; 
    foreach (@user_and_path_list) {
	if (grep /^$name\:/, $_) {
	    s/^$name\://gi;
	    return $_;
	}
    }
}

sub ftp_client {
    use Net::FTP; 
    my $ftp = Net::FTP->new("$host_name"); 
    $ftp->login("$login_user","$passwd_user"); 
    $ftp->cwd("$host_path"); 
#   $ftp->get("/ce/repertoire/ce.fichier"); 
    $ftp->send("$save_path/*"); 
    $ftp->quit; 
}

sub return_file_date {
    my($more_recent) = @_;
    my $file_date;
    $_ = $more_recent;
    s/backup\_incr\_sys\_//gi;
    s/backup\_base\_sys\_//gi;
    s/backup\_incr\_user\_//gi;
    s/backup\_base\_user\_//gi;
    s/.tar.\w+$//gi;
    s/\_/ /gi;
    my $date = substr($_, 0, 8);
    my $hour = substr($_, 9,  2);
    my $min =  substr($_, 11, 2);
    $file_date = $date . ' ' . $hour . ':' . $min;
    return $file_date;
}


sub build_backup_files {
    my $path_name;
    my $tar_cmd;
    my $more_recent;
    my $tar_cmd_sys;
    my $tar_cmd_user;
    my $tar_cmd_other;
    my $tar_ext;
    my $vartemp;
    my $base_sys_exist = 0;
    my $base_user_exist = 0;
    my $base_other_exist = 0;
    my @list_temp = ();
    my @list_other_;
    my @dir_content = ();
    my $file_date;

    the_time();    
    -d  $save_path or mkdir_p($save_path);
    if ($comp_mode) { $tar_cmd = "tar cv --use-compress-program /usr/bin/bzip2 "; $tar_ext = "tar.bz2" }
    else { $tar_cmd = "tar cvzp "; $tar_ext = "tar.gz"}
    $tar_cmd_sys = $tar_cmd;
    $tar_cmd_user = $tar_cmd;
    $tar_cmd_other = $tar_cmd;
    $no_critical_sys and $tar_cmd_sys .= "--exclude passwd --exclude fstab --exclude group";
    $what_no_browser and $tar_cmd_user .= "--exclude NewCache --exclude Cache --exclude cache";

    @dir_content = all($save_path);
    grep (/backup_base_sys/, @dir_content) and $base_sys_exist = 1;
    grep (/backup_base_other/, @dir_content) and $base_other_exist = 1;

# fixme use incremental backup   
#tar -cvf tarfilename --after-date="sept 1, 2000" /home
# tar -cf archive.tar --newer="`date -r file`" /home
# algo: liste des fichiers du meme nom, on prend le dernier puis on applique le tar ci-dessus.
# faire fonctions qui retourne le plus recent element.

    if ($where_hd) {
	$interactive and progress($pbar, 0.5, _("Backup system files..."));
	if ($backup_sys) { 
	    if ($backup_sys_versions) {
 		if (grep(/backup_incr_sys/, @dir_content)) { 
		    my @more_recent = grep /backup_incr_sys/, @dir_content; 
		    @list_temp = sort  @more_recent;
 		    $more_recent = pop @list_temp;
		    $file_date = return_file_date($more_recent);
 		}
  		else { 
		    my @more_recent = grep /backup_base_sys/, @dir_content; 
		    $more_recent = @more_recent[0];
		    $file_date = return_file_date($more_recent);
 		}
		if (!$base_sys_exist) { 
		    system("$tar_cmd_sys -f $save_path/backup_base_sys$the_time.$tar_ext @sys_files"); }
		else { 
		    system("$tar_cmd_sys -f $save_path/backup_incr_sys$the_time.$tar_ext --after-date='$file_date'  @sys_files"); }
	    } else {
		system("cd $save_path && rm -f backup_sys* backup_base_sys* backup_incr_sys*");
		system("$tar_cmd_sys -f $save_path/backup_sys$the_time.$tar_ext @sys_files");
	    }
	}

	$interactive and progress($pbar, 0.5, _("Backup system files..."));
	$interactive and progress($pbar3, 0.3, _("Hard Disk Backup files..."));

	if (@list_other) {
#	    if ($backup_other_versions) {
#		$base_other_exist or  system("$tar_cmd_other -f $save_path/backup_base_other$the_time.$tar_ext @list_other");
#		$base_other_exist and system("$tar_cmd_other -f $save_path/backup_incr_other$the_time.$tar_ext @list_other");
#	    } else {
#	    system("cd $save_path && rm -f backup_other* backup_base_other* backup_incr_other*");
#	    system("$tar_cmd_other -f $save_path/backup_other$the_time.$tar_ext @list_other");
#	    }
	    system("cd $save_path && rm -f backup_other* ");
	    system("$tar_cmd_other -f $save_path/backup_other$the_time.$tar_ext @list_other");
	    
	    foreach (@list_other) { push @list_other_, $_ . "\n"; }
	    output_p( $save_path . '/list_other', @list_other_);    
	}
	
	$interactive and progress($pbar1, 1, _("Backup User files..."));
	$interactive and progress($pbar3, 0.3, _("Hard Disk Backup Progress..."));
	
	if ($backup_user) {
	    foreach (@user_list) {
		my $user = $_;
		if (grep (/backup_base_user_$user/, @dir_content)) {  $base_user_exist = 1; }
		else { $base_user_exist = 0; }
		$path_name = return_path($user);
		if ($backup_user_versions) {
		    if (grep(/backup_incr_user/, @dir_content)) { 
			my @more_recent = grep /backup_incr_user/, @dir_content; 
			@list_temp = sort  @more_recent;
			$more_recent = pop @list_temp;
			$file_date = return_file_date($more_recent);
		    }
		    else { 
			my @more_recent = grep /backup_base_user/, @dir_content; 
			$more_recent = @more_recent[0];
			$file_date = return_file_date($more_recent);
		    }
		    if (!$base_user_exist) { 
			system("$tar_cmd_user -f $save_path/backup_base_user_$user$the_time.$tar_ext $path_name");}
		    else { 
			system("$tar_cmd_user -f $save_path/backup_incr_user_$user$the_time.$tar_ext --after-date='$file_date' $path_name");}
		} else {
		    system("cd $save_path && rm -f backup_user_$_* backup_base_user_$_* backup_incr_user_$_*");
		    system("$tar_cmd_user -f $save_path/backup_user_$_$the_time.$tar_ext $path_name");
		}
	    }
	}
	$interactive and progress($pbar2, 1, _("Backup Other files..."));
	$interactive and progress($pbar3, 0.4, _("Hard Disk Backup files..."));
    }

    if ($where_net_ssh) {
#  $res = Net::SSLeay::write($ssl, $msg);  # Perl knows how long $msg is
#         die_if_ssl_error("ssl write");
#         shutdown S, 1;  # Half close --> No more output, sends EOF to server
#         $got = Net::SSLeay::read($ssl);         # Perl returns undef on failure
#         die_if_ssl_error("ssl read");
#         print $got;
                
#         Net::SSLeay::free ($ssl);               # Tear down connection
#         Net::SSLeay::CTX_free ($ctx);
#         close S;
    }
    if ($where_net_ftp) { }
    if ($where_cd)      { }
}

sub list_remove {
    my($widget, $list) = @_;
    my @to_remove;
    push @to_remove, $list->child_position($_) foreach($list->selection);
    splice @list_other, $_, 1 foreach(reverse sort @to_remove);
    $list->remove_items($list->selection);
}

sub file_ok_sel { 
    my ( $widget, $file_selection ) = @_;     
    my $file_name = $file_selection->get_filename();
    if(!member($file_name, @list_other)) {
	push(@list_other, $file_name);
	$list_other->add(gtkshow(new Gtk::ListItem($file_name)));
    }
}

sub filedialog_where_hd {
    my $file_dialog;

    $file_dialog = gtksignal_connect(new Gtk::FileSelection(_("File Selection")), destroy => sub { $file_dialog->destroy(); } );
    $file_dialog->ok_button->signal_connect(clicked => sub { 
	$save_path_entry->set_text($file_dialog->get_filename()); 
	$file_dialog->destroy() });
    $file_dialog->cancel_button->signal_connect(clicked => sub { $file_dialog->destroy() });
    $file_dialog->show();
}

sub filedialog_restore_find_path {
    my $file_dialog;

    $file_dialog = gtksignal_connect(new Gtk::FileSelection(_("File Selection")), destroy => sub { $file_dialog->destroy(); } );
    $file_dialog->ok_button->signal_connect(clicked => sub { 
	$restore_find_path_entry->set_text($file_dialog->get_filename()); 
	$file_dialog->destroy() });
    $file_dialog->cancel_button->signal_connect(clicked => sub { $file_dialog->destroy() });
    $file_dialog->show();
}


sub filedialog {
    my $file_dialog;

    $file_dialog = gtksignal_connect(new Gtk::FileSelection(_("File Selection")), destroy => sub { $file_dialog->destroy(); } );
    $file_dialog->ok_button->signal_connect(clicked => \&file_ok_sel, $file_dialog);
    $file_dialog->ok_button->child->set(_("Add"));
    $file_dialog->cancel_button->signal_connect(clicked => sub { $file_dialog->destroy() });
    $file_dialog->cancel_button->child->set(_("Close"));
    $file_dialog->set_filename(_("Select the files or directories and click on 'Add'"));
    $file_dialog->show();
}

################################################  ADVANCED  ################################################  

sub advanced_what_sys {
    my $box_what_sys;
    
    gtkpack($advanced_box,
	    $box_what_sys = gtkpack_(new Gtk::VBox(0, 15),
				     1, _("\nPlease check all options that you need.\n"),
				     1, _("This options can backup and restore all files on your /etc directory.\n"),
				     0, my $check_what_sys = new Gtk::CheckButton( _("Backup your System files. (~ 2Mo)")),
				     0, my $check_what_versions = new Gtk::CheckButton( _("Use incremental backup  (do not replace old backups)") ),
				     0, my $check_what_critical = new Gtk::CheckButton( _("Do not include critical files (passwd, goup, fstab)") ),
				     0, _("With this option you will be able to restore any version\n of your /etc directory."),
				     1, new Gtk::VBox(0, 15),
				     ),
	    );
    foreach ([$check_what_sys, \$backup_sys], [$check_what_critical, \$no_critical_sys]) {
	my $ref = $_->[1];
	gtksignal_connect(gtkset_active($_->[0], ${$ref}), toggled => sub { ${$ref} = ${$ref} ? 0 : 1; })
	}
    gtksignal_connect(gtkset_active($check_what_versions, $backup_sys_versions), toggled => sub {
	$backup_sys_versions = $backup_sys_versions ? 0 : 1;
    });
    $custom_help = "what";
    $current_widget = \&advanced_what_sys;
    $previous_widget =\&advanced_what;
    $central_widget = \$box_what_sys;
    $up_box->show_all();
}

sub advanced_what_user {
    my ($previous_function) = @_,
    my $box_what_user;
    my %check_what_user;
    
    gtkpack($advanced_box,
	    $box_what_user = gtkpack_(new Gtk::VBox(0, 15),
				      0, _("Please check all user that you want to include inb your backup."),
				      0, new Gtk::HSeparator,
				      1, createScrolledWindow( 
						gtkpack__(new Gtk::VBox(0,0),
							map { my $name = $_;
							      my @user_list_tmp;
							      my $b = new Gtk::CheckButton($name); 
							      if (grep /^$name$/, @user_list) {
								  $check_what_user{$_}[1] = 1;
								  gtkset_active($b, 1);
							      } else {
								  $check_what_user{$_}[1] = 0;
								  gtkset_active($b, 0);
							      }
							      $b->signal_connect(toggled => sub { 
								  if ($check_what_user{$name}[1] ) {
								      $check_what_user{$name}[1] = 0;
								      @user_list_tmp = grep(!/^$name$/, @user_list);
								      @user_list = @user_list_tmp;
								  } else { 
								      $check_what_user{$name}[1] = 1;
								      if (!member($name, @user_list) ) {push @user_list, $name;}
								  }
							      });
							      $b } (@all_user_list) 
							),
							       ),
				      0, my $check_what_browser = new Gtk::CheckButton( _(" do not include the browser cache") ),
				      0, my $check_what_user_versions = new Gtk::CheckButton( _("Use Incremental Backups  (do not replace old backups)") ),
				      ),
	    );
    foreach ([$check_what_browser, \$what_no_browser]) {
	my $ref = $_->[1];
	gtksignal_connect(gtkset_active($_->[0], ${$ref}), toggled => sub { ${$ref} = ${$ref} ? 0 : 1; })
	}
    gtksignal_connect(gtkset_active($check_what_user_versions, $backup_user_versions), toggled => sub {
	$backup_user_versions = $backup_user_versions ? 0 : 1;
    });
    $custom_help = "what";
    if ($previous_function) { $previous_widget =\&$previous_function; $next_widget =\&$previous_function; }
    else { $previous_widget =\&advanced_what; }
    $current_widget = \&advanced_what_user;
    $central_widget = \$box_what_user;
    $up_box->show_all();
}

sub advanced_what_other {
    my $box_what_other;
    $list_other = new Gtk::List();
    $list_other->set_selection_mode(-extended);
    $list_other->add(gtkshow(new Gtk::ListItem($_))) foreach (@list_other);
    
    gtkpack($advanced_box,
	    $box_what_other = gtkpack_(new Gtk::VBox(0, 15),
				  1, gtkpack_(new Gtk::HBox(0,4),
					      1, createScrolledWindow($list_other),
					      ),
				  0, gtkadd(gtkset_layout(new Gtk::HButtonBox, -spread),
					    gtksignal_connect(new Gtk::Button(_("Add")), clicked => sub {filedialog()  }),
					    gtksignal_connect(new Gtk::Button(_("Remove Selected")), clicked => \&list_remove, $list_other),
					    ),
				  0, gtkset_sensitive(my $check_what_other_versions = new Gtk::CheckButton( _("Use Incremental Backups  (do not replace old backups)") ), 0),