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