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.6
   8  *
   9  */
  10
  11 #include "install.h"
  12 #define _GNU_SOURCE
  13
  14 #define INST_FILECOUNT 8400
  15 #define UNATTENDED_CONF "/cdrom/boot/unattended.conf"
  16
  17 #define EXT2 0
  18 #define EXT3 1
  19 #define EXT4 2
  20 #define REISERFS 3
  21
  22 FILE *flog = NULL;
  23 char *mylog;
  24
  25 char **ctr;
  26
  27 extern char url[STRING_SIZE];
  28
  29 struct  nic  nics[20] = { { "" , "" , "" } }; // only defined for compile
  30 struct knic knics[20] = { { "" , "" , "" , "" } }; // only defined for compile
  31
  32 extern char *en_tr[];
  33 extern char *es_tr[];
  34 extern char *de_tr[];
  35 extern char *fr_tr[];
  36
  37 int main(int argc, char *argv[])
  38 {
  39
  40         char discl_msg[40000] = "Disclaimer\n";
  41
  42         char *langnames[] = { "Deutsch", "English", "Français", "Español", NULL };
  43         char *shortlangnames[] = { "de", "en", "fr", "es", NULL };
  44         char **langtrs[] = { de_tr, en_tr, fr_tr, es_tr, NULL };
  45         char hdletter;
  46         char harddrive[30], sourcedrive[5];     /* Device holder. */
  47         struct devparams hdparams, cdromparams; /* Params for CDROM and HD */
  48         int rc = 0;
  49         char commandstring[STRING_SIZE];
  50         char mkfscommand[STRING_SIZE];
  51         char *fstypes[] = { "ext2", "ext3", "ext4", "ReiserFS", NULL };
  52         int fstype = EXT3;
  53         int choice;
  54         int i;
  55         int found = 0;
  56         int firstrun = 0;
  57         char shortlangname[10];
  58         char message[1000];
  59         char title[STRING_SIZE];
  60         int allok = 0;
  61         int allok_fastexit=0;
  62         int raid_disk = 0;
  63         struct keyvalue *ethernetkv = initkeyvalues();
  64         FILE *handle, *cmdfile, *copying;
  65         char line[STRING_SIZE];
  66         char string[STRING_SIZE];
  67         long memory = 0, disk = 0, free;
  68         long system_partition, boot_partition, root_partition, swap_file;
  69         int scsi_disk = 0;
  70         char *yesnoharddisk[3]; //      char *yesnoharddisk = { "NO", "YES", NULL };
  71
  72         int unattended = 0;
  73         struct keyvalue *unattendedkv = initkeyvalues();
  74         int hardyn = 0;
  75         char restore_file[STRING_SIZE] = "";
  76
  77         setlocale (LC_ALL, "");
  78         sethostname( SNAME , 10);
  79
  80         memset(&hdparams, 0, sizeof(struct devparams));
  81         memset(&cdromparams, 0, sizeof(struct devparams));
  82
  83         /* Log file/terminal stuff. */
  84         if (argc >= 2)
  85         {
  86                 if (!(flog = fopen(argv[1], "w+")))
  87                         return 0;
  88         }
  89         else
  90                 return 0;
  91
  92         mylog = argv[1];
  93
  94         fprintf(flog, "Install program started.\n");
  95
  96         newtInit();
  97         newtCls();
  98
  99         newtDrawRootText(14, 0, NAME " " VERSION " - " SLOGAN );
 100         sprintf (title, "%s %s - %s", NAME, VERSION, SLOGAN);
 101
 102         if (! (cmdfile = fopen("/proc/cmdline", "r")))
 103         {
 104                 fprintf(flog, "Couldn't open commandline: /proc/cmdline\n");
 105         } else {
 106                 fgets(line, STRING_SIZE, cmdfile);
 107
 108                 // check if we have to make an unattended install
 109                 if (strstr (line, "unattended") != NULL) {
 110                     unattended = 1;
 111                     runcommandwithstatus("/bin/sleep 10", "WARNING: Unattended installation will start in 10 seconds...");
 112                 }
 113         }
 114
 115         // Read gpl ...
 116         if (! (copying = fopen("/COPYING", "r")))
 117         {
 118                 fprintf(flog,      "Couldn't open gpl (/COPYING)\n");
 119                 sprintf(discl_msg, "Couldn't open gpl (/COPYING)\n");
 120         } else {
 121                 fread(discl_msg, 1, 40000, copying);
 122                 fclose(copying);
 123         }
 124
 125         // Load common modules
 126         mysystem("/sbin/modprobe iso9660"); // CDROM
 127         mysystem("/sbin/modprobe ext2"); // Boot patition
 128         mysystem("/sbin/modprobe vfat"); // USB key
 129
 130         /* German is the default */
 131         for (choice = 0; langnames[choice]; choice++)
 132         {
 133                 if (strcmp(langnames[choice], "Deutsch") == 0)
 134                         break;
 135         }
 136         if (!langnames[choice])
 137                 goto EXIT;
 138
 139         if (!unattended) {
 140             rc = newtWinMenu("Language selection", "Select the language you wish to use for the " NAME ".", 50, 5, 5, 8,
 141                     langnames, &choice, "Ok", NULL);
 142         }
 143
 144         ctr = langtrs[choice];
 145         strcpy(shortlangname, shortlangnames[choice]);
 146
 147         newtPushHelpLine(ctr[TR_HELPLINE]);
 148
 149         sprintf(message, ctr[TR_WELCOME], NAME);
 150         newtWinMessage(title, ctr[TR_OK], message);
 151
 152         if (!unattended) {
 153                 if (disclaimerbox(discl_msg)==0) {
 154                         errorbox(ctr[TR_LICENSE_NOT_ACCEPTED]);
 155                         goto EXIT;
 156                 }
 157         }
 158
 159         mysystem("/bin/mountsource.sh");
 160
 161         if ((handle = fopen("/tmp/source_device", "r")) == NULL) {
 162                 newtWinMessage(title, ctr[TR_OK], ctr[TR_NO_LOCAL_SOURCE]);
 163                 runcommandwithstatus("/bin/downloadsource.sh",ctr[TR_DOWNLOADING_ISO]);
 164                 if ((handle = fopen("/tmp/source_device", "r")) == NULL) {
 165                         errorbox(ctr[TR_DOWNLOAD_ERROR]);
 166                         goto EXIT;
 167                 }
 168         }
 169
 170         fgets(sourcedrive, 5, handle);
 171         fprintf(flog, "Source drive: %s\n", sourcedrive);
 172         fclose(handle);
 173
 174         i = 0;
 175         while (found == 0) {
 176                 i++;
 177                 fprintf(flog, "Harddisk scan pass %i\n", i);
 178
 179                 switch (mysystem("/bin/mountdest.sh") % 255) {
 180                         case 0: // Found IDE disk
 181                                 scsi_disk = 0;
 182                                 raid_disk = 0;
 183                                 found = 1;
 184                                 break;
 185                         case 1: // Found SCSI disk
 186                                 scsi_disk = 1;
 187                                 raid_disk = 0;
 188                                 found = 1;
 189                                 break;
 190                         case 2: // Found RAID disk
 191                                 scsi_disk = 0;
 192                                 raid_disk= 1;
 193                                 found = 1;
 194                                 break;
 195                         case 10: // No harddisk found
 196                                 if (firstrun == 1) {
 197                                         errorbox(ctr[TR_NO_HARDDISK]);
 198                                         goto EXIT;
 199                                 }
 200                                 // Do this if the kudzu-scan fails...
 201                                 runcommandwithstatus("/bin/probehw.sh deep-scan", ctr[TR_PROBING_HARDWARE]);
 202                                 firstrun = 1;
 203                 }
 204         }
 205
 206         if ((handle = fopen("/tmp/dest_device", "r")) == NULL) {
 207                 errorbox(ctr[TR_NO_HARDDISK]);
 208                 goto EXIT;
 209         }
 210         fgets(harddrive, 30, handle);
 211         fclose(handle);
 212
 213         /* load unattended configuration */
 214         if (unattended) {
 215             fprintf(flog, "unattended: Reading unattended.conf\n");
 216
 217             (void) readkeyvalues(unattendedkv, UNATTENDED_CONF);
 218             findkey(unattendedkv, "RESTORE_FILE", restore_file);
 219         }
 220
 221         /* Make the hdparms struct and print the contents.
 222            With USB-KEY install and SCSI disk, while installing, the disk
 223            is named 'sdb,sdc,...' (following keys)
 224            On reboot, it will become 'sda'
 225            To avoid many test, all names are built in the struct.
 226         */
 227         sprintf(hdparams.devnode_disk, "/dev/%s", harddrive);
 228         /* Address the partition or raid partition (eg dev/sda or /dev/sdap1 */
 229         sprintf(hdparams.devnode_part, "/dev/%s%s", harddrive,raid_disk ? "p" : "");
 230         /* Now the names after the machine is booted. Only scsi is affected
 231            and we only install on the first scsi disk. */
 232
 233         fprintf(flog, "Destination drive: %s\n", hdparams.devnode_disk);
 234
 235         sprintf(message, ctr[TR_PREPARE_HARDDISK], hdparams.devnode_disk);
 236         if (unattended) {
 237             hardyn = 1;
 238         } else {
 239                 yesnoharddisk[0] = ctr[TR_NO];
 240                 yesnoharddisk[1] = ctr[TR_YES];
 241                 yesnoharddisk[2] = NULL;
 242         }
 243
 244         while (! hardyn) {
 245                 rc = newtWinMenu(title, message,
 246                                  50, 5, 5, 6, yesnoharddisk,
 247                                  &hardyn, ctr[TR_OK],
 248                                  ctr[TR_CANCEL], NULL);
 249                 if (rc == 2)
 250                         goto EXIT;
 251         }
 252         if (rc == 2)
 253                 goto EXIT;
 254
 255         fstypes[0]=ctr[TR_EXT2FS_DESCR];
 256         fstypes[1]=ctr[TR_EXT3FS_DESCR];
 257         fstypes[2]=ctr[TR_EXT4FS_DESCR];
 258         fstypes[3]=ctr[TR_REISERFS_DESCR];
 259         fstypes[4]=NULL;
 260
 261         if (!unattended) {
 262                 sprintf(message, ctr[TR_CHOOSE_FILESYSTEM]);
 263                 rc = newtWinMenu( ctr[TR_CHOOSE_FILESYSTEM], message,
 264                         50, 5, 5, 6, fstypes, &fstype, ctr[TR_OK],
 265                         ctr[TR_CANCEL], NULL);
 266         } else {
 267             rc = 1;
 268             fstype = EXT3;
 269         }
 270         if (rc == 2)
 271                 goto EXIT;
 272
 273         /* Calculate amount of memory in machine */
 274         if ((handle = fopen("/proc/meminfo", "r")))
 275         {
 276             while (fgets(line, STRING_SIZE-1, handle)) {
 277                 if (sscanf (line, "MemTotal: %s kB", string)) {
 278                     memory = atoi(string) / 1024 ;
 279                 }
 280             }
 281             fclose(handle);
 282         }
 283
 284         /* Partition, mkswp, mkfs.
 285          * before partitioning, first determine the sizes of each
 286          * partition.  In order to do that we need to know the size of
 287          * the disk.
 288          */
 289         /* Don't use mysystem here so we can redirect output */
 290         sprintf(commandstring, "/sbin/sfdisk -s /dev/%s > /tmp/disksize 2> /dev/null", harddrive);
 291         system(commandstring);
 292
 293         /* Calculate amount of disk space */
 294         if ((handle = fopen("/tmp/disksize", "r"))) {
 295                 fgets(line, STRING_SIZE-1, handle);
 296                 if (sscanf (line, "%s", string)) {
 297                         disk = atoi(string) / 1024;
 298                 }
 299                 fclose(handle);
 300         }
 301
 302         fprintf(flog, "Disksize = %ld, memory = %ld", disk, memory);
 303
 304          /* Calculating Swap-Size dependend of Ram Size */
 305         if (memory <= 256)
 306                 swap_file = 128;
 307         else if (memory <= 1024 && memory > 256)
 308                 swap_file = 256;
 309         else
 310                 swap_file = memory / 4;
 311
 312   /* Calculating Root-Size dependend of Max Disk Space */
 313   if ( disk < 756 )
 314                 root_partition = 200;
 315         else if ( disk >= 756 && disk <= 3072 )
 316                 root_partition = 512;
 317         else
 318                 root_partition = 2048;
 319
 320
 321   /* Calculating the amount of free space */
 322         boot_partition = 20; /* in MB */
 323         system_partition = disk - ( root_partition + swap_file + boot_partition );
 324
 325         fprintf(flog, ", boot = %ld, swap = %ld, mylog = %ld, root = %ld\n",
 326         boot_partition, swap_file, system_partition, root_partition);
 327         rc = 0;
 328
 329         if ( (!unattended) && (((disk - (root_partition + swap_file + boot_partition)) < 256 ) && ((disk - (root_partition + boot_partition )) > 256)) ) {
 330    rc = newtWinChoice(title, ctr[TR_OK], ctr[TR_CANCEL], ctr[TR_CONTINUE_NO_SWAP]);
 331     if (rc == 1){
 332       swap_file = 0;
 333       system_partition = disk - ( root_partition + swap_file + boot_partition );
 334       fprintf(flog, "Changing Swap Size to 0 MB.\n");
 335     }
 336     else if (rc == 2){
 337     fprintf(flog, "Disk is too small.\n");
 338     errorbox(ctr[TR_DISK_TOO_SMALL]);goto EXIT;
 339     }
 340   }
 341   else if (disk - (root_partition + swap_file + boot_partition) >= 256) {
 342
 343   }
 344   else {
 345    fprintf(flog, "Disk is too small.\n");
 346    errorbox(ctr[TR_DISK_TOO_SMALL]);goto EXIT;
 347   }
 348
 349         handle = fopen("/tmp/partitiontable", "w");
 350
 351         /* Make swapfile */
 352   if (swap_file) {
 353      fprintf(handle, ",%ld,L,*\n,%ld,S,\n,%ld,L,\n,,L,\n",
 354      boot_partition, swap_file, root_partition);
 355   } else {
 356      fprintf(handle, ",%ld,L,*\n,0,0,\n,%ld,L,\n,,L,\n",
 357      boot_partition, root_partition);
 358   }
 359
 360         fclose(handle);
 361
 362         snprintf(commandstring, STRING_SIZE, "/sbin/sfdisk -L -uM %s < /tmp/partitiontable", hdparams.devnode_disk);
 363         if (runcommandwithstatus(commandstring, ctr[TR_PARTITIONING_DISK]))
 364         {
 365                 errorbox(ctr[TR_UNABLE_TO_PARTITION]);
 366                 goto EXIT;
 367         }
 368
 369         if (fstype == EXT2) {
 370                 mysystem("/sbin/modprobe ext2");
 371                 sprintf(mkfscommand, "/sbin/mke2fs -T ext2");
 372         } else if (fstype == REISERFS) {
 373                 mysystem("/sbin/modprobe reiserfs");
 374                 sprintf(mkfscommand, "/sbin/mkreiserfs -f");
 375         } else if (fstype == EXT3) {
 376                 mysystem("/sbin/modprobe ext3");
 377                 sprintf(mkfscommand, "/sbin/mke2fs -T ext3");
 378         } else if (fstype == EXT4) {
 379                 mysystem("/sbin/modprobe ext4");
 380                 sprintf(mkfscommand, "/sbin/mke2fs -T ext4");
 381         }
 382
 383         snprintf(commandstring, STRING_SIZE, "/sbin/mke2fs -T ext2 -I 128 %s1", hdparams.devnode_part);
 384         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_BOOT_FILESYSTEM]))
 385         {
 386                 errorbox(ctr[TR_UNABLE_TO_MAKE_BOOT_FILESYSTEM]);
 387                 goto EXIT;
 388         }
 389
 390         if (swap_file) {
 391                 snprintf(commandstring, STRING_SIZE, "/sbin/mkswap %s2", hdparams.devnode_part);
 392                 if (runcommandwithstatus(commandstring, ctr[TR_MAKING_SWAPSPACE]))
 393                 {
 394                         errorbox(ctr[TR_UNABLE_TO_MAKE_SWAPSPACE]);
 395                         goto EXIT;
 396                 }
 397         }
 398
 399         snprintf(commandstring, STRING_SIZE, "%s %s3", mkfscommand, hdparams.devnode_part);
 400         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_ROOT_FILESYSTEM]))
 401         {
 402                 errorbox(ctr[TR_UNABLE_TO_MAKE_ROOT_FILESYSTEM]);
 403                 goto EXIT;
 404         }
 405
 406         snprintf(commandstring, STRING_SIZE, "%s %s4", mkfscommand, hdparams.devnode_part);
 407         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_LOG_FILESYSTEM]))
 408         {
 409                 errorbox(ctr[TR_UNABLE_TO_MAKE_LOG_FILESYSTEM]);
 410                 goto EXIT;
 411         }
 412
 413         snprintf(commandstring, STRING_SIZE, "/bin/mount %s3 /harddisk", hdparams.devnode_part);
 414         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_ROOT_FILESYSTEM]))
 415         {
 416                 errorbox(ctr[TR_UNABLE_TO_MOUNT_ROOT_FILESYSTEM]);
 417                 goto EXIT;
 418         }
 419
 420         mkdir("/harddisk/boot", S_IRWXU|S_IRWXG|S_IRWXO);
 421         mkdir("/harddisk/var", S_IRWXU|S_IRWXG|S_IRWXO);
 422         mkdir("/harddisk/var/log", S_IRWXU|S_IRWXG|S_IRWXO);
 423
 424         snprintf(commandstring, STRING_SIZE, "/bin/mount %s1 /harddisk/boot", hdparams.devnode_part);
 425         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_BOOT_FILESYSTEM]))
 426         {
 427                 errorbox(ctr[TR_UNABLE_TO_MOUNT_BOOT_FILESYSTEM]);
 428                 goto EXIT;
 429         }
 430         if (swap_file) {
 431                 snprintf(commandstring, STRING_SIZE, "/sbin/swapon %s2", hdparams.devnode_part);
 432                 if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_SWAP_PARTITION]))
 433                 {
 434                         errorbox(ctr[TR_UNABLE_TO_MOUNT_SWAP_PARTITION]);
 435                         goto EXIT;
 436                 }
 437         }
 438         snprintf(commandstring, STRING_SIZE, "/bin/mount %s4 /harddisk/var", hdparams.devnode_part);
 439         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_LOG_FILESYSTEM]))
 440         {
 441                 errorbox(ctr[TR_UNABLE_TO_MOUNT_LOG_FILESYSTEM]);
 442                 goto EXIT;
 443         }
 444
 445         snprintf(commandstring, STRING_SIZE,
 446                 "/bin/tar -C /harddisk  -xvf /cdrom/" SNAME "-" VERSION ".tlz --lzma 2>/dev/null");
 447
 448         if (runcommandwithprogress(60, 4, title, commandstring, INST_FILECOUNT,
 449                 ctr[TR_INSTALLING_FILES]))
 450         {
 451                 errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
 452                 goto EXIT;
 453         }
 454
 455         /* Save language und local settings */
 456         write_lang_configs(shortlangname);
 457
 458         /* Rename uname */
 459         rename ("/harddisk/bin/uname.bak", "/harddisk/bin/uname");
 460
 461         /* mount proc filesystem */
 462         mysystem("mkdir /harddisk/proc");
 463         mysystem("/bin/mount --bind /proc /harddisk/proc");
 464         mysystem("/bin/mount --bind /dev  /harddisk/dev");
 465         mysystem("/bin/mount --bind /sys  /harddisk/sys");
 466
 467         /* Build cache lang file */
 468         snprintf(commandstring, STRING_SIZE, "/usr/sbin/chroot /harddisk /usr/bin/perl -e \"require '" CONFIG_ROOT "/lang.pl'; &Lang::BuildCacheLang\"");
 469         if (runcommandwithstatus(commandstring, ctr[TR_INSTALLING_LANG_CACHE]))
 470         {
 471                 errorbox(ctr[TR_UNABLE_TO_INSTALL_LANG_CACHE]);
 472                 goto EXIT;
 473         }
 474
 475         /* Update /etc/fstab */
 476         snprintf(commandstring, STRING_SIZE, "/bin/sed -i -e \"s#DEVICE1#UUID=$(/sbin/blkid %s1 -sUUID | /usr/bin/cut -d'\"' -f2)#g\" /harddisk/etc/fstab", hdparams.devnode_part);
 477         system(commandstring);
 478         snprintf(commandstring, STRING_SIZE, "/bin/sed -i -e \"s#DEVICE2#UUID=$(/sbin/blkid %s2 -sUUID | /usr/bin/cut -d'\"' -f2)#g\" /harddisk/etc/fstab", hdparams.devnode_part);
 479         system(commandstring);
 480         snprintf(commandstring, STRING_SIZE, "/bin/sed -i -e \"s#DEVICE3#UUID=$(/sbin/blkid %s3 -sUUID | /usr/bin/cut -d'\"' -f2)#g\" /harddisk/etc/fstab", hdparams.devnode_part);
 481         system(commandstring);
 482         snprintf(commandstring, STRING_SIZE, "/bin/sed -i -e \"s#DEVICE4#UUID=$(/sbin/blkid %s4 -sUUID | /usr/bin/cut -d'\"' -f2)#g\" /harddisk/etc/fstab", hdparams.devnode_part);
 483         system(commandstring);
 484
 485         if (fstype == EXT2) {
 486                 replace("/harddisk/etc/fstab", "FSTYPE", "ext2");
 487                 replace("/harddisk/boot/grub/grub.conf", "MOUNT", "ro");
 488         } else if (fstype == REISERFS) {
 489                 replace("/harddisk/etc/fstab", "FSTYPE", "reiserfs");
 490                 replace("/harddisk/boot/grub/grub.conf", "MOUNT", "ro");
 491         } else if (fstype == EXT3) {
 492                 replace("/harddisk/etc/fstab", "FSTYPE", "ext3");
 493                 replace("/harddisk/boot/grub/grub.conf", "MOUNT", "ro");
 494         } else if (fstype == EXT4) {
 495                 replace("/harddisk/etc/fstab", "FSTYPE", "ext4");
 496                 replace("/harddisk/boot/grub/grub.conf", "MOUNT", "ro");
 497         }
 498
 499         replace("/harddisk/boot/grub/grub.conf", "KVER", KERNEL_VERSION);
 500
 501         snprintf(commandstring, STRING_SIZE, "/bin/sed -i -e \"s#root=ROOT#root=UUID=$(/sbin/blkid %s3 -sUUID | /usr/bin/cut -d'\"' -f2)#g\" /harddisk/boot/grub/grub.conf", hdparams.devnode_part);
 502         system(commandstring);
 503
 504         mysystem("ln -s grub.conf /harddisk/boot/grub/menu.lst");
 505
 506         system("/bin/sed -e 's#/harddisk#/#g' -e 's#//#/#g'  < /proc/mounts > /harddisk/etc/mtab");
 507
 508         snprintf(commandstring, STRING_SIZE,
 509                  "/usr/sbin/chroot /harddisk /usr/sbin/grub-install --no-floppy %s", hdparams.devnode_disk);
 510         if (runcommandwithstatus(commandstring, ctr[TR_INSTALLING_GRUB])) {
 511                 errorbox(ctr[TR_UNABLE_TO_INSTALL_GRUB]);
 512                 goto EXIT;
 513         }
 514
 515         /* Copy restore file from cdrom */
 516         if (unattended && (strlen(restore_file) > 0)) {
 517                 fprintf(flog, "unattended: Copy restore file\n");
 518                 snprintf(commandstring, STRING_SIZE,
 519                         "cp /cdrom/%s /harddisk/var/ipfire/backup", restore_file);
 520                 mysystem(commandstring);
 521         }
 522
 523         mysystem("umount /cdrom");
 524         snprintf(commandstring, STRING_SIZE, "/usr/bin/eject /dev/%s", sourcedrive);
 525         mysystem(commandstring);
 526
 527         if (!unattended) {
 528                 sprintf(message, ctr[TR_CONGRATULATIONS_LONG],
 529                                 NAME, SNAME, NAME);
 530                 newtWinMessage(ctr[TR_CONGRATULATIONS], ctr[TR_OK], message);
 531         }
 532
 533         allok = 1;
 534
 535 EXIT:
 536         fprintf(flog, "Install program ended.\n");
 537
 538         if (!(allok))
 539                 newtWinMessage(title, ctr[TR_OK], ctr[TR_PRESS_OK_TO_REBOOT]);
 540
 541         freekeyvalues(ethernetkv);
 542
 543         if (allok && !allok_fastexit)
 544         {
 545                 if (unattended) {
 546                         fprintf(flog, "Entering unattended setup\n");
 547                         if (unattended_setup(unattendedkv)) {
 548                                 snprintf(commandstring, STRING_SIZE, "/bin/sleep 10");
 549                                 runcommandwithstatus(commandstring, "Unattended installation finished, system will reboot");
 550                         } else {
 551                                 errorbox("Unattended setup failed.");
 552                                 goto EXIT;
 553                         }
 554                 }
 555
 556                 fflush(flog);
 557                 fclose(flog);
 558                 newtFinished();
 559
 560                 if (unattended) {
 561                         // Remove Setup autorun after boot
 562                         if (system("rm -f /harddisk/etc/rc.d/rcsysinit.d/S75firstsetup"))
 563                                 printf("Unable to disable setup autorun.\n");
 564                 }
 565
 566                 if (system("/bin/umount /harddisk/proc"))
 567                         printf("Unable to umount /harddisk/proc.\n");
 568         } else {
 569                 fflush(flog);
 570                 fclose(flog);
 571                 newtFinished();
 572         }
 573
 574         fcloseall();
 575
 576         if (swap_file) {
 577                 snprintf(commandstring, STRING_SIZE, "/bin/swapoff %s2", hdparams.devnode_part);
 578         }
 579
 580         newtFinished();
 581
 582         system("/bin/umount /harddisk/proc");
 583         system("/bin/umount /harddisk/dev");
 584         system("/bin/umount /harddisk/sys");
 585
 586         system("/bin/umount /harddisk/var");
 587         system("/bin/umount /harddisk/boot");
 588         system("/bin/umount /harddisk");
 589
 590         if (!(allok))
 591                 system("/etc/halt");
 592
 593         return 0;
 594 }