Context Navigation

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

Visit:

Last change on this file since 2376 was 2376, checked in by Bruno Cornec, 15 years ago
replace system("sync") by sync() calls
Property svn:keywords set to `Id`
File size: 35.6 KB

Rev	Line
[1]	1	/***************************************************************************
[2211]	2	$Id: libmondo-verify.c 2376 2009-09-09 10:37:59Z 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 2376 2009-09-09 10:37:59Z 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);
[2376]	94	sync();
[128]	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");
[2338]	256	} else if (bkpinfo->use_lzma) {
	257	mr_asprintf(sz_exe, "lzma");
[128]	258	} else {
[2327]	259	mr_asprintf(sz_exe, "bzip2");
[128]	260	}
	261	}
[1]	262
[2230]	263	log_it("before vsbf");
[2242]	264	mds = media_descriptor_string(bkpinfo->backup_media_type);
[2323]	265	mr_asprintf(tmp, "Verifying %s#%d's big files", mds, g_current_media_number);
[2242]	266	mr_free(mds);
	267
[128]	268	open_evalcall_form(tmp);
[2276]	269	mr_free(tmp);
	270
[2230]	271	log_it("after vsbf");
[2323]	272	mr_asprintf(mountpoint, "%s/archives", mtpt);
[128]	273	if (last_bigfile_num == -1) {
	274	bigfile_num = 0;
	275	slice_num = 0;
	276	} else if (slice_num == 0) {
	277	bigfile_num = last_bigfile_num + 1;
	278	slice_num = 0;
	279	} else {
	280	bigfile_num = last_bigfile_num;
	281	slice_num = last_slice_num + 1;
	282	}
[2276]	283	while (does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, bkpinfo->zip_suffix))
[128]	284	\|\|
[2276]	285	does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, ""))) {
[1236]	286	// handle slices until end of CD
[128]	287	if (slice_num == 0) {
[2327]	288	log_msg(2, "ISO=%d bigfile=%ld --START--", g_current_media_number, bigfile_num);
[2276]	289	if (! (fin = fopen(slice_fname(bigfile_num, slice_num, mountpoint, ""), "r"))) {
[128]	290	log_msg(2, "Cannot open bigfile's info file");
	291	} else {
[2276]	292	if (fread ((void *) &biggiestruct, 1, sizeof(biggiestruct), fin) < sizeof(biggiestruct)) {
[128]	293	log_msg(2, "Unable to get biggiestruct");
	294	}
	295	paranoid_fclose(fin);
	296	}
[2327]	297	if (bkpinfo->restore_path) {
	298	mr_asprintf(tmp, "%s/%s", bkpinfo->restore_path, biggiestruct.filename);
	299	log_msg(2, "Opening biggiefile #%ld - '%s'", bigfile_num, tmp);
	300	forig = fopen(tmp, "r");
[2276]	301	mr_free(tmp);
[2327]	302
	303	if (!forig) {
	304	log_msg(2, "Failed to open bigfile. Darn.");
	305	log_to_screen("%s/%s not found on live filesystem", bkpinfo->restore_path, biggiestruct.filename);
	306	mr_asprintf(tmp, "echo \"%s/%s not found\" >> %s/biggies.changed", bkpinfo->restore_path, biggiestruct.filename, bkpinfo->tmpdir);
	307	system(tmp);
	308	mr_free(tmp);
[1236]	309
[2327]	310	bigfile_num++;
	311	slice_num = 0;
	312	retval++;
	313	} else {
	314	slice_num++;
	315	}
[1236]	316	} else {
[2327]	317	log_it("Unable to open bigfile as restore_path is NULL");
[128]	318	}
[1236]	319	} else if (does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, "")) &&
	320	(length_of_file(slice_fname(bigfile_num, slice_num, mountpoint, "")) == 0)) {
[128]	321	log_msg(2, "ISO=%d bigfile=%ld ---END---",
	322	g_current_media_number, bigfile_num);
	323	bigfile_num++;
	324	paranoid_fclose(forig);
	325	slice_num = 0;
	326	} else {
[2327]	327	log_msg(2, "ISO=%d bigfile=%ld slice=%ld", g_current_media_number, bigfile_num, slice_num);
	328	if ((!does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, ""))) && (sz_exe != NULL)) {
[2323]	329	mr_asprintf(command, "%s -dc %s 2>> %s", sz_exe, slice_fname(bigfile_num, slice_num, mountpoint, bkpinfo->zip_suffix), MONDO_LOGFILE);
[128]	330	} else {
[2323]	331	mr_asprintf(command, "cat %s 2>> %s", slice_fname(bigfile_num, slice_num, mountpoint, ""), MONDO_LOGFILE);
[128]	332	}
[2276]	333	pin = popen(command, "r");
	334	mr_free(command);
	335	if (pin) {
[128]	336	res = 0;
	337	while (!feof(pin)) {
	338	currsizA = fread(bufblkA, 1, maxbufsize, pin);
	339	if (currsizA <= 0) {
	340	break;
	341	}
	342	currsizB = fread(bufblkB, 1, currsizA, forig);
	343	if (currsizA != currsizB) {
	344	res++;
	345	} else {
	346	for (j = 0;
	347	j < currsizA && bufblkA[j] == bufblkB[j];
	348	j++);
	349	if (j < currsizA) {
	350	res++;
	351	}
	352	}
	353	}
	354	paranoid_pclose(pin);
[1236]	355	if (res && !strncmp(biggiestruct.filename, "/dev/", 5)) {
[128]	356	log_msg(3,
[296]	357	"Ignoring differences between %s and live filesystem because it's a device and therefore the archives are stored via ntfsclone, not dd.",
[128]	358	biggiestruct.filename);
	359	log_msg(3,
	360	"If you really want verification for %s, please contact the devteam and offer an incentive.",
	361	biggiestruct.filename);
	362	res = 0;
	363	}
	364	if (res) {
	365	log_msg(0,
	366	"afio: \"%s\": Corrupt biggie file, says libmondo-archive.c",
	367	biggiestruct.filename);
	368	retval++;
	369	}
	370	}
	371	slice_num++;
	372	}
[1]	373	}
[2276]	374	mr_free(mountpoint);
[2327]	375	mr_free(sz_exe);
	376
[128]	377	last_bigfile_num = bigfile_num;
	378	last_slice_num = slice_num - 1;
	379	if (last_slice_num < 0) {
	380	last_bigfile_num--;
[1]	381	}
[128]	382	close_evalcall_form();
	383	if (bufblkA) {
	384	paranoid_free(bufblkA);
[1]	385	}
[128]	386	if (bufblkB) {
	387	paranoid_free(bufblkB);
	388	}
	389	return (0);
[1]	390	}
	391
	392
	393
	394
	395
	396
	397	/**
	398	* Verify one afioball from the CD.
	399	* You should be changed to the root directory (/) for this to work.
	400	* @param bkpinfo The backup information structure. Fields used:
	401	* - @c bkpinfo->use_lzo
	402	* - @c bkpinfo->tmpdir
	403	* - @c bkpinfo->zip_exe
	404	* - @c bkpinfo->zip_suffix
	405	* @param tarball_fname The filename of the afioball to verify.
	406	* @return 0, always.
	407	*/
[1645]	408	int verify_a_tarball(char *tarball_fname)
[1]	409	{
[128]	410	/@ buffers ******************************************************** */
[2276]	411	char *command = NULL;
	412	char *outlog = NULL;
[2357]	413	char *tmp = NULL;
[1]	414
[128]	415	/@ pointers ****************************************************** */
	416	FILE *pin;
[1]	417
[128]	418	/@ long ********************************************************** */
	419	long diffs = 0;
	420	/* getcwd(old_pwd,MAX_STR_LEN-1); */
[1]	421
	422
[128]	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;
[2338]	437	bkpinfo->use_lzma = FALSE;
[128]	438	}
[2326]	439	if (strstr(tarball_fname, ".gz") && strcmp(bkpinfo->zip_suffix, "gz")) {
[998]	440	log_msg(2, "OK, I'm going to start using gzip.");
[2326]	441	mr_free(bkpinfo->zip_exe);
	442	mr_asprintf(bkpinfo->zip_exe, "gzip");
[2327]	443	mr_free(bkpinfo->zip_suffix);
	444	mr_asprintf(bkpinfo->zip_suffix, "gz");
[998]	445	bkpinfo->use_lzo = FALSE;
	446	bkpinfo->use_gzip = TRUE;
[2338]	447	bkpinfo->use_lzma = FALSE;
[998]	448	}
[2326]	449	if (strstr(tarball_fname, ".bz2") && strcmp(bkpinfo->zip_suffix, "bz2")) {
[128]	450	log_msg(2, "OK, I'm going to start using bzip2.");
[2326]	451	mr_free(bkpinfo->zip_exe);
	452	mr_asprintf(bkpinfo->zip_exe, "bzip2");
[2327]	453	mr_free(bkpinfo->zip_suffix);
	454	mr_asprintf(bkpinfo->zip_suffix, "bz2");
[128]	455	bkpinfo->use_lzo = FALSE;
[998]	456	bkpinfo->use_gzip = FALSE;
[2338]	457	bkpinfo->use_lzma = FALSE;
[128]	458	}
[2338]	459	if (strstr(tarball_fname, ".lzma") && strcmp(bkpinfo->zip_suffix, "lzma")) {
	460	log_msg(2, "OK, I'm going to start using lzma.");
	461	mr_free(bkpinfo->zip_exe);
	462	mr_asprintf(bkpinfo->zip_exe, "lzma");
	463	mr_free(bkpinfo->zip_suffix);
	464	mr_asprintf(bkpinfo->zip_suffix, "lzma");
	465	bkpinfo->use_lzo = FALSE;
	466	bkpinfo->use_gzip = FALSE;
	467	bkpinfo->use_lzma = TRUE;
	468	}
[2327]	469	if (bkpinfo->zip_exe == NULL) {
	470	mr_asprintf(bkpinfo->zip_exe, "none");
	471	}
	472	if (bkpinfo->zip_suffix == NULL) {
	473	mr_asprintf(bkpinfo->zip_suffix, "");
	474	}
[128]	475	unlink(outlog);
	476	if (strstr(tarball_fname, ".star")) {
	477	bkpinfo->use_star = TRUE;
	478	if (strstr(tarball_fname, ".bz2"))
[2323]	479	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]	480	} else {
	481	bkpinfo->use_star = FALSE;
[2326]	482	/* Here we suppose that there is always a compression program called */
	483	if (bkpinfo->zip_exe) {
	484	mr_asprintf(command, "afio -r -P %s -Z %s >> %s 2>> %s", bkpinfo->zip_exe, tarball_fname, outlog, outlog);
	485	} else {
	486	mr_asprintf(command, "afio -r -Z %s >> %s 2>> %s", tarball_fname, outlog, outlog);
	487	}
[128]	488	}
	489	log_msg(6, "command=%s", command);
	490	paranoid_system(command);
[2276]	491	mr_free(command);
	492
[128]	493	if (length_of_file(outlog) < 10) {
[2323]	494	mr_asprintf(command, "cat %s >> %s", outlog, MONDO_LOGFILE);
[128]	495	} else {
[2323]	496	mr_asprintf(command, "cut -d: -f%d %s \| sort -u", (bkpinfo->use_star) ? 1 : 2, outlog);
[128]	497	pin = popen(command, "r");
	498	if (pin) {
[2357]	499	for (mr_getline(tmp, pin); !feof(pin); mr_getline(tmp, pin)) {
[128]	500	if (bkpinfo->use_star) {
	501	if (!strstr(tmp, "diffopts=")) {
[2357]	502	while (strlen(tmp) > 0 && tmp[strlen(tmp) - 1] < 32) {
[128]	503	tmp[strlen(tmp) - 1] = '\0';
	504	}
	505	if (strchr(tmp, '/')) {
	506	if (!diffs) {
[2357]	507	log_msg(0, "'%s' - differences found", tarball_fname);
[128]	508	}
[2357]	509	log_msg(0, "star: /%s", strip_afio_output_line(tmp));
[128]	510	diffs++;
	511	}
	512	}
	513	} else {
	514	if (!diffs) {
[2357]	515	log_msg(0, "'%s' - differences found", tarball_fname);
[128]	516	}
	517	log_msg(0, "afio: /%s", strip_afio_output_line(tmp));
	518	diffs++;
	519	}
[2357]	520	mr_free(tmp);
[1]	521	}
[2357]	522	mr_free(tmp);
[128]	523	paranoid_pclose(pin);
	524	} else {
	525	log_OS_error(command);
	526	}
	527	}
[2276]	528	mr_free(command);
	529	mr_free(outlog);
[128]	530	return (0);
[1]	531	}
	532
	533
	534
	535
	536
	537
	538	/**
	539	* Verify one afioball from the CD.
	540	* Checks for existence (calls fatal_error() if it does not exist) and
	541	* then calls verify_an_afioball().
	542	* @param bkpinfo The backup information structure. Passed to verify_an_afioball().
	543	* @param tarball_fname The filename of the afioball to verify.
	544	* @return The return value of verify_an_afioball().
	545	* @see verify_an_afioball
	546	*/
	547	int
[1645]	548	verify_an_afioball_from_CD(char *tarball_fname)
[1]	549	{
	550
[128]	551	/@ int ************************************************************ */
	552	int res = 0;
[1]	553
[128]	554	assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
[1]	555
[128]	556	log_msg(1, "Verifying %s", tarball_fname);
	557	if (!does_file_exist(tarball_fname)) {
	558	fatal_error("Cannot verify nonexistent afioball");
	559	}
[1645]	560	res = verify_a_tarball(tarball_fname);
[128]	561	return (res);
[1]	562	}
	563
	564
	565	/**
	566	* Verify one afioball from the opened tape/CD stream.
	567	* Copies the file from tape to tmpdir and then calls verify_an_afioball().
	568	* @param bkpinfo The backup information structure. Passed to verify_an_afioball().
	569	* @param orig_fname The original filename of the afioball to verify.
	570	* @param size The size of the afioball to verify.
	571	* @return The return value of verify_an_afioball().
	572	* @see verify_an_afioball
	573	*/
	574	int
[1645]	575	verify_an_afioball_from_stream(char *orig_fname, long long size)
[1]	576	{
	577
[128]	578	/@ int ************************************************************* */
	579	int retval = 0;
[1]	580	int res = 0;
	581
[128]	582	/@ buffers ********************************************************* */
[2276]	583	char *tmp = NULL;
	584	char *tarball_fname = NULL;
[1]	585
[128]	586	/@ pointers ******************************************************** */
	587	char *p;
[1]	588
[128]	589	assert(bkpinfo != NULL);
	590	assert_string_is_neither_NULL_nor_zerolength(orig_fname);
[1]	591
[128]	592	p = strrchr(orig_fname, '/');
	593	if (!p) {
	594	p = orig_fname;
	595	} else {
	596	p++;
	597	}
[2323]	598	mr_asprintf(tmp, "mkdir -p %s/tmpfs", bkpinfo->tmpdir);
[128]	599	paranoid_system(tmp);
[2276]	600	mr_free(tmp);
	601
[2323]	602	mr_asprintf(tarball_fname, "%s/tmpfs/temporary-%s", bkpinfo->tmpdir, p);
[1645]	603	read_file_from_stream_to_file(tarball_fname, size);
	604	res = verify_a_tarball(tarball_fname);
[128]	605	if (res) {
[2276]	606	log_msg(0, "Afioball '%s' no longer matches your live filesystem", p);
[128]	607	retval++;
	608	}
	609	unlink(tarball_fname);
[2276]	610	mr_free(tarball_fname);
[128]	611	return (retval);
[1]	612	}
	613
	614
	615	/**
	616	* Verify one biggiefile form the opened tape/CD stream.
	617	* @param bkpinfo The backup information structure. @c bkpinfo->tmpdir is the only field used.
	618	* @param biggie_fname The filename of the biggiefile to verify.
	619	* @param size The size in bytes of said biggiefile.
	620	* @return 0 for success (even if the file doesn't match); nonzero for a tape error.
	621	*/
	622	int
[1645]	623	verify_a_biggiefile_from_stream(char *biggie_fname, long long size)
[1]	624	{
	625
[128]	626	/@ int ************************************************************ */
	627	int retval = 0;
[1]	628	int res = 0;
	629	int current_slice_number = 0;
	630	int ctrl_chr = '\0';
	631
[128]	632	/@ char *********************************************************** */
[2276]	633	char *test_file = NULL;
[2334]	634	char *biggie_cksum = NULL;
	635	char *orig_cksum = NULL;
[2276]	636	char *tmp = NULL;
[1]	637	char *slice_fnam;
[128]	638
	639	/@ pointers ******************************************************* */
[1]	640	char *p;
	641
[128]	642	/@ long long ****************************************************** */
	643	long long slice_siz;
[1]	644
[128]	645	malloc_string(slice_fnam);
	646	assert(bkpinfo != NULL);
	647	assert_string_is_neither_NULL_nor_zerolength(biggie_fname);
[1]	648
[128]	649	p = strrchr(biggie_fname, '/');
	650	if (!p) {
	651	p = biggie_fname;
	652	} else {
	653	p++;
	654	}
[2323]	655	mr_asprintf(test_file, "%s/temporary-%s", bkpinfo->tmpdir, p);
[128]	656	for (res =
	657	read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr);
	658	ctrl_chr != BLK_STOP_A_BIGGIE;
	659	res =
[2334]	660	read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr)) {
[128]	661	if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
	662	wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
	663	}
[1645]	664	res = read_file_from_stream_to_file(test_file, slice_siz);
[128]	665	unlink(test_file);
	666	res =
[2334]	667	read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr);
[128]	668	if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
	669	log_msg(2, "test_file = %s", test_file);
	670	wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
	671	}
	672	current_slice_number++;
	673	retval += res;
[1]	674	}
[2334]	675	mr_asprintf(biggie_cksum, "%s", slice_fnam);
[128]	676	if (biggie_cksum[0] != '\0') {
[2357]	677	orig_cksum = calc_checksum_of_file(biggie_fname);
[128]	678	if (strcmp(biggie_cksum, orig_cksum)) {
[2276]	679	log_msg(2, "orig cksum=%s; curr cksum=%s", biggie_cksum, orig_cksum);
[2324]	680	log_to_screen("%s has changed on live filesystem", biggie_fname);
[2276]	681
[2323]	682	mr_asprintf(tmp, "echo \"%s\" >> %s/biggies.changed", biggie_fname, bkpinfo->tmpdir);
[128]	683	system(tmp);
[2276]	684	mr_free(tmp);
[128]	685	}
[2357]	686	mr_free(orig_cksum);
[1]	687	}
[2334]	688	mr_free(biggie_cksum);
[2276]	689	mr_free(test_file);
[128]	690	paranoid_free(slice_fnam);
	691	return (retval);
[1]	692	}
	693
	694
	695	/**
	696	* Verify all afioballs from the opened tape/CD stream.
	697	* @param bkpinfo The backup information structure. Fields used:
	698	* - @c bkpinfo->tmpdir
	699	*
	700	* @return 0 for success (even if there are differences); nonzero for a tape error.
	701	*/
[1645]	702	int verify_afioballs_from_stream()
[1]	703	{
[128]	704	/@ int ********************************************************* */
	705	int retval = 0;
[1]	706	int res = 0;
	707	long current_afioball_number = 0;
	708	int ctrl_chr = 0;
	709	int total_afioballs = 0;
	710
[128]	711	/@ buffers **************************************************** */
[2276]	712	char *tmp = NULL;
[1]	713	char *fname;
[2276]	714	char *curr_xattr_list_fname = NULL;
	715	char *curr_acl_list_fname = NULL;
[1]	716
[128]	717	/@ long long ************************************************** */
	718	long long size = 0;
[1]	719
[128]	720	assert(bkpinfo != NULL);
	721	malloc_string(fname);
[1]	722
[948]	723	if (g_getfattr) {
[2323]	724	mr_asprintf(curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
[948]	725	}
	726	if (g_getfacl) {
[2323]	727	mr_asprintf(curr_acl_list_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
[948]	728	}
[541]	729	log_to_screen("Verifying regular archives on tape");
[1645]	730	total_afioballs = get_last_filelist_number() + 1;
[541]	731	open_progress_form("Verifying filesystem",
	732	"I am verifying archives against your live filesystem now.",
	733	"Please wait. This may take a couple of hours.", "",
[128]	734	total_afioballs);
	735	res = read_header_block_from_stream(&size, fname, &ctrl_chr);
	736	if (ctrl_chr != BLK_START_AFIOBALLS) {
[2230]	737	log_it("YOU SHOULD NOT GET HERE");
	738	log_it("Grabbing the EXAT files");
[128]	739	if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
	740	res =
[1645]	741	read_EXAT_files_from_tape(&size, fname, &ctrl_chr,
[128]	742	curr_xattr_list_fname,
	743	curr_acl_list_fname);
	744	}
[1]	745	}
[128]	746	if (ctrl_chr != BLK_START_AFIOBALLS) {
	747	wrong_marker(BLK_START_AFIOBALLS, ctrl_chr);
[1]	748	}
[2276]	749	if (g_getfattr) {
	750	mr_free(curr_xattr_list_fname);
	751	}
	752	if (g_getfacl) {
	753	mr_free(curr_acl_list_fname);
	754	}
[128]	755
	756	for (res = read_header_block_from_stream(&size, fname, &ctrl_chr);
	757	ctrl_chr != BLK_STOP_AFIOBALLS;
	758	res = read_header_block_from_stream(&size, fname, &ctrl_chr)) {
[948]	759	if (g_getfattr) {
[2323]	760	mr_asprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, current_afioball_number);
[948]	761	}
	762	if (g_getfacl) {
[2323]	763	mr_asprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, current_afioball_number);
[948]	764	}
[128]	765	if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
[2230]	766	log_it("Reading EXAT files from tape");
[128]	767	res =
[1645]	768	read_EXAT_files_from_tape(&size, fname, &ctrl_chr,
[128]	769	curr_xattr_list_fname,
	770	curr_acl_list_fname);
	771	}
[2276]	772	if (g_getfattr) {
	773	mr_free(curr_xattr_list_fname);
	774	}
	775	if (g_getfacl) {
	776	mr_free(curr_acl_list_fname);
	777	}
[128]	778	if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
	779	wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
	780	}
[2323]	781	mr_asprintf(tmp, "Verifying fileset #%ld", current_afioball_number);
[128]	782	update_progress_form(tmp);
[2276]	783	mr_free(tmp);
	784
[1645]	785	res = verify_an_afioball_from_stream(fname, size);
[128]	786	if (res) {
[2324]	787	log_to_screen("Afioball %ld differs from live filesystem", current_afioball_number);
[128]	788	}
	789	retval += res;
	790	current_afioball_number++;
	791	g_current_progress++;
	792	res = read_header_block_from_stream(&size, fname, &ctrl_chr);
	793	if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
	794	wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
	795	}
[1]	796	}
[128]	797	log_msg(1, "All done with afioballs");
	798	close_progress_form();
	799	paranoid_free(fname);
	800	return (retval);
[1]	801	}
	802
	803	/**
	804	* Verify all biggiefiles on the opened CD/tape stream.
	805	* @param bkpinfo The backup information structure. Fields used:
	806	* - @c bkpinfo->restore_path
	807	* - @c bkpinfo->tmpdir
	808	*
	809	* @return 0 for success (even if there are differences); nonzero for a tape error.
	810	*/
[1645]	811	int verify_biggiefiles_from_stream()
[1]	812	{
	813
[128]	814	/@ int *********************************************************** */
	815	int retval = 0;
[1]	816	int res = 0;
	817	int ctrl_chr = 0;
	818
[128]	819	/@ long ********************************************************** */
	820	long noof_biggiefiles = 0;
[1]	821	long current_biggiefile_number = 0;
	822
[128]	823	/@ buffers ******************************************************* */
[2276]	824	char *orig_fname;
	825	char *logical_fname = NULL;
	826	char *comment = NULL;
	827	char *curr_xattr_list_fname = NULL;
	828	char *curr_acl_list_fname = NULL;
[128]	829	/@ pointers ****************************************************** */
[1]	830	char *p;
	831
[128]	832	/@ long long size ************************************************ */
	833	long long size = 0;
[1]	834
[128]	835	assert(bkpinfo != NULL);
	836	malloc_string(orig_fname);
[1]	837
[948]	838	if (g_getfattr) {
[2323]	839	mr_asprintf(curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
[948]	840	}
	841	if (g_getfacl) {
[2323]	842	mr_asprintf(curr_acl_list_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
[948]	843	}
[2323]	844	mr_asprintf(comment, "Verifying all bigfiles.");
[128]	845	log_to_screen(comment);
	846	res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr);
	847	if (ctrl_chr != BLK_START_BIGGIEFILES) {
	848	if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
[2230]	849	log_it("Grabbing the EXAT biggiefiles");
[128]	850	res =
[1645]	851	read_EXAT_files_from_tape(&size, orig_fname,
[128]	852	&ctrl_chr, curr_xattr_list_fname,
	853	curr_acl_list_fname);
	854	}
[1]	855	}
[2276]	856	if (g_getfattr) {
	857	mr_free(curr_xattr_list_fname);
	858	}
	859	if (g_getfacl) {
	860	mr_free(curr_acl_list_fname);
	861	}
	862
[128]	863	if (ctrl_chr != BLK_START_BIGGIEFILES) {
	864	wrong_marker(BLK_START_BIGGIEFILES, ctrl_chr);
[1]	865	}
[128]	866	noof_biggiefiles = (long) size;
	867	log_msg(1, "noof_biggiefiles = %ld", noof_biggiefiles);
[541]	868	open_progress_form("Verifying big files", comment,
	869	"Please wait. This may take some time.", "",
[128]	870	noof_biggiefiles);
[2276]	871	mr_free(comment);
	872
[128]	873	for (res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr);
	874	ctrl_chr != BLK_STOP_BIGGIEFILES;
	875	res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr))
[1]	876	{
[128]	877	if (ctrl_chr != BLK_START_A_NORMBIGGIE
	878	&& ctrl_chr != BLK_START_A_PIHBIGGIE) {
	879	wrong_marker(BLK_START_A_NORMBIGGIE, ctrl_chr);
	880	}
	881	p = strrchr(orig_fname, '/');
	882	if (!p) {
	883	p = orig_fname;
	884	} else {
	885	p++;
	886	}
[2323]	887	mr_asprintf(comment, "Verifying bigfile #%ld (%ld K)", current_biggiefile_number, (long) size >> 10);
[128]	888	update_progress_form(comment);
[2276]	889	mr_free(comment);
	890
[2327]	891	if (bkpinfo->restore_path) {
	892	mr_asprintf(logical_fname, "%s/%s", bkpinfo->restore_path, orig_fname);
	893	res = verify_a_biggiefile_from_stream(logical_fname, size);
	894	mr_free(logical_fname);
	895	retval += res;
	896	} else {
	897	log_it("Unable to verify bigfile as restore_path is NULL");
	898	}
[2276]	899
[128]	900	current_biggiefile_number++;
	901	g_current_progress++;
[1]	902	}
[128]	903	close_progress_form();
	904	paranoid_free(orig_fname);
	905	return (retval);
[1]	906	}
	907
	908	/* @} - end of LLverifyGroup */
	909
	910
	911	/**
[1709]	912	* Verify the USB device
	913	* @param bkpinfo The backup information structure. Fields used:
	914	* - @c bkpinfo->media_device
	915	* - @c bkpinfo->tmpdir
	916	* - @c bkpinfo->verify_data
	917	*
	918	* @return 0 for success (even if differences are found), nonzero for failure.
	919	* @ingroup verifyGroup
	920	*/
	921	int verify_usb_image()
	922	{
	923
	924	/@ int *********************************************************** */
	925	int retval = 0;
	926
	927	/@ buffers ******************************************************* */
	928	char *mountpoint = NULL;
	929	char *tmp = NULL;
	930	char *tmp1 = NULL;
	931	char *fname = NULL;
[1711]	932	int ret = 0;
[1709]	933	#ifdef __FreeBSD__
	934	char mdd[32];
	935	char *mddevice = mdd;
	936	int vndev = 2;
	937	#else
	938	//skip
	939	#endif
	940
	941	assert(bkpinfo != NULL);
	942
[2325]	943	if (bkpinfo->media_device == NULL) {
	944	return(1);
	945	}
	946
[2323]	947	mr_asprintf(fname, "%s1", bkpinfo->media_device);
[1709]	948	if (is_this_device_mounted(fname)) {
	949	log_msg(1, "USB device mounted. Remounting it at the right place");
[2323]	950	mr_asprintf(tmp, "umount %s", fname);
[1709]	951	run_program_and_log_output(tmp, FALSE);
	952	paranoid_free(tmp);
	953	}
	954	paranoid_free(fname);
	955
	956	log_msg(1, "Mounting USB device.");
[2323]	957	mr_asprintf(mountpoint, "%s/usb", bkpinfo->tmpdir);
	958	mr_asprintf(tmp, "mkdir -p %s", mountpoint);
[1709]	959	run_program_and_log_output(tmp, FALSE);
	960	paranoid_free(tmp);
	961	/* Mindi always create one single parition on the USB dev */
[2323]	962	mr_asprintf(tmp, "mount %s1 %s", bkpinfo->media_device, mountpoint);
[1709]	963	ret = run_program_and_log_output(tmp, FALSE);
	964	paranoid_free(tmp);
	965	if (ret) {
	966	paranoid_free(mountpoint);
	967	return(ret);
	968	}
	969
	970	sync();
	971	log_msg(2, "OK, I've mounted the USB Disk/Key\n");
[2323]	972	mr_asprintf(tmp, "%s/archives/NOT-THE-LAST", mountpoint);
[1709]	973	if (!does_file_exist(tmp)) {
	974	log_msg
	975	(2,
	976	"This is the last USB device. I am therefore setting bkpinfo->verify_data to FALSE.");
	977	bkpinfo->verify_data = FALSE;
	978	/*
	979	(a) It's an easy way to tell the calling subroutine that we've finished &
	980	there are no more device to be verified; (b) It stops the post-backup verifier
	981	from running after the per-device verifier has run too.
	982	*/
	983	}
	984	paranoid_free(tmp);
	985	verify_afioballs_on_CD(mountpoint);
[2230]	986	log_it("before verify_all_slices");
[1709]	987	verify_all_slices_on_CD(mountpoint);
	988
[2323]	989	mr_asprintf(tmp1, "umount %s", mountpoint);
[1709]	990	#ifdef __FreeBSD__
	991	ret += system(tmp1);
	992	ret += kick_vn(mddevice);
	993	if (ret)
	994	#else
	995	if (system(tmp1))
	996	#endif
	997	{
[2324]	998	log_to_screen("%s failed; unable to unmount USB device\n", tmp1);
[1709]	999	retval++;
	1000	} else {
	1001	log_msg(2, "OK, I've unmounted the USB device\n");
	1002	}
[2324]	1003	mr_free(tmp1);
	1004	mr_free(mountpoint);
[1709]	1005	return (retval);
	1006	}
	1007
	1008
	1009	/**
[1]	1010	* Verify the CD indicated by @c g_current_media_number.
	1011	* @param bkpinfo The backup information structure. Fields used:
	1012	* - @c bkpinfo->isodir
[20]	1013	* - @c bkpinfo->prefix
[1]	1014	* - @c bkpinfo->manual_cd_tray
	1015	* - @c bkpinfo->media_device
	1016	* - @c bkpinfo->nfs_remote_dir
	1017	* - @c bkpinfo->tmpdir
	1018	* - @c bkpinfo->verify_data
	1019	*
	1020	* @return 0 for success (even if differences are found), nonzero for failure.
	1021	* @ingroup verifyGroup
	1022	*/
[1645]	1023	int verify_cd_image()
[1]	1024	{
	1025
[128]	1026	/@ int *********************************************************** */
	1027	int retval = 0;
[1]	1028
[128]	1029	/@ buffers ******************************************************* */
[2276]	1030	char *mountpoint = NULL;
	1031	char *command = NULL;
	1032	char *tmp = NULL;
	1033	char *fname = NULL;
[1]	1034	#ifdef __FreeBSD__
[128]	1035	char mdd[32];
[1]	1036	char *mddevice = mdd;
[128]	1037	int ret = 0;
	1038	int vndev = 2;
[1]	1039	#else
	1040	//skip
	1041	#endif
	1042
[128]	1043	assert(bkpinfo != NULL);
[1]	1044
[2325]	1045	if (bkpinfo->media_device == NULL) {
	1046	return(1);
	1047	}
	1048
[2323]	1049	mr_asprintf(mountpoint, "%s/cdrom", bkpinfo->tmpdir);
[2325]	1050	if (((bkpinfo->isodir == NULL) && (bkpinfo->nfs_remote_dir == NULL)) \|\| (bkpinfo->prefix == NULL)) {
	1051	fatal_error("No iso filename preparation possible");
	1052	}
	1053	if (bkpinfo->nfs_remote_dir) {
	1054	// NFS
	1055	mr_asprintf(fname, "%s/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->nfs_remote_dir, bkpinfo->prefix, g_current_media_number);
	1056	} else {
	1057	// ISO
	1058	mr_asprintf(fname, "%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->prefix, g_current_media_number);
	1059	}
[128]	1060
	1061	mkdir(mountpoint, 1777);
	1062	sync();
	1063	if (!does_file_exist(fname)) {
[2276]	1064	log_msg(2, "%s not found; assuming you backed up to CD; verifying CD...", fname);
[128]	1065	if (bkpinfo->manual_cd_tray) {
[541]	1066	popup_and_OK("Please push CD tray closed.");
[128]	1067	}
[1645]	1068	if (find_and_mount_actual_cd(mountpoint)) {
[541]	1069	log_to_screen("failed to mount actual CD");
[2276]	1070	mr_free(mountpoint);
	1071	mr_free(fname);
[128]	1072	return (1);
	1073	}
	1074	} else {
[2276]	1075	log_msg(2, "%s found; verifying ISO...", fname);
[1]	1076	#ifdef __FreeBSD__
[128]	1077	ret = 0;
	1078	vndev = 2;
	1079	mddevice = make_vn(fname);
	1080	if (ret) {
[2324]	1081	log_to_screen("make_vn of %s failed; unable to verify ISO\n", fname);
[2276]	1082	mr_free(mountpoint);
	1083	mr_free(fname);
[128]	1084	return (1);
	1085	}
[2323]	1086	mr_asprintf(command, "mount_cd9660 %s %s", mddevice, mountpoint);
[1]	1087	#else
[2323]	1088	mr_asprintf(command, "mount -o loop,ro -t iso9660 %s %s", fname, mountpoint);
[1]	1089	#endif
[128]	1090	if (run_program_and_log_output(command, FALSE)) {
[2324]	1091	log_to_screen("%s failed; unable to mount ISO image\n", command);
[2276]	1092	mr_free(mountpoint);
	1093	mr_free(command);
	1094	mr_free(fname);
[128]	1095	return (1);
	1096	}
[2276]	1097	mr_free(command);
[1]	1098	}
[128]	1099	log_msg(2, "OK, I've mounted the ISO/CD\n");
[2323]	1100	mr_asprintf(tmp, "%s/archives/NOT-THE-LAST", mountpoint);
[128]	1101	if (!does_file_exist(tmp)) {
	1102	log_msg
	1103	(2,
	1104	"This is the last CD. I am therefore setting bkpinfo->verify_data to FALSE.");
	1105	bkpinfo->verify_data = FALSE;
[1]	1106	/*
	1107	(a) It's an easy way to tell the calling subroutine that we've finished &
	1108	there are no more CD's to be verified; (b) It stops the post-backup verifier
	1109	from running after the per-CD verifier has run too.
	1110	*/
[128]	1111	}
[2276]	1112	mr_free(tmp);
	1113
[1645]	1114	verify_afioballs_on_CD(mountpoint);
[2230]	1115	log_it("before verify_all_slices");
[1645]	1116	verify_all_slices_on_CD(mountpoint);
[1]	1117
	1118	#ifdef __FreeBSD__
[128]	1119	ret = 0;
[2323]	1120	mr_asprintf(command, "umount %s", mountpoint);
[128]	1121	ret += system(command);
	1122	ret += kick_vn(mddevice);
[2324]	1123	if (ret) {
[1]	1124	#else
[2323]	1125	mr_asprintf(command, "umount %s", mountpoint);
[2324]	1126	if (system(command)) {
[1]	1127	#endif
[2324]	1128	log_to_screen("%s failed; unable to unmount ISO image\n", command);
[2276]	1129
[128]	1130	retval++;
	1131	} else {
	1132	log_msg(2, "OK, I've unmounted the ISO file\n");
[1]	1133	}
[2276]	1134	mr_free(mountpoint);
	1135	mr_free(command);
	1136
[128]	1137	if (!does_file_exist(fname)) {
[2323]	1138	mr_asprintf(command, "umount %s", bkpinfo->media_device);
[128]	1139	run_program_and_log_output(command, 2);
[2276]	1140	mr_free(command);
	1141
[2325]	1142	if (!bkpinfo->please_dont_eject && eject_device(bkpinfo->media_device)) {
[128]	1143	log_msg(2, "Failed to eject CD-ROM drive");
	1144	}
	1145	}
[2276]	1146	mr_free(fname);
[128]	1147	return (retval);
[1]	1148	}
	1149
	1150	/**
	1151	* Verify all backups on tape.
	1152	* This should be done after the backup process has already closed the tape.
	1153	* @param bkpinfo The backup information structure. Passed to various helper functions.
	1154	* @return 0 for success (even if thee were differences), nonzero for failure.
	1155	* @ingroup verifyGroup
	1156	*/
[1645]	1157	int verify_tape_backups()
[1]	1158	{
	1159
[128]	1160	/@ int *********************************************************** */
	1161	int retval = 0;
[1]	1162
[128]	1163	/@ buffers ******************************************************* */
[2276]	1164	char *tmp = NULL;
	1165	char *changed_files_fname = NULL;
[1]	1166
[128]	1167	/@ long ********************************************************** */
	1168	long diffs = 0;
[1]	1169
[128]	1170	assert(bkpinfo != NULL);
[1]	1171
[128]	1172	log_msg(3, "verify_tape_backups --- starting");
[541]	1173	log_to_screen("Verifying backups");
[1645]	1174	openin_tape();
[1]	1175	/* verify archives themselves */
[1645]	1176	retval += verify_afioballs_from_stream();
	1177	retval += verify_biggiefiles_from_stream();
[1]	1178	/* find the final blocks */
[2376]	1179	sync();
[128]	1180	sleep(2);
[1645]	1181	closein_tape();
[1]	1182	/* close tape; exit */
	1183	// fclose(g_tape_stream); <-- not needed; is handled by closein_tape()
[2323]	1184	mr_asprintf(tmp, "rm -f %s/biggies.changed %s/changed.files 2> /dev/null", bkpinfo->tmpdir, bkpinfo->tmpdir);
[1644]	1185	paranoid_system(tmp);
[2276]	1186	mr_free(tmp);
	1187
[2323]	1188	mr_asprintf(changed_files_fname, "%s/changed.files", bkpinfo->tmpdir);
	1189	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]	1190	log_msg(2, "Running command to derive list of changed files");
	1191	log_msg(2, tmp);
	1192	if (system(tmp)) {
[2276]	1193	if (does_file_exist(changed_files_fname) && length_of_file(changed_files_fname) > 2) {
	1194	log_to_screen("Warning - unable to check logfile to derive list of changed files");
[128]	1195	} else {
[2276]	1196	log_to_screen("No differences found. Therefore, no 'changed.files' text file.");
[128]	1197	}
	1198	}
[2276]	1199	mr_free(tmp);
	1200
[2323]	1201	mr_asprintf(tmp, "cat %s/biggies.changed >> %s", bkpinfo->tmpdir, changed_files_fname);
[128]	1202	paranoid_system(tmp);
[2276]	1203	mr_free(tmp);
[1]	1204
[128]	1205	diffs = count_lines_in_file(changed_files_fname);
	1206	if (diffs > 0) {
[2323]	1207	mr_asprintf(tmp, "cp -f %s %s/changed.files", changed_files_fname, MONDO_CACHE);
[128]	1208	run_program_and_log_output(tmp, FALSE);
[2276]	1209	mr_free(tmp);
	1210
	1211	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]	1212	log_to_screen("See "MONDO_CACHE"/changed.files for a list of nonmatching files.");
[1644]	1213	log_to_screen("The files probably changed on filesystem, not on backup media.");
[128]	1214	}
[2276]	1215	mr_free(changed_files_fname);
[128]	1216	return (retval);
[1]	1217	}
	1218
	1219
	1220

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

Download in other formats: