8b808031f66bbf1043584a11eaf490aa5edd42ef
[people/pmueller/ipfire-2.x.git] / src / install+setup / install / main.c
1 /* SmoothWall install program.
2 *
3 * This program is distributed under the terms of the GNU General Public
4 * Licence. See the file COPYING for details.
5 *
6 * (c) Lawrence Manning, 2001
7 * Contains main entry point, and misc functions.
8 *
9 */
10
11 #include "install.h"
12 #define _GNU_SOURCE
13
14 #define CDROM_INSTALL 0
15 #define URL_INSTALL 1
16 #define DISK_INSTALL 2
17 #define INST_FILECOUNT 5600
18 #define UNATTENDED_CONF "/cdrom/boot/unattended.conf"
19
20 int raid_disk = 0;
21 FILE *flog = NULL;
22 char *mylog;
23
24 char **ctr;
25
26 char *pcmcia = NULL;
27 extern char url[STRING_SIZE];
28
29 extern char *en_tr[];
30 extern char *de_tr[];
31
32 int detect_smp() {
33 FILE *fd = NULL;
34 char line[STRING_SIZE];
35 int cpu_count = 0;
36
37 if ((fd = fopen("/proc/cpuinfo", "r")) == NULL) {
38 return 0;
39 }
40 while (fgets(line, STRING_SIZE, fd) != NULL) {
41 if (strstr(line, "processor") == line) {
42 cpu_count++;
43 }
44 }
45 (void)fclose(fd);
46 return (cpu_count > 1);
47 }
48
49 int generate_packages_list(char *packages, const char *rpmdir, const char *source) {
50
51 FILE *fd=NULL;
52 char buffer[STRING_SIZE];
53 bzero(buffer, sizeof(buffer));
54
55 if ((fd = fopen(source, "r")) == NULL) {
56 (void) fprintf(flog, "Packages file %s not found\n", source);
57 return -1;
58 }
59 while (fgets(buffer, sizeof(buffer), fd) != NULL) {
60 int length = -1;
61 length = strlen(buffer)-1;
62 if (length<=0) {
63 continue;
64 }
65 if (buffer[length] == '\n') {
66 buffer[length]='\0';
67 }
68 length = snprintf(packages, STRING_SIZE, "%s %s/%s", strdup(packages), rpmdir, buffer);
69 if ((length <0) || (length >STRING_SIZE)) {
70 (void) fprintf(flog, "rpm command line too long: %d\n%s", length, packages);
71 return -1;
72 }
73 }
74 if (ferror(fd)) {
75 (void) fprintf(flog, "Error reading file\n");
76 (void) fclose(fd);
77 return -1;
78 }
79 (void) fclose(fd);
80 return 0;
81 }
82
83 long calc_swapsize(long memory, long disk) {
84 if (memory < 128) {
85 return 256;
86 }
87 if (memory > 1024) {
88 return 512;
89 }
90
91 return memory*2;
92 }
93
94 int unattended_setup(struct keyvalue *unattendedkv) {
95 struct keyvalue *mainsettings = initkeyvalues();
96 struct keyvalue *ethernetkv = initkeyvalues();
97 FILE *file, *hosts;
98 char commandstring[STRING_SIZE];
99
100 char domainname[STRING_SIZE];
101 char hostname[STRING_SIZE];
102 char keymap[STRING_SIZE];
103 char language[STRING_SIZE];
104 char timezone[STRING_SIZE];
105 char green_address[STRING_SIZE];
106 char green_netmask[STRING_SIZE];
107 char green_netaddress[STRING_SIZE];
108 char green_broadcast[STRING_SIZE];
109 char root_password[STRING_SIZE];
110 char admin_password[STRING_SIZE];
111
112 findkey(unattendedkv, "DOMAINNAME", domainname);
113 findkey(unattendedkv, "HOSTNAME", hostname);
114 findkey(unattendedkv, "KEYMAP", keymap);
115 findkey(unattendedkv, "LANGUAGE", language);
116 findkey(unattendedkv, "TIMEZONE", timezone);
117 findkey(unattendedkv, "GREEN_ADDRESS", green_address);
118 findkey(unattendedkv, "GREEN_NETMASK", green_netmask);
119 findkey(unattendedkv, "GREEN_NETADDRESS", green_netaddress);
120 findkey(unattendedkv, "GREEN_BROADCAST", green_broadcast);
121 findkey(unattendedkv, "ROOT_PASSWORD", root_password);
122 findkey(unattendedkv, "ADMIN_PASSWORD", admin_password);
123
124 /* write main/settings. */
125 replacekeyvalue(mainsettings, "DOMAINNAME", domainname);
126 replacekeyvalue(mainsettings, "HOSTNAME", hostname);
127 replacekeyvalue(mainsettings, "KEYMAP", keymap);
128 replacekeyvalue(mainsettings, "LANGUAGE", language);
129 replacekeyvalue(mainsettings, "TIMEZONE", timezone);
130 writekeyvalues(mainsettings, "/harddisk" CONFIG_ROOT "/main/settings");
131 freekeyvalues(mainsettings);
132
133 /* do setup stuff */
134 fprintf(flog, "unattended: Starting setup\n");
135
136 /* network */
137 fprintf(flog, "unattended: setting up network configuration\n");
138
139 (void) readkeyvalues(ethernetkv, "/harddisk" CONFIG_ROOT "/ethernet/settings");
140 replacekeyvalue(ethernetkv, "GREEN_ADDRESS", green_address);
141 replacekeyvalue(ethernetkv, "GREEN_NETMASK", green_netmask);
142 replacekeyvalue(ethernetkv, "GREEN_NETADDRESS", green_netaddress);
143 replacekeyvalue(ethernetkv, "GREEN_BROADCAST", green_broadcast);
144 replacekeyvalue(ethernetkv, "CONFIG_TYPE", "0");
145 replacekeyvalue(ethernetkv, "GREEN_DEV", "eth0");
146 write_ethernet_configs(ethernetkv);
147 freekeyvalues(ethernetkv);
148
149 /* timezone */
150 unlink("/harddisk/etc/localtime");
151 snprintf(commandstring, STRING_SIZE, "/harddisk/%s", timezone);
152 link(commandstring, "/harddisk/etc/localtime");
153
154 /* hostname */
155 fprintf(flog, "unattended: writing hostname.conf\n");
156 if (!(file = fopen("/harddisk" CONFIG_ROOT "/main/hostname.conf", "w")))
157 {
158 errorbox("unattended: ERROR writing hostname.conf");
159 return 0;
160 }
161 fprintf(file, "ServerName %s\n", hostname);
162 fclose(file);
163
164 fprintf(flog, "unattended: writing hosts\n");
165 if (!(hosts = fopen("/harddisk/etc/hosts", "w")))
166 {
167 errorbox("unattended: ERROR writing hosts");
168 return 0;
169 }
170 fprintf(hosts, "127.0.0.1\tlocalhost\n");
171 fprintf(hosts, "%s\t%s.%s\t%s\n", green_address, hostname, domainname, hostname);
172 fclose(hosts);
173
174 fprintf(flog, "unattended: writing hosts.allow\n");
175 if (!(file = fopen("/harddisk/etc/hosts.allow", "w")))
176 {
177 errorbox("unattended: ERROR writing hosts.allow");
178 return 0;
179 }
180 fprintf(file, "sshd : ALL\n");
181 fprintf(file, "ALL : localhost\n");
182 fprintf(file, "ALL : %s/%s\n", green_netaddress, green_netmask);
183 fclose(file);
184
185 fprintf(flog, "unattended: writing hosts.deny\n");
186 if (!(file = fopen("/harddisk/etc/hosts.deny", "w")))
187 {
188 errorbox("unattended: ERROR writing hosts.deny");
189 return 0;
190 }
191 fprintf(file, "ALL : ALL\n");
192 fclose(file);
193
194 /* set root password */
195 fprintf(flog, "unattended: setting root password\n");
196 snprintf(commandstring, STRING_SIZE,
197 "/sbin/chroot /harddisk /bin/sh -c \"echo 'root:%s' | /usr/sbin/chpasswd\"", root_password);
198 if (mysystem(commandstring)) {
199 errorbox("unattended: ERROR setting root password");
200 return 0;
201 }
202
203 /* set admin password */
204 fprintf(flog, "unattended: setting admin password\n");
205 snprintf(commandstring, STRING_SIZE,
206 "/sbin/chroot /harddisk /usr/sbin/htpasswd -c -m -b " CONFIG_ROOT "/auth/users admin '%s'", admin_password);
207 if (mysystem(commandstring)) {
208 errorbox("unattended: ERROR setting admin password");
209 return 0;
210 }
211 return 1;
212 }
213
214 int main(int argc, char *argv[])
215 {
216 char *langnames[] = { "Deutsch", "English", NULL };
217 char *shortlangnames[] = { "de", "en", NULL };
218 char **langtrs[] = { de_tr, en_tr, NULL };
219 char hdletter, cdletter;
220 char harddrive[5], sourcedrive[5]; /* Device holder. */
221 struct devparams hdparams, cdromparams; /* Params for CDROM and HD */
222 int cdmounted = 0; /* Loop flag for inserting a cd. */
223 int rc = 0;
224 char commandstring[STRING_SIZE];
225 char *installtypes[] = { "CDROM", "HTTP/FTP", NULL };
226 int installtype = CDROM_INSTALL;
227 char insertmessage[STRING_SIZE];
228 char insertdevnode[STRING_SIZE];
229 int choice;
230 char shortlangname[10];
231 char message[1000];
232 char title[STRING_SIZE];
233 int allok = 0;
234 int allok_fastexit=0;
235 int unmount_before=0;
236 struct keyvalue *ethernetkv = initkeyvalues();
237 FILE *handle, *cmdfile;
238 char line[STRING_SIZE];
239 char string[STRING_SIZE];
240 long maximum_free = 0, current_free;
241 long memory = 0;
242 long system_partition, boot_partition, root_partition, swap_file;
243 int scsi_disk = 0;
244 int pcmcia_disk = 0;
245 int pcmcia_cdrom = 0;
246 int scsi_cdrom = 0;
247 int ide_cdrom = 0;
248 int fdisk = 0;
249 int hardyn = 0;
250 char *yesnoharddisk[] = { "NO", "YES", NULL };
251 char *yesno[] = { "NO", "YES", NULL };
252 char green[STRING_SIZE];
253 int unattended = 0;
254 struct keyvalue *unattendedkv = initkeyvalues();
255 char packages[STRING_SIZE];
256 int serial_console = 0;
257 char megabridge[STRING_SIZE];
258
259 setlocale (LC_ALL, "");
260 sethostname( SNAME , 10);
261
262 memset(&hdparams, 0, sizeof(struct devparams));
263 memset(&cdromparams, 0, sizeof(struct devparams));
264
265 /* Log file/terminal stuff. */
266 if (argc >= 2)
267 {
268 if (!(flog = fopen(argv[1], "w+")))
269 return 0;
270 }
271 else
272 return 0;
273
274 mylog = argv[1];
275
276 fprintf(flog, "Install program started.\n");
277
278 newtInit();
279 newtCls();
280
281 /* Do usb detection first for usb keyboard */
282 if (! (cmdfile = fopen("/proc/cmdline", "r")))
283 {
284 fprintf(flog, "Couldn't open commandline: /proc/cmdline\n");
285 } else {
286 fgets(line, STRING_SIZE, cmdfile);
287 if (strstr (line, "fdisk") != NULL) {
288 fprintf(flog, "Manual FDISK selected.\n");
289 fdisk = 1;
290 }
291 if (strstr (line, "nopcmcia") == NULL) {
292 fprintf(flog, "Initializing PCMCIA controllers.\n");
293 pcmcia = initialize_pcmcia();
294 if (pcmcia) {
295 fprintf (flog, "Detected PCMCIA Controller: %s.\n", pcmcia);
296 sprintf(commandstring, "/sbin/modprobe %s", pcmcia);
297 mysystem("/sbin/modprobe pcmcia_core");
298 mysystem(commandstring);
299 mysystem("/sbin/modprobe ds");
300 /* pcmcia netcard drivers are not available from Boot floppy,
301 * they will be loaded from Drivers floppy later */
302 } else {
303 fprintf (flog, "Detected No PCMCIA Controller.\n");
304 }
305 } else {
306 fprintf(flog, "Skipping PCMCIA detection.\n");
307 }
308 if (strstr (line, "nousb") == NULL) {
309 fprintf(flog, "Initializing USB controllers.\n");
310 initialize_usb();
311 } else {
312 fprintf(flog, "Skipping USB detection.\n");
313 }
314 // check if we have to make an unattended install
315 if (strstr (line, "unattended") != NULL) {
316 unattended = 1;
317 }
318 }
319
320 // make some beeps before wiping the system :)
321 if (unattended) {
322 runcommandwithstatus("/bin/sleep 10", "WARNING: Unattended installation will start in 10 seconds...");
323 }
324
325 /* German is the default */
326 for (choice = 0; langnames[choice]; choice++)
327 {
328 if (strcmp(langnames[choice], "Deutsch") == 0)
329 break;
330 }
331 if (!langnames[choice])
332 goto EXIT;
333
334 if (!unattended) {
335 rc = newtWinMenu("Language selection",
336 "Select the language you wish to use for the " NAME ".", 50, 5, 5, 8,
337 langnames, &choice, "Ok", NULL);
338 }
339
340 ctr = langtrs[choice];
341 strcpy(shortlangname, shortlangnames[choice]);
342
343 mysystem("/bin/setfont lat0-16");
344
345 newtDrawRootText(14, 0, NAME " " VERSION " - " SLOGAN );
346 newtPushHelpLine(ctr[TR_HELPLINE]);
347
348 if (!unattended) {
349 sprintf(message, ctr[TR_WELCOME], NAME);
350 sprintf (title, "%s %s - %s", NAME, VERSION, SLOGAN);
351 newtWinMessage(title, ctr[TR_OK], message);
352
353 sprintf(message, ctr[TR_SELECT_INSTALLATION_MEDIA_LONG], NAME);
354 rc = newtWinMenu(ctr[TR_SELECT_INSTALLATION_MEDIA], message,
355 50, 5, 5, 6, installtypes, &installtype, ctr[TR_OK],
356 ctr[TR_CANCEL], NULL);
357 }
358 else {
359 rc = 1;
360 installtype = CDROM_INSTALL;
361 }
362
363 if (rc == 2)
364 goto EXIT;
365
366 // Starting hardware detection
367 runcommandwithstatus("/bin/probehw.sh", ctr[TR_PROBING_HARDWARE]);
368
369 /* CDROM INSTALL */
370 if (installtype == CDROM_INSTALL) {
371
372 switch (mysystem("/bin/mountsource.sh")) {
373 case 0:
374 installtype = CDROM_INSTALL;
375 cdmounted = 1;
376 break;
377 case 1:
378 installtype = DISK_INSTALL;
379 break;
380 case 10:
381 errorbox(ctr[TR_NO_CDROM]);
382 goto EXIT;
383 }
384
385 /* read source drive letter */
386 if ((handle = fopen("/source_device", "r")) == NULL) {
387 errorbox(ctr[TR_ERROR_PROBING_CDROM]);
388 goto EXIT;
389 }
390 fgets(sourcedrive, 5, handle);
391 fprintf(flog, "Source drive: %s\n", sourcedrive);
392 fclose(handle);
393
394 snprintf(cdromparams.devnode, STRING_SIZE, "/dev/%s", sourcedrive);
395 cdromparams.module = 0;
396 fprintf(flog, "Source device: %s\n", cdromparams.devnode);
397 }
398
399 /* Configure the network now! */
400 if (installtype == URL_INSTALL) {
401 /* Network driver and params. */
402 if (!(networkmenu(ethernetkv))) {
403 errorbox(ctr[TR_NETWORK_SETUP_FAILED]);
404 goto EXIT;
405 }
406
407 /* Check for ipcop-<VERSION>.tbz2 */
408 if (checktarball(SNAME "-" VERSION ".tbz2", ctr[TR_ENTER_URL])) {
409 errorbox(ctr[TR_NO_IPCOP_TARBALL_FOUND]);
410 goto EXIT;
411 }
412 }
413
414 /* Get device for the HD. This has to succeed. */
415 if (!(hdletter = findidetype(IDE_HD)))
416 {
417 /* Need to clean this up at some point */
418 if (!try_scsi("sda") || strstr(sourcedrive, "sda") != NULL) {
419 if (!try_scsi("ida/c0d0")) {
420 if (!try_scsi("cciss/c0d0")) {
421 if (!try_scsi("rd/c0d0")) {
422 if (!try_scsi("ataraid/d0")) {
423 errorbox(ctr[TR_NO_HARDDISK]);
424 goto EXIT;
425 } else {
426 raid_disk = 1;
427 sprintf(harddrive, "ataraid/d0");
428 }
429 } else {
430 raid_disk = 1;
431 sprintf(harddrive, "rd/c0d0");
432 }
433 } else {
434 raid_disk = 1;
435 sprintf(harddrive, "cciss/c0d0");
436 }
437 } else {
438 raid_disk = 1;
439 sprintf(harddrive, "ida/c0d0");
440 }
441 } else {
442 if (strstr(sourcedrive, "sda") != NULL) {
443 // probably installing from usb stick, try sdb
444 if (try_scsi("sdb")) {
445 sprintf(harddrive, "sdb");
446 }
447 else {
448 errorbox(ctr[TR_NO_HARDDISK]);
449 goto EXIT;
450 }
451 }
452 else {
453 sprintf(harddrive, "sda");
454 }
455 }
456 scsi_disk = 1;
457 } else
458 sprintf(harddrive, "hd%c", hdletter);
459
460 fprintf(flog, "Destination drive: %s\n", harddrive);
461
462 /* load unattended configuration */
463 if (unattended) {
464 fprintf(flog, "unattended: Reading unattended.conf\n");
465
466 (void) readkeyvalues(unattendedkv, UNATTENDED_CONF);
467 }
468
469 /* Make the hdparms struct and print the contents. */
470 snprintf(hdparams.devnode, STRING_SIZE, "/dev/%s", harddrive);
471 hdparams.module = 0;
472
473 sprintf(message, ctr[TR_PREPARE_HARDDISK], hdparams.devnode);
474
475 if (unattended) {
476 hardyn = 1;
477 }
478
479 while (! hardyn) {
480 rc = newtWinMenu(title, message,
481 50, 5, 5, 6, yesnoharddisk,
482 &hardyn, ctr[TR_OK],
483 ctr[TR_CANCEL], NULL);
484 if (rc == 2)
485 goto EXIT;
486 }
487
488 if (rc == 2)
489 goto EXIT;
490
491 /* Calculate amount of memory in machine */
492 if ((handle = fopen("/proc/meminfo", "r")))
493 {
494 while (fgets(line, STRING_SIZE-1, handle)) {
495 if (sscanf (line, "MemTotal: %s kB", string)) {
496 memory = atoi(string) / 1024 ;
497 }
498 }
499 fclose(handle);
500 }
501
502 /* Partition, mkswp, mkfs.
503 * before partitioning, first determine the sizes of each
504 * partition. In order to do that we need to know the size of
505 * the disk.
506 */
507 /* Don't use mysystem here so we can redirect output */
508 sprintf(commandstring, "/bin/sfdisk -s /dev/%s > /disksize 2> /dev/null", harddrive);
509 system(commandstring);
510
511 /* Calculate amount of disk space */
512 if ((handle = fopen("/disksize", "r")))
513 {
514 fgets(line, STRING_SIZE-1, handle);
515 if (sscanf (line, "%s", string)) {
516 maximum_free = atoi(string) / 1024;
517 }
518 fclose(handle);
519 }
520
521 fprintf(flog, "maximum_free = %ld, memory = %ld",
522 maximum_free, memory);
523
524 swap_file = calc_swapsize(memory, maximum_free);
525
526 if (maximum_free < 512 + swap_file ) {
527 if (maximum_free < 512) {
528 errorbox(ctr[TR_DISK_TOO_SMALL]);
529 goto EXIT;
530 }
531
532 if (!unattended) {
533 rc = newtWinChoice(title, ctr[TR_OK], ctr[TR_CANCEL], ctr[TR_CONTINUE_NO_SWAP]);
534 }
535 else {
536 rc = 1;
537 }
538
539 if (rc != 1)
540 goto EXIT;
541 swap_file = 0;
542 }
543
544 boot_partition = 20; /* in MB */
545 current_free = maximum_free - boot_partition - swap_file;
546
547 root_partition = 2048 ;
548 if (current_free < 512) {
549 errorbox(ctr[TR_DISK_TOO_SMALL]);
550 goto EXIT;
551 }
552
553 current_free = current_free - root_partition;
554 if (!swap_file) {
555 root_partition = root_partition + swap_file;
556 }
557
558 system_partition = current_free;
559
560 fprintf(flog, "boot = %ld, swap = %ld, mylog = %ld, root = %ld\n",
561 boot_partition, swap_file, system_partition, root_partition);
562
563 handle = fopen("/tmp/partitiontable", "w");
564
565 /* Make swapfile */
566 if (swap_file) {
567 fprintf(handle, ",%ld,L,*\n,%ld,S,\n,%ld,L,\n,,L,\n",
568 boot_partition, swap_file, root_partition);
569 } else {
570 fprintf(handle, ",%ld,L,*\n,0,0,\n,%ld,L,\n,,L,\n",
571 boot_partition, root_partition);
572 }
573
574 fclose(handle);
575
576 snprintf(commandstring, STRING_SIZE, "/bin/sfdisk -L -uM %s < /tmp/partitiontable", hdparams.devnode);
577 if (runcommandwithstatus(commandstring, ctr[TR_PARTITIONING_DISK]))
578 {
579 errorbox(ctr[TR_UNABLE_TO_PARTITION]);
580 goto EXIT;
581 }
582
583 mysystem("/sbin/udevstart");
584
585 if (raid_disk)
586 snprintf(commandstring, STRING_SIZE, "/bin/mke2fs -T ext2 -c %sp1", hdparams.devnode);
587 else
588 snprintf(commandstring, STRING_SIZE, "/bin/mke2fs -T ext2 -c %s1", hdparams.devnode);
589 if (runcommandwithstatus(commandstring, ctr[TR_MAKING_BOOT_FILESYSTEM]))
590 {
591 errorbox(ctr[TR_UNABLE_TO_MAKE_BOOT_FILESYSTEM]);
592 goto EXIT;
593 }
594
595 if (swap_file) {
596 if (raid_disk)
597 snprintf(commandstring, STRING_SIZE, "/sbin/mkswap %sp2", hdparams.devnode);
598 else
599 snprintf(commandstring, STRING_SIZE, "/sbin/mkswap %s2", hdparams.devnode);
600 if (runcommandwithstatus(commandstring, ctr[TR_MAKING_SWAPSPACE]))
601 {
602 errorbox(ctr[TR_UNABLE_TO_MAKE_SWAPSPACE]);
603 goto EXIT;
604 }
605 }
606
607 if (raid_disk)
608 snprintf(commandstring, STRING_SIZE, "/bin/mkreiserfs -f %sp3", hdparams.devnode);
609 else
610 snprintf(commandstring, STRING_SIZE, "/bin/mkreiserfs -f %s3", hdparams.devnode);
611
612 if (runcommandwithstatus(commandstring, ctr[TR_MAKING_ROOT_FILESYSTEM]))
613 {
614 errorbox(ctr[TR_UNABLE_TO_MAKE_ROOT_FILESYSTEM]);
615 goto EXIT;
616 }
617
618 if (raid_disk)
619 snprintf(commandstring, STRING_SIZE, "/bin/mkreiserfs -f %sp4", hdparams.devnode);
620 else
621 snprintf(commandstring, STRING_SIZE, "/bin/mkreiserfs -f %s4", hdparams.devnode);
622
623 if (runcommandwithstatus(commandstring, ctr[TR_MAKING_LOG_FILESYSTEM]))
624 {
625 errorbox(ctr[TR_UNABLE_TO_MAKE_ROOT_FILESYSTEM]);
626 goto EXIT;
627 }
628
629 /* Mount harddisk. */
630 if (raid_disk)
631 snprintf(commandstring, STRING_SIZE, "/bin/mount %sp3 /harddisk", hdparams.devnode);
632 else
633 snprintf(commandstring, STRING_SIZE, "/bin/mount %s3 /harddisk", hdparams.devnode);
634 if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_ROOT_FILESYSTEM]))
635 {
636 errorbox(ctr[TR_UNABLE_TO_MOUNT_ROOT_FILESYSTEM]);
637 goto EXIT;
638 }
639
640 mkdir("/harddisk/boot", S_IRWXU|S_IRWXG|S_IRWXO);
641 mkdir("/harddisk/var", S_IRWXU|S_IRWXG|S_IRWXO);
642 mkdir("/harddisk/var/log", S_IRWXU|S_IRWXG|S_IRWXO);
643
644 if (raid_disk)
645 snprintf(commandstring, STRING_SIZE, "/bin/mount %sp1 /harddisk/boot", hdparams.devnode);
646 else
647 snprintf(commandstring, STRING_SIZE, "/bin/mount %s1 /harddisk/boot", hdparams.devnode);
648
649 if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_BOOT_FILESYSTEM]))
650 {
651 errorbox(ctr[TR_UNABLE_TO_MOUNT_BOOT_FILESYSTEM]);
652 goto EXIT;
653 }
654 if (swap_file) {
655 if (raid_disk)
656 snprintf(commandstring, STRING_SIZE, "/sbin/swapon %sp2", hdparams.devnode);
657 else
658 snprintf(commandstring, STRING_SIZE, "/sbin/swapon %s2", hdparams.devnode);
659 if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_SWAP_PARTITION]))
660 {
661 errorbox(ctr[TR_UNABLE_TO_MOUNT_SWAP_PARTITION]);
662 goto EXIT;
663 }
664 }
665 if (raid_disk)
666 snprintf(commandstring, STRING_SIZE, "/bin/mount %sp4 /harddisk/var", hdparams.devnode);
667 else
668 snprintf(commandstring, STRING_SIZE, "/bin/mount %s4 /harddisk/var", hdparams.devnode);
669 if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_LOG_FILESYSTEM]))
670 {
671 errorbox(ctr[TR_UNABLE_TO_MOUNT_LOG_FILESYSTEM]);
672 goto EXIT;
673 }
674
675 snprintf(commandstring, STRING_SIZE, "/bin/tar -C /harddisk -xvjf /cdrom/" SNAME "-" VERSION ".tbz2");
676
677 if (runcommandwithprogress(60, 4, title, commandstring, INST_FILECOUNT,
678 ctr[TR_INSTALLING_FILES]))
679 {
680 errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
681 goto EXIT;
682 }
683
684 /* Save USB controller type to modules.conf */
685 write_usb_modules_conf();
686
687 /* touch the modules.dep files */
688 snprintf(commandstring, STRING_SIZE,
689 "/sbin/chroot /harddisk /usr/bin/touch /lib/modules/%s/modules.dep",
690 KERNEL_VERSION);
691 mysystem(commandstring);
692 snprintf(commandstring, STRING_SIZE,
693 "/sbin/chroot /harddisk /usr/bin/touch /lib/modules/%s-smp/modules.dep",
694 KERNEL_VERSION);
695 mysystem(commandstring);
696
697 /* Rename uname */
698 rename ("/harddisk/bin/uname.bak", "/harddisk/bin/uname");
699
700 /* Write PCMCIA Config */
701 if (pcmcia) {
702 handle = fopen("/harddisk/etc/modules.conf", "a");
703 if (handle != NULL) {
704 fprintf (handle, "# PCMCIA Settings\n");
705 fprintf (handle, "alias pcmcia-controller %s\n", pcmcia);
706 fclose(handle);
707 }
708 }
709
710 handle = fopen("/harddisk/etc/pcmcia.conf", "w");
711 if (handle != NULL) {
712 if (pcmcia) {
713 fprintf (handle, "PCMCIA=yes\n");
714 fprintf (handle, "PCIC=%s\n", pcmcia);
715 } else {
716 fprintf (handle, "PCMCIA=no\n");
717 fprintf (handle, "PCIC=\n");
718 }
719 fprintf (handle, "CARDMGR_OPTS=\n");
720 fprintf (handle, "SCHEME=\n");
721 fclose(handle);
722 }
723
724 /* *always* write disk configuration */
725 if (!(write_disk_configs(&hdparams))){
726 errorbox(ctr[TR_ERROR_WRITING_CONFIG]);
727 goto EXIT;
728 }
729
730 /* mount proc filesystem */
731 mysystem("mkdir /harddisk/proc");
732 mysystem("/bin/mount -t proc none /harddisk/proc");
733 mysystem("/bin/mount --bind /dev /harddisk/dev");
734
735
736
737 /* if we detected SCSI then fixup */
738 /* doesn't really work cause it sometimes creates a ramdisk on ide systems */
739 /* mysystem("/bin/probecntrl.sh");
740 if ((handle = fopen("/cntrldriver", "r")))
741 {
742 char *driver;
743 fgets(line, STRING_SIZE-1, handle);
744 fclose(handle);
745 line[strlen(line) - 1] = 0;
746 driver = strtok(line, ".");
747 fprintf(flog, "Detected SCSI driver %s\n",driver);
748 if (strlen(driver) > 1) {
749 fprintf(flog, "Fixing up ipfirerd.img\n");
750 mysystem("/sbin/chroot /harddisk /sbin/modprobe loop");
751 mkdir("/harddisk/initrd", S_IRWXU|S_IRWXG|S_IRWXO);
752 snprintf(commandstring, STRING_SIZE, "/sbin/chroot /harddisk /sbin/mkinitrd --with=scsi_mod --with=%s --with=sd_mod --with=sr_mod --with=libata /boot/ipfirerd.img %s", driver, KERNEL_VERSION);
753 runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
754 snprintf(commandstring, STRING_SIZE, "/sbin/chroot /harddisk /sbin/mkinitrd --with=scsi_mod --with=%s --with=sd_mod --with=sr_mod --with=libata /boot/ipfirerd-smp.img %s-smp", driver, KERNEL_VERSION);
755 runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
756 mysystem("/sbin/chroot /harddisk /bin/mv /boot/grub/scsigrub.conf /boot/grub/grub.conf");
757 }
758 } */
759
760 /* Build cache lang file */
761 snprintf(commandstring, STRING_SIZE, "/sbin/chroot /harddisk /usr/bin/perl -e \"require '" CONFIG_ROOT "/lang.pl'; &Lang::BuildCacheLang\"");
762 if (runcommandwithstatus(commandstring, ctr[TR_INSTALLING_LANG_CACHE]))
763 {
764 errorbox(ctr[TR_UNABLE_TO_INSTALL_LANG_CACHE]);
765 goto EXIT;
766 }
767
768 if (raid_disk)
769 sprintf(string, "root=%sp3", hdparams.devnode);
770 else
771 sprintf(string, "root=%s3", hdparams.devnode);
772 replace( "/harddisk/boot/grub/grub.conf", "root=ROOT", string);
773 replace( "/harddisk/boot/grub/grubbatch", "DEVICE", hdparams.devnode);
774
775 /* restore permissions */
776 chmod("/harddisk/boot/grub/grubbatch", S_IXUSR | S_IRUSR | S_IXGRP | S_IRGRP | S_IXOTH | S_IROTH);
777
778 snprintf(commandstring, STRING_SIZE,
779 "/sbin/chroot /harddisk /boot/grub/grubbatch");
780 if (runcommandwithstatus(commandstring, ctr[TR_INSTALLING_GRUB])) {
781 errorbox(ctr[TR_UNABLE_TO_INSTALL_GRUB]);
782 goto EXIT;
783 }
784
785 /* Update /etc/fstab */
786 replace( "/harddisk/etc/fstab", "DEVICE", hdparams.devnode);
787
788 /* Install bootsplash */
789 mysystem("/bin/installbootsplash.sh");
790
791 mysystem("ln -s grub.conf /harddisk/boot/grub/menu.lst");
792 mysystem("umount /harddisk/proc");
793 mysystem("umount /harddisk/dev");
794
795 if (!unattended) {
796 sprintf(message, ctr[TR_CONGRATULATIONS_LONG],
797 NAME, SNAME, SNAME, NAME, NAME, NAME);
798 newtWinMessage(ctr[TR_CONGRATULATIONS], ctr[TR_OK], message);
799 }
800
801 allok = 1;
802
803 EXIT:
804 fprintf(flog, "Install program ended.\n");
805 fflush(flog);
806 fclose(flog);
807
808 if (!(allok))
809 newtWinMessage(title, ctr[TR_OK], ctr[TR_PRESS_OK_TO_REBOOT]);
810
811 newtFinished();
812
813 freekeyvalues(ethernetkv);
814
815 if (allok && !allok_fastexit)
816 {
817 /* /proc is needed by the module checker. We have to mount it
818 * so it can be seen by setup, which is run chrooted. */
819 if (system("/bin/mount proc -t proc /harddisk/proc"))
820 printf("Unable to mount proc in /harddisk.");
821 else
822 {
823
824 if (!unattended) {
825 if (system("/sbin/chroot /harddisk /usr/local/sbin/setup /dev/tty2 INSTALL"))
826 printf("Unable to run setup.\n");
827 }
828 else {
829 fprintf(flog, "Entering unattended setup\n");
830 unattended_setup(unattendedkv);
831 snprintf(commandstring, STRING_SIZE, "/bin/sleep 10");
832 runcommandwithstatus(commandstring, "Unattended installation finished, system will reboot");
833 }
834
835 if (system("/bin/umount /harddisk/proc"))
836 printf("Unable to umount /harddisk/proc.\n");
837 }
838 }
839
840 fcloseall();
841
842 if (swap_file) {
843 if (raid_disk)
844 snprintf(commandstring, STRING_SIZE, "/bin/swapoff %sp2", hdparams.devnode);
845 else
846 snprintf(commandstring, STRING_SIZE, "/bin/swapoff %s2", hdparams.devnode);
847 }
848
849 newtFinished();
850
851 system("/bin/umount /harddisk/var");
852 system("/bin/umount /harddisk/boot");
853 system("/bin/umount /harddisk");
854
855 system("/etc/halt");
856
857 return 0;
858 }