zip.c@ 40354

Last change on this file since 40354 was 40354, checked in by vboxsync, 13 years ago
libs/zlib-1.2.6: fix OSE
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 64.3 KB

Line
1	/* zip.c -- IO on .zip files using zlib
2	Version 1.1, February 14h, 2010
3	part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
4
5	Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
6
7	Modifications for Zip64 support
8	Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
9
10	For more info read MiniZip_info.txt
11
12	Changes
13	Oct-2009 - Mathias Svensson - Remove old C style function prototypes
14	Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives
15	Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions.
16	Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data
17	It is used when recreting zip archive with RAW when deleting items from a zip.
18	ZIP64 data is automaticly added to items that needs it, and existing ZIP64 data need to be removed.
19	Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required)
20	Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
21
22	*/
23
24
25	#include <stdio.h>
26	#include <stdlib.h>
27	#include <string.h>
28	#include <time.h>
29	#include "zlib.h"
30	#include "zip.h"
31
32	#ifdef STDC
33	# include <stddef.h>
34	# include <string.h>
35	# include <stdlib.h>
36	#endif
37	#ifdef NO_ERRNO_H
38	extern int errno;
39	#else
40	# include <errno.h>
41	#endif
42
43
44	#ifndef local
45	# define local static
46	#endif
47	/* compile with -Dlocal if your debugger can't find static symbols */
48
49	#ifndef VERSIONMADEBY
50	# define VERSIONMADEBY (0x0) /* platform depedent */
51	#endif
52
53	#ifndef Z_BUFSIZE
54	#define Z_BUFSIZE (64*1024) //(16384)
55	#endif
56
57	#ifndef Z_MAXFILENAMEINZIP
58	#define Z_MAXFILENAMEINZIP (256)
59	#endif
60
61	#ifndef ALLOC
62	# define ALLOC(size) (malloc(size))
63	#endif
64	#ifndef TRYFREE
65	# define TRYFREE(p) {if (p) free(p);}
66	#endif
67
68	/*
69	#define SIZECENTRALDIRITEM (0x2e)
70	#define SIZEZIPLOCALHEADER (0x1e)
71	*/
72
73	/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
74
75
76	// NOT sure that this work on ALL platform
77	#define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) \| ((ZPOS64_T)((unsigned long)(b))) << 32))
78
79	#ifndef SEEK_CUR
80	#define SEEK_CUR 1
81	#endif
82
83	#ifndef SEEK_END
84	#define SEEK_END 2
85	#endif
86
87	#ifndef SEEK_SET
88	#define SEEK_SET 0
89	#endif
90
91	#ifndef DEF_MEM_LEVEL
92	#if MAX_MEM_LEVEL >= 8
93	# define DEF_MEM_LEVEL 8
94	#else
95	# define DEF_MEM_LEVEL MAX_MEM_LEVEL
96	#endif
97	#endif
98	const char zip_copyright[] =" zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
99
100
101	#define SIZEDATA_INDATABLOCK (4096-(4*4))
102
103	#define LOCALHEADERMAGIC (0x04034b50)
104	#define CENTRALHEADERMAGIC (0x02014b50)
105	#define ENDHEADERMAGIC (0x06054b50)
106	#define ZIP64ENDHEADERMAGIC (0x6064b50)
107	#define ZIP64ENDLOCHEADERMAGIC (0x7064b50)
108
109	#define FLAG_LOCALHEADER_OFFSET (0x06)
110	#define CRC_LOCALHEADER_OFFSET (0x0e)
111
112	#define SIZECENTRALHEADER (0x2e) /* 46 */
113
114	typedef struct linkedlist_datablock_internal_s
115	{
116	struct linkedlist_datablock_internal_s* next_datablock;
117	uLong avail_in_this_block;
118	uLong filled_in_this_block;
119	uLong unused; /* for future use and alignement */
120	unsigned char data[SIZEDATA_INDATABLOCK];
121	} linkedlist_datablock_internal;
122
123	typedef struct linkedlist_data_s
124	{
125	linkedlist_datablock_internal* first_block;
126	linkedlist_datablock_internal* last_block;
127	} linkedlist_data;
128
129
130	typedef struct
131	{
132	z_stream stream; /* zLib stream structure for inflate */
133	#ifdef HAVE_BZIP2
134	bz_stream bstream; /* bzLib stream structure for bziped */
135	#endif
136
137	int stream_initialised; /* 1 is stream is initialised */
138	uInt pos_in_buffered_data; /* last written byte in buffered_data */
139
140	ZPOS64_T pos_local_header; /* offset of the local header of the file
141	currenty writing */
142	char* central_header; /* central header data for the current file */
143	uLong size_centralExtra;
144	uLong size_centralheader; /* size of the central header for cur file */
145	uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */
146	uLong flag; /* flag of the file currently writing */
147
148	int method; /* compression method of file currenty wr.*/
149	int raw; /* 1 for directly writing raw data */
150	Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
151	uLong dosDate;
152	uLong crc32;
153	int encrypt;
154	int zip64; /* Add ZIP64 extened information in the extra field */
155	ZPOS64_T pos_zip64extrainfo;
156	ZPOS64_T totalCompressedData;
157	ZPOS64_T totalUncompressedData;
158	#ifndef NOCRYPT
159	unsigned long keys[3]; /* keys defining the pseudo-random sequence */
160	const unsigned long* pcrc_32_tab;
161	int crypt_header_size;
162	#endif
163	} curfile64_info;
164
165	typedef struct
166	{
167	zlib_filefunc64_32_def z_filefunc;
168	voidpf filestream; /* io structore of the zipfile */
169	linkedlist_data central_dir;/* datablock with central dir in construction*/
170	int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/
171	curfile64_info ci; /* info on the file curretly writing */
172
173	ZPOS64_T begin_pos; /* position of the beginning of the zipfile */
174	ZPOS64_T add_position_when_writting_offset;
175	ZPOS64_T number_entry;
176
177	#ifndef NO_ADDFILEINEXISTINGZIP
178	char *globalcomment;
179	#endif
180
181	} zip64_internal;
182
183
184	#ifndef NOCRYPT
185	#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
186	#include "crypt.h"
187	#endif
188
189	local linkedlist_datablock_internal* allocate_new_datablock()
190	{
191	linkedlist_datablock_internal* ldi;
192	ldi = (linkedlist_datablock_internal*)
193	ALLOC(sizeof(linkedlist_datablock_internal));
194	if (ldi!=NULL)
195	{
196	ldi->next_datablock = NULL ;
197	ldi->filled_in_this_block = 0 ;
198	ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
199	}
200	return ldi;
201	}
202
203	local void free_datablock(linkedlist_datablock_internal* ldi)
204	{
205	while (ldi!=NULL)
206	{
207	linkedlist_datablock_internal* ldinext = ldi->next_datablock;
208	TRYFREE(ldi);
209	ldi = ldinext;
210	}
211	}
212
213	local void init_linkedlist(linkedlist_data* ll)
214	{
215	ll->first_block = ll->last_block = NULL;
216	}
217
218	local void free_linkedlist(linkedlist_data* ll)
219	{
220	free_datablock(ll->first_block);
221	ll->first_block = ll->last_block = NULL;
222	}
223
224
225	local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len)
226	{
227	linkedlist_datablock_internal* ldi;
228	const unsigned char* from_copy;
229
230	if (ll==NULL)
231	return ZIP_INTERNALERROR;
232
233	if (ll->last_block == NULL)
234	{
235	ll->first_block = ll->last_block = allocate_new_datablock();
236	if (ll->first_block == NULL)
237	return ZIP_INTERNALERROR;
238	}
239
240	ldi = ll->last_block;
241	from_copy = (unsigned char*)buf;
242
243	while (len>0)
244	{
245	uInt copy_this;
246	uInt i;
247	unsigned char* to_copy;
248
249	if (ldi->avail_in_this_block==0)
250	{
251	ldi->next_datablock = allocate_new_datablock();
252	if (ldi->next_datablock == NULL)
253	return ZIP_INTERNALERROR;
254	ldi = ldi->next_datablock ;
255	ll->last_block = ldi;
256	}
257
258	if (ldi->avail_in_this_block < len)
259	copy_this = (uInt)ldi->avail_in_this_block;
260	else
261	copy_this = (uInt)len;
262
263	to_copy = &(ldi->data[ldi->filled_in_this_block]);
264
265	for (i=0;i<copy_this;i++)
266	(to_copy+i)=(from_copy+i);
267
268	ldi->filled_in_this_block += copy_this;
269	ldi->avail_in_this_block -= copy_this;
270	from_copy += copy_this ;
271	len -= copy_this;
272	}
273	return ZIP_OK;
274	}
275
276
277
278	/****************************************************************************/
279
280	#ifndef NO_ADDFILEINEXISTINGZIP
281	/* ===========================================================================
282	Inputs a long in LSB order to the given file
283	nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T)
284	*/
285
286	local int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte));
287	local int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte)
288	{
289	unsigned char buf[8];
290	int n;
291	for (n = 0; n < nbByte; n++)
292	{
293	buf[n] = (unsigned char)(x & 0xff);
294	x >>= 8;
295	}
296	if (x != 0)
297	{ /* data overflow - hack for ZIP64 (X Roche) */
298	for (n = 0; n < nbByte; n++)
299	{
300	buf[n] = 0xff;
301	}
302	}
303
304	if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
305	return ZIP_ERRNO;
306	else
307	return ZIP_OK;
308	}
309
310	local void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte));
311	local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte)
312	{
313	unsigned char* buf=(unsigned char*)dest;
314	int n;
315	for (n = 0; n < nbByte; n++) {
316	buf[n] = (unsigned char)(x & 0xff);
317	x >>= 8;
318	}
319
320	if (x != 0)
321	{ /* data overflow - hack for ZIP64 */
322	for (n = 0; n < nbByte; n++)
323	{
324	buf[n] = 0xff;
325	}
326	}
327	}
328
329	/****************************************************************************/
330
331
332	local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm)
333	{
334	uLong year = (uLong)ptm->tm_year;
335	if (year>=1980)
336	year-=1980;
337	else if (year>=80)
338	year-=80;
339	return
340	(uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) \|
341	((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
342	}
343
344
345	/****************************************************************************/
346
347	local int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi));
348
349	local int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def,voidpf filestream,int* pi)
350	{
351	unsigned char c;
352	int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
353	if (err==1)
354	{
355	*pi = (int)c;
356	return ZIP_OK;
357	}
358	else
359	{
360	if (ZERROR64(*pzlib_filefunc_def,filestream))
361	return ZIP_ERRNO;
362	else
363	return ZIP_EOF;
364	}
365	}
366
367
368	/* ===========================================================================
369	Reads a long in LSB order from the given gz_stream. Sets
370	*/
371	local int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
372
373	local int zip64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
374	{
375	uLong x ;
376	int i = 0;
377	int err;
378
379	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
380	x = (uLong)i;
381
382	if (err==ZIP_OK)
383	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
384	x += ((uLong)i)<<8;
385
386	if (err==ZIP_OK)
387	*pX = x;
388	else
389	*pX = 0;
390	return err;
391	}
392
393	local int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
394
395	local int zip64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
396	{
397	uLong x ;
398	int i = 0;
399	int err;
400
401	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
402	x = (uLong)i;
403
404	if (err==ZIP_OK)
405	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
406	x += ((uLong)i)<<8;
407
408	if (err==ZIP_OK)
409	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
410	x += ((uLong)i)<<16;
411
412	if (err==ZIP_OK)
413	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
414	x += ((uLong)i)<<24;
415
416	if (err==ZIP_OK)
417	*pX = x;
418	else
419	*pX = 0;
420	return err;
421	}
422
423	local int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX));
424
425
426	local int zip64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)
427	{
428	ZPOS64_T x;
429	int i = 0;
430	int err;
431
432	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
433	x = (ZPOS64_T)i;
434
435	if (err==ZIP_OK)
436	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
437	x += ((ZPOS64_T)i)<<8;
438
439	if (err==ZIP_OK)
440	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
441	x += ((ZPOS64_T)i)<<16;
442
443	if (err==ZIP_OK)
444	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
445	x += ((ZPOS64_T)i)<<24;
446
447	if (err==ZIP_OK)
448	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
449	x += ((ZPOS64_T)i)<<32;
450
451	if (err==ZIP_OK)
452	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
453	x += ((ZPOS64_T)i)<<40;
454
455	if (err==ZIP_OK)
456	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
457	x += ((ZPOS64_T)i)<<48;
458
459	if (err==ZIP_OK)
460	err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
461	x += ((ZPOS64_T)i)<<56;
462
463	if (err==ZIP_OK)
464	*pX = x;
465	else
466	*pX = 0;
467
468	return err;
469	}
470
471	#ifndef BUFREADCOMMENT
472	#define BUFREADCOMMENT (0x400)
473	#endif
474	/*
475	Locate the Central directory of a zipfile (at the end, just before
476	the global comment)
477	*/
478	local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
479
480	local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
481	{
482	unsigned char* buf;
483	ZPOS64_T uSizeFile;
484	ZPOS64_T uBackRead;
485	ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
486	ZPOS64_T uPosFound=0;
487
488	if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
489	return 0;
490
491
492	uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
493
494	if (uMaxBack>uSizeFile)
495	uMaxBack = uSizeFile;
496
497	buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
498	if (buf==NULL)
499	return 0;
500
501	uBackRead = 4;
502	while (uBackRead<uMaxBack)
503	{
504	uLong uReadSize;
505	ZPOS64_T uReadPos ;
506	int i;
507	if (uBackRead+BUFREADCOMMENT>uMaxBack)
508	uBackRead = uMaxBack;
509	else
510	uBackRead+=BUFREADCOMMENT;
511	uReadPos = uSizeFile-uBackRead ;
512
513	uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
514	(BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
515	if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
516	break;
517
518	if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
519	break;
520
521	for (i=(int)uReadSize-3; (i--)>0;)
522	if ((((buf+i))==0x50) && (((buf+i+1))==0x4b) &&
523	(((buf+i+2))==0x05) && (((buf+i+3))==0x06))
524	{
525	uPosFound = uReadPos+i;
526	break;
527	}
528
529	if (uPosFound!=0)
530	break;
531	}
532	TRYFREE(buf);
533	return uPosFound;
534	}
535
536	/*
537	Locate the End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before
538	the global comment)
539	*/
540	local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
541
542	local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
543	{
544	unsigned char* buf;
545	ZPOS64_T uSizeFile;
546	ZPOS64_T uBackRead;
547	ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
548	ZPOS64_T uPosFound=0;
549	uLong uL;
550	ZPOS64_T relativeOffset;
551
552	if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
553	return 0;
554
555	uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
556
557	if (uMaxBack>uSizeFile)
558	uMaxBack = uSizeFile;
559
560	buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
561	if (buf==NULL)
562	return 0;
563
564	uBackRead = 4;
565	while (uBackRead<uMaxBack)
566	{
567	uLong uReadSize;
568	ZPOS64_T uReadPos;
569	int i;
570	if (uBackRead+BUFREADCOMMENT>uMaxBack)
571	uBackRead = uMaxBack;
572	else
573	uBackRead+=BUFREADCOMMENT;
574	uReadPos = uSizeFile-uBackRead ;
575
576	uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
577	(BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
578	if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
579	break;
580
581	if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
582	break;
583
584	for (i=(int)uReadSize-3; (i--)>0;)
585	{
586	// Signature "0x07064b50" Zip64 end of central directory locater
587	if ((((buf+i))==0x50) && (((buf+i+1))==0x4b) && (((buf+i+2))==0x06) && (((buf+i+3))==0x07))
588	{
589	uPosFound = uReadPos+i;
590	break;
591	}
592	}
593
594	if (uPosFound!=0)
595	break;
596	}
597
598	TRYFREE(buf);
599	if (uPosFound == 0)
600	return 0;
601
602	/* Zip64 end of central directory locator */
603	if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
604	return 0;
605
606	/* the signature, already checked */
607	if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
608	return 0;
609
610	/* number of the disk with the start of the zip64 end of central directory */
611	if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
612	return 0;
613	if (uL != 0)
614	return 0;
615
616	/* relative offset of the zip64 end of central directory record */
617	if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK)
618	return 0;
619
620	/* total number of disks */
621	if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
622	return 0;
623	if (uL != 1)
624	return 0;
625
626	/* Goto Zip64 end of central directory record */
627	if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
628	return 0;
629
630	/* the signature */
631	if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
632	return 0;
633
634	if (uL != 0x06064b50) // signature of 'Zip64 end of central directory'
635	return 0;
636
637	return relativeOffset;
638	}
639
640	int LoadCentralDirectoryRecord(zip64_internal* pziinit)
641	{
642	int err=ZIP_OK;
643	ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
644
645	ZPOS64_T size_central_dir; /* size of the central directory */
646	ZPOS64_T offset_central_dir; /* offset of start of central directory */
647	ZPOS64_T central_pos;
648	uLong uL;
649
650	uLong number_disk; /* number of the current dist, used for
651	spaning ZIP, unsupported, always 0*/
652	uLong number_disk_with_CD; /* number the the disk with central dir, used
653	for spaning ZIP, unsupported, always 0*/
654	ZPOS64_T number_entry;
655	ZPOS64_T number_entry_CD; /* total number of entries in
656	the central dir
657	(same than number_entry on nospan) */
658	uLong VersionMadeBy;
659	uLong VersionNeeded;
660	uLong size_comment;
661
662	int hasZIP64Record = 0;
663
664	// check first if we find a ZIP64 record
665	central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream);
666	if(central_pos > 0)
667	{
668	hasZIP64Record = 1;
669	}
670	else if(central_pos == 0)
671	{
672	central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream);
673	}
674
675	/* disable to allow appending to empty ZIP archive
676	if (central_pos==0)
677	err=ZIP_ERRNO;
678	*/
679
680	if(hasZIP64Record)
681	{
682	ZPOS64_T sizeEndOfCentralDirectory;
683	if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
684	err=ZIP_ERRNO;
685
686	/* the signature, already checked */
687	if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
688	err=ZIP_ERRNO;
689
690	/* size of zip64 end of central directory record */
691	if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK)
692	err=ZIP_ERRNO;
693
694	/* version made by */
695	if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK)
696	err=ZIP_ERRNO;
697
698	/* version needed to extract */
699	if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK)
700	err=ZIP_ERRNO;
701
702	/* number of this disk */
703	if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
704	err=ZIP_ERRNO;
705
706	/* number of the disk with the start of the central directory */
707	if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
708	err=ZIP_ERRNO;
709
710	/* total number of entries in the central directory on this disk */
711	if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &number_entry)!=ZIP_OK)
712	err=ZIP_ERRNO;
713
714	/* total number of entries in the central directory */
715	if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK)
716	err=ZIP_ERRNO;
717
718	if ((number_entry_CD!=number_entry) \|\| (number_disk_with_CD!=0) \|\| (number_disk!=0))
719	err=ZIP_BADZIPFILE;
720
721	/* size of the central directory */
722	if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK)
723	err=ZIP_ERRNO;
724
725	/* offset of start of central directory with respect to the
726	starting disk number */
727	if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK)
728	err=ZIP_ERRNO;
729
730	// TODO..
731	// read the comment from the standard central header.
732	size_comment = 0;
733	}
734	else
735	{
736	// Read End of central Directory info
737	if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
738	err=ZIP_ERRNO;
739
740	/* the signature, already checked */
741	if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
742	err=ZIP_ERRNO;
743
744	/* number of this disk */
745	if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
746	err=ZIP_ERRNO;
747
748	/* number of the disk with the start of the central directory */
749	if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
750	err=ZIP_ERRNO;
751
752	/* total number of entries in the central dir on this disk */
753	number_entry = 0;
754	if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
755	err=ZIP_ERRNO;
756	else
757	number_entry = uL;
758
759	/* total number of entries in the central dir */
760	number_entry_CD = 0;
761	if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
762	err=ZIP_ERRNO;
763	else
764	number_entry_CD = uL;
765
766	if ((number_entry_CD!=number_entry) \|\| (number_disk_with_CD!=0) \|\| (number_disk!=0))
767	err=ZIP_BADZIPFILE;
768
769	/* size of the central directory */
770	size_central_dir = 0;
771	if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
772	err=ZIP_ERRNO;
773	else
774	size_central_dir = uL;
775
776	/* offset of start of central directory with respect to the starting disk number */
777	offset_central_dir = 0;
778	if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
779	err=ZIP_ERRNO;
780	else
781	offset_central_dir = uL;
782
783
784	/* zipfile global comment length */
785	if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK)
786	err=ZIP_ERRNO;
787	}
788
789	if ((central_pos<offset_central_dir+size_central_dir) &&
790	(err==ZIP_OK))
791	err=ZIP_BADZIPFILE;
792
793	if (err!=ZIP_OK)
794	{
795	ZCLOSE64(pziinit->z_filefunc, pziinit->filestream);
796	return ZIP_ERRNO;
797	}
798
799	if (size_comment>0)
800	{
801	pziinit->globalcomment = (char*)ALLOC(size_comment+1);
802	if (pziinit->globalcomment)
803	{
804	size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment);
805	pziinit->globalcomment[size_comment]=0;
806	}
807	}
808
809	byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir);
810	pziinit->add_position_when_writting_offset = byte_before_the_zipfile;
811
812	{
813	ZPOS64_T size_central_dir_to_read = size_central_dir;
814	size_t buf_size = SIZEDATA_INDATABLOCK;
815	void* buf_read = (void*)ALLOC(buf_size);
816	if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)
817	err=ZIP_ERRNO;
818
819	while ((size_central_dir_to_read>0) && (err==ZIP_OK))
820	{
821	ZPOS64_T read_this = SIZEDATA_INDATABLOCK;
822	if (read_this > size_central_dir_to_read)
823	read_this = size_central_dir_to_read;
824
825	if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this)
826	err=ZIP_ERRNO;
827
828	if (err==ZIP_OK)
829	err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this);
830
831	size_central_dir_to_read-=read_this;
832	}
833	TRYFREE(buf_read);
834	}
835	pziinit->begin_pos = byte_before_the_zipfile;
836	pziinit->number_entry = number_entry_CD;
837
838	if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0)
839	err=ZIP_ERRNO;
840
841	return err;
842	}
843
844
845	#endif /* !NO_ADDFILEINEXISTINGZIP*/
846
847
848	/************************************************************/
849	extern zipFile ZEXPORT zipOpen3 (const void pathname, int append, zipcharpc globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def)
850	{
851	zip64_internal ziinit;
852	zip64_internal* zi;
853	int err=ZIP_OK;
854
855	ziinit.z_filefunc.zseek32_file = NULL;
856	ziinit.z_filefunc.ztell32_file = NULL;
857	if (pzlib_filefunc64_32_def==NULL)
858	fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64);
859	else
860	ziinit.z_filefunc = *pzlib_filefunc64_32_def;
861
862	ziinit.filestream = ZOPEN64(ziinit.z_filefunc,
863	pathname,
864	(append == APPEND_STATUS_CREATE) ?
865	(ZLIB_FILEFUNC_MODE_READ \| ZLIB_FILEFUNC_MODE_WRITE \| ZLIB_FILEFUNC_MODE_CREATE) :
866	(ZLIB_FILEFUNC_MODE_READ \| ZLIB_FILEFUNC_MODE_WRITE \| ZLIB_FILEFUNC_MODE_EXISTING));
867
868	if (ziinit.filestream == NULL)
869	return NULL;
870
871	if (append == APPEND_STATUS_CREATEAFTER)
872	ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END);
873
874	ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream);
875	ziinit.in_opened_file_inzip = 0;
876	ziinit.ci.stream_initialised = 0;
877	ziinit.number_entry = 0;
878	ziinit.add_position_when_writting_offset = 0;
879	init_linkedlist(&(ziinit.central_dir));
880
881
882
883	zi = (zip64_internal*)ALLOC(sizeof(zip64_internal));
884	if (zi==NULL)
885	{
886	ZCLOSE64(ziinit.z_filefunc,ziinit.filestream);
887	return NULL;
888	}
889
890	/* now we add file in a zipfile */
891	# ifndef NO_ADDFILEINEXISTINGZIP
892	ziinit.globalcomment = NULL;
893	if (append == APPEND_STATUS_ADDINZIP)
894	{
895	// Read and Cache Central Directory Records
896	err = LoadCentralDirectoryRecord(&ziinit);
897	}
898
899	if (globalcomment)
900	{
901	*globalcomment = ziinit.globalcomment;
902	}
903	# endif /* !NO_ADDFILEINEXISTINGZIP*/
904
905	if (err != ZIP_OK)
906	{
907	# ifndef NO_ADDFILEINEXISTINGZIP
908	TRYFREE(ziinit.globalcomment);
909	# endif /* !NO_ADDFILEINEXISTINGZIP*/
910	TRYFREE(zi);
911	return NULL;
912	}
913	else
914	{
915	*zi = ziinit;
916	return (zipFile)zi;
917	}
918	}
919
920	extern zipFile ZEXPORT zipOpen2 (const char pathname, int append, zipcharpc globalcomment, zlib_filefunc_def* pzlib_filefunc32_def)
921	{
922	if (pzlib_filefunc32_def != NULL)
923	{
924	zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
925	fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
926	return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
927	}
928	else
929	return zipOpen3(pathname, append, globalcomment, NULL);
930	}
931
932	extern zipFile ZEXPORT zipOpen2_64 (const void pathname, int append, zipcharpc globalcomment, zlib_filefunc64_def* pzlib_filefunc_def)
933	{
934	if (pzlib_filefunc_def != NULL)
935	{
936	zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
937	zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
938	zlib_filefunc64_32_def_fill.ztell32_file = NULL;
939	zlib_filefunc64_32_def_fill.zseek32_file = NULL;
940	return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
941	}
942	else
943	return zipOpen3(pathname, append, globalcomment, NULL);
944	}
945
946
947
948	extern zipFile ZEXPORT zipOpen (const char* pathname, int append)
949	{
950	return zipOpen3((const void*)pathname,append,NULL,NULL);
951	}
952
953	extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append)
954	{
955	return zipOpen3(pathname,append,NULL,NULL);
956	}
957
958	int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local)
959	{
960	/* write the local header */
961	int err;
962	uInt size_filename = (uInt)strlen(filename);
963	uInt size_extrafield = size_extrafield_local;
964
965	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4);
966
967	if (err==ZIP_OK)
968	{
969	if(zi->ci.zip64)
970	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */
971	else
972	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
973	}
974
975	if (err==ZIP_OK)
976	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
977
978	if (err==ZIP_OK)
979	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
980
981	if (err==ZIP_OK)
982	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
983
984	// CRC / Compressed size / Uncompressed size will be filled in later and rewritten later
985	if (err==ZIP_OK)
986	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
987	if (err==ZIP_OK)
988	{
989	if(zi->ci.zip64)
990	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */
991	else
992	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
993	}
994	if (err==ZIP_OK)
995	{
996	if(zi->ci.zip64)
997	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */
998	else
999	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
1000	}
1001
1002	if (err==ZIP_OK)
1003	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
1004
1005	if(zi->ci.zip64)
1006	{
1007	size_extrafield += 20;
1008	}
1009
1010	if (err==ZIP_OK)
1011	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2);
1012
1013	if ((err==ZIP_OK) && (size_filename > 0))
1014	{
1015	if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
1016	err = ZIP_ERRNO;
1017	}
1018
1019	if ((err==ZIP_OK) && (size_extrafield_local > 0))
1020	{
1021	if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local)
1022	err = ZIP_ERRNO;
1023	}
1024
1025
1026	if ((err==ZIP_OK) && (zi->ci.zip64))
1027	{
1028	// write the Zip64 extended info
1029	short HeaderID = 1;
1030	short DataSize = 16;
1031	ZPOS64_T CompressedSize = 0;
1032	ZPOS64_T UncompressedSize = 0;
1033
1034	// Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file)
1035	zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream);
1036
1037	err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2);
1038	err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2);
1039
1040	err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8);
1041	err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8);
1042	}
1043
1044	return err;
1045	}
1046
1047	/*
1048	NOTE.
1049	When writing RAW the ZIP64 extended information in extrafield_local and extrafield_global needs to be stripped
1050	before calling this function it can be done with zipRemoveExtraInfoBlock
1051
1052	It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize
1053	unnecessary allocations.
1054	*/
1055	extern int ZEXPORT zipOpenNewFileInZip4_64 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
1056	const void* extrafield_local, uInt size_extrafield_local,
1057	const void* extrafield_global, uInt size_extrafield_global,
1058	const char* comment, int method, int level, int raw,
1059	int windowBits,int memLevel, int strategy,
1060	const char* password, uLong crcForCrypting,
1061	uLong versionMadeBy, uLong flagBase, int zip64)
1062	{
1063	zip64_internal* zi;
1064	uInt size_filename;
1065	uInt size_comment;
1066	uInt i;
1067	int err = ZIP_OK;
1068
1069	# ifdef NOCRYPT
1070	(crcForCrypting);
1071	if (password != NULL)
1072	return ZIP_PARAMERROR;
1073	# endif
1074
1075	if (file == NULL)
1076	return ZIP_PARAMERROR;
1077
1078	#ifdef HAVE_BZIP2
1079	if ((method!=0) && (method!=Z_DEFLATED) && (method!=Z_BZIP2ED))
1080	return ZIP_PARAMERROR;
1081	#else
1082	if ((method!=0) && (method!=Z_DEFLATED))
1083	return ZIP_PARAMERROR;
1084	#endif
1085
1086	zi = (zip64_internal*)file;
1087
1088	if (zi->in_opened_file_inzip == 1)
1089	{
1090	err = zipCloseFileInZip (file);
1091	if (err != ZIP_OK)
1092	return err;
1093	}
1094
1095	if (filename==NULL)
1096	filename="-";
1097
1098	if (comment==NULL)
1099	size_comment = 0;
1100	else
1101	size_comment = (uInt)strlen(comment);
1102
1103	size_filename = (uInt)strlen(filename);
1104
1105	if (zipfi == NULL)
1106	zi->ci.dosDate = 0;
1107	else
1108	{
1109	if (zipfi->dosDate != 0)
1110	zi->ci.dosDate = zipfi->dosDate;
1111	else
1112	zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date);
1113	}
1114
1115	zi->ci.flag = flagBase;
1116	if ((level==8) \|\| (level==9))
1117	zi->ci.flag \|= 2;
1118	if ((level==2))
1119	zi->ci.flag \|= 4;
1120	if ((level==1))
1121	zi->ci.flag \|= 6;
1122	if (password != NULL)
1123	zi->ci.flag \|= 1;
1124
1125	zi->ci.crc32 = 0;
1126	zi->ci.method = method;
1127	zi->ci.encrypt = 0;
1128	zi->ci.stream_initialised = 0;
1129	zi->ci.pos_in_buffered_data = 0;
1130	zi->ci.raw = raw;
1131	zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream);
1132
1133	zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment;
1134	zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data
1135
1136	zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree);
1137
1138	zi->ci.size_centralExtra = size_extrafield_global;
1139	zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
1140	/* version info */
1141	zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2);
1142	zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
1143	zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
1144	zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
1145	zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
1146	zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /crc/
1147	zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /compr size/
1148	zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /uncompr size/
1149	zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
1150	zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
1151	zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
1152	zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /disk nm start/
1153
1154	if (zipfi==NULL)
1155	zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
1156	else
1157	zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
1158
1159	if (zipfi==NULL)
1160	zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
1161	else
1162	zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
1163
1164	if(zi->ci.pos_local_header >= 0xffffffff)
1165	zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4);
1166	else
1167	zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writting_offset,4);
1168
1169	for (i=0;i<size_filename;i++)
1170	(zi->ci.central_header+SIZECENTRALHEADER+i) = (filename+i);
1171
1172	for (i=0;i<size_extrafield_global;i++)
1173	*(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
1174	(((const char)extrafield_global)+i);
1175
1176	for (i=0;i<size_comment;i++)
1177	*(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
1178	size_extrafield_global+i) = *(comment+i);
1179	if (zi->ci.central_header == NULL)
1180	return ZIP_INTERNALERROR;
1181
1182	zi->ci.zip64 = zip64;
1183	zi->ci.totalCompressedData = 0;
1184	zi->ci.totalUncompressedData = 0;
1185	zi->ci.pos_zip64extrainfo = 0;
1186
1187	err = Write_LocalFileHeader(zi, filename, size_extrafield_local, extrafield_local);
1188
1189	#ifdef HAVE_BZIP2
1190	zi->ci.bstream.avail_in = (uInt)0;
1191	zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
1192	zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
1193	zi->ci.bstream.total_in_hi32 = 0;
1194	zi->ci.bstream.total_in_lo32 = 0;
1195	zi->ci.bstream.total_out_hi32 = 0;
1196	zi->ci.bstream.total_out_lo32 = 0;
1197	#endif
1198
1199	zi->ci.stream.avail_in = (uInt)0;
1200	zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
1201	zi->ci.stream.next_out = zi->ci.buffered_data;
1202	zi->ci.stream.total_in = 0;
1203	zi->ci.stream.total_out = 0;
1204	zi->ci.stream.data_type = Z_BINARY;
1205
1206	#ifdef HAVE_BZIP2
1207	if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED \|\| zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
1208	#else
1209	if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1210	#endif
1211	{
1212	if(zi->ci.method == Z_DEFLATED)
1213	{
1214	zi->ci.stream.zalloc = (alloc_func)0;
1215	zi->ci.stream.zfree = (free_func)0;
1216	zi->ci.stream.opaque = (voidpf)0;
1217
1218	if (windowBits>0)
1219	windowBits = -windowBits;
1220
1221	err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy);
1222
1223	if (err==Z_OK)
1224	zi->ci.stream_initialised = Z_DEFLATED;
1225	}
1226	else if(zi->ci.method == Z_BZIP2ED)
1227	{
1228	#ifdef HAVE_BZIP2
1229	// Init BZip stuff here
1230	zi->ci.bstream.bzalloc = 0;
1231	zi->ci.bstream.bzfree = 0;
1232	zi->ci.bstream.opaque = (voidpf)0;
1233
1234	err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0,35);
1235	if(err == BZ_OK)
1236	zi->ci.stream_initialised = Z_BZIP2ED;
1237	#endif
1238	}
1239
1240	}
1241
1242	# ifndef NOCRYPT
1243	zi->ci.crypt_header_size = 0;
1244	if ((err==Z_OK) && (password != NULL))
1245	{
1246	unsigned char bufHead[RAND_HEAD_LEN];
1247	unsigned int sizeHead;
1248	zi->ci.encrypt = 1;
1249	zi->ci.pcrc_32_tab = get_crc_table();
1250	/init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);/
1251
1252	sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
1253	zi->ci.crypt_header_size = sizeHead;
1254
1255	if (ZWRITE64(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
1256	err = ZIP_ERRNO;
1257	}
1258	# endif
1259
1260	if (err==Z_OK)
1261	zi->in_opened_file_inzip = 1;
1262	return err;
1263	}
1264
1265	extern int ZEXPORT zipOpenNewFileInZip4 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
1266	const void* extrafield_local, uInt size_extrafield_local,
1267	const void* extrafield_global, uInt size_extrafield_global,
1268	const char* comment, int method, int level, int raw,
1269	int windowBits,int memLevel, int strategy,
1270	const char* password, uLong crcForCrypting,
1271	uLong versionMadeBy, uLong flagBase)
1272	{
1273	return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1274	extrafield_local, size_extrafield_local,
1275	extrafield_global, size_extrafield_global,
1276	comment, method, level, raw,
1277	windowBits, memLevel, strategy,
1278	password, crcForCrypting, versionMadeBy, flagBase, 0);
1279	}
1280
1281	extern int ZEXPORT zipOpenNewFileInZip3 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
1282	const void* extrafield_local, uInt size_extrafield_local,
1283	const void* extrafield_global, uInt size_extrafield_global,
1284	const char* comment, int method, int level, int raw,
1285	int windowBits,int memLevel, int strategy,
1286	const char* password, uLong crcForCrypting)
1287	{
1288	return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1289	extrafield_local, size_extrafield_local,
1290	extrafield_global, size_extrafield_global,
1291	comment, method, level, raw,
1292	windowBits, memLevel, strategy,
1293	password, crcForCrypting, VERSIONMADEBY, 0, 0);
1294	}
1295
1296	extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1297	const void* extrafield_local, uInt size_extrafield_local,
1298	const void* extrafield_global, uInt size_extrafield_global,
1299	const char* comment, int method, int level, int raw,
1300	int windowBits,int memLevel, int strategy,
1301	const char* password, uLong crcForCrypting, int zip64)
1302	{
1303	return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1304	extrafield_local, size_extrafield_local,
1305	extrafield_global, size_extrafield_global,
1306	comment, method, level, raw,
1307	windowBits, memLevel, strategy,
1308	password, crcForCrypting, VERSIONMADEBY, 0, zip64);
1309	}
1310
1311	extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1312	const void* extrafield_local, uInt size_extrafield_local,
1313	const void* extrafield_global, uInt size_extrafield_global,
1314	const char* comment, int method, int level, int raw)
1315	{
1316	return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1317	extrafield_local, size_extrafield_local,
1318	extrafield_global, size_extrafield_global,
1319	comment, method, level, raw,
1320	-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1321	NULL, 0, VERSIONMADEBY, 0, 0);
1322	}
1323
1324	extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1325	const void* extrafield_local, uInt size_extrafield_local,
1326	const void* extrafield_global, uInt size_extrafield_global,
1327	const char* comment, int method, int level, int raw, int zip64)
1328	{
1329	return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1330	extrafield_local, size_extrafield_local,
1331	extrafield_global, size_extrafield_global,
1332	comment, method, level, raw,
1333	-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1334	NULL, 0, VERSIONMADEBY, 0, zip64);
1335	}
1336
1337	extern int ZEXPORT zipOpenNewFileInZip64 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
1338	const void* extrafield_local, uInt size_extrafield_local,
1339	const void*extrafield_global, uInt size_extrafield_global,
1340	const char* comment, int method, int level, int zip64)
1341	{
1342	return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1343	extrafield_local, size_extrafield_local,
1344	extrafield_global, size_extrafield_global,
1345	comment, method, level, 0,
1346	-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1347	NULL, 0, VERSIONMADEBY, 0, zip64);
1348	}
1349
1350	extern int ZEXPORT zipOpenNewFileInZip (zipFile file, const char* filename, const zip_fileinfo* zipfi,
1351	const void* extrafield_local, uInt size_extrafield_local,
1352	const void*extrafield_global, uInt size_extrafield_global,
1353	const char* comment, int method, int level)
1354	{
1355	return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1356	extrafield_local, size_extrafield_local,
1357	extrafield_global, size_extrafield_global,
1358	comment, method, level, 0,
1359	-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1360	NULL, 0, VERSIONMADEBY, 0, 0);
1361	}
1362
1363	local int zip64FlushWriteBuffer(zip64_internal* zi)
1364	{
1365	int err=ZIP_OK;
1366
1367	if (zi->ci.encrypt != 0)
1368	{
1369	#ifndef NOCRYPT
1370	uInt i;
1371	int t;
1372	for (i=0;i<zi->ci.pos_in_buffered_data;i++)
1373	zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t);
1374	#endif
1375	}
1376
1377	if (ZWRITE64(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) != zi->ci.pos_in_buffered_data)
1378	err = ZIP_ERRNO;
1379
1380	zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data;
1381
1382	#ifdef HAVE_BZIP2
1383	if(zi->ci.method == Z_BZIP2ED)
1384	{
1385	zi->ci.totalUncompressedData += zi->ci.bstream.total_in_lo32;
1386	zi->ci.bstream.total_in_lo32 = 0;
1387	zi->ci.bstream.total_in_hi32 = 0;
1388	}
1389	else
1390	#endif
1391	{
1392	zi->ci.totalUncompressedData += zi->ci.stream.total_in;
1393	zi->ci.stream.total_in = 0;
1394	}
1395
1396
1397	zi->ci.pos_in_buffered_data = 0;
1398
1399	return err;
1400	}
1401
1402	extern int ZEXPORT zipWriteInFileInZip (zipFile file,const void* buf,unsigned int len)
1403	{
1404	zip64_internal* zi;
1405	int err=ZIP_OK;
1406
1407	if (file == NULL)
1408	return ZIP_PARAMERROR;
1409	zi = (zip64_internal*)file;
1410
1411	if (zi->in_opened_file_inzip == 0)
1412	return ZIP_PARAMERROR;
1413
1414	zi->ci.crc32 = crc32(zi->ci.crc32,buf,(uInt)len);
1415
1416	#ifdef HAVE_BZIP2
1417	if(zi->ci.method == Z_BZIP2ED && (!zi->ci.raw))
1418	{
1419	zi->ci.bstream.next_in = (void*)buf;
1420	zi->ci.bstream.avail_in = len;
1421	err = BZ_RUN_OK;
1422
1423	while ((err==BZ_RUN_OK) && (zi->ci.bstream.avail_in>0))
1424	{
1425	if (zi->ci.bstream.avail_out == 0)
1426	{
1427	if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
1428	err = ZIP_ERRNO;
1429	zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
1430	zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
1431	}
1432
1433
1434	if(err != BZ_RUN_OK)
1435	break;
1436
1437	if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
1438	{
1439	uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32;
1440	// uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32;
1441	err=BZ2_bzCompress(&zi->ci.bstream, BZ_RUN);
1442
1443	zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo) ;
1444	}
1445	}
1446
1447	if(err == BZ_RUN_OK)
1448	err = ZIP_OK;
1449	}
1450	else
1451	#endif
1452	{
1453	zi->ci.stream.next_in = (Bytef*)buf;
1454	zi->ci.stream.avail_in = len;
1455
1456	while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
1457	{
1458	if (zi->ci.stream.avail_out == 0)
1459	{
1460	if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
1461	err = ZIP_ERRNO;
1462	zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
1463	zi->ci.stream.next_out = zi->ci.buffered_data;
1464	}
1465
1466
1467	if(err != ZIP_OK)
1468	break;
1469
1470	if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1471	{
1472	uLong uTotalOutBefore = zi->ci.stream.total_out;
1473	err=deflate(&zi->ci.stream, Z_NO_FLUSH);
1474	if(uTotalOutBefore > zi->ci.stream.total_out)
1475	{
1476	int bBreak = 0;
1477	bBreak++;
1478	}
1479
1480	zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1481	}
1482	else
1483	{
1484	uInt copy_this,i;
1485	if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
1486	copy_this = zi->ci.stream.avail_in;
1487	else
1488	copy_this = zi->ci.stream.avail_out;
1489
1490	for (i = 0; i < copy_this; i++)
1491	(((char)zi->ci.stream.next_out)+i) =
1492	(((const char)zi->ci.stream.next_in)+i);
1493	{
1494	zi->ci.stream.avail_in -= copy_this;
1495	zi->ci.stream.avail_out-= copy_this;
1496	zi->ci.stream.next_in+= copy_this;
1497	zi->ci.stream.next_out+= copy_this;
1498	zi->ci.stream.total_in+= copy_this;
1499	zi->ci.stream.total_out+= copy_this;
1500	zi->ci.pos_in_buffered_data += copy_this;
1501	}
1502	}
1503	}// while(...)
1504	}
1505
1506	return err;
1507	}
1508
1509	extern int ZEXPORT zipCloseFileInZipRaw (zipFile file, uLong uncompressed_size, uLong crc32)
1510	{
1511	return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32);
1512	}
1513
1514	extern int ZEXPORT zipCloseFileInZipRaw64 (zipFile file, ZPOS64_T uncompressed_size, uLong crc32)
1515	{
1516	zip64_internal* zi;
1517	ZPOS64_T compressed_size;
1518	uLong invalidValue = 0xffffffff;
1519	short datasize = 0;
1520	int err=ZIP_OK;
1521
1522	if (file == NULL)
1523	return ZIP_PARAMERROR;
1524	zi = (zip64_internal*)file;
1525
1526	if (zi->in_opened_file_inzip == 0)
1527	return ZIP_PARAMERROR;
1528	zi->ci.stream.avail_in = 0;
1529
1530	if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1531	{
1532	while (err==ZIP_OK)
1533	{
1534	uLong uTotalOutBefore;
1535	if (zi->ci.stream.avail_out == 0)
1536	{
1537	if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
1538	err = ZIP_ERRNO;
1539	zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
1540	zi->ci.stream.next_out = zi->ci.buffered_data;
1541	}
1542	uTotalOutBefore = zi->ci.stream.total_out;
1543	err=deflate(&zi->ci.stream, Z_FINISH);
1544	zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1545	}
1546	}
1547	else if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
1548	{
1549	#ifdef HAVE_BZIP2
1550	err = BZ_FINISH_OK;
1551	while (err==BZ_FINISH_OK)
1552	{
1553	uLong uTotalOutBefore;
1554	if (zi->ci.bstream.avail_out == 0)
1555	{
1556	if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
1557	err = ZIP_ERRNO;
1558	zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
1559	zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
1560	}
1561	uTotalOutBefore = zi->ci.bstream.total_out_lo32;
1562	err=BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH);
1563	if(err == BZ_STREAM_END)
1564	err = Z_STREAM_END;
1565
1566	zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore);
1567	}
1568
1569	if(err == BZ_FINISH_OK)
1570	err = ZIP_OK;
1571	#endif
1572	}
1573
1574	if (err==Z_STREAM_END)
1575	err=ZIP_OK; /* this is normal */
1576
1577	if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
1578	{
1579	if (zip64FlushWriteBuffer(zi)==ZIP_ERRNO)
1580	err = ZIP_ERRNO;
1581	}
1582
1583	if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1584	{
1585	int tmp_err = deflateEnd(&zi->ci.stream);
1586	if (err == ZIP_OK)
1587	err = tmp_err;
1588	zi->ci.stream_initialised = 0;
1589	}
1590	#ifdef HAVE_BZIP2
1591	else if((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
1592	{
1593	int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream);
1594	if (err==ZIP_OK)
1595	err = tmperr;
1596	zi->ci.stream_initialised = 0;
1597	}
1598	#endif
1599
1600	if (!zi->ci.raw)
1601	{
1602	crc32 = (uLong)zi->ci.crc32;
1603	uncompressed_size = zi->ci.totalUncompressedData;
1604	}
1605	compressed_size = zi->ci.totalCompressedData;
1606
1607	# ifndef NOCRYPT
1608	compressed_size += zi->ci.crypt_header_size;
1609	# endif
1610
1611	// update Current Item crc and sizes,
1612	if(compressed_size >= 0xffffffff \|\| uncompressed_size >= 0xffffffff \|\| zi->ci.pos_local_header >= 0xffffffff)
1613	{
1614	/version Made by/
1615	zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)45,2);
1616	/version needed/
1617	zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)45,2);
1618
1619	}
1620
1621	zip64local_putValue_inmemory(zi->ci.central_header+16,crc32,4); /crc/
1622
1623
1624	if(compressed_size >= 0xffffffff)
1625	zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue,4); /compr size/
1626	else
1627	zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /compr size/
1628
1629	/// set internal file attributes field
1630	if (zi->ci.stream.data_type == Z_ASCII)
1631	zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
1632
1633	if(uncompressed_size >= 0xffffffff)
1634	zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue,4); /uncompr size/
1635	else
1636	zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /uncompr size/
1637
1638	// Add ZIP64 extra info field for uncompressed size
1639	if(uncompressed_size >= 0xffffffff)
1640	datasize += 8;
1641
1642	// Add ZIP64 extra info field for compressed size
1643	if(compressed_size >= 0xffffffff)
1644	datasize += 8;
1645
1646	// Add ZIP64 extra info field for relative offset to local file header of current file
1647	if(zi->ci.pos_local_header >= 0xffffffff)
1648	datasize += 8;
1649
1650	if(datasize > 0)
1651	{
1652	char* p = NULL;
1653
1654	if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree)
1655	{
1656	// we can not write more data to the buffer that we have room for.
1657	return ZIP_BADZIPFILE;
1658	}
1659
1660	p = zi->ci.central_header + zi->ci.size_centralheader;
1661
1662	// Add Extra Information Header for 'ZIP64 information'
1663	zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID
1664	p += 2;
1665	zip64local_putValue_inmemory(p, datasize, 2); // DataSize
1666	p += 2;
1667
1668	if(uncompressed_size >= 0xffffffff)
1669	{
1670	zip64local_putValue_inmemory(p, uncompressed_size, 8);
1671	p += 8;
1672	}
1673
1674	if(compressed_size >= 0xffffffff)
1675	{
1676	zip64local_putValue_inmemory(p, compressed_size, 8);
1677	p += 8;
1678	}
1679
1680	if(zi->ci.pos_local_header >= 0xffffffff)
1681	{
1682	zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8);
1683	p += 8;
1684	}
1685
1686	// Update how much extra free space we got in the memory buffer
1687	// and increase the centralheader size so the new ZIP64 fields are included
1688	// ( 4 below is the size of HeaderID and DataSize field )
1689	zi->ci.size_centralExtraFree -= datasize + 4;
1690	zi->ci.size_centralheader += datasize + 4;
1691
1692	// Update the extra info size field
1693	zi->ci.size_centralExtra += datasize + 4;
1694	zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)zi->ci.size_centralExtra,2);
1695	}
1696
1697	if (err==ZIP_OK)
1698	err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader);
1699
1700	free(zi->ci.central_header);
1701
1702	if (err==ZIP_OK)
1703	{
1704	// Update the LocalFileHeader with the new values.
1705
1706	ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
1707
1708	if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
1709	err = ZIP_ERRNO;
1710
1711	if (err==ZIP_OK)
1712	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
1713
1714	if(uncompressed_size >= 0xffffffff \|\| compressed_size >= 0xffffffff )
1715	{
1716	if(zi->ci.pos_zip64extrainfo > 0)
1717	{
1718	// Update the size in the ZIP64 extended field.
1719	if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_zip64extrainfo + 4,ZLIB_FILEFUNC_SEEK_SET)!=0)
1720	err = ZIP_ERRNO;
1721
1722	if (err==ZIP_OK) /* compressed size, unknown */
1723	err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8);
1724
1725	if (err==ZIP_OK) /* uncompressed size, unknown */
1726	err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8);
1727	}
1728	else
1729	err = ZIP_BADZIPFILE; // Caller passed zip64 = 0, so no room for zip64 info -> fatal
1730	}
1731	else
1732	{
1733	if (err==ZIP_OK) /* compressed size, unknown */
1734	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
1735
1736	if (err==ZIP_OK) /* uncompressed size, unknown */
1737	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
1738	}
1739
1740	if (ZSEEK64(zi->z_filefunc,zi->filestream, cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
1741	err = ZIP_ERRNO;
1742	}
1743
1744	zi->number_entry ++;
1745	zi->in_opened_file_inzip = 0;
1746
1747	return err;
1748	}
1749
1750	extern int ZEXPORT zipCloseFileInZip (zipFile file)
1751	{
1752	return zipCloseFileInZipRaw (file,0,0);
1753	}
1754
1755	int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip)
1756	{
1757	int err = ZIP_OK;
1758	ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writting_offset;
1759
1760	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4);
1761
1762	/num disks/
1763	if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1764	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
1765
1766	/relative offset/
1767	if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */
1768	err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8);
1769
1770	/total disks/ /* Do not support spawning of disk so always say 1 here*/
1771	if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1772	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4);
1773
1774	return err;
1775	}
1776
1777	int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
1778	{
1779	int err = ZIP_OK;
1780
1781	uLong Zip64DataSize = 44;
1782
1783	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4);
1784
1785	if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */
1786	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ?
1787
1788	if (err==ZIP_OK) /* version made by */
1789	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
1790
1791	if (err==ZIP_OK) /* version needed */
1792	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
1793
1794	if (err==ZIP_OK) /* number of this disk */
1795	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
1796
1797	if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1798	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
1799
1800	if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
1801	err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
1802
1803	if (err==ZIP_OK) /* total number of entries in the central dir */
1804	err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
1805
1806	if (err==ZIP_OK) /* size of the central directory */
1807	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)size_centraldir,8);
1808
1809	if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
1810	{
1811	ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
1812	err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8);
1813	}
1814	return err;
1815	}
1816	int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
1817	{
1818	int err = ZIP_OK;
1819
1820	/signature/
1821	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
1822
1823	if (err==ZIP_OK) /* number of this disk */
1824	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1825
1826	if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1827	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1828
1829	if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
1830	{
1831	{
1832	if(zi->number_entry >= 0xFFFF)
1833	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
1834	else
1835	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1836	}
1837	}
1838
1839	if (err==ZIP_OK) /* total number of entries in the central dir */
1840	{
1841	if(zi->number_entry >= 0xFFFF)
1842	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
1843	else
1844	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1845	}
1846
1847	if (err==ZIP_OK) /* size of the central directory */
1848	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
1849
1850	if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
1851	{
1852	ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
1853	if(pos >= 0xffffffff)
1854	{
1855	err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)0xffffffff,4);
1856	}
1857	else
1858	err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
1859	}
1860
1861	return err;
1862	}
1863
1864	int Write_GlobalComment(zip64_internal* zi, const char* global_comment)
1865	{
1866	int err = ZIP_OK;
1867	uInt size_global_comment = 0;
1868
1869	if(global_comment != NULL)
1870	size_global_comment = (uInt)strlen(global_comment);
1871
1872	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
1873
1874	if (err == ZIP_OK && size_global_comment > 0)
1875	{
1876	if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment)
1877	err = ZIP_ERRNO;
1878	}
1879	return err;
1880	}
1881
1882	extern int ZEXPORT zipClose (zipFile file, const char* global_comment)
1883	{
1884	zip64_internal* zi;
1885	int err = 0;
1886	uLong size_centraldir = 0;
1887	ZPOS64_T centraldir_pos_inzip;
1888	ZPOS64_T pos;
1889
1890	if (file == NULL)
1891	return ZIP_PARAMERROR;
1892
1893	zi = (zip64_internal*)file;
1894
1895	if (zi->in_opened_file_inzip == 1)
1896	{
1897	err = zipCloseFileInZip (file);
1898	}
1899
1900	#ifndef NO_ADDFILEINEXISTINGZIP
1901	if (global_comment==NULL)
1902	global_comment = zi->globalcomment;
1903	#endif
1904
1905	centraldir_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
1906
1907	if (err==ZIP_OK)
1908	{
1909	linkedlist_datablock_internal* ldi = zi->central_dir.first_block;
1910	while (ldi!=NULL)
1911	{
1912	if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
1913	{
1914	if (ZWRITE64(zi->z_filefunc,zi->filestream, ldi->data, ldi->filled_in_this_block) != ldi->filled_in_this_block)
1915	err = ZIP_ERRNO;
1916	}
1917
1918	size_centraldir += ldi->filled_in_this_block;
1919	ldi = ldi->next_datablock;
1920	}
1921	}
1922	free_linkedlist(&(zi->central_dir));
1923
1924	pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
1925	if(pos >= 0xffffffff \|\| zi->number_entry > 0xFFFF)
1926	{
1927	ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream);
1928	Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
1929
1930	Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos);
1931	}
1932
1933	if (err==ZIP_OK)
1934	err = Write_EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
1935
1936	if(err == ZIP_OK)
1937	err = Write_GlobalComment(zi, global_comment);
1938
1939	if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0)
1940	if (err == ZIP_OK)
1941	err = ZIP_ERRNO;
1942
1943	#ifndef NO_ADDFILEINEXISTINGZIP
1944	TRYFREE(zi->globalcomment);
1945	#endif
1946	TRYFREE(zi);
1947
1948	return err;
1949	}
1950
1951	extern int ZEXPORT zipRemoveExtraInfoBlock (char* pData, int* dataLen, short sHeader)
1952	{
1953	char* p = pData;
1954	int size = 0;
1955	char* pNewHeader;
1956	char* pTmp;
1957	short header;
1958	short dataSize;
1959
1960	int retVal = ZIP_OK;
1961
1962	if(pData == NULL \|\| *dataLen < 4)
1963	return ZIP_PARAMERROR;
1964
1965	pNewHeader = (char)ALLOC(dataLen);
1966	pTmp = pNewHeader;
1967
1968	while(p < (pData + *dataLen))
1969	{
1970	header = (short)p;
1971	dataSize = (((short)p)+1);
1972
1973	if( header == sHeader ) // Header found.
1974	{
1975	p += dataSize + 4; // skip it. do not copy to temp buffer
1976	}
1977	else
1978	{
1979	// Extra Info block should not be removed, So copy it to the temp buffer.
1980	memcpy(pTmp, p, dataSize + 4);
1981	p += dataSize + 4;
1982	size += dataSize + 4;
1983	}
1984
1985	}
1986
1987	if(size < *dataLen)
1988	{
1989	// clean old extra info block.
1990	memset(pData,0, *dataLen);
1991
1992	// copy the new extra info block over the old
1993	if(size > 0)
1994	memcpy(pData, pNewHeader, size);
1995
1996	// set the new extra info size
1997	*dataLen = size;
1998
1999	retVal = ZIP_OK;
2000	}
2001	else
2002	retVal = ZIP_ERRNO;
2003
2004	TRYFREE(pNewHeader);
2005
2006	return retVal;
2007	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/zlib-1.2.6/contrib/minizip/zip.c@ 40354

Download in other formats: