Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

unzip.c @ 15211

Visit:

Revision 15211, 33.7 KB checked in by ghudson, 24 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r15210, which included commits to RCS files with non-trunk default branches.

Rev	Line
[15210]	1	/* unzip.c -- IO on .zip files using zlib
	2	Version 0.15 beta, Mar 19th, 1998,
	3
	4	Read unzip.h for more info
	5	*/
	6
	7
	8	#include <stdio.h>
	9	#include <stdlib.h>
	10	#include <string.h>
	11	#include "zlib.h"
	12	#include "unzip.h"
	13
	14	#ifdef STDC
	15	# include <stddef.h>
	16	# include <string.h>
	17	# include <stdlib.h>
	18	#endif
	19	#ifdef NO_ERRNO_H
	20	extern int errno;
	21	#else
	22	# include <errno.h>
	23	#endif
	24
	25
	26	#ifndef local
	27	# define local static
	28	#endif
	29	/* compile with -Dlocal if your debugger can't find static symbols */
	30
	31
	32
	33	#if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \
	34	!defined(CASESENSITIVITYDEFAULT_NO)
	35	#define CASESENSITIVITYDEFAULT_NO
	36	#endif
	37
	38
	39	#ifndef UNZ_BUFSIZE
	40	#define UNZ_BUFSIZE (16384)
	41	#endif
	42
	43	#ifndef UNZ_MAXFILENAMEINZIP
	44	#define UNZ_MAXFILENAMEINZIP (256)
	45	#endif
	46
	47	#ifndef ALLOC
	48	# define ALLOC(size) (malloc(size))
	49	#endif
	50	#ifndef TRYFREE
	51	# define TRYFREE(p) {if (p) free(p);}
	52	#endif
	53
	54	#define SIZECENTRALDIRITEM (0x2e)
	55	#define SIZEZIPLOCALHEADER (0x1e)
	56
	57
	58	/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
	59
	60	#ifndef SEEK_CUR
	61	#define SEEK_CUR 1
	62	#endif
	63
	64	#ifndef SEEK_END
	65	#define SEEK_END 2
	66	#endif
	67
	68	#ifndef SEEK_SET
	69	#define SEEK_SET 0
	70	#endif
	71
	72	const char unz_copyright[] =
	73	" unzip 0.15 Copyright 1998 Gilles Vollant ";
	74
	75	/* unz_file_info_interntal contain internal info about a file in zipfile*/
	76	typedef struct unz_file_info_internal_s
	77	{
	78	uLong offset_curfile;/* relative offset of local header 4 bytes */
	79	} unz_file_info_internal;
	80
	81
	82	/* file_in_zip_read_info_s contain internal information about a file in zipfile,
	83	when reading and decompress it */
	84	typedef struct
	85	{
	86	char read_buffer; / internal buffer for compressed data */
	87	z_stream stream; /* zLib stream structure for inflate */
	88
	89	uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/
	90	uLong stream_initialised; /* flag set if stream structure is initialised*/
	91
	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*/
	95
	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;
	104
	105
	106	/* unz_s contain internal information about the zipfile
	107	*/
	108	typedef struct
	109	{
	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*/
	117
	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 */
	121
	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 */
	126	} unz_s;
	127
	128
	129	/* ===========================================================================
	130	Read a byte from a gz_stream; update next_in and avail_in. Return EOF
	131	for end of file.
	132	IN assertion: the stream s has been sucessfully opened for reading.
	133	*/
	134
	135
	136	local int unzlocal_getByte(fin,pi)
	137	FILE *fin;
	138	int *pi;
	139	{
	140	unsigned char c;
	141	int err = fread(&c, 1, 1, fin);
	142	if (err==1)
	143	{
	144	*pi = (int)c;
	145	return UNZ_OK;
	146	}
	147	else
	148	{
	149	if (ferror(fin))
	150	return UNZ_ERRNO;
	151	else
	152	return UNZ_EOF;
	153	}
	154	}
	155
	156
	157	/* ===========================================================================
	158	Reads a long in LSB order from the given gz_stream. Sets
	159	*/
	160	local int unzlocal_getShort (fin,pX)
	161	FILE* fin;
	162	uLong *pX;
	163	{
	164	uLong x ;
	165	int i;
	166	int err;
	167
	168	err = unzlocal_getByte(fin,&i);
	169	x = (uLong)i;
	170
	171	if (err==UNZ_OK)
	172	err = unzlocal_getByte(fin,&i);
	173	x += ((uLong)i)<<8;
	174
	175	if (err==UNZ_OK)
	176	*pX = x;
	177	else
	178	*pX = 0;
	179	return err;
	180	}
	181
	182	local int unzlocal_getLong (fin,pX)
	183	FILE* fin;
	184	uLong *pX;
	185	{
	186	uLong x ;
	187	int i;
	188	int err;
	189
	190	err = unzlocal_getByte(fin,&i);
	191	x = (uLong)i;
	192
	193	if (err==UNZ_OK)
	194	err = unzlocal_getByte(fin,&i);
	195	x += ((uLong)i)<<8;
	196
	197	if (err==UNZ_OK)
	198	err = unzlocal_getByte(fin,&i);
	199	x += ((uLong)i)<<16;
	200
	201	if (err==UNZ_OK)
	202	err = unzlocal_getByte(fin,&i);
	203	x += ((uLong)i)<<24;
	204
	205	if (err==UNZ_OK)
	206	*pX = x;
	207	else
	208	*pX = 0;
	209	return err;
	210	}
	211
	212
	213	/* My own strcmpi / strcasecmp */
	214	local int strcmpcasenosensitive_internal (fileName1,fileName2)
	215	const char* fileName1;
	216	const char* fileName2;
	217	{
	218	for (;;)
	219	{
	220	char c1=*(fileName1++);
	221	char c2=*(fileName2++);
	222	if ((c1>='a') && (c1<='z'))
	223	c1 -= 0x20;
	224	if ((c2>='a') && (c2<='z'))
	225	c2 -= 0x20;
	226	if (c1=='\0')
	227	return ((c2=='\0') ? 0 : -1);
	228	if (c2=='\0')
	229	return 1;
	230	if (c1<c2)
	231	return -1;
	232	if (c1>c2)
	233	return 1;
	234	}
	235	}
	236
	237
	238	#ifdef CASESENSITIVITYDEFAULT_NO
	239	#define CASESENSITIVITYDEFAULTVALUE 2
	240	#else
	241	#define CASESENSITIVITYDEFAULTVALUE 1
	242	#endif
	243
	244	#ifndef STRCMPCASENOSENTIVEFUNCTION
	245	#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
	246	#endif
	247
	248	/*
	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
	252	or strcasecmp)
	253	If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
	254	(like 1 on Unix, 2 on Windows)
	255
	256	*/
	257	extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
	258	const char* fileName1;
	259	const char* fileName2;
	260	int iCaseSensitivity;
	261	{
	262	if (iCaseSensitivity==0)
	263	iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
	264
	265	if (iCaseSensitivity==1)
	266	return strcmp(fileName1,fileName2);
	267
	268	return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
	269	}
	270
	271	#define BUFREADCOMMENT (0x400)
	272
	273	/*
	274	Locate the Central directory of a zipfile (at the end, just before
	275	the global comment)
	276	*/
	277	local uLong unzlocal_SearchCentralDir(fin)
	278	FILE *fin;
	279	{
	280	unsigned char* buf;
	281	uLong uSizeFile;
	282	uLong uBackRead;
	283	uLong uMaxBack=0xffff; /* maximum size of global comment */
	284	uLong uPosFound=0;
	285
	286	if (fseek(fin,0,SEEK_END) != 0)
	287	return 0;
	288
	289
	290	uSizeFile = ftell( fin );
	291
	292	if (uMaxBack>uSizeFile)
	293	uMaxBack = uSizeFile;
	294
	295	buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
	296	if (buf==NULL)
	297	return 0;
	298
	299	uBackRead = 4;
	300	while (uBackRead<uMaxBack)
	301	{
	302	uLong uReadSize,uReadPos ;
	303	int i;
	304	if (uBackRead+BUFREADCOMMENT>uMaxBack)
	305	uBackRead = uMaxBack;
	306	else
	307	uBackRead+=BUFREADCOMMENT;
	308	uReadPos = uSizeFile-uBackRead ;
	309
	310	uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
	311	(BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
	312	if (fseek(fin,uReadPos,SEEK_SET)!=0)
	313	break;
	314
	315	if (fread(buf,(uInt)uReadSize,1,fin)!=1)
	316	break;
	317
	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))
	321	{
	322	uPosFound = uReadPos+i;
	323	break;
	324	}
	325
	326	if (uPosFound!=0)
	327	break;
	328	}
	329	TRYFREE(buf);
	330	return uPosFound;
	331	}
	332
	333	/*
	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
	336	"zlib/zlib109.zip".
	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.
	341	*/
	342	extern unzFile ZEXPORT unzOpen (path)
	343	const char *path;
	344	{
	345	unz_s us;
	346	unz_s *s;
	347	uLong central_pos,uL;
	348	FILE * fin ;
	349
	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
	355	the central dir
	356	(same than number_entry on nospan) */
	357
	358	int err=UNZ_OK;
	359
	360	if (unz_copyright[0]!=' ')
	361	return NULL;
	362
	363	fin=fopen(path,"rb");
	364	if (fin==NULL)
	365	return NULL;
	366
	367	central_pos = unzlocal_SearchCentralDir(fin);
	368	if (central_pos==0)
	369	err=UNZ_ERRNO;
	370
	371	if (fseek(fin,central_pos,SEEK_SET)!=0)
	372	err=UNZ_ERRNO;
	373
	374	/* the signature, already checked */
	375	if (unzlocal_getLong(fin,&uL)!=UNZ_OK)
	376	err=UNZ_ERRNO;
	377
	378	/* number of this disk */
	379	if (unzlocal_getShort(fin,&number_disk)!=UNZ_OK)
	380	err=UNZ_ERRNO;
	381
	382	/* number of the disk with the start of the central directory */
	383	if (unzlocal_getShort(fin,&number_disk_with_CD)!=UNZ_OK)
	384	err=UNZ_ERRNO;
	385
	386	/* total number of entries in the central dir on this disk */
	387	if (unzlocal_getShort(fin,&us.gi.number_entry)!=UNZ_OK)
	388	err=UNZ_ERRNO;
	389
	390	/* total number of entries in the central dir */
	391	if (unzlocal_getShort(fin,&number_entry_CD)!=UNZ_OK)
	392	err=UNZ_ERRNO;
	393
	394	if ((number_entry_CD!=us.gi.number_entry) \|\|
	395	(number_disk_with_CD!=0) \|\|
	396	(number_disk!=0))
	397	err=UNZ_BADZIPFILE;
	398
	399	/* size of the central directory */
	400	if (unzlocal_getLong(fin,&us.size_central_dir)!=UNZ_OK)
	401	err=UNZ_ERRNO;
	402
	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)
	406	err=UNZ_ERRNO;
	407
	408	/* zipfile comment length */
	409	if (unzlocal_getShort(fin,&us.gi.size_comment)!=UNZ_OK)
	410	err=UNZ_ERRNO;
	411
	412	if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
	413	(err==UNZ_OK))
	414	err=UNZ_BADZIPFILE;
	415
	416	if (err!=UNZ_OK)
	417	{
	418	fclose(fin);
	419	return NULL;
	420	}
	421
	422	us.file=fin;
	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;
	427
	428
	429	s=(unz_s*)ALLOC(sizeof(unz_s));
	430	*s=us;
	431	unzGoToFirstFile((unzFile)s);
	432	return (unzFile)s;
	433	}
	434
	435
	436	/*
	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)
	442	unzFile file;
	443	{
	444	unz_s* s;
	445	if (file==NULL)
	446	return UNZ_PARAMERROR;
	447	s=(unz_s*)file;
	448
	449	if (s->pfile_in_zip_read!=NULL)
	450	unzCloseCurrentFile(file);
	451
	452	fclose(s->file);
	453	TRYFREE(s);
	454	return UNZ_OK;
	455	}
	456
	457
	458	/*
	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)
	463	unzFile file;
	464	unz_global_info *pglobal_info;
	465	{
	466	unz_s* s;
	467	if (file==NULL)
	468	return UNZ_PARAMERROR;
	469	s=(unz_s*)file;
	470	*pglobal_info=s->gi;
	471	return UNZ_OK;
	472	}
	473
	474
	475	/*
	476	Translate date/time from Dos format to tm_unz (readable more easilty)
	477	*/
	478	local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
	479	uLong ulDosDate;
	480	tm_unz* ptm;
	481	{
	482	uLong uDate;
	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) ;
	487
	488	ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
	489	ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;
	490	ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;
	491	}
	492
	493	/*
	494	Get Info about the current file in the zipfile, with internal only info
	495	*/
	496	local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
	497	unz_file_info *pfile_info,
	498	unz_file_info_internal
	499	*pfile_info_internal,
	500	char *szFileName,
	501	uLong fileNameBufferSize,
	502	void *extraField,
	503	uLong extraFieldBufferSize,
	504	char *szComment,
	505	uLong commentBufferSize));
	506
	507	local int unzlocal_GetCurrentFileInfoInternal (file,
	508	pfile_info,
	509	pfile_info_internal,
	510	szFileName, fileNameBufferSize,
	511	extraField, extraFieldBufferSize,
	512	szComment, commentBufferSize)
	513	unzFile file;
	514	unz_file_info *pfile_info;
	515	unz_file_info_internal *pfile_info_internal;
	516	char *szFileName;
	517	uLong fileNameBufferSize;
	518	void *extraField;
	519	uLong extraFieldBufferSize;
	520	char *szComment;
	521	uLong commentBufferSize;
	522	{
	523	unz_s* s;
	524	unz_file_info file_info;
	525	unz_file_info_internal file_info_internal;
	526	int err=UNZ_OK;
	527	uLong uMagic;
	528	long lSeek=0;
	529
	530	if (file==NULL)
	531	return UNZ_PARAMERROR;
	532	s=(unz_s*)file;
	533	if (fseek(s->file,s->pos_in_central_dir+s->byte_before_the_zipfile,SEEK_SET)!=0)
	534	err=UNZ_ERRNO;
	535
	536
	537	/* we check the magic */
	538	if (err==UNZ_OK)
	539	if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
	540	err=UNZ_ERRNO;
	541	else if (uMagic!=0x02014b50)
	542	err=UNZ_BADZIPFILE;
	543
	544	if (unzlocal_getShort(s->file,&file_info.version) != UNZ_OK)
	545	err=UNZ_ERRNO;
	546
	547	if (unzlocal_getShort(s->file,&file_info.version_needed) != UNZ_OK)
	548	err=UNZ_ERRNO;
	549
	550	if (unzlocal_getShort(s->file,&file_info.flag) != UNZ_OK)
	551	err=UNZ_ERRNO;
	552
	553	if (unzlocal_getShort(s->file,&file_info.compression_method) != UNZ_OK)
	554	err=UNZ_ERRNO;
	555
	556	if (unzlocal_getLong(s->file,&file_info.dosDate) != UNZ_OK)
	557	err=UNZ_ERRNO;
	558
	559	unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
	560
	561	if (unzlocal_getLong(s->file,&file_info.crc) != UNZ_OK)
	562	err=UNZ_ERRNO;
	563
	564	if (unzlocal_getLong(s->file,&file_info.compressed_size) != UNZ_OK)
	565	err=UNZ_ERRNO;
	566
	567	if (unzlocal_getLong(s->file,&file_info.uncompressed_size) != UNZ_OK)
	568	err=UNZ_ERRNO;
	569
	570	if (unzlocal_getShort(s->file,&file_info.size_filename) != UNZ_OK)
	571	err=UNZ_ERRNO;
	572
	573	if (unzlocal_getShort(s->file,&file_info.size_file_extra) != UNZ_OK)
	574	err=UNZ_ERRNO;
	575
	576	if (unzlocal_getShort(s->file,&file_info.size_file_comment) != UNZ_OK)
	577	err=UNZ_ERRNO;
	578
	579	if (unzlocal_getShort(s->file,&file_info.disk_num_start) != UNZ_OK)
	580	err=UNZ_ERRNO;
	581
	582	if (unzlocal_getShort(s->file,&file_info.internal_fa) != UNZ_OK)
	583	err=UNZ_ERRNO;
	584
	585	if (unzlocal_getLong(s->file,&file_info.external_fa) != UNZ_OK)
	586	err=UNZ_ERRNO;
	587
	588	if (unzlocal_getLong(s->file,&file_info_internal.offset_curfile) != UNZ_OK)
	589	err=UNZ_ERRNO;
	590
	591	lSeek+=file_info.size_filename;
	592	if ((err==UNZ_OK) && (szFileName!=NULL))
	593	{
	594	uLong uSizeRead ;
	595	if (file_info.size_filename<fileNameBufferSize)
	596	{
	597	*(szFileName+file_info.size_filename)='\0';
	598	uSizeRead = file_info.size_filename;
	599	}
	600	else
	601	uSizeRead = fileNameBufferSize;
	602
	603	if ((file_info.size_filename>0) && (fileNameBufferSize>0))
	604	if (fread(szFileName,(uInt)uSizeRead,1,s->file)!=1)
	605	err=UNZ_ERRNO;
	606	lSeek -= uSizeRead;
	607	}
	608
	609
	610	if ((err==UNZ_OK) && (extraField!=NULL))
	611	{
	612	uLong uSizeRead ;
	613	if (file_info.size_file_extra<extraFieldBufferSize)
	614	uSizeRead = file_info.size_file_extra;
	615	else
	616	uSizeRead = extraFieldBufferSize;
	617
	618	if (lSeek!=0)
	619	if (fseek(s->file,lSeek,SEEK_CUR)==0)
	620	lSeek=0;
	621	else
	622	err=UNZ_ERRNO;
	623	if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
	624	if (fread(extraField,(uInt)uSizeRead,1,s->file)!=1)
	625	err=UNZ_ERRNO;
	626	lSeek += file_info.size_file_extra - uSizeRead;
	627	}
	628	else
	629	lSeek+=file_info.size_file_extra;
	630
	631
	632	if ((err==UNZ_OK) && (szComment!=NULL))
	633	{
	634	uLong uSizeRead ;
	635	if (file_info.size_file_comment<commentBufferSize)
	636	{
	637	*(szComment+file_info.size_file_comment)='\0';
	638	uSizeRead = file_info.size_file_comment;
	639	}
	640	else
	641	uSizeRead = commentBufferSize;
	642
	643	if (lSeek!=0)
	644	if (fseek(s->file,lSeek,SEEK_CUR)==0)
	645	lSeek=0;
	646	else
	647	err=UNZ_ERRNO;
	648	if ((file_info.size_file_comment>0) && (commentBufferSize>0))
	649	if (fread(szComment,(uInt)uSizeRead,1,s->file)!=1)
	650	err=UNZ_ERRNO;
	651	lSeek+=file_info.size_file_comment - uSizeRead;
	652	}
	653	else
	654	lSeek+=file_info.size_file_comment;
	655
	656	if ((err==UNZ_OK) && (pfile_info!=NULL))
	657	*pfile_info=file_info;
	658
	659	if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
	660	*pfile_info_internal=file_info_internal;
	661
	662	return err;
	663	}
	664
	665
	666
	667	/*
	668	Write info about the ZipFile in the *pglobal_info structure.
	669	No preparation of the structure is needed
	670	return UNZ_OK if there is no problem.
	671	*/
	672	extern int ZEXPORT unzGetCurrentFileInfo (file,
	673	pfile_info,
	674	szFileName, fileNameBufferSize,
	675	extraField, extraFieldBufferSize,
	676	szComment, commentBufferSize)
	677	unzFile file;
	678	unz_file_info *pfile_info;
	679	char *szFileName;
	680	uLong fileNameBufferSize;
	681	void *extraField;
	682	uLong extraFieldBufferSize;
	683	char *szComment;
	684	uLong commentBufferSize;
	685	{
	686	return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
	687	szFileName,fileNameBufferSize,
	688	extraField,extraFieldBufferSize,
	689	szComment,commentBufferSize);
	690	}
	691
	692	/*
	693	Set the current file of the zipfile to the first file.
	694	return UNZ_OK if there is no problem
	695	*/
	696	extern int ZEXPORT unzGoToFirstFile (file)
	697	unzFile file;
	698	{
	699	int err=UNZ_OK;
	700	unz_s* s;
	701	if (file==NULL)
	702	return UNZ_PARAMERROR;
	703	s=(unz_s*)file;
	704	s->pos_in_central_dir=s->offset_central_dir;
	705	s->num_file=0;
	706	err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
	707	&s->cur_file_info_internal,
	708	NULL,0,NULL,0,NULL,0);
	709	s->current_file_ok = (err == UNZ_OK);
	710	return err;
	711	}
	712
	713
	714	/*
	715	Set the current file of the zipfile to the next file.
	716	return UNZ_OK if there is no problem
	717	return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
	718	*/
	719	extern int ZEXPORT unzGoToNextFile (file)
	720	unzFile file;
	721	{
	722	unz_s* s;
	723	int err;
	724
	725	if (file==NULL)
	726	return UNZ_PARAMERROR;
	727	s=(unz_s*)file;
	728	if (!s->current_file_ok)
	729	return UNZ_END_OF_LIST_OF_FILE;
	730	if (s->num_file+1==s->gi.number_entry)
	731	return UNZ_END_OF_LIST_OF_FILE;
	732
	733	s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
	734	s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
	735	s->num_file++;
	736	err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
	737	&s->cur_file_info_internal,
	738	NULL,0,NULL,0,NULL,0);
	739	s->current_file_ok = (err == UNZ_OK);
	740	return err;
	741	}
	742
	743
	744	/*
	745	Try locate the file szFileName in the zipfile.
	746	For the iCaseSensitivity signification, see unzipStringFileNameCompare
	747
	748	return value :
	749	UNZ_OK if the file is found. It becomes the current file.
	750	UNZ_END_OF_LIST_OF_FILE if the file is not found
	751	*/
	752	extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
	753	unzFile file;
	754	const char *szFileName;
	755	int iCaseSensitivity;
	756	{
	757	unz_s* s;
	758	int err;
	759
	760
	761	uLong num_fileSaved;
	762	uLong pos_in_central_dirSaved;
	763
	764
	765	if (file==NULL)
	766	return UNZ_PARAMERROR;
	767
	768	if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
	769	return UNZ_PARAMERROR;
	770
	771	s=(unz_s*)file;
	772	if (!s->current_file_ok)
	773	return UNZ_END_OF_LIST_OF_FILE;
	774
	775	num_fileSaved = s->num_file;
	776	pos_in_central_dirSaved = s->pos_in_central_dir;
	777
	778	err = unzGoToFirstFile(file);
	779
	780	while (err == UNZ_OK)
	781	{
	782	char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
	783	unzGetCurrentFileInfo(file,NULL,
	784	szCurrentFileName,sizeof(szCurrentFileName)-1,
	785	NULL,0,NULL,0);
	786	if (unzStringFileNameCompare(szCurrentFileName,
	787	szFileName,iCaseSensitivity)==0)
	788	return UNZ_OK;
	789	err = unzGoToNextFile(file);
	790	}
	791
	792	s->num_file = num_fileSaved ;
	793	s->pos_in_central_dir = pos_in_central_dirSaved ;
	794	return err;
	795	}
	796
	797
	798	/*
	799	Read the local header of the current zipfile
	800	Check the coherency of the local header and info in the end of central
	801	directory about this file
	802	store in *piSizeVar the size of extra info in local header
	803	(filename and size of extra field data)
	804	*/
	805	local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
	806	poffset_local_extrafield,
	807	psize_local_extrafield)
	808	unz_s* s;
	809	uInt* piSizeVar;
	810	uLong *poffset_local_extrafield;
	811	uInt *psize_local_extrafield;
	812	{
	813	uLong uMagic,uData,uFlags;
	814	uLong size_filename;
	815	uLong size_extra_field;
	816	int err=UNZ_OK;
	817
	818	*piSizeVar = 0;
	819	*poffset_local_extrafield = 0;
	820	*psize_local_extrafield = 0;
	821
	822	if (fseek(s->file,s->cur_file_info_internal.offset_curfile +
	823	s->byte_before_the_zipfile,SEEK_SET)!=0)
	824	return UNZ_ERRNO;
	825
	826
	827	if (err==UNZ_OK)
	828	if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
	829	err=UNZ_ERRNO;
	830	else if (uMagic!=0x04034b50)
	831	err=UNZ_BADZIPFILE;
	832
	833	if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
	834	err=UNZ_ERRNO;
	835	/*
	836	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
	837	err=UNZ_BADZIPFILE;
	838	*/
	839	if (unzlocal_getShort(s->file,&uFlags) != UNZ_OK)
	840	err=UNZ_ERRNO;
	841
	842	if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
	843	err=UNZ_ERRNO;
	844	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
	845	err=UNZ_BADZIPFILE;
	846
	847	if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
	848	(s->cur_file_info.compression_method!=Z_DEFLATED))
	849	err=UNZ_BADZIPFILE;
	850
	851	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* date/time */
	852	err=UNZ_ERRNO;
	853
	854	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* crc */
	855	err=UNZ_ERRNO;
	856	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
	857	((uFlags & 8)==0))
	858	err=UNZ_BADZIPFILE;
	859
	860	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size compr */
	861	err=UNZ_ERRNO;
	862	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
	863	((uFlags & 8)==0))
	864	err=UNZ_BADZIPFILE;
	865
	866	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size uncompr */
	867	err=UNZ_ERRNO;
	868	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
	869	((uFlags & 8)==0))
	870	err=UNZ_BADZIPFILE;
	871
	872
	873	if (unzlocal_getShort(s->file,&size_filename) != UNZ_OK)
	874	err=UNZ_ERRNO;
	875	else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
	876	err=UNZ_BADZIPFILE;
	877
	878	*piSizeVar += (uInt)size_filename;
	879
	880	if (unzlocal_getShort(s->file,&size_extra_field) != UNZ_OK)
	881	err=UNZ_ERRNO;
	882	*poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
	883	SIZEZIPLOCALHEADER + size_filename;
	884	*psize_local_extrafield = (uInt)size_extra_field;
	885
	886	*piSizeVar += (uInt)size_extra_field;
	887
	888	return err;
	889	}
	890
	891	/*
	892	Open for reading data the current file in the zipfile.
	893	If there is no error and the file is opened, the return value is UNZ_OK.
	894	*/
	895	extern int ZEXPORT unzOpenCurrentFile (file)
	896	unzFile file;
	897	{
	898	int err=UNZ_OK;
	899	int Store;
	900	uInt iSizeVar;
	901	unz_s* s;
	902	file_in_zip_read_info_s* pfile_in_zip_read_info;
	903	uLong offset_local_extrafield; /* offset of the local extra field */
	904	uInt size_local_extrafield; /* size of the local extra field */
	905
	906	if (file==NULL)
	907	return UNZ_PARAMERROR;
	908	s=(unz_s*)file;
	909	if (!s->current_file_ok)
	910	return UNZ_PARAMERROR;
	911
	912	if (s->pfile_in_zip_read != NULL)
	913	unzCloseCurrentFile(file);
	914
	915	if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
	916	&offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
	917	return UNZ_BADZIPFILE;
	918
	919	pfile_in_zip_read_info = (file_in_zip_read_info_s*)
	920	ALLOC(sizeof(file_in_zip_read_info_s));
	921	if (pfile_in_zip_read_info==NULL)
	922	return UNZ_INTERNALERROR;
	923
	924	pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
	925	pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
	926	pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
	927	pfile_in_zip_read_info->pos_local_extrafield=0;
	928
	929	if (pfile_in_zip_read_info->read_buffer==NULL)
	930	{
	931	TRYFREE(pfile_in_zip_read_info);
	932	return UNZ_INTERNALERROR;
	933	}
	934
	935	pfile_in_zip_read_info->stream_initialised=0;
	936
	937	if ((s->cur_file_info.compression_method!=0) &&
	938	(s->cur_file_info.compression_method!=Z_DEFLATED))
	939	err=UNZ_BADZIPFILE;
	940	Store = s->cur_file_info.compression_method==0;
	941
	942	pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
	943	pfile_in_zip_read_info->crc32=0;
	944	pfile_in_zip_read_info->compression_method =
	945	s->cur_file_info.compression_method;
	946	pfile_in_zip_read_info->file=s->file;
	947	pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
	948
	949	pfile_in_zip_read_info->stream.total_out = 0;
	950
	951	if (!Store)
	952	{
	953	pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
	954	pfile_in_zip_read_info->stream.zfree = (free_func)0;
	955	pfile_in_zip_read_info->stream.opaque = (voidpf)0;
	956
	957	err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
	958	if (err == Z_OK)
	959	pfile_in_zip_read_info->stream_initialised=1;
	960	/* windowBits is passed < 0 to tell that there is no zlib header.
	961	* Note that in this case inflate requires an extra "dummy" byte
	962	* after the compressed stream in order to complete decompression and
	963	* return Z_STREAM_END.
	964	* In unzip, i don't wait absolutely Z_STREAM_END because I known the
	965	* size of both compressed and uncompressed data
	966	*/
	967	}
	968	pfile_in_zip_read_info->rest_read_compressed =
	969	s->cur_file_info.compressed_size ;
	970	pfile_in_zip_read_info->rest_read_uncompressed =
	971	s->cur_file_info.uncompressed_size ;
	972
	973
	974	pfile_in_zip_read_info->pos_in_zipfile =
	975	s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
	976	iSizeVar;
	977
	978	pfile_in_zip_read_info->stream.avail_in = (uInt)0;
	979
	980
	981	s->pfile_in_zip_read = pfile_in_zip_read_info;
	982	return UNZ_OK;
	983	}
	984
	985
	986	/*
	987	Read bytes from the current file.
	988	buf contain buffer where data must be copied
	989	len the size of buf.
	990
	991	return the number of byte copied if somes bytes are copied
	992	return 0 if the end of file was reached
	993	return <0 with error code if there is an error
	994	(UNZ_ERRNO for IO error, or zLib error for uncompress error)
	995	*/
	996	extern int ZEXPORT unzReadCurrentFile (file, buf, len)
	997	unzFile file;
	998	voidp buf;
	999	unsigned len;
	1000	{
	1001	int err=UNZ_OK;
	1002	uInt iRead = 0;
	1003	unz_s* s;
	1004	file_in_zip_read_info_s* pfile_in_zip_read_info;
	1005	if (file==NULL)
	1006	return UNZ_PARAMERROR;
	1007	s=(unz_s*)file;
	1008	pfile_in_zip_read_info=s->pfile_in_zip_read;
	1009
	1010	if (pfile_in_zip_read_info==NULL)
	1011	return UNZ_PARAMERROR;
	1012
	1013
	1014	if ((pfile_in_zip_read_info->read_buffer == NULL))
	1015	return UNZ_END_OF_LIST_OF_FILE;
	1016	if (len==0)
	1017	return 0;
	1018
	1019	pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
	1020
	1021	pfile_in_zip_read_info->stream.avail_out = (uInt)len;
	1022
	1023	if (len>pfile_in_zip_read_info->rest_read_uncompressed)
	1024	pfile_in_zip_read_info->stream.avail_out =
	1025	(uInt)pfile_in_zip_read_info->rest_read_uncompressed;
	1026
	1027	while (pfile_in_zip_read_info->stream.avail_out>0)
	1028	{
	1029	if ((pfile_in_zip_read_info->stream.avail_in==0) &&
	1030	(pfile_in_zip_read_info->rest_read_compressed>0))
	1031	{
	1032	uInt uReadThis = UNZ_BUFSIZE;
	1033	if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
	1034	uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
	1035	if (uReadThis == 0)
	1036	return UNZ_EOF;
	1037	if (fseek(pfile_in_zip_read_info->file,
	1038	pfile_in_zip_read_info->pos_in_zipfile +
	1039	pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET)!=0)
	1040	return UNZ_ERRNO;
	1041	if (fread(pfile_in_zip_read_info->read_buffer,uReadThis,1,
	1042	pfile_in_zip_read_info->file)!=1)
	1043	return UNZ_ERRNO;
	1044	pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
	1045
	1046	pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
	1047
	1048	pfile_in_zip_read_info->stream.next_in =
	1049	(Bytef*)pfile_in_zip_read_info->read_buffer;
	1050	pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
	1051	}
	1052
	1053	if (pfile_in_zip_read_info->compression_method==0)
	1054	{
	1055	uInt uDoCopy,i ;
	1056	if (pfile_in_zip_read_info->stream.avail_out <
	1057	pfile_in_zip_read_info->stream.avail_in)
	1058	uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
	1059	else
	1060	uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
	1061
	1062	for (i=0;i<uDoCopy;i++)
	1063	*(pfile_in_zip_read_info->stream.next_out+i) =
	1064	*(pfile_in_zip_read_info->stream.next_in+i);
	1065
	1066	pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
	1067	pfile_in_zip_read_info->stream.next_out,
	1068	uDoCopy);
	1069	pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
	1070	pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
	1071	pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
	1072	pfile_in_zip_read_info->stream.next_out += uDoCopy;
	1073	pfile_in_zip_read_info->stream.next_in += uDoCopy;
	1074	pfile_in_zip_read_info->stream.total_out += uDoCopy;
	1075	iRead += uDoCopy;
	1076	}
	1077	else
	1078	{
	1079	uLong uTotalOutBefore,uTotalOutAfter;
	1080	const Bytef *bufBefore;
	1081	uLong uOutThis;
	1082	int flush=Z_SYNC_FLUSH;
	1083
	1084	uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
	1085	bufBefore = pfile_in_zip_read_info->stream.next_out;
	1086
	1087	/*
	1088	if ((pfile_in_zip_read_info->rest_read_uncompressed ==
	1089	pfile_in_zip_read_info->stream.avail_out) &&
	1090	(pfile_in_zip_read_info->rest_read_compressed == 0))
	1091	flush = Z_FINISH;
	1092	*/
	1093	err=inflate(&pfile_in_zip_read_info->stream,flush);
	1094
	1095	uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
	1096	uOutThis = uTotalOutAfter-uTotalOutBefore;
	1097
	1098	pfile_in_zip_read_info->crc32 =
	1099	crc32(pfile_in_zip_read_info->crc32,bufBefore,
	1100	(uInt)(uOutThis));
	1101
	1102	pfile_in_zip_read_info->rest_read_uncompressed -=
	1103	uOutThis;
	1104
	1105	iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
	1106
	1107	if (err==Z_STREAM_END)
	1108	return (iRead==0) ? UNZ_EOF : iRead;
	1109	if (err!=Z_OK)
	1110	break;
	1111	}
	1112	}
	1113
	1114	if (err==Z_OK)
	1115	return iRead;
	1116	return err;
	1117	}
	1118
	1119
	1120	/*
	1121	Give the current position in uncompressed data
	1122	*/
	1123	extern z_off_t ZEXPORT unztell (file)
	1124	unzFile file;
	1125	{
	1126	unz_s* s;
	1127	file_in_zip_read_info_s* pfile_in_zip_read_info;
	1128	if (file==NULL)
	1129	return UNZ_PARAMERROR;
	1130	s=(unz_s*)file;
	1131	pfile_in_zip_read_info=s->pfile_in_zip_read;
	1132
	1133	if (pfile_in_zip_read_info==NULL)
	1134	return UNZ_PARAMERROR;
	1135
	1136	return (z_off_t)pfile_in_zip_read_info->stream.total_out;
	1137	}
	1138
	1139
	1140	/*
	1141	return 1 if the end of file was reached, 0 elsewhere
	1142	*/
	1143	extern int ZEXPORT unzeof (file)
	1144	unzFile file;
	1145	{
	1146	unz_s* s;
	1147	file_in_zip_read_info_s* pfile_in_zip_read_info;
	1148	if (file==NULL)
	1149	return UNZ_PARAMERROR;
	1150	s=(unz_s*)file;
	1151	pfile_in_zip_read_info=s->pfile_in_zip_read;
	1152
	1153	if (pfile_in_zip_read_info==NULL)
	1154	return UNZ_PARAMERROR;
	1155
	1156	if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
	1157	return 1;
	1158	else
	1159	return 0;
	1160	}
	1161
	1162
	1163
	1164	/*
	1165	Read extra field from the current file (opened by unzOpenCurrentFile)
	1166	This is the local-header version of the extra field (sometimes, there is
	1167	more info in the local-header version than in the central-header)
	1168
	1169	if buf==NULL, it return the size of the local extra field that can be read
	1170
	1171	if buf!=NULL, len is the size of the buffer, the extra header is copied in
	1172	buf.
	1173	the return value is the number of bytes copied in buf, or (if <0)
	1174	the error code
	1175	*/
	1176	extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
	1177	unzFile file;
	1178	voidp buf;
	1179	unsigned len;
	1180	{
	1181	unz_s* s;
	1182	file_in_zip_read_info_s* pfile_in_zip_read_info;
	1183	uInt read_now;
	1184	uLong size_to_read;
	1185
	1186	if (file==NULL)
	1187	return UNZ_PARAMERROR;
	1188	s=(unz_s*)file;
	1189	pfile_in_zip_read_info=s->pfile_in_zip_read;
	1190
	1191	if (pfile_in_zip_read_info==NULL)
	1192	return UNZ_PARAMERROR;
	1193
	1194	size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
	1195	pfile_in_zip_read_info->pos_local_extrafield);
	1196
	1197	if (buf==NULL)
	1198	return (int)size_to_read;
	1199
	1200	if (len>size_to_read)
	1201	read_now = (uInt)size_to_read;
	1202	else
	1203	read_now = (uInt)len ;
	1204
	1205	if (read_now==0)
	1206	return 0;
	1207
	1208	if (fseek(pfile_in_zip_read_info->file,
	1209	pfile_in_zip_read_info->offset_local_extrafield +
	1210	pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0)
	1211	return UNZ_ERRNO;
	1212
	1213	if (fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1)
	1214	return UNZ_ERRNO;
	1215
	1216	return (int)read_now;
	1217	}
	1218
	1219	/*
	1220	Close the file in zip opened with unzipOpenCurrentFile
	1221	Return UNZ_CRCERROR if all the file was read but the CRC is not good
	1222	*/
	1223	extern int ZEXPORT unzCloseCurrentFile (file)
	1224	unzFile file;
	1225	{
	1226	int err=UNZ_OK;
	1227
	1228	unz_s* s;
	1229	file_in_zip_read_info_s* pfile_in_zip_read_info;
	1230	if (file==NULL)
	1231	return UNZ_PARAMERROR;
	1232	s=(unz_s*)file;
	1233	pfile_in_zip_read_info=s->pfile_in_zip_read;
	1234
	1235	if (pfile_in_zip_read_info==NULL)
	1236	return UNZ_PARAMERROR;
	1237
	1238
	1239	if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
	1240	{
	1241	if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
	1242	err=UNZ_CRCERROR;
	1243	}
	1244
	1245
	1246	TRYFREE(pfile_in_zip_read_info->read_buffer);
	1247	pfile_in_zip_read_info->read_buffer = NULL;
	1248	if (pfile_in_zip_read_info->stream_initialised)
	1249	inflateEnd(&pfile_in_zip_read_info->stream);
	1250
	1251	pfile_in_zip_read_info->stream_initialised = 0;
	1252	TRYFREE(pfile_in_zip_read_info);
	1253
	1254	s->pfile_in_zip_read=NULL;
	1255
	1256	return err;
	1257	}
	1258
	1259
	1260	/*
	1261	Get the global comment string of the ZipFile, in the szComment buffer.
	1262	uSizeBuf is the size of the szComment buffer.
	1263	return the number of byte copied or an error code <0
	1264	*/
	1265	extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
	1266	unzFile file;
	1267	char *szComment;
	1268	uLong uSizeBuf;
	1269	{
	1270	int err=UNZ_OK;
	1271	unz_s* s;
	1272	uLong uReadThis ;
	1273	if (file==NULL)
	1274	return UNZ_PARAMERROR;
	1275	s=(unz_s*)file;
	1276
	1277	uReadThis = uSizeBuf;
	1278	if (uReadThis>s->gi.size_comment)
	1279	uReadThis = s->gi.size_comment;
	1280
	1281	if (fseek(s->file,s->central_pos+22,SEEK_SET)!=0)
	1282	return UNZ_ERRNO;
	1283
	1284	if (uReadThis>0)
	1285	{
	1286	*szComment='\0';
	1287	if (fread(szComment,(uInt)uReadThis,1,s->file)!=1)
	1288	return UNZ_ERRNO;
	1289	}
	1290
	1291	if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
	1292	*(szComment+s->gi.size_comment)='\0';
	1293	return (int)uReadThis;
	1294	}

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

Context Navigation

source: trunk/third/zlib/contrib/minizip/unzip.c @ 15211

Download in other formats: