Switch users of archive_read_skip() over to archive_read_consume() now

that they both do the same thing.  Remove archive_read_consume().
Rename the core "advance_file_pointer" function to make it a little
more clear that it's internal to archive_read.c.
Clean up a few comments.

SVN-Revision: 2047

diff --git a/libarchive/archive_read.c b/libarchive/archive_read.c
index c6f1f0e0b4198292170ac84aa49103922c3d861c..4f30072ec2329282fc467099700209371f3e2505 100644 (file)
--- a/libarchive/archive_read.c
+++ b/libarchive/archive_read.c
@@ -65,7 +65,7 @@ static int    _archive_filter_code(struct archive *, int);
 static const char *_archive_filter_name(struct archive *, int);
 static int     _archive_read_close(struct archive *);
 static int     _archive_read_free(struct archive *);
-static int64_t  _archive_read_filter_skip(struct archive_read_filter *, int64_t);
+static int64_t  advance_file_pointer(struct archive_read_filter *, int64_t);
 
 static struct archive_vtable *
 archive_read_vtable(void)
@@ -1184,7 +1184,7 @@ __archive_read_filter_ahead(struct archive_read_filter *filter,
  * Move the file pointer forward.
  */
 int64_t
-__archive_read_consume(struct archive_read *a, size_t request)
+__archive_read_consume(struct archive_read *a, int64_t request)
 {
        return (__archive_read_filter_consume(a->filter, request));
 }
@@ -1193,7 +1193,7 @@ int64_t
 __archive_read_filter_consume(struct archive_read_filter * filter,
     int64_t request)
 {
-       int64_t skipped = _archive_read_filter_skip(filter, request);
+       int64_t skipped = advance_file_pointer(filter, request);
        if (skipped == request)
                return (skipped);
        /* We hit EOF before we satisfied the skip request. */
@@ -1207,20 +1207,14 @@ __archive_read_filter_consume(struct archive_read_filter * filter,
 }
 
 int64_t
-__archive_read_skip(struct archive_read *a, int64_t request)
-{
-       return (__archive_read_filter_consume(a->filter, request));
-}
-
-int64_t
-__archive_read_skip_all(struct archive_read *a)
+__archive_read_consume_all(struct archive_read *a)
 {
        int64_t total_bytes_skipped = 0;
        off_t bytes_skipped;
        int64_t request = 1024 * 1024 * 1024UL; /* Skip 1 GB at a time. */
 
        for (;;) {
-               bytes_skipped = _archive_read_filter_skip(a->filter, request);
+               bytes_skipped = advance_file_pointer(a->filter, request);
                if (bytes_skipped < 0)
                        return (ARCHIVE_FATAL);
                total_bytes_skipped += bytes_skipped;
@@ -1229,9 +1223,14 @@ __archive_read_skip_all(struct archive_read *a)
        }
 }
 
-
+/*
+ * Advance the file pointer by the amount requested.
+ * Returns the amount actually advanced, which may be less than the
+ * request if EOF is encountered first.
+ * Returns a negative value if there's an I/O error.
+ */
 static int64_t
-_archive_read_filter_skip(struct archive_read_filter *filter, int64_t request)
+advance_file_pointer(struct archive_read_filter *filter, int64_t request)
 {
        int64_t bytes_skipped, total_bytes_skipped = 0;
        ssize_t bytes_read;

diff --git a/libarchive/archive_read_private.h b/libarchive/archive_read_private.h
index 68873f06d1131d89156dc0c020d82946ab100104..7b0090972bab32bdb0dd895072b8f14c21b3e7bc 100644 (file)
--- a/libarchive/archive_read_private.h
+++ b/libarchive/archive_read_private.h
@@ -208,9 +208,8 @@ struct archive_read_filter_bidder
 const void *__archive_read_ahead(struct archive_read *, size_t, ssize_t *);
 const void *__archive_read_filter_ahead(struct archive_read_filter *,
     size_t, ssize_t *);
-int64_t        __archive_read_consume(struct archive_read *, size_t);
+int64_t        __archive_read_consume(struct archive_read *, int64_t);
 int64_t        __archive_read_filter_consume(struct archive_read_filter *, int64_t);
-int64_t        __archive_read_skip(struct archive_read *, int64_t);
-int64_t        __archive_read_skip_all(struct archive_read *);
+int64_t        __archive_read_consume_all(struct archive_read *);
 int __archive_read_program(struct archive_read_filter *, const char *);
 #endif

diff --git a/libarchive/archive_read_support_format_ar.c b/libarchive/archive_read_support_format_ar.c
index 94836706f593f39a648a0e85fae492f5e65a4ace..dcee9ba470c7fbea252b89667c66480c3f059587 100644 (file)
--- a/libarchive/archive_read_support_format_ar.c
+++ b/libarchive/archive_read_support_format_ar.c
@@ -499,7 +499,7 @@ archive_read_format_ar_skip(struct archive_read *a)
 
        ar = (struct ar *)(a->format->data);
 
-       bytes_skipped = __archive_read_skip(a,
+       bytes_skipped = __archive_read_consume(a,
            ar->entry_bytes_remaining + ar->entry_padding);
        if (bytes_skipped < 0)
                return (ARCHIVE_FATAL);

diff --git a/libarchive/archive_read_support_format_iso9660.c b/libarchive/archive_read_support_format_iso9660.c
index b667cf8794f3b3bd490f3772d00ebba2b365c983..9ba687af05fcf33f214b7a1037bdbc259b56e372 100644 (file)
--- a/libarchive/archive_read_support_format_iso9660.c
+++ b/libarchive/archive_read_support_format_iso9660.c
@@ -934,7 +934,7 @@ read_children(struct archive_read *a, struct file_info *parent)
                int64_t skipsize;
 
                skipsize = parent->offset - iso9660->current_position;
-               skipsize = __archive_read_skip(a, skipsize);
+               skipsize = __archive_read_consume(a, skipsize);
                if (skipsize < 0)
                        return ((int)skipsize);
                iso9660->current_position = parent->offset;
@@ -1141,7 +1141,7 @@ archive_read_format_iso9660_read_header(struct archive_read *a,
                        vd = &(iso9660->joliet);
 
                skipsize = LOGICAL_BLOCK_SIZE * vd->location;
-               skipsize = __archive_read_skip(a, skipsize);
+               skipsize = __archive_read_consume(a, skipsize);
                if (skipsize < 0)
                        return ((int)skipsize);
                iso9660->current_position = skipsize;
@@ -1179,7 +1179,7 @@ archive_read_format_iso9660_read_header(struct archive_read *a,
                        vd = &(iso9660->joliet);
                        skipsize = LOGICAL_BLOCK_SIZE * vd->location;
                        skipsize -= iso9660->current_position;
-                       skipsize = __archive_read_skip(a, skipsize);
+                       skipsize = __archive_read_consume(a, skipsize);
                        if (skipsize < 0)
                                return ((int)skipsize);
                        iso9660->current_position += skipsize;
@@ -1617,7 +1617,7 @@ archive_read_format_iso9660_read_data(struct archive_read *a,
 
                        step = iso9660->entry_content->offset -
                            iso9660->current_position;
-                       step = __archive_read_skip(a, step);
+                       step = __archive_read_consume(a, step);
                        if (step < 0)
                                return ((int)step);
                        iso9660->current_position =
@@ -2516,7 +2516,7 @@ next_entry_seek(struct archive_read *a, struct iso9660 *iso9660,
                int64_t step;
 
                step = file->offset - iso9660->current_position;
-               step = __archive_read_skip(a, step);
+               step = __archive_read_consume(a, step);
                if (step < 0)
                        return ((int)step);
                iso9660->current_position = file->offset;

diff --git a/libarchive/archive_read_support_format_raw.c b/libarchive/archive_read_support_format_raw.c
index fafb5bfe6de4795264934e39bbbc8feb01ae8642..bf4c0055bdac2ae53cf63c86bd5f4026a87a55f7 100644 (file)
--- a/libarchive/archive_read_support_format_raw.c
+++ b/libarchive/archive_read_support_format_raw.c
@@ -175,7 +175,7 @@ archive_read_format_raw_read_data_skip(struct archive_read *a)
        if (info->end_of_file)
                return (ARCHIVE_EOF);
        info->end_of_file = 1;
-       skipped = __archive_read_skip_all(a);
+       skipped = __archive_read_consume_all(a);
        if (skipped < 0)
                return ((int)skipped);
        return (ARCHIVE_OK);

diff --git a/libarchive/archive_read_support_format_tar.c b/libarchive/archive_read_support_format_tar.c
index b96ac72432aece68642b7eb5258028f498bf182b..157a7fd4e40cdfbc33b65629c5bd41e577ed9573 100644 (file)
--- a/libarchive/archive_read_support_format_tar.c
+++ b/libarchive/archive_read_support_format_tar.c
@@ -480,7 +480,7 @@ archive_read_format_tar_read_data(struct archive_read *a,
 
        /* If we're at end of file, return EOF. */
        if (tar->sparse_list == NULL || tar->entry_bytes_remaining == 0) {
-               if (__archive_read_skip(a, tar->entry_padding) < 0)
+               if (__archive_read_consume(a, tar->entry_padding) < 0)
                        return (ARCHIVE_FATAL);
                tar->entry_padding = 0;
                *buff = NULL;
@@ -520,12 +520,7 @@ archive_read_format_tar_skip(struct archive_read *a)
 
        tar = (struct tar *)(a->format->data);
 
-       /*
-        * Compression layer skip functions are required to either skip the
-        * length requested or fail, so we can rely upon the entire entry
-        * plus padding being skipped.
-        */
-       bytes_skipped = __archive_read_skip(a,
+       bytes_skipped = __archive_read_consume(a,
            tar->entry_bytes_remaining + tar->entry_padding);
        if (bytes_skipped < 0)
                return (ARCHIVE_FATAL);
@@ -2000,7 +1995,7 @@ gnu_sparse_10_read(struct archive_read *a, struct tar *tar)
        /* Skip rest of block... */
        bytes_read = tar->entry_bytes_remaining - remaining;
        to_skip = 0x1ff & -bytes_read;
-       if (to_skip != __archive_read_skip(a, to_skip))
+       if (to_skip != __archive_read_consume(a, to_skip))
                return (ARCHIVE_FATAL);
        return (bytes_read + to_skip);
 }

diff --git a/libarchive/archive_read_support_format_xar.c b/libarchive/archive_read_support_format_xar.c
index 02c3b53a3b2f656778e55c82aed083b6165c9ba4..669517d9f024d0fd4dbbb79463cf584fe1744fe1 100644 (file)
--- a/libarchive/archive_read_support_format_xar.c
+++ b/libarchive/archive_read_support_format_xar.c
@@ -834,7 +834,7 @@ xar_read_data_skip(struct archive_read *a)
        xar = (struct xar *)(a->format->data);
        if (xar->end_of_file)
                return (ARCHIVE_EOF);
-       bytes_skipped = __archive_read_skip(a, xar->entry_remaining);
+       bytes_skipped = __archive_read_consume(a, xar->entry_remaining);
        if (bytes_skipped < 0)
                return (ARCHIVE_FATAL);
        xar->offset += bytes_skipped;
@@ -885,7 +885,7 @@ move_reading_point(struct archive_read *a, uint64_t offset)
 
                step = offset - (xar->offset - xar->h_base);
                if (step > 0) {
-                       step = __archive_read_skip(a, step);
+                       step = __archive_read_consume(a, step);
                        if (step < 0)
                                return ((int)step);
                        xar->offset += step;

diff --git a/libarchive/archive_read_support_format_zip.c b/libarchive/archive_read_support_format_zip.c
index 49288ac075fd816b181c2cda6ccb8d2d8ed8fc19..a29407627f512aa17ef412234dd1bc3e13ceea02 100644 (file)
--- a/libarchive/archive_read_support_format_zip.c
+++ b/libarchive/archive_read_support_format_zip.c
@@ -825,7 +825,7 @@ archive_read_format_zip_read_data_skip(struct archive_read *a)
         * If the length is at the beginning, we can skip the
         * compressed data much more quickly.
         */
-       bytes_skipped = __archive_read_skip(a, zip->entry_bytes_remaining);
+       bytes_skipped = __archive_read_consume(a, zip->entry_bytes_remaining);
        if (bytes_skipped < 0)
                return (ARCHIVE_FATAL);