source: MondoRescue/branches/2.2.2/mondo/src/mondorestore/mondo-rstr-compare.c@ 1315

Last change on this file since 1315 was 1315, checked in by Bruno Cornec, 17 years ago

Log files are now consistent: mondoarchive.log for mondoarchive (containing also mindi.log) and mondorestore.log for mondorestore (copied from /tmp (ram) to /var/log (disk) at the end of the restore)
One include has been created for each bianry containing only that declaration ofr the moment, but which will be extended to include all local definitions (ps_* e.g.)
Doc updated accordingly
LOGFILE in restore process is now passed in the environment and not duplicated anymore
LogIt is not redifined either
LOGFILE should be put in environment by mondoarchive for mindi's usage but that's a step left for later.
  • Property svn:keywords set to Id
File size: 22.8 KB
RevLine 
[1]1/***************************************************************************
2 mondo-compare.c - compares mondoarchive data
3 -------------------
4 begin : Fri Apr 25 2003
5 copyright : (C) 2000 by Hugo Rabson
6 email : Hugo Rabson <hugorabson@msn.com>
[128]7 cvsid : $Id: mondo-rstr-compare.c 1315 2007-04-16 14:13:59Z bruno $
[1]8***************************************************************************/
9
10/***************************************************************************
11 * *
12 * This program is free software; you can redistribute it and/or modify *
13 * it under the terms of the GNU General Public License as published by *
14 * the Free Software Foundation; either version 2 of the License, or *
15 * (at your option) any later version. *
16 * *
17 ***************************************************************************/
18
19/***************************************************************************
20 * Change Log *
21 ***************************************************************************
22.
23
24
25
2610/21/2003
27- changed "/mnt/cdrom" to MNT_CDROM
28
2910/18
30- don't say unknown compressor if no compressor at all
31
3209/17
33- cleaned up logging & conversion-to-changed.txt
34- cleaned up compare_mode()
35
3609/16
37- fixed bad malloc(),free() pairs in compare_a_biggiefile()
38
3909/14
40- compare_mode() --- a couple of strings were the wrong way round,
41 e.g. changed.txt and changed.files
42
4305/05
44- exclude /dev/ * from list of changed files
45
4604/30
47- added textonly mode
48
4904/27
50- improved compare_mode() to allow for ISO/cd/crazy people
51
5204/25
53- first incarnation
54*/
55
56
57#include <pthread.h>
58#include "../common/my-stuff.h"
59#include "../common/mondostructures.h"
60#include "../common/libmondo.h"
61//#include "../../config.h"
62#include "mr-externs.h"
63#include "mondo-rstr-compare.h"
64#include "mondo-restore-EXT.h"
65#include "mondo-rstr-tools-EXT.h"
66
[128]67//static char cvsid[] = "$Id: mondo-rstr-compare.c 1315 2007-04-16 14:13:59Z bruno $";
[1]68
[128]69void popup_changelist_from_file(char *);
[1]70
71
72/**
73 * @addtogroup LLcompareGroup
74 * @{
75 */
76/**
77 * Compare biggiefile number @p bigfileno with the filesystem mounted on @p MNT_RESTORING.
78 * @param bkpinfo The backup information structure. Only used in insist_on_this_cd_number().
79 * @param bigfileno The biggiefile number (starting from 0) to compare.
80 * @note This function uses an MD5 checksum.
81 */
[128]82int compare_a_biggiefile(struct s_bkpinfo *bkpinfo, long bigfileno)
[1]83{
84
[128]85 FILE *fin;
86 FILE *fout;
[1]87
88 /** needs malloc *******/
[128]89 char *checksum_ptr;
90 char *original_cksum_ptr;
91 char *bigfile_fname_ptr;
92 char *tmp_ptr;
93 char *command_ptr;
[1]94
[128]95 char *checksum, *original_cksum, *bigfile_fname, *tmp, *command;
[1]96
[128]97 char *p;
98 int i;
99 int retval = 0;
100
101 struct s_filename_and_lstat_info biggiestruct;
102
103 malloc_string(checksum);
104 malloc_string(original_cksum);
105 malloc_string(bigfile_fname);
106 malloc_string(tmp);
107 malloc_string(command);
108 malloc_string(checksum_ptr);
109 malloc_string(original_cksum_ptr);
110 malloc_string(bigfile_fname_ptr);
111 malloc_string(command_ptr);
112 malloc_string(tmp_ptr);
113
[1]114 /*********************************************************************
115 * allocate memory clear test sab 16 feb 2003 *
116 *********************************************************************/
[128]117 assert(bkpinfo != NULL);
118 memset(checksum_ptr, '\0', sizeof(checksum));
119 memset(original_cksum_ptr, '\0', sizeof(original_cksum));
120 memset(bigfile_fname_ptr, '\0', sizeof(bigfile_fname));
121 memset(tmp_ptr, '\0', sizeof(tmp));
122 memset(command_ptr, '\0', sizeof(command));
[1]123 /** end **/
124
[128]125 if (!does_file_exist(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""))) {
126 if (does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")) {
127 insist_on_this_cd_number(bkpinfo, (++g_current_media_number));
128 } else {
129 sprintf(tmp_ptr,
130 "No CD's left. No biggiefiles left. No prob, Bob.");
131 log_msg(2, tmp_ptr);
132 return (0);
133 }
[1]134 }
[128]135 if (!(fin = fopen(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""), "r"))) {
136 sprintf(tmp_ptr,
[541]137 "Cannot open bigfile %ld (%s)'s info file",
[128]138 bigfileno + 1, bigfile_fname_ptr);
139 log_to_screen(tmp_ptr);
140 return (1);
[1]141 }
[128]142 fread((void *) &biggiestruct, 1, sizeof(biggiestruct), fin);
143 paranoid_fclose(fin);
144
145 strcpy(checksum_ptr, biggiestruct.checksum);
146 strcpy(bigfile_fname_ptr, biggiestruct.filename);
147
148 log_msg(2, "biggiestruct.filename = %s", biggiestruct.filename);
149 log_msg(2, "biggiestruct.checksum = %s", biggiestruct.checksum);
150
[541]151 sprintf(tmp_ptr, "Comparing %s", bigfile_fname_ptr);
[128]152
153 if (!g_text_mode) {
154 newtDrawRootText(0, 22, tmp_ptr);
155 newtRefresh();
[1]156 }
[128]157 if (!checksum[0]) {
158 log_msg(2, "Warning - %s has no checksum", bigfile_fname_ptr);
159 }
160 if (!strncmp(bigfile_fname_ptr, "/dev/", 5)) {
161 strcpy(original_cksum_ptr, "IGNORE");
162 } else {
163 sprintf(command_ptr,
[1315]164 "md5sum \"%s%s\" > /tmp/md5sum.txt 2> /tmp/errors",
[128]165 MNT_RESTORING, bigfile_fname_ptr);
166 }
167 log_msg(2, command_ptr);
168 paranoid_system
[1315]169 ("cat /tmp/errors >> %s 2> /dev/null", MONDO_LOGFILE);
[128]170 if (system(command_ptr)) {
171 log_OS_error("Warning - command failed");
172 original_cksum[0] = '\0';
173 return (1);
174 } else {
175 if (!(fin = fopen("/tmp/md5sum.txt", "r"))) {
176 log_msg(2,
177 "Unable to open /tmp/md5sum.txt; can't get live checksum");
178 original_cksum[0] = '\0';
179 return (1);
180 } else {
181 fgets(original_cksum_ptr, MAX_STR_LEN - 1, fin);
182 paranoid_fclose(fin);
183 for (i = strlen(original_cksum_ptr);
184 i > 0 && original_cksum[i - 1] < 32; i--);
185 original_cksum[i] = '\0';
186 p = (char *) strchr(original_cksum_ptr, ' ');
187 if (p) {
188 *p = '\0';
189 }
190 }
191 }
192 sprintf(tmp_ptr, "bigfile #%ld ('%s') ", bigfileno + 1,
193 bigfile_fname_ptr);
194 if (!strcmp(checksum_ptr, original_cksum_ptr) != 0) {
195 strcat(tmp_ptr, " ... OK");
196 } else {
197 strcat(tmp_ptr, "... changed");
198 retval++;
199 }
200 log_msg(1, tmp_ptr);
201 if (retval) {
202 if (!(fout = fopen("/tmp/changed.txt", "a"))) {
203 fatal_error("Cannot openout changed.txt");
204 }
205 fprintf(fout, "%s\n", bigfile_fname_ptr);
206 paranoid_fclose(fout);
207 }
[1]208
[128]209 paranoid_free(original_cksum_ptr);
210 paranoid_free(original_cksum);
211 paranoid_free(bigfile_fname_ptr);
212 paranoid_free(bigfile_fname);
213 paranoid_free(checksum_ptr);
214 paranoid_free(checksum);
215 paranoid_free(command_ptr);
216 paranoid_free(command);
217 paranoid_free(tmp_ptr);
218 paranoid_free(tmp);
[1]219
[128]220 return (retval);
[1]221}
222
223/**************************************************************************
224 *END_COMPARE_A_BIGGIEFILE *
225 **************************************************************************/
226
227
228/**
229 * Compare all biggiefiles in the backup.
230 * @param bkpinfo The backup information structure. Used only in compare_a_biggiefile().
231 * @return 0 for success, nonzero for failure.
232 */
[128]233int compare_all_biggiefiles(struct s_bkpinfo *bkpinfo)
[1]234{
[128]235 int retval = 0;
236 int res;
237 long noof_biggiefiles, bigfileno = 0;
238 char tmp[MAX_STR_LEN];
[1]239
[128]240 assert(bkpinfo != NULL);
241 log_msg(1, "Comparing biggiefiles");
242
243 if (length_of_file(BIGGIELIST) < 6) {
244 log_msg(1,
245 "OK, really teeny-tiny biggielist; not comparing biggiefiles");
246 return (0);
247 }
248 noof_biggiefiles = count_lines_in_file(BIGGIELIST);
249 if (noof_biggiefiles <= 0) {
250 log_msg(1, "OK, no biggiefiles; not comparing biggiefiles");
251 return (0);
252 }
253 mvaddstr_and_log_it(g_currentY, 0,
[541]254 "Comparing large files ");
255 open_progress_form("Comparing large files",
256 "I am now comparing the large files",
257 "against the filesystem. Please wait.", "",
[128]258 noof_biggiefiles);
259 for (bigfileno = 0; bigfileno < noof_biggiefiles; bigfileno++) {
260 sprintf(tmp, "Comparing big file #%ld", bigfileno + 1);
261 log_msg(1, tmp);
262 update_progress_form(tmp);
263 res = compare_a_biggiefile(bkpinfo, bigfileno);
264 retval += res;
265 g_current_progress++;
266 }
267 close_progress_form();
268 return (0);
269 if (retval) {
[541]270 mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
[128]271 } else {
[541]272 mvaddstr_and_log_it(g_currentY++, 74, "Done.");
[128]273 }
274 return (retval);
[1]275}
[128]276
[1]277/**************************************************************************
278 *END_COMPARE_ALL_BIGGIEFILES *
279 **************************************************************************/
280
281
282/**
283 * Compare afioball @p tarball_fname against the filesystem.
284 * You must be chdir()ed to the directory where the filesystem is mounted
285 * before you call this function.
286 * @param tarball_fname The filename of the tarball to compare.
287 * @param current_tarball_number The fileset number contained in @p tarball_fname.
288 * @return 0 for success, nonzero for failure.
289 */
[128]290int compare_a_tarball(char *tarball_fname, int current_tarball_number)
[1]291{
[128]292 int retval = 0;
293 int res;
294 long noof_lines;
295 long archiver_errors;
296 bool use_star;
297
[1]298 /*** needs malloc *********/
[128]299 char *command, *tmp, *filelist_name, *logfile, *archiver_exe,
300 *compressor_exe;
[1]301
[128]302 malloc_string(command);
303 malloc_string(tmp);
304 malloc_string(filelist_name);
305 malloc_string(logfile);
306 malloc_string(archiver_exe);
307 malloc_string(compressor_exe);
[1]308
[128]309 use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
310 assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
311 sprintf(logfile, "/tmp/afio.log.%d", current_tarball_number);
312 sprintf(filelist_name, MNT_CDROM "/archives/filelist.%d",
313 current_tarball_number);
[1]314
[128]315 noof_lines = count_lines_in_file(filelist_name);
316
317 if (strstr(tarball_fname, ".bz2")) {
318 strcpy(compressor_exe, "bzip2");
[998]319 } else if (strstr(tarball_fname, ".gz")) {
320 strcpy(compressor_exe, "gzip");
[128]321 } else if (strstr(tarball_fname, ".lzo")) {
322 strcpy(compressor_exe, "lzop");
323 } else {
324 compressor_exe[0] = '\0';
[1]325 }
[128]326
327 if (use_star) {
328 strcpy(archiver_exe, "star");
329 } else {
330 strcpy(archiver_exe, "afio");
[1]331 }
[128]332
333 if (compressor_exe[0]) {
334 strcpy(tmp, compressor_exe);
335 if (!find_home_of_exe(tmp)) {
336 fatal_error("(compare_a_tarball) Compression program missing");
337 }
338 if (use_star) // star
339 {
340 if (!strcmp(compressor_exe, "bzip2")) {
341 strcat(archiver_exe, " -bz");
342 } else {
343 fatal_error
344 ("(compare_a_tarball) Please use only bzip2 with star");
345 }
346 } else // afio
347 {
348 sprintf(compressor_exe, "-P %s -Z", tmp);
349 }
350 }
[1]351// star -diff H=star -bz file=....
352
353#ifdef __FreeBSD__
354#define BUFSIZE 512L
355#else
356#define BUFSIZE (1024L*1024L)/TAPE_BLOCK_SIZE
357#endif
[128]358 if (use_star) // doesn't use compressor_exe
359 {
360 sprintf(command,
361 "%s -diff H=star file=%s >> %s 2>> %s",
362 archiver_exe, tarball_fname, logfile, logfile);
363 } else {
364 sprintf(command,
365 "%s -r -b %ld -M 16m -c %ld %s %s >> %s 2>> %s",
366 archiver_exe,
367 TAPE_BLOCK_SIZE,
368 BUFSIZE, compressor_exe, tarball_fname, logfile, logfile);
369 }
[1]370#undef BUFSIZE
371
[128]372 res = system(command);
373 retval += res;
374 if (res) {
375 log_OS_error(command);
376 sprintf(tmp, "Warning - afio returned error = %d", res);
377 }
378 if (length_of_file(logfile) > 5) {
379 sprintf(command,
[1294]380 "sed s/': \\\"'/\\|/ %s | sed s/'\\\": '/\\|/ | cut -d'|' -f2 | sort -u | grep -vE \"^dev/.*\" >> /tmp/changed.txt",
[128]381 logfile);
382 system(command);
383 archiver_errors = count_lines_in_file(logfile);
384 } else {
385 archiver_errors = 0;
386 }
387 sprintf(tmp, "%ld difference%c in fileset #%d ",
388 archiver_errors, (archiver_errors != 1) ? 's' : ' ',
389 current_tarball_number);
390 if (archiver_errors) {
391 sprintf(tmp,
392 "Differences found while processing fileset #%d ",
393 current_tarball_number);
394 log_msg(1, tmp);
395 }
396 unlink(logfile);
397 paranoid_free(command);
398 paranoid_free(tmp);
399 paranoid_free(filelist_name);
400 paranoid_free(logfile);
401 malloc_string(archiver_exe);
402 malloc_string(compressor_exe);
403 return (retval);
[1]404}
[128]405
[1]406/**************************************************************************
407 *END_COMPARE_A_TARBALL *
408 **************************************************************************/
409
410
411/**
412 * Compare all afioballs in this backup.
413 * @param bkpinfo The backup media structure. Passed to other functions.
414 * @return 0 for success, nonzero for failure.
415 */
[128]416int compare_all_tarballs(struct s_bkpinfo *bkpinfo)
[1]417{
[128]418 int retval = 0;
419 int res;
420 int current_tarball_number = 0;
[1]421
422 /** needs malloc **********/
423
[128]424 char *tarball_fname, *progress_str, *tmp;
425 long max_val;
[1]426
[128]427 malloc_string(tarball_fname);
428 malloc_string(progress_str);
429 malloc_string(tmp);
430
431 assert(bkpinfo != NULL);
[541]432 mvaddstr_and_log_it(g_currentY, 0, "Comparing archives");
[128]433 read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
434
435 max_val = atol(tmp);
[541]436 sprintf(progress_str, "Comparing with %s #%d ",
[128]437 media_descriptor_string(bkpinfo->backup_media_type),
438 g_current_media_number);
439
[541]440 open_progress_form("Comparing files",
441 "Comparing tarballs against filesystem.",
442 "Please wait. This may take some time.",
[128]443 progress_str, max_val);
444
445 log_to_screen(progress_str);
446
447 for (;;) {
448 insist_on_this_cd_number(bkpinfo, g_current_media_number);
449 update_progress_form(progress_str);
450 sprintf(tarball_fname,
451 MNT_CDROM "/archives/%d.afio.bz2", current_tarball_number);
452
453 if (!does_file_exist(tarball_fname)) {
454 sprintf(tarball_fname, MNT_CDROM "/archives/%d.afio.lzo",
455 current_tarball_number);
456 }
457 if (!does_file_exist(tarball_fname)) {
458 sprintf(tarball_fname, MNT_CDROM "/archives/%d.afio.",
459 current_tarball_number);
460 }
461 if (!does_file_exist(tarball_fname)) {
462 sprintf(tarball_fname, MNT_CDROM "/archives/%d.star.bz2",
463 current_tarball_number);
464 }
465 if (!does_file_exist(tarball_fname)) {
466 sprintf(tarball_fname, MNT_CDROM "/archives/%d.star.",
467 current_tarball_number);
468 }
469 if (!does_file_exist(tarball_fname)) {
470 if (!does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST") ||
471 system("find " MNT_CDROM
472 "/archives/slice* > /dev/null 2> /dev/null")
473 == 0) {
474 log_msg(2, "OK, I think I'm done with tarballs...");
475 break;
476 }
477 log_msg(2, "OK, I think it's time for another CD...");
478 g_current_media_number++;
[541]479 sprintf(progress_str, "Comparing with %s #%d ",
[128]480 media_descriptor_string(bkpinfo->backup_media_type),
481 g_current_media_number);
482 log_to_screen(progress_str);
483 } else {
484 res = compare_a_tarball(tarball_fname, current_tarball_number);
485
486 g_current_progress++;
487 current_tarball_number++;
488 }
[1]489 }
[128]490 close_progress_form();
491 if (retval) {
[541]492 mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
[128]493 } else {
[541]494 mvaddstr_and_log_it(g_currentY++, 74, "Done.");
[1]495 }
[128]496 paranoid_free(tarball_fname);
497 paranoid_free(progress_str);
498 paranoid_free(tmp);
499 return (retval);
[1]500}
[128]501
[1]502/**************************************************************************
503 *END_COMPARE_ALL_TARBALLS *
504 **************************************************************************/
505
506/* @} - end LLcompareGroup */
507
508
509/**
510 * @addtogroup compareGroup
511 * @{
512 */
513/**
514 * Compare all data on a CD-R/CD-RW/DVD/ISO/NFS-based backup.
515 * @param bkpinfo The backup information structure. Passed to other functions.
516 * @return 0 for success, nonzero for failure.
517 */
[128]518int compare_to_CD(struct s_bkpinfo *bkpinfo)
[1]519{
520 /** needs malloc *********/
[128]521 char *tmp, *cwd, *new, *command;
522 int resA = 0;
523 int resB = 0;
524 long noof_changed_files;
[1]525
[128]526 malloc_string(tmp);
527 malloc_string(cwd);
528 malloc_string(new);
529 malloc_string(command);
[1]530
[128]531 assert(bkpinfo != NULL);
532
533 getcwd(cwd, MAX_STR_LEN - 1);
534 chdir(bkpinfo->restore_path);
535 getcwd(new, MAX_STR_LEN - 1);
536 sprintf(tmp, "new path is %s", new);
537 insist_on_this_cd_number(bkpinfo, g_current_media_number);
538 unlink("/tmp/changed.txt");
539
540 resA = compare_all_tarballs(bkpinfo);
541 resB = compare_all_biggiefiles(bkpinfo);
542 chdir(cwd);
543 noof_changed_files = count_lines_in_file("/tmp/changed.txt");
544 if (noof_changed_files) {
[541]545 sprintf(tmp, "%ld files do not match the backup ",
[128]546 noof_changed_files);
547 // mvaddstr_and_log_it( g_currentY++, 0, tmp );
548 log_to_screen(tmp);
549 sprintf(command, "cat /tmp/changed.txt >> %s", MONDO_LOGFILE);
550 paranoid_system(command);
551 } else {
[541]552 sprintf(tmp, "All files match the backup ");
[128]553 mvaddstr_and_log_it(g_currentY++, 0, tmp);
554 log_to_screen(tmp);
555 }
556
557 paranoid_free(tmp);
558 paranoid_free(cwd);
559 paranoid_free(new);
560 paranoid_free(command);
561
562 return (resA + resB);
[1]563}
564
565/**************************************************************************
566 *END_COMPARE_TO_CD *
567 **************************************************************************/
568
569
570
571
572/**
573 * Compare all data in the user's backup.
574 * This function will mount filesystems, compare afioballs and biggiefiles,
575 * and show the user the differences.
576 * @param bkpinfo The backup information structure. Passed to other functions.
577 * @param mountlist The mountlist containing partitions to mount.
578 * @param raidlist The raidlist containing the user's RAID devices.
579 * @return The number of errors/differences found.
580 */
581int
[128]582compare_mode(struct s_bkpinfo *bkpinfo,
583 struct mountlist_itself *mountlist,
584 struct raidlist_itself *raidlist)
[1]585{
[128]586 int retval = 0;
587 long q;
588 char *tmp;
[1]589
[128]590 malloc_string(tmp);
591
[1]592 /**************************************************************************
593 * also deletes tmp/filelist.full & tmp/biggielist.txt _and_ tries to *
594 * restore them from start of tape, if available *
595 **************************************************************************/
[128]596 assert(bkpinfo != NULL);
597 assert(mountlist != NULL);
598 assert(raidlist != NULL);
[1]599
[128]600 while (get_cfg_file_from_archive(bkpinfo)) {
601 if (!ask_me_yes_or_no
[541]602 ("Failed to find config file/archives. Choose another source?"))
[128]603 {
604 fatal_error("Unable to find config file/archives. Aborting.");
605 }
606 interactively_obtain_media_parameters_from_user(bkpinfo, FALSE);
607 }
[1]608
[128]609 read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
610 g_current_media_number = 1;
[541]611 mvaddstr_and_log_it(1, 30, "Comparing Automatically");
[128]612 iamhere("Pre-MAD");
613 retval = mount_all_devices(mountlist, FALSE);
614 iamhere("Post-MAD");
615 if (retval) {
616 unmount_all_devices(mountlist);
617 return (retval);
618 }
619 if (bkpinfo->backup_media_type == tape
620 || bkpinfo->backup_media_type == udev) {
621 retval += compare_to_tape(bkpinfo);
622 } else if (bkpinfo->backup_media_type == cdstream) {
623 retval += compare_to_cdstream(bkpinfo);
624 } else {
625 retval += compare_to_CD(bkpinfo);
626 }
627 if (retval) {
628 mvaddstr_and_log_it(g_currentY++,
629 0,
[541]630 "Warning - differences found during the compare phase");
[128]631 }
[1]632
[128]633 retval += unmount_all_devices(mountlist);
[1]634
[128]635 if (count_lines_in_file("/tmp/changed.txt") > 0) {
636 mvaddstr_and_log_it(g_currentY++, 0,
[541]637 "Differences found while files were being compared.");
[128]638 streamline_changes_file("/tmp/changed.files", "/tmp/changed.txt");
639 if (count_lines_in_file("/tmp/changed.files") <= 0) {
640 mvaddstr_and_log_it(g_currentY++, 0,
[541]641 "...but they were logfiles and temporary files. Your archives are fine.");
[128]642 log_to_screen
[541]643 ("The differences were logfiles and temporary files. Your archives are fine.");
[128]644 } else {
645 q = count_lines_in_file("/tmp/changed.files");
[541]646 sprintf(tmp, "%ld significant difference%s found.", q,
[128]647 (q != 1) ? "s" : "");
648 mvaddstr_and_log_it(g_currentY++, 0, tmp);
649 log_to_screen(tmp);
[1]650
[128]651 strcpy(tmp,
[541]652 "Type 'less /tmp/changed.files' for a list of non-matching files");
[128]653 mvaddstr_and_log_it(g_currentY++, 0, tmp);
654 log_to_screen(tmp);
[1]655
[128]656 log_msg(2, "calling popup_changelist_from_file()");
657 popup_changelist_from_file("/tmp/changed.files");
658 log_msg(2, "Returning from popup_changelist_from_file()");
659 }
660 } else {
661 log_to_screen
[541]662 ("No significant differences were found. Your backup is perfect.");
[1]663 }
[128]664 kill_petris();
665 paranoid_free(tmp);
666 return (retval);
[1]667}
668
669/**************************************************************************
670 *END_COMPARE_MODE *
671 **************************************************************************/
672
673/**
674 * Compare all data on a cdstream-based backup.
675 * @param bkpinfo The backup information structure. Fields used:
676 * - @c bkpinfo->disaster_recovery
677 * - @c bkpinfo->media_device
678 * - @c bkpinfo->restore_path
679 * @return 0 for success, nonzero for failure.
680 */
[128]681int compare_to_cdstream(struct s_bkpinfo *bkpinfo)
[1]682{
[128]683 int res;
[1]684
685 /** needs malloc **/
[128]686 char *dir, *command;
[1]687
[128]688 assert(bkpinfo != NULL);
689 malloc_string(dir);
690 malloc_string(command);
691 getcwd(dir, MAX_STR_LEN);
692 chdir(bkpinfo->restore_path);
[1]693
[128]694 sprintf(command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp",
695 bkpinfo->restore_path);
696 run_program_and_log_output(command, FALSE);
697 mvaddstr_and_log_it(g_currentY,
[541]698 0, "Verifying archives against filesystem");
[1]699
[128]700 if (bkpinfo->disaster_recovery
701 && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
702 strcpy(bkpinfo->media_device,
703 last_line_of_file("/tmp/CDROM-LIVES-HERE"));
704 } else {
705 find_cdrom_device(bkpinfo->media_device, FALSE);
706 }
707 res = verify_tape_backups(bkpinfo);
708 chdir(dir);
709 if (length_of_file("/tmp/changed.txt") > 2
710 && length_of_file("/tmp/changed.files") > 2) {
711 log_msg(0,
712 "Type 'less /tmp/changed.files' to see which files don't match the archives");
713 log_msg(2, "Calling popup_changelist_from_file()");
714 popup_changelist_from_file("/tmp/changed.files");
715 log_msg(2, "Returned from popup_changelist_from_file()");
716 }
717
[541]718 mvaddstr_and_log_it(g_currentY++, 74, "Done.");
[128]719 paranoid_free(dir);
720 paranoid_free(command);
721 return (res);
[1]722}
[128]723
[1]724/**************************************************************************
725 *END_COMPARE_CD_STREAM *
726 **************************************************************************/
727
728
729/**
730 * Compare all data on a tape-based backup.
731 * @param bkpinfo The backup information structure. Field used: @c bkpinfo->restore_path.
732 * @return 0 for success, nonzero for failure.
733 */
734/**************************************************************************
735 * F@COMPARE_TO_TAPE() *
736 * compare_to_tape() - gots me?? *
737 * *
738 * returns: int *
739 **************************************************************************/
[128]740int compare_to_tape(struct s_bkpinfo *bkpinfo)
[1]741{
[128]742 int res;
743 char *dir, *command;
[1]744
[128]745 assert(bkpinfo != NULL);
746 malloc_string(dir);
747 malloc_string(command);
748
749 getcwd(dir, MAX_STR_LEN);
750 chdir(bkpinfo->restore_path);
751 sprintf(command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp",
752 bkpinfo->restore_path);
753 run_program_and_log_output(command, FALSE);
754 mvaddstr_and_log_it(g_currentY,
[541]755 0, "Verifying archives against filesystem");
[128]756 res = verify_tape_backups(bkpinfo);
757 chdir(dir);
758 if (res) {
[541]759 mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
[128]760 } else {
[541]761 mvaddstr_and_log_it(g_currentY++, 74, "Done.");
[128]762 }
763 paranoid_free(dir);
764 paranoid_free(command);
765 return (res);
[1]766}
767
768/**************************************************************************
769 *END_COMPARE_TO_TAPE *
770 **************************************************************************/
771
772/* @} - end compareGroup */
Note: See TracBrowser for help on using the repository browser.