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