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

Version 1.2.0, September 16th, 2017

part of the MiniZip project

Copyright (C) 2010-2017 Nathan Moinvaziri

Modifications for AES, PKWARE disk spanning

https://github.com/nmoinvaz/minizip

Copyright (C) 2009-2010 Mathias Svensson

Modifications for Zip64 support

http://result42.com

Copyright (C) 1998-2010 Gilles Vollant

http://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 <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include <string.h>

#include <limits.h>

#include <errno.h>

#include "zlib.h"

#include "zip.h"

#ifdef HAVE_AES

# define AES_METHOD (99)

# define AES_PWVERIFYSIZE (2)

# define AES_AUTHCODESIZE (10)

# define AES_MAXSALTLENGTH (16)

# define AES_VERSION (0x0001)

# define AES_ENCRYPTIONMODE (0x03)

# include "aes/aes.h"

# include "aes/fileenc.h"

# include "aes/prng.h"

#endif

#ifdef HAVE_APPLE_COMPRESSION

# include <compression.h>

#endif

#ifndef NOCRYPT

# include "crypt.h"

#endif

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

#define DISKHEADERMAGIC (0x08074b50)

#define LOCALHEADERMAGIC (0x04034b50)

#define CENTRALHEADERMAGIC (0x02014b50)

#define ENDHEADERMAGIC (0x06054b50)

#define ZIP64ENDHEADERMAGIC (0x06064b50)

#define ZIP64ENDLOCHEADERMAGIC (0x07064b50)

#define DATADESCRIPTORMAGIC (0x08074b50)

#define FLAG_LOCALHEADER_OFFSET (0x06)

#define CRC_LOCALHEADER_OFFSET (0x0e)

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

#define SIZECENTRALHEADERLOCATOR (0x14) /* 20 */

#define SIZECENTRALDIRITEM (0x2e)

#define SIZEZIPLOCALHEADER (0x1e)

#ifndef BUFREADCOMMENT

# define BUFREADCOMMENT (0x400)

#endif

#ifndef VERSIONMADEBY

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

#endif

#ifndef Z_BUFSIZE

# define Z_BUFSIZE (UINT16_MAX)

#endif

#ifndef ALLOC

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

#endif

#ifndef TRYFREE

# define TRYFREE(p) {if (p) free(p);}

#endif

/* NOT sure that this work on ALL platform */

#define MAKEULONG64(a, b) ((uint64_t)(((unsigned long)(a)) | ((uint64_t)((unsigned long)(b))) << 32))

#ifndef DEF_MEM_LEVEL

# if MAX_MEM_LEVEL >= 8

# define DEF_MEM_LEVEL 8

# else

# define DEF_MEM_LEVEL MAX_MEM_LEVEL

# endif

#endif

const char zip_copyright[] = " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";

typedef struct linkedlist_datablock_internal_s

{

struct linkedlist_datablock_internal_s *next_datablock;

uint32_t avail_in_this_block;

uint32_t filled_in_this_block;

uint32_t unused; /* for future use and alignment */

uint8_t 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 */

#ifdef HAVE_BZIP2

bz_stream bstream; /* bzLib stream structure for bziped */

#endif

#ifdef HAVE_APPLE_COMPRESSION

compression_stream astream; /* libcompression stream structure */

#endif

#ifdef HAVE_AES

fcrypt_ctx aes_ctx;

prng_ctx aes_rng[1];

#endif

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

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

uint64_t pos_local_header; /* offset of the local header of the file currently writing */

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

uint16_t size_centralextra;

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

uint16_t size_centralextrafree; /* Extra bytes allocated to the central header but that are not used */

uint16_t size_comment;

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

uint16_t method; /* compression method written to file.*/

uint16_t compression_method; /* compression method to use */

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

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

uint32_t dos_date;

uint32_t crc32;

int zip64; /* add ZIP64 extended information in the extra field */

uint32_t number_disk; /* number of current disk used for spanning ZIP */

uint64_t total_compressed;

uint64_t total_uncompressed;

#ifndef NOCRYPT

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

const z_crc_t *pcrc_32_tab;

#endif

} curfile64_info;

typedef struct

{

zlib_filefunc64_32_def z_filefunc;

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

voidpf filestream_with_CD; /* io structure of the zipfile with the central dir */

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.*/

int append; /* append mode */

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

uint64_t add_position_when_writting_offset;

uint64_t number_entry;

uint64_t disk_size; /* size of each disk */

uint32_t number_disk; /* number of the current disk, used for spanning ZIP */

uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */

#ifndef NO_ADDFILEINEXISTINGZIP

char *globalcomment;

#endif

} zip64_internal;

/* Allocate a new data block */

static linkedlist_datablock_internal *allocate_new_datablock(void)

{

linkedlist_datablock_internal *ldi = NULL;

ldi = (linkedlist_datablock_internal*)ALLOC(sizeof(linkedlist_datablock_internal));

if (ldi != NULL)

{

ldi->next_datablock = NULL;

ldi->filled_in_this_block = 0;

ldi->avail_in_this_block = SIZEDATA_INDATABLOCK;

}

return ldi;

}

/* Free data block in linked list */

static void free_datablock(linkedlist_datablock_internal *ldi)

{

while (ldi != NULL)

{

linkedlist_datablock_internal *ldinext = ldi->next_datablock;

TRYFREE(ldi);

ldi = ldinext;

}

}

/* Initialize linked list */

static void init_linkedlist(linkedlist_data *ll)

{

ll->first_block = ll->last_block = NULL;

}

/* Free entire linked list and all data blocks */

static void free_linkedlist(linkedlist_data *ll)

{

free_datablock(ll->first_block);

ll->first_block = ll->last_block = NULL;

}

/* Add data to linked list data block */

static int add_data_in_datablock(linkedlist_data *ll, const void *buf, uint32_t len)

{

linkedlist_datablock_internal *ldi = NULL;

const unsigned char *from_copy = NULL;

if (ll == NULL)

return ZIP_INTERNALERROR;

if (ll->last_block == NULL)

{

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

if (ll->first_block == NULL)

return ZIP_INTERNALERROR;

}

ldi = ll->last_block;

from_copy = (unsigned char*)buf;

while (len > 0)

{

uint32_t copy_this = 0;

uint32_t i = 0;

unsigned char *to_copy = NULL;

if (ldi->avail_in_this_block == 0)

{

ldi->next_datablock = allocate_new_datablock();

if (ldi->next_datablock == NULL)

return ZIP_INTERNALERROR;

ldi = ldi->next_datablock ;

ll->last_block = ldi;

}

if (ldi->avail_in_this_block < len)

copy_this = ldi->avail_in_this_block;

else

copy_this = 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;

}

/* Inputs a long in LSB order to the given file: nbByte == 1, 2 ,4 or 8 (byte, short or long, uint64_t) */

static int zipWriteValue(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream,

uint64_t x, uint32_t len)

{

unsigned char buf[8];

uint32_t n = 0;

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

{

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

x >>= 8;

}

if (x != 0)

{

/* Data overflow - hack for ZIP64 (X Roche) */

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

{

buf[n] = 0xff;

}

}

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

return ZIP_ERRNO;

return ZIP_OK;

}

static void zipWriteValueToMemory(void* dest, uint64_t x, uint32_t len)

{

unsigned char *buf = (unsigned char*)dest;

uint32_t n = 0;

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

{

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

x >>= 8;

}

if (x != 0)

{

/* data overflow - hack for ZIP64 */

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

{

buf[n] = 0xff;

}

}

}

static void zipWriteValueToMemoryAndMove(unsigned char **dest_ptr, uint64_t x, uint32_t len)

{

zipWriteValueToMemory(*dest_ptr, x, len);

*dest_ptr += len;

}

static int zipReadUInt8(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint8_t *value)

{

uint8_t c = 0;

if (ZREAD64(*pzlib_filefunc_def, filestream, &c, 1) == 1)

{

*value = (uint8_t)c;

return ZIP_OK;

}

if (ZERROR64(*pzlib_filefunc_def, filestream))

return ZIP_ERRNO;

return ZIP_EOF;

}

static int zipReadUInt16(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint16_t *value)

{

uint16_t x = 0;

uint8_t c = 0;

int err = ZIP_OK;

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x = (uint16_t)c;

if (err == ZIP_OK)

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x += ((uint16_t)c) << 8;

if (err == ZIP_OK)

*value = x;

else

*value = 0;

return err;

}

static int zipReadUInt32(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint32_t *value)

{

uint32_t x = 0;

uint8_t c = 0;

int err = ZIP_OK;

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x = (uint32_t)c;

if (err == ZIP_OK)

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x += ((uint32_t)c) << 8;

if (err == ZIP_OK)

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x += ((uint32_t)c) << 16;

if (err == ZIP_OK)

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x += ((uint32_t)c) << 24;

if (err == ZIP_OK)

*value = x;

else

*value = 0;

return err;

}

static int zipReadUInt64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint64_t *value)

{

uint64_t x = 0;

uint8_t c = 0;

int err = ZIP_OK;

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x = (uint64_t)c;

if (err == ZIP_OK)

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x += ((uint64_t)c) << 8;

if (err == ZIP_OK)

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x += ((uint64_t)c) << 16;

if (err == ZIP_OK)

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x += ((uint64_t)c) << 24;

if (err == ZIP_OK)

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x += ((uint64_t)c) << 32;

if (err == ZIP_OK)

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x += ((uint64_t)c) << 40;

if (err == ZIP_OK)

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x += ((uint64_t)c) << 48;

if (err == ZIP_OK)

err = zipReadUInt8(pzlib_filefunc_def, filestream, &c);

x += ((uint64_t)c) << 56;

if (err == ZIP_OK)

*value = x;

else

*value = 0;

return err;

}

/* Gets the amount of bytes left to write to the current disk for spanning archives */

static void zipGetDiskSizeAvailable(zipFile file, uint64_t *size_available)

{

zip64_internal *zi = NULL;

uint64_t current_disk_size = 0;

zi = (zip64_internal*)file;

ZSEEK64(zi->z_filefunc, zi->filestream, 0, ZLIB_FILEFUNC_SEEK_END);

current_disk_size = ZTELL64(zi->z_filefunc, zi->filestream);

*size_available = zi->disk_size - current_disk_size;

}

/* Goes to a specific disk number for spanning archives */

static int zipGoToSpecificDisk(zipFile file, uint32_t number_disk, int open_existing)

{

zip64_internal *zi = NULL;

int err = ZIP_OK;

zi = (zip64_internal*)file;

if (zi->disk_size == 0)

return err;

if ((zi->filestream != NULL) && (zi->filestream != zi->filestream_with_CD))

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

zi->filestream = ZOPENDISK64(zi->z_filefunc, zi->filestream_with_CD, number_disk, (open_existing == 1) ?

(ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING) :

(ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE));

if (zi->filestream == NULL)

err = ZIP_ERRNO;

return err;

}

/* Goes to the first disk in a spanned archive */

static int zipGoToFirstDisk(zipFile file)

{

zip64_internal *zi = NULL;

uint32_t number_disk_next = 0;

int err = ZIP_OK;

zi = (zip64_internal*)file;

if (zi->disk_size == 0)

return err;

number_disk_next = 0;

if (zi->number_disk_with_CD > 0)

number_disk_next = zi->number_disk_with_CD - 1;

err = zipGoToSpecificDisk(file, number_disk_next, (zi->append == APPEND_STATUS_ADDINZIP));

if ((err == ZIP_ERRNO) && (zi->append == APPEND_STATUS_ADDINZIP))

err = zipGoToSpecificDisk(file, number_disk_next, 0);

if (err == ZIP_OK)

zi->number_disk = number_disk_next;

ZSEEK64(zi->z_filefunc, zi->filestream, 0, ZLIB_FILEFUNC_SEEK_END);

return err;

}

/* Goes to the next disk in a spanned archive */

static int zipGoToNextDisk(zipFile file)

{

zip64_internal *zi = NULL;

uint64_t size_available_in_disk = 0;

uint32_t number_disk_next = 0;

int err = ZIP_OK;

zi = (zip64_internal*)file;

if (zi->disk_size == 0)

return err;

number_disk_next = zi->number_disk + 1;

do

{

err = zipGoToSpecificDisk(file, number_disk_next, (zi->append == APPEND_STATUS_ADDINZIP));

if ((err == ZIP_ERRNO) && (zi->append == APPEND_STATUS_ADDINZIP))

err = zipGoToSpecificDisk(file, number_disk_next, 0);

if (err != ZIP_OK)

break;

zipGetDiskSizeAvailable(file, &size_available_in_disk);

zi->number_disk = number_disk_next;

zi->number_disk_with_CD = zi->number_disk + 1;

number_disk_next += 1;

}

while (size_available_in_disk <= 0);

return err;

}

/* Locate the Central directory of a zipfile (at the end, just before the global comment) */

static uint64_t zipSearchCentralDir(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream)

{

unsigned char *buf = NULL;

uint64_t file_size = 0;

uint64_t back_read = 4;

uint64_t max_back = UINT16_MAX; /* maximum size of global comment */

uint64_t pos_found = 0;

uint32_t read_size = 0;

uint64_t read_pos = 0;

uint32_t i = 0;

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

if (buf == NULL)

return 0;

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

{

TRYFREE(buf);

return 0;

}

file_size = ZTELL64(*pzlib_filefunc_def, filestream);

if (max_back > file_size)

max_back = file_size;

while (back_read < max_back)

{

if (back_read + BUFREADCOMMENT > max_back)

back_read = max_back;

else

back_read += BUFREADCOMMENT;

read_pos = file_size-back_read;

read_size = ((BUFREADCOMMENT+4) < (file_size - read_pos)) ?

(BUFREADCOMMENT+4) : (uint32_t)(file_size - read_pos);

if (ZSEEK64(*pzlib_filefunc_def, filestream, read_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)

break;

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

break;

for (i = read_size-3; (i--) > 0;)

if ((*(buf+i)) == (ENDHEADERMAGIC & 0xff) &&

(*(buf+i+1)) == (ENDHEADERMAGIC >> 8 & 0xff) &&

(*(buf+i+2)) == (ENDHEADERMAGIC >> 16 & 0xff) &&

(*(buf+i+3)) == (ENDHEADERMAGIC >> 24 & 0xff))

{

pos_found = read_pos+i;

break;

}

if (pos_found != 0)

break;

}

TRYFREE(buf);

return pos_found;

}

/* Locate the Central directory 64 of a zipfile (at the end, just before the global comment) */

static uint64_t zipSearchCentralDir64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream,

const uint64_t endcentraloffset)

{

uint64_t offset = 0;

uint32_t value32 = 0;

/* Zip64 end of central directory locator */

if (ZSEEK64(*pzlib_filefunc_def, filestream, endcentraloffset - SIZECENTRALHEADERLOCATOR, ZLIB_FILEFUNC_SEEK_SET) != 0)

return 0;

/* Read locator signature */

if (zipReadUInt32(pzlib_filefunc_def, filestream, &value32) != ZIP_OK)

return 0;

if (value32 != ZIP64ENDLOCHEADERMAGIC)

return 0;

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

if (zipReadUInt32(pzlib_filefunc_def, filestream, &value32) != ZIP_OK)

return 0;

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

if (zipReadUInt64(pzlib_filefunc_def, filestream, &offset) != ZIP_OK)

return 0;

/* Total number of disks */

if (zipReadUInt32(pzlib_filefunc_def, filestream, &value32) != ZIP_OK)

return 0;

/* Goto end of central directory record */

if (ZSEEK64(*pzlib_filefunc_def,filestream, offset, ZLIB_FILEFUNC_SEEK_SET) != 0)

return 0;

/* The signature */

if (zipReadUInt32(pzlib_filefunc_def, filestream, &value32) != ZIP_OK)

return 0;

if (value32 != ZIP64ENDHEADERMAGIC)

return 0;

return offset;

}

extern zipFile ZEXPORT zipOpen4(const void *path, int append, uint64_t disk_size, const char **globalcomment,

zlib_filefunc64_32_def *pzlib_filefunc64_32_def)

{

zip64_internal ziinit;

zip64_internal *zi = NULL;

#ifndef NO_ADDFILEINEXISTINGZIP

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

uint64_t size_central_dir = 0; /* size of the central directory */

uint64_t offset_central_dir = 0; /* offset of start of central directory */

uint64_t number_entry_CD = 0; /* total number of entries in the central dir */

uint64_t number_entry = 0;

uint64_t central_pos = 0;

uint64_t size_central_dir_to_read = 0;

uint16_t value16 = 0;

uint32_t value32 = 0;

uint16_t size_comment = 0;

size_t buf_size = SIZEDATA_INDATABLOCK;

void *buf_read = NULL;

#endif

int err = ZIP_OK;

int mode = 0;

ziinit.z_filefunc.zseek32_file = NULL;

ziinit.z_filefunc.ztell32_file = NULL;

if (pzlib_filefunc64_32_def == NULL)

fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64);

else

ziinit.z_filefunc = *pzlib_filefunc64_32_def;

if (append == APPEND_STATUS_CREATE)

mode = (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE);

else

mode = (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING);

ziinit.filestream = ZOPEN64(ziinit.z_filefunc, path, mode);

if (ziinit.filestream == NULL)

return NULL;

if (append == APPEND_STATUS_CREATEAFTER)

{

/* Don't support spanning ZIP with APPEND_STATUS_CREATEAFTER */

if (disk_size > 0)

return NULL;

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

}

ziinit.filestream_with_CD = ziinit.filestream;

ziinit.append = append;

ziinit.number_disk = 0;

ziinit.number_disk_with_CD = 0;

ziinit.disk_size = disk_size;

ziinit.in_opened_file_inzip = 0;

ziinit.ci.stream_initialised = 0;

ziinit.number_entry = 0;

ziinit.add_position_when_writting_offset = 0;

init_linkedlist(&(ziinit.central_dir));

zi = (zip64_internal*)ALLOC(sizeof(zip64_internal));

if (zi == NULL)

{

ZCLOSE64(ziinit.z_filefunc,ziinit.filestream);

return NULL;

}

#ifndef NO_ADDFILEINEXISTINGZIP

/* Add file in a zipfile */

ziinit.globalcomment = NULL;

if (append == APPEND_STATUS_ADDINZIP)

{

/* Read and Cache Central Directory Records */

central_pos = zipSearchCentralDir(&ziinit.z_filefunc,ziinit.filestream);

/* Disable to allow appending to empty ZIP archive (must be standard zip, not zip64)

if (central_pos == 0)

err = ZIP_ERRNO;

*/

if (err == ZIP_OK)

{

/* Read end of central directory info */

if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET) != 0)

err = ZIP_ERRNO;

/* The signature, already checked */

if (zipReadUInt32(&ziinit.z_filefunc, ziinit.filestream, &value32) != ZIP_OK)

err = ZIP_ERRNO;

/* Number of this disk */

if (zipReadUInt16(&ziinit.z_filefunc, ziinit.filestream, &value16) != ZIP_OK)

err = ZIP_ERRNO;

ziinit.number_disk = value16;

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

if (zipReadUInt16(&ziinit.z_filefunc, ziinit.filestream, &value16) != ZIP_OK)

err = ZIP_ERRNO;

ziinit.number_disk_with_CD = value16;

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

number_entry = 0;

if (zipReadUInt16(&ziinit.z_filefunc, ziinit.filestream, &value16) != ZIP_OK)

err = ZIP_ERRNO;

else

number_entry = value16;

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

number_entry_CD = 0;

if (zipReadUInt16(&ziinit.z_filefunc, ziinit.filestream, &value16) != ZIP_OK)

err = ZIP_ERRNO;

else

number_entry_CD = value16;

if (number_entry_CD!=number_entry)

err = ZIP_BADZIPFILE;

/* Size of the central directory */

size_central_dir = 0;

if (zipReadUInt32(&ziinit.z_filefunc, ziinit.filestream, &value32) != ZIP_OK)

err = ZIP_ERRNO;

else

size_central_dir = value32;

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

offset_central_dir = 0;

if (zipReadUInt32(&ziinit.z_filefunc, ziinit.filestream, &value32) != ZIP_OK)

err = ZIP_ERRNO;

else

offset_central_dir = value32;

/* Zipfile global comment length */

if (zipReadUInt16(&ziinit.z_filefunc, ziinit.filestream, &size_comment) != ZIP_OK)

err = ZIP_ERRNO;

if ((err == ZIP_OK) && ((number_entry_CD == UINT16_MAX) || (offset_central_dir == UINT32_MAX)))

{

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

central_pos = zipSearchCentralDir64(&ziinit.z_filefunc, ziinit.filestream, central_pos);

if (central_pos)

{

uint64_t sizeEndOfCentralDirectory;

if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)

err = ZIP_ERRNO;

/* The signature, already checked */

if (zipReadUInt32(&ziinit.z_filefunc, ziinit.filestream, &value32) != ZIP_OK)

err = ZIP_ERRNO;

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

if (zipReadUInt64(&ziinit.z_filefunc, ziinit.filestream, &sizeEndOfCentralDirectory) != ZIP_OK)

err = ZIP_ERRNO;

/* Version made by */

if (zipReadUInt16(&ziinit.z_filefunc, ziinit.filestream, &value16) != ZIP_OK)

err = ZIP_ERRNO;

/* Version needed to extract */

if (zipReadUInt16(&ziinit.z_filefunc, ziinit.filestream, &value16) != ZIP_OK)

err = ZIP_ERRNO;

/* Number of this disk */

if (zipReadUInt32(&ziinit.z_filefunc, ziinit.filestream, &ziinit.number_disk) != ZIP_OK)

err = ZIP_ERRNO;

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

if (zipReadUInt32(&ziinit.z_filefunc, ziinit.filestream, &ziinit.number_disk_with_CD) != ZIP_OK)

err = ZIP_ERRNO;

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

if (zipReadUInt64(&ziinit.z_filefunc, ziinit.filestream, &number_entry) != ZIP_OK)

err = ZIP_ERRNO;

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

if (zipReadUInt64(&ziinit.z_filefunc, ziinit.filestream, &number_entry_CD) != ZIP_OK)

err = ZIP_ERRNO;

if (number_entry_CD!=number_entry)

err = ZIP_BADZIPFILE;

/* Size of the central directory */

if (zipReadUInt64(&ziinit.z_filefunc, ziinit.filestream, &size_central_dir) != ZIP_OK)

err = ZIP_ERRNO;

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

if (zipReadUInt64(&ziinit.z_filefunc, ziinit.filestream, &offset_central_dir) != ZIP_OK)

err = ZIP_ERRNO;

}

else

err = ZIP_BADZIPFILE;

}

}

if ((err == ZIP_OK) && (central_pos < offset_central_dir + size_central_dir))

err = ZIP_BADZIPFILE;

if ((err == ZIP_OK) && (size_comment > 0))

{

ziinit.globalcomment = (char*)ALLOC(size_comment+1);

if (ziinit.globalcomment)

{

if (ZREAD64(ziinit.z_filefunc, ziinit.filestream, ziinit.globalcomment, size_comment) != size_comment)

err = ZIP_ERRNO;

else

ziinit.globalcomment[size_comment] = 0;

}

}

if (err != ZIP_OK)

{

ZCLOSE64(ziinit.z_filefunc, ziinit.filestream);

TRYFREE(ziinit.globalcomment);

TRYFREE(zi);

return NULL;

}

byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir);

ziinit.add_position_when_writting_offset = byte_before_the_zipfile;

/* Store central directory in memory */

size_central_dir_to_read = size_central_dir;

buf_size = SIZEDATA_INDATABLOCK;

buf_read = (void*)ALLOC(buf_size);

if (ZSEEK64(ziinit.z_filefunc, ziinit.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))

{

uint64_t read_this = SIZEDATA_INDATABLOCK;

if (read_this > size_central_dir_to_read)

read_this = size_central_dir_to_read;

if (ZREAD64(ziinit.z_filefunc, ziinit.filestream, buf_read, (uint32_t)read_this) != read_this)

err = ZIP_ERRNO;

if (err == ZIP_OK)

err = add_data_in_datablock(&ziinit.central_dir, buf_read, (uint32_t)read_this);

size_central_dir_to_read -= read_this;

}

TRYFREE(buf_read);

ziinit.number_entry = number_entry_CD;

if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream,

offset_central_dir+byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)

err = ZIP_ERRNO;

}

if (globalcomment)

*globalcomment = ziinit.globalcomment;

#endif

if (err != ZIP_OK)

{

#ifndef NO_ADDFILEINEXISTINGZIP

TRYFREE(ziinit.globalcomment);

#endif

TRYFREE(zi);

return NULL;

}

*zi = ziinit;

zipGoToFirstDisk((zipFile)zi);

return(zipFile)zi;

}

extern zipFile ZEXPORT zipOpen2(const char *path, int append, const char **globalcomment,

zlib_filefunc_def *pzlib_filefunc32_def)

{

if (pzlib_filefunc32_def != NULL)

{

zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;

fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);

return zipOpen4(path, append, 0, globalcomment, &zlib_filefunc64_32_def_fill);

}

return zipOpen4(path, append, 0, globalcomment, NULL);

}

extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **globalcomment,

zlib_filefunc64_def *pzlib_filefunc_def)

{

if (pzlib_filefunc_def != NULL)

{

zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;

zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;

zlib_filefunc64_32_def_fill.ztell32_file = NULL;

zlib_filefunc64_32_def_fill.zseek32_file = NULL;

return zipOpen4(path, append, 0, globalcomment, &zlib_filefunc64_32_def_fill);

}

return zipOpen4(path, append, 0, globalcomment, NULL);

}

extern zipFile ZEXPORT zipOpen3(const char *path, int append, uint64_t disk_size, const char **globalcomment,

zlib_filefunc_def *pzlib_filefunc32_def)

{

if (pzlib_filefunc32_def != NULL)

{

zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;

fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);

return zipOpen4(path, append, disk_size, globalcomment, &zlib_filefunc64_32_def_fill);

}

return zipOpen4(path, append, disk_size, globalcomment, NULL);

}

extern zipFile ZEXPORT zipOpen3_64(const void *path, int append, uint64_t disk_size, const char **globalcomment,

zlib_filefunc64_def *pzlib_filefunc_def)

{

if (pzlib_filefunc_def != NULL)

{

zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;

zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;

zlib_filefunc64_32_def_fill.ztell32_file = NULL;

zlib_filefunc64_32_def_fill.zseek32_file = NULL;

return zipOpen4(path, append, disk_size, globalcomment, &zlib_filefunc64_32_def_fill);

}

return zipOpen4(path, append, disk_size, globalcomment, NULL);

}

extern zipFile ZEXPORT zipOpen(const char *path, int append)

{

return zipOpen3((const void*)path, append, 0, NULL, NULL);

}

extern zipFile ZEXPORT zipOpen64(const void *path, int append)

{

return zipOpen3(path, append, 0, NULL, NULL);

}

extern int ZEXPORT zipOpenNewFileInZip_internal(zipFile file,

const char *filename,

const zip_fileinfo *zipfi,

const void *extrafield_local,

uint16_t size_extrafield_local,

const void *extrafield_global,

uint16_t size_extrafield_global,

const char *comment,

uint16_t flag_base,

int zip64,

uint16_t method,

int level,

int raw,

int windowBits,

int memLevel,

int strategy,

const char *password,

int aes,

uint16_t version_madeby)

{

zip64_internal *zi = NULL;

uint64_t size_available = 0;

uint64_t size_needed = 0;

uint16_t size_filename = 0;

uint16_t size_comment = 0;

uint16_t i = 0;

unsigned char *central_dir = NULL;

int err = ZIP_OK;

#ifdef NOCRYPT

if (password != NULL)

return ZIP_PARAMERROR;

#endif

if (file == NULL)

return ZIP_PARAMERROR;

if ((method != 0) &&

#ifdef HAVE_BZIP2

(method != Z_BZIP2ED) &&

#endif

(method != Z_DEFLATED))

return ZIP_PARAMERROR;

zi = (zip64_internal*)file;

if (zi->in_opened_file_inzip == 1)

{

err = zipCloseFileInZip (file);

if (err != ZIP_OK)

return err;

}

if (filename == NULL)

filename = "-";

if (comment != NULL)

size_comment = (uint16_t)strlen(comment);

size_filename = (uint16_t)strlen(filename);

if (zipfi == NULL)

zi->ci.dos_date = 0;

else

{

if (zipfi->dos_date != 0)

zi->ci.dos_date = zipfi->dos_date;

}

zi->ci.method = method;

zi->ci.compression_method = method;

zi->ci.raw = raw;

zi->ci.flag = flag_base | 8;

if ((level == 8) || (level == 9))

zi->ci.flag |= 2;

if (level == 2)

zi->ci.flag |= 4;

if (level == 1)

zi->ci.flag |= 6;

if (password != NULL)

{

zi->ci.flag |= 1;

#ifdef HAVE_AES

if (aes)

zi->ci.method = AES_METHOD;

#endif

}