One Hat Cyber Team

View File Name : restore.cgi

#!/usr/bin/perl
# Actually restore some servers, after asking for confirmation

require './virtual-server-lib.pl';
$crmode = &can_restore_domain();
$crmode || &error($text{'restore_ecannot'});
$safe_backup = $crmode == 1 ? 1 : 0;
&ReadParseMime();

# Work out the current user's main domain, if needed
if ($crmode == 2) {
	$d = &get_domain_by_user($base_remote_user);
	}

# Validate inputs, starting with source
&error_setup($text{'restore_err'});
if ($in{'log'}) {
	# Restoring a logged backup
	$log = &get_backup_log($in{'log'});
	$log || &error($text{'viewbackup_egone'});
	&can_backup_log($log) || &error($text{'viewbackup_ecannot'});
	$src = $log->{'dest'};
	$safe_backup = &can_trust_backup($log);
	}
elsif ($in{'src'}) {
	$src = $in{'src'};
	}
else {
	# Restoring from user-entered source
	$src = &parse_backup_destination("src", \%in, $crmode == 2, $d, undef);
	}
$origsrc = $in{'origsrc'} || $src;
$nice = &nice_backup_url($src);
if ($src eq "upload:") {
	# Special case - uploaded data, which we need to save locally
	$fn = $in{'src_upload_filename'};
	$fn =~ s/^.*[\\\/]//;
	if ($d) {
		# In domain's home dir
		$bdir = "$d->{'home'}/$home_virtualmin_backup";
		if (!-d $bdir) {
			&make_dir_as_domain_user($d, $bdir, 0700);
			}
		$temp = "$bdir/$fn";
		&open_tempfile_as_domain_user($d, TEMP, ">$temp", 0, 1);
		&print_tempfile(TEMP, $in{'src_upload'});
		&close_tempfile_as_domain_user($d, TEMP);
		&set_ownership_permissions(undef, undef, 0700, $temp);
		}
	else {
		# In /tmp/.webmin
		$temp = &tempname($fn);
		&open_tempfile(TEMP, ">$temp", 0, 1);
		&print_tempfile(TEMP, $in{'src_upload'});
		&close_tempfile(TEMP);
		&set_ownership_permissions(undef, undef,
			$safe_backup ? 0700 : 0755, $temp);
		}
	$src = $temp;
	}
($mode) = &parse_backup_url($src);
$mode > 0 || -r $src || -d $src || &error($text{'restore_esrc'});

# Get the backup key
$key = undef;
if (defined(&get_backup_key)) {
	if ($in{'key'}) {
		# User selected key
		$key = &get_backup_key($in{'key'});
		$key || &error($text{'backup_ekey'});
		&can_backup_key($key) || &error($text{'backup_ekeycannot'});
		}
	elsif ($log && $log->{'key'}) {
		# Key from the logged backup
		$key = &get_backup_key($log->{'key'});
		$key || &error($text{'backup_ekey'});
		}
	}

# Parse features
if ($in{'feature_all'}) {
	# All features usable by current user
	@do_features = &get_available_backup_features(!$safe_backup);
	foreach my $f (&list_backup_plugins()) {
		push(@do_features, $f);
		}
	if (!$safe_backup) {
		@do_features = grep {
			&indexof($_, @safe_backup_features) >= 0 ||
			&plugin_call($_, "feature_backup_safe") } @do_features;
		}
	}
else {
	# Selected features
	@do_features = split(/\0/, $in{'feature'});
	@do_features || &error($text{'restore_efeatures'});
	if (!$safe_backup) {
		# Make sure they are all safe
		foreach my $f (@do_features) {
			&indexof($f, @safe_backup_features) >= 0 ||
			  &plugin_call($f, "feature_backup_safe") ||
			    &error(&text('restore_eunsafe', $f));
			}
		}
	}
%do_features = map { $_, 1 } @do_features;

# Parse virtualmin configs to restore
if (&can_backup_virtualmin()) {
	@vbs = split(/\0/, $in{'virtualmin'});
	%vbs = map { $_, 1 } @vbs;
	}

# Parse option inputs
foreach $f (@do_features) {
	local $ofunc = "parse_restore_$f";
	if (defined(&$ofunc)) {
		$options{$f} = &$ofunc(\%in);
		}
	}

# Parse creation options
if ($crmode == 1) {
	$options{'reuid'} = $in{'reuid'};
	$options{'reuser'} = $in{'reuser'};
	$options{'fix'} = $in{'fix'};

	# Parse IP inputs
	$ipinfo = { };
	$tmpl = &get_template(0);
	if (&can_select_ip() && $in{'virt'} != -1) {
		# Different IPv4 address selected
		($ip, $virt, $virtalready, $netmask) =
			&parse_virtual_ip($tmpl, undef);
		$ipinfo->{'ip'} = $ip;
		$ipinfo->{'virt'} = $virt;
		$ipinfo->{'mode'} = $in{'virt'};
		$ipinfo->{'virtalready'} = $virtalready;
		$ipinfo->{'netmask'} = $netmask;
		}
	if (&can_select_ip6() && &supports_ipv6() && $in{'virt6'} != -1) {
		# Different IPv6 address selected
		($ip6, $virt6, $virt6already, $netmask6) =
			&parse_virtual_ip6($tmpl, undef);
		$ipinfo->{'ip6'} = $ip6;
		$ipinfo->{'virt6'} = $virt6;
		$ipinfo->{'mode6'} = $in{'virt6'};
		$ipinfo->{'virt6already'} = $virt6already;
		$ipinfo->{'netmask6'} = $netmask6;
		}
	}

&ui_print_unbuffered_header(undef, $text{'restore_title'}, "");

# Check what's in the backup
&$first_print($text{'restore_contents'});
($cont, $contdoms) = &backup_contents($src, 1, $key, $d);
if ($log && ref($cont)) {
	# Limit to domains in the backup that the user has access to
	my %dnames = map { $_, 1 } &backup_log_own_domains($log);
	foreach my $k (keys %$cont) {
		if (!$dnames{$k}) {
			delete($cont->{$k});
			}
		}
	if ($contdoms) {
		$contdoms = [ grep { $dnames{$_->{'dom'}} } @$contdoms ];
		}
	}
ref($cont) || &error(&text('restore_efile', $cont));
(keys %$cont) || &error($text{'restore_enone'});

if ($in{'confirm'}) {
	# Find the selected domain objects, in preparation for actual restore
	$gotvbs = 0;
	foreach $d (split(/\0/, $in{'dom'})) {
		if ($d eq "virtualmin") {
			$gotvbs = 1;
			next;
			}
		local $dinfo = &get_domain_by("dom", $d);
		if ($dinfo && (!$dinfo->{'id'} || !$dinfo->{'dom'})) {
			# File is actually empty!
			$dinfo = undef;
			}
		if ($dinfo) {
			&can_edit_domain($dinfo) ||
				&error(&text('restore_ecannotdom',
					&show_domain_name($dinfo)));
			push(@doms, $dinfo);
			}
		else {
			$crmode == 1 || &error(&text('restore_ecannotcreate',
						 &show_domain_name($d)));
			push(@doms, { 'dom' => $d,
				      'missing' => 1 });
			}
		}
	@vbs = ( ) if (!$gotvbs);
	@doms || @vbs || &error($text{'restore_edoms'});
	}

# Show contents summary to the user
$contcount = 0;
$vbscount = 0;
foreach my $dname (keys %$cont) {
	if ($dname eq "virtualmin") {
		$vbscount += scalar(@{$cont->{$dname}});
		}
	else {
		$contcount++;
		}
	}
&$second_print(&text($vbscount ? 'restore_gotcontents2'
			       : 'restore_gotcontents', $contcount, $vbscount));

if (!$in{'confirm'}) {
	# Check for missing features
	@missing = &missing_restore_features($cont, $contdoms);
	@critical = grep { $_->{'critical'} } @missing;
	if (@critical) {
		print &ui_alert_box(&text('restore_fmissing', 
			join(", ", map { $_->{'desc'} } @critical))."<br>$text{'restore_fmissing3'}", 'info');
		goto FAILED;
		}
	elsif (@missing) {
		print &ui_alert_box(&text('restore_fmissing', 
			join(", ", map { $_->{'desc'} } @missing))."<br>$text{'restore_fmissing2'}", 'info');
		}

	# Check for backup problems
	@errs = &check_restore_errors($cont, $contdoms);
	@criticalerrs = $in{'skipwarnings'} ? (grep { $_->{'critical'} } @errs)
				      	    : @errs;
	if (@criticalerrs) {
		print "<b>",&text('restore_rerrors', 
		    join(", ", &unique(map { $_->{'desc'} } @criticalerrs))),
		    "</b><p>\n";
		goto FAILED;
		}
	elsif (@errs) {
		print "<b>",&text('restore_rerrors2', 
		    join(", ", &unique(map { $_->{'desc'} } @criticalerrs))),
		    "</b><p>\n";
		}

	# Tell the user what will be done
	print &ui_alert_box(&text('restore_from', $nice), 'warn');

	print &ui_form_start("restore.cgi", "form-data");
	print &ui_hidden("origsrc", $origsrc);

	# Show domains with features below them
	@links = ( &select_all_link("dom", 0), &select_invert_link("dom", 0) );
	print &ui_links_row(\@links);
	%plugins = map { $_, 1 } &list_backup_plugins();
	print "<dl>\n";
	$anymissing = 0;
	foreach $d (sort { $a cmp $b } keys %$cont) {
		next if ($d eq "virtualmin");
		local $dinfo = &get_domain_by("dom", $d);
		local $can = $crmode == 1 ||
			     $dinfo && &can_edit_domain($dinfo);
		if ($in{'log'} && !$can) {
			# When restoring from a logged backup, don't even show
			# domains that this user can't restore
			next;
			}
		print "<dt>",&ui_checkbox("dom", $d,
				"<b>".&show_domain_name($d)."</b>",
				$can, undef, !$can),"\n";
		if (!$dinfo) {
			# Tell user that it doesn't exist, and if he can create
			if ($crmode == 1) {
				print "($text{'restore_create'})\n";
				}
			else {
				print "($text{'restore_nocreate'})\n";
				}
			$anymissing++;
			}
		elsif (!&can_edit_domain($dinfo)) {
			# Warn if cannot restore
			print "($text{'restore_norestore'})\n";
			}

		@dfeats = grep { $do_features{$_} } @{$cont->{$d}};
		@dfeats_f = grep { !$plugins{$_} } @dfeats;
		@dfeats_p = grep { $plugins{$_} } @dfeats;
		if (!@dfeats && !$in{'fix'}) {
			print "<dd><i>$text{'restore_nofeat'}</i>\n";
			}
		else {
			print "<dd>",join("<br>",
				map { $text{'backup_feature_'.$_} ||
				      $text{'feature_'.$_} } @dfeats_f),"\n";
			print "<dd>",join("<br>",
				map { &plugin_call($_, "feature_backup_name") ||
				      &plugin_call($_, "feature_name") }
				    @dfeats_p),"\n";
			$any++;
			}
		}

	# Show virtualmin settings
	if ($cont->{'virtualmin'} && &can_backup_virtualmin()) {
		print "<dt>",&ui_checkbox("dom", "virtualmin",
			"<b>$text{'restore_dovirtualmin'}</b>", 1),"\n";
		@dvbs = grep { $vbs{$_} } @{$cont->{'virtualmin'}};
		if (!@dvbs) {
			print "<dd><i>$text{'restore_novirt'}</i>\n";
			}
		else {
			print "<dd>",join("<br>",
				map { $text{'backup_v'.$_} } @dvbs),"\n";
			$any++;
			}
		}

	print "</dl>\n";
	print &ui_links_row(\@links);
	if ($any) {
		# Pass all HTML inputs to program again, and show OK button
		print &ui_hidden("src", $src),"\n";
		foreach $i (keys %in) {
			next if ($i =~ /^src_/);
			foreach $v (split(/\0/, $in{$i})) {
				print &ui_hidden($i, $v),"\n";
				}
			}
		print "<center>",&ui_submit($text{'restore_now2'}, "confirm"),
		      "<p></p>",&ui_checkbox("skipwarnings", 1,
					  $text{'restore_wskip'}, 0),
		      (keys %$cont > 1 ?
			      "<br>".&ui_checkbox("continue", 1,
					  $text{'restore_wcontinue'}, 0) : ""),
		      "</center>\n";
		}
	else {
		print "$text{'restore_notany'}<p>\n";
		}
	print &ui_form_end();
	}
else {
	# Actually execute the restore
	if (@doms) {
		print &text('restore_doing', scalar(@doms), $nice),"<p>\n";
		}
	else {
		print &text('restore_doing2', scalar(@vbs), $nice),"<p>\n";
		}
	$ok = &restore_domains($src, \@doms, \@do_features, \%options, \@vbs,
			       0, $ipinfo, !$safe_backup,
			       $in{'skipwarnings'}, $key, $in{'continue'},
			       $in{'delete_existing'});
	&run_post_actions();
	if ($ok) {
		print &text('restore_done'),"<p>\n";
		}
	else {
		print &text('restore_failed'),"<p>\n";
		}
	if ($origsrc eq "upload:") {
		# Delete uploaded temp file
		&unlink_file($src);
		}
	&webmin_log("restore", $src, undef,
		    { 'doms' => [ map { $_->{'dom'} } @doms ] });

	# Call any theme post command
	foreach my $d (@doms) {
		if (!$log->{'plugged'} && defined(&theme_post_save_domain)) {
			&theme_post_save_domain($d,
				$d->{'missing'} ? 'create' : 'modify');
			}
		last; # No need to call for each domain
		}
	}

FAILED:
if (defined($in{'onedom'})) {
	# Link is back to view/edit form
	&ui_print_footer(&domain_footer_link(&get_domain($in{'onedom'})));
	}
else {
	&ui_print_footer($in{'return'} || "", $text{'index_return'});
	}