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