Context Navigation

source: MondoRescue/branches/stable/mondo/src/mondorestore/mondorestore.c@ 1903

Visit:

Last change on this file since 1903 was 1903, checked in by Bruno Cornec, 16 years ago
merge -r 1842:1889 2.2.5
Property svn:keywords set to `Id`
File size: 97.8 KB

Rev	Line
[1]	1	/***************************************************************************
[1080]	2	* restores mondoarchive data
	3	* $Id: mondorestore.c 1903 2008-04-09 23:13:58Z bruno $
[1]	4	***************************************************************************/
	5
	6	/**
	7	* @file
	8	* The main file for mondorestore.
	9	*/
	10
	11	/**************************************************************************
	12	* #include statements *
	13	**************************************************************************/
[1199]	14	#include <unistd.h>
[1203]	15	#include <utime.h>
[1555]	16	#include <locale.h>
[1199]	17
[1458]	18	#include "mr_gettext.h"
[1067]	19	#include "my-stuff.h"
[1168]	20	#include "mr_mem.h"
	21	#include "mr_msg.h"
	22	#include "mr_str.h"
[1264]	23	#include "mr_err.h"
[1265]	24	#include "mr_conf.h"
[1168]	25
	26	#include "mondostructures.h"
	27	#include "libmondo.h"
[1]	28	#include "mr-externs.h"
	29	#include "mondo-restore.h"
[1326]	30	#include "mondorestore.h"
[1]	31	#include "mondo-rstr-compare-EXT.h"
	32	#include "mondo-rstr-tools-EXT.h"
	33
[1625]	34	#define DEFAULT_MR_LOGLEVEL 4
	35
[1]	36	extern void twenty_seconds_til_yikes(void);
	37
[1663]	38	/* Reference to global bkpinfo */
	39	struct s_bkpinfo *bkpinfo;
	40
[1]	41	/* For use in other programs (ex. XMondo) */
	42	#ifdef MONDORESTORE_MODULE
	43	#define main __mondorestore_main
	44	#define g_ISO_restore_mode __mondorestore_g_ISO_restore_mode
	45	#endif
	46
[128]	47	//static char cvsid[] = "$Id: mondorestore.c 1903 2008-04-09 23:13:58Z bruno $";
[1]	48
	49	/**************************************************************************
	50	* Globals *
	51	**************************************************************************/
[128]	52	extern char *g_tmpfs_mountpt; // declared in libmondo-tools.c
[1]	53	extern bool g_text_mode;
	54	extern FILE *g_fprep;
	55	extern double g_kernel_version;
	56	extern int g_partition_table_locked_up;
	57	extern int g_noof_rows;
	58
	59	extern int partition_everything(struct mountlist_itself *mountlist);
	60
	61
	62	/**
	63	* @name Restore-Time Globals
	64	* @ingroup globalGroup
	65	* @{
	66	*/
	67	/**
	68	* If TRUE, then SIGPIPE was just caught.
	69	* Set by the signal handler; cleared after it's handled.
	70	*/
[128]	71	bool g_sigpipe_caught = FALSE;
[1]	72
	73	/**
	74	* If TRUE, then we're restoring from ISOs or an NFS server.
	75	* If FALSE, then we're restoring from some kind of real media (tape, CD, etc.)
	76	*/
[128]	77	bool g_ISO_restore_mode = FALSE; /* are we in Iso Mode? */
[1]	78
	79	/**
	80	* If TRUE, then we have had a successful "nuke" restore.
	81	*/
[128]	82	bool g_I_have_just_nuked = FALSE;
[1]	83
	84	/**
	85	* The device to mount to get at the ISO images. Ignored unless @p g_ISO_restore_mode.
	86	*/
[1199]	87	char *g_isodir_device = NULL;
[1]	88
	89	/**
	90	* The format of @p g_isodir_device. Ignored unless @p g_ISO_restore_mode.
	91	*/
[1199]	92	char *g_isodir_format = NULL;
[1]	93
	94	/**
	95	* The location of 'biggielist.txt', containing the biggiefiles on the current archive set.
	96	*/
[1199]	97	char *g_biggielist_txt = NULL;
[1]	98
	99	/**
	100	* The location of 'filelist.full', containing all files (<em>including biggiefiles</em>) on
	101	* the current archive set.
	102	*/
[1199]	103	char *g_filelist_full = NULL;
[1]	104
	105	/**
	106	* The location of a file containing a list of the devices that were archived
	107	* as images, not as individual files.
	108	*/
[1199]	109	char *g_filelist_imagedevs = NULL;
[1]	110
	111	/**
	112	* The location of a file containing a list of imagedevs to actually restore.
	113	* @see g_filelist_imagedevs
	114	*/
[1199]	115	char *g_imagedevs_restthese = NULL;
[1]	116
	117	/**
	118	* The location of 'mondo-restore.cfg', containing the metadata
	119	* information for this backup.
	120	*/
[1199]	121	char *g_mondo_cfg_file = NULL;
[1]	122
	123	/**
	124	* The location of 'mountlist.txt', containing the information on the
	125	* user's partitions and hard drives.
	126	*/
[1199]	127	char *g_mountlist_fname = NULL;
[1]	128
[952]	129	extern char *g_getfacl;
	130	extern char *g_getfattr;
[946]	131
[1]	132	/* @} - end of "Restore-Time Globals" in globalGroup */
	133
[128]	134	extern int copy_from_src_to_dest(FILE * f_orig, FILE * f_archived,
	135	char direction);
[1]	136
[1626]	137	struct mr_rs_conf *mr_conf = NULL;
[1264]	138
	139	/* destroy the mr_rs_conf structure's content */
	140	static void mr_rs_clean_conf(struct mr_rs_conf *mr_cnf) {
	141
	142	if (mr_cnf == NULL) {
	143	return;
	144	}
[1265]	145	mr_free(mr_cnf->media_device);
	146	mr_free(mr_cnf->prefix);
	147	mr_free(mr_cnf->boot_loader);
	148	mr_free(mr_cnf->compression_tool);
	149	mr_free(mr_cnf->ui_mode);
	150	mr_free(mr_cnf->images_dir);
[1264]	151	}
	152
	153	/* Create the pointer to the function called in mr_exit */
	154	void (*mr_cleanup)(void) = NULL;
	155
	156	/* Cleanup all memory allocated in various structures */
	157	void mr_rs_cleanup(void) {
	158	/* Highly incomplete function for the moment */
	159	/* We have to free all allocated memory */
	160	/* Not allocated yet
	161	mr_rs_clean_conf(&mr_conf);
	162	*/
[1265]	163	mr_rs_clean_conf(NULL);
[1264]	164	/* We have to remove all temporary files */
	165	/* We have to unmount what has been mounted */
	166	/* We have to properly end newt */
	167	/* We have to remind people of log files */
	168
	169	mr_msg_close();
	170	}
	171
[1626]	172	/* reset/empty the mr_ar_conf structure from mondo's conf file */
	173	static void mr_rs_reset_conf(struct mr_rs_conf *mr_cnf) {
	174
	175	/* This should correspond to the default conf file */
	176	/* Especially for boolean values */
	177	mr_cnf->media_size = 0;
	178	mr_cnf->media_device = NULL;
	179	mr_cnf->manual_tray = FALSE;
	180	mr_cnf->log_level = 0;
	181	mr_cnf->prefix = NULL;
	182	mr_cnf->external_tape_blocksize = 0;
	183	mr_cnf->internal_tape_blocksize = 0;
	184	mr_cnf->boot_loader = NULL;
	185	mr_cnf->differential = FALSE;
	186	mr_cnf->compression_tool = NULL;
	187	mr_cnf->ui_mode = NULL;
	188	mr_cnf->automatic_restore = FALSE;
	189	mr_cnf->images_dir = NULL;
	190	}
	191
[1]	192	/**************************************************************************
	193	* COMPAQ PROLIANT Stuff: needs some special help *
	194	**************************************************************************/
	195
	196	/**
	197	* The message to display if we detect that the user is using a Compaq Proliant.
	198	*/
[1581]	199	#define COMPAQ_PROLIANTS_SUCK _("Partition and format your disk using Compaq's disaster recovery CD. After you've done that, please reboot with your Mondo media in Interactive Mode.")
[1]	200
	201
	202	/**
	203	* Allow the user to modify the mountlist before we partition & format their drives.
	204	* @param bkpinfo The backup information structure. @c disaster_recovery is the only field used.
	205	* @param mountlist The mountlist to let the user modify.
	206	* @param raidlist The raidlist that goes with @p mountlist.
	207	* @return 0 for success, nonzero for failure.
	208	* @ingroup restoreGuiGroup
	209	*/
[1663]	210	int let_user_edit_the_mountlist(struct mountlist_itself *mountlist,
[128]	211	struct raidlist_itself *raidlist)
[1]	212	{
[128]	213	int retval = 0, res = 0;
[1]	214
[1108]	215	mr_msg(2, "let_user_edit_the_mountlist() --- starting");
[1]	216
[128]	217	assert(bkpinfo != NULL);
	218	assert(mountlist != NULL);
	219	assert(raidlist != NULL);
	220	if (!bkpinfo->disaster_recovery) {
	221	strcpy(g_mountlist_fname, "/tmp/mountlist.txt");
[1108]	222	mr_msg(2, "I guess you're testing edit_mountlist()");
[1]	223	}
[128]	224	if (!does_file_exist(g_mountlist_fname)) {
	225	log_to_screen(g_mountlist_fname);
[1199]	226	log_to_screen(_("does not exist"));
[128]	227	return (1);
	228	}
[1]	229
[128]	230	retval = load_mountlist(mountlist, g_mountlist_fname);
	231	load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
	232	if (retval) {
	233	log_to_screen
[1199]	234	(_("Warning - load_raidtab_into_raidlist returned an error"));
[128]	235	}
	236	res = edit_mountlist(g_mountlist_fname, mountlist, raidlist);
	237	if (res) {
	238	return (1);
	239	}
[1]	240
[128]	241	save_mountlist_to_disk(mountlist, g_mountlist_fname);
	242	save_raidlist_to_raidtab(raidlist, RAIDTAB_FNAME);
[1]	243
[1199]	244	log_to_screen(_("I have finished editing the mountlist for you."));
[1]	245
[128]	246	return (retval);
	247	}
[1]	248
	249
	250	/**
	251	* Determine whether @p mountlist contains a Compaq diagnostic partition.
	252	* @param mountlist The mountlist to examine.
	253	* @return TRUE if there's a Compaq diagnostic partition; FALSE if not.
	254	* @ingroup restoreUtilityGroup
	255	*/
[128]	256	bool
	257	partition_table_contains_Compaq_diagnostic_partition(struct
	258	mountlist_itself *
	259	mountlist)
[1]	260	{
[128]	261	int i;
[1]	262
[128]	263	assert(mountlist != NULL);
[1]	264
[128]	265	for (i = 0; i < mountlist->entries; i++) {
	266	if (strstr(mountlist->el[i].format, "ompaq")) {
[1108]	267	mr_msg(2, "mountlist[%d] (%s) is %s (Compaq alert!)",
[128]	268	i, mountlist->el[i].device, mountlist->el[i].format);
	269
	270	return (TRUE);
	271	}
[1]	272	}
[128]	273	return (FALSE);
[1]	274	}
[128]	275
[1]	276	/**************************************************************************
	277	END_PARTITION_TABLE_CONTAINS_COMPAQ_DIAGNOSTIC_PARTITION
	278	**************************************************************************/
	279
	280
	281	/**
	282	* Allow the user to abort the backup if we find that there is a Compaq diagnostic partition.
	283	* @note This function does not actually check for the presence of a Compaq partition.
	284	* @ingroup restoreUtilityGroup
	285	*/
[128]	286	void offer_to_abort_because_Compaq_Proliants_suck(void)
[1]	287	{
[128]	288	popup_and_OK(COMPAQ_PROLIANTS_SUCK);
	289	if (ask_me_yes_or_no
[1203]	290	(_("Would you like to reboot and use your Compaq CD to prep your hard drive?")))
[128]	291	{
[1203]	292	fatal_error(_("Aborting. Please reboot and prep your hard drive with your Compaq CD."));
[128]	293	}
[1]	294	}
[128]	295
[1]	296	/**************************************************************************
	297	END_OFFER_TO_ABORT_BECAUSE_COMPAQ_PROLIANTS_SUCK
	298	**************************************************************************/
	299
	300
	301	/**
	302	* Call interactive_mode(), nuke_mode(), or compare_mode() depending on the user's choice.
	303	* @param bkpinfo The backup information structure. Most fields are used.
	304	* @param mountlist The mountlist containing information about the user's partitions.
	305	* @param raidlist The raidlist to go with @p mountlist.
	306	* @return The return code from the mode function called.
	307	* @ingroup restoreGroup
	308	*/
[128]	309	int
[1663]	310	catchall_mode(struct mountlist_itself *mountlist,
[128]	311	struct raidlist_itself *raidlist)
[1]	312	{
[128]	313	char c, *tmp;
	314	int retval = 0;
[1]	315
[128]	316	iamhere("inside catchall");
	317	assert(bkpinfo != NULL);
	318	assert(mountlist != NULL);
	319	assert(raidlist != NULL);
	320	iamhere("pre wrm");
	321	c = which_restore_mode();
	322	iamhere("post wrm");
	323	if (c == 'I' \|\| c == 'N' \|\| c == 'C') {
[1663]	324	interactively_obtain_media_parameters_from_user(FALSE);
[128]	325	} else {
[1203]	326	popup_and_OK(_("No restoring or comparing will take place today."));
[128]	327	if (is_this_device_mounted("/mnt/cdrom")) {
	328	run_program_and_log_output("umount /mnt/cdrom", FALSE);
	329	}
	330	if (g_ISO_restore_mode) {
[1199]	331	mr_asprintf(&tmp, "umount %s", bkpinfo->isodir);
[128]	332	run_program_and_log_output(tmp, FALSE);
[1199]	333	mr_free(tmp);
[128]	334	}
	335	paranoid_MR_finish(0);
[1]	336	}
	337
[128]	338	iamhere("post int");
[1]	339
[128]	340	if (bkpinfo->backup_media_type == iso) {
[1663]	341	if (iso_fiddly_bits((c == 'N') ? TRUE : FALSE)) {
[1108]	342	mr_msg(2,
[128]	343	"catchall_mode --- iso_fiddly_bits returned w/ error");
	344	return (1);
	345	} else {
[1108]	346	mr_msg(2, "catchall_mode --- iso_fiddly_bits ok");
[128]	347	}
	348	}
[1]	349
[128]	350	if (c == 'I') {
[1108]	351	mr_msg(2, "IM selected");
[1663]	352	retval += interactive_mode(mountlist, raidlist);
[128]	353	} else if (c == 'N') {
[1108]	354	mr_msg(2, "NM selected");
[1663]	355	retval += nuke_mode(mountlist, raidlist);
[128]	356	} else if (c == 'C') {
[1108]	357	mr_msg(2, "CM selected");
[1663]	358	retval += compare_mode(mountlist, raidlist);
[128]	359	}
	360	return (retval);
[1]	361	}
[128]	362
[1]	363	/**************************************************************************
	364	END_CATCHALL_MODE
	365	**************************************************************************/
	366
	367	/**************************************************************************
	368	END_ EXTRACT_CONFIG_FILE_FROM_RAMDISK
	369	**************************************************************************/
	370
[1663]	371	static void clean_blkid() {
[1]	372
[1548]	373	char *tmp1 = NULL;
	374
	375	/* Clean up blkid cache file if they exist */
	376	mr_asprintf(&tmp1,"%s/etc/blkid.tab",bkpinfo->restore_path);
	377	(void)unlink(tmp1);
	378	mr_free(tmp1);
	379	mr_asprintf(&tmp1,"%s/etc/blkid.tab.old",bkpinfo->restore_path);
	380	(void)unlink(tmp1);
	381	mr_free(tmp1);
	382	}
	383
	384
[1]	385	/**
	386	* @addtogroup restoreGroup
	387	* @{
	388	*/
	389	/**
	390	* Restore the user's data, in a disaster recovery situation, prompting the
	391	* user about whether or not to do every step.
	392	* The user can edit the mountlist, choose files to restore, etc.
	393	* @param bkpinfo The backup information structure. Most fields are used.
	394	* @param mountlist The mountlist containing information about the user's partitions.
	395	* @param raidlist The raidlist to go with @p mountlist.
	396	* @return 0 for success, or the number of errors encountered.
	397	*/
[128]	398	int
[1663]	399	interactive_mode(struct mountlist_itself *mountlist,
[128]	400	struct raidlist_itself *raidlist)
[1]	401	{
[128]	402	int retval = 0;
	403	int res;
	404	int ptn_errs = 0;
	405	int fmt_errs = 0;
[1]	406
[128]	407	bool done;
	408	bool restore_all;
[1]	409
[1199]	410	char *tmp = NULL;
	411	char *tmp1 = NULL;
	412	char *fstab_fname = NULL;
	413	char *old_restpath = NULL;
[1]	414
[1199]	415	struct s_node *filelist = NULL;
[1]	416
[128]	417	/* try to partition and format */
[1]	418
[1108]	419	mr_msg(2, "interactive_mode --- starting (great, assertions OK)");
[1]	420
[128]	421	assert(bkpinfo != NULL);
	422	assert(mountlist != NULL);
	423	assert(raidlist != NULL);
[1]	424
[1108]	425	mr_msg(2, "interactive_mode --- assertions OK");
[1]	426
[128]	427	if (g_text_mode) {
	428	if (!ask_me_yes_or_no
[1203]	429	(_("Interactive Mode + textonly = experimental! Proceed anyway?")))
[128]	430	{
	431	fatal_error("Wise move.");
	432	}
	433	}
	434
	435	iamhere("About to load config file");
[1663]	436	get_cfg_file_from_archive_or_bust();
	437	read_cfg_file_into_bkpinfo(g_mondo_cfg_file);
[128]	438	iamhere("Done loading config file; resizing ML");
[1903]	439	if (bkpinfo->backup_media_type == nfs) {
[1770]	440	mr_asprintf(&tmp,bkpinfo->prefix);
	441	if (popup_and_get_string
	442	("Prefix", "Prefix of your ISO images ?", tmp, MAX_STR_LEN / 4)) {
	443	mr_free(bkpinfo->prefix);
	444	bkpinfo->prefix = tmp;
	445	mr_msg(1, "Prefix set to %s",bkpinfo->prefix);
	446	}
[1454]	447	}
	448
[1]	449	#ifdef __FreeBSD__
[128]	450	if (strstr
	451	(call_program_and_get_last_line_of_output("cat /tmp/cmdline"),
	452	"noresize"))
[1]	453	#else
[128]	454	if (strstr
	455	(call_program_and_get_last_line_of_output("cat /proc/cmdline"),
	456	"noresize"))
[1]	457	#endif
[128]	458	{
[1108]	459	mr_msg(1, "Not resizing mountlist.");
[128]	460	} else {
	461	resize_mountlist_proportionately_to_suit_new_drives(mountlist);
[1]	462	}
[128]	463	for (done = FALSE; !done;) {
	464	iamhere("About to edit mountlist");
	465	if (g_text_mode) {
	466	save_mountlist_to_disk(mountlist, g_mountlist_fname);
[1199]	467	mr_asprintf(&tmp, "%s %s", find_my_editor(), g_mountlist_fname);
[128]	468	res = system(tmp);
[1199]	469	mr_free(tmp);
[128]	470	load_mountlist(mountlist, g_mountlist_fname);
	471	} else {
	472	res = edit_mountlist(g_mountlist_fname, mountlist, raidlist);
[1]	473	}
[128]	474	iamhere("Finished editing mountlist");
	475	if (res) {
	476	paranoid_MR_finish(1);
[1]	477	}
[1108]	478	mr_msg(2, "Proceeding...");
[128]	479	save_mountlist_to_disk(mountlist, g_mountlist_fname);
	480	save_raidlist_to_raidtab(raidlist, RAIDTAB_FNAME);
[1199]	481	mvaddstr_and_log_it(1, 30, _("Restoring Interactively"));
[128]	482	if (bkpinfo->differential) {
[1203]	483	log_to_screen(_("Because this is a differential backup, disk"));
	484	log_to_screen(_(" partitioning and formatting will not take place."));
[128]	485	done = TRUE;
	486	} else {
	487	if (ask_me_yes_or_no
[1203]	488	(_("Do you want to erase and partition your hard drives?")))
[1199]	489	{
[128]	490	if (partition_table_contains_Compaq_diagnostic_partition
	491	(mountlist)) {
	492	offer_to_abort_because_Compaq_Proliants_suck();
	493	done = TRUE;
	494	} else {
	495	twenty_seconds_til_yikes();
	496	g_fprep = fopen("/tmp/prep.sh", "w");
	497	ptn_errs = partition_everything(mountlist);
	498	if (ptn_errs) {
	499	log_to_screen
[1203]	500	(_("Warning. Errors occurred during disk partitioning."));
[128]	501	}
[1]	502
[558]	503	fmt_errs = format_everything(mountlist, FALSE, raidlist);
[128]	504	if (!fmt_errs) {
	505	log_to_screen
[1203]	506	(_("Errors during disk partitioning were handled OK."));
	507	log_to_screen(_("Partitions were formatted OK despite those errors."));
[128]	508	ptn_errs = 0;
	509	}
	510	if (!ptn_errs && !fmt_errs) {
	511	done = TRUE;
	512	}
	513	}
	514	paranoid_fclose(g_fprep);
	515	} else {
	516	mvaddstr_and_log_it(g_currentY++, 0,
[1203]	517	_("User opted not to partition the devices"));
[128]	518	if (ask_me_yes_or_no
[1199]	519	(_("Do you want to format your hard drives?"))) {
	520	fmt_errs =
	521	format_everything(mountlist, TRUE, raidlist);
[128]	522	if (!fmt_errs) {
	523	done = TRUE;
	524	}
	525	} else {
	526	ptn_errs = fmt_errs = 0;
	527	done = TRUE;
	528	}
	529	}
	530	if (fmt_errs) {
	531	mvaddstr_and_log_it(g_currentY++,
	532	0,
[1203]	533	_("Errors occurred. Please repartition and format drives manually."));
[128]	534	done = FALSE;
	535	}
	536	if (ptn_errs & !fmt_errs) {
	537	mvaddstr_and_log_it(g_currentY++,
	538	0,
[1203]	539	_("Errors occurred during partitioning. Formatting, however, went OK."));
[128]	540	done = TRUE;
	541	}
	542	if (!done) {
[1199]	543	if (!ask_me_yes_or_no(_("Re-edit the mountlist?"))) {
[128]	544	retval++;
[1199]	545	iamhere("Leaving interactive_mode()");
	546	return (retval);
[128]	547	}
	548	}
[1]	549	}
	550	}
	551
[128]	552	/* mount */
	553	if (mount_all_devices(mountlist, TRUE)) {
	554	unmount_all_devices(mountlist);
	555	retval++;
[1199]	556	iamhere("Leaving interactive_mode()");
	557	return (retval);
[1]	558	}
[128]	559	/* restore */
	560	if ((restore_all =
[1203]	561	ask_me_yes_or_no(_("Do you want me to restore all of your data?"))))
[1]	562	{
[1108]	563	mr_msg(1, "Restoring all data");
[1663]	564	retval += restore_everything(NULL);
[1199]	565	} else if ((restore_all =
[128]	566	ask_me_yes_or_no
[1199]	567	(_("Do you want me to restore _some_ of your data?")))) {
	568	mr_asprintf(&old_restpath,bkpinfo->restore_path);
[128]	569	for (done = FALSE; !done;) {
	570	unlink("/tmp/filelist.full");
[1663]	571	filelist = process_filelist_and_biggielist();
[128]	572	/* Now you have /tmp/tmpfs/filelist.restore-these and /tmp/tmpfs/biggielist.restore-these;
	573	the former is a list of regular files; the latter, biggiefiles and imagedevs.
	574	*/
	575	if (filelist) {
[1199]	576	malloc_string(tmp1);
[128]	577	gotos_suck:
[1199]	578	strcpy(tmp1, old_restpath);
	579	// (NB: MNT_RESTORING is where your filesystem is mounted now, by default)
[128]	580	if (popup_and_get_string
[1199]	581	(_("Restore path"), _("Restore files to where?"), tmp1,
[128]	582	MAX_STR_LEN / 4)) {
[1199]	583	if (!strcmp(tmp1, "/")) {
	584	if (!ask_me_yes_or_no(_("Are you sure?"))) {
[128]	585	goto gotos_suck;
	586	}
[1199]	587	tmp1[0] = '\0'; // so we restore to [blank]/file/name :)
[128]	588	}
[1199]	589	strcpy(bkpinfo->restore_path, tmp1);
[1108]	590	mr_msg(1, "Restoring subset");
[1663]	591	retval += restore_everything(filelist);
[128]	592	free_filelist(filelist);
	593	} else {
	594	strcpy(bkpinfo->restore_path, old_restpath);
	595	free_filelist(filelist);
	596	}
	597	if (!ask_me_yes_or_no
[1199]	598	(_("Restore another subset of your backup?"))) {
[128]	599	done = TRUE;
	600	}
[1199]	601	mr_free(tmp1);
[128]	602	} else {
	603	done = TRUE;
	604	}
	605	}
[1199]	606	mr_free(old_restpath);
[128]	607	} else {
	608	mvaddstr_and_log_it(g_currentY++,
	609	0,
[1203]	610	_("User opted not to restore any data. "));
[1]	611	}
[128]	612	if (retval) {
	613	mvaddstr_and_log_it(g_currentY++,
	614	0,
[1203]	615	_("Errors occurred during the restore phase. "));
[1]	616	}
	617
[1199]	618	if (ask_me_yes_or_no(_("Initialize the boot loader?"))) {
[128]	619	run_boot_loader(TRUE);
	620	} else {
	621	mvaddstr_and_log_it(g_currentY++,
	622	0,
[1203]	623	_("User opted not to initialize the boot loader."));
[128]	624	}
	625
[1663]	626	clean_blkid();
[128]	627	protect_against_braindead_sysadmins();
	628	retval += unmount_all_devices(mountlist);
	629	/* if (restore_some \|\| restore_all \|\| */
	630	if (ask_me_yes_or_no
[1297]	631	(_("Label/Identify your ext2 and ext3 partitions if necessary?"))) {
[128]	632	mvaddstr_and_log_it(g_currentY, 0,
[1297]	633	_("Using tune2fs to identify your ext2,3 partitions"));
[128]	634	if (does_file_exist("/tmp/fstab.new")) {
[1199]	635	mr_asprintf(&fstab_fname, "/tmp/fstab.new");
[128]	636	} else {
[1199]	637	mr_asprintf(&fstab_fname, "/tmp/fstab");
[128]	638	}
[1199]	639	mr_asprintf(&tmp,
[128]	640	"label-partitions-as-necessary %s < %s >> %s 2>> %s",
	641	g_mountlist_fname, fstab_fname, MONDO_LOGFILE,
	642	MONDO_LOGFILE);
[1199]	643	mr_free(fstab_fname);
	644
[128]	645	res = system(tmp);
[1199]	646	mr_free(tmp);
[128]	647	if (res) {
	648	log_to_screen
[1199]	649	(_("label-partitions-as-necessary returned an error"));
	650	mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
[128]	651	} else {
[1199]	652	mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
[128]	653	}
	654	retval += res;
	655	}
	656
	657	iamhere("About to leave interactive_mode()");
	658	if (retval) {
	659	mvaddstr_and_log_it(g_currentY++,
	660	0,
[1203]	661	_("Warning - errors occurred during the restore phase."));
[128]	662	}
	663	iamhere("Leaving interactive_mode()");
[1199]	664	return(retval);
[1]	665	}
[128]	666
[1]	667	/**************************************************************************
	668	END_INTERACTIVE_MODE
	669	**************************************************************************/
	670
	671
	672	/**
	673	* Run an arbitrary restore mode (prompt the user), but from ISO images
	674	* instead of real media.
	675	* @param mountlist The mountlist containing information about the user's partitions.
	676	* @param raidlist The raidlist that goes with @p mountlist.
	677	* @param nuke_me_please If TRUE, we plan to run Nuke Mode.
	678	* @return 0 for success, or the number of errors encountered.
	679	*/
[128]	680	int
[1663]	681	iso_mode(struct mountlist_itself *mountlist,
[128]	682	struct raidlist_itself *raidlist, bool nuke_me_please)
[1]	683	{
[1199]	684	char c = ' ';
[128]	685	int retval = 0;
[1]	686
[128]	687	assert(mountlist != NULL);
	688	assert(raidlist != NULL);
[1663]	689	if (iso_fiddly_bits(nuke_me_please)) {
[1108]	690	mr_msg(1, "iso_mode --- returning w/ error");
[128]	691	return (1);
	692	} else {
	693	c = which_restore_mode();
	694	if (c == 'I' \|\| c == 'N' \|\| c == 'C') {
[1663]	695	interactively_obtain_media_parameters_from_user(FALSE);
[128]	696	}
	697	if (c == 'I') {
[1663]	698	retval += interactive_mode(mountlist, raidlist);
[128]	699	} else if (c == 'N') {
[1663]	700	retval += nuke_mode(mountlist, raidlist);
[128]	701	} else if (c == 'C') {
[1663]	702	retval += compare_mode(mountlist, raidlist);
[128]	703	} else {
[1199]	704	log_to_screen(_("OK, I shan't restore/compare any files."));
[128]	705	}
	706	}
	707	if (is_this_device_mounted(MNT_CDROM)) {
	708	paranoid_system("umount " MNT_CDROM);
	709	}
	710	if (system("umount /tmp/isodir 2> /dev/null")) {
	711	log_to_screen
[1203]	712	(_("WARNING - unable to unmount device where the ISO files are stored."));
[128]	713	}
	714	return (retval);
[1]	715	}
[128]	716
[1]	717	/**************************************************************************
	718	END_ISO_MODE
	719	**************************************************************************/
[1199]	720	static void call_me_after_the_nuke(int retval) {
[1]	721
[1199]	722	char *tmp = NULL;
	723	char *tmp1 = NULL;
[1]	724
[1199]	725	if (retval) {
	726	log_to_screen(_("Errors occurred during the nuke phase."));
[1202]	727	log_to_screen(_("Please visit our website at http://www.mondorescue.org for more information."));
[1199]	728	} else {
	729	#ifdef __FreeBSD__
	730	tmp1 = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
	731	#else
	732	tmp1 = call_program_and_get_last_line_of_output("cat /proc/cmdline");
	733	#endif
[1621]	734	if (strstr(tmp1,"RESTORE") == NULL) {
[1199]	735	/* -H option */
	736	mr_asprintf(&tmp,
[1204]	737	_(" Mondo has restored your system. Please remove the backup media and reboot.\n\nPlease visit our website at http://www.mondorescue.org for more information."));
[1199]	738	popup_and_OK(tmp);
	739	mr_free(tmp);
	740	}
[1]	741
[1203]	742	log_to_screen(_("Mondo has restored your system. Please remove the backup media and reboot."));
	743	log_to_screen(_("Thank you for using Mondo Rescue."));
	744	log_to_screen(_("Please visit our website at http://www.mondorescue.org for more information."));
[1199]	745	}
	746	g_I_have_just_nuked = TRUE;
	747	return;
	748	}
[1]	749
	750
	751	/**
	752	* Restore the user's data automatically (no prompts), after a twenty-second
	753	* warning period.
	754	* @param bkpinfo The backup information structure. Most fields are used.
	755	* @param mountlist The mountlist containing information about the user's partitions.
	756	* @param raidlist The raidlist that goes with @p mountlist.
	757	* @return 0 for success, or the number of errors encountered.
	758	* @warning <b><i>THIS WILL ERASE ALL EXISTING DATA!</i></b>
	759	*/
[128]	760	int
[1663]	761	nuke_mode(struct mountlist_itself *mountlist,
[128]	762	struct raidlist_itself *raidlist)
[1]	763	{
[128]	764	int retval = 0;
	765	int res = 0;
	766	bool boot_loader_installed = FALSE;
[1199]	767	char *tmp = NULL;
	768	char tmpA[MAX_STR_LEN], tmpB[MAX_STR_LEN],
[128]	769	tmpC[MAX_STR_LEN];
[1]	770
[128]	771	assert(bkpinfo != NULL);
	772	assert(mountlist != NULL);
	773	assert(raidlist != NULL);
[1]	774
[1108]	775	mr_msg(2, "nuke_mode --- starting");
[1]	776
[1663]	777	get_cfg_file_from_archive_or_bust();
[128]	778	load_mountlist(mountlist, g_mountlist_fname); // in case read_cfg_file_into_bkpinfo updated the mountlist
[1]	779	#ifdef __FreeBSD__
[1199]	780	tmp = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
[1]	781	#else
[1199]	782	tmp = call_program_and_get_last_line_of_output("cat /proc/cmdline");
[1]	783	#endif
[1199]	784	if (strstr(tmp,"noresize")) {
[1108]	785	mr_msg(2, "Not resizing mountlist.");
[128]	786	} else {
	787	resize_mountlist_proportionately_to_suit_new_drives(mountlist);
[1]	788	}
[128]	789	if (!evaluate_mountlist(mountlist, tmpA, tmpB, tmpC)) {
[1199]	790	mr_asprintf(&tmp,
[1203]	791	_("Mountlist analyzed. Result: \"%s %s %s\" Switch to Interactive Mode?"),
[128]	792	tmpA, tmpB, tmpC);
	793	if (ask_me_yes_or_no(tmp)) {
[1199]	794	mr_free(tmp);
[1663]	795	retval = interactive_mode(mountlist, raidlist);
[1199]	796	call_me_after_the_nuke(retval);
	797	return(retval);
[128]	798	} else {
[1199]	799	mr_free(tmp);
[128]	800	fatal_error("Nuke Mode aborted. ");
	801	}
[1]	802	}
[128]	803	save_mountlist_to_disk(mountlist, g_mountlist_fname);
[1199]	804	mvaddstr_and_log_it(1, 30, _("Restoring Automatically"));
[128]	805	if (bkpinfo->differential) {
[1199]	806	log_to_screen(_("Because this is a differential backup, disk"));
[1203]	807	log_to_screen(_("partitioning and formatting will not take place."));
[128]	808	res = 0;
	809	} else {
	810	if (partition_table_contains_Compaq_diagnostic_partition
	811	(mountlist)) {
	812	offer_to_abort_because_Compaq_Proliants_suck();
	813	} else {
	814	twenty_seconds_til_yikes();
	815	g_fprep = fopen("/tmp/prep.sh", "w");
[1]	816	#ifdef __FreeBSD__
[1199]	817	tmp = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
[1]	818	#else
[1199]	819	tmp = call_program_and_get_last_line_of_output("cat /proc/cmdline");
[1]	820	#endif
[1199]	821	if (strstr(tmp,"nopart")) {
[1108]	822	mr_msg(2,
[128]	823	"Not partitioning drives due to 'nopart' option.");
	824	res = 0;
	825	} else {
	826	res = partition_everything(mountlist);
	827	if (res) {
	828	log_to_screen
[1203]	829	(_("Warning. Errors occurred during partitioning."));
[128]	830	res = 0;
	831	}
	832	}
	833	retval += res;
	834	if (!res) {
[1199]	835	log_to_screen(_("Preparing to format your disk(s)"));
[128]	836	sleep(1);
[1199]	837	sync();
[1203]	838	log_to_screen(_("Please wait. This may take a few minutes."));
[558]	839	res += format_everything(mountlist, FALSE, raidlist);
[128]	840	}
	841	paranoid_fclose(g_fprep);
	842	}
[1]	843	}
[128]	844	retval += res;
	845	if (res) {
	846	mvaddstr_and_log_it(g_currentY++,
	847	0,
[1203]	848	_("Failed to partition and/or format your hard drives."));
[128]	849
[1199]	850	if (ask_me_yes_or_no(_("Try in interactive mode instead?"))) {
[1663]	851	retval = interactive_mode(mountlist, raidlist);
[1199]	852	call_me_after_the_nuke(retval);
	853	return(retval);
[128]	854	} else
	855	if (!ask_me_yes_or_no
[1199]	856	(_("Would you like to try to proceed anyway?"))) {
	857	return(retval);
[128]	858	}
[1]	859	}
[128]	860	retval = mount_all_devices(mountlist, TRUE);
	861	if (retval) {
	862	unmount_all_devices(mountlist);
	863	log_to_screen
[1203]	864	(_("Unable to mount all partitions. Sorry, I cannot proceed."));
[128]	865	return (retval);
[1]	866	}
[128]	867	iamhere("Restoring everything");
[1663]	868	retval += restore_everything(NULL);
[128]	869	if (!run_boot_loader(FALSE)) {
[1108]	870	mr_msg(1,
[128]	871	"Great! Boot loader was installed. No need for msg at end.");
	872	boot_loader_installed = TRUE;
	873	}
[1663]	874	clean_blkid();
[128]	875	protect_against_braindead_sysadmins();
	876	retval += unmount_all_devices(mountlist);
	877	mvaddstr_and_log_it(g_currentY,
	878	0,
[1297]	879	_("Using tune2fs to identify your ext2,3 partitions"));
[1]	880
[1199]	881	mr_asprintf(&tmp, "label-partitions-as-necessary %s < /tmp/fstab",
[128]	882	g_mountlist_fname);
	883	res = run_program_and_log_output(tmp, TRUE);
[1199]	884	mr_free(tmp);
	885
[128]	886	if (res) {
[1203]	887	log_to_screen(_("label-partitions-as-necessary returned an error"));
[1199]	888	mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
[128]	889	} else {
[1199]	890	mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
[128]	891	}
	892	retval += res;
[1]	893
[1199]	894	call_me_after_the_nuke(retval);
[128]	895	return (retval);
[1]	896	}
	897
	898	/**************************************************************************
	899	END_NUKE_MODE
	900	**************************************************************************/
	901
	902
	903	/**
	904	* Restore the user's data (or a subset of it) to the live filesystem.
	905	* This should not be called if we're booted from CD!
	906	* @param bkpinfo The backup information structure. Most fields are used.
	907	* @return 0 for success, or the number of errors encountered.
	908	*/
[1663]	909	int restore_to_live_filesystem()
[1]	910	{
[128]	911	int retval = 0;
[1]	912
[1199]	913	char *old_restpath = NULL;
[1]	914
[1199]	915	struct mountlist_itself *mountlist = NULL;
	916	struct raidlist_itself *raidlist = NULL;
	917	struct s_node *filelist = NULL;
[1]	918
[1108]	919	mr_msg(1, "restore_to_live_filesystem() - starting");
[128]	920	assert(bkpinfo != NULL);
[1199]	921
[1080]	922	mountlist = mr_malloc(sizeof(struct mountlist_itself));
	923	raidlist = mr_malloc(sizeof(struct raidlist_itself));
[1]	924
[128]	925	strcpy(bkpinfo->restore_path, "/");
	926	if (!g_restoring_live_from_cd) {
	927	popup_and_OK
[1770]	928	(_("Please insert tape/CD/USB key, then hit 'OK' to continue."));
[128]	929	sleep(1);
	930	}
[1663]	931	interactively_obtain_media_parameters_from_user(FALSE);
[1594]	932	if (!bkpinfo->media_device) {
[1108]	933	mr_msg(2, "Warning - failed to find media dev");
[1199]	934	} else {
	935	mr_msg(2, "bkpinfo->media_device = %s", bkpinfo->media_device);
[128]	936	}
[1]	937
	938
[1108]	939	mr_msg(2, "bkpinfo->isodir = %s", bkpinfo->isodir);
[1]	940
[1199]	941	open_evalcall_form(_("Thinking..."));
[1]	942
[1663]	943	get_cfg_file_from_archive_or_bust();
	944	read_cfg_file_into_bkpinfo(g_mondo_cfg_file);
[128]	945	load_mountlist(mountlist, g_mountlist_fname); // in case read_cfg_file_into_bkpinfo
	946
	947	close_evalcall_form();
	948	retval = load_mountlist(mountlist, g_mountlist_fname);
	949	load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
[1663]	950	filelist = process_filelist_and_biggielist();
[128]	951	if (filelist) {
	952	save_filelist(filelist, "/tmp/selected-files.txt");
[1199]	953	mr_asprintf(&old_restpath,bkpinfo->restore_path);
	954	if (popup_and_get_string(_("Restore path"),
[1201]	955	_("Restore files to where? "),
[1210]	956	bkpinfo->restore_path, MAX_STR_LEN)) {
[128]	957	iamhere("Restoring everything");
[1663]	958	retval += restore_everything(filelist);
[128]	959	}
[1199]	960	free_filelist(filelist);
[128]	961	strcpy(bkpinfo->restore_path, old_restpath);
[1199]	962	mr_free(old_restpath);
[128]	963	}
	964	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
[1108]	965	mr_msg(2,
[1239]	966	"Tape : I don't need to unmount or eject the CD-ROM.");
	967	} else {
	968	run_program_and_log_output("umount " MNT_CDROM, FALSE);
	969	if (!bkpinfo->please_dont_eject) {
	970	eject_device(bkpinfo->media_device);
	971	}
[128]	972	}
	973	run_program_and_log_output("umount " MNT_CDROM, FALSE);
[1594]	974	if ((!bkpinfo->please_dont_eject) && (bkpinfo->media_device)) {
[128]	975	eject_device(bkpinfo->media_device);
	976	}
[1080]	977	mr_free(mountlist);
	978	mr_free(raidlist);
[128]	979	return (retval);
[1]	980	}
	981
	982	/**************************************************************************
	983	END_RESTORE_TO_LIVE_FILESYSTEM
	984	**************************************************************************/
	985
	986	/* @} - end of restoreGroup */
	987
	988
	989	/**
	990	* @addtogroup LLrestoreGroup
	991	* @{
	992	*/
	993	/**
	994	* Restore biggiefile @p bigfileno from the currently mounted CD.
	995	* @param bkpinfo The backup information structure. Fields used:
	996	* - @c bkpinfo->backup_media_type
	997	* - @c bkpinfo->restore_path
	998	* @param bigfileno The biggiefile number (starting from 0) to restore.
	999	* @param filelist The node structure containing the list of files to restore.
	1000	* If the biggiefile is not in this list, it will be skipped (return value will
	1001	* still indicate success).
	1002	* @return 0 for success (or skip), nonzero for failure.
	1003	*/
	1004	int
[1663]	1005	restore_a_biggiefile_from_CD(long bigfileno,
[128]	1006	struct s_node *filelist,
	1007	char *pathname_of_last_file_restored)
[1]	1008	{
[1199]	1009	FILE *fin = NULL;
	1010	FILE *fout = NULL;
	1011	FILE *fbzip2 = NULL;
[128]	1012
[1199]	1013	char *checksum = NULL;
	1014	char *outfile_fname = NULL;
	1015	char *tmp = NULL;
	1016	char *bzip2_command = NULL;
	1017	char *suffix = NULL;
	1018	char *bigblk = NULL;
[128]	1019	int retval = 0;
	1020	int finished = FALSE;
[1199]	1021	long sliceno = 0L;
[128]	1022	long siz;
[1199]	1023	char *ntfsprog_fifo = NULL;
[128]	1024	char *file_to_openout = NULL;
	1025	struct s_filename_and_lstat_info biggiestruct;
[1199]	1026	struct utimbuf the_utime_buf, *ubuf = NULL;
[296]	1027	bool use_ntfsprog_hack = FALSE;
[128]	1028	pid_t pid;
	1029	int res = 0;
	1030	int old_loglevel;
[1199]	1031	struct s_node *node = NULL;
[1]	1032
[1625]	1033	old_loglevel = mr_conf->log_level;
[128]	1034	ubuf = &the_utime_buf;
	1035	assert(bkpinfo != NULL);
[1]	1036
[128]	1037	pathname_of_last_file_restored[0] = '\0';
[1638]	1038	bigblk = mr_malloc(mr_conf->external_tape_blocksize);
[1]	1039
[128]	1040	if (!(fin = fopen(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""), "r"))) {
[541]	1041	log_to_screen("Cannot even open bigfile's info file");
[128]	1042	return (1);
	1043	}
[1]	1044
[128]	1045	memset((void *) &biggiestruct, 0, sizeof(biggiestruct));
	1046	if (fread((void *) &biggiestruct, 1, sizeof(biggiestruct), fin) <
	1047	sizeof(biggiestruct)) {
[1108]	1048	mr_msg(2, "Warning - unable to get biggiestruct of bigfile #%d",
[128]	1049	bigfileno + 1);
	1050	}
	1051	paranoid_fclose(fin);
[1]	1052
[1199]	1053	mr_asprintf(&checksum, biggiestruct.checksum);
[1]	1054
[128]	1055	if (!checksum[0]) {
[1199]	1056	mr_msg(3, "Warning - bigfile %ld does not have a checksum",
[128]	1057	bigfileno + 1);
	1058	}
[1199]	1059	mr_free(checksum);
[1]	1060
[128]	1061	if (!strncmp(biggiestruct.filename, "/dev/", 5)) // Whether NTFS or not :)
	1062	{
[1199]	1063	mr_asprintf(&outfile_fname, biggiestruct.filename);
[128]	1064	} else {
[1199]	1065	mr_asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
[128]	1066	biggiestruct.filename);
	1067	}
[1]	1068
[128]	1069	/* skip file if we have a selective restore subset & it doesn't match */
	1070	if (filelist != NULL) {
	1071	node = find_string_at_node(filelist, biggiestruct.filename);
	1072	if (!node) {
[1108]	1073	mr_msg(0, "Skipping %s (name isn't in filelist)",
[128]	1074	biggiestruct.filename);
	1075	return (0);
	1076	} else if (!(node->selected)) {
[1108]	1077	mr_msg(1, "Skipping %s (name isn't in biggielist subset)",
[128]	1078	biggiestruct.filename);
	1079	return (0);
	1080	}
[1]	1081	}
[128]	1082	/* otherwise, continue */
[1]	1083
[1108]	1084	mr_msg(1, "DEFINITELY restoring %s", biggiestruct.filename);
[296]	1085	if (biggiestruct.use_ntfsprog) {
[128]	1086	if (strncmp(biggiestruct.filename, "/dev/", 5)) {
[1108]	1087	mr_msg(1,
[296]	1088	"I was in error when I set biggiestruct.use_ntfsprog to TRUE.");
[1108]	1089	mr_msg(1, "%s isn't even in /dev", biggiestruct.filename);
[296]	1090	biggiestruct.use_ntfsprog = FALSE;
[128]	1091	}
	1092	}
	1093
[296]	1094	if (biggiestruct.use_ntfsprog) // if it's an NTFS device
[128]	1095	{
[1625]	1096	mr_conf->log_level = 4;
[296]	1097	use_ntfsprog_hack = TRUE;
[1108]	1098	mr_msg(2,
[296]	1099	"Calling ntfsclone in background because %s is an NTFS /dev entry",
[128]	1100	outfile_fname);
[1199]	1101	mr_asprintf(&ntfsprog_fifo, "/tmp/%d.%d.000", (int) (random() % 32768),
[128]	1102	(int) (random() % 32768));
[1199]	1103	mkfifo(ntfsprog_fifo, 0x770);
	1104
[296]	1105	file_to_openout = ntfsprog_fifo;
[128]	1106	switch (pid = fork()) {
	1107	case -1:
	1108	fatal_error("Fork failure");
	1109	case 0:
[1108]	1110	mr_msg(3,
[296]	1111	"CHILD - fip - calling feed_outfrom_ntfsprog(%s, %s)",
	1112	biggiestruct.filename, ntfsprog_fifo);
[128]	1113	res =
[296]	1114	feed_outfrom_ntfsprog(biggiestruct.filename,
[1199]	1115	ntfsprog_fifo);
[128]	1116	exit(res);
	1117	break;
	1118	default:
[1108]	1119	mr_msg(3,
[296]	1120	"feed_into_ntfsprog() called in background --- pid=%ld",
[128]	1121	(long int) (pid));
	1122	}
	1123	} else {
[296]	1124	use_ntfsprog_hack = FALSE;
[128]	1125	file_to_openout = outfile_fname;
	1126	if (!does_file_exist(outfile_fname)) // yes, it looks weird with the '!' but it's correct that way
	1127	{
	1128	make_hole_for_file(outfile_fname);
	1129	}
	1130	}
[1]	1131
[1199]	1132	mr_msg(2, "Reassembling big file %ld (%s)", bigfileno + 1,
[128]	1133	outfile_fname);
[1]	1134
[128]	1135	/*
	1136	last slice is zero-length and uncompressed; when we find it, we stop.
	1137	We DON'T wait until there are no more slices; if we did that,
	1138	We might stop at end of CD, not at last slice (which is 0-len and uncompd)
	1139	*/
[1]	1140
[128]	1141	strncpy(pathname_of_last_file_restored, biggiestruct.filename,
	1142	MAX_STR_LEN - 1);
	1143	pathname_of_last_file_restored[MAX_STR_LEN - 1] = '\0';
[1]	1144
[1108]	1145	mr_msg(3, "file_to_openout = %s", file_to_openout);
[128]	1146	if (!(fout = fopen(file_to_openout, "w"))) {
[1199]	1147	log_to_screen(_("Cannot openout file_to_openout - hard disk full?"));
[128]	1148	return (1);
[1]	1149	}
[1199]	1150
	1151	mr_free(ntfsprog_fifo);
[1108]	1152	mr_msg(3, "Opened out to %s", outfile_fname); // CD/DVD --> mondorestore --> ntfsclone --> hard disk itself
[1]	1153
[128]	1154	for (sliceno = 1, finished = FALSE; !finished;) {
	1155	if (!does_file_exist
	1156	(slice_fname(bigfileno, sliceno, ARCHIVES_PATH, ""))
	1157	&&
	1158	!does_file_exist(slice_fname
	1159	(bigfileno, sliceno, ARCHIVES_PATH, "lzo"))
	1160	&&
	1161	!does_file_exist(slice_fname
[1053]	1162	(bigfileno, sliceno, ARCHIVES_PATH, "gz"))
	1163	&&
	1164	!does_file_exist(slice_fname
[128]	1165	(bigfileno, sliceno, ARCHIVES_PATH, "bz2"))) {
[1108]	1166	mr_msg(3,
[128]	1167	"Cannot find a data slice or terminator slice on CD %d",
	1168	g_current_media_number);
	1169	g_current_media_number++;
[1199]	1170	mr_msg(2, "Asking for %s #%d so that I may read slice #%ld\n",
[128]	1171	media_descriptor_string(bkpinfo->backup_media_type),
	1172	g_current_media_number, sliceno);
[1199]	1173	log_to_screen(_("Restoring from %s #%d"),
	1174	bkpinfo->backup_media_string,
[128]	1175	g_current_media_number);
[1663]	1176	insist_on_this_cd_number(g_current_media_number);
[1199]	1177	log_to_screen(_("Continuing to restore."));
[128]	1178	} else {
[1199]	1179	mr_asprintf(&tmp,
[128]	1180	slice_fname(bigfileno, sliceno, ARCHIVES_PATH, ""));
	1181	if (does_file_exist(tmp) && length_of_file(tmp) == 0) {
[1108]	1182	mr_msg(2,
[128]	1183	"End of bigfile # %ld (slice %ld is the terminator)",
	1184	bigfileno + 1, sliceno);
	1185	finished = TRUE;
[1199]	1186	mr_free(tmp);
[128]	1187	continue;
	1188	} else {
[1199]	1189	mr_free(tmp);
[128]	1190	if (does_file_exist
	1191	(slice_fname
	1192	(bigfileno, sliceno, ARCHIVES_PATH, "lzo"))) {
[1199]	1193	mr_asprintf(&bzip2_command, "lzop");
	1194	mr_asprintf(&suffix, "lzo");
[128]	1195	} else
	1196	if (does_file_exist
	1197	(slice_fname
[998]	1198	(bigfileno, sliceno, ARCHIVES_PATH, "gz"))) {
[1199]	1199	mr_asprintf(&bzip2_command, "gzip");
	1200	mr_asprintf(&suffix, "gz");
[998]	1201	} else
	1202	if (does_file_exist
	1203	(slice_fname
[128]	1204	(bigfileno, sliceno, ARCHIVES_PATH, "bz2"))) {
[1199]	1205	mr_asprintf(&bzip2_command, "bzip2");
	1206	mr_asprintf(&suffix, "bz2");
[128]	1207	} else
	1208	if (does_file_exist
	1209	(slice_fname
	1210	(bigfileno, sliceno, ARCHIVES_PATH, ""))) {
[1199]	1211	mr_asprintf(&bzip2_command, "");
	1212	mr_asprintf(&suffix, "");
[128]	1213	} else {
[1199]	1214	log_to_screen(_("OK, that's pretty fsck0red..."));
[128]	1215	return (1);
	1216	}
	1217	}
	1218	if (bzip2_command[0] != '\0') {
[1199]	1219	mr_strcat(bzip2_command,
[128]	1220	" -dc %s 2>> %s",
	1221	slice_fname(bigfileno, sliceno, ARCHIVES_PATH,
	1222	suffix), MONDO_LOGFILE);
	1223	} else {
[1199]	1224	mr_free(bzip2_command);
	1225	mr_asprintf(&bzip2_command, "cat %s 2>> %s",
[128]	1226	slice_fname(bigfileno, sliceno, ARCHIVES_PATH,
	1227	suffix), MONDO_LOGFILE);
	1228	}
[1199]	1229	mr_asprintf(&tmp, "Working on %s #%d, file #%ld, slice #%ld",
	1230	bkpinfo->backup_media_string,
[128]	1231	g_current_media_number, bigfileno + 1, sliceno);
[1108]	1232	mr_msg(2, tmp);
[128]	1233	if (!g_text_mode) {
	1234	newtDrawRootText(0, g_noof_rows - 2, tmp);
	1235	newtRefresh();
	1236	update_progress_form(tmp);
	1237	}
[1199]	1238	mr_free(tmp);
	1239
[128]	1240	if (!(fbzip2 = popen(bzip2_command, "r"))) {
[1199]	1241	mr_free(bzip2_command);
	1242	mr_free(suffix);
[128]	1243	fatal_error("Can't run popen command");
	1244	}
[1199]	1245	mr_free(bzip2_command);
	1246	mr_free(suffix);
	1247
[128]	1248	while (!feof(fbzip2)) {
[1638]	1249	siz = fread(bigblk, 1, mr_conf->external_tape_blocksize, fbzip2);
[128]	1250	if (siz > 0) {
	1251	siz = fwrite(bigblk, 1, siz, fout);
	1252	}
	1253	}
	1254	paranoid_pclose(fbzip2);
[1]	1255
[128]	1256	sliceno++;
	1257	g_current_progress++;
	1258	}
	1259	}
	1260	paranoid_fclose(fout);
[1625]	1261	mr_conf->log_level = old_loglevel;
[1]	1262
[296]	1263	if (use_ntfsprog_hack) {
[1108]	1264	mr_msg(3, "Waiting for ntfsclone to finish");
[1199]	1265	mr_asprintf(&tmp,
[433]	1266	" ps \| grep \" ntfsclone \" \| grep -v grep > /dev/null 2> /dev/null");
[128]	1267	while (system(tmp) == 0) {
	1268	sleep(1);
	1269	}
[1199]	1270	mr_free(tmp);
[296]	1271	log_it("OK, ntfsclone has really finished");
[128]	1272	}
[1]	1273
[128]	1274	if (strcmp(outfile_fname, "/dev/null")) {
	1275	chown(outfile_fname, biggiestruct.properties.st_uid,
	1276	biggiestruct.properties.st_gid);
	1277	chmod(outfile_fname, biggiestruct.properties.st_mode);
	1278	ubuf->actime = biggiestruct.properties.st_atime;
	1279	ubuf->modtime = biggiestruct.properties.st_mtime;
	1280	utime(outfile_fname, ubuf);
	1281	}
[1199]	1282	mr_free(outfile_fname);
[1080]	1283	mr_free(bigblk);
[1]	1284
[128]	1285	return (retval);
[1]	1286	}
	1287
[1199]	1288
[1]	1289	/**************************************************************************
	1290	END_ RESTORE_A_BIGGIEFILE_FROM_CD
	1291	**************************************************************************/
	1292
	1293
	1294	/**
	1295	* Restore a biggiefile from the currently opened stream.
	1296	* @param bkpinfo The backup information structure. Fields used:
	1297	* - @c bkpinfo->restore_path
[1769]	1298	* - @c bkpinfo->compression_tool
[1]	1299	* @param orig_bf_fname The original filename of the biggiefile.
	1300	* @param biggiefile_number The number of the biggiefile (starting from 0).
	1301	* @param filelist The node structure containing the list of files to be restored.
	1302	* If @p orig_bf_fname is not in the list, it will be ignored.
	1303	* @return 0 for success (or skip), nonzero for failure.
	1304	*/
[1663]	1305	int restore_a_biggiefile_from_stream(char orig_bf_fname, long biggiefile_number, char orig_checksum, //UNUSED
[128]	1306	long long biggiefile_size, //UNUSED
	1307	struct s_node *filelist,
[296]	1308	int use_ntfsprog,
[128]	1309	char *pathname_of_last_file_restored)
[1]	1310	{
[1199]	1311	FILE *pout = NULL;
	1312	FILE *fin = NULL;
[1]	1313
	1314	/ mallocs ******/
[1199]	1315	char *tmp = NULL;
	1316	char *tmp1 = NULL;
	1317	char *command = NULL;
	1318	char *outfile_fname = NULL;
	1319	char *ntfsprog_fifo = NULL;
[128]	1320	char *file_to_openout = NULL;
[1]	1321
[1199]	1322	struct s_node *node = NULL;
[1]	1323
[1199]	1324	int old_loglevel = 0;
[128]	1325	long current_slice_number = 0;
	1326	int retval = 0;
	1327	int res = 0;
	1328	int ctrl_chr = '\0';
[1199]	1329	long long slice_siz = 0L;
[128]	1330	bool dummy_restore = FALSE;
[296]	1331	bool use_ntfsprog_hack = FALSE;
[128]	1332	pid_t pid;
	1333	struct s_filename_and_lstat_info biggiestruct;
[1199]	1334	struct utimbuf the_utime_buf, *ubuf = NULL;
[128]	1335	ubuf = &the_utime_buf;
[1]	1336
[1625]	1337	old_loglevel = mr_conf->log_level;
[128]	1338	assert(bkpinfo != NULL);
	1339	assert(orig_bf_fname != NULL);
	1340	assert(orig_checksum != NULL);
[1]	1341
[128]	1342	pathname_of_last_file_restored[0] = '\0';
[296]	1343	if (use_ntfsprog == BLK_START_A_PIHBIGGIE) {
	1344	use_ntfsprog = 1;
[1108]	1345	mr_msg(1, "%s --- pih=YES", orig_bf_fname);
[296]	1346	} else if (use_ntfsprog == BLK_START_A_NORMBIGGIE) {
	1347	use_ntfsprog = 0;
[1108]	1348	mr_msg(1, "%s --- pih=NO", orig_bf_fname);
[128]	1349	} else {
[296]	1350	use_ntfsprog = 0;
[1108]	1351	mr_msg(1, "%s --- pih=NO (weird marker though)", orig_bf_fname);
[128]	1352	}
[1]	1353
[128]	1354	strncpy(pathname_of_last_file_restored, orig_bf_fname,
	1355	MAX_STR_LEN - 1);
	1356	pathname_of_last_file_restored[MAX_STR_LEN - 1] = '\0';
[1]	1357
[128]	1358	/* open out to biggiefile to be restored (or /dev/null if biggiefile is not to be restored) */
	1359
	1360	if (filelist != NULL) {
	1361	node = find_string_at_node(filelist, orig_bf_fname);
	1362	if (!node) {
	1363	dummy_restore = TRUE;
[1108]	1364	mr_msg(1,
[128]	1365	"Skipping big file %ld (%s) - not in biggielist subset",
	1366	biggiefile_number + 1, orig_bf_fname);
	1367	pathname_of_last_file_restored[0] = '\0';
	1368	} else if (!(node->selected)) {
	1369	dummy_restore = TRUE;
[1108]	1370	mr_msg(1, "Skipping %s (name isn't in biggielist subset)",
[128]	1371	orig_bf_fname);
	1372	pathname_of_last_file_restored[0] = '\0';
	1373	}
[1]	1374	}
	1375
[296]	1376	if (use_ntfsprog) {
[128]	1377	if (strncmp(orig_bf_fname, "/dev/", 5)) {
[1199]	1378	mr_msg(1, "I was in error when I set use_ntfsprog to TRUE.");
[1108]	1379	mr_msg(1, "%s isn't even in /dev", orig_bf_fname);
[296]	1380	use_ntfsprog = FALSE;
[128]	1381	}
	1382	}
[1]	1383
[296]	1384	if (use_ntfsprog) {
[1625]	1385	mr_conf->log_level = 4;
[1199]	1386	mr_asprintf(&outfile_fname, orig_bf_fname);
[296]	1387	use_ntfsprog_hack = TRUE;
[1108]	1388	mr_msg(2,
[296]	1389	"Calling ntfsclone in background because %s is a /dev entry",
[128]	1390	outfile_fname);
[1199]	1391	mr_asprintf(&ntfsprog_fifo, "%s/%d.%d.000",
[812]	1392	bkpinfo->tmpdir,
	1393	(int) (random() % 32768),
[128]	1394	(int) (random() % 32768));
[1199]	1395	mkfifo(ntfsprog_fifo, 0x770);
	1396
[296]	1397	file_to_openout = ntfsprog_fifo;
[128]	1398	switch (pid = fork()) {
	1399	case -1:
	1400	fatal_error("Fork failure");
	1401	case 0:
[1108]	1402	mr_msg(3,
[296]	1403	"CHILD - fip - calling feed_outfrom_ntfsprog(%s, %s)",
	1404	outfile_fname, ntfsprog_fifo);
[1199]	1405	res = feed_outfrom_ntfsprog(outfile_fname, ntfsprog_fifo);
[128]	1406	exit(res);
	1407	break;
	1408	default:
[1108]	1409	mr_msg(3,
[296]	1410	"feed_into_ntfsprog() called in background --- pid=%ld",
[128]	1411	(long int) (pid));
	1412	}
	1413	} else {
	1414	if (!strncmp(orig_bf_fname, "/dev/", 5)) // non-NTFS partition
	1415	{
[1199]	1416	mr_asprintf(&outfile_fname, orig_bf_fname);
[128]	1417	} else // biggiefile
	1418	{
[1199]	1419	mr_asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
[128]	1420	orig_bf_fname);
	1421	}
[296]	1422	use_ntfsprog_hack = FALSE;
[128]	1423	file_to_openout = outfile_fname;
	1424	if (!does_file_exist(outfile_fname)) // yes, it looks weird with the '!' but it's correct that way
	1425	{
	1426	make_hole_for_file(outfile_fname);
	1427	}
[1199]	1428	mr_msg(2, "Reassembling big file %ld (%s)",
[128]	1429	biggiefile_number + 1, orig_bf_fname);
[1]	1430	}
[128]	1431
	1432	if (dummy_restore) {
[1199]	1433	mr_free(outfile_fname);
	1434	mr_asprintf(&outfile_fname, "/dev/null");
[1]	1435	}
[128]	1436
[1769]	1437	if (!bkpinfo->compression_tool) {
[1199]	1438	mr_asprintf(&command, "cat > \"%s\"", file_to_openout);
[128]	1439	} else {
[1769]	1440	mr_asprintf(&command, "%s -dc > \"%s\" 2>> %s", bkpinfo->compression_tool,
[128]	1441	file_to_openout, MONDO_LOGFILE);
[1]	1442	}
[1199]	1443	mr_msg(3, "Pipe command = '%s'", command);
	1444	mr_free(outfile_fname);
	1445	mr_free(ntfsprog_fifo);
[1]	1446
[128]	1447	/* restore biggiefile, one slice at a time */
	1448	if (!(pout = popen(command, "w"))) {
	1449	fatal_error("Cannot pipe out");
	1450	}
[1199]	1451	mr_free(command);
	1452
	1453	malloc_string(tmp1);
	1454	for (res = read_header_block_from_stream(&slice_siz, tmp1, &ctrl_chr);
[128]	1455	ctrl_chr != BLK_STOP_A_BIGGIE;
[1199]	1456	res = read_header_block_from_stream(&slice_siz, tmp1, &ctrl_chr)) {
[128]	1457	if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
	1458	wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
	1459	}
[1199]	1460	mr_asprintf(&tmp, "Working on file #%ld, slice #%ld ",
[128]	1461	biggiefile_number + 1, current_slice_number);
[1108]	1462	mr_msg(2, tmp);
[128]	1463	if (!g_text_mode) {
	1464	newtDrawRootText(0, g_noof_rows - 2, tmp);
	1465	newtRefresh();
	1466	}
[1168]	1467	mr_strip_spaces(tmp);
[128]	1468	update_progress_form(tmp);
[1199]	1469	mr_free(tmp);
[128]	1470	if (current_slice_number == 0) {
	1471	res =
[1663]	1472	read_file_from_stream_to_file("/tmp/biggie-blah.txt",
[128]	1473	slice_siz);
	1474	if (!(fin = fopen("/tmp/biggie-blah.txt", "r"))) {
	1475	log_OS_error("blah blah");
	1476	} else {
	1477	if (fread
	1478	((void *) &biggiestruct, 1, sizeof(biggiestruct),
	1479	fin) < sizeof(biggiestruct)) {
[1108]	1480	mr_msg(2,
[128]	1481	"Warning - unable to get biggiestruct of bigfile #%d",
	1482	biggiefile_number + 1);
	1483	}
	1484	paranoid_fclose(fin);
	1485	}
	1486	} else {
	1487	res =
[1663]	1488	read_file_from_stream_to_stream(pout, slice_siz);
[128]	1489	}
	1490	retval += res;
[1199]	1491	res = read_header_block_from_stream(&slice_siz, tmp1, &ctrl_chr);
[128]	1492	if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
	1493	wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
	1494	}
	1495	current_slice_number++;
	1496	g_current_progress++;
	1497	}
[1199]	1498	mr_free(tmp1);
[128]	1499	paranoid_pclose(pout);
[1]	1500
[1108]	1501	mr_msg(1, "pathname_of_last_file_restored is now %s",
[128]	1502	pathname_of_last_file_restored);
[1]	1503
[296]	1504	if (use_ntfsprog_hack) {
[1108]	1505	mr_msg(3, "Waiting for ntfsclone to finish");
[1199]	1506	mr_asprintf(&tmp,
[433]	1507	" ps \| grep \" ntfsclone \" \| grep -v grep > /dev/null 2> /dev/null");
[128]	1508	while (system(tmp) == 0) {
	1509	sleep(1);
[1199]	1510	}
	1511	mr_free(tmp);
[1108]	1512	mr_msg(3, "OK, ntfsclone has really finished");
[128]	1513	}
	1514
[1108]	1515	mr_msg(3, "biggiestruct.filename = %s", biggiestruct.filename);
	1516	mr_msg(3, "biggiestruct.checksum = %s", biggiestruct.checksum);
[128]	1517	if (strcmp(outfile_fname, "/dev/null")) {
	1518	chmod(outfile_fname, biggiestruct.properties.st_mode);
	1519	chown(outfile_fname, biggiestruct.properties.st_uid,
	1520	biggiestruct.properties.st_gid);
	1521	ubuf->actime = biggiestruct.properties.st_atime;
	1522	ubuf->modtime = biggiestruct.properties.st_mtime;
	1523	utime(outfile_fname, ubuf);
	1524	}
	1525
[1625]	1526	mr_conf->log_level = old_loglevel;
[128]	1527	return (retval);
[1]	1528	}
	1529
	1530	/**************************************************************************
	1531	END_RESTORE_A_BIGGIEFILE_FROM_STREAM
	1532	**************************************************************************/
	1533
	1534
	1535	/**
	1536	* Restore @p tarball_fname from CD.
	1537	* @param tarball_fname The filename of the tarball to restore (in /mnt/cdrom).
	1538	* This will be used unmodified.
	1539	* @param current_tarball_number The number (starting from 0) of the fileset
	1540	* we're restoring now.
	1541	* @param filelist The node structure containing the list of files to be
	1542	* restored. If no file in the afioball is in this list, afio will still be
	1543	* called, but nothing will be written.
	1544	* @return 0 for success, nonzero for failure.
	1545	*/
	1546	int
	1547	restore_a_tarball_from_CD(char *tarball_fname,
[128]	1548	long current_tarball_number,
[1170]	1549	struct s_node filelist, struct s_bkpinfo bkpinfo)
[1]	1550	{
[128]	1551	int retval = 0;
[1199]	1552	int res = 0;
	1553	char *p = NULL;
[1]	1554
	1555	/ malloc /
[1199]	1556	char *command = NULL;
	1557	char *tmp = NULL;
	1558	char *filelist_name = NULL;
	1559	char *filelist_subset_fname = NULL;
	1560	char *executable = NULL;
	1561	char *temp_log = NULL;
[128]	1562	long matches = 0;
[1199]	1563	bool use_star = FALSE;
	1564	char *xattr_fname = NULL;
	1565	char *acl_fname = NULL;
[1638]	1566	#ifdef __FreeBSD__
	1567	long BUFSIZE=512L;
	1568	#else
	1569	long BUFSIZE=(1024L*1024L)/mr_conf->external_tape_blocksize;
	1570	#endif
[1]	1571
[1638]	1572
[128]	1573	assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
	1574
[1108]	1575	mr_msg(5, "Entering");
[128]	1576	use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
[1199]	1577	mr_asprintf(&command, "mkdir -p %s/tmp", MNT_RESTORING);
[128]	1578	run_program_and_log_output(command, 9);
[1199]	1579	mr_free(command);
[1]	1580
[1199]	1581	mr_asprintf(&filelist_name, MNT_CDROM "/archives/filelist.%ld",
[128]	1582	current_tarball_number);
	1583	if (length_of_file(filelist_name) <= 2) {
[1108]	1584	mr_msg(2, "There are _zero_ files in filelist '%s'",
[128]	1585	filelist_name);
[1108]	1586	mr_msg(2,
[676]	1587	"This is a bit silly (ask dev-team to fix mondo_makefilelist, please)");
[1108]	1588	mr_msg(2,
[128]	1589	"but it's non-critical. It's cosmetic. Don't worry about it.");
	1590	retval = 0;
[1199]	1591	mr_msg(5, "Leaving");
	1592	mr_free(filelist_name);
	1593	return (retval);
[1]	1594	}
[128]	1595	if (count_lines_in_file(filelist_name) <= 0
	1596	\|\| length_of_file(tarball_fname) <= 0) {
[1108]	1597	mr_msg(3, "length_of_file(%s) = %llu", tarball_fname,
[128]	1598	length_of_file(tarball_fname));
[1199]	1599	log_to_screen(_("Unable to restore fileset #%ld (CD I/O error)"),
[128]	1600	current_tarball_number);
	1601	retval = 1;
[1199]	1602	mr_msg(5, "Leaving");
	1603	mr_free(filelist_name);
	1604	return (retval);
[1]	1605	}
	1606
[128]	1607	if (filelist) {
[1199]	1608	mr_asprintf(&filelist_subset_fname, "/tmp/filelist-subset-%ld.tmp",
[128]	1609	current_tarball_number);
	1610	if ((matches =
	1611	save_filelist_entries_in_common(filelist_name, filelist,
	1612	filelist_subset_fname,
	1613	use_star))
	1614	<= 0) {
[1199]	1615	mr_msg(1, "Skipping fileset %ld", current_tarball_number);
[128]	1616	} else {
[1108]	1617	mr_msg(3, "Saved fileset %ld's subset to %s",
[128]	1618	current_tarball_number, filelist_subset_fname);
	1619	}
[1199]	1620	log_to_screen("Tarball #%ld --- %ld matches",
[128]	1621	current_tarball_number, matches);
	1622	}
[1199]	1623	mr_free(filelist_name);
[128]	1624
	1625	if (filelist == NULL \|\| matches > 0) {
[948]	1626	if (g_getfattr) {
[1199]	1627	mr_asprintf(&xattr_fname, XATTR_LIST_FNAME_RAW_SZ,
[128]	1628	MNT_CDROM "/archives", current_tarball_number);
[948]	1629	}
	1630	if (g_getfacl) {
[1199]	1631	mr_asprintf(&acl_fname, ACL_LIST_FNAME_RAW_SZ, MNT_CDROM "/archives",
[128]	1632	current_tarball_number);
[948]	1633	}
[128]	1634	if (strstr(tarball_fname, ".bz2")) {
[1199]	1635	mr_asprintf(&executable, "-P bzip2 -Z");
[998]	1636	} else if (strstr(tarball_fname, ".gz")) {
[1199]	1637	mr_asprintf(&executable, "-P gzip -Z");
[128]	1638	} else if (strstr(tarball_fname, ".lzo")) {
[1199]	1639	mr_asprintf(&executable, "-P lzop -Z");
[128]	1640	}
[1199]	1641
	1642	if (executable == NULL) {
	1643	mr_asprintf(&tmp, "which %s > /dev/null 2> /dev/null", executable);
[128]	1644	if (run_program_and_log_output(tmp, FALSE)) {
	1645	log_to_screen
[1203]	1646	(_("(compare_a_tarball) Compression program not found - oh no!"));
[1199]	1647	mr_free(tmp);
	1648	mr_free(executable);
	1649	mr_free(acl_fname);
	1650	mr_free(xattr_fname);
	1651	mr_free(filelist_subset_fname);
[128]	1652	paranoid_MR_finish(1);
	1653	}
[1199]	1654	mr_free(tmp);
[128]	1655	}
	1656	if (use_star) {
[1211]	1657	mr_asprintf(&command,
[128]	1658	"star -x -force-remove -U " STAR_ACL_SZ
	1659	" errctl= file=%s", tarball_fname);
	1660	if (strstr(tarball_fname, ".bz2")) {
[1199]	1661	mr_strcat(command, " -bz");
[128]	1662	}
	1663	} else {
[1199]	1664	if (filelist_subset_fname != NULL) {
	1665	mr_asprintf(&command,
[543]	1666	"afio -i -M 8m -b %ld -c %ld %s -w '%s' %s",
[1638]	1667	mr_conf->external_tape_blocksize,
[128]	1668	BUFSIZE, executable, filelist_subset_fname,
	1669	tarball_fname);
	1670	} else {
[1199]	1671	mr_asprintf(&command,
[128]	1672	"afio -i -b %ld -c %ld -M 8m %s %s",
[1638]	1673	mr_conf->external_tape_blocksize,
[128]	1674	BUFSIZE, executable, tarball_fname);
	1675	}
	1676	}
[1199]	1677	mr_free(executable);
	1678
	1679	mr_asprintf(&temp_log, "/tmp/%d.%d", (int) (random() % 32768),
	1680	(int) (random() % 32768));
	1681
	1682	mr_strcat(command, " 2>> %s >> %s", temp_log, temp_log);
[1108]	1683	mr_msg(1, "command = '%s'", command);
[128]	1684	unlink(temp_log);
	1685	res = system(command);
	1686	if (res) {
	1687	p = strstr(command, "-acl ");
	1688	if (p) {
	1689	p[0] = p[1] = p[2] = p[3] = ' ';
[1108]	1690	mr_msg(1, "new command = '%s'", command);
[128]	1691	res = system(command);
	1692	}
	1693	}
[1199]	1694	mr_free(command);
	1695
[128]	1696	if (res && length_of_file(temp_log) < 5) {
	1697	res = 0;
	1698	}
	1699
[948]	1700	if (g_getfattr) {
[1108]	1701	mr_msg(1, "Setting fattr list %s", xattr_fname);
[948]	1702	if (length_of_file(xattr_fname) > 0) {
	1703	res = set_fattr_list(filelist_subset_fname, xattr_fname);
	1704	if (res) {
	1705	log_to_screen
	1706	("Errors occurred while setting extended attributes");
	1707	} else {
[1108]	1708	mr_msg(1, "I set xattr OK");
[948]	1709	}
	1710	retval += res;
[128]	1711	}
	1712	}
[948]	1713	if (g_getfacl) {
[1108]	1714	mr_msg(1, "Setting acl list %s", acl_fname);
[948]	1715	if (length_of_file(acl_fname) > 0) {
	1716	res = set_acl_list(filelist_subset_fname, acl_fname);
	1717	if (res) {
	1718	log_to_screen
	1719	("Errors occurred while setting access control lists");
	1720	} else {
[1108]	1721	mr_msg(1, "I set ACL OK");
[948]	1722	}
	1723	retval += res;
[128]	1724	}
	1725	}
	1726	if (retval) {
[1199]	1727	mr_asprintf(&command, "cat %s >> %s", temp_log, MONDO_LOGFILE);
[128]	1728	system(command);
[1199]	1729	mr_free(command);
[1108]	1730	mr_msg(2, "Errors occurred while processing fileset #%d",
[128]	1731	current_tarball_number);
	1732	} else {
[1108]	1733	mr_msg(2, "Fileset #%d processed OK", current_tarball_number);
[128]	1734	}
[1199]	1735	unlink(xattr_fname);
	1736	mr_free(xattr_fname);
	1737	unlink(acl_fname);
	1738	mr_free(acl_fname);
	1739	unlink(temp_log);
	1740	mr_free(temp_log);
[1]	1741	}
[128]	1742	if (does_file_exist("/PAUSE")) {
	1743	popup_and_OK
[1203]	1744	(_("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
[1]	1745	}
[128]	1746	unlink(filelist_subset_fname);
[1080]	1747	mr_free(filelist_subset_fname);
[1108]	1748	mr_msg(5, "Leaving");
[128]	1749	return (retval);
[1]	1750	}
	1751
	1752	/**************************************************************************
	1753	END_RESTORE_A_TARBALL_FROM_CD
	1754	**************************************************************************/
	1755
	1756
	1757	/**
	1758	* Restore a tarball from the currently opened stream.
	1759	* @param bkpinfo The backup information structure. Fields used:
	1760	* - @c bkpinfo->backup_media_type
	1761	* - @c bkpinfo->media_device
[1769]	1762	* - @c bkpinfo->compression_tool
[1]	1763	* @param tarball_fname The filename of the afioball to restore.
	1764	* @param current_tarball_number The number (starting from 0) of the fileset
	1765	* we're restoring now.
	1766	* @param filelist The node structure containing the list of files to be
	1767	* restored. If no file in the afioball is in this list, afio will still be
	1768	* called, but nothing will be written.
	1769	* @param size The size (in @b bytes) of the afioball.
	1770	* @return 0 for success, nonzero for failure.
	1771	*/
	1772	int
[1663]	1773	restore_a_tarball_from_stream(char *tarball_fname,
[128]	1774	long current_tarball_number,
	1775	struct s_node *filelist,
	1776	long long size, char *xattr_fname,
	1777	char *acl_fname)
[1]	1778	{
[128]	1779	int retval = 0;
	1780	int res = 0;
[1]	1781
	1782	/ malloc add */
[1199]	1783	char *command = NULL;
	1784	char *afio_fname = NULL;
	1785	char *filelist_fname = NULL;
	1786	char *filelist_subset_fname = NULL;
	1787	char *executable = NULL;
[128]	1788	long matches = 0;
	1789	bool restore_this_fileset = FALSE;
[1199]	1790	bool use_star = FALSE;
[1]	1791
[128]	1792	assert(bkpinfo != NULL);
	1793	assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
	1794	/* to do it with a file... */
	1795	use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
[1199]	1796	mr_msg(2, "Restoring from fileset #%ld (%ld KB) on %s #%d",
[128]	1797	current_tarball_number, (long) size >> 10,
[1199]	1798	bkpinfo->backup_media_string,
[128]	1799	g_current_media_number);
	1800	run_program_and_log_output("mkdir -p " MNT_RESTORING "/tmp", FALSE);
	1801
[1]	1802	/****************************************************************************
	1803	* Use RAMDISK's /tmp; saves time; oh wait, it's too small *
	1804	* Well, pipe from tape to afio, then; oh wait, can't do that either: bug *
	1805	* in afio or someting; oh darn.. OK, use tmpfs :-) *
	1806	****************************************************************************/
[1199]	1807	mr_asprintf(&afio_fname, "/tmp/tmpfs/archive.tmp.%ld",
[128]	1808	current_tarball_number);
[1199]	1809	mr_asprintf(&filelist_fname, "%s/filelist.%ld", bkpinfo->tmpdir,
[128]	1810	current_tarball_number);
[1199]	1811	mr_asprintf(&filelist_subset_fname, "%s/filelist-subset-%ld.tmp",
[128]	1812	bkpinfo->tmpdir, current_tarball_number);
[1663]	1813	res = read_file_from_stream_to_file(afio_fname, size);
[128]	1814	if (strstr(tarball_fname, ".star")) {
	1815	bkpinfo->use_star = TRUE;
[1]	1816	}
[128]	1817	if (res) {
[1108]	1818	mr_msg(1, "Warning - error reading afioball from tape");
[1]	1819	}
[1199]	1820	if (bkpinfo->compression_level != 0) {
[128]	1821	if (bkpinfo->use_star) {
[1199]	1822	mr_asprintf(&executable, " -bz");
[128]	1823	} else {
[1769]	1824	mr_asprintf(&executable, "-P %s -Z", bkpinfo->compression_tool);
[128]	1825	}
[1]	1826	}
	1827
[128]	1828	if (!filelist) // if unconditional restore then restore entire fileset
	1829	{
	1830	restore_this_fileset = TRUE;
	1831	} else // If restoring selectively then get TOC from tarball
	1832	{
	1833	if (strstr(tarball_fname, ".star.")) {
	1834	use_star = TRUE;
[1199]	1835	mr_asprintf(&command, "star -t file=%s %s", afio_fname, executable);
[128]	1836	} else {
	1837	use_star = FALSE;
[1638]	1838	mr_asprintf(&command, "afio -t -M 8m -b %ld %s %s", mr_conf->external_tape_blocksize,
[128]	1839	executable, afio_fname);
	1840	}
[1199]	1841	mr_strcat(command, " > %s 2>> %s", filelist_fname, MONDO_LOGFILE);
[1108]	1842	mr_msg(1, "command = %s", command);
[128]	1843	if (system(command)) {
[1108]	1844	mr_msg(4, "Warning - error occurred while retrieving TOC");
[128]	1845	}
[1199]	1846	mr_free(command);
	1847
[128]	1848	if ((matches =
	1849	save_filelist_entries_in_common(filelist_fname, filelist,
	1850	filelist_subset_fname,
	1851	use_star))
	1852	<= 0 \|\| length_of_file(filelist_subset_fname) < 2) {
	1853	if (length_of_file(filelist_subset_fname) < 2) {
[1108]	1854	mr_msg(1, "No matches found in fileset %ld",
[128]	1855	current_tarball_number);
	1856	}
[1199]	1857	mr_msg(2, "Skipping fileset %ld", current_tarball_number);
[128]	1858	restore_this_fileset = FALSE;
	1859	} else {
[1108]	1860	mr_msg(5, "%ld matches. Saved fileset %ld's subset to %s",
[128]	1861	matches, current_tarball_number,
	1862	filelist_subset_fname);
	1863	restore_this_fileset = TRUE;
	1864	}
	1865	}
[1199]	1866	unlink(filelist_fname);
	1867	mr_free(filelist_fname);
[128]	1868
[1]	1869	// Concoct the call to star/afio to restore files
[1199]	1870	if (strstr(tarball_fname, ".star.")) {
	1871	// star
[128]	1872	if (filelist) {
[1199]	1873	mr_asprintf(&command, "star -x file=%s %s list=%s 2>> %s", afio_fname, executable, filelist_subset_fname, MONDO_LOGFILE);
	1874	} else {
	1875	mr_asprintf(&command, "star -x file=%s %s 2>> %s", afio_fname, executable, MONDO_LOGFILE);
[128]	1876	}
[1199]	1877	} else {
	1878	// afio
[128]	1879	if (filelist) {
[1638]	1880	mr_asprintf(&command, "afio -i -M 8m -b %ld %s -w %s %s 2>> %s", mr_conf->external_tape_blocksize, executable, filelist_subset_fname, afio_fname, MONDO_LOGFILE);
[1199]	1881	} else {
[1638]	1882	mr_asprintf(&command, "afio -i -M 8m -b %ld %s %s 2>> %s", mr_conf->external_tape_blocksize, executable, afio_fname, MONDO_LOGFILE);
[128]	1883	}
	1884	}
[1199]	1885	mr_free(executable);
[1]	1886
[1199]	1887	// Call if IF there are files to restore (selectively/unconditionally)
[128]	1888	if (restore_this_fileset) {
[1108]	1889	mr_msg(1, "Calling command='%s'", command);
[128]	1890	paranoid_system(command);
[1]	1891
[948]	1892	if (g_getfattr) {
	1893	iamhere("Restoring xattr stuff");
	1894	res = set_fattr_list(filelist_subset_fname, xattr_fname);
	1895	if (res) {
[1108]	1896	mr_msg(1, "Errors occurred while setting xattr");
[948]	1897	} else {
[1108]	1898	mr_msg(1, "I set xattr OK");
[948]	1899	}
	1900	retval += res;
[128]	1901	}
[1]	1902
[948]	1903	if (g_getfacl) {
	1904	iamhere("Restoring acl stuff");
	1905	res = set_acl_list(filelist_subset_fname, acl_fname);
	1906	if (res) {
[1108]	1907	mr_msg(1, "Errors occurred while setting ACL");
[948]	1908	} else {
[1108]	1909	mr_msg(1, "I set ACL OK");
[948]	1910	}
	1911	retval += res;
[128]	1912	}
	1913
	1914	} else {
[1108]	1915	mr_msg(1, "NOT CALLING '%s'", command);
[128]	1916	}
[1199]	1917	mr_free(command);
[128]	1918
	1919	if (does_file_exist("/PAUSE") && current_tarball_number >= 50) {
[1199]	1920	log_to_screen(_("Paused after set %ld"), current_tarball_number);
	1921	popup_and_OK(_("Pausing. Press ENTER to continue."));
[128]	1922	}
	1923
	1924	unlink(filelist_subset_fname);
	1925	unlink(afio_fname);
	1926
[1080]	1927	mr_free(filelist_subset_fname);
	1928	mr_free(afio_fname);
[128]	1929	return (retval);
[1]	1930	}
[128]	1931
[1]	1932	/**************************************************************************
	1933	END_RESTORE_A_TARBALL_FROM_STREAM
	1934	**************************************************************************/
	1935
	1936
	1937	/**
	1938	* Restore all biggiefiles from all media in this CD backup.
	1939	* The CD with the last afioball should be currently mounted.
	1940	* @param bkpinfo The backup information structure. @c backup_media_type is the
	1941	* only field used in this function.
	1942	* @param filelist The node structure containing the list of files to be
	1943	* restored. If a prospective biggiefile is not in this list, it will be ignored.
	1944	* @return 0 for success, nonzero for failure.
	1945	*/
	1946	int
[1663]	1947	restore_all_biggiefiles_from_CD(struct s_node *filelist)
[1]	1948	{
[128]	1949	int retval = 0;
[1199]	1950	int res = 0;
	1951	long noof_biggiefiles = 0L, bigfileno = 0L, total_slices = 0L;
	1952	char *tmp = NULL;
	1953	char *tmp1 = NULL;
	1954	bool just_changed_cds = FALSE, finished = FALSE;
	1955	char *xattr_fname = NULL;
	1956	char *acl_fname = NULL;
	1957	char *biggies_whose_EXATs_we_should_set = NULL; // EXtended ATtributes
	1958	char *pathname_of_last_biggie_restored = NULL;
[128]	1959	FILE *fbw = NULL;
[1]	1960
[1199]	1961	malloc_string(tmp1);
[128]	1962	malloc_string(pathname_of_last_biggie_restored);
	1963	assert(bkpinfo != NULL);
	1964
[1199]	1965	mr_asprintf(&biggies_whose_EXATs_we_should_set,
[128]	1966	"%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
	1967	if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w"))) {
[1108]	1968	mr_msg(1, "Warning - cannot openout %s",
[128]	1969	biggies_whose_EXATs_we_should_set);
[1]	1970	}
	1971
[1199]	1972	read_cfg_var(g_mondo_cfg_file, "total-slices", tmp1);
	1973	total_slices = atol(tmp1);
	1974	mr_free(tmp1);
	1975
	1976	mr_asprintf(&tmp, _("Reassembling large files "));
[128]	1977	mvaddstr_and_log_it(g_currentY, 0, tmp);
[1199]	1978	mr_free(tmp);
	1979
[128]	1980	if (length_of_file(BIGGIELIST) < 6) {
[1108]	1981	mr_msg(1, "OK, no biggielist; not restoring biggiefiles");
[128]	1982	return (0);
[1]	1983	}
[128]	1984	noof_biggiefiles = count_lines_in_file(BIGGIELIST);
	1985	if (noof_biggiefiles <= 0) {
[1108]	1986	mr_msg(2,
[128]	1987	"OK, no biggiefiles in biggielist; not restoring biggiefiles");
	1988	return (0);
	1989	}
[1199]	1990	mr_msg(2, "OK, there are %ld biggiefiles in the archives", noof_biggiefiles);
[1]	1991
[1199]	1992	open_progress_form(_("Reassembling large files"),
	1993	_("I am now reassembling all the large files."),
	1994	_("Please wait. This may take some time."),
[128]	1995	"", total_slices);
[1903]	1996	for (bigfileno = 0 ; bigfileno < noof_biggiefiles ;) {
[1108]	1997	mr_msg(2, "Thinking about restoring bigfile %ld", bigfileno + 1);
[128]	1998	if (!does_file_exist(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""))) {
[1108]	1999	mr_msg(3,
[128]	2000	"...but its first slice isn't on this CD. Perhaps this was a selective restore?");
[1108]	2001	mr_msg(3, "Cannot find bigfile #%ld 's first slice on %s #%d",
[128]	2002	bigfileno + 1,
[1199]	2003	bkpinfo->backup_media_string,
[128]	2004	g_current_media_number);
[1108]	2005	mr_msg(3, "Slicename would have been %s",
[1903]	2006	slice_fname(bigfileno, 0, ARCHIVES_PATH, ""));
[128]	2007	// I'm not positive 'just_changed_cds' is even necessary...
	2008	if (just_changed_cds) {
	2009	just_changed_cds = FALSE;
[1108]	2010	mr_msg(3,
[128]	2011	"I'll continue to scan this CD for bigfiles to be restored.");
	2012	} else if (does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")) {
[1663]	2013	insist_on_this_cd_number(++g_current_media_number);
[1199]	2014	log_to_screen(_("Restoring from %s #%d"),
[1663]	2015	media_descriptor_string(bkpinfo->backup_media_type),
[128]	2016	g_current_media_number);
	2017	just_changed_cds = TRUE;
	2018	} else {
[1903]	2019	/* That big file doesn't exist, but the followings may */
	2020	/* So we need to continue looping */
[1108]	2021	mr_msg(2, "There was no bigfile #%ld. That's OK.",
[1903]	2022	bigfileno + 1);
[1108]	2023	mr_msg(2, "I'm going to stop restoring bigfiles now.");
[1903]	2024	retval++;
	2025	bigfileno++;
[128]	2026	}
	2027	} else {
	2028	just_changed_cds = FALSE;
[1199]	2029	mr_asprintf(&tmp, _("Restoring big file %ld"), bigfileno + 1);
[128]	2030	update_progress_form(tmp);
[1199]	2031	mr_free(tmp);
	2032
[128]	2033	res =
[1663]	2034	restore_a_biggiefile_from_CD(bigfileno, filelist, pathname_of_last_biggie_restored);
[128]	2035	iamhere(pathname_of_last_biggie_restored);
	2036	if (fbw && pathname_of_last_biggie_restored[0]) {
	2037	fprintf(fbw, "%s\n", pathname_of_last_biggie_restored);
	2038	}
	2039	retval += res;
	2040	bigfileno++;
	2041	}
[1]	2042	}
[128]	2043
	2044	if (fbw) {
	2045	fclose(fbw);
[948]	2046	if (g_getfattr) {
[1199]	2047	mr_asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
[948]	2048	if (length_of_file(xattr_fname) > 0) {
	2049	set_fattr_list(biggies_whose_EXATs_we_should_set, xattr_fname);
	2050	}
[128]	2051	}
[948]	2052	if (g_getfacl) {
[1199]	2053	mr_asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
[948]	2054	if (length_of_file(acl_fname) > 0) {
	2055	set_acl_list(biggies_whose_EXATs_we_should_set, acl_fname);
	2056	}
[128]	2057	}
[1199]	2058	mr_free(acl_fname);
	2059	mr_free(xattr_fname);
[1]	2060	}
[1199]	2061	mr_free(biggies_whose_EXATs_we_should_set);
	2062
[128]	2063	if (does_file_exist("/PAUSE")) {
	2064	popup_and_OK
[1203]	2065	(_("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
[128]	2066	}
	2067	close_progress_form();
	2068	if (retval) {
[1199]	2069	mvaddstr_and_log_it(g_currentY++, 74, _("Errors."));
[128]	2070	} else {
[1199]	2071	mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
[128]	2072	}
[1080]	2073	mr_free(pathname_of_last_biggie_restored);
[128]	2074	return (retval);
[1]	2075	}
[128]	2076
[1]	2077	/**************************************************************************
	2078	END_RESTORE_ALL_BIGGIFILES_FROM_CD
	2079	**************************************************************************/
	2080
	2081
	2082	/**
	2083	* Restore all afioballs from all CDs in the backup.
	2084	* The first CD should be inserted (if not, it will be asked for).
	2085	* @param bkpinfo The backup information structure. @c backup_media_type is the
	2086	* only field used in @e this function.
	2087	* @param filelist The node structure containing the list of files to be
	2088	* restored. If no file in some particular afioball is in this list, afio will
	2089	* still be called for that fileset, but nothing will be written.
	2090	* @return 0 for success, or the number of filesets that failed.
	2091	*/
	2092	int
[1663]	2093	restore_all_tarballs_from_CD(struct s_node *filelist)
[1]	2094	{
[128]	2095	int retval = 0;
[1199]	2096	int res = 0;
	2097	int attempts = 0;
[128]	2098	long current_tarball_number = 0;
[1199]	2099	long max_val = 0L;
[1]	2100	/malloc */
[1199]	2101	char *tmp = NULL;
	2102	char *tmp1 = NULL;
	2103	char *tarball_fname = NULL;
	2104	char *progress_str = NULL;
	2105	char *comment = NULL;
[1]	2106
[1199]	2107	malloc_string(tmp1);
[128]	2108	malloc_string(tarball_fname);
	2109	malloc_string(progress_str);
	2110	malloc_string(comment);
[1]	2111
[128]	2112	assert(bkpinfo != NULL);
	2113
[1199]	2114	mvaddstr_and_log_it(g_currentY, 0, _("Restoring from archives"));
[1108]	2115	mr_msg(2,
[128]	2116	"Insisting on 1st CD, so that I can have a look at LAST-FILELIST-NUMBER");
	2117	if (g_current_media_number != 1) {
[1108]	2118	mr_msg(3, "OK, that's jacked up.");
[128]	2119	g_current_media_number = 1;
[1]	2120	}
[1663]	2121	insist_on_this_cd_number(g_current_media_number);
[1199]	2122	read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp1);
	2123	max_val = atol(tmp1) + 1;
	2124	mr_free(tmp1);
	2125
	2126	mr_asprintf(&progress_str, _("Restoring from %s #%d"),
	2127	bkpinfo->backup_media_string,
[128]	2128	g_current_media_number);
	2129	log_to_screen(progress_str);
[1199]	2130	open_progress_form(_("Restoring from archives"),
	2131	_("Restoring data from the archives."),
	2132	_("Please wait. This may take some time."),
[128]	2133	progress_str, max_val);
	2134	for (;;) {
[1663]	2135	insist_on_this_cd_number(g_current_media_number);
[128]	2136	update_progress_form(progress_str);
[1199]	2137	mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.bz2",
[128]	2138	current_tarball_number);
[1077]	2139	if (!does_file_exist(tarball_fname)) {
[1199]	2140	mr_free(tarball_fname);
[1374]	2141	mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.gz",
	2142	current_tarball_number);
[1077]	2143	}
[128]	2144	if (!does_file_exist(tarball_fname)) {
[1199]	2145	mr_free(tarball_fname);
[1374]	2146	mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.lzo",
	2147	current_tarball_number);
[128]	2148	}
	2149	if (!does_file_exist(tarball_fname)) {
[1199]	2150	mr_free(tarball_fname);
	2151	mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.",
[128]	2152	current_tarball_number);
	2153	}
	2154	if (!does_file_exist(tarball_fname)) {
[1199]	2155	mr_free(tarball_fname);
	2156	mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.bz2",
[128]	2157	current_tarball_number);
	2158	}
	2159	if (!does_file_exist(tarball_fname)) {
[1199]	2160	mr_free(tarball_fname);
	2161	mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.",
[128]	2162	current_tarball_number);
	2163	}
	2164	if (!does_file_exist(tarball_fname)) {
[1199]	2165	mr_free(tarball_fname);
[128]	2166	if (current_tarball_number == 0) {
	2167	log_to_screen
[1203]	2168	(_("No tarballs. Strange. Maybe you only backed up freakin' big files?"));
[1199]	2169	mr_free(progress_str);
[128]	2170	return (0);
	2171	}
	2172	if (!does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")
	2173	\|\| system("find " MNT_CDROM
	2174	"/archives/slice* > /dev/null 2> /dev/null") ==
	2175	0) {
[1199]	2176	mr_free(tarball_fname);
	2177	mr_free(progress_str);
[128]	2178	break;
	2179	}
	2180	g_current_media_number++;
[1199]	2181	mr_free(progress_str);
	2182
	2183	mr_asprintf(&progress_str, _("Restoring from %s #%d"),
	2184	bkpinfo->backup_media_string,
[128]	2185	g_current_media_number);
	2186	log_to_screen(progress_str);
	2187	} else {
[1199]	2188	mr_free(progress_str);
	2189	mr_asprintf(&progress_str,
	2190	_("Restoring from fileset #%ld on %s #%d"),
[128]	2191	current_tarball_number,
[1199]	2192	bkpinfo->backup_media_string,
[128]	2193	g_current_media_number);
	2194	for (res = 999, attempts = 0; attempts < 3 && res != 0;
	2195	attempts++) {
	2196	res =
	2197	restore_a_tarball_from_CD(tarball_fname,
	2198	current_tarball_number,
[1166]	2199	filelist, bkpinfo);
[128]	2200	}
[1199]	2201	mr_asprintf(&tmp, _("%s #%d, fileset #%ld - restore "),
[128]	2202	media_descriptor_string(bkpinfo->backup_media_type),
	2203	g_current_media_number, current_tarball_number);
	2204	if (res) {
[1199]	2205	mr_strcat(tmp, _("reported errors"));
[128]	2206	} else {
[1199]	2207	mr_strcat(tmp, _("succeeded"));
[128]	2208	}
	2209	if (attempts > 1) {
[1199]	2210	mr_strcat(tmp, _(" (%d attempts) - review logs"), attempts);
[128]	2211	}
	2212	if (attempts > 1) {
[1199]	2213	log_to_screen(tmp);
[128]	2214	}
[1199]	2215	mr_free(tmp);
[128]	2216
	2217	retval += res;
	2218	current_tarball_number++;
	2219	g_current_progress++;
	2220	}
[1199]	2221	mr_free(tarball_fname);
[1]	2222	}
[1199]	2223	mr_free(progress_str);
[128]	2224	close_progress_form();
[1199]	2225
[128]	2226	if (retval) {
[1199]	2227	mvaddstr_and_log_it(g_currentY++, 74, _("Errors."));
[128]	2228	} else {
[1199]	2229	mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
[1]	2230	}
[128]	2231	return (retval);
[1]	2232	}
	2233
	2234	/**************************************************************************
	2235	END_RESTORE_ALL_TARBALLS_FROM_CD
	2236	**************************************************************************/
	2237
	2238
	2239	/**
	2240	* Restore all biggiefiles from the currently opened stream.
	2241	* @param bkpinfo The backup information structure. Passed to other functions.
	2242	* @param filelist The node structure containing the list of files to be
	2243	* restored. If a prospective biggiefile is not in the list, it will be ignored.
	2244	* @return 0 for success, or the number of biggiefiles that failed.
	2245	*/
	2246	int
[1663]	2247	restore_all_biggiefiles_from_stream(struct s_node *filelist)
[1]	2248	{
[1199]	2249	long noof_biggiefiles = 0L;
	2250	long current_bigfile_number = 0L;
	2251	long total_slices = 0L;
[1]	2252
[128]	2253	int retval = 0;
	2254	int res = 0;
[1199]	2255	int ctrl_chr = 0;
[1]	2256
	2257	/ malloc add **/
[1199]	2258	char *tmp = NULL;
	2259	char *biggie_fname = NULL;
	2260	char *biggie_cksum = NULL;
	2261	char *xattr_fname = NULL;
	2262	char *acl_fname = NULL;
	2263	char *pathname_of_last_biggie_restored = NULL;
	2264	char *biggies_whose_EXATs_we_should_set = NULL; // EXtended ATtributes
	2265	long long biggie_size = (long long)0;
	2266	FILE *fbw;
[1]	2267
[1199]	2268	assert(bkpinfo != NULL);
	2269
[128]	2270	malloc_string(tmp);
	2271	malloc_string(biggie_fname);
	2272	malloc_string(biggie_cksum);
	2273	malloc_string(pathname_of_last_biggie_restored);
	2274	read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
[1199]	2275	total_slices = atol(tmp);
	2276	mr_free(tmp);
[1]	2277
[1199]	2278	mr_asprintf(&tmp, "Reassembling large files ");
[948]	2279	if (g_getfattr) {
[1199]	2280	mr_asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
[948]	2281	}
	2282	if (g_getfacl) {
[1199]	2283	mr_asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
[948]	2284	}
[128]	2285	mvaddstr_and_log_it(g_currentY, 0, tmp);
[1199]	2286	mr_free(tmp);
	2287
	2288	mr_asprintf(&biggies_whose_EXATs_we_should_set,
[128]	2289	"%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
	2290	if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w"))) {
[1108]	2291	mr_msg(1, "Warning - cannot openout %s",
[128]	2292	biggies_whose_EXATs_we_should_set);
	2293	}
[1199]	2294	// get xattr and acl files if they're there
[128]	2295	res =
	2296	read_header_block_from_stream(&biggie_size, biggie_fname,
	2297	&ctrl_chr);
	2298	if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
	2299	res =
[1663]	2300	read_EXAT_files_from_tape(&biggie_size, biggie_fname,
[128]	2301	&ctrl_chr, xattr_fname, acl_fname);
	2302	}
[1]	2303
[128]	2304	noof_biggiefiles = atol(biggie_fname);
[1199]	2305	mr_msg(2, "OK, there are %ld biggiefiles in the archives",
[128]	2306	noof_biggiefiles);
[1199]	2307	open_progress_form(_("Reassembling large files"),
	2308	_("I am now reassembling all the large files."),
	2309	_("Please wait. This may take some time."),
[128]	2310	"", total_slices);
[1]	2311
[128]	2312	for (res =
	2313	read_header_block_from_stream(&biggie_size, biggie_fname,
	2314	&ctrl_chr);
	2315	ctrl_chr != BLK_STOP_BIGGIEFILES;
	2316	res =
	2317	read_header_block_from_stream(&biggie_size, biggie_fname,
	2318	&ctrl_chr)) {
	2319	if (ctrl_chr != BLK_START_A_NORMBIGGIE
	2320	&& ctrl_chr != BLK_START_A_PIHBIGGIE) {
	2321	wrong_marker(BLK_START_A_NORMBIGGIE, ctrl_chr);
	2322	}
[1199]	2323	/* BERLIOS: useless
[128]	2324	p = strrchr(biggie_fname, '/');
	2325	if (!p) {
	2326	p = biggie_fname;
	2327	} else {
	2328	p++;
	2329	}
[1199]	2330	*/
	2331	mr_asprintf(&tmp, _("Restoring big file %ld (%lld K)"),
[128]	2332	current_bigfile_number + 1, biggie_size / 1024);
	2333	update_progress_form(tmp);
[1199]	2334	mr_free(tmp);
	2335
[1663]	2336	res = restore_a_biggiefile_from_stream(biggie_fname,
[128]	2337	current_bigfile_number,
	2338	biggie_cksum,
	2339	biggie_size,
	2340	filelist, ctrl_chr,
	2341	pathname_of_last_biggie_restored);
[1108]	2342	mr_msg(1, "I believe I have restored %s",
[128]	2343	pathname_of_last_biggie_restored);
	2344	if (fbw && pathname_of_last_biggie_restored[0]) {
	2345	fprintf(fbw, "%s\n", pathname_of_last_biggie_restored);
	2346	}
[1199]	2347	mr_free(pathname_of_last_biggie_restored);
	2348
[128]	2349	retval += res;
	2350	current_bigfile_number++;
	2351
[1]	2352	}
[128]	2353	if (current_bigfile_number != noof_biggiefiles
	2354	&& noof_biggiefiles != 0) {
[1199]	2355	mr_msg(1, "Warning - bigfileno=%ld but noof_biggiefiles=%ld\n",
[128]	2356	current_bigfile_number, noof_biggiefiles);
	2357	} else {
[1199]	2358	mr_msg(1, "%ld biggiefiles in biggielist.txt; %ld biggiefiles processed today.",
[128]	2359	noof_biggiefiles, current_bigfile_number);
[1]	2360	}
	2361
[128]	2362	if (fbw) {
	2363	fclose(fbw);
	2364	if (length_of_file(biggies_whose_EXATs_we_should_set) > 2) {
	2365	iamhere("Setting biggie-EXATs");
[948]	2366	if (g_getfattr) {
	2367	if (length_of_file(xattr_fname) > 0) {
[1108]	2368	mr_msg(1, "set_fattr_List(%s,%s)",
[128]	2369	biggies_whose_EXATs_we_should_set, xattr_fname);
[948]	2370	set_fattr_list(biggies_whose_EXATs_we_should_set,
[128]	2371	xattr_fname);
[948]	2372	}
[128]	2373	}
[948]	2374	if (g_getfacl) {
	2375	if (length_of_file(acl_fname) > 0) {
[1108]	2376	mr_msg(1, "set_acl_list(%s,%s)",
[948]	2377	biggies_whose_EXATs_we_should_set, acl_fname);
	2378	set_acl_list(biggies_whose_EXATs_we_should_set, acl_fname);
	2379	}
	2380	}
[128]	2381	} else {
	2382	iamhere
	2383	("No biggiefiles selected. So, no biggie-EXATs to set.");
	2384	}
[1]	2385	}
[1199]	2386	mr_free(xattr_fname);
	2387	mr_free(acl_fname);
	2388	mr_free(biggies_whose_EXATs_we_should_set);
	2389
[128]	2390	if (does_file_exist("/PAUSE")) {
	2391	popup_and_OK
[1203]	2392	(_("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
[1]	2393	}
	2394
[128]	2395	close_progress_form();
	2396	if (retval) {
[1199]	2397	mvaddstr_and_log_it(g_currentY++, 74, _("Errors."));
[128]	2398	} else {
[1199]	2399	mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
[128]	2400	}
[1080]	2401	mr_free(biggie_fname);
	2402	mr_free(biggie_cksum);
[128]	2403	return (retval);
[1]	2404	}
[128]	2405
[1]	2406	/**************************************************************************
	2407	END_RESTORE_ALL_BIGGIEFILES_FROM_STREAM
	2408	**************************************************************************/
	2409
	2410
	2411	/**
	2412	* Restore all afioballs from the currently opened tape stream.
	2413	* @param bkpinfo The backup information structure. Fields used:
	2414	* - @c bkpinfo->backup_media_type
	2415	* - @c bkpinfo->restore_path
	2416	* @param filelist The node structure containing the list of files to be
	2417	* restored. If no file in an afioball is in this list, afio will still be
	2418	* called for that fileset, but nothing will be written.
	2419	* @return 0 for success, or the number of filesets that failed.
	2420	*/
	2421	int
[1663]	2422	restore_all_tarballs_from_stream(struct s_node *filelist)
[1]	2423	{
[128]	2424	int retval = 0;
[1199]	2425	int res = 0;
[128]	2426	long current_afioball_number = 0;
[1199]	2427	int ctrl_chr = 0;
	2428	long max_val = 0L /, total_noof_files / ;
[1]	2429
	2430	/ malloc /
[1199]	2431	char *tmp = NULL;
	2432	char *progress_str = NULL;
	2433	char *tmp_fname = NULL;
	2434	char *xattr_fname = NULL;
	2435	char *acl_fname = NULL;
[1]	2436
[1199]	2437	long long tmp_size = 0L;
[1]	2438
[1199]	2439	malloc_string(tmp_fname);
[128]	2440	malloc_string(tmp);
	2441	assert(bkpinfo != NULL);
[1199]	2442	mvaddstr_and_log_it(g_currentY, 0, _("Restoring from archives"));
[128]	2443	read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
	2444	max_val = atol(tmp) + 1;
[1199]	2445	mr_free(tmp);
[1]	2446
[128]	2447	chdir(bkpinfo->restore_path); /* I don't know why this is needed _here_ but it seems to be. -HR, 02/04/2002 */
[1]	2448
[128]	2449	run_program_and_log_output("pwd", 5);
[1]	2450
[1199]	2451	mr_asprintf(&progress_str, _("Restoring from media #%d"),
[128]	2452	g_current_media_number);
	2453	log_to_screen(progress_str);
[1199]	2454	open_progress_form(_("Restoring from archives"),
	2455	_("Restoring data from the archives."),
	2456	_("Please wait. This may take some time."),
[128]	2457	progress_str, max_val);
[1]	2458
[1108]	2459	mr_msg(3, "hey");
[1]	2460
[128]	2461	res = read_header_block_from_stream(&tmp_size, tmp_fname, &ctrl_chr);
	2462	if (res) {
[1108]	2463	mr_msg(2, "Warning - error reading afioball from tape");
[1]	2464	}
[128]	2465	retval += res;
	2466	if (ctrl_chr != BLK_START_AFIOBALLS) {
	2467	wrong_marker(BLK_START_AFIOBALLS, ctrl_chr);
[1]	2468	}
[1108]	2469	mr_msg(2, "ho");
[128]	2470	res = read_header_block_from_stream(&tmp_size, tmp_fname, &ctrl_chr);
	2471	while (ctrl_chr != BLK_STOP_AFIOBALLS) {
	2472	update_progress_form(progress_str);
[948]	2473	if (g_getfattr) {
[1199]	2474	mr_asprintf(&xattr_fname, "%s/xattr-subset-%ld.tmp", bkpinfo->tmpdir,
[128]	2475	current_afioball_number);
[948]	2476	unlink(xattr_fname);
	2477	}
	2478	if (g_getfacl) {
[1199]	2479	mr_asprintf(&acl_fname, "%s/acl-subset-%ld.tmp", bkpinfo->tmpdir,
[128]	2480	current_afioball_number);
[948]	2481	unlink(acl_fname);
	2482	}
[128]	2483	if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
	2484	iamhere("Reading EXAT files from tape");
	2485	res =
[1663]	2486	read_EXAT_files_from_tape(&tmp_size, tmp_fname,
[128]	2487	&ctrl_chr, xattr_fname,
	2488	acl_fname);
	2489	}
	2490	if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
	2491	wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
	2492	}
[1199]	2493	/* BERLIOS: useless ?
	2494	mr_asprintf(&tmp,
	2495	_("Restoring from fileset #%ld (name=%s, size=%ld K)"),
[128]	2496	current_afioball_number, tmp_fname, (long) tmp_size >> 10);
[1199]	2497	*/
[128]	2498	res =
[1663]	2499	restore_a_tarball_from_stream(tmp_fname,
[128]	2500	current_afioball_number,
	2501	filelist, tmp_size, xattr_fname,
	2502	acl_fname);
	2503	retval += res;
	2504	if (res) {
[1199]	2505	log_to_screen("Fileset %ld - errors occurred",
[128]	2506	current_afioball_number);
	2507	}
	2508	res =
	2509	read_header_block_from_stream(&tmp_size, tmp_fname, &ctrl_chr);
	2510	if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
	2511	wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
	2512	}
[1]	2513
[128]	2514	current_afioball_number++;
	2515	g_current_progress++;
[1199]	2516
	2517	mr_free(progress_str);
	2518	mr_asprintf(&progress_str, _("Restoring from fileset #%ld on %s #%d"),
[128]	2519	current_afioball_number,
[1199]	2520	bkpinfo->backup_media_string,
[128]	2521	g_current_media_number);
	2522	res =
	2523	read_header_block_from_stream(&tmp_size, tmp_fname, &ctrl_chr);
[948]	2524	if (g_getfattr) {
	2525	unlink(xattr_fname);
	2526	}
	2527	if (g_getfacl) {
	2528	unlink(acl_fname);
	2529	}
[1199]	2530	mr_free(xattr_fname);
	2531	mr_free(acl_fname);
[128]	2532	} // next
[1199]	2533	mr_free(progress_str);
	2534	mr_free(tmp_fname);
	2535
[1108]	2536	mr_msg(1, "All done with afioballs");
[128]	2537	close_progress_form();
	2538	if (retval) {
[1199]	2539	mvaddstr_and_log_it(g_currentY++, 74, _("Errors."));
[128]	2540	} else {
[1199]	2541	mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
[128]	2542	}
	2543	return (retval);
[1]	2544	}
[128]	2545
[1]	2546	/**************************************************************************
	2547	END_ RESTORE_ALL_TARBALLS_FROM_STREAM
	2548	**************************************************************************/
	2549
	2550	/* @} - end of LLrestoreGroup */
	2551
	2552
	2553	/**
	2554	* Restore all files in @p filelist.
	2555	* @param bkpinfo The backup information structure. Most fields are used.
	2556	* @param filelist The node structure containing the list of files to be
	2557	* restored.
	2558	* @return 0 for success, or the number of afioballs and biggiefiles that failed.
	2559	* @ingroup restoreGroup
	2560	*/
[1663]	2561	int restore_everything(struct s_node *filelist)
[1]	2562	{
[128]	2563	int resA;
	2564	int resB;
[1]	2565
	2566	/ mallco */
[1199]	2567	char *cwd = NULL;
	2568	char *newpath = NULL;
	2569	char *tmp = NULL;
[128]	2570	assert(bkpinfo != NULL);
[1]	2571
[128]	2572	malloc_string(cwd);
	2573	malloc_string(newpath);
[1108]	2574	mr_msg(2, "restore_everything() --- starting");
[128]	2575	g_current_media_number = 1;
[1199]	2576	/* BERLIOS: should test return value, or better change the function */
[128]	2577	getcwd(cwd, MAX_STR_LEN - 1);
[1199]	2578	mr_asprintf(&tmp, "mkdir -p %s", bkpinfo->restore_path);
[128]	2579	run_program_and_log_output(tmp, FALSE);
[1199]	2580	mr_free(tmp);
	2581
[1108]	2582	mr_msg(1, "Changing dir to %s", bkpinfo->restore_path);
[128]	2583	chdir(bkpinfo->restore_path);
[1199]	2584	/* BERLIOS: should test return value, or better change the function */
[128]	2585	getcwd(newpath, MAX_STR_LEN - 1);
[1108]	2586	mr_msg(1, "path is now %s", newpath);
	2587	mr_msg(1, "restoring everything");
[128]	2588	if (!find_home_of_exe("petris") && !g_text_mode) {
	2589	newtDrawRootText(0, g_noof_rows - 2,
[1203]	2590	_("Press ALT-<left cursor> twice to play Petris :-) "));
[128]	2591	newtRefresh();
[1]	2592	}
[1199]	2593	mvaddstr_and_log_it(g_currentY, 0, _("Preparing to read your archives"));
[128]	2594	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
[1770]	2595	mount_media();
[128]	2596	mvaddstr_and_log_it(g_currentY++, 0,
[1203]	2597	_("Restoring OS and data from streaming media"));
[128]	2598	if (bkpinfo->backup_media_type == cdstream) {
[1663]	2599	openin_cdstream();
[128]	2600	} else {
[1663]	2601	assert_string_is_neither_NULL_nor_zerolength(bkpinfo->media_device);
	2602	openin_tape();
[128]	2603	}
[1663]	2604	resA = restore_all_tarballs_from_stream(filelist);
	2605	resB = restore_all_biggiefiles_from_stream(filelist);
[128]	2606	if (bkpinfo->backup_media_type == cdstream) {
[1663]	2607	closein_cdstream();
[128]	2608	} else {
[1663]	2609	closein_tape();
[128]	2610	}
	2611	} else {
	2612	mvaddstr_and_log_it(g_currentY++, 0,
[1770]	2613	_("Restoring OS and data from CD/USB "));
	2614	mount_media();
[1663]	2615	resA = restore_all_tarballs_from_CD(filelist);
	2616	resB = restore_all_biggiefiles_from_CD(filelist);
[1]	2617	}
[128]	2618	chdir(cwd);
	2619	if (resA + resB) {
[1199]	2620	log_to_screen(_("Errors occurred while data was being restored."));
[1]	2621	}
[128]	2622	if (length_of_file("/etc/raidtab") > 0) {
[1108]	2623	mr_msg(2, "Copying local raidtab to restored filesystem");
[128]	2624	run_program_and_log_output("cp -f /etc/raidtab " MNT_RESTORING
	2625	"/etc/raidtab", FALSE);
[1]	2626	}
[128]	2627	kill_petris();
[1108]	2628	mr_msg(2, "restore_everything() --- leaving");
[1080]	2629	mr_free(cwd);
	2630	mr_free(newpath);
[128]	2631	return (resA + resB);
[1]	2632	}
	2633
	2634	/**************************************************************************
	2635	END_RESTORE_EVERYTHING
	2636	**************************************************************************/
	2637
	2638
	2639	/**
	2640	* @brief Haha. You wish! (This function is not implemented :-)
	2641	*/
	2642	int
[1663]	2643	restore_live_from_monitas_server(char *monitas_device,
[128]	2644	char *restore_this_directory,
	2645	char *restore_here)
	2646	/* NB: bkpinfo hasn't been populated yet, except for ->tmp which is "/tmp" */
[1]	2647	{
[128]	2648	FILE *fout;
	2649	int retval = 0;
	2650	int i;
	2651	int j;
	2652	struct mountlist_itself the_mountlist;
	2653	static struct raidlist_itself the_raidlist;
[1]	2654	/ malloc /
[128]	2655	char tmp[MAX_STR_LEN + 1];
	2656	char command[MAX_STR_LEN + 1];
	2657	char datablock[256 * 1024];
	2658	char datadisks_fname[MAX_STR_LEN + 1];
	2659	long k;
	2660	long length;
	2661	long long llt;
	2662	struct s_node *filelist = NULL;
	2663	assert(bkpinfo != NULL);
	2664	assert_string_is_neither_NULL_nor_zerolength(monitas_device);
	2665	assert(restore_this_directory != NULL);
	2666	assert(restore_here != NULL);
[1]	2667
[128]	2668	sprintf(tmp, "restore_here = '%s'", restore_here);
[1]	2669
[1108]	2670	mr_msg(2, tmp);
[1]	2671
[1108]	2672	mr_msg(2, "restore_live_from_monitas_server() - starting");
[128]	2673	unlink("/tmp/mountlist.txt");
	2674	unlink("/tmp/filelist.full");
	2675	unlink("/tmp/biggielist.txt");
	2676	if (restore_here[0] == '\0') {
	2677	strcpy(bkpinfo->restore_path, MNT_RESTORING);
	2678	} else {
	2679	strcpy(bkpinfo->restore_path, restore_here);
	2680	}
[1108]	2681	mr_msg(3, "FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI");
[128]	2682	sprintf(tmp, "FYI - data will be restored to %s",
	2683	bkpinfo->restore_path);
[1108]	2684	mr_msg(3, tmp);
	2685	mr_msg(3, "FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI");
[128]	2686	sprintf(datadisks_fname, "/tmp/mondorestore.datadisks.%d",
	2687	(int) (random() % 32768));
	2688	chdir(bkpinfo->tmpdir);
[1]	2689
[128]	2690	sprintf(command, "cat %s", monitas_device);
	2691	g_tape_stream = popen(command, "r"); // for compatibility with openin_tape()
	2692	if (!(fout = fopen(datadisks_fname, "w"))) {
	2693	log_OS_error(datadisks_fname);
	2694	return (1);
	2695	}
	2696	for (i = 0; i < 32; i++) {
	2697	for (j = 0; j < 4; j++) {
	2698	for (length = k = 0; length < 256 * 1024; length += k) {
	2699	k = fread(datablock + length, 1, 256 * 1024 - length,
	2700	g_tape_stream);
	2701	}
	2702	fwrite(datablock, 1, length, fout);
	2703	g_tape_posK += length;
	2704	}
	2705	}
	2706	paranoid_fclose(fout);
	2707	sprintf(command,
	2708	"tar -zxvf %s tmp/mondo-restore.cfg tmp/mountlist.txt tmp/filelist.full tmp/biggielist.txt",
	2709	datadisks_fname);
	2710	run_program_and_log_output(command, 4);
	2711	read_header_block_from_stream(&llt, tmp, &i);
	2712	read_header_block_from_stream(&llt, tmp, &i);
[1]	2713
[128]	2714	unlink(datadisks_fname);
[1663]	2715	read_cfg_file_into_bkpinfo(g_mondo_cfg_file);
[128]	2716	retval = load_mountlist(&the_mountlist, g_mountlist_fname); // in case read_cfg_file_into_bkpinfo strcpy(bkpinfo->media_device, monitas_device);
	2717
	2718
	2719	load_raidtab_into_raidlist(&the_raidlist, RAIDTAB_FNAME);
	2720	iamhere("FIXME");
	2721	fatal_error("This will fail");
	2722	sprintf(command,
[911]	2723	"grep -E '^%s.*$' %s > %s",
[273]	2724	restore_this_directory, g_filelist_full, g_filelist_full);
[128]	2725	if (system(command)) {
	2726	retval++;
	2727	log_to_screen
[541]	2728	("Error(s) occurred while processing filelist and wildcard");
[128]	2729	}
	2730	iamhere("FIXME");
	2731	fatal_error("This will fail");
	2732	sprintf(command,
[911]	2733	"grep -E '^%s.*$' %s > %s",
[273]	2734	restore_this_directory, g_biggielist_txt, g_biggielist_txt);
[128]	2735	if (system(command)) {
[1108]	2736	mr_msg(1,
[128]	2737	"Error(s) occurred while processing biggielist and wildcard");
	2738	}
	2739	sprintf(command, "touch %s", g_biggielist_txt);
	2740	run_program_and_log_output(command, FALSE);
[1]	2741	// filelist = load_filelist(g_filelist_restthese); // FIXME --- this probably doesn't work because it doesn't include the biggiefiles
[1663]	2742	retval += restore_everything(filelist);
[128]	2743	free_filelist(filelist);
[1108]	2744	mr_msg(2, "--------End of restore_live_from_monitas_server--------");
[128]	2745	return (retval);
[1]	2746	}
[128]	2747
[1]	2748	/**************************************************************************
	2749	END_RESTORE_LIVE_FROM_MONITAS_SERVER
	2750	**************************************************************************/
	2751
	2752
	2753
	2754
[1251]	2755	extern void wait_until_software_raids_are_prepped(int);
[1]	2756
	2757	char which_restore_mode(void);
	2758
	2759
	2760	/**
	2761	* Log a "don't panic" message to the logfile.
	2762	*/
[1265]	2763	void welcome_to_mondorestore(void)
[1]	2764	{
[1108]	2765	mr_msg(0, "-------------- Mondo Restore v%s -------------", PACKAGE_VERSION);
	2766	mr_msg(0,
[128]	2767	"DON'T PANIC! Mondorestore logs almost everything, so please ");
[1108]	2768	mr_msg(0,
[128]	2769	"don't break out in a cold sweat just because you see a few ");
[1108]	2770	mr_msg(0,
[128]	2771	"error messages in the log. Read them; analyze them; see if ");
[1108]	2772	mr_msg(0,
[128]	2773	"they are significant; above all, verify your backups! Please");
[1108]	2774	mr_msg(0,
[128]	2775	"attach a compressed copy of this log to any e-mail you send ");
[1108]	2776	mr_msg(0,
[128]	2777	"to the Mondo mailing list when you are seeking technical ");
[1108]	2778	mr_msg(0,
[607]	2779	"support. Without it, we can't help you. - DevTeam");
[1108]	2780	mr_msg(0,
[128]	2781	"------------------------------------------------------------");
[1108]	2782	mr_msg(0,
[128]	2783	"BTW, despite (or perhaps because of) the wealth of messages,");
[1108]	2784	mr_msg(0,
[128]	2785	"some users are inclined to stop reading this log. If Mondo ");
[1108]	2786	mr_msg(0,
[128]	2787	"stopped for some reason, chances are it's detailed here. ");
[1108]	2788	mr_msg(0,
[1199]	2789	"More than likely there's a message near the end of this ");
[1108]	2790	mr_msg(0,
[128]	2791	"log that will tell you what is wrong. Please read it! ");
[1108]	2792	mr_msg(0,
[128]	2793	"------------------------------------------------------------");
[1]	2794	}
	2795
	2796
	2797	/**
	2798	* Restore the user's data.
	2799	* What did you think it did, anyway? :-)
	2800	*/
[1556]	2801	int main(int argc, char *argv[])
[1]	2802	{
[1199]	2803	FILE *fin = NULL;
	2804	FILE *fout = NULL;
[128]	2805	int retval = 0;
[1199]	2806	int res = 0;
	2807	char *tmp = NULL;
[1]	2808
[1199]	2809	struct mountlist_itself *mountlist = NULL;
	2810	struct raidlist_itself *raidlist = NULL;
	2811	struct s_node *filelist = NULL;
	2812	char a = NULL, b = NULL;
[818]	2813	bool run_postnuke = FALSE;
[1]	2814
[1199]	2815	#ifdef ENABLE_NLS
	2816	setlocale(LC_ALL, "");
	2817	(void) textdomain("mondo");
	2818	#endif
	2819
[1264]	2820	/* Reference the right cleanup function for mr_exit */
[1269]	2821	mr_cleanup = &mr_rs_cleanup;
[1264]	2822
[128]	2823	if (getuid() != 0) {
[1199]	2824	fprintf(stderr, _("Please run as root.\n"));
[1264]	2825	mr_exit(127, NULL);
[128]	2826	}
[1626]	2827	/* Conf file management */
	2828	mr_conf = mr_malloc(sizeof(struct mr_rs_conf));
	2829	mr_rs_reset_conf(mr_conf);
[1663]	2830	bkpinfo = mr_malloc(sizeof(struct s_bkpinfo));
	2831	reset_bkpinfo();
[1]	2832
[1625]	2833	mr_conf->log_level = DEFAULT_MR_LOGLEVEL;
[128]	2834
[1]	2835	/* Configure global variables */
	2836	#ifdef __FreeBSD__
[128]	2837	if (strstr
	2838	(call_program_and_get_last_line_of_output("cat /tmp/cmdline"),
	2839	"textonly"))
[1]	2840	#else
[128]	2841	if (strstr
	2842	(call_program_and_get_last_line_of_output("cat /proc/cmdline"),
	2843	"textonly"))
[1]	2844	#endif
[128]	2845	{
	2846	g_text_mode = TRUE;
[1108]	2847	mr_msg(1, "TEXTONLY MODE");
[128]	2848	} else {
	2849	g_text_mode = FALSE;
	2850	} // newt :-)
[1080]	2851	mountlist = mr_malloc(sizeof(struct mountlist_itself));
	2852	raidlist = mr_malloc(sizeof(struct raidlist_itself));
[1]	2853
[128]	2854	malloc_libmondo_global_strings();
[1]	2855
[128]	2856	sprintf(g_tmpfs_mountpt, "/tmp/tmpfs");
	2857	make_hole_for_dir(g_tmpfs_mountpt);
	2858	g_current_media_number = 1; // precaution
[1]	2859
[128]	2860	run_program_and_log_output("mkdir -p " MNT_CDROM, FALSE);
[1]	2861
[128]	2862	malloc_string(a);
	2863	malloc_string(b);
[1663]	2864	setup_MR_global_filenames(); // malloc() and set globals, using bkpinfo->tmpdir etc.
[128]	2865	bkpinfo->backup_media_type = none; // in case boot disk was made for one backup type but user wants to restore from another backup type
[1208]	2866	strcpy(bkpinfo->backup_media_string,"");
[128]	2867	bkpinfo->restore_data = TRUE; // Well, yeah :-)
	2868	if (am_I_in_disaster_recovery_mode()) {
	2869	run_program_and_log_output("mount / -o remount,rw", 2);
	2870	} // for b0rken distros
	2871	g_main_pid = getpid();
	2872	srandom((int) (time(NULL)));
	2873	register_pid(getpid(), "mondo");
	2874	set_signals(TRUE);
	2875	g_kernel_version = get_kernel_version();
[1]	2876
[1108]	2877	mr_msg(1, "FYI - g_mountlist_fname = %s", g_mountlist_fname);
[128]	2878	if (strlen(g_mountlist_fname) < 3) {
	2879	fatal_error
	2880	("Serious error in malloc()'ing. Could be a bug in your glibc.");
	2881	}
	2882	mkdir(MNT_CDROM, 0x770);
[1770]	2883	make_hole_for_dir(MONDO_CACHE);
[128]	2884
[1]	2885	/* Backup original mountlist.txt */
[1199]	2886	mr_asprintf(&tmp, "%s.orig", g_mountlist_fname);
[128]	2887	if (!does_file_exist(g_mountlist_fname)) {
[1108]	2888	mr_msg(2,
[128]	2889	"%ld: Warning - g_mountlist_fname (%s) does not exist yet",
	2890	__LINE__, g_mountlist_fname);
	2891	} else if (!does_file_exist(tmp)) {
[1199]	2892	mr_free(tmp);
	2893	mr_asprintf(&tmp, "cp -f %s %s.orig", g_mountlist_fname,
[128]	2894	g_mountlist_fname);
	2895	run_program_and_log_output(tmp, FALSE);
	2896	}
[1199]	2897	mr_free(tmp);
[1]	2898
	2899	/* Init directories */
[128]	2900	make_hole_for_dir("/var/log");
	2901	make_hole_for_dir("/tmp/tmpfs"); /* just in case... */
	2902	run_program_and_log_output("umount " MNT_CDROM, FALSE);
[1]	2903
[128]	2904	run_program_and_log_output("rm -Rf /tmp/tmpfs/mondo.tmp.*", FALSE);
[1]	2905
[1199]	2906	/* Init GUI */
[128]	2907	malloc_libmondo_global_strings();
	2908	setup_newt_stuff(); /* call newtInit and setup screen log */
	2909	welcome_to_mondorestore();
	2910	if (bkpinfo->disaster_recovery) {
[1108]	2911	mr_msg(1, "I am in disaster recovery mode");
[128]	2912	} else {
[1108]	2913	mr_msg(1, "I am in normal, live mode");
[128]	2914	}
[1]	2915
[128]	2916	iamhere("what time is it");
[1]	2917
[1199]	2918	/* Process command-line parameters */
[128]	2919	if (argc == 2 && strcmp(argv[1], "--edit-mountlist") == 0) {
[1]	2920	#ifdef __FreeBSD__
[128]	2921	system("mv -f /tmp/raidconf.txt /etc/raidtab");
	2922	if (!does_file_exist("/etc/raidtab"))
	2923	system("vinum printconfig > /etc/raidtab");
[1]	2924	#endif
[128]	2925	load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
	2926	if (!does_file_exist(g_mountlist_fname)) {
	2927	strcpy(g_mountlist_fname, "/tmp/mountlist.txt");
	2928	}
[1663]	2929	res = let_user_edit_the_mountlist(mountlist, raidlist);
[1]	2930	#ifdef __FreeBSD__
[128]	2931	system("mv -f /etc/raidtab /tmp/raidconf.txt");
[1]	2932	#endif
[128]	2933	paranoid_MR_finish(res);
	2934	}
[1]	2935
[1625]	2936	mr_conf->log_level = DEFAULT_MR_LOGLEVEL;
[128]	2937	if (argc == 3 && strcmp(argv[1], "--echo-to-screen") == 0) {
	2938	fout = fopen("/tmp/out.txt", "w");
	2939	fput_string_one_char_at_a_time(stderr, argv[2]);
	2940	finish(0);
	2941	}
[1]	2942
[128]	2943	if (argc == 3 && strcmp(argv[1], "--gendf") == 0) {
	2944	make_grub_install_scriptlet(argv[2]);
	2945	finish(0);
	2946	}
[1]	2947
[128]	2948	if (argc == 5 && strcmp(argv[1], "--common") == 0) {
[1625]	2949	mr_conf->log_level = 6;
[128]	2950	filelist = load_filelist(argv[2]);
	2951	if (!filelist) {
	2952	fatal_error("Failed to load filelist");
	2953	}
	2954	toggle_node_selection(filelist, FALSE);
	2955	toggle_all_root_dirs_on(filelist);
[179]	2956	// BERLIOS: /usr/lib ???
[128]	2957	toggle_path_selection(filelist, "/usr/share", TRUE);
	2958	save_filelist(filelist, "/tmp/out.txt");
[1199]	2959	mr_asprintf(&a, argv[3]);
	2960	mr_asprintf(&b, argv[4]);
[1]	2961
[128]	2962	res = save_filelist_entries_in_common(a, filelist, b, FALSE);
	2963	free_filelist(filelist);
[1199]	2964	mr_free(a);
	2965	mr_free(b);
[128]	2966	printf("res = %d", res);
	2967	finish(0);
	2968	}
[1]	2969
[128]	2970	if (argc == 3 && strcmp(argv[1], "--popuplist") == 0) {
	2971	popup_changelist_from_file(argv[2]);
	2972	paranoid_MR_finish(0);
	2973	}
[1]	2974
[128]	2975	if (argc == 5 && strcmp(argv[1], "--copy") == 0) {
[1108]	2976	mr_msg(1, "SCORE");
[1625]	2977	mr_conf->log_level = 10;
[128]	2978	if (strstr(argv[2], "save")) {
[1108]	2979	mr_msg(1, "Saving from %s to %s", argv[3], argv[4]);
[128]	2980	fin = fopen(argv[3], "r");
	2981	fout = fopen(argv[4], "w");
	2982	copy_from_src_to_dest(fin, fout, 'w');
	2983	fclose(fin);
	2984	fin = fopen(argv[3], "r");
	2985	copy_from_src_to_dest(fin, fout, 'w');
	2986	fclose(fout);
	2987	fclose(fin);
	2988	} else if (strstr(argv[2], "restore")) {
	2989	fout = fopen(argv[3], "w");
	2990	fin = fopen(argv[4], "r");
	2991	copy_from_src_to_dest(fout, fin, 'r');
	2992	fclose(fin);
	2993	fin = fopen(argv[4], "r");
	2994	copy_from_src_to_dest(fout, fin, 'r');
	2995	fclose(fout);
	2996	fclose(fin);
	2997	} else {
	2998	fatal_error("Unknown additional param");
	2999	}
	3000	finish(0);
	3001	}
[1]	3002
[1251]	3003	if (argc == 2 && strcmp(argv[1], "--mdstat") == 0) {
	3004	wait_until_software_raids_are_prepped(100);
[128]	3005	finish(0);
	3006	}
[1]	3007
[558]	3008	if (argc == 3 && strcmp(argv[1], "--mdconv") == 0) {
	3009	finish(create_raidtab_from_mdstat(argv[2]));
[128]	3010	}
[1]	3011
[1454]	3012	if (argc == 3 && strcmp(argv[1], "-p") == 0) {
[1628]	3013	mr_allocstr(bkpinfo->prefix,argv[2]);
[1555]	3014	mr_msg(1,"Prefix forced to %s",bkpinfo->prefix);
[1454]	3015	}
[128]	3016
[1903]	3017	if (argc == 3 && strcmp(argv[1], "-K") == 0) {
	3018	g_loglevel = atoi(argv[2]);
	3019	log_msg(1,"Loglevel forced to %s",g_loglevel);
	3020	}
[1454]	3021
[128]	3022	if (argc == 2 && strcmp(argv[1], "--live-grub") == 0) {
	3023	retval = run_grub(FALSE, "/dev/hda");
	3024	if (retval) {
[1199]	3025	log_to_screen(_("Failed to write Master Boot Record"));
[128]	3026	}
	3027	paranoid_MR_finish(0);
[1]	3028	}
[128]	3029	if (argc == 3 && strcmp(argv[1], "--paa") == 0) {
	3030	g_current_media_number = atoi(argv[2]);
[1594]	3031	pause_and_ask_for_cdr(5);
[128]	3032	paranoid_MR_finish(0);
	3033	} else if (!bkpinfo->disaster_recovery) { // live!
	3034	if (argc != 1) {
	3035	popup_and_OK
[1203]	3036	(_("Live mode doesn't support command-line parameters yet."));
[128]	3037	paranoid_MR_finish(1);
	3038	}
[1108]	3039	mr_msg(1, "I am in normal, live mode.");
	3040	mr_msg(2, "FYI, MOUNTLIST_FNAME = %s", g_mountlist_fname);
[128]	3041	mount_boot_if_necessary(); /* for Gentoo users */
[1108]	3042	mr_msg(2, "Still here.");
[128]	3043	if (argc > 1 && strcmp(argv[argc - 1], "--live-from-cd") == 0) {
	3044	g_restoring_live_from_cd = TRUE;
	3045	}
	3046	if (argc == 5 && strcmp(argv[1], "--monitas-live") == 0) {
	3047	retval =
[1663]	3048	restore_live_from_monitas_server(argv[2],
[128]	3049	argv[3], argv[4]);
	3050	} else {
[1108]	3051	mr_msg(2, "Calling restore_to_live_filesystem()");
[1663]	3052	retval = restore_to_live_filesystem();
[128]	3053	}
[1108]	3054	mr_msg(2, "Still here. Yay.");
[128]	3055	if (strlen(bkpinfo->tmpdir) > 0) {
[1199]	3056	mr_asprintf(&tmp, "rm -Rf %s/*", bkpinfo->tmpdir);
[128]	3057	run_program_and_log_output(tmp, FALSE);
[1199]	3058	mr_free(tmp);
[128]	3059	}
	3060	unmount_boot_if_necessary(); /* for Gentoo users */
	3061	paranoid_MR_finish(retval);
	3062	} else {
[804]	3063	/* Disaster recovery mode (must be) */
[1108]	3064	mr_msg(1, "I must be in disaster recovery mode.");
	3065	mr_msg(2, "FYI, MOUNTLIST_FNAME = %s ", g_mountlist_fname);
[128]	3066	if (argc == 3 && strcmp(argv[1], "--monitas-memorex") == 0) {
[1199]	3067	log_to_screen(_("Uh, that hasn't been implemented yet."));
[128]	3068	paranoid_MR_finish(1);
	3069	}
[1]	3070
[128]	3071	iamhere("About to call load_mountlist and load_raidtab");
	3072	strcpy(bkpinfo->restore_path, MNT_RESTORING);
[1663]	3073	read_cfg_file_into_bkpinfo(g_mondo_cfg_file);
[128]	3074	retval = load_mountlist(mountlist, g_mountlist_fname);
	3075	retval += load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
	3076	iamhere
	3077	("Returned from calling load_mountlist and load_raidtab successfully");
[1]	3078
[128]	3079	if (argc > 1
	3080	&& (strcmp(argv[1], "--compare") == 0
	3081	\|\| strcmp(argv[1], "--nuke") == 0)) {
	3082	if (bkpinfo->backup_media_type == nfs
	3083	&& !is_this_device_mounted(bkpinfo->nfs_mount)) {
[1108]	3084	mr_msg(1, "Mounting nfs dir");
[128]	3085	sprintf(bkpinfo->isodir, "/tmp/isodir");
	3086	run_program_and_log_output("mkdir -p /tmp/isodir", 5);
[1199]	3087	mr_asprintf(&tmp, "mount %s -t nfs -o nolock /tmp/isodir",
[128]	3088	bkpinfo->nfs_mount);
	3089	run_program_and_log_output(tmp, 1);
[1199]	3090	mr_free(tmp);
[128]	3091	}
	3092	}
[1]	3093
	3094
[128]	3095	if (retval) {
	3096	log_to_screen
[1203]	3097	(_("Warning - load_raidtab_into_raidlist returned an error"));
[128]	3098	}
[1]	3099
	3100
[1108]	3101	mr_msg(1, "Send in the clowns.");
[1]	3102
[128]	3103	if (argc == 2 && strcmp(argv[1], "--partition-only") == 0) {
[1108]	3104	mr_msg(0, "Partitioning only.");
[128]	3105	load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
	3106	strcpy(g_mountlist_fname, "/tmp/mountlist.txt");
	3107	load_mountlist(mountlist, g_mountlist_fname);
	3108	res = partition_everything(mountlist);
	3109	finish(res);
	3110	}
[1]	3111
[128]	3112	if (argc == 2 && strcmp(argv[1], "--format-only") == 0) {
[1108]	3113	mr_msg(0, "Formatting only.");
[128]	3114	load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
	3115	strcpy(g_mountlist_fname, "/tmp/mountlist.txt");
	3116	load_mountlist(mountlist, g_mountlist_fname);
[558]	3117	res = format_everything(mountlist, FALSE, raidlist);
[128]	3118	finish(res);
	3119	}
[1]	3120
[128]	3121	if (argc == 2 && strcmp(argv[1], "--stop-lvm-and-raid") == 0) {
[1108]	3122	mr_msg(0, "Stopping LVM and RAID");
[128]	3123	load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
	3124	strcpy(g_mountlist_fname, "/tmp/mountlist.txt");
	3125	load_mountlist(mountlist, g_mountlist_fname);
	3126	res = do_my_funky_lvm_stuff(TRUE, FALSE);
	3127	res += stop_all_raid_devices(mountlist);
	3128	finish(res);
	3129	}
	3130
	3131	if (argc == 2 && strcmp(argv[1], "--nuke") == 0) {
	3132	iamhere("nuking");
[1663]	3133	retval += nuke_mode(mountlist, raidlist);
[128]	3134	} else if (argc == 2 && strcmp(argv[1], "--interactive") == 0) {
	3135	iamhere("catchall");
[1663]	3136	retval += catchall_mode(mountlist, raidlist);
[128]	3137	} else if (argc == 2 && strcmp(argv[1], "--compare") == 0) {
	3138	iamhere("compare");
[1663]	3139	retval += compare_mode(mountlist, raidlist);
[128]	3140	} else if (argc == 2 && strcmp(argv[1], "--iso") == 0) {
	3141	iamhere("iso");
[1663]	3142	retval = iso_mode(mountlist, raidlist, FALSE);
[128]	3143	} else if (argc == 2 && strcmp(argv[1], "--mbr") == 0) {
	3144	iamhere("mbr");
	3145	retval = mount_all_devices(mountlist, TRUE);
	3146	if (!retval) {
	3147	retval += run_boot_loader(FALSE);
	3148	retval += unmount_all_devices(mountlist);
	3149	}
	3150	if (retval) {
[1199]	3151	log_to_screen(_("Failed to write Master Boot Record"));
[128]	3152	}
	3153	} else if (argc == 2 && strcmp(argv[1], "--isonuke") == 0) {
	3154	iamhere("isonuke");
[1663]	3155	retval = iso_mode(mountlist, raidlist, TRUE);
[128]	3156	} else if (argc != 1) {
[1202]	3157	log_to_screen(_("Invalid parameters"));
[128]	3158	paranoid_MR_finish(1);
	3159	} else {
	3160	iamhere("catchall (no mode specified in command-line call");
[1663]	3161	retval += catchall_mode(mountlist, raidlist);
[128]	3162	}
[1]	3163	}
[128]	3164
	3165	/* clean up at the end */
	3166	if (retval) {
[1770]	3167	if (does_file_exist(MONDO_CACHE"/changed.files")) {
[128]	3168	log_to_screen
[1770]	3169	(_("See "MONDO_CACHE"/changed.files for list of files that have changed."));
[128]	3170	}
	3171	mvaddstr_and_log_it(g_currentY++,
	3172	0,
[1203]	3173	_("Run complete. Errors were reported. Please review the logfile."));
[128]	3174	} else {
	3175	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
	3176	mvaddstr_and_log_it(g_currentY++,
	3177	0,
[1903]	3178	_("Run complete. Please remove media and reboot."));
[128]	3179	} else {
	3180	run_program_and_log_output("sync", FALSE);
	3181	if (is_this_device_mounted(MNT_CDROM)) {
	3182	res =
	3183	run_program_and_log_output("umount " MNT_CDROM, FALSE);
	3184	} else {
	3185	res = 0;
	3186	}
	3187
	3188	if (!bkpinfo->please_dont_eject) {
	3189	res = eject_device("/dev/cdrom");
	3190	}
	3191	mvaddstr_and_log_it(g_currentY++,
	3192	0,
[1203]	3193	_("Run complete. Please remove media and reboot."));
[128]	3194	}
[1]	3195	}
	3196
[1199]	3197	// g_I_have_just_nuked is set true by nuke_mode() just before it returns
[818]	3198	if (!system("which post-nuke > /dev/null 2> /dev/null")) {
[1108]	3199	mr_msg(1, "post-nuke found; find out whether we should run it...");
[818]	3200	if (g_I_have_just_nuked \|\| does_file_exist("/POST-NUKE-ANYWAY")) {
	3201	run_postnuke = TRUE;
[1108]	3202	mr_msg(1, "Yes, will run post-nuke because in nuke mode or file /POST-NUKE-ANYWAY exists.");
[818]	3203	} else if (ask_me_yes_or_no("post-nuke script found. Do you want to run it?")) {
	3204	run_postnuke = TRUE;
[1108]	3205	mr_msg(1, "Yes, will run post-nuke because user interactively asked for it.");
[818]	3206	} else {
	3207	run_postnuke = FALSE;
[1108]	3208	mr_msg(1, "No, will not run post-nuke.");
[818]	3209	}
	3210	} else {
[1108]	3211	mr_msg(1, "No post-nuke found.");
[128]	3212	}
[818]	3213	if (run_postnuke) {
	3214	log_to_screen("Running post-nuke...");
	3215	if (mount_all_devices(mountlist, TRUE)) {
	3216	log_to_screen
	3217	("Unable to re-mount partitions for post-nuke stuff");
	3218	} else {
[1108]	3219	mr_msg(1, "Re-mounted partitions for post-nuke stuff");
[1199]	3220	mr_asprintf(&tmp, "post-nuke %s %d", bkpinfo->restore_path,
[818]	3221	retval);
[1108]	3222	mr_msg(2, "Calling '%s'", tmp);
[818]	3223	if ((res = run_program_and_log_output(tmp, 0))) {
	3224	log_OS_error(tmp);
	3225	}
[1199]	3226	mr_free(tmp);
[1108]	3227	mr_msg(1, "post-nuke returned w/ res=%d", res);
[818]	3228	}
	3229	unmount_all_devices(mountlist);
	3230	log_to_screen("I've finished post-nuking.");
	3231	}
	3232
[128]	3233	unlink("/tmp/mondo-run-prog.tmp");
	3234	set_signals(FALSE);
[1199]	3235
[128]	3236	log_to_screen
[1326]	3237	(_("Restore log (%s) copied to /var/log on your hard disk"), MONDO_LOGFILE);
[1199]	3238	log_to_screen(_("Mondo-restore is exiting (retval=%d)"), retval);
	3239
	3240	mr_asprintf(&tmp, "umount %s", bkpinfo->isodir);
[128]	3241	run_program_and_log_output(tmp, 5);
[1199]	3242	mr_free(tmp);
	3243
[1080]	3244	mr_free(mountlist);
	3245	mr_free(raidlist);
[128]	3246	if (am_I_in_disaster_recovery_mode()) {
	3247	run_program_and_log_output("mount / -o remount,rw", 2);
	3248	} // for b0rken distros
[1903]	3249	mr_asprintf(&tmp, "rm -Rf %s", bkpinfo->tmpdir);
	3250	run_program_and_log_output(tmp, FALSE);
	3251	mr_free(tmp);
	3252
[128]	3253	paranoid_MR_finish(retval); // frees global stuff plus bkpinfo
	3254	free_libmondo_global_strings(); // it's fine to have this here :) really :)
[1]	3255
[128]	3256	unlink("/tmp/filelist.full");
	3257	unlink("/tmp/filelist.full.gz");
	3258
[1264]	3259	mr_exit(retval, NULL);
[1]	3260	}
	3261
	3262	/**************************************************************************
	3263	END_MAIN
	3264	**************************************************************************/
	3265
	3266
	3267	/**************************************************************************
	3268	END_MONDO-RESTORE.C
	3269	**************************************************************************/

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

Download in other formats: