Changeset 48 in MondoRescue

Timestamp:

Oct 6, 2005, 6:08:17 PM (20 years ago)

Author:

bcornec

Message:

asprintf + getline + memory management going on

Location:

trunk/mondo

Files:

• TODO (modified) (2 diffs)
• mondo/common/libmondo-mountlist.c (modified) (20 diffs)
• mondo/common/libmondo-verify.c (modified) (17 diffs)

trunk/mondo/TODO

@@ +1 @@
+TODO:
+
+- add encryption option (so that the archives will be encrypted)
+- remove mktemp command
+- remove goto
+- remove strcat, strcpy, sprintf
+- manage all memory dynamically (remove MAX_STR_LEN,...)
+- find safe equivalent to fread
+
+
+
+
+Old version:
+
 MONDO TODO            Hugo Rabson <hugorabson@msn.com>              07/04/2004
 
@@ -21 +35 @@
 - thoroughly document each script & its function, in the source code
 - flowchart everything; save in PostScript & publish on web
-
-
-TASKS PROCESSED
-- write a TODO file :-)
-- write a CHANGES file
-- proper command-line switches
-- more switches/options
-- make switches and '--help' user-friendly
-- make it possible to burn CDs straight from script, if user wants to
-  (using the '--call-after-iso <call>' switch)
-- well, implement some, to start with :-) <-- command-line switches
-- make it possible to write to CDRW disks directly from script, 
-  prompting for disk change <-- using '--call-make-iso <call>' switch
-- clean up the scripts, esp. mondo-archive, its "MakeTarballsAndImages" 
-  routine and the main loop
-- release a stable copy w/no known bugs & declare v0.90 (it's about time)
-  ...well, one problem reported w/user's BASH but I'm working on that ;)
-- rewrite filelist splitter (parallelize it)
-    - MakeAllFilelists &
-    - while [ "`ps MakeAllFilelists`' is running ] || [ "filelist.N+1" exists ] ; do
-        WaitForFilelist N
-        MakeSet N
-      done
-- directly support CDRs in kernel and scripts (?)
-    - to burn a CD after creating the ISO image, use
-        --call-after-iso "cdrecord ... ; eject /dev/cdrom" etc.
-    - I'm not sure if the kernel has all the necessary features compiled
-      into it; I'm looking into it.
-- write a 'man' page <----- type 'mondo-archive --help'
-- verify ISO archives against filesystem, to make sure there's no corruption
-- verify ISO filelists against original filelist, to make sure all files were
-  backed up that should have been, and none were backed up that shouldn't
-- parallelized filelist-creation and -tarballing, to improve speed
-- added --verify option, to give LOTS more confidence in archives
-- mailing list? <----- now possible, thanks to SourceForge (underway)
-- write a proper README / quickstart file
-- better self-checking for prep-me
-- make kernel modular; include modules in tarball, to be put on CD
-- multi-volume backup/restore <-- works well! :-) [v0.916]
-- easier installation from tarball
-- faster code, esp. 'set-chopper'
-- proper '--help' thingy
-- better mondo-archive and mondo-restore progress reports
-- offer to restore MBRs for user
-- give user the option of _not_ wiping all hard drives
-- let user choose which files to restore (e.g. restore-me /mnt/dos)
-- finally, Mondo uses SYSLINUX instead of COMMAND.COM (thanks, Steve Pitts)
-- hack user's restored lilo.conf and fstab to reflect the mountlist, if the
-  user has modified it;
-- let user amend mountlist semi-automatically to reflect larger/smaller hard
-  drives than original (useful for moving files from one hard drive to another)
-  ...part of check-mountlist-sanity
-- mondo-restore ----- edit mountlist (using pico)
-- Mondo now uses afio instead of tar
-- mondo-archive now much more sensible when sending info between processes
-- make Mondo distro-independent
-- save&restore all boot sectors automatically (MBRs remaining optional)
-- release RPMs and tarballs at same time
-- mondo-restore --- verify disk copy after extracting from archive
-- chop large files into blocks; reassemble them at restore-time
-- MD5 checksum for every file, inc. chopped-up files
-- remove '[' from overhead-list; put list of required packages on web page
-- make sure user knows --skip-spacetest is AT OWN RISK
-- replace instances of 'cat | grep' with just plain 'grep'
-- concatenate all fileset lists; compare to original filelist.full
-- compare mode: nondestructive comparison of filesystem with Rescue CD
-- better verify-progress feedback [Verifying 5/107]
-- hdX2,3,4 layout now works OK at backup and restore time! W00H00! :-)
-- fix Win98 boot sector kludge problem
-- speed up mondo-checksum (thanks, Fabrice!)
-- to save some time & space, do not pad the ISO image
-- build and burn CDs with one command
-- support CDRW drives
-- support SCSI hard drives
-- write straight to CD-R by calling mondo-archive w/correct params
-- use optional 2nd floppy to support extras modules, inc. SCSI hard drives
-- only let Mondo run as root
-- recompile kernel + modules for i386
-- added ReiserFS support
-- amalgamated the Mondo RPMs/TGZs into a single ball
-- let user incorporate their own kernel and tools (thanks to Mindi!)
-- Linux 2.4 kernel support
-- add XFS support
-- add ext3 support
-- add JFS support
-- add ReiserFS support
-- give comprehensive restore-time feedback (not just '%done')
-- pipe mkisofs to cdrecord, saving a lot of disk space & some time
-- add Windows ME and Windows 2000 support (VFAT only)
-- make the SRPM recompile Mondo's C programs
-- RAID support
-- make it possible to use an NFS-mounted partition as scratch/iso dir
-- write a proper manual
-- add Red Hat LABEL support (/etc/fstab)
-- record '%age full' of each partition at backup-time
-- newt/ncurses interface would be cool
-- implement user-friendly mountlist editor
-- progress screen (mondo-tarme)
-- check that the partitions will fit on the hard drives
-- verify ISO after creating if (if user uses '--verify')
-- verify CD after burning if (if user uses '--verify')
-- support parallel-port CD writers
-- support tape drives
-- test with Red Hat 7.2
-- incremental/differential backup mode
-- add GRUB support
-- make it possible to backup and restore partitions of an unknown type
-- incorporate busybox-0.60-2
-- put data disks on tape, so that tape users only need 1 floppy + tape
-- text mode
-- add "NFS" boot option
-- drop trailing slashes from all params of --exclude-path
-- add Petris :)
-- Tab-format fstab after 'hacking' it
-- Interactive Mode should let the user choose which partitions to format
-- add an "exclude path?" dialog to Interactive Mode
-- re-enable CD verification
-- if creation/format fails, go back to mountlist editor
-- let user choose which partitions to format
-- port mondo-archive entirely to C
-- if -E /dev/xxx then exclude _device_ from mountlist but don't exclude
-  /dev file from filelist
-- rewrite the "is tape there?" test: if 'V' then RO test; if 'O' then RW test
-- allow mondorestore to be used to restore to live filesystems
-- add /proc/cpuinfo to logfile
-- enable Ctrl-C --> abort in mondoarchive and mindi
-- write a 'man' page
-- test w/multiple tapes
-- an easy-to-use interface to Mondo-archive which does a lot of the
-  fiddly configurating for you
-- if Compare Mode then popup list of /tmp/changed.files
-- only zero drive /dev/hdXn if /dev/hdX1 is being prepped
-- if differential backup then disable nuke at restore-time
-- write X-based front end to mondoarchive/mondorestore (XMondo)
-- added partimagehack to Mondo (freeloader - you know who you are - please
-  quit being a dick)
-- put serial# on each CD/tape
-- give Mondo+Mindi a CVS
-- add parted
-- Ian Mortimer's spec patches
-- encourage -X
-
-
-ABANDONED
-- detect size of CDR automatically (I don't know how)
-- allow user to choose archive engine besides tar (e.g. star, cpio)
-  ...tar sucked; star _really_ sucked; cpio, forget it; I chose afio in the end
-  because it was the only engine which I knew would work. I've used it for
-  years w/o any problems. Tar has been nothing but a headache.
-- split up mondo-archive's functionality into separate scripts, so that it will
-  be possible to backup files, do something else, then archive it, etc.etc. 
-  ...too much trouble; no incentive to do it; no-one asked me to :)
-- pseudocode
-  ...why bother? If bash scripts are too complicated for you, try COBOL...

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

@@ -1 @@
-/* libmondo-mountlist.c                            subroutines for handling mountlist
-   $Id: libmondo-mountlist.c,v 1.2 2004/06/10 15:29:12 hugo Exp $
-
-
-
-08/01
-- when evaluating mountlist, skip drive entirely if it does not exist
-
-07/14
-- always exclude /devpts, /proc, /sys from mountlist
-   
-06/29/2004
-- changed some char[] to *char
-- drivelist is struct now, not char[][]
-
-10/19/2003
-- format_device() --- contract /dev/md/N to /dev/mdN to
-  overcome devfs problems
-
-06/11
-- added support for 5th column in mountlist.txt, for labels
-
-05/08
-- added save_mountlist_to_disk() and load_mountlist()
-  and misc other funcs from mondorestore.c
-
-05/05
-- added Joshua Oreman's FreeBSD patches
-
-04/24
-- added some assert()'s
-
-04/23
-- cleaned up evaluate_drive_within_mountlist() a bit
-
-01/15/2003
-- added code for LVM (Brian Borgeson)
-
-10/19/2002
-- added some comments
-
-07/24/2002
-- created
+/* $Id$
+subroutines for handling mountlist
 */
-
 
 /**
@@ -61 +19 @@
 
 /*@unused@*/
-//static char cvsid[] = "$Id: libmondo-mountlist.c,v 1.2 2004/06/10 15:29:12 hugo Exp $";
+//static char cvsid[] = "$Id$";
 
 /**
@@ -85 +43 @@
  * @see evaluate_mountlist
  */
-int evaluate_drive_within_mountlist (struct mountlist_itself *mountlist,
-                 char *drive, char *flaws_str)
+int evaluate_drive_within_mountlist(struct mountlist_itself *mountlist,
+                                    char *drive, char *flaws_str)
 #ifdef __FreeBSD__
 {
 // FreeBSD-specific version of evaluate_drive_within_mountlist()
-    /*@ int **************************************************************/
-  int prev_part_no = 0;
+    /*@ int ************************************************************* */
+    int prev_part_no = 0;
     int curr_part_no = 0;
     int pos = 0, npos = 0;
@@ -102 +60 @@
     int foundsome = FALSE;
 
-    /*@ buffers *********************************************************/
-  char tmp[MAX_STR_LEN];
-    char device[MAX_STR_LEN];
-    char mountpoint[MAX_STR_LEN];
-
-    /*@ long ************************************************************/
-  long physical_drive_size = 0;
+    /*@ buffers ******************************************************** */
+    char *tmp;
+    char *device;
+    // BERLIOS : useless ? char *mountpoint;
+
+    /*@ long *********************************************************** */
+    long physical_drive_size = 0;
     long amount_allocated = 0;
 
-    /*@ pointers ********************************************************/
+    /*@ pointers ******************************************************* */
     char *part_table_fmt;
 
-    /*@ initialize ******************************************************/
-  flaws_str[0] = '\0';
-  prev_part_no = 0;
-  tmp[0] = '\0';
-
-
-  physical_drive_size = get_phys_size_of_drive (drive);
-
-  if (physical_drive_size < 0)
-    {
-      sprintf (tmp, " %s does not exist.", drive);
-      strcat (flaws_str, tmp);
-    }
-  else
-    {
-      sprintf (tmp, "%s is %ld MB", drive, physical_drive_size);
-    }
-  log_it (tmp);
-  
-
-  /* check DD */
-  for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {
-      sprintf (device, "%s%c", drive, cur_sp_no);
-      if (find_device_in_mountlist (mountlist, device) >= 0)
-      foundsome = TRUE;
-  }
-  if (foundsome) {
-      for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {   
-      sprintf (device, "%s%c", drive, cur_sp_no);
-      pos = find_device_in_mountlist (mountlist, device);
-      if (pos < 0)
-          {
-          continue;
-          }
-      strcpy (mountpoint, mountlist->el[pos].mountpoint);
-      /* is it too big? */
-      if (curr_part_no > 'h')
-          {
-          sprintf (tmp, " Can only have up to 'h' in disklabel.");
-          log_it (tmp);
-          strcat (flaws_str, tmp);
-          res++;
-          }
-      /* does partition /dev/adXsYZ exist more than once in the mountlist? */
-      for (i = 0, mountpoint_copies = 0, device_copies = 0;
-           i < mountlist->entries; i++)
-          {
-          if (!strcmp (device, mountlist->el[i].device))
-              {
-              device_copies++;
-              }
-          }
-      if (device_copies > 1)
-          {
-          sprintf (tmp, " %s %s's.", number_to_text (device_copies), device);
-          if (!strstr (flaws_str, tmp))
-              {
-              log_it (tmp);
-              strcat (flaws_str, tmp);
-              res++;
-              }
-          }
-      /* silly partition size? */
-      if (mountlist->el[pos].size < 8192
-          && strcmp (mountlist->el[pos].mountpoint, "lvm"))
-          {
-          sprintf (tmp, " %s is tiny!", device);
-          log_it (tmp);
-          strcat (flaws_str, tmp);
-          res++;
-          }
-      /* mountpoint should begin with / unless it is swap, lvm or raid */
-      if (strcmp (mountlist->el[pos].mountpoint, "swap")
-          && strcmp (mountlist->el[pos].mountpoint, "lvm")
-          && strcmp (mountlist->el[pos].mountpoint, "raid")
-          && strcmp (mountlist->el[pos].mountpoint, "image")
-          && strcmp (mountlist->el[pos].mountpoint, "none")
-          && mountlist->el[pos].mountpoint[0] != '/')
-          {
-          sprintf (tmp, " %s has a weird mountpoint.", device);
-          log_it (tmp);
-          strcat (flaws_str, tmp);
-          res++;
-          }
-      /* is format sensible? */
-      if (!is_this_a_valid_disk_format (mountlist->el[pos].format))
-          {
-          sprintf (tmp, " %s has unsupported format.", device);
-          log_it (tmp);
-          strcat (flaws_str, tmp);
-          res++;
-          }
-      amount_allocated += mountlist->el[pos].size / 1024;
-      prev_sp_no = cur_sp_no;
-      }
-  }
-
-  npos = pos = 0;
-  for (curr_part_no = 1; curr_part_no < 99; curr_part_no++)
-    {
-      sprintf (device, "%ss%d", drive, curr_part_no);
-      pos = find_device_in_mountlist (mountlist, device);
-      npos = 0;
-      for (cur_sp_no = 'a'; cur_sp_no <= 'h'; cur_sp_no++) {
-      sprintf (device, "%ss%i%c", device, curr_part_no, cur_sp_no);
-      if (find_device_in_mountlist (mountlist, device) >= 0) npos++;
-      }
-      if (((pos >= 0) || npos) && foundsome) {
-      sprintf (flaws_str + strlen (flaws_str), " %s has both DD and PC-style partitions.", drive);
-      return ++res; // fatal error
-      }
-      
-      sprintf (device, "%ss%d", drive, curr_part_no);
-      strcpy (mountpoint, mountlist->el[pos].mountpoint);
-      if (pos > 0 && !npos) {
-      /* gap in the partition list? */
-      if (curr_part_no - prev_part_no > 1)
-          {
-          if (prev_part_no == 0)
-              {
-              sprintf (tmp, " Gap prior to %s.", device);
-              log_it (tmp);
-              strcat (flaws_str, tmp);
-              res++;
-              }
-          else if (curr_part_no > 5
-               || (curr_part_no <= 4 && prev_part_no > 0))
-              {
-              sprintf (tmp, " Gap between %ss%d and %d.", drive, prev_part_no,
-                   curr_part_no);
-              log_it (tmp);
-              strcat (flaws_str, tmp);
-              res++;
-              }
-          }
-      /* GPT allows more than 4 primary partitions */
-      part_table_fmt = which_partition_format(drive);
-      /* no spare primary partitions to help accommodate the logical(s)? */
-      if ((curr_part_no >= 5 && prev_part_no == 4) && (strcmp(part_table_fmt,"MBR") == 0)) 
-          {
-          sprintf (tmp, " Partition %ss4 is occupied.", drive);
-          log_it (tmp);
-          strcat (flaws_str, tmp);
-          res++;
-          }
-      /* does partition /dev/adXsY exist more than once in the mountlist? */
-      for (i = 0, mountpoint_copies = 0, device_copies = 0;
-           i < mountlist->entries; i++)
-          {
-          if (!strcmp (device, mountlist->el[i].device))
-              {
-              device_copies++;
-              }
-          }
-      if (device_copies > 1)
-          {
-          sprintf (tmp, " %s %s's.", number_to_text (device_copies), device);
-          if (!strstr (flaws_str, tmp))
-              {
-              log_it (tmp);
-              strcat (flaws_str, tmp);
-              res++;
-              }
-          }
-      /* silly partition size? */
-      if (mountlist->el[pos].size < 8192
-          && strcmp (mountlist->el[pos].mountpoint, "lvm"))
-          {
-          sprintf (tmp, " %s is tiny!", device);
-          log_it (tmp);
-          strcat (flaws_str, tmp);
-          res++;
-          }
-      /* mountpoint should begin with / unless it is swap, lvm or raid */
-      if (strcmp (mountlist->el[pos].mountpoint, "swap")
-          && strcmp (mountlist->el[pos].mountpoint, "lvm")
-          && strcmp (mountlist->el[pos].mountpoint, "raid")
-          && strcmp (mountlist->el[pos].mountpoint, "image")
-          && strcmp (mountlist->el[pos].mountpoint, "none")
-          && mountlist->el[pos].mountpoint[0] != '/')
-          {
-          sprintf (tmp, " %s has a weird mountpoint.", device);
-          log_it (tmp);
-          strcat (flaws_str, tmp);
-          res++;
-          }
-      /* is format sensible? */
-      if (!is_this_a_valid_disk_format (mountlist->el[pos].format))
-          {
-          sprintf (tmp, " %s has unsupported format.", device);
-          log_it (tmp);
-          strcat (flaws_str, tmp);
-          res++;
-          }
-      } else {
-      /* Check subpartitions */
-      for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {   
-          sprintf (device, "%ss%d%c", drive, curr_part_no, cur_sp_no);
-          pos = find_device_in_mountlist (mountlist, device);
-          if (pos < 0)
-          {
-          continue;
-          }
-          strcpy (mountpoint, mountlist->el[pos].mountpoint);
-          /* is it too big? */
-          if (curr_part_no > 'h')
-          {
-              sprintf (tmp, " Can only have up to 'h' in disklabel.");
-              log_it (tmp);
-              strcat (flaws_str, tmp);
-              res++;
-          }
-          /* does partition /dev/adXsYZ exist more than once in the mountlist? */
-          for (i = 0, mountpoint_copies = 0, device_copies = 0;
-           i < mountlist->entries; i++)
-          {
-              if (!strcmp (device, mountlist->el[i].device))
-              {
-                  device_copies++;
-              }
-          }
-          if (device_copies > 1)
-          {
-              sprintf (tmp, " %s %s's.", number_to_text (device_copies), device);
-              if (!strstr (flaws_str, tmp))
-              {
-                  log_it (tmp);
-                  strcat (flaws_str, tmp);
-                  res++;
-              }
-          }
-          /* silly partition size? */
-          if (mountlist->el[pos].size < 8192
-          && strcmp (mountlist->el[pos].mountpoint, "lvm"))
-          {
-              sprintf (tmp, " %s is tiny!", device);
-              log_it (tmp);
-              strcat (flaws_str, tmp);
-              res++;
-          }
-          /* mountpoint should begin with / unless it is swap, lvm or raid */
-          if (strcmp (mountlist->el[pos].mountpoint, "swap")
-          && strcmp (mountlist->el[pos].mountpoint, "lvm")
-          && strcmp (mountlist->el[pos].mountpoint, "raid")
-          && strcmp (mountlist->el[pos].mountpoint, "image")
-          && strcmp (mountlist->el[pos].mountpoint, "none")
-          && mountlist->el[pos].mountpoint[0] != '/')
-          {
-              sprintf (tmp, " %s has a weird mountpoint.", device);
-              log_it (tmp);
-              strcat (flaws_str, tmp);
-              res++;
-          }
-          /* is format sensible? */
-          if (!is_this_a_valid_disk_format (mountlist->el[pos].format))
-          {
-              sprintf (tmp, " %s has unsupported format.", device);
-              log_it (tmp);
-              strcat (flaws_str, tmp);
-              res++;
-          }
-          amount_allocated += mountlist->el[pos].size / 1024;
-          prev_sp_no = cur_sp_no;
-      }
-      }
-      
-      /* OK, continue with main loop */
-      amount_allocated += mountlist->el[pos].size / 1024;
-      prev_part_no = curr_part_no;
-    }
-
-  /* Over-allocated the disk? Unallocated space on disk? */
-  if (amount_allocated > physical_drive_size)  // Used to be +1, but what if you're 1 MB too high?
-    {
-      sprintf (tmp, " %ld MB over-allocated on %s.",
-           amount_allocated - physical_drive_size, drive);
-      log_it (tmp);
-      strcat (flaws_str, tmp);
-      res++;
-    }
-  else if (amount_allocated < physical_drive_size - 1)
-    {               /* NOT AN ERROR, JUST A WARNING :-) */
-      sprintf (tmp, " %ld MB unallocated on %s.",
-           physical_drive_size - amount_allocated, drive);
-      log_it (tmp), strcat (flaws_str, tmp);
-    }
-  if (res)
-    {
-      return (FALSE);
-    }
-  else
-    {
-      return (TRUE);
-    }
+    /*@ initialize ***************************************************** */
+    flaws_str[0] = '\0';
+    prev_part_no = 0;
+    // BERLIOS: tmp[0] = '\0';
+
+
+    physical_drive_size = get_phys_size_of_drive(drive);
+
+    if (physical_drive_size < 0) {
+        asprintf(&tmp, " %s does not exist.", drive);
+        strcat(flaws_str, tmp);
+    } else {
+        asprintf(&tmp, "%s is %ld MB", drive, physical_drive_size);
+    }
+    log_it(tmp);
+    paranoid_free(tmp);
+
+
+    /* check DD */
+    for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {
+        asprintf(&device, "%s%c", drive, cur_sp_no);
+        if (find_device_in_mountlist(mountlist, device) >= 0)
+            foundsome = TRUE;
+        paranoid_free(device);
+    }
+    if (foundsome) {
+        for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {
+            asprintf(&device, "%s%c", drive, cur_sp_no);
+            pos = find_device_in_mountlist(mountlist, device);
+            if (pos < 0) {
+                continue;
+            }
+            // BERLIOS : useless ? asprintf(&mountpoint, mountlist->el[pos].mountpoint);
+            /* is it too big? */
+            if (curr_part_no > 'h') {
+                asprintf(&tmp, " Can only have up to 'h' in disklabel.");
+                log_it(tmp);
+                strcat(flaws_str, tmp);
+                paranoid_free(tmp);
+                res++;
+            }
+            /* does partition /dev/adXsYZ exist more than once in the mountlist? */
+            for (i = 0, mountpoint_copies = 0, device_copies = 0;
+                 i < mountlist->entries; i++) {
+                if (!strcmp(device, mountlist->el[i].device)) {
+                    device_copies++;
+                }
+            }
+            if (device_copies > 1) {
+                asprintf(&tmp, " %s %s's.", number_to_text(device_copies),
+                        device);
+                if (!strstr(flaws_str, tmp)) {
+                    log_it(tmp);
+                    strcat(flaws_str, tmp);
+                    res++;
+                }
+                paranoid_free(tmp);
+            }
+            /* silly partition size? */
+            if (mountlist->el[pos].size < 8192
+                && strcmp(mountlist->el[pos].mountpoint, "lvm")) {
+                asprintf(&tmp, " %s is tiny!", device);
+                log_it(tmp);
+                strcat(flaws_str, tmp);
+                paranoid_free(tmp);
+                res++;
+            }
+            /* mountpoint should begin with / unless it is swap, lvm or raid */
+            if (strcmp(mountlist->el[pos].mountpoint, "swap")
+                && strcmp(mountlist->el[pos].mountpoint, "lvm")
+                && strcmp(mountlist->el[pos].mountpoint, "raid")
+                && strcmp(mountlist->el[pos].mountpoint, "image")
+                && strcmp(mountlist->el[pos].mountpoint, "none")
+                && mountlist->el[pos].mountpoint[0] != '/') {
+                asprintf(&tmp, " %s has a weird mountpoint.", device);
+                log_it(tmp);
+                strcat(flaws_str, tmp);
+                paranoid_free(tmp);
+                res++;
+            }
+            /* is format sensible? */
+            if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) {
+                asprintf(&tmp, " %s has unsupported format.", device);
+                log_it(tmp);
+                strcat(flaws_str, tmp);
+                paranoid_free(tmp);
+                res++;
+            }
+            amount_allocated += mountlist->el[pos].size / 1024;
+            prev_sp_no = cur_sp_no;
+
+            paranoid_free(device);
+        }
+    }
+
+    npos = pos = 0;
+    for (curr_part_no = 1; curr_part_no < 99; curr_part_no++) {
+        asprintf(&device, "%ss%d", drive, curr_part_no);
+        pos = find_device_in_mountlist(mountlist, device);
+        npos = 0;
+        for (cur_sp_no = 'a'; cur_sp_no <= 'h'; cur_sp_no++) {
+            sprintf(device, "%ss%i%c", device, curr_part_no, cur_sp_no);
+            if (find_device_in_mountlist(mountlist, device) >= 0)
+                npos++;
+        }
+        paranoid_free(device);
+
+        if (((pos >= 0) || npos) && foundsome) {
+            sprintf(flaws_str + strlen(flaws_str),
+                    " %s has both DD and PC-style partitions.", drive);
+            return ++res;       // fatal error
+        }
+
+        // BERLIOS : useless ? asprintf(&mountpoint, mountlist->el[pos].mountpoint);
+        if (pos > 0 && !npos) {
+            asprintf(&device, "%ss%d", drive, curr_part_no);
+            /* gap in the partition list? */
+            if (curr_part_no - prev_part_no > 1) {
+                if (prev_part_no == 0) {
+                    asprintf(&tmp, " Gap prior to %s.", device);
+                    log_it(tmp);
+                    strcat(flaws_str, tmp);
+                    paranoid_free(tmp);
+                    res++;
+                } else if (curr_part_no > 5
+                           || (curr_part_no <= 4 && prev_part_no > 0)) {
+                    asprintf(&tmp, " Gap between %ss%d and %d.", drive,
+                            prev_part_no, curr_part_no);
+                    log_it(tmp);
+                    strcat(flaws_str, tmp);
+                    paranoid_free(tmp);
+                    res++;
+                }
+            }
+            /* GPT allows more than 4 primary partitions */
+            part_table_fmt = which_partition_format(drive);
+            /* no spare primary partitions to help accommodate the logical(s)? */
+            if ((curr_part_no >= 5 && prev_part_no == 4)
+                && (strcmp(part_table_fmt, "MBR") == 0)) {
+                asprintf(&tmp, " Partition %ss4 is occupied.", drive);
+                log_it(tmp);
+                strcat(flaws_str, tmp);
+                paranoid_free(tmp);
+                res++;
+            }
+            /* does partition /dev/adXsY exist more than once in the mountlist? */
+            for (i = 0, mountpoint_copies = 0, device_copies = 0;
+                 i < mountlist->entries; i++) {
+                if (!strcmp(device, mountlist->el[i].device)) {
+                    device_copies++;
+                }
+            }
+            if (device_copies > 1) {
+                asprintf(&tmp, " %s %s's.", number_to_text(device_copies),
+                        device);
+                if (!strstr(flaws_str, tmp)) {
+                    log_it(tmp);
+                    strcat(flaws_str, tmp);
+                    res++;
+                }
+                paranoid_free(tmp);
+            }
+            /* silly partition size? */
+            if (mountlist->el[pos].size < 8192
+                && strcmp(mountlist->el[pos].mountpoint, "lvm")) {
+                asprintf(&tmp, " %s is tiny!", device);
+                log_it(tmp);
+                strcat(flaws_str, tmp);
+                paranoid_free(tmp);
+                res++;
+            }
+            /* mountpoint should begin with / unless it is swap, lvm or raid */
+            if (strcmp(mountlist->el[pos].mountpoint, "swap")
+                && strcmp(mountlist->el[pos].mountpoint, "lvm")
+                && strcmp(mountlist->el[pos].mountpoint, "raid")
+                && strcmp(mountlist->el[pos].mountpoint, "image")
+                && strcmp(mountlist->el[pos].mountpoint, "none")
+                && mountlist->el[pos].mountpoint[0] != '/') {
+                asprintf(&tmp, " %s has a weird mountpoint.", device);
+                log_it(tmp);
+                strcat(flaws_str, tmp);
+                paranoid_free(tmp);
+                res++;
+            }
+            /* is format sensible? */
+            if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) {
+                asprintf(&tmp, " %s has unsupported format.", device);
+                log_it(tmp);
+                strcat(flaws_str, tmp);
+                paranoid_free(tmp);
+                res++;
+            }
+            paranoid_free(device);
+        } else {
+            /* Check subpartitions */
+            for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {
+                asprintf(&device, "%ss%d%c", drive, curr_part_no, cur_sp_no);
+                pos = find_device_in_mountlist(mountlist, device);
+                if (pos < 0) {
+                    continue;
+                }
+                // BERLIOS : useless ? asprintf(&mountpoint, mountlist->el[pos].mountpoint);
+                /* is it too big? */
+                if (curr_part_no > 'h') {
+                    asprintf(&tmp, " Can only have up to 'h' in disklabel.");
+                    log_it(tmp);
+                    strcat(flaws_str, tmp);
+                    paranoid_free(tmp);
+                    res++;
+                }
+                /* does partition /dev/adXsYZ exist more than once in the mountlist? */
+                for (i = 0, mountpoint_copies = 0, device_copies = 0;
+                     i < mountlist->entries; i++) {
+                    if (!strcmp(device, mountlist->el[i].device)) {
+                        device_copies++;
+                    }
+                }
+                if (device_copies > 1) {
+                    asprintf(&tmp, " %s %s's.",
+                            number_to_text(device_copies), device);
+                    if (!strstr(flaws_str, tmp)) {
+                        log_it(tmp);
+                        strcat(flaws_str, tmp);
+                        res++;
+                    }
+                    paranoid_free(tmp);
+                }
+                /* silly partition size? */
+                if (mountlist->el[pos].size < 8192
+                    && strcmp(mountlist->el[pos].mountpoint, "lvm")) {
+                    asprintf(&tmp, " %s is tiny!", device);
+                    log_it(tmp);
+                    strcat(flaws_str, tmp);
+                    paranoid_free(tmp);
+                    res++;
+                }
+                /* mountpoint should begin with / unless it is swap, lvm or raid */
+                if (strcmp(mountlist->el[pos].mountpoint, "swap")
+                    && strcmp(mountlist->el[pos].mountpoint, "lvm")
+                    && strcmp(mountlist->el[pos].mountpoint, "raid")
+                    && strcmp(mountlist->el[pos].mountpoint, "image")
+                    && strcmp(mountlist->el[pos].mountpoint, "none")
+                    && mountlist->el[pos].mountpoint[0] != '/') {
+                    asprintf(&tmp, " %s has a weird mountpoint.", device);
+                    log_it(tmp);
+                    strcat(flaws_str, tmp);
+                    paranoid_free(tmp);
+                    res++;
+                }
+                /* is format sensible? */
+                if (!is_this_a_valid_disk_format
+                    (mountlist->el[pos].format)) {
+                    asprintf(&tmp, " %s has unsupported format.", device);
+                    log_it(tmp);
+                    strcat(flaws_str, tmp);
+                    paranoid_free(tmp);
+                    res++;
+                }
+                amount_allocated += mountlist->el[pos].size / 1024;
+                prev_sp_no = cur_sp_no;
+                paranoid_free(device);
+            }
+        }
+
+        /* OK, continue with main loop */
+        amount_allocated += mountlist->el[pos].size / 1024;
+        prev_part_no = curr_part_no;
+    }
+
+    /* Over-allocated the disk? Unallocated space on disk? */
+    if (amount_allocated > physical_drive_size) // Used to be +1, but what if you're 1 MB too high?
+    {
+        asprintf(&tmp, " %ld MB over-allocated on %s.",
+                amount_allocated - physical_drive_size, drive);
+        log_it(tmp);
+        strcat(flaws_str, tmp);
+        paranoid_free(tmp);
+        res++;
+    } else if (amount_allocated < physical_drive_size - 1) {    /* NOT AN ERROR, JUST A WARNING :-) */
+        asprintf(&tmp, " %ld MB unallocated on %s.",
+                physical_drive_size - amount_allocated, drive);
+        log_it(tmp);
+        strcat(flaws_str, tmp);
+        paranoid_free(tmp);
+    }
+    if (res) {
+        return (FALSE);
+    } else {
+        return (TRUE);
+    }
 }
 
@@ -414 +368 @@
 {
 
-    /*@ int **************************************************************/
-  int prev_part_no = 0;
+    /*@ int ************************************************************* */
+    int prev_part_no = 0;
     int curr_part_no = 0;
     int pos = 0;
@@ -423 +377 @@
     int i = 0;
 
-    /*@ buffers *********************************************************/
-  char *tmp;
+    /*@ buffers ******************************************************** */
+    char *tmp;
     char *device;
     char *mountpoint;
 
-    /*@ long ************************************************************/
-  long physical_drive_size = 0;
+    /*@ long *********************************************************** */
+    long physical_drive_size = 0;
     long amount_allocated = 0;
 
-    /*@ pointers ********************************************************/
+    /*@ pointers ******************************************************* */
     char *part_table_fmt;
 
-    /*@ initialize ******************************************************/
-  assert_string_is_neither_NULL_nor_zerolength(drive);
-  assert(mountlist!=NULL);
-  assert(flaws_str!=NULL);
-
-  malloc_string(tmp);
-  malloc_string(device);
-  malloc_string(mountpoint);
-  flaws_str[0] = '\0';
-  prev_part_no = 0;
-  tmp[0] = '\0';
-
-
-  physical_drive_size = get_phys_size_of_drive (drive);
-
-  if (physical_drive_size < 0)
-    {
-      sprintf (tmp, " %s does not exist.", drive);
-      strcat (flaws_str, tmp);
-      res++;
-      log_msg(1, tmp);
-      goto endoffunc;
-    }
-  else
-    {
-      sprintf (tmp, "%s is %ld MB", drive, physical_drive_size);
-      log_it (tmp);
-    }
-
-  for (curr_part_no = 1; curr_part_no < 99; curr_part_no++)
-    {
-      sprintf (device, "%s%d", drive, curr_part_no);
-      pos = find_device_in_mountlist (mountlist, device);
-      if (pos < 0)
-    {
-      continue;
-    }
-      if (physical_drive_size < 0)
-        {
-          sprintf(tmp, " %s refers to non-existent hardware.", device);
-          strcat (flaws_str, tmp);
-          res++;
-          continue;
-        }
-      strcpy (mountpoint, mountlist->el[pos].mountpoint);
-      /* gap in the partition list? */
-      if (curr_part_no - prev_part_no > 1)
-    {
-      if (prev_part_no == 0)
-        {
-          sprintf (tmp, " Gap prior to %s.", device);
-          log_it (tmp);
-          strcat (flaws_str, tmp);
-          res++;
-        }
-      else if (curr_part_no > 5
-           || (curr_part_no <= 4 && prev_part_no > 0))
-        {
-          sprintf (tmp, " Gap between %s%d and %d.", drive, prev_part_no,
-               curr_part_no);
-          log_it (tmp);
-          strcat (flaws_str, tmp);
-          res++;
-        }
-    }
-      /* GPT allows more than 4 primary partitions */
-      part_table_fmt = which_partition_format(drive);
-      /* no spare primary partitions to help accommodate the logical(s)? */
-      if ((curr_part_no >= 5 && prev_part_no == 4) && (strcmp(part_table_fmt,"MBR") == 0)) 
-    {
-      sprintf (tmp, " Partition %s4 is occupied.", drive);
-      log_it (tmp);
-      strcat (flaws_str, tmp);
-      res++;
-    }
-      /* does partition /dev/hdNX exist more than once in the mountlist? */
-      for (i = 0, mountpoint_copies = 0, device_copies = 0;
-       i < mountlist->entries; i++)
-    {
-      if (!strcmp (device, mountlist->el[i].device))
-        {
-          device_copies++;
-        }
-    }
-      if (device_copies > 1)
-    {
-      sprintf (tmp, " %s %s's.", number_to_text (device_copies), device);
-      if (!strstr (flaws_str, tmp))
-        {
-          log_it (tmp);
-          strcat (flaws_str, tmp);
-          res++;
-        }
-    }
-      /* silly partition size? */
-      if (mountlist->el[pos].size < 8192
-      && strcmp (mountlist->el[pos].mountpoint, "lvm"))
-    {
-      sprintf (tmp, " %s is tiny!", device);
-      log_it (tmp);
-      strcat (flaws_str, tmp);
-      res++;
-    }
-      /* mountpoint should begin with / unless it is swap, lvm or raid */
-      if (strcmp (mountlist->el[pos].mountpoint, "swap")
-      && strcmp (mountlist->el[pos].mountpoint, "lvm")
-      && strcmp (mountlist->el[pos].mountpoint, "raid")
-      && strcmp (mountlist->el[pos].mountpoint, "image")
-      && mountlist->el[pos].mountpoint[0] != '/')
-    {
-      sprintf (tmp, " %s has a weird mountpoint.", device);
-      log_it (tmp);
-      strcat (flaws_str, tmp);
-      res++;
-    }
-      /* is format sensible? */
-      if (!is_this_a_valid_disk_format (mountlist->el[pos].format))
-    {
-      sprintf (tmp, " %s has unsupported format.", device);
-      log_it (tmp);
-      strcat (flaws_str, tmp);
-      res++;
-    }
-      /* OK, continue with main loop */
-      amount_allocated += mountlist->el[pos].size / 1024;
-      prev_part_no = curr_part_no;
-    }
-
-  /* Over-allocated the disk? Unallocated space on disk? */
-  if (amount_allocated > physical_drive_size + 1)
-    {
-      sprintf (tmp, " %ld MB over-allocated on %s.",
-           amount_allocated - physical_drive_size, drive);
-      log_it (tmp);
-      strcat (flaws_str, tmp);
-      res++;
-    }
-  else if (amount_allocated < physical_drive_size - 1)
-    {               /* NOT AN ERROR, JUST A WARNING :-) */
-      sprintf (tmp, " %ld MB unallocated on %s.",
-           physical_drive_size - amount_allocated, drive);
-      log_it (tmp), strcat (flaws_str, tmp);
-    }
-
-endoffunc:
-  paranoid_free(tmp);
-  paranoid_free(device);
-  paranoid_free(mountpoint);
-  
-  if (res)
-    {
-      return (FALSE);
-    }
-  else
-    {
-      return (TRUE);
-    }
+    /*@ initialize ***************************************************** */
+    assert_string_is_neither_NULL_nor_zerolength(drive);
+    assert(mountlist != NULL);
+    assert(flaws_str != NULL);
+
+    flaws_str[0] = '\0';
+    prev_part_no = 0;
+    // BERLIOS : useless ? tmp[0] = '\0';
+
+
+    physical_drive_size = get_phys_size_of_drive(drive);
+
+    if (physical_drive_size < 0) {
+        asprintf(&tmp, " %s does not exist.", drive);
+        strcat(flaws_str, tmp);
+        res++;
+        log_msg(1, tmp);
+        paranoid_free(tmp);
+        return(FALSE);
+    } else {
+        asprintf(&tmp, "%s is %ld MB", drive, physical_drive_size);
+        log_it(tmp);
+        paranoid_free(tmp);
+    }
+
+    for (curr_part_no = 1; curr_part_no < 99; curr_part_no++) {
+        asprintf(&device, "%s%d", drive, curr_part_no);
+        pos = find_device_in_mountlist(mountlist, device);
+        if (pos < 0) {
+            continue;
+        }
+        if (physical_drive_size < 0) {
+            asprintf(&tmp, " %s refers to non-existent hardware.", device);
+            strcat(flaws_str, tmp);
+            res++;
+            paranoid_free(tmp);
+            continue;
+        }
+        // BERLIOS : useless ? strcpy(mountpoint, mountlist->el[pos].mountpoint);
+        /* gap in the partition list? */
+        if (curr_part_no - prev_part_no > 1) {
+            if (prev_part_no == 0) {
+                asprintf(&tmp, " Gap prior to %s.", device);
+                log_it(tmp);
+                strcat(flaws_str, tmp);
+                paranoid_free(tmp);
+                res++;
+            } else if (curr_part_no > 5
+                       || (curr_part_no <= 4 && prev_part_no > 0)) {
+                asprintf(&tmp, " Gap between %s%d and %d.", drive,
+                        prev_part_no, curr_part_no);
+                log_it(tmp);
+                strcat(flaws_str, tmp);
+                paranoid_free(tmp);
+                res++;
+            }
+        }
+        /* GPT allows more than 4 primary partitions */
+        part_table_fmt = which_partition_format(drive);
+        /* no spare primary partitions to help accommodate the logical(s)? */
+        if ((curr_part_no >= 5 && prev_part_no == 4)
+            && (strcmp(part_table_fmt, "MBR") == 0)) {
+            asprintf(&tmp, " Partition %s4 is occupied.", drive);
+            log_it(tmp);
+            strcat(flaws_str, tmp);
+            paranoid_free(tmp);
+            res++;
+        }
+        /* does partition /dev/hdNX exist more than once in the mountlist? */
+        for (i = 0, mountpoint_copies = 0, device_copies = 0;
+             i < mountlist->entries; i++) {
+            if (!strcmp(device, mountlist->el[i].device)) {
+                device_copies++;
+            }
+        }
+        if (device_copies > 1) {
+            asprintf(&tmp, " %s %s's.", number_to_text(device_copies),
+                    device);
+            if (!strstr(flaws_str, tmp)) {
+                log_it(tmp);
+                strcat(flaws_str, tmp);
+                res++;
+            }
+            paranoid_free(tmp);
+        }
+        /* silly partition size? */
+        if (mountlist->el[pos].size < 8192
+            && strcmp(mountlist->el[pos].mountpoint, "lvm")) {
+            asprintf(&tmp, " %s is tiny!", device);
+            log_it(tmp);
+            strcat(flaws_str, tmp);
+            paranoid_free(tmp);
+            res++;
+        }
+        /* mountpoint should begin with / unless it is swap, lvm or raid */
+        if (strcmp(mountlist->el[pos].mountpoint, "swap")
+            && strcmp(mountlist->el[pos].mountpoint, "lvm")
+            && strcmp(mountlist->el[pos].mountpoint, "raid")
+            && strcmp(mountlist->el[pos].mountpoint, "image")
+            && mountlist->el[pos].mountpoint[0] != '/') {
+            asprintf(&tmp, " %s has a weird mountpoint.", device);
+            log_it(tmp);
+            strcat(flaws_str, tmp);
+            paranoid_free(tmp);
+            res++;
+        }
+        /* is format sensible? */
+        if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) {
+            asprintf(&tmp, " %s has unsupported format.", device);
+            log_it(tmp);
+            strcat(flaws_str, tmp);
+            paranoid_free(tmp);
+            res++;
+        }
+        /* OK, continue with main loop */
+        amount_allocated += mountlist->el[pos].size / 1024;
+        prev_part_no = curr_part_no;
+        paranoid_free(device);
+    }
+
+    /* Over-allocated the disk? Unallocated space on disk? */
+    if (amount_allocated > physical_drive_size + 1) {
+        asprintf(&tmp, " %ld MB over-allocated on %s.",
+                amount_allocated - physical_drive_size, drive);
+        log_it(tmp);
+        strcat(flaws_str, tmp);
+        paranoid_free(tmp);
+        res++;
+    } else if (amount_allocated < physical_drive_size - 1) {    /* NOT AN ERROR, JUST A WARNING :-) */
+        asprintf(&tmp, " %ld MB unallocated on %s.",
+                physical_drive_size - amount_allocated, drive);
+        log_it(tmp);
+        strcat(flaws_str, tmp);
+        paranoid_free(tmp);
+    }
+
+    if (res) {
+        return (FALSE);
+    } else {
+        return (TRUE);
+    }
 }
 #endif
-
 
 
@@ -608 +545 @@
  */
 int
-evaluate_mountlist (struct mountlist_itself *mountlist, char *flaws_str_A,
-            char *flaws_str_B, char *flaws_str_C)
-{
-
-    /*@ buffer ************************************************************/
-    struct list_of_disks *drivelist;
+evaluate_mountlist(struct mountlist_itself *mountlist, char *flaws_str_A,
+                   char *flaws_str_B, char *flaws_str_C)
+{
+
+    /*@ buffer *********************************************************** */
+    struct list_of_disks *drivelist;
     char *tmp;
+    char *tmp1;
     char *flaws_str;
 
-    /*@ int ***************************************************************/
+    /*@ int ************************************************************** */
     int i = 0;
     int res = 0;
 
-    /*@ initialize ********************************************************/
-
-  drivelist = malloc(sizeof(struct list_of_disks));
-  malloc_string(tmp);
-  malloc_string(flaws_str);
-  assert(mountlist!=NULL);
-  assert(flaws_str_A!=NULL);
-  assert(flaws_str_B!=NULL);
-  assert(flaws_str_C!=NULL);
-  flaws_str[0] = '\0';
-
-  make_list_of_drives_in_mountlist (mountlist, drivelist);
-
-  log_it ("Evaluating mountlist...");
-
- for (i = 0; i < drivelist->entries; i++)
-    {
-      if (strstr (drivelist->el[i].device, DONT_KNOW_HOW_TO_EVALUATE_THIS_DEVICE_TYPE))
-    {
-      sprintf (tmp, " Not evaluating %s (I don't know how yet)",
-           drivelist->el[i].device);
-      log_it (tmp);
-      tmp[0] = '\0';
-    }
-      else
-    {
-      if (!evaluate_drive_within_mountlist
-          (mountlist, drivelist->el[i].device, tmp))
-        {
-          res++;
-        }
-    }
-      strcat (flaws_str, tmp);
-    }
-  res += look_for_duplicate_mountpoints (mountlist, flaws_str);
+    /*@ initialize ******************************************************* */
+
+    drivelist = malloc(sizeof(struct list_of_disks));
+    assert(mountlist != NULL);
+    assert(flaws_str_A != NULL);
+    assert(flaws_str_B != NULL);
+    assert(flaws_str_C != NULL);
+
+    asprintf(&flaws_str, "");
+
+    make_list_of_drives_in_mountlist(mountlist, drivelist);
+
+    log_it("Evaluating mountlist...");
+
+    for (i = 0; i < drivelist->entries; i++) {
+        if (strstr
+            (drivelist->el[i].device,
+             DONT_KNOW_HOW_TO_EVALUATE_THIS_DEVICE_TYPE)) {
+            asprintf(&tmp, " Not evaluating %s (I don't know how yet)",
+                    drivelist->el[i].device);
+            log_it(tmp);
+        } else {
+            asprintf(&tmp, "");
+            // BERLIOS : tmp was NOT initialized ???
+            if (!evaluate_drive_within_mountlist
+                (mountlist, drivelist->el[i].device, tmp)) {
+                res++;
+            }
+        }
+        asprintf(&tmp1, "%s%s", flaws_str, tmp);
+        paranoid_free(tmp);
+        paranoid_free(flaws_str);
+        flaws_str = tmp1;
+    }
+    res += look_for_duplicate_mountpoints(mountlist, flaws_str);
 /*  res+=look_for_weird_formats(mountlist,flaws_str); .. not necessary, now that we can check to see
  which formarts are actually _supported_ by the kernel */
-  /* log_it(flaws_str); */
-  return (spread_flaws_across_three_lines
-      (flaws_str, flaws_str_A, flaws_str_B, flaws_str_C, res));
+    /* log_it(flaws_str); */
+    return (spread_flaws_across_three_lines
+            (flaws_str, flaws_str_A, flaws_str_B, flaws_str_C, res));
 }
 
@@ -672 +610 @@
  */
 int
-find_device_in_mountlist (struct mountlist_itself *mountlist, char *device)
-{
-
-    /*@ int ***************************************************************/
-  int i = 0;
-  char*tmp;
-  char*flaws_str;
-  
-  malloc_string(tmp);
-  malloc_string(flaws_str);
- 
-  assert(mountlist!=NULL);
-  assert_string_is_neither_NULL_nor_zerolength(device);
-  for (i = 0;
-       i < mountlist->entries
-       && strcmp (mountlist->el[i].device, device) != 0; i++);
-  
-  paranoid_free(tmp);
-  paranoid_free(flaws_str);
-
-  if (i == mountlist->entries)
-    {
-      return (-1);
-    }
-  else
-    {
-      return (i);
-    }
-}
-
-
-
+find_device_in_mountlist(struct mountlist_itself *mountlist, char *device)
+{
+
+    /*@ int ************************************************************** */
+    int i = 0;
+
+    assert(mountlist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(device);
+    for (i = 0;
+         i < mountlist->entries
+         && strcmp(mountlist->el[i].device, device) != 0; i++);
+
+    if (i == mountlist->entries) {
+        return (-1);
+    } else {
+        return (i);
+    }
+}
 
 
@@ -713 +637 @@
  */
 int
-look_for_duplicate_mountpoints (struct mountlist_itself *mountlist,
-                char *flaws_str)
-{
-
-    /*@ int **************************************************************/
-  int res = 0;
+look_for_duplicate_mountpoints(struct mountlist_itself *mountlist,
+                               char *flaws_str)
+{
+
+    /*@ int ************************************************************* */
+    int res = 0;
     int currline = 0;
     int i = 0;
@@ -724 +648 @@
     int last_copy = 0;
 
-    /*@ buffetr **********************************************************/
-  char *curr_mountpoint;
+    /*@ buffetr ********************************************************* */
+    char *curr_mountpoint;
     char *tmp;
 
-  malloc_string(curr_mountpoint);
-  malloc_string(tmp);
-  assert(mountlist!=NULL);
-  assert(flaws_str!=NULL);
-  for (currline = 0; currline < mountlist->entries; currline++)
-    {
-      strcpy (curr_mountpoint, mountlist->el[currline].mountpoint);
-      for (i = 0, copies = 0, last_copy = -1; i < mountlist->entries; i++)
-    {
-      if (!strcmp (mountlist->el[i].mountpoint, curr_mountpoint)
-          && strcmp (mountlist->el[i].mountpoint, "lvm")
-          && strcmp (mountlist->el[i].mountpoint, "swap"))
-        {
-          last_copy = i;
-          copies++;
-        }
-    }
-      if (copies > 1 && last_copy == currline
-      && strcmp (curr_mountpoint, "raid"))
-    {
-      sprintf (tmp, " %s %s's.", number_to_text (copies),
-           curr_mountpoint);
-      strcat (flaws_str, tmp);
-      log_it (tmp);
-      res++;
-    }
-    }
-  paranoid_free(curr_mountpoint);
-  paranoid_free(tmp);
-  return (res);
-}
+    assert(mountlist != NULL);
+    assert(flaws_str != NULL);
+    for (currline = 0; currline < mountlist->entries; currline++) {
+        asprintf(&curr_mountpoint, mountlist->el[currline].mountpoint);
+        for (i = 0, copies = 0, last_copy = -1; i < mountlist->entries;
+             i++) {
+            if (!strcmp(mountlist->el[i].mountpoint, curr_mountpoint)
+                && strcmp(mountlist->el[i].mountpoint, "lvm")
+                && strcmp(mountlist->el[i].mountpoint, "swap")) {
+                last_copy = i;
+                copies++;
+            }
+        }
+        if (copies > 1 && last_copy == currline
+            && strcmp(curr_mountpoint, "raid")) {
+            asprintf(&tmp, " %s %s's.", number_to_text(copies),
+                    curr_mountpoint);
+            strcat(flaws_str, tmp);
+            log_it(tmp);
+            paranoid_free(tmp);
+            res++;
+        }
+        paranoid_free(curr_mountpoint);
+    }
+    return (res);
+}
+
 
 /**
@@ -768 +688 @@
  */
 int
-look_for_weird_formats (struct mountlist_itself *mountlist, char *flaws_str)
-{
-
-    /*@ int **************************************************************/
-  int i = 0;
+look_for_weird_formats(struct mountlist_itself *mountlist, char *flaws_str)
+{
+
+    /*@ int ************************************************************* */
+    int i = 0;
     int res = 0;
 
-    /*@ buffers **********************************************************/
-  char *tmp;
+    /*@ buffers ********************************************************* */
+    char *tmp;
     char *format_sz;
 
-  malloc_string(tmp);
-  malloc_string(format_sz);
-  
-  assert(mountlist!=NULL);
-  assert(flaws_str!=NULL);
-
-  for (i = 0; i < mountlist->entries; i++)
-    {
-      sprintf (format_sz, " %s ", mountlist->el[i].format);
-      if (!strstr
-      (SANE_FORMATS, format_sz) 
-        && strcmp (mountlist->el[i].mountpoint, "image") != 0)
-    {
-      sprintf (tmp, " %s has unknown format.", mountlist->el[i].device);
-      log_it (tmp);
-      strcat (flaws_str, tmp);
-      res++;
-    }
-      else
-    if ((!strcmp (mountlist->el[i].format, "swap")
-         && strcmp (mountlist->el[i].mountpoint, "swap") && strcmp (mountlist->el[i].mountpoint, "none"))
-        || (strcmp (mountlist->el[i].format, "swap")
-        && !strcmp (mountlist->el[i].mountpoint, "swap") && !strcmp (mountlist->el[i].mountpoint, "none")))
-    {
-      sprintf (tmp, " %s is half-swap.", mountlist->el[i].device);
-      log_it (tmp);
-      strcat (flaws_str, tmp);
-      res++;
-    }
-    }
-  paranoid_free(tmp);
-  paranoid_free(format_sz);
-  return (res);
-}
-
+    assert(mountlist != NULL);
+    assert(flaws_str != NULL);
+
+    for (i = 0; i < mountlist->entries; i++) {
+        asprintf(&format_sz, " %s ", mountlist->el[i].format);
+        if (!strstr(SANE_FORMATS, format_sz)
+            && strcmp(mountlist->el[i].mountpoint, "image") != 0) {
+            asprintf(&tmp, " %s has unknown format.",
+                    mountlist->el[i].device);
+            log_it(tmp);
+            strcat(flaws_str, tmp);
+            paranoid_free(tmp);
+            res++;
+        } else if ((!strcmp(mountlist->el[i].format, "swap")
+                    && strcmp(mountlist->el[i].mountpoint, "swap")
+                    && strcmp(mountlist->el[i].mountpoint, "none"))
+                   || (strcmp(mountlist->el[i].format, "swap")
+                       && !strcmp(mountlist->el[i].mountpoint, "swap")
+                       && !strcmp(mountlist->el[i].mountpoint, "none"))) {
+            asprintf(&tmp, " %s is half-swap.", mountlist->el[i].device);
+            log_it(tmp);
+            strcat(flaws_str, tmp);
+            paranoid_free(tmp);
+            res++;
+        }
+        paranoid_free(format_sz);
+    }
+    return (res);
+}
 
 
@@ -823 +737 @@
  */
 int
-make_list_of_drives_in_mountlist (struct mountlist_itself *mountlist,
-             struct list_of_disks *drivelist)
-{
-
-        /*@ int **************************************************************/
-  int lino;
-  int noof_drives;
-  int j;
-
-        /*@ buffers **********************************************************/
-  char *drive;
-  char *tmp;
-
-  long long size;
-
-  malloc_string(drive);
-  malloc_string(tmp);
-  assert(mountlist!=NULL);
-  assert(drivelist!=NULL);
-  log_it ("Making list of drives");
-  for (lino = 0, noof_drives = 0; lino < mountlist->entries; lino++)
-    {
-      
-      strcpy (drive, mountlist->el[lino].device);
-      if (!strncmp (drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB)))
-    {
-      sprintf (tmp,
-           "Not putting %s in list of drives: it's a virtual drive",
-           drive);
-      log_msg (8, tmp);
-      continue;
-    }
-
-      size=mountlist->el[lino].size;
-      if ( size == 0 )
-        {
-          sprintf (tmp,
-                   "Not putting %s in list of drives: it has zero size (maybe an LVM volume)",
-                   drive);
-          log_msg (8, tmp);
-          continue;
-        }
+make_list_of_drives_in_mountlist(struct mountlist_itself *mountlist,
+                                 struct list_of_disks *drivelist)
+{
+
+    /*@ int ************************************************************* */
+    int lino;
+    int noof_drives;
+    int j;
+
+    /*@ buffers ********************************************************* */
+    char *drive;
+    char *tmp;
+
+    long long size;
+
+    assert(mountlist != NULL);
+    assert(drivelist != NULL);
+    log_it("Making list of drives");
+    for (lino = 0, noof_drives = 0; lino < mountlist->entries; lino++) {
+
+        asprintf(&drive, mountlist->el[lino].device);
+        if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
+            asprintf(&tmp,
+                    "Not putting %s in list of drives: it's a virtual drive",
+                    drive);
+            log_msg(8, tmp);
+            paranoid_free(tmp);
+            continue;
+        }
+
+        size = mountlist->el[lino].size;
+        if (size == 0) {
+            asprintf(&tmp,
+                    "Not putting %s in list of drives: it has zero size (maybe an LVM volume)",
+                    drive);
+            log_msg(8, tmp);
+            paranoid_free(tmp);
+            continue;
+        }
 
 /*
@@ -877 +788 @@
 */
 
-      sprintf (tmp,
-           "Putting %s with size %lli in list of drives",
-           drive, size);
-      log_msg (8, tmp);
-
-      (void) truncate_to_drive_name (drive);
-      for (j = 0; j < noof_drives && strcmp (drivelist->el[j].device, drive) != 0; j++)
-    continue;
-      if (j == noof_drives)
-    {
-      strcpy (drivelist->el[noof_drives++].device, drive);
-    }
-    }
-  drivelist->entries = noof_drives;
-  log_msg (8, "Made list of drives");
-  paranoid_free(drive);
-  paranoid_free(tmp);
-
-  return (noof_drives);
-}
-
-
-
-
+        asprintf(&tmp,
+                "Putting %s with size %lli in list of drives",
+                drive, size);
+        log_msg(8, tmp);
+        paranoid_free(tmp);
+
+        (void) truncate_to_drive_name(drive);
+        for (j = 0;
+             j < noof_drives
+             && strcmp(drivelist->el[j].device, drive) != 0; j++)
+            continue;
+        if (j == noof_drives) {
+            strcpy(drivelist->el[noof_drives++].device, drive);
+        }
+        paranoid_free(drive);
+
+    }
+    drivelist->entries = noof_drives;
+    log_msg(8, "Made list of drives");
+
+    return (noof_drives);
+}
 
 
@@ -910 +819 @@
  * @param raidlist The raidlist to examine.
  */
-void
-make_list_of_unallocated_raid_partitions (struct mountlist_itself
-                      *output_list,
-                      struct mountlist_itself *mountlist,
-                      struct raidlist_itself *raidlist)
-{
-
-    /*@ int **************************************************************/
-  int items = 0;
+void make_list_of_unallocated_raid_partitions(struct mountlist_itself
+                                              *output_list,
+                                              struct mountlist_itself
+                                              *mountlist,
+                                              struct raidlist_itself
+                                              *raidlist)
+{
+
+    /*@ int ************************************************************* */
+    int items = 0;
     int i = 0;
     int used_by = 0;
 
-    /*@ buffers **********************************************************/
-  char *tmp;
-
-  malloc_string(tmp);
-  assert(output_list!=NULL);
-  assert(mountlist!=NULL);
-  assert(raidlist!=NULL);
-  log_it ("MLOURP -- starting");
-  items = 0;
-
-
-  for (i = 0; i < mountlist->entries; i++)
-    {
-      if (strstr (mountlist->el[i].mountpoint, "raid"))
-    {
-      used_by =
-        which_raid_device_is_using_this_partition (raidlist,
-                               mountlist->el[i].
-                               device);
-      if (used_by < 0)
-        {
-          memcpy ((void *) &output_list->el[items++],
-              (void *) &mountlist->el[i],
-              sizeof (struct mountlist_line));
-          sprintf (tmp,
-               "%s is available; user may choose to add it to raid device",
-               output_list->el[items - 1].device);
-          log_it (tmp);
-        }
-    }
-    }
-  output_list->entries = items;
-  log_it ("MLUORP -- ending");
-  paranoid_free(tmp);
-}
-
-
-
+    /*@ buffers ********************************************************* */
+    char *tmp;
+
+    assert(output_list != NULL);
+    assert(mountlist != NULL);
+    assert(raidlist != NULL);
+    log_it("MLOURP -- starting");
+    items = 0;
+
+
+    for (i = 0; i < mountlist->entries; i++) {
+        if (strstr(mountlist->el[i].mountpoint, "raid")) {
+            used_by =
+                which_raid_device_is_using_this_partition(raidlist,
+                                                          mountlist->el[i].
+                                                          device);
+            if (used_by < 0) {
+                memcpy((void *) &output_list->el[items++],
+                       (void *) &mountlist->el[i],
+                       sizeof(struct mountlist_line));
+                asprintf(&tmp,
+                        "%s is available; user may choose to add it to raid device",
+                        output_list->el[items - 1].device);
+                log_it(tmp);
+                paranoid_free(tmp);
+            }
+        }
+    }
+    output_list->entries = items;
+    log_it("MLUORP -- ending");
+}
 
 
@@ -969 +872 @@
  */
 long long
-size_of_specific_device_in_mountlist (struct mountlist_itself *mountlist, char *device)
-{
-    /*@ int ***************************************************************/
-  int i = 0;
-
-
-  assert(mountlist!=NULL);
-  assert_string_is_neither_NULL_nor_zerolength(device);
-
-  for (i = 0;
-       i < mountlist->entries && strcmp (mountlist->el[i].device, device);
-       i++);
-  if (i == mountlist->entries)
-    {
-      return (-1);
-    }
-  else
-    {
-      return (mountlist->el[i].size);
-    }
-}
-
-
+size_of_specific_device_in_mountlist(struct mountlist_itself *mountlist,
+                                     char *device)
+{
+    /*@ int ************************************************************** */
+    int i = 0;
+
+
+    assert(mountlist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(device);
+
+    for (i = 0;
+         i < mountlist->entries && strcmp(mountlist->el[i].device, device);
+         i++);
+    if (i == mountlist->entries) {
+        return (-1);
+    } else {
+        return (mountlist->el[i].size);
+    }
+}
 
 
@@ -1004 +903 @@
  * @return 0 for success, 1 for failure.
  */
-int
-load_mountlist( struct mountlist_itself *mountlist, char *fname)
-{
-  FILE *fin;
-  /* malloc ***/
-  char *incoming;
-  char *siz;
-  char *tmp;
-  char*p;
-
-  int items;
-  int j;
-
-  assert(mountlist!=NULL);
-  assert_string_is_neither_NULL_nor_zerolength(fname);
-  malloc_string(incoming);
-  malloc_string(siz);
-  malloc_string(tmp);
-  if ( !( fin = fopen( fname, "r" ) ) )
-    {
-      log_it( "Unable to open mountlist - '%s'", fname );
-      log_to_screen( "Cannot open mountlist" );
-      paranoid_free(incoming);
-      paranoid_free(siz);
-      paranoid_free(tmp);
-      return( 1 );
-    }
-  items = 0;
-  (void) fgets( incoming, MAX_STR_LEN - 1, fin );
-  log_it( "Loading mountlist..." );
-  while( !feof( fin ) )
-    {
+int load_mountlist(struct mountlist_itself *mountlist, char *fname)
+{
+    FILE *fin;
+    /* malloc ** */
+    char *incoming = NULL;
+    char *siz;
+    char *tmp;
+    char *p;
+
+    int items;
+    int j;
+    int n = 0;
+
+    assert(mountlist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(fname);
+    malloc_string(siz);
+    if (!(fin = fopen(fname, "r"))) {
+        log_it("Unable to open mountlist - '%s'", fname);
+        log_to_screen("Cannot open mountlist");
+        paranoid_free(siz);
+        return (1);
+    }
+    items = 0;
+    (void) getline(&incoming, &n, fin);
+    log_it("Loading mountlist...");
+    while (!feof(fin)) {
 #if linux
-      sscanf( incoming,
-          "%s %s %s %s %s",
-          mountlist->el[items].device,
-          mountlist->el[items].mountpoint,
-          mountlist->el[items].format,
-          siz,
-          mountlist->el[items].label);
+        sscanf(incoming,
+               "%s %s %s %s %s",
+               mountlist->el[items].device,
+               mountlist->el[items].mountpoint,
+               mountlist->el[items].format,
+               siz, mountlist->el[items].label);
 #elif __FreeBSD__
-      sscanf (incoming,
-          "%s %s %s %s",
-          mountlist->el[items].device,
-          mountlist->el[items].mountpoint,
-          mountlist->el[items].format,
-          siz);
-      strcpy (mountlist->el[items].label, "");
+        sscanf(incoming,
+               "%s %s %s %s",
+               mountlist->el[items].device,
+               mountlist->el[items].mountpoint,
+               mountlist->el[items].format, siz);
+        strcpy(mountlist->el[items].label, "");
 #endif
 
-      if (
-        !strcmp(mountlist->el[items].device,"/proc") ||
-        !strcmp(mountlist->el[items].device, "proc") ||
-        !strcmp(mountlist->el[items].device,"/sys") ||
-        !strcmp(mountlist->el[items].device, "sys") ||
-        !strcmp(mountlist->el[items].device,"/devpts") ||
-    !strcmp(mountlist->el[items].device, "devpts")
-      )
-        {
-      log_msg(1, "Ignoring %s in mountlist - not loading that line :) ", mountlist->el[items].device);
-          (void) fgets( incoming, MAX_STR_LEN - 1,fin );
-      continue;
-    }
-      mountlist->el[items].size = atoll( siz );
-      if ( mountlist->el[items].device[0] != '\0' && mountlist->el[items].device[0] != '#' )
-    {
-      if ( items >= ARBITRARY_MAXIMUM )
-        {
-          log_to_screen( "Too many lines in mountlist.. ABORTING" );
-          finish( 1 );
-        }
-      for( j=0; j < items && strcmp( mountlist->el[j].device, mountlist->el[items].device ); j++);
-      if (j < items)
-        {
-          strcat( mountlist->el[items].device, "_dup" );
-          sprintf( tmp, "Duplicate entry in mountlist - renaming to %s",mountlist->el[items].device );
-          log_it( tmp );
-        }
-    strcpy(tmp, mountlist->el[items].device);
-    if (strstr(tmp, "/dev/md/"))
-      {
-        log_it("format_device() --- Contracting %s", tmp);
-        p = strrchr(tmp, '/');
-        if (p) { *p = *(p+1); *(p+1) = *(p+2); *(p+2) = *(p+3); }
-        log_it("It was %s; it is now %s", mountlist->el[items].device, tmp);
-        strcpy(mountlist->el[items].device, tmp);
-      }
-
-      sprintf( tmp,
-           "%s %s %s %lld %s",
-           mountlist->el[items].device,
-           mountlist->el[items].mountpoint,
-           mountlist->el[items].format,
-           mountlist->el[items].size,
-           mountlist->el[items].label);
-
-      log_it( tmp );
-      items++;
-    }
-      (void) fgets( incoming, MAX_STR_LEN - 1,fin );
-    }
-  paranoid_fclose( fin );
-  mountlist->entries = items;
-
-  log_it( "Mountlist loaded successfully." );
-  sprintf( tmp, "%d entries in mountlist", items );
-  log_it( tmp );
-  paranoid_free(incoming);
-  paranoid_free(siz);
-  paranoid_free(tmp);
-  return( 0 );
+        if (!strcmp(mountlist->el[items].device, "/proc") ||
+            !strcmp(mountlist->el[items].device, "proc") ||
+            !strcmp(mountlist->el[items].device, "/sys") ||
+            !strcmp(mountlist->el[items].device, "sys") ||
+            !strcmp(mountlist->el[items].device, "/devpts") ||
+            !strcmp(mountlist->el[items].device, "devpts")
+            ) {
+            log_msg(1,
+                    "Ignoring %s in mountlist - not loading that line :) ",
+                    mountlist->el[items].device);
+            (void) getline(&incoming, &n, fin);
+            continue;
+        }
+        mountlist->el[items].size = atoll(siz);
+        if (mountlist->el[items].device[0] != '\0'
+            && mountlist->el[items].device[0] != '#') {
+            if (items >= ARBITRARY_MAXIMUM) {
+                log_to_screen("Too many lines in mountlist.. ABORTING");
+                finish(1);
+            }
+            for (j = 0;
+                 j < items
+                 && strcmp(mountlist->el[j].device,
+                           mountlist->el[items].device); j++);
+            if (j < items) {
+                strcat(mountlist->el[items].device, "_dup");
+                asprintf(&tmp,
+                        "Duplicate entry in mountlist - renaming to %s",
+                        mountlist->el[items].device);
+                log_it(tmp);
+                paranoid_free(tmp);
+            }
+            asprintf(&tmp, mountlist->el[items].device);
+            if (strstr(tmp, "/dev/md/")) {
+                log_it("format_device() --- Contracting %s", tmp);
+                p = strrchr(tmp, '/');
+                if (p) {
+                    *p = *(p + 1);
+                    *(p + 1) = *(p + 2);
+                    *(p + 2) = *(p + 3);
+                }
+                log_it("It was %s; it is now %s",
+                       mountlist->el[items].device, tmp);
+                strcpy(mountlist->el[items].device, tmp);
+            }
+            paranoid_free(tmp);
+
+            asprintf(&tmp,
+                    "%s %s %s %lld %s",
+                    mountlist->el[items].device,
+                    mountlist->el[items].mountpoint,
+                    mountlist->el[items].format,
+                    mountlist->el[items].size, mountlist->el[items].label);
+
+            log_it(tmp);
+            paranoid_free(tmp);
+            items++;
+        }
+        (void) getline(&incoming, &n, fin);
+    }
+    paranoid_fclose(fin);
+    paranoid_free(incoming);
+    mountlist->entries = items;
+
+    log_it("Mountlist loaded successfully.");
+    asprintf(&tmp, "%d entries in mountlist", items);
+    log_it(tmp);
+    paranoid_free(tmp);
+
+    paranoid_free(siz);
+    return (0);
 }
 
@@ -1126 +1027 @@
  * @see load_mountlist
  */
-int 
-save_mountlist_to_disk(struct mountlist_itself *mountlist, char *fname)
-{
-  FILE *fout;
-  int i;
-
-  assert(mountlist!=NULL);
-  assert_string_is_neither_NULL_nor_zerolength(fname);
-
-  log_it("save_mountlist_to_disk() --- saving to %s", fname);
-  if (!(fout=fopen(fname,"w"))) 
-    {
-      log_OS_error("WMTD - Cannot openout mountlist");
-      return(1);
-    }
-  for( i = 0; i < mountlist->entries; i++)
-    {
-      fprintf(fout,
-          "%-15s %-15s %-15s %-15lld %-15s\n",mountlist->el[i].device, 
-          mountlist->el[i].mountpoint, 
-          mountlist->el[i].format, 
-          mountlist->el[i].size,
-          mountlist->el[i].label);
-    }
-  paranoid_fclose(fout);
-  return(0);
-}
-
+int save_mountlist_to_disk(struct mountlist_itself *mountlist, char *fname)
+{
+    FILE *fout;
+    int i;
+
+    assert(mountlist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(fname);
+
+    log_it("save_mountlist_to_disk() --- saving to %s", fname);
+    if (!(fout = fopen(fname, "w"))) {
+        log_OS_error("WMTD - Cannot openout mountlist");
+        return (1);
+    }
+    for (i = 0; i < mountlist->entries; i++) {
+        fprintf(fout,
+                "%-15s %-15s %-15s %-15lld %-15s\n",
+                mountlist->el[i].device, mountlist->el[i].mountpoint,
+                mountlist->el[i].format, mountlist->el[i].size,
+                mountlist->el[i].label);
+    }
+    paranoid_fclose(fout);
+    return (0);
+}
 
 
@@ -1161 +1057 @@
  * @param mountlist The mountlist to sort.
  */
-void 
-sort_mountlist_by_device( struct mountlist_itself *mountlist)
-{
-  int diff;
-  int lino = -999;
-
-  assert(mountlist!=NULL);
-
-  while (lino < mountlist->entries)
-    {
-      for(lino = 1; lino < mountlist->entries; lino++)
-    {
-      diff = strcmp_inc_numbers(mountlist->el[lino-1].device,mountlist->el[lino].device);
-      if (diff > 0)
-        {
-          swap_mountlist_entries( mountlist, lino - 1, lino);
-          break;
-        }
-    }
-    }
-}
+void sort_mountlist_by_device(struct mountlist_itself *mountlist)
+{
+    int diff;
+    int lino = -999;
+
+    assert(mountlist != NULL);
+
+    while (lino < mountlist->entries) {
+        for (lino = 1; lino < mountlist->entries; lino++) {
+            diff =
+                strcmp_inc_numbers(mountlist->el[lino - 1].device,
+                                   mountlist->el[lino].device);
+            if (diff > 0) {
+                swap_mountlist_entries(mountlist, lino - 1, lino);
+                break;
+            }
+        }
+    }
+}
+
 
 /**
@@ -1189 +1084 @@
  * @param reverse If TRUE, then do a reverse sort.
  */
-void 
-sort_mountlist_by_mountpoint(struct mountlist_itself *mountlist, bool reverse)
-{
-  int diff;
-  int lino = -999;
-
-  assert(mountlist!=NULL);
-
-  while(lino < mountlist->entries)
-    {
-      for(lino = 1; lino < mountlist->entries; lino++)
-    {
-      diff = strcmp( mountlist->el[lino-1].mountpoint,mountlist->el[lino].mountpoint);
-      if ((diff >0 && !reverse) || ((diff <0 && reverse)))
-        {
-          swap_mountlist_entries(mountlist, lino - 1, lino);
-          break;
-        }
-    }
-    }
+void
+sort_mountlist_by_mountpoint(struct mountlist_itself *mountlist,
+                             bool reverse)
+{
+    int diff;
+    int lino = -999;
+
+    assert(mountlist != NULL);
+
+    while (lino < mountlist->entries) {
+        for (lino = 1; lino < mountlist->entries; lino++) {
+            diff =
+                strcmp(mountlist->el[lino - 1].mountpoint,
+                       mountlist->el[lino].mountpoint);
+            if ((diff > 0 && !reverse) || ((diff < 0 && reverse))) {
+                swap_mountlist_entries(mountlist, lino - 1, lino);
+                break;
+            }
+        }
+    }
 }
 
@@ -1218 +1113 @@
  * @param b The index number of the second entry.
  */
-void 
+void
 swap_mountlist_entries(struct mountlist_itself *mountlist, int a, int b)
 {
-  /*@ mallocs ****/
-  char device[64];
-  char mountpoint[256];
-  char format[64];
-
-  long long size;
-
-  assert(mountlist!=NULL);
-  assert(a>=0);
-  assert(b>=0);
-
-  strcpy(device,                     mountlist->el[a].device);
-  strcpy(mountpoint,                 mountlist->el[a].mountpoint);
-  strcpy(format,                     mountlist->el[a].format);
-
-  size=                              mountlist->el[a].size;
-
-  strcpy(mountlist->el[a].device,    mountlist->el[b].device);
-  strcpy(mountlist->el[a].mountpoint,mountlist->el[b].mountpoint);
-  strcpy(mountlist->el[a].format,    mountlist->el[b].format);
-
-  mountlist->el[a].size=             mountlist->el[b].size;
-
-  strcpy(mountlist->el[b].device,    device);
-  strcpy(mountlist->el[b].mountpoint,mountpoint);
-  strcpy(mountlist->el[b].format,    format);
-
-  mountlist->el[b].size=             size;
+    /*@ mallocs *** */
+    char *device;
+    char *mountpoint;
+    char *format;
+
+    long long size;
+
+    assert(mountlist != NULL);
+    assert(a >= 0);
+    assert(b >= 0);
+
+    asprintf(&device, mountlist->el[a].device);
+    asprintf(&mountpoint, mountlist->el[a].mountpoint);
+    asprintf(&format, mountlist->el[a].format);
+
+    size = mountlist->el[a].size;
+
+    strcpy(mountlist->el[a].device, mountlist->el[b].device);
+    strcpy(mountlist->el[a].mountpoint, mountlist->el[b].mountpoint);
+    strcpy(mountlist->el[a].format, mountlist->el[b].format);
+
+    mountlist->el[a].size = mountlist->el[b].size;
+
+    strcpy(mountlist->el[b].device, device);
+    strcpy(mountlist->el[b].mountpoint, mountpoint);
+    strcpy(mountlist->el[b].format, format);
+
+    mountlist->el[b].size = size;
 }
 

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

@@ -1 @@
-/***************************************************************************
-libmondo-verify.c  -  description
------------------
-
-begin: Fri Apr 19 16:40:35 EDT 2002
-copyright : (C) 2002 Mondo  Hugo Rabson
-email     : Hugo Rabson <hugorabson@msn.com>
-edited by : by Stan Benoit 4/2002
-email     : troff@nakedsoul.org
-cvsid     : $Id: libmondo-verify.c,v 1.9 2004/06/21 20:20:36 hugo Exp $
-***************************************************************************/
-
-/***************************************************************************
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- ***************************************************************************/
-/* mondo-verify
-
-
-07/07
-- added star verify support
-
-04/04/2004
-- added star support
-
-10/23/2003
-- changed "ISO #n" to "<media descriptor> #n"
-
-10/01
-- working on biggiefile verification (CDs)
-
-09/16
-- fixed bug in CD biggie verif'n
-
-09/15
-- state explicitly that we do not verify disk images
-
-09/13
-- working on verify_all_slices_on_CD()
-
-09/01
-- write list of changed biggiefiles (streaming only) to changed.files
-
-05/05
-- exclude /dev/ * from list of changed files
-- add Joshua Oreman's FreeBSD patches
-
-04/24/2003
-- added lots of assert()'s and log_OS_error()'s
-
-09/01 - 09/30/2002
-- run_program_and_log_output() now takes boolean operator to specify
-  whether it will log its activities in the event of _success_
-- eject_device() added
-- cleaned up 'changed file' feedback a little bit
-
-08/01 - 08/31
-- make sure to prefix bkpinfo->restore_path to local biggiefile fname when
-  comparing it to the archived copy of biggiefile; otherwise, biggiefile
-  not found & checksum missing & so on
-- exclude "incheckentry xwait()" from changed.files
-- cleaned up some log_it() calls
-
-07/01 - 07/31
-- renamed libmondo-verify.c
-- say 'bigfile' not 'biggiefile'
-- exclude /dev/ * from changed.files
-
-01/01 - 06/30
-- remove /tmp/changed.files.* dead files
-- don't pclose() tape after calling closein_tape(): the latter does it already
-- fixed bug in verify_cd_image()'s CD-mounting code
-- don't write to screen "old cksum.. curr cksum.."
-- changed the gawks to awks for the benefit of Debian
-- handles files >2GB in size
-- fixed bug in /tmp/changed.files-generator
-- re-enabled a lot of CD-verification code
-- afioballs are saved in %s/tmpfs/ now (%s=tmpdir)
-- changed some labels to make them more user-friendly
-- don't chdir() anywhere before verifying stuff
-- changed files are now detected by verify_tape_backup() and listed in
-  /tmp/changed.files
-- replaced &> with > .. 2>
-- still implementing improved tape support
-
-
-Started late Dec, 2001
-
------------------------------------------------------------------------------
+/* $Id$ */
+/*
+copyright : (C) 2002 Mondo  Hugo Rabson <hugorabson@msn.com>
+edited by : by Stan Benoit 4/2002 troff@nakedsoul.org
 */
 
@@ -113 +24 @@
 
 /*@unused@*/
-//static char cvsid[] = "$Id: libmondo-verify.c,v 1.9 2004/06/21 20:20:36 hugo Exp $";
-
-char *vfy_tball_fname (struct s_bkpinfo *, char *, int);
+//static char cvsid[] = "$Id$";
+
+char *vfy_tball_fname(struct s_bkpinfo *, char *, int);
 
 
@@ -136 +47 @@
  */
 long
-generate_list_of_changed_files (char *changedfiles_fname,
-                char *ignorefiles_fname, char *stderr_fname)
+generate_list_of_changed_files(char *changedfiles_fname,
+                               char *ignorefiles_fname, char *stderr_fname)
 {
-    /*@ buffer ***********************************************************/
-  char *command;
+    /*@ buffer ********************************************************** */
+    char *command;
     char *afio_found_changes;
 
-    /*@ int **************************************************************/
-  int res = 0;
-
-    /*@ long *************************************************************/
-  long afio_diffs = 0;
-
-  command = malloc(2000);
-  afio_found_changes = malloc(500);
-  assert_string_is_neither_NULL_nor_zerolength(changedfiles_fname);
-  assert_string_is_neither_NULL_nor_zerolength(ignorefiles_fname);
-  assert_string_is_neither_NULL_nor_zerolength(stderr_fname);
-
-  sprintf (afio_found_changes, "%s.afio", ignorefiles_fname);
-  paranoid_system ("sync");
-  
+    /*@ int ************************************************************* */
+    int res = 0;
+
+    /*@ long ************************************************************ */
+    long afio_diffs = 0;
+
+    assert_string_is_neither_NULL_nor_zerolength(changedfiles_fname);
+    assert_string_is_neither_NULL_nor_zerolength(ignorefiles_fname);
+    assert_string_is_neither_NULL_nor_zerolength(stderr_fname);
+
+    asprintf(&afio_found_changes, "%s.afio", ignorefiles_fname);
+    paranoid_system("sync");
+
 /*  sprintf (command,
        "cat %s | grep \"afio: \" | awk '{j=substr($0,8); i=index(j,\": \");printf \"/%%s\\n\",substr(j,1,i-2);}' | sort | uniq | grep -v \"incheckentry.*xwait\" | grep -vx \"/afio:.*\" | grep -vx \"/dev/.*\" > %s",
        stderr_fname, afio_found_changes);
 */
-  
-  log_msg(1, "Now scanning log file for 'afio: ' stuff");
-  sprintf (command,
-       "cat %s | grep \"afio: \" | sed 's/afio: //' | grep -vx \"/dev/.*\" >> %s",
-       stderr_fname, afio_found_changes);
-  log_msg (2, command);
-  res = system (command);
-  if (res)
-    {
-      log_msg (2, "Warning - failed to think");
-    }
-
-  log_msg(1, "Now scanning log file for 'star: ' stuff");
-  sprintf (command,
-       "cat %s | grep \"star: \" | sed 's/star: //' | grep -vx \"/dev/.*\" >> %s",
-       stderr_fname, afio_found_changes);
-  log_msg (2, command);
-  res = system (command);
-  if (res)
-    {
-      log_msg (2, "Warning - failed to think");
-    }
+
+    log_msg(1, "Now scanning log file for 'afio: ' stuff");
+    asprintf(&command,
+            "cat %s | grep \"afio: \" | sed 's/afio: //' | grep -vx \"/dev/.*\" >> %s",
+            stderr_fname, afio_found_changes);
+    log_msg(2, command);
+    res = system(command);
+    paranoid_free(command);
+    if (res) {
+        log_msg(2, "Warning - failed to think");
+    }
+
+    log_msg(1, "Now scanning log file for 'star: ' stuff");
+    asprintf(&command,
+            "cat %s | grep \"star: \" | sed 's/star: //' | grep -vx \"/dev/.*\" >> %s",
+            stderr_fname, afio_found_changes);
+    log_msg(2, command);
+    res = system(command);
+    paranoid_free(command);
+    if (res) {
+        log_msg(2, "Warning - failed to think");
+    }
 //  exclude_nonexistent_files (afio_found_changes);
-  afio_diffs = count_lines_in_file (afio_found_changes);
-  sprintf (command,
-       "cat %s %s %s | sort | uniq -c | awk '{ if ($1==\"2\") {print $2;};}' | grep -v \"incheckentry xwait()\" > %s",
-       ignorefiles_fname, afio_found_changes, afio_found_changes,
-       changedfiles_fname);
-  log_msg (2, command);
-  paranoid_system (command);
-  paranoid_free(command);
-  paranoid_free(afio_found_changes);
-  return (afio_diffs);
+    afio_diffs = count_lines_in_file(afio_found_changes);
+    asprintf(&command,
+            "cat %s %s %s | sort | uniq -c | awk '{ if ($1==\"2\") {print $2;};}' | grep -v \"incheckentry xwait()\" > %s",
+            ignorefiles_fname, afio_found_changes, afio_found_changes,
+            changedfiles_fname);
+    log_msg(2, command);
+    paranoid_system(command);
+    paranoid_free(command);
+    paranoid_free(afio_found_changes);
+    return (afio_diffs);
 }
 
@@ -209 +118 @@
  * @return The number of sets containing differences (0 for success).
  */
-int
-verify_afioballs_on_CD (struct s_bkpinfo *bkpinfo, char *mountpoint)
+int verify_afioballs_on_CD(struct s_bkpinfo *bkpinfo, char *mountpoint)
 {
 
-    /*@ buffers **********************************************************/
-  char *tmp;
-
-    /*@ int **************************************************************/
-  int set_number = 0;
+    /*@ buffers ********************************************************* */
+    char *tmp;
+
+    /*@ int ************************************************************* */
+    int set_number = 0;
     int retval = 0;
     int total_sets = 0;
     int percentage = 0;
 
-  assert_string_is_neither_NULL_nor_zerolength(mountpoint);
-  assert(bkpinfo!=NULL);
-  malloc_string(tmp);
-  
-  for (set_number = 0;
-       set_number < 9999
-       &&
-       !does_file_exist (vfy_tball_fname (bkpinfo, mountpoint, set_number));
-       set_number++);
-  if (!does_file_exist (vfy_tball_fname (bkpinfo, mountpoint, set_number)))
-    {
-      return (0);
-    }
-    
-  if (g_last_afioball_number != set_number - 1)
-    {
-      if (set_number==0)
-        {
-      log_msg(1, "Weird error in verify_afioballs_on_CD() but it's really a cosmetic error, nothing more");
-    }
-      else
-        {
-          retval++;
-          sprintf (tmp, "Warning - missing set(s) between %d and %d\n",
-               g_last_afioball_number, set_number - 1);
-          log_to_screen (tmp);
-        }
-    }
-  sprintf (tmp, "Verifying %s #%d's tarballs", media_descriptor_string(bkpinfo->backup_media_type), g_current_media_number);
-  open_evalcall_form (tmp);
-  
-  for (total_sets = set_number;
-       does_file_exist (vfy_tball_fname (bkpinfo, mountpoint, total_sets));
-       total_sets++) { log_msg(1, "total_sets = %d", total_sets); }
-  for (; does_file_exist (vfy_tball_fname (bkpinfo, mountpoint, set_number));
-       set_number++)
-    {
-      percentage =
-    (set_number - g_last_afioball_number) * 100 / (total_sets -
-                               g_last_afioball_number);
-      update_evalcall_form (percentage);
-      log_msg(1, "set = %d", set_number);
-      retval +=
-    verify_an_afioball_from_CD (bkpinfo,
-                    vfy_tball_fname (bkpinfo, mountpoint,
-                             set_number));
-    }
-  g_last_afioball_number = set_number - 1;
-  close_evalcall_form ();
-  paranoid_free(tmp);
-  return (retval);
+    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
+    assert(bkpinfo != NULL);
+
+    for (set_number = 0;
+         set_number < 9999
+         &&
+         !does_file_exist(vfy_tball_fname
+                          (bkpinfo, mountpoint, set_number));
+         set_number++);
+    if (!does_file_exist(vfy_tball_fname(bkpinfo, mountpoint, set_number))) {
+        return (0);
+    }
+
+    if (g_last_afioball_number != set_number - 1) {
+        if (set_number == 0) {
+            log_msg(1,
+                    "Weird error in verify_afioballs_on_CD() but it's really a cosmetic error, nothing more");
+        } else {
+            retval++;
+            asprintf(&tmp, "Warning - missing set(s) between %d and %d\n",
+                    g_last_afioball_number, set_number - 1);
+            log_to_screen(tmp);
+            paranoid_free(tmp);
+        }
+    }
+    asprintf(&tmp, "Verifying %s #%d's tarballs",
+            media_descriptor_string(bkpinfo->backup_media_type),
+            g_current_media_number);
+    open_evalcall_form(tmp);
+    paranoid_free(tmp);
+
+    for (total_sets = set_number;
+         does_file_exist(vfy_tball_fname(bkpinfo, mountpoint, total_sets));
+         total_sets++) {
+        log_msg(1, "total_sets = %d", total_sets);
+    }
+    for (;
+         does_file_exist(vfy_tball_fname(bkpinfo, mountpoint, set_number));
+         set_number++) {
+        percentage =
+            (set_number - g_last_afioball_number) * 100 / (total_sets -
+                                                           g_last_afioball_number);
+        update_evalcall_form(percentage);
+        log_msg(1, "set = %d", set_number);
+        retval +=
+            verify_an_afioball_from_CD(bkpinfo,
+                                       vfy_tball_fname(bkpinfo, mountpoint,
+                                       set_number));
+    }
+    g_last_afioball_number = set_number - 1;
+    close_evalcall_form();
+    return (retval);
 }
+
 
 /**
@@ -286 +196 @@
  * @return The number of differences (0 for perfect biggiefiles).
  */
-int
-verify_all_slices_on_CD (struct s_bkpinfo *bkpinfo, char *mtpt)
+int verify_all_slices_on_CD(struct s_bkpinfo *bkpinfo, char *mtpt)
 {
 
-    /*@ buffer ***********************************************************/
-  char *tmp;
-  char *mountpoint;
+    /*@ buffer ********************************************************** */
+    char *tmp;
+    char *mountpoint;
 //  char ca, cb;
-  char *command;
-  char *sz_exe;
-  static char *bufblkA=NULL;
-  static char *bufblkB=NULL;
-  const long maxbufsize=65536L;
-  long currsizA=0;
-  long currsizB=0;
-  long j;
-
-    /*@ long *************************************************************/
-  long bigfile_num = 0;
-  long slice_num = -1;
-  int res;
-
-  static FILE*forig=NULL;
-  static struct s_filename_and_lstat_info biggiestruct;
-  static long last_bigfile_num = -1;
-  static long last_slice_num = -1;
-  FILE*pin;
-  FILE*fin;
-  int retval=0;
+    char *command;
+    char *sz_exe;
+    static char *bufblkA = NULL;
+    static char *bufblkB = NULL;
+    const long maxbufsize = 65536L;
+    long currsizA = 0;
+    long currsizB = 0;
+    long j;
+
+    /*@ long ************************************************************ */
+    long bigfile_num = 0;
+    long slice_num = -1;
+    int res;
+
+    static FILE *forig = NULL;
+    static struct s_filename_and_lstat_info biggiestruct;
+    static long last_bigfile_num = -1;
+    static long last_slice_num = -1;
+    FILE *pin;
+    FILE *fin;
+    int retval = 0;
 //  long long outlen;
 
-  malloc_string(tmp);
-  malloc_string(mountpoint);
-  malloc_string(command);
-  malloc_string(sz_exe);
-  if (!bufblkA) { if (!(bufblkA = malloc(maxbufsize))) { fatal_error("Cannot malloc bufblkA"); } }
-  if (!bufblkB) { if (!(bufblkB = malloc(maxbufsize))) { fatal_error("Cannot malloc bufblkB"); } }
-
-  assert(bkpinfo!=NULL);
-  assert_string_is_neither_NULL_nor_zerolength(mtpt);
-
-  if (bkpinfo->compression_level>0)
-    {
-      if (bkpinfo->use_lzo)
-        { strcpy(sz_exe, "lzop"); }
-      else
-        { strcpy(sz_exe, "bzip2"); }
-    }
-  else
-    { sz_exe[0] = '\0'; }
-
-  iamhere("before vsbf");
-  sprintf (tmp, "Verifying %s#%d's big files", media_descriptor_string(bkpinfo->backup_media_type), g_current_media_number);
-  open_evalcall_form (tmp);
-  iamhere("after vsbf");
-  sprintf (mountpoint, "%s/archives", mtpt);
-  if (last_bigfile_num == -1)
-    {
-      bigfile_num = 0;
-      slice_num = 0;
-    }
-  else if (slice_num == 0)
-    {
-      bigfile_num = last_bigfile_num + 1;
-      slice_num = 0;
-    }
-  else
-    {
-      bigfile_num = last_bigfile_num;
-      slice_num = last_slice_num + 1;
-    }
-  while (does_file_exist
-    (slice_fname(bigfile_num, slice_num, mountpoint, bkpinfo->zip_suffix))
-    ||
-    does_file_exist
-    (slice_fname(bigfile_num, slice_num, mountpoint, "")))
-    {
+    malloc_string(sz_exe);
+    if (!bufblkA) {
+        if (!(bufblkA = malloc(maxbufsize))) {
+            fatal_error("Cannot malloc bufblkA");
+        }
+    }
+    if (!bufblkB) {
+        if (!(bufblkB = malloc(maxbufsize))) {
+            fatal_error("Cannot malloc bufblkB");
+        }
+    }
+
+    assert(bkpinfo != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(mtpt);
+
+    if (bkpinfo->compression_level > 0) {
+        if (bkpinfo->use_lzo) {
+            asprintf(&sz_exe, "lzop");
+        } else {
+            asprintf(&sz_exe, "bzip2");
+        }
+    } else {
+        asprintf(&sz_exe, "");
+    }
+
+    iamhere("before vsbf");
+    asprintf(&tmp, "Verifying %s#%d's big files",
+            media_descriptor_string(bkpinfo->backup_media_type),
+            g_current_media_number);
+    open_evalcall_form(tmp);
+    paranoid_free(tmp);
+    iamhere("after vsbf");
+    asprintf(&mountpoint, "%s/archives", mtpt);
+    if (last_bigfile_num == -1) {
+        bigfile_num = 0;
+        slice_num = 0;
+    } else if (slice_num == 0) {
+        bigfile_num = last_bigfile_num + 1;
+        slice_num = 0;
+    } else {
+        bigfile_num = last_bigfile_num;
+        slice_num = last_slice_num + 1;
+    }
+    while (does_file_exist
+           (slice_fname
+            (bigfile_num, slice_num, mountpoint, bkpinfo->zip_suffix))
+           ||
+           does_file_exist(slice_fname
+                           (bigfile_num, slice_num, mountpoint, ""))) {
 // handle slices until end of CD
-      if (slice_num == 0)
-    {
-      log_msg (2, "ISO=%d  bigfile=%ld --START--", g_current_media_number, bigfile_num);
-      if ( !(fin = fopen( slice_fname( bigfile_num, slice_num, mountpoint, ""), "r" ) ) )
-            { log_msg(2, "Cannot open bigfile's info file"); }
-      else
-        {
-          if ( fread((void*)&biggiestruct, 1, sizeof(biggiestruct), fin) < sizeof(biggiestruct))
-            { log_msg(2, "Unable to get biggiestruct"); }
-          paranoid_fclose(fin);
-        }
-      sprintf( tmp, "%s/%s", bkpinfo->restore_path, biggiestruct.filename );
-      log_msg(2, "Opening biggiefile #%ld - '%s'", bigfile_num, tmp);
-      if (!(forig = fopen(tmp, "r"))) { log_msg(2, "Failed to open bigfile. Darn."); retval++; }
-      slice_num++;
-    }
-      else if (does_file_exist
-        (slice_fname (bigfile_num, slice_num, mountpoint, "")))
-    {
-      log_msg (2, "ISO=%d  bigfile=%ld ---END---",
-           g_current_media_number, bigfile_num);
-      bigfile_num++;
-      paranoid_fclose(forig);
-      slice_num = 0;
-    }
-      else
-    {
-      log_msg (2, "ISO=%d  bigfile=%ld  slice=%ld  \r",
-           g_current_media_number, bigfile_num, slice_num);
-      if (bkpinfo->compression_level > 0)
-        { sprintf(command, "cat %s | %s -dc 2>> %s", slice_fname(bigfile_num, slice_num, mountpoint, bkpinfo->zip_suffix), sz_exe, MONDO_LOGFILE); }
-      else
-        { sprintf(command, "cat %s", slice_fname(bigfile_num, slice_num, mountpoint, bkpinfo->zip_suffix)); }
-      if ((pin = popen(command,"r")))
-        {
-          res=0;
-          while(!feof(pin))
-            {
-          currsizA = fread(bufblkA, 1, maxbufsize, pin);
-          if (currsizA<=0) { break; }
-          currsizB = fread(bufblkB, 1, currsizA, forig);
-          if (currsizA != currsizB) { res++; }
-          else
-            {
-              for(j=0; j<currsizA && bufblkA[j]==bufblkB[j]; j++);
-              if (j<currsizA) { res++;}
-            }
-        }
-          paranoid_pclose(pin);
-          if (res && !strncmp(biggiestruct.filename," /dev/", 5))
-            {
-          log_msg(3, "Ignoring differences between %s and live filesystem because it's a device and therefore the archives are stored via partimagehack, not dd.", biggiestruct.filename);
-          log_msg(3, "If you really want verification for %s, please contact the devteam and offer an incentive.", biggiestruct.filename);
-          res=0;
-        }
-          if (res)
-            {
-          log_msg(0, "afio: \"%s\": Corrupt biggie file, says libmondo-archive.c", biggiestruct.filename);
-          retval++;
-        }
-        }
-      slice_num++;
-    }
-    }
-  last_bigfile_num = bigfile_num;
-  last_slice_num = slice_num - 1;
-  if (last_slice_num < 0)
-    {
-      last_bigfile_num--;
-    }
-  close_evalcall_form ();
-  if (bufblkA) { paranoid_free(bufblkA); }
-  if (bufblkB) { paranoid_free(bufblkB); }
-  paranoid_free(tmp);
-  paranoid_free(command);
-  paranoid_free(sz_exe);
-  paranoid_free(mountpoint);
-  return (0);
+        if (slice_num == 0) {
+            log_msg(2, "ISO=%d  bigfile=%ld --START--",
+                    g_current_media_number, bigfile_num);
+            if (!
+                (fin =
+                 fopen(slice_fname(bigfile_num, slice_num, mountpoint, ""),
+                       "r"))) {
+                log_msg(2, "Cannot open bigfile's info file");
+            } else {
+                if (fread
+                    ((void *) &biggiestruct, 1, sizeof(biggiestruct),
+                     fin) < sizeof(biggiestruct)) {
+                    log_msg(2, "Unable to get biggiestruct");
+                }
+                paranoid_fclose(fin);
+            }
+            asprintf(&tmp, "%s/%s", bkpinfo->restore_path,
+                    biggiestruct.filename);
+            log_msg(2, "Opening biggiefile #%ld - '%s'", bigfile_num, tmp);
+            if (!(forig = fopen(tmp, "r"))) {
+                log_msg(2, "Failed to open bigfile. Darn.");
+                retval++;
+            }
+            paranoid_free(tmp);
+
+            slice_num++;
+        } else if (does_file_exist
+                   (slice_fname(bigfile_num, slice_num, mountpoint, ""))) {
+            log_msg(2, "ISO=%d  bigfile=%ld ---END---",
+                    g_current_media_number, bigfile_num);
+            bigfile_num++;
+            paranoid_fclose(forig);
+            slice_num = 0;
+        } else {
+            log_msg(2, "ISO=%d  bigfile=%ld  slice=%ld  \r",
+                    g_current_media_number, bigfile_num, slice_num);
+            if (bkpinfo->compression_level > 0) {
+                asprintf(&command, "cat %s | %s -dc 2>> %s",
+                        slice_fname(bigfile_num, slice_num, mountpoint,
+                                    bkpinfo->zip_suffix), sz_exe,
+                        MONDO_LOGFILE);
+            } else {
+                asprintf(&command, "cat %s",
+                        slice_fname(bigfile_num, slice_num, mountpoint,
+                                    bkpinfo->zip_suffix));
+            }
+            if ((pin = popen(command, "r"))) {
+                res = 0;
+                while (!feof(pin)) {
+                    currsizA = fread(bufblkA, 1, maxbufsize, pin);
+                    if (currsizA <= 0) {
+                        break;
+                    }
+                    currsizB = fread(bufblkB, 1, currsizA, forig);
+                    if (currsizA != currsizB) {
+                        res++;
+                    } else {
+                        for (j = 0;
+                             j < currsizA && bufblkA[j] == bufblkB[j];
+                             j++);
+                        if (j < currsizA) {
+                            res++;
+                        }
+                    }
+                }
+                paranoid_pclose(pin);
+                if (res && !strncmp(biggiestruct.filename, " /dev/", 5)) {
+                    log_msg(3,
+                            "Ignoring differences between %s and live filesystem because it's a device and therefore the archives are stored via partimagehack, not dd.",
+                            biggiestruct.filename);
+                    log_msg(3,
+                            "If you really want verification for %s, please contact the devteam and offer an incentive.",
+                            biggiestruct.filename);
+                    res = 0;
+                }
+                if (res) {
+                    log_msg(0,
+                            "afio: \"%s\": Corrupt biggie file, says libmondo-archive.c",
+                            biggiestruct.filename);
+                    retval++;
+                }
+            }
+            paranoid_free(command);
+            slice_num++;
+        }
+    }
+    paranoid_free(mountpoint);
+    paranoid_free(sz_exe);
+
+    last_bigfile_num = bigfile_num;
+    last_slice_num = slice_num - 1;
+    if (last_slice_num < 0) {
+        last_bigfile_num--;
+    }
+    close_evalcall_form();
+    if (bufblkA) {
+        paranoid_free(bufblkA);
+    }
+    if (bufblkB) {
+        paranoid_free(bufblkB);
+    }
+    return (0);
 }
-
-
-
-
 
 
@@ -460 +392 @@
  * @return 0, always.
  */
-int
-verify_a_tarball (struct s_bkpinfo *bkpinfo, char *tarball_fname)
+int verify_a_tarball(struct s_bkpinfo *bkpinfo, char *tarball_fname)
 {
-    /*@ buffers **********************************************************/
-  char *command;
+    /*@ buffers ********************************************************* */
+    char *command;
     char *outlog;
-    char *tmp;
-    //  char *p;
-
-    /*@ pointers ********************************************************/
-  FILE *pin;
-
-    /*@ long ************************************************************/
-  long diffs = 0;
-  /*  getcwd(old_pwd,MAX_STR_LEN-1); */
-
-
-  command = malloc(2000);
-  malloc_string(outlog);
-  malloc_string(tmp);
-  assert(bkpinfo!=NULL);
-  assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
-
-  log_it("Verifying fileset '%s'", tarball_fname);
-  /*  chdir("/"); */
-  sprintf (outlog, "%s/afio.log", bkpinfo->tmpdir);
-/* if programmer forgot to say which compression thingy to use then find out */
-  if (strstr (tarball_fname, ".lzo") && strcmp (bkpinfo->zip_suffix, "lzo"))
-    {
-      log_msg (2, "OK, I'm going to start using lzop.");
-      strcpy (bkpinfo->zip_exe, "lzop");
-      strcpy (bkpinfo->zip_suffix, "lzo");
-      bkpinfo->use_lzo = TRUE;
-    }
-  if (strstr (tarball_fname, ".bz2") && strcmp (bkpinfo->zip_suffix, "bz2"))
-    {
-      log_msg (2, "OK, I'm going to start using bzip2.");
-      strcpy (bkpinfo->zip_exe, "bzip2");
-      strcpy (bkpinfo->zip_suffix, "bz2");
-      bkpinfo->use_lzo = FALSE;
-    }
-  unlink(outlog);
-  if (strstr(tarball_fname, ".star"))
-    {
-      bkpinfo->use_star = TRUE;
-      if (strstr(tarball_fname, ".bz2"))
-      sprintf (command, "star -diff diffopts=mode,size,data file=%s %s >> %s 2>> %s",
-           tarball_fname,
-           (strstr(tarball_fname, ".bz2"))?"-bz":" ",
-           outlog, outlog);
-    }
-  else
-    {
-      bkpinfo->use_star = FALSE;
-      sprintf (command, "afio -r -P %s -Z %s >> %s 2>> %s",
-       bkpinfo->zip_exe, tarball_fname, outlog, outlog);
-    }
-  log_msg(6, "command=%s", command);
-  paranoid_system (command);
-  if (length_of_file(outlog) < 10)
-    {
-      sprintf (command, "cat %s >> %s", outlog, MONDO_LOGFILE);
-    }
-  else
-    {
-      sprintf (command, "cat %s | cut -d':' -f%d | sort | uniq", outlog,
-       (bkpinfo->use_star)?1:2);
-      pin = popen (command, "r");
-      if (pin)
-        {
-          for (fgets (tmp, MAX_STR_LEN, pin); !feof (pin);
-           fgets (tmp, MAX_STR_LEN, pin))
-        {
-          if (bkpinfo->use_star)
-            {
-              if (!strstr(tmp, "diffopts="))
-            {
-              while( strlen(tmp)>0 && tmp[strlen(tmp)-1] < 32)
-                { tmp[strlen(tmp)-1] = '\0'; }
-              if (strchr(tmp, '/') )
-                {
-                  if (!diffs) { log_msg (0, "'%s' - differences found", tarball_fname); }
-                          log_msg (0,"star: /%s", strip_afio_output_line (tmp));
-                          diffs++;
+    char *tmp = NULL;
+    //  char *p;
+
+    /*@ pointers ******************************************************* */
+    FILE *pin;
+
+    int n = 0;
+
+    /*@ long *********************************************************** */
+    long diffs = 0;
+    /*  getcwd(old_pwd,MAX_STR_LEN-1); */
+
+    assert(bkpinfo != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
+
+    log_it("Verifying fileset '%s'", tarball_fname);
+
+    /*  chdir("/"); */
+    asprintf(&outlog, "%s/afio.log", bkpinfo->tmpdir);
+
+    /* if programmer forgot to say which compression thingy to use then find out */
+    if (strstr(tarball_fname, ".lzo")
+        && strcmp(bkpinfo->zip_suffix, "lzo")) {
+        log_msg(2, "OK, I'm going to start using lzop.");
+        strcpy(bkpinfo->zip_exe, "lzop");
+        strcpy(bkpinfo->zip_suffix, "lzo");
+        bkpinfo->use_lzo = TRUE;
+    }
+    if (strstr(tarball_fname, ".bz2")
+        && strcmp(bkpinfo->zip_suffix, "bz2")) {
+        log_msg(2, "OK, I'm going to start using bzip2.");
+        strcpy(bkpinfo->zip_exe, "bzip2");
+        strcpy(bkpinfo->zip_suffix, "bz2");
+        bkpinfo->use_lzo = FALSE;
+    }
+    unlink(outlog);
+    if (strstr(tarball_fname, ".star")) {
+        bkpinfo->use_star = TRUE;
+        if (strstr(tarball_fname, ".bz2"))
+            asprintf(&command,
+                    "star -diff diffopts=mode,size,data file=%s %s >> %s 2>> %s",
+                    tarball_fname,
+                    (strstr(tarball_fname, ".bz2")) ? "-bz" : " ", outlog,
+                    outlog);
+    } else {
+        bkpinfo->use_star = FALSE;
+        asprintf(&command, "afio -r -P %s -Z %s >> %s 2>> %s",
+                bkpinfo->zip_exe, tarball_fname, outlog, outlog);
+    }
+    log_msg(6, "command=%s", command);
+    paranoid_system(command);
+    paranoid_free(command);
+
+    if (length_of_file(outlog) < 10) {
+        asprintf(&command, "cat %s >> %s", outlog, MONDO_LOGFILE);
+    } else {
+        asprintf(&command, "cat %s | cut -d':' -f%d | sort | uniq", outlog,
+                (bkpinfo->use_star) ? 1 : 2);
+        pin = popen(command, "r");
+        if (pin) {
+            for (getline(&tmp, &n, pin); !feof(pin);
+                 fgets(&tmp, &n, pin)) {
+                if (bkpinfo->use_star) {
+                    if (!strstr(tmp, "diffopts=")) {
+                        while (strlen(tmp) > 0
+                               && tmp[strlen(tmp) - 1] < 32) {
+                            tmp[strlen(tmp) - 1] = '\0';
+                        }
+                        if (strchr(tmp, '/')) {
+                            if (!diffs) {
+                                log_msg(0, "'%s' - differences found",
+                                        tarball_fname);
+                            }
+                            log_msg(0, "star: /%s",
+                                    strip_afio_output_line(tmp));
+                            diffs++;
+                        }
+                    }
+                } else {
+                    if (!diffs) {
+                        log_msg(0, "'%s' - differences found",
+                                tarball_fname);
+                    }
+                    log_msg(0, "afio: /%s", strip_afio_output_line(tmp));
+                    diffs++;
+                }
             }
-            }
-            }
-          else
-            {
-              if (!diffs) { log_msg (0, "'%s' - differences found", tarball_fname); }
-                  log_msg (0,"afio: /%s", strip_afio_output_line (tmp));
-                  diffs++;
-            }
-        }
-          paranoid_pclose (pin);
-        }
-      else
-        {
-          log_OS_error(command);
-         }
-    }
-  /*  chdir(old_pwd); */
-  //  sprintf (tmp, "cat %s | uniq -u >> %s", "/tmp/mondo-verify.err", MONDO_LOGFILE);
-  //  paranoid_system (tmp);
-  //  unlink ("/tmp/mondo-verify.err");
-  paranoid_free(command);
-  paranoid_free(outlog);
-  paranoid_free(tmp);
-  return (0);
+            paranoid_pclose(pin);
+            paranoid_free(tmp);
+        } else {
+            log_OS_error(command);
+        }
+    }
+    paranoid_free(outlog);
+    paranoid_free(command);
+
+    /*  chdir(old_pwd); */
+    //  sprintf (tmp, "cat %s | uniq -u >> %s", "/tmp/mondo-verify.err", MONDO_LOGFILE);
+    //  paranoid_system (tmp);
+    //  unlink ("/tmp/mondo-verify.err");
+    return (0);
 }
-
-
-
-
 
 
@@ -586 +511 @@
  */
 int
-verify_an_afioball_from_CD (struct s_bkpinfo *bkpinfo, char *tarball_fname)
+verify_an_afioball_from_CD(struct s_bkpinfo *bkpinfo, char *tarball_fname)
 {
 
-    /*@ int **************************************************************/
-  int res = 0;
-
-  assert(bkpinfo!=NULL);
-  assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
-
-  log_msg (1, "Verifying %s", tarball_fname);
-  if (!does_file_exist (tarball_fname))
-    {
-      fatal_error ("Cannot verify nonexistent afioball");
-    }
-  res = verify_a_tarball (bkpinfo, tarball_fname);
-  return (res);
+    /*@ int ************************************************************* */
+    int res = 0;
+
+    assert(bkpinfo != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
+
+    log_msg(1, "Verifying %s", tarball_fname);
+    if (!does_file_exist(tarball_fname)) {
+        fatal_error("Cannot verify nonexistent afioball");
+    }
+    res = verify_a_tarball(bkpinfo, tarball_fname);
+    return (res);
 }
 
@@ -615 +539 @@
  */
 int
-verify_an_afioball_from_stream (struct s_bkpinfo *bkpinfo, char *orig_fname,
-                  long long size)
+verify_an_afioball_from_stream(struct s_bkpinfo *bkpinfo, char *orig_fname,
+                               long long size)
 {
 
-    /*@ int ***************************************************************/
-  int retval = 0;
+    /*@ int ************************************************************** */
+    int retval = 0;
     int res = 0;
 
-    /*@ buffers ***********************************************************/
-  char *tmp;
+    /*@ buffers ********************************************************** */
+    char *tmp;
     char *tarball_fname;
 
-    /*@ pointers **********************************************************/
-    char  *p;
-
-  malloc_string(tmp);
-  malloc_string(tarball_fname);
-  assert(bkpinfo!=NULL);
-  assert_string_is_neither_NULL_nor_zerolength(orig_fname);
-
-  p = strrchr (orig_fname, '/');
-  if (!p)
-    {
-      p = orig_fname;
-    }
-  else
-    {
-      p++;
-    }
-  sprintf (tmp, "mkdir -p %s/tmpfs", bkpinfo->tmpdir);
-  paranoid_system (tmp);
-  sprintf (tarball_fname, "%s/tmpfs/temporary-%s", bkpinfo->tmpdir, p);
-  sprintf (tmp, "Temporarily copying file from tape to '%s'", tarball_fname);
-/*  log_it(tmp); */
-  read_file_from_stream_to_file (bkpinfo, tarball_fname, size);
-  res = verify_a_tarball (bkpinfo, tarball_fname);
-  if (res)
-    {
-      sprintf (tmp, "Afioball '%s' no longer matches your live filesystem",
-           p);
-      log_msg (0, tmp);
-      retval++;
-    }
-  unlink (tarball_fname);
-  paranoid_free(tmp);
-  paranoid_free(tarball_fname);
-  return (retval);
+    /*@ pointers ********************************************************* */
+    char *p;
+
+    assert(bkpinfo != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(orig_fname);
+
+    p = strrchr(orig_fname, '/');
+    if (!p) {
+        p = orig_fname;
+    } else {
+        p++;
+    }
+    asprintf(&tmp, "mkdir -p %s/tmpfs", bkpinfo->tmpdir);
+    paranoid_system(tmp);
+    paranoid_free(tmp);
+
+    asprintf(&tarball_fname, "%s/tmpfs/temporary-%s", bkpinfo->tmpdir, p);
+    /* BERLIOS : useless
+    asprintf(&tmp, "Temporarily copying file from tape to '%s'",
+            tarball_fname);
+    log_it(tmp); 
+    paranoid_free(tmp);
+    */
+    read_file_from_stream_to_file(bkpinfo, tarball_fname, size);
+    res = verify_a_tarball(bkpinfo, tarball_fname);
+    if (res) {
+        asprintf(&tmp,
+                "Afioball '%s' no longer matches your live filesystem", p);
+        log_msg(0, tmp);
+        paranoid_free(tmp);
+        retval++;
+    }
+    unlink(tarball_fname);
+    paranoid_free(tarball_fname);
+    return (retval);
 }
 
@@ -673 +597 @@
  */
 int
-verify_a_biggiefile_from_stream (struct s_bkpinfo *bkpinfo, char *biggie_fname,
-                   long long size)
+verify_a_biggiefile_from_stream(struct s_bkpinfo *bkpinfo,
+                                char *biggie_fname, long long size)
 {
 
-    /*@ int **************************************************************/
-  int retval = 0;
+    /*@ int ************************************************************* */
+    int retval = 0;
     int res = 0;
     int current_slice_number = 0;
     int ctrl_chr = '\0';
 
-  /*@ char *************************************************************/
+    /*@ char ************************************************************ */
     char *test_file;
     char *biggie_cksum;
@@ -689 +613 @@
     char *tmp;
     char *slice_fnam;
-    
-    /*@ pointers *********************************************************/
+
+    /*@ pointers ******************************************************** */
     char *p;
 
-    /*@ long long ********************************************************/
-  long long slice_siz;
-
-  malloc_string(test_file);
-  malloc_string(biggie_cksum);
-  malloc_string(orig_cksum);
-  malloc_string(tmp);
-  malloc_string(slice_fnam);
-  assert(bkpinfo!=NULL); 
-  assert_string_is_neither_NULL_nor_zerolength(biggie_fname);
-
-  p = strrchr (biggie_fname, '/');
-  if (!p)
-    {
-      p = biggie_fname;
-    }
-  else
-    {
-      p++;
-    }
-  sprintf (test_file, "%s/temporary-%s", bkpinfo->tmpdir, p);
-  sprintf (tmp,
-       "Temporarily copying biggiefile %s's slices from tape to '%s'", p,
-       test_file);
-/*  log_it(tmp); */
-  for (res = read_header_block_from_stream (&slice_siz, slice_fnam, &ctrl_chr);
-       ctrl_chr != BLK_STOP_A_BIGGIE;
-       res = read_header_block_from_stream (&slice_siz, slice_fnam, &ctrl_chr))
-    {
-      if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE)
-    {
-      wrong_marker (BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
-    }
-      res = read_file_from_stream_to_file (bkpinfo, test_file, slice_siz);
-      unlink (test_file);
-      res = read_header_block_from_stream (&slice_siz, slice_fnam, &ctrl_chr);
-      if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE)
-    {
-      log_msg (2, "test_file = %s", test_file);
-      wrong_marker (BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
-    }
-      current_slice_number++;
-      retval += res;
-    }
-  strcpy (biggie_cksum, slice_fnam);
-  if (biggie_cksum[0] != '\0')
-    {
-      strcpy (orig_cksum, calc_checksum_of_file (biggie_fname));
-      if (strcmp (biggie_cksum, orig_cksum))
-    {
-      sprintf (tmp, "orig cksum=%s; curr cksum=%s", biggie_cksum,
-           orig_cksum);
-      log_msg (2, tmp);
-      sprintf (tmp, "%s has changed on live filesystem", biggie_fname);
-      log_to_screen (tmp);
-      sprintf(tmp, "echo \"%s\" >> /tmp/biggies.changed", biggie_fname);
-      system(tmp);
-    }
-    }
-  paranoid_free(test_file);
-  paranoid_free(biggie_cksum);
-  paranoid_free(orig_cksum);
-  paranoid_free(tmp);
-  paranoid_free(slice_fnam);
-  return (retval);
+    /*@ long long ******************************************************* */
+    long long slice_siz;
+
+    malloc_string(slice_fnam);
+    assert(bkpinfo != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(biggie_fname);
+
+    p = strrchr(biggie_fname, '/');
+    if (!p) {
+        p = biggie_fname;
+    } else {
+        p++;
+    }
+    asprintf(&test_file, "%s/temporary-%s", bkpinfo->tmpdir, p);
+    /* BERLIOS: useless
+    asprintf(&tmp,
+            "Temporarily copying biggiefile %s's slices from tape to '%s'",
+            p, test_file);
+    log_it(tmp); 
+    paranoid_free(tmp);
+    */
+    for (res = read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr);
+         ctrl_chr != BLK_STOP_A_BIGGIE;
+         res = read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr)) {
+        if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
+            wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
+        }
+        res = read_file_from_stream_to_file(bkpinfo, test_file, slice_siz);
+        unlink(test_file);
+        res = read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr);
+        if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
+            log_msg(2, "test_file = %s", test_file);
+            wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
+        }
+        current_slice_number++;
+        retval += res;
+    }
+    paranoid_free(test_file);
+
+    asprintf(&biggie_cksum, slice_fnam);
+    paranoid_free(slice_fnam);
+
+    if (biggie_cksum[0] != '\0') {
+        asprintf(&orig_cksum, calc_checksum_of_file(biggie_fname));
+        if (strcmp(biggie_cksum, orig_cksum)) {
+            asprintf(&tmp, "orig cksum=%s; curr cksum=%s", biggie_cksum,
+                    orig_cksum);
+            log_msg(2, tmp);
+            paranoid_free(tmp);
+
+            asprintf(&tmp, "%s has changed on live filesystem",
+                    biggie_fname);
+            log_to_screen(tmp);
+            paranoid_free(tmp);
+
+            asprintf(&tmp, "echo \"%s\" >> /tmp/biggies.changed",
+                    biggie_fname);
+            system(tmp);
+            paranoid_free(tmp);
+        }
+        paranoid_free(orig_cksum);
+    }
+    paranoid_free(biggie_cksum);
+
+    return (retval);
 }
 
@@ -769 +693 @@
  * @return 0 for success (even if there are differences); nonzero for a tape error.
  */
-int
-verify_afioballs_from_stream (struct s_bkpinfo *bkpinfo)
+int verify_afioballs_from_stream(struct s_bkpinfo *bkpinfo)
 {
-    /*@ int ***********************************************************/
-  int retval = 0;
+    /*@ int ********************************************************** */
+    int retval = 0;
     int res = 0;
     long current_afioball_number = 0;
@@ -779 +702 @@
     int total_afioballs = 0;
 
-    /*@ buffers ******************************************************/
-  char *tmp;
+    /*@ buffers ***************************************************** */
+    char *tmp;
     char *fname;
-  char *curr_xattr_list_fname;
-  char *curr_acl_list_fname;
-
-    /*@ long long ****************************************************/
-  long long size = 0;
-
-  assert(bkpinfo!=NULL);
-  malloc_string(tmp);
-  malloc_string(fname);
-  malloc_string(curr_xattr_list_fname);
-  malloc_string(curr_acl_list_fname);
-
-  sprintf(curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);  
-  sprintf(curr_acl_list_fname,     ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);  
-  log_to_screen ("Verifying regular archives on tape");
-  total_afioballs = get_last_filelist_number (bkpinfo) + 1;
-  open_progress_form ("Verifying filesystem",
-              "I am verifying archives against your live filesystem now.",
-              "Please wait. This may take a couple of hours.", "",
-              total_afioballs);
-  res = read_header_block_from_stream (&size, fname, &ctrl_chr);
-  if (ctrl_chr != BLK_START_AFIOBALLS)
-    {
-      iamhere("YOU SHOULD NOT GET HERE");
-      iamhere("Grabbing the EXAT files");
-      if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES)
-        {
-      res = read_EXAT_files_from_tape(bkpinfo, &size, fname, &ctrl_chr, curr_xattr_list_fname, curr_acl_list_fname); 
-    }
-    }
-  if (ctrl_chr != BLK_START_AFIOBALLS)
-    { wrong_marker (BLK_START_AFIOBALLS, ctrl_chr); }
-  
-  for (res = read_header_block_from_stream (&size, fname, &ctrl_chr);
-       ctrl_chr != BLK_STOP_AFIOBALLS;
-       res = read_header_block_from_stream (&size, fname, &ctrl_chr))
-    {
-      sprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, current_afioball_number);
-      sprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, current_afioball_number);
-      if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES)
-        {
-      iamhere("Reading EXAT files from tape");
-      res = read_EXAT_files_from_tape(bkpinfo, &size, fname, &ctrl_chr, curr_xattr_list_fname, curr_acl_list_fname);
-        }
-      if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE)
-    {
-      wrong_marker (BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
-    }
-      sprintf (tmp, "Verifying fileset #%ld", current_afioball_number);
-      /*log_it(tmp); */
-      update_progress_form (tmp);
-      res = verify_an_afioball_from_stream (bkpinfo, fname, size);
-      if (res)
-    {
-      sprintf (tmp, "Afioball %ld differs from live filesystem",
-           current_afioball_number);
-      log_to_screen (tmp);
-    }
-      retval += res;
-      current_afioball_number++;
-      g_current_progress++;
-      res = read_header_block_from_stream (&size, fname, &ctrl_chr);
-      if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE)
-    {
-      wrong_marker (BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
-    }
-    }
-  log_msg (1, "All done with afioballs");
-  close_progress_form ();
-  paranoid_free(tmp);
-  paranoid_free(fname);
-  paranoid_free(curr_xattr_list_fname);
-  paranoid_free(curr_acl_list_fname);
-  return (retval);
+    char *curr_xattr_list_fname;
+    char *curr_acl_list_fname;
+
+    /*@ long long *************************************************** */
+    long long size = 0;
+
+    assert(bkpinfo != NULL);
+    malloc_string(fname);
+
+    asprintf(&curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ,
+            bkpinfo->tmpdir);
+    asprintf(&curr_acl_list_fname, ACL_BIGGLST_FNAME_RAW_SZ,
+            bkpinfo->tmpdir);
+    log_to_screen("Verifying regular archives on tape");
+    total_afioballs = get_last_filelist_number(bkpinfo) + 1;
+    open_progress_form("Verifying filesystem",
+                       "I am verifying archives against your live filesystem now.",
+                       "Please wait. This may take a couple of hours.", "",
+                       total_afioballs);
+    res = read_header_block_from_stream(&size, fname, &ctrl_chr);
+    if (ctrl_chr != BLK_START_AFIOBALLS) {
+        iamhere("YOU SHOULD NOT GET HERE");
+        iamhere("Grabbing the EXAT files");
+        if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
+            res =
+                read_EXAT_files_from_tape(bkpinfo, &size, fname, &ctrl_chr,
+                                          curr_xattr_list_fname,
+                                          curr_acl_list_fname);
+        }
+    }
+    if (ctrl_chr != BLK_START_AFIOBALLS) {
+        wrong_marker(BLK_START_AFIOBALLS, ctrl_chr);
+    }
+    paranoid_free(curr_xattr_list_fname);
+    paranoid_free(curr_acl_list_fname);
+
+    for (res = read_header_block_from_stream(&size, fname, &ctrl_chr);
+         ctrl_chr != BLK_STOP_AFIOBALLS;
+         res = read_header_block_from_stream(&size, fname, &ctrl_chr)) {
+        asprintf(&curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
+                bkpinfo->tmpdir, current_afioball_number);
+        asprintf(&curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
+                bkpinfo->tmpdir, current_afioball_number);
+        if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
+            iamhere("Reading EXAT files from tape");
+            res =
+                read_EXAT_files_from_tape(bkpinfo, &size, fname, &ctrl_chr,
+                                          curr_xattr_list_fname,
+                                          curr_acl_list_fname);
+        }
+        paranoid_free(curr_xattr_list_fname);
+        paranoid_free(curr_acl_list_fname);
+
+        if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
+            wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
+        }
+        asprintf(&tmp, "Verifying fileset #%ld", current_afioball_number);
+        /*log_it(tmp); */
+        update_progress_form(tmp);
+        paranoid_free(tmp);
+
+        res = verify_an_afioball_from_stream(bkpinfo, fname, size);
+        if (res) {
+            asprintf(&tmp, "Afioball %ld differs from live filesystem",
+                    current_afioball_number);
+            log_to_screen(tmp);
+            paranoid_free(tmp);
+        }
+        retval += res;
+        current_afioball_number++;
+        g_current_progress++;
+        res = read_header_block_from_stream(&size, fname, &ctrl_chr);
+        if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
+            wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
+        }
+    }
+    log_msg(1, "All done with afioballs");
+    close_progress_form();
+    paranoid_free(fname);
+    return (retval);
 }
+
 
 /**
@@ -866 +796 @@
  * @return 0 for success (even if there are differences); nonzero for a tape error.
  */
-int
-verify_biggiefiles_from_stream (struct s_bkpinfo *bkpinfo)
+int verify_biggiefiles_from_stream(struct s_bkpinfo *bkpinfo)
 {
 
-    /*@ int *************************************************************/
-  int retval = 0;
+    /*@ int ************************************************************ */
+    int retval = 0;
     int res = 0;
     int ctrl_chr = 0;
 
-    /*@ long ************************************************************/
-  long noof_biggiefiles = 0;
+    /*@ long *********************************************************** */
+    long noof_biggiefiles = 0;
     long current_biggiefile_number = 0;
 
-    /*@ buffers *********************************************************/
-  char *tmp;
+    /*@ buffers ******************************************************** */
+    char *tmp;
     char *orig_fname, *logical_fname;
     char *comment;
     char *curr_xattr_list_fname;
     char *curr_acl_list_fname;
-    /*@ pointers ********************************************************/
+    /*@ pointers ******************************************************* */
     char *p;
 
-    /*@ long long size **************************************************/
-  long long size = 0;
-
-  assert(bkpinfo!=NULL);
-  malloc_string(tmp);
-  malloc_string(orig_fname);
-  malloc_string(logical_fname);
-  malloc_string(comment);
-  malloc_string(curr_xattr_list_fname);
-  malloc_string(curr_acl_list_fname);
-
-  sprintf(curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);  
-  sprintf(curr_acl_list_fname,     ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);  
-  sprintf (comment, "Verifying all bigfiles.");
-  log_to_screen (comment);
-  sprintf (tmp, "%s/biggielist.txt", bkpinfo->tmpdir);
-//  noof_biggiefiles = count_lines_in_file (tmp); // pointless
-  res = read_header_block_from_stream (&size, orig_fname, &ctrl_chr);
-  if (ctrl_chr != BLK_START_BIGGIEFILES)
-    {
-      if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES)
-        {
-          iamhere("Grabbing the EXAT biggiefiles");
-      res = read_EXAT_files_from_tape(bkpinfo, &size, orig_fname, &ctrl_chr, curr_xattr_list_fname, curr_acl_list_fname); 
-    }
-    }
-  if (ctrl_chr != BLK_START_BIGGIEFILES)
-    {
-      wrong_marker (BLK_START_BIGGIEFILES, ctrl_chr);
-    }
-  noof_biggiefiles = (long)size;
-  log_msg(1, "noof_biggiefiles = %ld", noof_biggiefiles);
-  open_progress_form ("Verifying big files", comment,
-              "Please wait. This may take some time.", "",
-              noof_biggiefiles);
-  for (res = read_header_block_from_stream (&size, orig_fname, &ctrl_chr);
-       ctrl_chr != BLK_STOP_BIGGIEFILES;
-       res = read_header_block_from_stream (&size, orig_fname, &ctrl_chr))
-    {
-      if (ctrl_chr != BLK_START_A_NORMBIGGIE && ctrl_chr != BLK_START_A_PIHBIGGIE)
+    /*@ long long size ************************************************* */
+    long long size = 0;
+
+    assert(bkpinfo != NULL);
+    malloc_string(orig_fname);
+
+    asprintf(&curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ,
+            bkpinfo->tmpdir);
+    asprintf(&curr_acl_list_fname, ACL_BIGGLST_FNAME_RAW_SZ,
+            bkpinfo->tmpdir);
+    asprintf(&comment, "Verifying all bigfiles.");
+    log_to_screen(comment);
+    /*
+    asprintf(&tmp, "%s/biggielist.txt", bkpinfo->tmpdir);
+    noof_biggiefiles = count_lines_in_file (tmp); // pointless
+    paranoid_free(tmp);
+    */
+    res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr);
+    if (ctrl_chr != BLK_START_BIGGIEFILES) {
+        if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
+            iamhere("Grabbing the EXAT biggiefiles");
+            res =
+                read_EXAT_files_from_tape(bkpinfo, &size, orig_fname,
+                                          &ctrl_chr, curr_xattr_list_fname,
+                                          curr_acl_list_fname);
+        }
+    }
+    paranoid_free(curr_xattr_list_fname);
+    paranoid_free(curr_acl_list_fname);
+
+    if (ctrl_chr != BLK_START_BIGGIEFILES) {
+        wrong_marker(BLK_START_BIGGIEFILES, ctrl_chr);
+    }
+    noof_biggiefiles = (long) size;
+    log_msg(1, "noof_biggiefiles = %ld", noof_biggiefiles);
+    open_progress_form("Verifying big files", comment,
+                       "Please wait. This may take some time.", "",
+                       noof_biggiefiles);
+    paranoid_free(comment);
+
+    for (res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr);
+         ctrl_chr != BLK_STOP_BIGGIEFILES;
+         res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr))
     {
-      wrong_marker (BLK_START_A_NORMBIGGIE, ctrl_chr);
-    }
-      p = strrchr (orig_fname, '/');
-      if (!p)
-    {
-      p = orig_fname;
-    }
-      else
-    {
-      p++;
-    }
-      sprintf (comment, "Verifying bigfile #%ld (%ld K)",
-           current_biggiefile_number, (long) size >> 10);
-      update_progress_form (comment);
-      sprintf( logical_fname, "%s/%s", bkpinfo->restore_path, orig_fname);
-      res = verify_a_biggiefile_from_stream (bkpinfo, logical_fname, size);
-      retval += res;
-      current_biggiefile_number++;
-      g_current_progress++;
-    }
-  close_progress_form ();
-  paranoid_free(orig_fname);
-  paranoid_free(logical_fname);
-  paranoid_free(curr_xattr_list_fname);
-  paranoid_free(curr_acl_list_fname);
-  paranoid_free(comment);
-  paranoid_free(tmp);
-  return (retval);
+        if (ctrl_chr != BLK_START_A_NORMBIGGIE
+            && ctrl_chr != BLK_START_A_PIHBIGGIE) {
+            wrong_marker(BLK_START_A_NORMBIGGIE, ctrl_chr);
+        }
+        p = strrchr(orig_fname, '/');
+        if (!p) {
+            p = orig_fname;
+        } else {
+            p++;
+        }
+        asprintf(&comment, "Verifying bigfile #%ld (%ld K)",
+                current_biggiefile_number, (long) size >> 10);
+        update_progress_form(comment);
+        paranoid_free(comment);
+
+        asprintf(&logical_fname, "%s/%s", bkpinfo->restore_path, orig_fname);
+        res = verify_a_biggiefile_from_stream(bkpinfo, logical_fname, size);
+        paranoid_free(logical_fname);
+        retval += res;
+        current_biggiefile_number++;
+        g_current_progress++;
+    }
+    close_progress_form();
+    paranoid_free(orig_fname);
+    return (retval);
 }
 
@@ -976 +905 @@
  * @ingroup verifyGroup
  */
-int
-verify_cd_image (struct s_bkpinfo *bkpinfo)
+int verify_cd_image(struct s_bkpinfo *bkpinfo)
 {
 
-    /*@ int *************************************************************/
-  int retval = 0;
-
-    /*@ buffers *********************************************************/
-  char *mountpoint;
+    /*@ int ************************************************************ */
+    int retval = 0;
+
+    /*@ buffers ******************************************************** */
+    char *mountpoint;
     char *command;
     char *tmp;
     char *fname;
 #ifdef __FreeBSD__
-        char mdd[32];
+    char mdd[32];
     char *mddevice = mdd;
-        int ret = 0; int vndev = 2;
+    int ret = 0;
+    int vndev = 2;
 #else
 //skip
 #endif
 
-  command = malloc(2000);
-  malloc_string(mountpoint);
-  malloc_string(tmp);
-  malloc_string(fname);
-  
-  assert(bkpinfo!=NULL);
-
-  sprintf (mountpoint, "%s/cdrom", bkpinfo->tmpdir);
-  sprintf (fname, "%s/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->prefix, 
-          bkpinfo->nfs_remote_dir, g_current_media_number);
-
-  mkdir (mountpoint, 1777);
-  sync ();
-  if (!does_file_exist (fname))
-    {
-      sprintf (tmp,
-           "%s not found; assuming you backed up to CD; verifying CD...",
-           fname);
-      log_msg (2, tmp);
-      if (bkpinfo->manual_cd_tray)
-    {
-      popup_and_OK ("Please push CD tray closed.");
-    }
-      if (find_and_mount_actual_cd (bkpinfo, mountpoint))
-    {
-      log_to_screen ("failed to mount actual CD");
-      return (1);
-    }
-    }
-  else
-    {
-      sprintf (tmp, "%s found; verifying ISO...", fname);
+    assert(bkpinfo != NULL);
+
+    asprintf(&mountpoint, "%s/cdrom", bkpinfo->tmpdir);
+    asprintf(&fname, "%s/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->prefix,
+            bkpinfo->nfs_remote_dir, g_current_media_number);
+
+    mkdir(mountpoint, 1777);
+    sync();
+    if (!does_file_exist(fname)) {
+        asprintf(&tmp,
+                "%s not found; assuming you backed up to CD; verifying CD...",
+                fname);
+        log_msg(2, tmp);
+        paranoid_free(tmp);
+
+        if (bkpinfo->manual_cd_tray) {
+            popup_and_OK("Please push CD tray closed.");
+        }
+        if (find_and_mount_actual_cd(bkpinfo, mountpoint)) {
+            log_to_screen("failed to mount actual CD");
+            return (1);
+        }
+    } else {
+        asprintf(&tmp, "%s found; verifying ISO...", fname);
+        log_to_screen(tmp);
+        paranoid_free(tmp);
 #ifdef __FreeBSD__
-      ret = 0;
-      vndev = 2;
-      mddevice = make_vn (fname);
-      if (ret)
-        {
-          sprintf (tmp, "make_vn of %s failed; unable to verify ISO\n", fname);
-          log_to_screen (tmp);
-          return (1);
-        }
-      sprintf (command, "mount_cd9660 %s %s", mddevice, mountpoint);
+        ret = 0;
+        vndev = 2;
+        mddevice = make_vn(fname);
+        if (ret) {
+            asprintf(&tmp, "make_vn of %s failed; unable to verify ISO\n",
+                    fname);
+            log_to_screen(tmp);
+            paranoid_free(tmp);
+            return (1);
+        }
+        asprintf(&command, "mount_cd9660 %s %s", mddevice, mountpoint);
 #else
-      sprintf (command, "mount -o loop,ro -t iso9660 %s %s", fname,
-           mountpoint);
+        asprintf(&command, "mount -o loop,ro -t iso9660 %s %s", fname,
+                mountpoint);
 #endif
-      if (run_program_and_log_output(command, FALSE))
-    {
-      sprintf (tmp, "%s failed; unable to mount ISO image\n", command);
-      log_to_screen (tmp);
-      return (1);
-    }
-    }
-  log_msg (2, "OK, I've mounted the ISO/CD\n");
-  sprintf (tmp, "%s/archives/NOT-THE-LAST", mountpoint);
-  if (!does_file_exist (tmp))
-    {
-      log_msg
-    (2, "This is the last CD. I am therefore setting bkpinfo->verify_data to FALSE.");
-      bkpinfo->verify_data = FALSE;
+        if (run_program_and_log_output(command, FALSE)) {
+            asprintf(&tmp, "%s failed; unable to mount ISO image\n",
+                    command);
+            log_to_screen(tmp);
+            paranoid_free(tmp);
+            return (1);
+        }
+        paranoid_free(command);
+    }
+    log_msg(2, "OK, I've mounted the ISO/CD\n");
+    asprintf(&tmp, "%s/archives/NOT-THE-LAST", mountpoint);
+    if (!does_file_exist(tmp)) {
+        log_msg
+            (2,
+             "This is the last CD. I am therefore setting bkpinfo->verify_data to FALSE.");
+        bkpinfo->verify_data = FALSE;
 /*
    (a) It's an easy way to tell the calling subroutine that we've finished &
@@ -1062 +988 @@
    from running after the per-CD verifier has run too.
 */
-    }
-  verify_afioballs_on_CD (bkpinfo, mountpoint);
-  iamhere("before verify_all_slices");
-  verify_all_slices_on_CD (bkpinfo, mountpoint);
+    }
+    paranoid_free(tmp);
+
+    verify_afioballs_on_CD(bkpinfo, mountpoint);
+    iamhere("before verify_all_slices");
+    verify_all_slices_on_CD(bkpinfo, mountpoint);
 
 #ifdef __FreeBSD__
-  ret=0;
-  sprintf (command, "umount %s", mountpoint);
-  ret += system (command);
-  ret += kick_vn (mddevice);
-  if (ret)
+    ret = 0;
+    asprintf(&command, "umount %s", mountpoint);
+    ret += system(command);
+
+    ret += kick_vn(mddevice);
+    if (ret)
 #else
-  sprintf (command, "umount %s", mountpoint);
-  if (system (command))
+    asprintf(&command, "umount %s", mountpoint);
+
+    if (system(command))
 #endif
-    {
-      sprintf (tmp, "%s failed; unable to unmount ISO image\n", command);
-      log_to_screen (tmp);
-      retval++;
-    }
-  else
-    {
-      log_msg (2, "OK, I've unmounted the ISO file\n");
-    }
-  if (!does_file_exist (fname))
-    {
-      sprintf(command, "umount %s", bkpinfo->media_device);
-      run_program_and_log_output(command, 2);
-      if (!bkpinfo->please_dont_eject && eject_device(bkpinfo->media_device))
     {
-      log_msg (2, "Failed to eject CD-ROM drive");
-    }
-    }
-  paranoid_free(command);
-  paranoid_free(mountpoint);
-  paranoid_free(tmp);
-  paranoid_free(fname);
-  return (retval);
+        asprintf(&tmp, "%s failed; unable to unmount ISO image\n", command);
+        log_to_screen(tmp);
+        paranoid_free(tmp);
+        retval++;
+    } else {
+        log_msg(2, "OK, I've unmounted the ISO file\n");
+    }
+    paranoid_free(command);
+    paranoid_free(mountpoint);
+
+    if (!does_file_exist(fname)) {
+        asprintf(&command, "umount %s", bkpinfo->media_device);
+        run_program_and_log_output(command, 2);
+        paranoid_free(command);
+
+        if (!bkpinfo->please_dont_eject
+            && eject_device(bkpinfo->media_device)) {
+            log_msg(2, "Failed to eject CD-ROM drive");
+        }
+    }
+    paranoid_free(fname);
+    return (retval);
 }
+
 
 /**
@@ -1109 +1040 @@
  * @ingroup verifyGroup
  */
-int
-verify_tape_backups (struct s_bkpinfo *bkpinfo)
+int verify_tape_backups(struct s_bkpinfo *bkpinfo)
 {
 
-    /*@ int *************************************************************/
-  int retval = 0;
-
-    /*@ buffers *********************************************************/
-  char tmp[MAX_STR_LEN];
-  char changed_files_fname[MAX_STR_LEN];
-
-    /*@ long ************************************************************/
-  long diffs = 0;
-
-  assert(bkpinfo!=NULL);
-
-  log_msg (3, "verify_tape_backups --- starting");
-  log_to_screen ("Verifying backups");
-  openin_tape (bkpinfo);
-/* verify archives themselves */
-  retval += verify_afioballs_from_stream (bkpinfo);
-  retval += verify_biggiefiles_from_stream (bkpinfo);
-/* find the final blocks */
-  paranoid_system ("sync");
-  sleep (2);
-  closein_tape (bkpinfo);
-/* close tape; exit */
-//  fclose(g_tape_stream); <-- not needed; is handled by closein_tape()
-  paranoid_system("rm -f /tmp/biggies.changed /tmp/changed.files.[0-9]* 2> /dev/null");
-  sprintf (changed_files_fname, "/tmp/changed.files.%d", (int)(random()%32767));
-  sprintf (tmp,
-       "cat %s | grep -x \"%s:.*\" | cut -d'\"' -f2 | sort -u | awk '{print \"/\"$0;};' | tr -s '/' '/' | grep -v \"(total of\" | grep -v \"incheckentry.*xwait\" | grep -vx \"/afio:.*\" | grep -vx \"dev/.*\"  > %s",
-       MONDO_LOGFILE, (bkpinfo->use_star)?"star":"afio", changed_files_fname);
-  log_msg (2, "Running command to derive list of changed files");
-  log_msg (2, tmp);
-  if (system (tmp))
-    {
-      if (does_file_exist(changed_files_fname) && length_of_file(changed_files_fname)>2)
-        { log_to_screen("Warning - unable to check logfile to derive list of changed files"); }
-      else
-        { log_to_screen("No differences found. Therefore, no 'changed.files' text file."); }
-    }
-  sprintf(tmp, "cat /tmp/biggies.changed >> %s", changed_files_fname);
-  paranoid_system(tmp);
-
-  diffs = count_lines_in_file (changed_files_fname);
-  if (diffs > 0)
-    {
-      sprintf (tmp, "cp -f %s %s", changed_files_fname, "/tmp/changed.files");
-      run_program_and_log_output(tmp, FALSE);
-      sprintf (tmp,
-           "%ld files differed from live filesystem; type less %s or less %s to see",
-           diffs, changed_files_fname, "/tmp/changed.files");
-      log_msg (0, tmp);
-      log_to_screen ("See /tmp/changed.files for a list of nonmatching files.");
-      log_to_screen ("The files probably changed on filesystem, not on backup media.");
-      //      retval++;
-    }
-  return (retval);
+    /*@ int ************************************************************ */
+    int retval = 0;
+
+    /*@ buffers ******************************************************** */
+    char *tmp;
+    char *changed_files_fname;
+
+    /*@ long *********************************************************** */
+    long diffs = 0;
+
+    assert(bkpinfo != NULL);
+
+    log_msg(3, "verify_tape_backups --- starting");
+    log_to_screen("Verifying backups");
+    openin_tape(bkpinfo);
+
+    /* verify archives themselves */
+    retval += verify_afioballs_from_stream(bkpinfo);
+    retval += verify_biggiefiles_from_stream(bkpinfo);
+
+    /* find the final blocks */
+    paranoid_system("sync");
+    sleep(2);
+    closein_tape(bkpinfo);
+
+    /* close tape; exit */
+    //  fclose(g_tape_stream); <-- not needed; is handled by closein_tape()
+    paranoid_system
+        ("rm -f /tmp/biggies.changed /tmp/changed.files.[0-9]* 2> /dev/null");
+    asprintf(&changed_files_fname, "/tmp/changed.files.%d",
+            (int) (random() % 32767));
+    asprintf(&tmp,
+            "cat %s | grep -x \"%s:.*\" | cut -d'\"' -f2 | sort -u | awk '{print \"/\"$0;};' | tr -s '/' '/' | grep -v \"(total of\" | grep -v \"incheckentry.*xwait\" | grep -vx \"/afio:.*\" | grep -vx \"dev/.*\"  > %s",
+            MONDO_LOGFILE, (bkpinfo->use_star) ? "star" : "afio",
+            changed_files_fname);
+    log_msg(2, "Running command to derive list of changed files");
+    log_msg(2, tmp);
+    if (system(tmp)) {
+        if (does_file_exist(changed_files_fname)
+            && length_of_file(changed_files_fname) > 2) {
+            log_to_screen
+                ("Warning - unable to check logfile to derive list of changed files");
+        } else {
+            log_to_screen
+                ("No differences found. Therefore, no 'changed.files' text file.");
+        }
+    }
+    paranoid_free(tmp);
+
+    asprintf(&tmp, "cat /tmp/biggies.changed >> %s", changed_files_fname);
+    paranoid_system(tmp);
+    paranoid_free(tmp);
+
+    diffs = count_lines_in_file(changed_files_fname);
+    if (diffs > 0) {
+        asprintf(&tmp, "cp -f %s %s", changed_files_fname,
+                "/tmp/changed.files");
+        run_program_and_log_output(tmp, FALSE);
+        paranoid_free(tmp);
+
+        asprintf(&tmp,
+                "%ld files differed from live filesystem; type less %s or less %s to see",
+                diffs, changed_files_fname, "/tmp/changed.files");
+        log_msg(0, tmp);
+        paranoid_free(tmp);
+
+        log_to_screen
+            ("See /tmp/changed.files for a list of nonmatching files.");
+        log_to_screen
+            ("The files probably changed on filesystem, not on backup media.");
+        //      retval++;
+    }
+    paranoid_free(changed_files_fname);
+    return (retval);
 }
-
 
 
@@ -1181 +1129 @@
  * @ingroup stringGroup
  */
-char *
-vfy_tball_fname (struct s_bkpinfo *bkpinfo, char *mountpoint, int setno)
+char *vfy_tball_fname(struct s_bkpinfo *bkpinfo, char *mountpoint,
+                      int setno)
 {
-    /*@ buffers ********************************************************/
-  static char output[MAX_STR_LEN];
-
-  assert(bkpinfo!=NULL);
-  assert_string_is_neither_NULL_nor_zerolength(mountpoint);
-  sprintf (output, "%s/archives/%d.star.%s", mountpoint, setno,
-       bkpinfo->zip_suffix);
-  if (!does_file_exist(output))
-    {
-      sprintf (output, "%s/archives/%d.afio.%s", mountpoint, setno,
-       bkpinfo->zip_suffix);
-    }
-  return (output);
+    /*@ buffers ******************************************************* */
+    static char *output;
+
+    assert(bkpinfo != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
+    asprintf(&output, "%s/archives/%d.star.%s", mountpoint, setno,
+            bkpinfo->zip_suffix);
+    if (!does_file_exist(output)) {
+        paranoid_free(output);
+        asprintf(&output, "%s/archives/%d.afio.%s", mountpoint, setno,
+                bkpinfo->zip_suffix);
+    }
+    return (output);
 }