src/install+setup/install/main.c

   1 /* SmoothWall install program.
   2  *
   3  * This program is distributed under the terms of the GNU General Public
   4  * Licence.  See the file COPYING for details.
   5  *
   6  * (c) Lawrence Manning, 2001
   7  * Contains main entry point, and misc functions.
   8  *
   9  */
  10
  11 #include "install.h"
  12 #define _GNU_SOURCE
  13
  14 #define CDROM_INSTALL 0
  15 #define URL_INSTALL 1
  16 #define DISK_INSTALL 2
  17 #define INST_FILECOUNT 7000
  18 #define UNATTENDED_CONF "/cdrom/boot/unattended.conf"
  19
  20 int raid_disk = 0;
  21 FILE *flog = NULL;
  22 char *mylog;
  23
  24 char **ctr;
  25
  26 extern char url[STRING_SIZE];
  27
  28 extern char *en_tr[];
  29 extern char *de_tr[];
  30
  31 int detect_smp() {
  32         FILE *fd = NULL;
  33         char line[STRING_SIZE];
  34         int cpu_count = 0;
  35
  36         if ((fd = fopen("/proc/cpuinfo", "r")) == NULL) {
  37                 return 0;
  38         }
  39         while (fgets(line, STRING_SIZE, fd) != NULL) {
  40                 if (strstr(line, "processor") == line) {
  41                         cpu_count++;
  42                 }
  43         }
  44         (void)fclose(fd);
  45         return (cpu_count > 1);
  46 }
  47
  48 long calc_swapsize(long memory, long disk) {
  49         if (memory < 128) {
  50                 return 256;
  51         }
  52         if (memory > 1024) {
  53                 return 512;
  54         }
  55
  56         return memory*2;
  57 }
  58
  59 int main(int argc, char *argv[])
  60 {
  61         char *langnames[] = { "Deutsch", "English", NULL };
  62         char *shortlangnames[] = { "de", "en", NULL };
  63         char **langtrs[] = { de_tr, en_tr, NULL };
  64         char hdletter;
  65         char harddrive[5], sourcedrive[5];      /* Device holder. */
  66         struct devparams hdparams, cdromparams; /* Params for CDROM and HD */
  67         int cdmounted = 0; /* Loop flag for inserting a cd. */
  68         int rc = 0;
  69         char commandstring[STRING_SIZE];
  70         char *installtypes[] = { "CDROM/USB", "HTTP/FTP", NULL };
  71         int installtype = CDROM_INSTALL;
  72         int choice;
  73         char shortlangname[10];
  74         char message[1000];
  75         char title[STRING_SIZE];
  76         int allok = 0;
  77         int allok_fastexit=0;
  78         struct keyvalue *ethernetkv = initkeyvalues();
  79         FILE *handle, *cmdfile;
  80         char line[STRING_SIZE];
  81         char string[STRING_SIZE];
  82         long maximum_free = 0, current_free;
  83         long memory = 0;
  84         long system_partition, boot_partition, root_partition, swap_file;
  85         int scsi_disk = 0;
  86         char *yesnoharddisk[] = { "NO", "YES", NULL };
  87         int unattended = 0;
  88         struct keyvalue *unattendedkv = initkeyvalues();
  89         int hardyn = 0;
  90
  91         setlocale (LC_ALL, "");
  92         sethostname( SNAME , 10);
  93
  94         memset(&hdparams, 0, sizeof(struct devparams));
  95         memset(&cdromparams, 0, sizeof(struct devparams));
  96
  97         /* Log file/terminal stuff. */
  98         if (argc >= 2)
  99         {
 100                 if (!(flog = fopen(argv[1], "w+")))
 101                         return 0;
 102         }
 103         else
 104                 return 0;
 105
 106         mylog = argv[1];
 107
 108         fprintf(flog, "Install program started.\n");
 109
 110         newtInit();
 111         newtCls();
 112
 113         /* Do usb detection first for usb keyboard */
 114         if (! (cmdfile = fopen("/proc/cmdline", "r")))
 115         {
 116                 fprintf(flog, "Couldn't open commandline: /proc/cmdline\n");
 117         } else {
 118                 fgets(line, STRING_SIZE, cmdfile);
 119                 if (strstr (line, "nousb") == NULL) {
 120                         fprintf(flog, "Initializing USB controllers.\n");
 121                         initialize_usb();
 122                 } else {
 123                         fprintf(flog, "Skipping USB detection.\n");
 124                 }
 125                 // check if we have to make an unattended install
 126                 if (strstr (line, "unattended") != NULL) {
 127                     unattended = 1;
 128                 }
 129         }
 130
 131         if (unattended) {
 132             runcommandwithstatus("/bin/sleep 10", "WARNING: Unattended installation will start in 10 seconds...");
 133         }
 134
 135         /* German is the default */
 136         for (choice = 0; langnames[choice]; choice++)
 137         {
 138                 if (strcmp(langnames[choice], "Deutsch") == 0)
 139                         break;
 140         }
 141         if (!langnames[choice])
 142                 goto EXIT;
 143
 144         if (!unattended) {
 145             rc = newtWinMenu("Language selection",
 146                     "Select the language you wish to use for the " NAME ".", 50, 5, 5, 8,
 147                     langnames, &choice, "Ok", NULL);
 148         }
 149
 150         ctr = langtrs[choice];
 151         strcpy(shortlangname, shortlangnames[choice]);
 152         fprintf(flog, "Selected language: %s\n", shortlangname);
 153
 154         mysystem("/bin/setfont lat0-16");
 155
 156         newtDrawRootText(14, 0, NAME " " VERSION " - " SLOGAN );
 157         newtPushHelpLine(ctr[TR_HELPLINE]);
 158         sprintf (title, "%s %s - %s", NAME, VERSION, SLOGAN);
 159
 160         if (!unattended) {
 161                 sprintf(message, ctr[TR_WELCOME], NAME);
 162                 newtWinMessage(title, ctr[TR_OK], message);
 163
 164                 sprintf(message, ctr[TR_SELECT_INSTALLATION_MEDIA_LONG], NAME);
 165                 rc = newtWinMenu(ctr[TR_SELECT_INSTALLATION_MEDIA], message,
 166                         50, 5, 5, 6, installtypes, &installtype, ctr[TR_OK],
 167                         ctr[TR_CANCEL], NULL);
 168         } else {
 169             rc = 1;
 170             installtype = CDROM_INSTALL;
 171         }
 172
 173         if (rc == 2)
 174                 goto EXIT;
 175
 176         // Starting hardware detection
 177         runcommandwithstatus("/bin/probehw.sh", ctr[TR_PROBING_HARDWARE]);
 178         runcommandwithstatus("/bin/probenic.sh install", ctr[TR_PROBING_HARDWARE]);
 179
 180         /* CDROM INSTALL */
 181         if (installtype == CDROM_INSTALL) {
 182                 switch (mysystem("/bin/mountsource.sh")) {
 183                     case 0:
 184                         installtype = CDROM_INSTALL;
 185                         cdmounted = 1;
 186                         break;
 187                     case 1:
 188                         installtype = DISK_INSTALL;
 189                         break;
 190                     case 10:
 191                         errorbox(ctr[TR_NO_CDROM]);
 192                         goto EXIT;
 193                 }
 194
 195                 /* read source drive letter */
 196                 if ((handle = fopen("/tmp/source_device", "r")) == NULL) {
 197                         errorbox(ctr[TR_ERROR_PROBING_CDROM]);
 198                         goto EXIT;
 199                 }
 200                 fgets(sourcedrive, 5, handle);
 201                 fprintf(flog, "Source drive: %s\n", sourcedrive);
 202                 fclose(handle);
 203
 204                 //snprintf(cdromparams.devnode_disk, STRING_SIZE, "/dev/%s", sourcedrive);
 205                 fprintf(flog, "Source device: %s\n", sourcedrive);
 206         }
 207
 208         /* Configure the network now! */
 209         if (installtype == URL_INSTALL) {
 210                 /* Network driver and params. */
 211                 if (!(networkmenu(ethernetkv))) {
 212                         errorbox(ctr[TR_NETWORK_SETUP_FAILED]);
 213                         goto EXIT;
 214                 }
 215
 216                 /* Check for ipfire-<VERSION>.tbz2 */
 217                 if (checktarball(SNAME "-" VERSION ".tbz2", ctr[TR_ENTER_URL])) {
 218                         errorbox(ctr[TR_NO_IPCOP_TARBALL_FOUND]);
 219                         goto EXIT;
 220                 }
 221         }
 222
 223         // Now try to find destination device...
 224         if ((hdletter = findidetype(IDE_HD))) {
 225                 sprintf(harddrive, "hd%c", hdletter);
 226                 goto FOUND_DESTINATION;
 227         }
 228
 229         /* Need to clean this up at some point
 230            scsi disk is sdb/sdc when sda/sdb is used for usb-key
 231            if scsi-disk is sdd or more, it is not discovered
 232            Support only 2 usb keys, none could be unplugged */
 233         if (checkusb("sdb") && try_scsi("sdc")) {
 234                 scsi_disk = 1;
 235                 sprintf(harddrive, "sdc");
 236                 goto FOUND_DESTINATION;
 237         }
 238         if (checkusb("sda") && try_scsi("sdb")) {
 239                 scsi_disk = 1;
 240                 sprintf(harddrive, "sdb");
 241                 goto FOUND_DESTINATION;
 242         }
 243         if (try_scsi("sda")) {
 244                 scsi_disk = 1;
 245                 sprintf(harddrive, "sda");
 246                 goto FOUND_DESTINATION;
 247         }
 248         if (try_scsi("ida/c0d0")) {
 249                 raid_disk = 1;
 250                 sprintf(harddrive, "ida/c0d0");
 251                 goto FOUND_DESTINATION;
 252         }
 253         if (try_scsi("cciss/c0d0")) {
 254                 raid_disk = 1;
 255                 sprintf(harddrive, "cciss/c0d0");
 256                 goto FOUND_DESTINATION;
 257         }
 258         if (try_scsi("rd/c0d0")) {
 259                 raid_disk = 1;
 260                 sprintf(harddrive, "rd/c0d0");
 261                 goto FOUND_DESTINATION;
 262         }
 263         if (try_scsi("ataraid/d0")) {
 264                 raid_disk = 1;
 265                 sprintf(harddrive, "ataraid/d0");
 266                 goto FOUND_DESTINATION;
 267         }
 268         /* nothing worked, give up */
 269         errorbox(ctr[TR_NO_HARDDISK]);
 270         goto EXIT;
 271
 272         FOUND_DESTINATION:
 273         /* load unattended configuration */
 274         if (unattended) {
 275             fprintf(flog, "unattended: Reading unattended.conf\n");
 276
 277             (void) readkeyvalues(unattendedkv, UNATTENDED_CONF);
 278         }
 279
 280         /* Make the hdparms struct and print the contents.
 281            With USB-KEY install and SCSI disk, while installing, the disk
 282            is named 'sdb,sdc,...' (following keys)
 283            On reboot, it will become 'sda'
 284            To avoid many test, all names are built in the struct.
 285         */
 286         sprintf(hdparams.devnode_disk, "/dev/%s", harddrive);
 287         /* Address the partition or raid partition (eg dev/sda or /dev/sdap1 */
 288         sprintf(hdparams.devnode_part, "/dev/%s%s", harddrive,raid_disk ? "p" : "");
 289         /* Now the names after the machine is booted. Only scsi is affected
 290            and we only install on the first scsi disk. */
 291         {       char tmp[30];
 292                 strcpy(tmp, scsi_disk ? "sda" : harddrive);
 293                 sprintf(hdparams.devnode_disk_run, "/dev/%s", tmp);
 294                 sprintf(hdparams.devnode_part_run, "/dev/%s%s", tmp, raid_disk ? "p" : "");
 295         }
 296
 297         fprintf(flog, "Destination drive: %s\n", hdparams.devnode_disk);
 298
 299         sprintf(message, ctr[TR_PREPARE_HARDDISK], hdparams.devnode_disk);
 300         if (unattended) {
 301             hardyn = 1;
 302         }
 303         while (! hardyn) {
 304                 rc = newtWinMenu(title, message,
 305                                  50, 5, 5, 6, yesnoharddisk,
 306                                  &hardyn, ctr[TR_OK],
 307                                  ctr[TR_CANCEL], NULL);
 308                 if (rc == 2)
 309                         goto EXIT;
 310         }
 311         if (rc == 2)
 312                 goto EXIT;
 313
 314         /* Calculate amount of memory in machine */
 315         if ((handle = fopen("/proc/meminfo", "r")))
 316         {
 317             while (fgets(line, STRING_SIZE-1, handle)) {
 318                 if (sscanf (line, "MemTotal: %s kB", string)) {
 319                     memory = atoi(string) / 1024 ;
 320                 }
 321             }
 322             fclose(handle);
 323         }
 324
 325         /* Partition, mkswp, mkfs.
 326          * before partitioning, first determine the sizes of each
 327          * partition.  In order to do that we need to know the size of
 328          * the disk.
 329          */
 330         /* Don't use mysystem here so we can redirect output */
 331         sprintf(commandstring, "/bin/sfdisk -s /dev/%s > /tmp/disksize 2> /dev/null", harddrive);
 332         system(commandstring);
 333
 334         /* Calculate amount of disk space */
 335         if ((handle = fopen("/tmp/disksize", "r")))
 336         {
 337                 fgets(line, STRING_SIZE-1, handle);
 338                 if (sscanf (line, "%s", string)) {
 339                         maximum_free = atoi(string) / 1024;
 340                 }
 341                 fclose(handle);
 342         }
 343
 344         fprintf(flog, "maximum_free = %ld, memory = %ld",
 345                 maximum_free, memory);
 346
 347         swap_file = calc_swapsize(memory, maximum_free);
 348
 349         if (maximum_free < 512 + swap_file ) {
 350                 if (maximum_free < 512) {
 351                         errorbox(ctr[TR_DISK_TOO_SMALL]);
 352                         goto EXIT;
 353                 }
 354
 355                 if (!unattended) {
 356                     rc = newtWinChoice(title, ctr[TR_OK], ctr[TR_CANCEL], ctr[TR_CONTINUE_NO_SWAP]);
 357                 }
 358                 else {
 359                     rc = 1;
 360                 }
 361
 362                 if (rc != 1)
 363                         goto EXIT;
 364                 swap_file = 0;
 365         }
 366
 367         boot_partition = 20; /* in MB */
 368         current_free = maximum_free - boot_partition - swap_file;
 369
 370         root_partition = 2048 ;
 371         if (current_free < 512) {
 372                 errorbox(ctr[TR_DISK_TOO_SMALL]);
 373                 goto EXIT;
 374         }
 375
 376         current_free = current_free - root_partition;
 377         if (!swap_file) {
 378                 root_partition = root_partition + swap_file;
 379         }
 380
 381         system_partition = current_free;
 382
 383         fprintf(flog, "boot = %ld, swap = %ld, mylog = %ld, root = %ld\n",
 384                 boot_partition, swap_file, system_partition, root_partition);
 385
 386         handle = fopen("/tmp/partitiontable", "w");
 387
 388         /* Make swapfile */
 389         if (swap_file) {
 390                 fprintf(handle, ",%ld,L,*\n,%ld,S,\n,%ld,L,\n,,L,\n",
 391                         boot_partition, swap_file, root_partition);
 392         } else {
 393                 fprintf(handle, ",%ld,L,*\n,0,0,\n,%ld,L,\n,,L,\n",
 394                         boot_partition, root_partition);
 395         }
 396
 397         fclose(handle);
 398
 399         snprintf(commandstring, STRING_SIZE, "/bin/sfdisk -L -uM %s < /tmp/partitiontable", hdparams.devnode_disk);
 400         if (runcommandwithstatus(commandstring, ctr[TR_PARTITIONING_DISK]))
 401         {
 402                 errorbox(ctr[TR_UNABLE_TO_PARTITION]);
 403                 goto EXIT;
 404         }
 405
 406         mysystem("/sbin/udevstart");
 407
 408         snprintf(commandstring, STRING_SIZE, "/bin/mke2fs -T ext2 -c %s1", hdparams.devnode_part);
 409         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_BOOT_FILESYSTEM]))
 410         {
 411                 errorbox(ctr[TR_UNABLE_TO_MAKE_BOOT_FILESYSTEM]);
 412                 goto EXIT;
 413         }
 414
 415         if (swap_file) {
 416                 snprintf(commandstring, STRING_SIZE, "/sbin/mkswap %s2", hdparams.devnode_part);
 417                 if (runcommandwithstatus(commandstring, ctr[TR_MAKING_SWAPSPACE]))
 418                 {
 419                         errorbox(ctr[TR_UNABLE_TO_MAKE_SWAPSPACE]);
 420                         goto EXIT;
 421                 }
 422         }
 423
 424         snprintf(commandstring, STRING_SIZE, "/sbin/mkreiserfs -f %s3", hdparams.devnode_part);
 425         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_ROOT_FILESYSTEM]))
 426         {
 427                 errorbox(ctr[TR_UNABLE_TO_MAKE_ROOT_FILESYSTEM]);
 428                 goto EXIT;
 429         }
 430
 431         snprintf(commandstring, STRING_SIZE, "/sbin/mkreiserfs -f %s4", hdparams.devnode_part);
 432         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_LOG_FILESYSTEM]))
 433         {
 434                 errorbox(ctr[TR_UNABLE_TO_MAKE_ROOT_FILESYSTEM]);
 435                 goto EXIT;
 436         }
 437
 438         /* Mount harddisk. */
 439
 440         snprintf(commandstring, STRING_SIZE, "/bin/mount %s3 /harddisk", hdparams.devnode_part);
 441         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_ROOT_FILESYSTEM]))
 442         {
 443                 errorbox(ctr[TR_UNABLE_TO_MOUNT_ROOT_FILESYSTEM]);
 444                 goto EXIT;
 445         }
 446
 447         mkdir("/harddisk/boot", S_IRWXU|S_IRWXG|S_IRWXO);
 448         mkdir("/harddisk/var", S_IRWXU|S_IRWXG|S_IRWXO);
 449         mkdir("/harddisk/var/log", S_IRWXU|S_IRWXG|S_IRWXO);
 450
 451         snprintf(commandstring, STRING_SIZE, "/bin/mount %s1 /harddisk/boot", hdparams.devnode_part);
 452         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_BOOT_FILESYSTEM]))
 453         {
 454                 errorbox(ctr[TR_UNABLE_TO_MOUNT_BOOT_FILESYSTEM]);
 455                 goto EXIT;
 456         }
 457         if (swap_file) {
 458                 snprintf(commandstring, STRING_SIZE, "/sbin/swapon %s2", hdparams.devnode_part);
 459                 if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_SWAP_PARTITION]))
 460                 {
 461                         errorbox(ctr[TR_UNABLE_TO_MOUNT_SWAP_PARTITION]);
 462                         goto EXIT;
 463                 }
 464         }
 465         snprintf(commandstring, STRING_SIZE, "/bin/mount %s4 /harddisk/var", hdparams.devnode_part);
 466         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_LOG_FILESYSTEM]))
 467         {
 468                 errorbox(ctr[TR_UNABLE_TO_MOUNT_LOG_FILESYSTEM]);
 469                 goto EXIT;
 470         }
 471
 472         if (installtype == URL_INSTALL) {
 473                 snprintf(commandstring, STRING_SIZE,
 474                         "/bin/wget -q -O - %s/" SNAME "-" VERSION ".tbz2 | /bin/tar -C /harddisk -xvjf -", url);
 475         }
 476
 477         if (installtype == CDROM_INSTALL) {
 478                 snprintf(commandstring, STRING_SIZE,
 479                         "/bin/tar -C /harddisk -xvjf /cdrom/" SNAME "-" VERSION ".tbz2");
 480         }
 481
 482         if (runcommandwithprogress(60, 4, title, commandstring, INST_FILECOUNT,
 483                 ctr[TR_INSTALLING_FILES]))
 484         {
 485                 errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
 486                 goto EXIT;
 487         }
 488
 489         /* Save USB controller type to modules.conf */
 490         write_usb_modules_conf();
 491
 492         /* Save language und local settings */
 493         write_lang_configs(shortlangname);
 494
 495         /* touch the modules.dep files */
 496         snprintf(commandstring, STRING_SIZE,
 497                 "/bin/touch /harddisk/lib/modules/%s-ipfire/modules.dep",
 498                 KERNEL_VERSION);
 499         mysystem(commandstring);
 500         snprintf(commandstring, STRING_SIZE,
 501                 "/bin/touch /harddisk/lib/modules/%s-ipfire-smp/modules.dep",
 502                 KERNEL_VERSION);
 503         mysystem(commandstring);
 504
 505         /* Rename uname */
 506         rename ("/harddisk/bin/uname.bak", "/harddisk/bin/uname");
 507
 508         /* mount proc filesystem */
 509         mysystem("mkdir /harddisk/proc");
 510         mysystem("/bin/mount -t proc none /harddisk/proc");
 511         mysystem("/bin/mount --bind /dev /harddisk/dev");
 512
 513         /* Build cache lang file */
 514         snprintf(commandstring, STRING_SIZE, "/sbin/chroot /harddisk /usr/bin/perl -e \"require '" CONFIG_ROOT "/lang.pl'; &Lang::BuildCacheLang\"");
 515         if (runcommandwithstatus(commandstring, ctr[TR_INSTALLING_LANG_CACHE]))
 516         {
 517                 errorbox(ctr[TR_UNABLE_TO_INSTALL_LANG_CACHE]);
 518                 goto EXIT;
 519         }
 520
 521         /* Update /etc/fstab */
 522         replace("/harddisk/etc/fstab", "DEVICE", hdparams.devnode_part_run);
 523
 524         /* if we detected SCSI/USB then fixup */
 525 /*      mysystem("/bin/probecntrl.sh");
 526         if ((handle = fopen("/tmp/cntrldriver", "r")))
 527         {
 528                 char *driver;
 529                 fgets(line, STRING_SIZE-1, handle);
 530                 fclose(handle);
 531                 line[strlen(line) - 1] = 0;
 532                 driver = strtok(line, ".");
 533                 if (strlen(driver) > 1) {
 534                         fprintf(flog, "Fixing up ipfirerd.img\n");
 535                         mkdir("/harddisk/initrd", S_IRWXU|S_IRWXG|S_IRWXO);
 536                         snprintf(commandstring, STRING_SIZE, "/sbin/chroot /harddisk /sbin/mkinitrd --with=scsi_mod %s --with=sd_mod --with=sr_mod /boot/ipfirerd.img %s-ipfire", driver, KERNEL_VERSION);
 537                         runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
 538                         snprintf(commandstring, STRING_SIZE, "/sbin/chroot /harddisk /sbin/mkinitrd --with=scsi_mod %s --with=sd_mod --with=sr_mod /boot/ipfirerd-smp.img %s-ipfire-smp", driver, KERNEL_VERSION);
 539                         runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
 540                         mysystem("/sbin/chroot /harddisk /bin/mv /boot/grub/scsigrub.conf /boot/grub/grub.conf");
 541                 }
 542         } */
 543
 544         sprintf(string, "root=%s3", hdparams.devnode_part_run);
 545         replace( "/harddisk/boot/grub/grub.conf", "root=ROOT", string);
 546         replace( "/harddisk/boot/grub/grubbatch", "DEVICE", hdparams.devnode_disk);
 547
 548         /* restore permissions */
 549         chmod("/harddisk/boot/grub/grubbatch", S_IXUSR | S_IRUSR | S_IXGRP | S_IRGRP | S_IXOTH | S_IROTH);
 550
 551         snprintf(commandstring, STRING_SIZE,
 552                  "/sbin/chroot /harddisk /boot/grub/grubbatch");
 553         if (runcommandwithstatus(commandstring, ctr[TR_INSTALLING_GRUB])) {
 554                 errorbox(ctr[TR_UNABLE_TO_INSTALL_GRUB]);
 555                 goto EXIT;
 556         }
 557
 558         /* Install bootsplash */
 559         mysystem("/bin/installbootsplash.sh");
 560
 561         mysystem("ln -s grub.conf /harddisk/boot/grub/menu.lst");
 562         mysystem("umount /harddisk/proc");
 563         mysystem("umount /harddisk/dev");
 564
 565         if (!unattended) {
 566                 sprintf(message, ctr[TR_CONGRATULATIONS_LONG],
 567                                 NAME, SNAME, SNAME, NAME, NAME, NAME);
 568                 newtWinMessage(ctr[TR_CONGRATULATIONS], ctr[TR_OK], message);
 569         }
 570
 571         allok = 1;
 572
 573 EXIT:
 574         fprintf(flog, "Install program ended.\n");
 575
 576         if (!(allok))
 577                 newtWinMessage(title, ctr[TR_OK], ctr[TR_PRESS_OK_TO_REBOOT]);
 578
 579         freekeyvalues(ethernetkv);
 580
 581         if (allok && !allok_fastexit)
 582         {
 583                 /* /proc is needed by the module checker.  We have to mount it
 584                  * so it can be seen by setup, which is run chrooted. */
 585                 if (system("/bin/mount proc -t proc /harddisk/proc"))
 586                         printf("Unable to mount proc in /harddisk.");
 587                 else
 588                 {
 589                         if (unattended) {
 590                             fprintf(flog, "Entering unattended setup\n");
 591                             if (unattended_setup(unattendedkv)) {
 592                                 snprintf(commandstring, STRING_SIZE, "/bin/sleep 10");
 593                                 runcommandwithstatus(commandstring, "Unattended installation finished, system will reboot");
 594                             } else {
 595                                 errorbox("Unattended setup failed.");
 596                                 goto EXIT;
 597                             }
 598                         }
 599
 600                         newtFinished();
 601                         fflush(flog);
 602                         fclose(flog);
 603
 604                         if (!unattended) {
 605                                         // Copy our scanned nics to the disk and lock because scan doesn't work in chroot
 606                                         system("touch /harddisk/var/ipfire/ethernet/scan_lock");
 607                                         system("cp -f /tmp/scanned_nics /harddisk/var/ipfire/ethernet/scanned_nics");
 608                             if (system("/sbin/chroot /harddisk /usr/local/sbin/setup /dev/tty2 INSTALL"))
 609                                     printf("Unable to run setup.\n");
 610                                   system("rm -f /harddisk/var/ipfire/ethernet/scan_lock");
 611                         }
 612
 613                         if (system("/bin/umount /harddisk/proc"))
 614                                 printf("Unable to umount /harddisk/proc.\n");
 615                 }
 616         }
 617         fcloseall();
 618
 619         if (swap_file) {
 620                 snprintf(commandstring, STRING_SIZE, "/bin/swapoff %s2", hdparams.devnode_part);
 621         }
 622
 623         newtFinished();
 624
 625         system("/bin/umount /harddisk/var");
 626         system("/bin/umount /harddisk/boot");
 627         system("/bin/umount /harddisk");
 628
 629         system("/etc/halt");
 630
 631         return 0;
 632 }