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