source: branches/2.04_berlios/mondo/mondo/common/libmondo-filelist.c @ 2708

Last change on this file since 2708 was 2708, checked in by bruno, 8 years ago

r4184@localhost: bruno | 2011-01-27 15:52:51 +0100

  • Adds support for hpsa driver (new HP Smart Array driver)
  • Property svn:keywords set to Id
File size: 55.5 KB
Line 
1/* libmondo-filelist.c
2   $Id: libmondo-filelist.c 2708 2011-01-27 18:31:44Z bruno $
3
4- for subroutines which manipulate the filelist
5
6
701/11/2005
8- change  time_of_last_full_backup =  to st_mtime to allow manipulation of
9- /var/cache/mondo-archive/difflevel.0
10- Conor Daly <conor.daly@met.ie>
11
1210/01
13- don't try to sort non-existent file; return 0 instead
14
1509/14
16- dropped 'sort -o' (busybox doesn't support); use 'sort > ' instead
17
1808/02
19- add \ in front of [, ], ? or * when generating filelist subset
20
2107/27
22- sort filelists after creating them
23
2407/14
25- disabled ACL, xattr stuff; moved it to libmondo-archive.c
26- max sane size for a file is now 32MB
27
2807/10
29- added ACL and xattr support for afio users
30
3107/05
32- exclude /dev/shm from backup (Roberto Alsina)
33
3406/09
35- exclude /media/floppy or SuSE 9.1 freezes :(
36
3701/18/2004
38- exclude /sys as well as /proc
39
4010/18/2003
41- load_filelist() --- make sure you add the paths
42  leading to the file, e.g. if you add /usr/lib/thingy.so
43  then add /usr, /usr/lib first
44- rewritten load_filelist(), save_filelist(),
45- add_string_at_node(), find_string_at_node(),
46- save_filelist_entries_in_common()
47
4809/27
49- line 1269 had one too many '%s's
50
5109/26
52- fix newt* to be enclosed in #ifndef _XWIN
53- added superior progress display to mondo_makefilelist()
54
5509/18
56- call locate w/ 2> /dev/null at end of str
57
5809/16
59- replaced mondo-makefilelist with C subroutine
60
6106/06
62- fixed silly bug in load_filelist() which stopped
63  funny German filenames from being handled properly
64
6505/19
66- misc clean-up (Steve Hindle)
67
6805/04
69- added Herman Kuster's multi-level bkp patch
70
7104/26
72- maximum max_set_size_for_a_file = maxsetsizeK*2
73- maximum is also 32MB
74
7504/24
76- added lots of assert()'s and log_OS_error()'s
77
7804/22
79- added lots of asserts() and log_OS_errors()'s
80
8104/07
82- cleaned up code a bit
83
8404/04
85- max_sane_size_for_a_file = maxsetsizeK*2 (was *8)
86
8701/02/2003
88- tell mondo-makefilelist that it's a custom catalog (if it is)
89
9010/01 - 10/31/2002
91- don't make large .bz2 or .tbz files into biggiefiles
92- max_sane_size_for_a_file = maxsetsizeK*8, or 64MB
93  ...whichever is smaller
94
9508/01 - 08/31
96- if last filelist is <=2 bytes long then delete it
97- max_sane_size_for_a_file = maxsetsizeK
98  (was SLICESIZE*4 or something)
99- cleaned up some log_it() calls
100
10107/26
102- started
103*/
104
105/**
106 * @file
107 * Functions which create, chop, and edit the filelist.
108 */
109
110#include "my-stuff.h"
111#include "mondostructures.h"
112#include "lib-common-externs.h"
113#include "libmondo-filelist.h"
114#include "libmondo-string-EXT.h"
115#include "libmondo-files-EXT.h"
116#include "libmondo-fork-EXT.h"
117#include "libmondo-gui-EXT.h"
118#include "libmondo-tools-EXT.h"
119
120
121#include <time.h>
122#include <stdio.h>
123#include <sys/types.h>
124#include <sys/stat.h>
125#include <dirent.h>
126#include <errno.h>
127#include <stdio.h>
128
129
130/**
131 * The maximum depth of directories to put in the skeleton filelist.
132 * This is a balance between performance and a good progress indicator.
133 */
134#define MAX_SKEL_DEPTH 3
135
136
137extern ssize_t getline(char **lineptr, size_t *n, FILE *stream);
138
139
140int mondo_makefilelist(char*logfile, char*tmpdir, char*scratchdir,
141    char*include_paths, char*excp, int differential, char *userdef_filelist);
142
143
144/*@unused@*/
145//static char cvsid[] = "$Id: libmondo-filelist.c 2708 2011-01-27 18:31:44Z bruno $";
146
147/**
148 * Number of lines in the filelist last loaded.
149 * @warning This implies that two filesets cannot be loaded at once.
150 * @ingroup globalGroup
151 */
152long g_original_noof_lines_in_filelist = 0;
153
154/**
155 * Number of filesets in the current backup.
156 * @ingroup globalGroup
157 */
158long g_noof_sets=0;
159
160extern bool g_text_mode;
161extern newtComponent g_progressForm;
162extern int g_currentY;
163extern int g_noof_rows;
164
165
166
167
168
169/**
170 * @addtogroup filelistGroup
171 * @{
172 */
173/**
174 * Call chop_filelist() to chop the filelist into sets.
175 * @param bkpinfo The backup information structure. Fields used:
176 * - @c bkpinfo->image_devs
177 * - @c bkpinfo->optimal_set_size
178 * - @c bkpinfo->scratchdir
179 * - @c bkpinfo->tmpdir
180 * @see chop_filelist
181 */
182int
183call_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/*
210  if (find_home_of_exe("getfattr"))
211    { i++; log_to_screen ("NEW! Recording extended attributes."); }
212  if (find_home_of_exe("getfacl"))
213    { i++; log_to_screen ("NEW! Recording ACL information."); }
214  if (i)
215    { i=0; log_to_screen ("This will take more time. Please be patient."); }
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
255end_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
266int 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      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}
305
306
307
308/**
309 * Chop the filelist into sets.
310 * Each fileset is a list of files whose total (uncompressed) size is usually
311 * about X KB. Files bigger than 8X KB are placed in a "biggielist"; they will
312 * be sliced and compressed separately from the regular files.
313 *
314 * @param filelist The big filelist (filelist.full) to chop up.
315 * @param outdir The directory to place the files (filelist.N where N is
316 * an integer, biggielist.txt, and LAST-FILELIST-NUMBER) created
317 * @param maxsetsizeK Optimal size of a fileset (X above).
318 * @return number of errors encountered (0 for success).
319 */
320int
321chop_filelist (char *filelist, char *outdir, long maxsetsizeK)
322{
323/*@ long ****************************************/
324  long lino = 0;
325  long max_sane_size_for_a_file;
326  long curr_set_size;
327  long noof_lines;
328  long siz;
329
330    /*@ int *****************************************/
331  int i;
332  long curr_set_no;
333
334    /*@ buffers **************************************/
335  char *outfname;
336  char *biggie_fname;
337  char *incoming;
338  char *tmp;
339  char *acl_fname;
340  char *xattr_fname;
341
342    /*@ pointers ************************************/
343  FILE *fin;
344  FILE *fout;
345  FILE *fbig;
346
347    /*@ structures **********************************/
348  struct stat buf;
349  int err = 0;
350
351  malloc_string(outfname);
352  malloc_string(biggie_fname);
353  incoming = malloc(MAX_STR_LEN*2);
354  malloc_string(tmp);
355  malloc_string(acl_fname);
356  malloc_string(xattr_fname);
357 
358  assert_string_is_neither_NULL_nor_zerolength(filelist);
359  assert_string_is_neither_NULL_nor_zerolength(outdir);
360  assert( maxsetsizeK > 0);
361
362  max_sane_size_for_a_file = 32L*1024L;
363// max_sane_size_for_a_file = maxsetsizeK*2;
364//  if (max_sane_size_for_a_file > 32*1024)
365//    { 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)
410// && 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      unlink(outfname);
440      g_noof_sets --;
441    }
442  g_noof_sets = curr_set_no;
443  sort_file(outfname);
444  sort_file(biggie_fname);
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  log_msg(1, tmp);
458  close_evalcall_form ();
459  /* This is to work around an obscure bug in Newt; open a form, close it,
460     carry on... I don't know why it works but it works. If you don't do this
461     then update_progress_form() won't show the "time taken / time remaining"
462     line. The bug only crops up AFTER the call to chop_filelist(). Weird. */
463#ifndef _XWIN
464  if (!g_text_mode)
465    {
466      open_progress_form ("", "", "", "", 100);
467      newtPopHelpLine ();
468      newtFormDestroy (g_progressForm);
469      newtPopWindow ();
470    }
471#endif
472end_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}
481
482
483
484
485
486/**
487 * Free all the memory used by a filelist structure.
488 * Since this may take a long time for large filelists, a progress bar will be displayed.
489 * @param filelist The filelist to free.
490 */
491void
492free_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    {
528/*      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
543int 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
572int 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
616int 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    {
626//      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
636int 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    {
646//      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);
651}
652
653
654/*
655int set_acl_list(char*masklist, char*acl_fname)
656{
657  char*command;
658  int retval=0;
659 
660  if (length_of_file(acl_fname) <= 0) { return(0); }
661  log_msg(1, "FIXME - not using masklist"); 
662  malloc_string(command);
663  if (find_home_of_exe("setfacl"))
664    {
665      sprintf(command, "cat %s | gzip -dc | setfacl --restore - 2>> %s", acl_fname, MONDO_LOGFILE);
666      log_msg(1, "command = %s", command);
667      retval = system(command);
668    }
669  paranoid_free(command);
670  return(retval);
671}
672*/
673
674
675
676int 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
730//  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    {
736//      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     
754//      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     
767//      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//  printf("OK, loop is done\n");
786
787  unlink(masklist); 
788  paranoid_free(current_subset_file);
789  paranoid_free(current_master_file);
790  paranoid_free(syscall_pout);
791  paranoid_free(syscall_pin);
792  paranoid_free(masklist);
793  paranoid_free(incoming);
794  paranoid_free(command);
795  return(retval);
796} 
797
798
799int set_fattr_list(char*masklist, char*fattr_fname)
800{
801  return(set_EXAT_list(masklist, fattr_fname, "setfattr"));
802}
803
804
805
806int set_acl_list(char*masklist, char*acl_fname)
807{
808  return(set_EXAT_list(masklist, acl_fname, "setfacl"));
809}
810
811/*
812  if (find_home_of_exe("setfattr"))
813    {
814      sprintf(command, "cat %s | gzip -dc | setfattr --restore - 2>> %s", acl_fname, MONDO_LOGFILE);
815      log_msg(1, "command = %s", command);
816      retval = system(command);
817    }
818  paranoid_free(acl_subset_fname);
819  paranoid_free(syscall_pin);
820  paranoid_free(command);
821  return(retval);
822*/
823
824
825
826
827
828
829/**
830 * Get the number of the last fileset in the backup.
831 * @param bkpinfo The backup information structure. Only the @c bkpinfo->tmpdir field is used.
832 * @return The last filelist number.
833 * @note This function should only be called at restore-time.
834 */
835int
836get_last_filelist_number (struct s_bkpinfo *bkpinfo)
837{
838    /*@ buffers ******************************************************/
839  char val_sz[MAX_STR_LEN];
840  char cfg_fname[MAX_STR_LEN];
841/*  char tmp[MAX_STR_LEN]; remove stan benoit apr 2002 */
842
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);
858}
859
860
861/**
862 * Add a string at @p startnode.
863 * @param startnode The node to start at when searching for where to add the string.
864 * @param string_to_add The string to add.
865 * @return 0 for success, 1 for failure.
866 * @bug I don't understand this function. Would someone care to explain it?
867 */
868int
869add_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' */
897
898/* walk across tree if necessary */
899  node = startnode;
900  char_to_add = string_to_add[0];
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    }
906
907/* 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    }
922
923/* 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
953// 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);
972}
973
974
975
976
977/**
978 * Load a filelist into a <tt>struct s_node</tt>.
979 * When you are done with the filelist, call free_filelist().
980 * @param filelist_fname The file to load the filelist from.
981 * @return A filelist tree structure.
982 */
983struct s_node *
984load_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'; }
1039//      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      strcpy(tmp, fname);
1048      tmp[pos_in_fname] = '\0';
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      percentage = (int) (lino * 100 / lines_in_filelist);
1056      update_evalcall_form (percentage);
1057    }
1058    }
1059  paranoid_pclose(pin);
1060  close_evalcall_form ();
1061  log_it ("Finished loading filelist");
1062  return (filelist);
1063}
1064
1065
1066/**
1067 * Log a list of files in @p node.
1068 * @param node The toplevel node to use.
1069 */
1070void
1071show_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;
1102}
1103
1104
1105
1106
1107/**
1108 * Reset the filelist to the state it was when it was loaded. This does not
1109 * touch the file on disk.
1110 * @param filelist The filelist tree structure.
1111 */
1112void
1113reload_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);
1119}
1120
1121
1122
1123/**
1124 * Save a filelist tree structure to disk.
1125 * @param filelist The filelist tree structure to save.
1126 * @param outfname Where to save it.
1127 */
1128void
1129save_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    }
1188}
1189
1190
1191
1192/**
1193 * Toggle all root dirs on.
1194 * @param filelist The filelist tree structure to operate on.
1195 * @bug I don't understand this function. Would someone care to explain it?
1196 */
1197void
1198toggle_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    }
1240}
1241
1242
1243/**
1244 * Toggle the expandability of a path.
1245 * @param filelist The filelist tree to operate on.
1246 * @param pathname The path to toggle expandability of.
1247 * @param on_or_off Whether to toggle it on or off.
1248 * @bug I don't understand this function. Would someone care to explain it?
1249 */
1250void
1251toggle_path_expandability (struct s_node *filelist, char *pathname,
1252               bool on_or_off)
1253{
1254
1255    /*@ int *********************************************************/
1256  static int depth = 0;
1257  static int total_expanded;
1258  static int root_depth;
1259  int j;
1260    /*@ structures **************************************************/
1261  struct s_node *node;
1262
1263    /*@ buffers *****************************************************/
1264  static char current_filename[MAX_STR_LEN];
1265
1266/*  char tmp[MAX_STR_LEN+2]; */
1267
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;
1275//      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    {
1327//      log_it ("Finished toggling expandability");
1328    }
1329}
1330
1331/**
1332 * Toggle whether a path is selected.
1333 * @param filelist The filelist tree to operate on.
1334 * @param pathname The path to toggle selection of.
1335 * @param on_or_off Whether to toggle it on or off.
1336 * @bug I don't understand this function. Would someone care to explain it?
1337 */
1338void
1339toggle_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    }
1389}
1390
1391
1392/**
1393 * Toggle node selection of a filelist tree.
1394 * @param filelist The filelist tree to operate on.
1395 * @param on_or_off Whether to toggle selection on or off.
1396 * @bug I don't understand this function. Would someone care to explain it?
1397 */
1398void
1399toggle_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    }
1421}
1422
1423
1424
1425
1426
1427
1428
1429/**
1430 * The pathname to the skeleton filelist, used to give better progress reporting for mondo_makefilelist().
1431 */
1432char *g_skeleton_filelist=NULL;
1433
1434/**
1435 * Number of entries in the skeleton filelist.
1436 */
1437long g_skeleton_entries=0;
1438
1439/**
1440 * Wrapper around mondo_makefilelist().
1441 * @param bkpinfo The backup information structure. Fields used:
1442 * - @c bkpinfo->differential
1443 * - @c bkpinfo->exclude_paths
1444 * - @c bkpinfo->include_paths
1445 * - @c bkpinfo->make_filelist
1446 * - @c bkpinfo->scratchdir
1447 * - @c bkpinfo->tmpdir
1448 * @return 0 for success, nonzero for failure.
1449 * @see mondo_makefilelist
1450 */
1451int
1452prepare_filelist (struct s_bkpinfo *bkpinfo)
1453{
1454
1455    /*@ int *****************************************************/
1456  int res = 0;
1457// patch by Herman Kuster
1458// end patch
1459  int *p_res = &res;
1460
1461    /*@ buffers *************************************************/
1462//  char command[MAX_STR_LEN*2];
1463
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);
1510}
1511
1512
1513/**
1514 * Recursively list all files in @p dir newer than @p time_of_last_full_backup to @p fout.
1515 * @param dir The directory to list to @p fout.
1516 * @param sth The directories to skip (exclude).
1517 * @param fout The file to write everything to.
1518 * @param time_of_last_full_backup Only backup files newer than this (0 to disable).
1519 * @return 0, always.
1520 * @bug Return value should be @c void.
1521 */
1522int 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);
1562#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);
1565#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);
1568#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;
1596#ifndef _XWIN
1597                  if (!g_text_mode)
1598                {
1599              sprintf(tmp, "Reading %-68s", dir);
1600                  newtDrawRootText (0, g_noof_rows - 3, tmp);
1601            }
1602#endif
1603          update_evalcall_form(percentage);
1604        }
1605        }
1606        }
1607
1608  depth++;
1609
1610//  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));
1658#ifndef _XWIN
1659              if (!g_text_mode) {
1660                  newtDrawRootText (77, g_noof_rows - 3, tmp);
1661                  newtRefresh();
1662              }
1663#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);
1692}
1693
1694
1695
1696/**
1697 * Get the next entry in the space-separated list in @p incoming.
1698 * So if @p incoming was '"one and two" three four', we would
1699 * return "one and two".
1700 * @param incoming The list to get the next entry from.
1701 * @return The first item in the list (respecting double quotes).
1702 * @note The returned string points to static data that will be overwritten with each call.
1703 */
1704char *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);
1719}
1720
1721
1722
1723/**
1724 * Create the filelist for the backup. It will be stored in [scratchdir]/archives/filelist.full.
1725 * @param logfile Unused.
1726 * @param tmpdir The tmpdir of the backup.
1727 * @param scratchdir The scratchdir of the backup.
1728 * @param include_paths The paths to back up, or NULL if you're using a user-defined filelist.
1729 * @param excp The paths to NOT back up.
1730 * @param differential The differential level (currently only 0 and 1 are supported).
1731 * @param userdef_filelist The user-defined filelist, or NULL if you're using @p include_paths.
1732 * @return 0, always.
1733 * @bug @p logfile is unused.
1734 * @bug Return value is meaningless.
1735 */
1736int mondo_makefilelist(char*logfile, char*tmpdir, char*scratchdir,
1737    char*include_paths, char*excp, int differential, char *userdef_filelist)
1738{
1739    char sz_datefile_wildcard[] = "/var/cache/mondo-archive/difflevel.%d";
1740    char *p, *q;
1741    char sz_datefile[80];
1742    char *sz_filelist, *exclude_paths, *tmp;
1743    int i;
1744    FILE*fout;
1745    char *command;
1746        time_t time_of_last_full_backup=0;
1747    struct stat statbuf;
1748
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
1761// 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    }
1792
1793// 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++; }
1839            }
1840        }
1841    paranoid_fclose(fout);
1842    }
1843  log_msg(2, "Copying new filelist to scratchdir");
1844  sprintf(command, "mkdir -p %s/archives", scratchdir);
1845  paranoid_system(command);
1846  sprintf(command, "cp -f %s %s/archives/", sz_filelist, scratchdir);
1847  paranoid_system(command);
1848  sprintf(command, "mv -f %s %s", sz_filelist, tmpdir);
1849  paranoid_system(command);
1850  log_msg(2, "Freeing variables");
1851  paranoid_free(sz_filelist);
1852  paranoid_free(command);
1853  paranoid_free(exclude_paths);
1854  paranoid_free(tmp);
1855  paranoid_free(g_skeleton_filelist);
1856  log_msg(2, "Exiting");
1857  return(0);
1858}
1859
1860
1861
1862
1863/**
1864 * Locate the string @p string_to_find in the tree rooted at @p startnode.
1865 * @param startnode The node containing the root of the directory tree.
1866 * @param string_to_find The string to look for at @p startnode.
1867 * @return The node containing the last element of @p string_to_find, or NULL if
1868 * it was not found.
1869 */
1870struct 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);
1893
1894/* walk across tree if necessary */
1895  node = startnode;
1896  char_to_find = string_to_find[0];
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    }
1902
1903/* 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    }
1923}
1924
1925
1926
1927/**
1928 * Write all entries in @p needles_list_fname which are also in
1929 * @p filelist to @p matches_list_fname.
1930 * @param needles_list_fname A file containing strings to look for, 1 per line.
1931 * @param filelist The node for the root of the directory structure to search in.
1932 * @param matches_list_fname The filename where we should put the matches.
1933 * @return The number of matches found.
1934 */
1935long 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  struct s_node *found_node;
1942  FILE*fin;
1943  FILE*fout;
1944  char *fname;
1945  char *tmp;
1946  size_t len = 0; // Scrub's patch doesn't work without that
1947
1948//  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    {
1958//      fscanf(fin, "%s\n", fname);
1959      len = MAX_STR_LEN-1;
1960      getline(& fname, & len, fin); // patch by Scrub
1961      if (!use_star)
1962        {
1963      if (fname[0]=='/')
1964        { strcpy(tmp, fname); }
1965      else
1966        {
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'; }
1973
1974/*
1975      if (strlen(fname)>3 && fname[strlen(fname)-1]=='/') { fname[strlen(fname)-1] = '\0'; }
1976      if (strlen(fname)==0) { continue; }
1977      sprintf(temporary_string, "echo \"Looking for '%s'\" >> /tmp/looking.txt", fname);
1978      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        {
1987//              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);
2005}
2006
2007
2008
2009
2010
2011
2012/**
2013 * Add all files listed in @p list_of_files_fname to the directory structure rooted at
2014 * @p filelist.
2015 * @param filelist The top node of the directory structure to add the files to.
2016 * @param list_of_files_fname The file containing the files to add, 1 per line.
2017 * @param flag_em If TRUE, then flag the added files for restoration.
2018 * @return 0 for success, nonzero for failure.
2019 */
2020int 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);
2056}
2057
2058/* @} - end of filelistGroup */
Note: See TracBrowser for help on using the repository browser.