#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "zlib.h"
#include "zip.h"
#include <errno.h>
#include "crypt.h"

Classes
struct	linkedlist_datablock_internal_s

struct	linkedlist_data_s

struct	curfile_info

struct	zip_internal

Macros
#define	local static

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

#define	Z_BUFSIZE (16384)

#define	Z_MAXFILENAMEINZIP (256)

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

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

#define	SEEK_CUR 1

#define	SEEK_END 2

#define	SEEK_SET 0

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

#define	LOCALHEADERMAGIC (0x04034b50)

#define	CENTRALHEADERMAGIC (0x02014b50)

#define	ENDHEADERMAGIC (0x06054b50)

#define	FLAG_LOCALHEADER_OFFSET (0x06)

#define	CRC_LOCALHEADER_OFFSET (0x0e)

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

#define	INCLUDECRYPTINGCODE_IFCRYPTALLOWED

#define	BUFREADCOMMENT (0x400)

Typedefs
typedef struct linkedlist_datablock_internal_s	linkedlist_datablock_internal

typedef struct linkedlist_data_s	linkedlist_data

Functions
local linkedlist_datablock_internal *	allocate_new_datablock ()

local void	free_datablock (linkedlist_datablock_internal *ldi)

local void	init_linkedlist (linkedlist_data *ll)

local void	free_linkedlist (linkedlist_data *ll)

local int	add_data_in_datablock (linkedlist_data ll, const void buf, uLong len)

local int ziplocal_putValue	OF ((const zlib_filefunc_def *pzlib_filefunc_def, voidpf filestream, uLong x, int nbByte))

local int	ziplocal_putValue (zlib_filefunc_def *pzlib_filefunc_def, voidpf filestream, uLong x, int nbByte) const

local void ziplocal_putValue_inmemory	OF ((void *dest, uLong x, int nbByte))

local void	ziplocal_putValue_inmemory (void *dest, uLong x, int nbByte)

local uLong	ziplocal_TmzDateToDosDate (tm_zip *ptm, uLong dosDate) const

local int ziplocal_getByte	OF ((const zlib_filefunc_def pzlib_filefunc_def, voidpf filestream, int pi))

local int	ziplocal_getByte (zlib_filefunc_def pzlib_filefunc_def, voidpf filestream, int pi) const

local int ziplocal_getShort	OF ((const zlib_filefunc_def pzlib_filefunc_def, voidpf filestream, uLong pX))

local int	ziplocal_getShort (zlib_filefunc_def pzlib_filefunc_def, voidpf filestream, uLong pX) const

local int	ziplocal_getLong (zlib_filefunc_def pzlib_filefunc_def, voidpf filestream, uLong pX) const

local uLong ziplocal_SearchCentralDir	OF ((const zlib_filefunc_def *pzlib_filefunc_def, voidpf filestream))

local uLong	ziplocal_SearchCentralDir (zlib_filefunc_def *pzlib_filefunc_def, voidpf filestream) const

zipFile ZEXPORT	zipOpen2 (char pathname, int append, zipcharpc globalcomment, zlib_filefunc_def *pzlib_filefunc_def) const

zipFile ZEXPORT	zipOpen (char *pathname, int append) const

int ZEXPORT	zipOpenNewFileInZip3 (zipFile file, const char filename, const zip_fileinfo zipfi, const void extrafield_local, uInt size_extrafield_local, const void extrafield_global, uInt size_extrafield_global, const char comment, int method, int level, int raw, int windowBits, int memLevel, int strategy, const char password, uLong crcForCrypting)

int ZEXPORT	zipOpenNewFileInZip2 (zipFile file, const char filename, const zip_fileinfo zipfi, const void extrafield_local, uInt size_extrafield_local, const void extrafield_global, uInt size_extrafield_global, const char *comment, int method, int level, int raw)

int ZEXPORT	zipOpenNewFileInZip (zipFile file, const char filename, const zip_fileinfo zipfi, const void extrafield_local, uInt size_extrafield_local, const void extrafield_global, uInt size_extrafield_global, const char *comment, int method, int level)

local int	zipFlushWriteBuffer (zip_internal *zi)

int ZEXPORT	zipWriteInFileInZip (zipFile file, const void *buf, unsigned len)

int ZEXPORT	zipCloseFileInZipRaw (zipFile file, uLong uncompressed_size, uLong crc32)

int ZEXPORT	zipCloseFileInZip (zipFile file)

int ZEXPORT	zipClose (zipFile file, const char *global_comment)

Variables
const char	zip_copyright []

Macro Definition Documentation

◆ ALLOC

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

Definition at line 50 of file zip.c.

◆ BUFREADCOMMENT

#define BUFREADCOMMENT (0x400)

Definition at line 430 of file zip.c.

◆ CENTRALHEADERMAGIC

#define CENTRALHEADERMAGIC (0x02014b50)

Definition at line 89 of file zip.c.

◆ CRC_LOCALHEADER_OFFSET

#define CRC_LOCALHEADER_OFFSET (0x0e)

Definition at line 93 of file zip.c.

◆ ENDHEADERMAGIC

#define ENDHEADERMAGIC (0x06054b50)

Definition at line 90 of file zip.c.

◆ FLAG_LOCALHEADER_OFFSET

#define FLAG_LOCALHEADER_OFFSET (0x06)

Definition at line 92 of file zip.c.

◆ INCLUDECRYPTINGCODE_IFCRYPTALLOWED

#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED

Definition at line 157 of file zip.c.

◆ local

#define local static

Definition at line 33 of file zip.c.

◆ LOCALHEADERMAGIC

#define LOCALHEADERMAGIC (0x04034b50)

Definition at line 88 of file zip.c.

◆ SEEK_CUR

#define SEEK_CUR 1

Definition at line 64 of file zip.c.

◆ SEEK_END

#define SEEK_END 2

Definition at line 68 of file zip.c.

◆ SEEK_SET

#define SEEK_SET 0

Definition at line 72 of file zip.c.

◆ SIZECENTRALHEADER

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

Definition at line 95 of file zip.c.

◆ SIZEDATA_INDATABLOCK

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

Definition at line 86 of file zip.c.

◆ TRYFREE

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

Definition at line 53 of file zip.c.

◆ VERSIONMADEBY

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

Definition at line 38 of file zip.c.

◆ Z_BUFSIZE

#define Z_BUFSIZE (16384)

Definition at line 42 of file zip.c.

◆ Z_MAXFILENAMEINZIP

#define Z_MAXFILENAMEINZIP (256)

Definition at line 46 of file zip.c.

Typedef Documentation

◆ linkedlist_data

typedef struct linkedlist_data_s linkedlist_data

◆ linkedlist_datablock_internal

typedef struct linkedlist_datablock_internal_s linkedlist_datablock_internal

Function Documentation

◆ add_data_in_datablock()

local int add_data_in_datablock	(	linkedlist_data*	ll,
		const void*	buf,
		uLong	len
	)

Definition at line 200 of file zip.c.

 {
     linkedlist_datablock_internal* ldi;
     const unsigned char* from_copy;
 
     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)
     {
         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 == NULL)
                 return ZIP_INTERNALERROR;
             ldi = ldi->next_datablock ;
             ll->last_block = ldi;
         }
 
         if (ldi->avail_in_this_block < len)
             copy_this = (uInt)ldi->avail_in_this_block;
         else
             copy_this = (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;
 }

◆ allocate_new_datablock()

local linkedlist_datablock_internal* allocate_new_datablock ( )

Definition at line 161 of file zip.c.

 {
     linkedlist_datablock_internal* ldi;
     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_datablock()

local void free_datablock ( linkedlist_datablock_internal* ldi )

Definition at line 175 of file zip.c.

 {
     while (ldi!=NULL)
     {
         linkedlist_datablock_internal* ldinext = ldi->next_datablock;
         TRYFREE(ldi);
         ldi = ldinext;
     }
 }

◆ free_linkedlist()

local void free_linkedlist ( linkedlist_data* ll )

Definition at line 192 of file zip.c.

 {
     free_datablock(ll->first_block);
     ll->first_block = ll->last_block = NULL;
 }

◆ init_linkedlist()

local void init_linkedlist ( linkedlist_data* ll )

Definition at line 186 of file zip.c.

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

◆ OF() [1/5]

local int ziplocal_putValue OF ( (const zlib_filefunc_def *pzlib_filefunc_def, voidpf filestream, uLong x, int nbByte) )

◆ OF() [2/5]

local void ziplocal_putValue_inmemory OF ( (void *dest, uLong x, int nbByte) )

◆ OF() [3/5]

local int ziplocal_getByte OF ( (const zlib_filefunc_def *pzlib_filefunc_def, voidpf filestream, int *pi) )

◆ OF() [4/5]

local int ziplocal_getShort OF ( (const zlib_filefunc_def *pzlib_filefunc_def, voidpf filestream, uLong *pX) )

◆ OF() [5/5]

local uLong ziplocal_SearchCentralDir OF ( (const zlib_filefunc_def *pzlib_filefunc_def, voidpf filestream) )

◆ zipClose()

int ZEXPORT zipClose	(	zipFile	file,
		const char*	global_comment
	)

Definition at line 1133 of file zip.c.

 {
     zip_internal* zi;
     int err = 0;
     uLong size_centraldir = 0;
     uLong centraldir_pos_inzip;
     uInt size_global_comment;
     if (file == NULL)
         return ZIP_PARAMERROR;
     zi = (zip_internal*)file;
 
     if (zi->in_opened_file_inzip == 1)
     {
         err = zipCloseFileInZip (file);
     }
 
 #ifndef NO_ADDFILEINEXISTINGZIP
     if (global_comment==NULL)
         global_comment = zi->globalcomment;
 #endif
     if (global_comment==NULL)
         size_global_comment = 0;
     else
         size_global_comment = (uInt)strlen(global_comment);
 
     centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
     if (err==ZIP_OK)
     {
         linkedlist_datablock_internal* ldi = zi->central_dir.first_block ;
         while (ldi!=NULL)
         {
             if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
                 if (ZWRITE(zi->z_filefunc,zi->filestream,
                            ldi->data,ldi->filled_in_this_block)
                               !=ldi->filled_in_this_block )
                     err = ZIP_ERRNO;
 
             size_centraldir += ldi->filled_in_this_block;
             ldi = ldi->next_datablock;
         }
     }
     free_datablock(zi->central_dir.first_block);
 
     if (err==ZIP_OK) /* Magic End */
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
 
     if (err==ZIP_OK) /* number of this disk */
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
 
     if (err==ZIP_OK) /* number of the disk with the start of the central directory */
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
 
     if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
 
     if (err==ZIP_OK) /* total number of entries in the central dir */
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
 
     if (err==ZIP_OK) /* size of the central directory */
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
 
     if (err==ZIP_OK) /* offset of start of central directory with respect to the
                             starting disk number */
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,
                                 (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
 
     if (err==ZIP_OK) /* zipfile comment length */
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
 
     if ((err==ZIP_OK) && (size_global_comment>0))
         if (ZWRITE(zi->z_filefunc,zi->filestream,
                    global_comment,size_global_comment) != size_global_comment)
                 err = ZIP_ERRNO;
 
     if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0)
         if (err == ZIP_OK)
             err = ZIP_ERRNO;
 
 #ifndef NO_ADDFILEINEXISTINGZIP
     TRYFREE(zi->globalcomment);
 #endif
     TRYFREE(zi);
 
     return err;
 }

◆ zipCloseFileInZip()

int ZEXPORT zipCloseFileInZip ( zipFile file )

Definition at line 1127 of file zip.c.

 {
     return zipCloseFileInZipRaw (file,0,0);
 }

◆ zipCloseFileInZipRaw()

int ZEXPORT zipCloseFileInZipRaw	(	zipFile	file,
		uLong	uncompressed_size,
		uLong	crc32
	)

Definition at line 1031 of file zip.c.

 {
     zip_internal* zi;
     uLong compressed_size;
     int err=ZIP_OK;
 
     if (file == NULL)
         return ZIP_PARAMERROR;
     zi = (zip_internal*)file;
 
     if (zi->in_opened_file_inzip == 0)
         return ZIP_PARAMERROR;
     zi->ci.stream.avail_in = 0;
 
     if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
         while (err==ZIP_OK)
     {
         uLong uTotalOutBefore;
         if (zi->ci.stream.avail_out == 0)
         {
             if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
                 err = ZIP_ERRNO;
             zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
             zi->ci.stream.next_out = zi->ci.buffered_data;
         }
         uTotalOutBefore = zi->ci.stream.total_out;
         err=deflate(&zi->ci.stream,  Z_FINISH);
         zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
     }
 
     if (err==Z_STREAM_END)
         err=ZIP_OK; /* this is normal */
 
     if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
         if (zipFlushWriteBuffer(zi)==ZIP_ERRNO)
             err = ZIP_ERRNO;
 
     if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
     {
         err=deflateEnd(&zi->ci.stream);
         zi->ci.stream_initialised = 0;
     }
 
     if (!zi->ci.raw)
     {
         crc32 = (uLong)zi->ci.crc32;
         uncompressed_size = (uLong)zi->ci.stream.total_in;
     }
     compressed_size = (uLong)zi->ci.stream.total_out;
 #    ifndef NOCRYPT
     compressed_size += zi->ci.crypt_header_size;
 #    endif
 
     ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
     ziplocal_putValue_inmemory(zi->ci.central_header+20,
                                 compressed_size,4); /*compr size*/
     if (zi->ci.stream.data_type == Z_ASCII)
         ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
     ziplocal_putValue_inmemory(zi->ci.central_header+24,
                                 uncompressed_size,4); /*uncompr size*/
 
     if (err==ZIP_OK)
         err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header,
                                        (uLong)zi->ci.size_centralheader);
     free(zi->ci.central_header);
 
     if (err==ZIP_OK)
     {
         long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
         if (ZSEEK(zi->z_filefunc,zi->filestream,
                   zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
             err = ZIP_ERRNO;
 
         if (err==ZIP_OK)
             err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
 
         if (err==ZIP_OK) /* compressed size, unknown */
             err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
 
         if (err==ZIP_OK) /* uncompressed size, unknown */
             err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
 
         if (ZSEEK(zi->z_filefunc,zi->filestream,
                   cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
             err = ZIP_ERRNO;
     }
 
     zi->number_entry ++;
     zi->in_opened_file_inzip = 0;
 
     return err;
 }

◆ zipFlushWriteBuffer()

local int zipFlushWriteBuffer ( zip_internal* zi )

Definition at line 944 of file zip.c.

 {
     int err=ZIP_OK;
 
     if (zi->ci.encrypt != 0)
     {
 #ifndef NOCRYPT
         uInt i;
         int t;
         for (i=0;i<zi->ci.pos_in_buffered_data;i++)
             zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab,
                                        zi->ci.buffered_data[i],t);
 #endif
     }
     if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data)
                                                                     !=zi->ci.pos_in_buffered_data)
       err = ZIP_ERRNO;
     zi->ci.pos_in_buffered_data = 0;
     return err;
 }

◆ ziplocal_getByte()

local int ziplocal_getByte	(	zlib_filefunc_def*	pzlib_filefunc_def,
		voidpf	filestream,
		int *	pi
	)		const

Definition at line 340 of file zip.c.

 {
     unsigned char c;
     int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
     if (err==1)
     {
         *pi = (int)c;
         return ZIP_OK;
     }
     else
     {
         if (ZERROR(*pzlib_filefunc_def,filestream))
             return ZIP_ERRNO;
         else
             return ZIP_EOF;
     }
 }

◆ ziplocal_getLong()

local int ziplocal_getLong	(	zlib_filefunc_def*	pzlib_filefunc_def,
		voidpf	filestream,
		uLong *	pX
	)		const

Definition at line 398 of file zip.c.

 {
     uLong x ;
     int i;
     int err;
 
     err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     x = (uLong)i;
 
     if (err==ZIP_OK)
         err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     x += ((uLong)i)<<8;
 
     if (err==ZIP_OK)
         err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     x += ((uLong)i)<<16;
 
     if (err==ZIP_OK)
         err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     x += ((uLong)i)<<24;
 
     if (err==ZIP_OK)
         *pX = x;
     else
         *pX = 0;
     return err;
 }

◆ ziplocal_getShort()

local int ziplocal_getShort	(	zlib_filefunc_def*	pzlib_filefunc_def,
		voidpf	filestream,
		uLong *	pX
	)		const

Definition at line 370 of file zip.c.

 {
     uLong x ;
     int i;
     int err;
 
     err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     x = (uLong)i;
 
     if (err==ZIP_OK)
         err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     x += ((uLong)i)<<8;
 
     if (err==ZIP_OK)
         *pX = x;
     else
         *pX = 0;
     return err;
 }

◆ ziplocal_putValue()

local int ziplocal_putValue	(	zlib_filefunc_def*	pzlib_filefunc_def,
		voidpf	filestream,
		uLong	x,
		int	nbByte
	)		const

Definition at line 266 of file zip.c.

 {
     unsigned char buf[4];
     int n;
     for (n = 0; n < nbByte; n++)
     {
         buf[n] = (unsigned char)(x & 0xff);
         x >>= 8;
     }
     if (x != 0)
       {     /* data overflow - hack for ZIP64 (X Roche) */
       for (n = 0; n < nbByte; n++)
         {
           buf[n] = 0xff;
         }
       }
 
     if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
         return ZIP_ERRNO;
     else
         return ZIP_OK;
 }

◆ ziplocal_putValue_inmemory()

local void ziplocal_putValue_inmemory	(	void*	dest,
		uLong	x,
		int	nbByte
	)

Definition at line 294 of file zip.c.

 {
     unsigned char* buf=(unsigned char*)dest;
     int n;
     for (n = 0; n < nbByte; n++) {
         buf[n] = (unsigned char)(x & 0xff);
         x >>= 8;
     }
 
     if (x != 0)
     {     /* data overflow - hack for ZIP64 */
        for (n = 0; n < nbByte; n++)
        {
           buf[n] = 0xff;
        }
     }
 }

◆ ziplocal_SearchCentralDir()

local uLong ziplocal_SearchCentralDir	(	zlib_filefunc_def*	pzlib_filefunc_def,
		voidpf	filestream
	)		const

Definition at line 440 of file zip.c.

 {
     unsigned char* buf;
     uLong uSizeFile;
     uLong uBackRead;
     uLong uMaxBack=0xffff; /* maximum size of global comment */
     uLong uPosFound=0;
 
     if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
         return 0;
 
 
     uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
 
     if (uMaxBack>uSizeFile)
         uMaxBack = uSizeFile;
 
     buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
     if (buf==NULL)
         return 0;
 
     uBackRead = 4;
     while (uBackRead<uMaxBack)
     {
         uLong uReadSize,uReadPos ;
         int i;
         if (uBackRead+BUFREADCOMMENT>uMaxBack)
             uBackRead = uMaxBack;
         else
             uBackRead+=BUFREADCOMMENT;
         uReadPos = uSizeFile-uBackRead ;
 
         uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
                      (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
         if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
             break;
 
         if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
             break;
 
         for (i=(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;
 }

◆ ziplocal_TmzDateToDosDate()

local uLong ziplocal_TmzDateToDosDate	(	tm_zip*	ptm,
		uLong	dosDate
	)		const

Definition at line 318 of file zip.c.

 {
     uLong year = (uLong)ptm->tm_year;
     if (year>1980)
         year-=1980;
     else if (year>80)
         year-=80;
     return
       (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
         ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
 }

◆ zipOpen()

zipFile ZEXPORT zipOpen	(	char *	pathname,
		int	append
	)		const

Definition at line 683 of file zip.c.

 {
     return zipOpen2(pathname,append,NULL,NULL);
 }

◆ zipOpen2()

zipFile ZEXPORT zipOpen2	(	char *	pathname,
		int	append,
		zipcharpc*	globalcomment,
		zlib_filefunc_def*	pzlib_filefunc_def
	)		const

Definition at line 499 of file zip.c.

 {
     zip_internal ziinit;
     zip_internal* zi;
     int err=ZIP_OK;
 
 
     if (pzlib_filefunc_def==NULL)
         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 == NULL)
         return NULL;
     ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream);
     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 = (zip_internal*)ALLOC(sizeof(zip_internal));
     if (zi==NULL)
     {
         ZCLOSE(ziinit.z_filefunc,ziinit.filestream);
         return NULL;
     }
 
     /* now we add file in a zipfile */
 #    ifndef NO_ADDFILEINEXISTINGZIP
     ziinit.globalcomment = NULL;
     if (append == APPEND_STATUS_ADDINZIP)
     {
         uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
 
         uLong size_central_dir;     /* size of the central directory  */
         uLong offset_central_dir;   /* offset of start of central directory */
         uLong central_pos,uL;
 
         uLong number_disk;          /* number of the current dist, used for
                                     spaning ZIP, unsupported, always 0*/
         uLong number_disk_with_CD;  /* number the the disk with central dir, used
                                     for spaning ZIP, unsupported, always 0*/
         uLong number_entry;
         uLong number_entry_CD;      /* total number of entries in
                                     the central dir
                                     (same than number_entry on nospan) */
         uLong size_comment;
 
         central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream);
         if (central_pos==0)
             err=ZIP_ERRNO;
 
         if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
                                         central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
             err=ZIP_ERRNO;
 
         /* the signature, already checked */
         if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK)
             err=ZIP_ERRNO;
 
         /* number of this disk */
         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK)
             err=ZIP_ERRNO;
 
         /* number of the disk with the start of the central directory */
         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK)
             err=ZIP_ERRNO;
 
         /* total number of entries in the central dir on this disk */
         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK)
             err=ZIP_ERRNO;
 
         /* total number of entries in the central dir */
         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.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 (ziplocal_getLong(&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 (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK)
             err=ZIP_ERRNO;
 
         /* zipfile global comment length */
         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.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)
         {
             ZCLOSE(ziinit.z_filefunc, ziinit.filestream);
             return NULL;
         }
 
         if (size_comment>0)
         {
             ziinit.globalcomment = ALLOC(size_comment+1);
             if (ziinit.globalcomment)
             {
                size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment);
                ziinit.globalcomment[size_comment]=0;
             }
         }
 
         byte_before_the_zipfile = central_pos -
                                 (offset_central_dir+size_central_dir);
         ziinit.add_position_when_writting_offset = byte_before_the_zipfile;
 
         {
             uLong size_central_dir_to_read = size_central_dir;
             size_t buf_size = SIZEDATA_INDATABLOCK;
             void* buf_read = (void*)ALLOC(buf_size);
             if (ZSEEK(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))
             {
                 uLong read_this = SIZEDATA_INDATABLOCK;
                 if (read_this > size_central_dir_to_read)
                     read_this = size_central_dir_to_read;
                 if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this)
                     err=ZIP_ERRNO;
 
                 if (err==ZIP_OK)
                     err = add_data_in_datablock(&ziinit.central_dir,buf_read,
                                                 (uLong)read_this);
                 size_central_dir_to_read-=read_this;
             }
             TRYFREE(buf_read);
         }
         ziinit.begin_pos = byte_before_the_zipfile;
         ziinit.number_entry = number_entry_CD;
 
         if (ZSEEK(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 /* !NO_ADDFILEINEXISTINGZIP*/
 
     if (err != ZIP_OK)
     {
 #    ifndef NO_ADDFILEINEXISTINGZIP
         TRYFREE(ziinit.globalcomment);
 #    endif /* !NO_ADDFILEINEXISTINGZIP*/
         TRYFREE(zi);
         return NULL;
     }
     else
     {
         *zi = ziinit;
         return (zipFile)zi;
     }
 }

◆ zipOpenNewFileInZip()

int ZEXPORT zipOpenNewFileInZip	(	zipFile	file,
		const char*	filename,
		const zip_fileinfo*	zipfi,
		const void*	extrafield_local,
		uInt	size_extrafield_local,
		const void*	extrafield_global,
		uInt	size_extrafield_global,
		const char*	comment,
		int	method,
		int	level
	)

Definition at line 923 of file zip.c.

 {
     return zipOpenNewFileInZip2 (file, filename, zipfi,
                                  extrafield_local, size_extrafield_local,
                                  extrafield_global, size_extrafield_global,
                                  comment, method, level, 0);
 }

◆ zipOpenNewFileInZip2()

int ZEXPORT zipOpenNewFileInZip2	(	zipFile	file,
		const char*	filename,
		const zip_fileinfo*	zipfi,
		const void*	extrafield_local,
		uInt	size_extrafield_local,
		const void*	extrafield_global,
		uInt	size_extrafield_global,
		const char*	comment,
		int	method,
		int	level,
		int	raw
	)

Definition at line 899 of file zip.c.

 {
     return zipOpenNewFileInZip3 (file, filename, zipfi,
                                  extrafield_local, size_extrafield_local,
                                  extrafield_global, size_extrafield_global,
                                  comment, method, level, raw,
                                  -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
                                  NULL, 0);
 }

◆ zipOpenNewFileInZip3()

int ZEXPORT zipOpenNewFileInZip3	(	zipFile	file,
		const char*	filename,
		const zip_fileinfo*	zipfi,
		const void*	extrafield_local,
		uInt	size_extrafield_local,
		const void*	extrafield_global,
		uInt	size_extrafield_global,
		const char*	comment,
		int	method,
		int	level,
		int	raw,
		int	windowBits,
		int	memLevel,
		int	strategy,
		const char*	password,
		uLong	crcForCrypting
	)

Definition at line 690 of file zip.c.

 {
     zip_internal* zi;
     uInt size_filename;
     uInt size_comment;
     uInt i;
     int err = ZIP_OK;
 
 #    ifdef NOCRYPT
     if (password != NULL)
         return ZIP_PARAMERROR;
 #    endif
 
     if (file == NULL)
         return ZIP_PARAMERROR;
     if ((method!=0) && (method!=Z_DEFLATED))
         return ZIP_PARAMERROR;
 
     zi = (zip_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 = 0;
     else
         size_comment = (uInt)strlen(comment);
 
     size_filename = (uInt)strlen(filename);
 
     if (zipfi == NULL)
         zi->ci.dosDate = 0;
     else
     {
         if (zipfi->dosDate != 0)
             zi->ci.dosDate = zipfi->dosDate;
         else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate);
     }
 
     zi->ci.flag = 0;
     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;
 
     zi->ci.crc32 = 0;
     zi->ci.method = method;
     zi->ci.encrypt = 0;
     zi->ci.stream_initialised = 0;
     zi->ci.pos_in_buffered_data = 0;
     zi->ci.raw = raw;
     zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ;
     zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename +
                                       size_extrafield_global + size_comment;
     zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader);
 
     ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
     /* version info */
     ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2);
     ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
     ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
     ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
     ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
     ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
     ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
     ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
     ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
     ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
     ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
     ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
 
     if (zipfi==NULL)
         ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
     else
         ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
 
     if (zipfi==NULL)
         ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
     else
         ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
 
     ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4);
 
     for (i=0;i<size_filename;i++)
         *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
 
     for (i=0;i<size_extrafield_global;i++)
         *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
               *(((const char*)extrafield_global)+i);
 
     for (i=0;i<size_comment;i++)
         *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
               size_extrafield_global+i) = *(comment+i);
     if (zi->ci.central_header == NULL)
         return ZIP_INTERNALERROR;
 
     /* write the local header */
     err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4);
 
     if (err==ZIP_OK)
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
     if (err==ZIP_OK)
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
 
     if (err==ZIP_OK)
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
 
     if (err==ZIP_OK)
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
 
     if (err==ZIP_OK)
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
     if (err==ZIP_OK)
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
     if (err==ZIP_OK)
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
 
     if (err==ZIP_OK)
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
 
     if (err==ZIP_OK)
         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2);
 
     if ((err==ZIP_OK) && (size_filename>0))
         if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
                 err = ZIP_ERRNO;
 
     if ((err==ZIP_OK) && (size_extrafield_local>0))
         if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local)
                                                                            !=size_extrafield_local)
                 err = ZIP_ERRNO;
 
     zi->ci.stream.avail_in = (uInt)0;
     zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
     zi->ci.stream.next_out = zi->ci.buffered_data;
     zi->ci.stream.total_in = 0;
     zi->ci.stream.total_out = 0;
 
     if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
     {
         zi->ci.stream.zalloc = (alloc_func)0;
         zi->ci.stream.zfree = (free_func)0;
         zi->ci.stream.opaque = (voidpf)0;
 
         if (windowBits>0)
             windowBits = -windowBits;
 
         err = deflateInit2(&zi->ci.stream, level,
                Z_DEFLATED, windowBits, memLevel, strategy);
 
         if (err==Z_OK)
             zi->ci.stream_initialised = 1;
     }
 #    ifndef NOCRYPT
     zi->ci.crypt_header_size = 0;
     if ((err==Z_OK) && (password != NULL))
     {
         unsigned char bufHead[RAND_HEAD_LEN];
         unsigned int sizeHead;
         zi->ci.encrypt = 1;
         zi->ci.pcrc_32_tab = get_crc_table();
         /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
 
         sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
         zi->ci.crypt_header_size = sizeHead;
 
         if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
                 err = ZIP_ERRNO;
     }
 #    endif
 
     if (err==Z_OK)
         zi->in_opened_file_inzip = 1;
     return err;
 }

◆ zipWriteInFileInZip()

int ZEXPORT zipWriteInFileInZip	(	zipFile	file,
		const void*	buf,
		unsigned	len
	)

Definition at line 966 of file zip.c.

 {
     zip_internal* zi;
     int err=ZIP_OK;
 
     if (file == NULL)
         return ZIP_PARAMERROR;
     zi = (zip_internal*)file;
 
     if (zi->in_opened_file_inzip == 0)
         return ZIP_PARAMERROR;
 
     zi->ci.stream.next_in = (void*)buf;
     zi->ci.stream.avail_in = len;
     zi->ci.crc32 = crc32(zi->ci.crc32,buf,len);
 
     while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
     {
         if (zi->ci.stream.avail_out == 0)
         {
             if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
                 err = ZIP_ERRNO;
             zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
             zi->ci.stream.next_out = zi->ci.buffered_data;
         }
 
 
         if(err != ZIP_OK)
             break;
 
         if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
         {
             uLong uTotalOutBefore = zi->ci.stream.total_out;
             err=deflate(&zi->ci.stream,  Z_NO_FLUSH);
             zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
 
         }
         else
         {
             uInt copy_this,i;
             if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
                 copy_this = zi->ci.stream.avail_in;
             else
                 copy_this = zi->ci.stream.avail_out;
             for (i=0;i<copy_this;i++)
                 *(((char*)zi->ci.stream.next_out)+i) =
                     *(((const char*)zi->ci.stream.next_in)+i);
             {
                 zi->ci.stream.avail_in -= copy_this;
                 zi->ci.stream.avail_out-= copy_this;
                 zi->ci.stream.next_in+= copy_this;
                 zi->ci.stream.next_out+= copy_this;
                 zi->ci.stream.total_in+= copy_this;
                 zi->ci.stream.total_out+= copy_this;
                 zi->ci.pos_in_buffered_data += copy_this;
             }
         }
     }
 
     return err;
 }

Variable Documentation

◆ zip_copyright

const char zip_copyright[]

Initial value:

=

Definition at line 82 of file zip.c.

Classes

Macros

Typedefs

Functions

Variables