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 21000
  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         if (disk < 2097150) {
 376                 // <2TB use sfdisk and normal mbr
 377                 snprintf(commandstring, STRING_SIZE, "/sbin/sfdisk -L -uM %s < /tmp/partitiontable", hdparams.devnode_disk);
 378         } else {
 379                 // >2TB use parted with gpt
 380                 snprintf(commandstring, STRING_SIZE, "/usr/sbin/parted -s %s mklabel gpt mkpart boot ext2 1M 64M mkpart swap linux-swap 64M 1000M mkpart root ext4 1000M 5000M mkpart var ext4 5000M 100%% disk_set pmbr_boot on", hdparams.devnode_disk);
 381         }
 382
 383         if (runcommandwithstatus(commandstring, ctr[TR_PARTITIONING_DISK]))
 384         {
 385                 errorbox(ctr[TR_UNABLE_TO_PARTITION]);
 386                 goto EXIT;
 387         }
 388
 389         if (fstype == EXT2) {
 390 //              mysystem("/sbin/modprobe ext2");
 391                 sprintf(mkfscommand, "/sbin/mke2fs -T ext2");
 392         } else if (fstype == REISERFS) {
 393                 mysystem("/sbin/modprobe reiserfs");
 394                 sprintf(mkfscommand, "/sbin/mkreiserfs -f");
 395         } else if (fstype == EXT3) {
 396 //              mysystem("/sbin/modprobe ext3");
 397                 sprintf(mkfscommand, "/sbin/mke2fs -T ext3");
 398         } else if (fstype == EXT4) {
 399 //              mysystem("/sbin/modprobe ext4");
 400                 sprintf(mkfscommand, "/sbin/mke2fs -T ext4");
 401         }
 402
 403         snprintf(commandstring, STRING_SIZE, "/sbin/mke2fs -T ext2 -I 128 %s1", hdparams.devnode_part);
 404         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_BOOT_FILESYSTEM]))
 405         {
 406                 errorbox(ctr[TR_UNABLE_TO_MAKE_BOOT_FILESYSTEM]);
 407                 goto EXIT;
 408         }
 409
 410         if (swap_file) {
 411                 snprintf(commandstring, STRING_SIZE, "/sbin/mkswap %s2", hdparams.devnode_part);
 412                 if (runcommandwithstatus(commandstring, ctr[TR_MAKING_SWAPSPACE]))
 413                 {
 414                         errorbox(ctr[TR_UNABLE_TO_MAKE_SWAPSPACE]);
 415                         goto EXIT;
 416                 }
 417         }
 418
 419         snprintf(commandstring, STRING_SIZE, "%s %s3", mkfscommand, hdparams.devnode_part);
 420         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_ROOT_FILESYSTEM]))
 421         {
 422                 errorbox(ctr[TR_UNABLE_TO_MAKE_ROOT_FILESYSTEM]);
 423                 goto EXIT;
 424         }
 425
 426         snprintf(commandstring, STRING_SIZE, "%s %s4", mkfscommand, hdparams.devnode_part);
 427         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_LOG_FILESYSTEM]))
 428         {
 429                 errorbox(ctr[TR_UNABLE_TO_MAKE_LOG_FILESYSTEM]);
 430                 goto EXIT;
 431         }
 432
 433         snprintf(commandstring, STRING_SIZE, "/bin/mount %s3 /harddisk", hdparams.devnode_part);
 434         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_ROOT_FILESYSTEM]))
 435         {
 436                 errorbox(ctr[TR_UNABLE_TO_MOUNT_ROOT_FILESYSTEM]);
 437                 goto EXIT;
 438         }
 439
 440         mkdir("/harddisk/boot", S_IRWXU|S_IRWXG|S_IRWXO);
 441         mkdir("/harddisk/var", S_IRWXU|S_IRWXG|S_IRWXO);
 442         mkdir("/harddisk/var/log", S_IRWXU|S_IRWXG|S_IRWXO);
 443
 444         snprintf(commandstring, STRING_SIZE, "/bin/mount %s1 /harddisk/boot", hdparams.devnode_part);
 445         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_BOOT_FILESYSTEM]))
 446         {
 447                 errorbox(ctr[TR_UNABLE_TO_MOUNT_BOOT_FILESYSTEM]);
 448                 goto EXIT;
 449         }
 450         if (swap_file) {
 451                 snprintf(commandstring, STRING_SIZE, "/sbin/swapon %s2", hdparams.devnode_part);
 452                 if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_SWAP_PARTITION]))
 453                 {
 454                         errorbox(ctr[TR_UNABLE_TO_MOUNT_SWAP_PARTITION]);
 455                         goto EXIT;
 456                 }
 457         }
 458         snprintf(commandstring, STRING_SIZE, "/bin/mount %s4 /harddisk/var", hdparams.devnode_part);
 459         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_LOG_FILESYSTEM]))
 460         {
 461                 errorbox(ctr[TR_UNABLE_TO_MOUNT_LOG_FILESYSTEM]);
 462                 goto EXIT;
 463         }
 464
 465         snprintf(commandstring, STRING_SIZE,
 466                 "/bin/tar -C /harddisk  -xvf /cdrom/" SNAME "-" VERSION ".tlz --lzma 2>/dev/null");
 467
 468         if (runcommandwithprogress(60, 4, title, commandstring, INST_FILECOUNT,
 469                 ctr[TR_INSTALLING_FILES]))
 470         {
 471                 errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
 472                 goto EXIT;
 473         }
 474
 475         /* Save language und local settings */
 476         write_lang_configs(shortlangname);
 477
 478         /* mount proc filesystem */
 479         mysystem("mkdir /harddisk/proc");
 480         mysystem("/bin/mount --bind /proc /harddisk/proc");
 481         mysystem("/bin/mount --bind /dev  /harddisk/dev");
 482         mysystem("/bin/mount --bind /sys  /harddisk/sys");
 483
 484         /* Build cache lang file */
 485         snprintf(commandstring, STRING_SIZE, "/usr/sbin/chroot /harddisk /usr/bin/perl -e \"require '" CONFIG_ROOT "/lang.pl'; &Lang::BuildCacheLang\"");
 486         if (runcommandwithstatus(commandstring, ctr[TR_INSTALLING_LANG_CACHE]))
 487         {
 488                 errorbox(ctr[TR_UNABLE_TO_INSTALL_LANG_CACHE]);
 489                 goto EXIT;
 490         }
 491
 492         /* Update /etc/fstab */
 493         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);
 494         system(commandstring);
 495         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);
 496         system(commandstring);
 497         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);
 498         system(commandstring);
 499         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);
 500         system(commandstring);
 501
 502         if (fstype == EXT2) {
 503                 replace("/harddisk/etc/fstab", "FSTYPE", "ext2");
 504                 replace("/harddisk/boot/grub/grub.conf", "MOUNT", "ro");
 505         } else if (fstype == REISERFS) {
 506                 replace("/harddisk/etc/fstab", "FSTYPE", "reiserfs");
 507                 replace("/harddisk/boot/grub/grub.conf", "MOUNT", "ro");
 508         } else if (fstype == EXT3) {
 509                 replace("/harddisk/etc/fstab", "FSTYPE", "ext3");
 510                 replace("/harddisk/boot/grub/grub.conf", "MOUNT", "ro");
 511         } else if (fstype == EXT4) {
 512                 replace("/harddisk/etc/fstab", "FSTYPE", "ext4");
 513                 replace("/harddisk/boot/grub/grub.conf", "MOUNT", "ro");
 514         }
 515
 516         replace("/harddisk/boot/grub/grub.conf", "KVER", KERNEL_VERSION);
 517
 518         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);
 519         system(commandstring);
 520
 521         mysystem("ln -s grub.conf /harddisk/boot/grub/menu.lst");
 522
 523         system("/bin/sed -e 's#/harddisk#/#g' -e 's#//#/#g'  < /proc/mounts > /harddisk/etc/mtab");
 524
 525         /*
 526          * Generate device.map to help grub finding the device to install itself on.
 527          */
 528         FILE *f = NULL;
 529         if (f = fopen("/harddisk/boot/grub/device.map", "w")) {
 530                 fprintf(f, "(hd0) %s\n", hdparams.devnode_disk);
 531                 fclose(f);
 532         }
 533
 534         snprintf(commandstring, STRING_SIZE,
 535                  "/usr/sbin/chroot /harddisk /usr/sbin/grub-install --no-floppy %s", hdparams.devnode_disk);
 536         if (runcommandwithstatus(commandstring, ctr[TR_INSTALLING_GRUB])) {
 537                 errorbox(ctr[TR_UNABLE_TO_INSTALL_GRUB]);
 538                 goto EXIT;
 539         }
 540
 541         /* Serial console ? */
 542         if (serialconsole) {
 543                 /* grub */
 544                 replace("/harddisk/boot/grub/grub.conf", "splashimage", "#splashimage");
 545                 replace("/harddisk/boot/grub/grub.conf", "#serial", "serial");
 546                 replace("/harddisk/boot/grub/grub.conf", "#terminal", "terminal");
 547                 replace("/harddisk/boot/grub/grub.conf", " panic=10 ", " console=ttyS0,38400n8 panic=10 ");
 548
 549                 /*inittab*/
 550                 replace("/harddisk/etc/inittab", "1:2345:respawn:", "#1:2345:respawn:");
 551                 replace("/harddisk/etc/inittab", "2:2345:respawn:", "#2:2345:respawn:");
 552                 replace("/harddisk/etc/inittab", "3:2345:respawn:", "#3:2345:respawn:");
 553                 replace("/harddisk/etc/inittab", "4:2345:respawn:", "#4:2345:respawn:");
 554                 replace("/harddisk/etc/inittab", "5:2345:respawn:", "#5:2345:respawn:");
 555                 replace("/harddisk/etc/inittab", "6:2345:respawn:", "#6:2345:respawn:");
 556                 replace("/harddisk/etc/inittab", "#7:2345:respawn:", "7:2345:respawn:");
 557         }
 558
 559         /* Set marker that the user has already accepted the gpl */
 560         mysystem("/usr/bin/touch /harddisk/var/ipfire/main/gpl_accepted");
 561
 562         /* Copy restore file from cdrom */
 563         if (unattended && (strlen(restore_file) > 0)) {
 564                 fprintf(flog, "unattended: Copy restore file\n");
 565                 snprintf(commandstring, STRING_SIZE,
 566                         "cp /cdrom/%s /harddisk/var/ipfire/backup", restore_file);
 567                 mysystem(commandstring);
 568         }
 569
 570         mysystem("umount /cdrom");
 571         snprintf(commandstring, STRING_SIZE, "/usr/bin/eject /dev/%s", sourcedrive);
 572         mysystem(commandstring);
 573
 574         if (!unattended) {
 575                 sprintf(message, ctr[TR_CONGRATULATIONS_LONG],
 576                                 NAME, SNAME, NAME);
 577                 newtWinMessage(ctr[TR_CONGRATULATIONS], ctr[TR_PRESS_OK_TO_REBOOT], message);
 578         }
 579
 580         allok = 1;
 581
 582 EXIT:
 583         fprintf(flog, "Install program ended.\n");
 584
 585         if (!(allok))
 586                 newtWinMessage(title, ctr[TR_OK], ctr[TR_PRESS_OK_TO_REBOOT]);
 587
 588         freekeyvalues(ethernetkv);
 589
 590         if (allok && !allok_fastexit)
 591         {
 592                 if (unattended) {
 593                         fprintf(flog, "Entering unattended setup\n");
 594                         if (unattended_setup(unattendedkv)) {
 595                                 snprintf(commandstring, STRING_SIZE, "/bin/sleep 10");
 596                                 runcommandwithstatus(commandstring, "Unattended installation finished, system will reboot");
 597                         } else {
 598                                 errorbox("Unattended setup failed.");
 599                                 goto EXIT;
 600                         }
 601                 }
 602
 603                 fflush(flog);
 604                 fclose(flog);
 605                 newtFinished();
 606
 607                 if (system("/bin/umount /harddisk/proc"))
 608                         printf("Unable to umount /harddisk/proc.\n");
 609         } else {
 610                 fflush(flog);
 611                 fclose(flog);
 612                 newtFinished();
 613         }
 614
 615         fcloseall();
 616
 617         if (swap_file) {
 618                 snprintf(commandstring, STRING_SIZE, "/bin/swapoff %s2", hdparams.devnode_part);
 619         }
 620
 621         newtFinished();
 622
 623         system("/bin/umount /harddisk/proc >/dev/null 2>&1");
 624         system("/bin/umount /harddisk/dev >/dev/null 2>&1");
 625         system("/bin/umount /harddisk/sys >/dev/null 2>&1");
 626
 627         system("/bin/umount /harddisk/var >/dev/null 2>&1");
 628         system("/bin/umount /harddisk/boot >/dev/null 2>&1");
 629         system("/bin/umount /harddisk >/dev/null 2>&1");
 630
 631         if (!(allok))
 632                 system("/etc/halt");
 633
 634         return 0;
 635 }