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