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

 *

 * Project:  CPL - Common Portability Library

 * Author:   Frank Warmerdam, warmerdam@pobox.com

 * Purpose:  Adjusted minizip "zip.c" source code for zip services.

 *

 * Modified version by Even Rouault. :

 *   - Decoration of symbol names unz* -> cpl_unz*

 *   - Undef EXPORT so that we are sure the symbols are not exported

 *   - Remove old C style function prototypes

 *   - Added CPL* simplified API at bottom.

 *

 *   Original license available in port/LICENCE_minizip

 *

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

/* zip.c -- IO on .zip files using zlib

   Version 1.1, February 14h, 2010

   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html

   )

         Copyright (C) 1998-2010 Gilles Vollant (minizip) (

   http://www.winimage.com/zLibDll/minizip.html )

         Modifications for Zip64 support

         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )

         For more info read MiniZip_info.txt

         Changes

   Oct-2009 - Mathias Svensson - Remove old C style function prototypes

   Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file

   archives Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring

   to get better overview of some functions. Oct-2009 - Mathias Svensson - Added

   zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data It is

   used when recreating zip archive with RAW when deleting items from a zip.

                                 ZIP64 data is automatically added to items that

   needs it, and existing ZIP64 data need to be removed. Oct-2009 - Mathias

   Svensson - Added support for BZIP2 as compression mode (bzip2 lib is

   required) Jan-2010 - back to unzip and minizip 1.0 name scheme, with

   compatibility layer

   Copyright (c) 2010-2018, Even Rouault <even dot rouault at spatialys.com>

*/

#include "cpl_port.h"

#include "cpl_minizip_zip.h"

#include <algorithm>

#include <limits>

#include <cassert>

#include <cstddef>

#include <cstdlib>

#include <cstring>

#if HAVE_FCNTL_H

#include <fcntl.h>

#endif

#include <time.h>

#include "cpl_conv.h"

#include "cpl_error.h"

#include "cpl_minizip_unzip.h"

#include "cpl_string.h"

#include "cpl_time.h"

#include "cpl_vsi_virtual.h"

#ifdef NO_ERRNO_H

extern int errno;

#else

#include <errno.h>

#endif

#ifndef VERSIONMADEBY

#define VERSIONMADEBY (0x0) /* platform dependent */

#endif

#ifndef Z_BUFSIZE

#define Z_BUFSIZE (16384)

#endif

#ifndef ALLOC

#define ALLOC(size) (malloc(size))

#endif

#ifndef TRYFREE

#define TRYFREE(p)                                                             \

    {                                                                          \

        if (p)                                                                 \

            free(p);                                                           \

    }

#endif

/*

#define SIZECENTRALDIRITEM (0x2e)

#define SIZEZIPLOCALHEADER (0x1e)

*/

/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined... */

#ifndef SEEK_CUR

#define SEEK_CUR 1

#endif

#ifndef SEEK_END

#define SEEK_END 2

#endif

#ifndef SEEK_SET

#define SEEK_SET 0

#endif

#ifndef DEF_MEM_LEVEL

#if MAX_MEM_LEVEL >= 8

#define DEF_MEM_LEVEL 8

#else

#define DEF_MEM_LEVEL MAX_MEM_LEVEL

#endif

#endif

CPL_UNUSED static const char zip_copyright[] =

    " zip 1.01 Copyright 1998-2004 Gilles Vollant - "

    "http://www.winimage.com/zLibDll";

#define SIZEDATA_INDATABLOCK (4096 - (4 * 4))

#define LOCALHEADERMAGIC (0x04034b50)

#define CENTRALHEADERMAGIC (0x02014b50)

#define ENDHEADERMAGIC (0x06054b50)

#define ZIP64ENDHEADERMAGIC (0x6064b50)

#define ZIP64ENDLOCHEADERMAGIC (0x7064b50)

#define FLAG_LOCALHEADER_OFFSET (0x06)

#define CRC_LOCALHEADER_OFFSET (0x0e)

#define SIZECENTRALHEADER (0x2e) /* 46 */

typedef struct linkedlist_datablock_internal_s

{

    struct linkedlist_datablock_internal_s *next_datablock;

    uLong avail_in_this_block;

    uLong filled_in_this_block;

    uLong unused;  // For future use and alignment.

    unsigned char data[SIZEDATA_INDATABLOCK];

} linkedlist_datablock_internal;

typedef struct linkedlist_data_s

{

    linkedlist_datablock_internal *first_block;

    linkedlist_datablock_internal *last_block;

} linkedlist_data;

typedef struct

{

    z_stream stream;           /* zLib stream structure for inflate */

    int stream_initialised;    /* 1 is stream is initialized */

    uInt pos_in_buffered_data; /* last written byte in buffered_data */

    ZPOS64_T pos_local_header; /* offset of the local header of the file

                                 currently writing */

    char *local_header;

    uInt size_local_header;

    uInt size_local_header_extrafield;

    char *central_header; /* central header data for the current file */

    uLong size_centralExtra;

    uLong size_centralheader;    /* size of the central header for cur file */

    uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader

                                    but that are not used */

    uLong flag;                  /* flag of the file currently writing */

    // TODO: What is "wr"?  "to"?

    int method;                    /* compression method of file currently wr.*/

    int raw;                       /* 1 for directly writing raw data */

    Byte buffered_data[Z_BUFSIZE]; /* buffer contain compressed data to be

                                        written. */

    uLong dosDate;

    uLong crc32;

    int encrypt;

    ZPOS64_T pos_zip64extrainfo;

    ZPOS64_T totalCompressedData;

    ZPOS64_T totalUncompressedData;

#ifndef NOCRYPT

    unsigned long keys[3]; /* keys defining the pseudo-random sequence */

    const unsigned long *pcrc_32_tab;

    int crypt_header_size;

#endif

} curfile64_info;

typedef struct

{

    zlib_filefunc_def z_filefunc;

    voidpf filestream;           /* IO structure of the zipfile */

    linkedlist_data central_dir; /* datablock with central dir in construction*/

    int in_opened_file_inzip;    /* 1 if a file in the zip is currently writ.*/

    curfile64_info ci;           /* info on the file currently writing */

    ZPOS64_T begin_pos; /* position of the beginning of the zipfile */

    ZPOS64_T add_position_when_writing_offset;

    ZPOS64_T number_entry;

#ifndef NO_ADDFILEINEXISTINGZIP

    char *globalcomment;

#endif

    int use_cpl_io;

    vsi_l_offset vsi_raw_length_before;

    VSIVirtualHandle *vsi_deflate_handle;

    size_t nChunkSize;

    int nThreads;

    size_t nOffsetSize;

    std::vector<uint8_t> *sozip_index;

} zip64_internal;

#ifndef NOCRYPT

#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED

#include "crypt.h"

#endif

static linkedlist_datablock_internal *allocate_new_datablock()

{

    linkedlist_datablock_internal *ldi;

    ldi = static_cast<linkedlist_datablock_internal *>(

        ALLOC(sizeof(linkedlist_datablock_internal)));

    if (ldi != nullptr)

    {

        ldi->next_datablock = nullptr;

        ldi->filled_in_this_block = 0;

        ldi->avail_in_this_block = SIZEDATA_INDATABLOCK;

    }

    return ldi;

}

static void free_datablock(linkedlist_datablock_internal *ldi)

{

    while (ldi != nullptr)

    {

        linkedlist_datablock_internal *ldinext = ldi->next_datablock;

        TRYFREE(ldi);

        ldi = ldinext;

    }

}

static void init_linkedlist(linkedlist_data *ll)

{

    ll->first_block = ll->last_block = nullptr;

}

static void free_linkedlist(linkedlist_data *ll)

{

    free_datablock(ll->first_block);

    ll->first_block = ll->last_block = nullptr;

}

static int add_data_in_datablock(linkedlist_data *ll, const void *buf,

                                 uLong len)

{

    linkedlist_datablock_internal *ldi;

    const unsigned char *from_copy;

    if (ll == nullptr)

        return ZIP_INTERNALERROR;

    if (ll->last_block == nullptr)

    {

        ll->first_block = ll->last_block = allocate_new_datablock();

        if (ll->first_block == nullptr)

            return ZIP_INTERNALERROR;

    }

    ldi = ll->last_block;

    from_copy = reinterpret_cast<const unsigned char *>(buf);

    while (len > 0)

    {

        uInt copy_this;

        uInt i;

        unsigned char *to_copy;

        if (ldi->avail_in_this_block == 0)

        {

            ldi->next_datablock = allocate_new_datablock();

            if (ldi->next_datablock == nullptr)

                return ZIP_INTERNALERROR;

            ldi = ldi->next_datablock;

            ll->last_block = ldi;

        }

        if (ldi->avail_in_this_block < len)

            copy_this = static_cast<uInt>(ldi->avail_in_this_block);

        else

            copy_this = static_cast<uInt>(len);

        to_copy = &(ldi->data[ldi->filled_in_this_block]);

        for (i = 0; i < copy_this; i++)

            *(to_copy + i) = *(from_copy + i);

        ldi->filled_in_this_block += copy_this;

        ldi->avail_in_this_block -= copy_this;

        from_copy += copy_this;

        len -= copy_this;

    }

    return ZIP_OK;

}

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

#ifndef NO_ADDFILEINEXISTINGZIP

/* ===========================================================================

   Inputs a long in LSB order to the given file

   nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T)

*/

static int zip64local_putValue(const zlib_filefunc_def *pzlib_filefunc_def,

                               voidpf filestream, ZPOS64_T x, int nbByte)

{

    unsigned char buf[8];

    for (int n = 0; n < nbByte; n++)

    {

        buf[n] = static_cast<unsigned char>(x & 0xff);

        x >>= 8;

    }

    if (x != 0)

    { /* data overflow - hack for ZIP64 (X Roche) */

        for (int n = 0; n < nbByte; n++)

        {

            buf[n] = 0xff;

        }

    }

    if (ZWRITE64(*pzlib_filefunc_def, filestream, buf, nbByte) !=

        static_cast<uLong>(nbByte))

        return ZIP_ERRNO;

    else

        return ZIP_OK;

}

static void zip64local_putValue_inmemory(void *dest, ZPOS64_T x, int nbByte)

{

    unsigned char *buf = reinterpret_cast<unsigned char *>(dest);

    for (int n = 0; n < nbByte; n++)

    {

        buf[n] = static_cast<unsigned char>(x & 0xff);

        x >>= 8;

    }

    if (x != 0)

    { /* data overflow - hack for ZIP64 */

        for (int n = 0; n < nbByte; n++)

        {

            buf[n] = 0xff;

        }

    }

}

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

static uLong zip64local_TmzDateToDosDate(const tm_zip *ptm)

{

    uLong year = static_cast<uLong>(ptm->tm_year);

    if (year > 1980)

        year -= 1980;

    else if (year > 80)

        year -= 80;

    return static_cast<uLong>(

               ((ptm->tm_mday) + (32 * (ptm->tm_mon + 1)) + (512 * year))

               << 16) |

           ((ptm->tm_sec / 2) + (32 * ptm->tm_min) +

            (2048 * static_cast<uLong>(ptm->tm_hour)));

}

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

static int zip64local_getByte(const zlib_filefunc_def *pzlib_filefunc_def,

                              voidpf filestream, int *pi)

{

    unsigned char c = 0;

    const int err =

        static_cast<int>(ZREAD64(*pzlib_filefunc_def, filestream, &c, 1));

    if (err == 1)

    {

        *pi = static_cast<int>(c);

        return ZIP_OK;

    }

    else

    {

        if (ZERROR64(*pzlib_filefunc_def, filestream))

            return ZIP_ERRNO;

        else

            return ZIP_EOF;

    }

}

/* ===========================================================================

   Reads a long in LSB order from the given gz_stream. Sets

*/

static int zip64local_getShort(const zlib_filefunc_def *pzlib_filefunc_def,

                               voidpf filestream, uLong *pX)

{

    int i = 0;

    int err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    uLong x = static_cast<uLong>(i);

    if (err == ZIP_OK)

        err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x += static_cast<uLong>(i) << 8;

    if (err == ZIP_OK)

        *pX = x;

    else

        *pX = 0;

    return err;

}

static int zip64local_getLong(const zlib_filefunc_def *pzlib_filefunc_def,

                              voidpf filestream, uLong *pX)

{

    int i = 0;

    int err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    uLong x = static_cast<uLong>(i);

    if (err == ZIP_OK)

        err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x += static_cast<uLong>(i) << 8;

    if (err == ZIP_OK)

        err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x += static_cast<uLong>(i) << 16;

    if (err == ZIP_OK)

        err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x += static_cast<uLong>(i) << 24;

    if (err == ZIP_OK)

        *pX = x;

    else

        *pX = 0;

    return err;

}

static int zip64local_getLong64(const zlib_filefunc_def *pzlib_filefunc_def,

                                voidpf filestream, ZPOS64_T *pX)

{

    ZPOS64_T x;

    int i = 0;

    int err;

    err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x = static_cast<ZPOS64_T>(i);

    if (err == ZIP_OK)

        err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x += static_cast<ZPOS64_T>(i) << 8;

    if (err == ZIP_OK)

        err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x += static_cast<ZPOS64_T>(i) << 16;

    if (err == ZIP_OK)

        err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x += static_cast<ZPOS64_T>(i) << 24;

    if (err == ZIP_OK)

        err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x += static_cast<ZPOS64_T>(i) << 32;

    if (err == ZIP_OK)

        err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x += static_cast<ZPOS64_T>(i) << 40;

    if (err == ZIP_OK)

        err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x += static_cast<ZPOS64_T>(i) << 48;

    if (err == ZIP_OK)

        err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);

    x += static_cast<ZPOS64_T>(i) << 56;

    if (err == ZIP_OK)

        *pX = x;

    else

        *pX = 0;

    return err;

}

#ifndef BUFREADCOMMENT

#define BUFREADCOMMENT (0x400)

#endif

/*

  Locate the Central directory of a zipfile (at the end, just before

    the global comment)

*/

static ZPOS64_T

zip64local_SearchCentralDir(const zlib_filefunc_def *pzlib_filefunc_def,

                            voidpf filestream)

{

    ZPOS64_T uMaxBack = 0xffff; /* maximum size of global comment */

    ZPOS64_T uPosFound = 0;

    if (ZSEEK64(*pzlib_filefunc_def, filestream, 0, ZLIB_FILEFUNC_SEEK_END) !=

        0)

        return 0;

    ZPOS64_T uSizeFile = ZTELL64(*pzlib_filefunc_def, filestream);

    if (uMaxBack > uSizeFile)

        uMaxBack = uSizeFile;

    unsigned char *buf =

        static_cast<unsigned char *>(ALLOC(BUFREADCOMMENT + 4));

    if (buf == nullptr)

        return 0;

    ZPOS64_T uBackRead = 4;

    while (uBackRead < uMaxBack)

    {

        if (uBackRead + BUFREADCOMMENT > uMaxBack)

            uBackRead = uMaxBack;

        else

            uBackRead += BUFREADCOMMENT;

        ZPOS64_T uReadPos = uSizeFile - uBackRead;

        uLong uReadSize = ((BUFREADCOMMENT + 4) < (uSizeFile - uReadPos))

                              ? (BUFREADCOMMENT + 4)

                              : static_cast<uLong>(uSizeFile - uReadPos);

        if (ZSEEK64(*pzlib_filefunc_def, filestream, uReadPos,

                    ZLIB_FILEFUNC_SEEK_SET) != 0)

            break;

        if (ZREAD64(*pzlib_filefunc_def, filestream, buf, uReadSize) !=

            uReadSize)

            break;

        for (int i = static_cast<int>(uReadSize) - 3; (i--) > 0;)

            if (((*(buf + i)) == 0x50) && ((*(buf + i + 1)) == 0x4b) &&

                ((*(buf + i + 2)) == 0x05) && ((*(buf + i + 3)) == 0x06))

            {

                uPosFound = uReadPos + i;

                break;

            }

        if (uPosFound != 0)

            break;

    }

    TRYFREE(buf);

    return uPosFound;

}

/*

Locate the End of Zip64 Central directory locator and from there find the CD of

a zipfile (at the end, just before the global comment)

*/

static ZPOS64_T

zip64local_SearchCentralDir64(const zlib_filefunc_def *pzlib_filefunc_def,

                              voidpf filestream)

{

    unsigned char *buf;

    ZPOS64_T uSizeFile;

    ZPOS64_T uBackRead;

    ZPOS64_T uMaxBack = 0xffff; /* maximum size of global comment */

    ZPOS64_T uPosFound = 0;

    uLong uL;

    ZPOS64_T relativeOffset;

    if (ZSEEK64(*pzlib_filefunc_def, filestream, 0, ZLIB_FILEFUNC_SEEK_END) !=

        0)

        return 0;

    uSizeFile = ZTELL64(*pzlib_filefunc_def, filestream);

    if (uMaxBack > uSizeFile)

        uMaxBack = uSizeFile;

    buf = static_cast<unsigned char *>(ALLOC(BUFREADCOMMENT + 4));

    if (buf == nullptr)

        return 0;

    uBackRead = 4;

    while (uBackRead < uMaxBack)

    {

        uLong uReadSize;

        ZPOS64_T uReadPos;

        int i;

        if (uBackRead + BUFREADCOMMENT > uMaxBack)

            uBackRead = uMaxBack;

        else

            uBackRead += BUFREADCOMMENT;

        uReadPos = uSizeFile - uBackRead;

        uReadSize = ((BUFREADCOMMENT + 4) < (uSizeFile - uReadPos))

                        ? (BUFREADCOMMENT + 4)

                        : static_cast<uLong>(uSizeFile - uReadPos);

        if (ZSEEK64(*pzlib_filefunc_def, filestream, uReadPos,

                    ZLIB_FILEFUNC_SEEK_SET) != 0)

            break;

        if (ZREAD64(*pzlib_filefunc_def, filestream, buf, uReadSize) !=

            uReadSize)

            break;

        for (i = static_cast<int>(uReadSize) - 3; (i--) > 0;)

        {

            // Signature "0x07064b50" Zip64 end of central directory locater

            if (((*(buf + i)) == 0x50) && ((*(buf + i + 1)) == 0x4b) &&

                ((*(buf + i + 2)) == 0x06) && ((*(buf + i + 3)) == 0x07))

            {

                uPosFound = uReadPos + i;

                break;

            }

        }

        if (uPosFound != 0)

            break;

    }

    TRYFREE(buf);

    if (uPosFound == 0)

        return 0;

    /* Zip64 end of central directory locator */

    if (ZSEEK64(*pzlib_filefunc_def, filestream, uPosFound,

                ZLIB_FILEFUNC_SEEK_SET) != 0)

        return 0;

    /* the signature, already checked */

    if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK)

        return 0;

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

     */

    if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK)

        return 0;

    if (uL != 0)

        return 0;

    /* relative offset of the zip64 end of central directory record */

    if (zip64local_getLong64(pzlib_filefunc_def, filestream, &relativeOffset) !=

        ZIP_OK)

        return 0;

    /* total number of disks */

    if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK)

        return 0;

    /* Some .zip declare 0 disks, such as in

     * http://trac.osgeo.org/gdal/ticket/5615 */

    if (uL != 0 && uL != 1)

        return 0;

    /* Goto Zip64 end of central directory record */

    if (ZSEEK64(*pzlib_filefunc_def, filestream, relativeOffset,

                ZLIB_FILEFUNC_SEEK_SET) != 0)

        return 0;

    /* the signature */

    if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK)

        return 0;

    if (uL != 0x06064b50)  // signature of 'Zip64 end of central directory'

        return 0;

    return relativeOffset;

}

static int LoadCentralDirectoryRecord(zip64_internal *pziinit)

{

    int err = ZIP_OK;

    ZPOS64_T byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx)*/

    ZPOS64_T size_central_dir;   /* size of the central directory  */

    ZPOS64_T offset_central_dir; /* offset of start of central directory */

    ZPOS64_T central_pos;

    uLong uL;

    uLong number_disk;         /* number of the current dist, used for

                               spanning ZIP, unsupported, always 0*/

    uLong number_disk_with_CD; /* number the disk with central dir, used

                               for spanning ZIP, unsupported, always 0*/

    ZPOS64_T number_entry;

    ZPOS64_T number_entry_CD; /* total number of entries in

                             the central dir

                             (same than number_entry on nospan) */

    uLong VersionMadeBy;

    uLong VersionNeeded;

    uLong size_comment;

    int hasZIP64Record = 0;

    // check first if we find a ZIP64 record

    central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,

                                                pziinit->filestream);

    if (central_pos > 0)

    {

        hasZIP64Record = 1;

    }

    else /* if (central_pos == 0) */

    {

        central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,

                                                  pziinit->filestream);

    }

    /* disable to allow appending to empty ZIP archive

            if (central_pos==0)

                err=ZIP_ERRNO;

    */

    if (hasZIP64Record)

    {

        ZPOS64_T sizeEndOfCentralDirectory;

        if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,

                    ZLIB_FILEFUNC_SEEK_SET) != 0)

            err = ZIP_ERRNO;

        /* the signature, already checked */

        if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,

                               &uL) != ZIP_OK)

            err = ZIP_ERRNO;

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

        if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,

                                 &sizeEndOfCentralDirectory) != ZIP_OK)

            err = ZIP_ERRNO;

        /* version made by */

        if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,

                                &VersionMadeBy) != ZIP_OK)

            err = ZIP_ERRNO;

        /* version needed to extract */

        if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,

                                &VersionNeeded) != ZIP_OK)

            err = ZIP_ERRNO;

        /* number of this disk */

        if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,

                               &number_disk) != ZIP_OK)

            err = ZIP_ERRNO;

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

        if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,

                               &number_disk_with_CD) != ZIP_OK)

            err = ZIP_ERRNO;

        /* total number of entries in the central directory on this disk */

        if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,

                                 &number_entry) != ZIP_OK)

            err = ZIP_ERRNO;

        /* total number of entries in the central directory */

        if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,

                                 &number_entry_CD) != ZIP_OK)

            err = ZIP_ERRNO;

        if ((number_entry_CD != number_entry) || (number_disk_with_CD != 0) ||

            (number_disk != 0))

            err = ZIP_BADZIPFILE;

        /* size of the central directory */

        if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,

                                 &size_central_dir) != ZIP_OK)

            err = ZIP_ERRNO;

        /* offset of start of central directory with respect to the

        starting disk number */

        if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,

                                 &offset_central_dir) != ZIP_OK)

            err = ZIP_ERRNO;

        // TODO..

        // read the comment from the standard central header.

        size_comment = 0;

    }

    else

    {

        // Read End of central Directory info

        if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,

                    ZLIB_FILEFUNC_SEEK_SET) != 0)

            err = ZIP_ERRNO;

        /* the signature, already checked */

        if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,

                               &uL) != ZIP_OK)

            err = ZIP_ERRNO;

        /* number of this disk */

        if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,

                                &number_disk) != ZIP_OK)

            err = ZIP_ERRNO;

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

        if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,

                                &number_disk_with_CD) != ZIP_OK)

            err = ZIP_ERRNO;

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

        number_entry = 0;

        if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,

                                &uL) != ZIP_OK)

            err = ZIP_ERRNO;

        else

            number_entry = uL;

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

        number_entry_CD = 0;

        if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,

                                &uL) != ZIP_OK)

            err = ZIP_ERRNO;

        else

            number_entry_CD = uL;

        if ((number_entry_CD != number_entry) || (number_disk_with_CD != 0) ||

            (number_disk != 0))

            err = ZIP_BADZIPFILE;

        /* size of the central directory */

        size_central_dir = 0;

        if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,

                               &uL) != ZIP_OK)

            err = ZIP_ERRNO;

        else

            size_central_dir = uL;

        /* offset of start of central directory with respect to the starting

         * disk number */

        offset_central_dir = 0;

        if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,

                               &uL) != ZIP_OK)

            err = ZIP_ERRNO;

        else

            offset_central_dir = uL;

        /* zipfile global comment length */

        if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,

                                &size_comment) != ZIP_OK)

            err = ZIP_ERRNO;

    }

    if ((central_pos < offset_central_dir + size_central_dir) &&

        (err == ZIP_OK))

        err = ZIP_BADZIPFILE;

    if (err != ZIP_OK)

    {

        ZCLOSE64(pziinit->z_filefunc, pziinit->filestream);

        return ZIP_ERRNO;

    }

    if (size_comment > 0)

    {

        pziinit->globalcomment = static_cast<char *>(ALLOC(size_comment + 1));

        if (pziinit->globalcomment)

        {

            size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream,

                                   pziinit->globalcomment, size_comment);

            pziinit->globalcomment[size_comment] = 0;

        }

    }

    byte_before_the_zipfile =

        central_pos - (offset_central_dir + size_central_dir);

    pziinit->add_position_when_writing_offset = byte_before_the_zipfile;

    {

        ZPOS64_T size_central_dir_to_read = size_central_dir;

        size_t buf_size = SIZEDATA_INDATABLOCK;

        void *buf_read = ALLOC(buf_size);

        if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream,

                    offset_central_dir + byte_before_the_zipfile,

                    ZLIB_FILEFUNC_SEEK_SET) != 0)

            err = ZIP_ERRNO;

        while ((size_central_dir_to_read > 0) && (err == ZIP_OK))

        {

            ZPOS64_T read_this = SIZEDATA_INDATABLOCK;

            if (read_this > size_central_dir_to_read)

                read_this = size_central_dir_to_read;

            if (ZREAD64(pziinit->z_filefunc, pziinit->filestream, buf_read,

                        static_cast<uLong>(read_this)) != read_this)

                err = ZIP_ERRNO;

            if (err == ZIP_OK)

                err = add_data_in_datablock(&pziinit->central_dir, buf_read,

                                            static_cast<uLong>(read_this));

            size_central_dir_to_read -= read_this;

        }

        TRYFREE(buf_read);

    }

    pziinit->begin_pos = byte_before_the_zipfile;

    pziinit->number_entry = number_entry_CD;

    if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream,

                offset_central_dir + byte_before_the_zipfile,

                ZLIB_FILEFUNC_SEEK_SET) != 0)

        err = ZIP_ERRNO;

    return err;

}

#endif /* !NO_ADDFILEINEXISTINGZIP*/

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

extern zipFile ZEXPORT cpl_zipOpen2(const char *pathname, int append,

                                    zipcharpc *globalcomment,

                                    zlib_filefunc_def *pzlib_filefunc_def)

{

    zip64_internal ziinit;

    memset(&ziinit, 0, sizeof(ziinit));

    if (pzlib_filefunc_def == nullptr)

        cpl_fill_fopen_filefunc(&ziinit.z_filefunc);

    else

        ziinit.z_filefunc = *pzlib_filefunc_def;

    ziinit.filestream = (*(ziinit.z_filefunc.zopen_file))(

        ziinit.z_filefunc.opaque, pathname,

        (append == APPEND_STATUS_CREATE)

            ? (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE |

               ZLIB_FILEFUNC_MODE_CREATE)

            : (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE |

               ZLIB_FILEFUNC_MODE_EXISTING));

    if (ziinit.filestream == nullptr)

        return nullptr;

    if (append == APPEND_STATUS_CREATEAFTER)

        ZSEEK64(ziinit.z_filefunc, ziinit.filestream, 0, SEEK_END);

    ziinit.begin_pos = ZTELL64(ziinit.z_filefunc, ziinit.filestream);

    ziinit.in_opened_file_inzip = 0;

    ziinit.ci.stream_initialised = 0;

    ziinit.number_entry = 0;

    ziinit.add_position_when_writing_offset = 0;

    ziinit.use_cpl_io = (pzlib_filefunc_def == nullptr) ? 1 : 0;

    ziinit.vsi_raw_length_before = 0;

    ziinit.vsi_deflate_handle = nullptr;

    ziinit.nChunkSize = 0;

    ziinit.nThreads = 0;

    ziinit.nOffsetSize = 0;

    ziinit.sozip_index = nullptr;

    init_linkedlist(&(ziinit.central_dir));

    zip64_internal *zi =

        static_cast<zip64_internal *>(ALLOC(sizeof(zip64_internal)));

    if (zi == nullptr)

    {

        ZCLOSE64(ziinit.z_filefunc, ziinit.filestream);

        return nullptr;

    }

    /* now we add file in a zipfile */

#ifndef NO_ADDFILEINEXISTINGZIP

    ziinit.globalcomment = nullptr;

    int err = ZIP_OK;

    if (append == APPEND_STATUS_ADDINZIP)

    {

        // Read and Cache Central Directory Records

        err = LoadCentralDirectoryRecord(&ziinit);

    }

    if (globalcomment)

    {

        *globalcomment = ziinit.globalcomment;

    }

#endif /* !NO_ADDFILEINEXISTINGZIP*/

    if (err != ZIP_OK)

    {

#ifndef NO_ADDFILEINEXISTINGZIP

        TRYFREE(ziinit.globalcomment);

#endif /* !NO_ADDFILEINEXISTINGZIP*/

        TRYFREE(zi);

        return nullptr;

    }

    else

    {

        *zi = ziinit;

        return static_cast<zipFile>(zi);

    }

}

extern zipFile ZEXPORT cpl_zipOpen(const char *pathname, int append)

{

    return cpl_zipOpen2(pathname, append, nullptr, nullptr);

}

static void zip64local_putValue_inmemory_update(char **dest, ZPOS64_T x,

                                                int nbByte)

{

    zip64local_putValue_inmemory(*dest, x, nbByte);

    *dest += nbByte;

}

static int Write_LocalFileHeader(zip64_internal *zi, const char *filename,

                                 uInt size_extrafield_local,

                                 const void *extrafield_local, int zip64)