Context Navigation

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

Visit:

Last change on this file since 3207 was 3207, checked in by Bruno Cornec, 10 years ago
Add LZMA compression possibility through the GUI
Property svn:keywords set to `Id`
File size: 35.4 KB

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

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

Download in other formats: