proxinstall

   1 #!/usr/bin/perl -w
   2
   3 $ENV{DEBIAN_FRONTEND} = 'noninteractive';
   4 $ENV{LC_ALL} = 'C';
   5
   6 use strict;
   7 use Getopt::Long;
   8 use IPC::Open2;
   9 use IPC::Open3;
  10 use IO::File;
  11 use IO::Dir;
  12 use IO::Select;
  13 use Cwd 'abs_path';
  14 use Gtk3 '-init';
  15 use Gtk3::WebKit;
  16 use Encode;
  17 use String::ShellQuote;
  18 use Data::Dumper;
  19
  20 my $release = '3.3';
  21
  22 my $kapi = `uname -r`;
  23 chomp $kapi;
  24
  25 my $opt_testmode;
  26
  27 if (!$ENV{G_SLICE} ||  $ENV{G_SLICE} ne "always-malloc") {
  28     die "do not use slice allocator (run with 'G_SLICE=always-malloc ./proxinstall ...')\n";
  29 }
  30
  31 if (!GetOptions ('testmode=s' => \$opt_testmode)) {
  32     die "usage error\n";
  33     exit (-1);
  34 }
  35
  36 my $logfd = IO::File->new (">/tmp/install.log");
  37
  38 my $proxmox_dir = $opt_testmode ? Cwd::cwd() : "/var/lib/pve-installer";
  39
  40 my $grub_plattform = "pc"; # pc, efi-amd64 or efi-ia32
  41
  42 $grub_plattform = "efi-amd64" if -d "/sys/firmware/efi";
  43
  44 my ($window, $cmdbox, $inbox, $htmlview);
  45 my ($next, $next_fctn, $target_hd, $master_hd);
  46 my ($progress, $progress_status);
  47 my ($ipaddress, $ip_1, $ip_2, $ip_3, $ip_4);
  48 my ($netmask, $mask_1, $mask_2, $mask_3, $mask_4);
  49 my ($gateway, $gw_1, $gw_2, $gw_3, $gw_4);
  50 my ($dnsserver, $dns_1, $dns_2, $dns_3, $dns_4);
  51 my $hostname = 'proxmox';
  52 my $domain = 'domain.tld';
  53 my $cmdline = `cat /proc/cmdline` || '';
  54 my $ipconf;
  55 my $country;
  56 my $timezone = 'Europe/Vienna';
  57 my $password;
  58 my $mailto;
  59 my $keymap = 'en-us';
  60 my $cmap;
  61
  62 # parse command line args
  63
  64 my $config_options = {};
  65
  66 $config_options->{filesys} = ($cmdline =~ m/\sext4(\s.*)$/) ? 'ext4' : 'ext3';
  67
  68 if ($cmdline =~ m/hdsize=(\d+(\.\d+)?)[\s\n]/i) {
  69     $config_options->{hdsize} = $1;
  70 }
  71
  72 if ($cmdline =~ m/swapsize=(\d+(\.\d+)?)[\s\n]/i) {
  73     $config_options->{swapsize} = $1;
  74 }
  75
  76 if ($cmdline =~ m/maxroot=(\d+(\.\d+)?)[\s\n]/i) {
  77     $config_options->{maxroot} = $1;
  78 }
  79
  80 if ($cmdline =~ m/minfree=(\d+(\.\d+)?)[\s\n]/i) {
  81     $config_options->{minfree} = $1;
  82 }
  83
  84 if ($cmdline =~ m/maxvz=(\d+(\.\d+)?)[\s\n]/i) {
  85     $config_options->{maxvz} = $1;
  86 }
  87
  88 my $postfix_main_cf = <<_EOD;
  89 # See /usr/share/postfix/main.cf.dist for a commented, more complete version
  90
  91 myhostname=__FQDN__
  92
  93 smtpd_banner = \$myhostname ESMTP \$mail_name (Debian/GNU)
  94 biff = no
  95
  96 # appending .domain is the MUA's job.
  97 append_dot_mydomain = no
  98
  99 # Uncomment the next line to generate "delayed mail" warnings
 100 #delay_warning_time = 4h
 101
 102 alias_maps = hash:/etc/aliases
 103 alias_database = hash:/etc/aliases
 104 mydestination = \$myhostname, localhost.\$mydomain, localhost
 105 relayhost =
 106 mynetworks = 127.0.0.0/8
 107 inet_interfaces = loopback-only
 108 recipient_delimiter = +
 109
 110 _EOD
 111
 112 sub shellquote {
 113     my $str = shift;
 114
 115     return String::ShellQuote::shell_quote($str);
 116 }
 117
 118 sub cmd2string {
 119     my ($cmd) = @_;
 120
 121     die "no arguments" if !$cmd;
 122
 123     return $cmd if !ref($cmd);
 124
 125     my @qa = ();
 126     foreach my $arg (@$cmd) { push @qa, shellquote($arg); }
 127
 128     return join (' ', @qa);
 129 }
 130
 131 sub syscmd {
 132     my ($cmd) = @_;
 133
 134     return run_command ($cmd, undef, undef, 1);
 135 }
 136
 137 sub run_command {
 138     my ($cmd, $func, $input, $noout) = @_;
 139
 140     my $cmdstr;
 141     if (!ref($cmd)) {
 142         $cmdstr = $cmd;
 143         if ($cmd =~ m/|/) {
 144             # see 'man bash' for option pipefail
 145             $cmd = [ '/bin/bash', '-c', "set -o pipefail && $cmd" ];
 146         } else {
 147             $cmd = [ $cmd ];
 148         }
 149     } else {
 150         $cmdstr = cmd2string($cmd);
 151     }
 152
 153     my $cmdtxt;
 154     if ($input && ($cmdstr !~ m/chpasswd/)) {
 155         $cmdtxt = "# $cmdstr <<EOD\n$input";
 156         chomp $cmdtxt;
 157         $cmdtxt .= "\nEOD\n";
 158     } else {
 159         $cmdtxt = "# $cmdstr\n";
 160     }
 161
 162     if ($opt_testmode) {
 163         print $cmdtxt;
 164         STDOUT->flush();
 165     }
 166
 167     print $logfd $cmdtxt;
 168
 169     my $reader = IO::File->new();
 170     my $writer = IO::File->new();
 171     my $error  = IO::File->new();
 172
 173     my $orig_pid = $$;
 174
 175     my $pid;
 176     eval {
 177         $pid = open3 ($writer, $reader, $error, @$cmd) || die $!;
 178     };
 179
 180     my $err = $@;
 181
 182     # catch exec errors
 183     if ($orig_pid != $$) {
 184         POSIX::_exit (1);
 185         kill ('KILL', $$);
 186     }
 187
 188     die $err if $err;
 189
 190     print $writer $input if defined $input;
 191     close $writer;
 192
 193     my $select = new IO::Select;
 194     $select->add ($reader);
 195     $select->add ($error);
 196
 197     my ($ostream, $logout) = ('', '', '');
 198
 199     while ($select->count) {
 200         my @handles = $select->can_read (0.2);
 201
 202         Gtk3->main_iteration while Gtk3->events_pending;
 203
 204         next if !scalar (@handles); # timeout
 205
 206         foreach my $h (@handles) {
 207             my $buf = '';
 208             my $count = sysread ($h, $buf, 4096);
 209             if (!defined ($count)) {
 210                 my $err = $!;
 211                 kill (9, $pid);
 212                 waitpid ($pid, 0);
 213                 die "command '$cmd' failed: $err";
 214             }
 215             $select->remove ($h) if !$count;
 216             if ($h eq $reader) {
 217                 $ostream .= $buf if !($noout || $func);
 218                 $logout .= $buf;
 219                 while ($logout =~ s/^([^\010\r\n]*)(\r|\n|(\010)+|\r\n)//s) {
 220                     my $line = $1;
 221                     &$func($line) if $func;
 222                 }
 223
 224             } elsif ($h eq $error) {
 225                 $ostream .= $buf if !($noout || $func);
 226             }
 227             print $buf;
 228             STDOUT->flush();
 229             print $logfd $buf;
 230         }
 231     }
 232
 233     &$func($logout) if $func;
 234
 235     my $rv = waitpid ($pid, 0);
 236
 237     return $? if $noout; # behave like standard system();
 238
 239     my $ec = ($? >> 8);
 240
 241     if ($ec) {
 242         die "command '$cmdstr' failed with exit code $ec";
 243     }
 244
 245     return $ostream;
 246 }
 247
 248 sub detect_country {
 249
 250     print "trying to detect country...\n";
 251     my $cpid = open2(\*TMP, undef, "traceroute -N 1 -q 1 -n 8.8.8.8");
 252     return undef if !$cpid;
 253
 254     my $country;
 255
 256     my $previous_alarm = alarm (10);
 257     eval  {
 258         local $SIG{ALRM} = sub { die "timed out!\n" };
 259         my $line;
 260         while (defined ($line = <TMP>)) {
 261             print $logfd "DC TRACEROUTE: $line";
 262             if ($line =~ m/\s*\d+\s+(\d+\.\d+\.\d+\.\d+)\s/) {
 263                 my $geoip = `geoiplookup $1`;
 264                 print $logfd "DC GEOIP: $geoip";
 265                 if ($geoip =~ m/GeoIP Country Edition:\s*([A-Z]+),/) {
 266                     $country = lc ($1);
 267                     print $logfd "DC FOUND: $country\n";
 268                     last;
 269                 }
 270             }
 271         }
 272     };
 273
 274     my $err = $@;
 275
 276     alarm ($previous_alarm);
 277
 278     close (TMP);
 279
 280     if ($err) {
 281         print "unable to detect country - $err\n";
 282     } elsif ($country) {
 283         print "detected country: " . uc($country) . "\n";
 284     } else {
 285         print "unable to detect country\n";
 286     }
 287
 288     return $country;
 289 }
 290
 291 sub get_memtotal {
 292
 293     open (MEMINFO, "/proc/meminfo");
 294
 295     my $res = 512; # default to 512 if something goes wrong
 296     while (my $line = <MEMINFO>) {
 297         if ($line =~ m/^MemTotal:\s+(\d+)\s*kB/i) {
 298             $res = int ($1 / 1024);
 299         }
 300     }
 301
 302     close (MEMINFO);
 303
 304     return $res;
 305 }
 306
 307 my $total_memory = get_memtotal();
 308
 309 sub link_points_to {
 310     my ($src, $dest) = @_;
 311
 312     my ($dev1,$ino1) = stat ($src);
 313     my ($dev2,$ino2) = stat ($dest);
 314
 315     return 0 if !($dev1 && $dev2 && $ino1 && $ino2);
 316
 317     return $ino1 == $ino2 && $dev1 == $dev2;
 318 }
 319
 320 sub find_stable_path {
 321     my ($stabledir, $bdev) = @_;
 322
 323     my $dh = IO::Dir->new ($stabledir);
 324     if ($dh) {
 325         while (defined(my $tmp = $dh->read)) {
 326             my $path = "$stabledir/$tmp";
 327             if (link_points_to ($path, $bdev)) {
 328                 return wantarray ? ($path, $tmp) : $path;
 329             }
 330         }
 331
 332         $dh->close;
 333     }
 334
 335     return wantarray ? () : undef;
 336 }
 337
 338 sub find_dev_by_uuid {
 339     my $bdev = shift;
 340
 341     my ($full_path, $name) = find_stable_path ("/dev/disk/by-uuid", $bdev);
 342
 343     return $name;
 344 }
 345
 346 sub hd_list {
 347
 348     my $res = ();
 349
 350     if ($opt_testmode) {
 351         push @$res, [-1, $opt_testmode, int((-s $opt_testmode)/512), "TESTDISK"];
 352     }
 353
 354     my $count = 0;
 355
 356     foreach my $bd (</sys/block/*>) {
 357         next if $bd =~ m|^/sys/block/ram\d+$|;
 358         next if $bd =~ m|^/sys/block/loop\d+$|;
 359         next if $bd =~ m|^/sys/block/md\d+$|;
 360         next if $bd =~ m|^/sys/block/dm-.*$|;
 361         next if $bd =~ m|^/sys/block/fd\d+$|;
 362         next if $bd =~ m|^/sys/block/sr\d+$|;
 363
 364         my $dev = `cat '$bd/dev'`;
 365         chomp $dev;
 366
 367         next if !$dev;
 368
 369         my $info = `udevadm info --path $bd --query all`;
 370         next if !$info;
 371
 372         next if $info !~ m/^E: DEVTYPE=disk$/m;
 373
 374         next if $info =~ m/^E: ID_CDROM/m;
 375
 376         my ($name) = $info =~ m/^N: (\S+)$/m;
 377
 378         if ($name) {
 379             my $real_name = "/dev/$name";
 380
 381             my $size = `cat '$bd/size'`;
 382             chomp $size;
 383             $size = undef if !($size && $size =~ m/^\d+$/);
 384
 385             my $model = `cat '$bd/device/model'`;
 386             $model =~ s/^\s+//;
 387             $model =~ s/\s+$//;
 388             if (length ($model) > 30) {
 389                 $model = substr ($model, 0, 30);
 390             }
 391             push @$res, [$count++, $real_name, $size, $model] if $size;
 392         } else {
 393             print STDERR "ERROR: unable to map device $dev ($bd)\n";
 394         }
 395     }
 396
 397     return $res;
 398 }
 399
 400 sub read_cmap {
 401     my $countryfn = $opt_testmode ? "/usr/share/pve-manager/country.dat" :
 402         "/proxmox/country.dat";
 403     open (TMP, "<$countryfn") || die "unable to open '$countryfn' - $!\n";
 404     my $line;
 405     my $country = {};
 406     my $countryhash = {};
 407     my $kmap = {};
 408     my $kmaphash = {};
 409     while (defined ($line = <TMP>)) {
 410         if ($line =~ m|^map:([^\s:]+):([^:]+):([^:]+):([^:]+):([^:]+):([^:]*):$|) {
 411             $kmap->{$1} = {
 412                 name => $2,
 413                 kvm => $3,
 414                 console => $4,
 415                 x11 => $5,
 416                 x11var => $6,
 417             };
 418             $kmaphash->{$2} = $1;
 419         } elsif ($line =~ m|^([a-z]{2}):([^:]+):([^:]*):([^:]*):$|) {
 420             $country->{$1} = {
 421                 name => $2,
 422                 kmap => $3,
 423                 mirror => $4,
 424             };
 425             $countryhash->{lc($2)} = $1;
 426         } else {
 427             warn "unable to parse 'country.dat' line: $line";
 428         }
 429     }
 430     close (TMP);
 431
 432     my $zones = {};
 433     my $cczones = {};
 434     my $zonefn = "/usr/share/zoneinfo/zone.tab";
 435     open (TMP, "<$zonefn") || die "unable to open '$zonefn' - $!\n";
 436     while (defined ($line = <TMP>)) {
 437         next if $line =~ m/^\#/;
 438         next if $line =~ m/^\s*$/;
 439         if ($line =~ m|^([A-Z][A-Z])\s+\S+\s+(([^/]+)/\S+)\s|) {
 440             my $cc = lc($1);
 441             $cczones->{$cc}->{$2} = 1;
 442             $country->{$cc}->{zone} = $2 if !defined ($country->{$cc}->{zone});
 443             $zones->{$2} = 1;
 444
 445         }
 446     }
 447     close (TMP);
 448
 449     return {
 450         zones => $zones,
 451         cczones => $cczones,
 452         country => $country,
 453         countryhash => $countryhash,
 454         kmap => $kmap,
 455         kmaphash => $kmaphash,
 456     }
 457 }
 458
 459 # search for Harddisks
 460 my $hds = hd_list ();
 461
 462 sub hd_size {
 463     my ($dev) = @_;
 464
 465     foreach my $hd (@$hds) {
 466         my ($disk, $devname, $size, $model) = @$hd;
 467         return int($size/2) if $devname eq $dev;
 468     }
 469
 470     die "no such device '$dev'";
 471 }
 472
 473 # find the master boot disk - return the first found scsi/ide disk
 474 sub find_master {
 475     my ($target_hd) = @_;
 476
 477     foreach my $hd (sort { ${$a}[1] cmp ${$b}[1] } @$hds) {
 478         my ($disk, $devname) = @$hd;
 479         next if $disk < 0;
 480
 481         if ($target_hd =~ m|^/dev/sd|) {
 482             return $devname if $devname =~ m|^/dev/sd|;
 483         } elsif ($target_hd =~ m|^/dev/hd|) {
 484             return $devname if $devname =~ m|^/dev/hd|;
 485         } elsif ($target_hd =~ m|^/dev/i2o/|) {
 486             return $devname if $devname =~ m|^/dev/i2o/|;
 487         } elsif ($target_hd =~ m|^/dev/ataraid/|) {
 488             return $devname if $devname =~ m|^/dev/ataraid/|;
 489         } elsif ($target_hd =~ m|^/dev/ida/|) {
 490             return $devname if $devname =~ m|^/dev/ida/|;
 491         } elsif ($target_hd =~ m|^/dev/cciss/|) {
 492             return $devname if $devname =~ m|^/dev/cciss/|;
 493         } elsif ($target_hd =~ m|^/dev/rd/|) {
 494             return $devname if $devname =~ m|^/dev/rd/|;
 495         }
 496     }
 497
 498     return $target_hd;
 499 }
 500
 501 sub get_partition_dev {
 502     my ($target_hd, $partnum) = @_;
 503
 504     if ($target_hd =~ m|^/dev/[hxsev]d[a-z]$|) {
 505         return "${target_hd}$partnum";
 506     } elsif ($target_hd =~ m|^/dev/[^/]+/c\d+d\d+$|) {
 507         return "${target_hd}p$partnum";
 508     } elsif ($target_hd =~ m|^/dev/[^/]+/d\d+$|) {
 509         return "${target_hd}p$partnum";
 510     } elsif ($target_hd =~ m|^/dev/[^/]+/hd[a-z]$|) {
 511         return "${target_hd}$partnum";
 512     } else {
 513         die "unable to get device for partition $partnum on device $target_hd\n";
 514     }
 515
 516 }
 517
 518 sub file_get_contents {
 519     my ($filename, $max) = @_;
 520
 521     my $fh = IO::File->new($filename, "r") ||
 522         die "can't open '$filename' - $!\n";
 523
 524     local $/; # slurp mode
 525
 526     my $content = <$fh>;
 527
 528     close $fh;
 529
 530     return $content;
 531 }
 532
 533 sub write_config {
 534     my ($text, $filename) = @_;
 535
 536     my $fd = IO::File->new (">$filename") ||
 537         die "unable to open file '$filename' - $!";
 538     print $fd $text;
 539     $fd->close();
 540 }
 541
 542 sub update_progress {
 543     my ($frac, $start, $end, $text) = @_;
 544
 545     my $part = $end - $start;
 546     my $res = $start + $frac*$part;
 547
 548     $progress->set_fraction ($res);
 549     $progress->set_text (sprintf ("%d%%", int ($res*100)));
 550     $progress_status->set_text ($text) if defined ($text);
 551
 552     Gtk3->main_iteration while Gtk3->events_pending;
 553 }
 554
 555 sub create_filesystem {
 556     my ($dev, $name, $type, $start, $end, $fs, $fe, $opts) = @_;
 557
 558     $opts = '' if !$opts;
 559
 560     my $range = $end - $start;
 561     my $rs = $start + $range*$fs;
 562     my $re = $start + $range*$fe;
 563     my $max = 0;
 564
 565     update_progress (0, $rs, $re, "creating $name filesystem");
 566
 567     run_command ("mkfs.$type $opts -F $dev", sub {
 568         my $line = shift;
 569
 570         if ($line =~ m/Writing inode tables:\s+(\d+)\/(\d+)/) {
 571             $max = $2;
 572         } elsif ($max && $line =~ m/(\d+)\/$max/) {
 573             update_progress (($1/$max)*0.9, $rs, $re);
 574         } elsif ($line =~ m/Creating journal.*done/) {
 575             update_progress (0.95, $rs, $re);
 576         } elsif ($line =~ m/Writing superblocks and filesystem.*done/) {
 577             update_progress (1, $rs, $re);
 578         }
 579     });
 580 }
 581
 582 sub debconfig_set {
 583     my ($targetdir, $dcdata) = @_;
 584
 585     my $cfgfile = "/tmp/debconf.txt";
 586     write_config ($dcdata, "$targetdir/$cfgfile");
 587     syscmd ("chroot $targetdir debconf-set-selections $cfgfile");
 588     unlink "$targetdir/$cfgfile";
 589 }
 590
 591 sub diversion_add {
 592     my ($targetdir, $cmd, $new_cmd) = @_;
 593
 594     syscmd ("chroot $targetdir dpkg-divert --package proxmox " .
 595             "--add --rename $cmd") == 0 ||
 596             die "unable to exec dpkg-divert\n";
 597
 598     syscmd ("ln -sf ${new_cmd} $targetdir/$cmd") == 0 ||
 599         die "unable to link diversion to ${new_cmd}\n";
 600 }
 601
 602 sub diversion_remove {
 603     my  ($targetdir, $cmd) = @_;
 604
 605     syscmd ("mv $targetdir/${cmd}.distrib $targetdir/${cmd};") == 0 ||
 606         die "unable to remove $cmd diversion\n";
 607
 608     syscmd ("chroot $targetdir dpkg-divert --remove $cmd") == 0 ||
 609         die "unable to remove $cmd diversion\n";
 610 }
 611
 612 sub extract_data {
 613     my ($tgzfile, $targetdir) = @_;
 614
 615     die "target '$targetdir' does not exist\n" if ! -d  $targetdir;
 616
 617     my $rootdev;
 618     my $efibootdev;
 619     my $bootdev;
 620     my $datadev;
 621     my $swapfile;
 622
 623     my $filesys = $config_options->{filesys};
 624
 625     eval {
 626
 627         my $maxper = 0.25;
 628
 629         update_progress (0, 0, $maxper, "create partitions");
 630
 631         if ( -b $target_hd) {
 632             syscmd ("dd if=/dev/zero of=${target_hd} bs=512 count=256");
 633             my $hdsize = hd_size ($target_hd); # size in blocks (1024 bytes)
 634
 635             if ($config_options->{hdsize}) {
 636                 # max hdsize passed on cmdline (GB)
 637                 my $maxhdsize= $config_options->{hdsize}*1024*1024;
 638
 639                 # use $maxhdsize if specified size is lower than hdsize
 640                 if ($maxhdsize < $hdsize) {
 641                     $hdsize = $maxhdsize;
 642                 }
 643             }
 644
 645             if ($grub_plattform =~ m/^efi/) {
 646                 $efibootdev = get_partition_dev($target_hd, 1);
 647             }
 648             $bootdev = get_partition_dev ($target_hd, 2);
 649             my $lvmdev = get_partition_dev ($target_hd, 3);
 650
 651             my $efibootsize_mb = 512;
 652             my $bootsize_mb = 512;
 653
 654             my $hdsize_mb = $hdsize/1024;
 655
 656             my $pcmd = ['parted', '--script', '--align', 'optimal', $target_hd];
 657             push @$pcmd, 'unit', 'MiB';
 658             push @$pcmd, 'mklabel', 'gpt';
 659
 660             my $pnum = 1;
 661
 662             if ($efibootdev) {
 663                 push @$pcmd, 'mkpart', 'primary', 'fat32', 1, $efibootsize_mb;
 664                 push @$pcmd, 'set', $pnum, 'boot', 'on';
 665                 push @$pcmd, 'name', $pnum, 'EFI-System-Partition';
 666             } else {
 667                 push @$pcmd, 'mkpart', 'primary', 1, 2;
 668                 push @$pcmd, 'set', $pnum, 'bios_grub', 'on';
 669                 push @$pcmd, 'name', $pnum, 'Grub-Boot-Partition';
 670             }
 671             $pnum++;
 672
 673             if ($efibootdev) {
 674                 push @$pcmd, 'mkpart', 'primary', 'ext2', $efibootsize_mb, $efibootsize_mb + $bootsize_mb;
 675             } else {
 676                 push @$pcmd, 'mkpart', 'primary', 'ext2', 2, $bootsize_mb;
 677                 push @$pcmd, 'set', $pnum, 'boot', 'on';
 678             }
 679             push @$pcmd, 'name', $pnum, 'PVE-Boot-Partition';
 680             $pnum++;
 681
 682             if ($efibootdev) {
 683                 push @$pcmd, 'mkpart', 'primary', 'ext2', $efibootsize_mb + $bootsize_mb, $hdsize_mb;
 684             } else {
 685                 push @$pcmd, 'mkpart', 'primary', 'ext2', $bootsize_mb, $hdsize_mb;
 686             }
 687
 688             push @$pcmd, 'set', $pnum, 'lvm', 'on';
 689             push @$pcmd, 'name', $pnum, 'PVE-LVM2-Partition';
 690
 691             syscmd($pcmd) == 0 ||
 692                 die "unable to partition harddisk '${target_hd}'\n";
 693
 694             sleep(1); # give kernel time to reread part table
 695
 696             $rootdev = '/dev/pve/root';
 697             $datadev = '/dev/pve/data';
 698             $swapfile = '/dev/pve/swap';
 699
 700             # we use --metadatasize 250k, which reseults in "pe_start = 512"
 701             # so pe_start is aligned on a 128k boundary (advantage for SSDs)
 702             syscmd ("/sbin/pvcreate --metadatasize 250k -y -ff $lvmdev") == 0 ||
 703                 die "unable to initialize physical volume $lvmdev";
 704             syscmd ("/sbin/vgcreate pve $lvmdev") == 0 ||
 705                 die "unable to create volume group";
 706
 707             my $hdgb = int($hdsize/(1024*1024));
 708             die "hardisk too small (${hdgb}GB)" if $hdgb < 4;
 709
 710             my $swapsize;
 711             if ($config_options->{swapsize}) {
 712                 $swapsize = $config_options->{swapsize}*1024*1024;
 713             } else {
 714                 my $ss = int ($total_memory / 1024);
 715                 $ss = 4 if $ss < 4;
 716                 $ss = ($hdgb/8) if $ss > ($hdgb/8);
 717                 $swapsize = $ss*1024*1024;
 718             }
 719
 720             my $space = (($hdgb > 128) ? 16 : ($hdgb/8))*1024*1024;
 721
 722             my $maxroot;
 723             if ($config_options->{maxroot}) {
 724                 $maxroot = $config_options->{maxroot};
 725             } else {
 726                 $maxroot = 96;
 727             }
 728
 729             my $rootsize = (($hdgb > ($maxroot*4)) ? $maxroot : $hdgb/4)*1024*1024;
 730
 731             my $bootsize = $bootsize_mb * 1024;
 732             $bootsize += $efibootsize_mb * 1024 if $efibootdev;
 733
 734             my $rest = int($hdsize) - $bootsize - $swapsize - $rootsize; # in KB
 735
 736             my $minfree;
 737             if ($config_options->{minfree}) {
 738                 $minfree = (($config_options->{minfree}*1024*1024) >= $rest ) ? $space :
 739                     $config_options->{minfree}*1024*1024 ;
 740             } else {
 741                 $minfree = $space;
 742             }
 743
 744             $rest = $rest - $minfree;
 745
 746             if ($config_options->{maxvz}) {
 747                 $rest = (($config_options->{maxvz}*1024*1024) <= $rest) ?
 748                     $config_options->{maxvz}*1024*1024 : $rest;
 749             }
 750
 751             syscmd ("/sbin/lvcreate -L${swapsize}K -nswap pve") == 0 ||
 752                 die "unable to create swap volume";
 753
 754             syscmd ("/sbin/lvcreate -L${rootsize}K -nroot pve") == 0 ||
 755                 die "unable to create root volume";
 756
 757             syscmd ("/sbin/lvcreate -L${rest}K -ndata pve") == 0 ||
 758                 die "unable to create data volume";
 759
 760             syscmd ("/sbin/vgchange -a y pve") == 0 ||
 761                 die "unable to activate volume group";
 762
 763         } else {
 764             $rootdev = $target_hd;
 765             syscmd ("umount $rootdev");
 766         }
 767
 768         update_progress (0.03, 0, $maxper, "create swap space");
 769         if ($swapfile) {
 770             syscmd ("mkswap $swapfile") == 0 ||
 771                 die "unable to create swap space\n";
 772         }
 773
 774         update_progress (0.05, 0, $maxper, "creating filesystems");
 775
 776         if ( -b $target_hd) {
 777             if ($efibootdev) {
 778                 syscmd ("mkfs.vfat -F32 $efibootdev");
 779             }
 780             create_filesystem ($bootdev, 'boot', $filesys, 0.05, $maxper, 0, 0.1, '-m 0');
 781             create_filesystem ($rootdev, 'root', $filesys, 0.05, $maxper, 0.1, 0.5);
 782             create_filesystem ($datadev, 'data', $filesys, 0.05, $maxper, 0.5, 1, '-m 0');
 783         } else {
 784             create_filesystem ($rootdev, 'root', $filesys, 0.05, $maxper, 0, 1, '-m 0');
 785         }
 786
 787         update_progress (1, 0.05, $maxper, "mounting target $rootdev");
 788
 789         if ( -b $target_hd) {
 790
 791             # trigger udev to create /dev/disk/by-uuid
 792             syscmd ("udevadm trigger --subsystem-match block");
 793             syscmd ("udevadm settle --timeout 10");
 794
 795             syscmd ("mount -n $rootdev -o noatime,barrier=0 $targetdir") == 0 ||
 796                 die "unable to mount $rootdev\n";
 797
 798             mkdir "$targetdir/boot";
 799             syscmd ("mount -n $bootdev -o noatime,barrier=0 $targetdir/boot") == 0 ||
 800                 die "unable to mount $bootdev\n";
 801
 802             if ($efibootdev) {
 803                 mkdir "$targetdir/boot/efi";
 804                 syscmd ("mount -n $efibootdev $targetdir/boot/efi") == 0 ||
 805                     die "unable to mount $efibootdev\n";
 806             }
 807
 808             mkdir "$targetdir/var";
 809             mkdir "$targetdir/var/lib";
 810             mkdir "$targetdir/var/lib/vz";
 811             syscmd ("mount -n $datadev $targetdir/var/lib/vz") == 0 ||
 812                 die "unable to mount $datadev\n";
 813
 814         } else {
 815             syscmd ("mount $rootdev $targetdir -o loop,noatime,barrier=0") == 0 ||
 816                 die "unable to mount $rootdev\n";
 817         }
 818
 819         display_html ("extract2-rulesystem.htm");
 820         update_progress (1, 0.05, $maxper, "extracting base system");
 821
 822         my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size) = stat ($tgzfile);
 823         $ino || die "unable to open file '$tgzfile' - $!\n";
 824
 825         my $files;
 826         if ($opt_testmode) {
 827             $files = `cat /pve/$release/install/pve-base.cnt`;
 828         } else {
 829             $files = `cat /proxmox/pve-base.cnt`;
 830         }
 831
 832         my $per = 0;
 833         my $count = 0;
 834
 835         run_command ("tar xvf $tgzfile -C $targetdir", sub {
 836             my $line = shift;
 837             $count++;
 838             my $nper = int (($count *100)/$files);
 839             if ($nper != $per) {
 840                 $per = $nper;
 841                 my $frac = $per > 100 ? 100 : $per/100;
 842                 update_progress ($frac, $maxper, 0.5);
 843             }
 844         });
 845
 846         syscmd ("mount -n -t tmpfs tmpfs $targetdir/tmp") == 0 ||
 847             die "unable to mount tmpfs on $targetdir/tmp\n";
 848         syscmd ("mount -n -t proc proc $targetdir/proc") == 0 ||
 849             die "unable to mount proc on $targetdir/proc\n";
 850         syscmd ("mount -n -t sysfs sysfs $targetdir/sys") == 0 ||
 851             die "unable to mount sysfs on $targetdir/sys\n";
 852
 853         display_html ("extract3-spam.htm");
 854         update_progress (1, $maxper, 0.5, "configuring base system");
 855
 856         # configure hosts
 857
 858         my $hosts =
 859             "127.0.0.1 localhost.localdomain localhost\n" .
 860             "$ipaddress $hostname.$domain $hostname pvelocalhost\n\n" .
 861             "# The following lines are desirable for IPv6 capable hosts\n\n" .
 862             "::1     ip6-localhost ip6-loopback\n" .
 863             "fe00::0 ip6-localnet\n" .
 864             "ff00::0 ip6-mcastprefix\n" .
 865             "ff02::1 ip6-allnodes\n" .
 866             "ff02::2 ip6-allrouters\n" .
 867             "ff02::3 ip6-allhosts\n";
 868
 869         write_config ($hosts, "$targetdir/etc/hosts");
 870
 871         write_config ("$hostname\n", "$targetdir/etc/hostname");
 872
 873         syscmd ("/bin/hostname $hostname") if !$opt_testmode;
 874
 875         # configure interfaces
 876
 877         my $ifaces =
 878             "auto lo\niface lo inet loopback\n\n" .
 879             "auto vmbr0\niface vmbr0 inet static\n" .
 880             "\taddress $ipaddress\n" .
 881             "\tnetmask $netmask\n" .
 882             "\tgateway $gateway\n" .
 883             "\tbridge_ports eth0\n" .
 884             "\tbridge_stp off\n" .
 885             "\tbridge_fd 0\n";
 886
 887         write_config ($ifaces, "$targetdir/etc/network/interfaces");
 888
 889         # configure dns
 890
 891         my $resolfconf = "search $domain\nnameserver $dnsserver\n";
 892         write_config ($resolfconf, "$targetdir/etc/resolv.conf");
 893
 894         # try to use UUID=XXX for boot device
 895         my $boot_uuid = $bootdev;
 896         if (my $uuid = find_dev_by_uuid ($bootdev)) {
 897             $boot_uuid = "UUID=$uuid";
 898         }
 899
 900         # configure fstab
 901
 902         my $fstab =
 903             "# <file system> <mount point> <type> <options> <dump> <pass>\n" .
 904             "$rootdev / $filesys errors=remount-ro 0 1\n";
 905
 906         $fstab .= "$datadev /var/lib/vz $filesys defaults 0 1\n" if $datadev;
 907
 908         $fstab .= "${boot_uuid} /boot $filesys defaults 0 1\n" if $boot_uuid;
 909
 910         if ($efibootdev) {
 911             my $efi_boot_uuid = $efibootdev;
 912             if (my $uuid = find_dev_by_uuid ($efibootdev)) {
 913                 $efi_boot_uuid = "UUID=$uuid";
 914             }
 915
 916             $fstab .= "${efi_boot_uuid} /boot/efi vfat defaults 0 1\n";
 917         }
 918
 919         $fstab .= "$swapfile none swap sw 0 0\n" if $swapfile;
 920
 921         $fstab .= "proc /proc proc defaults 0 0\n";
 922
 923         write_config ($fstab, "$targetdir/etc/fstab");
 924         write_config ("", "$targetdir/etc/mtab");
 925
 926         syscmd ("cp ${proxmox_dir}/policy-disable-rc.d " .
 927                 "$targetdir/usr/sbin/policy-rc.d") == 0 ||
 928                 die "unable to copy policy-rc.d\n";
 929         syscmd ("cp ${proxmox_dir}/fake-start-stop-daemon " .
 930                 "$targetdir/sbin/") == 0 ||
 931                 die "unable to copy start-stop-daemon\n";
 932
 933         diversion_add ($targetdir, "/sbin/start-stop-daemon", "/sbin/fake-start-stop-daemon");
 934         diversion_add ($targetdir, "/usr/sbin/update-grub", "/bin/true");
 935         diversion_add ($targetdir, "/usr/sbin/update-initramfs", "/bin/true");
 936
 937         syscmd ("touch  $targetdir/proxmox_install_mode");
 938
 939         debconfig_set ($targetdir, <<_EOD);
 940 locales locales/default_environment_locale select en_US.UTF-8
 941 locales locales/locales_to_be_generated select en_US.UTF-8 UTF-8
 942 samba-common samba-common/dhcp boolean false
 943 samba-common samba-common/workgroup string WORKGROUP
 944 postfix postfix/main_mailer_type select Local only
 945 console-data console-data/keymap/policy select Don\'t touch keymap
 946 _EOD
 947
 948         my $pkgdir = $opt_testmode ? "packages" : "/proxmox/packages";
 949         my $pkg_count = 0;
 950         while (<$pkgdir/*.deb>) { $pkg_count++ };
 951
 952         $count = 0;
 953         while (<$pkgdir/*.deb>) {
 954             chomp;
 955             my $path = $_;
 956             my ($deb) = $path =~ m/$pkgdir\/(.*\.deb)/;
 957             if ($deb =~ m/^grub-efi-/ && $deb !~ m/^grub-${grub_plattform}/) {
 958                 $count++;
 959                 next;
 960             }
 961             update_progress ($count/$pkg_count, 0.5, 0.75, "extracting $deb");
 962             print "extracting: $deb\n";
 963             syscmd ("cp $path $targetdir/tmp/$deb") == 0 ||
 964                 die "installation of package $deb failed\n";
 965             syscmd ("chroot $targetdir dpkg --force-depends --no-triggers --unpack /tmp/$deb") == 0 ||
 966                 die "installation of package $deb failed\n";
 967             update_progress ((++$count)/$pkg_count, 0.5, 0.75);
 968         }
 969
 970         display_html ("extract4-virus.htm");
 971
 972         my $cmd = "chroot $targetdir dpkg --force-confold --configure -a";
 973         $count = 0;
 974         run_command ($cmd, sub {
 975             my $line = shift;
 976             if ($line =~ m/Setting up\s+(\S+)/) {
 977                 update_progress ((++$count)/$pkg_count, 0.75, 0.95,
 978                                  "configuring $1");
 979             }
 980         });
 981
 982         debconfig_set ($targetdir, <<_EOD);
 983 postfix postfix/main_mailer_type select No configuration
 984 _EOD
 985
 986         unlink "$targetdir/etc/mailname";
 987         $postfix_main_cf =~ s/__FQDN__/${hostname}.${domain}/;
 988         write_config ($postfix_main_cf, "$targetdir/etc/postfix/main.cf");
 989
 990         # make sure we have all postfix directories
 991         syscmd ("chroot $targetdir /usr/sbin/postfix check");
 992         # cleanup mail queue
 993         syscmd ("chroot $targetdir /usr/sbin/postsuper -d ALL");
 994
 995         unlink  "$targetdir/proxmox_install_mode";
 996
 997         # disable bacula-fd
 998         syscmd ("touch '$targetdir/etc/bacula/do_not_run'");
 999
1000         # set timezone
1001         unlink ("$targetdir/etc/localtime");
1002         symlink ("/usr/share/zoneinfo/$timezone", "$targetdir/etc/localtime");
1003         write_config ("$timezone\n", "$targetdir/etc/timezone");
1004
1005         # set console keymap
1006         if (my $kmapfile = $cmap->{kmap}->{$keymap}->{console}) {
1007             syscmd ("chroot $targetdir /usr/sbin/install-keymap '/usr/share/keymaps/i386/$kmapfile'");
1008         }
1009
1010         # set apt mirror
1011         if (my $mirror = $cmap->{country}->{$country}->{mirror}) {
1012             my $fn = "$targetdir/etc/apt/sources.list";
1013             syscmd ("sed -i 's/ftp\\.debian\\.org/$mirror/' '$fn'");
1014         }
1015
1016         # create extended_states for apt (avoid cron job warning if that
1017         # file does not exist)
1018         write_config ('', "$targetdir/var/lib/apt/extended_states");
1019
1020         # save installer settings
1021         my $ucc = uc ($country);
1022         debconfig_set ($targetdir, <<_EOD);
1023 pve-manager pve-manager/country string $ucc
1024 _EOD
1025
1026         update_progress (0.8, 0.95, 1, "make system bootable");
1027
1028         # update default grub settings
1029         syscmd ("sed -i -e 's/^GRUB_DISTRIBUTOR.*/GRUB_DISTRIBUTOR=\"Proxmox Virtual Environment\"/' -e 's/#GRUB_DISABLE_RECOVERY=.*/GRUB_DISABLE_RECOVERY=\"true\"/' $targetdir/etc/default/grub");
1030
1031         diversion_remove ($targetdir, "/usr/sbin/update-grub");
1032         diversion_remove ($targetdir, "/usr/sbin/update-initramfs");
1033
1034         if (!$opt_testmode && -b $target_hd) {
1035
1036             unlink ("$targetdir/etc/mtab");
1037             symlink ("/proc/mounts", "$targetdir/etc/mtab");
1038             syscmd ("mount -n --bind /dev $targetdir/dev");
1039
1040             syscmd ("chroot $targetdir /usr/sbin/update-initramfs -c -k $kapi") == 0 ||
1041                 die "unable to install initramfs\n";
1042
1043             syscmd ("chroot $targetdir /usr/sbin/grub-install --no-floppy --bootloader-id='proxmox' ${target_hd}") == 0 ||
1044                 die "unable to install the boot loader\n";
1045
1046             syscmd ("chroot $targetdir /usr/sbin/update-grub") == 0 ||
1047                 die "unable to install the boot loader\n";
1048
1049             syscmd ("umount $targetdir/dev");
1050         }
1051
1052
1053         # cleanup
1054
1055         # hack: remove dead.letter from sshd installation
1056         syscmd ("rm -rf $targetdir/dead.letter");
1057
1058         unlink "$targetdir/usr/sbin/policy-rc.d";
1059
1060         diversion_remove ($targetdir, "/sbin/start-stop-daemon");
1061
1062         # set root password
1063         my $octets = encode("utf-8", $password);
1064         run_command ("chroot $targetdir /usr/sbin/chpasswd", undef,
1065                      "root:$octets\n");
1066
1067         # create pmxcfs DB
1068
1069         my $tmpdir = "$targetdir/tmp/pve";
1070         mkdir $tmpdir;
1071
1072         # write vnc keymap to datacenter.cfg
1073         my $vnckmap = $cmap->{kmap}->{$keymap}->{kvm} || 'en-us';
1074         write_config ("keyboard: $vnckmap\n",
1075                       "$tmpdir/datacenter.cfg");
1076
1077         # save admin email
1078         write_config ("user:root\@pam:1:0:::${mailto}::\n",
1079                       "$tmpdir/user.cfg");
1080
1081         run_command("chroot $targetdir /usr/bin/create_pmxcfs_db /tmp/pve /var/lib/pve-cluster/config.db");
1082
1083         syscmd ("rm -rf $tmpdir");
1084     };
1085
1086     my $err = $@;
1087
1088     update_progress (1, 0, 1, "");
1089
1090     print $err if $err;
1091
1092     if ($opt_testmode) {
1093         syscmd ("chroot $targetdir /usr/bin/dpkg-query -W --showformat='\${package}\n'> pve-final.pkglist");
1094     }
1095
1096     syscmd ("umount $targetdir/boot/efi") if $efibootdev;
1097     syscmd ("umount $targetdir/boot");
1098     syscmd ("umount $targetdir/var/lib/vz");
1099     syscmd ("umount $targetdir/tmp");
1100     syscmd ("umount $targetdir/proc");
1101     syscmd ("umount $targetdir/sys");
1102     syscmd ("umount -d $targetdir");
1103
1104     die $err if $err;
1105 }
1106
1107 sub display_html {
1108     my ($filename) = @_;
1109
1110     my $path = "${proxmox_dir}/html/$filename";
1111     my $url = "file://$path";
1112
1113     my $data = file_get_contents($path);
1114
1115     if ($filename eq 'license.htm') {
1116         my $licensefn = -f "/EULA" ? "/EULA" :
1117             $opt_testmode ? "./copyright" :
1118             "/usr/share/doc/pve-installer/copyright";
1119         my $license = decode('utf8', file_get_contents($licensefn));
1120         $license =~ m/^\s+(.+\n)/;
1121         my $title = $licensefn eq '/EULA' ? "END USER LICENSE AGREEMENT (EULA)": $1;
1122         $data =~ s/__LICENSE__/$license/;
1123         $data =~ s/__LICENSE_TITLE__/$title/;
1124     }
1125
1126     $htmlview->load_html_string($data, $url);
1127 }
1128
1129 sub set_next {
1130     my ($text, $fctn) = @_;
1131
1132     $next_fctn = $fctn;
1133     $text = "_Next" if !$text;
1134     $next->set_label ($text);
1135
1136     $next->grab_focus ();
1137 }
1138
1139 sub url_requested {
1140     my ($doc, $url, $stream) = @_;
1141
1142     $stream->set_cancel_func (sub {}); # hack: avoid warning
1143
1144     my $path = "${proxmox_dir}/html/$url";
1145
1146     if (-f $path) {
1147         open (HTMLTMP, $path) ||
1148             die "unable to open file '$path' - $! ";
1149         my $buf;
1150         while (my $i = read (HTMLTMP, $buf, 4096)) {
1151             $stream->write ($buf);
1152             Gtk3->main_iteration while Gtk3->events_pending;
1153         }
1154         close (HTMLTMP);
1155     }
1156
1157     #$stream->close(); # hack: dont close - avoid crash
1158 }
1159
1160 sub create_main_window {
1161
1162     $window = Gtk3::Window->new ();
1163     $window->set_default_size (1024, 768);
1164     $window->set_has_resize_grip(0);
1165     $window->set_decorated (0) if !$opt_testmode;
1166
1167     my $vbox = Gtk3::VBox->new (0, 0);
1168
1169     my $image = Gtk3::Image->new_from_file  ("${proxmox_dir}/proxlogo.xpm");
1170     $vbox->pack_start ($image, 0, 0, 0);
1171
1172     my $hbox = Gtk3::HBox->new (0, 0);
1173     $vbox->pack_start ($hbox, 1, 1, 0);
1174
1175  #  my $f1 = Gtk3::Frame->new ('test');
1176  #  $f1->set_shadow_type ('none');
1177  #  $hbox->pack_start ($f1, 1, 1, 0);
1178
1179     my $sep1 = Gtk3::HSeparator->new;
1180     $vbox->pack_start ($sep1, 0, 0, 0);
1181
1182     $cmdbox = Gtk3::HBox->new ();
1183     $vbox->pack_start ($cmdbox, 0, 0, 10);
1184
1185     $next = Gtk3::Button->new ('_Next');
1186     $next->signal_connect (clicked => sub { &$next_fctn (); });
1187     $cmdbox->pack_end ($next, 0, 0, 10);
1188     my $abort = Gtk3::Button->new ('_Abort');
1189     $abort->set_can_focus (0);
1190     $cmdbox->pack_start ($abort, 0, 0, 10);
1191     $abort->signal_connect (clicked => sub { exit (-1); });
1192
1193     my $vbox2 = Gtk3::VBox->new (0, 0);
1194     $hbox->add ($vbox2);
1195
1196     $htmlview = Gtk3::WebKit::WebView->new();
1197     my $scrolls = Gtk3::ScrolledWindow->new();
1198     $scrolls->add($htmlview);
1199
1200     my $hbox2 = Gtk3::HBox->new (0, 0);
1201     $hbox2->pack_start ($scrolls, 1, 1, 0);
1202
1203     $vbox2->pack_start ($hbox2, 1, 1, 0);
1204
1205     my $vbox3 = Gtk3::VBox->new (0, 0);
1206     $vbox2->pack_start ($vbox3, 0, 0, 0);
1207
1208     my $sep2 = Gtk3::HSeparator->new;
1209     $vbox3->pack_start ($sep2, 0, 0, 0);
1210
1211     $inbox = Gtk3::HBox->new (0, 0);
1212     $vbox3->pack_start ($inbox, 0, 0, 0);
1213
1214     $window->add ($vbox);
1215
1216     $window->show_all;
1217     $window->realize ();
1218 }
1219
1220 sub cleanup_view {
1221     my $list = $inbox->get_children;
1222     foreach my $c (@$list) {
1223         next if !defined ($c);
1224         $inbox->remove ($c);
1225     }
1226 }
1227
1228 # fixme: newer GTK3 has special properties to handle numbers with Entry
1229 # only allow floating point numbers with Gtk3::Entry
1230 sub check_float {
1231     my ($entry, $event) = @_;
1232
1233
1234     my $val = $event->get_keyval;
1235
1236     if ($val == ord '.' ||
1237         $val == Gtk3::Gdk::KEY_ISO_Left_Tab ||
1238         $val == Gtk3::Gdk::KEY_Shift_L ||
1239         $val == Gtk3::Gdk::KEY_Tab ||
1240         $val == Gtk3::Gdk::KEY_Left ||
1241         $val == Gtk3::Gdk::KEY_Right ||
1242         $val == Gtk3::Gdk::KEY_BackSpace ||
1243         $val == Gtk3::Gdk::KEY_Delete ||
1244         ($val >= ord '0' && $val <= ord '9') ||
1245         ($val >= Gtk3::Gdk::KEY_KP_0 &&
1246          $val <= Gtk3::Gdk::KEY_KP_9)) {
1247         return undef;
1248     }
1249
1250     return 1;
1251 }
1252
1253 # used by the IP input entry
1254 sub check_num {
1255     my ($entry, $event) = @_;
1256
1257
1258     my $val = $event->get_keyval;
1259
1260     if ($val == ord '.') {
1261         $entry->get_parent->child_focus ('right');
1262         return 1;
1263     }
1264
1265     if ($val == Gtk3::Gdk::KEY_ISO_Left_Tab ||
1266         $val == Gtk3::Gdk::KEY_Shift_L ||
1267         $val == Gtk3::Gdk::KEY_Tab ||
1268         $val == Gtk3::Gdk::KEY_BackSpace ||
1269         $val == Gtk3::Gdk::KEY_Delete ||
1270         ($val >= ord '0' && $val <= ord '9') ||
1271         ($val >= Gtk3::Gdk::KEY_KP_0 &&
1272          $val <= Gtk3::Gdk::KEY_KP_9)) {
1273         return undef;
1274     }
1275
1276     return 1;
1277 }
1278
1279 sub check_range {
1280     my ($entry, $event) = @_;
1281
1282     my $text = $entry->get_text;
1283     if (!defined($text) || ($text !~ m/^(\d+)$/) || ($1 > 255)) {
1284         $entry->set_text ($entry->{default});
1285     }
1286
1287     return undef;
1288 }
1289
1290
1291 sub creat_text_input {
1292     my ($default, $text) = @_;
1293
1294     my $hbox = Gtk3::HBox->new (0, 0);
1295
1296     my $label = Gtk3::Label->new ($text);
1297     $label->set_size_request (150, -1);
1298     $label->set_alignment (1, 0.5);
1299     $hbox->pack_start ($label, 0, 0, 10);
1300     my $e1 = Gtk3::Entry->new ();
1301     $e1->set_width_chars (30);
1302     $hbox->pack_start ($e1, 0, 0, 0);
1303     $e1->set_text ($default);
1304
1305     return ($hbox, $e1);
1306 }
1307
1308 sub creat_ip_input {
1309     my ($init, $default, $text) = @_;
1310
1311     my (@ips) = split /\./, $init;
1312     my (@defs) = split /\./, $default;
1313
1314     my $hbox = Gtk3::HBox->new (0, 0);
1315
1316     my $label = Gtk3::Label->new ($text);
1317     $label->set_size_request (150, -1);
1318     $label->set_alignment (1, 0.5);
1319     $hbox->pack_start ($label, 0, 0, 10);
1320
1321     my $e1 = Gtk3::Entry->new();
1322     $e1->set_max_length(3);
1323     $e1->{default} = $defs[0];
1324     $hbox->pack_start ($e1, 0, 0, 0);
1325     $e1->set_width_chars (3);
1326     $e1->set_text ($ips[0]);
1327     $e1->signal_connect (key_press_event => \&check_num);
1328     $e1->signal_connect (focus_out_event => \&check_range);
1329
1330     my $l1 = Gtk3::Label->new (".");
1331     $hbox->pack_start ($l1, 0, 0, 2);
1332
1333     my $e2 = Gtk3::Entry->new();
1334     $e2->set_max_length(3);
1335     $e2->{default} = $defs[1];
1336     $hbox->pack_start ($e2, 0, 0, 0);
1337     $e2->set_width_chars (3);
1338     $e2->set_text ($ips[1]);
1339     $e2->signal_connect (key_press_event => \&check_num);
1340     $e2->signal_connect (focus_out_event => \&check_range);
1341
1342     my $l2 = Gtk3::Label->new (".");
1343     $hbox->pack_start ($l2, 0, 0, 2);
1344
1345     my $e3 = Gtk3::Entry->new();
1346     $e3->set_max_length(3);
1347     $e3->{default} = $defs[2];
1348     $hbox->pack_start ($e3, 0, 0, 0);
1349     $e3->set_width_chars (3);
1350     $e3->set_text ($ips[2]);
1351     $e3->signal_connect (key_press_event => \&check_num);
1352     $e3->signal_connect (focus_out_event => \&check_range);
1353
1354     my $l3 = Gtk3::Label->new (".");
1355     $hbox->pack_start ($l3, 0, 0, 2);
1356
1357     my $e4 = Gtk3::Entry->new();
1358     $e4->set_max_length(3);
1359     $e4->{default} = $defs[3];
1360     $hbox->pack_start ($e4, 0, 0, 0);
1361     $e4->set_width_chars (3);
1362     $e4->set_text ($ips[3]);
1363     $e4->signal_connect (key_press_event => \&check_num);
1364     $e4->signal_connect (focus_out_event => \&check_range);
1365
1366     return ($hbox, $e1, $e2, $e3, $e4);
1367 }
1368
1369 sub get_ip_config {
1370
1371     my $ifconfig = `ifconfig eth0`;
1372
1373     my ($addr) = $ifconfig =~ m/inet addr:(\S*)/m;
1374     my ($mask) = $ifconfig =~ m/Mask:(\S*)/m;
1375
1376     my $route = `route -n`;
1377     my ($gateway) = $route =~ m/^0\.0\.0\.0\s+(\d+\.\d+\.\d+\.\d+)\s+/m;
1378
1379     my $resolvconf = `cat /etc/resolv.conf`;
1380     my ($dnsserver) = $resolvconf =~ m/^nameserver\s+(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/m;
1381
1382     return {
1383         addr => $addr,
1384         mask => $mask,
1385         gateway => $gateway,
1386         dnsserver => $dnsserver,
1387     }
1388 }
1389
1390 sub display_message {
1391     my ($msg) = @_;
1392
1393     my $dialog = Gtk3::MessageDialog->new ($window, 'modal',
1394                                            'info', 'ok', $msg);
1395     $dialog->run();
1396     $dialog->destroy();
1397 }
1398
1399 sub display_error {
1400     my ($msg) = @_;
1401
1402     my $dialog = Gtk3::MessageDialog->new ($window, 'modal',
1403                                            'error', 'ok', $msg);
1404     $dialog->run();
1405     $dialog->destroy();
1406 }
1407
1408 sub create_ipconf_view {
1409
1410     cleanup_view ();
1411     display_html ("ipconf.htm");
1412
1413     my $vbox =  Gtk3::VBox->new (0, 0);
1414     $inbox->pack_start ($vbox, 1, 0, 0);
1415     my $hbox =  Gtk3::HBox->new (0, 0);
1416     $vbox->pack_start ($hbox, 0, 0, 10);
1417     my $vbox2 =  Gtk3::VBox->new (0, 0);
1418     $hbox->add ($vbox2);
1419
1420     my $addr = $ipconf->{addr} || '192.168.100.2';
1421     my $mask = $ipconf->{mask} || '255.255.255.0';
1422
1423     my ($hostbox, $hostentry) =
1424         creat_text_input ('proxmox.domain.tld', 'Hostname (FQDN):');
1425     $vbox2->pack_start ($hostbox, 0, 0, 2);
1426
1427     my $ipbox;
1428     ($ipbox, $ip_1, $ip_2, $ip_3, $ip_4) =
1429         creat_ip_input ($addr, '0.0.0.0', 'IP Address:');
1430     $vbox2->pack_start ($ipbox, 0, 0, 2);
1431
1432     my $maskbox;
1433     ($maskbox, $mask_1, $mask_2, $mask_3, $mask_4) =
1434         creat_ip_input ($mask, '255.255.255.0', 'Netmask:');
1435     $vbox2->pack_start ($maskbox, 0, 0, 2);
1436
1437     $gateway = $ipconf->{gateway} || '192.168.100.1';
1438
1439     my $gwbox;
1440     ($gwbox, $gw_1, $gw_2, $gw_3, $gw_4) =
1441         creat_ip_input ($gateway, '0.0.0.0', 'Gateway:');
1442
1443     $vbox2->pack_start ($gwbox, 0, 0, 2);
1444
1445     $dnsserver = $ipconf->{dnsserver} || $gateway;
1446
1447     my $dnsbox;
1448     ($dnsbox, $dns_1, $dns_2, $dns_3, $dns_4) =
1449         creat_ip_input ($dnsserver, '0.0.0.0', 'DNS Server:');
1450
1451     $vbox2->pack_start ($dnsbox, 0, 0, 0);
1452
1453     $inbox->show_all;
1454     set_next (undef, sub {
1455         my $text = $hostentry->get_text();
1456
1457         $text =~ s/^\s+//;
1458         $text =~ s/\s+$//;
1459
1460         my $namere = "([a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?)";
1461
1462         if ($text && $text =~ m/^(${namere}\.)*${namere}$/ && $text !~ m/.domain.tld$/ &&
1463             $text =~ m/^([^\.]+)\.(\S+)$/) {
1464             $hostname = $1;
1465             $domain = $2;
1466             create_extract_view ();
1467             return;
1468         }
1469         display_message ("Hostname does not look like a fully qualified domain name.");
1470         $hostentry->grab_focus();
1471     });
1472
1473     $hostentry->grab_focus();
1474 }
1475
1476 sub get_device_desc {
1477     my ($devname, $size, $model) = @_;
1478
1479     if ($size && ($size > 0) && $model) {
1480         $size = int($size/2048); # size in MB
1481
1482         if ($size >= 1024) {
1483             $size = int($size/1024); # size in GB
1484             return "$devname (${size}GB, $model)";
1485         } else {
1486             return "$devname (${size}MB, $model)";
1487         }
1488
1489     } else {
1490         return $devname;
1491     }
1492 }
1493
1494 sub update_layout {
1495     my ($cb, $kmap) = @_;
1496
1497     my $ind;
1498     my $def;
1499     my $i = 0;
1500     my $kmaphash = $cmap->{kmaphash};
1501     foreach my $layout (sort keys %$kmaphash) {
1502         $def = $i if $kmaphash->{$layout} eq 'en-us';
1503         $ind = $i if $kmap && $kmaphash->{$layout} eq $kmap;
1504         $i++;
1505     }
1506
1507     $cb->set_active ($ind || $def || 0);
1508 }
1509
1510 my $lastzonecb;
1511 sub update_zonelist {
1512     my ($box, $cc) = @_;
1513
1514     my $cczones = $cmap->{cczones};
1515     my $zones = $cmap->{zones};
1516
1517     my $sel;
1518     if ($lastzonecb) {
1519         $sel = $lastzonecb->get_active_text();
1520         $box->remove ($lastzonecb);
1521     } else {
1522         $sel = $timezone; # used once to select default
1523     }
1524
1525     my $cb = $lastzonecb = Gtk3::ComboBoxText->new_with_entry();
1526     $cb->set_size_request (200, -1);
1527
1528     $cb->signal_connect ('changed' => sub {
1529         $timezone = $cb->get_active_text();
1530     });
1531
1532     my @za;
1533     if ($cc && defined ($cczones->{$cc})) {
1534         @za = keys %{$cczones->{$cc}};
1535     } else {
1536         @za = keys %$zones;
1537     }
1538     my $ind;
1539     my $i = 0;
1540     foreach my $zone (sort @za) {
1541         $ind = $i if $sel && $zone eq $sel;
1542         $cb->append_text ($zone);
1543         $i++;
1544     }
1545
1546     $cb->set_active ($ind || 0);
1547
1548     $cb->show;
1549     $box->pack_start ($cb, 0, 0, 0);
1550 }
1551
1552 sub create_password_view {
1553
1554     cleanup_view ();
1555
1556     my $vbox2 =  Gtk3::VBox->new (0, 0);
1557     $inbox->pack_start ($vbox2, 1, 0, 0);
1558     my $vbox =  Gtk3::VBox->new (0, 0);
1559     $vbox2->pack_start ($vbox, 0, 0, 10);
1560
1561     my $hbox1 = Gtk3::HBox->new (0, 0);
1562     my $label = Gtk3::Label->new ("Password");
1563     $label->set_size_request (150, -1);
1564     $label->set_alignment (1, 0.5);
1565     $hbox1->pack_start ($label, 0, 0, 10);
1566     my $pwe1 = Gtk3::Entry->new ();
1567     $pwe1->set_visibility (0);
1568     $pwe1->set_size_request (200, -1);
1569     $hbox1->pack_start ($pwe1, 0, 0, 0);
1570
1571     my $hbox2 = Gtk3::HBox->new (0, 0);
1572     $label = Gtk3::Label->new ("Confirm");
1573     $label->set_size_request (150, -1);
1574     $label->set_alignment (1, 0.5);
1575     $hbox2->pack_start ($label, 0, 0, 10);
1576     my $pwe2 = Gtk3::Entry->new ();
1577     $pwe2->set_visibility (0);
1578     $pwe2->set_size_request (200, -1);
1579     $hbox2->pack_start ($pwe2, 0, 0, 0);
1580
1581     my $hbox3 = Gtk3::HBox->new (0, 0);
1582     $label = Gtk3::Label->new ("E-Mail");
1583     $label->set_size_request (150, -1);
1584     $label->set_alignment (1, 0.5);
1585     $hbox3->pack_start ($label, 0, 0, 10);
1586     my $eme = Gtk3::Entry->new ();
1587     $eme->set_size_request (200, -1);
1588     $hbox3->pack_start ($eme, 0, 0, 0);
1589
1590
1591     $vbox->pack_start ($hbox1, 0, 0, 5);
1592     $vbox->pack_start ($hbox2, 0, 0, 5);
1593     $vbox->pack_start ($hbox3, 0, 0, 15);
1594
1595     $inbox->show_all;
1596
1597     display_html ("passwd.htm");
1598
1599     set_next (undef,  sub {
1600
1601         my $t1 = $pwe1->get_text;
1602         my $t2 = $pwe2->get_text;
1603
1604         if (length ($t1) < 5) {
1605             display_message ("Password is too short.");
1606             $pwe1->grab_focus();
1607             return;
1608         }
1609
1610         if ($t1 ne $t2) {
1611             display_message ("Password does not match.");
1612             $pwe1->grab_focus();
1613             return;
1614         }
1615
1616         my $t3 = $eme->get_text;
1617         if ($t3 !~ m/^\S+\@\S+\.\S+$/) {
1618             display_message ("E-Mail does not look like a vaild address" .
1619                              " (user\@domain.tld)");
1620             $eme->grab_focus();
1621             return;
1622
1623         }
1624
1625         $password = $t1;
1626         $mailto = $t3;
1627
1628         create_ipconf_view();
1629     });
1630
1631     $pwe1->grab_focus();
1632
1633 }
1634
1635 sub create_country_view {
1636
1637     cleanup_view ();
1638
1639     my $countryhash = $cmap->{countryhash};
1640     my $ctr = $cmap->{country};
1641
1642     my $vbox2 =  Gtk3::VBox->new (0, 0);
1643     $inbox->pack_start ($vbox2, 1, 0, 0);
1644     my $vbox =  Gtk3::VBox->new (0, 0);
1645     $vbox2->pack_start ($vbox, 0, 0, 10);
1646
1647     my $w = Gtk3::Entry->new ();
1648     $w->set_size_request (200, -1);
1649
1650     my $c = Gtk3::EntryCompletion->new ();
1651     $c->set_text_column (0);
1652     $c->set_minimum_key_length(0);
1653     $c->set_popup_set_width (1);
1654     $c->set_inline_completion (1);
1655
1656     my $hbox2 = Gtk3::HBox->new (0, 0);
1657     my $label = Gtk3::Label->new ("Time zone");
1658     $label->set_size_request (150, -1);
1659     $label->set_alignment (1, 0.5);
1660     $hbox2->pack_start ($label, 0, 0, 10);
1661     update_zonelist ($hbox2);
1662
1663     my $hbox3 = Gtk3::HBox->new (0, 0);
1664     $label = Gtk3::Label->new ("Keyboard Layout");
1665     $label->set_size_request (150, -1);
1666     $label->set_alignment (1, 0.5);
1667     $hbox3->pack_start ($label, 0, 0, 10);
1668
1669     my $kmapcb = Gtk3::ComboBoxText->new_with_entry ();
1670     $kmapcb->set_size_request (200, -1);
1671     foreach my $layout (sort keys %{$cmap->{kmaphash}}) {
1672         $kmapcb->append_text ($layout);
1673     }
1674
1675     update_layout ($kmapcb);
1676     $hbox3->pack_start ($kmapcb, 0, 0, 0);
1677
1678     $kmapcb->signal_connect ('changed' => sub {
1679         my $sel = $kmapcb->get_active_text();
1680         if (my $kmap = $cmap->{kmaphash}->{$sel}) {
1681             my $xkmap = $cmap->{kmap}->{$kmap}->{x11};
1682             my $xvar = $cmap->{kmap}->{$kmap}->{x11var};
1683             syscmd ("setxkbmap $xkmap $xvar") if !$opt_testmode;
1684             $keymap = $kmap;
1685         }
1686     });
1687
1688     $w->signal_connect ('changed' => sub {
1689         my ($entry, $event) = @_;
1690         my $text = $entry->get_text;
1691
1692         if (my $cc = $countryhash->{lc($text)}) {
1693             update_zonelist ($hbox2, $cc);
1694             my $kmap = $ctr->{$cc}->{kmap} || 'en-us';
1695             update_layout ($kmapcb, $kmap);
1696         }
1697     });
1698
1699     $w->signal_connect (key_press_event => sub {
1700         my ($entry, $event) = @_;
1701         my $text = $entry->get_text;
1702
1703         my $val = $event->get_keyval;
1704
1705         if ($val == Gtk3::Gdk::KEY_Tab) {
1706             my $cc = $countryhash->{lc($text)};
1707
1708             my $found = 0;
1709             my $compl;
1710
1711             if ($cc) {
1712                 $found = 1;
1713                 $compl = $ctr->{$cc}->{name};
1714             } else {
1715                 foreach my $cc (keys %$ctr) {
1716                     my $ct = $ctr->{$cc}->{name};
1717                     if ($ct =~ m/^\Q$text\E.*$/i) {
1718                         $found++;
1719                         $compl = $ct;
1720                     }
1721                     last if $found > 1;
1722                 }
1723             }
1724
1725             if ($found == 1) {
1726                 $entry->set_text($compl);
1727                 $c->complete();
1728                 return undef;
1729             } else {
1730                 #Gtk3::Gdk::beep();
1731                 print chr(7); # beep ?
1732             }
1733
1734             $c->complete();
1735
1736             my $buf = $w->get_buffer();
1737             $buf->insert_text(-1, '', -1); # popup selection
1738
1739             return 1;
1740         }
1741
1742         return undef;
1743     });
1744
1745     my $ls = Gtk3::ListStore->new('Glib::String');
1746     foreach my $cc (sort {$ctr->{$a}->{name} cmp $ctr->{$b}->{name} } keys %$ctr) {
1747         my $iter = $ls->append();
1748         $ls->set ($iter, 0, $ctr->{$cc}->{name});
1749     }
1750     $c->set_model ($ls);
1751
1752     $w->set_completion ($c);
1753
1754     my $hbox =  Gtk3::HBox->new (0, 0);
1755
1756     $label = Gtk3::Label->new ("Country");
1757     $label->set_alignment (1, 0.5);
1758     $label->set_size_request (150, -1);
1759     $hbox->pack_start ($label, 0, 0, 10);
1760     $hbox->pack_start ($w, 0, 0, 0);
1761
1762     $vbox->pack_start ($hbox, 0, 0, 5);
1763     $vbox->pack_start ($hbox2, 0, 0, 5);
1764     $vbox->pack_start ($hbox3, 0, 0, 5);
1765
1766     if ($country) {
1767         $w->set_text ($ctr->{$country}->{name});
1768     }
1769
1770     $inbox->show_all;
1771
1772     display_html ("country.htm");
1773     set_next (undef,  sub {
1774
1775         my $text = $w->get_text;
1776
1777         if (my $cc = $countryhash->{lc($text)}) {
1778             $country = $cc;
1779             create_password_view();
1780             return;
1781         } else {
1782             display_message ("Please select a country first.");
1783             $w->grab_focus();
1784         }
1785     });
1786
1787     $w->grab_focus();
1788 }
1789
1790 sub create_hdoption_view {
1791
1792     my $dialog = Gtk3::Dialog->new();
1793
1794     $dialog->set_title("Harddisk options");
1795
1796     $dialog->add_button("_OK", 1);
1797
1798     my $contarea = $dialog->get_content_area();
1799
1800     my $hbox2 =  Gtk3::Box->new('horizontal', 0);
1801     $contarea->pack_start($hbox2, 1, 1, 10);
1802
1803     my $grid =  Gtk3::Grid->new();
1804     $grid->set_column_spacing(10);
1805     $grid->set_row_spacing(10);
1806
1807     $hbox2->pack_start($grid, 1, 0, 10);
1808
1809     # Filesystem type
1810
1811     my $label0 = Gtk3::Label->new ("Filesystem");
1812     $label0->set_alignment (1, 0.5);
1813     $grid->attach($label0, 0, 0, 1, 1);
1814
1815     my $fstypecb = Gtk3::ComboBoxText->new_with_entry ();
1816
1817     $fstypecb->append_text ('ext3');
1818     $fstypecb->append_text ('ext4');
1819
1820     if ($config_options->{filesys} eq 'ext4') {
1821         $fstypecb->set_active (1);
1822     } else {
1823         $fstypecb->set_active (0);
1824     }
1825
1826     $fstypecb->signal_connect (changed => sub {
1827         $config_options->{filesys} = $fstypecb->get_active_text();
1828     });
1829     $grid->attach($fstypecb, 1, 0, 1, 1);
1830
1831     my $label_hdsize = Gtk3::Label->new ("hdsize");
1832     $label_hdsize->set_alignment (1, 0.5);
1833     $grid->attach($label_hdsize, 0, 1, 1, 1);
1834
1835     # size compute
1836     my $hdsize;
1837     if ( -b $target_hd) {
1838         $hdsize = int(hd_size ($target_hd) / (1024*1024.0)); # size in GB
1839     } else {
1840         $hdsize = int((-s $target_hd) / (1024*1024*1024.0));
1841     }
1842
1843     my $hdsize_size_adj = Gtk3::Adjustment->new($config_options->{hdsize} || $hdsize, 0, $hdsize+1, 1, 1, 1);
1844     my $spinbutton_hdsize = Gtk3::SpinButton->new($hdsize_size_adj, 1, 1);
1845     $spinbutton_hdsize->set_tooltip_text("only use specified size (GB) of the harddisk (rest left unpartitioned)");
1846     $grid->attach($spinbutton_hdsize, 1, 1, 1, 1);
1847
1848     my $label_swapsize = Gtk3::Label->new ("swapsize");
1849     $label_swapsize->set_alignment (1, 0.5);
1850     $grid->attach($label_swapsize, 0, 2, 1, 1);
1851
1852     my $entry_swapsize = Gtk3::Entry->new();
1853     $entry_swapsize->set_tooltip_text("maximum SWAP size (GB)");
1854     $entry_swapsize->signal_connect (key_press_event => \&check_float);
1855     $entry_swapsize->set_text($config_options->{swapsize}) if $config_options->{swapsize};
1856     $grid->attach($entry_swapsize, 1, 2, 1, 1);
1857
1858     my $label_maxroot = Gtk3::Label->new ("maxroot");
1859     $label_maxroot->set_alignment (1, 0.5);
1860     $grid->attach($label_maxroot, 0, 3, 1, 1);
1861
1862     my $entry_maxroot = Gtk3::Entry->new();
1863     $entry_maxroot->set_tooltip_text("maximum size (GB) for LVM root volume");
1864     $entry_maxroot->signal_connect (key_press_event => \&check_float);
1865     $entry_maxroot->set_text($config_options->{maxroot}) if $config_options->{maxroot};
1866     $grid->attach($entry_maxroot, 1, 3, 1, 1);
1867
1868     my $label_minfree = Gtk3::Label->new ("minfree");
1869     $label_minfree->set_alignment (1, 0.5);
1870     $grid->attach($label_minfree, 0, 4, 1, 1);
1871
1872     my $entry_minfree = Gtk3::Entry->new();
1873     $entry_minfree->set_tooltip_text("minumum free LVM space (GB, required for LVM snapshots)");
1874     $entry_minfree->signal_connect (key_press_event => \&check_float);
1875     $entry_minfree->set_text($config_options->{minfree}) if $config_options->{minfree};
1876     $grid->attach($entry_minfree, 1, 4, 1, 1);
1877
1878     my $label_maxvz = Gtk3::Label->new ("maxvz");
1879     $label_maxvz->set_alignment (1, 0.5);
1880     $grid->attach($label_maxvz, 0, 5, 1, 1);
1881
1882     my $entry_maxvz = Gtk3::Entry->new();
1883     $entry_maxvz->set_tooltip_text("maximum size (GB) for LVM data volume");
1884     $entry_maxvz->signal_connect (key_press_event => \&check_float);
1885     $entry_maxvz->set_text($config_options->{maxvz}) if $config_options->{maxvz};
1886     $grid->attach($entry_maxvz, 1, 5, 1, 1);
1887
1888     $dialog->show_all;
1889
1890     $dialog->run();
1891
1892     my $get_float = sub {
1893         my ($entry) = @_;
1894
1895         my $text = $entry->get_text();
1896         return undef if !defined($text);
1897
1898         $text =~ s/^\s+//;
1899         $text =~ s/\s+$//;
1900
1901         return undef if $text !~ m/^\d+(\.\d+)?$/;
1902
1903         return $text;
1904     };
1905
1906     my $tmp;
1907
1908     if (($tmp = &$get_float($spinbutton_hdsize)) && ($tmp != $hdsize)) {
1909         $config_options->{hdsize} = $tmp;
1910     } else {
1911         delete $config_options->{hdsize};
1912     }
1913
1914     if (defined($tmp = &$get_float($entry_swapsize))) {
1915         $config_options->{swapsize} = $tmp;
1916     } else {
1917         delete $config_options->{swapsize};
1918     }
1919
1920     if (defined($tmp = &$get_float($entry_maxroot))) {
1921         $config_options->{maxroot} = $tmp;
1922     } else {
1923         delete $config_options->{maxroot};
1924     }
1925
1926     if (defined($tmp = &$get_float($entry_minfree))) {
1927         $config_options->{minfree} = $tmp;
1928     } else {
1929         delete $config_options->{minfree};
1930     }
1931
1932     if (defined($tmp = &$get_float($entry_maxvz))) {
1933         $config_options->{maxvz} = $tmp;
1934     } else {
1935         delete $config_options->{maxvz};
1936     }
1937
1938     $dialog->destroy();
1939 }
1940
1941 sub create_hdsel_view {
1942
1943     cleanup_view ();
1944
1945     my $vbox =  Gtk3::VBox->new (0, 0);
1946     $inbox->pack_start ($vbox, 1, 0, 0);
1947     my $hbox =  Gtk3::HBox->new (0, 0);
1948     $vbox->pack_start ($hbox, 0, 0, 10);
1949
1950     my ($disk, $devname, $size, $model) = @{@$hds[0]};
1951     $target_hd = $devname;
1952     $master_hd = find_master ($target_hd);
1953     my $label;
1954
1955     $label = Gtk3::Label->new ("Target Harddisks: ");
1956     $hbox->pack_start ($label, 0, 0, 0);
1957
1958     my $combo = Gtk3::ComboBoxText->new_with_entry();
1959     my $e = $combo->get_child();
1960     $e->set_width_chars(40);
1961
1962     foreach my $hd (@$hds) {
1963         ($disk, $devname, $size, $model) = @$hd;
1964         $combo->append_text (get_device_desc ($devname, $size, $model));
1965     }
1966
1967     $combo->set_active (0);
1968     $combo->signal_connect (changed => sub {
1969         $a = shift->get_active;
1970         my ($disk, $devname) = @{@$hds[$a]};
1971         $target_hd = $devname;
1972         $master_hd = find_master ($target_hd);
1973     });
1974
1975     $hbox->pack_start ($combo, 0, 0, 10);
1976
1977     my $options = Gtk3::Button->new ('_Options');
1978     $options->signal_connect (clicked => \&create_hdoption_view);
1979     $hbox->pack_start ($options, 0, 0, 0);
1980
1981
1982     $inbox->show_all;
1983
1984     display_html ("page1.htm");
1985     set_next (undef, \&create_country_view);
1986 }
1987
1988 sub create_extract_view {
1989
1990     $ipaddress = $ip_1->get_text . "." . $ip_2->get_text . "." .
1991         $ip_3->get_text . "." . $ip_4->get_text;
1992
1993     $netmask = $mask_1->get_text . "." . $mask_2->get_text . "." .
1994         $mask_3->get_text . "." . $mask_4->get_text;
1995
1996     $gateway = $gw_1->get_text . "." . $gw_2->get_text . "." .
1997         $gw_3->get_text . "." . $gw_4->get_text;
1998
1999     $dnsserver = $dns_1->get_text . "." . $dns_2->get_text . "." .
2000         $dns_3->get_text . "." . $dns_4->get_text;
2001
2002     # print "TEST $ipaddress $netmask $gateway $dnsserver\n";
2003     cleanup_view ();
2004
2005     display_html ("extract1-license.htm");
2006     $next->set_sensitive (0);
2007
2008     my $vbox =  Gtk3::VBox->new (0, 0);
2009     $inbox->pack_start ($vbox, 1, 0, 0);
2010     my $hbox =  Gtk3::HBox->new (0, 0);
2011     $vbox->pack_start ($hbox, 0, 0, 10);
2012
2013     my $vbox2 =  Gtk3::VBox->new (0, 0);
2014     $hbox->pack_start ($vbox2, 0, 0, 0);
2015
2016     $progress_status = Gtk3::Label->new ('');
2017     $vbox2->pack_start ($progress_status, 1, 1, 0);
2018
2019     $progress = Gtk3::ProgressBar->new;
2020     $progress->set_show_text(1);
2021     $progress->set_size_request (600, -1);
2022
2023     $vbox2->pack_start ($progress, 0, 0, 0);
2024
2025     $inbox->show_all;
2026
2027     my $tdir = $opt_testmode ? "target" : "/target";
2028     mkdir $tdir;
2029     my $base = $opt_testmode ? "/pve/$release/install/pve-base.tar" : "/proxmox/pve-base.tar";
2030
2031     eval  { extract_data ($base, $tdir); };
2032     my $err = $@;
2033
2034     $next->set_sensitive (1);
2035
2036     set_next ("_Reboot", sub { exit (0); } );
2037
2038     if ($err) {
2039         display_html ("fail.htm");
2040         display_error ($err);
2041     } else {
2042         cleanup_view ();
2043         display_html ("success.htm");
2044     }
2045 }
2046
2047 sub create_intro_view {
2048
2049     cleanup_view ();
2050
2051     display_html ("license.htm");
2052
2053     set_next ("I a_gree", \&create_hdsel_view);
2054 }
2055
2056 $ipconf = get_ip_config ();
2057
2058 $country = detect_country() if $ipconf->{addr} || $opt_testmode;;
2059
2060 # read country, kmap and timezone infos
2061 $cmap = read_cmap ();
2062
2063 create_main_window ();
2064
2065 if (!defined ($hds) || (scalar (@$hds) <= 0)) {
2066     print "no hardisks found\n";
2067     display_html ("nohds.htm");
2068     set_next ("Reboot", sub { exit (0); } );
2069 } else {
2070
2071     foreach my $hd (@$hds) {
2072         my ($disk, $devname) = @$hd;
2073         next if $devname =~ m|^/dev/md\d+$|;
2074         print "found Disk$disk N:$devname\n";
2075     }
2076
2077     create_intro_view ();
2078 }
2079
2080 Gtk3->main;
2081
2082 exit 0;