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

 *

 * Project:  CPL - Common Portability Library

 * Purpose:  Implement VSI large file api for gz/zip files (.gz and .zip).

 * Author:   Even Rouault, even.rouault at spatialys.com

 *

 ******************************************************************************

 * Copyright (c) 2008-2014, Even Rouault <even dot rouault at spatialys.com>

 *

 * SPDX-License-Identifier: MIT

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

//! @cond Doxygen_Suppress

/* gzio.c -- IO on .gz files

  Copyright (C) 1995-2005 Jean-loup Gailly.

  This software is provided 'as-is', without any express or implied

  warranty.  In no event will the authors be held liable for any damages

  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,

  including commercial applications, and to alter it and redistribute it

  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not

     claim that you wrote the original software. If you use this software

     in a product, an acknowledgment in the product documentation would be

     appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be

     misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

  Jean-loup Gailly        Mark Adler

  jloup@gzip.org          madler@alumni.caltech.edu

  The data format used by the zlib library is described by RFCs (Request for

  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt

  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).

*/

/* This file contains a refactoring of gzio.c from zlib project.

   It replaces classical calls operating on FILE* by calls to the VSI large file

   API. It also adds the capability to seek at the end of the file, which is not

   implemented in original gzSeek. It also implements a concept of in-memory

   "snapshots", that are a way of improving efficiency while seeking GZip

   files. Snapshots are created regularly when decompressing the data a snapshot

   of the gzip state.  Later we can seek directly in the compressed data to the

   closest snapshot in order to reduce the amount of data to uncompress again.

   For .gz files, an effort is done to cache the size of the uncompressed data

   in a .gz.properties file, so that we don't need to seek at the end of the

   file each time a Stat() is done.

   For .zip and .gz, both reading and writing are supported, but just one mode

   at a time (read-only or write-only).

*/

#include "cpl_port.h"

#include "cpl_conv.h"

#include "cpl_vsi.h"

#include <cerrno>

#include <cinttypes>

#include <climits>

#include <cstddef>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <fcntl.h>

#include "cpl_zlib_header.h"  // to avoid warnings when including zlib.h

#ifdef HAVE_LIBDEFLATE

#include "libdeflate.h"

#endif

#include <algorithm>

#include <iterator>

#include <limits>

#include <list>

#include <map>

#include <memory>

#include <mutex>

#include <string>

#include <utility>

#include <vector>

#include "cpl_error.h"

#include "cpl_minizip_ioapi.h"

#include "cpl_minizip_unzip.h"

#include "cpl_multiproc.h"

#include "cpl_string.h"

#include "cpl_time.h"

#include "cpl_vsi_virtual.h"

#include "cpl_worker_thread_pool.h"

#include "../gcore/gdal_thread_pool.h"

constexpr int Z_BUFSIZE = 65536;           // Original size is 16384

constexpr int gz_magic[2] = {0x1f, 0x8b};  // gzip magic header

// gzip flag byte.

#define ASCII_FLAG 0x01   // bit 0 set: file probably ascii text

#define HEAD_CRC 0x02     // bit 1 set: header CRC present

#define EXTRA_FIELD 0x04  // bit 2 set: extra field present

#define ORIG_NAME 0x08    // bit 3 set: original file name present

#define COMMENT 0x10      // bit 4 set: file comment present

#define RESERVED 0xE0     // bits 5..7: reserved

#define ALLOC(size) malloc(size)

#define TRYFREE(p)                                                             \

    {                                                                          \

        if (p)                                                                 \

            free(p);                                                           \

    }

#define CPL_VSIL_GZ_RETURN(ret)                                                \

    CPLError(CE_Failure, CPLE_AppDefined, "In file %s, at line %d, return %d", \

             __FILE__, __LINE__, ret)

// To avoid aliasing to CopyFile to CopyFileA on Windows

#ifdef CopyFile

#undef CopyFile

#endif

// #define ENABLE_DEBUG 1

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

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

/*                       VSIGZipHandle                                  */

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

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

typedef struct

{

    vsi_l_offset posInBaseHandle;

    z_stream stream;

    uLong crc;

    int transparent;

    vsi_l_offset in;

    vsi_l_offset out;

} GZipSnapshot;

class VSIGZipHandle final : public VSIVirtualHandle

{

    VSIVirtualHandleUniquePtr m_poBaseHandle{};

#ifdef DEBUG

    vsi_l_offset m_offset = 0;

#endif

    vsi_l_offset m_compressed_size = 0;

    vsi_l_offset m_uncompressed_size = 0;

    vsi_l_offset offsetEndCompressedData = 0;

    uLong m_expected_crc = 0;

    char *m_pszBaseFileName = nullptr; /* optional */

    bool m_bWriteProperties = false;

    bool m_bCanSaveInfo = false;

    /* Fields from gz_stream structure */

    z_stream stream;

    int z_err = Z_OK;    /* error code for last stream operation */

    int z_eof = 0;       /* set if end of input file (but not necessarily of the

                         uncompressed stream !) */

    bool m_bEOF = false; /* EOF flag for uncompressed stream */

    Byte *inbuf = nullptr;  /* input buffer */

    Byte *outbuf = nullptr; /* output buffer */

    uLong crc = 0;          /* crc32 of uncompressed data */

    int m_transparent = 0;  /* 1 if input file is not a .gz file */

    vsi_l_offset startOff =

        0; /* startOff of compressed data in file (header skipped) */

    vsi_l_offset in = 0;  /* bytes into deflate or inflate */

    vsi_l_offset out = 0; /* bytes out of deflate or inflate */

    vsi_l_offset m_nLastReadOffset = 0;

    GZipSnapshot *snapshots = nullptr;

    vsi_l_offset snapshot_byte_interval =

        0; /* number of compressed bytes at which we create a "snapshot" */

    void check_header();

    int get_byte();

    bool gzseek(vsi_l_offset nOffset, int nWhence);

    int gzrewind();

    uLong getLong();

    CPL_DISALLOW_COPY_ASSIGN(VSIGZipHandle)

  public:

    VSIGZipHandle(VSIVirtualHandleUniquePtr poBaseHandleIn,

                  const char *pszBaseFileName, vsi_l_offset offset = 0,

                  vsi_l_offset compressed_size = 0,

                  vsi_l_offset uncompressed_size = 0, uLong expected_crc = 0,

                  int transparent = 0);

    ~VSIGZipHandle() override;

    bool IsInitOK() const

    {

        return inbuf != nullptr;

    }

    int Seek(vsi_l_offset nOffset, int nWhence) override;

    vsi_l_offset Tell() override;

    size_t Read(void *pBuffer, size_t nBytes) override;

    size_t Write(const void *pBuffer, size_t nBytes) override;

    void ClearErr() override;

    int Eof() override;

    int Error() override;

    int Flush() override;

    int Close() override;

    VSIGZipHandle *Duplicate();

    bool CloseBaseHandle();

    vsi_l_offset GetLastReadOffset()

    {

        return m_nLastReadOffset;

    }

    const char *GetBaseFileName()

    {

        return m_pszBaseFileName;

    }

    void SetUncompressedSize(vsi_l_offset nUncompressedSize)

    {

        m_uncompressed_size = nUncompressedSize;

    }

    vsi_l_offset GetUncompressedSize()

    {

        return m_uncompressed_size;

    }

    void SaveInfo_unlocked();

    void UnsetCanSaveInfo()

    {

        m_bCanSaveInfo = false;

    }

};

#ifdef ENABLE_DEFLATE64

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

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

/*                           VSIDeflate64Handle                         */

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

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

struct VSIDeflate64Snapshot

{

    vsi_l_offset posInBaseHandle = 0;

    z_stream stream{};

    uLong crc = 0;

    vsi_l_offset in = 0;

    vsi_l_offset out = 0;

    std::vector<GByte> extraOutput{};

    bool m_bStreamEndReached = false;

};

class VSIDeflate64Handle final : public VSIVirtualHandle

{

    VSIVirtualHandleUniquePtr m_poBaseHandle{};

#ifdef DEBUG

    vsi_l_offset m_offset = 0;

#endif

    vsi_l_offset m_compressed_size = 0;

    vsi_l_offset m_uncompressed_size = 0;

    vsi_l_offset offsetEndCompressedData = 0;

    uLong m_expected_crc = 0;

    char *m_pszBaseFileName = nullptr; /* optional */

    /* Fields from gz_stream structure */

    z_stream stream;

    int z_err = Z_OK;    /* error code for last stream operation */

    int z_eof = 0;       /* set if end of input file (but not necessarily of the

                         uncompressed stream ! ) */

    bool m_bEOF = false; /* EOF flag for uncompressed stream */

    Byte *inbuf = nullptr;  /* input buffer */

    Byte *outbuf = nullptr; /* output buffer */

    std::vector<GByte> extraOutput{};

    bool m_bStreamEndReached = false;

    uLong crc = 0; /* crc32 of uncompressed data */

    vsi_l_offset startOff =

        0; /* startOff of compressed data in file (header skipped) */

    vsi_l_offset in = 0;  /* bytes into deflate or inflate */

    vsi_l_offset out = 0; /* bytes out of deflate or inflate */

    std::vector<VSIDeflate64Snapshot> snapshots{};

    vsi_l_offset snapshot_byte_interval =

        0; /* number of compressed bytes at which we create a "snapshot" */

    bool gzseek(vsi_l_offset nOffset, int nWhence);

    int gzrewind();

    CPL_DISALLOW_COPY_ASSIGN(VSIDeflate64Handle)

  public:

    VSIDeflate64Handle(VSIVirtualHandleUniquePtr poBaseHandleIn,

                       const char *pszBaseFileName, vsi_l_offset offset = 0,

                       vsi_l_offset compressed_size = 0,

                       vsi_l_offset uncompressed_size = 0,

                       uLong expected_crc = 0);

    ~VSIDeflate64Handle() override;

    bool IsInitOK() const

    {

        return inbuf != nullptr;

    }

    int Seek(vsi_l_offset nOffset, int nWhence) override;

    vsi_l_offset Tell() override;

    size_t Read(void *pBuffer, size_t nBytes) override;

    size_t Write(const void *pBuffer, size_t nBytes) override;

    void ClearErr() override;

    int Eof() override;

    int Error() override;

    int Flush() override;

    int Close() override;

    VSIDeflate64Handle *Duplicate();

    bool CloseBaseHandle();

    const char *GetBaseFileName()

    {

        return m_pszBaseFileName;

    }

    void SetUncompressedSize(vsi_l_offset nUncompressedSize)

    {

        m_uncompressed_size = nUncompressedSize;

    }

    vsi_l_offset GetUncompressedSize()

    {

        return m_uncompressed_size;

    }

};

#endif

class VSIGZipFilesystemHandler final : public VSIFilesystemHandler

{

    CPL_DISALLOW_COPY_ASSIGN(VSIGZipFilesystemHandler)

    std::recursive_mutex oMutex{};

    std::unique_ptr<VSIGZipHandle> poHandleLastGZipFile{};

    bool m_bInSaveInfo = false;

  public:

    VSIGZipFilesystemHandler() = default;

    ~VSIGZipFilesystemHandler() override;

    VSIVirtualHandleUniquePtr Open(const char *pszFilename,

                                   const char *pszAccess, bool bSetError,

                                   CSLConstList /* papszOptions */) override;

    VSIGZipHandle *OpenGZipReadOnly(const char *pszFilename,

                                    const char *pszAccess);

    int Stat(const char *pszFilename, VSIStatBufL *pStatBuf,

             int nFlags) override;

    char **ReadDirEx(const char *pszDirname, int nMaxFiles) override;

    const char *GetOptions() override;

    virtual bool SupportsSequentialWrite(const char *pszPath,

                                         bool bAllowLocalTempFile) override;

    virtual bool SupportsRandomWrite(const char * /* pszPath */,

                                     bool /* bAllowLocalTempFile */) override

    {

        return false;

    }

    void SaveInfo(VSIGZipHandle *poHandle);

    void SaveInfo_unlocked(VSIGZipHandle *poHandle);

};

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

/*                             Duplicate()                              */

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

VSIGZipHandle *VSIGZipHandle::Duplicate()

{

    CPLAssert(m_offset == 0);

    CPLAssert(m_compressed_size != 0);

    CPLAssert(m_pszBaseFileName != nullptr);

    VSIFilesystemHandler *poFSHandler =

        VSIFileManager::GetHandler(m_pszBaseFileName);

    auto poNewBaseHandle = poFSHandler->Open(m_pszBaseFileName, "rb");

    if (poNewBaseHandle == nullptr)

        return nullptr;

    auto poHandle = std::make_unique<VSIGZipHandle>(

        std::move(poNewBaseHandle), m_pszBaseFileName, 0, m_compressed_size,

        m_uncompressed_size);

    if (!(poHandle->IsInitOK()))

    {

        return nullptr;

    }

    poHandle->m_nLastReadOffset = m_nLastReadOffset;

    // Most important: duplicate the snapshots!

    for (unsigned int i = 0; i < m_compressed_size / snapshot_byte_interval + 1;

         i++)

    {

        if (snapshots[i].posInBaseHandle == 0)

            break;

        poHandle->snapshots[i].posInBaseHandle = snapshots[i].posInBaseHandle;

        inflateCopy(&poHandle->snapshots[i].stream, &snapshots[i].stream);

        poHandle->snapshots[i].crc = snapshots[i].crc;

        poHandle->snapshots[i].transparent = snapshots[i].transparent;

        poHandle->snapshots[i].in = snapshots[i].in;

        poHandle->snapshots[i].out = snapshots[i].out;

    }

    return poHandle.release();

}

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

/*                          CloseBaseHandle()                           */

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

bool VSIGZipHandle::CloseBaseHandle()

{

    bool bRet = true;

    if (m_poBaseHandle)

    {

        bRet = m_poBaseHandle->Close() == 0;

        m_poBaseHandle.reset();

    }

    return bRet;

}

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

/*                           VSIGZipHandle()                            */

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

VSIGZipHandle::VSIGZipHandle(VSIVirtualHandleUniquePtr poBaseHandleIn,

                             const char *pszBaseFileName, vsi_l_offset offset,

                             vsi_l_offset compressed_size,

                             vsi_l_offset uncompressed_size, uLong expected_crc,

                             int transparent)

    : m_poBaseHandle(std::move(poBaseHandleIn)),

#ifdef DEBUG

      m_offset(offset),

#endif

      m_uncompressed_size(uncompressed_size), m_expected_crc(expected_crc),

      m_pszBaseFileName(pszBaseFileName ? CPLStrdup(pszBaseFileName) : nullptr),

      m_bWriteProperties(CPLTestBool(

          CPLGetConfigOption("CPL_VSIL_GZIP_WRITE_PROPERTIES", "YES"))),

      m_bCanSaveInfo(

          CPLTestBool(CPLGetConfigOption("CPL_VSIL_GZIP_SAVE_INFO", "YES"))),

      stream(), crc(0), m_transparent(transparent)

{

    if (compressed_size || transparent)

    {

        m_compressed_size = compressed_size;

    }

    else

    {

        if (m_poBaseHandle->Seek(0, SEEK_END) != 0)

        {

            CPLError(CE_Failure, CPLE_FileIO, "Seek() failed");

            return;

        }

        const auto nFileSize = m_poBaseHandle->Tell();

        if (nFileSize < offset)

        {

            CPLError(CE_Failure, CPLE_FileIO, "/vsizip/: invalid file offset");

            return;

        }

        m_compressed_size = nFileSize - offset;

        compressed_size = m_compressed_size;

    }

    offsetEndCompressedData = offset + compressed_size;

    if (m_poBaseHandle->Seek(offset, SEEK_SET) != 0)

        CPLError(CE_Failure, CPLE_FileIO, "Seek() failed");

    stream.zalloc = nullptr;

    stream.zfree = nullptr;

    stream.opaque = nullptr;

    stream.next_in = inbuf = nullptr;

    stream.next_out = outbuf = nullptr;

    stream.avail_in = stream.avail_out = 0;

    inbuf = static_cast<Byte *>(ALLOC(Z_BUFSIZE));

    stream.next_in = inbuf;

    int err = inflateInit2(&(stream), -MAX_WBITS);

    // windowBits is passed < 0 to tell that there is no zlib header.

    // Note that in this case inflate *requires* an extra "dummy" byte

    // after the compressed stream in order to complete decompression and

    // return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are

    // present after the compressed stream.

    if (err != Z_OK || inbuf == nullptr)

    {

        CPLError(CE_Failure, CPLE_NotSupported, "inflateInit2 init failed");

        TRYFREE(inbuf);

        inbuf = nullptr;

        return;

    }

    stream.avail_out = static_cast<uInt>(Z_BUFSIZE);

    if (offset == 0)

        check_header();  // Skip the .gz header.

    startOff = m_poBaseHandle->Tell() - stream.avail_in;

    if (transparent == 0)

    {

        snapshot_byte_interval = std::max(static_cast<vsi_l_offset>(Z_BUFSIZE),

                                          compressed_size / 100);

        snapshots = static_cast<GZipSnapshot *>(CPLCalloc(

            sizeof(GZipSnapshot),

            static_cast<size_t>(compressed_size / snapshot_byte_interval + 1)));

    }

}

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

/*                         SaveInfo_unlocked()                          */

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

void VSIGZipHandle::SaveInfo_unlocked()

{

    if (m_pszBaseFileName && m_bCanSaveInfo)

    {

        VSIFilesystemHandler *poFSHandler =

            VSIFileManager::GetHandler("/vsigzip/");

        cpl::down_cast<VSIGZipFilesystemHandler *>(poFSHandler)

            ->SaveInfo_unlocked(this);

        m_bCanSaveInfo = false;

    }

}

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

/*                           ~VSIGZipHandle()                           */

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

VSIGZipHandle::~VSIGZipHandle()

{

    if (m_pszBaseFileName && m_bCanSaveInfo)

    {

        VSIFilesystemHandler *poFSHandler =

            VSIFileManager::GetHandler("/vsigzip/");

        cpl::down_cast<VSIGZipFilesystemHandler *>(poFSHandler)->SaveInfo(this);

    }

    if (stream.state != nullptr)

    {

        inflateEnd(&(stream));

    }

    TRYFREE(inbuf);

    TRYFREE(outbuf);

    if (snapshots != nullptr)

    {

        for (size_t i = 0; i < m_compressed_size / snapshot_byte_interval + 1;

             i++)

        {

            if (snapshots[i].posInBaseHandle)

            {

                inflateEnd(&(snapshots[i].stream));

            }

        }

        CPLFree(snapshots);

    }

    CPLFree(m_pszBaseFileName);

    CloseBaseHandle();

}

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

/*                            check_header()                            */

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

void VSIGZipHandle::check_header()

{

    // Assure two bytes in the buffer so we can peek ahead -- handle case

    // where first byte of header is at the end of the buffer after the last

    // gzip segment.

    uInt len = stream.avail_in;

    if (len < 2)

    {

        if (len)

            inbuf[0] = stream.next_in[0];

        errno = 0;

        size_t nToRead = static_cast<size_t>(Z_BUFSIZE - len);

        CPLAssert(m_poBaseHandle->Tell() <= offsetEndCompressedData);

        if (m_poBaseHandle->Tell() + nToRead > offsetEndCompressedData)

            nToRead = static_cast<size_t>(offsetEndCompressedData -

                                          m_poBaseHandle->Tell());

        len = static_cast<uInt>(m_poBaseHandle->Read(inbuf + len, nToRead));

#ifdef ENABLE_DEBUG

        CPLDebug("GZIP", CPL_FRMT_GUIB " " CPL_FRMT_GUIB,

                 m_poBaseHandle->Tell(), offsetEndCompressedData);

#endif

        if (len == 0)  // && ferror(file)

        {

            if (m_poBaseHandle->Tell() != offsetEndCompressedData)

                z_err = Z_ERRNO;

        }

        stream.avail_in += len;

        stream.next_in = inbuf;

        if (stream.avail_in < 2)

        {

            m_transparent = stream.avail_in;

            return;

        }

    }

    // Peek ahead to check the gzip magic header.

    if (stream.next_in[0] != gz_magic[0] || stream.next_in[1] != gz_magic[1])

    {

        m_transparent = 1;

        return;

    }

    stream.avail_in -= 2;

    stream.next_in += 2;

    // Check the rest of the gzip header.

    const int method = get_byte();

    const int flags = get_byte();

    if (method != Z_DEFLATED || (flags & RESERVED) != 0)

    {

        z_err = Z_DATA_ERROR;

        return;

    }

    // Discard time, xflags and OS code:

    for (len = 0; len < 6; len++)

        CPL_IGNORE_RET_VAL(get_byte());

    if ((flags & EXTRA_FIELD) != 0)

    {

        // Skip the extra field.

        len = static_cast<uInt>(get_byte()) & 0xFF;

        len += (static_cast<uInt>(get_byte()) & 0xFF) << 8;

        // len is garbage if EOF but the loop below will quit anyway.

        while (len != 0 && get_byte() != EOF)

        {

            --len;

        }

    }

    if ((flags & ORIG_NAME) != 0)

    {

        // Skip the original file name.

        int c;

        while ((c = get_byte()) != 0 && c != EOF)

        {

        }

    }

    if ((flags & COMMENT) != 0)

    {

        // skip the .gz file comment.

        int c;

        while ((c = get_byte()) != 0 && c != EOF)

        {

        }

    }

    if ((flags & HEAD_CRC) != 0)

    {

        // Skip the header crc.

        for (len = 0; len < 2; len++)

            CPL_IGNORE_RET_VAL(get_byte());

    }

    z_err = z_eof ? Z_DATA_ERROR : Z_OK;

}

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

/*                              get_byte()                              */

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

int VSIGZipHandle::get_byte()

{

    if (z_eof)

        return EOF;

    if (stream.avail_in == 0)

    {

        errno = 0;

        size_t nToRead = static_cast<size_t>(Z_BUFSIZE);

        CPLAssert(m_poBaseHandle->Tell() <= offsetEndCompressedData);

        if (m_poBaseHandle->Tell() + nToRead > offsetEndCompressedData)

            nToRead = static_cast<size_t>(offsetEndCompressedData -

                                          m_poBaseHandle->Tell());

        stream.avail_in =

            static_cast<uInt>(m_poBaseHandle->Read(inbuf, nToRead));

#ifdef ENABLE_DEBUG

        CPLDebug("GZIP", CPL_FRMT_GUIB " " CPL_FRMT_GUIB,

                 m_poBaseHandle->Tell(), offsetEndCompressedData);

#endif

        if (stream.avail_in == 0)

        {

            z_eof = 1;

            if (m_poBaseHandle->Tell() != offsetEndCompressedData)

                z_err = Z_ERRNO;

            // if( ferror(file) ) z_err = Z_ERRNO;

            return EOF;

        }

        stream.next_in = inbuf;

    }

    stream.avail_in--;

    return *(stream.next_in)++;

}

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

/*                              gzrewind()                              */

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

int VSIGZipHandle::gzrewind()

{

    z_err = Z_OK;

    z_eof = 0;

    m_bEOF = false;

    stream.avail_in = 0;

    stream.next_in = inbuf;

    crc = 0;

    if (!m_transparent)

        CPL_IGNORE_RET_VAL(inflateReset(&stream));

    in = 0;

    out = 0;

    return m_poBaseHandle->Seek(startOff, SEEK_SET);

}

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

/*                                Seek()                                */

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

int VSIGZipHandle::Seek(vsi_l_offset nOffset, int nWhence)

{

    m_bEOF = false;

    return gzseek(nOffset, nWhence) ? 0 : -1;

}

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

/*                               gzseek()                               */

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

bool VSIGZipHandle::gzseek(vsi_l_offset offset, int whence)

{

    const vsi_l_offset original_offset = offset;

    const int original_nWhence = whence;

    z_eof = 0;

#ifdef ENABLE_DEBUG

    CPLDebug("GZIP", "Seek(" CPL_FRMT_GUIB ",%d)", offset, whence);

#endif

    if (m_transparent)

    {

        stream.avail_in = 0;

        stream.next_in = inbuf;

        if (whence == SEEK_CUR)

        {

            if (out + offset > m_compressed_size)

            {

                CPL_VSIL_GZ_RETURN(FALSE);

                return false;

            }

            offset = startOff + out + offset;

        }

        else if (whence == SEEK_SET)

        {

            if (offset > m_compressed_size)

            {

                CPL_VSIL_GZ_RETURN(FALSE);

                return false;

            }

            offset = startOff + offset;

        }

        else if (whence == SEEK_END)

        {

            // Commented test: because vsi_l_offset is unsigned (for the moment)

            // so no way to seek backward. See #1590 */

            if (offset > 0)  // || -offset > compressed_size

            {

                CPL_VSIL_GZ_RETURN(FALSE);

                return false;

            }

            offset = startOff + m_compressed_size - offset;

        }

        else

        {

            CPL_VSIL_GZ_RETURN(FALSE);

            return false;

        }

        if (m_poBaseHandle->Seek(offset, SEEK_SET) < 0)

        {

            CPL_VSIL_GZ_RETURN(FALSE);

            return false;

        }

        out = offset - startOff;

        in = out;

        return true;

    }

    // whence == SEEK_END is unsuppored in original gzseek.

    if (whence == SEEK_END)

    {

        // If we known the uncompressed size, we can fake a jump to

        // the end of the stream.

        if (offset == 0 && m_uncompressed_size != 0)

        {

            out = m_uncompressed_size;

            return true;

        }

        // We don't know the uncompressed size. This is unfortunate.

        // Do the slow version.

        static int firstWarning = 1;

        if (m_compressed_size > 10 * 1024 * 1024 && firstWarning)

        {

            CPLError(CE_Warning, CPLE_AppDefined,

                     "VSIFSeekL(xxx, SEEK_END) may be really slow "

                     "on GZip streams.");

            firstWarning = 0;

        }

        whence = SEEK_CUR;

        offset = 1024 * 1024 * 1024;

        offset *= 1024 * 1024;

    }

    // Rest of function is for reading only.

    // Compute absolute position.

    if (whence == SEEK_CUR)

    {

        offset += out;

    }

    // For a negative seek, rewind and use positive seek.

    if (offset >= out)

    {

        offset -= out;

    }

    else if (gzrewind() < 0)

    {

        CPL_VSIL_GZ_RETURN(FALSE);

        return false;

    }

    if (z_err != Z_OK && z_err != Z_STREAM_END)

    {

        CPL_VSIL_GZ_RETURN(FALSE);

        return false;

    }

    for (unsigned int i = 0; i < m_compressed_size / snapshot_byte_interval + 1;

         i++)

    {

        if (snapshots[i].posInBaseHandle == 0)

            break;

        if (snapshots[i].out <= out + offset &&

            (i == m_compressed_size / snapshot_byte_interval ||

             snapshots[i + 1].out == 0 || snapshots[i + 1].out > out + offset))

        {

            if (out >= snapshots[i].out)

                break;

#ifdef ENABLE_DEBUG

            CPLDebug("SNAPSHOT",

                     "using snapshot %d : "

                     "posInBaseHandle(snapshot)=" CPL_FRMT_GUIB

                     " in(snapshot)=" CPL_FRMT_GUIB

                     " out(snapshot)=" CPL_FRMT_GUIB " out=" CPL_FRMT_GUIB

                     " offset=" CPL_FRMT_GUIB,

                     i, snapshots[i].posInBaseHandle, snapshots[i].in,

                     snapshots[i].out, out, offset);

#endif

            offset = out + offset - snapshots[i].out;

            if (m_poBaseHandle->Seek(snapshots[i].posInBaseHandle, SEEK_SET) !=

                0)

                CPLError(CE_Failure, CPLE_FileIO, "Seek() failed");

            inflateEnd(&stream);

            inflateCopy(&stream, &snapshots[i].stream);

            crc = snapshots[i].crc;

            m_transparent = snapshots[i].transparent;

            in = snapshots[i].in;

            out = snapshots[i].out;

            break;

        }

    }

    // Offset is now the number of bytes to skip.

    if (offset != 0 && outbuf == nullptr)

    {

        outbuf = static_cast<Byte *>(ALLOC(Z_BUFSIZE));

        if (outbuf == nullptr)

        {

            CPL_VSIL_GZ_RETURN(FALSE);

            return false;

        }

    }

    if (original_nWhence == SEEK_END && z_err == Z_STREAM_END)

    {

        return true;

    }

    while (offset > 0)

    {

        int size = Z_BUFSIZE;

        if (offset < static_cast<vsi_l_offset>(Z_BUFSIZE))

            size = static_cast<int>(offset);

        const int read_size =

            static_cast<int>(Read(outbuf, static_cast<uInt>(size)));

        if (original_nWhence == SEEK_END)

        {

            if (size != read_size)

            {

                z_err = Z_STREAM_END;

                break;

            }

        }

        else if (read_size == 0)

        {

            // CPL_VSIL_GZ_RETURN(FALSE);

            return false;

        }

        offset -= read_size;

    }

#ifdef ENABLE_DEBUG

    CPLDebug("GZIP", "gzseek at offset " CPL_FRMT_GUIB, out);

#endif

    if (original_offset == 0 && original_nWhence == SEEK_END)

    {

        m_uncompressed_size = out;

        if (m_pszBaseFileName && !STARTS_WITH(m_pszBaseFileName, "/vsicurl/") &&

            !STARTS_WITH(m_pszBaseFileName, "/vsitar/") &&

            !STARTS_WITH(m_pszBaseFileName, "/vsizip/") && m_bWriteProperties)

        {

            CPLErrorStateBackuper oErrorStateBackuper(CPLQuietErrorHandler);

            CPLString osCacheFilename(m_pszBaseFileName);

            osCacheFilename += ".properties";

            // Write a .properties file to avoid seeking next time.

            VSILFILE *fpCacheLength = VSIFOpenL(osCacheFilename.c_str(), "wb");

            if (fpCacheLength)

            {

                char szBuffer[32] = {};

                CPLPrintUIntBig(szBuffer, m_compressed_size, 31);

                char *pszFirstNonSpace = szBuffer;

                while (*pszFirstNonSpace == ' ')

                    pszFirstNonSpace++;

                CPL_IGNORE_RET_VAL(VSIFPrintfL(

                    fpCacheLength, "compressed_size=%s\n", pszFirstNonSpace));

                CPLPrintUIntBig(szBuffer, m_uncompressed_size, 31);

                pszFirstNonSpace = szBuffer;

                while (*pszFirstNonSpace == ' ')

                    pszFirstNonSpace++;

                CPL_IGNORE_RET_VAL(VSIFPrintfL(

                    fpCacheLength, "uncompressed_size=%s\n", pszFirstNonSpace));

                CPL_IGNORE_RET_VAL(VSIFCloseL(fpCacheLength));

            }

        }

    }

    return true;

}

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

/*                                Tell()                                */

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

vsi_l_offset VSIGZipHandle::Tell()

{

#ifdef ENABLE_DEBUG

    CPLDebug("GZIP", "Tell() = " CPL_FRMT_GUIB, out);

#endif

    return out;

}

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

/*                                Read()                                */

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

size_t VSIGZipHandle::Read(void *const buf, size_t const nBytes)

{

#ifdef ENABLE_DEBUG

    CPLDebug("GZIP", "Read(%p, %d)", buf, static_cast<int>(nBytes));

#endif

    if (m_bEOF || z_err != Z_OK)

    {

        if (z_err == Z_STREAM_END && nBytes > 0)

            m_bEOF = true;

        return 0;

    }

    if (nBytes > UINT32_MAX)

    {

        CPLError(CE_Failure, CPLE_FileIO, "Too many bytes to read at once");

        return 0;

    }

    const unsigned len = static_cast<unsigned int>(nBytes);

    Bytef *pStart =

        static_cast<Bytef *>(buf);  // Start off point for crc computation.

    // == stream.next_out but not forced far (for MSDOS).

    Byte *next_out = static_cast<Byte *>(buf);

    stream.next_out = static_cast<Bytef *>(buf);

    stream.avail_out = len;

    while (stream.avail_out != 0)

    {

        if (m_transparent)

        {

            // Copy first the lookahead bytes:

            uInt nRead = 0;

            uInt n = stream.avail_in;

            if (n > stream.avail_out)

                n = stream.avail_out;

            if (n > 0)

            {

                memcpy(stream.next_out, stream.next_in, n);

                next_out += n;

                stream.next_out = next_out;

                stream.next_in += n;

                stream.avail_out -= n;