Fix zstd reader and change variable scopes

diff --git a/libarchive/archive_read_support_filter_zstd.c b/libarchive/archive_read_support_filter_zstd.c
index dc9ceee350c0dd8115e9821788813c83cdb1742b..ea12206fea808e0daa867483b3c564559aca69bb 100644 (file)
--- a/libarchive/archive_read_support_filter_zstd.c
+++ b/libarchive/archive_read_support_filter_zstd.c
@@ -60,9 +60,8 @@ struct private_data {
        unsigned char   *out_block;
        size_t           out_block_size;
        int64_t          total_out;
-       char             endFrame; /* True = not in the middle of a zstd frame. */
+       char             in_frame; /* True = in the middle of a zstd frame. */
        char             eof; /* True = found end of compressed data. */
-       char             in_stream;
 };
 
 /* Zstd Filter. */
@@ -200,9 +199,8 @@ zstd_bidder_init(struct archive_read_filter *self)
        self->skip = NULL; /* not supported */
        self->close = zstd_filter_close;
 
-       state->in_stream = 0; /* We're not actually within a stream yet. */
        state->eof = 0;
-       state->endFrame = 1; /* We could end now without corruption */
+       state->in_frame = 0;
 
        return (ARCHIVE_OK);
 }
@@ -213,7 +211,6 @@ zstd_filter_read(struct archive_read_filter *self, const void **p)
        struct private_data *state;
        size_t decompressed;
        ssize_t avail_in;
-       size_t ret;
        ZSTD_outBuffer out;
        ZSTD_inBuffer in;
 
@@ -223,8 +220,8 @@ zstd_filter_read(struct archive_read_filter *self, const void **p)
 
        /* Try to fill the output buffer. */
        while (out.pos < out.size && !state->eof) {
-               if (!state->in_stream) {
-                       ret = ZSTD_initDStream(state->dstream);
+               if (!state->in_frame) {
+                       const size_t ret = ZSTD_initDStream(state->dstream);
                        if (ZSTD_isError(ret)) {
                                free(state->out_block);
                                free(state);
@@ -234,7 +231,6 @@ zstd_filter_read(struct archive_read_filter *self, const void **p)
                                    ZSTD_getErrorName(ret));
                                return (ARCHIVE_FATAL);
                        }
-                       state->in_stream = 1;
                }
                in.src = __archive_read_filter_ahead(self->upstream, 1,
                    &avail_in);
@@ -242,7 +238,7 @@ zstd_filter_read(struct archive_read_filter *self, const void **p)
                        return avail_in;
                }
                if (in.src == NULL && avail_in == 0) {
-                       if (state->endFrame) {
+                       if (!state->in_frame) {
                                /* end of stream */
                                state->eof = 1;
                                break;
@@ -256,22 +252,24 @@ zstd_filter_read(struct archive_read_filter *self, const void **p)
                in.size = avail_in;
                in.pos = 0;
 
-               ret = ZSTD_decompressStream(state->dstream, &out, &in);
+               {
+                       const size_t ret =
+                           ZSTD_decompressStream(state->dstream, &out, &in);
 
-               if (ZSTD_isError(ret)) {
-                       archive_set_error(&self->archive->archive,
-                           ARCHIVE_ERRNO_MISC,
-                           "Zstd decompression failed: %s",
-                           ZSTD_getErrorName(ret));
-                       return (ARCHIVE_FATAL);
-               }
+                       if (ZSTD_isError(ret)) {
+                               archive_set_error(&self->archive->archive,
+                                   ARCHIVE_ERRNO_MISC,
+                                   "Zstd decompression failed: %s",
+                                   ZSTD_getErrorName(ret));
+                               return (ARCHIVE_FATAL);
+                       }
 
-               /* Decompressor made some progress */
-               __archive_read_filter_consume(self->upstream, in.pos);
+                       /* Decompressor made some progress */
+                       __archive_read_filter_consume(self->upstream, in.pos);
 
-               /* Need to know if it's the end of the frame, as if input ends
-                * at any other time it's an error */
-               state->endFrame = (ret == 0);
+                       /* ret guaranteed to be > 0 if frame isn't done yet */
+                       state->in_frame = (ret != 0);
+               }
        }
 
        decompressed = out.pos;

diff --git a/libarchive/archive_write_add_filter_zstd.c b/libarchive/archive_write_add_filter_zstd.c
index c47b2de0754350d6f8f43de3322cbd7061d9014a..29ba6ccadfe90ef9279b140a9c807a8fb27413bf 100644 (file)
--- a/libarchive/archive_write_add_filter_zstd.c
+++ b/libarchive/archive_write_add_filter_zstd.c
@@ -255,13 +255,11 @@ static int
 drive_compressor(struct archive_write_filter *f,
     struct private_data *data, int finishing, const void *src, size_t length)
 {
-       int ret;
-       size_t zstdret;
        ZSTD_inBuffer in = (ZSTD_inBuffer) { src, length, 0 };
 
        for (;;) {
                if (data->out.pos == data->out.size) {
-                       ret = __archive_write_filter(f->next_filter,
+                       const int ret = __archive_write_filter(f->next_filter,
                            data->out.dst, data->out.size);
                        if (ret != ARCHIVE_OK)
                                return (ARCHIVE_FATAL);
@@ -272,26 +270,25 @@ drive_compressor(struct archive_write_filter *f,
                if (!finishing && in.pos == in.size)
                        return (ARCHIVE_OK);
 
-               if (!finishing) {
-                       zstdret = ZSTD_compressStream(data->cstream,
-                           &data->out, &in);
-               } else {
-                       zstdret = ZSTD_endStream(data->cstream,
-                           &data->out);
-               }
-
-               if (ZSTD_isError(zstdret)) {
-                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
-                           "Zstd compression failed: %s",
-                           ZSTD_getErrorName(zstdret));
-                       return (ARCHIVE_FATAL);
-               }
+               {
+                       const size_t zstdret = !finishing ?
+                           ZSTD_compressStream(data->cstream, &data->out, &in)
+                           : ZSTD_endStream(data->cstream, &data->out);
 
-               /* If we're finishing, 0 means nothing left to flush */
-               if (finishing && zstdret == 0) {
-                       ret = __archive_write_filter(f->next_filter,
-                           data->out.dst, data->out.pos);
-                       return (ret);
+                       if (ZSTD_isError(zstdret)) {
+                               archive_set_error(f->archive,
+                                   ARCHIVE_ERRNO_MISC,
+                                   "Zstd compression failed: %s",
+                                   ZSTD_getErrorName(zstdret));
+                               return (ARCHIVE_FATAL);
+                       }
+
+                       /* If we're finishing, 0 means nothing left to flush */
+                       if (finishing && zstdret == 0) {
+                               const int ret = __archive_write_filter(f->next_filter,
+                                   data->out.dst, data->out.pos);
+                               return (ret);
+                       }
                }
        }
 }