Context Navigation

libmondo-verify.c@ 3613

Visit:

Last change on this file since 3613 was 3613, checked in by Bruno Cornec, 7 years ago
Add function mr_getcwd and use it to allow use o dynamically allocated memory instead of getcwd
Property svn:keywords set to `Id`
File size: 35.3 KB

Rev	Line
[1]	1	/***************************************************************************
[2211]	2	$Id: libmondo-verify.c 3613 2016-11-18 16:31:42Z 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 3613 2016-11-18 16:31:42Z 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);
[3191]	57	sprintf(output, "%s/archives/%d.star.%s", mountpoint, setno, bkpinfo->zip_suffix);
[1648]	58	if (!does_file_exist(output)) {
[3191]	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 ********************************************************* */
[3191]	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
[3191]	93	mr_asprintf(afio_found_changes, "%s.afio", ignorefiles_fname);
	94	sync();
[128]	95
	96	log_msg(1, "Now scanning log file for 'afio: ' stuff");
[3191]	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);
[3191]	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");
[3191]	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);
[3191]	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);
[3191]	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);
	117	mr_free(afio_found_changes);
[128]	118	log_msg(2, command);
	119	paranoid_system(command);
[3191]	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 ******************************************************** */
[3191]	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) {
[3191]	163	log_msg(1, "Weird error in verify_afioballs_on_CD() but it's really a cosmetic error, nothing more");
[128]	164	} else {
	165	retval++;
[3191]	166	log_to_screen("Warning - missing set(s) between %d and %d\n", g_last_afioball_number, set_number - 1);
[128]	167	}
	168	}
[2242]	169	mds = media_descriptor_string(bkpinfo->backup_media_type);
[3191]	170	mr_asprintf(tmp, "Verifying %s #%d's tarballs", mds, g_current_media_number);
[2242]	171	mr_free(mds);
	172
[128]	173	open_evalcall_form(tmp);
[3191]	174	mr_free(tmp);
[128]	175
	176	for (total_sets = set_number;
[1645]	177	does_file_exist(vfy_tball_fname(mountpoint, total_sets));
[128]	178	total_sets++) {
	179	log_msg(1, "total_sets = %d", total_sets);
	180	}
	181	for (;
[1645]	182	does_file_exist(vfy_tball_fname(mountpoint, set_number));
[128]	183	set_number++) {
	184	percentage =
	185	(set_number - g_last_afioball_number) * 100 / (total_sets -
	186	g_last_afioball_number);
	187	update_evalcall_form(percentage);
	188	log_msg(1, "set = %d", set_number);
	189	retval +=
[1645]	190	verify_an_afioball_from_CD(vfy_tball_fname(mountpoint, set_number));
[128]	191	}
	192	g_last_afioball_number = set_number - 1;
	193	close_evalcall_form();
	194	return (retval);
[1]	195	}
	196
	197	/**
	198	* Verify all slices stored on the inserted CD (or a mounted ISO image).
	199	* @param bkpinfo The backup information structure. Fields used:
	200	* - @c compression_level
	201	* - @c restore_path
	202	* - @c use_lzo
	203	* - @c zip_exe
	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 ********************************************************* */
[3191]	212	char *tmp = NULL;
	213	char *mountpoint = NULL;
	214	char *command = NULL;
[2242]	215	char *mds = NULL;
[3191]	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) {
[3191]	253	mr_asprintf(sz_exe, "lzop");
[1003]	254	} else if (bkpinfo->use_gzip) {
[3191]	255	mr_asprintf(sz_exe, "gzip");
	256	} else if (bkpinfo->use_lzma) {
	257	mr_asprintf(sz_exe, "lzma");
[128]	258	} else {
[3191]	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);
[3191]	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);
[3191]	269	mr_free(tmp);
	270
[2230]	271	log_it("after vsbf");
[3191]	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	}
[3191]	283	while (does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, bkpinfo->zip_suffix))
[128]	284	\|\|
[3191]	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) {
[3191]	288	log_msg(2, "ISO=%d bigfile=%ld --START--", g_current_media_number, bigfile_num);
	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 {
[3191]	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	}
[3191]	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");
	301	mr_free(tmp);
	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	paranoid_system(tmp);
	308	mr_free(tmp);
[1236]	309
[3191]	310	bigfile_num++;
	311	slice_num = 0;
	312	retval++;
	313	} else {
	314	slice_num++;
	315	}
[1236]	316	} else {
[3191]	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 {
[3191]	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)) {
	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 {
[3191]	331	mr_asprintf(command, "cat %s 2>> %s", slice_fname(bigfile_num, slice_num, mountpoint, ""), MONDO_LOGFILE);
[128]	332	}
[3191]	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	}
[3191]	374	mr_free(mountpoint);
	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 ******************************************************** */
[3191]	411	char *command = NULL;
	412	char *outlog = NULL;
	413	char *tmp = NULL;
[1]	414
[128]	415	/@ pointers ****************************************************** */
	416	FILE *pin;
[1]	417
[128]	418	/@ long ********************************************************** */
	419	long diffs = 0;
[1]	420
[128]	421	assert(bkpinfo != NULL);
	422	assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
[1]	423
[128]	424	log_it("Verifying fileset '%s'", tarball_fname);
[3191]	425	mr_asprintf(outlog, "%s/afio.log", bkpinfo->tmpdir);
	426	/* if programmer forgot to say which compression thingy to use then find out */
	427	if (strstr(tarball_fname, ".lzo") && strcmp(bkpinfo->zip_suffix, "lzo")) {
[128]	428	log_msg(2, "OK, I'm going to start using lzop.");
	429	strcpy(bkpinfo->zip_exe, "lzop");
	430	strcpy(bkpinfo->zip_suffix, "lzo");
	431	bkpinfo->use_lzo = TRUE;
[998]	432	bkpinfo->use_gzip = FALSE;
[3191]	433	bkpinfo->use_lzma = FALSE;
[128]	434	}
[3191]	435	if (strstr(tarball_fname, ".gz") && strcmp(bkpinfo->zip_suffix, "gz")) {
[998]	436	log_msg(2, "OK, I'm going to start using gzip.");
	437	strcpy(bkpinfo->zip_exe, "gzip");
	438	strcpy(bkpinfo->zip_suffix, "gz");
	439	bkpinfo->use_lzo = FALSE;
	440	bkpinfo->use_gzip = TRUE;
[3191]	441	bkpinfo->use_lzma = FALSE;
[998]	442	}
[3191]	443	if (strstr(tarball_fname, ".bz2") && strcmp(bkpinfo->zip_suffix, "bz2")) {
[128]	444	log_msg(2, "OK, I'm going to start using bzip2.");
	445	strcpy(bkpinfo->zip_exe, "bzip2");
	446	strcpy(bkpinfo->zip_suffix, "bz2");
	447	bkpinfo->use_lzo = FALSE;
[998]	448	bkpinfo->use_gzip = FALSE;
[3191]	449	bkpinfo->use_lzma = FALSE;
[128]	450	}
[3191]	451	if (strstr(tarball_fname, ".lzma") && strcmp(bkpinfo->zip_suffix, "lzma")) {
	452	log_msg(2, "OK, I'm going to start using lzma.");
	453	strcpy(bkpinfo->zip_exe, "lzma");
	454	strcpy(bkpinfo->zip_suffix, "lzma");
	455	bkpinfo->use_lzo = FALSE;
	456	bkpinfo->use_gzip = FALSE;
	457	bkpinfo->use_lzma = TRUE;
	458	}
	459	if (bkpinfo->zip_exe == NULL) {
	460	strcpy(bkpinfo->zip_exe, "none");
	461	}
	462	if (bkpinfo->zip_suffix == NULL) {
	463	strcpy(bkpinfo->zip_suffix, "");
	464	}
[128]	465	unlink(outlog);
	466	if (strstr(tarball_fname, ".star")) {
	467	bkpinfo->use_star = TRUE;
	468	if (strstr(tarball_fname, ".bz2"))
[3191]	469	mr_asprintf(command, "star -sparse -diff diffopts=mode,size,data file=%s %s >> %s 2>> %s", tarball_fname, (strstr(tarball_fname, ".bz2")) ? "-bz" : " ", outlog, outlog);
[128]	470	} else {
	471	bkpinfo->use_star = FALSE;
[3191]	472	/* Here we suppose that there is always a compression program called */
	473	if (bkpinfo->zip_exe) {
	474	mr_asprintf(command, "afio -r -P %s -Z %s >> %s 2>> %s", bkpinfo->zip_exe, tarball_fname, outlog, outlog);
	475	} else {
	476	mr_asprintf(command, "afio -r -Z %s >> %s 2>> %s", tarball_fname, outlog, outlog);
	477	}
[128]	478	}
	479	log_msg(6, "command=%s", command);
	480	paranoid_system(command);
[3191]	481	mr_free(command);
	482
[128]	483	if (length_of_file(outlog) < 10) {
[3191]	484	mr_asprintf(command, "cat %s >> %s", outlog, MONDO_LOGFILE);
[128]	485	} else {
[3191]	486	mr_asprintf(command, "cut -d: -f%d %s \| sort -u", (bkpinfo->use_star) ? 1 : 2, outlog);
[128]	487	pin = popen(command, "r");
	488	if (pin) {
[3191]	489	for (mr_getline(tmp, pin); !feof(pin); mr_getline(tmp, pin)) {
[128]	490	if (bkpinfo->use_star) {
	491	if (!strstr(tmp, "diffopts=")) {
[3191]	492	while (strlen(tmp) > 0 && tmp[strlen(tmp) - 1] < 32) {
[128]	493	tmp[strlen(tmp) - 1] = '\0';
	494	}
	495	if (strchr(tmp, '/')) {
	496	if (!diffs) {
[3191]	497	log_msg(0, "'%s' - differences found", tarball_fname);
[128]	498	}
[3191]	499	log_msg(0, "star: /%s", strip_afio_output_line(tmp));
[128]	500	diffs++;
	501	}
	502	}
	503	} else {
	504	if (!diffs) {
[3191]	505	log_msg(0, "'%s' - differences found", tarball_fname);
[128]	506	}
	507	log_msg(0, "afio: /%s", strip_afio_output_line(tmp));
	508	diffs++;
	509	}
[3191]	510	mr_free(tmp);
[1]	511	}
[3191]	512	mr_free(tmp);
[128]	513	paranoid_pclose(pin);
	514	} else {
	515	log_OS_error(command);
	516	}
	517	}
[3191]	518	mr_free(command);
	519	mr_free(outlog);
[128]	520	return (0);
[1]	521	}
	522
	523
	524
	525
	526
	527
	528	/**
	529	* Verify one afioball from the CD.
	530	* Checks for existence (calls fatal_error() if it does not exist) and
	531	* then calls verify_an_afioball().
	532	* @param bkpinfo The backup information structure. Passed to verify_an_afioball().
	533	* @param tarball_fname The filename of the afioball to verify.
	534	* @return The return value of verify_an_afioball().
	535	* @see verify_an_afioball
	536	*/
	537	int
[1645]	538	verify_an_afioball_from_CD(char *tarball_fname)
[1]	539	{
	540
[128]	541	/@ int ************************************************************ */
	542	int res = 0;
[1]	543
[128]	544	assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
[1]	545
[128]	546	log_msg(1, "Verifying %s", tarball_fname);
	547	if (!does_file_exist(tarball_fname)) {
	548	fatal_error("Cannot verify nonexistent afioball");
	549	}
[1645]	550	res = verify_a_tarball(tarball_fname);
[128]	551	return (res);
[1]	552	}
	553
	554
	555	/**
	556	* Verify one afioball from the opened tape/CD stream.
	557	* Copies the file from tape to tmpdir and then calls verify_an_afioball().
	558	* @param bkpinfo The backup information structure. Passed to verify_an_afioball().
	559	* @param orig_fname The original filename of the afioball to verify.
	560	* @param size The size of the afioball to verify.
	561	* @return The return value of verify_an_afioball().
	562	* @see verify_an_afioball
	563	*/
	564	int
[1645]	565	verify_an_afioball_from_stream(char *orig_fname, long long size)
[1]	566	{
	567
[128]	568	/@ int ************************************************************* */
	569	int retval = 0;
[1]	570	int res = 0;
	571
[128]	572	/@ buffers ********************************************************* */
[3191]	573	char *tmp = NULL;
	574	char *tarball_fname = NULL;
[1]	575
[128]	576	/@ pointers ******************************************************** */
	577	char *p;
[1]	578
[128]	579	assert(bkpinfo != NULL);
	580	assert_string_is_neither_NULL_nor_zerolength(orig_fname);
[1]	581
[128]	582	p = strrchr(orig_fname, '/');
	583	if (!p) {
	584	p = orig_fname;
	585	} else {
	586	p++;
	587	}
[3191]	588	mr_asprintf(tmp, "mkdir -p %s/tmpfs", bkpinfo->tmpdir);
[128]	589	paranoid_system(tmp);
[3191]	590	mr_free(tmp);
	591
	592	mr_asprintf(tarball_fname, "%s/tmpfs/temporary-%s", bkpinfo->tmpdir, p);
[1645]	593	read_file_from_stream_to_file(tarball_fname, size);
	594	res = verify_a_tarball(tarball_fname);
[128]	595	if (res) {
[3191]	596	log_msg(0, "Afioball '%s' no longer matches your live filesystem", p);
[128]	597	retval++;
	598	}
	599	unlink(tarball_fname);
[3191]	600	mr_free(tarball_fname);
[128]	601	return (retval);
[1]	602	}
	603
	604
	605	/**
	606	* Verify one biggiefile form the opened tape/CD stream.
	607	* @param bkpinfo The backup information structure. @c bkpinfo->tmpdir is the only field used.
	608	* @param biggie_fname The filename of the biggiefile to verify.
	609	* @param size The size in bytes of said biggiefile.
	610	* @return 0 for success (even if the file doesn't match); nonzero for a tape error.
	611	*/
	612	int
[1645]	613	verify_a_biggiefile_from_stream(char *biggie_fname, long long size)
[1]	614	{
	615
[128]	616	/@ int ************************************************************ */
	617	int retval = 0;
[1]	618	int res = 0;
	619	int current_slice_number = 0;
	620	int ctrl_chr = '\0';
	621
[128]	622	/@ char *********************************************************** */
[3191]	623	char *test_file = NULL;
	624	char *biggie_cksum = NULL;
	625	char *orig_cksum = NULL;
	626	char *tmp = NULL;
	627	char *slice_fnam = NULL;
[128]	628
	629	/@ pointers ******************************************************* */
[1]	630	char *p;
	631
[128]	632	/@ long long ****************************************************** */
	633	long long slice_siz;
[1]	634
[128]	635	malloc_string(slice_fnam);
	636	assert(bkpinfo != NULL);
	637	assert_string_is_neither_NULL_nor_zerolength(biggie_fname);
[1]	638
[128]	639	p = strrchr(biggie_fname, '/');
	640	if (!p) {
	641	p = biggie_fname;
	642	} else {
	643	p++;
	644	}
[3191]	645	mr_asprintf(test_file, "%s/temporary-%s", bkpinfo->tmpdir, p);
[128]	646	for (res =
	647	read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr);
	648	ctrl_chr != BLK_STOP_A_BIGGIE;
	649	res =
[3191]	650	read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr)) {
[128]	651	if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
	652	wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
	653	}
[1645]	654	res = read_file_from_stream_to_file(test_file, slice_siz);
[128]	655	unlink(test_file);
	656	res =
[3191]	657	read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr);
[128]	658	if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
	659	log_msg(2, "test_file = %s", test_file);
	660	wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
	661	}
	662	current_slice_number++;
	663	retval += res;
[1]	664	}
[3191]	665	mr_asprintf(biggie_cksum, "%s", slice_fnam);
[128]	666	if (biggie_cksum[0] != '\0') {
[3191]	667	mr_asprintf(orig_cksum, "%s", calc_checksum_of_file(biggie_fname));
[128]	668	if (strcmp(biggie_cksum, orig_cksum)) {
[3191]	669	log_msg(2, "orig cksum=%s; curr cksum=%s", biggie_cksum, orig_cksum);
	670	log_to_screen("%s has changed on live filesystem", biggie_fname);
	671
	672	mr_asprintf(tmp, "echo \"%s\" >> %s/biggies.changed", biggie_fname, bkpinfo->tmpdir);
[3060]	673	paranoid_system(tmp);
[3191]	674	mr_free(tmp);
[128]	675	}
[3191]	676	mr_free(orig_cksum);
[1]	677	}
[3191]	678	mr_free(biggie_cksum);
	679	mr_free(test_file);
[128]	680	paranoid_free(slice_fnam);
	681	return (retval);
[1]	682	}
	683
	684
	685	/**
	686	* Verify all afioballs from the opened tape/CD stream.
	687	* @param bkpinfo The backup information structure. Fields used:
	688	* - @c bkpinfo->tmpdir
	689	*
	690	* @return 0 for success (even if there are differences); nonzero for a tape error.
	691	*/
[1645]	692	int verify_afioballs_from_stream()
[1]	693	{
[128]	694	/@ int ********************************************************* */
	695	int retval = 0;
[1]	696	int res = 0;
	697	long current_afioball_number = 0;
	698	int ctrl_chr = 0;
	699	int total_afioballs = 0;
	700
[128]	701	/@ buffers **************************************************** */
[3191]	702	char *tmp = NULL;
[1]	703	char *fname;
[128]	704	char *curr_xattr_list_fname;
	705	char *curr_acl_list_fname;
[1]	706
[128]	707	/@ long long ************************************************** */
	708	long long size = 0;
[1]	709
[128]	710	assert(bkpinfo != NULL);
	711	malloc_string(fname);
	712	malloc_string(curr_xattr_list_fname);
	713	malloc_string(curr_acl_list_fname);
[1]	714
[948]	715	if (g_getfattr) {
	716	sprintf(curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ,
[128]	717	bkpinfo->tmpdir);
[948]	718	}
	719	if (g_getfacl) {
	720	sprintf(curr_acl_list_fname, ACL_BIGGLST_FNAME_RAW_SZ,
[128]	721	bkpinfo->tmpdir);
[948]	722	}
[541]	723	log_to_screen("Verifying regular archives on tape");
[1645]	724	total_afioballs = get_last_filelist_number() + 1;
[541]	725	open_progress_form("Verifying filesystem",
	726	"I am verifying archives against your live filesystem now.",
	727	"Please wait. This may take a couple of hours.", "",
[128]	728	total_afioballs);
	729	res = read_header_block_from_stream(&size, fname, &ctrl_chr);
	730	if (ctrl_chr != BLK_START_AFIOBALLS) {
[2230]	731	log_it("YOU SHOULD NOT GET HERE");
	732	log_it("Grabbing the EXAT files");
[128]	733	if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
[3116]	734	res = read_EXAT_files_from_tape(&size, fname, &ctrl_chr,
[128]	735	curr_xattr_list_fname,
	736	curr_acl_list_fname);
	737	}
[1]	738	}
[128]	739	if (ctrl_chr != BLK_START_AFIOBALLS) {
	740	wrong_marker(BLK_START_AFIOBALLS, ctrl_chr);
[1]	741	}
[128]	742
	743	for (res = read_header_block_from_stream(&size, fname, &ctrl_chr);
	744	ctrl_chr != BLK_STOP_AFIOBALLS;
	745	res = read_header_block_from_stream(&size, fname, &ctrl_chr)) {
[948]	746	if (g_getfattr) {
	747	sprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
[128]	748	bkpinfo->tmpdir, current_afioball_number);
[948]	749	}
	750	if (g_getfacl) {
	751	sprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
[128]	752	bkpinfo->tmpdir, current_afioball_number);
[948]	753	}
[128]	754	if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
[2230]	755	log_it("Reading EXAT files from tape");
[3116]	756	res = read_EXAT_files_from_tape(&size, fname, &ctrl_chr,
[128]	757	curr_xattr_list_fname,
	758	curr_acl_list_fname);
	759	}
	760	if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
	761	wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
	762	}
[3191]	763	mr_asprintf(tmp, "Verifying fileset #%ld", current_afioball_number);
[128]	764	update_progress_form(tmp);
[3191]	765	mr_free(tmp);
	766
[1645]	767	res = verify_an_afioball_from_stream(fname, size);
[128]	768	if (res) {
[3191]	769	log_to_screen("Afioball %ld differs from live filesystem", current_afioball_number);
[128]	770	}
	771	retval += res;
	772	current_afioball_number++;
	773	g_current_progress++;
	774	res = read_header_block_from_stream(&size, fname, &ctrl_chr);
	775	if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
	776	wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
	777	}
[1]	778	}
[128]	779	log_msg(1, "All done with afioballs");
	780	close_progress_form();
	781	paranoid_free(fname);
	782	paranoid_free(curr_xattr_list_fname);
	783	paranoid_free(curr_acl_list_fname);
	784	return (retval);
[1]	785	}
	786
	787	/**
	788	* Verify all biggiefiles on the opened CD/tape stream.
	789	* @param bkpinfo The backup information structure. Fields used:
	790	* - @c bkpinfo->restore_path
	791	* - @c bkpinfo->tmpdir
	792	*
	793	* @return 0 for success (even if there are differences); nonzero for a tape error.
	794	*/
[1645]	795	int verify_biggiefiles_from_stream()
[1]	796	{
	797
[128]	798	/@ int *********************************************************** */
	799	int retval = 0;
[1]	800	int res = 0;
	801	int ctrl_chr = 0;
	802
[128]	803	/@ long ********************************************************** */
	804	long noof_biggiefiles = 0;
[1]	805	long current_biggiefile_number = 0;
	806
[128]	807	/@ buffers ******************************************************* */
[3191]	808	char *orig_fname;
	809	char *logical_fname = NULL;
	810	char *comment = NULL;
	811	char *curr_xattr_list_fname = NULL;
	812	char *curr_acl_list_fname = NULL;
[128]	813	/@ pointers ****************************************************** */
[1]	814	char *p;
	815
[128]	816	/@ long long size ************************************************ */
	817	long long size = 0;
[1]	818
[128]	819	assert(bkpinfo != NULL);
	820	malloc_string(orig_fname);
	821	malloc_string(curr_xattr_list_fname);
	822	malloc_string(curr_acl_list_fname);
[1]	823
[948]	824	if (g_getfattr) {
	825	sprintf(curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ,
[128]	826	bkpinfo->tmpdir);
[948]	827	}
	828	if (g_getfacl) {
	829	sprintf(curr_acl_list_fname, ACL_BIGGLST_FNAME_RAW_SZ,
[128]	830	bkpinfo->tmpdir);
[948]	831	}
[3191]	832	mr_asprintf(comment, "Verifying all bigfiles.");
[128]	833	log_to_screen(comment);
	834	res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr);
	835	if (ctrl_chr != BLK_START_BIGGIEFILES) {
	836	if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
[2230]	837	log_it("Grabbing the EXAT biggiefiles");
[3116]	838	res = read_EXAT_files_from_tape(&size, orig_fname,
[128]	839	&ctrl_chr, curr_xattr_list_fname,
	840	curr_acl_list_fname);
	841	}
[1]	842	}
[128]	843	if (ctrl_chr != BLK_START_BIGGIEFILES) {
	844	wrong_marker(BLK_START_BIGGIEFILES, ctrl_chr);
[1]	845	}
[128]	846	noof_biggiefiles = (long) size;
	847	log_msg(1, "noof_biggiefiles = %ld", noof_biggiefiles);
[541]	848	open_progress_form("Verifying big files", comment,
	849	"Please wait. This may take some time.", "",
[128]	850	noof_biggiefiles);
[3191]	851	mr_free(comment);
	852
[128]	853	for (res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr);
	854	ctrl_chr != BLK_STOP_BIGGIEFILES;
	855	res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr))
[1]	856	{
[128]	857	if (ctrl_chr != BLK_START_A_NORMBIGGIE
	858	&& ctrl_chr != BLK_START_A_PIHBIGGIE) {
	859	wrong_marker(BLK_START_A_NORMBIGGIE, ctrl_chr);
	860	}
	861	p = strrchr(orig_fname, '/');
	862	if (!p) {
	863	p = orig_fname;
	864	} else {
	865	p++;
	866	}
[3191]	867	mr_asprintf(comment, "Verifying bigfile #%ld (%ld K)", current_biggiefile_number, (long) size >> 10);
[128]	868	update_progress_form(comment);
[3191]	869	mr_free(comment);
	870
	871	if (bkpinfo->restore_path) {
	872	mr_asprintf(logical_fname, "%s/%s", bkpinfo->restore_path, orig_fname);
	873	res = verify_a_biggiefile_from_stream(logical_fname, size);
	874	mr_free(logical_fname);
	875	retval += res;
	876	} else {
	877	log_it("Unable to verify bigfile as restore_path is NULL");
	878	}
	879
[128]	880	current_biggiefile_number++;
	881	g_current_progress++;
[1]	882	}
[128]	883	close_progress_form();
	884	paranoid_free(orig_fname);
	885	paranoid_free(curr_xattr_list_fname);
	886	paranoid_free(curr_acl_list_fname);
	887	return (retval);
[1]	888	}
	889
	890	/* @} - end of LLverifyGroup */
	891
	892
	893	/**
[1709]	894	* Verify the USB device
	895	* @param bkpinfo The backup information structure. Fields used:
	896	* - @c bkpinfo->media_device
	897	* - @c bkpinfo->tmpdir
	898	* - @c bkpinfo->verify_data
	899	*
	900	* @return 0 for success (even if differences are found), nonzero for failure.
	901	* @ingroup verifyGroup
	902	*/
	903	int verify_usb_image()
	904	{
	905
	906	/@ int *********************************************************** */
	907	int retval = 0;
	908
	909	/@ buffers ******************************************************* */
	910	char *mountpoint = NULL;
	911	char *tmp = NULL;
	912	char *tmp1 = NULL;
	913	char *fname = NULL;
[1711]	914	int ret = 0;
[1709]	915	#ifdef __FreeBSD__
	916	char mdd[32];
	917	char *mddevice = mdd;
	918	int vndev = 2;
	919	#else
	920	//skip
	921	#endif
	922
	923	assert(bkpinfo != NULL);
	924
[3191]	925	if (bkpinfo->media_device == NULL) {
	926	return(1);
	927	}
	928
[3185]	929	mr_asprintf(fname, "%s1", bkpinfo->media_device);
[1709]	930	if (is_this_device_mounted(fname)) {
	931	log_msg(1, "USB device mounted. Remounting it at the right place");
[3185]	932	mr_asprintf(tmp, "umount %s", fname);
[1709]	933	run_program_and_log_output(tmp, FALSE);
	934	paranoid_free(tmp);
	935	}
	936	paranoid_free(fname);
	937
	938	log_msg(1, "Mounting USB device.");
[3185]	939	mr_asprintf(mountpoint, "%s/usb", bkpinfo->tmpdir);
	940	mr_asprintf(tmp, "mkdir -p %s", mountpoint);
[1709]	941	run_program_and_log_output(tmp, FALSE);
	942	paranoid_free(tmp);
	943	/* Mindi always create one single parition on the USB dev */
[3185]	944	mr_asprintf(tmp, "mount %s1 %s", bkpinfo->media_device, mountpoint);
[1709]	945	ret = run_program_and_log_output(tmp, FALSE);
	946	paranoid_free(tmp);
	947	if (ret) {
	948	paranoid_free(mountpoint);
	949	return(ret);
	950	}
	951
	952	sync();
[3380]	953	log_msg(2, "OK, I've mounted the USB Disk/Key");
[3185]	954	mr_asprintf(tmp, "%s/archives/NOT-THE-LAST", mountpoint);
[1709]	955	if (!does_file_exist(tmp)) {
	956	log_msg
	957	(2,
	958	"This is the last USB device. I am therefore setting bkpinfo->verify_data to FALSE.");
	959	bkpinfo->verify_data = FALSE;
	960	/*
	961	(a) It's an easy way to tell the calling subroutine that we've finished &
	962	there are no more device to be verified; (b) It stops the post-backup verifier
	963	from running after the per-device verifier has run too.
	964	*/
	965	}
	966	paranoid_free(tmp);
	967	verify_afioballs_on_CD(mountpoint);
[2230]	968	log_it("before verify_all_slices");
[1709]	969	verify_all_slices_on_CD(mountpoint);
	970
[3185]	971	mr_asprintf(tmp1, "umount -d %s", mountpoint);
[1709]	972	#ifdef __FreeBSD__
	973	ret += system(tmp1);
	974	ret += kick_vn(mddevice);
	975	if (ret)
	976	#else
	977	if (system(tmp1))
	978	#endif
	979	{
[3191]	980	log_to_screen("%s failed; unable to unmount USB device\n", tmp1);
[1709]	981	retval++;
	982	} else {
[3380]	983	log_msg(2, "OK, I've unmounted the USB device");
[1709]	984	}
[3191]	985	mr_free(tmp1);
	986	mr_free(mountpoint);
[1709]	987	return (retval);
	988	}
	989
	990
	991	/**
[1]	992	* Verify the CD indicated by @c g_current_media_number.
	993	* @param bkpinfo The backup information structure. Fields used:
	994	* - @c bkpinfo->isodir
[20]	995	* - @c bkpinfo->prefix
[1]	996	* - @c bkpinfo->manual_cd_tray
	997	* - @c bkpinfo->media_device
[2380]	998	* - @c bkpinfo->netfs_remote_dir
[1]	999	* - @c bkpinfo->tmpdir
	1000	* - @c bkpinfo->verify_data
	1001	*
	1002	* @return 0 for success (even if differences are found), nonzero for failure.
	1003	* @ingroup verifyGroup
	1004	*/
[1645]	1005	int verify_cd_image()
[1]	1006	{
	1007
[128]	1008	/@ int *********************************************************** */
	1009	int retval = 0;
[1]	1010
[128]	1011	/@ buffers ******************************************************* */
[3191]	1012	char *mountpoint = NULL;
	1013	char *command = NULL;
	1014	char *tmp = NULL;
	1015	char *fname = NULL;
[1]	1016	#ifdef __FreeBSD__
[128]	1017	char mdd[32];
[1]	1018	char *mddevice = mdd;
[128]	1019	int ret = 0;
	1020	int vndev = 2;
[1]	1021	#else
	1022	//skip
	1023	#endif
	1024
[128]	1025	assert(bkpinfo != NULL);
[1]	1026
[3191]	1027	if (bkpinfo->media_device == NULL) {
	1028	return(1);
	1029	}
[128]	1030
[3191]	1031	mr_asprintf(mountpoint, "%s/cdrom", bkpinfo->tmpdir);
	1032	if (((bkpinfo->isodir == NULL) && (bkpinfo->netfs_remote_dir == NULL)) \|\| (bkpinfo->prefix == NULL)) {
	1033	fatal_error("No iso filename preparation possible");
	1034	}
[3207]	1035	if (bkpinfo->netfs_remote_dir != NULL) {
[3191]	1036	// NETFS
	1037	mr_asprintf(fname, "%s/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix, g_current_media_number);
	1038	} else {
	1039	// ISO
	1040	mr_asprintf(fname, "%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->prefix, g_current_media_number);
	1041	}
	1042
[128]	1043	mkdir(mountpoint, 1777);
	1044	sync();
	1045	if (!does_file_exist(fname)) {
[3191]	1046	log_msg(2, "%s not found; assuming you backed up to CD; verifying CD...", fname);
[128]	1047	if (bkpinfo->manual_cd_tray) {
[541]	1048	popup_and_OK("Please push CD tray closed.");
[128]	1049	}
[1645]	1050	if (find_and_mount_actual_cd(mountpoint)) {
[541]	1051	log_to_screen("failed to mount actual CD");
[3191]	1052	mr_free(mountpoint);
	1053	mr_free(fname);
[128]	1054	return (1);
	1055	}
	1056	} else {
[3191]	1057	log_msg(2, "%s found; verifying ISO...", fname);
[1]	1058	#ifdef __FreeBSD__
[128]	1059	ret = 0;
	1060	vndev = 2;
	1061	mddevice = make_vn(fname);
	1062	if (ret) {
[3191]	1063	log_to_screen("make_vn of %s failed; unable to verify ISO\n", fname);
	1064	mr_free(mountpoint);
	1065	mr_free(fname);
[128]	1066	return (1);
	1067	}
[3191]	1068	mr_asprintf(command, "mount_cd9660 %s %s", mddevice, mountpoint);
[1]	1069	#else
[3191]	1070	mr_asprintf(command, "mount -o loop,ro -t iso9660 %s %s", fname, mountpoint);
[1]	1071	#endif
[128]	1072	if (run_program_and_log_output(command, FALSE)) {
[3191]	1073	log_to_screen("%s failed; unable to mount ISO image\n", command);
	1074	mr_free(mountpoint);
	1075	mr_free(command);
	1076	mr_free(fname);
[128]	1077	return (1);
	1078	}
[3191]	1079	mr_free(command);
[1]	1080	}
[3380]	1081	log_msg(2, "OK, I've mounted the ISO/CD");
[3191]	1082	mr_asprintf(tmp, "%s/archives/NOT-THE-LAST", mountpoint);
[128]	1083	if (!does_file_exist(tmp)) {
	1084	log_msg
	1085	(2,
	1086	"This is the last CD. I am therefore setting bkpinfo->verify_data to FALSE.");
	1087	bkpinfo->verify_data = FALSE;
[1]	1088	/*
	1089	(a) It's an easy way to tell the calling subroutine that we've finished &
	1090	there are no more CD's to be verified; (b) It stops the post-backup verifier
	1091	from running after the per-CD verifier has run too.
	1092	*/
[128]	1093	}
[3191]	1094	mr_free(tmp);
	1095
[1645]	1096	verify_afioballs_on_CD(mountpoint);
[2230]	1097	log_it("before verify_all_slices");
[1645]	1098	verify_all_slices_on_CD(mountpoint);
[1]	1099
	1100	#ifdef __FreeBSD__
[128]	1101	ret = 0;
[3191]	1102	mr_asprintf(command, "umount -d %s", mountpoint);
[128]	1103	ret += system(command);
	1104	ret += kick_vn(mddevice);
[3191]	1105	if (ret) {
[1]	1106	#else
[3191]	1107	mr_asprintf(command, "umount -d %s", mountpoint);
	1108	if (system(command)) {
[1]	1109	#endif
[3191]	1110	log_to_screen("%s failed; unable to unmount ISO image\n", command);
	1111
[128]	1112	retval++;
	1113	} else {
[3380]	1114	log_msg(2, "OK, I've unmounted the ISO file");
[1]	1115	}
[3191]	1116	mr_free(mountpoint);
	1117	mr_free(command);
	1118
[128]	1119	if (!does_file_exist(fname)) {
[3191]	1120	mr_asprintf(command, "umount -d %s", bkpinfo->media_device);
[128]	1121	run_program_and_log_output(command, 2);
[3191]	1122	mr_free(command);
	1123
	1124	if (!bkpinfo->please_dont_eject && eject_device(bkpinfo->media_device)) {
[128]	1125	log_msg(2, "Failed to eject CD-ROM drive");
	1126	}
	1127	}
[3191]	1128	mr_free(fname);
[128]	1129	return (retval);
[1]	1130	}
	1131
	1132	/**
	1133	* Verify all backups on tape.
	1134	* This should be done after the backup process has already closed the tape.
	1135	* @param bkpinfo The backup information structure. Passed to various helper functions.
	1136	* @return 0 for success (even if thee were differences), nonzero for failure.
	1137	* @ingroup verifyGroup
	1138	*/
[1645]	1139	int verify_tape_backups()
[1]	1140	{
	1141
[128]	1142	/@ int *********************************************************** */
	1143	int retval = 0;
[1]	1144
[128]	1145	/@ buffers ******************************************************* */
[3191]	1146	char *tmp = NULL;
	1147	char *changed_files_fname = NULL;
[1]	1148
[128]	1149	/@ long ********************************************************** */
	1150	long diffs = 0;
[1]	1151
[128]	1152	assert(bkpinfo != NULL);
[1]	1153
[128]	1154	log_msg(3, "verify_tape_backups --- starting");
[541]	1155	log_to_screen("Verifying backups");
[1645]	1156	openin_tape();
[1]	1157	/* verify archives themselves */
[1645]	1158	retval += verify_afioballs_from_stream();
	1159	retval += verify_biggiefiles_from_stream();
[1]	1160	/* find the final blocks */
[3191]	1161	sync();
[128]	1162	sleep(2);
[1645]	1163	closein_tape();
[1]	1164	/* close tape; exit */
	1165	// fclose(g_tape_stream); <-- not needed; is handled by closein_tape()
[3191]	1166	mr_asprintf(tmp, "rm -f %s/biggies.changed %s/changed.files 2> /dev/null", bkpinfo->tmpdir, bkpinfo->tmpdir);
[1644]	1167	paranoid_system(tmp);
[3191]	1168	mr_free(tmp);
	1169
	1170	mr_asprintf(changed_files_fname, "%s/changed.files", bkpinfo->tmpdir);
	1171	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]	1172	log_msg(2, "Running command to derive list of changed files");
	1173	log_msg(2, tmp);
	1174	if (system(tmp)) {
[3191]	1175	if (does_file_exist(changed_files_fname) && length_of_file(changed_files_fname) > 2) {
	1176	log_to_screen("Warning - unable to check logfile to derive list of changed files");
[128]	1177	} else {
[3191]	1178	log_to_screen("No differences found. Therefore, no 'changed.files' text file.");
[128]	1179	}
	1180	}
[3191]	1181	mr_free(tmp);
	1182
	1183	mr_asprintf(tmp, "cat %s/biggies.changed >> %s", bkpinfo->tmpdir, changed_files_fname);
[128]	1184	paranoid_system(tmp);
[3191]	1185	mr_free(tmp);
[1]	1186
[128]	1187	diffs = count_lines_in_file(changed_files_fname);
	1188	if (diffs > 0) {
[3191]	1189	mr_asprintf(tmp, "cp -f %s %s/changed.files", changed_files_fname, MONDO_CACHE);
[128]	1190	run_program_and_log_output(tmp, FALSE);
[3191]	1191	mr_free(tmp);
	1192
	1193	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]	1194	log_to_screen("See "MONDO_CACHE"/changed.files for a list of nonmatching files.");
[1644]	1195	log_to_screen("The files probably changed on filesystem, not on backup media.");
[128]	1196	}
[3191]	1197	mr_free(changed_files_fname);
[128]	1198	return (retval);
[1]	1199	}
	1200
	1201
	1202

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

Context Navigation

source: MondoRescue/branches/3.2/mondo/src/common/libmondo-verify.c@ 3613

Download in other formats: