Fix build failure with zlib on Win64.

diff --git a/libarchive/archive_read_support_filter_gzip.c b/libarchive/archive_read_support_filter_gzip.c
index a2b399781d1c509d3b3d884e84a57a4a6c306de2..475cc1737dd2cb356995265b5ffc693bd5807e35 100644 (file)
--- a/libarchive/archive_read_support_filter_gzip.c
+++ b/libarchive/archive_read_support_filter_gzip.c
@@ -299,7 +299,7 @@ consume_header(struct archive_read_filter *self)
        /* Initialize compression library. */
        state->stream.next_in = (unsigned char *)(uintptr_t)
            __archive_read_filter_ahead(self->upstream, 1, &avail);
-       state->stream.avail_in = avail;
+       state->stream.avail_in = (uInt)avail;
        ret = inflateInit2(&(state->stream),
            -15 /* Don't check for zlib header */);
 
@@ -380,7 +380,7 @@ gzip_filter_read(struct archive_read_filter *self, const void **p)
 
        /* Empty our output buffer. */
        state->stream.next_out = state->out_block;
-       state->stream.avail_out = state->out_block_size;
+       state->stream.avail_out = (uInt)state->out_block_size;
 
        /* Try to fill the output buffer. */
        while (state->stream.avail_out > 0 && !state->eof) {
@@ -407,7 +407,7 @@ gzip_filter_read(struct archive_read_filter *self, const void **p)
                            "truncated gzip input");
                        return (ARCHIVE_FATAL);
                }
-               state->stream.avail_in = avail_in;
+               state->stream.avail_in = (uInt)avail_in;
 
                /* Decompress and consume some of that data. */
                ret = inflate(&(state->stream), 0);

diff --git a/libarchive/archive_read_support_format_7zip.c b/libarchive/archive_read_support_format_7zip.c
index 9e29d74fb49aa3d2fadf74ebe4533b421f490d29..6a0a29d351e21a927fa5e2cf48d1ff503bbf3f6b 100644 (file)
--- a/libarchive/archive_read_support_format_7zip.c
+++ b/libarchive/archive_read_support_format_7zip.c
@@ -736,7 +736,7 @@ archive_read_format_7zip_read_data(struct archive_read *a,
 
        /* Update checksum */
        if ((zip->entry->flg & CRC32_IS_SET) && bytes)
-               zip->entry_crc32 = crc32(zip->entry_crc32, *buff, bytes);
+               zip->entry_crc32 = crc32(zip->entry_crc32, *buff, (uInt)bytes);
 
        /* If we hit the end, swallow any end-of-data marker. */
        if (zip->end_of_entry) {
@@ -1363,9 +1363,9 @@ decompress(struct archive_read *a, struct _7zip *zip,
 #ifdef HAVE_ZLIB_H
        case _7Z_DEFLATE:
                zip->stream.next_in = (Bytef *)(uintptr_t)t_next_in;
-               zip->stream.avail_in = t_avail_in;
+               zip->stream.avail_in = (uInt)t_avail_in;
                zip->stream.next_out = t_next_out;
-               zip->stream.avail_out = t_avail_out;
+               zip->stream.avail_out = (uInt)t_avail_out;
                r = inflate(&(zip->stream), 0);
                switch (r) {
                case Z_STREAM_END: /* Found end of stream. */
@@ -2688,7 +2688,7 @@ header_bytes(struct archive_read *a, size_t rbytes)
        }
 
        /* Update checksum */
-       zip->header_crc32 = crc32(zip->header_crc32, p, rbytes);
+       zip->header_crc32 = crc32(zip->header_crc32, p, (uInt)rbytes);
        return (p);
 }
 

diff --git a/libarchive/archive_read_support_format_cab.c b/libarchive/archive_read_support_format_cab.c
index 20bbc5db1d76d05d49dab7e37b7388e3c7123bff..3c9f94ca6ba3b18050fef490b2b167ce4b58cc38 100644 (file)
--- a/libarchive/archive_read_support_format_cab.c
+++ b/libarchive/archive_read_support_format_cab.c
@@ -1487,7 +1487,7 @@ cab_read_ahead_cfdata_deflate(struct archive_read *a, ssize_t *avail)
                 * cast to remove 'const'.
                 */
                cab->stream.next_in = (Bytef *)(uintptr_t)d;
-               cab->stream.avail_in = bytes_avail;
+               cab->stream.avail_in = (uInt)bytes_avail;
                cab->stream.total_in = 0;
 
                /* Cut out a tow-byte MSZIP signature(0x43, 0x4b). */
@@ -1508,7 +1508,7 @@ cab_read_ahead_cfdata_deflate(struct archive_read *a, ssize_t *avail)
                                        *avail = ARCHIVE_FATAL;
                                        return (NULL);
                                }
-                               mszip -= bytes_avail;
+                               mszip -= (int)bytes_avail;
                                continue;
                        }
                        if (mszip == 1 && cab->stream.next_in[0] != 0x4b)

diff --git a/libarchive/archive_read_support_format_iso9660.c b/libarchive/archive_read_support_format_iso9660.c
index 5719cebead84bd0d9bae447b05e3ad10571eb4aa..914bc71dfed546710f9d512abd8ec2b0986a05d2 100644 (file)
--- a/libarchive/archive_read_support_format_iso9660.c
+++ b/libarchive/archive_read_support_format_iso9660.c
@@ -1446,7 +1446,7 @@ zisofs_read_data(struct archive_read *a,
                zisofs->block_pointers_size = xsize;
 
                /* Allocate uncompressed data buffer. */
-               xsize = 1UL << zisofs->pz_log2_bs;
+               xsize = (size_t)1UL << zisofs->pz_log2_bs;
                if (zisofs->uncompressed_buffer_size < xsize) {
                        if (zisofs->uncompressed_buffer != NULL)
                                free(zisofs->uncompressed_buffer);
@@ -1583,9 +1583,10 @@ zisofs_read_data(struct archive_read *a,
                if (avail > zisofs->block_avail)
                        zisofs->stream.avail_in = zisofs->block_avail;
                else
-                       zisofs->stream.avail_in = avail;
+                       zisofs->stream.avail_in = (uInt)avail;
                zisofs->stream.next_out = zisofs->uncompressed_buffer;
-               zisofs->stream.avail_out = zisofs->uncompressed_buffer_size;
+               zisofs->stream.avail_out =
+                   (uInt)zisofs->uncompressed_buffer_size;
 
                r = inflate(&zisofs->stream, 0);
                switch (r) {
@@ -1600,7 +1601,7 @@ zisofs_read_data(struct archive_read *a,
                uncompressed_size =
                    zisofs->uncompressed_buffer_size - zisofs->stream.avail_out;
                avail -= zisofs->stream.next_in - p;
-               zisofs->block_avail -= zisofs->stream.next_in - p;
+               zisofs->block_avail -= (uint32_t)(zisofs->stream.next_in - p);
        }
 next_data:
        bytes_read -= avail;
@@ -1610,7 +1611,7 @@ next_data:
        iso9660->entry_sparse_offset += uncompressed_size;
        iso9660->entry_bytes_remaining -= bytes_read;
        iso9660->current_position += bytes_read;
-       zisofs->pz_offset += bytes_read;
+       zisofs->pz_offset += (uint32_t)bytes_read;
        iso9660->entry_bytes_unconsumed += bytes_read;
 
        return (ARCHIVE_OK);

diff --git a/libarchive/archive_read_support_format_rar.c b/libarchive/archive_read_support_format_rar.c
index 98b998bb19523d764007800838baec372cf8e917..888949890bdc211c1bb404daabad96d0c4f791d0 100644 (file)
--- a/libarchive/archive_read_support_format_rar.c
+++ b/libarchive/archive_read_support_format_rar.c
@@ -862,7 +862,7 @@ archive_read_format_rar_read_header(struct archive_read *a,
         return (ARCHIVE_FATAL);
       }
 
-      crc32_val = crc32(0, (const unsigned char *)p + 2, skip - 2);
+      crc32_val = crc32(0, (const unsigned char *)p + 2, (uInt)skip - 2);
       if ((crc32_val & 0xffff) != archive_le16dec(p)) {
         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
           "Header CRC error");
@@ -905,7 +905,7 @@ archive_read_format_rar_read_header(struct archive_read *a,
         p = h;
       }
 
-      crc32_val = crc32(0, (const unsigned char *)p + 2, skip - 2);
+      crc32_val = crc32(0, (const unsigned char *)p + 2, (uInt)skip - 2);
       if ((crc32_val & 0xffff) != archive_le16dec(p)) {
         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
           "Header CRC error");
@@ -1701,7 +1701,7 @@ read_data_stored(struct archive_read *a, const void **buff, size_t *size,
   rar->bytes_remaining -= bytes_avail;
   rar->bytes_unconsumed = bytes_avail;
   /* Calculate File CRC. */
-  rar->crc_calculated = crc32(rar->crc_calculated, *buff, bytes_avail);
+  rar->crc_calculated = crc32(rar->crc_calculated, *buff, (uInt)bytes_avail);
   return (ARCHIVE_OK);
 }
 
@@ -1731,7 +1731,7 @@ read_data_compressed(struct archive_read *a, const void **buff, size_t *size,
         *offset = rar->offset_outgoing;
         rar->offset_outgoing += *size;
         /* Calculate File CRC. */
-        rar->crc_calculated = crc32(rar->crc_calculated, *buff, *size);
+        rar->crc_calculated = crc32(rar->crc_calculated, *buff, (uInt)*size);
         rar->unp_offset = 0;
         return (ARCHIVE_OK);
       }
@@ -1764,7 +1764,7 @@ read_data_compressed(struct archive_read *a, const void **buff, size_t *size,
         *offset = rar->offset_outgoing;
         rar->offset_outgoing += *size;
         /* Calculate File CRC. */
-        rar->crc_calculated = crc32(rar->crc_calculated, *buff, *size);
+        rar->crc_calculated = crc32(rar->crc_calculated, *buff, (uInt)*size);
         return (ret);
       }
       continue;
@@ -1897,7 +1897,7 @@ read_data_compressed(struct archive_read *a, const void **buff, size_t *size,
   *offset = rar->offset_outgoing;
   rar->offset_outgoing += *size;
   /* Calculate File CRC. */
-  rar->crc_calculated = crc32(rar->crc_calculated, *buff, *size);
+  rar->crc_calculated = crc32(rar->crc_calculated, *buff, (uInt)*size);
   return ret;
 }
 

diff --git a/libarchive/archive_read_support_format_zip.c b/libarchive/archive_read_support_format_zip.c
index ff74f4fa66102c8cc11a04e91eb499da554ca5e5..8903ce8d017f145d91172c2d382419a9dfaa9576 100644 (file)
--- a/libarchive/archive_read_support_format_zip.c
+++ b/libarchive/archive_read_support_format_zip.c
@@ -920,7 +920,7 @@ archive_read_format_zip_read_data(struct archive_read *a,
                return (r);
        /* Update checksum */
        if (*size)
-               zip->entry_crc32 = crc32(zip->entry_crc32, *buff, *size);
+               zip->entry_crc32 = crc32(zip->entry_crc32, *buff, (uInt)*size);
        /* If we hit the end, swallow any end-of-data marker. */
        if (zip->end_of_entry) {
                /* Check file size, CRC against these values. */
@@ -1133,10 +1133,10 @@ zip_read_data_deflate(struct archive_read *a, const void **buff,
         * cast to remove 'const'.
         */
        zip->stream.next_in = (Bytef *)(uintptr_t)(const void *)compressed_buff;
-       zip->stream.avail_in = bytes_avail;
+       zip->stream.avail_in = (uInt)bytes_avail;
        zip->stream.total_in = 0;
        zip->stream.next_out = zip->uncompressed_buffer;
-       zip->stream.avail_out = zip->uncompressed_buffer_size;
+       zip->stream.avail_out = (uInt)zip->uncompressed_buffer_size;
        zip->stream.total_out = 0;
 
        r = inflate(&zip->stream, 0);

diff --git a/libarchive/archive_write_add_filter_gzip.c b/libarchive/archive_write_add_filter_gzip.c
index 1a7246745fb8cb8d1e3390c2f9d2f89f569424e8..da4607bb934cceb62153bd00dd2f2142c63752fa 100644 (file)
--- a/libarchive/archive_write_add_filter_gzip.c
+++ b/libarchive/archive_write_add_filter_gzip.c
@@ -211,7 +211,7 @@ archive_compressor_gzip_open(struct archive_write_filter *f)
 
        data->crc = crc32(0L, NULL, 0);
        data->stream.next_out = data->compressed;
-       data->stream.avail_out = data->compressed_buffer_size;
+       data->stream.avail_out = (uInt)data->compressed_buffer_size;
 
        /* Prime output buffer with a gzip header. */
        data->compressed[0] = 0x1f; /* GZip signature bytes */
@@ -282,12 +282,12 @@ archive_compressor_gzip_write(struct archive_write_filter *f, const void *buff,
        int ret;
 
        /* Update statistics */
-       data->crc = crc32(data->crc, (const Bytef *)buff, length);
+       data->crc = crc32(data->crc, (const Bytef *)buff, (uInt)length);
        data->total_in += length;
 
        /* Compress input data to output buffer */
        SET_NEXT_IN(data, buff);
-       data->stream.avail_in = length;
+       data->stream.avail_in = (uInt)length;
        if ((ret = drive_compressor(f, data, 0)) != ARCHIVE_OK)
                return (ret);
 
@@ -358,7 +358,8 @@ drive_compressor(struct archive_write_filter *f,
                        if (ret != ARCHIVE_OK)
                                return (ARCHIVE_FATAL);
                        data->stream.next_out = data->compressed;
-                       data->stream.avail_out = data->compressed_buffer_size;
+                       data->stream.avail_out =
+                           (uInt)data->compressed_buffer_size;
                }
 
                /* If there's nothing to do, we're done. */

diff --git a/libarchive/archive_write_set_format_7zip.c b/libarchive/archive_write_set_format_7zip.c
index dcb23b970eda1108c8b7d955c128295668d2fe32..ef8cb959eee0b182055d13e247c4e15db13ef436 100644 (file)
--- a/libarchive/archive_write_set_format_7zip.c
+++ b/libarchive/archive_write_set_format_7zip.c
@@ -504,7 +504,7 @@ _7z_write_header(struct archive_write *a, struct archive_entry *entry)
                bytes = compress_out(a, p, (size_t)file->size, ARCHIVE_Z_RUN);
                if (bytes < 0)
                        return ((int)bytes);
-               zip->entry_crc32 = crc32(zip->entry_crc32, p, bytes);
+               zip->entry_crc32 = crc32(zip->entry_crc32, p, (uInt)bytes);
                zip->entry_bytes_remaining -= bytes;
        }
 
@@ -562,7 +562,7 @@ compress_out(struct archive_write *a, const void *buff, size_t s,
                return (0);
 
        if ((zip->crc32flg & PRECODE_CRC32) && s)
-               zip->precode_crc32 = crc32(zip->precode_crc32, buff, s);
+               zip->precode_crc32 = crc32(zip->precode_crc32, buff, (uInt)s);
        zip->stream.next_in = (const unsigned char *)buff;
        zip->stream.avail_in = s;
        do {
@@ -608,7 +608,7 @@ _7z_write_data(struct archive_write *a, const void *buff, size_t s)
        bytes = compress_out(a, buff, s, ARCHIVE_Z_RUN);
        if (bytes < 0)
                return (bytes);
-       zip->entry_crc32 = crc32(zip->entry_crc32, buff, bytes);
+       zip->entry_crc32 = crc32(zip->entry_crc32, buff, (uInt)bytes);
        zip->entry_bytes_remaining -= bytes;
        return (bytes);
 }
@@ -1680,10 +1680,10 @@ compression_init_encoder_deflate(struct archive *a,
         * of ugly hackery to convert a const * pointer to
         * a non-const pointer. */
        strm->next_in = (Bytef *)(uintptr_t)(const void *)lastrm->next_in;
-       strm->avail_in = lastrm->avail_in;
+       strm->avail_in = (uInt)lastrm->avail_in;
        strm->total_in = (uLong)lastrm->total_in;
        strm->next_out = lastrm->next_out;
-       strm->avail_out = lastrm->avail_out;
+       strm->avail_out = (uInt)lastrm->avail_out;
        strm->total_out = (uLong)lastrm->total_out;
        if (deflateInit2(strm, level, Z_DEFLATED,
            (withheader)?15:-15,
@@ -1713,10 +1713,10 @@ compression_code_deflate(struct archive *a,
         * of ugly hackery to convert a const * pointer to
         * a non-const pointer. */
        strm->next_in = (Bytef *)(uintptr_t)(const void *)lastrm->next_in;
-       strm->avail_in = lastrm->avail_in;
+       strm->avail_in = (uInt)lastrm->avail_in;
        strm->total_in = (uLong)lastrm->total_in;
        strm->next_out = lastrm->next_out;
-       strm->avail_out = lastrm->avail_out;
+       strm->avail_out = (uInt)lastrm->avail_out;
        strm->total_out = (uLong)lastrm->total_out;
        r = deflate(strm,
            (action == ARCHIVE_Z_FINISH)? Z_FINISH: Z_NO_FLUSH);

diff --git a/libarchive/archive_write_set_format_iso9660.c b/libarchive/archive_write_set_format_iso9660.c
index c1900528a6aabfce2cd6f5bfefc3addc68e484c4..7bdcd0199a0a2e4b76a15c7d7fd7b2fec854f18f 100644 (file)
--- a/libarchive/archive_write_set_format_iso9660.c
+++ b/libarchive/archive_write_set_format_iso9660.c
@@ -7433,7 +7433,7 @@ zisofs_init(struct archive_write *a,  struct isofile *file)
        /* Calculate a size of Block Pointers of zisofs. */
        _ceil = (file->zisofs.uncompressed_size + ZF_BLOCK_SIZE -1)
                >> file->zisofs.log2_bs;
-       iso9660->zisofs.block_pointers_cnt = _ceil + 1;
+       iso9660->zisofs.block_pointers_cnt = (int)_ceil + 1;
        iso9660->zisofs.block_pointers_idx = 0;
 
        /* Ensure a buffer size used for Block Pointers */
@@ -7579,7 +7579,7 @@ zisofs_write_to_temp(struct archive_write *a, const void *buff, size_t s)
 
        zstrm = &(iso9660->zisofs.stream);
        zstrm->next_out = wb_buffptr(a);
-       zstrm->avail_out = wb_remaining(a);
+       zstrm->avail_out = (uInt)wb_remaining(a);
        b = (const unsigned char *)buff;
        do {
                avail = ZF_BLOCK_SIZE - zstrm->total_in;
@@ -7593,7 +7593,7 @@ zisofs_write_to_temp(struct archive_write *a, const void *buff, size_t s)
                        flush = Z_FINISH;
 
                zstrm->next_in = (Bytef *)(uintptr_t)(const void *)b;
-               zstrm->avail_in = avail;
+               zstrm->avail_in = (uInt)avail;
 
                /*
                 * Check if current data block are all zero.
@@ -7649,7 +7649,7 @@ zisofs_write_to_temp(struct archive_write *a, const void *buff, size_t s)
                                iso9660->zisofs.total_size += csize;
                                iso9660->cur_file->cur_content->size += csize;
                                zstrm->next_out = wb_buffptr(a);
-                               zstrm->avail_out = wb_remaining(a);
+                               zstrm->avail_out = (uInt)wb_remaining(a);
                                break;
                        default:
                                archive_set_error(&a->archive,
@@ -7813,7 +7813,7 @@ zisofs_extract_init(struct archive_write *a, struct zisofs_extract *zisofs,
        zisofs->block_pointers_size = xsize;
 
        /* Allocate uncompressed data buffer. */
-       zisofs->uncompressed_buffer_size = 1UL << zisofs->pz_log2_bs;
+       zisofs->uncompressed_buffer_size = (size_t)1UL << zisofs->pz_log2_bs;
 
        /*
         * Read the file header, and check the magic code of zisofs.
@@ -7883,7 +7883,7 @@ zisofs_extract(struct archive_write *a, struct zisofs_extract *zisofs,
                        return (rs);
                if (!zisofs->initialized) {
                        /* We need more data. */
-                       zisofs->pz_offset += bytes;
+                       zisofs->pz_offset += (uint32_t)bytes;
                        return (bytes);
                }
                avail = rs;
@@ -7966,9 +7966,9 @@ zisofs_extract(struct archive_write *a, struct zisofs_extract *zisofs,
                if (avail > zisofs->block_avail)
                        zisofs->stream.avail_in = zisofs->block_avail;
                else
-                       zisofs->stream.avail_in = avail;
+                       zisofs->stream.avail_in = (uInt)avail;
                zisofs->stream.next_out = wb_buffptr(a);
-               zisofs->stream.avail_out = wb_remaining(a);
+               zisofs->stream.avail_out = (uInt)wb_remaining(a);
 
                r = inflate(&zisofs->stream, 0);
                switch (r) {
@@ -7981,12 +7981,12 @@ zisofs_extract(struct archive_write *a, struct zisofs_extract *zisofs,
                        return (ARCHIVE_FATAL);
                }
                avail -= zisofs->stream.next_in - p;
-               zisofs->block_avail -= zisofs->stream.next_in - p;
+               zisofs->block_avail -= (uint32_t)(zisofs->stream.next_in - p);
                r = wb_consume(a, wb_remaining(a) - zisofs->stream.avail_out);
                if (r < 0)
                        return (r);
        }
-       zisofs->pz_offset += bytes;
+       zisofs->pz_offset += (uint32_t)bytes;
        return (bytes - avail);
 }
 

diff --git a/libarchive/archive_write_set_format_zip.c b/libarchive/archive_write_set_format_zip.c
index e8dca57db4b6bd5fda8b80c7e606acb25c47e6de..d7ec326e7c010e2855a959652e44f7efd3181061 100644 (file)
--- a/libarchive/archive_write_set_format_zip.c
+++ b/libarchive/archive_write_set_format_zip.c
@@ -560,7 +560,7 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
                zip->stream.zfree = Z_NULL;
                zip->stream.opaque = Z_NULL;
                zip->stream.next_out = zip->buf;
-               zip->stream.avail_out = zip->len_buf;
+               zip->stream.avail_out = (uInt)zip->len_buf;
                if (deflateInit2(&zip->stream, Z_DEFAULT_COMPRESSION,
                    Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
                        archive_set_error(&a->archive, ENOMEM,
@@ -648,12 +648,12 @@ archive_write_zip_data(struct archive_write *a, const void *buff, size_t s)
                zip->written_bytes += s;
                zip->remaining_data_bytes -= s;
                l->compressed_size += s;
-               l->crc32 = crc32(l->crc32, buff, s);
+               l->crc32 = crc32(l->crc32, buff, (uInt)s);
                return (s);
 #if HAVE_ZLIB_H
        case COMPRESSION_DEFLATE:
                zip->stream.next_in = (unsigned char*)(uintptr_t)buff;
-               zip->stream.avail_in = s;
+               zip->stream.avail_in = (uInt)s;
                do {
                        ret = deflate(&zip->stream, Z_NO_FLUSH);
                        if (ret == Z_STREAM_ERROR)
@@ -666,12 +666,12 @@ archive_write_zip_data(struct archive_write *a, const void *buff, size_t s)
                                l->compressed_size += zip->len_buf;
                                zip->written_bytes += zip->len_buf;
                                zip->stream.next_out = zip->buf;
-                               zip->stream.avail_out = zip->len_buf;
+                               zip->stream.avail_out = (uInt)zip->len_buf;
                        }
                } while (zip->stream.avail_in != 0);
                zip->remaining_data_bytes -= s;
                /* If we have it, use zlib's fast crc32() */
-               l->crc32 = crc32(l->crc32, buff, s);
+               l->crc32 = crc32(l->crc32, buff, (uInt)s);
                return (s);
 #endif
 
@@ -712,7 +712,7 @@ archive_write_zip_finish_entry(struct archive_write *a)
                        zip->stream.next_out = zip->buf;
                        if (zip->stream.avail_out != 0)
                                break;
-                       zip->stream.avail_out = zip->len_buf;
+                       zip->stream.avail_out = (uInt)zip->len_buf;
                }
                deflateEnd(&zip->stream);
                break;