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  * $Id: main.c,v 1.63.2.57 2005/09/25 19:57:46 gespinasse Exp $
  10  *
  11  */
  12
  13 #include "install.h"
  14
  15 #define CDROM_INSTALL 0
  16 #define URL_INSTALL 1
  17 #define LANG_DE_EN
  18
  19 int raid_disk = 0;
  20 FILE *flog = NULL;
  21 char *mylog;
  22
  23 char **ctr;
  24
  25 char *pcmcia = NULL;
  26 extern char url[STRING_SIZE];
  27
  28 extern char *bz_tr[];
  29 extern char *cs_tr[];
  30 extern char *da_tr[];
  31 extern char *en_tr[];
  32 extern char *es_tr[];
  33 extern char *fi_tr[];
  34 extern char *fr_tr[];
  35 extern char *hu_tr[];
  36 extern char *la_tr[];
  37 extern char *nl_tr[];
  38 extern char *de_tr[];
  39 extern char *tr_tr[];
  40 extern char *it_tr[];
  41 extern char *el_tr[];
  42 extern char *pl_tr[];
  43 extern char *pt_tr[];
  44 extern char *so_tr[];
  45 extern char *sv_tr[];
  46 extern char *no_tr[];
  47 extern char *vi_tr[];
  48
  49 int main(int argc, char *argv[])
  50 {
  51 #ifdef  LANG_EN_ONLY
  52         char *langnames[] = { "English", NULL };
  53         char *shortlangnames[] = { "en", NULL };
  54         char **langtrs[] = { en_tr, NULL };
  55 #elif   LANG_DE_EN
  56         char *langnames[] = { "Deutsch", "English", NULL };
  57         char *shortlangnames[] = { "de", "en", NULL };
  58         char **langtrs[] = { de_tr, en_tr, NULL };
  59 #else
  60         char *langnames[] = { "Brasil", "Cestina", "Dansk", "Deutsch", "English", "Español", "Français", "Hellenic", "Italiano", "Spanish Latino", "Magyar", "Nederlands", "Norsk", "Polski", "Português", "Soomali", "Suomi", "Svenska", "Türkçe", "Tieng Viet", NULL };
  61         char *shortlangnames[] = { "bz", "cs", "da", "de", "en", "es", "fr", "el", "it", "la", "hu", "nl", "no", "pl", "pt", "so", "fi", "sv", "tr", "vi", NULL };
  62         char **langtrs[] = { bz_tr, cs_tr, da_tr, de_tr, en_tr, es_tr, fr_tr, el_tr, it_tr, la_tr, hu_tr, nl_tr, no_tr, pl_tr, pt_tr, so_tr, fi_tr, sv_tr, tr_tr, vi_tr, NULL };
  63
  64 #endif
  65         char hdletter, cdletter;
  66         char harddrive[5], cdromdrive[5];       /* Device holder. */
  67         struct devparams hdparams, cdromparams; /* Params for CDROM and HD */
  68         int cdmounted = 0;              /* Loop flag for inserting a cd. */
  69         int rc;
  70         char commandstring[STRING_SIZE];
  71         char *installtypes[] = { "CDROM", "HTTP/FTP", NULL };
  72         int installtype = CDROM_INSTALL;
  73         char insertmessage[STRING_SIZE];
  74         char insertdevnode[STRING_SIZE];
  75         int choice;
  76         char shortlangname[10];
  77         char message[1000];
  78         char title[STRING_SIZE];
  79         int allok = 0;
  80         int allok_fastexit=0;
  81         int unmount_before=0;
  82         struct keyvalue *ethernetkv = initkeyvalues();
  83         FILE *handle, *cmdfile;
  84         char line[STRING_SIZE];
  85         char string[STRING_SIZE];
  86         int maximum_free = 0, current_free;
  87         int memory = 0;
  88         int log_partition, boot_partition, root_partition, swap_file;
  89         int scsi_disk = 0;
  90         int pcmcia_disk = 0;
  91         int pcmcia_cdrom = 0;
  92         int scsi_cdrom = 0;
  93         int ide_cdrom = 0;
  94         int fdisk = 0;
  95
  96
  97         setlocale (LC_ALL, "");
  98         sethostname( SNAME , 10);
  99
 100         memset(&hdparams, 0, sizeof(struct devparams));
 101         memset(&cdromparams, 0, sizeof(struct devparams));
 102
 103         /* Log file/terminal stuff. */
 104         if (argc >= 2)
 105         {
 106                 if (!(flog = fopen(argv[1], "w+")))
 107                         return 0;
 108         }
 109         else
 110                 return 0;
 111
 112         mylog = argv[1];
 113
 114         fprintf(flog, "Install program started.\n");
 115
 116         newtInit();
 117         newtCls();
 118
 119         /* Do usb detection first for usb keyboard */
 120         if (! (cmdfile = fopen("/proc/cmdline", "r")))
 121         {
 122                 fprintf(flog, "Couldn't open commandline: /proc/cmdline\n");
 123         } else {
 124                 fgets(line, STRING_SIZE, cmdfile);
 125                 if (strstr (line, "fdisk") != NULL) {
 126                         fprintf(flog, "Manual FDISK selected.\n");
 127                         fdisk = 1;
 128                 }
 129                 if (strstr (line, "nopcmcia") == NULL) {
 130                         fprintf(flog, "Initializing PCMCIA controllers.\n");
 131                         pcmcia = initialize_pcmcia();
 132                         if (pcmcia) {
 133                                 fprintf (flog, "Detected PCMCIA Controller: %s.\n", pcmcia);
 134                                 sprintf(commandstring, "/sbin/modprobe %s", pcmcia);
 135                                 mysystem("/sbin/modprobe pcmcia_core");
 136                                 mysystem(commandstring);
 137                                 mysystem("/sbin/modprobe ds");
 138                                 /* pcmcia netcard drivers are not available from Boot floppy,
 139                                  * they will be loaded from Drivers floppy later */
 140                         } else {
 141                                 fprintf (flog, "Detected No PCMCIA Controller.\n");
 142                         }
 143                 } else {
 144                         fprintf(flog, "Skipping PCMCIA detection.\n");
 145                 }
 146                 if (strstr (line, "nousb") == NULL) {
 147                         fprintf(flog, "Initializing USB controllers.\n");
 148                         initialize_usb();
 149                 } else {
 150                         fprintf(flog, "Skipping USB detection.\n");
 151                 }
 152         }
 153
 154         /* Deutsch is the default */
 155         for (choice = 0; langnames[choice]; choice++)
 156         {
 157                 if (strcmp(langnames[choice], "Deutsch") == 0)
 158                         break;
 159         }
 160         if (!langnames[choice])
 161                 goto EXIT;
 162
 163 #ifdef  LANG_EN_ONLY
 164         /* No need to ask.  "choice" already has the index for English */
 165 #else
 166         rc = newtWinMenu("Language selection",
 167                 "Select the language you wish to use for the " NAME ".", 50, 5, 5, 8,
 168                 langnames, &choice, "Ok", NULL);
 169 #endif
 170         ctr = langtrs[choice];
 171         strcpy(shortlangname, shortlangnames[choice]);
 172         if (strcmp(shortlangname, "el") == 0)
 173                 mysystem("/bin/setfont iso07u-16");
 174         else if (strcmp(shortlangname, "pt") == 0)
 175                 mysystem("/bin/setfont lat1-16");
 176         else if (strcmp(shortlangname, "bz") == 0)
 177                 mysystem("/bin/setfont lat1-16");
 178         else if (strcmp(shortlangname, "cs") == 0)
 179                 mysystem("/bin/setfont lat2-16");
 180         else if (strcmp(shortlangname, "hu") == 0)
 181                 mysystem("/bin/setfont lat2-16");
 182         else if (strcmp(shortlangname, "pl") == 0)
 183                 mysystem("/bin/setfont lat2-16");
 184         else if (strcmp(shortlangname, "tr") == 0)
 185                 mysystem("/bin/setfont lat5-16");
 186         else if (strcmp(shortlangname, "vi") == 0)
 187                 mysystem("/bin/setfont viscii10-8x16");
 188         else
 189                 mysystem("/bin/setfont lat0-16");
 190
 191         newtDrawRootText(14, 0, NAME " v" VERSION " - " SLOGAN );
 192         newtPushHelpLine(ctr[TR_HELPLINE]);
 193
 194         sprintf(message, ctr[TR_WELCOME], NAME);
 195         sprintf (title, "%s v%s - %s", NAME, VERSION, SLOGAN);
 196         newtWinMessage(title, ctr[TR_OK], message);
 197
 198         sprintf(message, ctr[TR_SELECT_INSTALLATION_MEDIA_LONG], NAME);
 199         rc = newtWinMenu(ctr[TR_SELECT_INSTALLATION_MEDIA], message,
 200                 50, 5, 5, 6, installtypes, &installtype, ctr[TR_OK],
 201                 ctr[TR_CANCEL], NULL);
 202
 203         if (rc == 2)
 204                 goto EXIT;
 205
 206         if (installtype == CDROM_INSTALL)
 207         {
 208                 /* First look for an IDE CDROM. */
 209                 if (!(cdletter = findidetype(IDE_CDROM)))
 210                 {
 211                         /* If we have a USB attached CDROM then it will
 212                          * have already appeared at /dev/scd0, so we
 213                          * try to access it first, before asking for the
 214                          * SCSI drivers disk.
 215                          */
 216                         if (!(try_scsi("scd0"))) {
 217                                 sprintf(insertmessage, ctr[TR_INSERT_FLOPPY], NAME" SCSI");
 218                                 rc = newtWinChoice(title, ctr[TR_OK], ctr[TR_CANCEL], insertmessage);
 219                                 if (rc != 1)
 220                                 {
 221                                         errorbox(ctr[TR_INSTALLATION_CANCELED]);
 222                                         goto EXIT;
 223                                 }
 224
 225                                 if (runcommandwithstatus("/bin/tar -C / -xvzf /dev/floppy", ctr[TR_EXTRACTING_MODULES]))
 226                                 {
 227                                         errorbox(ctr[TR_UNABLE_TO_EXTRACT_MODULES]);
 228                                         goto EXIT;
 229                                 }
 230
 231                                 if (pcmcia)
 232                                 {
 233                                         /* trying to support SCSI pcmcia :-) */
 234                                         runcommandwithstatus("cardmgr -o -c /etc/pcmcia/scsi",
 235                                                 ctr[TR_LOADING_PCMCIA]);
 236                                         if (try_scsi("scd0"))
 237                                                 pcmcia_cdrom = 1;
 238                                 }
 239
 240                                 /* try loading all SCSI modules with default options */
 241                                 /* Should expand this to allow options later though */
 242                                 if (!pcmcia_cdrom)
 243                                     runcommandwithstatus("/bin/probescsi.sh",
 244                                         ctr[TR_PROBING_SCSI]);
 245
 246                                 /* If it fails, give up. */
 247                                 if (!(try_scsi("scd0"))) {
 248                                         errorbox(ctr[TR_NO_CDROM]);
 249                                         goto EXIT;
 250                                 }
 251                         }
 252
 253                         sprintf(cdromdrive, "scd0");
 254                         scsi_cdrom = 1;
 255                 } else {
 256                         sprintf(cdromdrive, "hd%c", cdletter);
 257                         ide_cdrom = 1;
 258                 }
 259
 260                 snprintf(cdromparams.devnode, STRING_SIZE, "/dev/%s", cdromdrive);
 261                 cdromparams.module = 0;
 262
 263                 sprintf(insertmessage, ctr[TR_INSERT_CDROM], NAME);
 264                 strcpy (insertdevnode, cdromparams.devnode);
 265         }
 266         else
 267         {
 268                 /* If we've done a PXE boot, we can skip the Drivers floppy,
 269                  * as we've already got the modules in our instroot.gz */
 270                 if (!(handle = fopen("/CDROMBOOT", "r"))) {
 271                         sprintf(insertmessage, ctr[TR_INSERT_FLOPPY], NAME);
 272                         strcpy (insertdevnode , "/dev/floppy");
 273                 } else {
 274                         fclose(handle);
 275                         cdmounted = 1;
 276                         unmount_before = 1;
 277                 }
 278         }
 279
 280         if (scsi_cdrom || ide_cdrom) {
 281                 /* Try to mount /cdrom in a loop. */
 282                 snprintf(commandstring, STRING_SIZE, "/bin/mount -o ro %s /cdrom", insertdevnode);
 283                 while (!cdmounted)
 284                 {
 285                         rc = newtWinChoice(title, ctr[TR_OK], ctr[TR_CANCEL], insertmessage);
 286                         if (rc != 1)
 287                         {
 288                                 errorbox(ctr[TR_INSTALLATION_CANCELED]);
 289                                 goto EXIT;
 290                         }
 291                         if (!(mysystem(commandstring))) {
 292                                 handle = fopen ("/cdrom/" SNAME "-" VERSION ".tgz", "r");
 293                                 if (handle != NULL) {
 294                                         fclose (handle);
 295                                         cdmounted = 1;
 296                                         /* If we've booted from CDROM, then
 297                                          * we've already got the drivers,
 298                                          * so we can skip this unpack. */
 299                                         if (!(handle = fopen("/CDROMBOOT", "r"))) {
 300                                                 sprintf(string, "/bin/tar -C / -xvzf /cdrom/images/drivers-%s.img", VERSION);
 301                                                 if (runcommandwithprogress(60, 4, title,
 302                                                         string,
 303                                                         175, ctr[TR_EXTRACTING_MODULES]))
 304                                                 {
 305                                                         errorbox(ctr[TR_UNABLE_TO_EXTRACT_MODULES]);
 306
 307                                                         goto EXIT;
 308                                                 }
 309                                         } else
 310                                                 fclose(handle);
 311                                 } else {
 312                                         mysystem ("/bin/umount /cdrom");
 313                                 }
 314                         }
 315                 }
 316         } else {
 317                 snprintf(commandstring, STRING_SIZE, "/bin/tar -C / -xvzf /dev/floppy");
 318                 while (!cdmounted)
 319                 {
 320                         rc = newtWinChoice(title, ctr[TR_OK], ctr[TR_CANCEL], insertmessage);
 321                         if (rc != 1)
 322                         {
 323                                 errorbox(ctr[TR_INSTALLATION_CANCELED]);
 324                                 goto EXIT;
 325                         }
 326                         if (runcommandwithprogress(60, 4, title,
 327                                 commandstring,
 328                                 175, ctr[TR_EXTRACTING_MODULES]))
 329                         {
 330 #if 0 /* disable this, so we allow for people putting in the wrong disk */
 331                                 errorbox(ctr[TR_UNABLE_TO_EXTRACT_MODULES]);
 332                                 goto EXIT;
 333 #endif
 334                         }
 335                         else
 336                         {
 337                                 handle = fopen ("/bin/mke2fs", "r");
 338                                 if (handle != NULL) {
 339                                         fclose (handle);
 340                                         cdmounted = 1;
 341                                 }
 342                         }
 343                 }
 344         }
 345
 346         /* PCMCIA controller is already detected
 347          * On Boot floppy, we didn't have the PCMCIA drivers
 348          * so load them now because they are installed from Drivers. */
 349         if (!(handle = fopen("/CDROMBOOT", "r"))) {
 350                 if (strstr (line, "nopcmcia") == NULL) {
 351                         fprintf(flog,"Floppy boot detected, loading PCMCIA drivers.\n");
 352                         if (pcmcia) {
 353                                 fprintf (flog, "Detected PCMCIA Controller: %s.\n", pcmcia);
 354                                 sprintf(commandstring, "/sbin/modprobe %s", pcmcia);
 355                                 mysystem("/sbin/modprobe pcmcia_core");
 356                                 mysystem(commandstring);
 357                                 mysystem("/sbin/modprobe ds");
 358                         } else {
 359                                 fprintf (flog, "Detected No PCMCIA Controller.\n");
 360                         }
 361                 } else {
 362                         fprintf(flog, "Skipping PCMCIA detection.\n");
 363                 }
 364                 if (strstr (line, "nousb") == NULL) {
 365                         fprintf(flog, "Initializing USB controllers.\n");
 366                         initialize_usb();
 367                 } else {
 368                         fprintf(flog, "Skipping USB detection.\n");
 369                 }
 370         } else
 371                 fclose(handle);
 372
 373         /* Configure the network now! */
 374         if (installtype == URL_INSTALL)
 375         {
 376                 /* Network driver and params. */
 377                 if (!(networkmenu(ethernetkv)))
 378                 {
 379                         errorbox(ctr[TR_NETWORK_SETUP_FAILED]);
 380                         goto EXIT;
 381                 }
 382
 383                 /* Check for ipcop-<VERSION>.tgz */
 384                 if (!(checktarball(SNAME "-" VERSION ".tgz")))
 385                 {
 386                         errorbox(ctr[TR_NO_IPCOP_TARBALL_FOUND]);
 387                         goto EXIT;
 388                 }
 389         }
 390
 391         /* Get device for the HD.  This has to succeed. */
 392         if (!(hdletter = findidetype(IDE_HD)))
 393         {
 394                 if (installtype == URL_INSTALL)
 395                 {
 396                         /* If we've done a PXE boot, we can skip the SCSI
 397                          * floppy as we've already got the modules in our
 398                          * instroot.gz */
 399                         if (!(handle = fopen("/CDROMBOOT", "r")))
 400                         {
 401                                 /* search img where it is on a mounted loop iso */
 402                                 sprintf(string, "images/scsidrv-%s.img", VERSION);
 403                                 if (!(checktarball(string)))
 404                                 {
 405                                         /* Couldn't find the SCSI drivers on the URL page,
 406                                          * so after 3 failed attempts, ask the user for the
 407                                          * SCSI drivers floppy disk. */
 408                                         errorbox(ctr[TR_NO_SCSI_IMAGE_FOUND]);
 409                                         sprintf(insertmessage, ctr[TR_INSERT_FLOPPY], NAME" SCSI");
 410                                         rc = newtWinChoice(title, ctr[TR_OK], ctr[TR_CANCEL], insertmessage);
 411                                         if (rc != 1)
 412                                         {
 413                                                 errorbox(ctr[TR_INSTALLATION_CANCELED]);
 414                                                 goto EXIT;
 415                                         }
 416
 417                                         if (runcommandwithstatus("/bin/tar -C / -xvzf /dev/floppy", ctr[TR_EXTRACTING_MODULES]))
 418                                         {
 419                                                 errorbox(ctr[TR_UNABLE_TO_EXTRACT_MODULES]);
 420                                                 goto EXIT;
 421                                         }
 422                                 } else {
 423                                         /* unpack... */
 424                                         snprintf(commandstring, STRING_SIZE,
 425                                                 "/bin/wget -O - %s/%s | /bin/tar -C / -xvzf -",
 426                                                 url, string);
 427                                         if (runcommandwithprogress(60, 4, title, commandstring,
 428                                                 4500, ctr[TR_INSTALLING_FILES]))
 429                                         {
 430                                                 errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
 431                                                 goto EXIT;
 432                                         }
 433                                 }
 434                         } else
 435                                 fclose(handle);
 436                 } else {
 437                         if (ide_cdrom) {
 438                                 sprintf(string, "/bin/tar -C / -xvzf /cdrom/images/scsidrv-%s.img", VERSION);
 439                                 if (runcommandwithstatus(string, ctr[TR_EXTRACTING_MODULES]))
 440                                 {
 441                                         errorbox(ctr[TR_UNABLE_TO_EXTRACT_MODULES]);
 442                                         goto EXIT;
 443                                 }
 444                         }
 445                 }
 446
 447                 if (!scsi_cdrom) {
 448
 449 #if 0 /* not yet */
 450                         if (pcmcia)
 451                         {
 452                                 /* trying to support SCSI pcmcia :-) */
 453                                 runcommandwithstatus("cardmgr -o -c /etc/pcmcia/scsi",
 454                                         ctr[TR_LOADING_PCMCIA]);
 455                                 if (try_scsi("sda"))
 456                                         pcmcia_disk = 1;
 457                         }
 458 #endif
 459
 460                         /* try loading all SCSI modules with default options */
 461                         /* Should expand this to allow options later though */
 462                         if (!pcmcia_disk)
 463                                 runcommandwithstatus("/bin/probescsi.sh",
 464                                         ctr[TR_PROBING_SCSI]);
 465                 }
 466
 467                 /* Need to clean this up at some point */
 468                 if (!try_scsi("sda")) {
 469                         if (!try_scsi("ida/c0d0")) {
 470                                 if (!try_scsi("cciss/c0d0")) {
 471                                         if (!try_scsi("rd/c0d0")) {
 472                                                 if (!try_scsi("ataraid/d0")) {
 473                                                         errorbox(ctr[TR_NO_HARDDISK]);
 474                                                         goto EXIT;
 475                                                 } else {
 476                                                         raid_disk = 1;
 477                                                         sprintf(harddrive, "ataraid/d0");
 478                                                 }
 479                                         } else {
 480                                                 raid_disk = 1;
 481                                                 sprintf(harddrive, "rd/c0d0");
 482                                         }
 483                                 } else {
 484                                         raid_disk = 1;
 485                                         sprintf(harddrive, "cciss/c0d0");
 486                                 }
 487                         } else {
 488                                 raid_disk = 1;
 489                                 sprintf(harddrive, "ida/c0d0");
 490                         }
 491                 } else {
 492                         sprintf(harddrive, "sda");
 493                 }
 494                 scsi_disk = 1;
 495         } else
 496                 sprintf(harddrive, "hd%c", hdletter);
 497
 498         /* Make the hdparms struct and print the contents. */
 499         snprintf(hdparams.devnode, STRING_SIZE, "/dev/%s", harddrive);
 500         hdparams.module = 0;
 501
 502         rc = newtWinChoice(title, ctr[TR_OK], ctr[TR_CANCEL],
 503                 ctr[TR_PREPARE_HARDDISK], hdparams.devnode);
 504         if (rc != 1)
 505                 goto EXIT;
 506
 507         /* Calculate amount of memory in machine */
 508         if ((handle = fopen("/proc/meminfo", "r")))
 509         {
 510             while (fgets(line, STRING_SIZE-1, handle)) {
 511                 if (sscanf (line, "MemTotal: %s kB", string)) {
 512                     memory = atoi(string) / 1024 ;
 513                 }
 514             }
 515             fclose(handle);
 516         }
 517
 518         /* Partition, mkswp, mkfs.
 519          * before partitioning, first determine the sizes of each
 520          * partition.  In order to do that we need to know the size of
 521          * the disk.
 522          */
 523         /* Don't use mysystem here so we can redirect output */
 524         sprintf(commandstring, "/bin/sfdisk -s /dev/%s > /disksize 2> /dev/null", harddrive);
 525         system(commandstring);
 526
 527         /* Calculate amount of disk space */
 528         if ((handle = fopen("/disksize", "r")))
 529         {
 530                 fgets(line, STRING_SIZE-1, handle);
 531                 if (sscanf (line, "%s", string)) {
 532                         maximum_free = atoi(string) / 1024;
 533                 }
 534                 fclose(handle);
 535         }
 536
 537         fprintf(flog, "maximum_free = %d, memory = %d",
 538                 maximum_free, memory);
 539
 540         /* If you need more than this, you should really add physical memory */
 541         /* Minimum: 192 = 64 real + 128 swap */
 542         swap_file = memory < 64 ? 2 * memory : 192 - memory ;
 543         swap_file = swap_file < 32 ? 32 : swap_file ;
 544
 545         if (maximum_free < 135 + swap_file )
 546         {
 547                 if (maximum_free < 135) {
 548                         errorbox(ctr[TR_DISK_TOO_SMALL]);
 549                         goto EXIT;
 550                 }
 551
 552                 rc = newtWinChoice(title, ctr[TR_OK], ctr[TR_CANCEL], ctr[TR_CONTINUE_NO_SWAP]);
 553                 if (rc != 1)
 554                         goto EXIT;
 555                 swap_file = 0;
 556         }
 557
 558         boot_partition = 8; /* in MB */
 559         current_free = maximum_free - boot_partition - swap_file;
 560
 561         /* Give more place for add-on, extend root to 25% of current_free, upper limit to 8 gigas */
 562         root_partition = current_free / 4 ;
 563         root_partition = root_partition > 8192 ? 8192 : root_partition ;
 564         root_partition = current_free < 860 ? 235 : root_partition;
 565         root_partition = current_free < 380 ? 110 : root_partition;
 566
 567         current_free = current_free - root_partition;
 568         root_partition = root_partition + swap_file;
 569
 570         log_partition = current_free;
 571
 572         fprintf(flog, "boot = %d, swap = %d, mylog = %d, root = %d\n",
 573                 boot_partition, swap_file, log_partition, root_partition);
 574
 575
 576 #ifdef __alpha__
 577         fdisk = 1;
 578 #endif
 579
 580         if (fdisk) {
 581                 rc = newtWinChoice(title, ctr[TR_OK], ctr[TR_CANCEL], "NOW FDISK");
 582                 if (rc != 1)
 583                         goto EXIT;
 584         } else {
 585 #ifdef __i386__
 586                 handle = fopen("/tmp/partitiontable", "w");
 587
 588                 fprintf(handle, ",%d,83,*\n,%d,83,\n,0,0,\n,,83,\n",
 589                         boot_partition, log_partition);
 590
 591                 fclose(handle);
 592
 593                 snprintf(commandstring, STRING_SIZE, "/bin/sfdisk -uM %s < /tmp/partitiontable", hdparams.devnode);
 594                 if (runcommandwithstatus(commandstring, ctr[TR_PARTITIONING_DISK]))
 595                 {
 596                         errorbox(ctr[TR_UNABLE_TO_PARTITION]);
 597                         goto EXIT;
 598                 }
 599 #endif
 600         }
 601
 602         if (raid_disk)
 603                 snprintf(commandstring, STRING_SIZE, "/bin/mke2fs -m 0 -j %sp1", hdparams.devnode);
 604         else
 605                 snprintf(commandstring, STRING_SIZE, "/bin/mke2fs -m 0 -j %s1", hdparams.devnode);
 606         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_BOOT_FILESYSTEM]))
 607         {
 608                 errorbox(ctr[TR_UNABLE_TO_MAKE_BOOT_FILESYSTEM]);
 609                 goto EXIT;
 610         }
 611         if (raid_disk)
 612                 snprintf(commandstring, STRING_SIZE, "/bin/mke2fs -j %sp2", hdparams.devnode);
 613         else
 614                 snprintf(commandstring, STRING_SIZE, "/bin/mke2fs -j %s2", hdparams.devnode);
 615         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_LOG_FILESYSTEM]))
 616         {
 617                 errorbox(ctr[TR_UNABLE_TO_MAKE_LOG_FILESYSTEM]);
 618                 goto EXIT;
 619         }
 620         if (raid_disk)
 621                 snprintf(commandstring, STRING_SIZE, "/bin/mke2fs -m 1 -j %sp4", hdparams.devnode);
 622         else
 623                 snprintf(commandstring, STRING_SIZE, "/bin/mke2fs -m 1 -j %s4", hdparams.devnode);
 624
 625         if (runcommandwithstatus(commandstring, ctr[TR_MAKING_ROOT_FILESYSTEM]))
 626         {
 627                 errorbox(ctr[TR_UNABLE_TO_MAKE_ROOT_FILESYSTEM]);
 628                 goto EXIT;
 629         }
 630         /* Mount harddisk. */
 631         if (raid_disk)
 632                 snprintf(commandstring, STRING_SIZE, "/sbin/mount -t ext2 %sp4 /harddisk", hdparams.devnode);
 633         else
 634                 snprintf(commandstring, STRING_SIZE, "/sbin/mount -t ext2 %s4 /harddisk", hdparams.devnode);
 635         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_ROOT_FILESYSTEM]))
 636         {
 637                 errorbox(ctr[TR_UNABLE_TO_MOUNT_ROOT_FILESYSTEM]);
 638                 goto EXIT;
 639         }
 640         /* Make swapfile */
 641         if (swap_file) {
 642                 snprintf(commandstring, STRING_SIZE, "/bin/dd if=/dev/zero of=/harddisk/swapfile bs=1024k count=%d", swap_file);
 643                 if (runcommandwithstatus(commandstring, ctr[TR_MAKING_SWAPSPACE]))
 644                 {
 645                         errorbox(ctr[TR_UNABLE_TO_MAKE_SWAPSPACE]);
 646                         goto EXIT;
 647                 }
 648                 snprintf(commandstring, STRING_SIZE, "/bin/mkswap /harddisk/swapfile");
 649                 if (runcommandwithstatus(commandstring, ctr[TR_MAKING_SWAPSPACE]))
 650                 {
 651                         errorbox(ctr[TR_UNABLE_TO_MAKE_SWAPSPACE]);
 652                         goto EXIT;
 653                 }
 654         }
 655         mkdir("/harddisk/boot", S_IRWXU|S_IRWXG|S_IRWXO);
 656         mkdir("/harddisk/var", S_IRWXU|S_IRWXG|S_IRWXO);
 657         mkdir("/harddisk/var/log", S_IRWXU|S_IRWXG|S_IRWXO);
 658
 659         if (raid_disk)
 660                 snprintf(commandstring, STRING_SIZE, "/sbin/mount -t ext2 %sp1 /harddisk/boot", hdparams.devnode);
 661         else
 662                 snprintf(commandstring, STRING_SIZE, "/sbin/mount -t ext2 %s1 /harddisk/boot", hdparams.devnode);
 663
 664         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_BOOT_FILESYSTEM]))
 665         {
 666                 errorbox(ctr[TR_UNABLE_TO_MOUNT_BOOT_FILESYSTEM]);
 667                 goto EXIT;
 668         }
 669         if (swap_file) {
 670                 snprintf(commandstring, STRING_SIZE, "/bin/swapon /harddisk/swapfile");
 671                 if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_SWAP_PARTITION]))
 672                 {
 673                         errorbox(ctr[TR_UNABLE_TO_MOUNT_SWAP_PARTITION]);
 674                         goto EXIT;
 675                 }
 676         }
 677         if (raid_disk)
 678                 snprintf(commandstring, STRING_SIZE, "/sbin/mount -t ext2 %sp2 /harddisk/var/log", hdparams.devnode);
 679         else
 680                 snprintf(commandstring, STRING_SIZE, "/sbin/mount -t ext2 %s2 /harddisk/var/log", hdparams.devnode);
 681         if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_LOG_FILESYSTEM]))
 682         {
 683                 errorbox(ctr[TR_UNABLE_TO_MOUNT_LOG_FILESYSTEM]);
 684                 goto EXIT;
 685         }
 686
 687         /* Either use tarball from cdrom or download. */
 688         if (installtype == CDROM_INSTALL)
 689                 snprintf(commandstring, STRING_SIZE,
 690                         "/bin/tar -C /harddisk -xvzf /cdrom/" SNAME "-" VERSION ".tgz");
 691         else
 692                 snprintf(commandstring, STRING_SIZE,
 693                         "/bin/wget -O - %s/" SNAME "-" VERSION ".tgz | /bin/tar -C /harddisk -xvzf -", url);
 694
 695         if (runcommandwithprogress(60, 4, title, commandstring, 4600,
 696                 ctr[TR_INSTALLING_FILES]))
 697         {
 698                 errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
 699                 goto EXIT;
 700         }
 701
 702         /* Save USB controller type to modules.conf */
 703         write_usb_modules_conf();
 704
 705         /* touch the modules.dep files */
 706         snprintf(commandstring, STRING_SIZE,
 707                 "/bin/chroot /harddisk /bin/touch /lib/modules/%s/modules.dep",
 708                 KERNEL_VERSION);
 709         mysystem(commandstring);
 710 #ifdef __i386__
 711         snprintf(commandstring, STRING_SIZE,
 712                 "/bin/chroot /harddisk /bin/touch /lib/modules/%s-smp/modules.dep",
 713                 KERNEL_VERSION);
 714         mysystem(commandstring);
 715 #endif
 716
 717         /* Rename uname */
 718         rename ("/harddisk/bin/uname.bak", "/harddisk/bin/uname");
 719
 720         /* Write PCMCIA Config */
 721         if (pcmcia) {
 722                 handle = fopen("/harddisk/etc/modules.conf", "a");
 723                 if (handle != NULL) {
 724                         fprintf (handle, "# PCMCIA Settings\n");
 725                         fprintf (handle, "alias pcmcia-controller %s\n", pcmcia);
 726                         fclose(handle);
 727                 }
 728         }
 729
 730         handle = fopen("/harddisk/etc/pcmcia.conf", "w");
 731         if (handle != NULL) {
 732                 if (pcmcia) {
 733                         fprintf (handle, "PCMCIA=yes\n");
 734                         fprintf (handle, "PCIC=%s\n", pcmcia);
 735                 } else {
 736                         fprintf (handle, "PCMCIA=no\n");
 737                         fprintf (handle, "PCIC=\n");
 738                 }
 739                 fprintf (handle, "CARDMGR_OPTS=\n");
 740                 fprintf (handle, "SCHEME=\n");
 741                 fclose(handle);
 742         }
 743
 744         /* *always* write disk configuration */
 745         if (!(write_disk_configs(&hdparams))){
 746           errorbox(ctr[TR_ERROR_WRITING_CONFIG]);
 747           goto EXIT;
 748         }
 749
 750         /*
 751           Allow the user to restore their configuration from a floppy.
 752           It uses tar.  If the tar fails for any reason, show user an
 753           error and go back to the restore/skip question. This gives
 754           the user the chance to have another go. */
 755
 756 RESTORE:
 757         /* set status variables to nonsense values */
 758         allok_fastexit = 0;
 759         /* loop until floppy succeeds or user skips out */
 760         while (1)
 761         {
 762           sprintf(message, ctr[TR_RESTORE_CONFIGURATION], NAME);
 763           if (newtWinChoice(title, ctr[TR_RESTORE], ctr[TR_SKIP], message) == 1)
 764           {
 765             /* Temporarily mount /proc under /harddisk/proc,
 766              * run updfstab to locate the floppy, and unmount /harddisk/proc
 767              * again.  This should be run each time the user tries to restore
 768              * so it can properly detect removable devices */
 769             if (mysystem("/bin/mount -n -t proc /proc /harddisk/proc")) {
 770               errorbox(ctr[TR_UNABLE_TO_MOUNT_PROC_FILESYSTEM]);
 771               goto EXIT;
 772             }
 773             if (mysystem("/bin/chroot /harddisk /usr/sbin/updfstab")) {
 774               errorbox(ctr[TR_UNABLE_TO_WRITE_ETC_FSTAB]);
 775               goto EXIT;
 776             }
 777             mysystem("/bin/umount /harddisk/proc");
 778
 779             mkdir("/harddisk/tmp/ipcop", S_IRWXU|S_IRWXG|S_IRWXO);
 780
 781             /* Always extract to /tmp/ipcop for temporary extraction
 782              * just in case floppy fails */
 783
 784             /* try a compressed backup first because it's quicker to fail.
 785              * In exclude.system, files name must be without leading / or
 786              * on extraction, name will never match */
 787             snprintf(commandstring, STRING_SIZE,
 788                      "/bin/chroot /harddisk /bin/tar -X " CONFIG_ROOT "/backup/exclude.system -C /tmp/ipcop -xvzf /dev/floppy > %s 2> /dev/null", mylog);
 789
 790             statuswindow(45, 4, title, ctr[TR_INSTALLING_FILES]);
 791             rc = system(commandstring);
 792
 793             if (rc) {
 794               /* if it's not compressed, try uncompressed first before failing*/
 795               snprintf(commandstring, STRING_SIZE,
 796                      "/bin/chroot /harddisk /bin/tar -X " CONFIG_ROOT "/backup/exclude.system -C /tmp/ipcop -xvf /dev/floppy > %s 2> /dev/null", mylog);
 797               rc = system(commandstring);
 798               if (rc) {
 799                 newtPopWindow();
 800                 /* command failed trying to read from floppy */
 801                 errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
 802
 803                 /* remove badly restored files */
 804                 mysystem("/bin/chroot /harddisk /bin/rm -rf /tmp/ipcop");
 805                 goto RESTORE;
 806               } else {
 807                 /* Now copy to correct location */
 808                 mysystem("/bin/chroot /harddisk /bin/cp -af /tmp/ipcop/. /");
 809                 mysystem("/bin/chroot /harddisk /bin/rm -rf /tmp/ipcop");
 810                 newtPopWindow();
 811                 allok_fastexit=1;
 812
 813                 /* Upgrade necessary files from v1.2 to v1.3 to v1.4 */
 814                 upgrade_v12_v13();
 815                 upgrade_v130_v140();
 816                 break; /* out of loop at this point because floppy has
 817                         successfully restored */
 818               }
 819             }
 820             else { /* success */
 821               /* Now copy to correct location */
 822               mysystem("/bin/chroot /harddisk /bin/cp -af /tmp/ipcop/. /");
 823               mysystem("/bin/chroot /harddisk /bin/rm -rf /tmp/ipcop");
 824               newtPopWindow();
 825               allok_fastexit=1;
 826
 827               /* Upgrade necessary files from v1.2 to v1.3 to v1.4 */
 828               upgrade_v12_v13();
 829               upgrade_v130_v140();
 830               break; /* out of loop at this point because floppy has
 831                         successfully restored */
 832             }
 833           }
 834           else{  /* user chose to skip install from floppy */
 835             if (installtype == CDROM_INSTALL){
 836               /* if we installed from CD ROM then we didn't set up the
 837                  network interface yet.  Therefore, set up Network
 838                  driver and params just before we need them. */
 839
 840               if (!(networkmenu(ethernetkv))){
 841                 /* network setup failed, tell the world */
 842                 errorbox(ctr[TR_NETWORK_SETUP_FAILED]);
 843                 goto EXIT;
 844               }
 845             }
 846             break; /* out of loop because we succeeded with ethernet
 847                       set up and user is notrestarting from floppy*/
 848           }
 849         }
 850
 851         /* Check the SQUID acl file exists, if not use our 1.4 copy */
 852         {
 853                 FILE *aclreadfile;
 854
 855                 if (!(aclreadfile = fopen ("/harddisk" CONFIG_ROOT "/proxy/acl", "r"))) {
 856                         rename ("/harddisk" CONFIG_ROOT "/proxy/acl-1.4",
 857                                 "/harddisk" CONFIG_ROOT "/proxy/acl");
 858                 } else {
 859                         unlink ("/harddisk" CONFIG_ROOT "/proxy/acl-1.4");
 860                         fclose(aclreadfile);
 861                 }
 862                 chown  ("/harddisk" CONFIG_ROOT "/proxy/acl", 99, 99);
 863         }
 864
 865         /* Build cache lang file */
 866         mysystem("/bin/chroot /harddisk /usr/bin/perl -e \"require '" CONFIG_ROOT "/lang.pl'; &Lang::BuildCacheLang\"");
 867
 868         if (!allok_fastexit){
 869           /* write ethernet and lang configs only if they have not
 870              been restored from floppy already. */
 871           if (!(write_ethernet_configs( ethernetkv))||
 872               !(write_lang_configs(shortlangname))){
 873             errorbox(ctr[TR_ERROR_WRITING_CONFIG]);
 874             goto EXIT;
 875           }
 876         }
 877
 878         /* if we detected SCSI then fixup */
 879         if ((handle = fopen("/scsidriver", "r")))
 880         {
 881                 char *driver;
 882                 fgets(line, STRING_SIZE-1, handle);
 883                 fclose(handle);
 884                 line[strlen(line) - 1] = 0;
 885                 driver = strtok(line, ".");
 886                 fprintf(flog, "Detected SCSI driver %s\n",driver);
 887                 if (strlen(driver) > 1) {
 888                         fprintf(flog, "Fixing up ipcoprd.img\n");
 889                         mysystem("/bin/chroot /harddisk /sbin/modprobe loop");
 890                         mkdir("/harddisk/initrd", S_IRWXU|S_IRWXG|S_IRWXO);
 891                         snprintf(commandstring, STRING_SIZE, "/bin/chroot /harddisk /sbin/mkinitrd --with=scsi_mod --with=%s --with=sd_mod --with=sr_mod --with=libata --with=ataraid /boot/ipcoprd.img %s", driver, KERNEL_VERSION);
 892                         runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
 893 #ifdef __i386__
 894                         snprintf(commandstring, STRING_SIZE, "/bin/chroot /harddisk /sbin/mkinitrd --with=scsi_mod --with=%s --with=sd_mod --with=sr_mod --with=libata --with=ataraid /boot/ipcoprd-smp.img %s-smp", driver, KERNEL_VERSION);
 895                         runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
 896                         mysystem("/bin/chroot /harddisk /bin/mv /boot/grub/scsigrub.conf /boot/grub/grub.conf");
 897 #endif
 898 #ifdef __alpha__
 899                         snprintf(commandstring, STRING_SIZE, "/bin/chroot /harddisk /bin/mv /boot/etc/scsiaboot.conf /boot/etc/aboot.conf");
 900                         runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
 901 #endif
 902                 }
 903         }
 904
 905 #if 0 /* not yet */
 906         if (pcmcia_disk)
 907         {
 908                 fprintf(flog, "Detected SCSI driver PCMCIA\n");
 909                 fprintf(flog, "Fixing up ipcoprd.img\n");
 910                 mysystem("/bin/chroot /harddisk /sbin/modprobe loop");
 911                 mkdir("/harddisk/initrd", S_IRWXU|S_IRWXG|S_IRWXO);
 912                 snprintf(commandstring, STRING_SIZE, "/bin/chroot /harddisk /sbin/pcinitrd -r %s /boot/ipcoprd.img", KERNEL_VERSION);
 913                 mysystem(commandstring);
 914 #ifdef __i386__
 915                 mysystem("/bin/chroot /harddisk /bin/mv /boot/grub/scsigrub.conf /boot/grub/grub.conf");
 916 #endif
 917 #ifdef __alpha__
 918                 mysystem("/bin/chroot /harddisk /bin/mv /boot/etc/scsiaboot.conf /boot/etc/aboot.conf");
 919 #endif
 920         }
 921 #endif
 922
 923 #ifdef __i386__
 924         replace( "/harddisk/boot/grub/grubbatch", "DEVICE", hdparams.devnode);
 925         /* restore permissions */
 926         chmod("/harddisk/boot/grub/grubbatch", S_IXUSR | S_IRUSR | S_IXGRP | S_IRGRP | S_IXOTH | S_IROTH);
 927
 928         if (raid_disk)
 929                 sprintf(string, "root=%sp4", hdparams.devnode);
 930         else
 931                 sprintf(string, "root=%s4", hdparams.devnode);
 932         replace( "/harddisk/boot/grub/grub.conf", "root=ROOT", string);
 933
 934         mysystem("/bin/chroot /harddisk /bin/mount -n -t proc none /proc");
 935
 936         snprintf(commandstring, STRING_SIZE, "/bin/chroot /harddisk /boot/grub/grubbatch");
 937
 938         if (runcommandwithstatus(commandstring, ctr[TR_INSTALLING_GRUB]))
 939         {
 940                 errorbox(ctr[TR_UNABLE_TO_INSTALL_GRUB]);
 941                 goto EXIT;
 942         }
 943         mysystem("/bin/chroot /harddisk /bin/umount -n /proc");
 944 #endif
 945 #ifdef __alpha__
 946         snprintf(commandstring, STRING_SIZE, "/bin/chroot /harddisk /sbin/swriteboot -f3 %s /boot/bootlx", hdparams.devnode);
 947         mysystem(commandstring);
 948         snprintf(commandstring, STRING_SIZE, "/bin/chroot /harddisk /sbin/abootconf %s 1", hdparams.devnode);
 949         mysystem(commandstring);
 950         if (raid_disk)
 951                 sprintf(string, "root=%sp4", hdparams.devnode);
 952         else
 953                 sprintf(string, "root=%s4", hdparams.devnode);
 954         replace( "/harddisk/boot/etc/aboot.conf", "root=ROOT", string);
 955 #endif
 956
 957         /* unmounting happens everywhere because there are places
 958            which require device is to be unmounted under certain
 959            circumstances.  This is the last place we can unmount
 960            anything and still succeed. */
 961
 962         if (!unmount_before && installtype == CDROM_INSTALL){
 963           if (mysystem("/sbin/umount /cdrom"))
 964             {
 965               errorbox(ctr[TR_UNABLE_TO_UNMOUNT_CDROM]);
 966               goto EXIT;
 967             }
 968         }
 969
 970         if (installtype == CDROM_INSTALL)
 971         {
 972
 973                 if (!(ejectcdrom(cdromparams.devnode)))
 974                 {
 975                         errorbox(ctr[TR_UNABLE_TO_EJECT_CDROM]);
 976                         // goto EXIT;
 977                 }
 978         }
 979
 980
 981         sprintf(message, ctr[TR_CONGRATULATIONS_LONG],
 982                 NAME, SNAME, SNAME, NAME, NAME, NAME);
 983         newtWinMessage(ctr[TR_CONGRATULATIONS], ctr[TR_OK], message);
 984
 985         allok = 1;
 986
 987 EXIT:
 988         fprintf(flog, "Install program ended.\n");
 989         fflush(flog);
 990         fclose(flog);
 991
 992         if (!(allok))
 993                 newtWinMessage(title, ctr[TR_OK], ctr[TR_PRESS_OK_TO_REBOOT]);
 994
 995         newtFinished();
 996
 997         freekeyvalues(ethernetkv);
 998
 999         if (allok && !allok_fastexit)
1000         {
1001                 /* /proc is needed by the module checker.  We have to mount it
1002                  * so it can be seen by setup, which is run chrooted. */
1003                 if (system("/sbin/mount proc -t proc /harddisk/proc"))
1004                         printf("Unable to mount proc in /harddisk.");
1005                 else
1006                 {
1007                         if (system("/bin/chroot /harddisk /usr/local/sbin/setup /dev/tty2 INSTALL"))
1008                                 printf("Unable to run setup.\n");
1009                         if (system("/sbin/umount /harddisk/proc"))
1010                                 printf("Unable to umount /harddisk/proc.\n");
1011                 }
1012         }
1013
1014         fcloseall();
1015
1016         system("/bin/swapoff /harddisk/swapfile");
1017         system("/sbin/umount /harddisk/var/log");
1018         system("/sbin/umount /harddisk/boot");
1019         system("/sbin/umount /harddisk");
1020
1021         system("/etc/halt");
1022
1023         return 0;
1024 }