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