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