Context Navigation

source: MondoRescue/branches/2.2.10/mondo/src/common/libmondo-verify.c@ 2334

Visit:

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

r3369@localhost: bruno | 2009-08-18 16:57:27 +0200

Transform bout 100 strcpy in dyn. allocation. Quality is improving
function figure_out_kernel_path_interactively_if_necessary now return a dynamically allocated string
mondoarchive checked with valgrind in text an newt modes

Property svn:keywords set to Id

File size: 35.2 KB

Rev	Line
[1]	1	/***************************************************************************
[2211]	2	$Id: libmondo-verify.c 2334 2009-08-18 15:28:18Z bruno $
[1]	3	***************************************************************************/
	4
	5
	6	/**
	7	* @file
	8	* Functions for verifying backups (booted from hard drive, not CD).
	9	*/
	10
	11	#include "my-stuff.h"
[2211]	12	#include "mr_mem.h"
[1]	13	#include "mondostructures.h"
	14	#include "libmondo-verify.h"
[541]	15	#include "libmondo-gui-EXT.h"
[1]	16	#include "libmondo-files-EXT.h"
	17	#include "libmondo-fork-EXT.h"
	18	#include "libmondo-stream-EXT.h"
	19	#include "libmondo-string-EXT.h"
	20	#include "libmondo-devices-EXT.h"
	21	#include "libmondo-tools-EXT.h"
[541]	22	#include "lib-common-externs.h"
[1]	23
	24	/@unused@/
[117]	25	//static char cvsid[] = "$Id: libmondo-verify.c 2334 2009-08-18 15:28:18Z bruno $";
[1]	26
	27	/**
	28	* The number of the most recently verified afioball.
	29	* @ingroup globalGroup
	30	*/
	31	int g_last_afioball_number = -1;
	32
[948]	33	extern char *g_getfacl;
	34	extern char *g_getfattr;
[1316]	35	extern char *MONDO_LOGFILE;
[1]	36
[1645]	37	/* Reference to global bkpinfo */
	38	extern struct s_bkpinfo *bkpinfo;
	39
[1648]	40
[1]	41	/**
[1648]	42	* Generate the filename of a tarball to verify.
	43	* @param bkpinfo The backup information structure. @c bkpinfo->zip_suffix is the only field used.
	44	* @param mountpoint The directory where the CD/DVD/ISO is mounted.
	45	* @param setno The afioball number to get the location of.
	46	* @return The absolute path to the afioball.
	47	* @note The returned string points to static data that will be overwritten with each call.
	48	* @ingroup stringGroup
	49	*/
	50	char vfy_tball_fname(char mountpoint, int setno)
	51	{
	52	/@ buffers ****************************************************** */
	53	static char output[MAX_STR_LEN];
	54
	55	assert(bkpinfo != NULL);
	56	assert_string_is_neither_NULL_nor_zerolength(mountpoint);
[2327]	57	sprintf(output, "%s/archives/%d.star.%s", mountpoint, setno, bkpinfo->zip_suffix);
[1648]	58	if (!does_file_exist(output)) {
[2327]	59	sprintf(output, "%s/archives/%d.afio.%s", mountpoint, setno, bkpinfo->zip_suffix);
[1648]	60	}
	61	return (output);
	62	}
	63
	64
	65	/**
[1]	66	* Generate a list of the files that have changed, based on @c afio @c -r
	67	* messages.
	68	* @param changedfiles_fname Filename of the place to put a list of afio's reported changed.
	69	* @param ignorefiles_fname Filename of a list of files to ignore (use "" if none).
	70	* @param stderr_fname File containing afio's stderr output.
	71	* @return The number of differences found (0 for a perfect backup).
	72	* @bug This function seems orphaned.
	73	* @ingroup utilityGroup
	74	*/
	75	long
[128]	76	generate_list_of_changed_files(char *changedfiles_fname,
	77	char ignorefiles_fname, char stderr_fname)
[1]	78	{
[128]	79	/@ buffer ********************************************************* */
[2276]	80	char *command = NULL;
	81	char *afio_found_changes = NULL;
[1]	82
[128]	83	/@ int ************************************************************ */
	84	int res = 0;
[1]	85
[128]	86	/@ long *********************************************************** */
	87	long afio_diffs = 0;
[1]	88
[128]	89	assert_string_is_neither_NULL_nor_zerolength(changedfiles_fname);
	90	assert_string_is_neither_NULL_nor_zerolength(ignorefiles_fname);
	91	assert_string_is_neither_NULL_nor_zerolength(stderr_fname);
[1]	92
[2323]	93	mr_asprintf(afio_found_changes, "%s.afio", ignorefiles_fname);
[128]	94	paranoid_system("sync");
	95
	96	log_msg(1, "Now scanning log file for 'afio: ' stuff");
[2323]	97	mr_asprintf(command, "grep \"afio: \" %s \| sed 's/afio: //' \| grep -vE '^/dev/.*$' >> %s", stderr_fname, afio_found_changes);
[128]	98	log_msg(2, command);
	99	res = system(command);
[2276]	100	mr_free(command);
	101
[128]	102	if (res) {
	103	log_msg(2, "Warning - failed to think");
	104	}
	105
	106	log_msg(1, "Now scanning log file for 'star: ' stuff");
[2323]	107	mr_asprintf(command, "grep \"star: \" %s \| sed 's/star: //' \| grep -vE '^/dev/.*$' >> %s", stderr_fname, afio_found_changes);
[128]	108	log_msg(2, command);
	109	res = system(command);
[2276]	110	mr_free(command);
	111
[128]	112	if (res) {
	113	log_msg(2, "Warning - failed to think");
	114	}
	115	afio_diffs = count_lines_in_file(afio_found_changes);
[2323]	116	mr_asprintf(command, "sort %s %s %s \| uniq -c \| awk '{ if ($1==\"2\") {print $2;};}' \| grep -v \"incheckentry xwait()\" > %s", ignorefiles_fname, afio_found_changes, afio_found_changes, changedfiles_fname);
[2276]	117	mr_free(afio_found_changes);
[128]	118	log_msg(2, command);
	119	paranoid_system(command);
[2276]	120	mr_free(command);
[128]	121	return (afio_diffs);
[1]	122	}
	123
	124
	125	/**
	126	* @addtogroup LLverifyGroup
	127	* @{
	128	*/
	129	/**
	130	* Verify all afioballs stored on the inserted CD (or an ISO image).
	131	* @param bkpinfo The backup information structure. @c bkpinfo->backup_media_type
	132	* is used in this function, and the structure is also passed to verify_an_afioball_from_CD().
	133	* @param mountpoint The location the CD/DVD/ISO is mounted on.
	134	* @return The number of sets containing differences (0 for success).
	135	*/
[1645]	136	int verify_afioballs_on_CD(char *mountpoint)
[1]	137	{
	138
[128]	139	/@ buffers ******************************************************** */
[2276]	140	char *tmp = NULL;
[2242]	141	char *mds = NULL;
[1]	142
[128]	143	/@ int ************************************************************ */
	144	int set_number = 0;
[1]	145	int retval = 0;
	146	int total_sets = 0;
	147	int percentage = 0;
	148
[128]	149	assert_string_is_neither_NULL_nor_zerolength(mountpoint);
	150	assert(bkpinfo != NULL);
	151
	152	for (set_number = 0;
	153	set_number < 9999
	154	&&
[1645]	155	!does_file_exist(vfy_tball_fname(mountpoint, set_number));
[128]	156	set_number++);
[1645]	157	if (!does_file_exist(vfy_tball_fname(mountpoint, set_number))) {
[128]	158	return (0);
[1]	159	}
[128]	160
	161	if (g_last_afioball_number != set_number - 1) {
	162	if (set_number == 0) {
	163	log_msg(1,
	164	"Weird error in verify_afioballs_on_CD() but it's really a cosmetic error, nothing more");
	165	} else {
	166	retval++;
[2324]	167	log_to_screen("Warning - missing set(s) between %d and %d\n", g_last_afioball_number, set_number - 1);
[128]	168	}
	169	}
[2242]	170	mds = media_descriptor_string(bkpinfo->backup_media_type);
[2323]	171	mr_asprintf(tmp, "Verifying %s #%d's tarballs", mds, g_current_media_number);
[2242]	172	mr_free(mds);
	173
[128]	174	open_evalcall_form(tmp);
[2276]	175	mr_free(tmp);
[128]	176
	177	for (total_sets = set_number;
[1645]	178	does_file_exist(vfy_tball_fname(mountpoint, total_sets));
[128]	179	total_sets++) {
	180	log_msg(1, "total_sets = %d", total_sets);
	181	}
	182	for (;
[1645]	183	does_file_exist(vfy_tball_fname(mountpoint, set_number));
[128]	184	set_number++) {
	185	percentage =
	186	(set_number - g_last_afioball_number) * 100 / (total_sets -
	187	g_last_afioball_number);
	188	update_evalcall_form(percentage);
	189	log_msg(1, "set = %d", set_number);
	190	retval +=
[1645]	191	verify_an_afioball_from_CD(vfy_tball_fname(mountpoint, set_number));
[128]	192	}
	193	g_last_afioball_number = set_number - 1;
	194	close_evalcall_form();
	195	return (retval);
[1]	196	}
	197
	198	/**
	199	* Verify all slices stored on the inserted CD (or a mounted ISO image).
	200	* @param bkpinfo The backup information structure. Fields used:
	201	* - @c compression_level
	202	* - @c restore_path
	203	* - @c use_lzo
	204	* - @c zip_suffix
	205	* @param mtpt The mountpoint the CD/DVD/ISO is mounted on.
	206	* @return The number of differences (0 for perfect biggiefiles).
	207	*/
[1645]	208	int verify_all_slices_on_CD(char *mtpt)
[1]	209	{
	210
[128]	211	/@ buffer ********************************************************* */
[2276]	212	char *tmp = NULL;
	213	char *mountpoint = NULL;
	214	char *command = NULL;
[2242]	215	char *mds = NULL;
[2327]	216	char *sz_exe = NULL;
[128]	217	static char *bufblkA = NULL;
	218	static char *bufblkB = NULL;
	219	const long maxbufsize = 65536L;
	220	long currsizA = 0;
	221	long currsizB = 0;
	222	long j;
[1]	223
[128]	224	/@ long *********************************************************** */
	225	long bigfile_num = 0;
	226	long slice_num = -1;
	227	int res;
[1]	228
[128]	229	static FILE *forig = NULL;
	230	static struct s_filename_and_lstat_info biggiestruct;
	231	static long last_bigfile_num = -1;
	232	static long last_slice_num = -1;
	233	FILE *pin;
	234	FILE *fin;
	235	int retval = 0;
[1]	236
[128]	237	if (!bufblkA) {
	238	if (!(bufblkA = malloc(maxbufsize))) {
	239	fatal_error("Cannot malloc bufblkA");
	240	}
	241	}
	242	if (!bufblkB) {
	243	if (!(bufblkB = malloc(maxbufsize))) {
	244	fatal_error("Cannot malloc bufblkB");
	245	}
	246	}
[1]	247
[128]	248	assert(bkpinfo != NULL);
	249	assert_string_is_neither_NULL_nor_zerolength(mtpt);
[1]	250
[128]	251	if (bkpinfo->compression_level > 0) {
	252	if (bkpinfo->use_lzo) {
[2327]	253	mr_asprintf(sz_exe, "lzop");
[1003]	254	} else if (bkpinfo->use_gzip) {
[2327]	255	mr_asprintf(sz_exe, "gzip");
[128]	256	} else {
[2327]	257	mr_asprintf(sz_exe, "bzip2");
[128]	258	}
	259	}
[1]	260
[2230]	261	log_it("before vsbf");
[2242]	262	mds = media_descriptor_string(bkpinfo->backup_media_type);
[2323]	263	mr_asprintf(tmp, "Verifying %s#%d's big files", mds, g_current_media_number);
[2242]	264	mr_free(mds);
	265
[128]	266	open_evalcall_form(tmp);
[2276]	267	mr_free(tmp);
	268
[2230]	269	log_it("after vsbf");
[2323]	270	mr_asprintf(mountpoint, "%s/archives", mtpt);
[128]	271	if (last_bigfile_num == -1) {
	272	bigfile_num = 0;
	273	slice_num = 0;
	274	} else if (slice_num == 0) {
	275	bigfile_num = last_bigfile_num + 1;
	276	slice_num = 0;
	277	} else {
	278	bigfile_num = last_bigfile_num;
	279	slice_num = last_slice_num + 1;
	280	}
[2276]	281	while (does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, bkpinfo->zip_suffix))
[128]	282	\|\|
[2276]	283	does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, ""))) {
[1236]	284	// handle slices until end of CD
[128]	285	if (slice_num == 0) {
[2327]	286	log_msg(2, "ISO=%d bigfile=%ld --START--", g_current_media_number, bigfile_num);
[2276]	287	if (! (fin = fopen(slice_fname(bigfile_num, slice_num, mountpoint, ""), "r"))) {
[128]	288	log_msg(2, "Cannot open bigfile's info file");
	289	} else {
[2276]	290	if (fread ((void *) &biggiestruct, 1, sizeof(biggiestruct), fin) < sizeof(biggiestruct)) {
[128]	291	log_msg(2, "Unable to get biggiestruct");
	292	}
	293	paranoid_fclose(fin);
	294	}
[2327]	295	if (bkpinfo->restore_path) {
	296	mr_asprintf(tmp, "%s/%s", bkpinfo->restore_path, biggiestruct.filename);
	297	log_msg(2, "Opening biggiefile #%ld - '%s'", bigfile_num, tmp);
	298	forig = fopen(tmp, "r");
[2276]	299	mr_free(tmp);
[2327]	300
	301	if (!forig) {
	302	log_msg(2, "Failed to open bigfile. Darn.");
	303	log_to_screen("%s/%s not found on live filesystem", bkpinfo->restore_path, biggiestruct.filename);
	304	mr_asprintf(tmp, "echo \"%s/%s not found\" >> %s/biggies.changed", bkpinfo->restore_path, biggiestruct.filename, bkpinfo->tmpdir);
	305	system(tmp);
	306	mr_free(tmp);
[1236]	307
[2327]	308	bigfile_num++;
	309	slice_num = 0;
	310	retval++;
	311	} else {
	312	slice_num++;
	313	}
[1236]	314	} else {
[2327]	315	log_it("Unable to open bigfile as restore_path is NULL");
[128]	316	}
[1236]	317	} else if (does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, "")) &&
	318	(length_of_file(slice_fname(bigfile_num, slice_num, mountpoint, "")) == 0)) {
[128]	319	log_msg(2, "ISO=%d bigfile=%ld ---END---",
	320	g_current_media_number, bigfile_num);
	321	bigfile_num++;
	322	paranoid_fclose(forig);
	323	slice_num = 0;
	324	} else {
[2327]	325	log_msg(2, "ISO=%d bigfile=%ld slice=%ld", g_current_media_number, bigfile_num, slice_num);
	326	if ((!does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, ""))) && (sz_exe != NULL)) {
[2323]	327	mr_asprintf(command, "%s -dc %s 2>> %s", sz_exe, slice_fname(bigfile_num, slice_num, mountpoint, bkpinfo->zip_suffix), MONDO_LOGFILE);
[128]	328	} else {
[2323]	329	mr_asprintf(command, "cat %s 2>> %s", slice_fname(bigfile_num, slice_num, mountpoint, ""), MONDO_LOGFILE);
[128]	330	}
[2276]	331	pin = popen(command, "r");
	332	mr_free(command);
	333	if (pin) {
[128]	334	res = 0;
	335	while (!feof(pin)) {
	336	currsizA = fread(bufblkA, 1, maxbufsize, pin);
	337	if (currsizA <= 0) {
	338	break;
	339	}
	340	currsizB = fread(bufblkB, 1, currsizA, forig);
	341	if (currsizA != currsizB) {
	342	res++;
	343	} else {
	344	for (j = 0;
	345	j < currsizA && bufblkA[j] == bufblkB[j];
	346	j++);
	347	if (j < currsizA) {
	348	res++;
	349	}
	350	}
	351	}
	352	paranoid_pclose(pin);
[1236]	353	if (res && !strncmp(biggiestruct.filename, "/dev/", 5)) {
[128]	354	log_msg(3,
[296]	355	"Ignoring differences between %s and live filesystem because it's a device and therefore the archives are stored via ntfsclone, not dd.",
[128]	356	biggiestruct.filename);
	357	log_msg(3,
	358	"If you really want verification for %s, please contact the devteam and offer an incentive.",
	359	biggiestruct.filename);
	360	res = 0;
	361	}
	362	if (res) {
	363	log_msg(0,
	364	"afio: \"%s\": Corrupt biggie file, says libmondo-archive.c",
	365	biggiestruct.filename);
	366	retval++;
	367	}
	368	}
	369	slice_num++;
	370	}
[1]	371	}
[2276]	372	mr_free(mountpoint);
[2327]	373	mr_free(sz_exe);
	374
[128]	375	last_bigfile_num = bigfile_num;
	376	last_slice_num = slice_num - 1;
	377	if (last_slice_num < 0) {
	378	last_bigfile_num--;
[1]	379	}
[128]	380	close_evalcall_form();
	381	if (bufblkA) {
	382	paranoid_free(bufblkA);
[1]	383	}
[128]	384	if (bufblkB) {
	385	paranoid_free(bufblkB);
	386	}
	387	return (0);
[1]	388	}
	389
	390
	391
	392
	393
	394
	395	/**
	396	* Verify one afioball from the CD.
	397	* You should be changed to the root directory (/) for this to work.
	398	* @param bkpinfo The backup information structure. Fields used:
	399	* - @c bkpinfo->use_lzo
	400	* - @c bkpinfo->tmpdir
	401	* - @c bkpinfo->zip_exe
	402	* - @c bkpinfo->zip_suffix
	403	* @param tarball_fname The filename of the afioball to verify.
	404	* @return 0, always.
	405	*/
[1645]	406	int verify_a_tarball(char *tarball_fname)
[1]	407	{
[128]	408	/@ buffers ******************************************************** */
[2276]	409	char *command = NULL;
	410	char *outlog = NULL;
[1]	411	char *tmp;
[128]	412	// char *p;
[1]	413
[128]	414	/@ pointers ****************************************************** */
	415	FILE *pin;
[1]	416
[128]	417	/@ long ********************************************************** */
	418	long diffs = 0;
	419	/* getcwd(old_pwd,MAX_STR_LEN-1); */
[1]	420
	421
[128]	422	malloc_string(tmp);
	423	assert(bkpinfo != NULL);
	424	assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
[1]	425
[128]	426	log_it("Verifying fileset '%s'", tarball_fname);
[2323]	427	mr_asprintf(outlog, "%s/afio.log", bkpinfo->tmpdir);
[2276]	428	/* if programmer forgot to say which compression thingy to use then find out */
[2326]	429	if (strstr(tarball_fname, ".lzo") && strcmp(bkpinfo->zip_suffix, "lzo")) {
[128]	430	log_msg(2, "OK, I'm going to start using lzop.");
[2326]	431	mr_free(bkpinfo->zip_exe);
	432	mr_asprintf(bkpinfo->zip_exe, "lzop");
[2327]	433	mr_free(bkpinfo->zip_suffix);
	434	mr_asprintf(bkpinfo->zip_suffix, "lzo");
[128]	435	bkpinfo->use_lzo = TRUE;
[998]	436	bkpinfo->use_gzip = FALSE;
[128]	437	}
[2326]	438	if (strstr(tarball_fname, ".gz") && strcmp(bkpinfo->zip_suffix, "gz")) {
[998]	439	log_msg(2, "OK, I'm going to start using gzip.");
[2326]	440	mr_free(bkpinfo->zip_exe);
	441	mr_asprintf(bkpinfo->zip_exe, "gzip");
[2327]	442	mr_free(bkpinfo->zip_suffix);
	443	mr_asprintf(bkpinfo->zip_suffix, "gz");
[998]	444	bkpinfo->use_lzo = FALSE;
	445	bkpinfo->use_gzip = TRUE;
	446	}
[2326]	447	if (strstr(tarball_fname, ".bz2") && strcmp(bkpinfo->zip_suffix, "bz2")) {
[128]	448	log_msg(2, "OK, I'm going to start using bzip2.");
[2326]	449	mr_free(bkpinfo->zip_exe);
	450	mr_asprintf(bkpinfo->zip_exe, "bzip2");
[2327]	451	mr_free(bkpinfo->zip_suffix);
	452	mr_asprintf(bkpinfo->zip_suffix, "bz2");
[128]	453	bkpinfo->use_lzo = FALSE;
[998]	454	bkpinfo->use_gzip = FALSE;
[128]	455	}
[2327]	456	if (bkpinfo->zip_exe == NULL) {
	457	mr_asprintf(bkpinfo->zip_exe, "none");
	458	}
	459	if (bkpinfo->zip_suffix == NULL) {
	460	mr_asprintf(bkpinfo->zip_suffix, "");
	461	}
[128]	462	unlink(outlog);
	463	if (strstr(tarball_fname, ".star")) {
	464	bkpinfo->use_star = TRUE;
	465	if (strstr(tarball_fname, ".bz2"))
[2323]	466	mr_asprintf(command, "star -diff diffopts=mode,size,data file=%s %s >> %s 2>> %s", tarball_fname, (strstr(tarball_fname, ".bz2")) ? "-bz" : " ", outlog, outlog);
[128]	467	} else {
	468	bkpinfo->use_star = FALSE;
[2326]	469	/* Here we suppose that there is always a compression program called */
	470	if (bkpinfo->zip_exe) {
	471	mr_asprintf(command, "afio -r -P %s -Z %s >> %s 2>> %s", bkpinfo->zip_exe, tarball_fname, outlog, outlog);
	472	} else {
	473	mr_asprintf(command, "afio -r -Z %s >> %s 2>> %s", tarball_fname, outlog, outlog);
	474	}
[128]	475	}
	476	log_msg(6, "command=%s", command);
	477	paranoid_system(command);
[2276]	478	mr_free(command);
	479
[128]	480	if (length_of_file(outlog) < 10) {
[2323]	481	mr_asprintf(command, "cat %s >> %s", outlog, MONDO_LOGFILE);
[128]	482	} else {
[2323]	483	mr_asprintf(command, "cut -d: -f%d %s \| sort -u", (bkpinfo->use_star) ? 1 : 2, outlog);
[128]	484	pin = popen(command, "r");
	485	if (pin) {
	486	for (fgets(tmp, MAX_STR_LEN, pin); !feof(pin);
	487	fgets(tmp, MAX_STR_LEN, pin)) {
	488	if (bkpinfo->use_star) {
	489	if (!strstr(tmp, "diffopts=")) {
	490	while (strlen(tmp) > 0
	491	&& tmp[strlen(tmp) - 1] < 32) {
	492	tmp[strlen(tmp) - 1] = '\0';
	493	}
	494	if (strchr(tmp, '/')) {
	495	if (!diffs) {
	496	log_msg(0, "'%s' - differences found",
	497	tarball_fname);
	498	}
	499	log_msg(0, "star: /%s",
	500	strip_afio_output_line(tmp));
	501	diffs++;
	502	}
	503	}
	504	} else {
	505	if (!diffs) {
	506	log_msg(0, "'%s' - differences found",
	507	tarball_fname);
	508	}
	509	log_msg(0, "afio: /%s", strip_afio_output_line(tmp));
	510	diffs++;
	511	}
[1]	512	}
[128]	513	paranoid_pclose(pin);
	514	} else {
	515	log_OS_error(command);
	516	}
	517	}
[2276]	518	mr_free(command);
	519	mr_free(outlog);
[128]	520	paranoid_free(tmp);
	521	return (0);
[1]	522	}
	523
	524
	525
	526
	527
	528
	529	/**
	530	* Verify one afioball from the CD.
	531	* Checks for existence (calls fatal_error() if it does not exist) and
	532	* then calls verify_an_afioball().
	533	* @param bkpinfo The backup information structure. Passed to verify_an_afioball().
	534	* @param tarball_fname The filename of the afioball to verify.
	535	* @return The return value of verify_an_afioball().
	536	* @see verify_an_afioball
	537	*/
	538	int
[1645]	539	verify_an_afioball_from_CD(char *tarball_fname)
[1]	540	{
	541
[128]	542	/@ int ************************************************************ */
	543	int res = 0;
[1]	544
[128]	545	assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
[1]	546
[128]	547	log_msg(1, "Verifying %s", tarball_fname);
	548	if (!does_file_exist(tarball_fname)) {
	549	fatal_error("Cannot verify nonexistent afioball");
	550	}
[1645]	551	res = verify_a_tarball(tarball_fname);
[128]	552	return (res);
[1]	553	}
	554
	555
	556	/**
	557	* Verify one afioball from the opened tape/CD stream.
	558	* Copies the file from tape to tmpdir and then calls verify_an_afioball().
	559	* @param bkpinfo The backup information structure. Passed to verify_an_afioball().
	560	* @param orig_fname The original filename of the afioball to verify.
	561	* @param size The size of the afioball to verify.
	562	* @return The return value of verify_an_afioball().
	563	* @see verify_an_afioball
	564	*/
	565	int
[1645]	566	verify_an_afioball_from_stream(char *orig_fname, long long size)
[1]	567	{
	568
[128]	569	/@ int ************************************************************* */
	570	int retval = 0;
[1]	571	int res = 0;
	572
[128]	573	/@ buffers ********************************************************* */
[2276]	574	char *tmp = NULL;
	575	char *tarball_fname = NULL;
[1]	576
[128]	577	/@ pointers ******************************************************** */
	578	char *p;
[1]	579
[128]	580	assert(bkpinfo != NULL);
	581	assert_string_is_neither_NULL_nor_zerolength(orig_fname);
[1]	582
[128]	583	p = strrchr(orig_fname, '/');
	584	if (!p) {
	585	p = orig_fname;
	586	} else {
	587	p++;
	588	}
[2323]	589	mr_asprintf(tmp, "mkdir -p %s/tmpfs", bkpinfo->tmpdir);
[128]	590	paranoid_system(tmp);
[2276]	591	mr_free(tmp);
	592
[2323]	593	mr_asprintf(tarball_fname, "%s/tmpfs/temporary-%s", bkpinfo->tmpdir, p);
[1645]	594	read_file_from_stream_to_file(tarball_fname, size);
	595	res = verify_a_tarball(tarball_fname);
[128]	596	if (res) {
[2276]	597	log_msg(0, "Afioball '%s' no longer matches your live filesystem", p);
[128]	598	retval++;
	599	}
	600	unlink(tarball_fname);
[2276]	601	mr_free(tarball_fname);
[128]	602	return (retval);
[1]	603	}
	604
	605
	606	/**
	607	* Verify one biggiefile form the opened tape/CD stream.
	608	* @param bkpinfo The backup information structure. @c bkpinfo->tmpdir is the only field used.
	609	* @param biggie_fname The filename of the biggiefile to verify.
	610	* @param size The size in bytes of said biggiefile.
	611	* @return 0 for success (even if the file doesn't match); nonzero for a tape error.
	612	*/
	613	int
[1645]	614	verify_a_biggiefile_from_stream(char *biggie_fname, long long size)
[1]	615	{
	616
[128]	617	/@ int ************************************************************ */
	618	int retval = 0;
[1]	619	int res = 0;
	620	int current_slice_number = 0;
	621	int ctrl_chr = '\0';
	622
[128]	623	/@ char *********************************************************** */
[2276]	624	char *test_file = NULL;
[2334]	625	char *biggie_cksum = NULL;
	626	char *orig_cksum = NULL;
[2276]	627	char *tmp = NULL;
[1]	628	char *slice_fnam;
[128]	629
	630	/@ pointers ******************************************************* */
[1]	631	char *p;
	632
[128]	633	/@ long long ****************************************************** */
	634	long long slice_siz;
[1]	635
[128]	636	malloc_string(slice_fnam);
	637	assert(bkpinfo != NULL);
	638	assert_string_is_neither_NULL_nor_zerolength(biggie_fname);
[1]	639
[128]	640	p = strrchr(biggie_fname, '/');
	641	if (!p) {
	642	p = biggie_fname;
	643	} else {
	644	p++;
	645	}
[2323]	646	mr_asprintf(test_file, "%s/temporary-%s", bkpinfo->tmpdir, p);
[128]	647	for (res =
	648	read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr);
	649	ctrl_chr != BLK_STOP_A_BIGGIE;
	650	res =
[2334]	651	read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr)) {
[128]	652	if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
	653	wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
	654	}
[1645]	655	res = read_file_from_stream_to_file(test_file, slice_siz);
[128]	656	unlink(test_file);
	657	res =
[2334]	658	read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr);
[128]	659	if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
	660	log_msg(2, "test_file = %s", test_file);
	661	wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
	662	}
	663	current_slice_number++;
	664	retval += res;
[1]	665	}
[2334]	666	mr_asprintf(biggie_cksum, "%s", slice_fnam);
[128]	667	if (biggie_cksum[0] != '\0') {
[2334]	668	mr_asprintf(orig_cksum, "%s", calc_checksum_of_file(biggie_fname));
[128]	669	if (strcmp(biggie_cksum, orig_cksum)) {
[2276]	670	log_msg(2, "orig cksum=%s; curr cksum=%s", biggie_cksum, orig_cksum);
[2324]	671	log_to_screen("%s has changed on live filesystem", biggie_fname);
[2276]	672
[2323]	673	mr_asprintf(tmp, "echo \"%s\" >> %s/biggies.changed", biggie_fname, bkpinfo->tmpdir);
[128]	674	system(tmp);
[2276]	675	mr_free(tmp);
[128]	676	}
[1]	677	}
[2334]	678	mr_free(biggie_cksum);
[2276]	679	mr_free(test_file);
[2334]	680	mr_free(orig_cksum);
[128]	681	paranoid_free(slice_fnam);
	682	return (retval);
[1]	683	}
	684
	685
	686	/**
	687	* Verify all afioballs from the opened tape/CD stream.
	688	* @param bkpinfo The backup information structure. Fields used:
	689	* - @c bkpinfo->tmpdir
	690	*
	691	* @return 0 for success (even if there are differences); nonzero for a tape error.
	692	*/
[1645]	693	int verify_afioballs_from_stream()
[1]	694	{
[128]	695	/@ int ********************************************************* */
	696	int retval = 0;
[1]	697	int res = 0;
	698	long current_afioball_number = 0;
	699	int ctrl_chr = 0;
	700	int total_afioballs = 0;
	701
[128]	702	/@ buffers **************************************************** */
[2276]	703	char *tmp = NULL;
[1]	704	char *fname;
[2276]	705	char *curr_xattr_list_fname = NULL;
	706	char *curr_acl_list_fname = NULL;
[1]	707
[128]	708	/@ long long ************************************************** */
	709	long long size = 0;
[1]	710
[128]	711	assert(bkpinfo != NULL);
	712	malloc_string(fname);
[1]	713
[948]	714	if (g_getfattr) {
[2323]	715	mr_asprintf(curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
[948]	716	}
	717	if (g_getfacl) {
[2323]	718	mr_asprintf(curr_acl_list_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
[948]	719	}
[541]	720	log_to_screen("Verifying regular archives on tape");
[1645]	721	total_afioballs = get_last_filelist_number() + 1;
[541]	722	open_progress_form("Verifying filesystem",
	723	"I am verifying archives against your live filesystem now.",
	724	"Please wait. This may take a couple of hours.", "",
[128]	725	total_afioballs);
	726	res = read_header_block_from_stream(&size, fname, &ctrl_chr);
	727	if (ctrl_chr != BLK_START_AFIOBALLS) {
[2230]	728	log_it("YOU SHOULD NOT GET HERE");
	729	log_it("Grabbing the EXAT files");
[128]	730	if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
	731	res =
[1645]	732	read_EXAT_files_from_tape(&size, fname, &ctrl_chr,
[128]	733	curr_xattr_list_fname,
	734	curr_acl_list_fname);
	735	}
[1]	736	}
[128]	737	if (ctrl_chr != BLK_START_AFIOBALLS) {
	738	wrong_marker(BLK_START_AFIOBALLS, ctrl_chr);
[1]	739	}
[2276]	740	if (g_getfattr) {
	741	mr_free(curr_xattr_list_fname);
	742	}
	743	if (g_getfacl) {
	744	mr_free(curr_acl_list_fname);
	745	}
[128]	746
	747	for (res = read_header_block_from_stream(&size, fname, &ctrl_chr);
	748	ctrl_chr != BLK_STOP_AFIOBALLS;
	749	res = read_header_block_from_stream(&size, fname, &ctrl_chr)) {
[948]	750	if (g_getfattr) {
[2323]	751	mr_asprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, current_afioball_number);
[948]	752	}
	753	if (g_getfacl) {
[2323]	754	mr_asprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, current_afioball_number);
[948]	755	}
[128]	756	if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
[2230]	757	log_it("Reading EXAT files from tape");
[128]	758	res =
[1645]	759	read_EXAT_files_from_tape(&size, fname, &ctrl_chr,
[128]	760	curr_xattr_list_fname,
	761	curr_acl_list_fname);
	762	}
[2276]	763	if (g_getfattr) {
	764	mr_free(curr_xattr_list_fname);
	765	}
	766	if (g_getfacl) {
	767	mr_free(curr_acl_list_fname);
	768	}
[128]	769	if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
	770	wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
	771	}
[2323]	772	mr_asprintf(tmp, "Verifying fileset #%ld", current_afioball_number);
[128]	773	update_progress_form(tmp);
[2276]	774	mr_free(tmp);
	775
[1645]	776	res = verify_an_afioball_from_stream(fname, size);
[128]	777	if (res) {
[2324]	778	log_to_screen("Afioball %ld differs from live filesystem", current_afioball_number);
[128]	779	}
	780	retval += res;
	781	current_afioball_number++;
	782	g_current_progress++;
	783	res = read_header_block_from_stream(&size, fname, &ctrl_chr);
	784	if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
	785	wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
	786	}
[1]	787	}
[128]	788	log_msg(1, "All done with afioballs");
	789	close_progress_form();
	790	paranoid_free(fname);
	791	return (retval);
[1]	792	}
	793
	794	/**
	795	* Verify all biggiefiles on the opened CD/tape stream.
	796	* @param bkpinfo The backup information structure. Fields used:
	797	* - @c bkpinfo->restore_path
	798	* - @c bkpinfo->tmpdir
	799	*
	800	* @return 0 for success (even if there are differences); nonzero for a tape error.
	801	*/
[1645]	802	int verify_biggiefiles_from_stream()
[1]	803	{
	804
[128]	805	/@ int *********************************************************** */
	806	int retval = 0;
[1]	807	int res = 0;
	808	int ctrl_chr = 0;
	809
[128]	810	/@ long ********************************************************** */
	811	long noof_biggiefiles = 0;
[1]	812	long current_biggiefile_number = 0;
	813
[128]	814	/@ buffers ******************************************************* */
[2276]	815	char *orig_fname;
	816	char *logical_fname = NULL;
	817	char *comment = NULL;
	818	char *curr_xattr_list_fname = NULL;
	819	char *curr_acl_list_fname = NULL;
[128]	820	/@ pointers ****************************************************** */
[1]	821	char *p;
	822
[128]	823	/@ long long size ************************************************ */
	824	long long size = 0;
[1]	825
[128]	826	assert(bkpinfo != NULL);
	827	malloc_string(orig_fname);
[1]	828
[948]	829	if (g_getfattr) {
[2323]	830	mr_asprintf(curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
[948]	831	}
	832	if (g_getfacl) {
[2323]	833	mr_asprintf(curr_acl_list_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
[948]	834	}
[2323]	835	mr_asprintf(comment, "Verifying all bigfiles.");
[128]	836	log_to_screen(comment);
	837	res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr);
	838	if (ctrl_chr != BLK_START_BIGGIEFILES) {
	839	if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
[2230]	840	log_it("Grabbing the EXAT biggiefiles");
[128]	841	res =
[1645]	842	read_EXAT_files_from_tape(&size, orig_fname,
[128]	843	&ctrl_chr, curr_xattr_list_fname,
	844	curr_acl_list_fname);
	845	}
[1]	846	}
[2276]	847	if (g_getfattr) {
	848	mr_free(curr_xattr_list_fname);
	849	}
	850	if (g_getfacl) {
	851	mr_free(curr_acl_list_fname);
	852	}
	853
[128]	854	if (ctrl_chr != BLK_START_BIGGIEFILES) {
	855	wrong_marker(BLK_START_BIGGIEFILES, ctrl_chr);
[1]	856	}
[128]	857	noof_biggiefiles = (long) size;
	858	log_msg(1, "noof_biggiefiles = %ld", noof_biggiefiles);
[541]	859	open_progress_form("Verifying big files", comment,
	860	"Please wait. This may take some time.", "",
[128]	861	noof_biggiefiles);
[2276]	862	mr_free(comment);
	863
[128]	864	for (res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr);
	865	ctrl_chr != BLK_STOP_BIGGIEFILES;
	866	res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr))
[1]	867	{
[128]	868	if (ctrl_chr != BLK_START_A_NORMBIGGIE
	869	&& ctrl_chr != BLK_START_A_PIHBIGGIE) {
	870	wrong_marker(BLK_START_A_NORMBIGGIE, ctrl_chr);
	871	}
	872	p = strrchr(orig_fname, '/');
	873	if (!p) {
	874	p = orig_fname;
	875	} else {
	876	p++;
	877	}
[2323]	878	mr_asprintf(comment, "Verifying bigfile #%ld (%ld K)", current_biggiefile_number, (long) size >> 10);
[128]	879	update_progress_form(comment);
[2276]	880	mr_free(comment);
	881
[2327]	882	if (bkpinfo->restore_path) {
	883	mr_asprintf(logical_fname, "%s/%s", bkpinfo->restore_path, orig_fname);
	884	res = verify_a_biggiefile_from_stream(logical_fname, size);
	885	mr_free(logical_fname);
	886	retval += res;
	887	} else {
	888	log_it("Unable to verify bigfile as restore_path is NULL");
	889	}
[2276]	890
[128]	891	current_biggiefile_number++;
	892	g_current_progress++;
[1]	893	}
[128]	894	close_progress_form();
	895	paranoid_free(orig_fname);
	896	return (retval);
[1]	897	}
	898
	899	/* @} - end of LLverifyGroup */
	900
	901
	902	/**
[1709]	903	* Verify the USB device
	904	* @param bkpinfo The backup information structure. Fields used:
	905	* - @c bkpinfo->media_device
	906	* - @c bkpinfo->tmpdir
	907	* - @c bkpinfo->verify_data
	908	*
	909	* @return 0 for success (even if differences are found), nonzero for failure.
	910	* @ingroup verifyGroup
	911	*/
	912	int verify_usb_image()
	913	{
	914
	915	/@ int *********************************************************** */
	916	int retval = 0;
	917
	918	/@ buffers ******************************************************* */
	919	char *mountpoint = NULL;
	920	char *tmp = NULL;
	921	char *tmp1 = NULL;
	922	char *fname = NULL;
[1711]	923	int ret = 0;
[1709]	924	#ifdef __FreeBSD__
	925	char mdd[32];
	926	char *mddevice = mdd;
	927	int vndev = 2;
	928	#else
	929	//skip
	930	#endif
	931
	932	assert(bkpinfo != NULL);
	933
[2325]	934	if (bkpinfo->media_device == NULL) {
	935	return(1);
	936	}
	937
[2323]	938	mr_asprintf(fname, "%s1", bkpinfo->media_device);
[1709]	939	if (is_this_device_mounted(fname)) {
	940	log_msg(1, "USB device mounted. Remounting it at the right place");
[2323]	941	mr_asprintf(tmp, "umount %s", fname);
[1709]	942	run_program_and_log_output(tmp, FALSE);
	943	paranoid_free(tmp);
	944	}
	945	paranoid_free(fname);
	946
	947	log_msg(1, "Mounting USB device.");
[2323]	948	mr_asprintf(mountpoint, "%s/usb", bkpinfo->tmpdir);
	949	mr_asprintf(tmp, "mkdir -p %s", mountpoint);
[1709]	950	run_program_and_log_output(tmp, FALSE);
	951	paranoid_free(tmp);
	952	/* Mindi always create one single parition on the USB dev */
[2323]	953	mr_asprintf(tmp, "mount %s1 %s", bkpinfo->media_device, mountpoint);
[1709]	954	ret = run_program_and_log_output(tmp, FALSE);
	955	paranoid_free(tmp);
	956	if (ret) {
	957	paranoid_free(mountpoint);
	958	return(ret);
	959	}
	960
	961	sync();
	962	log_msg(2, "OK, I've mounted the USB Disk/Key\n");
[2323]	963	mr_asprintf(tmp, "%s/archives/NOT-THE-LAST", mountpoint);
[1709]	964	if (!does_file_exist(tmp)) {
	965	log_msg
	966	(2,
	967	"This is the last USB device. I am therefore setting bkpinfo->verify_data to FALSE.");
	968	bkpinfo->verify_data = FALSE;
	969	/*
	970	(a) It's an easy way to tell the calling subroutine that we've finished &
	971	there are no more device to be verified; (b) It stops the post-backup verifier
	972	from running after the per-device verifier has run too.
	973	*/
	974	}
	975	paranoid_free(tmp);
	976	verify_afioballs_on_CD(mountpoint);
[2230]	977	log_it("before verify_all_slices");
[1709]	978	verify_all_slices_on_CD(mountpoint);
	979
[2323]	980	mr_asprintf(tmp1, "umount %s", mountpoint);
[1709]	981	#ifdef __FreeBSD__
	982	ret += system(tmp1);
	983	ret += kick_vn(mddevice);
	984	if (ret)
	985	#else
	986	if (system(tmp1))
	987	#endif
	988	{
[2324]	989	log_to_screen("%s failed; unable to unmount USB device\n", tmp1);
[1709]	990	retval++;
	991	} else {
	992	log_msg(2, "OK, I've unmounted the USB device\n");
	993	}
[2324]	994	mr_free(tmp1);
	995	mr_free(mountpoint);
[1709]	996	return (retval);
	997	}
	998
	999
	1000	/**
[1]	1001	* Verify the CD indicated by @c g_current_media_number.
	1002	* @param bkpinfo The backup information structure. Fields used:
	1003	* - @c bkpinfo->isodir
[20]	1004	* - @c bkpinfo->prefix
[1]	1005	* - @c bkpinfo->manual_cd_tray
	1006	* - @c bkpinfo->media_device
	1007	* - @c bkpinfo->nfs_remote_dir
	1008	* - @c bkpinfo->tmpdir
	1009	* - @c bkpinfo->verify_data
	1010	*
	1011	* @return 0 for success (even if differences are found), nonzero for failure.
	1012	* @ingroup verifyGroup
	1013	*/
[1645]	1014	int verify_cd_image()
[1]	1015	{
	1016
[128]	1017	/@ int *********************************************************** */
	1018	int retval = 0;
[1]	1019
[128]	1020	/@ buffers ******************************************************* */
[2276]	1021	char *mountpoint = NULL;
	1022	char *command = NULL;
	1023	char *tmp = NULL;
	1024	char *fname = NULL;
[1]	1025	#ifdef __FreeBSD__
[128]	1026	char mdd[32];
[1]	1027	char *mddevice = mdd;
[128]	1028	int ret = 0;
	1029	int vndev = 2;
[1]	1030	#else
	1031	//skip
	1032	#endif
	1033
[128]	1034	assert(bkpinfo != NULL);
[1]	1035
[2325]	1036	if (bkpinfo->media_device == NULL) {
	1037	return(1);
	1038	}
	1039
[2323]	1040	mr_asprintf(mountpoint, "%s/cdrom", bkpinfo->tmpdir);
[2325]	1041	if (((bkpinfo->isodir == NULL) && (bkpinfo->nfs_remote_dir == NULL)) \|\| (bkpinfo->prefix == NULL)) {
	1042	fatal_error("No iso filename preparation possible");
	1043	}
	1044	if (bkpinfo->nfs_remote_dir) {
	1045	// NFS
	1046	mr_asprintf(fname, "%s/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->nfs_remote_dir, bkpinfo->prefix, g_current_media_number);
	1047	} else {
	1048	// ISO
	1049	mr_asprintf(fname, "%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->prefix, g_current_media_number);
	1050	}
[128]	1051
	1052	mkdir(mountpoint, 1777);
	1053	sync();
	1054	if (!does_file_exist(fname)) {
[2276]	1055	log_msg(2, "%s not found; assuming you backed up to CD; verifying CD...", fname);
[128]	1056	if (bkpinfo->manual_cd_tray) {
[541]	1057	popup_and_OK("Please push CD tray closed.");
[128]	1058	}
[1645]	1059	if (find_and_mount_actual_cd(mountpoint)) {
[541]	1060	log_to_screen("failed to mount actual CD");
[2276]	1061	mr_free(mountpoint);
	1062	mr_free(fname);
[128]	1063	return (1);
	1064	}
	1065	} else {
[2276]	1066	log_msg(2, "%s found; verifying ISO...", fname);
[1]	1067	#ifdef __FreeBSD__
[128]	1068	ret = 0;
	1069	vndev = 2;
	1070	mddevice = make_vn(fname);
	1071	if (ret) {
[2324]	1072	log_to_screen("make_vn of %s failed; unable to verify ISO\n", fname);
[2276]	1073	mr_free(mountpoint);
	1074	mr_free(fname);
[128]	1075	return (1);
	1076	}
[2323]	1077	mr_asprintf(command, "mount_cd9660 %s %s", mddevice, mountpoint);
[1]	1078	#else
[2323]	1079	mr_asprintf(command, "mount -o loop,ro -t iso9660 %s %s", fname, mountpoint);
[1]	1080	#endif
[128]	1081	if (run_program_and_log_output(command, FALSE)) {
[2324]	1082	log_to_screen("%s failed; unable to mount ISO image\n", command);
[2276]	1083	mr_free(mountpoint);
	1084	mr_free(command);
	1085	mr_free(fname);
[128]	1086	return (1);
	1087	}
[2276]	1088	mr_free(command);
[1]	1089	}
[128]	1090	log_msg(2, "OK, I've mounted the ISO/CD\n");
[2323]	1091	mr_asprintf(tmp, "%s/archives/NOT-THE-LAST", mountpoint);
[128]	1092	if (!does_file_exist(tmp)) {
	1093	log_msg
	1094	(2,
	1095	"This is the last CD. I am therefore setting bkpinfo->verify_data to FALSE.");
	1096	bkpinfo->verify_data = FALSE;
[1]	1097	/*
	1098	(a) It's an easy way to tell the calling subroutine that we've finished &
	1099	there are no more CD's to be verified; (b) It stops the post-backup verifier
	1100	from running after the per-CD verifier has run too.
	1101	*/
[128]	1102	}
[2276]	1103	mr_free(tmp);
	1104
[1645]	1105	verify_afioballs_on_CD(mountpoint);
[2230]	1106	log_it("before verify_all_slices");
[1645]	1107	verify_all_slices_on_CD(mountpoint);
[1]	1108
	1109	#ifdef __FreeBSD__
[128]	1110	ret = 0;
[2323]	1111	mr_asprintf(command, "umount %s", mountpoint);
[128]	1112	ret += system(command);
	1113	ret += kick_vn(mddevice);
[2324]	1114	if (ret) {
[1]	1115	#else
[2323]	1116	mr_asprintf(command, "umount %s", mountpoint);
[2324]	1117	if (system(command)) {
[1]	1118	#endif
[2324]	1119	log_to_screen("%s failed; unable to unmount ISO image\n", command);
[2276]	1120
[128]	1121	retval++;
	1122	} else {
	1123	log_msg(2, "OK, I've unmounted the ISO file\n");
[1]	1124	}
[2276]	1125	mr_free(mountpoint);
	1126	mr_free(command);
	1127
[128]	1128	if (!does_file_exist(fname)) {
[2323]	1129	mr_asprintf(command, "umount %s", bkpinfo->media_device);
[128]	1130	run_program_and_log_output(command, 2);
[2276]	1131	mr_free(command);
	1132
[2325]	1133	if (!bkpinfo->please_dont_eject && eject_device(bkpinfo->media_device)) {
[128]	1134	log_msg(2, "Failed to eject CD-ROM drive");
	1135	}
	1136	}
[2276]	1137	mr_free(fname);
[128]	1138	return (retval);
[1]	1139	}
	1140
	1141	/**
	1142	* Verify all backups on tape.
	1143	* This should be done after the backup process has already closed the tape.
	1144	* @param bkpinfo The backup information structure. Passed to various helper functions.
	1145	* @return 0 for success (even if thee were differences), nonzero for failure.
	1146	* @ingroup verifyGroup
	1147	*/
[1645]	1148	int verify_tape_backups()
[1]	1149	{
	1150
[128]	1151	/@ int *********************************************************** */
	1152	int retval = 0;
[1]	1153
[128]	1154	/@ buffers ******************************************************* */
[2276]	1155	char *tmp = NULL;
	1156	char *changed_files_fname = NULL;
[1]	1157
[128]	1158	/@ long ********************************************************** */
	1159	long diffs = 0;
[1]	1160
[128]	1161	assert(bkpinfo != NULL);
[1]	1162
[128]	1163	log_msg(3, "verify_tape_backups --- starting");
[541]	1164	log_to_screen("Verifying backups");
[1645]	1165	openin_tape();
[1]	1166	/* verify archives themselves */
[1645]	1167	retval += verify_afioballs_from_stream();
	1168	retval += verify_biggiefiles_from_stream();
[1]	1169	/* find the final blocks */
[128]	1170	paranoid_system("sync");
	1171	sleep(2);
[1645]	1172	closein_tape();
[1]	1173	/* close tape; exit */
	1174	// fclose(g_tape_stream); <-- not needed; is handled by closein_tape()
[2323]	1175	mr_asprintf(tmp, "rm -f %s/biggies.changed %s/changed.files 2> /dev/null", bkpinfo->tmpdir, bkpinfo->tmpdir);
[1644]	1176	paranoid_system(tmp);
[2276]	1177	mr_free(tmp);
	1178
[2323]	1179	mr_asprintf(changed_files_fname, "%s/changed.files", bkpinfo->tmpdir);
	1180	mr_asprintf(tmp, "grep -E '^%s:.$' %s \| cut -d'\"' -f2 \| sort -u \| awk '{print \"/\"$0;};' \| tr -s '/' '/' \| grep -v \"(total of\" \| grep -v \"incheckentry.xwait\" \| grep -vE '^/afio:.$' \| grep -vE '^dev/.$' > %s", (bkpinfo->use_star) ? "star" : "afio", MONDO_LOGFILE, changed_files_fname);
[128]	1181	log_msg(2, "Running command to derive list of changed files");
	1182	log_msg(2, tmp);
	1183	if (system(tmp)) {
[2276]	1184	if (does_file_exist(changed_files_fname) && length_of_file(changed_files_fname) > 2) {
	1185	log_to_screen("Warning - unable to check logfile to derive list of changed files");
[128]	1186	} else {
[2276]	1187	log_to_screen("No differences found. Therefore, no 'changed.files' text file.");
[128]	1188	}
	1189	}
[2276]	1190	mr_free(tmp);
	1191
[2323]	1192	mr_asprintf(tmp, "cat %s/biggies.changed >> %s", bkpinfo->tmpdir, changed_files_fname);
[128]	1193	paranoid_system(tmp);
[2276]	1194	mr_free(tmp);
[1]	1195
[128]	1196	diffs = count_lines_in_file(changed_files_fname);
	1197	if (diffs > 0) {
[2323]	1198	mr_asprintf(tmp, "cp -f %s %s/changed.files", changed_files_fname, MONDO_CACHE);
[128]	1199	run_program_and_log_output(tmp, FALSE);
[2276]	1200	mr_free(tmp);
	1201
	1202	log_msg(0, "%ld files differed from live filesystem; type less %s or less %s/changed.files to see", diffs, changed_files_fname, MONDO_CACHE);
[1747]	1203	log_to_screen("See "MONDO_CACHE"/changed.files for a list of nonmatching files.");
[1644]	1204	log_to_screen("The files probably changed on filesystem, not on backup media.");
[128]	1205	}
[2276]	1206	mr_free(changed_files_fname);
[128]	1207	return (retval);
[1]	1208	}
	1209
	1210
	1211

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

Download in other formats: