Context Navigation

source: MondoRescue/branches/2.2.9/mondo/src/mondorestore/mondo-rstr-tools.c@ 2195

Visit:

Last change on this file since 2195 was 2195, checked in by Bruno Cornec, 15 years ago
-Werror=format-security option used only for gcc >= 4.2 fix compiler issue and one warning
Property svn:keywords set to `Id`
File size: 74.5 KB

Rev	Line
[1]	1	/***************************************************************************
[2029]	2	$Id: mondo-rstr-tools.c 2195 2009-05-11 01:08:02Z bruno $
[1]	3
[2195]	4	***************************************************************************
[1242]	5	* *
	6	* This program is free software; you can redistribute it and/or modify *
	7	* it under the terms of the GNU General Public License as published by *
	8	* the Free Software Foundation; either version 2 of the License, or *
	9	* (at your option) any later version. *
	10	* *
	11	***************************************************************************/
[1]	12
	13	#include <pthread.h>
[1846]	14	#include <linux/fd.h>
[1930]	15	#include "my-stuff.h"
[1]	16	#include "../common/mondostructures.h"
	17	#include "../common/libmondo.h"
	18	#include "mr-externs.h"
	19	#include "mondo-rstr-tools.h"
	20
[2029]	21	/**
	22	* The biggielist stub (appended to the directory where all.tar.gz was unpacked).
	23	*/
	24	#define BIGGIELIST_TXT_STUB "tmp/biggielist.txt"
	25
	26	/**
	27	* The filelist stub (appended to the directory where all.tar.gz was unpacked).
	28	*/
	29	#define FILELIST_FULL_STUB "tmp/filelist.full.gz"
	30
	31	/**
	32	* The mountlist stub (appended to the directory where all.tar.gz was unpacked).
	33	*/
	34	#define MOUNTLIST_FNAME_STUB "tmp/mountlist.txt"
	35
	36	/**
	37	* The mondo-restore.cfg stub (appended to the directory where all.tar.gz was unpacked).
	38	*/
	39	#define MONDO_CFG_FILE_STUB "tmp/mondo-restore.cfg"
	40	/**
	41	* The i-want-my-lvm stub
	42	*/
	43	#define IWANTMYLVM_STUB "tmp/i-want-my-lvm"
	44
[128]	45	extern bool g_ISO_restore_mode; /* are we in Iso Mode? */
[1]	46	extern bool g_I_have_just_nuked;
[2030]	47	/*
[1]	48	extern char *g_tmpfs_mountpt;
[2030]	49	*/
[1]	50	extern char *g_isodir_device;
	51	extern char *g_isodir_format;
	52	extern long g_current_progress, g_maximum_progress;
[128]	53	extern char *g_biggielist_txt; // where 'biggielist.txt' is stored, on ramdisk / tempdir;
[1242]	54	// biggielist.txt is the list of big files stored on the
	55	// backup media set in question
[128]	56	extern char *g_filelist_full; // filelist.full.gz is the list of all regular files
[1242]	57	// (excluding big files) stored on the backup media set
[128]	58	extern char *g_biggielist_pot; // list of big files which _could_ be restored, if the
[1242]	59	// user chooses them
[128]	60	extern char *g_filelist_imagedevs; // list of devices (e.g. /dev/hda1, /dev/sda5) which
[1242]	61	// were archived as images, not just /dev entries
	62	// ... e.g. NTFS, BeOS partitions
[128]	63	extern char *g_imagedevs_restthese; // of the imagedevs listed in FILELIST_IMAGEDEVS,
[1242]	64	// restore only these
[128]	65	extern char g_mondo_cfg_file; // where mndo-restore.cfg (the config file) is stored
	66	extern char *g_mountlist_fname; // where mountlist.txt (the mountlist file) is stored
	67	extern char *g_mondo_home; // homedir of Mondo; usually /usr/local/share/mondo
[1]	68
	69	extern t_bkptype g_backup_media_type;
	70
	71	extern int g_partition_table_locked_up;
[1316]	72	extern char *MONDO_LOGFILE;
[1]	73
[1645]	74	/* Reference to global bkpinfo */
	75	extern struct s_bkpinfo *bkpinfo;
	76
[949]	77	/* Should we use or not extended attributes and acl when restoring */
	78	char *g_getfattr = NULL;
	79	char *g_getfacl = NULL;
	80
[1850]	81	extern void kill_anything_like_this(char *str);
[1968]	82	extern int skip_obdr(void);
[2022]	83	extern int set_tape_block_size_with_mt(long internal_tape_block_size);
[1850]	84
[1]	85	/**
[1242]	86	* @addtogroup restoreUtilityGroup
	87	* @{
	88	*/
[1]	89	/**
[1242]	90	* Free the malloc()s for the filename variables.
	91	*/
[1967]	92	void free_MR_global_filenames(void)
[1]	93	{
[1242]	94	paranoid_free(g_biggielist_txt);
	95	paranoid_free(g_filelist_full);
	96	paranoid_free(g_filelist_imagedevs);
	97	paranoid_free(g_imagedevs_restthese);
	98	paranoid_free(g_mondo_cfg_file);
	99	paranoid_free(g_mountlist_fname);
	100	paranoid_free(g_mondo_home);
[2030]	101	/*
[1242]	102	paranoid_free(g_tmpfs_mountpt);
[2030]	103	*/
[1242]	104	paranoid_free(g_isodir_device);
	105	paranoid_free(g_isodir_format);
[1]	106
	107	}
	108
	109
	110
	111	/**
[1242]	112	* Ask the user which imagedevs from the list contained in @p infname should
	113	* actually be restored.
	114	* @param infname The file containing a list of all imagedevs.
	115	* @param outfname The location of the output file containing the imagedevs the user wanted to restore.
	116	* @ingroup restoreUtilityGroup
	117	*/
[128]	118	void ask_about_these_imagedevs(char infname, char outfname)
[1]	119	{
[1242]	120	FILE *fin;
	121	FILE *fout;
	122	/************************************************************************
	123	* allocate memory regions. test and set -sab 16 feb 2003 *
	124	************************************************************************/
	125	char *incoming_ptr;
	126	char *question_ptr;
[1]	127
[1242]	128	char incoming[MAX_STR_LEN] = "\0";
	129	char question[MAX_STR_LEN];
[1]	130
[1242]	131	assert_string_is_neither_NULL_nor_zerolength(infname);
	132	assert_string_is_neither_NULL_nor_zerolength(outfname);
[1]	133
[1242]	134	incoming_ptr = malloc(sizeof(incoming));
	135	if (incoming_ptr == NULL) {
	136	fprintf(stderr, "Out of Memory\n");
	137	exit(EXIT_FAILURE);
	138	}
[1]	139
[1242]	140	question_ptr = malloc(sizeof(question));
	141	if (question_ptr == NULL) {
	142	fprintf(stderr, "Out of Memory\n");
	143	exit(EXIT_FAILURE);
	144	}
[1]	145
[1242]	146	memset(incoming_ptr, '\0', sizeof(incoming));
	147	memset(question_ptr, '\0', sizeof(question));
[1]	148
	149
	150
[1242]	151	if (!(fin = fopen(infname, "r"))) {
	152	fatal_error("Cannot openin infname");
	153	}
	154	if (!(fout = fopen(outfname, "w"))) {
	155	fatal_error("Cannot openin outfname");
	156	}
	157	for (fgets(incoming_ptr, MAX_STR_LEN, fin);
	158	!feof(fin); fgets(incoming_ptr, MAX_STR_LEN, fin)) {
	159	strip_spaces(incoming_ptr);
[1]	160
[1242]	161	if (incoming[0] == '\0') {
	162	continue;
	163	}
[1]	164
[1242]	165	sprintf(question_ptr,
	166	"Should I restore the image of %s ?", incoming_ptr);
[128]	167
[1242]	168	if (ask_me_yes_or_no(question_ptr)) {
	169	fprintf(fout, "%s\n", incoming_ptr);
	170	}
	171	}
[128]	172
[1242]	173	/* free memory *********/
	174	paranoid_free(incoming_ptr);
	175	incoming_ptr = NULL;
	176	paranoid_free(question_ptr);
	177	question_ptr = NULL;
[1]	178
[128]	179
[1242]	180	paranoid_fclose(fout);
	181	paranoid_fclose(fin);
[1]	182	}
	183
	184	/**************************************************************************
[1242]	185	ASK_ABOUT_THESE_IMAGEDEVS
	186	**************************************************************************/
[1]	187
	188
	189
	190
	191
	192
	193
	194
	195	/**
[1242]	196	* Extract @c mondo-restore.cfg and @c mountlist.txt from @p ramdisk_fname.
	197	* @param bkpinfo The backup information structure. @c tmpdir is the only field used.
	198	* @param ramdisk_fname The filename of the @b compressed ramdisk to look in.
	199	* @param output_cfg_file Where to put the configuration file extracted.
	200	* @param output_mountlist_file Where to put the mountlist file extracted.
	201	* @return 0 for success, nonzero for failure.
	202	* @ingroup restoreUtilityGroup
	203	*/
[1]	204
	205	/**
[1242]	206	* Keep trying to get mondo-restore.cfg from the archive, until the user gives up.
	207	*/
[1645]	208	void get_cfg_file_from_archive_or_bust()
[1]	209	{
[1645]	210	while (get_cfg_file_from_archive()) {
[1242]	211	if (!ask_me_yes_or_no
	212	("Failed to find config file/archives. Choose another source?"))
	213	{
	214	fatal_error("Could not find config file/archives. Aborting.");
[1]	215	}
[1645]	216	interactively_obtain_media_parameters_from_user(FALSE);
[1242]	217	}
	218	}
[1]	219
	220
	221	/**
[1242]	222	* Determine whether @p list_fname contains a line containing @p f.
	223	* @param f The line to search for.
	224	* @param list_fname The file to search in.
	225	* @param preamble Ignore this beginning part of @p f ("" to disable).
	226	* @return TRUE if it's in the list, FALSE if it's not.
	227	*/
[128]	228	bool is_file_in_list(char f, char list_fname, char *preamble)
[1]	229	{
	230
[1242]	231	/ needs malloc /
	232	char *command;
	233	char *file;
	234	char *tmp;
	235	int res;
[1]	236
[1242]	237	malloc_string(command);
	238	malloc_string(file);
	239	malloc_string(tmp);
	240	assert_string_is_neither_NULL_nor_zerolength(f);
	241	assert_string_is_neither_NULL_nor_zerolength(list_fname);
	242	assert(preamble != NULL);
[1]	243
[1242]	244	if (strncmp(preamble, f, strlen(preamble)) == 0) {
	245	strcpy(file, f + strlen(preamble));
	246	} else {
	247	strcpy(file, f);
[1]	248	}
[1242]	249	if (file[0] == '/' && file[1] == '/') {
	250	strcpy(tmp, file);
	251	strcpy(file, tmp + 1);
	252	}
	253	sprintf(tmp,
	254	"Checking to see if f=%s, file=%s, is in the list of biggiefiles",
	255	f, file);
	256	log_msg(2, tmp);
	257	sprintf(command, "grep -E '^%s$' %s", file, list_fname);
	258	res = run_program_and_log_output(command, FALSE);
	259	paranoid_free(command);
	260	paranoid_free(file);
	261	paranoid_free(tmp);
	262	if (res) {
	263	return (FALSE);
	264	} else {
	265	return (TRUE);
	266	}
	267	}
[128]	268
[1]	269	/**************************************************************************
[1242]	270	END_IS_FILE_IN_LIST
	271	**************************************************************************/
[1]	272
	273
	274
	275	/**
[1242]	276	* Set up an ISO backup.
	277	* @param bkpinfo The backup information structure. Fields used:
	278	* - @c bkpinfo->backup_media_type
	279	* - @c bkpinfo->disaster_recovery
	280	* - @c bkpinfo->isodir
	281	* @param nuke_me_please If TRUE, we're in nuke mode; if FALSE we're in interactive mode.
	282	* @return 0 for success, nonzero for failure.
	283	*/
[1645]	284	int iso_fiddly_bits(bool nuke_me_please)
[1]	285	{
[1242]	286	char mount_isodir_command, tmp, *command;
	287	int retval = 0, i;
	288	bool already_mounted = FALSE;
[1]	289
[1242]	290	assert(bkpinfo != NULL);
	291	malloc_string(mount_isodir_command);
	292	malloc_string(tmp);
	293	malloc_string(command);
	294	g_ISO_restore_mode = TRUE;
	295	read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
	296	if (bkpinfo->disaster_recovery) {
[1]	297	/* Patch Conor Daly 26-june-2004
[1242]	298	* Don't let this clobber an existing bkpinfo->isodir */
	299	if (!bkpinfo->isodir[0]) {
	300	strcpy(bkpinfo->isodir, "/tmp/isodir");
	301	}
[1]	302	/* End patch */
[1242]	303	sprintf(command, "mkdir -p %s", bkpinfo->isodir);
	304	run_program_and_log_output(command, 5);
	305	log_msg(2, "Setting isodir to %s", bkpinfo->isodir);
	306	}
[1]	307
[1242]	308	if (!get_isodir_info
	309	(g_isodir_device, g_isodir_format, bkpinfo->isodir,
	310	nuke_me_please)) {
	311	return (1);
	312	}
	313	paranoid_system("umount " MNT_CDROM " 2> /dev/null"); /* just in case */
[1]	314
[1242]	315	if (is_this_device_mounted(g_isodir_device)) {
	316	log_to_screen("WARNING - isodir is already mounted");
	317	already_mounted = TRUE;
	318	} else {
	319	sprintf(mount_isodir_command, "mount %s", g_isodir_device);
	320	if (strlen(g_isodir_format) > 1) {
	321	sprintf(mount_isodir_command + strlen(mount_isodir_command),
	322	" -t %s", g_isodir_format);
[1]	323	}
[1242]	324	strcat(mount_isodir_command, " -o ro ");
	325	strcat(mount_isodir_command, bkpinfo->isodir);
	326	run_program_and_log_output("df -m", FALSE);
	327	sprintf(tmp,
	328	"The 'mount' command is '%s'. PLEASE report this command to be if you have problems, ok?",
	329	mount_isodir_command);
	330	log_msg(1, tmp);
	331	if (run_program_and_log_output(mount_isodir_command, FALSE)) {
	332	popup_and_OK
	333	("Cannot mount the device where the ISO files are stored.");
	334	return (1);
	335	}
	336	log_to_screen
	337	("I have mounted the device where the ISO files are stored.");
	338	}
	339	if (!IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
[1736]	340	mount_media();
[1242]	341	}
[1736]	342	i = what_number_cd_is_this(); /* has the side-effect of calling mount_media() */
[1242]	343	sprintf(tmp, "%s #%d has been mounted via loopback mount",
	344	media_descriptor_string(bkpinfo->backup_media_type), i);
	345	log_msg(1, tmp);
	346	if (i < 0) {
	347	popup_and_OK
	348	("Cannot find ISO images in the directory you specified.");
	349	retval = 1;
	350	}
	351	log_msg(2, "%ld: bkpinfo->isodir is now %s", __LINE__,
	352	bkpinfo->isodir);
	353	paranoid_free(mount_isodir_command);
	354	paranoid_free(tmp);
	355	paranoid_free(command);
	356	return (retval);
	357	}
[1]	358
	359
	360
	361
	362	/**
[1242]	363	* Kill all Petris processes.
	364	*/
[1850]	365	void kill_petris(void) {
[1852]	366	kill_anything_like_this("petris");
[1]	367	}
[128]	368
[1]	369	/**************************************************************************
[1242]	370	END_KILL_PETRIS
	371	**************************************************************************/
[1]	372
	373
	374	/**
[1843]	375	* Mount @p device at @p mpt as @p format.
	376	* @param device The device (/dev entry) to mount.
	377	* @param mpt The directory to mount it on.
	378	* @param format The filesystem type of @p device.
	379	* @param writeable If TRUE, mount read-write; if FALSE, mount read-only.
	380	* @return 0 for success, nonzero for failure.
	381	*/
[1771]	382	int mount_device(char device, char mpt, char *format, bool writeable)
	383	{
	384	int res = 0;
	385
	386	/ malloc /
	387	char tmp, command, mountdir, mountpoint, *additional_parameters;
	388
	389	assert_string_is_neither_NULL_nor_zerolength(device);
	390	assert_string_is_neither_NULL_nor_zerolength(mpt);
	391	assert(format != NULL);
	392	malloc_string(tmp);
	393	malloc_string(command);
	394	malloc_string(mountdir);
	395	malloc_string(mountpoint);
	396	malloc_string(additional_parameters);
	397
[1843]	398	if (!strcmp(mpt, "/1")) {
	399	strcpy(mountpoint, "/");
	400	log_msg(3, "Mommm! SME is being a dildo!");
	401	} else {
	402	strcpy(mountpoint, mpt);
	403	}
[1771]	404
[1843]	405	if (!strcmp(mountpoint, "lvm")) {
	406	return (0);
	407	}
	408	if (!strcmp(mountpoint, "image")) {
	409	return (0);
	410	}
	411	sprintf(tmp, "Mounting device %s ", device);
	412	log_msg(1, tmp);
[1937]	413	/* Deal with additional params only if not /proc or /sys */
	414	if (strcmp(format, "proc") && strcmp(format, "sys")) {
	415	if (writeable) {
	416	strcpy(additional_parameters, "-o rw");
	417	} else {
	418	strcpy(additional_parameters, "-o ro");
	419	}
	420	if (find_home_of_exe("setfattr")) {
	421	strcat(additional_parameters, ",user_xattr");
	422	}
	423	if (find_home_of_exe("setfacl")) {
	424	strcat(additional_parameters, ",acl");
	425	}
[1843]	426	}
[1771]	427
	428	if (!strcmp(mountpoint, "swap")) {
[1843]	429	sprintf(command, "swapon %s", device);
[1771]	430	} else {
[1843]	431	if (!strcmp(mountpoint, "/")) {
	432	strcpy(mountdir, MNT_RESTORING);
	433	} else {
	434	sprintf(mountdir, "%s%s", MNT_RESTORING, mountpoint);
	435	}
	436	sprintf(command, "mkdir -p %s", mountdir);
	437	run_program_and_log_output(command, FALSE);
	438	sprintf(command, "mount -t %s %s %s %s 2>> %s", format, device,
	439	additional_parameters, mountdir, MONDO_LOGFILE);
	440	log_msg(2, "command='%s'", command);
	441	}
	442
	443	res = run_program_and_log_output(command, TRUE);
	444	if (res && (strstr(command, "xattr") \|\| strstr(command, "acl"))) {
	445	log_msg(1, "Re-trying without the fancy extra parameters");
	446	sprintf(command, "mount -t %s %s %s 2>> %s", format, device,
	447	mountdir, MONDO_LOGFILE);
[1771]	448	res = run_program_and_log_output(command, TRUE);
[1843]	449	}
	450	if (res) {
	451	log_msg(1, "Unable to mount device %s (type %s) at %s", device,
	452	format, mountdir);
	453	log_msg(1, "command was '%s'", command);
	454	if (!strcmp(mountpoint, "swap")) {
	455	log_to_screen(tmp);
[1771]	456	} else {
[1843]	457	log_msg(2, "Retrying w/o the '-t' switch");
	458	sprintf(command, "mount %s %s 2>> %s", device, mountdir,
	459	MONDO_LOGFILE);
	460	log_msg(2, "2nd command = '%s'", command);
	461	res = run_program_and_log_output(command, TRUE);
	462	if (res == 0) {
	463	log_msg(1,
	464	"That's OK. I called mount w/o a filesystem type and it worked fine in the end.");
	465	} else {
	466	log_to_screen(tmp);
	467	}
[1771]	468	}
	469	}
	470
[1843]	471	if (res && !strcmp(mountpoint, "swap")) {
	472	log_msg(2, "That's ok. It's just a swap partition.");
	473	log_msg(2, "Non-fatal error. Returning 0.");
	474	res = 0;
	475	}
	476
[1771]	477	paranoid_free(tmp);
	478	paranoid_free(command);
	479	paranoid_free(mountdir);
	480	paranoid_free(mountpoint);
	481	paranoid_free(additional_parameters);
	482
[1843]	483	return (res);
[1771]	484	}
	485	/**************************************************************************
[1843]	486	END_MOUNT_DEVICE
[1771]	487	**************************************************************************/
	488
	489
	490	/**
[1843]	491	* Mount all devices in @p p_external_copy_of_mountlist on @p MNT_RESTORING.
	492	* @param p_external_copy_of_mountlist The mountlist containing devices to be mounted.
	493	* @param writeable If TRUE, then mount read-write; if FALSE mount read-only.
	494	* @return The number of errors encountered (0 for success).
	495	*/
[128]	496	int mount_all_devices(struct mountlist_itself
[1843]	497	*p_external_copy_of_mountlist, bool writeable)
[1]	498	{
[1242]	499	int retval = 0, lino, res;
	500	char tmp, these_failed, *format;
[1843]	501	struct mountlist_itself *mountlist = NULL;
[1]	502
[1242]	503	malloc_string(tmp);
	504	malloc_string(format);
	505	malloc_string(these_failed);
[1843]	506	/ menset /
	507	these_failed[0] = '\0';
	508
[1242]	509	assert(p_external_copy_of_mountlist != NULL);
	510	mountlist = malloc(sizeof(struct mountlist_itself));
	511	memcpy((void ) mountlist, (void ) p_external_copy_of_mountlist,
	512	sizeof(struct mountlist_itself));
[1843]	513	sort_mountlist_by_mountpoint(mountlist, 0);
[1]	514
	515
[1843]	516	mvaddstr_and_log_it(g_currentY, 0, "Mounting devices ");
	517	open_progress_form("Mounting devices",
[1242]	518	"I am now mounting all the drives.",
	519	"This should not take long.",
	520	"", mountlist->entries);
[128]	521
[1843]	522	for (lino = 0; lino < mountlist->entries; lino++) {
	523	if (!strcmp(mountlist->el[lino].device, "/proc")) {
	524	log_msg(1,
	525	"Again with the /proc - why is this in your mountlist?");
	526	} else if (is_this_device_mounted(mountlist->el[lino].device)) {
	527	sprintf(tmp, "%s is already mounted",
	528	mountlist->el[lino].device);
	529	log_to_screen(tmp);
	530	} else if (strcmp(mountlist->el[lino].mountpoint, "none")
[1242]	531	&& strcmp(mountlist->el[lino].mountpoint, "lvm")
	532	&& strcmp(mountlist->el[lino].mountpoint, "raid")
	533	&& strcmp(mountlist->el[lino].mountpoint, "image")) {
[1843]	534	sprintf(tmp, "Mounting %s", mountlist->el[lino].device);
	535	update_progress_form(tmp);
	536	strcpy(format, mountlist->el[lino].format);
	537	res = mount_device(mountlist->el[lino].device,
[1242]	538	mountlist->el[lino].mountpoint,
	539	format, writeable);
[1843]	540	retval += res;
	541	if (res) {
	542	strcat(these_failed, mountlist->el[lino].device);
	543	strcat(these_failed, " ");
	544	}
	545	}
	546	g_current_progress++;
[1]	547	}
[1843]	548	close_progress_form();
	549	if (retval) {
	550	if (g_partition_table_locked_up > 0) {
	551	log_to_screen
	552	("fdisk's ictol() call to refresh its copy of the partition table causes the kernel to");
	553	log_to_screen
	554	("lock up the partition table. You might have to reboot and use Interactive Mode to");
	555	log_to_screen
	556	("format and restore without partitioning first. Sorry for the inconvenience.");
	557	}
	558	sprintf(tmp, "Could not mount device(s) %s- shall I abort?",
	559	these_failed);
	560
	561	if (!ask_me_yes_or_no(tmp)) {
	562	retval = 0;
	563	log_to_screen
	564	("Continuing, although some device(s) failed to be mounted");
	565	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
	566	} else {
	567	mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
	568	log_to_screen
[1242]	569	("Unable to mount some or all of your partitions.");
[1843]	570	}
	571	} else {
	572	log_to_screen("All partitions were mounted OK.");
	573	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
	574	}
[1937]	575	/* Also mounting under MNT_RESTORING special FS */
	576	(void)mount_device("/proc","/proc","proc",TRUE);
	577	(void)mount_device("/sys","/sys","sysfs",TRUE);
[1843]	578	run_program_and_log_output("df -m", 3);
	579	paranoid_free(mountlist);
	580	paranoid_free(tmp);
	581	paranoid_free(format);
	582	paranoid_free(these_failed);
	583	return (retval);
[1242]	584	}
	585	/**************************************************************************
	586	END_MOUNT_ALL_DEVICES
	587	**************************************************************************/
[1]	588
	589
	590	/**
[1736]	591	* Mount the CD-ROM or USB device at /mnt/cdrom.
[1242]	592	* @param bkpinfo The backup information structure. Fields used:
	593	* - @c bkpinfo->backup_media_type
	594	* - @c bkpinfo->disaster_recovery
	595	* - @c bkpinfo->isodir
	596	* - @c bkpinfo->media_device
	597	* @return 0 for success, nonzero for failure.
	598	*/
[1736]	599	int mount_media()
[1]	600	{
[1242]	601	char *mount_cmd;
	602	int i, res;
[1]	603	#ifdef __FreeBSD__
[1242]	604	char mdd[32];
	605	char *mddev = mdd;
[1]	606	#endif
	607
[1242]	608	malloc_string(mount_cmd);
	609	assert(bkpinfo != NULL);
[1]	610
[1843]	611	if (bkpinfo->backup_media_type == tape
	612	\|\| bkpinfo->backup_media_type == udev) {
	613	log_msg(8, "Tape/udev. Therefore, no need to mount a media.");
	614	paranoid_free(mount_cmd);
	615	return 0;
	616	}
[1]	617
[1843]	618	if (!run_program_and_log_output("mount \| grep -F " MNT_CDROM, FALSE)) {
	619	log_msg(2, "mount_media() - media already mounted. Fair enough.");
	620	paranoid_free(mount_cmd);
	621	return (0);
	622	}
[1]	623
[1843]	624	if (bkpinfo->backup_media_type == nfs) {
	625	log_msg(2, "Mounting for NFS thingy");
	626	log_msg(2, "isodir = %s", bkpinfo->isodir);
	627	if ((!bkpinfo->isodir[0] \|\| !strcmp(bkpinfo->isodir, "/"))
	628	&& am_I_in_disaster_recovery_mode()) {
	629	strcpy(bkpinfo->isodir, "/tmp/isodir");
	630	log_msg(1, "isodir is being set to %s", bkpinfo->isodir);
	631	}
[1]	632	#ifdef __FreeBSD__
[1843]	633	sprintf(mount_cmd, "/mnt/isodir/%s/%s/%s-%d.iso", bkpinfo->isodir,
	634	bkpinfo->nfs_remote_dir, bkpinfo->prefix, g_current_media_number);
	635	mddev = make_vn(mount_cmd);
	636	sprintf(mount_cmd, "mount_cd9660 -r %s " MNT_CDROM, mddev);
[1]	637	#else
[1843]	638	sprintf(mount_cmd, "mount %s/%s/%s-%d.iso -t iso9660 -o loop,ro %s",
	639	bkpinfo->isodir, bkpinfo->nfs_remote_dir,
	640	bkpinfo->prefix, g_current_media_number, MNT_CDROM);
[1]	641	#endif
	642
[1843]	643	} else if (bkpinfo->backup_media_type == iso) {
[1]	644	#ifdef __FreeBSD__
[1843]	645	sprintf(mount_cmd, "%s/%s-%d.iso", bkpinfo->isodir,
	646	bkpinfo->prefix, g_current_media_number);
	647	mddev = make_vn(mount_cmd);
	648	sprintf(mount_cmd, "mount_cd9660 -r %s %s", mddev, MNT_CDROM);
[1]	649	#else
[1843]	650	sprintf(mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s",
	651	bkpinfo->isodir, bkpinfo->prefix, g_current_media_number, MNT_CDROM);
[1]	652	#endif
[1843]	653	} else if (bkpinfo->backup_media_type == usb) {
[1741]	654	sprintf(mount_cmd, "mount -t vfat %s %s", bkpinfo->media_device, MNT_CDROM);
[1843]	655	} else if (strstr(bkpinfo->media_device, "/dev/")) {
[1]	656	#ifdef __FreeBSD__
[1736]	657	sprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
[1242]	658	MNT_CDROM);
[1]	659	#else
[1736]	660	sprintf(mount_cmd, "mount %s -t iso9660 -o ro %s",
[1242]	661	bkpinfo->media_device, MNT_CDROM);
[1]	662	#endif
[1736]	663	} else {
[1843]	664	if (bkpinfo->disaster_recovery
	665	&& does_file_exist("/tmp/CDROM-LIVES-HERE")) {
	666	strcpy(bkpinfo->media_device,
	667	last_line_of_file("/tmp/CDROM-LIVES-HERE"));
	668	} else {
	669	find_cdrom_device(bkpinfo->media_device, TRUE);
	670	}
[1]	671
	672	#ifdef __FreeBSD__
[1738]	673	sprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
	674	MNT_CDROM);
[1]	675	#else
[1738]	676	sprintf(mount_cmd, "mount %s -t iso9660 -o ro %s",
	677	bkpinfo->media_device, MNT_CDROM);
[1]	678	#endif
[1843]	679	}
[1]	680
[1843]	681	log_msg(2, "(mount_media) --- command = %s", mount_cmd);
	682	for (i = 0; i < 2; i++) {
	683	res = run_program_and_log_output(mount_cmd, FALSE);
	684	if (!res) {
	685	break;
	686	} else {
	687	log_msg(2, "Failed to mount device.");
	688	sleep(5);
	689	run_program_and_log_output("sync", FALSE);
	690	}
	691	}
	692
	693	if (res) {
	694	log_msg(2, "Failed, despite %d attempts", i);
	695	} else {
	696	log_msg(2, "Mounted media drive OK");
	697	}
	698	paranoid_free(mount_cmd);
	699	return (res);
[1242]	700	}
[1]	701	/**************************************************************************
[1242]	702	END_MOUNT_CDROM
	703	**************************************************************************/
[1]	704
	705
	706
	707	/**
[1242]	708	* Fix some miscellaneous things in the filesystem so the system will come
	709	* up correctly on the first boot.
	710	*/
[128]	711	void protect_against_braindead_sysadmins()
[1]	712	{
[1242]	713	run_program_and_log_output("touch " MNT_RESTORING "/var/log/pacct",
	714	FALSE);
	715	run_program_and_log_output("touch " MNT_RESTORING "/var/account/pacct",
	716	FALSE);
	717	if (run_program_and_log_output("ls " MNT_RESTORING " /tmp", FALSE)) {
	718	run_program_and_log_output("chmod 1777 " MNT_RESTORING "/tmp",
	719	FALSE);
[1]	720	}
[1242]	721	run_program_and_log_output("mkdir -p " MNT_RESTORING
	722	"/var/run/console", FALSE);
	723	run_program_and_log_output("chmod 777 " MNT_RESTORING "/dev/null",
	724	FALSE);
	725	run_program_and_log_output("cd " MNT_RESTORING
	726	"; for i in `ls home/`; do echo \"Moving $i's spurious files to $i/.disabled\"; mkdir \"$i\"/.disabled ; mv -f \"$i\"/.DCOP* \"$i\"/.MCOP* \"$i\"/.authority \"$i\"/.kde/tmp \"$i\"/.kde/socket* \"$i\"/.disabled/ ; done",
	727	TRUE);
	728	run_program_and_log_output("rm -f " MNT_RESTORING "/var/run/*.pid",
	729	TRUE);
	730	run_program_and_log_output("rm -f " MNT_RESTORING "/var/lock/subsys/*",
	731	TRUE);
	732	}
[128]	733
[1]	734	/**************************************************************************
[1242]	735	END_PROTECT_AGAINST_BRAINDEAD_SYSADMINS
	736	**************************************************************************/
[1]	737
	738
	739
	740
	741	/**
[1242]	742	* Fill out @p bkpinfo based on @p cfg_file.
	743	* @param cfg_file The mondo-restore.cfg file to read into @p bkpinfo.
	744	* @param bkpinfo The backup information structure to fill out with information
	745	* from @p cfg_file.
	746	* @return 0 for success, nonzero for failure.
	747	*/
[1645]	748	int read_cfg_file_into_bkpinfo(char *cfgf)
[1]	749	{
[1242]	750	/ add mallocs /
	751	char *value = NULL;
	752	char *tmp = NULL;
	753	char *envtmp1 = NULL;
	754	char *envtmp2 = NULL;
	755	char *command = NULL;
	756	char *iso_mnt = NULL;
	757	char *iso_path = NULL;
	758	char *old_isodir = NULL;
	759	char cfg_file[100];
	760	t_bkptype media_specified_by_user;
[1]	761
[1242]	762	malloc_string(command);
	763	malloc_string(iso_mnt);
	764	malloc_string(iso_path);
	765	malloc_string(old_isodir);
	766	malloc_string(value);
	767	malloc_string(tmp);
[1]	768	// assert_string_is_neither_NULL_nor_zerolength(cfg_file);
[1242]	769	assert(bkpinfo != NULL);
[1]	770
[1242]	771	if (!cfgf) {
[2188]	772	strcpy(cfg_file, g_mondo_cfg_file);
[1242]	773	} else {
[2188]	774	strcpy(cfg_file, cfgf);
[1242]	775	}
[1]	776
[1242]	777	media_specified_by_user = bkpinfo->backup_media_type; // or 'none', if not specified
[1]	778
[1242]	779	if (0 == read_cfg_var(cfg_file, "backup-media-type", value)) {
	780	if (!strcmp(value, "cdstream")) {
	781	bkpinfo->backup_media_type = cdstream;
	782	} else if (!strcmp(value, "cdr")) {
	783	bkpinfo->backup_media_type = cdr;
	784	} else if (!strcmp(value, "cdrw")) {
	785	bkpinfo->backup_media_type = cdrw;
	786	} else if (!strcmp(value, "dvd")) {
	787	bkpinfo->backup_media_type = dvd;
[1736]	788	} else if (!strcmp(value, "usb")) {
	789	bkpinfo->backup_media_type = usb;
[1746]	790	bkpinfo->please_dont_eject = TRUE;
[1242]	791	} else if (!strcmp(value, "iso")) {
[1]	792
	793	// Patch by Conor Daly - 2004/07/12
[1242]	794	bkpinfo->backup_media_type = iso;
	795	if (am_I_in_disaster_recovery_mode()) {
	796	/* Check to see if CD is already mounted before mounting it... */
	797	if (!is_this_device_mounted("/dev/cdrom")) {
	798	log_msg(2,
	799	"NB: CDROM device not mounted, mounting...");
	800	run_program_and_log_output("mount /dev/cdrom "
	801	MNT_CDROM, 1);
[128]	802	}
[1242]	803	if (does_file_exist(MNT_CDROM "/archives/filelist.0")) {
	804	bkpinfo->backup_media_type = cdr;
	805	run_program_and_log_output("umount " MNT_CDROM, 1);
	806	log_it
	807	("Re-jigging configuration AGAIN. CD-R, not ISO.");
	808	}
	809	}
	810	if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
	811	strcpy(bkpinfo->prefix,value);
[128]	812	} else {
[1242]	813	strcpy(bkpinfo->prefix,STD_PREFIX);
[1]	814	}
[1242]	815	} else if (!strcmp(value, "nfs")) {
	816	bkpinfo->backup_media_type = nfs;
[1848]	817	bkpinfo->please_dont_eject = TRUE;
[1242]	818	if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
	819	strcpy(bkpinfo->prefix,value);
[128]	820	} else {
[1242]	821	strcpy(bkpinfo->prefix,STD_PREFIX);
[1]	822	}
[1242]	823	if (strstr(call_program_and_get_last_line_of_output
	824	("cat /proc/cmdline"), "pxe")) {
	825	/* We need to override prefix value in PXE mode as it's
	826	* already done in start-nfs */
	827	envtmp1 = getenv("imgname");
	828	if (envtmp1 == NULL) {
	829	fatal_error("no imgname variable in environment");
[949]	830	}
[1242]	831	strcpy(bkpinfo->prefix,envtmp1);
[949]	832	}
	833
[1242]	834	} else if (!strcmp(value, "tape")) {
	835	bkpinfo->backup_media_type = tape;
	836	} else if (!strcmp(value, "udev")) {
	837	bkpinfo->backup_media_type = udev;
	838	} else {
	839	fatal_error("UNKNOWN bkp-media-type");
	840	}
	841	} else {
	842	fatal_error("backup-media-type not specified!");
	843	}
	844	if (bkpinfo->disaster_recovery) {
[1736]	845	if (bkpinfo->backup_media_type == cdstream) {
	846	sprintf(bkpinfo->media_device, "/dev/cdrom");
[1242]	847	// bkpinfo->media_size[0] = -1;
[1736]	848	bkpinfo->media_size[0] = 1999 * 1024;
	849	bkpinfo->media_size[1] = 650; /* good guess */
	850	} else if (bkpinfo->backup_media_type == usb) {
[2127]	851	envtmp1 = getenv("MRUSBDEV");
	852	if (envtmp1 == NULL) {
	853	if (read_cfg_var(cfg_file, "usb-dev", value)) {
	854	fatal_error("Cannot get USB device name from cfg file");
	855	}
	856	} else {
	857	strcpy(value,envtmp1);
[1736]	858	}
[1741]	859	sprintf(bkpinfo->media_device, "%s1", value);
[1736]	860	sprintf(tmp, "Backup medium is USB --- dev=%s", bkpinfo->media_device);
	861	log_msg(2, tmp);
	862	} else if (bkpinfo->backup_media_type == tape
[1968]	863	\|\| bkpinfo->backup_media_type == udev) {
[1736]	864	if (read_cfg_var(cfg_file, "media-dev", value)) {
	865	fatal_error("Cannot get tape device name from cfg file");
	866	}
	867	strcpy(bkpinfo->media_device, value);
	868	read_cfg_var(cfg_file, "media-size", value);
	869	bkpinfo->media_size[1] = atol(value);
	870	sprintf(tmp, "Backup medium is TAPE --- dev=%s",
	871	bkpinfo->media_device);
	872	log_msg(2, tmp);
	873	} else {
	874	strcpy(bkpinfo->media_device, "/dev/cdrom"); /* we don't really need this var */
	875	bkpinfo->media_size[0] = 1999 * 1024; /* 650, probably, but we don't need this var anyway */
	876	bkpinfo->media_size[1] = 1999 * 1024; /* 650, probably, but we don't need this var anyway */
	877	log_msg(2, "Backup medium is CD-R[W]");
[1]	878	}
[1242]	879	} else {
[1736]	880	log_msg(2,
[1242]	881	"Not in Disaster Recovery Mode. No need to derive device name from config file.");
	882	}
[128]	883
[1242]	884	read_cfg_var(cfg_file, "use-star", value);
	885	if (strstr(value, "yes")) {
[1948]	886	bkpinfo->use_star = TRUE;
	887	log_msg(1, "Goody! ... bkpinfo->use_star is now true.");
[1242]	888	}
	889
[1948]	890	read_cfg_var(cfg_file, "obdr", value);
	891	if (strstr(value, "TRUE")) {
	892	bkpinfo->use_obdr = TRUE;
	893	log_msg(1, "OBDR mode activated");
	894	}
	895
[1242]	896	read_cfg_var(cfg_file, "acl", value);
	897	if (strstr(value, "TRUE")) {
[1948]	898	asprintf(&g_getfacl,"setfacl");
	899	log_msg(1, "We will restore ACLs");
	900	if (! find_home_of_exe("setfacl")) {
	901	log_msg(1, "Unable to restore ACLs as no setfacl found");
	902	}
[1242]	903	}
	904	read_cfg_var(cfg_file, "xattr", value);
	905	if (strstr(value, "TRUE")) {
[1948]	906	asprintf(&g_getfattr,"setfattr");
	907	log_msg(1, "We will restore XATTRs");
	908	if (! find_home_of_exe("setfattr")) {
	909	log_msg(1, "Unable to restore XATTRs as no setfattr found");
	910	}
[1242]	911	}
	912
	913	if (0 == read_cfg_var(cfg_file, "internal-tape-block-size", value)) {
	914	bkpinfo->internal_tape_block_size = atol(value);
	915	log_msg(1, "Internal tape block size has been custom-set to %ld",
	916	bkpinfo->internal_tape_block_size);
	917	} else {
	918	bkpinfo->internal_tape_block_size =
	919	DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
	920	log_msg(1, "Internal tape block size = default (%ld)",
	921	DEFAULT_INTERNAL_TAPE_BLOCK_SIZE);
	922	}
	923
	924	read_cfg_var(cfg_file, "use-lzo", value);
	925	if (strstr(value, "yes")) {
	926	bkpinfo->use_lzo = TRUE;
	927	bkpinfo->use_gzip = FALSE;
	928	strcpy(bkpinfo->zip_exe, "lzop");
	929	strcpy(bkpinfo->zip_suffix, "lzo");
	930	} else {
	931	read_cfg_var(cfg_file, "use-gzip", value);
	932	if (strstr(value, "yes")) {
	933	bkpinfo->use_lzo = FALSE;
	934	bkpinfo->use_gzip = TRUE;
	935	strcpy(bkpinfo->zip_exe, "gzip");
	936	strcpy(bkpinfo->zip_suffix, "gz");
	937	} else {
	938	read_cfg_var(cfg_file, "use-comp", value);
[128]	939	if (strstr(value, "yes")) {
[1242]	940	bkpinfo->use_lzo = FALSE;
[998]	941	bkpinfo->use_gzip = FALSE;
[1242]	942	strcpy(bkpinfo->zip_exe, "bzip2");
	943	strcpy(bkpinfo->zip_suffix, "bz2");
[128]	944	} else {
[1242]	945	bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
[1]	946	}
[1242]	947	}
	948	}
[1]	949
[1242]	950	value[0] = '\0';
	951	read_cfg_var(cfg_file, "differential", value);
	952	if (!strcmp(value, "yes") \|\| !strcmp(value, "1")) {
	953	bkpinfo->differential = TRUE;
	954	}
	955	log_msg(2, "differential var = '%s'", value);
	956	if (bkpinfo->differential) {
	957	log_msg(2, "THIS IS A DIFFERENTIAL BACKUP");
	958	} else {
	959	log_msg(2, "This is a regular (full) backup");
	960	}
	961
	962	read_cfg_var(g_mondo_cfg_file, "please-dont-eject", tmp);
	963	if (tmp[0]
	964	\|\|
	965	strstr(call_program_and_get_last_line_of_output
	966	("cat /proc/cmdline"), "donteject")) {
	967	bkpinfo->please_dont_eject = TRUE;
	968	log_msg(2, "Ok, I shan't eject when restoring! Groovy.");
	969	}
	970
	971	if (bkpinfo->backup_media_type == nfs) {
[1736]	972	if (!cfgf) {
	973	log_msg(2, "nfs_mount remains %s", bkpinfo->nfs_mount);
	974	log_msg(2, "nfs_remote_dir remains %s",
	975	bkpinfo->nfs_remote_dir);
	976	log_msg(2,
	977	"...cos it wouldn't make sense to abandon the values that GOT ME to this config file in the first place");
	978	} else {
	979	read_cfg_var(g_mondo_cfg_file, "nfs-server-mount",
[1968]	980	bkpinfo->nfs_mount);
[1736]	981	read_cfg_var(g_mondo_cfg_file, "nfs-server-path",
[1968]	982	bkpinfo->nfs_remote_dir);
[1736]	983	log_msg(2, "nfs_mount is %s", bkpinfo->nfs_mount);
	984	log_msg(2, "nfs_remote_dir is %s", bkpinfo->nfs_remote_dir);
[1]	985	}
[1736]	986	if (strstr(call_program_and_get_last_line_of_output
[1968]	987	("cat /proc/cmdline"), "pxe")) {
	988	/* We need to override values in PXE mode as it's
[1736]	989	* already done in start-nfs */
	990	envtmp1 = getenv("nfsmount");
	991	if (envtmp1 == NULL) {
	992	fatal_error("no nfsmount variable in environment");
	993	}
	994	envtmp2 = getenv("dirimg");
	995	if (envtmp2 == NULL) {
	996	fatal_error("no dirimg variable in environment");
	997	}
	998	strcpy(bkpinfo->nfs_mount,envtmp1);
	999	strcpy(bkpinfo->nfs_remote_dir,envtmp2);
[1]	1000	}
[1242]	1001	} else if (bkpinfo->backup_media_type == iso) {
[1736]	1002	/* Patch by Conor Daly 23-june-2004
	1003	* to correctly mount iso-dev and set a sensible
	1004	* isodir in disaster recovery mode
	1005	*/
	1006	strcpy(old_isodir, bkpinfo->isodir);
	1007	read_cfg_var(g_mondo_cfg_file, "iso-mnt", iso_mnt);
	1008	read_cfg_var(g_mondo_cfg_file, "isodir", iso_path);
	1009	sprintf(bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
	1010	if (!bkpinfo->isodir[0]) {
[1242]	1011	strcpy(bkpinfo->isodir, old_isodir);
[128]	1012	}
[1736]	1013	if (!bkpinfo->disaster_recovery) {
	1014	if (strcmp(old_isodir, bkpinfo->isodir)) {
	1015	log_it
	1016	("user nominated isodir differs from archive, keeping user's choice: %s %s\n",
	1017	old_isodir, bkpinfo->isodir);
	1018	strcpy(bkpinfo->isodir, old_isodir);
	1019	}
	1020	}
	1021	read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
	1022	log_msg(2, "isodir=%s; iso-dev=%s", bkpinfo->isodir,
	1023	g_isodir_device);
	1024	if (bkpinfo->disaster_recovery) {
	1025	if (is_this_device_mounted(g_isodir_device)) {
	1026	log_msg(2, "NB: isodir is already mounted");
	1027	/* Find out where it's mounted */
	1028	sprintf(command,
	1029	"mount \| grep -E '^%s' \| tail -n1 \| cut -d' ' -f3",
	1030	g_isodir_device);
	1031	log_it("command = %s", command);
	1032	log_it("res of it = %s",
[1968]	1033	call_program_and_get_last_line_of_output(command));
[1736]	1034	sprintf(iso_mnt, "%s",
	1035	call_program_and_get_last_line_of_output(command));
	1036	} else {
	1037	sprintf(iso_mnt, "/tmp/isodir");
	1038	sprintf(tmp, "mkdir -p %s", iso_mnt);
	1039	run_program_and_log_output(tmp, 5);
	1040	sprintf(tmp, "mount %s %s", g_isodir_device, iso_mnt);
	1041	if (run_program_and_log_output(tmp, 3)) {
[1242]	1042	log_msg(1,
[1736]	1043	"Unable to mount isodir. Perhaps this is really a CD backup?");
	1044	bkpinfo->backup_media_type = cdr;
	1045	strcpy(bkpinfo->media_device, "/dev/cdrom"); /* superfluous */
	1046	bkpinfo->isodir[0] = iso_mnt[0] = iso_path[0] = '\0';
	1047	if (mount_media()) {
	1048	fatal_error
	1049	("Unable to mount isodir. Failed to mount CD-ROM as well.");
	1050	} else {
	1051	log_msg(1,
	1052	"You backed up to disk, then burned some CDs.");
	1053	}
[128]	1054	}
	1055	}
[1736]	1056	/* bkpinfo->isodir should now be the true path to prefix-1.iso etc... */
	1057	if (bkpinfo->backup_media_type == iso) {
	1058	sprintf(bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
	1059	}
[1]	1060	}
[1242]	1061	}
[1]	1062
[1242]	1063	if (media_specified_by_user != none) {
[1736]	1064	if (g_restoring_live_from_cd) {
	1065	if (bkpinfo->backup_media_type != media_specified_by_user) {
	1066	log_msg(2,
	1067	"bkpinfo->backup_media_type != media_specified_by_user, so I'd better ask :)");
	1068	interactively_obtain_media_parameters_from_user(FALSE);
	1069	media_specified_by_user = bkpinfo->backup_media_type;
	1070	get_cfg_file_from_archive();
	1071	/*
[1968]	1072	if (media_specified_by_user != cdr && media_specified_by_user == cdrw)
[1736]	1073	{ g_restoring_live_from_cd = FALSE; }
	1074	*/
	1075	}
[128]	1076	}
[1736]	1077	bkpinfo->backup_media_type = media_specified_by_user;
[1242]	1078	}
	1079	g_backup_media_type = bkpinfo->backup_media_type;
	1080	paranoid_free(value);
	1081	paranoid_free(tmp);
	1082	paranoid_free(command);
	1083	paranoid_free(iso_mnt);
	1084	paranoid_free(iso_path);
	1085	paranoid_free(old_isodir);
	1086	return (0);
[1]	1087
	1088	}
[128]	1089
[1]	1090	/**************************************************************************
[1242]	1091	END_READ_CFG_FILE_INTO_BKPINFO
	1092	**************************************************************************/
[1]	1093
	1094
	1095
[128]	1096
[1]	1097	/**
[1843]	1098	* Allow the user to edit the filelist and biggielist.
	1099	* The filelist is unlinked after it is read.
	1100	* @param bkpinfo The backup information structure. Fields used:
	1101	* - @c bkpinfo->backup_media_type
	1102	* - @c bkpinfo->isodir
	1103	* - @c bkpinfo->media_device
	1104	* - @c bkpinfo->tmpdir
	1105	* @return The filelist structure containing the information read from disk.
	1106	*/
[1]	1107	struct
[1645]	1108	s_node *process_filelist_and_biggielist()
[1]	1109	{
[1242]	1110	struct s_node *filelist;
[1]	1111
[1242]	1112	/ add mallocs/
	1113	char *command;
	1114	char *tmp;
	1115	int res = 0;
	1116	pid_t pid;
[2049]	1117	bool extract_mountlist_stub = FALSE;
[1]	1118
[1242]	1119	assert(bkpinfo != NULL);
	1120	malloc_string(command);
	1121	malloc_string(tmp);
[1]	1122
[2049]	1123	/* If those files already exist, do not overwrite them later on */
	1124	if (does_file_exist("/"MOUNTLIST_FNAME_STUB)) {
	1125	extract_mountlist_stub = FALSE;
	1126	} else {
	1127	extract_mountlist_stub = TRUE;
	1128	}
	1129
[1242]	1130	if (does_file_exist(g_filelist_full)
	1131	&& does_file_exist(g_biggielist_txt)) {
[1987]	1132	log_msg(1, "%s exists", g_filelist_full);
	1133	log_msg(1, "%s exists", g_biggielist_txt);
	1134	log_msg(2,
[1242]	1135	"Filelist and biggielist already recovered from media. Yay!");
	1136	} else {
[1987]	1137	getcwd(tmp, MAX_STR_LEN);
	1138	chdir(bkpinfo->tmpdir);
	1139	log_msg(1, "chdir(%s)", bkpinfo->tmpdir);
	1140	log_to_screen("Extracting filelist and biggielist from media...");
	1141	unlink("/tmp/filelist.full");
[2029]	1142	unlink(FILELIST_FULL_STUB);
[1987]	1143	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
	1144	sprintf(command,
[2029]	1145	"tar -b %ld -zxf %s ./%s ./%s ./%s ./%s ./%s",
[1242]	1146	bkpinfo->internal_tape_block_size,
	1147	bkpinfo->media_device,
	1148	MOUNTLIST_FNAME_STUB,
	1149	BIGGIELIST_TXT_STUB,
	1150	FILELIST_FULL_STUB,
[2049]	1151	IWANTMYLVM_STUB,
[2029]	1152	MONDO_CFG_FILE_STUB);
[1987]	1153	log_msg(1, "tarcommand = %s", command);
	1154	run_program_and_log_output(command, 1);
[2029]	1155	if (!does_file_exist(FILELIST_FULL_STUB)) {
	1156	/* Doing that allow us to remain compatible with pre-2.2.5 versions */
	1157	log_msg(2, "pre-2.2.4 compatible mode on");
	1158	sprintf(command,
	1159	"tar -b %ld -zxf %s %s %s %s %s %s",
	1160	bkpinfo->internal_tape_block_size,
	1161	bkpinfo->media_device,
	1162	MOUNTLIST_FNAME_STUB,
	1163	BIGGIELIST_TXT_STUB,
	1164	FILELIST_FULL_STUB,
	1165	IWANTMYLVM_STUB,
[2049]	1166	MONDO_CFG_FILE_STUB);
[2029]	1167	log_msg(1, "tarcommand = %s", command);
	1168	run_program_and_log_output(command, 1);
	1169	}
[1987]	1170	} else {
	1171	log_msg(2,
[1242]	1172	"Calling insist_on_this_cd_number; bkpinfo->isodir=%s",
	1173	bkpinfo->isodir);
[1987]	1174	insist_on_this_cd_number(1);
	1175	log_msg(2, "Back from iotcn");
	1176	run_program_and_log_output("mount", 1);
	1177	sprintf(command,
[2029]	1178	"tar -zxf %s/images/all.tar.gz ./%s ./%s ./%s ./%s ./%s",
[1242]	1179	MNT_CDROM,
	1180	MOUNTLIST_FNAME_STUB,
	1181	BIGGIELIST_TXT_STUB,
	1182	FILELIST_FULL_STUB,
[2049]	1183	IWANTMYLVM_STUB,
[2029]	1184	MONDO_CFG_FILE_STUB);
[1]	1185
[1987]	1186	log_msg(1, "tarcommand = %s", command);
	1187	run_program_and_log_output(command, 1);
[2029]	1188	if (!does_file_exist(FILELIST_FULL_STUB)) {
	1189	/* Doing that allow us to remain compatible with pre-2.2.5 versions */
	1190	log_msg(2, "pre-2.2.4 compatible mode on");
	1191	sprintf(command,
	1192	"tar -zxf %s/images/all.tar.gz %s %s %s %s %s",
	1193	MNT_CDROM,
	1194	MOUNTLIST_FNAME_STUB,
	1195	BIGGIELIST_TXT_STUB,
	1196	FILELIST_FULL_STUB,
[2049]	1197	IWANTMYLVM_STUB,
[2029]	1198	MONDO_CFG_FILE_STUB);
	1199
	1200	log_msg(1, "tarcommand = %s", command);
	1201	run_program_and_log_output(command, 1);
	1202	}
[1987]	1203	if (!does_file_exist(BIGGIELIST_TXT_STUB)) {
	1204	fatal_error
[2029]	1205	("all.tar.gz did not include " BIGGIELIST_TXT_STUB);
[1987]	1206	}
	1207	if (!does_file_exist(FILELIST_FULL_STUB)) {
	1208	fatal_error
[2029]	1209	("all.tar.gz did not include " FILELIST_FULL_STUB);
[1987]	1210	}
[128]	1211	}
[1987]	1212	sprintf(command, "cp -f %s %s", MONDO_CFG_FILE_STUB,
[1242]	1213	g_mondo_cfg_file);
[1987]	1214	run_program_and_log_output(command, FALSE);
[1]	1215
[1987]	1216	sprintf(command, "cp -f %s/%s %s", bkpinfo->tmpdir,
[1242]	1217	BIGGIELIST_TXT_STUB, g_biggielist_txt);
[1987]	1218	log_msg(1, "command = %s", command);
	1219	paranoid_system(command);
	1220	sprintf(command, "ln -sf %s/%s %s", bkpinfo->tmpdir,
[1242]	1221	FILELIST_FULL_STUB, g_filelist_full);
[1987]	1222	log_msg(1, "command = %s", command);
	1223	paranoid_system(command);
	1224	}
[1242]	1225
[1987]	1226	if (am_I_in_disaster_recovery_mode()
	1227	&&
[2049]	1228	/* If it was there, do not overwrite it */
	1229	(extract_mountlist_stub)
	1230	&&
[1987]	1231	ask_me_yes_or_no("Do you want to retrieve the mountlist as well?"))
	1232	{
	1233	sprintf(command, "ln -sf %s/%s /tmp", MOUNTLIST_FNAME_STUB,
	1234	bkpinfo->tmpdir);
	1235	paranoid_system(command);
	1236	}
[1]	1237
[1987]	1238	chdir(tmp);
[2049]	1239
[1987]	1240	if (!does_file_exist(g_biggielist_txt)) {
	1241	log_msg(1, "Warning - %s not found", g_biggielist_txt);
	1242	}
	1243	if (!does_file_exist(g_filelist_full)) {
	1244	log_msg(1, "Warning - %s does not exist", g_filelist_full);
	1245	}
[1]	1246	// popup_and_OK("Wonderful.");
	1247
[1987]	1248	log_msg(2, "Forking");
	1249	pid = fork();
	1250	switch (pid) {
	1251	case -1:
	1252	fatal_error("Forking error");
	1253	break;
[1]	1254
[1987]	1255	case 0:
	1256	log_to_screen("Pre-processing filelist");
	1257	if (!does_file_exist(g_biggielist_txt)) {
[1242]	1258	sprintf(command, "echo -n > %s", g_biggielist_txt);
[128]	1259	paranoid_system(command);
	1260	}
[910]	1261	sprintf(command, "grep -E '^/dev/.*' %s > %s",
[128]	1262	g_biggielist_txt, g_filelist_imagedevs);
	1263	paranoid_system(command);
	1264	exit(0);
	1265	break;
	1266
	1267	default:
[541]	1268	open_evalcall_form("Pre-processing filelist");
[128]	1269	while (!waitpid(pid, (int *) 0, WNOHANG)) {
	1270	usleep(100000);
	1271	update_evalcall_form(0);
	1272	}
[1]	1273	}
[128]	1274	close_evalcall_form();
[1]	1275
[128]	1276	log_msg(3, "loading filelist");
	1277	filelist = load_filelist(g_filelist_full);
	1278	log_msg(3, "deleting original filelist");
	1279	unlink(g_filelist_full);
	1280	if (g_text_mode) {
[541]	1281	printf("Restore which directory? --> ");
[128]	1282	fgets(tmp, sizeof(tmp), stdin);
	1283	toggle_path_selection(filelist, tmp, TRUE);
	1284	if (strlen(tmp) == 0) {
	1285	res = 1;
	1286	} else {
	1287	res = 0;
	1288	}
	1289	} else {
	1290	res = edit_filelist(filelist);
[1]	1291	}
[128]	1292	if (res) {
	1293	log_msg(2, "User hit 'cancel'. Freeing filelist and aborting.");
	1294	free_filelist(filelist);
	1295	return (NULL);
	1296	}
	1297	ask_about_these_imagedevs(g_filelist_imagedevs, g_imagedevs_restthese);
	1298	close_evalcall_form();
[1]	1299
[128]	1300	// NB: It's not necessary to add g_biggielist_txt to the filelist.full
	1301	// file. The filelist.full file already contains the filename of EVERY
	1302	// file backed up - regular and biggie files.
[1]	1303
[128]	1304	// However, we do want to make sure the imagedevs selected by the user
	1305	// are flagged for restoring.
	1306	if (length_of_file(g_imagedevs_restthese) > 2) {
	1307	add_list_of_files_to_filelist(filelist, g_imagedevs_restthese,
	1308	TRUE);
	1309	}
[1]	1310
[128]	1311	paranoid_free(command);
	1312	paranoid_free(tmp);
	1313	return (filelist);
	1314	}
[1]	1315
	1316	/**************************************************************************
	1317	END_ PROCESS_FILELIST_AND_BIGGIELIST
	1318	**************************************************************************/
	1319
	1320
	1321
	1322
	1323	/**
	1324	* Make a backup copy of <tt>path_root</tt>/<tt>filename</tt>.
	1325	* The backup filename is the filename of the original with ".pristine" added.
	1326	* @param path_root The place where the filesystem is mounted (e.g. MNT_RESTORING).
	1327	* @param filename The filename (absolute path) within @p path_root.
	1328	* @return 0 for success, nonzero for failure.
	1329	*/
[128]	1330	int backup_crucial_file(char path_root, char filename)
[1]	1331	{
[128]	1332	char *tmp;
	1333	char *command;
	1334	int res;
[1]	1335
[128]	1336	malloc_string(tmp);
	1337	malloc_string(command);
	1338	assert(path_root != NULL);
	1339	assert_string_is_neither_NULL_nor_zerolength(filename);
	1340
	1341	sprintf(tmp, "%s/%s", path_root, filename);
	1342	sprintf(command, "cp -f %s %s.pristine", tmp, tmp);
	1343
	1344	res = run_program_and_log_output(command, 5);
	1345	paranoid_free(tmp);
	1346	paranoid_free(command);
	1347	return (res);
[1]	1348	}
	1349
[2094]	1350	void offer_to_make_initrd() {
[1]	1351
[2094]	1352	if (bkpinfo->restore_mode != nuke) {
[2110]	1353	if (ask_me_yes_or_no
	1354	("You will now be able to re-generate your initrd.\nThis is especially useful if you changed of hardware configuration, cloned, made P2V, used multipath...\nDo you need to do it ?")) {
[2136]	1355	log_msg(1,"Launching shell for manual initrd recreation");
	1356	popup_and_OK("You'll now be chrooted under your future / partition.\nGo under /boot and rebuild your initrd with\nmkinitrd -f -v initrd-2.x.y.img 2.x.y e.g.\nThen type exit to finish.");
[2110]	1357	mvaddstr_and_log_it(g_currentY, 0, "Modifying initrd...");
	1358	if (!g_text_mode) {
	1359	newtSuspend();
	1360	}
	1361	(void)system("chroot " MNT_RESTORING);
	1362	if (!g_text_mode) {
	1363	newtResume();
	1364	}
	1365	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
	1366	} else {
[2094]	1367	return;
	1368	}
	1369	} else {
	1370	log_to_screen("Non-interactive mode: no way to give you the keyboard so that you re-generate your initrd. Hope it's OK");
	1371	log_msg(1,"Non-interactive mode: no way to give you the keyboard so that you re-generate your initrd. Hope it's OK");
	1372	}
	1373	}
	1374
	1375
[1]	1376	/**
	1377	* Install the user's boot loader in the MBR.
	1378	* Currently LILO, ELILO, GRUB, RAW (dd of MBR), and the FreeBSD bootloader are supported.
	1379	* @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
	1380	* @return 0 for success, nonzero for failure.
	1381	*/
[128]	1382	int run_boot_loader(bool offer_to_hack_scripts)
[1]	1383	{
[128]	1384	int res;
	1385	int retval = 0;
[1]	1386
	1387	/ malloc *****/
[128]	1388	char *device;
[1873]	1389	char *tmp = NULL;
[128]	1390	char *name;
[1845]	1391	char *cmd = NULL;
[1]	1392
[128]	1393	malloc_string(device);
	1394	malloc_string(name);
[1845]	1395
	1396	/* In order to have a working bootloader, we need to have all devices
	1397	* ready in the chroot. If they are not there (udev) then copy them from
	1398	* the current /dev location
	1399	*/
	1400	asprintf(&cmd,"tar cf - /dev \| ( cd %s ; tar xf - )",MNT_RESTORING);
	1401	run_program_and_log_output(cmd, 3);
[1873]	1402	paranoid_free(cmd);
[1845]	1403
[128]	1404	backup_crucial_file(MNT_RESTORING, "/etc/fstab");
[2095]	1405	backup_crucial_file(MNT_RESTORING, "/boot/grub/menu.lst");
[128]	1406	backup_crucial_file(MNT_RESTORING, "/etc/lilo.conf");
	1407	backup_crucial_file(MNT_RESTORING, "/etc/elilo.conf");
[1845]	1408	backup_crucial_file(MNT_RESTORING, "/boot/grub/device.map");
	1409	backup_crucial_file(MNT_RESTORING, "/etc/mtab");
[128]	1410	read_cfg_var(g_mondo_cfg_file, "bootloader.device", device);
	1411	read_cfg_var(g_mondo_cfg_file, "bootloader.name", name);
[1873]	1412	asprintf(&tmp, "run_boot_loader: device='%s', name='%s'", device, name);
[128]	1413	log_msg(2, tmp);
[1873]	1414	paranoid_free(tmp);
[128]	1415	system("sync");
[2094]	1416
	1417	offer_to_make_initrd();
[128]	1418	if (!strcmp(name, "LILO")) {
	1419	res = run_lilo(offer_to_hack_scripts);
	1420	} else if (!strcmp(name, "ELILO")) {
	1421	res = run_elilo(offer_to_hack_scripts);
	1422	} else if (!strcmp(name, "GRUB")) {
	1423	res = run_grub(offer_to_hack_scripts, device);
	1424	} else if (!strcmp(name, "RAW")) {
	1425	res = run_raw_mbr(offer_to_hack_scripts, device);
	1426	}
[1]	1427	#ifdef __FreeBSD__
[128]	1428	else if (!strcmp(name, "BOOT0")) {
[1873]	1429	asprintf(&tmp, "boot0cfg -B %s", device);
[128]	1430	res = run_program_and_log_output(tmp, FALSE);
[1873]	1431	paranoid_free(tmp);
[128]	1432	} else {
[1873]	1433	asprintf(&tmp, "ls /dev \| grep -Eq '^%ss[1-4].*'", device);
[128]	1434	if (!system(tmp)) {
[1873]	1435	paranoid_free(tmp);
	1436	asprintf(&tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
[128]	1437	res = run_program_and_log_output(tmp, 3);
	1438	} else {
	1439	log_msg(1,
	1440	"I'm not running any boot loader. You have a DD boot drive. It's already loaded up.");
	1441	}
[1873]	1442	paranoid_free(tmp);
[128]	1443	}
[1]	1444	#else
[128]	1445	else {
	1446	log_to_screen
[541]	1447	("Unable to determine type of boot loader. Defaulting to LILO.");
[128]	1448	res = run_lilo(offer_to_hack_scripts);
	1449	}
[1]	1450	#endif
[128]	1451	retval += res;
	1452	if (res) {
[541]	1453	log_to_screen("Your boot loader returned an error");
[128]	1454	} else {
[541]	1455	log_to_screen("Your boot loader ran OK");
[128]	1456	}
	1457	paranoid_free(device);
	1458	paranoid_free(name);
	1459	return (retval);
[1]	1460	}
[128]	1461
[1]	1462	/**************************************************************************
	1463	END_ RUN_BOOT_LOADER
	1464	**************************************************************************/
	1465
	1466
	1467
	1468	/**
	1469	* Attempt to find the user's editor.
	1470	* @return The editor found ("vi" if none could be found).
	1471	* @note The returned string points to static storage that will be overwritten with each call.
	1472	*/
	1473	char *find_my_editor(void)
	1474	{
[128]	1475	static char output[MAX_STR_LEN];
	1476	if (find_home_of_exe("pico")) {
	1477	strcpy(output, "pico");
	1478	} else if (find_home_of_exe("nano")) {
	1479	strcpy(output, "nano");
	1480	} else if (find_home_of_exe("e3em")) {
	1481	strcpy(output, "e3em");
	1482	} else if (find_home_of_exe("e3vi")) {
	1483	strcpy(output, "e3vi");
	1484	} else {
	1485	strcpy(output, "vi");
	1486	}
	1487	if (!find_home_of_exe(output)) {
	1488	log_msg(2, " (find_my_editor) --- warning - %s not found", output);
	1489	}
	1490	return (output);
[1]	1491	}
	1492
	1493
	1494	/**
	1495	* Install GRUB on @p bd.
	1496	* @param offer_to_run_stabgrub If TRUE, then offer to hack the user's fstab for them.
	1497	* @param bd The boot device where GRUB is installed.
	1498	* @return 0 for success, nonzero for failure.
	1499	*/
[128]	1500	int run_grub(bool offer_to_run_stabgrub, char *bd)
[1]	1501	{
	1502	/ malloc /
[128]	1503	char *command;
	1504	char *boot_device;
	1505	char *rootdev;
	1506	char *rootdrive;
	1507	char *conffile;
	1508	char *tmp;
	1509	char *editor;
[1]	1510
[128]	1511	int res;
	1512	int done;
[1]	1513
[128]	1514	malloc_string(command);
	1515	malloc_string(boot_device);
	1516	malloc_string(tmp);
	1517	malloc_string(editor);
	1518	malloc_string(rootdev);
	1519	malloc_string(rootdrive);
	1520	malloc_string(conffile);
	1521	assert_string_is_neither_NULL_nor_zerolength(bd);
[1640]	1522	strcpy(editor, find_my_editor());
[128]	1523	strcpy(boot_device, bd);
	1524
	1525	if (!run_program_and_log_output("which grub-MR", FALSE)) {
	1526	log_msg(1, "Yay! grub-MR found...");
	1527	sprintf(command, "grub-MR %s /tmp/mountlist.txt", boot_device);
	1528	log_msg(1, "command = %s", command);
	1529	} else {
	1530	sprintf(command, "chroot " MNT_RESTORING " grub-install %s",
	1531	boot_device);
	1532	log_msg(1, "WARNING - grub-MR not found; using grub-install");
[1]	1533	}
[128]	1534	if (offer_to_run_stabgrub
[2094]	1535	&& ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
[128]	1536	/* interactive mode */
[1]	1537	{
[128]	1538	mvaddstr_and_log_it(g_currentY,
	1539	0,
[2095]	1540	"Modifying fstab, mtab, device.map and menu.lst, and running GRUB... ");
[128]	1541	for (done = FALSE; !done;) {
[541]	1542	popup_and_get_string("Boot device",
	1543	"Please confirm/enter the boot device. If in doubt, try /dev/hda",
[128]	1544	boot_device, MAX_STR_LEN / 4);
	1545	sprintf(command, "stabgrub-me %s", boot_device);
	1546	res = run_program_and_log_output(command, 1);
	1547	if (res) {
	1548	popup_and_OK
[541]	1549	("GRUB installation failed. Please install manually using 'grub-install' or similar command. You are now chroot()'ed to your restored system. Please type 'exit' when you are done.");
[128]	1550	newtSuspend();
	1551	system("chroot " MNT_RESTORING);
	1552	newtResume();
[541]	1553	popup_and_OK("Thank you.");
[128]	1554	} else {
	1555	done = TRUE;
	1556	}
[2095]	1557	popup_and_OK("You will now edit fstab, mtab, device.map and menu.lst");
[128]	1558	if (!g_text_mode) {
	1559	newtSuspend();
	1560	}
[1498]	1561	sprintf(tmp, "chroot %s %s /etc/fstab", MNT_RESTORING, editor);
[128]	1562	paranoid_system(tmp);
[1547]	1563	sprintf(tmp, "chroot %s %s /etc/mtab", MNT_RESTORING, editor);
	1564	paranoid_system(tmp);
[2095]	1565	sprintf(tmp, "chroot %s %s /boot/grub/menu.lst", MNT_RESTORING, editor);
[128]	1566	paranoid_system(tmp);
[1547]	1567	sprintf(tmp, "chroot %s %s /boot/grub/device.map", MNT_RESTORING, editor);
	1568	paranoid_system(tmp);
[128]	1569	if (!g_text_mode) {
	1570	newtResume();
	1571	}
	1572	}
	1573	} else
	1574	/* nuke mode */
	1575	{
	1576	mvaddstr_and_log_it(g_currentY,
	1577	0,
[541]	1578	"Running GRUB... ");
[128]	1579	iamhere(command);
	1580	res = run_program_and_log_output(command, 1);
	1581	if (res) {
	1582	popup_and_OK
[541]	1583	("Because of bugs in GRUB's own installer, GRUB was not installed properly. Please install the boot loader manually now, using this chroot()'ed shell prompt. Type 'exit' when you have finished.");
[128]	1584	newtSuspend();
	1585	system("chroot " MNT_RESTORING);
	1586	newtResume();
[541]	1587	popup_and_OK("Thank you.");
[128]	1588	}
[1]	1589	}
[128]	1590	if (res) {
[541]	1591	mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
[128]	1592	log_to_screen
[1315]	1593	("GRUB ran w/error(s). See %s for more info.", MONDO_LOGFILE);
[128]	1594	log_msg(1, "Type:-");
	1595	log_msg(1, " mount-me");
	1596	log_msg(1, " chroot " MNT_RESTORING);
	1597	log_msg(1, " mount /boot");
	1598	log_msg(1, " grub-install '(hd0)'");
	1599	log_msg(1, " exit");
	1600	log_msg(1, " unmount-me");
	1601	log_msg(1,
	1602	"If you're really stuck, please e-mail the mailing list.");
	1603	} else {
[541]	1604	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
[128]	1605	}
	1606	paranoid_free(rootdev);
	1607	paranoid_free(rootdrive);
	1608	paranoid_free(conffile);
	1609	paranoid_free(command);
	1610	paranoid_free(boot_device);
	1611	paranoid_free(tmp);
	1612	paranoid_free(editor);
[1]	1613
[128]	1614	return (res);
[1]	1615	}
[128]	1616
[1]	1617	/**************************************************************************
	1618	END_RUN_GRUB
	1619	**************************************************************************/
	1620
	1621
	1622	/**
	1623	* Install ELILO on the user's boot drive (determined by elilo.conf).
	1624	* @param offer_to_run_stabelilo If TRUE, then offer to hack the user's fstab for them.
	1625	* @return 0 for success, nonzero for failure.
	1626	*/
[128]	1627	int run_elilo(bool offer_to_run_stabelilo)
[1]	1628	{
	1629	/ malloc /
[128]	1630	char *command;
	1631	char *tmp;
	1632	char *editor;
[1]	1633
[128]	1634	int res;
	1635	int done;
[1]	1636
[128]	1637	malloc_string(command);
	1638	malloc_string(tmp);
	1639	malloc_string(editor);
	1640	strcpy(editor, find_my_editor());
	1641	if (offer_to_run_stabelilo
[2094]	1642	&& ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
[1]	1643
[128]	1644	/* interactive mode */
	1645	{
	1646	mvaddstr_and_log_it(g_currentY,
	1647	0,
[541]	1648	"Modifying fstab and elilo.conf... ");
[128]	1649	sprintf(command, "stabelilo-me");
	1650	res = run_program_and_log_output(command, 3);
	1651	if (res) {
	1652	popup_and_OK
[541]	1653	("You will now edit fstab and elilo.conf, to make sure they match your new mountlist.");
[128]	1654	for (done = FALSE; !done;) {
	1655	if (!g_text_mode) {
	1656	newtSuspend();
	1657	}
[1845]	1658	sprintf(tmp, "chroot %s %s /etc/fstab", MNT_RESTORING, editor);
[128]	1659	paranoid_system(tmp);
[1845]	1660	sprintf(tmp, "chroot %s %s /etc/elilo.conf", MNT_RESTORING, editor);
[128]	1661	paranoid_system(tmp);
	1662	if (!g_text_mode) {
	1663	newtResume();
	1664	}
[1]	1665	// newtCls();
[541]	1666	if (ask_me_yes_or_no("Edit them again?")) {
[128]	1667	continue;
	1668	}
	1669	done = TRUE;
	1670	}
	1671	} else {
[541]	1672	log_to_screen("elilo.conf and fstab were modified OK");
[1]	1673	}
[128]	1674	} else
	1675	/* nuke mode */
[1]	1676	{
[128]	1677	res = TRUE;
[1]	1678	}
[128]	1679	paranoid_free(command);
	1680	paranoid_free(tmp);
	1681	paranoid_free(editor);
	1682	return (res);
	1683	}
[1]	1684
	1685	/**************************************************************************
	1686	END_RUN_ELILO
	1687	**************************************************************************/
	1688
	1689
	1690	/**
	1691	* Install LILO on the user's boot drive (determined by /etc/lilo.conf).
	1692	* @param offer_to_run_stablilo If TRUE, then offer to hack the user's fstab for them.
	1693	* @return 0 for success, nonzero for failure.
	1694	*/
[128]	1695	int run_lilo(bool offer_to_run_stablilo)
[1]	1696	{
	1697	/ malloc /
[128]	1698	char *command;
	1699	char *tmp;
	1700	char *editor;
[1]	1701
[128]	1702	int res;
	1703	int done;
	1704	bool run_lilo_M = FALSE;
	1705	malloc_string(command);
	1706	malloc_string(tmp);
	1707	malloc_string(editor);
[1]	1708
[128]	1709	if (!run_program_and_log_output
	1710	("grep \"boot.=./dev/md\" " MNT_RESTORING "/etc/lilo.conf", 1)) {
	1711	run_lilo_M = TRUE;
	1712	}
[1]	1713
[128]	1714	strcpy(editor, find_my_editor());
	1715	if (offer_to_run_stablilo
[2094]	1716	&& ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
[1]	1717
[128]	1718	/* interactive mode */
	1719	{
	1720	mvaddstr_and_log_it(g_currentY,
	1721	0,
[541]	1722	"Modifying fstab and lilo.conf, and running LILO... ");
[128]	1723	sprintf(command, "stablilo-me");
	1724	res = run_program_and_log_output(command, 3);
	1725	if (res) {
	1726	popup_and_OK
[541]	1727	("You will now edit fstab and lilo.conf, to make sure they match your new mountlist.");
[128]	1728	for (done = FALSE; !done;) {
	1729	if (!g_text_mode) {
	1730	newtSuspend();
	1731	}
	1732	sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
	1733	paranoid_system(tmp);
	1734	sprintf(tmp, "%s " MNT_RESTORING "/etc/lilo.conf", editor);
	1735	paranoid_system(tmp);
	1736	if (!g_text_mode) {
	1737	newtResume();
	1738	}
[1]	1739	// newtCls();
[541]	1740	if (ask_me_yes_or_no("Edit them again?")) {
[128]	1741	continue;
	1742	}
	1743	res =
	1744	run_program_and_log_output("chroot " MNT_RESTORING
	1745	" lilo -L", 3);
	1746	if (res) {
	1747	res =
	1748	run_program_and_log_output("chroot " MNT_RESTORING
	1749	" lilo", 3);
	1750	}
	1751	if (res) {
	1752	done =
	1753	ask_me_yes_or_no
[541]	1754	("LILO failed. Re-edit system files?");
[128]	1755	} else {
	1756	done = TRUE;
	1757	}
	1758	}
	1759	} else {
[541]	1760	log_to_screen("lilo.conf and fstab were modified OK");
[1]	1761	}
[128]	1762	} else
	1763	/* nuke mode */
	1764	{
	1765	mvaddstr_and_log_it(g_currentY,
	1766	0,
[541]	1767	"Running LILO... ");
[128]	1768	res =
	1769	run_program_and_log_output("chroot " MNT_RESTORING " lilo -L",
	1770	3);
	1771	if (res) {
	1772	res =
	1773	run_program_and_log_output("chroot " MNT_RESTORING " lilo",
	1774	3);
[1]	1775	}
[128]	1776	if (res) {
[541]	1777	mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
[128]	1778	log_to_screen
[541]	1779	("Failed to re-jig fstab and/or lilo. Edit/run manually, please.");
[128]	1780	} else {
[541]	1781	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
[128]	1782	}
[1]	1783	}
[128]	1784	if (run_lilo_M) {
	1785	run_program_and_log_output("chroot " MNT_RESTORING
	1786	" lilo -M /dev/hda", 3);
	1787	run_program_and_log_output("chroot " MNT_RESTORING
	1788	" lilo -M /dev/sda", 3);
[1]	1789	}
[128]	1790	paranoid_free(command);
	1791	paranoid_free(tmp);
	1792	paranoid_free(editor);
	1793	return (res);
	1794	}
[1]	1795
	1796	/**************************************************************************
	1797	END_RUN_LILO
	1798	**************************************************************************/
	1799
	1800
	1801	/**
	1802	* Install a raw MBR onto @p bd.
	1803	* @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
	1804	* @param bd The device to copy the stored MBR to.
	1805	* @return 0 for success, nonzero for failure.
	1806	*/
[128]	1807	int run_raw_mbr(bool offer_to_hack_scripts, char *bd)
[1]	1808	{
	1809	/ malloc /
[128]	1810	char *command;
	1811	char *boot_device;
	1812	char *tmp;
	1813	char *editor;
	1814	int res;
	1815	int done;
[1]	1816
[128]	1817	malloc_string(command);
	1818	malloc_string(boot_device);
	1819	malloc_string(tmp);
	1820	malloc_string(editor);
	1821	assert_string_is_neither_NULL_nor_zerolength(bd);
[1]	1822
[128]	1823	strcpy(editor, find_my_editor());
	1824	strcpy(boot_device, bd);
	1825	sprintf(command, "raw-MR %s /tmp/mountlist.txt", boot_device);
	1826	log_msg(2, "run_raw_mbr() --- command='%s'", command);
[1]	1827
[128]	1828	if (offer_to_hack_scripts
[2094]	1829	&& ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
[128]	1830	/* interactive mode */
[1]	1831	{
[128]	1832	mvaddstr_and_log_it(g_currentY, 0,
[541]	1833	"Modifying fstab and restoring MBR... ");
[128]	1834	for (done = FALSE; !done;) {
	1835	if (!run_program_and_log_output("which vi", FALSE)) {
[541]	1836	popup_and_OK("You will now edit fstab");
[128]	1837	if (!g_text_mode) {
	1838	newtSuspend();
	1839	}
	1840	sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
	1841	paranoid_system(tmp);
	1842	if (!g_text_mode) {
	1843	newtResume();
	1844	}
[1]	1845	// newtCls();
[128]	1846	}
[541]	1847	popup_and_get_string("Boot device",
	1848	"Please confirm/enter the boot device. If in doubt, try /dev/hda",
[128]	1849	boot_device, MAX_STR_LEN / 4);
	1850	sprintf(command, "stabraw-me %s", boot_device);
	1851	res = run_program_and_log_output(command, 3);
	1852	if (res) {
[541]	1853	done = ask_me_yes_or_no("Modifications failed. Re-try?");
[128]	1854	} else {
	1855	done = TRUE;
	1856	}
	1857	}
	1858	} else
	1859	/* nuke mode */
	1860	{
	1861	mvaddstr_and_log_it(g_currentY, 0,
[541]	1862	"Restoring MBR... ");
[128]	1863	res = run_program_and_log_output(command, 3);
[1]	1864	}
[128]	1865	if (res) {
[541]	1866	mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
[128]	1867	log_to_screen
[1315]	1868	("MBR+fstab processed w/error(s). See %s for more info.", MONDO_LOGFILE);
[128]	1869	} else {
[541]	1870	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
[128]	1871	}
	1872	paranoid_free(command);
	1873	paranoid_free(boot_device);
	1874	paranoid_free(tmp);
	1875	paranoid_free(editor);
	1876	return (res);
[1]	1877	}
[128]	1878
[1]	1879	/**************************************************************************
	1880	END_RUN_RAW_MBR
	1881	**************************************************************************/
	1882
	1883
	1884
	1885	/**
	1886	* malloc() and set sensible defaults for the mondorestore filename variables.
	1887	* @param bkpinfo The backup information structure. Fields used:
	1888	* - @c bkpinfo->tmpdir
	1889	* - @c bkpinfo->disaster_recovery
	1890	*/
[1645]	1891	void setup_MR_global_filenames()
[1]	1892	{
[128]	1893	char *temppath;
[1]	1894
[128]	1895	assert(bkpinfo != NULL);
[1]	1896
[128]	1897	malloc_string(g_biggielist_txt);
	1898	malloc_string(g_filelist_full);
	1899	malloc_string(g_filelist_imagedevs);
	1900	malloc_string(g_imagedevs_restthese);
	1901	malloc_string(g_mondo_cfg_file);
	1902	malloc_string(g_mountlist_fname);
	1903	malloc_string(g_mondo_home);
[2030]	1904	/*
[128]	1905	malloc_string(g_tmpfs_mountpt);
[2030]	1906	*/
[128]	1907	malloc_string(g_isodir_device);
	1908	malloc_string(g_isodir_format);
[1]	1909
[128]	1910	temppath = bkpinfo->tmpdir;
[1]	1911
[128]	1912	sprintf(g_biggielist_txt, "%s/%s", temppath, BIGGIELIST_TXT_STUB);
	1913	sprintf(g_filelist_full, "%s/%s", temppath, FILELIST_FULL_STUB);
	1914	sprintf(g_filelist_imagedevs, "%s/tmp/filelist.imagedevs", temppath);
[1]	1915	// sprintf(g_imagedevs_pot, "%s/tmp/imagedevs.pot", temppath);
[128]	1916	sprintf(g_imagedevs_restthese, "%s/tmp/imagedevs.restore-these",
	1917	temppath);
	1918	if (bkpinfo->disaster_recovery) {
	1919	sprintf(g_mondo_cfg_file, "/%s", MONDO_CFG_FILE_STUB);
	1920	sprintf(g_mountlist_fname, "/%s", MOUNTLIST_FNAME_STUB);
	1921	} else {
	1922	sprintf(g_mondo_cfg_file, "%s/%s", temppath, MONDO_CFG_FILE_STUB);
	1923	sprintf(g_mountlist_fname, "%s/%s", temppath,
	1924	MOUNTLIST_FNAME_STUB);
	1925	}
[1]	1926	}
[128]	1927
[1]	1928	/**************************************************************************
	1929	END_SET_GLOBAL_FILENAME
	1930	**************************************************************************/
	1931
	1932
	1933	/**
	1934	* Copy @p input_file (containing the result of a compare) to @p output_file,
	1935	* deleting spurious "changes" along the way.
	1936	* @param output_file The output file to write with spurious changes removed.
	1937	* @param input_file The input file, a list of changed files created by a compare.
	1938	*/
[128]	1939	void streamline_changes_file(char output_file, char input_file)
[1]	1940	{
[128]	1941	FILE *fin;
	1942	FILE *fout;
[1]	1943	/ malloc /
[128]	1944	char *incoming;
[1]	1945
[128]	1946	assert_string_is_neither_NULL_nor_zerolength(output_file);
	1947	assert_string_is_neither_NULL_nor_zerolength(input_file);
	1948	malloc_string(incoming);
	1949
	1950	if (!(fin = fopen(input_file, "r"))) {
	1951	log_OS_error(input_file);
	1952	return;
	1953	}
	1954	if (!(fout = fopen(output_file, "w"))) {
	1955	fatal_error("cannot open output_file");
	1956	}
	1957	for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
	1958	fgets(incoming, MAX_STR_LEN - 1, fin)) {
	1959	if (strncmp(incoming, "etc/adjtime", 11)
	1960	&& strncmp(incoming, "etc/mtab", 8)
	1961	&& strncmp(incoming, "tmp/", 4)
	1962	&& strncmp(incoming, "boot/map", 8)
	1963	&& !strstr(incoming, "incheckentry")
	1964	&& strncmp(incoming, "etc/mail/statistics", 19)
	1965	&& strncmp(incoming, "var/", 4))
	1966	fprintf(fout, "%s", incoming); /* don't need \n here, for some reason.. */
	1967	}
	1968	paranoid_fclose(fout);
	1969	paranoid_fclose(fin);
	1970	paranoid_free(incoming);
[1]	1971	}
[128]	1972
[1]	1973	/**************************************************************************
	1974	END_STREAMLINE_CHANGES_FILE
	1975	**************************************************************************/
	1976
	1977
	1978	/**
	1979	* Give the user twenty seconds to press Ctrl-Alt-Del before we nuke their drives.
	1980	*/
[128]	1981	void twenty_seconds_til_yikes()
[1]	1982	{
[128]	1983	int i;
	1984	/* MALLOC * */
	1985	char *tmp;
[1]	1986
[128]	1987	malloc_string(tmp);
	1988	if (does_file_exist("/tmp/NOPAUSE")) {
	1989	return;
	1990	}
[541]	1991	open_progress_form("CAUTION",
	1992	"Be advised: I am about to ERASE your hard disk(s)!",
	1993	"You may press Ctrl+Alt+Del to abort safely.",
[128]	1994	"", 20);
	1995	for (i = 0; i < 20; i++) {
	1996	g_current_progress = i;
[541]	1997	sprintf(tmp, "You have %d seconds left to abort.", 20 - i);
[128]	1998	update_progress_form(tmp);
	1999	sleep(1);
	2000	}
	2001	close_progress_form();
	2002	paranoid_free(tmp);
[1]	2003	}
[128]	2004
[1]	2005	/**************************************************************************
	2006	END_TWENTY_SECONDS_TIL_YIKES
	2007	**************************************************************************/
	2008
	2009
	2010	/**
	2011	* Unmount all devices in @p p_external_copy_of_mountlist.
	2012	* @param p_external_copy_of_mountlist The mountlist to guide the devices to unmount.
	2013	* @return 0 for success, nonzero for failure.
	2014	*/
[128]	2015	int unmount_all_devices(struct mountlist_itself
	2016	*p_external_copy_of_mountlist)
[1]	2017	{
[128]	2018	struct mountlist_itself *mountlist;
	2019	int retval = 0, lino, res = 0, i;
	2020	char *command;
	2021	char *tmp;
[1]	2022
[128]	2023	malloc_string(command);
	2024	malloc_string(tmp);
	2025	assert(p_external_copy_of_mountlist != NULL);
[1]	2026
[128]	2027	mountlist = malloc(sizeof(struct mountlist_itself));
	2028	memcpy((void ) mountlist, (void ) p_external_copy_of_mountlist,
	2029	sizeof(struct mountlist_itself));
	2030	sort_mountlist_by_mountpoint(mountlist, 0);
[1]	2031
[691]	2032	run_program_and_log_output("df -m", 3);
[541]	2033	mvaddstr_and_log_it(g_currentY, 0, "Unmounting devices ");
	2034	open_progress_form("Unmounting devices",
	2035	"Unmounting all devices that were mounted,",
	2036	"in preparation for the post-restoration reboot.",
[128]	2037	"", mountlist->entries);
	2038	chdir("/");
	2039	for (i = 0;
	2040	i < 10
	2041	&&
	2042	run_program_and_log_output
[792]	2043	("ps \| grep buffer \| grep -v \"grep buffer\"", TRUE) == 0;
[128]	2044	i++) {
	2045	sleep(1);
	2046	log_msg(2, "Waiting for buffer() to finish");
	2047	}
[1]	2048
[128]	2049	paranoid_system("sync");
[1]	2050
[1322]	2051	sprintf(tmp, "cp -f %s " MNT_RESTORING "/var/log", MONDO_LOGFILE);
	2052	if (run_program_and_log_output(tmp, FALSE)) {
[128]	2053	log_msg(1,
[1315]	2054	"Error. Failed to copy log to PC's /var/log dir. (Mounted read-only?)");
[1]	2055	}
[128]	2056	if (does_file_exist("/tmp/DUMBASS-GENTOO")) {
	2057	run_program_and_log_output("mkdir -p " MNT_RESTORING
	2058	"/mnt/.boot.d", 5);
[1]	2059	}
[1971]	2060
	2061	/* Unmounting the local /proc and /sys first */
	2062	run_program_and_log_output("umount " MNT_RESTORING "/proc",3);
	2063	run_program_and_log_output("umount " MNT_RESTORING "/sys",3);
	2064
[128]	2065	for (lino = mountlist->entries - 1; lino >= 0; lino--) {
	2066	if (!strcmp(mountlist->el[lino].mountpoint, "lvm")) {
	2067	continue;
	2068	}
[541]	2069	sprintf(tmp, "Unmounting device %s ", mountlist->el[lino].device);
[128]	2070
	2071	update_progress_form(tmp);
	2072	if (is_this_device_mounted(mountlist->el[lino].device)) {
	2073	if (!strcmp(mountlist->el[lino].mountpoint, "swap")) {
	2074	sprintf(command, "swapoff %s", mountlist->el[lino].device);
	2075	} else {
	2076	if (!strcmp(mountlist->el[lino].mountpoint, "/1")) {
	2077	sprintf(command, "umount %s/", MNT_RESTORING);
	2078	log_msg(3,
	2079	"Well, I know a certain kitty-kitty who'll be sleeping with Mommy tonight...");
	2080	} else {
	2081	sprintf(command, "umount " MNT_RESTORING "%s",
	2082	mountlist->el[lino].mountpoint);
[2144]	2083
	2084	/* To support latest Ubuntu where /var is a separate FS
	2085	* Cf: http://linux.derkeiler.com/Mailing-Lists/Ubuntu/2007-04/msg01319.html
	2086	* we need to create some dirs under the real / before unmounting it */
	2087	if (!strcmp(mountlist->el[lino].mountpoint, "/")) {
	2088	run_program_and_log_output("mkdir -p " MNT_RESTORING "/var/lock", FALSE);
	2089	run_program_and_log_output("mkdir -p " MNT_RESTORING "/var/run", FALSE);
	2090	}
[128]	2091	}
	2092	}
	2093	log_msg(10, "The 'umount' command is '%s'", command);
	2094	res = run_program_and_log_output(command, 3);
	2095	} else {
[541]	2096	strcat(tmp, "...not mounted anyway :-) OK");
[128]	2097	res = 0;
	2098	}
	2099	g_current_progress++;
	2100	if (res) {
[541]	2101	strcat(tmp, "...Failed");
[128]	2102	retval++;
	2103	log_to_screen(tmp);
	2104	} else {
	2105	log_msg(2, tmp);
	2106	}
	2107	}
	2108	close_progress_form();
	2109	if (retval) {
[541]	2110	mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
[128]	2111	} else {
[541]	2112	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
[128]	2113	}
	2114	if (retval) {
[541]	2115	log_to_screen("Unable to unmount some of your partitions.");
[128]	2116	} else {
[541]	2117	log_to_screen("All partitions were unmounted OK.");
[128]	2118	}
	2119	free(mountlist);
	2120	paranoid_free(command);
	2121	paranoid_free(tmp);
	2122	return (retval);
[1]	2123	}
[128]	2124
[1]	2125	/**************************************************************************
	2126	END_UNMOUNT_ALL_DEVICES
	2127	**************************************************************************/
	2128
	2129
	2130
	2131	/**
	2132	* Extract mondo-restore.cfg and the mountlist from the tape inserted
	2133	* to the ./tmp/ directory.
	2134	* @param dev The tape device to read from.
	2135	* @return 0 for success, nonzero for failure.
	2136	*/
[128]	2137	int extract_cfg_file_and_mountlist_from_tape_dev(char *dev)
[1]	2138	{
[128]	2139	char *command;
	2140	int res = 0;
[1]	2141
[128]	2142	malloc_string(command);
[1]	2143
[1968]	2144	if (bkpinfo->use_obdr) {
	2145	skip_obdr();
[1990]	2146	} else {
	2147	// BCO: below 32KB seems to block at least on RHAS 2.1 and MDK 10.0
	2148	set_tape_block_size_with_mt(bkpinfo->internal_tape_block_size);
[1968]	2149	}
[1990]	2150
[128]	2151	sprintf(command,
[2029]	2152	"dd if=%s bs=%ld count=%ld 2> /dev/null \| tar -zx ./%s ./%s ./%s ./%s ./%s",
[128]	2153	dev,
[1990]	2154	bkpinfo->internal_tape_block_size,
	2155	1024L * 1024 * 32 / bkpinfo->internal_tape_block_size,
[128]	2156	MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB,
[2029]	2157	BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);
[128]	2158	log_msg(2, "command = '%s'", command);
	2159	res = run_program_and_log_output(command, -1);
[2029]	2160	if (res != 0) {
	2161	if (does_file_exist(MONDO_CFG_FILE_STUB)) {
	2162	res = 0;
	2163	} else {
	2164	/* Doing that allow us to remain compatible with pre-2.2.5 versions */
	2165	log_msg(2, "pre-2.2.4 compatible mode on");
	2166	sprintf(command,
	2167	"dd if=%s bs=%ld count=%ld 2> /dev/null \| tar -zx %s %s %s %s %s",
	2168	dev,
	2169	bkpinfo->internal_tape_block_size,
	2170	1024L * 1024 * 32 / bkpinfo->internal_tape_block_size,
	2171	MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB,
	2172	BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);
	2173	log_msg(2, "command = '%s'", command);
	2174	res = run_program_and_log_output(command, -1);
	2175	if ((res != 0) && (does_file_exist(MONDO_CFG_FILE_STUB))) {
	2176	res = 0;
	2177	}
	2178	}
[128]	2179	}
	2180	paranoid_free(command);
	2181	return (res);
[1]	2182	}
	2183
[128]	2184
	2185
[1]	2186	/**
	2187	* Get the configuration file from the floppy, tape, or CD.
	2188	* @param bkpinfo The backup information structure. Fields used:
	2189	* - @c bkpinfo->backup_media_type
	2190	* - @c bkpinfo->media_device
	2191	* - @c bkpinfo->tmpdir
	2192	* @return 0 for success, nonzero for failure.
	2193	*/
[1645]	2194	int get_cfg_file_from_archive()
[1]	2195	{
[128]	2196	int retval = 0;
	2197
[1]	2198	/ malloc ***/
[128]	2199	char *device;
	2200	char *command;
	2201	char *cfg_file;
	2202	char *mounted_cfgf_path;
	2203	char *tmp;
	2204	char *mountpt;
	2205	char *ramdisk_fname;
	2206	char *mountlist_file;
[2049]	2207	bool extract_mountlist_stub;
	2208	bool extract_i_want_my_lvm;
[1]	2209
[128]	2210	bool try_plan_B;
	2211
	2212	assert(bkpinfo != NULL);
	2213	malloc_string(cfg_file);
	2214	malloc_string(mounted_cfgf_path);
	2215	malloc_string(mountpt);
	2216	malloc_string(ramdisk_fname);
	2217	malloc_string(mountlist_file);
	2218	malloc_string(device);
	2219	malloc_string(command);
	2220	malloc_string(tmp);
	2221	log_msg(2, "gcffa --- starting");
[541]	2222	log_to_screen("I'm thinking...");
[128]	2223	sprintf(mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
	2224	device[0] = '\0';
	2225	chdir(bkpinfo->tmpdir);
	2226	strcpy(cfg_file, MONDO_CFG_FILE_STUB);
	2227	unlink(cfg_file); // cfg_file[] is missing the '/' at the start, FYI, by intent
	2228	unlink(FILELIST_FULL_STUB);
	2229	unlink(BIGGIELIST_TXT_STUB);
	2230	sprintf(command, "mkdir -p %s", mountpt);
	2231	run_program_and_log_output(command, FALSE);
	2232
	2233	sprintf(cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
[2049]	2234	sprintf(mountlist_file, "%s/%s", bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
[128]	2235	// make_hole_for_file( cfg_file );
	2236	// make_hole_for_file( mountlist_file);
	2237	log_msg(2, "mountpt = %s; cfg_file=%s", mountpt, cfg_file);
	2238
	2239	if (!does_file_exist(cfg_file)) {
	2240	log_msg(2, "gcffa --- we don't have cfg file yet.");
	2241	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
	2242	try_plan_B = TRUE;
	2243	} else {
[1736]	2244	log_msg(2, "gcffa --- calling mount_media now :)");
	2245	if (!mount_media()) {
[128]	2246	log_msg(2,
	2247	"gcffa --- managed to mount CD; so, no need for Plan B");
	2248	try_plan_B = FALSE;
	2249	} else {
	2250	try_plan_B = TRUE;
	2251	}
[1645]	2252	if (what_number_cd_is_this() > 1) {
	2253	insist_on_this_cd_number((g_current_media_number = 1));
[128]	2254	}
	2255	}
	2256	if (try_plan_B) {
	2257	log_msg(2, "gcffa --- OK, switching to Plan B");
	2258	chdir(bkpinfo->tmpdir);
	2259	run_program_and_log_output("mkdir -p tmp", FALSE);
[1]	2260
[128]	2261	if (strlen(bkpinfo->media_device) == 0) {
	2262	strcpy(bkpinfo->media_device, "/dev/st0");
	2263	log_msg(2, "media_device is blank; assuming %s");
	2264	}
	2265	strcpy(tmp, bkpinfo->media_device);
	2266	if (extract_cfg_file_and_mountlist_from_tape_dev
	2267	(bkpinfo->media_device)) {
	2268	strcpy(bkpinfo->media_device, "/dev/st0");
	2269	if (extract_cfg_file_and_mountlist_from_tape_dev
	2270	(bkpinfo->media_device)) {
	2271	strcpy(bkpinfo->media_device, "/dev/osst0");
	2272	if (extract_cfg_file_and_mountlist_from_tape_dev
	2273	(bkpinfo->media_device)) {
	2274	strcpy(bkpinfo->media_device, "/dev/ht0");
	2275	if (extract_cfg_file_and_mountlist_from_tape_dev
	2276	(bkpinfo->media_device)) {
	2277	log_msg(3,
	2278	"I tried lots of devices but none worked.");
	2279	strcpy(bkpinfo->media_device, tmp);
	2280	}
	2281	}
	2282	}
	2283	}
[1]	2284
[128]	2285	if (!does_file_exist("tmp/mondo-restore.cfg")) {
[1885]	2286	log_to_screen("Cannot find config info on media");
[128]	2287	return (1);
	2288	}
	2289	} else {
[2049]	2290	if (does_file_exist("/"MOUNTLIST_FNAME_STUB)) {
	2291	extract_mountlist_stub = FALSE;
	2292	} else {
	2293	extract_mountlist_stub = TRUE;
	2294	}
	2295	if (does_file_exist("/"IWANTMYLVM_STUB)) {
	2296	extract_i_want_my_lvm = FALSE;
	2297	} else {
	2298	extract_i_want_my_lvm = TRUE;
	2299	}
	2300
[128]	2301	log_msg(2,
[1406]	2302	"gcffa --- Plan B, a.k.a. untarring some file from all.tar.gz");
[2029]	2303	sprintf(command, "tar -zxvf " MNT_CDROM "/images/all.tar.gz ./%s ./%s ./%s ./%s ./%s", MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB); // add -b TAPE_BLOCK_SIZE if you _really_ think it's necessary
[128]	2304	run_program_and_log_output(command, TRUE);
	2305	if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
[2029]	2306	/* Doing that allow us to remain compatible with pre-2.2.5 versions */
	2307	log_msg(2, "pre-2.2.4 compatible mode on");
	2308	sprintf(command, "tar -zxvf " MNT_CDROM "/images/all.tar.gz %s %s %s %s %s", MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB); // add -b TAPE_BLOCK_SIZE if you _really_ think it's necessary
	2309	run_program_and_log_output(command, TRUE);
	2310	if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
	2311	fatal_error
	2312	("Please reinsert the disk/CD and try again.");
	2313	}
[128]	2314	}
[1]	2315	}
[128]	2316	}
	2317	if (does_file_exist(MONDO_CFG_FILE_STUB)) {
	2318	log_msg(1, "gcffa --- great! We've got the config file");
	2319	sprintf(tmp, "%s/%s",
	2320	call_program_and_get_last_line_of_output("pwd"),
	2321	MONDO_CFG_FILE_STUB);
	2322	sprintf(command, "cp -f %s %s", tmp, cfg_file);
	2323	iamhere(command);
	2324	if (strcmp(tmp, cfg_file)
	2325	&& run_program_and_log_output(command, 1)) {
	2326	log_msg(1,
	2327	"... but an error occurred when I tried to move it to %s",
	2328	cfg_file);
	2329	} else {
	2330	log_msg(1, "... and I moved it successfully to %s", cfg_file);
	2331	}
	2332	sprintf(command, "cp -f %s/%s %s",
[2049]	2333	call_program_and_get_last_line_of_output("pwd"),
	2334	MOUNTLIST_FNAME_STUB, mountlist_file);
[128]	2335	iamhere(command);
[2049]	2336	if (extract_mountlist_stub) {
	2337	if (strcmp(tmp, cfg_file)
	2338	&& run_program_and_log_output(command, 1)) {
	2339	log_msg(1, "Failed to get mountlist");
[128]	2340	} else {
[2049]	2341	log_msg(1, "Got mountlist too");
	2342	sprintf(command, "cp -f %s %s", mountlist_file,
	2343	g_mountlist_fname);
	2344	if (run_program_and_log_output(command, 1)) {
	2345	log_msg(1, "Failed to copy mountlist to /tmp");
	2346	} else {
	2347	log_msg(1, "Copied mountlist to /tmp as well OK");
	2348	sprintf(command, "cp -f %s /tmp/",IWANTMYLVM_STUB);
	2349	run_program_and_log_output(command, 1);
	2350	}
[128]	2351	}
	2352	}
	2353	}
	2354	run_program_and_log_output("umount " MNT_CDROM, FALSE);
	2355	if (!does_file_exist(cfg_file)) {
	2356	iamhere(cfg_file);
	2357	log_msg(1, "%s not found", cfg_file);
	2358	log_to_screen
[541]	2359	("Oh dear. Unable to recover configuration file from boot disk");
[128]	2360	return (1);
	2361	}
[1]	2362
[541]	2363	log_to_screen("Recovered mondo-restore.cfg");
[128]	2364	if (!does_file_exist(MOUNTLIST_FNAME_STUB)) {
[541]	2365	log_to_screen("...but not mountlist.txt - a pity, really...");
[128]	2366	}
	2367	else {
[2049]	2368	/* Is this code really useful ??? */
	2369	if (extract_mountlist_stub) {
	2370	sprintf(command, "cp -f %s %s/%s", MOUNTLIST_FNAME_STUB,
	2371	bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
	2372	run_program_and_log_output(command, FALSE);
	2373	}
[128]	2374	}
[1]	2375
[128]	2376	sprintf(command, "cp -f %s /%s", cfg_file, MONDO_CFG_FILE_STUB);
	2377	run_program_and_log_output(command, FALSE);
[2049]	2378	if (extract_mountlist_stub) {
	2379	sprintf(command, "cp -f %s /%s", mountlist_file, MOUNTLIST_FNAME_STUB);
	2380	run_program_and_log_output(command, FALSE);
	2381	}
[128]	2382	sprintf(command, "cp -f etc/raidtab /etc/");
	2383	run_program_and_log_output(command, FALSE);
[2049]	2384	if (extract_i_want_my_lvm) {
	2385	sprintf(command, "cp -f %s /tmp/",IWANTMYLVM_STUB);
	2386	run_program_and_log_output(command, FALSE);
	2387	}
[128]	2388	g_backup_media_type = bkpinfo->backup_media_type;
	2389	paranoid_free(device);
	2390	paranoid_free(command);
	2391	paranoid_free(tmp);
	2392	paranoid_free(cfg_file);
	2393	paranoid_free(mounted_cfgf_path);
	2394	paranoid_free(mountpt);
	2395	paranoid_free(ramdisk_fname);
	2396	paranoid_free(mountlist_file);
	2397	return (retval);
[1]	2398	}
	2399
	2400	/**************************************************************************
	2401	END_GET_CFG_FILE_FROM_ARCHIVE
	2402	**************************************************************************/
	2403
	2404	/* @} - end restoreUtilityGroup */
	2405
	2406
	2407	/***************************************************************************
	2408	* F@ *
	2409	* () -- Hugo Rabson *
	2410	* *
	2411	* Purpose: *
	2412	* *
	2413	* Called by: *
	2414	* Params: - - *
	2415	* Returns: 0=success; nonzero=failure *
	2416	***************************************************************************/
	2417
[128]	2418
	2419
	2420	void wait_until_software_raids_are_prepped(char *mdstat_file,
	2421	int wait_for_percentage)
[1]	2422	{
[558]	2423	struct raidlist_itself *raidlist;
[128]	2424	int unfinished_mdstat_devices = 9999, i;
	2425	char *screen_message;
[1]	2426
[128]	2427	malloc_string(screen_message);
[558]	2428	raidlist = malloc(sizeof(struct raidlist_itself));
[128]	2429
	2430	assert(wait_for_percentage <= 100);
[799]	2431	iamhere("wait_until_software_raids_are_prepped");
[128]	2432	while (unfinished_mdstat_devices > 0) {
[558]	2433	// FIXME: Prefix '/dev/' should really be dynamic!
	2434	if (parse_mdstat(raidlist, "/dev/")) {
	2435	log_to_screen("Sorry, cannot read %s", MDSTAT_FILE);
	2436	log_msg(1,"Sorry, cannot read %s", MDSTAT_FILE);
[128]	2437	return;
[1]	2438	}
[558]	2439	for (unfinished_mdstat_devices = i = 0; i <= raidlist->entries; i++) {
	2440	if (raidlist->el[i].progress < wait_for_percentage) {
[128]	2441	unfinished_mdstat_devices++;
[704]	2442	if (raidlist->el[i].progress == -1) // delayed while another partition inits
	2443	{
	2444	continue;
	2445	}
[558]	2446	log_msg(1,"Sync'ing %s (i=%d)", raidlist->el[i].raid_device, i);
	2447	sprintf(screen_message, "Sync'ing %s",
	2448	raidlist->el[i].raid_device);
[128]	2449	open_evalcall_form(screen_message);
[558]	2450	while (raidlist->el[i].progress < wait_for_percentage) {
	2451	log_msg(1,"Percentage sync'ed: %d", raidlist->el[i].progress);
	2452	update_evalcall_form(raidlist->el[i].progress);
[128]	2453	sleep(2);
[558]	2454	// FIXME: Prefix '/dev/' should really be dynamic!
	2455	if (parse_mdstat(raidlist, "/dev/")) {
[128]	2456	break;
	2457	}
	2458	}
	2459	close_evalcall_form();
	2460	}
[1]	2461	}
[128]	2462	}
	2463	paranoid_free(screen_message);
[558]	2464	paranoid_free(raidlist);
[1]	2465	}
[2094]	2466
	2467

Note: See TracBrowser for help on using the repository browser.

Download in other formats: