[pve-container.git] / src / PVE / LXC / Create.pm

package PVE::LXC::Create;

use strict;
use warnings;
use File::Basename;
use File::Path;
use Data::Dumper;
use Fcntl;

use PVE::Storage;
use PVE::LXC;
use PVE::LXC::Setup;
use PVE::VZDump::ConvertOVZ;
use PVE::Tools;
use POSIX;

sub detect_architecture {
    my ($rootdir) = @_;

    # see https://en.wikipedia.org/wiki/Executable_and_Linkable_Format

    my $supported_elf_machine = {
	0x03 => 'i386',
	0x3e => 'amd64',
	0x28 => 'armhf',
	0xb7 => 'arm64',
    };

    my $elf_fn = '/bin/sh'; # '/bin/sh' is POSIX mandatory
    my $detect_arch = sub {
	# chroot avoids a problem where we check the binary of the host system
	# if $elf_fn is an absolut symlink (e.g. $rootdir/bin/sh -> /bin/bash)
	chroot($rootdir) or die "chroot '$rootdir' failed: $!\n";
	chdir('/') or die "failed to change to root directory\n";

	open(my $fh, "<", $elf_fn) or die "open '$elf_fn' failed: $!\n";
	binmode($fh);

	my $length = read($fh, my $data, 20) or die "read failed: $!\n";

	# 4 bytes ELF magic number and 1 byte ELF class, padding, machine
	my ($magic, $class, undef, $machine) = unpack("A4CA12n", $data);

	die "'$elf_fn' does not resolve to an ELF!\n"
	    if (!defined($class) || !defined($magic) || $magic ne "\177ELF");

	my $arch = $supported_elf_machine->{$machine};
	die "'$elf_fn' has unknown ELF machine '$machine'!\n"
	    if !defined($arch);

	return $arch;
    };

    my $arch = eval { PVE::Tools::run_fork_with_timeout(5, $detect_arch) };
    if (my $err = $@) {
	$arch = 'amd64';
	print "Architecture detection failed: $err\nFalling back to amd64.\n" .
	      "Use `pct set VMID --arch ARCH` to change.\n";
    } else {
	print "Detected container architecture: $arch\n";
    }

    return $arch;
}

sub restore_archive {
    my ($archive, $rootdir, $conf, $no_unpack_error, $bwlimit) = @_;

    my ($id_map, $rootuid, $rootgid) = PVE::LXC::parse_id_maps($conf);
    my $userns_cmd = PVE::LXC::userns_command($id_map);

    my $archive_fh;
    my $tar_input = '<&STDIN';
    my @compression_opt;
    if ($archive ne '-') {
	# GNU tar refuses to autodetect this... *sigh*
	my %compression_map = (
	    '.gz'  => '-z',
	    '.bz2' => '-j',
	    '.xz'  => '-J',
	    '.lzo'  => '--lzop',
	);
	if ($archive =~ /\.tar(\.[^.]+)?$/) {
	    if (defined($1)) {
		@compression_opt = $compression_map{$1}
		    or die "unrecognized compression format: $1\n";
	    }
	} else {
	    die "file does not look like a template archive: $archive\n";
	}
	sysopen($archive_fh, $archive, O_RDONLY)
	    or die "failed to open '$archive': $!\n";
	my $flags = $archive_fh->fcntl(Fcntl::F_GETFD(), 0);
	$archive_fh->fcntl(Fcntl::F_SETFD(), $flags & ~(Fcntl::FD_CLOEXEC()));
	$tar_input = '<&'.fileno($archive_fh);
    }

    my $cmd = [@$userns_cmd, 'tar', 'xpf', '-', @compression_opt, '--totals',
               @PVE::Storage::Plugin::COMMON_TAR_FLAGS,
               '-C', $rootdir];

    # skip-old-files doesn't have anything to do with time (old/new), but is
    # simply -k (annoyingly also called --keep-old-files) without the 'treat
    # existing files as errors' part... iow. it's bsdtar's interpretation of -k
    # *sigh*, gnu...
    push @$cmd, '--skip-old-files';
    push @$cmd, '--anchored';
    push @$cmd, '--exclude' , './dev/*';

    if (defined($bwlimit)) {
	$cmd = [ ['cstream', '-t', $bwlimit*1024], $cmd ];
    }

    if ($archive eq '-') {
	print "extracting archive from STDIN\n";
    } else {
	print "extracting archive '$archive'\n";
    }
    eval { PVE::Tools::run_command($cmd, input => $tar_input); };
    my $err = $@;
    close($archive_fh) if defined $archive_fh;
    die $err if $err && !$no_unpack_error;

    # if arch is set, we do not try to autodetect it
    return if defined($conf->{arch});

    $conf->{arch} = detect_architecture($rootdir);
}

sub recover_config {
    my ($archive) = @_;

    my ($raw, $conf_file) = PVE::Storage::extract_vzdump_config_tar($archive, qr!(\./etc/vzdump/(pct|vps)\.conf)$!);
    my $conf;
    my $mp_param = {};

    if ($conf_file =~ m/pct\.conf/) {

	$conf = PVE::LXC::Config::parse_pct_config("/lxc/0.conf" , $raw);

	delete $conf->{snapshots};
	delete $conf->{template}; # restored CT is never a template

	PVE::LXC::Config->foreach_mountpoint($conf, sub {
	    my ($ms, $mountpoint) = @_;
	    $mp_param->{$ms} = $conf->{$ms};
	});

    } elsif ($conf_file =~ m/vps\.conf/) {

	($conf, $mp_param) = PVE::VZDump::ConvertOVZ::convert_ovz($raw);

    } else {

       die "internal error";
    }

    return wantarray ? ($conf, $mp_param) : $conf;
}

sub restore_configuration {
    my ($vmid, $rootdir, $conf, $restricted) = @_;

    # restore: try to extract configuration from archive

    my $pct_cfg_fn = "$rootdir/etc/vzdump/pct.conf";
    my $pct_fwcfg_fn = "$rootdir/etc/vzdump/pct.fw";
    my $ovz_cfg_fn = "$rootdir/etc/vzdump/vps.conf";
    if (-f $pct_cfg_fn) {
	my $raw = PVE::Tools::file_get_contents($pct_cfg_fn);
	my $oldconf = PVE::LXC::Config::parse_pct_config("/lxc/$vmid.conf", $raw);

	foreach my $key (keys %$oldconf) {
	    next if $key eq 'digest' || $key eq 'rootfs' || $key eq 'snapshots' || $key eq 'unprivileged' || $key eq 'parent';
	    next if $key =~ /^mp\d+$/; # don't recover mountpoints
	    next if $key =~ /^unused\d+$/; # don't recover unused disks
	    if ($restricted && $key eq 'lxc') {
		warn "skipping custom lxc options, restore manually as root:\n";
		warn "--------------------------------\n";
		my $lxc_list = $oldconf->{'lxc'};
		foreach my $lxc_opt (@$lxc_list) {
		    warn "$lxc_opt->[0]: $lxc_opt->[1]\n"
		}
		warn "--------------------------------\n";
		next;
	    }
	    $conf->{$key} = $oldconf->{$key} if !defined($conf->{$key});
	}
	unlink($pct_cfg_fn);

	if (-f $pct_fwcfg_fn) {
	    my $pve_firewall_dir = '/etc/pve/firewall';
	    mkdir $pve_firewall_dir; # make sure the directory exists
	    PVE::Tools::file_copy($pct_fwcfg_fn, "${pve_firewall_dir}/$vmid.fw");
	    unlink $pct_fwcfg_fn;
	}

    } elsif (-f $ovz_cfg_fn) {
	print "###########################################################\n";
	print "Converting OpenVZ configuration to LXC.\n";
	print "Please check the configuration and reconfigure the network.\n";
	print "###########################################################\n";

	my $lxc_setup = PVE::LXC::Setup->new($conf, $rootdir); # detect OS
	$conf->{ostype} = $lxc_setup->{conf}->{ostype};
	my $raw = PVE::Tools::file_get_contents($ovz_cfg_fn);
	my $oldconf = PVE::VZDump::ConvertOVZ::convert_ovz($raw);
	foreach my $key (keys %$oldconf) {
	    $conf->{$key} = $oldconf->{$key} if !defined($conf->{$key});
	}
	unlink($ovz_cfg_fn);

    } else {
	print "###########################################################\n";
	print "Backup archive does not contain any configuration\n";
	print "###########################################################\n";
    }
}

1;
Commit	Line	Data
	1	package PVE::LXC::Create;
	2
	3	use strict;
	4	use warnings;
	5	use File::Basename;
	6	use File::Path;
	7	use Data::Dumper;
	8	use Fcntl;
	9
	10	use PVE::Storage;
	11	use PVE::LXC;
	12	use PVE::LXC::Setup;
	13	use PVE::VZDump::ConvertOVZ;
	14	use PVE::Tools;
	15	use POSIX;
	16
	17	sub detect_architecture {
	18	my ($rootdir) = @_;
	19
	20	# see https://en.wikipedia.org/wiki/Executable_and_Linkable_Format
	21
	22	my $supported_elf_machine = {
	23	0x03 => 'i386',
	24	0x3e => 'amd64',
	25	0x28 => 'armhf',
	26	0xb7 => 'arm64',
	27	};
	28
	29	my $elf_fn = '/bin/sh'; # '/bin/sh' is POSIX mandatory
	30	my $detect_arch = sub {
	31	# chroot avoids a problem where we check the binary of the host system
	32	# if $elf_fn is an absolut symlink (e.g. $rootdir/bin/sh -> /bin/bash)
	33	chroot($rootdir) or die "chroot '$rootdir' failed: $!\n";
	34	chdir('/') or die "failed to change to root directory\n";
	35
	36	open(my $fh, "<", $elf_fn) or die "open '$elf_fn' failed: $!\n";
	37	binmode($fh);
	38
	39	my $length = read($fh, my $data, 20) or die "read failed: $!\n";
	40
	41	# 4 bytes ELF magic number and 1 byte ELF class, padding, machine
	42	my ($magic, $class, undef, $machine) = unpack("A4CA12n", $data);
	43
	44	die "'$elf_fn' does not resolve to an ELF!\n"
	45	if (!defined($class) \|\| !defined($magic) \|\| $magic ne "\177ELF");
	46
	47	my $arch = $supported_elf_machine->{$machine};
	48	die "'$elf_fn' has unknown ELF machine '$machine'!\n"
	49	if !defined($arch);
	50
	51	return $arch;
	52	};
	53
	54	my $arch = eval { PVE::Tools::run_fork_with_timeout(5, $detect_arch) };
	55	if (my $err = $@) {
	56	$arch = 'amd64';
	57	print "Architecture detection failed: $err\nFalling back to amd64.\n" .
	58	"Use `pct set VMID --arch ARCH` to change.\n";
	59	} else {
	60	print "Detected container architecture: $arch\n";
	61	}
	62
	63	return $arch;
	64	}
	65
	66	sub restore_archive {
	67	my ($archive, $rootdir, $conf, $no_unpack_error, $bwlimit) = @_;
	68
	69	my ($id_map, $rootuid, $rootgid) = PVE::LXC::parse_id_maps($conf);
	70	my $userns_cmd = PVE::LXC::userns_command($id_map);
	71
	72	my $archive_fh;
	73	my $tar_input = '<&STDIN';
	74	my @compression_opt;
	75	if ($archive ne '-') {
	76	# GNU tar refuses to autodetect this... sigh
	77	my %compression_map = (
	78	'.gz' => '-z',
	79	'.bz2' => '-j',
	80	'.xz' => '-J',
	81	'.lzo' => '--lzop',
	82	);
	83	if ($archive =~ /\.tar(\.[^.]+)?$/) {
	84	if (defined($1)) {
	85	@compression_opt = $compression_map{$1}
	86	or die "unrecognized compression format: $1\n";
	87	}
	88	} else {
	89	die "file does not look like a template archive: $archive\n";
	90	}
	91	sysopen($archive_fh, $archive, O_RDONLY)
	92	or die "failed to open '$archive': $!\n";
	93	my $flags = $archive_fh->fcntl(Fcntl::F_GETFD(), 0);
	94	$archive_fh->fcntl(Fcntl::F_SETFD(), $flags & ~(Fcntl::FD_CLOEXEC()));
	95	$tar_input = '<&'.fileno($archive_fh);
	96	}
	97
	98	my $cmd = [@$userns_cmd, 'tar', 'xpf', '-', @compression_opt, '--totals',
	99	@PVE::Storage::Plugin::COMMON_TAR_FLAGS,
	100	'-C', $rootdir];
	101
	102	# skip-old-files doesn't have anything to do with time (old/new), but is
	103	# simply -k (annoyingly also called --keep-old-files) without the 'treat
	104	# existing files as errors' part... iow. it's bsdtar's interpretation of -k
	105	# sigh, gnu...
	106	push @$cmd, '--skip-old-files';
	107	push @$cmd, '--anchored';
	108	push @$cmd, '--exclude' , './dev/*';
	109
	110	if (defined($bwlimit)) {
	111	$cmd = [ ['cstream', '-t', $bwlimit*1024], $cmd ];
	112	}
	113
	114	if ($archive eq '-') {
	115	print "extracting archive from STDIN\n";
	116	} else {
	117	print "extracting archive '$archive'\n";
	118	}
	119	eval { PVE::Tools::run_command($cmd, input => $tar_input); };
	120	my $err = $@;
	121	close($archive_fh) if defined $archive_fh;
	122	die $err if $err && !$no_unpack_error;
	123
	124	# if arch is set, we do not try to autodetect it
	125	return if defined($conf->{arch});
	126
	127	$conf->{arch} = detect_architecture($rootdir);
	128	}
	129
	130	sub recover_config {
	131	my ($archive) = @_;
	132
	133	my ($raw, $conf_file) = PVE::Storage::extract_vzdump_config_tar($archive, qr!(\./etc/vzdump/(pct\|vps)\.conf)$!);
	134	my $conf;
	135	my $mp_param = {};
	136
	137	if ($conf_file =~ m/pct\.conf/) {
	138
	139	$conf = PVE::LXC::Config::parse_pct_config("/lxc/0.conf" , $raw);
	140
	141	delete $conf->{snapshots};
	142	delete $conf->{template}; # restored CT is never a template
	143
	144	PVE::LXC::Config->foreach_mountpoint($conf, sub {
	145	my ($ms, $mountpoint) = @_;
	146	$mp_param->{$ms} = $conf->{$ms};
	147	});
	148
	149	} elsif ($conf_file =~ m/vps\.conf/) {
	150
	151	($conf, $mp_param) = PVE::VZDump::ConvertOVZ::convert_ovz($raw);
	152
	153	} else {
	154
	155	die "internal error";
	156	}
	157
	158	return wantarray ? ($conf, $mp_param) : $conf;
	159	}
	160
	161	sub restore_configuration {
	162	my ($vmid, $rootdir, $conf, $restricted) = @_;
	163
	164	# restore: try to extract configuration from archive
	165
	166	my $pct_cfg_fn = "$rootdir/etc/vzdump/pct.conf";
	167	my $pct_fwcfg_fn = "$rootdir/etc/vzdump/pct.fw";
	168	my $ovz_cfg_fn = "$rootdir/etc/vzdump/vps.conf";
	169	if (-f $pct_cfg_fn) {
	170	my $raw = PVE::Tools::file_get_contents($pct_cfg_fn);
	171	my $oldconf = PVE::LXC::Config::parse_pct_config("/lxc/$vmid.conf", $raw);
	172
	173	foreach my $key (keys %$oldconf) {
	174	next if $key eq 'digest' \|\| $key eq 'rootfs' \|\| $key eq 'snapshots' \|\| $key eq 'unprivileged' \|\| $key eq 'parent';
	175	next if $key =~ /^mp\d+$/; # don't recover mountpoints
	176	next if $key =~ /^unused\d+$/; # don't recover unused disks
	177	if ($restricted && $key eq 'lxc') {
	178	warn "skipping custom lxc options, restore manually as root:\n";
	179	warn "--------------------------------\n";
	180	my $lxc_list = $oldconf->{'lxc'};
	181	foreach my $lxc_opt (@$lxc_list) {
	182	warn "$lxc_opt->[0]: $lxc_opt->[1]\n"
	183	}
	184	warn "--------------------------------\n";
	185	next;
	186	}
	187	$conf->{$key} = $oldconf->{$key} if !defined($conf->{$key});
	188	}
	189	unlink($pct_cfg_fn);
	190
	191	if (-f $pct_fwcfg_fn) {
	192	my $pve_firewall_dir = '/etc/pve/firewall';
	193	mkdir $pve_firewall_dir; # make sure the directory exists
	194	PVE::Tools::file_copy($pct_fwcfg_fn, "${pve_firewall_dir}/$vmid.fw");
	195	unlink $pct_fwcfg_fn;
	196	}
	197
	198	} elsif (-f $ovz_cfg_fn) {
	199	print "###########################################################\n";
	200	print "Converting OpenVZ configuration to LXC.\n";
	201	print "Please check the configuration and reconfigure the network.\n";
	202	print "###########################################################\n";
	203
	204	my $lxc_setup = PVE::LXC::Setup->new($conf, $rootdir); # detect OS
	205	$conf->{ostype} = $lxc_setup->{conf}->{ostype};
	206	my $raw = PVE::Tools::file_get_contents($ovz_cfg_fn);
	207	my $oldconf = PVE::VZDump::ConvertOVZ::convert_ovz($raw);
	208	foreach my $key (keys %$oldconf) {
	209	$conf->{$key} = $oldconf->{$key} if !defined($conf->{$key});
	210	}
	211	unlink($ovz_cfg_fn);
	212
	213	} else {
	214	print "###########################################################\n";
	215	print "Backup archive does not contain any configuration\n";
	216	print "###########################################################\n";
	217	}
	218	}
	219
	220	1;