src/install+setup/install/main.c

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