Context Navigation

source: MondoRescue/branches/3.2/mondo/src/common/libmondo-devices.c@ 3212

Visit:

Last change on this file since 3212 was 3212, checked in by Bruno Cornec, 10 years ago
Fix wrong analyzis of temp and scratch dirs in interactive mode (wrong memory allocation mngt and comparison with previous dir) (report from Rick Stevens)
Property svn:keywords set to `Id`
File size: 96.9 KB

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

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

Download in other formats: