[people/pmueller/ipfire-2.x.git] / src / install+setup / install / install2.c

/* IPCop install2 program.
 *
 * This program is distributed under the terms of the GNU General Public
 * Licence.  See the file COPYING for details.
 *
 * (c) Lawrence Manning, 2001
 * (c) Franck Bourdonnec, 2006
 * Contains update/restore code
 * 
 * $Id: install2.c,v 1.1.2.5 2006/02/10 06:53:57 gespinasse Exp $
 * 
 */
#include "install.h"

FILE *flog = NULL;
char *mylog;
char **ctr;

/* 
    To include a translated string in the final installer, you must reference
    it here with a simplr comment. This save a lot a space in the installer
*/

/* TR_BUILDING_INITRD */
/* TR_HELPLINE */
/* TR_SKIP */
/* TR_RESTORE_CONFIGURATION */
/* TR_RESTORE */
/* TR_OK */
/* TR_CANCEL */
/* TR_ERROR */
/* TR_INSTALLING_FILES */
/* TR_FAILED_TO_FIND */
/* TR_UNABLE_TO_INSTALL_FILES */
/* TR_LOADING_PCMCIA */

//libsmooth
/* TR_INTERFACE */
/* TR_ENTER_THE_IP_ADDRESS_INFORMATION */
/* TR_STATIC */
/* TR_DHCP_HOSTNAME */
/* TR_IP_ADDRESS_PROMPT */
/* TR_NETMASK_PROMPT */
/* TR_INVALID_FIELDS */
/* TR_IP_ADDRESS_CR */
/* TR_NETWORK_MASK_CR */
/* TR_DHCP_HOSTNAME_CR */
/* TR_LOOKING_FOR_NIC */
/* TR_MANUAL */
/* TR_SELECT_NETWORK_DRIVER */
/* TR_SELECT_NETWORK_DRIVER_LONG */
/* TR_UNABLE_TO_LOAD_DRIVER_MODULE */
/* TR_THIS_DRIVER_MODULE_IS_ALREADY_LOADED */
/* TR_MODULE_PARAMETERS */
/* TR_LOADING_MODULE */
/* TR_MODULE_NAME_CANNOT_BE_BLANK */

//upgrade 120
/* TR_UNABLE_TO_OPEN_SETTINGS_FILE */
/* TR_DOMAINNAME */
/* TR_ENTER_DOMAINNAME */
/* TR_DOMAINNAME_CANNOT_CONTAIN_SPACES */
/* TR_UNABLE_TO_MOUNT_PROC_FILESYSTEM */
/* TR_UNABLE_TO_WRITE_ETC_FSTAB */

// dir to find files, chrooted or not...
#define TMP_EXTRACT_CH "/tmp/ipcop"
#define TMP_EXTRACT "/harddisk" TMP_EXTRACT_CH
#define MOUNT_BACKUP_CH "/mnt/usb"
#define MOUNT_BACKUP "/harddisk" MOUNT_BACKUP_CH
/*
    return 0 when dev contains a backup set
    leave dev mounted
*/
int try_mount (char *dev, char *testfile) {
	char commandstring[STRING_SIZE];
	mysystem("/bin/umount " MOUNT_BACKUP);
	sprintf(commandstring, "/bin/mount -t vfat -o ro %s " MOUNT_BACKUP, dev);
	mysystem(commandstring);

	/*verify it's what we want */
	sprintf(commandstring, MOUNT_BACKUP "/%s.dat", testfile);
	FILE *handle = fopen(commandstring, "r");
	if (handle == NULL) {
		return 1;   /* bad disk ! */
	}
	fclose(handle);
	
	handle = fopen(MOUNT_BACKUP "/backup.key", "r");
	if (handle == NULL) {
		return 1;   /* bad disk ! */
	}
	fclose(handle);
	return 0; //success
}

/* try to mount usb device until backup.tgz is found except the 
    destination device (scsi names are identical with usb key)
    check "sda sdb sdc sdd"
*/
int mountbackup (char *testfile, char *destination_device) {
	char sourcedev[30];
	char i,j;
	for (i = 'a'; i < 'e'; i++) {
		sprintf (sourcedev,"/dev/sd%c ",i);
		if (strcmp (destination_device, sourcedev) != 0) {
			if (!try_mount (sourcedev, testfile)) return 0;
		}
		for (j = '1'; j < '5'; j++) {
			sourcedev[8] = j;
			if (strcmp (destination_device, sourcedev) != 0) {
				if (!try_mount (sourcedev, testfile)) return 0;
			}
		}
	}
	return 1;
}

int floppy_locate() {
	/* Temporarily mount /proc under /harddisk/proc,
	   run updfstab to locate the floppy, and unmount /harddisk/proc
	   again.  This should be run each time the user tries to restore
	   so it can properly detect removable devices */
	if (mysystem("/bin/mount -n -t proc /proc /harddisk/proc")) {
		errorbox(ctr[TR_UNABLE_TO_MOUNT_PROC_FILESYSTEM]);
		return 1;
	}
	if (mysystem("/bin/chroot /harddisk /usr/sbin/updfstab")) {
		errorbox(ctr[TR_UNABLE_TO_WRITE_ETC_FSTAB]);
		return 1;
	}
	mysystem("/bin/umount /harddisk/proc");
	return 0;
}

/* Check the SQUID acl file exists, if not use our 1.4 copy */
void fixup_squidacl() {
	FILE *aclreadfile;
	if ((aclreadfile = fopen ("/harddisk" CONFIG_ROOT "/proxy/acl", "r"))) {
		unlink ("/harddisk" CONFIG_ROOT "/proxy/acl-1.4");
		fclose(aclreadfile);
	} else {
		rename ("/harddisk" CONFIG_ROOT "/proxy/acl-1.4",
			"/harddisk" CONFIG_ROOT "/proxy/acl");
	}
	chown  ("/harddisk" CONFIG_ROOT "/proxy/acl", 99, 99);
}
/* if we detected SCSI then fixup */
void fixup_initrd() {
	FILE *handle;
	char line[STRING_SIZE];
	char commandstring[STRING_SIZE];
	
	if (!(handle = fopen("/scsidriver", "r"))) 
	    return;

	char *driver;
	fgets(line, STRING_SIZE-1, handle);
	fclose(handle);
	line[strlen(line) - 1] = 0;
	driver = strtok(line, ".");
	fprintf(flog, "Detected SCSI driver %s\n", driver);
	if (!strlen(driver) > 1) 
		return;
		
	fprintf(flog, "Fixing up ipfirerd.img\n");
	mysystem("/bin/chroot /harddisk /sbin/modprobe loop");
	mkdir("/harddisk/initrd", S_IRWXU|S_IRWXG|S_IRWXO);
	sprintf(commandstring, "/bin/chroot /harddisk /sbin/mkinitrd"
				" --with=scsi_mod --with=%s --with=sd_mod"
				" --with=sr_mod --with=libata"
				" --with=ataraid /boot/ipfirerd.img "KERNEL_VERSION,
				driver );
	runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
#ifdef __i386__
	sprintf(commandstring, "/bin/chroot /harddisk /sbin/mkinitrd"
				" --with=scsi_mod --with=%s --with=sd_mod"
				" --with=sr_mod --with=libata"
				" --with=ataraid /boot/ipfirerd-smp.img "KERNEL_VERSION"-smp",
				driver );
	runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
	mysystem("/bin/chroot /harddisk /bin/mv /boot/grub/scsigrub.conf /boot/grub/grub.conf");
#endif
#ifdef __alpha__
	runcommandwithstatus("/bin/chroot /harddisk /bin/mv /boot/etc/scsiaboot.conf /boot/etc/aboot.conf", ctr[TR_BUILDING_INITRD]);
#endif
}
/* when backup is ready in tmpdir, move files to definitive location */
void do_copy_files() {
	mysystem("/bin/chroot /harddisk /bin/cp -af "TMP_EXTRACT_CH"/. /");
	/* Upgrade necessary files from v1.2 to v1.3 to v1.4 */
	upgrade_v12_v13();
	upgrade_v130_v140();
	/* Upgrade configuration files starting from 1.4.11 */
	mysystem("/bin/chroot /harddisk /usr/local/bin/upgrade");
}

int main(int argc, char *argv[]) {
#define LANG argv[1]
#define DEST_DEV argv[2]
#define WGET argv[3]

#ifdef	LANG_EN_ONLY
	char **langtrs[] = { en_tr, NULL };
#elifdef	LANG_ALL
	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, sk_tr, so_tr, fi_tr, sv_tr, tr_tr, vi_tr, NULL };
#else
	char **langtrs[] = { de_tr, en_tr, NULL };
#endif
	char message[1000];
	char title[STRING_SIZE];
	char commandstring[STRING_SIZE];

	setlocale (LC_ALL, "");	
	/* Log file/terminal stuff. */
	mylog = "/dev/tty2";
	ctr = langtrs[ atoi(LANG) ];

	if (!(flog = fopen(mylog, "w+")))
	{
		printf("Couldn't open log terminal\n");
		return 0;
	}
	fprintf(flog, "Install2 program started.\n");
	newtInit();
	newtCls();
	strcpy (title, NAME " v" VERSION " - " SLOGAN);
	newtDrawRootText(14, 0, title);
	newtPushHelpLine(ctr[TR_HELPLINE]);

	/* working dirs... */
	mkdir(MOUNT_BACKUP, S_IRWXU|S_IRWXG|S_IRWXO);

	//create the GUI screen and objects
	newtComponent form, header, labelfile, labelkey, file, key, radio0, radio1, radio2, radio3, radio4, ok;

	newtCenteredWindow (55,20,ctr[TR_RESTORE]);
	form = newtForm (NULL, NULL,0);

	sprintf(message, ctr[TR_RESTORE_CONFIGURATION], NAME);
	header = newtTextboxReflowed (2,1,message,51,0,0,0);
	newtFormAddComponent(form, header);

	// The four method of restauration
	int start1=1, start2=0, start3=0, start4=0;
	radio1 = newtRadiobutton (17, 5, ctr[TR_SKIP], start1, NULL);
	radio2 = newtRadiobutton (17, 6, "Floppy (legacy)", start2, radio1);
	radio3 = newtRadiobutton (17, 7, "Usb-storage/CDROM", start3, radio2);
	if (strcmp(WGET,"none"))
	    radio4 = newtRadiobutton (17, 8, "HTTP/FTP", start4, radio3);
	else
	    radio4 = NULL;
	newtFormAddComponents(form, radio1, radio2, radio3, radio4, NULL);

	// The optionnal filename for 'backup'
	labelfile=newtTextbox(12, 10, 35, 1, 0);
	newtTextboxSetText (labelfile, "Filename");
	newtFormAddComponent(form, labelfile);
	char *filevalue;
	char fileinit[STRING_SIZE] = "backup";
	file = newtEntry (17, 11, fileinit, 20, &filevalue, 0);
	newtFormAddComponent(form, file);

	// The optionnal password for the key
	labelkey=newtTextbox(12, 13, 35, 1, 0);
	newtTextboxSetText (labelkey, "Backup key password");
	newtFormAddComponent(form, labelkey);
	char *keyvalue;
	char keyinit[STRING_SIZE] = "";
	key = newtEntry (17, 14, keyinit, 20, &keyvalue, 0);
	newtFormAddComponent(form, key);

	// The OK button
	ok=newtButton (23, 16, ctr[TR_OK]);
	newtFormAddComponent(form, ok);

	/* loop until succeeds or user skips out */
	int retcode = -1;
	while ( retcode<0 ) {

	    // run the windows
	    struct newtExitStruct reponse;
	    newtFormRun (form, &reponse);
	    radio0 = newtRadioGetCurrent(radio1);
	    int radio;
	    radio = radio0 == radio1 ? 1 : radio0 == radio2 ? 2 :  radio0 == radio3 ? 3 : radio0 == radio4 ? 4 : 0;
	    strcpy(keyinit,keyvalue);	//reuse actual value
	    strcpy(fileinit,filevalue);

	    if (radio==1) {
		    retcode = 1;	// no restore: nothing special
		    break;		// out of the while loop
	    }

	    mkdir(TMP_EXTRACT, S_IRWXU|S_IRWXG|S_IRWXO);
	    statuswindow(45, 4, title, ctr[TR_INSTALLING_FILES]);
	    switch (radio) {
	    case 4:	// network
		    sprintf(commandstring,"/bin/wget -P " TMP_EXTRACT " %s/%s.dat", WGET, filevalue);
		    mysystem (commandstring);
		    sprintf(commandstring,"/bin/wget -P " TMP_EXTRACT " %s/%s.key", WGET, filevalue);
		    if (mysystem (commandstring)) {
			    errorbox(ctr[TR_FAILED_TO_FIND]);
			    break;
		    };
		    goto COMMON;
	    case 3:	// normal backup
		    if (mountbackup( filevalue, DEST_DEV )) {
			    errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);//mess=no device with backup found
			    break;
		    };
		    // link files to a COMMON location
		    sprintf (commandstring, "chroot /harddisk ln -s "MOUNT_BACKUP_CH"/%s.dat " TMP_EXTRACT_CH "/%s.dat", filevalue, filevalue);
		    mysystem (commandstring);
		    sprintf (commandstring, "chroot /harddisk ln -s "MOUNT_BACKUP_CH"/%s.key " TMP_EXTRACT_CH "/%s.key", filevalue, filevalue);
		    mysystem (commandstring);

	COMMON:	    // DECRYPT THE TARBALL
		    // Copy the key to a new location because we decrypt it!	
		    if (strcmp(keyvalue, "")) { // password provided: decrypt the key
			    sprintf(commandstring,   "/bin/chroot /harddisk /usr/bin/openssl enc"
						    " -a -d -aes256 -salt"
						    " -pass pass:%s"
						    " -in " TMP_EXTRACT_CH "/%s.key"
						    " -out " TMP_EXTRACT_CH "/__tmp.key",
						    keyvalue, filevalue);
		    } else {			//just copy to new name
			    sprintf(commandstring,  "/bin/chroot /harddisk cp"
						    " " TMP_EXTRACT_CH "/%s.key"
						    " " TMP_EXTRACT_CH "/__tmp.key",
						    filevalue);
		    }
		    mysystem (commandstring);

		    sprintf(commandstring,  "/bin/chroot /harddisk /usr/bin/openssl des3"
					    " -d -salt"
					    " -in " TMP_EXTRACT_CH "/%s.dat"
					    " -out " TMP_EXTRACT_CH "/backup.tgz"
					    " -kfile " TMP_EXTRACT_CH "/__tmp.key",
					    filevalue);

		    if (mysystem (commandstring)) {
			    errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);//mess=decrypt error:invalid key?
			    break;
		    }
		    strcpy(commandstring,   "/bin/chroot /harddisk /bin/tar"
					    " -X " CONFIG_ROOT "/backup/exclude.system"
					    " -C " TMP_EXTRACT_CH
					    " -xzf " TMP_EXTRACT_CH "/backup.tgz");

		    if (mysystem(commandstring)) {
			    errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
			    break;
		    }
		    sprintf(commandstring, TMP_EXTRACT "/%s.dat", filevalue);
		    unlink(commandstring ); //dont need them anymore
		    unlink( TMP_EXTRACT "/backup.tgz");
		    sprintf(commandstring, TMP_EXTRACT "/%s.key", filevalue);
		    unlink(commandstring );
		    unlink( TMP_EXTRACT "/__tmp.key");

		    /* Now copy to correct location */
		    do_copy_files();
		    retcode = 0; /* successfully restored */
		    break;
	    case 2:
		    // diskette change
		    if (floppy_locate()) {
			    retcode = 2; // this an error!
			    break;
		    }

		    /* Always extract to /tmp/ipcop for temporary extraction
		       just in case floppy fails.
		       try a compressed backup first because it's quicker to fail.
		       In exclude.system, files name must be without leading / or 
		       on extraction, name will never match
		    */
		    sprintf(commandstring,
		     "/bin/chroot /harddisk /bin/tar -X " CONFIG_ROOT "/backup/exclude.system -C "TMP_EXTRACT_CH" -xvzf /dev/floppy > %s 2> /dev/null", mylog);
		    if (system(commandstring)) {
		    /* if it's not compressed, try uncompressed first before failing*/
			sprintf(commandstring,
		     "/bin/chroot /harddisk /bin/tar -X " CONFIG_ROOT "/backup/exclude.system -C "TMP_EXTRACT_CH" -xvf /dev/floppy > %s 2> /dev/null", mylog);
			if (system(commandstring)) {
			    /* command failed trying to read from floppy */
			    errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
			    break;
			} 
		    }
		    /* Now copy to correct location */
		    do_copy_files();
		    retcode = 0; /* successfully restored */
	    }//switch
	    /* remove possible badly restored files */
	    mysystem("/bin/chroot /harddisk /bin/rm -rf " TMP_EXTRACT_CH );
	    newtPopWindow(); // close windows
	}//while
	newtFormDestroy(form);

	/* cleanup */
	mysystem("/bin/umount " MOUNT_BACKUP);
	mysystem("/bin/chroot /harddisk /bin/rmdir " MOUNT_BACKUP_CH);

	/* others operations moved from install to install2 */
	fixup_squidacl();
	fixup_initrd();

	fprintf(flog, "Install2 program ended.\n");
	fflush(flog);
	fclose(flog);
	newtFinished();
	return retcode;
}
Commit	Line	Data
d6aaa55d MT	1	/* IPCop install2 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	* (c) Franck Bourdonnec, 2006
	8	* Contains update/restore code
	9	*
	10	* $Id: install2.c,v 1.1.2.5 2006/02/10 06:53:57 gespinasse Exp $
	11	*
	12	*/
	13	#include "install.h"
	14
	15	FILE *flog = NULL;
	16	char *mylog;
	17	char **ctr;
	18
	19	/*
	20	To include a translated string in the final installer, you must reference
	21	it here with a simplr comment. This save a lot a space in the installer
	22	*/
	23
	24	/* TR_BUILDING_INITRD */
	25	/* TR_HELPLINE */
	26	/* TR_SKIP */
	27	/* TR_RESTORE_CONFIGURATION */
	28	/* TR_RESTORE */
	29	/* TR_OK */
	30	/* TR_CANCEL */
	31	/* TR_ERROR */
	32	/* TR_INSTALLING_FILES */
	33	/* TR_FAILED_TO_FIND */
	34	/* TR_UNABLE_TO_INSTALL_FILES */
	35	/* TR_LOADING_PCMCIA */
	36
	37	//libsmooth
	38	/* TR_INTERFACE */
	39	/* TR_ENTER_THE_IP_ADDRESS_INFORMATION */
	40	/* TR_STATIC */
	41	/* TR_DHCP_HOSTNAME */
	42	/* TR_IP_ADDRESS_PROMPT */
	43	/* TR_NETMASK_PROMPT */
	44	/* TR_INVALID_FIELDS */
	45	/* TR_IP_ADDRESS_CR */
	46	/* TR_NETWORK_MASK_CR */
	47	/* TR_DHCP_HOSTNAME_CR */
	48	/* TR_LOOKING_FOR_NIC */
	49	/* TR_MANUAL */
	50	/* TR_SELECT_NETWORK_DRIVER */
	51	/* TR_SELECT_NETWORK_DRIVER_LONG */
	52	/* TR_UNABLE_TO_LOAD_DRIVER_MODULE */
	53	/* TR_THIS_DRIVER_MODULE_IS_ALREADY_LOADED */
	54	/* TR_MODULE_PARAMETERS */
	55	/* TR_LOADING_MODULE */
	56	/* TR_MODULE_NAME_CANNOT_BE_BLANK */
	57
	58	//upgrade 120
	59	/* TR_UNABLE_TO_OPEN_SETTINGS_FILE */
	60	/* TR_DOMAINNAME */
	61	/* TR_ENTER_DOMAINNAME */
	62	/* TR_DOMAINNAME_CANNOT_CONTAIN_SPACES */
	63	/* TR_UNABLE_TO_MOUNT_PROC_FILESYSTEM */
	64	/* TR_UNABLE_TO_WRITE_ETC_FSTAB */
65
66	// dir to find files, chrooted or not...
67	#define TMP_EXTRACT_CH "/tmp/ipcop"
68	#define TMP_EXTRACT "/harddisk" TMP_EXTRACT_CH
69	#define MOUNT_BACKUP_CH "/mnt/usb"
70	#define MOUNT_BACKUP "/harddisk" MOUNT_BACKUP_CH
71	/*
72	return 0 when dev contains a backup set
73	leave dev mounted
74	*/
75	int try_mount (char dev, char testfile) {
76	char commandstring[STRING_SIZE];
77	mysystem("/bin/umount " MOUNT_BACKUP);
78	sprintf(commandstring, "/bin/mount -t vfat -o ro %s " MOUNT_BACKUP, dev);
79	mysystem(commandstring);
80
81	/verify it's what we want /
82	sprintf(commandstring, MOUNT_BACKUP "/%s.dat", testfile);
83	FILE *handle = fopen(commandstring, "r");
84	if (handle == NULL) {
85	return 1; /* bad disk ! */
86	}
87	fclose(handle);
88
89	handle = fopen(MOUNT_BACKUP "/backup.key", "r");
90	if (handle == NULL) {
91	return 1; /* bad disk ! */
92	}
93	fclose(handle);
94	return 0; //success
95	}
96
97	/* try to mount usb device until backup.tgz is found except the
98	destination device (scsi names are identical with usb key)
99	check "sda sdb sdc sdd"
100	*/
101	int mountbackup (char testfile, char destination_device) {
102	char sourcedev[30];
103	char i,j;
104	for (i = 'a'; i < 'e'; i++) {
105	sprintf (sourcedev,"/dev/sd%c ",i);
106	if (strcmp (destination_device, sourcedev) != 0) {
107	if (!try_mount (sourcedev, testfile)) return 0;
108	}
109	for (j = '1'; j < '5'; j++) {
110	sourcedev[8] = j;
111	if (strcmp (destination_device, sourcedev) != 0) {
112	if (!try_mount (sourcedev, testfile)) return 0;
113	}
114	}
115	}
116	return 1;
117	}
118
119	int floppy_locate() {
120	/* Temporarily mount /proc under /harddisk/proc,
121	run updfstab to locate the floppy, and unmount /harddisk/proc
122	again. This should be run each time the user tries to restore
123	so it can properly detect removable devices */
124	if (mysystem("/bin/mount -n -t proc /proc /harddisk/proc")) {
125	errorbox(ctr[TR_UNABLE_TO_MOUNT_PROC_FILESYSTEM]);
126	return 1;
127	}
128	if (mysystem("/bin/chroot /harddisk /usr/sbin/updfstab")) {
129	errorbox(ctr[TR_UNABLE_TO_WRITE_ETC_FSTAB]);
130	return 1;
131	}
132	mysystem("/bin/umount /harddisk/proc");
133	return 0;
134	}
135
136	/* Check the SQUID acl file exists, if not use our 1.4 copy */
137	void fixup_squidacl() {
138	FILE *aclreadfile;
139	if ((aclreadfile = fopen ("/harddisk" CONFIG_ROOT "/proxy/acl", "r"))) {
140	unlink ("/harddisk" CONFIG_ROOT "/proxy/acl-1.4");
141	fclose(aclreadfile);
142	} else {
143	rename ("/harddisk" CONFIG_ROOT "/proxy/acl-1.4",
144	"/harddisk" CONFIG_ROOT "/proxy/acl");
145	}
146	chown ("/harddisk" CONFIG_ROOT "/proxy/acl", 99, 99);
147	}
148	/* if we detected SCSI then fixup */
149	void fixup_initrd() {
150	FILE *handle;
151	char line[STRING_SIZE];
152	char commandstring[STRING_SIZE];
153
154	if (!(handle = fopen("/scsidriver", "r")))
155	return;
156
157	char *driver;
158	fgets(line, STRING_SIZE-1, handle);
159	fclose(handle);
160	line[strlen(line) - 1] = 0;
161	driver = strtok(line, ".");
162	fprintf(flog, "Detected SCSI driver %s\n", driver);
163	if (!strlen(driver) > 1)
164	return;
165
fd4e5787	166	fprintf(flog, "Fixing up ipfirerd.img\n");
d6aaa55d MT	167	mysystem("/bin/chroot /harddisk /sbin/modprobe loop");
	168	mkdir("/harddisk/initrd", S_IRWXU\|S_IRWXG\|S_IRWXO);
	169	sprintf(commandstring, "/bin/chroot /harddisk /sbin/mkinitrd"
	170	" --with=scsi_mod --with=%s --with=sd_mod"
	171	" --with=sr_mod --with=libata"
fd4e5787	172	" --with=ataraid /boot/ipfirerd.img "KERNEL_VERSION,
d6aaa55d MT	173	driver );
	174	runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
	175	#ifdef __i386__
	176	sprintf(commandstring, "/bin/chroot /harddisk /sbin/mkinitrd"
	177	" --with=scsi_mod --with=%s --with=sd_mod"
	178	" --with=sr_mod --with=libata"
fd4e5787	179	" --with=ataraid /boot/ipfirerd-smp.img "KERNEL_VERSION"-smp",
d6aaa55d MT	180	driver );
	181	runcommandwithstatus(commandstring, ctr[TR_BUILDING_INITRD]);
	182	mysystem("/bin/chroot /harddisk /bin/mv /boot/grub/scsigrub.conf /boot/grub/grub.conf");
	183	#endif
	184	#ifdef __alpha__
	185	runcommandwithstatus("/bin/chroot /harddisk /bin/mv /boot/etc/scsiaboot.conf /boot/etc/aboot.conf", ctr[TR_BUILDING_INITRD]);
	186	#endif
	187	}
	188	/* when backup is ready in tmpdir, move files to definitive location */
	189	void do_copy_files() {
	190	mysystem("/bin/chroot /harddisk /bin/cp -af "TMP_EXTRACT_CH"/. /");
	191	/* Upgrade necessary files from v1.2 to v1.3 to v1.4 */
	192	upgrade_v12_v13();
	193	upgrade_v130_v140();
	194	/* Upgrade configuration files starting from 1.4.11 */
	195	mysystem("/bin/chroot /harddisk /usr/local/bin/upgrade");
	196	}
	197
	198	int main(int argc, char *argv[]) {
	199	#define LANG argv[1]
	200	#define DEST_DEV argv[2]
	201	#define WGET argv[3]
	202
	203	#ifdef LANG_EN_ONLY
	204	char **langtrs[] = { en_tr, NULL };
1217aa01	205	#elifdef LANG_ALL
d6aaa55d	206	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, sk_tr, so_tr, fi_tr, sv_tr, tr_tr, vi_tr, NULL };
1217aa01 HS	207	#else
1217aa01 HS	208	char **langtrs[] = { de_tr, en_tr, NULL };
d6aaa55d MT	209	#endif
	210	char message[1000];
	211	char title[STRING_SIZE];
	212	char commandstring[STRING_SIZE];
	213
	214	setlocale (LC_ALL, "");
	215	/* Log file/terminal stuff. */
	216	mylog = "/dev/tty2";
	217	ctr = langtrs[ atoi(LANG) ];
	218
	219	if (!(flog = fopen(mylog, "w+")))
	220	{
	221	printf("Couldn't open log terminal\n");
	222	return 0;
	223	}
	224	fprintf(flog, "Install2 program started.\n");
	225	newtInit();
	226	newtCls();
	227	strcpy (title, NAME " v" VERSION " - " SLOGAN);
	228	newtDrawRootText(14, 0, title);
	229	newtPushHelpLine(ctr[TR_HELPLINE]);
	230
	231	/* working dirs... */
	232	mkdir(MOUNT_BACKUP, S_IRWXU\|S_IRWXG\|S_IRWXO);
	233
	234	//create the GUI screen and objects
	235	newtComponent form, header, labelfile, labelkey, file, key, radio0, radio1, radio2, radio3, radio4, ok;
	236
	237	newtCenteredWindow (55,20,ctr[TR_RESTORE]);
	238	form = newtForm (NULL, NULL,0);
	239
	240	sprintf(message, ctr[TR_RESTORE_CONFIGURATION], NAME);
	241	header = newtTextboxReflowed (2,1,message,51,0,0,0);
	242	newtFormAddComponent(form, header);
	243
	244	// The four method of restauration
	245	int start1=1, start2=0, start3=0, start4=0;
	246	radio1 = newtRadiobutton (17, 5, ctr[TR_SKIP], start1, NULL);
	247	radio2 = newtRadiobutton (17, 6, "Floppy (legacy)", start2, radio1);
	248	radio3 = newtRadiobutton (17, 7, "Usb-storage/CDROM", start3, radio2);
	249	if (strcmp(WGET,"none"))
	250	radio4 = newtRadiobutton (17, 8, "HTTP/FTP", start4, radio3);
	251	else
	252	radio4 = NULL;
	253	newtFormAddComponents(form, radio1, radio2, radio3, radio4, NULL);
	254
	255	// The optionnal filename for 'backup'
	256	labelfile=newtTextbox(12, 10, 35, 1, 0);
	257	newtTextboxSetText (labelfile, "Filename");
	258	newtFormAddComponent(form, labelfile);
	259	char *filevalue;
	260	char fileinit[STRING_SIZE] = "backup";
	261	file = newtEntry (17, 11, fileinit, 20, &filevalue, 0);
	262	newtFormAddComponent(form, file);
	263
	264	// The optionnal password for the key
	265	labelkey=newtTextbox(12, 13, 35, 1, 0);
	266	newtTextboxSetText (labelkey, "Backup key password");
	267	newtFormAddComponent(form, labelkey);
	268	char *keyvalue;
	269	char keyinit[STRING_SIZE] = "";
	270	key = newtEntry (17, 14, keyinit, 20, &keyvalue, 0);
	271	newtFormAddComponent(form, key);
	272
273	// The OK button
274	ok=newtButton (23, 16, ctr[TR_OK]);
275	newtFormAddComponent(form, ok);
276
277	/* loop until succeeds or user skips out */
278	int retcode = -1;
279	while ( retcode<0 ) {
280
281	// run the windows
282	struct newtExitStruct reponse;
283	newtFormRun (form, &reponse);
284	radio0 = newtRadioGetCurrent(radio1);
285	int radio;
286	radio = radio0 == radio1 ? 1 : radio0 == radio2 ? 2 : radio0 == radio3 ? 3 : radio0 == radio4 ? 4 : 0;
287	strcpy(keyinit,keyvalue); //reuse actual value
288	strcpy(fileinit,filevalue);
289
290	if (radio==1) {
291	retcode = 1; // no restore: nothing special
292	break; // out of the while loop
293	}
294
295	mkdir(TMP_EXTRACT, S_IRWXU\|S_IRWXG\|S_IRWXO);
296	statuswindow(45, 4, title, ctr[TR_INSTALLING_FILES]);
297	switch (radio) {
298	case 4: // network
299	sprintf(commandstring,"/bin/wget -P " TMP_EXTRACT " %s/%s.dat", WGET, filevalue);
300	mysystem (commandstring);
301	sprintf(commandstring,"/bin/wget -P " TMP_EXTRACT " %s/%s.key", WGET, filevalue);
302	if (mysystem (commandstring)) {
303	errorbox(ctr[TR_FAILED_TO_FIND]);
304	break;
305	};
306	goto COMMON;
307	case 3: // normal backup
308	if (mountbackup( filevalue, DEST_DEV )) {
309	errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);//mess=no device with backup found
310	break;
311	};
312	// link files to a COMMON location
313	sprintf (commandstring, "chroot /harddisk ln -s "MOUNT_BACKUP_CH"/%s.dat " TMP_EXTRACT_CH "/%s.dat", filevalue, filevalue);
314	mysystem (commandstring);
315	sprintf (commandstring, "chroot /harddisk ln -s "MOUNT_BACKUP_CH"/%s.key " TMP_EXTRACT_CH "/%s.key", filevalue, filevalue);
316	mysystem (commandstring);
317
318	COMMON: // DECRYPT THE TARBALL
319	// Copy the key to a new location because we decrypt it!
320	if (strcmp(keyvalue, "")) { // password provided: decrypt the key
321	sprintf(commandstring, "/bin/chroot /harddisk /usr/bin/openssl enc"
322	" -a -d -aes256 -salt"
323	" -pass pass:%s"
324	" -in " TMP_EXTRACT_CH "/%s.key"
325	" -out " TMP_EXTRACT_CH "/__tmp.key",
326	keyvalue, filevalue);
327	} else { //just copy to new name
328	sprintf(commandstring, "/bin/chroot /harddisk cp"
329	" " TMP_EXTRACT_CH "/%s.key"
330	" " TMP_EXTRACT_CH "/__tmp.key",
331	filevalue);
332	}
333	mysystem (commandstring);
334
335	sprintf(commandstring, "/bin/chroot /harddisk /usr/bin/openssl des3"
336	" -d -salt"
337	" -in " TMP_EXTRACT_CH "/%s.dat"
338	" -out " TMP_EXTRACT_CH "/backup.tgz"
339	" -kfile " TMP_EXTRACT_CH "/__tmp.key",
340	filevalue);
341
342	if (mysystem (commandstring)) {
343	errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);//mess=decrypt error:invalid key?
344	break;
345	}
346	strcpy(commandstring, "/bin/chroot /harddisk /bin/tar"
347	" -X " CONFIG_ROOT "/backup/exclude.system"
348	" -C " TMP_EXTRACT_CH
349	" -xzf " TMP_EXTRACT_CH "/backup.tgz");
350
351	if (mysystem(commandstring)) {
352	errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
353	break;
354	}
355	sprintf(commandstring, TMP_EXTRACT "/%s.dat", filevalue);
356	unlink(commandstring ); //dont need them anymore
357	unlink( TMP_EXTRACT "/backup.tgz");
358	sprintf(commandstring, TMP_EXTRACT "/%s.key", filevalue);
359	unlink(commandstring );
360	unlink( TMP_EXTRACT "/__tmp.key");
361
362	/* Now copy to correct location */
363	do_copy_files();
364	retcode = 0; /* successfully restored */
365	break;
366	case 2:
367	// diskette change
368	if (floppy_locate()) {
369	retcode = 2; // this an error!
370	break;
371	}
372
373	/* Always extract to /tmp/ipcop for temporary extraction
374	just in case floppy fails.
375	try a compressed backup first because it's quicker to fail.
376	In exclude.system, files name must be without leading / or
377	on extraction, name will never match
378	*/
379	sprintf(commandstring,
380	"/bin/chroot /harddisk /bin/tar -X " CONFIG_ROOT "/backup/exclude.system -C "TMP_EXTRACT_CH" -xvzf /dev/floppy > %s 2> /dev/null", mylog);
381	if (system(commandstring)) {
382	/* if it's not compressed, try uncompressed first before failing*/
383	sprintf(commandstring,
384	"/bin/chroot /harddisk /bin/tar -X " CONFIG_ROOT "/backup/exclude.system -C "TMP_EXTRACT_CH" -xvf /dev/floppy > %s 2> /dev/null", mylog);
385	if (system(commandstring)) {
386	/* command failed trying to read from floppy */
387	errorbox(ctr[TR_UNABLE_TO_INSTALL_FILES]);
388	break;
389	}
390	}
391	/* Now copy to correct location */
392	do_copy_files();
393	retcode = 0; /* successfully restored */
394	}//switch
395	/* remove possible badly restored files */
396	mysystem("/bin/chroot /harddisk /bin/rm -rf " TMP_EXTRACT_CH );
397	newtPopWindow(); // close windows
398	}//while
399	newtFormDestroy(form);
400
401	/* cleanup */
402	mysystem("/bin/umount " MOUNT_BACKUP);
403	mysystem("/bin/chroot /harddisk /bin/rmdir " MOUNT_BACKUP_CH);
404
405	/* others operations moved from install to install2 */
406	fixup_squidacl();
407	fixup_initrd();
408
409	fprintf(flog, "Install2 program ended.\n");
410	fflush(flog);
411	fclose(flog);
412	newtFinished();
413	return retcode;
414	}
415