X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fsparse.c;h=ecbbe108842bbd27366b3d16a470fc4e047a474e;hb=040b5ab5f969f9ee6c69a54bc284e2ff57b86556;hp=d4816f80ca758810c285dd5e9ba4b291808aeb33;hpb=2bda83b48d8a6807632312403561b11b79048443;p=chaz%2Ftar

diff --git a/src/sparse.c b/src/sparse.c
index d4816f8..ecbbe10 100644
--- a/src/sparse.c
+++ b/src/sparse.c
@@ -1,6 +1,6 @@
 /* Functions for dealing with sparse files
 
-   Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
 
    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
@@ -14,9 +14,10 @@
 
    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
-   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
 
-#include "system.h"
+#include <system.h>
+#include <inttostr.h>
 #include <quotearg.h>
 #include "common.h"
 
@@ -46,14 +47,50 @@ struct tar_sparse_optab
 struct tar_sparse_file
 {
   int fd;                           /* File descriptor */
-  size_t dumped_size;               /* Number of bytes actually written
+  bool seekable;                    /* Is fd seekable? */
+  off_t offset;                     /* Current offset in fd if seekable==false.
+				       Otherwise unused */
+  off_t dumped_size;                /* Number of bytes actually written
 				       to the archive */
   struct tar_stat_info *stat_info;  /* Information about the file */
-  struct tar_sparse_optab *optab;
+  struct tar_sparse_optab const *optab;
   void *closure;                    /* Any additional data optab calls might
-				       reqiure */
+				       require */
 };
 
+/* Dump zeros to file->fd until offset is reached. It is used instead of
+   lseek if the output file is not seekable */
+static bool
+dump_zeros (struct tar_sparse_file *file, off_t offset)
+{
+  static char const zero_buf[BLOCKSIZE];
+
+  if (offset < file->offset)
+    {
+      errno = EINVAL;
+      return false;
+    }
+
+  while (file->offset < offset)
+    {
+      size_t size = (BLOCKSIZE < offset - file->offset
+		     ? BLOCKSIZE
+		     : offset - file->offset);
+      ssize_t wrbytes;
+
+      wrbytes = write (file->fd, zero_buf, size);
+      if (wrbytes <= 0)
+	{
+	  if (wrbytes == 0)
+	    errno = EINVAL;
+	  return false;
+	}
+      file->offset += wrbytes;
+    }
+
+  return true;
+}
+
 static bool
 tar_sparse_member_p (struct tar_sparse_file *file)
 {
@@ -65,7 +102,6 @@ tar_sparse_member_p (struct tar_sparse_file *file)
 static bool
 tar_sparse_init (struct tar_sparse_file *file)
 {
-  file->dumped_size = 0;
   if (file->optab->init)
     return file->optab->init (file);
   return true;
@@ -130,9 +166,11 @@ tar_sparse_fixup_header (struct tar_sparse_file *file)
 
 
 static bool
-lseek_or_error (struct tar_sparse_file *file, off_t offset, int whence)
+lseek_or_error (struct tar_sparse_file *file, off_t offset)
 {
-  if (lseek (file->fd, offset, whence) < 0)
+  if (file->seekable
+      ? lseek (file->fd, offset, SEEK_SET) < 0
+      : ! dump_zeros (file, offset))
     {
       seek_diag_details (file->stat_info->orig_file_name, offset);
       return false;
@@ -144,7 +182,7 @@ lseek_or_error (struct tar_sparse_file *file, off_t offset, int whence)
    it's made *entirely* of zeros, returning a 0 the instant it finds
    something that is a nonzero, i.e., useful data.  */
 static bool
-zero_block_p (char *buffer, size_t size)
+zero_block_p (char const *buffer, size_t size)
 {
   while (size--)
     if (*buffer++)
@@ -152,58 +190,44 @@ zero_block_p (char *buffer, size_t size)
   return true;
 }
 
-#define clear_block(p) memset (p, 0, BLOCKSIZE);
-
-#define SPARSES_INIT_COUNT SPARSES_IN_SPARSE_HEADER
-
 static void
-sparse_add_map (struct tar_sparse_file *file, struct sp_array *sp)
+sparse_add_map (struct tar_stat_info *st, struct sp_array const *sp)
 {
-  if (file->stat_info->sparse_map == NULL)
-    {
-      file->stat_info->sparse_map =
-	xmalloc (SPARSES_INIT_COUNT * sizeof file->stat_info->sparse_map[0]);
-      file->stat_info->sparse_map_size = SPARSES_INIT_COUNT;
-    }
-  else if (file->stat_info->sparse_map_avail == file->stat_info->sparse_map_size)
-    {
-      file->stat_info->sparse_map_size *= 2;
-      file->stat_info->sparse_map =
-	xrealloc (file->stat_info->sparse_map,
-		  file->stat_info->sparse_map_size
-		  * sizeof file->stat_info->sparse_map[0]);
-    }
-  file->stat_info->sparse_map[file->stat_info->sparse_map_avail++] = *sp;
+  struct sp_array *sparse_map = st->sparse_map;
+  size_t avail = st->sparse_map_avail;
+  if (avail == st->sparse_map_size)
+    st->sparse_map = sparse_map =
+      x2nrealloc (sparse_map, &st->sparse_map_size, sizeof *sparse_map);
+  sparse_map[avail] = *sp;
+  st->sparse_map_avail = avail + 1;
 }
 
 /* Scan the sparse file and create its map */
 static bool
 sparse_scan_file (struct tar_sparse_file *file)
 {
-  static char buffer[BLOCKSIZE];
+  struct tar_stat_info *st = file->stat_info;
+  int fd = file->fd;
+  char buffer[BLOCKSIZE];
   size_t count;
-  size_t offset = 0;
+  off_t offset = 0;
   struct sp_array sp = {0, 0};
 
-  if (!lseek_or_error (file, 0, SEEK_SET))
+  if (!lseek_or_error (file, 0))
     return false;
-  clear_block (buffer);
-
-  file->stat_info->sparse_map_size = 0;
-  file->stat_info->archive_file_size = 0;
 
   if (!tar_sparse_scan (file, scan_begin, NULL))
     return false;
 
-  while ((count = safe_read (file->fd, buffer, sizeof buffer)) != 0
+  while ((count = safe_read (fd, buffer, sizeof buffer)) != 0
 	 && count != SAFE_READ_ERROR)
     {
-      /* Analize the block */
+      /* Analyze the block.  */
       if (zero_block_p (buffer, count))
 	{
 	  if (sp.numbytes)
 	    {
-	      sparse_add_map (file, &sp);
+	      sparse_add_map (st, &sp);
 	      sp.numbytes = 0;
 	      if (!tar_sparse_scan (file, scan_block, NULL))
 		return false;
@@ -214,26 +238,25 @@ sparse_scan_file (struct tar_sparse_file *file)
 	  if (sp.numbytes == 0)
 	    sp.offset = offset;
 	  sp.numbytes += count;
-	  file->stat_info->archive_file_size += count;
+	  st->archive_file_size += count;
 	  if (!tar_sparse_scan (file, scan_block, buffer))
 	    return false;
 	}
 
       offset += count;
-      clear_block (buffer);
     }
 
   if (sp.numbytes == 0)
     sp.offset = offset;
 
-  sparse_add_map (file, &sp);
-  file->stat_info->archive_file_size += count;
+  sparse_add_map (st, &sp);
+  st->archive_file_size += count;
   return tar_sparse_scan (file, scan_end, NULL);
 }
 
-static struct tar_sparse_optab oldgnu_optab;
-static struct tar_sparse_optab star_optab;
-static struct tar_sparse_optab pax_optab;
+static struct tar_sparse_optab const oldgnu_optab;
+static struct tar_sparse_optab const star_optab;
+static struct tar_sparse_optab const pax_optab;
 
 static bool
 sparse_select_optab (struct tar_sparse_file *file)
@@ -269,8 +292,7 @@ sparse_dump_region (struct tar_sparse_file *file, size_t i)
   union block *blk;
   off_t bytes_left = file->stat_info->sparse_map[i].numbytes;
 
-  if (!lseek_or_error (file, file->stat_info->sparse_map[i].offset,
-		       SEEK_SET))
+  if (!lseek_or_error (file, file->stat_info->sparse_map[i].offset))
     return false;
 
   while (bytes_left > 0)
@@ -279,18 +301,18 @@ sparse_dump_region (struct tar_sparse_file *file, size_t i)
       size_t bytes_read;
 
       blk = find_next_block ();
-      memset (blk->buffer, 0, BLOCKSIZE);
       bytes_read = safe_read (file->fd, blk->buffer, bufsize);
       if (bytes_read == SAFE_READ_ERROR)
 	{
           read_diag_details (file->stat_info->orig_file_name,
-	                     file->stat_info->sparse_map[i].offset
-	                         + file->stat_info->sparse_map[i].numbytes
-	                         - bytes_left,
-	             bufsize);
+	                     (file->stat_info->sparse_map[i].offset
+			      + file->stat_info->sparse_map[i].numbytes
+			      - bytes_left),
+			     bufsize);
 	  return false;
 	}
 
+      memset (blk->buffer + bytes_read, 0, BLOCKSIZE - bytes_read);
       bytes_left -= bytes_read;
       file->dumped_size += bytes_read;
       set_next_block_after (blk);
@@ -304,8 +326,7 @@ sparse_extract_region (struct tar_sparse_file *file, size_t i)
 {
   size_t write_size;
 
-  if (!lseek_or_error (file, file->stat_info->sparse_map[i].offset,
-		       SEEK_SET))
+  if (!lseek_or_error (file, file->stat_info->sparse_map[i].offset))
     return false;
 
   write_size = file->stat_info->sparse_map[i].numbytes;
@@ -313,7 +334,7 @@ sparse_extract_region (struct tar_sparse_file *file, size_t i)
   if (write_size == 0)
     {
       /* Last block of the file is a hole */
-      if (sys_truncate (file->fd))
+      if (file->seekable && sys_truncate (file->fd))
 	truncate_warn (file->stat_info->orig_file_name);
     }
   else while (write_size > 0)
@@ -330,6 +351,7 @@ sparse_extract_region (struct tar_sparse_file *file, size_t i)
       count = full_write (file->fd, blk->buffer, wrbytes);
       write_size -= count;
       file->dumped_size += count;
+      file->offset += count;
       if (count != wrbytes)
 	{
 	  write_error_details (file->stat_info->orig_file_name,
@@ -347,10 +369,11 @@ enum dump_status
 sparse_dump_file (int fd, struct tar_stat_info *st)
 {
   bool rc;
-  struct tar_sparse_file file;
+  struct tar_sparse_file file = { 0, };
 
   file.stat_info = st;
   file.fd = fd;
+  file.seekable = true; /* File *must* be seekable for dump to work */
 
   if (!sparse_select_optab (&file)
       || !tar_sparse_init (&file))
@@ -370,7 +393,7 @@ sparse_dump_file (int fd, struct tar_stat_info *st)
 	}
     }
 
-  pad_archive(file.stat_info->archive_file_size - file.dumped_size);
+  pad_archive (file.stat_info->archive_file_size - file.dumped_size);
   return (tar_sparse_done (&file) && rc) ? dump_status_ok : dump_status_short;
 }
 
@@ -414,6 +437,8 @@ sparse_extract_file (int fd, struct tar_stat_info *st, off_t *size)
 
   file.stat_info = st;
   file.fd = fd;
+  file.seekable = lseek (fd, 0, SEEK_SET) == 0;
+  file.offset = 0;
 
   if (!sparse_select_optab (&file)
       || !tar_sparse_init (&file))
@@ -445,22 +470,18 @@ sparse_skip_file (struct tar_stat_info *st)
 }
 
 
-static char diff_buffer[BLOCKSIZE];
-
 static bool
 check_sparse_region (struct tar_sparse_file *file, off_t beg, off_t end)
 {
-  if (!lseek_or_error (file, beg, SEEK_SET))
+  if (!lseek_or_error (file, beg))
     return false;
 
   while (beg < end)
     {
       size_t bytes_read;
-      size_t rdsize = end - beg;
+      size_t rdsize = BLOCKSIZE < end - beg ? BLOCKSIZE : end - beg;
+      char diff_buffer[BLOCKSIZE];
 
-      if (rdsize > BLOCKSIZE)
-	rdsize = BLOCKSIZE;
-      clear_block (diff_buffer);
       bytes_read = safe_read (file->fd, diff_buffer, rdsize);
       if (bytes_read == SAFE_READ_ERROR)
 	{
@@ -471,8 +492,10 @@ check_sparse_region (struct tar_sparse_file *file, off_t beg, off_t end)
 	}
       if (!zero_block_p (diff_buffer, bytes_read))
 	{
+	  char begbuf[INT_BUFSIZE_BOUND (off_t)];
  	  report_difference (file->stat_info,
-			     _("File fragment at %lu is not a hole"), beg);
+			     _("File fragment at %s is not a hole"),
+			     offtostr (beg, begbuf));
 	  return false;
 	}
 
@@ -486,14 +509,14 @@ check_data_region (struct tar_sparse_file *file, size_t i)
 {
   size_t size_left;
 
-  if (!lseek_or_error (file, file->stat_info->sparse_map[i].offset,
-		       SEEK_SET))
+  if (!lseek_or_error (file, file->stat_info->sparse_map[i].offset))
     return false;
   size_left = file->stat_info->sparse_map[i].numbytes;
   while (size_left > 0)
     {
       size_t bytes_read;
       size_t rdsize = (size_left > BLOCKSIZE) ? BLOCKSIZE : size_left;
+      char diff_buffer[BLOCKSIZE];
 
       union block *blk = find_next_block ();
       if (!blk)
@@ -506,9 +529,9 @@ check_data_region (struct tar_sparse_file *file, size_t i)
       if (bytes_read == SAFE_READ_ERROR)
 	{
           read_diag_details (file->stat_info->orig_file_name,
-			     file->stat_info->sparse_map[i].offset
-	                         + file->stat_info->sparse_map[i].numbytes
-			         - size_left,
+			     (file->stat_info->sparse_map[i].offset
+			      + file->stat_info->sparse_map[i].numbytes
+			      - size_left),
 			     rdsize);
 	  return false;
 	}
@@ -602,7 +625,7 @@ oldgnu_add_sparse (struct tar_sparse_file *file, struct sparse *s)
       || file->stat_info->archive_file_size < 0)
     return add_fail;
 
-  sparse_add_map (file, &sp);
+  sparse_add_map (file->stat_info, &sp);
   return add_ok;
 }
 
@@ -613,7 +636,7 @@ oldgnu_fixup_header (struct tar_sparse_file *file)
      which actually contains archived size. The following fixes it */
   file->stat_info->archive_file_size = file->stat_info->stat.st_size;
   file->stat_info->stat.st_size =
-                OFF_FROM_HEADER (current_header->oldgnu_header.realsize);
+    OFF_FROM_HEADER (current_header->oldgnu_header.realsize);
   return true;
 }
 
@@ -624,9 +647,9 @@ oldgnu_get_sparse_info (struct tar_sparse_file *file)
   size_t i;
   union block *h = current_header;
   int ext_p;
-  static enum oldgnu_add_status rc;
+  enum oldgnu_add_status rc;
 
-  file->stat_info->sparse_map_size = 0;
+  file->stat_info->sparse_map_avail = 0;
   for (i = 0; i < SPARSES_IN_OLDGNU_HEADER; i++)
     {
       rc = oldgnu_add_sparse (file, &h->oldgnu_header.sp[i]);
@@ -711,7 +734,7 @@ oldgnu_dump_header (struct tar_sparse_file *file)
   return true;
 }
 
-static struct tar_sparse_optab oldgnu_optab = {
+static struct tar_sparse_optab const oldgnu_optab = {
   NULL,  /* No init function */
   NULL,  /* No done function */
   oldgnu_sparse_member_p,
@@ -750,9 +773,9 @@ star_get_sparse_info (struct tar_sparse_file *file)
   size_t i;
   union block *h = current_header;
   int ext_p;
-  static enum oldgnu_add_status rc;
+  enum oldgnu_add_status rc = add_ok;
 
-  file->stat_info->sparse_map_size = 0;
+  file->stat_info->sparse_map_avail = 0;
 
   if (h->star_in_header.prefix[0] == '\0'
       && h->star_in_header.sp[0].offset[10] != '\0')
@@ -792,7 +815,7 @@ star_get_sparse_info (struct tar_sparse_file *file)
 }
 
 
-static struct tar_sparse_optab star_optab = {
+static struct tar_sparse_optab const star_optab = {
   NULL,  /* No init function */
   NULL,  /* No done function */
   star_sparse_member_p,
@@ -845,7 +868,7 @@ pax_dump_header (struct tar_sparse_file *file)
   return true;
 }
 
-static struct tar_sparse_optab pax_optab = {
+static struct tar_sparse_optab const pax_optab = {
   NULL,  /* No init function */
   NULL,  /* No done function */
   pax_sparse_member_p,
@@ -856,4 +879,3 @@ static struct tar_sparse_optab pax_optab = {
   sparse_dump_region,
   sparse_extract_region,
 };
-