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         html => 'ipconf.htm',
 220         function => \&create_ipconf_view,
 221     },
 222     {
 223         step => 'ack',
 224         html => 'ack.htm',
 225         next_button => '_Install',
 226         function => \&create_ack_view,
 227     },
 228     {
 229         step => 'extract',
 230         next_button => '_Reboot',
 231         function => \&create_extract_view,
 232     },
 233 );
 234
 235 # GUI global variables
 236 my ($window, $cmdbox, $inbox, $htmlview);
 237 my $prev;
 238 my ($next, $next_fctn, $target_hd);
 239 my ($progress, $progress_status);
 240
 241 my ($ipversion, $ipaddress, $ipconf_entry_addr);
 242 my ($netmask, $ipconf_entry_mask);
 243 my ($gateway, $ipconf_entry_gw);
 244 my ($dnsserver, $ipconf_entry_dns);
 245 my $hostname = 'proxmox';
 246 my $domain = 'domain.tld';
 247 my $cmdline = file_read_firstline("/proc/cmdline");
 248 my $ipconf;
 249 my $country;
 250 my $timezone = 'Europe/Vienna';
 251 my $keymap = 'en-us';
 252 my $password;
 253 my $mailto = 'mail@example.invalid';
 254 my $cmap;
 255
 256 my $config = {
 257     # TODO: add all the user-provided options for previous button
 258     country => $country,
 259     timezone => $timezone,
 260     keymap => $keymap,
 261
 262     password => $password,
 263     mailto => $mailto,
 264
 265     mngmt_nic => undef,
 266     hostname => $hostname,
 267     fqdn => undef,
 268     ipaddress => undef,
 269     netmask => undef,
 270     gateway => undef,
 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_ack_view();
2168     });
2169
2170     $hostentry->grab_focus();
2171 }
2172
2173 sub create_ack_view {
2174
2175     cleanup_view();
2176
2177     my $ack_template = "${proxmox_libdir}/html/ack_template.htm";
2178     my $ack_html = "${proxmox_libdir}/html/$steps[$step_number]->{html}";
2179     my $html_data = file_get_contents($ack_template);
2180
2181     my %config_values = (
2182         __target_hd__ => $target_hd,
2183         __target_fs__ => $config_options->{filesys},
2184         __country__ => $country,
2185         __timezone__ => $timezone,
2186         __keymap__ => $keymap,
2187         __mailto__ => $mailto,
2188         __interface__ => $ipconf->{ifaces}->{$ipconf->{selected}}->{name},
2189         __hostname__ => $hostname,
2190         __ip__ => $ipaddress,
2191         __netmask__ => $netmask,
2192         __gateway__ => $gateway,
2193         __dnsserver__ => $dnsserver,
2194     );
2195
2196     while ( my ($k, $v) = each %config_values) {
2197         $html_data =~ s/$k/$v/g;
2198     }
2199
2200     write_config($html_data, $ack_html);
2201
2202     display_html();
2203
2204     set_next(undef, sub {
2205         $step_number++;
2206         create_extract_view();
2207     });
2208 }
2209
2210 sub get_device_desc {
2211     my ($devname, $size, $model) = @_;
2212
2213     if ($size && ($size > 0)) {
2214         $size = int($size/2048); # size in MB, from 512B "sectors"
2215
2216         my $text = "$devname (";
2217         if ($size >= 1024) {
2218             $size = int($size/1024); # size in GB
2219             $text .= "${size}GB";
2220         } else {
2221             $text .= "${size}MB";
2222         }
2223
2224         $text .= ", $model" if $model;
2225         $text .= ")";
2226
2227     } else {
2228         return $devname;
2229     }
2230 }
2231
2232 sub update_layout {
2233     my ($cb, $kmap) = @_;
2234
2235     my $ind;
2236     my $def;
2237     my $i = 0;
2238     my $kmaphash = $cmap->{kmaphash};
2239     foreach my $layout (sort keys %$kmaphash) {
2240         $def = $i if $kmaphash->{$layout} eq 'en-us';
2241         $ind = $i if $kmap && $kmaphash->{$layout} eq $kmap;
2242         $i++;
2243     }
2244
2245     $cb->set_active ($ind || $def || 0);
2246 }
2247
2248 my $lastzonecb;
2249 sub update_zonelist {
2250     my ($box, $cc) = @_;
2251
2252     my $cczones = $cmap->{cczones};
2253     my $zones = $cmap->{zones};
2254
2255     my $sel;
2256     if ($lastzonecb) {
2257         $sel = $lastzonecb->get_active_text();
2258         $box->remove ($lastzonecb);
2259     } else {
2260         $sel = $timezone; # used once to select default
2261     }
2262
2263     my $cb = $lastzonecb = Gtk3::ComboBoxText->new();
2264     $cb->set_size_request (200, -1);
2265
2266     $cb->signal_connect ('changed' => sub {
2267         $timezone = $cb->get_active_text();
2268     });
2269
2270     my @za;
2271     if ($cc && defined ($cczones->{$cc})) {
2272         @za = keys %{$cczones->{$cc}};
2273     } else {
2274         @za = keys %$zones;
2275     }
2276     my $ind;
2277     my $i = 0;
2278     foreach my $zone (sort @za) {
2279         $ind = $i if $sel && $zone eq $sel;
2280         $cb->append_text ($zone);
2281         $i++;
2282     }
2283
2284     $cb->set_active ($ind || 0);
2285
2286     $cb->show;
2287     $box->pack_start ($cb, 0, 0, 0);
2288 }
2289
2290 sub create_password_view {
2291
2292     cleanup_view ();
2293
2294     my $vbox2 =  Gtk3::VBox->new (0, 0);
2295     $inbox->pack_start ($vbox2, 1, 0, 0);
2296     my $vbox =  Gtk3::VBox->new (0, 0);
2297     $vbox2->pack_start ($vbox, 0, 0, 10);
2298
2299     my $hbox1 = Gtk3::HBox->new (0, 0);
2300     my $label = Gtk3::Label->new ("Password");
2301     $label->set_size_request (150, -1);
2302     $label->set_alignment (1, 0.5);
2303     $hbox1->pack_start ($label, 0, 0, 10);
2304     my $pwe1 = Gtk3::Entry->new ();
2305     $pwe1->set_visibility (0);
2306     $pwe1->set_text($password) if $password;
2307     $pwe1->set_size_request (200, -1);
2308     $hbox1->pack_start ($pwe1, 0, 0, 0);
2309
2310     my $hbox2 = Gtk3::HBox->new (0, 0);
2311     $label = Gtk3::Label->new ("Confirm");
2312     $label->set_size_request (150, -1);
2313     $label->set_alignment (1, 0.5);
2314     $hbox2->pack_start ($label, 0, 0, 10);
2315     my $pwe2 = Gtk3::Entry->new ();
2316     $pwe2->set_visibility (0);
2317     $pwe2->set_text($password) if $password;
2318     $pwe2->set_size_request (200, -1);
2319     $hbox2->pack_start ($pwe2, 0, 0, 0);
2320
2321     my $hbox3 = Gtk3::HBox->new (0, 0);
2322     $label = Gtk3::Label->new ("E-Mail");
2323     $label->set_size_request (150, -1);
2324     $label->set_alignment (1, 0.5);
2325     $hbox3->pack_start ($label, 0, 0, 10);
2326     my $eme = Gtk3::Entry->new ();
2327     $eme->set_size_request (200, -1);
2328     $eme->set_text($mailto);
2329     $hbox3->pack_start ($eme, 0, 0, 0);
2330
2331
2332     $vbox->pack_start ($hbox1, 0, 0, 5);
2333     $vbox->pack_start ($hbox2, 0, 0, 5);
2334     $vbox->pack_start ($hbox3, 0, 0, 15);
2335
2336     $inbox->show_all;
2337
2338     display_html();
2339
2340     set_next (undef,  sub {
2341
2342         my $t1 = $pwe1->get_text;
2343         my $t2 = $pwe2->get_text;
2344
2345         if (length ($t1) < 5) {
2346             display_message ("Password is too short.");
2347             $pwe1->grab_focus();
2348             return;
2349         }
2350
2351         if ($t1 ne $t2) {
2352             display_message ("Password does not match.");
2353             $pwe1->grab_focus();
2354             return;
2355         }
2356
2357         my $t3 = $eme->get_text;
2358         if ($t3 !~ m/^\S+\@\S+\.\S+$/) {
2359             display_message ("E-Mail does not look like a valid address" .
2360                              " (user\@domain.tld)");
2361             $eme->grab_focus();
2362             return;
2363         }
2364
2365         if ($t3 eq 'mail@example.invalid') {
2366             display_message ("Please enter a valid E-Mail address");
2367             $eme->grab_focus();
2368             return;
2369         }
2370
2371         $password = $t1;
2372         $mailto = $t3;
2373
2374         $step_number++;
2375         create_ipconf_view();
2376     });
2377
2378     $pwe1->grab_focus();
2379
2380 }
2381
2382 sub create_country_view {
2383
2384     cleanup_view ();
2385
2386     my $countryhash = $cmap->{countryhash};
2387     my $ctr = $cmap->{country};
2388
2389     my $vbox2 =  Gtk3::VBox->new (0, 0);
2390     $inbox->pack_start ($vbox2, 1, 0, 0);
2391     my $vbox =  Gtk3::VBox->new (0, 0);
2392     $vbox2->pack_start ($vbox, 0, 0, 10);
2393
2394     my $w = Gtk3::Entry->new ();
2395     $w->set_size_request (200, -1);
2396
2397     my $c = Gtk3::EntryCompletion->new ();
2398     $c->set_text_column (0);
2399     $c->set_minimum_key_length(0);
2400     $c->set_popup_set_width (1);
2401     $c->set_inline_completion (1);
2402
2403     my $hbox2 = Gtk3::HBox->new (0, 0);
2404     my $label = Gtk3::Label->new ("Time zone");
2405     $label->set_size_request (150, -1);
2406     $label->set_alignment (1, 0.5);
2407     $hbox2->pack_start ($label, 0, 0, 10);
2408     update_zonelist ($hbox2);
2409
2410     my $hbox3 = Gtk3::HBox->new (0, 0);
2411     $label = Gtk3::Label->new ("Keyboard Layout");
2412     $label->set_size_request (150, -1);
2413     $label->set_alignment (1, 0.5);
2414     $hbox3->pack_start ($label, 0, 0, 10);
2415
2416     my $kmapcb = Gtk3::ComboBoxText->new();
2417     $kmapcb->set_size_request (200, -1);
2418     foreach my $layout (sort keys %{$cmap->{kmaphash}}) {
2419         $kmapcb->append_text ($layout);
2420     }
2421
2422     update_layout ($kmapcb);
2423     $hbox3->pack_start ($kmapcb, 0, 0, 0);
2424
2425     $kmapcb->signal_connect ('changed' => sub {
2426         my $sel = $kmapcb->get_active_text();
2427         if (my $kmap = $cmap->{kmaphash}->{$sel}) {
2428             my $xkmap = $cmap->{kmap}->{$kmap}->{x11};
2429             my $xvar = $cmap->{kmap}->{$kmap}->{x11var};
2430             syscmd ("setxkbmap $xkmap $xvar") if !$opt_testmode;
2431             $keymap = $kmap;
2432         }
2433     });
2434
2435     $w->signal_connect ('changed' => sub {
2436         my ($entry, $event) = @_;
2437         my $text = $entry->get_text;
2438
2439         if (my $cc = $countryhash->{lc($text)}) {
2440             update_zonelist ($hbox2, $cc);
2441             my $kmap = $ctr->{$cc}->{kmap} || 'en-us';
2442             update_layout ($kmapcb, $kmap);
2443         }
2444     });
2445
2446     $w->signal_connect (key_press_event => sub {
2447         my ($entry, $event) = @_;
2448         my $text = $entry->get_text;
2449
2450         my $val = $event->get_keyval;
2451
2452         if ($val == Gtk3::Gdk::KEY_Tab) {
2453             my $cc = $countryhash->{lc($text)};
2454
2455             my $found = 0;
2456             my $compl;
2457
2458             if ($cc) {
2459                 $found = 1;
2460                 $compl = $ctr->{$cc}->{name};
2461             } else {
2462                 foreach my $cc (keys %$ctr) {
2463                     my $ct = $ctr->{$cc}->{name};
2464                     if ($ct =~ m/^\Q$text\E.*$/i) {
2465                         $found++;
2466                         $compl = $ct;
2467                     }
2468                     last if $found > 1;
2469                 }
2470             }
2471
2472             if ($found == 1) {
2473                 $entry->set_text($compl);
2474                 $c->complete();
2475                 return undef;
2476             } else {
2477                 #Gtk3::Gdk::beep();
2478                 print chr(7); # beep ?
2479             }
2480
2481             $c->complete();
2482
2483             my $buf = $w->get_buffer();
2484             $buf->insert_text(-1, '', -1); # popup selection
2485
2486             return 1;
2487         }
2488
2489         return undef;
2490     });
2491
2492     my $ls = Gtk3::ListStore->new('Glib::String');
2493     foreach my $cc (sort {$ctr->{$a}->{name} cmp $ctr->{$b}->{name} } keys %$ctr) {
2494         my $iter = $ls->append();
2495         $ls->set ($iter, 0, $ctr->{$cc}->{name});
2496     }
2497     $c->set_model ($ls);
2498
2499     $w->set_completion ($c);
2500
2501     my $hbox =  Gtk3::HBox->new (0, 0);
2502
2503     $label = Gtk3::Label->new ("Country");
2504     $label->set_alignment (1, 0.5);
2505     $label->set_size_request (150, -1);
2506     $hbox->pack_start ($label, 0, 0, 10);
2507     $hbox->pack_start ($w, 0, 0, 0);
2508
2509     $vbox->pack_start ($hbox, 0, 0, 5);
2510     $vbox->pack_start ($hbox2, 0, 0, 5);
2511     $vbox->pack_start ($hbox3, 0, 0, 5);
2512
2513     if ($country && $ctr->{$country}) {
2514         $w->set_text ($ctr->{$country}->{name});
2515     }
2516
2517     $inbox->show_all;
2518
2519     display_html();
2520     set_next (undef,  sub {
2521
2522         my $text = $w->get_text;
2523
2524         if (my $cc = $countryhash->{lc($text)}) {
2525             $country = $cc;
2526             $step_number++;
2527             create_password_view();
2528             return;
2529         } else {
2530             display_message ("Please select a country first.");
2531             $w->grab_focus();
2532         }
2533     });
2534
2535     $w->grab_focus();
2536 }
2537
2538 my $target_hd_combo;
2539 my $target_hd_label;
2540
2541 my $hdopion_first_setup = 1;
2542
2543 my $create_basic_grid = sub {
2544     my $grid =  Gtk3::Grid->new();
2545     $grid->set_visible(1);
2546     $grid->set_column_spacing(10);
2547     $grid->set_row_spacing(10);
2548     $grid->set_hexpand(1);
2549
2550     $grid->set_margin_start(5);
2551     $grid->set_margin_end(5);
2552     $grid->set_margin_top(5);
2553     $grid->set_margin_bottom(5);
2554
2555     return $grid;
2556 };
2557
2558 my $create_label_widget_grid = sub {
2559     my ($labeled_widgets) = @_;
2560
2561     my $grid = &$create_basic_grid();
2562     my $row = 0;
2563
2564     for (my $i = 0; $i < @$labeled_widgets; $i += 2) {
2565         my $widget = @$labeled_widgets[$i+1];
2566         my $label = Gtk3::Label->new(@$labeled_widgets[$i]);
2567         $label->set_visible(1);
2568         $label->set_alignment (1, 0.5);
2569         $grid->attach($label, 0, $row, 1, 1);
2570         $widget->set_visible(1);
2571         $grid->attach($widget, 1, $row, 1, 1);
2572         $row++;
2573     }
2574
2575     return $grid;
2576 };
2577
2578 my $create_raid_disk_grid = sub {
2579     my $disk_labeled_widgets = [];
2580     for (my $i = 0; $i < @$hds; $i++) {
2581         my $disk_selector = Gtk3::ComboBoxText->new();
2582         $disk_selector->append_text("-- do not use --");
2583         $disk_selector->set_active(0);
2584         $disk_selector->set_visible(1);
2585         foreach my $hd (@$hds) {
2586             my ($disk, $devname, $size, $model) = @$hd;
2587             $disk_selector->append_text(get_device_desc ($devname, $size, $model));
2588             $disk_selector->{pve_disk_id} = $i;
2589             $disk_selector->signal_connect (changed => sub {
2590                 my $w = shift;
2591                 my $diskid = $w->{pve_disk_id};
2592                 my $a = $w->get_active - 1;
2593                 $config_options->{"disksel${diskid}"} = ($a >= 0) ? $hds->[$a] : undef;
2594             });
2595         }
2596
2597         if ($hdopion_first_setup) {
2598             $disk_selector->set_active ($i+1) if $hds->[$i];
2599         } else {
2600             my $hdind = 0;
2601             if (my $cur_hd = $config_options->{"disksel$i"}) {
2602                 foreach my $hd (@$hds) {
2603                     if (@$hd[1] eq @$cur_hd[1]) {
2604                         $disk_selector->set_active($hdind+1);
2605                         last;
2606                     }
2607                     $hdind++;
2608                 }
2609             }
2610         }
2611
2612         push @$disk_labeled_widgets, "Harddisk $i", $disk_selector;
2613     }
2614
2615     my $scrolled_window = Gtk3::ScrolledWindow->new();
2616     $scrolled_window->set_hexpand(1);
2617     $scrolled_window->set_propagate_natural_height(1) if @$hds > 4;
2618     $scrolled_window->add(&$create_label_widget_grid($disk_labeled_widgets));
2619     $scrolled_window->set_policy('never', 'automatic');
2620
2621     return $scrolled_window;
2622 #    &$create_label_widget_grid($disk_labeled_widgets)
2623 };
2624
2625 # shared between different ui parts (e.g., ZFS and "normal" single disk FS)
2626 my $hdsize_size_adj;
2627 my $hdsize_entry_buffer;
2628
2629 my $get_hdsize_spinbtn = sub {
2630     my $hdsize = shift;
2631
2632     $hdsize_entry_buffer //= Gtk3::EntryBuffer->new(undef, 1);
2633
2634     if (defined($hdsize)) {
2635         $hdsize_size_adj = Gtk3::Adjustment->new($config_options->{hdsize} || $hdsize, 0, $hdsize+1, 1, 1, 1);
2636     } else {
2637         die "called get_hdsize_spinbtn with \$hdsize_size_adj not defined but did not pass hdsize!\n"
2638             if !defined($hdsize_size_adj);
2639     }
2640
2641     my $spinbutton_hdsize = Gtk3::SpinButton->new($hdsize_size_adj, 1, 1);
2642     $spinbutton_hdsize->set_buffer($hdsize_entry_buffer);
2643     $spinbutton_hdsize->set_adjustment($hdsize_size_adj);
2644     $spinbutton_hdsize->set_tooltip_text("only use specified size (GB) of the harddisk (rest left unpartitioned)");
2645     return $spinbutton_hdsize;
2646 };
2647
2648 my $create_raid_advanced_grid = sub {
2649     my $labeled_widgets = [];
2650     my $spinbutton_ashift = Gtk3::SpinButton->new_with_range(9,13,1);
2651     $spinbutton_ashift->set_tooltip_text("zpool ashift property (pool sector size, default 2^12)");
2652     $spinbutton_ashift->signal_connect ("value-changed" => sub {
2653         my $w = shift;
2654         $config_options->{ashift} = $w->get_value_as_int();
2655     });
2656     $config_options->{ashift} = 12 if ! defined($config_options->{ashift});
2657     $spinbutton_ashift->set_value($config_options->{ashift});
2658     push @$labeled_widgets, "ashift";
2659     push @$labeled_widgets, $spinbutton_ashift;
2660
2661     my $combo_compress = Gtk3::ComboBoxText->new();
2662     $combo_compress->set_tooltip_text("zfs compression algorithm for rpool dataset");
2663     # note: gzip / lze not allowed for bootfs vdevs
2664     my $comp_opts = ["on","off","lzjb","lz4"];
2665     foreach my $opt (@$comp_opts) {
2666         $combo_compress->append($opt, $opt);
2667     }
2668     $config_options->{compress} = "on" if !defined($config_options->{compress});
2669     $combo_compress->set_active_id($config_options->{compress});
2670     $combo_compress->signal_connect (changed => sub {
2671         my $w = shift;
2672         $config_options->{compress} = $w->get_active_text();
2673     });
2674     push @$labeled_widgets, "compress";
2675     push @$labeled_widgets, $combo_compress;
2676
2677     my $combo_checksum = Gtk3::ComboBoxText->new();
2678     $combo_checksum->set_tooltip_text("zfs checksum algorithm for rpool dataset");
2679     my $csum_opts = ["on", "off","fletcher2", "fletcher4", "sha256"];
2680     foreach my $opt (@$csum_opts) {
2681         $combo_checksum->append($opt, $opt);
2682     }
2683     $config_options->{checksum} = "on" if !($config_options->{checksum});
2684     $combo_checksum->set_active_id($config_options->{checksum});
2685     $combo_checksum->signal_connect (changed => sub {
2686         my $w = shift;
2687         $config_options->{checksum} = $w->get_active_text();
2688     });
2689     push @$labeled_widgets, "checksum";
2690     push @$labeled_widgets, $combo_checksum;
2691
2692     my $spinbutton_copies = Gtk3::SpinButton->new_with_range(1,3,1);
2693     $spinbutton_copies->set_tooltip_text("zfs copies property for rpool dataset (in addition to RAID redundancy!)");
2694     $spinbutton_copies->signal_connect ("value-changed" => sub {
2695         my $w = shift;
2696         $config_options->{copies} = $w->get_value_as_int();
2697     });
2698     $config_options->{copies} = 1 if !defined($config_options->{copies});
2699     $spinbutton_copies->set_value($config_options->{copies});
2700     push @$labeled_widgets, "copies", $spinbutton_copies;
2701
2702     push @$labeled_widgets, "hdsize", $get_hdsize_spinbtn->();
2703     return &$create_label_widget_grid($labeled_widgets);;
2704 };
2705
2706 sub create_hdoption_view {
2707
2708     my $dialog = Gtk3::Dialog->new();
2709
2710     $dialog->set_title("Harddisk options");
2711
2712     $dialog->add_button("_OK", 1);
2713
2714     my $contarea = $dialog->get_content_area();
2715
2716     my $hbox2 =  Gtk3::Box->new('horizontal', 0);
2717     $contarea->pack_start($hbox2, 1, 1, 10);
2718
2719     my $grid =  Gtk3::Grid->new();
2720     $grid->set_column_spacing(10);
2721     $grid->set_row_spacing(10);
2722
2723     $hbox2->pack_start($grid, 1, 0, 10);
2724
2725     my $row = 0;
2726
2727     # Filesystem type
2728
2729     my $label0 = Gtk3::Label->new ("Filesystem");
2730     $label0->set_alignment (1, 0.5);
2731     $grid->attach($label0, 0, $row, 1, 1);
2732
2733     my $fstypecb = Gtk3::ComboBoxText->new();
2734
2735     my $fstype = ['ext3', 'ext4', 'xfs',
2736                   'zfs (RAID0)', 'zfs (RAID1)',
2737                   'zfs (RAID10)', 'zfs (RAIDZ-1)',
2738                   'zfs (RAIDZ-2)', 'zfs (RAIDZ-3)'];
2739
2740     push @$fstype, 'btrfs (RAID0)', 'btrfs (RAID1)', 'btrfs (RAID10)'
2741         if $setup->{enable_btrfs};
2742
2743     my $tcount = 0;
2744     foreach my $tmp (@$fstype) {
2745         $fstypecb->append_text($tmp);
2746         $fstypecb->set_active ($tcount)
2747             if $config_options->{filesys} eq $tmp;
2748         $tcount++;
2749     }
2750
2751     $grid->attach($fstypecb, 1, $row, 1, 1);
2752
2753     $hbox2->show_all();
2754
2755     $row++;
2756
2757     my $sep = Gtk3::HSeparator->new();
2758     $sep->set_visible(1);
2759     $grid->attach($sep, 0, $row, 2, 1);
2760     $row++;
2761
2762     my $hdsize_labeled_widgets = [];
2763
2764     # size compute
2765     my $hdsize = 0;
2766     if ( -b $target_hd) {
2767         $hdsize = int(hd_size ($target_hd) / (1024*1024.0)); # size in GB
2768     } elsif ($target_hd) {
2769         $hdsize = int((-s $target_hd) / (1024*1024*1024.0));
2770     }
2771
2772     my $spinbutton_hdsize = $get_hdsize_spinbtn->($hdsize);
2773     push @$hdsize_labeled_widgets, "hdsize", $spinbutton_hdsize;
2774
2775     my $entry_swapsize = Gtk3::Entry->new();
2776     $entry_swapsize->set_tooltip_text("maximum SWAP size (GB)");
2777     $entry_swapsize->signal_connect (key_press_event => \&check_float);
2778     $entry_swapsize->set_text($config_options->{swapsize}) if defined($config_options->{swapsize});
2779     push @$hdsize_labeled_widgets, "swapsize", $entry_swapsize;
2780
2781     my $entry_maxroot = Gtk3::Entry->new();
2782     if ($setup->{product} eq 'pve') {
2783         $entry_maxroot->set_tooltip_text("maximum size (GB) for LVM root volume");
2784         $entry_maxroot->signal_connect (key_press_event => \&check_float);
2785         $entry_maxroot->set_text($config_options->{maxroot}) if $config_options->{maxroot};
2786         push @$hdsize_labeled_widgets, "maxroot", $entry_maxroot;
2787     }
2788
2789     my $entry_minfree = Gtk3::Entry->new();
2790     $entry_minfree->set_tooltip_text("minimum free LVM space (GB, required for LVM snapshots)");
2791     $entry_minfree->signal_connect (key_press_event => \&check_float);
2792     $entry_minfree->set_text($config_options->{minfree}) if defined($config_options->{minfree});
2793     push @$hdsize_labeled_widgets, "minfree", $entry_minfree;
2794
2795     my $entry_maxvz;
2796     if ($setup->{product} eq 'pve') {
2797         $entry_maxvz = Gtk3::Entry->new();
2798         $entry_maxvz->set_tooltip_text("maximum size (GB) for LVM data volume");
2799         $entry_maxvz->signal_connect (key_press_event => \&check_float);
2800         $entry_maxvz->set_text($config_options->{maxvz}) if defined($config_options->{maxvz});
2801         push @$hdsize_labeled_widgets, "maxvz", $entry_maxvz;
2802     }
2803
2804     my $options_stack = Gtk3::Stack->new();
2805     $options_stack->set_visible(1);
2806     $options_stack->set_hexpand(1);
2807     $options_stack->set_vexpand(1);
2808     $options_stack->add_titled(&$create_raid_disk_grid(), "raiddisk", "Disk Setup");
2809     $options_stack->add_titled(&$create_label_widget_grid($hdsize_labeled_widgets), "hdsize", "Size Options");
2810     $options_stack->add_titled(&$create_raid_advanced_grid("zfs"), "raidzfsadvanced", "Advanced Options");
2811     $options_stack->set_visible_child_name("raiddisk");
2812     my $options_stack_switcher = Gtk3::StackSwitcher->new();
2813     $options_stack_switcher->set_halign('center');
2814     $options_stack_switcher->set_stack($options_stack);
2815     $grid->attach($options_stack_switcher, 0, $row, 2, 1);
2816     $row++;
2817     $grid->attach($options_stack, 0, $row, 2, 1);
2818     $row++;
2819
2820     $hdopion_first_setup = 0;
2821
2822     my $switch_view = sub {
2823         my $raid = $config_options->{filesys} =~ m/zfs|btrfs/;
2824         my $enable_zfs_opts = $config_options->{filesys} =~ m/zfs/;
2825
2826         $target_hd_combo->set_visible(!$raid);
2827         $options_stack->get_child_by_name("hdsize")->set_visible(!$raid);
2828         $options_stack->get_child_by_name("raiddisk")->set_visible($raid);
2829         $options_stack_switcher->set_visible($enable_zfs_opts);
2830         $options_stack->get_child_by_name("raidzfsadvanced")->set_visible($enable_zfs_opts);
2831         if ($raid) {
2832             $target_hd_label->set_text("Target: $config_options->{filesys} ");
2833             $options_stack->set_visible_child_name("raiddisk");
2834         } else {
2835             $target_hd_label->set_text("Target Harddisk: ");
2836         }
2837         my (undef, $pref_width) = $dialog->get_preferred_width();
2838         my (undef, $pref_height) = $dialog->get_preferred_height();
2839         $pref_height = 750 if $pref_height > 750;
2840         $dialog->resize($pref_width, $pref_height);
2841     };
2842
2843     &$switch_view();
2844
2845     $fstypecb->signal_connect (changed => sub {
2846         $config_options->{filesys} = $fstypecb->get_active_text();
2847         &$switch_view();
2848     });
2849
2850     $dialog->show();
2851
2852     $dialog->run();
2853
2854     my $get_float = sub {
2855         my ($entry) = @_;
2856
2857         my $text = $entry->get_text();
2858         return undef if !defined($text);
2859
2860         $text =~ s/^\s+//;
2861         $text =~ s/\s+$//;
2862
2863         return undef if $text !~ m/^\d+(\.\d+)?$/;
2864
2865         return $text;
2866     };
2867
2868     my $tmp;
2869
2870     if (($tmp = &$get_float($spinbutton_hdsize)) && ($tmp != $hdsize)) {
2871         $config_options->{hdsize} = $tmp;
2872     } else {
2873         delete $config_options->{hdsize};
2874     }
2875
2876     if (defined($tmp = &$get_float($entry_swapsize))) {
2877         $config_options->{swapsize} = $tmp;
2878     } else {
2879         delete $config_options->{swapsize};
2880     }
2881
2882     if (defined($tmp = &$get_float($entry_maxroot))) {
2883         $config_options->{maxroot} = $tmp;
2884     } else {
2885         delete $config_options->{maxroot};
2886     }
2887
2888     if (defined($tmp = &$get_float($entry_minfree))) {
2889         $config_options->{minfree} = $tmp;
2890     } else {
2891         delete $config_options->{minfree};
2892     }
2893
2894     if ($entry_maxvz && defined($tmp = &$get_float($entry_maxvz))) {
2895         $config_options->{maxvz} = $tmp;
2896     } else {
2897         delete $config_options->{maxvz};
2898     }
2899
2900     $dialog->destroy();
2901 }
2902
2903 my $get_raid_devlist = sub {
2904
2905     my $dev_name_hash = {};
2906
2907     my $devlist = [];
2908     for (my $i = 0; $i < @$hds; $i++) {
2909         if (my $hd = $config_options->{"disksel$i"}) {
2910             my ($disk, $devname, $size, $model) = @$hd;
2911             die "device '$devname' is used more than once\n"
2912                 if $dev_name_hash->{$devname};
2913             $dev_name_hash->{$devname} = $hd;
2914             push @$devlist, $hd;
2915         }
2916     }
2917
2918     return $devlist;
2919 };
2920
2921 sub zfs_mirror_size_check {
2922     my ($expected, $actual) = @_;
2923
2924     die "mirrored disks must have same size\n"
2925         if abs($expected - $actual) > $expected / 10;
2926 }
2927
2928 sub get_zfs_raid_setup {
2929
2930     my $filesys = $config_options->{filesys};
2931
2932     my $devlist = &$get_raid_devlist();
2933
2934     my $diskcount = scalar(@$devlist);
2935     die "$filesys needs at least one device\n" if $diskcount < 1;
2936
2937     my $bootdevlist = [];
2938
2939     my $cmd= '';
2940     if ($filesys eq 'zfs (RAID0)') {
2941         push @$bootdevlist, @$devlist[0];
2942         foreach my $hd (@$devlist) {
2943             $cmd .= " @$hd[1]";
2944         }
2945     } elsif ($filesys eq 'zfs (RAID1)') {
2946         die "zfs (RAID1) needs at least 2 device\n" if $diskcount < 2;
2947         $cmd .= ' mirror ';
2948         my $hd = @$devlist[0];
2949         my $expected_size = @$hd[2]; # all disks need approximately same size
2950         foreach $hd (@$devlist) {
2951             zfs_mirror_size_check($expected_size, @$hd[2]);
2952             $cmd .= " @$hd[1]";
2953             push @$bootdevlist, $hd;
2954         }
2955     } elsif ($filesys eq 'zfs (RAID10)') {
2956         die "zfs (RAID10) needs at least 4 device\n" if $diskcount < 4;
2957         die "zfs (RAID10) needs an even number of devices\n" if $diskcount & 1;
2958
2959         push @$bootdevlist, @$devlist[0], @$devlist[1];
2960
2961         for (my $i = 0; $i < $diskcount; $i+=2) {
2962             my $hd1 = @$devlist[$i];
2963             my $hd2 = @$devlist[$i+1];
2964             zfs_mirror_size_check(@$hd1[2], @$hd2[2]); # pairs need approximately same size
2965             $cmd .= ' mirror ' . @$hd1[1] . ' ' . @$hd2[1];
2966         }
2967
2968     } elsif ($filesys =~ m/^zfs \(RAIDZ-([123])\)$/) {
2969         my $level = $1;
2970         my $mindisks = 2 + $level;
2971         die "zfs (RAIDZ-$level) needs at least $mindisks devices\n" if scalar(@$devlist) < $mindisks;
2972         my $hd = @$devlist[0];
2973         my $expected_size = @$hd[2]; # all disks need approximately same size
2974         $cmd .= " raidz$level";
2975         foreach $hd (@$devlist) {
2976             zfs_mirror_size_check($expected_size, @$hd[2]);
2977             $cmd .= " @$hd[1]";
2978             push @$bootdevlist, $hd;
2979         }
2980     } else {
2981         die "unknown zfs mode '$filesys'\n";
2982     }
2983
2984     return ($devlist, $bootdevlist, $cmd);
2985 }
2986
2987 sub get_btrfs_raid_setup {
2988
2989     my $filesys = $config_options->{filesys};
2990
2991     my $devlist = &$get_raid_devlist();
2992
2993     my $diskcount = scalar(@$devlist);
2994     die "$filesys needs at least one device\n" if $diskcount < 1;
2995
2996     my $mode;
2997
2998     if ($diskcount == 1) {
2999         $mode = 'single';
3000     } else {
3001         if ($filesys eq 'btrfs (RAID0)') {
3002             $mode = 'raid0';
3003         } elsif ($filesys eq 'btrfs (RAID1)') {
3004             die "btrfs (RAID1) needs at least 2 device\n" if $diskcount < 2;
3005             $mode = 'raid1';
3006         } elsif ($filesys eq 'btrfs (RAID10)') {
3007             die "btrfs (RAID10) needs at least 4 device\n" if $diskcount < 4;
3008             $mode = 'raid10';
3009         } else {
3010             die "unknown btrfs mode '$filesys'\n";
3011         }
3012     }
3013
3014     return ($devlist, $mode);
3015 }
3016
3017 sub create_hdsel_view {
3018
3019     $prev->set_sensitive(1); # enable previous button at this point
3020
3021     cleanup_view ();
3022
3023     my $vbox =  Gtk3::VBox->new (0, 0);
3024     $inbox->pack_start ($vbox, 1, 0, 0);
3025     my $hbox =  Gtk3::HBox->new (0, 0);
3026     $vbox->pack_start ($hbox, 0, 0, 10);
3027
3028     my ($disk, $devname, $size, $model) = @{@$hds[0]};
3029     $target_hd = $devname;
3030
3031     $target_hd_label = Gtk3::Label->new ("Target Harddisk: ");
3032     $hbox->pack_start ($target_hd_label, 0, 0, 0);
3033
3034     $target_hd_combo = Gtk3::ComboBoxText->new();
3035
3036     foreach my $hd (@$hds) {
3037         ($disk, $devname, $size, $model) = @$hd;
3038         $target_hd_combo->append_text (get_device_desc ($devname, $size, $model));
3039     }
3040
3041     $target_hd_combo->set_active (0);
3042     $target_hd_combo->signal_connect (changed => sub {
3043         $a = shift->get_active;
3044         my ($disk, $devname) = @{@$hds[$a]};
3045         $target_hd = $devname;
3046     });
3047
3048     $hbox->pack_start ($target_hd_combo, 0, 0, 10);
3049
3050     my $options = Gtk3::Button->new ('_Options');
3051     $options->signal_connect (clicked => \&create_hdoption_view);
3052     $hbox->pack_start ($options, 0, 0, 0);
3053
3054
3055     $inbox->show_all;
3056
3057     display_html();
3058
3059     set_next (undef, sub {
3060
3061         if ($config_options->{filesys} =~ m/zfs/) {
3062             eval { get_zfs_raid_setup(); };
3063             if (my $err = $@) {
3064                 display_message ("Warning: $err\n" .
3065                                  "Please fix ZFS setup first.");
3066             } else {
3067                 $step_number++;
3068                 create_country_view();
3069             }
3070         } elsif ($config_options->{filesys} =~ m/btrfs/) {
3071             eval { get_btrfs_raid_setup(); };
3072             if (my $err = $@) {
3073                 display_message ("Warning: $err\n" .
3074                                  "Please fix BTRFS setup first.");
3075             } else {
3076                 $step_number++;
3077                 create_country_view();
3078             }
3079         } else {
3080             $step_number++;
3081             create_country_view();
3082         }
3083     });
3084 }
3085
3086 sub create_extract_view {
3087
3088     cleanup_view ();
3089
3090     display_info();
3091
3092     $next->set_sensitive(0);
3093
3094     my $vbox =  Gtk3::VBox->new (0, 0);
3095     $inbox->pack_start ($vbox, 1, 0, 0);
3096     my $hbox =  Gtk3::HBox->new (0, 0);
3097     $vbox->pack_start ($hbox, 0, 0, 10);
3098
3099     my $vbox2 =  Gtk3::VBox->new (0, 0);
3100     $hbox->pack_start ($vbox2, 0, 0, 0);
3101
3102     $progress_status = Gtk3::Label->new ('');
3103     $vbox2->pack_start ($progress_status, 1, 1, 0);
3104
3105     $progress = Gtk3::ProgressBar->new;
3106     $progress->set_show_text(1);
3107     $progress->set_size_request (600, -1);
3108
3109     $vbox2->pack_start ($progress, 0, 0, 0);
3110
3111     $inbox->show_all();
3112
3113     my $tdir = $opt_testmode ? "target" : "/target";
3114     mkdir $tdir;
3115     my $base = "${proxmox_cddir}/$setup->{product}-base.squashfs";
3116
3117     eval  { extract_data ($base, $tdir); };
3118     my $err = $@;
3119
3120     $next->set_sensitive(1);
3121
3122     set_next ("_Reboot", sub { exit (0); } );
3123
3124     if ($err) {
3125         display_html("fail.htm");
3126         display_error($err);
3127     } else {
3128         cleanup_view();
3129         display_html("success.htm");
3130     }
3131 }
3132
3133 sub create_intro_view {
3134
3135     $prev->set_sensitive(0);
3136
3137     cleanup_view();
3138
3139     if ($setup->{product} eq 'pve') {
3140         eval {
3141             my $cpuinfo = file_get_contents('/proc/cpuinfo');
3142             if ($cpuinfo && !($cpuinfo =~ /^flags\s*:.*(vmx|svm)/m)) {
3143                 display_error("No support for KVM virtualisation detected.\n\n" .
3144                               "Check BIOS settings for Intel VT / AMD-V / SVM.")
3145             }
3146         };
3147     }
3148
3149     display_html();
3150
3151     $step_number++;
3152     set_next ("I a_gree", \&create_hdsel_view);
3153 }
3154
3155 $ipconf = get_ip_config ();
3156
3157 $country = detect_country() if $ipconf->{default} || $opt_testmode;
3158
3159 # read country, kmap and timezone infos
3160 $cmap = read_cmap ();
3161
3162 if (!defined($cmap->{country}->{$country})) {
3163     print $logfd "ignoring detected country '$country', invalid or unknown\n";
3164     $country = undef;
3165 }
3166
3167 create_main_window ();
3168
3169 my $initial_error = 0;
3170
3171 if (!defined ($hds) || (scalar (@$hds) <= 0)) {
3172     print "no hardisks found\n";
3173     $initial_error = 1;
3174     display_html("nohds.htm");
3175     set_next ("Reboot", sub { exit (0); } );
3176 } else {
3177     foreach my $hd (@$hds) {
3178         my ($disk, $devname) = @$hd;
3179         next if $devname =~ m|^/dev/md\d+$|;
3180         print "found Disk$disk N:$devname\n";
3181     }
3182 }
3183
3184 if (!$initial_error && (scalar keys %{ $ipconf->{ifaces} } == 0)) {
3185     print "no network interfaces found\n";
3186     $initial_error = 1;
3187     display_html("nonics.htm");
3188     set_next ("Reboot", sub { exit (0); } );
3189 }
3190
3191 create_intro_view () if !$initial_error;
3192
3193 Gtk3->main;
3194
3195 exit 0;