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