1
/* unzip.c -- IO on .zip files using zlib
2
Version 0.15 beta, Mar 19th, 1998,
4
Read unzip.h for more info
29
/* compile with -Dlocal if your debugger can't find static symbols */
33
#if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \
34
!defined(CASESENSITIVITYDEFAULT_NO)
35
#define CASESENSITIVITYDEFAULT_NO
40
#define UNZ_BUFSIZE (16384)
43
#ifndef UNZ_MAXFILENAMEINZIP
44
#define UNZ_MAXFILENAMEINZIP (256)
48
# define ALLOC(size) (malloc(size))
51
# define TRYFREE(p) {if (p) free(p);}
54
#define SIZECENTRALDIRITEM (0x2e)
55
#define SIZEZIPLOCALHEADER (0x1e)
58
/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
72
const char unz_copyright[] =
73
" unzip 0.15 Copyright 1998 Gilles Vollant ";
75
/* unz_file_info_interntal contain internal info about a file in zipfile*/
76
typedef struct unz_file_info_internal_s
78
uLong offset_curfile;/* relative offset of local header 4 bytes */
79
} unz_file_info_internal;
82
/* file_in_zip_read_info_s contain internal information about a file in zipfile,
83
when reading and decompress it */
86
char *read_buffer; /* internal buffer for compressed data */
87
z_stream stream; /* zLib stream structure for inflate */
89
uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/
90
uLong stream_initialised; /* flag set if stream structure is initialised*/
92
uLong offset_local_extrafield;/* offset of the local extra field */
93
uInt size_local_extrafield;/* size of the local extra field */
94
uLong pos_local_extrafield; /* position in the local extra field in read*/
96
uLong crc32; /* crc32 of all data uncompressed */
97
uLong crc32_wait; /* crc32 we must obtain after decompress all */
98
uLong rest_read_compressed; /* number of byte to be decompressed */
99
uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
100
FILE* file; /* io structore of the zipfile */
101
uLong compression_method; /* compression method (0==store) */
102
uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
103
} file_in_zip_read_info_s;
106
/* unz_s contain internal information about the zipfile
110
FILE* file; /* io structore of the zipfile */
111
unz_global_info gi; /* public global information */
112
uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
113
uLong num_file; /* number of the current file in the zipfile*/
114
uLong pos_in_central_dir; /* pos of the current file in the central dir*/
115
uLong current_file_ok; /* flag about the usability of the current file*/
116
uLong central_pos; /* position of the beginning of the central dir*/
118
uLong size_central_dir; /* size of the central directory */
119
uLong offset_central_dir; /* offset of start of central directory with
120
respect to the starting disk number */
122
unz_file_info cur_file_info; /* public info about the current file in zip*/
123
unz_file_info_internal cur_file_info_internal; /* private info about it*/
124
file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
125
file if we are decompressing it */
129
/* ===========================================================================
130
Read a byte from a gz_stream; update next_in and avail_in. Return EOF
132
IN assertion: the stream s has been sucessfully opened for reading.
136
local int unzlocal_getByte(fin,pi)
141
int err = fread(&c, 1, 1, fin);
157
/* ===========================================================================
158
Reads a long in LSB order from the given gz_stream. Sets
160
local int unzlocal_getShort (fin,pX)
168
err = unzlocal_getByte(fin,&i);
172
err = unzlocal_getByte(fin,&i);
182
local int unzlocal_getLong (fin,pX)
190
err = unzlocal_getByte(fin,&i);
194
err = unzlocal_getByte(fin,&i);
198
err = unzlocal_getByte(fin,&i);
202
err = unzlocal_getByte(fin,&i);
213
/* My own strcmpi / strcasecmp */
214
local int strcmpcasenosensitive_internal (fileName1,fileName2)
215
const char* fileName1;
216
const char* fileName2;
220
char c1=*(fileName1++);
221
char c2=*(fileName2++);
222
if ((c1>='a') && (c1<='z'))
224
if ((c2>='a') && (c2<='z'))
227
return ((c2=='\0') ? 0 : -1);
238
#ifdef CASESENSITIVITYDEFAULT_NO
239
#define CASESENSITIVITYDEFAULTVALUE 2
241
#define CASESENSITIVITYDEFAULTVALUE 1
244
#ifndef STRCMPCASENOSENTIVEFUNCTION
245
#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
249
Compare two filename (fileName1,fileName2).
250
If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
251
If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
253
If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
254
(like 1 on Unix, 2 on Windows)
257
extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
258
const char* fileName1;
259
const char* fileName2;
260
int iCaseSensitivity;
262
if (iCaseSensitivity==0)
263
iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
265
if (iCaseSensitivity==1)
266
return strcmp(fileName1,fileName2);
268
return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
271
#define BUFREADCOMMENT (0x400)
274
Locate the Central directory of a zipfile (at the end, just before
277
local uLong unzlocal_SearchCentralDir(fin)
283
uLong uMaxBack=0xffff; /* maximum size of global comment */
286
if (fseek(fin,0,SEEK_END) != 0)
290
uSizeFile = ftell( fin );
292
if (uMaxBack>uSizeFile)
293
uMaxBack = uSizeFile;
295
buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
300
while (uBackRead<uMaxBack)
302
uLong uReadSize,uReadPos ;
304
if (uBackRead+BUFREADCOMMENT>uMaxBack)
305
uBackRead = uMaxBack;
307
uBackRead+=BUFREADCOMMENT;
308
uReadPos = uSizeFile-uBackRead ;
310
uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
311
(BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
312
if (fseek(fin,uReadPos,SEEK_SET)!=0)
315
if (fread(buf,(uInt)uReadSize,1,fin)!=1)
318
for (i=(int)uReadSize-3; (i--)>0;)
319
if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
320
((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
322
uPosFound = uReadPos+i;
334
Open a Zip file. path contain the full pathname (by example,
335
on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer
337
If the zipfile cannot be opened (file don't exist or in not valid), the
338
return value is NULL.
339
Else, the return value is a unzFile Handle, usable with other function
340
of this unzip package.
342
extern unzFile ZEXPORT unzOpen (path)
347
uLong central_pos,uL;
350
uLong number_disk; /* number of the current dist, used for
351
spaning ZIP, unsupported, always 0*/
352
uLong number_disk_with_CD; /* number the the disk with central dir, used
353
for spaning ZIP, unsupported, always 0*/
354
uLong number_entry_CD; /* total number of entries in
356
(same than number_entry on nospan) */
360
if (unz_copyright[0]!=' ')
363
fin=fopen(path,"rb");
367
central_pos = unzlocal_SearchCentralDir(fin);
371
if (fseek(fin,central_pos,SEEK_SET)!=0)
374
/* the signature, already checked */
375
if (unzlocal_getLong(fin,&uL)!=UNZ_OK)
378
/* number of this disk */
379
if (unzlocal_getShort(fin,&number_disk)!=UNZ_OK)
382
/* number of the disk with the start of the central directory */
383
if (unzlocal_getShort(fin,&number_disk_with_CD)!=UNZ_OK)
386
/* total number of entries in the central dir on this disk */
387
if (unzlocal_getShort(fin,&us.gi.number_entry)!=UNZ_OK)
390
/* total number of entries in the central dir */
391
if (unzlocal_getShort(fin,&number_entry_CD)!=UNZ_OK)
394
if ((number_entry_CD!=us.gi.number_entry) ||
395
(number_disk_with_CD!=0) ||
399
/* size of the central directory */
400
if (unzlocal_getLong(fin,&us.size_central_dir)!=UNZ_OK)
403
/* offset of start of central directory with respect to the
404
starting disk number */
405
if (unzlocal_getLong(fin,&us.offset_central_dir)!=UNZ_OK)
408
/* zipfile comment length */
409
if (unzlocal_getShort(fin,&us.gi.size_comment)!=UNZ_OK)
412
if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
423
us.byte_before_the_zipfile = central_pos -
424
(us.offset_central_dir+us.size_central_dir);
425
us.central_pos = central_pos;
426
us.pfile_in_zip_read = NULL;
429
s=(unz_s*)ALLOC(sizeof(unz_s));
431
unzGoToFirstFile((unzFile)s);
437
Close a ZipFile opened with unzipOpen.
438
If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
439
these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
440
return UNZ_OK if there is no problem. */
441
extern int ZEXPORT unzClose (file)
446
return UNZ_PARAMERROR;
449
if (s->pfile_in_zip_read!=NULL)
450
unzCloseCurrentFile(file);
459
Write info about the ZipFile in the *pglobal_info structure.
460
No preparation of the structure is needed
461
return UNZ_OK if there is no problem. */
462
extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
464
unz_global_info *pglobal_info;
468
return UNZ_PARAMERROR;
476
Translate date/time from Dos format to tm_unz (readable more easilty)
478
local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
483
uDate = (uLong)(ulDosDate>>16);
484
ptm->tm_mday = (uInt)(uDate&0x1f) ;
485
ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ;
486
ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
488
ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
489
ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;
490
ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;
494
Get Info about the current file in the zipfile, with internal only info
496
local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
497
unz_file_info *pfile_info,
498
unz_file_info_internal
499
*pfile_info_internal,
501
uLong fileNameBufferSize,
503
uLong extraFieldBufferSize,
505
uLong commentBufferSize));
507
local int unzlocal_GetCurrentFileInfoInternal (file,
510
szFileName, fileNameBufferSize,
511
extraField, extraFieldBufferSize,
512
szComment, commentBufferSize)
514
unz_file_info *pfile_info;
515
unz_file_info_internal *pfile_info_internal;
517
uLong fileNameBufferSize;
519
uLong extraFieldBufferSize;
521
uLong commentBufferSize;
524
unz_file_info file_info;
525
unz_file_info_internal file_info_internal;
531
return UNZ_PARAMERROR;
533
if (fseek(s->file,s->pos_in_central_dir+s->byte_before_the_zipfile,SEEK_SET)!=0)
537
/* we check the magic */
539
if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
541
else if (uMagic!=0x02014b50)
545
if (unzlocal_getShort(s->file,&file_info.version) != UNZ_OK)
548
if (unzlocal_getShort(s->file,&file_info.version_needed) != UNZ_OK)
551
if (unzlocal_getShort(s->file,&file_info.flag) != UNZ_OK)
554
if (unzlocal_getShort(s->file,&file_info.compression_method) != UNZ_OK)
557
if (unzlocal_getLong(s->file,&file_info.dosDate) != UNZ_OK)
560
unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
562
if (unzlocal_getLong(s->file,&file_info.crc) != UNZ_OK)
565
if (unzlocal_getLong(s->file,&file_info.compressed_size) != UNZ_OK)
568
if (unzlocal_getLong(s->file,&file_info.uncompressed_size) != UNZ_OK)
571
if (unzlocal_getShort(s->file,&file_info.size_filename) != UNZ_OK)
574
if (unzlocal_getShort(s->file,&file_info.size_file_extra) != UNZ_OK)
577
if (unzlocal_getShort(s->file,&file_info.size_file_comment) != UNZ_OK)
580
if (unzlocal_getShort(s->file,&file_info.disk_num_start) != UNZ_OK)
583
if (unzlocal_getShort(s->file,&file_info.internal_fa) != UNZ_OK)
586
if (unzlocal_getLong(s->file,&file_info.external_fa) != UNZ_OK)
589
if (unzlocal_getLong(s->file,&file_info_internal.offset_curfile) != UNZ_OK)
592
lSeek+=file_info.size_filename;
593
if ((err==UNZ_OK) && (szFileName!=NULL))
596
if (file_info.size_filename<fileNameBufferSize)
598
*(szFileName+file_info.size_filename)='\0';
599
uSizeRead = file_info.size_filename;
602
uSizeRead = fileNameBufferSize;
604
if ((file_info.size_filename>0) && (fileNameBufferSize>0))
605
if (fread(szFileName,(uInt)uSizeRead,1,s->file)!=1)
611
if ((err==UNZ_OK) && (extraField!=NULL))
614
if (file_info.size_file_extra<extraFieldBufferSize)
615
uSizeRead = file_info.size_file_extra;
617
uSizeRead = extraFieldBufferSize;
620
if (fseek(s->file,lSeek,SEEK_CUR)==0)
626
if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
627
if (fread(extraField,(uInt)uSizeRead,1,s->file)!=1)
629
lSeek += file_info.size_file_extra - uSizeRead;
632
lSeek+=file_info.size_file_extra;
635
if ((err==UNZ_OK) && (szComment!=NULL))
638
if (file_info.size_file_comment<commentBufferSize)
640
*(szComment+file_info.size_file_comment)='\0';
641
uSizeRead = file_info.size_file_comment;
644
uSizeRead = commentBufferSize;
647
if (fseek(s->file,lSeek,SEEK_CUR)==0)
652
if ((file_info.size_file_comment>0) && (commentBufferSize>0))
653
if (fread(szComment,(uInt)uSizeRead,1,s->file)!=1)
655
lSeek+=file_info.size_file_comment - uSizeRead;
658
lSeek+=file_info.size_file_comment;
660
if ((err==UNZ_OK) && (pfile_info!=NULL))
661
*pfile_info=file_info;
663
if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
664
*pfile_info_internal=file_info_internal;
672
Write info about the ZipFile in the *pglobal_info structure.
673
No preparation of the structure is needed
674
return UNZ_OK if there is no problem.
676
extern int ZEXPORT unzGetCurrentFileInfo (file,
678
szFileName, fileNameBufferSize,
679
extraField, extraFieldBufferSize,
680
szComment, commentBufferSize)
682
unz_file_info *pfile_info;
684
uLong fileNameBufferSize;
686
uLong extraFieldBufferSize;
688
uLong commentBufferSize;
690
return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
691
szFileName,fileNameBufferSize,
692
extraField,extraFieldBufferSize,
693
szComment,commentBufferSize);
697
Set the current file of the zipfile to the first file.
698
return UNZ_OK if there is no problem
700
extern int ZEXPORT unzGoToFirstFile (file)
706
return UNZ_PARAMERROR;
708
s->pos_in_central_dir=s->offset_central_dir;
710
err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
711
&s->cur_file_info_internal,
712
NULL,0,NULL,0,NULL,0);
713
s->current_file_ok = (err == UNZ_OK);
719
Set the current file of the zipfile to the next file.
720
return UNZ_OK if there is no problem
721
return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
723
extern int ZEXPORT unzGoToNextFile (file)
730
return UNZ_PARAMERROR;
732
if (!s->current_file_ok)
733
return UNZ_END_OF_LIST_OF_FILE;
734
if (s->num_file+1==s->gi.number_entry)
735
return UNZ_END_OF_LIST_OF_FILE;
737
s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
738
s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
740
err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
741
&s->cur_file_info_internal,
742
NULL,0,NULL,0,NULL,0);
743
s->current_file_ok = (err == UNZ_OK);
749
Try locate the file szFileName in the zipfile.
750
For the iCaseSensitivity signification, see unzipStringFileNameCompare
753
UNZ_OK if the file is found. It becomes the current file.
754
UNZ_END_OF_LIST_OF_FILE if the file is not found
756
extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
758
const char *szFileName;
759
int iCaseSensitivity;
766
uLong pos_in_central_dirSaved;
770
return UNZ_PARAMERROR;
772
if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
773
return UNZ_PARAMERROR;
776
if (!s->current_file_ok)
777
return UNZ_END_OF_LIST_OF_FILE;
779
num_fileSaved = s->num_file;
780
pos_in_central_dirSaved = s->pos_in_central_dir;
782
err = unzGoToFirstFile(file);
784
while (err == UNZ_OK)
786
char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
787
unzGetCurrentFileInfo(file,NULL,
788
szCurrentFileName,sizeof(szCurrentFileName)-1,
790
if (unzStringFileNameCompare(szCurrentFileName,
791
szFileName,iCaseSensitivity)==0)
793
err = unzGoToNextFile(file);
796
s->num_file = num_fileSaved ;
797
s->pos_in_central_dir = pos_in_central_dirSaved ;
803
Read the local header of the current zipfile
804
Check the coherency of the local header and info in the end of central
805
directory about this file
806
store in *piSizeVar the size of extra info in local header
807
(filename and size of extra field data)
809
local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
810
poffset_local_extrafield,
811
psize_local_extrafield)
814
uLong *poffset_local_extrafield;
815
uInt *psize_local_extrafield;
817
uLong uMagic,uData,uFlags;
819
uLong size_extra_field;
823
*poffset_local_extrafield = 0;
824
*psize_local_extrafield = 0;
826
if (fseek(s->file,s->cur_file_info_internal.offset_curfile +
827
s->byte_before_the_zipfile,SEEK_SET)!=0)
832
if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
834
else if (uMagic!=0x04034b50)
838
if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
841
else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
844
if (unzlocal_getShort(s->file,&uFlags) != UNZ_OK)
847
if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
849
else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
852
if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
853
(s->cur_file_info.compression_method!=Z_DEFLATED))
856
if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* date/time */
859
if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* crc */
861
else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
865
if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size compr */
867
else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
871
if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size uncompr */
873
else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
878
if (unzlocal_getShort(s->file,&size_filename) != UNZ_OK)
880
else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
883
*piSizeVar += (uInt)size_filename;
885
if (unzlocal_getShort(s->file,&size_extra_field) != UNZ_OK)
887
*poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
888
SIZEZIPLOCALHEADER + size_filename;
889
*psize_local_extrafield = (uInt)size_extra_field;
891
*piSizeVar += (uInt)size_extra_field;
897
Open for reading data the current file in the zipfile.
898
If there is no error and the file is opened, the return value is UNZ_OK.
900
extern int ZEXPORT unzOpenCurrentFile (file)
907
file_in_zip_read_info_s* pfile_in_zip_read_info;
908
uLong offset_local_extrafield; /* offset of the local extra field */
909
uInt size_local_extrafield; /* size of the local extra field */
912
return UNZ_PARAMERROR;
914
if (!s->current_file_ok)
915
return UNZ_PARAMERROR;
917
if (s->pfile_in_zip_read != NULL)
918
unzCloseCurrentFile(file);
920
if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
921
&offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
922
return UNZ_BADZIPFILE;
924
pfile_in_zip_read_info = (file_in_zip_read_info_s*)
925
ALLOC(sizeof(file_in_zip_read_info_s));
926
if (pfile_in_zip_read_info==NULL)
927
return UNZ_INTERNALERROR;
929
pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
930
pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
931
pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
932
pfile_in_zip_read_info->pos_local_extrafield=0;
934
if (pfile_in_zip_read_info->read_buffer==NULL)
936
TRYFREE(pfile_in_zip_read_info);
937
return UNZ_INTERNALERROR;
940
pfile_in_zip_read_info->stream_initialised=0;
942
if ((s->cur_file_info.compression_method!=0) &&
943
(s->cur_file_info.compression_method!=Z_DEFLATED))
945
Store = s->cur_file_info.compression_method==0;
947
pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
948
pfile_in_zip_read_info->crc32=0;
949
pfile_in_zip_read_info->compression_method =
950
s->cur_file_info.compression_method;
951
pfile_in_zip_read_info->file=s->file;
952
pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
954
pfile_in_zip_read_info->stream.total_out = 0;
958
pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
959
pfile_in_zip_read_info->stream.zfree = (free_func)0;
960
pfile_in_zip_read_info->stream.opaque = (voidpf)0;
962
err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
964
pfile_in_zip_read_info->stream_initialised=1;
965
/* windowBits is passed < 0 to tell that there is no zlib header.
966
* Note that in this case inflate *requires* an extra "dummy" byte
967
* after the compressed stream in order to complete decompression and
968
* return Z_STREAM_END.
969
* In unzip, i don't wait absolutely Z_STREAM_END because I known the
970
* size of both compressed and uncompressed data
973
pfile_in_zip_read_info->rest_read_compressed =
974
s->cur_file_info.compressed_size ;
975
pfile_in_zip_read_info->rest_read_uncompressed =
976
s->cur_file_info.uncompressed_size ;
979
pfile_in_zip_read_info->pos_in_zipfile =
980
s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
983
pfile_in_zip_read_info->stream.avail_in = (uInt)0;
986
s->pfile_in_zip_read = pfile_in_zip_read_info;
992
Read bytes from the current file.
993
buf contain buffer where data must be copied
996
return the number of byte copied if somes bytes are copied
997
return 0 if the end of file was reached
998
return <0 with error code if there is an error
999
(UNZ_ERRNO for IO error, or zLib error for uncompress error)
1001
extern int ZEXPORT unzReadCurrentFile (file, buf, len)
1009
file_in_zip_read_info_s* pfile_in_zip_read_info;
1011
return UNZ_PARAMERROR;
1013
pfile_in_zip_read_info=s->pfile_in_zip_read;
1015
if (pfile_in_zip_read_info==NULL)
1016
return UNZ_PARAMERROR;
1019
if ((pfile_in_zip_read_info->read_buffer == NULL))
1020
return UNZ_END_OF_LIST_OF_FILE;
1024
pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
1026
pfile_in_zip_read_info->stream.avail_out = (uInt)len;
1028
if (len>pfile_in_zip_read_info->rest_read_uncompressed)
1029
pfile_in_zip_read_info->stream.avail_out =
1030
(uInt)pfile_in_zip_read_info->rest_read_uncompressed;
1032
while (pfile_in_zip_read_info->stream.avail_out>0)
1034
if ((pfile_in_zip_read_info->stream.avail_in==0) &&
1035
(pfile_in_zip_read_info->rest_read_compressed>0))
1037
uInt uReadThis = UNZ_BUFSIZE;
1038
if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
1039
uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
1042
if (fseek(pfile_in_zip_read_info->file,
1043
pfile_in_zip_read_info->pos_in_zipfile +
1044
pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET)!=0)
1046
if (fread(pfile_in_zip_read_info->read_buffer,uReadThis,1,
1047
pfile_in_zip_read_info->file)!=1)
1049
pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1051
pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
1053
pfile_in_zip_read_info->stream.next_in =
1054
(Bytef*)pfile_in_zip_read_info->read_buffer;
1055
pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
1058
if (pfile_in_zip_read_info->compression_method==0)
1061
if (pfile_in_zip_read_info->stream.avail_out <
1062
pfile_in_zip_read_info->stream.avail_in)
1063
uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
1065
uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
1067
for (i=0;i<uDoCopy;i++)
1068
*(pfile_in_zip_read_info->stream.next_out+i) =
1069
*(pfile_in_zip_read_info->stream.next_in+i);
1071
pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
1072
pfile_in_zip_read_info->stream.next_out,
1074
pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
1075
pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1076
pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1077
pfile_in_zip_read_info->stream.next_out += uDoCopy;
1078
pfile_in_zip_read_info->stream.next_in += uDoCopy;
1079
pfile_in_zip_read_info->stream.total_out += uDoCopy;
1084
uLong uTotalOutBefore,uTotalOutAfter;
1085
const Bytef *bufBefore;
1087
int flush=Z_SYNC_FLUSH;
1089
uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
1090
bufBefore = pfile_in_zip_read_info->stream.next_out;
1093
if ((pfile_in_zip_read_info->rest_read_uncompressed ==
1094
pfile_in_zip_read_info->stream.avail_out) &&
1095
(pfile_in_zip_read_info->rest_read_compressed == 0))
1098
err=inflate(&pfile_in_zip_read_info->stream,flush);
1100
uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
1101
uOutThis = uTotalOutAfter-uTotalOutBefore;
1103
pfile_in_zip_read_info->crc32 =
1104
crc32(pfile_in_zip_read_info->crc32,bufBefore,
1107
pfile_in_zip_read_info->rest_read_uncompressed -=
1110
iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1112
if (err==Z_STREAM_END)
1113
return (iRead==0) ? UNZ_EOF : iRead;
1126
Give the current position in uncompressed data
1128
extern z_off_t ZEXPORT unztell (file)
1132
file_in_zip_read_info_s* pfile_in_zip_read_info;
1134
return UNZ_PARAMERROR;
1136
pfile_in_zip_read_info=s->pfile_in_zip_read;
1138
if (pfile_in_zip_read_info==NULL)
1139
return UNZ_PARAMERROR;
1141
return (z_off_t)pfile_in_zip_read_info->stream.total_out;
1146
return 1 if the end of file was reached, 0 elsewhere
1148
extern int ZEXPORT unzeof (file)
1152
file_in_zip_read_info_s* pfile_in_zip_read_info;
1154
return UNZ_PARAMERROR;
1156
pfile_in_zip_read_info=s->pfile_in_zip_read;
1158
if (pfile_in_zip_read_info==NULL)
1159
return UNZ_PARAMERROR;
1161
if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1170
Read extra field from the current file (opened by unzOpenCurrentFile)
1171
This is the local-header version of the extra field (sometimes, there is
1172
more info in the local-header version than in the central-header)
1174
if buf==NULL, it return the size of the local extra field that can be read
1176
if buf!=NULL, len is the size of the buffer, the extra header is copied in
1178
the return value is the number of bytes copied in buf, or (if <0)
1181
extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
1187
file_in_zip_read_info_s* pfile_in_zip_read_info;
1192
return UNZ_PARAMERROR;
1194
pfile_in_zip_read_info=s->pfile_in_zip_read;
1196
if (pfile_in_zip_read_info==NULL)
1197
return UNZ_PARAMERROR;
1199
size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
1200
pfile_in_zip_read_info->pos_local_extrafield);
1203
return (int)size_to_read;
1205
if (len>size_to_read)
1206
read_now = (uInt)size_to_read;
1208
read_now = (uInt)len ;
1213
if (fseek(pfile_in_zip_read_info->file,
1214
pfile_in_zip_read_info->offset_local_extrafield +
1215
pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0)
1218
if (fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1)
1221
return (int)read_now;
1225
Close the file in zip opened with unzipOpenCurrentFile
1226
Return UNZ_CRCERROR if all the file was read but the CRC is not good
1228
extern int ZEXPORT unzCloseCurrentFile (file)
1234
file_in_zip_read_info_s* pfile_in_zip_read_info;
1236
return UNZ_PARAMERROR;
1238
pfile_in_zip_read_info=s->pfile_in_zip_read;
1240
if (pfile_in_zip_read_info==NULL)
1241
return UNZ_PARAMERROR;
1244
if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1246
if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
1251
TRYFREE(pfile_in_zip_read_info->read_buffer);
1252
pfile_in_zip_read_info->read_buffer = NULL;
1253
if (pfile_in_zip_read_info->stream_initialised)
1254
inflateEnd(&pfile_in_zip_read_info->stream);
1256
pfile_in_zip_read_info->stream_initialised = 0;
1257
TRYFREE(pfile_in_zip_read_info);
1259
s->pfile_in_zip_read=NULL;
1266
Get the global comment string of the ZipFile, in the szComment buffer.
1267
uSizeBuf is the size of the szComment buffer.
1268
return the number of byte copied or an error code <0
1270
extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
1279
return UNZ_PARAMERROR;
1282
uReadThis = uSizeBuf;
1283
if (uReadThis>s->gi.size_comment)
1284
uReadThis = s->gi.size_comment;
1286
if (fseek(s->file,s->central_pos+22,SEEK_SET)!=0)
1292
if (fread(szComment,(uInt)uReadThis,1,s->file)!=1)
1296
if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
1297
*(szComment+s->gi.size_comment)='\0';
1298
return (int)uReadThis;
added
removed
cutestuff/zip/minizip/unzip.c
