OSDN Git Service

* Imported zlib 1.2.3; merged local changes.
[pf3gnuchains/gcc-fork.git] / zlib / contrib / minizip / zip.c
1 /* zip.c -- IO on .zip files using zlib
2    Version 1.01e, February 12th, 2005
3
4    27 Dec 2004 Rolf Kalbermatter
5    Modification to zipOpen2 to support globalComment retrieval.
6
7    Copyright (C) 1998-2005 Gilles Vollant
8
9    Read zip.h for more info
10 */
11
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <time.h>
17 #include "zlib.h"
18 #include "zip.h"
19
20 #ifdef STDC
21 #  include <stddef.h>
22 #  include <string.h>
23 #  include <stdlib.h>
24 #endif
25 #ifdef NO_ERRNO_H
26     extern int errno;
27 #else
28 #   include <errno.h>
29 #endif
30
31
32 #ifndef local
33 #  define local static
34 #endif
35 /* compile with -Dlocal if your debugger can't find static symbols */
36
37 #ifndef VERSIONMADEBY
38 # define VERSIONMADEBY   (0x0) /* platform depedent */
39 #endif
40
41 #ifndef Z_BUFSIZE
42 #define Z_BUFSIZE (16384)
43 #endif
44
45 #ifndef Z_MAXFILENAMEINZIP
46 #define Z_MAXFILENAMEINZIP (256)
47 #endif
48
49 #ifndef ALLOC
50 # define ALLOC(size) (malloc(size))
51 #endif
52 #ifndef TRYFREE
53 # define TRYFREE(p) {if (p) free(p);}
54 #endif
55
56 /*
57 #define SIZECENTRALDIRITEM (0x2e)
58 #define SIZEZIPLOCALHEADER (0x1e)
59 */
60
61 /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
62
63 #ifndef SEEK_CUR
64 #define SEEK_CUR    1
65 #endif
66
67 #ifndef SEEK_END
68 #define SEEK_END    2
69 #endif
70
71 #ifndef SEEK_SET
72 #define SEEK_SET    0
73 #endif
74
75 #ifndef DEF_MEM_LEVEL
76 #if MAX_MEM_LEVEL >= 8
77 #  define DEF_MEM_LEVEL 8
78 #else
79 #  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
80 #endif
81 #endif
82 const char zip_copyright[] =
83    " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
84
85
86 #define SIZEDATA_INDATABLOCK (4096-(4*4))
87
88 #define LOCALHEADERMAGIC    (0x04034b50)
89 #define CENTRALHEADERMAGIC  (0x02014b50)
90 #define ENDHEADERMAGIC      (0x06054b50)
91
92 #define FLAG_LOCALHEADER_OFFSET (0x06)
93 #define CRC_LOCALHEADER_OFFSET  (0x0e)
94
95 #define SIZECENTRALHEADER (0x2e) /* 46 */
96
97 typedef struct linkedlist_datablock_internal_s
98 {
99   struct linkedlist_datablock_internal_s* next_datablock;
100   uLong  avail_in_this_block;
101   uLong  filled_in_this_block;
102   uLong  unused; /* for future use and alignement */
103   unsigned char data[SIZEDATA_INDATABLOCK];
104 } linkedlist_datablock_internal;
105
106 typedef struct linkedlist_data_s
107 {
108     linkedlist_datablock_internal* first_block;
109     linkedlist_datablock_internal* last_block;
110 } linkedlist_data;
111
112
113 typedef struct
114 {
115     z_stream stream;            /* zLib stream structure for inflate */
116     int  stream_initialised;    /* 1 is stream is initialised */
117     uInt pos_in_buffered_data;  /* last written byte in buffered_data */
118
119     uLong pos_local_header;     /* offset of the local header of the file
120                                      currenty writing */
121     char* central_header;       /* central header data for the current file */
122     uLong size_centralheader;   /* size of the central header for cur file */
123     uLong flag;                 /* flag of the file currently writing */
124
125     int  method;                /* compression method of file currenty wr.*/
126     int  raw;                   /* 1 for directly writing raw data */
127     Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
128     uLong dosDate;
129     uLong crc32;
130     int  encrypt;
131 #ifndef NOCRYPT
132     unsigned long keys[3];     /* keys defining the pseudo-random sequence */
133     const unsigned long* pcrc_32_tab;
134     int crypt_header_size;
135 #endif
136 } curfile_info;
137
138 typedef struct
139 {
140     zlib_filefunc_def z_filefunc;
141     voidpf filestream;        /* io structore of the zipfile */
142     linkedlist_data central_dir;/* datablock with central dir in construction*/
143     int  in_opened_file_inzip;  /* 1 if a file in the zip is currently writ.*/
144     curfile_info ci;            /* info on the file curretly writing */
145
146     uLong begin_pos;            /* position of the beginning of the zipfile */
147     uLong add_position_when_writting_offset;
148     uLong number_entry;
149 #ifndef NO_ADDFILEINEXISTINGZIP
150     char *globalcomment;
151 #endif
152 } zip_internal;
153
154
155
156 #ifndef NOCRYPT
157 #define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
158 #include "crypt.h"
159 #endif
160
161 local linkedlist_datablock_internal* allocate_new_datablock()
162 {
163     linkedlist_datablock_internal* ldi;
164     ldi = (linkedlist_datablock_internal*)
165                  ALLOC(sizeof(linkedlist_datablock_internal));
166     if (ldi!=NULL)
167     {
168         ldi->next_datablock = NULL ;
169         ldi->filled_in_this_block = 0 ;
170         ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
171     }
172     return ldi;
173 }
174
175 local void free_datablock(ldi)
176     linkedlist_datablock_internal* ldi;
177 {
178     while (ldi!=NULL)
179     {
180         linkedlist_datablock_internal* ldinext = ldi->next_datablock;
181         TRYFREE(ldi);
182         ldi = ldinext;
183     }
184 }
185
186 local void init_linkedlist(ll)
187     linkedlist_data* ll;
188 {
189     ll->first_block = ll->last_block = NULL;
190 }
191
192 local void free_linkedlist(ll)
193     linkedlist_data* ll;
194 {
195     free_datablock(ll->first_block);
196     ll->first_block = ll->last_block = NULL;
197 }
198
199
200 local int add_data_in_datablock(ll,buf,len)
201     linkedlist_data* ll;
202     const void* buf;
203     uLong len;
204 {
205     linkedlist_datablock_internal* ldi;
206     const unsigned char* from_copy;
207
208     if (ll==NULL)
209         return ZIP_INTERNALERROR;
210
211     if (ll->last_block == NULL)
212     {
213         ll->first_block = ll->last_block = allocate_new_datablock();
214         if (ll->first_block == NULL)
215             return ZIP_INTERNALERROR;
216     }
217
218     ldi = ll->last_block;
219     from_copy = (unsigned char*)buf;
220
221     while (len>0)
222     {
223         uInt copy_this;
224         uInt i;
225         unsigned char* to_copy;
226
227         if (ldi->avail_in_this_block==0)
228         {
229             ldi->next_datablock = allocate_new_datablock();
230             if (ldi->next_datablock == NULL)
231                 return ZIP_INTERNALERROR;
232             ldi = ldi->next_datablock ;
233             ll->last_block = ldi;
234         }
235
236         if (ldi->avail_in_this_block < len)
237             copy_this = (uInt)ldi->avail_in_this_block;
238         else
239             copy_this = (uInt)len;
240
241         to_copy = &(ldi->data[ldi->filled_in_this_block]);
242
243         for (i=0;i<copy_this;i++)
244             *(to_copy+i)=*(from_copy+i);
245
246         ldi->filled_in_this_block += copy_this;
247         ldi->avail_in_this_block -= copy_this;
248         from_copy += copy_this ;
249         len -= copy_this;
250     }
251     return ZIP_OK;
252 }
253
254
255
256 /****************************************************************************/
257
258 #ifndef NO_ADDFILEINEXISTINGZIP
259 /* ===========================================================================
260    Inputs a long in LSB order to the given file
261    nbByte == 1, 2 or 4 (byte, short or long)
262 */
263
264 local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def,
265                                 voidpf filestream, uLong x, int nbByte));
266 local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte)
267     const zlib_filefunc_def* pzlib_filefunc_def;
268     voidpf filestream;
269     uLong x;
270     int nbByte;
271 {
272     unsigned char buf[4];
273     int n;
274     for (n = 0; n < nbByte; n++)
275     {
276         buf[n] = (unsigned char)(x & 0xff);
277         x >>= 8;
278     }
279     if (x != 0)
280       {     /* data overflow - hack for ZIP64 (X Roche) */
281       for (n = 0; n < nbByte; n++)
282         {
283           buf[n] = 0xff;
284         }
285       }
286
287     if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
288         return ZIP_ERRNO;
289     else
290         return ZIP_OK;
291 }
292
293 local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte));
294 local void ziplocal_putValue_inmemory (dest, x, nbByte)
295     void* dest;
296     uLong x;
297     int nbByte;
298 {
299     unsigned char* buf=(unsigned char*)dest;
300     int n;
301     for (n = 0; n < nbByte; n++) {
302         buf[n] = (unsigned char)(x & 0xff);
303         x >>= 8;
304     }
305
306     if (x != 0)
307     {     /* data overflow - hack for ZIP64 */
308        for (n = 0; n < nbByte; n++)
309        {
310           buf[n] = 0xff;
311        }
312     }
313 }
314
315 /****************************************************************************/
316
317
318 local uLong ziplocal_TmzDateToDosDate(ptm,dosDate)
319     const tm_zip* ptm;
320     uLong dosDate;
321 {
322     uLong year = (uLong)ptm->tm_year;
323     if (year>1980)
324         year-=1980;
325     else if (year>80)
326         year-=80;
327     return
328       (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
329         ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
330 }
331
332
333 /****************************************************************************/
334
335 local int ziplocal_getByte OF((
336     const zlib_filefunc_def* pzlib_filefunc_def,
337     voidpf filestream,
338     int *pi));
339
340 local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi)
341     const zlib_filefunc_def* pzlib_filefunc_def;
342     voidpf filestream;
343     int *pi;
344 {
345     unsigned char c;
346     int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
347     if (err==1)
348     {
349         *pi = (int)c;
350         return ZIP_OK;
351     }
352     else
353     {
354         if (ZERROR(*pzlib_filefunc_def,filestream))
355             return ZIP_ERRNO;
356         else
357             return ZIP_EOF;
358     }
359 }
360
361
362 /* ===========================================================================
363    Reads a long in LSB order from the given gz_stream. Sets
364 */
365 local int ziplocal_getShort OF((
366     const zlib_filefunc_def* pzlib_filefunc_def,
367     voidpf filestream,
368     uLong *pX));
369
370 local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX)
371     const zlib_filefunc_def* pzlib_filefunc_def;
372     voidpf filestream;
373     uLong *pX;
374 {
375     uLong x ;
376     int i;
377     int err;
378
379     err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
380     x = (uLong)i;
381
382     if (err==ZIP_OK)
383         err = ziplocal_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 ziplocal_getLong OF((
394     const zlib_filefunc_def* pzlib_filefunc_def,
395     voidpf filestream,
396     uLong *pX));
397
398 local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX)
399     const zlib_filefunc_def* pzlib_filefunc_def;
400     voidpf filestream;
401     uLong *pX;
402 {
403     uLong x ;
404     int i;
405     int err;
406
407     err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
408     x = (uLong)i;
409
410     if (err==ZIP_OK)
411         err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
412     x += ((uLong)i)<<8;
413
414     if (err==ZIP_OK)
415         err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
416     x += ((uLong)i)<<16;
417
418     if (err==ZIP_OK)
419         err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
420     x += ((uLong)i)<<24;
421
422     if (err==ZIP_OK)
423         *pX = x;
424     else
425         *pX = 0;
426     return err;
427 }
428
429 #ifndef BUFREADCOMMENT
430 #define BUFREADCOMMENT (0x400)
431 #endif
432 /*
433   Locate the Central directory of a zipfile (at the end, just before
434     the global comment)
435 */
436 local uLong ziplocal_SearchCentralDir OF((
437     const zlib_filefunc_def* pzlib_filefunc_def,
438     voidpf filestream));
439
440 local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream)
441     const zlib_filefunc_def* pzlib_filefunc_def;
442     voidpf filestream;
443 {
444     unsigned char* buf;
445     uLong uSizeFile;
446     uLong uBackRead;
447     uLong uMaxBack=0xffff; /* maximum size of global comment */
448     uLong uPosFound=0;
449
450     if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
451         return 0;
452
453
454     uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
455
456     if (uMaxBack>uSizeFile)
457         uMaxBack = uSizeFile;
458
459     buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
460     if (buf==NULL)
461         return 0;
462
463     uBackRead = 4;
464     while (uBackRead<uMaxBack)
465     {
466         uLong uReadSize,uReadPos ;
467         int i;
468         if (uBackRead+BUFREADCOMMENT>uMaxBack)
469             uBackRead = uMaxBack;
470         else
471             uBackRead+=BUFREADCOMMENT;
472         uReadPos = uSizeFile-uBackRead ;
473
474         uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
475                      (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
476         if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
477             break;
478
479         if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
480             break;
481
482         for (i=(int)uReadSize-3; (i--)>0;)
483             if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
484                 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
485             {
486                 uPosFound = uReadPos+i;
487                 break;
488             }
489
490         if (uPosFound!=0)
491             break;
492     }
493     TRYFREE(buf);
494     return uPosFound;
495 }
496 #endif /* !NO_ADDFILEINEXISTINGZIP*/
497
498 /************************************************************/
499 extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def)
500     const char *pathname;
501     int append;
502     zipcharpc* globalcomment;
503     zlib_filefunc_def* pzlib_filefunc_def;
504 {
505     zip_internal ziinit;
506     zip_internal* zi;
507     int err=ZIP_OK;
508
509
510     if (pzlib_filefunc_def==NULL)
511         fill_fopen_filefunc(&ziinit.z_filefunc);
512     else
513         ziinit.z_filefunc = *pzlib_filefunc_def;
514
515     ziinit.filestream = (*(ziinit.z_filefunc.zopen_file))
516                  (ziinit.z_filefunc.opaque,
517                   pathname,
518                   (append == APPEND_STATUS_CREATE) ?
519                   (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
520                     (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
521
522     if (ziinit.filestream == NULL)
523         return NULL;
524     ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream);
525     ziinit.in_opened_file_inzip = 0;
526     ziinit.ci.stream_initialised = 0;
527     ziinit.number_entry = 0;
528     ziinit.add_position_when_writting_offset = 0;
529     init_linkedlist(&(ziinit.central_dir));
530
531
532     zi = (zip_internal*)ALLOC(sizeof(zip_internal));
533     if (zi==NULL)
534     {
535         ZCLOSE(ziinit.z_filefunc,ziinit.filestream);
536         return NULL;
537     }
538
539     /* now we add file in a zipfile */
540 #    ifndef NO_ADDFILEINEXISTINGZIP
541     ziinit.globalcomment = NULL;
542     if (append == APPEND_STATUS_ADDINZIP)
543     {
544         uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
545
546         uLong size_central_dir;     /* size of the central directory  */
547         uLong offset_central_dir;   /* offset of start of central directory */
548         uLong central_pos,uL;
549
550         uLong number_disk;          /* number of the current dist, used for
551                                     spaning ZIP, unsupported, always 0*/
552         uLong number_disk_with_CD;  /* number the the disk with central dir, used
553                                     for spaning ZIP, unsupported, always 0*/
554         uLong number_entry;
555         uLong number_entry_CD;      /* total number of entries in
556                                     the central dir
557                                     (same than number_entry on nospan) */
558         uLong size_comment;
559
560         central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream);
561         if (central_pos==0)
562             err=ZIP_ERRNO;
563
564         if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
565                                         central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
566             err=ZIP_ERRNO;
567
568         /* the signature, already checked */
569         if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK)
570             err=ZIP_ERRNO;
571
572         /* number of this disk */
573         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK)
574             err=ZIP_ERRNO;
575
576         /* number of the disk with the start of the central directory */
577         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK)
578             err=ZIP_ERRNO;
579
580         /* total number of entries in the central dir on this disk */
581         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK)
582             err=ZIP_ERRNO;
583
584         /* total number of entries in the central dir */
585         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK)
586             err=ZIP_ERRNO;
587
588         if ((number_entry_CD!=number_entry) ||
589             (number_disk_with_CD!=0) ||
590             (number_disk!=0))
591             err=ZIP_BADZIPFILE;
592
593         /* size of the central directory */
594         if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK)
595             err=ZIP_ERRNO;
596
597         /* offset of start of central directory with respect to the
598             starting disk number */
599         if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK)
600             err=ZIP_ERRNO;
601
602         /* zipfile global comment length */
603         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK)
604             err=ZIP_ERRNO;
605
606         if ((central_pos<offset_central_dir+size_central_dir) &&
607             (err==ZIP_OK))
608             err=ZIP_BADZIPFILE;
609
610         if (err!=ZIP_OK)
611         {
612             ZCLOSE(ziinit.z_filefunc, ziinit.filestream);
613             return NULL;
614         }
615
616         if (size_comment>0)
617         {
618             ziinit.globalcomment = ALLOC(size_comment+1);
619             if (ziinit.globalcomment)
620             {
621                size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment);
622                ziinit.globalcomment[size_comment]=0;
623             }
624         }
625
626         byte_before_the_zipfile = central_pos -
627                                 (offset_central_dir+size_central_dir);
628         ziinit.add_position_when_writting_offset = byte_before_the_zipfile;
629
630         {
631             uLong size_central_dir_to_read = size_central_dir;
632             size_t buf_size = SIZEDATA_INDATABLOCK;
633             void* buf_read = (void*)ALLOC(buf_size);
634             if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
635                   offset_central_dir + byte_before_the_zipfile,
636                   ZLIB_FILEFUNC_SEEK_SET) != 0)
637                   err=ZIP_ERRNO;
638
639             while ((size_central_dir_to_read>0) && (err==ZIP_OK))
640             {
641                 uLong read_this = SIZEDATA_INDATABLOCK;
642                 if (read_this > size_central_dir_to_read)
643                     read_this = size_central_dir_to_read;
644                 if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this)
645                     err=ZIP_ERRNO;
646
647                 if (err==ZIP_OK)
648                     err = add_data_in_datablock(&ziinit.central_dir,buf_read,
649                                                 (uLong)read_this);
650                 size_central_dir_to_read-=read_this;
651             }
652             TRYFREE(buf_read);
653         }
654         ziinit.begin_pos = byte_before_the_zipfile;
655         ziinit.number_entry = number_entry_CD;
656
657         if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
658                   offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
659             err=ZIP_ERRNO;
660     }
661
662     if (globalcomment)
663     {
664       *globalcomment = ziinit.globalcomment;
665     }
666 #    endif /* !NO_ADDFILEINEXISTINGZIP*/
667
668     if (err != ZIP_OK)
669     {
670 #    ifndef NO_ADDFILEINEXISTINGZIP
671         TRYFREE(ziinit.globalcomment);
672 #    endif /* !NO_ADDFILEINEXISTINGZIP*/
673         TRYFREE(zi);
674         return NULL;
675     }
676     else
677     {
678         *zi = ziinit;
679         return (zipFile)zi;
680     }
681 }
682
683 extern zipFile ZEXPORT zipOpen (pathname, append)
684     const char *pathname;
685     int append;
686 {
687     return zipOpen2(pathname,append,NULL,NULL);
688 }
689
690 extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi,
691                                          extrafield_local, size_extrafield_local,
692                                          extrafield_global, size_extrafield_global,
693                                          comment, method, level, raw,
694                                          windowBits, memLevel, strategy,
695                                          password, crcForCrypting)
696     zipFile file;
697     const char* filename;
698     const zip_fileinfo* zipfi;
699     const void* extrafield_local;
700     uInt size_extrafield_local;
701     const void* extrafield_global;
702     uInt size_extrafield_global;
703     const char* comment;
704     int method;
705     int level;
706     int raw;
707     int windowBits;
708     int memLevel;
709     int strategy;
710     const char* password;
711     uLong crcForCrypting;
712 {
713     zip_internal* zi;
714     uInt size_filename;
715     uInt size_comment;
716     uInt i;
717     int err = ZIP_OK;
718
719 #    ifdef NOCRYPT
720     if (password != NULL)
721         return ZIP_PARAMERROR;
722 #    endif
723
724     if (file == NULL)
725         return ZIP_PARAMERROR;
726     if ((method!=0) && (method!=Z_DEFLATED))
727         return ZIP_PARAMERROR;
728
729     zi = (zip_internal*)file;
730
731     if (zi->in_opened_file_inzip == 1)
732     {
733         err = zipCloseFileInZip (file);
734         if (err != ZIP_OK)
735             return err;
736     }
737
738
739     if (filename==NULL)
740         filename="-";
741
742     if (comment==NULL)
743         size_comment = 0;
744     else
745         size_comment = (uInt)strlen(comment);
746
747     size_filename = (uInt)strlen(filename);
748
749     if (zipfi == NULL)
750         zi->ci.dosDate = 0;
751     else
752     {
753         if (zipfi->dosDate != 0)
754             zi->ci.dosDate = zipfi->dosDate;
755         else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate);
756     }
757
758     zi->ci.flag = 0;
759     if ((level==8) || (level==9))
760       zi->ci.flag |= 2;
761     if ((level==2))
762       zi->ci.flag |= 4;
763     if ((level==1))
764       zi->ci.flag |= 6;
765     if (password != NULL)
766       zi->ci.flag |= 1;
767
768     zi->ci.crc32 = 0;
769     zi->ci.method = method;
770     zi->ci.encrypt = 0;
771     zi->ci.stream_initialised = 0;
772     zi->ci.pos_in_buffered_data = 0;
773     zi->ci.raw = raw;
774     zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ;
775     zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename +
776                                       size_extrafield_global + size_comment;
777     zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader);
778
779     ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
780     /* version info */
781     ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2);
782     ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
783     ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
784     ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
785     ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
786     ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
787     ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
788     ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
789     ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
790     ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
791     ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
792     ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
793
794     if (zipfi==NULL)
795         ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
796     else
797         ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
798
799     if (zipfi==NULL)
800         ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
801     else
802         ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
803
804     ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4);
805
806     for (i=0;i<size_filename;i++)
807         *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
808
809     for (i=0;i<size_extrafield_global;i++)
810         *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
811               *(((const char*)extrafield_global)+i);
812
813     for (i=0;i<size_comment;i++)
814         *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
815               size_extrafield_global+i) = *(comment+i);
816     if (zi->ci.central_header == NULL)
817         return ZIP_INTERNALERROR;
818
819     /* write the local header */
820     err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4);
821
822     if (err==ZIP_OK)
823         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
824     if (err==ZIP_OK)
825         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
826
827     if (err==ZIP_OK)
828         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
829
830     if (err==ZIP_OK)
831         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
832
833     if (err==ZIP_OK)
834         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
835     if (err==ZIP_OK)
836         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
837     if (err==ZIP_OK)
838         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
839
840     if (err==ZIP_OK)
841         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
842
843     if (err==ZIP_OK)
844         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2);
845
846     if ((err==ZIP_OK) && (size_filename>0))
847         if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
848                 err = ZIP_ERRNO;
849
850     if ((err==ZIP_OK) && (size_extrafield_local>0))
851         if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local)
852                                                                            !=size_extrafield_local)
853                 err = ZIP_ERRNO;
854
855     zi->ci.stream.avail_in = (uInt)0;
856     zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
857     zi->ci.stream.next_out = zi->ci.buffered_data;
858     zi->ci.stream.total_in = 0;
859     zi->ci.stream.total_out = 0;
860
861     if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
862     {
863         zi->ci.stream.zalloc = (alloc_func)0;
864         zi->ci.stream.zfree = (free_func)0;
865         zi->ci.stream.opaque = (voidpf)0;
866
867         if (windowBits>0)
868             windowBits = -windowBits;
869
870         err = deflateInit2(&zi->ci.stream, level,
871                Z_DEFLATED, windowBits, memLevel, strategy);
872
873         if (err==Z_OK)
874             zi->ci.stream_initialised = 1;
875     }
876 #    ifndef NOCRYPT
877     zi->ci.crypt_header_size = 0;
878     if ((err==Z_OK) && (password != NULL))
879     {
880         unsigned char bufHead[RAND_HEAD_LEN];
881         unsigned int sizeHead;
882         zi->ci.encrypt = 1;
883         zi->ci.pcrc_32_tab = get_crc_table();
884         /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
885
886         sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
887         zi->ci.crypt_header_size = sizeHead;
888
889         if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
890                 err = ZIP_ERRNO;
891     }
892 #    endif
893
894     if (err==Z_OK)
895         zi->in_opened_file_inzip = 1;
896     return err;
897 }
898
899 extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
900                                         extrafield_local, size_extrafield_local,
901                                         extrafield_global, size_extrafield_global,
902                                         comment, method, level, raw)
903     zipFile file;
904     const char* filename;
905     const zip_fileinfo* zipfi;
906     const void* extrafield_local;
907     uInt size_extrafield_local;
908     const void* extrafield_global;
909     uInt size_extrafield_global;
910     const char* comment;
911     int method;
912     int level;
913     int raw;
914 {
915     return zipOpenNewFileInZip3 (file, filename, zipfi,
916                                  extrafield_local, size_extrafield_local,
917                                  extrafield_global, size_extrafield_global,
918                                  comment, method, level, raw,
919                                  -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
920                                  NULL, 0);
921 }
922
923 extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
924                                         extrafield_local, size_extrafield_local,
925                                         extrafield_global, size_extrafield_global,
926                                         comment, method, level)
927     zipFile file;
928     const char* filename;
929     const zip_fileinfo* zipfi;
930     const void* extrafield_local;
931     uInt size_extrafield_local;
932     const void* extrafield_global;
933     uInt size_extrafield_global;
934     const char* comment;
935     int method;
936     int level;
937 {
938     return zipOpenNewFileInZip2 (file, filename, zipfi,
939                                  extrafield_local, size_extrafield_local,
940                                  extrafield_global, size_extrafield_global,
941                                  comment, method, level, 0);
942 }
943
944 local int zipFlushWriteBuffer(zi)
945   zip_internal* zi;
946 {
947     int err=ZIP_OK;
948
949     if (zi->ci.encrypt != 0)
950     {
951 #ifndef NOCRYPT
952         uInt i;
953         int t;
954         for (i=0;i<zi->ci.pos_in_buffered_data;i++)
955             zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab,
956                                        zi->ci.buffered_data[i],t);
957 #endif
958     }
959     if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data)
960                                                                     !=zi->ci.pos_in_buffered_data)
961       err = ZIP_ERRNO;
962     zi->ci.pos_in_buffered_data = 0;
963     return err;
964 }
965
966 extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
967     zipFile file;
968     const void* buf;
969     unsigned len;
970 {
971     zip_internal* zi;
972     int err=ZIP_OK;
973
974     if (file == NULL)
975         return ZIP_PARAMERROR;
976     zi = (zip_internal*)file;
977
978     if (zi->in_opened_file_inzip == 0)
979         return ZIP_PARAMERROR;
980
981     zi->ci.stream.next_in = (void*)buf;
982     zi->ci.stream.avail_in = len;
983     zi->ci.crc32 = crc32(zi->ci.crc32,buf,len);
984
985     while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
986     {
987         if (zi->ci.stream.avail_out == 0)
988         {
989             if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
990                 err = ZIP_ERRNO;
991             zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
992             zi->ci.stream.next_out = zi->ci.buffered_data;
993         }
994
995
996         if(err != ZIP_OK)
997             break;
998
999         if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1000         {
1001             uLong uTotalOutBefore = zi->ci.stream.total_out;
1002             err=deflate(&zi->ci.stream,  Z_NO_FLUSH);
1003             zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1004
1005         }
1006         else
1007         {
1008             uInt copy_this,i;
1009             if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
1010                 copy_this = zi->ci.stream.avail_in;
1011             else
1012                 copy_this = zi->ci.stream.avail_out;
1013             for (i=0;i<copy_this;i++)
1014                 *(((char*)zi->ci.stream.next_out)+i) =
1015                     *(((const char*)zi->ci.stream.next_in)+i);
1016             {
1017                 zi->ci.stream.avail_in -= copy_this;
1018                 zi->ci.stream.avail_out-= copy_this;
1019                 zi->ci.stream.next_in+= copy_this;
1020                 zi->ci.stream.next_out+= copy_this;
1021                 zi->ci.stream.total_in+= copy_this;
1022                 zi->ci.stream.total_out+= copy_this;
1023                 zi->ci.pos_in_buffered_data += copy_this;
1024             }
1025         }
1026     }
1027
1028     return err;
1029 }
1030
1031 extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32)
1032     zipFile file;
1033     uLong uncompressed_size;
1034     uLong crc32;
1035 {
1036     zip_internal* zi;
1037     uLong compressed_size;
1038     int err=ZIP_OK;
1039
1040     if (file == NULL)
1041         return ZIP_PARAMERROR;
1042     zi = (zip_internal*)file;
1043
1044     if (zi->in_opened_file_inzip == 0)
1045         return ZIP_PARAMERROR;
1046     zi->ci.stream.avail_in = 0;
1047
1048     if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1049         while (err==ZIP_OK)
1050     {
1051         uLong uTotalOutBefore;
1052         if (zi->ci.stream.avail_out == 0)
1053         {
1054             if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
1055                 err = ZIP_ERRNO;
1056             zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
1057             zi->ci.stream.next_out = zi->ci.buffered_data;
1058         }
1059         uTotalOutBefore = zi->ci.stream.total_out;
1060         err=deflate(&zi->ci.stream,  Z_FINISH);
1061         zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1062     }
1063
1064     if (err==Z_STREAM_END)
1065         err=ZIP_OK; /* this is normal */
1066
1067     if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
1068         if (zipFlushWriteBuffer(zi)==ZIP_ERRNO)
1069             err = ZIP_ERRNO;
1070
1071     if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1072     {
1073         err=deflateEnd(&zi->ci.stream);
1074         zi->ci.stream_initialised = 0;
1075     }
1076
1077     if (!zi->ci.raw)
1078     {
1079         crc32 = (uLong)zi->ci.crc32;
1080         uncompressed_size = (uLong)zi->ci.stream.total_in;
1081     }
1082     compressed_size = (uLong)zi->ci.stream.total_out;
1083 #    ifndef NOCRYPT
1084     compressed_size += zi->ci.crypt_header_size;
1085 #    endif
1086
1087     ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
1088     ziplocal_putValue_inmemory(zi->ci.central_header+20,
1089                                 compressed_size,4); /*compr size*/
1090     if (zi->ci.stream.data_type == Z_ASCII)
1091         ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
1092     ziplocal_putValue_inmemory(zi->ci.central_header+24,
1093                                 uncompressed_size,4); /*uncompr size*/
1094
1095     if (err==ZIP_OK)
1096         err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header,
1097                                        (uLong)zi->ci.size_centralheader);
1098     free(zi->ci.central_header);
1099
1100     if (err==ZIP_OK)
1101     {
1102         long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
1103         if (ZSEEK(zi->z_filefunc,zi->filestream,
1104                   zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
1105             err = ZIP_ERRNO;
1106
1107         if (err==ZIP_OK)
1108             err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
1109
1110         if (err==ZIP_OK) /* compressed size, unknown */
1111             err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
1112
1113         if (err==ZIP_OK) /* uncompressed size, unknown */
1114             err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
1115
1116         if (ZSEEK(zi->z_filefunc,zi->filestream,
1117                   cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
1118             err = ZIP_ERRNO;
1119     }
1120
1121     zi->number_entry ++;
1122     zi->in_opened_file_inzip = 0;
1123
1124     return err;
1125 }
1126
1127 extern int ZEXPORT zipCloseFileInZip (file)
1128     zipFile file;
1129 {
1130     return zipCloseFileInZipRaw (file,0,0);
1131 }
1132
1133 extern int ZEXPORT zipClose (file, global_comment)
1134     zipFile file;
1135     const char* global_comment;
1136 {
1137     zip_internal* zi;
1138     int err = 0;
1139     uLong size_centraldir = 0;
1140     uLong centraldir_pos_inzip;
1141     uInt size_global_comment;
1142     if (file == NULL)
1143         return ZIP_PARAMERROR;
1144     zi = (zip_internal*)file;
1145
1146     if (zi->in_opened_file_inzip == 1)
1147     {
1148         err = zipCloseFileInZip (file);
1149     }
1150
1151 #ifndef NO_ADDFILEINEXISTINGZIP
1152     if (global_comment==NULL)
1153         global_comment = zi->globalcomment;
1154 #endif
1155     if (global_comment==NULL)
1156         size_global_comment = 0;
1157     else
1158         size_global_comment = (uInt)strlen(global_comment);
1159
1160     centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
1161     if (err==ZIP_OK)
1162     {
1163         linkedlist_datablock_internal* ldi = zi->central_dir.first_block ;
1164         while (ldi!=NULL)
1165         {
1166             if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
1167                 if (ZWRITE(zi->z_filefunc,zi->filestream,
1168                            ldi->data,ldi->filled_in_this_block)
1169                               !=ldi->filled_in_this_block )
1170                     err = ZIP_ERRNO;
1171
1172             size_centraldir += ldi->filled_in_this_block;
1173             ldi = ldi->next_datablock;
1174         }
1175     }
1176     free_datablock(zi->central_dir.first_block);
1177
1178     if (err==ZIP_OK) /* Magic End */
1179         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
1180
1181     if (err==ZIP_OK) /* number of this disk */
1182         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1183
1184     if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1185         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1186
1187     if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
1188         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1189
1190     if (err==ZIP_OK) /* total number of entries in the central dir */
1191         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1192
1193     if (err==ZIP_OK) /* size of the central directory */
1194         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
1195
1196     if (err==ZIP_OK) /* offset of start of central directory with respect to the
1197                             starting disk number */
1198         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,
1199                                 (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
1200
1201     if (err==ZIP_OK) /* zipfile comment length */
1202         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
1203
1204     if ((err==ZIP_OK) && (size_global_comment>0))
1205         if (ZWRITE(zi->z_filefunc,zi->filestream,
1206                    global_comment,size_global_comment) != size_global_comment)
1207                 err = ZIP_ERRNO;
1208
1209     if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0)
1210         if (err == ZIP_OK)
1211             err = ZIP_ERRNO;
1212
1213 #ifndef NO_ADDFILEINEXISTINGZIP
1214     TRYFREE(zi->globalcomment);
1215 #endif
1216     TRYFREE(zi);
1217
1218     return err;
1219 }