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