Context Navigation

libmondo-devices.c@ 2444

Visit:

Last change on this file since 2444 was 2444, checked in by Bruno Cornec, 15 years ago

priority given to env var for tmpdir
fuse FS excluded from tmpdir computation
Improves udev timeout handling
fuse device is needed at restore time for sshfs
Avoids comment analysis in the new code handling deplist.d
Avoids error message if some ssh conf files do not exist
Improvements on sshfs/ssh management in restore mode
Include now all minimal requirements for sshfs
Fix udev support in init for Mandriva 2009.1 (udevadm settle is blocking)
Improve deplist.d/* files
adds libnss for ssh support in boot disk
Solve a memory management issue in DSF module (strtok => mr_strtok)
DSF now also supports partitions in addition to full disks
Adds debug in open_and_list_dir
Improve user management for NetFS cases
ssh in the restore env needs some dlopened libs (libnss_compat|files)
Warning emited in case of duplicate mountpoints or devices in fstab found
Use only the AWK veriable everywhere and not the awk command
Simplify GetInitrdFilesystemToUse which doesn't need to detect everything, but just know if it's initramfs (new mode) or a compressed FS ext2/3 (older mode) as initrd is anyway re-made by mindi. Should fix #353

(Backport from 2.2.9)

Property svn:keywords set to Id

File size: 90.2 KB

Rev	Line
[1]	1	/* libmondo-devices.c Subroutines for handling devices
[85]	2	$Id: libmondo-devices.c 2444 2009-09-30 02:44:40Z bruno $
[1]	3	*/
	4
	5	/**
	6	* @file
	7	* Functions to handle interactions with backup devices.
	8	*/
	9
	10	#include "my-stuff.h"
[2211]	11	#include "mr_mem.h"
[2428]	12	#include "mr_str.h"
[1]	13	#include "mondostructures.h"
	14	#include "libmondo-files-EXT.h"
	15	#include "libmondo-devices.h"
[541]	16	#include "lib-common-externs.h"
[1]	17	#include "libmondo-string-EXT.h"
	18	#include "libmondo-tools-EXT.h"
[541]	19	#include "libmondo-gui-EXT.h"
[1]	20	#include "libmondo-fork-EXT.h"
	21	#include "libmondo-stream-EXT.h"
	22
[2322]	23	extern void mr_strip_spaces(char *);
	24
[1]	25	#include <sys/types.h>
	26	#ifdef __FreeBSD__
	27	#define DKTYPENAMES
	28	#define FSTYPENAMES
	29	#include <sys/disklabel.h>
	30	#include <sys/disk.h>
	31	#elif linux
	32	#define u64 unsigned long long
[128]	33	#include <linux/fs.h> /* for BLKGETSIZE64 */
[1]	34	#include <linux/hdreg.h>
	35	#endif
	36
	37	/@unused@/
[85]	38	//static char cvsid[] = "$Id: libmondo-devices.c 2444 2009-09-30 02:44:40Z bruno $";
[1]	39
	40	extern int g_current_media_number;
	41	extern double g_kernel_version;
	42
	43	extern bool g_ISO_restore_mode;
[99]	44	extern char *g_selfmounted_isodir;
[1316]	45	extern char *MONDO_LOGFILE;
[1]	46
[128]	47	static char g_cdrw_drive_is_here[MAX_STR_LEN / 4] = "";
	48	static char g_cdrom_drive_is_here[MAX_STR_LEN / 4] = "";
	49	static char g_dvd_drive_is_here[MAX_STR_LEN / 4] = "";
[1]	50
	51
	52	/**
	53	* ????? @bug ?????
	54	* @ingroup globalGroup
	55	*/
[128]	56	bool g_restoring_live_from_cd = FALSE;
[2382]	57	bool g_restoring_live_from_netfs = FALSE;
[1]	58
[128]	59	extern t_bkptype g_backup_media_type; // set by main()
[1]	60
[1645]	61	/* Reference to global bkpinfo */
	62	extern struct s_bkpinfo *bkpinfo;
[1]	63
[2428]	64	/* Stuff that handles the -I and -E option when a whole disk DSF is used */
	65	typedef struct mounted_fs_struct {
	66	char device[MAX_STR_LEN]; /* The name of the device */
	67	char mount_point[MAX_STR_LEN]; /* The devices mount point */
	68	unsigned char check; /* 1 == included on DSF */
	69	struct mounted_fs_struct *next;
	70	} MOUNTED_FS_STRUCT;
[1]	71
[2428]	72	static MOUNTED_FS_STRUCT DSF_Head = NULL; / Points to the first entry of mounted_fs_struct list */
	73	static MOUNTED_FS_STRUCT DSF_Tail = NULL; / Points to the last entry of mounted_fs_struct list */
[1]	74
[1645]	75
[2325]	76	void set_g_cdrom_and_g_dvd_to_bkpinfo_value() {
	77
	78	if (bkpinfo->media_device) {
	79	strcpy(g_cdrom_drive_is_here, bkpinfo->media_device); // just in case
	80	strcpy(g_dvd_drive_is_here, bkpinfo->media_device); // just in case
	81	}
[1]	82	}
	83
	84
	85
	86	/**
	87	* Retract all CD trays and wait for autorun to complete.
	88	* @ingroup deviceGroup
	89	*/
	90	void retract_CD_tray_and_defeat_autorun(void)
	91	{
	92	// log_it("rctada: Retracting all CD trays", __LINE__);
[128]	93	if (strlen(g_cdrom_drive_is_here) > 0) {
	94	inject_device(g_cdrom_drive_is_here);
	95	}
	96	if (strlen(g_dvd_drive_is_here) > 0) {
	97	inject_device(g_dvd_drive_is_here);
	98	}
	99	if (strlen(g_cdrw_drive_is_here) > 0) {
	100	inject_device(g_cdrw_drive_is_here);
	101	}
[1]	102	// log_it("rctada: killing autorun");
	103	// run_program_and_log_output("killall autorun", TRUE);
[128]	104	if (!run_program_and_log_output("ps \| grep autorun \| grep -v grep", 5)) {
	105	log_it("autorun detected; sleeping for 2 seconds");
	106	sleep(2);
	107	}
	108	log_it("rctada: Unmounting all CD drives", __LINE__);
	109	run_program_and_log_output("umount /dev/cdr* /dev/dvd*", 5);
[1]	110	}
	111
	112
	113
	114	/**
	115	* Determine whether we're booted off a ramdisk.
	116	* @return @c TRUE (we are) or @c FALSE (we aren't).
	117	* @ingroup utilityGroup
	118	*/
[128]	119	bool am_I_in_disaster_recovery_mode(void)
[1]	120	{
[2214]	121	char *tmp = NULL;
[128]	122	bool is_this_a_ramdisk = FALSE;
[1]	123
[2330]	124	tmp = where_is_root_mounted();
[2324]	125	log_msg(0, "root is currently mounted at %s\n", tmp);
[1]	126
	127	#ifdef __FreeBSD__
[128]	128	if (strstr(tmp, "/dev/md")) {
	129	is_this_a_ramdisk = TRUE;
	130	}
[1]	131	#else
[128]	132	if (!strncmp(tmp, "/dev/ram", 8)
	133	\|\| (!strncmp(tmp, "/dev/rd", 7) && !strcmp(tmp, "/dev/rd/")
	134	&& strncmp(tmp, "/dev/rd/cd", 10)) \|\| strstr(tmp, "rootfs")
	135	\|\| !strcmp(tmp, "/dev/root")) {
	136	is_this_a_ramdisk = TRUE;
	137	} else {
	138	is_this_a_ramdisk = FALSE;
	139	}
[1]	140	#endif
[2214]	141	mr_free(tmp);
[1]	142
[2321]	143	log_msg(1, "Is this a ramdisk? result = %s", (is_this_a_ramdisk) ? "TRUE" : "FALSE");
[128]	144	return (is_this_a_ramdisk);
[1]	145	}
	146
	147
	148
	149
	150
	151	/**
	152	* Turn @c bkpinfo->backup_media_type into a human-readable string.
	153	* @return The human readable string (e.g. @c cdr becomes <tt>"cdr"</tt>).
	154	* @note The returned string points to static storage that will be overwritten with each call.
	155	* @ingroup stringGroup
	156	*/
	157	static char *bkptype_to_string(t_bkptype bt)
	158	{
[2330]	159	char *output;
[128]	160	switch (bt) {
	161	case none:
[2330]	162	mr_asprintf(output, "none");
[1]	163	break;
[128]	164	case iso:
[2330]	165	mr_asprintf(output, "iso");
[1]	166	break;
[128]	167	case cdr:
[2330]	168	mr_asprintf(output, "cdr");
[1]	169	break;
[128]	170	case cdrw:
[2330]	171	mr_asprintf(output, "cdrw");
[1]	172	break;
[128]	173	case cdstream:
[2330]	174	mr_asprintf(output, "cdstream");
[1]	175	break;
[2382]	176	case netfs:
	177	mr_asprintf(output, "netfs");
[1]	178	break;
[128]	179	case tape:
[2330]	180	mr_asprintf(output, "tape");
[1]	181	break;
[128]	182	case udev:
[2330]	183	mr_asprintf(output, "udev");
[1]	184	break;
[1687]	185	case usb:
[2330]	186	mr_asprintf(output, "usb");
[1687]	187	break;
[128]	188	default:
[2330]	189	mr_asprintf(output, "default");
[128]	190	}
	191	return (output);
[1]	192	}
	193
	194
	195
	196	/**
	197	* @addtogroup deviceGroup
	198	* @{
	199	*/
	200	/**
	201	* Eject the tray of the specified CD device.
	202	* @param dev The device to eject.
	203	* @return the return value of the @c eject command. (0=success, nonzero=failure)
	204	*/
[128]	205	int eject_device(char *dev)
[1]	206	{
[2266]	207	char *command = NULL;
[128]	208	int res1 = 0, res2 = 0;
[1]	209
[2325]	210	if (dev == NULL) {
	211	return (1);
	212	}
	213
[128]	214	if (IS_THIS_A_STREAMING_BACKUP(g_backup_media_type)
	215	&& g_backup_media_type != udev) {
[2323]	216	mr_asprintf(command, "mt -f %s offline", dev);
[128]	217	res1 = run_program_and_log_output(command, 1);
[2266]	218	mr_free(command);
[128]	219	} else {
	220	res1 = 0;
	221	}
[1]	222
	223	#ifdef __FreeBSD__
[128]	224	if (strstr(dev, "acd")) {
[2323]	225	mr_asprintf(command, "cdcontrol -f %s eject", dev);
[128]	226	} else {
[2324]	227	mr_asprintf(command, "camcontrol eject `echo %s \| sed 's\|/dev/\|\|'`", dev);
[128]	228	}
[1]	229	#else
[2323]	230	mr_asprintf(command, "eject %s", dev);
[1]	231	#endif
	232
[128]	233	log_msg(3, "Ejecting %s", dev);
	234	res2 = run_program_and_log_output(command, 1);
[2266]	235	mr_free(command);
[128]	236	if (res1 && res2) {
	237	return (1);
	238	} else {
	239	return (0);
	240	}
[1]	241	}
	242
	243	/**
	244	* Load (inject) the tray of the specified CD device.
	245	* @param dev The device to load/inject.
	246	* @return 0 for success, nonzero for failure.
	247	*/
[128]	248	int inject_device(char *dev)
[1]	249	{
[2266]	250	char *command = NULL;
[128]	251	int i;
[1]	252
[2325]	253	if (dev == NULL) {
	254	return (1);
	255	}
	256
[1]	257	#ifdef __FreeBSD__
[128]	258	if (strstr(dev, "acd")) {
[2323]	259	mr_asprintf(command, "cdcontrol -f %s close", dev);
[128]	260	} else {
[2323]	261	mr_asprintf(command, "camcontrol load `echo %s \| sed 's\|/dev/\|\|'`", dev);
[128]	262	}
[1]	263	#else
[2323]	264	mr_asprintf(command, "eject -t %s", dev);
[1]	265	#endif
[128]	266	i = run_program_and_log_output(command, FALSE);
[2266]	267	mr_free(command);
[128]	268	return (i);
[1]	269	}
	270
	271
	272	/**
	273	* Determine whether the specified @p device (really, you can use any file)
	274	* exists.
	275	* @return TRUE if it exists, FALSE if it doesn't.
	276	*/
[128]	277	bool does_device_exist(char *device)
[1]	278	{
	279
[128]	280	/@ buffers ********************************************************** */
[2266]	281	char *tmp = NULL;
[128]	282	bool ret;
[1]	283
[128]	284	assert_string_is_neither_NULL_nor_zerolength(device);
[1]	285
[2323]	286	mr_asprintf(tmp, "ls %s > /dev/null 2> /dev/null", device);
[128]	287
	288	if (system(tmp)) {
	289	ret = FALSE;
	290	} else {
	291	ret = TRUE;
	292	}
[2266]	293	mr_free(tmp);
[128]	294	return (ret);
[1]	295	}
	296
	297
	298	/**
	299	* Determine whether a non-Microsoft partition exists on any connected hard drive.
	300	* @return TRUE (there's a Linux/FreeBSD partition) or FALSE (Microsoft has taken over yet another innocent PC).
	301	*/
[128]	302	bool does_nonMS_partition_exist(void)
[1]	303	{
	304	#if __FreeBSD__
[128]	305	return
	306	!system
	307	("for drive in /dev/ad? /dev/da?; do fdisk $drive \| grep -q FreeBSD && exit 0; done; false");
[1]	308	#else
[128]	309	return
	310	!system
[681]	311	("parted2fdisk -l 2>/dev/null \| grep '^/dev/' \| grep -Eqv '(MS\|DOS\|FAT\|NTFS)'");
[1]	312	#endif
	313	}
	314
	315	/**
	316	* Determine whether the specified @p partno exists on the specified @p drive.
	317	* @param drive The drive to search for the partition in.
	318	* @param partno The partition number to look for.
	319	* @return 0 if it exists, nonzero otherwise.
	320	*/
[128]	321	int does_partition_exist(const char *drive, int partno)
[1]	322	{
[128]	323	/@ buffers *************************************************** */
[2266]	324	char *program = NULL;
[2351]	325	char *incoming = NULL;
[2211]	326	char *searchstr = NULL;
[2316]	327	char *tmp = NULL;
[1]	328
[128]	329	/@ ints ****************************************************** */
	330	int res = 0;
[1]	331
[128]	332	/@ pointers ************************************************** */
	333	FILE *fin;
[1]	334
	335
[128]	336	/@ end vars ************************************************** */
	337	assert_string_is_neither_NULL_nor_zerolength(drive);
	338	assert(partno >= 0 && partno < 999);
[1]	339
	340	#ifdef __FreeBSD__
[128]	341	// We assume here that this is running from mondorestore. (It is.)
[2316]	342	tmp = build_partition_name(drive, partno);
[2323]	343	mr_asprintf(program, "ls %s %s >/dev/null 2>&1", drive, tmp);
[2316]	344	mr_free(tmp);
	345
[2266]	346	res = system(program);
	347	mr_free(program);
	348	return (res);
[1]	349	#else
[2316]	350	/* To avoid compiler warnings */
	351	tmp = NULL;
[1]	352	#endif
	353
[2323]	354	mr_asprintf(program, "parted2fdisk -l %s 2> /dev/null", drive);
[128]	355	fin = popen(program, "r");
	356	if (!fin) {
	357	log_it("program=%s", program);
	358	log_OS_error("Cannot popen-in program");
[2266]	359	mr_free(program);
[128]	360	return (0);
[1]	361	}
[2266]	362	mr_free(program);
	363
[2316]	364	searchstr = build_partition_name(drive, partno);
	365	mr_strcat(searchstr, " ");
[2351]	366	for (res = 0, mr_getline(incoming, fin); !res && !feof(fin) ; mr_getline(incoming, fin)) {
[128]	367	if (strstr(incoming, searchstr)) {
	368	res = 1;
	369	}
[2351]	370	mr_free(incoming);
[128]	371	}
[2351]	372	mr_free(incoming);
[2316]	373	mr_free(searchstr);
	374
[128]	375	if (pclose(fin)) {
	376	log_OS_error("Cannot pclose fin");
	377	}
	378	return (res);
[1]	379	}
	380
	381
	382
	383
	384
	385	/**
	386	* Determine whether given NULL-terminated @p str exists in the MBR of @p dev.
	387	* @param dev The device to look in.
	388	* @param str The string to look for.
	389	* @return TRUE if it exists, FALSE if it doesn't.
	390	*/
[128]	391	bool does_string_exist_in_boot_block(char dev, char str)
[1]	392	{
[128]	393	/@ buffers *************************************************** */
[2266]	394	char *command = NULL;
[1]	395
[128]	396	/@ end vars ************************************************** */
	397	int i;
[1]	398
[128]	399	assert_string_is_neither_NULL_nor_zerolength(dev);
	400	assert_string_is_neither_NULL_nor_zerolength(str);
[1]	401
[2323]	402	mr_asprintf(command, "dd if=%s bs=446 count=1 2> /dev/null \| strings \| grep \"%s\" > /dev/null 2> /dev/null", dev, str);
[128]	403	i = system(command);
[2266]	404	mr_free(command);
[128]	405	if (i) {
	406	return (FALSE);
	407	} else {
	408	return (TRUE);
	409	}
[1]	410	}
	411
	412	/**
	413	* Determine whether specified @p str exists in the first @p n sectors of
	414	* @p dev.
	415	* @param dev The device to look in.
	416	* @param str The string to look for.
	417	* @param n The number of 512-byte sectors to search.
	418	*/
[128]	419	bool does_string_exist_in_first_N_blocks(char dev, char str, int n)
[1]	420	{
[128]	421	/@ buffers *************************************************** */
[2266]	422	char *command = NULL;
[128]	423	/@ end vars ************************************************** */
	424	int i;
[1]	425
[2323]	426	mr_asprintf(command, "dd if=%s bs=512 count=%i 2> /dev/null \| strings \| grep \"%s\" > /dev/null 2> /dev/null", dev, n, str);
[128]	427	i = system(command);
[2266]	428	mr_free(command);
[128]	429	if (i) {
	430	return (FALSE);
	431	} else {
	432	return (TRUE);
	433	}
[1]	434	}
	435
	436
	437
	438	/**
	439	* Try to mount CD-ROM at @p mountpoint. If the CD-ROM is not found or has
	440	* not been specified, call find_cdrom_device() to find it.
	441	* @param mountpoint Where to mount the CD-ROM.
	442	* @return 0 for success, nonzero for failure.
	443	* @see mount_CDROM_here
	444	*/
[2325]	445	int find_and_mount_actual_cd(char *mountpoint) {
	446
[128]	447	/@ buffers **************************************************** */
[1]	448
[128]	449	/@ int's ***************************************************** */
	450	int res;
[2325]	451	char *dev = NULL;
[2316]	452	char *p = NULL;
[1]	453
[128]	454	/@ end vars *************************************************** */
[1]	455
[128]	456	assert(bkpinfo != NULL);
	457	assert_string_is_neither_NULL_nor_zerolength(mountpoint);
[1]	458
[128]	459	if (g_backup_media_type == dvd) {
[2325]	460	if (g_dvd_drive_is_here[0]) {
	461	mr_asprintf(dev, "%s", g_dvd_drive_is_here);
[128]	462	}
[2325]	463	if (dev == NULL) {
	464	dev = find_dvd_device();
	465	}
[128]	466	} else {
[2325]	467	if (g_cdrom_drive_is_here[0]) {
	468	mr_asprintf(dev, "%s", g_cdrom_drive_is_here);
[128]	469	}
[2325]	470	if (dev == NULL) {
	471	dev = find_cdrom_device(FALSE);
	472	}
[128]	473	}
[1]	474
[128]	475	if (bkpinfo->backup_media_type != iso) {
	476	retract_CD_tray_and_defeat_autorun();
	477	}
[1]	478
[2325]	479	if ((dev == NULL) \|\| (res = mount_CDROM_here(dev, mountpoint))) {
[2316]	480	p = popup_and_get_string ("CD-ROM device", "Please enter your CD-ROM's /dev device",dev);
	481	if (p == NULL) {
[128]	482	res = 1;
	483	} else {
[2316]	484	res = mount_CDROM_here(p, mountpoint);
[128]	485	}
[2316]	486	mr_free(p);
[128]	487	}
	488	if (res) {
[541]	489	log_msg(1, "mount failed");
[128]	490	} else {
[541]	491	log_msg(1, "mount succeeded with %s", dev);
[128]	492	}
[2325]	493	mr_free(dev);
[128]	494	return (res);
[1]	495	}
	496
	497
	498
	499
	500
	501
	502	/**
	503	* Locate a CD-R/W writer's SCSI node.
	504	* @param cdrw_device SCSI node will be placed here.
	505	* @return 0 for success, nonzero for failure.
	506	*/
[2325]	507	char *find_cdrw_device()
[1]	508	{
[128]	509	/@ buffers *********************** */
[2214]	510	char *tmp = NULL;
[2331]	511	char *tmp1 = NULL;
[2214]	512	char *cdr_exe = NULL;
[2266]	513	char *command = NULL;
[2325]	514	char *cdrw_device = NULL;
[1]	515
[128]	516	if (g_cdrw_drive_is_here[0]) {
[2334]	517	mr_asprintf(cdrw_device, "%s", g_cdrw_drive_is_here);
[128]	518	log_msg(3, "Been there, done that. Returning %s", cdrw_device);
[2325]	519	return(cdrw_device);
[128]	520	}
	521	if (g_backup_media_type == dvd) {
[2325]	522	log_msg(1, "This is dumb. You're calling find_cdrw_device() but you're backing up to DVD. WTF?");
	523	return(NULL);
[128]	524	}
	525	run_program_and_log_output("insmod ide-scsi", -1);
[2331]	526	tmp = find_home_of_exe("cdrecord");
	527	if (tmp) {
[2323]	528	mr_asprintf(cdr_exe, "cdrecord");
[128]	529	} else {
[2323]	530	mr_asprintf(cdr_exe, "dvdrecord");
[128]	531	}
[2331]	532	mr_free(tmp);
	533
	534	tmp1 = find_home_of_exe(cdr_exe);
	535	if (tmp1) {
[2323]	536	mr_asprintf(command, "%s -scanbus 2> /dev/null \| tr -s '\t' ' ' \| grep \"[0-9],[0-9],[0-9]\" \| grep -v \"[0-9]) \\*\" \| grep CD \| cut -d' ' -f2 \| head -n1", cdr_exe);
[2383]	537	tmp = call_program_and_get_last_line_of_output(command);
[2266]	538	mr_free(command);
[128]	539	}
[2331]	540	mr_free(tmp1);
	541
[2214]	542	if ((tmp == NULL) \|\| (strlen(tmp) < 2)) {
	543	mr_free(tmp);
	544	mr_free(cdr_exe);
[2325]	545	return(NULL);
[128]	546	} else {
[2325]	547	cdrw_device = tmp;
[2324]	548	log_it("Found CDRW device - %s", cdrw_device);
[128]	549	strcpy(g_cdrw_drive_is_here, cdrw_device);
[2214]	550	mr_free(cdr_exe);
[2325]	551	return (cdrw_device);
[128]	552	}
[1]	553	}
	554
	555
	556	/**
	557	* Attempt to locate a CD-ROM device's /dev entry.
	558	* Several different methods may be used to find the device, including
	559	* calling @c cdrecord, searching @c dmesg, and trial-and-error.
	560	* @param output Where to put the located /dev entry.
	561	* @param try_to_mount Whether to mount the CD as part of the test; if mount
	562	* fails then return failure.
	563	* @return 0 for success, nonzero for failure.
	564	*/
[2325]	565	char *find_cdrom_device(bool try_to_mount)
[1]	566	{
[128]	567	/@ pointers *************************************************** */
	568	FILE *fin;
	569	char *p;
	570	char *q;
	571	char *r;
[1]	572
[128]	573	/@ bool's ***************************************************** */
	574	bool found_it = FALSE;
[1]	575
[128]	576	/@ buffers **************************************************** */
[2325]	577	char *tmp = NULL;
	578	char *output = NULL;
[2214]	579	char *cdr_exe = NULL;
[2325]	580	char *phrase_two = NULL;
[2266]	581	char *command = NULL;
	582	#ifndef __FreeBSD__
	583	char *dvd_last_resort = NULL;
	584	#endif
	585	char *mountpoint = NULL;
[128]	586	static char the_last_place_i_found_it[MAX_STR_LEN] = "";
[1]	587
[128]	588	/@ intialize ************************************************** */
[1]	589
[2325]	590	output = NULL;
[2266]	591	#ifndef __FreeBSD__
[2323]	592	mr_asprintf(dvd_last_resort, "%s", "");;
[2266]	593	#endif
[1]	594
[128]	595	/@ end vars *************************************************** */
[1]	596
[128]	597	if (g_cdrom_drive_is_here[0] && !isdigit(g_cdrom_drive_is_here[0])) {
[2325]	598	mr_asprintf(output, "%s", g_cdrom_drive_is_here);
[128]	599	log_msg(3, "Been there, done that. Returning %s", output);
[2325]	600	return(output);
[128]	601	}
	602	if (the_last_place_i_found_it[0] != '\0' && !try_to_mount) {
[2325]	603	mr_asprintf(output, "%s", the_last_place_i_found_it);
	604	log_msg(3, "find_cdrom_device() --- returning last found location - '%s'", output);
	605	return(output);
[128]	606	}
[1]	607
[2323]	608	mr_asprintf(mountpoint, "%s/cd.mnt", bkpinfo->tmpdir);
[128]	609	make_hole_for_dir(mountpoint);
[1]	610
[2331]	611	tmp = find_home_of_exe("cdrecord");
	612	if (tmp) {
[2323]	613	mr_asprintf(cdr_exe, "cdrecord");
[128]	614	} else {
[2323]	615	mr_asprintf(cdr_exe, "dvdrecord");
[128]	616	}
[2331]	617	mr_free(tmp);
[2325]	618
[2331]	619	tmp = find_home_of_exe(cdr_exe);
	620	if (!tmp) {
[2325]	621	mr_asprintf(output, "/dev/cdrom");
[128]	622	log_msg(4, "Can't find cdrecord; assuming %s", output);
[2325]	623	mr_free(cdr_exe);
[128]	624	if (!does_device_exist(output)) {
	625	log_msg(4, "That didn't work. Sorry.");
[2325]	626	mr_free(output);
[128]	627	}
[2331]	628	mr_free(tmp);
	629	return(output);
[128]	630	}
[2331]	631	mr_free(tmp);
[128]	632
[2323]	633	mr_asprintf(command, "%s -scanbus 2> /dev/null", cdr_exe);
[128]	634	fin = popen(command, "r");
[2266]	635	log_msg(4, "command=%s", command);
	636	mr_free(command);
	637
[128]	638	if (!fin) {
	639	log_OS_error("Cannot popen command");
[2214]	640	mr_free(cdr_exe);
[2325]	641	return(NULL);
[128]	642	}
[2266]	643
[2351]	644	for (mr_getline(tmp, fin); !feof(fin); mr_getline(tmp, fin)) {
[128]	645	p = strchr(tmp, '\'');
	646	if (p) {
	647	q = strchr(++p, '\'');
	648	if (q) {
	649	for (r = q; *(r - 1) == ' '; r--);
	650	*r = '\0';
	651	p = strchr(++q, '\'');
	652	if (p) {
	653	q = strchr(++p, '\'');
	654	if (q) {
	655	while (*(q - 1) == ' ') {
	656	q--;
	657	}
	658	*q = '\0';
[2330]	659	mr_asprintf(phrase_two, "%s", p);
[128]	660	}
	661	}
[1]	662	}
	663	}
[2351]	664	mr_free(tmp);
[1]	665	}
[2351]	666	mr_free(tmp);
[128]	667	paranoid_pclose(fin);
[1]	668
	669	#ifndef __FreeBSD__
[2330]	670	if (!phrase_two \|\| strlen(phrase_two) == 0) {
[128]	671	log_msg(4, "Not running phase two. String is empty.");
	672	} else {
[2323]	673	mr_asprintf(command, "dmesg \| grep \"%s\" 2> /dev/null", phrase_two);
[128]	674	fin = popen(command, "r");
[2266]	675	mr_free(command);
	676
[128]	677	if (!fin) {
	678	log_msg(4, "Cannot run 2nd command - non-fatal, fortunately");
	679	} else {
[2351]	680	for (mr_getline(tmp, fin); !feof(fin); mr_getline(tmp, fin)) {
[128]	681	log_msg(5, "--> '%s'", tmp);
	682	if (tmp[0] != ' ' && tmp[1] != ' ') {
	683	p = strchr(tmp, ':');
	684	if (p) {
	685	*p = '\0';
	686	if (strstr(tmp, "DVD")) {
[2266]	687	mr_free(dvd_last_resort);
[2323]	688	mr_asprintf(dvd_last_resort, "/dev/%s", tmp);
[2325]	689	log_msg(4, "Ignoring '%s' because it's a DVD drive", tmp);
[128]	690	} else {
[2325]	691	mr_asprintf(output, "/dev/%s", tmp);
[128]	692	found_it = TRUE;
	693	}
	694	}
	695	}
[2351]	696	mr_free(tmp);
[128]	697	}
	698	paranoid_pclose(fin);
[2351]	699	mr_free(tmp);
[128]	700	}
	701	}
[2330]	702	mr_free(phrase_two);
[1]	703
	704	#endif
	705	#ifdef __FreeBSD__
[128]	706	if (!found_it) {
	707	log_msg(4, "OK, approach 2");
[2325]	708	if (!(output = set_dev_to_this_if_rx_OK("/dev/cdrom"))) {
	709	if (!(output = set_dev_to_this_if_rx_OK("/dev/cdrom1"))) {
	710	if (!(output = set_dev_to_this_if_rx_OK("/dev/dvd"))) {
	711	if (!(output = set_dev_to_this_if_rx_OK("/dev/acd0"))) {
	712	if (!(output = set_dev_to_this_if_rx_OK("/dev/cd01"))) {
	713	if (!(output = set_dev_to_this_if_rx_OK("/dev/acd1"))) {
	714	if (!(output = set_dev_to_this_if_rx_OK("/dev/cd1"))) {
	715	mr_free(cdr_exe);
	716	return(NULL);
[128]	717	}
	718	}
	719	}
	720	}
	721	}
	722	}
	723	}
	724	}
[1]	725	#else
[128]	726	if (!found_it && strlen(dvd_last_resort) > 0) {
[2266]	727	log_msg(4, "Well, I'll use the DVD - %s - as a last resort", dvd_last_resort);
[2325]	728	mr_asprintf(output, "%s", dvd_last_resort);
[128]	729	found_it = TRUE;
[1]	730	}
[2266]	731	mr_free(dvd_last_resort);
[2325]	732
[128]	733	if (found_it) {
[2351]	734	mr_asprintf(tmp, "grep \"%s=ide-scsi\" " CMDLINE " &> /dev/null", strrchr(output, '/') + 1);
	735	if (system(tmp) == 0) {
[2325]	736	log_msg(4, "%s is not right. It's being SCSI-emulated. Continuing.", output);
[128]	737	found_it = FALSE;
[2325]	738	mr_free(output);
[128]	739	}
[2351]	740	mr_free(tmp);
[128]	741	}
[1]	742
[128]	743	if (found_it) {
	744	log_msg(4, "(find_cdrom_device) --> '%s'", output);
	745	if (!does_device_exist(output)) {
	746	found_it = FALSE;
	747	log_msg(4, "OK, I was wrong, I haven't found it... yet.");
[2325]	748	mr_free(output);
[128]	749	}
	750	}
[1]	751
[128]	752	if (!found_it) {
	753	log_msg(4, "OK, approach 2");
[2325]	754	if (!(output = set_dev_to_this_if_rx_OK("/dev/scd0"))) {
	755	if (!(output = set_dev_to_this_if_rx_OK("/dev/sr0"))) {
	756	if (!(output = set_dev_to_this_if_rx_OK("/dev/cdrom"))) {
	757	if (!(output = set_dev_to_this_if_rx_OK("/dev/cdrom0"))) {
	758	if (!(output = set_dev_to_this_if_rx_OK("/dev/cdrom1"))) {
	759	if (!(output = set_dev_to_this_if_rx_OK("/dev/sr1"))) {
	760	if (!(output = set_dev_to_this_if_rx_OK("/dev/dvd"))) {
	761	if (!(output = set_dev_to_this_if_rx_OK(g_cdrw_drive_is_here))) {
	762	mr_free(cdr_exe);
	763	return(NULL);
[128]	764	}
	765	}
	766	}
	767	}
	768	}
	769	}
	770	}
	771	}
	772	}
[1]	773	#endif
	774
[128]	775	if (found_it && try_to_mount) {
	776	if (mount_CDROM_here(output, mountpoint)) {
	777	log_msg(4, "[Cardigans] I've changed my mind");
	778	found_it = FALSE;
[2325]	779	mr_free(output);
[128]	780	} else {
[2351]	781	mr_asprintf(tmp, "%s/archives", mountpoint);
[128]	782	if (!does_file_exist(tmp)) {
	783	log_msg(4, "[Cardigans] I'll take it back");
	784	found_it = FALSE;
[2325]	785	mr_free(output);
[128]	786	} else {
[2323]	787	mr_asprintf(command, "umount %s", output);
[128]	788	paranoid_system(command);
[2266]	789	mr_free(command);
	790
[128]	791	log_msg(4, "I'm confident the Mondo CD is in %s", output);
	792	}
[2351]	793	mr_free(tmp);
[128]	794	}
	795	}
	796	unlink(mountpoint);
[2266]	797	mr_free(mountpoint);
[1]	798
[128]	799	if (found_it) {
	800	if (!does_file_exist(output)) {
	801	log_msg(3, "I still haven't found it.");
[2325]	802	mr_free(cdr_exe);
	803	mr_free(output);
	804	return (NULL);
[128]	805	}
	806	log_msg(3, "(find_cdrom_device) --> '%s'", output);
	807	strcpy(the_last_place_i_found_it, output);
	808	strcpy(g_cdrom_drive_is_here, output);
[2325]	809	mr_free(cdr_exe);
	810	return (output);
[128]	811	}
[1]	812
[2323]	813	mr_asprintf(command, "%s -scanbus \| grep \"[0-9],[0-9],[0-9]\" \| grep \"[D\|C][V\|D]\" \| grep -n \"\" \| grep \"%s\" \| cut -d':' -f2", cdr_exe, g_cdrw_drive_is_here);
[2325]	814	mr_free(cdr_exe);
	815
[128]	816	log_msg(1, "command=%s", command);
[2383]	817	tmp = call_program_and_get_last_line_of_output(command);
[2266]	818	mr_free(command);
	819
[2325]	820	mr_free(output);
[2351]	821	if (strlen(tmp) > 0) {
	822	mr_asprintf(output, "%s", tmp);
[128]	823	log_msg(4, "Finally found it at %s", output);
	824	} else {
	825	log_msg(4, "Still couldn't find it.");
	826	}
[2351]	827	mr_free(tmp);
[2214]	828
[2325]	829	return (output);
[1]	830	}
	831
	832
[2325]	833	char *find_dvd_device()
[1]	834	{
[2266]	835	char *tmp = NULL;
[2325]	836	int devno = -1;
	837	char *output = NULL;
[1]	838
[128]	839	if (g_dvd_drive_is_here[0]) {
[2334]	840	mr_asprintf(output, "%s", g_dvd_drive_is_here);
[128]	841	log_msg(3, "Been there, done that. Returning %s", output);
[2325]	842	return (output);
[128]	843	}
[1]	844
[2383]	845	tmp = call_program_and_get_last_line_of_output("dvdrecord -scanbus 2> /dev/null \| grep \") '\" \| grep -n \"\" \| grep DVD \| cut -d':' -f1");
[128]	846	log_msg(5, "tmp = '%s'", tmp);
	847	if (!tmp[0])
[2266]	848	mr_free(tmp);
[2383]	849	tmp = call_program_and_get_last_line_of_output("cdrecord -scanbus 2> /dev/null \| grep \") '\" \| grep -n \"\" \| grep DVD \| cut -d':' -f1");
[128]	850	if (tmp[0]) {
	851	devno = atoi(tmp) - 1;
	852	}
[2266]	853	mr_free(tmp);
	854
[128]	855	if (devno >= 0) {
[2325]	856	mr_asprintf(output, "/dev/scd%d", devno);
[128]	857	strcpy(g_dvd_drive_is_here, output);
	858	log_msg(2, "I think DVD is at %s", output);
	859	} else {
	860	log_msg(2, "I cannot find DVD");
	861	}
[1]	862
[2325]	863	return (output);
[1]	864	}
	865
	866
	867
	868
	869
	870	#include <sys/ioctl.h>
	871
	872	/**
	873	* Find the size of the specified @p drive, in megabytes. Uses @c ioctl calls
	874	* and @c dmesg.
	875	* @param drive The device to find the size of.
	876	* @return size in megabytes.
	877	*/
[128]	878	long get_phys_size_of_drive(char *drive)
[1]	879	{
[128]	880	int fd;
[1]	881	#if linux
[128]	882	unsigned long long s = 0;
	883	int fileid, cylinders = 0, cylindersleft = 0;
	884	int cylindersize = 0;
[1]	885	int gotgeo = 0;
	886
[128]	887
	888	struct hd_geometry hdgeo;
[1]	889	#elif __FreeBSD__
[128]	890	off_t s;
[1]	891	#endif
	892
[128]	893	long outvalA = -1;
	894	long outvalB = -1;
	895	long outvalC = -1;
[1]	896
[128]	897	if ((fd = open(drive, O_RDONLY)) != -1) {
	898	if (ioctl(fd,
[1]	899	#if linux
[128]	900	#ifdef BLKGETSIZE64
	901	BLKGETSIZE64,
	902	#else
	903	BLKGETSIZE,
	904	#endif
[1]	905	#elif __FreeBSD__
[128]	906	DIOCGMEDIASIZE,
[1]	907	#endif
[128]	908	&s) != -1) {
	909	close(fd);
	910	// s>>11 works for older disks but not for newer ones
	911	outvalB =
[1]	912	#if linux
[128]	913	#ifdef BLKGETSIZE64
	914	s >> 20
[1]	915	#else
[128]	916	s >> 11
[1]	917	#endif
[128]	918	#else
	919	s >> 20
	920	#endif
	921	;
	922	}
[1]	923	}
	924
[128]	925	if (outvalB <= 0) {
	926	log_msg(1, "Error getting size of %s: %s", drive, strerror(errno));
[1]	927	#if linux
[161]	928	fileid = open(drive, O_RDONLY);
[2205]	929	if (fileid != -1) {
[161]	930	if (ioctl(fileid, HDIO_GETGEO, &hdgeo) != -1) {
	931	if (hdgeo.cylinders && hdgeo.heads && hdgeo.sectors) {
	932	cylindersleft = cylinders = hdgeo.cylinders;
	933	cylindersize = hdgeo.heads * hdgeo.sectors / 2;
	934	outvalA = cylindersize * cylinders / 1024;
	935	log_msg(2, "Got Harddisk geometry, C:%d, H:%d, S:%d",
	936	hdgeo.cylinders, hdgeo.heads, hdgeo.sectors);
	937	gotgeo = 1;
	938	} else {
	939	log_msg(1, "Harddisk geometry wrong");
	940	}
[1]	941	} else {
[161]	942	log_msg(1,
	943	"Error in ioctl() getting new hard disk geometry (%s), resizing in unsafe mode",
	944	strerror(errno));
[1]	945	}
[161]	946	close(fileid);
[1]	947	} else {
[161]	948	log_msg(1, "Failed to open %s for reading: %s", drive,
[128]	949	strerror(errno));
[1]	950	}
[161]	951	if (!gotgeo) {
	952	log_msg(1, "Failed to get harddisk geometry, using old mode");
	953	}
[1]	954	#endif
[161]	955	}
[1]	956	// OLDER DISKS will give ridiculously low value for outvalB (so outvalA is returned) :)
	957	// NEWER DISKS will give sane value for outvalB (close to outvalA, in other words) :)
	958
[128]	959	outvalC = (outvalA > outvalB) ? outvalA : outvalB;
	960
[1]	961	// log_msg (5, "drive = %s, error = %s", drive, strerror (errno));
	962	// fatal_error ("GPSOD: Unable to get size of drive");
[128]	963	log_msg(1, "%s --> %ld or %ld --> %ld", drive, outvalA, outvalB,
	964	outvalC);
	965
	966	return (outvalC);
[1]	967	}
[128]	968
[1]	969	/**
	970	* Determine whether @p format is supported by the kernel. Uses /proc/filesystems
	971	* under Linux and @c lsvfs under FreeBSD.
	972	* @param format The format to test.
	973	* @return TRUE if the format is supported, FALSE if not.
	974	*/
[128]	975	bool is_this_a_valid_disk_format(char *format)
[1]	976	{
[2211]	977	char *good_formats = NULL;
[2266]	978	char *command = NULL;
	979	char *format_sz = NULL;
[1]	980
[128]	981	FILE *pin;
	982	int retval;
[1]	983
[128]	984	assert_string_is_neither_NULL_nor_zerolength(format);
[1]	985
[2323]	986	mr_asprintf(format_sz, "%s ", format);
[1]	987
	988	#ifdef __FreeBSD__
[2323]	989	mr_asprintf(command, "lsvfs \| tr -s '\t' ' ' \| grep -v Filesys \| grep -v -- -- \| cut -d' ' -f1 \| tr -s '\n' ' '");
[1]	990	#else
[2323]	991	mr_asprintf(command, "grep -v nodev /proc/filesystems \| tr -s '\t' ' ' \| cut -d' ' -f2 \| tr -s '\n' ' '");
[1]	992	#endif
	993
[128]	994	pin = popen(command, "r");
[2266]	995	mr_free(command);
	996
[128]	997	if (!pin) {
	998	log_OS_error("Unable to read good formats");
	999	retval = 0;
	1000	} else {
[2331]	1001	mr_getline(good_formats, pin);
[128]	1002	if (pclose(pin)) {
	1003	log_OS_error("Cannot pclose good formats");
	1004	}
[2316]	1005	mr_strip_spaces(good_formats);
	1006	mr_strcat(good_formats, " swap lvm raid ntfs-3g ntfs 7 "); // " ntfs 7 " -- um, cheating much? :)
[128]	1007	if (strstr(good_formats, format_sz)) {
	1008	retval = 1;
	1009	} else {
	1010	retval = 0;
	1011	}
[2316]	1012	mr_free(good_formats);
[128]	1013	}
[2266]	1014	mr_free(format_sz);
	1015
[128]	1016	return (retval);
[1]	1017	}
	1018
	1019
	1020	/** @def SWAPLIST_COMMAND The command to list the swap files/partitions in use. */
	1021
	1022	/**
	1023	* Determine whether @p device_raw is currently mounted.
	1024	* @param device_raw The device to check.
	1025	* @return TRUE if it's mounted, FALSE if not.
	1026	*/
[128]	1027	bool is_this_device_mounted(char *device_raw)
[1]	1028	{
	1029
[128]	1030	/@ pointers *************************************************** */
	1031	FILE *fin;
[1]	1032
[128]	1033	/@ buffers **************************************************** */
[2351]	1034	char *incoming = NULL;
[2214]	1035	char *device_with_tab = NULL;
	1036	char *device_with_space = NULL;
	1037	char *tmp = NULL;
	1038	bool retval = FALSE;
[128]	1039
[1]	1040	#ifdef __FreeBSD__
[128]	1041	#define SWAPLIST_COMMAND "swapinfo"
[1]	1042	#else
[128]	1043	#define SWAPLIST_COMMAND "cat /proc/swaps"
[1]	1044	#endif
	1045
[128]	1046	/@ end vars *************************************************** */
[1]	1047
[2325]	1048	if (device_raw == NULL) {
	1049	return(FALSE);
	1050	}
	1051
[128]	1052	if (device_raw[0] != '/' && !strstr(device_raw, ":/")) {
	1053	log_msg(1, "%s needs to have a '/' prefixed - I'll do it",
	1054	device_raw);
[2323]	1055	mr_asprintf(tmp, "/%s", device_raw);
[128]	1056	} else {
[2323]	1057	mr_asprintf(tmp, "%s", device_raw);
[128]	1058	}
	1059	log_msg(1, "Is %s mounted?", tmp);
	1060	if (!strcmp(tmp, "/proc") \|\| !strcmp(tmp, "proc")) {
	1061	log_msg(1,
	1062	"I don't know how the heck /proc made it into the mountlist. I'll ignore it.");
[2214]	1063	mr_free(tmp);
	1064	return(FALSE);
[128]	1065	}
[2323]	1066	mr_asprintf(device_with_tab, "%s\t", tmp);
	1067	mr_asprintf(device_with_space, "%s ", tmp);
[2214]	1068	mr_free(tmp);
[1]	1069
[128]	1070	if (!(fin = popen("mount", "r"))) {
	1071	log_OS_error("Cannot popen 'mount'");
[2214]	1072	return(FALSE);
[1]	1073	}
[2351]	1074
	1075	for (mr_getline(incoming, fin); !feof(fin); mr_getline(incoming, fin)) {
	1076	if (strstr(incoming, device_with_space) \|\| strstr(incoming, device_with_tab)) {
[128]	1077	paranoid_pclose(fin);
[2351]	1078	mr_free(incoming);
[2214]	1079	return(TRUE);
[128]	1080	}
[2351]	1081	mr_free(incoming);
[128]	1082	}
[2351]	1083	mr_free(incoming);
[2214]	1084	mr_free(device_with_tab);
[128]	1085	paranoid_pclose(fin);
[2323]	1086	mr_asprintf(tmp, "%s \| grep -E \"^%s\" > /dev/null 2> /dev/null", SWAPLIST_COMMAND, device_with_space);
[2428]	1087	mr_free(device_with_space);
[128]	1088	log_msg(4, "tmp (command) = '%s'", tmp);
	1089	if (!system(tmp)) {
[2214]	1090	retval = TRUE;
[128]	1091	}
[2214]	1092	mr_free(tmp);
	1093	return(retval);
[1]	1094	}
	1095
	1096	#ifdef __FreeBSD__
	1097	// CODE IS FREEBSD-SPECIFIC
	1098	/**
	1099	* Create a loopback device for specified @p fname.
	1100	* @param fname The file to associate with a device.
	1101	* @return /dev entry for the device, or NULL if it couldn't be allocated.
	1102	*/
[128]	1103	char make_vn(char fname)
[1]	1104	{
[128]	1105	char device = (char ) malloc(MAX_STR_LEN);
	1106	char mddevice = (char ) malloc(32);
	1107	char command[MAX_STR_LEN];
[2383]	1108	char *tmp = NULL;
[128]	1109	int vndev = 2;
[2383]	1110	int i = 2;
	1111
[2428]	1112	tmp = call_program_and_get_last_line_of_output("/sbin/sysctl -n kern.osreldate");
[2383]	1113	i = atoi(tmp);
	1114	mr_free(tmp);
	1115
	1116	if (i < 500000) {
[128]	1117	do {
	1118	sprintf(mddevice, "vn%ic", vndev++);
	1119	sprintf(command, "vnconfig %s %s", mddevice, fname);
	1120	if (vndev > 10) {
	1121	return NULL;
	1122	}
	1123	}
	1124	while (system(command));
	1125	} else {
	1126	sprintf(command, "mdconfig -a -t vnode -f %s", fname);
	1127	mddevice = call_program_and_get_last_line_of_output(command);
	1128	if (!strstr(mddevice, "md")) {
	1129	return NULL;
	1130	}
	1131	}
	1132	sprintf(device, "/dev/%s", mddevice);
	1133	return device;
[1]	1134	}
	1135
	1136
	1137
	1138	// CODE IS FREEBSD-SPECIFIC
	1139	/**
	1140	* Deallocate specified @p dname.
	1141	* This should be called when you are done with the device created by make_vn(),
	1142	* so the system does not run out of @c vn devices.
	1143	* @param dname The device to deallocate.
	1144	* @return 0 for success, nonzero for failure.
	1145	*/
[128]	1146	int kick_vn(char *dname)
[1]	1147	{
[2266]	1148	char *command = NULL;
[2383]	1149	char *tmp = NULL;
[2266]	1150	int res = 0;
[2383]	1151	int i = 0;
[1]	1152
[128]	1153	if (strncmp(dname, "/dev/", 5) == 0) {
	1154	dname += 5;
	1155	}
[1]	1156
[2383]	1157	tmp = call_program_and_get_last_line_of_output("/sbin/sysctl -n kern.osreldate"));
	1158	i = atoi(tmp);
	1159	mr_free(tmp);
	1160
	1161	if (i < 500000) {
[2323]	1162	mr_asprintf(command, "vnconfig -d %s", dname);
[128]	1163	} else {
[2323]	1164	mr_asprintf(command, "mdconfig -d -u %s", dname);
[128]	1165	}
[2266]	1166	res = system(command);
	1167	mr_free(command);
	1168	return(res);
[1]	1169	}
	1170	#endif
	1171
	1172
	1173	/**
	1174	* Mount the CD-ROM at @p mountpoint.
	1175	* @param device The device (or file if g_ISO_restore_mode) to mount.
	1176	* @param mountpoint The place to mount it.
	1177	* @return 0 for success, nonzero for failure.
	1178	*/
[1741]	1179	int mount_USB_here(char device, char mountpoint)
	1180	{
	1181	/@ buffer ***************************************************** */
[2266]	1182	char *command = NULL;
[1741]	1183	int retval;
	1184
	1185	assert_string_is_neither_NULL_nor_zerolength(device);
	1186	assert_string_is_neither_NULL_nor_zerolength(mountpoint);
	1187
	1188	make_hole_for_dir(mountpoint);
	1189	if (isdigit(device[0])) {
	1190	return(1);
	1191	}
[2325]	1192	log_msg(4, "(mount_USB_here --- device=%s, mountpoint=%s", device, mountpoint);
[1741]	1193
	1194	#ifdef __FreeBSD__
[2323]	1195	mr_asprintf(command, "mount_vfat %s %s 2>> %s", device, mountpoint, MONDO_LOGFILE);
[1741]	1196
	1197	#else
[2323]	1198	mr_asprintf(command, "mount %s -t vfat %s 2>> %s", device, mountpoint, MONDO_LOGFILE);
[1741]	1199	#endif
	1200
	1201	log_msg(4, command);
	1202	retval = system(command);
	1203	log_msg(1, "system(%s) returned %d", command, retval);
[2266]	1204	mr_free(command);
[1741]	1205
	1206	return (retval);
	1207	}
	1208
	1209	/**
	1210	* Mount the CD-ROM at @p mountpoint.
	1211	* @param device The device (or file if g_ISO_restore_mode) to mount.
	1212	* @param mountpoint The place to mount it.
	1213	* @return 0 for success, nonzero for failure.
	1214	*/
[2325]	1215	int mount_CDROM_here(char device, const char mountpoint)
[1]	1216	{
[128]	1217	/@ buffer ***************************************************** */
[2211]	1218	char *command = NULL;
[128]	1219	int retval;
[2257]	1220	#ifdef __FreeBSD__
	1221	char *dev = NULL;
	1222	#else
	1223	char *options = NULL;
	1224	#endif
[1]	1225
[128]	1226	assert_string_is_neither_NULL_nor_zerolength(mountpoint);
[1]	1227
[128]	1228	make_hole_for_dir(mountpoint);
[2211]	1229
[2325]	1230	if ((device == NULL) \|\| (isdigit(device[0]))) {
	1231	mr_free(device);
	1232	device = find_cdrom_device(FALSE);
[2257]	1233	}
	1234	#ifndef __FreeBSD__
[2323]	1235	mr_asprintf(options, "ro");
[2211]	1236	#endif
	1237
[128]	1238	if (g_ISO_restore_mode) {
[1]	1239
	1240	#ifdef __FreeBSD__
[2323]	1241	mr_asprintf(dev, "%s", make_vn(device));
[128]	1242	if (!dev) {
[2323]	1243	mr_asprintf(command, "Unable to mount ISO (make_vn(%s) failed)", device);
[128]	1244	fatal_error(command);
	1245	}
[2325]	1246	mr_free(device);
	1247	device = dev;
[1]	1248	#else
[2211]	1249	mr_strcat(options, ",loop");
[1]	1250	#endif
	1251
[128]	1252	}
[2325]	1253	log_msg(4, "(mount_CDROM_here --- device=%s, mountpoint=%s", device, mountpoint);
[128]	1254	/@ end vars ************************************************** */
[1]	1255
	1256	#ifdef __FreeBSD__
[2323]	1257	mr_asprintf(command, "mount_cd9660 -r %s %s 2>> %s", device, mountpoint, MONDO_LOGFILE);
[1]	1258
	1259	#else
[2323]	1260	mr_asprintf(command, "mount %s -o %s -t iso9660 %s 2>> %s", device, options, mountpoint, MONDO_LOGFILE);
[2211]	1261	paranoid_free(options);
[1]	1262	#endif
	1263
[128]	1264	log_msg(4, command);
	1265	if (strncmp(device, "/dev/", 5) == 0) {
	1266	retract_CD_tray_and_defeat_autorun();
	1267	}
	1268	retval = system(command);
	1269	log_msg(1, "system(%s) returned %d", command, retval);
[2325]	1270	mr_free(command);
[1]	1271
[128]	1272	return (retval);
[1]	1273	}
	1274
	1275
	1276
	1277
	1278
	1279
	1280	/**
	1281	* Ask the user for CD number @p cd_number_i_want.
	1282	* Sets g_current_media_number once the correct CD is inserted.
	1283	* @param bkpinfo The backup information structure. Fields used:
	1284	* - @c bkpinfo->backup_media_type
[20]	1285	* - @c bkpinfo->prefix
[1]	1286	* - @c bkpinfo->isodir
	1287	* - @c bkpinfo->media_device
	1288	* - @c bkpinfo->please_dont_eject_when_restoring
	1289	* @param cd_number_i_want The CD number to ask for.
	1290	*/
	1291	void
[1645]	1292	insist_on_this_cd_number(int cd_number_i_want)
[1]	1293	{
	1294
[128]	1295	/@ int ************************************************************ */
	1296	int res = 0;
[1]	1297
	1298
[128]	1299	/@ buffers ******************************************************** */
[2266]	1300	char *tmp = NULL;
[2242]	1301	char *mds = NULL;
[2266]	1302	char *request = NULL;
[1]	1303
[128]	1304	assert(bkpinfo != NULL);
	1305	assert(cd_number_i_want > 0);
[1]	1306
	1307	// log_msg(3, "Insisting on CD number %d", cd_number_i_want);
	1308
[128]	1309	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
	1310	log_msg(3,
	1311	"No need to insist_on_this_cd_number when the backup type isn't CD-R(W) or NFS or ISO");
	1312	return;
	1313	}
[2323]	1314	mr_asprintf(tmp, "mkdir -p " MNT_CDROM);
[128]	1315	run_program_and_log_output(tmp, 5);
[2266]	1316	mr_free(tmp);
	1317
[2382]	1318	if (g_ISO_restore_mode \|\| bkpinfo->backup_media_type == iso \|\| bkpinfo->backup_media_type == netfs) {
[2325]	1319	// BERLIOS --- I'm tempted to do something about this...
	1320	// Why unmount and remount again and again?
[128]	1321	log_msg(3, "Remounting CD");
	1322	g_ISO_restore_mode = TRUE;
	1323	if (is_this_device_mounted(MNT_CDROM)) {
	1324	run_program_and_log_output("umount " MNT_CDROM, 5);
	1325	}
[2323]	1326	mr_asprintf(tmp, "mkdir -p %s/isodir &> /dev/null", bkpinfo->tmpdir);
[2202]	1327	(void)system(tmp);
[2266]	1328	mr_free(tmp);
	1329
[2382]	1330	if (((bkpinfo->isodir == NULL) && (bkpinfo->netfs_remote_dir == NULL)) \|\| (bkpinfo->prefix == NULL)) {
[2325]	1331	fatal_error("Unable to prepare ISO file name. Please report to dev team");
	1332	}
[2382]	1333	if (bkpinfo->netfs_remote_dir) {
	1334	// NETFS
	1335	mr_asprintf(tmp, "%s/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix, cd_number_i_want);
[2325]	1336	} else {
	1337	// ISO
	1338	mr_asprintf(tmp, "%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->prefix, cd_number_i_want);
	1339	}
[128]	1340	if (!does_file_exist(tmp)) {
[2266]	1341	mr_free(tmp);
[2382]	1342	if (bkpinfo->netfs_remote_dir) {
	1343	// NETFS
	1344	mr_asprintf(tmp, "%s/isodir/%s/%s-%d.iso", bkpinfo->tmpdir, bkpinfo->netfs_remote_dir, bkpinfo->prefix, cd_number_i_want);
[2325]	1345	} else {
	1346	// ISO
	1347	mr_asprintf(tmp, "%s/isodir/%s-%d.iso", bkpinfo->tmpdir, bkpinfo->prefix, cd_number_i_want);
	1348	}
[128]	1349	if (does_file_exist(tmp)) {
[2321]	1350	log_msg(1, "FIXME - hacking bkpinfo->isodir from '%s' to %s/isodir", bkpinfo->isodir, bkpinfo->tmpdir);
[2323]	1351	mr_free(bkpinfo->isodir);
[2324]	1352	mr_asprintf(bkpinfo->isodir, "%s/isodir", bkpinfo->tmpdir);
[128]	1353	}
	1354	}
	1355	log_msg(3, "Mounting %s at %s", tmp, MNT_CDROM);
	1356	if (mount_CDROM_here(tmp, MNT_CDROM)) {
[2266]	1357	mr_free(tmp);
[128]	1358	fatal_error("Mommy!");
	1359	}
[2266]	1360	mr_free(tmp);
[1]	1361	}
[1645]	1362	if ((res = what_number_cd_is_this()) != cd_number_i_want) {
[2325]	1363	log_msg(3, "Currently, we hold %d but we want %d", res, cd_number_i_want);
[2242]	1364	mds = media_descriptor_string(bkpinfo->backup_media_type);
[2324]	1365	log_msg(3, "Insisting on %s #%d", mds, cd_number_i_want);
[2323]	1366	mr_asprintf(request, "Please insert %s #%d and press Enter.", mds, cd_number_i_want);
[2242]	1367	mr_free(mds);
[2266]	1368
[1645]	1369	while (what_number_cd_is_this() != cd_number_i_want) {
[2376]	1370	sync();
[128]	1371	if (is_this_device_mounted(MNT_CDROM)) {
	1372	res =
	1373	run_program_and_log_output("umount " MNT_CDROM, FALSE);
	1374	} else {
	1375	res = 0;
	1376	}
	1377	if (res) {
[541]	1378	log_to_screen("WARNING - failed to unmount CD-ROM drive");
[128]	1379	}
	1380	if (!bkpinfo->please_dont_eject) {
	1381	res = eject_device(bkpinfo->media_device);
	1382	} else {
	1383	res = 0;
	1384	}
	1385	if (res) {
[541]	1386	log_to_screen("WARNING - failed to eject CD-ROM disk");
[128]	1387	}
	1388	popup_and_OK(request);
	1389	if (!bkpinfo->please_dont_eject) {
	1390	inject_device(bkpinfo->media_device);
	1391	}
[2376]	1392	sync();
[128]	1393	}
[2266]	1394	mr_free(request);
	1395
[128]	1396	log_msg(1, "Thankyou. Proceeding...");
	1397	g_current_media_number = cd_number_i_want;
	1398	}
[1]	1399	}
	1400
	1401	/* @} - end of deviceGroup */
	1402
	1403
[2428]	1404
[1]	1405	/**
[2444]	1406	* Creates a singly linked list of all of the non-NETFS mounted file systems.
	1407	* @param DSFptr A pointer to the structure MOUNTED_FS_STRUCT used to hold
	1408	* the list of mounted file systems.
	1409	* @return None.
	1410	*/
	1411	static void add_mounted_fs_struct (MOUNTED_FS_STRUCT *DSFptr)
	1412	{
	1413	assert (DSFptr);
	1414	if (DSF_Head == NULL) {
	1415	DSF_Head = DSFptr;
	1416	} else {
	1417	DSF_Tail->next = DSFptr;
	1418	}
	1419	DSFptr->next = NULL;
	1420	DSF_Tail = DSFptr;
	1421	}
	1422
	1423	/**
	1424	* Find the structure, in the singly linked list of all of the non-NETFS
	1425	* mounted file systems, that contains the specified device.
	1426	* @param device The device to find
	1427	* @return NULL if it didn't find the device, a pointer to the
	1428	* structure if it did.
	1429	*/
	1430	static MOUNTED_FS_STRUCT find_device_in_list (char device)
	1431	{
	1432	MOUNTED_FS_STRUCT *DSFptr = NULL;
	1433
	1434	DSFptr = DSF_Head;
	1435	while (DSFptr != NULL) {
	1436	if (!strcmp(DSFptr->device, device)) {
	1437	break;
	1438	}
	1439	DSFptr = DSFptr->next;
	1440	}
	1441	return (DSFptr);
	1442	}
	1443
	1444	/**
	1445	* Find the structure, in the singly linked list of all of the non-NETFS
	1446	* mounted file systems, that contains the specified mount point.
	1447	* @param mount_point The mount point to find
	1448	* @return NULL is it didn't find the mount point, a pointer to the
	1449	* structure if it did.
	1450	*/
	1451	static MOUNTED_FS_STRUCT find_mount_point_in_list (char mount_point)
	1452	{
	1453	MOUNTED_FS_STRUCT *DSFptr = NULL;
	1454
	1455	DSFptr = DSF_Head;
	1456	while (DSFptr != NULL) {
	1457	if (!strcmp(DSFptr->mount_point, mount_point)) {
	1458	break;
	1459	}
	1460	DSFptr = DSFptr->next;
	1461	}
	1462	return (DSFptr);
	1463	}
	1464
	1465	/**
	1466	* Frees the memory for all of the structures on the linked list of
	1467	* all of the non-NETFS mounted file systems.
	1468	*/
	1469	static void free_mounted_fs_list (void) {
	1470	MOUNTED_FS_STRUCT *DSFptr = NULL;
	1471	MOUNTED_FS_STRUCT *DSFnext = NULL;
	1472
	1473	DSFptr = DSF_Head;
	1474	while (DSFptr != NULL) {
	1475	DSFnext = DSFptr->next;
	1476	paranoid_free(DSFptr);
	1477	DSFptr = DSFnext;
	1478	}
	1479	DSF_Head = NULL;
	1480	DSF_Tail = NULL;
	1481	}
	1482
	1483
	1484	/**
	1485	* Creates a linked list of all of the non-NETFS mounted file systems.
	1486	* We use a linked list because we don't know how many mounted file
	1487	* there are (and there can be a lot).
	1488	* @return 0 on success and greated than 0 on failure.
	1489	*/
	1490	static int create_list_of_non_NETFS_mounted_file_systems (void)
	1491	{
	1492	int i = 0;
	1493	int mount_cnt = 0;
	1494	int lastpos = 0;
	1495	char *mounted_file_system = NULL;
	1496	char *command = NULL;
	1497	char *token = NULL;
	1498	char token_chars[] =" :\t\r\f\a\0";
	1499	MOUNTED_FS_STRUCT *DSFptr = NULL;
	1500
	1501	free_mounted_fs_list();
	1502	/********
	1503	* Find the number of mounted file system entries and their respective mount points.
	1504	* I can't return all of the entries as one string because it's length can be longer
	1505	* than MAX_STR_LEN which is used in call_program_and_get_last_line_of_output().
	1506	* So start looping and get the number of mounted file systems and query them one by one.
	1507	********/
	1508	/* Get the number of mounted file systems ((those that start with "/dev/" */
	1509	mr_asprintf(command, "mount 2>/dev/null \| awk '{if($1 ~ \"^/dev/\"){print $0}}'\|wc -l");
	1510	log_msg(5, "Running: %s", command);
	1511	mounted_file_system = call_program_and_get_last_line_of_output(command);
	1512	mr_free(command);
	1513
	1514	mount_cnt = atoi(mounted_file_system);
	1515	log_msg (5, "mount_cnt: %d", mount_cnt);
	1516	mr_free(mounted_file_system);
	1517
	1518	for (i=mount_cnt; i > 0; i--) {
	1519	mr_asprintf(command, "mount 2>/dev/null \| awk '{if($1 ~ \"^/dev/\"){print $1,$3}}'\|head -n %d", i);
	1520	log_msg(5, "Running: %s", command);
	1521	mounted_file_system = call_program_and_get_last_line_of_output(command);
	1522	mr_free(command);
	1523
	1524	log_msg (5, "mounted_file_system: %s", mounted_file_system);
	1525	if ((token = mr_strtok(mounted_file_system, token_chars, &lastpos)) == NULL) {
	1526	log_msg (4, "Could not get the list of mounted file systems");
	1527	mr_free(mounted_file_system);
	1528	mr_free(token);
	1529	return (1);
	1530	}
	1531	if (token) {
	1532	log_msg (5, "token: %s", token);
	1533	}
	1534	while (token != NULL) {
	1535	log_msg (5, "token: %s", token);
	1536	if ((DSFptr = (MOUNTED_FS_STRUCT *) calloc(1, sizeof(MOUNTED_FS_STRUCT))) == NULL) {
	1537	fatal_error ("Cannot allocate memory");
	1538	}
	1539	add_mounted_fs_struct(DSFptr);
	1540	strcpy(DSFptr->device, token);
	1541	mr_free(token);
	1542	if ((token = mr_strtok(mounted_file_system, token_chars, &lastpos)) == NULL) {
	1543	log_msg (5, "Ran out of entries on the mounted file systems list");
	1544	mr_free(mounted_file_system);
	1545	mr_free(token);
	1546	return (1);
	1547	}
	1548	log_msg (5, "token: %s", token);
	1549	strcpy(DSFptr->mount_point, token);
	1550	mr_free(token);
	1551	token = mr_strtok(mounted_file_system, token_chars, &lastpos);
	1552	}
	1553	mr_free(mounted_file_system);
	1554	}
	1555	return (0);
	1556	}
	1557
	1558
	1559
	1560	/**
	1561	* Given a whole disk device special file, determine which mounted file systems
	1562	* are on the dsf's partitions and which mounted file systems are not.
	1563	* @param dsf The whole disk device special file.
	1564	* @param included_dsf_list A char pointer used to hold the list of mount points
	1565	* that are on the dsf. Memory for the array will be allocated within the function.
	1566	* @param excluded_dsf_list A char pointer used to hold the list of mount points
	1567	* that are not on the dsf. Memory for the array will be allocated within the function.
	1568	* @return 0 on success, -1 if no device special file was passed in, -2 if a device
	1569	* special file was passed in but it has no partitions on it, or 1 on failure
	1570	*/
	1571	static int get_dsf_mount_list (const char dsf, char included_dsf_list, char *excluded_dsf_list) {
	1572	int i = 0;
	1573	int c = 0;
	1574	int lastpos = 0;
	1575	char *VG = NULL;
	1576	char *tmp = NULL;
	1577	char *command = NULL;
	1578	char *partition_list = NULL;
	1579	char *partitions[64];
	1580	char *mount_list = NULL;
	1581	char *token = NULL;
	1582	char *ndsf = NULL;
	1583	char token_chars[] =" \t\r\f\a\0";
	1584	MOUNTED_FS_STRUCT *DSFptr = NULL;
	1585
	1586	memset((char *)partitions, 0, sizeof(partitions));
	1587
	1588	log_msg(5, "dsf: %s", dsf);
	1589
	1590	/********
	1591	* See if a device special file was passed in (i.e. it must start with /dev/
	1592	********/
	1593	if (strncmp(dsf, "/dev/", 5)) {
	1594	log_msg (5, "%s does not start with /dev/ and (probably) is not a device special file", dsf);
	1595	return (-1);
	1596	}
	1597	log_msg(5, " %s looks like a device special file", dsf);
	1598	/* Verify that the dsf exists */
	1599	mr_asprintf(command, "ls -al %s 2>/dev/null \| wc -l", dsf);
	1600	log_msg(5, " Executing: %s", command);
	1601	tmp = call_program_and_get_last_line_of_output(command);
	1602	mr_free(command);
	1603
	1604	log_msg(5, " Return value: %s", tmp);
	1605	c = atoi(tmp);
	1606	mr_free(tmp);
	1607
	1608	if (!c) {
	1609	log_to_screen("Cannot find device special file %s", dsf);
	1610	return (1);
	1611	}
	1612	log_msg(5, " %s device special file exists", dsf);
	1613
	1614	/* Get a list of the mounted file systems */
	1615	if (create_list_of_non_NETFS_mounted_file_systems()) {
	1616	log_to_screen ("Could not get the list of mounted file systems");
	1617	return (1);
	1618	}
	1619	log_msg (5, "Processing dsf: %s", dsf);
	1620	/********
	1621	* Get a list of the dsf's partitions. There could be no partitions on the disk
	1622	* or a dsf of a partition was passed in (e.g. /dev/sda1 instead of /dev/sda).
	1623	* Either way, it's an error.
	1624	********/
	1625	mr_asprintf(command, "parted2fdisk -l %s 2>/dev/null\|grep -E \"^/dev/\"\|awk '{printf(\"%%s \", $1)}END{print \"\"}'", dsf);
	1626	log_msg(4, "Executing: %s", command);
	1627	partition_list = call_program_and_get_last_line_of_output(command);
	1628	mr_free(command);
	1629
	1630	log_msg(4, "Partition list for %s: %s", dsf, partition_list);
	1631	if (!strlen(partition_list)) {
	1632	/* There were no partitions on the disk */
	1633	log_msg(4, "No partitions on device special file %s", dsf);
	1634	log_msg(4, "I guess it's a partiion itself");
	1635	mr_asprintf(partitions[0], "%s", dsf);
	1636	ndsf = truncate_to_drive_name(dsf);
	1637	} else {
	1638	/* Fill the partition list */
	1639	i = 0;
	1640	lastpos = 0;
	1641	while ((token = mr_strtok(partition_list, token_chars, &lastpos)) != NULL) {
	1642	log_msg (5, "Found partition: %s", token);
	1643	partitions[i++] = token;
	1644	}
	1645	mr_asprintf(ndsf, "%s", dsf);
	1646	}
	1647	mr_free(partition_list);
	1648
	1649	/* For the rest ndsf is the new dsf to deal with */
	1650	/********
	1651	* At this point, we have a list of all of the partitions on the dsf. Now try to
	1652	* see which partitions have a file system on them.
	1653	*
	1654	* Loop through each partition on the disk and:
	1655	*
	1656	* - If the partition is swap, it ignores it.
	1657	*
	1658	* - If the partition is mounted (e.g. /dev/sda1 is mounted on /boot), it adds an entry
	1659	* to the linked list, copies to it the device name and mount point, and sets check == 1.
	1660	*
	1661	* - If the partition is part of a Volume Group that has Logical Volumes mounted, it adds
	1662	* an entry to the linked list for each mounted Logical Volume in that Volume Group, copying
	1663	* to it the device name and mount point, and sets check == 1. Note that if the Volume Group
	1664	* contains more than one disk, it will still add the entry even if the Logical Volume's
	1665	* extents are not on the dsf that was passed in to the function. For example, Volume Group
	1666	* VolGroup00 contains the disks /dev/sda1 and /dev/sdb1, and the Logical Volumes LogVol01,
	1667	* which is mounted on /var and has all of its extents on /dev/sda1, and LogVol02, which is
	1668	* mounted as /usr and has all of its extents on /dev/sdb1. If you pass /dev/sda into the
	1669	* function, both /var and /usr will be archived even though /usr is actually on/dev/sdb.
	1670	*
	1671	* - If the partition is part of a Volume Group that has Logical Volumes used in a mounted
	1672	* software raid device, it adds an entry to the linked list, copies to it the software raid
	1673	* device name and mount point, and sets check == 1.
	1674	*
	1675	* - If the partition is part of a mounted software raid device, it adds an entry to the linked
	1676	* list, copies to it the software raid device name and mount point, and sets check == 1.
	1677	*
	1678	********/
	1679	for (i=0; strlen(partitions[i]); i++) {
	1680	log_msg(4, "Processing partition: %s", partitions[i]);
	1681	/* See if it's swap. If it is, ignore it. */
	1682	mr_asprintf(command, "parted2fdisk -l %s 2>/dev/null \| awk '{if(($1==\"%s\")&&(toupper($0) ~ \"SWAP\")){print $1;exit}}'", ndsf, partitions[i]);
	1683	log_msg(4, " Running: %s", command);
	1684	tmp = call_program_and_get_last_line_of_output(command);
	1685	mr_free(command);
	1686
	1687	log_msg(4, " Return value: %s", tmp);
	1688	c = strlen(tmp);
	1689	mr_free(tmp);
	1690
	1691	if (c) {
	1692	log_msg(4, "It's swap. Ignoring partition %s", partitions[i]);
	1693	continue;
	1694	}
	1695
	1696	/* It's not swap. See if we can find the mount point from the mount command. */
	1697	mr_asprintf(command, "mount 2>/dev/null \| awk '{if((NF>0)&&($1==\"%s\")){print $3}}'", partitions[i]);
	1698	tmp = call_program_and_get_last_line_of_output(command);
	1699	mr_free(command);
	1700
	1701	if (strlen(tmp)) {
	1702	log_msg(4, " %s is mounted: %s", partitions[i], tmp);
	1703	if ((DSFptr = find_mount_point_in_list(tmp)) == NULL) {
	1704	log_msg (4, "Can't find mount point %s in mounted file systems list", tmp);
	1705	mr_free(tmp);
	1706	return (1);
	1707	}
	1708	DSFptr->check = 1;
	1709	mr_free(tmp);
	1710	continue;
	1711	}
	1712	mr_free(tmp);
	1713
	1714	/* It's not swap and it's not mounted. See if it's LVM */
	1715	log_msg(4, " It's not mounted. Checking to see if it's LVM...");
	1716
	1717	/* Get the partition ID; 8e for LVM */
	1718	mr_asprintf(command, "parted2fdisk -l %s \|awk '{if($1 ~ \"^%s\"){print $5}}'", ndsf, partitions[i]);
	1719	log_msg(4, " Running: %s", command);
	1720	tmp = call_program_and_get_last_line_of_output(command);
	1721	mr_free(command);
	1722
	1723	if (strlen(tmp)) {
	1724	log_msg(4, " Partition ID: %s", tmp);
	1725	if (!strcasecmp(tmp, "8e")) {
	1726	/* It's LVM: Find the VG it's in */
	1727	log_msg(4, " It's LVM: Find the VG it's in...");
	1728	mr_asprintf(command, "pvdisplay -v %s 2>/dev/null\|grep \"VG Name\"\|awk '{print $NF}'", partitions[i]);
	1729	log_msg(4, " Running: %s", command);
	1730	VG = call_program_and_get_last_line_of_output(command);
	1731	mr_free(command);
	1732
	1733	log_msg(4, " Volume Group: %s", VG);
	1734	if (strlen(VG)) {
	1735	/* Found the Volume Group. Now find all of the VG's mount points */
	1736	log_msg(4, " Found the Volume Group. Now find all of the VG's mount points");
	1737	mr_asprintf(command, "mount 2>/dev/null\|grep -E \"/dev/mapper/%s-\|/dev/%s/\"\|awk '{printf(\"%%s \",$3)}END{print \"\"}'", VG, VG);
	1738	log_msg(4, " Running: %s", command);
	1739	mount_list = call_program_and_get_last_line_of_output(command);
	1740	mr_free(command);
	1741
	1742	log_msg(4, " VG %s mount_list: %s", VG, mount_list);
	1743	lastpos = 0;
	1744	while ((token = mr_strtok(mount_list, token_chars, &lastpos)) != NULL) {
	1745	log_msg (5, "mount point token: %s", token);
	1746	if ((DSFptr = find_mount_point_in_list(token)) == NULL) {
	1747	log_msg (4, "Can't find mount point %s in mounted file systems list", token);
	1748	mr_free(tmp);
	1749	mr_free(VG);
	1750	mr_free(token);
	1751	return (1);
	1752	}
	1753	DSFptr->check = 1;
	1754	mr_free(token);
	1755	}
	1756	/********
	1757	* Now we want to see if there are any software raid devices using
	1758	* any of the Logical Volumes on the Volume Group.
	1759	*******/
	1760	mr_free(mount_list);
	1761
	1762	mr_asprintf(command, "%s", "cat /proc/mdstat\|grep -iv Personal\|awk '{if($0~\"^.*[ ]+:\"){printf(\"/dev/%s \", $1)}}END{print \"\"}'");
	1763	log_msg (5, "Running: %s", command);
	1764	mount_list = call_program_and_get_last_line_of_output(command);
	1765	mr_free(command);
	1766
	1767	log_msg(4, " Software raid device list: %s", mount_list);
	1768	lastpos = 0;
	1769	while ((token = mr_strtok(mount_list, token_chars, &lastpos)) != NULL) {
	1770	mr_asprintf(command, "mdadm --detail %s 2>/dev/null \| grep -c %s", token, VG);
	1771	log_msg (5, "Running: %s", command);
	1772	mr_free(tmp);
	1773
	1774	tmp = call_program_and_get_last_line_of_output(command);
	1775	mr_free(command);
	1776
	1777	log_msg(4, "Number of Software raid device: %s", tmp);
	1778	c = atoi(tmp);
	1779	mr_free(tmp);
	1780
	1781	if (c) {
	1782	/* This device is on our disk */
	1783	if ((DSFptr = find_device_in_list(token)) == NULL) {
	1784	log_msg (4, "Can't find device %s in mounted file systems list", token);
	1785	mr_free(VG);
	1786	mr_free(token);
	1787	return (1);
	1788	}
	1789	DSFptr->check = 1;
	1790	}
	1791	mr_free(token);
	1792	}
	1793	mr_free(token);
	1794	mr_free(mount_list);
	1795	} else {
	1796	log_msg (4, "Error finding Volume Group for partition %s", partitions[i]);
	1797	mr_free(tmp);
	1798	return (1);
	1799	}
	1800	mr_free(tmp);
	1801	mr_free(VG);
	1802	continue;
	1803	}
	1804	} else {
	1805	log_msg (4, "Error finding partition type for the partition %s", partitions[i]);
	1806	}
	1807	mr_free(tmp);
	1808
	1809	/********
	1810	* It's not swap, mounted, or LVM. See if it's used in a software raid device.
	1811	********/
	1812	log_msg (5, "It's not swap, mounted, or LVM. See if it's used in a software raid device.");
	1813	mr_asprintf(command, "mdadm --examine %s 2>/dev/null \| awk '{if($1 == \"UUID\"){print $3}}'", partitions[i]);
	1814	log_msg(4, " Running: %s", command);
	1815	tmp = call_program_and_get_last_line_of_output(command);
	1816	mr_free(command);
	1817
	1818	if (!strlen(tmp)) {
	1819	log_msg(4, " Partition %s is not used in a non-LVM software raid device", partitions[i]);
	1820	mr_free(tmp);
	1821	continue;
	1822	}
	1823	log_msg (5, " UUID: %s", tmp);
	1824
	1825	/* Get the Software raid device list */
	1826	mr_asprintf(command, "%s", "cat /proc/mdstat\|grep -iv Personal\|awk '{if($0~\"^.*[ ]+:\"){printf(\"/dev/%s \", $1)}}END{print \"\"}'");
	1827	log_msg (5, " Running: %s", command);
	1828	mount_list = call_program_and_get_last_line_of_output(command);
	1829	mr_free(command);
	1830	:w!
	1831	log_msg(4, " Software raid device list: %s", mount_list);
	1832	/* Loop through the software raid device list to see if we can find the partition */
	1833	lastpos = 0;
	1834	while ((token = mr_strtok(mount_list, token_chars, &lastpos)) != NULL) {
	1835	mr_asprintf(command, "mdadm --detail %s 2>/dev/null \| grep -c %s", token, tmp);
	1836	log_msg(4, " Running: %s", command);
	1837	mr_free(tmp);
	1838
	1839	tmp = call_program_and_get_last_line_of_output(command);
	1840	mr_free(command);
	1841
	1842	c = atoi(tmp);
	1843	mr_free(tmp);
	1844
	1845	if (!c) {
	1846	log_msg (4," Didn't find partition %s in software raid device %s", partitions[i], token);
	1847	} else {
	1848	if ((DSFptr = find_device_in_list(token)) == NULL) {
	1849	log_msg (4, "Can't find device %s in mounted file systems list", token);
	1850	mr_free(token);
	1851	return (1);
	1852	}
	1853	DSFptr->check = 1;
	1854	break;
	1855	}
	1856	mr_free(token);
	1857	}
	1858	mr_free(tmp);
	1859	mr_free(mount_list);
	1860	mr_free(partitions[i]);
	1861	}
	1862
	1863	/* Determine how much memory to allocate for included_dsf_list and excluded_dsf_list */
	1864	i = 0;
	1865	DSFptr= DSF_Head;
	1866	while (DSFptr != NULL) {
	1867	i += strlen(DSFptr->mount_point) + 1;
	1868	DSFptr = DSFptr->next;
	1869	}
	1870	log_msg (5, "i: %d", i);
	1871	if ((included_dsf_list = (char ) calloc(i+100, sizeof(char))) == NULL) {
	1872	fatal_error ("Cannot allocate memory");
	1873	}
	1874	if ((excluded_dsf_list = (char ) calloc(i+100, sizeof(char))) == NULL) {
	1875	fatal_error ("Cannot allocate memory");
	1876	}
	1877	DSFptr= DSF_Head;
	1878	while (DSFptr != NULL) {
	1879	if (DSFptr->check) {
	1880	log_msg (5, "%s is mounted on %s and is on disk %s\n", DSFptr->device, DSFptr->mount_point, ndsf);
	1881	strcat(*included_dsf_list, DSFptr->mount_point);
	1882	strcat(*included_dsf_list, " ");
	1883	} else {
	1884	log_msg (4, "%s is mounted on %s and is NOT on disk %s\n", DSFptr->device, DSFptr->mount_point, ndsf);
	1885	strcat(*excluded_dsf_list, DSFptr->mount_point);
	1886	strcat(*excluded_dsf_list, " ");
	1887	}
	1888	DSFptr = DSFptr->next;
	1889	}
	1890	mr_free(ndsf);
	1891
	1892	log_msg (5, "included_dsf_list: %s", *included_dsf_list);
	1893	log_msg (5, "excluded_dsf_list: %s", *excluded_dsf_list);
	1894	return (0);
	1895	}
	1896
	1897
	1898	/* Update the bkpinfo structure for exclude & include paths
	1899	* in order to handle correctly paths corresponding to devices */
	1900	void mr_make_devlist_from_pathlist(char *pathlist, char mode) {
	1901
	1902	char *token = NULL;
	1903	int lastpos = 0;
	1904	char *mounted_on_dsf = NULL;
	1905	char *not_mounted_on_dsf = NULL;
	1906	char token_chars[] =" \t\r\f\a\0";
	1907
	1908	while ((token = mr_strtok(pathlist, token_chars, &lastpos)) != NULL) {
	1909	switch (get_dsf_mount_list(token, &mounted_on_dsf, &not_mounted_on_dsf)) {
	1910	case 1:
	1911	if (mode == 'E') {
	1912	log_msg(1, "WARNING ! %s doesn't exist in -E option", token);
	1913	} else {
	1914	fatal_error("Error processing -I option");
	1915	}
	1916	break;
	1917	/* Everything is OK; proceed to archive data */
	1918	case 0:
	1919	if (mode == 'E') {
	1920	if (strlen(mounted_on_dsf)) {
	1921	log_to_screen("Excluding the following file systems on %s:\n", token);
	1922	log_to_screen(" %s\n", mounted_on_dsf);
	1923	log_msg (5, "Adding to bkpinfo->exclude_paths due to -E option: %s", mounted_on_dsf);
	1924	mr_strcat(bkpinfo->exclude_paths, "%s ", mounted_on_dsf);
	1925	mr_strcat(bkpinfo->exclude_devs, " %s ", token);
	1926	} else {
	1927	log_to_screen("Archiving only the following file systems on %s:\n", token);
	1928	log_to_screen(" %s\n", mounted_on_dsf);
	1929	mr_asprintf(bkpinfo->include_paths, "/");
	1930	if (strlen(not_mounted_on_dsf)) {
	1931	log_msg (5, "Adding to bkpinfo->exclude_paths due to -I option: %s", not_mounted_on_dsf);
	1932	log_to_screen("Not archiving the following file systems:\n");
	1933	log_to_screen(" %s\n", not_mounted_on_dsf);
	1934	mr_strcat(bkpinfo->exclude_paths, "%s ", not_mounted_on_dsf);
	1935	}
	1936	}
	1937	}
	1938	break;
	1939	/* It's a dsf but not a whole disk dsf */
	1940	case -2:
	1941	log_to_screen("Could %s be a partition instead of a whole disk device special file?\nIgnored.", token);
	1942	break;
	1943	/* A device special file was not passed in. Process it as a path. */
	1944	case -1:
	1945	if (mode == 'E') {
	1946	mr_strcat(bkpinfo->exclude_paths, "%s ", token);
	1947	} else {
	1948	mr_strcat(bkpinfo->include_paths, "%s ", token);
	1949	}
	1950	break;
	1951	}
	1952	mr_free(token);
	1953
	1954	if (bkpinfo->include_paths != NULL) {
	1955	mr_strip_spaces(bkpinfo->include_paths);
	1956	log_msg(1, "include_paths is now '%s'", bkpinfo->include_paths);
	1957	}
	1958	if (bkpinfo->exclude_paths != NULL) {
	1959	mr_strip_spaces(bkpinfo->exclude_paths);
	1960	log_msg(1, "exclude_paths is now '%s'", bkpinfo->exclude_paths);
	1961	}
	1962	if (bkpinfo->exclude_devs != NULL) {
	1963	mr_strip_spaces(bkpinfo->exclude_devs);
	1964	log_msg(1, "exclude_devs is now '%s'", bkpinfo->exclude_devs);
	1965	}
	1966	}
	1967	}
	1968
	1969
	1970	/**
[2428]	1971	* @addtogroup utilityGroup
	1972	* @{
	1973	*/
	1974	/**
	1975	* Get a space-separated list of NETFS devices and mounts.
	1976	* @return The list created.
	1977	* @note The return value points to static data that will be overwritten with each call.
	1978	*/
	1979	char *list_of_NETFS_devices_and_mounts(void)
	1980	{
	1981	char *exclude_these_devices = NULL;
	1982	char *exclude_these_directories = NULL;
	1983	static char result_sz[1024];
	1984
	1985	mr_asprintf(exclude_these_directories,"%s",list_of_NETFS_mounts_only());
	1986	exclude_these_devices = call_program_and_get_last_line_of_output("tr -s '\t' ' ' < /etc/fstab \| grep -E '( (coda\|ncpfs\|sshfs\|nfs\|nfs4\|smbfs\|cifs\|afs\|gfs\|ocfs\|ocfs2\|mvfs\|nsspool\|nsvol) )' \| cut -d' ' -f1 \| tr -s '\n' ' ' \| awk '{print $0;}'");
	1987	snprintf(result_sz, 1023, "%s %s", exclude_these_directories, exclude_these_devices);
	1988	mr_free(exclude_these_devices);
	1989	mr_free(exclude_these_directories);
	1990	return (result_sz);
	1991	}
	1992
	1993
	1994
	1995
	1996	/**
	1997	* Get a space-separated list of NETFS mounts.
	1998	* @return The list created.
	1999	* @note The return value points to static data that will be overwritten with each call.
	2000	* @bug Even though we only want the mounts, the devices are still checked.
	2001	*/
	2002	char *list_of_NETFS_mounts_only(void)
	2003	{
	2004	char *exclude_these_directories = NULL;
	2005	static char result_sz[512];
	2006
	2007	exclude_these_directories = call_program_and_get_last_line_of_output("mount -t coda,ncpfs,fuse.sshfs,nfs,nfs4,smbfs,cifs,afs,gfs,ocfs,ocfs2,mvfs,nsspool,nssvol \| tr -s '\t' ' ' \| cut -d' ' -f3 \| tr -s '\n' ' ' \| awk '{print $0;}'");
	2008	snprintf(result_sz, 511, "%s", exclude_these_directories);
	2009	mr_free(exclude_these_directories);
	2010	return (result_sz);
	2011	}
	2012
	2013	/* @} - end of utilityGroup */
	2014
	2015
	2016
	2017
	2018
	2019	/**
	2020	* Create a randomly-named FIFO. The format is @p stub "." [random] [random] where
	2021	* [random] is a random number between 1 and 32767.
	2022	* @param store_name_here Where to store the new filename.
	2023	* @param stub A random number will be appended to this to make the FIFO's name.
	2024	* @ingroup deviceGroup
	2025	*/
	2026	void make_fifo(char store_name_here, char stub)
	2027	{
	2028	char *tmp = NULL;
	2029
	2030	assert_string_is_neither_NULL_nor_zerolength(stub);
	2031
	2032	sprintf(store_name_here, "%s%d%d", stub, (int) (random() % 32768),
	2033	(int) (random() % 32768));
	2034	make_hole_for_file(store_name_here);
	2035	mkfifo(store_name_here, S_IRWXU \| S_IRWXG);
	2036	mr_asprintf(tmp, "chmod 770 %s", store_name_here);
	2037	paranoid_system(tmp);
	2038	mr_free(tmp);
	2039	}
	2040
	2041
	2042
	2043
	2044
	2045
	2046	/**
	2047	* Set the tmpdir and scratchdir to reside on the partition with the most free space.
	2048	* Automatically excludes DOS, NTFS, SMB, and NFS filesystems.
	2049	* @param bkpinfo The backup information structure. @c bkpinfo->tmpdir and @c bkpinfo->scratchdir will be set.
	2050	* @ingroup utilityGroup
	2051	*/
	2052	void sensibly_set_scratchdir()
	2053	{
	2054	char *tmp = NULL;
	2055	char *command = NULL;
	2056	char *sz = NULL;
	2057
	2058	#ifdef __FreeBSD__
	2059	tmp = call_program_and_get_last_line_of_output("LANGUAGE=C df -m -P -t nonfs,msdosfs,ntfs,ntfs-3g,smbfs,smb,cifs,afs,gfs,ocfs,ocfs2,mvfs,nsspool,nssvol \| grep -vE \"none\|Filesystem\" \| awk '{printf \"%s %s\\n\", $4, $6;}' \| sort -n \| tail -n1 \| awk '{print $NF;}'");
	2060	#else
[2444]	2061	tmp = call_program_and_get_last_line_of_output("LANGUAGE=C df -m -P -x nfs -x nfs4 -x fuse.sshfs -x fuse -x vfat -x ntfs -x ntfs-3g -x smbfs -x smb -x cifs -x afs -x gfs -x ocfs -x ocfs2 -x mvfs -x nsspool -x nssvol -x iso9660 \| grep -vE \"none\|Filesystem\|/dev/shm\" \| awk '{printf \"%s %s\\n\", $4, $6;}' \| sort -n \| tail -n1 \| awk '{print $NF;}'");
[2428]	2062	#endif
	2063
	2064	if (tmp[0] != '/') {
	2065	mr_asprintf(sz, "%s", tmp);
	2066	mr_free(tmp);
	2067	mr_asprintf(tmp, "/%s", sz);
	2068	mr_free(sz);
	2069	}
	2070	if (!tmp[0]) {
	2071	fatal_error("I couldn't figure out the scratchdir!");
	2072	}
	2073
	2074	/* Cleaning a potential previous scratchdir */
	2075	if (bkpinfo->scratchdir) {
	2076	mr_asprintf(command, "rm -Rf %s", bkpinfo->scratchdir);
	2077	paranoid_system(command);
	2078	mr_free(command);
	2079	}
	2080	mr_free(bkpinfo->scratchdir);
	2081
	2082	mr_asprintf(bkpinfo->scratchdir , "%s/mondo.scratch.%d", tmp, (int) (random() % 32768));
	2083	log_it("bkpinfo->scratchdir is being set to %s", bkpinfo->scratchdir);
	2084
	2085	/* Cleaning potential previous scratchdir */
	2086	mr_asprintf(command, "rm -Rf %s/mondo.scratch.*", tmp);
	2087	mr_free(tmp);
	2088
	2089	paranoid_system(command);
	2090	mr_free(command);
	2091	}
	2092
	2093
	2094
	2095
	2096
	2097
	2098	/**
	2099	* @addtogroup deviceGroup
	2100	* @{
	2101	*/
	2102	/**
	2103	* If we can read @p dev, set @return output to it.
	2104	* If @p dev cannot be read, set @p output to NULL.
	2105	* @param dev The device to check for.
	2106	* @return output Set to @p dev if @p dev exists, NULL otherwise.
	2107	*/
	2108	char set_dev_to_this_if_rx_OK(char dev)
	2109	{
	2110	char *command = NULL;
	2111	char *output = NULL;
	2112
	2113	if (!dev \|\| dev[0] == '\0') {
	2114	return(NULL);
	2115	}
	2116	log_msg(10, "Injecting %s", dev);
	2117	inject_device(dev);
	2118	if (!does_file_exist(dev)) {
	2119	log_msg(10, "%s doesn't exist. Returning FALSE.", dev);
	2120	return(NULL);
	2121	}
	2122	mr_asprintf(command, "dd bs=%ld count=1 if=%s of=/dev/null &> /dev/null", 512L, dev);
	2123	if (!run_program_and_log_output(command, FALSE)
	2124	&& !run_program_and_log_output(command, FALSE)) {
	2125	mr_asprintf(output, "%s", dev);
	2126	log_msg(4, "Found it - %s", dev);
	2127	} else {
	2128	log_msg(4, "It's not %s", dev);
	2129	}
	2130	mr_free(command);
	2131	return(output);
	2132	}
	2133
	2134
	2135
	2136
	2137
	2138	/**
	2139	* Find out what number CD is in the drive.
	2140	* @param bkpinfo The backup information structure. The @c bkpinfo->media_device field is the only one used.
	2141	* @return The current CD number, or -1 if it could not be found.
	2142	* @note If the CD is not mounted, it will be mounted
	2143	* (and remain mounted after this function returns).
	2144	*/
	2145	int what_number_cd_is_this()
	2146	{
	2147	int cd_number = -1;
	2148	char *mountdev = NULL;
	2149	char *tmp = NULL;
	2150
	2151	assert(bkpinfo != NULL);
	2152	// log_it("Asking what_number_cd_is_this");
	2153	if (g_ISO_restore_mode) {
	2154	mr_asprintf(tmp, "mount \| grep iso9660 \| awk '{print $3;}'");
	2155	mountdev = call_program_and_get_last_line_of_output(tmp);
	2156	mr_strcat(mountdev, "/archives/THIS-CD-NUMBER");
	2157	mr_free(tmp);
	2158
	2159	tmp = last_line_of_file(mountdev);
	2160	cd_number = atoi(tmp);
	2161	mr_free(tmp);
	2162	mr_free(mountdev);
	2163	return (cd_number);
	2164	}
	2165
	2166	if (bkpinfo->media_device) {
	2167	mr_asprintf(mountdev, "%s", bkpinfo->media_device);
	2168	}
	2169	if (!mountdev) {
	2170	log_it("(what_number_cd_is_this) Warning - media_device unknown. Finding out...");
	2171	mr_free(bkpinfo->media_device);
	2172	bkpinfo->media_device = find_cdrom_device(FALSE);
	2173	mr_asprintf(mountdev, "%s", bkpinfo->media_device);
	2174	}
	2175	if (!is_this_device_mounted(MNT_CDROM)) {
	2176	if (bkpinfo->backup_media_type == usb) {
	2177	mount_USB_here(mountdev, MNT_CDROM);
	2178	} else {
	2179	mount_CDROM_here(mountdev, MNT_CDROM);
	2180	}
	2181	}
	2182	mr_free(mountdev);
	2183
	2184	tmp = last_line_of_file(MNT_CDROM "/archives/THIS-CD-NUMBER");
	2185	cd_number = atoi(tmp);
	2186	mr_free(tmp);
	2187	return (cd_number);
	2188	}
	2189
	2190
	2191
	2192
	2193
	2194
	2195
	2196	/**
	2197	* Find out what device is mounted as root (/).
	2198	* @return Root device.
	2199	* @note The returned string points to static storage and will be overwritten with every call.
	2200	* @bug A bit of a misnomer; it's actually finding out the root device.
	2201	* The mountpoint (where it's mounted) will obviously be '/'.
	2202	*/
	2203	char *where_is_root_mounted() {
	2204	/@ buffers *************** */
	2205	char *output = NULL;
	2206
	2207
	2208	#ifdef __FreeBSD__
	2209	output = call_program_and_get_last_line_of_output("mount \| grep ' on / ' \| cut -d' ' -f1");
	2210	#else
	2211	output = call_program_and_get_last_line_of_output("mount \| grep ' on / ' \| cut -d' ' -f1 \| sed 's/[0-9]//' \| sed 's/[0-9]//'");
	2212	if (strstr(output, "/dev/cciss/")) {
	2213	mr_free(output);
	2214	output = call_program_and_get_last_line_of_output("mount \| grep ' on / ' \| cut -d' ' -f1 \| cut -dp -f1");
	2215	}
	2216	if (strstr(output, "/dev/md")) {
	2217	mr_free(output);
	2218	output = call_program_and_get_last_line_of_output("mount \| grep ' on / ' \| cut -d' ' -f1");
	2219	}
	2220	#endif
	2221
	2222	return (output);
	2223	}
	2224
	2225
	2226	/**
	2227	* Find out which boot loader is in use.
	2228	* @param which_device Device to look for the boot loader on.
	2229	* @return 'L' for LILO, 'E'for ELILO, 'G' for GRUB, 'B' or 'D' for FreeBSD boot loaders, or 'U' for Unknown.
	2230	* @note Under Linux, all drives are examined, not just @p which_device.
	2231	*/
	2232	#ifdef __FreeBSD__
	2233	char which_boot_loader(char *which_device) {
	2234	int count_lilos = 0;
	2235	int count_grubs = 0;
	2236	int count_boot0s = 0;
	2237	int count_dangerouslydedicated = 0;
	2238
	2239	log_it("looking at drive %s's MBR", which_device);
	2240	if (does_string_exist_in_boot_block(which_device, "GRUB")) {
	2241	count_grubs++;
	2242	}
	2243	if (does_string_exist_in_boot_block(which_device, "LILO")) {
	2244	count_lilos++;
	2245	}
	2246	if (does_string_exist_in_boot_block(which_device, "Drive")) {
	2247	count_boot0s++;
	2248	}
	2249	if (does_string_exist_in_first_N_blocks(which_device, "FreeBSD/i386", 17)) {
	2250	count_dangerouslydedicated++;
	2251	}
	2252	log_it("%d grubs and %d lilos and %d elilos and %d boot0s and %d DD\n",
	2253	count_grubs, count_lilos, count_elilos, count_boot0s,
	2254	count_dangerouslydedicated);
	2255
	2256	if (count_grubs && !count_lilos) {
	2257	return ('G');
	2258	} else if (count_lilos && !count_grubs) {
	2259	return ('L');
	2260	} else if (count_grubs == 1 && count_lilos == 1) {
	2261	log_it("I'll bet you used to use LILO but switched to GRUB...");
	2262	return ('G');
	2263	} else if (count_boot0s == 1) {
	2264	return ('B');
	2265	} else if (count_dangerouslydedicated) {
	2266	return ('D');
	2267	} else {
	2268	log_it("Unknown boot loader");
	2269	return ('U');
	2270	}
	2271	}
	2272
	2273	#else
	2274
	2275	char which_boot_loader(char *which_device) {
	2276	/@ buffer **************************************************** */
	2277	char *list_drives_cmd = NULL;
	2278	char *tmp = NULL;
	2279	char *current_drive = NULL;
	2280
	2281	/@ pointers ************************************************** */
	2282	FILE *pdrives = NULL;
	2283
	2284	/@ int ******************************************************* */
	2285	int count_lilos = 0;
	2286	int count_grubs = 0;
	2287
	2288	/@ end vars ************************************************** */
	2289
	2290
	2291	#ifdef __IA64__
	2292	/* No choice for it */
	2293	return ('E');
	2294	#endif
	2295
	2296	tmp = where_is_root_mounted();
	2297	mr_asprintf(list_drives_cmd, "parted2fdisk -l 2>/dev/null \| grep \"/dev/.*:\" \| tr -s ':' ' ' \| tr -s ' ' '\n' \| grep /dev/; echo %s", tmp);
	2298	mr_free(tmp);
	2299	log_it("list_drives_cmd = %s", list_drives_cmd);
	2300
	2301	pdrives = popen(list_drives_cmd, "r");
	2302	mr_free(list_drives_cmd);
	2303
	2304	if (!pdrives) {
	2305	log_OS_error("Unable to open list of drives");
	2306	return ('\0');
	2307	}
	2308
	2309	for (mr_getline(current_drive, pdrives); !feof(pdrives); mr_getline(current_drive, pdrives)) {
	2310	mr_strip_spaces(current_drive);
	2311	log_it("looking at drive %s's MBR", current_drive);
	2312	if (does_string_exist_in_boot_block(current_drive, "GRUB")) {
	2313	count_grubs++;
	2314	/* BERLIOS : removed as I don't think it's mandatory here
	2315	mr_free(which_device);
	2316	mr_asprintf(which_device, "%s", current_drive);
	2317	*/
	2318	mr_free(current_drive);
	2319	break;
	2320	}
	2321	if (does_string_exist_in_boot_block(current_drive, "LILO")) {
	2322	count_lilos++;
	2323	/* BERLIOS : removed as I don't think it's mandatory here
	2324	mr_free(which_device);
	2325	mr_asprintf(which_device, "%s", current_drive);
	2326	*/
	2327	mr_free(current_drive);
	2328	break;
	2329	}
	2330	mr_free(current_drive);
	2331	}
	2332	mr_free(current_drive);
	2333
	2334	if (pclose(pdrives)) {
	2335	log_OS_error("Cannot pclose pdrives");
	2336	}
	2337	log_it("%d grubs and %d lilos\n", count_grubs, count_lilos);
	2338	if (count_grubs && !count_lilos) {
	2339	return ('G');
	2340	} else if (count_lilos && !count_grubs) {
	2341	return ('L');
	2342	} else if (count_grubs == 1 && count_lilos == 1) {
	2343	log_it("I'll bet you used to use LILO but switched to GRUB...");
	2344	return ('G');
	2345	} else {
	2346	// We need to look on each partition then
	2347	mr_asprintf(list_drives_cmd, "parted2fdisk -l 2>/dev/null \| grep -E \"^/dev/\" \| tr -s ':' ' ' \| tr -s ' ' '\n' \| grep /dev/");
	2348	log_it("list_drives_cmd = %s", list_drives_cmd);
	2349
	2350	if (!(pdrives = popen(list_drives_cmd, "r"))) {
	2351	log_OS_error("Unable to open list of drives");
	2352	mr_free(list_drives_cmd);
	2353	return ('\0');
	2354	}
	2355	mr_free(list_drives_cmd);
	2356
	2357	for (mr_getline(current_drive, pdrives); !feof(pdrives); mr_getline(current_drive, pdrives)) {
	2358	mr_strip_spaces(current_drive);
	2359	log_it("looking at partition %s's BR", current_drive);
	2360	if (does_string_exist_in_boot_block(current_drive, "GRUB")) {
	2361	count_grubs++;
	2362	/* BERLIOS : removed as I don't think it's mandatory here
	2363	mr_free(which_device);
	2364	mr_asprintf(which_device, "%s", current_drive);
	2365	*/
	2366	mr_free(current_drive);
	2367	break;
	2368	}
	2369	if (does_string_exist_in_boot_block(current_drive, "LILO")) {
	2370	count_lilos++;
	2371	/* BERLIOS : removed as I don't think it's mandatory here
	2372	mr_free(which_device);
	2373	mr_asprintf(which_device, "%s", current_drive);
	2374	*/
	2375	mr_free(current_drive);
	2376	break;
	2377	}
	2378	mr_free(current_drive);
	2379	}
	2380	mr_free(current_drive);
	2381
	2382	if (pclose(pdrives)) {
	2383	log_OS_error("Cannot pclose pdrives");
	2384	}
	2385	log_it("%d grubs and %d lilos\n", count_grubs, count_lilos);
	2386	if (count_grubs && !count_lilos) {
	2387	return ('G');
	2388	} else if (count_lilos && !count_grubs) {
	2389	return ('L');
	2390	} else if (count_grubs == 1 && count_lilos == 1) {
	2391	log_it("I'll bet you used to use LILO but switched to GRUB...");
	2392	return ('G');
	2393	} else {
	2394	log_it("Unknown boot loader");
	2395	return ('U');
	2396	}
	2397	}
	2398	}
	2399	#endif
	2400
	2401
	2402
	2403
	2404	/**
	2405	* Write zeroes over the first 16K of @p device.
	2406	* @param device The device to zero.
	2407	* @return 0 for success, 1 for failure.
	2408	*/
	2409	int zero_out_a_device(char *device)
	2410	{
	2411	FILE *fout;
	2412	int i;
	2413
	2414	assert_string_is_neither_NULL_nor_zerolength(device);
	2415
	2416	log_it("Zeroing drive %s", device);
	2417	if (!(fout = fopen(device, "w"))) {
	2418	log_OS_error("Unable to open/write to device");
	2419	return (1);
	2420	}
	2421	for (i = 0; i < 16384; i++) {
	2422	fputc('\0', fout);
	2423	}
	2424	paranoid_fclose(fout);
	2425	log_it("Device successfully zeroed.");
	2426	return (0);
	2427	}
	2428
	2429	/**
	2430	* Return the device pointed to by @p incoming.
	2431	* @param incoming The device to resolve symlinks for.
	2432	* @return The path to the real device file.
	2433	* @note The returned string points to static storage that will be overwritten with each call.
	2434	* @bug Won't work with file v4.0; needs to be written in C.
	2435	*/
	2436	char resolve_softlinks_to_get_to_actual_device_file(char incoming)
	2437	{
	2438	char *output;
	2439	char *command = NULL;
	2440	char *curr_fname;
	2441	char *scratch = NULL;
	2442	char *tmp = NULL;
	2443	char *p;
	2444
	2445	struct stat statbuf;
	2446	malloc_string(curr_fname);
	2447	if (!does_file_exist(incoming)) {
	2448	log_it("resolve_softlinks_to_get_to_actual_device_file --- device not found");
	2449	mr_asprintf(output, "%s", incoming);
	2450	} else {
	2451	strcpy(curr_fname, incoming);
	2452	lstat(curr_fname, &statbuf);
	2453	while (S_ISLNK(statbuf.st_mode)) {
	2454	log_msg(1, "curr_fname = %s", curr_fname);
	2455	mr_asprintf(command, "file %s", curr_fname);
	2456	tmp = call_program_and_get_last_line_of_output(command);
	2457	mr_free(command);
	2458	for (p = tmp + strlen(tmp); p != tmp && p != '`' && p != ' '; p--);
	2459	p++;
	2460	mr_asprintf(scratch, "%s", p);
	2461	for (p = scratch; p != '\0' && p != '\''; p++);
	2462	*p = '\0';
	2463	log_msg(0, "curr_fname %s --> '%s' --> %s", curr_fname, tmp, scratch);
	2464	mr_free(tmp);
	2465
	2466	if (scratch[0] == '/') {
	2467	strcpy(curr_fname, scratch); // copy whole thing because it's an absolute softlink
	2468	} else { // copy over the basename cos it's a relative softlink
	2469	p = curr_fname + strlen(curr_fname);
	2470	while (p != curr_fname && *p != '/') {
	2471	p--;
	2472	}
	2473	if (*p == '/') {
	2474	p++;
	2475	}
	2476	strcpy(p, scratch);
	2477	}
	2478	mr_free(scratch);
	2479	lstat(curr_fname, &statbuf);
	2480	}
	2481	mr_asprintf(output, "%s", curr_fname);
	2482	log_it("resolved %s to %s", incoming, output);
	2483	}
	2484	paranoid_free(curr_fname);
	2485	return (output);
	2486	}
	2487
	2488	/* @} - end of deviceGroup */
	2489
	2490	/**
	2491	* Return the type of partition format (GPT or MBR)
	2492	*/
	2493	char which_partition_format(const char drive)
	2494	{
	2495	char *output;
	2496	char *tmp = NULL;
	2497	char *command = NULL;
	2498	char *fdisk = NULL;
	2499	#ifdef __IA64__
	2500	struct stat buf;
	2501	#endif
	2502	mr_asprintf(fdisk, "/sbin/parted2fdisk");
	2503	mr_asprintf(command, "%s -l %s \| grep 'EFI GPT'", fdisk, drive);
	2504	mr_free(fdisk);
	2505
	2506	tmp = call_program_and_get_last_line_of_output(command);
	2507	mr_free(command);
	2508
	2509	if (strstr(tmp, "GPT") == NULL) {
	2510	mr_asprintf(output, "MBR");
	2511	} else {
	2512	mr_asprintf(output, "GPT");
	2513	}
	2514	mr_free(tmp);
	2515
	2516	log_msg(0, "Found %s partition table format type", output);
	2517	return (output);
	2518	}
	2519
	2520	/**
[1]	2521	* Ask user for details of backup/restore information.
	2522	* Called when @c mondoarchive doesn't get any parameters.
	2523	* @param bkpinfo The backup information structure to fill out with the user's data.
	2524	* @param archiving_to_media TRUE if archiving, FALSE if restoring.
	2525	* @return 0, always.
	2526	* @bug No point of `int' return value.
	2527	* @ingroup archiveGroup
	2528	*/
[1645]	2529	int interactively_obtain_media_parameters_from_user(bool archiving_to_media)
[1]	2530	// archiving_to_media is TRUE if I'm being called by mondoarchive
	2531	// archiving_to_media is FALSE if I'm being called by mondorestore
	2532	{
[2214]	2533	char *tmp = NULL;
[2316]	2534	char *p = NULL;
[2242]	2535	char *mds = NULL;
[2266]	2536	char *sz_size = NULL;
	2537	char *command = NULL;
	2538	char *comment = NULL;
[128]	2539	int i;
	2540	FILE *fin;
[1]	2541
[128]	2542	assert(bkpinfo != NULL);
	2543	bkpinfo->nonbootable_backup = FALSE;
[1]	2544
[2382]	2545	// Tape, CD, NETFS, ...?
[128]	2546	srandom(getpid());
	2547	bkpinfo->backup_media_type =
	2548	(g_restoring_live_from_cd) ? cdr :
	2549	which_backup_media_type(bkpinfo->restore_data);
	2550	if (bkpinfo->backup_media_type == none) {
[541]	2551	log_to_screen("User has chosen not to backup the PC");
[128]	2552	finish(1);
	2553	}
[1934]	2554	/* Why asking to remove the media with tape ?
[128]	2555	if (bkpinfo->backup_media_type == tape && bkpinfo->restore_data) {
[1885]	2556	popup_and_OK("Please remove media from drive(s)");
[128]	2557	}
[1934]	2558	*/
[2330]	2559	tmp = bkptype_to_string(bkpinfo->backup_media_type);
	2560	log_msg(3, "media type = %s", tmp);
	2561	mr_free(tmp);
	2562
[128]	2563	bkpinfo->cdrw_speed = (bkpinfo->backup_media_type == cdstream) ? 2 : 4;
[2330]	2564	bkpinfo->compression_level = (bkpinfo->backup_media_type == cdstream) ? 1 : 5;
	2565	bkpinfo->use_lzo = (bkpinfo->backup_media_type == cdstream) ? TRUE : FALSE;
[128]	2566	mvaddstr_and_log_it(2, 0, " ");
[1]	2567
[1934]	2568	// Find device's /dev (or SCSI) entry
[128]	2569	switch (bkpinfo->backup_media_type) {
	2570	case cdr:
	2571	case cdrw:
	2572	case dvd:
[1687]	2573	case usb:
[1745]	2574	/* Never try to eject a USB device */
	2575	if (bkpinfo->backup_media_type == usb) {
[1746]	2576	bkpinfo->please_dont_eject = TRUE;
[1745]	2577	}
[128]	2578	if (archiving_to_media) {
[1687]	2579	if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
[2405]	2580	if (ask_me_yes_or_no("Is your computer a laptop, or does the CD writer incorporate BurnProof technology?")) {
[685]	2581	bkpinfo->manual_cd_tray = TRUE;
	2582	}
[128]	2583	}
[2405]	2584	if ((bkpinfo->compression_level = which_compression_level()) == -1) {
[541]	2585	log_to_screen("User has chosen not to backup the PC");
[128]	2586	finish(1);
	2587	}
[2242]	2588	mds = media_descriptor_string(bkpinfo->backup_media_type);
[2323]	2589	mr_asprintf(comment, "What speed is your %s (re)writer?", mds);
[2325]	2590	mr_free(bkpinfo->media_device);
[128]	2591	if (bkpinfo->backup_media_type == dvd) {
[2325]	2592	bkpinfo->media_device = find_dvd_device();
[2323]	2593	mr_asprintf(tmp, "1");
	2594	mr_asprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE); // 4.7 salesman's GB = 4.482 real GB = 4482 MB
[128]	2595	log_msg(1, "Setting to DVD defaults");
	2596	} else {
[2325]	2597	mr_asprintf(bkpinfo->media_device, "%s", VANILLA_SCSI_CDROM);
[2323]	2598	mr_asprintf(tmp, "4");
	2599	mr_asprintf(sz_size, "%d", 650);
[128]	2600	log_msg(1, "Setting to CD defaults");
	2601	}
[1687]	2602	if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
[2316]	2603	p = popup_and_get_string("Speed", comment, tmp);
	2604	mr_free(tmp);
	2605
	2606	if (p == NULL) {
[541]	2607	log_to_screen("User has chosen not to backup the PC");
[2266]	2608	mr_free(comment);
[128]	2609	finish(1);
	2610	}
[2316]	2611	/* tmp now has the new value given by the user */
	2612	tmp = p;
[128]	2613	}
[2266]	2614	mr_free(comment);
	2615
[2405]	2616	bkpinfo->cdrw_speed = atoi(tmp); // if DVD then this shouldn't ever be used anyway :)
	2617	mr_free(tmp);
[2214]	2618
[2323]	2619	mr_asprintf(comment, "How much data (in Megabytes) will each %s store?", mds);
[2242]	2620	mr_free(mds);
[2316]	2621	p = popup_and_get_string("Size", comment, sz_size);
	2622	mr_free(sz_size);
	2623	mr_free(comment);
	2624
	2625	if (p == NULL) {
[541]	2626	log_to_screen("User has chosen not to backup the PC");
[128]	2627	finish(1);
	2628	}
[2316]	2629	sz_size = p;
[2266]	2630
[128]	2631	for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
	2632	bkpinfo->media_size[i] = atoi(sz_size);
	2633	}
[2266]	2634
[128]	2635	if (bkpinfo->media_size[0] <= 0) {
[541]	2636	log_to_screen("User has chosen not to backup the PC");
[128]	2637	finish(1);
	2638	}
	2639	}
[1737]	2640	/* No break because we continue even for usb */
[128]	2641	case cdstream:
[2242]	2642	mds = media_descriptor_string(bkpinfo->backup_media_type);
	2643
[2325]	2644	mr_free(bkpinfo->media_device);
[1737]	2645	if ((bkpinfo->disaster_recovery) && (bkpinfo->backup_media_type != usb)) {
[2325]	2646	mr_asprintf(bkpinfo->media_device, "/dev/cdrom");
	2647	log_msg(2, "CD-ROM device assumed to be at %s", bkpinfo->media_device);
	2648	} else if ((bkpinfo->restore_data && (bkpinfo->backup_media_type != usb)) \|\| bkpinfo->backup_media_type == dvd) {
	2649	if ((bkpinfo->backup_media_type == dvd) \|\| ((bkpinfo->media_device = find_cdrom_device(FALSE)) != NULL)) {
[2323]	2650	mr_asprintf(comment, "Please specify your %s drive's /dev entry", mds);
[2316]	2651	p = popup_and_get_string("Device?", comment, bkpinfo->media_device);
	2652	mr_free(comment);
	2653
	2654	if (p == NULL) {
[541]	2655	log_to_screen("User has chosen not to backup the PC");
[128]	2656	finish(1);
	2657	}
[2325]	2658	mr_free(bkpinfo->media_device);
	2659	bkpinfo->media_device = p;
[128]	2660	}
[2325]	2661	if (bkpinfo->media_device != NULL) {
	2662	log_msg(2, "%s device found at %s", mds, bkpinfo->media_device);
	2663	} else {
	2664	log_msg(2, "%s device not found (bkpinfo->media_device is NULL)", mds);
	2665	}
[128]	2666	} else {
[2325]	2667	if (((bkpinfo->media_device = find_cdrw_device()) != NULL) && (bkpinfo->backup_media_type != usb)) {
	2668	mr_free(bkpinfo->media_device);
[128]	2669	}
[2325]	2670	if (bkpinfo->media_device != NULL) {
[1738]	2671	if (bkpinfo->backup_media_type == usb) {
[2323]	2672	mr_asprintf(tmp, "I think your %s media corresponds to %s. Is this correct?", mds, bkpinfo->media_device);
[1738]	2673	} else {
[2323]	2674	mr_asprintf(tmp, "I think I've found your %s burner at SCSI node %s. Is this correct? (Say no if you have an IDE burner and you are running a 2.6 kernel. You will then be prompted for further details.)", mds, bkpinfo->media_device);
[1739]	2675	}
[128]	2676	if (!ask_me_yes_or_no(tmp)) {
[2325]	2677	mr_free(bkpinfo->media_device);
[128]	2678	}
[2214]	2679	mr_free(tmp);
[128]	2680	}
[2325]	2681	if (!bkpinfo->media_device) {
[1737]	2682	if (bkpinfo->backup_media_type == usb) {
[2325]	2683	p = popup_and_get_string("/dev entry?", "What is the /dev entry of your USB Disk/Key, please?", NULL);
[1737]	2684	} else {
	2685	if (g_kernel_version < 2.6) {
[2325]	2686	p = popup_and_get_string("Device node?", "What is the SCSI node of your CD (re)writer, please?", NULL);
[1709]	2687	} else {
[2325]	2688	p = popup_and_get_string("/dev entry?", "What is the /dev entry of your CD (re)writer, please?", NULL);
[1709]	2689	}
[128]	2690	}
[2316]	2691	if (p == NULL) {
[541]	2692	log_to_screen("User has chosen not to backup the PC");
[128]	2693	finish(1);
	2694	}
[2325]	2695	bkpinfo->media_device = p;
[128]	2696	}
	2697	}
[2242]	2698	mr_free(mds);
	2699
[128]	2700	if (bkpinfo->backup_media_type == cdstream) {
	2701	for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
	2702	bkpinfo->media_size[i] = 650;
	2703	}
	2704	}
	2705	break;
	2706	case udev:
	2707	if (!ask_me_yes_or_no
[541]	2708	("This option is for advanced users only. Are you sure?")) {
	2709	log_to_screen("User has chosen not to backup the PC");
[128]	2710	finish(1);
	2711	}
	2712	case tape:
[1]	2713
[2325]	2714	mr_free(bkpinfo->media_device);
[2334]	2715	if ((!bkpinfo->restore_mode) && ((bkpinfo->media_device = mr_find_tape_device()) == NULL)) {
[541]	2716	log_msg(3, "Ok, using vanilla scsi tape.");
[2325]	2717	mr_asprintf(bkpinfo->media_device, "%s", VANILLA_SCSI_TAPE);
[128]	2718	if ((fin = fopen(bkpinfo->media_device, "r"))) {
	2719	paranoid_fclose(fin);
	2720	} else {
[2325]	2721	mr_free(bkpinfo->media_device);
	2722	mr_asprintf(bkpinfo->media_device, "/dev/osst0");
[128]	2723	}
	2724	}
[2325]	2725	if (bkpinfo->media_device != NULL) {
[128]	2726	if ((fin = fopen(bkpinfo->media_device, "r"))) {
	2727	paranoid_fclose(fin);
	2728	} else {
	2729	if (does_file_exist("/tmp/mondo-restore.cfg")) {
[2325]	2730	mr_free(bkpinfo->media_device);
	2731	bkpinfo->media_device = read_cfg_var("/tmp/mondo-restore.cfg", "media-dev");
[128]	2732	}
	2733	}
	2734	}
[2325]	2735	if (bkpinfo->media_device != NULL) {
[2323]	2736	mr_asprintf(tmp, "I think I've found your tape streamer at %s; am I right on the money?", bkpinfo->media_device);
[128]	2737	if (!ask_me_yes_or_no(tmp)) {
[2325]	2738	mr_free(bkpinfo->media_device);
[128]	2739	}
[2214]	2740	mr_free(tmp);
[128]	2741	}
[2325]	2742	if (bkpinfo->media_device == NULL) {
[2316]	2743	p = popup_and_get_string("Device name?", "What is the /dev entry of your tape streamer?", bkpinfo->media_device);
	2744	if (p == NULL) {
[541]	2745	log_to_screen("User has chosen not to backup the PC");
[128]	2746	finish(1);
	2747	}
[2325]	2748	bkpinfo->media_device = p;
[128]	2749	}
[2323]	2750	mr_asprintf(tmp, "ls -l %s", bkpinfo->media_device);
[128]	2751	if (run_program_and_log_output(tmp, FALSE)) {
[541]	2752	log_to_screen("User has not specified a valid /dev entry");
[128]	2753	finish(1);
	2754	}
[2214]	2755	mr_free(tmp);
	2756
[2334]	2757	bkpinfo->use_obdr = ask_me_yes_or_no("Do you want to activate OBDR support for your tapes ?");
[2266]	2758	bkpinfo->media_size[0] = 0;
[128]	2759	log_msg(4, "media_size[0] = %ld", bkpinfo->media_size[0]);
	2760	if (bkpinfo->media_size[0] <= 0) {
	2761	bkpinfo->media_size[0] = 0;
	2762	}
	2763	for (i = 1; i <= MAX_NOOF_MEDIA; i++) {
	2764	bkpinfo->media_size[i] = bkpinfo->media_size[0];
	2765	}
	2766	if (archiving_to_media) {
	2767	if ((bkpinfo->compression_level =
	2768	which_compression_level()) == -1) {
[541]	2769	log_to_screen("User has chosen not to backup the PC");
[128]	2770	finish(1);
	2771	}
	2772	}
	2773	break;
[1]	2774
	2775
	2776
[2382]	2777	case netfs:
	2778	/* Never try to eject a NETFS device */
[1848]	2779	bkpinfo->please_dont_eject = TRUE;
	2780
[2382]	2781	/* Initiate bkpinfo netfs_mount path from running environment if not already done */
	2782	if (bkpinfo->netfs_mount == NULL) {
[2383]	2783	bkpinfo->netfs_mount = call_program_and_get_last_line_of_output("mount \| grep \":\" \| cut -d' ' -f1 \| head -n1");
[128]	2784	}
[1]	2785	#ifdef __FreeBSD__
[128]	2786	if (TRUE)
[1]	2787	#else
[128]	2788	if (!bkpinfo->disaster_recovery)
[1]	2789	#endif
[128]	2790	{
[2382]	2791	p = popup_and_get_string("Network shared dir.", "Please enter path and directory where archives are stored remotely. (Mondo has taken a guess at the correct value. If it is incorrect, delete it and type the correct one.)", bkpinfo->netfs_mount);
[2316]	2792	if (p == NULL) {
[541]	2793	log_to_screen("User has chosen not to backup the PC");
[128]	2794	finish(1);
	2795	}
[2382]	2796	mr_free(bkpinfo->netfs_mount);
	2797	bkpinfo->netfs_mount = p;
[128]	2798	if (!bkpinfo->restore_data) {
	2799	if ((bkpinfo->compression_level =
	2800	which_compression_level()) == -1) {
[541]	2801	log_to_screen("User has chosen not to backup the PC");
[128]	2802	finish(1);
	2803	}
	2804	}
	2805	// check whether already mounted - we better remove
	2806	// surrounding spaces and trailing '/' for this
[2382]	2807	mr_strip_spaces(bkpinfo->netfs_mount);
	2808	if (bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] == '/')
	2809	bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] = '\0';
	2810	mr_asprintf(command, "mount \| grep \"%s \" \| cut -d' ' -f3", bkpinfo->netfs_mount);
[2323]	2811	mr_free(bkpinfo->isodir);
[2383]	2812	bkpinfo->isodir = call_program_and_get_last_line_of_output(command);
[2266]	2813	mr_free(command);
[256]	2814
[1847]	2815	if (!bkpinfo->restore_data) {
[2323]	2816	mr_asprintf(comment, "How much data (in Megabytes) will each media store?");
[2316]	2817	// BERLIOS: 4480 shouldn't be hardcoded here
	2818	sz_size = popup_and_get_string("Size", comment, "4480");
	2819	mr_free(comment);
	2820	if (sz_size == NULL) {
[1847]	2821	log_to_screen("User has chosen not to backup the PC");
	2822	finish(1);
	2823	}
	2824	} else {
[2323]	2825	mr_asprintf(sz_size, "0");
[256]	2826	}
	2827	for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
	2828	bkpinfo->media_size[i] = atoi(sz_size);
	2829	}
[2316]	2830	mr_free(sz_size);
[1917]	2831	if (bkpinfo->media_size[0] < 0) {
[541]	2832	log_to_screen("User has chosen not to backup the PC");
[256]	2833	finish(1);
	2834	}
[128]	2835	}
	2836	if (bkpinfo->disaster_recovery) {
[2323]	2837	mr_asprintf(command ,"umount %s/isodir 2> /dev/null", bkpinfo->tmpdir);
[2202]	2838	(void)system(command);
[2266]	2839	mr_free(command);
	2840
[2400]	2841	p = popup_and_get_string("Network protocol", "Which Network protocol should I use?", bkpinfo->netfs_proto);
	2842	if (p == NULL) {
	2843	log_to_screen("User has chosen not to backup the PC");
	2844	finish(1);
	2845	}
	2846	mr_free(bkpinfo->netfs_proto);
	2847	bkpinfo->netfs_proto = p;
	2848
[2382]	2849	p = popup_and_get_string("Network share", "Which remote Network share should I mount?", bkpinfo->netfs_mount);
[2316]	2850	if (p == NULL) {
[541]	2851	log_to_screen("User has chosen not to backup the PC");
[128]	2852	finish(1);
	2853	}
[2382]	2854	mr_free(bkpinfo->netfs_mount);
	2855	bkpinfo->netfs_mount = p;
[128]	2856	}
[1858]	2857	/* Initiate bkpinfo isodir path from running environment if mount already done */
[2323]	2858	mr_free(bkpinfo->isodir);
[2382]	2859	if (is_this_device_mounted(bkpinfo->netfs_mount)) {
[2383]	2860	bkpinfo->isodir = call_program_and_get_last_line_of_output("mount \| grep \":\" \| cut -d' ' -f3 \| head -n1");
[2323]	2861
[1858]	2862	} else {
[2382]	2863	mr_asprintf(bkpinfo->isodir, "%s/netfsdir", bkpinfo->tmpdir);
[2323]	2864	mr_asprintf(command, "mkdir -p %s", bkpinfo->isodir);
[128]	2865	run_program_and_log_output(command, 5);
[2266]	2866	mr_free(command);
	2867
[2364]	2868	if (bkpinfo->restore_data) {
[2382]	2869	if (strstr(bkpinfo->netfs_proto, "sshfs")) {
	2870	mr_asprintf(tmp, "sshfs -o ro %s %s", bkpinfo->netfs_mount, bkpinfo->isodir);
	2871	} else {
	2872	mr_asprintf(tmp, "mount -t %s -o nolock,ro %s %s", bkpinfo->netfs_proto, bkpinfo->netfs_mount, bkpinfo->isodir);
	2873	}
[2370]	2874	} else {
[2382]	2875	if (strstr(bkpinfo->netfs_proto, "sshfs")) {
	2876	mr_asprintf(tmp, "sshfs %s %s", bkpinfo->netfs_mount, bkpinfo->isodir);
	2877	} else {
	2878	mr_asprintf(tmp, "mount -t %s -o nolock %s %s", bkpinfo->netfs_proto, bkpinfo->netfs_mount, bkpinfo->isodir);
	2879	}
[2364]	2880	}
[1819]	2881	run_program_and_log_output(tmp, 3);
[2214]	2882	mr_free(tmp);
	2883
[128]	2884	malloc_string(g_selfmounted_isodir);
	2885	strcpy(g_selfmounted_isodir, bkpinfo->isodir);
	2886	}
[2382]	2887	if (!is_this_device_mounted(bkpinfo->netfs_mount)) {
[2324]	2888	popup_and_OK("Please mount that partition before you try to backup to or restore from it.");
[128]	2889	finish(1);
	2890	}
[2382]	2891	p = popup_and_get_string("Directory", "Which directory within that mountpoint?", bkpinfo->netfs_remote_dir);
[2316]	2892	if (p == NULL) {
[541]	2893	log_to_screen("User has chosen not to backup the PC");
[128]	2894	finish(1);
	2895	}
[2382]	2896	mr_free(bkpinfo->netfs_remote_dir);
	2897	bkpinfo->netfs_remote_dir = p;
[2214]	2898
[128]	2899	// check whether writable - we better remove surrounding spaces for this
[2382]	2900	mr_strip_spaces(bkpinfo->netfs_remote_dir);
[1767]	2901
[2316]	2902	p = popup_and_get_string("Prefix.", "Please enter the prefix that will be prepended to your ISO filename. Example: machine1 to obtain machine1-[1-9]*.iso files", bkpinfo->prefix);
	2903	if (p == NULL) {
[541]	2904	log_to_screen("User has chosen not to backup the PC");
[251]	2905	finish(1);
	2906	}
[2322]	2907	mr_free(bkpinfo->prefix);
	2908	bkpinfo->prefix = p;
[251]	2909	log_msg(3, "prefix set to %s", bkpinfo->prefix);
[99]	2910
[2382]	2911	log_msg(3, "Just set netfs_remote_dir to %s", bkpinfo->netfs_remote_dir);
[128]	2912	log_msg(3, "isodir is still %s", bkpinfo->isodir);
	2913	break;
[1]	2914
[128]	2915	case iso:
	2916	if (!bkpinfo->disaster_recovery) {
[2316]	2917	p = popup_and_get_string("Storage dir.", "Please enter the full path name to the directory for your ISO images. Example: /mnt/raid0_0", bkpinfo->isodir);
	2918	if (p == NULL) {
[541]	2919	log_to_screen("User has chosen not to backup the PC");
[128]	2920	finish(1);
	2921	}
[2323]	2922	bkpinfo->isodir = p;
[2316]	2923
[128]	2924	if (archiving_to_media) {
	2925	if ((bkpinfo->compression_level =
	2926	which_compression_level()) == -1) {
[541]	2927	log_to_screen("User has chosen not to backup the PC");
[128]	2928	finish(1);
	2929	}
[2316]	2930	p = popup_and_get_string("ISO size.", "Please enter how big you want each ISO image to be (in megabytes). This should be less than or equal to the size of the CD-R[W]'s or DVD's you plan to backup to.", sz_size);
	2931	if (p == NULL) {
[541]	2932	log_to_screen("User has chosen not to backup the PC");
[128]	2933	finish(1);
	2934	}
	2935	for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
[2316]	2936	bkpinfo->media_size[i] = atoi(p);
[128]	2937	}
[2316]	2938	mr_free(p);
[128]	2939	} else {
	2940	for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
	2941	bkpinfo->media_size[i] = 650;
	2942	}
	2943	}
	2944	}
[2316]	2945	p = popup_and_get_string("Prefix.", "Please enter the prefix that will be prepended to your ISO filename. Example: machine1 to obtain machine1-[1-9]*.iso files", bkpinfo->prefix);
	2946	if (p == NULL) {
[804]	2947	log_to_screen("User has chosen not to backup the PC");
	2948	finish(1);
	2949	}
[2322]	2950	mr_free(bkpinfo->prefix);
	2951	bkpinfo->prefix = p;
[804]	2952	log_msg(3, "prefix set to %s", bkpinfo->prefix);
[128]	2953	break;
[2322]	2954
[128]	2955	default:
	2956	fatal_error
	2957	("I, Mojo Jojo, shall defeat those pesky Powerpuff Girls!");
	2958	}
[1]	2959
[128]	2960	if (archiving_to_media) {
[1]	2961
[2326]	2962	mr_free(bkpinfo->boot_device);
[1]	2963	#ifdef __FreeBSD__
[2326]	2964	#define EXAMPLEBD "/dev/ad0"
[2383]	2965	bkpinfo->boot_device = call_program_and_get_last_line_of_output("mount \| grep ' / ' \| head -1 \| cut -d' ' -f1 \| sed 's/\$[0-9]\$.*/\\1/'");
[1]	2966	#else
[2326]	2967	#define EXAMPLEBD "/dev/hda"
[2383]	2968	bkpinfo->boot_device = call_program_and_get_last_line_of_output("mount \| grep ' / ' \| head -1 \| cut -d' ' -f1 \| sed 's/[0-9].*//'");
[1]	2969	#endif
[128]	2970	i = which_boot_loader(bkpinfo->boot_device);
	2971	if (i == 'U') // unknown
	2972	{
[1]	2973
[2326]	2974	p = popup_and_get_string("Boot device", "What is your boot device? (e.g. "EXAMPLEBD")", bkpinfo->boot_device);
	2975	#undef EXAMPLEBD
	2976	if (p == NULL) {
[541]	2977	log_to_screen("User has chosen not to backup the PC");
[128]	2978	finish(1);
	2979	}
[2326]	2980	mr_free(bkpinfo->boot_device);
	2981	bkpinfo->boot_device = p;
	2982	#ifdef __FreeBSD__
[128]	2983	i = which_boot_loader(bkpinfo->boot_device);
[1]	2984	#else
[2316]	2985	if (does_string_exist_in_boot_block(bkpinfo->boot_device, "LILO")) {
[128]	2986	i = 'L';
	2987	} else
[2316]	2988	if (does_string_exist_in_boot_block(bkpinfo->boot_device, "ELILO")) {
[128]	2989	i = 'E';
	2990	} else
[2316]	2991	if (does_string_exist_in_boot_block(bkpinfo->boot_device, "GRUB")) {
[128]	2992	i = 'G';
	2993	} else {
	2994	i = 'U';
	2995	}
[1]	2996	#endif
[128]	2997	if (i == 'U') {
[2326]	2998	if (ask_me_yes_or_no("Unidentified boot loader. Shall I restore it byte-for-byte at restore time and hope for the best?")) {
[128]	2999	i = 'R'; // raw
	3000	} else {
[2326]	3001	log_to_screen("I cannot find your boot loader. Please run mondoarchive with parameters.");
[128]	3002	finish(1);
	3003	}
	3004	}
[1]	3005	}
[128]	3006	bkpinfo->boot_loader = i;
[2319]	3007	mr_free(bkpinfo->include_paths);
[2323]	3008	mr_asprintf(p, "/");
[2319]	3009	bkpinfo->include_paths = p;
	3010
[2316]	3011	p = popup_and_get_string("Backup paths", "Please enter paths which you want me to backup. The default is '/' (i.e. everything).", bkpinfo->include_paths);
	3012	if (p == NULL) {
[541]	3013	log_to_screen("User has chosen not to backup the PC");
[128]	3014	finish(1);
[1]	3015	}
[2319]	3016	mr_free(bkpinfo->include_paths);
	3017	bkpinfo->include_paths = p;
[2316]	3018
[2382]	3019	mr_asprintf(tmp, "%s", list_of_NETFS_mounts_only());
[128]	3020	if (strlen(tmp) > 2) {
[2318]	3021	mr_strcat(bkpinfo->exclude_paths, " %s",tmp);
[128]	3022	}
[2214]	3023	mr_free(tmp);
[1]	3024	// NTFS
[2383]	3025	tmp = call_program_and_get_last_line_of_output("parted2fdisk -l \| grep -i ntfs \| awk '{ print $1};' \| tr -s '\\n' ' ' \| awk '{ print $0};'");
[2323]	3026	if (strlen(tmp) > 2) {
[2316]	3027	p = popup_and_get_string("NTFS partitions", "Please enter/confirm the NTFS partitions you wish to backup as well.", tmp);
	3028
	3029	if (p == NULL) {
[541]	3030	log_to_screen("User has chosen not to backup the PC");
[128]	3031	finish(1);
	3032	}
[2327]	3033	mr_free(bkpinfo->image_devs);
	3034	bkpinfo->image_devs = p;
[128]	3035	}
[1]	3036
	3037
[2316]	3038	p = popup_and_get_string("Exclude paths", "Please enter paths which you do NOT want to backup. Separate them with spaces. NB: /tmp and /proc are always excluded. :-) Just hit 'Enter' if you want to do a full system backup.", bkpinfo->exclude_paths);
	3039	if (p == NULL) {
[541]	3040	log_to_screen("User has chosen not to backup the PC");
[128]	3041	finish(1);
	3042	}
[2318]	3043	mr_free(bkpinfo->exclude_paths);
	3044	bkpinfo->exclude_paths = p;
[2316]	3045
	3046	p = popup_and_get_string("Temporary directory", "Please enter your temporary directory.", bkpinfo->tmpdir);
	3047	if (p == NULL) {
[2220]	3048	log_to_screen("User has chosen not to backup the PC");
	3049	finish(1);
	3050	}
[2321]	3051	mr_free(bkpinfo->tmpdir);
	3052	bkpinfo->tmpdir = p;
[2316]	3053
	3054	p = popup_and_get_string("Scratch directory", "Please enter your scratch directory.", bkpinfo->scratchdir);
	3055	if (p == NULL) {
[2220]	3056	log_to_screen("User has chosen not to backup the PC");
	3057	finish(1);
	3058	}
[2320]	3059	mr_free(bkpinfo->scratchdir);
	3060	bkpinfo->scratchdir = p;
[2316]	3061
[1575]	3062	// Interactive mode:
	3063	#ifdef __IA64__
	3064	bkpinfo->make_cd_use_lilo = TRUE;
	3065	#else
[128]	3066	bkpinfo->make_cd_use_lilo = FALSE;
[1575]	3067	#endif
[128]	3068	bkpinfo->backup_data = TRUE;
	3069	bkpinfo->verify_data =
	3070	ask_me_yes_or_no
[541]	3071	("Will you want to verify your backups after Mondo has created them?");
[1]	3072
	3073	#ifndef __FreeBSD__
[128]	3074	if (!ask_me_yes_or_no
[541]	3075	("Are you confident that your kernel is a sane, sensible, standard Linux kernel? Say 'no' if you are using a Gentoo <1.4 or Debian <3.0, please."))
[1]	3076	#endif
[128]	3077	{
[2328]	3078	mr_free(bkpinfo->kernel_path);
	3079	mr_asprintf(bkpinfo->kernel_path, "FAILSAFE");
[128]	3080	}
[1]	3081
[128]	3082	if (!ask_me_yes_or_no
[541]	3083	("Are you sure you want to proceed? Hit 'no' to abort.")) {
	3084	log_to_screen("User has chosen not to backup the PC");
[128]	3085	finish(1);
	3086	}
	3087	} else {
	3088	bkpinfo->restore_data = TRUE; // probably...
	3089	}
[1]	3090
[128]	3091	if (bkpinfo->backup_media_type == iso
[2382]	3092	\|\| bkpinfo->backup_media_type == netfs) {
[128]	3093	g_ISO_restore_mode = TRUE;
	3094	}
[1]	3095	#ifdef __FreeSD__
	3096	// skip
	3097	#else
[2382]	3098	if (bkpinfo->backup_media_type == netfs) {
	3099	log_msg(3, "I think the Remote mount is mounted at %s", bkpinfo->isodir);
[128]	3100	}
	3101	log_it("isodir = %s", bkpinfo->isodir);
[2382]	3102	if (bkpinfo->netfs_mount) {
	3103	log_it("netfs_mount = '%s'", bkpinfo->netfs_mount);
[2325]	3104	}
[2382]	3105	if (bkpinfo->netfs_user) {
	3106	log_it("netfs_user = '%s'", bkpinfo->netfs_user);
[2224]	3107	}
[2382]	3108	if (bkpinfo->netfs_proto) {
	3109	log_it("netfs_proto = '%s'", bkpinfo->netfs_proto);
	3110	}
[1]	3111	#endif
	3112
[128]	3113	log_it("media device = %s", bkpinfo->media_device);
	3114	log_it("media size = %ld", bkpinfo->media_size[1]);
[2330]	3115	tmp = bkptype_to_string(bkpinfo->backup_media_type);
	3116	log_it("media type = %s", tmp);
	3117	mr_free(tmp);
	3118
[2327]	3119	if (bkpinfo->prefix) {
	3120	log_it("prefix = %s", bkpinfo->prefix);
	3121	}
[128]	3122	log_it("compression = %ld", bkpinfo->compression_level);
[2428]	3123
	3124	/* Handle devices passed in bkpinfo and print result */
	3125	mr_make_devlist_from_pathlist(bkpinfo->exclude_paths, 'E');
	3126	mr_make_devlist_from_pathlist(bkpinfo->include_paths, 'I');
	3127
[128]	3128	log_it("scratchdir = '%s'", bkpinfo->scratchdir);
	3129	log_it("tmpdir = '%s'", bkpinfo->tmpdir);
[2327]	3130	if (bkpinfo->image_devs) {
	3131	log_it("image_devs = '%s'", bkpinfo->image_devs);
	3132	}
[2322]	3133	log_it("boot_device = '%s' (loader=%c)", bkpinfo->boot_device, bkpinfo->boot_loader);
[128]	3134	if (bkpinfo->media_size[0] < 0) {
	3135	if (archiving_to_media) {
	3136	fatal_error("Media size is less than zero.");
	3137	} else {
	3138	log_msg(2, "Warning - media size is less than zero.");
	3139	bkpinfo->media_size[0] = 0;
	3140	}
[1]	3141	}
[128]	3142	paranoid_free(sz_size);
	3143	return (0);
[1]	3144	}
	3145
	3146
	3147
	3148
	3149	/* @} - end of deviceGroup */

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

Context Navigation

source: MondoRescue/branches/2.2.10/mondo/src/common/libmondo-devices.c@ 2444

Download in other formats: