Context Navigation

source: MondoRescue/branches/2.2.9/mondo/src/common/libmondo-tools.c@ 2449

Visit:

Last change on this file since 2449 was 2443, checked in by Bruno Cornec, 15 years ago
priority given to env var for tmpdir fuse FS excluded from tmpdir computation
Property svn:keywords set to `Id`
File size: 39.6 KB

Rev	Line
[2030]	1	/*
[99]	2	$Id: libmondo-tools.c 2443 2009-09-29 18:43:38Z bruno $
[1]	3	*/
	4
	5
	6	/**
	7	* @file
	8	* Miscellaneous tools that didn't really fit anywhere else.
	9	*/
	10
	11	#include "my-stuff.h"
[2211]	12	#include "mr_mem.h"
[1]	13	#include "mondostructures.h"
[541]	14	#include "lib-common-externs.h"
[1]	15	#include "libmondo-tools.h"
[541]	16	#include "libmondo-gui-EXT.h"
[1]	17	#include "libmondo-files-EXT.h"
	18	#include "libmondo-fork-EXT.h"
	19	#include "libmondo-raid-EXT.h"
[1917]	20	#include "libmondo-devices-EXT.h"
[1]	21	#include <sys/socket.h>
	22	#include <netdb.h>
[1653]	23	#include <stdlib.h>
[1]	24	#include <netinet/in.h>
	25	#include <arpa/inet.h>
[1375]	26	#include <sys/utsname.h>
[1]	27
	28	/@unused@/
[99]	29	//static char cvsid[] = "$Id: libmondo-tools.c 2443 2009-09-29 18:43:38Z bruno $";
[1]	30
	31	extern int g_tape_buffer_size_MB;
	32	extern char *g_serial_string;
	33	extern bool g_text_mode;
	34	extern int g_currentY;
	35	extern int g_current_media_number;
[1316]	36	extern char *MONDO_LOGFILE;
[1]	37
[1645]	38	/* Reference to global bkpinfo */
	39	extern struct s_bkpinfo *bkpinfo;
	40
[1]	41	/**
	42	* @addtogroup globalGroup
	43	* @{
	44	*/
[128]	45	bool g_remount_cdrom_at_end, ///< TRUE if we unmounted the CD-ROM and should remount it when done with the backup.
	46	g_remount_floppy_at_end; ///< TRUE if we unmounted the floppy and should remount it when done with the backup.
	47	bool g_cd_recovery; ///< TRUE if we're making an "autonuke" backup.
[1]	48	double g_kernel_version;
	49
	50	/**
	51	* The place where /boot is mounted.
	52	*/
[128]	53	char *g_boot_mountpt = NULL;
[1]	54
	55	/**
	56	* The location of Mondo's home directory.
	57	*/
[128]	58	char *g_mondo_home = NULL;
[1]	59
	60	/**
	61	* The serial string (used to differentiate between backups) of the current backup.
	62	*/
[128]	63	char *g_serial_string = NULL;
[1]	64
	65	/**
	66	* The location where tmpfs is mounted, or "" if it's not mounted.
[2030]	67	char *g_tmpfs_mountpt = NULL;
[1]	68	*/
[128]	69	char *g_magicdev_command = NULL;
[1]	70
	71	/**
	72	* The default maximum level to log messages at or below.
	73	*/
[128]	74	int g_loglevel = DEFAULT_DEBUG_LEVEL;
[1]	75
	76	/* @} - end of globalGroup */
	77
	78
	79	extern pid_t g_buffer_pid;
	80	extern pid_t g_main_pid;
	81
	82	extern t_bkptype g_backup_media_type;
	83
	84	extern bool am_I_in_disaster_recovery_mode(void);
	85
[1917]	86	/-----------------------------------------------------------/
	87
	88
[1]	89	/**
	90	* @addtogroup utilityGroup
	91	* @{
	92	*/
	93	/**
	94	* Assertion handler. Prints a friendly message to the user,
	95	* offering to ignore all, dump core, break to debugger,
	96	* exit, or ignore. Intended to be used with an assert() macro.
	97	*
	98	* @param file The file in which the assertion triggered.
	99	* @param function The function (@c __FUNCTION__) in which the assertion triggered.
	100	* @param line The line number of the assert() statement.
	101	* @param exp The expression that failed (as a string).
	102	*/
[128]	103	void _mondo_assert_fail(const char *file,
	104	const char function, int line, const char exp)
[1]	105	{
[128]	106	static int ignoring_assertions = 0;
	107	bool is_valid = TRUE;
[1]	108
[128]	109	log_it("ASSERTION FAILED: `%s' at %s:%d in %s", exp, file, line,
	110	function);
	111	if (ignoring_assertions) {
	112	log_it("Well, the user doesn't care...");
	113	return;
	114	}
[1]	115	#ifndef _XWIN
[128]	116	if (!g_text_mode)
	117	newtSuspend();
[1]	118	#endif
[541]	119	printf("ASSERTION FAILED: `%s'\n", exp);
	120	printf("\tat %s:%d in %s\n\n", file, line, function);
	121	printf("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? ");
[128]	122	do {
	123	is_valid = TRUE;
	124	switch (toupper(getchar())) {
	125	case 'A': // ignore (A)ll
	126	ignoring_assertions = 1;
	127	break;
	128	case 'B': // a(B)ort
	129	signal(SIGABRT, SIG_DFL); /* prevent SIGABRT handler from running */
	130	raise(SIGABRT);
	131	break; /* "can't get here" */
	132	case 'D': // (D)ebug, aka asm("int 3")
[1]	133	#ifdef __IA32__
[128]	134	__asm__ __volatile__("int $3"); // break to debugger
[1]	135	#endif
[128]	136	break;
	137	case 'E': // (E)xit
	138	fatal_error("Failed assertion -- see above for details");
	139	break; /* "can't get here" */
	140	case 'I': // (I)gnore
	141	break;
	142	/* These next two work as follows:
	143	the `default' catches the user's invalid choice and says so;
	144	the '\n' catches the newline on the end and prints the prompt again.
	145	*/
	146	case '\n':
	147	printf
[541]	148	("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? ");
[128]	149	break;
	150	default:
	151	is_valid = FALSE;
[541]	152	printf("Invalid choice.\n");
[128]	153	break;
	154	}
	155	} while (!is_valid);
	156
	157	if (ignoring_assertions) {
	158	log_it("Ignoring ALL assertions from now on.");
	159	} else {
	160	log_it("Ignoring assertion: %s", exp);
[1]	161	}
	162
[128]	163	getchar(); // skip \n
[1]	164
	165	#ifndef _XWIN
[128]	166	if (!g_text_mode)
	167	newtResume();
[1]	168	#endif
	169	}
	170
	171	/**
	172	* Clean's up users' KDE desktops.
	173	* @bug Details about this function are unknown.
	174	*/
	175	void clean_up_KDE_desktop_if_necessary(void)
	176	{
[128]	177	char *tmp;
[1]	178
[128]	179	malloc_string(tmp);
	180	strcpy(tmp,
	181	"for i in `find /root /home -type d -name Desktop -maxdepth 2`; do \
[1]	182	file=$i/.directory; if [ -f \"$file\" ] ; then mv -f $file $file.old ; \
[273]	183	awk '{if (index($0, \"rootimagesmindi\")) { while (length($0)>2) { getline;} ; } \
[275]	184	else { print $0;};}' $file.old > $file ; fi ; done");
[128]	185	run_program_and_log_output(tmp, 5);
	186	paranoid_free(tmp);
[1]	187	}
	188
	189
	190	/**
	191	* Locate mondoarchive's home directory. Searches in /usr/local/mondo, /usr/share/mondo,
	192	* /usr/local/share/mondo, /opt, or if all else fails, search /usr.
	193	*
	194	* @param home_sz String to store the home directory ("" if it could not be found).
	195	* @return 0 for success, nonzero for failure.
	196	*/
	197	int find_and_store_mondoarchives_home(char *home_sz)
	198	{
[128]	199	assert(home_sz != NULL);
[424]	200	strcpy(home_sz, MONDO_SHARE);
[182]	201	return (0);
[1]	202	}
	203
	204
[1375]	205	char *get_architecture(void) {
[1]	206	#ifdef __IA32__
[1375]	207	# ifdef __X86_64__
	208	return ("x86_64");
	209	# else
	210	return ("i386");
	211	# endif
[1]	212	#endif
	213	#ifdef __IA64__
[128]	214	return ("ia64");
[1]	215	#endif
[128]	216	return ("unknown");
[1]	217	}
	218
	219
[1375]	220	char *get_uname_m(void) {
[1]	221
[1375]	222	struct utsname utsn;
	223	char *tmp = NULL;
	224
	225	uname(&utsn);
[2211]	226	mr_asprintf(&tmp, "%s", utsn.machine);
[1375]	227	return (tmp);
	228	}
	229
	230
	231
	232	double get_kernel_version(void)
[1]	233	{
[128]	234	char *p, tmp[200];
	235	double d;
[1]	236	#ifdef __FreeBSD__
[128]	237	// JOSH - FIXME :)
	238	d = 5.2; // :-)
[1]	239	#else
[128]	240	strcpy(tmp, call_program_and_get_last_line_of_output("uname -r"));
	241	p = strchr(tmp, '.');
	242	if (p) {
	243	p = strchr(++p, '.');
	244	if (p) {
	245	while (*p) {
	246	p = (p + 1);
	247	p++;
	248	}
	249	}
	250	}
[1]	251	// log_msg(1, "tmp = '%s'", tmp);
[128]	252	d = atof(tmp);
[1]	253	#endif
[128]	254	log_msg(1, "g_kernel_version = %f", d);
	255	return (d);
[1]	256	}
	257
	258
	259
	260
	261
	262	/**
	263	* Get the current time.
	264	* @return number of seconds since the epoch.
	265	*/
[128]	266	long get_time()
[1]	267	{
[128]	268	return (long) time((void *) 0);
[1]	269	}
	270
	271
	272
	273
	274
	275
	276
	277	/**
	278	* Initialize a RAID volume structure, setting fields to zero. The
	279	* actual hard drive is unaffected.
	280	*
	281	* @param raidrec The RAID volume structure to initialize.
	282	* @note This function is system dependent.
	283	*/
	284	#ifdef __FreeBSD__
[128]	285	void initialize_raidrec(struct vinum_volume *raidrec)
[1]	286	{
[128]	287	int i, j;
	288	raidrec->volname[0] = '\0';
	289	raidrec->plexes = 0;
	290	for (i = 0; i < 9; ++i) {
	291	raidrec->plex[i].raidlevel = -1;
	292	raidrec->plex[i].stripesize = 0;
	293	raidrec->plex[i].subdisks = 0;
	294	for (j = 0; j < 9; ++j) {
	295	strcpy(raidrec->plex[i].sd[j].which_device, "");
	296	}
	297	}
[1]	298	}
	299	#else
[128]	300	void initialize_raidrec(struct raid_device_record *raidrec)
[1]	301	{
[128]	302	assert(raidrec != NULL);
	303	raidrec->raid_device[0] = '\0';
[558]	304	raidrec->raid_level = -9;
[128]	305	raidrec->persistent_superblock = 1;
[558]	306	raidrec->chunk_size = 64;
	307	raidrec->parity = -1;
[128]	308	raidrec->data_disks.entries = 0;
	309	raidrec->spare_disks.entries = 0;
	310	raidrec->parity_disks.entries = 0;
	311	raidrec->failed_disks.entries = 0;
	312	raidrec->additional_vars.entries = 0;
[1]	313	}
	314	#endif
	315
	316
	317
	318
	319	/**
	320	* Insert modules that Mondo requires.
[1236]	321	* Currently inserts @c msdos, @c vfat, and @c loop for Linux;
[1]	322	* @c msdosfs and @c ext2fs for FreeBSD.
	323	*/
	324	void insmod_crucial_modules(void)
	325	{
	326	#ifdef __FreeBSD__
[128]	327	system("kldstat \| grep msdosfs \|\| kldload msdosfs 2> /dev/null");
	328	system("kldstat \| grep ext2fs \|\| kldload ext2fs 2> /dev/null");
[1]	329	#else
[1236]	330	system("modprobe -a msdos vfat loop &> /dev/null");
[1]	331	#endif
	332	}
	333
	334
	335	/**
[541]	336	* Log a trace message to the trace file.
	337	* @bug This function seems orphaned. Please remove.
	338	*/
	339	void log_trace(char *o)
	340	{
	341	/@ pointers *************************************************** */
	342	FILE *fout;
	343
	344	/@ buffers **************************************************** */
	345	char output[MAX_STR_LEN];
	346
	347	/@ int ***************************************************** */
	348	int i;
	349
	350	/@ end vars ************************************************** */
	351
	352	if (o[0] == '\0') {
	353	return;
	354	}
	355	strcpy(output, o);
	356	i = (int) strlen(output);
	357	if (i <= 0) {
	358	return;
	359	}
	360	if (output[i - 1] < 32) {
	361	output[i - 1] = '\0';
	362	}
	363	if (g_text_mode
	364	/* && !strstr(last_line_of_file(MONDO_LOGFILE),output) */ ) {
	365	printf("%s\n", output);
	366	}
	367
	368	fout = fopen(MONDO_TRACEFILE, "a");
	369	if (fout) {
	370	fprintf(fout, "%s\n", output);
	371	paranoid_fclose(fout);
	372	} else {
	373	log_OS_error("Cannot write to tracefile");
	374	}
	375	}
	376
	377
	378
	379
	380
	381	/**
[1]	382	* Finish configuring the backup information structure. Call this function
	383	* to set the parameters that depend on those that can be given on the command
	384	* line.
	385	*
	386	* @param bkpinfo The backup information structure. Fields modified/used:
	387	* - Used: @c bkpinfo->backup_data
	388	* - Used: @c bkpinfo->backup_media_type
	389	* - Used: @c bkpinfo->cdrw_speed
	390	* - Used: @c bkpinfo->compression_level
	391	* - Used: @c bkpinfo->include_paths
[20]	392	* - Used: @c bkpinfo->prefix
[1]	393	* - Used: @c bkpinfo->isodir
	394	* - Used: @c bkpinfo->manual_cd_tray
	395	* - Used: @c bkpinfo->make_cd_use_lilo
	396	* - Used: @c bkpinfo->media_device
[2380]	397	* - Used: @c bkpinfo->netfs_mount
[1]	398	* - Used: @c bkpinfo->nonbootable_backup
	399	* - Used: @c bkpinfo->scratchdir
	400	* - Used: @c bkpinfo->tmpdir
	401	* - Used: @c bkpinfo->use_lzo
	402	* - Modified: @c bkpinfo->call_before_iso
	403	* - Modified: @c bkpinfo->call_make_iso
	404	* - Modified: @c bkpinfo->optimal_set_size
	405	* - Modified: @c bkpinfo->zip_exe
	406	* - Modified: @c bkpinfo->zip_suffix
	407	*
	408	* @return number of errors, or 0 for success.
	409	* @note Also creates directories that are specified in the @c bkpinfo structure but
	410	* do not exist.
	411	*/
[1645]	412	int post_param_configuration()
[1]	413	{
[2211]	414	char *extra_cdrom_params = NULL;
	415	char *mondo_mkisofs_sz = NULL;
[128]	416	char *command;
	417	char *mtpt;
[2211]	418	char *hostname;
	419	char *ip_address = NULL;
[128]	420	int retval = 0;
	421	char *colon;
	422	char *cdr_exe;
	423	char *tmp;
[163]	424	char call_before_iso_user[MAX_STR_LEN] = "\0";
[2030]	425	/*
	426	long avm = 0;
[128]	427	int rdsiz_MB;
[2030]	428	*/
[128]	429	char *iso_dev;
	430	char *iso_mnt;
	431	char *iso_tmp;
	432	char *iso_path;
[1]	433
[128]	434	assert(bkpinfo != NULL);
	435	malloc_string(command);
	436	malloc_string(mtpt);
	437	malloc_string(hostname);
	438	malloc_string(cdr_exe);
	439	malloc_string(tmp);
	440	malloc_string(iso_dev);
	441	malloc_string(iso_mnt);
	442	malloc_string(iso_tmp);
	443	malloc_string(iso_path);
	444	bkpinfo->optimal_set_size =
[686]	445	(IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type) ? 16 : 16) *
[128]	446	1024;
[1]	447
[128]	448	log_msg(1, "Foo");
	449	if (bkpinfo->backup_media_type == tape) {
	450	log_msg(1, "Bar");
	451	sprintf(tmp, "mt -f %s status", bkpinfo->media_device);
	452	log_msg(1, "tmp = '%s'", tmp);
	453	if (run_program_and_log_output(tmp, 3)) {
	454	fatal_error
	455	("Unable to open tape device. If you haven't specified it with -d, do so. If you already have, check your parameter. I think it's wrong.");
	456	}
[1]	457	}
[128]	458	make_hole_for_dir(bkpinfo->scratchdir);
	459	if (bkpinfo->backup_media_type == iso)
	460	make_hole_for_dir(bkpinfo->isodir);
[1]	461
[128]	462	run_program_and_log_output("uname -a", 5);
[678]	463	run_program_and_log_output("cat /etc/*-release", 5);
[128]	464	run_program_and_log_output("cat /etc/issue", 5);
[1]	465	#ifdef __FreeBSD__
	466	#else
[128]	467	run_program_and_log_output("cat /proc/cpuinfo", 5);
	468	run_program_and_log_output
	469	("rpm -q newt newt-devel slang slang-devel ncurses ncurses-devel gcc",
	470	5);
[1]	471	#endif
[128]	472
	473	if (bkpinfo->use_lzo) {
	474	strcpy(bkpinfo->zip_exe, "lzop");
	475	strcpy(bkpinfo->zip_suffix, "lzo");
[998]	476	} else if (bkpinfo->use_gzip) {
	477	strcpy(bkpinfo->zip_exe, "gzip");
	478	strcpy(bkpinfo->zip_suffix, "gz");
[128]	479	} else if (bkpinfo->compression_level != 0) {
	480	strcpy(bkpinfo->zip_exe, "bzip2");
	481	strcpy(bkpinfo->zip_suffix, "bz2");
	482	} else {
	483	bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
[1]	484	}
	485
	486	// DVD
	487
[128]	488	if (bkpinfo->backup_media_type == dvd) {
	489	if (find_home_of_exe("growisofs")) {
	490	strcpy(cdr_exe, "growisofs");
	491	} // unlikely to be used
	492	else {
	493	fatal_error("Please install growisofs.");
	494	}
	495	if (bkpinfo->nonbootable_backup) {
[2211]	496	mr_asprintf(&mondo_mkisofs_sz, MONDO_GROWISOFS_NONBOOT);
[128]	497	} else if
[1]	498	#ifdef __FreeBSD__
[128]	499	(TRUE)
[1]	500	#else
[128]	501	(bkpinfo->make_cd_use_lilo)
[1]	502	#endif
	503	#ifdef __IA64__
[128]	504	{
[2211]	505	mr_asprintf(&mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_ELILO);
[128]	506	}
[1]	507	#else
	508	{
[2211]	509	mr_asprintf(&mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_LILO);
[1]	510	}
[128]	511	#endif
	512	else
	513	{
[2211]	514	mr_asprintf(&mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_SYSLINUX);
[128]	515	}
	516	if (bkpinfo->manual_cd_tray) {
[2211]	517	paranoid_free(mondo_mkisofs_sz);
[128]	518	fatal_error("Manual CD tray + DVD not supported yet.");
	519	// -m isn't supported by growisofs, BTW...
	520	} else {
	521	sprintf(bkpinfo->call_make_iso,
	522	"%s %s -Z %s . 2>> _ERR_",
	523	mondo_mkisofs_sz,
[2211]	524	"", bkpinfo->media_device);
	525	paranoid_free(mondo_mkisofs_sz);
[128]	526	}
[153]	527	if (getenv ("SUDO_COMMAND")) {
[679]	528	sprintf(command, "strings `which growisofs` \| grep -c SUDO_COMMAND");
	529	if (!strcmp(call_program_and_get_last_line_of_output(command), "1")) {
	530	popup_and_OK("Fatal Error: Can't write DVDs as sudo because growisofs doesn't support this - see the growisofs manpage for details.");
	531	fatal_error("Can't write DVDs as sudo because growisofs doesn't support this - see the growisofs manpage for details.");
	532	}
[153]	533	}
[128]	534	log_msg(2, "call_make_iso (DVD res) is ... %s",
	535	bkpinfo->call_make_iso);
	536	} // end of DVD code
[1]	537
	538	// CD-R or CD-RW
[128]	539	if (bkpinfo->backup_media_type == cdrw
	540	\|\| bkpinfo->backup_media_type == cdr) {
	541	if (!bkpinfo->manual_cd_tray) {
[2211]	542	mr_asprintf(&extra_cdrom_params, "-waiti ");
[128]	543	}
	544	if (bkpinfo->backup_media_type == cdrw) {
[2211]	545	mr_asprintf(&extra_cdrom_params, "blank=fast ");
[128]	546	}
	547	if (find_home_of_exe("cdrecord")) {
	548	strcpy(cdr_exe, "cdrecord");
	549	} else if (find_home_of_exe("dvdrecord")) {
	550	strcpy(cdr_exe, "dvdrecord");
	551	} else {
	552	fatal_error("Please install either cdrecord or dvdrecord.");
	553	}
	554	if (bkpinfo->nonbootable_backup) {
[2211]	555	mr_asprintf(&mondo_mkisofs_sz, MONDO_MKISOFS_NONBOOT);
[128]	556	} else if
[1]	557	#ifdef __FreeBSD__
[128]	558	(TRUE)
[1]	559	#else
[128]	560	(bkpinfo->make_cd_use_lilo)
[1]	561	#endif
	562	#ifdef __IA64__
	563	{
[2211]	564	mr_asprintf(&mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_ELILO);
[1]	565	}
[128]	566	#else
[1]	567	{
[2211]	568	mr_asprintf(&mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_LILO);
[1]	569	}
[128]	570	#endif
	571	else
	572	{
[2211]	573	mr_asprintf(&mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_SYSLINUX);
[128]	574	}
	575	if (bkpinfo->manual_cd_tray) {
[163]	576	if (bkpinfo->call_before_iso[0] == '\0') {
[128]	577	sprintf(bkpinfo->call_before_iso,
[1666]	578	"%s -o %s/"MONDO_TMPISOS" . 2>> _ERR_",
[163]	579	mondo_mkisofs_sz, bkpinfo->tmpdir);
	580	} else {
	581	strncpy(call_before_iso_user, bkpinfo->call_before_iso, MAX_STR_LEN);
	582	sprintf (bkpinfo->call_before_iso,
[1666]	583	"( %s -o %s/"MONDO_TMPISOS" . 2>> _ERR_ ; %s )",
[163]	584	mondo_mkisofs_sz, bkpinfo->tmpdir, call_before_iso_user);
	585	}
	586	log_it("bkpinfo->call_before_iso = %s", bkpinfo->call_before_iso);
[128]	587	sprintf(bkpinfo->call_make_iso,
[1666]	588	"%s %s -v %s fs=4m dev=%s speed=%d %s/"MONDO_TMPISOS,
[128]	589	cdr_exe, (bkpinfo->please_dont_eject) ? " " : "-eject",
	590	extra_cdrom_params, bkpinfo->media_device,
	591	bkpinfo->cdrw_speed, bkpinfo->tmpdir);
	592	} else {
	593	sprintf(bkpinfo->call_make_iso,
	594	"%s . 2>> _ERR_ \| %s %s %s fs=4m dev=%s speed=%d -",
	595	mondo_mkisofs_sz, cdr_exe,
	596	(bkpinfo->please_dont_eject) ? " " : "-eject",
	597	extra_cdrom_params, bkpinfo->media_device,
	598	bkpinfo->cdrw_speed);
	599	}
[2211]	600	paranoid_free(mondo_mkisofs_sz);
	601	paranoid_free(extra_cdrom_params);
[128]	602	} // end of CD code
[1]	603
[128]	604	/*
	605	if (bkpinfo->backup_data && bkpinfo->backup_media_type == tape)
	606	{
	607	sprintf (tmp,
	608	"dd if=/dev/zero of=%s bs=%ld count=32 2> /dev/null",
	609	bkpinfo->media_device, bkpinfo->internal_tape_block_size);
	610	if (system(tmp))
	611	{
	612	retval++;
	613	fprintf (stderr,
	614	"Cannot write to tape device. Is the tape set read-only?\n");
	615	}
	616	} // end of tape code
	617	*/
[1]	618
	619
[128]	620	if (bkpinfo->backup_media_type == iso) {
	621
[1]	622	/* Patch by Conor Daly <conor.daly@met.ie>
	623	* 23-june-2004
	624	* Break up isodir into iso_mnt and iso_path
	625	* These will be used along with iso-dev at restore time
	626	* to locate the ISOs where ever they're mounted
	627	*/
	628
[128]	629	log_it("isodir = %s", bkpinfo->isodir);
[165]	630	sprintf(command, "df -P %s \| tail -n1 \| cut -d' ' -f1",
[128]	631	bkpinfo->isodir);
	632	log_it("command = %s", command);
	633	log_it("res of it = %s",
	634	call_program_and_get_last_line_of_output(command));
	635	sprintf(iso_dev, "%s",
	636	call_program_and_get_last_line_of_output(command));
	637	sprintf(tmp, "%s/ISO-DEV", bkpinfo->tmpdir);
	638	write_one_liner_data_file(tmp,
	639	call_program_and_get_last_line_of_output
	640	(command));
[1]	641
[128]	642	sprintf(command, "mount \| grep -w %s \| tail -n1 \| cut -d' ' -f3",
	643	iso_dev);
	644	log_it("command = %s", command);
	645	log_it("res of it = %s",
	646	call_program_and_get_last_line_of_output(command));
	647	sprintf(iso_mnt, "%s",
	648	call_program_and_get_last_line_of_output(command));
	649	sprintf(tmp, "%s/ISO-MNT", bkpinfo->tmpdir);
	650	write_one_liner_data_file(tmp,
	651	call_program_and_get_last_line_of_output
	652	(command));
	653	log_it("isomnt: %s, %d", iso_mnt, strlen(iso_mnt));
	654	sprintf(iso_tmp, "%s", bkpinfo->isodir);
	655	if (strlen(iso_tmp) < strlen(iso_mnt)) {
	656	iso_path[0] = '\0';
	657	} else {
	658	sprintf(iso_path, "%s", iso_tmp + strlen(iso_mnt));
	659	}
	660	sprintf(tmp, "%s/ISODIR", bkpinfo->tmpdir);
	661	write_one_liner_data_file(tmp, iso_path);
	662	log_it("isodir: %s", iso_path);
[148]	663	sprintf(tmp, "%s/ISO-PREFIX", bkpinfo->tmpdir);
	664	write_one_liner_data_file(tmp, bkpinfo->prefix);
	665	log_it("iso-prefix: %s", bkpinfo->prefix);
[1]	666
	667	/* End patch */
[128]	668	} // end of iso code
[1]	669
[2380]	670	if (bkpinfo->backup_media_type == netfs) {
	671	strcpy(hostname, bkpinfo->netfs_mount);
[128]	672	colon = strchr(hostname, ':');
	673	if (!colon) {
[2380]	674	log_it("netfs mount doesn't have a colon in it");
[128]	675	retval++;
	676	} else {
	677	struct hostent *hent;
[1]	678
[128]	679	*colon = '\0';
	680	hent = gethostbyname(hostname);
	681	if (!hent) {
[2380]	682	log_it("Can't resolve Network mount (%s): %s", hostname,
[128]	683	hstrerror(h_errno));
	684	retval++;
	685	} else {
[2290]	686	mr_asprintf(&ip_address, "%s", inet_ntoa((struct in_addr) ((struct in_addr ) hent->h_addr)));
[2380]	687	mr_strcat(ip_address, strchr(bkpinfo->netfs_mount, ':'));
	688	strcpy(bkpinfo->netfs_mount, ip_address);
[2211]	689	paranoid_free(ip_address);
[128]	690	}
	691	}
[2380]	692	store_netfs_config();
[128]	693	}
[1]	694
[128]	695	log_it("Finished processing incoming params");
	696	if (retval) {
	697	fprintf(stderr, "Type 'man mondoarchive' for help.\n");
	698	}
	699	if (strlen(bkpinfo->tmpdir) < 2 \|\| strlen(bkpinfo->scratchdir) < 2) {
	700	log_it("tmpdir or scratchdir are blank/missing");
	701	retval++;
	702	}
	703	if (bkpinfo->include_paths[0] == '\0') {
	704	// fatal_error ("Why no backup path?");
	705	strcpy(bkpinfo->include_paths, "/");
	706	}
	707	chmod(bkpinfo->scratchdir, 0700);
	708	g_backup_media_type = bkpinfo->backup_media_type;
	709	paranoid_free(mtpt);
	710	paranoid_free(command);
	711	paranoid_free(hostname);
	712	paranoid_free(cdr_exe);
	713	paranoid_free(tmp);
	714	paranoid_free(iso_dev);
	715	paranoid_free(iso_mnt);
	716	paranoid_free(iso_tmp);
	717	paranoid_free(iso_path);
	718	return (retval);
[1]	719	}
	720
	721
	722
	723	/**
	724	* Do some miscellaneous setup tasks to be performed before filling @c bkpinfo.
	725	* Seeds the random-number generator, loads important modules, checks the sanity
	726	* of the user's Linux distribution, and deletes logfile.
	727	* @param bkpinfo The backup information structure. Will be initialized.
	728	* @return number of errors (0 for success)
	729	*/
[1645]	730	int pre_param_configuration()
[1]	731	{
[128]	732	int res = 0;
[1652]	733	char *tmp = NULL;
[1]	734
[128]	735	make_hole_for_dir(MNT_CDROM);
	736	assert(bkpinfo != NULL);
	737	srandom((unsigned long) (time(NULL)));
	738	insmod_crucial_modules();
	739	if (bkpinfo->disaster_recovery) {
	740	if (!does_nonMS_partition_exist()) {
	741	fatal_error
	742	("I am in disaster recovery mode\nPlease don't run mondoarchive.");
	743	}
	744	}
[1]	745
[128]	746	unlink(MONDO_TRACEFILE);
[2211]	747	mr_asprintf(&tmp,"rm -Rf %s/changed.files*",MONDO_CACHE);
[1652]	748	run_program_and_log_output(tmp, FALSE);
	749	paranoid_free(tmp);
[128]	750	if (find_and_store_mondoarchives_home(g_mondo_home)) {
	751	fprintf(stderr,
	752	"Cannot find Mondo's homedir. I think you have >1 'mondo' directory on your hard disk. Please delete the superfluous 'mondo' directories and try again\n");
	753	res++;
	754	return (res);
	755	}
	756	res += some_basic_system_sanity_checks();
	757	if (res) {
	758	log_it("Your distribution did not pass Mondo's sanity test.");
	759	}
	760	g_current_media_number = 1;
[2380]	761	bkpinfo->postnuke_tarball[0] = bkpinfo->netfs_mount[0] = '\0';
[128]	762	return (res);
[1]	763	}
	764
[1655]	765	void setup_tmpdir(char *path) {
[1967]	766
[1653]	767	char *tmp = NULL;
[1654]	768	char *p = NULL;
[1]	769
[1999]	770	if ((bkpinfo->tmpdir != NULL) && (strstr(bkpinfo->tmpdir,"mondo.tmp.") != NULL)) {
[1655]	771	/* purging a potential old tmpdir */
[2348]	772	log_it("Purging old tmpdir %s", bkpinfo->tmpdir);
[2211]	773	mr_asprintf(&tmp,"rm -Rf %s",bkpinfo->tmpdir);
[2348]	774	(void)system(tmp);
[1655]	775	paranoid_free(tmp);
	776	}
[1967]	777
[2443]	778	/* Always take in account env first */
	779	if (getenv("TMPDIR")) {
[2211]	780	mr_asprintf(&tmp, "%s/mondo.tmp.XXXXXX", getenv("TMPDIR"));
[1653]	781	} else if (getenv("TMP")) {
[2211]	782	mr_asprintf(&tmp, "%s/mondo.tmp.XXXXXX", getenv("TMP"));
[2443]	783	} else if (path != NULL) {
	784	mr_asprintf(&tmp, "%s/mondo.tmp.XXXXXX", path);
[1653]	785	} else {
[2211]	786	mr_asprintf(&tmp, "/tmp/mondo.tmp.XXXXXX");
[1653]	787	}
[1654]	788	p = mkdtemp(tmp);
	789	if (p == NULL) {
	790	log_it("Failed to create global tmp directory %s for Mondo.",tmp);
[1653]	791	finish(-1);
	792	}
[1654]	793	strcpy(bkpinfo->tmpdir,p);
	794	paranoid_free(tmp);
[1653]	795	}
[1]	796
	797
	798	/**
	799	* Reset all fields of the backup information structure to a sensible default.
	800	* @param bkpinfo The @c bkpinfo to reset.
	801	*/
[1645]	802	void reset_bkpinfo()
[1]	803	{
[128]	804	int i;
[1]	805
[128]	806	log_msg(1, "Hi");
	807	assert(bkpinfo != NULL);
	808	memset((void *) bkpinfo, 0, sizeof(struct s_bkpinfo));
[1653]	809
[128]	810	bkpinfo->media_device[0] = '\0';
	811	for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
	812	bkpinfo->media_size[i] = -1;
	813	}
	814	bkpinfo->boot_loader = '\0';
	815	bkpinfo->boot_device[0] = '\0';
	816	bkpinfo->zip_exe[0] = '\0';
	817	bkpinfo->zip_suffix[0] = '\0';
[1966]	818	bkpinfo->image_devs[0] = '\0';
	819	bkpinfo->compression_level = 3;
[128]	820	bkpinfo->use_lzo = FALSE;
[998]	821	bkpinfo->use_gzip = FALSE;
[128]	822	bkpinfo->do_not_compress_these[0] = '\0';
	823	bkpinfo->verify_data = FALSE;
	824	bkpinfo->backup_data = FALSE;
	825	bkpinfo->restore_data = FALSE;
[1966]	826	bkpinfo->use_star = FALSE;
	827	bkpinfo->internal_tape_block_size = DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
[128]	828	bkpinfo->disaster_recovery =
	829	(am_I_in_disaster_recovery_mode()? TRUE : FALSE);
	830	if (bkpinfo->disaster_recovery) {
	831	strcpy(bkpinfo->isodir, "/");
	832	} else {
[2059]	833	strcpy(bkpinfo->isodir, MONDO_CACHE);
[128]	834	}
[148]	835	strcpy(bkpinfo->prefix, STD_PREFIX);
[1966]	836	sensibly_set_tmpdir_and_scratchdir();
[1]	837
[128]	838	bkpinfo->optimal_set_size = 0;
	839	strcpy(bkpinfo->include_paths, "/");
[1966]	840	bkpinfo->make_filelist = TRUE; // unless -J supplied to mondoarchive
	841	bkpinfo->include_paths[0] = '\0';
[128]	842	bkpinfo->exclude_paths[0] = '\0';
[2424]	843	bkpinfo->exclude_devs = NULL;
[1966]	844	bkpinfo->restore_path[0] = '\0';
[128]	845	bkpinfo->call_before_iso[0] = '\0';
	846	bkpinfo->call_make_iso[0] = '\0';
	847	bkpinfo->call_burn_iso[0] = '\0';
	848	bkpinfo->call_after_iso[0] = '\0';
	849	bkpinfo->kernel_path[0] = '\0';
[2380]	850	bkpinfo->netfs_mount[0] = '\0';
	851	bkpinfo->netfs_proto = NULL;
	852	bkpinfo->netfs_user = NULL;
	853	bkpinfo->netfs_remote_dir[0] = '\0';
[1966]	854	bkpinfo->postnuke_tarball[0] = '\0';
[128]	855	bkpinfo->wipe_media_first = FALSE;
[1966]	856	bkpinfo->differential = 0;
	857	bkpinfo->please_dont_eject = FALSE;
[128]	858	bkpinfo->cdrw_speed = 0;
[1966]	859	bkpinfo->manual_cd_tray = FALSE;
	860	bkpinfo->nonbootable_backup = FALSE;
	861	bkpinfo->make_cd_use_lilo = FALSE;
	862	bkpinfo->use_obdr = FALSE;
[1967]	863	bkpinfo->restore_mode = interactive;
[1]	864	}
	865
	866
	867
	868
	869	/**
	870	* Get the remaining free space (in MB) on @p partition.
	871	* @param partition The partition to check free space on (either a device or a mountpoint).
	872	* @return The free space on @p partition, in MB.
	873	*/
[128]	874	long free_space_on_given_partition(char *partition)
[1]	875	{
[128]	876	char command[MAX_STR_LEN], out_sz[MAX_STR_LEN];
	877	long res;
[1]	878
[128]	879	assert_string_is_neither_NULL_nor_zerolength(partition);
[1]	880
[1744]	881	sprintf(command, "df -m -P %s 1> /dev/null 2> /dev/null", partition);
[128]	882	if (system(command)) {
	883	return (-1);
	884	} // partition does not exist
[305]	885	sprintf(command, "df -m -P %s \| tail -n1 \| tr -s ' ' '\t' \| cut -f4",
[128]	886	partition);
	887	strcpy(out_sz, call_program_and_get_last_line_of_output(command));
	888	if (strlen(out_sz) == 0) {
	889	return (-1);
	890	} // error within df, probably
	891	res = atol(out_sz);
	892	return (res);
[1]	893	}
	894
	895
	896
	897	/**
	898	* Check the user's system for sanity. Checks performed:
	899	* - make sure user has enough RAM (32mb required, 64mb recommended)
	900	* - make sure user has enough free space in @c /
	901	* - check kernel for ramdisk support
	902	* - make sure afio, cdrecord, mkisofs, bzip2, awk, md5sum, strings, mindi, and buffer exist
	903	* - make sure CD-ROM is unmounted
	904	* - make sure user's mountlist is OK by running <tt>mindi --makemountlist</tt>
	905	*
	906	* @return number of problems with the user's setup (0 for success)
	907	*/
[128]	908	int some_basic_system_sanity_checks()
[1]	909	{
	910
[128]	911	/@ buffers *********** */
	912	char tmp[MAX_STR_LEN];
	913	// char command[MAX_STR_LEN];
[1]	914
[128]	915	/@ int's ************** */
	916	int retval = 0;
[1]	917
[128]	918	mvaddstr_and_log_it(g_currentY, 0,
	919	"Checking sanity of your Linux distribution");
[1]	920	#ifndef __FreeBSD__
[1737]	921	if (system("which mkfs.vfat 2> /dev/null 1> /dev/null")
	922	&& !system("which mkfs.msdos 2> /dev/null 1> /dev/null")) {
[128]	923	log_it
	924	("OK, you've got mkfs.msdos but not mkfs.vfat; time for the fairy to wave her magic wand...");
	925	run_program_and_log_output
	926	("ln -sf `which mkfs.msdos` /sbin/mkfs.vfat", FALSE);
	927	}
	928	strcpy(tmp,
	929	call_program_and_get_last_line_of_output
	930	("free \| grep Mem \| head -n1 \| tr -s ' ' '\t' \| cut -f2"));
	931	if (atol(tmp) < 35000) {
	932	retval++;
[541]	933	log_to_screen("You must have at least 32MB of RAM to use Mondo.");
[128]	934	}
	935	if (atol(tmp) < 66000) {
	936	log_to_screen
[541]	937	("WARNING! You have very little RAM. Please upgrade to 64MB or more.");
[128]	938	}
[1]	939	#endif
	940
[128]	941	if (system("which " MKE2FS_OR_NEWFS " > /dev/null 2> /dev/null")) {
	942	retval++;
	943	log_to_screen
	944	("Unable to find " MKE2FS_OR_NEWFS " in system path.");
	945	fatal_error
	946	("Please use \"su -\", not \"su\" to become root. OK? ...and please don't e-mail the mailing list or me about this. Just read the message. :)");
	947	}
[1]	948	#ifndef __FreeBSD__
[128]	949	if (run_program_and_log_output
[273]	950	("grep ramdisk /proc/devices", FALSE)) {
[2194]	951	/* Some SuSE have ramdisk as modules, so insert it first, then test again */
[2195]	952	run_program_and_log_output("modprobe brd 2> /dev/null > /dev/null",FALSE);
[2194]	953	if (run_program_and_log_output
	954	("grep ramdisk /proc/devices", FALSE)) {
	955	if (!ask_me_yes_or_no
	956	("Your kernel has no ramdisk support. That's mind-numbingly stupid but I'll allow it if you're planning to use a failsafe kernel. Are you?"))
	957	{
	958	// retval++;
	959	log_to_screen
	960	("It looks as if your kernel lacks ramdisk and initrd support.");
	961	log_to_screen
	962	("I'll allow you to proceed but FYI, if I'm right, your kernel is broken.");
	963	}
[128]	964	}
	965	}
[1]	966	#endif
[128]	967	retval += whine_if_not_found(MKE2FS_OR_NEWFS);
	968	retval += whine_if_not_found("mkisofs");
	969	if (system("which dvdrecord > /dev/null 2> /dev/null")) {
	970	retval += whine_if_not_found("cdrecord");
	971	}
	972	retval += whine_if_not_found("bzip2");
[998]	973	retval += whine_if_not_found("gzip");
[128]	974	retval += whine_if_not_found("awk");
	975	retval += whine_if_not_found("md5sum");
	976	retval += whine_if_not_found("strings");
	977	retval += whine_if_not_found("mindi");
	978	retval += whine_if_not_found("buffer");
[1]	979
[128]	980	// abort if Windows partition but no ms-sys and parted
[1855]	981	if (!run_program_and_log_output("mount \| grep -Ew 'vfat\|fat\|dos' \| grep -vE \"/dev/fd\|nexdisk\"", 0)) {
[541]	982	log_to_screen("I think you have a Windows 9x partition.");
[128]	983	retval += whine_if_not_found("parted");
[1]	984	}
	985
[128]	986	if (!find_home_of_exe("cmp")) {
	987	if (!find_home_of_exe("true")) {
	988	whine_if_not_found("cmp");
	989	} else {
	990	log_to_screen
[541]	991	("Your system lacks the 'cmp' binary. I'll create a dummy cmp for you.");
[128]	992	if (run_program_and_log_output
	993	("cp -f `which true` /usr/bin/cmp", 0)) {
	994	fatal_error("Failed to create dummy 'cmp' file.");
	995	}
	996	}
[1]	997	}
[128]	998	run_program_and_log_output
	999	("umount `mount \| grep cdr \| cut -d' ' -f3 \| tr '\n' ' '`", 5);
	1000	strcpy(tmp,
	1001	call_program_and_get_last_line_of_output
	1002	("mount \| grep -E \"cdr(om\|w)\""));
	1003	if (strcmp("", tmp)) {
	1004	if (strstr(tmp, "autofs")) {
	1005	log_to_screen
[541]	1006	("Your CD-ROM is mounted via autofs. I therefore cannot tell");
[128]	1007	log_to_screen
[541]	1008	("if a CD actually is inserted. If a CD is inserted, please");
	1009	log_to_screen("eject it. Thank you.");
[128]	1010	log_it
	1011	("Ignoring autofs CD-ROM 'mount' since we hope nothing's in it.");
	1012	} else
	1013	if (run_program_and_log_output("uname -a \| grep Knoppix", 5)) {
	1014	retval++;
	1015	fatal_error
	1016	("Your CD-ROM drive is mounted. Please unmount it.");
	1017	}
	1018	}
[1]	1019
[128]	1020	run_program_and_log_output("cat /etc/fstab", 5);
[1]	1021	#ifdef __FreeBSD__
[128]	1022	run_program_and_log_output("vinum printconfig", 5);
[1]	1023	#else
[128]	1024	run_program_and_log_output("cat /etc/raidtab", 5);
[1]	1025	#endif
	1026
[128]	1027	if (run_program_and_log_output("mindi -V", 1)) {
[541]	1028	log_to_screen("Could not ascertain mindi's version number.");
[128]	1029	log_to_screen
[541]	1030	("You have not installed Mondo and/or Mindi properly.");
	1031	log_to_screen("Please uninstall and reinstall them both.");
[128]	1032	fatal_error("Please reinstall Mondo and Mindi.");
	1033	}
[1644]	1034	sprintf(tmp, "mindi --makemountlist %s/mountlist.txt.test", bkpinfo->tmpdir);
	1035	if (run_program_and_log_output(tmp, 5)) {
	1036	sprintf(tmp, "mindi --makemountlist %s/mountlist.txt.test failed for some reason.", bkpinfo->tmpdir);
	1037	log_to_screen(tmp);
[128]	1038	log_to_screen
[541]	1039	("Please run that command by hand and examine /var/log/mindi.log");
[128]	1040	log_to_screen
[541]	1041	("for more information. Perhaps your /etc/fstab file is insane.");
[128]	1042	log_to_screen
[541]	1043	("Perhaps Mindi's MakeMountlist() subroutine has a bug. We'll see.");
[128]	1044	retval++;
	1045	}
[1]	1046
[196]	1047	if (!run_program_and_log_output("parted2fdisk -l \| grep -i raid", 1)
[128]	1048	&& !does_file_exist("/etc/raidtab")) {
	1049	log_to_screen
[541]	1050	("You have RAID partitions but no /etc/raidtab - creating one from /proc/mdstat");
[558]	1051	create_raidtab_from_mdstat("/etc/raidtab");
[128]	1052	}
	1053
	1054	if (retval) {
[541]	1055	mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
[128]	1056	} else {
[541]	1057	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
[128]	1058	}
	1059	return (retval);
[1]	1060	}
	1061
	1062	/**
	1063	* Retrieve the line containing @p label from the config file.
	1064	* @param config_file The file to read from, usually @c /tmp/mondo-restore.cfg.
	1065	* @param label What to read from the file.
	1066	* @param value Where to put it.
	1067	* @return 0 for success, 1 for failure.
	1068	*/
[128]	1069	int read_cfg_var(char config_file, char label, char *value)
[1]	1070	{
[128]	1071	/@ buffer ***************************************************** */
	1072	char command[MAX_STR_LEN * 2];
	1073	char tmp[MAX_STR_LEN];
[1]	1074
[128]	1075	/@ end vars ************************************************** */
[1]	1076
[128]	1077	assert_string_is_neither_NULL_nor_zerolength(config_file);
	1078	assert_string_is_neither_NULL_nor_zerolength(label);
	1079	if (!does_file_exist(config_file)) {
	1080	sprintf(tmp, "(read_cfg_var) Cannot find %s config file",
	1081	config_file);
	1082	log_to_screen(tmp);
	1083	value[0] = '\0';
	1084	return (1);
[1279]	1085	} else if ((value != NULL) && (strstr(value, "/dev/") && strstr(value, "t0") && !strcmp(label, "media-dev"))) {
	1086	log_msg(2, "FYI, I can't read new value for %s - already got %s", label, value);
[128]	1087	return (0);
	1088	} else {
[148]	1089	sprintf(command, "grep '%s .*' %s\| cut -d' ' -f2,3,4,5",
	1090	label, config_file);
[128]	1091	strcpy(value, call_program_and_get_last_line_of_output(command));
	1092	if (strlen(value) == 0) {
	1093	return (1);
	1094	} else {
	1095	return (0);
	1096	}
[1]	1097	}
	1098	}
	1099
	1100
	1101
	1102	/**
	1103	* Remount @c supermount if it was unmounted earlier.
	1104	*/
	1105	void remount_supermounts_if_necessary()
	1106	{
[128]	1107	if (g_remount_cdrom_at_end) {
	1108	run_program_and_log_output("mount " MNT_CDROM, FALSE);
	1109	}
	1110	if (g_remount_floppy_at_end) {
	1111	run_program_and_log_output("mount " MNT_FLOPPY, FALSE);
	1112	}
[1]	1113	}
	1114
	1115	/**
	1116	* Unmount @c supermount if it's mounted.
	1117	*/
	1118	void unmount_supermounts_if_necessary()
	1119	{
[128]	1120	if (run_program_and_log_output
	1121	("mount \| grep cdrom \| grep super", FALSE) == 0) {
	1122	g_remount_cdrom_at_end = TRUE;
	1123	run_program_and_log_output("umount " MNT_CDROM, FALSE);
	1124	}
	1125	if (run_program_and_log_output
	1126	("mount \| grep floppy \| grep super", FALSE) == 0) {
	1127	g_remount_floppy_at_end = TRUE;
	1128	run_program_and_log_output("umount " MNT_FLOPPY, FALSE);
	1129	}
[1]	1130	}
	1131
	1132	/**
	1133	* Whether we had to stop autofs (if so, restart it at end).
	1134	*/
[128]	1135	bool g_autofs_stopped = FALSE;
[1]	1136
	1137	/**
	1138	* Path to the autofs initscript ("" if none exists).
	1139	*/
	1140	char g_autofs_exe[MAX_STR_LEN];
	1141
	1142	/**
	1143	* Autofs initscript in Xandros Linux distribution.
	1144	*/
	1145	#define XANDROS_AUTOFS_FNAME "/etc/init.d/xandros-autofs"
	1146
	1147	/**
	1148	* Autofs initscript in most Linux distributions.
	1149	*/
	1150	#define STOCK_AUTOFS_FNAME "/etc/rc.d/init.d/autofs"
	1151
	1152	/**
	1153	* If autofs is mounted, stop it (restart at end).
	1154	*/
	1155	void stop_autofs_if_necessary()
	1156	{
[128]	1157	char tmp[MAX_STR_LEN];
	1158
	1159	g_autofs_exe[0] = '\0';
	1160	if (does_file_exist(XANDROS_AUTOFS_FNAME)) {
	1161	strcpy(g_autofs_exe, XANDROS_AUTOFS_FNAME);
	1162	} else if (does_file_exist(STOCK_AUTOFS_FNAME)) {
	1163	strcpy(g_autofs_exe, STOCK_AUTOFS_FNAME);
	1164	}
	1165
	1166	if (!g_autofs_exe[0]) {
	1167	log_msg(3, "No autofs detected.");
	1168	} else {
	1169	log_msg(3, "%s --- autofs detected", g_autofs_exe);
[1]	1170	// FIXME -- only disable it if it's running --- sprintf(tmp, "%s status", autofs_exe);
[128]	1171	sprintf(tmp, "%s stop", g_autofs_exe);
	1172	if (run_program_and_log_output(tmp, 2)) {
	1173	log_it("Failed to stop autofs - I assume it wasn't running");
	1174	} else {
	1175	g_autofs_stopped = TRUE;
	1176	log_it("Stopped autofs OK");
	1177	}
	1178	}
[1]	1179	}
	1180
	1181	/**
	1182	* If autofs was stopped earlier, restart it.
	1183	*/
	1184	void restart_autofs_if_necessary()
	1185	{
[128]	1186	char tmp[MAX_STR_LEN];
	1187
	1188	if (!g_autofs_stopped \|\| !g_autofs_exe[0]) {
	1189	log_msg(3, "No autofs detected.");
	1190	return;
	1191	}
	1192	sprintf(tmp, "%s start", g_autofs_exe);
	1193	if (run_program_and_log_output(tmp, 2)) {
	1194	log_it("Failed to start autofs");
	1195	} else {
	1196	g_autofs_stopped = FALSE;
	1197	log_it("Started autofs OK");
	1198	}
[1]	1199	}
	1200
	1201
	1202	/**
	1203	* If this is a distribution like Gentoo that doesn't keep /boot mounted, mount it.
	1204	*/
	1205	void mount_boot_if_necessary()
	1206	{
[128]	1207	char tmp[MAX_STR_LEN];
	1208	char command[MAX_STR_LEN];
[1]	1209
[128]	1210	log_msg(1, "Started sub");
	1211	log_msg(4, "About to set g_boot_mountpt[0] to '\\0'");
	1212	g_boot_mountpt[0] = '\0';
	1213	log_msg(4, "Done. Great. Seeting command to something");
	1214	strcpy(command,
[911]	1215	"grep -v \":\" /etc/fstab \| grep -vE '^#.*$' \| grep -E \"[ ]/boot[ ]\" \| tr -s ' ' '\t' \| cut -f1 \| head -n1");
[128]	1216	log_msg(4, "Cool. Command = '%s'", command);
	1217	strcpy(tmp, call_program_and_get_last_line_of_output(command));
	1218	log_msg(4, "tmp = '%s'", tmp);
	1219	if (tmp[0]) {
	1220	log_it("/boot is at %s according to /etc/fstab", tmp);
[1791]	1221	strcpy(command, "mount \| grep -Ew '/boot'");
	1222	strcpy(tmp, call_program_and_get_last_line_of_output(command));
[1818]	1223	if (!strcmp(tmp,"")) {
[1791]	1224	if ((strstr(tmp, "LABEL=") \|\| strstr(tmp,"UUID="))) {
	1225	if (!run_program_and_log_output("mount /boot", 5)) {
	1226	strcpy(g_boot_mountpt, "/boot");
	1227	log_msg(1, "Mounted /boot");
	1228	} else {
	1229	log_it("...ignored cos it's a label or uuid :-)");
	1230	}
[128]	1231	} else {
[1791]	1232	sprintf(command, "mount \| grep -E '^%s'", tmp);
	1233	log_msg(3, "command = %s", command);
	1234	if (run_program_and_log_output(command, 5)) {
	1235	strcpy(g_boot_mountpt, tmp);
	1236	sprintf(tmp,
	1237	"%s (your /boot partition) is not mounted. I'll mount it before backing up",
	1238	g_boot_mountpt);
	1239	log_it(tmp);
	1240	sprintf(tmp, "mount %s", g_boot_mountpt);
	1241	if (run_program_and_log_output(tmp, 5)) {
	1242	g_boot_mountpt[0] = '\0';
	1243	log_msg(1, "Plan B");
	1244	if (!run_program_and_log_output("mount /boot", 5)) {
	1245	strcpy(g_boot_mountpt, "/boot");
	1246	log_msg(1, "Plan B worked");
	1247	} else {
	1248	log_msg(1,
[128]	1249	"Plan B failed. Unable to mount /boot for backup purposes. This probably means /boot is mounted already, or doesn't have its own partition.");
[1791]	1250	}
[128]	1251	}
	1252	}
	1253	}
	1254	}
[1]	1255	}
[128]	1256	log_msg(1, "Ended sub");
[1]	1257	}
	1258
	1259
	1260	/**
	1261	* If we mounted /boot earlier, unmount it.
	1262	*/
	1263	void unmount_boot_if_necessary()
	1264	{
[128]	1265	char tmp[MAX_STR_LEN];
[1]	1266
[128]	1267	log_msg(3, "starting");
	1268	if (g_boot_mountpt[0]) {
	1269	sprintf(tmp, "umount %s", g_boot_mountpt);
	1270	if (run_program_and_log_output(tmp, 5)) {
	1271	log_it("WARNING - unable to unmount /boot");
	1272	}
	1273	}
	1274	log_msg(3, "leaving");
[1]	1275	}
	1276
	1277
	1278
	1279	/**
	1280	* Write a line to a configuration file. Writes a line of the form,
	1281	* @c label @c value.
	1282	* @param config_file The file to write to. Usually @c mondo-restore.cfg.
	1283	* @param label What to call this bit of data you're writing.
	1284	* @param value The bit of data you're writing.
	1285	* @return 0 for success, 1 for failure.
	1286	*/
[128]	1287	int write_cfg_var(char config_file, char label, char *value)
[1]	1288	{
[128]	1289	/@ buffers **************************************************** */
	1290	char command[MAX_STR_LEN * 2];
	1291	char tempfile[MAX_STR_LEN];
	1292	char tmp[MAX_STR_LEN];
[1]	1293
	1294
[128]	1295	/@ end vars ************************************************** */
	1296	assert_string_is_neither_NULL_nor_zerolength(config_file);
	1297	assert_string_is_neither_NULL_nor_zerolength(label);
	1298	assert(value != NULL);
	1299	if (!does_file_exist(config_file)) {
	1300	sprintf(tmp, "(write_cfg_file) Cannot find %s config file",
	1301	config_file);
	1302	log_to_screen(tmp);
	1303	return (1);
	1304	}
[1644]	1305	sprintf(tempfile, "%s/mojo-jojo.blah", bkpinfo->tmpdir);
[128]	1306	if (does_file_exist(config_file)) {
[911]	1307	sprintf(command, "grep -vE '^%s .*$' %s > %s",
[148]	1308	label, config_file, tempfile);
[128]	1309	paranoid_system(command);
	1310	}
	1311	sprintf(command, "echo \"%s %s\" >> %s", label, value, tempfile);
	1312	paranoid_system(command);
	1313	sprintf(command, "mv -f %s %s", tempfile, config_file);
	1314	paranoid_system(command);
	1315	unlink(tempfile);
	1316	return (0);
[1]	1317	}
	1318
[541]	1319
[1]	1320	/**
[541]	1321	* The standard log_debug_msg() (log_msg() also due to a macro). Writes some describing
	1322	* information to the logfile.
	1323	*/
	1324	void standard_log_debug_msg(int debug_level, const char *szFile,
	1325	const char *szFunction, int nLine,
	1326	const char *fmt, ...)
	1327	{
	1328	va_list args;
	1329	int i;
	1330	static int depth = 0;
	1331	FILE *fout;
	1332
	1333	if (depth > 5) {
	1334	depth--;
	1335	return;
	1336	}
	1337	depth++;
	1338
	1339	if (debug_level <= g_loglevel) {
	1340	if (!(fout = fopen(MONDO_LOGFILE, "a"))) {
	1341	return;
[1946]	1342	} // fatal_error("Failed to openout to logfile - sheesh..."); }
[541]	1343
	1344	// add tabs to distinguish log levels
	1345	if (debug_level > 0) {
	1346	for (i = 1; i < debug_level; i++)
	1347	fprintf(fout, "\t");
	1348	if (getpid() == g_main_pid)
[2205]	1349	fprintf(fout, "[Main] %s->%s#%d: ", szFile, szFunction, nLine);
[541]	1350	else if (getpid() == g_buffer_pid && g_buffer_pid > 0)
[2205]	1351	fprintf(fout, "[Buff] %s->%s#%d: ", szFile, szFunction, nLine);
[541]	1352	else
[2205]	1353	fprintf(fout, "[TH=%d] %s->%s#%d: ", getpid(), szFile, szFunction, nLine);
[541]	1354	}
[2230]	1355	va_start(args, fmt);
[541]	1356	vfprintf(fout, fmt, args);
[2230]	1357	va_end(args);
[541]	1358
	1359	// do not slow down the progran if standard debug level
	1360	// must be enabled: if no flush, the log won't be up-to-date if there
	1361	// is a segfault
	1362	//if (g_dwDebugLevel != 1)
	1363
	1364	fprintf(fout, "\n");
	1365	paranoid_fclose(fout);
	1366	}
	1367	depth--;
	1368	}
	1369
	1370	/**
	1371	* Function pointer to the @c log_debug_msg function to use. Points to standard_log_debug_msg() by default.
	1372	*/
	1373	void (log_debug_msg) (int, const char , const char , int, const char ,
	1374	...) = standard_log_debug_msg;
	1375
	1376
	1377	/**
[1]	1378	* If @p y, malloc @p x, else free @p x.
	1379	* @bug This function seems orphaned. Please remove.
	1380	*/
	1381	#define do_alloc_or_free_depending(x,y) { if(y) {x=malloc(MAX_STR_LEN);} else {paranoid_free(x);} }
	1382
	1383	/**
	1384	* Allocate or free important globals, depending on @p mal.
	1385	* @param mal If TRUE, malloc; if FALSE, free.
	1386	*/
	1387	void do_libmondo_global_strings_thing(int mal)
	1388	{
[128]	1389	if (mal) {
	1390	malloc_string(g_boot_mountpt);
	1391	malloc_string(g_mondo_home);
[2030]	1392	/*
[128]	1393	malloc_string(g_tmpfs_mountpt);
[2030]	1394	*/
[128]	1395	malloc_string(g_serial_string);
	1396	malloc_string(g_magicdev_command);
	1397	} else {
	1398	paranoid_free(g_boot_mountpt);
	1399	paranoid_free(g_mondo_home);
[2030]	1400	/*
[128]	1401	paranoid_free(g_tmpfs_mountpt);
[2030]	1402	*/
[128]	1403	paranoid_free(g_serial_string);
	1404	paranoid_free(g_magicdev_command);
[2226]	1405
[128]	1406	}
[541]	1407
	1408	/*
	1409	char**list_of_arrays[] = {
	1410	&g_boot_mountpt,
	1411	&g_mondo_home,
	1412	&g_tmpfs_mountpt,
	1413	&g_serial_string,
	1414	&g_magicdev_command,
	1415	NULL};
	1416
	1417	char**ppcurr;
	1418	int i;
	1419
	1420	for(i=0;list_of_arrays[i];i++)
	1421	{
	1422	log_msg(5, "Allocating %d", i);
	1423	ppcurr = list_of_arrays[i];
	1424	if (mal)
	1425	{ *ppcurr = malloc(MAX_STR_LEN); }
	1426	else
	1427	{
	1428	if (*ppcurr)
	1429	{
	1430	free(*ppcurr);
	1431	}
	1432	}
	1433	}
	1434	log_msg(5, "Returning");
	1435	*/
[1]	1436	}
	1437
	1438	/**
	1439	* Allocate important globals.
	1440	* @see do_libmondo_global_strings_thing
	1441	*/
	1442	void malloc_libmondo_global_strings(void)
	1443	{
[128]	1444	do_libmondo_global_strings_thing(1);
[1]	1445	}
	1446
	1447	/**
	1448	* Free important globals.
	1449	* @see do_libmondo_global_strings_thing
	1450	*/
	1451	void free_libmondo_global_strings(void)
	1452	{
[128]	1453	do_libmondo_global_strings_thing(0);
[1]	1454	}
	1455
	1456
	1457
	1458	/**
	1459	* Stop @c magicdev if it's running.
	1460	* The command used to start it is saved in @p g_magicdev_command.
	1461	*/
	1462	void stop_magicdev_if_necessary()
	1463	{
[128]	1464	strcpy(g_magicdev_command,
	1465	call_program_and_get_last_line_of_output
	1466	("ps ax \| grep -w magicdev \| grep -v grep \| tr -s '\t' ' '\| cut -d' ' -f6-99"));
	1467	if (g_magicdev_command[0]) {
	1468	log_msg(1, "g_magicdev_command = '%s'", g_magicdev_command);
	1469	paranoid_system("killall magicdev");
	1470	}
[1]	1471	}
	1472
	1473
	1474	/**
	1475	* Restart magicdev if it was stopped.
	1476	*/
	1477	void restart_magicdev_if_necessary()
	1478	{
[128]	1479	char *tmp;
	1480
	1481	malloc_string(tmp);
	1482	if (g_magicdev_command && g_magicdev_command[0]) {
	1483	sprintf(tmp, "%s &", g_magicdev_command);
	1484	paranoid_system(tmp);
	1485	}
	1486	paranoid_free(tmp);
[1]	1487	}
	1488
	1489	/* @} - end of utilityGroup */

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

Download in other formats: