Changeset 128 in MondoRescue for branches/2.05/mondo/mondo/common/libmondo-filelist.c
- Timestamp:
- Nov 19, 2005, 2:27:41 AM (18 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/2.05/mondo/mondo/common/libmondo-filelist.c
r30 r128 1 1 /* libmondo-filelist.c 2 $Id : libmondo-filelist.c,v 1.6 2004/06/10 15:29:12 hugo Exp$2 $Id$ 3 3 4 4 - for subroutines which manipulate the filelist … … 135 135 136 136 137 extern ssize_t getline(char **lineptr, size_t *n, FILE *stream); 138 139 140 int mondo_makefilelist(char*logfile, char*tmpdir, char*scratchdir, 141 char*include_paths, char*excp, int differential, char *userdef_filelist); 137 extern ssize_t getline(char **lineptr, size_t * n, FILE * stream); 138 139 140 int mondo_makefilelist(char *logfile, char *tmpdir, char *scratchdir, 141 char *include_paths, char *excp, int differential, 142 char *userdef_filelist); 142 143 143 144 144 145 /*@unused@*/ 145 //static char cvsid[] = "$Id : libmondo-filelist.c,v 1.6 2004/06/10 15:29:12 hugo Exp$";146 //static char cvsid[] = "$Id$"; 146 147 147 148 /** … … 156 157 * @ingroup globalGroup 157 158 */ 158 long g_noof_sets =0;159 long g_noof_sets = 0; 159 160 160 161 extern bool g_text_mode; … … 180 181 * @see chop_filelist 181 182 */ 182 int 183 call_filelist_chopper (struct s_bkpinfo *bkpinfo) 184 { 185 /*@ buffers ************************/ 186 char *dev; 187 char *filelist; 188 char *tempfile; 189 char *cksumlist; 190 char *tmp; 191 long noof_sets; 192 193 /*@ pointers ***********************/ 194 char *ptr; 195 FILE *fout; 196 197 /*@ int ****************************/ 198 int i, retval=0; 199 200 malloc_string(dev); 201 malloc_string(filelist); 202 malloc_string(tempfile); 203 malloc_string(cksumlist); 204 malloc_string(tmp); 205 mvaddstr_and_log_it (g_currentY, 0, "Dividing filelist into sets"); 206 207 log_to_screen ("Dividing filelist into sets. Please wait."); 208 i=0; 183 int call_filelist_chopper(struct s_bkpinfo *bkpinfo) 184 { 185 /*@ buffers *********************** */ 186 char *dev; 187 char *filelist; 188 char *tempfile; 189 char *cksumlist; 190 char *tmp; 191 long noof_sets; 192 193 /*@ pointers ********************** */ 194 char *ptr; 195 FILE *fout; 196 197 /*@ int *************************** */ 198 int i, retval = 0; 199 200 malloc_string(dev); 201 malloc_string(filelist); 202 malloc_string(tempfile); 203 malloc_string(cksumlist); 204 malloc_string(tmp); 205 mvaddstr_and_log_it(g_currentY, 0, "Dividing filelist into sets"); 206 207 log_to_screen("Dividing filelist into sets. Please wait."); 208 i = 0; 209 209 /* 210 210 if (find_home_of_exe("getfattr")) … … 215 215 { i=0; log_to_screen ("This will take more time. Please be patient."); } 216 216 */ 217 sprintf(filelist, "%s/archives/filelist.full", bkpinfo->scratchdir);218 sprintf(cksumlist, "%s/cklist.full", bkpinfo->tmpdir);219 if (!does_file_exist(filelist)) { log_it("filelist %s not found", filelist); fatal_error("call_filelist_chopper() -- filelist not found!"); } 220 221 noof_sets = chop_filelist (filelist, bkpinfo->tmpdir, bkpinfo->optimal_set_size);222 estimate_noof_media_required (bkpinfo, noof_sets); // for cosmetic purposes 223 224 sprintf (tempfile, "%s/biggielist.txt", bkpinfo->tmpdir); 225 if (!(fout = fopen (tempfile, "a"))) 226 { 227 log_OS_error("Cannot append to biggielist"); 228 retval++; 229 goto end_of_func;230 } 231 log_it (bkpinfo->image_devs);232 233 ptr = bkpinfo->image_devs;234 235 while (ptr && *ptr) 236 { 237 strcpy (dev, ptr);238 log_it ("Examining imagedev %s", dev); 239 for (i = 0; i < (int) strlen (dev) && dev[i] != ' '; i++); 240 dev[i] = '\0';241 if (!strlen (dev)) 242 {243 continue;244 }245 fprintf (fout, "%s\n", dev);246 log_it ("Adding '%s' to biggielist", dev); 247 if ((ptr = strchr (ptr, ' '))) 248 {249 ptr++;250 }251 252 paranoid_fclose(fout); 253 mvaddstr_and_log_it (g_currentY++, 74, "Done.");254 255 end_of_func: 256 paranoid_free(filelist);257 paranoid_free(tempfile);258 paranoid_free(cksumlist);259 paranoid_free(dev);260 paranoid_free(tmp);261 return(retval);262 } 263 264 265 266 int sort_file(char*orig_fname) 267 { 268 char *tmp_fname; 269 char *command;270 int retval=0;271 272 log_msg(1, "Sorting file %s", orig_fname); 273 malloc_string(tmp_fname);274 malloc_string(command);275 sprintf(tmp_fname, "/tmp/sort.%d.%d.%d", (int)(random()%32768), (int)(random()%32768), (int)(random()%32768));276 277 if (!does_file_exist(orig_fname)) 278 { return(0); } // no sense in trying to sort an empty file 279 280 sprintf(command, "sort %s > %s 2>> %s", orig_fname, tmp_fname, MONDO_LOGFILE);281 retval = system(command); 282 if (retval) 283 { 284 log_msg(2, "Failed to sort %s - oh dear", orig_fname);285 } 286 else 287 { 288 log_msg(2, "Sorted %s --> %s OK. Copying it back to %s now", orig_fname, tmp_fname, orig_fname); 289 sprintf(command, "mv -f %s %s", tmp_fname, orig_fname); 290 retval += run_program_and_log_output(command, 2);291 if (retval) 292 { 293 log_msg(2, "Failed to copy %s back to %s - oh dear", tmp_fname, orig_fname);294 }295 else 296 297 298 }299 300 301 302 303 return(retval);217 sprintf(filelist, "%s/archives/filelist.full", bkpinfo->scratchdir); 218 sprintf(cksumlist, "%s/cklist.full", bkpinfo->tmpdir); 219 if (!does_file_exist(filelist)) { 220 log_it("filelist %s not found", filelist); 221 fatal_error("call_filelist_chopper() -- filelist not found!"); 222 } 223 224 noof_sets = 225 chop_filelist(filelist, bkpinfo->tmpdir, 226 bkpinfo->optimal_set_size); 227 estimate_noof_media_required(bkpinfo, noof_sets); // for cosmetic purposes 228 229 sprintf(tempfile, "%s/biggielist.txt", bkpinfo->tmpdir); 230 if (!(fout = fopen(tempfile, "a"))) { 231 log_OS_error("Cannot append to biggielist"); 232 retval++; 233 goto end_of_func; 234 } 235 log_it(bkpinfo->image_devs); 236 237 ptr = bkpinfo->image_devs; 238 239 while (ptr && *ptr) { 240 strcpy(dev, ptr); 241 log_it("Examining imagedev %s", dev); 242 for (i = 0; i < (int) strlen(dev) && dev[i] != ' '; i++); 243 dev[i] = '\0'; 244 if (!strlen(dev)) { 245 continue; 246 } 247 fprintf(fout, "%s\n", dev); 248 log_it("Adding '%s' to biggielist", dev); 249 if ((ptr = strchr(ptr, ' '))) { 250 ptr++; 251 } 252 } 253 paranoid_fclose(fout); 254 mvaddstr_and_log_it(g_currentY++, 74, "Done."); 255 256 end_of_func: 257 paranoid_free(filelist); 258 paranoid_free(tempfile); 259 paranoid_free(cksumlist); 260 paranoid_free(dev); 261 paranoid_free(tmp); 262 return (retval); 263 } 264 265 266 267 int sort_file(char *orig_fname) 268 { 269 char *tmp_fname; 270 char *command; 271 int retval = 0; 272 273 log_msg(1, "Sorting file %s", orig_fname); 274 malloc_string(tmp_fname); 275 malloc_string(command); 276 sprintf(tmp_fname, "/tmp/sort.%d.%d.%d", (int) (random() % 32768), 277 (int) (random() % 32768), (int) (random() % 32768)); 278 279 if (!does_file_exist(orig_fname)) { 280 return (0); 281 } // no sense in trying to sort an empty file 282 283 sprintf(command, "sort %s > %s 2>> %s", orig_fname, tmp_fname, 284 MONDO_LOGFILE); 285 retval = system(command); 286 if (retval) { 287 log_msg(2, "Failed to sort %s - oh dear", orig_fname); 288 } else { 289 log_msg(2, "Sorted %s --> %s OK. Copying it back to %s now", 290 orig_fname, tmp_fname, orig_fname); 291 sprintf(command, "mv -f %s %s", tmp_fname, orig_fname); 292 retval += run_program_and_log_output(command, 2); 293 if (retval) { 294 log_msg(2, "Failed to copy %s back to %s - oh dear", tmp_fname, 295 orig_fname); 296 } else { 297 log_msg(2, "%s was sorted OK.", orig_fname); 298 } 299 } 300 paranoid_free(tmp_fname); 301 paranoid_free(command); 302 log_msg(1, "Finished sorting file %s", orig_fname); 303 return (retval); 304 304 } 305 305 … … 318 318 * @return number of errors encountered (0 for success). 319 319 */ 320 int 321 chop_filelist (char *filelist, char *outdir, long maxsetsizeK) 320 int chop_filelist(char *filelist, char *outdir, long maxsetsizeK) 322 321 { 323 322 /*@ long ****************************************/ 324 325 326 327 328 329 330 /*@ int **************************************** */331 332 333 334 /*@ buffers ************************************* */335 336 337 338 339 340 341 342 /*@ pointers *********************************** */343 344 345 346 347 /*@ structures ********************************* */348 349 350 351 352 353 incoming = malloc(MAX_STR_LEN*2);354 355 356 357 358 359 360 assert(maxsetsizeK > 0);361 362 max_sane_size_for_a_file = 32L*1024L;323 long lino = 0; 324 long max_sane_size_for_a_file; 325 long curr_set_size; 326 long noof_lines; 327 long siz; 328 329 /*@ int **************************************** */ 330 int i; 331 long curr_set_no; 332 333 /*@ buffers ************************************* */ 334 char *outfname; 335 char *biggie_fname; 336 char *incoming; 337 char *tmp; 338 char *acl_fname; 339 char *xattr_fname; 340 341 /*@ pointers *********************************** */ 342 FILE *fin; 343 FILE *fout; 344 FILE *fbig; 345 346 /*@ structures ********************************* */ 347 struct stat buf; 348 int err = 0; 349 350 malloc_string(outfname); 351 malloc_string(biggie_fname); 352 incoming = malloc(MAX_STR_LEN * 2); 353 malloc_string(tmp); 354 malloc_string(acl_fname); 355 malloc_string(xattr_fname); 356 357 assert_string_is_neither_NULL_nor_zerolength(filelist); 358 assert_string_is_neither_NULL_nor_zerolength(outdir); 359 assert(maxsetsizeK > 0); 360 361 max_sane_size_for_a_file = 32L * 1024L; 363 362 // max_sane_size_for_a_file = maxsetsizeK*2; 364 363 // if (max_sane_size_for_a_file > 32*1024) 365 364 // { max_sane_size_for_a_file = 32*1024; } 366 367 log_it("filelist=%s;", filelist); 368 open_evalcall_form ("Dividing filelist into sets"); 369 noof_lines = count_lines_in_file (filelist); 370 if (!(fin = fopen (filelist, "r"))) { log_OS_error("Cannot openin filelist"); return(0); } 371 curr_set_no = 0; 372 curr_set_size = 0; 373 sprintf (outfname, "%s/filelist.%ld", outdir, curr_set_no); 374 sprintf (biggie_fname, "%s/biggielist.txt", outdir); 375 log_it("outfname=%s; biggie_fname=%s", outfname, biggie_fname); 376 if (!(fbig = fopen (biggie_fname, "w"))) { log_OS_error("Cannot openout biggie_fname"); err++; goto end_of_func; } 377 if (!(fout = fopen (outfname, "w"))) { log_OS_error("Cannot openout outfname"); err++; goto end_of_func; } 378 (void) fgets (incoming, MAX_STR_LEN*2-1, fin); 379 while (!feof (fin)) 380 { 381 lino++; 382 i = strlen (incoming) - 1; 383 if (i < 0) 384 { 385 i = 0; 386 } 387 if (i > MAX_STR_LEN-1) 388 { 389 incoming[MAX_STR_LEN-30] = '\0'; 390 log_msg(1, "Warning - truncating file %s's name", incoming); 391 err++; 392 } 393 if (incoming[i] < 32) 394 { 395 incoming[i] = '\0'; 396 } 397 if (!strncmp (incoming, "/dev/", 5)) 398 { 399 siz = 1; 400 } 401 else if (lstat (incoming, &buf) != 0) 402 { 403 siz = 0; 404 } 405 else 406 { 407 siz = (long) (buf.st_size >> 10); 408 } 409 if (siz > max_sane_size_for_a_file) 365 366 log_it("filelist=%s;", filelist); 367 open_evalcall_form("Dividing filelist into sets"); 368 noof_lines = count_lines_in_file(filelist); 369 if (!(fin = fopen(filelist, "r"))) { 370 log_OS_error("Cannot openin filelist"); 371 return (0); 372 } 373 curr_set_no = 0; 374 curr_set_size = 0; 375 sprintf(outfname, "%s/filelist.%ld", outdir, curr_set_no); 376 sprintf(biggie_fname, "%s/biggielist.txt", outdir); 377 log_it("outfname=%s; biggie_fname=%s", outfname, biggie_fname); 378 if (!(fbig = fopen(biggie_fname, "w"))) { 379 log_OS_error("Cannot openout biggie_fname"); 380 err++; 381 goto end_of_func; 382 } 383 if (!(fout = fopen(outfname, "w"))) { 384 log_OS_error("Cannot openout outfname"); 385 err++; 386 goto end_of_func; 387 } 388 (void) fgets(incoming, MAX_STR_LEN * 2 - 1, fin); 389 while (!feof(fin)) { 390 lino++; 391 i = strlen(incoming) - 1; 392 if (i < 0) { 393 i = 0; 394 } 395 if (i > MAX_STR_LEN - 1) { 396 incoming[MAX_STR_LEN - 30] = '\0'; 397 log_msg(1, "Warning - truncating file %s's name", incoming); 398 err++; 399 } 400 if (incoming[i] < 32) { 401 incoming[i] = '\0'; 402 } 403 if (!strncmp(incoming, "/dev/", 5)) { 404 siz = 1; 405 } else if (lstat(incoming, &buf) != 0) { 406 siz = 0; 407 } else { 408 siz = (long) (buf.st_size >> 10); 409 } 410 if (siz > max_sane_size_for_a_file) 410 411 // && strcmp(incoming+strlen(incoming)-4, ".bz2") && strcmp(incoming+strlen(incoming)-4, ".tbz")) 411 {412 fprintf(fbig, "%s\n", incoming);413 }414 else 415 {416 curr_set_size += siz;417 fprintf (fout, "%s\n", incoming);418 if (curr_set_size > maxsetsizeK)419 {420 paranoid_fclose(fout);421 sort_file(outfname);422 curr_set_no++;423 curr_set_size = 0;424 sprintf (outfname, "%s/filelist.%ld", outdir, curr_set_no);425 if (!(fout = fopen (outfname, "w"))) { log_OS_error("Unable to openout outfname"); err++; goto end_of_func; }426 sprintf (tmp, "Fileset #%ld chopped ", curr_set_no - 1);427 update_evalcall_form ((int) (lino * 100 / noof_lines));428 /* if (!g_text_mode) {newtDrawRootText(0,22,tmp);newtRefresh();} else {log_it(tmp);} */429 }430 }431 (void) fgets (incoming, MAX_STR_LEN*2-1, fin); 432 } 433 paranoid_fclose (fin); 434 paranoid_fclose (fout);435 paranoid_fclose (fbig);436 437 if (length_of_file(outfname) <= 2) 438 439 440 g_noof_sets--;441 442 443 444 445 sprintf(outfname, "%s/LAST-FILELIST-NUMBER", outdir);446 sprintf(tmp, "%ld", curr_set_no);447 if (write_one_liner_data_file (outfname, tmp)) 448 { log_OS_error("Unable to echo write one-liner to LAST-FILELIST-NUMBER"); err = 1;} 449 if (curr_set_no == 0) 450 { 451 sprintf (tmp, "Only one fileset. Fine."); 452 } 453 else 454 455 sprintf(tmp, "Filelist divided into %ld sets", curr_set_no + 1);456 457 458 close_evalcall_form();459 460 461 462 412 { 413 fprintf(fbig, "%s\n", incoming); 414 } else { 415 curr_set_size += siz; 416 fprintf(fout, "%s\n", incoming); 417 if (curr_set_size > maxsetsizeK) { 418 paranoid_fclose(fout); 419 sort_file(outfname); 420 curr_set_no++; 421 curr_set_size = 0; 422 sprintf(outfname, "%s/filelist.%ld", outdir, curr_set_no); 423 if (!(fout = fopen(outfname, "w"))) { 424 log_OS_error("Unable to openout outfname"); 425 err++; 426 goto end_of_func; 427 } 428 sprintf(tmp, "Fileset #%ld chopped ", curr_set_no - 1); 429 update_evalcall_form((int) (lino * 100 / noof_lines)); 430 /* if (!g_text_mode) {newtDrawRootText(0,22,tmp);newtRefresh();} else {log_it(tmp);} */ 431 } 432 } 433 (void) fgets(incoming, MAX_STR_LEN * 2 - 1, fin); 434 } 435 paranoid_fclose(fin); 436 paranoid_fclose(fout); 437 paranoid_fclose(fbig); 438 439 if (length_of_file(outfname) <= 2) { 440 unlink(outfname); 441 g_noof_sets--; 442 } 443 g_noof_sets = curr_set_no; 444 sort_file(outfname); 445 sort_file(biggie_fname); 446 sprintf(outfname, "%s/LAST-FILELIST-NUMBER", outdir); 447 sprintf(tmp, "%ld", curr_set_no); 448 if (write_one_liner_data_file(outfname, tmp)) { 449 log_OS_error 450 ("Unable to echo write one-liner to LAST-FILELIST-NUMBER"); 451 err = 1; 452 } 453 if (curr_set_no == 0) { 454 sprintf(tmp, "Only one fileset. Fine."); 455 } else { 456 sprintf(tmp, "Filelist divided into %ld sets", curr_set_no + 1); 457 } 458 log_msg(1, tmp); 459 close_evalcall_form(); 460 /* This is to work around an obscure bug in Newt; open a form, close it, 461 carry on... I don't know why it works but it works. If you don't do this 462 then update_progress_form() won't show the "time taken / time remaining" 463 line. The bug only crops up AFTER the call to chop_filelist(). Weird. */ 463 464 #ifndef _XWIN 464 if (!g_text_mode) 465 { 466 open_progress_form ("", "", "", "", 100); 467 newtPopHelpLine (); 468 newtFormDestroy (g_progressForm); 469 newtPopWindow (); 470 } 465 if (!g_text_mode) { 466 open_progress_form("", "", "", "", 100); 467 newtPopHelpLine(); 468 newtFormDestroy(g_progressForm); 469 newtPopWindow(); 470 } 471 471 #endif 472 end_of_func:473 474 475 476 477 478 479 472 end_of_func: 473 paranoid_free(outfname); 474 paranoid_free(biggie_fname); 475 paranoid_free(incoming); 476 paranoid_free(tmp); 477 paranoid_free(acl_fname); 478 paranoid_free(xattr_fname); 479 return (err ? 0 : curr_set_no + 1); 480 480 } 481 481 … … 489 489 * @param filelist The filelist to free. 490 490 */ 491 void 492 free_filelist (struct s_node *filelist) 493 { 494 /*@ int's ********************************************************/ 495 static int depth = 0; 496 int percentage; 497 498 /*@ long's *******************************************************/ 499 static long i = 0; 500 501 /*@ end vars *****************************************************/ 502 503 assert(filelist!=NULL); 504 if (depth == 0) 505 { 506 open_evalcall_form ("Freeing memory"); 507 log_to_screen ("Freeing memory formerly occupied by filelist"); 508 } 509 depth++; 510 511 if (filelist->ch == '\0') 512 { 513 if (!(i++ % 1111)) 514 { 515 percentage = (int) (i * 100 / g_original_noof_lines_in_filelist); 516 update_evalcall_form (percentage); 517 518 } 519 } 520 521 if (filelist->right) 522 { 523 free_filelist (filelist->right); 524 filelist->right = NULL; 525 } 526 if (filelist->down) 527 { 491 void free_filelist(struct s_node *filelist) 492 { 493 /*@ int's ******************************************************* */ 494 static int depth = 0; 495 int percentage; 496 497 /*@ long's ****************************************************** */ 498 static long i = 0; 499 500 /*@ end vars **************************************************** */ 501 502 assert(filelist != NULL); 503 if (depth == 0) { 504 open_evalcall_form("Freeing memory"); 505 log_to_screen("Freeing memory formerly occupied by filelist"); 506 } 507 depth++; 508 509 if (filelist->ch == '\0') { 510 if (!(i++ % 1111)) { 511 percentage = 512 (int) (i * 100 / g_original_noof_lines_in_filelist); 513 update_evalcall_form(percentage); 514 515 } 516 } 517 518 if (filelist->right) { 519 free_filelist(filelist->right); 520 filelist->right = NULL; 521 } 522 if (filelist->down) { 528 523 /* if (!(i++ %39999)) { update_evalcall_form(0); } */ 529 free_filelist (filelist->down); 530 filelist->down = NULL; 531 } 532 filelist->ch = '\0'; 533 paranoid_free (filelist); 534 depth--; 535 if (depth == 0) 536 { 537 close_evalcall_form (); 538 log_it ("Finished freeing memory"); 539 } 540 } 541 542 543 int call_exe_and_pipe_output_to_fd(char*syscall, FILE*pout) 544 { 545 FILE *pattr; 546 char *tmp; 547 pattr = popen(syscall, "r"); 548 if (!pattr) 549 { 550 log_msg(1, "Failed to open fattr() %s", syscall); 551 return(1); 552 } 553 if (feof(pattr)) 554 { 555 log_msg(1, "Failed to call fattr() %s", syscall); 556 paranoid_pclose(pattr); 557 return(2); 558 } 559 malloc_string(tmp); 560 for (fgets (tmp, MAX_STR_LEN, pattr); !feof (pattr); 561 fgets (tmp, MAX_STR_LEN, pattr)) 562 { 563 fputs(tmp, pout); 564 } 565 paranoid_pclose(pattr); 566 paranoid_free(tmp); 567 return(0); 568 } 569 570 571 572 int gen_aux_list(char*filelist, char*syscall_sprintf, char*auxlist_fname) 573 { 574 FILE*fin; 575 FILE*pout; 576 char*pout_command; 577 char*syscall; 578 char*file_to_analyze; 579 int i; 580 581 if (!(fin=fopen(filelist, "r"))) 582 { 583 log_msg(1, "Cannot openin filelist %s", filelist); 584 return(1); 585 } 586 malloc_string(pout_command); 587 sprintf(pout_command, "gzip -c1 > %s", auxlist_fname); 588 if (!(pout=popen(pout_command, "w"))) 589 { 590 log_msg(1, "Cannot openout auxlist_fname %s", auxlist_fname); 591 fclose(fin); 592 paranoid_free(pout_command); 593 return(4); 594 } 595 malloc_string(syscall); 596 malloc_string(file_to_analyze); 597 for (fgets (file_to_analyze, MAX_STR_LEN, fin); !feof (fin); 598 fgets (file_to_analyze, MAX_STR_LEN, fin)) 599 { 600 i = strlen(file_to_analyze); 601 if (i>0 && file_to_analyze[i-1]<32) { file_to_analyze[i-1]='\0'; } 602 log_msg(8, "Analyzing %s", file_to_analyze); 603 sprintf(syscall, syscall_sprintf, file_to_analyze); 604 strcat(syscall, " 2>> /dev/null"); // " MONDO_LOGFILE); 605 call_exe_and_pipe_output_to_fd(syscall, pout); 606 } 607 paranoid_fclose(fin); 608 paranoid_pclose(pout); 609 paranoid_free(file_to_analyze); 610 paranoid_free(syscall); 611 paranoid_free(pout_command); 612 return(0); 613 } 614 615 616 int get_acl_list(char*filelist, char*facl_fname) 617 { 618 char*command; 619 int retval=0; 620 621 malloc_string(command); 622 sprintf(command, "touch %s", facl_fname); 623 run_program_and_log_output(command, 8); 624 if (find_home_of_exe("getfacl")) 625 { 524 free_filelist(filelist->down); 525 filelist->down = NULL; 526 } 527 filelist->ch = '\0'; 528 paranoid_free(filelist); 529 depth--; 530 if (depth == 0) { 531 close_evalcall_form(); 532 log_it("Finished freeing memory"); 533 } 534 } 535 536 537 int call_exe_and_pipe_output_to_fd(char *syscall, FILE * pout) 538 { 539 FILE *pattr; 540 char *tmp; 541 pattr = popen(syscall, "r"); 542 if (!pattr) { 543 log_msg(1, "Failed to open fattr() %s", syscall); 544 return (1); 545 } 546 if (feof(pattr)) { 547 log_msg(1, "Failed to call fattr() %s", syscall); 548 paranoid_pclose(pattr); 549 return (2); 550 } 551 malloc_string(tmp); 552 for (fgets(tmp, MAX_STR_LEN, pattr); !feof(pattr); 553 fgets(tmp, MAX_STR_LEN, pattr)) { 554 fputs(tmp, pout); 555 } 556 paranoid_pclose(pattr); 557 paranoid_free(tmp); 558 return (0); 559 } 560 561 562 563 int gen_aux_list(char *filelist, char *syscall_sprintf, 564 char *auxlist_fname) 565 { 566 FILE *fin; 567 FILE *pout; 568 char *pout_command; 569 char *syscall; 570 char *file_to_analyze; 571 int i; 572 573 if (!(fin = fopen(filelist, "r"))) { 574 log_msg(1, "Cannot openin filelist %s", filelist); 575 return (1); 576 } 577 malloc_string(pout_command); 578 sprintf(pout_command, "gzip -c1 > %s", auxlist_fname); 579 if (!(pout = popen(pout_command, "w"))) { 580 log_msg(1, "Cannot openout auxlist_fname %s", auxlist_fname); 581 fclose(fin); 582 paranoid_free(pout_command); 583 return (4); 584 } 585 malloc_string(syscall); 586 malloc_string(file_to_analyze); 587 for (fgets(file_to_analyze, MAX_STR_LEN, fin); !feof(fin); 588 fgets(file_to_analyze, MAX_STR_LEN, fin)) { 589 i = strlen(file_to_analyze); 590 if (i > 0 && file_to_analyze[i - 1] < 32) { 591 file_to_analyze[i - 1] = '\0'; 592 } 593 log_msg(8, "Analyzing %s", file_to_analyze); 594 sprintf(syscall, syscall_sprintf, file_to_analyze); 595 strcat(syscall, " 2>> /dev/null"); // " MONDO_LOGFILE); 596 call_exe_and_pipe_output_to_fd(syscall, pout); 597 } 598 paranoid_fclose(fin); 599 paranoid_pclose(pout); 600 paranoid_free(file_to_analyze); 601 paranoid_free(syscall); 602 paranoid_free(pout_command); 603 return (0); 604 } 605 606 607 int get_acl_list(char *filelist, char *facl_fname) 608 { 609 char *command; 610 int retval = 0; 611 612 malloc_string(command); 613 sprintf(command, "touch %s", facl_fname); 614 run_program_and_log_output(command, 8); 615 if (find_home_of_exe("getfacl")) { 626 616 // sort_file(filelist); // FIXME - filelist chopper sorts, so this isn't necessary 627 sprintf(command, "cat %s | getfacl --all-effective -P - 2>> %s | gzip -c1 > %s 2>> %s", filelist, MONDO_LOGFILE, facl_fname, MONDO_LOGFILE); 628 iamhere(command); 629 retval = system(command); 630 } 631 paranoid_free(command); 632 return(retval); 633 } 634 635 636 int get_fattr_list(char*filelist, char*fattr_fname) 637 { 638 char *command; 639 int retval=0; 640 641 malloc_string(command); 642 sprintf(command, "touch %s", fattr_fname); 643 run_program_and_log_output(command, 8); 644 if (find_home_of_exe("getfattr")) 645 { 617 sprintf(command, 618 "cat %s | getfacl --all-effective -P - 2>> %s | gzip -c1 > %s 2>> %s", 619 filelist, MONDO_LOGFILE, facl_fname, MONDO_LOGFILE); 620 iamhere(command); 621 retval = system(command); 622 } 623 paranoid_free(command); 624 return (retval); 625 } 626 627 628 int get_fattr_list(char *filelist, char *fattr_fname) 629 { 630 char *command; 631 int retval = 0; 632 633 malloc_string(command); 634 sprintf(command, "touch %s", fattr_fname); 635 run_program_and_log_output(command, 8); 636 if (find_home_of_exe("getfattr")) { 646 637 // sort_file(filelist); // FIXME - filelist chopper sorts, so this isn't necessary 647 retval = gen_aux_list(filelist, "getfattr --en=hex -P -d \"%s\"", fattr_fname); 648 } 649 paranoid_free(command); 650 return(retval); 638 retval = 639 gen_aux_list(filelist, "getfattr --en=hex -P -d \"%s\"", 640 fattr_fname); 641 } 642 paranoid_free(command); 643 return (retval); 651 644 } 652 645 … … 674 667 675 668 676 int set_EXAT_list(char*orig_msklist, char*original_exat_fname, char*executable) 677 { 678 const int my_depth=8; 679 char*command, *syscall_pin, *syscall_pout, *incoming; 680 char*current_subset_file, *current_master_file, *masklist; 681 int retval=0; 682 int i; 683 char*p,*q; 684 FILE*pin, *pout, *faclin; 685 686 malloc_string(command); 687 log_msg(1, "set_EXAT_list(%s, %s, %s)", orig_msklist, original_exat_fname, executable); 688 if (!orig_msklist || !orig_msklist[0] || !does_file_exist(orig_msklist)) 689 { 690 log_msg(1, "No masklist provided. I shall therefore set ALL attributes."); 691 sprintf(command, "cat %s | gzip -dc | %s --restore - 2>> %s", original_exat_fname, executable, MONDO_LOGFILE); 692 log_msg(1, "command = %s", command); 693 retval = system(command); 694 paranoid_free(command); 695 log_msg(1, "Returning w/ retval=%d", retval); 696 return(retval); 697 } 698 if (length_of_file(original_exat_fname) <= 0) 699 { 700 log_msg(1, "original_exat_fname %s is empty or missing, so no need to set EXAT list", original_exat_fname); 701 paranoid_free(command); 702 return(0); 703 } 704 malloc_string(incoming); 705 malloc_string(masklist); 706 malloc_string(current_subset_file); 707 malloc_string(current_master_file); 708 malloc_string(syscall_pin); 709 malloc_string(syscall_pout); 710 sprintf(masklist, "/tmp/%d.%d.mask", (int)(random()%32768), (int)(random()%32768)); 711 sprintf(command, "cp -f %s %s", orig_msklist, masklist); 712 run_program_and_log_output(command, 1); 713 sort_file(masklist); 714 current_subset_file[0] = current_master_file[0] = '\0'; 715 sprintf(syscall_pin, "cat %s | gzip -dc", original_exat_fname); 716 sprintf(syscall_pout, "%s --restore - 2>> %s", executable, MONDO_LOGFILE); 717 718 log_msg(1, "syscall_pin = %s", syscall_pin); 719 log_msg(1, "syscall_pout = %s", syscall_pout); 720 pout = popen(syscall_pout, "w"); 721 if (!pout) 722 { iamhere("Unable to openout to syscall_pout"); return(1); } 723 pin = popen(syscall_pin, "r"); 724 if (!pin) 725 { pclose(pout); iamhere("Unable to openin from syscall"); return(1); } 726 faclin = fopen(masklist, "r"); 727 if (!faclin) 728 { pclose(pin); pclose(pout); iamhere("Unable to openin masklist"); return(1); } 729 669 int set_EXAT_list(char *orig_msklist, char *original_exat_fname, 670 char *executable) 671 { 672 const int my_depth = 8; 673 char *command, *syscall_pin, *syscall_pout, *incoming; 674 char *current_subset_file, *current_master_file, *masklist; 675 int retval = 0; 676 int i; 677 char *p, *q; 678 FILE *pin, *pout, *faclin; 679 680 malloc_string(command); 681 log_msg(1, "set_EXAT_list(%s, %s, %s)", orig_msklist, 682 original_exat_fname, executable); 683 if (!orig_msklist || !orig_msklist[0] 684 || !does_file_exist(orig_msklist)) { 685 log_msg(1, 686 "No masklist provided. I shall therefore set ALL attributes."); 687 sprintf(command, "cat %s | gzip -dc | %s --restore - 2>> %s", 688 original_exat_fname, executable, MONDO_LOGFILE); 689 log_msg(1, "command = %s", command); 690 retval = system(command); 691 paranoid_free(command); 692 log_msg(1, "Returning w/ retval=%d", retval); 693 return (retval); 694 } 695 if (length_of_file(original_exat_fname) <= 0) { 696 log_msg(1, 697 "original_exat_fname %s is empty or missing, so no need to set EXAT list", 698 original_exat_fname); 699 paranoid_free(command); 700 return (0); 701 } 702 malloc_string(incoming); 703 malloc_string(masklist); 704 malloc_string(current_subset_file); 705 malloc_string(current_master_file); 706 malloc_string(syscall_pin); 707 malloc_string(syscall_pout); 708 sprintf(masklist, "/tmp/%d.%d.mask", (int) (random() % 32768), 709 (int) (random() % 32768)); 710 sprintf(command, "cp -f %s %s", orig_msklist, masklist); 711 run_program_and_log_output(command, 1); 712 sort_file(masklist); 713 current_subset_file[0] = current_master_file[0] = '\0'; 714 sprintf(syscall_pin, "cat %s | gzip -dc", original_exat_fname); 715 sprintf(syscall_pout, "%s --restore - 2>> %s", executable, 716 MONDO_LOGFILE); 717 718 log_msg(1, "syscall_pin = %s", syscall_pin); 719 log_msg(1, "syscall_pout = %s", syscall_pout); 720 pout = popen(syscall_pout, "w"); 721 if (!pout) { 722 iamhere("Unable to openout to syscall_pout"); 723 return (1); 724 } 725 pin = popen(syscall_pin, "r"); 726 if (!pin) { 727 pclose(pout); 728 iamhere("Unable to openin from syscall"); 729 return (1); 730 } 731 faclin = fopen(masklist, "r"); 732 if (!faclin) { 733 pclose(pin); 734 pclose(pout); 735 iamhere("Unable to openin masklist"); 736 return (1); 737 } 730 738 // printf("Hi there. Starting the loop\n"); 731 732 fgets(current_subset_file, MAX_STR_LEN, faclin); 733 fgets(incoming, MAX_STR_LEN, pin); 734 while(!feof(pin) && !feof(faclin)) 735 { 739 740 fgets(current_subset_file, MAX_STR_LEN, faclin); 741 fgets(incoming, MAX_STR_LEN, pin); 742 while (!feof(pin) && !feof(faclin)) { 736 743 // printf("incoming = %s", incoming); 737 738 strcpy(current_master_file, incoming+8); 739 740 p = current_subset_file; 741 if (*p=='/') {p++;} 742 i = strlen(p); 743 if (i>0 && p[i-1]<32) { p[i-1] = '\0'; } 744 745 746 q = current_master_file; 747 if (*q=='/') {q++;} 748 i = strlen(q); 749 if (i>0 && q[i-1]<32) { q[i-1] = '\0'; } 750 751 i = strcmp(p,q); 752 log_msg(my_depth, "'%s' v '%s' --> %d\n", p, q, i); 753 744 745 strcpy(current_master_file, incoming + 8); 746 747 p = current_subset_file; 748 if (*p == '/') { 749 p++; 750 } 751 i = strlen(p); 752 if (i > 0 && p[i - 1] < 32) { 753 p[i - 1] = '\0'; 754 } 755 756 757 q = current_master_file; 758 if (*q == '/') { 759 q++; 760 } 761 i = strlen(q); 762 if (i > 0 && q[i - 1] < 32) { 763 q[i - 1] = '\0'; 764 } 765 766 i = strcmp(p, q); 767 log_msg(my_depth, "'%s' v '%s' --> %d\n", p, q, i); 768 754 769 // printf("%s v %s --> %d\n", p, q, i); 755 756 if (i<0) 757 { // read another subset file in. 758 log_msg(my_depth, "Reading next subset line in\n\n"); 759 fgets(current_subset_file, MAX_STR_LEN, faclin); 760 continue; 761 } 762 763 if (!i) { fputs(incoming, pout); } 764 fgets(incoming, MAX_STR_LEN, pin); 765 if (!i) { log_msg(my_depth, "Copying master %s", q); } 766 770 771 if (i < 0) { // read another subset file in. 772 log_msg(my_depth, "Reading next subset line in\n\n"); 773 fgets(current_subset_file, MAX_STR_LEN, faclin); 774 continue; 775 } 776 777 if (!i) { 778 fputs(incoming, pout); 779 } 780 fgets(incoming, MAX_STR_LEN, pin); 781 if (!i) { 782 log_msg(my_depth, "Copying master %s", q); 783 } 767 784 // if (!i) { printf("Match --- %s\n", q); } 768 769 while (!feof(pin) && strncmp(incoming, "# file: ", 8)) 770 { 771 if (!i) { 772 773 // printf("%s", incoming); 774 775 fputs(incoming, pout); } 776 fgets(incoming, MAX_STR_LEN, pin); 777 } 778 if (!i) { fgets(current_subset_file, MAX_STR_LEN, faclin); } 779 } 780 while(!feof(pin)) { fgets (incoming, MAX_STR_LEN, pin); } 781 fclose(faclin); 782 pclose(pin); 783 pclose(pout); 784 785 786 while (!feof(pin) && strncmp(incoming, "# file: ", 8)) { 787 if (!i) { 788 789 // printf("%s", incoming); 790 791 fputs(incoming, pout); 792 } 793 fgets(incoming, MAX_STR_LEN, pin); 794 } 795 if (!i) { 796 fgets(current_subset_file, MAX_STR_LEN, faclin); 797 } 798 } 799 while (!feof(pin)) { 800 fgets(incoming, MAX_STR_LEN, pin); 801 } 802 fclose(faclin); 803 pclose(pin); 804 pclose(pout); 805 785 806 // printf("OK, loop is done\n"); 786 807 787 unlink(masklist); 788 789 790 791 792 793 794 795 return(retval);796 } 797 798 799 int set_fattr_list(char *masklist, char*fattr_fname)800 { 801 return(set_EXAT_list(masklist, fattr_fname, "setfattr"));802 } 803 804 805 806 int set_acl_list(char *masklist, char*acl_fname)807 { 808 return(set_EXAT_list(masklist, acl_fname, "setfacl"));808 unlink(masklist); 809 paranoid_free(current_subset_file); 810 paranoid_free(current_master_file); 811 paranoid_free(syscall_pout); 812 paranoid_free(syscall_pin); 813 paranoid_free(masklist); 814 paranoid_free(incoming); 815 paranoid_free(command); 816 return (retval); 817 } 818 819 820 int set_fattr_list(char *masklist, char *fattr_fname) 821 { 822 return (set_EXAT_list(masklist, fattr_fname, "setfattr")); 823 } 824 825 826 827 int set_acl_list(char *masklist, char *acl_fname) 828 { 829 return (set_EXAT_list(masklist, acl_fname, "setfacl")); 809 830 } 810 831 … … 833 854 * @note This function should only be called at restore-time. 834 855 */ 835 int 836 get_last_filelist_number (struct s_bkpinfo *bkpinfo) 837 { 838 /*@ buffers ******************************************************/ 839 char val_sz[MAX_STR_LEN]; 840 char cfg_fname[MAX_STR_LEN]; 856 int get_last_filelist_number(struct s_bkpinfo *bkpinfo) 857 { 858 /*@ buffers ***************************************************** */ 859 char val_sz[MAX_STR_LEN]; 860 char cfg_fname[MAX_STR_LEN]; 841 861 /* char tmp[MAX_STR_LEN]; remove stan benoit apr 2002 */ 842 862 843 /*@ long *********************************************************/ 844 int val_i; 845 846 /*@ end vars *****************************************************/ 847 848 assert(bkpinfo!=NULL); 849 850 sprintf (cfg_fname, "%s/mondo-restore.cfg", bkpinfo->tmpdir); 851 read_cfg_var (cfg_fname, "last-filelist-number", val_sz); 852 val_i = atoi (val_sz); 853 if (val_i <= 0) 854 { 855 val_i = 500; 856 } 857 return (val_i); 863 /*@ long ******************************************************** */ 864 int val_i; 865 866 /*@ end vars **************************************************** */ 867 868 assert(bkpinfo != NULL); 869 870 sprintf(cfg_fname, "%s/mondo-restore.cfg", bkpinfo->tmpdir); 871 read_cfg_var(cfg_fname, "last-filelist-number", val_sz); 872 val_i = atoi(val_sz); 873 if (val_i <= 0) { 874 val_i = 500; 875 } 876 return (val_i); 858 877 } 859 878 … … 866 885 * @bug I don't understand this function. Would someone care to explain it? 867 886 */ 868 int 869 add_string_at_node (struct s_node *startnode, char *string_to_add) 870 { 871 872 873 /*@ int *********************************************************/ 874 int noof_chars; 875 int i; 876 int res; 877 878 /*@ sturctures **************************************************/ 879 struct s_node *node, *newnode; 880 881 /*@ char *******************************************************/ 882 char char_to_add; 883 884 /*@ bools *******************************************************/ 885 886 const bool sosodef = FALSE; 887 888 static int depth=0; 889 static char original_string[MAX_STR_LEN]; 890 891 assert(startnode!=NULL); 892 assert(string_to_add!=NULL); 893 894 if (!depth) { strcpy(original_string, string_to_add); } 895 896 noof_chars = strlen (string_to_add) + 1; /* we include the '\0' */ 887 int add_string_at_node(struct s_node *startnode, char *string_to_add) 888 { 889 890 891 /*@ int ******************************************************** */ 892 int noof_chars; 893 int i; 894 int res; 895 896 /*@ sturctures ************************************************* */ 897 struct s_node *node, *newnode; 898 899 /*@ char ****************************************************** */ 900 char char_to_add; 901 902 /*@ bools ****************************************************** */ 903 904 const bool sosodef = FALSE; 905 906 static int depth = 0; 907 static char original_string[MAX_STR_LEN]; 908 909 assert(startnode != NULL); 910 assert(string_to_add != NULL); 911 912 if (!depth) { 913 strcpy(original_string, string_to_add); 914 } 915 916 noof_chars = strlen(string_to_add) + 1; /* we include the '\0' */ 897 917 898 918 /* walk across tree if necessary */ 899 900 901 if (node->right != NULL && node->ch < char_to_add) 902 { 903 log_msg(7, "depth=%d --- going RIGHT ... %c-->%c", depth,char_to_add, node->ch, (node->right)->ch);904 return (add_string_at_node(node->right, string_to_add));905 919 node = startnode; 920 char_to_add = string_to_add[0]; 921 if (node->right != NULL && node->ch < char_to_add) { 922 log_msg(7, "depth=%d --- going RIGHT ... %c-->%c", depth, 923 char_to_add, node->ch, (node->right)->ch); 924 return (add_string_at_node(node->right, string_to_add)); 925 } 906 926 907 927 /* walk down tree if appropriate */ 908 if (node->down != NULL && node->ch == char_to_add) 909 { 910 log_msg(7, "depth=%d char=%c --- going DOWN", depth, char_to_add); 911 depth++; 912 res = add_string_at_node (node->down, string_to_add + 1); 913 depth--; 914 return (res); 915 } 916 917 if (char_to_add == '\0' && node->ch =='\0') 918 { 919 log_msg(6, "%s already in tree", original_string); 920 return(1); 921 } 928 if (node->down != NULL && node->ch == char_to_add) { 929 log_msg(7, "depth=%d char=%c --- going DOWN", depth, char_to_add); 930 depth++; 931 res = add_string_at_node(node->down, string_to_add + 1); 932 depth--; 933 return (res); 934 } 935 936 if (char_to_add == '\0' && node->ch == '\0') { 937 log_msg(6, "%s already in tree", original_string); 938 return (1); 939 } 922 940 923 941 /* add here */ 924 if (!(newnode = (struct s_node*)malloc (sizeof (struct s_node)))) 925 { 926 log_to_screen ("failed to malloc"); 927 depth--; 928 return (1); 929 } 930 if (char_to_add < node->ch) // add to the left of node 931 { 932 log_msg(7, "depth=%d char=%c --- adding (left)", depth, char_to_add); 933 memcpy((void*)newnode, (void*)node, sizeof(struct s_node)); 934 node->right = newnode; 935 } 936 else if (char_to_add > node->ch) // add to the right of node 937 { 938 log_msg(7, "depth=%d char=%c --- adding (right)", depth, char_to_add); 939 newnode->right = node->right; // newnode is to the RIGHT of node 940 node->right = newnode; 941 node = newnode; 942 } 943 // from now on, we're working on 'node' 944 node->down = NULL; 945 node->ch = char_to_add; 946 node->expanded = node->selected = FALSE; 947 if (char_to_add == '\0') 948 { 949 log_msg (6, "Added %s OK", original_string); 950 return (0); 951 } 952 942 if (!(newnode = (struct s_node *) malloc(sizeof(struct s_node)))) { 943 log_to_screen("failed to malloc"); 944 depth--; 945 return (1); 946 } 947 if (char_to_add < node->ch) // add to the left of node 948 { 949 log_msg(7, "depth=%d char=%c --- adding (left)", depth, 950 char_to_add); 951 memcpy((void *) newnode, (void *) node, sizeof(struct s_node)); 952 node->right = newnode; 953 } else if (char_to_add > node->ch) // add to the right of node 954 { 955 log_msg(7, "depth=%d char=%c --- adding (right)", depth, 956 char_to_add); 957 newnode->right = node->right; // newnode is to the RIGHT of node 958 node->right = newnode; 959 node = newnode; 960 } 961 // from now on, we're working on 'node' 962 node->down = NULL; 963 node->ch = char_to_add; 964 node->expanded = node->selected = FALSE; 965 if (char_to_add == '\0') { 966 log_msg(6, "Added %s OK", original_string); 967 return (0); 968 } 953 969 // add the rest 954 log_msg(6, "Adding remaining chars ('%s')", string_to_add+1); 955 for (i = 1; i < noof_chars; i++) 956 { 957 if (!(node->down = (struct s_node*)malloc (sizeof (struct s_node)))) 958 { 959 log_to_screen ("%s - failed to malloc", string_to_add); 960 return (1); 961 } 962 node = node->down; 963 char_to_add = string_to_add[i]; 964 log_msg(6, "Adding '%c'", char_to_add); 965 node->ch = char_to_add; 966 node->right = node->down = NULL; 967 node->expanded = node->selected = FALSE; 968 if (!node->ch) { node->selected = sosodef; } 969 } 970 log_msg (6, "Finally - added %s OK", original_string); 971 return (0); 970 log_msg(6, "Adding remaining chars ('%s')", string_to_add + 1); 971 for (i = 1; i < noof_chars; i++) { 972 if (! 973 (node->down = 974 (struct s_node *) malloc(sizeof(struct s_node)))) { 975 log_to_screen("%s - failed to malloc", string_to_add); 976 return (1); 977 } 978 node = node->down; 979 char_to_add = string_to_add[i]; 980 log_msg(6, "Adding '%c'", char_to_add); 981 node->ch = char_to_add; 982 node->right = node->down = NULL; 983 node->expanded = node->selected = FALSE; 984 if (!node->ch) { 985 node->selected = sosodef; 986 } 987 } 988 log_msg(6, "Finally - added %s OK", original_string); 989 return (0); 972 990 } 973 991 … … 981 999 * @return A filelist tree structure. 982 1000 */ 983 struct s_node * 984 load_filelist (char *filelist_fname) 985 { 986 987 /*@ structures **************************************************/ 988 struct s_node *filelist; 989 990 /*@ pointers ****************************************************/ 991 FILE *pin; 992 993 /*@ buffers *****************************************************/ 994 char command_to_open_fname[MAX_STR_LEN]; 995 char fname[MAX_STR_LEN]; 996 char tmp[MAX_STR_LEN]; 997 int pos_in_fname; 998 /*@ int *********************************************************/ 999 int percentage; 1000 1001 /*@ long ********************************************************/ 1002 long lines_in_filelist; 1003 long lino = 0; 1004 /*@ end vars ****************************************************/ 1005 1006 assert_string_is_neither_NULL_nor_zerolength(filelist_fname); 1007 1008 if (!does_file_exist(filelist_fname)) 1009 { fatal_error("filelist does not exist -- cannot load it"); } 1010 log_to_screen ("Loading filelist"); 1011 sprintf(command_to_open_fname, "gzip -dc %s", filelist_fname); 1012 sprintf(tmp, "zcat %s | wc -l", filelist_fname); 1013 log_msg(6, "tmp = %s", tmp); 1014 lines_in_filelist = atol(call_program_and_get_last_line_of_output(tmp)); 1015 if (lines_in_filelist < 3) { log_to_screen("Warning - surprisingly short filelist."); } 1016 g_original_noof_lines_in_filelist = lines_in_filelist; 1017 if (!(filelist = (struct s_node*)malloc (sizeof (struct s_node)))) 1018 { 1019 return (NULL); 1020 } 1021 filelist->ch = '/'; 1022 filelist->right = NULL; 1023 filelist->down = malloc(sizeof(struct s_node)); 1024 filelist->expanded = filelist->selected = FALSE; 1025 (filelist->down)->ch = '\0'; 1026 (filelist->down)->right = (filelist->down)->down = FALSE; 1027 (filelist->down)->expanded = (filelist->down)->selected = FALSE; 1028 if (!(pin = popen (command_to_open_fname, "r"))) 1029 { 1030 log_OS_error("Unable to openin filelist_fname"); 1031 return (NULL); 1032 } 1033 open_evalcall_form ("Loading filelist from disk"); 1034 for (fgets (fname, MAX_STR_LEN, pin); !feof (pin); 1035 fgets (fname, MAX_STR_LEN, pin)) 1036 { 1037 if ((fname[strlen(fname)-1]==13 || fname[strlen(fname)-1]==10) && strlen(fname)>0) 1038 { fname[strlen(fname)-1] = '\0'; } 1001 struct s_node *load_filelist(char *filelist_fname) 1002 { 1003 1004 /*@ structures ************************************************* */ 1005 struct s_node *filelist; 1006 1007 /*@ pointers *************************************************** */ 1008 FILE *pin; 1009 1010 /*@ buffers **************************************************** */ 1011 char command_to_open_fname[MAX_STR_LEN]; 1012 char fname[MAX_STR_LEN]; 1013 char tmp[MAX_STR_LEN]; 1014 int pos_in_fname; 1015 /*@ int ******************************************************** */ 1016 int percentage; 1017 1018 /*@ long ******************************************************* */ 1019 long lines_in_filelist; 1020 long lino = 0; 1021 /*@ end vars *************************************************** */ 1022 1023 assert_string_is_neither_NULL_nor_zerolength(filelist_fname); 1024 1025 if (!does_file_exist(filelist_fname)) { 1026 fatal_error("filelist does not exist -- cannot load it"); 1027 } 1028 log_to_screen("Loading filelist"); 1029 sprintf(command_to_open_fname, "gzip -dc %s", filelist_fname); 1030 sprintf(tmp, "zcat %s | wc -l", filelist_fname); 1031 log_msg(6, "tmp = %s", tmp); 1032 lines_in_filelist = 1033 atol(call_program_and_get_last_line_of_output(tmp)); 1034 if (lines_in_filelist < 3) { 1035 log_to_screen("Warning - surprisingly short filelist."); 1036 } 1037 g_original_noof_lines_in_filelist = lines_in_filelist; 1038 if (!(filelist = (struct s_node *) malloc(sizeof(struct s_node)))) { 1039 return (NULL); 1040 } 1041 filelist->ch = '/'; 1042 filelist->right = NULL; 1043 filelist->down = malloc(sizeof(struct s_node)); 1044 filelist->expanded = filelist->selected = FALSE; 1045 (filelist->down)->ch = '\0'; 1046 (filelist->down)->right = (filelist->down)->down = FALSE; 1047 (filelist->down)->expanded = (filelist->down)->selected = FALSE; 1048 if (!(pin = popen(command_to_open_fname, "r"))) { 1049 log_OS_error("Unable to openin filelist_fname"); 1050 return (NULL); 1051 } 1052 open_evalcall_form("Loading filelist from disk"); 1053 for (fgets(fname, MAX_STR_LEN, pin); !feof(pin); 1054 fgets(fname, MAX_STR_LEN, pin)) { 1055 if ((fname[strlen(fname) - 1] == 13 1056 || fname[strlen(fname) - 1] == 10) && strlen(fname) > 0) { 1057 fname[strlen(fname) - 1] = '\0'; 1058 } 1039 1059 // strip_spaces (fname); 1040 if (!strlen (fname)) 1041 {1042 continue;1043 }1044 for(pos_in_fname=0; fname[pos_in_fname]!='\0'; pos_in_fname++) 1045 { 1046 if (fname[pos_in_fname]!='/') { continue;}1047 1048 1049 if (strlen(tmp))1050 { add_string_at_node (filelist, tmp); } 1051 }1052 add_string_at_node (filelist, fname); 1053 if (!(++lino % 1111)) 1054 {1055 1056 update_evalcall_form(percentage);1057 }1058 1059 1060 close_evalcall_form();1061 log_it("Finished loading filelist");1062 1060 if (!strlen(fname)) { 1061 continue; 1062 } 1063 for (pos_in_fname = 0; fname[pos_in_fname] != '\0'; pos_in_fname++) { 1064 if (fname[pos_in_fname] != '/') { 1065 continue; 1066 } 1067 strcpy(tmp, fname); 1068 tmp[pos_in_fname] = '\0'; 1069 if (strlen(tmp)) { 1070 add_string_at_node(filelist, tmp); 1071 } 1072 } 1073 add_string_at_node(filelist, fname); 1074 if (!(++lino % 1111)) { 1075 percentage = (int) (lino * 100 / lines_in_filelist); 1076 update_evalcall_form(percentage); 1077 } 1078 } 1079 paranoid_pclose(pin); 1080 close_evalcall_form(); 1081 log_it("Finished loading filelist"); 1082 return (filelist); 1063 1083 } 1064 1084 … … 1068 1088 * @param node The toplevel node to use. 1069 1089 */ 1070 void 1071 show_filelist (struct s_node *node) 1072 { 1073 static int depth=0; 1074 static char current_string[200]; 1075 1076 if (depth==0) 1077 { log_msg(0, "----------------show filelist--------------"); } 1078 current_string[depth] = node->ch; 1079 1080 log_msg(3, "depth=%d", depth); 1081 if (node->down) 1082 { 1083 log_msg(3, "moving down"); 1084 depth++; 1085 show_filelist(node->down); 1086 depth--; 1087 } 1088 1089 if (!node->ch) 1090 { 1091 log_msg(0, "%s\n", current_string); 1092 } 1093 1094 if (node->right) 1095 { 1096 log_msg(3, "moving right"); 1097 show_filelist(node->right); 1098 } 1099 if (depth==0) 1100 { log_msg(0, "----------------show filelist--------------"); } 1101 return; 1090 void show_filelist(struct s_node *node) 1091 { 1092 static int depth = 0; 1093 static char current_string[200]; 1094 1095 if (depth == 0) { 1096 log_msg(0, "----------------show filelist--------------"); 1097 } 1098 current_string[depth] = node->ch; 1099 1100 log_msg(3, "depth=%d", depth); 1101 if (node->down) { 1102 log_msg(3, "moving down"); 1103 depth++; 1104 show_filelist(node->down); 1105 depth--; 1106 } 1107 1108 if (!node->ch) { 1109 log_msg(0, "%s\n", current_string); 1110 } 1111 1112 if (node->right) { 1113 log_msg(3, "moving right"); 1114 show_filelist(node->right); 1115 } 1116 if (depth == 0) { 1117 log_msg(0, "----------------show filelist--------------"); 1118 } 1119 return; 1102 1120 } 1103 1121 … … 1110 1128 * @param filelist The filelist tree structure. 1111 1129 */ 1112 void 1113 reload_filelist (struct s_node *filelist) 1114 { 1115 assert(filelist!=NULL); 1116 toggle_node_selection (filelist, FALSE); 1117 toggle_path_expandability (filelist, "/", FALSE); 1118 toggle_all_root_dirs_on (filelist); 1130 void reload_filelist(struct s_node *filelist) 1131 { 1132 assert(filelist != NULL); 1133 toggle_node_selection(filelist, FALSE); 1134 toggle_path_expandability(filelist, "/", FALSE); 1135 toggle_all_root_dirs_on(filelist); 1119 1136 } 1120 1137 … … 1126 1143 * @param outfname Where to save it. 1127 1144 */ 1128 void 1129 save_filelist (struct s_node *filelist, char *outfname) 1130 { 1131 /*@ int **********************************************************/ 1132 static int percentage; 1133 static int depth = 0; 1134 1135 /*@ buffers ******************************************************/ 1136 static char str[MAX_STR_LEN]; 1137 1138 /*@ structures ***************************************************/ 1139 struct s_node *node; 1140 1141 /*@ pointers *****************************************************/ 1142 static FILE *fout = NULL; 1143 1144 /*@ long *********************************************************/ 1145 static long lines_in_filelist = 0; 1146 static long lino = 0; 1147 1148 /*@ end vars ****************************************************/ 1149 1150 assert(filelist!=NULL); 1151 assert(outfname!=NULL); // will be zerolength if save_filelist() is called by itself 1152 if (depth == 0) 1153 { 1154 log_to_screen ("Saving filelist"); 1155 if (!(fout = fopen (outfname, "w"))) { fatal_error("Cannot openout/save filelist"); } 1156 lines_in_filelist = g_original_noof_lines_in_filelist; /* set by load_filelist() */ 1157 open_evalcall_form ("Saving selection to disk"); 1158 } 1159 for (node = filelist; node != NULL; node = node->right) 1160 { 1161 str[depth] = node->ch; 1162 log_msg(5, "depth=%d ch=%c", depth, node->ch); 1163 if (!node->ch) 1164 { 1165 // if (node->selected) 1166 // { 1167 fprintf (fout, "%s\n", str); 1168 // } 1169 if (!(++lino % 1111)) 1170 { 1171 percentage = (int) (lino * 100 / lines_in_filelist); 1172 update_evalcall_form (percentage); 1173 } 1174 } 1175 if (node->down) 1176 { 1177 depth++; 1178 save_filelist (node->down, ""); 1179 depth--; 1180 } 1181 } 1182 if (depth == 0) 1183 { 1184 paranoid_fclose (fout); 1185 close_evalcall_form (); 1186 log_it ("Finished saving filelist"); 1187 } 1145 void save_filelist(struct s_node *filelist, char *outfname) 1146 { 1147 /*@ int ********************************************************* */ 1148 static int percentage; 1149 static int depth = 0; 1150 1151 /*@ buffers ***************************************************** */ 1152 static char str[MAX_STR_LEN]; 1153 1154 /*@ structures ************************************************** */ 1155 struct s_node *node; 1156 1157 /*@ pointers **************************************************** */ 1158 static FILE *fout = NULL; 1159 1160 /*@ long ******************************************************** */ 1161 static long lines_in_filelist = 0; 1162 static long lino = 0; 1163 1164 /*@ end vars *************************************************** */ 1165 1166 assert(filelist != NULL); 1167 assert(outfname != NULL); // will be zerolength if save_filelist() is called by itself 1168 if (depth == 0) { 1169 log_to_screen("Saving filelist"); 1170 if (!(fout = fopen(outfname, "w"))) { 1171 fatal_error("Cannot openout/save filelist"); 1172 } 1173 lines_in_filelist = g_original_noof_lines_in_filelist; /* set by load_filelist() */ 1174 open_evalcall_form("Saving selection to disk"); 1175 } 1176 for (node = filelist; node != NULL; node = node->right) { 1177 str[depth] = node->ch; 1178 log_msg(5, "depth=%d ch=%c", depth, node->ch); 1179 if (!node->ch) { 1180 // if (node->selected) 1181 // { 1182 fprintf(fout, "%s\n", str); 1183 // } 1184 if (!(++lino % 1111)) { 1185 percentage = (int) (lino * 100 / lines_in_filelist); 1186 update_evalcall_form(percentage); 1187 } 1188 } 1189 if (node->down) { 1190 depth++; 1191 save_filelist(node->down, ""); 1192 depth--; 1193 } 1194 } 1195 if (depth == 0) { 1196 paranoid_fclose(fout); 1197 close_evalcall_form(); 1198 log_it("Finished saving filelist"); 1199 } 1188 1200 } 1189 1201 … … 1195 1207 * @bug I don't understand this function. Would someone care to explain it? 1196 1208 */ 1197 void 1198 toggle_all_root_dirs_on (struct s_node *filelist) 1199 { 1200 /*@ structures ***************************************************/ 1201 struct s_node *node; 1202 1203 /*@ int **********************************************************/ 1204 static int depth = 0; 1205 static int root_dirs_expanded; 1206 1207 /*@ buffers ******************************************************/ 1208 static char filename[MAX_STR_LEN]; 1209 1210 /*@ end vars ****************************************************/ 1211 1212 assert(filelist!=NULL); 1213 if (depth == 0) 1214 { 1215 log_it ("Toggling all root dirs ON"); 1216 root_dirs_expanded = 0; 1217 } 1218 for (node = filelist; node != NULL; node = node->right) 1219 { 1220 filename[depth] = node->ch; 1221 if (node->ch == '\0' && strlen (filename) > 1 1222 && (!strchr (filename + 1, '/'))) 1223 { 1224 node->selected = FALSE; 1225 node->expanded = TRUE; 1226 // log_it (filename); 1227 root_dirs_expanded++; 1228 } 1229 if (node->down) 1230 { 1231 depth++; 1232 toggle_all_root_dirs_on (node->down); 1233 depth--; 1234 } 1235 } 1236 if (depth == 0) 1237 { 1238 log_it ("Finished toggling all root dirs ON"); 1239 } 1209 void toggle_all_root_dirs_on(struct s_node *filelist) 1210 { 1211 /*@ structures ************************************************** */ 1212 struct s_node *node; 1213 1214 /*@ int ********************************************************* */ 1215 static int depth = 0; 1216 static int root_dirs_expanded; 1217 1218 /*@ buffers ***************************************************** */ 1219 static char filename[MAX_STR_LEN]; 1220 1221 /*@ end vars *************************************************** */ 1222 1223 assert(filelist != NULL); 1224 if (depth == 0) { 1225 log_it("Toggling all root dirs ON"); 1226 root_dirs_expanded = 0; 1227 } 1228 for (node = filelist; node != NULL; node = node->right) { 1229 filename[depth] = node->ch; 1230 if (node->ch == '\0' && strlen(filename) > 1 1231 && (!strchr(filename + 1, '/'))) { 1232 node->selected = FALSE; 1233 node->expanded = TRUE; 1234 // log_it (filename); 1235 root_dirs_expanded++; 1236 } 1237 if (node->down) { 1238 depth++; 1239 toggle_all_root_dirs_on(node->down); 1240 depth--; 1241 } 1242 } 1243 if (depth == 0) { 1244 log_it("Finished toggling all root dirs ON"); 1245 } 1240 1246 } 1241 1247 … … 1249 1255 */ 1250 1256 void 1251 toggle_path_expandability 1252 1253 { 1254 1255 /*@ int ******************************************************** */1256 1257 1258 1259 1260 /*@ structures ************************************************* */1261 1262 1263 /*@ buffers **************************************************** */1264 1257 toggle_path_expandability(struct s_node *filelist, char *pathname, 1258 bool on_or_off) 1259 { 1260 1261 /*@ int ******************************************************** */ 1262 static int depth = 0; 1263 static int total_expanded; 1264 static int root_depth; 1265 int j; 1266 /*@ structures ************************************************* */ 1267 struct s_node *node; 1268 1269 /*@ buffers **************************************************** */ 1270 static char current_filename[MAX_STR_LEN]; 1265 1271 1266 1272 /* char tmp[MAX_STR_LEN+2]; */ 1267 1273 1268 /*@ end vars ****************************************************/ 1269 1270 assert(filelist!=NULL); 1271 assert_string_is_neither_NULL_nor_zerolength(pathname); 1272 if (depth == 0) 1273 { 1274 total_expanded = 0; 1274 /*@ end vars *************************************************** */ 1275 1276 assert(filelist != NULL); 1277 assert_string_is_neither_NULL_nor_zerolength(pathname); 1278 if (depth == 0) { 1279 total_expanded = 0; 1275 1280 // log_it ("Toggling path's expandability"); 1276 for (root_depth = (int) strlen (pathname); 1277 root_depth > 0 && pathname[root_depth - 1] != '/'; root_depth--); 1278 if (root_depth < 2) 1279 { 1280 root_depth = (int) strlen (pathname); 1281 } 1282 } 1283 for (node = filelist; node != NULL; node = node->right) 1284 { 1285 current_filename[depth] = node->ch; 1286 if (node->down) 1287 { 1288 depth++; 1289 toggle_path_expandability (node->down, pathname, on_or_off); 1290 depth--; 1291 } 1292 if (node->ch == '\0') 1293 { 1294 if (!strncmp (pathname, current_filename, strlen (pathname))) 1295 { 1296 for (j = root_depth; 1297 current_filename[j] != '/' && current_filename[j] != '\0'; 1298 j++); 1299 if (current_filename[j] != '\0') 1300 { 1301 for (j++; 1302 current_filename[j] != '/' 1303 && current_filename[j] != '\0'; j++); 1304 } 1305 if (current_filename[j] == '\0') 1306 { 1307 node->expanded = 1308 (!strcmp (pathname, current_filename) ? TRUE : on_or_off); 1309 } 1310 } 1311 } 1312 if (node->expanded) 1313 { 1314 if (total_expanded < ARBITRARY_MAXIMUM - 32 1315 || !strrchr (current_filename + strlen (pathname), '/')) 1316 { 1317 total_expanded++; 1318 } 1319 else 1320 { 1321 node->expanded = FALSE; 1322 } 1323 } 1324 } 1325 if (depth == 0) 1326 { 1281 for (root_depth = (int) strlen(pathname); 1282 root_depth > 0 && pathname[root_depth - 1] != '/'; 1283 root_depth--); 1284 if (root_depth < 2) { 1285 root_depth = (int) strlen(pathname); 1286 } 1287 } 1288 for (node = filelist; node != NULL; node = node->right) { 1289 current_filename[depth] = node->ch; 1290 if (node->down) { 1291 depth++; 1292 toggle_path_expandability(node->down, pathname, on_or_off); 1293 depth--; 1294 } 1295 if (node->ch == '\0') { 1296 if (!strncmp(pathname, current_filename, strlen(pathname))) { 1297 for (j = root_depth; 1298 current_filename[j] != '/' 1299 && current_filename[j] != '\0'; j++); 1300 if (current_filename[j] != '\0') { 1301 for (j++; 1302 current_filename[j] != '/' 1303 && current_filename[j] != '\0'; j++); 1304 } 1305 if (current_filename[j] == '\0') { 1306 node->expanded = 1307 (!strcmp(pathname, current_filename) ? TRUE : 1308 on_or_off); 1309 } 1310 } 1311 } 1312 if (node->expanded) { 1313 if (total_expanded < ARBITRARY_MAXIMUM - 32 1314 || !strrchr(current_filename + strlen(pathname), '/')) { 1315 total_expanded++; 1316 } else { 1317 node->expanded = FALSE; 1318 } 1319 } 1320 } 1321 if (depth == 0) { 1327 1322 // log_it ("Finished toggling expandability"); 1328 1323 } 1329 1324 } 1330 1325 … … 1337 1332 */ 1338 1333 void 1339 toggle_path_selection (struct s_node *filelist, char *pathname, 1340 bool on_or_off) 1341 { 1342 /*@ int **********************************************************/ 1343 static int depth = 0; 1344 int j; 1345 1346 /*@ structures ***************************************************/ 1347 struct s_node *node; 1348 1349 /*@ buffers ******************************************************/ 1350 static char current_filename[MAX_STR_LEN]; 1351 char tmp[MAX_STR_LEN + 2]; 1352 1353 /*@ end vars ****************************************************/ 1354 assert(filelist!=NULL); 1355 assert_string_is_neither_NULL_nor_zerolength(pathname); 1356 if (depth == 0) 1357 { 1358 log_it ("Toggling path's selection"); 1359 } 1360 for (node = filelist; node != NULL; node = node->right) 1361 { 1362 current_filename[depth] = node->ch; 1363 if (node->down) 1364 { 1365 depth++; 1366 toggle_path_selection (node->down, pathname, on_or_off); 1367 depth--; 1368 } 1369 if (node->ch == '\0') 1370 { 1371 if (!strncmp (pathname, current_filename, strlen (pathname))) 1372 { 1373 for (j = 0; 1374 pathname[j] != '\0' && pathname[j] == current_filename[j]; 1375 j++); 1376 if (current_filename[j] == '/' || current_filename[j] == '\0') 1377 { 1378 node->selected = on_or_off; 1379 sprintf (tmp, "%s is now %s\n", current_filename, 1380 (on_or_off ? "ON" : "OFF")); 1381 } 1382 } 1383 } 1384 } 1385 if (depth == 0) 1386 { 1387 log_it ("Finished toggling selection"); 1388 } 1334 toggle_path_selection(struct s_node *filelist, char *pathname, 1335 bool on_or_off) 1336 { 1337 /*@ int ********************************************************* */ 1338 static int depth = 0; 1339 int j; 1340 1341 /*@ structures ************************************************** */ 1342 struct s_node *node; 1343 1344 /*@ buffers ***************************************************** */ 1345 static char current_filename[MAX_STR_LEN]; 1346 char tmp[MAX_STR_LEN + 2]; 1347 1348 /*@ end vars *************************************************** */ 1349 assert(filelist != NULL); 1350 assert_string_is_neither_NULL_nor_zerolength(pathname); 1351 if (depth == 0) { 1352 log_it("Toggling path's selection"); 1353 } 1354 for (node = filelist; node != NULL; node = node->right) { 1355 current_filename[depth] = node->ch; 1356 if (node->down) { 1357 depth++; 1358 toggle_path_selection(node->down, pathname, on_or_off); 1359 depth--; 1360 } 1361 if (node->ch == '\0') { 1362 if (!strncmp(pathname, current_filename, strlen(pathname))) { 1363 for (j = 0; 1364 pathname[j] != '\0' 1365 && pathname[j] == current_filename[j]; j++); 1366 if (current_filename[j] == '/' 1367 || current_filename[j] == '\0') { 1368 node->selected = on_or_off; 1369 sprintf(tmp, "%s is now %s\n", current_filename, 1370 (on_or_off ? "ON" : "OFF")); 1371 } 1372 } 1373 } 1374 } 1375 if (depth == 0) { 1376 log_it("Finished toggling selection"); 1377 } 1389 1378 } 1390 1379 … … 1396 1385 * @bug I don't understand this function. Would someone care to explain it? 1397 1386 */ 1398 void 1399 toggle_node_selection (struct s_node *filelist, bool on_or_off) 1400 { 1401 /*@ structure ***************************************************/ 1402 struct s_node *node; 1403 1404 /*@ end vars ****************************************************/ 1405 assert(filelist!=NULL); 1406 for (node = filelist; node != NULL; node = node->right) 1407 { 1408 if (node->ch == '/') 1409 { 1410 continue; 1411 } /* don't go deep */ 1412 if (node->ch == '\0') 1413 { 1414 node->selected = on_or_off; 1415 } 1416 if (node->down) 1417 { 1418 toggle_node_selection (node->down, on_or_off); 1419 } 1420 } 1387 void toggle_node_selection(struct s_node *filelist, bool on_or_off) 1388 { 1389 /*@ structure ************************************************** */ 1390 struct s_node *node; 1391 1392 /*@ end vars *************************************************** */ 1393 assert(filelist != NULL); 1394 for (node = filelist; node != NULL; node = node->right) { 1395 if (node->ch == '/') { 1396 continue; 1397 } /* don't go deep */ 1398 if (node->ch == '\0') { 1399 node->selected = on_or_off; 1400 } 1401 if (node->down) { 1402 toggle_node_selection(node->down, on_or_off); 1403 } 1404 } 1421 1405 } 1422 1406 … … 1430 1414 * The pathname to the skeleton filelist, used to give better progress reporting for mondo_makefilelist(). 1431 1415 */ 1432 char *g_skeleton_filelist =NULL;1416 char *g_skeleton_filelist = NULL; 1433 1417 1434 1418 /** 1435 1419 * Number of entries in the skeleton filelist. 1436 1420 */ 1437 long g_skeleton_entries =0;1421 long g_skeleton_entries = 0; 1438 1422 1439 1423 /** … … 1449 1433 * @see mondo_makefilelist 1450 1434 */ 1451 int 1452 prepare_filelist (struct s_bkpinfo *bkpinfo) 1453 { 1454 1455 /*@ int *****************************************************/ 1456 int res = 0; 1435 int prepare_filelist(struct s_bkpinfo *bkpinfo) 1436 { 1437 1438 /*@ int **************************************************** */ 1439 int res = 0; 1457 1440 // patch by Herman Kuster 1458 1441 // end patch 1459 1460 1461 /*@ buffers ************************************************ */1442 int *p_res = &res; 1443 1444 /*@ buffers ************************************************ */ 1462 1445 // char command[MAX_STR_LEN*2]; 1463 1446 1464 /*@ i don't have any idea ***********************************/ 1465 1466 assert(bkpinfo!=NULL); 1467 log_it ("tmpdir=%s; scratchdir=%s", bkpinfo->tmpdir, 1468 bkpinfo->scratchdir); 1469 if (bkpinfo->make_filelist) 1470 { 1471 mvaddstr_and_log_it (g_currentY, 0, 1472 "Making catalog of files to be backed up"); 1473 } 1474 else 1475 { 1476 mvaddstr_and_log_it (g_currentY, 0, 1477 "Using supplied catalog of files to be backed up"); 1478 } 1479 1480 if (bkpinfo->make_filelist) 1481 { 1482 res = mondo_makefilelist( 1483 MONDO_LOGFILE, bkpinfo->tmpdir, bkpinfo->scratchdir, 1484 bkpinfo->include_paths, 1485 bkpinfo->exclude_paths, 1486 bkpinfo->differential, 1487 NULL); 1488 } 1489 else 1490 { 1491 res = mondo_makefilelist( 1492 MONDO_LOGFILE, bkpinfo->tmpdir, bkpinfo->scratchdir, 1493 NULL, 1494 bkpinfo->exclude_paths, 1495 bkpinfo->differential, 1496 bkpinfo->include_paths); 1497 } 1498 1499 if (res) 1500 { 1501 log_OS_error("Call to mondo-makefilelist failed"); 1502 *p_res ++; 1503 mvaddstr_and_log_it (g_currentY++, 74, "Failed."); 1504 } 1505 else 1506 { 1507 mvaddstr_and_log_it (g_currentY++, 74, "Done."); 1508 } 1509 return (res); 1447 /*@ i don't have any idea ********************************** */ 1448 1449 assert(bkpinfo != NULL); 1450 log_it("tmpdir=%s; scratchdir=%s", bkpinfo->tmpdir, 1451 bkpinfo->scratchdir); 1452 if (bkpinfo->make_filelist) { 1453 mvaddstr_and_log_it(g_currentY, 0, 1454 "Making catalog of files to be backed up"); 1455 } else { 1456 mvaddstr_and_log_it(g_currentY, 0, 1457 "Using supplied catalog of files to be backed up"); 1458 } 1459 1460 if (bkpinfo->make_filelist) { 1461 res = 1462 mondo_makefilelist(MONDO_LOGFILE, bkpinfo->tmpdir, 1463 bkpinfo->scratchdir, bkpinfo->include_paths, 1464 bkpinfo->exclude_paths, 1465 bkpinfo->differential, NULL); 1466 } else { 1467 res = 1468 mondo_makefilelist(MONDO_LOGFILE, bkpinfo->tmpdir, 1469 bkpinfo->scratchdir, NULL, 1470 bkpinfo->exclude_paths, 1471 bkpinfo->differential, 1472 bkpinfo->include_paths); 1473 } 1474 1475 if (res) { 1476 log_OS_error("Call to mondo-makefilelist failed"); 1477 *p_res++; 1478 mvaddstr_and_log_it(g_currentY++, 74, "Failed."); 1479 } else { 1480 mvaddstr_and_log_it(g_currentY++, 74, "Done."); 1481 } 1482 return (res); 1510 1483 } 1511 1484 … … 1520 1493 * @bug Return value should be @c void. 1521 1494 */ 1522 int open_and_list_dir(char*dir, char*sth, FILE*fout, time_t time_of_last_full_backup) 1523 { 1524 DIR *dip; 1525 struct dirent *dit; 1526 struct stat statbuf; 1527 char new[MAX_STR_LEN]; 1528 char *tmp; 1529 char *sth_B; 1530 static int percentage=0; 1531 char *ith_B; 1532 char *skip_these; 1533 char *new_with_spaces; 1534 static char *name_of_evalcall_form; 1535 int i; 1536 static int depth=0; 1537 char *p; 1538 static int counter=0; 1539 static int uberctr=0; 1540 static char *find_skeleton_marker; 1541 static long skeleton_lino=0; 1542 static time_t last_time=0; 1543 time_t this_time; 1544 1545 malloc_string(tmp); 1546 malloc_string(sth_B); 1547 malloc_string(ith_B); 1548 malloc_string(new_with_spaces); 1549 p = strrchr(dir, '/'); 1550 if (p) 1551 { 1552 if (!strcmp(p, "/.") || !strcmp(p, "/..")) 1553 { 1554 return(0); 1555 } 1556 } 1557 1558 if (!depth) 1559 { 1560 malloc_string(name_of_evalcall_form); 1561 malloc_string(find_skeleton_marker); 1495 int open_and_list_dir(char *dir, char *sth, FILE * fout, 1496 time_t time_of_last_full_backup) 1497 { 1498 DIR *dip; 1499 struct dirent *dit; 1500 struct stat statbuf; 1501 char new[MAX_STR_LEN]; 1502 char *tmp; 1503 char *sth_B; 1504 static int percentage = 0; 1505 char *ith_B; 1506 char *skip_these; 1507 char *new_with_spaces; 1508 static char *name_of_evalcall_form; 1509 int i; 1510 static int depth = 0; 1511 char *p; 1512 static int counter = 0; 1513 static int uberctr = 0; 1514 static char *find_skeleton_marker; 1515 static long skeleton_lino = 0; 1516 static time_t last_time = 0; 1517 time_t this_time; 1518 1519 malloc_string(tmp); 1520 malloc_string(sth_B); 1521 malloc_string(ith_B); 1522 malloc_string(new_with_spaces); 1523 p = strrchr(dir, '/'); 1524 if (p) { 1525 if (!strcmp(p, "/.") || !strcmp(p, "/..")) { 1526 return (0); 1527 } 1528 } 1529 1530 if (!depth) { 1531 malloc_string(name_of_evalcall_form); 1532 malloc_string(find_skeleton_marker); 1562 1533 #if linux 1563 // 2.6 has /sys as a proc-type thing -- must be excluded 1564 sprintf(tmp, "find %s -maxdepth %d -path /proc -prune -o -path /tmp -prune -o -path /sys -prune -o -path /dev/shm -prune -o -path /media/floppy -prune -o -type d -a -print > %s 2> /dev/null", dir, MAX_SKEL_DEPTH, g_skeleton_filelist); 1534 // 2.6 has /sys as a proc-type thing -- must be excluded 1535 sprintf(tmp, 1536 "find %s -maxdepth %d -path /proc -prune -o -path /tmp -prune -o -path /sys -prune -o -path /dev/shm -prune -o -path /media/floppy -prune -o -type d -a -print > %s 2> /dev/null", 1537 dir, MAX_SKEL_DEPTH, g_skeleton_filelist); 1565 1538 #else 1566 // On BSD, for example, /sys is the kernel sources -- don't exclude 1567 sprintf(tmp, "find %s -maxdepth %d -path /proc -prune -o -path /tmp -prune -o -type d -a -print > %s 2> /dev/null", dir, MAX_SKEL_DEPTH, g_skeleton_filelist); 1539 // On BSD, for example, /sys is the kernel sources -- don't exclude 1540 sprintf(tmp, 1541 "find %s -maxdepth %d -path /proc -prune -o -path /tmp -prune -o -type d -a -print > %s 2> /dev/null", 1542 dir, MAX_SKEL_DEPTH, g_skeleton_filelist); 1568 1543 #endif 1569 system(tmp); 1570 sprintf(tmp, "wc -l %s | awk '{print $1;}'", g_skeleton_filelist); 1571 g_skeleton_entries = 1 + atol(call_program_and_get_last_line_of_output(tmp)); 1572 sprintf(name_of_evalcall_form, "Making catalog of %s", dir); 1573 open_evalcall_form (name_of_evalcall_form); 1574 find_skeleton_marker[0] = '\0'; 1575 skeleton_lino=1; 1576 log_msg(5, "entries = %ld", g_skeleton_entries); 1577 percentage=0; 1578 } 1579 else if (depth<=MAX_SKEL_DEPTH) // update evalcall form if appropriate 1580 { 1581 sprintf(find_skeleton_marker, "fgrep -v \"%s\" %s > %s.new 2> /dev/null", dir, g_skeleton_filelist, g_skeleton_filelist); 1582 // log_msg(0, "fsm = %s", find_skeleton_marker); 1583 if (!system(find_skeleton_marker)) 1584 { 1585 percentage = (int)(skeleton_lino*100/g_skeleton_entries); 1586 skeleton_lino++; 1587 // log_msg(5, "Found %s", dir); 1588 // log_msg(2, "Incrementing skeleton_lino; now %ld/%ld (%d%%)", skeleton_lino, g_skeleton_entries, percentage); 1589 sprintf(find_skeleton_marker, "mv -f %s.new %s", g_skeleton_filelist, g_skeleton_filelist); 1590 // log_msg(6, "fsm = %s", find_skeleton_marker); 1591 run_program_and_log_output(find_skeleton_marker, 8); 1592 time(&this_time); 1593 if (this_time != last_time) 1594 { 1595 last_time = this_time; 1544 system(tmp); 1545 sprintf(tmp, "wc -l %s | awk '{print $1;}'", g_skeleton_filelist); 1546 g_skeleton_entries = 1547 1 + atol(call_program_and_get_last_line_of_output(tmp)); 1548 sprintf(name_of_evalcall_form, "Making catalog of %s", dir); 1549 open_evalcall_form(name_of_evalcall_form); 1550 find_skeleton_marker[0] = '\0'; 1551 skeleton_lino = 1; 1552 log_msg(5, "entries = %ld", g_skeleton_entries); 1553 percentage = 0; 1554 } else if (depth <= MAX_SKEL_DEPTH) // update evalcall form if appropriate 1555 { 1556 sprintf(find_skeleton_marker, 1557 "fgrep -v \"%s\" %s > %s.new 2> /dev/null", dir, 1558 g_skeleton_filelist, g_skeleton_filelist); 1559 // log_msg(0, "fsm = %s", find_skeleton_marker); 1560 if (!system(find_skeleton_marker)) { 1561 percentage = (int) (skeleton_lino * 100 / g_skeleton_entries); 1562 skeleton_lino++; 1563 // log_msg(5, "Found %s", dir); 1564 // log_msg(2, "Incrementing skeleton_lino; now %ld/%ld (%d%%)", skeleton_lino, g_skeleton_entries, percentage); 1565 sprintf(find_skeleton_marker, "mv -f %s.new %s", 1566 g_skeleton_filelist, g_skeleton_filelist); 1567 // log_msg(6, "fsm = %s", find_skeleton_marker); 1568 run_program_and_log_output(find_skeleton_marker, 8); 1569 time(&this_time); 1570 if (this_time != last_time) { 1571 last_time = this_time; 1596 1572 #ifndef _XWIN 1597 if (!g_text_mode) 1598 { 1599 sprintf(tmp, "Reading %-68s", dir); 1600 newtDrawRootText (0, g_noof_rows - 3, tmp); 1601 } 1573 if (!g_text_mode) { 1574 sprintf(tmp, "Reading %-68s", dir); 1575 newtDrawRootText(0, g_noof_rows - 3, tmp); 1576 } 1602 1577 #endif 1603 1604 }1605 1606 1607 1608 1578 update_evalcall_form(percentage); 1579 } 1580 } 1581 } 1582 1583 depth++; 1609 1584 1610 1585 // log_msg(0, "Cataloguing %s", dir); 1611 if (sth[0]==' ') { skip_these = sth; } 1612 else 1613 { 1614 skip_these = sth_B; 1615 sprintf(skip_these, " %s ", sth); 1616 } 1617 sprintf(new_with_spaces, " %s ", dir); 1618 if ((dip = opendir(dir)) == NULL) 1619 { 1620 log_OS_error("opendir"); 1621 } 1622 else if (strstr(skip_these, new_with_spaces)) 1623 { 1624 fprintf(fout, "%s\n", dir); // if excluded dir then print dir ONLY 1625 } 1626 else 1627 { 1628 fprintf(fout, "%s\n", dir); 1629 while ((dit = readdir(dip)) != NULL) 1630 { 1631 i++; 1632 strcpy(new, dir); 1633 if (strcmp(dir, "/")) { strcat(new, "/"); } 1634 strcat(new, dit->d_name); 1635 new_with_spaces[0] = ' '; 1636 strcpy(new_with_spaces+1, new); 1637 strcat(new_with_spaces, " "); 1638 if (strstr(skip_these, new_with_spaces)) 1639 { 1640 fprintf(fout, "%s\n", new); 1641 } 1642 else 1643 { 1644 if (!lstat(new, &statbuf)) 1645 { 1646 if (!S_ISLNK(statbuf.st_mode) && S_ISDIR(statbuf.st_mode)) { 1647 open_and_list_dir(new, skip_these, fout, time_of_last_full_backup); 1648 } 1649 else { 1650 if (time_of_last_full_backup==0 || time_of_last_full_backup<statbuf.st_ctime) 1651 { 1652 fprintf(fout, "%s\n", new); 1653 if ((counter++)>128) 1654 { 1655 counter=0; 1656 uberctr++; 1657 sprintf(tmp, " %c ", special_dot_char(uberctr)); 1586 if (sth[0] == ' ') { 1587 skip_these = sth; 1588 } else { 1589 skip_these = sth_B; 1590 sprintf(skip_these, " %s ", sth); 1591 } 1592 sprintf(new_with_spaces, " %s ", dir); 1593 if ((dip = opendir(dir)) == NULL) { 1594 log_OS_error("opendir"); 1595 } else if (strstr(skip_these, new_with_spaces)) { 1596 fprintf(fout, "%s\n", dir); // if excluded dir then print dir ONLY 1597 } else { 1598 fprintf(fout, "%s\n", dir); 1599 while ((dit = readdir(dip)) != NULL) { 1600 i++; 1601 strcpy(new, dir); 1602 if (strcmp(dir, "/")) { 1603 strcat(new, "/"); 1604 } 1605 strcat(new, dit->d_name); 1606 new_with_spaces[0] = ' '; 1607 strcpy(new_with_spaces + 1, new); 1608 strcat(new_with_spaces, " "); 1609 if (strstr(skip_these, new_with_spaces)) { 1610 fprintf(fout, "%s\n", new); 1611 } else { 1612 if (!lstat(new, &statbuf)) { 1613 if (!S_ISLNK(statbuf.st_mode) 1614 && S_ISDIR(statbuf.st_mode)) { 1615 open_and_list_dir(new, skip_these, fout, 1616 time_of_last_full_backup); 1617 } else { 1618 if (time_of_last_full_backup == 0 1619 || time_of_last_full_backup < 1620 statbuf.st_ctime) { 1621 fprintf(fout, "%s\n", new); 1622 if ((counter++) > 128) { 1623 counter = 0; 1624 uberctr++; 1625 sprintf(tmp, " %c ", 1626 special_dot_char(uberctr)); 1658 1627 #ifndef _XWIN 1659 if (!g_text_mode) { 1660 newtDrawRootText (77, g_noof_rows - 3, tmp); 1661 newtRefresh(); 1662 } 1628 if (!g_text_mode) { 1629 newtDrawRootText(77, g_noof_rows - 3, 1630 tmp); 1631 newtRefresh(); 1632 } 1663 1633 #endif 1664 } 1665 } 1666 } 1667 } 1668 } 1669 } 1670 } 1671 if (dip) 1672 { 1673 if (closedir(dip) == -1) 1674 { 1675 log_OS_error("closedir"); 1676 } 1677 } 1678 depth--; 1679 if (!depth) 1680 { 1681 close_evalcall_form (); 1682 paranoid_free (name_of_evalcall_form); 1683 paranoid_free(find_skeleton_marker); 1684 unlink(g_skeleton_filelist); 1685 log_msg(5, "g_skeleton_entries = %ld", g_skeleton_entries); 1686 } 1687 paranoid_free(tmp); 1688 paranoid_free(sth_B); 1689 paranoid_free(ith_B); 1690 paranoid_free(new_with_spaces); 1691 return(0); 1634 } 1635 } 1636 } 1637 } 1638 } 1639 } 1640 } 1641 if (dip) { 1642 if (closedir(dip) == -1) { 1643 log_OS_error("closedir"); 1644 } 1645 } 1646 depth--; 1647 if (!depth) { 1648 close_evalcall_form(); 1649 paranoid_free(name_of_evalcall_form); 1650 paranoid_free(find_skeleton_marker); 1651 unlink(g_skeleton_filelist); 1652 log_msg(5, "g_skeleton_entries = %ld", g_skeleton_entries); 1653 } 1654 paranoid_free(tmp); 1655 paranoid_free(sth_B); 1656 paranoid_free(ith_B); 1657 paranoid_free(new_with_spaces); 1658 return (0); 1692 1659 } 1693 1660 … … 1702 1669 * @note The returned string points to static data that will be overwritten with each call. 1703 1670 */ 1704 char *next_entry(char*incoming) 1705 { 1706 static char sz_res[MAX_STR_LEN]; 1707 char *p; 1708 bool in_quotes=FALSE; 1709 1710 strcpy(sz_res, incoming); 1711 p = sz_res; 1712 while((*p!=' ' || in_quotes) && *p!='\0') 1713 { 1714 if (*p=='\"') { in_quotes = !in_quotes; } 1715 p++; 1716 } 1717 *p = '\0'; 1718 return(sz_res); 1671 char *next_entry(char *incoming) 1672 { 1673 static char sz_res[MAX_STR_LEN]; 1674 char *p; 1675 bool in_quotes = FALSE; 1676 1677 strcpy(sz_res, incoming); 1678 p = sz_res; 1679 while ((*p != ' ' || in_quotes) && *p != '\0') { 1680 if (*p == '\"') { 1681 in_quotes = !in_quotes; 1682 } 1683 p++; 1684 } 1685 *p = '\0'; 1686 return (sz_res); 1719 1687 } 1720 1688 … … 1734 1702 * @bug Return value is meaningless. 1735 1703 */ 1736 int mondo_makefilelist(char*logfile, char*tmpdir, char*scratchdir, 1737 char*include_paths, char*excp, int differential, char *userdef_filelist) 1704 int mondo_makefilelist(char *logfile, char *tmpdir, char *scratchdir, 1705 char *include_paths, char *excp, int differential, 1706 char *userdef_filelist) 1738 1707 { 1739 1708 char sz_datefile_wildcard[] = "/var/cache/mondo-archive/difflevel.%d"; … … 1742 1711 char *sz_filelist, *exclude_paths, *tmp; 1743 1712 int i; 1744 FILE *fout;1713 FILE *fout; 1745 1714 char *command; 1746 time_t time_of_last_full_backup=0;1715 time_t time_of_last_full_backup = 0; 1747 1716 struct stat statbuf; 1748 1717 1749 malloc_string(command); 1750 malloc_string(tmp); 1751 malloc_string(sz_filelist); 1752 malloc_string(g_skeleton_filelist); 1753 if (!(exclude_paths = malloc(1000))) { fatal_error("Cannot malloc exclude_paths"); } 1754 log_msg(3, "Trying to write test string to exclude_paths"); 1755 strcpy(exclude_paths, "/blah /froo"); 1756 log_msg(3, "...Success!"); 1757 sprintf(sz_datefile, sz_datefile_wildcard, 0); 1758 if (!include_paths && !userdef_filelist) 1759 { fatal_error("Please supply either include_paths or userdef_filelist"); } 1760 1718 malloc_string(command); 1719 malloc_string(tmp); 1720 malloc_string(sz_filelist); 1721 malloc_string(g_skeleton_filelist); 1722 if (!(exclude_paths = malloc(1000))) { 1723 fatal_error("Cannot malloc exclude_paths"); 1724 } 1725 log_msg(3, "Trying to write test string to exclude_paths"); 1726 strcpy(exclude_paths, "/blah /froo"); 1727 log_msg(3, "...Success!"); 1728 sprintf(sz_datefile, sz_datefile_wildcard, 0); 1729 if (!include_paths && !userdef_filelist) { 1730 fatal_error 1731 ("Please supply either include_paths or userdef_filelist"); 1732 } 1761 1733 // make hole for filelist 1762 sprintf(command, "mkdir -p %s/archives", scratchdir); 1763 paranoid_system(command); 1764 sprintf(sz_filelist, "%s/tmpfs/filelist.full", tmpdir); 1765 make_hole_for_file(sz_filelist); 1766 1767 if (differential==0) 1768 { 1769 // restore last good datefile if it exists 1770 sprintf(command, "cp -f %s.aborted %s", sz_datefile, sz_datefile); 1771 run_program_and_log_output(command, 3); 1772 // backup last known good datefile just in case :) 1773 if (does_file_exist(sz_datefile)) 1774 { 1775 sprintf(command, "mv -f %s %s.aborted", sz_datefile, sz_datefile); 1776 paranoid_system(command); 1777 } 1778 make_hole_for_file(sz_datefile); 1779 write_one_liner_data_file(sz_datefile, call_program_and_get_last_line_of_output("date +%s")); 1780 } 1781 else if (lstat(sz_datefile, &statbuf)) 1782 { 1783 log_msg(2, "Warning - unable to find date of previous backup. Full backup instead."); 1784 differential = 0; 1785 time_of_last_full_backup = 0; 1786 } 1787 else 1788 { 1789 time_of_last_full_backup = statbuf.st_mtime; 1790 log_msg(2, "Differential backup. Yay."); 1791 } 1734 sprintf(command, "mkdir -p %s/archives", scratchdir); 1735 paranoid_system(command); 1736 sprintf(sz_filelist, "%s/tmpfs/filelist.full", tmpdir); 1737 make_hole_for_file(sz_filelist); 1738 1739 if (differential == 0) { 1740 // restore last good datefile if it exists 1741 sprintf(command, "cp -f %s.aborted %s", sz_datefile, sz_datefile); 1742 run_program_and_log_output(command, 3); 1743 // backup last known good datefile just in case :) 1744 if (does_file_exist(sz_datefile)) { 1745 sprintf(command, "mv -f %s %s.aborted", sz_datefile, 1746 sz_datefile); 1747 paranoid_system(command); 1748 } 1749 make_hole_for_file(sz_datefile); 1750 write_one_liner_data_file(sz_datefile, 1751 call_program_and_get_last_line_of_output 1752 ("date +%s")); 1753 } else if (lstat(sz_datefile, &statbuf)) { 1754 log_msg(2, 1755 "Warning - unable to find date of previous backup. Full backup instead."); 1756 differential = 0; 1757 time_of_last_full_backup = 0; 1758 } else { 1759 time_of_last_full_backup = statbuf.st_mtime; 1760 log_msg(2, "Differential backup. Yay."); 1761 } 1792 1762 1793 1763 // use user-specified filelist (if specified) 1794 if (userdef_filelist) 1795 { 1796 log_msg(1, "Using the user-specified filelist - %s - instead of calculating one", userdef_filelist); 1797 sprintf(command, "cp -f %s %s", userdef_filelist, sz_filelist); 1798 if (run_program_and_log_output(command, 3)) 1799 { fatal_error("Failed to copy user-specified filelist"); } 1800 } 1801 else 1802 { 1803 log_msg(2, "include_paths = '%s'", include_paths); 1804 log_msg(1, "Calculating filelist"); 1805 sprintf(exclude_paths, " %s %s %s %s %s %s . .. \ 1806 "MNT_CDROM" "MNT_FLOPPY" /media/cdrom /media/cdrecorder \ 1807 /proc /sys /tmp /root/images/mondo /root/images/mindi ", 1808 excp, 1809 call_program_and_get_last_line_of_output("locate /win386.swp 2> /dev/null"), 1810 call_program_and_get_last_line_of_output("locate /hiberfil.sys 2> /dev/null"), 1811 call_program_and_get_last_line_of_output("locate /pagefile.sys 2> /dev/null"), 1812 (tmpdir[0]=='/' && tmpdir[1]=='/')?(tmpdir+1):tmpdir, 1813 (scratchdir[0]=='/' && scratchdir[1]=='/')?(scratchdir+1):scratchdir 1814 ); 1815 1816 log_msg(2, "Excluding paths = '%s'", exclude_paths); 1817 log_msg(2, "Generating skeleton filelist so that we can track our progress"); 1818 sprintf(g_skeleton_filelist, "%s/tmpfs/skeleton.txt", tmpdir); 1819 make_hole_for_file(g_skeleton_filelist); 1820 log_msg(4, "g_skeleton_entries = %ld", g_skeleton_entries); 1821 log_msg(2, "Opening out filelist to %s", sz_filelist); 1822 if (!(fout = fopen(sz_filelist, "w"))) { fatal_error("Cannot openout to sz_filelist"); } 1823 i = 0; 1824 if (strlen(include_paths)==0) 1825 { 1826 log_msg(1, "Including only '/' in %s", sz_filelist); 1827 open_and_list_dir("/", exclude_paths, fout, time_of_last_full_backup); 1828 } 1829 else 1830 { 1831 p = include_paths; 1832 while(*p) 1833 { 1834 q = next_entry(p); 1835 log_msg(1, "Including %s in filelist %s", q, sz_filelist); 1836 open_and_list_dir(q, exclude_paths, fout, time_of_last_full_backup); 1837 p += strlen(q); 1838 while(*p==' ') { p++; } 1764 if (userdef_filelist) { 1765 log_msg(1, 1766 "Using the user-specified filelist - %s - instead of calculating one", 1767 userdef_filelist); 1768 sprintf(command, "cp -f %s %s", userdef_filelist, sz_filelist); 1769 if (run_program_and_log_output(command, 3)) { 1770 fatal_error("Failed to copy user-specified filelist"); 1771 } 1772 } else { 1773 log_msg(2, "include_paths = '%s'", include_paths); 1774 log_msg(1, "Calculating filelist"); 1775 sprintf(exclude_paths, " %s %s %s %s %s %s . .. \ 1776 " MNT_CDROM " " MNT_FLOPPY " /media/cdrom /media/cdrecorder \ 1777 /proc /sys /tmp /root/images/mondo /root/images/mindi ", excp, call_program_and_get_last_line_of_output("locate /win386.swp 2> /dev/null"), call_program_and_get_last_line_of_output("locate /hiberfil.sys 2> /dev/null"), call_program_and_get_last_line_of_output("locate /pagefile.sys 2> /dev/null"), (tmpdir[0] == '/' && tmpdir[1] == '/') ? (tmpdir + 1) : tmpdir, (scratchdir[0] == '/' && scratchdir[1] == '/') ? (scratchdir + 1) : scratchdir); 1778 1779 log_msg(2, "Excluding paths = '%s'", exclude_paths); 1780 log_msg(2, 1781 "Generating skeleton filelist so that we can track our progress"); 1782 sprintf(g_skeleton_filelist, "%s/tmpfs/skeleton.txt", tmpdir); 1783 make_hole_for_file(g_skeleton_filelist); 1784 log_msg(4, "g_skeleton_entries = %ld", g_skeleton_entries); 1785 log_msg(2, "Opening out filelist to %s", sz_filelist); 1786 if (!(fout = fopen(sz_filelist, "w"))) { 1787 fatal_error("Cannot openout to sz_filelist"); 1788 } 1789 i = 0; 1790 if (strlen(include_paths) == 0) { 1791 log_msg(1, "Including only '/' in %s", sz_filelist); 1792 open_and_list_dir("/", exclude_paths, fout, 1793 time_of_last_full_backup); 1794 } else { 1795 p = include_paths; 1796 while (*p) { 1797 q = next_entry(p); 1798 log_msg(1, "Including %s in filelist %s", q, sz_filelist); 1799 open_and_list_dir(q, exclude_paths, fout, 1800 time_of_last_full_backup); 1801 p += strlen(q); 1802 while (*p == ' ') { 1803 p++; 1804 } 1839 1805 } 1840 1806 } 1841 paranoid_fclose(fout);1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 return(0);1807 paranoid_fclose(fout); 1808 } 1809 log_msg(2, "Copying new filelist to scratchdir"); 1810 sprintf(command, "mkdir -p %s/archives", scratchdir); 1811 paranoid_system(command); 1812 sprintf(command, "cp -f %s %s/archives/", sz_filelist, scratchdir); 1813 paranoid_system(command); 1814 sprintf(command, "mv -f %s %s", sz_filelist, tmpdir); 1815 paranoid_system(command); 1816 log_msg(2, "Freeing variables"); 1817 paranoid_free(sz_filelist); 1818 paranoid_free(command); 1819 paranoid_free(exclude_paths); 1820 paranoid_free(tmp); 1821 paranoid_free(g_skeleton_filelist); 1822 log_msg(2, "Exiting"); 1823 return (0); 1858 1824 } 1859 1825 … … 1868 1834 * it was not found. 1869 1835 */ 1870 struct s_node *find_string_at_node (struct s_node *startnode, char *string_to_find) 1871 { 1872 /*@ int *********************************************************/ 1873 int noof_chars; 1874 static int depth=0; 1875 static char original_string[MAX_STR_LEN]; 1876 1877 /*@ sturctures **************************************************/ 1878 struct s_node *node; 1879 1880 /*@ char *******************************************************/ 1881 char char_to_find; 1882 1883 /*@ bools *******************************************************/ 1884 1885 if (!depth) { strcpy(original_string, string_to_find); } 1886 1887 assert(startnode!=NULL); 1888 assert(string_to_find!=NULL); 1889 1890 noof_chars = strlen (string_to_find) + 1; /* we include the '\0' */ 1891 1892 log_msg(7, "starting --- str=%s", string_to_find); 1836 struct s_node *find_string_at_node(struct s_node *startnode, 1837 char *string_to_find) 1838 { 1839 /*@ int ******************************************************** */ 1840 int noof_chars; 1841 static int depth = 0; 1842 static char original_string[MAX_STR_LEN]; 1843 1844 /*@ sturctures ************************************************* */ 1845 struct s_node *node; 1846 1847 /*@ char ****************************************************** */ 1848 char char_to_find; 1849 1850 /*@ bools ****************************************************** */ 1851 1852 if (!depth) { 1853 strcpy(original_string, string_to_find); 1854 } 1855 1856 assert(startnode != NULL); 1857 assert(string_to_find != NULL); 1858 1859 noof_chars = strlen(string_to_find) + 1; /* we include the '\0' */ 1860 1861 log_msg(7, "starting --- str=%s", string_to_find); 1893 1862 1894 1863 /* walk across tree if necessary */ 1895 1896 1897 if (node->right != NULL && node->ch < char_to_find) 1898 { 1899 log_msg(7, "depth=%d --- going RIGHT ... %c-->%c", depth,char_to_find, node->ch, (node->right)->ch);1900 return (find_string_at_node(node->right, string_to_find));1901 1864 node = startnode; 1865 char_to_find = string_to_find[0]; 1866 if (node->right != NULL && node->ch < char_to_find) { 1867 log_msg(7, "depth=%d --- going RIGHT ... %c-->%c", depth, 1868 char_to_find, node->ch, (node->right)->ch); 1869 return (find_string_at_node(node->right, string_to_find)); 1870 } 1902 1871 1903 1872 /* walk down tree if appropriate */ 1904 if (node->down != NULL && node->ch == char_to_find) 1905 { 1906 log_msg(7, "depth=%d char=%c --- going DOWN", depth, char_to_find); 1907 depth++; 1908 node = find_string_at_node (node->down, string_to_find + 1); 1909 depth--; 1910 return (node); 1911 } 1912 1913 if (char_to_find == '\0' && node->ch =='\0') 1914 { 1915 log_msg(7, "%s is in tree", original_string); 1916 return(node); 1917 } 1918 else 1919 { 1920 log_msg(7, "%s is NOT in tree", original_string); 1921 return(NULL); 1922 } 1873 if (node->down != NULL && node->ch == char_to_find) { 1874 log_msg(7, "depth=%d char=%c --- going DOWN", depth, char_to_find); 1875 depth++; 1876 node = find_string_at_node(node->down, string_to_find + 1); 1877 depth--; 1878 return (node); 1879 } 1880 1881 if (char_to_find == '\0' && node->ch == '\0') { 1882 log_msg(7, "%s is in tree", original_string); 1883 return (node); 1884 } else { 1885 log_msg(7, "%s is NOT in tree", original_string); 1886 return (NULL); 1887 } 1923 1888 } 1924 1889 … … 1933 1898 * @return The number of matches found. 1934 1899 */ 1935 long save_filelist_entries_in_common( 1936 char*needles_list_fname,1937 struct s_node *filelist,1938 char*matches_list_fname,bool use_star)1939 { 1940 int retval=0;1941 1942 FILE*fin;1943 FILE*fout;1944 1945 1946 size_t len = 0;// Scrub's patch doesn't work without that1900 long save_filelist_entries_in_common(char *needles_list_fname, 1901 struct s_node *filelist, 1902 char *matches_list_fname, 1903 bool use_star) 1904 { 1905 int retval = 0; 1906 struct s_node *found_node; 1907 FILE *fin; 1908 FILE *fout; 1909 char *fname; 1910 char *tmp; 1911 size_t len = 0; // Scrub's patch doesn't work without that 1947 1912 1948 1913 // log_msg(1, "use_star = %s", (use_star)?"TRUE":"FALSE"); 1949 malloc_string(fname); 1950 malloc_string(tmp); 1951 log_msg(5, "starting"); 1952 log_msg(5, "needles_list_fname = %s", needles_list_fname); 1953 log_msg(5, "matches_list_fname = %s", matches_list_fname); 1954 if (!(fin = fopen(needles_list_fname, "r"))) { fatal_error("Cannot openin needles_list_fname"); } 1955 if (!(fout= fopen(matches_list_fname, "w"))) { fatal_error("Cannot openout matches_list_fname"); } 1956 while(!feof(fin)) 1957 { 1914 malloc_string(fname); 1915 malloc_string(tmp); 1916 log_msg(5, "starting"); 1917 log_msg(5, "needles_list_fname = %s", needles_list_fname); 1918 log_msg(5, "matches_list_fname = %s", matches_list_fname); 1919 if (!(fin = fopen(needles_list_fname, "r"))) { 1920 fatal_error("Cannot openin needles_list_fname"); 1921 } 1922 if (!(fout = fopen(matches_list_fname, "w"))) { 1923 fatal_error("Cannot openout matches_list_fname"); 1924 } 1925 while (!feof(fin)) { 1958 1926 // fscanf(fin, "%s\n", fname); 1959 len = MAX_STR_LEN-1;1960 getline(& fname, & len, fin);// patch by Scrub1961 if (!use_star) 1962 1963 if (fname[0]=='/')1964 { strcpy(tmp, fname); }1965 else1966 {1967 tmp[0]='/';1968 strcpy(tmp+1, fname);1969 1970 strcpy(fname, tmp);1971 } 1972 while (strlen(fname)>0 && fname[strlen(fname)-1]<32) { fname[strlen(fname)-1] = '\0';}1927 len = MAX_STR_LEN - 1; 1928 getline(&fname, &len, fin); // patch by Scrub 1929 if (!use_star) { 1930 if (fname[0] == '/') { 1931 strcpy(tmp, fname); 1932 } else { 1933 tmp[0] = '/'; 1934 strcpy(tmp + 1, fname); 1935 } 1936 strcpy(fname, tmp); 1937 } 1938 while (strlen(fname) > 0 && fname[strlen(fname) - 1] < 32) { 1939 fname[strlen(fname) - 1] = '\0'; 1940 } 1973 1941 1974 1942 /* … … 1977 1945 sprintf(temporary_string, "echo \"Looking for '%s'\" >> /tmp/looking.txt", fname); 1978 1946 system(temporary_string); 1979 */ 1980 1981 log_msg(5, "Looking for '%s'", fname); 1982 found_node = find_string_at_node(filelist, fname); 1983 if (found_node) 1984 { 1985 if (found_node->selected) 1986 { 1947 */ 1948 1949 log_msg(5, "Looking for '%s'", fname); 1950 found_node = find_string_at_node(filelist, fname); 1951 if (found_node) { 1952 if (found_node->selected) { 1987 1953 // if (use_star) 1988 if (fname[0]=='/') 1989 { 1990 strcpy(tmp, fname+1); 1991 strcpy(fname, tmp); 1992 } 1993 log_msg(5, "Found '%s'", fname); 1994 turn_wildcard_chars_into_literal_chars(tmp, fname); 1995 fprintf(fout, "%s\n", tmp); 1996 retval++; 1997 } 1998 } 1999 } 2000 paranoid_fclose(fout); 2001 paranoid_fclose(fin); 2002 paranoid_free(fname); 2003 paranoid_free(tmp); 2004 return(retval); 1954 if (fname[0] == '/') { 1955 strcpy(tmp, fname + 1); 1956 strcpy(fname, tmp); 1957 } 1958 log_msg(5, "Found '%s'", fname); 1959 turn_wildcard_chars_into_literal_chars(tmp, fname); 1960 fprintf(fout, "%s\n", tmp); 1961 retval++; 1962 } 1963 } 1964 } 1965 paranoid_fclose(fout); 1966 paranoid_fclose(fin); 1967 paranoid_free(fname); 1968 paranoid_free(tmp); 1969 return (retval); 2005 1970 } 2006 1971 … … 2018 1983 * @return 0 for success, nonzero for failure. 2019 1984 */ 2020 int add_list_of_files_to_filelist(struct s_node *filelist, char*list_of_files_fname, bool flag_em) 2021 { 2022 FILE*fin; 2023 char*tmp; 2024 struct s_node *nod; 2025 2026 malloc_string(tmp); 2027 log_msg(3, "Adding %s to filelist", list_of_files_fname); 2028 if (!(fin=fopen(list_of_files_fname,"r"))) { iamhere(list_of_files_fname); return(1); } 2029 for (fgets (tmp, MAX_STR_LEN, fin); !feof(fin); 2030 fgets (tmp, MAX_STR_LEN, fin)) 2031 { 2032 if (!tmp[0]) { continue; } 2033 if ((tmp[strlen(tmp)-1]==13 || tmp[strlen(tmp)-1]==10) && strlen(tmp)>0) 2034 { tmp[strlen(tmp)-1] = '\0'; } 2035 log_msg(2, "tmp = '%s'", tmp); 2036 if (!tmp[0]) { continue; } 2037 if ((nod = find_string_at_node (filelist, tmp))) 2038 { 2039 log_msg(5, "Found '%s' in filelist already. Cool.", tmp); 2040 } 2041 else 2042 { 2043 add_string_at_node (filelist, tmp); 2044 nod = find_string_at_node (filelist, tmp); 2045 } 2046 2047 if (nod && flag_em) 2048 { 2049 toggle_path_selection(filelist, tmp, TRUE); 2050 log_msg (5, "Flagged '%s'", tmp); 2051 } 2052 } 2053 paranoid_fclose(fin); 2054 paranoid_free(tmp); 2055 return(0); 1985 int add_list_of_files_to_filelist(struct s_node *filelist, 1986 char *list_of_files_fname, bool flag_em) 1987 { 1988 FILE *fin; 1989 char *tmp; 1990 struct s_node *nod; 1991 1992 malloc_string(tmp); 1993 log_msg(3, "Adding %s to filelist", list_of_files_fname); 1994 if (!(fin = fopen(list_of_files_fname, "r"))) { 1995 iamhere(list_of_files_fname); 1996 return (1); 1997 } 1998 for (fgets(tmp, MAX_STR_LEN, fin); !feof(fin); 1999 fgets(tmp, MAX_STR_LEN, fin)) { 2000 if (!tmp[0]) { 2001 continue; 2002 } 2003 if ((tmp[strlen(tmp) - 1] == 13 || tmp[strlen(tmp) - 1] == 10) 2004 && strlen(tmp) > 0) { 2005 tmp[strlen(tmp) - 1] = '\0'; 2006 } 2007 log_msg(2, "tmp = '%s'", tmp); 2008 if (!tmp[0]) { 2009 continue; 2010 } 2011 if ((nod = find_string_at_node(filelist, tmp))) { 2012 log_msg(5, "Found '%s' in filelist already. Cool.", tmp); 2013 } else { 2014 add_string_at_node(filelist, tmp); 2015 nod = find_string_at_node(filelist, tmp); 2016 } 2017 2018 if (nod && flag_em) { 2019 toggle_path_selection(filelist, tmp, TRUE); 2020 log_msg(5, "Flagged '%s'", tmp); 2021 } 2022 } 2023 paranoid_fclose(fin); 2024 paranoid_free(tmp); 2025 return (0); 2056 2026 } 2057 2027
Note:
See TracChangeset
for help on using the changeset viewer.