[people/teissler/ipfire-2.x.git] / src / install+setup / install / main.c

/* SmoothWall install program.
 *
 * This program is distributed under the terms of the GNU General Public
 * Licence.  See the file COPYING for details.
 *
 * (c) Lawrence Manning, 2001
 * Contains main entry point, and misc functions.6
 * 
 */

#include "install.h"
#define _GNU_SOURCE
 
#define CDROM_INSTALL 0
#define URL_INSTALL 1
#define DISK_INSTALL 2
#define INST_FILECOUNT 7000
#define UNATTENDED_CONF "/cdrom/boot/unattended.conf"

int raid_disk = 0;
FILE *flog = NULL;
char *mylog;

char **ctr;

extern char url[STRING_SIZE];

struct  nic  nics[20] = { { "" , "" , "" } }; // only defined for compile
struct knic knics[20] = { { "" , "" , "" , "" } }; // only defined for compile

extern char *en_tr[];
extern char *de_tr[];

int detect_smp() {
	FILE *fd = NULL;
	char line[STRING_SIZE];
	int cpu_count = 0;

	if ((fd = fopen("/proc/cpuinfo", "r")) == NULL) {
		return 0;
	}
	while (fgets(line, STRING_SIZE, fd) != NULL) {
		if (strstr(line, "processor") == line) {
			cpu_count++;
		}
	}
	(void)fclose(fd);
	return (cpu_count > 1);
}

long calc_swapsize(long memory, long disk) {
	if (memory < 128) {
		return 256;
	}
	if (memory > 1024) {
		return 512;
	}

	return memory*2;
}

int main(int argc, char *argv[])
{
	char *langnames[] = { "Deutsch", "English", NULL };
	char *shortlangnames[] = { "de", "en", NULL };
	char **langtrs[] = { de_tr, en_tr, NULL };
	char hdletter;
	char harddrive[5], sourcedrive[5];	/* Device holder. */
	struct devparams hdparams, cdromparams; /* Params for CDROM and HD */
	int cdmounted = 0; /* Loop flag for inserting a cd. */
	int rc = 0;
	char commandstring[STRING_SIZE];
	char *installtypes[] = { "CDROM/USB", "HTTP/FTP", NULL };
	int installtype = CDROM_INSTALL;
	int choice;
	int i;
	int found = 0;
	int firstrun = 0;
	char shortlangname[10];
	char message[1000];
	char title[STRING_SIZE];
	int allok = 0;
	int allok_fastexit=0;
	struct keyvalue *ethernetkv = initkeyvalues();
	FILE *handle, *cmdfile;
	char line[STRING_SIZE];
	char string[STRING_SIZE];
	long maximum_free = 0, current_free;
	long memory = 0;
	long system_partition, boot_partition, root_partition, swap_file;
	int scsi_disk = 0;
	char *yesnoharddisk[3];	//	char *yesnoharddisk = { "NO", "YES", NULL };
		
	int unattended = 0;
	struct keyvalue *unattendedkv = initkeyvalues();
	int hardyn = 0;

	setlocale (LC_ALL, "");
	sethostname( SNAME , 10);

	memset(&hdparams, 0, sizeof(struct devparams));
	memset(&cdromparams, 0, sizeof(struct devparams));

	/* Log file/terminal stuff. */
	if (argc >= 2)
	{		
		if (!(flog = fopen(argv[1], "w+")))
			return 0;
	}
	else
		return 0;
	
	mylog = argv[1];
	
	fprintf(flog, "Install program started.\n");
		
	newtInit();
	newtCls();

	/* Do usb detection first for usb keyboard */
	if (! (cmdfile = fopen("/proc/cmdline", "r")))
	{
		fprintf(flog, "Couldn't open commandline: /proc/cmdline\n");
	} else {
		fgets(line, STRING_SIZE, cmdfile);
		if (strstr (line, "noide") == NULL) {
			fprintf(flog, "Initializing IDE controllers.\n");
			initialize_ide();
		} else {
			fprintf(flog, "Skipping IDE detection.\n");
		}
		if (strstr (line, "nousb") == NULL) {
			fprintf(flog, "Initializing USB controllers.\n");
			initialize_usb();
		} else {
			fprintf(flog, "Skipping USB detection.\n");
		}
		// check if we have to make an unattended install
		if (strstr (line, "unattended") != NULL) {
		    unattended = 1;
		}
		// Loading the cdrom-filesystem
		mysystem("/sbin/modprobe iso9660");
	}

	if (unattended) {
	    runcommandwithstatus("/bin/sleep 10", "WARNING: Unattended installation will start in 10 seconds...");
 	}
	
	/* German is the default */
	for (choice = 0; langnames[choice]; choice++)
	{
		if (strcmp(langnames[choice], "Deutsch") == 0)
			break;
	}
	if (!langnames[choice])
		goto EXIT;

	if (!unattended) {
	    rc = newtWinMenu("Language selection",
		    "Select the language you wish to use for the " NAME ".", 50, 5, 5, 8,
		    langnames, &choice, "Ok", NULL);
	}

	ctr = langtrs[choice];
	strcpy(shortlangname, shortlangnames[choice]);
	fprintf(flog, "Selected language: %s\n", shortlangname);

	newtDrawRootText(14, 0, NAME " " VERSION " - " SLOGAN );
	newtPushHelpLine(ctr[TR_HELPLINE]);
	sprintf (title, "%s %s - %s", NAME, VERSION, SLOGAN);

	if (!unattended) {
		sprintf(message, ctr[TR_WELCOME], NAME);
		newtWinMessage(title, ctr[TR_OK], message);

		sprintf(message, ctr[TR_SELECT_INSTALLATION_MEDIA_LONG], NAME);
		rc = newtWinMenu(ctr[TR_SELECT_INSTALLATION_MEDIA], message,
			50, 5, 5, 6, installtypes, &installtype, ctr[TR_OK],
			ctr[TR_CANCEL], NULL);
	} else {
	    rc = 1;
	    installtype = CDROM_INSTALL;
	}

	if (rc == 2)
		goto EXIT;

	// Starting hardware detection
	runcommandwithstatus("/bin/probehw.sh", ctr[TR_PROBING_HARDWARE]);
	runcommandwithstatus("/bin/probenic.sh install", ctr[TR_PROBING_HARDWARE]);

	/* CDROM INSTALL */
	if (installtype == CDROM_INSTALL) {
		switch (mysystem("/bin/mountsource.sh")) {
		    case 0:
			installtype = CDROM_INSTALL;
			cdmounted = 1;
			break;
		    case 1:
			installtype = DISK_INSTALL;
			break;
		    case 10:
	        	errorbox(ctr[TR_NO_CDROM]);
			goto EXIT;
		}

		/* read source drive letter */
		if ((handle = fopen("/tmp/source_device", "r")) == NULL) {
			errorbox(ctr[TR_ERROR_PROBING_CDROM]);
			goto EXIT;
		}
		fgets(sourcedrive, 5, handle);
		fprintf(flog, "Source drive: %s\n", sourcedrive);
		fclose(handle);
	}

 	/* Configure the network now! */
	if (installtype == URL_INSTALL) {
		/* Network driver and params. */
		if (!(networkmenu(ethernetkv))) {
			errorbox(ctr[TR_NETWORK_SETUP_FAILED]);
			goto EXIT;
		}

		/* Check for ipfire-<VERSION>.tbz2 */
		if (checktarball(SNAME "-" VERSION ".tbz2", ctr[TR_ENTER_URL])) {
			errorbox(ctr[TR_NO_IPCOP_TARBALL_FOUND]);
			goto EXIT;
		}
	}
	
	i = 0;
	while (found == 0) {
		i++;
		fprintf(flog, "Harddisk scan pass %i\n", i);

		switch (mysystem("/bin/mountdest.sh") % 255) {
			case 0: // Found IDE disk
				scsi_disk = 0;
				found = 1;
				break;
			case 1: // Found SCSI disk
				scsi_disk = 1;
				found = 1;
				break;
			case 10: // No harddisk found
				if (firstrun == 1) {
					errorbox(ctr[TR_NO_HARDDISK]);
					goto EXIT;
				}
				// Do this if the kudzu-scan fails...
				runcommandwithstatus("/bin/probehw.sh deep-scan", ctr[TR_PROBING_HARDWARE]);
				firstrun = 1;
		}
	}

	/*
	// Need to clean this up at some point
	// scsi disk is sdb/sdc when sda/sdb is used for usb-key
	// if scsi-disk is sdd or more, it is not discovered
	// Support only 2 usb keys, none could be unplugged
	if (checkusb("sdb") && try_scsi("sdc")) {
		scsi_disk = 1;
		sprintf(harddrive, "sdc");
		goto FOUND_DESTINATION;
	}
	if (checkusb("sda") && try_scsi("sdb")) {
		scsi_disk = 1;
		sprintf(harddrive, "sdb");
		goto FOUND_DESTINATION;
	}
	if (try_scsi("sda")) {
		scsi_disk = 1;
		sprintf(harddrive, "sda");
		goto FOUND_DESTINATION;
	}
	if (try_scsi("ida/c0d0")) {
		raid_disk = 1;
		sprintf(harddrive, "ida/c0d0");
		goto FOUND_DESTINATION;
	}
	if (try_scsi("cciss/c0d0")) {
		raid_disk = 1;
		sprintf(harddrive, "cciss/c0d0");
		goto FOUND_DESTINATION;
	}
	if (try_scsi("rd/c0d0")) {
		raid_disk = 1;
		sprintf(harddrive, "rd/c0d0");
		goto FOUND_DESTINATION;
	}
	if (try_scsi("ataraid/d0")) {
		raid_disk = 1;
		sprintf(harddrive, "ataraid/d0");
		goto FOUND_DESTINATION;
	} */

	FOUND_DESTINATION:
	if ((handle = fopen("/tmp/dest_device", "r")) == NULL) {
		errorbox(ctr[TR_NO_HARDDISK]);
		goto EXIT;
	}
	fgets(harddrive, 5, handle);
	fclose(handle);
			
	/* load unattended configuration */
	if (unattended) {
	    fprintf(flog, "unattended: Reading unattended.conf\n");

	    (void) readkeyvalues(unattendedkv, UNATTENDED_CONF);
	}
	
	/* Make the hdparms struct and print the contents.
	   With USB-KEY install and SCSI disk, while installing, the disk
	   is named 'sdb,sdc,...' (following keys)
	   On reboot, it will become 'sda'
	   To avoid many test, all names are built in the struct.
	*/
	sprintf(hdparams.devnode_disk, "/dev/%s", harddrive);
	/* Address the partition or raid partition (eg dev/sda or /dev/sdap1 */
	sprintf(hdparams.devnode_part, "/dev/%s%s", harddrive,raid_disk ? "p" : "");
	/* Now the names after the machine is booted. Only scsi is affected
	   and we only install on the first scsi disk. */
	{	char tmp[30];
		strcpy(tmp, scsi_disk ? "sda" : harddrive);
		sprintf(hdparams.devnode_disk_run, "/dev/%s", tmp);
		sprintf(hdparams.devnode_part_run, "/dev/%s%s", tmp, raid_disk ? "p" : "");
	}

	fprintf(flog, "Destination drive: %s\n", hdparams.devnode_disk);
	
	sprintf(message, ctr[TR_PREPARE_HARDDISK], hdparams.devnode_disk);
	if (unattended) {
	    hardyn = 1;
	}

	yesnoharddisk[0] = ctr[TR_NO];
	yesnoharddisk[1] = ctr[TR_YES];
	yesnoharddisk[2] = NULL;

	while (! hardyn) {
		rc = newtWinMenu(title, message,
				 50, 5, 5, 6, yesnoharddisk,
				 &hardyn, ctr[TR_OK],
				 ctr[TR_CANCEL], NULL);
		if (rc == 2)
			goto EXIT;
	}
	if (rc == 2)
		goto EXIT;

	/* Calculate amount of memory in machine */
        if ((handle = fopen("/proc/meminfo", "r")))
        {
            while (fgets(line, STRING_SIZE-1, handle)) {
                if (sscanf (line, "MemTotal: %s kB", string)) {
                    memory = atoi(string) / 1024 ;
                }
            }
            fclose(handle);
        }

	/* Partition, mkswp, mkfs.
	 * before partitioning, first determine the sizes of each
	 * partition.  In order to do that we need to know the size of
	 * the disk. 
	 */
	/* Don't use mysystem here so we can redirect output */
	sprintf(commandstring, "/bin/sfdisk -s /dev/%s > /tmp/disksize 2> /dev/null", harddrive);
	system(commandstring);

	/* Calculate amount of disk space */
        if ((handle = fopen("/tmp/disksize", "r")))
        {
           	fgets(line, STRING_SIZE-1, handle);
            	if (sscanf (line, "%s", string)) {
			maximum_free = atoi(string) / 1024;
            	}
            	fclose(handle);
        }
	
	fprintf(flog, "maximum_free = %ld, memory = %ld", 
		maximum_free, memory);
	
	swap_file = calc_swapsize(memory, maximum_free);

	if (maximum_free < 512 + swap_file ) {
		if (maximum_free < 512) {
			errorbox(ctr[TR_DISK_TOO_SMALL]);
			goto EXIT;
		}

		if (!unattended) {
		    rc = newtWinChoice(title, ctr[TR_OK], ctr[TR_CANCEL], ctr[TR_CONTINUE_NO_SWAP]);
		}
		else {
		    rc = 1;
		}
		
		if (rc != 1)
			goto EXIT;
		swap_file = 0;
	}

	boot_partition = 20; /* in MB */
	current_free = maximum_free - boot_partition - swap_file;

	root_partition = 1024 ;
	if (current_free < 512) {
		errorbox(ctr[TR_DISK_TOO_SMALL]);
		goto EXIT;
	}

	current_free = current_free - root_partition;
	if (!swap_file) {
		root_partition = root_partition + swap_file;
	}

	system_partition = current_free;

	fprintf(flog, "boot = %ld, swap = %ld, mylog = %ld, root = %ld\n",
		boot_partition, swap_file, system_partition, root_partition);

	handle = fopen("/tmp/partitiontable", "w");

	/* Make swapfile */
	if (swap_file) {
		fprintf(handle, ",%ld,L,*\n,%ld,S,\n,%ld,L,\n,,L,\n",
			boot_partition, swap_file, root_partition);
	} else {
		fprintf(handle, ",%ld,L,*\n,0,0,\n,%ld,L,\n,,L,\n",
			boot_partition, root_partition);
	}

	fclose(handle);

	snprintf(commandstring, STRING_SIZE, "/bin/sfdisk -L -uM %s < /tmp/partitiontable", hdparams.devnode_disk);
	if (runcommandwithstatus(commandstring, ctr[TR_PARTITIONING_DISK]))
	{
		errorbox(ctr[TR_UNABLE_TO_PARTITION]);
		goto EXIT;
	}

	mysystem("/sbin/udevstart");

	snprintf(commandstring, STRING_SIZE, "/bin/mke2fs -T ext2 -c %s1", hdparams.devnode_part);
	if (runcommandwithstatus(commandstring, ctr[TR_MAKING_BOOT_FILESYSTEM]))
	{
		errorbox(ctr[TR_UNABLE_TO_MAKE_BOOT_FILESYSTEM]);
		goto EXIT;
	}

	if (swap_file) {
		snprintf(commandstring, STRING_SIZE, "/sbin/mkswap %s2", hdparams.devnode_part);
		if (runcommandwithstatus(commandstring, ctr[TR_MAKING_SWAPSPACE]))
		{
			errorbox(ctr[TR_UNABLE_TO_MAKE_SWAPSPACE]);
			goto EXIT;
		}
	}

	snprintf(commandstring, STRING_SIZE, "/sbin/mkreiserfs -f %s3", hdparams.devnode_part);
	if (runcommandwithstatus(commandstring, ctr[TR_MAKING_ROOT_FILESYSTEM]))
	{
		errorbox(ctr[TR_UNABLE_TO_MAKE_ROOT_FILESYSTEM]);
		goto EXIT;
	}

	snprintf(commandstring, STRING_SIZE, "/sbin/mkreiserfs -f %s4", hdparams.devnode_part);	
	if (runcommandwithstatus(commandstring, ctr[TR_MAKING_LOG_FILESYSTEM]))
	{
		errorbox(ctr[TR_UNABLE_TO_MAKE_ROOT_FILESYSTEM]);
		goto EXIT;
	}

	/* Mount harddisk. */
	mysystem("/sbin/modprobe reiserfs"); // to be banished...

	snprintf(commandstring, STRING_SIZE, "/bin/mount %s3 /harddisk", hdparams.devnode_part);
	if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_ROOT_FILESYSTEM]))
	{
		errorbox(ctr[TR_UNABLE_TO_MOUNT_ROOT_FILESYSTEM]);
		goto EXIT;
	}

	mkdir("/harddisk/boot", S_IRWXU|S_IRWXG|S_IRWXO);
	mkdir("/harddisk/var", S_IRWXU|S_IRWXG|S_IRWXO);
	mkdir("/harddisk/var/log", S_IRWXU|S_IRWXG|S_IRWXO);
	
	snprintf(commandstring, STRING_SIZE, "/bin/mount %s1 /harddisk/boot", hdparams.devnode_part);
	if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_BOOT_FILESYSTEM]))
	{
		errorbox(ctr[TR_UNABLE_TO_MOUNT_BOOT_FILESYSTEM]);
		goto EXIT;
	}
	if (swap_file) {
		snprintf(commandstring, STRING_SIZE, "/sbin/swapon %s2", hdparams.devnode_part);
		if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_SWAP_PARTITION]))
		{
			errorbox(ctr[TR_UNABLE_TO_MOUNT_SWAP_PARTITION]);
			goto EXIT;
		}
	}
	snprintf(commandstring, STRING_SIZE, "/bin/mount %s4 /harddisk/var", hdparams.devnode_part);
	if (runcommandwithstatus(commandstring, ctr[TR_MOUNTING_LOG_FILESYSTEM]))
	{
		errorbox(ctr[TR_UNABLE_TO_MOUNT_LOG_FILESYSTEM]);
		goto EXIT;
	}

	if (installtype == URL_INSTALL) {
		snprintf(commandstring, STRING_SIZE,
			"/bin/wget -q -O - %s/" SNAME "-" VERSION ".tbz2 | /bin/tar -C /harddisk -xvjf -", url);
	}

	if (installtype == CDROM_INSTALL) {
		snprintf(commandstring, STRING_SIZE,
			"/bin/tar -C /harddisk -xvjf /cdrom/" SNAME "-" VERSION ".tbz2");
	}
	
	if (runcommandwithprogress(60, 4, title, commandstring, INST_FILECOUNT,
		ctr[TR_INSTALLING_FILES]))
	{
		errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
		goto EXIT;
	}
		
	/* Save USB controller type to modules.conf */
	write_usb_modules_conf();
	
	/* Save language und local settings */
	write_lang_configs(shortlangname);

	/* touch the modules.dep files */
	snprintf(commandstring, STRING_SIZE, 
		"/bin/touch /harddisk/lib/modules/%s-ipfire/modules.dep",
		KERNEL_VERSION);
	mysystem(commandstring);
	snprintf(commandstring, STRING_SIZE, 
		"/bin/touch /harddisk/lib/modules/%s-ipfire-smp/modules.dep",
		KERNEL_VERSION);
	mysystem(commandstring);

	/* Rename uname */
	rename ("/harddisk/bin/uname.bak", "/harddisk/bin/uname");

	/* mount proc filesystem */
	mysystem("mkdir /harddisk/proc");
	mysystem("/bin/mount --bind /proc /harddisk/proc");
	mysystem("/bin/mount --bind /dev  /harddisk/dev");
	mysystem("/bin/mount --bind /sys  /harddisk/sys");

	/* Build cache lang file */
	snprintf(commandstring, STRING_SIZE, "/sbin/chroot /harddisk /usr/bin/perl -e \"require '" CONFIG_ROOT "/lang.pl'; &Lang::BuildCacheLang\"");
	if (runcommandwithstatus(commandstring, ctr[TR_INSTALLING_LANG_CACHE]))
	{
		errorbox(ctr[TR_UNABLE_TO_INSTALL_LANG_CACHE]);
		goto EXIT;
	}

	/* Update /etc/fstab */
	replace("/harddisk/etc/fstab", "DEVICE", hdparams.devnode_part_run);

	/* Going to make our initrd... */
	snprintf(commandstring, STRING_SIZE, "/sbin/chroot /harddisk /sbin/mkinitcpio -v -g /boot/ipfirerd.img -k %s-ipfire", KERNEL_VERSION);
	runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
	snprintf(commandstring, STRING_SIZE, "/sbin/chroot /harddisk /sbin/mkinitcpio -v -g /boot/ipfirerd-smp.img -k %s-ipfire-smp", KERNEL_VERSION);
	runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);

	sprintf(string, "root=%s3", hdparams.devnode_part_run);
	replace( "/harddisk/boot/grub/grub.conf", "root=ROOT", string);
	replace( "/harddisk/boot/grub/grubbatch", "DEVICE", hdparams.devnode_disk);

	/* restore permissions */
	chmod("/harddisk/boot/grub/grubbatch", S_IXUSR | S_IRUSR | S_IXGRP | S_IRGRP | S_IXOTH | S_IROTH);

	snprintf(commandstring, STRING_SIZE, 
		 "/sbin/chroot /harddisk /boot/grub/grubbatch");
	if (runcommandwithstatus(commandstring, ctr[TR_INSTALLING_GRUB])) {
		errorbox(ctr[TR_UNABLE_TO_INSTALL_GRUB]);
		goto EXIT;
	}

	/* Install bootsplash */
	// mysystem("/bin/installbootsplash.sh"); We cannot use this at the moment, it conflicts with our initrds...

	mysystem("ln -s grub.conf /harddisk/boot/grub/menu.lst");

	if (!unattended) {
		sprintf(message, ctr[TR_CONGRATULATIONS_LONG],
				NAME, SNAME, NAME);
		newtWinMessage(ctr[TR_CONGRATULATIONS], ctr[TR_OK], message);
	}
	         
	allok = 1;

EXIT:
	fprintf(flog, "Install program ended.\n");	

	if (!(allok))
		newtWinMessage(title, ctr[TR_OK], ctr[TR_PRESS_OK_TO_REBOOT]);	
	
	freekeyvalues(ethernetkv);

	if (allok && !allok_fastexit)
	{
		if (unattended) {
			fprintf(flog, "Entering unattended setup\n");
			if (unattended_setup(unattendedkv)) {
				snprintf(commandstring, STRING_SIZE, "/bin/sleep 10");
				runcommandwithstatus(commandstring, "Unattended installation finished, system will reboot");
			} else {
				errorbox("Unattended setup failed.");
				goto EXIT;
			}
		}

		fflush(flog);
		fclose(flog);
		newtFinished();

		if (!unattended) {
			// Copy our scanned nics to the disk and lock because scan doesn't work in chroot
			system("touch /harddisk/var/ipfire/ethernet/scan_lock");
			system("cp -f /tmp/scanned_nics /harddisk/var/ipfire/ethernet/scanned_nics");
			if (system("/sbin/chroot /harddisk /usr/local/sbin/setup /dev/tty2 INSTALL"))
				printf("Unable to run setup.\n");
			system("rm -f /harddisk/var/ipfire/ethernet/scan_lock");
		}

		if (system("/bin/umount /harddisk/proc"))
			printf("Unable to umount /harddisk/proc.\n"); 
	} else {
		fflush(flog);
		fclose(flog);
		newtFinished();
	}

	fcloseall();

	if (swap_file) {
		snprintf(commandstring, STRING_SIZE, "/bin/swapoff %s2", hdparams.devnode_part);
	}

	newtFinished();

	system("/bin/umount /harddisk/proc");
	system("/bin/umount /harddisk/dev");
	system("/bin/umount /harddisk/sys");

	system("/bin/umount /harddisk/var");
	system("/bin/umount /harddisk/boot");
	system("/bin/umount /harddisk");
	  
	system("/etc/halt");

	return 0;
}
Commit	Line	Data
	1	/* SmoothWall install program.
	2	*
	3	* This program is distributed under the terms of the GNU General Public
	4	* Licence. See the file COPYING for details.
	5	*
	6	* (c) Lawrence Manning, 2001
	7	* Contains main entry point, and misc functions.6
	8	*
	9	*/
	10
	11	#include "install.h"
	12	#define _GNU_SOURCE
	13
	14	#define 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 = 1024 ;
	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	}