proxinstall

   1 #!/usr/bin/perl
   2
   3 $ENV{DEBIAN_FRONTEND} = 'noninteractive';
   4 $ENV{LC_ALL} = 'C';
   5
   6 use strict;
   7 use warnings;
   8
   9 use Getopt::Long;
  10 use IPC::Open2;
  11 use IPC::Open3;
  12 use IO::File;
  13 use IO::Select;
  14 use Cwd 'abs_path';
  15 use Gtk3 '-init';
  16 use Gtk3::WebKit;
  17 use Encode;
  18 use String::ShellQuote;
  19 use Data::Dumper;
  20 use File::Basename;
  21 use Time::HiRes;
  22
  23 use ProxmoxInstallerSetup;
  24
  25 my $setup = ProxmoxInstallerSetup::setup();
  26
  27 my $opt_testmode;
  28
  29 if (!$ENV{G_SLICE} ||  $ENV{G_SLICE} ne "always-malloc") {
  30     die "do not use slice allocator (run with 'G_SLICE=always-malloc ./proxinstall ...')\n";
  31 }
  32
  33 if (!GetOptions ('testmode=s' => \$opt_testmode)) {
  34     die "usage error\n";
  35     exit (-1);
  36 }
  37
  38 my $zfstestpool = "test_rpool";
  39 my $zfspoolname = $opt_testmode ? $zfstestpool : 'rpool';
  40 my $zfsrootvolname = "$setup->{product}-1";
  41
  42 my $storage_cfg_zfs = <<__EOD__;
  43 dir: local
  44         path /var/lib/vz
  45         content iso,vztmpl,backup
  46
  47 zfspool: local-zfs
  48         pool $zfspoolname/data
  49         sparse
  50         content images,rootdir
  51 __EOD__
  52
  53 my $storage_cfg_btrfs = <<__EOD__;
  54 dir: local
  55         path /var/lib/vz
  56         content iso,vztmpl,backup
  57         disabled
  58
  59 btrfs: local-btrfs
  60         path /var/lib/pve/local-btrfs
  61         content iso,vztmpl,backup,images,rootdir
  62 __EOD__
  63
  64 my $storage_cfg_lvmthin = <<__EOD__;
  65 dir: local
  66         path /var/lib/vz
  67         content iso,vztmpl,backup
  68
  69 lvmthin: local-lvm
  70         thinpool data
  71         vgname pve
  72         content rootdir,images
  73 __EOD__
  74
  75 my $storage_cfg_local = <<__EOD__;
  76 dir: local
  77         path /var/lib/vz
  78         content iso,vztmpl,backup,rootdir,images
  79 __EOD__
  80
  81 sub file_read_firstline {
  82     my ($filename) = @_;
  83
  84     my $fh = IO::File->new ($filename, "r");
  85     return undef if !$fh;
  86     my $res = <$fh>;
  87     chomp $res if $res;
  88     $fh->close;
  89     return $res;
  90 }
  91
  92 my $logfd = IO::File->new (">/tmp/install.log");
  93
  94 my $proxmox_libdir = $opt_testmode ?
  95     Cwd::cwd() . "/testdir/var/lib/pve-installer" : "/var/lib/pve-installer";
  96 my $proxmox_cddir = $opt_testmode ? "../pve-cd-builder/tmp/data-gz/" : "/cdrom";
  97 my $proxmox_pkgdir = "${proxmox_cddir}/proxmox/packages/";
  98
  99 my $grub_plattform = "pc"; # pc, efi-amd64 or efi-ia32
 100
 101 $grub_plattform = "efi-amd64" if -d "/sys/firmware/efi";
 102
 103 my $IPV4OCTET = "(?:25[0-5]|(?:2[0-4]|1[0-9]|[1-9])?[0-9])";
 104 my $IPV4RE = "(?:(?:$IPV4OCTET\\.){3}$IPV4OCTET)";
 105 my $IPV6H16 = "(?:[0-9a-fA-F]{1,4})";
 106 my $IPV6LS32 = "(?:(?:$IPV4RE|$IPV6H16:$IPV6H16))";
 107
 108 my $IPV6RE = "(?:" .
 109     "(?:(?:" .                             "(?:$IPV6H16:){6})$IPV6LS32)|" .
 110     "(?:(?:" .                           "::(?:$IPV6H16:){5})$IPV6LS32)|" .
 111     "(?:(?:(?:" .              "$IPV6H16)?::(?:$IPV6H16:){4})$IPV6LS32)|" .
 112     "(?:(?:(?:(?:$IPV6H16:){0,1}$IPV6H16)?::(?:$IPV6H16:){3})$IPV6LS32)|" .
 113     "(?:(?:(?:(?:$IPV6H16:){0,2}$IPV6H16)?::(?:$IPV6H16:){2})$IPV6LS32)|" .
 114     "(?:(?:(?:(?:$IPV6H16:){0,3}$IPV6H16)?::(?:$IPV6H16:){1})$IPV6LS32)|" .
 115     "(?:(?:(?:(?:$IPV6H16:){0,4}$IPV6H16)?::" .           ")$IPV6LS32)|" .
 116     "(?:(?:(?:(?:$IPV6H16:){0,5}$IPV6H16)?::" .            ")$IPV6H16)|" .
 117     "(?:(?:(?:(?:$IPV6H16:){0,6}$IPV6H16)?::" .                    ")))";
 118
 119 my $IPRE = "(?:$IPV4RE|$IPV6RE)";
 120
 121
 122 my $ipv4_mask_hash = {
 123     '128.0.0.0' => 1,
 124     '192.0.0.0' => 2,
 125     '224.0.0.0' => 3,
 126     '240.0.0.0' => 4,
 127     '248.0.0.0' => 5,
 128     '252.0.0.0' => 6,
 129     '254.0.0.0' => 7,
 130     '255.0.0.0' => 8,
 131     '255.128.0.0' => 9,
 132     '255.192.0.0' => 10,
 133     '255.224.0.0' => 11,
 134     '255.240.0.0' => 12,
 135     '255.248.0.0' => 13,
 136     '255.252.0.0' => 14,
 137     '255.254.0.0' => 15,
 138     '255.255.0.0' => 16,
 139     '255.255.128.0' => 17,
 140     '255.255.192.0' => 18,
 141     '255.255.224.0' => 19,
 142     '255.255.240.0' => 20,
 143     '255.255.248.0' => 21,
 144     '255.255.252.0' => 22,
 145     '255.255.254.0' => 23,
 146     '255.255.255.0' => 24,
 147     '255.255.255.128' => 25,
 148     '255.255.255.192' => 26,
 149     '255.255.255.224' => 27,
 150     '255.255.255.240' => 28,
 151     '255.255.255.248' => 29,
 152     '255.255.255.252' => 30,
 153     '255.255.255.254' => 31,
 154     '255.255.255.255' => 32
 155 };
 156
 157 my $ipv4_reverse_mask = [
 158     '0.0.0.0',
 159     '128.0.0.0',
 160     '192.0.0.0',
 161     '224.0.0.0',
 162     '240.0.0.0',
 163     '248.0.0.0',
 164     '252.0.0.0',
 165     '254.0.0.0',
 166     '255.0.0.0',
 167     '255.128.0.0',
 168     '255.192.0.0',
 169     '255.224.0.0',
 170     '255.240.0.0',
 171     '255.248.0.0',
 172     '255.252.0.0',
 173     '255.254.0.0',
 174     '255.255.0.0',
 175     '255.255.128.0',
 176     '255.255.192.0',
 177     '255.255.224.0',
 178     '255.255.240.0',
 179     '255.255.248.0',
 180     '255.255.252.0',
 181     '255.255.254.0',
 182     '255.255.255.0',
 183     '255.255.255.128',
 184     '255.255.255.192',
 185     '255.255.255.224',
 186     '255.255.255.240',
 187     '255.255.255.248',
 188     '255.255.255.252',
 189     '255.255.255.254',
 190     '255.255.255.255',
 191 ];
 192
 193 my $step_number = 0; # Init number for global function list
 194
 195 my @steps = (
 196     {
 197         step => 'intro',
 198         html => 'license.htm',
 199         next_button => 'I a_gree',
 200         function => \&create_intro_view,
 201     },
 202     {
 203         step => 'intro',
 204         html => 'page1.htm',
 205         function => \&create_hdsel_view,
 206     },
 207     {
 208         step => 'country',
 209         html => 'country.htm',
 210         function => \&create_country_view,
 211     },
 212     {
 213         step => 'password',
 214         html => 'passwd.htm',
 215         function => \&create_password_view,
 216     },
 217     {
 218         step => 'ipconf',
 219         next_button => '_Install',
 220         html => 'ipconf.htm',
 221         function => \&create_ipconf_view,
 222     },
 223     {
 224         step => 'extract',
 225         next_button => '_Reboot',
 226         function => \&create_extract_view,
 227     },
 228 );
 229
 230 # GUI global variables
 231 my ($window, $cmdbox, $inbox, $htmlview);
 232 my $prev;
 233 my ($next, $next_fctn, $target_hd);
 234 my ($progress, $progress_status);
 235
 236 my ($ipversion, $ipaddress, $ipconf_entry_addr);
 237 my ($netmask, $ipconf_entry_mask);
 238 my ($gateway, $ipconf_entry_gw);
 239 my ($dnsserver, $ipconf_entry_dns);
 240 my $hostname = 'proxmox';
 241 my $domain = 'domain.tld';
 242 my $cmdline = file_read_firstline("/proc/cmdline");
 243 my $ipconf;
 244 my $country;
 245 my $timezone = 'Europe/Vienna';
 246 my $keymap = 'en-us';
 247 my $password;
 248 my $mailto = 'mail@example.invalid';
 249 my $cmap;
 250
 251 # Format: screen/function name => settings for that screen
 252 my $global_configuration = {
 253
 254     # TODO: add all the user-provided options during the install
 255     # to be able to call them back if necessary
 256
 257     hdsel => {},
 258     country => {
 259         country => $country,
 260         timezone => $timezone,
 261         keymap => $keymap,
 262     },
 263     password => {
 264         password => $password,
 265         mailto => $mailto,
 266     },
 267     ipconf => {
 268         hostname => $hostname,
 269         domain => $domain,
 270     },
 271 };
 272
 273 # parse command line args
 274
 275 my $config_options = {};
 276
 277 if ($cmdline =~ m/\s(ext3|ext4|xfs)(\s.*)?$/) {
 278     $config_options->{filesys} = $1;
 279 } else {
 280     $config_options->{filesys} = 'ext4';
 281 }
 282
 283 if ($cmdline =~ m/hdsize=(\d+(\.\d+)?)[\s\n]/i) {
 284     $config_options->{hdsize} = $1;
 285 }
 286
 287 if ($cmdline =~ m/swapsize=(\d+(\.\d+)?)[\s\n]/i) {
 288     $config_options->{swapsize} = $1;
 289 }
 290
 291 if ($cmdline =~ m/maxroot=(\d+(\.\d+)?)[\s\n]/i) {
 292     $config_options->{maxroot} = $1;
 293 }
 294
 295 if ($cmdline =~ m/minfree=(\d+(\.\d+)?)[\s\n]/i) {
 296     $config_options->{minfree} = $1;
 297 }
 298
 299 if ($setup->{product} eq 'pve') {
 300     if ($cmdline =~ m/maxvz=(\d+(\.\d+)?)[\s\n]/i) {
 301         $config_options->{maxvz} = $1;
 302     }
 303 }
 304
 305 my $postfix_main_cf = <<_EOD;
 306 # See /usr/share/postfix/main.cf.dist for a commented, more complete version
 307
 308 myhostname=__FQDN__
 309
 310 smtpd_banner = \$myhostname ESMTP \$mail_name (Debian/GNU)
 311 biff = no
 312
 313 # appending .domain is the MUA's job.
 314 append_dot_mydomain = no
 315
 316 # Uncomment the next line to generate "delayed mail" warnings
 317 #delay_warning_time = 4h
 318
 319 alias_maps = hash:/etc/aliases
 320 alias_database = hash:/etc/aliases
 321 mydestination = \$myhostname, localhost.\$mydomain, localhost
 322 relayhost =
 323 mynetworks = 127.0.0.0/8
 324 inet_interfaces = loopback-only
 325 recipient_delimiter = +
 326
 327 _EOD
 328
 329 sub shellquote {
 330     my $str = shift;
 331
 332     return String::ShellQuote::shell_quote($str);
 333 }
 334
 335 sub cmd2string {
 336     my ($cmd) = @_;
 337
 338     die "no arguments" if !$cmd;
 339
 340     return $cmd if !ref($cmd);
 341
 342     my @qa = ();
 343     foreach my $arg (@$cmd) { push @qa, shellquote($arg); }
 344
 345     return join (' ', @qa);
 346 }
 347
 348 sub syscmd {
 349     my ($cmd) = @_;
 350
 351     return run_command ($cmd, undef, undef, 1);
 352 }
 353
 354 sub run_command {
 355     my ($cmd, $func, $input, $noout) = @_;
 356
 357     my $cmdstr;
 358     if (!ref($cmd)) {
 359         $cmdstr = $cmd;
 360         if ($cmd =~ m/|/) {
 361             # see 'man bash' for option pipefail
 362             $cmd = [ '/bin/bash', '-c', "set -o pipefail && $cmd" ];
 363         } else {
 364             $cmd = [ $cmd ];
 365         }
 366     } else {
 367         $cmdstr = cmd2string($cmd);
 368     }
 369
 370     my $cmdtxt;
 371     if ($input && ($cmdstr !~ m/chpasswd/)) {
 372         $cmdtxt = "# $cmdstr <<EOD\n$input";
 373         chomp $cmdtxt;
 374         $cmdtxt .= "\nEOD\n";
 375     } else {
 376         $cmdtxt = "# $cmdstr\n";
 377     }
 378
 379     if ($opt_testmode) {
 380         print $cmdtxt;
 381         STDOUT->flush();
 382     }
 383
 384     print $logfd $cmdtxt;
 385
 386     my $reader = IO::File->new();
 387     my $writer = IO::File->new();
 388     my $error  = IO::File->new();
 389
 390     my $orig_pid = $$;
 391
 392     my $pid;
 393     eval {
 394         $pid = open3 ($writer, $reader, $error, @$cmd) || die $!;
 395     };
 396
 397     my $err = $@;
 398
 399     # catch exec errors
 400     if ($orig_pid != $$) {
 401         POSIX::_exit (1);
 402         kill ('KILL', $$);
 403     }
 404
 405     die $err if $err;
 406
 407     print $writer $input if defined $input;
 408     close $writer;
 409
 410     my $select = new IO::Select;
 411     $select->add ($reader);
 412     $select->add ($error);
 413
 414     my ($ostream, $logout) = ('', '', '');
 415
 416     while ($select->count) {
 417         my @handles = $select->can_read (0.2);
 418
 419         Gtk3::main_iteration() while Gtk3::events_pending();
 420
 421         next if !scalar (@handles); # timeout
 422
 423         foreach my $h (@handles) {
 424             my $buf = '';
 425             my $count = sysread ($h, $buf, 4096);
 426             if (!defined ($count)) {
 427                 my $err = $!;
 428                 kill (9, $pid);
 429                 waitpid ($pid, 0);
 430                 die "command '$cmd' failed: $err";
 431             }
 432             $select->remove ($h) if !$count;
 433             if ($h eq $reader) {
 434                 $ostream .= $buf if !($noout || $func);
 435                 $logout .= $buf;
 436                 while ($logout =~ s/^([^\010\r\n]*)(\r|\n|(\010)+|\r\n)//s) {
 437                     my $line = $1;
 438                     &$func($line) if $func;
 439                 }
 440
 441             } elsif ($h eq $error) {
 442                 $ostream .= $buf if !($noout || $func);
 443             }
 444             print $buf;
 445             STDOUT->flush();
 446             print $logfd $buf;
 447         }
 448     }
 449
 450     &$func($logout) if $func;
 451
 452     my $rv = waitpid ($pid, 0);
 453
 454     return $? if $noout; # behave like standard system();
 455
 456     if ($? == -1) {
 457         die "command '$cmdstr' failed to execute\n";
 458     } elsif (my $sig = ($? & 127)) {
 459         die "command '$cmdstr' failed - got signal $sig\n";
 460     } elsif (my $exitcode = ($? >> 8)) {
 461         die "command '$cmdstr' failed with exit code $exitcode";
 462     }
 463
 464     return $ostream;
 465 }
 466
 467 sub detect_country {
 468
 469     print "trying to detect country...\n";
 470     my $cpid = open2(\*TMP, undef, "traceroute -N 1 -q 1 -n 8.8.8.8");
 471     return undef if !$cpid;
 472
 473     my $country;
 474
 475     my $previous_alarm = alarm (10);
 476     eval  {
 477         local $SIG{ALRM} = sub { die "timed out!\n" };
 478         my $line;
 479         while (defined ($line = <TMP>)) {
 480             print $logfd "DC TRACEROUTE: $line";
 481             if ($line =~ m/\s*\d+\s+(\d+\.\d+\.\d+\.\d+)\s/) {
 482                 my $geoip = `geoiplookup $1`;
 483                 print $logfd "DC GEOIP: $geoip";
 484                 if ($geoip =~ m/GeoIP Country Edition:\s*([A-Z]+),/) {
 485                     $country = lc ($1);
 486                     print $logfd "DC FOUND: $country\n";
 487                     last;
 488                 }
 489             }
 490         }
 491     };
 492
 493     my $err = $@;
 494
 495     alarm ($previous_alarm);
 496
 497     close (TMP);
 498
 499     if ($err) {
 500         print "unable to detect country - $err\n";
 501     } elsif ($country) {
 502         print "detected country: " . uc($country) . "\n";
 503     } else {
 504         print "unable to detect country\n";
 505     }
 506
 507     return $country;
 508 }
 509
 510 sub get_memtotal {
 511
 512     open (MEMINFO, "/proc/meminfo");
 513
 514     my $res = 512; # default to 512 if something goes wrong
 515     while (my $line = <MEMINFO>) {
 516         if ($line =~ m/^MemTotal:\s+(\d+)\s*kB/i) {
 517             $res = int ($1 / 1024);
 518         }
 519     }
 520
 521     close (MEMINFO);
 522
 523     return $res;
 524 }
 525
 526 my $total_memory = get_memtotal();
 527
 528 sub link_points_to {
 529     my ($src, $dest) = @_;
 530
 531     my ($dev1,$ino1) = stat ($src);
 532     my ($dev2,$ino2) = stat ($dest);
 533
 534     return 0 if !($dev1 && $dev2 && $ino1 && $ino2);
 535
 536     return $ino1 == $ino2 && $dev1 == $dev2;
 537 }
 538
 539 sub find_stable_path {
 540     my ($stabledir, $bdev) = @_;
 541
 542     foreach my $path (<$stabledir/*>) {
 543         if (link_points_to ($path, $bdev)) {
 544             return wantarray ? ($path, basename($path)) : $path;
 545         }
 546     }
 547 }
 548
 549 sub find_dev_by_uuid {
 550     my $bdev = shift;
 551
 552     my ($full_path, $name) = find_stable_path ("/dev/disk/by-uuid", $bdev);
 553
 554     return $name;
 555 }
 556
 557 sub hd_list {
 558
 559     my $res = ();
 560
 561     if ($opt_testmode) {
 562         push @$res, [-1, $opt_testmode, int((-s $opt_testmode)/512), "TESTDISK"];
 563         return $res;
 564     }
 565
 566     my $count = 0;
 567
 568     foreach my $bd (</sys/block/*>) {
 569         next if $bd =~ m|^/sys/block/ram\d+$|;
 570         next if $bd =~ m|^/sys/block/loop\d+$|;
 571         next if $bd =~ m|^/sys/block/md\d+$|;
 572         next if $bd =~ m|^/sys/block/dm-.*$|;
 573         next if $bd =~ m|^/sys/block/fd\d+$|;
 574         next if $bd =~ m|^/sys/block/sr\d+$|;
 575
 576         my $dev = file_read_firstline("$bd/dev");
 577         chomp $dev;
 578
 579         next if !$dev;
 580
 581         my $info = `udevadm info --path $bd --query all`;
 582         next if !$info;
 583
 584         next if $info !~ m/^E: DEVTYPE=disk$/m;
 585
 586         next if $info =~ m/^E: ID_CDROM/m;
 587
 588         my ($name) = $info =~ m/^N: (\S+)$/m;
 589
 590         if ($name) {
 591             my $real_name = "/dev/$name";
 592
 593             my $size = file_read_firstline("$bd/size");
 594             chomp $size;
 595             $size = undef if !($size && $size =~ m/^\d+$/);
 596
 597             my $model = file_read_firstline("$bd/device/model") || '';
 598             $model =~ s/^\s+//;
 599             $model =~ s/\s+$//;
 600             if (length ($model) > 30) {
 601                 $model = substr ($model, 0, 30);
 602             }
 603             push @$res, [$count++, $real_name, $size, $model] if $size;
 604         } else {
 605             print STDERR "ERROR: unable to map device $dev ($bd)\n";
 606         }
 607     }
 608
 609     return $res;
 610 }
 611
 612 sub read_cmap {
 613     my $countryfn = "${proxmox_libdir}/country.dat";
 614     open (TMP, "<$countryfn") || die "unable to open '$countryfn' - $!\n";
 615     my $line;
 616     my $country = {};
 617     my $countryhash = {};
 618     my $kmap = {};
 619     my $kmaphash = {};
 620     while (defined ($line = <TMP>)) {
 621         if ($line =~ m|^map:([^\s:]+):([^:]+):([^:]+):([^:]+):([^:]+):([^:]*):$|) {
 622             $kmap->{$1} = {
 623                 name => $2,
 624                 kvm => $3,
 625                 console => $4,
 626                 x11 => $5,
 627                 x11var => $6,
 628             };
 629             $kmaphash->{$2} = $1;
 630         } elsif ($line =~ m|^([a-z]{2}):([^:]+):([^:]*):([^:]*):$|) {
 631             $country->{$1} = {
 632                 name => $2,
 633                 kmap => $3,
 634                 mirror => $4,
 635             };
 636             $countryhash->{lc($2)} = $1;
 637         } else {
 638             warn "unable to parse 'country.dat' line: $line";
 639         }
 640     }
 641     close (TMP);
 642
 643     my $zones = {};
 644     my $cczones = {};
 645     my $zonefn = "/usr/share/zoneinfo/zone.tab";
 646     open (TMP, "<$zonefn") || die "unable to open '$zonefn' - $!\n";
 647     while (defined ($line = <TMP>)) {
 648         next if $line =~ m/^\#/;
 649         next if $line =~ m/^\s*$/;
 650         if ($line =~ m|^([A-Z][A-Z])\s+\S+\s+(([^/]+)/\S+)\s|) {
 651             my $cc = lc($1);
 652             $cczones->{$cc}->{$2} = 1;
 653             $country->{$cc}->{zone} = $2 if !defined ($country->{$cc}->{zone});
 654             $zones->{$2} = 1;
 655
 656         }
 657     }
 658     close (TMP);
 659
 660     return {
 661         zones => $zones,
 662         cczones => $cczones,
 663         country => $country,
 664         countryhash => $countryhash,
 665         kmap => $kmap,
 666         kmaphash => $kmaphash,
 667     }
 668 }
 669
 670 # search for Harddisks
 671 my $hds = hd_list ();
 672
 673 sub hd_size {
 674     my ($dev) = @_;
 675
 676     foreach my $hd (@$hds) {
 677         my ($disk, $devname, $size, $model) = @$hd;
 678         # size is always in 512B "sectors"! convert to KB
 679         return int($size/2) if $devname eq $dev;
 680     }
 681
 682     die "no such device '$dev'\n";
 683 }
 684
 685 sub get_partition_dev {
 686     my ($dev, $partnum) = @_;
 687
 688     if ($dev =~ m|^/dev/sd([a-h]?[a-z]\|i[a-v])$|) {
 689         return "${dev}$partnum";
 690     } elsif ($dev =~ m|^/dev/[hxev]d[a-z]$|) {
 691         return "${dev}$partnum";
 692     } elsif ($dev =~ m|^/dev/[^/]+/c\d+d\d+$|) {
 693         return "${dev}p$partnum";
 694     } elsif ($dev =~ m|^/dev/[^/]+/d\d+$|) {
 695         return "${dev}p$partnum";
 696     } elsif ($dev =~ m|^/dev/[^/]+/hd[a-z]$|) {
 697         return "${dev}$partnum";
 698     } elsif ($dev =~ m|^/dev/nvme\d+n\d+$|) {
 699         return "${dev}p$partnum";
 700     } else {
 701         die "unable to get device for partition $partnum on device $dev\n";
 702     }
 703
 704 }
 705
 706 sub file_get_contents {
 707     my ($filename, $max) = @_;
 708
 709     my $fh = IO::File->new($filename, "r") ||
 710         die "can't open '$filename' - $!\n";
 711
 712     local $/; # slurp mode
 713
 714     my $content = <$fh>;
 715
 716     close $fh;
 717
 718     return $content;
 719 }
 720
 721 sub write_config {
 722     my ($text, $filename) = @_;
 723
 724     my $fd = IO::File->new (">$filename") ||
 725         die "unable to open file '$filename' - $!\n";
 726     print $fd $text;
 727     $fd->close();
 728 }
 729
 730 sub update_progress {
 731     my ($frac, $start, $end, $text) = @_;
 732
 733     my $part = $end - $start;
 734     my $res = $start + $frac*$part;
 735
 736     $progress->set_fraction ($res);
 737     $progress->set_text (sprintf ("%d%%", int ($res*100)));
 738     $progress_status->set_text ($text) if defined ($text);
 739
 740     display_info() if $res < 0.9;
 741
 742     Gtk3::main_iteration() while Gtk3::events_pending();
 743 }
 744
 745 my $fssetup = {
 746     ext3 => {
 747         mkfs => 'mkfs.ext3 -F',
 748         mkfs_root_opt => '',
 749         mkfs_data_opt => '-m 0',
 750         root_mountopt => 'errors=remount-ro',
 751     },
 752     ext4 => {
 753         mkfs => 'mkfs.ext4 -F',
 754         mkfs_root_opt => '',
 755         mkfs_data_opt => '-m 0',
 756         root_mountopt => 'errors=remount-ro',
 757     },
 758     xfs => {
 759         mkfs => 'mkfs.xfs -f',
 760         mkfs_root_opt => '',
 761         mkfs_data_opt => '',
 762         root_mountopt => '',
 763     },
 764 };
 765
 766 sub create_filesystem {
 767     my ($dev, $name, $type, $start, $end, $fs, $fe) = @_;
 768
 769     my $range = $end - $start;
 770     my $rs = $start + $range*$fs;
 771     my $re = $start + $range*$fe;
 772     my $max = 0;
 773
 774     my $fsdata = $fssetup->{$type} || die "internal error - unknown file system '$type'";
 775     my $opts = $name eq 'root' ? $fsdata->{mkfs_root_opt} : $fsdata->{mkfs_data_opt};
 776
 777     update_progress (0, $rs, $re, "creating $name filesystem");
 778
 779     run_command ("$fsdata->{mkfs} $opts $dev", sub {
 780         my $line = shift;
 781
 782         if ($line =~ m/Writing inode tables:\s+(\d+)\/(\d+)/) {
 783             $max = $2;
 784         } elsif ($max && $line =~ m/(\d+)\/$max/) {
 785             update_progress (($1/$max)*0.9, $rs, $re);
 786         } elsif ($line =~ m/Creating journal.*done/) {
 787             update_progress (0.95, $rs, $re);
 788         } elsif ($line =~ m/Writing superblocks and filesystem.*done/) {
 789             update_progress (1, $rs, $re);
 790         }
 791     });
 792 }
 793
 794 sub debconfig_set {
 795     my ($targetdir, $dcdata) = @_;
 796
 797     my $cfgfile = "/tmp/debconf.txt";
 798     write_config ($dcdata, "$targetdir/$cfgfile");
 799     syscmd ("chroot $targetdir debconf-set-selections $cfgfile");
 800     unlink "$targetdir/$cfgfile";
 801 }
 802
 803 sub diversion_add {
 804     my ($targetdir, $cmd, $new_cmd) = @_;
 805
 806     syscmd ("chroot $targetdir dpkg-divert --package proxmox " .
 807             "--add --rename $cmd") == 0 ||
 808             die "unable to exec dpkg-divert\n";
 809
 810     syscmd ("ln -sf ${new_cmd} $targetdir/$cmd") == 0 ||
 811         die "unable to link diversion to ${new_cmd}\n";
 812 }
 813
 814 sub diversion_remove {
 815     my  ($targetdir, $cmd) = @_;
 816
 817     syscmd ("mv $targetdir/${cmd}.distrib $targetdir/${cmd};") == 0 ||
 818         die "unable to remove $cmd diversion\n";
 819
 820     syscmd ("chroot $targetdir dpkg-divert --remove $cmd") == 0 ||
 821         die "unable to remove $cmd diversion\n";
 822 }
 823
 824 sub btrfs_create {
 825     my ($partitions, $mode) = @_;
 826
 827     die "unknown btrfs mode '$mode'"
 828         if !($mode eq 'single' || $mode eq 'raid0' ||
 829              $mode eq 'raid1' || $mode eq 'raid10');
 830
 831     my $cmd = ['mkfs.btrfs', '-f'];
 832
 833     push @$cmd, '-d', $mode, '-m', $mode;
 834
 835     push @$cmd, @$partitions;
 836
 837     syscmd($cmd);
 838 }
 839
 840 sub zfs_create_rpool {
 841     my ($vdev) = @_;
 842
 843     my $cmd = "zpool create -f -o cachefile=none";
 844
 845     $cmd .= " -o ashift=$config_options->{ashift}"
 846         if defined($config_options->{ashift});
 847
 848     syscmd ("$cmd $zfspoolname $vdev") == 0 ||
 849         die "unable to create zfs root pool\n";
 850
 851     syscmd ("zfs create $zfspoolname/ROOT")  == 0 ||
 852         die "unable to create zfs $zfspoolname/ROOT volume\n";
 853
 854     if ($setup->{product} eq 'pve') {
 855         syscmd ("zfs create $zfspoolname/data")  == 0 ||
 856             die "unable to create zfs $zfspoolname/data volume\n";
 857     }
 858
 859     syscmd ("zfs create $zfspoolname/ROOT/$zfsrootvolname")  == 0 ||
 860         die "unable to create zfs $zfspoolname/ROOT/$zfsrootvolname volume\n";
 861
 862     # disable atime during install
 863     syscmd ("zfs set atime=off $zfspoolname") == 0 ||
 864         die "unable to set zfs properties\n";
 865
 866     my $value = $config_options->{compress};
 867     syscmd ("zfs set compression=$value $zfspoolname")
 868         if defined($value) && $value ne 'off';
 869
 870     $value = $config_options->{checksum};
 871     syscmd ("zfs set checksum=$value $zfspoolname")
 872         if defined($value) && $value ne 'on';
 873
 874     $value = $config_options->{copies};
 875     syscmd ("zfs set copies=$value $zfspoolname")
 876         if defined($value) && $value != 1;
 877 }
 878
 879 my $udevadm_trigger_block = sub {
 880     my ($nowait) = @_;
 881
 882     sleep(1) if !$nowait; # give kernel time to reread part table
 883
 884     # trigger udev to create /dev/disk/by-uuid
 885     syscmd ("udevadm trigger --subsystem-match block");
 886     syscmd ("udevadm settle --timeout 10");
 887 };
 888
 889 my $clean_disk = sub {
 890     my ($disk) = @_;
 891
 892     my $partitions = `lsblk --output kname --noheadings --path --list $disk`;
 893     foreach my $part (split "\n", $partitions) {
 894         next if $part eq $disk;
 895         next if $part !~ /^\Q$disk\E/;
 896         eval { syscmd("pvremove -ff -y $part"); };
 897         eval { syscmd("dd if=/dev/zero of=$part bs=1M count=16"); };
 898     }
 899 };
 900
 901 sub partition_bootable_disk {
 902     my ($target_dev, $maxhdsizegb, $ptype) = @_;
 903
 904     die "too dangerous" if $opt_testmode;
 905
 906     die "unknown partition type '$ptype'"
 907         if !($ptype eq '8E00' || $ptype eq '8300' || $ptype eq 'BF01');
 908
 909     syscmd("sgdisk -Z ${target_dev}");
 910     my $hdsize = hd_size($target_dev); # size in KB (1024 bytes)
 911
 912     my $restricted_hdsize_mb = 0; # 0 ==> end of partition
 913     if ($maxhdsizegb) {
 914         my $maxhdsize = $maxhdsizegb * 1024 * 1024;
 915         if ($maxhdsize < $hdsize) {
 916             $hdsize = $maxhdsize;
 917             $restricted_hdsize_mb = int($hdsize/1024) . 'M';
 918         }
 919     }
 920
 921     my $hdgb = int($hdsize/(1024*1024));
 922     die "hardisk '$target_dev' too small (${hdgb}GB)\n" if $hdgb < 8;
 923
 924     # 1 - BIOS boot partition (Grub Stage2): first free 1M
 925     # 2 - EFI ESP: next free 512M
 926     # 3 - OS/Data partition: rest, up to $maxhdsize in MB
 927
 928     my $grubbootdev = get_partition_dev($target_dev, 1);
 929     my $efibootdev = get_partition_dev($target_dev, 2);
 930     my $osdev = get_partition_dev ($target_dev, 3);
 931
 932     my $pcmd = ['sgdisk'];
 933
 934     my $pnum = 2;
 935     push @$pcmd, "-n${pnum}:1M:+512M", "-t$pnum:EF00";
 936
 937     $pnum = 3;
 938     push @$pcmd, "-n${pnum}:513M:${restricted_hdsize_mb}", "-t$pnum:$ptype";
 939
 940     push @$pcmd, $target_dev;
 941
 942     my $os_size = $hdsize - 513*1024; # 512M efi + 1M bios_boot + 1M alignment
 943
 944     syscmd($pcmd) == 0 ||
 945         die "unable to partition harddisk '${target_dev}'\n";
 946
 947     $pnum = 1;
 948     $pcmd = ['sgdisk', '-a1', "-n$pnum:34:2047", "-t$pnum:EF02" , $target_dev];
 949
 950     syscmd($pcmd) == 0 ||
 951         die "unable to create bios_boot partition '${target_dev}'\n";
 952
 953     &$udevadm_trigger_block();
 954
 955     foreach my $part ($efibootdev, $osdev) {
 956         syscmd("dd if=/dev/zero of=$part bs=1M count=256") if -b $part;
 957     }
 958
 959     return ($os_size, $osdev, $efibootdev);
 960 }
 961
 962 sub create_lvm_volumes {
 963     my ($lvmdev, $os_size, $swap_size) = @_;
 964
 965     my $vgname = $setup->{product};
 966
 967     my $rootdev = "/dev/$vgname/root";
 968     my $datadev = "/dev/$vgname/data";
 969     my $swapfile;
 970
 971     # we use --metadatasize 250k, which results in "pe_start = 512"
 972     # so pe_start is aligned on a 128k boundary (advantage for SSDs)
 973     syscmd ("/sbin/pvcreate --metadatasize 250k -y -ff $lvmdev") == 0 ||
 974         die "unable to initialize physical volume $lvmdev\n";
 975     syscmd ("/sbin/vgcreate $vgname $lvmdev") == 0 ||
 976         die "unable to create volume group '$vgname'\n";
 977
 978     my $hdgb = int($os_size/(1024*1024));
 979     my $space = (($hdgb > 128) ? 16 : ($hdgb/8))*1024*1024;
 980
 981     my $rootsize;
 982     my $datasize;
 983
 984     if ($setup->{product} eq 'pve') {
 985
 986         my $maxroot;
 987         if ($config_options->{maxroot}) {
 988             $maxroot = $config_options->{maxroot};
 989         } else {
 990             $maxroot = 96;
 991         }
 992
 993         $rootsize = (($hdgb > ($maxroot*4)) ? $maxroot : $hdgb/4)*1024*1024;
 994
 995         my $rest = $os_size - $swap_size - $rootsize; # in KB
 996
 997         my $minfree;
 998         if (defined($config_options->{minfree})) {
 999             $minfree = (($config_options->{minfree}*1024*1024) >= $rest ) ? $space :
1000                 $config_options->{minfree}*1024*1024 ;
1001         } else {
1002             $minfree = $space;
1003         }
1004
1005         $rest = $rest - $minfree;
1006
1007         if (defined($config_options->{maxvz})) {
1008             $rest = (($config_options->{maxvz}*1024*1024) <= $rest) ?
1009                 $config_options->{maxvz}*1024*1024 : $rest;
1010         }
1011
1012         $datasize = $rest;
1013
1014     } else {
1015         my $minfree = defined($config_options->{minfree}) ? $config_options->{minfree}*1024*1024 : $space;
1016         $rootsize = $os_size - $minfree - $swap_size; # in KB
1017     }
1018
1019     if ($swap_size) {
1020         syscmd ("/sbin/lvcreate -L${swap_size}K -nswap $vgname") == 0 ||
1021             die "unable to create swap volume\n";
1022
1023         $swapfile = "/dev/$vgname/swap";
1024     }
1025
1026     syscmd ("/sbin/lvcreate -L${rootsize}K -nroot $vgname") == 0 ||
1027         die "unable to create root volume\n";
1028
1029     if ($datasize > 4*1024*1024) {
1030         my $metadatasize = $datasize/100; # default 1% of data
1031         $metadatasize = 1024*1024 if $metadatasize < 1024*1024; # but at least 1G
1032         $metadatasize = 16*1024*1024 if $metadatasize > 16*1024*1024; # but at most 16G
1033
1034         # otherwise the metadata is taken out of $minfree
1035         $datasize -= 2*$metadatasize;
1036
1037         # 1 4MB PE to allow for rounding
1038         $datasize -= 4*1024;
1039
1040         syscmd ("/sbin/lvcreate -L${datasize}K -ndata $vgname") == 0 ||
1041             die "unable to create data volume\n";
1042
1043         syscmd ("/sbin/lvconvert --yes --type thin-pool --poolmetadatasize ${metadatasize}K $vgname/data") == 0 ||
1044             die "unable to create data thin-pool\n";
1045     } else {
1046         $datadev = undef;
1047     }
1048
1049     syscmd ("/sbin/vgchange -a y $vgname") == 0 ||
1050         die "unable to activate volume group\n";
1051
1052     return ($rootdev, $swapfile, $datadev);
1053 }
1054
1055 sub compute_swapsize {
1056     my ($hdsize) = @_;
1057
1058     my $hdgb = int($hdsize/(1024*1024));
1059
1060     my $swapsize;
1061     if (defined($config_options->{swapsize})) {
1062         $swapsize = $config_options->{swapsize}*1024*1024;
1063     } else {
1064         my $ss = int ($total_memory / 1024);
1065         $ss = 4 if $ss < 4;
1066         $ss = ($hdgb/8) if $ss > ($hdgb/8);
1067         $ss = 8 if $ss > 8;
1068         $swapsize = $ss*1024*1024;
1069     }
1070
1071     return $swapsize;
1072 }
1073
1074
1075 sub extract_data {
1076     my ($basefile, $targetdir) = @_;
1077
1078     die "target '$targetdir' does not exist\n" if ! -d  $targetdir;
1079
1080     my $starttime = [Time::HiRes::gettimeofday];
1081
1082     my $bootdevinfo = [];
1083
1084     my $swapfile;
1085     my $rootdev;
1086     my $datadev;
1087
1088     my $use_zfs = 0;
1089     my $use_btrfs = 0;
1090
1091     my $filesys = $config_options->{filesys};
1092
1093     if ($filesys =~ m/zfs/) {
1094         $target_hd = undef; # do not use this config
1095         $use_zfs = 1;
1096         $targetdir = "/$zfspoolname/ROOT/$zfsrootvolname";
1097     } elsif ($filesys =~ m/btrfs/) {
1098         $target_hd = undef; # do not use this config
1099         $use_btrfs = 1;
1100     }
1101
1102     if ($use_zfs) {
1103         my $i;
1104         for ($i = 5; $i > 0; $i--) {
1105             syscmd("modprobe zfs");
1106             last if -c "/dev/zfs";
1107             sleep(1);
1108         }
1109
1110         die "unable to load zfs kernel module\n" if !$i;
1111     }
1112
1113     eval {
1114
1115
1116         my $maxper = 0.25;
1117
1118         update_progress (0, 0, $maxper, "create partitions");
1119
1120         syscmd("vgchange -an") if !$opt_testmode; # deactivate all detected VGs
1121
1122         if ($opt_testmode) {
1123
1124             $rootdev = abs_path($opt_testmode);
1125             syscmd("umount $rootdev");
1126
1127             if ($use_btrfs) {
1128
1129                 die "unsupported btrfs mode (for testing environment)\n"
1130                     if $filesys ne 'btrfs (RAID0)';
1131
1132                 btrfs_create([$rootdev], 'single');
1133
1134             } elsif ($use_zfs) {
1135
1136                 die "unsupported zfs mode (for testing environment)\n"
1137                     if $filesys ne 'zfs (RAID0)';
1138
1139                 syscmd ("zpool destroy $zfstestpool");
1140
1141                 zfs_create_rpool($rootdev);
1142
1143             } else {
1144
1145                 # nothing to do
1146             }
1147
1148         } elsif ($use_btrfs) {
1149
1150             my ($devlist, $btrfs_mode) = get_btrfs_raid_setup();
1151             my $btrfs_partitions = [];
1152             my $disksize;
1153             foreach my $hd (@$devlist) {
1154                 my $devname = @$hd[1];
1155                 &$clean_disk($devname);
1156                 my ($size, $osdev, $efidev) =
1157                     partition_bootable_disk($devname, undef, '8300');
1158                 $rootdev = $osdev if !defined($rootdev); # simply point to first disk
1159                 my $by_id = find_stable_path("/dev/disk/by-id", $devname);
1160                 push @$bootdevinfo, { esp => $efidev, devname => $devname,
1161                                       osdev => $osdev, by_id => $by_id };
1162                 push @$btrfs_partitions, $osdev;
1163                 $disksize = $size;
1164             }
1165
1166             &$udevadm_trigger_block();
1167
1168             btrfs_create($btrfs_partitions, $btrfs_mode);
1169
1170         } elsif ($use_zfs) {
1171
1172             my ($devlist, $bootdevlist, $vdev) = get_zfs_raid_setup();
1173
1174             my $disksize;
1175             foreach my $hd (@$devlist) {
1176                 &$clean_disk(@$hd[1]);
1177             }
1178             foreach my $hd (@$bootdevlist) {
1179                 my $devname = @$hd[1];
1180
1181                 my ($size, $osdev) =
1182                     partition_bootable_disk($devname, $config_options->{hdsize}, 'BF01');
1183                 zfs_mirror_size_check($disksize, $size) if $disksize;
1184                 push @$bootdevinfo, { devname => $devname, osdev => $osdev};
1185                 $disksize = $size;
1186             }
1187
1188             &$udevadm_trigger_block();
1189
1190             foreach my $di (@$bootdevinfo) {
1191                 my $devname = $di->{devname};
1192                 $di->{by_id} = find_stable_path ("/dev/disk/by-id", $devname);
1193
1194                 # Note: using /dev/disk/by-id/ does not work for unknown reason, we get
1195                 # cannot create 'rpool': no such pool or dataset
1196                 #my $osdev = find_stable_path ("/dev/disk/by-id", $di->{osdev}) || $di->{osdev};
1197
1198                 my $osdev = $di->{osdev};
1199                 $vdev =~ s/ $devname/ $osdev/;
1200             }
1201
1202             zfs_create_rpool($vdev);
1203
1204         } else {
1205
1206             die "target '$target_hd' is not a valid block device\n" if ! -b $target_hd;
1207
1208             &$clean_disk($target_hd);
1209
1210             my ($os_size, $osdev, $efidev);
1211             ($os_size, $osdev, $efidev) =
1212                 partition_bootable_disk($target_hd, $config_options->{hdsize}, '8E00');
1213
1214             &$udevadm_trigger_block();
1215
1216             my $by_id = find_stable_path ("/dev/disk/by-id", $target_hd);
1217             push @$bootdevinfo, { esp => $efidev, devname => $target_hd,
1218                                   osdev => $osdev, by_id => $by_id };
1219
1220             my $swap_size = compute_swapsize($os_size);
1221             ($rootdev, $swapfile, $datadev) =
1222                 create_lvm_volumes($osdev, $os_size, $swap_size);
1223
1224             # trigger udev to create /dev/disk/by-uuid
1225             &$udevadm_trigger_block(1);
1226         }
1227
1228         if ($use_zfs) {
1229             # to be fast during installation
1230             syscmd ("zfs set sync=disabled $zfspoolname") == 0 ||
1231                 die "unable to set zfs properties\n";
1232         }
1233
1234         update_progress (0.03, 0, $maxper, "create swap space");
1235         if ($swapfile) {
1236             syscmd ("mkswap -f $swapfile") == 0 ||
1237                 die "unable to create swap space\n";
1238         }
1239
1240         update_progress (0.05, 0, $maxper, "creating filesystems");
1241
1242         foreach my $di (@$bootdevinfo) {
1243             next if !$di->{esp};
1244             syscmd ("mkfs.vfat -F32 $di->{esp}") == 0 ||
1245                 die "unable to initialize EFI ESP on device $di->{esp}\n";
1246         }
1247
1248         if ($use_zfs) {
1249             # do nothing
1250         } elsif ($use_btrfs) {
1251             # do nothing
1252         } else {
1253             create_filesystem ($rootdev, 'root', $filesys, 0.05, $maxper, 0, 1);
1254         }
1255
1256         update_progress (1, 0.05, $maxper, "mounting target $rootdev");
1257
1258         if ($use_zfs) {
1259             # do nothing
1260         } else {
1261             my $mount_opts = 'noatime';
1262             $mount_opts .= ',nobarrier'
1263                 if $use_btrfs || $filesys =~ /^ext\d$/;
1264
1265             syscmd("mount -n $rootdev -o $mount_opts $targetdir") == 0 ||
1266                 die "unable to mount $rootdev\n";
1267         }
1268
1269         mkdir "$targetdir/boot";
1270         mkdir "$targetdir/boot/efi";
1271
1272         mkdir "$targetdir/var";
1273         mkdir "$targetdir/var/lib";
1274
1275         if ($setup->{product} eq 'pve') {
1276             mkdir "$targetdir/var/lib/vz";
1277             mkdir "$targetdir/var/lib/pve";
1278
1279             if ($use_btrfs) {
1280                 syscmd("btrfs subvolume create $targetdir/var/lib/pve/local-btrfs") == 0 ||
1281                     die "unable to create btrfs subvolume\n";
1282             }
1283         }
1284
1285         update_progress (1, 0.05, $maxper, "extracting base system");
1286
1287         my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size) = stat ($basefile);
1288         $ino || die "unable to open file '$basefile' - $!\n";
1289
1290         my $files = file_read_firstline("${proxmox_cddir}/proxmox/$setup->{product}-base.cnt") ||
1291             die "unable to read base file count\n";
1292
1293         my $per = 0;
1294         my $count = 0;
1295
1296         run_command ("unsquashfs -f -dest $targetdir -i $basefile", sub {
1297             my $line = shift;
1298             return if $line !~ m/^$targetdir/;
1299             $count++;
1300             my $nper = int (($count *100)/$files);
1301             if ($nper != $per) {
1302                 $per = $nper;
1303                 my $frac = $per > 100 ? 1 : $per/100;
1304                 update_progress ($frac, $maxper, 0.5);
1305             }
1306         });
1307
1308         syscmd ("mount -n -t tmpfs tmpfs $targetdir/tmp") == 0 ||
1309             die "unable to mount tmpfs on $targetdir/tmp\n";
1310         syscmd ("mount -n -t proc proc $targetdir/proc") == 0 ||
1311             die "unable to mount proc on $targetdir/proc\n";
1312         syscmd ("mount -n -t sysfs sysfs $targetdir/sys") == 0 ||
1313             die "unable to mount sysfs on $targetdir/sys\n";
1314
1315         update_progress (1, $maxper, 0.5, "configuring base system");
1316
1317         # configure hosts
1318
1319         my $hosts =
1320             "127.0.0.1 localhost.localdomain localhost\n" .
1321             "$ipaddress $hostname.$domain $hostname\n\n" .
1322             "# The following lines are desirable for IPv6 capable hosts\n\n" .
1323             "::1     ip6-localhost ip6-loopback\n" .
1324             "fe00::0 ip6-localnet\n" .
1325             "ff00::0 ip6-mcastprefix\n" .
1326             "ff02::1 ip6-allnodes\n" .
1327             "ff02::2 ip6-allrouters\n" .
1328             "ff02::3 ip6-allhosts\n";
1329
1330         write_config ($hosts, "$targetdir/etc/hosts");
1331
1332         write_config ("$hostname\n", "$targetdir/etc/hostname");
1333
1334         syscmd ("/bin/hostname $hostname") if !$opt_testmode;
1335
1336         # configure interfaces
1337
1338         my $ifaces = "auto lo\niface lo inet loopback\n\n";
1339
1340         my $ntype = $ipversion == 4 ? 'inet' : 'inet6';
1341
1342         my $ethdev = $ipconf->{ifaces}->{$ipconf->{selected}}->{name};
1343
1344         if ($setup->{bridged_network}) {
1345             $ifaces .= "iface $ethdev $ntype manual\n";
1346
1347             $ifaces .=
1348                 "\nauto vmbr0\niface vmbr0 $ntype static\n" .
1349                 "\taddress $ipaddress\n" .
1350                 "\tnetmask $netmask\n" .
1351                 "\tgateway $gateway\n" .
1352                 "\tbridge_ports $ethdev\n" .
1353                 "\tbridge_stp off\n" .
1354                 "\tbridge_fd 0\n";
1355         } else {
1356             $ifaces .= "auto $ethdev\n" .
1357                 "iface $ethdev $ntype static\n" .
1358                 "\taddress $ipaddress\n" .
1359                 "\tnetmask $netmask\n" .
1360                 "\tgateway $gateway\n";
1361         }
1362
1363         foreach my $iface (sort keys %{$ipconf->{ifaces}}) {
1364             my $name = $ipconf->{ifaces}->{$iface}->{name};
1365             next if $name eq $ethdev;
1366
1367             $ifaces .= "\niface $name $ntype manual\n";
1368         }
1369
1370         write_config ($ifaces, "$targetdir/etc/network/interfaces");
1371
1372         # configure dns
1373
1374         my $resolvconf = "search $domain\nnameserver $dnsserver\n";
1375         write_config ($resolvconf, "$targetdir/etc/resolv.conf");
1376
1377         # configure fstab
1378
1379         my $fstab = "# <file system> <mount point> <type> <options> <dump> <pass>\n";
1380
1381         if ($use_zfs) {
1382             # do nothing
1383         } elsif ($use_btrfs) {
1384             my $fsuuid;
1385             my $cmd = "blkid -u filesystem -t TYPE=btrfs -o export $rootdev";
1386             run_command($cmd, sub {
1387                 my $line = shift;
1388
1389                 if ($line =~ m/^UUID=([A-Fa-f0-9\-]+)$/) {
1390                     $fsuuid = $1;
1391                 }
1392             });
1393
1394             die "unable to detect FS UUID" if !defined($fsuuid);
1395
1396             $fstab .= "UUID=$fsuuid / btrfs defaults 0 1\n";
1397         } else {
1398             my $root_mountopt = $fssetup->{$filesys}->{root_mountopt} || 'defaults';
1399             $fstab .= "$rootdev / $filesys ${root_mountopt} 0 1\n";
1400         }
1401
1402         # mount /boot/efi
1403         # Note: this is required by current grub, but really dangerous, because
1404         # vfat does not have journaling, so it triggers manual fsck after each crash
1405         # so we only mount /boot/efi if really required (efi systems).
1406         if ($grub_plattform =~ m/^efi-/) {
1407             if (scalar(@$bootdevinfo)) {
1408                 my $di = @$bootdevinfo[0]; # simply use first disk
1409                 if ($di->{esp}) {
1410                     my $efi_boot_uuid = $di->{esp};
1411                     if (my $uuid = find_dev_by_uuid ($di->{esp})) {
1412                         $efi_boot_uuid = "UUID=$uuid";
1413                     }
1414
1415                     $fstab .= "${efi_boot_uuid} /boot/efi vfat defaults 0 1\n";
1416                 }
1417             }
1418         }
1419
1420
1421         $fstab .= "$swapfile none swap sw 0 0\n" if $swapfile;
1422
1423         $fstab .= "proc /proc proc defaults 0 0\n";
1424
1425         write_config ($fstab, "$targetdir/etc/fstab");
1426         write_config ("", "$targetdir/etc/mtab");
1427
1428         syscmd ("cp ${proxmox_libdir}/policy-disable-rc.d " .
1429                 "$targetdir/usr/sbin/policy-rc.d") == 0 ||
1430                 die "unable to copy policy-rc.d\n";
1431         syscmd ("cp ${proxmox_libdir}/fake-start-stop-daemon " .
1432                 "$targetdir/sbin/") == 0 ||
1433                 die "unable to copy start-stop-daemon\n";
1434
1435         diversion_add ($targetdir, "/sbin/start-stop-daemon", "/sbin/fake-start-stop-daemon");
1436         diversion_add ($targetdir, "/usr/sbin/update-grub", "/bin/true");
1437         diversion_add ($targetdir, "/usr/sbin/update-initramfs", "/bin/true");
1438
1439         syscmd ("touch  $targetdir/proxmox_install_mode");
1440
1441         my $grub_install_devices_txt = '';
1442         foreach my $di (@$bootdevinfo) {
1443             $grub_install_devices_txt .= ', ' if $grub_install_devices_txt;
1444             $grub_install_devices_txt .= $di->{by_id} || $di->{devname};
1445         }
1446
1447         # Note: keyboard-configuration/xbkb-keymap is used by console-setup
1448         my $xkmap = $cmap->{kmap}->{$keymap}->{x11} // 'us';
1449
1450         debconfig_set ($targetdir, <<_EOD);
1451 locales locales/default_environment_locale select en_US.UTF-8
1452 locales locales/locales_to_be_generated select en_US.UTF-8 UTF-8
1453 samba-common samba-common/dhcp boolean false
1454 samba-common samba-common/workgroup string WORKGROUP
1455 postfix postfix/main_mailer_type select No configuration
1456 keyboard-configuration keyboard-configuration/xkb-keymap select $xkmap
1457 d-i debian-installer/locale select en_US.UTF-8
1458 grub-pc grub-pc/install_devices select $grub_install_devices_txt
1459 _EOD
1460
1461         my $pkg_count = 0;
1462         while (<${proxmox_pkgdir}/*.deb>) { $pkg_count++ };
1463
1464         # btrfs/dpkg is extremely slow without --force-unsafe-io
1465         my $dpkg_opts = $use_btrfs ? "--force-unsafe-io" : "";
1466
1467         $count = 0;
1468         while (<${proxmox_pkgdir}/*.deb>) {
1469             chomp;
1470             my $path = $_;
1471             my ($deb) = $path =~ m/${proxmox_pkgdir}\/(.*\.deb)/;
1472 #           if ($deb =~ m/^grub-efi-/ && $deb !~ m/^grub-${grub_plattform}/) {
1473 #               $count++;
1474 #               next;
1475 #           }
1476             update_progress ($count/$pkg_count, 0.5, 0.75, "extracting $deb");
1477             print "extracting: $deb\n";
1478             syscmd ("cp $path $targetdir/tmp/$deb") == 0 ||
1479                 die "installation of package $deb failed\n";
1480             syscmd ("chroot $targetdir dpkg $dpkg_opts --force-depends --no-triggers --unpack /tmp/$deb") == 0 ||
1481                 die "installation of package $deb failed\n";
1482             update_progress ((++$count)/$pkg_count, 0.5, 0.75);
1483         }
1484
1485         # needed for postfix postinst in case no other NIC is active
1486         syscmd("chroot $targetdir ifup lo");
1487
1488         my $cmd = "chroot $targetdir dpkg $dpkg_opts --force-confold --configure -a";
1489         $count = 0;
1490         run_command ($cmd, sub {
1491             my $line = shift;
1492             if ($line =~ m/Setting up\s+(\S+)/) {
1493                 update_progress ((++$count)/$pkg_count, 0.75, 0.95,
1494                                  "configuring $1");
1495             }
1496         });
1497
1498         unlink "$targetdir/etc/mailname";
1499         $postfix_main_cf =~ s/__FQDN__/${hostname}.${domain}/;
1500         write_config ($postfix_main_cf, "$targetdir/etc/postfix/main.cf");
1501
1502         # make sure we have all postfix directories
1503         syscmd ("chroot $targetdir /usr/sbin/postfix check");
1504         # cleanup mail queue
1505         syscmd ("chroot $targetdir /usr/sbin/postsuper -d ALL");
1506
1507         # enable NTP (timedatectl set-ntp true  does not work without DBUS)
1508         syscmd ("chroot $targetdir /bin/systemctl enable systemd-timesyncd.service");
1509
1510         unlink  "$targetdir/proxmox_install_mode";
1511
1512         # set timezone
1513         unlink ("$targetdir/etc/localtime");
1514         symlink ("/usr/share/zoneinfo/$timezone", "$targetdir/etc/localtime");
1515         write_config ("$timezone\n", "$targetdir/etc/timezone");
1516
1517         # set apt mirror
1518         if (my $mirror = $cmap->{country}->{$country}->{mirror}) {
1519             my $fn = "$targetdir/etc/apt/sources.list";
1520             syscmd ("sed -i 's/ftp\\.debian\\.org/$mirror/' '$fn'");
1521         }
1522
1523         # create extended_states for apt (avoid cron job warning if that
1524         # file does not exist)
1525         write_config ('', "$targetdir/var/lib/apt/extended_states");
1526
1527         # allow ssh root login
1528         syscmd(['sed', '-i', 's/^#\?PermitRootLogin.*/PermitRootLogin yes/', "$targetdir/etc/ssh/sshd_config"]);
1529
1530         if ($setup->{product} eq 'pmg') {
1531             # install initial clamav DB
1532             my $srcdir = "${proxmox_cddir}/proxmox/clamav";
1533             foreach my $fn ("main.cvd", "bytecode.cvd", "daily.cvd", "safebrowsing.cvd") {
1534                 syscmd ("cp \"$srcdir/$fn\" \"$targetdir/var/lib/clamav\"") == 0 ||
1535                     die "installation of clamav db file '$fn' failed\n";
1536             }
1537             syscmd("chroot $targetdir /bin/chown clamav:clamav -R /var/lib/clamav") == 0 ||
1538                 die "unable to set owner for clamav database files\n";
1539         }
1540
1541         if ($setup->{product} eq 'pve') {
1542             # save installer settings
1543             my $ucc = uc ($country);
1544             debconfig_set($targetdir, "pve-manager pve-manager/country string $ucc\n");
1545         }
1546
1547         update_progress (0.8, 0.95, 1, "make system bootable");
1548
1549         if ($use_zfs) {
1550             syscmd ("sed -i -e 's/^GRUB_CMDLINE_LINUX=.*/GRUB_CMDLINE_LINUX=\"root=ZFS=$zfspoolname\\/ROOT\\/$zfsrootvolname boot=zfs\"/' $targetdir/etc/default/grub") == 0 ||
1551                 die "unable to update /etc/default/grub\n";
1552
1553         }
1554
1555         diversion_remove ($targetdir, "/usr/sbin/update-grub");
1556         diversion_remove ($targetdir, "/usr/sbin/update-initramfs");
1557
1558         my $kapi;
1559         foreach my $fn (<$targetdir/lib/modules/*>) {
1560             if ($fn =~ m!/(\d+\.\d+\.\d+-\d+-pve)$!) {
1561                 die "found multiple kernels\n" if defined($kapi);
1562                 $kapi = $1;
1563             }
1564         }
1565         die "unable to detect kernel version\n" if !defined($kapi);
1566
1567         if (!$opt_testmode) {
1568
1569             unlink ("$targetdir/etc/mtab");
1570             symlink ("/proc/mounts", "$targetdir/etc/mtab");
1571             syscmd ("mount -n --bind /dev $targetdir/dev");
1572
1573             syscmd ("chroot $targetdir /usr/sbin/update-initramfs -c -k $kapi") == 0 ||
1574                 die "unable to install initramfs\n";
1575
1576             foreach my $di (@$bootdevinfo) {
1577                 my $dev = $di->{devname};
1578                 syscmd ("chroot $targetdir /usr/sbin/grub-install --target i386-pc --no-floppy --bootloader-id='proxmox' $dev") == 0 ||
1579                         die "unable to install the i386-pc boot loader on '$dev'\n";
1580
1581                 if ($di->{esp}) {
1582                     syscmd ("mount -n $di->{esp} -t vfat $targetdir/boot/efi") == 0 ||
1583                         die "unable to mount $di->{esp}\n";
1584                     my $rc = syscmd ("chroot $targetdir /usr/sbin/grub-install --target x86_64-efi --no-floppy --bootloader-id='proxmox' $dev");
1585                     if ($rc != 0) {
1586                         if (-d '/sys/firmware/efi') {
1587                             die "unable to install the EFI boot loader on '$dev'\n";
1588                         } else {
1589                             warn "unable to install the EFI boot loader on '$dev', ignoring (not booted using UEFI)\n";
1590                         }
1591                     }
1592                     # also install fallback boot file (OVMF does not boot without)
1593                     mkdir("$targetdir/boot/efi/EFI/BOOT");
1594                     syscmd("cp $targetdir/boot/efi/EFI/proxmox/grubx64.efi $targetdir/boot/efi/EFI/BOOT/BOOTx64.EFI") == 0 ||
1595                         die "unable to copy efi boot loader\n";
1596
1597                     syscmd ("umount $targetdir/boot/efi") == 0 ||
1598                         die "unable to umount $targetdir/boot/efi\n";
1599                 }
1600             }
1601
1602             syscmd ("chroot $targetdir /usr/sbin/update-grub") == 0 ||
1603                 die "unable to update boot loader config\n";
1604
1605             syscmd ("umount $targetdir/dev");
1606         }
1607
1608         # cleanup
1609
1610         # hack: remove dead.letter from sshd installation
1611         syscmd ("rm -rf $targetdir/dead.letter");
1612
1613         unlink "$targetdir/usr/sbin/policy-rc.d";
1614
1615         diversion_remove ($targetdir, "/sbin/start-stop-daemon");
1616
1617         # set root password
1618         my $octets = encode("utf-8", $password);
1619         run_command ("chroot $targetdir /usr/sbin/chpasswd", undef,
1620                      "root:$octets\n");
1621
1622         if ($setup->{product} eq 'pmg') {
1623             # save admin email
1624             write_config ("section: admin\n\temail ${mailto}\n",
1625                           "$targetdir/etc/pmg/pmg.conf");
1626
1627         } elsif ($setup->{product} eq 'pve') {
1628
1629             # create pmxcfs DB
1630
1631             my $tmpdir = "$targetdir/tmp/pve";
1632             mkdir $tmpdir;
1633
1634             # write vnc keymap to datacenter.cfg
1635             my $vnckmap = $cmap->{kmap}->{$keymap}->{kvm} || 'en-us';
1636             write_config ("keyboard: $vnckmap\n",
1637                           "$tmpdir/datacenter.cfg");
1638
1639             # save admin email
1640             write_config ("user:root\@pam:1:0:::${mailto}::\n",
1641                           "$tmpdir/user.cfg");
1642
1643             # write storage.cfg
1644             my $storage_cfg_fn = "$tmpdir/storage.cfg";
1645             if ($use_zfs) {
1646                 write_config ($storage_cfg_zfs, $storage_cfg_fn);
1647             } elsif ($use_btrfs) {
1648                 write_config ($storage_cfg_btrfs, $storage_cfg_fn);
1649             } elsif ($datadev) {
1650                 write_config ($storage_cfg_lvmthin, $storage_cfg_fn);
1651             } else {
1652                 write_config ($storage_cfg_local, $storage_cfg_fn);
1653             }
1654
1655             run_command("chroot $targetdir /usr/bin/create_pmxcfs_db /tmp/pve /var/lib/pve-cluster/config.db");
1656
1657             syscmd ("rm -rf $tmpdir");
1658         }
1659     };
1660
1661     my $err = $@;
1662
1663     update_progress (1, 0, 1, "");
1664
1665     print $err if $err;
1666
1667     if ($opt_testmode) {
1668         my $elapsed = Time::HiRes::tv_interval($starttime);
1669         print "Elapsed extract time: $elapsed\n";
1670
1671         syscmd ("chroot $targetdir /usr/bin/dpkg-query -W --showformat='\${package}\n'> final.pkglist");
1672     }
1673
1674     syscmd ("umount $targetdir/tmp");
1675     syscmd ("umount $targetdir/proc");
1676     syscmd ("umount $targetdir/sys");
1677
1678     if ($use_zfs) {
1679         syscmd ("zfs umount -a") == 0 ||
1680             die "unable to unmount zfs\n";
1681     } else {
1682         syscmd ("umount -d $targetdir");
1683     }
1684
1685     if (!$err && $use_zfs) {
1686         syscmd ("zfs set sync=standard $zfspoolname") == 0 ||
1687             die "unable to set zfs properties\n";
1688
1689         syscmd ("zfs set mountpoint=/ $zfspoolname/ROOT/$zfsrootvolname") == 0 ||
1690             die "zfs set mountpoint failed\n";
1691
1692         syscmd ("zpool set bootfs=$zfspoolname/ROOT/$zfsrootvolname $zfspoolname")  == 0 ||
1693             die "zfs set bootfs failed\n";
1694         syscmd ("zpool export $zfspoolname");
1695     }
1696
1697     die $err if $err;
1698 }
1699
1700 my $last_display_change = 0;
1701
1702 my $display_info_counter = 0;
1703
1704 my $display_info_items = [
1705     "extract1-license.htm",
1706     "extract2-rulesystem.htm",
1707     "extract3-spam.htm",
1708     "extract4-virus.htm",
1709     ];
1710
1711 sub display_info {
1712
1713     my $min_display_time = 15;
1714
1715     my $ctime = time();
1716
1717     return if ($ctime - $last_display_change) < $min_display_time;
1718
1719     my $page = $display_info_items->[$display_info_counter % scalar(@$display_info_items)];
1720
1721     $display_info_counter++;
1722
1723     display_html($page);
1724 }
1725
1726 sub display_html {
1727     my ($filename) = @_;
1728
1729     $filename = $steps[$step_number]->{html} if !$filename;
1730
1731     my $path = "${proxmox_libdir}/html/$filename";
1732
1733     my $url = "file://$path";
1734
1735     my $data = file_get_contents($path);
1736
1737     if ($filename eq 'license.htm') {
1738         my $license = decode('utf8', file_get_contents("${proxmox_cddir}/EULA"));
1739         my $title = "END USER LICENSE AGREEMENT (EULA)";
1740         $data =~ s/__LICENSE__/$license/;
1741         $data =~ s/__LICENSE_TITLE__/$title/;
1742     }
1743
1744     $htmlview->load_html_string($data, $url);
1745
1746     $last_display_change = time();
1747 }
1748
1749 sub prev_function {
1750
1751     my ($text, $fctn) = @_;
1752
1753     $fctn = $step_number if !$fctn;
1754     $text = "_Previous" if !$text;
1755     $prev->set_label ($text);
1756
1757     $step_number--;
1758     $steps[$step_number]->{function}();
1759
1760     $prev->grab_focus ();
1761 }
1762
1763 sub set_next {
1764     my ($text, $fctn) = @_;
1765
1766     $next_fctn = $fctn;
1767     my $step = $steps[$step_number];
1768     $text //= $steps[$step_number]->{next_button} // '_Next';
1769     $next->set_label ($text);
1770
1771     $next->grab_focus ();
1772 }
1773
1774 sub create_main_window {
1775
1776     $window = Gtk3::Window->new ();
1777     $window->set_default_size (1024, 768);
1778     $window->set_has_resize_grip(0);
1779     $window->set_decorated (0) if !$opt_testmode;
1780
1781     my $vbox = Gtk3::VBox->new (0, 0);
1782
1783     my $logofn = "$setup->{product}-banner.png";
1784     my $image = Gtk3::Image->new_from_file("${proxmox_libdir}/$logofn");
1785     $vbox->pack_start ($image, 0, 0, 0);
1786
1787     my $hbox = Gtk3::HBox->new (0, 0);
1788     $vbox->pack_start ($hbox, 1, 1, 0);
1789
1790  #  my $f1 = Gtk3::Frame->new ('test');
1791  #  $f1->set_shadow_type ('none');
1792  #  $hbox->pack_start ($f1, 1, 1, 0);
1793
1794     my $sep1 = Gtk3::HSeparator->new;
1795     $vbox->pack_start ($sep1, 0, 0, 0);
1796
1797     $cmdbox = Gtk3::HBox->new ();
1798     $vbox->pack_start ($cmdbox, 0, 0, 10);
1799
1800     $next = Gtk3::Button->new ('_Next');
1801     $next->signal_connect (clicked => sub { $last_display_change = 0; &$next_fctn (); });
1802     $cmdbox->pack_end ($next, 0, 0, 10);
1803
1804
1805     $prev = Gtk3::Button->new ('_Previous');
1806     $prev->signal_connect (clicked => sub { $last_display_change = 0; &prev_function (); });
1807     $cmdbox->pack_end ($prev, 0, 0, 10);
1808
1809
1810     my $abort = Gtk3::Button->new ('_Abort');
1811     $abort->set_can_focus (0);
1812     $cmdbox->pack_start ($abort, 0, 0, 10);
1813     $abort->signal_connect (clicked => sub { exit (-1); });
1814
1815     my $vbox2 = Gtk3::VBox->new (0, 0);
1816     $hbox->add ($vbox2);
1817
1818     $htmlview = Gtk3::WebKit::WebView->new();
1819     my $scrolls = Gtk3::ScrolledWindow->new();
1820     $scrolls->add($htmlview);
1821
1822     my $hbox2 = Gtk3::HBox->new (0, 0);
1823     $hbox2->pack_start ($scrolls, 1, 1, 0);
1824
1825     $vbox2->pack_start ($hbox2, 1, 1, 0);
1826
1827     my $vbox3 = Gtk3::VBox->new (0, 0);
1828     $vbox2->pack_start ($vbox3, 0, 0, 0);
1829
1830     my $sep2 = Gtk3::HSeparator->new;
1831     $vbox3->pack_start ($sep2, 0, 0, 0);
1832
1833     $inbox = Gtk3::HBox->new (0, 0);
1834     $vbox3->pack_start ($inbox, 0, 0, 0);
1835
1836     $window->add ($vbox);
1837
1838     $window->show_all;
1839     $window->realize ();
1840 }
1841
1842 sub cleanup_view {
1843     $inbox->foreach(sub {
1844         my $child = shift;
1845         $inbox->remove ($child);
1846     });
1847 }
1848
1849 # fixme: newer GTK3 has special properties to handle numbers with Entry
1850 # only allow floating point numbers with Gtk3::Entry
1851
1852 sub check_float {
1853     my ($entry, $event) = @_;
1854
1855     return check_number($entry, $event, 1);
1856 }
1857
1858 sub check_int {
1859     my ($entry, $event) = @_;
1860
1861     return check_number($entry, $event, 0);
1862 }
1863
1864 sub check_number {
1865     my ($entry, $event, $float) = @_;
1866
1867     my $val = $event->get_keyval;
1868
1869     if (($float && $val == ord '.') ||
1870         $val == Gtk3::Gdk::KEY_ISO_Left_Tab ||
1871         $val == Gtk3::Gdk::KEY_Shift_L ||
1872         $val == Gtk3::Gdk::KEY_Tab ||
1873         $val == Gtk3::Gdk::KEY_Left ||
1874         $val == Gtk3::Gdk::KEY_Right ||
1875         $val == Gtk3::Gdk::KEY_BackSpace ||
1876         $val == Gtk3::Gdk::KEY_Delete ||
1877         ($val >= ord '0' && $val <= ord '9') ||
1878         ($val >= Gtk3::Gdk::KEY_KP_0 &&
1879          $val <= Gtk3::Gdk::KEY_KP_9)) {
1880         return undef;
1881     }
1882
1883     return 1;
1884 }
1885
1886 sub create_text_input {
1887     my ($default, $text) = @_;
1888
1889     my $hbox = Gtk3::HBox->new (0, 0);
1890
1891     my $label = Gtk3::Label->new ($text);
1892     $label->set_size_request (150, -1);
1893     $label->set_alignment (1, 0.5);
1894     $hbox->pack_start ($label, 0, 0, 10);
1895     my $e1 = Gtk3::Entry->new ();
1896     $e1->set_width_chars (30);
1897     $hbox->pack_start ($e1, 0, 0, 0);
1898     $e1->set_text ($default);
1899
1900     return ($hbox, $e1);
1901 }
1902
1903 sub get_ip_config {
1904
1905     my $ifaces = {};
1906     my $default;
1907
1908     my $links = `ip -o l`;
1909     foreach my $l (split /\n/,$links) {
1910         my ($index, $name, $flags, $state, $mac) = $l =~ m/^(\d+):\s+(\S+):\s+<(\S+)>.*\s+state\s+(\S+)\s+.*\s+link\/ether\s+(\S+)\s+/;
1911         next if !$name || $name eq 'lo';
1912
1913         my $driver = readlink "/sys/class/net/$name/device/driver" || 'unknown';
1914         $driver =~ s!^.*/!!;
1915
1916         $ifaces->{"$index"} = {
1917             name => $name,
1918             driver => $driver,
1919             flags => $flags,
1920             state => $state,
1921             mac => $mac,
1922         };
1923
1924         my $addresses = `ip -o a s $name`;
1925         foreach my $a (split /\n/,$addresses) {
1926             my ($family, $ip, $prefix) = $a =~ m/^\Q$index\E:\s+\Q$name\E\s+(inet|inet6)\s+($IPRE)\/(\d+)\s+/;
1927             next if !$ip;
1928             next if $a =~ /scope\s+link/; # ignore link local
1929
1930             my $mask = $prefix;
1931
1932             if ($family eq 'inet') {
1933                 next if !$ip =~ /$IPV4RE/;
1934                 next if $prefix < 8 || $prefix > 32;
1935                 $mask = @$ipv4_reverse_mask[$prefix];
1936             } else {
1937                 next if !$ip =~ /$IPV6RE/;
1938             }
1939
1940             $default = $index if !$default;
1941
1942             $ifaces->{"$index"}->{"$family"} = {
1943                 mask => $mask,
1944                 addr => $ip,
1945             };
1946         }
1947     }
1948
1949
1950     my $route = `ip route`;
1951     my ($gateway) = $route =~ m/^default\s+via\s+(\S+)\s+/m;
1952
1953     my $resolvconf = `cat /etc/resolv.conf`;
1954     my ($dnsserver) = $resolvconf =~ m/^nameserver\s+(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/m;
1955     my ($domain) = $resolvconf =~ m/^domain\s+(\S+)$/m;
1956
1957     return {
1958         default => $default,
1959         ifaces => $ifaces,
1960         gateway => $gateway,
1961         dnsserver => $dnsserver,
1962         domain => $domain,
1963     }
1964 }
1965
1966 sub display_message {
1967     my ($msg) = @_;
1968
1969     my $dialog = Gtk3::MessageDialog->new ($window, 'modal',
1970                                            'info', 'ok', $msg);
1971     $dialog->run();
1972     $dialog->destroy();
1973 }
1974
1975 sub display_error {
1976     my ($msg) = @_;
1977
1978     my $dialog = Gtk3::MessageDialog->new ($window, 'modal',
1979                                            'error', 'ok', $msg);
1980     $dialog->run();
1981     $dialog->destroy();
1982 }
1983
1984 my $ipconf_first_view = 1;
1985
1986 sub create_ipconf_view {
1987
1988     cleanup_view();
1989     display_html();
1990
1991     my $vbox =  Gtk3::VBox->new (0, 0);
1992     $inbox->pack_start ($vbox, 1, 0, 0);
1993     my $hbox =  Gtk3::HBox->new (0, 0);
1994     $vbox->pack_start ($hbox, 0, 0, 10);
1995     my $vbox2 =  Gtk3::VBox->new (0, 0);
1996     $hbox->add ($vbox2);
1997
1998     my $ipbox;
1999     ($ipbox, $ipconf_entry_addr) =
2000         create_text_input ("192.168.100.2", 'IP Address:');
2001
2002     my $maskbox;
2003     ($maskbox, $ipconf_entry_mask) =
2004         create_text_input ("255.255.255.0", 'Netmask:');
2005
2006     my $device_cb = Gtk3::ComboBoxText->new();
2007     $device_cb->set_active(0);
2008     $device_cb->set_visible(1);
2009
2010     my $get_device_desc = sub {
2011         my $iface = shift;
2012         return "$iface->{name} - $iface->{mac} ($iface->{driver})";
2013     };
2014
2015     my $device_active_map = {};
2016
2017     my $device_change_handler = sub {
2018         my $current = shift;
2019         $ipconf->{selected} = $device_active_map->{$current->get_active()};
2020         my $iface = $ipconf->{ifaces}->{$ipconf->{selected}};
2021         $ipconf_entry_addr->set_text($iface->{inet}->{addr} || $iface->{inet6}->{addr})
2022             if $iface->{inet}->{addr} || $iface->{inet6}->{addr};
2023         $ipconf_entry_mask->set_text($iface->{inet}->{mask} || $iface->{inet6}->{mask})
2024             if $iface->{inet}->{mask} || $iface->{inet6}->{mask};
2025     };
2026
2027     my $i = 0;
2028     foreach my $index (sort keys %{$ipconf->{ifaces}}) {
2029         $device_cb->append_text(&$get_device_desc($ipconf->{ifaces}->{$index}));
2030         $device_active_map->{$i} = $index;
2031         if ($ipconf_first_view && $index == $ipconf->{default}) {
2032             $device_cb->set_active($i);
2033             &$device_change_handler($device_cb);
2034             $ipconf_first_view = 0;
2035         }
2036         $device_cb->signal_connect ('changed' => $device_change_handler);
2037         $i++;
2038     }
2039
2040     $device_cb->set_active(0)
2041         if !($ipconf->{selected});
2042
2043     my $devicebox = Gtk3::HBox->new (0, 0);
2044     my $label = Gtk3::Label->new ("Management Interface:");
2045     $label->set_size_request (150, -1);
2046     $label->set_alignment (1, 0.5);
2047     $devicebox->pack_start ($label, 0, 0, 10);
2048     $devicebox->pack_start ($device_cb, 0, 0, 0);
2049
2050     $vbox2->pack_start ($devicebox, 0, 0, 2);
2051
2052     my $hn = $ipconf->{domain} ?
2053         "$setup->{product}.$ipconf->{domain}" : "$setup->{product}.example.invalid";
2054
2055     my ($hostbox, $hostentry) =
2056         create_text_input ($hn, 'Hostname (FQDN):');
2057     $vbox2->pack_start ($hostbox, 0, 0, 2);
2058
2059     $vbox2->pack_start ($ipbox, 0, 0, 2);
2060
2061     $vbox2->pack_start ($maskbox, 0, 0, 2);
2062
2063     $gateway = $ipconf->{gateway} || '192.168.100.1';
2064
2065     my $gwbox;
2066     ($gwbox, $ipconf_entry_gw) =
2067         create_text_input ($gateway, 'Gateway:');
2068
2069     $vbox2->pack_start ($gwbox, 0, 0, 2);
2070
2071     $dnsserver = $ipconf->{dnsserver} || $gateway;
2072
2073     my $dnsbox;
2074     ($dnsbox, $ipconf_entry_dns) =
2075         create_text_input ($dnsserver, 'DNS Server:');
2076
2077     $vbox2->pack_start ($dnsbox, 0, 0, 0);
2078
2079     $inbox->show_all;
2080     set_next (undef, sub {
2081
2082         # verify hostname
2083
2084         my $text = $hostentry->get_text();
2085
2086         $text =~ s/^\s+//;
2087         $text =~ s/\s+$//;
2088
2089         my $namere = "([a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?)";
2090
2091         # Debian does not support purely numeric hostnames
2092         if ($text && $text =~ /^[0-9]+(?:\.|$)/) {
2093             display_message("Purely numeric hostnames are not allowed.");
2094             $hostentry->grab_focus();
2095             return;
2096         }
2097
2098         if ($text && $text =~ m/^(${namere}\.)*${namere}$/ && $text !~ m/.example.invalid$/ &&
2099             $text =~ m/^([^\.]+)\.(\S+)$/) {
2100             $hostname = $1;
2101             $domain = $2;
2102         } else {
2103             display_message ("Hostname does not look like a fully qualified domain name.");
2104             $hostentry->grab_focus();
2105             return;
2106         }
2107
2108         # verify ip address
2109
2110         $text = $ipconf_entry_addr->get_text();
2111         $text =~ s/^\s+//;
2112         $text =~ s/\s+$//;
2113         if ($text =~ m!^($IPV4RE)$!) {
2114             $ipaddress = $text;
2115             $ipversion = 4;
2116         } elsif ($text =~ m!^($IPV6RE)$!) {
2117             $ipaddress = $text;
2118             $ipversion = 6;
2119         } else {
2120             display_message ("IP address is not valid.");
2121             $ipconf_entry_addr->grab_focus();
2122             return;
2123         }
2124
2125         $text = $ipconf_entry_mask->get_text();
2126         $text =~ s/^\s+//;
2127         $text =~ s/\s+$//;
2128         if (($ipversion == 6) && ($text =~ m/^(\d+)$/) && ($1 >= 8) && ($1 <= 126)) {
2129             $netmask = $text;
2130         } elsif (($ipversion == 4) && defined($ipv4_mask_hash->{$text})) {
2131             $netmask = $text;
2132         } else {
2133             display_message ("Netmask is not valid.");
2134             $ipconf_entry_mask->grab_focus();
2135             return;
2136         }
2137
2138         $text = $ipconf_entry_gw->get_text();
2139         $text =~ s/^\s+//;
2140         $text =~ s/\s+$//;
2141         if (($ipversion == 4) && ($text =~ m!^($IPV4RE)$!)) {
2142             $gateway = $text;
2143         } elsif (($ipversion == 6) && ($text =~ m!^($IPV6RE)$!)) {
2144             $gateway = $text;
2145         } else {
2146             display_message ("Gateway is not valid.");
2147             $ipconf_entry_gw->grab_focus();
2148             return;
2149         }
2150
2151         $text = $ipconf_entry_dns->get_text();
2152         $text =~ s/^\s+//;
2153         $text =~ s/\s+$//;
2154         if (($ipversion == 4) && ($text =~ m!^($IPV4RE)$!)) {
2155             $dnsserver = $text;
2156         } elsif (($ipversion == 6) && ($text =~ m!^($IPV6RE)$!)) {
2157             $dnsserver = $text;
2158         } else {
2159             display_message ("DNS server is not valid.");
2160             $ipconf_entry_dns->grab_focus();
2161             return;
2162         }
2163
2164         #print "TEST $ipaddress $netmask $gateway $dnsserver\n";
2165
2166         $step_number++;
2167         create_extract_view();
2168     });
2169
2170     $hostentry->grab_focus();
2171 }
2172
2173 sub get_device_desc {
2174     my ($devname, $size, $model) = @_;
2175
2176     if ($size && ($size > 0)) {
2177         $size = int($size/2048); # size in MB, from 512B "sectors"
2178
2179         my $text = "$devname (";
2180         if ($size >= 1024) {
2181             $size = int($size/1024); # size in GB
2182             $text .= "${size}GB";
2183         } else {
2184             $text .= "${size}MB";
2185         }
2186
2187         $text .= ", $model" if $model;
2188         $text .= ")";
2189
2190     } else {
2191         return $devname;
2192     }
2193 }
2194
2195 sub update_layout {
2196     my ($cb, $kmap) = @_;
2197
2198     my $ind;
2199     my $def;
2200     my $i = 0;
2201     my $kmaphash = $cmap->{kmaphash};
2202     foreach my $layout (sort keys %$kmaphash) {
2203         $def = $i if $kmaphash->{$layout} eq 'en-us';
2204         $ind = $i if $kmap && $kmaphash->{$layout} eq $kmap;
2205         $i++;
2206     }
2207
2208     $cb->set_active ($ind || $def || 0);
2209 }
2210
2211 my $lastzonecb;
2212 sub update_zonelist {
2213     my ($box, $cc) = @_;
2214
2215     my $cczones = $cmap->{cczones};
2216     my $zones = $cmap->{zones};
2217
2218     my $sel;
2219     if ($lastzonecb) {
2220         $sel = $lastzonecb->get_active_text();
2221         $box->remove ($lastzonecb);
2222     } else {
2223         $sel = $timezone; # used once to select default
2224     }
2225
2226     my $cb = $lastzonecb = Gtk3::ComboBoxText->new();
2227     $cb->set_size_request (200, -1);
2228
2229     $cb->signal_connect ('changed' => sub {
2230         $timezone = $cb->get_active_text();
2231     });
2232
2233     my @za;
2234     if ($cc && defined ($cczones->{$cc})) {
2235         @za = keys %{$cczones->{$cc}};
2236     } else {
2237         @za = keys %$zones;
2238     }
2239     my $ind;
2240     my $i = 0;
2241     foreach my $zone (sort @za) {
2242         $ind = $i if $sel && $zone eq $sel;
2243         $cb->append_text ($zone);
2244         $i++;
2245     }
2246
2247     $cb->set_active ($ind || 0);
2248
2249     $cb->show;
2250     $box->pack_start ($cb, 0, 0, 0);
2251 }
2252
2253 sub create_password_view {
2254
2255     cleanup_view ();
2256
2257     my $vbox2 =  Gtk3::VBox->new (0, 0);
2258     $inbox->pack_start ($vbox2, 1, 0, 0);
2259     my $vbox =  Gtk3::VBox->new (0, 0);
2260     $vbox2->pack_start ($vbox, 0, 0, 10);
2261
2262     my $hbox1 = Gtk3::HBox->new (0, 0);
2263     my $label = Gtk3::Label->new ("Password");
2264     $label->set_size_request (150, -1);
2265     $label->set_alignment (1, 0.5);
2266     $hbox1->pack_start ($label, 0, 0, 10);
2267     my $pwe1 = Gtk3::Entry->new ();
2268     $pwe1->set_visibility (0);
2269     $pwe1->set_text($password) if $password;
2270     $pwe1->set_size_request (200, -1);
2271     $hbox1->pack_start ($pwe1, 0, 0, 0);
2272
2273     my $hbox2 = Gtk3::HBox->new (0, 0);
2274     $label = Gtk3::Label->new ("Confirm");
2275     $label->set_size_request (150, -1);
2276     $label->set_alignment (1, 0.5);
2277     $hbox2->pack_start ($label, 0, 0, 10);
2278     my $pwe2 = Gtk3::Entry->new ();
2279     $pwe2->set_visibility (0);
2280     $pwe2->set_text($password) if $password;
2281     $pwe2->set_size_request (200, -1);
2282     $hbox2->pack_start ($pwe2, 0, 0, 0);
2283
2284     my $hbox3 = Gtk3::HBox->new (0, 0);
2285     $label = Gtk3::Label->new ("E-Mail");
2286     $label->set_size_request (150, -1);
2287     $label->set_alignment (1, 0.5);
2288     $hbox3->pack_start ($label, 0, 0, 10);
2289     my $eme = Gtk3::Entry->new ();
2290     $eme->set_size_request (200, -1);
2291     $eme->set_text($mailto);
2292     $hbox3->pack_start ($eme, 0, 0, 0);
2293
2294
2295     $vbox->pack_start ($hbox1, 0, 0, 5);
2296     $vbox->pack_start ($hbox2, 0, 0, 5);
2297     $vbox->pack_start ($hbox3, 0, 0, 15);
2298
2299     $inbox->show_all;
2300
2301     display_html();
2302
2303     set_next (undef,  sub {
2304
2305         my $t1 = $pwe1->get_text;
2306         my $t2 = $pwe2->get_text;
2307
2308         if (length ($t1) < 5) {
2309             display_message ("Password is too short.");
2310             $pwe1->grab_focus();
2311             return;
2312         }
2313
2314         if ($t1 ne $t2) {
2315             display_message ("Password does not match.");
2316             $pwe1->grab_focus();
2317             return;
2318         }
2319
2320         my $t3 = $eme->get_text;
2321         if ($t3 !~ m/^\S+\@\S+\.\S+$/) {
2322             display_message ("E-Mail does not look like a valid address" .
2323                              " (user\@domain.tld)");
2324             $eme->grab_focus();
2325             return;
2326         }
2327
2328         if ($t3 eq 'mail@example.invalid') {
2329             display_message ("Please enter a valid E-Mail address");
2330             $eme->grab_focus();
2331             return;
2332         }
2333
2334         $password = $t1;
2335         $mailto = $t3;
2336
2337         $step_number++;
2338         create_ipconf_view();
2339     });
2340
2341     $pwe1->grab_focus();
2342
2343 }
2344
2345 sub create_country_view {
2346
2347     cleanup_view ();
2348
2349     my $countryhash = $cmap->{countryhash};
2350     my $ctr = $cmap->{country};
2351
2352     my $vbox2 =  Gtk3::VBox->new (0, 0);
2353     $inbox->pack_start ($vbox2, 1, 0, 0);
2354     my $vbox =  Gtk3::VBox->new (0, 0);
2355     $vbox2->pack_start ($vbox, 0, 0, 10);
2356
2357     my $w = Gtk3::Entry->new ();
2358     $w->set_size_request (200, -1);
2359
2360     my $c = Gtk3::EntryCompletion->new ();
2361     $c->set_text_column (0);
2362     $c->set_minimum_key_length(0);
2363     $c->set_popup_set_width (1);
2364     $c->set_inline_completion (1);
2365
2366     my $hbox2 = Gtk3::HBox->new (0, 0);
2367     my $label = Gtk3::Label->new ("Time zone");
2368     $label->set_size_request (150, -1);
2369     $label->set_alignment (1, 0.5);
2370     $hbox2->pack_start ($label, 0, 0, 10);
2371     update_zonelist ($hbox2);
2372
2373     my $hbox3 = Gtk3::HBox->new (0, 0);
2374     $label = Gtk3::Label->new ("Keyboard Layout");
2375     $label->set_size_request (150, -1);
2376     $label->set_alignment (1, 0.5);
2377     $hbox3->pack_start ($label, 0, 0, 10);
2378
2379     my $kmapcb = Gtk3::ComboBoxText->new();
2380     $kmapcb->set_size_request (200, -1);
2381     foreach my $layout (sort keys %{$cmap->{kmaphash}}) {
2382         $kmapcb->append_text ($layout);
2383     }
2384
2385     update_layout ($kmapcb);
2386     $hbox3->pack_start ($kmapcb, 0, 0, 0);
2387
2388     $kmapcb->signal_connect ('changed' => sub {
2389         my $sel = $kmapcb->get_active_text();
2390         if (my $kmap = $cmap->{kmaphash}->{$sel}) {
2391             my $xkmap = $cmap->{kmap}->{$kmap}->{x11};
2392             my $xvar = $cmap->{kmap}->{$kmap}->{x11var};
2393             syscmd ("setxkbmap $xkmap $xvar") if !$opt_testmode;
2394             $keymap = $kmap;
2395         }
2396     });
2397
2398     $w->signal_connect ('changed' => sub {
2399         my ($entry, $event) = @_;
2400         my $text = $entry->get_text;
2401
2402         if (my $cc = $countryhash->{lc($text)}) {
2403             update_zonelist ($hbox2, $cc);
2404             my $kmap = $ctr->{$cc}->{kmap} || 'en-us';
2405             update_layout ($kmapcb, $kmap);
2406         }
2407     });
2408
2409     $w->signal_connect (key_press_event => sub {
2410         my ($entry, $event) = @_;
2411         my $text = $entry->get_text;
2412
2413         my $val = $event->get_keyval;
2414
2415         if ($val == Gtk3::Gdk::KEY_Tab) {
2416             my $cc = $countryhash->{lc($text)};
2417
2418             my $found = 0;
2419             my $compl;
2420
2421             if ($cc) {
2422                 $found = 1;
2423                 $compl = $ctr->{$cc}->{name};
2424             } else {
2425                 foreach my $cc (keys %$ctr) {
2426                     my $ct = $ctr->{$cc}->{name};
2427                     if ($ct =~ m/^\Q$text\E.*$/i) {
2428                         $found++;
2429                         $compl = $ct;
2430                     }
2431                     last if $found > 1;
2432                 }
2433             }
2434
2435             if ($found == 1) {
2436                 $entry->set_text($compl);
2437                 $c->complete();
2438                 return undef;
2439             } else {
2440                 #Gtk3::Gdk::beep();
2441                 print chr(7); # beep ?
2442             }
2443
2444             $c->complete();
2445
2446             my $buf = $w->get_buffer();
2447             $buf->insert_text(-1, '', -1); # popup selection
2448
2449             return 1;
2450         }
2451
2452         return undef;
2453     });
2454
2455     my $ls = Gtk3::ListStore->new('Glib::String');
2456     foreach my $cc (sort {$ctr->{$a}->{name} cmp $ctr->{$b}->{name} } keys %$ctr) {
2457         my $iter = $ls->append();
2458         $ls->set ($iter, 0, $ctr->{$cc}->{name});
2459     }
2460     $c->set_model ($ls);
2461
2462     $w->set_completion ($c);
2463
2464     my $hbox =  Gtk3::HBox->new (0, 0);
2465
2466     $label = Gtk3::Label->new ("Country");
2467     $label->set_alignment (1, 0.5);
2468     $label->set_size_request (150, -1);
2469     $hbox->pack_start ($label, 0, 0, 10);
2470     $hbox->pack_start ($w, 0, 0, 0);
2471
2472     $vbox->pack_start ($hbox, 0, 0, 5);
2473     $vbox->pack_start ($hbox2, 0, 0, 5);
2474     $vbox->pack_start ($hbox3, 0, 0, 5);
2475
2476     if ($country && $ctr->{$country}) {
2477         $w->set_text ($ctr->{$country}->{name});
2478     }
2479
2480     $inbox->show_all;
2481
2482     display_html();
2483     set_next (undef,  sub {
2484
2485         my $text = $w->get_text;
2486
2487         if (my $cc = $countryhash->{lc($text)}) {
2488             $country = $cc;
2489             $step_number++;
2490             create_password_view();
2491             return;
2492         } else {
2493             display_message ("Please select a country first.");
2494             $w->grab_focus();
2495         }
2496     });
2497
2498     $w->grab_focus();
2499 }
2500
2501 my $target_hd_combo;
2502 my $target_hd_label;
2503
2504 my $hdopion_first_setup = 1;
2505
2506 my $create_basic_grid = sub {
2507     my $grid =  Gtk3::Grid->new();
2508     $grid->set_visible(1);
2509     $grid->set_column_spacing(10);
2510     $grid->set_row_spacing(10);
2511     $grid->set_hexpand(1);
2512
2513     $grid->set_margin_start(5);
2514     $grid->set_margin_end(5);
2515     $grid->set_margin_top(5);
2516     $grid->set_margin_bottom(5);
2517
2518     return $grid;
2519 };
2520
2521 my $create_label_widget_grid = sub {
2522     my ($labeled_widgets) = @_;
2523
2524     my $grid = &$create_basic_grid();
2525     my $row = 0;
2526
2527     for (my $i = 0; $i < @$labeled_widgets; $i += 2) {
2528         my $widget = @$labeled_widgets[$i+1];
2529         my $label = Gtk3::Label->new(@$labeled_widgets[$i]);
2530         $label->set_visible(1);
2531         $label->set_alignment (1, 0.5);
2532         $grid->attach($label, 0, $row, 1, 1);
2533         $widget->set_visible(1);
2534         $grid->attach($widget, 1, $row, 1, 1);
2535         $row++;
2536     }
2537
2538     return $grid;
2539 };
2540
2541 my $create_raid_disk_grid = sub {
2542     my $disk_labeled_widgets = [];
2543     for (my $i = 0; $i < @$hds; $i++) {
2544         my $disk_selector = Gtk3::ComboBoxText->new();
2545         $disk_selector->append_text("-- do not use --");
2546         $disk_selector->set_active(0);
2547         $disk_selector->set_visible(1);
2548         foreach my $hd (@$hds) {
2549             my ($disk, $devname, $size, $model) = @$hd;
2550             $disk_selector->append_text(get_device_desc ($devname, $size, $model));
2551             $disk_selector->{pve_disk_id} = $i;
2552             $disk_selector->signal_connect (changed => sub {
2553                 my $w = shift;
2554                 my $diskid = $w->{pve_disk_id};
2555                 my $a = $w->get_active - 1;
2556                 $config_options->{"disksel${diskid}"} = ($a >= 0) ? $hds->[$a] : undef;
2557             });
2558         }
2559
2560         if ($hdopion_first_setup) {
2561             $disk_selector->set_active ($i+1) if $hds->[$i];
2562         } else {
2563             my $hdind = 0;
2564             if (my $cur_hd = $config_options->{"disksel$i"}) {
2565                 foreach my $hd (@$hds) {
2566                     if (@$hd[1] eq @$cur_hd[1]) {
2567                         $disk_selector->set_active($hdind+1);
2568                         last;
2569                     }
2570                     $hdind++;
2571                 }
2572             }
2573         }
2574
2575         push @$disk_labeled_widgets, "Harddisk $i", $disk_selector;
2576     }
2577
2578     my $scrolled_window = Gtk3::ScrolledWindow->new();
2579     $scrolled_window->set_hexpand(1);
2580     $scrolled_window->set_propagate_natural_height(1) if @$hds > 4;
2581     $scrolled_window->add(&$create_label_widget_grid($disk_labeled_widgets));
2582     $scrolled_window->set_policy('never', 'automatic');
2583
2584     return $scrolled_window;
2585 #    &$create_label_widget_grid($disk_labeled_widgets)
2586 };
2587
2588 # shared between different ui parts (e.g., ZFS and "normal" single disk FS)
2589 my $hdsize_size_adj;
2590 my $hdsize_entry_buffer;
2591
2592 my $get_hdsize_spinbtn = sub {
2593     my $hdsize = shift;
2594
2595     $hdsize_entry_buffer //= Gtk3::EntryBuffer->new(undef, 1);
2596
2597     if (defined($hdsize)) {
2598         $hdsize_size_adj = Gtk3::Adjustment->new($config_options->{hdsize} || $hdsize, 0, $hdsize+1, 1, 1, 1);
2599     } else {
2600         die "called get_hdsize_spinbtn with \$hdsize_size_adj not defined but did not pass hdsize!\n"
2601             if !defined($hdsize_size_adj);
2602     }
2603
2604     my $spinbutton_hdsize = Gtk3::SpinButton->new($hdsize_size_adj, 1, 1);
2605     $spinbutton_hdsize->set_buffer($hdsize_entry_buffer);
2606     $spinbutton_hdsize->set_adjustment($hdsize_size_adj);
2607     $spinbutton_hdsize->set_tooltip_text("only use specified size (GB) of the harddisk (rest left unpartitioned)");
2608     return $spinbutton_hdsize;
2609 };
2610
2611 my $create_raid_advanced_grid = sub {
2612     my $labeled_widgets = [];
2613     my $spinbutton_ashift = Gtk3::SpinButton->new_with_range(9,13,1);
2614     $spinbutton_ashift->set_tooltip_text("zpool ashift property (pool sector size, default 2^12)");
2615     $spinbutton_ashift->signal_connect ("value-changed" => sub {
2616         my $w = shift;
2617         $config_options->{ashift} = $w->get_value_as_int();
2618     });
2619     $config_options->{ashift} = 12 if ! defined($config_options->{ashift});
2620     $spinbutton_ashift->set_value($config_options->{ashift});
2621     push @$labeled_widgets, "ashift";
2622     push @$labeled_widgets, $spinbutton_ashift;
2623
2624     my $combo_compress = Gtk3::ComboBoxText->new();
2625     $combo_compress->set_tooltip_text("zfs compression algorithm for rpool dataset");
2626     # note: gzip / lze not allowed for bootfs vdevs
2627     my $comp_opts = ["on","off","lzjb","lz4"];
2628     foreach my $opt (@$comp_opts) {
2629         $combo_compress->append($opt, $opt);
2630     }
2631     $config_options->{compress} = "on" if !defined($config_options->{compress});
2632     $combo_compress->set_active_id($config_options->{compress});
2633     $combo_compress->signal_connect (changed => sub {
2634         my $w = shift;
2635         $config_options->{compress} = $w->get_active_text();
2636     });
2637     push @$labeled_widgets, "compress";
2638     push @$labeled_widgets, $combo_compress;
2639
2640     my $combo_checksum = Gtk3::ComboBoxText->new();
2641     $combo_checksum->set_tooltip_text("zfs checksum algorithm for rpool dataset");
2642     my $csum_opts = ["on", "off","fletcher2", "fletcher4", "sha256"];
2643     foreach my $opt (@$csum_opts) {
2644         $combo_checksum->append($opt, $opt);
2645     }
2646     $config_options->{checksum} = "on" if !($config_options->{checksum});
2647     $combo_checksum->set_active_id($config_options->{checksum});
2648     $combo_checksum->signal_connect (changed => sub {
2649         my $w = shift;
2650         $config_options->{checksum} = $w->get_active_text();
2651     });
2652     push @$labeled_widgets, "checksum";
2653     push @$labeled_widgets, $combo_checksum;
2654
2655     my $spinbutton_copies = Gtk3::SpinButton->new_with_range(1,3,1);
2656     $spinbutton_copies->set_tooltip_text("zfs copies property for rpool dataset (in addition to RAID redundancy!)");
2657     $spinbutton_copies->signal_connect ("value-changed" => sub {
2658         my $w = shift;
2659         $config_options->{copies} = $w->get_value_as_int();
2660     });
2661     $config_options->{copies} = 1 if !defined($config_options->{copies});
2662     $spinbutton_copies->set_value($config_options->{copies});
2663     push @$labeled_widgets, "copies", $spinbutton_copies;
2664
2665     push @$labeled_widgets, "hdsize", $get_hdsize_spinbtn->();
2666     return &$create_label_widget_grid($labeled_widgets);;
2667 };
2668
2669 sub create_hdoption_view {
2670
2671     my $dialog = Gtk3::Dialog->new();
2672
2673     $dialog->set_title("Harddisk options");
2674
2675     $dialog->add_button("_OK", 1);
2676
2677     my $contarea = $dialog->get_content_area();
2678
2679     my $hbox2 =  Gtk3::Box->new('horizontal', 0);
2680     $contarea->pack_start($hbox2, 1, 1, 10);
2681
2682     my $grid =  Gtk3::Grid->new();
2683     $grid->set_column_spacing(10);
2684     $grid->set_row_spacing(10);
2685
2686     $hbox2->pack_start($grid, 1, 0, 10);
2687
2688     my $row = 0;
2689
2690     # Filesystem type
2691
2692     my $label0 = Gtk3::Label->new ("Filesystem");
2693     $label0->set_alignment (1, 0.5);
2694     $grid->attach($label0, 0, $row, 1, 1);
2695
2696     my $fstypecb = Gtk3::ComboBoxText->new();
2697
2698     my $fstype = ['ext3', 'ext4', 'xfs',
2699                   'zfs (RAID0)', 'zfs (RAID1)',
2700                   'zfs (RAID10)', 'zfs (RAIDZ-1)',
2701                   'zfs (RAIDZ-2)', 'zfs (RAIDZ-3)'];
2702
2703     push @$fstype, 'btrfs (RAID0)', 'btrfs (RAID1)', 'btrfs (RAID10)'
2704         if $setup->{enable_btrfs};
2705
2706     my $tcount = 0;
2707     foreach my $tmp (@$fstype) {
2708         $fstypecb->append_text($tmp);
2709         $fstypecb->set_active ($tcount)
2710             if $config_options->{filesys} eq $tmp;
2711         $tcount++;
2712     }
2713
2714     $grid->attach($fstypecb, 1, $row, 1, 1);
2715
2716     $hbox2->show_all();
2717
2718     $row++;
2719
2720     my $sep = Gtk3::HSeparator->new();
2721     $sep->set_visible(1);
2722     $grid->attach($sep, 0, $row, 2, 1);
2723     $row++;
2724
2725     my $hdsize_labeled_widgets = [];
2726
2727     # size compute
2728     my $hdsize = 0;
2729     if ( -b $target_hd) {
2730         $hdsize = int(hd_size ($target_hd) / (1024*1024.0)); # size in GB
2731     } elsif ($target_hd) {
2732         $hdsize = int((-s $target_hd) / (1024*1024*1024.0));
2733     }
2734
2735     my $spinbutton_hdsize = $get_hdsize_spinbtn->($hdsize);
2736     push @$hdsize_labeled_widgets, "hdsize", $spinbutton_hdsize;
2737
2738     my $entry_swapsize = Gtk3::Entry->new();
2739     $entry_swapsize->set_tooltip_text("maximum SWAP size (GB)");
2740     $entry_swapsize->signal_connect (key_press_event => \&check_float);
2741     $entry_swapsize->set_text($config_options->{swapsize}) if defined($config_options->{swapsize});
2742     push @$hdsize_labeled_widgets, "swapsize", $entry_swapsize;
2743
2744     my $entry_maxroot = Gtk3::Entry->new();
2745     if ($setup->{product} eq 'pve') {
2746         $entry_maxroot->set_tooltip_text("maximum size (GB) for LVM root volume");
2747         $entry_maxroot->signal_connect (key_press_event => \&check_float);
2748         $entry_maxroot->set_text($config_options->{maxroot}) if $config_options->{maxroot};
2749         push @$hdsize_labeled_widgets, "maxroot", $entry_maxroot;
2750     }
2751
2752     my $entry_minfree = Gtk3::Entry->new();
2753     $entry_minfree->set_tooltip_text("minimum free LVM space (GB, required for LVM snapshots)");
2754     $entry_minfree->signal_connect (key_press_event => \&check_float);
2755     $entry_minfree->set_text($config_options->{minfree}) if defined($config_options->{minfree});
2756     push @$hdsize_labeled_widgets, "minfree", $entry_minfree;
2757
2758     my $entry_maxvz;
2759     if ($setup->{product} eq 'pve') {
2760         $entry_maxvz = Gtk3::Entry->new();
2761         $entry_maxvz->set_tooltip_text("maximum size (GB) for LVM data volume");
2762         $entry_maxvz->signal_connect (key_press_event => \&check_float);
2763         $entry_maxvz->set_text($config_options->{maxvz}) if defined($config_options->{maxvz});
2764         push @$hdsize_labeled_widgets, "maxvz", $entry_maxvz;
2765     }
2766
2767     my $options_stack = Gtk3::Stack->new();
2768     $options_stack->set_visible(1);
2769     $options_stack->set_hexpand(1);
2770     $options_stack->set_vexpand(1);
2771     $options_stack->add_titled(&$create_raid_disk_grid(), "raiddisk", "Disk Setup");
2772     $options_stack->add_titled(&$create_label_widget_grid($hdsize_labeled_widgets), "hdsize", "Size Options");
2773     $options_stack->add_titled(&$create_raid_advanced_grid("zfs"), "raidzfsadvanced", "Advanced Options");
2774     $options_stack->set_visible_child_name("raiddisk");
2775     my $options_stack_switcher = Gtk3::StackSwitcher->new();
2776     $options_stack_switcher->set_halign('center');
2777     $options_stack_switcher->set_stack($options_stack);
2778     $grid->attach($options_stack_switcher, 0, $row, 2, 1);
2779     $row++;
2780     $grid->attach($options_stack, 0, $row, 2, 1);
2781     $row++;
2782
2783     $hdopion_first_setup = 0;
2784
2785     my $switch_view = sub {
2786         my $raid = $config_options->{filesys} =~ m/zfs|btrfs/;
2787         my $enable_zfs_opts = $config_options->{filesys} =~ m/zfs/;
2788
2789         $target_hd_combo->set_visible(!$raid);
2790         $options_stack->get_child_by_name("hdsize")->set_visible(!$raid);
2791         $options_stack->get_child_by_name("raiddisk")->set_visible($raid);
2792         $options_stack_switcher->set_visible($enable_zfs_opts);
2793         $options_stack->get_child_by_name("raidzfsadvanced")->set_visible($enable_zfs_opts);
2794         if ($raid) {
2795             $target_hd_label->set_text("Target: $config_options->{filesys} ");
2796             $options_stack->set_visible_child_name("raiddisk");
2797         } else {
2798             $target_hd_label->set_text("Target Harddisk: ");
2799         }
2800         my (undef, $pref_width) = $dialog->get_preferred_width();
2801         my (undef, $pref_height) = $dialog->get_preferred_height();
2802         $pref_height = 750 if $pref_height > 750;
2803         $dialog->resize($pref_width, $pref_height);
2804     };
2805
2806     &$switch_view();
2807
2808     $fstypecb->signal_connect (changed => sub {
2809         $config_options->{filesys} = $fstypecb->get_active_text();
2810         &$switch_view();
2811     });
2812
2813     $dialog->show();
2814
2815     $dialog->run();
2816
2817     my $get_float = sub {
2818         my ($entry) = @_;
2819
2820         my $text = $entry->get_text();
2821         return undef if !defined($text);
2822
2823         $text =~ s/^\s+//;
2824         $text =~ s/\s+$//;
2825
2826         return undef if $text !~ m/^\d+(\.\d+)?$/;
2827
2828         return $text;
2829     };
2830
2831     my $tmp;
2832
2833     if (($tmp = &$get_float($spinbutton_hdsize)) && ($tmp != $hdsize)) {
2834         $config_options->{hdsize} = $tmp;
2835     } else {
2836         delete $config_options->{hdsize};
2837     }
2838
2839     if (defined($tmp = &$get_float($entry_swapsize))) {
2840         $config_options->{swapsize} = $tmp;
2841     } else {
2842         delete $config_options->{swapsize};
2843     }
2844
2845     if (defined($tmp = &$get_float($entry_maxroot))) {
2846         $config_options->{maxroot} = $tmp;
2847     } else {
2848         delete $config_options->{maxroot};
2849     }
2850
2851     if (defined($tmp = &$get_float($entry_minfree))) {
2852         $config_options->{minfree} = $tmp;
2853     } else {
2854         delete $config_options->{minfree};
2855     }
2856
2857     if ($entry_maxvz && defined($tmp = &$get_float($entry_maxvz))) {
2858         $config_options->{maxvz} = $tmp;
2859     } else {
2860         delete $config_options->{maxvz};
2861     }
2862
2863     $dialog->destroy();
2864 }
2865
2866 my $get_raid_devlist = sub {
2867
2868     my $dev_name_hash = {};
2869
2870     my $devlist = [];
2871     for (my $i = 0; $i < @$hds; $i++) {
2872         if (my $hd = $config_options->{"disksel$i"}) {
2873             my ($disk, $devname, $size, $model) = @$hd;
2874             die "device '$devname' is used more than once\n"
2875                 if $dev_name_hash->{$devname};
2876             $dev_name_hash->{$devname} = $hd;
2877             push @$devlist, $hd;
2878         }
2879     }
2880
2881     return $devlist;
2882 };
2883
2884 sub zfs_mirror_size_check {
2885     my ($expected, $actual) = @_;
2886
2887     die "mirrored disks must have same size\n"
2888         if abs($expected - $actual) > $expected / 10;
2889 }
2890
2891 sub get_zfs_raid_setup {
2892
2893     my $filesys = $config_options->{filesys};
2894
2895     my $devlist = &$get_raid_devlist();
2896
2897     my $diskcount = scalar(@$devlist);
2898     die "$filesys needs at least one device\n" if $diskcount < 1;
2899
2900     my $bootdevlist = [];
2901
2902     my $cmd= '';
2903     if ($filesys eq 'zfs (RAID0)') {
2904         push @$bootdevlist, @$devlist[0];
2905         foreach my $hd (@$devlist) {
2906             $cmd .= " @$hd[1]";
2907         }
2908     } elsif ($filesys eq 'zfs (RAID1)') {
2909         die "zfs (RAID1) needs at least 2 device\n" if $diskcount < 2;
2910         $cmd .= ' mirror ';
2911         my $hd = @$devlist[0];
2912         my $expected_size = @$hd[2]; # all disks need approximately same size
2913         foreach $hd (@$devlist) {
2914             zfs_mirror_size_check($expected_size, @$hd[2]);
2915             $cmd .= " @$hd[1]";
2916             push @$bootdevlist, $hd;
2917         }
2918     } elsif ($filesys eq 'zfs (RAID10)') {
2919         die "zfs (RAID10) needs at least 4 device\n" if $diskcount < 4;
2920         die "zfs (RAID10) needs an even number of devices\n" if $diskcount & 1;
2921
2922         push @$bootdevlist, @$devlist[0], @$devlist[1];
2923
2924         for (my $i = 0; $i < $diskcount; $i+=2) {
2925             my $hd1 = @$devlist[$i];
2926             my $hd2 = @$devlist[$i+1];
2927             zfs_mirror_size_check(@$hd1[2], @$hd2[2]); # pairs need approximately same size
2928             $cmd .= ' mirror ' . @$hd1[1] . ' ' . @$hd2[1];
2929         }
2930
2931     } elsif ($filesys =~ m/^zfs \(RAIDZ-([123])\)$/) {
2932         my $level = $1;
2933         my $mindisks = 2 + $level;
2934         die "zfs (RAIDZ-$level) needs at least $mindisks devices\n" if scalar(@$devlist) < $mindisks;
2935         my $hd = @$devlist[0];
2936         my $expected_size = @$hd[2]; # all disks need approximately same size
2937         $cmd .= " raidz$level";
2938         foreach $hd (@$devlist) {
2939             zfs_mirror_size_check($expected_size, @$hd[2]);
2940             $cmd .= " @$hd[1]";
2941             push @$bootdevlist, $hd;
2942         }
2943     } else {
2944         die "unknown zfs mode '$filesys'\n";
2945     }
2946
2947     return ($devlist, $bootdevlist, $cmd);
2948 }
2949
2950 sub get_btrfs_raid_setup {
2951
2952     my $filesys = $config_options->{filesys};
2953
2954     my $devlist = &$get_raid_devlist();
2955
2956     my $diskcount = scalar(@$devlist);
2957     die "$filesys needs at least one device\n" if $diskcount < 1;
2958
2959     my $mode;
2960
2961     if ($diskcount == 1) {
2962         $mode = 'single';
2963     } else {
2964         if ($filesys eq 'btrfs (RAID0)') {
2965             $mode = 'raid0';
2966         } elsif ($filesys eq 'btrfs (RAID1)') {
2967             die "btrfs (RAID1) needs at least 2 device\n" if $diskcount < 2;
2968             $mode = 'raid1';
2969         } elsif ($filesys eq 'btrfs (RAID10)') {
2970             die "btrfs (RAID10) needs at least 4 device\n" if $diskcount < 4;
2971             $mode = 'raid10';
2972         } else {
2973             die "unknown btrfs mode '$filesys'\n";
2974         }
2975     }
2976
2977     return ($devlist, $mode);
2978 }
2979
2980 sub create_hdsel_view {
2981
2982     $prev->set_sensitive(1); # enable previous button at this point
2983
2984     cleanup_view ();
2985
2986     my $vbox =  Gtk3::VBox->new (0, 0);
2987     $inbox->pack_start ($vbox, 1, 0, 0);
2988     my $hbox =  Gtk3::HBox->new (0, 0);
2989     $vbox->pack_start ($hbox, 0, 0, 10);
2990
2991     my ($disk, $devname, $size, $model) = @{@$hds[0]};
2992     $target_hd = $devname;
2993
2994     $target_hd_label = Gtk3::Label->new ("Target Harddisk: ");
2995     $hbox->pack_start ($target_hd_label, 0, 0, 0);
2996
2997     $target_hd_combo = Gtk3::ComboBoxText->new();
2998
2999     foreach my $hd (@$hds) {
3000         ($disk, $devname, $size, $model) = @$hd;
3001         $target_hd_combo->append_text (get_device_desc ($devname, $size, $model));
3002     }
3003
3004     $target_hd_combo->set_active (0);
3005     $target_hd_combo->signal_connect (changed => sub {
3006         $a = shift->get_active;
3007         my ($disk, $devname) = @{@$hds[$a]};
3008         $target_hd = $devname;
3009     });
3010
3011     $hbox->pack_start ($target_hd_combo, 0, 0, 10);
3012
3013     my $options = Gtk3::Button->new ('_Options');
3014     $options->signal_connect (clicked => \&create_hdoption_view);
3015     $hbox->pack_start ($options, 0, 0, 0);
3016
3017
3018     $inbox->show_all;
3019
3020     display_html();
3021
3022     set_next (undef, sub {
3023
3024         if ($config_options->{filesys} =~ m/zfs/) {
3025             eval { get_zfs_raid_setup(); };
3026             if (my $err = $@) {
3027                 display_message ("Warning: $err\n" .
3028                                  "Please fix ZFS setup first.");
3029             } else {
3030                 $step_number++;
3031                 create_country_view();
3032             }
3033         } elsif ($config_options->{filesys} =~ m/btrfs/) {
3034             eval { get_btrfs_raid_setup(); };
3035             if (my $err = $@) {
3036                 display_message ("Warning: $err\n" .
3037                                  "Please fix BTRFS setup first.");
3038             } else {
3039                 $step_number++;
3040                 create_country_view();
3041             }
3042         } else {
3043             $step_number++;
3044             create_country_view();
3045         }
3046     });
3047 }
3048
3049 sub create_extract_view {
3050
3051     cleanup_view ();
3052
3053     display_info();
3054
3055     $next->set_sensitive(0);
3056
3057     my $vbox =  Gtk3::VBox->new (0, 0);
3058     $inbox->pack_start ($vbox, 1, 0, 0);
3059     my $hbox =  Gtk3::HBox->new (0, 0);
3060     $vbox->pack_start ($hbox, 0, 0, 10);
3061
3062     my $vbox2 =  Gtk3::VBox->new (0, 0);
3063     $hbox->pack_start ($vbox2, 0, 0, 0);
3064
3065     $progress_status = Gtk3::Label->new ('');
3066     $vbox2->pack_start ($progress_status, 1, 1, 0);
3067
3068     $progress = Gtk3::ProgressBar->new;
3069     $progress->set_show_text(1);
3070     $progress->set_size_request (600, -1);
3071
3072     $vbox2->pack_start ($progress, 0, 0, 0);
3073
3074     $inbox->show_all();
3075
3076     my $tdir = $opt_testmode ? "target" : "/target";
3077     mkdir $tdir;
3078     my $base = "${proxmox_cddir}/$setup->{product}-base.squashfs";
3079
3080     eval  { extract_data ($base, $tdir); };
3081     my $err = $@;
3082
3083     $next->set_sensitive(1);
3084
3085     set_next ("_Reboot", sub { exit (0); } );
3086
3087     if ($err) {
3088         display_html("fail.htm");
3089         display_error($err);
3090     } else {
3091         cleanup_view();
3092         display_html("success.htm");
3093     }
3094 }
3095
3096 sub create_intro_view {
3097
3098     $prev->set_sensitive(0);
3099
3100     cleanup_view();
3101
3102     if ($setup->{product} eq 'pve') {
3103         eval {
3104             my $cpuinfo = file_get_contents('/proc/cpuinfo');
3105             if ($cpuinfo && !($cpuinfo =~ /^flags\s*:.*(vmx|svm)/m)) {
3106                 display_error("No support for KVM virtualisation detected.\n\n" .
3107                               "Check BIOS settings for Intel VT / AMD-V / SVM.")
3108             }
3109         };
3110     }
3111
3112     display_html();
3113
3114     $step_number++;
3115     set_next ("I a_gree", \&create_hdsel_view);
3116 }
3117
3118 $ipconf = get_ip_config ();
3119
3120 $country = detect_country() if $ipconf->{default} || $opt_testmode;
3121
3122 # read country, kmap and timezone infos
3123 $cmap = read_cmap ();
3124
3125 if (!defined($cmap->{country}->{$country})) {
3126     print $logfd "ignoring detected country '$country', invalid or unknown\n";
3127     $country = undef;
3128 }
3129
3130 create_main_window ();
3131
3132 my $initial_error = 0;
3133
3134 if (!defined ($hds) || (scalar (@$hds) <= 0)) {
3135     print "no hardisks found\n";
3136     $initial_error = 1;
3137     display_html("nohds.htm");
3138     set_next ("Reboot", sub { exit (0); } );
3139 } else {
3140     foreach my $hd (@$hds) {
3141         my ($disk, $devname) = @$hd;
3142         next if $devname =~ m|^/dev/md\d+$|;
3143         print "found Disk$disk N:$devname\n";
3144     }
3145 }
3146
3147 if (!$initial_error && (scalar keys %{ $ipconf->{ifaces} } == 0)) {
3148     print "no network interfaces found\n";
3149     $initial_error = 1;
3150     display_html("nonics.htm");
3151     set_next ("Reboot", sub { exit (0); } );
3152 }
3153
3154 create_intro_view () if !$initial_error;
3155
3156 Gtk3->main;
3157
3158 exit 0;