?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync usage with man page.
[netbsd-mini2440.git] / common / dist / zlib / contrib / minizip / unzip.c
blob107cb6d6fb082376bd069391892af5c980f52984
1 /* $NetBSD$ */
2
3 /* unzip.c -- IO for uncompress .zip files using zlib
4 Version 1.01e, February 12th, 2005
5
6 Copyright (C) 1998-2005 Gilles Vollant
7
8 Read unzip.h for more info
9 */
10
11 /* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
12 compatibility with older software. The following is from the original crypt.c. Code
13 woven in by Terry Thorsen 1/2003.
14 */
15 /*
16 Copyright (c) 1990-2000 Info-ZIP. All rights reserved.
17
18 See the accompanying file LICENSE, version 2000-Apr-09 or later
19 (the contents of which are also included in zip.h) for terms of use.
20 If, for some reason, all these files are missing, the Info-ZIP license
21 also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
22 */
23 /*
24 crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h]
25
26 The encryption/decryption parts of this source code (as opposed to the
27 non-echoing password parts) were originally written in Europe. The
28 whole source package can be freely distributed, including from the USA.
29 (Prior to January 2000, re-export from the US was a violation of US law.)
30 */
31
32 /*
33 This encryption code is a direct transcription of the algorithm from
34 Roger Schlafly, described by Phil Katz in the file appnote.txt. This
35 file (appnote.txt) is distributed with the PKZIP program (even in the
36 version without encryption capabilities).
37 */
38
39
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include "zlib.h"
44 #include "unzip.h"
45
46 #ifdef STDC
47 # include <stddef.h>
48 # include <string.h>
49 # include <stdlib.h>
50 #endif
51 #ifdef NO_ERRNO_H
52 extern int errno;
53 #else
54 # include <errno.h>
55 #endif
56
57
58 #ifndef local
59 # define local static
60 #endif
61 /* compile with -Dlocal if your debugger can't find static symbols */
62
63
64 #ifndef CASESENSITIVITYDEFAULT_NO
65 # if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
66 # define CASESENSITIVITYDEFAULT_NO
67 # endif
68 #endif
69
70
71 #ifndef UNZ_BUFSIZE
72 #define UNZ_BUFSIZE (16384)
73 #endif
74
75 #ifndef UNZ_MAXFILENAMEINZIP
76 #define UNZ_MAXFILENAMEINZIP (256)
77 #endif
78
79 #ifndef ALLOC
80 # define ALLOC(size) (malloc(size))
81 #endif
82 #ifndef TRYFREE
83 # define TRYFREE(p) {if (p) free(p);}
84 #endif
85
86 #define SIZECENTRALDIRITEM (0x2e)
87 #define SIZEZIPLOCALHEADER (0x1e)
88
89
90
91
92 const char unz_copyright[] =
93 " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
94
95 /* unz_file_info_interntal contain internal info about a file in zipfile*/
96 typedef struct unz_file_info_internal_s
97 {
98 uLong offset_curfile;/* relative offset of local header 4 bytes */
99 } unz_file_info_internal;
100
101
102 /* file_in_zip_read_info_s contain internal information about a file in zipfile,
103 when reading and decompress it */
104 typedef struct
105 {
106 char *read_buffer; /* internal buffer for compressed data */
107 z_stream stream; /* zLib stream structure for inflate */
108
109 uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/
110 uLong stream_initialised; /* flag set if stream structure is initialised*/
111
112 uLong offset_local_extrafield;/* offset of the local extra field */
113 uInt size_local_extrafield;/* size of the local extra field */
114 uLong pos_local_extrafield; /* position in the local extra field in read*/
115
116 uLong crc32; /* crc32 of all data uncompressed */
117 uLong crc32_wait; /* crc32 we must obtain after decompress all */
118 uLong rest_read_compressed; /* number of byte to be decompressed */
119 uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
120 zlib_filefunc_def z_filefunc;
121 voidpf filestream; /* io structore of the zipfile */
122 uLong compression_method; /* compression method (0==store) */
123 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
124 int raw;
125 } file_in_zip_read_info_s;
126
127
128 /* unz_s contain internal information about the zipfile
129 */
130 typedef struct
131 {
132 zlib_filefunc_def z_filefunc;
133 voidpf filestream; /* io structore of the zipfile */
134 unz_global_info gi; /* public global information */
135 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
136 uLong num_file; /* number of the current file in the zipfile*/
137 uLong pos_in_central_dir; /* pos of the current file in the central dir*/
138 uLong current_file_ok; /* flag about the usability of the current file*/
139 uLong central_pos; /* position of the beginning of the central dir*/
140
141 uLong size_central_dir; /* size of the central directory */
142 uLong offset_central_dir; /* offset of start of central directory with
143 respect to the starting disk number */
144
145 unz_file_info cur_file_info; /* public info about the current file in zip*/
146 unz_file_info_internal cur_file_info_internal; /* private info about it*/
147 file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
148 file if we are decompressing it */
149 int encrypted;
150 # ifndef NOUNCRYPT
151 unsigned long keys[3]; /* keys defining the pseudo-random sequence */
152 const unsigned long* pcrc_32_tab;
153 # endif
154 } unz_s;
155
156
157 #ifndef NOUNCRYPT
158 #include "crypt.h"
159 #endif
160
161 /* ===========================================================================
162 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
163 for end of file.
164 IN assertion: the stream s has been sucessfully opened for reading.
165 */
166
167
168 local int unzlocal_getByte OF((
169 const zlib_filefunc_def* pzlib_filefunc_def,
170 voidpf filestream,
171 int *pi));
172
173 local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi)
174 const zlib_filefunc_def* pzlib_filefunc_def;
175 voidpf filestream;
176 int *pi;
177 {
178 unsigned char c;
179 int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
180 if (err==1)
181 {
182 *pi = (int)c;
183 return UNZ_OK;
184 }
185 else
186 {
187 if (ZERROR(*pzlib_filefunc_def,filestream))
188 return UNZ_ERRNO;
189 else
190 return UNZ_EOF;
191 }
192 }
193
194
195 /* ===========================================================================
196 Reads a long in LSB order from the given gz_stream. Sets
197 */
198 local int unzlocal_getShort OF((
199 const zlib_filefunc_def* pzlib_filefunc_def,
200 voidpf filestream,
201 uLong *pX));
202
203 local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX)
204 const zlib_filefunc_def* pzlib_filefunc_def;
205 voidpf filestream;
206 uLong *pX;
207 {
208 uLong x ;
209 int i;
210 int err;
211
212 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
213 x = (uLong)i;
214
215 if (err==UNZ_OK)
216 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
217 x += ((uLong)i)<<8;
218
219 if (err==UNZ_OK)
220 *pX = x;
221 else
222 *pX = 0;
223 return err;
224 }
225
226 local int unzlocal_getLong OF((
227 const zlib_filefunc_def* pzlib_filefunc_def,
228 voidpf filestream,
229 uLong *pX));
230
231 local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX)
232 const zlib_filefunc_def* pzlib_filefunc_def;
233 voidpf filestream;
234 uLong *pX;
235 {
236 uLong x ;
237 int i;
238 int err;
239
240 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
241 x = (uLong)i;
242
243 if (err==UNZ_OK)
244 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
245 x += ((uLong)i)<<8;
246
247 if (err==UNZ_OK)
248 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
249 x += ((uLong)i)<<16;
250
251 if (err==UNZ_OK)
252 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
253 x += ((uLong)i)<<24;
254
255 if (err==UNZ_OK)
256 *pX = x;
257 else
258 *pX = 0;
259 return err;
260 }
261
262
263 /* My own strcmpi / strcasecmp */
264 local int strcmpcasenosensitive_internal (fileName1,fileName2)
265 const char* fileName1;
266 const char* fileName2;
267 {
268 for (;;)
269 {
270 char c1=*(fileName1++);
271 char c2=*(fileName2++);
272 if ((c1>='a') && (c1<='z'))
273 c1 -= 0x20;
274 if ((c2>='a') && (c2<='z'))
275 c2 -= 0x20;
276 if (c1=='\0')
277 return ((c2=='\0') ? 0 : -1);
278 if (c2=='\0')
279 return 1;
280 if (c1<c2)
281 return -1;
282 if (c1>c2)
283 return 1;
284 }
285 }
286
287
288 #ifdef CASESENSITIVITYDEFAULT_NO
289 #define CASESENSITIVITYDEFAULTVALUE 2
290 #else
291 #define CASESENSITIVITYDEFAULTVALUE 1
292 #endif
293
294 #ifndef STRCMPCASENOSENTIVEFUNCTION
295 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
296 #endif
297
298 /*
299 Compare two filename (fileName1,fileName2).
300 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
301 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
302 or strcasecmp)
303 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
304 (like 1 on Unix, 2 on Windows)
305
306 */
307 extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
308 const char* fileName1;
309 const char* fileName2;
310 int iCaseSensitivity;
311 {
312 if (iCaseSensitivity==0)
313 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
314
315 if (iCaseSensitivity==1)
316 return strcmp(fileName1,fileName2);
317
318 return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
319 }
320
321 #ifndef BUFREADCOMMENT
322 #define BUFREADCOMMENT (0x400)
323 #endif
324
325 /*
326 Locate the Central directory of a zipfile (at the end, just before
327 the global comment)
328 */
329 local uLong unzlocal_SearchCentralDir OF((
330 const zlib_filefunc_def* pzlib_filefunc_def,
331 voidpf filestream));
332
333 local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream)
334 const zlib_filefunc_def* pzlib_filefunc_def;
335 voidpf filestream;
336 {
337 unsigned char* buf;
338 uLong uSizeFile;
339 uLong uBackRead;
340 uLong uMaxBack=0xffff; /* maximum size of global comment */
341 uLong uPosFound=0;
342
343 if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
344 return 0;
345
346
347 uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
348
349 if (uMaxBack>uSizeFile)
350 uMaxBack = uSizeFile;
351
352 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
353 if (buf==NULL)
354 return 0;
355
356 uBackRead = 4;
357 while (uBackRead<uMaxBack)
358 {
359 uLong uReadSize,uReadPos ;
360 int i;
361 if (uBackRead+BUFREADCOMMENT>uMaxBack)
362 uBackRead = uMaxBack;
363 else
364 uBackRead+=BUFREADCOMMENT;
365 uReadPos = uSizeFile-uBackRead ;
366
367 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
368 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
369 if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
370 break;
371
372 if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
373 break;
374
375 for (i=(int)uReadSize-3; (i--)>0;)
376 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
377 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
378 {
379 uPosFound = uReadPos+i;
380 break;
381 }
382
383 if (uPosFound!=0)
384 break;
385 }
386 TRYFREE(buf);
387 return uPosFound;
388 }
389
390 /*
391 Open a Zip file. path contain the full pathname (by example,
392 on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
393 "zlib/zlib114.zip".
394 If the zipfile cannot be opened (file doesn't exist or in not valid), the
395 return value is NULL.
396 Else, the return value is a unzFile Handle, usable with other function
397 of this unzip package.
398 */
399 extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def)
400 const char *path;
401 zlib_filefunc_def* pzlib_filefunc_def;
402 {
403 unz_s us;
404 unz_s *s;
405 uLong central_pos,uL;
406
407 uLong number_disk; /* number of the current dist, used for
408 spaning ZIP, unsupported, always 0*/
409 uLong number_disk_with_CD; /* number the the disk with central dir, used
410 for spaning ZIP, unsupported, always 0*/
411 uLong number_entry_CD; /* total number of entries in
412 the central dir
413 (same than number_entry on nospan) */
414
415 int err=UNZ_OK;
416
417 if (unz_copyright[0]!=' ')
418 return NULL;
419
420 if (pzlib_filefunc_def==NULL)
421 fill_fopen_filefunc(&us.z_filefunc);
422 else
423 us.z_filefunc = *pzlib_filefunc_def;
424
425 us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque,
426 path,
427 ZLIB_FILEFUNC_MODE_READ |
428 ZLIB_FILEFUNC_MODE_EXISTING);
429 if (us.filestream==NULL)
430 return NULL;
431
432 central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream);
433 if (central_pos==0)
434 err=UNZ_ERRNO;
435
436 if (ZSEEK(us.z_filefunc, us.filestream,
437 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
438 err=UNZ_ERRNO;
439
440 /* the signature, already checked */
441 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
442 err=UNZ_ERRNO;
443
444 /* number of this disk */
445 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
446 err=UNZ_ERRNO;
447
448 /* number of the disk with the start of the central directory */
449 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
450 err=UNZ_ERRNO;
451
452 /* total number of entries in the central dir on this disk */
453 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
454 err=UNZ_ERRNO;
455
456 /* total number of entries in the central dir */
457 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
458 err=UNZ_ERRNO;
459
460 if ((number_entry_CD!=us.gi.number_entry) ||
461 (number_disk_with_CD!=0) ||
462 (number_disk!=0))
463 err=UNZ_BADZIPFILE;
464
465 /* size of the central directory */
466 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
467 err=UNZ_ERRNO;
468
469 /* offset of start of central directory with respect to the
470 starting disk number */
471 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
472 err=UNZ_ERRNO;
473
474 /* zipfile comment length */
475 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
476 err=UNZ_ERRNO;
477
478 if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
479 (err==UNZ_OK))
480 err=UNZ_BADZIPFILE;
481
482 if (err!=UNZ_OK)
483 {
484 ZCLOSE(us.z_filefunc, us.filestream);
485 return NULL;
486 }
487
488 us.byte_before_the_zipfile = central_pos -
489 (us.offset_central_dir+us.size_central_dir);
490 us.central_pos = central_pos;
491 us.pfile_in_zip_read = NULL;
492 us.encrypted = 0;
493
494
495 s=(unz_s*)ALLOC(sizeof(unz_s));
496 *s=us;
497 unzGoToFirstFile((unzFile)s);
498 return (unzFile)s;
499 }
500
501
502 extern unzFile ZEXPORT unzOpen (path)
503 const char *path;
504 {
505 return unzOpen2(path, NULL);
506 }
507
508 /*
509 Close a ZipFile opened with unzipOpen.
510 If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
511 these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
512 return UNZ_OK if there is no problem. */
513 extern int ZEXPORT unzClose (file)
514 unzFile file;
515 {
516 unz_s* s;
517 if (file==NULL)
518 return UNZ_PARAMERROR;
519 s=(unz_s*)file;
520
521 if (s->pfile_in_zip_read!=NULL)
522 unzCloseCurrentFile(file);
523
524 ZCLOSE(s->z_filefunc, s->filestream);
525 TRYFREE(s);
526 return UNZ_OK;
527 }
528
529
530 /*
531 Write info about the ZipFile in the *pglobal_info structure.
532 No preparation of the structure is needed
533 return UNZ_OK if there is no problem. */
534 extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
535 unzFile file;
536 unz_global_info *pglobal_info;
537 {
538 unz_s* s;
539 if (file==NULL)
540 return UNZ_PARAMERROR;
541 s=(unz_s*)file;
542 *pglobal_info=s->gi;
543 return UNZ_OK;
544 }
545
546
547 /*
548 Translate date/time from Dos format to tm_unz (readable more easilty)
549 */
550 local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
551 uLong ulDosDate;
552 tm_unz* ptm;
553 {
554 uLong uDate;
555 uDate = (uLong)(ulDosDate>>16);
556 ptm->tm_mday = (uInt)(uDate&0x1f) ;
557 ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ;
558 ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
559
560 ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
561 ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;
562 ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;
563 }
564
565 /*
566 Get Info about the current file in the zipfile, with internal only info
567 */
568 local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
569 unz_file_info *pfile_info,
570 unz_file_info_internal
571 *pfile_info_internal,
572 char *szFileName,
573 uLong fileNameBufferSize,
574 void *extraField,
575 uLong extraFieldBufferSize,
576 char *szComment,
577 uLong commentBufferSize));
578
579 local int unzlocal_GetCurrentFileInfoInternal (file,
580 pfile_info,
581 pfile_info_internal,
582 szFileName, fileNameBufferSize,
583 extraField, extraFieldBufferSize,
584 szComment, commentBufferSize)
585 unzFile file;
586 unz_file_info *pfile_info;
587 unz_file_info_internal *pfile_info_internal;
588 char *szFileName;
589 uLong fileNameBufferSize;
590 void *extraField;
591 uLong extraFieldBufferSize;
592 char *szComment;
593 uLong commentBufferSize;
594 {
595 unz_s* s;
596 unz_file_info file_info;
597 unz_file_info_internal file_info_internal;
598 int err=UNZ_OK;
599 uLong uMagic;
600 long lSeek=0;
601
602 if (file==NULL)
603 return UNZ_PARAMERROR;
604 s=(unz_s*)file;
605 if (ZSEEK(s->z_filefunc, s->filestream,
606 s->pos_in_central_dir+s->byte_before_the_zipfile,
607 ZLIB_FILEFUNC_SEEK_SET)!=0)
608 err=UNZ_ERRNO;
609
610
611 /* we check the magic */
612 if (err==UNZ_OK)
613 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
614 err=UNZ_ERRNO;
615 else if (uMagic!=0x02014b50)
616 err=UNZ_BADZIPFILE;
617
618 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
619 err=UNZ_ERRNO;
620
621 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
622 err=UNZ_ERRNO;
623
624 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
625 err=UNZ_ERRNO;
626
627 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
628 err=UNZ_ERRNO;
629
630 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
631 err=UNZ_ERRNO;
632
633 unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
634
635 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
636 err=UNZ_ERRNO;
637
638 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
639 err=UNZ_ERRNO;
640
641 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
642 err=UNZ_ERRNO;
643
644 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
645 err=UNZ_ERRNO;
646
647 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
648 err=UNZ_ERRNO;
649
650 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
651 err=UNZ_ERRNO;
652
653 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
654 err=UNZ_ERRNO;
655
656 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
657 err=UNZ_ERRNO;
658
659 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
660 err=UNZ_ERRNO;
661
662 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
663 err=UNZ_ERRNO;
664
665 lSeek+=file_info.size_filename;
666 if ((err==UNZ_OK) && (szFileName!=NULL))
667 {
668 uLong uSizeRead ;
669 if (file_info.size_filename<fileNameBufferSize)
670 {
671 *(szFileName+file_info.size_filename)='\0';
672 uSizeRead = file_info.size_filename;
673 }
674 else
675 uSizeRead = fileNameBufferSize;
676
677 if ((file_info.size_filename>0) && (fileNameBufferSize>0))
678 if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
679 err=UNZ_ERRNO;
680 lSeek -= uSizeRead;
681 }
682
683
684 if ((err==UNZ_OK) && (extraField!=NULL))
685 {
686 uLong uSizeRead ;
687 if (file_info.size_file_extra<extraFieldBufferSize)
688 uSizeRead = file_info.size_file_extra;
689 else
690 uSizeRead = extraFieldBufferSize;
691
692 if (lSeek!=0)
693 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
694 lSeek=0;
695 else
696 err=UNZ_ERRNO;
697 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
698 if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead)
699 err=UNZ_ERRNO;
700 lSeek += file_info.size_file_extra - uSizeRead;
701 }
702 else
703 lSeek+=file_info.size_file_extra;
704
705
706 if ((err==UNZ_OK) && (szComment!=NULL))
707 {
708 uLong uSizeRead ;
709 if (file_info.size_file_comment<commentBufferSize)
710 {
711 *(szComment+file_info.size_file_comment)='\0';
712 uSizeRead = file_info.size_file_comment;
713 }
714 else
715 uSizeRead = commentBufferSize;
716
717 if (lSeek!=0)
718 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
719 lSeek=0;
720 else
721 err=UNZ_ERRNO;
722 if ((file_info.size_file_comment>0) && (commentBufferSize>0))
723 if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
724 err=UNZ_ERRNO;
725 lSeek+=file_info.size_file_comment - uSizeRead;
726 }
727 else
728 lSeek+=file_info.size_file_comment;
729
730 if ((err==UNZ_OK) && (pfile_info!=NULL))
731 *pfile_info=file_info;
732
733 if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
734 *pfile_info_internal=file_info_internal;
735
736 return err;
737 }
738
739
740
741 /*
742 Write info about the ZipFile in the *pglobal_info structure.
743 No preparation of the structure is needed
744 return UNZ_OK if there is no problem.
745 */
746 extern int ZEXPORT unzGetCurrentFileInfo (file,
747 pfile_info,
748 szFileName, fileNameBufferSize,
749 extraField, extraFieldBufferSize,
750 szComment, commentBufferSize)
751 unzFile file;
752 unz_file_info *pfile_info;
753 char *szFileName;
754 uLong fileNameBufferSize;
755 void *extraField;
756 uLong extraFieldBufferSize;
757 char *szComment;
758 uLong commentBufferSize;
759 {
760 return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
761 szFileName,fileNameBufferSize,
762 extraField,extraFieldBufferSize,
763 szComment,commentBufferSize);
764 }
765
766 /*
767 Set the current file of the zipfile to the first file.
768 return UNZ_OK if there is no problem
769 */
770 extern int ZEXPORT unzGoToFirstFile (file)
771 unzFile file;
772 {
773 int err=UNZ_OK;
774 unz_s* s;
775 if (file==NULL)
776 return UNZ_PARAMERROR;
777 s=(unz_s*)file;
778 s->pos_in_central_dir=s->offset_central_dir;
779 s->num_file=0;
780 err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
781 &s->cur_file_info_internal,
782 NULL,0,NULL,0,NULL,0);
783 s->current_file_ok = (err == UNZ_OK);
784 return err;
785 }
786
787 /*
788 Set the current file of the zipfile to the next file.
789 return UNZ_OK if there is no problem
790 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
791 */
792 extern int ZEXPORT unzGoToNextFile (file)
793 unzFile file;
794 {
795 unz_s* s;
796 int err;
797
798 if (file==NULL)
799 return UNZ_PARAMERROR;
800 s=(unz_s*)file;
801 if (!s->current_file_ok)
802 return UNZ_END_OF_LIST_OF_FILE;
803 if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */
804 if (s->num_file+1==s->gi.number_entry)
805 return UNZ_END_OF_LIST_OF_FILE;
806
807 s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
808 s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
809 s->num_file++;
810 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
811 &s->cur_file_info_internal,
812 NULL,0,NULL,0,NULL,0);
813 s->current_file_ok = (err == UNZ_OK);
814 return err;
815 }
816
817
818 /*
819 Try locate the file szFileName in the zipfile.
820 For the iCaseSensitivity signification, see unzipStringFileNameCompare
821
822 return value :
823 UNZ_OK if the file is found. It becomes the current file.
824 UNZ_END_OF_LIST_OF_FILE if the file is not found
825 */
826 extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
827 unzFile file;
828 const char *szFileName;
829 int iCaseSensitivity;
830 {
831 unz_s* s;
832 int err;
833
834 /* We remember the 'current' position in the file so that we can jump
835 * back there if we fail.
836 */
837 unz_file_info cur_file_infoSaved;
838 unz_file_info_internal cur_file_info_internalSaved;
839 uLong num_fileSaved;
840 uLong pos_in_central_dirSaved;
841
842
843 if (file==NULL)
844 return UNZ_PARAMERROR;
845
846 if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
847 return UNZ_PARAMERROR;
848
849 s=(unz_s*)file;
850 if (!s->current_file_ok)
851 return UNZ_END_OF_LIST_OF_FILE;
852
853 /* Save the current state */
854 num_fileSaved = s->num_file;
855 pos_in_central_dirSaved = s->pos_in_central_dir;
856 cur_file_infoSaved = s->cur_file_info;
857 cur_file_info_internalSaved = s->cur_file_info_internal;
858
859 err = unzGoToFirstFile(file);
860
861 while (err == UNZ_OK)
862 {
863 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
864 err = unzGetCurrentFileInfo(file,NULL,
865 szCurrentFileName,sizeof(szCurrentFileName)-1,
866 NULL,0,NULL,0);
867 if (err == UNZ_OK)
868 {
869 if (unzStringFileNameCompare(szCurrentFileName,
870 szFileName,iCaseSensitivity)==0)
871 return UNZ_OK;
872 err = unzGoToNextFile(file);
873 }
874 }
875
876 /* We failed, so restore the state of the 'current file' to where we
877 * were.
878 */
879 s->num_file = num_fileSaved ;
880 s->pos_in_central_dir = pos_in_central_dirSaved ;
881 s->cur_file_info = cur_file_infoSaved;
882 s->cur_file_info_internal = cur_file_info_internalSaved;
883 return err;
884 }
885
886
887 /*
888 ///////////////////////////////////////////
889 // Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
890 // I need random access
891 //
892 // Further optimization could be realized by adding an ability
893 // to cache the directory in memory. The goal being a single
894 // comprehensive file read to put the file I need in a memory.
895 */
896
897 /*
898 typedef struct unz_file_pos_s
899 {
900 uLong pos_in_zip_directory; // offset in file
901 uLong num_of_file; // # of file
902 } unz_file_pos;
903 */
904
905 extern int ZEXPORT unzGetFilePos(file, file_pos)
906 unzFile file;
907 unz_file_pos* file_pos;
908 {
909 unz_s* s;
910
911 if (file==NULL || file_pos==NULL)
912 return UNZ_PARAMERROR;
913 s=(unz_s*)file;
914 if (!s->current_file_ok)
915 return UNZ_END_OF_LIST_OF_FILE;
916
917 file_pos->pos_in_zip_directory = s->pos_in_central_dir;
918 file_pos->num_of_file = s->num_file;
919
920 return UNZ_OK;
921 }
922
923 extern int ZEXPORT unzGoToFilePos(file, file_pos)
924 unzFile file;
925 unz_file_pos* file_pos;
926 {
927 unz_s* s;
928 int err;
929
930 if (file==NULL || file_pos==NULL)
931 return UNZ_PARAMERROR;
932 s=(unz_s*)file;
933
934 /* jump to the right spot */
935 s->pos_in_central_dir = file_pos->pos_in_zip_directory;
936 s->num_file = file_pos->num_of_file;
937
938 /* set the current file */
939 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
940 &s->cur_file_info_internal,
941 NULL,0,NULL,0,NULL,0);
942 /* return results */
943 s->current_file_ok = (err == UNZ_OK);
944 return err;
945 }
946
947 /*
948 // Unzip Helper Functions - should be here?
949 ///////////////////////////////////////////
950 */
951
952 /*
953 Read the local header of the current zipfile
954 Check the coherency of the local header and info in the end of central
955 directory about this file
956 store in *piSizeVar the size of extra info in local header
957 (filename and size of extra field data)
958 */
959 local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
960 poffset_local_extrafield,
961 psize_local_extrafield)
962 unz_s* s;
963 uInt* piSizeVar;
964 uLong *poffset_local_extrafield;
965 uInt *psize_local_extrafield;
966 {
967 uLong uMagic,uData,uFlags;
968 uLong size_filename;
969 uLong size_extra_field;
970 int err=UNZ_OK;
971
972 *piSizeVar = 0;
973 *poffset_local_extrafield = 0;
974 *psize_local_extrafield = 0;
975
976 if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
977 s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
978 return UNZ_ERRNO;
979
980
981 if (err==UNZ_OK)
982 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
983 err=UNZ_ERRNO;
984 else if (uMagic!=0x04034b50)
985 err=UNZ_BADZIPFILE;
986
987 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
988 err=UNZ_ERRNO;
989 /*
990 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
991 err=UNZ_BADZIPFILE;
992 */
993 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
994 err=UNZ_ERRNO;
995
996 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
997 err=UNZ_ERRNO;
998 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
999 err=UNZ_BADZIPFILE;
1000
1001 if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
1002 (s->cur_file_info.compression_method!=Z_DEFLATED))
1003 err=UNZ_BADZIPFILE;
1004
1005 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
1006 err=UNZ_ERRNO;
1007
1008 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
1009 err=UNZ_ERRNO;
1010 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
1011 ((uFlags & 8)==0))
1012 err=UNZ_BADZIPFILE;
1013
1014 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
1015 err=UNZ_ERRNO;
1016 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
1017 ((uFlags & 8)==0))
1018 err=UNZ_BADZIPFILE;
1019
1020 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
1021 err=UNZ_ERRNO;
1022 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
1023 ((uFlags & 8)==0))
1024 err=UNZ_BADZIPFILE;
1025
1026
1027 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
1028 err=UNZ_ERRNO;
1029 else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
1030 err=UNZ_BADZIPFILE;
1031
1032 *piSizeVar += (uInt)size_filename;
1033
1034 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
1035 err=UNZ_ERRNO;
1036 *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
1037 SIZEZIPLOCALHEADER + size_filename;
1038 *psize_local_extrafield = (uInt)size_extra_field;
1039
1040 *piSizeVar += (uInt)size_extra_field;
1041
1042 return err;
1043 }
1044
1045 /*
1046 Open for reading data the current file in the zipfile.
1047 If there is no error and the file is opened, the return value is UNZ_OK.
1048 */
1049 extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
1050 unzFile file;
1051 int* method;
1052 int* level;
1053 int raw;
1054 const char* password;
1055 {
1056 int err=UNZ_OK;
1057 uInt iSizeVar;
1058 unz_s* s;
1059 file_in_zip_read_info_s* pfile_in_zip_read_info;
1060 uLong offset_local_extrafield; /* offset of the local extra field */
1061 uInt size_local_extrafield; /* size of the local extra field */
1062 # ifndef NOUNCRYPT
1063 char source[12];
1064 # else
1065 if (password != NULL)
1066 return UNZ_PARAMERROR;
1067 # endif
1068
1069 if (file==NULL)
1070 return UNZ_PARAMERROR;
1071 s=(unz_s*)file;
1072 if (!s->current_file_ok)
1073 return UNZ_PARAMERROR;
1074
1075 if (s->pfile_in_zip_read != NULL)
1076 unzCloseCurrentFile(file);
1077
1078 if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
1079 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
1080 return UNZ_BADZIPFILE;
1081
1082 pfile_in_zip_read_info = (file_in_zip_read_info_s*)
1083 ALLOC(sizeof(file_in_zip_read_info_s));
1084 if (pfile_in_zip_read_info==NULL)
1085 return UNZ_INTERNALERROR;
1086
1087 pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
1088 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
1089 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
1090 pfile_in_zip_read_info->pos_local_extrafield=0;
1091 pfile_in_zip_read_info->raw=raw;
1092
1093 if (pfile_in_zip_read_info->read_buffer==NULL)
1094 {
1095 TRYFREE(pfile_in_zip_read_info);
1096 return UNZ_INTERNALERROR;
1097 }
1098
1099 pfile_in_zip_read_info->stream_initialised=0;
1100
1101 if (method!=NULL)
1102 *method = (int)s->cur_file_info.compression_method;
1103
1104 if (level!=NULL)
1105 {
1106 *level = 6;
1107 switch (s->cur_file_info.flag & 0x06)
1108 {
1109 case 6 : *level = 1; break;
1110 case 4 : *level = 2; break;
1111 case 2 : *level = 9; break;
1112 }
1113 }
1114
1115 if ((s->cur_file_info.compression_method!=0) &&
1116 (s->cur_file_info.compression_method!=Z_DEFLATED))
1117 err=UNZ_BADZIPFILE;
1118
1119 pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
1120 pfile_in_zip_read_info->crc32=0;
1121 pfile_in_zip_read_info->compression_method =
1122 s->cur_file_info.compression_method;
1123 pfile_in_zip_read_info->filestream=s->filestream;
1124 pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
1125 pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
1126
1127 pfile_in_zip_read_info->stream.total_out = 0;
1128
1129 if ((s->cur_file_info.compression_method==Z_DEFLATED) &&
1130 (!raw))
1131 {
1132 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
1133 pfile_in_zip_read_info->stream.zfree = (free_func)0;
1134 pfile_in_zip_read_info->stream.opaque = (voidpf)0;
1135 pfile_in_zip_read_info->stream.next_in = (voidpf)0;
1136 pfile_in_zip_read_info->stream.avail_in = 0;
1137
1138 err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
1139 if (err == Z_OK)
1140 pfile_in_zip_read_info->stream_initialised=1;
1141 else
1142 {
1143 TRYFREE(pfile_in_zip_read_info);
1144 return err;
1145 }
1146 /* windowBits is passed < 0 to tell that there is no zlib header.
1147 * Note that in this case inflate *requires* an extra "dummy" byte
1148 * after the compressed stream in order to complete decompression and
1149 * return Z_STREAM_END.
1150 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1151 * size of both compressed and uncompressed data
1152 */
1153 }
1154 pfile_in_zip_read_info->rest_read_compressed =
1155 s->cur_file_info.compressed_size ;
1156 pfile_in_zip_read_info->rest_read_uncompressed =
1157 s->cur_file_info.uncompressed_size ;
1158
1159
1160 pfile_in_zip_read_info->pos_in_zipfile =
1161 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
1162 iSizeVar;
1163
1164 pfile_in_zip_read_info->stream.avail_in = (uInt)0;
1165
1166 s->pfile_in_zip_read = pfile_in_zip_read_info;
1167
1168 # ifndef NOUNCRYPT
1169 if (password != NULL)
1170 {
1171 int i;
1172 s->pcrc_32_tab = get_crc_table();
1173 init_keys(password,s->keys,s->pcrc_32_tab);
1174 if (ZSEEK(s->z_filefunc, s->filestream,
1175 s->pfile_in_zip_read->pos_in_zipfile +
1176 s->pfile_in_zip_read->byte_before_the_zipfile,
1177 SEEK_SET)!=0)
1178 return UNZ_INTERNALERROR;
1179 if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12)
1180 return UNZ_INTERNALERROR;
1181
1182 for (i = 0; i<12; i++)
1183 zdecode(s->keys,s->pcrc_32_tab,source[i]);
1184
1185 s->pfile_in_zip_read->pos_in_zipfile+=12;
1186 s->encrypted=1;
1187 }
1188 # endif
1189
1190
1191 return UNZ_OK;
1192 }
1193
1194 extern int ZEXPORT unzOpenCurrentFile (file)
1195 unzFile file;
1196 {
1197 return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
1198 }
1199
1200 extern int ZEXPORT unzOpenCurrentFilePassword (file, password)
1201 unzFile file;
1202 const char* password;
1203 {
1204 return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
1205 }
1206
1207 extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
1208 unzFile file;
1209 int* method;
1210 int* level;
1211 int raw;
1212 {
1213 return unzOpenCurrentFile3(file, method, level, raw, NULL);
1214 }
1215
1216 /*
1217 Read bytes from the current file.
1218 buf contain buffer where data must be copied
1219 len the size of buf.
1220
1221 return the number of byte copied if somes bytes are copied
1222 return 0 if the end of file was reached
1223 return <0 with error code if there is an error
1224 (UNZ_ERRNO for IO error, or zLib error for uncompress error)
1225 */
1226 extern int ZEXPORT unzReadCurrentFile (file, buf, len)
1227 unzFile file;
1228 voidp buf;
1229 unsigned len;
1230 {
1231 int err=UNZ_OK;
1232 uInt iRead = 0;
1233 unz_s* s;
1234 file_in_zip_read_info_s* pfile_in_zip_read_info;
1235 if (file==NULL)
1236 return UNZ_PARAMERROR;
1237 s=(unz_s*)file;
1238 pfile_in_zip_read_info=s->pfile_in_zip_read;
1239
1240 if (pfile_in_zip_read_info==NULL)
1241 return UNZ_PARAMERROR;
1242
1243
1244 if ((pfile_in_zip_read_info->read_buffer == NULL))
1245 return UNZ_END_OF_LIST_OF_FILE;
1246 if (len==0)
1247 return 0;
1248
1249 pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
1250
1251 pfile_in_zip_read_info->stream.avail_out = (uInt)len;
1252
1253 if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
1254 (!(pfile_in_zip_read_info->raw)))
1255 pfile_in_zip_read_info->stream.avail_out =
1256 (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
1257
1258 if ((len>pfile_in_zip_read_info->rest_read_compressed+
1259 pfile_in_zip_read_info->stream.avail_in) &&
1260 (pfile_in_zip_read_info->raw))
1261 pfile_in_zip_read_info->stream.avail_out =
1262 (uInt)pfile_in_zip_read_info->rest_read_compressed+
1263 pfile_in_zip_read_info->stream.avail_in;
1264
1265 while (pfile_in_zip_read_info->stream.avail_out>0)
1266 {
1267 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
1268 (pfile_in_zip_read_info->rest_read_compressed>0))
1269 {
1270 uInt uReadThis = UNZ_BUFSIZE;
1271 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
1272 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
1273 if (uReadThis == 0)
1274 return UNZ_EOF;
1275 if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
1276 pfile_in_zip_read_info->filestream,
1277 pfile_in_zip_read_info->pos_in_zipfile +
1278 pfile_in_zip_read_info->byte_before_the_zipfile,
1279 ZLIB_FILEFUNC_SEEK_SET)!=0)
1280 return UNZ_ERRNO;
1281 if (ZREAD(pfile_in_zip_read_info->z_filefunc,
1282 pfile_in_zip_read_info->filestream,
1283 pfile_in_zip_read_info->read_buffer,
1284 uReadThis)!=uReadThis)
1285 return UNZ_ERRNO;
1286
1287
1288 # ifndef NOUNCRYPT
1289 if(s->encrypted)
1290 {
1291 uInt i;
1292 for(i=0;i<uReadThis;i++)
1293 pfile_in_zip_read_info->read_buffer[i] =
1294 zdecode(s->keys,s->pcrc_32_tab,
1295 pfile_in_zip_read_info->read_buffer[i]);
1296 }
1297 # endif
1298
1299
1300 pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1301
1302 pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
1303
1304 pfile_in_zip_read_info->stream.next_in =
1305 (Bytef*)pfile_in_zip_read_info->read_buffer;
1306 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
1307 }
1308
1309 if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
1310 {
1311 uInt uDoCopy,i ;
1312
1313 if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
1314 (pfile_in_zip_read_info->rest_read_compressed == 0))
1315 return (iRead==0) ? UNZ_EOF : iRead;
1316
1317 if (pfile_in_zip_read_info->stream.avail_out <
1318 pfile_in_zip_read_info->stream.avail_in)
1319 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
1320 else
1321 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
1322
1323 for (i=0;i<uDoCopy;i++)
1324 *(pfile_in_zip_read_info->stream.next_out+i) =
1325 *(pfile_in_zip_read_info->stream.next_in+i);
1326
1327 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
1328 pfile_in_zip_read_info->stream.next_out,
1329 uDoCopy);
1330 pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
1331 pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1332 pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1333 pfile_in_zip_read_info->stream.next_out += uDoCopy;
1334 pfile_in_zip_read_info->stream.next_in += uDoCopy;
1335 pfile_in_zip_read_info->stream.total_out += uDoCopy;
1336 iRead += uDoCopy;
1337 }
1338 else
1339 {
1340 uLong uTotalOutBefore,uTotalOutAfter;
1341 const Bytef *bufBefore;
1342 uLong uOutThis;
1343 int flush=Z_SYNC_FLUSH;
1344
1345 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
1346 bufBefore = pfile_in_zip_read_info->stream.next_out;
1347
1348 /*
1349 if ((pfile_in_zip_read_info->rest_read_uncompressed ==
1350 pfile_in_zip_read_info->stream.avail_out) &&
1351 (pfile_in_zip_read_info->rest_read_compressed == 0))
1352 flush = Z_FINISH;
1353 */
1354 err=inflate(&pfile_in_zip_read_info->stream,flush);
1355
1356 if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
1357 err = Z_DATA_ERROR;
1358
1359 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
1360 uOutThis = uTotalOutAfter-uTotalOutBefore;
1361
1362 pfile_in_zip_read_info->crc32 =
1363 crc32(pfile_in_zip_read_info->crc32,bufBefore,
1364 (uInt)(uOutThis));
1365
1366 pfile_in_zip_read_info->rest_read_uncompressed -=
1367 uOutThis;
1368
1369 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1370
1371 if (err==Z_STREAM_END)
1372 return (iRead==0) ? UNZ_EOF : iRead;
1373 if (err!=Z_OK)
1374 break;
1375 }
1376 }
1377
1378 if (err==Z_OK)
1379 return iRead;
1380 return err;
1381 }
1382
1383
1384 /*
1385 Give the current position in uncompressed data
1386 */
1387 extern z_off_t ZEXPORT unztell (file)
1388 unzFile file;
1389 {
1390 unz_s* s;
1391 file_in_zip_read_info_s* pfile_in_zip_read_info;
1392 if (file==NULL)
1393 return UNZ_PARAMERROR;
1394 s=(unz_s*)file;
1395 pfile_in_zip_read_info=s->pfile_in_zip_read;
1396
1397 if (pfile_in_zip_read_info==NULL)
1398 return UNZ_PARAMERROR;
1399
1400 return (z_off_t)pfile_in_zip_read_info->stream.total_out;
1401 }
1402
1403
1404 /*
1405 return 1 if the end of file was reached, 0 elsewhere
1406 */
1407 extern int ZEXPORT unzeof (file)
1408 unzFile file;
1409 {
1410 unz_s* s;
1411 file_in_zip_read_info_s* pfile_in_zip_read_info;
1412 if (file==NULL)
1413 return UNZ_PARAMERROR;
1414 s=(unz_s*)file;
1415 pfile_in_zip_read_info=s->pfile_in_zip_read;
1416
1417 if (pfile_in_zip_read_info==NULL)
1418 return UNZ_PARAMERROR;
1419
1420 if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1421 return 1;
1422 else
1423 return 0;
1424 }
1425
1426
1427
1428 /*
1429 Read extra field from the current file (opened by unzOpenCurrentFile)
1430 This is the local-header version of the extra field (sometimes, there is
1431 more info in the local-header version than in the central-header)
1432
1433 if buf==NULL, it return the size of the local extra field that can be read
1434
1435 if buf!=NULL, len is the size of the buffer, the extra header is copied in
1436 buf.
1437 the return value is the number of bytes copied in buf, or (if <0)
1438 the error code
1439 */
1440 extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
1441 unzFile file;
1442 voidp buf;
1443 unsigned len;
1444 {
1445 unz_s* s;
1446 file_in_zip_read_info_s* pfile_in_zip_read_info;
1447 uInt read_now;
1448 uLong size_to_read;
1449
1450 if (file==NULL)
1451 return UNZ_PARAMERROR;
1452 s=(unz_s*)file;
1453 pfile_in_zip_read_info=s->pfile_in_zip_read;
1454
1455 if (pfile_in_zip_read_info==NULL)
1456 return UNZ_PARAMERROR;
1457
1458 size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
1459 pfile_in_zip_read_info->pos_local_extrafield);
1460
1461 if (buf==NULL)
1462 return (int)size_to_read;
1463
1464 if (len>size_to_read)
1465 read_now = (uInt)size_to_read;
1466 else
1467 read_now = (uInt)len ;
1468
1469 if (read_now==0)
1470 return 0;
1471
1472 if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
1473 pfile_in_zip_read_info->filestream,
1474 pfile_in_zip_read_info->offset_local_extrafield +
1475 pfile_in_zip_read_info->pos_local_extrafield,
1476 ZLIB_FILEFUNC_SEEK_SET)!=0)
1477 return UNZ_ERRNO;
1478
1479 if (ZREAD(pfile_in_zip_read_info->z_filefunc,
1480 pfile_in_zip_read_info->filestream,
1481 buf,read_now)!=read_now)
1482 return UNZ_ERRNO;
1483
1484 return (int)read_now;
1485 }
1486
1487 /*
1488 Close the file in zip opened with unzipOpenCurrentFile
1489 Return UNZ_CRCERROR if all the file was read but the CRC is not good
1490 */
1491 extern int ZEXPORT unzCloseCurrentFile (file)
1492 unzFile file;
1493 {
1494 int err=UNZ_OK;
1495
1496 unz_s* s;
1497 file_in_zip_read_info_s* pfile_in_zip_read_info;
1498 if (file==NULL)
1499 return UNZ_PARAMERROR;
1500 s=(unz_s*)file;
1501 pfile_in_zip_read_info=s->pfile_in_zip_read;
1502
1503 if (pfile_in_zip_read_info==NULL)
1504 return UNZ_PARAMERROR;
1505
1506
1507 if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
1508 (!pfile_in_zip_read_info->raw))
1509 {
1510 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
1511 err=UNZ_CRCERROR;
1512 }
1513
1514
1515 TRYFREE(pfile_in_zip_read_info->read_buffer);
1516 pfile_in_zip_read_info->read_buffer = NULL;
1517 if (pfile_in_zip_read_info->stream_initialised)
1518 inflateEnd(&pfile_in_zip_read_info->stream);
1519
1520 pfile_in_zip_read_info->stream_initialised = 0;
1521 TRYFREE(pfile_in_zip_read_info);
1522
1523 s->pfile_in_zip_read=NULL;
1524
1525 return err;
1526 }
1527
1528
1529 /*
1530 Get the global comment string of the ZipFile, in the szComment buffer.
1531 uSizeBuf is the size of the szComment buffer.
1532 return the number of byte copied or an error code <0
1533 */
1534 extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
1535 unzFile file;
1536 char *szComment;
1537 uLong uSizeBuf;
1538 {
1539 int err=UNZ_OK;
1540 unz_s* s;
1541 uLong uReadThis ;
1542 if (file==NULL)
1543 return UNZ_PARAMERROR;
1544 s=(unz_s*)file;
1545
1546 uReadThis = uSizeBuf;
1547 if (uReadThis>s->gi.size_comment)
1548 uReadThis = s->gi.size_comment;
1549
1550 if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
1551 return UNZ_ERRNO;
1552
1553 if (uReadThis>0)
1554 {
1555 *szComment='\0';
1556 if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
1557 return UNZ_ERRNO;
1558 }
1559
1560 if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
1561 *(szComment+s->gi.size_comment)='\0';
1562 return (int)uReadThis;
1563 }
1564
1565 /* Additions by RX '2004 */
1566 extern uLong ZEXPORT unzGetOffset (file)
1567 unzFile file;
1568 {
1569 unz_s* s;
1570
1571 if (file==NULL)
1572 return UNZ_PARAMERROR;
1573 s=(unz_s*)file;
1574 if (!s->current_file_ok)
1575 return 0;
1576 if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
1577 if (s->num_file==s->gi.number_entry)
1578 return 0;
1579 return s->pos_in_central_dir;
1580 }
1581
1582 extern int ZEXPORT unzSetOffset (file, pos)
1583 unzFile file;
1584 uLong pos;
1585 {
1586 unz_s* s;
1587 int err;
1588
1589 if (file==NULL)
1590 return UNZ_PARAMERROR;
1591 s=(unz_s*)file;
1592
1593 s->pos_in_central_dir = pos;
1594 s->num_file = s->gi.number_entry; /* hack */
1595 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1596 &s->cur_file_info_internal,
1597 NULL,0,NULL,0,NULL,0);
1598 s->current_file_ok = (err == UNZ_OK);
1599 return err;
1600 }
NetBSD on the FriendlyARM MINI2440