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