/* zip.c -- Zip manipulation

   part of the minizip-ng project

   Copyright (C) Nathan Moinvaziri

     https://github.com/zlib-ng/minizip-ng

   Copyright (C) 2009-2010 Mathias Svensson

     Modifications for Zip64 support

     http://result42.com

   Copyright (C) 2007-2008 Even Rouault

     Modifications of Unzip for Zip64

   Copyright (C) 1998-2010 Gilles Vollant

     https://www.winimage.com/zLibDll/minizip.html

   This program is distributed under the terms of the same license as zlib.

   See the accompanying LICENSE file for the full text of the license.

*/

#include "mz.h"

#include "mz_crypt.h"

#include "mz_strm.h"

#ifdef HAVE_BZIP2

#  include "mz_strm_bzip.h"

#endif

#ifdef HAVE_LIBCOMP

#  include "mz_strm_libcomp.h"

#endif

#ifdef HAVE_LZMA

#  include "mz_strm_lzma.h"

#endif

#include "mz_strm_mem.h"

#ifdef HAVE_PKCRYPT

#  include "mz_strm_pkcrypt.h"

#endif

#ifdef HAVE_WZAES

#  include "mz_strm_wzaes.h"

#endif

#ifdef HAVE_ZLIB

#  include "mz_strm_zlib.h"

#endif

#ifdef HAVE_ZSTD

#  include "mz_strm_zstd.h"

#endif

#include "mz_zip.h"

#include <ctype.h> /* tolower */

#include <stdio.h> /* snprintf */

#if defined(_MSC_VER) || defined(__MINGW32__)

#  define localtime_r(t1, t2) (localtime_s(t2, t1) == 0 ? t1 : NULL)

#endif

#if defined(_MSC_VER) && (_MSC_VER < 1900)

#  define snprintf _snprintf

#endif

/***************************************************************************/

#define MZ_ZIP_MAGIC_LOCALHEADER        (0x04034b50)

#define MZ_ZIP_MAGIC_LOCALHEADERU8      {0x50, 0x4b, 0x03, 0x04}

#define MZ_ZIP_MAGIC_CENTRALHEADER      (0x02014b50)

#define MZ_ZIP_MAGIC_CENTRALHEADERU8    {0x50, 0x4b, 0x01, 0x02}

#define MZ_ZIP_MAGIC_ENDHEADER          (0x06054b50)

#define MZ_ZIP_MAGIC_ENDHEADERU8        {0x50, 0x4b, 0x05, 0x06}

#define MZ_ZIP_MAGIC_ENDHEADER64        (0x06064b50)

#define MZ_ZIP_MAGIC_ENDLOCHEADER64     (0x07064b50)

#define MZ_ZIP_MAGIC_DATADESCRIPTOR     (0x08074b50)

#define MZ_ZIP_MAGIC_DATADESCRIPTORU8   {0x50, 0x4b, 0x07, 0x08}

#define MZ_ZIP_SIZE_LD_ITEM             (30)

#define MZ_ZIP_SIZE_CD_ITEM             (46)

#define MZ_ZIP_SIZE_CD_LOCATOR64        (20)

#define MZ_ZIP_SIZE_MAX_DATA_DESCRIPTOR (24)

#define MZ_ZIP_OFFSET_CRC_SIZES         (14)

#define MZ_ZIP_UNCOMPR_SIZE64_CUSHION   (2 * 1024 * 1024)

#ifndef MZ_ZIP_EOCD_MAX_BACK

#  define MZ_ZIP_EOCD_MAX_BACK (1 << 20)

#endif

/***************************************************************************/

typedef struct mz_zip_s {

    mz_zip_file file_info;

    mz_zip_file local_file_info;

    void *stream;                 /* main stream */

    void *cd_stream;              /* pointer to the stream with the cd */

    void *cd_mem_stream;          /* memory stream for central directory */

    void *compress_stream;        /* compression stream */

    void *crypt_stream;           /* encryption stream */

    void *file_info_stream;       /* memory stream for storing file info */

    void *local_file_info_stream; /* memory stream for storing local file info */

    int32_t open_mode;

    uint8_t recover;

    uint8_t data_descriptor;

    uint32_t disk_number_with_cd; /* number of the disk with the central dir */

    int64_t disk_offset_shift;    /* correction for zips that have wrong offset start of cd */

    int64_t cd_start_pos;   /* pos of the first file in the central dir stream */

    int64_t cd_current_pos; /* pos of the current file in the central dir */

    int64_t cd_offset;      /* offset of start of central directory */

    int64_t cd_size;        /* size of the central directory */

    uint32_t cd_signature;  /* signature of central directory */

    uint8_t entry_scanned; /* entry header information read ok */

    uint8_t entry_opened;  /* entry is open for read/write */

    uint8_t entry_raw;     /* entry opened with raw mode */

    uint32_t entry_crc32;  /* entry crc32  */

    uint64_t number_entry;

    uint16_t version_madeby;

    char *comment;

} mz_zip;

/***************************************************************************/

#if 0

#  define mz_zip_print printf

#else

#  define mz_zip_print(fmt, ...)

#endif

/***************************************************************************/

/* Locate the end of central directory */

static int32_t mz_zip_search_eocd(void *stream, int64_t *central_pos) {

    int64_t file_size = 0;

    int64_t max_back = MZ_ZIP_EOCD_MAX_BACK;

    uint8_t find[4] = MZ_ZIP_MAGIC_ENDHEADERU8;

    int32_t err = MZ_OK;

    err = mz_stream_seek(stream, 0, MZ_SEEK_END);

    if (err != MZ_OK)

        return err;

    file_size = mz_stream_tell(stream);

    if (max_back <= 0 || max_back > file_size)

        max_back = file_size;

    return mz_stream_find_reverse(stream, (const void *)find, sizeof(find), max_back, central_pos);

}

/* Locate the end of central directory 64 of a zip file */

static int32_t mz_zip_search_zip64_eocd(void *stream, const int64_t end_central_offset, int64_t *central_pos) {

    int64_t offset = 0;

    uint32_t value32 = 0;

    int32_t err = MZ_OK;

    *central_pos = 0;

    /* Zip64 end of central directory locator */

    err = mz_stream_seek(stream, end_central_offset - MZ_ZIP_SIZE_CD_LOCATOR64, MZ_SEEK_SET);

    /* Read locator signature */

    if (err == MZ_OK) {

        err = mz_stream_read_uint32(stream, &value32);

        if (value32 != MZ_ZIP_MAGIC_ENDLOCHEADER64)

            err = MZ_FORMAT_ERROR;

    }

    /* Number of the disk with the start of the zip64 end of  central directory */

    if (err == MZ_OK)

        err = mz_stream_read_uint32(stream, &value32);

    /* Relative offset of the zip64 end of central directory record8 */

    if (err == MZ_OK)

        err = mz_stream_read_uint64(stream, (uint64_t *)&offset);

    /* Total number of disks */

    if (err == MZ_OK)

        err = mz_stream_read_uint32(stream, &value32);

    /* Goto end of central directory record */

    if (err == MZ_OK)

        err = mz_stream_seek(stream, (int64_t)offset, MZ_SEEK_SET);

    /* The signature */

    if (err == MZ_OK) {

        err = mz_stream_read_uint32(stream, &value32);

        if (value32 != MZ_ZIP_MAGIC_ENDHEADER64)

            err = MZ_FORMAT_ERROR;

    }

    if (err == MZ_OK)

        *central_pos = offset;

    return err;

}

#ifdef HAVE_PKCRYPT

/* Get PKWARE traditional encryption verifier */

static uint16_t mz_zip_get_pk_verify(uint32_t dos_date, uint64_t crc, uint16_t flag) {

    /* Info-ZIP modification to ZipCrypto format: if bit 3 of the general

     * purpose bit flag is set, it uses high byte of 16-bit File Time. */

    if (flag & MZ_ZIP_FLAG_DATA_DESCRIPTOR)

        return ((dos_date >> 16) & 0xff) << 8 | ((dos_date >> 8) & 0xff);

    return ((crc >> 16) & 0xff) << 8 | ((crc >> 24) & 0xff);

}

#endif

/* Get info about the current file in the zip file */

static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file *file_info, void *file_extra_stream) {

    uint64_t ntfs_time = 0;

    uint32_t reserved = 0;

    uint32_t magic = 0;

    uint32_t dos_date = 0;

    uint32_t field_pos = 0;

    uint16_t field_type = 0;

    uint16_t field_length = 0;

    uint32_t field_length_read = 0;

    uint16_t ntfs_attrib_id = 0;

    uint16_t ntfs_attrib_size = 0;

    uint16_t linkname_size;

    uint16_t value16 = 0;

    uint32_t value32 = 0;

    int64_t extrafield_pos = 0;

    int64_t comment_pos = 0;

    int64_t linkname_pos = 0;

    int64_t saved_pos = 0;

    int32_t err = MZ_OK;

    char *linkname = NULL;

    memset(file_info, 0, sizeof(mz_zip_file));

    /* Check the magic */

    err = mz_stream_read_uint32(stream, &magic);

    if (err == MZ_END_OF_STREAM)

        err = MZ_END_OF_LIST;

    else if (magic == MZ_ZIP_MAGIC_ENDHEADER || magic == MZ_ZIP_MAGIC_ENDHEADER64)

        err = MZ_END_OF_LIST;

    else if ((local) && (magic != MZ_ZIP_MAGIC_LOCALHEADER))

        err = MZ_FORMAT_ERROR;

    else if ((!local) && (magic != MZ_ZIP_MAGIC_CENTRALHEADER))

        err = MZ_FORMAT_ERROR;

    /* Read header fields */

    if (err == MZ_OK) {

        if (!local)

            err = mz_stream_read_uint16(stream, &file_info->version_madeby);

        if (err == MZ_OK)

            err = mz_stream_read_uint16(stream, &file_info->version_needed);

        if (err == MZ_OK)

            err = mz_stream_read_uint16(stream, &file_info->flag);

        if (err == MZ_OK)

            err = mz_stream_read_uint16(stream, &file_info->compression_method);

        if (err == MZ_OK) {

            err = mz_stream_read_uint32(stream, &dos_date);

            file_info->modified_date = mz_zip_dosdate_to_time_t(dos_date);

        }

        if (err == MZ_OK)

            err = mz_stream_read_uint32(stream, &file_info->crc);

#ifdef HAVE_PKCRYPT

        if (err == MZ_OK && file_info->flag & MZ_ZIP_FLAG_ENCRYPTED) {

            /* Use dos_date from header instead of derived from time in zip extensions */

            file_info->pk_verify = mz_zip_get_pk_verify(dos_date, file_info->crc, file_info->flag);

        }

#endif

        if (err == MZ_OK) {

            err = mz_stream_read_uint32(stream, &value32);

            file_info->compressed_size = value32;

        }

        if (err == MZ_OK) {

            err = mz_stream_read_uint32(stream, &value32);

            file_info->uncompressed_size = value32;

        }

        if (err == MZ_OK)

            err = mz_stream_read_uint16(stream, &file_info->filename_size);

        if (err == MZ_OK)

            err = mz_stream_read_uint16(stream, &file_info->extrafield_size);

        if (!local) {

            if (err == MZ_OK)

                err = mz_stream_read_uint16(stream, &file_info->comment_size);

            if (err == MZ_OK) {

                err = mz_stream_read_uint16(stream, &value16);

                file_info->disk_number = value16;

            }

            if (err == MZ_OK)

                err = mz_stream_read_uint16(stream, &file_info->internal_fa);

            if (err == MZ_OK)

                err = mz_stream_read_uint32(stream, &file_info->external_fa);

            if (err == MZ_OK) {

                err = mz_stream_read_uint32(stream, &value32);

                file_info->disk_offset = value32;

            }

        }

    }

    if (err == MZ_OK)

        err = mz_stream_seek(file_extra_stream, 0, MZ_SEEK_SET);

    /* Copy variable length data to memory stream for later retrieval */

    if ((err == MZ_OK) && (file_info->filename_size > 0))

        err = mz_stream_copy(file_extra_stream, stream, file_info->filename_size);

    mz_stream_write_uint8(file_extra_stream, 0);

    extrafield_pos = mz_stream_tell(file_extra_stream);

    if ((err == MZ_OK) && (file_info->extrafield_size > 0))

        err = mz_stream_copy(file_extra_stream, stream, file_info->extrafield_size);

    mz_stream_write_uint8(file_extra_stream, 0);

    comment_pos = mz_stream_tell(file_extra_stream);

    if ((err == MZ_OK) && (file_info->comment_size > 0))

        err = mz_stream_copy(file_extra_stream, stream, file_info->comment_size);

    mz_stream_write_uint8(file_extra_stream, 0);

    linkname_pos = mz_stream_tell(file_extra_stream);

    /* Overwrite if we encounter UNIX1 extra block */

    mz_stream_write_uint8(file_extra_stream, 0);

    if ((err == MZ_OK) && (file_info->extrafield_size > 0)) {

        /* Seek to and parse the extra field */

        err = mz_stream_seek(file_extra_stream, extrafield_pos, MZ_SEEK_SET);

        while ((err == MZ_OK) && (field_pos + 4 <= file_info->extrafield_size)) {

            err = mz_zip_extrafield_read(file_extra_stream, &field_type, &field_length);

            if (err != MZ_OK)

                break;

            field_pos += 4;

            /* Don't allow field length to exceed size of remaining extrafield */

            if (field_length > (file_info->extrafield_size - field_pos))

                field_length = (uint16_t)(file_info->extrafield_size - field_pos);

            /* Read ZIP64 extra field */

            if ((field_type == MZ_ZIP_EXTENSION_ZIP64) && (field_length >= 8)) {

                if ((err == MZ_OK) && (file_info->uncompressed_size == UINT32_MAX)) {

                    err = mz_stream_read_int64(file_extra_stream, &file_info->uncompressed_size);

                    if (file_info->uncompressed_size < 0)

                        err = MZ_FORMAT_ERROR;

                }

                if ((err == MZ_OK) && (file_info->compressed_size == UINT32_MAX)) {

                    err = mz_stream_read_int64(file_extra_stream, &file_info->compressed_size);

                    if (file_info->compressed_size < 0)

                        err = MZ_FORMAT_ERROR;

                }

                if ((err == MZ_OK) && (file_info->disk_offset == UINT32_MAX)) {

                    err = mz_stream_read_int64(file_extra_stream, &file_info->disk_offset);

                    if (file_info->disk_offset < 0)

                        err = MZ_FORMAT_ERROR;

                }

                if ((err == MZ_OK) && (file_info->disk_number == UINT16_MAX))

                    err = mz_stream_read_uint32(file_extra_stream, &file_info->disk_number);

            }

            /* Read NTFS extra field */

            else if ((field_type == MZ_ZIP_EXTENSION_NTFS) && (field_length > 4)) {

                if (err == MZ_OK)

                    err = mz_stream_read_uint32(file_extra_stream, &reserved);

                field_length_read = 4;

                while ((err == MZ_OK) && (field_length_read + 4 <= field_length)) {

                    err = mz_stream_read_uint16(file_extra_stream, &ntfs_attrib_id);

                    if (err == MZ_OK)

                        err = mz_stream_read_uint16(file_extra_stream, &ntfs_attrib_size);

                    field_length_read += 4;

                    if ((err == MZ_OK) && (ntfs_attrib_id == 0x01) && (ntfs_attrib_size == 24)) {

                        err = mz_stream_read_uint64(file_extra_stream, &ntfs_time);

                        mz_zip_ntfs_to_unix_time(ntfs_time, &file_info->modified_date);

                        if (err == MZ_OK) {

                            err = mz_stream_read_uint64(file_extra_stream, &ntfs_time);

                            mz_zip_ntfs_to_unix_time(ntfs_time, &file_info->accessed_date);

                        }

                        if (err == MZ_OK) {

                            err = mz_stream_read_uint64(file_extra_stream, &ntfs_time);

                            mz_zip_ntfs_to_unix_time(ntfs_time, &file_info->creation_date);

                        }

                    } else if ((err == MZ_OK) && (field_length_read + ntfs_attrib_size <= field_length)) {

                        err = mz_stream_seek(file_extra_stream, ntfs_attrib_size, MZ_SEEK_CUR);

                    }

                    field_length_read += ntfs_attrib_size;

                }

            }

            /* Read UNIX1 extra field */

            else if ((field_type == MZ_ZIP_EXTENSION_UNIX1) && (field_length >= 12)) {

                if (err == MZ_OK) {

                    err = mz_stream_read_uint32(file_extra_stream, &value32);

                    if (err == MZ_OK && file_info->accessed_date == 0)

                        file_info->accessed_date = value32;

                }

                if (err == MZ_OK) {

                    err = mz_stream_read_uint32(file_extra_stream, &value32);

                    if (err == MZ_OK && file_info->modified_date == 0)

                        file_info->modified_date = value32;

                }

                if (err == MZ_OK)

                    err = mz_stream_read_uint16(file_extra_stream, &value16); /* User id */

                if (err == MZ_OK)

                    err = mz_stream_read_uint16(file_extra_stream, &value16); /* Group id */

                /* Copy linkname to end of file extra stream so we can return null

                   terminated string */

                linkname_size = field_length - 12;

                if ((err == MZ_OK) && (linkname_size > 0)) {

                    linkname = (char *)malloc(linkname_size);

                    if (linkname) {

                        if (mz_stream_read(file_extra_stream, linkname, linkname_size) != linkname_size)

                            err = MZ_READ_ERROR;

                        if (err == MZ_OK) {

                            saved_pos = mz_stream_tell(file_extra_stream);

                            mz_stream_seek(file_extra_stream, linkname_pos, MZ_SEEK_SET);

                            mz_stream_write(file_extra_stream, linkname, linkname_size);

                            mz_stream_write_uint8(file_extra_stream, 0);

                            mz_stream_seek(file_extra_stream, saved_pos, MZ_SEEK_SET);

                        }

                        free(linkname);

                    }

                }

            }

#ifdef HAVE_WZAES

            /* Read AES extra field */

            else if ((field_type == MZ_ZIP_EXTENSION_AES) && (field_length == 7)) {

                uint8_t value8 = 0;

                /* Verify version info */

                err = mz_stream_read_uint16(file_extra_stream, &value16);

                /* Support AE-1 and AE-2 */

                if (value16 != 1 && value16 != 2)

                    err = MZ_FORMAT_ERROR;

                file_info->aes_version = value16;

                if (err == MZ_OK)

                    err = mz_stream_read_uint8(file_extra_stream, &value8);

                if ((char)value8 != 'A')

                    err = MZ_FORMAT_ERROR;

                if (err == MZ_OK)

                    err = mz_stream_read_uint8(file_extra_stream, &value8);

                if ((char)value8 != 'E')

                    err = MZ_FORMAT_ERROR;

                /* Get AES encryption strength and actual compression method */

                if (err == MZ_OK) {

                    err = mz_stream_read_uint8(file_extra_stream, &value8);

                    file_info->aes_strength = value8;

                }

                if (err == MZ_OK) {

                    err = mz_stream_read_uint16(file_extra_stream, &value16);

                    file_info->compression_method = value16;

                }

            }

#endif

            else if (field_length > 0) {

                err = mz_stream_seek(file_extra_stream, field_length, MZ_SEEK_CUR);

            }

            field_pos += field_length;

        }

    }

    /* Get pointers to variable length data */

    mz_stream_mem_get_buffer(file_extra_stream, (const void **)&file_info->filename);

    mz_stream_mem_get_buffer_at(file_extra_stream, extrafield_pos, (const void **)&file_info->extrafield);

    mz_stream_mem_get_buffer_at(file_extra_stream, comment_pos, (const void **)&file_info->comment);

    mz_stream_mem_get_buffer_at(file_extra_stream, linkname_pos, (const void **)&file_info->linkname);

    /* Set to empty string just in-case */

    if (!file_info->filename)

        file_info->filename = "";

    if (!file_info->extrafield)

        file_info->extrafield_size = 0;

    if (!file_info->comment)

        file_info->comment = "";

    if (!file_info->linkname)

        file_info->linkname = "";

    if (err == MZ_OK) {

        mz_zip_print("Zip - Entry - Read header - %s (local %" PRId8 ")\n", file_info->filename, local);

        mz_zip_print("Zip - Entry - Read header compress (ucs %" PRId64 " cs %" PRId64 " crc 0x%08" PRIx32 ")\n",

                     file_info->uncompressed_size, file_info->compressed_size, file_info->crc);

        if (!local) {

            mz_zip_print("Zip - Entry - Read header disk (disk %" PRIu32 " offset %" PRId64 ")\n",

                         file_info->disk_number, file_info->disk_offset);

        }

        mz_zip_print("Zip - Entry - Read header variable (fnl %" PRId32 " efs %" PRId32 " cms %" PRId32 ")\n",

                     file_info->filename_size, file_info->extrafield_size, file_info->comment_size);

    }

    return err;

}

static int32_t mz_zip_entry_read_descriptor(void *stream, uint8_t zip64, uint32_t *crc32, int64_t *compressed_size,

                                            int64_t *uncompressed_size) {

    uint32_t value32 = 0;

    int64_t value64 = 0;

    int32_t err = MZ_OK;

    err = mz_stream_read_uint32(stream, &value32);

    if (value32 != MZ_ZIP_MAGIC_DATADESCRIPTOR)

        err = MZ_FORMAT_ERROR;

    if (err == MZ_OK)

        err = mz_stream_read_uint32(stream, &value32);

    if (err == MZ_OK && crc32)

        *crc32 = value32;

    if (err == MZ_OK) {

        /* If zip 64 extension is enabled then read as 8 byte */

        if (!zip64) {

            err = mz_stream_read_uint32(stream, &value32);

            value64 = value32;

        } else {

            err = mz_stream_read_int64(stream, &value64);

            if (value64 < 0)

                err = MZ_FORMAT_ERROR;

        }

        if (err == MZ_OK && compressed_size)

            *compressed_size = value64;

    }

    if (err == MZ_OK) {

        if (!zip64) {

            err = mz_stream_read_uint32(stream, &value32);

            value64 = value32;

        } else {

            err = mz_stream_read_int64(stream, &value64);

            if (value64 < 0)

                err = MZ_FORMAT_ERROR;

        }

        if (err == MZ_OK && uncompressed_size)

            *uncompressed_size = value64;

    }

    return err;

}

static int32_t mz_zip_entry_write_crc_sizes(void *stream, uint8_t zip64, uint8_t mask, mz_zip_file *file_info) {

    int32_t err = MZ_OK;

    if (mask)

        err = mz_stream_write_uint32(stream, 0);

    else

        err = mz_stream_write_uint32(stream, file_info->crc); /* crc */

    /* For backwards-compatibility with older zip applications we set all sizes to UINT32_MAX

     * when zip64 is needed, instead of only setting sizes larger than UINT32_MAX. */

    if (err == MZ_OK) {

        if (zip64) /* compr size */

            err = mz_stream_write_uint32(stream, UINT32_MAX);

        else

            err = mz_stream_write_uint32(stream, (uint32_t)file_info->compressed_size);

    }

    if (err == MZ_OK) {

        if (mask) /* uncompr size */

            err = mz_stream_write_uint32(stream, 0);

        else if (zip64)

            err = mz_stream_write_uint32(stream, UINT32_MAX);

        else

            err = mz_stream_write_uint32(stream, (uint32_t)file_info->uncompressed_size);

    }

    return err;

}

static int32_t mz_zip_entry_needs_zip64(mz_zip_file *file_info, uint8_t local, uint8_t *zip64) {

    uint32_t max_uncompressed_size = UINT32_MAX;

    uint8_t needs_zip64 = 0;

    if (!zip64)

        return MZ_PARAM_ERROR;

    *zip64 = 0;

    if (local) {

        /* At local header we might not know yet whether compressed size will overflow unsigned

           32-bit integer which might happen for high entropy data so we give it some cushion */

        max_uncompressed_size -= MZ_ZIP_UNCOMPR_SIZE64_CUSHION;

    }

    needs_zip64 = (file_info->uncompressed_size >= max_uncompressed_size) || (file_info->compressed_size >= UINT32_MAX);

    if (!local) {

        /* Disk offset and number only used in central directory header */

        needs_zip64 |= (file_info->disk_offset >= UINT32_MAX) || (file_info->disk_number >= UINT16_MAX);

    }

    if (file_info->zip64 == MZ_ZIP64_AUTO) {

        /* If uncompressed size is unknown, assume zip64 for 64-bit data descriptors */

        if (local && file_info->uncompressed_size == 0) {

            /* Don't use zip64 for local header directory entries */

            if (mz_zip_attrib_is_dir(file_info->external_fa, file_info->version_madeby) != MZ_OK) {

                *zip64 = 1;

            }

        }

        *zip64 |= needs_zip64;

    } else if (file_info->zip64 == MZ_ZIP64_FORCE) {

        *zip64 = 1;

    } else if (file_info->zip64 == MZ_ZIP64_DISABLE) {

        /* Zip64 extension is required to zip file */

        if (needs_zip64)

            return MZ_PARAM_ERROR;

    }

    return MZ_OK;

}

static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_file *file_info) {

    uint64_t ntfs_time = 0;

    uint32_t reserved = 0;

    uint32_t dos_date = 0;

    uint16_t extrafield_size = 0;

    uint16_t field_type = 0;

    uint16_t field_length = 0;

    uint16_t field_length_zip64 = 0;

    uint16_t field_length_ntfs = 0;

    uint16_t field_length_aes = 0;

    uint16_t field_length_unix1 = 0;

    uint16_t filename_size = 0;

    uint16_t filename_length = 0;

    uint16_t linkname_size = 0;

    uint16_t version_needed = 0;

    int32_t comment_size = 0;

    int32_t err = MZ_OK;

    int32_t err_mem = MZ_OK;

    uint8_t zip64 = 0;

    uint8_t skip_aes = 0;

    uint8_t mask = 0;

    uint8_t write_end_slash = 0;

    const char *filename = NULL;

    char masked_name[64];

    void *file_extra_stream = NULL;

    if (!file_info)

        return MZ_PARAM_ERROR;

    if ((local) && (file_info->flag & MZ_ZIP_FLAG_MASK_LOCAL_INFO))

        mask = 1;

    /* Determine if zip64 extra field is necessary */

    err = mz_zip_entry_needs_zip64(file_info, local, &zip64);

    if (err != MZ_OK)

        return err;

    /* Start calculating extra field sizes */

    if (zip64) {

        /* Both compressed and uncompressed sizes must be included (at least in local header) */

        field_length_zip64 = 8 + 8;

        if ((!local) && (file_info->disk_offset >= UINT32_MAX))

            field_length_zip64 += 8;

        extrafield_size += 4;

        extrafield_size += field_length_zip64;

    }

    /* Calculate extra field size and check for duplicates */

    if (file_info->extrafield_size > 0) {

        file_extra_stream = mz_stream_mem_create();

        if (!file_extra_stream)

            return MZ_MEM_ERROR;

        mz_stream_mem_set_buffer(file_extra_stream, (void *)file_info->extrafield, file_info->extrafield_size);

        do {

            err_mem = mz_stream_read_uint16(file_extra_stream, &field_type);

            if (err_mem == MZ_OK)

                err_mem = mz_stream_read_uint16(file_extra_stream, &field_length);

            if (err_mem != MZ_OK)

                break;

            /* Prefer incoming aes extensions over ours */

            if (field_type == MZ_ZIP_EXTENSION_AES)

                skip_aes = 1;

            /* Prefer our zip64, ntfs, unix1 extension over incoming */

            if (field_type != MZ_ZIP_EXTENSION_ZIP64 && field_type != MZ_ZIP_EXTENSION_NTFS &&

                field_type != MZ_ZIP_EXTENSION_UNIX1)

                extrafield_size += 4 + field_length;

            if (err_mem == MZ_OK)

                err_mem = mz_stream_seek(file_extra_stream, field_length, MZ_SEEK_CUR);

        } while (err_mem == MZ_OK);

    }

#ifdef HAVE_WZAES

    if (!skip_aes) {

        if ((file_info->flag & MZ_ZIP_FLAG_ENCRYPTED) && (file_info->aes_version)) {

            field_length_aes = 1 + 1 + 1 + 2 + 2;

            extrafield_size += 4 + field_length_aes;

        }

    }

#else

    MZ_UNUSED(field_length_aes);

    MZ_UNUSED(skip_aes);

#endif

    /* NTFS timestamps */

    if ((file_info->modified_date != 0) && (file_info->accessed_date != 0) && (file_info->creation_date != 0) &&

        (!mask)) {

        field_length_ntfs = 8 + 8 + 8 + 4 + 2 + 2;

        extrafield_size += 4 + field_length_ntfs;

    }

    /* Unix1 symbolic links */

    if (file_info->linkname && *file_info->linkname != 0) {

        linkname_size = (uint16_t)strlen(file_info->linkname);

        field_length_unix1 = 12 + linkname_size;

        extrafield_size += 4 + field_length_unix1;

    }

    if (local)

        err = mz_stream_write_uint32(stream, MZ_ZIP_MAGIC_LOCALHEADER);

    else {

        err = mz_stream_write_uint32(stream, MZ_ZIP_MAGIC_CENTRALHEADER);

        if (err == MZ_OK)

            err = mz_stream_write_uint16(stream, file_info->version_madeby);

    }

    /* Calculate version needed to extract */

    if (err == MZ_OK) {

        version_needed = file_info->version_needed;

        if (version_needed == 0) {

            version_needed = 20;

            if (zip64)

                version_needed = 45;

#ifdef HAVE_BZIP2

            if (file_info->compression_method == MZ_COMPRESS_METHOD_BZIP2)

                version_needed = 46;

#endif

#ifdef HAVE_WZAES

            if ((file_info->flag & MZ_ZIP_FLAG_ENCRYPTED) && (file_info->aes_version))

                version_needed = 51;

#endif

#if defined(HAVE_LZMA) || defined(HAVE_LIBCOMP)

            if ((file_info->compression_method == MZ_COMPRESS_METHOD_LZMA) ||

                (file_info->compression_method == MZ_COMPRESS_METHOD_XZ))

                version_needed = 63;

#endif

        }

        err = mz_stream_write_uint16(stream, version_needed);

    }

    if (err == MZ_OK)

        err = mz_stream_write_uint16(stream, file_info->flag);

    if (err == MZ_OK) {

#ifdef HAVE_WZAES

        if ((file_info->flag & MZ_ZIP_FLAG_ENCRYPTED) && (file_info->aes_version))

            err = mz_stream_write_uint16(stream, MZ_COMPRESS_METHOD_AES);

        else

#endif

            err = mz_stream_write_uint16(stream, file_info->compression_method);

    }

    if (err == MZ_OK) {

        if (file_info->modified_date != 0 && !mask)

            dos_date = mz_zip_time_t_to_dos_date(file_info->modified_date);

        err = mz_stream_write_uint32(stream, dos_date);

    }

    if (err == MZ_OK)

        err = mz_zip_entry_write_crc_sizes(stream, zip64, mask, file_info);

    if (mask) {

        snprintf(masked_name, sizeof(masked_name), "%" PRIx32 "_%" PRIx64, file_info->disk_number,

                 file_info->disk_offset);

        filename = masked_name;

    } else {

        filename = file_info->filename;

    }

    filename_length = (uint16_t)strlen(filename);

    filename_size += filename_length;

    if ((mz_zip_attrib_is_dir(file_info->external_fa, file_info->version_madeby) == MZ_OK) &&

        ((filename[filename_length - 1] != '/') && (filename[filename_length - 1] != '\\'))) {

        filename_size += 1;

        write_end_slash = 1;

    }

    if (err == MZ_OK)

        err = mz_stream_write_uint16(stream, filename_size);

    if (err == MZ_OK)

        err = mz_stream_write_uint16(stream, extrafield_size);

    if (!local) {

        if (file_info->comment) {

            comment_size = (int32_t)strlen(file_info->comment);

            if (comment_size > UINT16_MAX)

                comment_size = UINT16_MAX;

        }

        if (err == MZ_OK)

            err = mz_stream_write_uint16(stream, (uint16_t)comment_size);

        if (err == MZ_OK)

            err = mz_stream_write_uint16(stream, (uint16_t)file_info->disk_number);

        if (err == MZ_OK)

            err = mz_stream_write_uint16(stream, file_info->internal_fa);

        if (err == MZ_OK)

            err = mz_stream_write_uint32(stream, file_info->external_fa);

        if (err == MZ_OK) {

            if (file_info->disk_offset >= UINT32_MAX)

                err = mz_stream_write_uint32(stream, UINT32_MAX);

            else

                err = mz_stream_write_uint32(stream, (uint32_t)file_info->disk_offset);

        }

    }

    if (err == MZ_OK) {

        const char *next = filename;

        int32_t left = filename_length;

#if defined(_WIN32)

        const char *backslash = NULL;

        /* Ensure all slashes are written as forward slashes according to 4.4.17.1 */

        while ((err == MZ_OK) && (backslash = strchr(next, '\\'))) {

            int32_t part_length = (int32_t)(backslash - next);

            if (mz_stream_write(stream, next, part_length) != part_length || mz_stream_write(stream, "/", 1) != 1)

                err = MZ_WRITE_ERROR;

            left -= part_length + 1;

            next = backslash + 1;

        }

#endif

        if (err == MZ_OK && left > 0) {

            if (mz_stream_write(stream, next, left) != left)

                err = MZ_WRITE_ERROR;

        }

        /* Ensure that directories have a slash appended to them for compatibility */

        if (err == MZ_OK && write_end_slash)

            err = mz_stream_write_uint8(stream, '/');

    }

    /* Write ZIP64 extra field first so we can update sizes later if data descriptor not used */

    if ((err == MZ_OK) && (zip64)) {

        err = mz_zip_extrafield_write(stream, MZ_ZIP_EXTENSION_ZIP64, field_length_zip64);

        if (err == MZ_OK) {

            if (mask)

                err = mz_stream_write_int64(stream, 0);

            else

                err = mz_stream_write_int64(stream, file_info->uncompressed_size);

        }

        if (err == MZ_OK)

            err = mz_stream_write_int64(stream, file_info->compressed_size);

        if ((err == MZ_OK) && (!local) && (file_info->disk_offset >= UINT32_MAX))

            err = mz_stream_write_int64(stream, file_info->disk_offset);

        if ((err == MZ_OK) && (!local) && (file_info->disk_number >= UINT16_MAX))

            err = mz_stream_write_uint32(stream, file_info->disk_number);

    }

    /* Write NTFS extra field */

    if ((err == MZ_OK) && (field_length_ntfs > 0)) {

        err = mz_zip_extrafield_write(stream, MZ_ZIP_EXTENSION_NTFS, field_length_ntfs);

        if (err == MZ_OK)

            err = mz_stream_write_uint32(stream, reserved);

        if (err == MZ_OK)

            err = mz_stream_write_uint16(stream, 0x01);

        if (err == MZ_OK)

            err = mz_stream_write_uint16(stream, field_length_ntfs - 8);

        if (err == MZ_OK) {

            mz_zip_unix_to_ntfs_time(file_info->modified_date, &ntfs_time);

            err = mz_stream_write_uint64(stream, ntfs_time);

        }

        if (err == MZ_OK) {

            mz_zip_unix_to_ntfs_time(file_info->accessed_date, &ntfs_time);

            err = mz_stream_write_uint64(stream, ntfs_time);

        }

        if (err == MZ_OK) {

            mz_zip_unix_to_ntfs_time(file_info->creation_date, &ntfs_time);

            err = mz_stream_write_uint64(stream, ntfs_time);

        }

    }

    /* Write UNIX extra block extra field */

    if ((err == MZ_OK) && (field_length_unix1 > 0)) {

        err = mz_zip_extrafield_write(stream, MZ_ZIP_EXTENSION_UNIX1, field_length_unix1);

        if (err == MZ_OK)

            err = mz_stream_write_uint32(stream, (uint32_t)file_info->accessed_date);

        if (err == MZ_OK)

            err = mz_stream_write_uint32(stream, (uint32_t)file_info->modified_date);

        if (err == MZ_OK) /* User id */

            err = mz_stream_write_uint16(stream, 0);

        if (err == MZ_OK) /* Group id */

            err = mz_stream_write_uint16(stream, 0);

        if (err == MZ_OK && linkname_size > 0) {

            if (mz_stream_write(stream, file_info->linkname, linkname_size) != linkname_size)

                err = MZ_WRITE_ERROR;

        }

    }

#ifdef HAVE_WZAES

    /* Write AES extra field */

    if ((err == MZ_OK) && (!skip_aes) && (file_info->flag & MZ_ZIP_FLAG_ENCRYPTED) && (file_info->aes_version)) {

        err = mz_zip_extrafield_write(stream, MZ_ZIP_EXTENSION_AES, field_length_aes);

        if (err == MZ_OK)

            err = mz_stream_write_uint16(stream, file_info->aes_version);

        if (err == MZ_OK)

            err = mz_stream_write_uint8(stream, 'A');

        if (err == MZ_OK)

            err = mz_stream_write_uint8(stream, 'E');

        if (err == MZ_OK)

            err = mz_stream_write_uint8(stream, file_info->aes_strength);

        if (err == MZ_OK)

            err = mz_stream_write_uint16(stream, file_info->compression_method);

    }

#endif

    if (file_info->extrafield_size > 0) {

        err_mem = mz_stream_mem_seek(file_extra_stream, 0, MZ_SEEK_SET);

        while (err == MZ_OK && err_mem == MZ_OK) {

            err_mem = mz_stream_read_uint16(file_extra_stream, &field_type);

            if (err_mem == MZ_OK)

                err_mem = mz_stream_read_uint16(file_extra_stream, &field_length);

            if (err_mem != MZ_OK)

                break;

            /* Prefer our zip 64, ntfs, unix1 extensions over incoming */

            if (field_type == MZ_ZIP_EXTENSION_ZIP64 || field_type == MZ_ZIP_EXTENSION_NTFS ||

                field_type == MZ_ZIP_EXTENSION_UNIX1) {

                err_mem = mz_stream_seek(file_extra_stream, field_length, MZ_SEEK_CUR);

                continue;

            }

            err = mz_stream_write_uint16(stream, field_type);

            if (err == MZ_OK)

                err = mz_stream_write_uint16(stream, field_length);

            if (err == MZ_OK)

                err = mz_stream_copy(stream, file_extra_stream, field_length);

        }

        mz_stream_mem_delete(&file_extra_stream);

    }

    if (err == MZ_OK && !local && file_info->comment) {

        if (mz_stream_write(stream, file_info->comment, file_info->comment_size) != file_info->comment_size)

            err = MZ_WRITE_ERROR;

    }

    return err;

}

static int32_t mz_zip_entry_write_descriptor(void *stream, uint8_t zip64, uint32_t crc32, int64_t compressed_size,

                                             int64_t uncompressed_size) {

    int32_t err = MZ_OK;

    err = mz_stream_write_uint32(stream, MZ_ZIP_MAGIC_DATADESCRIPTOR);

    if (err == MZ_OK)

        err = mz_stream_write_uint32(stream, crc32);

    /* Store data descriptor as 8 bytes if zip 64 extension enabled */

    if (err == MZ_OK) {

        /* Zip 64 extension is enabled when uncompressed size is > UINT32_MAX */

        if (!zip64)

            err = mz_stream_write_uint32(stream, (uint32_t)compressed_size);

        else

            err = mz_stream_write_int64(stream, compressed_size);

    }

    if (err == MZ_OK) {

        if (!zip64)

            err = mz_stream_write_uint32(stream, (uint32_t)uncompressed_size);

        else

            err = mz_stream_write_int64(stream, uncompressed_size);

    }

    return err;

}

static int32_t mz_zip_read_cd(void *handle) {

    mz_zip *zip = (mz_zip *)handle;

    uint64_t number_entry_cd64 = 0;

    uint64_t number_entry_cd = 0;

    int64_t eocd_pos = 0;

    int64_t eocd_pos64 = 0;

    int64_t value64i = 0;

    uint16_t value16 = 0;

    uint32_t value32 = 0;

    uint64_t value64 = 0;

    uint16_t comment_size = 0;

    int32_t comment_read = 0;

    int32_t err = MZ_OK;

    if (!zip)

        return MZ_PARAM_ERROR;

    /* Read and cache central directory records */

    err = mz_zip_search_eocd(zip->stream, &eocd_pos);

    if (err == MZ_OK) {

        /* The signature, already checked */

        err = mz_stream_read_uint32(zip->stream, &value32);

        /* Number of this disk */

        if (err == MZ_OK)

            err = mz_stream_read_uint16(zip->stream, &value16);

        /* Number of the disk with the start of the central directory */

        if (err == MZ_OK)

            err = mz_stream_read_uint16(zip->stream, &value16);

        zip->disk_number_with_cd = value16;

        /* Total number of entries in the central dir on this disk */

        if (err == MZ_OK)

            err = mz_stream_read_uint16(zip->stream, &value16);

        zip->number_entry = value16;

        /* Total number of entries in the central dir */

        if (err == MZ_OK)

            err = mz_stream_read_uint16(zip->stream, &value16);

        number_entry_cd = value16;

        /* When recover is enabled, we can ignore incorrect number of entries */

        if (number_entry_cd != zip->number_entry && !zip->recover)

            err = MZ_FORMAT_ERROR;

        /* Size of the central directory */

        if (err == MZ_OK)

            err = mz_stream_read_uint32(zip->stream, &value32);

        if (err == MZ_OK)

            zip->cd_size = value32;

        /* Offset of start of central directory with respect to the starting disk number */

        if (err == MZ_OK)

            err = mz_stream_read_uint32(zip->stream, &value32);

        if (err == MZ_OK)

            zip->cd_offset = value32;

        /* Zip file global comment length */

        if (err == MZ_OK)

            err = mz_stream_read_uint16(zip->stream, &comment_size);

        if ((err == MZ_OK) && (comment_size > 0)) {

            zip->comment = (char *)malloc(comment_size + 1);

            if (zip->comment) {

                comment_read = mz_stream_read(zip->stream, zip->comment, comment_size);

                /* Don't fail if incorrect comment length read, not critical */

                if (comment_read < 0)

                    comment_read = 0;

                zip->comment[comment_read] = 0;

            }

        }

        if ((err == MZ_OK) && ((number_entry_cd == UINT16_MAX) || (zip->cd_offset == UINT32_MAX))) {

            /* Format should be Zip64, as the central directory or file size is too large */

            if (mz_zip_search_zip64_eocd(zip->stream, eocd_pos, &eocd_pos64) == MZ_OK) {

                eocd_pos = eocd_pos64;

                err = mz_stream_seek(zip->stream, eocd_pos, MZ_SEEK_SET);

                /* The signature, already checked */

                if (err == MZ_OK)

                    err = mz_stream_read_uint32(zip->stream, &value32);

                /* Size of zip64 end of central directory record */

                if (err == MZ_OK)

                    err = mz_stream_read_uint64(zip->stream, &value64);

                /* Version made by */

                if (err == MZ_OK)

                    err = mz_stream_read_uint16(zip->stream, &zip->version_madeby);

                /* Version needed to extract */

                if (err == MZ_OK)

                    err = mz_stream_read_uint16(zip->stream, &value16);

                /* Number of this disk */

                if (err == MZ_OK)

                    err = mz_stream_read_uint32(zip->stream, &value32);

                /* Number of the disk with the start of the central directory */