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