Changeset 49 in MondoRescue

Timestamp:

Oct 7, 2005, 7:03:07 PM (20 years ago)

Author:

bcornec

Message:

some bugs corrected (size_t, & for getline, ...) + indent

Location:

trunk/mondo/mondo/common

Files:

• libmondo-archive.c (modified) (6 diffs)
• libmondo-filelist.c (modified) (28 diffs)
• libmondo-mountlist.c (modified) (1 diff)
• libmondo-string.c (modified) (2 diffs)
• libmondo-tools.c (modified) (35 diffs)
• libmondo-verify.c (modified) (2 diffs)

trunk/mondo/mondo/common/libmondo-archive.c

@@ -995 +995 @@
     asprintf(&archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
              bkpinfo->tmpdir, 0L);
-    archiving_set_no = 0;
+    archiving_set_no = 0L;
     while (does_file_exist(archiving_filelist_fname)) {
         paranoid_free(archiving_filelist_fname);
@@ -1981 +1981 @@
     int retval = 0;
     int res = 0;
-    int n = 0;
+    size_t n = 0;
     pid_t pid;
     FILE *ftmp = NULL;
@@ -2015 +2015 @@
         return (1);
     }
-    for (getline(&bigfile_fname, (size_t) & n, fin); !feof(fin);
-         getline(&bigfile_fname, (size_t) & n, fin),
+    for (getline(&bigfile_fname, &n, fin); !feof(fin);
+         getline(&bigfile_fname, &n, fin),
          biggie_file_number++) {
         use_partimagehack = FALSE;
@@ -3046 +3046 @@
 
     /*@ buffers ************************************************** */
-    char *tmp, *checksum_line, *command;
+    char *tmp, *checksum_line = NULL, *command;
     char *tempblock;
     char *curr_slice_fname_uncompressed;
@@ -3075 +3075 @@
     int retval = 0;
     int res = 0;
-    int n = 0;
+    size_t n = 0;
 
     /*@ structures ************************************************** */
@@ -3115 +3115 @@
         }
         paranoid_free(command);
-        (void) getline(&checksum_line, (size_t) & n, fin);
+        (void) getline(&checksum_line, &n, fin);
         pclose(fin);
     }

trunk/mondo/mondo/common/libmondo-filelist.c

@@ -1 @@
-/* libmondo-filelist.c
-   $Id: libmondo-filelist.c,v 1.6 2004/06/10 15:29:12 hugo Exp $
-
-- for subroutines which manipulate the filelist
-
-
-01/11/2005
-- change  time_of_last_full_backup =  to st_mtime to allow manipulation of 
-- /var/cache/mondo-archive/difflevel.0 
-- Conor Daly <conor.daly@met.ie>
-
-10/01
-- don't try to sort non-existent file; return 0 instead
-
-09/14
-- dropped 'sort -o' (busybox doesn't support); use 'sort > ' instead
-
-08/02
-- add \ in front of [, ], ? or * when generating filelist subset
-
-07/27
-- sort filelists after creating them
-
-07/14
-- disabled ACL, xattr stuff; moved it to libmondo-archive.c
-- max sane size for a file is now 32MB
-
-07/10
-- added ACL and xattr support for afio users
-
-07/05
-- exclude /dev/shm from backup (Roberto Alsina)
-
-06/09
-- exclude /media/floppy or SuSE 9.1 freezes :(
-
-01/18/2004
-- exclude /sys as well as /proc
-
-10/18/2003
-- load_filelist() --- make sure you add the paths
-  leading to the file, e.g. if you add /usr/lib/thingy.so
-  then add /usr, /usr/lib first
-- rewritten load_filelist(), save_filelist(),
-- add_string_at_node(), find_string_at_node(),
-- save_filelist_entries_in_common()
-
-09/27
-- line 1269 had one too many '%s's
-
-09/26
-- fix newt* to be enclosed in #ifndef _XWIN
-- added superior progress display to mondo_makefilelist()
-
-09/18
-- call locate w/ 2> /dev/null at end of str
-
-09/16
-- replaced mondo-makefilelist with C subroutine
-
-06/06
-- fixed silly bug in load_filelist() which stopped
-  funny German filenames from being handled properly
-
-05/19
-- misc clean-up (Steve Hindle)
-
-05/04
-- added Herman Kuster's multi-level bkp patch
-
-04/26
-- maximum max_set_size_for_a_file = maxsetsizeK*2
-- maximum is also 32MB
-
-04/24
-- added lots of assert()'s and log_OS_error()'s
-
-04/22
-- added lots of asserts() and log_OS_errors()'s
-
-04/07
-- cleaned up code a bit
-
-04/04
-- max_sane_size_for_a_file = maxsetsizeK*2 (was *8)
-
-01/02/2003
-- tell mondo-makefilelist that it's a custom catalog (if it is)
-
-10/01 - 10/31/2002
-- don't make large .bz2 or .tbz files into biggiefiles
-- max_sane_size_for_a_file = maxsetsizeK*8, or 64MB
-  ...whichever is smaller
-
-08/01 - 08/31
-- if last filelist is <=2 bytes long then delete it
-- max_sane_size_for_a_file = maxsetsizeK
-  (was SLICESIZE*4 or something)
-- cleaned up some log_it() calls
-
-07/26
-- started
+/* $Id$
+
+for subroutines which manipulate the filelist
+
 */
 
@@ -135 +37 @@
 
 
-extern ssize_t getline(char **lineptr, size_t *n, FILE *stream);
-
-
-int mondo_makefilelist(char*logfile, char*tmpdir, char*scratchdir,
-    char*include_paths, char*excp, int differential, char *userdef_filelist);
+int mondo_makefilelist(char *logfile, char *tmpdir, char *scratchdir,
+                       char *include_paths, char *excp, int differential,
+                       char *userdef_filelist);
 
 
 /*@unused@*/
-//static char cvsid[] = "$Id: libmondo-filelist.c,v 1.6 2004/06/10 15:29:12 hugo Exp $";
+//static char cvsid[] = "$Id$";
 
 /**
@@ -156 +56 @@
  * @ingroup globalGroup
  */
-long g_noof_sets=0;
+long g_noof_sets = 0;
 
 extern bool g_text_mode;
@@ -180 +80 @@
  * @see chop_filelist
  */
-int
-call_filelist_chopper (struct s_bkpinfo *bkpinfo)
-{
-    /*@ buffers ************************/
-  char *dev;
-  char *filelist;
-  char *tempfile;
-  char *cksumlist;
-  char *tmp;
-  long noof_sets;
-
-    /*@ pointers ***********************/
-  char *ptr;
-  FILE *fout;
-
-    /*@ int ****************************/
-  int i, retval=0;
-
-  malloc_string(dev);
-  malloc_string(filelist);
-  malloc_string(tempfile);
-  malloc_string(cksumlist);
-  malloc_string(tmp);
-  mvaddstr_and_log_it (g_currentY, 0, "Dividing filelist into sets");
-
-  log_to_screen ("Dividing filelist into sets. Please wait.");
-  i=0;
+int call_filelist_chopper(struct s_bkpinfo *bkpinfo)
+{
+    /*@ buffers *********************** */
+    char *dev;
+    char *filelist;
+    char *tempfile;
+    char *cksumlist;
+    char *tmp;
+    long noof_sets;
+
+    /*@ pointers ********************** */
+    char *ptr;
+    FILE *fout;
+
+    /*@ int *************************** */
+    int i, retval = 0;
+
+    malloc_string(dev);
+    malloc_string(filelist);
+    malloc_string(tempfile);
+    malloc_string(cksumlist);
+    malloc_string(tmp);
+    mvaddstr_and_log_it(g_currentY, 0, "Dividing filelist into sets");
+
+    log_to_screen("Dividing filelist into sets. Please wait.");
+    i = 0;
 /*
   if (find_home_of_exe("getfattr")) 
@@ -215 +114 @@
     { i=0; log_to_screen ("This will take more time. Please be patient."); }
 */
-  sprintf (filelist, "%s/archives/filelist.full", bkpinfo->scratchdir);
-  sprintf (cksumlist, "%s/cklist.full", bkpinfo->tmpdir);
-  if (!does_file_exist(filelist)) { log_it("filelist %s not found", filelist); fatal_error("call_filelist_chopper() -- filelist not found!"); }
-
-  noof_sets = chop_filelist (filelist, bkpinfo->tmpdir, bkpinfo->optimal_set_size);
-  estimate_noof_media_required (bkpinfo, noof_sets); // for cosmetic purposes
-
-  sprintf (tempfile, "%s/biggielist.txt", bkpinfo->tmpdir);
-  if (!(fout = fopen (tempfile, "a")))
-    {
-      log_OS_error("Cannot append to biggielist");
-      retval++;
-      goto end_of_func;
-    }
-  log_it (bkpinfo->image_devs);
-
-  ptr = bkpinfo->image_devs;
-
-  while (ptr && *ptr)
-    {
-      strcpy (dev, ptr);
-      log_it ("Examining imagedev %s", dev);
-      for (i = 0; i < (int) strlen (dev) && dev[i] != ' '; i++);
-      dev[i] = '\0';
-      if (!strlen (dev))
-    {
-      continue;
-    }
-      fprintf (fout, "%s\n", dev);
-      log_it ("Adding '%s' to biggielist", dev);
-      if ((ptr = strchr (ptr, ' ')))
-    {
-      ptr++;
-    }
-    }
-  paranoid_fclose(fout);
-  mvaddstr_and_log_it (g_currentY++, 74, "Done.");
-
-end_of_func:
-  paranoid_free(filelist);
-  paranoid_free(tempfile);
-  paranoid_free(cksumlist);
-  paranoid_free(dev);
-  paranoid_free(tmp);
-  return(retval);
-}
-
-
-
-int sort_file(char*orig_fname)
-{
-  char *tmp_fname;
-  char *command;
-  int retval=0;
-
-  log_msg(1, "Sorting file %s", orig_fname);
-  malloc_string(tmp_fname);
-  malloc_string(command);
-  sprintf(tmp_fname, "/tmp/sort.%d.%d.%d", (int)(random()%32768), (int)(random()%32768), (int)(random()%32768));
-  
-  if (!does_file_exist(orig_fname))
-    { return(0); } // no sense in trying to sort an empty file
-
-  sprintf(command, "sort %s > %s 2>> %s", orig_fname, tmp_fname, MONDO_LOGFILE);
-  retval = system(command);
-  if (retval)
-    {
-      log_msg(2, "Failed to sort %s - oh dear", orig_fname);
-    }
-  else
-    {
-      log_msg(2, "Sorted %s --> %s OK. Copying it back to %s now", orig_fname, tmp_fname, orig_fname);
-      sprintf(command, "mv -f %s %s", tmp_fname, orig_fname);
-      retval += run_program_and_log_output(command, 2);
-      if (retval)
-        {
-      log_msg(2, "Failed to copy %s back to %s - oh dear", tmp_fname, orig_fname);
-    }
-      else
-        {
-      log_msg(2, "%s was sorted OK.", orig_fname);
-    }
-    }
-  paranoid_free(tmp_fname);
-  paranoid_free(command);
-  log_msg(1, "Finished sorting file %s", orig_fname);
-  return(retval);
+    sprintf(filelist, "%s/archives/filelist.full", bkpinfo->scratchdir);
+    sprintf(cksumlist, "%s/cklist.full", bkpinfo->tmpdir);
+    if (!does_file_exist(filelist)) {
+        log_it("filelist %s not found", filelist);
+        fatal_error("call_filelist_chopper() -- filelist not found!");
+    }
+
+    noof_sets =
+        chop_filelist(filelist, bkpinfo->tmpdir,
+                      bkpinfo->optimal_set_size);
+    estimate_noof_media_required(bkpinfo, noof_sets);   // for cosmetic purposes
+
+    sprintf(tempfile, "%s/biggielist.txt", bkpinfo->tmpdir);
+    if (!(fout = fopen(tempfile, "a"))) {
+        log_OS_error("Cannot append to biggielist");
+        retval++;
+        goto end_of_func;
+    }
+    log_it(bkpinfo->image_devs);
+
+    ptr = bkpinfo->image_devs;
+
+    while (ptr && *ptr) {
+        strcpy(dev, ptr);
+        log_it("Examining imagedev %s", dev);
+        for (i = 0; i < (int) strlen(dev) && dev[i] != ' '; i++);
+        dev[i] = '\0';
+        if (!strlen(dev)) {
+            continue;
+        }
+        fprintf(fout, "%s\n", dev);
+        log_it("Adding '%s' to biggielist", dev);
+        if ((ptr = strchr(ptr, ' '))) {
+            ptr++;
+        }
+    }
+    paranoid_fclose(fout);
+    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+
+  end_of_func:
+    paranoid_free(filelist);
+    paranoid_free(tempfile);
+    paranoid_free(cksumlist);
+    paranoid_free(dev);
+    paranoid_free(tmp);
+    return (retval);
+}
+
+
+
+int sort_file(char *orig_fname)
+{
+    char *tmp_fname;
+    char *command;
+    int retval = 0;
+
+    log_msg(1, "Sorting file %s", orig_fname);
+    malloc_string(tmp_fname);
+    malloc_string(command);
+    sprintf(tmp_fname, "/tmp/sort.%d.%d.%d", (int) (random() % 32768),
+            (int) (random() % 32768), (int) (random() % 32768));
+
+    if (!does_file_exist(orig_fname)) {
+        return (0);
+    }                           // no sense in trying to sort an empty file
+
+    sprintf(command, "sort %s > %s 2>> %s", orig_fname, tmp_fname,
+            MONDO_LOGFILE);
+    retval = system(command);
+    if (retval) {
+        log_msg(2, "Failed to sort %s - oh dear", orig_fname);
+    } else {
+        log_msg(2, "Sorted %s --> %s OK. Copying it back to %s now",
+                orig_fname, tmp_fname, orig_fname);
+        sprintf(command, "mv -f %s %s", tmp_fname, orig_fname);
+        retval += run_program_and_log_output(command, 2);
+        if (retval) {
+            log_msg(2, "Failed to copy %s back to %s - oh dear", tmp_fname,
+                    orig_fname);
+        } else {
+            log_msg(2, "%s was sorted OK.", orig_fname);
+        }
+    }
+    paranoid_free(tmp_fname);
+    paranoid_free(command);
+    log_msg(1, "Finished sorting file %s", orig_fname);
+    return (retval);
 }
 
@@ -318 +217 @@
  * @return number of errors encountered (0 for success).
  */
-int
-chop_filelist (char *filelist, char *outdir, long maxsetsizeK)
+int chop_filelist(char *filelist, char *outdir, long maxsetsizeK)
 {
 /*@ long ****************************************/
-  long lino = 0;
-  long max_sane_size_for_a_file;
-  long curr_set_size;
-  long noof_lines;
-  long siz;
-
-    /*@ int *****************************************/
-  int i;
-  long curr_set_no;
-
-    /*@ buffers **************************************/
-  char *outfname;
-  char *biggie_fname;
-  char *incoming;
-  char *tmp;
-  char *acl_fname;
-  char *xattr_fname;
-
-    /*@ pointers ************************************/
-  FILE *fin;
-  FILE *fout;
-  FILE *fbig;
-
-    /*@ structures **********************************/
-  struct stat buf;
-  int err = 0;
-
-  malloc_string(outfname);
-  malloc_string(biggie_fname);
-  incoming = malloc(MAX_STR_LEN*2);
-  malloc_string(tmp);
-  malloc_string(acl_fname);
-  malloc_string(xattr_fname);
-  
-  assert_string_is_neither_NULL_nor_zerolength(filelist);
-  assert_string_is_neither_NULL_nor_zerolength(outdir);
-  assert( maxsetsizeK > 0);
-
-  max_sane_size_for_a_file = 32L*1024L;
+    long lino = 0;
+    long max_sane_size_for_a_file;
+    long curr_set_size;
+    long noof_lines;
+    long siz;
+
+    /*@ int **************************************** */
+    int i;
+    long curr_set_no;
+
+    /*@ buffers ************************************* */
+    char *outfname;
+    char *biggie_fname;
+    char *incoming;
+    char *tmp;
+    char *acl_fname;
+    char *xattr_fname;
+
+    /*@ pointers *********************************** */
+    FILE *fin;
+    FILE *fout;
+    FILE *fbig;
+
+    /*@ structures ********************************* */
+    struct stat buf;
+    int err = 0;
+
+    malloc_string(outfname);
+    malloc_string(biggie_fname);
+    incoming = malloc(MAX_STR_LEN * 2);
+    malloc_string(tmp);
+    malloc_string(acl_fname);
+    malloc_string(xattr_fname);
+
+    assert_string_is_neither_NULL_nor_zerolength(filelist);
+    assert_string_is_neither_NULL_nor_zerolength(outdir);
+    assert(maxsetsizeK > 0);
+
+    max_sane_size_for_a_file = 32L * 1024L;
 // max_sane_size_for_a_file = maxsetsizeK*2;
 //  if (max_sane_size_for_a_file > 32*1024)
 //    { max_sane_size_for_a_file = 32*1024; }
-  
-  log_it("filelist=%s;", filelist);
-  open_evalcall_form ("Dividing filelist into sets");
-  noof_lines = count_lines_in_file (filelist);
-  if (!(fin = fopen (filelist, "r"))) { log_OS_error("Cannot openin filelist"); return(0); }
-  curr_set_no = 0;
-  curr_set_size = 0;
-  sprintf (outfname, "%s/filelist.%ld", outdir, curr_set_no);
-  sprintf (biggie_fname, "%s/biggielist.txt", outdir);
-  log_it("outfname=%s; biggie_fname=%s", outfname, biggie_fname);
-  if (!(fbig = fopen (biggie_fname, "w"))) { log_OS_error("Cannot openout biggie_fname"); err++; goto end_of_func; }
-  if (!(fout = fopen (outfname, "w"))) { log_OS_error("Cannot openout outfname"); err++; goto end_of_func; }
-  (void) fgets (incoming, MAX_STR_LEN*2-1, fin);
-  while (!feof (fin))
-    {
-      lino++;
-      i = strlen (incoming) - 1;
-      if (i < 0)
-    {
-      i = 0;
-    }
-      if (i > MAX_STR_LEN-1)
-        {
-      incoming[MAX_STR_LEN-30] = '\0';
-      log_msg(1, "Warning - truncating file %s's name", incoming);
-      err++;
-    }
-      if (incoming[i] < 32)
-    {
-      incoming[i] = '\0';
-    }
-      if (!strncmp (incoming, "/dev/", 5))
-    {
-      siz = 1;
-    }
-      else if (lstat (incoming, &buf) != 0)
-    {
-      siz = 0;
-    }
-      else
-    {
-      siz = (long) (buf.st_size >> 10);
-    }
-      if (siz > max_sane_size_for_a_file)
+
+    log_it("filelist=%s;", filelist);
+    open_evalcall_form("Dividing filelist into sets");
+    noof_lines = count_lines_in_file(filelist);
+    if (!(fin = fopen(filelist, "r"))) {
+        log_OS_error("Cannot openin filelist");
+        return (0);
+    }
+    curr_set_no = 0;
+    curr_set_size = 0;
+    sprintf(outfname, "%s/filelist.%ld", outdir, curr_set_no);
+    sprintf(biggie_fname, "%s/biggielist.txt", outdir);
+    log_it("outfname=%s; biggie_fname=%s", outfname, biggie_fname);
+    if (!(fbig = fopen(biggie_fname, "w"))) {
+        log_OS_error("Cannot openout biggie_fname");
+        err++;
+        goto end_of_func;
+    }
+    if (!(fout = fopen(outfname, "w"))) {
+        log_OS_error("Cannot openout outfname");
+        err++;
+        goto end_of_func;
+    }
+    (void) fgets(incoming, MAX_STR_LEN * 2 - 1, fin);
+    while (!feof(fin)) {
+        lino++;
+        i = strlen(incoming) - 1;
+        if (i < 0) {
+            i = 0;
+        }
+        if (i > MAX_STR_LEN - 1) {
+            incoming[MAX_STR_LEN - 30] = '\0';
+            log_msg(1, "Warning - truncating file %s's name", incoming);
+            err++;
+        }
+        if (incoming[i] < 32) {
+            incoming[i] = '\0';
+        }
+        if (!strncmp(incoming, "/dev/", 5)) {
+            siz = 1;
+        } else if (lstat(incoming, &buf) != 0) {
+            siz = 0;
+        } else {
+            siz = (long) (buf.st_size >> 10);
+        }
+        if (siz > max_sane_size_for_a_file)
 // && strcmp(incoming+strlen(incoming)-4, ".bz2") && strcmp(incoming+strlen(incoming)-4, ".tbz"))
-    {
-      fprintf (fbig, "%s\n", incoming);
-    }
-      else
-    {
-      curr_set_size += siz;
-      fprintf (fout, "%s\n", incoming);
-      if (curr_set_size > maxsetsizeK)
-        {
-          paranoid_fclose(fout);
-          sort_file(outfname);
-          curr_set_no++;
-          curr_set_size = 0;
-          sprintf (outfname, "%s/filelist.%ld", outdir, curr_set_no);
-          if (!(fout = fopen (outfname, "w"))) { log_OS_error("Unable to openout outfname"); err++; goto end_of_func; }
-          sprintf (tmp, "Fileset #%ld chopped ", curr_set_no - 1);
-          update_evalcall_form ((int) (lino * 100 / noof_lines));
-          /*              if (!g_text_mode) {newtDrawRootText(0,22,tmp);newtRefresh();} else {log_it(tmp);} */
-        }
-    }
-      (void) fgets (incoming, MAX_STR_LEN*2-1, fin);
-    }
-  paranoid_fclose (fin);
-  paranoid_fclose (fout);
-  paranoid_fclose (fbig);
-
-  if (length_of_file(outfname) <= 2)
-    {
-      unlink(outfname);
-      g_noof_sets --;
-    }
-  g_noof_sets = curr_set_no;
-  sort_file(outfname);
-  sort_file(biggie_fname);
-  sprintf (outfname, "%s/LAST-FILELIST-NUMBER", outdir);
-  sprintf (tmp, "%ld", curr_set_no);
-  if (write_one_liner_data_file (outfname, tmp))
-      { log_OS_error("Unable to echo write one-liner to LAST-FILELIST-NUMBER"); err = 1;}
-  if (curr_set_no == 0)
-    {
-      sprintf (tmp, "Only one fileset. Fine.");
-    }
-  else
-    {
-      sprintf (tmp, "Filelist divided into %ld sets", curr_set_no + 1);
-    }
-  log_msg(1, tmp);
-  close_evalcall_form ();
-  /* This is to work around an obscure bug in Newt; open a form, close it,
-     carry on... I don't know why it works but it works. If you don't do this
-     then update_progress_form() won't show the "time taken / time remaining"
-     line. The bug only crops up AFTER the call to chop_filelist(). Weird. */
+        {
+            fprintf(fbig, "%s\n", incoming);
+        } else {
+            curr_set_size += siz;
+            fprintf(fout, "%s\n", incoming);
+            if (curr_set_size > maxsetsizeK) {
+                paranoid_fclose(fout);
+                sort_file(outfname);
+                curr_set_no++;
+                curr_set_size = 0;
+                sprintf(outfname, "%s/filelist.%ld", outdir, curr_set_no);
+                if (!(fout = fopen(outfname, "w"))) {
+                    log_OS_error("Unable to openout outfname");
+                    err++;
+                    goto end_of_func;
+                }
+                sprintf(tmp, "Fileset #%ld chopped ", curr_set_no - 1);
+                update_evalcall_form((int) (lino * 100 / noof_lines));
+                /*              if (!g_text_mode) {newtDrawRootText(0,22,tmp);newtRefresh();} else {log_it(tmp);} */
+            }
+        }
+        (void) fgets(incoming, MAX_STR_LEN * 2 - 1, fin);
+    }
+    paranoid_fclose(fin);
+    paranoid_fclose(fout);
+    paranoid_fclose(fbig);
+
+    if (length_of_file(outfname) <= 2) {
+        unlink(outfname);
+        g_noof_sets--;
+    }
+    g_noof_sets = curr_set_no;
+    sort_file(outfname);
+    sort_file(biggie_fname);
+    sprintf(outfname, "%s/LAST-FILELIST-NUMBER", outdir);
+    sprintf(tmp, "%ld", curr_set_no);
+    if (write_one_liner_data_file(outfname, tmp)) {
+        log_OS_error
+            ("Unable to echo write one-liner to LAST-FILELIST-NUMBER");
+        err = 1;
+    }
+    if (curr_set_no == 0) {
+        sprintf(tmp, "Only one fileset. Fine.");
+    } else {
+        sprintf(tmp, "Filelist divided into %ld sets", curr_set_no + 1);
+    }
+    log_msg(1, tmp);
+    close_evalcall_form();
+    /* This is to work around an obscure bug in Newt; open a form, close it,
+       carry on... I don't know why it works but it works. If you don't do this
+       then update_progress_form() won't show the "time taken / time remaining"
+       line. The bug only crops up AFTER the call to chop_filelist(). Weird. */
 #ifndef _XWIN
-  if (!g_text_mode)
-    {
-      open_progress_form ("", "", "", "", 100);
-      newtPopHelpLine ();
-      newtFormDestroy (g_progressForm);
-      newtPopWindow ();
-    }
+    if (!g_text_mode) {
+        open_progress_form("", "", "", "", 100);
+        newtPopHelpLine();
+        newtFormDestroy(g_progressForm);
+        newtPopWindow();
+    }
 #endif
-end_of_func:
-  paranoid_free(outfname);
-  paranoid_free(biggie_fname);
-  paranoid_free(incoming);
-  paranoid_free(tmp);
-  paranoid_free(acl_fname);
-  paranoid_free(xattr_fname);
-  return (err ? 0 : curr_set_no + 1);
+  end_of_func:
+    paranoid_free(outfname);
+    paranoid_free(biggie_fname);
+    paranoid_free(incoming);
+    paranoid_free(tmp);
+    paranoid_free(acl_fname);
+    paranoid_free(xattr_fname);
+    return (err ? 0 : curr_set_no + 1);
 }
 
@@ -489 +388 @@
  * @param filelist The filelist to free.
  */
-void
-free_filelist (struct s_node *filelist)
-{
-    /*@ int's ********************************************************/
-  static int depth = 0;
-  int percentage;
-
-    /*@ long's *******************************************************/
-  static long i = 0;
-
-    /*@ end vars *****************************************************/
-
-  assert(filelist!=NULL);
-  if (depth == 0)
-    {
-      open_evalcall_form ("Freeing memory");
-      log_to_screen ("Freeing memory formerly occupied by filelist");
-    }
-  depth++;
-
-  if (filelist->ch == '\0')
-    {
-      if (!(i++ % 1111))
-    {
-      percentage = (int) (i * 100 / g_original_noof_lines_in_filelist);
-      update_evalcall_form (percentage);
-
-    }
-    }
-
-  if (filelist->right)
-    {
-      free_filelist (filelist->right);
-      filelist->right = NULL;
-    }
-  if (filelist->down)
-    {
+void free_filelist(struct s_node *filelist)
+{
+    /*@ int's ******************************************************* */
+    static int depth = 0;
+    int percentage;
+
+    /*@ long's ****************************************************** */
+    static long i = 0;
+
+    /*@ end vars **************************************************** */
+
+    assert(filelist != NULL);
+    if (depth == 0) {
+        open_evalcall_form("Freeing memory");
+        log_to_screen("Freeing memory formerly occupied by filelist");
+    }
+    depth++;
+
+    if (filelist->ch == '\0') {
+        if (!(i++ % 1111)) {
+            percentage =
+                (int) (i * 100 / g_original_noof_lines_in_filelist);
+            update_evalcall_form(percentage);
+
+        }
+    }
+
+    if (filelist->right) {
+        free_filelist(filelist->right);
+        filelist->right = NULL;
+    }
+    if (filelist->down) {
 /*      if (!(i++ %39999)) { update_evalcall_form(0); } */
-      free_filelist (filelist->down);
-      filelist->down = NULL;
-    }
-  filelist->ch = '\0';
-  paranoid_free (filelist);
-  depth--;
-  if (depth == 0)
-    {
-      close_evalcall_form ();
-      log_it ("Finished freeing memory");
-    }
-}
-
-
-int call_exe_and_pipe_output_to_fd(char*syscall, FILE*pout)
-{
-  FILE *pattr;
-  char *tmp;
-      pattr = popen(syscall, "r");
-      if (!pattr)
-        { 
-      log_msg(1, "Failed to open fattr() %s", syscall); 
-      return(1);
-        }
-      if (feof(pattr))
-        {
-      log_msg(1, "Failed to call fattr() %s", syscall); 
-      paranoid_pclose(pattr); 
-      return(2);  
-    }
-      malloc_string(tmp);
-      for (fgets (tmp, MAX_STR_LEN, pattr); !feof (pattr);
-       fgets (tmp, MAX_STR_LEN, pattr))
-        {
-      fputs(tmp, pout);
-    }
-      paranoid_pclose(pattr);
-      paranoid_free(tmp);
-      return(0);
-}
-
-
-
-int gen_aux_list(char*filelist, char*syscall_sprintf, char*auxlist_fname)
-{
-  FILE*fin;
-  FILE*pout;
-  char*pout_command;
-  char*syscall;
-  char*file_to_analyze;
-  int i;
-  
-  if (!(fin=fopen(filelist, "r"))) 
-    {
-      log_msg(1, "Cannot openin filelist %s", filelist); 
-      return(1);
-    }
-  malloc_string(pout_command);
-  sprintf(pout_command, "gzip -c1 > %s", auxlist_fname);
-  if (!(pout=popen(pout_command, "w")))
-    { 
-      log_msg(1, "Cannot openout auxlist_fname %s", auxlist_fname); 
-      fclose(fin); 
-      paranoid_free(pout_command); 
-      return(4); 
-    }
-  malloc_string(syscall);
-  malloc_string(file_to_analyze);
-  for (fgets (file_to_analyze, MAX_STR_LEN, fin); !feof (fin);
-       fgets (file_to_analyze, MAX_STR_LEN, fin))
-    {
-      i = strlen(file_to_analyze);
-      if (i>0 && file_to_analyze[i-1]<32) { file_to_analyze[i-1]='\0'; }
-      log_msg(8, "Analyzing %s", file_to_analyze);
-      sprintf(syscall, syscall_sprintf, file_to_analyze);
-      strcat(syscall, " 2>> /dev/null"); // " MONDO_LOGFILE);
-      call_exe_and_pipe_output_to_fd(syscall, pout);
-    }
-  paranoid_fclose(fin);
-  paranoid_pclose(pout);
-  paranoid_free(file_to_analyze);
-  paranoid_free(syscall);
-  paranoid_free(pout_command);
-  return(0);
-}
-
-
-int get_acl_list(char*filelist, char*facl_fname)
-{
-  char*command;
-  int retval=0;
-  
-  malloc_string(command);
-  sprintf(command, "touch %s", facl_fname);
-  run_program_and_log_output(command, 8);
-  if (find_home_of_exe("getfacl"))
-    {
+        free_filelist(filelist->down);
+        filelist->down = NULL;
+    }
+    filelist->ch = '\0';
+    paranoid_free(filelist);
+    depth--;
+    if (depth == 0) {
+        close_evalcall_form();
+        log_it("Finished freeing memory");
+    }
+}
+
+
+int call_exe_and_pipe_output_to_fd(char *syscall, FILE * pout)
+{
+    FILE *pattr;
+    char *tmp;
+    pattr = popen(syscall, "r");
+    if (!pattr) {
+        log_msg(1, "Failed to open fattr() %s", syscall);
+        return (1);
+    }
+    if (feof(pattr)) {
+        log_msg(1, "Failed to call fattr() %s", syscall);
+        paranoid_pclose(pattr);
+        return (2);
+    }
+    malloc_string(tmp);
+    for (fgets(tmp, MAX_STR_LEN, pattr); !feof(pattr);
+         fgets(tmp, MAX_STR_LEN, pattr)) {
+        fputs(tmp, pout);
+    }
+    paranoid_pclose(pattr);
+    paranoid_free(tmp);
+    return (0);
+}
+
+
+
+int gen_aux_list(char *filelist, char *syscall_sprintf,
+                 char *auxlist_fname)
+{
+    FILE *fin;
+    FILE *pout;
+    char *pout_command;
+    char *syscall;
+    char *file_to_analyze;
+    int i;
+
+    if (!(fin = fopen(filelist, "r"))) {
+        log_msg(1, "Cannot openin filelist %s", filelist);
+        return (1);
+    }
+    malloc_string(pout_command);
+    sprintf(pout_command, "gzip -c1 > %s", auxlist_fname);
+    if (!(pout = popen(pout_command, "w"))) {
+        log_msg(1, "Cannot openout auxlist_fname %s", auxlist_fname);
+        fclose(fin);
+        paranoid_free(pout_command);
+        return (4);
+    }
+    malloc_string(syscall);
+    malloc_string(file_to_analyze);
+    for (fgets(file_to_analyze, MAX_STR_LEN, fin); !feof(fin);
+         fgets(file_to_analyze, MAX_STR_LEN, fin)) {
+        i = strlen(file_to_analyze);
+        if (i > 0 && file_to_analyze[i - 1] < 32) {
+            file_to_analyze[i - 1] = '\0';
+        }
+        log_msg(8, "Analyzing %s", file_to_analyze);
+        sprintf(syscall, syscall_sprintf, file_to_analyze);
+        strcat(syscall, " 2>> /dev/null");  // " MONDO_LOGFILE);
+        call_exe_and_pipe_output_to_fd(syscall, pout);
+    }
+    paranoid_fclose(fin);
+    paranoid_pclose(pout);
+    paranoid_free(file_to_analyze);
+    paranoid_free(syscall);
+    paranoid_free(pout_command);
+    return (0);
+}
+
+
+int get_acl_list(char *filelist, char *facl_fname)
+{
+    char *command;
+    int retval = 0;
+
+    malloc_string(command);
+    sprintf(command, "touch %s", facl_fname);
+    run_program_and_log_output(command, 8);
+    if (find_home_of_exe("getfacl")) {
 //      sort_file(filelist); // FIXME - filelist chopper sorts, so this isn't necessary
-      sprintf(command, "cat %s | getfacl --all-effective -P - 2>> %s | gzip -c1 > %s 2>> %s", filelist, MONDO_LOGFILE, facl_fname, MONDO_LOGFILE);
-      iamhere(command);
-      retval = system(command);
-    }
-  paranoid_free(command);
-  return(retval);
-}
-
-
-int get_fattr_list(char*filelist, char*fattr_fname)
-{
-  char *command;
-  int retval=0;
-  
-  malloc_string(command);
-  sprintf(command, "touch %s", fattr_fname);
-  run_program_and_log_output(command, 8);
-  if (find_home_of_exe("getfattr"))
-    {
+        sprintf(command,
+                "cat %s | getfacl --all-effective -P - 2>> %s | gzip -c1 > %s 2>> %s",
+                filelist, MONDO_LOGFILE, facl_fname, MONDO_LOGFILE);
+        iamhere(command);
+        retval = system(command);
+    }
+    paranoid_free(command);
+    return (retval);
+}
+
+
+int get_fattr_list(char *filelist, char *fattr_fname)
+{
+    char *command;
+    int retval = 0;
+
+    malloc_string(command);
+    sprintf(command, "touch %s", fattr_fname);
+    run_program_and_log_output(command, 8);
+    if (find_home_of_exe("getfattr")) {
 //      sort_file(filelist); // FIXME - filelist chopper sorts, so this isn't necessary
-      retval = gen_aux_list(filelist, "getfattr --en=hex -P -d \"%s\"", fattr_fname);
-    }
-  paranoid_free(command);
-  return(retval);
+        retval =
+            gen_aux_list(filelist, "getfattr --en=hex -P -d \"%s\"",
+                         fattr_fname);
+    }
+    paranoid_free(command);
+    return (retval);
 }
 
@@ -674 +566 @@
 
 
-int set_EXAT_list(char*orig_msklist, char*original_exat_fname, char*executable)
-{
-  const int my_depth=8;
-  char*command, *syscall_pin, *syscall_pout, *incoming;
-  char*current_subset_file, *current_master_file, *masklist;
-  int retval=0;
-  int i;
-  char*p,*q;
-  FILE*pin, *pout, *faclin;
-
-  malloc_string(command);
-  log_msg(1, "set_EXAT_list(%s, %s, %s)", orig_msklist, original_exat_fname, executable);  
-  if (!orig_msklist || !orig_msklist[0] || !does_file_exist(orig_msklist))
-    {
-      log_msg(1, "No masklist provided. I shall therefore set ALL attributes.");
-      sprintf(command, "cat %s | gzip -dc | %s --restore - 2>> %s", original_exat_fname, executable, MONDO_LOGFILE);
-      log_msg(1, "command = %s", command);
-      retval = system(command);
-      paranoid_free(command);
-      log_msg(1, "Returning w/ retval=%d", retval);
-      return(retval);
-    }
-  if (length_of_file(original_exat_fname) <= 0)
-    {
-      log_msg(1, "original_exat_fname %s is empty or missing, so no need to set EXAT list", original_exat_fname);
-      paranoid_free(command);
-      return(0); 
-    }
-  malloc_string(incoming);
-  malloc_string(masklist);
-  malloc_string(current_subset_file);
-  malloc_string(current_master_file);
-  malloc_string(syscall_pin);
-  malloc_string(syscall_pout);
-  sprintf(masklist, "/tmp/%d.%d.mask", (int)(random()%32768), (int)(random()%32768));
-  sprintf(command, "cp -f %s %s", orig_msklist, masklist);
-  run_program_and_log_output(command, 1);
-  sort_file(masklist);
-  current_subset_file[0] = current_master_file[0] = '\0';
-  sprintf(syscall_pin, "cat %s | gzip -dc", original_exat_fname);
-  sprintf(syscall_pout, "%s --restore - 2>> %s", executable, MONDO_LOGFILE);
-
-  log_msg(1, "syscall_pin = %s", syscall_pin);
-  log_msg(1, "syscall_pout = %s", syscall_pout);
-  pout = popen(syscall_pout, "w");
-  if (!pout)
-    { iamhere("Unable to openout to syscall_pout"); return(1); }
-  pin = popen(syscall_pin, "r");
-  if (!pin)
-    { pclose(pout); iamhere("Unable to openin from syscall"); return(1); }
-  faclin = fopen(masklist, "r");
-  if (!faclin)
-    { pclose(pin); pclose(pout); iamhere("Unable to openin masklist"); return(1); }
-
+int set_EXAT_list(char *orig_msklist, char *original_exat_fname,
+                  char *executable)
+{
+    const int my_depth = 8;
+    char *command, *syscall_pin, *syscall_pout, *incoming;
+    char *current_subset_file, *current_master_file, *masklist;
+    int retval = 0;
+    int i;
+    char *p, *q;
+    FILE *pin, *pout, *faclin;
+
+    malloc_string(command);
+    log_msg(1, "set_EXAT_list(%s, %s, %s)", orig_msklist,
+            original_exat_fname, executable);
+    if (!orig_msklist || !orig_msklist[0]
+        || !does_file_exist(orig_msklist)) {
+        log_msg(1,
+                "No masklist provided. I shall therefore set ALL attributes.");
+        sprintf(command, "cat %s | gzip -dc | %s --restore - 2>> %s",
+                original_exat_fname, executable, MONDO_LOGFILE);
+        log_msg(1, "command = %s", command);
+        retval = system(command);
+        paranoid_free(command);
+        log_msg(1, "Returning w/ retval=%d", retval);
+        return (retval);
+    }
+    if (length_of_file(original_exat_fname) <= 0) {
+        log_msg(1,
+                "original_exat_fname %s is empty or missing, so no need to set EXAT list",
+                original_exat_fname);
+        paranoid_free(command);
+        return (0);
+    }
+    malloc_string(incoming);
+    malloc_string(masklist);
+    malloc_string(current_subset_file);
+    malloc_string(current_master_file);
+    malloc_string(syscall_pin);
+    malloc_string(syscall_pout);
+    sprintf(masklist, "/tmp/%d.%d.mask", (int) (random() % 32768),
+            (int) (random() % 32768));
+    sprintf(command, "cp -f %s %s", orig_msklist, masklist);
+    run_program_and_log_output(command, 1);
+    sort_file(masklist);
+    current_subset_file[0] = current_master_file[0] = '\0';
+    sprintf(syscall_pin, "cat %s | gzip -dc", original_exat_fname);
+    sprintf(syscall_pout, "%s --restore - 2>> %s", executable,
+            MONDO_LOGFILE);
+
+    log_msg(1, "syscall_pin = %s", syscall_pin);
+    log_msg(1, "syscall_pout = %s", syscall_pout);
+    pout = popen(syscall_pout, "w");
+    if (!pout) {
+        iamhere("Unable to openout to syscall_pout");
+        return (1);
+    }
+    pin = popen(syscall_pin, "r");
+    if (!pin) {
+        pclose(pout);
+        iamhere("Unable to openin from syscall");
+        return (1);
+    }
+    faclin = fopen(masklist, "r");
+    if (!faclin) {
+        pclose(pin);
+        pclose(pout);
+        iamhere("Unable to openin masklist");
+        return (1);
+    }
 //  printf("Hi there. Starting the loop\n");
-  
-  fgets(current_subset_file, MAX_STR_LEN, faclin);
-  fgets(incoming, MAX_STR_LEN, pin);
-  while(!feof(pin) && !feof(faclin))
-    {
+
+    fgets(current_subset_file, MAX_STR_LEN, faclin);
+    fgets(incoming, MAX_STR_LEN, pin);
+    while (!feof(pin) && !feof(faclin)) {
 //      printf("incoming = %s", incoming);
-      
-      strcpy(current_master_file, incoming+8);
-      
-      p = current_subset_file;
-      if (*p=='/') {p++;}
-      i = strlen(p);
-      if (i>0 && p[i-1]<32) { p[i-1] = '\0'; }
-
-            
-      q = current_master_file;
-      if (*q=='/') {q++;}
-      i = strlen(q);
-      if (i>0 && q[i-1]<32) { q[i-1] = '\0'; }
-
-      i = strcmp(p,q);
-      log_msg(my_depth, "'%s' v '%s' --> %d\n", p, q, i);
-      
+
+        strcpy(current_master_file, incoming + 8);
+
+        p = current_subset_file;
+        if (*p == '/') {
+            p++;
+        }
+        i = strlen(p);
+        if (i > 0 && p[i - 1] < 32) {
+            p[i - 1] = '\0';
+        }
+
+
+        q = current_master_file;
+        if (*q == '/') {
+            q++;
+        }
+        i = strlen(q);
+        if (i > 0 && q[i - 1] < 32) {
+            q[i - 1] = '\0';
+        }
+
+        i = strcmp(p, q);
+        log_msg(my_depth, "'%s' v '%s' --> %d\n", p, q, i);
+
 //      printf("%s v %s --> %d\n", p, q, i);
-      
-      if (i<0)
-        { // read another subset file in.
-      log_msg(my_depth, "Reading next subset line in\n\n");
-      fgets(current_subset_file, MAX_STR_LEN, faclin);
-      continue;
-    }
-
-      if (!i) { fputs(incoming, pout); }
-      fgets(incoming, MAX_STR_LEN, pin);
-      if (!i) { log_msg(my_depth, "Copying master %s", q); }
-      
+
+        if (i < 0) {            // read another subset file in.
+            log_msg(my_depth, "Reading next subset line in\n\n");
+            fgets(current_subset_file, MAX_STR_LEN, faclin);
+            continue;
+        }
+
+        if (!i) {
+            fputs(incoming, pout);
+        }
+        fgets(incoming, MAX_STR_LEN, pin);
+        if (!i) {
+            log_msg(my_depth, "Copying master %s", q);
+        }
 //      if (!i) { printf("Match --- %s\n", q); }
-      
-      while (!feof(pin) && strncmp(incoming, "# file: ", 8))
-        {
-          if (!i) { 
-      
-//    printf("%s", incoming);
-      
-      fputs(incoming, pout); }
-          fgets(incoming, MAX_STR_LEN, pin);
-        }
-      if (!i) { fgets(current_subset_file, MAX_STR_LEN, faclin); }
-    }
-  while(!feof(pin)) { fgets (incoming, MAX_STR_LEN, pin); }
-  fclose(faclin);
-  pclose(pin);
-  pclose(pout);  
-  
+
+        while (!feof(pin) && strncmp(incoming, "# file: ", 8)) {
+            if (!i) {
+
+//    printf("%s", incoming);
+
+                fputs(incoming, pout);
+            }
+            fgets(incoming, MAX_STR_LEN, pin);
+        }
+        if (!i) {
+            fgets(current_subset_file, MAX_STR_LEN, faclin);
+        }
+    }
+    while (!feof(pin)) {
+        fgets(incoming, MAX_STR_LEN, pin);
+    }
+    fclose(faclin);
+    pclose(pin);
+    pclose(pout);
+
 //  printf("OK, loop is done\n");
 
-  unlink(masklist);  
-  paranoid_free(current_subset_file);
-  paranoid_free(current_master_file);
-  paranoid_free(syscall_pout);
-  paranoid_free(syscall_pin);
-  paranoid_free(masklist);
-  paranoid_free(incoming);
-  paranoid_free(command);
-  return(retval);
-}  
-
-
-int set_fattr_list(char*masklist, char*fattr_fname)
-{
-  return(set_EXAT_list(masklist, fattr_fname, "setfattr"));
-}
-
-
-
-int set_acl_list(char*masklist, char*acl_fname)
-{
-  return(set_EXAT_list(masklist, acl_fname, "setfacl"));
+    unlink(masklist);
+    paranoid_free(current_subset_file);
+    paranoid_free(current_master_file);
+    paranoid_free(syscall_pout);
+    paranoid_free(syscall_pin);
+    paranoid_free(masklist);
+    paranoid_free(incoming);
+    paranoid_free(command);
+    return (retval);
+}
+
+
+int set_fattr_list(char *masklist, char *fattr_fname)
+{
+    return (set_EXAT_list(masklist, fattr_fname, "setfattr"));
+}
+
+
+
+int set_acl_list(char *masklist, char *acl_fname)
+{
+    return (set_EXAT_list(masklist, acl_fname, "setfacl"));
 }
 
@@ -833 +753 @@
  * @note This function should only be called at restore-time.
  */
-int
-get_last_filelist_number (struct s_bkpinfo *bkpinfo)
-{
-    /*@ buffers ******************************************************/
-  char val_sz[MAX_STR_LEN];
-  char cfg_fname[MAX_STR_LEN];
+int get_last_filelist_number(struct s_bkpinfo *bkpinfo)
+{
+    /*@ buffers ***************************************************** */
+    char val_sz[MAX_STR_LEN];
+    char cfg_fname[MAX_STR_LEN];
 /*  char tmp[MAX_STR_LEN]; remove stan benoit apr 2002 */
 
-    /*@ long *********************************************************/
-  int val_i;
-
-    /*@ end vars *****************************************************/
-
-  assert(bkpinfo!=NULL);
-
-  sprintf (cfg_fname, "%s/mondo-restore.cfg", bkpinfo->tmpdir);
-  read_cfg_var (cfg_fname, "last-filelist-number", val_sz);
-  val_i = atoi (val_sz);
-  if (val_i <= 0)
-    {
-      val_i = 500;
-    }
-  return (val_i);
+    /*@ long ******************************************************** */
+    int val_i;
+
+    /*@ end vars **************************************************** */
+
+    assert(bkpinfo != NULL);
+
+    sprintf(cfg_fname, "%s/mondo-restore.cfg", bkpinfo->tmpdir);
+    read_cfg_var(cfg_fname, "last-filelist-number", val_sz);
+    val_i = atoi(val_sz);
+    if (val_i <= 0) {
+        val_i = 500;
+    }
+    return (val_i);
 }
 
@@ -866 +784 @@
  * @bug I don't understand this function. Would someone care to explain it?
  */
-int
-add_string_at_node (struct s_node *startnode, char *string_to_add)
-{
-
-
-    /*@ int *********************************************************/
-  int noof_chars;
-  int i;
-  int res;
-
-    /*@ sturctures **************************************************/
-  struct s_node *node, *newnode;
-
-    /*@ char  *******************************************************/
-  char char_to_add;
-
-    /*@ bools *******************************************************/
-
-  const bool sosodef = FALSE;
-
-  static int depth=0;
-  static char original_string[MAX_STR_LEN];
-
-  assert(startnode!=NULL);
-  assert(string_to_add!=NULL);
-
-  if (!depth) { strcpy(original_string, string_to_add); }
-
-  noof_chars = strlen (string_to_add) + 1;  /* we include the '\0' */
+int add_string_at_node(struct s_node *startnode, char *string_to_add)
+{
+
+
+    /*@ int ******************************************************** */
+    int noof_chars;
+    int i;
+    int res;
+
+    /*@ sturctures ************************************************* */
+    struct s_node *node, *newnode;
+
+    /*@ char  ****************************************************** */
+    char char_to_add;
+
+    /*@ bools ****************************************************** */
+
+    const bool sosodef = FALSE;
+
+    static int depth = 0;
+    static char original_string[MAX_STR_LEN];
+
+    assert(startnode != NULL);
+    assert(string_to_add != NULL);
+
+    if (!depth) {
+        strcpy(original_string, string_to_add);
+    }
+
+    noof_chars = strlen(string_to_add) + 1; /* we include the '\0' */
 
 /* walk across tree if necessary */
-  node = startnode;
-  char_to_add = string_to_add[0];
-  if (node->right != NULL && node->ch < char_to_add)
-    {
-      log_msg(7, "depth=%d --- going RIGHT ... %c-->%c", depth, char_to_add, node->ch, (node->right)->ch);
-      return (add_string_at_node (node->right, string_to_add));
-    }
+    node = startnode;
+    char_to_add = string_to_add[0];
+    if (node->right != NULL && node->ch < char_to_add) {
+        log_msg(7, "depth=%d --- going RIGHT ... %c-->%c", depth,
+                char_to_add, node->ch, (node->right)->ch);
+        return (add_string_at_node(node->right, string_to_add));
+    }
 
 /* walk down tree if appropriate */
-  if (node->down != NULL && node->ch == char_to_add)
-    {
-      log_msg(7, "depth=%d char=%c --- going DOWN", depth, char_to_add);
-      depth++;
-      res = add_string_at_node (node->down, string_to_add + 1);
-      depth--;
-      return (res);
-    }
-
-  if (char_to_add == '\0' && node->ch =='\0')
-    {
-      log_msg(6, "%s already in tree", original_string);
-      return(1);
-    }
+    if (node->down != NULL && node->ch == char_to_add) {
+        log_msg(7, "depth=%d char=%c --- going DOWN", depth, char_to_add);
+        depth++;
+        res = add_string_at_node(node->down, string_to_add + 1);
+        depth--;
+        return (res);
+    }
+
+    if (char_to_add == '\0' && node->ch == '\0') {
+        log_msg(6, "%s already in tree", original_string);
+        return (1);
+    }
 
 /* add here */
-  if (!(newnode = (struct s_node*)malloc (sizeof (struct s_node))))
-            {
-              log_to_screen ("failed to malloc");
-              depth--;
-              return (1);
-            }
-  if (char_to_add < node->ch) // add to the left of node
-    {
-      log_msg(7, "depth=%d char=%c --- adding (left)", depth, char_to_add);
-      memcpy((void*)newnode, (void*)node, sizeof(struct s_node));
-      node->right = newnode;
-    }
-  else if (char_to_add > node->ch) // add to the right of node
-    {
-      log_msg(7, "depth=%d char=%c --- adding (right)", depth, char_to_add);
-      newnode->right = node->right; // newnode is to the RIGHT of node
-      node->right = newnode;
-      node = newnode;
-    }
-  // from now on, we're working on 'node'
-  node->down = NULL;
-  node->ch = char_to_add;
-  node->expanded = node->selected = FALSE;
-  if (char_to_add == '\0')
-    {
-      log_msg (6, "Added %s OK", original_string);
-      return (0);
-    }
-
+    if (!(newnode = (struct s_node *) malloc(sizeof(struct s_node)))) {
+        log_to_screen("failed to malloc");
+        depth--;
+        return (1);
+    }
+    if (char_to_add < node->ch) // add to the left of node
+    {
+        log_msg(7, "depth=%d char=%c --- adding (left)", depth,
+                char_to_add);
+        memcpy((void *) newnode, (void *) node, sizeof(struct s_node));
+        node->right = newnode;
+    } else if (char_to_add > node->ch)  // add to the right of node
+    {
+        log_msg(7, "depth=%d char=%c --- adding (right)", depth,
+                char_to_add);
+        newnode->right = node->right;   // newnode is to the RIGHT of node
+        node->right = newnode;
+        node = newnode;
+    }
+    // from now on, we're working on 'node'
+    node->down = NULL;
+    node->ch = char_to_add;
+    node->expanded = node->selected = FALSE;
+    if (char_to_add == '\0') {
+        log_msg(6, "Added %s OK", original_string);
+        return (0);
+    }
 // add the rest
-  log_msg(6, "Adding remaining chars ('%s')", string_to_add+1);
-  for (i = 1; i < noof_chars; i++)
-    {
-      if (!(node->down = (struct s_node*)malloc (sizeof (struct s_node))))
-    {
-      log_to_screen ("%s - failed to malloc", string_to_add);
-      return (1);
-    }
-      node = node->down;
-      char_to_add = string_to_add[i];
-      log_msg(6, "Adding '%c'", char_to_add);
-      node->ch = char_to_add;
-      node->right = node->down = NULL;
-      node->expanded = node->selected = FALSE;
-      if (!node->ch) { node->selected = sosodef; }
-    }
-  log_msg (6, "Finally - added %s OK", original_string);
-  return (0);
+    log_msg(6, "Adding remaining chars ('%s')", string_to_add + 1);
+    for (i = 1; i < noof_chars; i++) {
+        if (!
+            (node->down =
+             (struct s_node *) malloc(sizeof(struct s_node)))) {
+            log_to_screen("%s - failed to malloc", string_to_add);
+            return (1);
+        }
+        node = node->down;
+        char_to_add = string_to_add[i];
+        log_msg(6, "Adding '%c'", char_to_add);
+        node->ch = char_to_add;
+        node->right = node->down = NULL;
+        node->expanded = node->selected = FALSE;
+        if (!node->ch) {
+            node->selected = sosodef;
+        }
+    }
+    log_msg(6, "Finally - added %s OK", original_string);
+    return (0);
 }
 
@@ -981 +898 @@
  * @return A filelist tree structure.
  */
-struct s_node *
-load_filelist (char *filelist_fname)
-{
-
-    /*@ structures **************************************************/
-  struct s_node *filelist;
-
-    /*@ pointers ****************************************************/
-  FILE *pin;
-
-    /*@ buffers *****************************************************/
-  char command_to_open_fname[MAX_STR_LEN];
-  char fname[MAX_STR_LEN];
-  char tmp[MAX_STR_LEN];
-  int pos_in_fname;
-    /*@ int *********************************************************/
-  int percentage;
-
-    /*@ long ********************************************************/
-  long lines_in_filelist;
-  long lino = 0;
-    /*@ end vars ****************************************************/
-
-  assert_string_is_neither_NULL_nor_zerolength(filelist_fname);
-
-  if (!does_file_exist(filelist_fname))
-    { fatal_error("filelist does not exist -- cannot load it"); }
-  log_to_screen ("Loading filelist");
-  sprintf(command_to_open_fname, "gzip -dc %s", filelist_fname);
-  sprintf(tmp, "zcat %s | wc -l", filelist_fname);
-  log_msg(6, "tmp = %s", tmp);
-  lines_in_filelist = atol(call_program_and_get_last_line_of_output(tmp));
-  if (lines_in_filelist < 3) { log_to_screen("Warning - surprisingly short filelist."); }
-  g_original_noof_lines_in_filelist = lines_in_filelist;
-  if (!(filelist = (struct s_node*)malloc (sizeof (struct s_node))))
-    {
-      return (NULL);
-    }
-  filelist->ch = '/';
-  filelist->right = NULL;
-  filelist->down = malloc(sizeof(struct s_node));
-  filelist->expanded = filelist->selected = FALSE;
-  (filelist->down)->ch = '\0';
-  (filelist->down)->right = (filelist->down)->down = FALSE;
-  (filelist->down)->expanded = (filelist->down)->selected = FALSE;
-  if (!(pin = popen (command_to_open_fname, "r")))
-    {
-      log_OS_error("Unable to openin filelist_fname");
-      return (NULL);
-    }
-  open_evalcall_form ("Loading filelist from disk");
-  for (fgets (fname, MAX_STR_LEN, pin); !feof (pin);
-       fgets (fname, MAX_STR_LEN, pin))
-    {
-      if ((fname[strlen(fname)-1]==13 || fname[strlen(fname)-1]==10) && strlen(fname)>0)
-        { fname[strlen(fname)-1] = '\0'; }
+struct s_node *load_filelist(char *filelist_fname)
+{
+
+    /*@ structures ************************************************* */
+    struct s_node *filelist;
+
+    /*@ pointers *************************************************** */
+    FILE *pin;
+
+    /*@ buffers **************************************************** */
+    char command_to_open_fname[MAX_STR_LEN];
+    char fname[MAX_STR_LEN];
+    char tmp[MAX_STR_LEN];
+    int pos_in_fname;
+    /*@ int ******************************************************** */
+    int percentage;
+
+    /*@ long ******************************************************* */
+    long lines_in_filelist;
+    long lino = 0;
+    /*@ end vars *************************************************** */
+
+    assert_string_is_neither_NULL_nor_zerolength(filelist_fname);
+
+    if (!does_file_exist(filelist_fname)) {
+        fatal_error("filelist does not exist -- cannot load it");
+    }
+    log_to_screen("Loading filelist");
+    sprintf(command_to_open_fname, "gzip -dc %s", filelist_fname);
+    sprintf(tmp, "zcat %s | wc -l", filelist_fname);
+    log_msg(6, "tmp = %s", tmp);
+    lines_in_filelist =
+        atol(call_program_and_get_last_line_of_output(tmp));
+    if (lines_in_filelist < 3) {
+        log_to_screen("Warning - surprisingly short filelist.");
+    }
+    g_original_noof_lines_in_filelist = lines_in_filelist;
+    if (!(filelist = (struct s_node *) malloc(sizeof(struct s_node)))) {
+        return (NULL);
+    }
+    filelist->ch = '/';
+    filelist->right = NULL;
+    filelist->down = malloc(sizeof(struct s_node));
+    filelist->expanded = filelist->selected = FALSE;
+    (filelist->down)->ch = '\0';
+    (filelist->down)->right = (filelist->down)->down = FALSE;
+    (filelist->down)->expanded = (filelist->down)->selected = FALSE;
+    if (!(pin = popen(command_to_open_fname, "r"))) {
+        log_OS_error("Unable to openin filelist_fname");
+        return (NULL);
+    }
+    open_evalcall_form("Loading filelist from disk");
+    for (fgets(fname, MAX_STR_LEN, pin); !feof(pin);
+         fgets(fname, MAX_STR_LEN, pin)) {
+        if ((fname[strlen(fname) - 1] == 13
+             || fname[strlen(fname) - 1] == 10) && strlen(fname) > 0) {
+            fname[strlen(fname) - 1] = '\0';
+        }
 //      strip_spaces (fname);
-      if (!strlen (fname))
-    {
-      continue;
-    }
-      for(pos_in_fname=0; fname[pos_in_fname]!='\0'; pos_in_fname++)
-        {
-      if (fname[pos_in_fname]!='/') { continue; }
-      strcpy(tmp, fname);
-      tmp[pos_in_fname] = '\0';
-      if (strlen(tmp))
-        { add_string_at_node (filelist, tmp); }
-    }
-      add_string_at_node (filelist, fname);
-      if (!(++lino % 1111))
-    {
-      percentage = (int) (lino * 100 / lines_in_filelist);
-      update_evalcall_form (percentage);
-    }
-    }
-  paranoid_pclose(pin);
-  close_evalcall_form ();
-  log_it ("Finished loading filelist");
-  return (filelist);
+        if (!strlen(fname)) {
+            continue;
+        }
+        for (pos_in_fname = 0; fname[pos_in_fname] != '\0'; pos_in_fname++) {
+            if (fname[pos_in_fname] != '/') {
+                continue;
+            }
+            strcpy(tmp, fname);
+            tmp[pos_in_fname] = '\0';
+            if (strlen(tmp)) {
+                add_string_at_node(filelist, tmp);
+            }
+        }
+        add_string_at_node(filelist, fname);
+        if (!(++lino % 1111)) {
+            percentage = (int) (lino * 100 / lines_in_filelist);
+            update_evalcall_form(percentage);
+        }
+    }
+    paranoid_pclose(pin);
+    close_evalcall_form();
+    log_it("Finished loading filelist");
+    return (filelist);
 }
 
@@ -1068 +987 @@
  * @param node The toplevel node to use.
  */
-void
-show_filelist (struct s_node *node)
-{
-  static int depth=0;
-  static char current_string[200];
-
-  if (depth==0)
-    { log_msg(0, "----------------show filelist--------------"); }
-  current_string[depth] = node->ch;
-
-  log_msg(3, "depth=%d", depth);
-  if (node->down)
-    {
-      log_msg(3, "moving down");
-      depth++;
-      show_filelist(node->down);
-      depth--;
-    }
-
-  if (!node->ch)
-    {
-      log_msg(0, "%s\n", current_string);
-    }
-
-  if (node->right)
-    {
-      log_msg(3, "moving right");
-      show_filelist(node->right);
-    }
-  if (depth==0)
-    { log_msg(0, "----------------show filelist--------------"); }
-  return;
+void show_filelist(struct s_node *node)
+{
+    static int depth = 0;
+    static char current_string[200];
+
+    if (depth == 0) {
+        log_msg(0, "----------------show filelist--------------");
+    }
+    current_string[depth] = node->ch;
+
+    log_msg(3, "depth=%d", depth);
+    if (node->down) {
+        log_msg(3, "moving down");
+        depth++;
+        show_filelist(node->down);
+        depth--;
+    }
+
+    if (!node->ch) {
+        log_msg(0, "%s\n", current_string);
+    }
+
+    if (node->right) {
+        log_msg(3, "moving right");
+        show_filelist(node->right);
+    }
+    if (depth == 0) {
+        log_msg(0, "----------------show filelist--------------");
+    }
+    return;
 }
 
@@ -1110 +1027 @@
  * @param filelist The filelist tree structure.
  */
-void
-reload_filelist (struct s_node *filelist)
-{
-  assert(filelist!=NULL);
-  toggle_node_selection (filelist, FALSE);
-  toggle_path_expandability (filelist, "/", FALSE);
-  toggle_all_root_dirs_on (filelist);
+void reload_filelist(struct s_node *filelist)
+{
+    assert(filelist != NULL);
+    toggle_node_selection(filelist, FALSE);
+    toggle_path_expandability(filelist, "/", FALSE);
+    toggle_all_root_dirs_on(filelist);
 }
 
@@ -1126 +1042 @@
  * @param outfname Where to save it.
  */
-void
-save_filelist (struct s_node *filelist, char *outfname)
-{
-    /*@ int **********************************************************/
-  static int percentage;
-  static int depth = 0;
-
-    /*@ buffers ******************************************************/
-  static char str[MAX_STR_LEN];
-
-    /*@ structures ***************************************************/
-  struct s_node *node;
-
-    /*@ pointers *****************************************************/
-  static FILE *fout = NULL;
-
-    /*@ long *********************************************************/
-  static long lines_in_filelist = 0;
-  static long lino = 0;
-
-    /*@ end vars ****************************************************/
-
-  assert(filelist!=NULL);
-  assert(outfname!=NULL); // will be zerolength if save_filelist() is called by itself
-  if (depth == 0)
-    {
-      log_to_screen ("Saving filelist");
-      if (!(fout = fopen (outfname, "w"))) { fatal_error("Cannot openout/save filelist"); }
-      lines_in_filelist = g_original_noof_lines_in_filelist;    /* set by load_filelist() */
-      open_evalcall_form ("Saving selection to disk");
-    }
-  for (node = filelist; node != NULL; node = node->right)
-    {
-      str[depth] = node->ch;
-      log_msg(5, "depth=%d ch=%c", depth, node->ch);
-      if (!node->ch)
-    {
-//    if (node->selected)
-//      {
-          fprintf (fout, "%s\n", str);
-//      }
-      if (!(++lino % 1111))
-        {
-          percentage = (int) (lino * 100 / lines_in_filelist);
-          update_evalcall_form (percentage);
-        }
-    }
-      if (node->down)
-    {
-      depth++;
-      save_filelist (node->down, "");
-      depth--;
-    }
-    }
-  if (depth == 0)
-    {
-      paranoid_fclose (fout);
-      close_evalcall_form ();
-      log_it ("Finished saving filelist");
-    }
+void save_filelist(struct s_node *filelist, char *outfname)
+{
+    /*@ int ********************************************************* */
+    static int percentage;
+    static int depth = 0;
+
+    /*@ buffers ***************************************************** */
+    static char str[MAX_STR_LEN];
+
+    /*@ structures ************************************************** */
+    struct s_node *node;
+
+    /*@ pointers **************************************************** */
+    static FILE *fout = NULL;
+
+    /*@ long ******************************************************** */
+    static long lines_in_filelist = 0;
+    static long lino = 0;
+
+    /*@ end vars *************************************************** */
+
+    assert(filelist != NULL);
+    assert(outfname != NULL);   // will be zerolength if save_filelist() is called by itself
+    if (depth == 0) {
+        log_to_screen("Saving filelist");
+        if (!(fout = fopen(outfname, "w"))) {
+            fatal_error("Cannot openout/save filelist");
+        }
+        lines_in_filelist = g_original_noof_lines_in_filelist;  /* set by load_filelist() */
+        open_evalcall_form("Saving selection to disk");
+    }
+    for (node = filelist; node != NULL; node = node->right) {
+        str[depth] = node->ch;
+        log_msg(5, "depth=%d ch=%c", depth, node->ch);
+        if (!node->ch) {
+//    if (node->selected)
+//      {
+            fprintf(fout, "%s\n", str);
+//      }
+            if (!(++lino % 1111)) {
+                percentage = (int) (lino * 100 / lines_in_filelist);
+                update_evalcall_form(percentage);
+            }
+        }
+        if (node->down) {
+            depth++;
+            save_filelist(node->down, "");
+            depth--;
+        }
+    }
+    if (depth == 0) {
+        paranoid_fclose(fout);
+        close_evalcall_form();
+        log_it("Finished saving filelist");
+    }
 }
 
@@ -1195 +1106 @@
  * @bug I don't understand this function. Would someone care to explain it?
  */
-void
-toggle_all_root_dirs_on (struct s_node *filelist)
-{
-    /*@ structures ***************************************************/
-  struct s_node *node;
-
-    /*@ int **********************************************************/
-  static int depth = 0;
-  static int root_dirs_expanded;
-
-    /*@ buffers ******************************************************/
-  static char filename[MAX_STR_LEN];
-
-    /*@ end vars ****************************************************/
-
-  assert(filelist!=NULL);
-  if (depth == 0)
-    {
-      log_it ("Toggling all root dirs ON");
-      root_dirs_expanded = 0;
-    }
-  for (node = filelist; node != NULL; node = node->right)
-    {
-      filename[depth] = node->ch;
-      if (node->ch == '\0' && strlen (filename) > 1
-      && (!strchr (filename + 1, '/')))
-    {
-      node->selected = FALSE;
-      node->expanded = TRUE;
-//    log_it (filename);
-      root_dirs_expanded++;
-    }
-      if (node->down)
-    {
-      depth++;
-      toggle_all_root_dirs_on (node->down);
-      depth--;
-    }
-    }
-  if (depth == 0)
-    {
-      log_it ("Finished toggling all root dirs ON");
-    }
+void toggle_all_root_dirs_on(struct s_node *filelist)
+{
+    /*@ structures ************************************************** */
+    struct s_node *node;
+
+    /*@ int ********************************************************* */
+    static int depth = 0;
+    static int root_dirs_expanded;
+
+    /*@ buffers ***************************************************** */
+    static char filename[MAX_STR_LEN];
+
+    /*@ end vars *************************************************** */
+
+    assert(filelist != NULL);
+    if (depth == 0) {
+        log_it("Toggling all root dirs ON");
+        root_dirs_expanded = 0;
+    }
+    for (node = filelist; node != NULL; node = node->right) {
+        filename[depth] = node->ch;
+        if (node->ch == '\0' && strlen(filename) > 1
+            && (!strchr(filename + 1, '/'))) {
+            node->selected = FALSE;
+            node->expanded = TRUE;
+//    log_it (filename);
+            root_dirs_expanded++;
+        }
+        if (node->down) {
+            depth++;
+            toggle_all_root_dirs_on(node->down);
+            depth--;
+        }
+    }
+    if (depth == 0) {
+        log_it("Finished toggling all root dirs ON");
+    }
 }
 
@@ -1249 +1154 @@
  */
 void
-toggle_path_expandability (struct s_node *filelist, char *pathname,
-               bool on_or_off)
-{
-
-    /*@ int *********************************************************/
-  static int depth = 0;
-  static int total_expanded;
-  static int root_depth;
-  int j;
-    /*@ structures **************************************************/
-  struct s_node *node;
-
-    /*@ buffers *****************************************************/
-  static char current_filename[MAX_STR_LEN];
+toggle_path_expandability(struct s_node *filelist, char *pathname,
+                          bool on_or_off)
+{
+
+    /*@ int ******************************************************** */
+    static int depth = 0;
+    static int total_expanded;
+    static int root_depth;
+    int j;
+    /*@ structures ************************************************* */
+    struct s_node *node;
+
+    /*@ buffers **************************************************** */
+    static char current_filename[MAX_STR_LEN];
 
 /*  char tmp[MAX_STR_LEN+2]; */
 
-    /*@ end vars ****************************************************/
-
-  assert(filelist!=NULL);
-  assert_string_is_neither_NULL_nor_zerolength(pathname);
-  if (depth == 0)
-    {
-      total_expanded = 0;
+    /*@ end vars *************************************************** */
+
+    assert(filelist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(pathname);
+    if (depth == 0) {
+        total_expanded = 0;
 //      log_it ("Toggling path's expandability");
-      for (root_depth = (int) strlen (pathname);
-       root_depth > 0 && pathname[root_depth - 1] != '/'; root_depth--);
-      if (root_depth < 2)
-    {
-      root_depth = (int) strlen (pathname);
-    }
-    }
-  for (node = filelist; node != NULL; node = node->right)
-    {
-      current_filename[depth] = node->ch;
-      if (node->down)
-    {
-      depth++;
-      toggle_path_expandability (node->down, pathname, on_or_off);
-      depth--;
-    }
-      if (node->ch == '\0')
-    {
-      if (!strncmp (pathname, current_filename, strlen (pathname)))
-        {
-          for (j = root_depth;
-           current_filename[j] != '/' && current_filename[j] != '\0';
-           j++);
-          if (current_filename[j] != '\0')
-        {
-          for (j++;
-               current_filename[j] != '/'
-               && current_filename[j] != '\0'; j++);
-        }
-          if (current_filename[j] == '\0')
-        {
-          node->expanded =
-            (!strcmp (pathname, current_filename) ? TRUE : on_or_off);
-        }
-        }
-    }
-      if (node->expanded)
-    {
-      if (total_expanded < ARBITRARY_MAXIMUM - 32
-          || !strrchr (current_filename + strlen (pathname), '/'))
-        {
-          total_expanded++;
-        }
-      else
-        {
-          node->expanded = FALSE;
-        }
-    }
-    }
-  if (depth == 0)
-    {
+        for (root_depth = (int) strlen(pathname);
+             root_depth > 0 && pathname[root_depth - 1] != '/';
+             root_depth--);
+        if (root_depth < 2) {
+            root_depth = (int) strlen(pathname);
+        }
+    }
+    for (node = filelist; node != NULL; node = node->right) {
+        current_filename[depth] = node->ch;
+        if (node->down) {
+            depth++;
+            toggle_path_expandability(node->down, pathname, on_or_off);
+            depth--;
+        }
+        if (node->ch == '\0') {
+            if (!strncmp(pathname, current_filename, strlen(pathname))) {
+                for (j = root_depth;
+                     current_filename[j] != '/'
+                     && current_filename[j] != '\0'; j++);
+                if (current_filename[j] != '\0') {
+                    for (j++;
+                         current_filename[j] != '/'
+                         && current_filename[j] != '\0'; j++);
+                }
+                if (current_filename[j] == '\0') {
+                    node->expanded =
+                        (!strcmp(pathname, current_filename) ? TRUE :
+                         on_or_off);
+                }
+            }
+        }
+        if (node->expanded) {
+            if (total_expanded < ARBITRARY_MAXIMUM - 32
+                || !strrchr(current_filename + strlen(pathname), '/')) {
+                total_expanded++;
+            } else {
+                node->expanded = FALSE;
+            }
+        }
+    }
+    if (depth == 0) {
 //      log_it ("Finished toggling expandability");
-    }
+    }
 }
 
@@ -1337 +1231 @@
  */
 void
-toggle_path_selection (struct s_node *filelist, char *pathname,
-               bool on_or_off)
-{
-    /*@ int **********************************************************/
-  static int depth = 0;
-  int j;
-
-    /*@ structures ***************************************************/
-  struct s_node *node;
-
-    /*@ buffers ******************************************************/
-  static char current_filename[MAX_STR_LEN];
-  char tmp[MAX_STR_LEN + 2];
-
-    /*@ end vars ****************************************************/
-  assert(filelist!=NULL);
-  assert_string_is_neither_NULL_nor_zerolength(pathname);
-  if (depth == 0)
-    {
-      log_it ("Toggling path's selection");
-    }
-  for (node = filelist; node != NULL; node = node->right)
-    {
-      current_filename[depth] = node->ch;
-      if (node->down)
-    {
-      depth++;
-      toggle_path_selection (node->down, pathname, on_or_off);
-      depth--;
-    }
-      if (node->ch == '\0')
-    {
-      if (!strncmp (pathname, current_filename, strlen (pathname)))
-        {
-          for (j = 0;
-           pathname[j] != '\0' && pathname[j] == current_filename[j];
-           j++);
-          if (current_filename[j] == '/' || current_filename[j] == '\0')
-        {
-          node->selected = on_or_off;
-          sprintf (tmp, "%s is now %s\n", current_filename,
-               (on_or_off ? "ON" : "OFF"));
-        }
-        }
-    }
-    }
-  if (depth == 0)
-    {
-      log_it ("Finished toggling selection");
-    }
+toggle_path_selection(struct s_node *filelist, char *pathname,
+                      bool on_or_off)
+{
+    /*@ int ********************************************************* */
+    static int depth = 0;
+    int j;
+
+    /*@ structures ************************************************** */
+    struct s_node *node;
+
+    /*@ buffers ***************************************************** */
+    static char current_filename[MAX_STR_LEN];
+    char tmp[MAX_STR_LEN + 2];
+
+    /*@ end vars *************************************************** */
+    assert(filelist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(pathname);
+    if (depth == 0) {
+        log_it("Toggling path's selection");
+    }
+    for (node = filelist; node != NULL; node = node->right) {
+        current_filename[depth] = node->ch;
+        if (node->down) {
+            depth++;
+            toggle_path_selection(node->down, pathname, on_or_off);
+            depth--;
+        }
+        if (node->ch == '\0') {
+            if (!strncmp(pathname, current_filename, strlen(pathname))) {
+                for (j = 0;
+                     pathname[j] != '\0'
+                     && pathname[j] == current_filename[j]; j++);
+                if (current_filename[j] == '/'
+                    || current_filename[j] == '\0') {
+                    node->selected = on_or_off;
+                    sprintf(tmp, "%s is now %s\n", current_filename,
+                            (on_or_off ? "ON" : "OFF"));
+                }
+            }
+        }
+    }
+    if (depth == 0) {
+        log_it("Finished toggling selection");
+    }
 }
 
@@ -1396 +1284 @@
  * @bug I don't understand this function. Would someone care to explain it?
  */
-void
-toggle_node_selection (struct s_node *filelist, bool on_or_off)
-{
-    /*@ structure ***************************************************/
-  struct s_node *node;
-
-    /*@ end vars ****************************************************/
-  assert(filelist!=NULL);
-  for (node = filelist; node != NULL; node = node->right)
-    {
-      if (node->ch == '/')
-    {
-      continue;
-    }           /* don't go deep */
-      if (node->ch == '\0')
-    {
-      node->selected = on_or_off;
-    }
-      if (node->down)
-    {
-      toggle_node_selection (node->down, on_or_off);
-    }
-    }
+void toggle_node_selection(struct s_node *filelist, bool on_or_off)
+{
+    /*@ structure ************************************************** */
+    struct s_node *node;
+
+    /*@ end vars *************************************************** */
+    assert(filelist != NULL);
+    for (node = filelist; node != NULL; node = node->right) {
+        if (node->ch == '/') {
+            continue;
+        }                       /* don't go deep */
+        if (node->ch == '\0') {
+            node->selected = on_or_off;
+        }
+        if (node->down) {
+            toggle_node_selection(node->down, on_or_off);
+        }
+    }
 }
 
@@ -1430 +1313 @@
  * The pathname to the skeleton filelist, used to give better progress reporting for mondo_makefilelist().
  */
-char *g_skeleton_filelist=NULL;
+char *g_skeleton_filelist = NULL;
 
 /**
  * Number of entries in the skeleton filelist.
  */
-long g_skeleton_entries=0;
+long g_skeleton_entries = 0;
 
 /**
@@ -1449 +1332 @@
  * @see mondo_makefilelist
  */
-int
-prepare_filelist (struct s_bkpinfo *bkpinfo)
-{
-
-    /*@ int *****************************************************/
-  int res = 0;
+int prepare_filelist(struct s_bkpinfo *bkpinfo)
+{
+
+    /*@ int **************************************************** */
+    int res = 0;
 // patch by Herman Kuster
 // end patch
-  int *p_res = &res;
-
-    /*@ buffers *************************************************/
+    int *p_res = &res;
+
+    /*@ buffers ************************************************ */
 //  char command[MAX_STR_LEN*2];
 
-    /*@ i don't have any idea ***********************************/
-
-  assert(bkpinfo!=NULL);
-  log_it ("tmpdir=%s; scratchdir=%s", bkpinfo->tmpdir,
-       bkpinfo->scratchdir);
-  if (bkpinfo->make_filelist)
-    {
-      mvaddstr_and_log_it (g_currentY, 0,
-               "Making catalog of files to be backed up");
-    }
-  else
-    {
-      mvaddstr_and_log_it (g_currentY, 0,
-               "Using supplied catalog of files to be backed up");
-    }
-
-  if (bkpinfo->make_filelist)
-    {
-      res = mondo_makefilelist(
-       MONDO_LOGFILE, bkpinfo->tmpdir, bkpinfo->scratchdir,
-       bkpinfo->include_paths,
-       bkpinfo->exclude_paths,
-       bkpinfo->differential,
-       NULL);
-    }
-  else
-    {
-      res = mondo_makefilelist(
-       MONDO_LOGFILE, bkpinfo->tmpdir, bkpinfo->scratchdir,
-       NULL,
-       bkpinfo->exclude_paths,
-       bkpinfo->differential,
-       bkpinfo->include_paths);
-    }
-
-  if (res)
-    {
-      log_OS_error("Call to mondo-makefilelist failed");
-      *p_res ++;
-      mvaddstr_and_log_it (g_currentY++, 74, "Failed.");
-    }
-  else
-    {
-      mvaddstr_and_log_it (g_currentY++, 74, "Done.");
-    }
-  return (res);
+    /*@ i don't have any idea ********************************** */
+
+    assert(bkpinfo != NULL);
+    log_it("tmpdir=%s; scratchdir=%s", bkpinfo->tmpdir,
+           bkpinfo->scratchdir);
+    if (bkpinfo->make_filelist) {
+        mvaddstr_and_log_it(g_currentY, 0,
+                            "Making catalog of files to be backed up");
+    } else {
+        mvaddstr_and_log_it(g_currentY, 0,
+                            "Using supplied catalog of files to be backed up");
+    }
+
+    if (bkpinfo->make_filelist) {
+        res =
+            mondo_makefilelist(MONDO_LOGFILE, bkpinfo->tmpdir,
+                               bkpinfo->scratchdir, bkpinfo->include_paths,
+                               bkpinfo->exclude_paths,
+                               bkpinfo->differential, NULL);
+    } else {
+        res =
+            mondo_makefilelist(MONDO_LOGFILE, bkpinfo->tmpdir,
+                               bkpinfo->scratchdir, NULL,
+                               bkpinfo->exclude_paths,
+                               bkpinfo->differential,
+                               bkpinfo->include_paths);
+    }
+
+    if (res) {
+        log_OS_error("Call to mondo-makefilelist failed");
+        *p_res++;
+        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
+    } else {
+        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+    }
+    return (res);
 }
 
@@ -1520 +1392 @@
  * @bug Return value should be @c void.
  */
-int open_and_list_dir(char*dir, char*sth, FILE*fout, time_t time_of_last_full_backup)
-{
-  DIR             *dip;
-  struct dirent   *dit;
-  struct stat statbuf;
-  char new[MAX_STR_LEN];
-  char *tmp;
-  char *sth_B;
-  static int percentage=0;
-  char *ith_B;
-  char *skip_these;
-  char *new_with_spaces;
-  static char *name_of_evalcall_form;
-  int i;
-  static int depth=0;
-  char *p;
-  static int counter=0;
-  static int uberctr=0;
-  static char *find_skeleton_marker;
-  static long skeleton_lino=0;
-  static time_t last_time=0;
-  time_t this_time;
-  
-  malloc_string(tmp);
-  malloc_string(sth_B);
-  malloc_string(ith_B);
-  malloc_string(new_with_spaces);
-  p = strrchr(dir, '/');
-  if (p)
-    {
-      if (!strcmp(p, "/.") || !strcmp(p, "/.."))
-        {
-          return(0);
-        }
-    }
-
-  if (!depth)
-    {
-      malloc_string(name_of_evalcall_form);
-      malloc_string(find_skeleton_marker);
+int open_and_list_dir(char *dir, char *sth, FILE * fout,
+                      time_t time_of_last_full_backup)
+{
+    DIR *dip;
+    struct dirent *dit;
+    struct stat statbuf;
+    char new[MAX_STR_LEN];
+    char *tmp;
+    char *sth_B;
+    static int percentage = 0;
+    char *ith_B;
+    char *skip_these;
+    char *new_with_spaces;
+    static char *name_of_evalcall_form;
+    int i;
+    static int depth = 0;
+    char *p;
+    static int counter = 0;
+    static int uberctr = 0;
+    static char *find_skeleton_marker;
+    static long skeleton_lino = 0;
+    static time_t last_time = 0;
+    time_t this_time;
+
+    malloc_string(tmp);
+    malloc_string(sth_B);
+    malloc_string(ith_B);
+    malloc_string(new_with_spaces);
+    p = strrchr(dir, '/');
+    if (p) {
+        if (!strcmp(p, "/.") || !strcmp(p, "/..")) {
+            return (0);
+        }
+    }
+
+    if (!depth) {
+        malloc_string(name_of_evalcall_form);
+        malloc_string(find_skeleton_marker);
 #if linux
-      // 2.6 has /sys as a proc-type thing -- must be excluded
-      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);
+        // 2.6 has /sys as a proc-type thing -- must be excluded
+        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);
 #else
-      // On BSD, for example, /sys is the kernel sources -- don't exclude
-      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);
+        // On BSD, for example, /sys is the kernel sources -- don't exclude
+        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);
 #endif
-      system(tmp);
-      sprintf(tmp, "wc -l %s | awk '{print $1;}'", g_skeleton_filelist);
-      g_skeleton_entries = 1 + atol(call_program_and_get_last_line_of_output(tmp));
-      sprintf(name_of_evalcall_form, "Making catalog of %s", dir);
-      open_evalcall_form (name_of_evalcall_form);
-      find_skeleton_marker[0] = '\0';
-      skeleton_lino=1;
-      log_msg(5, "entries = %ld", g_skeleton_entries);
-      percentage=0;
-    }
-  else if (depth<=MAX_SKEL_DEPTH) // update evalcall form if appropriate
-        {
-      sprintf(find_skeleton_marker, "fgrep -v \"%s\" %s > %s.new 2> /dev/null", dir, g_skeleton_filelist, g_skeleton_filelist);
-//    log_msg(0, "fsm = %s", find_skeleton_marker);
-      if (!system(find_skeleton_marker))
-        {
-          percentage = (int)(skeleton_lino*100/g_skeleton_entries);
-          skeleton_lino++;
-//        log_msg(5, "Found %s", dir);
-//        log_msg(2, "Incrementing skeleton_lino; now %ld/%ld (%d%%)", skeleton_lino, g_skeleton_entries, percentage);
-          sprintf(find_skeleton_marker, "mv -f %s.new %s", g_skeleton_filelist, g_skeleton_filelist);
-//        log_msg(6, "fsm = %s", find_skeleton_marker);
-          run_program_and_log_output(find_skeleton_marker, 8);
-          time(&this_time);
-          if (this_time != last_time)
-            {
-            last_time = this_time;
+        system(tmp);
+        sprintf(tmp, "wc -l %s | awk '{print $1;}'", g_skeleton_filelist);
+        g_skeleton_entries =
+            1 + atol(call_program_and_get_last_line_of_output(tmp));
+        sprintf(name_of_evalcall_form, "Making catalog of %s", dir);
+        open_evalcall_form(name_of_evalcall_form);
+        find_skeleton_marker[0] = '\0';
+        skeleton_lino = 1;
+        log_msg(5, "entries = %ld", g_skeleton_entries);
+        percentage = 0;
+    } else if (depth <= MAX_SKEL_DEPTH) // update evalcall form if appropriate
+    {
+        sprintf(find_skeleton_marker,
+                "fgrep -v \"%s\" %s > %s.new 2> /dev/null", dir,
+                g_skeleton_filelist, g_skeleton_filelist);
+//    log_msg(0, "fsm = %s", find_skeleton_marker);
+        if (!system(find_skeleton_marker)) {
+            percentage = (int) (skeleton_lino * 100 / g_skeleton_entries);
+            skeleton_lino++;
+//        log_msg(5, "Found %s", dir);
+//        log_msg(2, "Incrementing skeleton_lino; now %ld/%ld (%d%%)", skeleton_lino, g_skeleton_entries, percentage);
+            sprintf(find_skeleton_marker, "mv -f %s.new %s",
+                    g_skeleton_filelist, g_skeleton_filelist);
+//        log_msg(6, "fsm = %s", find_skeleton_marker);
+            run_program_and_log_output(find_skeleton_marker, 8);
+            time(&this_time);
+            if (this_time != last_time) {
+                last_time = this_time;
 #ifndef _XWIN
-                  if (!g_text_mode)
-                {
-              sprintf(tmp, "Reading %-68s", dir);
-                  newtDrawRootText (0, g_noof_rows - 3, tmp);
-            }
+                if (!g_text_mode) {
+                    sprintf(tmp, "Reading %-68s", dir);
+                    newtDrawRootText(0, g_noof_rows - 3, tmp);
+                }
 #endif
-          update_evalcall_form(percentage);
-        }
-        }
-        }
-
-  depth++;
+                update_evalcall_form(percentage);
+            }
+        }
+    }
+
+    depth++;
 
 //  log_msg(0, "Cataloguing %s", dir);
-  if (sth[0]==' ') { skip_these = sth; }
-  else
-    {
-      skip_these = sth_B;
-      sprintf(skip_these, " %s ", sth);
-    }
-  sprintf(new_with_spaces, " %s ", dir);
-  if ((dip = opendir(dir)) == NULL)
-    {
-      log_OS_error("opendir");
-    }
-  else if (strstr(skip_these, new_with_spaces))
-    {
-      fprintf(fout, "%s\n", dir); // if excluded dir then print dir ONLY
-    }
-  else
-    {
-      fprintf(fout, "%s\n", dir);
-      while ((dit = readdir(dip)) != NULL)
-       {
-    i++;
-        strcpy(new, dir);
-        if (strcmp(dir, "/")) { strcat(new, "/"); }
-        strcat(new, dit->d_name);
-    new_with_spaces[0] = ' ';
-          strcpy(new_with_spaces+1, new);
-          strcat(new_with_spaces, " ");
-    if (strstr(skip_these, new_with_spaces))
-      {
-        fprintf(fout, "%s\n", new);
-      }
-    else
-      {
-        if (!lstat(new, &statbuf))
-          {
-        if (!S_ISLNK(statbuf.st_mode) && S_ISDIR(statbuf.st_mode)) {
-          open_and_list_dir(new, skip_these, fout, time_of_last_full_backup);
-        }
-        else {
-          if (time_of_last_full_backup==0 || time_of_last_full_backup<statbuf.st_ctime)
-            {
-              fprintf(fout, "%s\n", new);
-              if ((counter++)>128)
-                {
-                  counter=0;
-              uberctr++;
-                  sprintf(tmp, " %c ", special_dot_char(uberctr));
+    if (sth[0] == ' ') {
+        skip_these = sth;
+    } else {
+        skip_these = sth_B;
+        sprintf(skip_these, " %s ", sth);
+    }
+    sprintf(new_with_spaces, " %s ", dir);
+    if ((dip = opendir(dir)) == NULL) {
+        log_OS_error("opendir");
+    } else if (strstr(skip_these, new_with_spaces)) {
+        fprintf(fout, "%s\n", dir); // if excluded dir then print dir ONLY
+    } else {
+        fprintf(fout, "%s\n", dir);
+        while ((dit = readdir(dip)) != NULL) {
+            i++;
+            strcpy(new, dir);
+            if (strcmp(dir, "/")) {
+                strcat(new, "/");
+            }
+            strcat(new, dit->d_name);
+            new_with_spaces[0] = ' ';
+            strcpy(new_with_spaces + 1, new);
+            strcat(new_with_spaces, " ");
+            if (strstr(skip_these, new_with_spaces)) {
+                fprintf(fout, "%s\n", new);
+            } else {
+                if (!lstat(new, &statbuf)) {
+                    if (!S_ISLNK(statbuf.st_mode)
+                        && S_ISDIR(statbuf.st_mode)) {
+                        open_and_list_dir(new, skip_these, fout,
+                                          time_of_last_full_backup);
+                    } else {
+                        if (time_of_last_full_backup == 0
+                            || time_of_last_full_backup <
+                            statbuf.st_ctime) {
+                            fprintf(fout, "%s\n", new);
+                            if ((counter++) > 128) {
+                                counter = 0;
+                                uberctr++;
+                                sprintf(tmp, " %c ",
+                                        special_dot_char(uberctr));
 #ifndef _XWIN
-              if (!g_text_mode) {
-                  newtDrawRootText (77, g_noof_rows - 3, tmp);
-                  newtRefresh();
-              }
+                                if (!g_text_mode) {
+                                    newtDrawRootText(77, g_noof_rows - 3,
+                                                     tmp);
+                                    newtRefresh();
+                                }
 #endif
-                        }
-            }
-        }
-          }
-      }
-       }
-    }
-  if (dip)
-    {
-      if (closedir(dip) == -1)
-        {
-      log_OS_error("closedir");
-        }
-    }
-  depth--;
-  if (!depth)
-    {
-      close_evalcall_form ();
-      paranoid_free (name_of_evalcall_form);
-      paranoid_free(find_skeleton_marker);
-      unlink(g_skeleton_filelist);
-      log_msg(5, "g_skeleton_entries = %ld", g_skeleton_entries);
-    }
-  paranoid_free(tmp);
-  paranoid_free(sth_B);
-  paranoid_free(ith_B);
-  paranoid_free(new_with_spaces);
-  return(0);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (dip) {
+        if (closedir(dip) == -1) {
+            log_OS_error("closedir");
+        }
+    }
+    depth--;
+    if (!depth) {
+        close_evalcall_form();
+        paranoid_free(name_of_evalcall_form);
+        paranoid_free(find_skeleton_marker);
+        unlink(g_skeleton_filelist);
+        log_msg(5, "g_skeleton_entries = %ld", g_skeleton_entries);
+    }
+    paranoid_free(tmp);
+    paranoid_free(sth_B);
+    paranoid_free(ith_B);
+    paranoid_free(new_with_spaces);
+    return (0);
 }
 
@@ -1702 +1568 @@
  * @note The returned string points to static data that will be overwritten with each call.
  */
-char *next_entry(char*incoming)
-{
-  static char sz_res[MAX_STR_LEN];
-  char *p;
-  bool in_quotes=FALSE;
-
-  strcpy(sz_res, incoming);
-  p = sz_res;
-  while((*p!=' ' || in_quotes) && *p!='\0')
-    {
-      if (*p=='\"') { in_quotes = !in_quotes; }
-      p++;
-    }
-  *p = '\0';
-  return(sz_res);
+char *next_entry(char *incoming)
+{
+    static char sz_res[MAX_STR_LEN];
+    char *p;
+    bool in_quotes = FALSE;
+
+    strcpy(sz_res, incoming);
+    p = sz_res;
+    while ((*p != ' ' || in_quotes) && *p != '\0') {
+        if (*p == '\"') {
+            in_quotes = !in_quotes;
+        }
+        p++;
+    }
+    *p = '\0';
+    return (sz_res);
 }
 
@@ -1734 +1601 @@
  * @bug Return value is meaningless.
  */
-int mondo_makefilelist(char*logfile, char*tmpdir, char*scratchdir,
-    char*include_paths, char*excp, int differential, char *userdef_filelist)
+int mondo_makefilelist(char *logfile, char *tmpdir, char *scratchdir,
+                       char *include_paths, char *excp, int differential,
+                       char *userdef_filelist)
 {
     char sz_datefile_wildcard[] = "/var/cache/mondo-archive/difflevel.%d";
@@ -1742 +1610 @@
     char *sz_filelist, *exclude_paths, *tmp;
     int i;
-    FILE*fout;
+    FILE *fout;
     char *command;
-        time_t time_of_last_full_backup=0;
+    time_t time_of_last_full_backup = 0;
     struct stat statbuf;
 
-  malloc_string(command);
-  malloc_string(tmp);
-  malloc_string(sz_filelist);
-  malloc_string(g_skeleton_filelist);
-  if (!(exclude_paths = malloc(1000))) { fatal_error("Cannot malloc exclude_paths"); }
-  log_msg(3, "Trying to write test string to exclude_paths");
-  strcpy(exclude_paths, "/blah /froo");
-  log_msg(3, "...Success!");
-  sprintf(sz_datefile, sz_datefile_wildcard, 0);
-  if (!include_paths && !userdef_filelist)
-    { fatal_error("Please supply either include_paths or userdef_filelist"); }
-
+    malloc_string(command);
+    malloc_string(tmp);
+    malloc_string(sz_filelist);
+    malloc_string(g_skeleton_filelist);
+    if (!(exclude_paths = malloc(1000))) {
+        fatal_error("Cannot malloc exclude_paths");
+    }
+    log_msg(3, "Trying to write test string to exclude_paths");
+    strcpy(exclude_paths, "/blah /froo");
+    log_msg(3, "...Success!");
+    sprintf(sz_datefile, sz_datefile_wildcard, 0);
+    if (!include_paths && !userdef_filelist) {
+        fatal_error
+            ("Please supply either include_paths or userdef_filelist");
+    }
 // make hole for filelist
-  sprintf(command, "mkdir -p %s/archives", scratchdir);
-  paranoid_system(command);
-  sprintf(sz_filelist, "%s/tmpfs/filelist.full", tmpdir);
-  make_hole_for_file(sz_filelist);
-
-  if (differential==0)
-    {
-  // restore last good datefile if it exists
-      sprintf(command, "cp -f %s.aborted %s", sz_datefile, sz_datefile);
-      run_program_and_log_output(command, 3);
-  // backup last known good datefile just in case :)
-      if (does_file_exist(sz_datefile))
-        {
-          sprintf(command, "mv -f %s %s.aborted", sz_datefile, sz_datefile);
-          paranoid_system(command);
-        }
-      make_hole_for_file(sz_datefile);
-      write_one_liner_data_file(sz_datefile, call_program_and_get_last_line_of_output("date +%s"));
-    }
-  else if (lstat(sz_datefile, &statbuf))
-    {
-      log_msg(2, "Warning - unable to find date of previous backup. Full backup instead.");
-      differential = 0;
-      time_of_last_full_backup = 0;
-    }
-  else
-    {
-      time_of_last_full_backup = statbuf.st_mtime;
-      log_msg(2, "Differential backup. Yay.");
-    }
+    sprintf(command, "mkdir -p %s/archives", scratchdir);
+    paranoid_system(command);
+    sprintf(sz_filelist, "%s/tmpfs/filelist.full", tmpdir);
+    make_hole_for_file(sz_filelist);
+
+    if (differential == 0) {
+        // restore last good datefile if it exists
+        sprintf(command, "cp -f %s.aborted %s", sz_datefile, sz_datefile);
+        run_program_and_log_output(command, 3);
+        // backup last known good datefile just in case :)
+        if (does_file_exist(sz_datefile)) {
+            sprintf(command, "mv -f %s %s.aborted", sz_datefile,
+                    sz_datefile);
+            paranoid_system(command);
+        }
+        make_hole_for_file(sz_datefile);
+        write_one_liner_data_file(sz_datefile,
+                                  call_program_and_get_last_line_of_output
+                                  ("date +%s"));
+    } else if (lstat(sz_datefile, &statbuf)) {
+        log_msg(2,
+                "Warning - unable to find date of previous backup. Full backup instead.");
+        differential = 0;
+        time_of_last_full_backup = 0;
+    } else {
+        time_of_last_full_backup = statbuf.st_mtime;
+        log_msg(2, "Differential backup. Yay.");
+    }
 
 // use user-specified filelist (if specified)
-  if (userdef_filelist)
-    {
-      log_msg(1, "Using the user-specified filelist - %s - instead of calculating one", userdef_filelist);
-      sprintf(command, "cp -f %s %s", userdef_filelist, sz_filelist);
-      if (run_program_and_log_output(command, 3))
-        { fatal_error("Failed to copy user-specified filelist"); }
-    }
-  else
-    {
-      log_msg(2, "include_paths = '%s'", include_paths);
-      log_msg(1, "Calculating filelist");
-      sprintf(exclude_paths, " %s %s %s %s %s %s . .. \
-"MNT_CDROM" "MNT_FLOPPY" /media/cdrom /media/cdrecorder \
-/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
-                        );
-
-    log_msg(2, "Excluding paths = '%s'", exclude_paths);
-    log_msg(2, "Generating skeleton filelist so that we can track our progress");
-    sprintf(g_skeleton_filelist, "%s/tmpfs/skeleton.txt", tmpdir);
-    make_hole_for_file(g_skeleton_filelist);
-    log_msg(4, "g_skeleton_entries = %ld", g_skeleton_entries);
-    log_msg(2, "Opening out filelist to %s", sz_filelist);
-    if (!(fout = fopen(sz_filelist, "w"))) { fatal_error("Cannot openout to sz_filelist"); }
-    i = 0;
-    if (strlen(include_paths)==0)
-        {
-          log_msg(1, "Including only '/' in %s", sz_filelist);
-        open_and_list_dir("/", exclude_paths, fout, time_of_last_full_backup);
-        }
-    else
-        {
-        p = include_paths;
-        while(*p)
-            {
-            q = next_entry(p);
-            log_msg(1, "Including %s in filelist %s", q, sz_filelist);
-            open_and_list_dir(q, exclude_paths, fout, time_of_last_full_backup);
-            p += strlen(q);
-            while(*p==' ') { p++; }
+    if (userdef_filelist) {
+        log_msg(1,
+                "Using the user-specified filelist - %s - instead of calculating one",
+                userdef_filelist);
+        sprintf(command, "cp -f %s %s", userdef_filelist, sz_filelist);
+        if (run_program_and_log_output(command, 3)) {
+            fatal_error("Failed to copy user-specified filelist");
+        }
+    } else {
+        log_msg(2, "include_paths = '%s'", include_paths);
+        log_msg(1, "Calculating filelist");
+        sprintf(exclude_paths, " %s %s %s %s %s %s . .. \
+" MNT_CDROM " " MNT_FLOPPY " /media/cdrom /media/cdrecorder \
+/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);
+
+        log_msg(2, "Excluding paths = '%s'", exclude_paths);
+        log_msg(2,
+                "Generating skeleton filelist so that we can track our progress");
+        sprintf(g_skeleton_filelist, "%s/tmpfs/skeleton.txt", tmpdir);
+        make_hole_for_file(g_skeleton_filelist);
+        log_msg(4, "g_skeleton_entries = %ld", g_skeleton_entries);
+        log_msg(2, "Opening out filelist to %s", sz_filelist);
+        if (!(fout = fopen(sz_filelist, "w"))) {
+            fatal_error("Cannot openout to sz_filelist");
+        }
+        i = 0;
+        if (strlen(include_paths) == 0) {
+            log_msg(1, "Including only '/' in %s", sz_filelist);
+            open_and_list_dir("/", exclude_paths, fout,
+                              time_of_last_full_backup);
+        } else {
+            p = include_paths;
+            while (*p) {
+                q = next_entry(p);
+                log_msg(1, "Including %s in filelist %s", q, sz_filelist);
+                open_and_list_dir(q, exclude_paths, fout,
+                                  time_of_last_full_backup);
+                p += strlen(q);
+                while (*p == ' ') {
+                    p++;
+                }
             }
         }
-    paranoid_fclose(fout);
-    }
-  log_msg(2, "Copying new filelist to scratchdir");
-  sprintf(command, "mkdir -p %s/archives", scratchdir);
-  paranoid_system(command);
-  sprintf(command, "cp -f %s %s/archives/", sz_filelist, scratchdir);
-  paranoid_system(command);
-  sprintf(command, "mv -f %s %s", sz_filelist, tmpdir);
-  paranoid_system(command);
-  log_msg(2, "Freeing variables");
-  paranoid_free(sz_filelist);
-  paranoid_free(command);
-  paranoid_free(exclude_paths);
-  paranoid_free(tmp);
-  paranoid_free(g_skeleton_filelist);
-  log_msg(2, "Exiting");
-  return(0);
+        paranoid_fclose(fout);
+    }
+    log_msg(2, "Copying new filelist to scratchdir");
+    sprintf(command, "mkdir -p %s/archives", scratchdir);
+    paranoid_system(command);
+    sprintf(command, "cp -f %s %s/archives/", sz_filelist, scratchdir);
+    paranoid_system(command);
+    sprintf(command, "mv -f %s %s", sz_filelist, tmpdir);
+    paranoid_system(command);
+    log_msg(2, "Freeing variables");
+    paranoid_free(sz_filelist);
+    paranoid_free(command);
+    paranoid_free(exclude_paths);
+    paranoid_free(tmp);
+    paranoid_free(g_skeleton_filelist);
+    log_msg(2, "Exiting");
+    return (0);
 }
 
@@ -1868 +1733 @@
  * it was not found.
  */
-struct s_node *find_string_at_node (struct s_node *startnode, char *string_to_find)
-{
-    /*@ int *********************************************************/
-  int noof_chars;
-  static int depth=0;
-  static char original_string[MAX_STR_LEN];
-
-    /*@ sturctures **************************************************/
-  struct s_node *node;
-
-    /*@ char  *******************************************************/
-  char char_to_find;
-
-    /*@ bools *******************************************************/
-
-  if (!depth) { strcpy(original_string, string_to_find); }
-
-  assert(startnode!=NULL);
-  assert(string_to_find!=NULL);
-
-  noof_chars = strlen (string_to_find) + 1; /* we include the '\0' */
-
-  log_msg(7, "starting --- str=%s", string_to_find);
+struct s_node *find_string_at_node(struct s_node *startnode,
+                                   char *string_to_find)
+{
+    /*@ int ******************************************************** */
+    int noof_chars;
+    static int depth = 0;
+    static char original_string[MAX_STR_LEN];
+
+    /*@ sturctures ************************************************* */
+    struct s_node *node;
+
+    /*@ char  ****************************************************** */
+    char char_to_find;
+
+    /*@ bools ****************************************************** */
+
+    if (!depth) {
+        strcpy(original_string, string_to_find);
+    }
+
+    assert(startnode != NULL);
+    assert(string_to_find != NULL);
+
+    noof_chars = strlen(string_to_find) + 1;    /* we include the '\0' */
+
+    log_msg(7, "starting --- str=%s", string_to_find);
 
 /* walk across tree if necessary */
-  node = startnode;
-  char_to_find = string_to_find[0];
-  if (node->right != NULL && node->ch < char_to_find)
-    {
-      log_msg(7, "depth=%d --- going RIGHT ... %c-->%c", depth, char_to_find, node->ch, (node->right)->ch);
-      return (find_string_at_node (node->right, string_to_find));
-    }
+    node = startnode;
+    char_to_find = string_to_find[0];
+    if (node->right != NULL && node->ch < char_to_find) {
+        log_msg(7, "depth=%d --- going RIGHT ... %c-->%c", depth,
+                char_to_find, node->ch, (node->right)->ch);
+        return (find_string_at_node(node->right, string_to_find));
+    }
 
 /* walk down tree if appropriate */
-  if (node->down != NULL && node->ch == char_to_find)
-    {
-      log_msg(7, "depth=%d char=%c --- going DOWN", depth, char_to_find);
-      depth++;
-      node = find_string_at_node (node->down, string_to_find + 1);
-      depth--;
-      return (node);
-    }
-
-  if (char_to_find == '\0' && node->ch =='\0')
-    {
-      log_msg(7, "%s is in tree", original_string);
-      return(node);
-    }
-  else
-    {
-      log_msg(7, "%s is NOT in tree", original_string);
-      return(NULL);
-    }
+    if (node->down != NULL && node->ch == char_to_find) {
+        log_msg(7, "depth=%d char=%c --- going DOWN", depth, char_to_find);
+        depth++;
+        node = find_string_at_node(node->down, string_to_find + 1);
+        depth--;
+        return (node);
+    }
+
+    if (char_to_find == '\0' && node->ch == '\0') {
+        log_msg(7, "%s is in tree", original_string);
+        return (node);
+    } else {
+        log_msg(7, "%s is NOT in tree", original_string);
+        return (NULL);
+    }
 }
 
@@ -1933 +1797 @@
  * @return The number of matches found.
  */
-long save_filelist_entries_in_common(
-            char*needles_list_fname,
-            struct s_node *filelist,
-            char*matches_list_fname, bool use_star)
-{
-  int retval=0;
-  struct s_node *found_node;
-  FILE*fin;
-  FILE*fout;
-  char *fname;
-  char *tmp;
-  size_t len = 0; // Scrub's patch doesn't work without that
+long save_filelist_entries_in_common(char *needles_list_fname,
+                                     struct s_node *filelist,
+                                     char *matches_list_fname,
+                                     bool use_star)
+{
+    int retval = 0;
+    struct s_node *found_node;
+    FILE *fin;
+    FILE *fout;
+    char *fname = NULL;
+    char *tmp;
+    size_t len = 0;             // Scrub's patch doesn't work without that
 
 //  log_msg(1, "use_star = %s", (use_star)?"TRUE":"FALSE");
-  malloc_string(fname);
-  malloc_string(tmp);
-  log_msg(5, "starting");
-  log_msg(5, "needles_list_fname = %s", needles_list_fname);
-  log_msg(5, "matches_list_fname = %s", matches_list_fname);
-  if (!(fin = fopen(needles_list_fname, "r"))) { fatal_error("Cannot openin needles_list_fname"); }
-  if (!(fout= fopen(matches_list_fname, "w"))) { fatal_error("Cannot openout matches_list_fname"); }
-  while(!feof(fin))
-    {
-//      fscanf(fin, "%s\n", fname);
-      len = MAX_STR_LEN-1;
-      getline(& fname, & len, fin); // patch by Scrub
-      if (!use_star)
-        {
-      if (fname[0]=='/')
-        { strcpy(tmp, fname); }
-      else
-        {
-          tmp[0]='/';
-          strcpy(tmp+1, fname);
-        }
-      strcpy(fname, tmp);
-        }
-      while (strlen(fname)>0 && fname[strlen(fname)-1]<32) { fname[strlen(fname)-1] = '\0'; }
+    log_msg(5, "starting");
+    log_msg(5, "needles_list_fname = %s", needles_list_fname);
+    log_msg(5, "matches_list_fname = %s", matches_list_fname);
+    if (!(fin = fopen(needles_list_fname, "r"))) {
+        fatal_error("Cannot openin needles_list_fname");
+    }
+    if (!(fout = fopen(matches_list_fname, "w"))) {
+        fatal_error("Cannot openout matches_list_fname");
+    }
+    while (!feof(fin)) {
+        getline(&fname, &len, fin);
+        if (!use_star) {
+            if (fname[0] == '/') {
+                asprintf(&tmp, fname);
+            } else {
+                asprintf(&tmp, "/%s", fname);
+            }
+            paranoid_free(fname);
+            asprintf(&fname, tmp);
+            paranoid_free(tmp);
+        }
+        while (strlen(fname) > 0 && fname[strlen(fname) - 1] < 32) {
+            fname[strlen(fname) - 1] = '\0';
+        }
 
 /*
@@ -1977 +1841 @@
       sprintf(temporary_string, "echo \"Looking for '%s'\" >> /tmp/looking.txt", fname);
       system(temporary_string);
-*/      
-      
-      log_msg(5, "Looking for '%s'", fname);
-      found_node = find_string_at_node(filelist, fname);
-      if (found_node)
-        {
-      if (found_node->selected)
-        {
-//              if (use_star)
-              if (fname[0]=='/')
-            {
-          strcpy(tmp, fname+1);
-          strcpy(fname, tmp);
-        }
-          log_msg(5, "Found '%s'", fname);
-          turn_wildcard_chars_into_literal_chars(tmp, fname);
-          fprintf(fout, "%s\n", tmp);
-          retval++;
-        }
-    }
-    }
-  paranoid_fclose(fout);
-  paranoid_fclose(fin);
-  paranoid_free(fname);
-  paranoid_free(tmp);
-  return(retval);
+*/
+
+        log_msg(5, "Looking for '%s'", fname);
+        found_node = find_string_at_node(filelist, fname);
+        if (found_node) {
+            if (found_node->selected) {
+                if (fname[0] == '/') {
+                    asprintf(&tmp, fname + 1);
+                    paranoid_free(fname);
+                    asprintf(&fname, tmp);
+                    paranoid_free(tmp);
+                }
+                log_msg(5, "Found '%s'", fname);
+                turn_wildcard_chars_into_literal_chars(tmp, fname);
+                fprintf(fout, "%s\n", tmp);
+                retval++;
+            }
+        }
+    paranoid_free(fname);
+    }
+    paranoid_fclose(fout);
+    paranoid_fclose(fin);
+    return (retval);
 }
 
@@ -2018 +1879 @@
  * @return 0 for success, nonzero for failure.
  */
-int add_list_of_files_to_filelist(struct s_node *filelist, char*list_of_files_fname, bool flag_em)
-{
-  FILE*fin;
-  char*tmp;
-  struct s_node *nod;
-
-  malloc_string(tmp);
-  log_msg(3, "Adding %s to filelist", list_of_files_fname);
-  if (!(fin=fopen(list_of_files_fname,"r"))) { iamhere(list_of_files_fname); return(1); }
-  for (fgets (tmp, MAX_STR_LEN, fin); !feof(fin);
-       fgets (tmp, MAX_STR_LEN, fin))
-    {
-      if (!tmp[0]) { continue; }
-      if ((tmp[strlen(tmp)-1]==13 || tmp[strlen(tmp)-1]==10) && strlen(tmp)>0)
-        { tmp[strlen(tmp)-1] = '\0'; }
-      log_msg(2, "tmp = '%s'", tmp);
-      if (!tmp[0]) { continue; }
-      if ((nod = find_string_at_node (filelist, tmp)))
-        {
-      log_msg(5, "Found '%s' in filelist already. Cool.", tmp);
-        }
-      else
-        {
-      add_string_at_node (filelist, tmp);
-          nod = find_string_at_node (filelist, tmp);
-        }
-
-      if (nod && flag_em)
-        {
-      toggle_path_selection(filelist, tmp, TRUE);
-      log_msg (5, "Flagged '%s'", tmp);
-    }
-    }
-  paranoid_fclose(fin);
-  paranoid_free(tmp);
-  return(0);
+int add_list_of_files_to_filelist(struct s_node *filelist,
+                                  char *list_of_files_fname, bool flag_em)
+{
+    FILE *fin;
+    char *tmp;
+    struct s_node *nod;
+
+    malloc_string(tmp);
+    log_msg(3, "Adding %s to filelist", list_of_files_fname);
+    if (!(fin = fopen(list_of_files_fname, "r"))) {
+        iamhere(list_of_files_fname);
+        return (1);
+    }
+    for (fgets(tmp, MAX_STR_LEN, fin); !feof(fin);
+         fgets(tmp, MAX_STR_LEN, fin)) {
+        if (!tmp[0]) {
+            continue;
+        }
+        if ((tmp[strlen(tmp) - 1] == 13 || tmp[strlen(tmp) - 1] == 10)
+            && strlen(tmp) > 0) {
+            tmp[strlen(tmp) - 1] = '\0';
+        }
+        log_msg(2, "tmp = '%s'", tmp);
+        if (!tmp[0]) {
+            continue;
+        }
+        if ((nod = find_string_at_node(filelist, tmp))) {
+            log_msg(5, "Found '%s' in filelist already. Cool.", tmp);
+        } else {
+            add_string_at_node(filelist, tmp);
+            nod = find_string_at_node(filelist, tmp);
+        }
+
+        if (nod && flag_em) {
+            toggle_path_selection(filelist, tmp, TRUE);
+            log_msg(5, "Flagged '%s'", tmp);
+        }
+    }
+    paranoid_fclose(fin);
+    paranoid_free(tmp);
+    return (0);
 }
 

trunk/mondo/mondo/common/libmondo-mountlist.c

@@ -914 +914 @@
     int items;
     int j;
-    int n = 0;
+    size_t n = 0;
 
     assert(mountlist != NULL);

trunk/mondo/mondo/common/libmondo-string.c

@@ -128 +128 @@
     assert(input != NULL);
 
-    asprintf(tmp, "%s", input);
+    asprintf(&tmp, "%s", input);
     if (strlen(tmp) > 6) {
         asprintf(&pos_w_commas, "%s", tmp);
@@ -250 +250 @@
     assert(width > 2);
 
-    asprintf(output, "%s", incoming);
+    asprintf(&output, "%s", incoming);
     for (i = (int) strlen(output); i < width; i++) {
         output[i] = ' ';

trunk/mondo/mondo/common/libmondo-tools.c

@@ -1 +1 @@
 /* libmondo-tools.c                                  misc tools
-   $Id: libmondo-tools.c,v 1.14 2004/06/19 01:36:07 hugo Exp $
+   $Id$
 .
 
@@ -186 +186 @@
 
 /*@unused@*/
-//static char cvsid[] = "$Id: libmondo-tools.c,v 1.14 2004/06/19 01:36:07 hugo Exp $";
+//static char cvsid[] = "$Id$";
 
 extern int g_tape_buffer_size_MB;
@@ -199 +199 @@
  * @{
  */
-bool g_remount_cdrom_at_end, ///< TRUE if we unmounted the CD-ROM and should remount it when done with the backup.
-    g_remount_floppy_at_end; ///< TRUE if we unmounted the floppy and should remount it when done with the backup.
-bool g_cd_recovery; ///< TRUE if we're making an "autonuke" backup.
+bool g_remount_cdrom_at_end,    ///< TRUE if we unmounted the CD-ROM and should remount it when done with the backup.
+ g_remount_floppy_at_end;       ///< TRUE if we unmounted the floppy and should remount it when done with the backup.
+bool g_cd_recovery;             ///< TRUE if we're making an "autonuke" backup.
 double g_kernel_version;
 
@@ -207 +207 @@
  * The place where /boot is mounted.
  */
-char *g_boot_mountpt=NULL;
+char *g_boot_mountpt = NULL;
 
 /**
  * The location of Mondo's home directory.
  */
-char *g_mondo_home=NULL;
+char *g_mondo_home = NULL;
 
 /**
  * The serial string (used to differentiate between backups) of the current backup.
  */
-char *g_serial_string=NULL;
+char *g_serial_string = NULL;
 
 /**
  * The location where tmpfs is mounted, or "" if it's not mounted.
  */
-char *g_tmpfs_mountpt=NULL;
-char *g_magicdev_command=NULL;
+char *g_tmpfs_mountpt = NULL;
+char *g_magicdev_command = NULL;
 
 /**
  * The default maximum level to log messages at or below.
  */
-int g_loglevel=DEFAULT_DEBUG_LEVEL;
+int g_loglevel = DEFAULT_DEBUG_LEVEL;
 
 /* @} - end of globalGroup */
@@ -255 +255 @@
  * @param exp The expression that failed (as a string).
  */
-void _mondo_assert_fail (const char *file,
-             const char *function,
-             int         line,
-             const char *exp) 
-{
-    static int ignoring_assertions = 0;
-    bool is_valid = TRUE;
-
-    log_it ("ASSERTION FAILED: `%s' at %s:%d in %s", exp, file, line, function);
-    if (ignoring_assertions) {
-    log_it ("Well, the user doesn't care...");
-    return;
-    }
-
+void _mondo_assert_fail(const char *file,
+                        const char *function, int line, const char *exp)
+{
+    static int ignoring_assertions = 0;
+    bool is_valid = TRUE;
+
+    log_it("ASSERTION FAILED: `%s' at %s:%d in %s", exp, file, line,
+           function);
+    if (ignoring_assertions) {
+        log_it("Well, the user doesn't care...");
+        return;
+    }
 #ifndef _XWIN
-    if (!g_text_mode)
-    newtSuspend();
-#endif
-    printf ("ASSERTION FAILED: `%s'\n", exp);
-    printf ("\tat %s:%d in %s\n\n", file, line, function);
-    printf ("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? ");
-    do {
-    is_valid = TRUE;
-    switch (toupper (getchar())) {
-    case 'A': // ignore (A)ll
-        ignoring_assertions = 1;
-        break;
-    case 'B': // a(B)ort
-        signal (SIGABRT, SIG_DFL); /* prevent SIGABRT handler from running */
-        raise (SIGABRT);
-        break;          /* "can't get here" */
-    case 'D': // (D)ebug, aka asm("int 3")
+    if (!g_text_mode)
+        newtSuspend();
+#endif
+    printf("ASSERTION FAILED: `%s'\n", exp);
+    printf("\tat %s:%d in %s\n\n", file, line, function);
+    printf("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? ");
+    do {
+        is_valid = TRUE;
+        switch (toupper(getchar())) {
+        case 'A':               // ignore (A)ll
+            ignoring_assertions = 1;
+            break;
+        case 'B':               // a(B)ort
+            signal(SIGABRT, SIG_DFL);   /* prevent SIGABRT handler from running */
+            raise(SIGABRT);
+            break;              /* "can't get here" */
+        case 'D':               // (D)ebug, aka asm("int 3")
 #ifdef __IA32__
-        __asm__ __volatile__ ("int $3"); // break to debugger
-#endif
-        break;
-    case 'E': // (E)xit
-        fatal_error ("Failed assertion -- see above for details");
-        break;          /* "can't get here" */
-    case 'I': // (I)gnore
-        break;
-    /* These next two work as follows:
-       the `default' catches the user's invalid choice and says so;
-       the '\n' catches the newline on the end and prints the prompt again.
-    */
-    case '\n':
-        printf ("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? ");
-        break;
-    default:
-        is_valid = FALSE;
-        printf ("Invalid choice.\n");
-        break;
-    }
-    } while (!is_valid);
-
-    if (ignoring_assertions) {
-    log_it ("Ignoring ALL assertions from now on.");
-    } else {
-    log_it ("Ignoring assertion: %s", exp);
-    }
-
-    getchar(); // skip \n
+            __asm__ __volatile__("int $3"); // break to debugger
+#endif
+            break;
+        case 'E':               // (E)xit
+            fatal_error("Failed assertion -- see above for details");
+            break;              /* "can't get here" */
+        case 'I':               // (I)gnore
+            break;
+            /* These next two work as follows:
+               the `default' catches the user's invalid choice and says so;
+               the '\n' catches the newline on the end and prints the prompt again.
+             */
+        case '\n':
+            printf
+                ("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? ");
+            break;
+        default:
+            is_valid = FALSE;
+            printf("Invalid choice.\n");
+            break;
+        }
+    } while (!is_valid);
+
+    if (ignoring_assertions) {
+        log_it("Ignoring ALL assertions from now on.");
+    } else {
+        log_it("Ignoring assertion: %s", exp);
+    }
+
+    getchar();                  // skip \n
 
 #ifndef _XWIN
-    if (!g_text_mode)
-    newtResume();
+    if (!g_text_mode)
+        newtResume();
 #endif
 }
@@ -330 +329 @@
 void clean_up_KDE_desktop_if_necessary(void)
 {
-  char *tmp;
-
-  malloc_string(tmp);
-  strcpy(tmp, "for i in `find /root /home -type d -name Desktop -maxdepth 2`; do \
+    char *tmp;
+
+    malloc_string(tmp);
+    strcpy(tmp,
+           "for i in `find /root /home -type d -name Desktop -maxdepth 2`; do \
 file=$i/.directory; if [ -f \"$file\" ] ; then mv -f $file $file.old ; \
 cat $file.old | awk '{if (index($0, \"rootimagesmindi\")) { while (length($0)>2) { getline;} ; } \
 else { print $0;};}' > $file ; fi ; done");
-  run_program_and_log_output(tmp, 5);
-  paranoid_free(tmp);
+    run_program_and_log_output(tmp, 5);
+    paranoid_free(tmp);
 }
 
@@ -351 +351 @@
 int find_and_store_mondoarchives_home(char *home_sz)
 {
-  assert(home_sz!=NULL);
-  strcpy (home_sz,
-      call_program_and_get_last_line_of_output
-      ("find /usr/lib/ /usr/local/ /usr/share/ /usr/local/share/ /opt/ /ramdisk/usr/share/ -type d -maxdepth 2 -name include -prune -o -type d -maxdepth 2 -path '*/mondo/restore-scripts' -printf '%h\n' 2> /dev/null"));
-
-  if (home_sz[0] == '\0')
-    {
-      strcpy (home_sz,
-          call_program_and_get_last_line_of_output
-          ("find /usr -type d -path '*/mondo/restore-scripts' -follow -maxdepth 3 -printf '%h\n' 2> /dev/null"));
-    }
-  if (home_sz[0] == '\0')
-    {
-      return(1);
-    }
-  else
-    {
-      return(0);
-    }
+    assert(home_sz != NULL);
+    strcpy(home_sz,
+           call_program_and_get_last_line_of_output
+           ("find /usr/lib/ /usr/local/ /usr/share/ /usr/local/share/ /opt/ /ramdisk/usr/share/ -type d -maxdepth 2 -name include -prune -o -type d -maxdepth 2 -path '*/mondo/restore-scripts' -printf '%h\n' 2> /dev/null"));
+
+    if (home_sz[0] == '\0') {
+        strcpy(home_sz,
+               call_program_and_get_last_line_of_output
+               ("find /usr -type d -path '*/mondo/restore-scripts' -follow -maxdepth 3 -printf '%h\n' 2> /dev/null"));
+    }
+    if (home_sz[0] == '\0') {
+        return (1);
+    } else {
+        return (0);
+    }
 }
 
@@ -376 +372 @@
 {
 #ifdef __IA32__
-    return("i386");
+    return ("i386");
 #endif
 #ifdef __IA64__
-    return("ia64");
-#endif
-    return("unknown");
+    return ("ia64");
+#endif
+    return ("unknown");
 }
 
@@ -388 +384 @@
 double get_kernel_version()
 {
-  char *p, tmp[200];
-  double d;
+    char *p, tmp[200];
+    double d;
 #ifdef __FreeBSD__
-  // JOSH - FIXME :)
-  d = 5.2; // :-)
+    // JOSH - FIXME :)
+    d = 5.2;                    // :-)
 #else
-  strcpy(tmp, call_program_and_get_last_line_of_output("uname -r"));
-  p = strchr(tmp, '.');
-  if (p)
-    {
-      p = strchr(++p, '.');
-      if (p)
-        {
-      while(*p) { *p=*(p+1); p++; }
-        }
-    }
+    strcpy(tmp, call_program_and_get_last_line_of_output("uname -r"));
+    p = strchr(tmp, '.');
+    if (p) {
+        p = strchr(++p, '.');
+        if (p) {
+            while (*p) {
+                *p = *(p + 1);
+                p++;
+            }
+        }
+    }
 //  log_msg(1, "tmp = '%s'", tmp);
-  d = atof(tmp);
-#endif
-  log_msg(1, "g_kernel_version = %f", d);
-  return(d);
+    d = atof(tmp);
+#endif
+    log_msg(1, "g_kernel_version = %f", d);
+    return (d);
 }
 
@@ -419 +416 @@
  * @return number of seconds since the epoch.
  */
-long
-get_time ()
+long get_time()
 {
 
 #if 0
 
-    /*@ pointers *****************************************************/
-  FILE *fin;
-
-    /*@ buffers ******************************************************/
-  char incoming[MAX_STR_LEN];
-
-    /*@ end vars *****************************************************/
-
-  if (!(fin = popen ("date +%s", "r"))) { log_OS_error("Cannot popen date"); return(0); }
-  fgets (incoming, MAX_STR_LEN - 1, fin);
-  paranoid_pclose (fin);
-  return (atol (incoming));
+    /*@ pointers **************************************************** */
+    FILE *fin;
+
+    /*@ buffers ***************************************************** */
+    char incoming[MAX_STR_LEN];
+
+    /*@ end vars **************************************************** */
+
+    if (!(fin = popen("date +%s", "r"))) {
+        log_OS_error("Cannot popen date");
+        return (0);
+    }
+    fgets(incoming, MAX_STR_LEN - 1, fin);
+    paranoid_pclose(fin);
+    return (atol(incoming));
 #else
-  return (long) time ((void *) 0);
+    return (long) time((void *) 0);
 #endif
 }
@@ -456 +455 @@
  */
 #ifdef __FreeBSD__
-void initialize_raidrec (struct vinum_volume *raidrec)
-{
-  int i, j;
-  raidrec->volname[0] = '\0';
-  raidrec->plexes = 0;
-  for (i = 0; i < 9; ++i) {
-    raidrec->plex[i].raidlevel = -1;
-    raidrec->plex[i].stripesize = 0;
-    raidrec->plex[i].subdisks = 0;
-    for (j = 0; j < 9; ++j) {
-       strcpy (raidrec->plex[i].sd[j].which_device, "");
-    }
-  }
+void initialize_raidrec(struct vinum_volume *raidrec)
+{
+    int i, j;
+    raidrec->volname[0] = '\0';
+    raidrec->plexes = 0;
+    for (i = 0; i < 9; ++i) {
+        raidrec->plex[i].raidlevel = -1;
+        raidrec->plex[i].stripesize = 0;
+        raidrec->plex[i].subdisks = 0;
+        for (j = 0; j < 9; ++j) {
+            strcpy(raidrec->plex[i].sd[j].which_device, "");
+        }
+    }
 }
 #else
-void initialize_raidrec (struct raid_device_record *raidrec)
-{
-  assert(raidrec!=NULL);
-  raidrec->raid_device[0] = '\0';
-  raidrec->raid_level = 0;
-  raidrec->chunk_size = 4;
-  raidrec->persistent_superblock = 1;
-  raidrec->data_disks.entries = 0;
-  raidrec->spare_disks.entries = 0;
-  raidrec->parity_disks.entries = 0;
-  raidrec->failed_disks.entries = 0;
-  raidrec->additional_vars.entries = 0;
+void initialize_raidrec(struct raid_device_record *raidrec)
+{
+    assert(raidrec != NULL);
+    raidrec->raid_device[0] = '\0';
+    raidrec->raid_level = 0;
+    raidrec->chunk_size = 4;
+    raidrec->persistent_superblock = 1;
+    raidrec->data_disks.entries = 0;
+    raidrec->spare_disks.entries = 0;
+    raidrec->parity_disks.entries = 0;
+    raidrec->failed_disks.entries = 0;
+    raidrec->additional_vars.entries = 0;
 }
 #endif
@@ -497 +496 @@
 {
 #ifdef __FreeBSD__
-  system("kldstat | grep msdosfs || kldload msdosfs 2> /dev/null");
-  system("kldstat | grep ext2fs  || kldload ext2fs 2> /dev/null");
+    system("kldstat | grep msdosfs || kldload msdosfs 2> /dev/null");
+    system("kldstat | grep ext2fs  || kldload ext2fs 2> /dev/null");
 #else
-  system("modprobe dos &> /dev/null");
-  system("modprobe fat &> /dev/null");
-  system("modprobe vfat &> /dev/null");
-  //  system("modprobe osst &> /dev/null");
+    system("modprobe dos &> /dev/null");
+    system("modprobe fat &> /dev/null");
+    system("modprobe vfat &> /dev/null");
+    //  system("modprobe osst &> /dev/null");
 #endif
 }
@@ -512 +511 @@
  * @bug This function seems orphaned. Please remove.
  */
-void
-log_trace (char *o)
-{
-    /*@ pointers *****************************************************/
-  FILE *fout;
-
-    /*@ buffers ******************************************************/
-  char output[MAX_STR_LEN];
-
-    /*@ int    *******************************************************/
-  int i;
-
-    /*@ end vars ****************************************************/
-
-  if (o[0] == '\0')
-    {
-      return;
-    }
-  strcpy (output, o);
-  i = (int) strlen (output);
-  if (i <= 0)
-    {
-      return;
-    }
-  if (output[i - 1] < 32)
-    {
-      output[i - 1] = '\0';
-    }
-  if (g_text_mode /* && !strstr(last_line_of_file(MONDO_LOGFILE),output) */ )
-    {
-      printf ("%s\n", output);
-    }
-
-  fout = fopen (MONDO_TRACEFILE, "a");
-  if (fout)
-    {
-      fprintf (fout, "%s\n", output);
-      paranoid_fclose (fout);
-    }
-  else
-    {
-      log_OS_error( "Cannot write to tracefile" );
-    }
+void log_trace(char *o)
+{
+    /*@ pointers **************************************************** */
+    FILE *fout;
+
+    /*@ buffers ***************************************************** */
+    char output[MAX_STR_LEN];
+
+    /*@ int    ****************************************************** */
+    int i;
+
+    /*@ end vars *************************************************** */
+
+    if (o[0] == '\0') {
+        return;
+    }
+    strcpy(output, o);
+    i = (int) strlen(output);
+    if (i <= 0) {
+        return;
+    }
+    if (output[i - 1] < 32) {
+        output[i - 1] = '\0';
+    }
+    if (g_text_mode
+        /* && !strstr(last_line_of_file(MONDO_LOGFILE),output) */ ) {
+        printf("%s\n", output);
+    }
+
+    fout = fopen(MONDO_TRACEFILE, "a");
+    if (fout) {
+        fprintf(fout, "%s\n", output);
+        paranoid_fclose(fout);
+    } else {
+        log_OS_error("Cannot write to tracefile");
+    }
 }
 
@@ -592 +584 @@
  * do not exist.
  */
-int post_param_configuration (struct s_bkpinfo *bkpinfo)
-{
-  char *extra_cdrom_params;
-  char *mondo_mkisofs_sz;
-  char *command;
-  char *mtpt;
-  char *hostname, *ip_address;
-  int retval=0;
-  long avm = 0;
-  char *colon;
-  char *cdr_exe;
-  char *tmp;
-  int rdsiz_MB;
-      char *iso_dev;
-      char *iso_mnt;
-      char *iso_tmp;
-      char *iso_path;
-
-  assert(bkpinfo!=NULL);
-  malloc_string(extra_cdrom_params);
-  malloc_string(mondo_mkisofs_sz);
-  malloc_string(command);
-  malloc_string(mtpt);
-  malloc_string(hostname);
-  malloc_string(ip_address);
-  malloc_string(cdr_exe);
-  malloc_string(tmp);
-      malloc_string(iso_dev);
-      malloc_string(iso_mnt);
-      malloc_string(iso_tmp);
-      malloc_string(iso_path);
-  bkpinfo->optimal_set_size = (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)?4:8) * 1024;
-
-  log_msg(1, "Foo");
-  if (bkpinfo->backup_media_type == tape)
-    {
-      log_msg(1, "Bar");
-      sprintf(tmp, "mt -f %s status", bkpinfo->media_device);
-      log_msg(1, "tmp = '%s'", tmp);
-      if (run_program_and_log_output(tmp, 3))
-        {
-          fatal_error("Unable to open tape device. If you haven't specified it with -d, do so. If you already have, check your parameter. I think it's wrong.");
-    }
-    }    
-  make_hole_for_dir(bkpinfo->scratchdir);
-  make_hole_for_dir(bkpinfo->tmpdir);
-  if (bkpinfo->backup_media_type == iso)
-      make_hole_for_dir(bkpinfo->isodir);
-
-  run_program_and_log_output ("uname -a", 5);
-  run_program_and_log_output ("cat /etc/*issue*", 5);
-  sprintf(g_tmpfs_mountpt, "%s/tmpfs", bkpinfo->tmpdir);
-  sprintf(command, "mkdir -p %s", g_tmpfs_mountpt);
-  paranoid_system(command);
-  rdsiz_MB = PPCFG_RAMDISK_SIZE + g_tape_buffer_size_MB;
+int post_param_configuration(struct s_bkpinfo *bkpinfo)
+{
+    char *extra_cdrom_params;
+    char *mondo_mkisofs_sz;
+    char *command;
+    char *mtpt;
+    char *hostname, *ip_address;
+    int retval = 0;
+    long avm = 0;
+    char *colon;
+    char *cdr_exe;
+    char *tmp;
+    int rdsiz_MB;
+    char *iso_dev;
+    char *iso_mnt;
+    char *iso_tmp;
+    char *iso_path;
+
+    assert(bkpinfo != NULL);
+    malloc_string(extra_cdrom_params);
+    malloc_string(mondo_mkisofs_sz);
+    malloc_string(command);
+    malloc_string(mtpt);
+    malloc_string(hostname);
+    malloc_string(ip_address);
+    malloc_string(cdr_exe);
+    malloc_string(tmp);
+    malloc_string(iso_dev);
+    malloc_string(iso_mnt);
+    malloc_string(iso_tmp);
+    malloc_string(iso_path);
+    bkpinfo->optimal_set_size =
+        (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type) ? 4 : 8) *
+        1024;
+
+    log_msg(1, "Foo");
+    if (bkpinfo->backup_media_type == tape) {
+        log_msg(1, "Bar");
+        sprintf(tmp, "mt -f %s status", bkpinfo->media_device);
+        log_msg(1, "tmp = '%s'", tmp);
+        if (run_program_and_log_output(tmp, 3)) {
+            fatal_error
+                ("Unable to open tape device. If you haven't specified it with -d, do so. If you already have, check your parameter. I think it's wrong.");
+        }
+    }
+    make_hole_for_dir(bkpinfo->scratchdir);
+    make_hole_for_dir(bkpinfo->tmpdir);
+    if (bkpinfo->backup_media_type == iso)
+        make_hole_for_dir(bkpinfo->isodir);
+
+    run_program_and_log_output("uname -a", 5);
+    run_program_and_log_output("cat /etc/*issue*", 5);
+    sprintf(g_tmpfs_mountpt, "%s/tmpfs", bkpinfo->tmpdir);
+    sprintf(command, "mkdir -p %s", g_tmpfs_mountpt);
+    paranoid_system(command);
+    rdsiz_MB = PPCFG_RAMDISK_SIZE + g_tape_buffer_size_MB;
 #ifdef __FreeBSD__
-  strcpy(tmp, call_program_and_get_last_line_of_output("vmstat | tail -1 | tr -s ' ' | cut -d' ' -f6"));
-  avm += atol (tmp);
-  strcpy(tmp, call_program_and_get_last_line_of_output("swapinfo | grep -v Device | tr -s ' ' | cut -d' ' -f4 | tr '\n' '+' | sed 's/+$//' | bc"));
-  avm += atol (tmp);
-  sprintf(command, "mdmfs -s %d%c md9 %s", rdsiz_MB, 'm', g_tmpfs_mountpt);
+    strcpy(tmp,
+           call_program_and_get_last_line_of_output
+           ("vmstat | tail -1 | tr -s ' ' | cut -d' ' -f6"));
+    avm += atol(tmp);
+    strcpy(tmp,
+           call_program_and_get_last_line_of_output
+           ("swapinfo | grep -v Device | tr -s ' ' | cut -d' ' -f4 | tr '\n' '+' | sed 's/+$//' | bc"));
+    avm += atol(tmp);
+    sprintf(command, "mdmfs -s %d%c md9 %s", rdsiz_MB, 'm',
+            g_tmpfs_mountpt);
 #else
-  strcpy(tmp, call_program_and_get_last_line_of_output("free | grep \":\" | tr -s ' ' '\t' | cut -f2 | head -n1"));
-  avm += atol (tmp);
-  sprintf(command, "mount /dev/shm -t tmpfs %s -o size=%d%c", g_tmpfs_mountpt, rdsiz_MB, 'm');
-  run_program_and_log_output ("cat /proc/cpuinfo", 5);
-  run_program_and_log_output ("rpm -q newt newt-devel slang slang-devel ncurses ncurses-devel gcc", 5);
-#endif
-  if (avm/1024 > rdsiz_MB*3)
-    {
-      if (run_program_and_log_output(command, 5))
+    strcpy(tmp,
+           call_program_and_get_last_line_of_output
+           ("free | grep \":\" | tr -s ' ' '\t' | cut -f2 | head -n1"));
+    avm += atol(tmp);
+    sprintf(command, "mount /dev/shm -t tmpfs %s -o size=%d%c",
+            g_tmpfs_mountpt, rdsiz_MB, 'm');
+    run_program_and_log_output("cat /proc/cpuinfo", 5);
+    run_program_and_log_output
+        ("rpm -q newt newt-devel slang slang-devel ncurses ncurses-devel gcc",
+         5);
+#endif
+    if (avm / 1024 > rdsiz_MB * 3) {
+        if (run_program_and_log_output(command, 5)) {
+            g_tmpfs_mountpt[0] = '\0';
+            log_it("Failed to mount tmpfs");
+        } else {
+            log_it("Tmpfs mounted OK - %d MB", rdsiz_MB);
+        }
+    } else {
+        g_tmpfs_mountpt[0] = '\0';
+        log_it("It doesn't seem you have enough swap to use tmpfs. Fine.");
+    }
+
+    if (bkpinfo->use_lzo) {
+        strcpy(bkpinfo->zip_exe, "lzop");
+        strcpy(bkpinfo->zip_suffix, "lzo");
+    } else if (bkpinfo->compression_level != 0) {
+        strcpy(bkpinfo->zip_exe, "bzip2");
+        strcpy(bkpinfo->zip_suffix, "bz2");
+    } else {
+        bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
+    }
+
+// DVD
+
+    if (bkpinfo->backup_media_type == dvd) {
+        extra_cdrom_params[0] = '\0';
+        mondo_mkisofs_sz[0] = '\0';
+        if (find_home_of_exe("growisofs")) {
+            strcpy(cdr_exe, "growisofs");
+        }                       // unlikely to be used
+        else {
+            fatal_error("Please install growisofs.");
+        }
+        if (bkpinfo->nonbootable_backup) {
+            strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_NONBOOT);
+        } else if
+#ifdef __FreeBSD__
+            (TRUE)
+#else
+            (bkpinfo->make_cd_use_lilo)
+#endif
+#ifdef __IA64__
     {
-      g_tmpfs_mountpt[0] = '\0';
-      log_it("Failed to mount tmpfs");
-    }
-      else
+        strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_ELILO);
+    }
+#else
     {
-      log_it("Tmpfs mounted OK - %d MB", rdsiz_MB);
-    }
-    }
-  else
-    {
-      g_tmpfs_mountpt[0] = '\0';
-      log_it ("It doesn't seem you have enough swap to use tmpfs. Fine.");
-    }
-
-  if (bkpinfo->use_lzo)
-    {
-      strcpy (bkpinfo->zip_exe, "lzop");
-      strcpy (bkpinfo->zip_suffix, "lzo");
-    }
-  else if (bkpinfo->compression_level!=0)
-    {
-      strcpy (bkpinfo->zip_exe, "bzip2");
-      strcpy (bkpinfo->zip_suffix, "bz2");
-    }
-  else
-    {
-      bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
-    }
-
-// DVD
-
-  if (bkpinfo->backup_media_type == dvd)
-      {
-      extra_cdrom_params[0] = '\0';
-      mondo_mkisofs_sz[0] = '\0';
-      if (find_home_of_exe("growisofs"))
-    { strcpy(cdr_exe, "growisofs"); } // unlikely to be used
-      else
-        { fatal_error("Please install growisofs."); }
-      if (bkpinfo->nonbootable_backup)
-        { strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_NONBOOT); }
-      else if
+        strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_LILO);
+    }
+#endif
+        else
+        {
+            strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_SYSLINUX);
+        }
+        if (bkpinfo->manual_cd_tray) {
+            fatal_error("Manual CD tray + DVD not supported yet.");
+            // -m isn't supported by growisofs, BTW...
+        } else {
+            sprintf(bkpinfo->call_make_iso,
+                    "%s %s -Z %s . 2>> _ERR_",
+                    mondo_mkisofs_sz,
+                    extra_cdrom_params, bkpinfo->media_device);
+        }
+        log_msg(2, "call_make_iso (DVD res) is ... %s",
+                bkpinfo->call_make_iso);
+    }                           // end of DVD code
+
+// CD-R or CD-RW
+    if (bkpinfo->backup_media_type == cdrw
+        || bkpinfo->backup_media_type == cdr) {
+        extra_cdrom_params[0] = '\0';
+        if (!bkpinfo->manual_cd_tray) {
+            strcat(extra_cdrom_params, "-waiti ");
+        }
+        if (bkpinfo->backup_media_type == cdrw) {
+            strcat(extra_cdrom_params, "blank=fast ");
+        }
+        if (find_home_of_exe("cdrecord")) {
+            strcpy(cdr_exe, "cdrecord");
+        } else if (find_home_of_exe("dvdrecord")) {
+            strcpy(cdr_exe, "dvdrecord");
+        } else {
+            fatal_error("Please install either cdrecord or dvdrecord.");
+        }
+        if (bkpinfo->nonbootable_backup) {
+            strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_NONBOOT);
+        } else if
 #ifdef __FreeBSD__
-        (TRUE)
+            (TRUE)
 #else
-        (bkpinfo->make_cd_use_lilo)
+            (bkpinfo->make_cd_use_lilo)
 #endif
 #ifdef __IA64__
-        { strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_ELILO); }
+    {
+        strcat(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_ELILO);
+    }
 #else
-        { strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_LILO); }
-#endif
-      else
-        { strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_SYSLINUX); }
-      if (bkpinfo->manual_cd_tray)
     {
-      fatal_error("Manual CD tray + DVD not supported yet.");
-      // -m isn't supported by growisofs, BTW...
-    }
-      else
-    {
-      sprintf (bkpinfo->call_make_iso,
-           "%s %s -Z %s . 2>> _ERR_",
-           mondo_mkisofs_sz,
-           extra_cdrom_params,
-           bkpinfo->media_device);
-        }
-      log_msg(2, "call_make_iso (DVD res) is ... %s", bkpinfo->call_make_iso);
-    } // end of DVD code
-
-// CD-R or CD-RW
-  if (bkpinfo->backup_media_type == cdrw || bkpinfo->backup_media_type == cdr)
-    {
-      extra_cdrom_params[0] = '\0';
-      if (!bkpinfo->manual_cd_tray)
-    {
-      strcat (extra_cdrom_params, "-waiti ");
-    }
-      if (bkpinfo->backup_media_type == cdrw)
-    {
-      strcat (extra_cdrom_params, "blank=fast ");
-    }
-      if (find_home_of_exe("cdrecord"))
-    { strcpy(cdr_exe, "cdrecord"); }
-      else if (find_home_of_exe("dvdrecord"))
-    { strcpy(cdr_exe, "dvdrecord"); }
-      else
-        { fatal_error("Please install either cdrecord or dvdrecord."); }
-      if (bkpinfo->nonbootable_backup)
-        { strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_NONBOOT); }
-      else if
-#ifdef __FreeBSD__
-        (TRUE)
-#else
-        (bkpinfo->make_cd_use_lilo)
-#endif
-#ifdef __IA64__
-        { strcat(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_ELILO); }
-#else
-        { strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_LILO); }
-#endif
-      else
-        { strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_SYSLINUX); }
-      if (bkpinfo->manual_cd_tray)
-    {
-      sprintf (bkpinfo->call_before_iso,
-           "%s -o %s/temporary.iso . 2>> _ERR_", mondo_mkisofs_sz, bkpinfo->tmpdir);
-      sprintf (bkpinfo->call_make_iso,
-           "%s %s -v %s fs=4m dev=%s speed=%d %s/temporary.iso",
-           cdr_exe,
-           (bkpinfo->please_dont_eject)?" ":"-eject",
-           extra_cdrom_params, bkpinfo->media_device,
-           bkpinfo->cdrw_speed, bkpinfo->tmpdir);
-    }
-      else
-    {
-      sprintf (bkpinfo->call_make_iso,
-           "%s . 2>> _ERR_ | %s %s %s fs=4m dev=%s speed=%d -",
-           mondo_mkisofs_sz, cdr_exe,
-           (bkpinfo->please_dont_eject)?" ":"-eject",
-           extra_cdrom_params, bkpinfo->media_device,
-           bkpinfo->cdrw_speed);
-        }
-    } // end of CD code
-
-  /*
-  if (bkpinfo->backup_data && bkpinfo->backup_media_type == tape)
-    {
-      sprintf (tmp,
-           "dd if=/dev/zero of=%s bs=%ld count=32 2> /dev/null",
-           bkpinfo->media_device, bkpinfo->internal_tape_block_size);
-      if (system(tmp))
-    {
-      retval++;
-      fprintf (stderr,
-           "Cannot write to tape device. Is the tape set read-only?\n");
-    }
-    } // end of tape code
-  */
-
-
-  if (bkpinfo->backup_media_type == iso)
-    {
+        strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_LILO);
+    }
+#endif
+        else
+        {
+            strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_SYSLINUX);
+        }
+        if (bkpinfo->manual_cd_tray) {
+            sprintf(bkpinfo->call_before_iso,
+                    "%s -o %s/temporary.iso . 2>> _ERR_", mondo_mkisofs_sz,
+                    bkpinfo->tmpdir);
+            sprintf(bkpinfo->call_make_iso,
+                    "%s %s -v %s fs=4m dev=%s speed=%d %s/temporary.iso",
+                    cdr_exe, (bkpinfo->please_dont_eject) ? " " : "-eject",
+                    extra_cdrom_params, bkpinfo->media_device,
+                    bkpinfo->cdrw_speed, bkpinfo->tmpdir);
+        } else {
+            sprintf(bkpinfo->call_make_iso,
+                    "%s . 2>> _ERR_ | %s %s %s fs=4m dev=%s speed=%d -",
+                    mondo_mkisofs_sz, cdr_exe,
+                    (bkpinfo->please_dont_eject) ? " " : "-eject",
+                    extra_cdrom_params, bkpinfo->media_device,
+                    bkpinfo->cdrw_speed);
+        }
+    }                           // end of CD code
+
+    /*
+       if (bkpinfo->backup_data && bkpinfo->backup_media_type == tape)
+       {
+       sprintf (tmp,
+       "dd if=/dev/zero of=%s bs=%ld count=32 2> /dev/null",
+       bkpinfo->media_device, bkpinfo->internal_tape_block_size);
+       if (system(tmp))
+       {
+       retval++;
+       fprintf (stderr,
+       "Cannot write to tape device. Is the tape set read-only?\n");
+       }
+       } // end of tape code
+     */
+
+
+    if (bkpinfo->backup_media_type == iso) {
 
 /* Patch by Conor Daly <conor.daly@met.ie> 
@@ -815 +812 @@
  */
 
-      log_it("isodir = %s", bkpinfo->isodir);
-      sprintf(command, "df %s | tail -n1 | cut -d' ' -f1", bkpinfo->isodir);
-      log_it("command = %s", command);
-      log_it("res of it = %s", call_program_and_get_last_line_of_output(command));
-      sprintf(iso_dev, "%s", call_program_and_get_last_line_of_output(command));
-      sprintf(tmp, "%s/ISO-DEV", bkpinfo->tmpdir);
-      write_one_liner_data_file(tmp, call_program_and_get_last_line_of_output(command));
-
-      sprintf(command, "mount | grep -w %s | tail -n1 | cut -d' ' -f3", iso_dev);
-      log_it("command = %s", command);
-      log_it("res of it = %s", call_program_and_get_last_line_of_output(command));
-      sprintf(iso_mnt, "%s", call_program_and_get_last_line_of_output(command));
-      sprintf(tmp, "%s/ISO-MNT", bkpinfo->tmpdir);
-      write_one_liner_data_file(tmp, call_program_and_get_last_line_of_output(command));
-log_it("isomnt: %s, %d", iso_mnt, strlen(iso_mnt));
-      sprintf(iso_tmp, "%s", bkpinfo->isodir);
-      if (strlen(iso_tmp) < strlen(iso_mnt))
-        {
-      iso_path[0] = '\0';
-    }
-      else
-        {
-          sprintf(iso_path, "%s", iso_tmp + strlen(iso_mnt));
-    }
-      sprintf(tmp, "%s/ISODIR", bkpinfo->tmpdir);
-      write_one_liner_data_file(tmp, iso_path);
-log_it("isodir: %s", iso_path);
+        log_it("isodir = %s", bkpinfo->isodir);
+        sprintf(command, "df %s | tail -n1 | cut -d' ' -f1",
+                bkpinfo->isodir);
+        log_it("command = %s", command);
+        log_it("res of it = %s",
+               call_program_and_get_last_line_of_output(command));
+        sprintf(iso_dev, "%s",
+                call_program_and_get_last_line_of_output(command));
+        sprintf(tmp, "%s/ISO-DEV", bkpinfo->tmpdir);
+        write_one_liner_data_file(tmp,
+                                  call_program_and_get_last_line_of_output
+                                  (command));
+
+        sprintf(command, "mount | grep -w %s | tail -n1 | cut -d' ' -f3",
+                iso_dev);
+        log_it("command = %s", command);
+        log_it("res of it = %s",
+               call_program_and_get_last_line_of_output(command));
+        sprintf(iso_mnt, "%s",
+                call_program_and_get_last_line_of_output(command));
+        sprintf(tmp, "%s/ISO-MNT", bkpinfo->tmpdir);
+        write_one_liner_data_file(tmp,
+                                  call_program_and_get_last_line_of_output
+                                  (command));
+        log_it("isomnt: %s, %d", iso_mnt, strlen(iso_mnt));
+        sprintf(iso_tmp, "%s", bkpinfo->isodir);
+        if (strlen(iso_tmp) < strlen(iso_mnt)) {
+            iso_path[0] = '\0';
+        } else {
+            sprintf(iso_path, "%s", iso_tmp + strlen(iso_mnt));
+        }
+        sprintf(tmp, "%s/ISODIR", bkpinfo->tmpdir);
+        write_one_liner_data_file(tmp, iso_path);
+        log_it("isodir: %s", iso_path);
 
 /* End patch */
-    } // end of iso code
-
-  if (bkpinfo->backup_media_type == nfs) {
-      strcpy (hostname, bkpinfo->nfs_mount);
-      colon = strchr (hostname, ':');
-      if (!colon) {
-      log_it ("nfs mount doesn't have a colon in it");
-      retval++;
-      } else {
-      struct hostent *hent;
-
-      *colon = '\0';
-      hent = gethostbyname (hostname);
-      if (!hent) {
-          log_it ("Can't resolve NFS mount (%s): %s", hostname, hstrerror (h_errno));
-          retval++;
-      } else {
-          strcpy (ip_address, inet_ntoa
-              ((struct in_addr)*((struct in_addr *)hent->h_addr)));
-          strcat (ip_address, strchr (bkpinfo->nfs_mount, ':'));
-          strcpy (bkpinfo->nfs_mount, ip_address);
-      }
-      }
-  }
-
-  log_it("Finished processing incoming params");
-  if (retval)
-    {
-      fprintf (stderr, "Type 'man mondoarchive' for help.\n");
-    }
-  sprintf (tmp, "%s", MONDO_TMPISOS);   /* added #define 22 apr 2002 */
-  if (does_file_exist (tmp))
-    {
-      unlink (tmp);
-    }
-  if (strlen (bkpinfo->tmpdir) < 2 || strlen (bkpinfo->scratchdir) < 2)
-    {
-      log_it ("tmpdir or scratchdir are blank/missing");
-      retval++;
-    }
-  if (bkpinfo->include_paths[0] == '\0')
-    {
-    //      fatal_error ("Why no backup path?");
-    strcpy (bkpinfo->include_paths, "/");
-    }
-  chmod(bkpinfo->scratchdir, 0700);
-  chmod(bkpinfo->tmpdir, 0700);
-  g_backup_media_type = bkpinfo->backup_media_type;
-  paranoid_free(mtpt);
-  paranoid_free(extra_cdrom_params);
-  paranoid_free(mondo_mkisofs_sz);
-  paranoid_free(command);
-  paranoid_free(hostname);
-  paranoid_free(ip_address);
-  paranoid_free(cdr_exe);
-  paranoid_free(tmp);
-  paranoid_free(iso_dev);
-  paranoid_free(iso_mnt);
-  paranoid_free(iso_tmp);
-  paranoid_free(iso_path);
-  return(retval);
+    }                           // end of iso code
+
+    if (bkpinfo->backup_media_type == nfs) {
+        strcpy(hostname, bkpinfo->nfs_mount);
+        colon = strchr(hostname, ':');
+        if (!colon) {
+            log_it("nfs mount doesn't have a colon in it");
+            retval++;
+        } else {
+            struct hostent *hent;
+
+            *colon = '\0';
+            hent = gethostbyname(hostname);
+            if (!hent) {
+                log_it("Can't resolve NFS mount (%s): %s", hostname,
+                       hstrerror(h_errno));
+                retval++;
+            } else {
+                strcpy(ip_address, inet_ntoa
+                       ((struct in_addr)
+                        *((struct in_addr *) hent->h_addr)));
+                strcat(ip_address, strchr(bkpinfo->nfs_mount, ':'));
+                strcpy(bkpinfo->nfs_mount, ip_address);
+            }
+        }
+    }
+
+    log_it("Finished processing incoming params");
+    if (retval) {
+        fprintf(stderr, "Type 'man mondoarchive' for help.\n");
+    }
+    sprintf(tmp, "%s", MONDO_TMPISOS);  /* added #define 22 apr 2002 */
+    if (does_file_exist(tmp)) {
+        unlink(tmp);
+    }
+    if (strlen(bkpinfo->tmpdir) < 2 || strlen(bkpinfo->scratchdir) < 2) {
+        log_it("tmpdir or scratchdir are blank/missing");
+        retval++;
+    }
+    if (bkpinfo->include_paths[0] == '\0') {
+        //      fatal_error ("Why no backup path?");
+        strcpy(bkpinfo->include_paths, "/");
+    }
+    chmod(bkpinfo->scratchdir, 0700);
+    chmod(bkpinfo->tmpdir, 0700);
+    g_backup_media_type = bkpinfo->backup_media_type;
+    paranoid_free(mtpt);
+    paranoid_free(extra_cdrom_params);
+    paranoid_free(mondo_mkisofs_sz);
+    paranoid_free(command);
+    paranoid_free(hostname);
+    paranoid_free(ip_address);
+    paranoid_free(cdr_exe);
+    paranoid_free(tmp);
+    paranoid_free(iso_dev);
+    paranoid_free(iso_mnt);
+    paranoid_free(iso_tmp);
+    paranoid_free(iso_path);
+    return (retval);
 }
 
@@ -918 +920 @@
 int pre_param_configuration(struct s_bkpinfo *bkpinfo)
 {
-  int res=0;
-
-  make_hole_for_dir(MNT_CDROM);
-  assert(bkpinfo!=NULL);
-  srandom ((unsigned long)(time (NULL)));
-  insmod_crucial_modules();
-  reset_bkpinfo (bkpinfo); // also sets defaults ('/'=backup path, 3=compression level)
-  if (bkpinfo->disaster_recovery) {
-    if (!does_nonMS_partition_exist()) {
-      fatal_error ("I am in disaster recovery mode\nPlease don't run mondoarchive.");
-    }
-  }
-
-  unlink (MONDO_TRACEFILE);
-  run_program_and_log_output( "rm -Rf /tmp/changed.files*", FALSE);
-  if (find_and_store_mondoarchives_home(g_mondo_home))
-    {
-      fprintf (stderr,
-           "Cannot find Mondo's homedir. I think you have >1 'mondo' directory on your hard disk. Please delete the superfluous 'mondo' directories and try again\n");
-      res++;
-      return(res);
-    }
-  res += some_basic_system_sanity_checks ();
-  if (res)
-    {
-      log_it ("Your distribution did not pass Mondo's sanity test.");
-    }
-  g_current_media_number = 1;
-  bkpinfo->postnuke_tarball[0] = bkpinfo->nfs_mount[0] = '\0';
-  return(res);
+    int res = 0;
+
+    make_hole_for_dir(MNT_CDROM);
+    assert(bkpinfo != NULL);
+    srandom((unsigned long) (time(NULL)));
+    insmod_crucial_modules();
+    reset_bkpinfo(bkpinfo);     // also sets defaults ('/'=backup path, 3=compression level)
+    if (bkpinfo->disaster_recovery) {
+        if (!does_nonMS_partition_exist()) {
+            fatal_error
+                ("I am in disaster recovery mode\nPlease don't run mondoarchive.");
+        }
+    }
+
+    unlink(MONDO_TRACEFILE);
+    run_program_and_log_output("rm -Rf /tmp/changed.files*", FALSE);
+    if (find_and_store_mondoarchives_home(g_mondo_home)) {
+        fprintf(stderr,
+                "Cannot find Mondo's homedir. I think you have >1 'mondo' directory on your hard disk. Please delete the superfluous 'mondo' directories and try again\n");
+        res++;
+        return (res);
+    }
+    res += some_basic_system_sanity_checks();
+    if (res) {
+        log_it("Your distribution did not pass Mondo's sanity test.");
+    }
+    g_current_media_number = 1;
+    bkpinfo->postnuke_tarball[0] = bkpinfo->nfs_mount[0] = '\0';
+    return (res);
 }
 
@@ -957 +958 @@
  * @param bkpinfo The @c bkpinfo to reset.
  */
-void
-reset_bkpinfo (struct s_bkpinfo *bkpinfo)
-{
-  int i;
-
-  log_msg(1, "Hi");
-  assert(bkpinfo!=NULL);
-  memset((void*)bkpinfo, 0, sizeof(struct s_bkpinfo));
-  bkpinfo->manual_cd_tray = FALSE;
-  bkpinfo->internal_tape_block_size = DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
-  bkpinfo->media_device[0] = '\0';
-  for(i=0; i<=MAX_NOOF_MEDIA; i++) { bkpinfo->media_size[i] = -1; }
-  bkpinfo->boot_loader = '\0';
-  bkpinfo->boot_device[0] = '\0';
-  bkpinfo->zip_exe[0] = '\0';
-  bkpinfo->zip_suffix[0] = '\0';
-  bkpinfo->restore_path[0] = '\0';
-  bkpinfo->use_lzo = FALSE;
-  bkpinfo->do_not_compress_these[0] = '\0';
-  bkpinfo->verify_data = FALSE;
-  bkpinfo->backup_data = FALSE;
-  bkpinfo->restore_data = FALSE;
-  bkpinfo->disaster_recovery = (am_I_in_disaster_recovery_mode()?TRUE:FALSE);
-  if (bkpinfo->disaster_recovery)
-    { strcpy(bkpinfo->isodir, "/"); }
-  else
-    { strcpy (bkpinfo->isodir, "/root/images/mondo"); }
-  strcpy (bkpinfo->prefix, "mondorescue");
-
-  bkpinfo->scratchdir[0] = '\0';
-  bkpinfo->make_filelist = TRUE; // unless -J supplied to mondoarchive
-  sprintf( bkpinfo->tmpdir, "/tmp/tmpfs/mondo.tmp.%d", (int) ( random() %32768 ) ); // for mondorestore
-  bkpinfo->optimal_set_size = 0;
-  bkpinfo->backup_media_type = none;
-  strcpy (bkpinfo->include_paths, "/");
-  bkpinfo->exclude_paths[0] = '\0';
-  bkpinfo->call_before_iso[0] = '\0';
-  bkpinfo->call_make_iso[0] = '\0';
-  bkpinfo->call_burn_iso[0] = '\0';
-  bkpinfo->call_after_iso[0] = '\0';
-  bkpinfo->image_devs[0] = '\0';
-  bkpinfo->postnuke_tarball[0] = '\0';
-  bkpinfo->kernel_path[0] = '\0';
-  bkpinfo->nfs_mount[0] = '\0';
-  bkpinfo->nfs_remote_dir[0] = '\0';
-  bkpinfo->wipe_media_first = FALSE;
-  bkpinfo->differential = FALSE;
-  bkpinfo->cdrw_speed = 0;
+void reset_bkpinfo(struct s_bkpinfo *bkpinfo)
+{
+    int i;
+
+    log_msg(1, "Hi");
+    assert(bkpinfo != NULL);
+    memset((void *) bkpinfo, 0, sizeof(struct s_bkpinfo));
+    bkpinfo->manual_cd_tray = FALSE;
+    bkpinfo->internal_tape_block_size = DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
+    bkpinfo->media_device[0] = '\0';
+    for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
+        bkpinfo->media_size[i] = -1;
+    }
+    bkpinfo->boot_loader = '\0';
+    bkpinfo->boot_device[0] = '\0';
+    bkpinfo->zip_exe[0] = '\0';
+    bkpinfo->zip_suffix[0] = '\0';
+    bkpinfo->restore_path[0] = '\0';
+    bkpinfo->use_lzo = FALSE;
+    bkpinfo->do_not_compress_these[0] = '\0';
+    bkpinfo->verify_data = FALSE;
+    bkpinfo->backup_data = FALSE;
+    bkpinfo->restore_data = FALSE;
+    bkpinfo->disaster_recovery =
+        (am_I_in_disaster_recovery_mode()? TRUE : FALSE);
+    if (bkpinfo->disaster_recovery) {
+        strcpy(bkpinfo->isodir, "/");
+    } else {
+        strcpy(bkpinfo->isodir, "/root/images/mondo");
+    }
+    strcpy(bkpinfo->prefix, "mondorescue");
+
+    bkpinfo->scratchdir[0] = '\0';
+    bkpinfo->make_filelist = TRUE;  // unless -J supplied to mondoarchive
+    sprintf(bkpinfo->tmpdir, "/tmp/tmpfs/mondo.tmp.%d", (int) (random() % 32768));  // for mondorestore
+    bkpinfo->optimal_set_size = 0;
+    bkpinfo->backup_media_type = none;
+    strcpy(bkpinfo->include_paths, "/");
+    bkpinfo->exclude_paths[0] = '\0';
+    bkpinfo->call_before_iso[0] = '\0';
+    bkpinfo->call_make_iso[0] = '\0';
+    bkpinfo->call_burn_iso[0] = '\0';
+    bkpinfo->call_after_iso[0] = '\0';
+    bkpinfo->image_devs[0] = '\0';
+    bkpinfo->postnuke_tarball[0] = '\0';
+    bkpinfo->kernel_path[0] = '\0';
+    bkpinfo->nfs_mount[0] = '\0';
+    bkpinfo->nfs_remote_dir[0] = '\0';
+    bkpinfo->wipe_media_first = FALSE;
+    bkpinfo->differential = FALSE;
+    bkpinfo->cdrw_speed = 0;
 // patch by Herman Kuster  
-  bkpinfo->differential = 0;
+    bkpinfo->differential = 0;
 // patch end
-  bkpinfo->compression_level = 3;
+    bkpinfo->compression_level = 3;
 }
 
@@ -1019 +1023 @@
  * @return The free space on @p partition, in MB.
  */
-long free_space_on_given_partition(char*partition)
-{
-  char command[MAX_STR_LEN], out_sz[MAX_STR_LEN];
-  long res;
-
-  assert_string_is_neither_NULL_nor_zerolength(partition);
-
-  sprintf(command, "df -m %s &> /dev/null", partition);
-  if (system(command))
-    { return(-1); } // partition does not exist
-  sprintf(command, "df -m %s | tail -n1 | tr -s ' ' '\t' | cut -f4", partition);
-  strcpy(out_sz, call_program_and_get_last_line_of_output(command));
-  if (strlen(out_sz)==0)
-    { return(-1); } // error within df, probably
-  res = atol(out_sz);
-  return(res);
+long free_space_on_given_partition(char *partition)
+{
+    char command[MAX_STR_LEN], out_sz[MAX_STR_LEN];
+    long res;
+
+    assert_string_is_neither_NULL_nor_zerolength(partition);
+
+    sprintf(command, "df -m %s &> /dev/null", partition);
+    if (system(command)) {
+        return (-1);
+    }                           // partition does not exist
+    sprintf(command, "df -m %s | tail -n1 | tr -s ' ' '\t' | cut -f4",
+            partition);
+    strcpy(out_sz, call_program_and_get_last_line_of_output(command));
+    if (strlen(out_sz) == 0) {
+        return (-1);
+    }                           // error within df, probably
+    res = atol(out_sz);
+    return (res);
 }
 
@@ -1051 +1058 @@
  * @return number of problems with the user's setup (0 for success)
  */
-int
-some_basic_system_sanity_checks ()
-{
-
-    /*@ buffers *************/
-  char tmp[MAX_STR_LEN];
-  //  char command[MAX_STR_LEN];
-
-    /*@ int's ****************/
-  int retval = 0;
-  long Lres;
-
-
-  mvaddstr_and_log_it (g_currentY, 0,
-               "Checking sanity of your Linux distribution");
+int some_basic_system_sanity_checks()
+{
+
+    /*@ buffers ************ */
+    char tmp[MAX_STR_LEN];
+    //  char command[MAX_STR_LEN];
+
+    /*@ int's *************** */
+    int retval = 0;
+    long Lres;
+
+
+    mvaddstr_and_log_it(g_currentY, 0,
+                        "Checking sanity of your Linux distribution");
 #ifndef __FreeBSD__
-  if (system("which mkfs.vfat &> /dev/null") && !system("which mkfs.msdos &> /dev/null"))
-    {
-      log_it("OK, you've got mkfs.msdos but not mkfs.vfat; time for the fairy to wave her magic wand...");
-      run_program_and_log_output("ln -sf `which mkfs.msdos` /sbin/mkfs.vfat", FALSE);
-    }
-  strcpy (tmp,
-      call_program_and_get_last_line_of_output
-      ("free | grep Mem | head -n1 | tr -s ' ' '\t' | cut -f2"));
-  if (atol (tmp) < 35000)
-    {
-      retval++;
-      log_to_screen ("You must have at least 32MB of RAM to use Mondo.");
-    }
-  if (atol (tmp) < 66000)
-    {
-      log_to_screen
-    ("WARNING! You have very little RAM. Please upgrade to 64MB or more.");
-    }
-#endif
-
-  if ((Lres = free_space_on_given_partition("/root"))==-1)
-    { Lres = free_space_on_given_partition("/"); }
-  log_it("Free space on given partition = %ld MB", Lres);
-
-  if (Lres < 50)
-    {
-      run_program_and_log_output("rm -Rf /root/images/mindi; mkdir -p /home/root/images/mindi; mkdir -p /root/images; ln -sf /home/root/images/mindi /root/images/mindi", 3);
-      //      fatal_error("Your / (or /root) partition has <50MB free. Please adjust your partition table to something saner."); 
-    } 
-
-  if (system ("which " MKE2FS_OR_NEWFS " > /dev/null 2> /dev/null"))
-    {
-      retval++;
-      log_to_screen
-    ("Unable to find " MKE2FS_OR_NEWFS " in system path.");
-      fatal_error
-        ("Please use \"su -\", not \"su\" to become root. OK? ...and please don't e-mail the mailing list or me about this. Just read the message. :)");
-    }
+    if (system("which mkfs.vfat &> /dev/null")
+        && !system("which mkfs.msdos &> /dev/null")) {
+        log_it
+            ("OK, you've got mkfs.msdos but not mkfs.vfat; time for the fairy to wave her magic wand...");
+        run_program_and_log_output
+            ("ln -sf `which mkfs.msdos` /sbin/mkfs.vfat", FALSE);
+    }
+    strcpy(tmp,
+           call_program_and_get_last_line_of_output
+           ("free | grep Mem | head -n1 | tr -s ' ' '\t' | cut -f2"));
+    if (atol(tmp) < 35000) {
+        retval++;
+        log_to_screen("You must have at least 32MB of RAM to use Mondo.");
+    }
+    if (atol(tmp) < 66000) {
+        log_to_screen
+            ("WARNING! You have very little RAM. Please upgrade to 64MB or more.");
+    }
+#endif
+
+    if ((Lres = free_space_on_given_partition("/root")) == -1) {
+        Lres = free_space_on_given_partition("/");
+    }
+    log_it("Free space on given partition = %ld MB", Lres);
+
+    if (Lres < 50) {
+        run_program_and_log_output
+            ("rm -Rf /root/images/mindi; mkdir -p /home/root/images/mindi; mkdir -p /root/images; ln -sf /home/root/images/mindi /root/images/mindi",
+             3);
+        //      fatal_error("Your / (or /root) partition has <50MB free. Please adjust your partition table to something saner."); 
+    }
+
+    if (system("which " MKE2FS_OR_NEWFS " > /dev/null 2> /dev/null")) {
+        retval++;
+        log_to_screen
+            ("Unable to find " MKE2FS_OR_NEWFS " in system path.");
+        fatal_error
+            ("Please use \"su -\", not \"su\" to become root. OK? ...and please don't e-mail the mailing list or me about this. Just read the message. :)");
+    }
 #ifndef __FreeBSD__
-  if (run_program_and_log_output ("cat /proc/devices | grep ramdisk", FALSE))
-    {
-      if (!ask_me_yes_or_no("Your kernel has no ramdisk support. That's mind-numbingly stupid but I'll allow it if you're planning to use a failsafe kernel. Are you?"))
-        {
-      //          retval++;
-          log_to_screen
-            ("It looks as if your kernel lacks ramdisk and initrd support.");
-      log_to_screen
-        ("I'll allow you to proceed but FYI, if I'm right, your kernel is broken.");
-        }
-    }
-#endif
-  retval += whine_if_not_found (MKE2FS_OR_NEWFS);
-  retval += whine_if_not_found ("mkisofs");
-  if (system("which dvdrecord > /dev/null 2> /dev/null"))
-    { retval += whine_if_not_found ("cdrecord"); }
-  retval += whine_if_not_found ("bzip2");
-  retval += whine_if_not_found ("awk");
-  retval += whine_if_not_found ("md5sum");
-  retval += whine_if_not_found ("strings");
-  retval += whine_if_not_found ("mindi");
-  retval += whine_if_not_found ("buffer");
-
-  // abort if Windows partition but no ms-sys and parted
-  if (!run_program_and_log_output("mount | grep -w vfat | grep -v /dev/fd | grep -v nexdisk", 0) ||
-      !run_program_and_log_output("mount | grep -w dos | grep -v /dev/fd | grep -v nexdisk", 0))
-    {
-      log_to_screen("I think you have a Windows 9x partition.");
-      retval += whine_if_not_found ("parted");
+    if (run_program_and_log_output
+        ("cat /proc/devices | grep ramdisk", FALSE)) {
+        if (!ask_me_yes_or_no
+            ("Your kernel has no ramdisk support. That's mind-numbingly stupid but I'll allow it if you're planning to use a failsafe kernel. Are you?"))
+        {
+            //          retval++;
+            log_to_screen
+                ("It looks as if your kernel lacks ramdisk and initrd support.");
+            log_to_screen
+                ("I'll allow you to proceed but FYI, if I'm right, your kernel is broken.");
+        }
+    }
+#endif
+    retval += whine_if_not_found(MKE2FS_OR_NEWFS);
+    retval += whine_if_not_found("mkisofs");
+    if (system("which dvdrecord > /dev/null 2> /dev/null")) {
+        retval += whine_if_not_found("cdrecord");
+    }
+    retval += whine_if_not_found("bzip2");
+    retval += whine_if_not_found("awk");
+    retval += whine_if_not_found("md5sum");
+    retval += whine_if_not_found("strings");
+    retval += whine_if_not_found("mindi");
+    retval += whine_if_not_found("buffer");
+
+    // abort if Windows partition but no ms-sys and parted
+    if (!run_program_and_log_output
+        ("mount | grep -w vfat | grep -v /dev/fd | grep -v nexdisk", 0)
+        ||
+        !run_program_and_log_output
+        ("mount | grep -w dos | grep -v /dev/fd | grep -v nexdisk", 0)) {
+        log_to_screen("I think you have a Windows 9x partition.");
+        retval += whine_if_not_found("parted");
 #ifndef __IA64__
-      /* IA64 always has one vfat partition for EFI even without Windows */
-      // retval += 
-      if (!find_home_of_exe("ms-sys"))
-        {
-      log_to_screen("Please install ms-sys just in case.");
-    }
-#endif
-    }
-
-  if (!find_home_of_exe("cmp"))
-    {
-      if (!find_home_of_exe("true"))
-        { whine_if_not_found ("cmp"); }
-      else
-        {
-          log_to_screen("Your system lacks the 'cmp' binary. I'll create a dummy cmp for you.");
-          if (run_program_and_log_output("cp -f `which true` /usr/bin/cmp", 0))
-            { fatal_error("Failed to create dummy 'cmp' file."); }
-        }
-    }
-  run_program_and_log_output("umount `mount | grep cdr | cut -d' ' -f3 | tr '\n' ' '`", 5);
-  strcpy (tmp,
-      call_program_and_get_last_line_of_output
-      ("mount | grep -E \"cdr(om|w)\""));
-  if (strcmp ("", tmp))
-    {
-    if (strstr (tmp, "autofs")) {
-        log_to_screen ("Your CD-ROM is mounted via autofs. I therefore cannot tell");
-        log_to_screen ("if a CD actually is inserted. If a CD is inserted, please");
-        log_to_screen ("eject it. Thank you.");
-        log_it ("Ignoring autofs CD-ROM 'mount' since we hope nothing's in it.");
-    } else if (run_program_and_log_output("uname -a | grep Knoppix", 5)) {
-        retval++;
-        fatal_error ("Your CD-ROM drive is mounted. Please unmount it.");
-    }
-    }
+        /* IA64 always has one vfat partition for EFI even without Windows */
+        // retval += 
+        if (!find_home_of_exe("ms-sys")) {
+            log_to_screen("Please install ms-sys just in case.");
+        }
+#endif
+    }
+
+    if (!find_home_of_exe("cmp")) {
+        if (!find_home_of_exe("true")) {
+            whine_if_not_found("cmp");
+        } else {
+            log_to_screen
+                ("Your system lacks the 'cmp' binary. I'll create a dummy cmp for you.");
+            if (run_program_and_log_output
+                ("cp -f `which true` /usr/bin/cmp", 0)) {
+                fatal_error("Failed to create dummy 'cmp' file.");
+            }
+        }
+    }
+    run_program_and_log_output
+        ("umount `mount | grep cdr | cut -d' ' -f3 | tr '\n' ' '`", 5);
+    strcpy(tmp,
+           call_program_and_get_last_line_of_output
+           ("mount | grep -E \"cdr(om|w)\""));
+    if (strcmp("", tmp)) {
+        if (strstr(tmp, "autofs")) {
+            log_to_screen
+                ("Your CD-ROM is mounted via autofs. I therefore cannot tell");
+            log_to_screen
+                ("if a CD actually is inserted. If a CD is inserted, please");
+            log_to_screen("eject it. Thank you.");
+            log_it
+                ("Ignoring autofs CD-ROM 'mount' since we hope nothing's in it.");
+        } else
+            if (run_program_and_log_output("uname -a | grep Knoppix", 5)) {
+            retval++;
+            fatal_error
+                ("Your CD-ROM drive is mounted. Please unmount it.");
+        }
+    }
 #ifndef __FreeBSD__
-  if (!does_file_exist ("/etc/modules.conf"))
-    {
-      if (does_file_exist("/etc/conf.modules"))
-        {
-          log_it("Linking /etc/modules.conf to /etc/conf.modules");
-          run_program_and_log_output("ln -sf /etc/conf.modules /etc/modules.conf", 5);
-        }
-      else if (does_file_exist("/etc/modprobe.d"))
-    {
-      log_it("Directory /etc/modprobe.d found. mindi will use its contents.");
-    }
-      else if (does_file_exist("/etc/modprobe.conf"))
-        {
-          log_it("Linking /etc/modules.conf to /etc/modprobe.conf");
-          run_program_and_log_output("ln -sf /etc/modprobe.conf /etc/modules.conf", 5);
-    }
-      else
-        {
-          retval++;
-          log_to_screen ("Please find out what happened to /etc/modules.conf");
-        }
-    }
-#endif
-
-  run_program_and_log_output("cat /etc/fstab", 5);
+    if (!does_file_exist("/etc/modules.conf")) {
+        if (does_file_exist("/etc/conf.modules")) {
+            log_it("Linking /etc/modules.conf to /etc/conf.modules");
+            run_program_and_log_output
+                ("ln -sf /etc/conf.modules /etc/modules.conf", 5);
+        } else if (does_file_exist("/etc/modprobe.d")) {
+            log_it
+                ("Directory /etc/modprobe.d found. mindi will use its contents.");
+        } else if (does_file_exist("/etc/modprobe.conf")) {
+            log_it("Linking /etc/modules.conf to /etc/modprobe.conf");
+            run_program_and_log_output
+                ("ln -sf /etc/modprobe.conf /etc/modules.conf", 5);
+        } else {
+            retval++;
+            log_to_screen
+                ("Please find out what happened to /etc/modules.conf");
+        }
+    }
+#endif
+
+    run_program_and_log_output("cat /etc/fstab", 5);
 #ifdef __FreeBSD__
-  run_program_and_log_output("vinum printconfig", 5);
+    run_program_and_log_output("vinum printconfig", 5);
 #else
-  run_program_and_log_output("cat /etc/raidtab", 5);
-#endif
-
-  if (run_program_and_log_output("mindi -V", 1))
-    {
-      log_to_screen("Could not ascertain mindi's version number.");
-      log_to_screen("You have not installed Mondo and/or Mindi properly.");
-      log_to_screen("Please uninstall and reinstall them both.");
-      fatal_error("Please reinstall Mondo and Mindi.");
-    }
-  if (run_program_and_log_output("mindi --makemountlist /tmp/mountlist.txt.test", 5))
-    {
-      log_to_screen("Mindi --makemountlist /tmp/mountlist.txt.test failed for some reason.");
-      log_to_screen("Please run that command by hand and examine /var/log/mindi.log");
-      log_to_screen("for more information. Perhaps your /etc/fstab file is insane.");
-      log_to_screen("Perhaps Mindi's MakeMountlist() subroutine has a bug. We'll see.");
-      retval++;
-    }
-
-  if (!run_program_and_log_output("fdisk -l | grep -i raid", 1) && !does_file_exist("/etc/raidtab"))
-    {
-      log_to_screen("You have RAID partitions but no /etc/raidtab - creating one from /proc/mdstat");
-      create_raidtab_from_mdstat("/etc/raidtab", "/proc/mdstat");
-    }
-  
-  if (retval)
-    {
-      mvaddstr_and_log_it (g_currentY++, 74, "Failed.");
-    }
-  else
-    {
-      mvaddstr_and_log_it (g_currentY++, 74, "Done.");
-    }
-  return (retval);
+    run_program_and_log_output("cat /etc/raidtab", 5);
+#endif
+
+    if (run_program_and_log_output("mindi -V", 1)) {
+        log_to_screen("Could not ascertain mindi's version number.");
+        log_to_screen
+            ("You have not installed Mondo and/or Mindi properly.");
+        log_to_screen("Please uninstall and reinstall them both.");
+        fatal_error("Please reinstall Mondo and Mindi.");
+    }
+    if (run_program_and_log_output
+        ("mindi --makemountlist /tmp/mountlist.txt.test", 5)) {
+        log_to_screen
+            ("Mindi --makemountlist /tmp/mountlist.txt.test failed for some reason.");
+        log_to_screen
+            ("Please run that command by hand and examine /var/log/mindi.log");
+        log_to_screen
+            ("for more information. Perhaps your /etc/fstab file is insane.");
+        log_to_screen
+            ("Perhaps Mindi's MakeMountlist() subroutine has a bug. We'll see.");
+        retval++;
+    }
+
+    if (!run_program_and_log_output("fdisk -l | grep -i raid", 1)
+        && !does_file_exist("/etc/raidtab")) {
+        log_to_screen
+            ("You have RAID partitions but no /etc/raidtab - creating one from /proc/mdstat");
+        create_raidtab_from_mdstat("/etc/raidtab", "/proc/mdstat");
+    }
+
+    if (retval) {
+        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
+    } else {
+        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+    }
+    return (retval);
 }
 
@@ -1244 +1258 @@
  * @return 0 for success, 1 for failure.
  */
-int
-read_cfg_var (char *config_file, char *label, char *value)
-{
-    /*@ buffer *******************************************************/
-  char command[MAX_STR_LEN*2];
-  char tmp[MAX_STR_LEN];
-
-    /*@ end vars ****************************************************/
-
-  assert_string_is_neither_NULL_nor_zerolength(config_file);
-  assert_string_is_neither_NULL_nor_zerolength(label);
-  if (!does_file_exist (config_file))
-    {
-      sprintf (tmp, "(read_cfg_var) Cannot find %s config file", config_file);
-      log_to_screen (tmp);
-      value[0] = '\0';
-      return (1);
-    }
-  else if (strstr(value, "/dev/") && strstr(value, "t0") && !strcmp(label, "media-dev"))
-    {
-      log_msg (2, "FYI, I shan't read new value for %s - already got %s", label, value);
-      return(0);
-    }
-  else
-    {
-      sprintf (command, "cat %s | grep \"%s .*\" | cut -d' ' -f2,3,4,5",
-           config_file, label);
-      strcpy (value, call_program_and_get_last_line_of_output (command));
-      if (strlen (value) == 0)
-    {
-      return (1);
-    }
-      else
-    {
-      return (0);
-    }
-    }
+int read_cfg_var(char *config_file, char *label, char *value)
+{
+    /*@ buffer ****************************************************** */
+    char command[MAX_STR_LEN * 2];
+    char tmp[MAX_STR_LEN];
+
+    /*@ end vars *************************************************** */
+
+    assert_string_is_neither_NULL_nor_zerolength(config_file);
+    assert_string_is_neither_NULL_nor_zerolength(label);
+    if (!does_file_exist(config_file)) {
+        sprintf(tmp, "(read_cfg_var) Cannot find %s config file",
+                config_file);
+        log_to_screen(tmp);
+        value[0] = '\0';
+        return (1);
+    } else if (strstr(value, "/dev/") && strstr(value, "t0")
+               && !strcmp(label, "media-dev")) {
+        log_msg(2, "FYI, I shan't read new value for %s - already got %s",
+                label, value);
+        return (0);
+    } else {
+        sprintf(command, "cat %s | grep \"%s .*\" | cut -d' ' -f2,3,4,5",
+                config_file, label);
+        strcpy(value, call_program_and_get_last_line_of_output(command));
+        if (strlen(value) == 0) {
+            return (1);
+        } else {
+            return (0);
+        }
+    }
 }
 
@@ -1290 +1298 @@
 void remount_supermounts_if_necessary()
 {
-  if (g_remount_cdrom_at_end)
-    {
-      run_program_and_log_output ("mount "MNT_CDROM, FALSE);
-    }
-  if (g_remount_floppy_at_end)
-    {
-      run_program_and_log_output ("mount "MNT_FLOPPY, FALSE);
-    }
+    if (g_remount_cdrom_at_end) {
+        run_program_and_log_output("mount " MNT_CDROM, FALSE);
+    }
+    if (g_remount_floppy_at_end) {
+        run_program_and_log_output("mount " MNT_FLOPPY, FALSE);
+    }
 }
 
@@ -1305 +1311 @@
 void unmount_supermounts_if_necessary()
 {
-  if (run_program_and_log_output ("mount | grep cdrom | grep super", FALSE) == 0)
-    {
-      g_remount_cdrom_at_end = TRUE;
-      run_program_and_log_output ("umount "MNT_CDROM, FALSE);
-    }
-  if (run_program_and_log_output ("mount | grep floppy | grep super", FALSE) == 0)
-    {
-      g_remount_floppy_at_end = TRUE;
-      run_program_and_log_output ("umount "MNT_FLOPPY, FALSE);
-    }
+    if (run_program_and_log_output
+        ("mount | grep cdrom | grep super", FALSE) == 0) {
+        g_remount_cdrom_at_end = TRUE;
+        run_program_and_log_output("umount " MNT_CDROM, FALSE);
+    }
+    if (run_program_and_log_output
+        ("mount | grep floppy | grep super", FALSE) == 0) {
+        g_remount_floppy_at_end = TRUE;
+        run_program_and_log_output("umount " MNT_FLOPPY, FALSE);
+    }
 }
 
@@ -1320 +1326 @@
  * Whether we had to stop autofs (if so, restart it at end).
  */
-bool g_autofs_stopped=FALSE;
+bool g_autofs_stopped = FALSE;
 
 /**
@@ -1342 +1348 @@
 void stop_autofs_if_necessary()
 {
-  char tmp[MAX_STR_LEN];
-  
-  g_autofs_exe[0] = '\0';
-  if (does_file_exist(XANDROS_AUTOFS_FNAME))
-    { strcpy(g_autofs_exe, XANDROS_AUTOFS_FNAME); }  
-  else if (does_file_exist(STOCK_AUTOFS_FNAME))
-    { strcpy(g_autofs_exe, STOCK_AUTOFS_FNAME); }
-    
-  if (!g_autofs_exe[0]) { log_msg(3, "No autofs detected."); }  
-  else
-    {
-      log_msg(3, "%s --- autofs detected", g_autofs_exe);
+    char tmp[MAX_STR_LEN];
+
+    g_autofs_exe[0] = '\0';
+    if (does_file_exist(XANDROS_AUTOFS_FNAME)) {
+        strcpy(g_autofs_exe, XANDROS_AUTOFS_FNAME);
+    } else if (does_file_exist(STOCK_AUTOFS_FNAME)) {
+        strcpy(g_autofs_exe, STOCK_AUTOFS_FNAME);
+    }
+
+    if (!g_autofs_exe[0]) {
+        log_msg(3, "No autofs detected.");
+    } else {
+        log_msg(3, "%s --- autofs detected", g_autofs_exe);
 // FIXME -- only disable it if it's running ---  sprintf(tmp, "%s status", autofs_exe);
-      sprintf(tmp, "%s stop", g_autofs_exe);
-      if (run_program_and_log_output(tmp, 2))
-        { log_it("Failed to stop autofs - I assume it wasn't running"); }
-      else
-        { g_autofs_stopped = TRUE; log_it("Stopped autofs OK"); }
-    }
+        sprintf(tmp, "%s stop", g_autofs_exe);
+        if (run_program_and_log_output(tmp, 2)) {
+            log_it("Failed to stop autofs - I assume it wasn't running");
+        } else {
+            g_autofs_stopped = TRUE;
+            log_it("Stopped autofs OK");
+        }
+    }
 }
 
@@ -1368 +1377 @@
 void restart_autofs_if_necessary()
 {
-  char tmp[MAX_STR_LEN];
-  
-  if (!g_autofs_stopped || !g_autofs_exe[0]) { log_msg(3, "No autofs detected."); return; }  
-  sprintf(tmp, "%s start", g_autofs_exe);
-  if (run_program_and_log_output(tmp, 2))
-    { log_it("Failed to start autofs"); }
-  else
-    { g_autofs_stopped = FALSE; log_it("Started autofs OK"); }
+    char tmp[MAX_STR_LEN];
+
+    if (!g_autofs_stopped || !g_autofs_exe[0]) {
+        log_msg(3, "No autofs detected.");
+        return;
+    }
+    sprintf(tmp, "%s start", g_autofs_exe);
+    if (run_program_and_log_output(tmp, 2)) {
+        log_it("Failed to start autofs");
+    } else {
+        g_autofs_stopped = FALSE;
+        log_it("Started autofs OK");
+    }
 }
 
@@ -1384 +1398 @@
 void mount_boot_if_necessary()
 {
-  char tmp[MAX_STR_LEN];
-  char command[MAX_STR_LEN];
-
-  log_msg(1, "Started sub");
-  log_msg(4, "About to set g_boot_mountpt[0] to '\\0'");
-  g_boot_mountpt[0] = '\0';
-  log_msg(4, "Done. Great. Seeting command to something");
-  strcpy(command, "cat /etc/fstab | grep -v \":\" | grep -vx \"#.*\" | grep -w \"/boot\" | tr -s ' ' '\t' | cut -f1 | head -n1");
-  log_msg(4, "Cool. Command = '%s'", command);
-  strcpy(tmp, call_program_and_get_last_line_of_output(command));
-  log_msg(4, "tmp = '%s'", tmp);
-  if (tmp[0])
-    {
-      log_it("/boot is at %s according to /etc/fstab", tmp);
-      if (strstr(tmp, "LABEL="))
-        {
-      if (!run_program_and_log_output("mount /boot", 5))
-        {
-          strcpy(g_boot_mountpt, "/boot");
-          log_msg(1, "Mounted /boot");
-        }
-      else
-        {
-          log_it("...ignored cos it's a label :-)"); 
-        }
-    }
-      else
-        {
-          sprintf(command, "mount | grep -w \"%s\"", tmp);
-          log_msg(3, "command = %s", command);
-          if (run_program_and_log_output(command, 5))
-            {
-          strcpy(g_boot_mountpt, tmp);
-              sprintf(tmp, "%s (your /boot partition) is not mounted. I'll mount it before backing up", g_boot_mountpt);
-          log_it(tmp);
-          sprintf(tmp, "mount %s", g_boot_mountpt);
-          if (run_program_and_log_output(tmp, 5))
-        { 
-          g_boot_mountpt[0] = '\0';
-          log_msg(1, "Plan B");
-          if (!run_program_and_log_output("mount /boot", 5))
-            {
-              strcpy(g_boot_mountpt, "/boot");
-              log_msg(1, "Plan B worked");
-            }
-          else
-            {
-              log_msg(1, "Plan B failed. Unable to mount /boot for backup purposes. This probably means /boot is mounted already, or doesn't have its own partition.");
-            }
-        }
-            }
-        }
-    }
-  log_msg(1, "Ended sub");
+    char tmp[MAX_STR_LEN];
+    char command[MAX_STR_LEN];
+
+    log_msg(1, "Started sub");
+    log_msg(4, "About to set g_boot_mountpt[0] to '\\0'");
+    g_boot_mountpt[0] = '\0';
+    log_msg(4, "Done. Great. Seeting command to something");
+    strcpy(command,
+           "cat /etc/fstab | grep -v \":\" | grep -vx \"#.*\" | grep -w \"/boot\" | tr -s ' ' '\t' | cut -f1 | head -n1");
+    log_msg(4, "Cool. Command = '%s'", command);
+    strcpy(tmp, call_program_and_get_last_line_of_output(command));
+    log_msg(4, "tmp = '%s'", tmp);
+    if (tmp[0]) {
+        log_it("/boot is at %s according to /etc/fstab", tmp);
+        if (strstr(tmp, "LABEL=")) {
+            if (!run_program_and_log_output("mount /boot", 5)) {
+                strcpy(g_boot_mountpt, "/boot");
+                log_msg(1, "Mounted /boot");
+            } else {
+                log_it("...ignored cos it's a label :-)");
+            }
+        } else {
+            sprintf(command, "mount | grep -w \"%s\"", tmp);
+            log_msg(3, "command = %s", command);
+            if (run_program_and_log_output(command, 5)) {
+                strcpy(g_boot_mountpt, tmp);
+                sprintf(tmp,
+                        "%s (your /boot partition) is not mounted. I'll mount it before backing up",
+                        g_boot_mountpt);
+                log_it(tmp);
+                sprintf(tmp, "mount %s", g_boot_mountpt);
+                if (run_program_and_log_output(tmp, 5)) {
+                    g_boot_mountpt[0] = '\0';
+                    log_msg(1, "Plan B");
+                    if (!run_program_and_log_output("mount /boot", 5)) {
+                        strcpy(g_boot_mountpt, "/boot");
+                        log_msg(1, "Plan B worked");
+                    } else {
+                        log_msg(1,
+                                "Plan B failed. Unable to mount /boot for backup purposes. This probably means /boot is mounted already, or doesn't have its own partition.");
+                    }
+                }
+            }
+        }
+    }
+    log_msg(1, "Ended sub");
 }
 
@@ -1446 +1452 @@
 void unmount_boot_if_necessary()
 {
-  char tmp[MAX_STR_LEN];
-
-  log_msg(3, "starting");
-  if (g_boot_mountpt[0])
-    {
-      sprintf(tmp, "umount %s", g_boot_mountpt);
-      if (run_program_and_log_output(tmp, 5))
-    { log_it("WARNING - unable to unmount /boot"); }
-    }
-   log_msg(3, "leaving");
+    char tmp[MAX_STR_LEN];
+
+    log_msg(3, "starting");
+    if (g_boot_mountpt[0]) {
+        sprintf(tmp, "umount %s", g_boot_mountpt);
+        if (run_program_and_log_output(tmp, 5)) {
+            log_it("WARNING - unable to unmount /boot");
+        }
+    }
+    log_msg(3, "leaving");
 }
 
@@ -1468 +1474 @@
  * @return 0 for success, 1 for failure.
  */
-int
-write_cfg_var (char *config_file, char *label, char *value)
-{
-    /*@ buffers ******************************************************/
-  char command[MAX_STR_LEN*2];
-  char tempfile[MAX_STR_LEN];
-  char tmp[MAX_STR_LEN];
-
-
-    /*@ end vars ****************************************************/
-  assert_string_is_neither_NULL_nor_zerolength(config_file);
-  assert_string_is_neither_NULL_nor_zerolength(label);
-  assert(value!=NULL);
-  if (!does_file_exist (config_file))
-    {
-      sprintf (tmp, "(write_cfg_file) Cannot find %s config file",
-           config_file);
-      log_to_screen (tmp);
-      return(1);
-    }
-  strcpy (tempfile,
-      call_program_and_get_last_line_of_output
-      ("mktemp -q /tmp/mojo-jojo.blah.XXXXXX"));
-  if (does_file_exist (config_file))
-    {
-      sprintf (command, "cat %s | grep -vx \"%s .*\" > %s", config_file,
-           label, tempfile);
-      paranoid_system (command);
-    }
-  sprintf (command, "echo \"%s %s\" >> %s", label, value, tempfile);
-  paranoid_system (command);
-  sprintf (command, "mv -f %s %s", tempfile, config_file);
-  paranoid_system (command);
-  unlink (tempfile);
-  return (0);
+int write_cfg_var(char *config_file, char *label, char *value)
+{
+    /*@ buffers ***************************************************** */
+    char command[MAX_STR_LEN * 2];
+    char tempfile[MAX_STR_LEN];
+    char tmp[MAX_STR_LEN];
+
+
+    /*@ end vars *************************************************** */
+    assert_string_is_neither_NULL_nor_zerolength(config_file);
+    assert_string_is_neither_NULL_nor_zerolength(label);
+    assert(value != NULL);
+    if (!does_file_exist(config_file)) {
+        sprintf(tmp, "(write_cfg_file) Cannot find %s config file",
+                config_file);
+        log_to_screen(tmp);
+        return (1);
+    }
+    strcpy(tempfile,
+           call_program_and_get_last_line_of_output
+           ("mktemp -q /tmp/mojo-jojo.blah.XXXXXX"));
+    if (does_file_exist(config_file)) {
+        sprintf(command, "cat %s | grep -vx \"%s .*\" > %s", config_file,
+                label, tempfile);
+        paranoid_system(command);
+    }
+    sprintf(command, "echo \"%s %s\" >> %s", label, value, tempfile);
+    paranoid_system(command);
+    sprintf(command, "mv -f %s %s", tempfile, config_file);
+    paranoid_system(command);
+    unlink(tempfile);
+    return (0);
 }
 
@@ -1511 +1514 @@
  */
 void standard_log_debug_msg(int debug_level, const char *szFile,
-                const char *szFunction, int nLine, const char *fmt, ...)
-{
-  va_list args;
-  int i;
-  static int depth=0;  
-  char *tmp;
-  FILE*fout;
-
-  if (depth>5) { depth--; return; }
-  depth++;
-
-  malloc_string(tmp);
-
-  if (debug_level <= g_loglevel)
-    {
-      va_start(args, fmt);
-      if (!(fout = fopen (MONDO_LOGFILE, "a")))
-    { return; } // fatal_error("Failed to openout to logfile - sheesh..."); }
-
-      // add tabs to distinguish log levels
-      if (debug_level > 0)
-    {
-      for (i = 1; i < debug_level; i++)
-        fprintf(fout, "\t");
-      if (getpid() == g_main_pid)
-        fprintf(fout, "[Main] %s->%s#%d: ", szFile, szFunction, nLine);
-      else if (getpid() == g_buffer_pid && g_buffer_pid>0)
-        fprintf(fout, "[Buff] %s->%s#%d: ", szFile, szFunction, nLine);
-      else
-        fprintf(fout, "[TH=%d] %s->%s#%d: ", getpid(), szFile, szFunction, nLine);
-    }
-      vfprintf(fout, fmt, args);
-
-    // do not slow down the progran if standard debug level
-    // must be enabled: if no flush, the log won't be up-to-date if there
-    // is a segfault
-    //if (g_dwDebugLevel != 1)
-
-      va_end(args);
-      fprintf(fout, "\n");
-      paranoid_fclose(fout);
-    }
-  depth--;
-  paranoid_free(tmp);
+                            const char *szFunction, int nLine,
+                            const char *fmt, ...)
+{
+    va_list args;
+    int i;
+    static int depth = 0;
+    char *tmp;
+    FILE *fout;
+
+    if (depth > 5) {
+        depth--;
+        return;
+    }
+    depth++;
+
+    malloc_string(tmp);
+
+    if (debug_level <= g_loglevel) {
+        va_start(args, fmt);
+        if (!(fout = fopen(MONDO_LOGFILE, "a"))) {
+            return;
+        }                       // fatal_error("Failed to openout to logfile - sheesh..."); }
+
+        // add tabs to distinguish log levels
+        if (debug_level > 0) {
+            for (i = 1; i < debug_level; i++)
+                fprintf(fout, "\t");
+            if (getpid() == g_main_pid)
+                fprintf(fout, "[Main] %s->%s#%d: ", szFile, szFunction,
+                        nLine);
+            else if (getpid() == g_buffer_pid && g_buffer_pid > 0)
+                fprintf(fout, "[Buff] %s->%s#%d: ", szFile, szFunction,
+                        nLine);
+            else
+                fprintf(fout, "[TH=%d] %s->%s#%d: ", getpid(), szFile,
+                        szFunction, nLine);
+        }
+        vfprintf(fout, fmt, args);
+
+        // do not slow down the progran if standard debug level
+        // must be enabled: if no flush, the log won't be up-to-date if there
+        // is a segfault
+        //if (g_dwDebugLevel != 1)
+
+        va_end(args);
+        fprintf(fout, "\n");
+        paranoid_fclose(fout);
+    }
+    depth--;
+    paranoid_free(tmp);
 }
 
@@ -1560 +1569 @@
  * Function pointer to the @c log_debug_msg function to use. Points to standard_log_debug_msg() by default.
  */
-void (*log_debug_msg) (int, const char *, const char *, int, const char *, ...) = standard_log_debug_msg;
+void (*log_debug_msg) (int, const char *, const char *, int, const char *,
+                       ...) = standard_log_debug_msg;
 
 
@@ -1575 +1585 @@
 void do_libmondo_global_strings_thing(int mal)
 {
-  if (mal)
-    {
-      iamhere("Malloc'ing globals");
-      malloc_string(g_boot_mountpt);
-      malloc_string(g_mondo_home);
-      malloc_string(g_tmpfs_mountpt);
-      malloc_string(g_erase_tmpdir_and_scratchdir);
-      malloc_string(g_serial_string);
-      malloc_string(g_magicdev_command);
-    }
-  else
-    {
-      iamhere("Freeing globals");
-      paranoid_free(g_boot_mountpt);
-      paranoid_free(g_mondo_home);
-      paranoid_free(g_tmpfs_mountpt);
-      paranoid_free(g_erase_tmpdir_and_scratchdir);
-      paranoid_free(g_serial_string);
-      paranoid_free(g_magicdev_command);
-    }
-
-  /*
-  char**list_of_arrays[] = {
-    &g_boot_mountpt,
-    &g_mondo_home,
-    &g_tmpfs_mountpt,
-    &g_erase_tmpdir_and_scratchdir,
-    &g_serial_string,
-    &g_magicdev_command,
-    NULL};
-
-  char**ppcurr;
-  int i;
-  
-  for(i=0;list_of_arrays[i];i++)
-    {
-      log_msg(5, "Allocating %d", i);
-      ppcurr = list_of_arrays[i];
-      if (mal)
-        { *ppcurr = malloc(MAX_STR_LEN); }
-      else
-        {
-      if (*ppcurr)
-        {
-          free(*ppcurr);
-        }
-    }
-    }
-  log_msg(5, "Returning");
-  */
+    if (mal) {
+        iamhere("Malloc'ing globals");
+        malloc_string(g_boot_mountpt);
+        malloc_string(g_mondo_home);
+        malloc_string(g_tmpfs_mountpt);
+        malloc_string(g_erase_tmpdir_and_scratchdir);
+        malloc_string(g_serial_string);
+        malloc_string(g_magicdev_command);
+    } else {
+        iamhere("Freeing globals");
+        paranoid_free(g_boot_mountpt);
+        paranoid_free(g_mondo_home);
+        paranoid_free(g_tmpfs_mountpt);
+        paranoid_free(g_erase_tmpdir_and_scratchdir);
+        paranoid_free(g_serial_string);
+        paranoid_free(g_magicdev_command);
+    }
+
+    /*
+       char**list_of_arrays[] = {
+       &g_boot_mountpt,
+       &g_mondo_home,
+       &g_tmpfs_mountpt,
+       &g_erase_tmpdir_and_scratchdir,
+       &g_serial_string,
+       &g_magicdev_command,
+       NULL};
+
+       char**ppcurr;
+       int i;
+
+       for(i=0;list_of_arrays[i];i++)
+       {
+       log_msg(5, "Allocating %d", i);
+       ppcurr = list_of_arrays[i];
+       if (mal)
+       { *ppcurr = malloc(MAX_STR_LEN); }
+       else
+       {
+       if (*ppcurr)
+       {
+       free(*ppcurr);
+       }
+       }
+       }
+       log_msg(5, "Returning");
+     */
 }
 
@@ -1633 +1640 @@
 void malloc_libmondo_global_strings(void)
 {
-  do_libmondo_global_strings_thing(1);
+    do_libmondo_global_strings_thing(1);
 }
 
@@ -1642 +1649 @@
 void free_libmondo_global_strings(void)
 {
-  do_libmondo_global_strings_thing(0);
+    do_libmondo_global_strings_thing(0);
 }
 
@@ -1653 +1660 @@
 void stop_magicdev_if_necessary()
 {
-  strcpy(g_magicdev_command, call_program_and_get_last_line_of_output("ps ax | grep -w magicdev | grep -v grep | tr -s '\t' ' '| cut -d' ' -f6-99"));
-  if (g_magicdev_command[0])
-    {
-      log_msg(1, "g_magicdev_command = '%s'", g_magicdev_command);
-      paranoid_system("killall magicdev");
-    }
+    strcpy(g_magicdev_command,
+           call_program_and_get_last_line_of_output
+           ("ps ax | grep -w magicdev | grep -v grep | tr -s '\t' ' '| cut -d' ' -f6-99"));
+    if (g_magicdev_command[0]) {
+        log_msg(1, "g_magicdev_command = '%s'", g_magicdev_command);
+        paranoid_system("killall magicdev");
+    }
 }
 
@@ -1667 +1675 @@
 void restart_magicdev_if_necessary()
 {
-  char *tmp;
-  
-  malloc_string(tmp);
-  if (g_magicdev_command && g_magicdev_command[0])
-    {
-      sprintf(tmp, "%s &", g_magicdev_command);
-      paranoid_system(tmp);
-    }
-  paranoid_free(tmp);
+    char *tmp;
+
+    malloc_string(tmp);
+    if (g_magicdev_command && g_magicdev_command[0]) {
+        sprintf(tmp, "%s &", g_magicdev_command);
+        paranoid_system(tmp);
+    }
+    paranoid_free(tmp);
 }
 

trunk/mondo/mondo/common/libmondo-verify.c

@@ -403 +403 @@
     FILE *pin;
 
-    int n = 0;
+    size_t n = 0;
 
     /*@ long *********************************************************** */
@@ -458 +458 @@
         if (pin) {
             for (getline(&tmp, &n, pin); !feof(pin);
-                 fgets(&tmp, &n, pin)) {
+                 getline(&tmp, &n, pin)) {
                 if (bkpinfo->use_star) {
                     if (!strstr(tmp, "diffopts=")) {